Blender V5.3
gpu_compute_evaluator.cc
Go to the documentation of this file.
1/* SPDX-FileCopyrightText: 2025 Blender Foundation
2 *
3 * SPDX-License-Identifier: GPL-2.0-or-later */
4
5#include <epoxy/gl.h>
6
8
9#include <opensubdiv/far/error.h>
10#include <opensubdiv/far/patchDescriptor.h>
11#include <opensubdiv/far/stencilTable.h>
12
13#include <cassert>
14#include <cmath>
15#include <sstream>
16#include <string>
17#include <vector>
18
19#include "GPU_capabilities.hh"
20#include "GPU_compute.hh"
21#include "GPU_context.hh"
22#include "GPU_debug.hh"
23#include "GPU_state.hh"
24#include "GPU_vertex_buffer.hh"
26
27using OpenSubdiv::Far::LimitStencilTable;
28using OpenSubdiv::Far::StencilTable;
29using OpenSubdiv::Osd::BufferDescriptor;
30using OpenSubdiv::Osd::PatchArray;
31using OpenSubdiv::Osd::PatchArrayVector;
32
35
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
46
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
51
52namespace blender::opensubdiv {
53
54template<class T> gpu::StorageBuf *create_buffer(std::vector<T> const &src, const char *name)
55{
56 if (src.empty()) {
57 return nullptr;
58 }
59
60 const size_t buffer_size = src.size() * sizeof(T);
62 buffer_size, &src.at(0), GPU_USAGE_STATIC, name);
63
64 return storage_buffer;
65}
66
67GPUStencilTableSSBO::GPUStencilTableSSBO(StencilTable const *stencilTable)
68{
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");
75 }
76}
77
78GPUStencilTableSSBO::GPUStencilTableSSBO(LimitStencilTable const *limitStencilTable)
79{
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");
91 }
92}
93
95{
96 if (*buffer) {
97 GPU_storagebuf_free(*buffer);
98 *buffer = nullptr;
99 }
100}
101
103{
104 storage_buffer_free(&sizes_buf);
105 storage_buffer_free(&offsets_buf);
106 storage_buffer_free(&indices_buf);
107 storage_buffer_free(&weights_buf);
108 storage_buffer_free(&du_weights_buf);
109 storage_buffer_free(&dv_weights_buf);
110 storage_buffer_free(&duu_weights_buf);
111 storage_buffer_free(&duv_weights_buf);
112 storage_buffer_free(&dvv_weights_buf);
113}
114
115// ---------------------------------------------------------------------------
116
117GPUComputeEvaluator::GPUComputeEvaluator() : _workGroupSize(64), _patchArraysSSBO(nullptr)
118{
119 memset((void *)&_stencilKernel, 0, sizeof(_stencilKernel));
120 memset((void *)&_patchKernel, 0, sizeof(_patchKernel));
121}
122
124{
125 if (_patchArraysSSBO) {
126 GPU_storagebuf_free(_patchArraysSSBO);
127 _patchArraysSSBO = nullptr;
128 }
129}
130
131bool GPUComputeEvaluator::Compile(BufferDescriptor const &srcDesc,
132 BufferDescriptor const &dstDesc,
133 BufferDescriptor const &duDesc,
134 BufferDescriptor const &dvDesc)
135{
136
137 if (!_stencilKernel.Compile(srcDesc, dstDesc, duDesc, dvDesc, _workGroupSize)) {
138 return false;
139 }
140
141 if (!_patchKernel.Compile(srcDesc, dstDesc, duDesc, dvDesc, _workGroupSize)) {
142 return false;
143 }
144
145 return true;
146}
147
148/* static */
149void GPUComputeEvaluator::Synchronize(void * /*kernel*/)
150{
151 // XXX: this is currently just for the performance measuring purpose.
152 // need to be reimplemented by fence and sync.
153 GPU_finish();
154}
155
156int GPUComputeEvaluator::GetDispatchSize(int count) const
157{
158 return (count + _workGroupSize - 1) / _workGroupSize;
159}
160
161void GPUComputeEvaluator::DispatchCompute(blender::gpu::Shader *shader,
162 int totalDispatchSize) const
163{
164 const int dispatchSize = GetDispatchSize(totalDispatchSize);
165 int dispatchRX = dispatchSize;
166 int dispatchRY = 1u;
167 if (dispatchRX > GPU_max_work_group_count(0)) {
168 /* Since there are some limitations with regards to the maximum work group size (could be as
169 * low as 64k elements per call), we split the number elements into a "2d" number, with the
170 * final index being computed as `res_x + res_y * max_work_group_size`. Even with a maximum
171 * work group size of 64k, that still leaves us with roughly `64k * 64k = 4` billion elements
172 * total, which should be enough. If not, we could also use the 3rd dimension. */
173 /* TODO(fclem): We could dispatch fewer groups if we compute the prime factorization and
174 * get the smallest rect fitting the requirements. */
175 dispatchRX = dispatchRY = std::ceil(std::sqrt(dispatchSize));
176 /* Avoid a completely empty dispatch line caused by rounding. */
177 if ((dispatchRX * (dispatchRY - 1)) >= dispatchSize) {
178 dispatchRY -= 1;
179 }
180 }
181
182 /* X and Y dimensions may have different limits so the above computation may not be right, but
183 * even with the standard 64k minimum on all dimensions we still have a lot of room. Therefore,
184 * we presume it all fits. */
185 assert(dispatchRY < GPU_max_work_group_count(1));
186 GPU_compute_dispatch(shader, dispatchRX, dispatchRY, 1);
187
188 /* Next usage of the src/dst buffers will always be a shader storage. Vertices/normals/attributes
189 * are copied over to the final buffers using compute shaders. */
191}
192
193bool GPUComputeEvaluator::EvalStencils(gpu::VertBuf *srcBuffer,
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,
207 int start,
208 int end) const
209{
210 if (_stencilKernel.shader == nullptr) {
211 return false;
212 }
213 int count = end - start;
214 if (count <= 0) {
215 return true;
216 }
217
218 GPU_shader_bind(_stencilKernel.shader);
221 if (duBuffer) {
223 }
224 if (dvBuffer) {
226 }
231 if (duWeightsBuffer) {
233 }
234 if (dvWeightsBuffer) {
236 }
237
238 GPU_shader_uniform_int_ex(_stencilKernel.shader, _stencilKernel.uniformStart, 1, 1, &start);
239 GPU_shader_uniform_int_ex(_stencilKernel.shader, _stencilKernel.uniformEnd, 1, 1, &end);
241 _stencilKernel.shader, _stencilKernel.uniformSrcOffset, 1, 1, &srcDesc.offset);
243 _stencilKernel.shader, _stencilKernel.uniformDstOffset, 1, 1, &dstDesc.offset);
244
245// TODO init to -1 and check >= 0 to align with GPU module. Currently we assume that the uniform
246// location is not zero as there are other uniforms defined as well.
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); \
251 }
252 BIND_BUF_DESC(uniformDuDesc, duDesc)
253 BIND_BUF_DESC(uniformDvDesc, dvDesc)
254#undef BIND_BUF_DESC
255 DispatchCompute(_stencilKernel.shader, count);
256 // GPU_storagebuf_unbind_all();
258
259 return true;
260}
261
262bool GPUComputeEvaluator::EvalPatches(gpu::VertBuf *srcBuffer,
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,
270 int numPatchCoords,
271 gpu::VertBuf *patchCoordsBuffer,
272 const PatchArrayVector &patchArrays,
273 gpu::StorageBuf *patchIndexBuffer,
274 gpu::StorageBuf *patchParamsBuffer)
275{
276 if (_patchKernel.shader == nullptr) {
277 return false;
278 }
279
280 GPU_shader_bind(_patchKernel.shader);
283 if (duBuffer) {
285 }
286 if (dvBuffer) {
288 }
292 int patchArraySize = sizeof(PatchArray);
293 if (_patchArraysSSBO) {
294 GPU_storagebuf_free(_patchArraysSSBO);
295 _patchArraysSSBO = nullptr;
296 }
297 _patchArraysSSBO = GPU_storagebuf_create_ex(patchArrays.size() * patchArraySize,
298 static_cast<const void *>(&patchArrays[0]),
300 "osd_patch_array");
302
304 _patchKernel.shader, _patchKernel.uniformSrcOffset, 1, 1, &srcDesc.offset);
306 _patchKernel.shader, _patchKernel.uniformDstOffset, 1, 1, &dstDesc.offset);
307
308// TODO init to -1 and check >= 0 to align with GPU module.
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); \
313 }
314 BIND_BUF_DESC(uniformDuDesc, duDesc)
315 BIND_BUF_DESC(uniformDvDesc, dvDesc)
316#undef BIND_BUF_DESC
317
318 DispatchCompute(_patchKernel.shader, numPatchCoords);
320
321 return true;
322}
323// ---------------------------------------------------------------------------
324
325GPUComputeEvaluator::_StencilKernel::_StencilKernel() {}
326GPUComputeEvaluator::_StencilKernel::~_StencilKernel()
327{
328 if (shader) {
329 GPU_shader_free(shader);
330 shader = nullptr;
331 }
332}
333static blender::gpu::Shader *compile_eval_stencil_shader(BufferDescriptor const &srcDesc,
334 BufferDescriptor const &dstDesc,
335 BufferDescriptor const &duDesc,
336 BufferDescriptor const &dvDesc,
337 int workGroupSize)
338{
339 using namespace blender::gpu::shader;
340 ShaderCreateInfo info("osd_eval_stencils_comp");
341 info.local_group_size(workGroupSize, 1, 1);
344
345 // TODO: use specialization constants for src_stride, dst_stride. Not sure we can use
346 // work group size as that requires extensions. This allows us to compile less shaders and
347 // improve overall performance. Adding length as specialization constant will not work as it is
348 // used to define an array length. This is not supported by Metal.
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);
353 info.define("LENGTH", length);
354 info.define("SRC_STRIDE", src_stride);
355 info.define("DST_STRIDE", dst_stride);
356 info.define("WORK_GROUP_SIZE", work_group_size);
357 info.typedef_source("osd_patch_defines.glsl");
358 info.typedef_source("osd_patch_basis.glsl");
359 info.storage_buf(
360 SHADER_SRC_VERTEX_BUFFER_BUF_SLOT, Qualifier::read, "float", "srcVertexBuffer[]");
361 info.storage_buf(
362 SHADER_DST_VERTEX_BUFFER_BUF_SLOT, Qualifier::write, "float", "dstVertexBuffer[]");
363 info.push_constant(Type::int_t, "srcOffset");
364 info.push_constant(Type::int_t, "dstOffset");
365
366 bool deriv1 = (duDesc.length > 0 || dvDesc.length > 0);
367 if (deriv1) {
368 info.define("OPENSUBDIV_GLSL_COMPUTE_USE_1ST_DERIVATIVES");
369 info.storage_buf(SHADER_DU_BUFFER_BUF_SLOT, Qualifier::read_write, "float", "duBuffer[]");
370 info.storage_buf(SHADER_DV_BUFFER_BUF_SLOT, Qualifier::read_write, "float", "dvBuffer[]");
371 info.push_constant(Type::int3_t, "duDesc");
372 info.push_constant(Type::int3_t, "dvDesc");
373 }
374
375 info.storage_buf(SHADER_SIZES_BUF_SLOT, Qualifier::read, "int", "sizes_buf[]");
376 info.storage_buf(SHADER_OFFSETS_BUF_SLOT, Qualifier::read, "int", "offsets_buf[]");
377 info.storage_buf(SHADER_INDICES_BUF_SLOT, Qualifier::read, "int", "indices_buf[]");
378 info.storage_buf(SHADER_WEIGHTS_BUF_SLOT, Qualifier::read, "float", "weights_buf[]");
379 if (deriv1) {
380 info.storage_buf(
381 SHADER_DU_WEIGHTS_BUF_SLOT, Qualifier::read_write, "float", "du_weights_buf[]");
382 info.storage_buf(
383 SHADER_DV_WEIGHTS_BUF_SLOT, Qualifier::read_write, "float", "dv_weights_buf[]");
384 }
385 info.push_constant(Type::int_t, "batchStart");
386 info.push_constant(Type::int_t, "batchEnd");
387
388 info.compute_source("osd_eval_stencils_comp.glsl");
390 reinterpret_cast<const GPUShaderCreateInfo *>(&info));
391 return shader;
392}
393
394bool GPUComputeEvaluator::_StencilKernel::Compile(BufferDescriptor const &srcDesc,
395 BufferDescriptor const &dstDesc,
396 BufferDescriptor const &duDesc,
397 BufferDescriptor const &dvDesc,
398 int workGroupSize)
399{
400 if (shader) {
402 shader = nullptr;
403 }
404
405 shader = compile_eval_stencil_shader(srcDesc, dstDesc, duDesc, dvDesc, workGroupSize);
406 if (shader == nullptr) {
407 return false;
408 }
409
410 // cache uniform locations (TODO: use uniform block)
411 uniformStart = GPU_shader_get_uniform(shader, "batchStart");
412 uniformEnd = GPU_shader_get_uniform(shader, "batchEnd");
413 uniformSrcOffset = GPU_shader_get_uniform(shader, "srcOffset");
414 uniformDstOffset = GPU_shader_get_uniform(shader, "dstOffset");
415 uniformDuDesc = GPU_shader_get_uniform(shader, "duDesc");
416 uniformDvDesc = GPU_shader_get_uniform(shader, "dvDesc");
417
418 return true;
419}
420
421// ---------------------------------------------------------------------------
422
423GPUComputeEvaluator::_PatchKernel::_PatchKernel() {}
424GPUComputeEvaluator::_PatchKernel::~_PatchKernel()
425{
426 if (shader) {
427 GPU_shader_free(shader);
428 shader = nullptr;
429 }
430}
431
432static blender::gpu::Shader *compile_eval_patches_shader(BufferDescriptor const &srcDesc,
433 BufferDescriptor const &dstDesc,
434 BufferDescriptor const &duDesc,
435 BufferDescriptor const &dvDesc,
436 int workGroupSize)
437{
438 using namespace blender::gpu::shader;
439 ShaderCreateInfo info("osd_eval_patches_comp");
440 info.local_group_size(workGroupSize, 1, 1);
444
445 // TODO: use specialization constants for src_stride, dst_stride. Not sure we can use
446 // work group size as that requires extensions. This allows us to compile less shaders and
447 // improve overall performance. Adding length as specialization constant will not work as it is
448 // used to define an array length. This is not supported by Metal.
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);
453 info.define("LENGTH", length);
454 info.define("SRC_STRIDE", src_stride);
455 info.define("DST_STRIDE", dst_stride);
456 info.define("WORK_GROUP_SIZE", work_group_size);
457 info.typedef_source("osd_patch_defines.glsl");
458 info.typedef_source("osd_patch_basis.glsl");
459 info.storage_buf(
460 SHADER_SRC_VERTEX_BUFFER_BUF_SLOT, Qualifier::read, "float", "srcVertexBuffer[]");
461 info.storage_buf(
462 SHADER_DST_VERTEX_BUFFER_BUF_SLOT, Qualifier::write, "float", "dstVertexBuffer[]");
463 info.push_constant(Type::int_t, "srcOffset");
464 info.push_constant(Type::int_t, "dstOffset");
465
466 bool deriv1 = (duDesc.length > 0 || dvDesc.length > 0);
467 if (deriv1) {
468 info.define("OPENSUBDIV_GLSL_COMPUTE_USE_1ST_DERIVATIVES");
469 info.storage_buf(SHADER_DU_BUFFER_BUF_SLOT, Qualifier::read_write, "float", "duBuffer[]");
470 info.storage_buf(SHADER_DV_BUFFER_BUF_SLOT, Qualifier::read_write, "float", "dvBuffer[]");
471 info.push_constant(Type::int3_t, "duDesc");
472 info.push_constant(Type::int3_t, "dvDesc");
473 }
474
475 info.storage_buf(
476 SHADER_PATCH_ARRAY_BUFFER_BUF_SLOT, Qualifier::read, "OsdPatchArray", "patchArrayBuffer[]");
477 info.storage_buf(
478 SHADER_PATCH_COORDS_BUF_SLOT, Qualifier::read, "OsdPatchCoord", "patchCoords[]");
479 info.storage_buf(
480 SHADER_PATCH_INDEX_BUFFER_BUF_SLOT, Qualifier::read, "int", "patchIndexBuffer[]");
481 info.storage_buf(
482 SHADER_PATCH_PARAM_BUFFER_BUF_SLOT, Qualifier::read, "OsdPatchParam", "patchParamBuffer[]");
483
484 info.compute_source("osd_eval_patches_comp.glsl");
486 reinterpret_cast<const GPUShaderCreateInfo *>(&info));
487 return shader;
488}
489
490bool GPUComputeEvaluator::_PatchKernel::Compile(BufferDescriptor const &srcDesc,
491 BufferDescriptor const &dstDesc,
492 BufferDescriptor const &duDesc,
493 BufferDescriptor const &dvDesc,
494 int workGroupSize)
495{
496 if (shader) {
498 shader = nullptr;
499 }
500
501 shader = compile_eval_patches_shader(srcDesc, dstDesc, duDesc, dvDesc, workGroupSize);
502 if (shader == nullptr) {
503 return false;
504 }
505
506 // cache uniform locations
507 uniformSrcOffset = GPU_shader_get_uniform(shader, "srcOffset");
508 uniformDstOffset = GPU_shader_get_uniform(shader, "dstOffset");
509 uniformDuDesc = GPU_shader_get_uniform(shader, "duDesc");
510 uniformDvDesc = GPU_shader_get_uniform(shader, "dvDesc");
511
512 return true;
513}
514
515} // namespace blender::opensubdiv
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 ...
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
#define T
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)
Definition gpu_state.cc:305
void GPU_shader_unbind()
void GPU_shader_bind(gpu::Shader *shader, const gpu::shader::SpecializationConstants *constants_state=nullptr)
@ GPU_BARRIER_SHADER_STORAGE
Definition GPU_state.hh:51
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)
void GPU_finish()
Definition gpu_state.cc:289
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)