bool
HdSt_TriangulateFaceVaryingComputation::Resolve()
{
if (!TF_VERIFY(_source)) return false;
if (!_source->IsResolved()) return false;
if (!_TryLock()) return false;
HD_TRACE_FUNCTION();
HD_PERF_COUNTER_INCR(HdPerfTokens->triangulateFaceVarying);
VtValue result;
HdMeshUtil meshUtil(_topology, _id);
if(meshUtil.ComputeTriangulatedFaceVaryingPrimvar(
_source->GetData(),
_source->GetNumElements(),
_source->GetGLElementDataType(),
&result)) {
_SetResult(HdBufferSourceSharedPtr(
new HdVtBufferSource(
_source->GetName(),
result)));
} else {
_SetResult(_source);
}
_SetResolved();
return true;
}
bool
Hd_TriangulateFaceVaryingComputation::Resolve()
{
if (not TF_VERIFY(_source)) return false;
if (not _source->IsResolved()) return false;
if (not _TryLock()) return false;
HD_TRACE_FUNCTION();
HD_PERF_COUNTER_INCR(HdPerfTokens->triangulateFaceVarying);
VtIntArray const &faceVertexCounts = _topology->GetFaceVertexCounts();
VtIntArray const &holeFaces = _topology->GetHoleIndices();
bool flip = (_topology->GetOrientation() != HdTokens->rightHanded);
HdBufferSourceSharedPtr result;
switch (_source->GetGLElementDataType()) {
case GL_FLOAT:
result = _TriangulateFaceVarying<float>(
_source, faceVertexCounts, holeFaces, flip, _id);
break;
case GL_FLOAT_VEC2:
result = _TriangulateFaceVarying<GfVec2f>(
_source, faceVertexCounts, holeFaces, flip, _id);
break;
case GL_FLOAT_VEC3:
result = _TriangulateFaceVarying<GfVec3f>(
_source, faceVertexCounts, holeFaces, flip, _id);
break;
case GL_FLOAT_VEC4:
result = _TriangulateFaceVarying<GfVec4f>(
_source, faceVertexCounts, holeFaces, flip, _id);
break;
case GL_DOUBLE:
result = _TriangulateFaceVarying<double>(
_source, faceVertexCounts, holeFaces, flip, _id);
break;
case GL_DOUBLE_VEC2:
result = _TriangulateFaceVarying<GfVec2d>(
_source, faceVertexCounts, holeFaces, flip, _id);
break;
case GL_DOUBLE_VEC3:
result = _TriangulateFaceVarying<GfVec3d>(
_source, faceVertexCounts, holeFaces, flip, _id);
break;
case GL_DOUBLE_VEC4:
result = _TriangulateFaceVarying<GfVec4d>(
_source, faceVertexCounts, holeFaces, flip, _id);
break;
default:
TF_CODING_ERROR("Unsupported primvar type for triangulation [%s]",
_id.GetText());
result = _source;
break;
}
_SetResult(result);
_SetResolved();
return true;
}
bool
HdSt_TriangleIndexBuilderComputation::Resolve()
{
if (!_TryLock()) return false;
HD_TRACE_FUNCTION();
VtVec3iArray trianglesFaceVertexIndices;
VtIntArray primitiveParam;
HdMeshUtil meshUtil(_topology, _id);
meshUtil.ComputeTriangleIndices(
&trianglesFaceVertexIndices,
&primitiveParam);
_SetResult(HdBufferSourceSharedPtr(
new HdVtBufferSource(
HdTokens->indices,
VtValue(trianglesFaceVertexIndices))));
_primitiveParam.reset(new HdVtBufferSource(
HdTokens->primitiveParam,
VtValue(primitiveParam)));
_SetResolved();
return true;
}
bool
Hd_SmoothNormalsComputation::Resolve()
{
// dependency check first
if (_adjacencyBuilder) {
if (not _adjacencyBuilder->IsResolved()) return false;
}
if (_points) {
if (not _points->IsResolved()) return false;
}
if (not _TryLock()) return false;
HD_TRACE_FUNCTION();
HD_MALLOC_TAG_FUNCTION();
if (not TF_VERIFY(_adjacency)) return true;
int numPoints = _points->GetNumElements();
HdBufferSourceSharedPtr normals;
switch (_points->GetGLElementDataType()) {
case GL_FLOAT_VEC3:
normals = HdBufferSourceSharedPtr(
new HdVtBufferSource(
_dstName, VtValue(
_adjacency->ComputeSmoothNormals(
numPoints,
static_cast<const GfVec3f*>(_points->GetData())))));
break;
case GL_DOUBLE_VEC3:
normals = HdBufferSourceSharedPtr(
new HdVtBufferSource(
_dstName, VtValue(
_adjacency->ComputeSmoothNormals(
numPoints,
static_cast<const GfVec3d*>(_points->GetData())))));
break;
default:
TF_CODING_ERROR("Unsupported points type for computing smooth normals");
break;
}
_SetResult(normals);
// call base class to mark as resolved.
_SetResolved();
return true;
}
bool
Hd_AdjacencyBuilderForGPUComputation::Resolve()
{
if (!_adjacencyBuilder->IsResolved()) return false;
if (!_TryLock()) return false;
HD_TRACE_FUNCTION();
HF_MALLOC_TAG_FUNCTION();
// prepare buffer source to be transferred.
std::vector<int> const &adjacency = _adjacency->GetAdjacencyTable();
// create buffer source
VtIntArray array(adjacency.size());
for (size_t i = 0; i < adjacency.size(); ++i) {
array[i] = adjacency[i];
}
_SetResult(HdBufferSourceSharedPtr(new HdVtBufferSource(HdTokens->adjacency,
VtValue(array))));
_SetResolved();
return true;
}
bool
Hd_TriangleIndexBuilderComputation::Resolve()
{
if (not _TryLock()) return false;
HD_TRACE_FUNCTION();
// generate triangle index buffer
int const * numVertsPtr = _topology->GetFaceVertexCounts().cdata();
int const * vertsPtr = _topology->GetFaceVertexIndices().cdata();
int const * holeFacesPtr = _topology->GetHoleIndices().cdata();
int numFaces = _topology->GetFaceVertexCounts().size();
int numVertIndices = _topology->GetFaceVertexIndices().size();
int numTris = 0;
int numHoleFaces = _topology->GetHoleIndices().size();
bool invalidTopology = false;
int holeIndex = 0;
for (int i=0; i<numFaces; ++i) {
int nv = numVertsPtr[i]-2;
if (nv < 1) {
// skip degenerated face
invalidTopology = true;
} else if (holeIndex < numHoleFaces and holeFacesPtr[holeIndex] == i) {
// skip hole face
++holeIndex;
} else {
numTris += nv;
}
}
if (invalidTopology) {
TF_WARN("degenerated face found [%s]", _id.GetText());
invalidTopology = false;
}
VtVec3iArray trianglesFaceVertexIndices(numTris);
VtIntArray primitiveParam(numTris);
bool flip = (_topology->GetOrientation() != HdTokens->rightHanded);
// reset holeIndex
holeIndex = 0;
for (int i=0,tv=0,v=0; i<numFaces; ++i) {
int nv = numVertsPtr[i];
if (nv < 3) {
// Skip degenerate faces.
} else if (holeIndex < numHoleFaces and holeFacesPtr[holeIndex] == i) {
// Skip hole faces.
++holeIndex;
} else {
// edgeFlag is used for inner-line removal of non-triangle
// faces on wireframe shading.
//
// 0__ 0 0 0__
// _/|\ \_ _/. .. . \_
// _/ | \ \_ -> _/ . . . . \_
// / A |C \ B \_ / A . .C . . B \_
// 1-----2---3----4 1-----2 1---2 1----2
//
// Type EdgeFlag Draw
// - 0 show all edges
// A 1 hide [2-0]
// B 2 hide [0-1]
// C 3 hide [0-1] and [2-0]
//
int edgeFlag = 0;
for (int j=0; j < nv-2; ++j) {
if (nv > 3) {
if (j == 0) edgeFlag = flip ? 2 : 1;
else if (j == nv-3) edgeFlag = flip ? 1 : 2;
else edgeFlag = 3;
}
if (not _FanTriangulate(
trianglesFaceVertexIndices[tv],
vertsPtr, v, j, numVertIndices, flip)) {
invalidTopology = true;
}
// note that ptex indexing isn't available along with
// triangulation.
int coarseFaceParam =
HdMeshTopology::EncodeCoarseFaceParam(i, edgeFlag);
primitiveParam[tv] = coarseFaceParam;
++tv;
}
}
// When the face is degenerate and nv > 0, we need to increment the v
// pointer to walk past the degenerate verts.
v += nv;
}
if (invalidTopology) {
TF_WARN("numVerts and verts are incosistent [%s]",
_id.GetText());
}
_SetResult(HdBufferSourceSharedPtr(
new HdVtBufferSource(
HdTokens->indices,
VtValue(trianglesFaceVertexIndices))));
_primitiveParam.reset(new HdVtBufferSource(
HdTokens->primitiveParam,
VtValue(primitiveParam)));
_SetResolved();
return true;
}
bool
Hd_SmoothNormalsComputation::Resolve()
{
// dependency check first
if (_adjacencyBuilder) {
if (!_adjacencyBuilder->IsResolved()) return false;
}
if (!_points->IsResolved()) return false;
if (!_TryLock()) return false;
HD_TRACE_FUNCTION();
HF_MALLOC_TAG_FUNCTION();
if (!TF_VERIFY(_adjacency)) return true;
size_t numPoints = _points->GetNumElements();
HdBufferSourceSharedPtr normals;
switch (_points->GetTupleType().type) {
case HdTypeFloatVec3:
if (_packed) {
normals = HdBufferSourceSharedPtr(
new HdVtBufferSource(
_dstName, VtValue(
Hd_SmoothNormals::ComputeSmoothNormalsPacked(
_adjacency,
numPoints,
static_cast<const GfVec3f*>(_points->GetData())))));
} else {
normals = HdBufferSourceSharedPtr(
new HdVtBufferSource(
_dstName, VtValue(
Hd_SmoothNormals::ComputeSmoothNormals(
_adjacency,
numPoints,
static_cast<const GfVec3f*>(_points->GetData())))));
}
break;
case HdTypeDoubleVec3:
if (_packed) {
normals = HdBufferSourceSharedPtr(
new HdVtBufferSource(
_dstName, VtValue(
Hd_SmoothNormals::ComputeSmoothNormalsPacked(
_adjacency,
numPoints,
static_cast<const GfVec3d*>(_points->GetData())))));
} else {
normals = HdBufferSourceSharedPtr(
new HdVtBufferSource(
_dstName, VtValue(
Hd_SmoothNormals::ComputeSmoothNormals(
_adjacency,
numPoints,
static_cast<const GfVec3d*>(_points->GetData())))));
}
break;
default:
TF_CODING_ERROR("Unsupported points type for computing smooth normals");
break;
}
_SetResult(normals);
// call base class to mark as resolved.
_SetResolved();
return true;
}
//------------------------------------------------------------------------------
void PostHandle::JobDoneCallBack( SmartPtr<IJob>& job )
{
SmartPtr<PostJob> postJob = SmartPtr_Static_Cast<PostJob>( job );
_SetResult( postJob->GetPostResult() );
_Finish( postJob->GetStatusCode() );
}
