void
HdPoints::_UpdateDrawItem(HdDrawItem *drawItem, HdChangeTracker::DirtyBits *dirtyBits)
{
HD_TRACE_FUNCTION();
HD_MALLOC_TAG_FUNCTION();
SdfPath const& id = GetId();
/* VISIBILITY */
_UpdateVisibility(dirtyBits);
/* CONSTANT PRIMVARS, TRANSFORM AND EXTENT */
_PopulateConstantPrimVars(drawItem, dirtyBits);
/* INSTANCE PRIMVARS */
_PopulateInstancePrimVars(drawItem, dirtyBits, InstancePrimVar);
Hd_PointsShaderKey shaderKey;
drawItem->SetGeometricShader(Hd_GeometricShader::Create(shaderKey));
/* PRIMVAR */
if (HdChangeTracker::IsAnyPrimVarDirty(*dirtyBits, id)) {
_PopulateVertexPrimVars(drawItem, dirtyBits);
}
// VertexPrimVar may be null, if there are no points in the prim.
TF_VERIFY(drawItem->GetConstantPrimVarRange());
}
void
HdxColorCorrectionTask::Sync(HdSceneDelegate* delegate,
HdTaskContext* ctx,
HdDirtyBits* dirtyBits)
{
HD_TRACE_FUNCTION();
HF_MALLOC_TAG_FUNCTION();
if ((*dirtyBits) & HdChangeTracker::DirtyParams) {
HdxColorCorrectionTaskParams params;
if (_GetTaskParams(delegate, ¶ms)) {
_framebufferSize = params.framebufferSize;
_colorCorrectionMode = params.colorCorrectionMode;
_displayOCIO = params.displayOCIO;
_viewOCIO = params.viewOCIO;
_colorspaceOCIO = params.colorspaceOCIO;
_looksOCIO = params.looksOCIO;
_lut3dSizeOCIO = params.lut3dSizeOCIO;
// Rebuild shader with new OCIO settings / shader-code.
_shaderProgram.reset();
}
}
*dirtyBits = HdChangeTracker::Clean;
}
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
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;
}
HdDirtyList::~HdDirtyList()
{
HD_TRACE_FUNCTION();
HF_MALLOC_TAG_FUNCTION();
HD_PERF_COUNTER_DECR(HdPerfTokens->dirtyLists);
}
bool
HdMeshTopology::operator==(HdMeshTopology const &other) const {
HD_TRACE_FUNCTION();
return (_topology == other._topology);
}
bool
HdSt_DrawBatch::_DrawingProgram::CompileShader(
HdStDrawItem const *drawItem,
bool indirect,
HdStResourceRegistrySharedPtr const &resourceRegistry)
{
HD_TRACE_FUNCTION();
HF_MALLOC_TAG_FUNCTION();
// glew has to be initialized
if (!glLinkProgram) {
return false;
}
if (!_geometricShader) {
TF_CODING_ERROR("Can not compile a shader without a geometric shader");
return false;
}
// determine binding points and populate metaData
HdBindingRequestVector customBindings;
bool instanceDraw = true;
_GetCustomBindings(&customBindings, &instanceDraw);
// also (surface, renderPass) shaders use their bindings
HdStShaderCodeSharedPtrVector shaders = GetComposedShaders();
TF_FOR_ALL(it, shaders) {
(*it)->AddBindings(&customBindings);
}
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;
}
HdReprSharedPtr const &
HdPoints::_GetRepr(TfToken const &reprName, HdChangeTracker::DirtyBits *dirtyBits)
{
HD_TRACE_FUNCTION();
HD_MALLOC_TAG_FUNCTION();
_PointsReprConfig::DescArray descs = _reprDescConfig.Find(reprName);
_ReprVector::iterator it = _reprs.begin();
bool isNew = it == _reprs.end();
if (isNew) {
it = _reprs.insert(_reprs.end(),
std::make_pair(reprName,
HdReprSharedPtr(new HdRepr())));
// allocate all draw items
for (auto desc : descs) {
if (desc.geomStyle == HdPointsGeomStyleInvalid) {
continue;
}
it->second->AddDrawItem(&_sharedData);
}
}
// points don't have multiple draw items (for now)
if (isNew or HdChangeTracker::IsDirty(*dirtyBits)) {
if (descs[0].geomStyle != HdPointsGeomStyleInvalid) {
_UpdateDrawItem(it->second->GetDrawItem(0), dirtyBits);
}
}
return it->second;
}
/* static */
void
HdPoints::ConfigureRepr(TfToken const &reprName, HdPointsReprDesc desc)
{
HD_TRACE_FUNCTION();
_reprDescConfig.Append(reprName, _PointsReprConfig::DescArray{desc});
}
void
HdRenderIndex::RemoveRprim(SdfPath const& id)
{
HD_TRACE_FUNCTION();
_RprimMap::iterator rit = _rprimMap.find(id);
if (rit == _rprimMap.end())
return;
_RprimInfo &rprimInfo = rit->second;
SdfPath instancerId = rprimInfo.rprim->GetInstancerId();
_rprimIds.Remove(id);
if (!instancerId.IsEmpty()) {
_tracker.InstancerRPrimRemoved(instancerId, id);
}
_tracker.RprimRemoved(id);
// Ask delegate to actually delete the rprim
rprimInfo.rprim->Finalize(_renderDelegate->GetRenderParam());
_renderDelegate->DestroyRprim(rprimInfo.rprim);
rprimInfo.rprim = nullptr;
_rprimMap.erase(rit);
}
void
Hd_PrimTypeIndex<PrimType>::RemovePrim(const TfToken &typeId,
const SdfPath &primId,
HdChangeTracker &tracker,
HdRenderDelegate *renderDelegate)
{
HD_TRACE_FUNCTION();
HF_MALLOC_TAG_FUNCTION();
typename _TypeIndex::iterator typeIt = _index.find(typeId);
if (typeIt ==_index.end()) {
TF_CODING_ERROR("Unsupported prim type: %s", typeId.GetText());
return;
}
_PrimTypeEntry &typeEntry = _entries[typeIt->second];
typename _PrimMap::iterator primIt = typeEntry.primMap.find(primId);
if (primIt == typeEntry.primMap.end()) {
return;
}
_TrackerRemovePrim(tracker, primId);
_PrimInfo &primInfo = primIt->second;
_RenderDelegateDestroyPrim(renderDelegate, primInfo.prim);
primInfo.prim = nullptr;
typeEntry.primMap.erase(primIt);
typeEntry.primIds.Remove(primId);
}
/* virtual */
std::string
HdSt_FallbackLightingShader::GetSource(TfToken const &shaderStageKey) const
{
HD_TRACE_FUNCTION();
HF_MALLOC_TAG_FUNCTION();
return _glslfx->GetSource(shaderStageKey);
}
void
HdxSelectionTask::_Execute(HdTaskContext* ctx)
{
HD_TRACE_FUNCTION();
HF_MALLOC_TAG_FUNCTION();
// Note that selectionTask comes after renderTask.
}
TfTokenVector const &
HdRenderPass::GetRenderTags()
{
HD_TRACE_FUNCTION();
HF_MALLOC_TAG_FUNCTION();
return _collection.GetRenderTags();
}
/* virtual */
HdSt_TestLightingShader::ID
HdSt_TestLightingShader::ComputeHash() const
{
HD_TRACE_FUNCTION();
size_t hash = _glslfx->GetHash();
return (ID)hash;
}
HdTopology::ID
HdMeshTopology::ComputeHash() const
{
HD_TRACE_FUNCTION();
HdTopology::ID hash =_topology.ComputeHash();
hash = ArchHash64((const char*)&_refineLevel, sizeof(_refineLevel), hash);
return hash;
}
/* virtual */
std::string
HdSt_TestLightingShader::GetSource(TfToken const &shaderStageKey) const
{
HD_TRACE_FUNCTION();
HF_MALLOC_TAG_FUNCTION();
std::string source = _glslfx->GetSource(shaderStageKey);
return source;
}
void
HdRenderPass::Sync()
{
HD_TRACE_FUNCTION();
HF_MALLOC_TAG_FUNCTION();
// Sync the dirty list of prims
_renderIndex->Sync(_dirtyList);
}
void
HdCommandBuffer::PrepareDraw(HdRenderPassStateSharedPtr const &renderPassState,
HdResourceRegistrySharedPtr const &resourceRegistry)
{
HD_TRACE_FUNCTION();
TF_FOR_ALL(batchIt, _drawBatches) {
(*batchIt)->PrepareDraw(renderPassState, resourceRegistry);
}
/* static */
void
HdMesh::ConfigureRepr(TfToken const &reprName,
HdMeshReprDesc desc1,
HdMeshReprDesc desc2)
{
HD_TRACE_FUNCTION();
_reprDescConfig.Append(reprName, _MeshReprConfig::DescArray{desc1, desc2});
}
void
HdPoints::_PopulateVertexPrimVars(HdDrawItem *drawItem,
HdChangeTracker::DirtyBits *dirtyBits)
{
HD_TRACE_FUNCTION();
HD_MALLOC_TAG_FUNCTION();
SdfPath const& id = GetId();
HdSceneDelegate* delegate = GetDelegate();
HdResourceRegistry *resourceRegistry = &HdResourceRegistry::GetInstance();
// The "points" attribute is expected to be in this list.
TfTokenVector primVarNames = delegate->GetPrimVarVertexNames(id);
TfTokenVector const& vars = delegate->GetPrimVarVaryingNames(id);
primVarNames.insert(primVarNames.end(), vars.begin(), vars.end());
HdBufferSourceVector sources;
sources.reserve(primVarNames.size());
int pointsIndexInSourceArray = -1;
TF_FOR_ALL(nameIt, primVarNames) {
if (not HdChangeTracker::IsPrimVarDirty(*dirtyBits, id, *nameIt))
continue;
// TODO: We don't need to pull primvar metadata every time a value
// changes, but we need support from the delegate.
//assert name not in range.bufferArray.GetResources()
VtValue value = delegate->Get(id, *nameIt);
if (!value.IsEmpty()) {
// Store where the points will be stored in the source array
// we need this later to figure out if the number of points is changing
// and we need to force a garbage collection to resize the buffer
if (*nameIt == HdTokens->points) {
pointsIndexInSourceArray = sources.size();
}
// XXX: do we need special treatment for width as basicCurves?
HdBufferSourceSharedPtr source(new HdVtBufferSource(*nameIt, value));
sources.push_back(source);
}
}
// return before allocation if it's empty.
if (sources.empty())
return;
if (not drawItem->GetVertexPrimVarRange() or
not drawItem->GetVertexPrimVarRange()->IsValid()) {
// initialize buffer array
HdBufferSpecVector bufferSpecs;
TF_FOR_ALL(it, sources) {
(*it)->AddBufferSpecs(&bufferSpecs);
}
void
HdStBufferArrayRangeGL::GetBufferSpecs(HdBufferSpecVector *specs) const
{
HD_TRACE_FUNCTION();
HdStBufferResourceGLNamedList const &resources = GetResources();
TF_FOR_ALL(it, resources) {
specs->emplace_back(it->first, it->second->GetTupleType());
}
void
UsdImagingPointsAdapter::_GetPoints(UsdPrim const& prim,
VtValue* value,
UsdTimeCode time)
{
HD_TRACE_FUNCTION();
if (!prim.GetAttribute(UsdGeomTokens->points).Get(value, time)) {
*value = VtVec3fArray();
}
}
void
HdRenderIndex::Clear()
{
HD_TRACE_FUNCTION();
TF_FOR_ALL(it, _rprimMap) {
_tracker.RprimRemoved(it->first);
_RprimInfo &rprimInfo = it->second;
_renderDelegate->DestroyRprim(rprimInfo.rprim);
rprimInfo.rprim = nullptr;
}
/* static */
HdTextureResource::ID
HdTextureResource::ComputeFallbackUVHash()
{
HD_TRACE_FUNCTION();
uint32_t hash = 0;
std::string const &filename = _tokens->fallbackUVPath.GetString();
hash = ArchHash(filename.c_str(), filename.size(), hash);
return hash;
}
/* static */
HdStGLSLProgram::ID
HdStGLSLProgram::ComputeHash(TfToken const &sourceFile)
{
HD_TRACE_FUNCTION();
uint32_t hash = 0;
std::string const &filename = sourceFile.GetString();
hash = ArchHash(filename.c_str(), filename.size(), hash);
return hash;
}
void
HdChangeTracker::AddCollection(TfToken const& collectionName)
{
HD_TRACE_FUNCTION();
_CollectionStateMap::iterator it = _collectionState.find(collectionName);
// if it already exists, just return.
if (it != _collectionState.end()) {
return;
}
_collectionState[collectionName] = 1;
}
bool
HdBasisCurvesTopology::operator==(HdBasisCurvesTopology const &other) const
{
HD_TRACE_FUNCTION();
// no need to compare _adajency and _quadInfo
return (_curveType == other._curveType &&
_curveBasis == other._curveBasis &&
_curveWrap == other._curveWrap &&
_curveVertexCounts == other._curveVertexCounts &&
_curveIndices == other._curveIndices);
}
void
Hd_OsdRefineComputationGPU::Execute(HdBufferArrayRangeSharedPtr const &range)
{
HD_TRACE_FUNCTION();
HD_MALLOC_TAG_FUNCTION();
Hd_Subdivision *subdivision = _topology->GetSubdivision();
if (not TF_VERIFY(subdivision)) return;
subdivision->RefineGPU(range, _name);
HD_PERF_COUNTER_INCR(HdPerfTokens->subdivisionRefineGPU);
}