From 500aded8cdd041d73515e6576b87f4ff6fe51e26 Mon Sep 17 00:00:00 2001 From: teachmain Date: Fri, 19 Apr 2024 15:50:57 +0800 Subject: [PATCH 01/22] update --- zenovis/xinxinoptix/DisneyBSDF.h | 54 +++++++++++++++++--------------- 1 file changed, 28 insertions(+), 26 deletions(-) diff --git a/zenovis/xinxinoptix/DisneyBSDF.h b/zenovis/xinxinoptix/DisneyBSDF.h index 12766a4a99..e0803d465c 100644 --- a/zenovis/xinxinoptix/DisneyBSDF.h +++ b/zenovis/xinxinoptix/DisneyBSDF.h @@ -407,17 +407,18 @@ namespace DisneyBSDF{ f = f + h; return f * abs(wi.z); } - if(diffPr > 0.0 && reflect) - { + if(reflect){ + + if(diffPr > 0.0f){ vec3 d = BRDFBasics::EvalDisneyDiffuse(thin? mat.basecolor : mix(mat.basecolor,mat.sssColor,mat.subsurface), mat.subsurface, mat.roughness, mat.sheen, Csheen, wo, wi, wm, tmpPdf) * dielectricWt; dterm = dterm + d; f = f + d; fPdf += tmpPdf * diffPr ; - } - if(dielectricPr>0.0 && reflect) - { + } + + if(dielectricPr > 0.0f){ float F = BRDFBasics::SchlickDielectic(abs(dot(wm, wo)), mat.ior); float ax, ay; BRDFBasics::CalculateAnisotropicParams(mat.roughness,mat.anisotropic,ax,ay); @@ -427,9 +428,9 @@ namespace DisneyBSDF{ sterm = sterm + s; f = f + s; fPdf += tmpPdf * dielectricPr; - } - if(metalPr>0.0 && reflect) - { + } + + if(metalPr>0.0f){ vec3 F = mix(mix(mat.basecolor, mat.diffractColor, mat.diffraction), vec3(1.0), BRDFBasics::SchlickWeight(HoV)); float ax, ay; BRDFBasics::CalculateAnisotropicParams(mat.roughness,mat.anisotropic,ax,ay); @@ -439,12 +440,28 @@ namespace DisneyBSDF{ sterm = sterm + s; f = f + s; fPdf += tmpPdf * metalPr; + } + + if(clearCtPr>0.0f){ + vec3 wm = normalize(wi + wo); + float ax, ay; + BRDFBasics::CalculateAnisotropicParams(mat.clearcoatRoughness,0,ax,ay); + //ior related clearCt + float F = BRDFBasics::SchlickDielectic(abs(dot(wm, wo)), mat.clearcoatIOR); + vec3 s = mix(vec3(0.04f), vec3(1.0f), F) * + BRDFBasics::EvalClearcoat(mat.clearcoatRoughness, wo, wi, + wm, tmpPdf) * 0.25 * mat.clearcoat; + sterm = sterm + s; + f = f + s; + fPdf += tmpPdf * clearCtPr; + } + } - if(glassPr>0.0) + + if(glassPr>0.0f) { bool entering = wo.z>0?true:false; - //float F = BRDFBasics::DielectricFresnel(, eta); float ax, ay; BRDFBasics::CalculateAnisotropicParams(mat.roughness,mat.anisotropic,ax,ay); if (reflect) { @@ -490,22 +507,7 @@ namespace DisneyBSDF{ } } - if(clearCtPr>0.0 && reflect) - { - vec3 wm = normalize(wi + wo); - float ax, ay; - BRDFBasics::CalculateAnisotropicParams(mat.clearcoatRoughness,0,ax,ay); - //ior related clearCt - float F = BRDFBasics::SchlickDielectic(abs(dot(wm, wo)), mat.clearcoatIOR); - vec3 s = mix(vec3(0.04f), vec3(1.0f), F) * - BRDFBasics::EvalClearcoat(mat.clearcoatRoughness, wo, wi, - wm, tmpPdf) * 0.25 * mat.clearcoat; - sterm = sterm + s; - f = f + s; - fPdf += tmpPdf * clearCtPr; - } - if((sssPr>0.0&&reflectance) || (sssPr>0.0 && dot(wo, N2)<0.0) || (sssPr>0.0 && (thin))) - { + if(sssPr > 0.0f && (reflectance || dot(wo,N2) < 0.0f || thin)){ bool trans = (dot(wi, N2) * dot(wo, N2)<0) && (wi.z * wo.z<0); float FL = BRDFBasics::SchlickWeight(abs(wi.z)); float FV = BRDFBasics::SchlickWeight(abs(wo.z)); From 969c8c1541f503a498925991daef55fa4b3ea61c Mon Sep 17 00:00:00 2001 From: teachmain Date: Fri, 19 Apr 2024 18:34:27 +0800 Subject: [PATCH 02/22] fix inner reflection problem --- zenovis/xinxinoptix/DeflMatShader.cu | 11 +---------- zenovis/xinxinoptix/DisneyBRDF.h | 2 +- 2 files changed, 2 insertions(+), 11 deletions(-) diff --git a/zenovis/xinxinoptix/DeflMatShader.cu b/zenovis/xinxinoptix/DeflMatShader.cu index b79153f4f0..9a0b7940f1 100644 --- a/zenovis/xinxinoptix/DeflMatShader.cu +++ b/zenovis/xinxinoptix/DeflMatShader.cu @@ -921,16 +921,7 @@ extern "C" __global__ void __closesthit__radiance() prd->direction = normalize(wi); - if(mats.thin<0.5f && mats.doubleSide<0.5f){ - //auto p_prim = vec3(prd->origin) + optixGetRayTmax() * vec3(prd->direction); - //float3 p = p_prim; - prd->origin = next_ray_is_going_inside? backPos : frontPos; - } - else { - //auto p_prim = vec3(prd->origin) + optixGetRayTmax() * vec3(prd->direction); - //float3 p = p_prim; - prd->origin = dot(prd->direction, prd->geometryNormal) < 0? backPos : frontPos; - } + prd->origin = dot(prd->direction, prd->geometryNormal) < 0? backPos : frontPos; if (prd->medium != DisneyBSDF::vacuum) { prd->_mask_ = (uint8_t)(EverythingMask ^ VolumeMatMask); diff --git a/zenovis/xinxinoptix/DisneyBRDF.h b/zenovis/xinxinoptix/DisneyBRDF.h index 14581596b2..709dc54f15 100644 --- a/zenovis/xinxinoptix/DisneyBRDF.h +++ b/zenovis/xinxinoptix/DisneyBRDF.h @@ -318,7 +318,7 @@ float DielectricFresnel(float cosThetaI, float eta) float eta2 = eta * eta; float cos2t = 1.0f - sin2 / eta2; - if(cos2t < 0) return 1.0f; + if(cos2t < 0.0f) return 1.0f; float t0 = sqrt(cos2t); float t1 = eta * t0; From 95503c60451917377d4e7b40dbe0ae2ce7c2a8fb Mon Sep 17 00:00:00 2001 From: teachmain Date: Sun, 28 Apr 2024 16:50:17 +0800 Subject: [PATCH 03/22] double surface by default --- zenovis/xinxinoptix/DeflMatShader.cu | 19 ++-- zenovis/xinxinoptix/DisneyBSDF.h | 146 +++++++++++++-------------- zenovis/xinxinoptix/Light.h | 2 +- zenovis/xinxinoptix/TraceStuff.h | 1 + 4 files changed, 80 insertions(+), 88 deletions(-) diff --git a/zenovis/xinxinoptix/DeflMatShader.cu b/zenovis/xinxinoptix/DeflMatShader.cu index 9a0b7940f1..0beb82ba96 100644 --- a/zenovis/xinxinoptix/DeflMatShader.cu +++ b/zenovis/xinxinoptix/DeflMatShader.cu @@ -884,18 +884,18 @@ extern "C" __global__ void __closesthit__radiance() float3 frontPos, backPos; SelfIntersectionAvoidance::offsetSpawnPoint( frontPos, backPos, wldPos, prd->geometryNormal, wldOffset ); - shadowPRD.origin = dot(-ray_dir, wldNorm) > 0 ? frontPos : backPos; + shadowPRD.origin = dot(wi, vec3(wldNorm)) > 0 ? frontPos : backPos; //auto shadingP = rtgems::offset_ray(shadowPRD.origin + params.cam.eye, prd->geometryNormal); // world space - shadowPRD.origin = frontPos; - if(mats.subsurface>0 && (mats.thin>0.5 || mats.doubleSide>0.5) && istransmission){ - shadowPRD.origin = backPos; //rtgems::offset_ray(P, -prd->geometryNormal); - } + //shadowPRD.origin = frontPos; + //if(mats.subsurface>0 && (mats.thin>0.5 || mats.doubleSide>0.5) && istransmission){ + //shadowPRD.origin = backPos; //rtgems::offset_ray(P, -prd->geometryNormal); + //} - auto shadingP = rtgems::offset_ray(P + params.cam.eye, prd->geometryNormal); // world space - if(mats.subsurface>0 && (mats.thin>0.5 || mats.doubleSide>0.5) && istransmission){ - shadingP = rtgems::offset_ray(P + params.cam.eye, -prd->geometryNormal); - } + auto shadingP = rtgems::offset_ray(P + params.cam.eye, dot(wi, vec3(wldNorm)) > 0 ? wldNorm:-wldNorm); // world space + //if(mats.subsurface>0 && (mats.thin>0.5 || mats.doubleSide>0.5) && istransmission){ + //shadingP = rtgems::offset_ray(P + params.cam.eye, -prd->geometryNormal); + //} prd->radiance = {}; prd->direction = normalize(wi); @@ -909,6 +909,7 @@ extern "C" __global__ void __closesthit__radiance() } prd->lightmask = DefaultMatMask; + shadowPRD.ShadowNormal = dot(wi, vec3(prd->geometryNormal)) > 0 ? prd->geometryNormal:-prd->geometryNormal; DirectLighting(prd, shadowPRD, shadingP, ray_dir, evalBxDF, &taskAux, dummy_prt); if(mats.shadowReceiver > 0.5f) { diff --git a/zenovis/xinxinoptix/DisneyBSDF.h b/zenovis/xinxinoptix/DisneyBSDF.h index e0803d465c..678e2ec9bd 100644 --- a/zenovis/xinxinoptix/DisneyBSDF.h +++ b/zenovis/xinxinoptix/DisneyBSDF.h @@ -306,6 +306,27 @@ namespace DisneyBSDF{ return result; } + static __inline__ __device__ + vec3 EvaluateDiffuse(vec3 baseColor, float subsurface, float roughness, float sheen, vec3 Csheen, vec3 V, vec3 L, vec3 H, float &pdf){ + pdf = 0.0f; + if (L.z == 0.0f) + return vec3(0.0f); + + float LDotH = abs(dot(L, H)); + float F90 = 0.5f + 2.0f * LDotH * LDotH * roughness; + // Diffuse + float FL = BRDFBasics::SchlickWeight(abs(L.z)); + float FV = BRDFBasics::SchlickWeight(abs(V.z)); + float Fd = mix(1.0f,F90,FL) * mix(1.0f,F90,FV); + + + // Sheen + float FH = BRDFBasics::SchlickWeight(LDotH); + vec3 Fsheen = FH * sheen * Csheen; + + pdf =abs (L.z) * 1.0f / M_PIf; + return 1.0f / M_PIf * baseColor * (Fd + Fsheen); + } static __inline__ __device__ float3 EvaluateDisney2( @@ -351,7 +372,6 @@ namespace DisneyBSDF{ wm = wm.z<0.0f?-wm:wm; BRDFBasics::TintColors(mix(mat.basecolor, mat.sssColor, mat.subsurface), eta, mat.specularTint, mat.sheenTint, F0, Csheen, Cspec0); - Cspec0 = Cspec0; //material layer mix weight float dielectricWt = (1.0 - mat.metallic) * (1.0 - mat.specTrans); float metalWt = mat.metallic; @@ -411,8 +431,8 @@ namespace DisneyBSDF{ if(reflect){ if(diffPr > 0.0f){ - vec3 d = BRDFBasics::EvalDisneyDiffuse(thin? mat.basecolor : mix(mat.basecolor,mat.sssColor,mat.subsurface), mat.subsurface, mat.roughness, mat.sheen, - Csheen, wo, wi, wm, tmpPdf) * dielectricWt; + vec3 d = EvaluateDiffuse(thin? mat.basecolor : mix(mat.basecolor,mat.sssColor,mat.subsurface), mat.subsurface, mat.roughness, mat.sheen,Csheen, wo, wi, wm, tmpPdf) * dielectricWt; + //vec3 d = BRDFBasics::EvalDisneyDiffuse(thin? mat.basecolor : mix(mat.basecolor,mat.sssColor,mat.subsurface), mat.subsurface, mat.roughness, mat.sheen,Csheen, wo, wi, wm, tmpPdf) * dielectricWt; dterm = dterm + d; f = f + d; fPdf += tmpPdf * diffPr ; @@ -556,6 +576,16 @@ namespace DisneyBSDF{ return 1.0f / ( n * n) - (1.0f - c * c); } + static __inline__ __device__ + void SampleSpecular(vec3 wo, vec3& wi, float rough, float aniso, float r1, float r2){ + float ax, ay; + BRDFBasics::CalculateAnisotropicParams(rough,aniso,ax,ay); + vec3 vtmp = wo; + vtmp.z = abs(vtmp.z); + vec3 wm = BRDFBasics::SampleGGXVNDF(vtmp, ax, ay, r1, r2); + + wi = normalize(reflect(-wo, wm)); + } static __inline__ __device__ @@ -684,10 +714,6 @@ namespace DisneyBSDF{ isSS = false; tbn.inverse_transform(wi); wi = normalize(wi); - - if (dot(wi, N2) < 0) { - wi = normalize(wi - 1.01f * dot(wi, N2) * N2); - } } else{ //switch between scattering or diffuse reflection @@ -696,17 +722,14 @@ namespace DisneyBSDF{ { prd->fromDiff = true; wi = BRDFBasics::CosineSampleHemisphere(r1, r2); + if(wo.z<0.0f){ + wi.z = -wi.z; + } isSS = false; tbn.inverse_transform(wi); wi = normalize(wi); - - if(dot(wi, N2)<0) - { - wi = normalize(wi - 1.01f * dot(wi, N2) * N2); - } }else { - //go inside wi = -BRDFBasics::UniformSampleHemisphere(r1, r2); wi.z = min(-0.2f, wi.z); @@ -725,11 +748,6 @@ namespace DisneyBSDF{ tbn.inverse_transform(wi); wi = normalize(wi); - bool sameside2 = (dot(wi, N) * dot(wi, N2)) > 0.0f; - if (sameside == false) { - wi = normalize(wi - 1.01f * dot(wi, N2) * N2); - } - } } @@ -745,62 +763,45 @@ namespace DisneyBSDF{ else if(r3hit_type = SPECULAR_HIT; - float ax, ay; - BRDFBasics::CalculateAnisotropicParams(mat.roughness,mat.anisotropic,ax,ay); - - vec3 vtmp = wo; - vtmp.z = wo.z>0?vtmp.z:-vtmp.z; - vec3 wm = BRDFBasics::SampleGGXVNDF(vtmp, ax, ay, r1, r2); - - if (wm.z < 0.0) - wm.z = -wm.z; - - wm.z = wo.z>0? wm.z:-wm.z; - - wi = normalize(reflect(-wo, wm)); + SampleSpecular(wo,wi,mat.roughness,mat.anisotropic,r1,r2); tbn.inverse_transform(wi); wi = normalize(wi); - if(dot(wi, N2)<0) - { - wi = normalize(wi - 1.01f * dot(wi, N2) * N2); - } }else if(r30?true:false; - float ax, ay; - BRDFBasics::CalculateAnisotropicParams(mat.roughness,mat.anisotropic,ax,ay); - vec3 swo = wo.z>0?wo:-wo; - vec3 wm = BRDFBasics::SampleGGXVNDF(swo, ax, ay, r1, r2); - wm = wm.z<0?-wm:wm; - - wm = entering?wm:-wm; - - float F = BRDFBasics::DielectricFresnel(abs(dot(wm, wo)), entering?mat.ior:1.0f/mat.ior); - float p = rnd(seed); - if(p0?true:false; + float ax, ay; + BRDFBasics::CalculateAnisotropicParams(mat.roughness,mat.anisotropic,ax,ay); + vec3 swo = wo.z>0?wo:-wo; + vec3 wm = BRDFBasics::SampleGGXVNDF(swo, ax, ay, r1, r2); + wm = wm.z<0?-wm:wm; + + wm = entering?wm:-wm; + + float F = BRDFBasics::DielectricFresnel(abs(dot(wm, wo)), entering?mat.ior:1.0f/mat.ior); + float p = rnd(seed); + if(phit_type = SPECULAR_HIT; - float ax, ay; - BRDFBasics::CalculateAnisotropicParams(mat.clearcoatRoughness,0,ax,ay); - vec3 swo = wo.z>0?wo:-wo; - vec3 wm = BRDFBasics::SampleGGXVNDF(swo, ax, ay, r1, r2); - wm = wm.z<0?-wm:wm; - - - wi = normalize(reflect(-wo, wm)); + SampleSpecular(wo,wi,mat.clearcoatRoughness,0.0f,r1,r2); tbn.inverse_transform(wi); wi = normalize(wi); - if(dot(wi, N2)<0) - { - wi = normalize(wi - 1.01f * dot(wi, N2) * N2); - } } tbn.inverse_transform(wo); diff --git a/zenovis/xinxinoptix/Light.h b/zenovis/xinxinoptix/Light.h index 6554fe16de..fe7ea9770f 100644 --- a/zenovis/xinxinoptix/Light.h +++ b/zenovis/xinxinoptix/Light.h @@ -229,7 +229,7 @@ void DirectLighting(RadiancePRD *prd, ShadowPRD& shadowPRD, const float3& shadin UF = (UF - _SKY_PROB_) / lightPickProb; const Vector3f& SP = reinterpret_cast(shadingP); - const Vector3f& SN = reinterpret_cast(prd->geometryNormal); + const Vector3f& SN = reinterpret_cast(shadowPRD.ShadowNormal); auto pick = lightTree->sample(UF, SP, SN); if (pick.prob <= 0.0f) { return; } diff --git a/zenovis/xinxinoptix/TraceStuff.h b/zenovis/xinxinoptix/TraceStuff.h index c9adac0a91..3c5d4f475a 100644 --- a/zenovis/xinxinoptix/TraceStuff.h +++ b/zenovis/xinxinoptix/TraceStuff.h @@ -61,6 +61,7 @@ struct ShadowPRD { uint8_t nonThinTransHit; VolumePRD vol; + float3 ShadowNormal; float rndf() { return rnd(seed); From f0196f4628b1ff5f71915598fe0b01798bdc1004 Mon Sep 17 00:00:00 2001 From: teachmain Date: Mon, 29 Apr 2024 17:48:40 +0800 Subject: [PATCH 04/22] update --- zenovis/xinxinoptix/DisneyBRDF.h | 2 +- zenovis/xinxinoptix/DisneyBSDF.h | 4 ++-- 2 files changed, 3 insertions(+), 3 deletions(-) diff --git a/zenovis/xinxinoptix/DisneyBRDF.h b/zenovis/xinxinoptix/DisneyBRDF.h index 709dc54f15..f8ec3b41f6 100644 --- a/zenovis/xinxinoptix/DisneyBRDF.h +++ b/zenovis/xinxinoptix/DisneyBRDF.h @@ -415,7 +415,7 @@ vec3 EvalDisneyDiffuse(vec3 baseColor, float subsurface, float roughness, float float FH = SchlickWeight(LDotH); vec3 Fsheen = FH * sheen * Csheen; - pdf = L.z * 1.0f / M_PIf; + pdf = abs(L.z) * 1.0f / M_PIf; return 1.0f / M_PIf * baseColor * (Fd + Fretro) + Fsheen; } diff --git a/zenovis/xinxinoptix/DisneyBSDF.h b/zenovis/xinxinoptix/DisneyBSDF.h index 678e2ec9bd..99ffdad54f 100644 --- a/zenovis/xinxinoptix/DisneyBSDF.h +++ b/zenovis/xinxinoptix/DisneyBSDF.h @@ -431,8 +431,8 @@ namespace DisneyBSDF{ if(reflect){ if(diffPr > 0.0f){ - vec3 d = EvaluateDiffuse(thin? mat.basecolor : mix(mat.basecolor,mat.sssColor,mat.subsurface), mat.subsurface, mat.roughness, mat.sheen,Csheen, wo, wi, wm, tmpPdf) * dielectricWt; - //vec3 d = BRDFBasics::EvalDisneyDiffuse(thin? mat.basecolor : mix(mat.basecolor,mat.sssColor,mat.subsurface), mat.subsurface, mat.roughness, mat.sheen,Csheen, wo, wi, wm, tmpPdf) * dielectricWt; + //vec3 d = EvaluateDiffuse(thin? mat.basecolor : mix(mat.basecolor,mat.sssColor,mat.subsurface), mat.subsurface, mat.roughness, mat.sheen,Csheen, wo, wi, wm, tmpPdf) * dielectricWt; + vec3 d = BRDFBasics::EvalDisneyDiffuse(thin? mat.basecolor : mix(mat.basecolor,mat.sssColor,mat.subsurface), mat.subsurface, mat.roughness, mat.sheen,Csheen, wo, wi, wm, tmpPdf) * dielectricWt; dterm = dterm + d; f = f + d; fPdf += tmpPdf * diffPr ; From 88d8d9231bc157a538c1bd496d4f4ed3c9c16eb1 Mon Sep 17 00:00:00 2001 From: teachmain Date: Tue, 23 Jul 2024 16:42:56 +0800 Subject: [PATCH 05/22] normal fix --- zenovis/xinxinoptix/DeflMatShader.cu | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/zenovis/xinxinoptix/DeflMatShader.cu b/zenovis/xinxinoptix/DeflMatShader.cu index 0beb82ba96..bf1cbb1807 100644 --- a/zenovis/xinxinoptix/DeflMatShader.cu +++ b/zenovis/xinxinoptix/DeflMatShader.cu @@ -884,7 +884,7 @@ extern "C" __global__ void __closesthit__radiance() float3 frontPos, backPos; SelfIntersectionAvoidance::offsetSpawnPoint( frontPos, backPos, wldPos, prd->geometryNormal, wldOffset ); - shadowPRD.origin = dot(wi, vec3(wldNorm)) > 0 ? frontPos : backPos; + shadowPRD.origin = dot(wi, vec3(prd->geometryNormal)) > 0 ? frontPos : backPos; //auto shadingP = rtgems::offset_ray(shadowPRD.origin + params.cam.eye, prd->geometryNormal); // world space //shadowPRD.origin = frontPos; @@ -892,7 +892,7 @@ extern "C" __global__ void __closesthit__radiance() //shadowPRD.origin = backPos; //rtgems::offset_ray(P, -prd->geometryNormal); //} - auto shadingP = rtgems::offset_ray(P + params.cam.eye, dot(wi, vec3(wldNorm)) > 0 ? wldNorm:-wldNorm); // world space + auto shadingP = rtgems::offset_ray(P + params.cam.eye, dot(wi, vec3(prd->geometryNormal)) > 0 ? prd->geometryNormal:-prd->geometryNormal); // world space //if(mats.subsurface>0 && (mats.thin>0.5 || mats.doubleSide>0.5) && istransmission){ //shadingP = rtgems::offset_ray(P + params.cam.eye, -prd->geometryNormal); //} From aeec9de94203e71a8fb6fbfd39b99511607fba7b Mon Sep 17 00:00:00 2001 From: iaomw Date: Mon, 14 Oct 2024 19:35:33 +0800 Subject: [PATCH 06/22] fix ptr capture --- zenovis/xinxinoptix/OptiXStuff.h | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/zenovis/xinxinoptix/OptiXStuff.h b/zenovis/xinxinoptix/OptiXStuff.h index 7583c5c820..cd49b1356a 100644 --- a/zenovis/xinxinoptix/OptiXStuff.h +++ b/zenovis/xinxinoptix/OptiXStuff.h @@ -1010,7 +1010,7 @@ inline void addTexture(std::string path, bool blockCompression=false, TaskType* tex_lut[tex_key] = makeCudaTexture((unsigned char *)data.data(), nx, ny, 4, blockCompression); } - lookupTexture = [&img](uint32_t idx) { + lookupTexture = [img=img](uint32_t idx) { auto ptr = (float*)img->verts->data(); return ptr[idx]; }; From b3ebb77b21ec72e9c6fd234c1c740a22b83a6a49 Mon Sep 17 00:00:00 2001 From: teachmain Date: Wed, 16 Oct 2024 14:45:09 +0800 Subject: [PATCH 07/22] fix thin glass --- zenovis/xinxinoptix/DisneyBSDF.h | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/zenovis/xinxinoptix/DisneyBSDF.h b/zenovis/xinxinoptix/DisneyBSDF.h index 99ffdad54f..9a3ffff84b 100644 --- a/zenovis/xinxinoptix/DisneyBSDF.h +++ b/zenovis/xinxinoptix/DisneyBSDF.h @@ -499,8 +499,10 @@ namespace DisneyBSDF{ } else { if(thin) { - vec3 t = sqrt(mix(mat.transColor, mat.diffractColor, mat.diffraction)) * glassWt; + vec3 t = sqrt(mix(mat.transColor, mat.diffractColor, mat.diffraction)) * glassWt / abs(wi.z); float tmpPdf = (reflectance==false)? 0.0f:1.0f; + float F = BRDFBasics::DielectricFresnel(abs(wo.z), entering?mat.ior:1.0/mat.ior); + tmpPdf *= (1.0f-F); t = t * (tmpPdf>0.0f?1.0f:0.0f); tterm = tterm + t; f = f + t; From 84e83ca43af693be91863dcd5cfec95345ba1fc5 Mon Sep 17 00:00:00 2001 From: teachmain Date: Wed, 16 Oct 2024 14:54:37 +0800 Subject: [PATCH 08/22] Fix thin glass problem --- zenovis/xinxinoptix/DisneyBSDF.h | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/zenovis/xinxinoptix/DisneyBSDF.h b/zenovis/xinxinoptix/DisneyBSDF.h index 12766a4a99..1716320f07 100644 --- a/zenovis/xinxinoptix/DisneyBSDF.h +++ b/zenovis/xinxinoptix/DisneyBSDF.h @@ -462,8 +462,9 @@ namespace DisneyBSDF{ } else { if(thin) { - vec3 t = sqrt(mix(mat.transColor, mat.diffractColor, mat.diffraction)) * glassWt; - float tmpPdf = (reflectance==false)? 0.0f:1.0f; + vec3 t = sqrt(mix(mat.transColor, mat.diffractColor, mat.diffraction)) * glassWt / (1e-6+abs(wi.z)); + float F = BRDFBasics::DielectricFresnel(abs(wo.z), entering?mat.ior:1.0/mat.ior); + float tmpPdf = reflectance ? (1.0f-F) : 0.0f; t = t * (tmpPdf>0.0f?1.0f:0.0f); tterm = tterm + t; f = f + t; From f0a42f2b5f3e6518e9484317bacca7d9e1bd0196 Mon Sep 17 00:00:00 2001 From: teachmain Date: Wed, 16 Oct 2024 14:54:37 +0800 Subject: [PATCH 09/22] Fix thin glass problem --- zenovis/xinxinoptix/DisneyBSDF.h | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/zenovis/xinxinoptix/DisneyBSDF.h b/zenovis/xinxinoptix/DisneyBSDF.h index 12766a4a99..1716320f07 100644 --- a/zenovis/xinxinoptix/DisneyBSDF.h +++ b/zenovis/xinxinoptix/DisneyBSDF.h @@ -462,8 +462,9 @@ namespace DisneyBSDF{ } else { if(thin) { - vec3 t = sqrt(mix(mat.transColor, mat.diffractColor, mat.diffraction)) * glassWt; - float tmpPdf = (reflectance==false)? 0.0f:1.0f; + vec3 t = sqrt(mix(mat.transColor, mat.diffractColor, mat.diffraction)) * glassWt / (1e-6+abs(wi.z)); + float F = BRDFBasics::DielectricFresnel(abs(wo.z), entering?mat.ior:1.0/mat.ior); + float tmpPdf = reflectance ? (1.0f-F) : 0.0f; t = t * (tmpPdf>0.0f?1.0f:0.0f); tterm = tterm + t; f = f + t; From f66fe4b64c51234a637d85ed1572367397254b18 Mon Sep 17 00:00:00 2001 From: teachmain Date: Fri, 19 Apr 2024 18:57:21 +0800 Subject: [PATCH 10/22] inner reflection fix --- zenovis/xinxinoptix/DeflMatShader.cu | 11 +---------- 1 file changed, 1 insertion(+), 10 deletions(-) diff --git a/zenovis/xinxinoptix/DeflMatShader.cu b/zenovis/xinxinoptix/DeflMatShader.cu index c9bcb8d6d6..0e3ae2dc6f 100644 --- a/zenovis/xinxinoptix/DeflMatShader.cu +++ b/zenovis/xinxinoptix/DeflMatShader.cu @@ -1006,16 +1006,7 @@ extern "C" __global__ void __closesthit__radiance() prd->direction = normalize(wi); - if(mats.thin<0.5f && mats.doubleSide<0.5f){ - //auto p_prim = vec3(prd->origin) + optixGetRayTmax() * vec3(prd->direction); - //float3 p = p_prim; - prd->origin = next_ray_is_going_inside? backPos : frontPos; - } - else { - //auto p_prim = vec3(prd->origin) + optixGetRayTmax() * vec3(prd->direction); - //float3 p = p_prim; - prd->origin = dot(prd->direction, prd->geometryNormal) < 0? backPos : frontPos; - } + prd->origin = dot(prd->direction, prd->geometryNormal) < 0? backPos : frontPos; if (prd->medium != DisneyBSDF::vacuum) { prd->_mask_ = (uint8_t)(EverythingMask ^ VolumeMatMask); From 2b498fa51962ba85e88d2fed79ead6090b698ece Mon Sep 17 00:00:00 2001 From: teachmain Date: Fri, 19 Apr 2024 18:59:11 +0800 Subject: [PATCH 11/22] fix inner reflection --- zenovis/xinxinoptix/DeflMatShader.cu | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/zenovis/xinxinoptix/DeflMatShader.cu b/zenovis/xinxinoptix/DeflMatShader.cu index 0e3ae2dc6f..f022a5864f 100644 --- a/zenovis/xinxinoptix/DeflMatShader.cu +++ b/zenovis/xinxinoptix/DeflMatShader.cu @@ -1006,7 +1006,7 @@ extern "C" __global__ void __closesthit__radiance() prd->direction = normalize(wi); - prd->origin = dot(prd->direction, prd->geometryNormal) < 0? backPos : frontPos; + prd->origin = dot(prd->direction, prd->geometryNormal) < 0.0f ? backPos : frontPos; if (prd->medium != DisneyBSDF::vacuum) { prd->_mask_ = (uint8_t)(EverythingMask ^ VolumeMatMask); From d98bffe3d02874e375998e348c25612ff465a87e Mon Sep 17 00:00:00 2001 From: littlemine Date: Wed, 16 Oct 2024 18:31:33 +0800 Subject: [PATCH 12/22] mark island no on face as an option --- projects/CUDA/utils/Primitives.cpp | 21 ++++++++++++++++++--- 1 file changed, 18 insertions(+), 3 deletions(-) diff --git a/projects/CUDA/utils/Primitives.cpp b/projects/CUDA/utils/Primitives.cpp index 879270a4cf..05bcdfa24c 100644 --- a/projects/CUDA/utils/Primitives.cpp +++ b/projects/CUDA/utils/Primitives.cpp @@ -507,7 +507,7 @@ struct PrimitiveMarkIslands : INode { } const auto &loops = prim->loops; - const auto &polys = prim->polys; + auto &polys = prim->polys; using IV = zs::vec; zs::bht tab{(std::size_t)(polys.values.back()[0] + polys.values.back()[1])}; std::vector is, js; @@ -568,12 +568,26 @@ struct PrimitiveMarkIslands : INode { std::sort(kvs.begin(), kvs.end(), lessOp); pol(enumerate(kvs), [&invMap](int no, auto kv) { invMap[kv.second] = no; }); - auto &setids = prim->add_attr(get_input2("island_tag")); + auto islandTag = get_input2("island_tag"); + auto &setids = prim->add_attr(islandTag); pol(range(pos.size()), [&fas, &setids, &invMap, vtab = view(vtab)](int vi) mutable { auto ancestor = fas[vi]; auto setNo = vtab.query(ancestor); setids[vi] = invMap[setNo]; }); + if (get_input2("mark_face")) { + auto &faceids = polys.add_attr(islandTag); + pol(zip(polys.values, faceids), [&](const auto &poly, int &fid) { + auto offset = poly[0]; + auto vi = loops[offset]; + auto vIslandId = setids[vi]; + fid = vIslandId; + // auto size = poly[1]; + // for (int i = 1; i < size; ++i) { + // assert(setids[loops[offset + i]] == set); + // } + }); + } if (isTris) { primTriangulate(prim.get(), true, false); @@ -583,7 +597,8 @@ struct PrimitiveMarkIslands : INode { }; ZENDEFNODE(PrimitiveMarkIslands, { - {{"PrimitiveObject", "prim"}, {"string", "island_tag", "island_index"}}, + {{"PrimitiveObject", "prim"}, {"string", "island_tag", "island_index"}, + {"bool", "mark_face", "0"}}, { {"PrimitiveObject", "prim"}, }, From 4aa45bce4914fdf671f19e40f0cd8965f847854f Mon Sep 17 00:00:00 2001 From: littlemine Date: Wed, 16 Oct 2024 18:32:02 +0800 Subject: [PATCH 13/22] spg difference node --- projects/CuEulerian/CMakeLists.txt | 3 + projects/CuEulerian/volume/VolumeOps.cu | 103 ++++++++++++++++++++++++ 2 files changed, 106 insertions(+) create mode 100644 projects/CuEulerian/volume/VolumeOps.cu diff --git a/projects/CuEulerian/CMakeLists.txt b/projects/CuEulerian/CMakeLists.txt index 3aa392d77d..709f399176 100644 --- a/projects/CuEulerian/CMakeLists.txt +++ b/projects/CuEulerian/CMakeLists.txt @@ -20,6 +20,9 @@ target_sources(zeno PRIVATE volume/Conversion.cu ) ]] +target_sources(zeno PRIVATE + volume/VolumeOps.cu +) # shallow water & terrain target_sources(zeno PRIVATE diff --git a/projects/CuEulerian/volume/VolumeOps.cu b/projects/CuEulerian/volume/VolumeOps.cu new file mode 100644 index 0000000000..8a93777bf4 --- /dev/null +++ b/projects/CuEulerian/volume/VolumeOps.cu @@ -0,0 +1,103 @@ +#include "Structures.hpp" +#include "zensim/cuda/execution/ExecutionPolicy.cuh" +#include "zensim/geometry/SparseGrid.hpp" +#include "zensim/omp/execution/ExecutionPolicy.hpp" +#include "zensim/zpc_tpls/fmt/color.h" +#include "zensim/zpc_tpls/fmt/format.h" + +#include +#include +#include + +// #include + +#include "../utils.cuh" +#include "zeno/utils/log.h" + +namespace zeno { + +struct ZSSParseGridDifference : INode { + void apply() override { + using namespace zs; + auto grid = get_input("ZSGrid"); + + auto attrTag = get_input2("attrName"); + auto chnOffset = get_input2("channelOffset"); + + auto outputAttrTag = get_input2("outputAttrName"); + if (outputAttrTag.empty()) + throw std::runtime_error( + "[outputAttrName] should not be an empty string."); + + auto orientationStr = get_input2("orientation"); + int orientation = + orientationStr == "ddx" ? 0 : (orientationStr == "ddy" ? 1 : 2); + + auto boundaryStr = get_input2("boundary_type"); + int boundaryType = boundaryStr == "neumann" ? 0 : /*dirichlet*/ 1; + + auto &spg = grid->spg; + auto block_cnt = spg.numBlocks(); + auto pol = cuda_exec(); + constexpr auto space = execspace_e::cuda; + + spg.append_channels(pol, {{outputAttrTag, 1}}); + + pol(Collapse{block_cnt, spg.block_size}, + [spgv = proxy(spg), + srcOffset = spg.getPropertyOffset(attrTag) + chnOffset, orientation, + dstOffset = spg.getPropertyOffset(outputAttrTag), boundaryType, + twodx = 2 * spg.voxelSize()[0]] __device__(int blockno, + int cellno) mutable { + auto icoord = spgv.iCoord(blockno, cellno); + auto val = spgv(srcOffset, blockno, cellno); + auto iCoordA = icoord; + iCoordA[orientation]++; + auto iCoordB = icoord; + iCoordB[orientation]--; + + auto getVal = [&](const auto &coord) -> zs::f32 { + auto [bno, cno] = spgv.decomposeCoord(coord); + if (bno == spgv.sentinel_v) { + // boundary + if (boundaryType == 0) // neumann + return val; + else + return 0.f; + } else { + return spgv(srcOffset, bno, cno); + } + }; + auto tmp = (getVal(iCoordA) - getVal(iCoordB)) / twodx; +#if 0 + if (zs::abs(tmp) > 0.01) { + printf("coord (%d, %d, %d) - (%d, %d, %d) diff: %f\n", iCoordA[0], + iCoordA[1], iCoordA[2], iCoordB[0], iCoordB[1], iCoordB[2], + (float)tmp); + } +#endif + spgv(dstOffset, blockno, cellno) = tmp; + }); + + set_output("ZSGrid", grid); + } +}; + +ZENDEFNODE(ZSSParseGridDifference, + {/* inputs: */ + { + "ZSGrid", + {"string", "attrName", "sdf"}, + {"int", "channelOffset", "0"}, + {"enum ddx ddy ddz", "orientation", "ddx"}, + {"string", "outputAttrName", ""}, + {"enum neumann dirichlet", "boundary_type", "neumann"}, + }, + /* outputs: */ + {"ZSGrid"}, + /* params: */ + {}, + /* category: */ + {"Eulerian"}}); + +} // namespace zeno \ No newline at end of file From 0154820fc12c7d549c5e4f6d459fc3c55c1341d8 Mon Sep 17 00:00:00 2001 From: iaomw Date: Wed, 16 Oct 2024 20:44:42 +0800 Subject: [PATCH 14/22] Fix 4 channel png loading --- zenovis/xinxinoptix/OptiXStuff.h | 20 +++++++++----------- 1 file changed, 9 insertions(+), 11 deletions(-) diff --git a/zenovis/xinxinoptix/OptiXStuff.h b/zenovis/xinxinoptix/OptiXStuff.h index cd49b1356a..90b8ab5ae3 100644 --- a/zenovis/xinxinoptix/OptiXStuff.h +++ b/zenovis/xinxinoptix/OptiXStuff.h @@ -982,37 +982,35 @@ inline void addTexture(std::string path, bool blockCompression=false, TaskType* ny = std::max(img->userData().get2("h"), 1); nc = std::max(img->userData().get2("channels"), 1); - if (nc < 4) { + auto ucdata = std::make_shared>(img->verts.size() * nc); - std::vector ucdata; - ucdata.resize(img->verts.size() * nc); + if (nc < 4) { for(size_t i=0; iverts.size(); i+=1 ) { for (int c=0; cverts[i][c] * 255.0); + ucdata->at(i*nc+c) = (img->verts[i][c] * 255.0); } } - tex_lut[tex_key] = makeCudaTexture(ucdata.data(), nx, ny, nc, blockCompression); + tex_lut[tex_key] = makeCudaTexture(ucdata->data(), nx, ny, nc, blockCompression); } else { assert(nc == 4); - std::vector data(nx * ny); + auto data = (uchar4*)ucdata->data(); auto &alpha = img->verts.attr("alpha"); for (auto i = 0; i < nx * ny; i++) { data[i].x = (unsigned char)(img->verts[i][0]*255.0); data[i].y = (unsigned char)(img->verts[i][1]*255.0); data[i].z = (unsigned char)(img->verts[i][2]*255.0); data[i].w = (unsigned char)(alpha[i] *255.0); - } - tex_lut[tex_key] = makeCudaTexture((unsigned char *)data.data(), nx, ny, 4, blockCompression); + tex_lut[tex_key] = makeCudaTexture((unsigned char *)data, nx, ny, 4, blockCompression); } - lookupTexture = [img=img](uint32_t idx) { - auto ptr = (float*)img->verts->data(); - return ptr[idx]; + lookupTexture = [ucdata=ucdata, img=img](uint32_t idx) { + auto ptr = ucdata->data(); + return ptr[idx]/255.0; }; } else if (stbi_is_hdr(native_path.c_str())) { From d37bd003f810e17177347f5a01fc5e8004da2545 Mon Sep 17 00:00:00 2001 From: iaomw Date: Wed, 16 Oct 2024 20:50:05 +0800 Subject: [PATCH 15/22] Dither sRGB --- zenovis/xinxinoptix/PTKernel.cu | 4 ++-- zenovis/xinxinoptix/SDK/cuda/helpers.h | 19 +++++++++---------- 2 files changed, 11 insertions(+), 12 deletions(-) diff --git a/zenovis/xinxinoptix/PTKernel.cu b/zenovis/xinxinoptix/PTKernel.cu index a199625b08..14aaffbc13 100644 --- a/zenovis/xinxinoptix/PTKernel.cu +++ b/zenovis/xinxinoptix/PTKernel.cu @@ -441,8 +441,8 @@ extern "C" __global__ void __raygen__rg() auto uv = float2{idx.x+0.5f, idx.y+0.5f}; auto dither = InterleavedGradientNoise(uv); - dither = (dither-0.5f)/255; - params.frame_buffer[ image_index ] = make_color( accum_color + dither); + dither = (dither-0.5f); + params.frame_buffer[ image_index ] = makeSRGB( accum_color, 2.2f, dither); if (params.denoise) { params.albedo_buffer[ image_index ] = tmp_albedo; diff --git a/zenovis/xinxinoptix/SDK/cuda/helpers.h b/zenovis/xinxinoptix/SDK/cuda/helpers.h index b98b6bb5b1..142927e0e2 100644 --- a/zenovis/xinxinoptix/SDK/cuda/helpers.h +++ b/zenovis/xinxinoptix/SDK/cuda/helpers.h @@ -32,9 +32,9 @@ #include -__forceinline__ __device__ float3 toSRGB( const float3& c ) +__forceinline__ __device__ float3 toSRGB( const float3& c, float gamma ) { - float invGamma = 1.0f / 2.4f; + float invGamma = 1.0f / gamma; float3 powed = make_float3( powf( c.x, invGamma ), powf( c.y, invGamma ), powf( c.z, invGamma ) ); return make_float3( c.x < 0.0031308f ? 12.92f * c.x : 1.055f * powed.x - 0.055f, @@ -42,11 +42,6 @@ __forceinline__ __device__ float3 toSRGB( const float3& c ) c.z < 0.0031308f ? 12.92f * c.z : 1.055f * powed.z - 0.055f ); } -//__forceinline__ __device__ float dequantizeUnsigned8Bits( const unsigned char i ) -//{ -// enum { N = (1 << 8) - 1 }; -// return min((float)i / (float)N), 1.f) -//} __forceinline__ __device__ unsigned char quantizeUnsigned8Bits( float x ) { x = clamp( x, 0.0f, 1.0f ); @@ -54,13 +49,17 @@ __forceinline__ __device__ unsigned char quantizeUnsigned8Bits( float x ) return (unsigned char)min((unsigned int)(x * (float)Np1), (unsigned int)N); } -__forceinline__ __device__ uchar4 make_color( const float3& c ) +__forceinline__ __device__ uchar4 makeSRGB( const float3& c, float gamma=2.2f, float dither=0.0f) { // first apply gamma, then convert to unsigned char - float3 srgb = toSRGB( clamp( c, 0.0f, 1.0f ) ); + float3 srgb = toSRGB( c, gamma ); + //srgb += make_float3(dither); + srgb += make_float3(dither, 1.0-dither, dither)/255; + srgb = clamp( srgb, 0.0f, 1.0f ); + return make_uchar4( quantizeUnsigned8Bits( srgb.x ), quantizeUnsigned8Bits( srgb.y ), quantizeUnsigned8Bits( srgb.z ), 255u ); } __forceinline__ __device__ uchar4 make_color( const float4& c ) { - return make_color( make_float3( c.x, c.y, c.z ) ); + return makeSRGB( make_float3( c.x, c.y, c.z ) ); } From 484308406cfcf929fd93c9ebcdb650ff74b59449 Mon Sep 17 00:00:00 2001 From: iaomw Date: Wed, 16 Oct 2024 20:53:53 +0800 Subject: [PATCH 16/22] White Furnace --- misc/graphs/WhiteFurnace.zsg | 29449 ++++++++++++++++++++++++++++++ zenovis/xinxinoptix/Light.h | 4 +- zenovis/xinxinoptix/PTKernel.cu | 2 + 3 files changed, 29453 insertions(+), 2 deletions(-) create mode 100644 misc/graphs/WhiteFurnace.zsg diff --git a/misc/graphs/WhiteFurnace.zsg b/misc/graphs/WhiteFurnace.zsg new file mode 100644 index 0000000000..921a1603a6 --- /dev/null +++ b/misc/graphs/WhiteFurnace.zsg @@ -0,0 +1,29449 @@ +{ + "graph": { + "main": { + "type": 0, + "forkLock": false, + "nodes": { + "5cbd8e0d-ShaderFinalize": { + "name": "ShaderFinalize", + "inputs": { + "base": { + "link": null, + "type": "float", + "default-value": 1.0, + "control": { + "name": "Float" + } + }, + "basecolor": { + "link": null, + "type": "colorvec3f", + "default-value": [ + 1.0, + 1.0, + 1.0 + ], + "control": { + "name": "Color Vec3f" + } + }, + "roughness": { + "link": null, + "type": "float", + "default-value": 0.0, + "control": { + "name": "Float" + } + }, + "metallic": { + "link": null, + "type": "float", + "default-value": 1.0, + "control": { + "name": "Float" + } + }, + "metalColor": { + "link": null, + "type": "colorvec3f", + "default-value": [ + 1.0, + 1.0, + 1.0 + ], + "control": { + "name": "Color Vec3f" + } + }, + "specular": { + "link": null, + "type": "float", + "default-value": 0.0, + "control": { + "name": "Float" + } + }, + "specularTint": { + "link": null, + "type": "float", + "default-value": 0.0, + "control": { + "name": "Float" + } + }, + "anisotropic": { + "link": null, + "type": "float", + "default-value": 0.0, + "control": { + "name": "Float" + } + }, + "anisoRotation": { + "link": null, + "type": "float", + "default-value": 0.0, + "control": { + "name": "Float" + } + }, + "subsurface": { + "link": null, + "type": "float", + "default-value": 0.0, + "control": { + "name": "Float" + } + }, + "sssRadius": { + "link": null, + "type": "enum Fixed Adaptive", + "default-value": "Fixed", + "control": { + "name": "Enum", + "items": [ + "Fixed", + "Adaptive" + ] + } + }, + "sssParam": { + "link": null, + "type": "vec3f", + "default-value": [ + 1.0, + 1.0, + 1.0 + ], + "control": { + "name": "Float Vector 3" + } + }, + "sssColor": { + "link": null, + "type": "colorvec3f", + "default-value": [ + 1.0, + 1.0, + 1.0 + ], + "control": { + "name": "Color Vec3f" + } + }, + "scatterDistance": { + "link": null, + "type": "float", + "default-value": 10000.0, + "control": { + "name": "Float" + } + }, + "scatterStep": { + "link": null, + "type": "float", + "default-value": 0.0, + "control": { + "name": "Float" + } + }, + "sheen": { + "link": null, + "type": "float", + "default-value": 0.0, + "control": { + "name": "Float" + } + }, + "sheenTint": { + "link": null, + "type": "float", + "default-value": 0.0, + "control": { + "name": "Float" + } + }, + "clearcoat": { + "link": null, + "type": "float", + "default-value": 0.0, + "control": { + "name": "Float" + } + }, + "clearcoatColor": { + "link": null, + "type": "vec3f", + "default-value": [ + 1.0, + 1.0, + 1.0 + ], + "control": { + "name": "Float Vector 3" + } + }, + "clearcoatRoughness": { + "link": null, + "type": "float", + "default-value": 0.0, + "control": { + "name": "Float" + } + }, + "clearcoatIOR": { + "link": null, + "type": "float", + "default-value": 1.5, + "control": { + "name": "Float" + } + }, + "specTrans": { + "link": null, + "type": "float", + "default-value": 0.0, + "control": { + "name": "Float" + } + }, + "transColor": { + "link": null, + "type": "vec3f", + "default-value": [ + 1.0, + 1.0, + 1.0 + ], + "control": { + "name": "Float Vector 3" + } + }, + "transTint": { + "link": null, + "type": "vec3f", + "default-value": [ + 1.0, + 1.0, + 1.0 + ], + "control": { + "name": "Float Vector 3" + } + }, + "transTintDepth": { + "link": null, + "type": "float", + "default-value": 10000.0, + "control": { + "name": "Float" + } + }, + "transDistance": { + "link": null, + "type": "float", + "default-value": 10.0, + "control": { + "name": "Float" + } + }, + "transScatterColor": { + "link": null, + "type": "vec3f", + "default-value": [ + 1.0, + 1.0, + 1.0 + ], + "control": { + "name": "Float Vector 3" + } + }, + "ior": { + "link": null, + "type": "float", + "default-value": 1.0, + "control": { + "name": "Float" + } + }, + "diffraction": { + "link": null, + "type": "float", + "default-value": 0.0, + "control": { + "name": "Float" + } + }, + "diffractColor": { + "link": null, + "type": "vec3f", + "default-value": [ + 0.0, + 0.0, + 0.0 + ], + "control": { + "name": "Float Vector 3" + } + }, + "flatness": { + "link": null, + "type": "float", + "default-value": 0.0, + "control": { + "name": "Float" + } + }, + "shadowReceiver": { + "link": null, + "type": "float", + "default-value": 0.0, + "control": { + "name": "Float" + } + }, + "thin": { + "link": null, + "type": "float", + "default-value": 0.0, + "control": { + "name": "Float" + } + }, + "doubleSide": { + "link": null, + "type": "float", + "default-value": 1.0, + "control": { + "name": "Float" + } + }, + "normal": { + "link": null, + "type": "vec3f", + "default-value": [ + 0.0, + 0.0, + 1.0 + ], + "control": { + "name": "Float Vector 3" + } + }, + "displacement": { + "link": null, + "type": "float", + "default-value": 0.0, + "control": { + "name": "Float" + } + }, + "smoothness": { + "link": null, + "type": "float", + "default-value": 1.0, + "control": { + "name": "Float" + } + }, + "emissionIntensity": { + "link": null, + "type": "float", + "default-value": 1.0, + "control": { + "name": "Float" + } + }, + "emission": { + "link": null, + "type": "vec3f", + "default-value": [ + 0.0, + 0.0, + 0.0 + ], + "control": { + "name": "Float Vector 3" + } + }, + "reflectance": { + "link": null, + "type": "vec3f", + "default-value": [ + 1.0, + 1.0, + 1.0 + ], + "control": { + "name": "Float Vector 3" + } + }, + "opacity": { + "link": null, + "type": "float", + "default-value": 0.0, + "control": { + "name": "Float" + } + }, + "thickness": { + "link": null, + "type": "float", + "default-value": 0.0, + "control": { + "name": "Float" + } + }, + "isHair": { + "link": null, + "type": "float", + "default-value": 0.0, + "control": { + "name": "Float" + } + }, + "commonCode": { + "link": null, + "type": "string", + "default-value": "", + "control": { + "name": "String" + } + }, + "extensionsCode": { + "link": null, + "type": "string", + "default-value": "", + "control": { + "name": "String" + } + }, + "mtlid": { + "link": null, + "type": "string", + "default-value": "Mat1", + "control": { + "name": "String" + } + }, + "tex2dList": { + "property": "dict-panel", + "dictlist-panel": { + "collasped": false, + "keys": {} + }, + "link": null, + "type": "list", + "default-value": null, + "control": { + "name": "" + } + }, + "mask_value": { + "link": null, + "type": "vec3i", + "default-value": [ + 0, + 0, + 0 + ], + "control": { + "name": "Integer Vector 3" + } + }, + "SRC": { + "link": null, + "type": "", + "default-value": null, + "control": { + "name": "" + } + } + }, + "params": { + "backend": { + "value": "CUDA", + "control": { + "name": "Enum", + "items": [ + "CUDA" + ] + }, + "type": "enum CUDA" + } + }, + "outputs": { + "mtl": { + "type": "MaterialObject" + }, + "DST": { + "type": "" + } + }, + "uipos": [ + 1911.505126953125, + -162.63856506347657 + ], + "options": [ + "VIEW" + ] + }, + "1411a749-BindMaterial": { + "name": "BindMaterial", + "inputs": { + "object": { + "link": "main:65827076-CreateSphere:[node]/outputs/prim", + "type": "", + "default-value": null, + "control": { + "name": "" + } + }, + "mtlid": { + "link": null, + "type": "string", + "default-value": "Mat1", + "control": { + "name": "String" + } + }, + "SRC": { + "link": null, + "type": "", + "default-value": null, + "control": { + "name": "" + } + } + }, + "params": {}, + "outputs": { + "object": { + "type": "" + }, + "DST": { + "type": "" + } + }, + "uipos": [ + 3675.923095703125, + 1334.8724365234376 + ], + "options": [ + "VIEW" + ] + }, + "ebdaeba7-HDRSky": { + "name": "HDRSky", + "inputs": { + "enable": { + "link": null, + "type": "bool", + "default-value": true, + "control": { + "name": "Boolean" + } + }, + "path": { + "link": "main:40bcf34d-StringEval:[node]/outputs/result", + "type": "readpath", + "default-value": "", + "control": { + "name": "read path" + } + }, + "rotation": { + "link": null, + "type": "float", + "default-value": 0.0, + "control": { + "name": "Float" + } + }, + "rotation3d": { + "link": null, + "type": "vec3f", + "default-value": [ + 0.0, + 0.0, + 0.0 + ], + "control": { + "name": "Float Vector 3" + } + }, + "strength": { + "link": null, + "type": "float", + "default-value": 1.0, + "control": { + "name": "Float" + } + }, + "SRC": { + "link": null, + "type": "", + "default-value": null, + "control": { + "name": "" + } + } + }, + "params": {}, + "outputs": { + "HDRSky": { + "type": "" + }, + "DST": { + "type": "" + } + }, + "uipos": [ + 1032.0037841796876, + 848.2868041992188 + ], + "options": [ + "VIEW" + ] + }, + "caf72c52-CreateSphere": { + "name": "CreateSphere", + "inputs": { + "position": { + "link": null, + "type": "vec3f", + "default-value": [ + 40.0, + 0.0, + 0.0 + ], + "control": { + "name": "Float Vector 3" + } + }, + "scaleSize": { + "link": null, + "type": "vec3f", + "default-value": [ + 10.0, + 10.0, + 10.0 + ], + "control": { + "name": "Float Vector 3" + } + }, + "radius": { + "link": null, + "type": "float", + "default-value": 1.0, + "control": { + "name": "Float" + } + }, + "rotate": { + "link": null, + "type": "vec3f", + "default-value": [ + 0.0, + 0.0, + 0.0 + ], + "control": { + "name": "Float Vector 3" + } + }, + "hasNormal": { + "link": null, + "type": "bool", + "default-value": false, + "control": { + "name": "Boolean" + } + }, + "hasVertUV": { + "link": null, + "type": "bool", + "default-value": false, + "control": { + "name": "Boolean" + } + }, + "isFlipFace": { + "link": null, + "type": "bool", + "default-value": false, + "control": { + "name": "Boolean" + } + }, + "rows": { + "link": null, + "type": "int", + "default-value": 12, + "control": { + "name": "Integer" + } + }, + "columns": { + "link": null, + "type": "int", + "default-value": 24, + "control": { + "name": "Integer" + } + }, + "quads": { + "link": null, + "type": "bool", + "default-value": false, + "control": { + "name": "Boolean" + } + }, + "SphereRT": { + "link": null, + "type": "bool", + "default-value": true, + "control": { + "name": "Boolean" + } + }, + "SRC": { + "link": null, + "type": "", + "default-value": null, + "control": { + "name": "" + } + } + }, + "params": { + "EulerAngleMeasure": { + "value": "Degree", + "control": { + "name": "Enum", + "items": [ + "", + "Degree", + "Radians" + ] + }, + "type": "enum Degree Radians" + }, + "EulerRotationOrder": { + "value": "XYZ", + "control": { + "name": "Enum", + "items": [ + "", + "XYZ", + "XZY", + "YXZ", + "YZX", + "ZXY", + "ZYX" + ] + }, + "type": "enum XYZ XZY YXZ YZX ZXY ZYX" + } + }, + "outputs": { + "prim": { + "type": "" + }, + "DST": { + "type": "" + } + }, + "uipos": [ + 2876.9833984375, + 0.23900079727172852 + ], + "options": [] + }, + "32c608da-BindMaterial": { + "name": "BindMaterial", + "inputs": { + "object": { + "link": "main:caf72c52-CreateSphere:[node]/outputs/prim", + "type": "", + "default-value": null, + "control": { + "name": "" + } + }, + "mtlid": { + "link": null, + "type": "string", + "default-value": "Mat1", + "control": { + "name": "String" + } + }, + "SRC": { + "link": null, + "type": "", + "default-value": null, + "control": { + "name": "" + } + } + }, + "params": {}, + "outputs": { + "object": { + "type": "" + }, + "DST": { + "type": "" + } + }, + "uipos": [ + 3631.699951171875, + 99.59801483154297 + ], + "options": [ + "VIEW" + ] + }, + "4fa0d0b9-WriteImageFile_v2": { + "name": "WriteImageFile_v2", + "inputs": { + "image": { + "link": "main:5c479936-NoiseImageGen2:[node]/outputs/image", + "type": "", + "default-value": null, + "control": { + "name": "" + } + }, + "path": { + "link": "main:40bcf34d-StringEval:[node]/outputs/result", + "type": "writepath", + "default-value": "${ZSG}/sky.png", + "control": { + "name": "write path" + } + }, + "type": { + "link": null, + "type": "enum png jpg exr pfm hdr", + "default-value": "png", + "control": { + "name": "Enum", + "items": [ + "png", + "jpg", + "exr", + "pfm", + "hdr" + ] + } + }, + "mask": { + "link": null, + "type": "", + "default-value": null, + "control": { + "name": "" + } + }, + "linear_to_srgb_when_save": { + "link": null, + "type": "bool", + "default-value": true, + "control": { + "name": "Boolean" + } + }, + "SRC": { + "link": null, + "type": "", + "default-value": null, + "control": { + "name": "" + } + } + }, + "params": {}, + "outputs": { + "image": { + "type": "" + }, + "DST": { + "type": "" + } + }, + "uipos": [ + 198.543212890625, + 567.2844848632813 + ], + "options": [ + "VIEW" + ] + }, + "5c479936-NoiseImageGen2": { + "name": "NoiseImageGen2", + "inputs": { + "image size": { + "link": null, + "type": "vec2i", + "default-value": [ + 1920, + 1080 + ], + "control": { + "name": "Integer Vector 2" + } + }, + "seed": { + "link": null, + "type": "int", + "default-value": 0, + "control": { + "name": "Integer" + } + }, + "noise per component": { + "link": null, + "type": "bool", + "default-value": false, + "control": { + "name": "Boolean" + } + }, + "turbulence": { + "link": null, + "type": "int", + "default-value": 0, + "control": { + "name": "Integer" + } + }, + "roughness": { + "link": null, + "type": "float", + "default-value": 0.0, + "control": { + "name": "Float" + } + }, + "exponent": { + "link": null, + "type": "float", + "default-value": 0.0, + "control": { + "name": "Float" + } + }, + "spatial frequency": { + "link": null, + "type": "vec2f", + "default-value": [ + 0.0, + 0.0 + ], + "control": { + "name": "Float Vector 2" + } + }, + "amplitude": { + "link": null, + "type": "vec4f", + "default-value": [ + 1.0, + 1.0, + 1.0, + 1.0 + ], + "control": { + "name": "Float Vector 4" + } + }, + "pulsenum": { + "link": null, + "type": "int", + "default-value": 1, + "control": { + "name": "Integer" + } + }, + "SRC": { + "link": null, + "type": "", + "default-value": null, + "control": { + "name": "" + } + } + }, + "params": {}, + "outputs": { + "image": { + "type": "PrimitiveObject" + }, + "DST": { + "type": "" + } + }, + "uipos": [ + -571.7866821289063, + 479.559326171875 + ], + "options": [] + }, + "40bcf34d-StringEval": { + "name": "StringEval", + "inputs": { + "zfxCode": { + "link": null, + "type": "string", + "default-value": "$ZSG/sky.png", + "control": { + "name": "Multiline String" + } + }, + "SRC": { + "link": null, + "type": "", + "default-value": null, + "control": { + "name": "" + } + } + }, + "params": {}, + "outputs": { + "result": { + "type": "string" + }, + "DST": { + "type": "" + } + }, + "uipos": [ + 75.59382629394531, + 1134.0048828125 + ], + "options": [] + }, + "65827076-CreateSphere": { + "name": "CreateSphere", + "inputs": { + "position": { + "link": null, + "type": "vec3f", + "default-value": [ + 0.0, + 0.0, + 0.0 + ], + "control": { + "name": "Float Vector 3" + } + }, + "scaleSize": { + "link": null, + "type": "vec3f", + "default-value": [ + 10.0, + 10.0, + 10.0 + ], + "control": { + "name": "Float Vector 3" + } + }, + "radius": { + "link": null, + "type": "float", + "default-value": 1.0, + "control": { + "name": "Float" + } + }, + "rotate": { + "link": null, + "type": "vec3f", + "default-value": [ + 0.0, + 0.0, + 0.0 + ], + "control": { + "name": "Float Vector 3" + } + }, + "hasNormal": { + "link": null, + "type": "bool", + "default-value": false, + "control": { + "name": "Boolean" + } + }, + "hasVertUV": { + "link": null, + "type": "bool", + "default-value": false, + "control": { + "name": "Boolean" + } + }, + "isFlipFace": { + "link": null, + "type": "bool", + "default-value": false, + "control": { + "name": "Boolean" + } + }, + "rows": { + "link": null, + "type": "int", + "default-value": 12, + "control": { + "name": "Integer" + } + }, + "columns": { + "link": null, + "type": "int", + "default-value": 24, + "control": { + "name": "Integer" + } + }, + "quads": { + "link": null, + "type": "bool", + "default-value": false, + "control": { + "name": "Boolean" + } + }, + "SphereRT": { + "link": null, + "type": "bool", + "default-value": false, + "control": { + "name": "Boolean" + } + }, + "SRC": { + "link": null, + "type": "", + "default-value": null, + "control": { + "name": "" + } + } + }, + "params": { + "EulerAngleMeasure": { + "value": "Degree", + "control": { + "name": "Enum", + "items": [ + "", + "Degree", + "Radians" + ] + }, + "type": "enum Degree Radians" + }, + "EulerRotationOrder": { + "value": "XYZ", + "control": { + "name": "Enum", + "items": [ + "", + "XYZ", + "XZY", + "YXZ", + "YZX", + "ZXY", + "ZYX" + ] + }, + "type": "enum XYZ XZY YXZ YZX ZXY ZYX" + } + }, + "outputs": { + "prim": { + "type": "" + }, + "DST": { + "type": "" + } + }, + "uipos": [ + 2828.293212890625, + 1117.6728515625 + ], + "options": [] + }, + "bbcf329e-CameraNode": { + "name": "CameraNode", + "inputs": { + "pos": { + "link": null, + "type": "vec3f", + "default-value": [ + 26.552457809448243, + -8.226021766662598, + -54.12051773071289 + ], + "control": { + "name": "Float Vector 3" + } + }, + "up": { + "link": null, + "type": "vec3f", + "default-value": [ + -0.04557733237743378, + 0.9832948446273804, + -0.17622052133083344 + ], + "control": { + "name": "Float Vector 3" + } + }, + "view": { + "link": null, + "type": "vec3f", + "default-value": [ + -0.05694492906332016, + 0.17355962097644807, + 0.983157753944397 + ], + "control": { + "name": "Float Vector 3" + } + }, + "fov": { + "link": null, + "type": "float", + "default-value": 45.0, + "control": { + "name": "Float" + } + }, + "aperture": { + "link": null, + "type": "float", + "default-value": 0.0, + "control": { + "name": "Float" + } + }, + "focalPlaneDistance": { + "link": null, + "type": "float", + "default-value": 2.0, + "control": { + "name": "Float" + } + }, + "other": { + "link": null, + "type": "string", + "default-value": "1.08676,-4.57906,-8.69904,0,0,52.2007,", + "control": { + "name": "String" + } + }, + "frame": { + "link": null, + "type": "int", + "default-value": 0, + "control": { + "name": "Integer" + } + }, + "SRC": { + "link": null, + "type": "", + "default-value": null, + "control": { + "name": "" + } + } + }, + "params": {}, + "outputs": { + "camera": { + "type": "CameraObject" + }, + "DST": { + "type": "" + } + }, + "uipos": [ + 1013.4251708984375, + -148.00021362304688 + ], + "options": [ + "VIEW" + ] + } + }, + "view_rect": {} + } + }, + "views": { + "timeline": { + "start-frame": 0, + "end-frame": 1, + "curr-frame": 0, + "always": false, + "timeline-fps": 24 + } + }, + "descs": { + "AABBCollideDetect": { + "inputs": [ + [ + "vec3f", + "bminA", + "" + ], + [ + "vec3f", + "bmaxA", + "" + ], + [ + "vec3f", + "bminB", + "" + ], + [ + "vec3f", + "bmaxB", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "bool", + "overlap", + "" + ], + [ + "bool", + "AinsideB", + "" + ], + [ + "bool", + "BinsideA", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "math" + ] + }, + "AlembicPrimList": { + "inputs": [ + [ + "bool", + "flipFrontBack", + "1" + ], + [ + "ABCTree", + "abctree", + "" + ], + [ + "bool", + "use_xform", + "0" + ], + [ + "bool", + "triangulate", + "0" + ], + [ + "bool", + "splitByFaceset", + "0" + ], + [ + "bool", + "killDeadVerts", + "1" + ], + [ + "string", + "pathInclude", + "" + ], + [ + "string", + "pathExclude", + "" + ], + [ + "string", + "facesetInclude", + "" + ], + [ + "string", + "facesetExclude", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "", + "prims", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "alembic" + ] + }, + "AlembicSplitByName": { + "inputs": [ + [ + "", + "prim", + "" + ], + [ + "bool", + "killDeadVerts", + "1" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "DictObject", + "dict", + "" + ], + [ + "ListObject", + "namelist", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "alembic" + ] + }, + "AlembicToDynamicRemeshVAT": { + "inputs": [ + [ + "readpath", + "path", + "" + ], + [ + "bool", + "useXForm", + "1" + ], + [ + "bool", + "flipFrontBack", + "1" + ], + [ + "int", + "frameEnd", + "1" + ], + [ + "int", + "frameStart", + "0" + ], + [ + "writepath", + "outputPath", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "", + "primitive", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "alembic", + "primitive" + ] + }, + "AlembicToSoftBodyVAT": { + "inputs": [ + [ + "readpath", + "path", + "" + ], + [ + "bool", + "useXForm", + "1" + ], + [ + "bool", + "flipFrontBack", + "1" + ], + [ + "int", + "frameEnd", + "1" + ], + [ + "int", + "frameStart", + "0" + ], + [ + "writepath", + "outputPath", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "", + "primitive", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "alembic", + "primitive" + ] + }, + "AllAlembicPrim": { + "inputs": [ + [ + "bool", + "flipFrontBack", + "1" + ], + [ + "ABCTree", + "abctree", + "" + ], + [ + "bool", + "use_xform", + "0" + ], + [ + "bool", + "triangulate", + "0" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "PrimitiveObject", + "prim", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "alembic" + ] + }, + "AppendList": { + "inputs": [ + [ + "", + "list", + "" + ], + [ + "", + "object", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "", + "list", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "list" + ] + }, + "AsCurves": { + "inputs": [ + [ + "", + "prim", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [ + [ + "enum QUADRATIC_BSPLINE RIBBON_BSPLINE CUBIC_BSPLINE LINEAR BEZIER CATROM", + "type", + "LINEAR" + ] + ], + "outputs": [ + [ + "", + "prim", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "prim" + ] + }, + "Assign": { + "inputs": [ + [ + "", + "dst", + "" + ], + [ + "", + "src", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "", + "dst", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "lifecycle" + ] + }, + "BVHNearestAttr": { + "inputs": [ + [ + "", + "prim", + "" + ], + [ + "", + "primNei", + "" + ], + [ + "string", + "bvhIdTag", + "bvh_id" + ], + [ + "string", + "bvhWeightTag", + "bvh_ws" + ], + [ + "string", + "bvhAttrTag", + "bvh_attr" + ], + [ + "enum float vec3f", + "bvhAttributesType", + "float" + ], + [ + "enum tris points", + "targetPrimType", + "tris" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "", + "prim", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "primitive" + ] + }, + "BVHNearestPos": { + "inputs": [ + [ + "", + "prim", + "" + ], + [ + "", + "primNei", + "" + ], + [ + "string", + "bvhIdTag", + "bvh_id" + ], + [ + "string", + "bvhWeightTag", + "bvh_ws" + ], + [ + "string", + "bvhPosTag", + "bvh_pos" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "", + "prim", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "deprecated" + ] + }, + "BecomeRtInst": { + "inputs": [ + [ + "", + "object", + "" + ], + [ + "bool", + "isInst", + "1" + ], + [ + "string", + "instID", + "Inst1" + ], + [ + "enum XYZ YXZ YZX ZYX ZXY XZY", + "onbType", + "XYZ" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "", + "object", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "shader" + ] + }, + "BeginFor": { + "inputs": [ + [ + "int", + "count", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "int", + "index", + "" + ], + [ + "", + "FOR", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "control" + ] + }, + "BeginForEach": { + "inputs": [ + [ + "", + "list", + "" + ], + [ + "", + "accumate", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "", + "object", + "" + ], + [ + "", + "accumate", + "" + ], + [ + "int", + "index", + "" + ], + [ + "", + "FOR", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "control" + ] + }, + "BeginSubstep": { + "inputs": [ + [ + "float", + "total_dt", + "" + ], + [ + "float", + "min_scale", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "", + "FOR", + "" + ], + [ + "float", + "elapsed_time", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "control" + ] + }, + "BindLight": { + "inputs": [ + [ + "", + "object", + "" + ], + [ + "bool", + "islight", + "1" + ], + [ + "bool", + "invertdir", + "0" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "", + "object", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "shader" + ] + }, + "BindMaterial": { + "inputs": [ + [ + "", + "object", + "" + ], + [ + "string", + "mtlid", + "Mat1" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "", + "object", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "shader" + ] + }, + "BindRtInst": { + "inputs": [ + [ + "", + "object", + "" + ], + [ + "string", + "instID", + "Inst1" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "", + "object", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "shader" + ] + }, + "Blackboard": { + "inputs": [], + "params": [], + "outputs": [], + "categories": [ + "layout" + ] + }, + "Blackbody": { + "inputs": [ + [ + "float", + "temperature", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "", + "color", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "shader" + ] + }, + "BoneGetAttr": { + "inputs": [ + [ + "", + "skeleton", + "" + ], + [ + "string", + "boneName", + "" + ], + [ + "string", + "attr", + "" + ], + [ + "enum float vec2f vec3f vec4f int vec2i vec3i vec4i", + "type", + "int" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "", + "value", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "FBXSDK" + ] + }, + "BoneSetAttr": { + "inputs": [ + [ + "", + "skeleton", + "" + ], + [ + "string", + "boneName", + "" + ], + [ + "int", + "value", + "0" + ], + [ + "string", + "attr", + "" + ], + [ + "enum float vec2f vec3f vec4f int vec2i vec3i vec4i", + "type", + "int" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "", + "prim", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "FBXSDK" + ] + }, + "BoneTransformView": { + "inputs": [ + [ + "", + "bones", + "" + ], + [ + "float", + "scale", + "" + ], + [ + "int", + "index", + "-1" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "", + "view", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "debug" + ] + }, + "BoundingBoxFitInto": { + "inputs": [ + [ + "vec3f", + "bminSrc", + "" + ], + [ + "vec3f", + "bmaxSrc", + "" + ], + [ + "vec3f", + "bminDst", + "" + ], + [ + "vec3f", + "bmaxDst", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "vec3f", + "translation", + "" + ], + [ + "vec3f", + "bminTrans", + "" + ], + [ + "vec3f", + "bmaxTrans", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "primitive" + ] + }, + "BreakFor": { + "inputs": [ + [ + "", + "FOR", + "" + ], + [ + "bool", + "breaks", + "1" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "", + "DST", + "" + ] + ], + "categories": [ + "control" + ] + }, + "BuildPrimitiveBvh": { + "inputs": [ + [ + "PrimitiveObject", + "prim", + "" + ], + [ + "float", + "thickness", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [ + [ + "enum auto point line tri quad", + "prim_type", + "auto" + ] + ], + "outputs": [ + [ + "LBvh", + "lbvh", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "zenofx" + ] + }, + "CacheLastFrameBegin": { + "inputs": [ + [ + "", + "input", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "", + "linkFrom", + "" + ], + [ + "", + "lastFrame", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "deprecated" + ] + }, + "CacheLastFrameEnd": { + "inputs": [ + [ + "", + "linkTo", + "" + ], + [ + "", + "updateCache", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "", + "output", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "deprecated" + ] + }, + "CachePrimitive": { + "inputs": [ + [ + "", + "inPrim", + "" + ], + [ + "", + "frameNum", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [ + [ + "string", + "dir", + "/tmp/cache" + ], + [ + "bool", + "ignore", + "0" + ], + [ + "string", + "prefix", + "" + ] + ], + "outputs": [ + [ + "", + "outPrim", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "deprecated" + ] + }, + "CacheToDisk": { + "inputs": [ + [ + "", + "object", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [ + [ + "string", + "cachebasedir", + "" + ] + ], + "outputs": [ + [ + "", + "object", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "lifecycle" + ] + }, + "CacheVDBGrid": { + "inputs": [ + [ + "", + "inGrid", + "" + ], + [ + "", + "frameNum", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [ + [ + "string", + "dir", + "/tmp/cache" + ], + [ + "bool", + "ignore", + "0" + ], + [ + "bool", + "mute", + "0" + ], + [ + "string", + "prefix", + "" + ] + ], + "outputs": [ + [ + "", + "outGrid", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "deprecated" + ] + }, + "CachedByKey": { + "inputs": [ + [ + "", + "input", + "" + ], + [ + "", + "key", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "", + "output", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "control" + ] + }, + "CachedIf": { + "inputs": [ + [ + "", + "input", + "" + ], + [ + "", + "keepCache", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "", + "output", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "control" + ] + }, + "CachedOnce": { + "inputs": [ + [ + "", + "input", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "", + "output", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "control" + ] + }, + "CalcCameraUp": { + "inputs": [ + [ + "vec3f", + "refUp", + "" + ], + [ + "vec3f", + "pos", + "" + ], + [ + "vec3f", + "target", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "vec3f", + "pos", + "" + ], + [ + "vec3f", + "up", + "" + ], + [ + "vec3f", + "view", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "shader" + ] + }, + "CalcDirectionFromAngle": { + "inputs": [ + [ + "float", + "angle", + "" + ], + [ + "enum XY YX YZ ZY ZX XZ", + "plane", + "XY" + ], + [ + "float", + "length", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "vec3f", + "direction", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "math" + ] + }, + "CameraEval": { + "inputs": [ + [ + "", + "frameid", + "" + ], + [ + "", + "nodelist", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "CameraObject", + "camera", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "FBX" + ] + }, + "CameraFrustum": { + "inputs": [ + [ + "", + "cam", + "" + ], + [ + "int", + "width", + "1920" + ], + [ + "int", + "height", + "1080" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "", + "prim", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "shader" + ] + }, + "CameraNode": { + "inputs": [ + [ + "vec3f", + "pos", + "" + ], + [ + "vec3f", + "up", + "" + ], + [ + "vec3f", + "view", + "" + ], + [ + "float", + "fov", + "" + ], + [ + "float", + "aperture", + "" + ], + [ + "float", + "focalPlaneDistance", + "" + ], + [ + "string", + "other", + "" + ], + [ + "int", + "frame", + "0" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "CameraObject", + "camera", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "FBX" + ] + }, + "CihouMayaCameraFov": { + "inputs": [ + [ + "enum Horizontal Vertical", + "fit_gate", + "Horizontal" + ], + [ + "float", + "focL", + "" + ], + [ + "float", + "fw", + "" + ], + [ + "float", + "fh", + "" + ], + [ + "float", + "nx", + "" + ], + [ + "float", + "ny", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "float", + "fov", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "FBX" + ] + }, + "Clone": { + "inputs": [ + [ + "", + "object", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "", + "newObject", + "" + ], + [ + "", + "origin", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "lifecycle" + ] + }, + "CombineVDB": { + "inputs": [ + [ + "", + "FieldA", + "" + ], + [ + "", + "FieldB", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [ + [ + "float", + "MultiplierA", + "" + ], + [ + "float", + "MultiplierB", + "" + ], + [ + "enum CSGUnion CSGIntersection CSGDifference Add Mul Replace A_Sample_B", + "OpType", + "CSGUnion" + ], + [ + "bool", + "writeBack", + "0" + ] + ], + "outputs": [ + [ + "", + "FieldOut", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "openvdb" + ] + }, + "CopyAllUserData": { + "inputs": [ + [ + "", + "dst", + "" + ], + [ + "", + "src", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "", + "dst", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "lifecycle" + ] + }, + "CopyPosAndNrmByIndex": { + "inputs": [ + [ + "", + "prim", + "" + ], + [ + "list", + "list", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "", + "out", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "alembic" + ] + }, + "CountAlembicPrims": { + "inputs": [ + [ + "ABCTree", + "abctree", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "int", + "count", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "alembic" + ] + }, + "CreateBezierCurve": { + "inputs": [ + [ + "list", + "CustomPoints", + "" + ], + [ + "prim", + "SamplePoints", + "" + ], + [ + "float", + "precision", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [ + [ + "string", + "SampleAttr", + "" + ], + [ + "string", + "SampleTag", + "" + ], + [ + "enum Bezier", + "Type", + "Bezier" + ] + ], + "outputs": [ + [ + "", + "prim", + "" + ], + [ + "", + "curev", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "create" + ] + }, + "CreateCircle": { + "inputs": [ + [ + "int", + "segments", + "32" + ], + [ + "float", + "r", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "", + "prim", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "primitive" + ] + }, + "CreateCone": { + "inputs": [ + [ + "vec3f", + "position", + "" + ], + [ + "vec3f", + "scaleSize", + "" + ], + [ + "float", + "radius", + "" + ], + [ + "float", + "height", + "" + ], + [ + "int", + "lons", + "32" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "", + "prim", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "create" + ] + }, + "CreateCube": { + "inputs": [ + [ + "vec3f", + "position", + "" + ], + [ + "vec3f", + "scaleSize", + "" + ], + [ + "vec3f", + "rotate", + "" + ], + [ + "bool", + "hasNormal", + "0" + ], + [ + "bool", + "hasVertUV", + "0" + ], + [ + "bool", + "isFlipFace", + "0" + ], + [ + "int", + "div_w", + "2" + ], + [ + "int", + "div_h", + "2" + ], + [ + "int", + "div_d", + "2" + ], + [ + "float", + "size", + "" + ], + [ + "bool", + "quads", + "0" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "", + "prim", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "create" + ] + }, + "CreateCylinder": { + "inputs": [ + [ + "vec3f", + "position", + "" + ], + [ + "vec3f", + "scaleSize", + "" + ], + [ + "float", + "radius", + "" + ], + [ + "float", + "height", + "" + ], + [ + "int", + "lons", + "32" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "", + "prim", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "create" + ] + }, + "CreateDisk": { + "inputs": [ + [ + "vec3f", + "position", + "" + ], + [ + "vec3f", + "scaleSize", + "" + ], + [ + "vec3f", + "rotate", + "" + ], + [ + "bool", + "hasNormal", + "0" + ], + [ + "bool", + "hasVertUV", + "0" + ], + [ + "bool", + "isFlipFace", + "0" + ], + [ + "float", + "radius", + "" + ], + [ + "int", + "divisions", + "32" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "", + "prim", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "create" + ] + }, + "CreateFolder": { + "inputs": [ + [ + "directory", + "folderPath", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "", + "DST", + "" + ] + ], + "categories": [ + "create" + ] + }, + "CreatePlane": { + "inputs": [ + [ + "vec3f", + "position", + "" + ], + [ + "vec3f", + "scaleSize", + "" + ], + [ + "vec3f", + "rotate", + "" + ], + [ + "bool", + "hasNormal", + "0" + ], + [ + "bool", + "hasVertUV", + "0" + ], + [ + "bool", + "isFlipFace", + "0" + ], + [ + "float", + "size", + "" + ], + [ + "int", + "rows", + "1" + ], + [ + "int", + "columns", + "1" + ], + [ + "bool", + "quads", + "0" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "", + "prim", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "create" + ] + }, + "CreatePoint": { + "inputs": [ + [ + "", + "SRC", + "" + ] + ], + "params": [ + [ + "float", + "x", + "" + ], + [ + "float", + "y", + "" + ], + [ + "float", + "z", + "" + ] + ], + "outputs": [ + [ + "", + "prim", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "create" + ] + }, + "CreatePrimCurve": { + "inputs": [ + [ + "prim", + "inputPoints", + "" + ], + [ + "float", + "precision", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [ + [ + "enum Bezier", + "Type", + "Bezier" + ] + ], + "outputs": [ + [ + "", + "prim", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "primCurve" + ] + }, + "CreateSphere": { + "inputs": [ + [ + "vec3f", + "position", + "" + ], + [ + "vec3f", + "scaleSize", + "" + ], + [ + "float", + "radius", + "" + ], + [ + "vec3f", + "rotate", + "" + ], + [ + "bool", + "hasNormal", + "0" + ], + [ + "bool", + "hasVertUV", + "0" + ], + [ + "bool", + "isFlipFace", + "0" + ], + [ + "int", + "rows", + "12" + ], + [ + "int", + "columns", + "24" + ], + [ + "bool", + "quads", + "0" + ], + [ + "bool", + "SphereRT", + "0" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [ + [ + "enum Degree Radians", + "EulerAngleMeasure", + "Degree" + ], + [ + "enum XYZ XZY YXZ YZX ZXY ZYX", + "EulerRotationOrder", + "XYZ" + ] + ], + "outputs": [ + [ + "", + "prim", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "create" + ] + }, + "CreateTorus": { + "inputs": [ + [ + "vec3f", + "position", + "" + ], + [ + "vec3f", + "rotate", + "" + ], + [ + "float", + "MajorRadius", + "" + ], + [ + "float", + "MinorRadius", + "" + ], + [ + "bool", + "hasNormal", + "0" + ], + [ + "bool", + "hasVertUV", + "0" + ], + [ + "int", + "MajorSegment", + "48" + ], + [ + "int", + "MinorSegment", + "12" + ], + [ + "bool", + "quads", + "0" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [ + [ + "enum Degree Radians", + "EulerAngleMeasure", + "Degree" + ], + [ + "enum XYZ XZY YXZ YZX ZXY ZYX", + "EulerRotationOrder", + "XYZ" + ] + ], + "outputs": [ + [ + "", + "prim", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "create" + ] + }, + "CreateTube": { + "inputs": [ + [ + "vec3f", + "position", + "" + ], + [ + "vec3f", + "scaleSize", + "" + ], + [ + "vec3f", + "rotate", + "" + ], + [ + "bool", + "hasNormal", + "0" + ], + [ + "bool", + "hasVertUV", + "0" + ], + [ + "bool", + "isFlipFace", + "0" + ], + [ + "float", + "radius1", + "" + ], + [ + "float", + "radius2", + "" + ], + [ + "float", + "height", + "" + ], + [ + "int", + "rows", + "3" + ], + [ + "int", + "columns", + "12" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "", + "prim", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "create" + ] + }, + "CreateVolumeBox": { + "inputs": [ + [ + "vec3f", + "pos", + "" + ], + [ + "vec3f", + "scale", + "" + ], + [ + "vec3f", + "rotate", + "" + ], + [ + "", + "vdbGrid", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [ + [ + "enum Degree Radians", + "EulerAngleMeasure", + "Degree" + ], + [ + "enum XYZ XZY YXZ YZX ZXY ZYX", + "EulerRotationOrder", + "XYZ" + ] + ], + "outputs": [ + [ + "", + "prim", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "create" + ] + }, + "CurveOrientation": { + "inputs": [ + [ + "", + "prim", + "" + ], + [ + "string", + "dirName", + "dir" + ], + [ + "string", + "tanName", + "tan" + ], + [ + "string", + "bitanName", + "bitan" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "", + "prim", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "primitive" + ] + }, + "Curvemap": { + "inputs": [ + [ + "", + "curvemap", + "" + ], + [ + "", + "value", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "", + "res", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "deprecated" + ] + }, + "CyHair": { + "inputs": [ + [ + "readpath", + "path", + "" + ], + [ + "bool", + "yup", + "1" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "", + "out", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "read" + ] + }, + "DegreetoRad": { + "inputs": [ + [ + "float", + "degree", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "float", + "radian", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "math" + ] + }, + "DelUserData": { + "inputs": [ + [ + "", + "object", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [ + [ + "string", + "key", + "" + ] + ], + "outputs": [ + [ + "", + "DST", + "" + ] + ], + "categories": [ + "deprecated" + ] + }, + "DelUserData2": { + "inputs": [ + [ + "string", + "key", + "" + ], + [ + "", + "object", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "", + "object", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "lifecycle" + ] + }, + "DictEraseItem": { + "inputs": [ + [ + "DictObject", + "dict", + "" + ], + [ + "string", + "key", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "DictObject", + "dict", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "WBTest" + ] + }, + "DictGetItem": { + "inputs": [ + [ + "DictObject", + "dict", + "" + ], + [ + "string", + "key", + "" + ], + [ + "IObject", + "defl", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "zany", + "object", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "dict" + ] + }, + "DictGetKeyList": { + "inputs": [ + [ + "DictObject", + "dict", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "ListObject", + "keys", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "dict" + ] + }, + "DictHasKey": { + "inputs": [ + [ + "DictObject", + "dict", + "" + ], + [ + "string", + "key", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "bool", + "hasKey", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "dict" + ] + }, + "DictSetItem": { + "inputs": [ + [ + "DictObject", + "dict", + "" + ], + [ + "string", + "key", + "" + ], + [ + "zany", + "object", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "DictObject", + "dict", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "dict" + ] + }, + "DictSize": { + "inputs": [ + [ + "DictObject", + "dict", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "int", + "size", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "dict" + ] + }, + "DictUnion": { + "inputs": [ + [ + "DictObject", + "dict1", + "" + ], + [ + "DictObject", + "dict2", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "DictObject", + "dict", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "dict" + ] + }, + "DirtyTBN": { + "inputs": [ + [ + "PrimitiveObject", + "prim", + "" + ], + [ + "vec3f", + "T", + "" + ], + [ + "vec3f", + "B", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "", + "prim", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "shader" + ] + }, + "DistantLight": { + "inputs": [ + [ + "vec2f", + "Lat-Lon", + "" + ], + [ + "float", + "angleExtent", + "" + ], + [ + "colorvec3f", + "color", + "" + ], + [ + "float", + "intensity", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "", + "out", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "shader" + ] + }, + "DynamicNumber": { + "inputs": [ + [ + "", + "frame", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [ + [ + "enum 100 10 1 0.1 0.01 0.001", + "speed", + "1" + ], + [ + "enum clamp zero cycle", + "type", + "clamp" + ], + [ + "floatslider", + "w", + "0" + ], + [ + "floatslider", + "x", + "0" + ], + [ + "floatslider", + "y", + "0" + ], + [ + "floatslider", + "z", + "0" + ] + ], + "outputs": [ + [ + "", + "vec3", + "" + ], + [ + "", + "x", + "" + ], + [ + "", + "y", + "" + ], + [ + "", + "z", + "" + ], + [ + "", + "w", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "deprecated" + ] + }, + "EmbedZsgGraph": { + "inputs": [ + [ + "readpath", + "zsgPath", + "" + ], + [ + "dict", + "argsDict", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "dict", + "retsDict", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "subgraph" + ] + }, + "EmptyDict": { + "inputs": [ + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "DictObject", + "dict", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "dict" + ] + }, + "EmptyList": { + "inputs": [ + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "", + "list", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "list" + ] + }, + "EndFor": { + "inputs": [ + [ + "", + "FOR", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "", + "DST", + "" + ] + ], + "categories": [ + "control" + ] + }, + "EndForEach": { + "inputs": [ + [ + "", + "object", + "" + ], + [ + "", + "list", + "" + ], + [ + "", + "accumate", + "" + ], + [ + "bool", + "accept", + "1" + ], + [ + "", + "FOR", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [ + [ + "bool", + "doConcat", + "0" + ] + ], + "outputs": [ + [ + "", + "list", + "" + ], + [ + "", + "droppedList", + "" + ], + [ + "", + "accumate", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "control" + ] + }, + "EnvMapRot": { + "inputs": [ + [ + "readpath", + "path", + "" + ], + [ + "vec3f", + "dir", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "float", + "rotation", + "" + ], + [ + "vec3f", + "rotation3d", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "comp" + ] + }, + "EvalBlenderFile": { + "inputs": [ + [ + "readpath", + "script_file", + "" + ], + [ + "readpath", + "blender_file", + "" + ], + [ + "readpath", + "output_path", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "", + "fake", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "FBX" + ] + }, + "EvalCurve": { + "inputs": [ + [ + "float", + "value", + "" + ], + [ + "curve", + "curve", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "float", + "value", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "curve" + ] + }, + "EvalCurveOnPrimAttr": { + "inputs": [ + [ + "", + "prim", + "" + ], + [ + "string", + "attrName", + "tmp" + ], + [ + "string", + "dstName", + "" + ], + [ + "curve", + "curve", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "", + "prim", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "curve" + ] + }, + "EvalFBXAnim": { + "inputs": [ + [ + "", + "frameid", + "" + ], + [ + "", + "data", + "" + ], + [ + "", + "animinfo", + "" + ], + [ + "", + "nodetree", + "" + ], + [ + "", + "bonetree", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [ + [ + "bool", + "evalBlendShape", + "0" + ], + [ + "enum TRUE FALSE", + "interAnimData", + "TRUE" + ], + [ + "bool", + "printAnimData", + "0" + ], + [ + "enum FROM_MAYA DEFAULT", + "unit", + "FROM_MAYA" + ], + [ + "bool", + "writeData", + "0" + ] + ], + "outputs": [ + [ + "", + "prim", + "" + ], + [ + "", + "camera", + "" + ], + [ + "", + "light", + "" + ], + [ + "", + "matName", + "" + ], + [ + "", + "meshName", + "" + ], + [ + "", + "pathName", + "" + ], + [ + "", + "bsPrimsOrigin", + "" + ], + [ + "list", + "bsPrims", + "" + ], + [ + "", + "transDict", + "" + ], + [ + "", + "quatDict", + "" + ], + [ + "", + "scaleDict", + "" + ], + [ + "", + "writeData", + "" + ], + [ + "", + "visibility", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "FBX" + ] + }, + "ExchangeFBXData": { + "inputs": [ + [ + "", + "d", + "" + ], + [ + "", + "animinfo", + "" + ], + [ + "", + "nodetree", + "" + ], + [ + "", + "bonetree", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [ + [ + "enum DATA DATAS MATS", + "dType", + "DATA" + ] + ], + "outputs": [ + [ + "", + "d", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "FBX" + ] + }, + "ExportFBX": { + "inputs": [ + [ + "string", + "custom_command", + "" + ], + [ + "string", + "extra_param", + " -b=5" + ], + [ + "string", + "abcpath", + "" + ], + [ + "string", + "fbxpath", + "" + ], + [ + "string", + "outpath", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "", + "result", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "FBX" + ] + }, + "ExportObjPrimitive": { + "inputs": [ + [ + "writepath", + "path", + "" + ], + [ + "", + "prim", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "", + "DST", + "" + ] + ], + "categories": [ + "deprecated" + ] + }, + "ExportVDBGrid": { + "inputs": [ + [ + "", + "data", + "" + ], + [ + "", + "path", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "", + "DST", + "" + ] + ], + "categories": [ + "deprecated" + ] + }, + "ExportZpmPrimitive": { + "inputs": [ + [ + "PrimitiveObject", + "prim", + "" + ], + [ + "writepath", + "path", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "", + "DST", + "" + ] + ], + "categories": [ + "deprecated" + ] + }, + "ExtendList": { + "inputs": [ + [ + "", + "list1", + "" + ], + [ + "", + "list2", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "list", + "list1", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "list" + ] + }, + "ExtractAxis": { + "inputs": [ + [ + "AxisObject", + "math", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "vec3f", + "origin", + "" + ], + [ + "vec3f", + "axisX", + "" + ], + [ + "vec3f", + "axisY", + "" + ], + [ + "vec3f", + "axisZ", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "math" + ] + }, + "ExtractCamera": { + "inputs": [ + [ + "", + "camobject", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "", + "pos", + "" + ], + [ + "", + "up", + "" + ], + [ + "", + "view", + "" + ], + [ + "", + "fov", + "" + ], + [ + "", + "aperture", + "" + ], + [ + "", + "focalPlaneDistance", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "FBX" + ] + }, + "ExtractCameraData": { + "inputs": [ + [ + "string", + "key", + "camera1" + ], + [ + "", + "camobject", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "", + "pos", + "" + ], + [ + "", + "up", + "" + ], + [ + "", + "view", + "" + ], + [ + "", + "focL", + "" + ], + [ + "", + "haov", + "" + ], + [ + "", + "waov", + "" + ], + [ + "", + "hfov", + "" + ], + [ + "", + "filmW", + "" + ], + [ + "", + "filmH", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "FBX" + ] + }, + "ExtractDict": { + "inputs": [ + [ + "DictObject", + "dict", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "", + "DST", + "" + ] + ], + "categories": [ + "dict" + ] + }, + "ExtractFBXData": { + "inputs": [ + [ + "FBXData", + "data", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "IVertices", + "vertices", + "" + ], + [ + "IIndices", + "indices", + "" + ], + [ + "IMaterial", + "material", + "" + ], + [ + "IBoneOffset", + "boneOffset", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "FBX" + ] + }, + "ExtractLegacyDict": { + "inputs": [ + [ + "DictObject", + "dict", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "", + "DST", + "" + ] + ], + "categories": [ + "deprecated" + ] + }, + "ExtractList": { + "inputs": [ + [ + "", + "list", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "", + "DST", + "" + ] + ], + "categories": [ + "list" + ] + }, + "ExtractMatData": { + "inputs": [ + [ + "", + "data", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "list", + "datas", + "" + ], + [ + "", + "matName", + "" + ], + [ + "list", + "texLists", + "" + ], + [ + "dict", + "texMaps", + "" + ], + [ + "dict", + "matValues", + "" + ], + [ + "dict", + "texUvs", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "FBX" + ] + }, + "ExtractMatDict": { + "inputs": [ + [ + "IMaterial", + "material", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "", + "mats", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "FBX" + ] + }, + "ExtractMatName": { + "inputs": [ + [ + "", + "material", + "" + ], + [ + "", + "key", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "", + "name", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "FBX" + ] + }, + "ExtractMatTexList": { + "inputs": [ + [ + "IMaterial", + "material", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "", + "texLists", + "" + ], + [ + "", + "name", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "FBX" + ] + }, + "FileReadString": { + "inputs": [ + [ + "readpath", + "path", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "string", + "str", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "string" + ] + }, + "FileWriteString": { + "inputs": [ + [ + "string", + "str", + "" + ], + [ + "writepath", + "path", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "", + "DST", + "" + ] + ], + "categories": [ + "string" + ] + }, + "FormJson": { + "inputs": [ + [ + "", + "iObject", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "", + "json", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "json" + ] + }, + "FormatString": { + "inputs": [ + [ + "string", + "str", + "{}" + ], + [ + "list", + "args", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "string", + "str", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "string" + ] + }, + "FuncBegin": { + "inputs": [ + [ + "", + "extraArgs", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "", + "args", + "" + ], + [ + "", + "FUNC", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "control" + ] + }, + "FuncCall": { + "inputs": [ + [ + "FunctionObject", + "function", + "" + ], + [ + "FunctionObject", + "args", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "FunctionObject", + "rets", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "control" + ] + }, + "FuncCallInDict": { + "inputs": [ + [ + "DictObject", + "funcDict", + "" + ], + [ + "bool", + "mayNotFound", + "1" + ], + [ + "string", + "dictKey", + "" + ], + [ + "DictObject", + "args", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "DictObject", + "rets", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "control" + ] + }, + "FuncEnd": { + "inputs": [ + [ + "", + "rets", + "" + ], + [ + "", + "FUNC", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "", + "function", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "control" + ] + }, + "FuncSimpleBegin": { + "inputs": [ + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "", + "arg", + "" + ], + [ + "", + "FUNC", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "control" + ] + }, + "FuncSimpleCall": { + "inputs": [ + [ + "FunctionObject", + "function", + "" + ], + [ + "IObject", + "arg", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "IObject", + "ret", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "control" + ] + }, + "FuncSimpleCallInDict": { + "inputs": [ + [ + "DictObject", + "funcDict", + "" + ], + [ + "string", + "dictKey", + "" + ], + [ + "IObject", + "arg", + "" + ], + [ + "bool", + "mayNotFound", + "1" + ], + [ + "IObject", + "notFoundRet", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "bool", + "isFound", + "" + ], + [ + "IObject", + "ret", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "control" + ] + }, + "FuncSimpleEnd": { + "inputs": [ + [ + "", + "ret", + "" + ], + [ + "", + "FUNC", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "", + "function", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "control" + ] + }, + "Gather2DFiniteDifference": { + "inputs": [ + [ + "PrimitiveObject", + "grid", + "" + ], + [ + "int", + "nx", + "1" + ], + [ + "int", + "ny", + "1" + ], + [ + "string", + "channel", + "pos" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [ + [ + "enum FIVE_STENCIL NINE_STENCIL", + "OpType", + "FIVE_STENCIL" + ], + [ + "enum vec3 float", + "attrT", + "float" + ] + ], + "outputs": [ + [ + "PrimitiveObject", + "prim", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "zenofx" + ] + }, + "GetAlembicCamera": { + "inputs": [ + [ + "ABCTree", + "abctree", + "" + ], + [ + "int", + "nx", + "1920" + ], + [ + "int", + "ny", + "1080" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "", + "pos", + "" + ], + [ + "", + "up", + "" + ], + [ + "", + "view", + "" + ], + [ + "", + "right", + "" + ], + [ + "", + "fov_y", + "" + ], + [ + "", + "focal_length", + "" + ], + [ + "", + "horizontalAperture", + "" + ], + [ + "", + "verticalAperture", + "" + ], + [ + "", + "near", + "" + ], + [ + "", + "far", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "alembic" + ] + }, + "GetAlembicPrim": { + "inputs": [ + [ + "bool", + "flipFrontBack", + "1" + ], + [ + "ABCTree", + "abctree", + "" + ], + [ + "int", + "index", + "0" + ], + [ + "bool", + "use_xform", + "0" + ], + [ + "bool", + "triangulate", + "0" + ], + [ + "bool", + "use_name", + "0" + ], + [ + "string", + "name", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "PrimitiveObject", + "prim", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "alembic" + ] + }, + "GetCurveControlPoint": { + "inputs": [ + [ + "curve", + "curve", + "" + ], + [ + "string", + "key", + "x" + ], + [ + "int", + "index", + "0" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "float", + "point_x", + "" + ], + [ + "float", + "point_y", + "" + ], + [ + "vec2f", + "left_handler", + "" + ], + [ + "vec2f", + "right_handler", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "curve" + ] + }, + "GetFrameNum": { + "inputs": [ + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "", + "FrameNum", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "frame" + ] + }, + "GetFramePortion": { + "inputs": [ + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "", + "FramePortion", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "frame" + ] + }, + "GetFrameTime": { + "inputs": [ + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "", + "time", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "frame" + ] + }, + "GetFrameTimeElapsed": { + "inputs": [ + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "", + "time", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "frame" + ] + }, + "GetPerlinNoise": { + "inputs": [ + [ + "vec3f", + "vec3", + "" + ], + [ + "", + "seed", + "" + ], + [ + "float", + "freq", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "", + "noise", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "noise" + ] + }, + "GetTime": { + "inputs": [ + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "", + "time", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "frame" + ] + }, + "GetUserData": { + "inputs": [ + [ + "", + "object", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [ + [ + "string", + "key", + "" + ] + ], + "outputs": [ + [ + "", + "data", + "" + ], + [ + "bool", + "hasValue", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "deprecated" + ] + }, + "GetUserData2": { + "inputs": [ + [ + "", + "object", + "" + ], + [ + "string", + "key", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "", + "data", + "" + ], + [ + "bool", + "hasValue", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "lifecycle" + ] + }, + "GetVDBBound": { + "inputs": [ + [ + "", + "vdbGrid", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "vec3f", + "bmin", + "" + ], + [ + "vec3f", + "bmax", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "openvdb" + ] + }, + "GetVDBPoints": { + "inputs": [ + [ + "", + "grid", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "", + "pars", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "deprecated" + ] + }, + "GetVDBPointsDroplets": { + "inputs": [ + [ + "", + "grid", + "" + ], + [ + "", + "sdf", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "", + "prim", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "openvdb" + ] + }, + "GetVDBVoxelSize": { + "inputs": [ + [ + "", + "vdbGrid", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "", + "dx", + "" + ], + [ + "", + "dy", + "" + ], + [ + "", + "dz", + "" + ], + [ + "", + "dxyz", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "openvdb" + ] + }, + "Grid2DSample": { + "inputs": [ + [ + "PrimitiveObject", + "prim", + "" + ], + [ + "PrimitiveObject", + "sampleGrid", + "" + ], + [ + "int", + "nx", + "1" + ], + [ + "int", + "ny", + "1" + ], + [ + "float", + "h", + "" + ], + [ + "vec3f", + "bmin", + "" + ], + [ + "string", + "channel", + "*" + ], + [ + "string", + "sampleBy", + "pos" + ], + [ + "enum Clamp Periodic", + "sampleType", + "Clamp" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "PrimitiveObject", + "prim", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "zenofx" + ] + }, + "Grid2DSample_M": { + "inputs": [ + [ + "PrimitiveObject", + "grid", + "" + ], + [ + "PrimitiveObject", + "grid2", + "" + ], + [ + "int", + "nx", + "1" + ], + [ + "int", + "ny", + "1" + ], + [ + "float", + "h", + "" + ], + [ + "vec3f", + "bmin", + "" + ], + [ + "string", + "channel", + "pos" + ], + [ + "string", + "sampleBy", + "pos" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [ + [ + "enum vec3 float", + "attrT", + "float" + ] + ], + "outputs": [ + [ + "PrimitiveObject", + "prim", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "deprecated" + ] + }, + "Group": { + "inputs": [], + "params": [], + "outputs": [], + "categories": [ + "layout" + ] + }, + "HDRSky": { + "inputs": [ + [ + "bool", + "enable", + "1" + ], + [ + "readpath", + "path", + "" + ], + [ + "float", + "rotation", + "" + ], + [ + "vec3f", + "rotation3d", + "" + ], + [ + "float", + "strength", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "", + "HDRSky", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "shader" + ] + }, + "HF_maskByFeature": { + "inputs": [ + [ + "", + "HeightField", + "" + ], + [ + "bool", + "invert_mask", + "0" + ], + [ + "string", + "height_layer", + "height" + ], + [ + "string", + "mask_layer", + "mask" + ], + [ + "int", + "smooth_radius", + "1" + ], + [ + "bool", + "use_slope", + "0" + ], + [ + "float", + "min_slopeangle", + "" + ], + [ + "float", + "max_slopeangle", + "" + ], + [ + "curve", + "slope_ramp", + "" + ], + [ + "bool", + "use_direction", + "0" + ], + [ + "float", + "goal_angle", + "" + ], + [ + "float", + "angle_spread", + "" + ], + [ + "curve", + "dir_ramp", + "" + ], + [ + "bool", + "use_height", + "0" + ], + [ + "float", + "min_height", + "" + ], + [ + "float", + "max_height", + "" + ], + [ + "curve", + "height_ramp", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "", + "HeightField", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "erode" + ] + }, + "HF_maskbyOcclusion": { + "inputs": [ + [ + "", + "prim", + "" + ], + [ + "bool", + "invert mask", + "0" + ], + [ + "int", + "view distance", + "200" + ], + [ + "float", + "step scale", + "" + ], + [ + "int", + "num of searches", + "16" + ], + [ + "bool", + "dohemisphere", + "0" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "", + "prim", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "erode" + ] + }, + "HF_remap": { + "inputs": [ + [ + "", + "prim", + "" + ], + [ + "string", + "remap layer", + "height" + ], + [ + "bool", + "Auto Compute input range", + "0" + ], + [ + "float", + "input min", + "" + ], + [ + "float", + "input max", + "" + ], + [ + "float", + "output min", + "" + ], + [ + "float", + "output max", + "" + ], + [ + "curve", + "remap ramp", + "" + ], + [ + "bool", + "clamp min", + "0" + ], + [ + "bool", + "clamp max", + "0" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "", + "prim", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "deprecated" + ] + }, + "HF_rotate_displacement_2d": { + "inputs": [ + [ + "", + "prim_2DGrid", + "" + ], + [ + "float", + "Rotate Displacement", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "", + "prim_2DGrid", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "erode" + ] + }, + "HeatmapFromImage": { + "inputs": [ + [ + "", + "image", + "" + ], + [ + "int", + "startPos", + "0" + ], + [ + "int", + "endPos", + "-1" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "", + "heatmap", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "visualize" + ] + }, + "HeatmapFromImage2": { + "inputs": [ + [ + "", + "image", + "" + ], + [ + "float", + "startPos", + "" + ], + [ + "float", + "endPos", + "" + ], + [ + "int", + "resample", + "0" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "", + "heatmap", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "visualize" + ] + }, + "HeatmapFromPrimAttr": { + "inputs": [ + [ + "", + "prim", + "" + ], + [ + "string", + "attrName", + "clr" + ], + [ + "int", + "attrNum", + "10" + ], + [ + "int", + "resample", + "0" + ], + [ + "bool", + "reverse Result", + "0" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "", + "heatmap", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "visualize" + ] + }, + "HeightStarPattern": { + "inputs": [ + [ + "PrimitiveObject", + "prim", + "" + ], + [ + "float", + "rotate", + "" + ], + [ + "float", + "anglerandom", + "" + ], + [ + "float", + "shapesize", + "" + ], + [ + "float", + "posjitter", + "" + ], + [ + "float", + "sharpness", + "" + ], + [ + "float", + "starness", + "" + ], + [ + "int", + "sides", + "5" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "PrimitiveObject", + "prim", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "erode" + ] + }, + "HelperMute": { + "inputs": [ + [ + "", + "SRC", + "" + ] + ], + "params": [ + [ + "string", + "NOTE", + "Dont-use-this-node-directly" + ] + ], + "outputs": [ + [ + "", + "DST", + "" + ] + ], + "categories": [ + "deprecated" + ] + }, + "HelperOnce": { + "inputs": [ + [ + "", + "SRC", + "" + ] + ], + "params": [ + [ + "string", + "NOTE", + "Dont-use-this-node-directly" + ] + ], + "outputs": [ + [ + "", + "DST", + "" + ] + ], + "categories": [ + "deprecated" + ] + }, + "IKChains": { + "inputs": [ + [ + "", + "Skeleton", + "" + ], + [ + "", + "IK Drivers", + "" + ], + [ + "list", + "items", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "", + "Skeleton", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "deprecated" + ] + }, + "IKChainsItem": { + "inputs": [ + [ + "string", + "RootName", + "" + ], + [ + "string", + "MidName", + "" + ], + [ + "string", + "TipName", + "" + ], + [ + "bool", + "MatchByName", + "1" + ], + [ + "string", + "TwistName", + "" + ], + [ + "string", + "GoalName", + "" + ], + [ + "bool", + "OrientTip", + "0" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "", + "poseItem", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "deprecated" + ] + }, + "INTERN_PreViewVDB": { + "inputs": [ + [ + "", + "arg0", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "", + "ret0", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "deprecated" + ] + }, + "IfElse": { + "inputs": [ + [ + "", + "true", + "" + ], + [ + "", + "false", + "" + ], + [ + "bool", + "cond", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "", + "result", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "control" + ] + }, + "IkChainsItem": { + "inputs": [ + [ + "string", + "endEffectorName", + "" + ], + [ + "int", + "depth", + "2" + ], + [ + "vec3f", + "targetPos", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "", + "IkChain", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "FBXSDK" + ] + }, + "IkJointConstraints": { + "inputs": [ + [ + "", + "Skeleton", + "" + ], + [ + "", + "RestSkeleton", + "" + ], + [ + "list", + "jointLimits", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "", + "Skeleton", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "FBXSDK" + ] + }, + "IkSolver": { + "inputs": [ + [ + "", + "Skeleton", + "" + ], + [ + "int", + "iterCount", + "50" + ], + [ + "list", + "IkChains", + "" + ], + [ + "list", + "jointLimits", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "", + "Skeleton", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "FBXSDK" + ] + }, + "ImageFlipVertical": { + "inputs": [ + [ + "", + "image", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "", + "image", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "deprecated" + ] + }, + "ImageFloatGaussianBlur": { + "inputs": [ + [ + "", + "image", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "", + "image", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "deprecated" + ] + }, + "ImportAlembicPrim": { + "inputs": [ + [ + "readpath", + "path", + "" + ], + [ + "", + "frameid", + "" + ], + [ + "int", + "index", + "-1" + ], + [ + "bool", + "use_xform", + "0" + ], + [ + "bool", + "triangulate", + "0" + ], + [ + "bool", + "read_face_set", + "0" + ], + [ + "bool", + "outOfRangeAsEmpty", + "0" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "", + "prim", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "alembic" + ] + }, + "ImportObjPrimitive": { + "inputs": [ + [ + "readpath", + "path", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "", + "prim", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "deprecated" + ] + }, + "ImportVDBGrid": { + "inputs": [ + [ + "", + "path", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [ + [ + "string", + "type", + "" + ] + ], + "outputs": [ + [ + "", + "data", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "deprecated" + ] + }, + "ImportZpmPrimitive": { + "inputs": [ + [ + "readpath", + "path", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "PrimitiveObject", + "prim", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "deprecated" + ] + }, + "IntegrateFrameTime": { + "inputs": [ + [ + "", + "desired_dt", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [ + [ + "float", + "min_scale", + "" + ] + ], + "outputs": [ + [ + "", + "actual_dt", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "frame" + ] + }, + "IsList": { + "inputs": [ + [ + "", + "list", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "", + "result", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "list" + ] + }, + "JointLimitItem": { + "inputs": [ + [ + "string", + "boneName", + "" + ], + [ + "bool", + "enableXLimit", + "0" + ], + [ + "vec2f", + "xLimit", + "" + ], + [ + "bool", + "enableYLimit", + "0" + ], + [ + "vec2f", + "yLimit", + "" + ], + [ + "bool", + "enableZLimit", + "0" + ], + [ + "vec2f", + "zLimit", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "", + "JointLimit", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "FBXSDK" + ] + }, + "JsonData": { + "inputs": [ + [ + "", + "json", + "" + ], + [ + "string", + "path", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "", + "out", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "deprecated" + ] + }, + "JsonGetArrayItem": { + "inputs": [ + [ + "", + "json", + "" + ], + [ + "int", + "index", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "", + "json", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "json" + ] + }, + "JsonGetArraySize": { + "inputs": [ + [ + "", + "json", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "", + "size", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "json" + ] + }, + "JsonGetChild": { + "inputs": [ + [ + "", + "json", + "" + ], + [ + "string", + "name", + "" + ], + [ + "enum json int float string vec2f vec3f vec4f", + "type", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "", + "out", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "deprecated" + ] + }, + "JsonGetData": { + "inputs": [ + [ + "", + "json", + "" + ], + [ + "multiline_string", + "paths", + "json_path:vec3f:output_name" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "DictObject", + "outs", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "json" + ] + }, + "JsonGetFloat": { + "inputs": [ + [ + "", + "json", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "", + "value", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "deprecated" + ] + }, + "JsonGetInt": { + "inputs": [ + [ + "", + "json", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "", + "value", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "deprecated" + ] + }, + "JsonGetString": { + "inputs": [ + [ + "", + "json", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "", + "string", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "deprecated" + ] + }, + "JsonGetTypeName": { + "inputs": [ + [ + "", + "json", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "", + "string", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "deprecated" + ] + }, + "JsonSetData": { + "inputs": [ + [ + "", + "json", + "" + ], + [ + "multiline_string", + "paths", + "input_name:json_path" + ], + [ + "dict", + "dict", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "", + "json", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "json" + ] + }, + "JsonSetDataSimple": { + "inputs": [ + [ + "", + "json", + "" + ], + [ + "string", + "path", + "" + ], + [ + "", + "value", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "", + "json", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "json" + ] + }, + "JsonToString": { + "inputs": [ + [ + "", + "json", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "", + "out", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "json" + ] + }, + "LightNode": { + "inputs": [ + [ + "vec3f", + "position", + "" + ], + [ + "vec3f", + "scale", + "" + ], + [ + "vec3f", + "rotate", + "" + ], + [ + "vec4f", + "quaternion", + "" + ], + [ + "colorvec3f", + "color", + "" + ], + [ + "float", + "exposure", + "" + ], + [ + "float", + "intensity", + "" + ], + [ + "float", + "fluxFixed", + "" + ], + [ + "vec2f", + "spread", + "" + ], + [ + "float", + "maxDistance", + "" + ], + [ + "float", + "falloffExponent", + "" + ], + [ + "int", + "mask", + "255" + ], + [ + "bool", + "visible", + "0" + ], + [ + "bool", + "invertdir", + "0" + ], + [ + "bool", + "doubleside", + "0" + ], + [ + "readpath", + "profile", + "" + ], + [ + "readpath", + "texturePath", + "" + ], + [ + "float", + "textureGamma", + "" + ], + [ + "float", + "visibleIntensity", + "" + ], + [ + "enum Plane Ellipse Sphere Point TriangleMesh", + "shape", + "Plane" + ], + [ + "enum Diffuse Direction IES Spot Projector", + "type", + "Diffuse" + ], + [ + "PrimitiveObject", + "prim", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [ + [ + "enum Degree Radians", + "EulerAngleMeasure", + "Radians" + ], + [ + "enum XYZ XZY YXZ YZX ZXY ZYX", + "EulerRotationOrder", + "YXZ" + ] + ], + "outputs": [ + [ + "", + "prim", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "shader" + ] + }, + "LineAddVert": { + "inputs": [ + [ + "", + "prim", + "" + ], + [ + "", + "vert", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "", + "DST", + "" + ] + ], + "categories": [ + "deprecated" + ] + }, + "LineCarve": { + "inputs": [ + [ + "", + "prim", + "" + ], + [ + "float", + "insertU", + "" + ], + [ + "bool", + "cut", + "0" + ], + [ + "bool", + "cut insert to end", + "1" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "", + "prim", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "primitive" + ] + }, + "LineResample": { + "inputs": [ + [ + "", + "prim", + "" + ], + [ + "int", + "segments", + "3" + ], + [ + "", + "PrimSampler", + "" + ], + [ + "string", + "SampleBy", + "t" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "", + "prim", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "primitive" + ] + }, + "ListGetItem": { + "inputs": [ + [ + "", + "list", + "" + ], + [ + "int", + "index", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "", + "object", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "list" + ] + }, + "ListLength": { + "inputs": [ + [ + "", + "list", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "", + "length", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "list" + ] + }, + "LiveMeshNode": { + "inputs": [ + [ + "", + "frameid", + "" + ], + [ + "string", + "vertSrc", + "" + ], + [ + "bool", + "outDict", + "0" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "", + "prims", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "FBX" + ] + }, + "Make1DLinePrimitive": { + "inputs": [ + [ + "int", + "n", + "2" + ], + [ + "vec3f", + "direction", + "" + ], + [ + "float", + "scale", + "" + ], + [ + "vec3f", + "origin", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [ + [ + "enum X Y Z", + "Direction", + "X" + ], + [ + "bool", + "hasLines", + "1" + ], + [ + "bool", + "isCentered", + "0" + ] + ], + "outputs": [ + [ + "PrimitiveObject", + "prim", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "primitive" + ] + }, + "Make2DGridPrimitive": { + "inputs": [ + [ + "int", + "nx", + "2" + ], + [ + "int", + "ny", + "0" + ], + [ + "vec3f", + "sizeX", + "" + ], + [ + "vec3f", + "sizeY", + "" + ], + [ + "float", + "scale", + "" + ], + [ + "vec3f", + "origin", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [ + [ + "enum XZ XY YZ", + "Direction", + "XZ" + ], + [ + "enum Column-major Row-major", + "Layout", + "Column-major" + ], + [ + "bool", + "hasFaces", + "1" + ], + [ + "bool", + "hasUV", + "0" + ], + [ + "bool", + "isCentered", + "0" + ] + ], + "outputs": [ + [ + "PrimitiveObject", + "prim", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "primitive" + ] + }, + "Make3DGridPointsInAABB": { + "inputs": [ + [ + "int", + "nx", + "4" + ], + [ + "int", + "ny", + "0" + ], + [ + "int", + "nz", + "0" + ], + [ + "vec3f", + "bmin", + "" + ], + [ + "vec3f", + "bmax", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [ + [ + "bool", + "isStaggered", + "1" + ] + ], + "outputs": [ + [ + "", + "prim", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "primitive" + ] + }, + "Make3DGridPrimitive": { + "inputs": [ + [ + "int", + "nx", + "2" + ], + [ + "int", + "ny", + "0" + ], + [ + "int", + "nz", + "0" + ], + [ + "vec3f", + "sizeX", + "" + ], + [ + "vec3f", + "sizeY", + "" + ], + [ + "vec3f", + "sizeZ", + "" + ], + [ + "float", + "scale", + "" + ], + [ + "vec3f", + "origin", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [ + [ + "bool", + "isCentered", + "0" + ] + ], + "outputs": [ + [ + "", + "prim", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "primitive" + ] + }, + "MakeAxis": { + "inputs": [ + [ + "vec3f", + "origin", + "" + ], + [ + "vec3f", + "axisX", + "" + ], + [ + "vec3f", + "axisY", + "" + ], + [ + "vec3f", + "axisZ", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [ + [ + "enum off X Y Z", + "normalize", + "off" + ] + ], + "outputs": [ + [ + "AxisObject", + "math", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "math" + ] + }, + "MakeBoxPrimitive": { + "inputs": [ + [ + "float", + "size_x", + "" + ], + [ + "float", + "size_y", + "" + ], + [ + "float", + "size_z", + "" + ], + [ + "vec3f", + "origin", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [ + [ + "bool", + "use_quads", + "0" + ] + ], + "outputs": [ + [ + "", + "prim", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "primitive" + ] + }, + "MakeCamera": { + "inputs": [ + [ + "vec3f", + "pos", + "" + ], + [ + "vec3f", + "up", + "" + ], + [ + "vec3f", + "view", + "" + ], + [ + "float", + "near", + "" + ], + [ + "float", + "far", + "" + ], + [ + "float", + "fov", + "" + ], + [ + "float", + "aperture", + "" + ], + [ + "float", + "focalPlaneDistance", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "CameraObject", + "camera", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "shader" + ] + }, + "MakeColor": { + "inputs": [ + [ + "colorvec3f", + "color", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "vec3f", + "color", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "color" + ] + }, + "MakeCubePrimitive": { + "inputs": [ + [ + "", + "spacing", + "" + ], + [ + "", + "nx", + "" + ], + [ + "", + "ny", + "" + ], + [ + "", + "nz", + "" + ], + [ + "", + "origin", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "", + "prim", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "deprecated" + ] + }, + "MakeCurve": { + "inputs": [ + [ + "", + "SRC", + "" + ] + ], + "params": [ + [ + "curve", + "curve", + "" + ] + ], + "outputs": [ + [ + "curve", + "curve", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "curve" + ] + }, + "MakeCurvemap": { + "inputs": [ + [ + "", + "SRC", + "" + ] + ], + "params": [ + [ + "float", + "input_max", + "" + ], + [ + "float", + "input_min", + "" + ], + [ + "float", + "output_max", + "" + ], + [ + "float", + "output_min", + "" + ] + ], + "outputs": [ + [ + "", + "curvemap", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "deprecated" + ] + }, + "MakeDict": { + "inputs": [ + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "DictObject", + "dict", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "dict" + ] + }, + "MakeDummy": { + "inputs": [ + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "", + "dummy", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "layout" + ] + }, + "MakeGCTest": { + "inputs": [ + [ + "", + "SRC", + "" + ] + ], + "params": [ + [ + "int", + "value", + "42" + ] + ], + "outputs": [ + [ + "", + "value", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "debug" + ] + }, + "MakeHeatmap": { + "inputs": [ + [ + "", + "SRC", + "" + ] + ], + "params": [ + [ + "int", + "nres", + "1024" + ] + ], + "outputs": [ + [ + "", + "heatmap", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "visualize" + ] + }, + "MakeInstancing": { + "inputs": [ + [ + "int", + "amount", + "1" + ], + [ + "list", + "modelMatrices", + "" + ], + [ + "float", + "deltaTime", + "" + ], + [ + "list", + "timeList", + "" + ], + [ + "list", + "framePrims", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "instancing", + "inst", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "shader" + ] + }, + "MakeLight": { + "inputs": [ + [ + "vec3f", + "lightDir", + "" + ], + [ + "float", + "intensity", + "" + ], + [ + "vec3f", + "shadowTint", + "" + ], + [ + "float", + "lightHight", + "" + ], + [ + "float", + "shadowSoftness", + "" + ], + [ + "vec3f", + "lightColor", + "" + ], + [ + "float", + "lightScale", + "" + ], + [ + "bool", + "isEnabled", + "1" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "LightObject", + "light", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "shader" + ] + }, + "MakeList": { + "inputs": [ + [ + "", + "SRC", + "" + ] + ], + "params": [ + [ + "bool", + "doConcat", + "1" + ] + ], + "outputs": [ + [ + "", + "list", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "list" + ] + }, + "MakeLocalSys": { + "inputs": [ + [ + "vec3f", + "front", + "" + ], + [ + "vec3f", + "up", + "" + ], + [ + "vec3f", + "right", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "", + "LocalSys", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "math" + ] + }, + "MakeMultilineString": { + "inputs": [ + [ + "", + "SRC", + "" + ] + ], + "params": [ + [ + "multiline_string", + "value", + "" + ] + ], + "outputs": [ + [ + "string", + "value", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "string" + ] + }, + "MakeOrthonormalBase": { + "inputs": [ + [ + "vec3f", + "normal", + "" + ], + [ + "vec3f", + "tangent", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "vec3f", + "normal", + "" + ], + [ + "vec3f", + "tangent", + "" + ], + [ + "vec3f", + "bitangent", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "math" + ] + }, + "MakePointPrimitive": { + "inputs": [ + [ + "", + "vec3", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "", + "prim", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "primitive" + ] + }, + "MakePrimitive": { + "inputs": [ + [ + "int", + "size", + "0" + ], + [ + "string", + "points", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "", + "prim", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "primitive" + ] + }, + "MakePrimitiveFromList": { + "inputs": [ + [ + "ListObject", + "list", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "", + "prim", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "primitive" + ] + }, + "MakeReadPath": { + "inputs": [ + [ + "", + "SRC", + "" + ] + ], + "params": [ + [ + "readpath", + "path", + "" + ] + ], + "outputs": [ + [ + "string", + "path", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "string" + ] + }, + "MakeShaderUniform": { + "inputs": [ + [ + "int", + "size", + "512" + ], + [ + "", + "uniformDict", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "", + "prim", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "shader" + ] + }, + "MakeSmallDict": { + "inputs": [ + [ + "string", + "key0", + "" + ], + [ + "IObject", + "obj0", + "" + ], + [ + "string", + "key1", + "" + ], + [ + "IObject", + "obj1", + "" + ], + [ + "string", + "key2", + "" + ], + [ + "IObject", + "obj2", + "" + ], + [ + "string", + "key3", + "" + ], + [ + "IObject", + "obj3", + "" + ], + [ + "string", + "key4", + "" + ], + [ + "IObject", + "obj4", + "" + ], + [ + "string", + "key5", + "" + ], + [ + "IObject", + "obj5", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "", + "dict", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "dict" + ] + }, + "MakeSmallList": { + "inputs": [ + [ + "", + "obj0", + "" + ], + [ + "", + "obj1", + "" + ], + [ + "", + "obj2", + "" + ], + [ + "", + "obj3", + "" + ], + [ + "", + "obj4", + "" + ], + [ + "", + "obj5", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [ + [ + "bool", + "doConcat", + "1" + ] + ], + "outputs": [ + [ + "", + "list", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "list" + ] + }, + "MakeString": { + "inputs": [ + [ + "", + "SRC", + "" + ] + ], + "params": [ + [ + "string", + "value", + "" + ] + ], + "outputs": [ + [ + "string", + "value", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "string" + ] + }, + "MakeTexture2D": { + "inputs": [ + [ + "readpath", + "path", + "" + ], + [ + "", + "heatmap", + "" + ], + [ + "enum REPEAT MIRRORED_REPEAT CLAMP_TO_EDGE CLAMP_TO_BORDER", + "wrapS", + "REPEAT" + ], + [ + "enum REPEAT MIRRORED_REPEAT CLAMP_TO_EDGE CLAMP_TO_BORDER", + "wrapT", + "REPEAT" + ], + [ + "enum NEAREST LINEAR NEAREST_MIPMAP_NEAREST LINEAR_MIPMAP_NEAREST NEAREST_MIPMAP_LINEAR LINEAR_MIPMAP_LINEAR", + "minFilter", + "LINEAR" + ], + [ + "enum NEAREST LINEAR NEAREST_MIPMAP_NEAREST LINEAR_MIPMAP_NEAREST NEAREST_MIPMAP_LINEAR LINEAR_MIPMAP_LINEAR", + "magFilter", + "LINEAR" + ], + [ + "bool", + "blockCompression", + "0" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "texture", + "tex", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "shader" + ] + }, + "MakeTextureVDB": { + "inputs": [ + [ + "readpath", + "path", + "" + ], + [ + "string", + "channel", + "0" + ], + [ + "enum Fp32 Fp16 Fp8 Fp4", + "type", + "Fp32" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "texture", + "tex", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "shader" + ] + }, + "MakeVDBGrid": { + "inputs": [ + [ + "float", + "Dx", + "" + ], + [ + "float", + "background", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [ + [ + "string", + "name", + "" + ], + [ + "enum vertex Centered Staggered", + "structure", + "Centered" + ], + [ + "enum float float3 int int3 points", + "type", + "float" + ] + ], + "outputs": [ + [ + "", + "data", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "openvdb" + ] + }, + "MakeVisualAABBPrimitive": { + "inputs": [ + [ + "float", + "dx", + "" + ], + [ + "vec3f", + "boundMin", + "" + ], + [ + "vec3f", + "boundMax", + "" + ], + [ + "int", + "OpenTop", + "0" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [ + [ + "enum points edges trifaces quadfaces", + "type", + "edges" + ] + ], + "outputs": [ + [ + "", + "prim", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "visualize" + ] + }, + "MakeWritePath": { + "inputs": [ + [ + "", + "SRC", + "" + ] + ], + "params": [ + [ + "writepath", + "path", + "" + ] + ], + "outputs": [ + [ + "string", + "path", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "string" + ] + }, + "MatTranspose": { + "inputs": [ + [ + "", + "mat", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "", + "transposeMat", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "math" + ] + }, + "MeshToSDF": { + "inputs": [ + [ + "", + "mesh", + "" + ], + [ + "float", + "Dx", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [ + [ + "enum vertex cell", + "type", + "vertex" + ], + [ + "float", + "voxel_size", + "0.08 0" + ] + ], + "outputs": [ + [ + "", + "sdf", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "deprecated" + ] + }, + "MocDictAsOutput": { + "inputs": [ + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "DictObject", + "dict", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "dict2" + ] + }, + "MomentumTransfer2DFiniteDifference": { + "inputs": [ + [ + "PrimitiveObject", + "grid", + "" + ], + [ + "int", + "nx", + "1" + ], + [ + "int", + "ny", + "1" + ], + [ + "string", + "channel", + "d" + ], + [ + "string", + "add_channel", + "d" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [ + [ + "enum FIVE_STENCIL NINE_STENCIL", + "OpType", + "FIVE_STENCIL" + ], + [ + "enum vec3 float", + "attrT", + "float" + ] + ], + "outputs": [ + [ + "PrimitiveObject", + "prim", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "zenofx" + ] + }, + "MoveAssign": { + "inputs": [ + [ + "", + "dst", + "" + ], + [ + "", + "src", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "", + "dst", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "lifecycle" + ] + }, + "MoveClone": { + "inputs": [ + [ + "", + "object", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "", + "newObject", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "lifecycle" + ] + }, + "MoveDelete": { + "inputs": [ + [ + "", + "object", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "", + "DST", + "" + ] + ], + "categories": [ + "lifecycle" + ] + }, + "MultiMakeDict": { + "inputs": [ + [ + "DictObject", + "dict", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "", + "dict", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "dict" + ] + }, + "MultiMakeList": { + "inputs": [ + [ + "list", + "list", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "", + "list", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "list" + ] + }, + "MustReadObjPrim": { + "inputs": [ + [ + "readpath", + "path", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [ + [ + "bool", + "triangulate", + "1" + ] + ], + "outputs": [ + [ + "primitive", + "prim", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "primitive" + ] + }, + "NewFBXBoneDeform": { + "inputs": [ + [ + "", + "GeometryToDeform", + "" + ], + [ + "", + "RestPointTransforms", + "" + ], + [ + "", + "DeformPointTransforms", + "" + ], + [ + "enum Linear DualQuaternion", + "SkinningMethod", + "Linear" + ], + [ + "string", + "vectors", + "nrm," + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "", + "prim", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "FBXSDK" + ] + }, + "NewFBXExtractKeyframe": { + "inputs": [ + [ + "", + "RestPointTransforms", + "" + ], + [ + "", + "DeformPointTransforms", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "", + "keyframe", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "FBXSDK" + ] + }, + "NewFBXGenerateAnimation": { + "inputs": [ + [ + "", + "skeleton", + "" + ], + [ + "", + "keyframe", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "", + "DeformPointTransforms", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "FBXSDK" + ] + }, + "NewFBXRigPose": { + "inputs": [ + [ + "", + "skeleton", + "" + ], + [ + "bool", + "WorldSpace", + "0" + ], + [ + "list", + "Transformations", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "", + "skeleton", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "FBXSDK" + ] + }, + "NewFBXRigPoseItem": { + "inputs": [ + [ + "string", + "boneName", + "" + ], + [ + "vec3f", + "translate", + "" + ], + [ + "vec3f", + "rotate", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "", + "poseItem", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "FBXSDK" + ] + }, + "NoiseImageGen": { + "inputs": [ + [ + "vec2i", + "image size", + "" + ], + [ + "int", + "seed", + "1" + ], + [ + "bool", + "noise per component", + "1" + ], + [ + "int", + "turbulence", + "1" + ], + [ + "float", + "roughness", + "" + ], + [ + "float", + "exponent", + "" + ], + [ + "vec2f", + "spatial frequency", + "" + ], + [ + "vec4f", + "amplitude", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "PrimitiveObject", + "image", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "deprecated" + ] + }, + "NoiseImageGen2": { + "inputs": [ + [ + "vec2i", + "image size", + "" + ], + [ + "int", + "seed", + "1" + ], + [ + "bool", + "noise per component", + "1" + ], + [ + "int", + "turbulence", + "1" + ], + [ + "float", + "roughness", + "" + ], + [ + "float", + "exponent", + "" + ], + [ + "vec2f", + "spatial frequency", + "" + ], + [ + "vec4f", + "amplitude", + "" + ], + [ + "int", + "pulsenum", + "1" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "PrimitiveObject", + "image", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "image" + ] + }, + "Noise_gabor_2d": { + "inputs": [ + [ + "", + "prim_2DGrid", + "" + ], + [ + "string", + "posLikeAttrName", + "pos" + ], + [ + "float", + "a_", + "" + ], + [ + "float", + "frequency", + "" + ], + [ + "float", + "Orientation", + "" + ], + [ + "int", + "impulses_per_kernel", + "64" + ], + [ + "bool", + "isotropic", + "0" + ], + [ + "float", + "offset", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [ + [ + "string", + "attrName", + "noise" + ] + ], + "outputs": [ + [ + "", + "prim_2DGrid", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "erode" + ] + }, + "NormalView": { + "inputs": [ + [ + "", + "prim", + "" + ], + [ + "float", + "scale", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "", + "normals", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "debug" + ] + }, + "NumRandom": { + "inputs": [ + [ + "vec3f", + "dir", + "" + ], + [ + "float", + "base", + "" + ], + [ + "float", + "scale", + "" + ], + [ + "int", + "seed", + "-1" + ], + [ + "enum scalar01 scalar11 cube01 cube11 plane01 plane11 disk cylinder ball semiball sphere semisphere", + "randType", + "scalar01" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "int", + "value", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "numeric" + ] + }, + "NumRandomFloat": { + "inputs": [ + [ + "int", + "seed", + "-1" + ], + [ + "float", + "valmin", + "" + ], + [ + "float", + "valmax", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "float", + "value", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "numeric" + ] + }, + "NumRandomInt": { + "inputs": [ + [ + "int", + "seed", + "-1" + ], + [ + "int", + "valmin", + "0" + ], + [ + "int", + "valmax", + "1" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "int", + "value", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "numeric" + ] + }, + "NumRandomSeedCombine": { + "inputs": [ + [ + "int", + "x", + "0" + ], + [ + "int", + "y", + "0" + ], + [ + "int", + "z", + "0" + ], + [ + "int", + "w", + "0" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "int", + "seed", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "numeric" + ] + }, + "NumbertoString": { + "inputs": [ + [ + "", + "number", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "string", + "string", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "string" + ] + }, + "NumericCounter": { + "inputs": [ + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "int", + "count", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "numeric" + ] + }, + "NumericEval": { + "inputs": [ + [ + "string", + "zfxCode", + "" + ], + [ + "enum float vec3f int string", + "resType", + "float" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "float", + "result", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "numeric" + ] + }, + "NumericFloat": { + "inputs": [ + [ + "", + "SRC", + "" + ] + ], + "params": [ + [ + "float", + "value", + "" + ] + ], + "outputs": [ + [ + "float", + "value", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "numeric" + ] + }, + "NumericInt": { + "inputs": [ + [ + "", + "SRC", + "" + ] + ], + "params": [ + [ + "int", + "value", + "0" + ] + ], + "outputs": [ + [ + "int", + "value", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "numeric" + ] + }, + "NumericIntVec2": { + "inputs": [ + [ + "", + "SRC", + "" + ] + ], + "params": [ + [ + "int", + "x", + "0" + ], + [ + "int", + "y", + "0" + ] + ], + "outputs": [ + [ + "vec2i", + "vec2", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "deprecated" + ] + }, + "NumericIntVec3": { + "inputs": [ + [ + "", + "SRC", + "" + ] + ], + "params": [ + [ + "int", + "x", + "0" + ], + [ + "int", + "y", + "0" + ], + [ + "int", + "z", + "0" + ] + ], + "outputs": [ + [ + "vec3i", + "vec3", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "numeric" + ] + }, + "NumericIntVec4": { + "inputs": [ + [ + "", + "SRC", + "" + ] + ], + "params": [ + [ + "float", + "w", + "" + ], + [ + "float", + "x", + "" + ], + [ + "float", + "y", + "" + ], + [ + "float", + "z", + "" + ] + ], + "outputs": [ + [ + "vec4f", + "vec4", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "numeric" + ] + }, + "NumericInterpolation": { + "inputs": [ + [ + "NumericObject", + "src", + "" + ], + [ + "NumericObject", + "srcMin", + "" + ], + [ + "NumericObject", + "srcMax", + "" + ], + [ + "NumericObject", + "dstMin", + "" + ], + [ + "NumericObject", + "dstMax", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [ + [ + "bool", + "isClamped", + "0" + ] + ], + "outputs": [ + [ + "NumericObject", + "dst", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "numeric" + ] + }, + "NumericOperator": { + "inputs": [ + [ + "NumericObject", + "lhs", + "" + ], + [ + "NumericObject", + "rhs", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [ + [ + "enum add sub mul div mod and or xor shr shl cmpge cmple cmpgt cmplt cmpne cmpeq land lor pos neg inv not atan2 pow max min fmod dot cross distance length normalize abs sqrt sin cos tan asin acos atan exp log floor round ceil toint tofloat anytrue alltrue copy copyr", + "op_type", + "add" + ] + ], + "outputs": [ + [ + "NumericObject", + "ret", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "numeric" + ] + }, + "NumericRandom": { + "inputs": [ + [ + "float", + "scale", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [ + [ + "int", + "dim", + "1" + ], + [ + "bool", + "symmetric", + "0" + ] + ], + "outputs": [ + [ + "NumericObject", + "value", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "deprecated" + ] + }, + "NumericRandomInt": { + "inputs": [ + [ + "int", + "min", + "0" + ], + [ + "int", + "max", + "65536" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "int", + "value", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "deprecated" + ] + }, + "NumericRangeList": { + "inputs": [ + [ + "int", + "start", + "0" + ], + [ + "int", + "end", + "1" + ], + [ + "int", + "skip", + "1" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "", + "list", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "list" + ] + }, + "NumericVec2": { + "inputs": [ + [ + "", + "SRC", + "" + ] + ], + "params": [ + [ + "float", + "x", + "" + ], + [ + "float", + "y", + "" + ] + ], + "outputs": [ + [ + "vec2f", + "vec2", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "numeric" + ] + }, + "NumericVec3": { + "inputs": [ + [ + "", + "SRC", + "" + ] + ], + "params": [ + [ + "float", + "x", + "" + ], + [ + "float", + "y", + "" + ], + [ + "float", + "z", + "" + ] + ], + "outputs": [ + [ + "vec3f", + "vec3", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "numeric" + ] + }, + "NumericVec4": { + "inputs": [ + [ + "", + "SRC", + "" + ] + ], + "params": [ + [ + "float", + "w", + "" + ], + [ + "float", + "x", + "" + ], + [ + "float", + "y", + "" + ], + [ + "float", + "z", + "" + ] + ], + "outputs": [ + [ + "vec4f", + "vec4", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "numeric" + ] + }, + "NumericWrangle": { + "inputs": [ + [ + "DictObject:NumericObject", + "params", + "" + ], + [ + "string", + "zfxCode", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "DictObject:NumericObject", + "result", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "zenofx" + ] + }, + "OSDPrimSubdiv": { + "inputs": [ + [ + "", + "prim", + "" + ], + [ + "int", + "levels", + "2" + ], + [ + "string", + "edgeCreaseAttr", + "" + ], + [ + "bool", + "triangulate", + "1" + ], + [ + "bool", + "asQuadFaces", + "1" + ], + [ + "bool", + "hasLoopUVs", + "1" + ], + [ + "bool", + "copyFaceAttrs", + "1" + ], + [ + "bool", + "delayTillIpc", + "0" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "", + "prim", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "primitive" + ] + }, + "ObjTimeShift": { + "inputs": [ + [ + "IObject", + "obj", + "" + ], + [ + "int", + "offset", + "1" + ], + [ + "ListObject", + "customList", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "IObject", + "obj", + "" + ], + [ + "IObject", + "prevObj", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "primitive" + ] + }, + "OrthonormalBase": { + "inputs": [ + [ + "vec3f", + "normal", + "" + ], + [ + "vec3f", + "tangent", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "vec3f", + "normal", + "" + ], + [ + "vec3f", + "tangent", + "" + ], + [ + "vec3f", + "bitangent", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "math" + ] + }, + "PackNumericIntVec2": { + "inputs": [ + [ + "int", + "x", + "0" + ], + [ + "int", + "y", + "0" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "vec2i", + "vec2", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "deprecated" + ] + }, + "PackNumericVec": { + "inputs": [ + [ + "float", + "x", + "" + ], + [ + "float", + "y", + "" + ], + [ + "float", + "z", + "" + ], + [ + "float", + "w", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [ + [ + "enum float vec2f vec3f vec4f", + "type", + "vec3f" + ] + ], + "outputs": [ + [ + "", + "vec", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "numeric" + ] + }, + "PackNumericVecInt": { + "inputs": [ + [ + "int", + "x", + "0" + ], + [ + "int", + "y", + "0" + ], + [ + "int", + "z", + "0" + ], + [ + "int", + "w", + "0" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [ + [ + "enum int vec2i vec3i vec4i", + "type", + "vec3i" + ] + ], + "outputs": [ + [ + "", + "veci", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "numeric" + ] + }, + "ParamFileParser": { + "inputs": [ + [ + "", + "formatList", + "" + ], + [ + "writepath", + "configFilePath", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "DictObject", + "params", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "string" + ] + }, + "ParamFormat": { + "inputs": [ + [ + "string", + "name", + "" + ], + [ + "enum float vec2f vec3f vec4f int vec2i vec3i vec4i string", + "type", + "string" + ], + [ + "string", + "defaultValue", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "", + "format", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "string" + ] + }, + "ParameterizeLine": { + "inputs": [ + [ + "", + "prim", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "", + "prim", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "primitive" + ] + }, + "ParticleAsVoxels": { + "inputs": [ + [ + "VDBGrid", + "vdbGrid", + "" + ], + [ + "string", + "Attr", + "" + ], + [ + "", + "particles", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "", + "oGrid", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "visualize" + ] + }, + "ParticleParticleWrangle": { + "inputs": [ + [ + "PrimitiveObject", + "prim1", + "" + ], + [ + "PrimitiveObject", + "prim2", + "" + ], + [ + "string", + "zfxCode", + "" + ], + [ + "DictObject:NumericObject", + "params", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "PrimitiveObject", + "prim", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "zenofx" + ] + }, + "ParticleToLevelSet": { + "inputs": [ + [ + "", + "Particles", + "" + ], + [ + "float", + "Radius", + "" + ], + [ + "float", + "Dx", + "" + ], + [ + "string", + "rname", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "", + "SurfaceSDF", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "openvdb" + ] + }, + "ParticlesBuildBvh": { + "inputs": [ + [ + "PrimitiveObject", + "primNei", + "" + ], + [ + "float", + "radius", + "" + ], + [ + "float", + "radiusMin", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "LBvh", + "lbvh", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "zenofx" + ] + }, + "ParticlesBuildBvhRadius": { + "inputs": [ + [ + "PrimitiveObject", + "primNei", + "" + ], + [ + "float", + "basicRadius", + "" + ], + [ + "string", + "radiusAttr", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "LBvh", + "lbvh", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "zenofx" + ] + }, + "ParticlesBuildHashGrid": { + "inputs": [ + [ + "PrimitiveObject", + "primNei", + "" + ], + [ + "numeric:float", + "radius", + "" + ], + [ + "numeric:float", + "radiusMin", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "hashgrid", + "hashGrid", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "zenofx" + ] + }, + "ParticlesMaskedWrangle": { + "inputs": [ + [ + "PrimitiveObject", + "prim", + "" + ], + [ + "string", + "zfxCode", + "" + ], + [ + "DictObject:NumericObject", + "params", + "" + ], + [ + "string", + "maskAttr", + "mask" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "PrimitiveObject", + "prim", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "zenofx" + ] + }, + "ParticlesNeighborBvhRadiusWrangle": { + "inputs": [ + [ + "PrimitiveObject", + "prim", + "" + ], + [ + "PrimitiveObject", + "primNei", + "" + ], + [ + "LBvh", + "lbvh", + "" + ], + [ + "bool", + "is_box", + "0" + ], + [ + "string", + "radiusAttr", + "radius" + ], + [ + "string", + "maskAttr", + "" + ], + [ + "string", + "zfxCode", + "" + ], + [ + "DictObject:NumericObject", + "params", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "PrimitiveObject", + "prim", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "zenofx" + ] + }, + "ParticlesNeighborBvhWrangle": { + "inputs": [ + [ + "PrimitiveObject", + "prim", + "" + ], + [ + "PrimitiveObject", + "primNei", + "" + ], + [ + "LBvh", + "lbvh", + "" + ], + [ + "bool", + "is_box", + "1" + ], + [ + "string", + "zfxCode", + "" + ], + [ + "DictObject:NumericObject", + "params", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "PrimitiveObject", + "prim", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "zenofx" + ] + }, + "ParticlesNeighborBvhWrangleSorted": { + "inputs": [ + [ + "PrimitiveObject", + "prim", + "" + ], + [ + "PrimitiveObject", + "primNei", + "" + ], + [ + "LBvh", + "lbvh", + "" + ], + [ + "bool", + "is_box", + "1" + ], + [ + "int", + "limit", + "-1" + ], + [ + "string", + "zfxCode", + "" + ], + [ + "DictObject:NumericObject", + "params", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "PrimitiveObject", + "prim", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "zenofx" + ] + }, + "ParticlesNeighborWrangle": { + "inputs": [ + [ + "PrimitiveObject", + "prim", + "" + ], + [ + "PrimitiveObject", + "primNei", + "" + ], + [ + "HashGrid", + "hashGrid", + "" + ], + [ + "string", + "zfxCode", + "" + ], + [ + "DictObject:NumericObject", + "params", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "PrimitiveObject", + "prim", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "zenofx" + ] + }, + "ParticlesTwoWrangle": { + "inputs": [ + [ + "PrimitiveObject", + "prim", + "" + ], + [ + "PrimitiveObject", + "prim2", + "" + ], + [ + "string", + "zfxCode", + "" + ], + [ + "DictObject:NumericObject", + "params", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "PrimitiveObject", + "prim", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "zenofx" + ] + }, + "ParticlesWrangle": { + "inputs": [ + [ + "PrimitiveObject", + "prim", + "" + ], + [ + "string", + "zfxCode", + "" + ], + [ + "DictObject:NumericObject", + "params", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "PrimitiveObject", + "prim", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "zenofx" + ] + }, + "PixarOrthonormalBase": { + "inputs": [ + [ + "vec3f", + "normal", + "" + ], + [ + "vec3f", + "tangent", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "vec3f", + "normal", + "" + ], + [ + "vec3f", + "tangent", + "" + ], + [ + "vec3f", + "bitangent", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "math" + ] + }, + "PlaneProjectPrimitive2DAABB": { + "inputs": [ + [ + "", + "origin", + "" + ], + [ + "", + "normal", + "" + ], + [ + "", + "tangent", + "" + ], + [ + "", + "bitangent", + "" + ], + [ + "", + "prim", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "", + "boundMin2D", + "" + ], + [ + "", + "boundMax2D", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "math" + ] + }, + "PortalIn": { + "inputs": [ + [ + "", + "port", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [ + [ + "string", + "name", + "RenameMe!" + ] + ], + "outputs": [ + [ + "", + "DST", + "" + ] + ], + "categories": [ + "layout" + ] + }, + "PortalLight": { + "inputs": [ + [ + "vec3f", + "pos", + "" + ], + [ + "vec2f", + "scale", + "" + ], + [ + "vec3f", + "rotate", + "" + ], + [ + "int", + "size", + "180" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [ + [ + "enum Degree Radians", + "EulerAngleMeasure", + "Degree" + ], + [ + "enum XYZ XZY YXZ YZX ZXY ZYX", + "EulerRotationOrder", + "XYZ" + ] + ], + "outputs": [ + [ + "", + "out", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "shader" + ] + }, + "PortalOut": { + "inputs": [ + [ + "", + "SRC", + "" + ] + ], + "params": [ + [ + "string", + "name", + "RenameMe!" + ] + ], + "outputs": [ + [ + "", + "port", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "layout" + ] + }, + "PrimAttrFlat": { + "inputs": [ + [ + "", + "prim", + "" + ], + [ + "string", + "params", + "transform_r0,transform_r1,transform_r2" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "", + "output", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "debug" + ] + }, + "PrimAttrInterp": { + "inputs": [ + [ + "PrimitiveObject", + "prim", + "" + ], + [ + "PrimitiveObject", + "prim2", + "" + ], + [ + "string", + "attr", + "" + ], + [ + "float", + "factor", + "" + ], + [ + "string", + "facAttr", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "PrimitiveObject", + "prim", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "primitive" + ] + }, + "PrimAttrRemap": { + "inputs": [ + [ + "PrimitiveObject", + "prim", + "" + ], + [ + "enum vert tri loop poly line", + "scope", + "vert" + ], + [ + "string", + "attr", + "" + ], + [ + "bool", + "Auto Compute input range", + "0" + ], + [ + "bool", + "Clamp min", + "0" + ], + [ + "bool", + "Clamp max", + "0" + ], + [ + "float", + "Input min", + "" + ], + [ + "float", + "Input max", + "" + ], + [ + "float", + "Output min", + "" + ], + [ + "float", + "Output max", + "" + ], + [ + "bool", + "Use Ramp", + "0" + ], + [ + "curve", + "Remap Ramp", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "PrimitiveObject", + "prim", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "primitive" + ] + }, + "PrimAttribBlur": { + "inputs": [ + [ + "", + "prim", + "" + ], + [ + "enum line tri", + "primType", + "tri" + ], + [ + "string", + "attributes", + "ratio" + ], + [ + "enum float vec3f ", + "attributesType", + "float" + ], + [ + "bool", + "useEdgeLengthWeight", + "0" + ], + [ + "int", + "blurringIterations", + "0" + ], + [ + "enum laplacian VolumePreserving custom", + "mode", + "laplacian" + ], + [ + "float", + "stepSize", + "" + ], + [ + "float", + "cutoffFrequency", + "" + ], + [ + "float", + "evenStepSize", + "" + ], + [ + "float", + "oddStepSize", + "" + ], + [ + "string", + "weightAttributes", + "weight" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "", + "prim", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "primCurve" + ] + }, + "PrimBarycentricInterp": { + "inputs": [ + [ + "", + "Particles", + "" + ], + [ + "", + "MeshPrim", + "" + ], + [ + "string", + "triIdTag", + "bvh_id" + ], + [ + "string", + "weightTag", + "bvh_ws" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "", + "Particles", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "primitive" + ] + }, + "PrimBend": { + "inputs": [ + [ + "PrimitiveObject", + "prim", + "" + ], + [ + "vec3f", + "tangent", + "" + ], + [ + "vec3f", + "direction", + "" + ], + [ + "float", + "angle", + "" + ], + [ + "float", + "limitMin", + "" + ], + [ + "float", + "limitMax", + "" + ], + [ + "float", + "midPoint", + "" + ], + [ + "float", + "biasDir", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "PrimitiveObject", + "prim", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "primitive" + ] + }, + "PrimBindOneBone": { + "inputs": [ + [ + "", + "prim", + "" + ], + [ + "string", + "boneName", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "", + "prim", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "FBXSDK" + ] + }, + "PrimBoundingBox": { + "inputs": [ + [ + "PrimitiveObject", + "prim", + "" + ], + [ + "float", + "extraBound", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "vec3f", + "bmin", + "" + ], + [ + "vec3f", + "bmax", + "" + ], + [ + "vec3f", + "center", + "" + ], + [ + "vec3f", + "radius", + "" + ], + [ + "vec3f", + "diameter", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "primitive" + ] + }, + "PrimCalcCentroid": { + "inputs": [ + [ + "PrimitiveObject", + "prim", + "" + ], + [ + "enum Volume Area Vertex BoundBox", + "method", + "Volume" + ], + [ + "float", + "density", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "vec3f", + "centroid", + "" + ], + [ + "float", + "mass", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "primitive" + ] + }, + "PrimCheckTagInRange": { + "inputs": [ + [ + "PrimitiveObject", + "prim", + "" + ], + [ + "string", + "tagAttr", + "index" + ], + [ + "int", + "beg", + "0" + ], + [ + "int", + "end", + "0" + ], + [ + "bool", + "endExcluded", + "0" + ], + [ + "int", + "modularBy", + "0" + ], + [ + "int", + "trueVal", + "1" + ], + [ + "int", + "falseVal", + "0" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "PrimitiveObject", + "prim", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "primitive" + ] + }, + "PrimColorByTag": { + "inputs": [ + [ + "PrimitiveObject", + "prim", + "" + ], + [ + "string", + "tagAttr", + "tag" + ], + [ + "string", + "clrAttr", + "clr" + ], + [ + "int", + "seed", + "-1" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "PrimitiveObject", + "prim", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "visualize" + ] + }, + "PrimConnectBridge": { + "inputs": [ + [ + "PrimitiveObject", + "prim", + "" + ], + [ + "string", + "edgeIndAttr", + "tag" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "PrimitiveObject", + "prim", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "primitive" + ] + }, + "PrimConnectSkin": { + "inputs": [ + [ + "ListObject", + "primList", + "" + ], + [ + "bool", + "isCloseRing", + "0" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "PrimitiveObject", + "prim", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "primitive" + ] + }, + "PrimConnectTape": { + "inputs": [ + [ + "PrimitiveObject", + "prim1", + "" + ], + [ + "PrimitiveObject", + "prim2", + "" + ], + [ + "enum quads lines none", + "faceType", + "quads" + ], + [ + "bool", + "isCloseRing", + "0" + ], + [ + "string", + "edgeMaskAttr", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "PrimitiveObject", + "prim", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "primitive" + ] + }, + "PrimCopyAttr": { + "inputs": [ + [ + "", + "prim", + "" + ], + [ + "string", + "sourceName", + "s" + ], + [ + "string", + "targetName", + "t" + ], + [ + "enum vert tri loop poly line", + "scope", + "vert" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "", + "prim", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "erode" + ] + }, + "PrimCurveDir": { + "inputs": [ + [ + "", + "prim_curve", + "" + ], + [ + "string", + "dirName", + "nrm" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "", + "prim_curve", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "primCurve" + ] + }, + "PrimCurveFromVerts": { + "inputs": [ + [ + "", + "primVerts", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "", + "primCurve", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "primCurve" + ] + }, + "PrimDecodeUVs": { + "inputs": [ + [ + "", + "prim", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "", + "prim", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "deprecated" + ] + }, + "PrimDeformByOneBone": { + "inputs": [ + [ + "", + "prim", + "" + ], + [ + "", + "skeleton", + "" + ], + [ + "string", + "boneName", + "" + ], + [ + "bool", + "useCustomPivot", + "0" + ], + [ + "bool", + "inheritRotation", + "0" + ], + [ + "vec3f", + "pivot", + "" + ], + [ + "vec3f", + "rotation", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "", + "prim", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "FBXSDK" + ] + }, + "PrimDualMesh": { + "inputs": [ + [ + "PrimitiveObject", + "prim", + "" + ], + [ + "bool", + "polygonate", + "1" + ], + [ + "bool", + "keepBounds", + "0" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "PrimitiveObject", + "prim", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "primitive" + ] + }, + "PrimDuplicate": { + "inputs": [ + [ + "PrimitiveObject", + "parsPrim", + "" + ], + [ + "PrimitiveObject", + "meshPrim", + "" + ], + [ + "string", + "dirAttr", + "" + ], + [ + "string", + "tanAttr", + "" + ], + [ + "string", + "radAttr", + "" + ], + [ + "enum XYZ YXZ YZX ZYX ZXY XZY", + "onbType", + "XYZ" + ], + [ + "float", + "radius", + "" + ], + [ + "bool", + "copyParsAttr", + "1" + ], + [ + "bool", + "copyMeshAttr", + "1" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "PrimitiveObject", + "prim", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "primitive" + ] + }, + "PrimDuplicateConnLines": { + "inputs": [ + [ + "PrimitiveObject", + "parsPrim", + "" + ], + [ + "PrimitiveObject", + "meshPrim", + "" + ], + [ + "string", + "dirAttr", + "" + ], + [ + "string", + "tanAttr", + "" + ], + [ + "string", + "radAttr", + "" + ], + [ + "enum XYZ YXZ YZX ZYX ZXY XZY", + "onbType", + "XYZ" + ], + [ + "float", + "radius", + "" + ], + [ + "bool", + "copyParsAttr", + "1" + ], + [ + "bool", + "copyMeshAttr", + "1" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "PrimitiveObject", + "prim", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "primitive" + ] + }, + "PrimEdgeBound": { + "inputs": [ + [ + "PrimitiveObject", + "prim", + "" + ], + [ + "bool", + "removeFaces", + "1" + ], + [ + "bool", + "killDeadVerts", + "1" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "PrimitiveObject", + "prim", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "primitive" + ] + }, + "PrimExtrude": { + "inputs": [ + [ + "PrimitiveObject", + "prim", + "" + ], + [ + "string", + "maskAttr", + "" + ], + [ + "float", + "extrude", + "" + ], + [ + "float", + "inset", + "" + ], + [ + "vec3f", + "offset", + "" + ], + [ + "string", + "sourceMaskAttrO", + "" + ], + [ + "bool", + "delOldFaces", + "1" + ], + [ + "bool", + "autoFindEdges", + "1" + ], + [ + "bool", + "averagedExtrude", + "1" + ], + [ + "bool", + "flipOldFaces", + "0" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "PrimitiveObject", + "prim", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "primitive" + ] + }, + "PrimFacesAttrToVerts": { + "inputs": [ + [ + "PrimitiveObject", + "prim", + "" + ], + [ + "enum lines tris quads polys", + "faceType", + "tris" + ], + [ + "string", + "faceAttr", + "tmp" + ], + [ + "string", + "vertAttr", + "tmp" + ], + [ + "float", + "deflVal", + "" + ], + [ + "enum sum average min max", + "method", + "average" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "PrimitiveObject", + "prim", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "primitive" + ] + }, + "PrimFacesCenterAsVerts": { + "inputs": [ + [ + "PrimitiveObject", + "prim", + "" + ], + [ + "enum faces lines", + "faceType", + "faces" + ], + [ + "bool", + "copyFaceAttrs", + "1" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "PrimitiveObject", + "prim", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "primitive" + ] + }, + "PrimFillAttr": { + "inputs": [ + [ + "PrimitiveObject", + "prim", + "" + ], + [ + "enum vert tri loop poly line", + "scope", + "vert" + ], + [ + "string", + "attr", + "rad" + ], + [ + "enum float vec3f int", + "type", + "float" + ], + [ + "float", + "value", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "PrimitiveObject", + "prim", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "primitive" + ] + }, + "PrimFillColor": { + "inputs": [ + [ + "PrimitiveObject", + "prim", + "" + ], + [ + "vec3f", + "value", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "PrimitiveObject", + "prim", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "primitive" + ] + }, + "PrimFilter": { + "inputs": [ + [ + "PrimitiveObject", + "prim", + "" + ], + [ + "string", + "tagAttr", + "tag" + ], + [ + "string", + "revampAttrO", + "" + ], + [ + "int", + "tagValue", + "0" + ], + [ + "bool", + "isInversed", + "1" + ], + [ + "enum verts faces", + "method", + "verts" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "PrimitiveObject", + "prim", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "primitive" + ] + }, + "PrimFlattenTris": { + "inputs": [ + [ + "", + "prim", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "", + "prim", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "primitive" + ] + }, + "PrimFlipFaces": { + "inputs": [ + [ + "", + "prim", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "", + "prim", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "primitive" + ] + }, + "PrimFloatAttrToInt": { + "inputs": [ + [ + "PrimitiveObject", + "prim", + "" + ], + [ + "string", + "attr", + "tag" + ], + [ + "string", + "attrOut", + "tag" + ], + [ + "float", + "divisor", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "PrimitiveObject", + "prim", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "primitive" + ] + }, + "PrimForceTrail": { + "inputs": [ + [ + "PrimitiveObject", + "prim", + "" + ], + [ + "PrimitiveObject", + "trailPrim", + "" + ], + [ + "string", + "forceAttr", + "force" + ], + [ + "float", + "attractForce", + "" + ], + [ + "float", + "driftForce", + "" + ], + [ + "", + "attractUDFCurve", + "" + ], + [ + "", + "driftCoordCurve", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "PrimitiveObject", + "prim", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "primitive" + ] + }, + "PrimGenerateONB": { + "inputs": [ + [ + "", + "prim", + "" + ], + [ + "string", + "dirAttr", + "nrm" + ], + [ + "string", + "tanAttrOut", + "tang" + ], + [ + "string", + "bitanAttrOut", + "bitang" + ], + [ + "bool", + "writebackDir", + "1" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "", + "prim", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "primitive" + ] + }, + "PrimGetAttr": { + "inputs": [ + [ + "", + "prim", + "" + ], + [ + "string", + "name", + "index" + ], + [ + "enum float vec2f vec3f vec4f int vec2i vec3i vec4i", + "type", + "int" + ], + [ + "enum vert tri line loop poly", + "method", + "tri" + ], + [ + "int", + "index", + "0" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "", + "value", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "erode" + ] + }, + "PrimGetTrisSize": { + "inputs": [ + [ + "", + "prim", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "int", + "TrisSize", + "0" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "WBTest" + ] + }, + "PrimHasAttr": { + "inputs": [ + [ + "", + "prim", + "" + ], + [ + "enum vert tri loop poly line", + "scope", + "vert" + ], + [ + "string", + "attrName", + "attr_x" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "", + "hasAttr", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "erode" + ] + }, + "PrimIntAttrToFloat": { + "inputs": [ + [ + "PrimitiveObject", + "prim", + "" + ], + [ + "string", + "attr", + "tag" + ], + [ + "string", + "attrOut", + "tag" + ], + [ + "float", + "divisor", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "PrimitiveObject", + "prim", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "primitive" + ] + }, + "PrimKillDeadVerts": { + "inputs": [ + [ + "PrimitiveObject", + "prim", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "PrimitiveObject", + "prim", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "primitive" + ] + }, + "PrimLineGenerateONB": { + "inputs": [ + [ + "", + "prim", + "" + ], + [ + "string", + "dirAttrOut", + "dir" + ], + [ + "string", + "tanAttrOut", + "tang" + ], + [ + "string", + "bitanAttrOut", + "bitang" + ], + [ + "bool", + "lineSort", + "1" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "", + "prim", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "primitive" + ] + }, + "PrimLoadExrToChannel": { + "inputs": [ + [ + "readpath", + "path", + "" + ], + [ + "", + "prim", + "" + ], + [ + "string", + "channel", + "clr" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "", + "output", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "comp" + ] + }, + "PrimLoopUVsToVerts": { + "inputs": [ + [ + "", + "prim", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "", + "prim", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "primitive" + ] + }, + "PrimMarkClose": { + "inputs": [ + [ + "PrimitiveObject", + "prim", + "" + ], + [ + "float", + "distance", + "" + ], + [ + "string", + "tagAttr", + "weld" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "PrimitiveObject", + "prim", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "primitive" + ] + }, + "PrimMarkIndex": { + "inputs": [ + [ + "PrimitiveObject", + "prim", + "" + ], + [ + "string", + "tagAttr", + "index" + ], + [ + "enum int float", + "type", + "int" + ], + [ + "int", + "base", + "0" + ], + [ + "int", + "step", + "1" + ], + [ + "enum vert tri loop poly line", + "scope", + "vert" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "PrimitiveObject", + "prim", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "primitive" + ] + }, + "PrimMarkIsland": { + "inputs": [ + [ + "PrimitiveObject", + "prim", + "" + ], + [ + "string", + "tagAttr", + "tag" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "PrimitiveObject", + "prim", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "primitive" + ] + }, + "PrimMarkSameIf": { + "inputs": [ + [ + "PrimitiveObject", + "prim", + "" + ], + [ + "string", + "tagAttrIn", + "index" + ], + [ + "int", + "tagValueIs", + "0" + ], + [ + "string", + "tagAttrOut", + "weld" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "PrimitiveObject", + "prim", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "primitive" + ] + }, + "PrimMarkTrisIdx": { + "inputs": [ + [ + "", + "prim", + "" + ], + [ + "string", + "idxName", + "index" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "", + "prim", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "WBTest" + ] + }, + "PrimMatchUVLine": { + "inputs": [ + [ + "", + "prim", + "" + ], + [ + "", + "prim2", + "" + ], + [ + "string", + "uvAttr", + "tmp" + ], + [ + "string", + "uvAttr2", + "tmp" + ], + [ + "bool", + "copyOtherAttrs", + "1" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "", + "prim", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "primitive" + ] + }, + "PrimMerge": { + "inputs": [ + [ + "list", + "listPrim", + "" + ], + [ + "string", + "tagAttr", + "" + ], + [ + "enum vert face vert_face", + "tag_scope", + "vert" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "primitive", + "prim", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "primitive" + ] + }, + "PrimPerlinNoise": { + "inputs": [ + [ + "PrimitiveObject", + "prim", + "" + ], + [ + "string", + "inAttr", + "pos" + ], + [ + "string", + "outAttr", + "tmp" + ], + [ + "float", + "scale", + "" + ], + [ + "float", + "detail", + "" + ], + [ + "float", + "roughness", + "" + ], + [ + "float", + "disortion", + "" + ], + [ + "vec3f", + "offset", + "" + ], + [ + "float", + "average", + "" + ], + [ + "float", + "strength", + "" + ], + [ + "enum float vec3f", + "outType", + "float" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "PrimitiveObject", + "prim", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "primitive" + ] + }, + "PrimPointTris": { + "inputs": [ + [ + "", + "prim", + "" + ], + [ + "int", + "pointID", + "0" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "", + "list", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "WBTest" + ] + }, + "PrimProject": { + "inputs": [ + [ + "PrimitiveObject", + "prim", + "" + ], + [ + "PrimitiveObject", + "targetPrim", + "" + ], + [ + "string", + "nrmAttr", + "nrm" + ], + [ + "float", + "offset", + "" + ], + [ + "float", + "limit", + "" + ], + [ + "enum front back both", + "allowDir", + "both" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "PrimitiveObject", + "prim", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "primitive" + ] + }, + "PrimQuadsLotSubdivision": { + "inputs": [ + [ + "", + "input_quads_model", + "" + ], + [ + "int", + "num", + "1" + ], + [ + "bool", + "row_or_columns", + "0" + ], + [ + "bool", + "random_rc", + "0" + ], + [ + "int", + "random_seed", + "1" + ], + [ + "bool", + "rcrc", + "1" + ], + [ + "bool", + "first_second_same", + "1" + ], + [ + "int", + "same_seed", + "1" + ], + [ + "float", + "min_offset", + "" + ], + [ + "float", + "max_offset", + "" + ], + [ + "float", + "first_edge_minoffset", + "" + ], + [ + "float", + "first_edge_maxoffset", + "" + ], + [ + "int", + "first_seed", + "1" + ], + [ + "float", + "second_edge_minoffset", + "" + ], + [ + "float", + "second_edge_maxoffset", + "" + ], + [ + "int", + "second_seed", + "1" + ], + [ + "bool", + "add_attr", + "0" + ], + [ + "string", + "tag_attr", + "tag" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "", + "output", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "primitive" + ] + }, + "PrimRandomize": { + "inputs": [ + [ + "PrimitiveObject", + "prim", + "" + ], + [ + "string", + "attr", + "tmp" + ], + [ + "string", + "dirAttr", + "" + ], + [ + "string", + "seedAttr", + "" + ], + [ + "float", + "base", + "" + ], + [ + "float", + "scale", + "" + ], + [ + "int", + "seed", + "-1" + ], + [ + "enum scalar01 scalar11 cube01 cube11 plane01 plane11 disk cylinder ball semiball sphere semisphere", + "randType", + "scalar01" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "PrimitiveObject", + "prim", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "primitive" + ] + }, + "PrimReduction": { + "inputs": [ + [ + "", + "prim", + "" + ], + [ + "string", + "attrName", + "pos" + ], + [ + "enum avg max min absmax", + "op", + "avg" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "", + "result", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "primitive" + ] + }, + "PrimSample": { + "inputs": [ + [ + "PrimitiveObject", + "prim", + "" + ], + [ + "", + "sampledObject", + "" + ], + [ + "string", + "srcChannel", + "uv" + ], + [ + "string", + "dstChannel", + "clr" + ], + [ + "float", + "remapMin", + "" + ], + [ + "float", + "remapMax", + "" + ], + [ + "enum REPEAT CLAMP_TO_EDGE CLAMP_TO_BORDER", + "wrap", + "REPEAT" + ], + [ + "vec3f", + "borderColor", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "PrimitiveObject", + "outPrim", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "primitive" + ] + }, + "PrimSample1D": { + "inputs": [ + [ + "PrimitiveObject", + "prim", + "" + ], + [ + "", + "heatmap", + "" + ], + [ + "string", + "srcChannel", + "rho" + ], + [ + "string", + "dstChannel", + "clr" + ], + [ + "float", + "remapMin", + "" + ], + [ + "float", + "remapMax", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "PrimitiveObject", + "outPrim", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "primitive" + ] + }, + "PrimSample2D": { + "inputs": [ + [ + "PrimitiveObject", + "prim", + "" + ], + [ + "PrimitiveObject", + "image", + "" + ], + [ + "string", + "uvChannel", + "uv" + ], + [ + "enum vertex tris loopsuv", + "uvSource", + "vertex" + ], + [ + "string", + "targetChannel", + "clr" + ], + [ + "float", + "remapMin", + "" + ], + [ + "float", + "remapMax", + "" + ], + [ + "enum REPEAT CLAMP_TO_EDGE CLAMP_TO_BORDER", + "wrap", + "REPEAT" + ], + [ + "enum nearest linear", + "filter", + "nearest" + ], + [ + "vec3f", + "borderColor", + "" + ], + [ + "bool", + "invert U", + "0" + ], + [ + "bool", + "invert V", + "0" + ], + [ + "float", + "scale", + "" + ], + [ + "float", + "rotate", + "" + ], + [ + "vec2f", + "translate", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "PrimitiveObject", + "outPrim", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "primitive" + ] + }, + "PrimSample3D": { + "inputs": [ + [ + "PrimitiveObject", + "prim", + "" + ], + [ + "", + "vdbGrid", + "" + ], + [ + "string", + "srcChannel", + "pos" + ], + [ + "string", + "dstChannel", + "clr" + ], + [ + "float", + "remapMin", + "" + ], + [ + "float", + "remapMax", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "PrimitiveObject", + "outPrim", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "primitive" + ] + }, + "PrimScale": { + "inputs": [ + [ + "PrimitiveObject", + "prim", + "" + ], + [ + "vec3f", + "scale", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "PrimitiveObject", + "prim", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "primitive" + ] + }, + "PrimScatter": { + "inputs": [ + [ + "", + "prim", + "" + ], + [ + "enum tris lines", + "type", + "tris" + ], + [ + "string", + "denAttr", + "" + ], + [ + "float", + "density", + "" + ], + [ + "float", + "minRadius", + "" + ], + [ + "bool", + "interpAttrs", + "1" + ], + [ + "int", + "seed", + "-1" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "", + "parsPrim", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "primitive" + ] + }, + "PrimSepTriangles": { + "inputs": [ + [ + "primitive", + "prim", + "" + ], + [ + "bool", + "smoothNormal", + "1" + ], + [ + "bool", + "keepTriFaces", + "1" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "primitive", + "prim", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "primitive" + ] + }, + "PrimSetAttr": { + "inputs": [ + [ + "", + "prim", + "" + ], + [ + "int", + "value", + "0" + ], + [ + "string", + "name", + "index" + ], + [ + "enum float vec2f vec3f vec4f int vec2i vec3i vec4i", + "type", + "int" + ], + [ + "enum vert tri line loop poly", + "method", + "tri" + ], + [ + "int", + "index", + "0" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "", + "prim", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "erode" + ] + }, + "PrimSimplifyTag": { + "inputs": [ + [ + "PrimitiveObject", + "prim", + "" + ], + [ + "string", + "tagAttr", + "tag" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "PrimitiveObject", + "prim", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "primitive" + ] + }, + "PrimSmooth": { + "inputs": [ + [ + "PrimitiveObject", + "prim", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "PrimitiveObject", + "prim", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "primitive" + ] + }, + "PrimSort": { + "inputs": [ + [ + "PrimitiveObject", + "prim", + "" + ], + [ + "enum NoChange ByAttribute", + "Vertex Sort", + "NoChange" + ], + [ + "string", + "Attribute", + "index" + ], + [ + "bool", + "Reverse", + "0" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "PrimitiveObject", + "prim", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "primitive" + ] + }, + "PrimSplit": { + "inputs": [ + [ + "", + "prim", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "", + "prim", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "primitive" + ] + }, + "PrimSplitVertexForSharedNormal": { + "inputs": [ + [ + "", + "prim", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "", + "prim", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "primitive" + ] + }, + "PrimSprayParticles": { + "inputs": [ + [ + "", + "TrianglePrim", + "" + ], + [ + "float", + "Dx", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "", + "particlesPrim", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "primitive" + ] + }, + "PrimSuperFormula": { + "inputs": [ + [ + "int", + "segments", + "1000" + ], + [ + "float", + "scale", + "" + ], + [ + "float", + "a", + "" + ], + [ + "float", + "b", + "" + ], + [ + "float", + "m", + "" + ], + [ + "float", + "n1", + "" + ], + [ + "float", + "n2", + "" + ], + [ + "float", + "n3", + "" + ], + [ + "bool", + "hasLines", + "1" + ], + [ + "bool", + "close", + "1" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "", + "output", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "primitive" + ] + }, + "PrimToList": { + "inputs": [ + [ + "", + "prim", + "" + ], + [ + "enum verts points lines tris quads polys loops", + "type", + "verts" + ], + [ + "string", + "attr", + "pos" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "", + "list", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "primitive" + ] + }, + "PrimToVDBPointDataGrid": { + "inputs": [ + [ + "", + "ParticleGeo", + "" + ], + [ + "float", + "Dx", + "" + ], + [ + "", + "vdbPoints", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "", + "Particles", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "openvdb" + ] + }, + "PrimTranslate": { + "inputs": [ + [ + "PrimitiveObject", + "prim", + "" + ], + [ + "vec3f", + "offset", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "PrimitiveObject", + "prim", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "primitive" + ] + }, + "PrimTriPoints": { + "inputs": [ + [ + "", + "prim", + "" + ], + [ + "int", + "trisID", + "0" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "", + "points", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "WBTest" + ] + }, + "PrimTriangulateIntoPolys": { + "inputs": [ + [ + "primitive", + "prim", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "primitive", + "prim", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "primitive" + ] + }, + "PrimTwist": { + "inputs": [ + [ + "PrimitiveObject", + "prim", + "" + ], + [ + "vec3f", + "origin", + "" + ], + [ + "vec3f", + "direction", + "" + ], + [ + "", + "tangent", + "" + ], + [ + "float", + "angle", + "" + ], + [ + "float", + "limitMin", + "" + ], + [ + "float", + "limitMax", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "PrimitiveObject", + "prim", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "primitive" + ] + }, + "PrimUVEdgeDuplicate": { + "inputs": [ + [ + "", + "prim", + "" + ], + [ + "bool", + "writeUVToVertex", + "1" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "", + "prim", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "primitive" + ] + }, + "PrimUVVertsToLoopsuv": { + "inputs": [ + [ + "", + "prim", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "", + "prim", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "primitive" + ] + }, + "PrimUnmerge": { + "inputs": [ + [ + "primitive", + "prim", + "" + ], + [ + "string", + "tagAttr", + "tag" + ], + [ + "bool", + "preSimplify", + "0" + ], + [ + "enum verts faces", + "method", + "verts" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "list", + "listPrim", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "primitive" + ] + }, + "PrimUpdateFromList": { + "inputs": [ + [ + "", + "prim", + "" + ], + [ + "enum verts points lines tris quads polys loops", + "type", + "verts" + ], + [ + "string", + "attr", + "pos" + ], + [ + "", + "list", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "", + "prim", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "primitive" + ] + }, + "PrimVertsAttrToFaces": { + "inputs": [ + [ + "PrimitiveObject", + "prim", + "" + ], + [ + "enum lines tris quads polys", + "faceType", + "tris" + ], + [ + "string", + "vertAttr", + "tmp" + ], + [ + "string", + "faceAttr", + "tmp" + ], + [ + "enum sum average min max", + "method", + "average" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "PrimitiveObject", + "prim", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "primitive" + ] + }, + "PrimWeld": { + "inputs": [ + [ + "PrimitiveObject", + "prim", + "" + ], + [ + "string", + "tagAttr", + "weld" + ], + [ + "enum oneof average", + "method", + "oneof" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "PrimitiveObject", + "prim", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "primitive" + ] + }, + "PrimWireframe": { + "inputs": [ + [ + "PrimitiveObject", + "prim", + "" + ], + [ + "bool", + "removeFaces", + "1" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "PrimitiveObject", + "prim", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "primitive" + ] + }, + "Primcluster": { + "inputs": [ + [ + "", + "prim", + "" + ], + [ + "int", + "numberofcluster", + "10" + ], + [ + "int", + "seed", + "9" + ], + [ + "int", + "cutoff", + "5" + ], + [ + "int", + "maxiter", + "20" + ], + [ + "string", + "ControlAttr", + "pos" + ], + [ + "string", + "ClusterAttr", + "cluster" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "", + "prim", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "deprecated" + ] + }, + "PrimitiveAddAttr": { + "inputs": [ + [ + "", + "prim", + "" + ], + [ + "", + "fillValue", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [ + [ + "string", + "name", + "clr" + ], + [ + "string", + "pybisgreat", + "DEPRECATED! USE PrimFillAttr INSTEAD" + ], + [ + "enum float float3", + "type", + "float3" + ] + ], + "outputs": [ + [ + "", + "prim", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "deprecated" + ] + }, + "PrimitiveAttrFit": { + "inputs": [ + [ + "PrimitiveObject", + "prim", + "" + ], + [ + "PrimitiveObject", + "refPrim", + "" + ], + [ + "string", + "attrNameSrc", + "pos" + ], + [ + "string", + "attrNameDst", + "pos" + ], + [ + "string", + "refAttrNameSrc", + "pos" + ], + [ + "string", + "refAttrNameDst", + "pos" + ], + [ + "float", + "limitMin", + "" + ], + [ + "float", + "limitMax", + "" + ], + [ + "enum X Y Z", + "axisSrc", + "X" + ], + [ + "enum X Y Z", + "axisDst", + "Y" + ], + [ + "enum X Y Z", + "refAxisSrc", + "X" + ], + [ + "enum X Y Z", + "refAxisDst", + "Y" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [ + [ + "bool", + "autoMinMax", + "1" + ], + [ + "bool", + "autoSort", + "1" + ] + ], + "outputs": [ + [ + "PrimitiveObject", + "prim", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "primitive" + ] + }, + "PrimitiveAttrPicker": { + "inputs": [ + [ + "PrimitiveObject", + "prim", + "" + ], + [ + "enum point line triangle", + "mode", + "point" + ], + [ + "string", + "newAttr", + "" + ], + [ + "float", + "attrVal", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [ + [ + "string", + "selected", + "" + ] + ], + "outputs": [ + [ + "PrimitiveObject", + "outPrim", + "" + ], + [ + "", + "list", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "primitive" + ] + }, + "PrimitiveBent": { + "inputs": [ + [ + "PrimitiveObject", + "prim", + "" + ], + [ + "vec3f", + "origin", + "" + ], + [ + "vec3f", + "tangent", + "" + ], + [ + "vec3f", + "direction", + "" + ], + [ + "float", + "angle", + "" + ], + [ + "float", + "limitMin", + "" + ], + [ + "float", + "limitMax", + "" + ], + [ + "float", + "midPoint", + "" + ], + [ + "float", + "biasDir", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [ + [ + "bool", + "useOrigin", + "0" + ] + ], + "outputs": [ + [ + "PrimitiveObject", + "prim", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "deprecated" + ] + }, + "PrimitiveBinaryOp": { + "inputs": [ + [ + "", + "primA", + "" + ], + [ + "", + "primB", + "" + ], + [ + "", + "primOut", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [ + [ + "string", + "attrA", + "pos" + ], + [ + "string", + "attrB", + "pos" + ], + [ + "string", + "attrOut", + "pos" + ], + [ + "string", + "op", + "copyA" + ] + ], + "outputs": [ + [ + "", + "primOut", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "deprecated" + ] + }, + "PrimitiveBoundingBox": { + "inputs": [ + [ + "PrimitiveObject", + "prim", + "" + ], + [ + "float", + "exWidth", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "vec3f", + "bmin", + "" + ], + [ + "vec3f", + "bmax", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "primitive" + ] + }, + "PrimitiveCalcCentroid": { + "inputs": [ + [ + "PrimitiveObject", + "prim", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [ + [ + "enum Volume Area Vertex", + "method", + "Volume" + ] + ], + "outputs": [ + [ + "vec3f", + "centroid", + "" + ], + [ + "float", + "totalArea", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "deprecated" + ] + }, + "PrimitiveCalcNormal": { + "inputs": [ + [ + "", + "prim", + "" + ], + [ + "string", + "nrmAttr", + "nrm" + ], + [ + "bool", + "flip", + "0" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "", + "prim", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "primitive" + ] + }, + "PrimitiveCalcVelocity": { + "inputs": [ + [ + "PrimitiveObject", + "prim", + "" + ], + [ + "float", + "dt", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "PrimitiveObject", + "prim", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "primitive" + ] + }, + "PrimitiveClearConnect": { + "inputs": [ + [ + "", + "prim", + "" + ], + [ + "enum edges faces tris quads polys points all", + "type", + "all" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "", + "prim", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "primitive" + ] + }, + "PrimitiveClip": { + "inputs": [ + [ + "PrimitiveObject", + "prim", + "" + ], + [ + "vec3f", + "origin", + "" + ], + [ + "vec3f", + "direction", + "" + ], + [ + "float", + "distance", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [ + [ + "bool", + "reverse", + "0" + ] + ], + "outputs": [ + [ + "PrimitiveObject", + "outPrim", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "primitive" + ] + }, + "PrimitiveColorByHeatmap": { + "inputs": [ + [ + "", + "prim", + "" + ], + [ + "", + "attrName2", + "" + ], + [ + "", + "heatmap", + "" + ], + [ + "float", + "min", + "" + ], + [ + "float", + "max", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [ + [ + "string", + "attrName", + "rho" + ] + ], + "outputs": [ + [ + "", + "prim", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "visualize" + ] + }, + "PrimitiveCurvemap": { + "inputs": [ + [ + "PrimitiveObject", + "prim", + "" + ], + [ + "", + "curvemap", + "" + ], + [ + "string", + "attrName", + "pos" + ], + [ + "int", + "sourceX", + "0" + ], + [ + "int", + "sourceY", + "1" + ], + [ + "int", + "sourceZ", + "2" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "PrimitiveObject", + "prim", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "primitive" + ] + }, + "PrimitiveDelAttr": { + "inputs": [ + [ + "", + "prim", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [ + [ + "string", + "name", + "nrm" + ] + ], + "outputs": [ + [ + "", + "prim", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "deprecated" + ] + }, + "PrimitiveDelAttrs": { + "inputs": [ + [ + "", + "prim", + "" + ], + [ + "bool", + "invert", + "0" + ], + [ + "string", + "names", + "name_1 name_2" + ], + [ + "enum vert tri loop poly line all", + "scope", + "all" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "", + "prim", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "erode" + ] + }, + "PrimitiveDuplicate": { + "inputs": [ + [ + "", + "meshPrim", + "" + ], + [ + "", + "particlesPrim", + "" + ], + [ + "float", + "uniScale", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [ + [ + "bool", + "attrFromMesh", + "1" + ], + [ + "bool", + "attrFromParticles", + "1" + ], + [ + "string", + "scaleByAttr", + "" + ] + ], + "outputs": [ + [ + "", + "outPrim", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "deprecated" + ] + }, + "PrimitiveFaceToEdges": { + "inputs": [ + [ + "", + "prim", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [ + [ + "bool", + "clearFaces", + "1" + ] + ], + "outputs": [ + [ + "", + "prim", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "deprecated" + ] + }, + "PrimitiveFarSimpleLines": { + "inputs": [ + [ + "", + "prim", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "", + "prim", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "primitive" + ] + }, + "PrimitiveFillAttr": { + "inputs": [ + [ + "", + "prim", + "" + ], + [ + "NumericObject", + "value", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [ + [ + "string", + "attrName", + "pos" + ], + [ + "enum float float3 none", + "attrType", + "none" + ] + ], + "outputs": [ + [ + "", + "prim", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "deprecated" + ] + }, + "PrimitiveFilterByAttr": { + "inputs": [ + [ + "", + "prim", + "" + ], + [ + "NumericObject", + "value", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [ + [ + "enum cmpgt cmplt cmpge cmple cmpeq cmpne", + "acceptIf", + "cmpgt" + ], + [ + "string", + "attrName", + "rad" + ], + [ + "bool", + "mockTopos", + "1" + ], + [ + "enum any all", + "vecSelType", + "all" + ] + ], + "outputs": [ + [ + "", + "prim", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "primitive" + ] + }, + "PrimitiveFlipPoly": { + "inputs": [ + [ + "", + "prim", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "", + "primOut", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "deprecated" + ] + }, + "PrimitiveGetAttrValue": { + "inputs": [ + [ + "", + "prim", + "" + ], + [ + "int", + "index", + "0" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [ + [ + "string", + "name", + "pos" + ], + [ + "enum float float3", + "type", + "float3" + ] + ], + "outputs": [ + [ + "", + "value", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "deprecated" + ] + }, + "PrimitiveGetFaceCount": { + "inputs": [ + [ + "", + "prim", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "", + "size", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "primitive" + ] + }, + "PrimitiveGetSize": { + "inputs": [ + [ + "", + "prim", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "", + "size", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "primitive" + ] + }, + "PrimitiveHalfBinaryOp": { + "inputs": [ + [ + "", + "primA", + "" + ], + [ + "", + "valueB", + "" + ], + [ + "", + "primOut", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [ + [ + "string", + "attrA", + "pos" + ], + [ + "string", + "attrOut", + "pos" + ], + [ + "string", + "op", + "copyA" + ] + ], + "outputs": [ + [ + "", + "primOut", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "deprecated" + ] + }, + "PrimitiveInterpSubframe": { + "inputs": [ + [ + "PrimitiveObject", + "prim", + "" + ], + [ + "float", + "portion", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "PrimitiveObject", + "prim", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "primitive" + ] + }, + "PrimitiveLineDistance": { + "inputs": [ + [ + "PrimitiveObject", + "prim", + "" + ], + [ + "string", + "resAttr", + "len" + ], + [ + "int", + "start", + "0" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "PrimitiveObject", + "prim", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "primitive" + ] + }, + "PrimitiveLineSimpleLink": { + "inputs": [ + [ + "PrimitiveObject", + "prim", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "PrimitiveObject", + "prim", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "primitive" + ] + }, + "PrimitiveLineSolidify": { + "inputs": [ + [ + "PrimitiveObject", + "prim", + "" + ], + [ + "int", + "count", + "4" + ], + [ + "float", + "radius", + "" + ], + [ + "string", + "radiusAttr", + "" + ], + [ + "bool", + "isTri", + "1" + ], + [ + "bool", + "sealEnd", + "1" + ], + [ + "bool", + "closeRing", + "0" + ], + [ + "bool", + "lineSort", + "1" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "PrimitiveObject", + "prim", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "primitive" + ] + }, + "PrimitiveLineSort": { + "inputs": [ + [ + "PrimitiveObject", + "prim", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [ + [ + "bool", + "reversed", + "0" + ] + ], + "outputs": [ + [ + "PrimitiveObject", + "prim", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "primitive" + ] + }, + "PrimitiveMerge": { + "inputs": [ + [ + "", + "listPrim", + "" + ], + [ + "", + "dst", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "", + "prim", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "deprecated" + ] + }, + "PrimitiveMix": { + "inputs": [ + [ + "", + "primA", + "" + ], + [ + "", + "primB", + "" + ], + [ + "", + "primOut", + "" + ], + [ + "", + "coef", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [ + [ + "string", + "attrA", + "pos" + ], + [ + "string", + "attrB", + "pos" + ], + [ + "string", + "attrOut", + "pos" + ] + ], + "outputs": [ + [ + "", + "primOut", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "deprecated" + ] + }, + "PrimitiveNearSimpleLines": { + "inputs": [ + [ + "", + "prim", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "", + "prim", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "primitive" + ] + }, + "PrimitiveOrderVertexByNormal": { + "inputs": [ + [ + "", + "prim", + "" + ], + [ + "string", + "nrmAttr", + "nrm" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "", + "prim", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "primitive" + ] + }, + "PrimitivePerlinNoiseAttr": { + "inputs": [ + [ + "", + "prim", + "" + ], + [ + "", + "seed", + "" + ], + [ + "float", + "freq", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [ + [ + "string", + "attrName", + "noise" + ], + [ + "enum float float3", + "attrType", + "float3" + ] + ], + "outputs": [ + [ + "", + "prim", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "noise" + ] + }, + "PrimitivePolygonate": { + "inputs": [ + [ + "primitive", + "prim", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [ + [ + "bool", + "with_uv", + "1" + ] + ], + "outputs": [ + [ + "primitive", + "prim", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "primitive" + ] + }, + "PrimitivePrintAttr": { + "inputs": [ + [ + "", + "prim", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [ + [ + "string", + "attrName", + "pos" + ] + ], + "outputs": [ + [ + "", + "prim", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "deprecated" + ] + }, + "PrimitiveRandomAttr": { + "inputs": [ + [ + "", + "prim", + "" + ], + [ + "NumericObject", + "min", + "" + ], + [ + "NumericObject", + "max", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [ + [ + "string", + "attrName", + "pos" + ], + [ + "enum float float3", + "attrType", + "" + ] + ], + "outputs": [ + [ + "", + "prim", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "deprecated" + ] + }, + "PrimitiveRandomizeAttr": { + "inputs": [ + [ + "", + "prim", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [ + [ + "string", + "attrName", + "pos" + ], + [ + "enum float float3", + "attrType", + "float3" + ], + [ + "float", + "max", + "" + ], + [ + "float", + "maxY", + "" + ], + [ + "float", + "maxZ", + "" + ], + [ + "float", + "min", + "" + ], + [ + "float", + "minY", + "" + ], + [ + "float", + "minZ", + "" + ] + ], + "outputs": [ + [ + "", + "prim", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "deprecated" + ] + }, + "PrimitiveReduction": { + "inputs": [ + [ + "", + "prim", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [ + [ + "string", + "attr", + "pos" + ], + [ + "enum avg max min absmax", + "op", + "avg" + ] + ], + "outputs": [ + [ + "", + "result", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "deprecated" + ] + }, + "PrimitiveResize": { + "inputs": [ + [ + "", + "prim", + "" + ], + [ + "", + "size", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "", + "prim", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "primitive" + ] + }, + "PrimitiveScale": { + "inputs": [ + [ + "PrimitiveObject", + "prim", + "" + ], + [ + "vec3f", + "origin", + "" + ], + [ + "vec3f", + "axis", + "" + ], + [ + "float", + "scale", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "PrimitiveObject", + "prim", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "primitive" + ] + }, + "PrimitiveScatter": { + "inputs": [ + [ + "PrimitiveObject", + "prim", + "" + ], + [ + "int", + "npoints", + "100" + ], + [ + "int", + "seed", + "0" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [ + [ + "enum tris lines", + "type", + "tris" + ] + ], + "outputs": [ + [ + "PrimitiveObject", + "points", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "primitive" + ] + }, + "PrimitiveSetAttrValue": { + "inputs": [ + [ + "", + "prim", + "" + ], + [ + "int", + "index", + "0" + ], + [ + "float", + "value", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [ + [ + "string", + "name", + "pos" + ], + [ + "enum float float3", + "type", + "float3" + ] + ], + "outputs": [ + [ + "", + "prim", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "deprecated" + ] + }, + "PrimitiveSimpleLines": { + "inputs": [ + [ + "", + "prim", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "", + "prim", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "primitive" + ] + }, + "PrimitiveSimplePoints": { + "inputs": [ + [ + "", + "prim", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "", + "prim", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "primitive" + ] + }, + "PrimitiveSimpleQuads": { + "inputs": [ + [ + "", + "prim", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "", + "prim", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "primitive" + ] + }, + "PrimitiveSimpleTris": { + "inputs": [ + [ + "", + "prim", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "", + "prim", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "primitive" + ] + }, + "PrimitiveSplitEdges": { + "inputs": [ + [ + "", + "prim", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "", + "prim", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "deprecated" + ] + }, + "PrimitiveToSDF": { + "inputs": [ + [ + "", + "PrimitiveMesh", + "" + ], + [ + "float", + "Dx", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [ + [ + "enum vertex cell", + "type", + "vertex" + ] + ], + "outputs": [ + [ + "", + "sdf", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "openvdb" + ] + }, + "PrimitiveTraceTrail": { + "inputs": [ + [ + "PrimitiveObject", + "parsPrim", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "PrimitiveObject", + "trailPrim", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "primitive" + ] + }, + "PrimitiveTransform": { + "inputs": [ + [ + "PrimitiveObject", + "prim", + "" + ], + [ + "string", + "path", + "" + ], + [ + "vec3f", + "translation", + "" + ], + [ + "vec3f", + "eulerXYZ", + "" + ], + [ + "vec4f", + "quatRotation", + "" + ], + [ + "vec3f", + "scaling", + "" + ], + [ + "vec3f", + "shear", + "" + ], + [ + "enum world bboxCenter custom", + "pivot", + "bboxCenter" + ], + [ + "vec3f", + "pivotPos", + "" + ], + [ + "", + "Matrix", + "" + ], + [ + "", + "preTransform", + "" + ], + [ + "", + "local", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [ + [ + "enum Degree Radians", + "EulerAngleMeasure", + "Degree" + ], + [ + "enum XYZ XZY YXZ YZX ZXY ZYX", + "EulerRotationOrder", + "YXZ" + ] + ], + "outputs": [ + [ + "PrimitiveObject", + "outPrim", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "primitive" + ] + }, + "PrimitiveTriangulate": { + "inputs": [ + [ + "primitive", + "prim", + "" + ], + [ + "bool", + "with_attr", + "1" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [ + [ + "bool", + "from_poly", + "1" + ], + [ + "bool", + "from_quads", + "1" + ], + [ + "bool", + "has_lines", + "1" + ], + [ + "bool", + "with_uv", + "1" + ] + ], + "outputs": [ + [ + "primitive", + "prim", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "primitive" + ] + }, + "PrimitiveTwist": { + "inputs": [ + [ + "PrimitiveObject", + "prim", + "" + ], + [ + "vec3f", + "origin", + "" + ], + [ + "vec3f", + "direction", + "" + ], + [ + "", + "tangent", + "" + ], + [ + "float", + "angle", + "" + ], + [ + "float", + "limitMin", + "" + ], + [ + "float", + "limitMax", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "PrimitiveObject", + "prim", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "deprecated" + ] + }, + "PrimitiveUnaryOp": { + "inputs": [ + [ + "", + "primA", + "" + ], + [ + "", + "primOut", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [ + [ + "string", + "attrA", + "pos" + ], + [ + "string", + "attrOut", + "pos" + ], + [ + "string", + "op", + "copy" + ] + ], + "outputs": [ + [ + "", + "primOut", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "deprecated" + ] + }, + "PrimitiveWireframe": { + "inputs": [ + [ + "PrimitiveObject", + "prim", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [ + [ + "bool", + "removeFaces", + "1" + ] + ], + "outputs": [ + [ + "PrimitiveObject", + "prim", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "deprecated" + ] + }, + "PrimsFilterInUserdata": { + "inputs": [ + [ + "list", + "list", + "" + ], + [ + "string", + "name", + "" + ], + [ + "string", + "filters", + "" + ], + [ + "bool", + "contain", + "1" + ], + [ + "bool", + "fuzzy", + "0" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "list", + "out", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "alembic" + ] + }, + "PrintMessage": { + "inputs": [ + [ + "", + "SRC", + "" + ] + ], + "params": [ + [ + "string", + "message", + "hello-stdout" + ] + ], + "outputs": [ + [ + "", + "DST", + "" + ] + ], + "categories": [ + "debug" + ] + }, + "PrintMessageStdErr": { + "inputs": [ + [ + "", + "SRC", + "" + ] + ], + "params": [ + [ + "string", + "message", + "hello-stderr" + ] + ], + "outputs": [ + [ + "", + "DST", + "" + ] + ], + "categories": [ + "debug" + ] + }, + "PrintNumeric": { + "inputs": [ + [ + "NumericObject", + "value", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [ + [ + "string", + "hint", + "PrintNumeric" + ] + ], + "outputs": [ + [ + "NumericObject", + "value", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "numeric" + ] + }, + "PrintString": { + "inputs": [ + [ + "string", + "str", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "", + "DST", + "" + ] + ], + "categories": [ + "string" + ] + }, + "ProceduralSky": { + "inputs": [ + [ + "vec2f", + "sunLightDir", + "" + ], + [ + "float", + "sunLightSoftness", + "" + ], + [ + "float", + "sunLightIntensity", + "" + ], + [ + "float", + "colorTemperatureMix", + "" + ], + [ + "float", + "colorTemperature", + "" + ], + [ + "vec2f", + "windDir", + "" + ], + [ + "float", + "timeStart", + "" + ], + [ + "float", + "timeSpeed", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "", + "ProceduralSky", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "shader" + ] + }, + "ProjectAndNormalize": { + "inputs": [ + [ + "vec3f", + "vec", + "" + ], + [ + "enum XY YX YZ ZY ZX XZ", + "plane", + "XY" + ], + [ + "float", + "directionScale", + "" + ], + [ + "float", + "lengthScale", + "" + ], + [ + "float", + "heightScale", + "" + ], + [ + "float", + "heightOffset", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "vec3f", + "direction", + "" + ], + [ + "float", + "length", + "" + ], + [ + "float", + "height", + "" + ], + [ + "float", + "phase", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "math" + ] + }, + "QuatAngleAxis": { + "inputs": [ + [ + "float", + "angle(D)", + "" + ], + [ + "vec3f", + "axis", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "vec4f", + "quat", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "quat" + ] + }, + "QuatGetAngle": { + "inputs": [ + [ + "vec4f", + "quat", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "float", + "angle(D)", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "quat" + ] + }, + "QuatGetAxis": { + "inputs": [ + [ + "vec4f", + "quat", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "vec3f", + "axis", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "quat" + ] + }, + "QuatRotBetweenVectors": { + "inputs": [ + [ + "vec3f", + "start", + "" + ], + [ + "vec3f", + "dest", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "vec4f", + "quat", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "quat" + ] + }, + "QuatRotate": { + "inputs": [ + [ + "vec4f", + "quat", + "" + ], + [ + "vec3f", + "vec3", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "vec3f", + "vec3", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "quat" + ] + }, + "QueryNearestPrimitive": { + "inputs": [ + [ + "", + "prim", + "" + ], + [ + "LBvh", + "lbvh", + "" + ], + [ + "string", + "idTag", + "bvh_id" + ], + [ + "string", + "distTag", + "bvh_dist" + ], + [ + "string", + "closestPointTag", + "cp" + ], + [ + "string", + "weightTag", + "bvh_ws" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "NumericObject", + "primid", + "" + ], + [ + "NumericObject", + "bvh_primid", + "" + ], + [ + "NumericObject", + "dist", + "" + ], + [ + "PrimitiveObject", + "bvh_prim", + "" + ], + [ + "PrimitiveObject", + "segment", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "zenofx" + ] + }, + "QueryNearestPrimitiveWithUV": { + "inputs": [ + [ + "", + "prim", + "" + ], + [ + "LBvh", + "lbvh", + "" + ], + [ + "string", + "idTag", + "bvh_id" + ], + [ + "string", + "distTag", + "bvh_dist" + ], + [ + "string", + "closestPointTag", + "cp" + ], + [ + "string", + "weightTag", + "bvh_ws" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "NumericObject", + "primid", + "" + ], + [ + "NumericObject", + "bvh_primid", + "" + ], + [ + "NumericObject", + "dist", + "" + ], + [ + "PrimitiveObject", + "bvh_prim", + "" + ], + [ + "PrimitiveObject", + "segment", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "zenofx" + ] + }, + "QueryNearestPrimitiveWithinGroup": { + "inputs": [ + [ + "", + "prim", + "" + ], + [ + "LBvh", + "lbvh", + "" + ], + [ + "string", + "groupTag", + "island_index" + ], + [ + "string", + "idTag", + "bvh_id" + ], + [ + "string", + "distTag", + "bvh_dist" + ], + [ + "string", + "closestPointTag", + "cp" + ], + [ + "string", + "weightTag", + "bvh_ws" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "NumericObject", + "primid", + "" + ], + [ + "NumericObject", + "bvh_primid", + "" + ], + [ + "NumericObject", + "dist", + "" + ], + [ + "PrimitiveObject", + "bvh_prim", + "" + ], + [ + "PrimitiveObject", + "segment", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "zenofx" + ] + }, + "RadtoDegree": { + "inputs": [ + [ + "float", + "radian", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "float", + "degree", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "math" + ] + }, + "ReadAlembic": { + "inputs": [ + [ + "readpath", + "path", + "" + ], + [ + "bool", + "read_face_set", + "1" + ], + [ + "bool", + "outOfRangeAsEmpty", + "0" + ], + [ + "bool", + "skipInvisibleObject", + "1" + ], + [ + "", + "frameid", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "ABCTree", + "abctree", + "" + ], + [ + "", + "namelist", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "alembic" + ] + }, + "ReadCustomVAT": { + "inputs": [ + [ + "", + "frameid", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [ + [ + "readpath", + "path", + "" + ] + ], + "outputs": [ + [ + "", + "prim", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "primitive" + ] + }, + "ReadFBXPrim": { + "inputs": [ + [ + "readpath", + "path", + "" + ], + [ + "readpath", + "hintPath", + "-1" + ], + [ + "bool", + "generate", + "0" + ], + [ + "float", + "offset", + "" + ], + [ + "DictObject", + "visibility", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [ + [ + "bool", + "indepData", + "0" + ], + [ + "bool", + "primitive", + "0" + ], + [ + "bool", + "printTree", + "0" + ], + [ + "bool", + "triangulate", + "0" + ], + [ + "enum ENABLE DISABLE", + "udim", + "DISABLE" + ] + ], + "outputs": [ + [ + "", + "prim", + "" + ], + [ + "", + "data", + "" + ], + [ + "dict", + "datas", + "" + ], + [ + "dict", + "mats", + "" + ], + [ + "", + "animinfo", + "" + ], + [ + "", + "nodetree", + "" + ], + [ + "", + "bonetree", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "FBX" + ] + }, + "ReadImageFile": { + "inputs": [ + [ + "readpath", + "path", + "" + ], + [ + "bool", + "Linearize Non-linear Images", + "1" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "PrimitiveObject", + "image", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "deprecated" + ] + }, + "ReadImageFile_v2": { + "inputs": [ + [ + "readpath", + "path", + "" + ], + [ + "bool", + "srgb_to_linear", + "0" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "PrimitiveObject", + "image", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "comp" + ] + }, + "ReadJson": { + "inputs": [ + [ + "readpath", + "path", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "", + "json", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "json" + ] + }, + "ReadJsonFromString": { + "inputs": [ + [ + "string", + "content", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "", + "json", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "json" + ] + }, + "ReadLightFromFile": { + "inputs": [ + [ + "readpath", + "path", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "", + "posList", + "" + ], + [ + "", + "rotList", + "" + ], + [ + "", + "sclList", + "" + ], + [ + "", + "colList", + "" + ], + [ + "", + "intList", + "" + ], + [ + "", + "expList", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "FBX" + ] + }, + "ReadObjPrim": { + "inputs": [ + [ + "readpath", + "path", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [ + [ + "bool", + "triangulate", + "1" + ] + ], + "outputs": [ + [ + "primitive", + "prim", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "primitive" + ] + }, + "ReadObjPrimitive": { + "inputs": [ + [ + "readpath", + "path", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "", + "prim", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "deprecated" + ] + }, + "ReadObjPrimitiveDict": { + "inputs": [ + [ + "readpath", + "path", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "", + "prim", + "" + ], + [ + "", + "dict", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "primitive" + ] + }, + "ReadPNG16": { + "inputs": [ + [ + "readpath", + "path", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "PrimitiveObject", + "image", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "comp" + ] + }, + "ReadSTL": { + "inputs": [ + [ + "readpath", + "path", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "", + "prim", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "BaseIO" + ] + }, + "ReadVATFile": { + "inputs": [ + [ + "readpath", + "path", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "PrimitiveObject", + "image", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "primitive" + ] + }, + "ReadVDB": { + "inputs": [ + [ + "readpath", + "path", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "", + "data", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "openvdb" + ] + }, + "ReadVDBGrid": { + "inputs": [ + [ + "", + "SRC", + "" + ] + ], + "params": [ + [ + "readpath", + "path", + "" + ], + [ + "string", + "type", + "" + ] + ], + "outputs": [ + [ + "", + "data", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "deprecated" + ] + }, + "RefitPrimitiveBvh": { + "inputs": [ + [ + "LBvh", + "lbvh", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "LBvh", + "lbvh", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "zenofx" + ] + }, + "RematchBestPrimitiveUV": { + "inputs": [ + [ + "PrimitiveObject", + "prim", + "" + ], + [ + "LBvh", + "lbvh", + "" + ], + [ + "float", + "threshold", + "" + ], + [ + "string", + "selection_tag", + "selected" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "PrimitiveObject", + "prim", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "zenofx" + ] + }, + "RemoveFolder": { + "inputs": [ + [ + "directory", + "folderPath", + "" + ], + [ + "bool", + "clean", + "0" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "", + "DST", + "" + ] + ], + "categories": [ + "create" + ] + }, + "ResampleVDBGrid": { + "inputs": [ + [ + "", + "resampleTo", + "" + ], + [ + "", + "resampleFrom", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "", + "resampleTo", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "openvdb" + ] + }, + "ResizeList": { + "inputs": [ + [ + "", + "list", + "" + ], + [ + "int", + "newSize", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "", + "list", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "list" + ] + }, + "Route": { + "inputs": [ + [ + "", + "input", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "", + "output", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "layout" + ] + }, + "SDFAdvect": { + "inputs": [ + [ + "", + "InoutSDF", + "" + ], + [ + "", + "VecField", + "" + ], + [ + "float", + "TimeStep", + "" + ], + [ + "enum Order_1 Order_2 Order_3 Order_5_WENO Order_5_HJ_WENO", + "SpatialScheme", + "Order_5_HJ_WENO" + ], + [ + "enum Explicit_Euler Order_2_Runge_Kuta Order_3_Runge_Kuta", + "TemporalScheme", + "Order_2_Runge_Kuta" + ], + [ + "int", + "RenormalizeStep", + "3" + ], + [ + "enum Order_1 Order_2 Order_3 Order_5_WENO Order_5_HJ_WENO", + "TrackerSpatialScheme", + "Order_5_HJ_WENO" + ], + [ + "enum Explicit_Euler Order_2_Runge_Kuta Order_3_Runge_Kuta", + "TrackerTemporalScheme", + "Explicit_Euler" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "", + "InoutSDF", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "openvdb" + ] + }, + "SDFScatterPoints": { + "inputs": [ + [ + "", + "SDF", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "", + "Points", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "openvdb" + ] + }, + "SDFToFog": { + "inputs": [ + [ + "", + "SDF", + "" + ], + [ + "bool", + "inplace", + "0" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "", + "oSDF", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "openvdb" + ] + }, + "SDFToPoly": { + "inputs": [ + [ + "", + "SDF", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [ + [ + "float", + "adaptivity", + "" + ], + [ + "bool", + "allowQuads", + "0" + ], + [ + "float", + "isoValue", + "" + ] + ], + "outputs": [ + [ + "", + "Mesh", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "deprecated" + ] + }, + "SDFToPrim": { + "inputs": [ + [ + "", + "SDF", + "" + ], + [ + "float", + "isoValue", + "" + ], + [ + "float", + "adaptivity", + "" + ], + [ + "bool", + "allowQuads", + "0" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "", + "prim", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "openvdb" + ] + }, + "SDFToPrimitive": { + "inputs": [ + [ + "", + "SDF", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [ + [ + "float", + "adaptivity", + "" + ], + [ + "bool", + "allowQuads", + "0" + ], + [ + "float", + "isoValue", + "" + ] + ], + "outputs": [ + [ + "", + "prim", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "deprecated" + ] + }, + "SampleVDBToPrimitive": { + "inputs": [ + [ + "", + "prim", + "" + ], + [ + "", + "vdbGrid", + "" + ], + [ + "string", + "sampleBy", + "pos" + ], + [ + "string", + "primAttr", + "sdf" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [ + [ + "enum Clamp Periodic", + "SampleType", + "Clamp" + ] + ], + "outputs": [ + [ + "", + "prim", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "openvdb" + ] + }, + "ScalarFieldAnalyzer": { + "inputs": [ + [ + "", + "InVDB", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [ + [ + "enum Gradient Curvature Laplacian ClosestPoint", + "Operator", + "Gradient" + ] + ], + "outputs": [ + [ + "", + "OutVDB", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "openvdb" + ] + }, + "ScreenSpaceProjectedGrid": { + "inputs": [ + [ + "", + "cam", + "" + ], + [ + "int", + "width", + "1920" + ], + [ + "int", + "height", + "1080" + ], + [ + "int", + "u_padding", + "0" + ], + [ + "int", + "v_padding", + "0" + ], + [ + "float", + "sea_level", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "", + "prim", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "shader" + ] + }, + "SetABCPath": { + "inputs": [ + [ + "", + "prim", + "" + ], + [ + "string", + "abcpathName", + "/ABC/your_path" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "", + "out", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "alembic" + ] + }, + "SetFaceset": { + "inputs": [ + [ + "", + "prim", + "" + ], + [ + "string", + "facesetName", + "defFS" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "", + "out", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "alembic" + ] + }, + "SetFrameTime": { + "inputs": [ + [ + "", + "time", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "", + "DST", + "" + ] + ], + "categories": [ + "frame" + ] + }, + "SetInstancing": { + "inputs": [ + [ + "primitive", + "prim", + "" + ], + [ + "instancing", + "inst", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "primitive", + "prim", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "shader" + ] + }, + "SetMaterial": { + "inputs": [ + [ + "primitive", + "prim", + "" + ], + [ + "material", + "mtl", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "primitive", + "prim", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "deprecated" + ] + }, + "SetMatrix": { + "inputs": [ + [ + "", + "dst", + "" + ], + [ + "", + "src", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "", + "DST", + "" + ] + ], + "categories": [ + "math" + ] + }, + "SetPhysicalCamera": { + "inputs": [ + [ + "", + "camera", + "" + ], + [ + "float", + "aperture", + "" + ], + [ + "float", + "shutter_speed", + "" + ], + [ + "float", + "iso", + "" + ], + [ + "bool", + "aces", + "0" + ], + [ + "bool", + "exposure", + "0" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "CameraObject", + "camera", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "shader" + ] + }, + "SetPrimInvisible": { + "inputs": [ + [ + "", + "prim", + "" + ], + [ + "bool", + "invisible", + "1" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "", + "out", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "shader" + ] + }, + "SetRandomSeed": { + "inputs": [ + [ + "", + "routeIn", + "" + ], + [ + "int", + "seed", + "0" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "", + "routeOut", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "deprecated" + ] + }, + "SetUserData": { + "inputs": [ + [ + "", + "object", + "" + ], + [ + "", + "data", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [ + [ + "string", + "key", + "" + ] + ], + "outputs": [ + [ + "", + "object", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "deprecated" + ] + }, + "SetUserData2": { + "inputs": [ + [ + "", + "object", + "" + ], + [ + "string", + "key", + "" + ], + [ + "string", + "data", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "", + "object", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "lifecycle" + ] + }, + "SetVDBGridClass": { + "inputs": [ + [ + "", + "grid", + "" + ], + [ + "enum UNKNOWN LEVEL_SET FOG_VOLUME STAGGERED", + "VDBGridClass", + "LEVEL_SET" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "", + "grid", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "openvdb" + ] + }, + "SetVDBGridName": { + "inputs": [ + [ + "", + "grid", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [ + [ + "string", + "name", + "density" + ] + ], + "outputs": [ + [ + "", + "grid", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "openvdb" + ] + }, + "SetVDBPointDataGrid": { + "inputs": [ + [ + "", + "ParticleGeo", + "" + ], + [ + "float", + "Dx", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [ + [ + "float", + "dx", + "" + ] + ], + "outputs": [ + [ + "", + "Particles", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "deprecated" + ] + }, + "ShaderBinaryMath": { + "inputs": [ + [ + "float", + "in1", + "" + ], + [ + "float", + "in2", + "" + ], + [ + "enum add sub mul div mod pow atan2 min max dot cross distance safepower step", + "op", + "add" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "float", + "out", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "shader" + ] + }, + "ShaderBlendMode": { + "inputs": [ + [ + "float", + "base", + "" + ], + [ + "float", + "blend", + "" + ], + [ + "float", + "opacity", + "" + ], + [ + "enum add average colorBurn colorDodge darken difference exclusion glow hardLight hardMix lighten linearBurn linearDodge linearLight multiply negation normal overlay phoenix pinLight reflect screen softLight subtract vividLight", + "mode", + "normal" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "shader", + "out", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "shader" + ] + }, + "ShaderCihouUnrealEngine": { + "inputs": [ + [ + "MaterialObject", + "mtl", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "string", + "code", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "shader" + ] + }, + "ShaderCustomFunc": { + "inputs": [ + [ + "string", + "args", + "vec3 arg1, vec3 arg2" + ], + [ + "enum float vec2 vec3 vec4", + "rettype", + "vec3" + ], + [ + "string", + "code", + "return arg1 + arg2;" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "ShaderCustomFuncObject", + "func", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "shader" + ] + }, + "ShaderExtractVec": { + "inputs": [ + [ + "vec3f", + "vec", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "float", + "x", + "" + ], + [ + "float", + "y", + "" + ], + [ + "float", + "z", + "" + ], + [ + "float", + "w", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "shader" + ] + }, + "ShaderFillVec": { + "inputs": [ + [ + "float", + "in", + "" + ], + [ + "enum float vec2 vec3 vec4", + "type", + "vec3" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "vec4f", + "out", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "shader" + ] + }, + "ShaderFinalize": { + "inputs": [ + [ + "float", + "base", + "" + ], + [ + "colorvec3f", + "basecolor", + "" + ], + [ + "float", + "roughness", + "" + ], + [ + "float", + "metallic", + "" + ], + [ + "colorvec3f", + "metalColor", + "" + ], + [ + "float", + "specular", + "" + ], + [ + "float", + "specularTint", + "" + ], + [ + "float", + "anisotropic", + "" + ], + [ + "float", + "anisoRotation", + "" + ], + [ + "float", + "subsurface", + "" + ], + [ + "enum Fixed Adaptive", + "sssRadius", + "Fixed" + ], + [ + "vec3f", + "sssParam", + "" + ], + [ + "colorvec3f", + "sssColor", + "" + ], + [ + "float", + "scatterDistance", + "" + ], + [ + "float", + "scatterStep", + "" + ], + [ + "float", + "sheen", + "" + ], + [ + "float", + "sheenTint", + "" + ], + [ + "float", + "clearcoat", + "" + ], + [ + "vec3f", + "clearcoatColor", + "" + ], + [ + "float", + "clearcoatRoughness", + "" + ], + [ + "float", + "clearcoatIOR", + "" + ], + [ + "float", + "specTrans", + "" + ], + [ + "vec3f", + "transColor", + "" + ], + [ + "vec3f", + "transTint", + "" + ], + [ + "float", + "transTintDepth", + "" + ], + [ + "float", + "transDistance", + "" + ], + [ + "vec3f", + "transScatterColor", + "" + ], + [ + "float", + "ior", + "" + ], + [ + "float", + "diffraction", + "" + ], + [ + "vec3f", + "diffractColor", + "" + ], + [ + "float", + "flatness", + "" + ], + [ + "float", + "shadowReceiver", + "" + ], + [ + "float", + "thin", + "" + ], + [ + "float", + "doubleSide", + "" + ], + [ + "vec3f", + "normal", + "" + ], + [ + "float", + "displacement", + "" + ], + [ + "float", + "smoothness", + "" + ], + [ + "float", + "emissionIntensity", + "" + ], + [ + "vec3f", + "emission", + "" + ], + [ + "vec3f", + "reflectance", + "" + ], + [ + "float", + "opacity", + "" + ], + [ + "float", + "thickness", + "" + ], + [ + "float", + "isHair", + "" + ], + [ + "string", + "commonCode", + "" + ], + [ + "string", + "extensionsCode", + "" + ], + [ + "string", + "mtlid", + "Mat1" + ], + [ + "list", + "tex2dList", + "" + ], + [ + "vec3i", + "mask_value", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [ + [ + "enum CUDA", + "backend", + "CUDA" + ] + ], + "outputs": [ + [ + "MaterialObject", + "mtl", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "shader" + ] + }, + "ShaderHsvAdjust": { + "inputs": [ + [ + "vec3f", + "color", + "" + ], + [ + "vec3f", + "amount", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "", + "out", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "shader" + ] + }, + "ShaderInputAttr": { + "inputs": [ + [ + "enum pos clr nrm uv tang bitang NoL LoV N T L V H reflectance fresnel instPos instNrm instUv instClr instTang prd.rndf() attrs.localPosLazy() attrs.uniformPosLazy() rayLength isShadowRay worldNrm worldTan worldBTn camFront camUp camRight", + "attr", + "pos" + ], + [ + "enum float vec2 vec3 vec4 bool", + "type", + "vec3" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "shader", + "out", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "shader" + ] + }, + "ShaderInvokeFunc": { + "inputs": [ + [ + "ShaderCustomFuncObject", + "func", + "" + ], + [ + "list", + "args", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "shader", + "out", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "shader" + ] + }, + "ShaderLinearFit": { + "inputs": [ + [ + "float", + "in", + "" + ], + [ + "float", + "inMin", + "" + ], + [ + "float", + "inMax", + "" + ], + [ + "float", + "outMin", + "" + ], + [ + "float", + "outMax", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [ + [ + "bool", + "clamped", + "0" + ] + ], + "outputs": [ + [ + "float", + "out", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "shader" + ] + }, + "ShaderMakeVec": { + "inputs": [ + [ + "float", + "x", + "" + ], + [ + "float", + "y", + "" + ], + [ + "float", + "z", + "" + ], + [ + "float", + "w", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "vec4f", + "out", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "deprecated" + ] + }, + "ShaderNormalMap": { + "inputs": [ + [ + "vec3f", + "normalTexel", + "" + ], + [ + "float", + "scale", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "vec3f", + "out", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "shader" + ] + }, + "ShaderPackVec": { + "inputs": [ + [ + "shader", + "x", + "" + ], + [ + "shader", + "y", + "" + ], + [ + "shader", + "z", + "" + ], + [ + "shader", + "w", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "vec4f", + "out", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "deprecated" + ] + }, + "ShaderPackVector": { + "inputs": [ + [ + "float", + "x", + "" + ], + [ + "float", + "y", + "" + ], + [ + "float", + "z", + "" + ], + [ + "float", + "w", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [ + [ + "enum float vec2 vec3 vec4", + "type", + "vec3" + ] + ], + "outputs": [ + [ + "", + "out", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "shader" + ] + }, + "ShaderReduceVec": { + "inputs": [ + [ + "vec3f", + "in", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [ + [ + "enum average sum", + "op", + "average" + ] + ], + "outputs": [ + [ + "float", + "out", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "shader" + ] + }, + "ShaderTernaryMath": { + "inputs": [ + [ + "float", + "in1", + "" + ], + [ + "float", + "in2", + "" + ], + [ + "float", + "in3", + "" + ], + [ + "enum mix clamp smoothstep add3 ?", + "op", + "mix" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "float", + "out", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "shader" + ] + }, + "ShaderTexture2D": { + "inputs": [ + [ + "int", + "texId", + "0" + ], + [ + "", + "coord", + "" + ], + [ + "vec2f", + "uvtiling", + "" + ], + [ + "enum float vec2 vec3 vec4", + "type", + "vec3" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "shader", + "out", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "shader" + ] + }, + "ShaderTexture3D": { + "inputs": [ + [ + "int", + "texId", + "0" + ], + [ + "vec3f", + "coord", + "" + ], + [ + "bool", + "cihou", + "0" + ], + [ + "enum World Local", + "space", + "World" + ], + [ + "enum vec2", + "type", + "vec2" + ], + [ + "enum Closest Trilinear Triquadratic Tricubic Stochastic", + "method", + "Trilinear" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "shader", + "out", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "shader" + ] + }, + "ShaderUnaryMath": { + "inputs": [ + [ + "float", + "in1", + "" + ], + [ + "enum copy neg abs sqrt inversesqrt exp log sin cos tan asin acos atan degrees radians sinh cosh tanh asinh acosh atanh round roundEven floor ceil trunc sign length normalize hsvToRgb rgbToHsv luminance saturate", + "op", + "sqrt" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "float", + "out", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "shader" + ] + }, + "ShaderUniformAttr": { + "inputs": [ + [ + "int", + "idx", + "0" + ], + [ + "enum float vec2 vec3 vec4", + "type", + "vec3" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "shader", + "out", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "shader" + ] + }, + "ShaderVecConvert": { + "inputs": [ + [ + "float", + "in", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [ + [ + "enum vec2 vec3 vec4", + "type", + "vec3" + ] + ], + "outputs": [ + [ + "", + "out", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "shader" + ] + }, + "ShaderVecExtract": { + "inputs": [ + [ + "", + "in", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [ + [ + "enum x y z w xyz 1-w xyz(srgb)", + "type", + "xyz" + ] + ], + "outputs": [ + [ + "", + "out", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "shader" + ] + }, + "ShaderVolume": { + "inputs": [ + [ + "string", + "mtlid", + "VolMat1" + ], + [ + "list", + "tex2dList", + "" + ], + [ + "list", + "tex3dList", + "" + ], + [ + "float", + "depth", + "" + ], + [ + "float", + "extinction", + "" + ], + [ + "float", + "anisotropy", + "" + ], + [ + "colorvec3f", + "albedo", + "" + ], + [ + "float", + "density", + "" + ], + [ + "vec3f", + "emission", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [ + [ + "enum Raw Density Absorption", + "EmissionScale", + "Raw" + ], + [ + "enum RatioTracking", + "Transmittance", + "RatioTracking" + ] + ], + "outputs": [ + [ + "MaterialObject", + "mtl", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "shader" + ] + }, + "ShaderVolumeHomogeneous": { + "inputs": [ + [ + "colorvec3f", + "albedo", + "" + ], + [ + "vec3f", + "extinction", + "" + ], + [ + "float", + "anisotropy", + "" + ], + [ + "bool", + "debug", + "0" + ], + [ + "bool", + "multiscatter", + "0" + ], + [ + "string", + "mtlid", + "VolMat1" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "MaterialObject", + "mtl", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "shader" + ] + }, + "SkyComposer": { + "inputs": [ + [ + "list", + "dlights", + "" + ], + [ + "list", + "portals", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [ + [ + "enum SphereUnbounded", + "proxy", + "SphereUnbounded" + ] + ], + "outputs": [ + [ + "", + "out", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "shader" + ] + }, + "SmartTexture2D": { + "inputs": [ + [ + "readpath", + "path", + "" + ], + [ + "", + "heatmap", + "" + ], + [ + "enum REPEAT MIRRORED_REPEAT CLAMP_TO_EDGE CLAMP_TO_BORDER", + "wrapS", + "REPEAT" + ], + [ + "enum REPEAT MIRRORED_REPEAT CLAMP_TO_EDGE CLAMP_TO_BORDER", + "wrapT", + "REPEAT" + ], + [ + "enum NEAREST LINEAR NEAREST_MIPMAP_NEAREST LINEAR_MIPMAP_NEAREST NEAREST_MIPMAP_LINEAR LINEAR_MIPMAP_LINEAR", + "minFilter", + "LINEAR" + ], + [ + "enum NEAREST LINEAR NEAREST_MIPMAP_NEAREST LINEAR_MIPMAP_NEAREST NEAREST_MIPMAP_LINEAR LINEAR_MIPMAP_LINEAR", + "magFilter", + "LINEAR" + ], + [ + "", + "coord", + "" + ], + [ + "vec2f", + "uvtiling", + "" + ], + [ + "vec4f", + "value", + "" + ], + [ + "enum float vec2 vec3 vec4 R G B A", + "type", + "vec3" + ], + [ + "enum raw srgb normal_map", + "post_process", + "raw" + ], + [ + "bool", + "blockCompression", + "0" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "shader", + "out", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "shader" + ] + }, + "SpdlogErrorMessage": { + "inputs": [ + [ + "", + "SRC", + "" + ] + ], + "params": [ + [ + "string", + "message", + "error from spdlog!" + ] + ], + "outputs": [ + [ + "", + "DST", + "" + ] + ], + "categories": [ + "debug" + ] + }, + "SpdlogInfoMessage": { + "inputs": [ + [ + "", + "SRC", + "" + ] + ], + "params": [ + [ + "string", + "message", + "hello from spdlog!" + ] + ], + "outputs": [ + [ + "", + "DST", + "" + ] + ], + "categories": [ + "debug" + ] + }, + "Stamp": { + "inputs": [ + [ + "", + "input", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [ + [ + "enum UnChanged DataChange ShapeChange TotalChange", + "mode", + "UnChanged" + ], + [ + "string", + "name", + "" + ] + ], + "outputs": [ + [ + "", + "output", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "lifecycle" + ] + }, + "StringDeleteOrReplace": { + "inputs": [ + [ + "multiline_string", + "String", + "" + ], + [ + "enum AllRefString First_N_characters Last_N_characters All_characters_before_RefString N_characters_before_RefString All_characters_after_RefString N_characters_after_RefString", + "oldString", + "AllRefString" + ], + [ + "string", + "RefString", + "" + ], + [ + "bool", + "UseLastRefString", + "0" + ], + [ + "int", + "N", + "1" + ], + [ + "string", + "newString", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "string", + "string", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "string" + ] + }, + "StringEditNumber": { + "inputs": [ + [ + "multiline_string", + "String", + "" + ], + [ + "enum Remove_all_numbers Remove_all_non_numbers Remove_last_number Return_last_number_Sequence", + "Method", + "Remove_all_numbers" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "string", + "string", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "string" + ] + }, + "StringEqual": { + "inputs": [ + [ + "string", + "lhs", + "" + ], + [ + "string", + "rhs", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "bool", + "isEqual", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "string" + ] + }, + "StringEval": { + "inputs": [ + [ + "string", + "zfxCode", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "string", + "result", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "zenofx" + ] + }, + "StringFind": { + "inputs": [ + [ + "multiline_string", + "string", + "" + ], + [ + "string", + "substring", + "" + ], + [ + "int", + "start", + "0" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "int", + "Position", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "string" + ] + }, + "StringFormat": { + "inputs": [ + [ + "string", + "str", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "string", + "str", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "deprecated" + ] + }, + "StringFormatNumStr": { + "inputs": [ + [ + "string", + "str", + "{}" + ], + [ + "", + "num_str", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "string", + "str", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "string" + ] + }, + "StringFormatNumber": { + "inputs": [ + [ + "string", + "str", + "{}" + ], + [ + "", + "number", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "string", + "str", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "deprecated" + ] + }, + "StringInsert": { + "inputs": [ + [ + "multiline_string", + "string", + "" + ], + [ + "string", + "substring", + "" + ], + [ + "int", + "start", + "0" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "string", + "string", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "string" + ] + }, + "StringJoin": { + "inputs": [ + [ + "", + "list", + "" + ], + [ + "string", + "Separator", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "string", + "string", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "string" + ] + }, + "StringLength": { + "inputs": [ + [ + "string", + "string", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "int", + "length", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "string" + ] + }, + "StringRegexMatch": { + "inputs": [ + [ + "string", + "str", + "" + ], + [ + "string", + "regex", + "" + ], + [ + "bool", + "case_sensitive", + "1" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "int", + "output", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "string" + ] + }, + "StringRegexSearch": { + "inputs": [ + [ + "string", + "str", + "" + ], + [ + "string", + "regex", + "" + ], + [ + "bool", + "case_sensitive", + "1" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "int", + "search_success", + "" + ], + [ + "", + "res", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "string" + ] + }, + "StringReplace": { + "inputs": [ + [ + "multiline_string", + "string", + "" + ], + [ + "string", + "old", + "" + ], + [ + "string", + "new", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "string", + "string", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "string" + ] + }, + "StringSplitAndMerge": { + "inputs": [ + [ + "string", + "str", + "" + ], + [ + "string", + "schar", + "_" + ], + [ + "string", + "merge", + "0" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "string", + "output", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "deprecated" + ] + }, + "StringSplitAndMerge2": { + "inputs": [ + [ + "multiline_string", + "String", + "" + ], + [ + "string", + "Separator", + "_" + ], + [ + "enum Custom_Index_Merge Clip_And_Merge", + "Merge Method", + "Custom_Index_Merge" + ], + [ + "string", + "Merge index", + "0,1" + ], + [ + "int", + "Clip Count From Start", + "0" + ], + [ + "int", + "Clip Count From End", + "0" + ], + [ + "bool", + "Remain Separator", + "0" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "string", + "string", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "string" + ] + }, + "StringSplitPath": { + "inputs": [ + [ + "readpath", + "string", + "" + ], + [ + "bool", + "SplitExtension", + "0" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "string", + "directory", + "" + ], + [ + "string", + "filename", + "" + ], + [ + "string", + "extension", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "string" + ] + }, + "StringToList": { + "inputs": [ + [ + "multiline_string", + "string", + "" + ], + [ + "string", + "Separator", + "" + ], + [ + "bool", + "Trim", + "0" + ], + [ + "bool", + "KeepEmpty", + "0" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "", + "list", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "string" + ] + }, + "StringToNumber": { + "inputs": [ + [ + "enum float int", + "type", + "float" + ], + [ + "string", + "str", + "0" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "", + "num_str", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "string" + ] + }, + "StringTrim": { + "inputs": [ + [ + "string", + "string", + "" + ], + [ + "bool", + "trimleft", + "0" + ], + [ + "bool", + "trimright", + "0" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "string", + "string", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "string" + ] + }, + "StringtoLower": { + "inputs": [ + [ + "string", + "string", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "string", + "string", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "string" + ] + }, + "StringtoUpper": { + "inputs": [ + [ + "string", + "string", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "string", + "string", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "string" + ] + }, + "SubCategory": { + "inputs": [ + [ + "", + "SRC", + "" + ] + ], + "params": [ + [ + "string", + "name", + "subgraph" + ] + ], + "outputs": [ + [ + "", + "DST", + "" + ] + ], + "categories": [ + "subgraph" + ] + }, + "SubInput": { + "inputs": [ + [ + "", + "SRC", + "" + ] + ], + "params": [ + [ + "string", + "defl", + "" + ], + [ + "string", + "name", + "input1" + ], + [ + "string", + "type", + "" + ] + ], + "outputs": [ + [ + "", + "port", + "" + ], + [ + "bool", + "hasValue", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "subgraph" + ] + }, + "SubLine": { + "inputs": [ + [ + "", + "line", + "" + ], + [ + "NumericObject", + "value", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [ + [ + "enum cmpgt cmplt cmpge cmple cmpeq cmpne", + "acceptIf", + "cmpgt" + ], + [ + "string", + "attrName", + "rad" + ], + [ + "enum any all", + "vecSelType", + "all" + ] + ], + "outputs": [ + [ + "", + "prim", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "deprecated" + ] + }, + "SubOutput": { + "inputs": [ + [ + "", + "port", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [ + [ + "string", + "defl", + "" + ], + [ + "string", + "name", + "output1" + ], + [ + "string", + "type", + "" + ] + ], + "outputs": [ + [ + "", + "DST", + "" + ] + ], + "categories": [ + "subgraph" + ] + }, + "SubString": { + "inputs": [ + [ + "multiline_string", + "string", + "" + ], + [ + "int", + "start", + "0" + ], + [ + "int", + "length", + "1" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "string", + "string", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "string" + ] + }, + "SubstepDt": { + "inputs": [ + [ + "", + "FOR", + "" + ], + [ + "float", + "desired_dt", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "float", + "actual_dt", + "" + ], + [ + "float", + "portion", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "control" + ] + }, + "SyncPrimitiveAttributes": { + "inputs": [ + [ + "", + "prim1", + "" + ], + [ + "", + "prim2", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "", + "prim1", + "" + ], + [ + "", + "prim2", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "primitive" + ] + }, + "TargetCamera": { + "inputs": [ + [ + "vec3f", + "pos", + "" + ], + [ + "vec3f", + "refUp", + "" + ], + [ + "vec3f", + "target", + "" + ], + [ + "float", + "near", + "" + ], + [ + "float", + "far", + "" + ], + [ + "float", + "fov", + "" + ], + [ + "float", + "aperture", + "" + ], + [ + "bool", + "AutoFocus", + "0" + ], + [ + "float", + "focalPlaneDistance", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "CameraObject", + "camera", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "shader" + ] + }, + "TestRayBox": { + "inputs": [ + [ + "", + "ray_origin", + "" + ], + [ + "", + "ray_dir", + "" + ], + [ + "", + "box_min", + "" + ], + [ + "", + "box_max", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "", + "predicate", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "primitive" + ] + }, + "ToView": { + "inputs": [ + [ + "", + "object", + "" + ], + [ + "bool", + "isStatic", + "0" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [ + [ + "string", + "mode", + "TotalChange" + ], + [ + "string", + "name", + "" + ] + ], + "outputs": [ + [ + "", + "object", + "" + ], + [ + "string", + "viewid", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "layout" + ] + }, + "TraceOneStep": { + "inputs": [ + [ + "", + "prim", + "" + ], + [ + "", + "dt", + "" + ], + [ + "", + "size", + "" + ], + [ + "", + "steps", + "" + ], + [ + "", + "maxlength", + "" + ], + [ + "", + "vecField", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "", + "prim", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "openvdb" + ] + }, + "TracePositionOneStep": { + "inputs": [ + [ + "", + "primData", + "" + ], + [ + "", + "primStart", + "" + ], + [ + "string", + "lineTag", + "lineID" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "", + "primVis", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "visualize" + ] + }, + "TransformPrimitive": { + "inputs": [ + [ + "PrimitiveObject", + "prim", + "" + ], + [ + "vec3f", + "translation", + "" + ], + [ + "vec3f", + "eulerXYZ", + "" + ], + [ + "vec4f", + "quatRotation", + "" + ], + [ + "vec3f", + "scaling", + "" + ], + [ + "vec3f", + "shear", + "" + ], + [ + "", + "Matrix", + "" + ], + [ + "", + "preTransform", + "" + ], + [ + "", + "local", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [ + [ + "enum Degree Radians", + "EulerAngleMeasure", + "Radians" + ], + [ + "enum XYZ XZY YXZ YZX ZXY ZYX", + "EulerRotationOrder", + "ZYX" + ] + ], + "outputs": [ + [ + "PrimitiveObject", + "outPrim", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "deprecated" + ] + }, + "TransformVDB": { + "inputs": [ + [ + "", + "VDBGrid", + "" + ], + [ + "vec3f", + "translation", + "" + ], + [ + "vec3f", + "eulerXYZ", + "" + ], + [ + "vec3f", + "scaling", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "", + "VDBGrid", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "openvdb" + ] + }, + "TrianglesWrangle": { + "inputs": [ + [ + "PrimitiveObject", + "prim", + "" + ], + [ + "string", + "zfxCode", + "" + ], + [ + "DictObject:NumericObject", + "params", + "" + ], + [ + "enum points lines tris quads loops polys", + "faceType", + "tris" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "PrimitiveObject", + "prim", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "zenofx" + ] + }, + "TriggerAbortSignal": { + "inputs": [ + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "", + "DST", + "" + ] + ], + "categories": [ + "debug" + ] + }, + "TriggerDivideZero": { + "inputs": [ + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "", + "DST", + "" + ] + ], + "categories": [ + "debug" + ] + }, + "TriggerException": { + "inputs": [ + [ + "", + "SRC", + "" + ] + ], + "params": [ + [ + "string", + "message", + "exception occurred!" + ] + ], + "outputs": [ + [ + "", + "DST", + "" + ] + ], + "categories": [ + "debug" + ] + }, + "TriggerExitProcess": { + "inputs": [ + [ + "", + "SRC", + "" + ] + ], + "params": [ + [ + "int", + "status", + "-1" + ] + ], + "outputs": [ + [ + "", + "DST", + "" + ] + ], + "categories": [ + "debug" + ] + }, + "TriggerSegFault": { + "inputs": [ + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "", + "DST", + "" + ] + ], + "categories": [ + "debug" + ] + }, + "TriggerViewportFault": { + "inputs": [ + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "", + "prim", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "debug" + ] + }, + "UVProjectFromPlane": { + "inputs": [ + [ + "PrimitiveObject", + "prim", + "" + ], + [ + "PrimitiveObject", + "refPlane", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "PrimitiveObject", + "outPrim", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "primitive" + ] + }, + "UnpackNumericVec": { + "inputs": [ + [ + "vec3f", + "vec", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "float", + "X", + "" + ], + [ + "float", + "Y", + "" + ], + [ + "float", + "Z", + "" + ], + [ + "float", + "W", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "numeric" + ] + }, + "UpdateCurveControlPoint": { + "inputs": [ + [ + "curve", + "curve", + "" + ], + [ + "string", + "key", + "x" + ], + [ + "int", + "index", + "0" + ], + [ + "optional float", + "point_x", + "" + ], + [ + "optional float", + "point_y", + "" + ], + [ + "optional vec2f", + "left_handler", + "" + ], + [ + "optional vec2f", + "right_handler", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "curve", + "curve", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "curve" + ] + }, + "UpdateCurveCycleType": { + "inputs": [ + [ + "curve", + "curve", + "" + ], + [ + "string", + "key", + "x" + ], + [ + "enum CLAMP CYCLE MIRROR", + "type", + "CLAMP" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "curve", + "curve", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "curve" + ] + }, + "UpdateCurveXYRange": { + "inputs": [ + [ + "curve", + "curve", + "" + ], + [ + "string", + "key", + "x" + ], + [ + "optional float", + "x_from", + "" + ], + [ + "optional float", + "x_to", + "" + ], + [ + "optional float", + "y_from", + "" + ], + [ + "optional float", + "y_to", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "curve", + "curve", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "curve" + ] + }, + "VDBAddPerlinNoise": { + "inputs": [ + [ + "", + "inoutSDF", + "" + ], + [ + "float", + "strength", + "" + ], + [ + "float", + "scale", + "" + ], + [ + "vec3f", + "scaling", + "" + ], + [ + "vec3f", + "translation", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "", + "inoutSDF", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "deprecated" + ] + }, + "VDBAddTurbulentNoise": { + "inputs": [ + [ + "", + "inoutSDF", + "" + ], + [ + "float", + "strength", + "" + ], + [ + "float", + "scale", + "" + ], + [ + "vec3f", + "scaling", + "" + ], + [ + "vec3f", + "translation", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "", + "inoutSDF", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "openvdb" + ] + }, + "VDBChangeBackground": { + "inputs": [ + [ + "", + "grid", + "" + ], + [ + "float", + "background", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "", + "grid", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "openvdb" + ] + }, + "VDBCreateLevelsetSphere": { + "inputs": [ + [ + "float", + "Dx", + "" + ], + [ + "float", + "radius", + "" + ], + [ + "vec3f", + "center", + "" + ], + [ + "float", + "half_width", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "", + "data", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "openvdb" + ] + }, + "VDBDeactivate": { + "inputs": [ + [ + "", + "Field", + "" + ], + [ + "", + "Mask", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "", + "DST", + "" + ] + ], + "categories": [ + "openvdb" + ] + }, + "VDBDilateTopo": { + "inputs": [ + [ + "", + "inField", + "" + ], + [ + "int", + "layers", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "", + "oField", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "openvdb" + ] + }, + "VDBErodeSDF": { + "inputs": [ + [ + "", + "inoutSDF", + "" + ], + [ + "float", + "depth", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "", + "inoutSDF", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "openvdb" + ] + }, + "VDBExplosiveTurbulentNoise": { + "inputs": [ + [ + "", + "inoutSDF", + "" + ], + [ + "float", + "strength", + "" + ], + [ + "float", + "scale", + "" + ], + [ + "vec3f", + "scaling", + "" + ], + [ + "vec3f", + "translation", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [ + [ + "float", + "FBM_EvalPersist", + "" + ], + [ + "float", + "FBM_Lacunarity", + "" + ], + [ + "int", + "FBM_Octaves", + "5" + ], + [ + "float", + "FBM_Persistence", + "" + ], + [ + "float", + "FBM_WarpPersist", + "" + ], + [ + "float", + "FBM_WarpPrimary", + "" + ], + [ + "float", + "FBM_WarpSecond", + "" + ], + [ + "float", + "Speed", + "" + ], + [ + "float", + "UVScale", + "" + ] + ], + "outputs": [ + [ + "", + "inoutSDF", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "openvdb" + ] + }, + "VDBFillActiveVoxels": { + "inputs": [ + [ + "", + "grid", + "" + ], + [ + "NumericObject", + "fillValue", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "", + "grid", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "openvdb" + ] + }, + "VDBGetBackground": { + "inputs": [ + [ + "", + "grid", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "float", + "background", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "openvdb" + ] + }, + "VDBInvertSDF": { + "inputs": [ + [ + "", + "grid", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "", + "grid", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "openvdb" + ] + }, + "VDBLeafAsParticles": { + "inputs": [ + [ + "", + "vdbGrid", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "", + "primPars", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "visualize" + ] + }, + "VDBPerlinNoise": { + "inputs": [ + [ + "", + "inoutSDF", + "" + ], + [ + "float", + "scale", + "" + ], + [ + "vec3f", + "scale3d", + "" + ], + [ + "float", + "detail", + "" + ], + [ + "float", + "roughness", + "" + ], + [ + "float", + "disortion", + "" + ], + [ + "vec3f", + "offset", + "" + ], + [ + "float", + "average", + "" + ], + [ + "float", + "strength", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "", + "inoutSDF", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "openvdb" + ] + }, + "VDBPointScatter": { + "inputs": [ + [ + "", + "grid", + "" + ], + [ + "int", + "count", + "4" + ], + [ + "float", + "spread", + "" + ], + [ + "int", + "seed", + "-1" + ], + [ + "enum Fog SDF", + "gridtype", + "Fog" + ], + [ + "enum PerVoxel Total", + "counttype", + "PerVoxel" + ], + [ + "enum Uniform NonUniform", + "method", + "Uniform" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "", + "points", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "openvdb" + ] + }, + "VDBPointsToPrimitive": { + "inputs": [ + [ + "", + "grid", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "", + "prim", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "openvdb" + ] + }, + "VDBPruneFootprint": { + "inputs": [ + [ + "", + "grid", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "", + "grid", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "openvdb" + ] + }, + "VDBRenormalizeSDF": { + "inputs": [ + [ + "", + "inoutSDF", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [ + [ + "int", + "dilateIters", + "0" + ], + [ + "int", + "iterations", + "4" + ], + [ + "enum 1oUpwind", + "method", + "1oUpwind" + ] + ], + "outputs": [ + [ + "", + "inoutSDF", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "openvdb" + ] + }, + "VDBSmooth": { + "inputs": [ + [ + "", + "inoutVDB", + "" + ], + [ + "", + "MaskGrid", + "" + ], + [ + "enum Mean Gaussian Median", + "type", + "Gaussian" + ], + [ + "int", + "width", + "1" + ], + [ + "int", + "iterations", + "1" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "", + "inoutVDB", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "openvdb" + ] + }, + "VDBSmoothSDF": { + "inputs": [ + [ + "", + "inoutSDF", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [ + [ + "string", + "DEPRECATED", + "Use VDBSmooth Instead" + ], + [ + "int", + "iterations", + "1" + ], + [ + "int", + "width", + "1" + ] + ], + "outputs": [ + [ + "", + "inoutSDF", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "deprecated" + ] + }, + "VDBTopoCopy": { + "inputs": [ + [ + "", + "grid", + "" + ], + [ + "", + "topo", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "", + "grid", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "openvdb" + ] + }, + "VDBTouchAABBRegion": { + "inputs": [ + [ + "", + "grid", + "" + ], + [ + "vec3f", + "bmin", + "" + ], + [ + "vec3f", + "bmax", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "", + "grid", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "openvdb" + ] + }, + "VDBVoxelAsParticles": { + "inputs": [ + [ + "", + "vdbGrid", + "" + ], + [ + "string", + "valToAttr", + "sdf" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [ + [ + "bool", + "asStaggers", + "1" + ], + [ + "bool", + "hasInactive", + "0" + ] + ], + "outputs": [ + [ + "", + "primPars", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "visualize" + ] + }, + "VDBWrangle": { + "inputs": [ + [ + "VDBGrid", + "grid", + "" + ], + [ + "string", + "zfxCode", + "" + ], + [ + "enum true false", + "ModifyActive", + "false" + ], + [ + "enum true false", + "ChangeBackground", + "false" + ], + [ + "DictObject:NumericObject", + "params", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "VDBGrid", + "grid", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "zenofx" + ] + }, + "VectorFieldAnalyzer": { + "inputs": [ + [ + "", + "InVDB", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [ + [ + "enum Divergence Curl Magnitude Normalize", + "Operator", + "Divergence" + ] + ], + "outputs": [ + [ + "", + "OutVDB", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "openvdb" + ] + }, + "VisPrimAttrValue_Modify": { + "inputs": [ + [ + "", + "prim", + "" + ], + [ + "string", + "attrName", + "pos" + ], + [ + "float", + "scale", + "" + ], + [ + "int", + "precision", + "3" + ], + [ + "bool", + "includeSelf", + "0" + ], + [ + "bool", + "dotDecoration", + "0" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "", + "outPrim", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "WBTest" + ] + }, + "VisVec3Attribute": { + "inputs": [ + [ + "", + "prim", + "" + ], + [ + "string", + "name", + "vel" + ], + [ + "bool", + "normalize", + "1" + ], + [ + "float", + "lengthScale", + "" + ], + [ + "vec3f", + "color", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "", + "primVis", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "visualize" + ] + }, + "VolumeAdvect": { + "inputs": [ + [ + "", + "InField", + "" + ], + [ + "", + "VecField", + "" + ], + [ + "float", + "TimeStep", + "" + ], + [ + "int", + "SubSteps", + "1" + ], + [ + "enum SemiLagrangian MidPoint RK3 RK4 MacCormack BFECC", + "Integrator", + "BFECC" + ], + [ + "enum None Clamp Revert", + "Limiter", + "Revert" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "", + "extend", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "openvdb" + ] + }, + "WBPrimBend": { + "inputs": [ + [ + "", + "prim", + "" + ], + [ + "int", + "Limit Deformation", + "1" + ], + [ + "int", + "Symmetric Deformation", + "0" + ], + [ + "float", + "Bend Angle (degree)", + "" + ], + [ + "vec3f", + "Up Vector", + "" + ], + [ + "vec3f", + "Capture Origin", + "" + ], + [ + "vec3f", + "Capture Direction", + "" + ], + [ + "float", + "Capture Length", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "", + "prim", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "primitive" + ] + }, + "WriteAlembic": { + "inputs": [ + [ + "", + "prim", + "" + ], + [ + "", + "frameid", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [ + [ + "bool", + "flipFrontBack", + "1" + ], + [ + "int", + "frame_end", + "100" + ], + [ + "int", + "frame_start", + "0" + ], + [ + "writepath", + "path", + "" + ] + ], + "outputs": [ + [ + "", + "DST", + "" + ] + ], + "categories": [ + "deprecated" + ] + }, + "WriteAlembic2": { + "inputs": [ + [ + "", + "prim", + "" + ], + [ + "", + "frameid", + "" + ], + [ + "writepath", + "path", + "" + ], + [ + "int", + "frame_start", + "0" + ], + [ + "int", + "frame_end", + "100" + ], + [ + "float", + "fps", + "" + ], + [ + "bool", + "flipFrontBack", + "1" + ], + [ + "bool", + "outputPoint", + "0" + ], + [ + "bool", + "outputToMaya", + "0" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "", + "DST", + "" + ] + ], + "categories": [ + "alembic" + ] + }, + "WriteAlembicPrims": { + "inputs": [ + [ + "", + "prim", + "" + ], + [ + "list", + "prims", + "" + ], + [ + "", + "frameid", + "" + ], + [ + "writepath", + "path", + "" + ], + [ + "int", + "frame_start", + "0" + ], + [ + "int", + "frame_end", + "100" + ], + [ + "float", + "fps", + "" + ], + [ + "bool", + "flipFrontBack", + "1" + ], + [ + "bool", + "outputToMaya", + "0" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "", + "DST", + "" + ] + ], + "categories": [ + "alembic" + ] + }, + "WriteCustomVAT": { + "inputs": [ + [ + "", + "prim", + "" + ], + [ + "", + "frameid", + "" + ], + [ + "bool", + "UnrealEngine", + "1" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [ + [ + "int", + "frameEnd", + "100" + ], + [ + "int", + "frameStart", + "0" + ], + [ + "writepath", + "path", + "" + ] + ], + "outputs": [ + [ + "", + "prim", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "primitive" + ] + }, + "WriteExr": { + "inputs": [ + [ + "writepath", + "path", + "" + ], + [ + "dict", + "channels", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "", + "DST", + "" + ] + ], + "categories": [ + "comp" + ] + }, + "WriteImageFile": { + "inputs": [ + [ + "", + "image", + "" + ], + [ + "writepath", + "path", + "" + ], + [ + "enum png jpg exr pfm", + "type", + "png" + ], + [ + "", + "mask", + "" + ], + [ + "bool", + "gamma", + "1" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "", + "image", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "deprecated" + ] + }, + "WriteImageFile_v2": { + "inputs": [ + [ + "", + "image", + "" + ], + [ + "writepath", + "path", + "" + ], + [ + "enum png jpg exr pfm hdr", + "type", + "png" + ], + [ + "", + "mask", + "" + ], + [ + "bool", + "linear_to_srgb_when_save", + "0" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "", + "image", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "comp" + ] + }, + "WriteJson": { + "inputs": [ + [ + "", + "json", + "" + ], + [ + "writepath", + "path", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "", + "DST", + "" + ] + ], + "categories": [ + "json" + ] + }, + "WriteObjPrim": { + "inputs": [ + [ + "primitive", + "prim", + "" + ], + [ + "writepath", + "path", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [ + [ + "bool", + "polygonate", + "1" + ] + ], + "outputs": [ + [ + "primitive", + "prim", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "primitive" + ] + }, + "WriteObjPrimitive": { + "inputs": [ + [ + "writepath", + "path", + "" + ], + [ + "", + "prim", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "", + "DST", + "" + ] + ], + "categories": [ + "deprecated" + ] + }, + "WritePrimToCSV": { + "inputs": [ + [ + "primitive", + "prim", + "" + ], + [ + "writepath", + "path", + "" + ], + [ + "enum verts points lines tris quads loops polys", + "type", + "verts" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "primitive", + "prim", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "primitive" + ] + }, + "WriteVDB": { + "inputs": [ + [ + "", + "data", + "" + ], + [ + "writepath", + "path", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "", + "DST", + "" + ] + ], + "categories": [ + "openvdb" + ] + }, + "WriteVDBGrid": { + "inputs": [ + [ + "", + "data", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [ + [ + "writepath", + "path", + "" + ] + ], + "outputs": [ + [ + "", + "DST", + "" + ] + ], + "categories": [ + "deprecated" + ] + }, + "ZipListAsDict": { + "inputs": [ + [ + "ListObject", + "keys", + "" + ], + [ + "ListObject", + "values", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "DictObject", + "dict", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "dict" + ] + }, + "erode_domainWarping_v1": { + "inputs": [ + [ + "", + "prim", + "" + ], + [ + "float", + "fbmH", + "" + ], + [ + "float", + "fbmFrequence", + "" + ], + [ + "float", + "fbmAmplitude", + "" + ], + [ + "int", + "fbmNumOctaves", + "4" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [ + [ + "string", + "attrName", + "noise" + ], + [ + "enum float float3", + "attrType", + "float" + ] + ], + "outputs": [ + [ + "", + "prim", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "erode" + ] + }, + "erode_domainWarping_v2": { + "inputs": [ + [ + "", + "prim", + "" + ], + [ + "float", + "fbmH", + "" + ], + [ + "float", + "fbmFrequence", + "" + ], + [ + "float", + "fbmAmplitude", + "" + ], + [ + "int", + "fbmNumOctaves", + "4" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [ + [ + "string", + "attrName", + "noise" + ], + [ + "enum float float3", + "attrType", + "float" + ] + ], + "outputs": [ + [ + "", + "prim", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "erode" + ] + }, + "erode_hybridMultifractal_v1": { + "inputs": [ + [ + "", + "prim_2DGrid", + "" + ], + [ + "float", + "H", + "" + ], + [ + "float", + "lacunarity", + "" + ], + [ + "float", + "octaves", + "" + ], + [ + "float", + "offset", + "" + ], + [ + "float", + "scale", + "" + ], + [ + "float", + "persistence", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [ + [ + "string", + "attrName", + "hybrid" + ], + [ + "enum float float3", + "attrType", + "float" + ] + ], + "outputs": [ + [ + "", + "prim_2DGrid", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "erode" + ] + }, + "erode_hybridMultifractal_v2": { + "inputs": [ + [ + "", + "prim_2DGrid", + "" + ], + [ + "float", + "H", + "" + ], + [ + "float", + "lacunarity", + "" + ], + [ + "float", + "octaves", + "" + ], + [ + "float", + "offset", + "" + ], + [ + "float", + "scale", + "" + ], + [ + "float", + "persistence", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [ + [ + "string", + "attrName", + "hybrid" + ], + [ + "enum float float3", + "attrType", + "float" + ] + ], + "outputs": [ + [ + "", + "prim_2DGrid", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "erode" + ] + }, + "erode_hybridMultifractal_v3": { + "inputs": [ + [ + "", + "prim_2DGrid", + "" + ], + [ + "float", + "H", + "" + ], + [ + "float", + "lacunarity", + "" + ], + [ + "float", + "octaves", + "" + ], + [ + "float", + "offset", + "" + ], + [ + "float", + "scale", + "" + ], + [ + "float", + "persistence", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [ + [ + "string", + "attrName", + "hybrid" + ], + [ + "enum float float3", + "attrType", + "float" + ] + ], + "outputs": [ + [ + "", + "prim_2DGrid", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "erode" + ] + }, + "erode_noise_analytic_simplex_2d": { + "inputs": [ + [ + "", + "prim_2DGrid", + "" + ], + [ + "string", + "posLikeAttrName", + "pos" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [ + [ + "string", + "attrName", + "analyticNoise" + ] + ], + "outputs": [ + [ + "", + "prim_2DGrid", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "erode" + ] + }, + "erode_noise_perlin": { + "inputs": [ + [ + "", + "prim_2DGrid", + "" + ], + [ + "string", + "vec3fAttrName", + "pos" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [ + [ + "string", + "attrName", + "noise" + ], + [ + "enum float float3", + "attrType", + "float" + ] + ], + "outputs": [ + [ + "", + "prim_2DGrid", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "erode" + ] + }, + "erode_noise_simplex": { + "inputs": [ + [ + "", + "prim_2DGrid", + "" + ], + [ + "string", + "posLikeAttrName", + "pos" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [ + [ + "string", + "attrName", + "noise" + ], + [ + "enum float float3", + "attrType", + "float" + ] + ], + "outputs": [ + [ + "", + "prim_2DGrid", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "erode" + ] + }, + "erode_noise_sparse_convolution": { + "inputs": [ + [ + "", + "prim_2DGrid", + "" + ], + [ + "string", + "posLikeAttrName", + "pos" + ], + [ + "int", + "pulsenum", + "3" + ], + [ + "int", + "seed", + "1" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [ + [ + "string", + "attrName", + "noise" + ], + [ + "enum float float3", + "attrType", + "float" + ] + ], + "outputs": [ + [ + "", + "prim_2DGrid", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "erode" + ] + }, + "erode_noise_worley": { + "inputs": [ + [ + "", + "prim_2DGrid", + "" + ], + [ + "vec3f", + "seed", + "" + ], + [ + "string", + "posLikeAttrName", + "pos" + ], + [ + "float", + "celljitter", + "" + ], + [ + "enum Euclidean Chebyshev Manhattan", + "distType", + "Euclidean" + ], + [ + "enum F1 F2-F1", + "fType", + "F1" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [ + [ + "string", + "attrName", + "noise" + ], + [ + "enum float float3", + "attrType", + "float" + ] + ], + "outputs": [ + [ + "", + "prim_2DGrid", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "erode" + ] + }, + "erode_rand_color": { + "inputs": [ + [ + "int", + "iterations", + "0" + ], + [ + "int", + "iter", + "0" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "", + "list", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "erode" + ] + }, + "erode_rand_dir": { + "inputs": [ + [ + "int", + "iterations", + "0" + ], + [ + "int", + "iter", + "0" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "", + "list", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "erode" + ] + }, + "erode_smooth_flow": { + "inputs": [ + [ + "", + "prim_2DGrid", + "" + ], + [ + "float", + "smoothRate", + "" + ], + [ + "string", + "flowName", + "flow" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "", + "prim_2DGrid", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "erode" + ] + }, + "erode_terrainHiMeLo": { + "inputs": [ + [ + "", + "prim_2DGrid", + "" + ], + [ + "string", + "attrName", + "fbm" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "", + "prim_2DGrid", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "erode" + ] + }, + "erode_tumble_material_erosion": { + "inputs": [ + [ + "", + "prim_2DGrid", + "" + ], + [ + "ListObject", + "perm", + "" + ], + [ + "ListObject", + "p_dirs", + "" + ], + [ + "ListObject", + "x_dirs", + "" + ], + [ + "float", + "seed", + "" + ], + [ + "int", + "iterations", + "0" + ], + [ + "int", + "iter", + "0" + ], + [ + "int", + "i", + "0" + ], + [ + "int", + "openborder", + "0" + ], + [ + "float", + "maxdepth", + "" + ], + [ + "float", + "global_erosionrate", + "" + ], + [ + "float", + "erosionrate", + "" + ], + [ + "float", + "cutangle", + "" + ], + [ + "string", + "cutangle_mask_layer", + "cutangle_mask" + ], + [ + "float", + "erodability", + "" + ], + [ + "string", + "erodability_mask_layer", + "erodability_mask" + ], + [ + "float", + "removalrate", + "" + ], + [ + "string", + "removalrate_mask_layer", + "removalrate_mask" + ], + [ + "float", + "gridbias", + "" + ], + [ + "string", + "gridbias_mask_layer", + "gridbias_mask" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "", + "prim_2DGrid", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "erode" + ] + }, + "erode_tumble_material_v0": { + "inputs": [ + [ + "", + "prim_2DGrid", + "" + ], + [ + "ListObject", + "perm", + "" + ], + [ + "ListObject", + "p_dirs", + "" + ], + [ + "ListObject", + "x_dirs", + "" + ], + [ + "float", + "seed", + "" + ], + [ + "int", + "iterations", + "0" + ], + [ + "int", + "iter", + "0" + ], + [ + "int", + "i", + "0" + ], + [ + "int", + "openborder", + "0" + ], + [ + "float", + "maxdepth", + "" + ], + [ + "float", + "global_erosionrate", + "" + ], + [ + "float", + "erosionrate", + "" + ], + [ + "float", + "cutangle", + "" + ], + [ + "string", + "cutangle_mask_layer", + "cutangle_mask" + ], + [ + "float", + "erodability", + "" + ], + [ + "string", + "erodability_mask_layer", + "erodability_mask" + ], + [ + "float", + "removalrate", + "" + ], + [ + "string", + "removalrate_mask_layer", + "removalrate_mask" + ], + [ + "float", + "gridbias", + "" + ], + [ + "string", + "gridbias_mask_layer", + "gridbias_mask" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "", + "prim_2DGrid", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "erode" + ] + }, + "erode_tumble_material_v1": { + "inputs": [ + [ + "", + "HeightField", + "" + ], + [ + "string", + "write_back_material_layer", + "write_back_material" + ], + [ + "int", + "openborder", + "0" + ], + [ + "float", + "repose_angle", + "" + ], + [ + "float", + "flow_rate", + "" + ], + [ + "float", + "height_factor", + "" + ], + [ + "float", + "entrainmentrate", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "", + "HeightField", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "erode" + ] + }, + "erode_tumble_material_v2": { + "inputs": [ + [ + "", + "HeightField", + "" + ], + [ + "string", + "stabilitymask", + "_stability" + ], + [ + "ListObject", + "perm", + "" + ], + [ + "ListObject", + "p_dirs", + "" + ], + [ + "ListObject", + "x_dirs", + "" + ], + [ + "float", + "seed", + "" + ], + [ + "int", + "iterations", + "0" + ], + [ + "int", + "iter", + "0" + ], + [ + "int", + "i", + "0" + ], + [ + "int", + "openborder", + "0" + ], + [ + "float", + "gridbias", + "" + ], + [ + "float", + "repose_angle", + "" + ], + [ + "float", + "quant_amt", + "" + ], + [ + "float", + "flow_rate", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "", + "HeightField", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "erode" + ] + }, + "erode_tumble_material_v3": { + "inputs": [ + [ + "", + "prim_2DGrid", + "" + ], + [ + "string", + "stabilitymask", + "_stability" + ], + [ + "ListObject", + "perm", + "" + ], + [ + "ListObject", + "p_dirs", + "" + ], + [ + "ListObject", + "x_dirs", + "" + ], + [ + "float", + "seed", + "" + ], + [ + "int", + "iterations", + "0" + ], + [ + "int", + "iter", + "0" + ], + [ + "int", + "i", + "0" + ], + [ + "int", + "openborder", + "0" + ], + [ + "float", + "gridbias", + "" + ], + [ + "float", + "repose_angle", + "" + ], + [ + "float", + "quant_amt", + "" + ], + [ + "float", + "flow_rate", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "", + "prim_2DGrid", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "erode" + ] + }, + "erode_tumble_material_v4": { + "inputs": [ + [ + "", + "prim_2DGrid", + "" + ], + [ + "ListObject", + "perm", + "" + ], + [ + "ListObject", + "p_dirs", + "" + ], + [ + "ListObject", + "x_dirs", + "" + ], + [ + "float", + "seed", + "" + ], + [ + "int", + "iterations", + "40" + ], + [ + "int", + "iter", + "0" + ], + [ + "int", + "i", + "0" + ], + [ + "int", + "openborder", + "0" + ], + [ + "float", + "gridbias", + "" + ], + [ + "float", + "global_erosionrate", + "" + ], + [ + "float", + "erodability", + "" + ], + [ + "float", + "erosionrate", + "" + ], + [ + "float", + "bank_angle", + "" + ], + [ + "float", + "removalrate", + "" + ], + [ + "float", + "max_debris_depth", + "" + ], + [ + "int", + "max_erodability_iteration", + "5" + ], + [ + "float", + "initial_erodability_factor", + "" + ], + [ + "float", + "slope_contribution_factor", + "" + ], + [ + "float", + "bed_erosionrate_factor", + "" + ], + [ + "float", + "depositionrate", + "" + ], + [ + "float", + "sedimentcap", + "" + ], + [ + "float", + "bank_erosionrate_factor", + "" + ], + [ + "float", + "max_bank_bed_ratio", + "" + ], + [ + "float", + "quant_amt", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "", + "prim_2DGrid", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "erode" + ] + }, + "erode_value2cond": { + "inputs": [ + [ + "", + "prim_2DGrid", + "" + ], + [ + "float", + "value", + "" + ], + [ + "float", + "seed", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "", + "prim_2DGrid", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "erode" + ] + }, + "erode_voronoi": { + "inputs": [ + [ + "", + "prim", + "" + ], + [ + "", + "featurePrim", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [ + [ + "string", + "attrName", + "voronoi" + ] + ], + "outputs": [ + [ + "", + "prim", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "erode" + ] + }, + "primClean": { + "inputs": [ + [ + "primitive", + "prim", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "primitive", + "prim", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "primitive" + ] + }, + "str2num": { + "inputs": [ + [ + "enum float int", + "type", + "int" + ], + [ + "string", + "str", + "0" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "", + "num", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "deprecated" + ] + }, + "testPoly1": { + "inputs": [ + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "", + "prim", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "WBTest" + ] + }, + "testPoly2": { + "inputs": [ + [ + "", + "prim", + "" + ], + [ + "", + "list", + "" + ], + [ + "", + "SRC", + "" + ] + ], + "params": [], + "outputs": [ + [ + "", + "prim", + "" + ], + [ + "", + "DST", + "" + ] + ], + "categories": [ + "WBTest" + ] + } + }, + "settings": { + "recordinfo": { + "record-path": "", + "video-name": "", + "fps": 24, + "bitrate": 200000, + "numMSAA": 0, + "numOptix": 1, + "width": 1280, + "height": 720, + "export-video": false, + "need-denoise": false, + "auto-remove-cache": true, + "aov": false, + "exr": false, + "exePath": "" + }, + "layoutinfo": { + "orientation": "H", + "left": { + "orientation": "V", + "left": { + "widget": { + "geometry": { + "x": 0.0015625000232830644, + "y": 0.017909003421664239, + "width": 0.4859375059604645, + "height": 0.37270087003707888 + }, + "tabs": [ + { + "type": "View", + "backgroundcolor": [ + 0.18000000715255738, + 0.20000000298023225, + 0.2199999988079071 + ], + "blockwindow": false, + "resolutionX": -1, + "resolutionY": -1, + "resolution-combobox-index": 0 + } + ] + } + }, + "right": { + "widget": { + "geometry": { + "x": 0.0015625000232830644, + "y": 0.3935140371322632, + "width": 0.4859375059604645, + "height": 0.5227492451667786 + }, + "tabs": [ + "Parameter", + "Data", + "Logger", + { + "type": "Optix", + "blockwindow": false, + "resolutionX": -1, + "resolutionY": -1, + "resolution-combobox-index": 0 + } + ] + } + } + }, + "right": { + "widget": { + "geometry": { + "x": 0.48906248807907107, + "y": 0.017909003421664239, + "width": 0.5093749761581421, + "height": 0.8983542919158936 + }, + "tabs": [ + "Editor" + ] + } + } + }, + "userdatainfo": { + "optix-show-background": true + } + }, + "version": "v2.5" +} \ No newline at end of file diff --git a/zenovis/xinxinoptix/Light.h b/zenovis/xinxinoptix/Light.h index 4ec41a3f35..c33ac1e7f7 100644 --- a/zenovis/xinxinoptix/Light.h +++ b/zenovis/xinxinoptix/Light.h @@ -564,11 +564,11 @@ void DirectLighting(RadiancePRD *prd, ShadowPRD& shadowPRD, const float3& shadin float samplePDF; float3 illum = envSky(sample_dir, sunLightDir, make_float3(0., 0., 1.), 40, // be careful - .45, 15., 1.030725f * 0.3f, params.elapsedTime, samplePDF);\ + .45, 15., 1.030725f * 0.3f, params.elapsedTime, samplePDF); samplePDF *= _SKY_PROB_; if(samplePDF <= 0.0f) { return; } - shadeTask(sample_dir, samplePDF, illum, true); + shadeTask(sample_dir, samplePDF, M_PIf*illum, true); } } }; \ No newline at end of file diff --git a/zenovis/xinxinoptix/PTKernel.cu b/zenovis/xinxinoptix/PTKernel.cu index 14aaffbc13..4ee331326a 100644 --- a/zenovis/xinxinoptix/PTKernel.cu +++ b/zenovis/xinxinoptix/PTKernel.cu @@ -482,6 +482,8 @@ extern "C" __global__ void __miss__radiance() ); + envPdf *= params.skyLightProbablity(); + float misWeight = BRDFBasics::PowerHeuristic(prd->samplePdf,envPdf, 1.0f); misWeight = misWeight>0.0f?misWeight:0.0f; From e59f7aa1211c69261f18ba4b0d29803e140aa418 Mon Sep 17 00:00:00 2001 From: iaomw Date: Fri, 18 Oct 2024 16:27:19 +0800 Subject: [PATCH 17/22] Fix StaticMeshes leak --- zenovis/xinxinoptix/optixPathTracer.cpp | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/zenovis/xinxinoptix/optixPathTracer.cpp b/zenovis/xinxinoptix/optixPathTracer.cpp index 5cbee114f7..1122010de4 100644 --- a/zenovis/xinxinoptix/optixPathTracer.cpp +++ b/zenovis/xinxinoptix/optixPathTracer.cpp @@ -788,7 +788,7 @@ static void buildMeshIAS(PathTracerState& state, int rayTypeCount, std::vector &mtlidlut) void UpdateMeshGasAndIas(bool staticNeedUpdate) { - buildMeshAccel(state, StaticMeshes); - tbb::parallel_for(static_cast(0), g_meshPieces.size(), [](size_t i){ buildMeshAccel(state, g_meshPieces[i]); }); @@ -2555,6 +2553,8 @@ static void updateStaticDrawObjects() { tri_offset += dat.tris.size() / 3; ver_offset += dat.verts.size() / 3; } + + buildMeshAccel(state, StaticMeshes); } static void updateDynamicDrawObjects() { From 05e7d765fd15e0008db36f26d735396a52aeae9f Mon Sep 17 00:00:00 2001 From: iaomw Date: Fri, 18 Oct 2024 16:27:34 +0800 Subject: [PATCH 18/22] Minor update --- zenovis/xinxinoptix/XAS.h | 7 +++++++ 1 file changed, 7 insertions(+) diff --git a/zenovis/xinxinoptix/XAS.h b/zenovis/xinxinoptix/XAS.h index 87d2c6e42c..c46ef6868f 100644 --- a/zenovis/xinxinoptix/XAS.h +++ b/zenovis/xinxinoptix/XAS.h @@ -118,6 +118,13 @@ namespace xinxinoptix { inline void buildIAS(OptixDeviceContext& context, OptixAccelBuildOptions& accel_options, std::vector& instances, raii& bufferIAS, OptixTraversableHandle& handleIAS) { + + if (instances.empty()) { + bufferIAS.reset(); + handleIAS = 0llu; + return; + } + raii d_instances; const size_t size_in_bytes = sizeof( OptixInstance ) * instances.size(); CUDA_CHECK( cudaMalloc( reinterpret_cast( &d_instances.reset() ), size_in_bytes ) ); From 0c45cbd43fa6f56b6f8f7e84d844289d451ea801 Mon Sep 17 00:00:00 2001 From: iaomw Date: Fri, 18 Oct 2024 21:14:57 +0800 Subject: [PATCH 19/22] Fix miss material lookup --- zenovis/src/optx/RenderEngineOptx.cpp | 6 ++++-- zenovis/xinxinoptix/optixPathTracer.cpp | 6 ++++-- 2 files changed, 8 insertions(+), 4 deletions(-) diff --git a/zenovis/src/optx/RenderEngineOptx.cpp b/zenovis/src/optx/RenderEngineOptx.cpp index 86dfb398e5..3a52826c72 100644 --- a/zenovis/src/optx/RenderEngineOptx.cpp +++ b/zenovis/src/optx/RenderEngineOptx.cpp @@ -1372,7 +1372,8 @@ struct RenderEngineOptx : RenderEngine, zeno::disable_copy { ensure_shadtmpl(_volume_shader_template); ensure_shadtmpl(_light_shader_template); - if (cachedMeshesMaterials.count("Default")) { + //if (cachedMeshesMaterials.count("Default")) + { auto tmp = std::make_shared(); tmp->mark = ShaderMark::Mesh; @@ -1385,7 +1386,8 @@ struct RenderEngineOptx : RenderEngine, zeno::disable_copy { meshMatLUT.insert({"Default", 0}); } - if (cachedSphereMaterials.count("Default")) { + //if (cachedSphereMaterials.count("Default")) + { auto tmp = std::make_shared(); tmp->mark = ShaderMark::Sphere; diff --git a/zenovis/xinxinoptix/optixPathTracer.cpp b/zenovis/xinxinoptix/optixPathTracer.cpp index 1122010de4..7e114534fc 100644 --- a/zenovis/xinxinoptix/optixPathTracer.cpp +++ b/zenovis/xinxinoptix/optixPathTracer.cpp @@ -744,8 +744,10 @@ static void buildMeshAccel( PathTracerState& state, std::shared_ptr m ) ); // // Build triangle GAS // // One per SBT record for this build input + auto numSbtRecords = g_mtlidlut.empty() ? 1 : g_mtlidlut.size(); + std::vector triangle_input_flags(//MAT_COUNT - g_mtlidlut.size(), + numSbtRecords, OPTIX_GEOMETRY_FLAG_REQUIRE_SINGLE_ANYHIT_CALL); OptixBuildInput triangle_input = {}; @@ -755,7 +757,7 @@ static void buildMeshAccel( PathTracerState& state, std::shared_ptr m triangle_input.triangleArray.numVertices = static_cast( mesh->vertices.size() ); triangle_input.triangleArray.vertexBuffers = mesh->vertices.empty() ? nullptr : &dverts; triangle_input.triangleArray.flags = triangle_input_flags.data(); - triangle_input.triangleArray.numSbtRecords = mesh->vertices.empty() ? 1 : g_mtlidlut.size(); + triangle_input.triangleArray.numSbtRecords = numSbtRecords; triangle_input.triangleArray.sbtIndexOffsetBuffer = dmats; triangle_input.triangleArray.sbtIndexOffsetSizeInBytes = sizeof( uint32_t ); triangle_input.triangleArray.sbtIndexOffsetStrideInBytes = sizeof( uint32_t ); From 92a76ce2711ed98771a1c898286bdce4166d2e80 Mon Sep 17 00:00:00 2001 From: iaomw Date: Tue, 22 Oct 2024 16:36:56 +0800 Subject: [PATCH 20/22] default width for linear curve (#2046) * default width for linear curve * remove --- zenovis/xinxinoptix/hair/optixHair.cpp | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/zenovis/xinxinoptix/hair/optixHair.cpp b/zenovis/xinxinoptix/hair/optixHair.cpp index f897306426..5af2d16dc8 100644 --- a/zenovis/xinxinoptix/hair/optixHair.cpp +++ b/zenovis/xinxinoptix/hair/optixHair.cpp @@ -58,10 +58,13 @@ void HairState::makeCurveGroupGAS(OptixDeviceContext context, std::vector dummy = widths; for( auto strand = strands.begin(); strand != strands.end() - 1; ++strand ) { + + if (zeno::CurveType::LINEAR == curveType) { break; } + const int end = *( strand + 1 ) - 1; auto degree = CurveDegree(curveType); - if (zeno::CurveType::CATROM == curveType ) { + if (zeno::CurveType::CATROM == curveType) { degree -= 1; } From b1903a07f60927321290e85ade4ce4a11d53d822 Mon Sep 17 00:00:00 2001 From: iaomw Date: Fri, 25 Oct 2024 20:31:13 +0800 Subject: [PATCH 21/22] fix ray ending condition --- zenovis/xinxinoptix/DeflMatShader.cu | 2 -- zenovis/xinxinoptix/Light.cu | 2 ++ zenovis/xinxinoptix/PTKernel.cu | 6 +++--- zenovis/xinxinoptix/TraceStuff.h | 1 - 4 files changed, 5 insertions(+), 6 deletions(-) diff --git a/zenovis/xinxinoptix/DeflMatShader.cu b/zenovis/xinxinoptix/DeflMatShader.cu index abe384de71..4fcabf34a4 100644 --- a/zenovis/xinxinoptix/DeflMatShader.cu +++ b/zenovis/xinxinoptix/DeflMatShader.cu @@ -658,8 +658,6 @@ extern "C" __global__ void __closesthit__radiance() } prd->attenuation2 = prd->attenuation; prd->passed = true; - prd->adepth++; - //prd->samplePdf = 0.0f; //you shall pass! prd->radiance = make_float3(0.0f); prd->_tmin_ = optixGetRayTmax(); diff --git a/zenovis/xinxinoptix/Light.cu b/zenovis/xinxinoptix/Light.cu index bc53d54cca..c908ca0969 100644 --- a/zenovis/xinxinoptix/Light.cu +++ b/zenovis/xinxinoptix/Light.cu @@ -282,6 +282,8 @@ extern "C" __global__ void __closesthit__radiance() // if (scatterPDF > __FLT_DENORM_MIN__) { // prd->radiance /= scatterPDF; // } + auto tmp = float3{1, 1, 1}; + prd->updateAttenuation(tmp); } return; } diff --git a/zenovis/xinxinoptix/PTKernel.cu b/zenovis/xinxinoptix/PTKernel.cu index 4ee331326a..71fdb80543 100644 --- a/zenovis/xinxinoptix/PTKernel.cu +++ b/zenovis/xinxinoptix/PTKernel.cu @@ -244,7 +244,7 @@ extern "C" __global__ void __raygen__rg() RadiancePRD prd; prd.pixel_area = cam.height/(float)(h)/(cam.focal_length); - prd.adepth = 0; + prd.emission = make_float3(0.f); prd.radiance = make_float3(0.f); prd.attenuation = make_float3(1.f); @@ -344,11 +344,11 @@ extern "C" __global__ void __raygen__rg() prd.done = true; } - if( prd.done || params.simpleRender==true || prd.adepth>64){ + if( prd.done || prd.depth>prd.max_depth){ break; } - if(prd.depth > prd.max_depth){ + if(prd.depth > 1){ float RRprob = max(max(prd.attenuation.x, prd.attenuation.y), prd.attenuation.z); RRprob = min(RRprob, 0.99f); if(rnd(prd.seed) > RRprob) { diff --git a/zenovis/xinxinoptix/TraceStuff.h b/zenovis/xinxinoptix/TraceStuff.h index d1ee364604..25659fa3d7 100644 --- a/zenovis/xinxinoptix/TraceStuff.h +++ b/zenovis/xinxinoptix/TraceStuff.h @@ -103,7 +103,6 @@ struct RadiancePRD int curMatIdx; float samplePdf; bool fromDiff; - unsigned char adepth; bool alphaHit; vec3 mask_value; vec3 click_pos; From 9b713886f5673ad99d9ab0d0b2d6a1648c59b8bc Mon Sep 17 00:00:00 2001 From: iaomw Date: Mon, 28 Oct 2024 18:43:45 +0800 Subject: [PATCH 22/22] fix gamma artifacts --- zenovis/xinxinoptix/SDK/cuda/helpers.h | 6 ++---- 1 file changed, 2 insertions(+), 4 deletions(-) diff --git a/zenovis/xinxinoptix/SDK/cuda/helpers.h b/zenovis/xinxinoptix/SDK/cuda/helpers.h index 142927e0e2..fec351015c 100644 --- a/zenovis/xinxinoptix/SDK/cuda/helpers.h +++ b/zenovis/xinxinoptix/SDK/cuda/helpers.h @@ -36,10 +36,8 @@ __forceinline__ __device__ float3 toSRGB( const float3& c, float gamma ) { float invGamma = 1.0f / gamma; float3 powed = make_float3( powf( c.x, invGamma ), powf( c.y, invGamma ), powf( c.z, invGamma ) ); - return make_float3( - c.x < 0.0031308f ? 12.92f * c.x : 1.055f * powed.x - 0.055f, - c.y < 0.0031308f ? 12.92f * c.y : 1.055f * powed.y - 0.055f, - c.z < 0.0031308f ? 12.92f * c.z : 1.055f * powed.z - 0.055f ); + + return powed; } __forceinline__ __device__ unsigned char quantizeUnsigned8Bits( float x )