9#include <opensubdiv/far/error.h>
10#include <opensubdiv/far/patchDescriptor.h>
11#include <opensubdiv/far/stencilTable.h>
27using OpenSubdiv::Far::LimitStencilTable;
28using OpenSubdiv::Far::StencilTable;
29using OpenSubdiv::Osd::BufferDescriptor;
30using OpenSubdiv::Osd::PatchArray;
31using OpenSubdiv::Osd::PatchArrayVector;
36#define SHADER_SRC_VERTEX_BUFFER_BUF_SLOT 0
37#define SHADER_DST_VERTEX_BUFFER_BUF_SLOT 1
38#define SHADER_DU_BUFFER_BUF_SLOT 2
39#define SHADER_DV_BUFFER_BUF_SLOT 3
40#define SHADER_SIZES_BUF_SLOT 4
41#define SHADER_OFFSETS_BUF_SLOT 5
42#define SHADER_INDICES_BUF_SLOT 6
43#define SHADER_WEIGHTS_BUF_SLOT 7
44#define SHADER_DU_WEIGHTS_BUF_SLOT 8
45#define SHADER_DV_WEIGHTS_BUF_SLOT 9
47#define SHADER_PATCH_ARRAY_BUFFER_BUF_SLOT 4
48#define SHADER_PATCH_COORDS_BUF_SLOT 5
49#define SHADER_PATCH_INDEX_BUFFER_BUF_SLOT 6
50#define SHADER_PATCH_PARAM_BUFFER_BUF_SLOT 7
60 const size_t buffer_size = src.size() *
sizeof(
T);
64 return storage_buffer;
69 _numStencils = stencilTable->GetNumStencils();
70 if (_numStencils > 0) {
71 sizes_buf =
create_buffer(stencilTable->GetSizes(),
"osd_sized");
72 offsets_buf =
create_buffer(stencilTable->GetOffsets(),
"osd_offsets");
73 indices_buf =
create_buffer(stencilTable->GetControlIndices(),
"osd_control_indices");
74 weights_buf =
create_buffer(stencilTable->GetWeights(),
"osd_weights");
80 _numStencils = limitStencilTable->GetNumStencils();
81 if (_numStencils > 0) {
82 sizes_buf =
create_buffer(limitStencilTable->GetSizes(),
"osd_sized");
83 offsets_buf =
create_buffer(limitStencilTable->GetOffsets(),
"osd_offsets");
84 indices_buf =
create_buffer(limitStencilTable->GetControlIndices(),
"osd_control_indices");
85 weights_buf =
create_buffer(limitStencilTable->GetWeights(),
"osd_weights");
86 du_weights_buf =
create_buffer(limitStencilTable->GetDuWeights(),
"osd_du_weights");
87 dv_weights_buf =
create_buffer(limitStencilTable->GetDvWeights(),
"osd_dv_weights");
88 duu_weights_buf =
create_buffer(limitStencilTable->GetDuuWeights(),
"osd_duu_weights");
89 duv_weights_buf =
create_buffer(limitStencilTable->GetDuvWeights(),
"osd_duv_weights");
90 dvv_weights_buf =
create_buffer(limitStencilTable->GetDvvWeights(),
"osd_dvv_weights");
119 memset((
void *)&_stencilKernel, 0,
sizeof(_stencilKernel));
120 memset((
void *)&_patchKernel, 0,
sizeof(_patchKernel));
125 if (_patchArraysSSBO) {
127 _patchArraysSSBO =
nullptr;
132 BufferDescriptor
const &dstDesc,
133 BufferDescriptor
const &duDesc,
134 BufferDescriptor
const &dvDesc)
137 if (!_stencilKernel.Compile(srcDesc, dstDesc, duDesc, dvDesc, _workGroupSize)) {
141 if (!_patchKernel.Compile(srcDesc, dstDesc, duDesc, dvDesc, _workGroupSize)) {
156int GPUComputeEvaluator::GetDispatchSize(
int count)
const
158 return (count + _workGroupSize - 1) / _workGroupSize;
162 int totalDispatchSize)
const
164 const int dispatchSize = GetDispatchSize(totalDispatchSize);
165 int dispatchRX = dispatchSize;
175 dispatchRX = dispatchRY = std::ceil(std::sqrt(dispatchSize));
177 if ((dispatchRX * (dispatchRY - 1)) >= dispatchSize) {
194 BufferDescriptor
const &srcDesc,
195 gpu::VertBuf *dstBuffer,
196 BufferDescriptor
const &dstDesc,
197 gpu::VertBuf *duBuffer,
198 BufferDescriptor
const &duDesc,
199 gpu::VertBuf *dvBuffer,
200 BufferDescriptor
const &dvDesc,
201 gpu::StorageBuf *sizesBuffer,
202 gpu::StorageBuf *offsetsBuffer,
203 gpu::StorageBuf *indicesBuffer,
204 gpu::StorageBuf *weightsBuffer,
205 gpu::StorageBuf *duWeightsBuffer,
206 gpu::StorageBuf *dvWeightsBuffer,
210 if (_stencilKernel.shader ==
nullptr) {
213 int count = end - start;
231 if (duWeightsBuffer) {
234 if (dvWeightsBuffer) {
241 _stencilKernel.shader, _stencilKernel.uniformSrcOffset, 1, 1, &srcDesc.offset);
243 _stencilKernel.shader, _stencilKernel.uniformDstOffset, 1, 1, &dstDesc.offset);
247#define BIND_BUF_DESC(uniform, desc) \
248 if (_stencilKernel.uniform > 0) { \
249 int value[] = {desc.offset, desc.length, desc.stride}; \
250 GPU_shader_uniform_int_ex(_stencilKernel.shader, _stencilKernel.uniform, 3, 1, value); \
255 DispatchCompute(_stencilKernel.shader, count);
263 BufferDescriptor
const &srcDesc,
264 gpu::VertBuf *dstBuffer,
265 BufferDescriptor
const &dstDesc,
266 gpu::VertBuf *duBuffer,
267 BufferDescriptor
const &duDesc,
268 gpu::VertBuf *dvBuffer,
269 BufferDescriptor
const &dvDesc,
271 gpu::VertBuf *patchCoordsBuffer,
272 const PatchArrayVector &patchArrays,
273 gpu::StorageBuf *patchIndexBuffer,
274 gpu::StorageBuf *patchParamsBuffer)
276 if (_patchKernel.shader ==
nullptr) {
292 int patchArraySize =
sizeof(PatchArray);
293 if (_patchArraysSSBO) {
295 _patchArraysSSBO =
nullptr;
298 static_cast<const void *
>(&patchArrays[0]),
304 _patchKernel.shader, _patchKernel.uniformSrcOffset, 1, 1, &srcDesc.offset);
306 _patchKernel.shader, _patchKernel.uniformDstOffset, 1, 1, &dstDesc.offset);
309#define BIND_BUF_DESC(uniform, desc) \
310 if (_stencilKernel.uniform > 0) { \
311 int value[] = {desc.offset, desc.length, desc.stride}; \
312 GPU_shader_uniform_int_ex(_patchKernel.shader, _patchKernel.uniform, 3, 1, value); \
318 DispatchCompute(_patchKernel.shader, numPatchCoords);
325GPUComputeEvaluator::_StencilKernel::_StencilKernel() {}
326GPUComputeEvaluator::_StencilKernel::~_StencilKernel()
334 BufferDescriptor
const &dstDesc,
335 BufferDescriptor
const &duDesc,
336 BufferDescriptor
const &dvDesc,
349 std::string
length = std::to_string(srcDesc.length);
350 std::string src_stride = std::to_string(srcDesc.stride);
351 std::string dst_stride = std::to_string(dstDesc.stride);
352 std::string work_group_size = std::to_string(workGroupSize);
354 info.
define(
"SRC_STRIDE", src_stride);
355 info.
define(
"DST_STRIDE", dst_stride);
356 info.
define(
"WORK_GROUP_SIZE", work_group_size);
366 bool deriv1 = (duDesc.length > 0 || dvDesc.length > 0);
368 info.
define(
"OPENSUBDIV_GLSL_COMPUTE_USE_1ST_DERIVATIVES");
390 reinterpret_cast<const GPUShaderCreateInfo *
>(&info));
394bool GPUComputeEvaluator::_StencilKernel::Compile(BufferDescriptor
const &srcDesc,
395 BufferDescriptor
const &dstDesc,
396 BufferDescriptor
const &duDesc,
397 BufferDescriptor
const &dvDesc,
423GPUComputeEvaluator::_PatchKernel::_PatchKernel() {}
424GPUComputeEvaluator::_PatchKernel::~_PatchKernel()
433 BufferDescriptor
const &dstDesc,
434 BufferDescriptor
const &duDesc,
435 BufferDescriptor
const &dvDesc,
449 std::string
length = std::to_string(srcDesc.length);
450 std::string src_stride = std::to_string(srcDesc.stride);
451 std::string dst_stride = std::to_string(dstDesc.stride);
452 std::string work_group_size = std::to_string(workGroupSize);
454 info.
define(
"SRC_STRIDE", src_stride);
455 info.
define(
"DST_STRIDE", dst_stride);
456 info.
define(
"WORK_GROUP_SIZE", work_group_size);
466 bool deriv1 = (duDesc.length > 0 || dvDesc.length > 0);
468 info.
define(
"OPENSUBDIV_GLSL_COMPUTE_USE_1ST_DERIVATIVES");
486 reinterpret_cast<const GPUShaderCreateInfo *
>(&info));
490bool GPUComputeEvaluator::_PatchKernel::Compile(BufferDescriptor
const &srcDesc,
491 BufferDescriptor
const &dstDesc,
492 BufferDescriptor
const &duDesc,
493 BufferDescriptor
const &dvDesc,
static bool EvalPatches(SRC_BUFFER *srcBuffer, OpenSubdiv::Osd::BufferDescriptor const &srcDesc, DST_BUFFER *dstBuffer, OpenSubdiv::Osd::BufferDescriptor const &dstDesc, int numPatchCoords, PATCHCOORD_BUFFER *patchCoords, PATCH_TABLE *patchTable, GPUComputeEvaluator *instance, void *deviceContext=nullptr)
Generic limit eval function. This function has a same signature as other device kernels have so that ...
GPUComputeEvaluator()
Constructor.
bool Compile(OpenSubdiv::Osd::BufferDescriptor const &srcDesc, OpenSubdiv::Osd::BufferDescriptor const &dstDesc, OpenSubdiv::Osd::BufferDescriptor const &duDesc=OpenSubdiv::Osd::BufferDescriptor(), OpenSubdiv::Osd::BufferDescriptor const &dvDesc=OpenSubdiv::Osd::BufferDescriptor())
static void Synchronize(void *deviceContext)
Wait the dispatched kernel finishes.
~GPUComputeEvaluator()
Destructor. note that the GL context must be made current.
static bool EvalStencils(SRC_BUFFER *srcBuffer, OpenSubdiv::Osd::BufferDescriptor const &srcDesc, DST_BUFFER *dstBuffer, OpenSubdiv::Osd::BufferDescriptor const &dstDesc, STENCIL_TABLE const *stencilTable, GPUComputeEvaluator *instance, void *deviceContext=nullptr)
Generic static stencil function. This function has a same signature as other device kernels have so t...
GPUStencilTableSSBO(OpenSubdiv::Far::StencilTable const *stencilTable)
#define SHADER_SIZES_BUF_SLOT
#define SHADER_PATCH_ARRAY_BUFFER_BUF_SLOT
#define SHADER_DST_VERTEX_BUFFER_BUF_SLOT
#define SHADER_OFFSETS_BUF_SLOT
#define SHADER_DU_BUFFER_BUF_SLOT
#define SHADER_PATCH_PARAM_BUFFER_BUF_SLOT
#define SHADER_DV_BUFFER_BUF_SLOT
#define SHADER_DV_WEIGHTS_BUF_SLOT
char datatoc_osd_eval_patches_comp_glsl[]
#define SHADER_DU_WEIGHTS_BUF_SLOT
#define SHADER_WEIGHTS_BUF_SLOT
#define SHADER_PATCH_COORDS_BUF_SLOT
#define SHADER_SRC_VERTEX_BUFFER_BUF_SLOT
#define SHADER_INDICES_BUF_SLOT
#define SHADER_PATCH_INDEX_BUFFER_BUF_SLOT
#define BIND_BUF_DESC(uniform, desc)
char datatoc_osd_eval_stencils_comp_glsl[]
float length(VecOp< float, D >) RET
gpu::StorageBuf * create_buffer(std::vector< T > const &src, const char *name)
static blender::gpu::Shader * compile_eval_patches_shader(BufferDescriptor const &srcDesc, BufferDescriptor const &dstDesc, BufferDescriptor const &duDesc, BufferDescriptor const &dvDesc, int workGroupSize)
static blender::gpu::Shader * compile_eval_stencil_shader(BufferDescriptor const &srcDesc, BufferDescriptor const &dstDesc, BufferDescriptor const &duDesc, BufferDescriptor const &dvDesc, int workGroupSize)
static void storage_buffer_free(gpu::StorageBuf **buffer)
gpu::StorageBuf * GPU_storagebuf_create_ex(size_t size, const void *data, GPUUsageType usage, const char *name)
gpu::Shader * GPU_shader_create_from_info(const GPUShaderCreateInfo *_info)
void GPU_compute_dispatch(gpu::Shader *shader, uint groups_x_len, uint groups_y_len, uint groups_z_len, const gpu::shader::SpecializationConstants *constants_state=nullptr)
void GPU_shader_uniform_int_ex(gpu::Shader *shader, int location, int length, int array_size, const int *value)
void GPU_vertbuf_bind_as_ssbo(gpu::VertBuf *verts, int binding)
int GPU_max_work_group_count(int index)
void GPU_memory_barrier(GPUBarrier barrier)
void GPU_shader_bind(gpu::Shader *shader, const gpu::shader::SpecializationConstants *constants_state=nullptr)
@ GPU_BARRIER_SHADER_STORAGE
void GPU_storagebuf_bind(gpu::StorageBuf *ssbo, int slot)
int GPU_shader_get_uniform(gpu::Shader *shader, const char *name)
void GPU_shader_free(gpu::Shader *shader)
void GPU_storagebuf_free(gpu::StorageBuf *ssbo)
Describe inputs & outputs, stage interfaces, resources and sources of a shader. If all data is correc...
Self & compute_source(StringRefNull filename)
Self & typedef_source(StringRefNull filename)
Self & storage_buf(int slot, Qualifier qualifiers, StringRefNull type_name, StringRefNull name, Frequency freq=Frequency::PASS, ConditionFn cond=nullptr)
Self & builtins(BuiltinBits builtin, ConditionFn cond=nullptr)
Self & local_group_size(int local_size_x, int local_size_y=1, int local_size_z=1)
Self & define(StringRefNull name, StringRefNull value="")
Self & push_constant(Type type, StringRefNull name, int array_size=0, ConditionFn cond=nullptr)