Blender V5.3
instancer.cpp
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/instancer.h"
7#include "hydra/util.h"
8
9#include <pxr/base/gf/quatd.h>
10#include <pxr/base/gf/quatf.h>
11#include <pxr/base/gf/quath.h>
12#include <pxr/imaging/hd/instancedBySchema.h>
13#include <pxr/imaging/hd/instancerTopologySchema.h>
14#include <pxr/imaging/hd/primvarSchema.h>
15#include <pxr/imaging/hd/primvarsSchema.h>
16#include <pxr/imaging/hd/sceneDelegate.h>
17#include <pxr/imaging/hd/xformSchema.h>
18
20
21HdCyclesInstancer::HdCyclesInstancer(HdSceneDelegate *delegate, const SdfPath &instancerId)
22 : HdInstancer(delegate, instancerId)
23{
24}
25
27
28void HdCyclesInstancer::Sync(HdSceneDelegate *sceneDelegate,
29 HdRenderParam * /*renderParam*/,
30 HdDirtyBits *dirtyBits)
31{
32 _UpdateInstancer(sceneDelegate, dirtyBits);
33
34 if (HdChangeTracker::IsAnyPrimvarDirty(*dirtyBits, GetId())) {
35 SyncPrimvars();
36 }
37}
38
39void HdCyclesInstancer::SyncPrimvars()
40{
41 HdSceneDelegate *const sceneDelegate = GetDelegate();
42 const SdfPath &id = GetId();
43 const HdSceneIndexPrim prim = GetPrim(sceneDelegate, id);
44 HdPrimvarsSchema primvars = HdPrimvarsSchema::GetFromParent(prim.dataSource);
45
46 auto read_array_primvar = [&](const TfToken &name, auto &out) {
47 using T = std::remove_reference_t<decltype(out)>;
48 if (HdPrimvarSchema pv = primvars.GetPrimvar(name)) {
49 if (auto valueDs = pv.GetPrimvarValue()) {
50 const VtValue v = valueDs->GetValue(0.0f);
51 if (v.IsHolding<T>()) {
52 out = v.UncheckedGet<T>();
53 }
54 }
55 }
56 };
57
58 read_array_primvar(HdInstancerTokens->instanceTranslations, _translate);
59 read_array_primvar(HdInstancerTokens->instanceScales, _scale);
60 read_array_primvar(HdInstancerTokens->instanceTransforms, _instanceTransform);
61
62 /* Accept different array types for quaternions. */
63 if (HdPrimvarSchema pv = primvars.GetPrimvar(HdInstancerTokens->instanceRotations)) {
64 if (auto valueDs = pv.GetPrimvarValue()) {
65 const VtValue v = valueDs->GetValue(0.0f);
66 if (v.IsHolding<VtVec4fArray>()) {
67 _rotate = v.UncheckedGet<VtVec4fArray>();
68 }
69 else if (v.IsHolding<VtQuatfArray>()) {
70 const VtQuatfArray &src = v.UncheckedGet<VtQuatfArray>();
71 _rotate.clear();
72 _rotate.reserve(src.size());
73 for (const GfQuatf &q : src) {
74 const GfVec3f &im = q.GetImaginary();
75 _rotate.push_back(GfVec4f(q.GetReal(), im[0], im[1], im[2]));
76 }
77 }
78 else if (v.IsHolding<VtQuathArray>()) {
79 const VtQuathArray &src = v.UncheckedGet<VtQuathArray>();
80 _rotate.clear();
81 _rotate.reserve(src.size());
82 for (const GfQuath &q : src) {
83 const GfVec3h &im = q.GetImaginary();
84 _rotate.push_back(GfVec4f(q.GetReal(), im[0], im[1], im[2]));
85 }
86 }
87 }
88 }
89
90 sceneDelegate->GetRenderIndex().GetChangeTracker().MarkInstancerClean(id);
91}
92
93VtMatrix4dArray HdCyclesInstancer::ComputeInstanceTransforms(const SdfPath &prototypeId)
94{
95 HdSceneDelegate *const sceneDelegate = GetDelegate();
96 const SdfPath &id = GetId();
97 const HdSceneIndexPrim prim = GetPrim(sceneDelegate, id);
98
99 HdInstancerTopologySchema topology = HdInstancerTopologySchema::GetFromParent(prim.dataSource);
100 const VtIntArray instanceIndices = topology ?
101 topology.ComputeInstanceIndicesForProto(prototypeId) :
102 VtIntArray();
103
104 GfMatrix4d instanceTransform(1.0);
105 if (auto matrixDs = HdXformSchema::GetFromParent(prim.dataSource).GetMatrix()) {
106 instanceTransform = matrixDs->GetTypedValue(0.0f);
107 }
108
109 VtMatrix4dArray transforms;
110 transforms.reserve(instanceIndices.size());
111
112 for (const int index : instanceIndices) {
113 GfMatrix4d transform = instanceTransform;
114
115 if (index < _translate.size()) {
116 GfMatrix4d translateMat(1);
117 translateMat.SetTranslate(_translate[index]);
118 transform *= translateMat;
119 }
120
121 if (index < _rotate.size()) {
122 GfMatrix4d rotateMat(1);
123 const GfVec4f &quat = _rotate[index];
124 rotateMat.SetRotate(GfQuatd(quat[0], quat[1], quat[2], quat[3]));
125 transform *= rotateMat;
126 }
127
128 if (index < _scale.size()) {
129 GfMatrix4d scaleMat(1);
130 scaleMat.SetScale(_scale[index]);
131 transform *= scaleMat;
132 }
133
134 if (index < _instanceTransform.size()) {
135 transform *= _instanceTransform[index];
136 }
137
138 transforms.push_back(transform);
139 }
140
141 /* Recurse into the parent instancer. */
142 VtMatrix4dArray resultTransforms;
143
144 HdInstancedBySchema instancedBy = HdInstancedBySchema::GetFromParent(prim.dataSource);
145 SdfPath parentId;
146 if (auto pathsDs = instancedBy.GetPaths()) {
147 const VtArray<SdfPath> parentPaths = pathsDs->GetTypedValue(0.0f);
148 if (!parentPaths.empty()) {
149 parentId = parentPaths.front();
150 }
151 }
152 if (parentId.IsEmpty()) {
153 parentId = GetParentId();
154 }
155
156 if (!parentId.IsEmpty()) {
157 auto *const parentInstancer = static_cast<HdCyclesInstancer *>(
158 sceneDelegate->GetRenderIndex().GetInstancer(parentId));
159 if (parentInstancer) {
160 for (const GfMatrix4d &parentTransform : parentInstancer->ComputeInstanceTransforms(id)) {
161 for (const GfMatrix4d &localTransform : transforms) {
162 resultTransforms.push_back(parentTransform * localTransform);
163 }
164 }
165 return resultTransforms;
166 }
167 }
168
169 return transforms;
170}
171
SIMD_FORCE_INLINE btVector3 transform(const btVector3 &point) const
void Sync(PXR_NS::HdSceneDelegate *sceneDelegate, PXR_NS::HdRenderParam *renderParam, PXR_NS::HdDirtyBits *dirtyBits) override
Definition instancer.cpp:28
HdCyclesInstancer(PXR_NS::HdSceneDelegate *delegate, const PXR_NS::SdfPath &instancerId)
Definition instancer.cpp:21
PXR_NS::VtMatrix4dArray ComputeInstanceTransforms(const PXR_NS::SdfPath &prototypeId)
Definition instancer.cpp:93
~HdCyclesInstancer() override
#define index(i)
#define HDCYCLES_NAMESPACE_CLOSE_SCOPE
HDCYCLES_NAMESPACE_OPEN_SCOPE HdSceneIndexPrim GetPrim(HdSceneDelegate *delegate, const SdfPath &id)
#define T
ATTR_WARN_UNUSED_RESULT const BMVert * v