AuroraMiddleware/OpenSubdiv
1
0
Fork 0
mirror of https://github.com/PixarAnimationStudios/OpenSubdiv synced 2024-12-04 00:41:05 +00:00
Code Issues Releases Wiki Activity
9913e349df
OpenSubdiv/opensubdiv/osd/tbbKernel.cpp

717 lines
27 KiB
C++
Raw 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"
#include "../osd/vertexDescriptor.h"
#include <math.h>
#include <tbb/parallel_for.h>
namespace OpenSubdiv {
namespace OPENSUBDIV_VERSION {
#define grain_size 200
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
clear(float *origin, int index, OsdVertexBufferDescriptor const &desc) {
if (origin) {
float *dst = origin + index * desc.stride;
memset(dst, 0, desc.length * sizeof(float));
}
}
static inline void
addWithWeight(float *origin, int dstIndex, int srcIndex,
float weight, OsdVertexBufferDescriptor const &desc) {
if (origin) {
const float *src = origin + srcIndex * desc.stride;
float *dst = origin + dstIndex * desc.stride;
for (int k = 0; k < desc.length; ++k) {
dst[k] += src[k] * weight;
}
}
}
initial checking in TBB kernel.
2013-06-05 17:55:24 +00:00
class TBBFaceKernel {
float *vertex;
float *varying;
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
OsdVertexBufferDescriptor vertexDesc;
OsdVertexBufferDescriptor varyingDesc;
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
int const *F_IT;
int const *F_ITa;
initial checking in TBB kernel.
2013-06-05 17:55:24 +00:00
int vertexOffset;
int tableOffset;
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
public:
void operator() (tbb::blocked_range<int> const &r) const {
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
if(vertexDesc.length == 4 && varying == NULL) {
initial checking in TBB kernel.
2013-06-05 17:55:24 +00:00
ComputeFaceKernel<4>
(vertex, F_IT, F_ITa, vertexOffset, tableOffset, r.begin(), r.end());
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
} else if(vertexDesc.length == 8 && varying == NULL) {
initial checking in TBB kernel.
2013-06-05 17:55:24 +00:00
ComputeFaceKernel<8>
(vertex, F_IT, F_ITa, vertexOffset, tableOffset, r.begin(), r.end());
}
else {
for (int i = r.begin() + tableOffset; i < r.end() + tableOffset; i++) {
int h = F_ITa[2*i];
int n = F_ITa[2*i+1];
float weight = 1.0f/n;
// XXX: should use local vertex struct variable instead of
// accumulating directly into global memory.
int dstIndex = i + vertexOffset - tableOffset;
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
clear(vertex, dstIndex, vertexDesc);
clear(varying, dstIndex, varyingDesc);
initial checking in TBB kernel.
2013-06-05 17:55:24 +00:00
for (int j = 0; j < n; ++j) {
int index = F_IT[h+j];
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
addWithWeight(vertex, dstIndex, index, weight, vertexDesc);
addWithWeight(varying, dstIndex, index, weight, varyingDesc);
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
}
}
}
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
TBBFaceKernel(TBBFaceKernel const &other)
initial checking in TBB kernel.
2013-06-05 17:55:24 +00:00
{
this->vertex = other.vertex;
this->varying= other.varying;
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
this->vertexDesc = other.vertexDesc;
this->varyingDesc = other.varyingDesc;
initial checking in TBB kernel.
2013-06-05 17:55:24 +00:00
this->F_IT = other.F_IT;
this->F_ITa = other.F_ITa;
this->vertexOffset = other.vertexOffset;
this->tableOffset = other.tableOffset;
}
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
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
TBBFaceKernel(float *vertex_in,
initial checking in TBB kernel.
2013-06-05 17:55:24 +00:00
float *varying_in,
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
OsdVertexBufferDescriptor const &vertexDesc_in,
OsdVertexBufferDescriptor const &varyingDesc_in,
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
int const *F_IT_in,
int const *F_ITa_in,
initial checking in TBB kernel.
2013-06-05 17:55:24 +00:00
int vertexOffset_in,
int tableOffset_in) :
vertex (vertex_in),
varying(varying_in),
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
vertexDesc(vertexDesc_in),
varyingDesc(varyingDesc_in),
initial checking in TBB kernel.
2013-06-05 17:55:24 +00:00
F_IT (F_IT_in),
F_ITa (F_ITa_in),
vertexOffset(vertexOffset_in),
tableOffset(tableOffset_in)
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
{};
initial checking in TBB kernel.
2013-06-05 17:55:24 +00:00
};
void OsdTbbComputeFace(
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
float * vertex, float * varying,
OsdVertexBufferDescriptor const &vertexDesc,
OsdVertexBufferDescriptor const &varyingDesc,
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
int const *F_IT, int const *F_ITa, int vertexOffset, int tableOffset,
initial checking in TBB kernel.
2013-06-05 17:55:24 +00:00
int start, int end) {
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
TBBFaceKernel kernel(vertex, varying, vertexDesc, varyingDesc, F_IT, F_ITa,
initial checking in TBB kernel.
2013-06-05 17:55:24 +00:00
vertexOffset, tableOffset);
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
tbb::parallel_for(range, kernel);
}
class TBBEdgeKernel {
float *vertex;
float *varying;
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
OsdVertexBufferDescriptor vertexDesc;
OsdVertexBufferDescriptor varyingDesc;
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
int const *E_IT;
float const *E_W;
initial checking in TBB kernel.
2013-06-05 17:55:24 +00:00
int vertexOffset;
int tableOffset;
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
public:
void operator() (tbb::blocked_range<int> const &r) const {
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
if(vertexDesc.length == 4 && varying == NULL) {
initial checking in TBB kernel.
2013-06-05 17:55:24 +00:00
ComputeEdgeKernel<4>(vertex, E_IT, E_W, vertexOffset, tableOffset,
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
r.begin(), r.end());
initial checking in TBB kernel.
2013-06-05 17:55:24 +00:00
}
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
else if(vertexDesc.length == 8 && varying == NULL) {
initial checking in TBB kernel.
2013-06-05 17:55:24 +00:00
ComputeEdgeKernel<8>(vertex, E_IT, E_W, vertexOffset, tableOffset,
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
r.begin(), r.end());
initial checking in TBB kernel.
2013-06-05 17:55:24 +00:00
}
else {
for (int i = r.begin() + tableOffset; i < r.end() + tableOffset; i++) {
int eidx0 = E_IT[4*i+0];
int eidx1 = E_IT[4*i+1];
int eidx2 = E_IT[4*i+2];
int eidx3 = E_IT[4*i+3];
float vertWeight = E_W[i*2+0];
int dstIndex = i + vertexOffset - tableOffset;
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
clear(vertex, dstIndex, vertexDesc);
clear(varying, dstIndex, varyingDesc);
initial checking in TBB kernel.
2013-06-05 17:55:24 +00:00
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
addWithWeight(vertex, dstIndex, eidx0, vertWeight, vertexDesc);
addWithWeight(vertex, dstIndex, eidx1, vertWeight, vertexDesc);
initial checking in TBB kernel.
2013-06-05 17:55:24 +00:00
if (eidx2 != -1) {
float faceWeight = E_W[i*2+1];
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
addWithWeight(vertex, dstIndex, eidx2, faceWeight, vertexDesc);
addWithWeight(vertex, dstIndex, eidx3, faceWeight, vertexDesc);
initial checking in TBB kernel.
2013-06-05 17:55:24 +00:00
}
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
addWithWeight(varying, dstIndex, eidx0, 0.5f, varyingDesc);
addWithWeight(varying, dstIndex, eidx1, 0.5f, varyingDesc);
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
}
}
}
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
TBBEdgeKernel(TBBEdgeKernel const &other)
initial checking in TBB kernel.
2013-06-05 17:55:24 +00:00
{
this->vertex = other.vertex;
this->varying= other.varying;
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
this->vertexDesc = other.vertexDesc;
this->varyingDesc = other.varyingDesc;
initial checking in TBB kernel.
2013-06-05 17:55:24 +00:00
this->E_IT = other.E_IT;
this->E_W = other.E_W;
this->vertexOffset = other.vertexOffset;
this->tableOffset = other.tableOffset;
}
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
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
TBBEdgeKernel(float *vertex_in,
initial checking in TBB kernel.
2013-06-05 17:55:24 +00:00
float *varying_in,
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
OsdVertexBufferDescriptor const &vertexDesc_in,
OsdVertexBufferDescriptor const &varyingDesc_in,
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
int const *E_IT_in,
float const *E_W_in,
initial checking in TBB kernel.
2013-06-05 17:55:24 +00:00
int vertexOffset_in,
int tableOffset_in) :
vertex (vertex_in),
varying(varying_in),
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
vertexDesc(vertexDesc_in),
varyingDesc(varyingDesc_in),
initial checking in TBB kernel.
2013-06-05 17:55:24 +00:00
E_IT (E_IT_in),
E_W (E_W_in),
vertexOffset(vertexOffset_in),
tableOffset(tableOffset_in)
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
{};
initial checking in TBB kernel.
2013-06-05 17:55:24 +00:00
};
void OsdTbbComputeEdge(
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
float *vertex, float *varying,
OsdVertexBufferDescriptor const &vertexDesc,
OsdVertexBufferDescriptor const &varyingDesc,
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
int const *E_IT, float const *E_W, int vertexOffset, int tableOffset,
initial checking in TBB kernel.
2013-06-05 17:55:24 +00:00
int start, int end) {
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);
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
TBBEdgeKernel kernel(vertex, varying, vertexDesc, varyingDesc, E_IT, E_W,
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
vertexOffset, tableOffset);
initial checking in TBB kernel.
2013-06-05 17:55:24 +00:00
tbb::parallel_for(range, kernel);
}
class TBBVertexKernelA {
float *vertex;
float *varying;
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
OsdVertexBufferDescriptor vertexDesc;
OsdVertexBufferDescriptor varyingDesc;
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
int const *V_ITa;
float const *V_W;
initial checking in TBB kernel.
2013-06-05 17:55:24 +00:00
int vertexOffset;
int tableOffset;
int pass;
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
public:
void operator() (tbb::blocked_range<int> const &r) const {
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
if(vertexDesc.length == 4 && varying == NULL) {
initial checking in TBB kernel.
2013-06-05 17:55:24 +00:00
ComputeVertexAKernel<4>(vertex, V_ITa, V_W, vertexOffset, tableOffset,
r.begin(), r.end(), pass);
}
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
else if (vertexDesc.length == 8 && varying == NULL) {
initial checking in TBB kernel.
2013-06-05 17:55:24 +00:00
ComputeVertexAKernel<8>(vertex, V_ITa, V_W, vertexOffset, tableOffset,
r.begin(), r.end(), pass);
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
}
initial checking in TBB kernel.
2013-06-05 17:55:24 +00:00
else {
for (int i = r.begin() + tableOffset; i < r.end() + tableOffset; i++) {
int n = V_ITa[5*i+1];
int p = V_ITa[5*i+2];
int eidx0 = V_ITa[5*i+3];
int eidx1 = V_ITa[5*i+4];
float weight = (pass == 1) ? V_W[i] : 1.0f - V_W[i];
// In the case of fractional weight, the weight must be inverted since
// the value is shared with the k_Smooth kernel (statistically the
// k_Smooth kernel runs much more often than this one)
if (weight > 0.0f && weight < 1.0f && n > 0)
weight = 1.0f - weight;
int dstIndex = i + vertexOffset - tableOffset;
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
if (not pass) {
clear(vertex, dstIndex, vertexDesc);
clear(varying, dstIndex, varyingDesc);
}
initial checking in TBB kernel.
2013-06-05 17:55:24 +00:00
if (eidx0 == -1 || (pass == 0 && (n == -1))) {
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
addWithWeight(vertex, dstIndex, p, weight, vertexDesc);
initial checking in TBB kernel.
2013-06-05 17:55:24 +00:00
} else {
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
addWithWeight(vertex, dstIndex, p, weight * 0.75f, vertexDesc);
addWithWeight(vertex, dstIndex, eidx0, weight * 0.125f, vertexDesc);
addWithWeight(vertex, dstIndex, eidx1, weight * 0.125f, vertexDesc);
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
initial checking in TBB kernel.
2013-06-05 17:55:24 +00:00
if (not pass)
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
addWithWeight(varying, dstIndex, p, 1.0f, varyingDesc);
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
}
}
}
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
TBBVertexKernelA(TBBVertexKernelA const &other)
initial checking in TBB kernel.
2013-06-05 17:55:24 +00:00
{
this->vertex = other.vertex;
this->varying= other.varying;
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
this->vertexDesc = other.vertexDesc;
this->varyingDesc = other.varyingDesc;
initial checking in TBB kernel.
2013-06-05 17:55:24 +00:00
this->V_ITa = other.V_ITa;
this->V_W = other.V_W;
this->vertexOffset = other.vertexOffset;
this->tableOffset = other.tableOffset;
this->pass = other.pass;
}
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
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
TBBVertexKernelA(float *vertex_in,
initial checking in TBB kernel.
2013-06-05 17:55:24 +00:00
float *varying_in,
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
OsdVertexBufferDescriptor const &vertexDesc_in,
OsdVertexBufferDescriptor const &varyingDesc_in,
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
int const *V_ITa_in,
float const *V_W_in,
initial checking in TBB kernel.
2013-06-05 17:55:24 +00:00
int vertexOffset_in,
int tableOffset_in,
int pass_in) :
vertex (vertex_in),
varying(varying_in),
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
vertexDesc(vertexDesc_in),
varyingDesc(varyingDesc_in),
initial checking in TBB kernel.
2013-06-05 17:55:24 +00:00
V_ITa (V_ITa_in),
V_W (V_W_in),
vertexOffset(vertexOffset_in),
tableOffset(tableOffset_in),
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
pass(pass_in)
{};
initial checking in TBB kernel.
2013-06-05 17:55:24 +00:00
};
void OsdTbbComputeVertexA(
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
float *vertex, float *varying,
OsdVertexBufferDescriptor const &vertexDesc,
OsdVertexBufferDescriptor const &varyingDesc,
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
int const *V_ITa, float const *V_W, int vertexOffset, int tableOffset,
initial checking in TBB kernel.
2013-06-05 17:55:24 +00:00
int start, int end, int pass) {
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);
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
TBBVertexKernelA kernel(vertex, varying, vertexDesc, varyingDesc,
V_ITa, V_W,
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
vertexOffset, tableOffset, pass);
initial checking in TBB kernel.
2013-06-05 17:55:24 +00:00
tbb::parallel_for(range, kernel);
}
class TBBVertexKernelB {
float *vertex;
float *varying;
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
OsdVertexBufferDescriptor vertexDesc;
OsdVertexBufferDescriptor varyingDesc;
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
int const *V_ITa;
int const *V_IT;
float const *V_W;
initial checking in TBB kernel.
2013-06-05 17:55:24 +00:00
int vertexOffset;
int tableOffset;
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
public:
void operator() (tbb::blocked_range<int> const &r) const {
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
if(vertexDesc.length == 4 && varying == NULL) {
initial checking in TBB kernel.
2013-06-05 17:55:24 +00:00
ComputeVertexBKernel<4>(vertex, V_ITa, V_IT, V_W,
vertexOffset, tableOffset, r.begin(), r.end());
}
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
else if(vertexDesc.length == 8 && varying == NULL) {
initial checking in TBB kernel.
2013-06-05 17:55:24 +00:00
ComputeVertexBKernel<8>(vertex, V_ITa, V_IT, V_W,
vertexOffset, tableOffset, r.begin(), r.end());
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
}
initial checking in TBB kernel.
2013-06-05 17:55:24 +00:00
else {
for (int i = r.begin() + tableOffset; i < r.end() + tableOffset; i++) {
int h = V_ITa[5*i];
int n = V_ITa[5*i+1];
int p = V_ITa[5*i+2];
float weight = V_W[i];
float wp = 1.0f/static_cast<float>(n*n);
float wv = (n-2.0f) * n * wp;
int dstIndex = i + vertexOffset - tableOffset;
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
clear(vertex, dstIndex, vertexDesc);
clear(varying, dstIndex, varyingDesc);
initial checking in TBB kernel.
2013-06-05 17:55:24 +00:00
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
addWithWeight(vertex, dstIndex, p, weight * wv, vertexDesc);
initial checking in TBB kernel.
2013-06-05 17:55:24 +00:00
for (int j = 0; j < n; ++j) {
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
addWithWeight(vertex, dstIndex, V_IT[h+j*2], weight * wp, vertexDesc);
addWithWeight(vertex, dstIndex, V_IT[h+j*2+1], weight * wp, vertexDesc);
initial checking in TBB kernel.
2013-06-05 17:55:24 +00:00
}
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
addWithWeight(varying, dstIndex, p, 1.0f, varyingDesc);
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
}
}
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
TBBVertexKernelB(TBBVertexKernelB const &other)
initial checking in TBB kernel.
2013-06-05 17:55:24 +00:00
{
this->vertex = other.vertex;
this->varying= other.varying;
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
this->vertexDesc = other.vertexDesc;
this->varyingDesc = other.varyingDesc;
initial checking in TBB kernel.
2013-06-05 17:55:24 +00:00
this->V_ITa = other.V_ITa;
this->V_IT = other.V_IT;
this->V_W = other.V_W;
this->vertexOffset = other.vertexOffset;
this->tableOffset = other.tableOffset;
}
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
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
TBBVertexKernelB(float *vertex_in,
initial checking in TBB kernel.
2013-06-05 17:55:24 +00:00
float *varying_in,
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
OsdVertexBufferDescriptor const &vertexDesc_in,
OsdVertexBufferDescriptor const &varyingDesc_in,
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
int const *V_ITa_in,
int const *V_IT_in,
float const *V_W_in,
initial checking in TBB kernel.
2013-06-05 17:55:24 +00:00
int vertexOffset_in,
int tableOffset_in) :
vertex (vertex_in),
varying(varying_in),
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
vertexDesc(vertexDesc_in),
varyingDesc(varyingDesc_in),
initial checking in TBB kernel.
2013-06-05 17:55:24 +00:00
V_ITa (V_ITa_in),
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
V_IT (V_IT_in),
initial checking in TBB kernel.
2013-06-05 17:55:24 +00:00
V_W (V_W_in),
vertexOffset(vertexOffset_in),
tableOffset(tableOffset_in)
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
{};
initial checking in TBB kernel.
2013-06-05 17:55:24 +00:00
};
void OsdTbbComputeVertexB(
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
float *vertex, float *varying,
OsdVertexBufferDescriptor const &vertexDesc,
OsdVertexBufferDescriptor const &varyingDesc,
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
int const *V_ITa, int const *V_IT, float const *V_W,
initial checking in TBB kernel.
2013-06-05 17:55:24 +00:00
int vertexOffset, int tableOffset, int start, int end) {
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);
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
TBBVertexKernelB kernel(vertex, varying, vertexDesc, varyingDesc,
V_ITa, V_IT, V_W,
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
vertexOffset, tableOffset);
initial checking in TBB kernel.
2013-06-05 17:55:24 +00:00
tbb::parallel_for(range, kernel);
}
class TBBLoopVertexKernelB {
float *vertex;
float *varying;
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
OsdVertexBufferDescriptor vertexDesc;
OsdVertexBufferDescriptor varyingDesc;
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
int const *V_ITa;
int const *V_IT;
float const *V_W;
initial checking in TBB kernel.
2013-06-05 17:55:24 +00:00
int vertexOffset;
int tableOffset;
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
public:
void operator() (tbb::blocked_range<int> const &r) const {
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
if(vertexDesc.length == 4 && varying == NULL) {
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
ComputeLoopVertexBKernel<4>(vertex, V_ITa, V_IT, V_W, vertexOffset,
initial checking in TBB kernel.
2013-06-05 17:55:24 +00:00
tableOffset, r.begin(), r.end());
}
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
else if(vertexDesc.length == 8 && varying == NULL) {
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
ComputeLoopVertexBKernel<8>(vertex, V_ITa, V_IT, V_W, vertexOffset,
tableOffset, r.begin(), r.end());
}
initial checking in TBB kernel.
2013-06-05 17:55:24 +00:00
else {
for (int i = r.begin() + tableOffset; i < r.end() + tableOffset; i++) {
int h = V_ITa[5*i];
int n = V_ITa[5*i+1];
int p = V_ITa[5*i+2];
float weight = V_W[i];
float wp = 1.0f/static_cast<float>(n);
float beta = 0.25f * cosf(static_cast<float>(M_PI) * 2.0f * wp) + 0.375f;
beta = beta * beta;
beta = (0.625f - beta) * wp;
int dstIndex = i + vertexOffset - tableOffset;
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
clear(vertex, dstIndex, vertexDesc);
clear(varying, dstIndex, varyingDesc);
initial checking in TBB kernel.
2013-06-05 17:55:24 +00:00
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
addWithWeight(vertex, dstIndex, p, weight * (1.0f - (beta * n)), vertexDesc);
initial checking in TBB kernel.
2013-06-05 17:55:24 +00:00
for (int j = 0; j < n; ++j)
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
addWithWeight(vertex, dstIndex, V_IT[h+j], weight * beta, vertexDesc);
initial checking in TBB kernel.
2013-06-05 17:55:24 +00:00
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
addWithWeight(varying, dstIndex, p, 1.0f, varyingDesc);
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
}
}
}
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
TBBLoopVertexKernelB(TBBLoopVertexKernelB const &other)
initial checking in TBB kernel.
2013-06-05 17:55:24 +00:00
{
this->vertex = other.vertex;
this->varying= other.varying;
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
this->vertexDesc = other.vertexDesc;
this->varyingDesc = other.varyingDesc;
initial checking in TBB kernel.
2013-06-05 17:55:24 +00:00
this->V_ITa = other.V_ITa;
this->V_IT = other.V_IT;
this->V_W = other.V_W;
this->vertexOffset = other.vertexOffset;
this->tableOffset = other.tableOffset;
}
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
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
TBBLoopVertexKernelB(float *vertex_in,
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
float *varying_in,
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
OsdVertexBufferDescriptor const &vertexDesc_in,
OsdVertexBufferDescriptor const &varyingDesc_in,
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
int const *V_ITa_in,
int const *V_IT_in,
float const *V_W_in,
int vertexOffset_in,
int tableOffset_in) :
vertex (vertex_in),
varying(varying_in),
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
vertexDesc(vertexDesc_in),
varyingDesc(varyingDesc_in),
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
V_ITa (V_ITa_in),
V_IT (V_IT_in),
V_W (V_W_in),
vertexOffset(vertexOffset_in),
tableOffset(tableOffset_in)
{};
initial checking in TBB kernel.
2013-06-05 17:55:24 +00:00
};
void OsdTbbComputeLoopVertexB(
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
float *vertex, float *varying,
OsdVertexBufferDescriptor const &vertexDesc,
OsdVertexBufferDescriptor const &varyingDesc,
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
int const *V_ITa, int const *V_IT, float const *V_W,
initial checking in TBB kernel.
2013-06-05 17:55:24 +00:00
int vertexOffset, int tableOffset, int start, int end) {
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);
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
TBBLoopVertexKernelB kernel(vertex, varying, vertexDesc, varyingDesc,
V_ITa, V_IT, V_W,
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
vertexOffset, tableOffset);
initial checking in TBB kernel.
2013-06-05 17:55:24 +00:00
tbb::parallel_for(range, kernel);
}
class TBBBilinearEdgeKernel {
float *vertex;
float *varying;
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
OsdVertexBufferDescriptor vertexDesc;
OsdVertexBufferDescriptor varyingDesc;
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
int const *E_IT;
initial checking in TBB kernel.
2013-06-05 17:55:24 +00:00
int vertexOffset;
int tableOffset;
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
public:
void operator() (tbb::blocked_range<int> const &r) const {
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
if(vertexDesc.length == 4 && varying == NULL) {
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
ComputeBilinearEdgeKernel<4>(vertex, E_IT, vertexOffset, tableOffset,
initial checking in TBB kernel.
2013-06-05 17:55:24 +00:00
r.begin(), r.end());
}
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
else if(vertexDesc.length == 8 && varying == NULL) {
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
ComputeBilinearEdgeKernel<8>(vertex, E_IT, vertexOffset, tableOffset,
r.begin(), r.end());
initial checking in TBB kernel.
2013-06-05 17:55:24 +00:00
}
else {
for (int i = r.begin() + tableOffset; i < r.end() + tableOffset; i++) {
int eidx0 = E_IT[2*i+0];
int eidx1 = E_IT[2*i+1];
int dstIndex = i + vertexOffset - tableOffset;
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
clear(vertex, dstIndex, vertexDesc);
clear(varying, dstIndex, varyingDesc);
initial checking in TBB kernel.
2013-06-05 17:55:24 +00:00
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
addWithWeight(vertex, dstIndex, eidx0, 0.5f, vertexDesc);
addWithWeight(vertex, dstIndex, eidx1, 0.5f, vertexDesc);
initial checking in TBB kernel.
2013-06-05 17:55:24 +00:00
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
addWithWeight(varying, dstIndex, eidx0, 0.5f, varyingDesc);
addWithWeight(varying, dstIndex, eidx1, 0.5f, varyingDesc);
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
}
}
}
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
TBBBilinearEdgeKernel(TBBBilinearEdgeKernel const &other)
initial checking in TBB kernel.
2013-06-05 17:55:24 +00:00
{
this->vertex = other.vertex;
this->varying= other.varying;
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
this->vertexDesc = other.vertexDesc;
this->varyingDesc = other.varyingDesc;
initial checking in TBB kernel.
2013-06-05 17:55:24 +00:00
this->E_IT = other.E_IT;
this->vertexOffset = other.vertexOffset;
this->tableOffset = other.tableOffset;
}
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
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
TBBBilinearEdgeKernel(float *vertex_in,
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
float *varying_in,
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
OsdVertexBufferDescriptor const &vertexDesc_in,
OsdVertexBufferDescriptor const &varyingDesc_in,
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
int const *E_IT_in,
int vertexOffset_in,
int tableOffset_in) :
vertex (vertex_in),
varying(varying_in),
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
vertexDesc(vertexDesc_in),
varyingDesc(varyingDesc_in),
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
E_IT (E_IT_in),
vertexOffset(vertexOffset_in),
tableOffset(tableOffset_in)
{};
initial checking in TBB kernel.
2013-06-05 17:55:24 +00:00
};
void OsdTbbComputeBilinearEdge(
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
float *vertex, float *varying,
OsdVertexBufferDescriptor const &vertexDesc,
OsdVertexBufferDescriptor const &varyingDesc,
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
int const *E_IT, int vertexOffset, int tableOffset, int start, int end) {
tbb::blocked_range<int> range(start, end, grain_size);
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
TBBBilinearEdgeKernel kernel(vertex, varying, vertexDesc, varyingDesc,
E_IT, vertexOffset, tableOffset);
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
}
class TBBBilinearVertexKernel {
float *vertex;
float *varying;
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
OsdVertexBufferDescriptor vertexDesc;
OsdVertexBufferDescriptor varyingDesc;
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
int const *V_ITa;
initial checking in TBB kernel.
2013-06-05 17:55:24 +00:00
int vertexOffset;
int tableOffset;
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
public:
void operator() (tbb::blocked_range<int> const &r) const {
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
int numVertexElements = vertexDesc.length;
int numVaryingElements = varyingDesc.length;
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
float *src, *des;
initial checking in TBB kernel.
2013-06-05 17:55:24 +00:00
for (int i = r.begin() + tableOffset; i < r.end() + tableOffset; i++) {
int p = V_ITa[i];
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
int dstIndex = i + vertexOffset - tableOffset;
initial checking in TBB kernel.
2013-06-05 17:55:24 +00:00
src = vertex + p * numVertexElements;
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
des = vertex + dstIndex * numVertexElements;
initial checking in TBB kernel.
2013-06-05 17:55:24 +00:00
memcpy(des, src, sizeof(float)*numVertexElements);
if(varying) {
src = varying + p * numVaryingElements;
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
des = varying + dstIndex * numVaryingElements;
initial checking in TBB kernel.
2013-06-05 17:55:24 +00:00
memcpy(des, src, sizeof(float)*numVaryingElements);
}
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
}
}
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
TBBBilinearVertexKernel(TBBBilinearVertexKernel const &other)
initial checking in TBB kernel.
2013-06-05 17:55:24 +00:00
{
this->vertex = other.vertex;
this->varying= other.varying;
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
this->vertexDesc = other.vertexDesc;
this->varyingDesc = other.varyingDesc;
initial checking in TBB kernel.
2013-06-05 17:55:24 +00:00
this->V_ITa = other.V_ITa;
this->vertexOffset = other.vertexOffset;
this->tableOffset = other.tableOffset;
}
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
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
TBBBilinearVertexKernel(float *vertex_in,
initial checking in TBB kernel.
2013-06-05 17:55:24 +00:00
float *varying_in,
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
OsdVertexBufferDescriptor const &vertexDesc_in,
OsdVertexBufferDescriptor const &varyingDesc_in,
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
int const *V_ITa_in,
initial checking in TBB kernel.
2013-06-05 17:55:24 +00:00
int vertexOffset_in,
int tableOffset_in) :
vertex (vertex_in),
varying(varying_in),
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
vertexDesc(vertexDesc_in),
varyingDesc(varyingDesc_in),
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
V_ITa (V_ITa_in),
initial checking in TBB kernel.
2013-06-05 17:55:24 +00:00
vertexOffset(vertexOffset_in),
tableOffset(tableOffset_in)
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
{};
initial checking in TBB kernel.
2013-06-05 17:55:24 +00:00
};
void OsdTbbComputeBilinearVertex(
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
float *vertex, float *varying,
OsdVertexBufferDescriptor const &vertexDesc,
OsdVertexBufferDescriptor const &varyingDesc,
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
int const *V_ITa, int vertexOffset, int tableOffset, int start, int end) {
tbb::blocked_range<int> range(start, end, grain_size);
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
TBBBilinearVertexKernel kernel(vertex, varying, vertexDesc, varyingDesc,
V_ITa, vertexOffset, tableOffset);
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
}
void OsdTbbEditVertexAdd(
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
float *vertex,
OsdVertexBufferDescriptor const &vertexDesc,
initial checking in TBB kernel.
2013-06-05 17:55:24 +00:00
int primVarOffset, int primVarWidth, int vertexOffset, int tableOffset,
int start, int end,
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
unsigned int const *editIndices, float const *editValues) {
initial checking in TBB kernel.
2013-06-05 17:55:24 +00:00
for (int i = start+tableOffset; i < end+tableOffset; i++) {
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
if (vertex) {
int editIndex = editIndices[i] + vertexOffset;
float *dst = vertex + editIndex * vertexDesc.stride + primVarOffset;
for (int i = 0; i < primVarWidth; ++i) {
dst[i] += editValues[i];
}
}
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
}
initial checking in TBB kernel.
2013-06-05 17:55:24 +00:00
}
void OsdTbbEditVertexSet(
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
float *vertex,
OsdVertexBufferDescriptor const &vertexDesc,
initial checking in TBB kernel.
2013-06-05 17:55:24 +00:00
int primVarOffset, int primVarWidth, int vertexOffset, int tableOffset,
int start, int end,
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
unsigned int const *editIndices, float const *editValues) {
initial checking in TBB kernel.
2013-06-05 17:55:24 +00:00
for (int i = start+tableOffset; i < end+tableOffset; i++) {
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
if (vertex) {
int editIndex = editIndices[i] + vertexOffset;
float *dst = vertex + editIndex * vertexDesc.stride + primVarOffset;
for (int i = 0; i < primVarWidth; ++i) {
dst[i] = editValues[i];
}
}
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