2023-02-22 09:16:42 +00:00
|
|
|
// Copyright 2013 Blender Foundation
|
OpenSubdiv: Re-work C-API integration
Main goal is to make API simpler to follow (at least ion terms what
is defined/declared where, as opposite of handful big headers which
includes all the declarations), and also avoid a big set of long and
obscure functions.
Now C-API files are split into smaller ones, following OpenSubdiv
behavior more closely, and also function pointers in structures
used a lot more, which shortens functions names,
UV integration part in GL Mesh is mainly stripped away, it needs
to be done differently. On a related topic, UV coordinates API in
converter needs to be removed as well, we do not need coordinates,
only island connectivity information there.
Additional changes:
- Varying interpolation in evaluator API are temporarily disabled,
need to extend API somewhere (probably, evaluator's API) to inform
layout information of vertex data (whether it contains varying
data, width, stride and such).
- Evaluator now can interpolate face-varying data.
Only works for adaptive refiner, since some issues in OpenSubdiv
itself.
Planned changes:
- Remove uv coordinates from TopologyConverter.
- Support evaluation of patches (as opposite to individual coordinates
as it happens currently).
- Support more flexible layout of varying and face-varying data.
It is stupid to assume varying is 3 floats and face-varying 2 floats.
- Support of second order derivatives.
- Everything else what i'm missing in this list.
2018-07-16 07:28:05 +00:00
|
|
|
//
|
|
|
|
// This program is free software; you can redistribute it and/or
|
|
|
|
// modify it under the terms of the GNU General Public License
|
|
|
|
// as published by the Free Software Foundation; either version 2
|
|
|
|
// of the License, or (at your option) any later version.
|
|
|
|
//
|
|
|
|
// This program is distributed in the hope that it will be useful,
|
|
|
|
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
|
|
// GNU General Public License for more details.
|
|
|
|
//
|
|
|
|
// You should have received a copy of the GNU General Public License
|
|
|
|
// along with this program; if not, write to the Free Software Foundation,
|
|
|
|
// Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
|
|
|
|
//
|
|
|
|
// Author: Sergey Sharybin
|
|
|
|
|
|
|
|
#ifndef OPENSUBDIV_EVALUATOR_CAPI_H_
|
|
|
|
#define OPENSUBDIV_EVALUATOR_CAPI_H_
|
|
|
|
|
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 15:34:47 +00:00
|
|
|
#include <stdint.h> // for uint64_t
|
|
|
|
|
|
|
|
#include "opensubdiv_capi_type.h"
|
|
|
|
|
OpenSubdiv: Re-work C-API integration
Main goal is to make API simpler to follow (at least ion terms what
is defined/declared where, as opposite of handful big headers which
includes all the declarations), and also avoid a big set of long and
obscure functions.
Now C-API files are split into smaller ones, following OpenSubdiv
behavior more closely, and also function pointers in structures
used a lot more, which shortens functions names,
UV integration part in GL Mesh is mainly stripped away, it needs
to be done differently. On a related topic, UV coordinates API in
converter needs to be removed as well, we do not need coordinates,
only island connectivity information there.
Additional changes:
- Varying interpolation in evaluator API are temporarily disabled,
need to extend API somewhere (probably, evaluator's API) to inform
layout information of vertex data (whether it contains varying
data, width, stride and such).
- Evaluator now can interpolate face-varying data.
Only works for adaptive refiner, since some issues in OpenSubdiv
itself.
Planned changes:
- Remove uv coordinates from TopologyConverter.
- Support evaluation of patches (as opposite to individual coordinates
as it happens currently).
- Support more flexible layout of varying and face-varying data.
It is stupid to assume varying is 3 floats and face-varying 2 floats.
- Support of second order derivatives.
- Everything else what i'm missing in this list.
2018-07-16 07:28:05 +00:00
|
|
|
#ifdef __cplusplus
|
|
|
|
extern "C" {
|
|
|
|
#endif
|
|
|
|
|
|
|
|
struct OpenSubdiv_EvaluatorInternal;
|
2019-10-16 12:59:18 +00:00
|
|
|
struct OpenSubdiv_PatchCoord;
|
OpenSubdiv: Re-work C-API integration
Main goal is to make API simpler to follow (at least ion terms what
is defined/declared where, as opposite of handful big headers which
includes all the declarations), and also avoid a big set of long and
obscure functions.
Now C-API files are split into smaller ones, following OpenSubdiv
behavior more closely, and also function pointers in structures
used a lot more, which shortens functions names,
UV integration part in GL Mesh is mainly stripped away, it needs
to be done differently. On a related topic, UV coordinates API in
converter needs to be removed as well, we do not need coordinates,
only island connectivity information there.
Additional changes:
- Varying interpolation in evaluator API are temporarily disabled,
need to extend API somewhere (probably, evaluator's API) to inform
layout information of vertex data (whether it contains varying
data, width, stride and such).
- Evaluator now can interpolate face-varying data.
Only works for adaptive refiner, since some issues in OpenSubdiv
itself.
Planned changes:
- Remove uv coordinates from TopologyConverter.
- Support evaluation of patches (as opposite to individual coordinates
as it happens currently).
- Support more flexible layout of varying and face-varying data.
It is stupid to assume varying is 3 floats and face-varying 2 floats.
- Support of second order derivatives.
- Everything else what i'm missing in this list.
2018-07-16 07:28:05 +00:00
|
|
|
struct OpenSubdiv_TopologyRefiner;
|
|
|
|
|
2022-05-30 11:28:38 +00:00
|
|
|
typedef struct OpenSubdiv_EvaluatorSettings {
|
|
|
|
// Number of smoothly interpolated vertex data channels.
|
|
|
|
int num_vertex_data;
|
|
|
|
} OpenSubdiv_EvaluatorSettings;
|
|
|
|
|
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 15:34:47 +00:00
|
|
|
// Callback type for doing input/output operations on buffers.
|
|
|
|
// Useful to abstract GPU buffers.
|
|
|
|
typedef struct OpenSubdiv_Buffer {
|
|
|
|
// Bind the buffer to the GPU.
|
|
|
|
void (*bind_gpu)(const struct OpenSubdiv_Buffer *buffer);
|
|
|
|
|
|
|
|
// Allocate the buffer directly on the host for the given size in bytes. This has to return
|
|
|
|
// a pointer to the newly allocated memory.
|
|
|
|
void *(*alloc)(const struct OpenSubdiv_Buffer *buffer, const unsigned int size);
|
|
|
|
|
|
|
|
// Allocate the buffer directly on the device for the given size in bytes.
|
|
|
|
void (*device_alloc)(const struct OpenSubdiv_Buffer *buffer, const unsigned int size);
|
|
|
|
|
|
|
|
// Update the given range of the buffer with new data.
|
|
|
|
void (*device_update)(const struct OpenSubdiv_Buffer *buffer,
|
|
|
|
unsigned int start,
|
|
|
|
unsigned int len,
|
|
|
|
const void *data);
|
|
|
|
|
|
|
|
// Wrap an existing GPU buffer, given its device handle, into the client's buffer type for
|
|
|
|
// read-only use.
|
|
|
|
void (*wrap_device_handle)(const struct OpenSubdiv_Buffer *buffer, uint64_t device_ptr);
|
|
|
|
|
|
|
|
// Offset in the buffer where the data starts, if a single buffer is used for multiple data
|
|
|
|
// channels.
|
|
|
|
int buffer_offset;
|
|
|
|
|
|
|
|
// Pointer to the client buffer data, which is modified or initialized through the various
|
|
|
|
// callbacks.
|
|
|
|
void *data;
|
|
|
|
} OpenSubdiv_Buffer;
|
|
|
|
|
OpenSubdiv: Re-work C-API integration
Main goal is to make API simpler to follow (at least ion terms what
is defined/declared where, as opposite of handful big headers which
includes all the declarations), and also avoid a big set of long and
obscure functions.
Now C-API files are split into smaller ones, following OpenSubdiv
behavior more closely, and also function pointers in structures
used a lot more, which shortens functions names,
UV integration part in GL Mesh is mainly stripped away, it needs
to be done differently. On a related topic, UV coordinates API in
converter needs to be removed as well, we do not need coordinates,
only island connectivity information there.
Additional changes:
- Varying interpolation in evaluator API are temporarily disabled,
need to extend API somewhere (probably, evaluator's API) to inform
layout information of vertex data (whether it contains varying
data, width, stride and such).
- Evaluator now can interpolate face-varying data.
Only works for adaptive refiner, since some issues in OpenSubdiv
itself.
Planned changes:
- Remove uv coordinates from TopologyConverter.
- Support evaluation of patches (as opposite to individual coordinates
as it happens currently).
- Support more flexible layout of varying and face-varying data.
It is stupid to assume varying is 3 floats and face-varying 2 floats.
- Support of second order derivatives.
- Everything else what i'm missing in this list.
2018-07-16 07:28:05 +00:00
|
|
|
typedef struct OpenSubdiv_Evaluator {
|
2022-05-30 11:28:38 +00:00
|
|
|
// Set settings for data buffers used.
|
|
|
|
void (*setSettings)(struct OpenSubdiv_Evaluator *evaluator,
|
|
|
|
const OpenSubdiv_EvaluatorSettings *settings);
|
|
|
|
|
OpenSubdiv: Re-work C-API integration
Main goal is to make API simpler to follow (at least ion terms what
is defined/declared where, as opposite of handful big headers which
includes all the declarations), and also avoid a big set of long and
obscure functions.
Now C-API files are split into smaller ones, following OpenSubdiv
behavior more closely, and also function pointers in structures
used a lot more, which shortens functions names,
UV integration part in GL Mesh is mainly stripped away, it needs
to be done differently. On a related topic, UV coordinates API in
converter needs to be removed as well, we do not need coordinates,
only island connectivity information there.
Additional changes:
- Varying interpolation in evaluator API are temporarily disabled,
need to extend API somewhere (probably, evaluator's API) to inform
layout information of vertex data (whether it contains varying
data, width, stride and such).
- Evaluator now can interpolate face-varying data.
Only works for adaptive refiner, since some issues in OpenSubdiv
itself.
Planned changes:
- Remove uv coordinates from TopologyConverter.
- Support evaluation of patches (as opposite to individual coordinates
as it happens currently).
- Support more flexible layout of varying and face-varying data.
It is stupid to assume varying is 3 floats and face-varying 2 floats.
- Support of second order derivatives.
- Everything else what i'm missing in this list.
2018-07-16 07:28:05 +00:00
|
|
|
// Set coarse positions from a continuous array of coordinates.
|
|
|
|
void (*setCoarsePositions)(struct OpenSubdiv_Evaluator *evaluator,
|
|
|
|
const float *positions,
|
|
|
|
const int start_vertex_index,
|
|
|
|
const int num_vertices);
|
2021-01-14 15:33:52 +00:00
|
|
|
// Set vertex data from a continuous array of coordinates.
|
|
|
|
void (*setVertexData)(struct OpenSubdiv_Evaluator *evaluator,
|
|
|
|
const float *data,
|
|
|
|
const int start_vertex_index,
|
|
|
|
const int num_vertices);
|
OpenSubdiv: Re-work C-API integration
Main goal is to make API simpler to follow (at least ion terms what
is defined/declared where, as opposite of handful big headers which
includes all the declarations), and also avoid a big set of long and
obscure functions.
Now C-API files are split into smaller ones, following OpenSubdiv
behavior more closely, and also function pointers in structures
used a lot more, which shortens functions names,
UV integration part in GL Mesh is mainly stripped away, it needs
to be done differently. On a related topic, UV coordinates API in
converter needs to be removed as well, we do not need coordinates,
only island connectivity information there.
Additional changes:
- Varying interpolation in evaluator API are temporarily disabled,
need to extend API somewhere (probably, evaluator's API) to inform
layout information of vertex data (whether it contains varying
data, width, stride and such).
- Evaluator now can interpolate face-varying data.
Only works for adaptive refiner, since some issues in OpenSubdiv
itself.
Planned changes:
- Remove uv coordinates from TopologyConverter.
- Support evaluation of patches (as opposite to individual coordinates
as it happens currently).
- Support more flexible layout of varying and face-varying data.
It is stupid to assume varying is 3 floats and face-varying 2 floats.
- Support of second order derivatives.
- Everything else what i'm missing in this list.
2018-07-16 07:28:05 +00:00
|
|
|
// Set varying data from a continuous array of data.
|
|
|
|
void (*setVaryingData)(struct OpenSubdiv_Evaluator *evaluator,
|
|
|
|
const float *varying_data,
|
|
|
|
const int start_vertex_index,
|
|
|
|
const int num_vertices);
|
|
|
|
// Set face varying data from a continuous array of data.
|
|
|
|
//
|
|
|
|
// TODO(sergey): Find a better name for vertex here. It is not the vertex of
|
|
|
|
// geometry, but a vertex of UV map.
|
|
|
|
void (*setFaceVaryingData)(struct OpenSubdiv_Evaluator *evaluator,
|
2018-08-01 16:31:05 +00:00
|
|
|
const int face_varying_channel,
|
OpenSubdiv: Re-work C-API integration
Main goal is to make API simpler to follow (at least ion terms what
is defined/declared where, as opposite of handful big headers which
includes all the declarations), and also avoid a big set of long and
obscure functions.
Now C-API files are split into smaller ones, following OpenSubdiv
behavior more closely, and also function pointers in structures
used a lot more, which shortens functions names,
UV integration part in GL Mesh is mainly stripped away, it needs
to be done differently. On a related topic, UV coordinates API in
converter needs to be removed as well, we do not need coordinates,
only island connectivity information there.
Additional changes:
- Varying interpolation in evaluator API are temporarily disabled,
need to extend API somewhere (probably, evaluator's API) to inform
layout information of vertex data (whether it contains varying
data, width, stride and such).
- Evaluator now can interpolate face-varying data.
Only works for adaptive refiner, since some issues in OpenSubdiv
itself.
Planned changes:
- Remove uv coordinates from TopologyConverter.
- Support evaluation of patches (as opposite to individual coordinates
as it happens currently).
- Support more flexible layout of varying and face-varying data.
It is stupid to assume varying is 3 floats and face-varying 2 floats.
- Support of second order derivatives.
- Everything else what i'm missing in this list.
2018-07-16 07:28:05 +00:00
|
|
|
const float *face_varying_data,
|
|
|
|
const int start_vertex_index,
|
|
|
|
const int num_vertices);
|
|
|
|
|
|
|
|
// Set coarse vertex position from a continuous memory buffer where
|
|
|
|
// first coordinate starts at offset of `start_offset` and there is `stride`
|
|
|
|
// bytes between adjacent vertex coordinates.
|
|
|
|
void (*setCoarsePositionsFromBuffer)(struct OpenSubdiv_Evaluator *evaluator,
|
|
|
|
const void *buffer,
|
|
|
|
const int start_offset,
|
|
|
|
const int stride,
|
|
|
|
const int start_vertex_index,
|
|
|
|
const int num_vertices);
|
|
|
|
// Set varying data from a continuous memory buffer where
|
|
|
|
// first coordinate starts at offset of `start_offset` and there is `stride`
|
|
|
|
// bytes between adjacent vertex coordinates.
|
|
|
|
void (*setVaryingDataFromBuffer)(struct OpenSubdiv_Evaluator *evaluator,
|
|
|
|
const void *buffer,
|
|
|
|
const int start_offset,
|
|
|
|
const int stride,
|
|
|
|
const int start_vertex_index,
|
|
|
|
const int num_vertices);
|
|
|
|
// Set face varying data from a continuous memory buffer where
|
|
|
|
// first coordinate starts at offset of `start_offset` and there is `stride`
|
|
|
|
// bytes between adjacent vertex coordinates.
|
|
|
|
//
|
|
|
|
// TODO(sergey): Find a better name for vertex here. It is not the vertex of
|
|
|
|
// geometry, but a vertex of UV map.
|
|
|
|
void (*setFaceVaryingDataFromBuffer)(struct OpenSubdiv_Evaluator *evaluator,
|
2018-08-01 16:31:05 +00:00
|
|
|
const int face_varying_channel,
|
OpenSubdiv: Re-work C-API integration
Main goal is to make API simpler to follow (at least ion terms what
is defined/declared where, as opposite of handful big headers which
includes all the declarations), and also avoid a big set of long and
obscure functions.
Now C-API files are split into smaller ones, following OpenSubdiv
behavior more closely, and also function pointers in structures
used a lot more, which shortens functions names,
UV integration part in GL Mesh is mainly stripped away, it needs
to be done differently. On a related topic, UV coordinates API in
converter needs to be removed as well, we do not need coordinates,
only island connectivity information there.
Additional changes:
- Varying interpolation in evaluator API are temporarily disabled,
need to extend API somewhere (probably, evaluator's API) to inform
layout information of vertex data (whether it contains varying
data, width, stride and such).
- Evaluator now can interpolate face-varying data.
Only works for adaptive refiner, since some issues in OpenSubdiv
itself.
Planned changes:
- Remove uv coordinates from TopologyConverter.
- Support evaluation of patches (as opposite to individual coordinates
as it happens currently).
- Support more flexible layout of varying and face-varying data.
It is stupid to assume varying is 3 floats and face-varying 2 floats.
- Support of second order derivatives.
- Everything else what i'm missing in this list.
2018-07-16 07:28:05 +00:00
|
|
|
const void *buffer,
|
|
|
|
const int start_offset,
|
|
|
|
const int stride,
|
|
|
|
const int start_vertex_index,
|
|
|
|
const int num_vertices);
|
|
|
|
|
|
|
|
// Refine after coarse positions update.
|
|
|
|
void (*refine)(struct OpenSubdiv_Evaluator *evaluator);
|
|
|
|
|
|
|
|
// Evaluate given ptex face at given bilinear coordinate.
|
|
|
|
// If derivatives are NULL, they will not be evaluated.
|
|
|
|
void (*evaluateLimit)(struct OpenSubdiv_Evaluator *evaluator,
|
|
|
|
const int ptex_face_index,
|
|
|
|
float face_u,
|
|
|
|
float face_v,
|
|
|
|
float P[3],
|
|
|
|
float dPdu[3],
|
|
|
|
float dPdv[3]);
|
|
|
|
|
2021-01-14 15:33:52 +00:00
|
|
|
// Evaluate vertex data at a given bilinear coordinate of given ptex face.
|
|
|
|
void (*evaluateVertexData)(struct OpenSubdiv_Evaluator *evaluator,
|
|
|
|
const int ptex_face_index,
|
|
|
|
float face_u,
|
|
|
|
float face_v,
|
|
|
|
float data[]);
|
|
|
|
|
OpenSubdiv: Re-work C-API integration
Main goal is to make API simpler to follow (at least ion terms what
is defined/declared where, as opposite of handful big headers which
includes all the declarations), and also avoid a big set of long and
obscure functions.
Now C-API files are split into smaller ones, following OpenSubdiv
behavior more closely, and also function pointers in structures
used a lot more, which shortens functions names,
UV integration part in GL Mesh is mainly stripped away, it needs
to be done differently. On a related topic, UV coordinates API in
converter needs to be removed as well, we do not need coordinates,
only island connectivity information there.
Additional changes:
- Varying interpolation in evaluator API are temporarily disabled,
need to extend API somewhere (probably, evaluator's API) to inform
layout information of vertex data (whether it contains varying
data, width, stride and such).
- Evaluator now can interpolate face-varying data.
Only works for adaptive refiner, since some issues in OpenSubdiv
itself.
Planned changes:
- Remove uv coordinates from TopologyConverter.
- Support evaluation of patches (as opposite to individual coordinates
as it happens currently).
- Support more flexible layout of varying and face-varying data.
It is stupid to assume varying is 3 floats and face-varying 2 floats.
- Support of second order derivatives.
- Everything else what i'm missing in this list.
2018-07-16 07:28:05 +00:00
|
|
|
// Evaluate varying data at a given bilinear coordinate of given ptex face.
|
|
|
|
void (*evaluateVarying)(struct OpenSubdiv_Evaluator *evaluator,
|
|
|
|
const int ptex_face_index,
|
|
|
|
float face_u,
|
|
|
|
float face_v,
|
|
|
|
float varying[3]);
|
|
|
|
|
|
|
|
// Evaluate face-varying data at a given bilinear coordinate of given
|
|
|
|
// ptex face.
|
|
|
|
void (*evaluateFaceVarying)(struct OpenSubdiv_Evaluator *evaluator,
|
2018-08-01 16:31:05 +00:00
|
|
|
const int face_varying_channel,
|
OpenSubdiv: Re-work C-API integration
Main goal is to make API simpler to follow (at least ion terms what
is defined/declared where, as opposite of handful big headers which
includes all the declarations), and also avoid a big set of long and
obscure functions.
Now C-API files are split into smaller ones, following OpenSubdiv
behavior more closely, and also function pointers in structures
used a lot more, which shortens functions names,
UV integration part in GL Mesh is mainly stripped away, it needs
to be done differently. On a related topic, UV coordinates API in
converter needs to be removed as well, we do not need coordinates,
only island connectivity information there.
Additional changes:
- Varying interpolation in evaluator API are temporarily disabled,
need to extend API somewhere (probably, evaluator's API) to inform
layout information of vertex data (whether it contains varying
data, width, stride and such).
- Evaluator now can interpolate face-varying data.
Only works for adaptive refiner, since some issues in OpenSubdiv
itself.
Planned changes:
- Remove uv coordinates from TopologyConverter.
- Support evaluation of patches (as opposite to individual coordinates
as it happens currently).
- Support more flexible layout of varying and face-varying data.
It is stupid to assume varying is 3 floats and face-varying 2 floats.
- Support of second order derivatives.
- Everything else what i'm missing in this list.
2018-07-16 07:28:05 +00:00
|
|
|
const int ptex_face_index,
|
|
|
|
float face_u,
|
|
|
|
float face_v,
|
|
|
|
float face_varying[2]);
|
|
|
|
|
2019-10-16 12:59:18 +00:00
|
|
|
// Batched evaluation of multiple input coordinates.
|
|
|
|
|
|
|
|
// Evaluate limit surface.
|
|
|
|
// If derivatives are NULL, they will not be evaluated.
|
|
|
|
//
|
|
|
|
// NOTE: Output arrays must point to a memory of size float[3]*num_patch_coords.
|
|
|
|
void (*evaluatePatchesLimit)(struct OpenSubdiv_Evaluator *evaluator,
|
|
|
|
const struct OpenSubdiv_PatchCoord *patch_coords,
|
|
|
|
const int num_patch_coords,
|
|
|
|
float *P,
|
|
|
|
float *dPdu,
|
|
|
|
float *dPdv);
|
|
|
|
|
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 15:34:47 +00:00
|
|
|
// Copy the patch map to the given buffers, and output some topology information.
|
|
|
|
void (*getPatchMap)(struct OpenSubdiv_Evaluator *evaluator,
|
|
|
|
struct OpenSubdiv_Buffer *patch_map_handles,
|
|
|
|
struct OpenSubdiv_Buffer *patch_map_quadtree,
|
|
|
|
int *min_patch_face,
|
|
|
|
int *max_patch_face,
|
|
|
|
int *max_depth,
|
|
|
|
int *patches_are_triangular);
|
|
|
|
|
|
|
|
// Fill the given buffer with data from the evaluator's patch array buffer.
|
|
|
|
void (*fillPatchArraysBuffer)(struct OpenSubdiv_Evaluator *evaluator,
|
|
|
|
struct OpenSubdiv_Buffer *patch_array_buffer);
|
|
|
|
|
|
|
|
// Fill the given buffer with data from the evaluator's patch index buffer.
|
|
|
|
void (*wrapPatchIndexBuffer)(struct OpenSubdiv_Evaluator *evaluator,
|
|
|
|
struct OpenSubdiv_Buffer *patch_index_buffer);
|
|
|
|
|
|
|
|
// Fill the given buffer with data from the evaluator's patch parameter buffer.
|
|
|
|
void (*wrapPatchParamBuffer)(struct OpenSubdiv_Evaluator *evaluator,
|
|
|
|
struct OpenSubdiv_Buffer *patch_param_buffer);
|
|
|
|
|
|
|
|
// Fill the given buffer with data from the evaluator's source buffer.
|
|
|
|
void (*wrapSrcBuffer)(struct OpenSubdiv_Evaluator *evaluator,
|
|
|
|
struct OpenSubdiv_Buffer *src_buffer);
|
|
|
|
|
2022-05-22 07:19:55 +00:00
|
|
|
// Fill the given buffer with data from the evaluator's extra source buffer.
|
|
|
|
void (*wrapSrcVertexDataBuffer)(struct OpenSubdiv_Evaluator *evaluator,
|
|
|
|
struct OpenSubdiv_Buffer *src_buffer);
|
|
|
|
|
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 15:34:47 +00:00
|
|
|
// Fill the given buffer with data from the evaluator's face varying patch array buffer.
|
|
|
|
void (*fillFVarPatchArraysBuffer)(struct OpenSubdiv_Evaluator *evaluator,
|
|
|
|
const int face_varying_channel,
|
|
|
|
struct OpenSubdiv_Buffer *patch_array_buffer);
|
|
|
|
|
|
|
|
// Fill the given buffer with data from the evaluator's face varying patch index buffer.
|
|
|
|
void (*wrapFVarPatchIndexBuffer)(struct OpenSubdiv_Evaluator *evaluator,
|
|
|
|
const int face_varying_channel,
|
|
|
|
struct OpenSubdiv_Buffer *patch_index_buffer);
|
|
|
|
|
|
|
|
// Fill the given buffer with data from the evaluator's face varying patch parameter buffer.
|
|
|
|
void (*wrapFVarPatchParamBuffer)(struct OpenSubdiv_Evaluator *evaluator,
|
|
|
|
const int face_varying_channel,
|
|
|
|
struct OpenSubdiv_Buffer *patch_param_buffer);
|
|
|
|
|
|
|
|
// Fill the given buffer with data from the evaluator's face varying source buffer.
|
|
|
|
void (*wrapFVarSrcBuffer)(struct OpenSubdiv_Evaluator *evaluator,
|
|
|
|
const int face_varying_channel,
|
|
|
|
struct OpenSubdiv_Buffer *src_buffer);
|
|
|
|
|
2022-05-22 07:19:55 +00:00
|
|
|
// Return true if the evaluator has source vertex data set.
|
|
|
|
bool (*hasVertexData)(struct OpenSubdiv_Evaluator *evaluator);
|
|
|
|
|
2020-05-19 08:46:42 +00:00
|
|
|
// Implementation of the evaluator.
|
|
|
|
struct OpenSubdiv_EvaluatorImpl *impl;
|
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 15:34:47 +00:00
|
|
|
|
|
|
|
// Type of the evaluator.
|
|
|
|
eOpenSubdivEvaluator type;
|
OpenSubdiv: Re-work C-API integration
Main goal is to make API simpler to follow (at least ion terms what
is defined/declared where, as opposite of handful big headers which
includes all the declarations), and also avoid a big set of long and
obscure functions.
Now C-API files are split into smaller ones, following OpenSubdiv
behavior more closely, and also function pointers in structures
used a lot more, which shortens functions names,
UV integration part in GL Mesh is mainly stripped away, it needs
to be done differently. On a related topic, UV coordinates API in
converter needs to be removed as well, we do not need coordinates,
only island connectivity information there.
Additional changes:
- Varying interpolation in evaluator API are temporarily disabled,
need to extend API somewhere (probably, evaluator's API) to inform
layout information of vertex data (whether it contains varying
data, width, stride and such).
- Evaluator now can interpolate face-varying data.
Only works for adaptive refiner, since some issues in OpenSubdiv
itself.
Planned changes:
- Remove uv coordinates from TopologyConverter.
- Support evaluation of patches (as opposite to individual coordinates
as it happens currently).
- Support more flexible layout of varying and face-varying data.
It is stupid to assume varying is 3 floats and face-varying 2 floats.
- Support of second order derivatives.
- Everything else what i'm missing in this list.
2018-07-16 07:28:05 +00:00
|
|
|
} OpenSubdiv_Evaluator;
|
|
|
|
|
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 15:34:47 +00:00
|
|
|
typedef struct OpenSubdiv_EvaluatorCache {
|
|
|
|
// Implementation of the evaluator cache.
|
|
|
|
struct OpenSubdiv_EvaluatorCacheImpl *impl;
|
|
|
|
} OpenSubdiv_EvaluatorCache;
|
|
|
|
|
OpenSubdiv: Re-work C-API integration
Main goal is to make API simpler to follow (at least ion terms what
is defined/declared where, as opposite of handful big headers which
includes all the declarations), and also avoid a big set of long and
obscure functions.
Now C-API files are split into smaller ones, following OpenSubdiv
behavior more closely, and also function pointers in structures
used a lot more, which shortens functions names,
UV integration part in GL Mesh is mainly stripped away, it needs
to be done differently. On a related topic, UV coordinates API in
converter needs to be removed as well, we do not need coordinates,
only island connectivity information there.
Additional changes:
- Varying interpolation in evaluator API are temporarily disabled,
need to extend API somewhere (probably, evaluator's API) to inform
layout information of vertex data (whether it contains varying
data, width, stride and such).
- Evaluator now can interpolate face-varying data.
Only works for adaptive refiner, since some issues in OpenSubdiv
itself.
Planned changes:
- Remove uv coordinates from TopologyConverter.
- Support evaluation of patches (as opposite to individual coordinates
as it happens currently).
- Support more flexible layout of varying and face-varying data.
It is stupid to assume varying is 3 floats and face-varying 2 floats.
- Support of second order derivatives.
- Everything else what i'm missing in this list.
2018-07-16 07:28:05 +00:00
|
|
|
OpenSubdiv_Evaluator *openSubdiv_createEvaluatorFromTopologyRefiner(
|
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 15:34:47 +00:00
|
|
|
struct OpenSubdiv_TopologyRefiner *topology_refiner,
|
|
|
|
eOpenSubdivEvaluator evaluator_type,
|
2022-05-30 11:28:38 +00:00
|
|
|
OpenSubdiv_EvaluatorCache *evaluator_cache);
|
OpenSubdiv: Re-work C-API integration
Main goal is to make API simpler to follow (at least ion terms what
is defined/declared where, as opposite of handful big headers which
includes all the declarations), and also avoid a big set of long and
obscure functions.
Now C-API files are split into smaller ones, following OpenSubdiv
behavior more closely, and also function pointers in structures
used a lot more, which shortens functions names,
UV integration part in GL Mesh is mainly stripped away, it needs
to be done differently. On a related topic, UV coordinates API in
converter needs to be removed as well, we do not need coordinates,
only island connectivity information there.
Additional changes:
- Varying interpolation in evaluator API are temporarily disabled,
need to extend API somewhere (probably, evaluator's API) to inform
layout information of vertex data (whether it contains varying
data, width, stride and such).
- Evaluator now can interpolate face-varying data.
Only works for adaptive refiner, since some issues in OpenSubdiv
itself.
Planned changes:
- Remove uv coordinates from TopologyConverter.
- Support evaluation of patches (as opposite to individual coordinates
as it happens currently).
- Support more flexible layout of varying and face-varying data.
It is stupid to assume varying is 3 floats and face-varying 2 floats.
- Support of second order derivatives.
- Everything else what i'm missing in this list.
2018-07-16 07:28:05 +00:00
|
|
|
|
|
|
|
void openSubdiv_deleteEvaluator(OpenSubdiv_Evaluator *evaluator);
|
|
|
|
|
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 15:34:47 +00:00
|
|
|
OpenSubdiv_EvaluatorCache *openSubdiv_createEvaluatorCache(eOpenSubdivEvaluator evaluator_type);
|
|
|
|
|
|
|
|
void openSubdiv_deleteEvaluatorCache(OpenSubdiv_EvaluatorCache *evaluator_cache);
|
|
|
|
|
|
|
|
// Return the GLSL source code from the OpenSubDiv library used for patch evaluation.
|
|
|
|
// This function is not thread-safe.
|
|
|
|
const char *openSubdiv_getGLSLPatchBasisSource(void);
|
|
|
|
|
OpenSubdiv: Re-work C-API integration
Main goal is to make API simpler to follow (at least ion terms what
is defined/declared where, as opposite of handful big headers which
includes all the declarations), and also avoid a big set of long and
obscure functions.
Now C-API files are split into smaller ones, following OpenSubdiv
behavior more closely, and also function pointers in structures
used a lot more, which shortens functions names,
UV integration part in GL Mesh is mainly stripped away, it needs
to be done differently. On a related topic, UV coordinates API in
converter needs to be removed as well, we do not need coordinates,
only island connectivity information there.
Additional changes:
- Varying interpolation in evaluator API are temporarily disabled,
need to extend API somewhere (probably, evaluator's API) to inform
layout information of vertex data (whether it contains varying
data, width, stride and such).
- Evaluator now can interpolate face-varying data.
Only works for adaptive refiner, since some issues in OpenSubdiv
itself.
Planned changes:
- Remove uv coordinates from TopologyConverter.
- Support evaluation of patches (as opposite to individual coordinates
as it happens currently).
- Support more flexible layout of varying and face-varying data.
It is stupid to assume varying is 3 floats and face-varying 2 floats.
- Support of second order derivatives.
- Everything else what i'm missing in this list.
2018-07-16 07:28:05 +00:00
|
|
|
#ifdef __cplusplus
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#endif // OPENSUBDIV_EVALUATOR_CAPI_H_
|