AuroraMiddleware/OpenSubdiv
1
0
Fork 0
mirror of https://github.com/PixarAnimationStudios/OpenSubdiv synced 2024-11-09 22:00:06 +00:00
Code Issues Releases Wiki Activity
release
OpenSubdiv/opensubdiv/osd/tbbKernel.cpp

614 lines
22 KiB
C++
Raw Permalink Normal View History

initial checking in TBB kernel.
2013-06-05 17:55:24 +00:00
//
Amending Apache license language & file headers. New text: Copyright 2013 Pixar Licensed under the Apache License, Version 2.0 (the "Apache License") with the following modification; you may not use this file except in compliance with the Apache License and the following modification to it: Section 6. Trademarks. is deleted and replaced with: 6. Trademarks. This License does not grant permission to use the trade names, trademarks, service marks, or product names of the Licensor and its affiliates, except as required to comply with Section 4(c) of the License and to reproduce the content of the NOTICE file. You may obtain a copy of the Apache License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the Apache License with the above modification is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the Apache License for the specific language governing permissions and limitations under the Apache License.
2013-09-26 19:04:57 +00:00
// Copyright 2013 Pixar
initial checking in TBB kernel.
2013-06-05 17:55:24 +00:00
//
Amending Apache license language & file headers. New text: Copyright 2013 Pixar Licensed under the Apache License, Version 2.0 (the "Apache License") with the following modification; you may not use this file except in compliance with the Apache License and the following modification to it: Section 6. Trademarks. is deleted and replaced with: 6. Trademarks. This License does not grant permission to use the trade names, trademarks, service marks, or product names of the Licensor and its affiliates, except as required to comply with Section 4(c) of the License and to reproduce the content of the NOTICE file. You may obtain a copy of the Apache License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the Apache License with the above modification is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the Apache License for the specific language governing permissions and limitations under the Apache License.
2013-09-26 19:04:57 +00:00
// Licensed under the Apache License, Version 2.0 (the "Apache License")
// with the following modification; you may not use this file except in
// compliance with the Apache License and the following modification to it:
// Section 6. Trademarks. is deleted and replaced with:
initial checking in TBB kernel.
2013-06-05 17:55:24 +00:00
//
Amending Apache license language & file headers. New text: Copyright 2013 Pixar Licensed under the Apache License, Version 2.0 (the "Apache License") with the following modification; you may not use this file except in compliance with the Apache License and the following modification to it: Section 6. Trademarks. is deleted and replaced with: 6. Trademarks. This License does not grant permission to use the trade names, trademarks, service marks, or product names of the Licensor and its affiliates, except as required to comply with Section 4(c) of the License and to reproduce the content of the NOTICE file. You may obtain a copy of the Apache License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the Apache License with the above modification is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the Apache License for the specific language governing permissions and limitations under the Apache License.
2013-09-26 19:04:57 +00:00
// 6. Trademarks. This License does not grant permission to use the trade
// names, trademarks, service marks, or product names of the Licensor
// and its affiliates, except as required to comply with Section 4(c) of
// the License and to reproduce the content of the NOTICE file.
initial checking in TBB kernel.
2013-06-05 17:55:24 +00:00
//
Amending Apache license language & file headers. New text: Copyright 2013 Pixar Licensed under the Apache License, Version 2.0 (the "Apache License") with the following modification; you may not use this file except in compliance with the Apache License and the following modification to it: Section 6. Trademarks. is deleted and replaced with: 6. Trademarks. This License does not grant permission to use the trade names, trademarks, service marks, or product names of the Licensor and its affiliates, except as required to comply with Section 4(c) of the License and to reproduce the content of the NOTICE file. You may obtain a copy of the Apache License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the Apache License with the above modification is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the Apache License for the specific language governing permissions and limitations under the Apache License.
2013-09-26 19:04:57 +00:00
// You may obtain a copy of the Apache License at
initial checking in TBB kernel.
2013-06-05 17:55:24 +00:00
//
Amending Apache license language & file headers. New text: Copyright 2013 Pixar Licensed under the Apache License, Version 2.0 (the "Apache License") with the following modification; you may not use this file except in compliance with the Apache License and the following modification to it: Section 6. Trademarks. is deleted and replaced with: 6. Trademarks. This License does not grant permission to use the trade names, trademarks, service marks, or product names of the Licensor and its affiliates, except as required to comply with Section 4(c) of the License and to reproduce the content of the NOTICE file. You may obtain a copy of the Apache License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the Apache License with the above modification is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the Apache License for the specific language governing permissions and limitations under the Apache License.
2013-09-26 19:04:57 +00:00
// http://www.apache.org/licenses/LICENSE-2.0
Changed license header
2013-08-14 16:46:53 +00:00
//
Amending Apache license language & file headers. New text: Copyright 2013 Pixar Licensed under the Apache License, Version 2.0 (the "Apache License") with the following modification; you may not use this file except in compliance with the Apache License and the following modification to it: Section 6. Trademarks. is deleted and replaced with: 6. Trademarks. This License does not grant permission to use the trade names, trademarks, service marks, or product names of the Licensor and its affiliates, except as required to comply with Section 4(c) of the License and to reproduce the content of the NOTICE file. You may obtain a copy of the Apache License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the Apache License with the above modification is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the Apache License for the specific language governing permissions and limitations under the Apache License.
2013-09-26 19:04:57 +00:00
// Unless required by applicable law or agreed to in writing, software
// distributed under the Apache License with the above modification is
// distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
// KIND, either express or implied. See the Apache License for the specific
// language governing permissions and limitations under the Apache License.
initial checking in TBB kernel.
2013-06-05 17:55:24 +00:00
//
#include "../osd/cpuKernel.h"
#include "../osd/tbbKernel.h"
Osd API refactor: EvalStencils and EvalPatches Add EvalStencils and EvalPatches API for most of CPU and GPU evaluators. with this change, Eval API in the osd layer consists of following parts: - Evaluators (Cpu, Omp, Tbb, Cuda, CL, GLXFB, GLCompute, D3D11Compute) implements EvalStencils and EvalPatches(*). Both supports derivatives (not fully implemented though) - Interop vertex buffer classes (optional, same as before) Note that these classes are not necessary to use Evaluators. All evaluators have EvalStencils/Patches which take device-specific buffer objects. For example, GLXFBEvaluator can take GLuint directly for both stencil tables and input primvars. Although using these interop classes makes it easy to integrate osd into relatively simple applications. - device-dependent StencilTable and PatchTable (optional) These are also optional, but can be used simply a substitute of Far::StencilTable and Far::PatchTable for osd evaluators. - PatchArray, PatchCoord, PatchParam They are tiny structs used for GPU based patch evaluation. (*) TODO and known issues: - CLEvaluator and D3D11Evaluator's EvalPatches() have not been implemented. - GPU Gregory patch evaluation has not been implemented in EvalPatches(). - CudaEvaluator::EvalPatches() is very unstable. - All patch evaluation kernels have not been well optimized. - Currently GLXFB kernel doesn't support derivative evaluation. There's a technical difficulty for the multi-stream output.
2015-05-26 04:51:55 +00:00
#include "../osd/types.h"
osdlayer: rename Osd::VertexBufferDescriptor to Osd::BufferDescriptor. A mechanical substitution of VertexBufferDescriptor with BufferDescriptor. Also removing unused files from osd.
2015-05-29 16:21:14 +00:00
#include "../osd/bufferDescriptor.h"
Reorganized osd/patchBasis and osd/patchBasisTypes Folded osd/patchBasisCommon.h and osd/patchBasisCommonEval.h into the single header file osd/patchBasis.h and renamed osd/PatchBasisCommonTypes.h to osd/patchBasisTypes.h Moved these into the OpenSubdiv::Osd namespace when compiled for C++ and added a brief comment describing the intended use cases for this code.
2023-09-07 23:53:12 +00:00
#include "../osd/patchBasis.h"
initial checking in TBB kernel.
2013-06-05 17:55:24 +00:00
Landing 3.0.0.alpha Sync'ing the 'dev' branch with the 'feature_3.0dev' branch at commit 68c6d11fc36761ae1a5e6cdc3457be16f2e9704a The branch 'feature_3.0dev' is now locked and preserved for historical purposes.
2014-09-05 22:07:46 +00:00
#include <cassert>
#include <cstdlib>
initial checking in TBB kernel.
2013-06-05 17:55:24 +00:00
#include <tbb/parallel_for.h>
namespace OpenSubdiv {
namespace OPENSUBDIV_VERSION {
Landing 3.0.0.alpha Sync'ing the 'dev' branch with the 'feature_3.0dev' branch at commit 68c6d11fc36761ae1a5e6cdc3457be16f2e9704a The branch 'feature_3.0dev' is now locked and preserved for historical purposes.
2014-09-05 22:07:46 +00:00
namespace Osd {
initial checking in TBB kernel.
2013-06-05 17:55:24 +00:00
#define grain_size 200
Landing 3.0.0.alpha Sync'ing the 'dev' branch with the 'feature_3.0dev' branch at commit 68c6d11fc36761ae1a5e6cdc3457be16f2e9704a The branch 'feature_3.0dev' is now locked and preserved for historical purposes.
2014-09-05 22:07:46 +00:00
template <class T> T *
osdlayer: rename Osd::VertexBufferDescriptor to Osd::BufferDescriptor. A mechanical substitution of VertexBufferDescriptor with BufferDescriptor. Also removing unused files from osd.
2015-05-29 16:21:14 +00:00
elementAtIndex(T * src, int index, BufferDescriptor const &desc) {
Interleaved buffer support in OsdCompute. Removed OsdVertexDescriptor and replaced with OsdVertexBufferDescriptor. All kernels take offset/length/stride to apply subdivision partially in each vertex elements. Also the offset can be used for client-based VBO aggregation, without modifying index buffers. This is useful for topology sharing, in conjunction with glDrawElementsBaseVertex etc. However, gregory patch shader fetches vertex buffer via texture buffer, which index should also be offsetted too. Although gl_BaseVertexARB extension should be able to do that job, it's a relatively new extension. So we use OsdBaseVertex() call to mitigate the compatibility issue as clients can provide it in their way at least for the time being.
2014-05-09 00:20:54 +00:00
Landing 3.0.0.alpha Sync'ing the 'dev' branch with the 'feature_3.0dev' branch at commit 68c6d11fc36761ae1a5e6cdc3457be16f2e9704a The branch 'feature_3.0dev' is now locked and preserved for historical purposes.
2014-09-05 22:07:46 +00:00
return src + index * desc.stride;
Interleaved buffer support in OsdCompute. Removed OsdVertexDescriptor and replaced with OsdVertexBufferDescriptor. All kernels take offset/length/stride to apply subdivision partially in each vertex elements. Also the offset can be used for client-based VBO aggregation, without modifying index buffers. This is useful for topology sharing, in conjunction with glDrawElementsBaseVertex etc. However, gregory patch shader fetches vertex buffer via texture buffer, which index should also be offsetted too. Although gl_BaseVertexARB extension should be able to do that job, it's a relatively new extension. So we use OsdBaseVertex() call to mitigate the compatibility issue as clients can provide it in their way at least for the time being.
2014-05-09 00:20:54 +00:00
}
static inline void
osdlayer: rename Osd::VertexBufferDescriptor to Osd::BufferDescriptor. A mechanical substitution of VertexBufferDescriptor with BufferDescriptor. Also removing unused files from osd.
2015-05-29 16:21:14 +00:00
clear(float *dst, BufferDescriptor const &desc) {
Interleaved buffer support in OsdCompute. Removed OsdVertexDescriptor and replaced with OsdVertexBufferDescriptor. All kernels take offset/length/stride to apply subdivision partially in each vertex elements. Also the offset can be used for client-based VBO aggregation, without modifying index buffers. This is useful for topology sharing, in conjunction with glDrawElementsBaseVertex etc. However, gregory patch shader fetches vertex buffer via texture buffer, which index should also be offsetted too. Although gl_BaseVertexARB extension should be able to do that job, it's a relatively new extension. So we use OsdBaseVertex() call to mitigate the compatibility issue as clients can provide it in their way at least for the time being.
2014-05-09 00:20:54 +00:00
Landing 3.0.0.alpha Sync'ing the 'dev' branch with the 'feature_3.0dev' branch at commit 68c6d11fc36761ae1a5e6cdc3457be16f2e9704a The branch 'feature_3.0dev' is now locked and preserved for historical purposes.
2014-09-05 22:07:46 +00:00
assert(dst);
memset(dst, 0, desc.length*sizeof(float));
Interleaved buffer support in OsdCompute. Removed OsdVertexDescriptor and replaced with OsdVertexBufferDescriptor. All kernels take offset/length/stride to apply subdivision partially in each vertex elements. Also the offset can be used for client-based VBO aggregation, without modifying index buffers. This is useful for topology sharing, in conjunction with glDrawElementsBaseVertex etc. However, gregory patch shader fetches vertex buffer via texture buffer, which index should also be offsetted too. Although gl_BaseVertexARB extension should be able to do that job, it's a relatively new extension. So we use OsdBaseVertex() call to mitigate the compatibility issue as clients can provide it in their way at least for the time being.
2014-05-09 00:20:54 +00:00
}
Landing 3.0.0.alpha Sync'ing the 'dev' branch with the 'feature_3.0dev' branch at commit 68c6d11fc36761ae1a5e6cdc3457be16f2e9704a The branch 'feature_3.0dev' is now locked and preserved for historical purposes.
2014-09-05 22:07:46 +00:00
static inline void
addWithWeight(float *dst, const float *src, int srcIndex, float weight,
osdlayer: rename Osd::VertexBufferDescriptor to Osd::BufferDescriptor. A mechanical substitution of VertexBufferDescriptor with BufferDescriptor. Also removing unused files from osd.
2015-05-29 16:21:14 +00:00
BufferDescriptor const &desc) {
Implemented CATMARK_QUAD_FACE_VERTEX and CATMARK_TRI_QUAD_FACE_VERTEX kernels for DirectX 11, OpenMP, and TBB platforms. Fixed a bug in the GLSL Transform Feedback kernels. Minor changes for consistent formatting.
2014-05-30 06:02:19 +00:00
iso-646 fix for CUDA / CL / TBB
2016-06-25 21:23:55 +00:00
assert(src && dst);
Landing 3.0.0.alpha Sync'ing the 'dev' branch with the 'feature_3.0dev' branch at commit 68c6d11fc36761ae1a5e6cdc3457be16f2e9704a The branch 'feature_3.0dev' is now locked and preserved for historical purposes.
2014-09-05 22:07:46 +00:00
src = elementAtIndex(src, srcIndex, desc);
for (int k = 0; k < desc.length; ++k) {
dst[k] += src[k] * weight;
Implemented CATMARK_QUAD_FACE_VERTEX and CATMARK_TRI_QUAD_FACE_VERTEX kernels for DirectX 11, OpenMP, and TBB platforms. Fixed a bug in the GLSL Transform Feedback kernels. Minor changes for consistent formatting.
2014-05-30 06:02:19 +00:00
}
}
Landing 3.0.0.alpha Sync'ing the 'dev' branch with the 'feature_3.0dev' branch at commit 68c6d11fc36761ae1a5e6cdc3457be16f2e9704a The branch 'feature_3.0dev' is now locked and preserved for historical purposes.
2014-09-05 22:07:46 +00:00
static inline void
copy(float *dst, int dstIndex, const float *src,
osdlayer: rename Osd::VertexBufferDescriptor to Osd::BufferDescriptor. A mechanical substitution of VertexBufferDescriptor with BufferDescriptor. Also removing unused files from osd.
2015-05-29 16:21:14 +00:00
BufferDescriptor const &desc) {
Implemented CATMARK_QUAD_FACE_VERTEX and CATMARK_TRI_QUAD_FACE_VERTEX kernels for DirectX 11, OpenMP, and TBB platforms. Fixed a bug in the GLSL Transform Feedback kernels. Minor changes for consistent formatting.
2014-05-30 06:02:19 +00:00
iso-646 fix for CUDA / CL / TBB
2016-06-25 21:23:55 +00:00
assert(src && dst);
Implemented CATMARK_QUAD_FACE_VERTEX and CATMARK_TRI_QUAD_FACE_VERTEX kernels for DirectX 11, OpenMP, and TBB platforms. Fixed a bug in the GLSL Transform Feedback kernels. Minor changes for consistent formatting.
2014-05-30 06:02:19 +00:00
Landing 3.0.0.alpha Sync'ing the 'dev' branch with the 'feature_3.0dev' branch at commit 68c6d11fc36761ae1a5e6cdc3457be16f2e9704a The branch 'feature_3.0dev' is now locked and preserved for historical purposes.
2014-09-05 22:07:46 +00:00
dst = elementAtIndex(dst, dstIndex, desc);
memcpy(dst, src, desc.length*sizeof(float));
Implemented CATMARK_QUAD_FACE_VERTEX and CATMARK_TRI_QUAD_FACE_VERTEX kernels for DirectX 11, OpenMP, and TBB platforms. Fixed a bug in the GLSL Transform Feedback kernels. Minor changes for consistent formatting.
2014-05-30 06:02:19 +00:00
}
initial checking in TBB kernel.
2013-06-05 17:55:24 +00:00
Landing 3.0.0.alpha Sync'ing the 'dev' branch with the 'feature_3.0dev' branch at commit 68c6d11fc36761ae1a5e6cdc3457be16f2e9704a The branch 'feature_3.0dev' is now locked and preserved for historical purposes.
2014-09-05 22:07:46 +00:00
class TBBStencilKernel {
initial checking in TBB kernel.
2013-06-05 17:55:24 +00:00
osdlayer: rename Osd::VertexBufferDescriptor to Osd::BufferDescriptor. A mechanical substitution of VertexBufferDescriptor with BufferDescriptor. Also removing unused files from osd.
2015-05-29 16:21:14 +00:00
BufferDescriptor _srcDesc;
BufferDescriptor _dstDesc;
Landing 3.0.0.alpha Sync'ing the 'dev' branch with the 'feature_3.0dev' branch at commit 68c6d11fc36761ae1a5e6cdc3457be16f2e9704a The branch 'feature_3.0dev' is now locked and preserved for historical purposes.
2014-09-05 22:07:46 +00:00
float const * _vertexSrc;
float * _vertexDst;
initial checking in TBB kernel.
2013-06-05 17:55:24 +00:00
Change stencils sizes from unsigned char to int.
2015-05-19 17:16:56 +00:00
int const * _sizes;
Landing 3.0.0.alpha Sync'ing the 'dev' branch with the 'feature_3.0dev' branch at commit 68c6d11fc36761ae1a5e6cdc3457be16f2e9704a The branch 'feature_3.0dev' is now locked and preserved for historical purposes.
2014-09-05 22:07:46 +00:00
int const * _offsets,
* _indices;
float const * _weights;
initial checking in TBB kernel.
2013-06-05 17:55:24 +00:00
Added the CATMARK_RESTRICTED_EDGE_VERTEX kernel which computes vertices resulting from the refinement of a smooth or (fully) sharp edge.
2014-05-27 22:25:54 +00:00
public:
osdlayer: rename Osd::VertexBufferDescriptor to Osd::BufferDescriptor. A mechanical substitution of VertexBufferDescriptor with BufferDescriptor. Also removing unused files from osd.
2015-05-29 16:21:14 +00:00
TBBStencilKernel(float const *src, BufferDescriptor srcDesc,
float *dst, BufferDescriptor dstDesc,
Change stencils sizes from unsigned char to int.
2015-05-19 17:16:56 +00:00
int const * sizes, int const * offsets,
osd refactor: split the vertex buffer argument into src and dst Changing all device kernels to take two buffer identifiers for source and destination separately. This change is an intermediate step toward upcoming context/controller refactoring. Previously we have a limitation that the source and destination vertex buffer has to be a single buffer, since the subdivision kernels are iteratively applied by level. With stencil tables, we don't have such a limitation any more, so we may want to apply stencils from seprate source buffer to another. To specifiy the output location within the destination buffer, we can use VertexBufferDescriptor.offset. This allows us not only configuring arbitrary batching scheme, but also relaxing the limitation that source and destination buffers are in same interleaved layout. For examples, we could include derivatives only in the destination buffer, which doesn't need to be allocated in the source buffer.
2015-05-07 23:11:00 +00:00
int const * indices, float const * weights) :
_srcDesc(srcDesc),
_dstDesc(dstDesc),
_vertexSrc(src),
_vertexDst(dst),
Landing 3.0.0.alpha Sync'ing the 'dev' branch with the 'feature_3.0dev' branch at commit 68c6d11fc36761ae1a5e6cdc3457be16f2e9704a The branch 'feature_3.0dev' is now locked and preserved for historical purposes.
2014-09-05 22:07:46 +00:00
_sizes(sizes),
_offsets(offsets),
_indices(indices),
_weights(weights) { }
TBBStencilKernel(TBBStencilKernel const & other) {
osd refactor: split the vertex buffer argument into src and dst Changing all device kernels to take two buffer identifiers for source and destination separately. This change is an intermediate step toward upcoming context/controller refactoring. Previously we have a limitation that the source and destination vertex buffer has to be a single buffer, since the subdivision kernels are iteratively applied by level. With stencil tables, we don't have such a limitation any more, so we may want to apply stencils from seprate source buffer to another. To specifiy the output location within the destination buffer, we can use VertexBufferDescriptor.offset. This allows us not only configuring arbitrary batching scheme, but also relaxing the limitation that source and destination buffers are in same interleaved layout. For examples, we could include derivatives only in the destination buffer, which doesn't need to be allocated in the source buffer.
2015-05-07 23:11:00 +00:00
_srcDesc = other._srcDesc;
_dstDesc = other._dstDesc;
Landing 3.0.0.alpha Sync'ing the 'dev' branch with the 'feature_3.0dev' branch at commit 68c6d11fc36761ae1a5e6cdc3457be16f2e9704a The branch 'feature_3.0dev' is now locked and preserved for historical purposes.
2014-09-05 22:07:46 +00:00
_sizes = other._sizes;
_offsets = other._offsets;
_indices = other._indices;
_weights = other._weights;
_vertexSrc = other._vertexSrc;
_vertexDst = other._vertexDst;
Added the CATMARK_RESTRICTED_EDGE_VERTEX kernel which computes vertices resulting from the refinement of a smooth or (fully) sharp edge.
2014-05-27 22:25:54 +00:00
}
Update TBB C&C's with Sheng's (shengfuintel) latest code Git cherry-picking of the original pull request missed a few changes to these files. Thanks again to Sheng for this most excellent contribution !
2013-08-15 22:24:42 +00:00
void operator() (tbb::blocked_range<int> const &r) const {
Landing 3.0.0.alpha Sync'ing the 'dev' branch with the 'feature_3.0dev' branch at commit 68c6d11fc36761ae1a5e6cdc3457be16f2e9704a The branch 'feature_3.0dev' is now locked and preserved for historical purposes.
2014-09-05 22:07:46 +00:00
#define USE_SIMD
#ifdef USE_SIMD
iso-646 fix for CUDA / CL / TBB
2016-06-25 21:23:55 +00:00
if (_srcDesc.length==4 && _srcDesc.stride==4 && _dstDesc.stride==4) {
Landing 3.0.0.alpha Sync'ing the 'dev' branch with the 'feature_3.0dev' branch at commit 68c6d11fc36761ae1a5e6cdc3457be16f2e9704a The branch 'feature_3.0dev' is now locked and preserved for historical purposes.
2014-09-05 22:07:46 +00:00
// SIMD fast path for aligned primvar data (4 floats)
int offset = _offsets[r.begin()];
ComputeStencilKernel<4>(_vertexSrc, _vertexDst,
_sizes, _indices+offset, _weights+offset, r.begin(), r.end());
iso-646 fix for CUDA / CL / TBB
2016-06-25 21:23:55 +00:00
} else if (_srcDesc.length==8 && _srcDesc.stride==4 && _dstDesc.stride==4) {
Landing 3.0.0.alpha Sync'ing the 'dev' branch with the 'feature_3.0dev' branch at commit 68c6d11fc36761ae1a5e6cdc3457be16f2e9704a The branch 'feature_3.0dev' is now locked and preserved for historical purposes.
2014-09-05 22:07:46 +00:00
// SIMD fast path for aligned primvar data (8 floats)
int offset = _offsets[r.begin()];
ComputeStencilKernel<8>(_vertexSrc, _vertexDst,
_sizes, _indices+offset, _weights+offset, r.begin(), r.end());
} else {
#else
{
osd refactor: split the vertex buffer argument into src and dst Changing all device kernels to take two buffer identifiers for source and destination separately. This change is an intermediate step toward upcoming context/controller refactoring. Previously we have a limitation that the source and destination vertex buffer has to be a single buffer, since the subdivision kernels are iteratively applied by level. With stencil tables, we don't have such a limitation any more, so we may want to apply stencils from seprate source buffer to another. To specifiy the output location within the destination buffer, we can use VertexBufferDescriptor.offset. This allows us not only configuring arbitrary batching scheme, but also relaxing the limitation that source and destination buffers are in same interleaved layout. For examples, we could include derivatives only in the destination buffer, which doesn't need to be allocated in the source buffer.
2015-05-07 23:11:00 +00:00
#endif
Change stencils sizes from unsigned char to int.
2015-05-19 17:16:56 +00:00
int const * sizes = _sizes;
Landing 3.0.0.alpha Sync'ing the 'dev' branch with the 'feature_3.0dev' branch at commit 68c6d11fc36761ae1a5e6cdc3457be16f2e9704a The branch 'feature_3.0dev' is now locked and preserved for historical purposes.
2014-09-05 22:07:46 +00:00
int const * indices = _indices;
float const * weights = _weights;
if (r.begin()>0) {
sizes += r.begin();
indices += _offsets[r.begin()];
weights += _offsets[r.begin()];
Update TBB C&C's with Sheng's (shengfuintel) latest code Git cherry-picking of the original pull request missed a few changes to these files. Thanks again to Sheng for this most excellent contribution !
2013-08-15 22:24:42 +00:00
}
Landing 3.0.0.alpha Sync'ing the 'dev' branch with the 'feature_3.0dev' branch at commit 68c6d11fc36761ae1a5e6cdc3457be16f2e9704a The branch 'feature_3.0dev' is now locked and preserved for historical purposes.
2014-09-05 22:07:46 +00:00
// Slow path for non-aligned data
osd refactor: split the vertex buffer argument into src and dst Changing all device kernels to take two buffer identifiers for source and destination separately. This change is an intermediate step toward upcoming context/controller refactoring. Previously we have a limitation that the source and destination vertex buffer has to be a single buffer, since the subdivision kernels are iteratively applied by level. With stencil tables, we don't have such a limitation any more, so we may want to apply stencils from seprate source buffer to another. To specifiy the output location within the destination buffer, we can use VertexBufferDescriptor.offset. This allows us not only configuring arbitrary batching scheme, but also relaxing the limitation that source and destination buffers are in same interleaved layout. For examples, we could include derivatives only in the destination buffer, which doesn't need to be allocated in the source buffer.
2015-05-07 23:11:00 +00:00
float * result = (float*)alloca(_srcDesc.length * sizeof(float));
initial checking in TBB kernel.
2013-06-05 17:55:24 +00:00
Landing 3.0.0.alpha Sync'ing the 'dev' branch with the 'feature_3.0dev' branch at commit 68c6d11fc36761ae1a5e6cdc3457be16f2e9704a The branch 'feature_3.0dev' is now locked and preserved for historical purposes.
2014-09-05 22:07:46 +00:00
for (int i=r.begin(); i<r.end(); ++i, ++sizes) {
initial checking in TBB kernel.
2013-06-05 17:55:24 +00:00
osd refactor: split the vertex buffer argument into src and dst Changing all device kernels to take two buffer identifiers for source and destination separately. This change is an intermediate step toward upcoming context/controller refactoring. Previously we have a limitation that the source and destination vertex buffer has to be a single buffer, since the subdivision kernels are iteratively applied by level. With stencil tables, we don't have such a limitation any more, so we may want to apply stencils from seprate source buffer to another. To specifiy the output location within the destination buffer, we can use VertexBufferDescriptor.offset. This allows us not only configuring arbitrary batching scheme, but also relaxing the limitation that source and destination buffers are in same interleaved layout. For examples, we could include derivatives only in the destination buffer, which doesn't need to be allocated in the source buffer.
2015-05-07 23:11:00 +00:00
clear(result, _dstDesc);
initial checking in TBB kernel.
2013-06-05 17:55:24 +00:00
Landing 3.0.0.alpha Sync'ing the 'dev' branch with the 'feature_3.0dev' branch at commit 68c6d11fc36761ae1a5e6cdc3457be16f2e9704a The branch 'feature_3.0dev' is now locked and preserved for historical purposes.
2014-09-05 22:07:46 +00:00
for (int j=0; j<*sizes; ++j) {
osd refactor: split the vertex buffer argument into src and dst Changing all device kernels to take two buffer identifiers for source and destination separately. This change is an intermediate step toward upcoming context/controller refactoring. Previously we have a limitation that the source and destination vertex buffer has to be a single buffer, since the subdivision kernels are iteratively applied by level. With stencil tables, we don't have such a limitation any more, so we may want to apply stencils from seprate source buffer to another. To specifiy the output location within the destination buffer, we can use VertexBufferDescriptor.offset. This allows us not only configuring arbitrary batching scheme, but also relaxing the limitation that source and destination buffers are in same interleaved layout. For examples, we could include derivatives only in the destination buffer, which doesn't need to be allocated in the source buffer.
2015-05-07 23:11:00 +00:00
addWithWeight(result, _vertexSrc, *indices++, *weights++, _srcDesc);
initial checking in TBB kernel.
2013-06-05 17:55:24 +00:00
}
osd refactor: split the vertex buffer argument into src and dst Changing all device kernels to take two buffer identifiers for source and destination separately. This change is an intermediate step toward upcoming context/controller refactoring. Previously we have a limitation that the source and destination vertex buffer has to be a single buffer, since the subdivision kernels are iteratively applied by level. With stencil tables, we don't have such a limitation any more, so we may want to apply stencils from seprate source buffer to another. To specifiy the output location within the destination buffer, we can use VertexBufferDescriptor.offset. This allows us not only configuring arbitrary batching scheme, but also relaxing the limitation that source and destination buffers are in same interleaved layout. For examples, we could include derivatives only in the destination buffer, which doesn't need to be allocated in the source buffer.
2015-05-07 23:11:00 +00:00
copy(_vertexDst, i, result, _dstDesc);
Added the CATMARK_RESTRICTED_VERT_VERTEX_A, CATMARK_RESTRICTED_VERT_VERTEX_B1, and CATMARK_RESTRICTED_VERT_VERTEX_B2 kernels which compute vertices resulting from the refinement of a smooth or (fully) sharp vertex. * CATMARK_RESTRICTED_VERT_VERTEX_A handles k_Crease and k_Corner rules * CATMARK_RESTRICTED_VERT_VERTEX_B1 handles regular k_Smooth and k_Dart rules * CATMARK_RESTRICTED_VERT_VERTEX_B2 handles irregular k_Smooth and k_Dart rules
2014-06-10 23:31:44 +00:00
}
}
}
};
Landing 3.0.0.alpha Sync'ing the 'dev' branch with the 'feature_3.0dev' branch at commit 68c6d11fc36761ae1a5e6cdc3457be16f2e9704a The branch 'feature_3.0dev' is now locked and preserved for historical purposes.
2014-09-05 22:07:46 +00:00
void
osdlayer: rename Osd::VertexBufferDescriptor to Osd::BufferDescriptor. A mechanical substitution of VertexBufferDescriptor with BufferDescriptor. Also removing unused files from osd.
2015-05-29 16:21:14 +00:00
TbbEvalStencils(float const * src, BufferDescriptor const &srcDesc,
float * dst, BufferDescriptor const &dstDesc,
Change stencils sizes from unsigned char to int.
2015-05-19 17:16:56 +00:00
int const * sizes,
Refurbish osd layer API. In OpenSubdiv 2.x, we encapsulated subdivision tables into compute context in osd layer since those tables are order-dependent and have to be applied in a certain manner. In 3.0, we adopted stencil table based refinement. It's more simple and such an encapsulation is no longer needed. Also 2.0 API has several ownership issues of GPU kernel caching, and forces unnecessary instantiation of controllers even though the cpu kernels typically don't need instances unlike GPU ones. This change completely revisit osd client facing APIs. All contexts and controllers were replaced with device-specific tables and evaluators. While we can still use consistent API across various device backends, unnecessary complexities have been removed. For example, cpu evaluator is just a set of static functions and also there's no need to replicate FarStencilTables to ComputeContext. Also the new API delegates the ownership of compiled GPU kernels to clients, for the better management of resources especially in multiple GPU environment. In addition to integrating ComputeController and EvalStencilController into a single function Evaluator::EvalStencils(), EvalLimit API is also added into Evaluator. This is working but still in progress, and we'll make a followup change for the complete implementation. -some naming convention changes: GLSLTransformFeedback to GLXFBEvaluator GLSLCompute to GLComputeEvaluator -move LimitLocation struct into examples/glEvalLimit. We're still discussing patch evaluation interface. Basically we'd like to tease all ptex-specific parametrization out of far/osd layer. TODO: -implments EvalPatches() in the right way -derivative evaluation API is still interim. -VertexBufferDescriptor needs a better API to advance its location -synchronization mechanism is not ideal (too global). -OsdMesh class is hacky. need to fix it.
2015-05-09 00:31:26 +00:00
int const * offsets,
int const * indices,
float const * weights,
int start, int end) {
osd refactor: split the vertex buffer argument into src and dst Changing all device kernels to take two buffer identifiers for source and destination separately. This change is an intermediate step toward upcoming context/controller refactoring. Previously we have a limitation that the source and destination vertex buffer has to be a single buffer, since the subdivision kernels are iteratively applied by level. With stencil tables, we don't have such a limitation any more, so we may want to apply stencils from seprate source buffer to another. To specifiy the output location within the destination buffer, we can use VertexBufferDescriptor.offset. This allows us not only configuring arbitrary batching scheme, but also relaxing the limitation that source and destination buffers are in same interleaved layout. For examples, we could include derivatives only in the destination buffer, which doesn't need to be allocated in the source buffer.
2015-05-07 23:11:00 +00:00
src += srcDesc.offset;
dst += dstDesc.offset;
TBBStencilKernel kernel(src, srcDesc, dst, dstDesc,
sizes, offsets, indices, weights);
initial checking in TBB kernel.
2013-06-05 17:55:24 +00:00
Update TBB C&C's with Sheng's (shengfuintel) latest code Git cherry-picking of the original pull request missed a few changes to these files. Thanks again to Sheng for this most excellent contribution !
2013-08-15 22:24:42 +00:00
tbb::blocked_range<int> range(start, end, grain_size);
initial checking in TBB kernel.
2013-06-05 17:55:24 +00:00
Update TBB C&C's with Sheng's (shengfuintel) latest code Git cherry-picking of the original pull request missed a few changes to these files. Thanks again to Sheng for this most excellent contribution !
2013-08-15 22:24:42 +00:00
tbb::parallel_for(range, kernel);
initial checking in TBB kernel.
2013-06-05 17:55:24 +00:00
}
Osd API refactor: EvalStencils and EvalPatches Add EvalStencils and EvalPatches API for most of CPU and GPU evaluators. with this change, Eval API in the osd layer consists of following parts: - Evaluators (Cpu, Omp, Tbb, Cuda, CL, GLXFB, GLCompute, D3D11Compute) implements EvalStencils and EvalPatches(*). Both supports derivatives (not fully implemented though) - Interop vertex buffer classes (optional, same as before) Note that these classes are not necessary to use Evaluators. All evaluators have EvalStencils/Patches which take device-specific buffer objects. For example, GLXFBEvaluator can take GLuint directly for both stencil tables and input primvars. Although using these interop classes makes it easy to integrate osd into relatively simple applications. - device-dependent StencilTable and PatchTable (optional) These are also optional, but can be used simply a substitute of Far::StencilTable and Far::PatchTable for osd evaluators. - PatchArray, PatchCoord, PatchParam They are tiny structs used for GPU based patch evaluation. (*) TODO and known issues: - CLEvaluator and D3D11Evaluator's EvalPatches() have not been implemented. - GPU Gregory patch evaluation has not been implemented in EvalPatches(). - CudaEvaluator::EvalPatches() is very unstable. - All patch evaluation kernels have not been well optimized. - Currently GLXFB kernel doesn't support derivative evaluation. There's a technical difficulty for the multi-stream output.
2015-05-26 04:51:55 +00:00
void
osdlayer: rename Osd::VertexBufferDescriptor to Osd::BufferDescriptor. A mechanical substitution of VertexBufferDescriptor with BufferDescriptor. Also removing unused files from osd.
2015-05-29 16:21:14 +00:00
TbbEvalStencils(float const * src, BufferDescriptor const &srcDesc,
float * dst, BufferDescriptor const &dstDesc,
float * du, BufferDescriptor const &duDesc,
float * dv, BufferDescriptor const &dvDesc,
Osd API refactor: EvalStencils and EvalPatches Add EvalStencils and EvalPatches API for most of CPU and GPU evaluators. with this change, Eval API in the osd layer consists of following parts: - Evaluators (Cpu, Omp, Tbb, Cuda, CL, GLXFB, GLCompute, D3D11Compute) implements EvalStencils and EvalPatches(*). Both supports derivatives (not fully implemented though) - Interop vertex buffer classes (optional, same as before) Note that these classes are not necessary to use Evaluators. All evaluators have EvalStencils/Patches which take device-specific buffer objects. For example, GLXFBEvaluator can take GLuint directly for both stencil tables and input primvars. Although using these interop classes makes it easy to integrate osd into relatively simple applications. - device-dependent StencilTable and PatchTable (optional) These are also optional, but can be used simply a substitute of Far::StencilTable and Far::PatchTable for osd evaluators. - PatchArray, PatchCoord, PatchParam They are tiny structs used for GPU based patch evaluation. (*) TODO and known issues: - CLEvaluator and D3D11Evaluator's EvalPatches() have not been implemented. - GPU Gregory patch evaluation has not been implemented in EvalPatches(). - CudaEvaluator::EvalPatches() is very unstable. - All patch evaluation kernels have not been well optimized. - Currently GLXFB kernel doesn't support derivative evaluation. There's a technical difficulty for the multi-stream output.
2015-05-26 04:51:55 +00:00
int const * sizes,
int const * offsets,
int const * indices,
float const * weights,
float const * duWeights,
float const * dvWeights,
int start, int end) {
if (src) src += srcDesc.offset;
if (dst) dst += dstDesc.offset;
if (du) du += duDesc.offset;
if (dv) dv += dvDesc.offset;
// PERFORMANCE: need to combine 3 launches together
if (dst) {
TBBStencilKernel kernel(src, srcDesc, dst, dstDesc,
sizes, offsets, indices, weights);
tbb::blocked_range<int> range(start, end, grain_size);
tbb::parallel_for(range, kernel);
}
if (du) {
TBBStencilKernel kernel(src, srcDesc, du, duDesc,
sizes, offsets, indices, duWeights);
tbb::blocked_range<int> range(start, end, grain_size);
tbb::parallel_for(range, kernel);
}
if (dv) {
TBBStencilKernel kernel(src, srcDesc, dv, dvDesc,
sizes, offsets, indices, dvWeights);
tbb::blocked_range<int> range(start, end, grain_size);
tbb::parallel_for(range, kernel);
}
Added missing Osd Evaluator methods for deriv eval Now that Far::LimitStencilTable and Far::PatchTable support evaluation of 1st and 2nd derivatives the Osd Evaluator API for evaluating stencils and patches has been updated to match.
2017-01-26 22:36:30 +00:00
}
void
TbbEvalStencils(float const * src, BufferDescriptor const &srcDesc,
float * dst, BufferDescriptor const &dstDesc,
float * du, BufferDescriptor const &duDesc,
float * dv, BufferDescriptor const &dvDesc,
float * duu, BufferDescriptor const &duuDesc,
float * duv, BufferDescriptor const &duvDesc,
float * dvv, BufferDescriptor const &dvvDesc,
int const * sizes,
int const * offsets,
int const * indices,
float const * weights,
float const * duWeights,
float const * dvWeights,
float const * duuWeights,
float const * duvWeights,
float const * dvvWeights,
int start, int end) {
if (src) src += srcDesc.offset;
if (dst) dst += dstDesc.offset;
if (du) du += duDesc.offset;
if (dv) dv += dvDesc.offset;
if (duu) duu += duuDesc.offset;
if (duv) duv += duvDesc.offset;
if (dvv) dvv += dvvDesc.offset;
// PERFORMANCE: need to combine 3 launches together
if (dst) {
TBBStencilKernel kernel(src, srcDesc, dst, dstDesc,
sizes, offsets, indices, weights);
tbb::blocked_range<int> range(start, end, grain_size);
tbb::parallel_for(range, kernel);
}
if (du) {
TBBStencilKernel kernel(src, srcDesc, du, duDesc,
sizes, offsets, indices, duWeights);
tbb::blocked_range<int> range(start, end, grain_size);
tbb::parallel_for(range, kernel);
}
if (dv) {
TBBStencilKernel kernel(src, srcDesc, dv, dvDesc,
sizes, offsets, indices, dvWeights);
tbb::blocked_range<int> range(start, end, grain_size);
tbb::parallel_for(range, kernel);
}
if (duu) {
TBBStencilKernel kernel(src, srcDesc, duu, duuDesc,
sizes, offsets, indices, duuWeights);
tbb::blocked_range<int> range(start, end, grain_size);
tbb::parallel_for(range, kernel);
}
if (duv) {
TBBStencilKernel kernel(src, srcDesc, duv, duvDesc,
sizes, offsets, indices, duvWeights);
tbb::blocked_range<int> range(start, end, grain_size);
tbb::parallel_for(range, kernel);
}
if (dvv) {
TBBStencilKernel kernel(src, srcDesc, dvv, dvvDesc,
sizes, offsets, indices, dvvWeights);
tbb::blocked_range<int> range(start, end, grain_size);
tbb::parallel_for(range, kernel);
}
Osd API refactor: EvalStencils and EvalPatches Add EvalStencils and EvalPatches API for most of CPU and GPU evaluators. with this change, Eval API in the osd layer consists of following parts: - Evaluators (Cpu, Omp, Tbb, Cuda, CL, GLXFB, GLCompute, D3D11Compute) implements EvalStencils and EvalPatches(*). Both supports derivatives (not fully implemented though) - Interop vertex buffer classes (optional, same as before) Note that these classes are not necessary to use Evaluators. All evaluators have EvalStencils/Patches which take device-specific buffer objects. For example, GLXFBEvaluator can take GLuint directly for both stencil tables and input primvars. Although using these interop classes makes it easy to integrate osd into relatively simple applications. - device-dependent StencilTable and PatchTable (optional) These are also optional, but can be used simply a substitute of Far::StencilTable and Far::PatchTable for osd evaluators. - PatchArray, PatchCoord, PatchParam They are tiny structs used for GPU based patch evaluation. (*) TODO and known issues: - CLEvaluator and D3D11Evaluator's EvalPatches() have not been implemented. - GPU Gregory patch evaluation has not been implemented in EvalPatches(). - CudaEvaluator::EvalPatches() is very unstable. - All patch evaluation kernels have not been well optimized. - Currently GLXFB kernel doesn't support derivative evaluation. There's a technical difficulty for the multi-stream output.
2015-05-26 04:51:55 +00:00
}
// ---------------------------------------------------------------------------
template <typename T>
struct BufferAdapter {
BufferAdapter(T *p, int length, int stride) :
_p(p), _length(length), _stride(stride) { }
void Clear() {
for (int i = 0; i < _length; ++i) _p[i] = 0;
}
void AddWithWeight(T const *src, float w) {
if (_p) {
for (int i = 0; i < _length; ++i) {
_p[i] += src[i] * w;
}
}
}
const T *operator[] (int index) const {
return _p + _stride * index;
}
BufferAdapter<T> & operator ++() {
if (_p) {
_p += _stride;
}
return *this;
}
T *_p;
int _length;
int _stride;
};
class TbbEvalPatchesKernel {
osdlayer: rename Osd::VertexBufferDescriptor to Osd::BufferDescriptor. A mechanical substitution of VertexBufferDescriptor with BufferDescriptor. Also removing unused files from osd.
2015-05-29 16:21:14 +00:00
BufferDescriptor _srcDesc;
BufferDescriptor _dstDesc;
BufferDescriptor _dstDuDesc;
BufferDescriptor _dstDvDesc;
Added missing Osd Evaluator methods for deriv eval Now that Far::LimitStencilTable and Far::PatchTable support evaluation of 1st and 2nd derivatives the Osd Evaluator API for evaluating stencils and patches has been updated to match.
2017-01-26 22:36:30 +00:00
BufferDescriptor _dstDuuDesc;
BufferDescriptor _dstDuvDesc;
BufferDescriptor _dstDvvDesc;
Osd API refactor: EvalStencils and EvalPatches Add EvalStencils and EvalPatches API for most of CPU and GPU evaluators. with this change, Eval API in the osd layer consists of following parts: - Evaluators (Cpu, Omp, Tbb, Cuda, CL, GLXFB, GLCompute, D3D11Compute) implements EvalStencils and EvalPatches(*). Both supports derivatives (not fully implemented though) - Interop vertex buffer classes (optional, same as before) Note that these classes are not necessary to use Evaluators. All evaluators have EvalStencils/Patches which take device-specific buffer objects. For example, GLXFBEvaluator can take GLuint directly for both stencil tables and input primvars. Although using these interop classes makes it easy to integrate osd into relatively simple applications. - device-dependent StencilTable and PatchTable (optional) These are also optional, but can be used simply a substitute of Far::StencilTable and Far::PatchTable for osd evaluators. - PatchArray, PatchCoord, PatchParam They are tiny structs used for GPU based patch evaluation. (*) TODO and known issues: - CLEvaluator and D3D11Evaluator's EvalPatches() have not been implemented. - GPU Gregory patch evaluation has not been implemented in EvalPatches(). - CudaEvaluator::EvalPatches() is very unstable. - All patch evaluation kernels have not been well optimized. - Currently GLXFB kernel doesn't support derivative evaluation. There's a technical difficulty for the multi-stream output.
2015-05-26 04:51:55 +00:00
float const * _src;
float * _dst;
float * _dstDu;
float * _dstDv;
Added missing Osd Evaluator methods for deriv eval Now that Far::LimitStencilTable and Far::PatchTable support evaluation of 1st and 2nd derivatives the Osd Evaluator API for evaluating stencils and patches has been updated to match.
2017-01-26 22:36:30 +00:00
float * _dstDuu;
float * _dstDuv;
float * _dstDvv;
Osd API refactor: EvalStencils and EvalPatches Add EvalStencils and EvalPatches API for most of CPU and GPU evaluators. with this change, Eval API in the osd layer consists of following parts: - Evaluators (Cpu, Omp, Tbb, Cuda, CL, GLXFB, GLCompute, D3D11Compute) implements EvalStencils and EvalPatches(*). Both supports derivatives (not fully implemented though) - Interop vertex buffer classes (optional, same as before) Note that these classes are not necessary to use Evaluators. All evaluators have EvalStencils/Patches which take device-specific buffer objects. For example, GLXFBEvaluator can take GLuint directly for both stencil tables and input primvars. Although using these interop classes makes it easy to integrate osd into relatively simple applications. - device-dependent StencilTable and PatchTable (optional) These are also optional, but can be used simply a substitute of Far::StencilTable and Far::PatchTable for osd evaluators. - PatchArray, PatchCoord, PatchParam They are tiny structs used for GPU based patch evaluation. (*) TODO and known issues: - CLEvaluator and D3D11Evaluator's EvalPatches() have not been implemented. - GPU Gregory patch evaluation has not been implemented in EvalPatches(). - CudaEvaluator::EvalPatches() is very unstable. - All patch evaluation kernels have not been well optimized. - Currently GLXFB kernel doesn't support derivative evaluation. There's a technical difficulty for the multi-stream output.
2015-05-26 04:51:55 +00:00
int _numPatchCoords;
const PatchCoord *_patchCoords;
const PatchArray *_patchArrayBuffer;
const int *_patchIndexBuffer;
const PatchParam *_patchParamBuffer;
public:
osdlayer: rename Osd::VertexBufferDescriptor to Osd::BufferDescriptor. A mechanical substitution of VertexBufferDescriptor with BufferDescriptor. Also removing unused files from osd.
2015-05-29 16:21:14 +00:00
TbbEvalPatchesKernel(float const *src, BufferDescriptor srcDesc,
float *dst, BufferDescriptor dstDesc,
float *dstDu, BufferDescriptor dstDuDesc,
float *dstDv, BufferDescriptor dstDvDesc,
Added missing Osd Evaluator methods for deriv eval Now that Far::LimitStencilTable and Far::PatchTable support evaluation of 1st and 2nd derivatives the Osd Evaluator API for evaluating stencils and patches has been updated to match.
2017-01-26 22:36:30 +00:00
float *dstDuu, BufferDescriptor dstDuuDesc,
float *dstDuv, BufferDescriptor dstDuvDesc,
float *dstDvv, BufferDescriptor dstDvvDesc,
Osd API refactor: EvalStencils and EvalPatches Add EvalStencils and EvalPatches API for most of CPU and GPU evaluators. with this change, Eval API in the osd layer consists of following parts: - Evaluators (Cpu, Omp, Tbb, Cuda, CL, GLXFB, GLCompute, D3D11Compute) implements EvalStencils and EvalPatches(*). Both supports derivatives (not fully implemented though) - Interop vertex buffer classes (optional, same as before) Note that these classes are not necessary to use Evaluators. All evaluators have EvalStencils/Patches which take device-specific buffer objects. For example, GLXFBEvaluator can take GLuint directly for both stencil tables and input primvars. Although using these interop classes makes it easy to integrate osd into relatively simple applications. - device-dependent StencilTable and PatchTable (optional) These are also optional, but can be used simply a substitute of Far::StencilTable and Far::PatchTable for osd evaluators. - PatchArray, PatchCoord, PatchParam They are tiny structs used for GPU based patch evaluation. (*) TODO and known issues: - CLEvaluator and D3D11Evaluator's EvalPatches() have not been implemented. - GPU Gregory patch evaluation has not been implemented in EvalPatches(). - CudaEvaluator::EvalPatches() is very unstable. - All patch evaluation kernels have not been well optimized. - Currently GLXFB kernel doesn't support derivative evaluation. There's a technical difficulty for the multi-stream output.
2015-05-26 04:51:55 +00:00
int numPatchCoords,
const PatchCoord *patchCoords,
const PatchArray *patchArrayBuffer,
const int *patchIndexBuffer,
const PatchParam *patchParamBuffer) :
_srcDesc(srcDesc), _dstDesc(dstDesc),
_dstDuDesc(dstDuDesc), _dstDvDesc(dstDvDesc),
Added missing Osd Evaluator methods for deriv eval Now that Far::LimitStencilTable and Far::PatchTable support evaluation of 1st and 2nd derivatives the Osd Evaluator API for evaluating stencils and patches has been updated to match.
2017-01-26 22:36:30 +00:00
_dstDuuDesc(dstDuuDesc), _dstDuvDesc(dstDuvDesc), _dstDvvDesc(dstDvvDesc),
_src(src), _dst(dst),
_dstDu(dstDu), _dstDv(dstDv),
_dstDuu(dstDuu), _dstDuv(dstDuv), _dstDvv(dstDvv),
Osd API refactor: EvalStencils and EvalPatches Add EvalStencils and EvalPatches API for most of CPU and GPU evaluators. with this change, Eval API in the osd layer consists of following parts: - Evaluators (Cpu, Omp, Tbb, Cuda, CL, GLXFB, GLCompute, D3D11Compute) implements EvalStencils and EvalPatches(*). Both supports derivatives (not fully implemented though) - Interop vertex buffer classes (optional, same as before) Note that these classes are not necessary to use Evaluators. All evaluators have EvalStencils/Patches which take device-specific buffer objects. For example, GLXFBEvaluator can take GLuint directly for both stencil tables and input primvars. Although using these interop classes makes it easy to integrate osd into relatively simple applications. - device-dependent StencilTable and PatchTable (optional) These are also optional, but can be used simply a substitute of Far::StencilTable and Far::PatchTable for osd evaluators. - PatchArray, PatchCoord, PatchParam They are tiny structs used for GPU based patch evaluation. (*) TODO and known issues: - CLEvaluator and D3D11Evaluator's EvalPatches() have not been implemented. - GPU Gregory patch evaluation has not been implemented in EvalPatches(). - CudaEvaluator::EvalPatches() is very unstable. - All patch evaluation kernels have not been well optimized. - Currently GLXFB kernel doesn't support derivative evaluation. There's a technical difficulty for the multi-stream output.
2015-05-26 04:51:55 +00:00
_numPatchCoords(numPatchCoords),
_patchCoords(patchCoords),
_patchArrayBuffer(patchArrayBuffer),
_patchIndexBuffer(patchIndexBuffer),
_patchParamBuffer(patchParamBuffer) {
}
void operator() (tbb::blocked_range<int> const &r) const {
if (_dstDu == NULL && _dstDv == NULL) {
compute(r);
Added missing Osd Evaluator methods for deriv eval Now that Far::LimitStencilTable and Far::PatchTable support evaluation of 1st and 2nd derivatives the Osd Evaluator API for evaluating stencils and patches has been updated to match.
2017-01-26 22:36:30 +00:00
} else if (_dstDuu == NULL && _dstDuv == NULL && _dstDvv == NULL) {
computeWith1stDerivative(r);
Osd API refactor: EvalStencils and EvalPatches Add EvalStencils and EvalPatches API for most of CPU and GPU evaluators. with this change, Eval API in the osd layer consists of following parts: - Evaluators (Cpu, Omp, Tbb, Cuda, CL, GLXFB, GLCompute, D3D11Compute) implements EvalStencils and EvalPatches(*). Both supports derivatives (not fully implemented though) - Interop vertex buffer classes (optional, same as before) Note that these classes are not necessary to use Evaluators. All evaluators have EvalStencils/Patches which take device-specific buffer objects. For example, GLXFBEvaluator can take GLuint directly for both stencil tables and input primvars. Although using these interop classes makes it easy to integrate osd into relatively simple applications. - device-dependent StencilTable and PatchTable (optional) These are also optional, but can be used simply a substitute of Far::StencilTable and Far::PatchTable for osd evaluators. - PatchArray, PatchCoord, PatchParam They are tiny structs used for GPU based patch evaluation. (*) TODO and known issues: - CLEvaluator and D3D11Evaluator's EvalPatches() have not been implemented. - GPU Gregory patch evaluation has not been implemented in EvalPatches(). - CudaEvaluator::EvalPatches() is very unstable. - All patch evaluation kernels have not been well optimized. - Currently GLXFB kernel doesn't support derivative evaluation. There's a technical difficulty for the multi-stream output.
2015-05-26 04:51:55 +00:00
} else {
Added missing Osd Evaluator methods for deriv eval Now that Far::LimitStencilTable and Far::PatchTable support evaluation of 1st and 2nd derivatives the Osd Evaluator API for evaluating stencils and patches has been updated to match.
2017-01-26 22:36:30 +00:00
computeWith2ndDerivative(r);
Osd API refactor: EvalStencils and EvalPatches Add EvalStencils and EvalPatches API for most of CPU and GPU evaluators. with this change, Eval API in the osd layer consists of following parts: - Evaluators (Cpu, Omp, Tbb, Cuda, CL, GLXFB, GLCompute, D3D11Compute) implements EvalStencils and EvalPatches(*). Both supports derivatives (not fully implemented though) - Interop vertex buffer classes (optional, same as before) Note that these classes are not necessary to use Evaluators. All evaluators have EvalStencils/Patches which take device-specific buffer objects. For example, GLXFBEvaluator can take GLuint directly for both stencil tables and input primvars. Although using these interop classes makes it easy to integrate osd into relatively simple applications. - device-dependent StencilTable and PatchTable (optional) These are also optional, but can be used simply a substitute of Far::StencilTable and Far::PatchTable for osd evaluators. - PatchArray, PatchCoord, PatchParam They are tiny structs used for GPU based patch evaluation. (*) TODO and known issues: - CLEvaluator and D3D11Evaluator's EvalPatches() have not been implemented. - GPU Gregory patch evaluation has not been implemented in EvalPatches(). - CudaEvaluator::EvalPatches() is very unstable. - All patch evaluation kernels have not been well optimized. - Currently GLXFB kernel doesn't support derivative evaluation. There's a technical difficulty for the multi-stream output.
2015-05-26 04:51:55 +00:00
}
}
void compute(tbb::blocked_range<int> const &r) const {
Improved patch basis eval for Osd to match Far This updates the patch basis evaluation functions in Osd to match recent changes to far/patchBasis. This also exposes a common facility for dealing with PatchCoord, PatchArray, and PatchParam. These are exposed as global functions operating on struct data, since C++ style class methods are not supported by all of the Osd shader and kernel execution envirionments. Changes: - Merged far/patchBasis.cpp to osd/patchBasisCommon{,Types,Eval}.h - Exposed PatchCoord, PatchArray, and PatchParam to Osd kernels - exposed OsdEvaluatePatchBasis and OsdEvaluatePatchBasisNormalized - Updated CPU, TBB, Omp, CUDA, OpenCL, GLSL, HLSL, and Metal evaluators - Updated glFVarViewer
2018-10-30 07:37:25 +00:00
float wP[20];
Osd API refactor: EvalStencils and EvalPatches Add EvalStencils and EvalPatches API for most of CPU and GPU evaluators. with this change, Eval API in the osd layer consists of following parts: - Evaluators (Cpu, Omp, Tbb, Cuda, CL, GLXFB, GLCompute, D3D11Compute) implements EvalStencils and EvalPatches(*). Both supports derivatives (not fully implemented though) - Interop vertex buffer classes (optional, same as before) Note that these classes are not necessary to use Evaluators. All evaluators have EvalStencils/Patches which take device-specific buffer objects. For example, GLXFBEvaluator can take GLuint directly for both stencil tables and input primvars. Although using these interop classes makes it easy to integrate osd into relatively simple applications. - device-dependent StencilTable and PatchTable (optional) These are also optional, but can be used simply a substitute of Far::StencilTable and Far::PatchTable for osd evaluators. - PatchArray, PatchCoord, PatchParam They are tiny structs used for GPU based patch evaluation. (*) TODO and known issues: - CLEvaluator and D3D11Evaluator's EvalPatches() have not been implemented. - GPU Gregory patch evaluation has not been implemented in EvalPatches(). - CudaEvaluator::EvalPatches() is very unstable. - All patch evaluation kernels have not been well optimized. - Currently GLXFB kernel doesn't support derivative evaluation. There's a technical difficulty for the multi-stream output.
2015-05-26 04:51:55 +00:00
BufferAdapter<const float> srcT(_src + _srcDesc.offset,
_srcDesc.length,
_srcDesc.stride);
BufferAdapter<float> dstT(_dst + _dstDesc.offset
+ r.begin() * _dstDesc.stride,
_dstDesc.length,
_dstDesc.stride);
Added missing Osd Evaluator methods for deriv eval Now that Far::LimitStencilTable and Far::PatchTable support evaluation of 1st and 2nd derivatives the Osd Evaluator API for evaluating stencils and patches has been updated to match.
2017-01-26 22:36:30 +00:00
for (int i = r.begin(); i < r.end(); ++i) {
PatchCoord const &coord = _patchCoords[i];
PatchArray const &array = _patchArrayBuffer[coord.handle.arrayIndex];
Improved patch basis eval for Osd to match Far This updates the patch basis evaluation functions in Osd to match recent changes to far/patchBasis. This also exposes a common facility for dealing with PatchCoord, PatchArray, and PatchParam. These are exposed as global functions operating on struct data, since C++ style class methods are not supported by all of the Osd shader and kernel execution envirionments. Changes: - Merged far/patchBasis.cpp to osd/patchBasisCommon{,Types,Eval}.h - Exposed PatchCoord, PatchArray, and PatchParam to Osd kernels - exposed OsdEvaluatePatchBasis and OsdEvaluatePatchBasisNormalized - Updated CPU, TBB, Omp, CUDA, OpenCL, GLSL, HLSL, and Metal evaluators - Updated glFVarViewer
2018-10-30 07:37:25 +00:00
Osd::PatchParam const & paramStruct =
Added missing Osd Evaluator methods for deriv eval Now that Far::LimitStencilTable and Far::PatchTable support evaluation of 1st and 2nd derivatives the Osd Evaluator API for evaluating stencils and patches has been updated to match.
2017-01-26 22:36:30 +00:00
_patchParamBuffer[coord.handle.patchIndex];
Improved patch basis eval for Osd to match Far This updates the patch basis evaluation functions in Osd to match recent changes to far/patchBasis. This also exposes a common facility for dealing with PatchCoord, PatchArray, and PatchParam. These are exposed as global functions operating on struct data, since C++ style class methods are not supported by all of the Osd shader and kernel execution envirionments. Changes: - Merged far/patchBasis.cpp to osd/patchBasisCommon{,Types,Eval}.h - Exposed PatchCoord, PatchArray, and PatchParam to Osd kernels - exposed OsdEvaluatePatchBasis and OsdEvaluatePatchBasisNormalized - Updated CPU, TBB, Omp, CUDA, OpenCL, GLSL, HLSL, and Metal evaluators - Updated glFVarViewer
2018-10-30 07:37:25 +00:00
OsdPatchParam param = OsdPatchParamInit(
paramStruct.field0, paramStruct.field1, paramStruct.sharpness);
int patchType = OsdPatchParamIsRegular(param)
? array.GetPatchTypeRegular()
: array.GetPatchTypeIrregular();
Added missing Osd Evaluator methods for deriv eval Now that Far::LimitStencilTable and Far::PatchTable support evaluation of 1st and 2nd derivatives the Osd Evaluator API for evaluating stencils and patches has been updated to match.
2017-01-26 22:36:30 +00:00
Improved patch basis eval for Osd to match Far This updates the patch basis evaluation functions in Osd to match recent changes to far/patchBasis. This also exposes a common facility for dealing with PatchCoord, PatchArray, and PatchParam. These are exposed as global functions operating on struct data, since C++ style class methods are not supported by all of the Osd shader and kernel execution envirionments. Changes: - Merged far/patchBasis.cpp to osd/patchBasisCommon{,Types,Eval}.h - Exposed PatchCoord, PatchArray, and PatchParam to Osd kernels - exposed OsdEvaluatePatchBasis and OsdEvaluatePatchBasisNormalized - Updated CPU, TBB, Omp, CUDA, OpenCL, GLSL, HLSL, and Metal evaluators - Updated glFVarViewer
2018-10-30 07:37:25 +00:00
int nPoints = OsdEvaluatePatchBasis(patchType, param,
coord.s, coord.t, wP, 0, 0, 0, 0, 0);
Added missing Osd Evaluator methods for deriv eval Now that Far::LimitStencilTable and Far::PatchTable support evaluation of 1st and 2nd derivatives the Osd Evaluator API for evaluating stencils and patches has been updated to match.
2017-01-26 22:36:30 +00:00
Improved patch basis eval for Osd to match Far This updates the patch basis evaluation functions in Osd to match recent changes to far/patchBasis. This also exposes a common facility for dealing with PatchCoord, PatchArray, and PatchParam. These are exposed as global functions operating on struct data, since C++ style class methods are not supported by all of the Osd shader and kernel execution envirionments. Changes: - Merged far/patchBasis.cpp to osd/patchBasisCommon{,Types,Eval}.h - Exposed PatchCoord, PatchArray, and PatchParam to Osd kernels - exposed OsdEvaluatePatchBasis and OsdEvaluatePatchBasisNormalized - Updated CPU, TBB, Omp, CUDA, OpenCL, GLSL, HLSL, and Metal evaluators - Updated glFVarViewer
2018-10-30 07:37:25 +00:00
int indexBase = array.GetIndexBase() + array.GetStride() *
Added missing Osd Evaluator methods for deriv eval Now that Far::LimitStencilTable and Far::PatchTable support evaluation of 1st and 2nd derivatives the Osd Evaluator API for evaluating stencils and patches has been updated to match.
2017-01-26 22:36:30 +00:00
(coord.handle.patchIndex - array.GetPrimitiveIdBase());
const int *cvs = &_patchIndexBuffer[indexBase];
dstT.Clear();
Improved patch basis eval for Osd to match Far This updates the patch basis evaluation functions in Osd to match recent changes to far/patchBasis. This also exposes a common facility for dealing with PatchCoord, PatchArray, and PatchParam. These are exposed as global functions operating on struct data, since C++ style class methods are not supported by all of the Osd shader and kernel execution envirionments. Changes: - Merged far/patchBasis.cpp to osd/patchBasisCommon{,Types,Eval}.h - Exposed PatchCoord, PatchArray, and PatchParam to Osd kernels - exposed OsdEvaluatePatchBasis and OsdEvaluatePatchBasisNormalized - Updated CPU, TBB, Omp, CUDA, OpenCL, GLSL, HLSL, and Metal evaluators - Updated glFVarViewer
2018-10-30 07:37:25 +00:00
for (int j = 0; j < nPoints; ++j) {
Added missing Osd Evaluator methods for deriv eval Now that Far::LimitStencilTable and Far::PatchTable support evaluation of 1st and 2nd derivatives the Osd Evaluator API for evaluating stencils and patches has been updated to match.
2017-01-26 22:36:30 +00:00
dstT.AddWithWeight(srcT[cvs[j]], wP[j]);
}
++dstT;
}
}
void computeWith1stDerivative(tbb::blocked_range<int> const &r) const {
float wP[20], wDu[20], wDv[20];
BufferAdapter<const float> srcT(_src + _srcDesc.offset,
_srcDesc.length,
_srcDesc.stride);
BufferAdapter<float> dstT(_dst + _dstDesc.offset
+ r.begin() * _dstDesc.stride,
_dstDesc.length,
_dstDesc.stride);
BufferAdapter<float> dstDuT(_dstDu + _dstDuDesc.offset
+ r.begin() * _dstDuDesc.stride,
Osd API refactor: EvalStencils and EvalPatches Add EvalStencils and EvalPatches API for most of CPU and GPU evaluators. with this change, Eval API in the osd layer consists of following parts: - Evaluators (Cpu, Omp, Tbb, Cuda, CL, GLXFB, GLCompute, D3D11Compute) implements EvalStencils and EvalPatches(*). Both supports derivatives (not fully implemented though) - Interop vertex buffer classes (optional, same as before) Note that these classes are not necessary to use Evaluators. All evaluators have EvalStencils/Patches which take device-specific buffer objects. For example, GLXFBEvaluator can take GLuint directly for both stencil tables and input primvars. Although using these interop classes makes it easy to integrate osd into relatively simple applications. - device-dependent StencilTable and PatchTable (optional) These are also optional, but can be used simply a substitute of Far::StencilTable and Far::PatchTable for osd evaluators. - PatchArray, PatchCoord, PatchParam They are tiny structs used for GPU based patch evaluation. (*) TODO and known issues: - CLEvaluator and D3D11Evaluator's EvalPatches() have not been implemented. - GPU Gregory patch evaluation has not been implemented in EvalPatches(). - CudaEvaluator::EvalPatches() is very unstable. - All patch evaluation kernels have not been well optimized. - Currently GLXFB kernel doesn't support derivative evaluation. There's a technical difficulty for the multi-stream output.
2015-05-26 04:51:55 +00:00
_dstDuDesc.length,
_dstDuDesc.stride);
Added missing Osd Evaluator methods for deriv eval Now that Far::LimitStencilTable and Far::PatchTable support evaluation of 1st and 2nd derivatives the Osd Evaluator API for evaluating stencils and patches has been updated to match.
2017-01-26 22:36:30 +00:00
BufferAdapter<float> dstDvT(_dstDv + _dstDvDesc.offset
+ r.begin() * _dstDvDesc.stride,
Osd API refactor: EvalStencils and EvalPatches Add EvalStencils and EvalPatches API for most of CPU and GPU evaluators. with this change, Eval API in the osd layer consists of following parts: - Evaluators (Cpu, Omp, Tbb, Cuda, CL, GLXFB, GLCompute, D3D11Compute) implements EvalStencils and EvalPatches(*). Both supports derivatives (not fully implemented though) - Interop vertex buffer classes (optional, same as before) Note that these classes are not necessary to use Evaluators. All evaluators have EvalStencils/Patches which take device-specific buffer objects. For example, GLXFBEvaluator can take GLuint directly for both stencil tables and input primvars. Although using these interop classes makes it easy to integrate osd into relatively simple applications. - device-dependent StencilTable and PatchTable (optional) These are also optional, but can be used simply a substitute of Far::StencilTable and Far::PatchTable for osd evaluators. - PatchArray, PatchCoord, PatchParam They are tiny structs used for GPU based patch evaluation. (*) TODO and known issues: - CLEvaluator and D3D11Evaluator's EvalPatches() have not been implemented. - GPU Gregory patch evaluation has not been implemented in EvalPatches(). - CudaEvaluator::EvalPatches() is very unstable. - All patch evaluation kernels have not been well optimized. - Currently GLXFB kernel doesn't support derivative evaluation. There's a technical difficulty for the multi-stream output.
2015-05-26 04:51:55 +00:00
_dstDvDesc.length,
_dstDvDesc.stride);
for (int i = r.begin(); i < r.end(); ++i) {
PatchCoord const &coord = _patchCoords[i];
PatchArray const &array = _patchArrayBuffer[coord.handle.arrayIndex];
Improved patch basis eval for Osd to match Far This updates the patch basis evaluation functions in Osd to match recent changes to far/patchBasis. This also exposes a common facility for dealing with PatchCoord, PatchArray, and PatchParam. These are exposed as global functions operating on struct data, since C++ style class methods are not supported by all of the Osd shader and kernel execution envirionments. Changes: - Merged far/patchBasis.cpp to osd/patchBasisCommon{,Types,Eval}.h - Exposed PatchCoord, PatchArray, and PatchParam to Osd kernels - exposed OsdEvaluatePatchBasis and OsdEvaluatePatchBasisNormalized - Updated CPU, TBB, Omp, CUDA, OpenCL, GLSL, HLSL, and Metal evaluators - Updated glFVarViewer
2018-10-30 07:37:25 +00:00
Osd::PatchParam const & paramStruct =
Reverted recent Far::PatchParam refactoring This reverts most of the recent changes to the organization of Far::PatchParam. In particular, the core parameterization is no longer exposed as a speparate PatchParamBase class. We'll revisit this again in a later release, but for now we will stick with a more straight forward implementation.
2016-09-29 16:38:32 +00:00
_patchParamBuffer[coord.handle.patchIndex];
Improved patch basis eval for Osd to match Far This updates the patch basis evaluation functions in Osd to match recent changes to far/patchBasis. This also exposes a common facility for dealing with PatchCoord, PatchArray, and PatchParam. These are exposed as global functions operating on struct data, since C++ style class methods are not supported by all of the Osd shader and kernel execution envirionments. Changes: - Merged far/patchBasis.cpp to osd/patchBasisCommon{,Types,Eval}.h - Exposed PatchCoord, PatchArray, and PatchParam to Osd kernels - exposed OsdEvaluatePatchBasis and OsdEvaluatePatchBasisNormalized - Updated CPU, TBB, Omp, CUDA, OpenCL, GLSL, HLSL, and Metal evaluators - Updated glFVarViewer
2018-10-30 07:37:25 +00:00
OsdPatchParam param = OsdPatchParamInit(
paramStruct.field0, paramStruct.field1, paramStruct.sharpness);
Osd API refactor: EvalStencils and EvalPatches Add EvalStencils and EvalPatches API for most of CPU and GPU evaluators. with this change, Eval API in the osd layer consists of following parts: - Evaluators (Cpu, Omp, Tbb, Cuda, CL, GLXFB, GLCompute, D3D11Compute) implements EvalStencils and EvalPatches(*). Both supports derivatives (not fully implemented though) - Interop vertex buffer classes (optional, same as before) Note that these classes are not necessary to use Evaluators. All evaluators have EvalStencils/Patches which take device-specific buffer objects. For example, GLXFBEvaluator can take GLuint directly for both stencil tables and input primvars. Although using these interop classes makes it easy to integrate osd into relatively simple applications. - device-dependent StencilTable and PatchTable (optional) These are also optional, but can be used simply a substitute of Far::StencilTable and Far::PatchTable for osd evaluators. - PatchArray, PatchCoord, PatchParam They are tiny structs used for GPU based patch evaluation. (*) TODO and known issues: - CLEvaluator and D3D11Evaluator's EvalPatches() have not been implemented. - GPU Gregory patch evaluation has not been implemented in EvalPatches(). - CudaEvaluator::EvalPatches() is very unstable. - All patch evaluation kernels have not been well optimized. - Currently GLXFB kernel doesn't support derivative evaluation. There's a technical difficulty for the multi-stream output.
2015-05-26 04:51:55 +00:00
Improved patch basis eval for Osd to match Far This updates the patch basis evaluation functions in Osd to match recent changes to far/patchBasis. This also exposes a common facility for dealing with PatchCoord, PatchArray, and PatchParam. These are exposed as global functions operating on struct data, since C++ style class methods are not supported by all of the Osd shader and kernel execution envirionments. Changes: - Merged far/patchBasis.cpp to osd/patchBasisCommon{,Types,Eval}.h - Exposed PatchCoord, PatchArray, and PatchParam to Osd kernels - exposed OsdEvaluatePatchBasis and OsdEvaluatePatchBasisNormalized - Updated CPU, TBB, Omp, CUDA, OpenCL, GLSL, HLSL, and Metal evaluators - Updated glFVarViewer
2018-10-30 07:37:25 +00:00
int patchType = OsdPatchParamIsRegular(param)
? array.GetPatchTypeRegular()
: array.GetPatchTypeIrregular();
Osd API refactor: EvalStencils and EvalPatches Add EvalStencils and EvalPatches API for most of CPU and GPU evaluators. with this change, Eval API in the osd layer consists of following parts: - Evaluators (Cpu, Omp, Tbb, Cuda, CL, GLXFB, GLCompute, D3D11Compute) implements EvalStencils and EvalPatches(*). Both supports derivatives (not fully implemented though) - Interop vertex buffer classes (optional, same as before) Note that these classes are not necessary to use Evaluators. All evaluators have EvalStencils/Patches which take device-specific buffer objects. For example, GLXFBEvaluator can take GLuint directly for both stencil tables and input primvars. Although using these interop classes makes it easy to integrate osd into relatively simple applications. - device-dependent StencilTable and PatchTable (optional) These are also optional, but can be used simply a substitute of Far::StencilTable and Far::PatchTable for osd evaluators. - PatchArray, PatchCoord, PatchParam They are tiny structs used for GPU based patch evaluation. (*) TODO and known issues: - CLEvaluator and D3D11Evaluator's EvalPatches() have not been implemented. - GPU Gregory patch evaluation has not been implemented in EvalPatches(). - CudaEvaluator::EvalPatches() is very unstable. - All patch evaluation kernels have not been well optimized. - Currently GLXFB kernel doesn't support derivative evaluation. There's a technical difficulty for the multi-stream output.
2015-05-26 04:51:55 +00:00
Improved patch basis eval for Osd to match Far This updates the patch basis evaluation functions in Osd to match recent changes to far/patchBasis. This also exposes a common facility for dealing with PatchCoord, PatchArray, and PatchParam. These are exposed as global functions operating on struct data, since C++ style class methods are not supported by all of the Osd shader and kernel execution envirionments. Changes: - Merged far/patchBasis.cpp to osd/patchBasisCommon{,Types,Eval}.h - Exposed PatchCoord, PatchArray, and PatchParam to Osd kernels - exposed OsdEvaluatePatchBasis and OsdEvaluatePatchBasisNormalized - Updated CPU, TBB, Omp, CUDA, OpenCL, GLSL, HLSL, and Metal evaluators - Updated glFVarViewer
2018-10-30 07:37:25 +00:00
int nPoints = OsdEvaluatePatchBasis(patchType, param,
coord.s, coord.t, wP, wDu, wDv, 0, 0, 0);
int indexBase = array.GetIndexBase() + array.GetStride() *
Osd Varying and FaceVarying Patch Evaluation Implemented EvalPatchesVarying and EvalPatchesFaceVarying methods for Osd::*Evaluator classes, i.e. cpu, omp, tbb, GLXFB, GLSLCompute, OpenCL, and CUDA. Also, the GPU Kernel implementations have been updated to use the common patchBasis implementation instead of re-implementing methods to compute patch basis weights locally.
2016-09-29 16:56:15 +00:00
(coord.handle.patchIndex - array.GetPrimitiveIdBase());
const int *cvs = &_patchIndexBuffer[indexBase];
Osd API refactor: EvalStencils and EvalPatches Add EvalStencils and EvalPatches API for most of CPU and GPU evaluators. with this change, Eval API in the osd layer consists of following parts: - Evaluators (Cpu, Omp, Tbb, Cuda, CL, GLXFB, GLCompute, D3D11Compute) implements EvalStencils and EvalPatches(*). Both supports derivatives (not fully implemented though) - Interop vertex buffer classes (optional, same as before) Note that these classes are not necessary to use Evaluators. All evaluators have EvalStencils/Patches which take device-specific buffer objects. For example, GLXFBEvaluator can take GLuint directly for both stencil tables and input primvars. Although using these interop classes makes it easy to integrate osd into relatively simple applications. - device-dependent StencilTable and PatchTable (optional) These are also optional, but can be used simply a substitute of Far::StencilTable and Far::PatchTable for osd evaluators. - PatchArray, PatchCoord, PatchParam They are tiny structs used for GPU based patch evaluation. (*) TODO and known issues: - CLEvaluator and D3D11Evaluator's EvalPatches() have not been implemented. - GPU Gregory patch evaluation has not been implemented in EvalPatches(). - CudaEvaluator::EvalPatches() is very unstable. - All patch evaluation kernels have not been well optimized. - Currently GLXFB kernel doesn't support derivative evaluation. There's a technical difficulty for the multi-stream output.
2015-05-26 04:51:55 +00:00
dstT.Clear();
Added missing Osd Evaluator methods for deriv eval Now that Far::LimitStencilTable and Far::PatchTable support evaluation of 1st and 2nd derivatives the Osd Evaluator API for evaluating stencils and patches has been updated to match.
2017-01-26 22:36:30 +00:00
dstDuT.Clear();
dstDvT.Clear();
Improved patch basis eval for Osd to match Far This updates the patch basis evaluation functions in Osd to match recent changes to far/patchBasis. This also exposes a common facility for dealing with PatchCoord, PatchArray, and PatchParam. These are exposed as global functions operating on struct data, since C++ style class methods are not supported by all of the Osd shader and kernel execution envirionments. Changes: - Merged far/patchBasis.cpp to osd/patchBasisCommon{,Types,Eval}.h - Exposed PatchCoord, PatchArray, and PatchParam to Osd kernels - exposed OsdEvaluatePatchBasis and OsdEvaluatePatchBasisNormalized - Updated CPU, TBB, Omp, CUDA, OpenCL, GLSL, HLSL, and Metal evaluators - Updated glFVarViewer
2018-10-30 07:37:25 +00:00
for (int j = 0; j < nPoints; ++j) {
Osd API refactor: EvalStencils and EvalPatches Add EvalStencils and EvalPatches API for most of CPU and GPU evaluators. with this change, Eval API in the osd layer consists of following parts: - Evaluators (Cpu, Omp, Tbb, Cuda, CL, GLXFB, GLCompute, D3D11Compute) implements EvalStencils and EvalPatches(*). Both supports derivatives (not fully implemented though) - Interop vertex buffer classes (optional, same as before) Note that these classes are not necessary to use Evaluators. All evaluators have EvalStencils/Patches which take device-specific buffer objects. For example, GLXFBEvaluator can take GLuint directly for both stencil tables and input primvars. Although using these interop classes makes it easy to integrate osd into relatively simple applications. - device-dependent StencilTable and PatchTable (optional) These are also optional, but can be used simply a substitute of Far::StencilTable and Far::PatchTable for osd evaluators. - PatchArray, PatchCoord, PatchParam They are tiny structs used for GPU based patch evaluation. (*) TODO and known issues: - CLEvaluator and D3D11Evaluator's EvalPatches() have not been implemented. - GPU Gregory patch evaluation has not been implemented in EvalPatches(). - CudaEvaluator::EvalPatches() is very unstable. - All patch evaluation kernels have not been well optimized. - Currently GLXFB kernel doesn't support derivative evaluation. There's a technical difficulty for the multi-stream output.
2015-05-26 04:51:55 +00:00
dstT.AddWithWeight(srcT[cvs[j]], wP[j]);
Added missing Osd Evaluator methods for deriv eval Now that Far::LimitStencilTable and Far::PatchTable support evaluation of 1st and 2nd derivatives the Osd Evaluator API for evaluating stencils and patches has been updated to match.
2017-01-26 22:36:30 +00:00
dstDuT.AddWithWeight(srcT[cvs[j]], wDu[j]);
dstDvT.AddWithWeight(srcT[cvs[j]], wDv[j]);
Osd API refactor: EvalStencils and EvalPatches Add EvalStencils and EvalPatches API for most of CPU and GPU evaluators. with this change, Eval API in the osd layer consists of following parts: - Evaluators (Cpu, Omp, Tbb, Cuda, CL, GLXFB, GLCompute, D3D11Compute) implements EvalStencils and EvalPatches(*). Both supports derivatives (not fully implemented though) - Interop vertex buffer classes (optional, same as before) Note that these classes are not necessary to use Evaluators. All evaluators have EvalStencils/Patches which take device-specific buffer objects. For example, GLXFBEvaluator can take GLuint directly for both stencil tables and input primvars. Although using these interop classes makes it easy to integrate osd into relatively simple applications. - device-dependent StencilTable and PatchTable (optional) These are also optional, but can be used simply a substitute of Far::StencilTable and Far::PatchTable for osd evaluators. - PatchArray, PatchCoord, PatchParam They are tiny structs used for GPU based patch evaluation. (*) TODO and known issues: - CLEvaluator and D3D11Evaluator's EvalPatches() have not been implemented. - GPU Gregory patch evaluation has not been implemented in EvalPatches(). - CudaEvaluator::EvalPatches() is very unstable. - All patch evaluation kernels have not been well optimized. - Currently GLXFB kernel doesn't support derivative evaluation. There's a technical difficulty for the multi-stream output.
2015-05-26 04:51:55 +00:00
}
++dstT;
Added missing Osd Evaluator methods for deriv eval Now that Far::LimitStencilTable and Far::PatchTable support evaluation of 1st and 2nd derivatives the Osd Evaluator API for evaluating stencils and patches has been updated to match.
2017-01-26 22:36:30 +00:00
++dstDuT;
++dstDvT;
Osd API refactor: EvalStencils and EvalPatches Add EvalStencils and EvalPatches API for most of CPU and GPU evaluators. with this change, Eval API in the osd layer consists of following parts: - Evaluators (Cpu, Omp, Tbb, Cuda, CL, GLXFB, GLCompute, D3D11Compute) implements EvalStencils and EvalPatches(*). Both supports derivatives (not fully implemented though) - Interop vertex buffer classes (optional, same as before) Note that these classes are not necessary to use Evaluators. All evaluators have EvalStencils/Patches which take device-specific buffer objects. For example, GLXFBEvaluator can take GLuint directly for both stencil tables and input primvars. Although using these interop classes makes it easy to integrate osd into relatively simple applications. - device-dependent StencilTable and PatchTable (optional) These are also optional, but can be used simply a substitute of Far::StencilTable and Far::PatchTable for osd evaluators. - PatchArray, PatchCoord, PatchParam They are tiny structs used for GPU based patch evaluation. (*) TODO and known issues: - CLEvaluator and D3D11Evaluator's EvalPatches() have not been implemented. - GPU Gregory patch evaluation has not been implemented in EvalPatches(). - CudaEvaluator::EvalPatches() is very unstable. - All patch evaluation kernels have not been well optimized. - Currently GLXFB kernel doesn't support derivative evaluation. There's a technical difficulty for the multi-stream output.
2015-05-26 04:51:55 +00:00
}
}
Added missing Osd Evaluator methods for deriv eval Now that Far::LimitStencilTable and Far::PatchTable support evaluation of 1st and 2nd derivatives the Osd Evaluator API for evaluating stencils and patches has been updated to match.
2017-01-26 22:36:30 +00:00
void computeWith2ndDerivative(tbb::blocked_range<int> const &r) const {
float wP[20], wDu[20], wDv[20], wDuu[20], wDuv[20], wDvv[20];
Osd API refactor: EvalStencils and EvalPatches Add EvalStencils and EvalPatches API for most of CPU and GPU evaluators. with this change, Eval API in the osd layer consists of following parts: - Evaluators (Cpu, Omp, Tbb, Cuda, CL, GLXFB, GLCompute, D3D11Compute) implements EvalStencils and EvalPatches(*). Both supports derivatives (not fully implemented though) - Interop vertex buffer classes (optional, same as before) Note that these classes are not necessary to use Evaluators. All evaluators have EvalStencils/Patches which take device-specific buffer objects. For example, GLXFBEvaluator can take GLuint directly for both stencil tables and input primvars. Although using these interop classes makes it easy to integrate osd into relatively simple applications. - device-dependent StencilTable and PatchTable (optional) These are also optional, but can be used simply a substitute of Far::StencilTable and Far::PatchTable for osd evaluators. - PatchArray, PatchCoord, PatchParam They are tiny structs used for GPU based patch evaluation. (*) TODO and known issues: - CLEvaluator and D3D11Evaluator's EvalPatches() have not been implemented. - GPU Gregory patch evaluation has not been implemented in EvalPatches(). - CudaEvaluator::EvalPatches() is very unstable. - All patch evaluation kernels have not been well optimized. - Currently GLXFB kernel doesn't support derivative evaluation. There's a technical difficulty for the multi-stream output.
2015-05-26 04:51:55 +00:00
BufferAdapter<const float> srcT(_src + _srcDesc.offset,
_srcDesc.length,
_srcDesc.stride);
BufferAdapter<float> dstT(_dst + _dstDesc.offset
+ r.begin() * _dstDesc.stride,
_dstDesc.length,
_dstDesc.stride);
BufferAdapter<float> dstDuT(_dstDu + _dstDuDesc.offset
+ r.begin() * _dstDuDesc.stride,
_dstDuDesc.length,
_dstDuDesc.stride);
BufferAdapter<float> dstDvT(_dstDv + _dstDvDesc.offset
+ r.begin() * _dstDvDesc.stride,
_dstDvDesc.length,
_dstDvDesc.stride);
Added missing Osd Evaluator methods for deriv eval Now that Far::LimitStencilTable and Far::PatchTable support evaluation of 1st and 2nd derivatives the Osd Evaluator API for evaluating stencils and patches has been updated to match.
2017-01-26 22:36:30 +00:00
BufferAdapter<float> dstDuuT(_dstDuu + _dstDuuDesc.offset
+ r.begin() * _dstDuuDesc.stride,
_dstDuuDesc.length,
_dstDuuDesc.stride);
BufferAdapter<float> dstDuvT(_dstDuv + _dstDuvDesc.offset
+ r.begin() * _dstDuvDesc.stride,
_dstDuvDesc.length,
_dstDuvDesc.stride);
BufferAdapter<float> dstDvvT(_dstDvv + _dstDvvDesc.offset
+ r.begin() * _dstDvvDesc.stride,
_dstDvvDesc.length,
_dstDvvDesc.stride);
Osd API refactor: EvalStencils and EvalPatches Add EvalStencils and EvalPatches API for most of CPU and GPU evaluators. with this change, Eval API in the osd layer consists of following parts: - Evaluators (Cpu, Omp, Tbb, Cuda, CL, GLXFB, GLCompute, D3D11Compute) implements EvalStencils and EvalPatches(*). Both supports derivatives (not fully implemented though) - Interop vertex buffer classes (optional, same as before) Note that these classes are not necessary to use Evaluators. All evaluators have EvalStencils/Patches which take device-specific buffer objects. For example, GLXFBEvaluator can take GLuint directly for both stencil tables and input primvars. Although using these interop classes makes it easy to integrate osd into relatively simple applications. - device-dependent StencilTable and PatchTable (optional) These are also optional, but can be used simply a substitute of Far::StencilTable and Far::PatchTable for osd evaluators. - PatchArray, PatchCoord, PatchParam They are tiny structs used for GPU based patch evaluation. (*) TODO and known issues: - CLEvaluator and D3D11Evaluator's EvalPatches() have not been implemented. - GPU Gregory patch evaluation has not been implemented in EvalPatches(). - CudaEvaluator::EvalPatches() is very unstable. - All patch evaluation kernels have not been well optimized. - Currently GLXFB kernel doesn't support derivative evaluation. There's a technical difficulty for the multi-stream output.
2015-05-26 04:51:55 +00:00
for (int i = r.begin(); i < r.end(); ++i) {
PatchCoord const &coord = _patchCoords[i];
PatchArray const &array = _patchArrayBuffer[coord.handle.arrayIndex];
Improved patch basis eval for Osd to match Far This updates the patch basis evaluation functions in Osd to match recent changes to far/patchBasis. This also exposes a common facility for dealing with PatchCoord, PatchArray, and PatchParam. These are exposed as global functions operating on struct data, since C++ style class methods are not supported by all of the Osd shader and kernel execution envirionments. Changes: - Merged far/patchBasis.cpp to osd/patchBasisCommon{,Types,Eval}.h - Exposed PatchCoord, PatchArray, and PatchParam to Osd kernels - exposed OsdEvaluatePatchBasis and OsdEvaluatePatchBasisNormalized - Updated CPU, TBB, Omp, CUDA, OpenCL, GLSL, HLSL, and Metal evaluators - Updated glFVarViewer
2018-10-30 07:37:25 +00:00
Osd::PatchParam const & paramStruct =
Reverted recent Far::PatchParam refactoring This reverts most of the recent changes to the organization of Far::PatchParam. In particular, the core parameterization is no longer exposed as a speparate PatchParamBase class. We'll revisit this again in a later release, but for now we will stick with a more straight forward implementation.
2016-09-29 16:38:32 +00:00
_patchParamBuffer[coord.handle.patchIndex];
Improved patch basis eval for Osd to match Far This updates the patch basis evaluation functions in Osd to match recent changes to far/patchBasis. This also exposes a common facility for dealing with PatchCoord, PatchArray, and PatchParam. These are exposed as global functions operating on struct data, since C++ style class methods are not supported by all of the Osd shader and kernel execution envirionments. Changes: - Merged far/patchBasis.cpp to osd/patchBasisCommon{,Types,Eval}.h - Exposed PatchCoord, PatchArray, and PatchParam to Osd kernels - exposed OsdEvaluatePatchBasis and OsdEvaluatePatchBasisNormalized - Updated CPU, TBB, Omp, CUDA, OpenCL, GLSL, HLSL, and Metal evaluators - Updated glFVarViewer
2018-10-30 07:37:25 +00:00
OsdPatchParam param = OsdPatchParamInit(
paramStruct.field0, paramStruct.field1, paramStruct.sharpness);
int patchType = OsdPatchParamIsRegular(param)
? array.GetPatchTypeRegular()
: array.GetPatchTypeIrregular();
Osd API refactor: EvalStencils and EvalPatches Add EvalStencils and EvalPatches API for most of CPU and GPU evaluators. with this change, Eval API in the osd layer consists of following parts: - Evaluators (Cpu, Omp, Tbb, Cuda, CL, GLXFB, GLCompute, D3D11Compute) implements EvalStencils and EvalPatches(*). Both supports derivatives (not fully implemented though) - Interop vertex buffer classes (optional, same as before) Note that these classes are not necessary to use Evaluators. All evaluators have EvalStencils/Patches which take device-specific buffer objects. For example, GLXFBEvaluator can take GLuint directly for both stencil tables and input primvars. Although using these interop classes makes it easy to integrate osd into relatively simple applications. - device-dependent StencilTable and PatchTable (optional) These are also optional, but can be used simply a substitute of Far::StencilTable and Far::PatchTable for osd evaluators. - PatchArray, PatchCoord, PatchParam They are tiny structs used for GPU based patch evaluation. (*) TODO and known issues: - CLEvaluator and D3D11Evaluator's EvalPatches() have not been implemented. - GPU Gregory patch evaluation has not been implemented in EvalPatches(). - CudaEvaluator::EvalPatches() is very unstable. - All patch evaluation kernels have not been well optimized. - Currently GLXFB kernel doesn't support derivative evaluation. There's a technical difficulty for the multi-stream output.
2015-05-26 04:51:55 +00:00
Improved patch basis eval for Osd to match Far This updates the patch basis evaluation functions in Osd to match recent changes to far/patchBasis. This also exposes a common facility for dealing with PatchCoord, PatchArray, and PatchParam. These are exposed as global functions operating on struct data, since C++ style class methods are not supported by all of the Osd shader and kernel execution envirionments. Changes: - Merged far/patchBasis.cpp to osd/patchBasisCommon{,Types,Eval}.h - Exposed PatchCoord, PatchArray, and PatchParam to Osd kernels - exposed OsdEvaluatePatchBasis and OsdEvaluatePatchBasisNormalized - Updated CPU, TBB, Omp, CUDA, OpenCL, GLSL, HLSL, and Metal evaluators - Updated glFVarViewer
2018-10-30 07:37:25 +00:00
int nPoints = OsdEvaluatePatchBasis(patchType, param,
coord.s, coord.t, wP, wDu, wDv, wDuu, wDuv, wDvv);
Osd API refactor: EvalStencils and EvalPatches Add EvalStencils and EvalPatches API for most of CPU and GPU evaluators. with this change, Eval API in the osd layer consists of following parts: - Evaluators (Cpu, Omp, Tbb, Cuda, CL, GLXFB, GLCompute, D3D11Compute) implements EvalStencils and EvalPatches(*). Both supports derivatives (not fully implemented though) - Interop vertex buffer classes (optional, same as before) Note that these classes are not necessary to use Evaluators. All evaluators have EvalStencils/Patches which take device-specific buffer objects. For example, GLXFBEvaluator can take GLuint directly for both stencil tables and input primvars. Although using these interop classes makes it easy to integrate osd into relatively simple applications. - device-dependent StencilTable and PatchTable (optional) These are also optional, but can be used simply a substitute of Far::StencilTable and Far::PatchTable for osd evaluators. - PatchArray, PatchCoord, PatchParam They are tiny structs used for GPU based patch evaluation. (*) TODO and known issues: - CLEvaluator and D3D11Evaluator's EvalPatches() have not been implemented. - GPU Gregory patch evaluation has not been implemented in EvalPatches(). - CudaEvaluator::EvalPatches() is very unstable. - All patch evaluation kernels have not been well optimized. - Currently GLXFB kernel doesn't support derivative evaluation. There's a technical difficulty for the multi-stream output.
2015-05-26 04:51:55 +00:00
Improved patch basis eval for Osd to match Far This updates the patch basis evaluation functions in Osd to match recent changes to far/patchBasis. This also exposes a common facility for dealing with PatchCoord, PatchArray, and PatchParam. These are exposed as global functions operating on struct data, since C++ style class methods are not supported by all of the Osd shader and kernel execution envirionments. Changes: - Merged far/patchBasis.cpp to osd/patchBasisCommon{,Types,Eval}.h - Exposed PatchCoord, PatchArray, and PatchParam to Osd kernels - exposed OsdEvaluatePatchBasis and OsdEvaluatePatchBasisNormalized - Updated CPU, TBB, Omp, CUDA, OpenCL, GLSL, HLSL, and Metal evaluators - Updated glFVarViewer
2018-10-30 07:37:25 +00:00
int indexBase = array.GetIndexBase() + array.GetStride() *
Osd Varying and FaceVarying Patch Evaluation Implemented EvalPatchesVarying and EvalPatchesFaceVarying methods for Osd::*Evaluator classes, i.e. cpu, omp, tbb, GLXFB, GLSLCompute, OpenCL, and CUDA. Also, the GPU Kernel implementations have been updated to use the common patchBasis implementation instead of re-implementing methods to compute patch basis weights locally.
2016-09-29 16:56:15 +00:00
(coord.handle.patchIndex - array.GetPrimitiveIdBase());
const int *cvs = &_patchIndexBuffer[indexBase];
Osd API refactor: EvalStencils and EvalPatches Add EvalStencils and EvalPatches API for most of CPU and GPU evaluators. with this change, Eval API in the osd layer consists of following parts: - Evaluators (Cpu, Omp, Tbb, Cuda, CL, GLXFB, GLCompute, D3D11Compute) implements EvalStencils and EvalPatches(*). Both supports derivatives (not fully implemented though) - Interop vertex buffer classes (optional, same as before) Note that these classes are not necessary to use Evaluators. All evaluators have EvalStencils/Patches which take device-specific buffer objects. For example, GLXFBEvaluator can take GLuint directly for both stencil tables and input primvars. Although using these interop classes makes it easy to integrate osd into relatively simple applications. - device-dependent StencilTable and PatchTable (optional) These are also optional, but can be used simply a substitute of Far::StencilTable and Far::PatchTable for osd evaluators. - PatchArray, PatchCoord, PatchParam They are tiny structs used for GPU based patch evaluation. (*) TODO and known issues: - CLEvaluator and D3D11Evaluator's EvalPatches() have not been implemented. - GPU Gregory patch evaluation has not been implemented in EvalPatches(). - CudaEvaluator::EvalPatches() is very unstable. - All patch evaluation kernels have not been well optimized. - Currently GLXFB kernel doesn't support derivative evaluation. There's a technical difficulty for the multi-stream output.
2015-05-26 04:51:55 +00:00
dstT.Clear();
dstDuT.Clear();
dstDvT.Clear();
Added missing Osd Evaluator methods for deriv eval Now that Far::LimitStencilTable and Far::PatchTable support evaluation of 1st and 2nd derivatives the Osd Evaluator API for evaluating stencils and patches has been updated to match.
2017-01-26 22:36:30 +00:00
dstDuuT.Clear();
dstDuvT.Clear();
dstDvvT.Clear();
Improved patch basis eval for Osd to match Far This updates the patch basis evaluation functions in Osd to match recent changes to far/patchBasis. This also exposes a common facility for dealing with PatchCoord, PatchArray, and PatchParam. These are exposed as global functions operating on struct data, since C++ style class methods are not supported by all of the Osd shader and kernel execution envirionments. Changes: - Merged far/patchBasis.cpp to osd/patchBasisCommon{,Types,Eval}.h - Exposed PatchCoord, PatchArray, and PatchParam to Osd kernels - exposed OsdEvaluatePatchBasis and OsdEvaluatePatchBasisNormalized - Updated CPU, TBB, Omp, CUDA, OpenCL, GLSL, HLSL, and Metal evaluators - Updated glFVarViewer
2018-10-30 07:37:25 +00:00
for (int j = 0; j < nPoints; ++j) {
Osd API refactor: EvalStencils and EvalPatches Add EvalStencils and EvalPatches API for most of CPU and GPU evaluators. with this change, Eval API in the osd layer consists of following parts: - Evaluators (Cpu, Omp, Tbb, Cuda, CL, GLXFB, GLCompute, D3D11Compute) implements EvalStencils and EvalPatches(*). Both supports derivatives (not fully implemented though) - Interop vertex buffer classes (optional, same as before) Note that these classes are not necessary to use Evaluators. All evaluators have EvalStencils/Patches which take device-specific buffer objects. For example, GLXFBEvaluator can take GLuint directly for both stencil tables and input primvars. Although using these interop classes makes it easy to integrate osd into relatively simple applications. - device-dependent StencilTable and PatchTable (optional) These are also optional, but can be used simply a substitute of Far::StencilTable and Far::PatchTable for osd evaluators. - PatchArray, PatchCoord, PatchParam They are tiny structs used for GPU based patch evaluation. (*) TODO and known issues: - CLEvaluator and D3D11Evaluator's EvalPatches() have not been implemented. - GPU Gregory patch evaluation has not been implemented in EvalPatches(). - CudaEvaluator::EvalPatches() is very unstable. - All patch evaluation kernels have not been well optimized. - Currently GLXFB kernel doesn't support derivative evaluation. There's a technical difficulty for the multi-stream output.
2015-05-26 04:51:55 +00:00
dstT.AddWithWeight(srcT[cvs[j]], wP[j]);
Added missing Osd Evaluator methods for deriv eval Now that Far::LimitStencilTable and Far::PatchTable support evaluation of 1st and 2nd derivatives the Osd Evaluator API for evaluating stencils and patches has been updated to match.
2017-01-26 22:36:30 +00:00
dstDuT.AddWithWeight(srcT[cvs[j]], wDu[j]);
dstDvT.AddWithWeight(srcT[cvs[j]], wDv[j]);
dstDuuT.AddWithWeight(srcT[cvs[j]], wDuu[j]);
dstDuvT.AddWithWeight(srcT[cvs[j]], wDuv[j]);
dstDvvT.AddWithWeight(srcT[cvs[j]], wDvv[j]);
Osd API refactor: EvalStencils and EvalPatches Add EvalStencils and EvalPatches API for most of CPU and GPU evaluators. with this change, Eval API in the osd layer consists of following parts: - Evaluators (Cpu, Omp, Tbb, Cuda, CL, GLXFB, GLCompute, D3D11Compute) implements EvalStencils and EvalPatches(*). Both supports derivatives (not fully implemented though) - Interop vertex buffer classes (optional, same as before) Note that these classes are not necessary to use Evaluators. All evaluators have EvalStencils/Patches which take device-specific buffer objects. For example, GLXFBEvaluator can take GLuint directly for both stencil tables and input primvars. Although using these interop classes makes it easy to integrate osd into relatively simple applications. - device-dependent StencilTable and PatchTable (optional) These are also optional, but can be used simply a substitute of Far::StencilTable and Far::PatchTable for osd evaluators. - PatchArray, PatchCoord, PatchParam They are tiny structs used for GPU based patch evaluation. (*) TODO and known issues: - CLEvaluator and D3D11Evaluator's EvalPatches() have not been implemented. - GPU Gregory patch evaluation has not been implemented in EvalPatches(). - CudaEvaluator::EvalPatches() is very unstable. - All patch evaluation kernels have not been well optimized. - Currently GLXFB kernel doesn't support derivative evaluation. There's a technical difficulty for the multi-stream output.
2015-05-26 04:51:55 +00:00
}
++dstT;
++dstDuT;
++dstDvT;
Added missing Osd Evaluator methods for deriv eval Now that Far::LimitStencilTable and Far::PatchTable support evaluation of 1st and 2nd derivatives the Osd Evaluator API for evaluating stencils and patches has been updated to match.
2017-01-26 22:36:30 +00:00
++dstDuuT;
++dstDuvT;
++dstDvvT;
Osd API refactor: EvalStencils and EvalPatches Add EvalStencils and EvalPatches API for most of CPU and GPU evaluators. with this change, Eval API in the osd layer consists of following parts: - Evaluators (Cpu, Omp, Tbb, Cuda, CL, GLXFB, GLCompute, D3D11Compute) implements EvalStencils and EvalPatches(*). Both supports derivatives (not fully implemented though) - Interop vertex buffer classes (optional, same as before) Note that these classes are not necessary to use Evaluators. All evaluators have EvalStencils/Patches which take device-specific buffer objects. For example, GLXFBEvaluator can take GLuint directly for both stencil tables and input primvars. Although using these interop classes makes it easy to integrate osd into relatively simple applications. - device-dependent StencilTable and PatchTable (optional) These are also optional, but can be used simply a substitute of Far::StencilTable and Far::PatchTable for osd evaluators. - PatchArray, PatchCoord, PatchParam They are tiny structs used for GPU based patch evaluation. (*) TODO and known issues: - CLEvaluator and D3D11Evaluator's EvalPatches() have not been implemented. - GPU Gregory patch evaluation has not been implemented in EvalPatches(). - CudaEvaluator::EvalPatches() is very unstable. - All patch evaluation kernels have not been well optimized. - Currently GLXFB kernel doesn't support derivative evaluation. There's a technical difficulty for the multi-stream output.
2015-05-26 04:51:55 +00:00
}
}
};
void
osdlayer: rename Osd::VertexBufferDescriptor to Osd::BufferDescriptor. A mechanical substitution of VertexBufferDescriptor with BufferDescriptor. Also removing unused files from osd.
2015-05-29 16:21:14 +00:00
TbbEvalPatches(float const *src, BufferDescriptor const &srcDesc,
float *dst, BufferDescriptor const &dstDesc,
float *dstDu, BufferDescriptor const &dstDuDesc,
float *dstDv, BufferDescriptor const &dstDvDesc,
Osd API refactor: EvalStencils and EvalPatches Add EvalStencils and EvalPatches API for most of CPU and GPU evaluators. with this change, Eval API in the osd layer consists of following parts: - Evaluators (Cpu, Omp, Tbb, Cuda, CL, GLXFB, GLCompute, D3D11Compute) implements EvalStencils and EvalPatches(*). Both supports derivatives (not fully implemented though) - Interop vertex buffer classes (optional, same as before) Note that these classes are not necessary to use Evaluators. All evaluators have EvalStencils/Patches which take device-specific buffer objects. For example, GLXFBEvaluator can take GLuint directly for both stencil tables and input primvars. Although using these interop classes makes it easy to integrate osd into relatively simple applications. - device-dependent StencilTable and PatchTable (optional) These are also optional, but can be used simply a substitute of Far::StencilTable and Far::PatchTable for osd evaluators. - PatchArray, PatchCoord, PatchParam They are tiny structs used for GPU based patch evaluation. (*) TODO and known issues: - CLEvaluator and D3D11Evaluator's EvalPatches() have not been implemented. - GPU Gregory patch evaluation has not been implemented in EvalPatches(). - CudaEvaluator::EvalPatches() is very unstable. - All patch evaluation kernels have not been well optimized. - Currently GLXFB kernel doesn't support derivative evaluation. There's a technical difficulty for the multi-stream output.
2015-05-26 04:51:55 +00:00
int numPatchCoords,
const PatchCoord *patchCoords,
const PatchArray *patchArrayBuffer,
const int *patchIndexBuffer,
const PatchParam *patchParamBuffer) {
TbbEvalPatchesKernel kernel(src, srcDesc, dst, dstDesc,
dstDu, dstDuDesc, dstDv, dstDvDesc,
Added missing Osd Evaluator methods for deriv eval Now that Far::LimitStencilTable and Far::PatchTable support evaluation of 1st and 2nd derivatives the Osd Evaluator API for evaluating stencils and patches has been updated to match.
2017-01-26 22:36:30 +00:00
NULL, BufferDescriptor(),
NULL, BufferDescriptor(),
NULL, BufferDescriptor(),
numPatchCoords, patchCoords,
patchArrayBuffer,
patchIndexBuffer,
patchParamBuffer);
tbb::blocked_range<int> range(0, numPatchCoords, grain_size);
tbb::parallel_for(range, kernel);
}
void
TbbEvalPatches(float const *src, BufferDescriptor const &srcDesc,
float *dst, BufferDescriptor const &dstDesc,
float *dstDu, BufferDescriptor const &dstDuDesc,
float *dstDv, BufferDescriptor const &dstDvDesc,
float *dstDuu, BufferDescriptor const &dstDuuDesc,
float *dstDuv, BufferDescriptor const &dstDuvDesc,
float *dstDvv, BufferDescriptor const &dstDvvDesc,
int numPatchCoords,
const PatchCoord *patchCoords,
const PatchArray *patchArrayBuffer,
const int *patchIndexBuffer,
const PatchParam *patchParamBuffer) {
TbbEvalPatchesKernel kernel(src, srcDesc, dst, dstDesc,
dstDu, dstDuDesc, dstDv, dstDvDesc,
dstDuu, dstDuuDesc,
dstDuv, dstDuvDesc,
dstDvv, dstDvvDesc,
Osd API refactor: EvalStencils and EvalPatches Add EvalStencils and EvalPatches API for most of CPU and GPU evaluators. with this change, Eval API in the osd layer consists of following parts: - Evaluators (Cpu, Omp, Tbb, Cuda, CL, GLXFB, GLCompute, D3D11Compute) implements EvalStencils and EvalPatches(*). Both supports derivatives (not fully implemented though) - Interop vertex buffer classes (optional, same as before) Note that these classes are not necessary to use Evaluators. All evaluators have EvalStencils/Patches which take device-specific buffer objects. For example, GLXFBEvaluator can take GLuint directly for both stencil tables and input primvars. Although using these interop classes makes it easy to integrate osd into relatively simple applications. - device-dependent StencilTable and PatchTable (optional) These are also optional, but can be used simply a substitute of Far::StencilTable and Far::PatchTable for osd evaluators. - PatchArray, PatchCoord, PatchParam They are tiny structs used for GPU based patch evaluation. (*) TODO and known issues: - CLEvaluator and D3D11Evaluator's EvalPatches() have not been implemented. - GPU Gregory patch evaluation has not been implemented in EvalPatches(). - CudaEvaluator::EvalPatches() is very unstable. - All patch evaluation kernels have not been well optimized. - Currently GLXFB kernel doesn't support derivative evaluation. There's a technical difficulty for the multi-stream output.
2015-05-26 04:51:55 +00:00
numPatchCoords, patchCoords,
patchArrayBuffer,
patchIndexBuffer,
patchParamBuffer);
tbb::blocked_range<int> range(0, numPatchCoords, grain_size);
tbb::parallel_for(range, kernel);
}
Osd Varying and FaceVarying Patch Evaluation Implemented EvalPatchesVarying and EvalPatchesFaceVarying methods for Osd::*Evaluator classes, i.e. cpu, omp, tbb, GLXFB, GLSLCompute, OpenCL, and CUDA. Also, the GPU Kernel implementations have been updated to use the common patchBasis implementation instead of re-implementing methods to compute patch basis weights locally.
2016-09-29 16:56:15 +00:00
Landing 3.0.0.alpha Sync'ing the 'dev' branch with the 'feature_3.0dev' branch at commit 68c6d11fc36761ae1a5e6cdc3457be16f2e9704a The branch 'feature_3.0dev' is now locked and preserved for historical purposes.
2014-09-05 22:07:46 +00:00
} // end namespace Osd
initial checking in TBB kernel.
2013-06-05 17:55:24 +00:00
} // end namespace OPENSUBDIV_VERSION
} // end namespace OpenSubdiv
Reference in New Issue Copy Permalink