9#include <pxr/base/gf/matrix3d.h>
10#include <pxr/base/gf/matrix3f.h>
11#include <pxr/base/gf/matrix4d.h>
12#include <pxr/base/gf/matrix4f.h>
13#include <pxr/base/gf/vec2f.h>
14#include <pxr/base/gf/vec3f.h>
15#include <pxr/base/vt/array.h>
16#include <pxr/usd/sdf/assetPath.h>
24 if (value.IsHolding<DstType>()) {
25 return value.UncheckedGet<DstType>();
28 const VtValue castedValue = VtValue::Cast<DstType>(value);
29 if (castedValue.IsHolding<DstType>()) {
30 return castedValue.UncheckedGet<DstType>();
33 TF_WARN(
"Could not convert VtValue to Cycles type");
40 return make_float2(convertedValue[0], convertedValue[1]);
45 if (value.IsHolding<GfVec3f>()) {
46 const GfVec3f convertedValue = value.UncheckedGet<GfVec3f>();
47 return make_float3(convertedValue[0], convertedValue[1], convertedValue[2]);
49 if (value.IsHolding<GfVec4f>()) {
50 const GfVec4f convertedValue = value.UncheckedGet<GfVec4f>();
51 return make_float3(convertedValue[0], convertedValue[1], convertedValue[2]);
54 if (value.CanCast<GfVec3f>()) {
55 const GfVec3f convertedValue = VtValue::Cast<GfVec3f>(value).UncheckedGet<GfVec3f>();
56 return make_float3(convertedValue[0], convertedValue[1], convertedValue[2]);
58 if (value.CanCast<GfVec4f>()) {
59 const GfVec4f convertedValue = VtValue::Cast<GfVec4f>(value).UncheckedGet<GfVec4f>();
60 return make_float3(convertedValue[0], convertedValue[1], convertedValue[2]);
63 TF_WARN(
"Could not convert VtValue to float3");
69 if (value.IsHolding<TfToken>()) {
70 return ustring(value.UncheckedGet<TfToken>().GetString());
72 if (value.IsHolding<std::string>()) {
73 return ustring(value.UncheckedGet<std::string>());
75 if (value.IsHolding<SdfAssetPath>()) {
76 const SdfAssetPath &path = value.UncheckedGet<SdfAssetPath>();
77 return ustring(path.GetResolvedPath());
80 if (value.CanCast<TfToken>()) {
83 if (value.CanCast<std::string>()) {
86 if (value.CanCast<SdfAssetPath>()) {
90 TF_WARN(
"Could not convert VtValue to ustring");
94template<
typename Matrix>
96 const typename std::enable_if<Matrix::numRows == 3 && Matrix::numColumns == 3, Matrix>::type
113template<
typename Matrix>
115 const typename std::enable_if<Matrix::numRows == 4 && Matrix::numColumns == 4, Matrix>::type
134 if (value.IsHolding<GfMatrix4f>()) {
137 if (value.IsHolding<GfMatrix3f>()) {
140 if (value.IsHolding<GfMatrix4d>()) {
143 if (value.IsHolding<GfMatrix3d>()) {
147 if (value.CanCast<GfMatrix4f>()) {
150 if (value.CanCast<GfMatrix3f>()) {
153 if (value.CanCast<GfMatrix4d>()) {
156 if (value.CanCast<GfMatrix3d>()) {
160 TF_WARN(
"Could not convert VtValue to Transform");
164template<
typename DstType,
typename SrcType = DstType>
167 static_assert(
sizeof(DstType) ==
sizeof(SrcType),
168 "Size mismatch between VtArray and array base type");
170 using SrcArray = VtArray<SrcType>;
172 if (value.IsHolding<SrcArray>()) {
173 const auto &valueData = value.UncheckedGet<SrcArray>();
175 cyclesArray.
resize(valueData.size());
176 std::memcpy(cyclesArray.data(), valueData.data(), valueData.size() *
sizeof(DstType));
180 if (value.CanCast<SrcArray>()) {
181 const VtValue castedValue = VtValue::Cast<SrcArray>(value);
182 const auto &valueData = castedValue.UncheckedGet<SrcArray>();
184 cyclesArray.
resize(valueData.size());
185 std::memcpy(cyclesArray.data(), valueData.data(), valueData.size() *
sizeof(DstType));
192template<>
array<packed_float3> convertToCyclesArray<packed_float3, GfVec3f>(
const VtValue &value)
194 if (value.IsHolding<VtVec3fArray>()) {
195 const auto &valueData = value.UncheckedGet<VtVec3fArray>();
197 cyclesArray.
reserve(valueData.size());
198 for (
const GfVec3f &vec : valueData) {
199 cyclesArray.push_back_reserved(
make_float3(vec[0], vec[1], vec[2]));
203 if (value.IsHolding<VtVec4fArray>()) {
204 const auto &valueData = value.UncheckedGet<VtVec4fArray>();
206 cyclesArray.
reserve(valueData.size());
207 for (
const GfVec4f &vec : valueData) {
208 cyclesArray.push_back_reserved(
make_float3(vec[0], vec[1], vec[2]));
213 if (value.CanCast<VtVec3fArray>()) {
214 return convertToCyclesArray<packed_float3, GfVec3f>(VtValue::Cast<VtVec3fArray>(value));
216 if (value.CanCast<VtVec4fArray>()) {
217 return convertToCyclesArray<packed_float3, GfVec3f>(VtValue::Cast<VtVec4fArray>(value));
223template<>
array<ustring> convertToCyclesArray<ustring, void>(
const VtValue &value)
225 using SdfPathArray = VtArray<SdfAssetPath>;
227 if (value.IsHolding<VtStringArray>()) {
228 const auto &valueData = value.UncheckedGet<VtStringArray>();
230 cyclesArray.
reserve(valueData.size());
231 for (
const auto &element : valueData) {
232 cyclesArray.push_back_reserved(ustring(element));
236 if (value.IsHolding<VtTokenArray>()) {
237 const auto &valueData = value.UncheckedGet<VtTokenArray>();
239 cyclesArray.
reserve(valueData.size());
240 for (
const auto &element : valueData) {
241 cyclesArray.push_back_reserved(ustring(
element.GetString()));
245 if (value.IsHolding<SdfPathArray>()) {
246 const auto &valueData = value.UncheckedGet<SdfPathArray>();
248 cyclesArray.
reserve(valueData.size());
249 for (
const auto &element : valueData) {
250 cyclesArray.push_back_reserved(ustring(
element.GetResolvedPath()));
255 if (value.CanCast<VtStringArray>()) {
256 return convertToCyclesArray<ustring, void>(VtValue::Cast<VtStringArray>(value));
258 if (value.CanCast<VtTokenArray>()) {
259 return convertToCyclesArray<ustring, void>(VtValue::Cast<VtTokenArray>(value));
261 if (value.CanCast<SdfPathArray>()) {
262 return convertToCyclesArray<ustring, void>(VtValue::Cast<SdfPathArray>(value));
265 TF_WARN(
"Could not convert VtValue to array<ustring>");
271 assert(value.IsHolding<MatrixArray>());
273 const auto &valueData = value.UncheckedGet<MatrixArray>();
275 cyclesArray.
reserve(valueData.size());
276 for (
const auto &element : valueData) {
277 cyclesArray.push_back_reserved(
283template<>
array<Transform> convertToCyclesArray<Transform, void>(
const VtValue &value)
285 if (value.IsHolding<VtMatrix4fArray>()) {
286 return convertToCyclesTransformArray<VtMatrix4fArray>(value);
288 if (value.IsHolding<VtMatrix3fArray>()) {
289 return convertToCyclesTransformArray<VtMatrix3fArray>(value);
291 if (value.IsHolding<VtMatrix4dArray>()) {
292 return convertToCyclesTransformArray<VtMatrix4dArray>(value);
294 if (value.IsHolding<VtMatrix3dArray>()) {
295 return convertToCyclesTransformArray<VtMatrix3dArray>(value);
298 if (value.CanCast<VtMatrix4fArray>()) {
299 return convertToCyclesTransformArray<VtMatrix4fArray>(VtValue::Cast<VtMatrix4fArray>(value));
301 if (value.CanCast<VtMatrix3fArray>()) {
302 return convertToCyclesTransformArray<VtMatrix3fArray>(VtValue::Cast<VtMatrix3fArray>(value));
304 if (value.CanCast<VtMatrix4dArray>()) {
305 return convertToCyclesTransformArray<VtMatrix4dArray>(VtValue::Cast<VtMatrix4dArray>(value));
307 if (value.CanCast<VtMatrix3dArray>()) {
308 return convertToCyclesTransformArray<VtMatrix3dArray>(VtValue::Cast<VtMatrix3dArray>(value));
311 TF_WARN(
"Could not convert VtValue to array<Transform>");
317 return VtValue(value);
322 const GfVec2f convertedValue(value.
x, value.
y);
323 return VtValue(convertedValue);
328 const GfVec3f convertedValue(value.
x, value.
y, value.
z);
329 return VtValue(convertedValue);
334 return VtValue(value.string());
339 return GfMatrix4f(matrix[0][0],
362template<
typename SrcType,
typename DstType = SrcType>
365 static_assert(
sizeof(DstType) ==
sizeof(SrcType),
366 "Size mismatch between VtArray and array base type");
368 VtArray<DstType> convertedValue;
369 convertedValue.resize(value.
size());
370 std::memcpy(convertedValue.data(), value.
data(), value.
size() *
sizeof(SrcType));
371 return VtValue(convertedValue);
376 VtVec2fArray convertedValue;
377 convertedValue.reserve(value.
size());
378 for (
const auto &element : value) {
379 convertedValue.push_back(GfVec2f(element.x, element.y));
381 return VtValue(convertedValue);
387 VtVec3fArray convertedValue;
388 convertedValue.reserve(value.
size());
389 for (
const auto &element : value) {
390 convertedValue.push_back(GfVec3f(element.x, element.y, element.z));
392 return VtValue(convertedValue);
397 VtStringArray convertedValue;
398 convertedValue.reserve(value.
size());
399 for (
const auto &element : value) {
400 convertedValue.push_back(element.string());
402 return VtValue(convertedValue);
407 VtMatrix4fArray convertedValue;
408 convertedValue.reserve(value.
size());
409 for (
const auto &element : value) {
412 return VtValue(convertedValue);
419 switch (socket.
type) {
422 TF_RUNTIME_ERROR(
"Unexpected conversion: SocketType::UNDEFINED");
426 node->set(socket, convertToCycles<bool>(value));
429 node->set(socket, convertToCycles<float>(value));
432 node->set(socket, convertToCycles<int>(value));
435 node->set(socket, convertToCycles<unsigned int>(value));
441 node->set(socket, convertToCycles<float3>(value));
444 node->set(socket, convertToCycles<float2>(value));
450 node->set(socket, convertToCycles<ustring>(value));
454 if (value.IsHolding<TfToken>() || value.IsHolding<std::string>()) {
455 node->set(socket, convertToCycles<ustring>(value));
458 node->set(socket, convertToCycles<int>(value));
462 node->set(socket, convertToCycles<Transform>(value));
466 TF_WARN(
"Unimplemented conversion: SocketType::NODE");
470 auto cyclesArray = convertToCyclesArray<bool>(value);
471 node->set(socket, cyclesArray);
475 auto cyclesArray = convertToCyclesArray<float>(value);
476 node->set(socket, cyclesArray);
480 auto cyclesArray = convertToCyclesArray<int>(value);
481 node->set(socket, cyclesArray);
488 auto cyclesArray = convertToCyclesArray<packed_float3, GfVec3f>(value);
489 node->set(socket, cyclesArray);
493 auto cyclesArray = convertToCyclesArray<float2, GfVec2f>(value);
494 node->set(socket, cyclesArray);
498 auto cyclesArray = convertToCyclesArray<ustring, void>(value);
499 node->set(socket, cyclesArray);
503 auto cyclesArray = convertToCyclesArray<Transform, void>(value);
504 node->set(socket, cyclesArray);
509 TF_WARN(
"Unimplemented conversion: SocketType::NODE_ARRAY");
517 switch (socket.
type) {
520 TF_RUNTIME_ERROR(
"Unexpected conversion: SocketType::UNDEFINED");
524 return convertFromCycles(
node->get_bool(socket));
526 return convertFromCycles(
node->get_float(socket));
528 return convertFromCycles(
node->get_int(socket));
530 return convertFromCycles(
node->get_uint(socket));
535 return convertFromCycles(
node->get_float3(socket));
537 return convertFromCycles(
node->get_float2(socket));
541 return convertFromCycles(
node->get_string(socket));
543 return convertFromCycles(
node->get_int(socket));
545 return convertFromCycles(
node->get_transform(socket));
547 TF_WARN(
"Unimplemented conversion: SocketType::NODE");
551 return convertFromCyclesArray(
node->get_bool_array(socket));
553 return convertFromCyclesArray(
node->get_float_array(socket));
555 return convertFromCyclesArray(
node->get_int_array(socket));
560 return convertFromCyclesArray<packed_float3, GfVec3f>(
node->get_float3_array(socket));
562 return convertFromCyclesArray<float2, GfVec2f>(
node->get_float2_array(socket));
564 return convertFromCyclesArray<ustring, void>(
node->get_string_array(socket));
566 return convertFromCyclesArray<Transform, void>(
node->get_transform_array(socket));
568 TF_WARN(
"Unimplemented conversion: SocketType::NODE_ARRAY");
void reserve(const size_t newcapacity)
T * resize(const size_t newsize)
#define assert(assertion)
#define HDCYCLES_NAMESPACE_CLOSE_SCOPE
CCL_NAMESPACE_BEGIN ccl_device_inline float3 zero_float3()
array< DstType > convertToCyclesArray(const VtValue &value)
array< Transform > convertToCyclesTransformArray(const VtValue &value)
GfMatrix4f convertMatrixFromCycles(const Transform &matrix)
VtValue convertFromCycles(const SrcType &value)
VtValue convertFromCyclesArray(const array< SrcType > &value)
Transform convertMatrixToCycles(const typename std::enable_if< Matrix::numRows==3 &&Matrix::numColumns==3, Matrix >::type &matrix)
DstType convertToCycles(const VtValue &value)
ATTR_WARN_UNUSED_RESULT const void * element
void SetNodeValue(Node *node, const SocketType &socket, const VtValue &value)
VtValue GetNodeValue(const Node *node, const SocketType &socket)