8 #include <pxr/base/gf/matrix3d.h>
9 #include <pxr/base/gf/matrix3f.h>
10 #include <pxr/base/gf/matrix4d.h>
11 #include <pxr/base/gf/matrix4f.h>
12 #include <pxr/base/gf/vec2f.h>
13 #include <pxr/base/gf/vec3f.h>
14 #include <pxr/base/vt/array.h>
15 #include <pxr/usd/sdf/assetPath.h>
23 if (value.IsHolding<DstType>()) {
24 return value.UncheckedGet<DstType>();
27 VtValue castedValue = VtValue::Cast<DstType>(value);
28 if (castedValue.IsHolding<DstType>()) {
29 return castedValue.UncheckedGet<DstType>();
32 TF_WARN(
"Could not convert VtValue to Cycles type");
38 const GfVec2f convertedValue = convertToCycles<GfVec2f>(value);
39 return make_float2(convertedValue[0], convertedValue[1]);
44 if (value.IsHolding<GfVec3f>()) {
45 const GfVec3f convertedValue = value.UncheckedGet<GfVec3f>();
46 return make_float3(convertedValue[0], convertedValue[1], convertedValue[2]);
48 if (value.IsHolding<GfVec4f>()) {
49 const GfVec4f convertedValue = value.UncheckedGet<GfVec4f>();
50 return make_float3(convertedValue[0], convertedValue[1], convertedValue[2]);
53 if (value.CanCast<GfVec3f>()) {
54 const GfVec3f convertedValue = VtValue::Cast<GfVec3f>(value).UncheckedGet<GfVec3f>();
55 return make_float3(convertedValue[0], convertedValue[1], convertedValue[2]);
57 if (value.CanCast<GfVec4f>()) {
58 const GfVec4f convertedValue = VtValue::Cast<GfVec4f>(value).UncheckedGet<GfVec4f>();
59 return make_float3(convertedValue[0], convertedValue[1], convertedValue[2]);
62 TF_WARN(
"Could not convert VtValue to float3");
68 if (value.IsHolding<TfToken>()) {
69 return ustring(value.UncheckedGet<TfToken>().GetString());
71 if (value.IsHolding<std::string>()) {
72 return ustring(value.UncheckedGet<std::string>());
74 if (value.IsHolding<SdfAssetPath>()) {
75 const SdfAssetPath &path = value.UncheckedGet<SdfAssetPath>();
76 return ustring(path.GetResolvedPath());
79 if (value.CanCast<TfToken>()) {
82 if (value.CanCast<std::string>()) {
85 if (value.CanCast<SdfAssetPath>()) {
89 TF_WARN(
"Could not convert VtValue to ustring");
93 template<
typename Matrix>
112 template<
typename Matrix>
133 if (value.IsHolding<GfMatrix4f>()) {
134 return convertMatrixToCycles<GfMatrix4f>(value.UncheckedGet<GfMatrix4f>());
136 if (value.IsHolding<GfMatrix3f>()) {
137 return convertMatrixToCycles<GfMatrix3f>(value.UncheckedGet<GfMatrix3f>());
139 if (value.IsHolding<GfMatrix4d>()) {
140 return convertMatrixToCycles<GfMatrix4d>(value.UncheckedGet<GfMatrix4d>());
142 if (value.IsHolding<GfMatrix3d>()) {
143 return convertMatrixToCycles<GfMatrix3d>(value.UncheckedGet<GfMatrix3d>());
146 if (value.CanCast<GfMatrix4f>()) {
149 if (value.CanCast<GfMatrix3f>()) {
152 if (value.CanCast<GfMatrix4d>()) {
155 if (value.CanCast<GfMatrix3d>()) {
159 TF_WARN(
"Could not convert VtValue to Transform");
163 template<
typename DstType,
typename SrcType = DstType>
166 static_assert(
sizeof(DstType) ==
sizeof(SrcType),
167 "Size mismatch between VtArray and array base type");
169 using SrcArray = VtArray<SrcType>;
171 if (value.IsHolding<SrcArray>()) {
172 const auto &valueData = value.UncheckedGet<SrcArray>();
174 cyclesArray.
resize(valueData.size());
175 std::memcpy(cyclesArray.data(), valueData.data(), valueData.size() *
sizeof(DstType));
179 if (value.CanCast<SrcArray>()) {
180 VtValue castedValue = VtValue::Cast<SrcArray>(value);
181 const auto &valueData = castedValue.UncheckedGet<SrcArray>();
183 cyclesArray.
resize(valueData.size());
184 std::memcpy(cyclesArray.data(), valueData.data(), valueData.size() *
sizeof(DstType));
193 if (value.IsHolding<VtVec3fArray>()) {
194 const auto &valueData = value.UncheckedGet<VtVec3fArray>();
196 cyclesArray.
reserve(valueData.size());
197 for (
const GfVec3f &vec : valueData) {
198 cyclesArray.push_back_reserved(
make_float3(vec[0], vec[1], vec[2]));
202 if (value.IsHolding<VtVec4fArray>()) {
203 const auto &valueData = value.UncheckedGet<VtVec4fArray>();
205 cyclesArray.
reserve(valueData.size());
206 for (
const GfVec4f &vec : valueData) {
207 cyclesArray.push_back_reserved(
make_float3(vec[0], vec[1], vec[2]));
212 if (value.CanCast<VtVec3fArray>()) {
215 if (value.CanCast<VtVec4fArray>()) {
224 using SdfPathArray = VtArray<SdfAssetPath>;
226 if (value.IsHolding<VtStringArray>()) {
227 const auto &valueData = value.UncheckedGet<VtStringArray>();
229 cyclesArray.
reserve(valueData.size());
230 for (
const auto &
element : valueData) {
231 cyclesArray.push_back_reserved(ustring(
element));
235 if (value.IsHolding<VtTokenArray>()) {
236 const auto &valueData = value.UncheckedGet<VtTokenArray>();
238 cyclesArray.
reserve(valueData.size());
239 for (
const auto &
element : valueData) {
240 cyclesArray.push_back_reserved(ustring(
element.GetString()));
244 if (value.IsHolding<SdfPathArray>()) {
245 const auto &valueData = value.UncheckedGet<SdfPathArray>();
247 cyclesArray.
reserve(valueData.size());
248 for (
const auto &
element : valueData) {
249 cyclesArray.push_back_reserved(ustring(
element.GetResolvedPath()));
254 if (value.CanCast<VtStringArray>()) {
257 if (value.CanCast<VtTokenArray>()) {
260 if (value.CanCast<SdfPathArray>()) {
264 TF_WARN(
"Could not convert VtValue to array<ustring>");
270 assert(value.IsHolding<MatrixArray>());
272 const auto &valueData = value.UncheckedGet<MatrixArray>();
274 cyclesArray.
reserve(valueData.size());
275 for (
const auto &
element : valueData) {
276 cyclesArray.push_back_reserved(
277 convertMatrixToCycles<typename MatrixArray::value_type>(
element));
284 if (value.IsHolding<VtMatrix4fArray>()) {
285 return convertToCyclesTransformArray<VtMatrix4fArray>(value);
287 if (value.IsHolding<VtMatrix3fArray>()) {
288 return convertToCyclesTransformArray<VtMatrix3fArray>(value);
290 if (value.IsHolding<VtMatrix4dArray>()) {
291 return convertToCyclesTransformArray<VtMatrix4dArray>(value);
293 if (value.IsHolding<VtMatrix3dArray>()) {
294 return convertToCyclesTransformArray<VtMatrix3dArray>(value);
297 if (value.CanCast<VtMatrix4fArray>()) {
298 return convertToCyclesTransformArray<VtMatrix4fArray>(VtValue::Cast<VtMatrix4fArray>(value));
300 if (value.CanCast<VtMatrix3fArray>()) {
301 return convertToCyclesTransformArray<VtMatrix3fArray>(VtValue::Cast<VtMatrix3fArray>(value));
303 if (value.CanCast<VtMatrix4dArray>()) {
304 return convertToCyclesTransformArray<VtMatrix4dArray>(VtValue::Cast<VtMatrix4dArray>(value));
306 if (value.CanCast<VtMatrix3dArray>()) {
307 return convertToCyclesTransformArray<VtMatrix3dArray>(VtValue::Cast<VtMatrix3dArray>(value));
310 TF_WARN(
"Could not convert VtValue to array<Transform>");
316 return VtValue(value);
321 const GfVec2f convertedValue(value.
x, value.
y);
322 return VtValue(convertedValue);
327 const GfVec3f convertedValue(value.
x, value.
y, value.
z);
328 return VtValue(convertedValue);
333 return VtValue(value.string());
338 return GfMatrix4f(matrix[0][0],
361 template<
typename SrcType,
typename DstType = SrcType>
364 static_assert(
sizeof(DstType) ==
sizeof(SrcType),
365 "Size mismatch between VtArray and array base type");
367 VtArray<DstType> convertedValue;
368 convertedValue.resize(value.
size());
369 std::memcpy(convertedValue.data(), value.
data(), value.
size() *
sizeof(SrcType));
370 return VtValue(convertedValue);
375 VtVec3fArray convertedValue;
376 convertedValue.reserve(value.
size());
377 for (
const auto &
element : value) {
380 return VtValue(convertedValue);
385 VtStringArray convertedValue;
386 convertedValue.reserve(value.
size());
387 for (
const auto &
element : value) {
388 convertedValue.push_back(
element.string());
390 return VtValue(convertedValue);
395 VtMatrix4fArray convertedValue;
396 convertedValue.reserve(value.
size());
397 for (
const auto &
element : value) {
400 return VtValue(convertedValue);
407 switch (socket.
type) {
410 TF_RUNTIME_ERROR(
"Unexpected conversion: SocketType::UNDEFINED");
414 node->set(socket, convertToCycles<bool>(value));
417 node->set(socket, convertToCycles<float>(value));
420 node->set(socket, convertToCycles<int>(value));
423 node->set(socket, convertToCycles<unsigned int>(value));
442 if (value.IsHolding<TfToken>() || value.IsHolding<std::string>()) {
446 node->set(socket, convertToCycles<int>(value));
454 TF_WARN(
"Unimplemented conversion: SocketType::NODE");
458 auto cyclesArray = convertToCyclesArray<bool>(value);
459 node->set(socket, cyclesArray);
463 auto cyclesArray = convertToCyclesArray<float>(value);
464 node->set(socket, cyclesArray);
468 auto cyclesArray = convertToCyclesArray<int>(value);
469 node->set(socket, cyclesArray);
477 node->set(socket, cyclesArray);
481 auto cyclesArray = convertToCyclesArray<float2, GfVec2f>(value);
482 node->set(socket, cyclesArray);
487 node->set(socket, cyclesArray);
492 node->set(socket, cyclesArray);
497 TF_WARN(
"Unimplemented conversion: SocketType::NODE_ARRAY");
505 switch (socket.
type) {
508 TF_RUNTIME_ERROR(
"Unexpected conversion: SocketType::UNDEFINED");
535 TF_WARN(
"Unimplemented conversion: SocketType::NODE");
550 return convertFromCyclesArray<float2, GfVec2f>(
node->get_float2_array(socket));
556 TF_WARN(
"Unimplemented conversion: SocketType::NODE_ARRAY");
_GL_VOID GLfloat value _GL_VOID_RET _GL_VOID const GLuint GLboolean *residences _GL_BOOL_RET _GL_VOID GLsizei GLfloat GLfloat GLfloat GLfloat const GLubyte *bitmap _GL_VOID_RET _GL_VOID GLenum type
ATTR_WARN_UNUSED_RESULT const void * element
T * resize(size_t newsize)
void reserve(size_t newcapacity)
#define HDCYCLES_NAMESPACE_CLOSE_SCOPE
ccl_device_inline float3 zero_float3()
VtValue convertFromCyclesArray< Transform, void >(const array< Transform > &value)
array< DstType > convertToCyclesArray(const VtValue &value)
VtValue convertFromCycles< float3 >(const float3 &value)
ustring convertToCycles< ustring >(const VtValue &value)
Transform convertToCycles< Transform >(const VtValue &value)
array< Transform > convertToCyclesArray< Transform, void >(const VtValue &value)
VtValue convertFromCycles< ustring >(const ustring &value)
VtValue convertFromCycles< float2 >(const float2 &value)
float3 convertToCycles< float3 >(const VtValue &value)
float2 convertToCycles< float2 >(const VtValue &value)
GfMatrix4f convertMatrixFromCycles(const Transform &matrix)
VtValue convertFromCycles< Transform >(const Transform &value)
VtValue convertFromCycles(const SrcType &value)
array< ustring > convertToCyclesArray< ustring, void >(const VtValue &value)
VtValue convertFromCyclesArray< float3, GfVec3f >(const array< float3 > &value)
VtValue convertFromCyclesArray(const array< SrcType > &value)
Transform convertMatrixToCycles(const typename std::enable_if< Matrix::numRows==4 &&Matrix::numColumns==4, Matrix >::type &matrix)
VtValue convertFromCyclesArray< ustring, void >(const array< ustring > &value)
array< Transform > convertToCyclesTransformArray(const VtValue &value)
array< float3 > convertToCyclesArray< float3, GfVec3f >(const VtValue &value)
DstType convertToCycles(const VtValue &value)
void SetNodeValue(Node *node, const SocketType &socket, const VtValue &value)
VtValue GetNodeValue(const Node *node, const SocketType &socket)