Blender V5.3
geometry.inl
Go to the documentation of this file.
1/* SPDX-FileCopyrightText: 2022 NVIDIA Corporation
2 * SPDX-FileCopyrightText: 2022 Blender Foundation
3 *
4 * SPDX-License-Identifier: Apache-2.0 */
5
6#include "hydra/geometry.h"
7#include "hydra/instancer.h"
8#include "hydra/material.h"
9#include "hydra/session.h"
10#include "hydra/util.h"
11#include "scene/geometry.h"
12#include "scene/object.h"
13#include "scene/scene.h"
14#include "util/hash.h"
15
16#include <pxr/imaging/hd/materialBindingSchema.h>
17#include <pxr/imaging/hd/materialBindingsSchema.h>
18#include <pxr/imaging/hd/sceneDelegate.h>
19#include <pxr/imaging/hd/tokens.h>
20#include <pxr/imaging/hd/xformSchema.h>
21
24extern Transform convert_transform(const GfMatrix4d &matrix);
26template<typename Base, typename CyclesBase>
28 : Base(rprimId), _geomTransform(1.0)
29{
31
32template<typename Base, typename CyclesBase>
34 HdDirtyBits *dirtyBits)
35{
36 TF_UNUSED(reprToken);
37 TF_UNUSED(dirtyBits);
38}
39
40template<typename Base, typename CyclesBase>
42{
43 return HdChangeTracker::DirtyPrimID | HdChangeTracker::DirtyTransform |
44 HdChangeTracker::DirtyMaterialId | HdChangeTracker::DirtyVisibility |
45 HdChangeTracker::DirtyInstancer;
46}
47
48template<typename Base, typename CyclesBase>
50{
51 return bits;
52}
53
54template<typename Base, typename CyclesBase>
55void HdCyclesGeometry<Base, CyclesBase>::Sync(HdSceneDelegate *sceneDelegate,
56 HdRenderParam *renderParam,
57 HdDirtyBits *dirtyBits,
58 const TfToken &reprToken)
59{
60 TF_UNUSED(reprToken);
61
62 if (*dirtyBits == HdChangeTracker::Clean) {
63 return;
64 }
65
66 Initialize(renderParam);
67
68 Base::_UpdateInstancer(sceneDelegate, dirtyBits);
69 HdInstancer::_SyncInstancerAndParents(sceneDelegate->GetRenderIndex(), Base::GetInstancerId());
70 Base::_UpdateVisibility(sceneDelegate, dirtyBits);
71
72 const SceneLock lock(renderParam);
73
74 const SdfPath &id = Base::GetId();
75 const HdSceneIndexPrim prim = GetPrim(sceneDelegate, id);
76 const HdContainerDataSourceHandle &primDs = prim.dataSource;
77
78 if (*dirtyBits & HdChangeTracker::DirtyMaterialId) {
79 SdfPath materialId;
80 /* Purpose here matches #HdCyclesDelegate::GetMaterialBindingPurpose. */
81 if (auto pathDs =
82 HdMaterialBindingsSchema::GetFromParent(primDs).GetMaterialBinding().GetPath())
83 {
84 materialId = pathDs->GetTypedValue(0.0f);
85 }
86 Base::SetMaterialId(materialId);
87
88 const auto *const material = static_cast<const HdCyclesMaterial *>(
89 sceneDelegate->GetRenderIndex().GetSprim(HdPrimTypeTokens->material,
90 Base::GetMaterialId()));
91
92 array<Node *> usedShaders(1);
93 if (material && material->GetCyclesShader()) {
94 usedShaders[0] = material->GetCyclesShader();
95 }
96 else {
97 usedShaders[0] = lock.scene->default_surface;
98 }
99
100 for (Node *shader : usedShaders) {
101 static_cast<Shader *>(shader)->tag_used(lock.scene);
102 }
103
104 _geom->set_used_shaders(usedShaders);
105 }
106
107 if (HdChangeTracker::IsPrimIdDirty(*dirtyBits, id)) {
108 // This needs to be corrected in the AOV
109 _instances[0]->set_pass_id(Base::GetPrimId() + 1);
110 }
111
112 if (HdChangeTracker::IsTransformDirty(*dirtyBits, id)) {
113 _geomTransform = GfMatrix4d(1.0);
114 if (auto matrixDs = HdXformSchema::GetFromParent(primDs).GetMatrix()) {
115 _geomTransform = matrixDs->GetTypedValue(0.0f);
116 }
117 }
118
119 if (HdChangeTracker::IsTransformDirty(*dirtyBits, id) ||
120 HdChangeTracker::IsInstancerDirty(*dirtyBits, id))
121 {
122 auto *const instancer = static_cast<HdCyclesInstancer *>(
123 sceneDelegate->GetRenderIndex().GetInstancer(Base::GetInstancerId()));
124
125 // Make sure the first object attribute is the instanceId
126 assert(_instances[0]->attributes.size() >= 1 &&
127 _instances[0]->attributes.front().name() == HdAovTokens->instanceId.GetString());
128
129 VtMatrix4dArray transforms;
130 if (instancer) {
131 transforms = instancer->ComputeInstanceTransforms(id);
132 _instances[0]->attributes.front() = ParamValue(HdAovTokens->instanceId.GetString(), +0.0f);
133 }
134 else {
135 // Default to a single instance with an identity transform
136 transforms.push_back(GfMatrix4d(1.0));
137 _instances[0]->attributes.front() = ParamValue(HdAovTokens->instanceId.GetString(), -1.0f);
138 }
139
140 const size_t oldSize = _instances.size();
141 const size_t newSize = transforms.size();
142
143 // Resize instance list
144 for (size_t i = newSize; i < oldSize; ++i) {
145 lock.scene->delete_node(_instances[i]);
146 }
147 _instances.resize(newSize);
148 for (size_t i = oldSize; i < newSize; ++i) {
149 _instances[i] = lock.scene->create_node<Object>();
150 InitializeInstance(static_cast<int>(i));
151 }
152
153 // Update transforms of all instances
154 for (size_t i = 0; i < transforms.size(); ++i) {
155 const float metersPerUnit =
156 static_cast<HdCyclesSession *>(renderParam)->GetStageMetersPerUnit();
157
158 const Transform tfm = transform_scale(make_float3(metersPerUnit)) *
159 convert_transform(_geomTransform * transforms[i]);
160 _instances[i]->set_tfm(tfm);
161 }
162 }
163
164 if (HdChangeTracker::IsVisibilityDirty(*dirtyBits, id)) {
165 for (Object *instance : _instances) {
166 instance->set_visibility(Base::IsVisible() ? PATH_RAY_VISIBILITY_OBJECT_ALL : 0);
167 }
168 }
169
170 // Must happen after material ID update, so that attribute decisions can be made
171 // based on it (e.g. check whether an attribute is actually needed)
172 bool rebuild = false;
173 Populate(sceneDelegate, *dirtyBits, rebuild);
174
175 if (_geom->is_modified() || rebuild) {
176 _geom->tag_update(lock.scene, rebuild);
177 }
178
179 for (Object *instance : _instances) {
180 instance->tag_update(lock.scene);
181 }
182
183 *dirtyBits = HdChangeTracker::Clean;
184}
185
186template<typename Base, typename CyclesBase>
187void HdCyclesGeometry<Base, CyclesBase>::Finalize(HdRenderParam *renderParam)
188{
189 if (!_geom && _instances.empty()) {
190 return;
191 }
192
193 const SceneLock lock(renderParam);
194 const bool keep_nodes = static_cast<const HdCyclesSession *>(renderParam)->keep_nodes;
195
196 /* Delete the instances before the geometry, since the objects reference the geometry. */
197 if (!keep_nodes) {
198 lock.scene->delete_nodes(set<Object *>(_instances.begin(), _instances.end()));
199 }
200 _instances.clear();
201 _instances.shrink_to_fit();
202
203 if (!keep_nodes) {
204 lock.scene->delete_node(_geom);
205 }
206 _geom = nullptr;
207}
208
209template<typename Base, typename CyclesBase>
210void HdCyclesGeometry<Base, CyclesBase>::Initialize(HdRenderParam *renderParam)
211{
212 if (_geom) {
213 return;
214 }
215
216 const SceneLock lock(renderParam);
217
218 // Create geometry
219 _geom = lock.scene->create_node<CyclesBase>();
220 _geom->name = Base::GetId().GetString();
221
222 // Create default instance
223 _instances.push_back(lock.scene->create_node<Object>());
224 InitializeInstance(0);
225}
226
227template<typename Base, typename CyclesBase>
228void HdCyclesGeometry<Base, CyclesBase>::InitializeInstance(int index)
229{
230 Object *instance = _instances[index];
231 instance->set_geometry(_geom);
232
233 instance->attributes.emplace_back(HdAovTokens->instanceId.GetString(),
234 _instances.size() == 1 ? -1.0f : static_cast<float>(index));
235
236 instance->set_color(make_float3(0.8f, 0.8f, 0.8f));
237 instance->set_random_id(hash_uint2(hash_string(_geom->name.c_str()), index));
238}
239
volatile int lock
PXR_NS::HdDirtyBits _PropagateDirtyBits(PXR_NS::HdDirtyBits bits) const override
Definition geometry.inl:49
void Finalize(PXR_NS::HdRenderParam *renderParam) override
Definition geometry.inl:187
void _InitRepr(const PXR_NS::TfToken &reprToken, PXR_NS::HdDirtyBits *dirtyBits) override
Definition geometry.inl:33
virtual void Populate(PXR_NS::HdSceneDelegate *sceneDelegate, PXR_NS::HdDirtyBits dirtyBits, bool &rebuild)=0
CyclesBase * _geom
HdCyclesGeometry(const PXR_NS::SdfPath &rprimId)
Definition geometry.inl:27
PXR_NS::HdDirtyBits GetInitialDirtyBitsMask() const override
Definition geometry.inl:41
void Sync(PXR_NS::HdSceneDelegate *sceneDelegate, PXR_NS::HdRenderParam *renderParam, PXR_NS::HdDirtyBits *dirtyBits, const PXR_NS::TfToken &reprToken) override
Definition geometry.inl:55
std::vector< CCL_NS::Object * > _instances
vector< ParamValue > attributes
ccl_device_forceinline float3 make_float3(const float x, const float y, const float z)
uint hash_uint2(uint kx, uint ky)
#define assert(assertion)
#define index(i)
HDCYCLES_NAMESPACE_OPEN_SCOPE Transform convert_transform(const GfMatrix4d &matrix)
#define HDCYCLES_NAMESPACE_CLOSE_SCOPE
HDCYCLES_NAMESPACE_OPEN_SCOPE HdSceneIndexPrim GetPrim(HdSceneDelegate *delegate, const SdfPath &id)
@ PATH_RAY_VISIBILITY_OBJECT_ALL
constexpr uint64_t hash_string(StringRef str)
Definition BLI_hash.hh:183
ccl_device_inline Transform transform_scale(const float3 s)
Definition transform.h:313