2022-02-10 23:07:11 +01:00
|
|
|
/* SPDX-License-Identifier: GPL-2.0-or-later
|
|
|
|
* Copyright 2018 Blender Foundation. All rights reserved. */
|
2018-07-18 17:34:44 +02:00
|
|
|
|
2019-02-17 22:08:12 +01:00
|
|
|
/** \file
|
|
|
|
* \ingroup bke
|
2018-09-04 15:22:36 +02:00
|
|
|
*/
|
|
|
|
|
Subsurf: Begin new subdivision surface module
The idea is to use this as a replacement of old CCG, now it is
based on OpenSubdiv. The goal is to reduce any possible overhead
which was happening with OpenSubdiv used by CCG.
Currently implemented/supported:
- Creation from mesh, including topology on OpenSubdiv side,
its refinement.
- Evaluation of limit point, first order derivatives, normal,
and face-varying data for individual coarse position.
- Evaluation of whole patches.
Currently not optimized, uses evaluation of individual coarse
positions.
- Creation of Mesh from subdiv, with all geometry being real:
all mvert, medge, mloop, and mpoly.
This includes custom data interpolation, but all faces currently
are getting separated (they are converted to ptex patches, which
we need to weld back together).
Still need to support lighter weights grids and such, but this
is already a required part to have subsurf working in the middle
of modifier stack.
Annoying part is ifdef all over the place, to keep it compilable
when OpenSubdiv is disabled. More cleaner approach would be to
have stub API for OpenSubdiv, so everything gets ifdef-ed in a
much fewer places.
2018-07-17 18:07:26 +02:00
|
|
|
#pragma once
|
|
|
|
|
2018-11-01 11:06:00 +01:00
|
|
|
#include "BLI_compiler_compat.h"
|
Subsurf: Begin new subdivision surface module
The idea is to use this as a replacement of old CCG, now it is
based on OpenSubdiv. The goal is to reduce any possible overhead
which was happening with OpenSubdiv used by CCG.
Currently implemented/supported:
- Creation from mesh, including topology on OpenSubdiv side,
its refinement.
- Evaluation of limit point, first order derivatives, normal,
and face-varying data for individual coarse position.
- Evaluation of whole patches.
Currently not optimized, uses evaluation of individual coarse
positions.
- Creation of Mesh from subdiv, with all geometry being real:
all mvert, medge, mloop, and mpoly.
This includes custom data interpolation, but all faces currently
are getting separated (they are converted to ptex patches, which
we need to weld back together).
Still need to support lighter weights grids and such, but this
is already a required part to have subsurf working in the middle
of modifier stack.
Annoying part is ifdef all over the place, to keep it compilable
when OpenSubdiv is disabled. More cleaner approach would be to
have stub API for OpenSubdiv, so everything gets ifdef-ed in a
much fewer places.
2018-07-17 18:07:26 +02:00
|
|
|
#include "BLI_sys_types.h"
|
|
|
|
|
2020-03-02 15:07:49 +01:00
|
|
|
#ifdef __cplusplus
|
|
|
|
extern "C" {
|
|
|
|
#endif
|
|
|
|
|
Subsurf: Begin new subdivision surface module
The idea is to use this as a replacement of old CCG, now it is
based on OpenSubdiv. The goal is to reduce any possible overhead
which was happening with OpenSubdiv used by CCG.
Currently implemented/supported:
- Creation from mesh, including topology on OpenSubdiv side,
its refinement.
- Evaluation of limit point, first order derivatives, normal,
and face-varying data for individual coarse position.
- Evaluation of whole patches.
Currently not optimized, uses evaluation of individual coarse
positions.
- Creation of Mesh from subdiv, with all geometry being real:
all mvert, medge, mloop, and mpoly.
This includes custom data interpolation, but all faces currently
are getting separated (they are converted to ptex patches, which
we need to weld back together).
Still need to support lighter weights grids and such, but this
is already a required part to have subsurf working in the middle
of modifier stack.
Annoying part is ifdef all over the place, to keep it compilable
when OpenSubdiv is disabled. More cleaner approach would be to
have stub API for OpenSubdiv, so everything gets ifdef-ed in a
much fewer places.
2018-07-17 18:07:26 +02:00
|
|
|
struct Mesh;
|
2018-08-14 17:05:54 +02:00
|
|
|
struct MultiresModifierData;
|
Subsurf: Begin new subdivision surface module
The idea is to use this as a replacement of old CCG, now it is
based on OpenSubdiv. The goal is to reduce any possible overhead
which was happening with OpenSubdiv used by CCG.
Currently implemented/supported:
- Creation from mesh, including topology on OpenSubdiv side,
its refinement.
- Evaluation of limit point, first order derivatives, normal,
and face-varying data for individual coarse position.
- Evaluation of whole patches.
Currently not optimized, uses evaluation of individual coarse
positions.
- Creation of Mesh from subdiv, with all geometry being real:
all mvert, medge, mloop, and mpoly.
This includes custom data interpolation, but all faces currently
are getting separated (they are converted to ptex patches, which
we need to weld back together).
Still need to support lighter weights grids and such, but this
is already a required part to have subsurf working in the middle
of modifier stack.
Annoying part is ifdef all over the place, to keep it compilable
when OpenSubdiv is disabled. More cleaner approach would be to
have stub API for OpenSubdiv, so everything gets ifdef-ed in a
much fewer places.
2018-07-17 18:07:26 +02:00
|
|
|
struct OpenSubdiv_Converter;
|
|
|
|
struct OpenSubdiv_Evaluator;
|
|
|
|
struct OpenSubdiv_TopologyRefiner;
|
2018-08-14 17:05:54 +02:00
|
|
|
struct Subdiv;
|
Subsurf: Begin new subdivision surface module
The idea is to use this as a replacement of old CCG, now it is
based on OpenSubdiv. The goal is to reduce any possible overhead
which was happening with OpenSubdiv used by CCG.
Currently implemented/supported:
- Creation from mesh, including topology on OpenSubdiv side,
its refinement.
- Evaluation of limit point, first order derivatives, normal,
and face-varying data for individual coarse position.
- Evaluation of whole patches.
Currently not optimized, uses evaluation of individual coarse
positions.
- Creation of Mesh from subdiv, with all geometry being real:
all mvert, medge, mloop, and mpoly.
This includes custom data interpolation, but all faces currently
are getting separated (they are converted to ptex patches, which
we need to weld back together).
Still need to support lighter weights grids and such, but this
is already a required part to have subsurf working in the middle
of modifier stack.
Annoying part is ifdef all over the place, to keep it compilable
when OpenSubdiv is disabled. More cleaner approach would be to
have stub API for OpenSubdiv, so everything gets ifdef-ed in a
much fewer places.
2018-07-17 18:07:26 +02:00
|
|
|
|
2018-10-31 17:46:22 +01:00
|
|
|
typedef enum eSubdivVtxBoundaryInterpolation {
|
|
|
|
/* Do not interpolate boundaries. */
|
|
|
|
SUBDIV_VTX_BOUNDARY_NONE,
|
|
|
|
/* Sharpen edges. */
|
|
|
|
SUBDIV_VTX_BOUNDARY_EDGE_ONLY,
|
|
|
|
/* sharpen edges and corners, */
|
|
|
|
SUBDIV_VTX_BOUNDARY_EDGE_AND_CORNER,
|
|
|
|
} eSubdivVtxBoundaryInterpolation;
|
|
|
|
|
|
|
|
typedef enum eSubdivFVarLinearInterpolation {
|
Subsurf: Begin new subdivision surface module
The idea is to use this as a replacement of old CCG, now it is
based on OpenSubdiv. The goal is to reduce any possible overhead
which was happening with OpenSubdiv used by CCG.
Currently implemented/supported:
- Creation from mesh, including topology on OpenSubdiv side,
its refinement.
- Evaluation of limit point, first order derivatives, normal,
and face-varying data for individual coarse position.
- Evaluation of whole patches.
Currently not optimized, uses evaluation of individual coarse
positions.
- Creation of Mesh from subdiv, with all geometry being real:
all mvert, medge, mloop, and mpoly.
This includes custom data interpolation, but all faces currently
are getting separated (they are converted to ptex patches, which
we need to weld back together).
Still need to support lighter weights grids and such, but this
is already a required part to have subsurf working in the middle
of modifier stack.
Annoying part is ifdef all over the place, to keep it compilable
when OpenSubdiv is disabled. More cleaner approach would be to
have stub API for OpenSubdiv, so everything gets ifdef-ed in a
much fewer places.
2018-07-17 18:07:26 +02:00
|
|
|
SUBDIV_FVAR_LINEAR_INTERPOLATION_NONE,
|
|
|
|
SUBDIV_FVAR_LINEAR_INTERPOLATION_CORNERS_ONLY,
|
2018-08-02 13:36:22 +02:00
|
|
|
SUBDIV_FVAR_LINEAR_INTERPOLATION_CORNERS_AND_JUNCTIONS,
|
|
|
|
SUBDIV_FVAR_LINEAR_INTERPOLATION_CORNERS_JUNCTIONS_AND_CONCAVE,
|
Subsurf: Begin new subdivision surface module
The idea is to use this as a replacement of old CCG, now it is
based on OpenSubdiv. The goal is to reduce any possible overhead
which was happening with OpenSubdiv used by CCG.
Currently implemented/supported:
- Creation from mesh, including topology on OpenSubdiv side,
its refinement.
- Evaluation of limit point, first order derivatives, normal,
and face-varying data for individual coarse position.
- Evaluation of whole patches.
Currently not optimized, uses evaluation of individual coarse
positions.
- Creation of Mesh from subdiv, with all geometry being real:
all mvert, medge, mloop, and mpoly.
This includes custom data interpolation, but all faces currently
are getting separated (they are converted to ptex patches, which
we need to weld back together).
Still need to support lighter weights grids and such, but this
is already a required part to have subsurf working in the middle
of modifier stack.
Annoying part is ifdef all over the place, to keep it compilable
when OpenSubdiv is disabled. More cleaner approach would be to
have stub API for OpenSubdiv, so everything gets ifdef-ed in a
much fewer places.
2018-07-17 18:07:26 +02:00
|
|
|
SUBDIV_FVAR_LINEAR_INTERPOLATION_BOUNDARIES,
|
|
|
|
SUBDIV_FVAR_LINEAR_INTERPOLATION_ALL,
|
|
|
|
} eSubdivFVarLinearInterpolation;
|
|
|
|
|
|
|
|
typedef struct SubdivSettings {
|
2021-09-25 09:15:25 +02:00
|
|
|
/* Simple subdivision corresponds to "Simple" option in the interface. When it's enabled the
|
2020-02-18 17:23:52 +01:00
|
|
|
* subdivided mesh is not "smoothed": new vertices are added uniformly on the existing surface.
|
|
|
|
*
|
|
|
|
* On an OpenSubdiv implementation level this translates to a subdivision scheme:
|
|
|
|
* when is_simple is true OSD_SCHEME_BILINEAR is used, otherwise OSD_SCHEME_CATMARK. */
|
Subsurf: Begin new subdivision surface module
The idea is to use this as a replacement of old CCG, now it is
based on OpenSubdiv. The goal is to reduce any possible overhead
which was happening with OpenSubdiv used by CCG.
Currently implemented/supported:
- Creation from mesh, including topology on OpenSubdiv side,
its refinement.
- Evaluation of limit point, first order derivatives, normal,
and face-varying data for individual coarse position.
- Evaluation of whole patches.
Currently not optimized, uses evaluation of individual coarse
positions.
- Creation of Mesh from subdiv, with all geometry being real:
all mvert, medge, mloop, and mpoly.
This includes custom data interpolation, but all faces currently
are getting separated (they are converted to ptex patches, which
we need to weld back together).
Still need to support lighter weights grids and such, but this
is already a required part to have subsurf working in the middle
of modifier stack.
Annoying part is ifdef all over the place, to keep it compilable
when OpenSubdiv is disabled. More cleaner approach would be to
have stub API for OpenSubdiv, so everything gets ifdef-ed in a
much fewer places.
2018-07-17 18:07:26 +02:00
|
|
|
bool is_simple;
|
2020-02-18 17:23:52 +01:00
|
|
|
|
|
|
|
/* This refers to an adaptive isolation when creating patches for the subdivided surface.
|
|
|
|
*
|
2020-03-29 07:33:51 +02:00
|
|
|
* When is set to false (aka uniform subdivision) fixed depth of isolation is used, which
|
2020-02-18 17:23:52 +01:00
|
|
|
* allows to iteratively add more subdivisions (uniform subdivision level 2 = uniform subdivision
|
|
|
|
* level 1 + uniform subdivision level 1). Uniform subdivisions will progressively go to a limit
|
|
|
|
* surface.
|
|
|
|
*
|
|
|
|
* Adaptive isolation generates patches at a limit surface (aka as if infinite number of uniform
|
|
|
|
* subdivisions have been applied). This setting allows to have matches normal and tangent space
|
|
|
|
* the same independent of number of subdivisions set in modifier settings. */
|
Subsurf: Begin new subdivision surface module
The idea is to use this as a replacement of old CCG, now it is
based on OpenSubdiv. The goal is to reduce any possible overhead
which was happening with OpenSubdiv used by CCG.
Currently implemented/supported:
- Creation from mesh, including topology on OpenSubdiv side,
its refinement.
- Evaluation of limit point, first order derivatives, normal,
and face-varying data for individual coarse position.
- Evaluation of whole patches.
Currently not optimized, uses evaluation of individual coarse
positions.
- Creation of Mesh from subdiv, with all geometry being real:
all mvert, medge, mloop, and mpoly.
This includes custom data interpolation, but all faces currently
are getting separated (they are converted to ptex patches, which
we need to weld back together).
Still need to support lighter weights grids and such, but this
is already a required part to have subsurf working in the middle
of modifier stack.
Annoying part is ifdef all over the place, to keep it compilable
when OpenSubdiv is disabled. More cleaner approach would be to
have stub API for OpenSubdiv, so everything gets ifdef-ed in a
much fewer places.
2018-07-17 18:07:26 +02:00
|
|
|
bool is_adaptive;
|
2020-02-18 17:23:52 +01:00
|
|
|
|
|
|
|
/* Corresponds to Quality option in modifier settings: higher values means the final surface
|
|
|
|
* will be more accurately represented by patches.
|
|
|
|
*
|
|
|
|
* On an OpenSubdiv implementation level this is an isolation level. */
|
Subsurf: Begin new subdivision surface module
The idea is to use this as a replacement of old CCG, now it is
based on OpenSubdiv. The goal is to reduce any possible overhead
which was happening with OpenSubdiv used by CCG.
Currently implemented/supported:
- Creation from mesh, including topology on OpenSubdiv side,
its refinement.
- Evaluation of limit point, first order derivatives, normal,
and face-varying data for individual coarse position.
- Evaluation of whole patches.
Currently not optimized, uses evaluation of individual coarse
positions.
- Creation of Mesh from subdiv, with all geometry being real:
all mvert, medge, mloop, and mpoly.
This includes custom data interpolation, but all faces currently
are getting separated (they are converted to ptex patches, which
we need to weld back together).
Still need to support lighter weights grids and such, but this
is already a required part to have subsurf working in the middle
of modifier stack.
Annoying part is ifdef all over the place, to keep it compilable
when OpenSubdiv is disabled. More cleaner approach would be to
have stub API for OpenSubdiv, so everything gets ifdef-ed in a
much fewer places.
2018-07-17 18:07:26 +02:00
|
|
|
int level;
|
2020-02-18 17:23:52 +01:00
|
|
|
|
2019-04-05 14:13:05 +02:00
|
|
|
bool use_creases;
|
2020-02-18 17:23:52 +01:00
|
|
|
|
2018-10-31 17:46:22 +01:00
|
|
|
eSubdivVtxBoundaryInterpolation vtx_boundary_interpolation;
|
Subsurf: Begin new subdivision surface module
The idea is to use this as a replacement of old CCG, now it is
based on OpenSubdiv. The goal is to reduce any possible overhead
which was happening with OpenSubdiv used by CCG.
Currently implemented/supported:
- Creation from mesh, including topology on OpenSubdiv side,
its refinement.
- Evaluation of limit point, first order derivatives, normal,
and face-varying data for individual coarse position.
- Evaluation of whole patches.
Currently not optimized, uses evaluation of individual coarse
positions.
- Creation of Mesh from subdiv, with all geometry being real:
all mvert, medge, mloop, and mpoly.
This includes custom data interpolation, but all faces currently
are getting separated (they are converted to ptex patches, which
we need to weld back together).
Still need to support lighter weights grids and such, but this
is already a required part to have subsurf working in the middle
of modifier stack.
Annoying part is ifdef all over the place, to keep it compilable
when OpenSubdiv is disabled. More cleaner approach would be to
have stub API for OpenSubdiv, so everything gets ifdef-ed in a
much fewer places.
2018-07-17 18:07:26 +02:00
|
|
|
eSubdivFVarLinearInterpolation fvar_linear_interpolation;
|
|
|
|
} SubdivSettings;
|
|
|
|
|
2018-07-19 16:27:18 +02:00
|
|
|
/* NOTE: Order of enumerators MUST match order of values in SubdivStats. */
|
|
|
|
typedef enum eSubdivStatsValue {
|
|
|
|
SUBDIV_STATS_TOPOLOGY_REFINER_CREATION_TIME = 0,
|
|
|
|
SUBDIV_STATS_SUBDIV_TO_MESH,
|
2018-07-25 16:51:48 +02:00
|
|
|
SUBDIV_STATS_SUBDIV_TO_MESH_GEOMETRY,
|
2018-07-19 16:27:18 +02:00
|
|
|
SUBDIV_STATS_EVALUATOR_CREATE,
|
|
|
|
SUBDIV_STATS_EVALUATOR_REFINE,
|
2018-09-06 17:06:17 +02:00
|
|
|
SUBDIV_STATS_SUBDIV_TO_CCG,
|
|
|
|
SUBDIV_STATS_SUBDIV_TO_CCG_ELEMENTS,
|
2019-01-15 15:34:11 +01:00
|
|
|
SUBDIV_STATS_TOPOLOGY_COMPARE,
|
2019-04-17 06:17:24 +02:00
|
|
|
|
2018-07-19 16:27:18 +02:00
|
|
|
NUM_SUBDIV_STATS_VALUES,
|
|
|
|
} eSubdivStatsValue;
|
|
|
|
|
|
|
|
typedef struct SubdivStats {
|
|
|
|
union {
|
|
|
|
struct {
|
|
|
|
/* Time spend on creating topology refiner, which includes time
|
|
|
|
* spend on conversion from Blender data to OpenSubdiv data, and
|
2019-01-04 15:57:44 +01:00
|
|
|
* time spend on topology orientation on OpenSubdiv C-API side. */
|
2018-07-19 16:27:18 +02:00
|
|
|
double topology_refiner_creation_time;
|
|
|
|
/* Total time spent in BKE_subdiv_to_mesh(). */
|
|
|
|
double subdiv_to_mesh_time;
|
2018-07-25 16:51:48 +02:00
|
|
|
/* Geometry (MVert and co) creation time during SUBDIV_TYO_MESH. */
|
|
|
|
double subdiv_to_mesh_geometry_time;
|
2018-07-19 16:27:18 +02:00
|
|
|
/* Time spent on evaluator creation from topology refiner. */
|
|
|
|
double evaluator_creation_time;
|
|
|
|
/* Time spent on evaluator->refine(). */
|
|
|
|
double evaluator_refine_time;
|
2018-09-06 17:06:17 +02:00
|
|
|
/* Total time spent on whole CCG creation. */
|
|
|
|
double subdiv_to_ccg_time;
|
|
|
|
/* Time spent on CCG elements evaluation/initialization. */
|
|
|
|
double subdiv_to_ccg_elements_time;
|
2019-01-15 15:34:11 +01:00
|
|
|
/* Time spent on CCG elements evaluation/initialization. */
|
|
|
|
double topology_compare_time;
|
2018-07-19 16:27:18 +02:00
|
|
|
};
|
|
|
|
double values_[NUM_SUBDIV_STATS_VALUES];
|
|
|
|
};
|
2019-04-17 06:17:24 +02:00
|
|
|
|
2018-07-19 16:27:18 +02:00
|
|
|
/* Per-value timestamp on when corresponding BKE_subdiv_stats_begin() was
|
2019-01-04 15:57:44 +01:00
|
|
|
* called. */
|
2018-07-19 16:27:18 +02:00
|
|
|
double begin_timestamp_[NUM_SUBDIV_STATS_VALUES];
|
|
|
|
} SubdivStats;
|
|
|
|
|
2019-06-17 04:51:53 +02:00
|
|
|
/* Functor which evaluates displacement at a given (u, v) of given ptex face. */
|
2018-08-14 17:05:54 +02:00
|
|
|
typedef struct SubdivDisplacement {
|
2019-01-04 15:57:44 +01:00
|
|
|
/* Initialize displacement evaluator.
|
|
|
|
*
|
|
|
|
* Is called right before evaluation is actually needed. This allows to do
|
|
|
|
* some lazy initialization, like allocate evaluator from a main thread but
|
|
|
|
* then do actual evaluation from background job. */
|
|
|
|
void (*initialize)(struct SubdivDisplacement *displacement);
|
2019-04-17 06:17:24 +02:00
|
|
|
|
2018-08-14 17:05:54 +02:00
|
|
|
/* Return displacement which is to be added to the original coordinate.
|
|
|
|
*
|
|
|
|
* NOTE: This function is supposed to return "continuous" displacement for
|
|
|
|
* each pf PTex faces created for special (non-quad) polygon. This means,
|
|
|
|
* if displacement is stored on per-corner manner (like MDisps for multires)
|
|
|
|
* this is up the displacement implementation to average boundaries of the
|
|
|
|
* displacement grids if needed.
|
|
|
|
*
|
|
|
|
* Averaging of displacement for vertices created for over coarse vertices
|
2019-01-04 15:57:44 +01:00
|
|
|
* and edges is done by subdiv code. */
|
2018-08-14 17:05:54 +02:00
|
|
|
void (*eval_displacement)(struct SubdivDisplacement *displacement,
|
2022-01-07 01:38:08 +01:00
|
|
|
int ptex_face_index,
|
|
|
|
float u,
|
|
|
|
float v,
|
2018-08-14 17:05:54 +02:00
|
|
|
const float dPdu[3],
|
|
|
|
const float dPdv[3],
|
|
|
|
float r_D[3]);
|
2019-04-17 06:17:24 +02:00
|
|
|
|
2018-08-14 17:05:54 +02:00
|
|
|
/* Free the data, not the evaluator itself. */
|
|
|
|
void (*free)(struct SubdivDisplacement *displacement);
|
2019-04-17 06:17:24 +02:00
|
|
|
|
2018-08-14 17:05:54 +02:00
|
|
|
void *user_data;
|
|
|
|
} SubdivDisplacement;
|
|
|
|
|
2018-09-04 15:17:33 +02:00
|
|
|
/* This structure contains everything needed to construct subdivided surface.
|
|
|
|
* It does not specify storage, memory layout or anything else.
|
2019-09-30 09:06:28 +02:00
|
|
|
* It is possible to create different storage's (like, grid based CPU side
|
2018-09-04 15:17:33 +02:00
|
|
|
* buffers, GPU subdivision mesh, CPU side fully qualified mesh) from the same
|
2019-01-04 15:57:44 +01:00
|
|
|
* Subdiv structure. */
|
Subsurf: Begin new subdivision surface module
The idea is to use this as a replacement of old CCG, now it is
based on OpenSubdiv. The goal is to reduce any possible overhead
which was happening with OpenSubdiv used by CCG.
Currently implemented/supported:
- Creation from mesh, including topology on OpenSubdiv side,
its refinement.
- Evaluation of limit point, first order derivatives, normal,
and face-varying data for individual coarse position.
- Evaluation of whole patches.
Currently not optimized, uses evaluation of individual coarse
positions.
- Creation of Mesh from subdiv, with all geometry being real:
all mvert, medge, mloop, and mpoly.
This includes custom data interpolation, but all faces currently
are getting separated (they are converted to ptex patches, which
we need to weld back together).
Still need to support lighter weights grids and such, but this
is already a required part to have subsurf working in the middle
of modifier stack.
Annoying part is ifdef all over the place, to keep it compilable
when OpenSubdiv is disabled. More cleaner approach would be to
have stub API for OpenSubdiv, so everything gets ifdef-ed in a
much fewer places.
2018-07-17 18:07:26 +02:00
|
|
|
typedef struct Subdiv {
|
|
|
|
/* Settings this subdivision surface is created for.
|
|
|
|
*
|
2019-02-22 16:56:54 +01:00
|
|
|
* It is read-only after assignment in BKE_subdiv_new_from_FOO(). */
|
Subsurf: Begin new subdivision surface module
The idea is to use this as a replacement of old CCG, now it is
based on OpenSubdiv. The goal is to reduce any possible overhead
which was happening with OpenSubdiv used by CCG.
Currently implemented/supported:
- Creation from mesh, including topology on OpenSubdiv side,
its refinement.
- Evaluation of limit point, first order derivatives, normal,
and face-varying data for individual coarse position.
- Evaluation of whole patches.
Currently not optimized, uses evaluation of individual coarse
positions.
- Creation of Mesh from subdiv, with all geometry being real:
all mvert, medge, mloop, and mpoly.
This includes custom data interpolation, but all faces currently
are getting separated (they are converted to ptex patches, which
we need to weld back together).
Still need to support lighter weights grids and such, but this
is already a required part to have subsurf working in the middle
of modifier stack.
Annoying part is ifdef all over the place, to keep it compilable
when OpenSubdiv is disabled. More cleaner approach would be to
have stub API for OpenSubdiv, so everything gets ifdef-ed in a
much fewer places.
2018-07-17 18:07:26 +02:00
|
|
|
SubdivSettings settings;
|
|
|
|
/* Topology refiner includes all the glue logic to feed Blender side
|
|
|
|
* topology to OpenSubdiv. It can be shared by both evaluator and GL mesh
|
2019-01-04 15:57:44 +01:00
|
|
|
* drawer. */
|
Subsurf: Begin new subdivision surface module
The idea is to use this as a replacement of old CCG, now it is
based on OpenSubdiv. The goal is to reduce any possible overhead
which was happening with OpenSubdiv used by CCG.
Currently implemented/supported:
- Creation from mesh, including topology on OpenSubdiv side,
its refinement.
- Evaluation of limit point, first order derivatives, normal,
and face-varying data for individual coarse position.
- Evaluation of whole patches.
Currently not optimized, uses evaluation of individual coarse
positions.
- Creation of Mesh from subdiv, with all geometry being real:
all mvert, medge, mloop, and mpoly.
This includes custom data interpolation, but all faces currently
are getting separated (they are converted to ptex patches, which
we need to weld back together).
Still need to support lighter weights grids and such, but this
is already a required part to have subsurf working in the middle
of modifier stack.
Annoying part is ifdef all over the place, to keep it compilable
when OpenSubdiv is disabled. More cleaner approach would be to
have stub API for OpenSubdiv, so everything gets ifdef-ed in a
much fewer places.
2018-07-17 18:07:26 +02:00
|
|
|
struct OpenSubdiv_TopologyRefiner *topology_refiner;
|
|
|
|
/* CPU side evaluator. */
|
|
|
|
struct OpenSubdiv_Evaluator *evaluator;
|
2018-08-14 17:05:54 +02:00
|
|
|
/* Optional displacement evaluator. */
|
|
|
|
struct SubdivDisplacement *displacement_evaluator;
|
|
|
|
/* Statistics for debugging. */
|
2018-07-19 16:27:18 +02:00
|
|
|
SubdivStats stats;
|
2019-04-17 06:17:24 +02:00
|
|
|
|
2018-09-06 15:39:27 +02:00
|
|
|
/* Cached values, are not supposed to be accessed directly. */
|
|
|
|
struct {
|
|
|
|
/* Indexed by base face index, element indicates total number of ptex
|
OpenSubDiv: add support for an OpenGL evaluator
This evaluator is used in order to evaluate subdivision at render time, allowing for
faster renders of meshes with a subdivision surface modifier placed at the last
position in the modifier list.
When evaluating the subsurf modifier, we detect whether we can delegate evaluation
to the draw code. If so, the subdivision is first evaluated on the GPU using our own
custom evaluator (only the coarse data needs to be initially sent to the GPU), then,
buffers for the final `MeshBufferCache` are filled on the GPU using a set of
compute shaders. However, some buffers are still filled on the CPU side, if doing so
on the GPU is impractical (e.g. the line adjacency buffer used for x-ray, whose
logic is hardly GPU compatible).
This is done at the mesh buffer extraction level so that the result can be readily used
in the various OpenGL engines, without having to write custom geometry or tesselation
shaders.
We use our own subdivision evaluation shaders, instead of OpenSubDiv's vanilla one, in
order to control the data layout, and interpolation. For example, we store vertex colors
as compressed 16-bit integers, while OpenSubDiv's default evaluator only work for float
types.
In order to still access the modified geometry on the CPU side, for use in modifiers
or transform operators, a dedicated wrapper type is added `MESH_WRAPPER_TYPE_SUBD`.
Subdivision will be lazily evaluated via `BKE_object_get_evaluated_mesh` which will
create such a wrapper if possible. If the final subdivision surface is not needed on
the CPU side, `BKE_object_get_evaluated_mesh_no_subsurf` should be used.
Enabling or disabling GPU subdivision can be done through the user preferences (under
Viewport -> Subdivision).
See patch description for benchmarks.
Reviewed By: campbellbarton, jbakker, fclem, brecht, #eevee_viewport
Differential Revision: https://developer.blender.org/D12406
2021-12-27 16:34:47 +01:00
|
|
|
* faces created for preceding base faces. This also stores the final
|
|
|
|
* ptex offset (the total number of PTex faces) at the end of the array
|
|
|
|
* so that algorithms can compute the number of ptex faces for a given
|
|
|
|
* face by computing the delta with the offset for the next face without
|
|
|
|
* using a separate data structure, e.g.:
|
|
|
|
*
|
|
|
|
* const int num_face_ptex_faces = face_ptex_offset[i + 1] - face_ptex_offset[i];
|
|
|
|
*
|
|
|
|
* In total this array has a size of `num base faces + 1`.
|
|
|
|
*/
|
2018-09-06 15:39:27 +02:00
|
|
|
int *face_ptex_offset;
|
|
|
|
} cache_;
|
Subsurf: Begin new subdivision surface module
The idea is to use this as a replacement of old CCG, now it is
based on OpenSubdiv. The goal is to reduce any possible overhead
which was happening with OpenSubdiv used by CCG.
Currently implemented/supported:
- Creation from mesh, including topology on OpenSubdiv side,
its refinement.
- Evaluation of limit point, first order derivatives, normal,
and face-varying data for individual coarse position.
- Evaluation of whole patches.
Currently not optimized, uses evaluation of individual coarse
positions.
- Creation of Mesh from subdiv, with all geometry being real:
all mvert, medge, mloop, and mpoly.
This includes custom data interpolation, but all faces currently
are getting separated (they are converted to ptex patches, which
we need to weld back together).
Still need to support lighter weights grids and such, but this
is already a required part to have subsurf working in the middle
of modifier stack.
Annoying part is ifdef all over the place, to keep it compilable
when OpenSubdiv is disabled. More cleaner approach would be to
have stub API for OpenSubdiv, so everything gets ifdef-ed in a
much fewer places.
2018-07-17 18:07:26 +02:00
|
|
|
} Subdiv;
|
|
|
|
|
2022-05-12 09:43:19 +02:00
|
|
|
/* --------------------------------------------------------------------
|
|
|
|
* Module.
|
|
|
|
*/
|
2020-05-18 16:42:59 +02:00
|
|
|
|
|
|
|
/* (De)initialize the entire subdivision surface module. */
|
|
|
|
void BKE_subdiv_init(void);
|
|
|
|
void BKE_subdiv_exit(void);
|
|
|
|
|
2022-05-12 09:43:19 +02:00
|
|
|
/* --------------------------------------------------------------------
|
|
|
|
* Conversion helpers.
|
|
|
|
*/
|
2018-08-14 12:17:10 +02:00
|
|
|
|
|
|
|
/* NOTE: uv_smooth is eSubsurfUVSmooth. */
|
|
|
|
eSubdivFVarLinearInterpolation BKE_subdiv_fvar_interpolation_from_uv_smooth(int uv_smooth);
|
|
|
|
|
2020-09-30 15:56:37 +02:00
|
|
|
eSubdivVtxBoundaryInterpolation BKE_subdiv_vtx_boundary_interpolation_from_subsurf(
|
|
|
|
int boundary_smooth);
|
|
|
|
|
2022-05-12 09:43:19 +02:00
|
|
|
/* --------------------------------------------------------------------
|
|
|
|
* Statistics.
|
|
|
|
*/
|
2018-07-19 16:27:18 +02:00
|
|
|
|
|
|
|
void BKE_subdiv_stats_init(SubdivStats *stats);
|
|
|
|
|
|
|
|
void BKE_subdiv_stats_begin(SubdivStats *stats, eSubdivStatsValue value);
|
|
|
|
void BKE_subdiv_stats_end(SubdivStats *stats, eSubdivStatsValue value);
|
|
|
|
|
2019-01-16 10:15:25 +01:00
|
|
|
void BKE_subdiv_stats_reset(SubdivStats *stats, eSubdivStatsValue value);
|
|
|
|
|
2018-07-19 16:27:18 +02:00
|
|
|
void BKE_subdiv_stats_print(const SubdivStats *stats);
|
|
|
|
|
2022-05-12 09:43:19 +02:00
|
|
|
/* --------------------------------------------------------------------
|
|
|
|
* Settings.
|
|
|
|
*/
|
2019-01-15 15:34:11 +01:00
|
|
|
|
|
|
|
bool BKE_subdiv_settings_equal(const SubdivSettings *settings_a, const SubdivSettings *settings_b);
|
|
|
|
|
2022-05-12 09:43:19 +02:00
|
|
|
/* --------------------------------------------------------------------
|
|
|
|
* Construction.
|
|
|
|
*/
|
Subsurf: Begin new subdivision surface module
The idea is to use this as a replacement of old CCG, now it is
based on OpenSubdiv. The goal is to reduce any possible overhead
which was happening with OpenSubdiv used by CCG.
Currently implemented/supported:
- Creation from mesh, including topology on OpenSubdiv side,
its refinement.
- Evaluation of limit point, first order derivatives, normal,
and face-varying data for individual coarse position.
- Evaluation of whole patches.
Currently not optimized, uses evaluation of individual coarse
positions.
- Creation of Mesh from subdiv, with all geometry being real:
all mvert, medge, mloop, and mpoly.
This includes custom data interpolation, but all faces currently
are getting separated (they are converted to ptex patches, which
we need to weld back together).
Still need to support lighter weights grids and such, but this
is already a required part to have subsurf working in the middle
of modifier stack.
Annoying part is ifdef all over the place, to keep it compilable
when OpenSubdiv is disabled. More cleaner approach would be to
have stub API for OpenSubdiv, so everything gets ifdef-ed in a
much fewer places.
2018-07-17 18:07:26 +02:00
|
|
|
|
2019-01-15 15:34:11 +01:00
|
|
|
/* Construct new subdivision surface descriptor, from scratch, using given
|
|
|
|
* settings and topology. */
|
Subsurf: Begin new subdivision surface module
The idea is to use this as a replacement of old CCG, now it is
based on OpenSubdiv. The goal is to reduce any possible overhead
which was happening with OpenSubdiv used by CCG.
Currently implemented/supported:
- Creation from mesh, including topology on OpenSubdiv side,
its refinement.
- Evaluation of limit point, first order derivatives, normal,
and face-varying data for individual coarse position.
- Evaluation of whole patches.
Currently not optimized, uses evaluation of individual coarse
positions.
- Creation of Mesh from subdiv, with all geometry being real:
all mvert, medge, mloop, and mpoly.
This includes custom data interpolation, but all faces currently
are getting separated (they are converted to ptex patches, which
we need to weld back together).
Still need to support lighter weights grids and such, but this
is already a required part to have subsurf working in the middle
of modifier stack.
Annoying part is ifdef all over the place, to keep it compilable
when OpenSubdiv is disabled. More cleaner approach would be to
have stub API for OpenSubdiv, so everything gets ifdef-ed in a
much fewer places.
2018-07-17 18:07:26 +02:00
|
|
|
Subdiv *BKE_subdiv_new_from_converter(const SubdivSettings *settings,
|
|
|
|
struct OpenSubdiv_Converter *converter);
|
|
|
|
Subdiv *BKE_subdiv_new_from_mesh(const SubdivSettings *settings, const struct Mesh *mesh);
|
|
|
|
|
2019-01-15 15:34:11 +01:00
|
|
|
/* Similar to above, but will not re-create descriptor if it was created for the
|
|
|
|
* same settings and topology.
|
|
|
|
* If settings or topology did change, the existing descriptor is freed and a
|
|
|
|
* new one is created from scratch.
|
|
|
|
*
|
|
|
|
* NOTE: It is allowed to pass NULL as an existing subdivision surface
|
2019-06-17 04:51:53 +02:00
|
|
|
* descriptor. This will create a new descriptor without any extra checks.
|
2019-01-15 15:34:11 +01:00
|
|
|
*/
|
|
|
|
Subdiv *BKE_subdiv_update_from_converter(Subdiv *subdiv,
|
|
|
|
const SubdivSettings *settings,
|
|
|
|
struct OpenSubdiv_Converter *converter);
|
|
|
|
Subdiv *BKE_subdiv_update_from_mesh(Subdiv *subdiv,
|
|
|
|
const SubdivSettings *settings,
|
|
|
|
const struct Mesh *mesh);
|
|
|
|
|
Subsurf: Begin new subdivision surface module
The idea is to use this as a replacement of old CCG, now it is
based on OpenSubdiv. The goal is to reduce any possible overhead
which was happening with OpenSubdiv used by CCG.
Currently implemented/supported:
- Creation from mesh, including topology on OpenSubdiv side,
its refinement.
- Evaluation of limit point, first order derivatives, normal,
and face-varying data for individual coarse position.
- Evaluation of whole patches.
Currently not optimized, uses evaluation of individual coarse
positions.
- Creation of Mesh from subdiv, with all geometry being real:
all mvert, medge, mloop, and mpoly.
This includes custom data interpolation, but all faces currently
are getting separated (they are converted to ptex patches, which
we need to weld back together).
Still need to support lighter weights grids and such, but this
is already a required part to have subsurf working in the middle
of modifier stack.
Annoying part is ifdef all over the place, to keep it compilable
when OpenSubdiv is disabled. More cleaner approach would be to
have stub API for OpenSubdiv, so everything gets ifdef-ed in a
much fewer places.
2018-07-17 18:07:26 +02:00
|
|
|
void BKE_subdiv_free(Subdiv *subdiv);
|
|
|
|
|
2022-05-12 09:43:19 +02:00
|
|
|
/* --------------------------------------------------------------------
|
2022-05-13 01:24:28 +02:00
|
|
|
* Displacement API.
|
2022-05-12 09:43:19 +02:00
|
|
|
*/
|
2018-08-14 17:05:54 +02:00
|
|
|
|
|
|
|
void BKE_subdiv_displacement_attach_from_multires(Subdiv *subdiv,
|
2019-01-04 15:57:44 +01:00
|
|
|
struct Mesh *mesh,
|
2018-08-14 17:05:54 +02:00
|
|
|
const struct MultiresModifierData *mmd);
|
|
|
|
|
|
|
|
void BKE_subdiv_displacement_detach(Subdiv *subdiv);
|
|
|
|
|
2022-05-12 09:43:19 +02:00
|
|
|
/* --------------------------------------------------------------------
|
|
|
|
* Topology helpers.
|
|
|
|
*/
|
2018-09-06 15:39:27 +02:00
|
|
|
|
OpenSubDiv: add support for an OpenGL evaluator
This evaluator is used in order to evaluate subdivision at render time, allowing for
faster renders of meshes with a subdivision surface modifier placed at the last
position in the modifier list.
When evaluating the subsurf modifier, we detect whether we can delegate evaluation
to the draw code. If so, the subdivision is first evaluated on the GPU using our own
custom evaluator (only the coarse data needs to be initially sent to the GPU), then,
buffers for the final `MeshBufferCache` are filled on the GPU using a set of
compute shaders. However, some buffers are still filled on the CPU side, if doing so
on the GPU is impractical (e.g. the line adjacency buffer used for x-ray, whose
logic is hardly GPU compatible).
This is done at the mesh buffer extraction level so that the result can be readily used
in the various OpenGL engines, without having to write custom geometry or tesselation
shaders.
We use our own subdivision evaluation shaders, instead of OpenSubDiv's vanilla one, in
order to control the data layout, and interpolation. For example, we store vertex colors
as compressed 16-bit integers, while OpenSubDiv's default evaluator only work for float
types.
In order to still access the modified geometry on the CPU side, for use in modifiers
or transform operators, a dedicated wrapper type is added `MESH_WRAPPER_TYPE_SUBD`.
Subdivision will be lazily evaluated via `BKE_object_get_evaluated_mesh` which will
create such a wrapper if possible. If the final subdivision surface is not needed on
the CPU side, `BKE_object_get_evaluated_mesh_no_subsurf` should be used.
Enabling or disabling GPU subdivision can be done through the user preferences (under
Viewport -> Subdivision).
See patch description for benchmarks.
Reviewed By: campbellbarton, jbakker, fclem, brecht, #eevee_viewport
Differential Revision: https://developer.blender.org/D12406
2021-12-27 16:34:47 +01:00
|
|
|
/* For each element in the array, this stores the total number of ptex faces up to that element,
|
|
|
|
* with the total number of ptex faces being the last element in the array. The array is of length
|
|
|
|
* `base face count + 1`. */
|
2018-09-06 15:39:27 +02:00
|
|
|
int *BKE_subdiv_face_ptex_offset_get(Subdiv *subdiv);
|
|
|
|
|
2022-05-12 09:43:19 +02:00
|
|
|
/* --------------------------------------------------------------------
|
|
|
|
* PTex faces and grids.
|
|
|
|
*/
|
2018-11-01 11:06:00 +01:00
|
|
|
|
|
|
|
/* For a given (ptex_u, ptex_v) within a ptex face get corresponding
|
2019-01-04 15:57:44 +01:00
|
|
|
* (grid_u, grid_v) within a grid. */
|
2022-01-07 01:38:08 +01:00
|
|
|
BLI_INLINE void BKE_subdiv_ptex_face_uv_to_grid_uv(float ptex_u,
|
|
|
|
float ptex_v,
|
2018-11-01 11:06:00 +01:00
|
|
|
float *r_grid_u,
|
|
|
|
float *r_grid_v);
|
|
|
|
|
2019-04-05 12:52:57 +02:00
|
|
|
/* Inverse of above. */
|
2022-01-07 01:38:08 +01:00
|
|
|
BLI_INLINE void BKE_subdiv_grid_uv_to_ptex_face_uv(float grid_u,
|
|
|
|
float grid_v,
|
2019-01-17 18:09:47 +01:00
|
|
|
float *r_ptex_u,
|
|
|
|
float *r_ptex_v);
|
|
|
|
|
2018-11-01 11:06:00 +01:00
|
|
|
/* For a given subdivision level (which is NOT refinement level) get size of
|
|
|
|
* CCG grid (number of grid points on a side).
|
|
|
|
*/
|
2022-01-07 01:38:08 +01:00
|
|
|
BLI_INLINE int BKE_subdiv_grid_size_from_level(int level);
|
2018-11-01 11:06:00 +01:00
|
|
|
|
2018-11-01 15:20:31 +01:00
|
|
|
/* Simplified version of mdisp_rot_face_to_crn, only handles quad and
|
|
|
|
* works in normalized coordinates.
|
|
|
|
*
|
2019-01-04 15:57:44 +01:00
|
|
|
* NOTE: Output coordinates are in ptex coordinates. */
|
2022-01-07 01:38:08 +01:00
|
|
|
BLI_INLINE int BKE_subdiv_rotate_quad_to_corner(float quad_u,
|
|
|
|
float quad_v,
|
2019-01-17 10:41:40 +01:00
|
|
|
float *r_corner_u,
|
|
|
|
float *r_corner_v);
|
2018-11-01 15:20:31 +01:00
|
|
|
|
2019-01-17 11:17:15 +01:00
|
|
|
/* Converts (u, v) coordinate from within a grid to a quad coordinate in
|
|
|
|
* normalized ptex coordinates. */
|
|
|
|
BLI_INLINE void BKE_subdiv_rotate_grid_to_quad(
|
2022-01-07 01:38:08 +01:00
|
|
|
int corner, float grid_u, float grid_v, float *r_quad_u, float *r_quad_v);
|
2019-01-17 10:47:14 +01:00
|
|
|
|
2020-03-19 10:32:16 +01:00
|
|
|
/* Convert Blender edge crease value to OpenSubdiv sharpness. */
|
Subdivision: add support for vertex creasing
This adds vertex creasing support for OpenSubDiv for modeling, rendering,
Alembic and USD I/O.
For modeling, vertex creasing follows the edge creasing implementation with an
operator accessible through the Vertex menu in Edit Mode, and some parameter in
the properties panel. The option in the Subsurf and Multires to use edge
creasing also affects vertex creasing.
The vertex crease data is stored as a CustomData layer, unlike edge creases
which for now are stored in `MEdge`, but will in the future also be moved to
a `CustomData` layer. See comments for details on the difference in behavior
for the `CD_CREASE` layer between egdes and vertices.
For Cycles this adds sockets on the Mesh node to hold data about which vertices
are creased (one socket for the indices, one for the weigths).
Viewport rendering of vertex creasing reuses the same color scheme as for edges
and creased vertices are drawn bigger than uncreased vertices.
For Alembic and USD, vertex crease support follows the edge crease
implementation, they are always read, but only exported if a `Subsurf` modifier
is present on the Mesh.
Reviewed By: brecht, fclem, sergey, sybren, campbellbarton
Differential Revision: https://developer.blender.org/D10145
2022-01-20 12:20:30 +01:00
|
|
|
BLI_INLINE float BKE_subdiv_crease_to_sharpness_f(float edge_crease);
|
|
|
|
BLI_INLINE float BKE_subdiv_crease_to_sharpness_char(char edge_crease);
|
2020-03-19 10:32:16 +01:00
|
|
|
|
2020-03-02 15:07:49 +01:00
|
|
|
#ifdef __cplusplus
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2018-11-01 11:06:00 +01:00
|
|
|
#include "intern/subdiv_inline.h"
|