griefith/test
1
0
Fork 0
Code Issues Pull Requests Actions 1 Packages Projects Releases Wiki Activity

Cleanup: Subdiv: Remove 2nd derivatives

Browse Source 
2nd derivatives aren't used within Blender but all
logic branches end up with checking for it. This PR
removes the 2nd derivatives from the code so we
can skip this test.

Pull Request: https://projects.blender.org/blender/blender/pulls/135745
This commit is contained in:
Jeroen Bakker
2025-03-11 09:26:35 +01:00
parent 05c7fb1eae
commit 96c9f480b3
4 changed files with 16 additions and 1328 deletions
Download Patch File Download Diff File Expand all files Collapse all files

202
intern/opensubdiv/internal/evaluator/gpu_compute_evaluator.cc
View File

@@ -41,12 +41,6 @@ using OpenSubdiv::Osd::PatchArrayVector;
#define SHADER_WEIGHTS_BUF_SLOT 7
#define SHADER_DU_WEIGHTS_BUF_SLOT 8
#define SHADER_DV_WEIGHTS_BUF_SLOT 9
#define SHADER_DUU_BUFFER_BUF_SLOT 10
#define SHADER_DUV_BUFFER_BUF_SLOT 11
#define SHADER_DVV_BUFFER_BUF_SLOT 12
#define SHADER_DUU_WEIGHTS_BUF_SLOT 13
#define SHADER_DUV_WEIGHTS_BUF_SLOT 14
#define SHADER_DVV_WEIGHTS_BUF_SLOT 15
#define SHADER_PATCH_ARRAY_BUFFER_BUF_SLOT 4
#define SHADER_PATCH_COORDS_BUF_SLOT 5
@@ -138,21 +132,14 @@ GPUComputeEvaluator::~GPUComputeEvaluator()
bool GPUComputeEvaluator::Compile(BufferDescriptor const &srcDesc,
BufferDescriptor const &dstDesc,
BufferDescriptor const &duDesc,
BufferDescriptor const &dvDesc,
BufferDescriptor const &duuDesc,
BufferDescriptor const &duvDesc,
BufferDescriptor const &dvvDesc)
BufferDescriptor const &dvDesc)
{
if (!_stencilKernel.Compile(
srcDesc, dstDesc, duDesc, dvDesc, duuDesc, duvDesc, dvvDesc, _workGroupSize))
{
if (!_stencilKernel.Compile(srcDesc, dstDesc, duDesc, dvDesc, _workGroupSize)) {
return false;
}
if (!_patchKernel.Compile(
srcDesc, dstDesc, duDesc, dvDesc, duuDesc, duvDesc, dvvDesc, _workGroupSize))
{
if (!_patchKernel.Compile(srcDesc, dstDesc, duDesc, dvDesc, _workGroupSize)) {
return false;
}
@@ -220,61 +207,6 @@ bool GPUComputeEvaluator::EvalStencils(gpu::VertBuf *srcBuffer,
int start,
int end) const
{
return EvalStencils(srcBuffer,
srcDesc,
dstBuffer,
dstDesc,
duBuffer,
duDesc,
dvBuffer,
dvDesc,
nullptr,
BufferDescriptor(),
nullptr,
BufferDescriptor(),
nullptr,
BufferDescriptor(),
sizesBuffer,
offsetsBuffer,
indicesBuffer,
weightsBuffer,
duWeightsBuffer,
dvWeightsBuffer,
nullptr,
nullptr,
nullptr,
start,
end);
}
bool GPUComputeEvaluator::EvalStencils(gpu::VertBuf *srcBuffer,
BufferDescriptor const &srcDesc,
gpu::VertBuf *dstBuffer,
BufferDescriptor const &dstDesc,
gpu::VertBuf *duBuffer,
BufferDescriptor const &duDesc,
gpu::VertBuf *dvBuffer,
BufferDescriptor const &dvDesc,
gpu::VertBuf *duuBuffer,
BufferDescriptor const &duuDesc,
gpu::VertBuf *duvBuffer,
BufferDescriptor const &duvDesc,
gpu::VertBuf *dvvBuffer,
BufferDescriptor const &dvvDesc,
GPUStorageBuf *sizesBuffer,
GPUStorageBuf *offsetsBuffer,
GPUStorageBuf *indicesBuffer,
GPUStorageBuf *weightsBuffer,
GPUStorageBuf *duWeightsBuffer,
GPUStorageBuf *dvWeightsBuffer,
GPUStorageBuf *duuWeightsBuffer,
GPUStorageBuf *duvWeightsBuffer,
GPUStorageBuf *dvvWeightsBuffer,
int start,
int end) const
{
if (_stencilKernel.shader == nullptr) {
return false;
}
@@ -292,15 +224,6 @@ bool GPUComputeEvaluator::EvalStencils(gpu::VertBuf *srcBuffer,
if (dvBuffer) {
GPU_vertbuf_bind_as_ssbo(dvBuffer, SHADER_DV_BUFFER_BUF_SLOT);
}
if (duuBuffer) {
GPU_vertbuf_bind_as_ssbo(duuBuffer, SHADER_DUU_BUFFER_BUF_SLOT);
}
if (duvBuffer) {
GPU_vertbuf_bind_as_ssbo(duvBuffer, SHADER_DUV_BUFFER_BUF_SLOT);
}
if (dvvBuffer) {
GPU_vertbuf_bind_as_ssbo(dvvBuffer, SHADER_DVV_BUFFER_BUF_SLOT);
}
GPU_storagebuf_bind(sizesBuffer, SHADER_SIZES_BUF_SLOT);
GPU_storagebuf_bind(offsetsBuffer, SHADER_OFFSETS_BUF_SLOT);
GPU_storagebuf_bind(indicesBuffer, SHADER_INDICES_BUF_SLOT);
@@ -311,15 +234,6 @@ bool GPUComputeEvaluator::EvalStencils(gpu::VertBuf *srcBuffer,
if (dvWeightsBuffer) {
GPU_storagebuf_bind(dvWeightsBuffer, SHADER_DV_WEIGHTS_BUF_SLOT);
}
if (duuWeightsBuffer) {
GPU_storagebuf_bind(duuWeightsBuffer, SHADER_DUU_WEIGHTS_BUF_SLOT);
}
if (duvWeightsBuffer) {
GPU_storagebuf_bind(duvWeightsBuffer, SHADER_DUV_WEIGHTS_BUF_SLOT);
}
if (dvvWeightsBuffer) {
GPU_storagebuf_bind(dvvWeightsBuffer, SHADER_DVV_WEIGHTS_BUF_SLOT);
}
GPU_shader_uniform_int_ex(_stencilKernel.shader, _stencilKernel.uniformStart, 1, 1, &start);
GPU_shader_uniform_int_ex(_stencilKernel.shader, _stencilKernel.uniformEnd, 1, 1, &end);
@@ -337,9 +251,6 @@ bool GPUComputeEvaluator::EvalStencils(gpu::VertBuf *srcBuffer,
}
BIND_BUF_DESC(uniformDuDesc, duDesc)
BIND_BUF_DESC(uniformDvDesc, dvDesc)
BIND_BUF_DESC(uniformDuuDesc, duuDesc)
BIND_BUF_DESC(uniformDuvDesc, duvDesc)
BIND_BUF_DESC(uniformDvvDesc, dvvDesc)
#undef BIND_BUF_DESC
DispatchCompute(_stencilKernel.shader, count);
// GPU_storagebuf_unbind_all();
@@ -362,49 +273,6 @@ bool GPUComputeEvaluator::EvalPatches(gpu::VertBuf *srcBuffer,
GPUStorageBuf *patchIndexBuffer,
GPUStorageBuf *patchParamsBuffer)
{
return EvalPatches(srcBuffer,
srcDesc,
dstBuffer,
dstDesc,
duBuffer,
duDesc,
dvBuffer,
dvDesc,
nullptr,
BufferDescriptor(),
nullptr,
BufferDescriptor(),
nullptr,
BufferDescriptor(),
numPatchCoords,
patchCoordsBuffer,
patchArrays,
patchIndexBuffer,
patchParamsBuffer);
}
bool GPUComputeEvaluator::EvalPatches(gpu::VertBuf *srcBuffer,
BufferDescriptor const &srcDesc,
gpu::VertBuf *dstBuffer,
BufferDescriptor const &dstDesc,
gpu::VertBuf *duBuffer,
BufferDescriptor const &duDesc,
gpu::VertBuf *dvBuffer,
BufferDescriptor const &dvDesc,
gpu::VertBuf *duuBuffer,
BufferDescriptor const &duuDesc,
gpu::VertBuf *duvBuffer,
BufferDescriptor const &duvDesc,
gpu::VertBuf *dvvBuffer,
BufferDescriptor const &dvvDesc,
int numPatchCoords,
gpu::VertBuf *patchCoordsBuffer,
const PatchArrayVector &patchArrays,
GPUStorageBuf *patchIndexBuffer,
GPUStorageBuf *patchParamsBuffer)
{
if (_patchKernel.shader == nullptr) {
return false;
}
@@ -418,15 +286,6 @@ bool GPUComputeEvaluator::EvalPatches(gpu::VertBuf *srcBuffer,
if (dvBuffer) {
GPU_vertbuf_bind_as_ssbo(dvBuffer, SHADER_DV_BUFFER_BUF_SLOT);
}
if (duuBuffer) {
GPU_vertbuf_bind_as_ssbo(duuBuffer, SHADER_DUU_BUFFER_BUF_SLOT);
}
if (duvBuffer) {
GPU_vertbuf_bind_as_ssbo(duvBuffer, SHADER_DUV_BUFFER_BUF_SLOT);
}
if (dvvBuffer) {
GPU_vertbuf_bind_as_ssbo(dvvBuffer, SHADER_DVV_BUFFER_BUF_SLOT);
}
GPU_vertbuf_bind_as_ssbo(patchCoordsBuffer, SHADER_PATCH_COORDS_BUF_SLOT);
GPU_storagebuf_bind(patchIndexBuffer, SHADER_PATCH_INDEX_BUFFER_BUF_SLOT);
GPU_storagebuf_bind(patchParamsBuffer, SHADER_PATCH_PARAM_BUFFER_BUF_SLOT);
@@ -454,9 +313,6 @@ bool GPUComputeEvaluator::EvalPatches(gpu::VertBuf *srcBuffer,
}
BIND_BUF_DESC(uniformDuDesc, duDesc)
BIND_BUF_DESC(uniformDvDesc, dvDesc)
BIND_BUF_DESC(uniformDuuDesc, duuDesc)
BIND_BUF_DESC(uniformDuvDesc, duvDesc)
BIND_BUF_DESC(uniformDvvDesc, dvvDesc)
#undef BIND_BUF_DESC
DispatchCompute(_patchKernel.shader, numPatchCoords);
@@ -478,9 +334,6 @@ static GPUShader *compile_eval_stencil_shader(BufferDescriptor const &srcDesc,
BufferDescriptor const &dstDesc,
BufferDescriptor const &duDesc,
BufferDescriptor const &dvDesc,
BufferDescriptor const &duuDesc,
BufferDescriptor const &duvDesc,
BufferDescriptor const &dvvDesc,
int workGroupSize)
{
using namespace blender::gpu::shader;
@@ -514,7 +367,6 @@ static GPUShader *compile_eval_stencil_shader(BufferDescriptor const &srcDesc,
info.push_constant(Type::INT, "dstOffset");
bool deriv1 = (duDesc.length > 0 || dvDesc.length > 0);
bool deriv2 = (duuDesc.length > 0 || duvDesc.length > 0 || dvvDesc.length > 0);
if (deriv1) {
info.define("OPENSUBDIV_GLSL_COMPUTE_USE_1ST_DERIVATIVES");
info.storage_buf(SHADER_DU_BUFFER_BUF_SLOT, Qualifier::READ_WRITE, "float", "duBuffer[]");
@@ -522,15 +374,6 @@ static GPUShader *compile_eval_stencil_shader(BufferDescriptor const &srcDesc,
info.push_constant(Type::IVEC3, "duDesc");
info.push_constant(Type::IVEC3, "dvDesc");
}
if (deriv2) {
info.define("OPENSUBDIV_GLSL_COMPUTE_USE_2ND_DERIVATIVES");
info.storage_buf(SHADER_DUU_BUFFER_BUF_SLOT, Qualifier::READ_WRITE, "float", "duuBuffer[]");
info.storage_buf(SHADER_DUV_BUFFER_BUF_SLOT, Qualifier::READ_WRITE, "float", "duvBuffer[]");
info.storage_buf(SHADER_DVV_BUFFER_BUF_SLOT, Qualifier::READ_WRITE, "float", "dvvBuffer[]");
info.push_constant(Type::IVEC3, "duuDesc");
info.push_constant(Type::IVEC3, "duvDesc");
info.push_constant(Type::IVEC3, "dvvDesc");
}
info.storage_buf(SHADER_SIZES_BUF_SLOT, Qualifier::READ, "int", "sizes_buf[]");
info.storage_buf(SHADER_OFFSETS_BUF_SLOT, Qualifier::READ, "int", "offsets_buf[]");
@@ -542,14 +385,6 @@ static GPUShader *compile_eval_stencil_shader(BufferDescriptor const &srcDesc,
info.storage_buf(
SHADER_DV_WEIGHTS_BUF_SLOT, Qualifier::READ_WRITE, "float", "dv_weights_buf[]");
}
if (deriv2) {
info.storage_buf(
SHADER_DUU_WEIGHTS_BUF_SLOT, Qualifier::READ_WRITE, "float", "duu_weights_buf[]");
info.storage_buf(
SHADER_DUV_WEIGHTS_BUF_SLOT, Qualifier::READ_WRITE, "float", "duv_weights_buf[]");
info.storage_buf(
SHADER_DVV_WEIGHTS_BUF_SLOT, Qualifier::READ_WRITE, "float", "dvv_weights_buf[]");
}
info.push_constant(Type::INT, "batchStart");
info.push_constant(Type::INT, "batchEnd");
@@ -563,9 +398,6 @@ bool GPUComputeEvaluator::_StencilKernel::Compile(BufferDescriptor const &srcDes
BufferDescriptor const &dstDesc,
BufferDescriptor const &duDesc,
BufferDescriptor const &dvDesc,
BufferDescriptor const &duuDesc,
BufferDescriptor const &duvDesc,
BufferDescriptor const &dvvDesc,
int workGroupSize)
{
if (shader) {
@@ -573,8 +405,7 @@ bool GPUComputeEvaluator::_StencilKernel::Compile(BufferDescriptor const &srcDes
shader = nullptr;
}
shader = compile_eval_stencil_shader(
srcDesc, dstDesc, duDesc, dvDesc, duuDesc, duvDesc, dvvDesc, workGroupSize);
shader = compile_eval_stencil_shader(srcDesc, dstDesc, duDesc, dvDesc, workGroupSize);
if (shader == nullptr) {
return false;
}
@@ -586,9 +417,6 @@ bool GPUComputeEvaluator::_StencilKernel::Compile(BufferDescriptor const &srcDes
uniformDstOffset = GPU_shader_get_uniform(shader, "dstOffset");
uniformDuDesc = GPU_shader_get_uniform(shader, "duDesc");
uniformDvDesc = GPU_shader_get_uniform(shader, "dvDesc");
uniformDuuDesc = GPU_shader_get_uniform(shader, "duuDesc");
uniformDuvDesc = GPU_shader_get_uniform(shader, "duvDesc");
uniformDvvDesc = GPU_shader_get_uniform(shader, "dvvDesc");
return true;
}
@@ -608,9 +436,6 @@ static GPUShader *compile_eval_patches_shader(BufferDescriptor const &srcDesc,
BufferDescriptor const &dstDesc,
BufferDescriptor const &duDesc,
BufferDescriptor const &dvDesc,
BufferDescriptor const &duuDesc,
BufferDescriptor const &duvDesc,
BufferDescriptor const &dvvDesc,
int workGroupSize)
{
using namespace blender::gpu::shader;
@@ -644,7 +469,6 @@ static GPUShader *compile_eval_patches_shader(BufferDescriptor const &srcDesc,
info.push_constant(Type::INT, "dstOffset");
bool deriv1 = (duDesc.length > 0 || dvDesc.length > 0);
bool deriv2 = (duuDesc.length > 0 || duvDesc.length > 0 || dvvDesc.length > 0);
if (deriv1) {
info.define("OPENSUBDIV_GLSL_COMPUTE_USE_1ST_DERIVATIVES");
info.storage_buf(SHADER_DU_BUFFER_BUF_SLOT, Qualifier::READ_WRITE, "float", "duBuffer[]");
@@ -652,15 +476,6 @@ static GPUShader *compile_eval_patches_shader(BufferDescriptor const &srcDesc,
info.push_constant(Type::IVEC3, "duDesc");
info.push_constant(Type::IVEC3, "dvDesc");
}
if (deriv2) {
info.define("OPENSUBDIV_GLSL_COMPUTE_USE_2ND_DERIVATIVES");
info.storage_buf(SHADER_DUU_BUFFER_BUF_SLOT, Qualifier::READ_WRITE, "float", "duuBuffer[]");
info.storage_buf(SHADER_DUV_BUFFER_BUF_SLOT, Qualifier::READ_WRITE, "float", "duvBuffer[]");
info.storage_buf(SHADER_DVV_BUFFER_BUF_SLOT, Qualifier::READ_WRITE, "float", "dvvBuffer[]");
info.push_constant(Type::IVEC3, "duuDesc");
info.push_constant(Type::IVEC3, "duvDesc");
info.push_constant(Type::IVEC3, "dvvDesc");
}
info.storage_buf(
SHADER_PATCH_ARRAY_BUFFER_BUF_SLOT, Qualifier::READ, "OsdPatchArray", "patchArrayBuffer[]");
@@ -681,9 +496,6 @@ bool GPUComputeEvaluator::_PatchKernel::Compile(BufferDescriptor const &srcDesc,
BufferDescriptor const &dstDesc,
BufferDescriptor const &duDesc,
BufferDescriptor const &dvDesc,
BufferDescriptor const &duuDesc,
BufferDescriptor const &duvDesc,
BufferDescriptor const &dvvDesc,
int workGroupSize)
{
if (shader) {
@@ -691,8 +503,7 @@ bool GPUComputeEvaluator::_PatchKernel::Compile(BufferDescriptor const &srcDesc,
shader = nullptr;
}
shader = compile_eval_patches_shader(
srcDesc, dstDesc, duDesc, dvDesc, duuDesc, duvDesc, dvvDesc, workGroupSize);
shader = compile_eval_patches_shader(srcDesc, dstDesc, duDesc, dvDesc, workGroupSize);
if (shader == nullptr) {
return false;
}
@@ -702,9 +513,6 @@ bool GPUComputeEvaluator::_PatchKernel::Compile(BufferDescriptor const &srcDesc,
uniformDstOffset = GPU_shader_get_uniform(shader, "dstOffset");
uniformDuDesc = GPU_shader_get_uniform(shader, "duDesc");
uniformDvDesc = GPU_shader_get_uniform(shader, "dvDesc");
uniformDuuDesc = GPU_shader_get_uniform(shader, "duuDesc");
uniformDuvDesc = GPU_shader_get_uniform(shader, "duvDesc");
uniformDvvDesc = GPU_shader_get_uniform(shader, "dvvDesc");
return true;
}

1050
intern/opensubdiv/internal/evaluator/gpu_compute_evaluator.h
View File

@@ -104,34 +104,30 @@ class GPUStencilTableSSBO {
class GPUComputeEvaluator {
public:
using Instantiatable = bool;
/**
* Blender doesn't use 2nd derivatives, but the OSD evaluator cache does expect this constructor
* to be present.
*/
static GPUComputeEvaluator *Create(OpenSubdiv::Osd::BufferDescriptor const &srcDesc,
OpenSubdiv::Osd::BufferDescriptor const &dstDesc,
OpenSubdiv::Osd::BufferDescriptor const &duDesc,
OpenSubdiv::Osd::BufferDescriptor const &dvDesc,
OpenSubdiv::Osd::BufferDescriptor const & /*duuDesc*/,
OpenSubdiv::Osd::BufferDescriptor const & /*duvDesc*/,
OpenSubdiv::Osd::BufferDescriptor const & /*dvvDesc*/,
void *deviceContext = nullptr)
{
return Create(srcDesc,
dstDesc,
duDesc,
dvDesc,
OpenSubdiv::Osd::BufferDescriptor(),
OpenSubdiv::Osd::BufferDescriptor(),
OpenSubdiv::Osd::BufferDescriptor(),
deviceContext);
return Create(srcDesc, dstDesc, duDesc, dvDesc, deviceContext);
}
static GPUComputeEvaluator *Create(OpenSubdiv::Osd::BufferDescriptor const &srcDesc,
OpenSubdiv::Osd::BufferDescriptor const &dstDesc,
OpenSubdiv::Osd::BufferDescriptor const &duDesc,
OpenSubdiv::Osd::BufferDescriptor const &dvDesc,
OpenSubdiv::Osd::BufferDescriptor const &duuDesc,
OpenSubdiv::Osd::BufferDescriptor const &duvDesc,
OpenSubdiv::Osd::BufferDescriptor const &dvvDesc,
void *deviceContext = nullptr)
void * /*deviceContext*/ = nullptr)
{
(void)deviceContext; // not used
GPUComputeEvaluator *instance = new GPUComputeEvaluator();
if (instance->Compile(srcDesc, dstDesc, duDesc, dvDesc, duuDesc, duvDesc, dvvDesc)) {
if (instance->Compile(srcDesc, dstDesc, duDesc, dvDesc)) {
return instance;
}
delete instance;
@@ -289,126 +285,6 @@ class GPUComputeEvaluator {
return false;
}
/// \brief Generic static stencil function. This function has a same
/// signature as other device kernels have so that it can be called
/// transparently from OsdMesh template interface.
///
/// @param srcBuffer Input primvar buffer.
/// Must have `get_vertex_buffer()` returning a `gpu::VertBuf`
/// buffer object of source data
///
/// @param srcDesc vertex buffer descriptor for the input buffer
///
/// @param dstBuffer Output primvar buffer
/// Must have `get_vertex_buffer()` returning a `gpu::VertBuf`
/// buffer object of destination data
///
/// @param dstDesc vertex buffer descriptor for the dstBuffer
///
/// @param duBuffer Output buffer derivative wrt u
/// Must have `get_vertex_buffer()` returning a `gpu::VertBuf`
/// buffer object of destination data
///
/// @param duDesc vertex buffer descriptor for the duBuffer
///
/// @param dvBuffer Output buffer derivative wrt v
/// Must have `get_vertex_buffer()` returning a `gpu::VertBuf`
/// buffer object of destination data
///
/// @param dvDesc vertex buffer descriptor for the dvBuffer
///
/// @param duuBuffer Output buffer 2nd derivative wrt u
/// Must have `get_vertex_buffer()` returning a `gpu::VertBuf`
/// buffer object of destination data
///
/// @param duuDesc vertex buffer descriptor for the duuBuffer
///
/// @param duvBuffer Output buffer 2nd derivative wrt u and v
/// Must have `get_vertex_buffer()` returning a `gpu::VertBuf`
/// buffer object of destination data
///
/// @param duvDesc vertex buffer descriptor for the duvBuffer
///
/// @param dvvBuffer Output buffer 2nd derivative wrt v
/// Must have `get_vertex_buffer()` returning a `gpu::VertBuf`
/// buffer object of destination data
///
/// @param dvvDesc vertex buffer descriptor for the dvvBuffer
///
/// @param stencilTable stencil table to be applied. The table must have
/// SSBO interfaces.
///
/// @param instance cached compiled instance. Clients are supposed to
/// pre-compile an instance of this class and provide
/// to this function. If it's null the kernel still
/// compute by instantiating on-demand kernel although
/// it may cause a performance problem.
///
/// @param deviceContext not used in the GLSL kernel
///
template<typename SRC_BUFFER, typename DST_BUFFER, typename STENCIL_TABLE>
static bool EvalStencils(SRC_BUFFER *srcBuffer,
OpenSubdiv::Osd::BufferDescriptor const &srcDesc,
DST_BUFFER *dstBuffer,
OpenSubdiv::Osd::BufferDescriptor const &dstDesc,
DST_BUFFER *duBuffer,
OpenSubdiv::Osd::BufferDescriptor const &duDesc,
DST_BUFFER *dvBuffer,
OpenSubdiv::Osd::BufferDescriptor const &dvDesc,
DST_BUFFER *duuBuffer,
OpenSubdiv::Osd::BufferDescriptor const &duuDesc,
DST_BUFFER *duvBuffer,
OpenSubdiv::Osd::BufferDescriptor const &duvDesc,
DST_BUFFER *dvvBuffer,
OpenSubdiv::Osd::BufferDescriptor const &dvvDesc,
STENCIL_TABLE const *stencilTable,
GPUComputeEvaluator *instance,
void *deviceContext = nullptr)
{
if (instance) {
return instance->EvalStencils(srcBuffer,
srcDesc,
dstBuffer,
dstDesc,
duBuffer,
duDesc,
dvBuffer,
dvDesc,
duuBuffer,
duuDesc,
duvBuffer,
duvDesc,
dvvBuffer,
dvvDesc,
stencilTable);
}
// Create an instance on demand (slow)
(void)deviceContext; // unused
instance = Create(srcDesc, dstDesc, duDesc, dvDesc, duuDesc, duvDesc, dvvDesc);
if (instance) {
bool r = instance->EvalStencils(srcBuffer,
srcDesc,
dstBuffer,
dstDesc,
duBuffer,
duDesc,
dvBuffer,
dvDesc,
duuBuffer,
duuDesc,
duvBuffer,
duvDesc,
dvvBuffer,
dvvDesc,
stencilTable);
delete instance;
return r;
}
return false;
}
/// \brief Generic stencil function.
///
/// @param srcBuffer Input primvar buffer.
@@ -509,97 +385,6 @@ class GPUComputeEvaluator {
/* end = */ stencilTable->GetNumStencils());
}
/// \brief Generic stencil function.
///
/// @param srcBuffer Input primvar buffer.
/// Must have `get_vertex_buffer()` returning a `gpu::VertBuf`
/// buffer object of source data
///
/// @param srcDesc vertex buffer descriptor for the input buffer
///
/// @param dstBuffer Output primvar buffer
/// Must have `get_vertex_buffer()` returning a `gpu::VertBuf`
/// buffer object of destination data
///
/// @param dstDesc vertex buffer descriptor for the dstBuffer
///
/// @param duBuffer Output buffer derivative wrt u
/// Must have `get_vertex_buffer()` returning a `gpu::VertBuf`
/// buffer object of destination data
///
/// @param duDesc vertex buffer descriptor for the duBuffer
///
/// @param dvBuffer Output buffer derivative wrt v
/// Must have `get_vertex_buffer()` returning a `gpu::VertBuf`
/// buffer object of destination data
///
/// @param dvDesc vertex buffer descriptor for the dvBuffer
///
/// @param duuBuffer Output buffer 2nd derivative wrt u
/// Must have `get_vertex_buffer()` returning a `gpu::VertBuf`
/// buffer object of destination data
///
/// @param duuDesc vertex buffer descriptor for the duuBuffer
///
/// @param duvBuffer Output buffer 2nd derivative wrt u and v
/// Must have `get_vertex_buffer()` returning a `gpu::VertBuf`
/// buffer object of destination data
///
/// @param duvDesc vertex buffer descriptor for the duvBuffer
///
/// @param dvvBuffer Output buffer 2nd derivative wrt v
/// Must have `get_vertex_buffer()` returning a `gpu::VertBuf`
/// buffer object of destination data
///
/// @param dvvDesc vertex buffer descriptor for the dvvBuffer
///
/// @param stencilTable stencil table to be applied. The table must have
/// SSBO interfaces.
///
template<typename SRC_BUFFER, typename DST_BUFFER, typename STENCIL_TABLE>
bool EvalStencils(SRC_BUFFER *srcBuffer,
OpenSubdiv::Osd::BufferDescriptor const &srcDesc,
DST_BUFFER *dstBuffer,
OpenSubdiv::Osd::BufferDescriptor const &dstDesc,
DST_BUFFER *duBuffer,
OpenSubdiv::Osd::BufferDescriptor const &duDesc,
DST_BUFFER *dvBuffer,
OpenSubdiv::Osd::BufferDescriptor const &dvDesc,
DST_BUFFER *duuBuffer,
OpenSubdiv::Osd::BufferDescriptor const &duuDesc,
DST_BUFFER *duvBuffer,
OpenSubdiv::Osd::BufferDescriptor const &duvDesc,
DST_BUFFER *dvvBuffer,
OpenSubdiv::Osd::BufferDescriptor const &dvvDesc,
STENCIL_TABLE const *stencilTable) const
{
return EvalStencils(srcBuffer->get_vertex_buffer(),
srcDesc,
dstBuffer->get_vertex_buffer(),
dstDesc,
duBuffer->get_vertex_buffer(),
duDesc,
dvBuffer->get_vertex_buffer(),
dvDesc,
duuBuffer->get_vertex_buffer(),
duuDesc,
duvBuffer->get_vertex_buffer(),
duvDesc,
dvvBuffer->get_vertex_buffer(),
dvvDesc,
stencilTable->GetSizesBuffer(),
stencilTable->GetOffsetsBuffer(),
stencilTable->GetIndicesBuffer(),
stencilTable->GetWeightsBuffer(),
stencilTable->GetDuWeightsBuffer(),
stencilTable->GetDvWeightsBuffer(),
stencilTable->GetDuuWeightsBuffer(),
stencilTable->GetDuvWeightsBuffer(),
stencilTable->GetDvvWeightsBuffer(),
/* start = */ 0,
/* end = */ stencilTable->GetNumStencils());
}
/// \brief Dispatch the GLSL compute kernel on GPU asynchronously
/// returns false if the kernel hasn't been compiled yet.
///
@@ -652,85 +437,6 @@ class GPUComputeEvaluator {
int start,
int end) const;
/// \brief Dispatch the GLSL compute kernel on GPU asynchronously
/// returns false if the kernel hasn't been compiled yet.
///
/// @param srcBuffer GL buffer of input primvar source data
///
/// @param srcDesc vertex buffer descriptor for the srcBuffer
///
/// @param dstBuffer GL buffer of output primvar destination data
///
/// @param dstDesc vertex buffer descriptor for the dstBuffer
///
/// @param duBuffer GL buffer of output derivative wrt u
///
/// @param duDesc vertex buffer descriptor for the duBuffer
///
/// @param dvBuffer GL buffer of output derivative wrt v
///
/// @param dvDesc vertex buffer descriptor for the dvBuffer
///
/// @param duuBuffer GL buffer of output 2nd derivative wrt u
///
/// @param duuDesc vertex buffer descriptor for the duuBuffer
///
/// @param duvBuffer GL buffer of output 2nd derivative wrt u and v
///
/// @param duvDesc vertex buffer descriptor for the duvBuffer
///
/// @param dvvBuffer GL buffer of output 2nd derivative wrt v
///
/// @param dvvDesc vertex buffer descriptor for the dvvBuffer
///
/// @param sizesBuffer GL buffer of the sizes in the stencil table
///
/// @param offsetsBuffer GL buffer of the offsets in the stencil table
///
/// @param indicesBuffer GL buffer of the indices in the stencil table
///
/// @param weightsBuffer GL buffer of the weights in the stencil table
///
/// @param duWeightsBuffer GL buffer of the du weights in the stencil table
///
/// @param dvWeightsBuffer GL buffer of the dv weights in the stencil table
///
/// @param duuWeightsBuffer GL buffer of the duu weights in the stencil table
///
/// @param duvWeightsBuffer GL buffer of the duv weights in the stencil table
///
/// @param dvvWeightsBuffer GL buffer of the dvv weights in the stencil table
///
/// @param start start index of stencil table
///
/// @param end end index of stencil table
///
bool EvalStencils(gpu::VertBuf *srcBuffer,
OpenSubdiv::Osd::BufferDescriptor const &srcDesc,
gpu::VertBuf *dstBuffer,
OpenSubdiv::Osd::BufferDescriptor const &dstDesc,
gpu::VertBuf *duBuffer,
OpenSubdiv::Osd::BufferDescriptor const &duDesc,
gpu::VertBuf *dvBuffer,
OpenSubdiv::Osd::BufferDescriptor const &dvDesc,
gpu::VertBuf *duuBuffer,
OpenSubdiv::Osd::BufferDescriptor const &duuDesc,
gpu::VertBuf *duvBuffer,
OpenSubdiv::Osd::BufferDescriptor const &duvDesc,
gpu::VertBuf *dvvBuffer,
OpenSubdiv::Osd::BufferDescriptor const &dvvDesc,
GPUStorageBuf *sizesBuffer,
GPUStorageBuf *offsetsBuffer,
GPUStorageBuf *indicesBuffer,
GPUStorageBuf *weightsBuffer,
GPUStorageBuf *duWeightsBuffer,
GPUStorageBuf *dvWeightsBuffer,
GPUStorageBuf *duuWeightsBuffer,
GPUStorageBuf *duvWeightsBuffer,
GPUStorageBuf *dvvWeightsBuffer,
int start,
int end) const;
/// ----------------------------------------------------------------------
///
/// Limit evaluations with PatchTable
@@ -900,139 +606,6 @@ class GPUComputeEvaluator {
return false;
}
/// \brief Generic limit eval function. This function has a same
/// signature as other device kernels have so that it can be called
/// in the same way.
///
/// @param srcBuffer Input primvar buffer.
/// Must have `get_vertex_buffer()` returning a `gpu::VertBuf`
/// buffer object of source data
///
/// @param srcDesc vertex buffer descriptor for the input buffer
///
/// @param dstBuffer Output primvar buffer
/// Must have `get_vertex_buffer()` returning a `gpu::VertBuf`
/// buffer object of destination data
///
/// @param dstDesc vertex buffer descriptor for the output buffer
///
/// @param duBuffer Output buffer derivative wrt u
/// Must have `get_vertex_buffer()` returning a `gpu::VertBuf`
/// buffer object of destination data
///
/// @param duDesc vertex buffer descriptor for the duBuffer
///
/// @param dvBuffer Output buffer derivative wrt v
/// Must have `get_vertex_buffer()` returning a `gpu::VertBuf`
/// buffer object of destination data
///
/// @param dvDesc vertex buffer descriptor for the dvBuffer
///
/// @param duuBuffer Output buffer 2nd derivative wrt u
/// Must have `get_vertex_buffer()` returning a `gpu::VertBuf`
/// buffer object of destination data
///
/// @param duuDesc vertex buffer descriptor for the duuBuffer
///
/// @param duvBuffer Output buffer 2nd derivative wrt u and v
/// Must have `get_vertex_buffer()` returning a `gpu::VertBuf`
/// buffer object of destination data
///
/// @param duvDesc vertex buffer descriptor for the duvBuffer
///
/// @param dvvBuffer Output buffer 2nd derivative wrt v
/// Must have `get_vertex_buffer()` returning a `gpu::VertBuf`
/// buffer object of destination data
///
/// @param dvvDesc vertex buffer descriptor for the dvvBuffer
///
/// @param numPatchCoords number of patchCoords.
///
/// @param patchCoords array of locations to be evaluated.
/// must have BindVBO() method returning an
/// array of PatchCoord struct in VBO.
///
/// @param patchTable GLPatchTable or equivalent
///
/// @param instance cached compiled instance. Clients are supposed to
/// pre-compile an instance of this class and provide
/// to this function. If it's null the kernel still
/// compute by instantiating on-demand kernel although
/// it may cause a performance problem.
///
/// @param deviceContext not used in the GLXFB evaluator
///
template<typename SRC_BUFFER,
typename DST_BUFFER,
typename PATCHCOORD_BUFFER,
typename PATCH_TABLE>
static bool EvalPatches(SRC_BUFFER *srcBuffer,
OpenSubdiv::Osd::BufferDescriptor const &srcDesc,
DST_BUFFER *dstBuffer,
OpenSubdiv::Osd::BufferDescriptor const &dstDesc,
DST_BUFFER *duBuffer,
OpenSubdiv::Osd::BufferDescriptor const &duDesc,
DST_BUFFER *dvBuffer,
OpenSubdiv::Osd::BufferDescriptor const &dvDesc,
DST_BUFFER *duuBuffer,
OpenSubdiv::Osd::BufferDescriptor const &duuDesc,
DST_BUFFER *duvBuffer,
OpenSubdiv::Osd::BufferDescriptor const &duvDesc,
DST_BUFFER *dvvBuffer,
OpenSubdiv::Osd::BufferDescriptor const &dvvDesc,
int numPatchCoords,
PATCHCOORD_BUFFER *patchCoords,
PATCH_TABLE *patchTable,
GPUComputeEvaluator *instance,
void *deviceContext = nullptr)
{
if (instance) {
return instance->EvalPatches(srcBuffer,
srcDesc,
dstBuffer,
dstDesc,
duBuffer,
duDesc,
dvBuffer,
dvDesc,
duuBuffer,
duuDesc,
duvBuffer,
duvDesc,
dvvBuffer,
dvvDesc,
numPatchCoords,
patchCoords,
patchTable);
}
// Create an instance on demand (slow)
(void)deviceContext; // unused
instance = Create(srcDesc, dstDesc, duDesc, dvDesc, duuDesc, duvDesc, dvvDesc);
if (instance) {
bool r = instance->EvalPatches(srcBuffer,
srcDesc,
dstBuffer,
dstDesc,
duBuffer,
duDesc,
dvBuffer,
dvDesc,
duuBuffer,
duuDesc,
duvBuffer,
duvDesc,
dvvBuffer,
dvvDesc,
numPatchCoords,
patchCoords,
patchTable);
delete instance;
return r;
}
return false;
}
/// \brief Generic limit eval function. This function has a same
/// signature as other device kernels have so that it can be called
/// in the same way.
@@ -1151,102 +724,6 @@ class GPUComputeEvaluator {
patchTable->GetPatchParamBuffer());
}
/// \brief Generic limit eval function with derivatives. This function has
/// a same signature as other device kernels have so that it can be
/// called in the same way.
///
/// @param srcBuffer Input primvar buffer.
/// Must have `get_vertex_buffer()` returning a `gpu::VertBuf`
/// buffer object of source data
///
/// @param srcDesc vertex buffer descriptor for the input buffer
///
/// @param dstBuffer Output primvar buffer
/// Must have `get_vertex_buffer()` returning a `gpu::VertBuf`
/// buffer object of destination data
///
/// @param dstDesc vertex buffer descriptor for the output buffer
///
/// @param duBuffer Output buffer derivative wrt u
/// Must have `get_vertex_buffer()` returning a `gpu::VertBuf`
/// buffer object of destination data
///
/// @param duDesc vertex buffer descriptor for the duBuffer
///
/// @param dvBuffer Output buffer derivative wrt v
/// Must have `get_vertex_buffer()` returning a `gpu::VertBuf`
/// buffer object of destination data
///
/// @param dvDesc vertex buffer descriptor for the dvBuffer
///
/// @param duuBuffer Output buffer 2nd derivative wrt u
/// Must have `get_vertex_buffer()` returning a `gpu::VertBuf`
/// buffer object of destination data
///
/// @param duuDesc vertex buffer descriptor for the duuBuffer
///
/// @param duvBuffer Output buffer 2nd derivative wrt u and v
/// Must have `get_vertex_buffer()` returning a `gpu::VertBuf`
/// buffer object of destination data
///
/// @param duvDesc vertex buffer descriptor for the duvBuffer
///
/// @param dvvBuffer Output buffer 2nd derivative wrt v
/// Must have `get_vertex_buffer()` returning a `gpu::VertBuf`
/// buffer object of destination data
///
/// @param dvvDesc vertex buffer descriptor for the dvvBuffer
///
/// @param numPatchCoords number of patchCoords.
///
/// @param patchCoords array of locations to be evaluated.
///
/// @param patchTable GLPatchTable or equivalent
///
template<typename SRC_BUFFER,
typename DST_BUFFER,
typename PATCHCOORD_BUFFER,
typename PATCH_TABLE>
bool EvalPatches(SRC_BUFFER *srcBuffer,
OpenSubdiv::Osd::BufferDescriptor const &srcDesc,
DST_BUFFER *dstBuffer,
OpenSubdiv::Osd::BufferDescriptor const &dstDesc,
DST_BUFFER *duBuffer,
OpenSubdiv::Osd::BufferDescriptor const &duDesc,
DST_BUFFER *dvBuffer,
OpenSubdiv::Osd::BufferDescriptor const &dvDesc,
DST_BUFFER *duuBuffer,
OpenSubdiv::Osd::BufferDescriptor const &duuDesc,
DST_BUFFER *duvBuffer,
OpenSubdiv::Osd::BufferDescriptor const &duvDesc,
DST_BUFFER *dvvBuffer,
OpenSubdiv::Osd::BufferDescriptor const &dvvDesc,
int numPatchCoords,
PATCHCOORD_BUFFER *patchCoords,
PATCH_TABLE *patchTable)
{
return EvalPatches(srcBuffer->get_vertex_buffer(),
srcDesc,
dstBuffer->get_vertex_buffer(),
dstDesc,
duBuffer->get_vertex_buffer(),
duDesc,
dvBuffer->get_vertex_buffer(),
dvDesc,
duuBuffer->get_vertex_buffer(),
duuDesc,
duvBuffer->get_vertex_buffer(),
duvDesc,
dvvBuffer->get_vertex_buffer(),
dvvDesc,
numPatchCoords,
patchCoords->get_vertex_buffer(),
patchTable->GetPatchArrays(),
patchTable->GetPatchIndexBuffer(),
patchTable->GetPatchParamBuffer());
}
bool EvalPatches(gpu::VertBuf *srcBuffer,
OpenSubdiv::Osd::BufferDescriptor const &srcDesc,
gpu::VertBuf *dstBuffer,
@@ -1261,26 +738,6 @@ class GPUComputeEvaluator {
GPUStorageBuf *patchIndexBuffer,
GPUStorageBuf *patchParamsBuffer);
bool EvalPatches(gpu::VertBuf *srcBuffer,
OpenSubdiv::Osd::BufferDescriptor const &srcDesc,
gpu::VertBuf *dstBuffer,
OpenSubdiv::Osd::BufferDescriptor const &dstDesc,
gpu::VertBuf *duBuffer,
OpenSubdiv::Osd::BufferDescriptor const &duDesc,
gpu::VertBuf *dvBuffer,
OpenSubdiv::Osd::BufferDescriptor const &dvDesc,
gpu::VertBuf *duuBuffer,
OpenSubdiv::Osd::BufferDescriptor const &duuDesc,
gpu::VertBuf *duvBuffer,
OpenSubdiv::Osd::BufferDescriptor const &duvDesc,
gpu::VertBuf *dvvBuffer,
OpenSubdiv::Osd::BufferDescriptor const &dvvDesc,
int numPatchCoords,
gpu::VertBuf *patchCoordsBuffer,
const OpenSubdiv::Osd::PatchArrayVector &patchArrays,
GPUStorageBuf *patchIndexBuffer,
GPUStorageBuf *patchParamsBuffer);
/// \brief Generic limit eval function. This function has a same
/// signature as other device kernels have so that it can be called
/// in the same way.
@@ -1564,237 +1021,6 @@ class GPUComputeEvaluator {
patchTable->GetPatchParamBuffer());
}
/// \brief Generic limit eval function. This function has a same
/// signature as other device kernels have so that it can be called
/// in the same way.
///
/// @param srcBuffer Input primvar buffer.
/// Must have `get_vertex_buffer()` returning a `gpu::VertBuf`
/// buffer object of source data
///
/// @param srcDesc vertex buffer descriptor for the input buffer
///
/// @param dstBuffer Output primvar buffer
/// Must have `get_vertex_buffer()` returning a `gpu::VertBuf`
/// buffer object of destination data
///
/// @param dstDesc vertex buffer descriptor for the output buffer
///
/// @param duBuffer Output buffer derivative wrt u
/// Must have `get_vertex_buffer()` returning a `gpu::VertBuf`
/// buffer object of destination data
///
/// @param duDesc vertex buffer descriptor for the duBuffer
///
/// @param dvBuffer Output buffer derivative wrt v
/// Must have `get_vertex_buffer()` returning a `gpu::VertBuf`
/// buffer object of destination data
///
/// @param dvDesc vertex buffer descriptor for the dvBuffer
///
/// @param duuBuffer Output buffer 2nd derivative wrt u
/// Must have `get_vertex_buffer()` returning a `gpu::VertBuf`
/// buffer object of destination data
///
/// @param duuDesc vertex buffer descriptor for the duuBuffer
///
/// @param duvBuffer Output buffer 2nd derivative wrt u and v
/// Must have `get_vertex_buffer()` returning a `gpu::VertBuf`
/// buffer object of destination data
///
/// @param duvDesc vertex buffer descriptor for the duvBuffer
///
/// @param dvvBuffer Output buffer 2nd derivative wrt v
/// Must have `get_vertex_buffer()` returning a `gpu::VertBuf`
/// buffer object of destination data
///
/// @param dvvDesc vertex buffer descriptor for the dvvBuffer
///
/// @param numPatchCoords number of patchCoords.
///
/// @param patchCoords array of locations to be evaluated.
/// must have BindVBO() method returning an
/// array of PatchCoord struct in VBO.
///
/// @param patchTable GLPatchTable or equivalent
///
/// @param instance cached compiled instance. Clients are supposed to
/// pre-compile an instance of this class and provide
/// to this function. If it's null the kernel still
/// compute by instantiating on-demand kernel although
/// it may cause a performance problem.
///
/// @param deviceContext not used in the GLXFB evaluator
///
template<typename SRC_BUFFER,
typename DST_BUFFER,
typename PATCHCOORD_BUFFER,
typename PATCH_TABLE>
static bool EvalPatchesVarying(SRC_BUFFER *srcBuffer,
OpenSubdiv::Osd::BufferDescriptor const &srcDesc,
DST_BUFFER *dstBuffer,
OpenSubdiv::Osd::BufferDescriptor const &dstDesc,
DST_BUFFER *duBuffer,
OpenSubdiv::Osd::BufferDescriptor const &duDesc,
DST_BUFFER *dvBuffer,
OpenSubdiv::Osd::BufferDescriptor const &dvDesc,
DST_BUFFER *duuBuffer,
OpenSubdiv::Osd::BufferDescriptor const &duuDesc,
DST_BUFFER *duvBuffer,
OpenSubdiv::Osd::BufferDescriptor const &duvDesc,
DST_BUFFER *dvvBuffer,
OpenSubdiv::Osd::BufferDescriptor const &dvvDesc,
int numPatchCoords,
PATCHCOORD_BUFFER *patchCoords,
PATCH_TABLE *patchTable,
GPUComputeEvaluator *instance,
void *deviceContext = nullptr)
{
if (instance) {
return instance->EvalPatchesVarying(srcBuffer,
srcDesc,
dstBuffer,
dstDesc,
duBuffer,
duDesc,
dvBuffer,
dvDesc,
duuBuffer,
duuDesc,
duvBuffer,
duvDesc,
dvvBuffer,
dvvDesc,
numPatchCoords,
patchCoords,
patchTable);
}
// Create an instance on demand (slow)
(void)deviceContext; // unused
instance = Create(srcDesc, dstDesc, duDesc, dvDesc, duuDesc, duvDesc, dvvDesc);
if (instance) {
bool r = instance->EvalPatchesVarying(srcBuffer,
srcDesc,
dstBuffer,
dstDesc,
duBuffer,
duDesc,
dvBuffer,
dvDesc,
duuBuffer,
duuDesc,
duvBuffer,
duvDesc,
dvvBuffer,
dvvDesc,
numPatchCoords,
patchCoords,
patchTable);
delete instance;
return r;
}
return false;
}
/// \brief Generic limit eval function. This function has a same
/// signature as other device kernels have so that it can be called
/// in the same way.
///
/// @param srcBuffer Input primvar buffer.
/// Must have `get_vertex_buffer()` returning a `gpu::VertBuf`
/// buffer object of source data
///
/// @param srcDesc vertex buffer descriptor for the input buffer
///
/// @param dstBuffer Output primvar buffer
/// Must have `get_vertex_buffer()` returning a `gpu::VertBuf`
/// buffer object of destination data
///
/// @param dstDesc vertex buffer descriptor for the output buffer
///
/// @param duBuffer Output buffer derivative wrt u
/// Must have `get_vertex_buffer()` returning a `gpu::VertBuf`
/// buffer object of destination data
///
/// @param duDesc vertex buffer descriptor for the duBuffer
///
/// @param dvBuffer Output buffer derivative wrt v
/// Must have `get_vertex_buffer()` returning a `gpu::VertBuf`
/// buffer object of destination data
///
/// @param dvDesc vertex buffer descriptor for the dvBuffer
///
/// @param duuBuffer Output buffer 2nd derivative wrt u
/// Must have `get_vertex_buffer()` returning a `gpu::VertBuf`
/// buffer object of destination data
///
/// @param duuDesc vertex buffer descriptor for the duuBuffer
///
/// @param duvBuffer Output buffer 2nd derivative wrt u and v
/// Must have `get_vertex_buffer()` returning a `gpu::VertBuf`
/// buffer object of destination data
///
/// @param duvDesc vertex buffer descriptor for the duvBuffer
///
/// @param dvvBuffer Output buffer 2nd derivative wrt v
/// Must have `get_vertex_buffer()` returning a `gpu::VertBuf`
/// buffer object of destination data
///
/// @param dvvDesc vertex buffer descriptor for the dvvBuffer
///
/// @param numPatchCoords number of patchCoords.
///
/// @param patchCoords array of locations to be evaluated.
/// must have BindVBO() method returning an
/// array of PatchCoord struct in VBO.
///
/// @param patchTable GLPatchTable or equivalent
///
template<typename SRC_BUFFER,
typename DST_BUFFER,
typename PATCHCOORD_BUFFER,
typename PATCH_TABLE>
bool EvalPatchesVarying(SRC_BUFFER *srcBuffer,
OpenSubdiv::Osd::BufferDescriptor const &srcDesc,
DST_BUFFER *dstBuffer,
OpenSubdiv::Osd::BufferDescriptor const &dstDesc,
DST_BUFFER *duBuffer,
OpenSubdiv::Osd::BufferDescriptor const &duDesc,
DST_BUFFER *dvBuffer,
OpenSubdiv::Osd::BufferDescriptor const &dvDesc,
DST_BUFFER *duuBuffer,
OpenSubdiv::Osd::BufferDescriptor const &duuDesc,
DST_BUFFER *duvBuffer,
OpenSubdiv::Osd::BufferDescriptor const &duvDesc,
DST_BUFFER *dvvBuffer,
OpenSubdiv::Osd::BufferDescriptor const &dvvDesc,
int numPatchCoords,
PATCHCOORD_BUFFER *patchCoords,
PATCH_TABLE *patchTable)
{
return EvalPatches(srcBuffer->get_vertex_buffer(),
srcDesc,
dstBuffer->get_vertex_buffer(),
dstDesc,
duBuffer->get_vertex_buffer(),
duDesc,
dvBuffer->get_vertex_buffer(),
dvDesc,
duuBuffer->get_vertex_buffer(),
duuDesc,
duvBuffer->get_vertex_buffer(),
duvDesc,
dvvBuffer->get_vertex_buffer(),
dvvDesc,
numPatchCoords,
patchCoords->get_vertex_buffer(),
patchTable->GetVaryingPatchArrays(),
patchTable->GetVaryingPatchIndexBuffer(),
patchTable->GetPatchParamBuffer());
}
/// \brief Generic limit eval function. This function has a same
/// signature as other device kernels have so that it can be called
/// in the same way.
@@ -2104,245 +1330,6 @@ class GPUComputeEvaluator {
patchTable->GetFVarPatchParamBuffer(fvarChannel));
}
/// \brief Generic limit eval function. This function has a same
/// signature as other device kernels have so that it can be called
/// in the same way.
///
/// @param srcBuffer Input primvar buffer.
/// Must have `get_vertex_buffer()` returning a `gpu::VertBuf`
/// buffer object of source data
///
/// @param srcDesc vertex buffer descriptor for the input buffer
///
/// @param dstBuffer Output primvar buffer
/// Must have `get_vertex_buffer()` returning a `gpu::VertBuf`
/// buffer object of destination data
///
/// @param dstDesc vertex buffer descriptor for the output buffer
///
/// @param duBuffer Output buffer derivative wrt u
/// Must have `get_vertex_buffer()` returning a `gpu::VertBuf`
/// buffer object of destination data
///
/// @param duDesc vertex buffer descriptor for the duBuffer
///
/// @param dvBuffer Output buffer derivative wrt v
/// Must have `get_vertex_buffer()` returning a `gpu::VertBuf`
/// buffer object of destination data
///
/// @param dvDesc vertex buffer descriptor for the dvBuffer
///
/// @param duuBuffer Output buffer 2nd derivative wrt u
/// Must have `get_vertex_buffer()` returning a `gpu::VertBuf`
/// buffer object of destination data
///
/// @param duuDesc vertex buffer descriptor for the duuBuffer
///
/// @param duvBuffer Output buffer 2nd derivative wrt u and v
/// Must have `get_vertex_buffer()` returning a `gpu::VertBuf`
/// buffer object of destination data
///
/// @param duvDesc vertex buffer descriptor for the duvBuffer
///
/// @param dvvBuffer Output buffer 2nd derivative wrt v
/// Must have `get_vertex_buffer()` returning a `gpu::VertBuf`
/// buffer object of destination data
///
/// @param dvvDesc vertex buffer descriptor for the dvvBuffer
///
/// @param numPatchCoords number of patchCoords.
///
/// @param patchCoords array of locations to be evaluated.
/// must have BindVBO() method returning an
/// array of PatchCoord struct in VBO.
///
/// @param patchTable GLPatchTable or equivalent
///
/// @param fvarChannel face-varying channel
///
/// @param instance cached compiled instance. Clients are supposed to
/// pre-compile an instance of this class and provide
/// to this function. If it's null the kernel still
/// compute by instantiating on-demand kernel although
/// it may cause a performance problem.
///
/// @param deviceContext not used in the GLXFB evaluator
///
template<typename SRC_BUFFER,
typename DST_BUFFER,
typename PATCHCOORD_BUFFER,
typename PATCH_TABLE>
static bool EvalPatchesFaceVarying(SRC_BUFFER *srcBuffer,
OpenSubdiv::Osd::BufferDescriptor const &srcDesc,
DST_BUFFER *dstBuffer,
OpenSubdiv::Osd::BufferDescriptor const &dstDesc,
DST_BUFFER *duBuffer,
OpenSubdiv::Osd::BufferDescriptor const &duDesc,
DST_BUFFER *dvBuffer,
OpenSubdiv::Osd::BufferDescriptor const &dvDesc,
DST_BUFFER *duuBuffer,
OpenSubdiv::Osd::BufferDescriptor const &duuDesc,
DST_BUFFER *duvBuffer,
OpenSubdiv::Osd::BufferDescriptor const &duvDesc,
DST_BUFFER *dvvBuffer,
OpenSubdiv::Osd::BufferDescriptor const &dvvDesc,
int numPatchCoords,
PATCHCOORD_BUFFER *patchCoords,
PATCH_TABLE *patchTable,
int fvarChannel,
GPUComputeEvaluator *instance,
void *deviceContext = nullptr)
{
if (instance) {
return instance->EvalPatchesFaceVarying(srcBuffer,
srcDesc,
dstBuffer,
dstDesc,
duBuffer,
duDesc,
dvBuffer,
dvDesc,
duuBuffer,
duuDesc,
duvBuffer,
duvDesc,
dvvBuffer,
dvvDesc,
numPatchCoords,
patchCoords,
patchTable,
fvarChannel);
}
// Create an instance on demand (slow)
(void)deviceContext; // unused
instance = Create(srcDesc, dstDesc, duDesc, dvDesc, duuDesc, duvDesc, dvvDesc);
if (instance) {
bool r = instance->EvalPatchesFaceVarying(srcBuffer,
srcDesc,
dstBuffer,
dstDesc,
duBuffer,
duDesc,
dvBuffer,
dvDesc,
duuBuffer,
duuDesc,
duvBuffer,
duvDesc,
dvvBuffer,
dvvDesc,
numPatchCoords,
patchCoords,
patchTable,
fvarChannel);
delete instance;
return r;
}
return false;
}
/// \brief Generic limit eval function. This function has a same
/// signature as other device kernels have so that it can be called
/// in the same way.
///
/// @param srcBuffer Input primvar buffer.
/// Must have `get_vertex_buffer()` returning a `gpu::VertBuf`
/// buffer object of source data
///
/// @param srcDesc vertex buffer descriptor for the input buffer
///
/// @param dstBuffer Output primvar buffer
/// Must have `get_vertex_buffer()` returning a `gpu::VertBuf`
/// buffer object of destination data
///
/// @param dstDesc vertex buffer descriptor for the output buffer
///
/// @param duBuffer Output buffer derivative wrt u
/// Must have `get_vertex_buffer()` returning a `gpu::VertBuf`
/// buffer object of destination data
///
/// @param duDesc vertex buffer descriptor for the duBuffer
///
/// @param dvBuffer Output buffer derivative wrt v
/// Must have `get_vertex_buffer()` returning a `gpu::VertBuf`
/// buffer object of destination data
///
/// @param dvDesc vertex buffer descriptor for the dvBuffer
///
/// @param duuBuffer Output buffer 2nd derivative wrt u
/// Must have `get_vertex_buffer()` returning a `gpu::VertBuf`
/// buffer object of destination data
///
/// @param duuDesc vertex buffer descriptor for the duuBuffer
///
/// @param duvBuffer Output buffer 2nd derivative wrt u and v
/// Must have `get_vertex_buffer()` returning a `gpu::VertBuf`
/// buffer object of destination data
///
/// @param duvDesc vertex buffer descriptor for the duvBuffer
///
/// @param dvvBuffer Output buffer 2nd derivative wrt v
/// Must have `get_vertex_buffer()` returning a `gpu::VertBuf`
/// buffer object of destination data
///
/// @param dvvDesc vertex buffer descriptor for the dvvBuffer
///
/// @param numPatchCoords number of patchCoords.
///
/// @param patchCoords array of locations to be evaluated.
/// must have BindVBO() method returning an
/// array of PatchCoord struct in VBO.
///
/// @param patchTable GLPatchTable or equivalent
///
/// @param fvarChannel face-varying channel
///
template<typename SRC_BUFFER,
typename DST_BUFFER,
typename PATCHCOORD_BUFFER,
typename PATCH_TABLE>
bool EvalPatchesFaceVarying(SRC_BUFFER *srcBuffer,
OpenSubdiv::Osd::BufferDescriptor const &srcDesc,
DST_BUFFER *dstBuffer,
OpenSubdiv::Osd::BufferDescriptor const &dstDesc,
DST_BUFFER *duBuffer,
OpenSubdiv::Osd::BufferDescriptor const &duDesc,
DST_BUFFER *dvBuffer,
OpenSubdiv::Osd::BufferDescriptor const &dvDesc,
DST_BUFFER *duuBuffer,
OpenSubdiv::Osd::BufferDescriptor const &duuDesc,
DST_BUFFER *duvBuffer,
OpenSubdiv::Osd::BufferDescriptor const &duvDesc,
DST_BUFFER *dvvBuffer,
OpenSubdiv::Osd::BufferDescriptor const &dvvDesc,
int numPatchCoords,
PATCHCOORD_BUFFER *patchCoords,
PATCH_TABLE *patchTable,
int fvarChannel = 0)
{
return EvalPatches(srcBuffer->get_vertex_buffer(),
srcDesc,
dstBuffer->get_vertex_buffer(),
dstDesc,
duBuffer->get_vertex_buffer(),
duDesc,
dvBuffer->get_vertex_buffer(),
dvDesc,
duuBuffer->get_vertex_buffer(),
duuDesc,
duvBuffer->get_vertex_buffer(),
duvDesc,
dvvBuffer->get_vertex_buffer(),
dvvDesc,
numPatchCoords,
patchCoords->get_vertex_buffer(),
patchTable->GetFVarPatchArrays(fvarChannel),
patchTable->GetFVarPatchIndexBuffer(fvarChannel),
patchTable->GetFVarPatchParamBuffer(fvarChannel));
}
/// ----------------------------------------------------------------------
///
/// Other methods
@@ -2355,10 +1342,7 @@ class GPUComputeEvaluator {
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(),
OpenSubdiv::Osd::BufferDescriptor const &duuDesc = OpenSubdiv::Osd::BufferDescriptor(),
OpenSubdiv::Osd::BufferDescriptor const &duvDesc = OpenSubdiv::Osd::BufferDescriptor(),
OpenSubdiv::Osd::BufferDescriptor const &dvvDesc = OpenSubdiv::Osd::BufferDescriptor());
OpenSubdiv::Osd::BufferDescriptor const &dvDesc = OpenSubdiv::Osd::BufferDescriptor());
/// Wait the dispatched kernel finishes.
static void Synchronize(void *deviceContext);
@@ -2371,9 +1355,6 @@ class GPUComputeEvaluator {
OpenSubdiv::Osd::BufferDescriptor const &dstDesc,
OpenSubdiv::Osd::BufferDescriptor const &duDesc,
OpenSubdiv::Osd::BufferDescriptor const &dvDesc,
OpenSubdiv::Osd::BufferDescriptor const &duuDesc,
OpenSubdiv::Osd::BufferDescriptor const &duvDesc,
OpenSubdiv::Osd::BufferDescriptor const &dvvDesc,
int workGroupSize);
GPUShader *shader = nullptr;
int uniformStart = 0;
@@ -2382,9 +1363,6 @@ class GPUComputeEvaluator {
int uniformDstOffset = 0;
int uniformDuDesc = 0;
int uniformDvDesc = 0;
int uniformDuuDesc = 0;
int uniformDuvDesc = 0;
int uniformDvvDesc = 0;
} _stencilKernel;
struct _PatchKernel {
@@ -2394,18 +1372,12 @@ class GPUComputeEvaluator {
OpenSubdiv::Osd::BufferDescriptor const &dstDesc,
OpenSubdiv::Osd::BufferDescriptor const &duDesc,
OpenSubdiv::Osd::BufferDescriptor const &dvDesc,
OpenSubdiv::Osd::BufferDescriptor const &duuDesc,
OpenSubdiv::Osd::BufferDescriptor const &duvDesc,
OpenSubdiv::Osd::BufferDescriptor const &dvvDesc,
int workGroupSize);
GPUShader *shader = nullptr;
int uniformSrcOffset = 0;
int uniformDstOffset = 0;
int uniformDuDesc = 0;
int uniformDvDesc = 0;
int uniformDuuDesc = 0;
int uniformDuvDesc = 0;
int uniformDvvDesc = 0;
} _patchKernel;
int _workGroupSize;

43
intern/opensubdiv/internal/evaluator/shaders/osd_eval_patches_comp.glsl
View File

@@ -95,32 +95,6 @@ void writeDv(int index, Vertex dv)
}
#endif
#if defined(OPENSUBDIV_GLSL_COMPUTE_USE_2ND_DERIVATIVES)
void writeDuu(int index, Vertex duu)
{
int duuIndex = duuDesc.x + index * duuDesc.z;
for (int i = 0; i < LENGTH; ++i) {
duuBuffer[duuIndex + i] = duu.vertexData[i];
}
}
void writeDuv(int index, Vertex duv)
{
int duvIndex = duvDesc.x + index * duvDesc.z;
for (int i = 0; i < LENGTH; ++i) {
duvBuffer[duvIndex + i] = duv.vertexData[i];
}
}
void writeDvv(int index, Vertex dvv)
{
int dvvIndex = dvvDesc.x + index * dvvDesc.z;
for (int i = 0; i < LENGTH; ++i) {
dvvBuffer[dvvIndex + i] = dvv.vertexData[i];
}
}
#endif
//------------------------------------------------------------------------------
// PERFORMANCE: stride could be constant, but not as significant as length
@@ -143,9 +117,6 @@ void main()
clear(dst);
clear(du);
clear(dv);
clear(duu);
clear(duv);
clear(dvv);
int indexBase = array.indexBase + array.stride * (coord.patchIndex - array.primitiveIdBase);
@@ -154,9 +125,6 @@ void main()
addWithWeight(dst, readVertex(index), wP[cv]);
addWithWeight(du, readVertex(index), wDu[cv]);
addWithWeight(dv, readVertex(index), wDv[cv]);
addWithWeight(duu, readVertex(index), wDuu[cv]);
addWithWeight(duv, readVertex(index), wDuv[cv]);
addWithWeight(dvv, readVertex(index), wDvv[cv]);
}
writeVertex(current, dst);
@@ -168,15 +136,4 @@ void main()
writeDv(current, dv);
}
#endif
#if defined(OPENSUBDIV_GLSL_COMPUTE_USE_2ND_DERIVATIVES)
if (duuDesc.y > 0) { // length
writeDuu(current, duu);
}
if (duvDesc.y > 0) { // length
writeDuv(current, duv);
}
if (dvvDesc.y > 0) {
writeDvv(current, dvv);
}
#endif
}

49
intern/opensubdiv/internal/evaluator/shaders/osd_eval_stencils_comp.glsl
View File

@@ -86,32 +86,6 @@ void writeDv(int index, Vertex dv)
}
#endif
#if defined(OPENSUBDIV_GLSL_COMPUTE_USE_2ND_DERIVATIVES)
void writeDuu(int index, Vertex duu)
{
int duuIndex = duuDesc.x + index * duuDesc.z;
for (int i = 0; i < LENGTH; ++i) {
duuBuffer[duuIndex + i] = duu.vertexData[i];
}
}
void writeDuv(int index, Vertex duv)
{
int duvIndex = duvDesc.x + index * duvDesc.z;
for (int i = 0; i < LENGTH; ++i) {
duvBuffer[duvIndex + i] = duv.vertexData[i];
}
}
void writeDvv(int index, Vertex dvv)
{
int dvvIndex = dvvDesc.x + index * dvvDesc.z;
for (int i = 0; i < LENGTH; ++i) {
dvvBuffer[dvvIndex + i] = dvv.vertexData[i];
}
}
#endif
//------------------------------------------------------------------------------
void main()
@@ -152,27 +126,4 @@ void main()
writeDv(current, dv);
}
#endif
#if defined(OPENSUBDIV_GLSL_COMPUTE_USE_2ND_DERIVATIVES)
Vertex duu, duv, dvv;
clear(duu);
clear(duv);
clear(dvv);
for (int i = 0; i < size; ++i) {
// expects the compiler optimizes readVertex out here.
Vertex src = readVertex(indices_buf[offset + i]);
addWithWeight(duu, src, duu_weights_buf[offset + i]);
addWithWeight(duv, src, duv_weights_buf[offset + i]);
addWithWeight(dvv, src, dvv_weights_buf[offset + i]);
}
if (duuDesc.y > 0) { // length
writeDuu(current, duu);
}
if (duvDesc.y > 0) {
writeDuv(current, duv);
}
if (dvvDesc.y > 0) {
writeDvv(current, dvv);
}
#endif
}