diff --git a/.gitattributes b/.gitattributes new file mode 100644 index 0000000..dfe0770 --- /dev/null +++ b/.gitattributes @@ -0,0 +1,2 @@ +# Auto detect text files and perform LF normalization +* text=auto diff --git a/CHANGELOG.md b/CHANGELOG.md new file mode 100644 index 0000000..96bd75f --- /dev/null +++ b/CHANGELOG.md @@ -0,0 +1,4 @@ +Changelog +========= + +v 0.1.0 Initial release. \ No newline at end of file diff --git a/CHANGELOG.md.meta b/CHANGELOG.md.meta new file mode 100644 index 0000000..2cfb7e2 --- /dev/null +++ b/CHANGELOG.md.meta @@ -0,0 +1,7 @@ +fileFormatVersion: 2 +guid: b06a6b0d8ff290c4b81ca364b8188469 +TextScriptImporter: + externalObjects: {} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Compute.meta b/Compute.meta new file mode 100644 index 0000000..f9960bb --- /dev/null +++ b/Compute.meta @@ -0,0 +1,8 @@ +fileFormatVersion: 2 +guid: 744598956f18b8a4b8ca9f32c89805f0 +folderAsset: yes +DefaultImporter: + externalObjects: {} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Compute/RLBakeShader.compute b/Compute/RLBakeShader.compute new file mode 100644 index 0000000..0a64400 --- /dev/null +++ b/Compute/RLBakeShader.compute @@ -0,0 +1,949 @@ +#include "UnityCG.cginc" + +// Kernels +// +#pragma kernel RLDiffuseBlend +#pragma kernel RLMask +#pragma kernel RLNormalBlend +#pragma kernel RLHeadDiffuse +#pragma kernel RLHeadMask +#pragma kernel RLSkinMask +#pragma kernel RLHeadSubsurface +#pragma kernel RLSkinSubsurface +#pragma kernel RLDetail +#pragma kernel RLSubsurface +#pragma kernel RLThickness +#pragma kernel RLTeethDiffuse +#pragma kernel RLTeethMask +#pragma kernel RLTeethSubsurface +#pragma kernel RLTeethThickness +#pragma kernel RLTongueDiffuse +#pragma kernel RLTongueMask +#pragma kernel RLTongueSubsurface +#pragma kernel RLCorneaDiffuse +#pragma kernel RLEyeDiffuse +#pragma kernel RLCorneaMask +#pragma kernel RLEyeMask +#pragma kernel RLCorneaThickness +#pragma kernel RLHairColoredDiffuse +#pragma kernel RLHairDiffuse +#pragma kernel RLHairMask +#pragma kernel RLEyeOcclusionDiffuse + +// Defines +// +#define SAMPLE(tex,coord) tex.SampleLevel (sampler##tex,coord, 0) +#define SAMPLE_NORMAL(tex, coord) UnpackNormal(tex.SampleLevel (sampler##tex,coord, 0)) +#define UPACK(comp) ((comp + 1.0) * 0.5) +#define INVERTED_SCALE(val, fac) (1.0 - ((1.0 - val) * fac)) +#define INVERTED_POWER_SCALE(val, power, fac) (1.0 - ((1.0 - pow(val, power)) * fac)) +#define RADIAL(uv) (length(uv - float2(0.5, 0.5))) +#define HSV(c, h, s, v) (Saturation_float3(Hue_float3(c, h), s) * v); +#define SV(c, s, v) (Saturation_float3(c, s) * v); +#define TEX2D(tex) Texture2Dtex; SamplerState sampler##tex + + +// Compute Shader Output +// +RWTexture2D Result; + +// Compute Shader Inputs +// +TEX2D(Diffuse); +TEX2D(ColorBlend); +float colorBlendStrength; + +TEX2D(Normal); +TEX2D(NormalBlend); +float normalBlendStrength; + +TEX2D(Mask); + +TEX2D(CavityAO); +float smoothnessMin, smoothnessMax, smoothnessPower; +float aoStrength; +float mouthAOPower, nostrilAOPower, lipsAOPower; + +TEX2D(RGBAMask); +TEX2D(NMUILMask); +TEX2D(CFULCMask); +TEX2D(EarNeckMask); +float microSmoothnessMod; +float rMSM, gMSM, bMSM, aMSM; +float noseMSM; +float mouthMSM; +float upperLidMSM; +float innerLidMSM; +float earMSM; +float neckMSM; +float cheekMSM; +float foreheadMSM; +float upperLipMSM; +float chinMSM; +float unmaskedMSM; +float rSS, gSS, bSS, aSS; +float noseSS; +float mouthSS; +float upperLidSS; +float innerLidSS; +float earSS; +float neckSS; +float cheekSS; +float foreheadSS; +float upperLipSS; +float chinSS; +float unmaskedSS; + +TEX2D(MicroNormal); +float microNormalStrength; + +TEX2D(Subsurface); +float subsurfaceScale; + +TEX2D(Thickness); +float thicknessScale; + +TEX2D(GradientAO); +TEX2D(GumsMask); +float frontAO; +float rearAO; +float gumsSaturation, gumsBrightness; +float teethSaturation, teethBrightness; +float tongueSaturation, tongueBrightness; +float gumsSSS, teethSSS, tongueSSS; +float gumsThickness, teethThickness, tongueThickness; +float isUpperTeeth; + +TEX2D(ScleraDiffuse); +TEX2D(CorneaDiffuse); +float irisScale, irisHue, irisSaturation, irisBrightness; +float scleraScale, scleraHue, scleraSaturation, scleraBrightness; +float pupilScale; +float irisRadius, limbusWidth; +float limbusDarkRadius, limbusDarkWidth; +float shadowRadius, shadowHardness; +float4 cornerShadowColor, limbusColor; +float depthRadius; +float corneaSmoothness, scleraSmoothness, irisSmoothness; + +TEX2D(Flow); +TEX2D(ID); +TEX2D(Root); +TEX2D(Specular); +float4 baseColor, vertexBaseColor; +float vertexColorStrength, baseColorStrength, diffuseStrength, alphaPower, alphaRemap; +float globalStrength, rootColorStrength, endColorStrength, invertRootMap; +float3 highlightADistribution, highlightBDistribution; +float highlightAStrength, highlightAOverlapEnd, highlightAOverlapInvert; +float highlightBStrength, highlightBOverlapEnd, highlightBOverlapInvert; +float4 rootColor, endColor, highlightAColor, highlightBColor; +float aoOccludeAll; + +float eoInnerMin, eoInnerMax, eoOuterMin, eoOuterMax; +float eoTopMin, eoTopMax, eoTopCurve, eoBottomMin, eoBottomMax, eoBottomCurve; +float eoOcclusionStrength, eoTop2Min, eoTop2Max, eoOcclusionStrength2; +float eoTearDuctPosition, eoTearDuctWidth, eoOcclusionPower; +float4 eoEyeOcclusionColor; + + +// Node functions +// +float4 BlendOverlay_float4(float4 Base, float4 Blend, float Opacity) +{ + float4 result1 = 1.0 - 2.0 * (1.0 - Base) * (1.0 - Blend); + float4 result2 = 2.0 * Base * Blend; + float4 zeroOrOne = step(Base, 0.5); + float4 Out = result2 * zeroOrOne + (1 - zeroOrOne) * result1; + return lerp(Base, Out, Opacity); +} + +float4 BlendMultiply_float4(float4 Base, float4 Blend, float Opacity) +{ + float4 Out = Base * Blend; + return lerp(Base, Out, Opacity); +} + +float4 BlendOverwrite_float4(float4 Base, float4 Blend, float Opacity) +{ + return lerp(Base, Blend, Opacity); +} + +void NormalStrength_float3(float3 In, float Strength, out float3 Out) +{ + Out = float3(In.rg * Strength, lerp(1, In.b, saturate(Strength))); +} + +void NormalBlend_float3(float3 A, float3 B, out float3 Out) +{ + Out = normalize(float3(A.rg + B.rg, A.b * B.b)); +} + +void NormalBlendReoriented_float3(float3 A, float3 B, out float3 Out) +{ + float3 t = A.xyz + float3(0.0, 0.0, 1.0); + float3 u = B.xyz * float3(-1.0, -1.0, 1.0); + Out = (t / t.z) * dot(t, u) - u; +} + + +float3 Hue_float3(float3 In, float Offset) +{ + // this expects the hue offset in normalized form i.e. 0.0 - 1.0, with 0.5 being no offset. + Offset = Offset * 360.0 - 180.0; + float4 K = float4(0.0, -1.0 / 3.0, 2.0 / 3.0, -1.0); + float4 P = lerp(float4(In.bg, K.wz), float4(In.gb, K.xy), step(In.b, In.g)); + float4 Q = lerp(float4(P.xyw, In.r), float4(In.r, P.yzx), step(P.x, In.r)); + float D = Q.x - min(Q.w, Q.y); + float E = 1e-10; + float3 hsv = float3(abs(Q.z + (Q.w - Q.y) / (6.0 * D + E)), D / (Q.x + E), Q.x); + + float hue = hsv.x + Offset / 360.0; + hsv.x = (hue < 0) + ? hue + 1 + : (hue > 1) + ? hue - 1 + : hue; + + float4 K2 = float4(1.0, 2.0 / 3.0, 1.0 / 3.0, 3.0); + float3 P2 = abs(frac(hsv.xxx + K2.xyz) * 6.0 - K2.www); + return hsv.z * lerp(K2.xxx, saturate(P2 - K2.xxx), hsv.y); +} + +float3 Saturation_float3(float3 In, float Saturation) +{ + float luma = dot(In, float3(0.2126729, 0.7151522, 0.0721750)); + return luma.xxx + Saturation.xxx * (In - luma.xxx); +} + +float Remap_float(float In, float InMin, float InMax, float OutMin, float OutMax) +{ + return OutMin + (In - InMin) * (OutMax - OutMin) / (InMax - InMin); +} + +float2 TilingOffset(float2 uv, float scale, float2 offset) +{ + float tilingScale = 1.0 / scale; + float2 tilingOffset = (1.0 - tilingScale) * offset; + return uv * tilingScale + tilingOffset; +} + +/* for reference... +fixed3 UnpackNormal(fixed4 packednormal) +{ +#if defined(SHADER_API_GLES) || defined(SHADER_API_MOBILE) + return packednormal.xyz * 2 - 1; +#else + fixed3 normal; + normal.xy = packednormal.wy * 2 - 1; + normal.z = sqrt(1 - normal.x * normal.x - normal.y * normal.y); + return normal; +#endif +}*/ + +float4 PackNormal(float3 n) +{ + return float4(UPACK(n), 1.0); +} + +/* +half4 LinearTosRGB(half4 linRGB) +{ + linRGB = max(linRGB, half4(0.h, 0.h, 0.h, 0.h)); + return half4((max(1.055h * pow(linRGB, 0.416666667h) - 0.055h, 0.h)).xyzw); +} + +half LinearTosRGB(half lin) +{ + lin = max(lin, 0.0h); + return max(1.055h * pow(lin, 0.416666667h) - 0.055h, 0.h); +} + +*/ + + +float4 LinearTosRGB(float4 In) +{ + float3 sRGBLo = In.xyz * 12.92; + float3 sRGBHi = (pow(max(abs(In.xyz), 1.192092896e-07), float3(1.0 / 2.4, 1.0 / 2.4, 1.0 / 2.4)) * 1.055) - 0.055; + float3 sRGB = float3(In.xyz <= 0.0031308) ? sRGBLo : sRGBHi; + return float4(sRGB, In.a); +} + +float LinearTosRGB(float In) +{ + float sRGBLo = In * 12.92; + float sRGBHi = (pow(max(abs(In), 1.192092896e-07), 1.0 / 2.4) * 1.055) - 0.055; + return In <= 0.0031308 ? sRGBLo : sRGBHi; +} + +float4 sRGBToLinear(float4 In) +{ + float3 linRGBLo = In.rgb / 12.92;; + float3 linRGBHi = pow(max(abs((In.rgb + 0.055) / 1.055), 1.192092896e-07), float3(2.4, 2.4, 2.4)); + float3 lin = float3(In.rgb <= 0.04045) ? linRGBLo : linRGBHi; + return float4(lin, In.a); +} + +half4 LinearTosRGBApprox(half4 In) +{ + half3 linRGB = max(In.rgb, half3(0.h, 0.h, 0.h)); + linRGB = max(1.055h * pow(linRGB, 0.416666667h) - 0.055h, 0.h); + return float4(linRGB, In.a); +} + +half4 sRGBToLinearApprox(half4 In) +{ + half3 sRGB = In.rgb; + sRGB = sRGB * (sRGB * (sRGB * 0.305306011h + 0.682171111h) + 0.012522878h); + return float4(sRGB, In.a); +} + +float sRGBToLinear(float In) +{ + float linearRGBLo = In / 12.92; + float linearRGBHi = pow(max(abs((In + 0.055) / 1.055), 1.192092896e-07), 2.4); + return In <= 0.04045 ? linearRGBLo : linearRGBHi; +} + +float2 GetUV(int2 xy) +{ + int w, h; + Result.GetDimensions(w, h); + return float2(float(xy.x + 0.5) / float(w), float(xy.y + 0.5) / float(h)); +} + +// Generic Bake kernels +// +[numthreads(1, 1, 1)] +void RLDiffuseBlend(uint3 id : SV_DispatchThreadID) +{ + float2 uv = GetUV(id.xy); + + float4 diffuse = SAMPLE(Diffuse, uv); + float4 colorBlend = SAMPLE(ColorBlend, uv); + + float4 ob = BlendOverlay_float4(diffuse, colorBlend, colorBlendStrength); + + Result[id.xy] = LinearTosRGB(ob); +} + +[numthreads(1, 1, 1)] +void RLMask(uint3 id : SV_DispatchThreadID) +{ + float2 uv = GetUV(id.xy); + + float4 mask = SAMPLE(Mask, uv); + + float metallic = mask.r; + float ao = INVERTED_SCALE(mask.g, aoStrength); + float detailMask = mask.b * microNormalStrength; + float smoothness = lerp(smoothnessMin, smoothnessMax, pow(mask.a, smoothnessPower)); + float4 packed = float4(metallic, ao, detailMask, smoothness); + + Result[id.xy] = packed; +} + +[numthreads(1, 1, 1)] +void RLNormalBlend(uint3 id : SV_DispatchThreadID) +{ + float2 uv = GetUV(id.xy); + + float3 normal = SAMPLE_NORMAL(Normal, uv); + float3 normalBlend = SAMPLE_NORMAL(NormalBlend, uv); + + float3 bn, on; + NormalStrength_float3(normalBlend, normalBlendStrength, bn); + NormalBlend_float3(normal, bn, on); + + Result[id.xy] = PackNormal(on); +} + +[numthreads(1, 1, 1)] +void RLDetail(uint3 id : SV_DispatchThreadID) +{ + float2 uv = GetUV(id.xy); + + float3 microNormal = SAMPLE_NORMAL(MicroNormal, uv); + + float4 packed; + packed.xz = 0.5; + packed.wy = UPACK(microNormal.xy); + + Result[id.xy] = packed; +} + +[numthreads(1, 1, 1)] +void RLSubsurface(uint3 id : SV_DispatchThreadID) +{ + float2 uv = GetUV(id.xy); + + float4 subsurface = subsurfaceScale * SAMPLE(Subsurface, uv); + + subsurface.a = 1.0; + + Result[id.xy] = subsurface; +} + +[numthreads(1, 1, 1)] +void RLThickness(uint3 id : SV_DispatchThreadID) +{ + float2 uv = GetUV(id.xy); + + float4 thickness = 1.0 - (SAMPLE(Thickness, uv) * thicknessScale); + + thickness.a = 1.0; + + Result[id.xy] = thickness; +} + + +// Skin and Head Bake Kernels +// +void HeadSmoothnessScatterMask(float2 uv, out float ScatterMask, out float SmoothnessMod) +{ + float4 In1 = SAMPLE(NMUILMask, uv); + float4 In2 = SAMPLE(CFULCMask, uv); + float4 In3 = SAMPLE(EarNeckMask, uv); + float4 Mod1 = float4(noseMSM, mouthMSM, upperLidMSM, innerLidMSM); + float4 Mod2 = float4(cheekMSM, foreheadMSM, upperLipMSM, chinMSM); + float4 Mod3 = float4(neckMSM, earMSM, 0.0, 0.0); + float4 Scatter1 = float4(noseSS, mouthSS, upperLidSS, innerLidSS); + float4 Scatter2 = float4(cheekSS, foreheadSS, upperLipSS, chinSS); + float4 Scatter3 = float4(neckSS, earSS, 0.0, 0.0); + + float4 m = In1 + In2 + In3; + float mask = saturate(m.x + m.y + m.z + m.w); + float unmask = 1.0 - mask; + + float4 ms = (In1 * Mod1) + (In2 * Mod2) + (In3 * Mod3); + SmoothnessMod = ms.x + ms.y + ms.z + ms.w + (unmask * unmaskedMSM); + + float4 ss = (In1 * Scatter1) + (In2 * Scatter2) + (In3 * Scatter3); + ScatterMask = ss.x + ss.y + ss.z + ss.w + (unmask * unmaskedSS); +} + +float HeadSmoothnessMod(float2 uv) +{ + float4 In1 = SAMPLE(NMUILMask, uv); + float4 In2 = SAMPLE(CFULCMask, uv); + float4 In3 = SAMPLE(EarNeckMask, uv); + float4 Mod1 = float4(noseMSM, mouthMSM, upperLidMSM, innerLidMSM); + float4 Mod2 = float4(cheekMSM, foreheadMSM, upperLipMSM, chinMSM); + float4 Mod3 = float4(neckMSM, earMSM, 0.0, 0.0); + + float4 m = In1 + In2 + In3; + float mask = saturate(m.x + m.y + m.z + m.w); + float unmask = 1.0 - mask; + + float4 ms = (In1 * Mod1) + (In2 * Mod2) + (In3 * Mod3); + return ms.x + ms.y + ms.z + ms.w + (unmask * unmaskedMSM); +} + +float HeadScatterMask(float2 uv) +{ + float4 In1 = SAMPLE(NMUILMask, uv); + float4 In2 = SAMPLE(CFULCMask, uv); + float4 In3 = SAMPLE(EarNeckMask, uv); + In3.zw = 0.0; + float4 Scatter1 = float4(noseSS, mouthSS, upperLidSS, innerLidSS); + float4 Scatter2 = float4(cheekSS, foreheadSS, upperLipSS, chinSS); + float4 Scatter3 = float4(neckSS, earSS, 0.0, 0.0); + + float4 m = In1 + In2 + In3; + float mask = saturate(m.x + m.y + m.z + m.w); + float unmask = 1.0 - mask; + + float4 ss = (In1 * Scatter1) + (In2 * Scatter2) + (In3 * Scatter3); + return ss.x + ss.y + ss.z + ss.w + (unmask * unmaskedSS); +} + +void SkinSmoothnessScatterMask(float2 uv, out float ScatterMask, out float SmoothnessMod) +{ + float4 In1 = SAMPLE(RGBAMask, uv); + float4 Mod1 = float4(rMSM, gMSM, bMSM, aMSM); + float4 Scatter1 = float4(rSS, gSS, bSS, aSS); + + float mask = saturate(In1.r + In1.g + In1.b + In1.a); + float unmask = 1.0 - mask; + + float4 ms = In1 * Mod1; + SmoothnessMod = ms.x + ms.y + ms.z + ms.w + (unmask * unmaskedMSM); + + float4 ss = In1 * Scatter1; + ScatterMask = ss.x + ss.y + ss.z + ss.w + (unmask * unmaskedSS); +} + +float SkinSmoothnessMod(float2 uv) +{ + float4 In1 = SAMPLE(RGBAMask, uv); + float4 Mod1 = float4(rMSM, gMSM, bMSM, aMSM); + + float mask = saturate(In1.r + In1.g + In1.b + In1.a); + float unmask = 1.0 - mask; + + float4 ms = In1 * Mod1; + return ms.x + ms.y + ms.z + ms.w + (unmask * unmaskedMSM); +} + +float SkinScatterMask(float2 uv) +{ + float4 In1 = SAMPLE(RGBAMask, uv); + float4 Scatter1 = float4(rSS, gSS, bSS, aSS); + + float mask = saturate(In1.r + In1.g + In1.b + In1.a); + float unmask = 1.0 - mask; + + float4 ss = In1 * Scatter1; + return ss.x + ss.y + ss.z + ss.w + (unmask * unmaskedSS); +} + +float HeadCavityAO(float2 uv) +{ + float4 cavityAO = SAMPLE(CavityAO, uv); + + float mouthAO = pow(cavityAO.g, mouthAOPower); + float nostrilAO = pow(cavityAO.b, nostrilAOPower); + float lipsAO = pow(cavityAO.a, lipsAOPower); + return saturate(mouthAO * nostrilAO * lipsAO); +} + +[numthreads(1, 1, 1)] +void RLHeadDiffuse(uint3 id : SV_DispatchThreadID) +{ + float2 uv = GetUV(id.xy); + + float4 diffuse = SAMPLE(Diffuse, uv); + float alpha = diffuse.a; + float4 colorBlend = SAMPLE(ColorBlend, uv); + + float cavityAO = HeadCavityAO(uv); + float4 ob = BlendOverlay_float4(diffuse, colorBlend, colorBlendStrength); + float4 cavityBlend = ob * cavityAO; + cavityBlend.a = alpha; + + Result[id.xy] = LinearTosRGB(cavityBlend); +} + +[numthreads(1, 1, 1)] +void RLHeadMask(uint3 id : SV_DispatchThreadID) +{ + float2 uv = GetUV(id.xy); + + float4 mask = SAMPLE(Mask, uv); + float cavityAO = HeadCavityAO(uv); + float smoothnessMod = HeadSmoothnessMod(uv); + + float metallic = mask.r; + float ao = INVERTED_SCALE(mask.g, aoStrength) * cavityAO; + float detailMask = mask.b * microNormalStrength; + float smoothness = lerp(smoothnessMin, smoothnessMax, pow(mask.a, smoothnessPower)); + smoothness = saturate((1.0 + smoothnessMod + microSmoothnessMod) * smoothness); + float4 packed = float4(metallic, ao, detailMask, smoothness); + + Result[id.xy] = packed; +} + +[numthreads(1, 1, 1)] +void RLSkinMask(uint3 id : SV_DispatchThreadID) +{ + float2 uv = GetUV(id.xy); + + float4 mask = SAMPLE(Mask, uv); + float smoothnessMod = SkinSmoothnessMod(uv); + + float metallic = mask.r; + float ao = INVERTED_SCALE(mask.g, aoStrength); + float detailMask = mask.b * microNormalStrength; + float smoothness = lerp(smoothnessMin, smoothnessMax, pow(mask.a, smoothnessPower)); + smoothness = saturate((1.0 + smoothnessMod + microSmoothnessMod) * smoothness); + float4 packed = float4(metallic, ao, detailMask, smoothness); + + Result[id.xy] = packed; +} + +[numthreads(1, 1, 1)] +void RLHeadSubsurface(uint3 id : SV_DispatchThreadID) +{ + float2 uv = GetUV(id.xy); + float scatterMask = HeadScatterMask(uv); + + float4 subsurface = (scatterMask * subsurfaceScale) * SAMPLE(Subsurface, uv); + + subsurface.a = 1.0; + + Result[id.xy] = saturate(subsurface); +} + +[numthreads(1, 1, 1)] +void RLSkinSubsurface(uint3 id : SV_DispatchThreadID) +{ + float2 uv = GetUV(id.xy); + float scatterMask = SkinScatterMask(uv); + + float4 subsurface = (scatterMask * subsurfaceScale) * SAMPLE(Subsurface, uv); + + subsurface.a = 1.0; + + Result[id.xy] = saturate(subsurface); +} + + +// Teeth and Tongue Bake Kernels +// +[numthreads(1, 1, 1)] +void RLTeethDiffuse(uint3 id : SV_DispatchThreadID) +{ + float2 uv = GetUV(id.xy); + + float4 diffuse = SAMPLE(Diffuse, uv); + float4 gradientAO = SAMPLE(GradientAO, uv); + float4 gumsMask = SAMPLE(GumsMask, uv); + + float aoFactor = lerp(gradientAO.r, gradientAO.g, isUpperTeeth); + float aoMask = lerp(rearAO, frontAO, aoFactor); + float3 gums = SV(diffuse, gumsSaturation, gumsBrightness); + float3 teeth = SV(diffuse, teethSaturation, teethBrightness); + float3 teethGums = lerp(gums, teeth, gumsMask); + float4 baseColor = float4(teethGums * aoMask, 1.0); + + Result[id.xy] = LinearTosRGB(baseColor); +} + +[numthreads(1, 1, 1)] +void RLTeethMask(uint3 id : SV_DispatchThreadID) +{ + float2 uv = GetUV(id.xy); + + float4 mask = SAMPLE(Mask, uv); + float4 gradientAO = SAMPLE(GradientAO, uv); + + float aoFactor = lerp(gradientAO.r, gradientAO.g, isUpperTeeth); + float aoMask = lerp(rearAO, frontAO, aoFactor); + float metallic = mask.r; + float ao = INVERTED_SCALE(mask.g, aoStrength); + float detailMask = mask.b * microNormalStrength; + float smoothness = lerp(smoothnessMin, smoothnessMax, pow(mask.a, smoothnessPower)); + smoothness = lerp(0.0, smoothness, aoMask); + float4 packed = float4(metallic, ao, detailMask, smoothness); + + Result[id.xy] = packed; +} + +[numthreads(1, 1, 1)] +void RLTeethSubsurface(uint3 id : SV_DispatchThreadID) +{ + float2 uv = GetUV(id.xy); + + float4 gradientAO = SAMPLE(GradientAO, uv); + float4 gumsMask = SAMPLE(GumsMask, uv); + + float aoFactor = lerp(gradientAO.r, gradientAO.g, isUpperTeeth); + float aoMask = lerp(rearAO, frontAO, aoFactor); + float4 subsurface = float4(lerp(gumsSSS.xxx, teethSSS.xxx, gumsMask) * aoMask, 1.0); + + Result[id.xy] = subsurface; +} + +[numthreads(1, 1, 1)] +void RLTeethThickness(uint3 id : SV_DispatchThreadID) +{ + float2 uv = GetUV(id.xy); + + float4 gumsMask = SAMPLE(GumsMask, uv); + + float4 thickness = float4(lerp(gumsThickness.xxx, teethThickness.xxx, gumsMask), 1.0); + + Result[id.xy] = thickness; +} + +[numthreads(1, 1, 1)] +void RLTongueDiffuse(uint3 id : SV_DispatchThreadID) +{ + float2 uv = GetUV(id.xy); + + float4 diffuse = SAMPLE(Diffuse, uv); + float4 gradientAO = SAMPLE(GradientAO, uv); + + float aoMask = lerp(rearAO, frontAO, gradientAO.b); + float3 tongue = SV(diffuse, tongueSaturation, tongueBrightness); + float4 baseColor = float4(tongue * aoMask, 1.0); + + Result[id.xy] = LinearTosRGB(baseColor); +} + +[numthreads(1, 1, 1)] +void RLTongueMask(uint3 id : SV_DispatchThreadID) +{ + float2 uv = GetUV(id.xy); + + float4 mask = SAMPLE(Mask, uv); + float4 gradientAO = SAMPLE(GradientAO, uv); + + float aoMask = lerp(rearAO, frontAO, gradientAO.b); + float metallic = mask.r; + float ao = INVERTED_SCALE(mask.g, aoStrength); + float detailMask = mask.b * microNormalStrength; + float smoothness = lerp(smoothnessMin, smoothnessMax, pow(mask.a, smoothnessPower)); + smoothness = lerp(0.0, smoothness, aoMask); + float4 packed = float4(metallic, ao, detailMask, smoothness); + + Result[id.xy] = packed; +} + +[numthreads(1, 1, 1)] +void RLTongueSubsurface(uint3 id : SV_DispatchThreadID) +{ + float2 uv = GetUV(id.xy); + + float4 gradientAO = SAMPLE(GradientAO, uv); + + float aoMask = lerp(rearAO, frontAO, gradientAO.b); + float4 subsurface = float4(tongueSSS.xxx * aoMask, 1.0); + + Result[id.xy] = subsurface; +} + + +// Eye masks +// +float EyeLimbusMask(float radial) +{ + float inner = limbusDarkRadius * irisScale; + float outer = limbusDarkWidth * irisScale + inner; + return smoothstep(inner, outer, radial); +} + +float EyeIrisMask(float radial) +{ + float outer = irisRadius * irisScale; + float inner = outer - limbusWidth * irisScale; + return smoothstep(inner, outer, radial); +} + +float EyeDepthMask(float radial) +{ + float scaledDepthRadius = irisRadius * irisScale * depthRadius; + return saturate(Remap_float(radial, 0, scaledDepthRadius, 1.0, 0.0)); +} + +float EyeShadowMask(float radial) +{ + return saturate(Remap_float(radial, shadowRadius, shadowRadius * shadowHardness, 1.0, 0.0)); +} + + +// Eye Bake Kernels +// +[numthreads(1, 1, 1)] +void RLCorneaDiffuse(uint3 id : SV_DispatchThreadID) +{ + float2 uv = GetUV(id.xy); + float2 touv = TilingOffset(uv, scleraScale, float2(0.5, 0.5)); + + float4 color = SAMPLE(ScleraDiffuse, touv); + float3 hsv = HSV(color, scleraHue, scleraSaturation, scleraBrightness); + color = float4(hsv, 1.0); + float4 colorBlend = SAMPLE(ColorBlend, uv); + + float radial = RADIAL(uv); + float shadowMask = EyeShadowMask(radial); + float irisMask = EyeIrisMask(radial); + color = BlendMultiply_float4(color, sRGBToLinear(cornerShadowColor), shadowMask); + + color = BlendMultiply_float4(color, colorBlend, colorBlendStrength); + color.a = irisMask; + + Result[id.xy] = LinearTosRGB(color); +} + +[numthreads(1, 1, 1)] +void RLEyeDiffuse(uint3 id : SV_DispatchThreadID) +{ + float2 uv = GetUV(id.xy); + float2 touv = TilingOffset(uv, irisScale, float2(0.5, 0.5)); + + float4 color = SAMPLE(CorneaDiffuse, touv); + float3 hsv = HSV(color, irisHue, irisSaturation, irisBrightness); + color = float4(hsv, 1.0); + float4 colorBlend = SAMPLE(ColorBlend, uv); + + float radial = RADIAL(uv); + float limbusMask = EyeLimbusMask(radial); + color = BlendMultiply_float4(color, limbusColor, limbusMask); + + color = BlendMultiply_float4(color, colorBlend, colorBlendStrength); + color.a = 1.0; + + Result[id.xy] = LinearTosRGB(color); +} + +[numthreads(1, 1, 1)] +void RLCorneaMask(uint3 id : SV_DispatchThreadID) +{ + float2 uv = GetUV(id.xy); + + float4 mask = SAMPLE(Mask, uv); + + float radial = RADIAL(uv); + float irisMask = EyeIrisMask(radial); + float metallic = mask.r; + float ao = INVERTED_SCALE(mask.g, aoStrength); + float detailMask = irisMask * microNormalStrength; + float smoothness = lerp(corneaSmoothness, scleraSmoothness, irisMask); + float4 packed = float4(metallic, ao, detailMask, smoothness); + + Result[id.xy] = packed; +} + +[numthreads(1, 1, 1)] +void RLEyeMask(uint3 id : SV_DispatchThreadID) +{ + float2 uv = GetUV(id.xy); + + float4 mask = SAMPLE(Mask, uv); + + float radial = RADIAL(uv); + float irisMask = EyeIrisMask(radial); + float depthMask = EyeDepthMask(radial); + float metallic = mask.r; + float ao = INVERTED_SCALE(mask.g, aoStrength); + float detailMask = depthMask; + float smoothness = lerp(irisSmoothness, scleraSmoothness, irisMask); + float4 packed = float4(metallic, ao, detailMask, smoothness); + + Result[id.xy] = packed; +} + +[numthreads(1, 1, 1)] +void RLCorneaThickness(uint3 id : SV_DispatchThreadID) +{ + float2 uv = GetUV(id.xy); + + float radial = RADIAL(uv); + float invertedIrisMask = 1.0 - EyeIrisMask(radial); + + float4 thickness = invertedIrisMask * thicknessScale; + thickness.a = 1.0; + + Result[id.xy] = thickness; +} + +float4 RootEndBlend(float4 color, float rootMask) +{ + float globalMask = globalStrength * (((1.0 - rootMask) * rootColorStrength) + (rootMask * endColorStrength)); + rootMask = lerp(rootMask, 1.0 - rootMask, invertRootMap); + float4 rootEnd = lerp(sRGBToLinearApprox(rootColor), sRGBToLinearApprox(endColor), rootMask); + return lerp(color, rootEnd, globalMask); +} + +float4 HighlightBlend(float4 color, float idMap, float rootMask, float4 highlightColor, + float3 distribution, float strength, float overlap, float invert) +{ + float lower = smoothstep(distribution.x, distribution.y, idMap); + float upper = 1.0 - smoothstep(distribution.y, distribution.z, idMap); + float highlightMask = strength * lerp(lower, upper, step(distribution.y, idMap)); + float invertedRootMask = lerp(rootMask, 1.0 - rootMask, 1.0 - invert); + float overlappedInvertedRootMask = 1.0 - ((1.0 - invertedRootMask) * overlap); + highlightMask = saturate(highlightMask * overlappedInvertedRootMask); + return lerp(color, sRGBToLinearApprox(highlightColor), highlightMask); +} + +[numthreads(1, 1, 1)] +void RLHairColoredDiffuse(uint3 id : SV_DispatchThreadID) +{ + float2 uv = GetUV(id.xy); + + float4 diffuse = SAMPLE(Diffuse, uv); + float4 rootMap = SAMPLE(Root, uv); + float4 idMap = SAMPLE(ID, uv); + float4 depthBlend = SAMPLE(ColorBlend, uv); + float4 mask = SAMPLE(Mask, uv); + + float ao = INVERTED_SCALE(mask.g, aoStrength); + float alpha = saturate(1.0 * pow(diffuse.a, alphaPower) / alphaRemap); + + float4 color = lerp(float4(1.0, 1.0, 1.0, 1.0), diffuse, baseColorStrength); + color = RootEndBlend(color, rootMap.g); + color = HighlightBlend(color, idMap.g, rootMap.g, highlightAColor, highlightADistribution, + highlightAStrength, highlightAOverlapEnd, highlightAOverlapInvert); + color = HighlightBlend(color, idMap.g, rootMap.g, highlightBColor, highlightBDistribution, + highlightBStrength, highlightBOverlapEnd, highlightBOverlapInvert); + + color = color * diffuseStrength; + color = lerp(color, color * depthBlend, colorBlendStrength); + color = lerp(color, color * ao, aoOccludeAll); + + color = LinearTosRGB(color); + color.a = alpha; + + Result[id.xy] = color; +} + +[numthreads(1, 1, 1)] +void RLHairDiffuse(uint3 id : SV_DispatchThreadID) +{ + float2 uv = GetUV(id.xy); + + float4 diffuse = SAMPLE(Diffuse, uv); + float4 depthBlend = SAMPLE(ColorBlend, uv); + float4 mask = SAMPLE(Mask, uv); + + float ao = INVERTED_SCALE(mask.g, aoStrength); + float alpha = saturate(1.0 * pow(saturate(diffuse.a), alphaPower) / alphaRemap); + + float4 color = diffuse * diffuseStrength; + color = lerp(color, color * depthBlend, colorBlendStrength); + color = lerp(color, color * ao, aoOccludeAll); + + color = LinearTosRGB(color); + color.a = alpha; + + Result[id.xy] = color; +} + +[numthreads(1, 1, 1)] +void RLHairMask(uint3 id : SV_DispatchThreadID) +{ + float2 uv = GetUV(id.xy); + + float4 mask = SAMPLE(Mask, uv); + float4 specular = SAMPLE(Specular, uv); + + float metallic = mask.r; + float ao = INVERTED_SCALE(mask.g, aoStrength); + float detailMask = (specular.r + specular.g + specular.b) / 3.0; + float smoothness = lerp(smoothnessMin, smoothnessMax, pow(mask.a, smoothnessPower)); + float4 packed = float4(metallic, ao, detailMask, smoothness); + + Result[id.xy] = packed; +} + +float EyeOcclusionGradient(float2 uv) +{ + float x = uv.x; + float y = uv.y; + float right = smoothstep(eoInnerMin, eoInnerMax, 1 - x); + float left = smoothstep(eoOuterMin, eoOuterMax, x); + float top = pow(smoothstep(eoTopMin, eoTopMax, 1 - y), eoBottomCurve); + float bottom = pow(smoothstep(eoBottomMin, eoBottomMax, y), eoTopCurve); + float alpha1 = saturate((1.0 - saturate(8.0 * right * left * top * bottom)) * eoOcclusionStrength); + float alpha2 = saturate(smoothstep(eoTop2Min, eoTop2Max, y) * eoOcclusionStrength2); + float edge2 = ((1.0 - eoTearDuctPosition) * eoTearDuctWidth) + eoTearDuctPosition; + float tearDuctMask = (1.0 - smoothstep(eoTearDuctPosition, edge2, x)); + return pow(max(alpha1, alpha2) * tearDuctMask, eoOcclusionPower); +} + +[numthreads(1, 1, 1)] +void RLEyeOcclusionDiffuse(uint3 id : SV_DispatchThreadID) +{ + float2 uv = GetUV(id.xy); + + float4 alpha = EyeOcclusionGradient(uv); + //float4 color = sRGBToLinearApprox(eoEyeOcclusionColor); + float4 color = eoEyeOcclusionColor * alpha; + color.a = alpha; + + Result[id.xy] = color; +} + + diff --git a/Compute/RLBakeShader.compute.meta b/Compute/RLBakeShader.compute.meta new file mode 100644 index 0000000..e7170b4 --- /dev/null +++ b/Compute/RLBakeShader.compute.meta @@ -0,0 +1,8 @@ +fileFormatVersion: 2 +guid: 8f0206486586f47458d01743f9cbdbc8 +ComputeShaderImporter: + externalObjects: {} + currentAPIMask: 4 + userData: + assetBundleName: + assetBundleVariant: diff --git a/Editor.meta b/Editor.meta new file mode 100644 index 0000000..7fdf0dc --- /dev/null +++ b/Editor.meta @@ -0,0 +1,8 @@ +fileFormatVersion: 2 +guid: 869593ca283b7f040ac6c16346b74700 +folderAsset: yes +DefaultImporter: + externalObjects: {} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Editor/CharacterInfo.cs b/Editor/CharacterInfo.cs new file mode 100644 index 0000000..f923969 --- /dev/null +++ b/Editor/CharacterInfo.cs @@ -0,0 +1,169 @@ +/* + * Copyright (C) 2021 Victor Soupday + * This file is part of CC3_Unity_Tools + * + * CC3_Unity_Tools is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * CC3_Unity_Tools is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with CC3_Unity_Tools. If not, see . + */ + +using System.IO; +using UnityEditor; +using UnityEngine; + +namespace Reallusion.Import +{ + public class CharacterInfo + { + public enum ProcessingType { None, Basic, HighQuality } + + public GameObject fbx; + public string guid; + public string path; + public string infoPath; + public string name; + public string folder; + public TextAsset infoAsset; + public ProcessingType logType = ProcessingType.None; + public bool qualRefractiveEyes = true; + public bool bakeIsBaked = false; + public bool bakeCustomShaders = true; + private QuickJSON jsonData; + private BaseGeneration generation; + + public CharacterInfo(GameObject obj) + { + path = AssetDatabase.GetAssetPath(obj); + fbx = obj; + name = Path.GetFileNameWithoutExtension(path); + folder = Path.GetDirectoryName(path); + infoPath = Path.Combine(folder, name + "_ImportInfo.txt"); + infoAsset = AssetDatabase.LoadAssetAtPath(infoPath); + if (infoAsset) + Read(); + else + Write(); + } + + public CharacterInfo(string guid) + { + this.guid = guid; + path = AssetDatabase.GUIDToAssetPath(this.guid); + fbx = AssetDatabase.LoadAssetAtPath(path); + name = Path.GetFileNameWithoutExtension(path); + folder = Path.GetDirectoryName(path); + infoPath = Path.Combine(folder, name + "_ImportInfo.txt"); + infoAsset = AssetDatabase.LoadAssetAtPath(infoPath); + if (infoAsset) + Read(); + else + Write(); + } + + public QuickJSON JsonData + { + get + { + if (jsonData == null) + { + TextAsset jsonAsset = Util.GetJSONAsset(name, new string[] { folder }); + jsonData = new QuickJSON(jsonAsset.text); + } + + return jsonData; + } + } + + + public BaseGeneration Generation + { + get + { + if (generation == BaseGeneration.None) + { + generation = RL.GetCharacterGeneration(fbx, name, JsonData); + } + + return generation; + } + } + + public bool CanHaveHighQualityMaterials + { + get + { + switch (Generation) + { + case BaseGeneration.G1: + case BaseGeneration.G3: + case BaseGeneration.G3Plus: + case BaseGeneration.GameBase: + return true; + default: + return false; + } + } + } + + + public void Read() + { + string[] lineEndings = new string[] { "\r\n", "\r", "\n" }; + char[] propertySplit = new char[] { '=' }; + string[] lines = infoAsset.text.Split(lineEndings, System.StringSplitOptions.None); + string property = ""; + string value = ""; + for (int i = 0; i < lines.Length; i++) + { + string[] line = lines[i].Split(propertySplit, System.StringSplitOptions.None); + if (line.Length > 0) + property = line[0]; + if (line.Length > 1) + value = line[1]; + + switch (property) + { + case "logType": + if (value == "Basic") logType = ProcessingType.Basic; + else if (value == "HighQuality") logType = ProcessingType.HighQuality; + else logType = ProcessingType.None; + break; + case "qualRefractiveEyes": + if (value == "true") qualRefractiveEyes = true; + else qualRefractiveEyes = false; + break; + case "bakeIsBaked": + if (value == "true") bakeIsBaked = true; + else bakeIsBaked = false; + break; + case "bakeCustomShaders": + if (value == "true") bakeCustomShaders = true; + else bakeCustomShaders = false; + break; + } + } + } + + public void Write() + { + StreamWriter writer = new StreamWriter(infoPath, false); + writer.WriteLine("logType=" + logType.ToString()); + writer.WriteLine("qualRefractiveEyes=" + (qualRefractiveEyes ? "true" : "false")); + writer.WriteLine("bakeIsBaked=" + (bakeIsBaked ? "true" : "false")); + writer.WriteLine("bakeCustomShaders=" + (bakeCustomShaders ? "true" : "false")); + writer.Close(); + AssetDatabase.ImportAsset(infoPath); + infoAsset = AssetDatabase.LoadAssetAtPath(infoPath); + } + } + +} diff --git a/Editor/CharacterInfo.cs.meta b/Editor/CharacterInfo.cs.meta new file mode 100644 index 0000000..b5a6e8c --- /dev/null +++ b/Editor/CharacterInfo.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 8d14b68477f9a6543873604d006136eb +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Editor/CharacterTreeView.cs b/Editor/CharacterTreeView.cs new file mode 100644 index 0000000..32550db --- /dev/null +++ b/Editor/CharacterTreeView.cs @@ -0,0 +1,195 @@ +/* + * Copyright (C) 2021 Victor Soupday + * This file is part of CC3_Unity_Tools + * + * CC3_Unity_Tools is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * CC3_Unity_Tools is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with CC3_Unity_Tools. If not, see . + */ + +using System.Collections.Generic; +using UnityEditor; +using UnityEditor.IMGUI.Controls; +using UnityEngine; + +namespace Reallusion.Import +{ + public class CharacterTreeView : UnityEditor.IMGUI.Controls.TreeView + { + public GameObject objectInContext; + private string assetPath; + public List objList; + public List[] linkedIndices; + public bool selectLinked = true; + public IList selectedIndices; + + public CharacterTreeView(TreeViewState treeViewState, GameObject obj) : base(treeViewState) + { + //Force Treeview to reload its data (will force BuildRoot and BuildRows to be called) + objectInContext = obj; + assetPath = AssetDatabase.GetAssetPath(obj); + objList = new List(); + Reload(); + } + + protected override TreeViewItem BuildRoot() + { + //indicies + int mDepth = -1;//root level + int mId = 0; + + objList.Clear(); + objList.Add(null); + var root = new TreeViewItem { id = mId++, depth = mDepth, displayName = "Root" }; + + var allItems = new List(); + + linkedIndices = new List[6]; + for (int i = 0; i < 6; i++) + linkedIndices[i] = new List(); + + mDepth = 0;//base level + + objList.Add(objectInContext); + allItems.Add(new TreeViewItem { id = mId++, depth = mDepth, displayName = objectInContext.name, icon = (Texture2D)EditorGUIUtility.IconContent("Avatar Icon").image }); + + //applicable objects + DoThing(objectInContext.transform, allItems, ref mId); + + SetupParentsAndChildrenFromDepths(root, allItems); + return root; + } + + void DoThing(Transform transform, List allItems, ref int mId) + { + int mDepth = 0; + + //applicable objects + foreach (Transform child in transform) + { + if (child.gameObject.GetComponent() != null) + { + mDepth = 1;//1st tier + + objList.Add(child); + allItems.Add(new TreeViewItem { id = mId++, depth = mDepth, displayName = child.name, icon = (Texture2D)EditorGUIUtility.IconContent("Mesh Icon").image }); + + foreach (Material m in child.gameObject.GetComponent().sharedMaterials) + { + mDepth = 2;//2nd tier + + string sourceName = Util.GetSourceMaterialName(assetPath, m); + string shaderName = Util.GetShaderName(m); + int linkedIndex = Util.GetLinkedMaterialIndex(sourceName, shaderName); + if (linkedIndex >= 0) + linkedIndices[linkedIndex].Add(mId); + + objList.Add(m); + allItems.Add(new TreeViewItem { id = mId++, depth = mDepth, displayName = m.name, icon = (Texture2D)EditorGUIUtility.IconContent("Material Icon").image }); + + int props = m.shader.GetPropertyCount(); + for (int i = 0; i < props; i++) + { + int flagValue = (int)m.shader.GetPropertyFlags(i); + int checkBit = 0x00000001; //bit for UnityEngine.Rendering.ShaderPropertyFlags.HideInInspector + int flagHasBit = (flagValue & checkBit); + + if (flagHasBit == 0 && m.shader.GetPropertyType(i).Equals(UnityEngine.Rendering.ShaderPropertyType.Texture)) + { + if (m.GetTexture(m.shader.GetPropertyName(i)) != null) + { + mDepth = 3;//3rd tier + + objList.Add(m.GetTexture(m.shader.GetPropertyName(i))); + allItems.Add(new TreeViewItem { id = mId++, depth = mDepth, displayName = m.shader.GetPropertyDescription(i), icon = (Texture2D)EditorGUIUtility.IconContent("Image Icon").image }); + } + } + } + } + } + else if (child.name.iContains("_LOD0")) + { + DoThing(child, allItems, ref mId); + } + + } + } + + public void ClearSelection() + { + IList list = new int[] { 0 }; + SetSelection(list); + } + + public void SelectLinked(int index) + { + if (selectLinked) + { + for (int i = 0; i < linkedIndices.Length; i++) + { + if (linkedIndices[i].Contains(index)) + { + SetSelection(linkedIndices[i]); //, TreeViewSelectionOptions.FireSelectionChanged); + } + } + } + } + + protected override void SelectionChanged(IList selectedIds) + { + if (selectedIds.Count == 1) + { + SelectLinked(selectedIds[0]); + } + + if (HasSelection()) + { + selectedIndices = GetSelection(); + if (selectedIndices.Count > 1) + { + UnityEngine.Object[] selectedObjects = new UnityEngine.Object[selectedIndices.Count]; + int num = 0; + foreach (int i in selectedIndices) + { + selectedObjects[num++] = objList[i]; + } + Selection.objects = selectedObjects; + } + else + { + Selection.activeObject = objList[selectedIndices[0]]; + } + } + } + + private void ExpandToDepth(TreeViewItem item, int depth, int maxDepth) + { + if (depth <= maxDepth) + SetExpanded(item.id, true); + else + SetExpanded(item.id, false); + + if (item.children != null) + { + foreach (TreeViewItem child in item.children) + { + ExpandToDepth(child, depth + 1, maxDepth); + } + } + } + + public void ExpandToDepth(int maxDepth) + { + ExpandToDepth(rootItem, 0, maxDepth); + } + } +} \ No newline at end of file diff --git a/Editor/CharacterTreeView.cs.meta b/Editor/CharacterTreeView.cs.meta new file mode 100644 index 0000000..7a300c0 --- /dev/null +++ b/Editor/CharacterTreeView.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: f70513f0c5b1ba946988c6cf0f74c946 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Editor/ComputeBake.cs b/Editor/ComputeBake.cs new file mode 100644 index 0000000..6b9821e --- /dev/null +++ b/Editor/ComputeBake.cs @@ -0,0 +1,1856 @@ +/* + * Copyright (C) 2021 Victor Soupday + * This file is part of CC3_Unity_Tools + * + * CC3_Unity_Tools is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * CC3_Unity_Tools is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with CC3_Unity_Tools. If not, see . + */ + +using UnityEngine; +using UnityEditor; +using System.IO; +using System.Collections.Generic; + +namespace Reallusion.Import +{ + public class ComputeBake + { + private readonly GameObject fbx; + private GameObject clone; + private CharacterInfo characterInfo; + private readonly string characterName; + private readonly string fbxPath; + private readonly string fbxFolder; + private readonly string bakeFolder; + private readonly string characterFolder; + private readonly string texturesFolder; + private readonly string materialsFolder; + private readonly string fbmFolder; + private readonly string texFolder; + private readonly List sourceTextureFolders; + private readonly ModelImporter importer; + private readonly List importAssets; + + public const int MAX_SIZE = 4096; + public const string COMPUTE_SHADER = "RLBakeShader"; + public const string BAKE_FOLDER = "Baked"; + public const string TEXTURES_FOLDER = "Textures"; + public const string MATERIALS_FOLDER = "Materials"; + + private Texture2D maskTex = null; + + public ComputeBake(UnityEngine.Object character, CharacterInfo info) + { + fbx = (GameObject)character; + fbxPath = AssetDatabase.GetAssetPath(fbx); + characterInfo = info; + characterName = Path.GetFileNameWithoutExtension(fbxPath); + fbxFolder = Path.GetDirectoryName(fbxPath); + bakeFolder = Util.CreateFolder(fbxFolder, BAKE_FOLDER); + characterFolder = Util.CreateFolder(bakeFolder, characterName); + texturesFolder = Util.CreateFolder(characterFolder, TEXTURES_FOLDER); + materialsFolder = Util.CreateFolder(characterFolder, MATERIALS_FOLDER); + + fbmFolder = Path.Combine(fbxFolder, characterName + ".fbm"); + texFolder = Path.Combine(fbxFolder, "textures", characterName); + sourceTextureFolders = new List() { fbmFolder, texFolder }; + + importer = (ModelImporter)AssetImporter.GetAtPath(fbxPath); + + importAssets = new List(); + } + + private static Vector2Int GetMaxSize(Texture2D a) + { + Vector2Int max = new Vector2Int(a.width, a.height); + if (max.x > MAX_SIZE) max.x = MAX_SIZE; + if (max.y > MAX_SIZE) max.y = MAX_SIZE; + return max; + } + + private static Vector2Int GetMaxSize(Texture2D a, Texture2D b) + { + Vector2Int max = new Vector2Int(a.width, a.height); + if (b.width > max.x) max.x = b.width; + if (b.height > max.y) max.y = b.height; + if (max.x > MAX_SIZE) max.x = MAX_SIZE; + if (max.y > MAX_SIZE) max.y = MAX_SIZE; + return max; + } + + private static Vector2Int GetMaxSize(Texture2D a, Texture2D b, Texture2D c) + { + Vector2Int max = new Vector2Int(a.width, a.height); + if (b.width > max.x) max.x = b.width; + if (b.height > max.y) max.y = b.height; + if (c.width > max.x) max.x = c.width; + if (c.height > max.y) max.y = c.height; + if (max.x > MAX_SIZE) max.x = MAX_SIZE; + if (max.y > MAX_SIZE) max.y = MAX_SIZE; + return max; + } + + private static Vector2Int GetMaxSize(Texture2D a, Texture2D b, Texture2D c, Texture2D d) + { + Vector2Int max = new Vector2Int(a.width, a.height); + if (b.width > max.x) max.x = b.width; + if (b.height > max.y) max.y = b.height; + if (c.width > max.x) max.x = c.width; + if (c.height > max.y) max.y = c.height; + if (d.width > max.x) max.x = d.width; + if (d.height > max.y) max.y = d.height; + if (max.x > MAX_SIZE) max.x = MAX_SIZE; + if (max.y > MAX_SIZE) max.y = MAX_SIZE; + return max; + } + + private Texture2D GetMaterialTexture(Material mat, string shaderRef, bool isNormal = false) + { + Texture2D tex = (Texture2D)mat.GetTexture(shaderRef); + string assetPath = AssetDatabase.GetAssetPath(tex); + TextureImporter importer = (TextureImporter)AssetImporter.GetAtPath(assetPath); + + if (importer) + { + // TODO should the character importer set these as the defaults? + // Turn off texture compression and unlock max size to 4k, for the best possible quality bake: + if (importer.textureCompression != TextureImporterCompression.Uncompressed || + importer.compressionQuality != 0 || + importer.maxTextureSize < 4096 || + (isNormal && importer.textureType != TextureImporterType.NormalMap)) + { + importer.textureCompression = TextureImporterCompression.Uncompressed; + importer.compressionQuality = 0; + importer.maxTextureSize = 4096; + if (isNormal) importer.textureType = TextureImporterType.NormalMap; + else importer.textureType = TextureImporterType.Default; + importer.SaveAndReimport(); + } + } + + return tex; + } + + private Texture2D CheckHDRP(Texture2D tex) + { + if (tex) + return tex; + + if (!maskTex) + { + maskTex = new Texture2D(8, 8, TextureFormat.ARGB32, false, true); + Color[] pixels = maskTex.GetPixels(); + for (int i = 0; i < pixels.Length; i++) + { + pixels[i] = new Color(0f, 1f, 1f, 0.5f); + } + maskTex.SetPixels(pixels); + } + + return maskTex; + } + + /// + /// Checks that the texture exists, if not returns a blank white texture. + /// + private Texture2D CheckDiffuse(Texture2D tex) + { + if (tex) return tex; + return Texture2D.whiteTexture; + } + + /// + /// Checks that the texture exists, if not returns a blank normal texture. + /// + private Texture2D CheckNormal(Texture2D tex) + { + if (tex) return tex; + return Texture2D.normalTexture; + } + + /// + /// Checks that the texture exists, if not returns a blank white texture. + /// + private Texture2D CheckMask(Texture2D tex) + { + if (tex) return tex; + return Texture2D.whiteTexture; + } + + /// + /// Checks that the texture exists, if not returns a blank black texture. + /// + private Texture2D CheckBlank(Texture2D tex) + { + if (tex) return tex; + return Texture2D.blackTexture; + } + + /// + /// Checks that the texture exists, if not returns a blank gray texture. + /// + private Texture2D CheckOverlay(Texture2D tex) + { + if (tex) return tex; + return Texture2D.linearGrayTexture; + } + + public void BakeHQ() + { + if (Util.IsCC3Character(fbx)) + { + CopyToClone(); + + int childCount = clone.transform.childCount; + for (int i = 0; i < childCount; i++) + { + GameObject child = clone.transform.GetChild(i).gameObject; + Renderer renderer = child.GetComponent(); + if (renderer) + { + foreach (Material sharedMat in renderer.sharedMaterials) + { + // in case any of the materials have been renamed after a previous import, get the source name. + string sourceName = Util.GetSourceMaterialName(fbxPath, sharedMat); + string shaderName = Util.GetShaderName(sharedMat); + Material bakedMaterial = null; + + switch (shaderName) + { + case Pipeline.SHADER_HQ_SKIN: + bakedMaterial = BakeSkinMaterial(sharedMat, sourceName); + break; + + case Pipeline.SHADER_HQ_TEETH: + bakedMaterial = BakeTeethMaterial(sharedMat, sourceName); + break; + + case Pipeline.SHADER_HQ_TONGUE: + bakedMaterial = BakeTongueMaterial(sharedMat, sourceName); + break; + + case Pipeline.SHADER_HQ_HAIR: + bakedMaterial = BakeHairMaterial(sharedMat, sourceName); + break; + + case Pipeline.SHADER_HQ_EYE: + bakedMaterial = BakeEyeMaterial(sharedMat, sourceName); + break; + + case Pipeline.SHADER_HQ_EYE_OCCLUSION: + bakedMaterial = BakeEyeOcclusionMaterial(sharedMat, sourceName); + break; + } + + if (bakedMaterial) + { + ReplaceMaterial(sharedMat, bakedMaterial); + } + } + } + } + + AssetDatabase.SaveAssets(); + AssetDatabase.Refresh(); + + SaveAsPrefab(); + + //System.Media.SystemSounds.Asterisk.Play(); + } + } + + private void ReplaceMaterial(Material from, Material to) + { + int childCount = clone.transform.childCount; + for (int i = 0; i < childCount; i++) + { + GameObject child = clone.transform.GetChild(i).gameObject; + Renderer renderer = child.GetComponent(); + if (renderer) + { + for (int j = 0; j < renderer.sharedMaterials.Length; j++) + { + if (renderer.sharedMaterials[j] == from) + { + Material[] copy = (Material[])renderer.sharedMaterials.Clone(); + copy[j] = to; + renderer.sharedMaterials = copy; + } + } + } + } + } + + public void CopyToClone() + { + clone = (GameObject)PrefabUtility.InstantiatePrefab(fbx); + } + + public void SaveAsPrefab() + { + string prefabFolder = Util.CreateFolder(fbxFolder, Importer.PREFABS_FOLDER); + string namedPrefabFolder = Util.CreateFolder(prefabFolder, characterName); + string prefabPath = Path.Combine(namedPrefabFolder, characterName + "_Baked.prefab"); + GameObject variant = PrefabUtility.SaveAsPrefabAsset(clone, prefabPath); + Selection.activeObject = variant; + GameObject.DestroyImmediate(clone); + } + + private Material CreateBakedMaterial(Texture2D baseMap, Texture2D maskMap, Texture2D normalMap, + Texture2D detailMap, Texture2D subsurfaceMap, Texture2D thicknessMap, float tiling, + string sourceName, Material templateMaterial) + { + Material bakedMaterial = Util.FindMaterial(sourceName, new string[] { materialsFolder }); + Shader shader = Pipeline.GetDefaultShader(); + + if (!bakedMaterial) + { + // create the remapped material and save it as an asset. + string matPath = AssetDatabase.GenerateUniqueAssetPath( + Path.Combine(materialsFolder, sourceName + ".mat") + ); + + bakedMaterial = new Material(shader); + + // save the material to the asset database. + AssetDatabase.CreateAsset(bakedMaterial, matPath); + } + + // copy the template material properties to the remapped material. + if (templateMaterial) + { + if (templateMaterial.shader && templateMaterial.shader != bakedMaterial.shader) + bakedMaterial.shader = templateMaterial.shader; + bakedMaterial.CopyPropertiesFromMaterial(templateMaterial); + } + else + { + // if the material shader doesn't match, update the shader. + if (bakedMaterial.shader != shader) + bakedMaterial.shader = shader; + } + + // apply the textures... + bakedMaterial.SetTexture("_BaseColorMap", baseMap); + bakedMaterial.SetTexture("_MaskMap", maskMap); + bakedMaterial.SetTexture("_NormalMap", normalMap); + bakedMaterial.SetTexture("_DetailMap", detailMap); + if (detailMap) + bakedMaterial.SetTextureScale("_DetailMap", new Vector2(tiling, tiling)); + bakedMaterial.SetTexture("_SubsurfaceMaskMap", subsurfaceMap); + bakedMaterial.SetTexture("_ThicknessMap", thicknessMap); + + // add the path of the remapped material for later re-import. + string remapPath = AssetDatabase.GetAssetPath(bakedMaterial); + if (remapPath == fbxPath) Debug.LogError("remapPath: " + remapPath + " is fbxPath!"); + if (remapPath != fbxPath && AssetDatabase.WriteImportSettingsIfDirty(remapPath)) + importAssets.Add(AssetDatabase.GetAssetPath(bakedMaterial)); + + return bakedMaterial; + } + + private Material BakeSkinMaterial(Material mat, string sourceName) + { + Texture2D diffuse = GetMaterialTexture(mat, "_DiffuseMap"); + Texture2D mask = GetMaterialTexture(mat, "_MaskMap"); + Texture2D subsurface = GetMaterialTexture(mat, "_SSSMap"); + Texture2D thickness = GetMaterialTexture(mat, "_ThicknessMap"); + Texture2D normal = GetMaterialTexture(mat, "_NormalMap", true); + Texture2D microNormal = GetMaterialTexture(mat, "_MicroNormalMap", true); + Texture2D colorBlend = GetMaterialTexture(mat, "_ColorBlendMap"); + Texture2D cavityAO = GetMaterialTexture(mat, "_MNAOMap"); + Texture2D normalBlend = GetMaterialTexture(mat, "_NormalBlendMap", true); + Texture2D RGBAMask = GetMaterialTexture(mat, "_RGBAMask"); + Texture2D CFULCMask = GetMaterialTexture(mat, "_CFULCMask"); + Texture2D EarNeckMask = GetMaterialTexture(mat, "_EarNeckMask"); + float microNormalStrength = mat.GetFloat("_MicroNormalStrength"); + float microNormalTiling = mat.GetFloat("_MicroNormalTiling"); + float aoStrength = mat.GetFloat("_AOStrength"); + float smoothnessMin = mat.GetFloat("_SmoothnessMin"); + float smoothnessMax = mat.GetFloat("_SmoothnessMax"); + float smoothnessPower = mat.GetFloat("_SmoothnessPower"); + float subsurfaceScale = mat.GetFloat("_SubsurfaceScale"); + float thicknessScale = mat.GetFloat("_ThicknessScale"); + float colorBlendStrength = mat.GetFloat("_ColorBlendStrength"); + float normalBlendStrength = mat.GetFloat("_NormalBlendStrength"); + float mouthAOPower = mat.GetFloat("_MouthCavityAO"); + float nostrilAOPower = mat.GetFloat("_NostrilCavityAO"); + float lipsAOPower = mat.GetFloat("_LipsCavityAO"); + float microSmoothnessMod = mat.GetFloat("_MicroSmoothnessMod"); + float rMSM = mat.GetFloat("_RSmoothnessMod"); + float gMSM = mat.GetFloat("_GSmoothnessMod"); + float bMSM = mat.GetFloat("_BSmoothnessMod"); + float aMSM = mat.GetFloat("_ASmoothnessMod"); + float earMSM = mat.GetFloat("_EarSmoothnessMod"); + float neckMSM = mat.GetFloat("_NeckSmoothnessMod"); + float cheekMSM = mat.GetFloat("_CheekSmoothnessMod"); + float foreheadMSM = mat.GetFloat("_ForeheadSmoothnessMod"); + float upperLipMSM = mat.GetFloat("_UpperLipSmoothnessMod"); + float chinMSM = mat.GetFloat("_ChinSmoothnessMod"); + float unmaskedMSM = mat.GetFloat("_UnmaskedSmoothnessMod"); + float rSS = mat.GetFloat("_RScatterScale"); + float gSS = mat.GetFloat("_GScatterScale"); + float bSS = mat.GetFloat("_BScatterScale"); + float aSS = mat.GetFloat("_AScatterScale"); + float earSS = mat.GetFloat("_EarScatterScale"); + float neckSS = mat.GetFloat("_NeckScatterScale"); + float cheekSS = mat.GetFloat("_CheekScatterScale"); + float foreheadSS = mat.GetFloat("_ForeheadScatterScale"); + float upperLipSS = mat.GetFloat("_UpperLipScatterScale"); + float chinSS = mat.GetFloat("_ChinScatterScale"); + float unmaskedSS = mat.GetFloat("_UnmaskedScatterScale"); + + bool isHead = mat.GetFloat("BOOLEAN_IS_HEAD") > 0f; + + Texture2D bakedBaseMap = diffuse; + Texture2D bakedMaskMap = mask; + Texture2D bakedNormalMap = normal; + Texture2D bakedDetailMap = null; + Texture2D bakedSubsurfaceMap = subsurface; + Texture2D bakedThicknessMap = thickness; + + if (isHead) + { + if (diffuse && colorBlend && cavityAO) + bakedBaseMap = BakeHeadDiffuseMap(diffuse, colorBlend, cavityAO, + colorBlendStrength, mouthAOPower, nostrilAOPower, lipsAOPower, + sourceName + "_BaseMap"); + + if (normal && normalBlend) + bakedNormalMap = BakeBlendNormalMap(normal, normalBlend, + normalBlendStrength, + sourceName + "_Normal"); + + if (mask && cavityAO && RGBAMask && CFULCMask && EarNeckMask) + bakedMaskMap = BakeHeadMaskMap(mask, cavityAO, RGBAMask, CFULCMask, EarNeckMask, + aoStrength, smoothnessMin, smoothnessMax, smoothnessPower, microNormalStrength, + mouthAOPower, nostrilAOPower, lipsAOPower, microSmoothnessMod, + rMSM, gMSM, bMSM, aMSM, earMSM, neckMSM, cheekMSM, foreheadMSM, upperLipMSM, chinMSM, unmaskedMSM, + sourceName + "_Mask"); + + else if (mask) + bakedMaskMap = BakeMaskMap(mask, + aoStrength, smoothnessMin, smoothnessMax, smoothnessPower, microNormalStrength, + sourceName + "_Mask"); + + if (subsurface && RGBAMask && CFULCMask && EarNeckMask) + bakedSubsurfaceMap = BakeHeadSubsurfaceMap(subsurface, RGBAMask, CFULCMask, EarNeckMask, + subsurfaceScale, + rSS, gSS, bSS, aSS, earSS, neckSS, cheekSS, foreheadSS, upperLipSS, chinSS, unmaskedSS, + sourceName + "_SSSMap"); + + else if (subsurface) + bakedSubsurfaceMap = BakeSubsurfaceMap(subsurface, + subsurfaceScale, + sourceName + "_SSSMap"); + + } + else + { + if (mask && RGBAMask) + bakedMaskMap = BakeSkinMaskMap(mask, RGBAMask, + aoStrength, smoothnessMin, smoothnessMax, smoothnessPower, microNormalStrength, microSmoothnessMod, + rMSM, gMSM, bMSM, aMSM, unmaskedMSM, + sourceName + "_Mask"); + + else if (mask) + bakedMaskMap = BakeMaskMap(mask, + aoStrength, smoothnessMin, smoothnessMax, smoothnessPower, microNormalStrength, + sourceName + "_Mask"); + + if (subsurface && RGBAMask) + bakedSubsurfaceMap = BakeSkinSubsurfaceMap(subsurface, RGBAMask, + subsurfaceScale, + rSS, gSS, bSS, aSS, unmaskedSS, + sourceName + "_SSSMap"); + + else if (subsurface) + bakedSubsurfaceMap = BakeSubsurfaceMap(subsurface, + subsurfaceScale, + sourceName + "_SSSMap"); + } + + if (microNormal) + bakedDetailMap = BakeDetailMap(microNormal, + sourceName + "_Detail"); + + if (thickness) + bakedThicknessMap = BakeThicknessMap(thickness, + thicknessScale, + sourceName + "_Thickness"); + + Material result = CreateBakedMaterial(bakedBaseMap, bakedMaskMap, bakedNormalMap, + bakedDetailMap, bakedSubsurfaceMap, bakedThicknessMap, + microNormalTiling, + sourceName, + Pipeline.GetTemplateMaterial(MaterialType.Skin, + MaterialQuality.Baked, characterInfo)); + + return result; + } + + private Material BakeTeethMaterial(Material mat, string sourceName) + { + Texture2D diffuse = GetMaterialTexture(mat, "_DiffuseMap"); + Texture2D mask = GetMaterialTexture(mat, "_MaskMap"); + Texture2D normal = GetMaterialTexture(mat, "_NormalMap", true); + Texture2D microNormal = GetMaterialTexture(mat, "_MicroNormalMap", true); + Texture2D gumsMask = GetMaterialTexture(mat, "_GumsMaskMap"); + Texture2D gradientAO = GetMaterialTexture(mat, "_GradientAOMap"); + float microNormalStrength = mat.GetFloat("_MicroNormalStrength"); + float microNormalTiling = mat.GetFloat("_MicroNormalTiling"); + float aoStrength = mat.GetFloat("_AOStrength"); + float smoothnessPower = mat.GetFloat("_SmoothnessPower"); + float smoothnessMin = mat.GetFloat("_SmoothnessMin"); + float smoothnessMax = mat.GetFloat("_SmoothnessMax"); + float gumsSaturation = mat.GetFloat("_GumsSaturation"); + float gumsBrightness = mat.GetFloat("_GumsBrightness"); + float teethSaturation = mat.GetFloat("_TeethSaturation"); + float teethBrightness = mat.GetFloat("_TeethBrightness"); + float frontAO = mat.GetFloat("_FrontAO"); + float rearAO = mat.GetFloat("_RearAO"); + float teethSSS = mat.GetFloat("_TeethSSS"); + float gumsSSS = mat.GetFloat("_GumsSSS"); + float teethThickness = mat.GetFloat("_TeethThickness"); + float gumsThickness = mat.GetFloat("_GumsThickness"); + float isUpperTeeth = mat.GetFloat("_IsUpperTeeth"); + + Texture2D bakedBaseMap = diffuse; + Texture2D bakedMaskMap = mask; + Texture2D bakedNormalMap = normal; + Texture2D bakedDetailMap = null; + Texture2D bakedSubsurfaceMap = null; + Texture2D bakedThicknessMap = null; + + if (diffuse && gumsMask && gradientAO) + bakedBaseMap = BakeTeethDiffuseMap(diffuse, gumsMask, gradientAO, + isUpperTeeth, frontAO, rearAO, gumsSaturation, gumsBrightness, teethSaturation, teethBrightness, + sourceName + "_BaseMap"); + + if (mask && gradientAO) + bakedMaskMap = BakeTeethMaskMap(mask, gradientAO, + isUpperTeeth, aoStrength, smoothnessMin, smoothnessMax, smoothnessPower, + frontAO, rearAO, microNormalStrength, + sourceName + "_Mask"); + + else if (mask) + bakedMaskMap = BakeMaskMap(mask, + aoStrength, smoothnessMin, smoothnessMax, smoothnessPower, microNormalStrength, + sourceName + "_Mask"); + + if (microNormal) + bakedDetailMap = BakeDetailMap(microNormal, + sourceName + "_Detail"); + + if (gumsMask && gradientAO) + bakedSubsurfaceMap = BakeTeethSubsurfaceMap(gumsMask, gradientAO, + isUpperTeeth, rearAO, frontAO, gumsSSS, teethSSS, + sourceName + "_SSSMap"); + + if (gumsMask) + bakedThicknessMap = BakeTeethThicknessMap(gumsMask, + gumsThickness, teethThickness, + sourceName + "_Thickness"); + + return CreateBakedMaterial(bakedBaseMap, bakedMaskMap, bakedNormalMap, + bakedDetailMap, bakedSubsurfaceMap, bakedThicknessMap, + microNormalTiling, + sourceName, + Pipeline.GetTemplateMaterial(MaterialType.Teeth, + MaterialQuality.Baked, characterInfo)); + } + + private Material BakeTongueMaterial(Material mat, string sourceName) + { + Texture2D diffuse = GetMaterialTexture(mat, "_DiffuseMap"); + Texture2D mask = GetMaterialTexture(mat, "_MaskMap"); + Texture2D normal = GetMaterialTexture(mat, "_NormalMap", true); + Texture2D microNormal = GetMaterialTexture(mat, "_MicroNormalMap", true); + Texture2D gradientAO = GetMaterialTexture(mat, "_GradientAOMap"); + float microNormalStrength = mat.GetFloat("_MicroNormalStrength"); + float microNormalTiling = mat.GetFloat("_MicroNormalTiling"); + float aoStrength = mat.GetFloat("_AOStrength"); + float smoothnessPower = mat.GetFloat("_SmoothnessPower"); + float smoothnessMin = mat.GetFloat("_SmoothnessMin"); + float smoothnessMax = mat.GetFloat("_SmoothnessMax"); + float tongueSaturation = mat.GetFloat("_TongueSaturation"); + float tongueBrightness = mat.GetFloat("_TongueBrightness"); + float frontAO = mat.GetFloat("_FrontAO"); + float rearAO = mat.GetFloat("_RearAO"); + float tongueSSS = mat.GetFloat("_TongueSSS"); + float tongueThickness = mat.GetFloat("_TongueThickness"); + + Texture2D bakedBaseMap = diffuse; + Texture2D bakedMaskMap = mask; + Texture2D bakedNormalMap = normal; + Texture2D bakedDetailMap = null; + Texture2D bakedSubsurfaceMap = null; + Texture2D bakedThicknessMap = null; + + if (diffuse && gradientAO) + bakedBaseMap = BakeTongueDiffuseMap(diffuse, gradientAO, + frontAO, rearAO, tongueSaturation, tongueBrightness, + sourceName + "_BaseMap"); + + if (mask && gradientAO) + bakedMaskMap = BakeTongueMaskMap(mask, gradientAO, + aoStrength, smoothnessMin, smoothnessMax, smoothnessPower, + frontAO, rearAO, microNormalStrength, + sourceName + "_Mask"); + + else if (mask) + bakedMaskMap = BakeMaskMap(mask, + aoStrength, smoothnessMin, smoothnessMax, smoothnessPower, microNormalStrength, + sourceName + "_Mask"); + + if (microNormal) + bakedDetailMap = BakeDetailMap(microNormal, + sourceName + "_Detail"); + + if (gradientAO) + bakedSubsurfaceMap = BakeTongueSubsurfaceMap(gradientAO, + rearAO, frontAO, tongueSSS, + sourceName + "_SSSMap"); + + Material result = CreateBakedMaterial(bakedBaseMap, bakedMaskMap, bakedNormalMap, + bakedDetailMap, bakedSubsurfaceMap, bakedThicknessMap, + microNormalTiling, + sourceName, + Pipeline.GetTemplateMaterial(MaterialType.Tongue, + MaterialQuality.Baked, characterInfo)); + + result.SetFloat("_Thickness", tongueThickness); + return result; + } + + private Material BakeEyeMaterial(Material mat, string sourceName) + { + Texture2D sclera = GetMaterialTexture(mat, "_ScleraDiffuseMap"); + Texture2D cornea = GetMaterialTexture(mat, "_CorneaDiffuseMap"); + Texture2D blend = GetMaterialTexture(mat, "_ColorBlendMap"); + Texture2D mask = GetMaterialTexture(mat, "_MaskMap"); + Texture2D microNormal = GetMaterialTexture(mat, "_ScleraNormalMap", true); + float microNormalStrength = mat.GetFloat("_ScleraNormalStrength"); + float microNormalTiling = mat.GetFloat("_ScleraNormalTiling"); + float aoStrength = mat.GetFloat("_AOStrength"); + float colorBlendStrength = mat.GetFloat("_ColorBlendStrength"); + float scleraSmoothness = mat.GetFloat("_ScleraSmoothness"); + float irisSmoothness = mat.GetFloat("_IrisSmoothness"); + float corneaSmoothness = mat.GetFloat("_CorneaSmoothness"); + float irisHue = mat.GetFloat("_IrisHue"); + float irisSaturation = mat.GetFloat("_IrisSaturation"); + float irisBrightness = mat.GetFloat("_IrisBrightness"); + float scleraHue = mat.GetFloat("_ScleraHue"); + float scleraSaturation = mat.GetFloat("_ScleraSaturation"); + float scleraBrightness = mat.GetFloat("_ScleraBrightness"); + float refractionThickness = mat.GetFloat("_RefractionThickness"); + float shadowRadius = mat.GetFloat("_ShadowRadius"); + float shadowHardness = mat.GetFloat("_ShadowHardness"); + float irisScale = mat.GetFloat("_IrisScale"); + float scleraScale = mat.GetFloat("_ScleraScale"); + float limbusDarkRadius = mat.GetFloat("_LimbusDarkRadius"); + float limbusDarkWidth = mat.GetFloat("_LimbusDarkWidth"); + float irisRadius = mat.GetFloat("_IrisRadius"); + float limbusWidth = mat.GetFloat("_LimbusWidth"); + float ior = mat.GetFloat("_IOR"); + float depthRadius = mat.GetFloat("_DepthRadius"); + float irisDepth = mat.GetFloat("_IrisDepth"); + float pupilScale = mat.GetFloat("_PupilScale"); + Color cornerShadowColor = mat.GetColor("_CornerShadowColor"); + Color limbusColor = mat.GetColor("_LimbusColor"); + bool isCornea = mat.GetFloat("BOOLEAN_ISCORNEA") > 0f; + bool isLeftEye = mat.GetFloat("_IsLeftEye") > 0f; + + Texture2D bakedBaseMap = cornea; + Texture2D bakedMaskMap = mask; + Texture2D bakedNormalMap = null; + Texture2D bakedDetailMap = null; + Texture2D bakedSubsurfaceMap = null; + Texture2D bakedThicknessMap = null; + + if (isCornea) + { + if (sclera && blend) + bakedBaseMap = BakeCorneaDiffuseMap(sclera, blend, + scleraScale, scleraHue, scleraSaturation, scleraBrightness, + irisScale, irisRadius, limbusWidth, + shadowRadius, shadowHardness, cornerShadowColor, + colorBlendStrength, + sourceName + "_BaseMap"); + + if (mask) + bakedMaskMap = BakeCorneaMaskMap(mask, aoStrength, corneaSmoothness, + scleraSmoothness, irisScale, + irisRadius, limbusWidth, microNormalStrength, + sourceName + "_Mask"); + + if (microNormal) + bakedDetailMap = BakeDetailMap(microNormal, + sourceName + "_Detail"); + + // RGB textures cannot store low enough values for the refraction thickness + // so normalize it and use the thickness remap in the HDRP/Lit shader. + bakedThicknessMap = BakeCorneaThicknessMap(irisScale, limbusDarkRadius, + limbusDarkWidth, refractionThickness / 0.025f, + sourceName + "_Thickness"); + } + else + { + if (cornea && blend) + bakedBaseMap = BakeEyeDiffuseMap(cornea, blend, + irisScale, irisHue, irisSaturation, irisBrightness, + limbusDarkRadius, limbusDarkWidth, limbusColor, colorBlendStrength, + sourceName + "_BaseMap"); + + if (mask) + bakedMaskMap = BakeEyeMaskMap(mask, aoStrength, irisSmoothness, + scleraSmoothness, irisScale, + limbusDarkRadius, limbusDarkWidth, irisRadius, depthRadius, + sourceName + "_Mask"); + } + + // the HDRP/Lit shader seems to use x10 thickness values... + Material result = CreateBakedMaterial(bakedBaseMap, bakedMaskMap, bakedNormalMap, + bakedDetailMap, bakedSubsurfaceMap, bakedThicknessMap, + microNormalTiling, + sourceName, isCornea ? Pipeline.GetTemplateMaterial(MaterialType.Cornea, + MaterialQuality.Baked, characterInfo) + : Pipeline.GetTemplateMaterial(MaterialType.Eye, + MaterialQuality.Baked, characterInfo)); + + if (isCornea) + { + result.SetFloat("_Ior", ior); + result.SetFloat("_Thickness", refractionThickness / 10f); + Color thicknessRemap; + thicknessRemap.r = 0f; + thicknessRemap.g = 0.025f; + thicknessRemap.b = 0f; + thicknessRemap.a = 0f; + result.SetColor("_ThicknessRemap", thicknessRemap); + } + else + { + result.SetFloat("_IrisDepth", irisDepth); + result.SetFloat("_PupilScale", pupilScale); + } + return result; + } + + + + private Material BakeHairMaterial(Material mat, string sourceName) + { + Texture2D diffuse = GetMaterialTexture(mat, "_DiffuseMap"); + Texture2D mask = GetMaterialTexture(mat, "_MaskMap"); + Texture2D normal = GetMaterialTexture(mat, "_NormalMap", true); + Texture2D blend = GetMaterialTexture(mat, "_BlendMap"); + Texture2D flow = GetMaterialTexture(mat, "_FlowMap"); + Texture2D id = GetMaterialTexture(mat, "_IDMap"); + Texture2D root = GetMaterialTexture(mat, "_RootMap"); + Texture2D specular = GetMaterialTexture(mat, "_SpecularMap"); + float aoStrength = mat.GetFloat("_AOStrength"); + float aoOccludeAll = mat.GetFloat("_AOOccludeAll"); + float diffuseStrength = mat.GetFloat("_DiffuseStrength"); + float blendStrength = mat.GetFloat("_BlendStrength"); + float vertexColorStrength = mat.GetFloat("_VertexColorStrength"); + float baseColorStrength = mat.GetFloat("_BaseColorStrength"); + float alphaPower = mat.GetFloat("_AlphaPower"); + float alphaRemap = mat.GetFloat("_AlphaRemap"); + float alphaClip = mat.GetFloat("_AlphaClip"); + float shadowClip = mat.GetFloat("_ShadowClip"); + float depthPrepass = mat.GetFloat("_DepthPrepass"); + float depthPostpass = mat.GetFloat("_DepthPostpass"); + float smoothnessMin = mat.GetFloat("_SmoothnessMin"); + float smoothnessMax = mat.GetFloat("_SmoothnessMax"); + float smoothnessPower = mat.GetFloat("_SmoothnessPower"); + float globalStrength = mat.GetFloat("_GlobalStrength"); + float rootColorStrength = mat.GetFloat("_RootColorStrength"); + float endColorStrength = mat.GetFloat("_EndColorStrength"); + float invertRootMap = mat.GetFloat("_InvertRootMap"); + float highlightAStrength = mat.GetFloat("_HighlightAStrength"); + float highlightAOverlapEnd = mat.GetFloat("_HighlightAOverlapEnd"); + float highlightAOverlapInvert = mat.GetFloat("_HighlightAOverlapInvert"); + float highlightBStrength = mat.GetFloat("_HighlightBStrength"); + float highlightBOverlapEnd = mat.GetFloat("_HighlightBOverlapEnd"); + float highlightBOverlapInvert = mat.GetFloat("_HighlightBOverlapInvert"); + float rimTransmissionIntensity = mat.GetFloat("_RimTransmissionIntensity"); + float specularMultiplier = mat.GetFloat("_SpecularMultiplier"); + float specularShift = mat.GetFloat("_SpecularShift"); + float secondarySpecularMultiplier = mat.GetFloat("_SecondarySpecularMultiplier"); + float secondarySpecularShift = mat.GetFloat("_SecondarySpecularShift"); + float secondarySmoothness = mat.GetFloat("_SecondarySmoothness"); + float normalStrength = mat.GetFloat("_NormalStrength"); + Vector4 highlightADistribution = mat.GetVector("_HighlightADistribution"); + Vector4 highlightBDistribution = mat.GetVector("_HighlightBDistribution"); + Color vertexBaseColor = mat.GetColor("_VertexBaseColor"); + Color rootColor = mat.GetColor("_RootColor"); + Color endColor = mat.GetColor("_EndColor"); + Color highlightAColor = mat.GetColor("_HighlightAColor"); + Color highlightBColor = mat.GetColor("_HighlightBColor"); + Color specularTint = mat.GetColor("_SpecularTint"); + bool enableColor = mat.GetFloat("BOOLEAN_ENABLECOLOR") > 0f; + + Texture2D bakedBaseMap = diffuse; + Texture2D bakedMaskMap = mask; + Texture2D bakedNormalMap = normal; + + if (enableColor && diffuse && id && root) + { + bakedBaseMap = BakeHairDiffuseMap(diffuse, blend, id, root, mask, + diffuseStrength, alphaPower, alphaRemap, aoStrength, aoOccludeAll, + rootColor, rootColorStrength, endColor, endColorStrength, globalStrength, + invertRootMap, baseColorStrength, + highlightAColor, highlightADistribution, highlightAOverlapEnd, + highlightAOverlapInvert, highlightAStrength, + highlightBColor, highlightBDistribution, highlightBOverlapEnd, + highlightBOverlapInvert, highlightBStrength, + blendStrength, vertexBaseColor, vertexColorStrength, + sourceName + "_BaseMap"); + } + else if (diffuse) + { + bakedBaseMap = BakeHairDiffuseMap(diffuse, blend, mask, + diffuseStrength, alphaPower, alphaRemap, aoStrength, aoOccludeAll, + blendStrength, vertexBaseColor, vertexColorStrength, + sourceName + "_BaseMap"); + } + + if (mask) + bakedMaskMap = BakeHairMaskMap(mask, specular, + aoStrength, smoothnessMin, smoothnessMax, smoothnessPower, + sourceName + "_Mask"); + + Material result = CreateBakedMaterial(bakedBaseMap, bakedMaskMap, bakedNormalMap, + null, null, null, + 1, + sourceName, + Pipeline.GetTemplateMaterial(MaterialType.Hair, + MaterialQuality.Baked, characterInfo)); + + if (characterInfo.bakeCustomShaders) + { + result.SetTexture("_FlowMap", flow); + result.SetColor("_VertexBaseColor", vertexBaseColor); + result.SetFloat("_VertexColorStrength", vertexColorStrength); + result.SetColor("_SpecularTint", specularTint); + result.SetFloat("_AlphaClip", alphaClip); + result.SetFloat("_ShadowClip", shadowClip); + result.SetFloat("_DepthPrepass", depthPrepass); // Mathf.Lerp(depthPrepass, 1.0f, 0.5f)); + result.SetFloat("_DepthPostpass", depthPostpass); + result.SetFloat("_RimTransmissionIntensity", rimTransmissionIntensity); + result.SetFloat("_SpecularMultiplier", specularMultiplier); + result.SetFloat("_SpecularShift", specularShift); + result.SetFloat("_SecondarySpecularMultiplier", secondarySpecularMultiplier); + result.SetFloat("_SecondarySpecularShift", secondarySpecularShift); + result.SetFloat("_SecondarySmoothness", secondarySmoothness); + result.SetFloat("_NormalStrength", normalStrength); + } + else + { + result.SetColor("_SpecularColor", specularTint); + result.SetFloat("_AlphaClipThreshold", alphaClip); + result.SetFloat("_AlphaThresholdShadow", shadowClip); + result.SetFloat("_AlphaClipThresholdDepthPrepass", depthPrepass); // Mathf.Lerp(depthPrepass, 1.0f, 0.5f)); + result.SetFloat("_AlphaClipThresholdDepthPostpass", depthPostpass); + result.SetFloat("_TransmissionRim", rimTransmissionIntensity); + result.SetFloat("_Specular", specularMultiplier); + result.SetFloat("_SpecularShift", specularShift); + result.SetFloat("_SecondarySpecular", secondarySpecularMultiplier); + result.SetFloat("_SecondarySpecularShift", secondarySpecularShift); + result.SetFloat("_NormalStrength", normalStrength); + result.SetFloat("_SmoothnessMin", smoothnessMin); + result.SetFloat("_SmoothnessMax", smoothnessMax); + } + + return result; + } + + private Material BakeEyeOcclusionMaterial(Material mat, string sourceName) + { + float occlusionStrength = mat.GetFloat("_OcclusionStrength"); + float occlusionPower = mat.GetFloat("_OcclusionPower"); + float topMin = mat.GetFloat("_TopMin"); + float topMax = mat.GetFloat("_TopMax"); + float topCurve = mat.GetFloat("_TopCurve"); + float bottomMin = mat.GetFloat("_BottomMin"); + float bottomMax = mat.GetFloat("_BottomMax"); + float bottomCurve = mat.GetFloat("_BottomCurve"); + float innerMin = mat.GetFloat("_InnerMin"); + float innerMax = mat.GetFloat("_InnerMax"); + float outerMin = mat.GetFloat("_OuterMin"); + float outerMax = mat.GetFloat("_OuterMax"); + float occlusionStrength2 = mat.GetFloat("_OcclusionStrength2"); + float top2Min = mat.GetFloat("_Top2Min"); + float top2Max = mat.GetFloat("_Top2Max"); + float tearDuctPosition = mat.GetFloat("_TearDuctPosition"); + float tearDuctWidth = mat.GetFloat("_TearDuctWidth"); + Color occlusionColor = mat.GetColor("_OcclusionColor"); + + float expandOut = mat.GetFloat("_ExpandOut"); + float expandUpper = mat.GetFloat("_ExpandUpper"); + float expandLower = mat.GetFloat("_ExpandLower"); + float expandInner = mat.GetFloat("_ExpandInner"); + float expandOuter = mat.GetFloat("_ExpandOuter"); + + Texture2D bakedBaseMap = null; + Texture2D bakedMaskMap = null; + Texture2D bakedNormalMap = null; + Texture2D bakedDetailMap = null; + Texture2D bakedSubsurfaceMap = null; + Texture2D bakedThicknessMap = null; + + bakedBaseMap = BakeEyeOcclusionDiffuseMap( + occlusionStrength, occlusionPower, topMin, topMax, topCurve, bottomMin, bottomMax, bottomCurve, + innerMin, innerMax, outerMin, outerMax, occlusionStrength2, top2Min, top2Max, + tearDuctPosition, tearDuctWidth, occlusionColor, + sourceName + "_BaseMap"); + + Material result = CreateBakedMaterial(bakedBaseMap, bakedMaskMap, bakedNormalMap, + bakedDetailMap, bakedSubsurfaceMap, bakedThicknessMap, 1.0f, + sourceName, Pipeline.GetTemplateMaterial(MaterialType.EyeOcclusion, + MaterialQuality.Baked, characterInfo)); + + result.SetFloat("_ExpandOut", expandOut); + result.SetFloat("_ExpandUpper", expandUpper); + result.SetFloat("_ExpandLower", expandLower); + result.SetFloat("_ExpandInner", expandInner); + result.SetFloat("_ExpandOuter", expandOuter); + + return result; + } + + + private Texture2D BakeDiffuseBlendMap(Texture2D diffuse, Texture2D blend, + float blendStrength, + string name) + { + Vector2Int maxSize = GetMaxSize(diffuse); + ComputeBakeTexture bakeTarget = + new ComputeBakeTexture(maxSize, texturesFolder, name, Importer.FLAG_SRGB); + + ComputeShader bakeShader = Util.FindComputeShader(COMPUTE_SHADER); + if (bakeShader) + { + diffuse = CheckDiffuse(diffuse); + blend = CheckOverlay(blend); + + int kernel = bakeShader.FindKernel("RLDiffuseBlend"); + bakeTarget.Create(bakeShader, kernel); + bakeShader.SetTexture(kernel, "Diffuse", diffuse); + bakeShader.SetTexture(kernel, "ColorBlend", blend); + bakeShader.SetFloat("colorBlendStrength", blendStrength); + bakeShader.Dispatch(kernel, bakeTarget.width, bakeTarget.height, 1); + return bakeTarget.SaveAndReimport(); + } + + return null; + } + + private Texture2D BakeMaskMap(Texture2D mask, + float aoStrength, float smoothnessMin, float smoothnessMax, float smoothnessPower, + float microNormalStrength, + string name) + { + Vector2Int maxSize = GetMaxSize(mask); + ComputeBakeTexture bakeTarget = + new ComputeBakeTexture(maxSize, texturesFolder, name); + + ComputeShader bakeShader = Util.FindComputeShader(COMPUTE_SHADER); + if (bakeShader) + { + mask = CheckHDRP(mask); + + int kernel = bakeShader.FindKernel("RLMask"); + bakeTarget.Create(bakeShader, kernel); + bakeShader.SetTexture(kernel, "Mask", mask); + bakeShader.SetFloat("aoStrength", aoStrength); + bakeShader.SetFloat("smoothnessMin", smoothnessMin); + bakeShader.SetFloat("smoothnessMax", smoothnessMax); + bakeShader.SetFloat("smoothnessPower", smoothnessPower); + bakeShader.SetFloat("microNormalStrength", microNormalStrength); + bakeShader.Dispatch(kernel, bakeTarget.width, bakeTarget.height, 1); + return bakeTarget.SaveAndReimport(); + } + + return null; + } + + private Texture2D BakeHeadDiffuseMap(Texture2D diffuse, Texture2D blend, Texture2D cavityAO, + float blendStrength, + float mouthAOPower, float nostrilAOPower, float lipsAOPower, + string name) + { + Vector2Int maxSize = GetMaxSize(diffuse); + ComputeBakeTexture bakeTarget = + new ComputeBakeTexture(maxSize, texturesFolder, name, Importer.FLAG_SRGB); + + ComputeShader bakeShader = Util.FindComputeShader(COMPUTE_SHADER); + if (bakeShader) + { + diffuse = CheckDiffuse(diffuse); + blend = CheckOverlay(blend); + cavityAO = CheckMask(cavityAO); + + int kernel = bakeShader.FindKernel("RLHeadDiffuse"); + bakeTarget.Create(bakeShader, kernel); + bakeShader.SetTexture(kernel, "Diffuse", diffuse); + bakeShader.SetTexture(kernel, "ColorBlend", blend); + bakeShader.SetTexture(kernel, "CavityAO", cavityAO); + bakeShader.SetFloat("colorBlendStrength", blendStrength); + bakeShader.SetFloat("mouthAOPower", mouthAOPower); + bakeShader.SetFloat("nostrilAOPower", nostrilAOPower); + bakeShader.SetFloat("lipsAOPower", lipsAOPower); + bakeShader.Dispatch(kernel, bakeTarget.width, bakeTarget.height, 1); + return bakeTarget.SaveAndReimport(); + } + + return null; + } + + private Texture2D BakeHeadMaskMap(Texture2D mask, Texture2D cavityAO, + Texture2D NMUIL, Texture2D CFULC, Texture2D earNeck, + float aoStrength, float smoothnessMin, float smoothnessMax, float smoothnessPower, float microNormalStrength, + float mouthAOPower, float nostrilAOPower, float lipsAOPower, float microSmoothnessMod, + float noseMSM, float mouthMSM, float upperLidMSM, float innerLidMSM, float earMSM, + float neckMSM, float cheekMSM, float foreheadMSM, float upperLipMSM, float chinMSM, float unmaskedMSM, + string name) + { + Vector2Int maxSize = GetMaxSize(mask); + ComputeBakeTexture bakeTarget = + new ComputeBakeTexture(maxSize, texturesFolder, name); + + ComputeShader bakeShader = Util.FindComputeShader(COMPUTE_SHADER); + if (bakeShader) + { + mask = CheckHDRP(mask); + cavityAO = CheckMask(cavityAO); + NMUIL = CheckBlank(NMUIL); + CFULC = CheckBlank(CFULC); + earNeck = CheckBlank(earNeck); + + int kernel = bakeShader.FindKernel("RLHeadMask"); + bakeTarget.Create(bakeShader, kernel); + bakeShader.SetTexture(kernel, "Mask", mask); + bakeShader.SetTexture(kernel, "CavityAO", cavityAO); + bakeShader.SetTexture(kernel, "NMUILMask", NMUIL); + bakeShader.SetTexture(kernel, "CFULCMask", CFULC); + bakeShader.SetTexture(kernel, "EarNeckMask", earNeck); + bakeShader.SetFloat("aoStrength", aoStrength); + bakeShader.SetFloat("smoothnessMin", smoothnessMin); + bakeShader.SetFloat("smoothnessMax", smoothnessMax); + bakeShader.SetFloat("smoothnessPower", smoothnessPower); + bakeShader.SetFloat("microNormalStrength", microNormalStrength); + bakeShader.SetFloat("mouthAOPower", mouthAOPower); + bakeShader.SetFloat("nostrilAOPower", nostrilAOPower); + bakeShader.SetFloat("lipsAOPower", lipsAOPower); + bakeShader.SetFloat("microSmoothnessMod", microSmoothnessMod); + bakeShader.SetFloat("noseMSM", noseMSM); + bakeShader.SetFloat("mouthMSM", mouthMSM); + bakeShader.SetFloat("upperLidMSM", upperLidMSM); + bakeShader.SetFloat("innerLidMSM", innerLidMSM); + bakeShader.SetFloat("earMSM", earMSM); + bakeShader.SetFloat("neckMSM", neckMSM); + bakeShader.SetFloat("cheekMSM", cheekMSM); + bakeShader.SetFloat("foreheadMSM", foreheadMSM); + bakeShader.SetFloat("upperLipMSM", upperLipMSM); + bakeShader.SetFloat("chinMSM", chinMSM); + bakeShader.SetFloat("unmaskedMSM", unmaskedMSM); + bakeShader.Dispatch(kernel, bakeTarget.width, bakeTarget.height, 1); + return bakeTarget.SaveAndReimport(); + } + + return null; + } + + private Texture2D BakeSkinMaskMap(Texture2D mask, Texture2D RGBA, + float aoStrength, float smoothnessMin, float smoothnessMax, float smoothnessPower, + float microNormalStrength, float microSmoothnessMod, + float rMSM, float gMSM, float bMSM, float aMSM, float unmaskedMSM, + string name) + { + Vector2Int maxSize = GetMaxSize(mask); + ComputeBakeTexture bakeTarget = + new ComputeBakeTexture(maxSize, texturesFolder, name); + + ComputeShader bakeShader = Util.FindComputeShader(COMPUTE_SHADER); + if (bakeShader) + { + mask = CheckHDRP(mask); + RGBA = CheckBlank(RGBA); + + int kernel = bakeShader.FindKernel("RLSkinMask"); + bakeTarget.Create(bakeShader, kernel); + bakeShader.SetTexture(kernel, "Mask", mask); + bakeShader.SetTexture(kernel, "RGBAMask", RGBA); + bakeShader.SetFloat("aoStrength", aoStrength); + bakeShader.SetFloat("smoothnessMin", smoothnessMin); + bakeShader.SetFloat("smoothnessMax", smoothnessMax); + bakeShader.SetFloat("smoothnessPower", smoothnessPower); + bakeShader.SetFloat("microNormalStrength", microNormalStrength); + bakeShader.SetFloat("microSmoothnessMod", microSmoothnessMod); + bakeShader.SetFloat("rMSM", rMSM); + bakeShader.SetFloat("gMSM", gMSM); + bakeShader.SetFloat("bMSM", bMSM); + bakeShader.SetFloat("aMSM", aMSM); + bakeShader.SetFloat("unmaskedMSM", unmaskedMSM); + bakeShader.Dispatch(kernel, bakeTarget.width, bakeTarget.height, 1); + return bakeTarget.SaveAndReimport(); + } + + return null; + } + + private Texture2D BakeHeadSubsurfaceMap(Texture2D subsurface, + Texture2D NMUIL, Texture2D CFULC, Texture2D earNeck, + float subsurfaceScale, + float noseSS, float mouthSS, float upperLidSS, float innerLidSS, float earSS, + float neckSS, float cheekSS, float foreheadSS, float upperLipSS, float chinSS, float unmaskedSS, + string name) + { + Vector2Int maxSize = GetMaxSize(subsurface); + if (maxSize.x > 1024) maxSize.x = 1024; + if (maxSize.y > 1024) maxSize.y = 1024; + ComputeBakeTexture bakeTarget = + new ComputeBakeTexture(maxSize, texturesFolder, name); + + ComputeShader bakeShader = Util.FindComputeShader(COMPUTE_SHADER); + if (bakeShader) + { + subsurface = CheckMask(subsurface); + NMUIL = CheckBlank(NMUIL); + CFULC = CheckBlank(CFULC); + earNeck = CheckBlank(earNeck); + + int kernel = bakeShader.FindKernel("RLHeadSubsurface"); + bakeTarget.Create(bakeShader, kernel); + bakeShader.SetTexture(kernel, "Subsurface", subsurface); + bakeShader.SetTexture(kernel, "NMUILMask", NMUIL); + bakeShader.SetTexture(kernel, "CFULCMask", CFULC); + bakeShader.SetTexture(kernel, "EarNeckMask", earNeck); + bakeShader.SetFloat("subsurfaceScale", subsurfaceScale); + bakeShader.SetFloat("noseSS", noseSS); + bakeShader.SetFloat("mouthSS", mouthSS); + bakeShader.SetFloat("upperLidSS", upperLidSS); + bakeShader.SetFloat("innerLidSS", innerLidSS); + bakeShader.SetFloat("earSS", earSS); + bakeShader.SetFloat("neckSS", neckSS); + bakeShader.SetFloat("cheekSS", cheekSS); + bakeShader.SetFloat("foreheadSS", foreheadSS); + bakeShader.SetFloat("upperLipSS", upperLipSS); + bakeShader.SetFloat("chinSS", chinSS); + bakeShader.SetFloat("unmaskedSS", unmaskedSS); + bakeShader.Dispatch(kernel, bakeTarget.width, bakeTarget.height, 1); + return bakeTarget.SaveAndReimport(); + } + + return null; + } + + private Texture2D BakeSkinSubsurfaceMap(Texture2D subsurface, Texture2D RGBA, + float subsurfaceScale, + float rSS, float gSS, float bSS, float aSS, float unmaskedSS, + string name) + { + Vector2Int maxSize = GetMaxSize(subsurface); + if (maxSize.x > 1024) maxSize.x = 1024; + if (maxSize.y > 1024) maxSize.y = 1024; + ComputeBakeTexture bakeTarget = + new ComputeBakeTexture(maxSize, texturesFolder, name); + + ComputeShader bakeShader = Util.FindComputeShader(COMPUTE_SHADER); + if (bakeShader) + { + subsurface = CheckMask(subsurface); + RGBA = CheckBlank(RGBA); + + int kernel = bakeShader.FindKernel("RLSkinSubsurface"); + bakeTarget.Create(bakeShader, kernel); + bakeShader.SetTexture(kernel, "Subsurface", subsurface); + bakeShader.SetTexture(kernel, "RGBAMask", RGBA); + bakeShader.SetFloat("subsurfaceScale", subsurfaceScale); + bakeShader.SetFloat("rSS", rSS); + bakeShader.SetFloat("gSS", gSS); + bakeShader.SetFloat("bSS", bSS); + bakeShader.SetFloat("aSS", aSS); + bakeShader.SetFloat("unmaskedSS", unmaskedSS); + bakeShader.Dispatch(kernel, bakeTarget.width, bakeTarget.height, 1); + return bakeTarget.SaveAndReimport(); + } + + return null; + } + + private Texture2D BakeBlendNormalMap(Texture2D normal, Texture2D normalBlend, + float normalBlendStrength, + string name) + { + Vector2Int maxSize = GetMaxSize(normal, normalBlend); + ComputeBakeTexture bakeTarget = + new ComputeBakeTexture(maxSize, texturesFolder, name, Importer.FLAG_NORMAL); + + ComputeShader bakeShader = Util.FindComputeShader(COMPUTE_SHADER); + if (bakeShader) + { + normal = CheckNormal(normal); + normalBlend = CheckNormal(normalBlend); + + int kernel = bakeShader.FindKernel("RLNormalBlend"); + bakeTarget.Create(bakeShader, kernel); + bakeShader.SetTexture(kernel, "Normal", normal); + bakeShader.SetTexture(kernel, "NormalBlend", normalBlend); + bakeShader.SetFloat("normalBlendStrength", normalBlendStrength); + bakeShader.Dispatch(kernel, bakeTarget.width, bakeTarget.height, 1); + return bakeTarget.SaveAndReimport(); + } + + return null; + } + + private Texture2D BakeDetailMap(Texture2D microNormal, + string name) + { + Vector2Int maxSize = GetMaxSize(microNormal); + ComputeBakeTexture bakeTarget = + new ComputeBakeTexture(maxSize, texturesFolder, name); + + ComputeShader bakeShader = Util.FindComputeShader(COMPUTE_SHADER); + if (bakeShader) + { + microNormal = CheckNormal(microNormal); + + int kernel = bakeShader.FindKernel("RLDetail"); + bakeTarget.Create(bakeShader, kernel); + bakeShader.SetTexture(kernel, "MicroNormal", microNormal); + bakeShader.Dispatch(kernel, bakeTarget.width, bakeTarget.height, 1); + return bakeTarget.SaveAndReimport(); + } + + return null; + } + + + private Texture2D BakeSubsurfaceMap(Texture2D subsurface, + float subsurfaceScale, + string name) + { + Vector2Int maxSize = GetMaxSize(subsurface); + if (maxSize.x > 1024) maxSize.x = 1024; + if (maxSize.y > 1024) maxSize.y = 1024; + ComputeBakeTexture bakeTarget = + new ComputeBakeTexture(maxSize, texturesFolder, name); + + ComputeShader bakeShader = Util.FindComputeShader(COMPUTE_SHADER); + if (bakeShader) + { + subsurface = CheckMask(subsurface); + + int kernel = bakeShader.FindKernel("RLSubsurface"); + bakeTarget.Create(bakeShader, kernel); + bakeShader.SetTexture(kernel, "Subsurface", subsurface); + bakeShader.SetFloat("subsurfaceScale", subsurfaceScale); + bakeShader.Dispatch(kernel, bakeTarget.width, bakeTarget.height, 1); + return bakeTarget.SaveAndReimport(); + } + + return null; + } + + private Texture2D BakeThicknessMap(Texture2D thickness, + float thicknessScale, + string name) + { + Vector2Int maxSize = GetMaxSize(thickness); + if (maxSize.x > 1024) maxSize.x = 1024; + if (maxSize.y > 1024) maxSize.y = 1024; + ComputeBakeTexture bakeTarget = + new ComputeBakeTexture(maxSize, texturesFolder, name); + + ComputeShader bakeShader = Util.FindComputeShader(COMPUTE_SHADER); + if (bakeShader) + { + thickness = CheckMask(thickness); + + int kernel = bakeShader.FindKernel("RLThickness"); + bakeTarget.Create(bakeShader, kernel); + bakeShader.SetTexture(kernel, "Thickness", thickness); + bakeShader.SetFloat("thicknessScale", thicknessScale); + bakeShader.Dispatch(kernel, bakeTarget.width, bakeTarget.height, 1); + return bakeTarget.SaveAndReimport(); + } + + return null; + } + + private Texture2D BakeTeethDiffuseMap(Texture2D diffuse, Texture2D gumsMask, Texture2D gradientAO, + float isUpperTeeth, float frontAO, float rearAO, float gumsSaturation, float gumsBrightness, + float teethSaturation, float teethBrightness, + string name) + { + Vector2Int maxSize = GetMaxSize(diffuse); + ComputeBakeTexture bakeTarget = + new ComputeBakeTexture(maxSize, texturesFolder, name, Importer.FLAG_SRGB); + + ComputeShader bakeShader = Util.FindComputeShader(COMPUTE_SHADER); + if (bakeShader) + { + diffuse = CheckDiffuse(diffuse); + gumsMask = CheckMask(gumsMask); + gradientAO = CheckMask(gradientAO); + + int kernel = bakeShader.FindKernel("RLTeethDiffuse"); + bakeTarget.Create(bakeShader, kernel); + bakeShader.SetTexture(kernel, "Diffuse", diffuse); + bakeShader.SetTexture(kernel, "GumsMask", gumsMask); + bakeShader.SetTexture(kernel, "GradientAO", gradientAO); + bakeShader.SetFloat("isUpperTeeth", isUpperTeeth); + bakeShader.SetFloat("frontAO", frontAO); + bakeShader.SetFloat("rearAO", rearAO); + bakeShader.SetFloat("gumsSaturation", gumsSaturation); + bakeShader.SetFloat("gumsBrightness", gumsBrightness); + bakeShader.SetFloat("teethSaturation", teethSaturation); + bakeShader.SetFloat("teethBrightness", teethBrightness); + bakeShader.Dispatch(kernel, bakeTarget.width, bakeTarget.height, 1); + return bakeTarget.SaveAndReimport(); + } + + return null; + } + + private Texture2D BakeTeethMaskMap(Texture2D mask, Texture2D gradientAO, + float isUpperTeeth, float aoStrength, float smoothnessMin, float smoothnessMax, float smoothnessPower, + float frontAO, float rearAO, float microNormalStrength, + string name) + { + Vector2Int maxSize = GetMaxSize(mask); + ComputeBakeTexture bakeTarget = + new ComputeBakeTexture(maxSize, texturesFolder, name); + + ComputeShader bakeShader = Util.FindComputeShader(COMPUTE_SHADER); + if (bakeShader) + { + mask = CheckHDRP(mask); + gradientAO = CheckMask(gradientAO); + + int kernel = bakeShader.FindKernel("RLTeethMask"); + bakeTarget.Create(bakeShader, kernel); + bakeShader.SetTexture(kernel, "Mask", mask); + bakeShader.SetTexture(kernel, "GradientAO", gradientAO); + bakeShader.SetFloat("aoStrength", aoStrength); + bakeShader.SetFloat("smoothnessMin", smoothnessMin); + bakeShader.SetFloat("smoothnessMax", smoothnessMax); + bakeShader.SetFloat("smoothnessPower", smoothnessPower); + bakeShader.SetFloat("microNormalStrength", microNormalStrength); + bakeShader.SetFloat("isUpperTeeth", isUpperTeeth); + bakeShader.SetFloat("frontAO", frontAO); + bakeShader.SetFloat("rearAO", rearAO); + bakeShader.Dispatch(kernel, bakeTarget.width, bakeTarget.height, 1); + return bakeTarget.SaveAndReimport(); + } + + return null; + } + + private Texture2D BakeTeethSubsurfaceMap(Texture2D gumsMask, Texture2D gradientAO, + float isUpperTeeth, float rearAO, float frontAO, float gumsSSS, float teethSSS, + string name) + { + Vector2Int maxSize = new Vector2Int(256, 256); + ComputeBakeTexture bakeTarget = + new ComputeBakeTexture(maxSize, texturesFolder, name); + + ComputeShader bakeShader = Util.FindComputeShader(COMPUTE_SHADER); + if (bakeShader) + { + gumsMask = CheckMask(gumsMask); + gradientAO = CheckMask(gradientAO); + + int kernel = bakeShader.FindKernel("RLTeethSubsurface"); + bakeTarget.Create(bakeShader, kernel); + bakeShader.SetTexture(kernel, "GumsMask", gumsMask); + bakeShader.SetTexture(kernel, "GradientAO", gradientAO); + bakeShader.SetFloat("isUpperTeeth", isUpperTeeth); + bakeShader.SetFloat("rearAO", rearAO); + bakeShader.SetFloat("frontAO", frontAO); + bakeShader.SetFloat("gumsSSS", gumsSSS); + bakeShader.SetFloat("teethSSS", teethSSS); + bakeShader.Dispatch(kernel, bakeTarget.width, bakeTarget.height, 1); + return bakeTarget.SaveAndReimport(); + } + + return null; + } + private Texture2D BakeTeethThicknessMap(Texture2D gumsMask, + float gumsThickness, float teethThickness, + string name) + { + Vector2Int maxSize = new Vector2Int(256, 256); + ComputeBakeTexture bakeTarget = + new ComputeBakeTexture(maxSize, texturesFolder, name); + + ComputeShader bakeShader = Util.FindComputeShader(COMPUTE_SHADER); + if (bakeShader) + { + gumsMask = CheckMask(gumsMask); + + int kernel = bakeShader.FindKernel("RLTeethThickness"); + bakeTarget.Create(bakeShader, kernel); + bakeShader.SetTexture(kernel, "GumsMask", gumsMask); + bakeShader.SetFloat("gumsThickness", gumsThickness); + bakeShader.SetFloat("teethThickness", teethThickness); + bakeShader.Dispatch(kernel, bakeTarget.width, bakeTarget.height, 1); + return bakeTarget.SaveAndReimport(); + } + + return null; + } + + + private Texture2D BakeTongueDiffuseMap(Texture2D diffuse, Texture2D gradientAO, + float frontAO, float rearAO, float tongueSaturation, float tongueBrightness, + string name) + { + Vector2Int maxSize = GetMaxSize(diffuse); + ComputeBakeTexture bakeTarget = + new ComputeBakeTexture(maxSize, texturesFolder, name, Importer.FLAG_SRGB); + + ComputeShader bakeShader = Util.FindComputeShader(COMPUTE_SHADER); + if (bakeShader) + { + diffuse = CheckDiffuse(diffuse); + gradientAO = CheckMask(gradientAO); + + int kernel = bakeShader.FindKernel("RLTongueDiffuse"); + bakeTarget.Create(bakeShader, kernel); + bakeShader.SetTexture(kernel, "Diffuse", diffuse); + bakeShader.SetTexture(kernel, "GradientAO", gradientAO); + bakeShader.SetFloat("frontAO", frontAO); + bakeShader.SetFloat("rearAO", rearAO); + bakeShader.SetFloat("tongueSaturation", tongueSaturation); + bakeShader.SetFloat("tongueBrightness", tongueBrightness); + bakeShader.Dispatch(kernel, bakeTarget.width, bakeTarget.height, 1); + return bakeTarget.SaveAndReimport(); + } + + return null; + } + + private Texture2D BakeTongueMaskMap(Texture2D mask, Texture2D gradientAO, + float aoStrength, float smoothnessMin, float smoothnessMax, float smoothnessPower, + float frontAO, float rearAO, float microNormalStrength, + string name) + { + Vector2Int maxSize = GetMaxSize(mask); + ComputeBakeTexture bakeTarget = + new ComputeBakeTexture(maxSize, texturesFolder, name); + + ComputeShader bakeShader = Util.FindComputeShader(COMPUTE_SHADER); + if (bakeShader) + { + mask = CheckHDRP(mask); + gradientAO = CheckMask(gradientAO); + + int kernel = bakeShader.FindKernel("RLTongueMask"); + bakeTarget.Create(bakeShader, kernel); + bakeShader.SetTexture(kernel, "Mask", mask); + bakeShader.SetTexture(kernel, "GradientAO", gradientAO); + bakeShader.SetFloat("aoStrength", aoStrength); + bakeShader.SetFloat("smoothnessMin", smoothnessMin); + bakeShader.SetFloat("smoothnessMax", smoothnessMax); + bakeShader.SetFloat("smoothnessPower", smoothnessPower); + bakeShader.SetFloat("microNormalStrength", microNormalStrength); + bakeShader.SetFloat("frontAO", frontAO); + bakeShader.SetFloat("rearAO", rearAO); + bakeShader.Dispatch(kernel, bakeTarget.width, bakeTarget.height, 1); + return bakeTarget.SaveAndReimport(); + } + + return null; + } + + private Texture2D BakeTongueSubsurfaceMap(Texture2D gradientAO, + float rearAO, float frontAO, float tongueSSS, + string name) + { + Vector2Int maxSize = new Vector2Int(256, 256); + ComputeBakeTexture bakeTarget = + new ComputeBakeTexture(maxSize, texturesFolder, name); + + ComputeShader bakeShader = Util.FindComputeShader(COMPUTE_SHADER); + if (bakeShader) + { + gradientAO = CheckMask(gradientAO); + + int kernel = bakeShader.FindKernel("RLTongueSubsurface"); + bakeTarget.Create(bakeShader, kernel); + bakeShader.SetTexture(kernel, "GradientAO", gradientAO); + bakeShader.SetFloat("rearAO", rearAO); + bakeShader.SetFloat("frontAO", frontAO); + bakeShader.SetFloat("tongueSSS", tongueSSS); + bakeShader.Dispatch(kernel, bakeTarget.width, bakeTarget.height, 1); + return bakeTarget.SaveAndReimport(); + } + + return null; + } + + private Texture2D BakeCorneaDiffuseMap(Texture2D sclera, Texture2D colorBlend, + float scleraScale, float scleraHue, float scleraSaturation, float scleraBrightness, + float irisScale, float irisRadius, float limbusWidth, float shadowRadius, float shadowHardness, + Color cornerShadowColor, float colorBlendStrength, + string name) + { + Vector2Int maxSize = GetMaxSize(sclera); + ComputeBakeTexture bakeTarget = + new ComputeBakeTexture(maxSize, texturesFolder, name, Importer.FLAG_SRGB); + + ComputeShader bakeShader = Util.FindComputeShader(COMPUTE_SHADER); + if (bakeShader) + { + sclera = CheckDiffuse(sclera); + colorBlend = CheckOverlay(colorBlend); + + int kernel = bakeShader.FindKernel("RLCorneaDiffuse"); + bakeTarget.Create(bakeShader, kernel); + bakeShader.SetTexture(kernel, "ScleraDiffuse", sclera); + bakeShader.SetTexture(kernel, "ColorBlend", colorBlend); + bakeShader.SetFloat("scleraScale", scleraScale); + bakeShader.SetFloat("scleraHue", scleraHue); + bakeShader.SetFloat("scleraSaturation", scleraSaturation); + bakeShader.SetFloat("scleraBrightness", scleraBrightness); + bakeShader.SetFloat("irisScale", irisScale); + bakeShader.SetFloat("irisRadius", irisRadius); + bakeShader.SetFloat("limbusWidth", limbusWidth); + bakeShader.SetFloat("shadowRadius", shadowRadius); + bakeShader.SetFloat("shadowHardness", shadowHardness); + bakeShader.SetFloat("colorBlendStrength", colorBlendStrength); + bakeShader.SetVector("cornerShadowColor", cornerShadowColor); + bakeShader.Dispatch(kernel, bakeTarget.width, bakeTarget.height, 1); + return bakeTarget.SaveAndReimport(); + } + + return null; + } + + private Texture2D BakeEyeDiffuseMap(Texture2D cornea, Texture2D colorBlend, + float irisScale, float irisHue, float irisSaturation, float irisBrightness, + float limbusDarkRadius, float limbusDarkWidth, Color limbusColor, + float colorBlendStrength, + string name) + { + Vector2Int maxSize = GetMaxSize(cornea); + ComputeBakeTexture bakeTarget = + new ComputeBakeTexture(maxSize, texturesFolder, name, Importer.FLAG_SRGB); + + ComputeShader bakeShader = Util.FindComputeShader(COMPUTE_SHADER); + if (bakeShader) + { + cornea = CheckDiffuse(cornea); + colorBlend = CheckOverlay(colorBlend); + + int kernel = bakeShader.FindKernel("RLEyeDiffuse"); + bakeTarget.Create(bakeShader, kernel); + bakeShader.SetTexture(kernel, "CorneaDiffuse", cornea); + bakeShader.SetTexture(kernel, "ColorBlend", colorBlend); + bakeShader.SetFloat("irisScale", irisScale); + bakeShader.SetFloat("irisHue", irisHue); + bakeShader.SetFloat("irisSaturation", irisSaturation); + bakeShader.SetFloat("irisBrightness", irisBrightness); + bakeShader.SetFloat("limbusDarkRadius", limbusDarkRadius); + bakeShader.SetFloat("limbusDarkWidth", limbusDarkWidth); + bakeShader.SetFloat("colorBlendStrength", colorBlendStrength); + bakeShader.SetVector("limbusColor", limbusColor); + bakeShader.Dispatch(kernel, bakeTarget.width, bakeTarget.height, 1); + return bakeTarget.SaveAndReimport(); + } + + return null; + } + + private Texture2D BakeCorneaMaskMap(Texture2D mask, + float aoStrength, float corneaSmoothness, float scleraSmoothness, + float irisScale, float irisRadius, float limbusWidth, float microNormalStrength, + string name) + { + Vector2Int maxSize = GetMaxSize(mask); + ComputeBakeTexture bakeTarget = + new ComputeBakeTexture(maxSize, texturesFolder, name); + + ComputeShader bakeShader = Util.FindComputeShader(COMPUTE_SHADER); + if (bakeShader) + { + mask = CheckHDRP(mask); + + int kernel = bakeShader.FindKernel("RLCorneaMask"); + bakeTarget.Create(bakeShader, kernel); + bakeShader.SetTexture(kernel, "Mask", mask); + bakeShader.SetFloat("aoStrength", aoStrength); + bakeShader.SetFloat("corneaSmoothness", corneaSmoothness); + bakeShader.SetFloat("scleraSmoothness", scleraSmoothness); + bakeShader.SetFloat("microNormalStrength", microNormalStrength); + bakeShader.SetFloat("irisScale", irisScale); + bakeShader.SetFloat("irisRadius", irisRadius); + bakeShader.SetFloat("limbusWidth", limbusWidth); + bakeShader.Dispatch(kernel, bakeTarget.width, bakeTarget.height, 1); + return bakeTarget.SaveAndReimport(); + } + + return null; + } + + private Texture2D BakeEyeMaskMap(Texture2D mask, + float aoStrength, float irisSmoothness, float scleraSmoothness, + float irisScale, float limbusDarkRadius, float limbusDarkWidth, + float irisRadius, float depthRadius, + string name) + { + Vector2Int maxSize = GetMaxSize(mask); + ComputeBakeTexture bakeTarget = + new ComputeBakeTexture(maxSize, texturesFolder, name); + + ComputeShader bakeShader = Util.FindComputeShader(COMPUTE_SHADER); + if (bakeShader) + { + mask = CheckHDRP(mask); + + int kernel = bakeShader.FindKernel("RLEyeMask"); + bakeTarget.Create(bakeShader, kernel); + bakeShader.SetTexture(kernel, "Mask", mask); + bakeShader.SetFloat("aoStrength", aoStrength); + bakeShader.SetFloat("irisSmoothness", irisSmoothness); + bakeShader.SetFloat("scleraSmoothness", scleraSmoothness); + bakeShader.SetFloat("irisScale", irisScale); + bakeShader.SetFloat("limbusDarkRadius", limbusDarkRadius); + bakeShader.SetFloat("limbusDarkWidth", limbusDarkWidth); + bakeShader.SetFloat("irisRadius", irisRadius); + bakeShader.SetFloat("depthRadius", depthRadius); + bakeShader.Dispatch(kernel, bakeTarget.width, bakeTarget.height, 1); + return bakeTarget.SaveAndReimport(); + } + + return null; + } + + private Texture2D BakeCorneaThicknessMap( + float irisScale, float limbusDarkRadius, float limbusDarkWidth, float thicknessScale, + string name) + { + Vector2Int maxSize = new Vector2Int(256, 256); + ComputeBakeTexture bakeTarget = + new ComputeBakeTexture(maxSize, texturesFolder, name); + + ComputeShader bakeShader = Util.FindComputeShader(COMPUTE_SHADER); + if (bakeShader) + { + int kernel = bakeShader.FindKernel("RLCorneaThickness"); + bakeTarget.Create(bakeShader, kernel); + bakeShader.SetFloat("irisScale", irisScale); + bakeShader.SetFloat("limbusDarkRadius", limbusDarkRadius); + bakeShader.SetFloat("limbusDarkWidth", limbusDarkWidth); + bakeShader.SetFloat("thicknessScale", thicknessScale); + bakeShader.Dispatch(kernel, bakeTarget.width, bakeTarget.height, 1); + return bakeTarget.SaveAndReimport(); + } + + return null; + } + + private Texture2D BakeHairDiffuseMap(Texture2D diffuse, Texture2D blend, Texture2D id, Texture2D root, Texture2D mask, + float diffuseStrength, float alphaPower, float alphaRemap, float aoStrength, float aoOccludeAll, + Color rootColor, float rootColorStrength, Color endColor, float endColorStrength, float globalStrength, + float invertRootMap, float baseColorStrength, + Color highlightAColor, Vector4 highlightADistribution, float highlightAOverlapEnd, + float highlightAOverlapInvert, float highlightAStrength, + Color highlightBColor, Vector4 highlightBDistribution, float highlightBOverlapEnd, + float highlightBOverlapInvert, float highlightBStrength, + float blendStrength, Color vertexBaseColor, float vertexColorStrength, + string name) + { + Vector2Int maxSize = GetMaxSize(diffuse, id); + ComputeBakeTexture bakeTarget = + new ComputeBakeTexture(maxSize, texturesFolder, name, + Importer.FLAG_SRGB + + (name.iContains("hair") ? Importer.FLAG_HAIR : Importer.FLAG_ALPHA_CLIP) + ); + + ComputeShader bakeShader = Util.FindComputeShader(COMPUTE_SHADER); + if (bakeShader) + { + diffuse = CheckDiffuse(diffuse); + blend = CheckMask(blend); + id = CheckOverlay(id); + root = CheckMask(root); + + int kernel = bakeShader.FindKernel("RLHairColoredDiffuse"); + bakeTarget.Create(bakeShader, kernel); + bakeShader.SetTexture(kernel, "Diffuse", diffuse); + bakeShader.SetTexture(kernel, "ColorBlend", blend); + bakeShader.SetTexture(kernel, "ID", id); + bakeShader.SetTexture(kernel, "Root", root); + bakeShader.SetTexture(kernel, "Mask", mask); + bakeShader.SetFloat("diffuseStrength", diffuseStrength); + bakeShader.SetFloat("alphaPower", alphaPower); + bakeShader.SetFloat("alphaRemap", alphaRemap); + bakeShader.SetFloat("aoStrength", aoStrength); + bakeShader.SetFloat("aoOccludeAll", aoOccludeAll); + bakeShader.SetFloat("rootColorStrength", rootColorStrength); + bakeShader.SetFloat("endColorStrength", endColorStrength); + bakeShader.SetFloat("globalStrength", globalStrength); + bakeShader.SetFloat("invertRootMap", invertRootMap); + bakeShader.SetFloat("baseColorStrength", baseColorStrength); + bakeShader.SetFloat("highlightAOverlapEnd", highlightAOverlapEnd); + bakeShader.SetFloat("highlightAOverlapInvert", highlightAOverlapInvert); + bakeShader.SetFloat("highlightAStrength", highlightAStrength); + bakeShader.SetFloat("highlightBOverlapEnd", highlightBOverlapEnd); + bakeShader.SetFloat("highlightBOverlapInvert", highlightBOverlapInvert); + bakeShader.SetFloat("highlightBStrength", highlightBStrength); + bakeShader.SetFloat("colorBlendStrength", blendStrength); + bakeShader.SetFloat("vertexColorStrength", vertexColorStrength); + bakeShader.SetVector("rootColor", rootColor); + bakeShader.SetVector("endColor", endColor); + bakeShader.SetVector("highlightAColor", highlightAColor); + bakeShader.SetVector("highlightBColor", highlightBColor); + bakeShader.SetVector("vertexBaseColor", vertexBaseColor); + bakeShader.SetVector("highlightADistribution", highlightADistribution); + bakeShader.SetVector("highlightBDistribution", highlightBDistribution); + bakeShader.Dispatch(kernel, bakeTarget.width, bakeTarget.height, 1); + return bakeTarget.SaveAndReimport(); + } + + return null; + } + + private Texture2D BakeHairDiffuseMap(Texture2D diffuse, Texture2D blend, Texture2D mask, + float diffuseStrength, float alphaPower, float alphaRemap, float aoStrength, float aoOccludeAll, + float blendStrength, Color vertexBaseColor, float vertexColorStrength, + string name) + { + Vector2Int maxSize = GetMaxSize(diffuse); + ComputeBakeTexture bakeTarget = + new ComputeBakeTexture(maxSize, texturesFolder, name, + Importer.FLAG_SRGB + + (name.iContains("hair") ? Importer.FLAG_HAIR : Importer.FLAG_ALPHA_CLIP) + ); + + ComputeShader bakeShader = Util.FindComputeShader(COMPUTE_SHADER); + if (bakeShader) + { + diffuse = CheckDiffuse(diffuse); + blend = CheckMask(blend); + + int kernel = bakeShader.FindKernel("RLHairDiffuse"); + bakeTarget.Create(bakeShader, kernel); + bakeShader.SetTexture(kernel, "Diffuse", diffuse); + bakeShader.SetTexture(kernel, "ColorBlend", blend); + bakeShader.SetTexture(kernel, "Mask", mask); + bakeShader.SetFloat("diffuseStrength", diffuseStrength); + bakeShader.SetFloat("alphaPower", alphaPower); + bakeShader.SetFloat("alphaRemap", alphaRemap); + bakeShader.SetFloat("aoStrength", aoStrength); + bakeShader.SetFloat("aoOccludeAll", aoOccludeAll); + bakeShader.SetFloat("colorBlendStrength", blendStrength); + bakeShader.SetFloat("vertexColorStrength", vertexColorStrength); + bakeShader.SetVector("vertexBaseColor", vertexBaseColor); + bakeShader.Dispatch(kernel, bakeTarget.width, bakeTarget.height, 1); + return bakeTarget.SaveAndReimport(); + } + + return null; + } + + private Texture2D BakeHairMaskMap(Texture2D mask, Texture2D specular, + float aoStrength, float smoothnessMin, float smoothnessMax, float smoothnessPower, + string name) + { + Vector2Int maxSize = GetMaxSize(mask); + ComputeBakeTexture bakeTarget = + new ComputeBakeTexture(maxSize, texturesFolder, name); + + ComputeShader bakeShader = Util.FindComputeShader(COMPUTE_SHADER); + if (bakeShader) + { + mask = CheckHDRP(mask); + specular = CheckMask(specular); + + int kernel = bakeShader.FindKernel("RLHairMask"); + bakeTarget.Create(bakeShader, kernel); + bakeShader.SetTexture(kernel, "Mask", mask); + bakeShader.SetTexture(kernel, "Specular", specular); + bakeShader.SetFloat("aoStrength", aoStrength); + bakeShader.SetFloat("smoothnessMin", smoothnessMin); + bakeShader.SetFloat("smoothnessMax", smoothnessMax); + bakeShader.SetFloat("smoothnessPower", smoothnessPower); + bakeShader.Dispatch(kernel, bakeTarget.width, bakeTarget.height, 1); + return bakeTarget.SaveAndReimport(); + } + + return null; + } + + private Texture2D BakeEyeOcclusionDiffuseMap(float occlusionStrength, float occlusionPower, + float topMin, float topMax, float topCurve, float bottomMin, float bottomMax, float bottomCurve, + float innerMin, float innerMax, float outerMin, float outerMax, + float occlusionStrength2, float top2Min, float top2Max, + float tearDuctPosition, float tearDuctWidth, Color occlusionColor, + string name) + { + Vector2Int maxSize = new Vector2Int(256, 256); + ComputeBakeTexture bakeTarget = + new ComputeBakeTexture(maxSize, texturesFolder, name, Importer.FLAG_SRGB); + + ComputeShader bakeShader = Util.FindComputeShader(COMPUTE_SHADER); + if (bakeShader) + { + int kernel = bakeShader.FindKernel("RLEyeOcclusionDiffuse"); + bakeTarget.Create(bakeShader, kernel); + bakeShader.SetFloat("eoOcclusionStrength", occlusionStrength); + bakeShader.SetFloat("eoOcclusionPower", occlusionPower); + bakeShader.SetFloat("eoTopMin", topMin); + bakeShader.SetFloat("eoTopMax", topMax); + bakeShader.SetFloat("eoTopCurve", topCurve); + bakeShader.SetFloat("eoBottomMin", bottomMin); + bakeShader.SetFloat("eoBottomMax", bottomMax); + bakeShader.SetFloat("eoBottomCurve", bottomCurve); + bakeShader.SetFloat("eoInnerMin", innerMin); + bakeShader.SetFloat("eoInnerMax", innerMax); + bakeShader.SetFloat("eoOuterMin", outerMin); + bakeShader.SetFloat("eoOuterMax", outerMax); + bakeShader.SetFloat("eoOcclusionStrength2", occlusionStrength2); + bakeShader.SetFloat("eoTop2Min", top2Min); + bakeShader.SetFloat("eoTop2Max", top2Max); + bakeShader.SetFloat("eoTearDuctPosition", tearDuctPosition); + bakeShader.SetFloat("eoTearDuctWidth", tearDuctWidth); + bakeShader.SetVector("eoEyeOcclusionColor", occlusionColor); + bakeShader.Dispatch(kernel, bakeTarget.width, bakeTarget.height, 1); + return bakeTarget.SaveAndReimport(); + } + + return null; + } + + + public Texture2D BakeDefaultSkinThicknessMap(Texture2D thickness, string name) + { + Texture2D bakedThickness = BakeThicknessMap(thickness, 1.0f, name); + return bakedThickness; + } + + public Texture2D BakeDefaultDetailMap(Texture2D microNormal, string name) + { + Texture2D bakedDetail = BakeDetailMap(microNormal, name); + return bakedDetail; + } + + } + +} diff --git a/Editor/ComputeBake.cs.meta b/Editor/ComputeBake.cs.meta new file mode 100644 index 0000000..9e81014 --- /dev/null +++ b/Editor/ComputeBake.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 33054e31a5161c043a3d284ff5985dd8 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Editor/ComputeBakeTexture.cs b/Editor/ComputeBakeTexture.cs new file mode 100644 index 0000000..5cb53e2 --- /dev/null +++ b/Editor/ComputeBakeTexture.cs @@ -0,0 +1,129 @@ +/* + * Copyright (C) 2021 Victor Soupday + * This file is part of CC3_Unity_Tools + * + * CC3_Unity_Tools is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * CC3_Unity_Tools is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with CC3_Unity_Tools. If not, see . + */ + +using System.IO; +using UnityEditor; +using UnityEngine; + +namespace Reallusion.Import +{ + public class ComputeBakeTexture + { + private readonly RenderTexture renderTexture; + private readonly Texture2D saveTexture; + public readonly int width; + public readonly int height; + public readonly string folderPath; + public readonly string textureName; + public readonly int flags; + + private const string COMPUTE_SHADER_RESULT = "Result"; + + public bool IsRGB { get { return (flags & Importer.FLAG_SRGB) > 0; } } + public bool IsNormal { get { return (flags & Importer.FLAG_NORMAL) > 0; } } + public bool IsAlphaClip { get { return (flags & Importer.FLAG_ALPHA_CLIP) > 0; } } + public bool IsHair { get { return (flags & Importer.FLAG_HAIR) > 0; } } + + public ComputeBakeTexture(Vector2Int size, string folder, string name, int flags = 0) + { + width = size.x; + height = size.y; + this.flags = flags; + renderTexture = new RenderTexture(width, height, 0, + RenderTextureFormat.ARGB32, + IsRGB ? RenderTextureReadWrite.sRGB : RenderTextureReadWrite.Linear); + saveTexture = new Texture2D(width, height, TextureFormat.ARGB32, true, !IsRGB); + folderPath = folder; + textureName = name; + } + + private string WritePNG() + { + string filePath = Path.Combine(Path.GetDirectoryName(Application.dataPath), folderPath, textureName + ".png"); + + Util.EnsureAssetsFolderExists(folderPath); + + byte[] pngArray = saveTexture.EncodeToPNG(); + + File.WriteAllBytes(filePath, pngArray); + + string assetPath = Util.GetRelativePath(filePath); + if (File.Exists(filePath)) return assetPath; + else return ""; + } + + private void ApplyImportSettings(string filePath) + { + if (!string.IsNullOrEmpty(filePath)) + { + AssetDatabase.Refresh(); + + TextureImporter importer = (TextureImporter)AssetImporter.GetAtPath(filePath); + if (importer) + { + importer.textureType = IsNormal ? TextureImporterType.NormalMap : TextureImporterType.Default; + importer.sRGBTexture = IsRGB; + importer.alphaIsTransparency = IsRGB; + importer.maxTextureSize = 4096; + importer.mipmapEnabled = true; + importer.mipMapBias = Importer.MIPMAP_BIAS; + if (IsHair) + { + importer.mipMapsPreserveCoverage = true; + importer.alphaTestReferenceValue = Importer.MIPMAP_ALPHA_CLIP_HAIR_BAKED; + } + else if (IsAlphaClip) + { + importer.mipMapsPreserveCoverage = true; + importer.alphaTestReferenceValue = 0.5f; + } + else + { + importer.mipMapsPreserveCoverage = false; + } + importer.mipmapFilter = TextureImporterMipFilter.BoxFilter; + importer.SaveAndReimport(); + //AssetDatabase.WriteImportSettingsIfDirty(filePath); + } + } + } + + public void Create(ComputeShader shader, int kernel) + { + renderTexture.enableRandomWrite = true; + renderTexture.Create(); + shader.SetTexture(kernel, COMPUTE_SHADER_RESULT, renderTexture); + } + + public Texture2D SaveAndReimport() + { + // copy the GPU render texture to a real texture2D + RenderTexture old = RenderTexture.active; + RenderTexture.active = renderTexture; + saveTexture.ReadPixels(new Rect(0, 0, width, height), 0, 0); + saveTexture.Apply(); + RenderTexture.active = old; + + string filePath = WritePNG(); + ApplyImportSettings(filePath); + + Texture2D assetTex = AssetDatabase.LoadAssetAtPath(filePath); + return assetTex; + } + } +} diff --git a/Editor/ComputeBakeTexture.cs.meta b/Editor/ComputeBakeTexture.cs.meta new file mode 100644 index 0000000..351bde9 --- /dev/null +++ b/Editor/ComputeBakeTexture.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: a0745421b002c48439d79a76106d6e58 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Editor/Importer.cs b/Editor/Importer.cs new file mode 100644 index 0000000..a601a64 --- /dev/null +++ b/Editor/Importer.cs @@ -0,0 +1,1219 @@ +/* + * Copyright (C) 2021 Victor Soupday + * This file is part of CC3_Unity_Tools + * + * CC3_Unity_Tools is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * CC3_Unity_Tools is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with CC3_Unity_Tools. If not, see . + */ + +using System.Collections.Generic; +using System.IO; +using UnityEditor; +using UnityEditor.Rendering.HighDefinition; +using UnityEngine; + +namespace Reallusion.Import +{ + public class Importer + { + private readonly GameObject fbx; + private readonly QuickJSON jsonData; + private readonly QuickJSON jsonMeshData; + private readonly string fbxPath; + private readonly string fbxFolder; + private readonly string fbmFolder; + private readonly string texFolder; + private readonly string materialsFolder; + private readonly string characterName; + private readonly int id; + private readonly List textureFolders; + private readonly ModelImporter importer; + private readonly List importAssets = new List(); + private MaterialQuality quality = MaterialQuality.High; + private CharacterInfo characterInfo; + private List processedSourceMaterials; + private Dictionary bakedDetailMaps; + private Dictionary bakedThicknessMaps; + private readonly BaseGeneration generation; + + public const string MATERIALS_FOLDER = "Materials"; + public const string PREFABS_FOLDER = "Prefabs"; + + public const float MIPMAP_BIAS = -0.2f; + public const float MIPMAP_ALPHA_CLIP_HAIR = 0.6f; + public const float MIPMAP_ALPHA_CLIP_HAIR_BAKED = 0.8f; + + public const int FLAG_SRGB = 1; + public const int FLAG_NORMAL = 2; + public const int FLAG_FOR_BAKE = 4; + public const int FLAG_ALPHA_CLIP = 8; + public const int FLAG_HAIR = 16; + + public Importer(CharacterInfo info) + { + ImporterWindow.LogReport("Initializing character import."); + + // fetch all the asset details for this character fbx object. + characterInfo = info; + fbx = info.fbx; + id = fbx.GetInstanceID(); + fbxPath = info.path; + importer = (ModelImporter)AssetImporter.GetAtPath(fbxPath); + characterName = info.name; + fbxFolder = info.folder; + + // construct the texture folder list for the character. + fbmFolder = Path.Combine(fbxFolder, characterName + ".fbm"); + texFolder = Path.Combine(fbxFolder, "textures", characterName); + textureFolders = new List() { fbmFolder, texFolder }; + + ImporterWindow.LogReport("Using texture folders:"); + ImporterWindow.LogReport(" " + fbmFolder); + ImporterWindow.LogReport(" " + texFolder); + + // find or create the materials folder for the character import. + string parentMaterialsFolder = Util.CreateFolder(fbxFolder, MATERIALS_FOLDER); + materialsFolder = Util.CreateFolder(parentMaterialsFolder, characterName); + ImporterWindow.LogReport("Using material folder: " + materialsFolder); + + // fetch the character json export data. + jsonData = info.JsonData; + jsonMeshData = jsonData.GetObjectAtPath(characterName + "/Object/" + characterName + "/Meshes"); + string jsonVersion = jsonData?.GetStringValue(characterName + "/Version"); + if (!string.IsNullOrEmpty(jsonVersion)) + ImporterWindow.LogReport("JSON version: " + jsonVersion); + + generation = info.Generation; + + // initialise the import path cache. + // this is used to re-import everything in one batch after it has all been setup. + // (calling a re-import on sub-materials or sub-objects will trigger a re-import of the entire fbx each time...) + importAssets = new List(); // { fbxPath }; + processedSourceMaterials = new List(); + } + + public void SetQuality(MaterialQuality qual) + { + quality = qual; + } + + public bool Import() + { + // firstly make sure the fbx is in: + // material creation mode: import via materialDescription + // location: use emmbedded materials + // extract any embedded textures + bool reimport = false; + if (importer.materialImportMode != ModelImporterMaterialImportMode.ImportViaMaterialDescription) + { + reimport = true; + importer.materialImportMode = ModelImporterMaterialImportMode.ImportViaMaterialDescription; + } + if (importer.materialLocation != ModelImporterMaterialLocation.InPrefab) + { + reimport = true; + importer.materialLocation = ModelImporterMaterialLocation.InPrefab; + } + + // only if we need to... + if (!AssetDatabase.IsValidFolder(fbmFolder)) + { + ImporterWindow.LogReport("Extracting embedded textures to: " + fbmFolder); + Util.CreateFolder(fbxPath, characterName + ".fbm"); + importer.ExtractTextures(fbmFolder); + } + + // clean up missing material remaps: + Dictionary remaps = importer.GetExternalObjectMap(); + List remapsToCleanUp = new List(); + foreach (KeyValuePair pair in remaps) + { + if (pair.Value == null) + { + remapsToCleanUp.Add(pair.Key); + reimport = true; + } + } + foreach (AssetImporter.SourceAssetIdentifier key in remapsToCleanUp) importer.RemoveRemap(key); + + // if nescessary write changes and reimport so that the fbx is populated with mappable material names: + if (reimport) + { + ImporterWindow.LogReport("Resetting import settings for correct material generation and reimporting."); + AssetDatabase.WriteImportSettingsIfDirty(fbxPath); + AssetDatabase.ImportAsset(fbxPath, ImportAssetOptions.ForceUpdate); + } + + // before we do anything else, if we are connecting default materials we need to bake a few maps first... + if (quality == MaterialQuality.Default) + { + CacheBakedMaps(); + } + + ProcessObjectTree(fbx); + + ImporterWindow.LogReport("Writing changes to asset database."); + + // set humanoid animation type + RL.HumanoidImportSettings(fbx, importer, characterName, generation, jsonData); + + // save all the changes and refresh the asset database. + AssetDatabase.WriteImportSettingsIfDirty(fbxPath); + importAssets.Add(fbxPath); + AssetDatabase.SaveAssets(); + AssetDatabase.Refresh(); + + // create prefab + RL.CreatePrefabFromFbx(characterInfo); + + ImporterWindow.LogReport("Done!"); + + Selection.activeObject = fbx; + + //System.Media.SystemSounds.Asterisk.Play(); + + return true; + } + + void ProcessObjectTree(GameObject obj) + { + int childCount = obj.transform.childCount; + for (int i = 0; i < childCount; i++) + { + GameObject child = obj.transform.GetChild(i).gameObject; + + if (child.GetComponent() != null) + { + ProcessObject(child); + } + else if (child.name.iContains("_LOD0")) + { + ProcessObjectTree(child); + } + } + } + + private void ProcessObject(GameObject obj) + { + Renderer renderer = obj.GetComponent(); + + if (renderer) + { + ImporterWindow.LogReport("Processing sub-object: " + obj.name); + + foreach (Material sharedMat in renderer.sharedMaterials) + { + // in case any of the materials have been renamed after a previous import, get the source name. + string sourceName = Util.GetSourceMaterialName(fbxPath, sharedMat); + + // if the material has already been processed, it is already in the remap list and should be connected automatically. + if (!processedSourceMaterials.Contains(sourceName)) + { + // fetch the json parent for this material. + // the json data for the material contains custom shader names, parameters and texture paths. + QuickJSON matJson = jsonMeshData.GetObjectAtPath(obj.name + "/Materials/" + sourceName); + + // determine the material type, this dictates the shader and template material. + MaterialType materialType = GetMaterialType(obj, sharedMat, sourceName, matJson); + + ImporterWindow.LogReport(" Material name: " + sourceName + ", type:" + materialType.ToString()); + + // re-use or create the material. + Material mat = CreateRemapMaterial(materialType, sharedMat, sourceName); + + // connect the textures. + if (mat) ProcessTextures(obj, sourceName, sharedMat, mat, materialType, matJson); + + processedSourceMaterials.Add(sourceName); + } + else + { + ImporterWindow.LogReport(" Material name: " + sourceName + " already processed."); + } + } + } + } + + private MaterialType GetMaterialType(GameObject obj, Material mat, string sourceName, QuickJSON matJson) + { + if (matJson != null) + { + bool hasOpacity = false; + if (!string.IsNullOrEmpty(matJson?.GetStringValue("Textures/Opacity/Texture Path"))) + { + hasOpacity = true; + } + + if (sourceName.StartsWith("Std_Eye_L", System.StringComparison.InvariantCultureIgnoreCase) || + sourceName.StartsWith("Std_Eye_R", System.StringComparison.InvariantCultureIgnoreCase)) + { + return MaterialType.Eye; + } + + if (hasOpacity) + { + if (sourceName.StartsWith("Std_Eyelash", System.StringComparison.InvariantCultureIgnoreCase)) + return MaterialType.Eyelash; + if (sourceName.StartsWith("Ga_Eyelash", System.StringComparison.InvariantCultureIgnoreCase)) + return MaterialType.Eyelash; + if (sourceName.ToLowerInvariant().Contains("_base_") || sourceName.ToLowerInvariant().Contains("scalp_")) + return MaterialType.Scalp; + } + + string customShader = matJson?.GetStringValue("Custom Shader/Shader Name"); + switch (customShader) + { + case "RLEyeOcclusion": return MaterialType.EyeOcclusion; + case "RLEyeTearline": return MaterialType.Tearline; + case "RLHair": return MaterialType.Hair; + case "RLSkin": return MaterialType.Skin; + case "RLHead": return MaterialType.Head; + case "RLTongue": return MaterialType.Tongue; + case "RLTeethGum": return MaterialType.Teeth; + case "RLEye": return MaterialType.Cornea; + default: + if (string.IsNullOrEmpty(matJson?.GetStringValue("Textures/Opacity/Texture Path"))) + return MaterialType.DefaultOpaque; + else + return MaterialType.DefaultAlpha; + } + } + else + { + // if there is no JSON, try to determine the material types from the names. + + if (sourceName.StartsWith("Std_Eye_L", System.StringComparison.InvariantCultureIgnoreCase) || + sourceName.StartsWith("Std_Eye_R", System.StringComparison.InvariantCultureIgnoreCase)) + return MaterialType.Eye; + + if (sourceName.StartsWith("Std_Cornea_L", System.StringComparison.InvariantCultureIgnoreCase) || + sourceName.StartsWith("Std_Cornea_R", System.StringComparison.InvariantCultureIgnoreCase)) + return MaterialType.Cornea; + + if (sourceName.StartsWith("Std_Eye_Occlusion_", System.StringComparison.InvariantCultureIgnoreCase)) + return MaterialType.EyeOcclusion; + + if (sourceName.StartsWith("Std_Tearline_", System.StringComparison.InvariantCultureIgnoreCase)) + return MaterialType.Tearline; + + if (sourceName.StartsWith("Std_Upper_Teeth", System.StringComparison.InvariantCultureIgnoreCase) || + sourceName.StartsWith("Std_Lower_Teeth", System.StringComparison.InvariantCultureIgnoreCase)) + return MaterialType.Teeth; + + if (sourceName.StartsWith("Std_Tongue", System.StringComparison.InvariantCultureIgnoreCase)) + return MaterialType.Tongue; + + if (sourceName.StartsWith("Std_Skin_Head", System.StringComparison.InvariantCultureIgnoreCase)) + return MaterialType.Head; + + if (sourceName.StartsWith("Std_Skin_", System.StringComparison.InvariantCultureIgnoreCase)) + return MaterialType.Skin; + + if (sourceName.StartsWith("Std_Nails", System.StringComparison.InvariantCultureIgnoreCase)) + return MaterialType.Skin; + + if (sourceName.StartsWith("Std_Eyelash", System.StringComparison.InvariantCultureIgnoreCase)) + return MaterialType.Eyelash; + + // Detecting the hair is harder to do... + + return MaterialType.DefaultOpaque; + } + } + + private Material CreateRemapMaterial(MaterialType materialType, Material sharedMaterial, string sourceName) + { + // get the template material. + Material templateMaterial = Pipeline.GetTemplateMaterial(materialType, quality, characterInfo); + + // get the appropriate shader to use + Shader shader; + if (templateMaterial && templateMaterial.shader != null) + shader = templateMaterial.shader; + else + shader = Pipeline.GetDefaultShader(); + + // check that shader exists. + if (!shader) + { + Debug.LogError("No shader found for material: " + sourceName); + return null; + } + + Material remapMaterial = sharedMaterial; + + // if the material is missing or it is embedded in the fbx, create a new unique material: + if (!remapMaterial || AssetDatabase.GetAssetPath(remapMaterial) == fbxPath) + { + // create the remapped material and save it as an asset. + string matPath = AssetDatabase.GenerateUniqueAssetPath( + Path.Combine(materialsFolder, sourceName + ".mat") + ); + + remapMaterial = new Material(shader); + + // save the material to the asset database. + AssetDatabase.CreateAsset(remapMaterial, matPath); + + ImporterWindow.LogReport(" Created new material: " + remapMaterial.name); + + // add the new remapped material to the importer remaps. + importer.AddRemap(new AssetImporter.SourceAssetIdentifier(typeof(Material), sourceName), remapMaterial); + } + + // copy the template material properties to the remapped material. + if (templateMaterial) + { + ImporterWindow.LogReport(" Using template material: " + templateMaterial.name); + //Debug.Log("Copying from Material template: " + templateMaterial.name); + if (templateMaterial.shader && templateMaterial.shader != remapMaterial.shader) + remapMaterial.shader = templateMaterial.shader; + remapMaterial.CopyPropertiesFromMaterial(templateMaterial); + } + else + { + // if the material shader doesn't match, update the shader. + if (remapMaterial.shader != shader) + remapMaterial.shader = shader; + } + + // add the path of the remapped material for later re-import. + string remapPath = AssetDatabase.GetAssetPath(remapMaterial); + if (remapPath == fbxPath) Debug.LogError("remapPath: " + remapPath + " is fbxPath (shouldn't happen)!"); + if (remapPath != fbxPath && AssetDatabase.WriteImportSettingsIfDirty(remapPath)) + importAssets.Add(AssetDatabase.GetAssetPath(remapMaterial)); + + return remapMaterial; + } + + private void ProcessTextures(GameObject obj, string sourceName, Material sharedMat, Material mat, + MaterialType materialType, QuickJSON matJson) + { + string shaderName = mat.shader.name; + + if (shaderName.iEndsWith(Pipeline.SHADER_DEFAULT)) + { + ConnectDefaultMaterial(obj, sourceName, sharedMat, mat, materialType, matJson); + } + + if (shaderName.iEndsWith(Pipeline.SHADER_DEFAULT_HAIR)) + { + ConnectDefaultHairMaterial(obj, sourceName, sharedMat, mat, materialType, matJson); + } + + else if (shaderName.EndsWith(Pipeline.SHADER_HQ_SKIN) || + shaderName.EndsWith(Pipeline.SHADER_HQ_HEAD)) + { + ConnectHQSkinMaterial(obj, sourceName, sharedMat, mat, materialType, matJson); + } + + else if (shaderName.EndsWith(Pipeline.SHADER_HQ_TEETH)) + { + ConnectHQTeethMaterial(obj, sourceName, sharedMat, mat, materialType, matJson); + } + + else if (shaderName.EndsWith(Pipeline.SHADER_HQ_TONGUE)) + { + ConnectHQTongueMaterial(obj, sourceName, sharedMat, mat, materialType, matJson); + } + + else if (shaderName.EndsWith(Pipeline.SHADER_HQ_EYE) || + shaderName.EndsWith(Pipeline.SHADER_HQ_CORNEA)) + { + ConnectHQEyeMaterial(obj, sourceName, sharedMat, mat, materialType, matJson); + } + + else if (shaderName.EndsWith(Pipeline.SHADER_HQ_HAIR)) + { + ConnectHQHairMaterial(obj, sourceName, sharedMat, mat, materialType, matJson); + } + + else if (shaderName.EndsWith(Pipeline.SHADER_HQ_EYE_OCCLUSION)) + { + ConnectHQEyeOcclusionMaterial(obj, sourceName, sharedMat, mat, materialType, matJson); + } + + else if (shaderName.EndsWith(Pipeline.SHADER_HQ_TEARLINE)) + { + ConnectHQTearlineMaterial(obj, sourceName, sharedMat, mat, materialType, matJson); + } + + HDShaderUtils.ResetMaterialKeywords(mat); + } + + private void ConnectDefaultMaterial(GameObject obj, string sourceName, Material sharedMat, Material mat, + MaterialType materialType, QuickJSON matJson) + { + string customShader = matJson?.GetStringValue("Custom Shader/Shader Name"); + + // these default materials should *not* attach any textures as I don't use them for these: + if (customShader == "RLEyeTearline" || customShader == "RLEyeOcclusion") return; + + // HDRP + ConnectTextureTo(sourceName, mat, "_BaseColorMap", "Diffuse", + matJson, "Textures/Base Color", + FLAG_SRGB); + + ConnectTextureTo(sourceName, mat, "_MaskMap", "HDRP", + matJson, "Textures/HDRP"); + + ConnectTextureTo(sourceName, mat, "_NormalMap", "Normal", + matJson, "Textures/Normal", + FLAG_NORMAL); + + // URP/3D + ConnectTextureTo(sourceName, mat, "_BaseMap", "Diffuse", + matJson, "Textures/Base Color", + FLAG_SRGB); + + ConnectTextureTo(sourceName, mat, "_MetallicGlossMap", "MetallicAlpha", + matJson, "Textures/MetallicAlpha"); + + ConnectTextureTo(sourceName, mat, "_OcclusionMap", "ao", + matJson, "Textures/AO"); + + ConnectTextureTo(sourceName, mat, "_BumpMap", "Normal", + matJson, "Textures/Normal", + FLAG_NORMAL); + + // All + if (matJson != null) + { + mat.SetColor("_BaseColor", matJson.GetColorValue("Diffuse Color")); + } + + //if (materialType == MaterialType.Scalp) + //{ + // mat.SetColor("_BaseColor", matJson.GetColorValue("Diffuse Color").ScaleRGB(0.2f)); + //} + + // connecting default HDRP materials: + if (Pipeline.GetRenderPipeline() == RenderPipeline.HDRP && !string.IsNullOrEmpty(customShader)) + { + // for skin and head materials: + if (customShader == "RLHead" || customShader == "RLSkin") + { + ConnectTextureTo(sourceName, mat, "_SubsurfaceMaskMap", "SSSMap", + matJson, "Custom Shader/Image/SSS Map"); + + // use the baked thickness and details maps... + mat.SetTexture("_ThicknessMap", GetCachedBakedMap(sharedMat, "_ThicknessMap")); + mat.SetTexture("_DetailMap", GetCachedBakedMap(sharedMat, "_DetailMap")); + + float microNormalTiling = 20f; + float microNormalStrength = 0.5f; + if (matJson != null) + { + microNormalTiling = matJson.GetFloatValue("Custom Shader/Variable/MicroNormal Tiling"); + microNormalStrength = matJson.GetFloatValue("Custom Shader/Variable/MicroNormal Strength"); + } + mat.SetTextureScale("_DetailMap", new Vector2(microNormalTiling, microNormalTiling)); + mat.SetFloat("_DetailNormalScale", microNormalStrength); + mat.SetFloat("_Thickness", 0.4f); + mat.SetRemapRange("_ThicknessRemap", 0.4f, 1f); + } + } + } + + private void ConnectDefaultHairMaterial(GameObject obj, string sourceName, Material sharedMat, + Material mat, MaterialType materialType, QuickJSON matJson) + { + bool isHair = sourceName.iContains("hair"); + + ConnectTextureTo(sourceName, mat, "_BaseColorMap", "Diffuse", + matJson, "Textures/Base Color", + FLAG_SRGB + (isHair ? FLAG_HAIR : FLAG_ALPHA_CLIP)); + + ConnectTextureTo(sourceName, mat, "_NormalMap", "Normal", + matJson, "Textures/Normal", + FLAG_NORMAL); + + ConnectTextureTo(sourceName, mat, "_MaskMap", "ao", + matJson, "Textures/AO"); + + if (matJson != null) + { + float diffuseStrength = matJson.GetFloatValue("Custom Shader/Variable/Diffuse Strength"); + mat.SetColor("_BaseColor", matJson.GetColorValue("Diffuse Color").ScaleRGB(diffuseStrength)); + } + } + + private void ConnectHQSkinMaterial(GameObject obj, string sourceName, Material sharedMat, Material mat, + MaterialType materialType, QuickJSON matJson) + { + ConnectTextureTo(sourceName, mat, "_DiffuseMap", "Diffuse", + matJson, "Textures/Base Color", + FLAG_SRGB); + + ConnectTextureTo(sourceName, mat, "_NormalMap", "Normal", + matJson, "Textures/Normal", + FLAG_NORMAL); + + ConnectTextureTo(sourceName, mat, "_MetallicAlphaMap", "MetallicAlpha", + matJson, "Textures/MetallicAlpha"); + + ConnectTextureTo(sourceName, mat, "_AOMap", "ao", + matJson, "Textures/AO"); + + ConnectTextureTo(sourceName, mat, "_MaskMap", "HDRP", + matJson, "Textures/HDRP"); + + ConnectTextureTo(sourceName, mat, "_SSSMap", "SSSMap", + matJson, "Custom Shader/Image/SSS Map"); + + ConnectTextureTo(sourceName, mat, "_ThicknessMap", "TransMap", + matJson, "Custom Shader/Image/Transmission Map"); + + ConnectTextureTo(sourceName, mat, "_MicroNormalMap", "MicroN", + matJson, "Custom Shader/Image/MicroNormal"); + + ConnectTextureTo(sourceName, mat, "_MicroNormalMaskMap", "MicroNMask", + matJson, "Custom Shader/Image/MicroNormalMask"); + + if (materialType == MaterialType.Head) + { + ConnectTextureTo(sourceName, mat, "_ColorBlendMap", "BCBMap", + matJson, "Custom Shader/Image/BaseColor Blend2"); + + ConnectTextureTo(sourceName, mat, "_MNAOMap", "MNAOMask", + matJson, "Custom Shader/Image/Mouth Cavity Mask and AO"); + + ConnectTextureTo(sourceName, mat, "_RGBAMask", "NMUILMask", + matJson, "Custom Shader/Image/Nose Mouth UpperInnerLid Mask"); + + ConnectTextureTo(sourceName, mat, "_CFULCMask", "CFULCMask", + matJson, "Custom Shader/Image/Cheek Fore UpperLip Chin Mask"); + + ConnectTextureTo(sourceName, mat, "_EarNeckMask", "ENMask", + matJson, "Custom Shader/Image/Ear Neck Mask"); + + ConnectTextureTo(sourceName, mat, "_NormalBlendMap", "NBMap", + matJson, "Custom Shader/Image/NormalMap Blend", + FLAG_NORMAL); + + mat.EnableKeyword("BOOLEAN_IS_HEAD_ON"); + } + else + { + ConnectTextureTo(sourceName, mat, "_RGBAMask", "RGBAMask", + matJson, "Custom Shader/Image/RGBA Area Mask"); + } + + if (matJson != null) + { + mat.SetFloat("_AOStrength", Mathf.Clamp01(matJson.GetFloatValue("Textures/AO/Strength") / 100f)); + mat.SetFloat("_MicroNormalTiling", matJson.GetFloatValue("Custom Shader/Variable/MicroNormal Tiling")); + mat.SetFloat("_MicroNormalStrength", matJson.GetFloatValue("Custom Shader/Variable/MicroNormal Strength")); + float specular = matJson.GetFloatValue("Custom Shader/Variable/_Specular"); + + // as there is no specular mask channel, I am simulating the specular mask by clamping the smoothness + // between 0 and a root curve function of the specular value: i.e. smoothnessMax = pow(specular, P) + // this function must range from f(0) = 0 to f(1) = 1 and achieve 0.88 maximum smoothness at 0.5 specular + // (0.5 specular being the default specular value for base max smoothness, visually detected as ~0.88 smoothness) + // specular values from 0.5 to 1.0 will generate a max smoothness of 0.88 to 1.0. + // Thus: P = ln(0.88) / ln(0.5) + // This should approximate the specular mask for specular values > 0.2 + const float smoothnessStdMax = 0.88f; + const float specularMid = 0.5f; + float P = Mathf.Log(smoothnessStdMax) / Mathf.Log(specularMid); + float smoothnessMax = Mathf.Clamp01(Mathf.Pow(specular, P)); + + mat.SetFloat("_SmoothnessMin", 0f); + mat.SetFloat("_SmoothnessMax", smoothnessMax); + mat.SetFloat("_SmoothnessPower", 1f); + + mat.SetFloat("_SubsurfaceScale", matJson.GetFloatValue("Custom Shader/Variable/Unmasked Scatter Scale")); + mat.SetFloat("_ThicknessScale", Mathf.Clamp01(matJson.GetFloatValue("Subsurface Scatter/Radius") / 5f)); + mat.SetFloat("_MicroSmoothnessMod", -matJson.GetFloatValue("Custom Shader/Variable/Micro Roughness Scale")); + mat.SetFloat("_UnmaskedSmoothnessMod", -matJson.GetFloatValue("Custom Shader/Variable/Unmasked Roughness Scale")); + mat.SetFloat("_UnmaskedScatterScale", matJson.GetFloatValue("Custom Shader/Variable/Unmasked Scatter Scale")); + + if (materialType == MaterialType.Head) + { + mat.SetFloat("_ColorBlendStrength", matJson.GetFloatValue("Custom Shader/Variable/BaseColor Blend2 Strength")); + mat.SetFloat("_NormalBlendStrength", matJson.GetFloatValue("Custom Shader/Variable/NormalMap Blend Strength")); + mat.SetFloat("_MouthCavityAO", matJson.GetFloatValue("Custom Shader/Variable/Inner Mouth Ao")); + mat.SetFloat("_NostrilCavityAO", matJson.GetFloatValue("Custom Shader/Variable/Nostril Ao")); + mat.SetFloat("_LipsCavityAO", matJson.GetFloatValue("Custom Shader/Variable/Lips Gap Ao")); + + mat.SetFloat("_RSmoothnessMod", -matJson.GetFloatValue("Custom Shader/Variable/Nose Roughness Scale")); + mat.SetFloat("_GSmoothnessMod", -matJson.GetFloatValue("Custom Shader/Variable/Mouth Roughness Scale")); + mat.SetFloat("_BSmoothnessMod", -matJson.GetFloatValue("Custom Shader/Variable/UpperLid Roughness Scale")); + mat.SetFloat("_ASmoothnessMod", -matJson.GetFloatValue("Custom Shader/Variable/InnerLid Roughness Scale")); + mat.SetFloat("_EarSmoothnessMod", -matJson.GetFloatValue("Custom Shader/Variable/Ear Roughness Scale")); + mat.SetFloat("_NeckSmoothnessMod", -matJson.GetFloatValue("Custom Shader/Variable/Neck Roughness Scale")); + mat.SetFloat("_CheekSmoothnessMod", -matJson.GetFloatValue("Custom Shader/Variable/Cheek Roughness Scale")); + mat.SetFloat("_ForeheadSmoothnessMod", -matJson.GetFloatValue("Custom Shader/Variable/Forehead Roughness Scale")); + mat.SetFloat("_UpperLipSmoothnessMod", -matJson.GetFloatValue("Custom Shader/Variable/UpperLip Roughness Scale")); + mat.SetFloat("_ChinSmoothnessMod", -matJson.GetFloatValue("Custom Shader/Variable/Chin Roughness Scale")); + + mat.SetFloat("_RScatterScale", matJson.GetFloatValue("Custom Shader/Variable/Nose Scatter Scale")); + mat.SetFloat("_GScatterScale", matJson.GetFloatValue("Custom Shader/Variable/Mouth Scatter Scale")); + mat.SetFloat("_BScatterScale", matJson.GetFloatValue("Custom Shader/Variable/UpperLid Scatter Scale")); + mat.SetFloat("_AScatterScale", matJson.GetFloatValue("Custom Shader/Variable/InnerLid Scatter Scale")); + mat.SetFloat("_EarScatterScale", matJson.GetFloatValue("Custom Shader/Variable/Ear Scatter Scale")); + mat.SetFloat("_NeckScatterScale", matJson.GetFloatValue("Custom Shader/Variable/Neck Scatter Scale")); + mat.SetFloat("_CheekScatterScale", matJson.GetFloatValue("Custom Shader/Variable/Cheek Scatter Scale")); + mat.SetFloat("_ForeheadScatterScale", matJson.GetFloatValue("Custom Shader/Variable/Forehead Scatter Scale")); + mat.SetFloat("_UpperLipScatterScale", matJson.GetFloatValue("Custom Shader/Variable/UpperLip Scatter Scale")); + mat.SetFloat("_ChinScatterScale", matJson.GetFloatValue("Custom Shader/Variable/Chin Scatter Scale")); + } + else + { + mat.SetFloat("_RSmoothnessMod", -matJson.GetFloatValue("Custom Shader/Variable/R Channel Roughness Scale")); + mat.SetFloat("_GSmoothnessMod", -matJson.GetFloatValue("Custom Shader/Variable/G Channel Roughness Scale")); + mat.SetFloat("_BSmoothnessMod", -matJson.GetFloatValue("Custom Shader/Variable/B Channel Roughness Scale")); + mat.SetFloat("_ASmoothnessMod", -matJson.GetFloatValue("Custom Shader/Variable/A Channel Roughness Scale")); + + mat.SetFloat("_RScatterScale", matJson.GetFloatValue("Custom Shader/Variable/R Channel Scatter Scale")); + mat.SetFloat("_GScatterScale", matJson.GetFloatValue("Custom Shader/Variable/G Channel Scatter Scale")); + mat.SetFloat("_BScatterScale", matJson.GetFloatValue("Custom Shader/Variable/B Channel Scatter Scale")); + mat.SetFloat("_AScatterScale", matJson.GetFloatValue("Custom Shader/Variable/A Channel Scatter Scale")); + } + } + } + + private void ConnectHQTeethMaterial(GameObject obj, string sourceName, Material sharedMat, Material mat, + MaterialType materialType, QuickJSON matJson) + { + ConnectTextureTo(sourceName, mat, "_DiffuseMap", "Diffuse", + matJson, "Textures/Base Color", + FLAG_SRGB); + + ConnectTextureTo(sourceName, mat, "_NormalMap", "Normal", + matJson, "Textures/Normal", + FLAG_NORMAL); + + ConnectTextureTo(sourceName, mat, "_MaskMap", "HDRP", + matJson, "Textures/HDRP"); + + ConnectTextureTo(sourceName, mat, "_MicroNormalMap", "MicroN", + matJson, "Custom Shader/Image/MicroNormal"); + + ConnectTextureTo(sourceName, mat, "_GumsMaskMap", "GumsMask", + matJson, "Custom Shader/Image/Gums Mask"); + + ConnectTextureTo(sourceName, mat, "_GradientAOMap", "GradAO", + matJson, "Custom Shader/Image/Gradient AO"); + + if (matJson != null) + { + mat.SetFloat("_IsUpperTeeth", matJson.GetFloatValue("Custom Shader/Variable/Is Upper Teeth")); + mat.SetFloat("_AOStrength", Mathf.Clamp01(matJson.GetFloatValue("Textures/AO/Strength") / 100f)); + mat.SetFloat("_MicroNormalTiling", matJson.GetFloatValue("Custom Shader/Variable/Teeth MicroNormal Tiling")); + mat.SetFloat("_MicroNormalStrength", matJson.GetFloatValue("Custom Shader/Variable/Teeth MicroNormal Strength")); + float specular = matJson.GetFloatValue("Custom Shader/Variable/Front Specular"); + float specularT = Mathf.InverseLerp(0f, 0.5f, specular); + float roughness = 1f - matJson.GetFloatValue("Custom Shader/Variable/Front Roughness"); + mat.SetFloat("_SmoothnessMin", roughness * 0.9f); + mat.SetFloat("_SmoothnessMax", Mathf.Lerp(0.9f, 1f, specularT)); + mat.SetFloat("_SmoothnessPower", 0.5f); + mat.SetFloat("_TeethSSS", matJson.GetFloatValue("Custom Shader/Variable/Teeth Scatter")); + mat.SetFloat("_GumsSSS", matJson.GetFloatValue("Custom Shader/Variable/Gums Scatter")); + mat.SetFloat("_TeethThickness", Mathf.Clamp01(matJson.GetFloatValue("Subsurface Scatter/Radius") / 5f)); + mat.SetFloat("_GumsThickness", Mathf.Clamp01(matJson.GetFloatValue("Subsurface Scatter/Radius") / 5f)); + mat.SetFloat("_FrontAO", matJson.GetFloatValue("Custom Shader/Variable/Front AO")); + mat.SetFloat("_RearAO", matJson.GetFloatValue("Custom Shader/Variable/Back AO")); + mat.SetFloat("_GumsSaturation", Mathf.Clamp01(1f - matJson.GetFloatValue("Custom Shader/Variable/Gums Desaturation"))); + mat.SetFloat("_GumsBrightness", matJson.GetFloatValue("Custom Shader/Variable/Gums Brightness")); + mat.SetFloat("_TeethSaturation", Mathf.Clamp01(1f - matJson.GetFloatValue("Custom Shader/Variable/Teeth Desaturation"))); + mat.SetFloat("_TeethBrightness", matJson.GetFloatValue("Custom Shader/Variable/Teeth Brightness")); + } + } + + private void ConnectHQTongueMaterial(GameObject obj, string sourceName, Material sharedMat, Material mat, + MaterialType materialType, QuickJSON matJson) + { + ConnectTextureTo(sourceName, mat, "_DiffuseMap", "Diffuse", + matJson, "Textures/Base Color", + FLAG_SRGB); + + ConnectTextureTo(sourceName, mat, "_NormalMap", "Normal", + matJson, "Textures/Normal", + FLAG_NORMAL); + + ConnectTextureTo(sourceName, mat, "_MaskMap", "HDRP", + matJson, "Textures/HDRP"); + + ConnectTextureTo(sourceName, mat, "_MicroNormalMap", "MicroN", + matJson, "Custom Shader/Image/MicroNormal"); + + ConnectTextureTo(sourceName, mat, "_GradientAOMap", "GradAO", + matJson, "Custom Shader/Image/Gradient AO"); + + if (matJson != null) + { + mat.SetFloat("_AOStrength", Mathf.Clamp01(matJson.GetFloatValue("Textures/AO/Strength") / 100f)); + mat.SetFloat("_MicroNormalTiling", matJson.GetFloatValue("Custom Shader/Variable/MicroNormal Tiling")); + mat.SetFloat("_MicroNormalStrength", matJson.GetFloatValue("Custom Shader/Variable/MicroNormal Strength")); + float specular = matJson.GetFloatValue("Custom Shader/Variable/Front Specular"); + float specularT = Mathf.InverseLerp(0f, 0.5f, specular); + float roughness = 1f - matJson.GetFloatValue("Custom Shader/Variable/Front Roughness"); + mat.SetFloat("_SmoothnessMin", roughness * 0.9f); + mat.SetFloat("_SmoothnessMax", Mathf.Lerp(0.9f, 1f, specularT)); + mat.SetFloat("_SmoothnessPower", 0.5f); + mat.SetFloat("_TongueSSS", matJson.GetFloatValue("Custom Shader/Variable/_Scatter")); + mat.SetFloat("_TongueThickness", Mathf.Clamp01(matJson.GetFloatValue("Subsurface Scatter/Radius") / 5f)); + mat.SetFloat("_FrontAO", matJson.GetFloatValue("Custom Shader/Variable/Front AO")); + mat.SetFloat("_RearAO", matJson.GetFloatValue("Custom Shader/Variable/Back AO")); + mat.SetFloat("_TongueSaturation", Mathf.Clamp01(1f - matJson.GetFloatValue("Custom Shader/Variable/_Desaturation"))); + mat.SetFloat("_TongueBrightness", matJson.GetFloatValue("Custom Shader/Variable/_Brightness")); + } + } + + private void ConnectHQEyeMaterial(GameObject obj, string sourceName, Material sharedMat, Material mat, + MaterialType materialType, QuickJSON matJson) + { + bool isCornea = mat.GetFloat("BOOLEAN_ISCORNEA") > 0f; + bool isLeftEye = sourceName.iContains("Eye_L"); + string customShader = matJson?.GetStringValue("Custom Shader/Shader Name"); + + // if there is no custom shader, then this is the PBR eye material, + // we need to find the cornea material json object with the RLEye shader data: + if (string.IsNullOrEmpty(customShader)) + { + QuickJSON parentJson = jsonData.FindParentOf(matJson); + if (sourceName.iContains("Eye_L")) + matJson = parentJson.FindObjectWithKey("Cornea_L"); + else if (sourceName.iContains("Eye_R")) + matJson = parentJson.FindObjectWithKey("Cornea_R"); + } + + if (matJson != null) isLeftEye = matJson.GetFloatValue("Custom Shader/Variable/Is Left Eye") > 0f ? true : false; + + if (isCornea) + { + ConnectTextureTo(sourceName, mat, "_ScleraDiffuseMap", "Sclera", + matJson, "Custom Shader/Image/Sclera", + FLAG_SRGB); + + ConnectTextureTo(sourceName, mat, "_MaskMap", "HDRP", + matJson, "Textures/HDRP"); + + ConnectTextureTo(sourceName, mat, "_ColorBlendMap", "BCBMap", + matJson, "Custom Shader/Image/EyeBlendMap2"); + + ConnectTextureTo(sourceName, mat, "_ScleraNormalMap", "MicroN", + matJson, "Custom Shader/Image/Sclera Normal", + FLAG_NORMAL); + } + else + { + ConnectTextureTo(sourceName, mat, "_CorneaDiffuseMap", "Diffuse", + matJson, "Textures/Base Color", + FLAG_SRGB); + + ConnectTextureTo(sourceName, mat, "_MaskMap", "HDRP", + matJson, "Textures/HDRP"); + + ConnectTextureTo(sourceName, mat, "_ColorBlendMap", "BCBMap", + matJson, "Custom Shader/Image/EyeBlendMap2"); + } + + if (matJson != null) + { + // both the cornea and the eye materials need the same settings: + mat.SetFloat("_AOStrength", Mathf.Clamp01(matJson.GetFloatValue("Textures/AO/Strength") / 100f)); + mat.SetFloat("_ColorBlendStrength", matJson.GetFloatValue("Custom Shader/Variable/BlendMap2 Strength")); + mat.SetFloat("_ShadowRadius", matJson.GetFloatValue("Custom Shader/Variable/Shadow Radius")); + mat.SetFloat("_ShadowHardness", matJson.GetFloatValue("Custom Shader/Variable/Shadow Hardness")); + float specularScale = matJson.GetFloatValue("Custom Shader/Variable/Specular Scale"); + mat.SetColor("_CornerShadowColor", matJson.GetColorValue("Custom Shader/Variable/Eye Corner Darkness Color")); + mat.SetFloat("_IrisDepth", 0.004f * matJson.GetFloatValue("Custom Shader/Variable/Iris Depth Scale")); + mat.SetFloat("_IrisSmoothness", 0f); // 1f - matJson.GetFloatValue("Custom Shader/Variable/_Iris Roughness")); + mat.SetFloat("_IrisBrightness", matJson.GetFloatValue("Custom Shader/Variable/Iris Color Brightness")); + mat.SetFloat("_PupilScale", 0.8f * matJson.GetFloatValue("Custom Shader/Variable/Pupil Scale")); + mat.SetFloat("_IOR", matJson.GetFloatValue("Custom Shader/Variable/_IoR")); + float irisScale = matJson.GetFloatValue("Custom Shader/Variable/Iris UV Radius") / 0.16f; + mat.SetFloat("_IrisScale", irisScale); + mat.SetFloat("_IrisRadius", 0.15f * irisScale); + mat.SetFloat("_LimbusWidth", matJson.GetFloatValue("Custom Shader/Variable/Limbus UV Width Color")); + float limbusDarkScale = matJson.GetFloatValue("Custom Shader/Variable/Limbus Dark Scale"); + float limbusDarkT = Mathf.InverseLerp(0f, 10f, limbusDarkScale); + mat.SetFloat("_LimbusDarkRadius", Mathf.Lerp(0.145f, 0.075f, limbusDarkT)); + //mat.SetFloat("_LimbusDarkWidth", 0.035f); + mat.SetFloat("_ScleraBrightness", 0.9f * matJson.GetFloatValue("Custom Shader/Variable/ScleraBrightness")); + mat.SetFloat("_ScleraSmoothness", 1f - matJson.GetFloatValue("Custom Shader/Variable/Sclera Roughness")); + mat.SetFloat("_ScleraScale", matJson.GetFloatValue("Custom Shader/Variable/Sclera UV Radius")); + mat.SetFloat("_ScleraNormalStrength", 1f - matJson.GetFloatValue("Custom Shader/Variable/Sclera Flatten Normal")); + mat.SetFloat("_ScleraNormalTiling", Mathf.Clamp(1f / matJson.GetFloatValue("Custom Shader/Variable/Sclera Normal UV Scale"), 0.1f, 10f)); + mat.SetFloat("_IsLeftEye", isLeftEye ? 1f : 0f); + } + } + + private void ConnectHQHairMaterial(GameObject obj, string sourceName, Material sharedMat, Material mat, + MaterialType materialType, QuickJSON matJson) + { + bool isHair = sourceName.iContains("Hair"); + + ConnectTextureTo(sourceName, mat, "_DiffuseMap", "Diffuse", + matJson, "Textures/Base Color", + FLAG_SRGB + (isHair ? FLAG_HAIR : FLAG_ALPHA_CLIP)); + + ConnectTextureTo(sourceName, mat, "_MaskMap", "HDRP", + matJson, "Textures/HDRP"); + + ConnectTextureTo(sourceName, mat, "_NormalMap", "Normal", + matJson, "Textures/Normal", + FLAG_NORMAL); + + ConnectTextureTo(sourceName, mat, "_BlendMap", "blend_multiply", + matJson, "Textures/Blend"); + + ConnectTextureTo(sourceName, mat, "_FlowMap", "Hair Flow Map", + matJson, "Custom Shader/Image/Hair Flow Map"); + + ConnectTextureTo(sourceName, mat, "_IDMap", "Hair ID Map", + matJson, "Custom Shader/Image/Hair ID Map"); + + ConnectTextureTo(sourceName, mat, "_RootMap", "Hair Root Map", + matJson, "Custom Shader/Image/Hair Root Map"); + + ConnectTextureTo(sourceName, mat, "_SpecularMap", "HSpecMap", + matJson, "Custom Shader/Image/Hair Specular Mask Map"); + + + if (isHair) + { + mat.SetFloat("_AlphaPower", 1.0f); + mat.SetFloat("_AlphaRemap", 0.5f); + mat.SetFloat("_DepthPrepass", 0.95f); + } + else + { + mat.SetFloat("_AlphaPower", 1.0f); + mat.SetFloat("_AlphaRemap", 0.8f); + mat.SetFloat("_DepthPrepass", 0.95f); + } + + if (matJson != null) + { + mat.SetFloat("_AOStrength", Mathf.Clamp01(matJson.GetFloatValue("Textures/AO/Strength") / 100f)); + mat.SetFloat("_AOOccludeAll", matJson.GetFloatValue("Custom Shader/Variable/AO Map Occlude All Lighting")); + mat.SetFloat("_BlendStrength", Mathf.Clamp01(matJson.GetFloatValue("Textures/Blend/Strength") / 100f)); + mat.SetColor("_VertexBaseColor", Util.LinearTosRGB(matJson.GetColorValue("Custom Shader/Variable/VertexGrayToColor"))); + // set the transmission colour to 1/4 between vertex base and white. + // mat.SetColor("_TransmissionColor", Color.Lerp(matJson.GetColorValue("Custom Shader/Variable/VertexGrayToColor"), Color.white, 0.25f)); + mat.SetFloat("_VertexColorStrength", 1f * matJson.GetFloatValue("Custom Shader/Variable/VertexColorStrength")); + mat.SetFloat("_BaseColorStrength", 1f * matJson.GetFloatValue("Custom Shader/Variable/BaseColorMapStrength")); + mat.SetFloat("_RimTransmissionIntensity", 0.2f * matJson.GetFloatValue("Custom Shader/Variable/Transmission Strength")); + + float specMapStrength = matJson.GetFloatValue("Custom Shader/Variable/Hair Specular Map Strength"); + mat.SetFloat("_DiffuseStrength", 1f * matJson.GetFloatValue("Custom Shader/Variable/Diffuse Strength")); + mat.SetFloat("_SmoothnessMax", 1f - matJson.GetFloatValue("Custom Shader/Variable/Hair Roughness Map Strength")); + // Unity does not have a specular-f0 channel so the specular map is being used to mask the + // specular multipliers in the hair shader instead. + mat.SetFloat("_SpecularMultiplier", specMapStrength * matJson.GetFloatValue("Custom Shader/Variable/Specular Strength")); + mat.SetFloat("_SecondarySpecularMultiplier", specMapStrength * 0.5f * matJson.GetFloatValue("Custom Shader/Variable/Secondary Specular Strength")); + + mat.SetColor("_RootColor", Util.LinearTosRGB(matJson.GetColorValue("Custom Shader/Variable/RootColor"))); + mat.SetColor("_EndColor", Util.LinearTosRGB(matJson.GetColorValue("Custom Shader/Variable/TipColor"))); + mat.SetFloat("_GlobalStrength", matJson.GetFloatValue("Custom Shader/Variable/UseRootTipColor")); + mat.SetFloat("_RootColorStrength", matJson.GetFloatValue("Custom Shader/Variable/RootColorStrength")); + mat.SetFloat("_EndColorStrength", matJson.GetFloatValue("Custom Shader/Variable/TipColorStrength")); + mat.SetFloat("_InvertRootMap", matJson.GetFloatValue("Custom Shader/Variable/InvertRootTip")); + if (matJson.GetFloatValue("Custom Shader/Variable/ActiveChangeHairColor") > 0f) + { + mat.EnableKeyword("BOOLEAN_ENABLECOLOR_ON"); + mat.SetFloat("BOOLEAN_ENABLECOLOR", 1f); + } + else + { + mat.DisableKeyword("BOOLEAN_ENABLECOLOR_ON"); + mat.SetFloat("BOOLEAN_ENABLECOLOR", 0f); + } + + mat.SetColor("_HighlightAColor", Util.LinearTosRGB(matJson.GetColorValue("Custom Shader/Variable/_1st Dye Color"))); + mat.SetFloat("_HighlightAStrength", matJson.GetFloatValue("Custom Shader/Variable/_1st Dye Strength")); + mat.SetVector("_HighlightADistribution", (1f / 255f) * matJson.GetVector3Value("Custom Shader/Variable/_1st Dye Distribution from Grayscale")); + mat.SetFloat("_HighlightAOverlapEnd", matJson.GetFloatValue("Custom Shader/Variable/Mask 1st Dye by RootMap")); + mat.SetFloat("_HighlightAOverlapInvert", matJson.GetFloatValue("Custom Shader/Variable/Invert 1st Dye RootMap Mask")); + + mat.SetColor("_HighlightBColor", Util.LinearTosRGB(matJson.GetColorValue("Custom Shader/Variable/_2nd Dye Color"))); + mat.SetFloat("_HighlightBStrength", matJson.GetFloatValue("Custom Shader/Variable/_2nd Dye Strength")); + mat.SetVector("_HighlightBDistribution", (1f / 255f) * matJson.GetVector3Value("Custom Shader/Variable/_2nd Dye Distribution from Grayscale")); + mat.SetFloat("_HighlightBOverlapEnd", matJson.GetFloatValue("Custom Shader/Variable/Mask 2nd Dye by RootMap")); + mat.SetFloat("_HighlightBOverlapInvert", matJson.GetFloatValue("Custom Shader/Variable/Invert 2nd Dye RootMap Mask")); + } + } + + private void ConnectHQEyeOcclusionMaterial(GameObject obj, string sourceName, Material sharedMat, Material mat, + MaterialType materialType, QuickJSON matJson) + { + if (matJson != null) + { + mat.SetFloat("_ExpandOut", 0.0001f * matJson.GetFloatValue("Custom Shader/Variable/Depth Offset")); + mat.SetFloat("_ExpandUpper", 0.005f * matJson.GetFloatValue("Custom Shader/Variable/Top Offset")); + mat.SetFloat("_ExpandLower", 0.005f * matJson.GetFloatValue("Custom Shader/Variable/Bottom Offset")); + mat.SetFloat("_ExpandInner", 0.0001f + 0.005f * matJson.GetFloatValue("Custom Shader/Variable/Inner Corner Offset")); + mat.SetFloat("_ExpandOuter", 0.005f * matJson.GetFloatValue("Custom Shader/Variable/Outer Corner Offset")); + mat.SetFloat("_TearDuctPosition", matJson.GetFloatValue("Custom Shader/Variable/Tear Duct Position")); + //mat.SetFloat("_TearDuctWidth", 0.05f); + mat.SetColor("_OcclusionColor", Color.Lerp(matJson.GetColorValue("Custom Shader/Variable/Shadow Color"), Color.black, 0.2f)); + + mat.SetFloat("_OcclusionStrength", 2f * matJson.GetFloatValue("Custom Shader/Variable/Shadow Strength")); + mat.SetFloat("_OcclusionStrength2", 2f * matJson.GetFloatValue("Custom Shader/Variable/Shadow2 Strength")); + //mat.SetFloat("_OcclusionPower", 2f); + + float top = matJson.GetFloatValue("Custom Shader/Variable/Shadow Top"); + float bottom = matJson.GetFloatValue("Custom Shader/Variable/Shadow Bottom"); + float inner = matJson.GetFloatValue("Custom Shader/Variable/Shadow Inner Corner"); + float outer = matJson.GetFloatValue("Custom Shader/Variable/Shadow Outer Corner"); + float top2 = matJson.GetFloatValue("Custom Shader/Variable/Shadow2 Top"); + + float topMax = Mathf.Lerp(top, 1f, matJson.GetFloatValue("Custom Shader/Variable/Shadow Top Range")); + float bottomMax = Mathf.Lerp(bottom, 1f, matJson.GetFloatValue("Custom Shader/Variable/Shadow Bottom Range")); + float innerMax = Mathf.Lerp(inner, 1f, matJson.GetFloatValue("Custom Shader/Variable/Shadow Inner Corner Range")); + float outerMax = Mathf.Lerp(outer, 1f, matJson.GetFloatValue("Custom Shader/Variable/Shadow Outer Corner Range")); + float top2Max = Mathf.Lerp(top2, 1f, matJson.GetFloatValue("Custom Shader/Variable/Shadow2 Top Range")); + mat.SetFloat("_TopMin", 0.8f * top); + mat.SetFloat("_TopMax", topMax); + mat.SetFloat("_TopCurve", matJson.GetFloatValue("Custom Shader/Variable/Shadow Top Arc")); + mat.SetFloat("_BottomMin", 0.8f * bottom); + mat.SetFloat("_BottomMax", bottomMax); + mat.SetFloat("_BottomCurve", matJson.GetFloatValue("Custom Shader/Variable/Shadow Bottom Arc")); + mat.SetFloat("_InnerMin", inner); + mat.SetFloat("_InnerMax", innerMax); + mat.SetFloat("_OuterMin", 0.8f * outer); + mat.SetFloat("_OuterMax", outerMax); + mat.SetFloat("_Top2Min", 0.8f * top2); + mat.SetFloat("_Top2Max", top2Max); + } + } + + private void ConnectHQTearlineMaterial(GameObject obj, string sourceName, Material sharedMat, Material mat, + MaterialType materialType, QuickJSON matJson) + { + if (matJson != null) + { + mat.SetFloat("_DepthOffset", 0.005f * matJson.GetFloatValue("Custom Shader/Variable/Depth Offset")); + mat.SetFloat("_InnerOffset", 0.005f * matJson.GetFloatValue("Custom Shader/Variable/Depth Offset")); + mat.SetFloat("_Smoothness", 1f - matJson.GetFloatValue("Custom Shader/Variable/Roughness")); + } + } + + private void CacheBakedMaps() + { + bakedDetailMaps = new Dictionary(); + bakedThicknessMaps = new Dictionary(); + + int childCount = fbx.transform.childCount; + for (int i = 0; i < childCount; i++) + { + GameObject obj = fbx.transform.GetChild(i).gameObject; + Renderer renderer = obj.GetComponent(); + + if (renderer) + { + foreach (Material sharedMat in renderer.sharedMaterials) + { + string sourceName = Util.GetSourceMaterialName(fbxPath, sharedMat); + QuickJSON matJson = jsonMeshData.GetObjectAtPath(obj.name + "/Materials/" + sourceName); + MaterialType materialType = GetMaterialType(obj, sharedMat, sourceName, matJson); + if (materialType == MaterialType.Skin || materialType == MaterialType.Head) + { + BakeDefaultMap(sharedMat, sourceName, "_ThicknessMap", "TransMap", + matJson, "Custom Shader/Image/Transmission Map"); + + BakeDefaultMap(sharedMat, sourceName, "_DetailMap", "MicroN", + matJson, "Custom Shader/Image/MicroNormal"); + } + } + } + } + } + + private Texture2D GetCachedBakedMap(Material sharedMaterial, string shaderRef) + { + switch (shaderRef) + { + case "_ThicknessMap": + if (bakedThicknessMaps.ContainsKey(sharedMaterial)) return bakedThicknessMaps[sharedMaterial]; + break; + + case "_DetailMap": + if (bakedDetailMaps.ContainsKey(sharedMaterial)) return bakedDetailMaps[sharedMaterial]; + break; + } + + return null; + } + + private void BakeDefaultMap(Material sharedMat, string sourceName, string shaderRef, string suffix, QuickJSON jsonData, string jsonPath) + { + ComputeBake baker = new ComputeBake(fbx, characterInfo); + + string texturePath = null; + if (jsonData != null) + { + texturePath = jsonData.GetStringValue(jsonPath + "/Texture Path"); + } + + Texture2D tex = GetTextureFrom(texturePath, sourceName, suffix, out string name); + Texture2D bakedTex = null; + + if (tex) + { + switch (shaderRef) + { + case "_ThicknessMap": + // make sure to set the correct import settings for + // these textures before using them for baking... + SetTextureImport(tex, name, FLAG_FOR_BAKE); + bakedTex = baker.BakeDefaultSkinThicknessMap(tex, name); + bakedThicknessMaps.Add(sharedMat, bakedTex); + break; + + case "_DetailMap": + SetTextureImport(tex, name, FLAG_FOR_BAKE); + bakedTex = baker.BakeDefaultDetailMap(tex, name); + bakedDetailMaps.Add(sharedMat, bakedTex); + break; + } + } + } + + private Texture2D GetTextureFrom(string texturePath, string materialName, string suffix, out string name) + { + Texture2D tex = null; + name = ""; + + // try to find the texture from the supplied texture path (usually from the json data). + if (!string.IsNullOrEmpty(texturePath)) + { + name = Path.GetFileNameWithoutExtension(texturePath); + tex = Util.FindTexture(textureFolders.ToArray(), name); + } + + // then try to find the texture from the material name and suffix. + if (!tex) + { + name = materialName + "_" + suffix; + tex = Util.FindTexture(textureFolders.ToArray(), name); + } + + return tex; + } + + private void SetTextureImport(Texture2D tex, string name, int flags = 0) + { + // now fix the import settings for the texture. + string path = AssetDatabase.GetAssetPath(tex); + TextureImporter importer = (TextureImporter)AssetImporter.GetAtPath(path); + importer.maxTextureSize = 4096; + + // apply the sRGB and alpha settings for re-import. + importer.alphaSource = TextureImporterAlphaSource.FromInput; + importer.mipmapEnabled = true; + importer.mipmapFilter = TextureImporterMipFilter.BoxFilter; + if ((flags & FLAG_SRGB) > 0) + { + importer.sRGBTexture = true; + importer.alphaIsTransparency = true; + importer.mipmapFilter = TextureImporterMipFilter.BoxFilter; + importer.mipMapBias = Importer.MIPMAP_BIAS; + if ((flags & FLAG_HAIR) > 0) + { + importer.mipMapsPreserveCoverage = true; + importer.alphaTestReferenceValue = Importer.MIPMAP_ALPHA_CLIP_HAIR; + } + else if ((flags & FLAG_ALPHA_CLIP) > 0) + { + importer.mipMapsPreserveCoverage = true; + importer.alphaTestReferenceValue = 0.5f; + } + else + { + importer.mipMapsPreserveCoverage = false; + } + } + else + { + importer.sRGBTexture = false; + importer.alphaIsTransparency = false; + importer.mipmapFilter = TextureImporterMipFilter.KaiserFilter; + importer.mipMapBias = Importer.MIPMAP_BIAS; + importer.mipMapsPreserveCoverage = false; + } + + // apply the texture type for re-import. + if ((flags & FLAG_NORMAL) > 0) + { + importer.textureType = TextureImporterType.NormalMap; + if (name.iEndsWith("Bump")) + { + importer.convertToNormalmap = true; + importer.heightmapScale = 0.025f; + importer.normalmapFilter = TextureImporterNormalFilter.Standard; + } + } + else + { + importer.textureType = TextureImporterType.Default; + } + + if ((flags & FLAG_FOR_BAKE) > 0) + { + // turn off texture compression and unlock max size to 4k, for the best possible quality bake + importer.textureCompression = TextureImporterCompression.Uncompressed; + importer.compressionQuality = 0; + importer.maxTextureSize = 4096; + } + else + { + importer.textureCompression = TextureImporterCompression.Compressed; + importer.compressionQuality = 50; + importer.maxTextureSize = 4096; + } + + // add the texure path to the re-import paths. + if (AssetDatabase.WriteImportSettingsIfDirty(path)) + if (!importAssets.Contains(path)) importAssets.Add(path); + } + + private bool ConnectTextureTo(string materialName, Material mat, string shaderRef, string suffix, QuickJSON jsonData, string jsonPath, int flags = 0) + { + Texture2D tex = null; + + if (mat.HasProperty(shaderRef)) + { + Vector2 offset = Vector2.zero; + Vector2 tiling = Vector2.one; + string texturePath = null; + + if (jsonData != null) + { + texturePath = jsonData.GetStringValue(jsonPath + "/Texture Path"); + offset = jsonData.GetVector2Value(jsonPath + "/Offset"); + tiling = jsonData.GetVector2Value(jsonPath + "/Tiling"); + } + + tex = GetTextureFrom(texturePath, materialName, suffix, out string name); + + if (tex) + { + // set the texture ref in the material. + mat.SetTexture(shaderRef, tex); + mat.SetTextureOffset(shaderRef, offset); + mat.SetTextureScale(shaderRef, tiling); + + ImporterWindow.LogReport(" Connected texture: " + tex.name); + + SetTextureImport(tex, name, flags); + } + } + + return tex != null; + } + } +} diff --git a/Editor/Importer.cs.meta b/Editor/Importer.cs.meta new file mode 100644 index 0000000..955dd03 --- /dev/null +++ b/Editor/Importer.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: b723cc52213e55a4280b37a9f2eafc41 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Editor/ImporterMenu.cs b/Editor/ImporterMenu.cs new file mode 100644 index 0000000..e671f8a --- /dev/null +++ b/Editor/ImporterMenu.cs @@ -0,0 +1,46 @@ +/* + * Copyright (C) 2021 Victor Soupday + * This file is part of CC3_Unity_Tools + * + * CC3_Unity_Tools is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * CC3_Unity_Tools is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with CC3_Unity_Tools. If not, see . + */ + +using UnityEngine; +using UnityEditor; + +namespace Reallusion.Import +{ + public class ImporterMenu : Editor + { + [MenuItem("CC3/Import Characters", priority = 1)] + public static void InitCC3ImportGUI() + { + ImporterWindow.Init(); + } + + [MenuItem("Assets/CC3/Import Character", priority = 2000)] + public static void InitAssetCC3ImportGUI() + { + ImporterWindow window = ImporterWindow.Init(); + window.SetActiveCharacter(Selection.activeObject); + } + + [MenuItem("Assets/CC3/Import Character", true)] + public static bool ValidateInitAssetCC3ImportGUI() + { + if (Util.IsCC3Character(Selection.activeObject)) return true; + return false; + } + } +} \ No newline at end of file diff --git a/Editor/ImporterMenu.cs.meta b/Editor/ImporterMenu.cs.meta new file mode 100644 index 0000000..71774b7 --- /dev/null +++ b/Editor/ImporterMenu.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: c169f1f4380d3d54c94994a44cb21f1f +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Editor/ImporterWindow.cs b/Editor/ImporterWindow.cs new file mode 100644 index 0000000..2a1b67d --- /dev/null +++ b/Editor/ImporterWindow.cs @@ -0,0 +1,545 @@ +/* + * Copyright (C) 2021 Victor Soupday + * This file is part of CC3_Unity_Tools + * + * CC3_Unity_Tools is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * CC3_Unity_Tools is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with CC3_Unity_Tools. If not, see . + */ + +using System.IO; +using System.Collections.Generic; +using UnityEngine; +using UnityEditor; +using UnityEditor.IMGUI.Controls; +using System; + +namespace Reallusion.Import +{ + public class ImporterWindow : EditorWindow + { + private static readonly string windowTitle = "CC3 Import Tool"; + private static CharacterInfo contextCharacter; + private static List validCharacters; + private static List postprocessCharacters; + + private Vector2 iconScrollView; + private bool previewCharacterAfterGUI; + + const float ICON_SIZE = 80f; + const float WINDOW_MARGIN = 4f; + const float TOP_PADDING = 16f; + const float ACTION_BUTTON_WIDTH = 100f; + const float BUTTON_HEIGHT = 30f; + const float FUNCTION_BUTTON_WIDTH = 100f; + const float INFO_HEIGHT = 90f; + const float OPTION_HEIGHT = 60f; + const float ACTION_HEIGHT = 76f; + const float ICON_WIDTH = 120f; + + + private static string logText = "Log Start:"; + private static GUIStyle logStyle, mainStyle, buttonStyle, labelStyle, boldStyle; + + private static Texture2D iconUnprocessed; + private static Texture2D iconBasic; + private static Texture2D iconHQ; + private static Texture2D iconBaked; + + // SerializeField is used to ensure the view state is written to the window + // layout file. This means that the state survives restarting Unity as long as the window + // is not closed. If the attribute is omitted then the state is still serialized/deserialized. + [SerializeField] TreeViewState treeViewState; + + //The TreeView is not serializable, so it should be reconstructed from the tree data. + CharacterTreeView characterTreeView; + + private void SetContextCharacter(UnityEngine.Object obj) + { + SetContextCharacter(AssetDatabase.AssetPathToGUID(AssetDatabase.GetAssetPath(obj))); + } + + private void SetContextCharacter(string guid) + { + CharacterInfo oldCharacter = contextCharacter; + + if (contextCharacter == null || contextCharacter.guid != guid) + { + contextCharacter = GetCharacterState(guid); + + CreateTreeView(oldCharacter != contextCharacter); + + EditorPrefs.SetString("RL_Importer_Context_Path", contextCharacter.path); + + LogReport("Setting Target Character to: " + contextCharacter.name + " (" + contextCharacter.Generation.ToString() + ")"); + } + } + + public static ImporterWindow Init() + { + ClearAllData(); + Type hwt = Type.GetType("UnityEditor.SceneHierarchyWindow, UnityEditor.dll"); + //EditorWindow hierarchyWindow = GetWindow(); + ImporterWindow window = GetWindow(windowTitle, hwt); + window.minSize = new Vector2(300f, 500f); + window.Show(); + return window; + } + + public static ImporterWindow InitPost(List characters) + { + ClearAllData(); + postprocessCharacters = characters; + ImporterWindow window = Init(); + return window; + } + + public void SetActiveCharacter(UnityEngine.Object obj) + { + if (Util.IsCC3Character(obj)) + { + SetContextCharacter(obj); + } + } + + private void InitData() + { + string[] folders = new string[] { "Assets", "Packages" }; + iconUnprocessed = Util.FindTexture(folders, "RLIcon_UnprocessedChar"); + iconBasic = Util.FindTexture(folders, "RLIcon_BasicChar"); + iconHQ = Util.FindTexture(folders, "RLIcon_HQChar"); + iconBaked = Util.FindTexture(folders, "RLIcon_BakedChar"); + + validCharacters = new List(); + List validCharacterGUIDs = Util.GetValidCharacterGUIDS(); + foreach (string validGUID in validCharacterGUIDs) + { + validCharacters.Add(new CharacterInfo(validGUID)); + } + + if (Util.IsCC3Character(Selection.activeGameObject)) + { + SetContextCharacter(Selection.activeGameObject); + } + + if (contextCharacter == null && validCharacters.Count > 0) + { + string editorPrefsContextPath = EditorPrefs.GetString("RL_Importer_Context_Path"); + if (!string.IsNullOrEmpty(editorPrefsContextPath)) + { + for (int i = 0; i < validCharacters.Count; i++) + { + if (validCharacters[i].path == editorPrefsContextPath) + SetContextCharacter(validCharacters[i].guid); + } + } + + if (contextCharacter == null) + SetContextCharacter(validCharacters[0].guid); + } + + MakeStyle(); + } + + private CharacterInfo GetCharacterState(string guid) + { + if (validCharacters == null) InitData(); + + foreach (CharacterInfo s in validCharacters) + { + if (s.guid.Equals(guid)) return s; + } + + return null; + } + + private void CreateTreeView(bool clearSelection = false) + { + if (contextCharacter != null) + { + // Check whether there is already a serialized view state (state + // that survived assembly reloading) + if (treeViewState == null) + { + treeViewState = new TreeViewState(); + } + characterTreeView = new CharacterTreeView(treeViewState, contextCharacter.fbx); + + characterTreeView.ExpandToDepth(2); + if (clearSelection) characterTreeView.ClearSelection(); + } + } + + private void OnGUI() + { + if (validCharacters == null) InitData(); + if (validCharacters == null || validCharacters.Count == 0) + { + GUILayout.Label("No CC3/iClone Characters detected!"); + return; + } + + float width = position.width - WINDOW_MARGIN; + float height = position.height - WINDOW_MARGIN; + float innerHeight = height - TOP_PADDING; + + Rect iconBlock = new Rect(0f, TOP_PADDING, ICON_WIDTH, innerHeight); + Rect infoBlock = new Rect(iconBlock.xMax, TOP_PADDING, width - iconBlock.width, INFO_HEIGHT); + Rect optionBlock = new Rect(iconBlock.xMax, infoBlock.yMax, infoBlock.width, OPTION_HEIGHT); + Rect actionBlock = new Rect(iconBlock.xMax, optionBlock.yMax, infoBlock.width, ACTION_HEIGHT); + Rect treeviewBlock = new Rect(iconBlock.xMax, actionBlock.yMax, infoBlock.width, height - actionBlock.yMax); + + previewCharacterAfterGUI = false; + + CheckDragAndDrop(); + + OnGUIIconArea(iconBlock); + + OnGUIInfoArea(infoBlock); + + OnGUIOptionArea(optionBlock); + + OnGUIActionArea(actionBlock); + + OnGUITreeViewArea(treeviewBlock); + + // creating a new preview scene in between GUI Layouts causes errors... + if (previewCharacterAfterGUI) Util.PreviewCharacter(contextCharacter.fbx); + } + + private void OnGUIIconArea(Rect iconBlock) + { + GUILayout.BeginArea(iconBlock); + using (var iconScrollViewScope = new EditorGUILayout.ScrollViewScope(iconScrollView, GUILayout.Width(iconBlock.width - 10f), GUILayout.Height(iconBlock.height - 10f))) + { + iconScrollView = iconScrollViewScope.scrollPosition; + GUILayout.BeginVertical(); + + for (int idx = 0; idx < validCharacters.Count; idx++) + { + CharacterInfo info = validCharacters[idx]; + GUILayout.BeginHorizontal(); + GUILayout.FlexibleSpace(); + Texture2D iconTexture = iconUnprocessed; + + if (info.bakeIsBaked) iconTexture = iconBaked; + else if (info.logType == CharacterInfo.ProcessingType.Basic) iconTexture = iconBasic; + else if (info.logType == CharacterInfo.ProcessingType.HighQuality) iconTexture = iconHQ; + + if (GUILayout.Button(iconTexture, + //mainStyle, + GUILayout.Width(ICON_SIZE), + GUILayout.Height(ICON_SIZE))) + { + SetContextCharacter(info.guid); + } + + GUILayout.FlexibleSpace(); + GUILayout.EndHorizontal(); + + GUILayout.BeginHorizontal(); + GUILayout.FlexibleSpace(); + string name = Path.GetFileNameWithoutExtension(AssetDatabase.GUIDToAssetPath(info.guid)); + GUILayout.Box(name, mainStyle); + GUILayout.FlexibleSpace(); + GUILayout.EndHorizontal(); + } + GUILayout.EndVertical(); + } + GUILayout.EndArea(); + } + + private void OnGUIInfoArea(Rect infoBlock) + { + string importType = "Unprocessed"; + if (contextCharacter.logType == CharacterInfo.ProcessingType.Basic) + importType = "Default Materials"; + if (contextCharacter.logType == CharacterInfo.ProcessingType.HighQuality) + importType = "High Quality Materials"; + if (contextCharacter.bakeIsBaked) + importType += " + Baked"; + + GUILayout.BeginArea(infoBlock); + + GUILayout.BeginHorizontal(); + GUILayout.FlexibleSpace(); + + GUILayout.BeginVertical(); + + GUILayout.BeginHorizontal(); + GUILayout.FlexibleSpace(); + GUILayout.Label(contextCharacter.name, boldStyle); + GUILayout.FlexibleSpace(); + GUILayout.EndHorizontal(); + + GUILayout.BeginHorizontal(); + GUILayout.FlexibleSpace(); + GUILayout.Label(contextCharacter.folder, labelStyle); + GUILayout.FlexibleSpace(); + GUILayout.EndHorizontal(); + + GUILayout.BeginHorizontal(); + GUILayout.FlexibleSpace(); + GUILayout.Label("(" + contextCharacter.Generation.ToString() + ")", boldStyle); + GUILayout.FlexibleSpace(); + GUILayout.EndHorizontal(); + + GUILayout.BeginHorizontal(); + GUILayout.FlexibleSpace(); + GUILayout.Label(importType, boldStyle); + GUILayout.FlexibleSpace(); + GUILayout.EndHorizontal(); + + GUILayout.FlexibleSpace(); + + GUILayout.BeginHorizontal(); + GUILayout.FlexibleSpace(); + if (GUILayout.Button("Preview Scene", GUILayout.Width(FUNCTION_BUTTON_WIDTH), GUILayout.Height(BUTTON_HEIGHT))) + { + previewCharacterAfterGUI = true; + } + GUILayout.FlexibleSpace(); + GUILayout.EndHorizontal(); + + GUILayout.FlexibleSpace(); + + GUILayout.EndVertical(); + + GUILayout.FlexibleSpace(); + GUILayout.EndHorizontal(); + + GUILayout.EndArea(); + } + + private void OnGUIOptionArea(Rect optionBlock) + { + GUILayout.BeginArea(optionBlock); + + GUILayout.BeginHorizontal(); + GUILayout.FlexibleSpace(); + + GUILayout.BeginVertical(); + GUILayout.FlexibleSpace(); + + if (!contextCharacter.CanHaveHighQualityMaterials) GUI.enabled = false; + + GUILayout.BeginHorizontal(); + GUILayout.FlexibleSpace(); + contextCharacter.qualRefractiveEyes = GUILayout.Toggle(contextCharacter.qualRefractiveEyes, "Eye - Refractive"); + GUILayout.FlexibleSpace(); + GUILayout.EndHorizontal(); + + GUILayout.BeginHorizontal(); + GUILayout.FlexibleSpace(); + contextCharacter.bakeCustomShaders = GUILayout.Toggle(contextCharacter.bakeCustomShaders, "Bake - Custom Shaders"); + GUILayout.FlexibleSpace(); + GUILayout.EndHorizontal(); + + GUI.enabled = true; + + GUILayout.FlexibleSpace(); + GUILayout.EndVertical(); + + GUILayout.FlexibleSpace(); + GUILayout.EndHorizontal(); + + GUILayout.EndArea(); + } + + private void OnGUIActionArea(Rect actionBlock) + { + GUILayout.BeginArea(actionBlock); + + GUILayout.BeginHorizontal(); + GUILayout.FlexibleSpace(); + + GUILayout.BeginVertical(); + + GUILayout.BeginHorizontal(); + GUILayout.FlexibleSpace(); + if (GUILayout.Button("Default", GUILayout.Width(ACTION_BUTTON_WIDTH), GUILayout.Height(BUTTON_HEIGHT))) + { + LogReport("Doing: Connect Default Materials."); + ImportCharacter(contextCharacter, MaterialQuality.Default); + contextCharacter.logType = CharacterInfo.ProcessingType.Basic; + contextCharacter.Write(); + CreateTreeView(true); + } + GUILayout.FlexibleSpace(); + if (!contextCharacter.CanHaveHighQualityMaterials) GUI.enabled = false; + if (GUILayout.Button("High Quality", GUILayout.Width(ACTION_BUTTON_WIDTH), GUILayout.Height(BUTTON_HEIGHT))) + { + LogReport("Doing: Connect High Quality Materials."); + ImportCharacter(contextCharacter, MaterialQuality.High); + contextCharacter.logType = CharacterInfo.ProcessingType.HighQuality; + contextCharacter.Write(); + CreateTreeView(true); + } + GUILayout.FlexibleSpace(); + GUILayout.EndHorizontal(); + + GUILayout.FlexibleSpace(); + + GUILayout.BeginHorizontal(); + GUILayout.FlexibleSpace(); + if (GUILayout.Button("Bake", GUILayout.Width(FUNCTION_BUTTON_WIDTH), GUILayout.Height(BUTTON_HEIGHT))) + { + if (contextCharacter.logType == CharacterInfo.ProcessingType.HighQuality) + { + + ComputeBake baker = new ComputeBake(contextCharacter.fbx, contextCharacter); + baker.BakeHQ(); + + contextCharacter.bakeIsBaked = true; + contextCharacter.Write(); + } + } + GUILayout.FlexibleSpace(); + GUI.enabled = true; + if (GUILayout.Button("Animations", GUILayout.Width(FUNCTION_BUTTON_WIDTH), GUILayout.Height(BUTTON_HEIGHT))) + { + RL.SetAnimationImport(contextCharacter); + } + GUILayout.FlexibleSpace(); + GUILayout.EndHorizontal(); + + GUILayout.FlexibleSpace(); + + GUILayout.EndVertical(); + + GUILayout.FlexibleSpace(); + GUILayout.EndHorizontal(); + + GUILayout.EndArea(); + } + + private void OnGUITreeViewArea(Rect treeviewBlock) + { + GUILayout.BeginArea(treeviewBlock); + + GUILayout.BeginVertical(); + + GUILayout.BeginHorizontal(); + if (contextCharacter != null) + { + characterTreeView.OnGUI(new Rect(0, 0, treeviewBlock.width, treeviewBlock.height - 16f)); + } + GUILayout.EndHorizontal(); + + GUILayout.FlexibleSpace(); + + GUILayout.BeginHorizontal(); + characterTreeView.selectLinked = GUILayout.Toggle(characterTreeView.selectLinked, "Select Linked"); + GUILayout.EndHorizontal(); + + GUILayout.EndVertical(); + + GUILayout.EndArea(); + } + + private void ImportCharacter(CharacterInfo info, MaterialQuality quality) + { + Importer import = new Importer(info); + import.SetQuality(quality); + import.Import(); + } + + private static void ClearAllData() + { + logText = "Log Start:"; + contextCharacter = null; + + if (validCharacters != null) validCharacters.Clear(); + validCharacters = null; + + if (postprocessCharacters != null) postprocessCharacters.Clear(); + postprocessCharacters = null; + + logStyle = null; + mainStyle = null; + buttonStyle = null; + labelStyle = null; + boldStyle = null; + + iconUnprocessed = null; + iconBasic = null; + iconHQ = null; + iconBaked = null; + } + + private void OnDestroy() + { + ClearAllData(); + } + + public static void LogReport(string s) + { + logText += "\n"; + logText += s; + } + + private static void MakeStyle() + { + logStyle = new GUIStyle(); + logStyle.wordWrap = true; + logStyle.fontStyle = FontStyle.Italic; + logStyle.normal.textColor = Color.grey; + + + mainStyle = new GUIStyle(); + mainStyle.wordWrap = false; + mainStyle.fontStyle = FontStyle.Normal; + mainStyle.normal.textColor = Color.white; + + boldStyle = new GUIStyle(); + boldStyle.alignment = TextAnchor.UpperLeft; + boldStyle.wordWrap = false; + boldStyle.fontStyle = FontStyle.Bold; + boldStyle.normal.textColor = Color.white; + + labelStyle = new GUIStyle(); + labelStyle.alignment = TextAnchor.UpperLeft; + labelStyle.wordWrap = false; + labelStyle.fontStyle = FontStyle.Normal; + labelStyle.normal.textColor = Color.white; + + buttonStyle = new GUIStyle(); + buttonStyle.wordWrap = false; + buttonStyle.fontStyle = FontStyle.Normal; + buttonStyle.normal.textColor = Color.white; + buttonStyle.alignment = TextAnchor.MiddleCenter; + } + + public void CheckDragAndDrop() + { + switch (Event.current.type) + { + case EventType.DragUpdated: + DragAndDrop.visualMode = DragAndDropVisualMode.Copy; + break; + + case EventType.DragPerform: + + UnityEngine.Object[] refs = DragAndDrop.objectReferences; + if (DragAndDrop.objectReferences.Length > 0) + { + UnityEngine.Object obj = DragAndDrop.objectReferences[0]; + if (Util.IsCC3Character(obj)) + SetContextCharacter(obj); + } + DragAndDrop.AcceptDrag(); + break; + } + } + + } +} diff --git a/Editor/ImporterWindow.cs.meta b/Editor/ImporterWindow.cs.meta new file mode 100644 index 0000000..2f5186f --- /dev/null +++ b/Editor/ImporterWindow.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 33708e323ba8daa439e1e3d578a2b7f9 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Editor/MeshUtil.cs b/Editor/MeshUtil.cs new file mode 100644 index 0000000..0f429ed --- /dev/null +++ b/Editor/MeshUtil.cs @@ -0,0 +1,493 @@ +/* + * Copyright (C) 2021 Victor Soupday + * This file is part of CC3_Unity_Tools + * + * CC3_Unity_Tools is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * CC3_Unity_Tools is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with CC3_Unity_Tools. If not, see . + */ + +using UnityEditor; +using UnityEngine; +using UnityEngine.Rendering; +using System.IO; + +namespace Reallusion.Import +{ + public static class MeshUtil + { + public const string INVERTED_FOLDER_NAME = "Inverted Meshes"; + public const string PRUNED_FOLDER_NAME = "Pruned Meshes"; + + [MenuItem("CC3/Tools/Reverse Triangle Order", priority = 100)] + private static void DoReverse() + { + MeshUtil.ReverseTriangleOrder(Selection.activeObject); + } + + [MenuItem("CC3/Tools/Prune Blend Shapes", priority = 101)] + private static void DoPrune() + { + MeshUtil.PruneBlendShapes(Selection.activeObject); + } + + [MenuItem("CC3/Tools/Open or Close Character Mouth", priority = 201)] + private static void DoOpenCloseMouth() + { + MeshUtil.CharacterOpenCloseMouth(Selection.activeObject); + } + + [MenuItem("CC3/Tools/Open or Close Character Eyes", priority = 202)] + private static void DoOpenCloseEyes() + { + MeshUtil.CharacterOpenCloseEyes(Selection.activeObject); + } + + [MenuItem("CC3/Tools/Eye/Look Left", priority = 203)] + private static void DoLookLeft() + { + MeshUtil.CharacterEyeLook(Selection.activeObject, EyeLookDir.Left); + } + + [MenuItem("CC3/Tools/Eye/Look Right", priority = 204)] + private static void DoLookRight() + { + MeshUtil.CharacterEyeLook(Selection.activeObject, EyeLookDir.Right); + } + + [MenuItem("CC3/Tools/Eye/Look Up", priority = 205)] + private static void DoLookUp() + { + MeshUtil.CharacterEyeLook(Selection.activeObject, EyeLookDir.Up); + } + + [MenuItem("CC3/Tools/Eye/Look Down", priority = 206)] + private static void DoLookDown() + { + MeshUtil.CharacterEyeLook(Selection.activeObject, EyeLookDir.Down); + } + + [MenuItem("CC3/Tools/Eye/Look Forward", priority = 207)] + private static void DoLookForward() + { + MeshUtil.CharacterEyeLook(Selection.activeObject, EyeLookDir.None); + } + + public static Mesh GetMeshFromSelected(Object obj) + { + if (obj.GetType() == typeof(Mesh)) + { + Mesh m = (Mesh)obj; + if (m) return m; + } + + if (obj.GetType() == typeof(GameObject)) + { + GameObject go = (GameObject)obj; + if (go) + { + Mesh m = go.GetComponent(); + if (m) return m; + + MeshFilter mf = go.GetComponent(); + if (mf) + { + return mf.mesh; + } + + SkinnedMeshRenderer smr = go.GetComponent(); + if (smr) + { + return smr.sharedMesh; + } + } + } + + return null; + } + + public static bool ReplaceMesh(Object obj, Mesh mesh) + { + if (obj.GetType() == typeof(GameObject)) + { + GameObject go = (GameObject)obj; + if (go) + { + MeshFilter mf = go.GetComponent(); + if (mf) + { + mf.mesh = mesh; + return true; + } + + SkinnedMeshRenderer smr = go.GetComponent(); + if (smr) + { + smr.sharedMesh = mesh; + return true; + } + } + } + + return false; + } + + public static void PruneBlendShapes(Object obj) + { + if (!obj) return; + + GameObject sceneRoot = PrefabUtility.GetOutermostPrefabInstanceRoot(obj); + GameObject asset = PrefabUtility.GetCorrespondingObjectFromSource(sceneRoot); + Object srcObj = PrefabUtility.GetCorrespondingObjectFromSource(obj); + Mesh srcMesh = GetMeshFromSelected(srcObj); + string path = AssetDatabase.GetAssetPath(asset); + + if (string.IsNullOrEmpty(path)) + { + Debug.LogWarning("Object: " + obj.name + " has no source Prefab Asset."); + path = Path.Combine("Assets", "dummy.prefab"); + } + + if (!srcMesh) + { + Debug.LogError("No mesh found in selected object."); + return; + } + + string folder = Path.GetDirectoryName(path); + string meshFolder = Path.Combine(folder, PRUNED_FOLDER_NAME); + + Mesh dstMesh = new Mesh(); + dstMesh.vertices = srcMesh.vertices; + dstMesh.uv = srcMesh.uv; + dstMesh.uv2 = srcMesh.uv2; + dstMesh.normals = srcMesh.normals; + dstMesh.colors = srcMesh.colors; + dstMesh.boneWeights = srcMesh.boneWeights; + dstMesh.bindposes = srcMesh.bindposes; + dstMesh.bounds = srcMesh.bounds; + dstMesh.tangents = srcMesh.tangents; + dstMesh.triangles = srcMesh.triangles; + dstMesh.subMeshCount = srcMesh.subMeshCount; + + for (int s = 0; s < srcMesh.subMeshCount; s++) + { + SubMeshDescriptor submesh = srcMesh.GetSubMesh(s); + dstMesh.SetSubMesh(s, submesh); + } + + // copy any blendshapes across + if (srcMesh.blendShapeCount > 0) + { + Vector3[] deltaVerts = new Vector3[srcMesh.vertexCount]; + Vector3[] deltaNormals = new Vector3[srcMesh.vertexCount]; + Vector3[] deltaTangents = new Vector3[srcMesh.vertexCount]; + + for (int i = 0; i < srcMesh.blendShapeCount; i++) + { + string name = srcMesh.GetBlendShapeName(i); + + int frameCount = srcMesh.GetBlendShapeFrameCount(i); + for (int f = 0; f < frameCount; f++) + { + float frameWeight = srcMesh.GetBlendShapeFrameWeight(i, f); + srcMesh.GetBlendShapeFrameVertices(i, f, deltaVerts, deltaNormals, deltaTangents); + + Vector3 deltaSum = Vector3.zero; + for (int d = 0; d < srcMesh.vertexCount; d++) deltaSum += deltaVerts[d]; + Debug.Log(name + ": deltaSum = " + deltaSum.ToString()); + + if (deltaSum.magnitude > 0.1f) + dstMesh.AddBlendShapeFrame(name, frameWeight, deltaVerts, deltaNormals, deltaTangents); + } + } + } + + // Save the mesh asset. + if (!AssetDatabase.IsValidFolder(meshFolder)) + AssetDatabase.CreateFolder(folder, PRUNED_FOLDER_NAME); + string meshPath = Path.Combine(meshFolder, srcObj.name + ".mesh"); + AssetDatabase.CreateAsset(dstMesh, meshPath); + + if (obj.GetType() == typeof(GameObject)) + { + GameObject go = (GameObject)obj; + if (go) + { + Mesh createdMesh = AssetDatabase.LoadAssetAtPath(meshPath); + + if (!ReplaceMesh(obj, createdMesh)) + { + Debug.LogError("Unable to set mesh in selected object!"); + } + } + } + } + + public static void ReverseTriangleOrder(Object obj) + { + if (!obj) return; + + GameObject sceneRoot = PrefabUtility.GetOutermostPrefabInstanceRoot(obj); + GameObject asset = PrefabUtility.GetCorrespondingObjectFromSource(sceneRoot); + Object srcObj = PrefabUtility.GetCorrespondingObjectFromSource(obj); + Mesh srcMesh = GetMeshFromSelected(srcObj); + string path = AssetDatabase.GetAssetPath(asset); + + if (string.IsNullOrEmpty(path)) + { + Debug.LogWarning("Object: " + obj.name + " has no source Prefab Asset."); + path = Path.Combine("Assets", "dummy.prefab"); + } + + if (!srcMesh) + { + Debug.LogError("No mesh found in selected object."); + return; + } + + string folder = Path.GetDirectoryName(path); + string meshFolder = Path.Combine(folder, INVERTED_FOLDER_NAME); + + Mesh dstMesh = new Mesh(); + dstMesh.vertices = srcMesh.vertices; + dstMesh.uv = srcMesh.uv; + dstMesh.uv2 = srcMesh.uv2; + dstMesh.normals = srcMesh.normals; + dstMesh.colors = srcMesh.colors; + dstMesh.boneWeights = srcMesh.boneWeights; + dstMesh.bindposes = srcMesh.bindposes; + dstMesh.bounds = srcMesh.bounds; + dstMesh.tangents = srcMesh.tangents; + + int[] reversed = new int[srcMesh.triangles.Length]; + int[] forward = srcMesh.triangles; + + // first pass: reverse the triangle order for each submesh + for (int s = 0; s < srcMesh.subMeshCount; s++) + { + SubMeshDescriptor submesh = srcMesh.GetSubMesh(s); + int start = submesh.indexStart; + int end = start + submesh.indexCount; + int j = end - 3; + for (int i = start; i < end; i += 3) + { + reversed[j] = forward[i]; + reversed[j + 1] = forward[i + 1]; + reversed[j + 2] = forward[i + 2]; + j -= 3; + } + } + + dstMesh.triangles = reversed; + dstMesh.subMeshCount = srcMesh.subMeshCount; + + // second pass: copy sub-mesh data (vertex and triangle data must be present for this) + for (int s = 0; s < srcMesh.subMeshCount; s++) + { + SubMeshDescriptor submesh = srcMesh.GetSubMesh(s); + dstMesh.SetSubMesh(s, submesh); + } + + // copy any blendshapes across + if (srcMesh.blendShapeCount > 0) + { + Vector3[] bufVerts = new Vector3[srcMesh.vertexCount]; + Vector3[] bufNormals = new Vector3[srcMesh.vertexCount]; + Vector3[] bufTangents = new Vector3[srcMesh.vertexCount]; + + for (int i = 0; i < srcMesh.blendShapeCount; i++) + { + string name = srcMesh.GetBlendShapeName(i); + + int frameCount = srcMesh.GetBlendShapeFrameCount(i); + for (int f = 0; f < frameCount; f++) + { + float frameWeight = srcMesh.GetBlendShapeFrameWeight(i, f); + srcMesh.GetBlendShapeFrameVertices(i, f, bufVerts, bufNormals, bufTangents); + dstMesh.AddBlendShapeFrame(name, frameWeight, bufVerts, bufNormals, bufTangents); + } + } + } + + // Save the mesh asset. + if (!AssetDatabase.IsValidFolder(meshFolder)) + AssetDatabase.CreateFolder(folder, INVERTED_FOLDER_NAME); + string meshPath = Path.Combine(meshFolder, srcObj.name + ".mesh"); + AssetDatabase.CreateAsset(dstMesh, meshPath); + + if (obj.GetType() == typeof(GameObject)) + { + GameObject go = (GameObject)obj; + if (go) + { + Mesh createdMesh = AssetDatabase.LoadAssetAtPath(meshPath); + + if (!ReplaceMesh(obj, createdMesh)) + { + Debug.LogError("Unable to set mesh in selected object!"); + } + } + } + } + + public static GameObject FindCharacterBone(GameObject gameObject, string name) + { + if (gameObject) + { + if (gameObject.name.iEndsWith(name)) + return gameObject; + + int children = gameObject.transform.childCount; + for (int i = 0; i < children; i++) + { + GameObject found = FindCharacterBone(gameObject.transform.GetChild(i).gameObject, name); + if (found) return found; + } + } + + return null; + } + + public static void CharacterOpenCloseMouth(Object obj) + { + GameObject root = PrefabUtility.GetOutermostPrefabInstanceRoot(obj); + + if (root) + { + bool isOpen; + + // find the jaw bone and change it's rotation + GameObject jawBone = FindCharacterBone(root, "CC_Base_JawRoot"); + if (!jawBone) jawBone = FindCharacterBone(root, "JawRoot"); + if (jawBone) + { + Transform jaw = jawBone.transform; + Quaternion rotation = jaw.localRotation; + Vector3 euler = rotation.eulerAngles; + if (euler.z < 91f || euler.z > 269f) + { + euler.z = -108f; + isOpen = true; + } + else + { + euler.z = -90f; + isOpen = false; + } + rotation.eulerAngles = euler; + jaw.localRotation = rotation; + + const string shapeName = "Mouth_Open"; + + // go through all the mesh object with blendshapes and set the "Mouth_Open" blend shape + for (int i = 0; i < root.transform.childCount; i++) + { + GameObject child = root.transform.GetChild(i).gameObject; + SkinnedMeshRenderer renderer = child.GetComponent(); + if (renderer) + { + Mesh mesh = renderer.sharedMesh; + if (mesh.blendShapeCount > 0) + { + int shapeIndex = mesh.GetBlendShapeIndex(shapeName); + if (shapeIndex > 0) + { + renderer.SetBlendShapeWeight(shapeIndex, isOpen ? 100f : 0f); + } + } + } + } + } + } + } + + public static void CharacterOpenCloseEyes(Object obj) + { + GameObject root = PrefabUtility.GetOutermostPrefabInstanceRoot(obj); + + if (root) + { + bool isOpen; + + const string shapeNameL = "Eye_Blink_L"; + const string shapeNameR = "Eye_Blink_R"; + const string shapeNameSingle = "Eye_Blink"; + + // go through all the mesh object with blendshapes and set the "Mouth_Open" blend shape + for (int i = 0; i < root.transform.childCount; i++) + { + GameObject child = root.transform.GetChild(i).gameObject; + SkinnedMeshRenderer renderer = child.GetComponent(); + if (renderer) + { + Mesh mesh = renderer.sharedMesh; + if (mesh.blendShapeCount > 0) + { + int shapeIndexL = mesh.GetBlendShapeIndex(shapeNameL); + int shapeIndexR = mesh.GetBlendShapeIndex(shapeNameR); + int shapeIndexS = mesh.GetBlendShapeIndex(shapeNameSingle); + + if (shapeIndexL > 0 && shapeIndexR > 0) + { + if (renderer.GetBlendShapeWeight(shapeIndexL) > 0f) isOpen = false; + else isOpen = true; + + renderer.SetBlendShapeWeight(shapeIndexL, isOpen ? 100f : 0f); + renderer.SetBlendShapeWeight(shapeIndexR, isOpen ? 100f : 0f); + } + else if (shapeIndexS > 0) + { + if (renderer.GetBlendShapeWeight(shapeIndexS) > 0f) isOpen = false; + else isOpen = true; + + renderer.SetBlendShapeWeight(shapeIndexS, isOpen ? 100f : 0f); + } + } + } + } + } + } + + public enum EyeLookDir { None = 0, Left = 1, Right = 2, Up = 4, Down = 8 } + public static void CharacterEyeLook(Object obj, EyeLookDir dirFlags) + { + GameObject root = PrefabUtility.GetOutermostPrefabInstanceRoot(obj); + + if (root) + { + GameObject leftEye = FindCharacterBone(root, "CC_Base_L_Eye"); + if (!leftEye) leftEye = FindCharacterBone(root, "L_Eye"); + GameObject rightEye = FindCharacterBone(root, "CC_Base_R_Eye"); + if (!rightEye) rightEye = FindCharacterBone(root, "R_Eye"); + + if (leftEye && rightEye) + { + Vector3 euler; + + if (dirFlags == 0) euler = new Vector3(0, -90f, 180f); + else euler = leftEye.transform.localRotation.eulerAngles; + + if ((dirFlags & EyeLookDir.Left) > 0) euler.z = 168f; + if ((dirFlags & EyeLookDir.Right) > 0) euler.z = 192f; + if ((dirFlags & EyeLookDir.Up) > 0) euler.x = 10f; + if ((dirFlags & EyeLookDir.Down) > 0) euler.x = -10f; + + Quaternion rotation = Quaternion.identity; + rotation.eulerAngles = euler; + leftEye.transform.localRotation = rotation; + rightEye.transform.localRotation = rotation; + } + } + } + } +} diff --git a/Editor/MeshUtil.cs.meta b/Editor/MeshUtil.cs.meta new file mode 100644 index 0000000..a2d514b --- /dev/null +++ b/Editor/MeshUtil.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 1ebbecd21b2b41c43adc68b058f3a07d +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Editor/Pipeline.cs b/Editor/Pipeline.cs new file mode 100644 index 0000000..d7c37d9 --- /dev/null +++ b/Editor/Pipeline.cs @@ -0,0 +1,436 @@ +/* + * Copyright (C) 2021 Victor Soupday + * This file is part of CC3_Unity_Tools + * + * CC3_Unity_Tools is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * CC3_Unity_Tools is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with CC3_Unity_Tools. If not, see . + */ + +#define PIPELINE_HDRP + +using System.Collections.Generic; +using UnityEngine; + +namespace Reallusion.Import +{ + public enum RenderPipeline { Unknown, HDRP, URP, Builtin } + + public enum MaterialType + { + None, Skin, Head, Eye, Cornea, EyeOcclusion, Tearline, Hair, Scalp, + Eyelash, Teeth, Tongue, DefaultOpaque, DefaultAlpha + } + + public enum MaterialQuality { Default, High, Baked } + + public static class Pipeline + { +#if PIPELINE_HDRP + // Shaders + // + public const string SHADER_DEFAULT = "HDRP/Lit"; + public const string SHADER_DEFAULT_HAIR = "HDRP/Hair"; + // + public const string SHADER_HQ_SKIN = "RL_SkinShaderVariants_HDRP"; + public const string SHADER_HQ_HEAD = "RL_SkinShaderVariants_HDRP"; + public const string SHADER_HQ_CORNEA = "RL_EyeShaderVariants_HDRP"; + public const string SHADER_HQ_EYE = "RL_EyeShaderVariants_HDRP"; + public const string SHADER_HQ_EYE_OCCLUSION = "RL_EyeOcclusionShader_HDRP"; + public const string SHADER_HQ_TEARLINE = "RL_TearlineShader_HDRP"; + public const string SHADER_HQ_HAIR = "RL_HairShaderVariants_HDRP"; + public const string SHADER_HQ_SCALPBASE = "HDRP/Lit"; + public const string SHADER_HQ_EYELASH = "HDRP/Lit"; + public const string SHADER_HQ_TEETH = "RL_TeethShader_HDRP"; + public const string SHADER_HQ_TONGUE = "RL_TongueShader_HDRP"; + public const string SHADER_HQ_ALPHACLIP = "HDRP/Lit"; + public const string SHADER_HQ_OPAQUE = "HDRP/Lit"; + + // HQ Materials + // + public const string MATERIAL_HQ_SKIN = "RL_Template_HQ_Skin_HDRP"; + public const string MATERIAL_HQ_HEAD = "RL_Template_HQ_Head_HDRP"; + public const string MATERIAL_HQ_CORNEA = "RL_Template_HQ_Cornea_HDRP"; + public const string MATERIAL_HQ_EYE = "RL_Template_HQ_Eye_HDRP"; + public const string MATERIAL_HQ_EYE_OCCLUSION = "RL_Template_HQ_EyeOcclusion_HDRP"; + public const string MATERIAL_HQ_TEARLINE = "RL_Template_HQ_Tearline_HDRP"; + public const string MATERIAL_HQ_HAIR = "RL_Template_HQ_Hair_HDRP"; + public const string MATERIAL_HQ_SCALPBASE = "RL_Template_Default_ScalpBase_HDRP"; + public const string MATERIAL_HQ_EYELASH = "RL_Template_Default_Eyelash_HDRP"; + public const string MATERIAL_HQ_TEETH = "RL_Template_HQ_Teeth_HDRP"; + public const string MATERIAL_HQ_TONGUE = "RL_Template_HQ_Tongue_HDRP"; + public const string MATERIAL_HQ_ALPHACLIP = "RL_Template_Default_AlphaClip_HDRP"; + public const string MATERIAL_HQ_OPAQUE = "RL_Template_Default_Opaque_HDRP"; + // variants + public const string MATERIAL_HQ_CORNEA_REFRACTIVE = "RL_Template_HQ_CorneaRef_HDRP"; + + // Default Materials + // + public const string MATERIAL_DEFAULT_SKIN = "RL_Template_Default_Skin_HDRP"; + public const string MATERIAL_DEFAULT_HEAD = "RL_Template_Default_Skin_HDRP"; + public const string MATERIAL_DEFAULT_CORNEA = "RL_Template_Default_Opaque_HDRP"; + public const string MATERIAL_DEFAULT_EYE = "RL_Template_Default_Opaque_HDRP"; + public const string MATERIAL_DEFAULT_EYE_OCCLUSION = "RL_Template_Default_EyeOcclusion_HDRP"; + public const string MATERIAL_DEFAULT_TEARLINE = "RL_Template_Default_Tearline_HDRP"; + public const string MATERIAL_DEFAULT_HAIR = "RL_Template_Default_Hair_HDRP"; + public const string MATERIAL_DEFAULT_SCALPBASE = "RL_Template_Default_ScalpBase_HDRP"; + public const string MATERIAL_DEFAULT_EYELASH = "RL_Template_Default_Eyelash_HDRP"; + public const string MATERIAL_DEFAULT_TEETH = "RL_Template_Default_Opaque_HDRP"; + public const string MATERIAL_DEFAULT_TONGUE = "RL_Template_Default_Opaque_HDRP"; + public const string MATERIAL_DEFAULT_ALPHACLIP = "RL_Template_Default_AlphaClip_HDRP"; + public const string MATERIAL_DEFAULT_OPAQUE = "RL_Template_Default_Opaque_HDRP"; + // variants + public const string MATERIAL_DEFAULT_CORNEA_REFRACTIVE = "RL_Template_Default_Opaque_HDRP"; + + // Baked Materials + // + public const string MATERIAL_BAKED_SKIN = "RL_Template_Baked_Skin_HDRP"; + public const string MATERIAL_BAKED_HEAD = "RL_Temaplte_Baked_Skin_HDRP"; + public const string MATERIAL_BAKED_CORNEA = "RL_Template_Baked_Cornea_HDRP"; + public const string MATERIAL_BAKED_EYE = "RL_Template_Baked_Eye_HDRP"; + public const string MATERIAL_BAKED_EYE_OCCLUSION = "RL_Template_Baked_EyeOcclusion_HDRP"; + public const string MATERIAL_BAKED_TEARLINE = "RL_Template_Tearline_HDRP"; + public const string MATERIAL_BAKED_HAIR = "RL_Template_Baked_Hair_HDRP"; + public const string MATERIAL_BAKED_SCALPBASE = "RL_Template_Default_ScalpBase_HDRP"; + public const string MATERIAL_BAKED_EYELASH = "RL_Template_Default_Eyelash_HDRP"; + public const string MATERIAL_BAKED_TEETH = "RL_Template_Baked_Skin_HDRP"; + public const string MATERIAL_BAKED_TONGUE = "RL_Template_Baked_Skin_HDRP"; + public const string MATERIAL_BAKED_ALPHACLIP = "RL_Template_Default_AlphaClip_HDRP"; + public const string MATERIAL_BAKED_OPAQUE = "RL_Template_Default_Opaque_HDRP"; + // variants + public const string MATERIAL_BAKED_CORNEA_REFRACTIVE = "RL_Template_Baked_CorneaRef_HDRP"; + public const string MATERIAL_BAKED_EYE_CUSTOM = "RL_Template_Baked_EyeCustom_HDRP"; + public const string MATERIAL_BAKED_EYE_OCCLUSION_CUSTOM = "RL_Template_Baked_EyeOcclusionCustom_HDRP"; + public const string MATERIAL_BAKED_HAIR_CUSTOM = "RL_Template_Baked_HairCustom_HDRP"; + // for gamebase single material or actor core... + public const string MATERIAL_DEFAULT_SINGLE_MATERIAL = "RL_Template_Default_SingleMaterial_HDRP"; +#elif PIPELINE_URP + // Shaders + // + public const string SHADER_DEFAULT = "Universal Render Pipeline/Lit"; + public const string SHADER_DEFAULT_HAIR = "Universal Render Pipeline/Hair"; + // + public const string SHADER_HQ_SKIN = "RL_SkinShaderVariants_URP"; + public const string SHADER_HQ_HEAD = "RL_SkinShaderVariants_URP"; + public const string SHADER_HQ_CORNEA = "RL_EyeShaderVariants_URP"; + public const string SHADER_HQ_EYE = "RL_EyeShaderVariants_URP"; + public const string SHADER_HQ_EYE_OCCLUSION = "RL_EyeOcclusionShader_URP"; + public const string SHADER_HQ_TEARLINE = "RL_TearlineShader_URP"; + public const string SHADER_HQ_HAIR = "RL_HairShaderVariants_URP"; + public const string SHADER_HQ_SCALPBASE = "Universal Render Pipeline/Lit"; + public const string SHADER_HQ_EYELASH = "Universal Render Pipeline/Lit"; + public const string SHADER_HQ_TEETH = "RL_TeethShader_URP"; + public const string SHADER_HQ_TONGUE = "RL_TongueShader_URP"; + public const string SHADER_HQ_ALPHACLIP = "Universal Render Pipeline/Lit"; + public const string SHADER_HQ_OPAQUE = "Universal Render Pipeline/Lit"; + + // HQ Materials + // + public const string MATERIAL_HQ_SKIN = "RL_Template_Skin_URP"; + public const string MATERIAL_HQ_HEAD = "RL_Template_Head_URP"; + public const string MATERIAL_HQ_CORNEA = "RL_Template_Cornea_URP"; + public const string MATERIAL_HQ_EYE = "RL_Template_Eye_URP"; + public const string MATERIAL_HQ_EYE_OCCLUSION = "RL_Template_EyeOcclusion_URP"; + public const string MATERIAL_HQ_TEARLINE = "RL_Template_Tearline_URP"; + public const string MATERIAL_HQ_HAIR = "RL_Template_Hair_URP"; + public const string MATERIAL_HQ_SCALPBASE = "RL_Template_Default_ScalpBase_URP"; + public const string MATERIAL_HQ_EYELASH = "RL_Template_Default_Eyelash_URP"; + public const string MATERIAL_HQ_TEETH = "RL_Template_Teeth_URP"; + public const string MATERIAL_HQ_TONGUE = "RL_Template_Tongue_URP"; + public const string MATERIAL_HQ_ALPHACLIP = "RL_Template_Default_AlphaClip_URP"; + public const string MATERIAL_HQ_OPAQUE = "RL_Template_Default_Opaque_URP"; + // variants + public const string MATERIAL_HQ_CORNEA_REFRACTIVE = "RL_Template_CorneaRef_URP"; + + // Default Materials + // + public const string MATERIAL_DEFAULT_SKIN = "RL_Template_Default_Skin_URP"; + public const string MATERIAL_DEFAULT_HEAD = "RL_Template_Default_Skin_URP"; + public const string MATERIAL_DEFAULT_CORNEA = "RL_Template_Default_Opaque_URP"; + public const string MATERIAL_DEFAULT_EYE = "RL_Template_Default_Opaque_URP"; + public const string MATERIAL_DEFAULT_EYE_OCCLUSION = "RL_Template_EyeOcclusion_URP"; + public const string MATERIAL_DEFAULT_TEARLINE = "RL_Template_Tearline_URP"; + public const string MATERIAL_DEFAULT_HAIR = "RL_Template_Default_Hair_URP"; + public const string MATERIAL_DEFAULT_SCALPBASE = "RL_Template_Default_ScalpBase_URP"; + public const string MATERIAL_DEFAULT_EYELASH = "RL_Template_Default_Eyelash_URP"; + public const string MATERIAL_DEFAULT_TEETH = "RL_Template_Default_Opaque_URP"; + public const string MATERIAL_DEFAULT_TONGUE = "RL_Template_Default_Opaque_URP"; + public const string MATERIAL_DEFAULT_ALPHACLIP = "RL_Template_Default_AlphaClip_URP"; + public const string MATERIAL_DEFAULT_OPAQUE = "RL_Template_Default_Opaque_URP"; + // variants + public const string MATERIAL_DEFAULT_CORNEA_REFRACTIVE = "RL_Template_Default_Opaque_URP"; + + // Baked Materials + // + public const string MATERIAL_BAKED_SKIN = "RL_Template_Baked_Skin_URP"; + public const string MATERIAL_BAKED_HEAD = "RL_Temaplte_Baked_Skin_URP"; + public const string MATERIAL_BAKED_CORNEA = "RL_Template_Baked_Cornea_URP"; + public const string MATERIAL_BAKED_EYE = "RL_Template_Baked_Eye_URP"; + public const string MATERIAL_BAKED_EYE_OCCLUSION = "RL_Template_EyeOcclusion_URP"; + public const string MATERIAL_BAKED_TEARLINE = "RL_Template_Tearline_URP"; + public const string MATERIAL_BAKED_HAIR = "RL_Template_Baked_Hair_URP"; + public const string MATERIAL_BAKED_SCALPBASE = "RL_Template_Default_ScalpBase_URP"; + public const string MATERIAL_BAKED_EYELASH = "RL_Template_Default_Eyelash_URP"; + public const string MATERIAL_BAKED_TEETH = "RL_Template_Baked_Skin_URP"; + public const string MATERIAL_BAKED_TONGUE = "RL_Template_Baked_Skin_URP"; + public const string MATERIAL_BAKED_ALPHACLIP = "RL_Template_Default_AlphaClip_URP"; + public const string MATERIAL_BAKED_OPAQUE = "RL_Template_Default_Opaque_URP"; + // variants + public const string MATERIAL_BAKED_CORNEA_REFRACTIVE = "RL_Template_Baked_CorneaRef_URP"; + public const string MATERIAL_BAKED_EYE_CUSTOM = "RL_Template_Baked_EyeCustom_URP"; + public const string MATERIAL_BAKED_HAIR_CUSTOM = "RL_Template_Baked_HairCustom_URP"; +#elif PIPELINE_3D + // Shaders + // + public const string SHADER_DEFAULT = "3D/Lit"; + public const string SHADER_DEFAULT_HAIR = "3D/Hair"; + // + public const string SHADER_HQ_SKIN = "RL_SkinShaderVariants_3D"; + public const string SHADER_HQ_HEAD = "RL_SkinShaderVariants_3D"; + public const string SHADER_HQ_CORNEA = "RL_EyeShaderVariants_3D"; + public const string SHADER_HQ_EYE = "RL_EyeShaderVariants_3D"; + public const string SHADER_HQ_EYE_OCCLUSION = "RL_EyeOcclusionShader_3D"; + public const string SHADER_HQ_TEARLINE = "RL_TearlineShader_3D"; + public const string SHADER_HQ_HAIR = "RL_HairShaderVariants_3D"; + public const string SHADER_HQ_SCALPBASE = "3D/Lit"; + public const string SHADER_HQ_EYELASH = "3D/Lit"; + public const string SHADER_HQ_TEETH = "RL_TeethShader_3D"; + public const string SHADER_HQ_TONGUE = "RL_TongueShader_3D"; + public const string SHADER_HQ_ALPHACLIP = "3D/Lit"; + public const string SHADER_HQ_OPAQUE = "3D/Lit"; + + // HQ Materials + // + public const string MATERIAL_HQ_SKIN = "RL_Template_Skin_3D"; + public const string MATERIAL_HQ_HEAD = "RL_Template_Head_3D"; + public const string MATERIAL_HQ_CORNEA = "RL_Template_Cornea_3D"; + public const string MATERIAL_HQ_EYE = "RL_Template_Eye_3D"; + public const string MATERIAL_HQ_EYE_OCCLUSION = "RL_Template_EyeOcclusion_3D"; + public const string MATERIAL_HQ_TEARLINE = "RL_Template_Tearline_3D"; + public const string MATERIAL_HQ_HAIR = "RL_Template_Hair_3D"; + public const string MATERIAL_HQ_SCALPBASE = "RL_Template_Default_ScalpBase_3D"; + public const string MATERIAL_HQ_EYELASH = "RL_Template_Default_Eyelash_3D"; + public const string MATERIAL_HQ_TEETH = "RL_Template_Teeth_3D"; + public const string MATERIAL_HQ_TONGUE = "RL_Template_Tongue_3D"; + public const string MATERIAL_HQ_ALPHACLIP = "RL_Template_Default_AlphaClip_3D"; + public const string MATERIAL_HQ_OPAQUE = "RL_Template_Default_Opaque_3D"; + // variants + public const string MATERIAL_HQ_CORNEA_REFRACTIVE = "RL_Template_CorneaRef_3D"; + + // Default Materials + // + public const string MATERIAL_DEFAULT_SKIN = "RL_Template_Default_Skin_3D"; + public const string MATERIAL_DEFAULT_HEAD = "RL_Template_Default_Skin_3D"; + public const string MATERIAL_DEFAULT_CORNEA = "RL_Template_Default_Opaque_3D"; + public const string MATERIAL_DEFAULT_EYE = "RL_Template_Default_Opaque_3D"; + public const string MATERIAL_DEFAULT_EYE_OCCLUSION = "RL_Template_EyeOcclusion_3D"; + public const string MATERIAL_DEFAULT_TEARLINE = "RL_Template_Tearline_3D"; + public const string MATERIAL_DEFAULT_HAIR = "RL_Template_Default_Hair_3D"; + public const string MATERIAL_DEFAULT_SCALPBASE = "RL_Template_Default_ScalpBase_3D"; + public const string MATERIAL_DEFAULT_EYELASH = "RL_Template_Default_Eyelash_3D"; + public const string MATERIAL_DEFAULT_TEETH = "RL_Template_Default_Opaque_3D"; + public const string MATERIAL_DEFAULT_TONGUE = "RL_Template_Default_Opaque_3D"; + public const string MATERIAL_DEFAULT_ALPHACLIP = "RL_Template_Default_AlphaClip_3D"; + public const string MATERIAL_DEFAULT_OPAQUE = "RL_Template_Default_Opaque_3D"; + // variants + public const string MATERIAL_DEFAULT_CORNEA_REFRACTIVE = "RL_Template_Default_Opaque_3D"; + + // Baked Materials + // + public const string MATERIAL_BAKED_SKIN = "RL_Template_Baked_Skin_3D"; + public const string MATERIAL_BAKED_HEAD = "RL_Temaplte_Baked_Skin_3D"; + public const string MATERIAL_BAKED_CORNEA = "RL_Template_Baked_Cornea_3D"; + public const string MATERIAL_BAKED_EYE = "RL_Template_Baked_Eye_3D"; + public const string MATERIAL_BAKED_EYE_OCCLUSION = "RL_Template_EyeOcclusion_3D"; + public const string MATERIAL_BAKED_TEARLINE = "RL_Template_Tearline_3D"; + public const string MATERIAL_BAKED_HAIR = "RL_Template_Baked_Hair_3D"; + public const string MATERIAL_BAKED_SCALPBASE = "RL_Template_Default_ScalpBase_3D"; + public const string MATERIAL_BAKED_EYELASH = "RL_Template_Default_Eyelash_3D"; + public const string MATERIAL_BAKED_TEETH = "RL_Template_Baked_Skin_3D"; + public const string MATERIAL_BAKED_TONGUE = "RL_Template_Baked_Skin_3D"; + public const string MATERIAL_BAKED_ALPHACLIP = "RL_Template_Default_AlphaClip_3D"; + public const string MATERIAL_BAKED_OPAQUE = "RL_Template_Default_Opaque_3D"; + // variants + public const string MATERIAL_BAKED_CORNEA_REFRACTIVE = "RL_Template_Baked_CorneaRef_3D"; + public const string MATERIAL_BAKED_EYE_CUSTOM = "RL_Template_Baked_EyeCustom_3D"; + public const string MATERIAL_BAKED_HAIR_CUSTOM = "RL_Template_Baked_HairCustom_3D"; +#endif + + private static Dictionary DICT_SHADERS = new Dictionary + { + { MaterialType.Skin, SHADER_HQ_SKIN }, + { MaterialType.Head, SHADER_HQ_HEAD }, + { MaterialType.Cornea, SHADER_HQ_CORNEA }, + { MaterialType.Eye, SHADER_HQ_EYE }, + { MaterialType.EyeOcclusion, SHADER_HQ_EYE_OCCLUSION }, + { MaterialType.Tearline, SHADER_HQ_TEARLINE }, + { MaterialType.Hair, SHADER_HQ_HAIR }, + { MaterialType.Scalp, SHADER_HQ_SCALPBASE }, + { MaterialType.Eyelash, SHADER_HQ_EYELASH }, + { MaterialType.Teeth, SHADER_HQ_TEETH }, + { MaterialType.Tongue, SHADER_HQ_TONGUE }, + { MaterialType.DefaultAlpha, SHADER_HQ_ALPHACLIP }, + { MaterialType.DefaultOpaque, SHADER_HQ_OPAQUE }, + }; + + private static Dictionary DICT_MATERIALS_DEFAULT = new Dictionary + { + { MaterialType.Skin, MATERIAL_DEFAULT_SKIN }, + { MaterialType.Head, MATERIAL_DEFAULT_HEAD }, + { MaterialType.Cornea, MATERIAL_DEFAULT_CORNEA }, + { MaterialType.Eye, MATERIAL_DEFAULT_EYE }, + { MaterialType.EyeOcclusion, MATERIAL_DEFAULT_EYE_OCCLUSION }, + { MaterialType.Tearline, MATERIAL_DEFAULT_TEARLINE }, + { MaterialType.Hair, MATERIAL_DEFAULT_HAIR }, + { MaterialType.Scalp, MATERIAL_DEFAULT_SCALPBASE }, + { MaterialType.Eyelash, MATERIAL_DEFAULT_EYELASH }, + { MaterialType.Teeth, MATERIAL_DEFAULT_TEETH }, + { MaterialType.Tongue, MATERIAL_DEFAULT_TONGUE }, + { MaterialType.DefaultAlpha, MATERIAL_DEFAULT_ALPHACLIP }, + { MaterialType.DefaultOpaque, MATERIAL_DEFAULT_OPAQUE }, + }; + + private static Dictionary DICT_MATERIALS_HQ = new Dictionary + { + { MaterialType.Skin, MATERIAL_HQ_SKIN }, + { MaterialType.Head, MATERIAL_HQ_HEAD }, + { MaterialType.Cornea, MATERIAL_HQ_CORNEA }, + { MaterialType.Eye, MATERIAL_HQ_EYE }, + { MaterialType.EyeOcclusion, MATERIAL_HQ_EYE_OCCLUSION }, + { MaterialType.Tearline, MATERIAL_HQ_TEARLINE }, + { MaterialType.Hair, MATERIAL_HQ_HAIR }, + { MaterialType.Scalp, MATERIAL_HQ_SCALPBASE }, + { MaterialType.Eyelash, MATERIAL_HQ_EYELASH }, + { MaterialType.Teeth, MATERIAL_HQ_TEETH }, + { MaterialType.Tongue, MATERIAL_HQ_TONGUE }, + { MaterialType.DefaultAlpha, MATERIAL_HQ_ALPHACLIP }, + { MaterialType.DefaultOpaque, MATERIAL_HQ_OPAQUE }, + }; + + private static Dictionary DICT_MATERIALS_BAKED = new Dictionary + { + { MaterialType.Skin, MATERIAL_BAKED_SKIN }, + { MaterialType.Head, MATERIAL_BAKED_HEAD }, + { MaterialType.Cornea, MATERIAL_BAKED_CORNEA }, + { MaterialType.Eye, MATERIAL_BAKED_EYE }, + { MaterialType.EyeOcclusion, MATERIAL_BAKED_EYE_OCCLUSION }, + { MaterialType.Tearline, MATERIAL_BAKED_TEARLINE }, + { MaterialType.Hair, MATERIAL_BAKED_HAIR }, + { MaterialType.Scalp, MATERIAL_BAKED_SCALPBASE }, + { MaterialType.Eyelash, MATERIAL_BAKED_EYELASH }, + { MaterialType.Teeth, MATERIAL_BAKED_TEETH }, + { MaterialType.Tongue, MATERIAL_BAKED_TONGUE }, + { MaterialType.DefaultAlpha, MATERIAL_BAKED_ALPHACLIP }, + { MaterialType.DefaultOpaque, MATERIAL_BAKED_OPAQUE }, + }; + + + public static RenderPipeline GetRenderPipeline() + { +#if PIPELINE_HDRP + return RenderPipeline.HDRP; +#elif PIPELINE_URP + return RenderPipeline.URP; +#elif PIPELINE_3D + return RenderPipeline.Builtin; +#else + return RenderPipeline.Unknown; +#endif + } + + public static Shader GetDefaultShader() + { + return Shader.Find(SHADER_DEFAULT); + } + + public static Dictionary GetShaderDictionary() + { + return DICT_SHADERS; + } + + public static Dictionary GetMaterialDictionary(MaterialQuality quality) + { + if (quality == MaterialQuality.High) return DICT_MATERIALS_HQ; + else if (quality == MaterialQuality.Baked) return DICT_MATERIALS_BAKED; + return DICT_MATERIALS_DEFAULT; + } + + public static Material GetQualityMaterial(MaterialType materialType, MaterialQuality quality, CharacterInfo info) + { + if (info.Generation == BaseGeneration.ActorCore) + return Util.FindMaterial(MATERIAL_DEFAULT_SINGLE_MATERIAL); + + // option based overrides + if (materialType == MaterialType.Cornea && quality == MaterialQuality.High && info.qualRefractiveEyes) + return Util.FindMaterial(MATERIAL_HQ_CORNEA_REFRACTIVE); + + if (materialType == MaterialType.Hair && quality == MaterialQuality.Baked && info.bakeCustomShaders) + return Util.FindMaterial(MATERIAL_BAKED_HAIR_CUSTOM); + + if (materialType == MaterialType.Cornea && quality == MaterialQuality.Baked && info.qualRefractiveEyes) + return Util.FindMaterial(MATERIAL_BAKED_CORNEA_REFRACTIVE); + + if (materialType == MaterialType.Eye && quality == MaterialQuality.Baked && info.bakeCustomShaders) + return Util.FindMaterial(MATERIAL_BAKED_EYE_CUSTOM); + + if (materialType == MaterialType.EyeOcclusion && quality == MaterialQuality.Baked && info.bakeCustomShaders) + return Util.FindMaterial(MATERIAL_BAKED_EYE_OCCLUSION_CUSTOM); + + // fetch the material dictionary for this quality setting: + Dictionary materialDictionary = GetMaterialDictionary(quality); + + // return the material named in the dictionary... + if (materialDictionary != null && materialDictionary.ContainsKey(materialType)) + { + return Util.FindMaterial(materialDictionary[materialType]); + } + + return GetDefaultMaterial(quality); + } + + public static Material GetDefaultMaterial(MaterialQuality quality) + { + switch (quality) + { + case MaterialQuality.Baked: return Util.FindMaterial(MATERIAL_BAKED_OPAQUE); + case MaterialQuality.High: return Util.FindMaterial(MATERIAL_HQ_OPAQUE); + case MaterialQuality.Default: return Util.FindMaterial(MATERIAL_DEFAULT_OPAQUE); + } + + return null; + } + + public static Material GetTemplateMaterial(MaterialType materialType, MaterialQuality quality, CharacterInfo info) + { + Material template = GetQualityMaterial(materialType, quality, info); + + if (!template) + template = GetDefaultMaterial(quality); + + if (!template) + Debug.LogError("Unable to find Template Material for: " + materialType + "/" + quality); + + return template; + } + + public static bool IsShaderFor(string shaderName, params MaterialType[] materialType) + { + Dictionary shaderDictionary = GetShaderDictionary(); + + foreach (MaterialType type in materialType) + if (shaderName.iEndsWith(shaderDictionary[type])) + return true; + + return false; + } + } +} diff --git a/Editor/Pipeline.cs.meta b/Editor/Pipeline.cs.meta new file mode 100644 index 0000000..a29b979 --- /dev/null +++ b/Editor/Pipeline.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 07878c11d21e78444b8d41ed50240080 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Editor/QuickJSON.cs b/Editor/QuickJSON.cs new file mode 100644 index 0000000..0f96ec0 --- /dev/null +++ b/Editor/QuickJSON.cs @@ -0,0 +1,569 @@ +/* + * Copyright (C) 2021 Victor Soupday + * This file is part of CC3_Unity_Tools + * + * CC3_Unity_Tools is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * CC3_Unity_Tools is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with CC3_Unity_Tools. If not, see . + */ + +using System.Collections.Generic; +using System.Linq; +using UnityEngine; + +namespace Reallusion.Import +{ + public class QuickJSON + { + public List values; + public bool isArray = false; + + public int index = 0; + private string text; + + public enum NextType { None, OpenBrace, CloseBrace, OpenSquare, CloseSquare, Number, Alpha, String, Seperator, Comma } + + public QuickJSON(string jsonText, int startIndex = 0, bool array = false) + { + isArray = array; + text = jsonText; + index = startIndex; + values = new List(); + if (index == 0) Brace(); + Parse(); + text = null; + } + + void Parse() + { + string name = ""; + bool newPair = true; + + while (index < text.Length) + { + NextType type = Next(); + + switch (type) + { + case NextType.Comma: + name = ""; + newPair = true; + break; + + case NextType.Seperator: + newPair = false; + break; + + case NextType.CloseSquare: + return; + + case NextType.CloseBrace: + return; + + case NextType.OpenBrace: + QuickJSON childObject = new QuickJSON(text, index); + index = childObject.index; + values.Add(new MultiValue(name, childObject)); + break; + + case NextType.OpenSquare: + QuickJSON childArray = new QuickJSON(text, index, true); + index = childArray.index; + values.Add(new MultiValue(name, childArray)); + break; + + case NextType.Number: + ParseNumber(name); + break; + + case NextType.String: + if (!isArray && newPair) + { + name = String(); + newPair = false; + } + else + ParseString(name); + break; + + case NextType.Alpha: + ParseAlpha(name); + break; + } + } + } + + void ParseNumber(string name) + { + string value = Value(); + + if (int.TryParse(value, out int tryInt)) + values.Add(new MultiValue(name, tryInt)); + else if (float.TryParse(value, out float tryFloat)) + values.Add(new MultiValue(name, tryFloat)); + } + + void ParseAlpha(string name) + { + string value = Value(); + + if (bool.TryParse(value, out bool tryBool)) + values.Add(new MultiValue(name, tryBool)); + else + values.Add(new MultiValue(name, value)); + } + + void ParseString(string name) + { + string value = String(); + + values.Add(new MultiValue(name, value)); + } + + NextType Next() + { + while (index < text.Length) + { + char c = text[index++]; + + if (char.IsWhiteSpace(c)) continue; + if (char.IsDigit(c) || c == '-' || c == '+') { index--; return NextType.Number; } + if (IsAlpha(c)) { index--; return NextType.Alpha; } + + switch (c) + { + case ',': return NextType.Comma; + case ':': return NextType.Seperator; + case '{': return NextType.OpenBrace; + case '}': return NextType.CloseBrace; + case '[': return NextType.OpenSquare; + case ']': return NextType.CloseSquare; + case '"': + index--; + return NextType.String; + } + } + + return NextType.None; + } + + bool IsAlpha(char c) + { + return (c >= 'A' && c <= 'Z') || (c >= 'a' && c <= 'z'); + } + + string String() + { + int s = index + 1; + int e = text.IndexOf('"', s); + if (e > -1) + { + index = e + 1; + return text.Substring(s, e - s); + } + return ""; + } + + string Value() + { + int s = index; + + while (index < text.Length) + { + char c = text[index]; + if (char.IsWhiteSpace(c)) break; + if (c == ',' || c == '}' || c == ']') break; + index++; + } + + int e = index; + + return text.Substring(s, e - s); + } + + void Brace() + { + // set index after the next brace + index = text.IndexOf("{", index) + 1; + } + + public MultiValue GetValue(string name) + { + foreach (MultiValue mv in values) + if (mv.Key == name) return mv; + + return new MultiValue("", false); + } + + public MultiValue GetValue(int index) + { + if (values.Count > index) + return values[index]; + + return new MultiValue("", false); + } + + public QuickJSON FindObjectWithKey(string keySearch) + { + for (int i = 0; i < values.Count; i++) + { + if (values[i].Type == MultiType.Object) + { + if (values[i].Key.iContains(keySearch)) + { + return values[i].ObjectValue; + } + else + { + QuickJSON found = values[i].ObjectValue.FindObjectWithKey(keySearch); + if (found != null) return found; + } + } + } + + return null; + } + + public QuickJSON GetObjectAtPath(string path) + { + string[] paths = path.Split('/'); + + return GetObjectAtPath(paths); + } + + public QuickJSON GetObjectAtPath(string[] paths) + { + if (paths.Length > 0) + { + MultiValue mv = GetValue(paths[0]); + if (paths.Length > 1 && mv.Type == MultiType.Object) + return mv.ObjectValue.GetObjectAtPath(paths.Skip(1).ToArray()); + else if (mv.Type == MultiType.Object) + return mv.ObjectValue; + } + + return null; + } + + public bool GetBoolValue(string path) + { + string[] paths = path.Split('/'); + + return GetBoolValue(paths); + } + + public bool GetBoolValue(string[] paths) + { + if (paths.Length > 0) + { + MultiValue mv = GetValue(paths[0]); + if (paths.Length > 1 && mv.Type == MultiType.Object) + return mv.ObjectValue.GetBoolValue(paths.Skip(1).ToArray()); + else if (mv.Type == MultiType.Bool) + return mv.BoolValue; + } + + return false; + } + + public int GetIntValue(string path) + { + string[] paths = path.Split('/'); + + return GetIntValue(paths); + } + + public int GetIntValue(string[] paths) + { + if (paths.Length > 0) + { + MultiValue mv = GetValue(paths[0]); + if (paths.Length > 1 && mv.Type == MultiType.Object) + return mv.ObjectValue.GetIntValue(paths.Skip(1).ToArray()); + else if (mv.Type == MultiType.Integer) + return mv.IntValue; + } + + return 0; + } + + public float GetFloatValue(string path) + { + string[] paths = path.Split('/'); + + return GetFloatValue(paths); + } + + public float GetFloatValue(string[] paths) + { + if (paths.Length > 0) + { + MultiValue mv = GetValue(paths[0]); + if (paths.Length > 1 && mv.Type == MultiType.Object) + return mv.ObjectValue.GetFloatValue(paths.Skip(1).ToArray()); + else if (mv.Type == MultiType.Float) + return mv.FloatValue; + } + + return 0.0f; + } + + public string GetStringValue(string path) + { + string[] paths = path.Split('/'); + + return GetStringValue(paths); + } + + public string GetStringValue(string[] paths) + { + if (paths.Length > 0) + { + MultiValue mv = GetValue(paths[0]); + if (paths.Length > 1 && mv.Type == MultiType.Object) + return mv.ObjectValue.GetStringValue(paths.Skip(1).ToArray()); + else if (mv.Type == MultiType.String) + return mv.StringValue; + } + + return ""; + } + + public Color GetColorValue(string path) + { + string[] paths = path.Split('/'); + + return GetColorValue(paths); + } + + public Color GetColorValue(string[] paths) + { + if (paths.Length > 0) + { + MultiValue mv = GetValue(paths[0]); + if (paths.Length > 1 && mv.Type == MultiType.Object) + return mv.ObjectValue.GetColorValue(paths.Skip(1).ToArray()); + else if (mv.Type == MultiType.Object) + return mv.ObjectValue.ColorValue; + } + + return Color.white; + } + + public Vector3 GetVector3Value(string path) + { + string[] paths = path.Split('/'); + + return GetVector3Value(paths); + } + + public Vector3 GetVector3Value(string[] paths) + { + if (paths.Length > 0) + { + MultiValue mv = GetValue(paths[0]); + if (paths.Length > 1 && mv.Type == MultiType.Object) + return mv.ObjectValue.GetVector3Value(paths.Skip(1).ToArray()); + else if (mv.Type == MultiType.Object) + return mv.ObjectValue.Vector3Value; + } + + return Vector3.zero; + } + + public Vector3 GetVector2Value(string path) + { + string[] paths = path.Split('/'); + + return GetVector2Value(paths); + } + + public Vector3 GetVector2Value(string[] paths) + { + if (paths.Length > 0) + { + MultiValue mv = GetValue(paths[0]); + if (paths.Length > 1 && mv.Type == MultiType.Object) + return mv.ObjectValue.GetVector2Value(paths.Skip(1).ToArray()); + else if (mv.Type == MultiType.Object) + return mv.ObjectValue.Vector2Value; + } + + return Vector3.zero; + } + + public Color ColorValue + { + get + { + Color value = Color.black; + + if (isArray && values.Count == 3) + { + value.r = values[0].FloatValue / 255.0f; + value.g = values[1].FloatValue / 255.0f; + value.b = values[2].FloatValue / 255.0f; + } + + return value; + } + } + + public Vector3 Vector3Value + { + get + { + Vector3 value = Vector3.zero; + + if (isArray && values.Count == 3) + { + value.x = values[0].FloatValue; + value.y = values[1].FloatValue; + value.z = values[2].FloatValue; + } + + return value; + } + } + + public Vector2 Vector2Value + { + get + { + Vector2 value = Vector2.zero; + + if (isArray && values.Count == 2) + { + value.x = values[0].FloatValue; + value.y = values[1].FloatValue; + } + + return value; + } + } + + public QuickJSON FindParentOf(QuickJSON jsonObject) + { + for (int i = 0; i < values.Count; i++) + { + if (values[i].Type == MultiType.Object) + { + if (values[i].ObjectValue == jsonObject) + { + return this; + } + else + { + QuickJSON found = values[i].ObjectValue.FindParentOf(jsonObject); + if (found != null) + { + return found; + } + } + } + } + + return null; + } + + } + + public enum MultiType { Integer, Float, Bool, String, Object } + + public struct MultiValue + { + private object objectValue; + + public MultiType Type { get; } + public string Key { get; } + public bool BoolValue + { + get + { + return Type == MultiType.Bool ? + (bool)objectValue : false; + } + } + public string StringValue + { + get + { + return Type == MultiType.String ? + (string)objectValue : null; + } + } + public int IntValue + { + get + { + return Type == MultiType.Integer ? + (int)objectValue : + (Type == MultiType.Float ? + (int)((float)objectValue) : 0); + } + } + public float FloatValue + { + get + { + return Type == MultiType.Float ? + (float)objectValue : + (Type == MultiType.Integer ? + (float)((int)objectValue) : 0); + } + } + public QuickJSON ObjectValue + { + get + { + return Type == MultiType.Object ? + (QuickJSON)objectValue : null; + } + } + + public MultiValue(string name, bool value) + { + Key = name; + Type = MultiType.Bool; + objectValue = value; + } + + public MultiValue(string name, int value) + { + Key = name; + Type = MultiType.Integer; + objectValue = value; + } + + public MultiValue(string name, float value) + { + Key = name; + Type = MultiType.Float; + objectValue = value; + } + + public MultiValue(string name, string value) + { + Key = name; + Type = MultiType.String; + objectValue = value; + } + + public MultiValue(string name, QuickJSON value) + { + Key = name; + Type = MultiType.Object; + objectValue = value; + } + } + +} \ No newline at end of file diff --git a/Editor/QuickJSON.cs.meta b/Editor/QuickJSON.cs.meta new file mode 100644 index 0000000..96d70d8 --- /dev/null +++ b/Editor/QuickJSON.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: f2656459be33d0744b56cd6b29b1a76b +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Editor/RL.cs b/Editor/RL.cs new file mode 100644 index 0000000..2378370 --- /dev/null +++ b/Editor/RL.cs @@ -0,0 +1,627 @@ +/* + * Copyright (C) 2021 Victor Soupday + * This file is part of CC3_Unity_Tools + * + * CC3_Unity_Tools is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * CC3_Unity_Tools is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with CC3_Unity_Tools. If not, see . + */ + +using System.Collections.Generic; +using UnityEditor; +using UnityEngine; +using System; +using System.IO; +using UnityEditor.Animations; + +namespace Reallusion.Import +{ + public enum BaseGeneration + { + None, + Unknown, + GameBase, + G1, + G3, + G3Plus, + ActorCore + }; + + /// + /// Functions taken from old Reallusion AutoSetup... + /// + public class RL + { + // Applicable CC character generation: + + // Applicable CC Character Uid EBaseGeneration: + public static readonly Dictionary GENERATION_MAP = new Dictionary + { + { "RL_CC3_Plus", BaseGeneration.G3Plus }, + { "RL_CharacterCreator_Base_Game_G1_Divide_Eyelash_UV", BaseGeneration.GameBase }, + { "RL_CharacterCreator_Base_Game_G1_Multi_UV", BaseGeneration.GameBase }, + { "RL_CharacterCreator_Base_Game_G1_One_UV", BaseGeneration.GameBase }, + { "RL_CharacterCreator_Base_Std_G3", BaseGeneration.G3 }, + { "RL_G6_Standard_Series", BaseGeneration.G1 }, + { "NonStdLookAtDataCopyFromCCBase", BaseGeneration.ActorCore } + }; + + public static BaseGeneration GetCharacterGeneration(GameObject fbx, string name, QuickJSON jsonData) + { + QuickJSON characterData = jsonData?.GetObjectAtPath(name + "/Object/" + name); + string generation = characterData?.GetStringValue("Generation"); + if (!string.IsNullOrEmpty(generation)) + { + if (GENERATION_MAP.TryGetValue(generation, out BaseGeneration gen)) return gen; + } + else + { + if (fbx) + { + Transform[] children = fbx.transform.GetComponentsInChildren(true); + foreach (Transform child in children) + { + if (child.gameObject.name == "RootNode_0_") return BaseGeneration.ActorCore; + if (child.gameObject.name == "CC_Base_L_Pinky3") return BaseGeneration.G3; + if (child.gameObject.name == "pinky_03_l") return BaseGeneration.GameBase; + if (child.gameObject.name == "CC_Base_L_Finger42") return BaseGeneration.G1; + } + return BaseGeneration.G3; + } + else + { + QuickJSON jsonBaseBody = characterData.GetObjectAtPath("Meshes/CC_Base_Body"); + QuickJSON jsonG1BodyMaterial = characterData.GetObjectAtPath("Meshes/CC_Base_Body/Materials/Skin_Body"); + QuickJSON jsonG3BodyMaterial = characterData.GetObjectAtPath("Meshes/CC_Base_Body/Materials/Std_Skin_Body"); + QuickJSON jsonGameBodyMaterial = characterData.GetObjectAtPath("Meshes/CC_Base_Body/Materials/ga_skin_body"); + QuickJSON jsonGameBody = characterData.GetObjectAtPath("Meshes/CC_Game_Body"); + QuickJSON jsonGameTongue = characterData.GetObjectAtPath("Meshes/CC_Game_Tongue"); + QuickJSON jsonActorCoreMaterial = characterData.GetObjectAtPath("Meshes/CC_Game_Body/Materials/Character_Pbr"); + + if (jsonBaseBody != null) + { + if (jsonG3BodyMaterial != null) + return BaseGeneration.G3; + else if (jsonGameBodyMaterial != null) + return BaseGeneration.GameBase; + else if (jsonG1BodyMaterial != null) + return BaseGeneration.G1; + else if (jsonActorCoreMaterial != null) + return BaseGeneration.ActorCore; + } + else if (jsonGameBody != null || jsonGameTongue != null) + if (jsonActorCoreMaterial != null) + return BaseGeneration.ActorCore; + else + return BaseGeneration.GameBase; + } + } + return BaseGeneration.Unknown; + } + + public static void HumanoidImportSettings(GameObject fbx, ModelImporter importer, string characterName, BaseGeneration generation, QuickJSON jsonData) + { + importer.importNormals = ModelImporterNormals.Calculate; + importer.importTangents = ModelImporterTangents.CalculateMikk; + importer.importBlendShapes = true; + importer.importBlendShapeNormals = ModelImporterNormals.Calculate; + importer.generateAnimations = ModelImporterGenerateAnimations.GenerateAnimations; + importer.animationType = ModelImporterAnimationType.Human; + importer.avatarSetup = ModelImporterAvatarSetup.CreateFromThisModel; + importer.autoGenerateAvatarMappingIfUnspecified = true; + + if (generation == BaseGeneration.Unknown) + { + if (!characterName.Contains("_Motion")) + importer.animationType = ModelImporterAnimationType.Generic; + return; + } + + HumanDescription human = importer.humanDescription; + Func Bone = (humanName, boneName) => new HumanBone() + { + humanName = humanName, + boneName = boneName + }; + + #region HumanBoneDescription + if (generation == BaseGeneration.G3 || + generation == BaseGeneration.G3Plus || + generation == BaseGeneration.ActorCore) + { + human.human = new[] { + Bone("Chest", "CC_Base_Spine01"), + Bone("Head", "CC_Base_Head"), + Bone("Hips", "CC_Base_Hip"), + Bone("Jaw", "CC_Base_JawRoot"), + Bone("Left Index Distal", "CC_Base_L_Index3"), + Bone("Left Index Intermediate", "CC_Base_L_Index2"), + Bone("Left Index Proximal", "CC_Base_L_Index1"), + Bone("Left Little Distal","CC_Base_L_Pinky3"), + Bone("Left Little Intermediate","CC_Base_L_Pinky2"), + Bone("Left Little Proximal","CC_Base_L_Pinky1"), + Bone("Left Middle Distal", "CC_Base_L_Mid3"), + Bone("Left Middle Intermediate", "CC_Base_L_Mid2"), + Bone("Left Middle Proximal", "CC_Base_L_Mid1"), + Bone("Left Ring Distal", "CC_Base_L_Ring3"), + Bone("Left Ring Intermediate", "CC_Base_L_Ring2"), + Bone("Left Ring Proximal", "CC_Base_L_Ring1"), + Bone("Left Thumb Distal", "CC_Base_L_Thumb3"), + Bone("Left Thumb Intermediate", "CC_Base_L_Thumb2"), + Bone("Left Thumb Proximal", "CC_Base_L_Thumb1"), + Bone("LeftEye","CC_Base_L_Eye"), + Bone("LeftFoot", "CC_Base_L_Foot"), + Bone("LeftHand", "CC_Base_L_Hand"), + Bone("LeftLowerArm", "CC_Base_L_Forearm"), + Bone("LeftLowerLeg", "CC_Base_L_Calf"), + Bone("LeftShoulder", "CC_Base_L_Clavicle"), + Bone("LeftToes", "CC_Base_L_ToeBase"), + Bone("LeftUpperArm", "CC_Base_L_Upperarm"), + Bone("LeftUpperLeg", "CC_Base_L_Thigh"), + Bone("Neck", "CC_Base_NeckTwist01"), + Bone("Right Index Distal", "CC_Base_R_Index3"), + Bone("Right Index Intermediate", "CC_Base_R_Index2"), + Bone("Right Index Proximal", "CC_Base_R_Index1"), + Bone("Right Little Distal","CC_Base_R_Pinky3"), + Bone("Right Little Intermediate","CC_Base_R_Pinky2"), + Bone("Right Little Proximal","CC_Base_R_Pinky1"), + Bone("Right Middle Distal", "CC_Base_R_Mid3"), + Bone("Right Middle Intermediate", "CC_Base_R_Mid2"), + Bone("Right Middle Proximal", "CC_Base_R_Mid1"), + Bone("Right Ring Distal", "CC_Base_R_Ring3"), + Bone("Right Ring Intermediate", "CC_Base_R_Ring2"), + Bone("Right Ring Proximal", "CC_Base_R_Ring1"), + Bone("Right Thumb Distal", "CC_Base_R_Thumb3"), + Bone("Right Thumb Intermediate", "CC_Base_R_Thumb2"), + Bone("Right Thumb Proximal", "CC_Base_R_Thumb1"), + Bone("RightEye","CC_Base_R_Eye"), + Bone("RightFoot", "CC_Base_R_Foot"), + Bone("RightHand", "CC_Base_R_Hand"), + Bone("RightLowerArm", "CC_Base_R_Forearm"), + Bone("RightLowerLeg", "CC_Base_R_Calf"), + Bone("RightShoulder", "CC_Base_R_Clavicle"), + Bone("RightToes", "CC_Base_R_ToeBase"), + Bone("RightUpperArm", "CC_Base_R_Upperarm"), + Bone("RightUpperLeg", "CC_Base_R_Thigh"), + Bone("Spine", "CC_Base_Waist"), + Bone("UpperChest", "CC_Base_Spine02"), + }; + } + else if (generation == BaseGeneration.G1) + { + human.human = new[] { + Bone("Chest", "CC_Base_Spine01"), + Bone("Head", "CC_Base_Head"), + Bone("Hips", "CC_Base_Hip"), + Bone("Jaw", "CC_Base_JawRoot"), + Bone("Left Index Distal", "CC_Base_L_Finger12"), + Bone("Left Index Intermediate", "CC_Base_L_Finger11"), + Bone("Left Index Proximal", "CC_Base_L_Finger10"), + Bone("Left Little Distal","CC_Base_L_Finger42"), + Bone("Left Little Intermediate","CC_Base_L_Finger41"), + Bone("Left Little Proximal","CC_Base_L_Finger40"), + Bone("Left Middle Distal", "CC_Base_L_Finger22"), + Bone("Left Middle Intermediate", "CC_Base_L_Finger21"), + Bone("Left Middle Proximal", "CC_Base_L_Finger20"), + Bone("Left Ring Distal", "CC_Base_L_Finger32"), + Bone("Left Ring Intermediate", "CC_Base_L_Finger31"), + Bone("Left Ring Proximal", "CC_Base_L_Finger30"), + Bone("Left Thumb Distal", "CC_Base_L_Finger02"), + Bone("Left Thumb Intermediate", "CC_Base_L_Finger01"), + Bone("Left Thumb Proximal", "CC_Base_L_Finger00"), + Bone("LeftEye","CC_Base_L_Eye"), + Bone("LeftFoot", "CC_Base_L_Foot"), + Bone("LeftHand", "CC_Base_L_Hand"), + Bone("LeftLowerArm", "CC_Base_L_Forearm"), + Bone("LeftLowerLeg", "CC_Base_L_Calf"), + Bone("LeftShoulder", "CC_Base_L_Clavicle"), + Bone("LeftToes", "CC_Base_L_ToeBase"), + Bone("LeftUpperArm", "CC_Base_L_Upperarm"), + Bone("LeftUpperLeg", "CC_Base_L_Thigh"), + Bone("Neck", "CC_Base_NeckTwist01"), + Bone("Right Index Distal", "CC_Base_R_Finger12"), + Bone("Right Index Intermediate", "CC_Base_R_Finger11"), + Bone("Right Index Proximal", "CC_Base_R_Finger10"), + Bone("Right Little Distal","CC_Base_R_Finger42"), + Bone("Right Little Intermediate","CC_Base_R_Finger41"), + Bone("Right Little Proximal","CC_Base_R_Finger40"), + Bone("Right Middle Distal", "CC_Base_R_Finger22"), + Bone("Right Middle Intermediate", "CC_Base_R_Finger21"), + Bone("Right Middle Proximal", "CC_Base_R_Finger20"), + Bone("Right Ring Distal", "CC_Base_R_Finger32"), + Bone("Right Ring Intermediate", "CC_Base_R_Finger31"), + Bone("Right Ring Proximal", "CC_Base_R_Finger30"), + Bone("Right Thumb Distal", "CC_Base_R_Finger02"), + Bone("Right Thumb Intermediate", "CC_Base_R_Finger01"), + Bone("Right Thumb Proximal", "CC_Base_R_Finger00"), + Bone("RightEye","CC_Base_R_Eye"), + Bone("RightFoot", "CC_Base_R_Foot"), + Bone("RightHand", "CC_Base_R_Hand"), + Bone("RightLowerArm", "CC_Base_R_Forearm"), + Bone("RightLowerLeg", "CC_Base_R_Calf"), + Bone("RightShoulder", "CC_Base_R_Clavicle"), + Bone("RightToes", "CC_Base_R_ToeBase"), + Bone("RightUpperArm", "CC_Base_R_Upperarm"), + Bone("RightUpperLeg", "CC_Base_R_Thigh"), + Bone("Spine", "CC_Base_Waist"), + Bone("UpperChest", "CC_Base_Spine02"), + }; + } + else if (generation == BaseGeneration.GameBase) + { + human.human = new[] { + Bone("Chest", "spine_02"), + Bone("Head", "head"), + Bone("Hips", "pelvis"), + Bone("Jaw", "CC_Base_JawRoot"), + Bone("Left Index Distal", "index_03_l"), + Bone("Left Index Intermediate", "index_02_l"), + Bone("Left Index Proximal", "index_01_l"), + Bone("Left Little Distal","pinky_03_l"), + Bone("Left Little Intermediate","pinky_02_l"), + Bone("Left Little Proximal","pinky_01_l"), + Bone("Left Middle Distal", "middle_03_l"), + Bone("Left Middle Intermediate", "middle_02_l"), + Bone("Left Middle Proximal", "middle_01_l"), + Bone("Left Ring Distal", "ring_03_l"), + Bone("Left Ring Intermediate", "ring_02_l"), + Bone("Left Ring Proximal", "ring_01_l"), + Bone("Left Thumb Distal", "thumb_03_l"), + Bone("Left Thumb Intermediate", "thumb_02_l"), + Bone("Left Thumb Proximal", "thumb_01_l"), + Bone("LeftEye","CC_Base_L_Eye"), + Bone("LeftFoot", "foot_l"), + Bone("LeftHand", "hand_l"), + Bone("LeftLowerArm", "lowerarm_l"), + Bone("LeftLowerLeg", "calf_l"), + Bone("LeftShoulder", "clavicle_l"), + Bone("LeftToes", "ball_l"), + Bone("LeftUpperArm", "upperarm_l"), + Bone("LeftUpperLeg", "thigh_l"), + Bone("Neck", "neck_01"), + Bone("Right Index Distal", "index_03_r"), + Bone("Right Index Intermediate", "index_02_r"), + Bone("Right Index Proximal", "index_01_r"), + Bone("Right Little Distal","pinky_03_r"), + Bone("Right Little Intermediate","pinky_02_r"), + Bone("Right Little Proximal","pinky_01_r"), + Bone("Right Middle Distal", "middle_03_r"), + Bone("Right Middle Intermediate", "middle_02_r"), + Bone("Right Middle Proximal", "middle_01_r"), + Bone("Right Ring Distal", "ring_03_r"), + Bone("Right Ring Intermediate", "ring_02_r"), + Bone("Right Ring Proximal", "ring_01_r"), + Bone("Right Thumb Distal", "thumb_03_r"), + Bone("Right Thumb Intermediate", "thumb_02_r"), + Bone("Right Thumb Proximal", "thumb_01_r"), + Bone("RightEye","CC_Base_R_Eye"), + Bone("RightFoot", "foot_r"), + Bone("RightHand", "hand_r"), + Bone("RightLowerArm", "lowerarm_r"), + Bone("RightLowerLeg", "calf_r"), + Bone("RightShoulder", "clavicle_r"), + Bone("RightToes", "ball_r"), + Bone("RightUpperArm", "upperarm_r"), + Bone("RightUpperLeg", "thigh_r"), + Bone("Spine", "spine_01"), + Bone("UpperChest", "spine_03"), + }; + } + #endregion + + for (int i = 0; i < human.human.Length; ++i) + { + human.human[i].limit.useDefaultValues = true; + } + + human.upperArmTwist = 0.5f; + human.lowerArmTwist = 0.5f; + human.upperLegTwist = 0.5f; + human.lowerLegTwist = 0.5f; + human.armStretch = 0.05f; + human.legStretch = 0.05f; + human.feetSpacing = 0.0f; + human.hasTranslationDoF = false; + + if (jsonData != null || !characterName.iContains("_Motion")) + { + Transform[] transforms = fbx.GetComponentsInChildren(); + SkeletonBone[] bones = new SkeletonBone[transforms.Length]; + for (int i = 0; i < transforms.Length; i++) + { + bones[i].name = transforms[i].name; + bones[i].position = transforms[i].localPosition; + bones[i].rotation = transforms[i].localRotation; + bones[i].scale = transforms[i].localScale; + } + human.skeleton = bones; + } + + importer.humanDescription = human; + } + + /* + * Create an Animator and apply an FBX animation to it. + * [in] kFbxObject: Fbx target object + * [in] assetPath: Fbx asset path + */ + public static void AutoCreateAnimator(GameObject fbx, string assetPath, ModelImporter importer) + { + string animatorPath = Path.GetDirectoryName(assetPath) + "/" + fbx.name + "_animator.controller"; + + /* + if (!fbx.GetComponent()) + { + fbx.AddComponent(); + fbx.GetComponent().avatar = AvatarBuilder.BuildHumanAvatar(fbx, importer.humanDescription); + fbx.GetComponent().applyRootMotion = true; + fbx.GetComponent().cullingMode = AnimatorCullingMode.CullUpdateTransforms; + }*/ + + + ModelImporterClipAnimation[] clipAnimations = importer.defaultClipAnimations; + + if (clipAnimations.Length != 0) + { + if (File.Exists(animatorPath)) return; + AnimatorController.CreateAnimatorControllerAtPath(animatorPath); + AnimatorController controller = AssetDatabase.LoadAssetAtPath(animatorPath); + AnimatorStateMachine stateMachine = controller.layers[0].stateMachine; + + UnityEngine.Object[] assets = AssetDatabase.LoadAllAssetsAtPath(assetPath); + foreach (UnityEngine.Object obj in assets) + { + AnimationClip clip = obj as AnimationClip; + + if (clip) + { + if (clip.name.iContains("__preview__") || clip.name.iContains("t-pose")) + continue; + + controller.AddMotion(clip, 0); + } + } + + if (AssetDatabase.WriteImportSettingsIfDirty(assetPath)) + { + AssetDatabase.SaveAssets(); + AssetDatabase.Refresh(); + } + } + } + + /* + * Set the Animation parameters. + * [in] kImporter: Model import settings + */ + public static void SetAnimation(ModelImporter importer, string assetPath) + { + if (importer.defaultClipAnimations.Length > 0) + { + if (importer.clipAnimations == null || importer.clipAnimations.Length == 0) + importer.clipAnimations = importer.defaultClipAnimations; + } + + ModelImporterClipAnimation[] animations = importer.clipAnimations; + if (animations == null) return; + + bool changed = false; + + foreach (ModelImporterClipAnimation anim in animations) + { + if (!anim.keepOriginalOrientation || !anim.keepOriginalPositionY || !anim.keepOriginalPositionXZ || + !anim.lockRootRotation || !anim.lockRootHeightY) + { + anim.keepOriginalOrientation = true; + anim.keepOriginalPositionY = true; + anim.keepOriginalPositionXZ = true; + anim.lockRootRotation = true; + anim.lockRootHeightY = true; + changed = true; + } + + if (anim.name.iContains("idle") && !anim.lockRootPositionXZ) + { + anim.lockRootPositionXZ = true; + changed = true; + } + + if (anim.name.iContains("_loop") && !anim.loopTime) + { + anim.loopTime = true; + changed = true; + } + } + + if (changed) + { + importer.clipAnimations = animations; + AssetDatabase.WriteImportSettingsIfDirty(assetPath); + AssetDatabase.SaveAssets(); + AssetDatabase.Refresh(); + } + } + + public static void SetAnimationImport(CharacterInfo info) + { + string assetPath = info.path; + ModelImporter importer = (ModelImporter)AssetImporter.GetAtPath(info.path); + + // set humanoid animation type + //CC3Util.HumanoidImportSettings(fbx, importer, characterName, generation, jsonData); + + SetAnimation(importer, info.path); + + AutoCreateAnimator(info.fbx, info.path, importer); + + AssetDatabase.SaveAssets(); + AssetDatabase.Refresh(); + + CreatePrefabFromFbx(info); + + //System.Media.SystemSounds.Asterisk.Play(); + } + + public static void CreatePrefabFromFbx(CharacterInfo info) + { + bool noMotion = !info.name.iContains("_Motion"); + + if (noMotion) + { + // Set the Prefab + if (info.path.iContains("_lod")) + { + CreateOneLODPrefabFromModel(info); + } + else + { + CreatePrefabFromModel(info); + } + } + } + + public static void CreatePrefabFromModel(CharacterInfo info) + { + // Create a Prefab folder: + string prefabFolder = Util.CreateFolder(info.folder, Importer.PREFABS_FOLDER); + string namedPrefabFolder = Util.CreateFolder(prefabFolder, info.name); + string prefabPath = Path.Combine(namedPrefabFolder, info.name + ".prefab"); + string animatorControllerPath = Path.Combine(info.folder, info.name + "_animator.controller"); + + // Apply to the scene: + GameObject prefabTemp = null; + if (File.Exists(prefabPath)) + { + try + { + var existingPrefab = AssetDatabase.LoadAssetAtPath(prefabPath) as GameObject; + prefabTemp = GameObject.Instantiate(existingPrefab, null); + } + catch { } + } + + if (!prefabTemp) prefabTemp = GameObject.Instantiate(info.fbx, null); + + + // Apply Animator: + if (!prefabTemp.GetComponent().runtimeAnimatorController) + { + if (File.Exists(animatorControllerPath)) + prefabTemp.GetComponent().runtimeAnimatorController = + AssetDatabase.LoadAssetAtPath(animatorControllerPath); + + prefabTemp.GetComponent().applyRootMotion = true; + prefabTemp.GetComponent().cullingMode = AnimatorCullingMode.CullUpdateTransforms; + PrefabUtility.SaveAsPrefabAsset(prefabTemp, prefabPath); + } + + UnityEngine.Object.DestroyImmediate(prefabTemp); + } + + + public static void CreateOneLODPrefabFromModel(CharacterInfo info) + { + GameObject lodObject = new GameObject(); + LODGroup lodGroup = lodObject.AddComponent(); + string prefabFolder = Util.CreateFolder(info.folder, Importer.PREFABS_FOLDER); + string namedPrefabFolder = Util.CreateFolder(prefabFolder, info.name); + string prefabPath = Path.Combine(namedPrefabFolder, info.name + ".prefab"); + string animatorControllerPath = Path.Combine(info.folder, info.name + "_animator.controller"); + + Renderer[] renderers = info.fbx.transform.GetComponentsInChildren(true); + int lodLevel = 0; + foreach (Renderer child in renderers) + { + if (child.name.Contains("_LOD")) + { + string level = child.name.Substring((child.name.Length - 1), 1); + lodLevel = Math.Max(lodLevel, int.Parse(level)); + } + } + + if (renderers.Length == lodLevel) + { + LOD[] lods = new LOD[lodLevel]; + GameObject lodPrefabTemp = PrefabUtility.InstantiatePrefab(info.fbx) as GameObject; + lodPrefabTemp.transform.SetParent(lodObject.transform, false); + Renderer[] prefabRenderers = lodPrefabTemp.transform.GetComponentsInChildren(true); + + for (int i = 0; i < lodLevel; ++i) // Does not process LOD0 + { + string LODLevel = "_LOD" + (i + 1); + for (int j = 0; j < prefabRenderers.Length; j++) + { + if (prefabRenderers[j].name.Contains(LODLevel)) + { + Renderer[] rendererLOD = new Renderer[1]; + rendererLOD[0] = prefabRenderers[j]; + lods[i] = new LOD(1.0F / (i + 2), rendererLOD); + } + + if (i == lodLevel - 1) + { + lods[i].screenRelativeTransitionHeight = (0.02f); + } + } + } + + lodGroup.SetLODs(lods); + lodGroup.RecalculateBounds(); + } + else + { + lodLevel++; + LOD[] lods = new LOD[lodLevel]; + GameObject lodPrefabTemp = PrefabUtility.InstantiatePrefab(info.fbx) as GameObject; + lodPrefabTemp.transform.SetParent(lodObject.transform, false); + Renderer[] prefabRenderers = lodPrefabTemp.transform.GetComponentsInChildren(true); + + if (File.Exists(animatorControllerPath)) + lodPrefabTemp.GetComponent().runtimeAnimatorController = + AssetDatabase.LoadAssetAtPath(animatorControllerPath); + + List renderersListLOD0 = new List(); + for (int i = 0; i < prefabRenderers.Length; i++) // Process LOD0 + { + if (!prefabRenderers[i].name.Contains("_LOD")) + { + renderersListLOD0.Add(prefabRenderers[i]); + } + } + Renderer[] renderersLOD0 = renderersListLOD0.ToArray(); + lods[0] = new LOD((1.0F / (2)), renderersLOD0); + for (int i = 1; i < lodLevel; i++) + { + string LODLevel = "_LOD" + i; + for (int j = 0; j < prefabRenderers.Length; j++) + { + if (prefabRenderers[j].name.Contains(LODLevel)) + { + Renderer[] rendererLOD = new Renderer[1]; + rendererLOD[0] = prefabRenderers[j]; + lods[i] = new LOD(1.0F / (i + 2), rendererLOD); + } + if (i == lodLevel - 1) + { + lods[i].screenRelativeTransitionHeight = (0.02f); + } + } + } + lodGroup.SetLODs(lods); + lodGroup.RecalculateBounds(); + } + + PrefabUtility.SaveAsPrefabAsset(lodObject, prefabPath); + UnityEngine.Object.DestroyImmediate(lodObject); + } + } +} \ No newline at end of file diff --git a/Editor/RL.cs.meta b/Editor/RL.cs.meta new file mode 100644 index 0000000..5bfb3bb --- /dev/null +++ b/Editor/RL.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 02225ff7daea3bf4e983b62a68db6ee3 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Editor/Util.cs b/Editor/Util.cs new file mode 100644 index 0000000..99930f5 --- /dev/null +++ b/Editor/Util.cs @@ -0,0 +1,543 @@ +/* + * Copyright (C) 2021 Victor Soupday + * This file is part of CC3_Unity_Tools + * + * CC3_Unity_Tools is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * CC3_Unity_Tools is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with CC3_Unity_Tools. If not, see . + */ + +using System.IO; +using System.Collections.Generic; +using UnityEngine; +using UnityEditor; +using UnityEditor.SceneManagement; + +namespace Reallusion.Import +{ + public static class Util + { + public static bool iEquals(this string a, string b) + { + return a.Equals(b, System.StringComparison.InvariantCultureIgnoreCase); + } + + public static bool iContains(this string a, string b) + { + return a.ToLowerInvariant().Contains(b.ToLowerInvariant()); + } + + public static bool iStartsWith(this string a, string b) + { + return a.StartsWith(b, System.StringComparison.InvariantCultureIgnoreCase); + } + + public static bool iEndsWith(this string a, string b) + { + return a.EndsWith(b, System.StringComparison.InvariantCultureIgnoreCase); + } + + public static void SetRemapRange(this Material mat, string shaderRef, float from, float to) + { + Color range; + range.r = from; + range.g = to; + range.b = 0f; + range.a = 0f; + mat.SetColor(shaderRef, range); + } + + public static bool ImportCharacter(CharacterInfo info, MaterialQuality quality) + { + Importer importCharacter = new Importer(info); + importCharacter.SetQuality(quality); + + return importCharacter.Import(); + } + + + public static bool IsCC3Character(Object obj) + { + if (!obj) return false; + string assetPath = AssetDatabase.GetAssetPath(obj).ToLower(); + if (string.IsNullOrEmpty(assetPath)) return false; + return IsCC3Character(AssetDatabase.AssetPathToGUID(assetPath)); + } + + public static bool IsCC3Character(string guid) + { + string assetPath = AssetDatabase.GUIDToAssetPath(guid); + string assetFolder = Path.GetDirectoryName(assetPath); + if (AssetDatabase.IsValidFolder(assetFolder)) + { + if (assetPath.EndsWith(".fbx", System.StringComparison.InvariantCultureIgnoreCase)) + { + string assetName = Path.GetFileNameWithoutExtension(assetPath); + string[] searchFolders = { assetFolder }; + + if (GetJSONAsset(assetName, searchFolders) != null) + { + if (AssetDatabase.IsValidFolder(Path.Combine(assetFolder, "textures", assetName))) + { + return true; + } + } + } + } + return false; + } + + public static Color LinearTosRGBOld(Color c) + { + if (c.r < 0f) c.r = 0f; + if (c.g < 0f) c.g = 0f; + if (c.b < 0f) c.b = 0f; + c.r = Mathf.Max(1.055f * Mathf.Pow(c.r, 0.416666667f) - 0.055f, 0f); + c.g = Mathf.Max(1.055f * Mathf.Pow(c.g, 0.416666667f) - 0.055f, 0f); + c.b = Mathf.Max(1.055f * Mathf.Pow(c.b, 0.416666667f) - 0.055f, 0f); + return c; + } + + public static float LinearTosRGB(float c) + { + float lo = c * 12.92f; + float hi = (Mathf.Pow(Mathf.Max(Mathf.Abs(c), 1.192092896e-07f), (1.0f / 2.4f)) * 1.055f) - 0.055f; + return c <= 0.0031308f ? lo : hi; + } + + public static Color LinearTosRGB(Color c) + { + return new Color(LinearTosRGB(c.r), LinearTosRGB(c.g), LinearTosRGB(c.b), c.a); + } + + public static Color sRGBToLinear(Color c) + { + Vector3 linearRGBLo; + linearRGBLo.x = c.r / 12.92f; + linearRGBLo.y = c.g / 12.92f; + linearRGBLo.z = c.b / 12.92f; + + Vector3 linearRGBHi; + linearRGBHi.x = Mathf.Pow(Mathf.Max(Mathf.Abs((c.r + 0.055f) / 1.055f), 1.192092896e-07f), 2.4f); + linearRGBHi.y = Mathf.Pow(Mathf.Max(Mathf.Abs((c.g + 0.055f) / 1.055f), 1.192092896e-07f), 2.4f); + linearRGBHi.z = Mathf.Pow(Mathf.Max(Mathf.Abs((c.b + 0.055f) / 1.055f), 1.192092896e-07f), 2.4f); + + c.r = (c.r <= 0.04045f) ? linearRGBLo.x : linearRGBHi.x; + c.g = (c.g <= 0.04045f) ? linearRGBLo.y : linearRGBHi.y; + c.b = (c.b <= 0.04045f) ? linearRGBLo.z : linearRGBHi.z; + + return c; + } + + public static Color ScaleRGB(this Color c, float scale) + { + float a = c.a; + c *= scale; + c.a = a; + return c; + } + + public static TextAsset GetJSONAsset(string name, string[] folders) + { + string[] foundGUIDs = AssetDatabase.FindAssets(name, folders); + foreach (string guid in foundGUIDs) + { + string assetPath = AssetDatabase.GUIDToAssetPath(guid); + if (assetPath.EndsWith(".json", System.StringComparison.InvariantCultureIgnoreCase)) + return AssetDatabase.LoadAssetAtPath(assetPath); + } + return null; + } + + public static List GetValidCharacterGUIDS() + { + string[] guids = AssetDatabase.FindAssets("t:Model", new string[] { "Assets" }); + List results = new List(); + + foreach (string g in guids) + { + if (IsCC3Character(g)) + { + results.Add(g); + } + } + + return results; + } + + public static void ImportPaths(List paths) + { + List done = new List(); + foreach (string path in paths) + { + if (!string.IsNullOrEmpty(path) && !done.Contains(path)) + { + AssetDatabase.WriteImportSettingsIfDirty(path); + AssetDatabase.ImportAsset(path, ImportAssetOptions.ForceUpdate); + done.Add(path); + } + } + } + + public static string CreateFolder(string path, string name) + { + string folderPath = Path.Combine(path, name); + + if (AssetDatabase.IsValidFolder(folderPath)) + { + return folderPath; + } + + string guid = AssetDatabase.CreateFolder(path, name); + return AssetDatabase.GUIDToAssetPath(guid); + } + + public static bool EnsureAssetsFolderExists(string folder) + { + if (string.IsNullOrEmpty(folder)) return true; + if (AssetDatabase.IsValidFolder(folder)) return true; + if (folder.Equals("Assets", System.StringComparison.InvariantCultureIgnoreCase)) return true; + + string parentFolder = Path.GetDirectoryName(folder); + string folderName = Path.GetFileName(folder); + + if (EnsureAssetsFolderExists(parentFolder)) + { + AssetDatabase.CreateFolder(parentFolder, folderName); + return true; + } + + return false; + } + + public static string GetRelativePath(string fullPath) + { + fullPath = Path.GetFullPath(fullPath); + string basePath = Path.GetFullPath(Path.GetDirectoryName(Application.dataPath)); + + string[] fullSplit = fullPath.Split('\\'); + string[] baseSplit = basePath.Split('\\'); + + int sharedRootIndex = -1; + + for (int i = 0; i < baseSplit.Length; i++) + { + if (fullSplit[i] == baseSplit[i]) + sharedRootIndex = i; + else + break; + } + + if (sharedRootIndex == -1) return fullPath; + + string relativePath = ""; + + for (int i = sharedRootIndex + 1; i < fullSplit.Length - 1; i++) + { + relativePath += fullSplit[i] + "\\"; + } + relativePath += fullSplit[fullSplit.Length - 1]; + + return relativePath; + } + + public static ComputeShader FindComputeShader(string name) + { + string[] shaderGuids = AssetDatabase.FindAssets("t:computeshader"); + + foreach (string guid in shaderGuids) + { + string path = AssetDatabase.GUIDToAssetPath(guid); + ComputeShader shader = AssetDatabase.LoadAssetAtPath(path); + if (shader != null) + { + if (shader.name.EndsWith(name, System.StringComparison.InvariantCultureIgnoreCase)) + { + return shader; + } + } + } + + return null; + } + + public static Material FindMaterial(string name, string[] folders = null) + { + if (folders == null) folders = new string[] { "Assets", "Packages" }; + + string[] guids = AssetDatabase.FindAssets("t:material", folders); + + foreach (string guid in guids) + { + string path = AssetDatabase.GUIDToAssetPath(guid); + Material mat = AssetDatabase.LoadAssetAtPath(path); + if (mat) + { + if (mat.name.EndsWith(name, System.StringComparison.InvariantCultureIgnoreCase)) + { + return mat; + } + } + } + + return null; + } + + public static Texture2D FindTexture(string[] folders, string search) + { + string[] texGuids; + + texGuids = AssetDatabase.FindAssets("t:texture2d", folders); + + foreach (string guid in texGuids) + { + string assetPath = AssetDatabase.GUIDToAssetPath(guid); + string texName = Path.GetFileNameWithoutExtension(assetPath); + if (texName.EndsWith(search, System.StringComparison.CurrentCultureIgnoreCase)) + { + return AssetDatabase.LoadAssetAtPath(assetPath); + } + } + + return null; + } + + public static GameObject FindPreviewScenePrefab() + { + string[] texGuids; + + texGuids = AssetDatabase.FindAssets("t:prefab PreviewScenePrefab"); + + foreach (string guid in texGuids) + { + string assetPath = AssetDatabase.GUIDToAssetPath(guid); + string name = Path.GetFileNameWithoutExtension(assetPath); + if (name.Equals("PreviewScenePrefab", System.StringComparison.InvariantCultureIgnoreCase)) + { + return AssetDatabase.LoadAssetAtPath(assetPath); + } + } + + return null; + } + + public static string GetSourceMaterialName(string fbxPath, Material sharedMaterial) + { + ModelImporter importer = (ModelImporter)AssetImporter.GetAtPath(fbxPath); + Dictionary importerRemaps = importer.GetExternalObjectMap(); + + foreach (KeyValuePair pair in importerRemaps) + { + if (pair.Value == sharedMaterial) return pair.Key.name; + } + + return sharedMaterial.name; + } + + // example functions + // from unity docs + public static void ExtractFromAsset(Object subAsset, string destinationPath) + { + string assetPath = AssetDatabase.GetAssetPath(subAsset); + + var clone = Object.Instantiate(subAsset); + AssetDatabase.CreateAsset(clone, destinationPath); + + var assetImporter = AssetImporter.GetAtPath(assetPath); + assetImporter.AddRemap(new AssetImporter.SourceAssetIdentifier(subAsset), clone); + + AssetDatabase.WriteImportSettingsIfDirty(assetPath); + AssetDatabase.ImportAsset(assetPath, ImportAssetOptions.ForceUpdate); + } + + public static void DoTest(Object asset) + { + string assetPath = AssetDatabase.GetAssetPath(asset); + + Object[] objects = AssetDatabase.LoadAllAssetsAtPath(assetPath); + + foreach (Object o in objects) + { + Debug.Log(o); + } + } + + public static string GetShaderName(Material mat) + { + if (mat && mat.shader) + { + string[] split = mat.shader.name.Split('/'); + return split[split.Length - 1]; + } + + return "None"; + } + + public static string[] GetLinkedMaterialNames(string name) + { + name = name.ToLowerInvariant(); + + if (name.Contains("std_eye_occlusion_")) return new[] { "std_eye_occlusion_l", "std_eye_occlusion_r" }; + if (name.Contains("std_skin_head") || name.Contains("std_skin_body") || + name.Contains("std_skin_arm") || name.Contains("std_skin_leg")) + return new[] { "std_skin_head", "std_skin_body", "std_skin_arm", "std_skin_leg" }; + return null; + } + + public static int GetLinkedMaterialIndex(string sourceName, string shaderName) + { + if ((shaderName.iContains(Pipeline.SHADER_HQ_HEAD) || + shaderName.iContains(Pipeline.SHADER_HQ_SKIN)) && + !sourceName.iContains("Std_Nails")) return 0; + if (shaderName.iContains(Pipeline.SHADER_HQ_EYE) || + shaderName.iContains(Pipeline.SHADER_HQ_CORNEA)) return 1; + if (shaderName.iContains(Pipeline.SHADER_HQ_EYE_OCCLUSION)) return 2; + if (shaderName.iContains(Pipeline.SHADER_HQ_TEARLINE)) return 3; + if (shaderName.iContains(Pipeline.SHADER_HQ_TEETH)) return 4; + if (shaderName.iContains(Pipeline.SHADER_HQ_HAIR)) return 5; + + if (sourceName.iContains("Std_Skin_Head") || sourceName.iContains("Std_Skin_Body") || + sourceName.iContains("Std_Skin_Arm") || sourceName.iContains("Std_Skin_Leg")) + return 0; + if (sourceName.iContains("Std_Eye_Occlusion_")) return 2; + if (sourceName.iContains("Std_Tearline_")) return 3; + if (sourceName.iContains("Std_Eye_") || sourceName.iContains("Std_Cornea_")) return 1; + if (sourceName.iContains("Std_Upper_Teeth") || sourceName.iContains("Std_Lower_Teeth")) return 4; + return -1; + } + + public static Material[] GetLinkedMaterials(Material mat) + { + string[] names = GetLinkedMaterialNames(mat.name); + string assetPath = AssetDatabase.GetAssetPath(mat); + string[] assetFolders = new[] { Path.GetDirectoryName(assetPath) }; + List results = new List(); + + foreach (string name in names) + { + string[] searchGuids = AssetDatabase.FindAssets("t:material " + name, assetFolders); + foreach (string guid in searchGuids) + { + string searchPath = AssetDatabase.GUIDToAssetPath(guid); + string searchName = Path.GetFileNameWithoutExtension(searchPath).ToLowerInvariant(); + if (searchName.Contains(name)) + { + Debug.Log(searchName); + results.Add(AssetDatabase.LoadAssetAtPath(searchPath)); + } + } + } + + return results.ToArray(); + } + + public static void UpdateLinkedMaterial(Material mat, Material[] linkedMaterials, string shaderRef, float value, bool linked) + { + if (linked) + { + foreach (Material m in linkedMaterials) + if (m.HasProperty(shaderRef)) + m.SetFloat(shaderRef, value); + } + else + mat.SetFloat(shaderRef, value); + } + + public static void UpdateLinkedMaterial(Material mat, Material[] linkedMaterials, string shaderRef, Color value, bool linked) + { + if (linked) + { + foreach (Material m in linkedMaterials) + if (m.HasProperty(shaderRef)) + m.SetColor(shaderRef, value); + } + else + mat.SetColor(shaderRef, value); + } + + public static void DestroyEditorChildObjects(GameObject obj) + { + GameObject[] children = new GameObject[obj.transform.childCount]; + + for (int i = 0; i < obj.transform.childCount; i++) + { + children[i] = obj.transform.GetChild(i).gameObject; + } + + foreach (GameObject child in children) + { + GameObject.DestroyImmediate(child); + } + } + + public static void PreviewCharacter(GameObject character) + { + if (!character) return; + + if (!EditorSceneManager.SaveCurrentModifiedScenesIfUserWantsTo()) return; + + //old code block + /* + UnityEngine.SceneManagement.Scene previewScene = EditorSceneManager.OpenScene("Assets/CC3Import/Scenes/PreviewScene.unity"); + + if (previewScene.IsValid()) + { + if (previewScene.isLoaded) + { + GameObject container = GameObject.Find("Character Container"); + if (container) + { + DestroyEditorChildObjects(container); + + GameObject clone = PrefabUtility.InstantiatePrefab(character, container.transform) as GameObject; + if (clone) + { + Selection.activeGameObject = clone; + SceneView.FrameLastActiveSceneView(); + } + } + } + } + */ + + //new code block start + EditorSceneManager.NewScene(NewSceneSetup.EmptyScene); + GameObject.Instantiate(Util.FindPreviewScenePrefab(), Vector3.zero, Quaternion.identity); + GameObject container = GameObject.Find("Character Container"); + if (container) + { + DestroyEditorChildObjects(container); + + GameObject clone = PrefabUtility.InstantiatePrefab(character, container.transform) as GameObject; + if (clone) + { + Selection.activeGameObject = clone; + SceneView.FrameLastActiveSceneView(); + } + } + //new code block end + + } + + public static GameObject GetPrefabFromObject(Object obj) + { + Object source = PrefabUtility.GetCorrespondingObjectFromSource(obj); + Object parent = PrefabUtility.GetPrefabInstanceHandle(source); + if (parent.GetType() == typeof(GameObject)) + { + return (GameObject)parent; + } + + return null; + } + } +} \ No newline at end of file diff --git a/Editor/Util.cs.meta b/Editor/Util.cs.meta new file mode 100644 index 0000000..7120fb2 --- /dev/null +++ b/Editor/Util.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 6694fba07fc9c3a4d82c7365262dba3c +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Editor/com.soupday.cc3_unity_tools_prototype.editor.asmdef b/Editor/com.soupday.cc3_unity_tools_prototype.editor.asmdef new file mode 100644 index 0000000..0ea4b0c --- /dev/null +++ b/Editor/com.soupday.cc3_unity_tools_prototype.editor.asmdef @@ -0,0 +1,26 @@ +{ + "name": "soupday.cc3_unity_tools.editor", + "rootNamespace": "Reallusion.Import", + "references": [ + "GUID:457756d89b35d2941b3e7b37b4ece6f1", + "GUID:3eae0364be2026648bf74846acb8a731", + "GUID:78bd2ddd6e276394a9615c203e574844" + ], + "includePlatforms": [], + "excludePlatforms": [], + "allowUnsafeCode": false, + "overrideReferences": false, + "precompiledReferences": [ + "" + ], + "autoReferenced": true, + "defineConstraints": [], + "versionDefines": [ + { + "name": "com.unity.render-pipelines.high-definition", + "expression": "10.5.0", + "define": "HDRP_10_5_0_OR_NEWER" + } + ], + "noEngineReferences": false +} \ No newline at end of file diff --git a/Editor/com.soupday.cc3_unity_tools_prototype.editor.asmdef.meta b/Editor/com.soupday.cc3_unity_tools_prototype.editor.asmdef.meta new file mode 100644 index 0000000..df72b01 --- /dev/null +++ b/Editor/com.soupday.cc3_unity_tools_prototype.editor.asmdef.meta @@ -0,0 +1,7 @@ +fileFormatVersion: 2 +guid: c81579c2ae95dd642ad408bc13b97031 +AssemblyDefinitionImporter: + externalObjects: {} + userData: + assetBundleName: + assetBundleVariant: diff --git a/HDRP.meta b/HDRP.meta new file mode 100644 index 0000000..d702a86 --- /dev/null +++ b/HDRP.meta @@ -0,0 +1,8 @@ +fileFormatVersion: 2 +guid: 04ab3ceb76b02e24494fd6d8d8e49d57 +folderAsset: yes +DefaultImporter: + externalObjects: {} + userData: + assetBundleName: + assetBundleVariant: diff --git a/HDRP/Material Templates.meta b/HDRP/Material Templates.meta new file mode 100644 index 0000000..7eb95ae --- /dev/null +++ b/HDRP/Material Templates.meta @@ -0,0 +1,8 @@ +fileFormatVersion: 2 +guid: 93235cb311b897242a661649702185cf +folderAsset: yes +DefaultImporter: + externalObjects: {} + userData: + assetBundleName: + assetBundleVariant: diff --git a/HDRP/Material Templates/RL_Template_Baked_CorneaRef_HDRP.mat b/HDRP/Material Templates/RL_Template_Baked_CorneaRef_HDRP.mat new file mode 100644 index 0000000..3a3016e --- /dev/null +++ b/HDRP/Material Templates/RL_Template_Baked_CorneaRef_HDRP.mat @@ -0,0 +1,277 @@ +%YAML 1.1 +%TAG !u! tag:unity3d.com,2011: +--- !u!114 &-4635880401996347712 +MonoBehaviour: + m_ObjectHideFlags: 11 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 0} + m_Enabled: 1 + m_EditorHideFlags: 0 + m_Script: {fileID: 11500000, guid: aa486462e6be1764e89c788ba30e61f7, type: 3} + m_Name: + m_EditorClassIdentifier: + m_DiffusionProfileReferences: + - {fileID: 11400000, guid: 26bdddf49760c61438938733f07fa2a2, type: 2} + m_MaterialReferences: [] +--- !u!114 &-3842705591719574230 +MonoBehaviour: + m_ObjectHideFlags: 11 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 0} + m_Enabled: 1 + m_EditorHideFlags: 0 + m_Script: {fileID: 11500000, guid: da692e001514ec24dbc4cca1949ff7e8, type: 3} + m_Name: + m_EditorClassIdentifier: + version: 11 +--- !u!21 &2100000 +Material: + serializedVersion: 6 + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_Name: RL_Template_Baked_CorneaRef_HDRP + m_Shader: {fileID: 4800000, guid: 6e4ae4064600d784cac1e41a9e6f2e59, type: 3} + m_ShaderKeywords: _DETAIL_MAP _DISABLE_SSR_TRANSPARENT _ENABLE_FOG_ON_TRANSPARENT + _MASKMAP _NORMALMAP _NORMALMAP_TANGENT_SPACE _REFRACTION_PLANE _SURFACE_TYPE_TRANSPARENT + _THICKNESSMAP + m_LightmapFlags: 4 + m_EnableInstancingVariants: 0 + m_DoubleSidedGI: 0 + m_CustomRenderQueue: 2996 + stringTagMap: + MotionVector: User + RenderType: Transparent + disabledShaderPasses: + - TransparentDepthPrepass + - TransparentDepthPostpass + - TransparentBackface + - RayTracingPrepass + - MOTIONVECTORS + m_SavedProperties: + serializedVersion: 3 + m_TexEnvs: + - _AnisotropyMap: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - _BaseColorMap: + m_Texture: {fileID: 2800000, guid: 2e6930762defd9149a4115ecb5f1a3f8, type: 3} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - _BentNormalMap: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - _BentNormalMapOS: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - _CoatMaskMap: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - _DetailMap: + m_Texture: {fileID: 2800000, guid: fba38fae484e7574a946d1527940b2b2, type: 3} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - _EmissiveColorMap: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - _HeightMap: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - _IridescenceMaskMap: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - _IridescenceThicknessMap: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - _MainTex: + m_Texture: {fileID: 2800000, guid: 2e6930762defd9149a4115ecb5f1a3f8, type: 3} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - _MaskMap: + m_Texture: {fileID: 2800000, guid: fba38fae484e7574a946d1527940b2b2, type: 3} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - _NormalMap: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - _NormalMapOS: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - _SpecularColorMap: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - _SubsurfaceMaskMap: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - _TangentMap: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - _TangentMapOS: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - _ThicknessMap: + m_Texture: {fileID: 2800000, guid: fba38fae484e7574a946d1527940b2b2, type: 3} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - _TransmittanceColorMap: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - unity_Lightmaps: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - unity_LightmapsInd: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - unity_ShadowMasks: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + m_Floats: + - _AORemapMax: 1 + - _AORemapMin: 0 + - _ATDistance: 1 + - _AddPrecomputedVelocity: 0 + - _AlbedoAffectEmissive: 0 + - _AlphaCutoff: 0.5 + - _AlphaCutoffEnable: 0 + - _AlphaCutoffPostpass: 0.5 + - _AlphaCutoffPrepass: 0.5 + - _AlphaCutoffShadow: 0.5 + - _AlphaDstBlend: 10 + - _AlphaSrcBlend: 1 + - _AlphaToMask: 0 + - _AlphaToMaskInspectorValue: 0 + - _Anisotropy: 0 + - _BlendMode: 0 + - _CoatMask: 0 + - _CullMode: 2 + - _CullModeForward: 2 + - _Cutoff: 0.5 + - _DepthOffsetEnable: 0 + - _DetailAlbedoScale: 1 + - _DetailNormalScale: 1 + - _DetailSmoothnessScale: 1 + - _DiffusionProfile: 0 + - _DiffusionProfileHash: 0 + - _DisplacementLockObjectScale: 1 + - _DisplacementLockTilingScale: 1 + - _DisplacementMode: 0 + - _DoubleSidedEnable: 0 + - _DoubleSidedNormalMode: 1 + - _DstBlend: 10 + - _EmissiveColorMode: 1 + - _EmissiveExposureWeight: 1 + - _EmissiveIntensity: 1 + - _EmissiveIntensityUnit: 0 + - _EnableBlendModePreserveSpecularLighting: 1 + - _EnableFogOnTransparent: 1 + - _EnableGeometricSpecularAA: 0 + - _EnergyConservingSpecularColor: 1 + - _HeightAmplitude: 0.02 + - _HeightCenter: 0.5 + - _HeightMapParametrization: 0 + - _HeightMax: 1 + - _HeightMin: -1 + - _HeightOffset: 0 + - _HeightPoMAmplitude: 2 + - _HeightTessAmplitude: 2 + - _HeightTessCenter: 0.5 + - _InvTilingScale: 1 + - _Ior: 1.4 + - _IridescenceMask: 1 + - _IridescenceThickness: 1 + - _LinkDetailsWithBase: 1 + - _MaterialID: 1 + - _Metallic: 0 + - _MetallicRemapMax: 1 + - _MetallicRemapMin: 0 + - _NormalMapSpace: 0 + - _NormalScale: 1 + - _OpaqueCullMode: 2 + - _PPDLodThreshold: 5 + - _PPDMaxSamples: 15 + - _PPDMinSamples: 5 + - _PPDPrimitiveLength: 1 + - _PPDPrimitiveWidth: 1 + - _RayTracing: 0 + - _ReceivesSSR: 1 + - _ReceivesSSRTransparent: 0 + - _RefractionModel: 1 + - _Smoothness: 0.5 + - _SmoothnessRemapMax: 1 + - _SmoothnessRemapMin: 0 + - _SpecularAAScreenSpaceVariance: 0.1 + - _SpecularAAThreshold: 0.2 + - _SpecularOcclusionMode: 1 + - _SrcBlend: 1 + - _StencilRef: 0 + - _StencilRefDepth: 0 + - _StencilRefGBuffer: 2 + - _StencilRefMV: 32 + - _StencilWriteMask: 6 + - _StencilWriteMaskDepth: 8 + - _StencilWriteMaskGBuffer: 14 + - _StencilWriteMaskMV: 40 + - _SubsurfaceMask: 1 + - _SupportDecals: 1 + - _SurfaceType: 1 + - _TexWorldScale: 1 + - _TexWorldScaleEmissive: 1 + - _Thickness: 1 + - _TransmissionEnable: 1 + - _TransparentBackfaceEnable: 0 + - _TransparentCullMode: 2 + - _TransparentDepthPostpassEnable: 0 + - _TransparentDepthPrepassEnable: 0 + - _TransparentSortPriority: -4 + - _TransparentWritingMotionVec: 0 + - _TransparentZWrite: 0 + - _UVBase: 0 + - _UVDetail: 0 + - _UVEmissive: 0 + - _UseEmissiveIntensity: 0 + - _UseShadowThreshold: 0 + - _ZTestDepthEqualForOpaque: 4 + - _ZTestGBuffer: 4 + - _ZTestTransparent: 4 + - _ZWrite: 0 + m_Colors: + - _BaseColor: {r: 1, g: 1, b: 1, a: 1} + - _BaseColorMap_MipInfo: {r: 0, g: 0, b: 0, a: 0} + - _Color: {r: 1, g: 1, b: 1, a: 1} + - _DiffusionProfileAsset: {r: 0, g: 0, b: 0, a: 0} + - _DoubleSidedConstants: {r: 1, g: 1, b: -1, a: 0} + - _EmissionColor: {r: 1, g: 1, b: 1, a: 1} + - _EmissiveColor: {r: 0, g: 0, b: 0, a: 1} + - _EmissiveColorLDR: {r: 0, g: 0, b: 0, a: 1} + - _InvPrimScale: {r: 1, g: 1, b: 0, a: 0} + - _IridescenceThicknessRemap: {r: 0, g: 1, b: 0, a: 0} + - _SpecularColor: {r: 1, g: 1, b: 1, a: 1} + - _ThicknessRemap: {r: 0, g: 0.022585671, b: 0, a: 0} + - _TransmittanceColor: {r: 1, g: 1, b: 1, a: 1} + - _UVDetailsMappingMask: {r: 1, g: 0, b: 0, a: 0} + - _UVMappingMask: {r: 1, g: 0, b: 0, a: 0} + - _UVMappingMaskEmissive: {r: 1, g: 0, b: 0, a: 0} + m_BuildTextureStacks: [] diff --git a/HDRP/Material Templates/RL_Template_Baked_CorneaRef_HDRP.mat.meta b/HDRP/Material Templates/RL_Template_Baked_CorneaRef_HDRP.mat.meta new file mode 100644 index 0000000..5c39514 --- /dev/null +++ b/HDRP/Material Templates/RL_Template_Baked_CorneaRef_HDRP.mat.meta @@ -0,0 +1,8 @@ +fileFormatVersion: 2 +guid: b0da49a073cbc9f41b9c49a27cd6bb07 +NativeFormatImporter: + externalObjects: {} + mainObjectFileID: 2100000 + userData: + assetBundleName: + assetBundleVariant: diff --git a/HDRP/Material Templates/RL_Template_Baked_Cornea_HDRP.mat b/HDRP/Material Templates/RL_Template_Baked_Cornea_HDRP.mat new file mode 100644 index 0000000..037dda4 --- /dev/null +++ b/HDRP/Material Templates/RL_Template_Baked_Cornea_HDRP.mat @@ -0,0 +1,276 @@ +%YAML 1.1 +%TAG !u! tag:unity3d.com,2011: +--- !u!114 &-4635880401996347712 +MonoBehaviour: + m_ObjectHideFlags: 11 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 0} + m_Enabled: 1 + m_EditorHideFlags: 0 + m_Script: {fileID: 11500000, guid: aa486462e6be1764e89c788ba30e61f7, type: 3} + m_Name: + m_EditorClassIdentifier: + m_DiffusionProfileReferences: + - {fileID: 11400000, guid: 26bdddf49760c61438938733f07fa2a2, type: 2} + m_MaterialReferences: [] +--- !u!114 &-3842705591719574230 +MonoBehaviour: + m_ObjectHideFlags: 11 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 0} + m_Enabled: 1 + m_EditorHideFlags: 0 + m_Script: {fileID: 11500000, guid: da692e001514ec24dbc4cca1949ff7e8, type: 3} + m_Name: + m_EditorClassIdentifier: + version: 11 +--- !u!21 &2100000 +Material: + serializedVersion: 6 + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_Name: RL_Template_Baked_Cornea_HDRP + m_Shader: {fileID: 4800000, guid: 6e4ae4064600d784cac1e41a9e6f2e59, type: 3} + m_ShaderKeywords: _DETAIL_MAP _DISABLE_SSR_TRANSPARENT _ENABLE_FOG_ON_TRANSPARENT + _MASKMAP _NORMALMAP _NORMALMAP_TANGENT_SPACE _SURFACE_TYPE_TRANSPARENT + m_LightmapFlags: 4 + m_EnableInstancingVariants: 0 + m_DoubleSidedGI: 0 + m_CustomRenderQueue: 2996 + stringTagMap: + MotionVector: User + RenderType: Transparent + disabledShaderPasses: + - TransparentDepthPrepass + - TransparentDepthPostpass + - TransparentBackface + - RayTracingPrepass + - MOTIONVECTORS + m_SavedProperties: + serializedVersion: 3 + m_TexEnvs: + - _AnisotropyMap: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - _BaseColorMap: + m_Texture: {fileID: 2800000, guid: 2e6930762defd9149a4115ecb5f1a3f8, type: 3} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - _BentNormalMap: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - _BentNormalMapOS: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - _CoatMaskMap: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - _DetailMap: + m_Texture: {fileID: 2800000, guid: fba38fae484e7574a946d1527940b2b2, type: 3} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - _EmissiveColorMap: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - _HeightMap: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - _IridescenceMaskMap: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - _IridescenceThicknessMap: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - _MainTex: + m_Texture: {fileID: 2800000, guid: 2e6930762defd9149a4115ecb5f1a3f8, type: 3} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - _MaskMap: + m_Texture: {fileID: 2800000, guid: fba38fae484e7574a946d1527940b2b2, type: 3} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - _NormalMap: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - _NormalMapOS: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - _SpecularColorMap: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - _SubsurfaceMaskMap: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - _TangentMap: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - _TangentMapOS: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - _ThicknessMap: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - _TransmittanceColorMap: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - unity_Lightmaps: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - unity_LightmapsInd: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - unity_ShadowMasks: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + m_Floats: + - _AORemapMax: 1 + - _AORemapMin: 0 + - _ATDistance: 1 + - _AddPrecomputedVelocity: 0 + - _AlbedoAffectEmissive: 0 + - _AlphaCutoff: 0.5 + - _AlphaCutoffEnable: 0 + - _AlphaCutoffPostpass: 0.5 + - _AlphaCutoffPrepass: 0.5 + - _AlphaCutoffShadow: 0.5 + - _AlphaDstBlend: 10 + - _AlphaSrcBlend: 1 + - _AlphaToMask: 0 + - _AlphaToMaskInspectorValue: 0 + - _Anisotropy: 0 + - _BlendMode: 0 + - _CoatMask: 0 + - _CullMode: 2 + - _CullModeForward: 2 + - _Cutoff: 0.5 + - _DepthOffsetEnable: 0 + - _DetailAlbedoScale: 1 + - _DetailNormalScale: 1 + - _DetailSmoothnessScale: 1 + - _DiffusionProfile: 0 + - _DiffusionProfileHash: 0 + - _DisplacementLockObjectScale: 1 + - _DisplacementLockTilingScale: 1 + - _DisplacementMode: 0 + - _DoubleSidedEnable: 0 + - _DoubleSidedNormalMode: 1 + - _DstBlend: 10 + - _EmissiveColorMode: 1 + - _EmissiveExposureWeight: 1 + - _EmissiveIntensity: 1 + - _EmissiveIntensityUnit: 0 + - _EnableBlendModePreserveSpecularLighting: 1 + - _EnableFogOnTransparent: 1 + - _EnableGeometricSpecularAA: 0 + - _EnergyConservingSpecularColor: 1 + - _HeightAmplitude: 0.02 + - _HeightCenter: 0.5 + - _HeightMapParametrization: 0 + - _HeightMax: 1 + - _HeightMin: -1 + - _HeightOffset: 0 + - _HeightPoMAmplitude: 2 + - _HeightTessAmplitude: 2 + - _HeightTessCenter: 0.5 + - _InvTilingScale: 1 + - _Ior: 1.5 + - _IridescenceMask: 1 + - _IridescenceThickness: 1 + - _LinkDetailsWithBase: 1 + - _MaterialID: 1 + - _Metallic: 0 + - _MetallicRemapMax: 1 + - _MetallicRemapMin: 0 + - _NormalMapSpace: 0 + - _NormalScale: 1 + - _OpaqueCullMode: 2 + - _PPDLodThreshold: 5 + - _PPDMaxSamples: 15 + - _PPDMinSamples: 5 + - _PPDPrimitiveLength: 1 + - _PPDPrimitiveWidth: 1 + - _RayTracing: 0 + - _ReceivesSSR: 1 + - _ReceivesSSRTransparent: 0 + - _RefractionModel: 0 + - _Smoothness: 0.5 + - _SmoothnessRemapMax: 1 + - _SmoothnessRemapMin: 0 + - _SpecularAAScreenSpaceVariance: 0.1 + - _SpecularAAThreshold: 0.2 + - _SpecularOcclusionMode: 1 + - _SrcBlend: 1 + - _StencilRef: 0 + - _StencilRefDepth: 0 + - _StencilRefGBuffer: 2 + - _StencilRefMV: 32 + - _StencilWriteMask: 6 + - _StencilWriteMaskDepth: 8 + - _StencilWriteMaskGBuffer: 14 + - _StencilWriteMaskMV: 40 + - _SubsurfaceMask: 1 + - _SupportDecals: 1 + - _SurfaceType: 1 + - _TexWorldScale: 1 + - _TexWorldScaleEmissive: 1 + - _Thickness: 1 + - _TransmissionEnable: 1 + - _TransparentBackfaceEnable: 0 + - _TransparentCullMode: 2 + - _TransparentDepthPostpassEnable: 0 + - _TransparentDepthPrepassEnable: 0 + - _TransparentSortPriority: -4 + - _TransparentWritingMotionVec: 0 + - _TransparentZWrite: 0 + - _UVBase: 0 + - _UVDetail: 0 + - _UVEmissive: 0 + - _UseEmissiveIntensity: 0 + - _UseShadowThreshold: 0 + - _ZTestDepthEqualForOpaque: 4 + - _ZTestGBuffer: 4 + - _ZTestTransparent: 4 + - _ZWrite: 0 + m_Colors: + - _BaseColor: {r: 1, g: 1, b: 1, a: 1} + - _BaseColorMap_MipInfo: {r: 0, g: 0, b: 0, a: 0} + - _Color: {r: 1, g: 1, b: 1, a: 1} + - _DiffusionProfileAsset: {r: 0, g: 0, b: 0, a: 0} + - _DoubleSidedConstants: {r: 1, g: 1, b: -1, a: 0} + - _EmissionColor: {r: 1, g: 1, b: 1, a: 1} + - _EmissiveColor: {r: 0, g: 0, b: 0, a: 1} + - _EmissiveColorLDR: {r: 0, g: 0, b: 0, a: 1} + - _InvPrimScale: {r: 1, g: 1, b: 0, a: 0} + - _IridescenceThicknessRemap: {r: 0, g: 1, b: 0, a: 0} + - _SpecularColor: {r: 1, g: 1, b: 1, a: 1} + - _ThicknessRemap: {r: 0, g: 1, b: 0, a: 0} + - _TransmittanceColor: {r: 1, g: 1, b: 1, a: 1} + - _UVDetailsMappingMask: {r: 1, g: 0, b: 0, a: 0} + - _UVMappingMask: {r: 1, g: 0, b: 0, a: 0} + - _UVMappingMaskEmissive: {r: 1, g: 0, b: 0, a: 0} + m_BuildTextureStacks: [] diff --git a/HDRP/Material Templates/RL_Template_Baked_Cornea_HDRP.mat.meta b/HDRP/Material Templates/RL_Template_Baked_Cornea_HDRP.mat.meta new file mode 100644 index 0000000..92a0c76 --- /dev/null +++ b/HDRP/Material Templates/RL_Template_Baked_Cornea_HDRP.mat.meta @@ -0,0 +1,8 @@ +fileFormatVersion: 2 +guid: 5a42b63860fcf9947b6f25e1afed3719 +NativeFormatImporter: + externalObjects: {} + mainObjectFileID: 2100000 + userData: + assetBundleName: + assetBundleVariant: diff --git a/HDRP/Material Templates/RL_Template_Baked_EyeCustom_HDRP.mat b/HDRP/Material Templates/RL_Template_Baked_EyeCustom_HDRP.mat new file mode 100644 index 0000000..7f3493e --- /dev/null +++ b/HDRP/Material Templates/RL_Template_Baked_EyeCustom_HDRP.mat @@ -0,0 +1,129 @@ +%YAML 1.1 +%TAG !u! tag:unity3d.com,2011: +--- !u!114 &-4635880401996347712 +MonoBehaviour: + m_ObjectHideFlags: 11 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 0} + m_Enabled: 1 + m_EditorHideFlags: 0 + m_Script: {fileID: 11500000, guid: aa486462e6be1764e89c788ba30e61f7, type: 3} + m_Name: + m_EditorClassIdentifier: + m_DiffusionProfileReferences: + - {fileID: 11400000, guid: 26bdddf49760c61438938733f07fa2a2, type: 2} + m_MaterialReferences: [] +--- !u!114 &-3842705591719574230 +MonoBehaviour: + m_ObjectHideFlags: 11 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 0} + m_Enabled: 1 + m_EditorHideFlags: 0 + m_Script: {fileID: 11500000, guid: da692e001514ec24dbc4cca1949ff7e8, type: 3} + m_Name: + m_EditorClassIdentifier: + version: 11 +--- !u!21 &2100000 +Material: + serializedVersion: 6 + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_Name: RL_Template_Baked_EyeCustom_HDRP + m_Shader: {fileID: -6465566751694194690, guid: 1f94846e709e483448feea617906bc23, type: 3} + m_ShaderKeywords: _DISABLE_SSR_TRANSPARENT + m_LightmapFlags: 4 + m_EnableInstancingVariants: 0 + m_DoubleSidedGI: 0 + m_CustomRenderQueue: 2225 + stringTagMap: + MotionVector: User + disabledShaderPasses: + - TransparentDepthPrepass + - TransparentDepthPostpass + - TransparentBackface + - RayTracingPrepass + - MOTIONVECTORS + m_SavedProperties: + serializedVersion: 3 + m_TexEnvs: + - _BaseColorMap: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - _MaskMap: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - unity_Lightmaps: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - unity_LightmapsInd: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - unity_ShadowMasks: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + m_Floats: + - _AddPrecomputedVelocity: 0 + - _AlphaCutoffEnable: 0 + - _AlphaDstBlend: 0 + - _AlphaSrcBlend: 1 + - _AlphaToMask: 0 + - _AlphaToMaskInspectorValue: 0 + - _BlendMode: 0 + - _CullMode: 2 + - _CullModeForward: 2 + - _DepthOffsetEnable: 0 + - _DoubleSidedEnable: 0 + - _DoubleSidedNormalMode: 2 + - _DstBlend: 0 + - _EnableBlendModePreserveSpecularLighting: 1 + - _EnableFogOnTransparent: 1 + - _IrisDepth: 0.004 + - _OpaqueCullMode: 2 + - _PupilScale: 1 + - _RayTracing: 0 + - _ReceivesSSR: 1 + - _ReceivesSSRTransparent: 0 + - _RefractionModel: 0 + - _RenderQueueType: 1 + - _RequireSplitLighting: 0 + - _SrcBlend: 1 + - _StencilRef: 0 + - _StencilRefDepth: 8 + - _StencilRefDistortionVec: 4 + - _StencilRefGBuffer: 10 + - _StencilRefMV: 40 + - _StencilWriteMask: 6 + - _StencilWriteMaskDepth: 8 + - _StencilWriteMaskDistortionVec: 4 + - _StencilWriteMaskGBuffer: 14 + - _StencilWriteMaskMV: 40 + - _SupportDecals: 1 + - _SurfaceType: 0 + - _TransparentBackfaceEnable: 0 + - _TransparentCullMode: 2 + - _TransparentDepthPostpassEnable: 0 + - _TransparentDepthPrepassEnable: 0 + - _TransparentSortPriority: 0 + - _TransparentWritingMotionVec: 0 + - _TransparentZWrite: 0 + - _UseShadowThreshold: 0 + - _ZTestDepthEqualForOpaque: 3 + - _ZTestGBuffer: 4 + - _ZTestTransparent: 4 + - _ZWrite: 1 + m_Colors: + - _DoubleSidedConstants: {r: 1, g: 1, b: -1, a: 0} + - _EmissionColor: {r: 1, g: 1, b: 1, a: 1} + m_BuildTextureStacks: [] diff --git a/HDRP/Material Templates/RL_Template_Baked_EyeCustom_HDRP.mat.meta b/HDRP/Material Templates/RL_Template_Baked_EyeCustom_HDRP.mat.meta new file mode 100644 index 0000000..6c1ad8a --- /dev/null +++ b/HDRP/Material Templates/RL_Template_Baked_EyeCustom_HDRP.mat.meta @@ -0,0 +1,8 @@ +fileFormatVersion: 2 +guid: 733f86c64c556e743bfc91a87b6accf3 +NativeFormatImporter: + externalObjects: {} + mainObjectFileID: 2100000 + userData: + assetBundleName: + assetBundleVariant: diff --git a/HDRP/Material Templates/RL_Template_Baked_EyeOcclusionCustom_HDRP.mat b/HDRP/Material Templates/RL_Template_Baked_EyeOcclusionCustom_HDRP.mat new file mode 100644 index 0000000..1b5ee34 --- /dev/null +++ b/HDRP/Material Templates/RL_Template_Baked_EyeOcclusionCustom_HDRP.mat @@ -0,0 +1,108 @@ +%YAML 1.1 +%TAG !u! tag:unity3d.com,2011: +--- !u!114 &-6507223048030999885 +MonoBehaviour: + m_ObjectHideFlags: 11 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 0} + m_Enabled: 1 + m_EditorHideFlags: 0 + m_Script: {fileID: 11500000, guid: da692e001514ec24dbc4cca1949ff7e8, type: 3} + m_Name: + m_EditorClassIdentifier: + version: 11 +--- !u!21 &2100000 +Material: + serializedVersion: 6 + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_Name: RL_Template_Baked_EyeOcclusionCustom_HDRP + m_Shader: {fileID: -6465566751694194690, guid: 19cfa70b21a0ca649855cd3bc8896d63, type: 3} + m_ShaderKeywords: _ENABLE_FOG_ON_TRANSPARENT _SURFACE_TYPE_TRANSPARENT + m_LightmapFlags: 4 + m_EnableInstancingVariants: 0 + m_DoubleSidedGI: 0 + m_CustomRenderQueue: 2997 + stringTagMap: + MotionVector: User + RenderType: Transparent + disabledShaderPasses: + - TransparentDepthPrepass + - TransparentDepthPostpass + - TransparentBackface + - RayTracingPrepass + - MOTIONVECTORS + m_SavedProperties: + serializedVersion: 3 + m_TexEnvs: + - _BaseColorMap: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - unity_Lightmaps: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - unity_LightmapsInd: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - unity_ShadowMasks: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + m_Floats: + - _AddPrecomputedVelocity: 0 + - _AlphaCutoffEnable: 0 + - _AlphaDstBlend: 10 + - _AlphaSrcBlend: 1 + - _AlphaToMask: 0 + - _AlphaToMaskInspectorValue: 0 + - _BlendMode: 4 + - _CullMode: 2 + - _CullModeForward: 2 + - _DepthOffsetEnable: 0 + - _DoubleSidedEnable: 0 + - _DoubleSidedNormalMode: 2 + - _DstBlend: 10 + - _EnableBlendModePreserveSpecularLighting: 0 + - _EnableFogOnTransparent: 1 + - _ExpandInner: 0 + - _ExpandLower: 0 + - _ExpandOut: 0.0001 + - _ExpandOuter: 0 + - _ExpandUpper: 0 + - _OpaqueCullMode: 2 + - _RenderQueueType: 4 + - _SrcBlend: 1 + - _StencilRef: 0 + - _StencilRefDepth: 0 + - _StencilRefDistortionVec: 4 + - _StencilRefGBuffer: 2 + - _StencilRefMV: 32 + - _StencilWriteMask: 6 + - _StencilWriteMaskDepth: 8 + - _StencilWriteMaskDistortionVec: 4 + - _StencilWriteMaskGBuffer: 14 + - _StencilWriteMaskMV: 40 + - _SurfaceType: 1 + - _TransparentBackfaceEnable: 0 + - _TransparentCullMode: 2 + - _TransparentDepthPostpassEnable: 0 + - _TransparentDepthPrepassEnable: 0 + - _TransparentSortPriority: -3 + - _TransparentWritingMotionVec: 0 + - _TransparentZWrite: 0 + - _UseShadowThreshold: 0 + - _ZTestDepthEqualForOpaque: 4 + - _ZTestGBuffer: 4 + - _ZTestTransparent: 4 + - _ZWrite: 0 + m_Colors: + - _DoubleSidedConstants: {r: 1, g: 1, b: -1, a: 0} + - _EmissionColor: {r: 1, g: 1, b: 1, a: 1} + m_BuildTextureStacks: [] diff --git a/HDRP/Material Templates/RL_Template_Baked_EyeOcclusionCustom_HDRP.mat.meta b/HDRP/Material Templates/RL_Template_Baked_EyeOcclusionCustom_HDRP.mat.meta new file mode 100644 index 0000000..37e8980 --- /dev/null +++ b/HDRP/Material Templates/RL_Template_Baked_EyeOcclusionCustom_HDRP.mat.meta @@ -0,0 +1,8 @@ +fileFormatVersion: 2 +guid: ba6221acb287b3a4fbf256347c2ee8e3 +NativeFormatImporter: + externalObjects: {} + mainObjectFileID: 2100000 + userData: + assetBundleName: + assetBundleVariant: diff --git a/HDRP/Material Templates/RL_Template_Baked_EyeOcclusion_HDRP.mat b/HDRP/Material Templates/RL_Template_Baked_EyeOcclusion_HDRP.mat new file mode 100644 index 0000000..cfd1224 --- /dev/null +++ b/HDRP/Material Templates/RL_Template_Baked_EyeOcclusion_HDRP.mat @@ -0,0 +1,261 @@ +%YAML 1.1 +%TAG !u! tag:unity3d.com,2011: +--- !u!114 &-6507223048030999885 +MonoBehaviour: + m_ObjectHideFlags: 11 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 0} + m_Enabled: 1 + m_EditorHideFlags: 0 + m_Script: {fileID: 11500000, guid: da692e001514ec24dbc4cca1949ff7e8, type: 3} + m_Name: + m_EditorClassIdentifier: + version: 11 +--- !u!21 &2100000 +Material: + serializedVersion: 6 + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_Name: RL_Template_Baked_EyeOcclusion_HDRP + m_Shader: {fileID: 4800000, guid: 6e4ae4064600d784cac1e41a9e6f2e59, type: 3} + m_ShaderKeywords: _DISABLE_SSR_TRANSPARENT _ENABLE_FOG_ON_TRANSPARENT _NORMALMAP_TANGENT_SPACE + _SURFACE_TYPE_TRANSPARENT + m_LightmapFlags: 4 + m_EnableInstancingVariants: 0 + m_DoubleSidedGI: 0 + m_CustomRenderQueue: 2997 + stringTagMap: + MotionVector: User + RenderType: Transparent + disabledShaderPasses: + - TransparentDepthPrepass + - TransparentDepthPostpass + - TransparentBackface + - RayTracingPrepass + - MOTIONVECTORS + m_SavedProperties: + serializedVersion: 3 + m_TexEnvs: + - _AnisotropyMap: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - _BaseColorMap: + m_Texture: {fileID: 2800000, guid: 2e6930762defd9149a4115ecb5f1a3f8, type: 3} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - _BentNormalMap: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - _BentNormalMapOS: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - _CoatMaskMap: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - _DetailMap: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - _EmissiveColorMap: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - _HeightMap: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - _IridescenceMaskMap: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - _IridescenceThicknessMap: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - _MainTex: + m_Texture: {fileID: 2800000, guid: 2e6930762defd9149a4115ecb5f1a3f8, type: 3} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - _MaskMap: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - _NormalMap: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - _NormalMapOS: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - _SpecularColorMap: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - _SubsurfaceMaskMap: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - _TangentMap: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - _TangentMapOS: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - _ThicknessMap: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - _TransmittanceColorMap: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - unity_Lightmaps: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - unity_LightmapsInd: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - unity_ShadowMasks: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + m_Floats: + - _AORemapMax: 1 + - _AORemapMin: 0 + - _ATDistance: 1 + - _AddPrecomputedVelocity: 0 + - _AlbedoAffectEmissive: 0 + - _AlphaCutoff: 0.5 + - _AlphaCutoffEnable: 0 + - _AlphaCutoffPostpass: 0.5 + - _AlphaCutoffPrepass: 0.5 + - _AlphaCutoffShadow: 0.5 + - _AlphaDstBlend: 10 + - _AlphaSrcBlend: 1 + - _AlphaToMask: 0 + - _AlphaToMaskInspectorValue: 0 + - _Anisotropy: 0 + - _BlendMode: 4 + - _CoatMask: 0 + - _CullMode: 2 + - _CullModeForward: 2 + - _Cutoff: 0.5 + - _DepthOffsetEnable: 0 + - _DetailAlbedoScale: 1 + - _DetailNormalScale: 1 + - _DetailSmoothnessScale: 1 + - _DiffusionProfile: 0 + - _DiffusionProfileHash: 0 + - _DisplacementLockObjectScale: 1 + - _DisplacementLockTilingScale: 1 + - _DisplacementMode: 0 + - _DoubleSidedEnable: 0 + - _DoubleSidedNormalMode: 1 + - _DstBlend: 10 + - _EmissiveColorMode: 1 + - _EmissiveExposureWeight: 1 + - _EmissiveIntensity: 1 + - _EmissiveIntensityUnit: 0 + - _EnableBlendModePreserveSpecularLighting: 0 + - _EnableFogOnTransparent: 1 + - _EnableGeometricSpecularAA: 0 + - _EnergyConservingSpecularColor: 1 + - _HeightAmplitude: 0.02 + - _HeightCenter: 0.5 + - _HeightMapParametrization: 0 + - _HeightMax: 1 + - _HeightMin: -1 + - _HeightOffset: 0 + - _HeightPoMAmplitude: 2 + - _HeightTessAmplitude: 2 + - _HeightTessCenter: 0.5 + - _InvTilingScale: 1 + - _Ior: 1.5 + - _IridescenceMask: 1 + - _IridescenceThickness: 1 + - _LinkDetailsWithBase: 1 + - _MaterialID: 1 + - _Metallic: 0 + - _MetallicRemapMax: 1 + - _MetallicRemapMin: 0 + - _NormalMapSpace: 0 + - _NormalScale: 1 + - _OpaqueCullMode: 2 + - _PPDLodThreshold: 5 + - _PPDMaxSamples: 15 + - _PPDMinSamples: 5 + - _PPDPrimitiveLength: 1 + - _PPDPrimitiveWidth: 1 + - _RayTracing: 0 + - _ReceivesSSR: 1 + - _ReceivesSSRTransparent: 0 + - _RefractionModel: 0 + - _Smoothness: 0 + - _SmoothnessRemapMax: 1 + - _SmoothnessRemapMin: 0 + - _SpecularAAScreenSpaceVariance: 0.1 + - _SpecularAAThreshold: 0.2 + - _SpecularOcclusionMode: 1 + - _SrcBlend: 1 + - _StencilRef: 0 + - _StencilRefDepth: 0 + - _StencilRefGBuffer: 2 + - _StencilRefMV: 32 + - _StencilWriteMask: 6 + - _StencilWriteMaskDepth: 8 + - _StencilWriteMaskGBuffer: 14 + - _StencilWriteMaskMV: 40 + - _SubsurfaceMask: 1 + - _SupportDecals: 1 + - _SurfaceType: 1 + - _TexWorldScale: 1 + - _TexWorldScaleEmissive: 1 + - _Thickness: 1 + - _TransmissionEnable: 1 + - _TransparentBackfaceEnable: 0 + - _TransparentCullMode: 2 + - _TransparentDepthPostpassEnable: 0 + - _TransparentDepthPrepassEnable: 0 + - _TransparentSortPriority: -3 + - _TransparentWritingMotionVec: 0 + - _TransparentZWrite: 0 + - _UVBase: 0 + - _UVDetail: 0 + - _UVEmissive: 0 + - _UseEmissiveIntensity: 0 + - _UseShadowThreshold: 0 + - _ZTestDepthEqualForOpaque: 4 + - _ZTestGBuffer: 4 + - _ZTestTransparent: 4 + - _ZWrite: 0 + m_Colors: + - _BaseColor: {r: 1, g: 1, b: 1, a: 1} + - _BaseColorMap_MipInfo: {r: 0, g: 0, b: 0, a: 0} + - _Color: {r: 1, g: 1, b: 1, a: 1} + - _DiffusionProfileAsset: {r: 0, g: 0, b: 0, a: 0} + - _DoubleSidedConstants: {r: 1, g: 1, b: -1, a: 0} + - _EmissionColor: {r: 1, g: 1, b: 1, a: 1} + - _EmissiveColor: {r: 0, g: 0, b: 0, a: 1} + - _EmissiveColorLDR: {r: 0, g: 0, b: 0, a: 1} + - _InvPrimScale: {r: 1, g: 1, b: 0, a: 0} + - _IridescenceThicknessRemap: {r: 0, g: 1, b: 0, a: 0} + - _SpecularColor: {r: 1, g: 1, b: 1, a: 1} + - _ThicknessRemap: {r: 0, g: 1, b: 0, a: 0} + - _TransmittanceColor: {r: 1, g: 1, b: 1, a: 1} + - _UVDetailsMappingMask: {r: 1, g: 0, b: 0, a: 0} + - _UVMappingMask: {r: 1, g: 0, b: 0, a: 0} + - _UVMappingMaskEmissive: {r: 1, g: 0, b: 0, a: 0} + m_BuildTextureStacks: [] diff --git a/HDRP/Material Templates/RL_Template_Baked_EyeOcclusion_HDRP.mat.meta b/HDRP/Material Templates/RL_Template_Baked_EyeOcclusion_HDRP.mat.meta new file mode 100644 index 0000000..235ff0b --- /dev/null +++ b/HDRP/Material Templates/RL_Template_Baked_EyeOcclusion_HDRP.mat.meta @@ -0,0 +1,8 @@ +fileFormatVersion: 2 +guid: 8305f8ccfe8d6474f9a9e3f89c23d698 +NativeFormatImporter: + externalObjects: {} + mainObjectFileID: 2100000 + userData: + assetBundleName: + assetBundleVariant: diff --git a/HDRP/Material Templates/RL_Template_Baked_HairCustom_HDRP.mat b/HDRP/Material Templates/RL_Template_Baked_HairCustom_HDRP.mat new file mode 100644 index 0000000..16d2d4c --- /dev/null +++ b/HDRP/Material Templates/RL_Template_Baked_HairCustom_HDRP.mat @@ -0,0 +1,137 @@ +%YAML 1.1 +%TAG !u! tag:unity3d.com,2011: +--- !u!114 &-195450499016413138 +MonoBehaviour: + m_ObjectHideFlags: 11 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 0} + m_Enabled: 1 + m_EditorHideFlags: 0 + m_Script: {fileID: 11500000, guid: da692e001514ec24dbc4cca1949ff7e8, type: 3} + m_Name: + m_EditorClassIdentifier: + version: 11 +--- !u!21 &2100000 +Material: + serializedVersion: 6 + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_Name: RL_Template_Baked_HairCustom_HDRP + m_Shader: {fileID: -6465566751694194690, guid: a081e115c7c82634aa606dafdcb27d08, type: 3} + m_ShaderKeywords: _ALPHATEST_ON _ALPHATOMASK_ON _DISABLE_SSR_TRANSPARENT _DOUBLESIDED_ON + _ENABLE_FOG_ON_TRANSPARENT _ENUMCLIPQUALITY_ON_STANDARD _SURFACE_TYPE_TRANSPARENT + _TRANSPARENT_WRITES_MOTION_VEC + m_LightmapFlags: 4 + m_EnableInstancingVariants: 0 + m_DoubleSidedGI: 1 + m_CustomRenderQueue: 3000 + stringTagMap: + MotionVector: User + RenderType: Transparent + disabledShaderPasses: + - RayTracingPrepass + - MOTIONVECTORS + m_SavedProperties: + serializedVersion: 3 + m_TexEnvs: + - _BaseColorMap: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - _EmissionMap: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - _FlowMap: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - _MaskMap: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - _NormalMap: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - unity_Lightmaps: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - unity_LightmapsInd: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - unity_ShadowMasks: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + m_Floats: + - _AddPrecomputedVelocity: 0 + - _AlphaClip: 0.1 + - _AlphaCutoffEnable: 1 + - _AlphaDstBlend: 10 + - _AlphaSrcBlend: 1 + - _AlphaToMask: 1 + - _AlphaToMaskInspectorValue: 1 + - _BlendMode: 0 + - _CullMode: 0 + - _CullModeForward: 2 + - _DepthOffsetEnable: 0 + - _DepthPostpass: 1 + - _DepthPrepass: 0.9 + - _DoubleSidedEnable: 1 + - _DoubleSidedNormalMode: 0 + - _DstBlend: 10 + - _ENUMCLIPQUALITY_ON: 0 + - _EnableBlendModePreserveSpecularLighting: 1 + - _EnableFogOnTransparent: 1 + - _NormalStrength: 1 + - _OpaqueCullMode: 2 + - _ReceivesSSR: 1 + - _ReceivesSSRTransparent: 0 + - _RenderQueueType: 4 + - _RequireSplitLighting: 0 + - _RimTransmissionIntensity: 0.05 + - _SecondarySmoothness: 0.6 + - _SecondarySpecularMultiplier: 0.05 + - _SecondarySpecularShift: 0.15 + - _ShadowClip: 0.25 + - _SpecularMultiplier: 0.5 + - _SpecularShift: 0.15 + - _SrcBlend: 1 + - _StencilRef: 0 + - _StencilRefDepth: 0 + - _StencilRefDistortionVec: 4 + - _StencilRefGBuffer: 2 + - _StencilRefMV: 32 + - _StencilWriteMask: 6 + - _StencilWriteMaskDepth: 8 + - _StencilWriteMaskDistortionVec: 4 + - _StencilWriteMaskGBuffer: 14 + - _StencilWriteMaskMV: 40 + - _SupportDecals: 1 + - _SurfaceType: 1 + - _TransparentBackfaceEnable: 1 + - _TransparentCullMode: 2 + - _TransparentDepthPostpassEnable: 1 + - _TransparentDepthPrepassEnable: 1 + - _TransparentSortPriority: 0 + - _TransparentWritingMotionVec: 1 + - _TransparentZWrite: 0 + - _UseShadowThreshold: 1 + - _VertexColorStrength: 0.5 + - _ZTestDepthEqualForOpaque: 4 + - _ZTestGBuffer: 3 + - _ZTestTransparent: 4 + - _ZWrite: 0 + m_Colors: + - _DoubleSidedConstants: {r: -1, g: -1, b: -1, a: 0} + - _EmissionColor: {r: 1, g: 1, b: 1, a: 1} + - _SpecularTint: {r: 1, g: 1, b: 1, a: 1} + - _VertexBaseColor: {r: 0, g: 0, b: 0, a: 0} + m_BuildTextureStacks: [] diff --git a/HDRP/Material Templates/RL_Template_Baked_HairCustom_HDRP.mat.meta b/HDRP/Material Templates/RL_Template_Baked_HairCustom_HDRP.mat.meta new file mode 100644 index 0000000..24bab5f --- /dev/null +++ b/HDRP/Material Templates/RL_Template_Baked_HairCustom_HDRP.mat.meta @@ -0,0 +1,8 @@ +fileFormatVersion: 2 +guid: 3ecfb8073e2c15a49b5025d911e45c13 +NativeFormatImporter: + externalObjects: {} + mainObjectFileID: 2100000 + userData: + assetBundleName: + assetBundleVariant: diff --git a/HDRP/Material Templates/RL_Template_Baked_Hair_HDRP.mat b/HDRP/Material Templates/RL_Template_Baked_Hair_HDRP.mat new file mode 100644 index 0000000..60e453f --- /dev/null +++ b/HDRP/Material Templates/RL_Template_Baked_Hair_HDRP.mat @@ -0,0 +1,135 @@ +%YAML 1.1 +%TAG !u! tag:unity3d.com,2011: +--- !u!21 &2100000 +Material: + serializedVersion: 6 + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_Name: RL_Template_Baked_Hair_HDRP + m_Shader: {fileID: -6465566751694194690, guid: 384d88ff5b296a44b89f1fb2d4442c01, type: 3} + m_ShaderKeywords: _ALPHATEST_ON _ALPHATOMASK_ON _DISABLE_SSR_TRANSPARENT _DOUBLESIDED_ON + _ENABLE_FOG_ON_TRANSPARENT _SURFACE_TYPE_TRANSPARENT _TRANSPARENT_WRITES_MOTION_VEC + m_LightmapFlags: 4 + m_EnableInstancingVariants: 0 + m_DoubleSidedGI: 1 + m_CustomRenderQueue: 3000 + stringTagMap: + MotionVector: User + RenderType: Transparent + disabledShaderPasses: + - RayTracingPrepass + - MOTIONVECTORS + m_SavedProperties: + serializedVersion: 3 + m_TexEnvs: + - _BaseColorMap: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - _MaskMap: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - _NormalMap: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - _SmoothnessMask: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - unity_Lightmaps: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - unity_LightmapsInd: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - unity_ShadowMasks: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + m_Floats: + - _AddPrecomputedVelocity: 0 + - _AlphaClipThreshold: 0.1 + - _AlphaClipThresholdDepthPostpass: 0.6 + - _AlphaClipThresholdDepthPrepass: 0.9 + - _AlphaCutoffEnable: 1 + - _AlphaDstBlend: 10 + - _AlphaSrcBlend: 1 + - _AlphaThresholdShadow: 0.5 + - _AlphaToMask: 1 + - _AlphaToMaskInspectorValue: 1 + - _BlendMode: 0 + - _CullMode: 0 + - _CullModeForward: 2 + - _DepthOffsetEnable: 0 + - _DoubleSidedEnable: 1 + - _DoubleSidedNormalMode: 0 + - _DstBlend: 10 + - _EnableBlendModePreserveSpecularLighting: 1 + - _EnableFogOnTransparent: 1 + - _LightmapUV: 0 + - _NormalScale: 1 + - _OpaqueCullMode: 2 + - _ReceivesSSR: 1 + - _ReceivesSSRTransparent: 0 + - _RenderQueueType: 4 + - _RequireSplitLighting: 0 + - _SecondarySpecular: 0.05 + - _SecondarySpecularShift: 0.15 + - _SmoothnessMax: 0.8 + - _SmoothnessMin: 0 + - _Specular: 0.5 + - _SpecularShift: 0.15 + - _SrcBlend: 1 + - _StencilRef: 0 + - _StencilRefDepth: 0 + - _StencilRefDistortionVec: 4 + - _StencilRefGBuffer: 2 + - _StencilRefMV: 32 + - _StencilWriteMask: 6 + - _StencilWriteMaskDepth: 8 + - _StencilWriteMaskDistortionVec: 4 + - _StencilWriteMaskGBuffer: 14 + - _StencilWriteMaskMV: 40 + - _SupportDecals: 1 + - _SurfaceType: 1 + - _TransmissionRim: 0.05 + - _TransparentBackfaceEnable: 1 + - _TransparentCullMode: 2 + - _TransparentDepthPostpassEnable: 1 + - _TransparentDepthPrepassEnable: 1 + - _TransparentSortPriority: 0 + - _TransparentWritingMotionVec: 1 + - _TransparentZWrite: 0 + - _UseShadowThreshold: 1 + - _ZTestDepthEqualForOpaque: 4 + - _ZTestGBuffer: 3 + - _ZTestTransparent: 4 + - _ZWrite: 0 + m_Colors: + - _BaseColor: {r: 1, g: 1, b: 1, a: 1} + - _DoubleSidedConstants: {r: -1, g: -1, b: -1, a: 0} + - _EmissionColor: {r: 1, g: 1, b: 1, a: 1} + - _SpecularColor: {r: 1, g: 1, b: 1, a: 1} + - _TransmissionColor: {r: 1, g: 0.8666667, b: 0.627451, a: 1} + - _uvBaseST: {r: 1, g: 1, b: 0, a: 0} + - _uvSmoothnessST: {r: 20, g: 5, b: 0, a: 0} + m_BuildTextureStacks: [] +--- !u!114 &222546521132590105 +MonoBehaviour: + m_ObjectHideFlags: 11 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 0} + m_Enabled: 1 + m_EditorHideFlags: 0 + m_Script: {fileID: 11500000, guid: da692e001514ec24dbc4cca1949ff7e8, type: 3} + m_Name: + m_EditorClassIdentifier: + version: 11 diff --git a/HDRP/Material Templates/RL_Template_Baked_Hair_HDRP.mat.meta b/HDRP/Material Templates/RL_Template_Baked_Hair_HDRP.mat.meta new file mode 100644 index 0000000..2a559c6 --- /dev/null +++ b/HDRP/Material Templates/RL_Template_Baked_Hair_HDRP.mat.meta @@ -0,0 +1,8 @@ +fileFormatVersion: 2 +guid: 7fba60151a33b334fbe462045cd18642 +NativeFormatImporter: + externalObjects: {} + mainObjectFileID: 2100000 + userData: + assetBundleName: + assetBundleVariant: diff --git a/HDRP/Material Templates/RL_Template_Baked_Skin_HDRP.mat b/HDRP/Material Templates/RL_Template_Baked_Skin_HDRP.mat new file mode 100644 index 0000000..cefc1cc --- /dev/null +++ b/HDRP/Material Templates/RL_Template_Baked_Skin_HDRP.mat @@ -0,0 +1,276 @@ +%YAML 1.1 +%TAG !u! tag:unity3d.com,2011: +--- !u!114 &-4635880401996347712 +MonoBehaviour: + m_ObjectHideFlags: 11 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 0} + m_Enabled: 1 + m_EditorHideFlags: 0 + m_Script: {fileID: 11500000, guid: aa486462e6be1764e89c788ba30e61f7, type: 3} + m_Name: + m_EditorClassIdentifier: + m_DiffusionProfileReferences: + - {fileID: 11400000, guid: 26bdddf49760c61438938733f07fa2a2, type: 2} + m_MaterialReferences: [] +--- !u!114 &-3842705591719574230 +MonoBehaviour: + m_ObjectHideFlags: 11 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 0} + m_Enabled: 1 + m_EditorHideFlags: 0 + m_Script: {fileID: 11500000, guid: da692e001514ec24dbc4cca1949ff7e8, type: 3} + m_Name: + m_EditorClassIdentifier: + version: 11 +--- !u!21 &2100000 +Material: + serializedVersion: 6 + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_Name: RL_Template_Baked_Skin_HDRP + m_Shader: {fileID: 4800000, guid: 6e4ae4064600d784cac1e41a9e6f2e59, type: 3} + m_ShaderKeywords: _DETAIL_MAP _DISABLE_SSR_TRANSPARENT _MASKMAP _MATERIAL_FEATURE_SUBSURFACE_SCATTERING + _MATERIAL_FEATURE_TRANSMISSION _NORMALMAP _NORMALMAP_TANGENT_SPACE _SUBSURFACE_MASK_MAP + _THICKNESSMAP + m_LightmapFlags: 4 + m_EnableInstancingVariants: 0 + m_DoubleSidedGI: 0 + m_CustomRenderQueue: 2225 + stringTagMap: + MotionVector: User + disabledShaderPasses: + - TransparentDepthPrepass + - TransparentDepthPostpass + - TransparentBackface + - RayTracingPrepass + - MOTIONVECTORS + m_SavedProperties: + serializedVersion: 3 + m_TexEnvs: + - _AnisotropyMap: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - _BaseColorMap: + m_Texture: {fileID: 2800000, guid: 2e6930762defd9149a4115ecb5f1a3f8, type: 3} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - _BentNormalMap: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - _BentNormalMapOS: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - _CoatMaskMap: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - _DetailMap: + m_Texture: {fileID: 2800000, guid: fba38fae484e7574a946d1527940b2b2, type: 3} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - _EmissiveColorMap: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - _HeightMap: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - _IridescenceMaskMap: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - _IridescenceThicknessMap: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - _MainTex: + m_Texture: {fileID: 2800000, guid: 2e6930762defd9149a4115ecb5f1a3f8, type: 3} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - _MaskMap: + m_Texture: {fileID: 2800000, guid: fba38fae484e7574a946d1527940b2b2, type: 3} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - _NormalMap: + m_Texture: {fileID: 2800000, guid: 924fb7f1705312d48b04eb5be69569ec, type: 3} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - _NormalMapOS: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - _SpecularColorMap: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - _SubsurfaceMaskMap: + m_Texture: {fileID: 2800000, guid: fba38fae484e7574a946d1527940b2b2, type: 3} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - _TangentMap: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - _TangentMapOS: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - _ThicknessMap: + m_Texture: {fileID: 2800000, guid: fba38fae484e7574a946d1527940b2b2, type: 3} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - _TransmittanceColorMap: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - unity_Lightmaps: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - unity_LightmapsInd: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - unity_ShadowMasks: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + m_Floats: + - _AORemapMax: 1 + - _AORemapMin: 0 + - _ATDistance: 1 + - _AddPrecomputedVelocity: 0 + - _AlbedoAffectEmissive: 0 + - _AlphaCutoff: 0.5 + - _AlphaCutoffEnable: 0 + - _AlphaCutoffPostpass: 0.5 + - _AlphaCutoffPrepass: 0.5 + - _AlphaCutoffShadow: 0.5 + - _AlphaDstBlend: 0 + - _AlphaSrcBlend: 1 + - _AlphaToMask: 0 + - _AlphaToMaskInspectorValue: 0 + - _Anisotropy: 0 + - _BlendMode: 0 + - _CoatMask: 0 + - _CullMode: 2 + - _CullModeForward: 2 + - _Cutoff: 0.5 + - _DepthOffsetEnable: 0 + - _DetailAlbedoScale: 1 + - _DetailNormalScale: 1 + - _DetailSmoothnessScale: 1 + - _DiffusionProfile: 0 + - _DiffusionProfileHash: 2.7317202 + - _DisplacementLockObjectScale: 1 + - _DisplacementLockTilingScale: 1 + - _DisplacementMode: 0 + - _DoubleSidedEnable: 0 + - _DoubleSidedNormalMode: 1 + - _DstBlend: 0 + - _EmissiveColorMode: 1 + - _EmissiveExposureWeight: 1 + - _EmissiveIntensity: 1 + - _EmissiveIntensityUnit: 0 + - _EnableBlendModePreserveSpecularLighting: 1 + - _EnableFogOnTransparent: 1 + - _EnableGeometricSpecularAA: 0 + - _EnergyConservingSpecularColor: 1 + - _HeightAmplitude: 0.02 + - _HeightCenter: 0.5 + - _HeightMapParametrization: 0 + - _HeightMax: 1 + - _HeightMin: -1 + - _HeightOffset: 0 + - _HeightPoMAmplitude: 2 + - _HeightTessAmplitude: 2 + - _HeightTessCenter: 0.5 + - _InvTilingScale: 1 + - _Ior: 1.5 + - _IridescenceMask: 1 + - _IridescenceThickness: 1 + - _LinkDetailsWithBase: 1 + - _MaterialID: 0 + - _Metallic: 0 + - _MetallicRemapMax: 1 + - _MetallicRemapMin: 0 + - _NormalMapSpace: 0 + - _NormalScale: 1 + - _OpaqueCullMode: 2 + - _PPDLodThreshold: 5 + - _PPDMaxSamples: 15 + - _PPDMinSamples: 5 + - _PPDPrimitiveLength: 1 + - _PPDPrimitiveWidth: 1 + - _RayTracing: 0 + - _ReceivesSSR: 1 + - _ReceivesSSRTransparent: 0 + - _RefractionModel: 0 + - _Smoothness: 0.5 + - _SmoothnessRemapMax: 1 + - _SmoothnessRemapMin: 0 + - _SpecularAAScreenSpaceVariance: 0.1 + - _SpecularAAThreshold: 0.2 + - _SpecularOcclusionMode: 1 + - _SrcBlend: 1 + - _StencilRef: 4 + - _StencilRefDepth: 8 + - _StencilRefGBuffer: 14 + - _StencilRefMV: 40 + - _StencilWriteMask: 6 + - _StencilWriteMaskDepth: 8 + - _StencilWriteMaskGBuffer: 14 + - _StencilWriteMaskMV: 40 + - _SubsurfaceMask: 1 + - _SupportDecals: 1 + - _SurfaceType: 0 + - _TexWorldScale: 1 + - _TexWorldScaleEmissive: 1 + - _Thickness: 1 + - _TransmissionEnable: 1 + - _TransparentBackfaceEnable: 0 + - _TransparentCullMode: 2 + - _TransparentDepthPostpassEnable: 0 + - _TransparentDepthPrepassEnable: 0 + - _TransparentSortPriority: 0 + - _TransparentWritingMotionVec: 0 + - _TransparentZWrite: 0 + - _UVBase: 0 + - _UVDetail: 0 + - _UVEmissive: 0 + - _UseEmissiveIntensity: 0 + - _UseShadowThreshold: 0 + - _ZTestDepthEqualForOpaque: 3 + - _ZTestGBuffer: 4 + - _ZTestTransparent: 4 + - _ZWrite: 1 + m_Colors: + - _BaseColor: {r: 1, g: 1, b: 1, a: 1} + - _BaseColorMap_MipInfo: {r: 0, g: 0, b: 0, a: 0} + - _Color: {r: 1, g: 1, b: 1, a: 1} + - _DiffusionProfileAsset: {r: -1.405437e+32, g: 2.0030989e-26, b: 0.00000006313206, a: -4.4045647e-18} + - _DoubleSidedConstants: {r: 1, g: 1, b: -1, a: 0} + - _EmissionColor: {r: 1, g: 1, b: 1, a: 1} + - _EmissiveColor: {r: 0, g: 0, b: 0, a: 1} + - _EmissiveColorLDR: {r: 0, g: 0, b: 0, a: 1} + - _InvPrimScale: {r: 1, g: 1, b: 0, a: 0} + - _IridescenceThicknessRemap: {r: 0, g: 1, b: 0, a: 0} + - _SpecularColor: {r: 1, g: 1, b: 1, a: 1} + - _ThicknessRemap: {r: 0, g: 1, b: 0, a: 0} + - _TransmittanceColor: {r: 1, g: 1, b: 1, a: 1} + - _UVDetailsMappingMask: {r: 1, g: 0, b: 0, a: 0} + - _UVMappingMask: {r: 1, g: 0, b: 0, a: 0} + - _UVMappingMaskEmissive: {r: 1, g: 0, b: 0, a: 0} + m_BuildTextureStacks: [] diff --git a/HDRP/Material Templates/RL_Template_Baked_Skin_HDRP.mat.meta b/HDRP/Material Templates/RL_Template_Baked_Skin_HDRP.mat.meta new file mode 100644 index 0000000..f11e5ee --- /dev/null +++ b/HDRP/Material Templates/RL_Template_Baked_Skin_HDRP.mat.meta @@ -0,0 +1,8 @@ +fileFormatVersion: 2 +guid: 424c74b137643eb478329bedaeb23667 +NativeFormatImporter: + externalObjects: {} + mainObjectFileID: 2100000 + userData: + assetBundleName: + assetBundleVariant: diff --git a/HDRP/Material Templates/RL_Template_Default_AlphaClip_HDRP.mat b/HDRP/Material Templates/RL_Template_Default_AlphaClip_HDRP.mat new file mode 100644 index 0000000..964b373 --- /dev/null +++ b/HDRP/Material Templates/RL_Template_Default_AlphaClip_HDRP.mat @@ -0,0 +1,261 @@ +%YAML 1.1 +%TAG !u! tag:unity3d.com,2011: +--- !u!114 &-4978073078925726089 +MonoBehaviour: + m_ObjectHideFlags: 11 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 0} + m_Enabled: 1 + m_EditorHideFlags: 0 + m_Script: {fileID: 11500000, guid: da692e001514ec24dbc4cca1949ff7e8, type: 3} + m_Name: + m_EditorClassIdentifier: + version: 11 +--- !u!21 &2100000 +Material: + serializedVersion: 6 + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_Name: RL_Template_Default_AlphaClip_HDRP + m_Shader: {fileID: 4800000, guid: 6e4ae4064600d784cac1e41a9e6f2e59, type: 3} + m_ShaderKeywords: _ALPHATEST_ON _ALPHATOMASK_ON _DISABLE_SSR_TRANSPARENT _DOUBLESIDED_ON + _ENABLE_FOG_ON_TRANSPARENT _MASKMAP _NORMALMAP _NORMALMAP_TANGENT_SPACE _SURFACE_TYPE_TRANSPARENT + _TRANSPARENT_WRITES_MOTION_VEC + m_LightmapFlags: 4 + m_EnableInstancingVariants: 0 + m_DoubleSidedGI: 1 + m_CustomRenderQueue: 3000 + stringTagMap: + RenderType: Transparent + disabledShaderPasses: + - TransparentDepthPrepass + - TransparentBackface + - MOTIONVECTORS + - RayTracingPrepass + - TransparentDepthPostpass + m_SavedProperties: + serializedVersion: 3 + m_TexEnvs: + - _AnisotropyMap: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - _BaseColorMap: + m_Texture: {fileID: 2800000, guid: 2e6930762defd9149a4115ecb5f1a3f8, type: 3} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - _BentNormalMap: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - _BentNormalMapOS: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - _CoatMaskMap: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - _DetailMap: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - _EmissiveColorMap: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - _HeightMap: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - _IridescenceMaskMap: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - _IridescenceThicknessMap: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - _MainTex: + m_Texture: {fileID: 2800000, guid: 2e6930762defd9149a4115ecb5f1a3f8, type: 3} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - _MaskMap: + m_Texture: {fileID: 2800000, guid: fba38fae484e7574a946d1527940b2b2, type: 3} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - _NormalMap: + m_Texture: {fileID: 2800000, guid: 924fb7f1705312d48b04eb5be69569ec, type: 3} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - _NormalMapOS: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - _SpecularColorMap: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - _SubsurfaceMaskMap: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - _TangentMap: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - _TangentMapOS: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - _ThicknessMap: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - _TransmittanceColorMap: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - unity_Lightmaps: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - unity_LightmapsInd: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - unity_ShadowMasks: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + m_Floats: + - _AORemapMax: 1 + - _AORemapMin: 0 + - _ATDistance: 1 + - _AddPrecomputedVelocity: 0 + - _AlbedoAffectEmissive: 0 + - _AlphaCutoff: 0.25 + - _AlphaCutoffEnable: 1 + - _AlphaCutoffPostpass: 0.5 + - _AlphaCutoffPrepass: 0.5 + - _AlphaCutoffShadow: 0.25 + - _AlphaDstBlend: 10 + - _AlphaSrcBlend: 1 + - _AlphaToMask: 1 + - _AlphaToMaskInspectorValue: 1 + - _Anisotropy: 0 + - _BlendMode: 0 + - _CoatMask: 0 + - _CullMode: 0 + - _CullModeForward: 0 + - _Cutoff: 0.25 + - _DepthOffsetEnable: 0 + - _DetailAlbedoScale: 1 + - _DetailNormalScale: 1 + - _DetailSmoothnessScale: 1 + - _DiffusionProfile: 0 + - _DiffusionProfileHash: 0 + - _DisplacementLockObjectScale: 1 + - _DisplacementLockTilingScale: 1 + - _DisplacementMode: 0 + - _DoubleSidedEnable: 1 + - _DoubleSidedNormalMode: 1 + - _DstBlend: 10 + - _EmissiveColorMode: 1 + - _EmissiveExposureWeight: 1 + - _EmissiveIntensity: 1 + - _EmissiveIntensityUnit: 0 + - _EnableBlendModePreserveSpecularLighting: 1 + - _EnableFogOnTransparent: 1 + - _EnableGeometricSpecularAA: 0 + - _EnergyConservingSpecularColor: 1 + - _HeightAmplitude: 0.02 + - _HeightCenter: 0.5 + - _HeightMapParametrization: 0 + - _HeightMax: 1 + - _HeightMin: -1 + - _HeightOffset: 0 + - _HeightPoMAmplitude: 2 + - _HeightTessAmplitude: 2 + - _HeightTessCenter: 0.5 + - _InvTilingScale: 1 + - _Ior: 1.5 + - _IridescenceMask: 1 + - _IridescenceThickness: 1 + - _LinkDetailsWithBase: 1 + - _MaterialID: 1 + - _Metallic: 0 + - _MetallicRemapMax: 1 + - _MetallicRemapMin: 0 + - _NormalMapSpace: 0 + - _NormalScale: 1 + - _OpaqueCullMode: 2 + - _PPDLodThreshold: 5 + - _PPDMaxSamples: 15 + - _PPDMinSamples: 5 + - _PPDPrimitiveLength: 1 + - _PPDPrimitiveWidth: 1 + - _RayTracing: 0 + - _ReceivesSSR: 1 + - _ReceivesSSRTransparent: 0 + - _RefractionModel: 0 + - _Smoothness: 0.5 + - _SmoothnessRemapMax: 0.88 + - _SmoothnessRemapMin: 0 + - _SpecularAAScreenSpaceVariance: 0.1 + - _SpecularAAThreshold: 0.2 + - _SpecularOcclusionMode: 1 + - _SrcBlend: 1 + - _StencilRef: 0 + - _StencilRefDepth: 0 + - _StencilRefGBuffer: 2 + - _StencilRefMV: 32 + - _StencilWriteMask: 6 + - _StencilWriteMaskDepth: 8 + - _StencilWriteMaskGBuffer: 14 + - _StencilWriteMaskMV: 40 + - _SubsurfaceMask: 1 + - _SupportDecals: 1 + - _SurfaceType: 1 + - _TexWorldScale: 1 + - _TexWorldScaleEmissive: 1 + - _Thickness: 1 + - _TransmissionEnable: 1 + - _TransparentBackfaceEnable: 0 + - _TransparentCullMode: 2 + - _TransparentDepthPostpassEnable: 0 + - _TransparentDepthPrepassEnable: 0 + - _TransparentSortPriority: 0 + - _TransparentWritingMotionVec: 1 + - _TransparentZWrite: 1 + - _UVBase: 0 + - _UVDetail: 0 + - _UVEmissive: 0 + - _UseEmissiveIntensity: 0 + - _UseShadowThreshold: 1 + - _ZTestDepthEqualForOpaque: 4 + - _ZTestGBuffer: 3 + - _ZTestTransparent: 4 + - _ZWrite: 1 + m_Colors: + - _BaseColor: {r: 1, g: 1, b: 1, a: 1} + - _BaseColorMap_MipInfo: {r: 0, g: 0, b: 0, a: 0} + - _Color: {r: 1, g: 1, b: 1, a: 1} + - _DiffusionProfileAsset: {r: 0, g: 0, b: 0, a: 0} + - _DoubleSidedConstants: {r: 1, g: 1, b: -1, a: 0} + - _EmissionColor: {r: 1, g: 1, b: 1, a: 1} + - _EmissiveColor: {r: 0, g: 0, b: 0, a: 1} + - _EmissiveColorLDR: {r: 0, g: 0, b: 0, a: 1} + - _InvPrimScale: {r: 1, g: 1, b: 0, a: 0} + - _IridescenceThicknessRemap: {r: 0, g: 1, b: 0, a: 0} + - _SpecularColor: {r: 1, g: 1, b: 1, a: 1} + - _ThicknessRemap: {r: 0, g: 1, b: 0, a: 0} + - _TransmittanceColor: {r: 1, g: 1, b: 1, a: 1} + - _UVDetailsMappingMask: {r: 1, g: 0, b: 0, a: 0} + - _UVMappingMask: {r: 1, g: 0, b: 0, a: 0} + - _UVMappingMaskEmissive: {r: 1, g: 0, b: 0, a: 0} + m_BuildTextureStacks: [] diff --git a/HDRP/Material Templates/RL_Template_Default_AlphaClip_HDRP.mat.meta b/HDRP/Material Templates/RL_Template_Default_AlphaClip_HDRP.mat.meta new file mode 100644 index 0000000..83b882f --- /dev/null +++ b/HDRP/Material Templates/RL_Template_Default_AlphaClip_HDRP.mat.meta @@ -0,0 +1,8 @@ +fileFormatVersion: 2 +guid: 34df85f08227cd54a995db4deacd20ee +NativeFormatImporter: + externalObjects: {} + mainObjectFileID: 2100000 + userData: + assetBundleName: + assetBundleVariant: diff --git a/HDRP/Material Templates/RL_Template_Default_EyeOcclusion_HDRP.mat b/HDRP/Material Templates/RL_Template_Default_EyeOcclusion_HDRP.mat new file mode 100644 index 0000000..79f30b5 --- /dev/null +++ b/HDRP/Material Templates/RL_Template_Default_EyeOcclusion_HDRP.mat @@ -0,0 +1,261 @@ +%YAML 1.1 +%TAG !u! tag:unity3d.com,2011: +--- !u!114 &-408364046999838362 +MonoBehaviour: + m_ObjectHideFlags: 11 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 0} + m_Enabled: 1 + m_EditorHideFlags: 0 + m_Script: {fileID: 11500000, guid: da692e001514ec24dbc4cca1949ff7e8, type: 3} + m_Name: + m_EditorClassIdentifier: + version: 11 +--- !u!21 &2100000 +Material: + serializedVersion: 6 + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_Name: RL_Template_Default_EyeOcclusion_HDRP + m_Shader: {fileID: 4800000, guid: 6e4ae4064600d784cac1e41a9e6f2e59, type: 3} + m_ShaderKeywords: _DISABLE_SSR_TRANSPARENT _ENABLE_FOG_ON_TRANSPARENT _NORMALMAP_TANGENT_SPACE + _SURFACE_TYPE_TRANSPARENT + m_LightmapFlags: 4 + m_EnableInstancingVariants: 0 + m_DoubleSidedGI: 0 + m_CustomRenderQueue: 2997 + stringTagMap: + RenderType: Transparent + disabledShaderPasses: + - DistortionVectors + - MOTIONVECTORS + - TransparentDepthPrepass + - TransparentDepthPostpass + - TransparentBackface + - RayTracingPrepass + m_SavedProperties: + serializedVersion: 3 + m_TexEnvs: + - _AnisotropyMap: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - _BaseColorMap: + m_Texture: {fileID: 2800000, guid: de8717c950fc50a4a837155e7e31cae2, type: 3} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - _BentNormalMap: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - _BentNormalMapOS: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - _CoatMaskMap: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - _DetailMap: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - _EmissiveColorMap: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - _HeightMap: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - _IridescenceMaskMap: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - _IridescenceThicknessMap: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - _MainTex: + m_Texture: {fileID: 2800000, guid: de8717c950fc50a4a837155e7e31cae2, type: 3} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - _MaskMap: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - _NormalMap: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - _NormalMapOS: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - _SpecularColorMap: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - _SubsurfaceMaskMap: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - _TangentMap: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - _TangentMapOS: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - _ThicknessMap: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - _TransmittanceColorMap: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - unity_Lightmaps: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - unity_LightmapsInd: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - unity_ShadowMasks: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + m_Floats: + - _AORemapMax: 1 + - _AORemapMin: 0 + - _ATDistance: 1 + - _AddPrecomputedVelocity: 0 + - _AlbedoAffectEmissive: 0 + - _AlphaCutoff: 0.5 + - _AlphaCutoffEnable: 0 + - _AlphaCutoffPostpass: 0.5 + - _AlphaCutoffPrepass: 0.5 + - _AlphaCutoffShadow: 0.5 + - _AlphaDstBlend: 10 + - _AlphaSrcBlend: 1 + - _AlphaToMask: 0 + - _AlphaToMaskInspectorValue: 0 + - _Anisotropy: 0 + - _BlendMode: 4 + - _CoatMask: 0 + - _CullMode: 2 + - _CullModeForward: 2 + - _Cutoff: 0.5 + - _DepthOffsetEnable: 0 + - _DetailAlbedoScale: 1 + - _DetailNormalScale: 1 + - _DetailSmoothnessScale: 1 + - _DiffusionProfile: 0 + - _DiffusionProfileHash: 0 + - _DisplacementLockObjectScale: 1 + - _DisplacementLockTilingScale: 1 + - _DisplacementMode: 0 + - _DoubleSidedEnable: 0 + - _DoubleSidedNormalMode: 1 + - _DstBlend: 10 + - _EmissiveColorMode: 1 + - _EmissiveExposureWeight: 1 + - _EmissiveIntensity: 1 + - _EmissiveIntensityUnit: 0 + - _EnableBlendModePreserveSpecularLighting: 0 + - _EnableFogOnTransparent: 1 + - _EnableGeometricSpecularAA: 0 + - _EnergyConservingSpecularColor: 1 + - _HeightAmplitude: 0.02 + - _HeightCenter: 0.5 + - _HeightMapParametrization: 0 + - _HeightMax: 1 + - _HeightMin: -1 + - _HeightOffset: 0 + - _HeightPoMAmplitude: 2 + - _HeightTessAmplitude: 2 + - _HeightTessCenter: 0.5 + - _InvTilingScale: 1 + - _Ior: 1.5 + - _IridescenceMask: 1 + - _IridescenceThickness: 1 + - _LinkDetailsWithBase: 1 + - _MaterialID: 1 + - _Metallic: 0 + - _MetallicRemapMax: 1 + - _MetallicRemapMin: 0 + - _NormalMapSpace: 0 + - _NormalScale: 1 + - _OpaqueCullMode: 2 + - _PPDLodThreshold: 5 + - _PPDMaxSamples: 15 + - _PPDMinSamples: 5 + - _PPDPrimitiveLength: 1 + - _PPDPrimitiveWidth: 1 + - _RayTracing: 0 + - _ReceivesSSR: 1 + - _ReceivesSSRTransparent: 0 + - _RefractionModel: 0 + - _Smoothness: 0 + - _SmoothnessRemapMax: 1 + - _SmoothnessRemapMin: 0 + - _SpecularAAScreenSpaceVariance: 0.1 + - _SpecularAAThreshold: 0.2 + - _SpecularOcclusionMode: 1 + - _SrcBlend: 1 + - _StencilRef: 0 + - _StencilRefDepth: 0 + - _StencilRefGBuffer: 2 + - _StencilRefMV: 32 + - _StencilWriteMask: 6 + - _StencilWriteMaskDepth: 8 + - _StencilWriteMaskGBuffer: 14 + - _StencilWriteMaskMV: 40 + - _SubsurfaceMask: 1 + - _SupportDecals: 1 + - _SurfaceType: 1 + - _TexWorldScale: 1 + - _TexWorldScaleEmissive: 1 + - _Thickness: 1 + - _TransmissionEnable: 1 + - _TransparentBackfaceEnable: 0 + - _TransparentCullMode: 2 + - _TransparentDepthPostpassEnable: 0 + - _TransparentDepthPrepassEnable: 0 + - _TransparentSortPriority: -3 + - _TransparentWritingMotionVec: 0 + - _TransparentZWrite: 0 + - _UVBase: 0 + - _UVDetail: 0 + - _UVEmissive: 0 + - _UseEmissiveIntensity: 0 + - _UseShadowThreshold: 0 + - _ZTestDepthEqualForOpaque: 4 + - _ZTestGBuffer: 4 + - _ZTestTransparent: 4 + - _ZWrite: 0 + m_Colors: + - _BaseColor: {r: 0.6, g: 0.6, b: 0.6, a: 0.6} + - _BaseColorMap_MipInfo: {r: 0, g: 0, b: 0, a: 0} + - _Color: {r: 0.6, g: 0.6, b: 0.6, a: 0.6} + - _DiffusionProfileAsset: {r: 0, g: 0, b: 0, a: 0} + - _DoubleSidedConstants: {r: 1, g: 1, b: -1, a: 0} + - _EmissionColor: {r: 1, g: 1, b: 1, a: 1} + - _EmissiveColor: {r: 0, g: 0, b: 0, a: 1} + - _EmissiveColorLDR: {r: 0, g: 0, b: 0, a: 1} + - _InvPrimScale: {r: 1, g: 1, b: 0, a: 0} + - _IridescenceThicknessRemap: {r: 0, g: 1, b: 0, a: 0} + - _SpecularColor: {r: 1, g: 1, b: 1, a: 1} + - _ThicknessRemap: {r: 0, g: 1, b: 0, a: 0} + - _TransmittanceColor: {r: 1, g: 1, b: 1, a: 1} + - _UVDetailsMappingMask: {r: 1, g: 0, b: 0, a: 0} + - _UVMappingMask: {r: 1, g: 0, b: 0, a: 0} + - _UVMappingMaskEmissive: {r: 1, g: 0, b: 0, a: 0} + m_BuildTextureStacks: [] diff --git a/HDRP/Material Templates/RL_Template_Default_EyeOcclusion_HDRP.mat.meta b/HDRP/Material Templates/RL_Template_Default_EyeOcclusion_HDRP.mat.meta new file mode 100644 index 0000000..ce0dca6 --- /dev/null +++ b/HDRP/Material Templates/RL_Template_Default_EyeOcclusion_HDRP.mat.meta @@ -0,0 +1,8 @@ +fileFormatVersion: 2 +guid: 34cc189d81c7e2b41a4f7f3a8151e8c9 +NativeFormatImporter: + externalObjects: {} + mainObjectFileID: 2100000 + userData: + assetBundleName: + assetBundleVariant: diff --git a/HDRP/Material Templates/RL_Template_Default_Eyelash_HDRP.mat b/HDRP/Material Templates/RL_Template_Default_Eyelash_HDRP.mat new file mode 100644 index 0000000..60a93b7 --- /dev/null +++ b/HDRP/Material Templates/RL_Template_Default_Eyelash_HDRP.mat @@ -0,0 +1,260 @@ +%YAML 1.1 +%TAG !u! tag:unity3d.com,2011: +--- !u!21 &2100000 +Material: + serializedVersion: 6 + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_Name: RL_Template_Default_Eyelash_HDRP + m_Shader: {fileID: 4800000, guid: 6e4ae4064600d784cac1e41a9e6f2e59, type: 3} + m_ShaderKeywords: _DISABLE_SSR_TRANSPARENT _DOUBLESIDED_ON _ENABLE_FOG_ON_TRANSPARENT + _MASKMAP _NORMALMAP _NORMALMAP_TANGENT_SPACE _SURFACE_TYPE_TRANSPARENT _TRANSPARENT_WRITES_MOTION_VEC + m_LightmapFlags: 4 + m_EnableInstancingVariants: 0 + m_DoubleSidedGI: 1 + m_CustomRenderQueue: 2999 + stringTagMap: + MotionVector: User + RenderType: Transparent + disabledShaderPasses: + - MOTIONVECTORS + - TransparentDepthPrepass + - TransparentBackface + - RayTracingPrepass + m_SavedProperties: + serializedVersion: 3 + m_TexEnvs: + - _AnisotropyMap: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - _BaseColorMap: + m_Texture: {fileID: 2800000, guid: 2e6930762defd9149a4115ecb5f1a3f8, type: 3} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - _BentNormalMap: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - _BentNormalMapOS: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - _CoatMaskMap: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - _DetailMap: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - _EmissiveColorMap: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - _HeightMap: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - _IridescenceMaskMap: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - _IridescenceThicknessMap: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - _MainTex: + m_Texture: {fileID: 2800000, guid: 2e6930762defd9149a4115ecb5f1a3f8, type: 3} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - _MaskMap: + m_Texture: {fileID: 2800000, guid: fba38fae484e7574a946d1527940b2b2, type: 3} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - _NormalMap: + m_Texture: {fileID: 2800000, guid: 924fb7f1705312d48b04eb5be69569ec, type: 3} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - _NormalMapOS: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - _SpecularColorMap: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - _SubsurfaceMaskMap: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - _TangentMap: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - _TangentMapOS: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - _ThicknessMap: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - _TransmittanceColorMap: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - unity_Lightmaps: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - unity_LightmapsInd: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - unity_ShadowMasks: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + m_Floats: + - _AORemapMax: 1 + - _AORemapMin: 0 + - _ATDistance: 1 + - _AddPrecomputedVelocity: 0 + - _AlbedoAffectEmissive: 0 + - _AlphaCutoff: 0.5 + - _AlphaCutoffEnable: 0 + - _AlphaCutoffPostpass: 0.5 + - _AlphaCutoffPrepass: 0.5 + - _AlphaCutoffShadow: 0.5 + - _AlphaDstBlend: 10 + - _AlphaSrcBlend: 1 + - _AlphaToMask: 0 + - _AlphaToMaskInspectorValue: 0 + - _Anisotropy: 0 + - _BlendMode: 0 + - _CoatMask: 0 + - _CullMode: 0 + - _CullModeForward: 0 + - _Cutoff: 0.5 + - _DepthOffsetEnable: 0 + - _DetailAlbedoScale: 1 + - _DetailNormalScale: 1 + - _DetailSmoothnessScale: 1 + - _DiffusionProfile: 0 + - _DiffusionProfileHash: 0 + - _DisplacementLockObjectScale: 1 + - _DisplacementLockTilingScale: 1 + - _DisplacementMode: 0 + - _DoubleSidedEnable: 1 + - _DoubleSidedNormalMode: 0 + - _DstBlend: 10 + - _EmissiveColorMode: 1 + - _EmissiveExposureWeight: 1 + - _EmissiveIntensity: 1 + - _EmissiveIntensityUnit: 0 + - _EnableBlendModePreserveSpecularLighting: 0 + - _EnableFogOnTransparent: 1 + - _EnableGeometricSpecularAA: 0 + - _EnergyConservingSpecularColor: 1 + - _HeightAmplitude: 0.02 + - _HeightCenter: 0.5 + - _HeightMapParametrization: 0 + - _HeightMax: 1 + - _HeightMin: -1 + - _HeightOffset: 0 + - _HeightPoMAmplitude: 2 + - _HeightTessAmplitude: 2 + - _HeightTessCenter: 0.5 + - _InvTilingScale: 1 + - _Ior: 1.5 + - _IridescenceMask: 1 + - _IridescenceThickness: 1 + - _LinkDetailsWithBase: 1 + - _MaterialID: 1 + - _Metallic: 0 + - _MetallicRemapMax: 1 + - _MetallicRemapMin: 0 + - _NormalMapSpace: 0 + - _NormalScale: 1 + - _OpaqueCullMode: 2 + - _PPDLodThreshold: 5 + - _PPDMaxSamples: 15 + - _PPDMinSamples: 5 + - _PPDPrimitiveLength: 1 + - _PPDPrimitiveWidth: 1 + - _RayTracing: 0 + - _ReceivesSSR: 1 + - _ReceivesSSRTransparent: 0 + - _RefractionModel: 0 + - _Smoothness: 0.5 + - _SmoothnessRemapMax: 0.5 + - _SmoothnessRemapMin: 0 + - _SpecularAAScreenSpaceVariance: 0.1 + - _SpecularAAThreshold: 0.2 + - _SpecularOcclusionMode: 1 + - _SrcBlend: 1 + - _StencilRef: 0 + - _StencilRefDepth: 0 + - _StencilRefGBuffer: 2 + - _StencilRefMV: 32 + - _StencilWriteMask: 6 + - _StencilWriteMaskDepth: 8 + - _StencilWriteMaskGBuffer: 14 + - _StencilWriteMaskMV: 40 + - _SubsurfaceMask: 1 + - _SupportDecals: 1 + - _SurfaceType: 1 + - _TexWorldScale: 1 + - _TexWorldScaleEmissive: 1 + - _Thickness: 1 + - _TransmissionEnable: 1 + - _TransparentBackfaceEnable: 0 + - _TransparentCullMode: 2 + - _TransparentDepthPostpassEnable: 1 + - _TransparentDepthPrepassEnable: 0 + - _TransparentSortPriority: -1 + - _TransparentWritingMotionVec: 1 + - _TransparentZWrite: 0 + - _UVBase: 0 + - _UVDetail: 0 + - _UVEmissive: 0 + - _UseEmissiveIntensity: 0 + - _UseShadowThreshold: 0 + - _ZTestDepthEqualForOpaque: 4 + - _ZTestGBuffer: 4 + - _ZTestTransparent: 4 + - _ZWrite: 0 + m_Colors: + - _BaseColor: {r: 1, g: 1, b: 1, a: 1} + - _BaseColorMap_MipInfo: {r: 0, g: 0, b: 0, a: 0} + - _Color: {r: 1, g: 1, b: 1, a: 1} + - _DiffusionProfileAsset: {r: 0, g: 0, b: 0, a: 0} + - _DoubleSidedConstants: {r: -1, g: -1, b: -1, a: 0} + - _EmissionColor: {r: 1, g: 1, b: 1, a: 1} + - _EmissiveColor: {r: 0, g: 0, b: 0, a: 1} + - _EmissiveColorLDR: {r: 0, g: 0, b: 0, a: 1} + - _InvPrimScale: {r: 1, g: 1, b: 0, a: 0} + - _IridescenceThicknessRemap: {r: 0, g: 1, b: 0, a: 0} + - _SpecularColor: {r: 1, g: 1, b: 1, a: 1} + - _ThicknessRemap: {r: 0, g: 1, b: 0, a: 0} + - _TransmittanceColor: {r: 1, g: 1, b: 1, a: 1} + - _UVDetailsMappingMask: {r: 1, g: 0, b: 0, a: 0} + - _UVMappingMask: {r: 1, g: 0, b: 0, a: 0} + - _UVMappingMaskEmissive: {r: 1, g: 0, b: 0, a: 0} + m_BuildTextureStacks: [] +--- !u!114 &2062867056901375254 +MonoBehaviour: + m_ObjectHideFlags: 11 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 0} + m_Enabled: 1 + m_EditorHideFlags: 0 + m_Script: {fileID: 11500000, guid: da692e001514ec24dbc4cca1949ff7e8, type: 3} + m_Name: + m_EditorClassIdentifier: + version: 11 diff --git a/HDRP/Material Templates/RL_Template_Default_Eyelash_HDRP.mat.meta b/HDRP/Material Templates/RL_Template_Default_Eyelash_HDRP.mat.meta new file mode 100644 index 0000000..270315f --- /dev/null +++ b/HDRP/Material Templates/RL_Template_Default_Eyelash_HDRP.mat.meta @@ -0,0 +1,8 @@ +fileFormatVersion: 2 +guid: c2359010df41e3b47a525f4fb0f49216 +NativeFormatImporter: + externalObjects: {} + mainObjectFileID: 2100000 + userData: + assetBundleName: + assetBundleVariant: diff --git a/HDRP/Material Templates/RL_Template_Default_Hair_HDRP.mat b/HDRP/Material Templates/RL_Template_Default_Hair_HDRP.mat new file mode 100644 index 0000000..612ce64 --- /dev/null +++ b/HDRP/Material Templates/RL_Template_Default_Hair_HDRP.mat @@ -0,0 +1,135 @@ +%YAML 1.1 +%TAG !u! tag:unity3d.com,2011: +--- !u!114 &-4978073078925726089 +MonoBehaviour: + m_ObjectHideFlags: 11 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 0} + m_Enabled: 1 + m_EditorHideFlags: 0 + m_Script: {fileID: 11500000, guid: da692e001514ec24dbc4cca1949ff7e8, type: 3} + m_Name: + m_EditorClassIdentifier: + version: 11 +--- !u!21 &2100000 +Material: + serializedVersion: 6 + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_Name: RL_Template_Default_Hair_HDRP + m_Shader: {fileID: -6465566751694194690, guid: 384d88ff5b296a44b89f1fb2d4442c01, type: 3} + m_ShaderKeywords: _ALPHATEST_ON _ALPHATOMASK_ON _DISABLE_SSR_TRANSPARENT _DOUBLESIDED_ON + _ENABLE_FOG_ON_TRANSPARENT _SURFACE_TYPE_TRANSPARENT _TRANSPARENT_WRITES_MOTION_VEC + m_LightmapFlags: 4 + m_EnableInstancingVariants: 0 + m_DoubleSidedGI: 1 + m_CustomRenderQueue: 3000 + stringTagMap: + MotionVector: User + RenderType: Transparent + disabledShaderPasses: + - RayTracingPrepass + - MOTIONVECTORS + m_SavedProperties: + serializedVersion: 3 + m_TexEnvs: + - _BaseColorMap: + m_Texture: {fileID: 2800000, guid: 2e6930762defd9149a4115ecb5f1a3f8, type: 3} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - _MaskMap: + m_Texture: {fileID: 2800000, guid: fba38fae484e7574a946d1527940b2b2, type: 3} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - _NormalMap: + m_Texture: {fileID: 2800000, guid: 924fb7f1705312d48b04eb5be69569ec, type: 3} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - _SmoothnessMask: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - unity_Lightmaps: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - unity_LightmapsInd: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - unity_ShadowMasks: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + m_Floats: + - _AddPrecomputedVelocity: 0 + - _AlphaClipThreshold: 0.15 + - _AlphaClipThresholdDepthPostpass: 0 + - _AlphaClipThresholdDepthPrepass: 0.9 + - _AlphaCutoffEnable: 1 + - _AlphaDstBlend: 10 + - _AlphaSrcBlend: 1 + - _AlphaThresholdShadow: 0.3 + - _AlphaToMask: 1 + - _AlphaToMaskInspectorValue: 1 + - _BlendMode: 0 + - _CullMode: 0 + - _CullModeForward: 2 + - _DepthOffsetEnable: 0 + - _DoubleSidedEnable: 1 + - _DoubleSidedNormalMode: 0 + - _DstBlend: 10 + - _EnableBlendModePreserveSpecularLighting: 1 + - _EnableFogOnTransparent: 1 + - _LightmapUV: 0 + - _NormalScale: 1 + - _OpaqueCullMode: 2 + - _ReceivesSSR: 1 + - _ReceivesSSRTransparent: 0 + - _RenderQueueType: 4 + - _RequireSplitLighting: 0 + - _SecondarySpecular: 0.05 + - _SecondarySpecularShift: 0.15 + - _SmoothnessMax: 0.5 + - _SmoothnessMin: 0 + - _Specular: 0.5 + - _SpecularShift: 0.15 + - _SrcBlend: 1 + - _StencilRef: 0 + - _StencilRefDepth: 0 + - _StencilRefDistortionVec: 4 + - _StencilRefGBuffer: 2 + - _StencilRefMV: 32 + - _StencilWriteMask: 6 + - _StencilWriteMaskDepth: 8 + - _StencilWriteMaskDistortionVec: 4 + - _StencilWriteMaskGBuffer: 14 + - _StencilWriteMaskMV: 40 + - _SupportDecals: 1 + - _SurfaceType: 1 + - _TransmissionRim: 0.05 + - _TransparentBackfaceEnable: 1 + - _TransparentCullMode: 2 + - _TransparentDepthPostpassEnable: 1 + - _TransparentDepthPrepassEnable: 1 + - _TransparentSortPriority: 0 + - _TransparentWritingMotionVec: 1 + - _TransparentZWrite: 0 + - _UseShadowThreshold: 1 + - _ZTestDepthEqualForOpaque: 4 + - _ZTestGBuffer: 3 + - _ZTestTransparent: 4 + - _ZWrite: 0 + m_Colors: + - _BaseColor: {r: 1, g: 1, b: 1, a: 1} + - _DoubleSidedConstants: {r: -1, g: -1, b: -1, a: 0} + - _EmissionColor: {r: 1, g: 1, b: 1, a: 1} + - _SpecularColor: {r: 1, g: 1, b: 1, a: 1} + - _TransmissionColor: {r: 1, g: 0.8666667, b: 0.627451, a: 1} + - _uvBaseST: {r: 1, g: 1, b: 0, a: 0} + - _uvSmoothnessST: {r: 20, g: 5, b: 0, a: 0} + m_BuildTextureStacks: [] diff --git a/HDRP/Material Templates/RL_Template_Default_Hair_HDRP.mat.meta b/HDRP/Material Templates/RL_Template_Default_Hair_HDRP.mat.meta new file mode 100644 index 0000000..aed5c92 --- /dev/null +++ b/HDRP/Material Templates/RL_Template_Default_Hair_HDRP.mat.meta @@ -0,0 +1,8 @@ +fileFormatVersion: 2 +guid: 7ee90b27915bf684986f68bfcf389c51 +NativeFormatImporter: + externalObjects: {} + mainObjectFileID: 2100000 + userData: + assetBundleName: + assetBundleVariant: diff --git a/HDRP/Material Templates/RL_Template_Default_Opaque_HDRP.mat b/HDRP/Material Templates/RL_Template_Default_Opaque_HDRP.mat new file mode 100644 index 0000000..aaa8c4f --- /dev/null +++ b/HDRP/Material Templates/RL_Template_Default_Opaque_HDRP.mat @@ -0,0 +1,259 @@ +%YAML 1.1 +%TAG !u! tag:unity3d.com,2011: +--- !u!114 &-3842705591719574230 +MonoBehaviour: + m_ObjectHideFlags: 11 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 0} + m_Enabled: 1 + m_EditorHideFlags: 0 + m_Script: {fileID: 11500000, guid: da692e001514ec24dbc4cca1949ff7e8, type: 3} + m_Name: + m_EditorClassIdentifier: + version: 11 +--- !u!21 &2100000 +Material: + serializedVersion: 6 + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_Name: RL_Template_Default_Opaque_HDRP + m_Shader: {fileID: 4800000, guid: 6e4ae4064600d784cac1e41a9e6f2e59, type: 3} + m_ShaderKeywords: _DISABLE_SSR_TRANSPARENT _MASKMAP _NORMALMAP _NORMALMAP_TANGENT_SPACE + m_LightmapFlags: 4 + m_EnableInstancingVariants: 0 + m_DoubleSidedGI: 0 + m_CustomRenderQueue: 2225 + stringTagMap: + MotionVector: User + disabledShaderPasses: + - TransparentDepthPrepass + - TransparentDepthPostpass + - TransparentBackface + - RayTracingPrepass + - MOTIONVECTORS + m_SavedProperties: + serializedVersion: 3 + m_TexEnvs: + - _AnisotropyMap: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - _BaseColorMap: + m_Texture: {fileID: 2800000, guid: 2e6930762defd9149a4115ecb5f1a3f8, type: 3} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - _BentNormalMap: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - _BentNormalMapOS: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - _CoatMaskMap: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - _DetailMap: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - _EmissiveColorMap: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - _HeightMap: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - _IridescenceMaskMap: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - _IridescenceThicknessMap: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - _MainTex: + m_Texture: {fileID: 2800000, guid: 2e6930762defd9149a4115ecb5f1a3f8, type: 3} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - _MaskMap: + m_Texture: {fileID: 2800000, guid: fba38fae484e7574a946d1527940b2b2, type: 3} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - _NormalMap: + m_Texture: {fileID: 2800000, guid: 924fb7f1705312d48b04eb5be69569ec, type: 3} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - _NormalMapOS: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - _SpecularColorMap: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - _SubsurfaceMaskMap: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - _TangentMap: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - _TangentMapOS: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - _ThicknessMap: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - _TransmittanceColorMap: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - unity_Lightmaps: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - unity_LightmapsInd: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - unity_ShadowMasks: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + m_Floats: + - _AORemapMax: 1 + - _AORemapMin: 0 + - _ATDistance: 1 + - _AddPrecomputedVelocity: 0 + - _AlbedoAffectEmissive: 0 + - _AlphaCutoff: 0.5 + - _AlphaCutoffEnable: 0 + - _AlphaCutoffPostpass: 0.5 + - _AlphaCutoffPrepass: 0.5 + - _AlphaCutoffShadow: 0.5 + - _AlphaDstBlend: 0 + - _AlphaSrcBlend: 1 + - _AlphaToMask: 0 + - _AlphaToMaskInspectorValue: 0 + - _Anisotropy: 0 + - _BlendMode: 0 + - _CoatMask: 0 + - _CullMode: 2 + - _CullModeForward: 2 + - _Cutoff: 0.5 + - _DepthOffsetEnable: 0 + - _DetailAlbedoScale: 1 + - _DetailNormalScale: 1 + - _DetailSmoothnessScale: 1 + - _DiffusionProfile: 0 + - _DiffusionProfileHash: 0 + - _DisplacementLockObjectScale: 1 + - _DisplacementLockTilingScale: 1 + - _DisplacementMode: 0 + - _DoubleSidedEnable: 0 + - _DoubleSidedNormalMode: 1 + - _DstBlend: 0 + - _EmissiveColorMode: 1 + - _EmissiveExposureWeight: 1 + - _EmissiveIntensity: 1 + - _EmissiveIntensityUnit: 0 + - _EnableBlendModePreserveSpecularLighting: 1 + - _EnableFogOnTransparent: 1 + - _EnableGeometricSpecularAA: 0 + - _EnergyConservingSpecularColor: 1 + - _HeightAmplitude: 0.02 + - _HeightCenter: 0.5 + - _HeightMapParametrization: 0 + - _HeightMax: 1 + - _HeightMin: -1 + - _HeightOffset: 0 + - _HeightPoMAmplitude: 2 + - _HeightTessAmplitude: 2 + - _HeightTessCenter: 0.5 + - _InvTilingScale: 1 + - _Ior: 1.5 + - _IridescenceMask: 1 + - _IridescenceThickness: 1 + - _LinkDetailsWithBase: 1 + - _MaterialID: 1 + - _Metallic: 0 + - _MetallicRemapMax: 1 + - _MetallicRemapMin: 0 + - _NormalMapSpace: 0 + - _NormalScale: 1 + - _OpaqueCullMode: 2 + - _PPDLodThreshold: 5 + - _PPDMaxSamples: 15 + - _PPDMinSamples: 5 + - _PPDPrimitiveLength: 1 + - _PPDPrimitiveWidth: 1 + - _RayTracing: 0 + - _ReceivesSSR: 1 + - _ReceivesSSRTransparent: 0 + - _RefractionModel: 0 + - _Smoothness: 0.5 + - _SmoothnessRemapMax: 0.88 + - _SmoothnessRemapMin: 0 + - _SpecularAAScreenSpaceVariance: 0.1 + - _SpecularAAThreshold: 0.2 + - _SpecularOcclusionMode: 1 + - _SrcBlend: 1 + - _StencilRef: 0 + - _StencilRefDepth: 8 + - _StencilRefGBuffer: 10 + - _StencilRefMV: 40 + - _StencilWriteMask: 6 + - _StencilWriteMaskDepth: 8 + - _StencilWriteMaskGBuffer: 14 + - _StencilWriteMaskMV: 40 + - _SubsurfaceMask: 1 + - _SupportDecals: 1 + - _SurfaceType: 0 + - _TexWorldScale: 1 + - _TexWorldScaleEmissive: 1 + - _Thickness: 1 + - _TransmissionEnable: 1 + - _TransparentBackfaceEnable: 0 + - _TransparentCullMode: 2 + - _TransparentDepthPostpassEnable: 0 + - _TransparentDepthPrepassEnable: 0 + - _TransparentSortPriority: 0 + - _TransparentWritingMotionVec: 0 + - _TransparentZWrite: 0 + - _UVBase: 0 + - _UVDetail: 0 + - _UVEmissive: 0 + - _UseEmissiveIntensity: 0 + - _UseShadowThreshold: 0 + - _ZTestDepthEqualForOpaque: 3 + - _ZTestGBuffer: 4 + - _ZTestTransparent: 4 + - _ZWrite: 1 + m_Colors: + - _BaseColor: {r: 1, g: 1, b: 1, a: 1} + - _BaseColorMap_MipInfo: {r: 0, g: 0, b: 0, a: 0} + - _Color: {r: 1, g: 1, b: 1, a: 1} + - _DiffusionProfileAsset: {r: 0, g: 0, b: 0, a: 0} + - _DoubleSidedConstants: {r: 1, g: 1, b: -1, a: 0} + - _EmissionColor: {r: 1, g: 1, b: 1, a: 1} + - _EmissiveColor: {r: 0, g: 0, b: 0, a: 1} + - _EmissiveColorLDR: {r: 0, g: 0, b: 0, a: 1} + - _InvPrimScale: {r: 1, g: 1, b: 0, a: 0} + - _IridescenceThicknessRemap: {r: 0, g: 1, b: 0, a: 0} + - _SpecularColor: {r: 1, g: 1, b: 1, a: 1} + - _ThicknessRemap: {r: 0, g: 1, b: 0, a: 0} + - _TransmittanceColor: {r: 1, g: 1, b: 1, a: 1} + - _UVDetailsMappingMask: {r: 1, g: 0, b: 0, a: 0} + - _UVMappingMask: {r: 1, g: 0, b: 0, a: 0} + - _UVMappingMaskEmissive: {r: 1, g: 0, b: 0, a: 0} + m_BuildTextureStacks: [] diff --git a/HDRP/Material Templates/RL_Template_Default_Opaque_HDRP.mat.meta b/HDRP/Material Templates/RL_Template_Default_Opaque_HDRP.mat.meta new file mode 100644 index 0000000..b87296c --- /dev/null +++ b/HDRP/Material Templates/RL_Template_Default_Opaque_HDRP.mat.meta @@ -0,0 +1,8 @@ +fileFormatVersion: 2 +guid: c023915403d2db94c9a6daaae3b539aa +NativeFormatImporter: + externalObjects: {} + mainObjectFileID: 2100000 + userData: + assetBundleName: + assetBundleVariant: diff --git a/HDRP/Material Templates/RL_Template_Default_ScalpBase_HDRP.mat b/HDRP/Material Templates/RL_Template_Default_ScalpBase_HDRP.mat new file mode 100644 index 0000000..3a113dd --- /dev/null +++ b/HDRP/Material Templates/RL_Template_Default_ScalpBase_HDRP.mat @@ -0,0 +1,260 @@ +%YAML 1.1 +%TAG !u! tag:unity3d.com,2011: +--- !u!21 &2100000 +Material: + serializedVersion: 6 + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_Name: RL_Template_Default_ScalpBase_HDRP + m_Shader: {fileID: 4800000, guid: 6e4ae4064600d784cac1e41a9e6f2e59, type: 3} + m_ShaderKeywords: _DISABLE_SSR_TRANSPARENT _ENABLE_FOG_ON_TRANSPARENT _MASKMAP + _NORMALMAP _NORMALMAP_TANGENT_SPACE _SURFACE_TYPE_TRANSPARENT _TRANSPARENT_WRITES_MOTION_VEC + m_LightmapFlags: 4 + m_EnableInstancingVariants: 0 + m_DoubleSidedGI: 0 + m_CustomRenderQueue: 2999 + stringTagMap: + MotionVector: User + RenderType: Transparent + disabledShaderPasses: + - MOTIONVECTORS + - TransparentDepthPrepass + - TransparentBackface + - RayTracingPrepass + m_SavedProperties: + serializedVersion: 3 + m_TexEnvs: + - _AnisotropyMap: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - _BaseColorMap: + m_Texture: {fileID: 2800000, guid: 2e6930762defd9149a4115ecb5f1a3f8, type: 3} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - _BentNormalMap: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - _BentNormalMapOS: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - _CoatMaskMap: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - _DetailMap: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - _EmissiveColorMap: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - _HeightMap: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - _IridescenceMaskMap: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - _IridescenceThicknessMap: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - _MainTex: + m_Texture: {fileID: 2800000, guid: 2e6930762defd9149a4115ecb5f1a3f8, type: 3} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - _MaskMap: + m_Texture: {fileID: 2800000, guid: fba38fae484e7574a946d1527940b2b2, type: 3} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - _NormalMap: + m_Texture: {fileID: 2800000, guid: 924fb7f1705312d48b04eb5be69569ec, type: 3} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - _NormalMapOS: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - _SpecularColorMap: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - _SubsurfaceMaskMap: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - _TangentMap: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - _TangentMapOS: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - _ThicknessMap: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - _TransmittanceColorMap: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - unity_Lightmaps: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - unity_LightmapsInd: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - unity_ShadowMasks: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + m_Floats: + - _AORemapMax: 1 + - _AORemapMin: 0 + - _ATDistance: 1 + - _AddPrecomputedVelocity: 0 + - _AlbedoAffectEmissive: 0 + - _AlphaCutoff: 0.5 + - _AlphaCutoffEnable: 0 + - _AlphaCutoffPostpass: 0.5 + - _AlphaCutoffPrepass: 0.5 + - _AlphaCutoffShadow: 0.5 + - _AlphaDstBlend: 10 + - _AlphaSrcBlend: 1 + - _AlphaToMask: 0 + - _AlphaToMaskInspectorValue: 0 + - _Anisotropy: 0 + - _BlendMode: 0 + - _CoatMask: 0 + - _CullMode: 2 + - _CullModeForward: 2 + - _Cutoff: 0.5 + - _DepthOffsetEnable: 0 + - _DetailAlbedoScale: 1 + - _DetailNormalScale: 1 + - _DetailSmoothnessScale: 1 + - _DiffusionProfile: 0 + - _DiffusionProfileHash: 0 + - _DisplacementLockObjectScale: 1 + - _DisplacementLockTilingScale: 1 + - _DisplacementMode: 0 + - _DoubleSidedEnable: 0 + - _DoubleSidedNormalMode: 1 + - _DstBlend: 10 + - _EmissiveColorMode: 1 + - _EmissiveExposureWeight: 1 + - _EmissiveIntensity: 1 + - _EmissiveIntensityUnit: 0 + - _EnableBlendModePreserveSpecularLighting: 0 + - _EnableFogOnTransparent: 1 + - _EnableGeometricSpecularAA: 0 + - _EnergyConservingSpecularColor: 1 + - _HeightAmplitude: 0.02 + - _HeightCenter: 0.5 + - _HeightMapParametrization: 0 + - _HeightMax: 1 + - _HeightMin: -1 + - _HeightOffset: 0 + - _HeightPoMAmplitude: 2 + - _HeightTessAmplitude: 2 + - _HeightTessCenter: 0.5 + - _InvTilingScale: 1 + - _Ior: 1.5 + - _IridescenceMask: 1 + - _IridescenceThickness: 1 + - _LinkDetailsWithBase: 1 + - _MaterialID: 1 + - _Metallic: 0 + - _MetallicRemapMax: 1 + - _MetallicRemapMin: 0 + - _NormalMapSpace: 0 + - _NormalScale: 1 + - _OpaqueCullMode: 2 + - _PPDLodThreshold: 5 + - _PPDMaxSamples: 15 + - _PPDMinSamples: 5 + - _PPDPrimitiveLength: 1 + - _PPDPrimitiveWidth: 1 + - _RayTracing: 0 + - _ReceivesSSR: 1 + - _ReceivesSSRTransparent: 0 + - _RefractionModel: 0 + - _Smoothness: 0.5 + - _SmoothnessRemapMax: 0.15 + - _SmoothnessRemapMin: 0 + - _SpecularAAScreenSpaceVariance: 0.1 + - _SpecularAAThreshold: 0.2 + - _SpecularOcclusionMode: 1 + - _SrcBlend: 1 + - _StencilRef: 0 + - _StencilRefDepth: 0 + - _StencilRefGBuffer: 2 + - _StencilRefMV: 32 + - _StencilWriteMask: 6 + - _StencilWriteMaskDepth: 8 + - _StencilWriteMaskGBuffer: 14 + - _StencilWriteMaskMV: 40 + - _SubsurfaceMask: 1 + - _SupportDecals: 1 + - _SurfaceType: 1 + - _TexWorldScale: 1 + - _TexWorldScaleEmissive: 1 + - _Thickness: 1 + - _TransmissionEnable: 1 + - _TransparentBackfaceEnable: 0 + - _TransparentCullMode: 2 + - _TransparentDepthPostpassEnable: 1 + - _TransparentDepthPrepassEnable: 0 + - _TransparentSortPriority: -1 + - _TransparentWritingMotionVec: 1 + - _TransparentZWrite: 0 + - _UVBase: 0 + - _UVDetail: 0 + - _UVEmissive: 0 + - _UseEmissiveIntensity: 0 + - _UseShadowThreshold: 0 + - _ZTestDepthEqualForOpaque: 4 + - _ZTestGBuffer: 4 + - _ZTestTransparent: 4 + - _ZWrite: 0 + m_Colors: + - _BaseColor: {r: 1, g: 1, b: 1, a: 1} + - _BaseColorMap_MipInfo: {r: 0, g: 0, b: 0, a: 0} + - _Color: {r: 1, g: 1, b: 1, a: 1} + - _DiffusionProfileAsset: {r: 0, g: 0, b: 0, a: 0} + - _DoubleSidedConstants: {r: 1, g: 1, b: -1, a: 0} + - _EmissionColor: {r: 1, g: 1, b: 1, a: 1} + - _EmissiveColor: {r: 0, g: 0, b: 0, a: 1} + - _EmissiveColorLDR: {r: 0, g: 0, b: 0, a: 1} + - _InvPrimScale: {r: 1, g: 1, b: 0, a: 0} + - _IridescenceThicknessRemap: {r: 0, g: 1, b: 0, a: 0} + - _SpecularColor: {r: 1, g: 1, b: 1, a: 1} + - _ThicknessRemap: {r: 0, g: 1, b: 0, a: 0} + - _TransmittanceColor: {r: 1, g: 1, b: 1, a: 1} + - _UVDetailsMappingMask: {r: 1, g: 0, b: 0, a: 0} + - _UVMappingMask: {r: 1, g: 0, b: 0, a: 0} + - _UVMappingMaskEmissive: {r: 1, g: 0, b: 0, a: 0} + m_BuildTextureStacks: [] +--- !u!114 &2062867056901375254 +MonoBehaviour: + m_ObjectHideFlags: 11 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 0} + m_Enabled: 1 + m_EditorHideFlags: 0 + m_Script: {fileID: 11500000, guid: da692e001514ec24dbc4cca1949ff7e8, type: 3} + m_Name: + m_EditorClassIdentifier: + version: 11 diff --git a/HDRP/Material Templates/RL_Template_Default_ScalpBase_HDRP.mat.meta b/HDRP/Material Templates/RL_Template_Default_ScalpBase_HDRP.mat.meta new file mode 100644 index 0000000..d957c46 --- /dev/null +++ b/HDRP/Material Templates/RL_Template_Default_ScalpBase_HDRP.mat.meta @@ -0,0 +1,8 @@ +fileFormatVersion: 2 +guid: dea828f0231a67542b87328430b396be +NativeFormatImporter: + externalObjects: {} + mainObjectFileID: 2100000 + userData: + assetBundleName: + assetBundleVariant: diff --git a/HDRP/Material Templates/RL_Template_Default_SingleMaterial_HDRP.mat b/HDRP/Material Templates/RL_Template_Default_SingleMaterial_HDRP.mat new file mode 100644 index 0000000..53d0c2d --- /dev/null +++ b/HDRP/Material Templates/RL_Template_Default_SingleMaterial_HDRP.mat @@ -0,0 +1,260 @@ +%YAML 1.1 +%TAG !u! tag:unity3d.com,2011: +--- !u!114 &-4978073078925726089 +MonoBehaviour: + m_ObjectHideFlags: 11 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 0} + m_Enabled: 1 + m_EditorHideFlags: 0 + m_Script: {fileID: 11500000, guid: da692e001514ec24dbc4cca1949ff7e8, type: 3} + m_Name: + m_EditorClassIdentifier: + version: 11 +--- !u!21 &2100000 +Material: + serializedVersion: 6 + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_Name: RL_Template_Default_SingleMaterial_HDRP + m_Shader: {fileID: 4800000, guid: 6e4ae4064600d784cac1e41a9e6f2e59, type: 3} + m_ShaderKeywords: _ALPHATEST_ON _ALPHATOMASK_ON _DISABLE_SSR_TRANSPARENT _DOUBLESIDED_ON + _MASKMAP _NORMALMAP _NORMALMAP_TANGENT_SPACE + m_LightmapFlags: 4 + m_EnableInstancingVariants: 0 + m_DoubleSidedGI: 1 + m_CustomRenderQueue: 2475 + stringTagMap: + RenderType: TransparentCutout + disabledShaderPasses: + - TransparentDepthPrepass + - TransparentBackface + - MOTIONVECTORS + - RayTracingPrepass + - TransparentDepthPostpass + m_SavedProperties: + serializedVersion: 3 + m_TexEnvs: + - _AnisotropyMap: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - _BaseColorMap: + m_Texture: {fileID: 2800000, guid: 2e6930762defd9149a4115ecb5f1a3f8, type: 3} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - _BentNormalMap: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - _BentNormalMapOS: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - _CoatMaskMap: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - _DetailMap: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - _EmissiveColorMap: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - _HeightMap: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - _IridescenceMaskMap: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - _IridescenceThicknessMap: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - _MainTex: + m_Texture: {fileID: 2800000, guid: 2e6930762defd9149a4115ecb5f1a3f8, type: 3} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - _MaskMap: + m_Texture: {fileID: 2800000, guid: fba38fae484e7574a946d1527940b2b2, type: 3} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - _NormalMap: + m_Texture: {fileID: 2800000, guid: 924fb7f1705312d48b04eb5be69569ec, type: 3} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - _NormalMapOS: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - _SpecularColorMap: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - _SubsurfaceMaskMap: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - _TangentMap: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - _TangentMapOS: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - _ThicknessMap: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - _TransmittanceColorMap: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - unity_Lightmaps: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - unity_LightmapsInd: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - unity_ShadowMasks: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + m_Floats: + - _AORemapMax: 1 + - _AORemapMin: 0 + - _ATDistance: 1 + - _AddPrecomputedVelocity: 0 + - _AlbedoAffectEmissive: 0 + - _AlphaCutoff: 0.25 + - _AlphaCutoffEnable: 1 + - _AlphaCutoffPostpass: 0.5 + - _AlphaCutoffPrepass: 0.5 + - _AlphaCutoffShadow: 0.25 + - _AlphaDstBlend: 0 + - _AlphaSrcBlend: 1 + - _AlphaToMask: 1 + - _AlphaToMaskInspectorValue: 1 + - _Anisotropy: 0 + - _BlendMode: 0 + - _CoatMask: 0 + - _CullMode: 0 + - _CullModeForward: 0 + - _Cutoff: 0.25 + - _DepthOffsetEnable: 0 + - _DetailAlbedoScale: 1 + - _DetailNormalScale: 1 + - _DetailSmoothnessScale: 1 + - _DiffusionProfile: 0 + - _DiffusionProfileHash: 0 + - _DisplacementLockObjectScale: 1 + - _DisplacementLockTilingScale: 1 + - _DisplacementMode: 0 + - _DoubleSidedEnable: 1 + - _DoubleSidedNormalMode: 0 + - _DstBlend: 0 + - _EmissiveColorMode: 1 + - _EmissiveExposureWeight: 1 + - _EmissiveIntensity: 1 + - _EmissiveIntensityUnit: 0 + - _EnableBlendModePreserveSpecularLighting: 1 + - _EnableFogOnTransparent: 1 + - _EnableGeometricSpecularAA: 0 + - _EnergyConservingSpecularColor: 1 + - _HeightAmplitude: 0.02 + - _HeightCenter: 0.5 + - _HeightMapParametrization: 0 + - _HeightMax: 1 + - _HeightMin: -1 + - _HeightOffset: 0 + - _HeightPoMAmplitude: 2 + - _HeightTessAmplitude: 2 + - _HeightTessCenter: 0.5 + - _InvTilingScale: 1 + - _Ior: 1.5 + - _IridescenceMask: 1 + - _IridescenceThickness: 1 + - _LinkDetailsWithBase: 1 + - _MaterialID: 1 + - _Metallic: 0 + - _MetallicRemapMax: 1 + - _MetallicRemapMin: 0 + - _NormalMapSpace: 0 + - _NormalScale: 1 + - _OpaqueCullMode: 2 + - _PPDLodThreshold: 5 + - _PPDMaxSamples: 15 + - _PPDMinSamples: 5 + - _PPDPrimitiveLength: 1 + - _PPDPrimitiveWidth: 1 + - _RayTracing: 0 + - _ReceivesSSR: 1 + - _ReceivesSSRTransparent: 0 + - _RefractionModel: 0 + - _Smoothness: 0.5 + - _SmoothnessRemapMax: 0.88 + - _SmoothnessRemapMin: 0 + - _SpecularAAScreenSpaceVariance: 0.1 + - _SpecularAAThreshold: 0.2 + - _SpecularOcclusionMode: 1 + - _SrcBlend: 1 + - _StencilRef: 0 + - _StencilRefDepth: 8 + - _StencilRefGBuffer: 10 + - _StencilRefMV: 40 + - _StencilWriteMask: 6 + - _StencilWriteMaskDepth: 8 + - _StencilWriteMaskGBuffer: 14 + - _StencilWriteMaskMV: 40 + - _SubsurfaceMask: 1 + - _SupportDecals: 1 + - _SurfaceType: 0 + - _TexWorldScale: 1 + - _TexWorldScaleEmissive: 1 + - _Thickness: 1 + - _TransmissionEnable: 1 + - _TransparentBackfaceEnable: 0 + - _TransparentCullMode: 2 + - _TransparentDepthPostpassEnable: 0 + - _TransparentDepthPrepassEnable: 0 + - _TransparentSortPriority: 0 + - _TransparentWritingMotionVec: 0 + - _TransparentZWrite: 0 + - _UVBase: 0 + - _UVDetail: 0 + - _UVEmissive: 0 + - _UseEmissiveIntensity: 0 + - _UseShadowThreshold: 1 + - _ZTestDepthEqualForOpaque: 3 + - _ZTestGBuffer: 3 + - _ZTestTransparent: 4 + - _ZWrite: 1 + m_Colors: + - _BaseColor: {r: 1, g: 1, b: 1, a: 1} + - _BaseColorMap_MipInfo: {r: 0, g: 0, b: 0, a: 0} + - _Color: {r: 1, g: 1, b: 1, a: 1} + - _DiffusionProfileAsset: {r: 0, g: 0, b: 0, a: 0} + - _DoubleSidedConstants: {r: -1, g: -1, b: -1, a: 0} + - _EmissionColor: {r: 1, g: 1, b: 1, a: 1} + - _EmissiveColor: {r: 0, g: 0, b: 0, a: 1} + - _EmissiveColorLDR: {r: 0, g: 0, b: 0, a: 1} + - _InvPrimScale: {r: 1, g: 1, b: 0, a: 0} + - _IridescenceThicknessRemap: {r: 0, g: 1, b: 0, a: 0} + - _SpecularColor: {r: 1, g: 1, b: 1, a: 1} + - _ThicknessRemap: {r: 0, g: 1, b: 0, a: 0} + - _TransmittanceColor: {r: 1, g: 1, b: 1, a: 1} + - _UVDetailsMappingMask: {r: 1, g: 0, b: 0, a: 0} + - _UVMappingMask: {r: 1, g: 0, b: 0, a: 0} + - _UVMappingMaskEmissive: {r: 1, g: 0, b: 0, a: 0} + m_BuildTextureStacks: [] diff --git a/HDRP/Material Templates/RL_Template_Default_SingleMaterial_HDRP.mat.meta b/HDRP/Material Templates/RL_Template_Default_SingleMaterial_HDRP.mat.meta new file mode 100644 index 0000000..f12c0bd --- /dev/null +++ b/HDRP/Material Templates/RL_Template_Default_SingleMaterial_HDRP.mat.meta @@ -0,0 +1,8 @@ +fileFormatVersion: 2 +guid: 0f4e301138141e241b80abdc85990760 +NativeFormatImporter: + externalObjects: {} + mainObjectFileID: 2100000 + userData: + assetBundleName: + assetBundleVariant: diff --git a/HDRP/Material Templates/RL_Template_Default_Skin_HDRP.mat b/HDRP/Material Templates/RL_Template_Default_Skin_HDRP.mat new file mode 100644 index 0000000..7aa62f6 --- /dev/null +++ b/HDRP/Material Templates/RL_Template_Default_Skin_HDRP.mat @@ -0,0 +1,276 @@ +%YAML 1.1 +%TAG !u! tag:unity3d.com,2011: +--- !u!114 &-4635880401996347712 +MonoBehaviour: + m_ObjectHideFlags: 11 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 0} + m_Enabled: 1 + m_EditorHideFlags: 0 + m_Script: {fileID: 11500000, guid: aa486462e6be1764e89c788ba30e61f7, type: 3} + m_Name: + m_EditorClassIdentifier: + m_DiffusionProfileReferences: + - {fileID: 11400000, guid: 26bdddf49760c61438938733f07fa2a2, type: 2} + m_MaterialReferences: [] +--- !u!114 &-3842705591719574230 +MonoBehaviour: + m_ObjectHideFlags: 11 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 0} + m_Enabled: 1 + m_EditorHideFlags: 0 + m_Script: {fileID: 11500000, guid: da692e001514ec24dbc4cca1949ff7e8, type: 3} + m_Name: + m_EditorClassIdentifier: + version: 11 +--- !u!21 &2100000 +Material: + serializedVersion: 6 + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_Name: RL_Template_Default_Skin_HDRP + m_Shader: {fileID: 4800000, guid: 6e4ae4064600d784cac1e41a9e6f2e59, type: 3} + m_ShaderKeywords: _DETAIL_MAP _DISABLE_SSR_TRANSPARENT _MASKMAP _MATERIAL_FEATURE_SUBSURFACE_SCATTERING + _MATERIAL_FEATURE_TRANSMISSION _NORMALMAP _NORMALMAP_TANGENT_SPACE _SUBSURFACE_MASK_MAP + _THICKNESSMAP + m_LightmapFlags: 4 + m_EnableInstancingVariants: 0 + m_DoubleSidedGI: 0 + m_CustomRenderQueue: 2225 + stringTagMap: + MotionVector: User + disabledShaderPasses: + - TransparentDepthPrepass + - TransparentDepthPostpass + - TransparentBackface + - RayTracingPrepass + - MOTIONVECTORS + m_SavedProperties: + serializedVersion: 3 + m_TexEnvs: + - _AnisotropyMap: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - _BaseColorMap: + m_Texture: {fileID: 2800000, guid: 2e6930762defd9149a4115ecb5f1a3f8, type: 3} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - _BentNormalMap: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - _BentNormalMapOS: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - _CoatMaskMap: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - _DetailMap: + m_Texture: {fileID: 2800000, guid: fba38fae484e7574a946d1527940b2b2, type: 3} + m_Scale: {x: 20, y: 20} + m_Offset: {x: 0, y: 0} + - _EmissiveColorMap: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - _HeightMap: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - _IridescenceMaskMap: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - _IridescenceThicknessMap: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - _MainTex: + m_Texture: {fileID: 2800000, guid: 2e6930762defd9149a4115ecb5f1a3f8, type: 3} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - _MaskMap: + m_Texture: {fileID: 2800000, guid: fba38fae484e7574a946d1527940b2b2, type: 3} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - _NormalMap: + m_Texture: {fileID: 2800000, guid: 924fb7f1705312d48b04eb5be69569ec, type: 3} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - _NormalMapOS: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - _SpecularColorMap: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - _SubsurfaceMaskMap: + m_Texture: {fileID: 2800000, guid: fba38fae484e7574a946d1527940b2b2, type: 3} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - _TangentMap: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - _TangentMapOS: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - _ThicknessMap: + m_Texture: {fileID: 2800000, guid: fba38fae484e7574a946d1527940b2b2, type: 3} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - _TransmittanceColorMap: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - unity_Lightmaps: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - unity_LightmapsInd: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - unity_ShadowMasks: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + m_Floats: + - _AORemapMax: 1 + - _AORemapMin: 0 + - _ATDistance: 1 + - _AddPrecomputedVelocity: 0 + - _AlbedoAffectEmissive: 0 + - _AlphaCutoff: 0.5 + - _AlphaCutoffEnable: 0 + - _AlphaCutoffPostpass: 0.5 + - _AlphaCutoffPrepass: 0.5 + - _AlphaCutoffShadow: 0.5 + - _AlphaDstBlend: 0 + - _AlphaSrcBlend: 1 + - _AlphaToMask: 0 + - _AlphaToMaskInspectorValue: 0 + - _Anisotropy: 0 + - _BlendMode: 0 + - _CoatMask: 0 + - _CullMode: 2 + - _CullModeForward: 2 + - _Cutoff: 0.5 + - _DepthOffsetEnable: 0 + - _DetailAlbedoScale: 0 + - _DetailNormalScale: 1 + - _DetailSmoothnessScale: 0 + - _DiffusionProfile: 0 + - _DiffusionProfileHash: 2.7317202 + - _DisplacementLockObjectScale: 1 + - _DisplacementLockTilingScale: 1 + - _DisplacementMode: 0 + - _DoubleSidedEnable: 0 + - _DoubleSidedNormalMode: 1 + - _DstBlend: 0 + - _EmissiveColorMode: 1 + - _EmissiveExposureWeight: 1 + - _EmissiveIntensity: 1 + - _EmissiveIntensityUnit: 0 + - _EnableBlendModePreserveSpecularLighting: 1 + - _EnableFogOnTransparent: 1 + - _EnableGeometricSpecularAA: 0 + - _EnergyConservingSpecularColor: 1 + - _HeightAmplitude: 0.02 + - _HeightCenter: 0.5 + - _HeightMapParametrization: 0 + - _HeightMax: 1 + - _HeightMin: -1 + - _HeightOffset: 0 + - _HeightPoMAmplitude: 2 + - _HeightTessAmplitude: 2 + - _HeightTessCenter: 0.5 + - _InvTilingScale: 1 + - _Ior: 1.5 + - _IridescenceMask: 1 + - _IridescenceThickness: 1 + - _LinkDetailsWithBase: 1 + - _MaterialID: 0 + - _Metallic: 0 + - _MetallicRemapMax: 1 + - _MetallicRemapMin: 0 + - _NormalMapSpace: 0 + - _NormalScale: 1 + - _OpaqueCullMode: 2 + - _PPDLodThreshold: 5 + - _PPDMaxSamples: 15 + - _PPDMinSamples: 5 + - _PPDPrimitiveLength: 1 + - _PPDPrimitiveWidth: 1 + - _RayTracing: 0 + - _ReceivesSSR: 1 + - _ReceivesSSRTransparent: 0 + - _RefractionModel: 0 + - _Smoothness: 0.5 + - _SmoothnessRemapMax: 0.7189502 + - _SmoothnessRemapMin: 0 + - _SpecularAAScreenSpaceVariance: 0.1 + - _SpecularAAThreshold: 0.2 + - _SpecularOcclusionMode: 1 + - _SrcBlend: 1 + - _StencilRef: 4 + - _StencilRefDepth: 8 + - _StencilRefGBuffer: 14 + - _StencilRefMV: 40 + - _StencilWriteMask: 6 + - _StencilWriteMaskDepth: 8 + - _StencilWriteMaskGBuffer: 14 + - _StencilWriteMaskMV: 40 + - _SubsurfaceMask: 1 + - _SupportDecals: 1 + - _SurfaceType: 0 + - _TexWorldScale: 1 + - _TexWorldScaleEmissive: 1 + - _Thickness: 1 + - _TransmissionEnable: 1 + - _TransparentBackfaceEnable: 0 + - _TransparentCullMode: 2 + - _TransparentDepthPostpassEnable: 0 + - _TransparentDepthPrepassEnable: 0 + - _TransparentSortPriority: 0 + - _TransparentWritingMotionVec: 0 + - _TransparentZWrite: 0 + - _UVBase: 0 + - _UVDetail: 0 + - _UVEmissive: 0 + - _UseEmissiveIntensity: 0 + - _UseShadowThreshold: 0 + - _ZTestDepthEqualForOpaque: 3 + - _ZTestGBuffer: 4 + - _ZTestTransparent: 4 + - _ZWrite: 1 + m_Colors: + - _BaseColor: {r: 1, g: 1, b: 1, a: 1} + - _BaseColorMap_MipInfo: {r: 0, g: 0, b: 0, a: 0} + - _Color: {r: 1, g: 1, b: 1, a: 1} + - _DiffusionProfileAsset: {r: -1.405437e+32, g: 2.0030989e-26, b: 0.00000006313206, a: -4.4045647e-18} + - _DoubleSidedConstants: {r: 1, g: 1, b: -1, a: 0} + - _EmissionColor: {r: 1, g: 1, b: 1, a: 1} + - _EmissiveColor: {r: 0, g: 0, b: 0, a: 1} + - _EmissiveColorLDR: {r: 0, g: 0, b: 0, a: 1} + - _InvPrimScale: {r: 1, g: 1, b: 0, a: 0} + - _IridescenceThicknessRemap: {r: 0, g: 1, b: 0, a: 0} + - _SpecularColor: {r: 1, g: 1, b: 1, a: 1} + - _ThicknessRemap: {r: 0.4, g: 1, b: 0, a: 0} + - _TransmittanceColor: {r: 1, g: 1, b: 1, a: 1} + - _UVDetailsMappingMask: {r: 1, g: 0, b: 0, a: 0} + - _UVMappingMask: {r: 1, g: 0, b: 0, a: 0} + - _UVMappingMaskEmissive: {r: 1, g: 0, b: 0, a: 0} + m_BuildTextureStacks: [] diff --git a/HDRP/Material Templates/RL_Template_Default_Skin_HDRP.mat.meta b/HDRP/Material Templates/RL_Template_Default_Skin_HDRP.mat.meta new file mode 100644 index 0000000..374a869 --- /dev/null +++ b/HDRP/Material Templates/RL_Template_Default_Skin_HDRP.mat.meta @@ -0,0 +1,8 @@ +fileFormatVersion: 2 +guid: 36128c2591570644a8079e6e7048efdf +NativeFormatImporter: + externalObjects: {} + mainObjectFileID: 2100000 + userData: + assetBundleName: + assetBundleVariant: diff --git a/HDRP/Material Templates/RL_Template_Default_Tearline_HDRP.mat b/HDRP/Material Templates/RL_Template_Default_Tearline_HDRP.mat new file mode 100644 index 0000000..d35d0b0 --- /dev/null +++ b/HDRP/Material Templates/RL_Template_Default_Tearline_HDRP.mat @@ -0,0 +1,260 @@ +%YAML 1.1 +%TAG !u! tag:unity3d.com,2011: +--- !u!114 &-3597491894954943127 +MonoBehaviour: + m_ObjectHideFlags: 11 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 0} + m_Enabled: 1 + m_EditorHideFlags: 0 + m_Script: {fileID: 11500000, guid: da692e001514ec24dbc4cca1949ff7e8, type: 3} + m_Name: + m_EditorClassIdentifier: + version: 11 +--- !u!21 &2100000 +Material: + serializedVersion: 6 + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_Name: RL_Template_Default_Tearline_HDRP + m_Shader: {fileID: 4800000, guid: 6e4ae4064600d784cac1e41a9e6f2e59, type: 3} + m_ShaderKeywords: _DISABLE_SSR_TRANSPARENT _ENABLE_FOG_ON_TRANSPARENT _NORMALMAP_TANGENT_SPACE + _SURFACE_TYPE_TRANSPARENT + m_LightmapFlags: 4 + m_EnableInstancingVariants: 0 + m_DoubleSidedGI: 0 + m_CustomRenderQueue: 2998 + stringTagMap: + RenderType: Transparent + disabledShaderPasses: + - TransparentDepthPrepass + - TransparentDepthPostpass + - TransparentBackface + - RayTracingPrepass + - MOTIONVECTORS + m_SavedProperties: + serializedVersion: 3 + m_TexEnvs: + - _AnisotropyMap: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - _BaseColorMap: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - _BentNormalMap: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - _BentNormalMapOS: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - _CoatMaskMap: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - _DetailMap: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - _EmissiveColorMap: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - _HeightMap: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - _IridescenceMaskMap: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - _IridescenceThicknessMap: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - _MainTex: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - _MaskMap: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - _NormalMap: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - _NormalMapOS: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - _SpecularColorMap: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - _SubsurfaceMaskMap: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - _TangentMap: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - _TangentMapOS: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - _ThicknessMap: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - _TransmittanceColorMap: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - unity_Lightmaps: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - unity_LightmapsInd: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - unity_ShadowMasks: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + m_Floats: + - _AORemapMax: 1 + - _AORemapMin: 0 + - _ATDistance: 1 + - _AddPrecomputedVelocity: 0 + - _AlbedoAffectEmissive: 0 + - _AlphaCutoff: 0.5 + - _AlphaCutoffEnable: 0 + - _AlphaCutoffPostpass: 0.5 + - _AlphaCutoffPrepass: 0.5 + - _AlphaCutoffShadow: 0.5 + - _AlphaDstBlend: 10 + - _AlphaSrcBlend: 1 + - _AlphaToMask: 0 + - _AlphaToMaskInspectorValue: 0 + - _Anisotropy: 0 + - _BlendMode: 4 + - _CoatMask: 0 + - _CullMode: 2 + - _CullModeForward: 2 + - _Cutoff: 0.5 + - _DepthOffsetEnable: 0 + - _DetailAlbedoScale: 1 + - _DetailNormalScale: 1 + - _DetailSmoothnessScale: 1 + - _DiffusionProfile: 0 + - _DiffusionProfileHash: 0 + - _DisplacementLockObjectScale: 1 + - _DisplacementLockTilingScale: 1 + - _DisplacementMode: 0 + - _DoubleSidedEnable: 0 + - _DoubleSidedNormalMode: 1 + - _DstBlend: 10 + - _EmissiveColorMode: 1 + - _EmissiveExposureWeight: 1 + - _EmissiveIntensity: 1 + - _EmissiveIntensityUnit: 0 + - _EnableBlendModePreserveSpecularLighting: 1 + - _EnableFogOnTransparent: 1 + - _EnableGeometricSpecularAA: 0 + - _EnergyConservingSpecularColor: 1 + - _HeightAmplitude: 0.02 + - _HeightCenter: 0.5 + - _HeightMapParametrization: 0 + - _HeightMax: 1 + - _HeightMin: -1 + - _HeightOffset: 0 + - _HeightPoMAmplitude: 2 + - _HeightTessAmplitude: 2 + - _HeightTessCenter: 0.5 + - _InvTilingScale: 1 + - _Ior: 1.5 + - _IridescenceMask: 1 + - _IridescenceThickness: 1 + - _LinkDetailsWithBase: 1 + - _MaterialID: 1 + - _Metallic: 0 + - _MetallicRemapMax: 1 + - _MetallicRemapMin: 0 + - _NormalMapSpace: 0 + - _NormalScale: 1 + - _OpaqueCullMode: 2 + - _PPDLodThreshold: 5 + - _PPDMaxSamples: 15 + - _PPDMinSamples: 5 + - _PPDPrimitiveLength: 1 + - _PPDPrimitiveWidth: 1 + - _RayTracing: 0 + - _ReceivesSSR: 1 + - _ReceivesSSRTransparent: 0 + - _RefractionModel: 0 + - _Smoothness: 1 + - _SmoothnessRemapMax: 1 + - _SmoothnessRemapMin: 0 + - _SpecularAAScreenSpaceVariance: 0.1 + - _SpecularAAThreshold: 0.2 + - _SpecularOcclusionMode: 1 + - _SrcBlend: 1 + - _StencilRef: 0 + - _StencilRefDepth: 0 + - _StencilRefGBuffer: 2 + - _StencilRefMV: 32 + - _StencilWriteMask: 6 + - _StencilWriteMaskDepth: 8 + - _StencilWriteMaskGBuffer: 14 + - _StencilWriteMaskMV: 40 + - _SubsurfaceMask: 1 + - _SupportDecals: 1 + - _SurfaceType: 1 + - _TexWorldScale: 1 + - _TexWorldScaleEmissive: 1 + - _Thickness: 1 + - _TransmissionEnable: 1 + - _TransparentBackfaceEnable: 0 + - _TransparentCullMode: 2 + - _TransparentDepthPostpassEnable: 0 + - _TransparentDepthPrepassEnable: 0 + - _TransparentSortPriority: -2 + - _TransparentWritingMotionVec: 0 + - _TransparentZWrite: 0 + - _UVBase: 0 + - _UVDetail: 0 + - _UVEmissive: 0 + - _UseEmissiveIntensity: 0 + - _UseShadowThreshold: 0 + - _ZTestDepthEqualForOpaque: 4 + - _ZTestGBuffer: 4 + - _ZTestTransparent: 4 + - _ZWrite: 0 + m_Colors: + - _BaseColor: {r: 0, g: 0, b: 0, a: 0} + - _BaseColorMap_MipInfo: {r: 0, g: 0, b: 0, a: 0} + - _Color: {r: 0, g: 0, b: 0, a: 0} + - _DiffusionProfileAsset: {r: 0, g: 0, b: 0, a: 0} + - _DoubleSidedConstants: {r: 1, g: 1, b: -1, a: 0} + - _EmissionColor: {r: 1, g: 1, b: 1, a: 1} + - _EmissiveColor: {r: 0, g: 0, b: 0, a: 1} + - _EmissiveColorLDR: {r: 0, g: 0, b: 0, a: 1} + - _InvPrimScale: {r: 1, g: 1, b: 0, a: 0} + - _IridescenceThicknessRemap: {r: 0, g: 1, b: 0, a: 0} + - _SpecularColor: {r: 1, g: 1, b: 1, a: 1} + - _ThicknessRemap: {r: 0, g: 1, b: 0, a: 0} + - _TransmittanceColor: {r: 1, g: 1, b: 1, a: 1} + - _UVDetailsMappingMask: {r: 1, g: 0, b: 0, a: 0} + - _UVMappingMask: {r: 1, g: 0, b: 0, a: 0} + - _UVMappingMaskEmissive: {r: 1, g: 0, b: 0, a: 0} + m_BuildTextureStacks: [] diff --git a/HDRP/Material Templates/RL_Template_Default_Tearline_HDRP.mat.meta b/HDRP/Material Templates/RL_Template_Default_Tearline_HDRP.mat.meta new file mode 100644 index 0000000..4e85d65 --- /dev/null +++ b/HDRP/Material Templates/RL_Template_Default_Tearline_HDRP.mat.meta @@ -0,0 +1,8 @@ +fileFormatVersion: 2 +guid: 8030603ee283b4543be5ca7705d5b4e8 +NativeFormatImporter: + externalObjects: {} + mainObjectFileID: 2100000 + userData: + assetBundleName: + assetBundleVariant: diff --git a/HDRP/Material Templates/RL_Template_HQ_CorneaRef_HDRP.mat b/HDRP/Material Templates/RL_Template_HQ_CorneaRef_HDRP.mat new file mode 100644 index 0000000..d4e3a75 --- /dev/null +++ b/HDRP/Material Templates/RL_Template_HQ_CorneaRef_HDRP.mat @@ -0,0 +1,156 @@ +%YAML 1.1 +%TAG !u! tag:unity3d.com,2011: +--- !u!114 &-5950502445045061723 +MonoBehaviour: + m_ObjectHideFlags: 11 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 0} + m_Enabled: 1 + m_EditorHideFlags: 0 + m_Script: {fileID: 11500000, guid: da692e001514ec24dbc4cca1949ff7e8, type: 3} + m_Name: + m_EditorClassIdentifier: + version: 11 +--- !u!21 &2100000 +Material: + serializedVersion: 6 + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_Name: RL_Template_HQ_CorneaRef_HDRP + m_Shader: {fileID: -6465566751694194690, guid: 48cccd4fafd06264c9dcce2137ba5738, type: 3} + m_ShaderKeywords: BOOLEAN_ISCORNEA_ON _DISABLE_SSR_TRANSPARENT _ENABLE_FOG_ON_TRANSPARENT + _REFRACTION_PLANE _SURFACE_TYPE_TRANSPARENT + m_LightmapFlags: 4 + m_EnableInstancingVariants: 0 + m_DoubleSidedGI: 0 + m_CustomRenderQueue: 2996 + stringTagMap: + MotionVector: User + RenderType: Transparent + disabledShaderPasses: + - MOTIONVECTORS + - TransparentDepthPostpass + - TransparentBackface + - RayTracingPrepass + - TransparentDepthPrepass + m_SavedProperties: + serializedVersion: 3 + m_TexEnvs: + - _ColorBlendMap: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - _CorneaDiffuseMap: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - _MaskMap: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - _ScleraDiffuseMap: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - _ScleraNormalMap: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - unity_Lightmaps: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - unity_LightmapsInd: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - unity_ShadowMasks: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + m_Floats: + - BOOLEAN_ISCORNEA: 1 + - _AOStrength: 0.2 + - _AddPrecomputedVelocity: 0 + - _AlphaCutoffEnable: 0 + - _AlphaDstBlend: 10 + - _AlphaSrcBlend: 1 + - _AlphaToMask: 0 + - _AlphaToMaskInspectorValue: 1 + - _BlendMode: 0 + - _ColorBlendStrength: 0.2 + - _CorneaSmoothness: 1 + - _CullMode: 2 + - _CullModeForward: 2 + - _DepthOffsetEnable: 0 + - _DepthRadius: 0.8 + - _DoubleSidedEnable: 0 + - _DoubleSidedNormalMode: 2 + - _DstBlend: 10 + - _EnableBlendModePreserveSpecularLighting: 1 + - _EnableFogOnTransparent: 1 + - _IOR: 1.4 + - _IrisBrightness: 1 + - _IrisDepth: 0.004 + - _IrisHue: 0.5 + - _IrisRadius: 0.15 + - _IrisSaturation: 1 + - _IrisScale: 1 + - _IrisSmoothness: 0 + - _IsLeftEye: 0 + - _LimbusDarkRadius: 0.1 + - _LimbusDarkWidth: 0.055 + - _LimbusWidth: 0.055 + - _OpaqueCullMode: 2 + - _PupilScale: 0.8 + - _RayTracing: 0 + - _ReceivesSSR: 1 + - _ReceivesSSRTransparent: 0 + - _RefractionModel: 1 + - _RefractionThickness: 0.01 + - _RenderQueueType: 4 + - _RequireSplitLighting: 0 + - _ScleraBrightness: 0.65 + - _ScleraHue: 0.5 + - _ScleraNormalStrength: 0.1 + - _ScleraNormalTiling: 2 + - _ScleraSaturation: 1 + - _ScleraScale: 1 + - _ScleraSmoothness: 0.8 + - _ShadowHardness: 0.5 + - _ShadowRadius: 0.275 + - _SrcBlend: 1 + - _StencilRef: 0 + - _StencilRefDepth: 0 + - _StencilRefDistortionVec: 4 + - _StencilRefGBuffer: 2 + - _StencilRefMV: 32 + - _StencilWriteMask: 6 + - _StencilWriteMaskDepth: 8 + - _StencilWriteMaskDistortionVec: 4 + - _StencilWriteMaskGBuffer: 14 + - _StencilWriteMaskMV: 40 + - _SupportDecals: 1 + - _SurfaceType: 1 + - _TransparentBackfaceEnable: 0 + - _TransparentCullMode: 2 + - _TransparentDepthPostpassEnable: 0 + - _TransparentDepthPrepassEnable: 0 + - _TransparentSortPriority: -4 + - _TransparentWritingMotionVec: 0 + - _TransparentZWrite: 0 + - _UseShadowThreshold: 1 + - _ZTestDepthEqualForOpaque: 4 + - _ZTestGBuffer: 4 + - _ZTestTransparent: 4 + - _ZWrite: 0 + m_Colors: + - _CornerShadowColor: {r: 1, g: 0.7333333, b: 0.6980392, a: 0} + - _DoubleSidedConstants: {r: 1, g: 1, b: -1, a: 0} + - _EmissionColor: {r: 1, g: 1, b: 1, a: 1} + - _LimbusColor: {r: 0, g: 0, b: 0, a: 0} + m_BuildTextureStacks: [] diff --git a/HDRP/Material Templates/RL_Template_HQ_CorneaRef_HDRP.mat.meta b/HDRP/Material Templates/RL_Template_HQ_CorneaRef_HDRP.mat.meta new file mode 100644 index 0000000..a42bc8f --- /dev/null +++ b/HDRP/Material Templates/RL_Template_HQ_CorneaRef_HDRP.mat.meta @@ -0,0 +1,8 @@ +fileFormatVersion: 2 +guid: bfb04cadcad425647a5f65b9a5eef682 +NativeFormatImporter: + externalObjects: {} + mainObjectFileID: 2100000 + userData: + assetBundleName: + assetBundleVariant: diff --git a/HDRP/Material Templates/RL_Template_HQ_Cornea_HDRP.mat b/HDRP/Material Templates/RL_Template_HQ_Cornea_HDRP.mat new file mode 100644 index 0000000..8834348 --- /dev/null +++ b/HDRP/Material Templates/RL_Template_HQ_Cornea_HDRP.mat @@ -0,0 +1,156 @@ +%YAML 1.1 +%TAG !u! tag:unity3d.com,2011: +--- !u!114 &-5950502445045061723 +MonoBehaviour: + m_ObjectHideFlags: 11 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 0} + m_Enabled: 1 + m_EditorHideFlags: 0 + m_Script: {fileID: 11500000, guid: da692e001514ec24dbc4cca1949ff7e8, type: 3} + m_Name: + m_EditorClassIdentifier: + version: 11 +--- !u!21 &2100000 +Material: + serializedVersion: 6 + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_Name: RL_Template_HQ_Cornea_HDRP + m_Shader: {fileID: -6465566751694194690, guid: 48cccd4fafd06264c9dcce2137ba5738, type: 3} + m_ShaderKeywords: BOOLEAN_ISCORNEA_ON _DISABLE_SSR_TRANSPARENT _ENABLE_FOG_ON_TRANSPARENT + _SURFACE_TYPE_TRANSPARENT + m_LightmapFlags: 4 + m_EnableInstancingVariants: 0 + m_DoubleSidedGI: 0 + m_CustomRenderQueue: 2996 + stringTagMap: + MotionVector: User + RenderType: Transparent + disabledShaderPasses: + - MOTIONVECTORS + - TransparentDepthPostpass + - TransparentBackface + - RayTracingPrepass + - TransparentDepthPrepass + m_SavedProperties: + serializedVersion: 3 + m_TexEnvs: + - _ColorBlendMap: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - _CorneaDiffuseMap: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - _MaskMap: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - _ScleraDiffuseMap: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - _ScleraNormalMap: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - unity_Lightmaps: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - unity_LightmapsInd: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - unity_ShadowMasks: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + m_Floats: + - BOOLEAN_ISCORNEA: 1 + - _AOStrength: 0.2 + - _AddPrecomputedVelocity: 0 + - _AlphaCutoffEnable: 0 + - _AlphaDstBlend: 10 + - _AlphaSrcBlend: 1 + - _AlphaToMask: 0 + - _AlphaToMaskInspectorValue: 1 + - _BlendMode: 0 + - _ColorBlendStrength: 0.2 + - _CorneaSmoothness: 1 + - _CullMode: 2 + - _CullModeForward: 2 + - _DepthOffsetEnable: 0 + - _DepthRadius: 0.8 + - _DoubleSidedEnable: 0 + - _DoubleSidedNormalMode: 2 + - _DstBlend: 10 + - _EnableBlendModePreserveSpecularLighting: 1 + - _EnableFogOnTransparent: 1 + - _IOR: 1.4 + - _IrisBrightness: 1 + - _IrisDepth: 0.004 + - _IrisHue: 0.5 + - _IrisRadius: 0.15 + - _IrisSaturation: 1 + - _IrisScale: 1 + - _IrisSmoothness: 0 + - _IsLeftEye: 0 + - _LimbusDarkRadius: 0.1 + - _LimbusDarkWidth: 0.055 + - _LimbusWidth: 0.055 + - _OpaqueCullMode: 2 + - _PupilScale: 0.8 + - _RayTracing: 0 + - _ReceivesSSR: 1 + - _ReceivesSSRTransparent: 0 + - _RefractionModel: 0 + - _RefractionThickness: 0.01 + - _RenderQueueType: 4 + - _RequireSplitLighting: 0 + - _ScleraBrightness: 0.65 + - _ScleraHue: 0.5 + - _ScleraNormalStrength: 0.1 + - _ScleraNormalTiling: 2 + - _ScleraSaturation: 1 + - _ScleraScale: 1 + - _ScleraSmoothness: 0.8 + - _ShadowHardness: 0.5 + - _ShadowRadius: 0.275 + - _SrcBlend: 1 + - _StencilRef: 0 + - _StencilRefDepth: 0 + - _StencilRefDistortionVec: 4 + - _StencilRefGBuffer: 2 + - _StencilRefMV: 32 + - _StencilWriteMask: 6 + - _StencilWriteMaskDepth: 8 + - _StencilWriteMaskDistortionVec: 4 + - _StencilWriteMaskGBuffer: 14 + - _StencilWriteMaskMV: 40 + - _SupportDecals: 1 + - _SurfaceType: 1 + - _TransparentBackfaceEnable: 0 + - _TransparentCullMode: 2 + - _TransparentDepthPostpassEnable: 0 + - _TransparentDepthPrepassEnable: 0 + - _TransparentSortPriority: -4 + - _TransparentWritingMotionVec: 0 + - _TransparentZWrite: 0 + - _UseShadowThreshold: 1 + - _ZTestDepthEqualForOpaque: 4 + - _ZTestGBuffer: 4 + - _ZTestTransparent: 4 + - _ZWrite: 0 + m_Colors: + - _CornerShadowColor: {r: 1, g: 0.7333333, b: 0.6980392, a: 0} + - _DoubleSidedConstants: {r: 1, g: 1, b: -1, a: 0} + - _EmissionColor: {r: 1, g: 1, b: 1, a: 1} + - _LimbusColor: {r: 0, g: 0, b: 0, a: 0} + m_BuildTextureStacks: [] diff --git a/HDRP/Material Templates/RL_Template_HQ_Cornea_HDRP.mat.meta b/HDRP/Material Templates/RL_Template_HQ_Cornea_HDRP.mat.meta new file mode 100644 index 0000000..d4ea797 --- /dev/null +++ b/HDRP/Material Templates/RL_Template_HQ_Cornea_HDRP.mat.meta @@ -0,0 +1,8 @@ +fileFormatVersion: 2 +guid: 843eb35c8a8792841aa40fd6f5933a7a +NativeFormatImporter: + externalObjects: {} + mainObjectFileID: 2100000 + userData: + assetBundleName: + assetBundleVariant: diff --git a/HDRP/Material Templates/RL_Template_HQ_EyeOcclusion_HDRP.mat b/HDRP/Material Templates/RL_Template_HQ_EyeOcclusion_HDRP.mat new file mode 100644 index 0000000..132bc01 --- /dev/null +++ b/HDRP/Material Templates/RL_Template_HQ_EyeOcclusion_HDRP.mat @@ -0,0 +1,122 @@ +%YAML 1.1 +%TAG !u! tag:unity3d.com,2011: +--- !u!114 &-3688768427451466403 +MonoBehaviour: + m_ObjectHideFlags: 11 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 0} + m_Enabled: 1 + m_EditorHideFlags: 0 + m_Script: {fileID: 11500000, guid: da692e001514ec24dbc4cca1949ff7e8, type: 3} + m_Name: + m_EditorClassIdentifier: + version: 11 +--- !u!21 &2100000 +Material: + serializedVersion: 6 + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_Name: RL_Template_HQ_EyeOcclusion_HDRP + m_Shader: {fileID: -6465566751694194690, guid: e11e1541751f73a4bbdc03b071617a93, type: 3} + m_ShaderKeywords: _ENABLE_FOG_ON_TRANSPARENT _SURFACE_TYPE_TRANSPARENT + m_LightmapFlags: 4 + m_EnableInstancingVariants: 0 + m_DoubleSidedGI: 0 + m_CustomRenderQueue: 2997 + stringTagMap: + MotionVector: User + RenderType: Transparent + disabledShaderPasses: + - TransparentDepthPrepass + - TransparentDepthPostpass + - TransparentBackface + - RayTracingPrepass + - MOTIONVECTORS + m_SavedProperties: + serializedVersion: 3 + m_TexEnvs: + - unity_Lightmaps: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - unity_LightmapsInd: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - unity_ShadowMasks: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + m_Floats: + - _AddPrecomputedVelocity: 0 + - _AlphaCutoffEnable: 0 + - _AlphaDstBlend: 10 + - _AlphaSrcBlend: 1 + - _AlphaToMask: 0 + - _AlphaToMaskInspectorValue: 0 + - _BlendMode: 0 + - _BottomCurve: 2 + - _BottomMax: 0.3 + - _BottomMin: 0.05 + - _CullMode: 2 + - _CullModeForward: 2 + - _DepthOffsetEnable: 0 + - _DoubleSidedEnable: 0 + - _DoubleSidedNormalMode: 2 + - _DstBlend: 10 + - _EnableBlendModePreserveSpecularLighting: 0 + - _EnableFogOnTransparent: 1 + - _ExpandInner: 0.0003 + - _ExpandLower: 0 + - _ExpandOut: 0 + - _ExpandOuter: 0.0007 + - _ExpandUpper: 0 + - _InnerMax: 0.5 + - _InnerMin: 0.25 + - _OcclusionPower: 1.5 + - _OcclusionStrength: 0.2 + - _OcclusionStrength2: 0.45 + - _OpaqueCullMode: 2 + - _OuterMax: 0.5 + - _OuterMin: 0.2 + - _RenderQueueType: 4 + - _SrcBlend: 1 + - _StencilRef: 0 + - _StencilRefDepth: 0 + - _StencilRefDistortionVec: 4 + - _StencilRefGBuffer: 2 + - _StencilRefMV: 32 + - _StencilWriteMask: 6 + - _StencilWriteMaskDepth: 8 + - _StencilWriteMaskDistortionVec: 4 + - _StencilWriteMaskGBuffer: 14 + - _StencilWriteMaskMV: 40 + - _SurfaceType: 1 + - _TearDuctPosition: 0.8 + - _TearDuctWidth: 0.5 + - _Top2Max: 1 + - _Top2Min: 0.15 + - _TopCurve: 1.287 + - _TopMax: 1 + - _TopMin: 0.1 + - _TransparentBackfaceEnable: 0 + - _TransparentCullMode: 2 + - _TransparentDepthPostpassEnable: 0 + - _TransparentDepthPrepassEnable: 0 + - _TransparentSortPriority: -3 + - _TransparentWritingMotionVec: 0 + - _TransparentZWrite: 0 + - _UseShadowThreshold: 0 + - _ZTestDepthEqualForOpaque: 4 + - _ZTestGBuffer: 4 + - _ZTestTransparent: 4 + - _ZWrite: 0 + m_Colors: + - _DoubleSidedConstants: {r: 1, g: 1, b: -1, a: 0} + - _EmissionColor: {r: 1, g: 1, b: 1, a: 1} + - _OcclusionColor: {r: 0.32941175, g: 0.094117604, b: 0.054901943, a: 0} + m_BuildTextureStacks: [] diff --git a/HDRP/Material Templates/RL_Template_HQ_EyeOcclusion_HDRP.mat.meta b/HDRP/Material Templates/RL_Template_HQ_EyeOcclusion_HDRP.mat.meta new file mode 100644 index 0000000..03a5dfc --- /dev/null +++ b/HDRP/Material Templates/RL_Template_HQ_EyeOcclusion_HDRP.mat.meta @@ -0,0 +1,8 @@ +fileFormatVersion: 2 +guid: 45766e0f2064d974b9eee5879b85906f +NativeFormatImporter: + externalObjects: {} + mainObjectFileID: 2100000 + userData: + assetBundleName: + assetBundleVariant: diff --git a/HDRP/Material Templates/RL_Template_HQ_Eye_HDRP.mat b/HDRP/Material Templates/RL_Template_HQ_Eye_HDRP.mat new file mode 100644 index 0000000..7e2615c --- /dev/null +++ b/HDRP/Material Templates/RL_Template_HQ_Eye_HDRP.mat @@ -0,0 +1,154 @@ +%YAML 1.1 +%TAG !u! tag:unity3d.com,2011: +--- !u!21 &2100000 +Material: + serializedVersion: 6 + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_Name: RL_Template_HQ_Eye_HDRP + m_Shader: {fileID: -6465566751694194690, guid: 48cccd4fafd06264c9dcce2137ba5738, type: 3} + m_ShaderKeywords: + m_LightmapFlags: 4 + m_EnableInstancingVariants: 0 + m_DoubleSidedGI: 0 + m_CustomRenderQueue: 2225 + stringTagMap: + MotionVector: User + disabledShaderPasses: + - MOTIONVECTORS + - TransparentDepthPostpass + - TransparentBackface + - RayTracingPrepass + - TransparentDepthPrepass + m_SavedProperties: + serializedVersion: 3 + m_TexEnvs: + - _ColorBlendMap: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - _CorneaDiffuseMap: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - _MaskMap: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - _ScleraDiffuseMap: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - _ScleraNormalMap: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - unity_Lightmaps: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - unity_LightmapsInd: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - unity_ShadowMasks: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + m_Floats: + - BOOLEAN_ISCORNEA: 0 + - _AOStrength: 0.2 + - _AddPrecomputedVelocity: 0 + - _AlphaCutoffEnable: 0 + - _AlphaDstBlend: 0 + - _AlphaSrcBlend: 1 + - _AlphaToMask: 0 + - _AlphaToMaskInspectorValue: 1 + - _BlendMode: 0 + - _ColorBlendStrength: 0.2 + - _CorneaSmoothness: 1 + - _CullMode: 2 + - _CullModeForward: 2 + - _DepthOffsetEnable: 0 + - _DepthRadius: 0.8 + - _DoubleSidedEnable: 0 + - _DoubleSidedNormalMode: 2 + - _DstBlend: 0 + - _EnableBlendModePreserveSpecularLighting: 1 + - _EnableFogOnTransparent: 1 + - _IOR: 1.4 + - _IrisBrightness: 1 + - _IrisDepth: 0.004 + - _IrisHue: 0.5 + - _IrisRadius: 0.15 + - _IrisSaturation: 1 + - _IrisScale: 1 + - _IrisSmoothness: 0 + - _IsLeftEye: 0 + - _LimbusDarkRadius: 0.1 + - _LimbusDarkWidth: 0.055 + - _LimbusWidth: 0.055 + - _OpaqueCullMode: 2 + - _PupilScale: 0.8 + - _RayTracing: 0 + - _ReceivesSSR: 1 + - _ReceivesSSRTransparent: 1 + - _RefractionModel: 1 + - _RefractionThickness: 0.01 + - _RenderQueueType: 1 + - _RequireSplitLighting: 0 + - _ScleraBrightness: 0.65 + - _ScleraHue: 0.5 + - _ScleraNormalStrength: 0.1 + - _ScleraNormalTiling: 2 + - _ScleraSaturation: 1 + - _ScleraScale: 1 + - _ScleraSmoothness: 0.8 + - _ShadowHardness: 0.5 + - _ShadowRadius: 0.275 + - _SrcBlend: 1 + - _StencilRef: 0 + - _StencilRefDepth: 8 + - _StencilRefDistortionVec: 4 + - _StencilRefGBuffer: 10 + - _StencilRefMV: 40 + - _StencilWriteMask: 6 + - _StencilWriteMaskDepth: 8 + - _StencilWriteMaskDistortionVec: 4 + - _StencilWriteMaskGBuffer: 14 + - _StencilWriteMaskMV: 40 + - _SupportDecals: 1 + - _SurfaceType: 0 + - _TransparentBackfaceEnable: 0 + - _TransparentCullMode: 2 + - _TransparentDepthPostpassEnable: 0 + - _TransparentDepthPrepassEnable: 0 + - _TransparentSortPriority: 0 + - _TransparentWritingMotionVec: 0 + - _TransparentZWrite: 0 + - _UseShadowThreshold: 1 + - _ZTestDepthEqualForOpaque: 3 + - _ZTestGBuffer: 4 + - _ZTestTransparent: 4 + - _ZWrite: 1 + m_Colors: + - _CornerShadowColor: {r: 1, g: 0.7333333, b: 0.6980392, a: 0} + - _DoubleSidedConstants: {r: 1, g: 1, b: -1, a: 0} + - _EmissionColor: {r: 1, g: 1, b: 1, a: 1} + - _LimbusColor: {r: 0, g: 0, b: 0, a: 0} + m_BuildTextureStacks: [] +--- !u!114 &7913225416247402805 +MonoBehaviour: + m_ObjectHideFlags: 11 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 0} + m_Enabled: 1 + m_EditorHideFlags: 0 + m_Script: {fileID: 11500000, guid: da692e001514ec24dbc4cca1949ff7e8, type: 3} + m_Name: + m_EditorClassIdentifier: + version: 11 diff --git a/HDRP/Material Templates/RL_Template_HQ_Eye_HDRP.mat.meta b/HDRP/Material Templates/RL_Template_HQ_Eye_HDRP.mat.meta new file mode 100644 index 0000000..c6a849f --- /dev/null +++ b/HDRP/Material Templates/RL_Template_HQ_Eye_HDRP.mat.meta @@ -0,0 +1,8 @@ +fileFormatVersion: 2 +guid: fb66d80eb1901e141bf51833949108ca +NativeFormatImporter: + externalObjects: {} + mainObjectFileID: 2100000 + userData: + assetBundleName: + assetBundleVariant: diff --git a/HDRP/Material Templates/RL_Template_HQ_Hair_HDRP.mat b/HDRP/Material Templates/RL_Template_HQ_Hair_HDRP.mat new file mode 100644 index 0000000..f2ce0b7 --- /dev/null +++ b/HDRP/Material Templates/RL_Template_HQ_Hair_HDRP.mat @@ -0,0 +1,180 @@ +%YAML 1.1 +%TAG !u! tag:unity3d.com,2011: +--- !u!21 &2100000 +Material: + serializedVersion: 6 + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_Name: RL_Template_HQ_Hair_HDRP + m_Shader: {fileID: -6465566751694194690, guid: 1b1fb9190f9a21344931aa2df1b6a845, type: 3} + m_ShaderKeywords: _ALPHATEST_ON _ALPHATOMASK_ON _DISABLE_SSR_TRANSPARENT _DOUBLESIDED_ON + _ENABLE_FOG_ON_TRANSPARENT _ENUMCLIPQUALITY_ON_STANDARD _SURFACE_TYPE_TRANSPARENT + _TRANSPARENT_WRITES_MOTION_VEC + m_LightmapFlags: 4 + m_EnableInstancingVariants: 0 + m_DoubleSidedGI: 1 + m_CustomRenderQueue: 3000 + stringTagMap: + MotionVector: User + RenderType: Transparent + disabledShaderPasses: + - RayTracingPrepass + - MOTIONVECTORS + m_SavedProperties: + serializedVersion: 3 + m_TexEnvs: + - _BlendMap: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - _DiffuseMap: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - _EmissionMap: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - _FlowMap: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - _IDMap: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - _MaskMap: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - _NormalMap: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - _RootMap: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - _SpecularMap: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - unity_Lightmaps: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - unity_LightmapsInd: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - unity_ShadowMasks: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + m_Floats: + - BOOLEAN_ENABLECOLOR: 0 + - _AOOccludeAll: 0 + - _AOStrength: 1 + - _AddPrecomputedVelocity: 0 + - _AlphaClip: 0.1 + - _AlphaCutoffEnable: 1 + - _AlphaDstBlend: 10 + - _AlphaPower: 0.8 + - _AlphaRemap: 0.6 + - _AlphaSrcBlend: 1 + - _AlphaToMask: 1 + - _AlphaToMaskInspectorValue: 1 + - _BaseColorStrength: 1 + - _BlendMode: 0 + - _BlendStrength: 1 + - _CullMode: 0 + - _CullModeForward: 2 + - _DepthOffsetEnable: 0 + - _DepthPostpass: 0.1 + - _DepthPrepass: 0.9 + - _DiffuseStrength: 1 + - _DoubleSidedEnable: 1 + - _DoubleSidedNormalMode: 0 + - _DstBlend: 10 + - _ENUMCLIPQUALITY_ON: 0 + - _EnableBlendModePreserveSpecularLighting: 1 + - _EnableFogOnTransparent: 1 + - _EndColorStrength: 1 + - _GlobalStrength: 1 + - _HighlightAOverlapEnd: 1 + - _HighlightAOverlapInvert: 1 + - _HighlightAStrength: 1 + - _HighlightBOverlapEnd: 1 + - _HighlightBOverlapInvert: 1 + - _HighlightBStrength: 0 + - _InvertRootMap: 0 + - _NormalStrength: 1 + - _OpaqueCullMode: 2 + - _ReceivesSSR: 1 + - _ReceivesSSRTransparent: 0 + - _RenderQueueType: 4 + - _RequireSplitLighting: 0 + - _RimTransmissionIntensity: 0.05 + - _RootColorStrength: 1 + - _SecondarySmoothness: 0.525 + - _SecondarySpecularMultiplier: 0.05 + - _SecondarySpecularShift: 0.15 + - _ShadowClip: 0.2 + - _SmoothnessMax: 0.8 + - _SmoothnessMin: 0 + - _SmoothnessPower: 1 + - _SpecularMultiplier: 0.5 + - _SpecularShift: 0.15 + - _SrcBlend: 1 + - _StencilRef: 0 + - _StencilRefDepth: 0 + - _StencilRefDistortionVec: 4 + - _StencilRefGBuffer: 2 + - _StencilRefMV: 32 + - _StencilWriteMask: 6 + - _StencilWriteMaskDepth: 8 + - _StencilWriteMaskDistortionVec: 4 + - _StencilWriteMaskGBuffer: 14 + - _StencilWriteMaskMV: 40 + - _SupportDecals: 1 + - _SurfaceType: 1 + - _TransparentBackfaceEnable: 1 + - _TransparentCullMode: 2 + - _TransparentDepthPostpassEnable: 1 + - _TransparentDepthPrepassEnable: 1 + - _TransparentSortPriority: 0 + - _TransparentWritingMotionVec: 1 + - _TransparentZWrite: 0 + - _UseShadowThreshold: 1 + - _VertexColorStrength: 0.5 + - _ZTestDepthEqualForOpaque: 4 + - _ZTestGBuffer: 3 + - _ZTestTransparent: 4 + - _ZWrite: 0 + m_Colors: + - _DoubleSidedConstants: {r: -1, g: -1, b: -1, a: 0} + - _EmissionColor: {r: 1, g: 1, b: 1, a: 1} + - _EndColor: {r: 0.6039216, g: 0.454902, b: 0.28627446, a: 0} + - _HighlightAColor: {r: 0.9137255, g: 0.7803922, b: 0.635294, a: 0} + - _HighlightADistribution: {r: 0.1, g: 0.2, b: 0.3, a: 0} + - _HighlightBColor: {r: 1, g: 1, b: 1, a: 0} + - _HighlightBDistribution: {r: 0.6, g: 0.7, b: 0.8, a: 0} + - _RootColor: {r: 0.32941175, g: 0.14117646, b: 0.050980367, a: 0} + - _SpecularTint: {r: 1, g: 1, b: 1, a: 1} + - _VertexBaseColor: {r: 0, g: 0, b: 0, a: 0} + m_BuildTextureStacks: [] +--- !u!114 &2688478677752794627 +MonoBehaviour: + m_ObjectHideFlags: 11 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 0} + m_Enabled: 1 + m_EditorHideFlags: 0 + m_Script: {fileID: 11500000, guid: da692e001514ec24dbc4cca1949ff7e8, type: 3} + m_Name: + m_EditorClassIdentifier: + version: 11 diff --git a/HDRP/Material Templates/RL_Template_HQ_Hair_HDRP.mat.meta b/HDRP/Material Templates/RL_Template_HQ_Hair_HDRP.mat.meta new file mode 100644 index 0000000..7c5ef09 --- /dev/null +++ b/HDRP/Material Templates/RL_Template_HQ_Hair_HDRP.mat.meta @@ -0,0 +1,8 @@ +fileFormatVersion: 2 +guid: 86f9d8a19e1a9604ab5188c4049400e5 +NativeFormatImporter: + externalObjects: {} + mainObjectFileID: 2100000 + userData: + assetBundleName: + assetBundleVariant: diff --git a/HDRP/Material Templates/RL_Template_HQ_Head_HDRP.mat b/HDRP/Material Templates/RL_Template_HQ_Head_HDRP.mat new file mode 100644 index 0000000..6440a00 --- /dev/null +++ b/HDRP/Material Templates/RL_Template_HQ_Head_HDRP.mat @@ -0,0 +1,214 @@ +%YAML 1.1 +%TAG !u! tag:unity3d.com,2011: +--- !u!21 &2100000 +Material: + serializedVersion: 6 + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_Name: RL_Template_HQ_Head_HDRP + m_Shader: {fileID: -6465566751694194690, guid: e4b1192022fa52046868c000971f662c, type: 3} + m_ShaderKeywords: BOOLEAN_IS_HEAD_ON _DISABLE_SSR_TRANSPARENT + m_LightmapFlags: 4 + m_EnableInstancingVariants: 0 + m_DoubleSidedGI: 0 + m_CustomRenderQueue: 2225 + stringTagMap: + MotionVector: User + disabledShaderPasses: + - TransparentDepthPrepass + - TransparentDepthPostpass + - TransparentBackface + - RayTracingPrepass + - MOTIONVECTORS + m_SavedProperties: + serializedVersion: 3 + m_TexEnvs: + - _AOMap: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - _CFULCMask: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - _ColorBlendMap: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - _DiffuseMap: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - _EarNeckMask: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - _MNAOMap: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - _MaskMap: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - _MetallicAlphaMap: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - _MicroNormalMap: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - _NormalBlendMap: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - _NormalMap: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - _RGBAMask: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - _SSSMap: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - _ThicknessMap: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - unity_Lightmaps: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - unity_LightmapsInd: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - unity_ShadowMasks: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + m_Floats: + - BOOLEAN_IS_HEAD: 1 + - _AOStrength: 1 + - _AScatterScale: 1 + - _ASmoothnessMod: 0 + - _AddPrecomputedVelocity: 0 + - _AlphaCutoffEnable: 0 + - _AlphaDstBlend: 0 + - _AlphaSrcBlend: 1 + - _AlphaToMask: 0 + - _AlphaToMaskInspectorValue: 0 + - _BScatterScale: 1 + - _BSmoothnessMod: 0 + - _BlendMode: 0 + - _CheekScatterScale: 1 + - _CheekSmoothnessMod: 0 + - _ChinScatterScale: 1 + - _ChinSmoothnessMod: 0 + - _ColorBlendStrength: 0.5 + - _CullMode: 2 + - _CullModeForward: 2 + - _DepthOffsetEnable: 0 + - _DiffusionProfileHash: 2.7317202 + - _DoubleSidedEnable: 0 + - _DoubleSidedNormalMode: 2 + - _DstBlend: 0 + - _EarScatterScale: 1 + - _EarSmoothnessMod: 0 + - _EnableBlendModePreserveSpecularLighting: 1 + - _EnableFogOnTransparent: 1 + - _ForeheadScatterScale: 1 + - _ForeheadSmoothnessMod: 0 + - _GScatterScale: 1 + - _GSmoothnessMod: 0 + - _LipsCavityAO: 2.5 + - _MicroNormalStrength: 0.5 + - _MicroNormalTiling: 25 + - _MicroSmoothnessMod: 0 + - _MouthCavityAO: 2.5 + - _NeckScatterScale: 1 + - _NeckSmoothnessMod: 0 + - _NormalBlendStrength: 0.5 + - _NostrilCavityAO: 2.5 + - _OpaqueCullMode: 2 + - _RScatterScale: 1 + - _RSmoothnessMod: 0 + - _RayTracing: 0 + - _ReceivesSSR: 1 + - _ReceivesSSRTransparent: 0 + - _RefractionModel: 0 + - _RenderQueueType: 1 + - _RequireSplitLighting: 1 + - _SmoothnessMax: 0.8 + - _SmoothnessMin: 0 + - _SmoothnessPower: 1 + - _SrcBlend: 1 + - _StencilRef: 4 + - _StencilRefDepth: 8 + - _StencilRefDistortionVec: 4 + - _StencilRefGBuffer: 14 + - _StencilRefMV: 40 + - _StencilWriteMask: 6 + - _StencilWriteMaskDepth: 8 + - _StencilWriteMaskDistortionVec: 4 + - _StencilWriteMaskGBuffer: 14 + - _StencilWriteMaskMV: 40 + - _SubsurfaceScale: 1 + - _SupportDecals: 1 + - _SurfaceType: 0 + - _ThicknessScale: 0.4 + - _TransparentBackfaceEnable: 0 + - _TransparentCullMode: 2 + - _TransparentDepthPostpassEnable: 0 + - _TransparentDepthPrepassEnable: 0 + - _TransparentSortPriority: 0 + - _TransparentWritingMotionVec: 0 + - _TransparentZWrite: 0 + - _UnmaskedScatterScale: 1 + - _UnmaskedSmoothnessMod: 0 + - _UpperLipScatterScale: 1 + - _UpperLipSmoothnessMod: 0 + - _UseShadowThreshold: 0 + - _ZTestDepthEqualForOpaque: 3 + - _ZTestGBuffer: 4 + - _ZTestTransparent: 4 + - _ZWrite: 1 + m_Colors: + - _DiffusionProfileAsset: {r: -1.405437e+32, g: 2.0030989e-26, b: 0.00000006313206, a: -4.4045647e-18} + - _DoubleSidedConstants: {r: 1, g: 1, b: -1, a: 0} + - _EmissionColor: {r: 1, g: 1, b: 1, a: 1} + m_BuildTextureStacks: [] +--- !u!114 &3368893710744450478 +MonoBehaviour: + m_ObjectHideFlags: 11 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 0} + m_Enabled: 1 + m_EditorHideFlags: 0 + m_Script: {fileID: 11500000, guid: da692e001514ec24dbc4cca1949ff7e8, type: 3} + m_Name: + m_EditorClassIdentifier: + version: 11 +--- !u!114 &7550266352547258012 +MonoBehaviour: + m_ObjectHideFlags: 11 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 0} + m_Enabled: 1 + m_EditorHideFlags: 0 + m_Script: {fileID: 11500000, guid: aa486462e6be1764e89c788ba30e61f7, type: 3} + m_Name: + m_EditorClassIdentifier: + m_DiffusionProfileReferences: + - {fileID: 11400000, guid: 26bdddf49760c61438938733f07fa2a2, type: 2} + m_MaterialReferences: [] diff --git a/HDRP/Material Templates/RL_Template_HQ_Head_HDRP.mat.meta b/HDRP/Material Templates/RL_Template_HQ_Head_HDRP.mat.meta new file mode 100644 index 0000000..8978410 --- /dev/null +++ b/HDRP/Material Templates/RL_Template_HQ_Head_HDRP.mat.meta @@ -0,0 +1,8 @@ +fileFormatVersion: 2 +guid: 98b51244fe155f74a89cc2734d83853e +NativeFormatImporter: + externalObjects: {} + mainObjectFileID: 2100000 + userData: + assetBundleName: + assetBundleVariant: diff --git a/HDRP/Material Templates/RL_Template_HQ_Skin_HDRP.mat b/HDRP/Material Templates/RL_Template_HQ_Skin_HDRP.mat new file mode 100644 index 0000000..d9fefba --- /dev/null +++ b/HDRP/Material Templates/RL_Template_HQ_Skin_HDRP.mat @@ -0,0 +1,214 @@ +%YAML 1.1 +%TAG !u! tag:unity3d.com,2011: +--- !u!114 &-3460971125383614642 +MonoBehaviour: + m_ObjectHideFlags: 11 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 0} + m_Enabled: 1 + m_EditorHideFlags: 0 + m_Script: {fileID: 11500000, guid: aa486462e6be1764e89c788ba30e61f7, type: 3} + m_Name: + m_EditorClassIdentifier: + m_DiffusionProfileReferences: + - {fileID: 11400000, guid: 26bdddf49760c61438938733f07fa2a2, type: 2} + m_MaterialReferences: [] +--- !u!21 &2100000 +Material: + serializedVersion: 6 + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_Name: RL_Template_HQ_Skin_HDRP + m_Shader: {fileID: -6465566751694194690, guid: e4b1192022fa52046868c000971f662c, type: 3} + m_ShaderKeywords: _DISABLE_SSR_TRANSPARENT + m_LightmapFlags: 4 + m_EnableInstancingVariants: 0 + m_DoubleSidedGI: 0 + m_CustomRenderQueue: 2225 + stringTagMap: + MotionVector: User + disabledShaderPasses: + - TransparentDepthPrepass + - TransparentDepthPostpass + - TransparentBackface + - RayTracingPrepass + - MOTIONVECTORS + m_SavedProperties: + serializedVersion: 3 + m_TexEnvs: + - _AOMap: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - _CFULCMask: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - _ColorBlendMap: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - _DiffuseMap: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - _EarNeckMask: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - _MNAOMap: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - _MaskMap: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - _MetallicAlphaMap: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - _MicroNormalMap: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - _NormalBlendMap: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - _NormalMap: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - _RGBAMask: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - _SSSMap: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - _ThicknessMap: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - unity_Lightmaps: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - unity_LightmapsInd: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - unity_ShadowMasks: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + m_Floats: + - BOOLEAN_IS_HEAD: 0 + - _AOStrength: 1 + - _AScatterScale: 1 + - _ASmoothnessMod: 0 + - _AddPrecomputedVelocity: 0 + - _AlphaCutoffEnable: 0 + - _AlphaDstBlend: 0 + - _AlphaSrcBlend: 1 + - _AlphaToMask: 0 + - _AlphaToMaskInspectorValue: 0 + - _BScatterScale: 1 + - _BSmoothnessMod: 0 + - _BlendMode: 0 + - _CheekScatterScale: 1 + - _CheekSmoothnessMod: 0 + - _ChinScatterScale: 1 + - _ChinSmoothnessMod: 0 + - _ColorBlendStrength: 0.5 + - _CullMode: 2 + - _CullModeForward: 2 + - _DepthOffsetEnable: 0 + - _DiffusionProfileHash: 2.7317202 + - _DoubleSidedEnable: 0 + - _DoubleSidedNormalMode: 2 + - _DstBlend: 0 + - _EarScatterScale: 1 + - _EarSmoothnessMod: 0 + - _EnableBlendModePreserveSpecularLighting: 1 + - _EnableFogOnTransparent: 1 + - _ForeheadScatterScale: 1 + - _ForeheadSmoothnessMod: 0 + - _GScatterScale: 1 + - _GSmoothnessMod: 0 + - _LipsCavityAO: 2.5 + - _MicroNormalStrength: 0.5 + - _MicroNormalTiling: 25 + - _MicroSmoothnessMod: 0 + - _MouthCavityAO: 2.5 + - _NeckScatterScale: 1 + - _NeckSmoothnessMod: 0 + - _NormalBlendStrength: 0.5 + - _NostrilCavityAO: 2.5 + - _OpaqueCullMode: 2 + - _RScatterScale: 1 + - _RSmoothnessMod: 0 + - _RayTracing: 0 + - _ReceivesSSR: 1 + - _ReceivesSSRTransparent: 0 + - _RefractionModel: 0 + - _RenderQueueType: 1 + - _RequireSplitLighting: 1 + - _SmoothnessMax: 0.8 + - _SmoothnessMin: 0 + - _SmoothnessPower: 1 + - _SrcBlend: 1 + - _StencilRef: 4 + - _StencilRefDepth: 8 + - _StencilRefDistortionVec: 4 + - _StencilRefGBuffer: 14 + - _StencilRefMV: 40 + - _StencilWriteMask: 6 + - _StencilWriteMaskDepth: 8 + - _StencilWriteMaskDistortionVec: 4 + - _StencilWriteMaskGBuffer: 14 + - _StencilWriteMaskMV: 40 + - _SubsurfaceScale: 1 + - _SupportDecals: 1 + - _SurfaceType: 0 + - _ThicknessScale: 0.4 + - _TransparentBackfaceEnable: 0 + - _TransparentCullMode: 2 + - _TransparentDepthPostpassEnable: 0 + - _TransparentDepthPrepassEnable: 0 + - _TransparentSortPriority: 0 + - _TransparentWritingMotionVec: 0 + - _TransparentZWrite: 0 + - _UnmaskedScatterScale: 1 + - _UnmaskedSmoothnessMod: 0 + - _UpperLipScatterScale: 1 + - _UpperLipSmoothnessMod: 0 + - _UseShadowThreshold: 0 + - _ZTestDepthEqualForOpaque: 3 + - _ZTestGBuffer: 4 + - _ZTestTransparent: 4 + - _ZWrite: 1 + m_Colors: + - _DiffusionProfileAsset: {r: -1.405437e+32, g: 2.0030989e-26, b: 0.00000006313206, a: -4.4045647e-18} + - _DoubleSidedConstants: {r: 1, g: 1, b: -1, a: 0} + - _EmissionColor: {r: 1, g: 1, b: 1, a: 1} + m_BuildTextureStacks: [] +--- !u!114 &168235113489978298 +MonoBehaviour: + m_ObjectHideFlags: 11 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 0} + m_Enabled: 1 + m_EditorHideFlags: 0 + m_Script: {fileID: 11500000, guid: da692e001514ec24dbc4cca1949ff7e8, type: 3} + m_Name: + m_EditorClassIdentifier: + version: 11 diff --git a/HDRP/Material Templates/RL_Template_HQ_Skin_HDRP.mat.meta b/HDRP/Material Templates/RL_Template_HQ_Skin_HDRP.mat.meta new file mode 100644 index 0000000..5857607 --- /dev/null +++ b/HDRP/Material Templates/RL_Template_HQ_Skin_HDRP.mat.meta @@ -0,0 +1,8 @@ +fileFormatVersion: 2 +guid: 5fa47099bf7fb534fbc8996a3525c82f +NativeFormatImporter: + externalObjects: {} + mainObjectFileID: 2100000 + userData: + assetBundleName: + assetBundleVariant: diff --git a/HDRP/Material Templates/RL_Template_HQ_Tearline_HDRP.mat b/HDRP/Material Templates/RL_Template_HQ_Tearline_HDRP.mat new file mode 100644 index 0000000..037251c --- /dev/null +++ b/HDRP/Material Templates/RL_Template_HQ_Tearline_HDRP.mat @@ -0,0 +1,111 @@ +%YAML 1.1 +%TAG !u! tag:unity3d.com,2011: +--- !u!114 &-253278940595695977 +MonoBehaviour: + m_ObjectHideFlags: 11 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 0} + m_Enabled: 1 + m_EditorHideFlags: 0 + m_Script: {fileID: 11500000, guid: da692e001514ec24dbc4cca1949ff7e8, type: 3} + m_Name: + m_EditorClassIdentifier: + version: 11 +--- !u!21 &2100000 +Material: + serializedVersion: 6 + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_Name: RL_Template_HQ_Tearline_HDRP + m_Shader: {fileID: -6465566751694194690, guid: 5acd4540882388b44adfb140c6c6290b, type: 3} + m_ShaderKeywords: _DISABLE_SSR_TRANSPARENT _ENABLE_FOG_ON_TRANSPARENT _SURFACE_TYPE_TRANSPARENT + m_LightmapFlags: 4 + m_EnableInstancingVariants: 0 + m_DoubleSidedGI: 0 + m_CustomRenderQueue: 2998 + stringTagMap: + MotionVector: User + RenderType: Transparent + disabledShaderPasses: + - MOTIONVECTORS + - TransparentDepthPostpass + - TransparentBackface + - RayTracingPrepass + - TransparentDepthPrepass + m_SavedProperties: + serializedVersion: 3 + m_TexEnvs: + - unity_Lightmaps: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - unity_LightmapsInd: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - unity_ShadowMasks: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + m_Floats: + - _AddPrecomputedVelocity: 0 + - _Alpha: 0 + - _AlphaCutoffEnable: 0 + - _AlphaDstBlend: 10 + - _AlphaSrcBlend: 1 + - _AlphaToMask: 0 + - _AlphaToMaskInspectorValue: 0 + - _BlendMode: 4 + - _CullMode: 2 + - _CullModeForward: 2 + - _DepthOffset: 0 + - _DepthOffsetEnable: 0 + - _DoubleSidedEnable: 0 + - _DoubleSidedNormalMode: 2 + - _DstBlend: 10 + - _EnableBlendModePreserveSpecularLighting: 1 + - _EnableFogOnTransparent: 1 + - _InnerOffset: 0.001 + - _Metallic: 0 + - _OpaqueCullMode: 2 + - _RayTracing: 0 + - _ReceivesSSR: 1 + - _ReceivesSSRTransparent: 0 + - _RefractionModel: 0 + - _RenderQueueType: 4 + - _RequireSplitLighting: 0 + - _Smoothness: 1 + - _SrcBlend: 1 + - _StencilRef: 0 + - _StencilRefDepth: 0 + - _StencilRefDistortionVec: 4 + - _StencilRefGBuffer: 2 + - _StencilRefMV: 32 + - _StencilWriteMask: 6 + - _StencilWriteMaskDepth: 8 + - _StencilWriteMaskDistortionVec: 4 + - _StencilWriteMaskGBuffer: 14 + - _StencilWriteMaskMV: 40 + - _SupportDecals: 1 + - _SurfaceType: 1 + - _TransparentBackfaceEnable: 0 + - _TransparentCullMode: 2 + - _TransparentDepthPostpassEnable: 0 + - _TransparentDepthPrepassEnable: 0 + - _TransparentSortPriority: -2 + - _TransparentWritingMotionVec: 0 + - _TransparentZWrite: 0 + - _UseShadowThreshold: 0 + - _ZTestDepthEqualForOpaque: 4 + - _ZTestGBuffer: 4 + - _ZTestTransparent: 4 + - _ZWrite: 0 + m_Colors: + - _BaseColor: {r: 0, g: 0, b: 0, a: 0} + - _DoubleSidedConstants: {r: 1, g: 1, b: -1, a: 0} + - _EmissionColor: {r: 1, g: 1, b: 1, a: 1} + m_BuildTextureStacks: [] diff --git a/HDRP/Material Templates/RL_Template_HQ_Tearline_HDRP.mat.meta b/HDRP/Material Templates/RL_Template_HQ_Tearline_HDRP.mat.meta new file mode 100644 index 0000000..4cfa27c --- /dev/null +++ b/HDRP/Material Templates/RL_Template_HQ_Tearline_HDRP.mat.meta @@ -0,0 +1,8 @@ +fileFormatVersion: 2 +guid: ce9a0ddb2296b1f408a2b2e71eebeac1 +NativeFormatImporter: + externalObjects: {} + mainObjectFileID: 2100000 + userData: + assetBundleName: + assetBundleVariant: diff --git a/HDRP/Material Templates/RL_Template_HQ_Teeth_HDRP.mat b/HDRP/Material Templates/RL_Template_HQ_Teeth_HDRP.mat new file mode 100644 index 0000000..3990673 --- /dev/null +++ b/HDRP/Material Templates/RL_Template_HQ_Teeth_HDRP.mat @@ -0,0 +1,162 @@ +%YAML 1.1 +%TAG !u! tag:unity3d.com,2011: +--- !u!21 &2100000 +Material: + serializedVersion: 6 + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_Name: RL_Template_HQ_Teeth_HDRP + m_Shader: {fileID: -6465566751694194690, guid: bade89290ffb11a468a4957d7cfbb4bd, type: 3} + m_ShaderKeywords: _DISABLE_SSR_TRANSPARENT + m_LightmapFlags: 4 + m_EnableInstancingVariants: 0 + m_DoubleSidedGI: 0 + m_CustomRenderQueue: 2225 + stringTagMap: + MotionVector: User + disabledShaderPasses: + - TransparentDepthPrepass + - TransparentDepthPostpass + - TransparentBackface + - RayTracingPrepass + - MOTIONVECTORS + m_SavedProperties: + serializedVersion: 3 + m_TexEnvs: + - _DiffuseMap: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - _GradientAOMap: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - _GumsMaskMap: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - _MaskMap: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - _MicroNormalMap: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - _NormalMap: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - unity_Lightmaps: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - unity_LightmapsInd: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - unity_ShadowMasks: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + m_Floats: + - _AOStrength: 1 + - _AddPrecomputedVelocity: 0 + - _AlphaCutoffEnable: 0 + - _AlphaDstBlend: 0 + - _AlphaSrcBlend: 1 + - _AlphaToMask: 0 + - _AlphaToMaskInspectorValue: 0 + - _BlendMode: 0 + - _CullMode: 2 + - _CullModeForward: 2 + - _DepthOffsetEnable: 0 + - _DiffusionProfileHash: 2.7317202 + - _DoubleSidedEnable: 0 + - _DoubleSidedNormalMode: 2 + - _DstBlend: 0 + - _EnableBlendModePreserveSpecularLighting: 1 + - _EnableFogOnTransparent: 1 + - _FrontAO: 1 + - _GumsBrightness: 0.9 + - _GumsSSS: 1 + - _GumsSaturation: 1 + - _GumsThickness: 0.85 + - _IsUpperTeeth: 0 + - _MicroNormalStrength: 0.3 + - _MicroNormalTiling: 10 + - _OpaqueCullMode: 2 + - _RayTracing: 0 + - _RearAO: 0 + - _ReceivesSSR: 1 + - _ReceivesSSRTransparent: 0 + - _RefractionModel: 0 + - _RenderQueueType: 1 + - _RequireSplitLighting: 1 + - _SmoothnessMax: 1 + - _SmoothnessMin: 0.25 + - _SmoothnessPower: 1 + - _SrcBlend: 1 + - _StencilRef: 4 + - _StencilRefDepth: 8 + - _StencilRefDistortionVec: 4 + - _StencilRefGBuffer: 14 + - _StencilRefMV: 40 + - _StencilWriteMask: 6 + - _StencilWriteMaskDepth: 8 + - _StencilWriteMaskDistortionVec: 4 + - _StencilWriteMaskGBuffer: 14 + - _StencilWriteMaskMV: 40 + - _SupportDecals: 1 + - _SurfaceType: 0 + - _TeethBrightness: 0.7 + - _TeethSSS: 0.5 + - _TeethSaturation: 0.9 + - _TeethThickness: 0.7 + - _TransparentBackfaceEnable: 0 + - _TransparentCullMode: 2 + - _TransparentDepthPostpassEnable: 0 + - _TransparentDepthPrepassEnable: 0 + - _TransparentSortPriority: 0 + - _TransparentWritingMotionVec: 0 + - _TransparentZWrite: 0 + - _UseShadowThreshold: 0 + - _ZTestDepthEqualForOpaque: 3 + - _ZTestGBuffer: 4 + - _ZTestTransparent: 4 + - _ZWrite: 1 + m_Colors: + - _DiffusionProfileAsset: {r: -1.405437e+32, g: 2.0030989e-26, b: 0.00000006313206, a: -4.4045647e-18} + - _DoubleSidedConstants: {r: 1, g: 1, b: -1, a: 0} + - _EmissionColor: {r: 1, g: 1, b: 1, a: 1} + m_BuildTextureStacks: [] +--- !u!114 &1002793509144919934 +MonoBehaviour: + m_ObjectHideFlags: 11 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 0} + m_Enabled: 1 + m_EditorHideFlags: 0 + m_Script: {fileID: 11500000, guid: aa486462e6be1764e89c788ba30e61f7, type: 3} + m_Name: + m_EditorClassIdentifier: + m_DiffusionProfileReferences: + - {fileID: 11400000, guid: 26bdddf49760c61438938733f07fa2a2, type: 2} + m_MaterialReferences: [] +--- !u!114 &8610666323703270636 +MonoBehaviour: + m_ObjectHideFlags: 11 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 0} + m_Enabled: 1 + m_EditorHideFlags: 0 + m_Script: {fileID: 11500000, guid: da692e001514ec24dbc4cca1949ff7e8, type: 3} + m_Name: + m_EditorClassIdentifier: + version: 11 diff --git a/HDRP/Material Templates/RL_Template_HQ_Teeth_HDRP.mat.meta b/HDRP/Material Templates/RL_Template_HQ_Teeth_HDRP.mat.meta new file mode 100644 index 0000000..0dc806d --- /dev/null +++ b/HDRP/Material Templates/RL_Template_HQ_Teeth_HDRP.mat.meta @@ -0,0 +1,8 @@ +fileFormatVersion: 2 +guid: bf2c2c56978b6da41826aba0690d6a97 +NativeFormatImporter: + externalObjects: {} + mainObjectFileID: 2100000 + userData: + assetBundleName: + assetBundleVariant: diff --git a/HDRP/Material Templates/RL_Template_HQ_Tongue_HDRP.mat b/HDRP/Material Templates/RL_Template_HQ_Tongue_HDRP.mat new file mode 100644 index 0000000..4a02007 --- /dev/null +++ b/HDRP/Material Templates/RL_Template_HQ_Tongue_HDRP.mat @@ -0,0 +1,153 @@ +%YAML 1.1 +%TAG !u! tag:unity3d.com,2011: +--- !u!114 &-4168683714291570087 +MonoBehaviour: + m_ObjectHideFlags: 11 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 0} + m_Enabled: 1 + m_EditorHideFlags: 0 + m_Script: {fileID: 11500000, guid: aa486462e6be1764e89c788ba30e61f7, type: 3} + m_Name: + m_EditorClassIdentifier: + m_DiffusionProfileReferences: + - {fileID: 11400000, guid: 26bdddf49760c61438938733f07fa2a2, type: 2} + m_MaterialReferences: [] +--- !u!114 &-1149261412115614025 +MonoBehaviour: + m_ObjectHideFlags: 11 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 0} + m_Enabled: 1 + m_EditorHideFlags: 0 + m_Script: {fileID: 11500000, guid: da692e001514ec24dbc4cca1949ff7e8, type: 3} + m_Name: + m_EditorClassIdentifier: + version: 11 +--- !u!21 &2100000 +Material: + serializedVersion: 6 + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_Name: RL_Template_HQ_Tongue_HDRP + m_Shader: {fileID: -6465566751694194690, guid: 9cea8e6ce656ff148a2ec8e1550340ce, type: 3} + m_ShaderKeywords: _DISABLE_SSR_TRANSPARENT + m_LightmapFlags: 4 + m_EnableInstancingVariants: 0 + m_DoubleSidedGI: 0 + m_CustomRenderQueue: 2225 + stringTagMap: + MotionVector: User + disabledShaderPasses: + - TransparentDepthPrepass + - TransparentDepthPostpass + - TransparentBackface + - RayTracingPrepass + - MOTIONVECTORS + m_SavedProperties: + serializedVersion: 3 + m_TexEnvs: + - _DiffuseMap: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - _GradientAOMap: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - _MaskMap: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - _MicroNormalMap: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - _NormalMap: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - unity_Lightmaps: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - unity_LightmapsInd: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - unity_ShadowMasks: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + m_Floats: + - _AOStrength: 1 + - _AddPrecomputedVelocity: 0 + - _AlphaCutoffEnable: 0 + - _AlphaDstBlend: 0 + - _AlphaSrcBlend: 1 + - _AlphaToMask: 0 + - _AlphaToMaskInspectorValue: 0 + - _BlendMode: 0 + - _CullMode: 2 + - _CullModeForward: 2 + - _DepthOffsetEnable: 0 + - _DiffusionProfileHash: 2.7317202 + - _DoubleSidedEnable: 0 + - _DoubleSidedNormalMode: 2 + - _DstBlend: 0 + - _EnableBlendModePreserveSpecularLighting: 1 + - _EnableFogOnTransparent: 1 + - _FrontAO: 1 + - _MicroNormalStrength: 0.5 + - _MicroNormalTiling: 4 + - _OpaqueCullMode: 2 + - _RayTracing: 0 + - _RearAO: 0 + - _ReceivesSSR: 1 + - _ReceivesSSRTransparent: 0 + - _RefractionModel: 0 + - _RenderQueueType: 1 + - _RequireSplitLighting: 1 + - _SmoothnessMax: 1 + - _SmoothnessMin: 0.25 + - _SmoothnessPower: 1 + - _SrcBlend: 1 + - _StencilRef: 4 + - _StencilRefDepth: 8 + - _StencilRefDistortionVec: 4 + - _StencilRefGBuffer: 14 + - _StencilRefMV: 40 + - _StencilWriteMask: 6 + - _StencilWriteMaskDepth: 8 + - _StencilWriteMaskDistortionVec: 4 + - _StencilWriteMaskGBuffer: 14 + - _StencilWriteMaskMV: 40 + - _SupportDecals: 1 + - _SurfaceType: 0 + - _TongueBrightness: 1 + - _TongueSSS: 1 + - _TongueSaturation: 0.95 + - _TongueThickness: 0.75 + - _TransparentBackfaceEnable: 0 + - _TransparentCullMode: 2 + - _TransparentDepthPostpassEnable: 0 + - _TransparentDepthPrepassEnable: 0 + - _TransparentSortPriority: 0 + - _TransparentWritingMotionVec: 0 + - _TransparentZWrite: 0 + - _UseShadowThreshold: 0 + - _ZTestDepthEqualForOpaque: 3 + - _ZTestGBuffer: 4 + - _ZTestTransparent: 4 + - _ZWrite: 1 + m_Colors: + - _DiffusionProfileAsset: {r: -1.405437e+32, g: 2.0030989e-26, b: 0.00000006313206, a: -4.4045647e-18} + - _DoubleSidedConstants: {r: 1, g: 1, b: -1, a: 0} + - _EmissionColor: {r: 1, g: 1, b: 1, a: 1} + m_BuildTextureStacks: [] diff --git a/HDRP/Material Templates/RL_Template_HQ_Tongue_HDRP.mat.meta b/HDRP/Material Templates/RL_Template_HQ_Tongue_HDRP.mat.meta new file mode 100644 index 0000000..33b9c77 --- /dev/null +++ b/HDRP/Material Templates/RL_Template_HQ_Tongue_HDRP.mat.meta @@ -0,0 +1,8 @@ +fileFormatVersion: 2 +guid: ff83f4946d449ab4e8b55c7ede9f3a77 +NativeFormatImporter: + externalObjects: {} + mainObjectFileID: 2100000 + userData: + assetBundleName: + assetBundleVariant: diff --git a/HDRP/Shaders.meta b/HDRP/Shaders.meta new file mode 100644 index 0000000..626407e --- /dev/null +++ b/HDRP/Shaders.meta @@ -0,0 +1,8 @@ +fileFormatVersion: 2 +guid: 43aacb252abb6c44bbbf148863de76a7 +folderAsset: yes +DefaultImporter: + externalObjects: {} + userData: + assetBundleName: + assetBundleVariant: diff --git a/HDRP/Shaders/RL_EyeOcclusionShaderBaked_HDRP.shadergraph b/HDRP/Shaders/RL_EyeOcclusionShaderBaked_HDRP.shadergraph new file mode 100644 index 0000000..865375f --- /dev/null +++ b/HDRP/Shaders/RL_EyeOcclusionShaderBaked_HDRP.shadergraph @@ -0,0 +1,3908 @@ +{ + "m_SGVersion": 2, + "m_Type": "UnityEditor.ShaderGraph.GraphData", + "m_ObjectId": "4e287a814e8046e8ac389e15c8a9e3ba", + "m_Properties": [ + { + "m_Id": "2ae3099df5ff47ea8af68ec7a4edbeae" + }, + { + "m_Id": "3c5c8cfa6e464d7489bcc7a552c5922c" + }, + { + "m_Id": "6443d28cbc024921bc6d0f46ee9c2102" + }, + { + "m_Id": "f9622be5f8634164ad02446464ba3c8b" + }, + { + "m_Id": "9d63cbda932d45ff98889efda5a06c38" + }, + { + "m_Id": "266fa5d358b4417ba68d60503300acd5" + } + ], + "m_Keywords": [], + "m_Nodes": [ + { + "m_Id": "2b8d19758b914347b3a90ff4d86a2765" + }, + { + "m_Id": "92cc80251fd64e0fbb5ee01393ce9ec4" + }, + { + "m_Id": "cf932a596e764ab3a051fde470178b7c" + }, + { + "m_Id": "28a1cb2245b64c76bdb75aec1006086e" + }, + { + "m_Id": "7cdec5e4eb1649ea8fa61a2f0e4a1d22" + }, + { + "m_Id": "f0929bd816264348880d393c528dc110" + }, + { + "m_Id": "f3091fe0fa9c4e38aef33375966f2355" + }, + { + "m_Id": "9d7651f674a34929a89bfa45eea65cd6" + }, + { + "m_Id": "c43cb6519f974ed182959abcd616d28b" + }, + { + "m_Id": "b816a39688d74617b11482edc3472c14" + }, + { + "m_Id": "4dec4ff124dd41cfb4722ae7a5ec21c1" + }, + { + "m_Id": "becdaadb0abb4175b8984aeab1c88d8e" + }, + { + "m_Id": "76e9db94bc4549ccb86b4375bef90585" + }, + { + "m_Id": "99bf0686a8d444adbb3b8ed9ca11a33f" + }, + { + "m_Id": "268dc0a6ddfa445fa31df9f283babb1b" + }, + { + "m_Id": "746698fd63c14464af64e794b5fd21a4" + }, + { + "m_Id": "2b9c28298dc14a06a9a0754e721d4e2d" + }, + { + "m_Id": "a378ec4c43524a919746d28ab5e334bf" + }, + { + "m_Id": "40b063e497c341459c7c086cf638a060" + }, + { + "m_Id": "543e3f76dfe745fca9462a84fc6d245e" + }, + { + "m_Id": "e7a24ae205bd439e86a2a235cea7e958" + }, + { + "m_Id": "8bb229fa2e8d462fa69dae3605318197" + }, + { + "m_Id": "91da4058677840c6b12a925b10033143" + }, + { + "m_Id": "8b0b26b61cad41c2868fb6dda828d531" + }, + { + "m_Id": "3defca4cdb924d2fba79c55fd76e2784" + }, + { + "m_Id": "05aa5b42f4d34008a88cdeb7735c74e3" + }, + { + "m_Id": "45127aa896fd4e1b83cfdeee010dcf3e" + }, + { + "m_Id": "4cdc570f6ada484ebeda0d4e7b408ad0" + }, + { + "m_Id": "bbec3648e6344c36a57fa1294aff3f23" + }, + { + "m_Id": "60ca34a12471430e9bb9936532a28fe1" + }, + { + "m_Id": "b99c64e2284844059cf414799a89f879" + }, + { + "m_Id": "9790f8445d214a3bb73abee6c00cf258" + } + ], + "m_GroupDatas": [ + { + "m_Id": "b0dc17fd9b744813b0d3cfe2bafd9cc5" + }, + { + "m_Id": "b4df5b2a90e74fea8f802d43a8c09f8b" + } + ], + "m_StickyNoteDatas": [], + "m_Edges": [ + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "05aa5b42f4d34008a88cdeb7735c74e3" + }, + "m_SlotId": 2 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "45127aa896fd4e1b83cfdeee010dcf3e" + }, + "m_SlotId": 1 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "268dc0a6ddfa445fa31df9f283babb1b" + }, + "m_SlotId": 2 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "91da4058677840c6b12a925b10033143" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "2b9c28298dc14a06a9a0754e721d4e2d" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "91da4058677840c6b12a925b10033143" + }, + "m_SlotId": 1 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "3defca4cdb924d2fba79c55fd76e2784" + }, + "m_SlotId": 2 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "45127aa896fd4e1b83cfdeee010dcf3e" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "40b063e497c341459c7c086cf638a060" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "e7a24ae205bd439e86a2a235cea7e958" + }, + "m_SlotId": 1 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "45127aa896fd4e1b83cfdeee010dcf3e" + }, + "m_SlotId": 2 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "4cdc570f6ada484ebeda0d4e7b408ad0" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "4cdc570f6ada484ebeda0d4e7b408ad0" + }, + "m_SlotId": 2 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "60ca34a12471430e9bb9936532a28fe1" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "4dec4ff124dd41cfb4722ae7a5ec21c1" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "becdaadb0abb4175b8984aeab1c88d8e" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "543e3f76dfe745fca9462a84fc6d245e" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "8bb229fa2e8d462fa69dae3605318197" + }, + "m_SlotId": 1 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "60ca34a12471430e9bb9936532a28fe1" + }, + "m_SlotId": 1 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "9d7651f674a34929a89bfa45eea65cd6" + }, + "m_SlotId": 1 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "746698fd63c14464af64e794b5fd21a4" + }, + "m_SlotId": 1 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "8b0b26b61cad41c2868fb6dda828d531" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "76e9db94bc4549ccb86b4375bef90585" + }, + "m_SlotId": 1 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "8bb229fa2e8d462fa69dae3605318197" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "8b0b26b61cad41c2868fb6dda828d531" + }, + "m_SlotId": 2 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "05aa5b42f4d34008a88cdeb7735c74e3" + }, + "m_SlotId": 1 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "8bb229fa2e8d462fa69dae3605318197" + }, + "m_SlotId": 2 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "3defca4cdb924d2fba79c55fd76e2784" + }, + "m_SlotId": 1 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "91da4058677840c6b12a925b10033143" + }, + "m_SlotId": 2 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "05aa5b42f4d34008a88cdeb7735c74e3" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "9790f8445d214a3bb73abee6c00cf258" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "28a1cb2245b64c76bdb75aec1006086e" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "9790f8445d214a3bb73abee6c00cf258" + }, + "m_SlotId": 7 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "f0929bd816264348880d393c528dc110" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "99bf0686a8d444adbb3b8ed9ca11a33f" + }, + "m_SlotId": 2 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "e7a24ae205bd439e86a2a235cea7e958" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "9d7651f674a34929a89bfa45eea65cd6" + }, + "m_SlotId": 2 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "c43cb6519f974ed182959abcd616d28b" + }, + "m_SlotId": 1 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "a378ec4c43524a919746d28ab5e334bf" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "8b0b26b61cad41c2868fb6dda828d531" + }, + "m_SlotId": 1 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "b816a39688d74617b11482edc3472c14" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "9d7651f674a34929a89bfa45eea65cd6" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "b99c64e2284844059cf414799a89f879" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "9790f8445d214a3bb73abee6c00cf258" + }, + "m_SlotId": 1 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "bbec3648e6344c36a57fa1294aff3f23" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "4cdc570f6ada484ebeda0d4e7b408ad0" + }, + "m_SlotId": 1 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "becdaadb0abb4175b8984aeab1c88d8e" + }, + "m_SlotId": 1 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "76e9db94bc4549ccb86b4375bef90585" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "becdaadb0abb4175b8984aeab1c88d8e" + }, + "m_SlotId": 1 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "99bf0686a8d444adbb3b8ed9ca11a33f" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "becdaadb0abb4175b8984aeab1c88d8e" + }, + "m_SlotId": 2 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "268dc0a6ddfa445fa31df9f283babb1b" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "becdaadb0abb4175b8984aeab1c88d8e" + }, + "m_SlotId": 2 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "746698fd63c14464af64e794b5fd21a4" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "c43cb6519f974ed182959abcd616d28b" + }, + "m_SlotId": 2 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "2b8d19758b914347b3a90ff4d86a2765" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "e7a24ae205bd439e86a2a235cea7e958" + }, + "m_SlotId": 2 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "3defca4cdb924d2fba79c55fd76e2784" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "f3091fe0fa9c4e38aef33375966f2355" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "c43cb6519f974ed182959abcd616d28b" + }, + "m_SlotId": 0 + } + } + ], + "m_VertexContext": { + "m_Position": { + "x": 154.9999237060547, + "y": 71.99999237060547 + }, + "m_Blocks": [ + { + "m_Id": "2b8d19758b914347b3a90ff4d86a2765" + }, + { + "m_Id": "92cc80251fd64e0fbb5ee01393ce9ec4" + }, + { + "m_Id": "cf932a596e764ab3a051fde470178b7c" + } + ] + }, + "m_FragmentContext": { + "m_Position": { + "x": 154.9999237060547, + "y": 272.0 + }, + "m_Blocks": [ + { + "m_Id": "28a1cb2245b64c76bdb75aec1006086e" + }, + { + "m_Id": "7cdec5e4eb1649ea8fa61a2f0e4a1d22" + }, + { + "m_Id": "f0929bd816264348880d393c528dc110" + } + ] + }, + "m_PreviewData": { + "serializedMesh": { + "m_SerializedMesh": "{\"mesh\":{\"instanceID\":0}}", + "m_Guid": "" + } + }, + "m_Path": "Shader Graphs", + "m_ConcretePrecision": 1, + "m_PreviewMode": 2, + "m_OutputNode": { + "m_Id": "" + }, + "m_ActiveTargets": [ + { + "m_Id": "524b537aa1c147b98f6d8296cc97cf5d" + } + ] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.Rendering.HighDefinition.ShaderGraph.HDUnlitData", + "m_ObjectId": "017597816b1d4ca480b6f999b23798f7", + "m_EnableShadowMatte": false, + "m_DistortionOnly": false +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "025715d269714389b2bc572d1b32a09a", + "m_Id": 0, + "m_DisplayName": "Expand Upper", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "02a4afedd77a45a18183ae0fb54970fb", + "m_Id": 2, + "m_DisplayName": "Out", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.AddNode", + "m_ObjectId": "05aa5b42f4d34008a88cdeb7735c74e3", + "m_Group": { + "m_Id": "b4df5b2a90e74fea8f802d43a8c09f8b" + }, + "m_Name": "Add", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -1817.0, + "y": -346.9999084472656, + "width": 126.00000762939453, + "height": 118.00000762939453 + } + }, + "m_Slots": [ + { + "m_Id": "e6bcbf0b79c94547b3a5801c6ee9ad01" + }, + { + "m_Id": "9809211060c749c4b9b2b2889abcc80a" + }, + { + "m_Id": "9daa98284e2e4f0689b4a202bbf65f3b" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "05b797db370449deb48124605e9e32f4", + "m_Id": 0, + "m_DisplayName": "In", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "In", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.NormalMaterialSlot", + "m_ObjectId": "0904b4e2e2af45338adfccb48136581c", + "m_Id": 0, + "m_DisplayName": "Normal", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "Normal", + "m_StageCapability": 1, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0 + }, + "m_Labels": [], + "m_Space": 0 +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "0959694a26f345a998f9e697aa408421", + "m_Id": 0, + "m_DisplayName": "In", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "In", + "m_StageCapability": 3, + "m_Value": { + "x": 1.0, + "y": 1.0, + "z": 1.0, + "w": 1.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "0aa6bfa1b6ea45d4aaea7f324d8940b4", + "m_Id": 1, + "m_DisplayName": "B", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "B", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.SamplerStateMaterialSlot", + "m_ObjectId": "10ab4bbc86954b99ab03ff2ce6ce9acf", + "m_Id": 3, + "m_DisplayName": "Sampler", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "Sampler", + "m_StageCapability": 3, + "m_BareResource": false +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicValueMaterialSlot", + "m_ObjectId": "12bb558652c74b3ab655b04fc0dec653", + "m_Id": 0, + "m_DisplayName": "A", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "A", + "m_StageCapability": 3, + "m_Value": { + "e00": 0.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 0.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 0.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 0.0 + }, + "m_DefaultValue": { + "e00": 1.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 1.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 1.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "1631527435bf4c089a32573369c91d85", + "m_Id": 5, + "m_DisplayName": "G", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "G", + "m_StageCapability": 2, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.PositionMaterialSlot", + "m_ObjectId": "1a10cbf41eff4c3e81bbf5abb15f47da", + "m_Id": 0, + "m_DisplayName": "Position", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "Position", + "m_StageCapability": 1, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0 + }, + "m_Labels": [], + "m_Space": 0 +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "1a3dd9f7b0504faa87c3e2bd7f79014f", + "m_Id": 2, + "m_DisplayName": "Out", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "1d711b75f4154318a5fb791fb04f2017", + "m_Id": 0, + "m_DisplayName": "A", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "A", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicValueMaterialSlot", + "m_ObjectId": "212af8d89c6544d0a4dc52b249d92d48", + "m_Id": 1, + "m_DisplayName": "B", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "B", + "m_StageCapability": 3, + "m_Value": { + "e00": 2.0, + "e01": 2.0, + "e02": 2.0, + "e03": 2.0, + "e10": 2.0, + "e11": 2.0, + "e12": 2.0, + "e13": 2.0, + "e20": 2.0, + "e21": 2.0, + "e22": 2.0, + "e23": 2.0, + "e30": 2.0, + "e31": 2.0, + "e32": 2.0, + "e33": 2.0 + }, + "m_DefaultValue": { + "e00": 1.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 1.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 1.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 1.0 + } +} + +{ + "m_SGVersion": 1, + "m_Type": "UnityEditor.ShaderGraph.Internal.Vector1ShaderProperty", + "m_ObjectId": "266fa5d358b4417ba68d60503300acd5", + "m_Guid": { + "m_GuidSerialized": "dbe879d0-d7b2-4e8f-979a-12a35f0efaab" + }, + "m_Name": "Expand Outer", + "m_DefaultReferenceName": "", + "m_OverrideReferenceName": "_ExpandOuter", + "m_GeneratePropertyBlock": true, + "m_Precision": 0, + "overrideHLSLDeclaration": false, + "hlslDeclarationOverride": 0, + "m_Hidden": false, + "m_Value": 0.0, + "m_FloatType": 1, + "m_RangeValues": { + "x": -0.0010000000474974514, + "y": 0.0010000000474974514 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.AddNode", + "m_ObjectId": "268dc0a6ddfa445fa31df9f283babb1b", + "m_Group": { + "m_Id": "b4df5b2a90e74fea8f802d43a8c09f8b" + }, + "m_Name": "Add", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -2710.000244140625, + "y": -487.9999694824219, + "width": 208.00001525878907, + "height": 302.0000305175781 + } + }, + "m_Slots": [ + { + "m_Id": "d4ee052d4ddc4ca781803618e0f24a45" + }, + { + "m_Id": "76ffca67ef58488c99e3bb61bbb16e13" + }, + { + "m_Id": "308e274fdf574467a0d9d889a9208431" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.BlockNode", + "m_ObjectId": "28a1cb2245b64c76bdb75aec1006086e", + "m_Group": { + "m_Id": "" + }, + "m_Name": "SurfaceDescription.BaseColor", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": 0.0, + "y": 0.0, + "width": 0.0, + "height": 0.0 + } + }, + "m_Slots": [ + { + "m_Id": "bb28d292ab8e4ae88fbf211b9f92593c" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_SerializedDescriptor": "SurfaceDescription.BaseColor" +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Internal.Texture2DShaderProperty", + "m_ObjectId": "2ae3099df5ff47ea8af68ec7a4edbeae", + "m_Guid": { + "m_GuidSerialized": "d6dda84c-9c97-44ab-a926-cc0e6a93bdde" + }, + "m_Name": "Base Color Map", + "m_DefaultReferenceName": "Texture2D_2ae3099df5ff47ea8af68ec7a4edbeae", + "m_OverrideReferenceName": "_BaseColorMap", + "m_GeneratePropertyBlock": true, + "m_Precision": 0, + "overrideHLSLDeclaration": false, + "hlslDeclarationOverride": 0, + "m_Hidden": false, + "m_Value": { + "m_SerializedTexture": "{\"texture\":{\"instanceID\":0}}", + "m_Guid": "" + }, + "m_Modifiable": true, + "m_DefaultType": 1 +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.BlockNode", + "m_ObjectId": "2b8d19758b914347b3a90ff4d86a2765", + "m_Group": { + "m_Id": "" + }, + "m_Name": "VertexDescription.Position", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": 0.0, + "y": 0.0, + "width": 0.0, + "height": 0.0 + } + }, + "m_Slots": [ + { + "m_Id": "1a10cbf41eff4c3e81bbf5abb15f47da" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_SerializedDescriptor": "VertexDescription.Position" +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.PropertyNode", + "m_ObjectId": "2b9c28298dc14a06a9a0754e721d4e2d", + "m_Group": { + "m_Id": "b4df5b2a90e74fea8f802d43a8c09f8b" + }, + "m_Name": "Property", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -2295.000244140625, + "y": -403.9999084472656, + "width": 108.0, + "height": 34.0 + } + }, + "m_Slots": [ + { + "m_Id": "025715d269714389b2bc572d1b32a09a" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_Property": { + "m_Id": "6443d28cbc024921bc6d0f46ee9c2102" + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "308e274fdf574467a0d9d889a9208431", + "m_Id": 2, + "m_DisplayName": "Out", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "35e0961e58b34e47a1304e16475e7563", + "m_Id": 0, + "m_DisplayName": "Expand Lower", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "3a6699ed5e1f42ea85eabd225365e718", + "m_Id": 0, + "m_DisplayName": "Expand Inner", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 1, + "m_Type": "UnityEditor.ShaderGraph.Internal.Vector1ShaderProperty", + "m_ObjectId": "3c5c8cfa6e464d7489bcc7a552c5922c", + "m_Guid": { + "m_GuidSerialized": "986e039e-52b8-436b-be83-d015856f3da1" + }, + "m_Name": "Expand Outward", + "m_DefaultReferenceName": "Vector1_3c5c8cfa6e464d7489bcc7a552c5922c", + "m_OverrideReferenceName": "_ExpandOut", + "m_GeneratePropertyBlock": true, + "m_Precision": 0, + "overrideHLSLDeclaration": false, + "hlslDeclarationOverride": 0, + "m_Hidden": false, + "m_Value": 0.00009999999747378752, + "m_FloatType": 1, + "m_RangeValues": { + "x": -0.0010000000474974514, + "y": 0.0010000000474974514 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.Rendering.HighDefinition.ShaderGraph.BuiltinData", + "m_ObjectId": "3db9538cb77844829582eddc326227b2", + "m_Distortion": false, + "m_DistortionMode": 0, + "m_DistortionDepthTest": true, + "m_AddPrecomputedVelocity": false, + "m_TransparentWritesMotionVec": false, + "m_AlphaToMask": false, + "m_DepthOffset": false, + "m_TransparencyFog": true, + "m_AlphaTestShadow": false, + "m_BackThenFrontRendering": false, + "m_TransparentDepthPrepass": false, + "m_TransparentDepthPostpass": false, + "m_SupportLodCrossFade": false +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.AddNode", + "m_ObjectId": "3defca4cdb924d2fba79c55fd76e2784", + "m_Group": { + "m_Id": "b4df5b2a90e74fea8f802d43a8c09f8b" + }, + "m_Name": "Add", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -1817.0, + "y": -920.0, + "width": 126.00000762939453, + "height": 118.00000762939453 + } + }, + "m_Slots": [ + { + "m_Id": "f684cfd6321046968800ae12100e18c6" + }, + { + "m_Id": "0aa6bfa1b6ea45d4aaea7f324d8940b4" + }, + { + "m_Id": "4950f81ba35848359e2eefdad3a3e308" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.PropertyNode", + "m_ObjectId": "40b063e497c341459c7c086cf638a060", + "m_Group": { + "m_Id": "b4df5b2a90e74fea8f802d43a8c09f8b" + }, + "m_Name": "Property", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -2292.000244140625, + "y": -988.0, + "width": 101.0, + "height": 34.0 + } + }, + "m_Slots": [ + { + "m_Id": "3a6699ed5e1f42ea85eabd225365e718" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_Property": { + "m_Id": "9d63cbda932d45ff98889efda5a06c38" + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "411a21496ffd47d9bcd022489f90cb93", + "m_Id": 1, + "m_DisplayName": "Out", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "430d8149083845e2843a208f1cc219d3", + "m_Id": 0, + "m_DisplayName": "", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.AddNode", + "m_ObjectId": "45127aa896fd4e1b83cfdeee010dcf3e", + "m_Group": { + "m_Id": "b4df5b2a90e74fea8f802d43a8c09f8b" + }, + "m_Name": "Add", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -1499.0, + "y": -643.0, + "width": 126.00000762939453, + "height": 118.00000762939453 + } + }, + "m_Slots": [ + { + "m_Id": "1d711b75f4154318a5fb791fb04f2017" + }, + { + "m_Id": "e2e320b532b343a2b345dcce6b6ca057" + }, + { + "m_Id": "89f91b700e2b46629637f2fe7a52ba45" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "45c3f04c18934f69b2c29ba02499303f", + "m_Id": 6, + "m_DisplayName": "B", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "B", + "m_StageCapability": 2, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "4950f81ba35848359e2eefdad3a3e308", + "m_Id": 2, + "m_DisplayName": "Out", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.AddNode", + "m_ObjectId": "4cdc570f6ada484ebeda0d4e7b408ad0", + "m_Group": { + "m_Id": "b4df5b2a90e74fea8f802d43a8c09f8b" + }, + "m_Name": "Add", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -1227.0, + "y": -369.9999084472656, + "width": 126.00000762939453, + "height": 118.00000762939453 + } + }, + "m_Slots": [ + { + "m_Id": "8760247084e04d55b954e42de386ae6c" + }, + { + "m_Id": "da6bd2aec3fc49ad95ac557950c2e3ac" + }, + { + "m_Id": "72916418c63c4dc0935a879ca8edfc26" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.UVNode", + "m_ObjectId": "4dec4ff124dd41cfb4722ae7a5ec21c1", + "m_Group": { + "m_Id": "b4df5b2a90e74fea8f802d43a8c09f8b" + }, + "m_Name": "UV", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -3294.000244140625, + "y": -584.0, + "width": 145.0, + "height": 130.0 + } + }, + "m_Slots": [ + { + "m_Id": "e506546e9df6439eafbf8afe832616ca" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_OutputChannel": 0 +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicValueMaterialSlot", + "m_ObjectId": "50a93afdfd7e42f79719c1039508358b", + "m_Id": 0, + "m_DisplayName": "A", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "A", + "m_StageCapability": 3, + "m_Value": { + "e00": 0.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 0.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 0.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 0.0 + }, + "m_DefaultValue": { + "e00": 1.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 1.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 1.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.Rendering.HighDefinition.ShaderGraph.HDTarget", + "m_ObjectId": "524b537aa1c147b98f6d8296cc97cf5d", + "m_ActiveSubTarget": { + "m_Id": "97edb8a79d314e8e9598cad34869684f" + }, + "m_Datas": [ + { + "m_Id": "3db9538cb77844829582eddc326227b2" + }, + { + "m_Id": "cd095f47ff5044e09409c402568d61d1" + }, + { + "m_Id": "017597816b1d4ca480b6f999b23798f7" + } + ], + "m_CustomEditorGUI": "" +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.PropertyNode", + "m_ObjectId": "543e3f76dfe745fca9462a84fc6d245e", + "m_Group": { + "m_Id": "b4df5b2a90e74fea8f802d43a8c09f8b" + }, + "m_Name": "Property", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -2295.000244140625, + "y": -681.9999389648438, + "width": 104.00000762939453, + "height": 34.0 + } + }, + "m_Slots": [ + { + "m_Id": "881becfd4fd44c389c76f42e34b2659b" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_Property": { + "m_Id": "266fa5d358b4417ba68d60503300acd5" + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicValueMaterialSlot", + "m_ObjectId": "5492411f859f437c9c9d33ab3c7af3fe", + "m_Id": 2, + "m_DisplayName": "Out", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": { + "e00": 0.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 0.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 0.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 0.0 + }, + "m_DefaultValue": { + "e00": 1.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 1.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 1.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicValueMaterialSlot", + "m_ObjectId": "5cc4f3718efe45ab8ccc9ca94bf1a9b6", + "m_Id": 1, + "m_DisplayName": "B", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "B", + "m_StageCapability": 3, + "m_Value": { + "e00": 2.0, + "e01": 2.0, + "e02": 2.0, + "e03": 2.0, + "e10": 2.0, + "e11": 2.0, + "e12": 2.0, + "e13": 2.0, + "e20": 2.0, + "e21": 2.0, + "e22": 2.0, + "e23": 2.0, + "e30": 2.0, + "e31": 2.0, + "e32": 2.0, + "e33": 2.0 + }, + "m_DefaultValue": { + "e00": 1.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 1.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 1.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.RedirectNodeData", + "m_ObjectId": "60ca34a12471430e9bb9936532a28fe1", + "m_Group": { + "m_Id": "b0dc17fd9b744813b0d3cfe2bafd9cc5" + }, + "m_Name": "Redirect Node", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -787.999755859375, + "y": -323.0000305175781, + "width": 56.0, + "height": 23.999998092651368 + } + }, + "m_Slots": [ + { + "m_Id": "430d8149083845e2843a208f1cc219d3" + }, + { + "m_Id": "8b3c92c479514b1fbdc26e0bb6353dc9" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 1, + "m_Type": "UnityEditor.ShaderGraph.Internal.Vector1ShaderProperty", + "m_ObjectId": "6443d28cbc024921bc6d0f46ee9c2102", + "m_Guid": { + "m_GuidSerialized": "e8c80ed7-076a-4019-8b5f-47564ff94790" + }, + "m_Name": "Expand Upper", + "m_DefaultReferenceName": "", + "m_OverrideReferenceName": "_ExpandUpper", + "m_GeneratePropertyBlock": true, + "m_Precision": 0, + "overrideHLSLDeclaration": false, + "hlslDeclarationOverride": 0, + "m_Hidden": false, + "m_Value": 0.0, + "m_FloatType": 1, + "m_RangeValues": { + "x": -0.0010000000474974514, + "y": 0.0010000000474974514 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "64da932b85b441a2bff9e05fcc44bd8f", + "m_Id": 0, + "m_DisplayName": "Alpha", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "Alpha", + "m_StageCapability": 2, + "m_Value": 1.0, + "m_DefaultValue": 1.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicValueMaterialSlot", + "m_ObjectId": "6535457859774692aacdf83757840fb4", + "m_Id": 0, + "m_DisplayName": "A", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "A", + "m_StageCapability": 3, + "m_Value": { + "e00": 0.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 0.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 0.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 0.0 + }, + "m_DefaultValue": { + "e00": 1.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 1.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 1.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "6d711b5fee3a476e82d8288a6439904f", + "m_Id": 1, + "m_DisplayName": "R", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "R", + "m_StageCapability": 3, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.UVMaterialSlot", + "m_ObjectId": "6de7d9abb0954aa692c9201ed3e9e9dc", + "m_Id": 2, + "m_DisplayName": "UV", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "UV", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0 + }, + "m_Labels": [], + "m_Channel": 0 +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "72916418c63c4dc0935a879ca8edfc26", + "m_Id": 2, + "m_DisplayName": "Out", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.OneMinusNode", + "m_ObjectId": "746698fd63c14464af64e794b5fd21a4", + "m_Group": { + "m_Id": "b4df5b2a90e74fea8f802d43a8c09f8b" + }, + "m_Name": "One Minus", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -2710.000244140625, + "y": -180.99998474121095, + "width": 208.00001525878907, + "height": 278.0 + } + }, + "m_Slots": [ + { + "m_Id": "89ff68f9c3af45f7bf3a87627a6de286" + }, + { + "m_Id": "d7eefb11caf34fa2b8e7022325c65f50" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.OneMinusNode", + "m_ObjectId": "76e9db94bc4549ccb86b4375bef90585", + "m_Group": { + "m_Id": "b4df5b2a90e74fea8f802d43a8c09f8b" + }, + "m_Name": "One Minus", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -2710.000244140625, + "y": -765.9999389648438, + "width": 208.00001525878907, + "height": 278.0 + } + }, + "m_Slots": [ + { + "m_Id": "0959694a26f345a998f9e697aa408421" + }, + { + "m_Id": "411a21496ffd47d9bcd022489f90cb93" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "76ffca67ef58488c99e3bb61bbb16e13", + "m_Id": 1, + "m_DisplayName": "B", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "B", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "778c121c491d4910bbbd52cb77493747", + "m_Id": 4, + "m_DisplayName": "A", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "A", + "m_StageCapability": 3, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.BlockNode", + "m_ObjectId": "7cdec5e4eb1649ea8fa61a2f0e4a1d22", + "m_Group": { + "m_Id": "" + }, + "m_Name": "SurfaceDescription.Emission", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": 0.0, + "y": 0.0, + "width": 0.0, + "height": 0.0 + } + }, + "m_Slots": [ + { + "m_Id": "fb6ca1a014e64d79bbba8f84f8ccb6d5" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_SerializedDescriptor": "SurfaceDescription.Emission" +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector3MaterialSlot", + "m_ObjectId": "800a75e3b71e420a9b875e7df50af764", + "m_Id": 0, + "m_DisplayName": "Out", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0 + }, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Texture2DMaterialSlot", + "m_ObjectId": "8164a9f198814cd8a65a1f06cb11c033", + "m_Id": 0, + "m_DisplayName": "Base Color Map", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_BareResource": false +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "8760247084e04d55b954e42de386ae6c", + "m_Id": 0, + "m_DisplayName": "A", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "A", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "881becfd4fd44c389c76f42e34b2659b", + "m_Id": 0, + "m_DisplayName": "Expand Outer", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "883183c2957240daab15ac73ec426ab3", + "m_Id": 3, + "m_DisplayName": "B", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "B", + "m_StageCapability": 3, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "89f91b700e2b46629637f2fe7a52ba45", + "m_Id": 2, + "m_DisplayName": "Out", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "89ff68f9c3af45f7bf3a87627a6de286", + "m_Id": 0, + "m_DisplayName": "In", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "In", + "m_StageCapability": 3, + "m_Value": { + "x": 1.0, + "y": 1.0, + "z": 1.0, + "w": 1.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.MultiplyNode", + "m_ObjectId": "8b0b26b61cad41c2868fb6dda828d531", + "m_Group": { + "m_Id": "b4df5b2a90e74fea8f802d43a8c09f8b" + }, + "m_Name": "Multiply", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -2143.0, + "y": -180.99998474121095, + "width": 126.00000762939453, + "height": 118.00000762939453 + } + }, + "m_Slots": [ + { + "m_Id": "6535457859774692aacdf83757840fb4" + }, + { + "m_Id": "c17008c6bd2746d3aff735bcf194834e" + }, + { + "m_Id": "f55702e69fe6422db241f04b73b2f8fe" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "8b3c92c479514b1fbdc26e0bb6353dc9", + "m_Id": 1, + "m_DisplayName": "", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.MultiplyNode", + "m_ObjectId": "8bb229fa2e8d462fa69dae3605318197", + "m_Group": { + "m_Id": "b4df5b2a90e74fea8f802d43a8c09f8b" + }, + "m_Name": "Multiply", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -2143.0, + "y": -765.9999389648438, + "width": 126.00000762939453, + "height": 118.00000762939453 + } + }, + "m_Slots": [ + { + "m_Id": "12bb558652c74b3ab655b04fc0dec653" + }, + { + "m_Id": "5cc4f3718efe45ab8ccc9ca94bf1a9b6" + }, + { + "m_Id": "e433a9c444b640dea68ac7f83ba7e24d" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector4MaterialSlot", + "m_ObjectId": "9154dc184fae4db7a53c7edd92d753fe", + "m_Id": 0, + "m_DisplayName": "RGBA", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "RGBA", + "m_StageCapability": 2, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "91898770038a4c9ca244c11883936fb0", + "m_Id": 0, + "m_DisplayName": "A", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "A", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.MultiplyNode", + "m_ObjectId": "91da4058677840c6b12a925b10033143", + "m_Group": { + "m_Id": "b4df5b2a90e74fea8f802d43a8c09f8b" + }, + "m_Name": "Multiply", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -2143.0, + "y": -487.9999694824219, + "width": 126.00000762939453, + "height": 118.00000762939453 + } + }, + "m_Slots": [ + { + "m_Id": "50a93afdfd7e42f79719c1039508358b" + }, + { + "m_Id": "212af8d89c6544d0a4dc52b249d92d48" + }, + { + "m_Id": "d5558c96962a45fda7fdf40869a247fc" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.BlockNode", + "m_ObjectId": "92cc80251fd64e0fbb5ee01393ce9ec4", + "m_Group": { + "m_Id": "" + }, + "m_Name": "VertexDescription.Normal", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": 0.0, + "y": 0.0, + "width": 0.0, + "height": 0.0 + } + }, + "m_Slots": [ + { + "m_Id": "0904b4e2e2af45338adfccb48136581c" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_SerializedDescriptor": "VertexDescription.Normal" +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "9592bd7eb63940599fec8c1c4ed8d7e5", + "m_Id": 0, + "m_DisplayName": "Expand Outward", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicValueMaterialSlot", + "m_ObjectId": "95cb1dbdb64941b5b08cb73233e62fe0", + "m_Id": 0, + "m_DisplayName": "A", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "A", + "m_StageCapability": 3, + "m_Value": { + "e00": 0.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 0.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 0.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 0.0 + }, + "m_DefaultValue": { + "e00": 1.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 1.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 1.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.SampleTexture2DNode", + "m_ObjectId": "9790f8445d214a3bb73abee6c00cf258", + "m_Group": { + "m_Id": "" + }, + "m_Name": "Sample Texture 2D", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -421.0, + "y": 272.0, + "width": 184.0, + "height": 253.0 + } + }, + "m_Slots": [ + { + "m_Id": "9154dc184fae4db7a53c7edd92d753fe" + }, + { + "m_Id": "e45b1d7b90a64e98bcac1964fed0f96b" + }, + { + "m_Id": "1631527435bf4c089a32573369c91d85" + }, + { + "m_Id": "45c3f04c18934f69b2c29ba02499303f" + }, + { + "m_Id": "fb688fb9a7154bc4a911e3e3406d2b54" + }, + { + "m_Id": "ce919dedeece4d3ba2039790a8faff60" + }, + { + "m_Id": "6de7d9abb0954aa692c9201ed3e9e9dc" + }, + { + "m_Id": "10ab4bbc86954b99ab03ff2ce6ce9acf" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_TextureType": 0, + "m_NormalMapSpace": 0 +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.Rendering.HighDefinition.ShaderGraph.HDUnlitSubTarget", + "m_ObjectId": "97edb8a79d314e8e9598cad34869684f" +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "9809211060c749c4b9b2b2889abcc80a", + "m_Id": 1, + "m_DisplayName": "B", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "B", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.AddNode", + "m_ObjectId": "99bf0686a8d444adbb3b8ed9ca11a33f", + "m_Group": { + "m_Id": "b4df5b2a90e74fea8f802d43a8c09f8b" + }, + "m_Name": "Add", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -2710.000244140625, + "y": -1072.0, + "width": 208.00001525878907, + "height": 302.0000305175781 + } + }, + "m_Slots": [ + { + "m_Id": "c2b7d105f8a740a99bddcd04de15eff6" + }, + { + "m_Id": "ad565fc369a4453dbc63b8c91397f0db" + }, + { + "m_Id": "1a3dd9f7b0504faa87c3e2bd7f79014f" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 1, + "m_Type": "UnityEditor.ShaderGraph.Internal.Vector1ShaderProperty", + "m_ObjectId": "9d63cbda932d45ff98889efda5a06c38", + "m_Guid": { + "m_GuidSerialized": "c5602d12-4cdc-41ac-97e6-3f50ef18c3f0" + }, + "m_Name": "Expand Inner", + "m_DefaultReferenceName": "", + "m_OverrideReferenceName": "_ExpandInner", + "m_GeneratePropertyBlock": true, + "m_Precision": 0, + "overrideHLSLDeclaration": false, + "hlslDeclarationOverride": 0, + "m_Hidden": false, + "m_Value": 0.0, + "m_FloatType": 1, + "m_RangeValues": { + "x": -0.0010000000474974514, + "y": 0.0010000000474974514 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.MultiplyNode", + "m_ObjectId": "9d7651f674a34929a89bfa45eea65cd6", + "m_Group": { + "m_Id": "b0dc17fd9b744813b0d3cfe2bafd9cc5" + }, + "m_Name": "Multiply", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -623.0, + "y": -486.0, + "width": 130.0, + "height": 118.0 + } + }, + "m_Slots": [ + { + "m_Id": "95cb1dbdb64941b5b08cb73233e62fe0" + }, + { + "m_Id": "d15a848ac85f4863b5ed4de006c537d3" + }, + { + "m_Id": "e1a26577b8104a598b18bcca2a5df82d" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "9daa98284e2e4f0689b4a202bbf65f3b", + "m_Id": 2, + "m_DisplayName": "Out", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.PropertyNode", + "m_ObjectId": "a378ec4c43524a919746d28ab5e334bf", + "m_Group": { + "m_Id": "b4df5b2a90e74fea8f802d43a8c09f8b" + }, + "m_Name": "Property", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -2299.0, + "y": -96.99991607666016, + "width": 108.0, + "height": 34.0 + } + }, + "m_Slots": [ + { + "m_Id": "35e0961e58b34e47a1304e16475e7563" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_Property": { + "m_Id": "f9622be5f8634164ad02446464ba3c8b" + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicValueMaterialSlot", + "m_ObjectId": "a87c27f9673b4d8d9014a10e8f1e5135", + "m_Id": 1, + "m_DisplayName": "B", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "B", + "m_StageCapability": 3, + "m_Value": { + "e00": 2.0, + "e01": 2.0, + "e02": 2.0, + "e03": 2.0, + "e10": 2.0, + "e11": 2.0, + "e12": 2.0, + "e13": 2.0, + "e20": 2.0, + "e21": 2.0, + "e22": 2.0, + "e23": 2.0, + "e30": 2.0, + "e31": 2.0, + "e32": 2.0, + "e33": 2.0 + }, + "m_DefaultValue": { + "e00": 1.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 1.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 1.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "ad565fc369a4453dbc63b8c91397f0db", + "m_Id": 1, + "m_DisplayName": "B", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "B", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.GroupData", + "m_ObjectId": "b0dc17fd9b744813b0d3cfe2bafd9cc5", + "m_Title": "Mesh Deform By Normal", + "m_Position": { + "x": -963.0, + "y": -706.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.GroupData", + "m_ObjectId": "b4df5b2a90e74fea8f802d43a8c09f8b", + "m_Title": "Vertex Adjust Strength", + "m_Position": { + "x": -3319.000244140625, + "y": -1131.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.NormalVectorNode", + "m_ObjectId": "b816a39688d74617b11482edc3472c14", + "m_Group": { + "m_Id": "b0dc17fd9b744813b0d3cfe2bafd9cc5" + }, + "m_Name": "Normal Vector", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -937.9996337890625, + "y": -486.0, + "width": 205.99998474121095, + "height": 132.0 + } + }, + "m_Slots": [ + { + "m_Id": "e8eb67cf30a8412e921e7ade8a3270d9" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 2, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_Space": 0 +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.PropertyNode", + "m_ObjectId": "b99c64e2284844059cf414799a89f879", + "m_Group": { + "m_Id": "" + }, + "m_Name": "Property", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -654.0, + "y": 272.0, + "width": 184.0, + "height": 34.0 + } + }, + "m_Slots": [ + { + "m_Id": "8164a9f198814cd8a65a1f06cb11c033" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_Property": { + "m_Id": "2ae3099df5ff47ea8af68ec7a4edbeae" + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.ColorRGBMaterialSlot", + "m_ObjectId": "bb28d292ab8e4ae88fbf211b9f92593c", + "m_Id": 0, + "m_DisplayName": "Base Color", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "BaseColor", + "m_StageCapability": 2, + "m_Value": { + "x": 0.5, + "y": 0.5, + "z": 0.5 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0 + }, + "m_Labels": [], + "m_ColorMode": 0, + "m_DefaultColor": { + "r": 0.5, + "g": 0.5, + "b": 0.5, + "a": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.PropertyNode", + "m_ObjectId": "bbec3648e6344c36a57fa1294aff3f23", + "m_Group": { + "m_Id": "b4df5b2a90e74fea8f802d43a8c09f8b" + }, + "m_Name": "Property", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -1411.0001220703125, + "y": -263.0, + "width": 94.0, + "height": 34.0 + } + }, + "m_Slots": [ + { + "m_Id": "9592bd7eb63940599fec8c1c4ed8d7e5" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_Property": { + "m_Id": "3c5c8cfa6e464d7489bcc7a552c5922c" + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.TangentMaterialSlot", + "m_ObjectId": "bc9d9b059af0485bb5d17f0cdcf6a0e2", + "m_Id": 0, + "m_DisplayName": "Tangent", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "Tangent", + "m_StageCapability": 1, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0 + }, + "m_Labels": [], + "m_Space": 0 +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "be768b094ed94bef9328e4c2ff806841", + "m_Id": 1, + "m_DisplayName": "B", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "B", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.SplitNode", + "m_ObjectId": "becdaadb0abb4175b8984aeab1c88d8e", + "m_Group": { + "m_Id": "b4df5b2a90e74fea8f802d43a8c09f8b" + }, + "m_Name": "Split", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -3078.000244140625, + "y": -584.0, + "width": 120.0, + "height": 149.0 + } + }, + "m_Slots": [ + { + "m_Id": "05b797db370449deb48124605e9e32f4" + }, + { + "m_Id": "6d711b5fee3a476e82d8288a6439904f" + }, + { + "m_Id": "cba48c63c29040739f9f941e20592ee3" + }, + { + "m_Id": "883183c2957240daab15ac73ec426ab3" + }, + { + "m_Id": "778c121c491d4910bbbd52cb77493747" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicValueMaterialSlot", + "m_ObjectId": "bfe206dc714e419bbae825796cd562fc", + "m_Id": 0, + "m_DisplayName": "A", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "A", + "m_StageCapability": 3, + "m_Value": { + "e00": 0.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 0.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 0.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 0.0 + }, + "m_DefaultValue": { + "e00": 1.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 1.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 1.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicValueMaterialSlot", + "m_ObjectId": "c17008c6bd2746d3aff735bcf194834e", + "m_Id": 1, + "m_DisplayName": "B", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "B", + "m_StageCapability": 3, + "m_Value": { + "e00": 2.0, + "e01": 2.0, + "e02": 2.0, + "e03": 2.0, + "e10": 2.0, + "e11": 2.0, + "e12": 2.0, + "e13": 2.0, + "e20": 2.0, + "e21": 2.0, + "e22": 2.0, + "e23": 2.0, + "e30": 2.0, + "e31": 2.0, + "e32": 2.0, + "e33": 2.0 + }, + "m_DefaultValue": { + "e00": 1.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 1.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 1.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "c2b7d105f8a740a99bddcd04de15eff6", + "m_Id": 0, + "m_DisplayName": "A", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "A", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.AddNode", + "m_ObjectId": "c43cb6519f974ed182959abcd616d28b", + "m_Group": { + "m_Id": "b0dc17fd9b744813b0d3cfe2bafd9cc5" + }, + "m_Name": "Add", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -356.9998474121094, + "y": -586.9999389648438, + "width": 130.0, + "height": 118.0 + } + }, + "m_Slots": [ + { + "m_Id": "91898770038a4c9ca244c11883936fb0" + }, + { + "m_Id": "be768b094ed94bef9328e4c2ff806841" + }, + { + "m_Id": "02a4afedd77a45a18183ae0fb54970fb" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "cba48c63c29040739f9f941e20592ee3", + "m_Id": 2, + "m_DisplayName": "G", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "G", + "m_StageCapability": 3, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.Rendering.HighDefinition.ShaderGraph.SystemData", + "m_ObjectId": "cd095f47ff5044e09409c402568d61d1", + "m_MaterialNeedsUpdateHash": 0, + "m_SurfaceType": 1, + "m_RenderingPass": 4, + "m_BlendMode": 0, + "m_ZTest": 4, + "m_ZWrite": false, + "m_TransparentCullMode": 2, + "m_OpaqueCullMode": 2, + "m_SortPriority": 1, + "m_AlphaTest": false, + "m_TransparentDepthPrepass": false, + "m_TransparentDepthPostpass": false, + "m_SupportLodCrossFade": false, + "m_DoubleSidedMode": 0, + "m_DOTSInstancing": false, + "m_Version": 0, + "m_FirstTimeMigrationExecuted": true, + "inspectorFoldoutMask": 11 +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Texture2DInputMaterialSlot", + "m_ObjectId": "ce919dedeece4d3ba2039790a8faff60", + "m_Id": 1, + "m_DisplayName": "Texture", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "Texture", + "m_StageCapability": 3, + "m_BareResource": false, + "m_Texture": { + "m_SerializedTexture": "{\"texture\":{\"instanceID\":0}}", + "m_Guid": "" + }, + "m_DefaultType": 0 +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.BlockNode", + "m_ObjectId": "cf932a596e764ab3a051fde470178b7c", + "m_Group": { + "m_Id": "" + }, + "m_Name": "VertexDescription.Tangent", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": 0.0, + "y": 0.0, + "width": 0.0, + "height": 0.0 + } + }, + "m_Slots": [ + { + "m_Id": "bc9d9b059af0485bb5d17f0cdcf6a0e2" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_SerializedDescriptor": "VertexDescription.Tangent" +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicValueMaterialSlot", + "m_ObjectId": "d15a848ac85f4863b5ed4de006c537d3", + "m_Id": 1, + "m_DisplayName": "B", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "B", + "m_StageCapability": 3, + "m_Value": { + "e00": 2.0, + "e01": 2.0, + "e02": 2.0, + "e03": 2.0, + "e10": 2.0, + "e11": 2.0, + "e12": 2.0, + "e13": 2.0, + "e20": 2.0, + "e21": 2.0, + "e22": 2.0, + "e23": 2.0, + "e30": 2.0, + "e31": 2.0, + "e32": 2.0, + "e33": 2.0 + }, + "m_DefaultValue": { + "e00": 1.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 1.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 1.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "d4ee052d4ddc4ca781803618e0f24a45", + "m_Id": 0, + "m_DisplayName": "A", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "A", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicValueMaterialSlot", + "m_ObjectId": "d5558c96962a45fda7fdf40869a247fc", + "m_Id": 2, + "m_DisplayName": "Out", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": { + "e00": 0.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 0.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 0.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 0.0 + }, + "m_DefaultValue": { + "e00": 1.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 1.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 1.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "d7eefb11caf34fa2b8e7022325c65f50", + "m_Id": 1, + "m_DisplayName": "Out", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "da6bd2aec3fc49ad95ac557950c2e3ac", + "m_Id": 1, + "m_DisplayName": "B", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "B", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicValueMaterialSlot", + "m_ObjectId": "e1a26577b8104a598b18bcca2a5df82d", + "m_Id": 2, + "m_DisplayName": "Out", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": { + "e00": 0.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 0.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 0.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 0.0 + }, + "m_DefaultValue": { + "e00": 1.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 1.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 1.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "e2e320b532b343a2b345dcce6b6ca057", + "m_Id": 1, + "m_DisplayName": "B", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "B", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicValueMaterialSlot", + "m_ObjectId": "e433a9c444b640dea68ac7f83ba7e24d", + "m_Id": 2, + "m_DisplayName": "Out", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": { + "e00": 0.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 0.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 0.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 0.0 + }, + "m_DefaultValue": { + "e00": 1.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 1.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 1.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "e45b1d7b90a64e98bcac1964fed0f96b", + "m_Id": 4, + "m_DisplayName": "R", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "R", + "m_StageCapability": 2, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector4MaterialSlot", + "m_ObjectId": "e506546e9df6439eafbf8afe832616ca", + "m_Id": 0, + "m_DisplayName": "Out", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "e6bcbf0b79c94547b3a5801c6ee9ad01", + "m_Id": 0, + "m_DisplayName": "A", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "A", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.MultiplyNode", + "m_ObjectId": "e7a24ae205bd439e86a2a235cea7e958", + "m_Group": { + "m_Id": "b4df5b2a90e74fea8f802d43a8c09f8b" + }, + "m_Name": "Multiply", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -2143.0, + "y": -1072.0, + "width": 126.00000762939453, + "height": 118.00000762939453 + } + }, + "m_Slots": [ + { + "m_Id": "bfe206dc714e419bbae825796cd562fc" + }, + { + "m_Id": "a87c27f9673b4d8d9014a10e8f1e5135" + }, + { + "m_Id": "5492411f859f437c9c9d33ab3c7af3fe" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector3MaterialSlot", + "m_ObjectId": "e8eb67cf30a8412e921e7ade8a3270d9", + "m_Id": 0, + "m_DisplayName": "Out", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 1.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0 + }, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.BlockNode", + "m_ObjectId": "f0929bd816264348880d393c528dc110", + "m_Group": { + "m_Id": "" + }, + "m_Name": "SurfaceDescription.Alpha", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": 0.0, + "y": 0.0, + "width": 0.0, + "height": 0.0 + } + }, + "m_Slots": [ + { + "m_Id": "64da932b85b441a2bff9e05fcc44bd8f" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_SerializedDescriptor": "SurfaceDescription.Alpha" +} + +{ + "m_SGVersion": 1, + "m_Type": "UnityEditor.ShaderGraph.PositionNode", + "m_ObjectId": "f3091fe0fa9c4e38aef33375966f2355", + "m_Group": { + "m_Id": "b0dc17fd9b744813b0d3cfe2bafd9cc5" + }, + "m_Name": "Position", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -699.0000610351563, + "y": -647.0, + "width": 205.99998474121095, + "height": 132.0 + } + }, + "m_Slots": [ + { + "m_Id": "800a75e3b71e420a9b875e7df50af764" + } + ], + "synonyms": [], + "m_Precision": 1, + "m_PreviewExpanded": false, + "m_PreviewMode": 2, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_Space": 0 +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicValueMaterialSlot", + "m_ObjectId": "f55702e69fe6422db241f04b73b2f8fe", + "m_Id": 2, + "m_DisplayName": "Out", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": { + "e00": 0.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 0.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 0.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 0.0 + }, + "m_DefaultValue": { + "e00": 1.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 1.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 1.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "f684cfd6321046968800ae12100e18c6", + "m_Id": 0, + "m_DisplayName": "A", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "A", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 1, + "m_Type": "UnityEditor.ShaderGraph.Internal.Vector1ShaderProperty", + "m_ObjectId": "f9622be5f8634164ad02446464ba3c8b", + "m_Guid": { + "m_GuidSerialized": "2ac36ad6-fb27-42c5-b454-00d2e8f02ac8" + }, + "m_Name": "Expand Lower", + "m_DefaultReferenceName": "", + "m_OverrideReferenceName": "_ExpandLower", + "m_GeneratePropertyBlock": true, + "m_Precision": 0, + "overrideHLSLDeclaration": false, + "hlslDeclarationOverride": 0, + "m_Hidden": false, + "m_Value": 0.0, + "m_FloatType": 1, + "m_RangeValues": { + "x": -0.0010000000474974514, + "y": 0.0010000000474974514 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "fb688fb9a7154bc4a911e3e3406d2b54", + "m_Id": 7, + "m_DisplayName": "A", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "A", + "m_StageCapability": 2, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.ColorRGBMaterialSlot", + "m_ObjectId": "fb6ca1a014e64d79bbba8f84f8ccb6d5", + "m_Id": 0, + "m_DisplayName": "Emission", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "Emission", + "m_StageCapability": 2, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0 + }, + "m_Labels": [], + "m_ColorMode": 1, + "m_DefaultColor": { + "r": 0.0, + "g": 0.0, + "b": 0.0, + "a": 1.0 + } +} + diff --git a/HDRP/Shaders/RL_EyeOcclusionShaderBaked_HDRP.shadergraph.meta b/HDRP/Shaders/RL_EyeOcclusionShaderBaked_HDRP.shadergraph.meta new file mode 100644 index 0000000..e26ee54 --- /dev/null +++ b/HDRP/Shaders/RL_EyeOcclusionShaderBaked_HDRP.shadergraph.meta @@ -0,0 +1,10 @@ +fileFormatVersion: 2 +guid: 19cfa70b21a0ca649855cd3bc8896d63 +ScriptedImporter: + internalIDToNameTable: [] + externalObjects: {} + serializedVersion: 2 + userData: + assetBundleName: + assetBundleVariant: + script: {fileID: 11500000, guid: 625f186215c104763be7675aa2d941aa, type: 3} diff --git a/HDRP/Shaders/RL_EyeOcclusionShader_HDRP.shadergraph b/HDRP/Shaders/RL_EyeOcclusionShader_HDRP.shadergraph new file mode 100644 index 0000000..aac82bc --- /dev/null +++ b/HDRP/Shaders/RL_EyeOcclusionShader_HDRP.shadergraph @@ -0,0 +1,10289 @@ +{ + "m_SGVersion": 2, + "m_Type": "UnityEditor.ShaderGraph.GraphData", + "m_ObjectId": "4e287a814e8046e8ac389e15c8a9e3ba", + "m_Properties": [ + { + "m_Id": "e9d81cab799f494a804d5a23f7b9931b" + }, + { + "m_Id": "3b4543cf814541948b29c37c11d7f65c" + }, + { + "m_Id": "65471bb49b7c449ba4b520bb17362d4a" + }, + { + "m_Id": "c530dc7dbef64ff88f5faaec8d3aeb70" + }, + { + "m_Id": "ab62a8666e40463bacc9ea9d5fd7d499" + }, + { + "m_Id": "2a55ed25fe554e5f8cfb78d36ce2a9e5" + }, + { + "m_Id": "09b87be164e345ad946f065f3a43d2ee" + }, + { + "m_Id": "dd54da0252e94dd6a1f7e2f67ac4e5d3" + }, + { + "m_Id": "d212ea7404ac470d8fb7e0b25f74c18e" + }, + { + "m_Id": "801dfebd26864a04b4834d8136ab2f4e" + }, + { + "m_Id": "1f1b7cfea51444bf896958c82e525655" + }, + { + "m_Id": "7bc08229a45c46be902bb162fca67728" + }, + { + "m_Id": "ba712075273f4fa1b806cc19118186a7" + }, + { + "m_Id": "290491e5ea18432bbfab7f17daf6f5d5" + }, + { + "m_Id": "f55851877d874420a73990f8c755a22a" + }, + { + "m_Id": "065243026f14459abdbaef4137a89d8a" + }, + { + "m_Id": "bcd952383b8d4fe0af79e073853c8be7" + }, + { + "m_Id": "f4c450cb47804c14b24590dae355002c" + }, + { + "m_Id": "3c5c8cfa6e464d7489bcc7a552c5922c" + }, + { + "m_Id": "6443d28cbc024921bc6d0f46ee9c2102" + }, + { + "m_Id": "f9622be5f8634164ad02446464ba3c8b" + }, + { + "m_Id": "9d63cbda932d45ff98889efda5a06c38" + }, + { + "m_Id": "266fa5d358b4417ba68d60503300acd5" + } + ], + "m_Keywords": [], + "m_Nodes": [ + { + "m_Id": "2b8d19758b914347b3a90ff4d86a2765" + }, + { + "m_Id": "92cc80251fd64e0fbb5ee01393ce9ec4" + }, + { + "m_Id": "cf932a596e764ab3a051fde470178b7c" + }, + { + "m_Id": "28a1cb2245b64c76bdb75aec1006086e" + }, + { + "m_Id": "7cdec5e4eb1649ea8fa61a2f0e4a1d22" + }, + { + "m_Id": "f0929bd816264348880d393c528dc110" + }, + { + "m_Id": "f3091fe0fa9c4e38aef33375966f2355" + }, + { + "m_Id": "9d7651f674a34929a89bfa45eea65cd6" + }, + { + "m_Id": "c43cb6519f974ed182959abcd616d28b" + }, + { + "m_Id": "b816a39688d74617b11482edc3472c14" + }, + { + "m_Id": "4dec4ff124dd41cfb4722ae7a5ec21c1" + }, + { + "m_Id": "becdaadb0abb4175b8984aeab1c88d8e" + }, + { + "m_Id": "76e9db94bc4549ccb86b4375bef90585" + }, + { + "m_Id": "99bf0686a8d444adbb3b8ed9ca11a33f" + }, + { + "m_Id": "268dc0a6ddfa445fa31df9f283babb1b" + }, + { + "m_Id": "746698fd63c14464af64e794b5fd21a4" + }, + { + "m_Id": "2b9c28298dc14a06a9a0754e721d4e2d" + }, + { + "m_Id": "a378ec4c43524a919746d28ab5e334bf" + }, + { + "m_Id": "40b063e497c341459c7c086cf638a060" + }, + { + "m_Id": "543e3f76dfe745fca9462a84fc6d245e" + }, + { + "m_Id": "e7a24ae205bd439e86a2a235cea7e958" + }, + { + "m_Id": "8bb229fa2e8d462fa69dae3605318197" + }, + { + "m_Id": "91da4058677840c6b12a925b10033143" + }, + { + "m_Id": "8b0b26b61cad41c2868fb6dda828d531" + }, + { + "m_Id": "3defca4cdb924d2fba79c55fd76e2784" + }, + { + "m_Id": "05aa5b42f4d34008a88cdeb7735c74e3" + }, + { + "m_Id": "45127aa896fd4e1b83cfdeee010dcf3e" + }, + { + "m_Id": "4cdc570f6ada484ebeda0d4e7b408ad0" + }, + { + "m_Id": "bbec3648e6344c36a57fa1294aff3f23" + }, + { + "m_Id": "60ca34a12471430e9bb9936532a28fe1" + }, + { + "m_Id": "5ad58c4b717741a48fa105d8432ce3f2" + }, + { + "m_Id": "f8d4eab103f0428892b5b5a06f03bb20" + }, + { + "m_Id": "9de05ac86e15482d9b4ec02fee6fa46f" + }, + { + "m_Id": "54aef52304b343b5878d3abe3ac44e80" + }, + { + "m_Id": "44903d0f5f2f43c183b7653670f708cf" + }, + { + "m_Id": "b094a74596ff4389a782f91be27df498" + }, + { + "m_Id": "d641720eefd44f0ab89160d5a390930c" + }, + { + "m_Id": "cc64b4d3127a4eb69ebaccceb3b0c8ea" + }, + { + "m_Id": "b90bcfe7812b47ffbe08d0e89368abd0" + }, + { + "m_Id": "6391b4c87f124a7db1ce66d39069c97e" + }, + { + "m_Id": "78b78883418c4457b4ff45cf3e5f9e1b" + }, + { + "m_Id": "9d09fa7384444049b4b62c28c48bff43" + }, + { + "m_Id": "4e5f91e4ca854626b423d1f238680464" + }, + { + "m_Id": "bea7d15637c342f5a0f46e3fe54f0c0c" + }, + { + "m_Id": "d308f8ae0caf4e4fb0fb9815db0829e5" + }, + { + "m_Id": "40934f7108764b6ea0c2a26cbce734c9" + }, + { + "m_Id": "d0f064ad3fb2480c84466012dad6fa0d" + }, + { + "m_Id": "5e800f943e0b4021a7929b6214afa644" + }, + { + "m_Id": "195fd554194946fd80a4cf472ed71f02" + }, + { + "m_Id": "1eb77f5fde77455a8d281a66375f21e3" + }, + { + "m_Id": "0c32ea026c014f27b9a3185a0967bac8" + }, + { + "m_Id": "973949d9bbe34e27a3b4d319f04baa71" + }, + { + "m_Id": "c265c36ac38a40ad9a117c9ee3bbd219" + }, + { + "m_Id": "8cf1d5529cb145a8aa9387117538ccbd" + }, + { + "m_Id": "fc71312321eb45b8b800345777d37a5d" + }, + { + "m_Id": "f0800ee295444cc6bc7eca6dab184d8e" + }, + { + "m_Id": "44362990242f4102a045c894da5631cf" + }, + { + "m_Id": "bec97d41a4a84aa58e0ff22f2f7adfd5" + }, + { + "m_Id": "74eb110adc4143f9a5ee6c6053eee5ef" + }, + { + "m_Id": "beb4ecf6c7834c56a1ac66b1d3f69323" + }, + { + "m_Id": "a63f6e2cd0db4079880e9db29ea73dff" + }, + { + "m_Id": "3a5b826f7b4c43938b639d4ab49776c2" + }, + { + "m_Id": "4eda52cace9043a38dfcb433aaa088b9" + }, + { + "m_Id": "171355558da246f28565da33d42b0a57" + }, + { + "m_Id": "cc2beb151c5b4a6589b44a757b3c845c" + }, + { + "m_Id": "7b4e326f0c4343d5952c2e703103f28b" + }, + { + "m_Id": "57be4831af9844c093bf59542287b3e4" + }, + { + "m_Id": "2626db8ff8044c67871e4e35f9026637" + }, + { + "m_Id": "6aeb789dd1694c07a16cb598fd712e52" + }, + { + "m_Id": "7ea050afc45244458bc53e4dc518f59f" + }, + { + "m_Id": "0d3485be019d484889b82097564d00cd" + }, + { + "m_Id": "b36665f3426c4d3b9382ff175d4c08a9" + }, + { + "m_Id": "00a1493bbd56454bb17139e9c3be4165" + }, + { + "m_Id": "19c371c10915456a830773ab66f74fdc" + }, + { + "m_Id": "441e86e7628f4579801f1111a03800a2" + }, + { + "m_Id": "d8e4155c85614881aaef68d3828c47bb" + }, + { + "m_Id": "d9cb07c9f0ba47839945d27cff94311a" + }, + { + "m_Id": "dc8dc19bad4543649f684efd8c0305a9" + }, + { + "m_Id": "3f18e638ea2c4c6d9fceab51663abdc7" + }, + { + "m_Id": "149c55393ab94752af2649b085e235a5" + }, + { + "m_Id": "5382dabaf66f42bbbbce0ad31d602c81" + }, + { + "m_Id": "6d360fc91efd4575acf35e944c49ea92" + }, + { + "m_Id": "4baacdf7cc65416b80f9b20bd797c289" + }, + { + "m_Id": "275c4f0a1fee43d2bddf634418e542a1" + } + ], + "m_GroupDatas": [ + { + "m_Id": "bb3fb3d46c9240e499693e3571b3e902" + }, + { + "m_Id": "b0dc17fd9b744813b0d3cfe2bafd9cc5" + }, + { + "m_Id": "b4df5b2a90e74fea8f802d43a8c09f8b" + }, + { + "m_Id": "0bda9324be5243aba9c7b05ef2f00ded" + }, + { + "m_Id": "07eec948987b4086a8f8a9921af44a06" + } + ], + "m_StickyNoteDatas": [], + "m_Edges": [ + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "00a1493bbd56454bb17139e9c3be4165" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "b36665f3426c4d3b9382ff175d4c08a9" + }, + "m_SlotId": 1 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "05aa5b42f4d34008a88cdeb7735c74e3" + }, + "m_SlotId": 2 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "45127aa896fd4e1b83cfdeee010dcf3e" + }, + "m_SlotId": 1 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "0c32ea026c014f27b9a3185a0967bac8" + }, + "m_SlotId": 2 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "c265c36ac38a40ad9a117c9ee3bbd219" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "0d3485be019d484889b82097564d00cd" + }, + "m_SlotId": 1 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "7ea050afc45244458bc53e4dc518f59f" + }, + "m_SlotId": 1 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "149c55393ab94752af2649b085e235a5" + }, + "m_SlotId": 1 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "5382dabaf66f42bbbbce0ad31d602c81" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "171355558da246f28565da33d42b0a57" + }, + "m_SlotId": 3 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "2626db8ff8044c67871e4e35f9026637" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "195fd554194946fd80a4cf472ed71f02" + }, + "m_SlotId": 1 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "3a5b826f7b4c43938b639d4ab49776c2" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "19c371c10915456a830773ab66f74fdc" + }, + "m_SlotId": 1 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "7ea050afc45244458bc53e4dc518f59f" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "1eb77f5fde77455a8d281a66375f21e3" + }, + "m_SlotId": 2 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "195fd554194946fd80a4cf472ed71f02" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "2626db8ff8044c67871e4e35f9026637" + }, + "m_SlotId": 2 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "0d3485be019d484889b82097564d00cd" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "268dc0a6ddfa445fa31df9f283babb1b" + }, + "m_SlotId": 2 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "91da4058677840c6b12a925b10033143" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "275c4f0a1fee43d2bddf634418e542a1" + }, + "m_SlotId": 1 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "f8d4eab103f0428892b5b5a06f03bb20" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "2b9c28298dc14a06a9a0754e721d4e2d" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "91da4058677840c6b12a925b10033143" + }, + "m_SlotId": 1 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "3a5b826f7b4c43938b639d4ab49776c2" + }, + "m_SlotId": 1 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "4eda52cace9043a38dfcb433aaa088b9" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "3defca4cdb924d2fba79c55fd76e2784" + }, + "m_SlotId": 2 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "45127aa896fd4e1b83cfdeee010dcf3e" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "3f18e638ea2c4c6d9fceab51663abdc7" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "5382dabaf66f42bbbbce0ad31d602c81" + }, + "m_SlotId": 1 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "40934f7108764b6ea0c2a26cbce734c9" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "f0800ee295444cc6bc7eca6dab184d8e" + }, + "m_SlotId": 1 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "40b063e497c341459c7c086cf638a060" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "e7a24ae205bd439e86a2a235cea7e958" + }, + "m_SlotId": 1 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "441e86e7628f4579801f1111a03800a2" + }, + "m_SlotId": 1 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "f8d4eab103f0428892b5b5a06f03bb20" + }, + "m_SlotId": 2 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "44362990242f4102a045c894da5631cf" + }, + "m_SlotId": 3 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "0c32ea026c014f27b9a3185a0967bac8" + }, + "m_SlotId": 1 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "44903d0f5f2f43c183b7653670f708cf" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "fc71312321eb45b8b800345777d37a5d" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "45127aa896fd4e1b83cfdeee010dcf3e" + }, + "m_SlotId": 2 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "4cdc570f6ada484ebeda0d4e7b408ad0" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "4baacdf7cc65416b80f9b20bd797c289" + }, + "m_SlotId": 1 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "441e86e7628f4579801f1111a03800a2" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "4cdc570f6ada484ebeda0d4e7b408ad0" + }, + "m_SlotId": 2 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "60ca34a12471430e9bb9936532a28fe1" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "4dec4ff124dd41cfb4722ae7a5ec21c1" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "becdaadb0abb4175b8984aeab1c88d8e" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "4e5f91e4ca854626b423d1f238680464" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "9d09fa7384444049b4b62c28c48bff43" + }, + "m_SlotId": 1 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "4eda52cace9043a38dfcb433aaa088b9" + }, + "m_SlotId": 2 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "19c371c10915456a830773ab66f74fdc" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "5382dabaf66f42bbbbce0ad31d602c81" + }, + "m_SlotId": 2 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "6d360fc91efd4575acf35e944c49ea92" + }, + "m_SlotId": 1 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "543e3f76dfe745fca9462a84fc6d245e" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "8bb229fa2e8d462fa69dae3605318197" + }, + "m_SlotId": 1 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "54aef52304b343b5878d3abe3ac44e80" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "9de05ac86e15482d9b4ec02fee6fa46f" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "57be4831af9844c093bf59542287b3e4" + }, + "m_SlotId": 1 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "78b78883418c4457b4ff45cf3e5f9e1b" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "57be4831af9844c093bf59542287b3e4" + }, + "m_SlotId": 1 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "d9cb07c9f0ba47839945d27cff94311a" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "5ad58c4b717741a48fa105d8432ce3f2" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "149c55393ab94752af2649b085e235a5" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "5ad58c4b717741a48fa105d8432ce3f2" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "275c4f0a1fee43d2bddf634418e542a1" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "5ad58c4b717741a48fa105d8432ce3f2" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "6d360fc91efd4575acf35e944c49ea92" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "5e800f943e0b4021a7929b6214afa644" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "44362990242f4102a045c894da5631cf" + }, + "m_SlotId": 1 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "60ca34a12471430e9bb9936532a28fe1" + }, + "m_SlotId": 1 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "9d7651f674a34929a89bfa45eea65cd6" + }, + "m_SlotId": 1 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "6391b4c87f124a7db1ce66d39069c97e" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "8cf1d5529cb145a8aa9387117538ccbd" + }, + "m_SlotId": 1 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "6aeb789dd1694c07a16cb598fd712e52" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "2626db8ff8044c67871e4e35f9026637" + }, + "m_SlotId": 1 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "6d360fc91efd4575acf35e944c49ea92" + }, + "m_SlotId": 2 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "f8d4eab103f0428892b5b5a06f03bb20" + }, + "m_SlotId": 1 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "746698fd63c14464af64e794b5fd21a4" + }, + "m_SlotId": 1 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "8b0b26b61cad41c2868fb6dda828d531" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "74eb110adc4143f9a5ee6c6053eee5ef" + }, + "m_SlotId": 1 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "8cf1d5529cb145a8aa9387117538ccbd" + }, + "m_SlotId": 2 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "76e9db94bc4549ccb86b4375bef90585" + }, + "m_SlotId": 1 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "8bb229fa2e8d462fa69dae3605318197" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "78b78883418c4457b4ff45cf3e5f9e1b" + }, + "m_SlotId": 1 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "fc71312321eb45b8b800345777d37a5d" + }, + "m_SlotId": 2 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "7b4e326f0c4343d5952c2e703103f28b" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "171355558da246f28565da33d42b0a57" + }, + "m_SlotId": 1 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "7ea050afc45244458bc53e4dc518f59f" + }, + "m_SlotId": 2 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "beb4ecf6c7834c56a1ac66b1d3f69323" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "8b0b26b61cad41c2868fb6dda828d531" + }, + "m_SlotId": 2 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "05aa5b42f4d34008a88cdeb7735c74e3" + }, + "m_SlotId": 1 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "8bb229fa2e8d462fa69dae3605318197" + }, + "m_SlotId": 2 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "3defca4cdb924d2fba79c55fd76e2784" + }, + "m_SlotId": 1 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "8cf1d5529cb145a8aa9387117538ccbd" + }, + "m_SlotId": 3 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "9d09fa7384444049b4b62c28c48bff43" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "91da4058677840c6b12a925b10033143" + }, + "m_SlotId": 2 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "05aa5b42f4d34008a88cdeb7735c74e3" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "973949d9bbe34e27a3b4d319f04baa71" + }, + "m_SlotId": 2 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "c265c36ac38a40ad9a117c9ee3bbd219" + }, + "m_SlotId": 1 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "99bf0686a8d444adbb3b8ed9ca11a33f" + }, + "m_SlotId": 2 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "e7a24ae205bd439e86a2a235cea7e958" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "9d09fa7384444049b4b62c28c48bff43" + }, + "m_SlotId": 2 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "973949d9bbe34e27a3b4d319f04baa71" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "9d7651f674a34929a89bfa45eea65cd6" + }, + "m_SlotId": 2 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "c43cb6519f974ed182959abcd616d28b" + }, + "m_SlotId": 1 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "9de05ac86e15482d9b4ec02fee6fa46f" + }, + "m_SlotId": 1 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "44362990242f4102a045c894da5631cf" + }, + "m_SlotId": 2 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "9de05ac86e15482d9b4ec02fee6fa46f" + }, + "m_SlotId": 1 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "bea7d15637c342f5a0f46e3fe54f0c0c" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "9de05ac86e15482d9b4ec02fee6fa46f" + }, + "m_SlotId": 1 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "d8e4155c85614881aaef68d3828c47bb" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "9de05ac86e15482d9b4ec02fee6fa46f" + }, + "m_SlotId": 2 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "57be4831af9844c093bf59542287b3e4" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "9de05ac86e15482d9b4ec02fee6fa46f" + }, + "m_SlotId": 2 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "74eb110adc4143f9a5ee6c6053eee5ef" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "a378ec4c43524a919746d28ab5e334bf" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "8b0b26b61cad41c2868fb6dda828d531" + }, + "m_SlotId": 1 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "a63f6e2cd0db4079880e9db29ea73dff" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "4eda52cace9043a38dfcb433aaa088b9" + }, + "m_SlotId": 1 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "b094a74596ff4389a782f91be27df498" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "fc71312321eb45b8b800345777d37a5d" + }, + "m_SlotId": 1 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "b36665f3426c4d3b9382ff175d4c08a9" + }, + "m_SlotId": 2 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "f0929bd816264348880d393c528dc110" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "b816a39688d74617b11482edc3472c14" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "9d7651f674a34929a89bfa45eea65cd6" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "b90bcfe7812b47ffbe08d0e89368abd0" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "8cf1d5529cb145a8aa9387117538ccbd" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "bbec3648e6344c36a57fa1294aff3f23" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "4cdc570f6ada484ebeda0d4e7b408ad0" + }, + "m_SlotId": 1 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "bea7d15637c342f5a0f46e3fe54f0c0c" + }, + "m_SlotId": 1 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "f0800ee295444cc6bc7eca6dab184d8e" + }, + "m_SlotId": 2 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "beb4ecf6c7834c56a1ac66b1d3f69323" + }, + "m_SlotId": 2 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "b36665f3426c4d3b9382ff175d4c08a9" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "bec97d41a4a84aa58e0ff22f2f7adfd5" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "28a1cb2245b64c76bdb75aec1006086e" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "becdaadb0abb4175b8984aeab1c88d8e" + }, + "m_SlotId": 1 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "76e9db94bc4549ccb86b4375bef90585" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "becdaadb0abb4175b8984aeab1c88d8e" + }, + "m_SlotId": 1 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "99bf0686a8d444adbb3b8ed9ca11a33f" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "becdaadb0abb4175b8984aeab1c88d8e" + }, + "m_SlotId": 2 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "268dc0a6ddfa445fa31df9f283babb1b" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "becdaadb0abb4175b8984aeab1c88d8e" + }, + "m_SlotId": 2 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "746698fd63c14464af64e794b5fd21a4" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "c265c36ac38a40ad9a117c9ee3bbd219" + }, + "m_SlotId": 2 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "1eb77f5fde77455a8d281a66375f21e3" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "c43cb6519f974ed182959abcd616d28b" + }, + "m_SlotId": 2 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "2b8d19758b914347b3a90ff4d86a2765" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "cc2beb151c5b4a6589b44a757b3c845c" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "171355558da246f28565da33d42b0a57" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "cc64b4d3127a4eb69ebaccceb3b0c8ea" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "d641720eefd44f0ab89160d5a390930c" + }, + "m_SlotId": 1 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "d0f064ad3fb2480c84466012dad6fa0d" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "44362990242f4102a045c894da5631cf" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "d308f8ae0caf4e4fb0fb9815db0829e5" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "f0800ee295444cc6bc7eca6dab184d8e" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "d641720eefd44f0ab89160d5a390930c" + }, + "m_SlotId": 2 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "973949d9bbe34e27a3b4d319f04baa71" + }, + "m_SlotId": 1 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "d8e4155c85614881aaef68d3828c47bb" + }, + "m_SlotId": 1 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "4baacdf7cc65416b80f9b20bd797c289" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "d9cb07c9f0ba47839945d27cff94311a" + }, + "m_SlotId": 1 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "171355558da246f28565da33d42b0a57" + }, + "m_SlotId": 2 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "dc8dc19bad4543649f684efd8c0305a9" + }, + "m_SlotId": 1 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "beb4ecf6c7834c56a1ac66b1d3f69323" + }, + "m_SlotId": 1 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "e7a24ae205bd439e86a2a235cea7e958" + }, + "m_SlotId": 2 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "3defca4cdb924d2fba79c55fd76e2784" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "f0800ee295444cc6bc7eca6dab184d8e" + }, + "m_SlotId": 3 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "0c32ea026c014f27b9a3185a0967bac8" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "f3091fe0fa9c4e38aef33375966f2355" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "c43cb6519f974ed182959abcd616d28b" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "f8d4eab103f0428892b5b5a06f03bb20" + }, + "m_SlotId": 3 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "dc8dc19bad4543649f684efd8c0305a9" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "fc71312321eb45b8b800345777d37a5d" + }, + "m_SlotId": 3 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "d641720eefd44f0ab89160d5a390930c" + }, + "m_SlotId": 0 + } + } + ], + "m_VertexContext": { + "m_Position": { + "x": 154.9999237060547, + "y": 71.99999237060547 + }, + "m_Blocks": [ + { + "m_Id": "2b8d19758b914347b3a90ff4d86a2765" + }, + { + "m_Id": "92cc80251fd64e0fbb5ee01393ce9ec4" + }, + { + "m_Id": "cf932a596e764ab3a051fde470178b7c" + } + ] + }, + "m_FragmentContext": { + "m_Position": { + "x": 154.9999237060547, + "y": 272.0 + }, + "m_Blocks": [ + { + "m_Id": "28a1cb2245b64c76bdb75aec1006086e" + }, + { + "m_Id": "7cdec5e4eb1649ea8fa61a2f0e4a1d22" + }, + { + "m_Id": "f0929bd816264348880d393c528dc110" + } + ] + }, + "m_PreviewData": { + "serializedMesh": { + "m_SerializedMesh": "{\"mesh\":{\"instanceID\":0}}", + "m_Guid": "" + } + }, + "m_Path": "Shader Graphs", + "m_ConcretePrecision": 1, + "m_PreviewMode": 2, + "m_OutputNode": { + "m_Id": "" + }, + "m_ActiveTargets": [ + { + "m_Id": "524b537aa1c147b98f6d8296cc97cf5d" + } + ] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.PropertyNode", + "m_ObjectId": "00a1493bbd56454bb17139e9c3be4165", + "m_Group": { + "m_Id": "07eec948987b4086a8f8a9921af44a06" + }, + "m_Name": "Property", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -2677.0, + "y": 897.9998779296875, + "width": 163.00001525878907, + "height": 34.000003814697269 + } + }, + "m_Slots": [ + { + "m_Id": "b48e9000cc99472c8a058c34c795c30b" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_Property": { + "m_Id": "65471bb49b7c449ba4b520bb17362d4a" + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "00a4b524b54d40fdbcf604c7cc58d749", + "m_Id": 1, + "m_DisplayName": "B", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "B", + "m_StageCapability": 3, + "m_Value": { + "x": 2.0, + "y": 2.0, + "z": 2.0, + "w": 2.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "01325722aef24833a50c42c536770a36", + "m_Id": 3, + "m_DisplayName": "Out", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.Rendering.HighDefinition.ShaderGraph.HDUnlitData", + "m_ObjectId": "017597816b1d4ca480b6f999b23798f7", + "m_EnableShadowMatte": false, + "m_DistortionOnly": false +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "025715d269714389b2bc572d1b32a09a", + "m_Id": 0, + "m_DisplayName": "Expand Upper", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "02a4afedd77a45a18183ae0fb54970fb", + "m_Id": 2, + "m_DisplayName": "Out", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.AddNode", + "m_ObjectId": "05aa5b42f4d34008a88cdeb7735c74e3", + "m_Group": { + "m_Id": "b4df5b2a90e74fea8f802d43a8c09f8b" + }, + "m_Name": "Add", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -1817.0, + "y": -346.9999084472656, + "width": 126.00000762939453, + "height": 118.00000762939453 + } + }, + "m_Slots": [ + { + "m_Id": "e6bcbf0b79c94547b3a5801c6ee9ad01" + }, + { + "m_Id": "9809211060c749c4b9b2b2889abcc80a" + }, + { + "m_Id": "9daa98284e2e4f0689b4a202bbf65f3b" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "05b797db370449deb48124605e9e32f4", + "m_Id": 0, + "m_DisplayName": "In", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "In", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "06315e49bb5a4718a4b0212b4815eac6", + "m_Id": 0, + "m_DisplayName": "Tear Duct Width", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 1, + "m_Type": "UnityEditor.ShaderGraph.Internal.Vector1ShaderProperty", + "m_ObjectId": "065243026f14459abdbaef4137a89d8a", + "m_Guid": { + "m_GuidSerialized": "9ea4bdef-b067-49ff-ad20-89a4c9431148" + }, + "m_Name": "Top 2 Max", + "m_DefaultReferenceName": "", + "m_OverrideReferenceName": "_Top2Max", + "m_GeneratePropertyBlock": true, + "m_Precision": 0, + "overrideHLSLDeclaration": false, + "hlslDeclarationOverride": 0, + "m_Hidden": false, + "m_Value": 1.0, + "m_FloatType": 1, + "m_RangeValues": { + "x": 0.0, + "y": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "068c8df0359a4bee80aa8249b915278f", + "m_Id": 0, + "m_DisplayName": "In", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "In", + "m_StageCapability": 3, + "m_Value": { + "x": 1.0, + "y": 1.0, + "z": 1.0, + "w": 1.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector4MaterialSlot", + "m_ObjectId": "076bd42eeeef49dfbdef82e7b1bf8eb9", + "m_Id": 0, + "m_DisplayName": "Occlusion Color", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "0790a7e02d5e42e4bef6d7349e41e1dc", + "m_Id": 0, + "m_DisplayName": "In", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "In", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "07b9cacb9b23468b9eb942369ab0dd27", + "m_Id": 2, + "m_DisplayName": "Out", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.GroupData", + "m_ObjectId": "07eec948987b4086a8f8a9921af44a06", + "m_Title": "Final Power Adjust", + "m_Position": { + "x": -2702.000244140625, + "y": 734.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicValueMaterialSlot", + "m_ObjectId": "08e714c99a1f4644bf2ffa5816a52dff", + "m_Id": 2, + "m_DisplayName": "Out", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": { + "e00": 0.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 0.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 0.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 0.0 + }, + "m_DefaultValue": { + "e00": 1.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 1.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 1.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.NormalMaterialSlot", + "m_ObjectId": "0904b4e2e2af45338adfccb48136581c", + "m_Id": 0, + "m_DisplayName": "Normal", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "Normal", + "m_StageCapability": 1, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0 + }, + "m_Labels": [], + "m_Space": 0 +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "0959694a26f345a998f9e697aa408421", + "m_Id": 0, + "m_DisplayName": "In", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "In", + "m_StageCapability": 3, + "m_Value": { + "x": 1.0, + "y": 1.0, + "z": 1.0, + "w": 1.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 1, + "m_Type": "UnityEditor.ShaderGraph.Internal.Vector1ShaderProperty", + "m_ObjectId": "09b87be164e345ad946f065f3a43d2ee", + "m_Guid": { + "m_GuidSerialized": "8dc33ea0-5873-49da-8266-ce82772c0d9e" + }, + "m_Name": "Bottom Min", + "m_DefaultReferenceName": "", + "m_OverrideReferenceName": "_BottomMin", + "m_GeneratePropertyBlock": true, + "m_Precision": 0, + "overrideHLSLDeclaration": false, + "hlslDeclarationOverride": 0, + "m_Hidden": false, + "m_Value": 0.05000000074505806, + "m_FloatType": 1, + "m_RangeValues": { + "x": 0.0, + "y": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "0aa6bfa1b6ea45d4aaea7f324d8940b4", + "m_Id": 1, + "m_DisplayName": "B", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "B", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "0bbe1b6c18db4500954f186ec72ad31c", + "m_Id": 0, + "m_DisplayName": "Edge1", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "Edge1", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.GroupData", + "m_ObjectId": "0bda9324be5243aba9c7b05ef2f00ded", + "m_Title": "Tear Duct Mask", + "m_Position": { + "x": -4244.0, + "y": 731.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.MultiplyNode", + "m_ObjectId": "0c32ea026c014f27b9a3185a0967bac8", + "m_Group": { + "m_Id": "bb3fb3d46c9240e499693e3571b3e902" + }, + "m_Name": "Multiply", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -5614.0, + "y": -969.0000610351563, + "width": 208.0, + "height": 302.0 + } + }, + "m_Slots": [ + { + "m_Id": "d0b43c7f386847468f35c737403aa6fb" + }, + { + "m_Id": "895cca255be24cf29a3be7ac6eedca31" + }, + { + "m_Id": "480b45a8a9c14d34bd58e8370f02276e" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.SaturateNode", + "m_ObjectId": "0d3485be019d484889b82097564d00cd", + "m_Group": { + "m_Id": "bb3fb3d46c9240e499693e3571b3e902" + }, + "m_Name": "Saturate", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -4184.0, + "y": 19.000076293945314, + "width": 208.0, + "height": 278.0 + } + }, + "m_Slots": [ + { + "m_Id": "107f29638abd4bbfb63b9e07d1d4f925" + }, + { + "m_Id": "8f2ee7484dd44a5b8340437652ba9c50" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "107f29638abd4bbfb63b9e07d1d4f925", + "m_Id": 0, + "m_DisplayName": "In", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "In", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicValueMaterialSlot", + "m_ObjectId": "12bb558652c74b3ab655b04fc0dec653", + "m_Id": 0, + "m_DisplayName": "A", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "A", + "m_StageCapability": 3, + "m_Value": { + "e00": 0.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 0.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 0.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 0.0 + }, + "m_DefaultValue": { + "e00": 1.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 1.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 1.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicValueMaterialSlot", + "m_ObjectId": "13926e9f8ba8424eab8ba9d9505be195", + "m_Id": 2, + "m_DisplayName": "Out", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": { + "e00": 0.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 0.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 0.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 0.0 + }, + "m_DefaultValue": { + "e00": 1.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 1.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 1.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "148b8781d99c40638b56e0cce0315f95", + "m_Id": 0, + "m_DisplayName": "A", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "A", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.OneMinusNode", + "m_ObjectId": "149c55393ab94752af2649b085e235a5", + "m_Group": { + "m_Id": "0bda9324be5243aba9c7b05ef2f00ded" + }, + "m_Name": "One Minus", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -4519.00048828125, + "y": 834.0, + "width": 128.0, + "height": 94.0 + } + }, + "m_Slots": [ + { + "m_Id": "d780ac648c1c4de3b184b3b6f4fb4444" + }, + { + "m_Id": "5b542458b15144d2b9b5b9b9983174e4" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "15499d5dcf724e8fa59aa431d0a7c5e7", + "m_Id": 3, + "m_DisplayName": "B", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "B", + "m_StageCapability": 3, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicValueMaterialSlot", + "m_ObjectId": "16468c50b06f4e7d8d18eb3297127f61", + "m_Id": 0, + "m_DisplayName": "A", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "A", + "m_StageCapability": 3, + "m_Value": { + "e00": 0.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 0.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 0.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 0.0 + }, + "m_DefaultValue": { + "e00": 1.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 1.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 1.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.SmoothstepNode", + "m_ObjectId": "171355558da246f28565da33d42b0a57", + "m_Group": { + "m_Id": "bb3fb3d46c9240e499693e3571b3e902" + }, + "m_Name": "Smoothstep", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -5899.0, + "y": 229.00003051757813, + "width": 208.0, + "height": 326.0000305175781 + } + }, + "m_Slots": [ + { + "m_Id": "d31794772e5249cc8624c820826d8018" + }, + { + "m_Id": "831da0d7c3804d74959a627cf863e488" + }, + { + "m_Id": "d355974e14d846879fb898fb29b7501a" + }, + { + "m_Id": "fa313b6cbb2549ee998561bdbbfdc217" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "18cd722a32d648f68ec3f5a0dd01d2b4", + "m_Id": 1, + "m_DisplayName": "", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.SaturateNode", + "m_ObjectId": "195fd554194946fd80a4cf472ed71f02", + "m_Group": { + "m_Id": "bb3fb3d46c9240e499693e3571b3e902" + }, + "m_Name": "Saturate", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -4893.0, + "y": -726.0000610351563, + "width": 208.0, + "height": 278.0 + } + }, + "m_Slots": [ + { + "m_Id": "6875cb582a3c49aeb2ad2c25ef0bfdd4" + }, + { + "m_Id": "38eb7c23683a4cc0a261239201702503" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "196787bff01345e29cc327dd6c8c5dc3", + "m_Id": 0, + "m_DisplayName": "", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.SaturateNode", + "m_ObjectId": "19c371c10915456a830773ab66f74fdc", + "m_Group": { + "m_Id": "bb3fb3d46c9240e499693e3571b3e902" + }, + "m_Name": "Saturate", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -4184.0, + "y": -339.00006103515627, + "width": 208.0, + "height": 278.0 + } + }, + "m_Slots": [ + { + "m_Id": "b28c78e993ae4a5ebdad9e9dad855b8a" + }, + { + "m_Id": "23d1409e6dc4419f8893cda2a3d44610" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.PositionMaterialSlot", + "m_ObjectId": "1a10cbf41eff4c3e81bbf5abb15f47da", + "m_Id": 0, + "m_DisplayName": "Position", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "Position", + "m_StageCapability": 1, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0 + }, + "m_Labels": [], + "m_Space": 0 +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "1a3dd9f7b0504faa87c3e2bd7f79014f", + "m_Id": 2, + "m_DisplayName": "Out", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "1d711b75f4154318a5fb791fb04f2017", + "m_Id": 0, + "m_DisplayName": "A", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "A", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.MultiplyNode", + "m_ObjectId": "1eb77f5fde77455a8d281a66375f21e3", + "m_Group": { + "m_Id": "bb3fb3d46c9240e499693e3571b3e902" + }, + "m_Name": "Multiply", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -5083.0, + "y": -705.0001220703125, + "width": 126.0, + "height": 118.0 + } + }, + "m_Slots": [ + { + "m_Id": "9e9d3ade79584b2f85e25c7602405817" + }, + { + "m_Id": "e265d221fc5543c2a821246aaf81c1e0" + }, + { + "m_Id": "13926e9f8ba8424eab8ba9d9505be195" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 1, + "m_Type": "UnityEditor.ShaderGraph.Internal.Vector1ShaderProperty", + "m_ObjectId": "1f1b7cfea51444bf896958c82e525655", + "m_Guid": { + "m_GuidSerialized": "ed58d142-d9eb-47ef-ba92-bd183171ebe2" + }, + "m_Name": "Inner Max", + "m_DefaultReferenceName": "", + "m_OverrideReferenceName": "_InnerMax", + "m_GeneratePropertyBlock": true, + "m_Precision": 0, + "overrideHLSLDeclaration": false, + "hlslDeclarationOverride": 0, + "m_Hidden": false, + "m_Value": 0.5, + "m_FloatType": 1, + "m_RangeValues": { + "x": 0.0, + "y": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "1f6ffa5fd1594e8bb959936cdad4af83", + "m_Id": 3, + "m_DisplayName": "Out", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "1fd72b34c59349b1928a26149cfeffae", + "m_Id": 0, + "m_DisplayName": "Edge1", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "Edge1", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicValueMaterialSlot", + "m_ObjectId": "212af8d89c6544d0a4dc52b249d92d48", + "m_Id": 1, + "m_DisplayName": "B", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "B", + "m_StageCapability": 3, + "m_Value": { + "e00": 2.0, + "e01": 2.0, + "e02": 2.0, + "e03": 2.0, + "e10": 2.0, + "e11": 2.0, + "e12": 2.0, + "e13": 2.0, + "e20": 2.0, + "e21": 2.0, + "e22": 2.0, + "e23": 2.0, + "e30": 2.0, + "e31": 2.0, + "e32": 2.0, + "e33": 2.0 + }, + "m_DefaultValue": { + "e00": 1.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 1.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 1.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicValueMaterialSlot", + "m_ObjectId": "239f505afc5745eeba30d213e5edff68", + "m_Id": 1, + "m_DisplayName": "B", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "B", + "m_StageCapability": 3, + "m_Value": { + "e00": 2.0, + "e01": 2.0, + "e02": 2.0, + "e03": 2.0, + "e10": 2.0, + "e11": 2.0, + "e12": 2.0, + "e13": 2.0, + "e20": 2.0, + "e21": 2.0, + "e22": 2.0, + "e23": 2.0, + "e30": 2.0, + "e31": 2.0, + "e32": 2.0, + "e33": 2.0 + }, + "m_DefaultValue": { + "e00": 1.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 1.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 1.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "23d1409e6dc4419f8893cda2a3d44610", + "m_Id": 1, + "m_DisplayName": "Out", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "247cee4d6cfa4edea2e80286d5bce344", + "m_Id": 1, + "m_DisplayName": "Out", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "26119b1e9b83423b987970fc75effc92", + "m_Id": 1, + "m_DisplayName": "", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.MultiplyNode", + "m_ObjectId": "2626db8ff8044c67871e4e35f9026637", + "m_Group": { + "m_Id": "bb3fb3d46c9240e499693e3571b3e902" + }, + "m_Name": "Multiply", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -5460.0, + "y": 229.00003051757813, + "width": 126.0, + "height": 118.0 + } + }, + "m_Slots": [ + { + "m_Id": "e0b0d8b22c4f4ffc9cf4cbe59f947987" + }, + { + "m_Id": "438a906760de49aaaf30c2d63185587b" + }, + { + "m_Id": "cd6ae63c6a0145ff98c017fa840d66a2" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 1, + "m_Type": "UnityEditor.ShaderGraph.Internal.Vector1ShaderProperty", + "m_ObjectId": "266fa5d358b4417ba68d60503300acd5", + "m_Guid": { + "m_GuidSerialized": "dbe879d0-d7b2-4e8f-979a-12a35f0efaab" + }, + "m_Name": "Expand Outer", + "m_DefaultReferenceName": "", + "m_OverrideReferenceName": "_ExpandOuter", + "m_GeneratePropertyBlock": true, + "m_Precision": 0, + "overrideHLSLDeclaration": false, + "hlslDeclarationOverride": 0, + "m_Hidden": false, + "m_Value": 0.000699999975040555, + "m_FloatType": 1, + "m_RangeValues": { + "x": -0.0010000000474974514, + "y": 0.0010000000474974514 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.AddNode", + "m_ObjectId": "268dc0a6ddfa445fa31df9f283babb1b", + "m_Group": { + "m_Id": "b4df5b2a90e74fea8f802d43a8c09f8b" + }, + "m_Name": "Add", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -2710.000244140625, + "y": -487.9999694824219, + "width": 208.00001525878907, + "height": 302.0000305175781 + } + }, + "m_Slots": [ + { + "m_Id": "d4ee052d4ddc4ca781803618e0f24a45" + }, + { + "m_Id": "76ffca67ef58488c99e3bb61bbb16e13" + }, + { + "m_Id": "308e274fdf574467a0d9d889a9208431" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.RedirectNodeData", + "m_ObjectId": "275c4f0a1fee43d2bddf634418e542a1", + "m_Group": { + "m_Id": "0bda9324be5243aba9c7b05ef2f00ded" + }, + "m_Name": "Redirect Node", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -4118.00048828125, + "y": 778.0, + "width": 56.000003814697269, + "height": 24.000001907348634 + } + }, + "m_Slots": [ + { + "m_Id": "89218f48e9fc41f58dccb4cb2044d541" + }, + { + "m_Id": "4a9a82308d804ffab9018066cf716762" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.BlockNode", + "m_ObjectId": "28a1cb2245b64c76bdb75aec1006086e", + "m_Group": { + "m_Id": "" + }, + "m_Name": "SurfaceDescription.BaseColor", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": 0.0, + "y": 0.0, + "width": 0.0, + "height": 0.0 + } + }, + "m_Slots": [ + { + "m_Id": "bb28d292ab8e4ae88fbf211b9f92593c" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_SerializedDescriptor": "SurfaceDescription.BaseColor" +} + +{ + "m_SGVersion": 1, + "m_Type": "UnityEditor.ShaderGraph.Internal.Vector1ShaderProperty", + "m_ObjectId": "290491e5ea18432bbfab7f17daf6f5d5", + "m_Guid": { + "m_GuidSerialized": "225de413-c559-4c37-b1a6-7108d5e5ce0d" + }, + "m_Name": "Occlusion Strength 2", + "m_DefaultReferenceName": "", + "m_OverrideReferenceName": "_OcclusionStrength2", + "m_GeneratePropertyBlock": true, + "m_Precision": 0, + "overrideHLSLDeclaration": false, + "hlslDeclarationOverride": 0, + "m_Hidden": false, + "m_Value": 0.44999998807907107, + "m_FloatType": 1, + "m_RangeValues": { + "x": 0.0, + "y": 2.0 + } +} + +{ + "m_SGVersion": 1, + "m_Type": "UnityEditor.ShaderGraph.Internal.Vector1ShaderProperty", + "m_ObjectId": "2a55ed25fe554e5f8cfb78d36ce2a9e5", + "m_Guid": { + "m_GuidSerialized": "7535b1a1-a8cd-408f-bee9-2506266899ba" + }, + "m_Name": "Top Curve", + "m_DefaultReferenceName": "", + "m_OverrideReferenceName": "_TopCurve", + "m_GeneratePropertyBlock": true, + "m_Precision": 0, + "overrideHLSLDeclaration": false, + "hlslDeclarationOverride": 0, + "m_Hidden": false, + "m_Value": 1.2869999408721924, + "m_FloatType": 1, + "m_RangeValues": { + "x": 0.0, + "y": 2.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.BlockNode", + "m_ObjectId": "2b8d19758b914347b3a90ff4d86a2765", + "m_Group": { + "m_Id": "" + }, + "m_Name": "VertexDescription.Position", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": 0.0, + "y": 0.0, + "width": 0.0, + "height": 0.0 + } + }, + "m_Slots": [ + { + "m_Id": "1a10cbf41eff4c3e81bbf5abb15f47da" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_SerializedDescriptor": "VertexDescription.Position" +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.PropertyNode", + "m_ObjectId": "2b9c28298dc14a06a9a0754e721d4e2d", + "m_Group": { + "m_Id": "b4df5b2a90e74fea8f802d43a8c09f8b" + }, + "m_Name": "Property", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -2295.000244140625, + "y": -403.9999084472656, + "width": 108.0, + "height": 34.0 + } + }, + "m_Slots": [ + { + "m_Id": "025715d269714389b2bc572d1b32a09a" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_Property": { + "m_Id": "6443d28cbc024921bc6d0f46ee9c2102" + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "2f91c8dd927e46188c7b09345fc36928", + "m_Id": 0, + "m_DisplayName": "In", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "In", + "m_StageCapability": 3, + "m_Value": { + "x": 1.0, + "y": 1.0, + "z": 1.0, + "w": 1.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "308e274fdf574467a0d9d889a9208431", + "m_Id": 2, + "m_DisplayName": "Out", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "353ee8bb1d6543909e1aeca8b54ff8f6", + "m_Id": 1, + "m_DisplayName": "B", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "B", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "35e0961e58b34e47a1304e16475e7563", + "m_Id": 0, + "m_DisplayName": "Expand Lower", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "35f44e6ed349424eb776f3b93f75e55a", + "m_Id": 3, + "m_DisplayName": "Out", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "38eb7c23683a4cc0a261239201702503", + "m_Id": 1, + "m_DisplayName": "Out", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "397e99ff6b06405ebc3aa2aab649ed4f", + "m_Id": 0, + "m_DisplayName": "Edge1", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "Edge1", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.OneMinusNode", + "m_ObjectId": "3a5b826f7b4c43938b639d4ab49776c2", + "m_Group": { + "m_Id": "bb3fb3d46c9240e499693e3571b3e902" + }, + "m_Name": "One Minus", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -4620.0, + "y": -617.0000610351563, + "width": 208.0, + "height": 278.0 + } + }, + "m_Slots": [ + { + "m_Id": "2f91c8dd927e46188c7b09345fc36928" + }, + { + "m_Id": "247cee4d6cfa4edea2e80286d5bce344" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "3a6654d0a7d84a5999316dc192816cdb", + "m_Id": 1, + "m_DisplayName": "Out", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "3a6699ed5e1f42ea85eabd225365e718", + "m_Id": 0, + "m_DisplayName": "Expand Inner", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "3ad05717c37e4e33a97663ba5ba9dea8", + "m_Id": 0, + "m_DisplayName": "Top Curve", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 1, + "m_Type": "UnityEditor.ShaderGraph.Internal.Vector1ShaderProperty", + "m_ObjectId": "3b4543cf814541948b29c37c11d7f65c", + "m_Guid": { + "m_GuidSerialized": "11695d24-24e7-403d-a5b6-6eef08e544c0" + }, + "m_Name": "Occlusion Strength", + "m_DefaultReferenceName": "Vector1_3b4543cf814541948b29c37c11d7f65c", + "m_OverrideReferenceName": "_OcclusionStrength", + "m_GeneratePropertyBlock": true, + "m_Precision": 0, + "overrideHLSLDeclaration": false, + "hlslDeclarationOverride": 0, + "m_Hidden": false, + "m_Value": 0.20000000298023225, + "m_FloatType": 1, + "m_RangeValues": { + "x": 0.0, + "y": 2.0 + } +} + +{ + "m_SGVersion": 1, + "m_Type": "UnityEditor.ShaderGraph.Internal.Vector1ShaderProperty", + "m_ObjectId": "3c5c8cfa6e464d7489bcc7a552c5922c", + "m_Guid": { + "m_GuidSerialized": "986e039e-52b8-436b-be83-d015856f3da1" + }, + "m_Name": "Expand Outward", + "m_DefaultReferenceName": "Vector1_3c5c8cfa6e464d7489bcc7a552c5922c", + "m_OverrideReferenceName": "_ExpandOut", + "m_GeneratePropertyBlock": true, + "m_Precision": 0, + "overrideHLSLDeclaration": false, + "hlslDeclarationOverride": 0, + "m_Hidden": false, + "m_Value": 0.0, + "m_FloatType": 1, + "m_RangeValues": { + "x": -0.0010000000474974514, + "y": 0.0010000000474974514 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.Rendering.HighDefinition.ShaderGraph.BuiltinData", + "m_ObjectId": "3db9538cb77844829582eddc326227b2", + "m_Distortion": false, + "m_DistortionMode": 0, + "m_DistortionDepthTest": true, + "m_AddPrecomputedVelocity": false, + "m_TransparentWritesMotionVec": false, + "m_AlphaToMask": false, + "m_DepthOffset": false, + "m_TransparencyFog": true, + "m_AlphaTestShadow": false, + "m_BackThenFrontRendering": false, + "m_TransparentDepthPrepass": false, + "m_TransparentDepthPostpass": false, + "m_SupportLodCrossFade": false +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.AddNode", + "m_ObjectId": "3defca4cdb924d2fba79c55fd76e2784", + "m_Group": { + "m_Id": "b4df5b2a90e74fea8f802d43a8c09f8b" + }, + "m_Name": "Add", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -1817.0, + "y": -920.0, + "width": 126.00000762939453, + "height": 118.00000762939453 + } + }, + "m_Slots": [ + { + "m_Id": "f684cfd6321046968800ae12100e18c6" + }, + { + "m_Id": "0aa6bfa1b6ea45d4aaea7f324d8940b4" + }, + { + "m_Id": "4950f81ba35848359e2eefdad3a3e308" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.PropertyNode", + "m_ObjectId": "3f18e638ea2c4c6d9fceab51663abdc7", + "m_Group": { + "m_Id": "0bda9324be5243aba9c7b05ef2f00ded" + }, + "m_Name": "Property", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -4534.0, + "y": 940.0, + "width": 160.0, + "height": 34.0 + } + }, + "m_Slots": [ + { + "m_Id": "06315e49bb5a4718a4b0212b4815eac6" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_Property": { + "m_Id": "f4c450cb47804c14b24590dae355002c" + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.PropertyNode", + "m_ObjectId": "40934f7108764b6ea0c2a26cbce734c9", + "m_Group": { + "m_Id": "bb3fb3d46c9240e499693e3571b3e902" + }, + "m_Name": "Property", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -6534.0, + "y": -1147.0, + "width": 126.0, + "height": 34.000003814697269 + } + }, + "m_Slots": [ + { + "m_Id": "c2802b4d1ed5477ebb2e709f3b6a50f7" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_Property": { + "m_Id": "1f1b7cfea51444bf896958c82e525655" + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.PropertyNode", + "m_ObjectId": "40b063e497c341459c7c086cf638a060", + "m_Group": { + "m_Id": "b4df5b2a90e74fea8f802d43a8c09f8b" + }, + "m_Name": "Property", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -2292.000244140625, + "y": -988.0, + "width": 101.0, + "height": 34.0 + } + }, + "m_Slots": [ + { + "m_Id": "3a6699ed5e1f42ea85eabd225365e718" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_Property": { + "m_Id": "9d63cbda932d45ff98889efda5a06c38" + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "411a21496ffd47d9bcd022489f90cb93", + "m_Id": 1, + "m_DisplayName": "Out", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "430d8149083845e2843a208f1cc219d3", + "m_Id": 0, + "m_DisplayName": "", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicValueMaterialSlot", + "m_ObjectId": "438a906760de49aaaf30c2d63185587b", + "m_Id": 1, + "m_DisplayName": "B", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "B", + "m_StageCapability": 3, + "m_Value": { + "e00": 2.0, + "e01": 2.0, + "e02": 2.0, + "e03": 2.0, + "e10": 2.0, + "e11": 2.0, + "e12": 2.0, + "e13": 2.0, + "e20": 2.0, + "e21": 2.0, + "e22": 2.0, + "e23": 2.0, + "e30": 2.0, + "e31": 2.0, + "e32": 2.0, + "e33": 2.0 + }, + "m_DefaultValue": { + "e00": 1.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 1.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 1.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.RedirectNodeData", + "m_ObjectId": "441e86e7628f4579801f1111a03800a2", + "m_Group": { + "m_Id": "0bda9324be5243aba9c7b05ef2f00ded" + }, + "m_Name": "Redirect Node", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -4118.00048828125, + "y": 987.0, + "width": 56.000003814697269, + "height": 24.000001907348634 + } + }, + "m_Slots": [ + { + "m_Id": "8fdc41a1ed6d4302b82b3c95c0218504" + }, + { + "m_Id": "26119b1e9b83423b987970fc75effc92" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.SmoothstepNode", + "m_ObjectId": "44362990242f4102a045c894da5631cf", + "m_Group": { + "m_Id": "bb3fb3d46c9240e499693e3571b3e902" + }, + "m_Name": "Smoothstep", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -6278.0, + "y": -835.0, + "width": 208.0, + "height": 326.0000305175781 + } + }, + "m_Slots": [ + { + "m_Id": "faa31ea642e94bbd866d7d274cfe0ecd" + }, + { + "m_Id": "5834593a8ada4b2fa2d469e6e2532d62" + }, + { + "m_Id": "ba1dd963f914499b8494ad276a6a1c4b" + }, + { + "m_Id": "01325722aef24833a50c42c536770a36" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.PropertyNode", + "m_ObjectId": "44903d0f5f2f43c183b7653670f708cf", + "m_Group": { + "m_Id": "bb3fb3d46c9240e499693e3571b3e902" + }, + "m_Name": "Property", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -6500.0, + "y": -144.0, + "width": 119.00000762939453, + "height": 34.0 + } + }, + "m_Slots": [ + { + "m_Id": "61e92eff644a42d3b1e156939ff6c53f" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_Property": { + "m_Id": "c530dc7dbef64ff88f5faaec8d3aeb70" + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.AddNode", + "m_ObjectId": "45127aa896fd4e1b83cfdeee010dcf3e", + "m_Group": { + "m_Id": "b4df5b2a90e74fea8f802d43a8c09f8b" + }, + "m_Name": "Add", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -1499.0, + "y": -643.0, + "width": 126.00000762939453, + "height": 118.00000762939453 + } + }, + "m_Slots": [ + { + "m_Id": "1d711b75f4154318a5fb791fb04f2017" + }, + { + "m_Id": "e2e320b532b343a2b345dcce6b6ca057" + }, + { + "m_Id": "89f91b700e2b46629637f2fe7a52ba45" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicValueMaterialSlot", + "m_ObjectId": "480b45a8a9c14d34bd58e8370f02276e", + "m_Id": 2, + "m_DisplayName": "Out", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": { + "e00": 0.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 0.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 0.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 0.0 + }, + "m_DefaultValue": { + "e00": 1.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 1.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 1.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "4879e075e449485daffefdad5cb24d7d", + "m_Id": 1, + "m_DisplayName": "Edge2", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "Edge2", + "m_StageCapability": 3, + "m_Value": { + "x": 1.0, + "y": 1.0, + "z": 1.0, + "w": 1.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "4950f81ba35848359e2eefdad3a3e308", + "m_Id": 2, + "m_DisplayName": "Out", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "4a9a82308d804ffab9018066cf716762", + "m_Id": 1, + "m_DisplayName": "", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.RedirectNodeData", + "m_ObjectId": "4baacdf7cc65416b80f9b20bd797c289", + "m_Group": { + "m_Id": "0bda9324be5243aba9c7b05ef2f00ded" + }, + "m_Name": "Redirect Node", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -4725.00048828125, + "y": 987.0, + "width": 56.000003814697269, + "height": 24.000001907348634 + } + }, + "m_Slots": [ + { + "m_Id": "7f77f39fe7eb418788d429f1e2f636c5" + }, + { + "m_Id": "724de480d4d6429c96bbe52855051e34" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "4bfcdced578a4412a7da40df467800ad", + "m_Id": 1, + "m_DisplayName": "Out", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.AddNode", + "m_ObjectId": "4cdc570f6ada484ebeda0d4e7b408ad0", + "m_Group": { + "m_Id": "b4df5b2a90e74fea8f802d43a8c09f8b" + }, + "m_Name": "Add", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -1227.0, + "y": -369.9999084472656, + "width": 126.00000762939453, + "height": 118.00000762939453 + } + }, + "m_Slots": [ + { + "m_Id": "8760247084e04d55b954e42de386ae6c" + }, + { + "m_Id": "da6bd2aec3fc49ad95ac557950c2e3ac" + }, + { + "m_Id": "72916418c63c4dc0935a879ca8edfc26" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.UVNode", + "m_ObjectId": "4dec4ff124dd41cfb4722ae7a5ec21c1", + "m_Group": { + "m_Id": "b4df5b2a90e74fea8f802d43a8c09f8b" + }, + "m_Name": "UV", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -3294.000244140625, + "y": -584.0, + "width": 145.0, + "height": 130.0 + } + }, + "m_Slots": [ + { + "m_Id": "e506546e9df6439eafbf8afe832616ca" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_OutputChannel": 0 +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.PropertyNode", + "m_ObjectId": "4e5f91e4ca854626b423d1f238680464", + "m_Group": { + "m_Id": "bb3fb3d46c9240e499693e3571b3e902" + }, + "m_Name": "Property", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -6052.0, + "y": -420.0, + "width": 148.0, + "height": 34.0 + } + }, + "m_Slots": [ + { + "m_Id": "6adf52aed9e84743af958d20f22e3fed" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_Property": { + "m_Id": "d212ea7404ac470d8fb7e0b25f74c18e" + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.MultiplyNode", + "m_ObjectId": "4eda52cace9043a38dfcb433aaa088b9", + "m_Group": { + "m_Id": "bb3fb3d46c9240e499693e3571b3e902" + }, + "m_Name": "Multiply", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -4344.0, + "y": -466.0000915527344, + "width": 126.0, + "height": 118.0 + } + }, + "m_Slots": [ + { + "m_Id": "b6c15f0dd0a741388c014bf93f2c816a" + }, + { + "m_Id": "9acd6c72d3274ad1b747d98a00003b1e" + }, + { + "m_Id": "08e714c99a1f4644bf2ffa5816a52dff" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicValueMaterialSlot", + "m_ObjectId": "50a93afdfd7e42f79719c1039508358b", + "m_Id": 0, + "m_DisplayName": "A", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "A", + "m_StageCapability": 3, + "m_Value": { + "e00": 0.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 0.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 0.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 0.0 + }, + "m_DefaultValue": { + "e00": 1.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 1.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 1.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.Rendering.HighDefinition.ShaderGraph.HDTarget", + "m_ObjectId": "524b537aa1c147b98f6d8296cc97cf5d", + "m_ActiveSubTarget": { + "m_Id": "97edb8a79d314e8e9598cad34869684f" + }, + "m_Datas": [ + { + "m_Id": "3db9538cb77844829582eddc326227b2" + }, + { + "m_Id": "cd095f47ff5044e09409c402568d61d1" + }, + { + "m_Id": "017597816b1d4ca480b6f999b23798f7" + } + ], + "m_CustomEditorGUI": "" +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.MultiplyNode", + "m_ObjectId": "5382dabaf66f42bbbbce0ad31d602c81", + "m_Group": { + "m_Id": "0bda9324be5243aba9c7b05ef2f00ded" + }, + "m_Name": "Multiply", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -4346.00048828125, + "y": 869.0, + "width": 126.0, + "height": 118.0 + } + }, + "m_Slots": [ + { + "m_Id": "16468c50b06f4e7d8d18eb3297127f61" + }, + { + "m_Id": "c03abd73db0b4da59628e1c0ab59d4e4" + }, + { + "m_Id": "a07de5c3f8304cd7ab0bb06889f84733" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.PropertyNode", + "m_ObjectId": "543e3f76dfe745fca9462a84fc6d245e", + "m_Group": { + "m_Id": "b4df5b2a90e74fea8f802d43a8c09f8b" + }, + "m_Name": "Property", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -2295.000244140625, + "y": -681.9999389648438, + "width": 104.00000762939453, + "height": 34.0 + } + }, + "m_Slots": [ + { + "m_Id": "881becfd4fd44c389c76f42e34b2659b" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_Property": { + "m_Id": "266fa5d358b4417ba68d60503300acd5" + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "544bfaba00b4447a806021f65a672962", + "m_Id": 0, + "m_DisplayName": "Bottom Max", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicValueMaterialSlot", + "m_ObjectId": "5492411f859f437c9c9d33ab3c7af3fe", + "m_Id": 2, + "m_DisplayName": "Out", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": { + "e00": 0.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 0.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 0.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 0.0 + }, + "m_DefaultValue": { + "e00": 1.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 1.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 1.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.UVNode", + "m_ObjectId": "54aef52304b343b5878d3abe3ac44e80", + "m_Group": { + "m_Id": "bb3fb3d46c9240e499693e3571b3e902" + }, + "m_Name": "UV", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -7712.99951171875, + "y": 9.000065803527832, + "width": 145.0, + "height": 130.0 + } + }, + "m_Slots": [ + { + "m_Id": "e77fe4d8036f480398f270e7cea20a2a" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_OutputChannel": 0 +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "54fe081fc97d4c3fae94da5b30d50350", + "m_Id": 2, + "m_DisplayName": "In", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "In", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.RedirectNodeData", + "m_ObjectId": "57be4831af9844c093bf59542287b3e4", + "m_Group": { + "m_Id": "bb3fb3d46c9240e499693e3571b3e902" + }, + "m_Name": "Redirect Node", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -6945.0, + "y": 88.00000762939453, + "width": 56.000003814697269, + "height": 24.000001907348634 + } + }, + "m_Slots": [ + { + "m_Id": "641f3a78d22a45a8a67f75d4f715f4d4" + }, + { + "m_Id": "88145c6189074ce99833f83085ff58e4" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "5834593a8ada4b2fa2d469e6e2532d62", + "m_Id": 1, + "m_DisplayName": "Edge2", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "Edge2", + "m_StageCapability": 3, + "m_Value": { + "x": 1.0, + "y": 1.0, + "z": 1.0, + "w": 1.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicValueMaterialSlot", + "m_ObjectId": "5a141b0ebcab4787a3c7554797acbc0f", + "m_Id": 0, + "m_DisplayName": "A", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "A", + "m_StageCapability": 3, + "m_Value": { + "e00": 0.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 0.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 0.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 0.0 + }, + "m_DefaultValue": { + "e00": 1.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 1.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 1.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.PropertyNode", + "m_ObjectId": "5ad58c4b717741a48fa105d8432ce3f2", + "m_Group": { + "m_Id": "0bda9324be5243aba9c7b05ef2f00ded" + }, + "m_Name": "Property", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -4706.00048828125, + "y": 768.0, + "width": 172.0, + "height": 34.0 + } + }, + "m_Slots": [ + { + "m_Id": "de5d34d01a804146a0ecba23241b4291" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_Property": { + "m_Id": "bcd952383b8d4fe0af79e073853c8be7" + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "5b542458b15144d2b9b5b9b9983174e4", + "m_Id": 1, + "m_DisplayName": "Out", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "5c960d505db748dbbdde9c3f60585761", + "m_Id": 0, + "m_DisplayName": "Top 2 Min", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicValueMaterialSlot", + "m_ObjectId": "5cc4f3718efe45ab8ccc9ca94bf1a9b6", + "m_Id": 1, + "m_DisplayName": "B", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "B", + "m_StageCapability": 3, + "m_Value": { + "e00": 2.0, + "e01": 2.0, + "e02": 2.0, + "e03": 2.0, + "e10": 2.0, + "e11": 2.0, + "e12": 2.0, + "e13": 2.0, + "e20": 2.0, + "e21": 2.0, + "e22": 2.0, + "e23": 2.0, + "e30": 2.0, + "e31": 2.0, + "e32": 2.0, + "e33": 2.0 + }, + "m_DefaultValue": { + "e00": 1.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 1.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 1.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.PropertyNode", + "m_ObjectId": "5e800f943e0b4021a7929b6214afa644", + "m_Group": { + "m_Id": "bb3fb3d46c9240e499693e3571b3e902" + }, + "m_Name": "Property", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -6484.0, + "y": -852.0000610351563, + "width": 129.0, + "height": 34.000003814697269 + } + }, + "m_Slots": [ + { + "m_Id": "76fac917019e480f89d6c693840d2106" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_Property": { + "m_Id": "ba712075273f4fa1b806cc19118186a7" + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "5f34f87b15084e7896e3304f861bb583", + "m_Id": 2, + "m_DisplayName": "In", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "In", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.RedirectNodeData", + "m_ObjectId": "60ca34a12471430e9bb9936532a28fe1", + "m_Group": { + "m_Id": "b0dc17fd9b744813b0d3cfe2bafd9cc5" + }, + "m_Name": "Redirect Node", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -787.999755859375, + "y": -323.0000305175781, + "width": 56.0, + "height": 23.999998092651368 + } + }, + "m_Slots": [ + { + "m_Id": "430d8149083845e2843a208f1cc219d3" + }, + { + "m_Id": "8b3c92c479514b1fbdc26e0bb6353dc9" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "61e92eff644a42d3b1e156939ff6c53f", + "m_Id": 0, + "m_DisplayName": "Top Min", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.PropertyNode", + "m_ObjectId": "6391b4c87f124a7db1ce66d39069c97e", + "m_Group": { + "m_Id": "bb3fb3d46c9240e499693e3571b3e902" + }, + "m_Name": "Property", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -6534.0, + "y": -461.0000305175781, + "width": 140.0, + "height": 34.000003814697269 + } + }, + "m_Slots": [ + { + "m_Id": "544bfaba00b4447a806021f65a672962" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_Property": { + "m_Id": "dd54da0252e94dd6a1f7e2f67ac4e5d3" + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "640e7709aac2433095ae84d95c451376", + "m_Id": 2, + "m_DisplayName": "In", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "In", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "641f3a78d22a45a8a67f75d4f715f4d4", + "m_Id": 0, + "m_DisplayName": "", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 1, + "m_Type": "UnityEditor.ShaderGraph.Internal.Vector1ShaderProperty", + "m_ObjectId": "6443d28cbc024921bc6d0f46ee9c2102", + "m_Guid": { + "m_GuidSerialized": "e8c80ed7-076a-4019-8b5f-47564ff94790" + }, + "m_Name": "Expand Upper", + "m_DefaultReferenceName": "", + "m_OverrideReferenceName": "_ExpandUpper", + "m_GeneratePropertyBlock": true, + "m_Precision": 0, + "overrideHLSLDeclaration": false, + "hlslDeclarationOverride": 0, + "m_Hidden": false, + "m_Value": 0.0, + "m_FloatType": 1, + "m_RangeValues": { + "x": -0.0010000000474974514, + "y": 0.0010000000474974514 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "64da932b85b441a2bff9e05fcc44bd8f", + "m_Id": 0, + "m_DisplayName": "Alpha", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "Alpha", + "m_StageCapability": 2, + "m_Value": 1.0, + "m_DefaultValue": 1.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicValueMaterialSlot", + "m_ObjectId": "6535457859774692aacdf83757840fb4", + "m_Id": 0, + "m_DisplayName": "A", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "A", + "m_StageCapability": 3, + "m_Value": { + "e00": 0.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 0.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 0.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 0.0 + }, + "m_DefaultValue": { + "e00": 1.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 1.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 1.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 1.0 + } +} + +{ + "m_SGVersion": 1, + "m_Type": "UnityEditor.ShaderGraph.Internal.Vector1ShaderProperty", + "m_ObjectId": "65471bb49b7c449ba4b520bb17362d4a", + "m_Guid": { + "m_GuidSerialized": "94a10990-9f0d-4736-8c90-9766f22eab57" + }, + "m_Name": "Occlusion Power", + "m_DefaultReferenceName": "", + "m_OverrideReferenceName": "_OcclusionPower", + "m_GeneratePropertyBlock": true, + "m_Precision": 0, + "overrideHLSLDeclaration": false, + "hlslDeclarationOverride": 0, + "m_Hidden": false, + "m_Value": 1.5, + "m_FloatType": 1, + "m_RangeValues": { + "x": 0.10000000149011612, + "y": 4.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "65a7ce14a34048d8aee7b6bcf923092a", + "m_Id": 0, + "m_DisplayName": "Top 2 Max", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "667078abac6b472d9c34971fcdf005b9", + "m_Id": 2, + "m_DisplayName": "In", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "In", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "6825a951f7b6466d91ecbb98d70bffa9", + "m_Id": 0, + "m_DisplayName": "Bottom Min", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "6875cb582a3c49aeb2ad2c25ef0bfdd4", + "m_Id": 0, + "m_DisplayName": "In", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "In", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "6adf52aed9e84743af958d20f22e3fed", + "m_Id": 0, + "m_DisplayName": "Bottom Curve", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.PropertyNode", + "m_ObjectId": "6aeb789dd1694c07a16cb598fd712e52", + "m_Group": { + "m_Id": "bb3fb3d46c9240e499693e3571b3e902" + }, + "m_Name": "Property", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -5876.0, + "y": 578.9999389648438, + "width": 185.00001525878907, + "height": 34.000003814697269 + } + }, + "m_Slots": [ + { + "m_Id": "93b5e5c95306437bad201603441841eb" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_Property": { + "m_Id": "290491e5ea18432bbfab7f17daf6f5d5" + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.AddNode", + "m_ObjectId": "6d360fc91efd4575acf35e944c49ea92", + "m_Group": { + "m_Id": "0bda9324be5243aba9c7b05ef2f00ded" + }, + "m_Name": "Add", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -4188.00048828125, + "y": 810.0, + "width": 126.0, + "height": 118.0 + } + }, + "m_Slots": [ + { + "m_Id": "e2cc1440bbbb457c9e73f5ccc9ee3ce8" + }, + { + "m_Id": "353ee8bb1d6543909e1aeca8b54ff8f6" + }, + { + "m_Id": "07b9cacb9b23468b9eb942369ab0dd27" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "6d711b5fee3a476e82d8288a6439904f", + "m_Id": 1, + "m_DisplayName": "R", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "R", + "m_StageCapability": 3, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicValueMaterialSlot", + "m_ObjectId": "70eb0c7c9d144afebe291ea6b19c0826", + "m_Id": 1, + "m_DisplayName": "B", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "B", + "m_StageCapability": 3, + "m_Value": { + "e00": 2.0, + "e01": 2.0, + "e02": 2.0, + "e03": 2.0, + "e10": 2.0, + "e11": 2.0, + "e12": 2.0, + "e13": 2.0, + "e20": 2.0, + "e21": 2.0, + "e22": 2.0, + "e23": 2.0, + "e30": 2.0, + "e31": 2.0, + "e32": 2.0, + "e33": 2.0 + }, + "m_DefaultValue": { + "e00": 1.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 1.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 1.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "724de480d4d6429c96bbe52855051e34", + "m_Id": 1, + "m_DisplayName": "", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "72916418c63c4dc0935a879ca8edfc26", + "m_Id": 2, + "m_DisplayName": "Out", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "745f46dae5c04ee493751d995bfa2880", + "m_Id": 0, + "m_DisplayName": "In", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "In", + "m_StageCapability": 3, + "m_Value": { + "x": 1.0, + "y": 1.0, + "z": 1.0, + "w": 1.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.OneMinusNode", + "m_ObjectId": "746698fd63c14464af64e794b5fd21a4", + "m_Group": { + "m_Id": "b4df5b2a90e74fea8f802d43a8c09f8b" + }, + "m_Name": "One Minus", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -2710.000244140625, + "y": -180.99998474121095, + "width": 208.00001525878907, + "height": 278.0 + } + }, + "m_Slots": [ + { + "m_Id": "89ff68f9c3af45f7bf3a87627a6de286" + }, + { + "m_Id": "d7eefb11caf34fa2b8e7022325c65f50" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.RedirectNodeData", + "m_ObjectId": "74eb110adc4143f9a5ee6c6053eee5ef", + "m_Group": { + "m_Id": "bb3fb3d46c9240e499693e3571b3e902" + }, + "m_Name": "Redirect Node", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -6562.0, + "y": -402.99993896484377, + "width": 56.000003814697269, + "height": 24.0 + } + }, + "m_Slots": [ + { + "m_Id": "8cd15079a1bc412eafc67ea146c829e5" + }, + { + "m_Id": "d98d8cd72101478b8c0bd71f3ad0ed66" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.OneMinusNode", + "m_ObjectId": "76e9db94bc4549ccb86b4375bef90585", + "m_Group": { + "m_Id": "b4df5b2a90e74fea8f802d43a8c09f8b" + }, + "m_Name": "One Minus", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -2710.000244140625, + "y": -765.9999389648438, + "width": 208.00001525878907, + "height": 278.0 + } + }, + "m_Slots": [ + { + "m_Id": "0959694a26f345a998f9e697aa408421" + }, + { + "m_Id": "411a21496ffd47d9bcd022489f90cb93" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "76fac917019e480f89d6c693840d2106", + "m_Id": 0, + "m_DisplayName": "Outer Max", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "76ffca67ef58488c99e3bb61bbb16e13", + "m_Id": 1, + "m_DisplayName": "B", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "B", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "778c121c491d4910bbbd52cb77493747", + "m_Id": 4, + "m_DisplayName": "A", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "A", + "m_StageCapability": 3, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.OneMinusNode", + "m_ObjectId": "78b78883418c4457b4ff45cf3e5f9e1b", + "m_Group": { + "m_Id": "bb3fb3d46c9240e499693e3571b3e902" + }, + "m_Name": "One Minus", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -6509.0, + "y": 44.99999237060547, + "width": 128.0, + "height": 94.0 + } + }, + "m_Slots": [ + { + "m_Id": "068c8df0359a4bee80aa8249b915278f" + }, + { + "m_Id": "3a6654d0a7d84a5999316dc192816cdb" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.PropertyNode", + "m_ObjectId": "7b4e326f0c4343d5952c2e703103f28b", + "m_Group": { + "m_Id": "bb3fb3d46c9240e499693e3571b3e902" + }, + "m_Name": "Property", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -6202.0, + "y": 279.99993896484377, + "width": 132.0, + "height": 34.000003814697269 + } + }, + "m_Slots": [ + { + "m_Id": "65a7ce14a34048d8aee7b6bcf923092a" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_Property": { + "m_Id": "065243026f14459abdbaef4137a89d8a" + } +} + +{ + "m_SGVersion": 1, + "m_Type": "UnityEditor.ShaderGraph.Internal.Vector1ShaderProperty", + "m_ObjectId": "7bc08229a45c46be902bb162fca67728", + "m_Guid": { + "m_GuidSerialized": "a587b93b-6893-4b29-8213-002ac0ab35da" + }, + "m_Name": "Outer Min", + "m_DefaultReferenceName": "", + "m_OverrideReferenceName": "_OuterMin", + "m_GeneratePropertyBlock": true, + "m_Precision": 0, + "overrideHLSLDeclaration": false, + "hlslDeclarationOverride": 0, + "m_Hidden": false, + "m_Value": 0.20000000298023225, + "m_FloatType": 1, + "m_RangeValues": { + "x": 0.0, + "y": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.BlockNode", + "m_ObjectId": "7cdec5e4eb1649ea8fa61a2f0e4a1d22", + "m_Group": { + "m_Id": "" + }, + "m_Name": "SurfaceDescription.Emission", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": 0.0, + "y": 0.0, + "width": 0.0, + "height": 0.0 + } + }, + "m_Slots": [ + { + "m_Id": "fb6ca1a014e64d79bbba8f84f8ccb6d5" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_SerializedDescriptor": "SurfaceDescription.Emission" +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.MaximumNode", + "m_ObjectId": "7ea050afc45244458bc53e4dc518f59f", + "m_Group": { + "m_Id": "bb3fb3d46c9240e499693e3571b3e902" + }, + "m_Name": "Maximum", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -3864.0, + "y": -143.99998474121095, + "width": 208.0, + "height": 302.0 + } + }, + "m_Slots": [ + { + "m_Id": "a6dcfbcf619145b79a41ab8962316327" + }, + { + "m_Id": "d99e4a9d3e314e1f9b15d1e9327df59f" + }, + { + "m_Id": "8fa23617d6e6421181719e1294f0812e" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "7f77f39fe7eb418788d429f1e2f636c5", + "m_Id": 0, + "m_DisplayName": "", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector3MaterialSlot", + "m_ObjectId": "800a75e3b71e420a9b875e7df50af764", + "m_Id": 0, + "m_DisplayName": "Out", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0 + }, + "m_Labels": [] +} + +{ + "m_SGVersion": 1, + "m_Type": "UnityEditor.ShaderGraph.Internal.Vector1ShaderProperty", + "m_ObjectId": "801dfebd26864a04b4834d8136ab2f4e", + "m_Guid": { + "m_GuidSerialized": "ed82dd7c-a48b-427d-976c-760b1c1e6d12" + }, + "m_Name": "inner Min", + "m_DefaultReferenceName": "", + "m_OverrideReferenceName": "_InnerMin", + "m_GeneratePropertyBlock": true, + "m_Precision": 0, + "overrideHLSLDeclaration": false, + "hlslDeclarationOverride": 0, + "m_Hidden": false, + "m_Value": 0.25, + "m_FloatType": 1, + "m_RangeValues": { + "x": 0.0, + "y": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "8151b70abdef4fda936fc0d9c9cf854a", + "m_Id": 0, + "m_DisplayName": "Top Max", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "831da0d7c3804d74959a627cf863e488", + "m_Id": 1, + "m_DisplayName": "Edge2", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "Edge2", + "m_StageCapability": 3, + "m_Value": { + "x": 1.0, + "y": 1.0, + "z": 1.0, + "w": 1.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "8760247084e04d55b954e42de386ae6c", + "m_Id": 0, + "m_DisplayName": "A", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "A", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "88145c6189074ce99833f83085ff58e4", + "m_Id": 1, + "m_DisplayName": "", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "881becfd4fd44c389c76f42e34b2659b", + "m_Id": 0, + "m_DisplayName": "Expand Outer", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "883183c2957240daab15ac73ec426ab3", + "m_Id": 3, + "m_DisplayName": "B", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "B", + "m_StageCapability": 3, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "89218f48e9fc41f58dccb4cb2044d541", + "m_Id": 0, + "m_DisplayName": "", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicValueMaterialSlot", + "m_ObjectId": "895cca255be24cf29a3be7ac6eedca31", + "m_Id": 1, + "m_DisplayName": "B", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "B", + "m_StageCapability": 3, + "m_Value": { + "e00": 2.0, + "e01": 2.0, + "e02": 2.0, + "e03": 2.0, + "e10": 2.0, + "e11": 2.0, + "e12": 2.0, + "e13": 2.0, + "e20": 2.0, + "e21": 2.0, + "e22": 2.0, + "e23": 2.0, + "e30": 2.0, + "e31": 2.0, + "e32": 2.0, + "e33": 2.0 + }, + "m_DefaultValue": { + "e00": 1.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 1.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 1.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "89f91b700e2b46629637f2fe7a52ba45", + "m_Id": 2, + "m_DisplayName": "Out", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "89ff68f9c3af45f7bf3a87627a6de286", + "m_Id": 0, + "m_DisplayName": "In", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "In", + "m_StageCapability": 3, + "m_Value": { + "x": 1.0, + "y": 1.0, + "z": 1.0, + "w": 1.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.MultiplyNode", + "m_ObjectId": "8b0b26b61cad41c2868fb6dda828d531", + "m_Group": { + "m_Id": "b4df5b2a90e74fea8f802d43a8c09f8b" + }, + "m_Name": "Multiply", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -2143.0, + "y": -180.99998474121095, + "width": 126.00000762939453, + "height": 118.00000762939453 + } + }, + "m_Slots": [ + { + "m_Id": "6535457859774692aacdf83757840fb4" + }, + { + "m_Id": "c17008c6bd2746d3aff735bcf194834e" + }, + { + "m_Id": "f55702e69fe6422db241f04b73b2f8fe" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "8b3c92c479514b1fbdc26e0bb6353dc9", + "m_Id": 1, + "m_DisplayName": "", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.MultiplyNode", + "m_ObjectId": "8bb229fa2e8d462fa69dae3605318197", + "m_Group": { + "m_Id": "b4df5b2a90e74fea8f802d43a8c09f8b" + }, + "m_Name": "Multiply", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -2143.0, + "y": -765.9999389648438, + "width": 126.00000762939453, + "height": 118.00000762939453 + } + }, + "m_Slots": [ + { + "m_Id": "12bb558652c74b3ab655b04fc0dec653" + }, + { + "m_Id": "5cc4f3718efe45ab8ccc9ca94bf1a9b6" + }, + { + "m_Id": "e433a9c444b640dea68ac7f83ba7e24d" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "8cd15079a1bc412eafc67ea146c829e5", + "m_Id": 0, + "m_DisplayName": "", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.SmoothstepNode", + "m_ObjectId": "8cf1d5529cb145a8aa9387117538ccbd", + "m_Group": { + "m_Id": "bb3fb3d46c9240e499693e3571b3e902" + }, + "m_Name": "Smoothstep", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -6278.0, + "y": -501.9999694824219, + "width": 208.0, + "height": 326.0000305175781 + } + }, + "m_Slots": [ + { + "m_Id": "1fd72b34c59349b1928a26149cfeffae" + }, + { + "m_Id": "b059854fe00b445983b21407550ff234" + }, + { + "m_Id": "667078abac6b472d9c34971fcdf005b9" + }, + { + "m_Id": "ac7e1d4733224b938f2237fa96812242" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "8de9225e19194f959a9b6104d22dcec8", + "m_Id": 0, + "m_DisplayName": "inner Min", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "8f2ee7484dd44a5b8340437652ba9c50", + "m_Id": 1, + "m_DisplayName": "Out", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "8fa23617d6e6421181719e1294f0812e", + "m_Id": 2, + "m_DisplayName": "Out", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "8fdc41a1ed6d4302b82b3c95c0218504", + "m_Id": 0, + "m_DisplayName": "", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "918706adaa944c508876a310d7944745", + "m_Id": 0, + "m_DisplayName": "Occlusion Strength", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "91898770038a4c9ca244c11883936fb0", + "m_Id": 0, + "m_DisplayName": "A", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "A", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.MultiplyNode", + "m_ObjectId": "91da4058677840c6b12a925b10033143", + "m_Group": { + "m_Id": "b4df5b2a90e74fea8f802d43a8c09f8b" + }, + "m_Name": "Multiply", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -2143.0, + "y": -487.9999694824219, + "width": 126.00000762939453, + "height": 118.00000762939453 + } + }, + "m_Slots": [ + { + "m_Id": "50a93afdfd7e42f79719c1039508358b" + }, + { + "m_Id": "212af8d89c6544d0a4dc52b249d92d48" + }, + { + "m_Id": "d5558c96962a45fda7fdf40869a247fc" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.BlockNode", + "m_ObjectId": "92cc80251fd64e0fbb5ee01393ce9ec4", + "m_Group": { + "m_Id": "" + }, + "m_Name": "VertexDescription.Normal", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": 0.0, + "y": 0.0, + "width": 0.0, + "height": 0.0 + } + }, + "m_Slots": [ + { + "m_Id": "0904b4e2e2af45338adfccb48136581c" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_SerializedDescriptor": "VertexDescription.Normal" +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "93b5e5c95306437bad201603441841eb", + "m_Id": 0, + "m_DisplayName": "Occlusion Strength 2", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "9592bd7eb63940599fec8c1c4ed8d7e5", + "m_Id": 0, + "m_DisplayName": "Expand Outward", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicValueMaterialSlot", + "m_ObjectId": "95cb1dbdb64941b5b08cb73233e62fe0", + "m_Id": 0, + "m_DisplayName": "A", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "A", + "m_StageCapability": 3, + "m_Value": { + "e00": 0.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 0.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 0.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 0.0 + }, + "m_DefaultValue": { + "e00": 1.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 1.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 1.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.MultiplyNode", + "m_ObjectId": "973949d9bbe34e27a3b4d319f04baa71", + "m_Group": { + "m_Id": "bb3fb3d46c9240e499693e3571b3e902" + }, + "m_Name": "Multiply", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -5614.0, + "y": -339.00006103515627, + "width": 208.0, + "height": 302.0 + } + }, + "m_Slots": [ + { + "m_Id": "a265b4ad92a74a8ab5e82cd0d304d7b3" + }, + { + "m_Id": "70eb0c7c9d144afebe291ea6b19c0826" + }, + { + "m_Id": "ba43b6747f4c41e3adce6e2da4e3ac90" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.Rendering.HighDefinition.ShaderGraph.HDUnlitSubTarget", + "m_ObjectId": "97edb8a79d314e8e9598cad34869684f" +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "980157ddb0954c939e831d7fadecabcd", + "m_Id": 2, + "m_DisplayName": "Out", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "9809211060c749c4b9b2b2889abcc80a", + "m_Id": 1, + "m_DisplayName": "B", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "B", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "982e94daa6fd478894f4f791d59d2bf1", + "m_Id": 0, + "m_DisplayName": "", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "9917301b74a248f1a0b80c55e7edef74", + "m_Id": 0, + "m_DisplayName": "Edge1", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "Edge1", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.AddNode", + "m_ObjectId": "99bf0686a8d444adbb3b8ed9ca11a33f", + "m_Group": { + "m_Id": "b4df5b2a90e74fea8f802d43a8c09f8b" + }, + "m_Name": "Add", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -2710.000244140625, + "y": -1072.0, + "width": 208.00001525878907, + "height": 302.0000305175781 + } + }, + "m_Slots": [ + { + "m_Id": "c2b7d105f8a740a99bddcd04de15eff6" + }, + { + "m_Id": "ad565fc369a4453dbc63b8c91397f0db" + }, + { + "m_Id": "1a3dd9f7b0504faa87c3e2bd7f79014f" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicValueMaterialSlot", + "m_ObjectId": "9acd6c72d3274ad1b747d98a00003b1e", + "m_Id": 1, + "m_DisplayName": "B", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "B", + "m_StageCapability": 3, + "m_Value": { + "e00": 2.0, + "e01": 2.0, + "e02": 2.0, + "e03": 2.0, + "e10": 2.0, + "e11": 2.0, + "e12": 2.0, + "e13": 2.0, + "e20": 2.0, + "e21": 2.0, + "e22": 2.0, + "e23": 2.0, + "e30": 2.0, + "e31": 2.0, + "e32": 2.0, + "e33": 2.0 + }, + "m_DefaultValue": { + "e00": 1.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 1.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 1.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.PowerNode", + "m_ObjectId": "9d09fa7384444049b4b62c28c48bff43", + "m_Group": { + "m_Id": "bb3fb3d46c9240e499693e3571b3e902" + }, + "m_Name": "Power", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -5899.0, + "y": -515.0000610351563, + "width": 208.0, + "height": 302.0 + } + }, + "m_Slots": [ + { + "m_Id": "e62699515699496f8be6c469a6ee6166" + }, + { + "m_Id": "ee8dff5ed61a4b78937cf5ad03d487e0" + }, + { + "m_Id": "980157ddb0954c939e831d7fadecabcd" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 1, + "m_Type": "UnityEditor.ShaderGraph.Internal.Vector1ShaderProperty", + "m_ObjectId": "9d63cbda932d45ff98889efda5a06c38", + "m_Guid": { + "m_GuidSerialized": "c5602d12-4cdc-41ac-97e6-3f50ef18c3f0" + }, + "m_Name": "Expand Inner", + "m_DefaultReferenceName": "", + "m_OverrideReferenceName": "_ExpandInner", + "m_GeneratePropertyBlock": true, + "m_Precision": 0, + "overrideHLSLDeclaration": false, + "hlslDeclarationOverride": 0, + "m_Hidden": false, + "m_Value": 0.0003000000142492354, + "m_FloatType": 1, + "m_RangeValues": { + "x": -0.0010000000474974514, + "y": 0.0010000000474974514 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.MultiplyNode", + "m_ObjectId": "9d7651f674a34929a89bfa45eea65cd6", + "m_Group": { + "m_Id": "b0dc17fd9b744813b0d3cfe2bafd9cc5" + }, + "m_Name": "Multiply", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -623.0, + "y": -486.0, + "width": 130.0, + "height": 118.0 + } + }, + "m_Slots": [ + { + "m_Id": "95cb1dbdb64941b5b08cb73233e62fe0" + }, + { + "m_Id": "d15a848ac85f4863b5ed4de006c537d3" + }, + { + "m_Id": "e1a26577b8104a598b18bcca2a5df82d" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "9daa98284e2e4f0689b4a202bbf65f3b", + "m_Id": 2, + "m_DisplayName": "Out", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.SplitNode", + "m_ObjectId": "9de05ac86e15482d9b4ec02fee6fa46f", + "m_Group": { + "m_Id": "bb3fb3d46c9240e499693e3571b3e902" + }, + "m_Name": "Split", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -7518.99951171875, + "y": 9.000065803527832, + "width": 120.0, + "height": 149.0 + } + }, + "m_Slots": [ + { + "m_Id": "0790a7e02d5e42e4bef6d7349e41e1dc" + }, + { + "m_Id": "b01656cf6a9344648a3d5ce3b6f0ab87" + }, + { + "m_Id": "ea927058cb774ec4966146b951890498" + }, + { + "m_Id": "15499d5dcf724e8fa59aa431d0a7c5e7" + }, + { + "m_Id": "df25e2c94b0f41918bbc3c6b457490a4" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicValueMaterialSlot", + "m_ObjectId": "9e9d3ade79584b2f85e25c7602405817", + "m_Id": 0, + "m_DisplayName": "A", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "A", + "m_StageCapability": 3, + "m_Value": { + "e00": 0.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 0.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 0.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 0.0 + }, + "m_DefaultValue": { + "e00": 1.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 1.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 1.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicValueMaterialSlot", + "m_ObjectId": "a07de5c3f8304cd7ab0bb06889f84733", + "m_Id": 2, + "m_DisplayName": "Out", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": { + "e00": 0.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 0.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 0.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 0.0 + }, + "m_DefaultValue": { + "e00": 1.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 1.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 1.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicValueMaterialSlot", + "m_ObjectId": "a265b4ad92a74a8ab5e82cd0d304d7b3", + "m_Id": 0, + "m_DisplayName": "A", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "A", + "m_StageCapability": 3, + "m_Value": { + "e00": 0.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 0.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 0.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 0.0 + }, + "m_DefaultValue": { + "e00": 1.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 1.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 1.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.PropertyNode", + "m_ObjectId": "a378ec4c43524a919746d28ab5e334bf", + "m_Group": { + "m_Id": "b4df5b2a90e74fea8f802d43a8c09f8b" + }, + "m_Name": "Property", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -2299.0, + "y": -96.99991607666016, + "width": 108.0, + "height": 34.0 + } + }, + "m_Slots": [ + { + "m_Id": "35e0961e58b34e47a1304e16475e7563" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_Property": { + "m_Id": "f9622be5f8634164ad02446464ba3c8b" + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.PropertyNode", + "m_ObjectId": "a63f6e2cd0db4079880e9db29ea73dff", + "m_Group": { + "m_Id": "bb3fb3d46c9240e499693e3571b3e902" + }, + "m_Name": "Property", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -4587.0, + "y": -293.00006103515627, + "width": 175.0, + "height": 34.000003814697269 + } + }, + "m_Slots": [ + { + "m_Id": "918706adaa944c508876a310d7944745" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_Property": { + "m_Id": "3b4543cf814541948b29c37c11d7f65c" + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "a6dcfbcf619145b79a41ab8962316327", + "m_Id": 0, + "m_DisplayName": "A", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "A", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicValueMaterialSlot", + "m_ObjectId": "a87c27f9673b4d8d9014a10e8f1e5135", + "m_Id": 1, + "m_DisplayName": "B", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "B", + "m_StageCapability": 3, + "m_Value": { + "e00": 2.0, + "e01": 2.0, + "e02": 2.0, + "e03": 2.0, + "e10": 2.0, + "e11": 2.0, + "e12": 2.0, + "e13": 2.0, + "e20": 2.0, + "e21": 2.0, + "e22": 2.0, + "e23": 2.0, + "e30": 2.0, + "e31": 2.0, + "e32": 2.0, + "e33": 2.0 + }, + "m_DefaultValue": { + "e00": 1.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 1.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 1.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 1.0 + } +} + +{ + "m_SGVersion": 1, + "m_Type": "UnityEditor.ShaderGraph.Internal.Vector1ShaderProperty", + "m_ObjectId": "ab62a8666e40463bacc9ea9d5fd7d499", + "m_Guid": { + "m_GuidSerialized": "84bd7a6e-5e1e-444c-9949-4c78cab87f41" + }, + "m_Name": "Top Max", + "m_DefaultReferenceName": "", + "m_OverrideReferenceName": "_TopMax", + "m_GeneratePropertyBlock": true, + "m_Precision": 0, + "overrideHLSLDeclaration": false, + "hlslDeclarationOverride": 0, + "m_Hidden": false, + "m_Value": 1.0, + "m_FloatType": 1, + "m_RangeValues": { + "x": 0.0, + "y": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "ac7e1d4733224b938f2237fa96812242", + "m_Id": 3, + "m_DisplayName": "Out", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "ad565fc369a4453dbc63b8c91397f0db", + "m_Id": 1, + "m_DisplayName": "B", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "B", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "b01656cf6a9344648a3d5ce3b6f0ab87", + "m_Id": 1, + "m_DisplayName": "R", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "R", + "m_StageCapability": 3, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "b059854fe00b445983b21407550ff234", + "m_Id": 1, + "m_DisplayName": "Edge2", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "Edge2", + "m_StageCapability": 3, + "m_Value": { + "x": 1.0, + "y": 1.0, + "z": 1.0, + "w": 1.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.PropertyNode", + "m_ObjectId": "b094a74596ff4389a782f91be27df498", + "m_Group": { + "m_Id": "bb3fb3d46c9240e499693e3571b3e902" + }, + "m_Name": "Property", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -6503.0, + "y": -104.99999237060547, + "width": 122.0, + "height": 34.0 + } + }, + "m_Slots": [ + { + "m_Id": "8151b70abdef4fda936fc0d9c9cf854a" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_Property": { + "m_Id": "ab62a8666e40463bacc9ea9d5fd7d499" + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.GroupData", + "m_ObjectId": "b0dc17fd9b744813b0d3cfe2bafd9cc5", + "m_Title": "Mesh Deform By Normal", + "m_Position": { + "x": -963.0, + "y": -706.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "b28c78e993ae4a5ebdad9e9dad855b8a", + "m_Id": 0, + "m_DisplayName": "In", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "In", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.PowerNode", + "m_ObjectId": "b36665f3426c4d3b9382ff175d4c08a9", + "m_Group": { + "m_Id": "07eec948987b4086a8f8a9921af44a06" + }, + "m_Name": "Power", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -2471.0, + "y": 792.9999389648438, + "width": 208.0, + "height": 302.0 + } + }, + "m_Slots": [ + { + "m_Id": "148b8781d99c40638b56e0cce0315f95" + }, + { + "m_Id": "00a4b524b54d40fdbcf604c7cc58d749" + }, + { + "m_Id": "e3d540a187cf426595f122103da7b5df" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "b48e9000cc99472c8a058c34c795c30b", + "m_Id": 0, + "m_DisplayName": "Occlusion Power", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.GroupData", + "m_ObjectId": "b4df5b2a90e74fea8f802d43a8c09f8b", + "m_Title": "Vertex Adjust Strength", + "m_Position": { + "x": -3319.000244140625, + "y": -1131.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicValueMaterialSlot", + "m_ObjectId": "b6c15f0dd0a741388c014bf93f2c816a", + "m_Id": 0, + "m_DisplayName": "A", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "A", + "m_StageCapability": 3, + "m_Value": { + "e00": 0.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 0.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 0.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 0.0 + }, + "m_DefaultValue": { + "e00": 1.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 1.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 1.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.NormalVectorNode", + "m_ObjectId": "b816a39688d74617b11482edc3472c14", + "m_Group": { + "m_Id": "b0dc17fd9b744813b0d3cfe2bafd9cc5" + }, + "m_Name": "Normal Vector", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -937.9996337890625, + "y": -486.0, + "width": 205.99998474121095, + "height": 132.0 + } + }, + "m_Slots": [ + { + "m_Id": "e8eb67cf30a8412e921e7ade8a3270d9" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 2, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_Space": 0 +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.PropertyNode", + "m_ObjectId": "b90bcfe7812b47ffbe08d0e89368abd0", + "m_Group": { + "m_Id": "bb3fb3d46c9240e499693e3571b3e902" + }, + "m_Name": "Property", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -6499.0, + "y": -508.99993896484377, + "width": 137.0, + "height": 34.000003814697269 + } + }, + "m_Slots": [ + { + "m_Id": "6825a951f7b6466d91ecbb98d70bffa9" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_Property": { + "m_Id": "09b87be164e345ad946f065f3a43d2ee" + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "ba1dd963f914499b8494ad276a6a1c4b", + "m_Id": 2, + "m_DisplayName": "In", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "In", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicValueMaterialSlot", + "m_ObjectId": "ba43b6747f4c41e3adce6e2da4e3ac90", + "m_Id": 2, + "m_DisplayName": "Out", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": { + "e00": 0.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 0.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 0.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 0.0 + }, + "m_DefaultValue": { + "e00": 1.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 1.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 1.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "ba62e0615495409688e71158440aa3e0", + "m_Id": 2, + "m_DisplayName": "Out", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 1, + "m_Type": "UnityEditor.ShaderGraph.Internal.Vector1ShaderProperty", + "m_ObjectId": "ba712075273f4fa1b806cc19118186a7", + "m_Guid": { + "m_GuidSerialized": "114d81fa-bb74-4a1f-92f1-8131501dab46" + }, + "m_Name": "Outer Max", + "m_DefaultReferenceName": "", + "m_OverrideReferenceName": "_OuterMax", + "m_GeneratePropertyBlock": true, + "m_Precision": 0, + "overrideHLSLDeclaration": false, + "hlslDeclarationOverride": 0, + "m_Hidden": false, + "m_Value": 0.5, + "m_FloatType": 1, + "m_RangeValues": { + "x": 0.0, + "y": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.ColorRGBMaterialSlot", + "m_ObjectId": "bb28d292ab8e4ae88fbf211b9f92593c", + "m_Id": 0, + "m_DisplayName": "Base Color", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "BaseColor", + "m_StageCapability": 2, + "m_Value": { + "x": 0.5, + "y": 0.5, + "z": 0.5 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0 + }, + "m_Labels": [], + "m_ColorMode": 0, + "m_DefaultColor": { + "r": 0.5, + "g": 0.5, + "b": 0.5, + "a": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.GroupData", + "m_ObjectId": "bb3fb3d46c9240e499693e3571b3e902", + "m_Title": "AO Gradient Generator", + "m_Position": { + "x": -7827.0, + "y": -1245.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.PropertyNode", + "m_ObjectId": "bbec3648e6344c36a57fa1294aff3f23", + "m_Group": { + "m_Id": "b4df5b2a90e74fea8f802d43a8c09f8b" + }, + "m_Name": "Property", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -1411.0001220703125, + "y": -263.0, + "width": 94.0, + "height": 34.0 + } + }, + "m_Slots": [ + { + "m_Id": "9592bd7eb63940599fec8c1c4ed8d7e5" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_Property": { + "m_Id": "3c5c8cfa6e464d7489bcc7a552c5922c" + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.TangentMaterialSlot", + "m_ObjectId": "bc9d9b059af0485bb5d17f0cdcf6a0e2", + "m_Id": 0, + "m_DisplayName": "Tangent", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "Tangent", + "m_StageCapability": 1, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0 + }, + "m_Labels": [], + "m_Space": 0 +} + +{ + "m_SGVersion": 1, + "m_Type": "UnityEditor.ShaderGraph.Internal.Vector1ShaderProperty", + "m_ObjectId": "bcd952383b8d4fe0af79e073853c8be7", + "m_Guid": { + "m_GuidSerialized": "3472deb1-9f64-4620-8030-8a16c5a64864" + }, + "m_Name": "Tear Duct Position", + "m_DefaultReferenceName": "Vector1_bcd952383b8d4fe0af79e073853c8be7", + "m_OverrideReferenceName": "_TearDuctPosition", + "m_GeneratePropertyBlock": true, + "m_Precision": 0, + "overrideHLSLDeclaration": false, + "hlslDeclarationOverride": 0, + "m_Hidden": false, + "m_Value": 0.800000011920929, + "m_FloatType": 1, + "m_RangeValues": { + "x": 0.0, + "y": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "bdb935029f0a4ef98312efa0926f5f29", + "m_Id": 3, + "m_DisplayName": "Out", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "be768b094ed94bef9328e4c2ff806841", + "m_Id": 1, + "m_DisplayName": "B", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "B", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.OneMinusNode", + "m_ObjectId": "bea7d15637c342f5a0f46e3fe54f0c0c", + "m_Group": { + "m_Id": "bb3fb3d46c9240e499693e3571b3e902" + }, + "m_Name": "One Minus", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -6551.0, + "y": -1090.0, + "width": 128.0, + "height": 94.0 + } + }, + "m_Slots": [ + { + "m_Id": "745f46dae5c04ee493751d995bfa2880" + }, + { + "m_Id": "4bfcdced578a4412a7da40df467800ad" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.MultiplyNode", + "m_ObjectId": "beb4ecf6c7834c56a1ac66b1d3f69323", + "m_Group": { + "m_Id": "0bda9324be5243aba9c7b05ef2f00ded" + }, + "m_Name": "Multiply", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -3190.0, + "y": 790.0001220703125, + "width": 208.0, + "height": 302.0 + } + }, + "m_Slots": [ + { + "m_Id": "5a141b0ebcab4787a3c7554797acbc0f" + }, + { + "m_Id": "d80ff40201e944a7acfe7ffc9f2c724d" + }, + { + "m_Id": "e1efe5d8349349ca91458c9e9992dbf5" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.PropertyNode", + "m_ObjectId": "bec97d41a4a84aa58e0ff22f2f7adfd5", + "m_Group": { + "m_Id": "" + }, + "m_Name": "Property", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -186.00006103515626, + "y": 309.0, + "width": 161.0, + "height": 34.0 + } + }, + "m_Slots": [ + { + "m_Id": "076bd42eeeef49dfbdef82e7b1bf8eb9" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_Property": { + "m_Id": "e9d81cab799f494a804d5a23f7b9931b" + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.SplitNode", + "m_ObjectId": "becdaadb0abb4175b8984aeab1c88d8e", + "m_Group": { + "m_Id": "b4df5b2a90e74fea8f802d43a8c09f8b" + }, + "m_Name": "Split", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -3078.000244140625, + "y": -584.0, + "width": 120.0, + "height": 149.0 + } + }, + "m_Slots": [ + { + "m_Id": "05b797db370449deb48124605e9e32f4" + }, + { + "m_Id": "6d711b5fee3a476e82d8288a6439904f" + }, + { + "m_Id": "cba48c63c29040739f9f941e20592ee3" + }, + { + "m_Id": "883183c2957240daab15ac73ec426ab3" + }, + { + "m_Id": "778c121c491d4910bbbd52cb77493747" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicValueMaterialSlot", + "m_ObjectId": "bfe206dc714e419bbae825796cd562fc", + "m_Id": 0, + "m_DisplayName": "A", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "A", + "m_StageCapability": 3, + "m_Value": { + "e00": 0.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 0.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 0.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 0.0 + }, + "m_DefaultValue": { + "e00": 1.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 1.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 1.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicValueMaterialSlot", + "m_ObjectId": "c03abd73db0b4da59628e1c0ab59d4e4", + "m_Id": 1, + "m_DisplayName": "B", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "B", + "m_StageCapability": 3, + "m_Value": { + "e00": 2.0, + "e01": 2.0, + "e02": 2.0, + "e03": 2.0, + "e10": 2.0, + "e11": 2.0, + "e12": 2.0, + "e13": 2.0, + "e20": 2.0, + "e21": 2.0, + "e22": 2.0, + "e23": 2.0, + "e30": 2.0, + "e31": 2.0, + "e32": 2.0, + "e33": 2.0 + }, + "m_DefaultValue": { + "e00": 1.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 1.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 1.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "c11638346b114fad92971e74e5f9223a", + "m_Id": 1, + "m_DisplayName": "Out", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicValueMaterialSlot", + "m_ObjectId": "c17008c6bd2746d3aff735bcf194834e", + "m_Id": 1, + "m_DisplayName": "B", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "B", + "m_StageCapability": 3, + "m_Value": { + "e00": 2.0, + "e01": 2.0, + "e02": 2.0, + "e03": 2.0, + "e10": 2.0, + "e11": 2.0, + "e12": 2.0, + "e13": 2.0, + "e20": 2.0, + "e21": 2.0, + "e22": 2.0, + "e23": 2.0, + "e30": 2.0, + "e31": 2.0, + "e32": 2.0, + "e33": 2.0 + }, + "m_DefaultValue": { + "e00": 1.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 1.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 1.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.MultiplyNode", + "m_ObjectId": "c265c36ac38a40ad9a117c9ee3bbd219", + "m_Group": { + "m_Id": "bb3fb3d46c9240e499693e3571b3e902" + }, + "m_Name": "Multiply", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -5356.0, + "y": -705.0001220703125, + "width": 208.0, + "height": 302.0 + } + }, + "m_Slots": [ + { + "m_Id": "dc0688ac9ddd4d68b98b9c33c1f9c650" + }, + { + "m_Id": "239f505afc5745eeba30d213e5edff68" + }, + { + "m_Id": "de416a1e2c2c4368863b920244e8cdcf" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "c2802b4d1ed5477ebb2e709f3b6a50f7", + "m_Id": 0, + "m_DisplayName": "Inner Max", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "c2b7d105f8a740a99bddcd04de15eff6", + "m_Id": 0, + "m_DisplayName": "A", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "A", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.AddNode", + "m_ObjectId": "c43cb6519f974ed182959abcd616d28b", + "m_Group": { + "m_Id": "b0dc17fd9b744813b0d3cfe2bafd9cc5" + }, + "m_Name": "Add", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -356.9998474121094, + "y": -586.9999389648438, + "width": 130.0, + "height": 118.0 + } + }, + "m_Slots": [ + { + "m_Id": "91898770038a4c9ca244c11883936fb0" + }, + { + "m_Id": "be768b094ed94bef9328e4c2ff806841" + }, + { + "m_Id": "02a4afedd77a45a18183ae0fb54970fb" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 1, + "m_Type": "UnityEditor.ShaderGraph.Internal.Vector1ShaderProperty", + "m_ObjectId": "c530dc7dbef64ff88f5faaec8d3aeb70", + "m_Guid": { + "m_GuidSerialized": "6b2eac4a-19c4-4e04-9a7e-1fbc184962b2" + }, + "m_Name": "Top Min", + "m_DefaultReferenceName": "Vector1_c530dc7dbef64ff88f5faaec8d3aeb70", + "m_OverrideReferenceName": "_TopMin", + "m_GeneratePropertyBlock": true, + "m_Precision": 0, + "overrideHLSLDeclaration": false, + "hlslDeclarationOverride": 0, + "m_Hidden": false, + "m_Value": 0.10000000149011612, + "m_FloatType": 1, + "m_RangeValues": { + "x": 0.0, + "y": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "cba48c63c29040739f9f941e20592ee3", + "m_Id": 2, + "m_DisplayName": "G", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "G", + "m_StageCapability": 3, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.PropertyNode", + "m_ObjectId": "cc2beb151c5b4a6589b44a757b3c845c", + "m_Group": { + "m_Id": "bb3fb3d46c9240e499693e3571b3e902" + }, + "m_Name": "Property", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -6199.0, + "y": 239.0, + "width": 129.0, + "height": 34.000003814697269 + } + }, + "m_Slots": [ + { + "m_Id": "5c960d505db748dbbdde9c3f60585761" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_Property": { + "m_Id": "f55851877d874420a73990f8c755a22a" + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.PropertyNode", + "m_ObjectId": "cc64b4d3127a4eb69ebaccceb3b0c8ea", + "m_Group": { + "m_Id": "bb3fb3d46c9240e499693e3571b3e902" + }, + "m_Name": "Property", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -6052.0, + "y": -71.00003814697266, + "width": 130.0, + "height": 34.000003814697269 + } + }, + "m_Slots": [ + { + "m_Id": "3ad05717c37e4e33a97663ba5ba9dea8" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_Property": { + "m_Id": "2a55ed25fe554e5f8cfb78d36ce2a9e5" + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.Rendering.HighDefinition.ShaderGraph.SystemData", + "m_ObjectId": "cd095f47ff5044e09409c402568d61d1", + "m_MaterialNeedsUpdateHash": 0, + "m_SurfaceType": 1, + "m_RenderingPass": 4, + "m_BlendMode": 0, + "m_ZTest": 4, + "m_ZWrite": false, + "m_TransparentCullMode": 2, + "m_OpaqueCullMode": 2, + "m_SortPriority": 1, + "m_AlphaTest": false, + "m_TransparentDepthPrepass": false, + "m_TransparentDepthPostpass": false, + "m_SupportLodCrossFade": false, + "m_DoubleSidedMode": 0, + "m_DOTSInstancing": false, + "m_Version": 0, + "m_FirstTimeMigrationExecuted": true, + "inspectorFoldoutMask": 11 +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicValueMaterialSlot", + "m_ObjectId": "cd6ae63c6a0145ff98c017fa840d66a2", + "m_Id": 2, + "m_DisplayName": "Out", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": { + "e00": 0.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 0.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 0.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 0.0 + }, + "m_DefaultValue": { + "e00": 1.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 1.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 1.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "ce0ad783cd2241789da30ff6024dcba9", + "m_Id": 1, + "m_DisplayName": "B", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "B", + "m_StageCapability": 3, + "m_Value": { + "x": 2.0, + "y": 2.0, + "z": 2.0, + "w": 2.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.BlockNode", + "m_ObjectId": "cf932a596e764ab3a051fde470178b7c", + "m_Group": { + "m_Id": "" + }, + "m_Name": "VertexDescription.Tangent", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": 0.0, + "y": 0.0, + "width": 0.0, + "height": 0.0 + } + }, + "m_Slots": [ + { + "m_Id": "bc9d9b059af0485bb5d17f0cdcf6a0e2" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_SerializedDescriptor": "VertexDescription.Tangent" +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicValueMaterialSlot", + "m_ObjectId": "d0b43c7f386847468f35c737403aa6fb", + "m_Id": 0, + "m_DisplayName": "A", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "A", + "m_StageCapability": 3, + "m_Value": { + "e00": 0.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 0.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 0.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 0.0 + }, + "m_DefaultValue": { + "e00": 1.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 1.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 1.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.PropertyNode", + "m_ObjectId": "d0f064ad3fb2480c84466012dad6fa0d", + "m_Group": { + "m_Id": "bb3fb3d46c9240e499693e3571b3e902" + }, + "m_Name": "Property", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -6487.0, + "y": -894.0000610351563, + "width": 126.0, + "height": 34.000003814697269 + } + }, + "m_Slots": [ + { + "m_Id": "eb7668480f494e35a9fd8f23b00497f5" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_Property": { + "m_Id": "7bc08229a45c46be902bb162fca67728" + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicValueMaterialSlot", + "m_ObjectId": "d15a848ac85f4863b5ed4de006c537d3", + "m_Id": 1, + "m_DisplayName": "B", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "B", + "m_StageCapability": 3, + "m_Value": { + "e00": 2.0, + "e01": 2.0, + "e02": 2.0, + "e03": 2.0, + "e10": 2.0, + "e11": 2.0, + "e12": 2.0, + "e13": 2.0, + "e20": 2.0, + "e21": 2.0, + "e22": 2.0, + "e23": 2.0, + "e30": 2.0, + "e31": 2.0, + "e32": 2.0, + "e33": 2.0 + }, + "m_DefaultValue": { + "e00": 1.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 1.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 1.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 1.0 + } +} + +{ + "m_SGVersion": 1, + "m_Type": "UnityEditor.ShaderGraph.Internal.Vector1ShaderProperty", + "m_ObjectId": "d212ea7404ac470d8fb7e0b25f74c18e", + "m_Guid": { + "m_GuidSerialized": "d6a22534-0177-4189-90b1-fb1fbf02d6ff" + }, + "m_Name": "Bottom Curve", + "m_DefaultReferenceName": "", + "m_OverrideReferenceName": "_BottomCurve", + "m_GeneratePropertyBlock": true, + "m_Precision": 0, + "overrideHLSLDeclaration": false, + "hlslDeclarationOverride": 0, + "m_Hidden": false, + "m_Value": 2.0, + "m_FloatType": 1, + "m_RangeValues": { + "x": 0.0, + "y": 2.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.PropertyNode", + "m_ObjectId": "d308f8ae0caf4e4fb0fb9815db0829e5", + "m_Group": { + "m_Id": "bb3fb3d46c9240e499693e3571b3e902" + }, + "m_Name": "Property", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -6506.0, + "y": -1186.0, + "width": 123.00000762939453, + "height": 34.000003814697269 + } + }, + "m_Slots": [ + { + "m_Id": "8de9225e19194f959a9b6104d22dcec8" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_Property": { + "m_Id": "801dfebd26864a04b4834d8136ab2f4e" + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "d31794772e5249cc8624c820826d8018", + "m_Id": 0, + "m_DisplayName": "Edge1", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "Edge1", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "d355974e14d846879fb898fb29b7501a", + "m_Id": 2, + "m_DisplayName": "In", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "In", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "d4ee052d4ddc4ca781803618e0f24a45", + "m_Id": 0, + "m_DisplayName": "A", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "A", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicValueMaterialSlot", + "m_ObjectId": "d5558c96962a45fda7fdf40869a247fc", + "m_Id": 2, + "m_DisplayName": "Out", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": { + "e00": 0.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 0.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 0.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 0.0 + }, + "m_DefaultValue": { + "e00": 1.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 1.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 1.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.PowerNode", + "m_ObjectId": "d641720eefd44f0ab89160d5a390930c", + "m_Group": { + "m_Id": "bb3fb3d46c9240e499693e3571b3e902" + }, + "m_Name": "Power", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -5899.0, + "y": -143.99998474121095, + "width": 208.0, + "height": 302.0 + } + }, + "m_Slots": [ + { + "m_Id": "e692c6bc2ca04556a5130485b37c3918" + }, + { + "m_Id": "ce0ad783cd2241789da30ff6024dcba9" + }, + { + "m_Id": "ba62e0615495409688e71158440aa3e0" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "d780ac648c1c4de3b184b3b6f4fb4444", + "m_Id": 0, + "m_DisplayName": "In", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "In", + "m_StageCapability": 3, + "m_Value": { + "x": 1.0, + "y": 1.0, + "z": 1.0, + "w": 1.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "d7eefb11caf34fa2b8e7022325c65f50", + "m_Id": 1, + "m_DisplayName": "Out", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicValueMaterialSlot", + "m_ObjectId": "d80ff40201e944a7acfe7ffc9f2c724d", + "m_Id": 1, + "m_DisplayName": "B", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "B", + "m_StageCapability": 3, + "m_Value": { + "e00": 2.0, + "e01": 2.0, + "e02": 2.0, + "e03": 2.0, + "e10": 2.0, + "e11": 2.0, + "e12": 2.0, + "e13": 2.0, + "e20": 2.0, + "e21": 2.0, + "e22": 2.0, + "e23": 2.0, + "e30": 2.0, + "e31": 2.0, + "e32": 2.0, + "e33": 2.0 + }, + "m_DefaultValue": { + "e00": 1.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 1.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 1.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "d83674a1b5534416b5e07d2246210a36", + "m_Id": 1, + "m_DisplayName": "", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.RedirectNodeData", + "m_ObjectId": "d8e4155c85614881aaef68d3828c47bb", + "m_Group": { + "m_Id": "" + }, + "m_Name": "Redirect Node", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -6052.00048828125, + "y": 900.9999389648438, + "width": 56.0, + "height": 24.000001907348634 + } + }, + "m_Slots": [ + { + "m_Id": "982e94daa6fd478894f4f791d59d2bf1" + }, + { + "m_Id": "18cd722a32d648f68ec3f5a0dd01d2b4" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "d98d8cd72101478b8c0bd71f3ad0ed66", + "m_Id": 1, + "m_DisplayName": "", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "d99e4a9d3e314e1f9b15d1e9327df59f", + "m_Id": 1, + "m_DisplayName": "B", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "B", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.RedirectNodeData", + "m_ObjectId": "d9cb07c9f0ba47839945d27cff94311a", + "m_Group": { + "m_Id": "bb3fb3d46c9240e499693e3571b3e902" + }, + "m_Name": "Redirect Node", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -6199.0, + "y": 323.0000305175781, + "width": 56.000003814697269, + "height": 24.0 + } + }, + "m_Slots": [ + { + "m_Id": "196787bff01345e29cc327dd6c8c5dc3" + }, + { + "m_Id": "d83674a1b5534416b5e07d2246210a36" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "da6bd2aec3fc49ad95ac557950c2e3ac", + "m_Id": 1, + "m_DisplayName": "B", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "B", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicValueMaterialSlot", + "m_ObjectId": "dc0688ac9ddd4d68b98b9c33c1f9c650", + "m_Id": 0, + "m_DisplayName": "A", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "A", + "m_StageCapability": 3, + "m_Value": { + "e00": 0.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 0.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 0.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 0.0 + }, + "m_DefaultValue": { + "e00": 1.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 1.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 1.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.OneMinusNode", + "m_ObjectId": "dc8dc19bad4543649f684efd8c0305a9", + "m_Group": { + "m_Id": "0bda9324be5243aba9c7b05ef2f00ded" + }, + "m_Name": "One Minus", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -3690.999755859375, + "y": 898.0, + "width": 208.0, + "height": 278.0 + } + }, + "m_Slots": [ + { + "m_Id": "ec51f87aa7364cb4b069d42ebf50f289" + }, + { + "m_Id": "c11638346b114fad92971e74e5f9223a" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 1, + "m_Type": "UnityEditor.ShaderGraph.Internal.Vector1ShaderProperty", + "m_ObjectId": "dd54da0252e94dd6a1f7e2f67ac4e5d3", + "m_Guid": { + "m_GuidSerialized": "79f799dc-ff65-4dc4-bd47-7130a851ea9e" + }, + "m_Name": "Bottom Max", + "m_DefaultReferenceName": "", + "m_OverrideReferenceName": "_BottomMax", + "m_GeneratePropertyBlock": true, + "m_Precision": 0, + "overrideHLSLDeclaration": false, + "hlslDeclarationOverride": 0, + "m_Hidden": false, + "m_Value": 0.30000001192092898, + "m_FloatType": 1, + "m_RangeValues": { + "x": 0.0, + "y": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicValueMaterialSlot", + "m_ObjectId": "de416a1e2c2c4368863b920244e8cdcf", + "m_Id": 2, + "m_DisplayName": "Out", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": { + "e00": 0.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 0.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 0.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 0.0 + }, + "m_DefaultValue": { + "e00": 1.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 1.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 1.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "de5d34d01a804146a0ecba23241b4291", + "m_Id": 0, + "m_DisplayName": "Tear Duct Position", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "df25e2c94b0f41918bbc3c6b457490a4", + "m_Id": 4, + "m_DisplayName": "A", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "A", + "m_StageCapability": 3, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicValueMaterialSlot", + "m_ObjectId": "e0b0d8b22c4f4ffc9cf4cbe59f947987", + "m_Id": 0, + "m_DisplayName": "A", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "A", + "m_StageCapability": 3, + "m_Value": { + "e00": 0.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 0.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 0.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 0.0 + }, + "m_DefaultValue": { + "e00": 1.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 1.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 1.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicValueMaterialSlot", + "m_ObjectId": "e1a26577b8104a598b18bcca2a5df82d", + "m_Id": 2, + "m_DisplayName": "Out", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": { + "e00": 0.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 0.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 0.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 0.0 + }, + "m_DefaultValue": { + "e00": 1.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 1.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 1.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicValueMaterialSlot", + "m_ObjectId": "e1efe5d8349349ca91458c9e9992dbf5", + "m_Id": 2, + "m_DisplayName": "Out", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": { + "e00": 0.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 0.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 0.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 0.0 + }, + "m_DefaultValue": { + "e00": 1.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 1.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 1.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicValueMaterialSlot", + "m_ObjectId": "e265d221fc5543c2a821246aaf81c1e0", + "m_Id": 1, + "m_DisplayName": "B", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "B", + "m_StageCapability": 3, + "m_Value": { + "e00": 8.0, + "e01": 2.0, + "e02": 2.0, + "e03": 2.0, + "e10": 2.0, + "e11": 2.0, + "e12": 2.0, + "e13": 2.0, + "e20": 2.0, + "e21": 2.0, + "e22": 2.0, + "e23": 2.0, + "e30": 2.0, + "e31": 2.0, + "e32": 2.0, + "e33": 2.0 + }, + "m_DefaultValue": { + "e00": 1.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 1.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 1.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "e2cc1440bbbb457c9e73f5ccc9ee3ce8", + "m_Id": 0, + "m_DisplayName": "A", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "A", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "e2e320b532b343a2b345dcce6b6ca057", + "m_Id": 1, + "m_DisplayName": "B", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "B", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "e3d540a187cf426595f122103da7b5df", + "m_Id": 2, + "m_DisplayName": "Out", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicValueMaterialSlot", + "m_ObjectId": "e433a9c444b640dea68ac7f83ba7e24d", + "m_Id": 2, + "m_DisplayName": "Out", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": { + "e00": 0.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 0.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 0.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 0.0 + }, + "m_DefaultValue": { + "e00": 1.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 1.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 1.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector4MaterialSlot", + "m_ObjectId": "e506546e9df6439eafbf8afe832616ca", + "m_Id": 0, + "m_DisplayName": "Out", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "e62699515699496f8be6c469a6ee6166", + "m_Id": 0, + "m_DisplayName": "A", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "A", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "e692c6bc2ca04556a5130485b37c3918", + "m_Id": 0, + "m_DisplayName": "A", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "A", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "e6bcbf0b79c94547b3a5801c6ee9ad01", + "m_Id": 0, + "m_DisplayName": "A", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "A", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector4MaterialSlot", + "m_ObjectId": "e77fe4d8036f480398f270e7cea20a2a", + "m_Id": 0, + "m_DisplayName": "Out", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.MultiplyNode", + "m_ObjectId": "e7a24ae205bd439e86a2a235cea7e958", + "m_Group": { + "m_Id": "b4df5b2a90e74fea8f802d43a8c09f8b" + }, + "m_Name": "Multiply", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -2143.0, + "y": -1072.0, + "width": 126.00000762939453, + "height": 118.00000762939453 + } + }, + "m_Slots": [ + { + "m_Id": "bfe206dc714e419bbae825796cd562fc" + }, + { + "m_Id": "a87c27f9673b4d8d9014a10e8f1e5135" + }, + { + "m_Id": "5492411f859f437c9c9d33ab3c7af3fe" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector3MaterialSlot", + "m_ObjectId": "e8eb67cf30a8412e921e7ade8a3270d9", + "m_Id": 0, + "m_DisplayName": "Out", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 1.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0 + }, + "m_Labels": [] +} + +{ + "m_SGVersion": 3, + "m_Type": "UnityEditor.ShaderGraph.Internal.ColorShaderProperty", + "m_ObjectId": "e9d81cab799f494a804d5a23f7b9931b", + "m_Guid": { + "m_GuidSerialized": "0875e745-aa70-41bd-83dd-9eba8fbe3909" + }, + "m_Name": "Occlusion Color", + "m_DefaultReferenceName": "Color_e9d81cab799f494a804d5a23f7b9931b", + "m_OverrideReferenceName": "_OcclusionColor", + "m_GeneratePropertyBlock": true, + "m_Precision": 0, + "overrideHLSLDeclaration": false, + "hlslDeclarationOverride": 0, + "m_Hidden": false, + "m_Value": { + "r": 0.3294117748737335, + "g": 0.0941176488995552, + "b": 0.054901961237192157, + "a": 0.0 + }, + "m_ColorMode": 0 +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "ea927058cb774ec4966146b951890498", + "m_Id": 2, + "m_DisplayName": "G", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "G", + "m_StageCapability": 3, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "eb7668480f494e35a9fd8f23b00497f5", + "m_Id": 0, + "m_DisplayName": "Outer Min", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "ec51f87aa7364cb4b069d42ebf50f289", + "m_Id": 0, + "m_DisplayName": "In", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "In", + "m_StageCapability": 3, + "m_Value": { + "x": 1.0, + "y": 1.0, + "z": 1.0, + "w": 1.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "ee8dff5ed61a4b78937cf5ad03d487e0", + "m_Id": 1, + "m_DisplayName": "B", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "B", + "m_StageCapability": 3, + "m_Value": { + "x": 2.0, + "y": 2.0, + "z": 2.0, + "w": 2.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "ee9f6bbc4d2b424baba015a531d354a2", + "m_Id": 1, + "m_DisplayName": "Edge2", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "Edge2", + "m_StageCapability": 3, + "m_Value": { + "x": 1.0, + "y": 1.0, + "z": 1.0, + "w": 1.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.SmoothstepNode", + "m_ObjectId": "f0800ee295444cc6bc7eca6dab184d8e", + "m_Group": { + "m_Id": "bb3fb3d46c9240e499693e3571b3e902" + }, + "m_Name": "Smoothstep", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -6278.0, + "y": -1167.0001220703125, + "width": 208.0, + "height": 326.0000305175781 + } + }, + "m_Slots": [ + { + "m_Id": "0bbe1b6c18db4500954f186ec72ad31c" + }, + { + "m_Id": "f4a1e8eb6b6b4a5e88d9e00b94e5996e" + }, + { + "m_Id": "640e7709aac2433095ae84d95c451376" + }, + { + "m_Id": "bdb935029f0a4ef98312efa0926f5f29" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.BlockNode", + "m_ObjectId": "f0929bd816264348880d393c528dc110", + "m_Group": { + "m_Id": "" + }, + "m_Name": "SurfaceDescription.Alpha", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": 0.0, + "y": 0.0, + "width": 0.0, + "height": 0.0 + } + }, + "m_Slots": [ + { + "m_Id": "64da932b85b441a2bff9e05fcc44bd8f" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_SerializedDescriptor": "SurfaceDescription.Alpha" +} + +{ + "m_SGVersion": 1, + "m_Type": "UnityEditor.ShaderGraph.PositionNode", + "m_ObjectId": "f3091fe0fa9c4e38aef33375966f2355", + "m_Group": { + "m_Id": "b0dc17fd9b744813b0d3cfe2bafd9cc5" + }, + "m_Name": "Position", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -699.0000610351563, + "y": -647.0, + "width": 205.99998474121095, + "height": 132.0 + } + }, + "m_Slots": [ + { + "m_Id": "800a75e3b71e420a9b875e7df50af764" + } + ], + "synonyms": [], + "m_Precision": 1, + "m_PreviewExpanded": false, + "m_PreviewMode": 2, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_Space": 0 +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "f4a1e8eb6b6b4a5e88d9e00b94e5996e", + "m_Id": 1, + "m_DisplayName": "Edge2", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "Edge2", + "m_StageCapability": 3, + "m_Value": { + "x": 1.0, + "y": 1.0, + "z": 1.0, + "w": 1.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 1, + "m_Type": "UnityEditor.ShaderGraph.Internal.Vector1ShaderProperty", + "m_ObjectId": "f4c450cb47804c14b24590dae355002c", + "m_Guid": { + "m_GuidSerialized": "fdb5cc6f-e469-44bf-bc25-d763dd364fd7" + }, + "m_Name": "Tear Duct Width", + "m_DefaultReferenceName": "Vector1_f4c450cb47804c14b24590dae355002c", + "m_OverrideReferenceName": "_TearDuctWidth", + "m_GeneratePropertyBlock": true, + "m_Precision": 0, + "overrideHLSLDeclaration": false, + "hlslDeclarationOverride": 0, + "m_Hidden": false, + "m_Value": 0.5, + "m_FloatType": 1, + "m_RangeValues": { + "x": 0.0, + "y": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicValueMaterialSlot", + "m_ObjectId": "f55702e69fe6422db241f04b73b2f8fe", + "m_Id": 2, + "m_DisplayName": "Out", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": { + "e00": 0.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 0.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 0.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 0.0 + }, + "m_DefaultValue": { + "e00": 1.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 1.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 1.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 1.0 + } +} + +{ + "m_SGVersion": 1, + "m_Type": "UnityEditor.ShaderGraph.Internal.Vector1ShaderProperty", + "m_ObjectId": "f55851877d874420a73990f8c755a22a", + "m_Guid": { + "m_GuidSerialized": "f5b7bbc0-8e90-496f-b80a-c1cb81d3f257" + }, + "m_Name": "Top 2 Min", + "m_DefaultReferenceName": "", + "m_OverrideReferenceName": "_Top2Min", + "m_GeneratePropertyBlock": true, + "m_Precision": 0, + "overrideHLSLDeclaration": false, + "hlslDeclarationOverride": 0, + "m_Hidden": false, + "m_Value": 0.15000000596046449, + "m_FloatType": 1, + "m_RangeValues": { + "x": 0.0, + "y": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "f684cfd6321046968800ae12100e18c6", + "m_Id": 0, + "m_DisplayName": "A", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "A", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.SmoothstepNode", + "m_ObjectId": "f8d4eab103f0428892b5b5a06f03bb20", + "m_Group": { + "m_Id": "0bda9324be5243aba9c7b05ef2f00ded" + }, + "m_Name": "Smoothstep", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -3956.999755859375, + "y": 790.0, + "width": 208.0, + "height": 326.0 + } + }, + "m_Slots": [ + { + "m_Id": "397e99ff6b06405ebc3aa2aab649ed4f" + }, + { + "m_Id": "4879e075e449485daffefdad5cb24d7d" + }, + { + "m_Id": "54fe081fc97d4c3fae94da5b30d50350" + }, + { + "m_Id": "1f6ffa5fd1594e8bb959936cdad4af83" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 1, + "m_Type": "UnityEditor.ShaderGraph.Internal.Vector1ShaderProperty", + "m_ObjectId": "f9622be5f8634164ad02446464ba3c8b", + "m_Guid": { + "m_GuidSerialized": "2ac36ad6-fb27-42c5-b454-00d2e8f02ac8" + }, + "m_Name": "Expand Lower", + "m_DefaultReferenceName": "", + "m_OverrideReferenceName": "_ExpandLower", + "m_GeneratePropertyBlock": true, + "m_Precision": 0, + "overrideHLSLDeclaration": false, + "hlslDeclarationOverride": 0, + "m_Hidden": false, + "m_Value": 0.0, + "m_FloatType": 1, + "m_RangeValues": { + "x": -0.0010000000474974514, + "y": 0.0010000000474974514 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "fa313b6cbb2549ee998561bdbbfdc217", + "m_Id": 3, + "m_DisplayName": "Out", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "faa31ea642e94bbd866d7d274cfe0ecd", + "m_Id": 0, + "m_DisplayName": "Edge1", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "Edge1", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.ColorRGBMaterialSlot", + "m_ObjectId": "fb6ca1a014e64d79bbba8f84f8ccb6d5", + "m_Id": 0, + "m_DisplayName": "Emission", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "Emission", + "m_StageCapability": 2, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0 + }, + "m_Labels": [], + "m_ColorMode": 1, + "m_DefaultColor": { + "r": 0.0, + "g": 0.0, + "b": 0.0, + "a": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.SmoothstepNode", + "m_ObjectId": "fc71312321eb45b8b800345777d37a5d", + "m_Group": { + "m_Id": "bb3fb3d46c9240e499693e3571b3e902" + }, + "m_Name": "Smoothstep", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -6278.0, + "y": -143.99998474121095, + "width": 208.0, + "height": 326.0000305175781 + } + }, + "m_Slots": [ + { + "m_Id": "9917301b74a248f1a0b80c55e7edef74" + }, + { + "m_Id": "ee9f6bbc4d2b424baba015a531d354a2" + }, + { + "m_Id": "5f34f87b15084e7896e3304f861bb583" + }, + { + "m_Id": "35f44e6ed349424eb776f3b93f75e55a" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + diff --git a/HDRP/Shaders/RL_EyeOcclusionShader_HDRP.shadergraph.meta b/HDRP/Shaders/RL_EyeOcclusionShader_HDRP.shadergraph.meta new file mode 100644 index 0000000..8cd00f9 --- /dev/null +++ b/HDRP/Shaders/RL_EyeOcclusionShader_HDRP.shadergraph.meta @@ -0,0 +1,10 @@ +fileFormatVersion: 2 +guid: e11e1541751f73a4bbdc03b071617a93 +ScriptedImporter: + internalIDToNameTable: [] + externalObjects: {} + serializedVersion: 2 + userData: + assetBundleName: + assetBundleVariant: + script: {fileID: 11500000, guid: 625f186215c104763be7675aa2d941aa, type: 3} diff --git a/HDRP/Shaders/RL_EyeShaderBaked_HDRP.shadergraph b/HDRP/Shaders/RL_EyeShaderBaked_HDRP.shadergraph new file mode 100644 index 0000000..243b67c --- /dev/null +++ b/HDRP/Shaders/RL_EyeShaderBaked_HDRP.shadergraph @@ -0,0 +1,3635 @@ +{ + "m_SGVersion": 2, + "m_Type": "UnityEditor.ShaderGraph.GraphData", + "m_ObjectId": "3053821ffc274b2ea6b4cc7d989c23cf", + "m_Properties": [ + { + "m_Id": "52f02aeee7404dfda840641c91caeddb" + }, + { + "m_Id": "dfba2e664b854d7da03879c577fca0d8" + }, + { + "m_Id": "d5d122eed44b41ae84d69f8bb777e94b" + }, + { + "m_Id": "8ece50505af046fab4f259d189770780" + } + ], + "m_Keywords": [], + "m_Nodes": [ + { + "m_Id": "bcfdce6c0ab14b7990e1c860fcd647e2" + }, + { + "m_Id": "de0c01eb18a547fdbe20f493469a7c6d" + }, + { + "m_Id": "ee74bc357bc94231a7dfd0efd1b889f3" + }, + { + "m_Id": "5f2a85f2be60457c910ca347ab57af46" + }, + { + "m_Id": "8cbb7b1e46ae4b408b7db7abad3b8f4b" + }, + { + "m_Id": "9793273e24544c1487e7f5a12fb16336" + }, + { + "m_Id": "92f838491ba947f584a076eaa4a5fad1" + }, + { + "m_Id": "bbb748d7daeb4992a717c5199d0bc690" + }, + { + "m_Id": "c508a09dcb7f4f06aa0f8ecf9e96259c" + }, + { + "m_Id": "ec6f605ead8f4fd6a96a492279ce0302" + }, + { + "m_Id": "a4ac7b4160ba47c98dc6e20c28ba81ea" + }, + { + "m_Id": "ddf8b777a50c429fb122f94c58d1f101" + }, + { + "m_Id": "f037fecbc403464fb614598ba9c22b95" + }, + { + "m_Id": "2bef449599564fb3822fd4e75d52d7d6" + }, + { + "m_Id": "5f2191730fba43239d38db446558a163" + }, + { + "m_Id": "156f557746454fa4b8283e362ec920d8" + }, + { + "m_Id": "3a9a84efd47842bf8cfb51363959c295" + }, + { + "m_Id": "74c8d8dd779247ba849a24460c6f7076" + }, + { + "m_Id": "9dd1c77fb00c4649a5d4c260bb5148d5" + }, + { + "m_Id": "08215151f8264accae52ffaeb3798150" + }, + { + "m_Id": "6719ad891bc64c5282ba6b76000e03ce" + }, + { + "m_Id": "d7dfcec608db4609a4374b3c9a84ef32" + }, + { + "m_Id": "696a08a4d44b4f65bca2437d68fa6d3d" + }, + { + "m_Id": "0e59a7f4c22e4e5ea15447c089ba0908" + }, + { + "m_Id": "d9954637b73947b99d89ef5a3fe791b8" + }, + { + "m_Id": "5becb5ea83c943d8ac512fecbed6ffac" + }, + { + "m_Id": "184ba437bcdd44ba8404aa50c843e3ee" + }, + { + "m_Id": "5cd9382b2a024acc987edc47bfa51fad" + }, + { + "m_Id": "ba28e30a615c49eead26ea0709253381" + }, + { + "m_Id": "d903631d751145939c27b46b27bdc593" + }, + { + "m_Id": "ad0b8c720afc4dff858361e65627778b" + } + ], + "m_GroupDatas": [], + "m_StickyNoteDatas": [], + "m_Edges": [ + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "08215151f8264accae52ffaeb3798150" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "6719ad891bc64c5282ba6b76000e03ce" + }, + "m_SlotId": 1 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "0e59a7f4c22e4e5ea15447c089ba0908" + }, + "m_SlotId": 2 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "d903631d751145939c27b46b27bdc593" + }, + "m_SlotId": 2 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "156f557746454fa4b8283e362ec920d8" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "696a08a4d44b4f65bca2437d68fa6d3d" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "184ba437bcdd44ba8404aa50c843e3ee" + }, + "m_SlotId": 1 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "0e59a7f4c22e4e5ea15447c089ba0908" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "2bef449599564fb3822fd4e75d52d7d6" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "5f2a85f2be60457c910ca347ab57af46" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "2bef449599564fb3822fd4e75d52d7d6" + }, + "m_SlotId": 7 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "a4ac7b4160ba47c98dc6e20c28ba81ea" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "3a9a84efd47842bf8cfb51363959c295" + }, + "m_SlotId": 2 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "696a08a4d44b4f65bca2437d68fa6d3d" + }, + "m_SlotId": 1 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "5becb5ea83c943d8ac512fecbed6ffac" + }, + "m_SlotId": 2 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "184ba437bcdd44ba8404aa50c843e3ee" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "5becb5ea83c943d8ac512fecbed6ffac" + }, + "m_SlotId": 2 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "d903631d751145939c27b46b27bdc593" + }, + "m_SlotId": 1 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "5cd9382b2a024acc987edc47bfa51fad" + }, + "m_SlotId": 3 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "5becb5ea83c943d8ac512fecbed6ffac" + }, + "m_SlotId": 1 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "5f2191730fba43239d38db446558a163" + }, + "m_SlotId": 4 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "92f838491ba947f584a076eaa4a5fad1" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "5f2191730fba43239d38db446558a163" + }, + "m_SlotId": 5 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "ec6f605ead8f4fd6a96a492279ce0302" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "5f2191730fba43239d38db446558a163" + }, + "m_SlotId": 6 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "ba28e30a615c49eead26ea0709253381" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "5f2191730fba43239d38db446558a163" + }, + "m_SlotId": 7 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "c508a09dcb7f4f06aa0f8ecf9e96259c" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "6719ad891bc64c5282ba6b76000e03ce" + }, + "m_SlotId": 7 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "9dd1c77fb00c4649a5d4c260bb5148d5" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "696a08a4d44b4f65bca2437d68fa6d3d" + }, + "m_SlotId": 2 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "bcfdce6c0ab14b7990e1c860fcd647e2" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "74c8d8dd779247ba849a24460c6f7076" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "3a9a84efd47842bf8cfb51363959c295" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "9dd1c77fb00c4649a5d4c260bb5148d5" + }, + "m_SlotId": 2 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "3a9a84efd47842bf8cfb51363959c295" + }, + "m_SlotId": 1 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "ad0b8c720afc4dff858361e65627778b" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "5cd9382b2a024acc987edc47bfa51fad" + }, + "m_SlotId": 1 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "ba28e30a615c49eead26ea0709253381" + }, + "m_SlotId": 1 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "5cd9382b2a024acc987edc47bfa51fad" + }, + "m_SlotId": 2 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "d7dfcec608db4609a4374b3c9a84ef32" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "9dd1c77fb00c4649a5d4c260bb5148d5" + }, + "m_SlotId": 1 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "d903631d751145939c27b46b27bdc593" + }, + "m_SlotId": 3 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "2bef449599564fb3822fd4e75d52d7d6" + }, + "m_SlotId": 2 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "d9954637b73947b99d89ef5a3fe791b8" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "0e59a7f4c22e4e5ea15447c089ba0908" + }, + "m_SlotId": 1 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "ddf8b777a50c429fb122f94c58d1f101" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "2bef449599564fb3822fd4e75d52d7d6" + }, + "m_SlotId": 1 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "f037fecbc403464fb614598ba9c22b95" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "5f2191730fba43239d38db446558a163" + }, + "m_SlotId": 1 + } + } + ], + "m_VertexContext": { + "m_Position": { + "x": -0.00000286102294921875, + "y": -255.0 + }, + "m_Blocks": [ + { + "m_Id": "bcfdce6c0ab14b7990e1c860fcd647e2" + }, + { + "m_Id": "de0c01eb18a547fdbe20f493469a7c6d" + }, + { + "m_Id": "ee74bc357bc94231a7dfd0efd1b889f3" + } + ] + }, + "m_FragmentContext": { + "m_Position": { + "x": 0.0000286102294921875, + "y": 389.0 + }, + "m_Blocks": [ + { + "m_Id": "5f2a85f2be60457c910ca347ab57af46" + }, + { + "m_Id": "8cbb7b1e46ae4b408b7db7abad3b8f4b" + }, + { + "m_Id": "9793273e24544c1487e7f5a12fb16336" + }, + { + "m_Id": "a4ac7b4160ba47c98dc6e20c28ba81ea" + }, + { + "m_Id": "92f838491ba947f584a076eaa4a5fad1" + }, + { + "m_Id": "bbb748d7daeb4992a717c5199d0bc690" + }, + { + "m_Id": "ec6f605ead8f4fd6a96a492279ce0302" + }, + { + "m_Id": "c508a09dcb7f4f06aa0f8ecf9e96259c" + } + ] + }, + "m_PreviewData": { + "serializedMesh": { + "m_SerializedMesh": "{\"mesh\":{\"instanceID\":0}}", + "m_Guid": "" + } + }, + "m_Path": "Shader Graphs", + "m_ConcretePrecision": 0, + "m_PreviewMode": 2, + "m_OutputNode": { + "m_Id": "" + }, + "m_ActiveTargets": [ + { + "m_Id": "6c9fa4d78a8b410c848e9db6fec4cae5" + } + ] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.ColorRGBMaterialSlot", + "m_ObjectId": "02a7c828595a4ec8a3e9d7a568a4b49a", + "m_Id": 0, + "m_DisplayName": "Base Color", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "BaseColor", + "m_StageCapability": 2, + "m_Value": { + "x": 0.5, + "y": 0.5, + "z": 0.5 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0 + }, + "m_Labels": [], + "m_ColorMode": 0, + "m_DefaultColor": { + "r": 0.5, + "g": 0.5, + "b": 0.5, + "a": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.UVMaterialSlot", + "m_ObjectId": "043b93100eae413fb9aaf8b21e750d98", + "m_Id": 2, + "m_DisplayName": "UV", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "UV", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0 + }, + "m_Labels": [], + "m_Channel": 0 +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.PropertyNode", + "m_ObjectId": "08215151f8264accae52ffaeb3798150", + "m_Group": { + "m_Id": "" + }, + "m_Name": "Property", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -1762.0, + "y": -249.0, + "width": 139.0, + "height": 34.0 + } + }, + "m_Slots": [ + { + "m_Id": "3126fcd00d6e42fb82aa4de1cd9e45ce" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_Property": { + "m_Id": "dfba2e664b854d7da03879c577fca0d8" + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "0bb9984794da4bc8b9cf1f64d12d97af", + "m_Id": 0, + "m_DisplayName": "A", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "A", + "m_StageCapability": 3, + "m_Value": { + "x": 1.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.MultiplyNode", + "m_ObjectId": "0e59a7f4c22e4e5ea15447c089ba0908", + "m_Group": { + "m_Id": "" + }, + "m_Name": "Multiply", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -1400.9998779296875, + "y": 1000.0, + "width": 130.0, + "height": 118.00000762939453 + } + }, + "m_Slots": [ + { + "m_Id": "a45955955d274df68f3bdaed76f315b7" + }, + { + "m_Id": "d999bd4137f243f3b1420b3423035766" + }, + { + "m_Id": "c823b277c66e444f929cf759a730f6d4" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector2MaterialSlot", + "m_ObjectId": "1318e82d404f453dac6bb6db9d9ab786", + "m_Id": 0, + "m_DisplayName": "Out", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0 + }, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector2MaterialSlot", + "m_ObjectId": "13d3baf753e845edbe96241a8bc59b3a", + "m_Id": 2, + "m_DisplayName": "Offset", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "Offset", + "m_StageCapability": 3, + "m_Value": { + "x": -0.5, + "y": -0.5 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0 + }, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "1509113565e844429dd28d2957cda099", + "m_Id": 0, + "m_DisplayName": "Iris Depth", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 1, + "m_Type": "UnityEditor.ShaderGraph.PositionNode", + "m_ObjectId": "156f557746454fa4b8283e362ec920d8", + "m_Group": { + "m_Id": "" + }, + "m_Name": "Position", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -844.9999389648438, + "y": -572.9999389648438, + "width": 207.99998474121095, + "height": 315.9999694824219 + } + }, + "m_Slots": [ + { + "m_Id": "417efec4074c4635ad8760fc7666b9fd" + } + ], + "synonyms": [], + "m_Precision": 1, + "m_PreviewExpanded": true, + "m_PreviewMode": 2, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_Space": 0 +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.OneMinusNode", + "m_ObjectId": "184ba437bcdd44ba8404aa50c843e3ee", + "m_Group": { + "m_Id": "" + }, + "m_Name": "One Minus", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -1575.999755859375, + "y": 940.0, + "width": 128.0, + "height": 94.0 + } + }, + "m_Slots": [ + { + "m_Id": "8f970bf159e04d1cbb7005aad21e34d4" + }, + { + "m_Id": "4861b12fe4a8468a877b794a0205e598" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "1dab4a164d7b4a55b957258e4fc44393", + "m_Id": 4, + "m_DisplayName": "R", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "R", + "m_StageCapability": 2, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicValueMaterialSlot", + "m_ObjectId": "241f917cc8be4bcdbda8e5b470ee1d6d", + "m_Id": 2, + "m_DisplayName": "Out", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": { + "e00": 0.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 0.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 0.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 0.0 + }, + "m_DefaultValue": { + "e00": 1.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 1.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 1.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Texture2DInputMaterialSlot", + "m_ObjectId": "272db3af3b6e4d718800145ec42a3e70", + "m_Id": 1, + "m_DisplayName": "Texture", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "Texture", + "m_StageCapability": 3, + "m_BareResource": false, + "m_Texture": { + "m_SerializedTexture": "{\"texture\":{\"instanceID\":0}}", + "m_Guid": "" + }, + "m_DefaultType": 0 +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "27bdaaa695d14834adc080a85d107304", + "m_Id": 7, + "m_DisplayName": "A", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "A", + "m_StageCapability": 2, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicValueMaterialSlot", + "m_ObjectId": "28b05ba0ad0b49068908ea9a04f5a2a3", + "m_Id": 0, + "m_DisplayName": "A", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "A", + "m_StageCapability": 3, + "m_Value": { + "e00": 0.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 0.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 0.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 0.0 + }, + "m_DefaultValue": { + "e00": 1.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 1.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 1.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicValueMaterialSlot", + "m_ObjectId": "2a46a8db16cc4435b0585e0334222c72", + "m_Id": 1, + "m_DisplayName": "B", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "B", + "m_StageCapability": 3, + "m_Value": { + "e00": 2.0, + "e01": 2.0, + "e02": 2.0, + "e03": 2.0, + "e10": 2.0, + "e11": 2.0, + "e12": 2.0, + "e13": 2.0, + "e20": 2.0, + "e21": 2.0, + "e22": 2.0, + "e23": 2.0, + "e30": 2.0, + "e31": 2.0, + "e32": 2.0, + "e33": 2.0 + }, + "m_DefaultValue": { + "e00": 1.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 1.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 1.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.SampleTexture2DNode", + "m_ObjectId": "2bef449599564fb3822fd4e75d52d7d6", + "m_Group": { + "m_Id": "" + }, + "m_Name": "Sample Texture 2D", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -845.0001220703125, + "y": 324.0000305175781, + "width": 184.0, + "height": 253.0 + } + }, + "m_Slots": [ + { + "m_Id": "fe45125fc1744e8993b5211ced384cb3" + }, + { + "m_Id": "2e960e760d764d0295af244a419ad5b9" + }, + { + "m_Id": "3bc0e95f9fdd4e71a86c973ff5ff82e8" + }, + { + "m_Id": "497ed4f250c04da59c4156805d048287" + }, + { + "m_Id": "4e30b407f84845589f3d2730936e6322" + }, + { + "m_Id": "a42146fb84af483592af56fd3f884fa4" + }, + { + "m_Id": "d4f2907a973d4ecf92b023e7b18f43e3" + }, + { + "m_Id": "4b5dbc925316472d996a8881970eac5c" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_TextureType": 0, + "m_NormalMapSpace": 0 +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.Rendering.HighDefinition.ShaderGraph.SystemData", + "m_ObjectId": "2e34e731cfd3410eb9c8357be7b3f5ca", + "m_MaterialNeedsUpdateHash": 529, + "m_SurfaceType": 0, + "m_RenderingPass": 1, + "m_BlendMode": 0, + "m_ZTest": 4, + "m_ZWrite": false, + "m_TransparentCullMode": 2, + "m_OpaqueCullMode": 2, + "m_SortPriority": 0, + "m_AlphaTest": false, + "m_TransparentDepthPrepass": false, + "m_TransparentDepthPostpass": false, + "m_SupportLodCrossFade": false, + "m_DoubleSidedMode": 0, + "m_DOTSInstancing": false, + "m_Version": 0, + "m_FirstTimeMigrationExecuted": true, + "inspectorFoldoutMask": 9 +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "2e960e760d764d0295af244a419ad5b9", + "m_Id": 4, + "m_DisplayName": "R", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "R", + "m_StageCapability": 2, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Texture2DMaterialSlot", + "m_ObjectId": "3126fcd00d6e42fb82aa4de1cd9e45ce", + "m_Id": 0, + "m_DisplayName": "Mask Map", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_BareResource": false +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.MultiplyNode", + "m_ObjectId": "3a9a84efd47842bf8cfb51363959c295", + "m_Group": { + "m_Id": "" + }, + "m_Name": "Multiply", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -844.9999389648438, + "y": -215.0, + "width": 208.0, + "height": 302.0 + } + }, + "m_Slots": [ + { + "m_Id": "28b05ba0ad0b49068908ea9a04f5a2a3" + }, + { + "m_Id": "2a46a8db16cc4435b0585e0334222c72" + }, + { + "m_Id": "553e25da0e7d4cfeb6b40eb689c04127" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector3MaterialSlot", + "m_ObjectId": "3ba7a29454784381bb3a6db8134124b9", + "m_Id": 0, + "m_DisplayName": "Out", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0 + }, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "3bc0e95f9fdd4e71a86c973ff5ff82e8", + "m_Id": 5, + "m_DisplayName": "G", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "G", + "m_StageCapability": 2, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector3MaterialSlot", + "m_ObjectId": "417efec4074c4635ad8760fc7666b9fd", + "m_Id": 0, + "m_DisplayName": "Out", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0 + }, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "4861b12fe4a8468a877b794a0205e598", + "m_Id": 1, + "m_DisplayName": "Out", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "497ed4f250c04da59c4156805d048287", + "m_Id": 6, + "m_DisplayName": "B", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "B", + "m_StageCapability": 2, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "49a6685efef54ddc9a6e669fb9a94595", + "m_Id": 0, + "m_DisplayName": "Metallic", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "Metallic", + "m_StageCapability": 2, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.SamplerStateMaterialSlot", + "m_ObjectId": "4b5dbc925316472d996a8881970eac5c", + "m_Id": 3, + "m_DisplayName": "Sampler", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "Sampler", + "m_StageCapability": 3, + "m_BareResource": false +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "4e30b407f84845589f3d2730936e6322", + "m_Id": 7, + "m_DisplayName": "A", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "A", + "m_StageCapability": 2, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "4fd7b5b635df4b28991c8b9c354e7501", + "m_Id": 3, + "m_DisplayName": "Z", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "Z", + "m_StageCapability": 3, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [ + "Z" + ] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicValueMaterialSlot", + "m_ObjectId": "52b8db69a4c14f1c8cb0a1448bfec741", + "m_Id": 0, + "m_DisplayName": "A", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "A", + "m_StageCapability": 3, + "m_Value": { + "e00": 0.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 0.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 0.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 0.0 + }, + "m_DefaultValue": { + "e00": 1.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 1.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 1.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Internal.Texture2DShaderProperty", + "m_ObjectId": "52f02aeee7404dfda840641c91caeddb", + "m_Guid": { + "m_GuidSerialized": "d7c203bd-4eeb-4357-a6bd-f218fd954f2d" + }, + "m_Name": "Base Color Map", + "m_DefaultReferenceName": "Texture2D_52f02aeee7404dfda840641c91caeddb", + "m_OverrideReferenceName": "_BaseColorMap", + "m_GeneratePropertyBlock": true, + "m_Precision": 0, + "overrideHLSLDeclaration": false, + "hlslDeclarationOverride": 0, + "m_Hidden": false, + "m_Value": { + "m_SerializedTexture": "{\"texture\":{\"instanceID\":0}}", + "m_Guid": "" + }, + "m_Modifiable": true, + "m_DefaultType": 0 +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicValueMaterialSlot", + "m_ObjectId": "553e25da0e7d4cfeb6b40eb689c04127", + "m_Id": 2, + "m_DisplayName": "Out", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": { + "e00": 0.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 0.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 0.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 0.0 + }, + "m_DefaultValue": { + "e00": 1.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 1.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 1.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "5643e7089a9b4f5e9f095815e82fed3f", + "m_Id": 1, + "m_DisplayName": "B", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "B", + "m_StageCapability": 3, + "m_Value": { + "x": 1.0, + "y": 1.0, + "z": 1.0, + "w": 1.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "57563220c9e1430cb8c54fd1f53fe97d", + "m_Id": 0, + "m_DisplayName": "", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "580e244d2770488fb12832dd65cfb154", + "m_Id": 6, + "m_DisplayName": "G", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "G", + "m_StageCapability": 3, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DivideNode", + "m_ObjectId": "5becb5ea83c943d8ac512fecbed6ffac", + "m_Group": { + "m_Id": "" + }, + "m_Name": "Divide", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -1749.0, + "y": 818.9999389648438, + "width": 126.00000762939453, + "height": 118.00000762939453 + } + }, + "m_Slots": [ + { + "m_Id": "9def10245fc44f68bfff3f9c00332ccf" + }, + { + "m_Id": "91a80dac2deb45ef84b125402e590ca7" + }, + { + "m_Id": "fb4703bf852d4f4d904f8b9e02b4dd20" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.LerpNode", + "m_ObjectId": "5cd9382b2a024acc987edc47bfa51fad", + "m_Group": { + "m_Id": "" + }, + "m_Name": "Lerp", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -2007.0, + "y": 840.0000610351563, + "width": 126.00000762939453, + "height": 142.0 + } + }, + "m_Slots": [ + { + "m_Id": "0bb9984794da4bc8b9cf1f64d12d97af" + }, + { + "m_Id": "5643e7089a9b4f5e9f095815e82fed3f" + }, + { + "m_Id": "97e59b8276c74314a5d187b09c1505ed" + }, + { + "m_Id": "cfbd0be54c814652a62dd2c24979aba1" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.SamplerStateMaterialSlot", + "m_ObjectId": "5e66f23874224141a1c149be3d351c66", + "m_Id": 3, + "m_DisplayName": "Sampler", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "Sampler", + "m_StageCapability": 3, + "m_BareResource": false +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.SampleTexture2DNode", + "m_ObjectId": "5f2191730fba43239d38db446558a163", + "m_Group": { + "m_Id": "" + }, + "m_Name": "Sample Texture 2D", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -2561.0, + "y": 653.0, + "width": 184.0, + "height": 253.00001525878907 + } + }, + "m_Slots": [ + { + "m_Id": "b2202dfccca549a8b516b7ce9278b386" + }, + { + "m_Id": "1dab4a164d7b4a55b957258e4fc44393" + }, + { + "m_Id": "d93ae1729b65461c85c73a8178be4b1a" + }, + { + "m_Id": "dd945389630c4a5a896f72ab3750585a" + }, + { + "m_Id": "27bdaaa695d14834adc080a85d107304" + }, + { + "m_Id": "272db3af3b6e4d718800145ec42a3e70" + }, + { + "m_Id": "e5f45cf401034ee4bf97d73d48bb700e" + }, + { + "m_Id": "5e66f23874224141a1c149be3d351c66" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_TextureType": 0, + "m_NormalMapSpace": 0 +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.BlockNode", + "m_ObjectId": "5f2a85f2be60457c910ca347ab57af46", + "m_Group": { + "m_Id": "" + }, + "m_Name": "SurfaceDescription.BaseColor", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": 0.0, + "y": 0.0, + "width": 0.0, + "height": 0.0 + } + }, + "m_Slots": [ + { + "m_Id": "02a7c828595a4ec8a3e9d7a568a4b49a" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_SerializedDescriptor": "SurfaceDescription.BaseColor" +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.NormalMaterialSlot", + "m_ObjectId": "620418c7f64f48e795fd7afa252031b7", + "m_Id": 0, + "m_DisplayName": "Normal (Tangent Space)", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "NormalTS", + "m_StageCapability": 2, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0 + }, + "m_Labels": [], + "m_Space": 3 +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.Rendering.HighDefinition.ShaderGraph.HDLitData", + "m_ObjectId": "637f03eae68a40db8bc27c0c8b79c1a5", + "m_RayTracing": false, + "m_MaterialType": 0, + "m_RefractionModel": 0, + "m_SSSTransmission": true, + "m_EnergyConservingSpecular": true, + "m_ClearCoat": false +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.SampleTexture2DLODNode", + "m_ObjectId": "6719ad891bc64c5282ba6b76000e03ce", + "m_Group": { + "m_Id": "" + }, + "m_Name": "Sample Texture 2D LOD", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -1525.0001220703125, + "y": -257.0, + "width": 184.0, + "height": 253.0 + } + }, + "m_Slots": [ + { + "m_Id": "b5f630398c8f46d5a284578010a11e52" + }, + { + "m_Id": "b33020cf882642958d217c21ad348d3b" + }, + { + "m_Id": "580e244d2770488fb12832dd65cfb154" + }, + { + "m_Id": "706c2f4c16f442f69a16dbf91c668c49" + }, + { + "m_Id": "78b516425ab44d98ae8e3c95d9d2074d" + }, + { + "m_Id": "6a8c2df2e5c2465ca5647ec2ffc1b6ff" + }, + { + "m_Id": "043b93100eae413fb9aaf8b21e750d98" + }, + { + "m_Id": "c378d63dc9a74d89b8d9833ab398d7a9" + }, + { + "m_Id": "f78b6edcba8f42f8b15a2c6ba786ce62" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_TextureType": 0, + "m_NormalMapSpace": 0 +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.Rendering.HighDefinition.ShaderGraph.BuiltinData", + "m_ObjectId": "68463861e35c4439bee6116390447805", + "m_Distortion": false, + "m_DistortionMode": 0, + "m_DistortionDepthTest": true, + "m_AddPrecomputedVelocity": false, + "m_TransparentWritesMotionVec": false, + "m_AlphaToMask": false, + "m_DepthOffset": false, + "m_TransparencyFog": true, + "m_AlphaTestShadow": false, + "m_BackThenFrontRendering": false, + "m_TransparentDepthPrepass": false, + "m_TransparentDepthPostpass": false, + "m_SupportLodCrossFade": false +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.SubtractNode", + "m_ObjectId": "696a08a4d44b4f65bca2437d68fa6d3d", + "m_Group": { + "m_Id": "" + }, + "m_Name": "Subtract", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -496.5626220703125, + "y": -400.5625915527344, + "width": 208.0, + "height": 302.0 + } + }, + "m_Slots": [ + { + "m_Id": "a8bfa723adfd4a24ba9bc82bbe5d29dd" + }, + { + "m_Id": "93320a1d72d84ecc9f6980bc8283f9cf" + }, + { + "m_Id": "f04363b38c1846e9b050b04cdce9a74c" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.ColorRGBMaterialSlot", + "m_ObjectId": "6a3b16487d02465481e710ed226650fd", + "m_Id": 0, + "m_DisplayName": "Emission", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "Emission", + "m_StageCapability": 2, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0 + }, + "m_Labels": [], + "m_ColorMode": 1, + "m_DefaultColor": { + "r": 0.0, + "g": 0.0, + "b": 0.0, + "a": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Texture2DInputMaterialSlot", + "m_ObjectId": "6a8c2df2e5c2465ca5647ec2ffc1b6ff", + "m_Id": 1, + "m_DisplayName": "Texture", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "Texture", + "m_StageCapability": 3, + "m_BareResource": false, + "m_Texture": { + "m_SerializedTexture": "{\"texture\":{\"instanceID\":0}}", + "m_Guid": "" + }, + "m_DefaultType": 0 +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.Rendering.HighDefinition.ShaderGraph.HDTarget", + "m_ObjectId": "6c9fa4d78a8b410c848e9db6fec4cae5", + "m_ActiveSubTarget": { + "m_Id": "a014f23373ea4c7dbb0fdf4620bf28ec" + }, + "m_Datas": [ + { + "m_Id": "637f03eae68a40db8bc27c0c8b79c1a5" + }, + { + "m_Id": "68463861e35c4439bee6116390447805" + }, + { + "m_Id": "c8bd46e85aca4f1bbef633b6ce9b7b5b" + }, + { + "m_Id": "2e34e731cfd3410eb9c8357be7b3f5ca" + } + ], + "m_CustomEditorGUI": "" +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "706c2f4c16f442f69a16dbf91c668c49", + "m_Id": 7, + "m_DisplayName": "B", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "B", + "m_StageCapability": 3, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.NormalMaterialSlot", + "m_ObjectId": "71da8d209d9f42e5b1d60a290356fa7f", + "m_Id": 0, + "m_DisplayName": "Normal", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "Normal", + "m_StageCapability": 1, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0 + }, + "m_Labels": [], + "m_Space": 0 +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector3Node", + "m_ObjectId": "74c8d8dd779247ba849a24460c6f7076", + "m_Group": { + "m_Id": "" + }, + "m_Name": "Vector 3", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -1163.9998779296875, + "y": -255.0, + "width": 128.0, + "height": 125.0 + } + }, + "m_Slots": [ + { + "m_Id": "8ff941b238ac413095c3b24e970c5b86" + }, + { + "m_Id": "dd1c4182f9514bcf847c26a7c5aae174" + }, + { + "m_Id": "4fd7b5b635df4b28991c8b9c354e7501" + }, + { + "m_Id": "3ba7a29454784381bb3a6db8134124b9" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "78b516425ab44d98ae8e3c95d9d2074d", + "m_Id": 8, + "m_DisplayName": "A", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "A", + "m_StageCapability": 3, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "7c82496097944027abdc5faeb810856c", + "m_Id": 1, + "m_DisplayName": "", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "81fe30b62be541bca04993f28c70907d", + "m_Id": 0, + "m_DisplayName": "Smoothness", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "Smoothness", + "m_StageCapability": 2, + "m_Value": 0.5, + "m_DefaultValue": 0.5, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicValueMaterialSlot", + "m_ObjectId": "83f1c8120d9c44de842b253b6866e3b3", + "m_Id": 1, + "m_DisplayName": "B", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "B", + "m_StageCapability": 3, + "m_Value": { + "e00": 0.019999999552965165, + "e01": 2.0, + "e02": 2.0, + "e03": 2.0, + "e10": 2.0, + "e11": 2.0, + "e12": 2.0, + "e13": 2.0, + "e20": 2.0, + "e21": 2.0, + "e22": 2.0, + "e23": 2.0, + "e30": 2.0, + "e31": 2.0, + "e32": 2.0, + "e33": 2.0 + }, + "m_DefaultValue": { + "e00": 1.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 1.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 1.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.BlockNode", + "m_ObjectId": "8cbb7b1e46ae4b408b7db7abad3b8f4b", + "m_Group": { + "m_Id": "" + }, + "m_Name": "SurfaceDescription.NormalTS", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": 0.0, + "y": 0.0, + "width": 0.0, + "height": 0.0 + } + }, + "m_Slots": [ + { + "m_Id": "620418c7f64f48e795fd7afa252031b7" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_SerializedDescriptor": "SurfaceDescription.NormalTS" +} + +{ + "m_SGVersion": 1, + "m_Type": "UnityEditor.ShaderGraph.Internal.Vector1ShaderProperty", + "m_ObjectId": "8ece50505af046fab4f259d189770780", + "m_Guid": { + "m_GuidSerialized": "b04682f8-7252-41a1-8872-34c8537ecff3" + }, + "m_Name": "Pupil Scale", + "m_DefaultReferenceName": "Vector1_8ece50505af046fab4f259d189770780", + "m_OverrideReferenceName": "_PupilScale", + "m_GeneratePropertyBlock": true, + "m_Precision": 0, + "overrideHLSLDeclaration": false, + "hlslDeclarationOverride": 0, + "m_Hidden": false, + "m_Value": 1.0, + "m_FloatType": 1, + "m_RangeValues": { + "x": 0.25, + "y": 2.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "8f970bf159e04d1cbb7005aad21e34d4", + "m_Id": 0, + "m_DisplayName": "In", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "In", + "m_StageCapability": 3, + "m_Value": { + "x": 1.0, + "y": 1.0, + "z": 1.0, + "w": 1.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "8ff941b238ac413095c3b24e970c5b86", + "m_Id": 1, + "m_DisplayName": "X", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "X", + "m_StageCapability": 3, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "91a80dac2deb45ef84b125402e590ca7", + "m_Id": 1, + "m_DisplayName": "B", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "B", + "m_StageCapability": 3, + "m_Value": { + "x": 2.0, + "y": 2.0, + "z": 2.0, + "w": 2.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "921a4184990f418abbdc6758af2c7a9e", + "m_Id": 1, + "m_DisplayName": "X", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "X", + "m_StageCapability": 3, + "m_Value": 0.5, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.BlockNode", + "m_ObjectId": "92f838491ba947f584a076eaa4a5fad1", + "m_Group": { + "m_Id": "" + }, + "m_Name": "SurfaceDescription.Metallic", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": 0.0, + "y": 0.0, + "width": 0.0, + "height": 0.0 + } + }, + "m_Slots": [ + { + "m_Id": "49a6685efef54ddc9a6e669fb9a94595" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_SerializedDescriptor": "SurfaceDescription.Metallic" +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "93320a1d72d84ecc9f6980bc8283f9cf", + "m_Id": 1, + "m_DisplayName": "B", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "B", + "m_StageCapability": 3, + "m_Value": { + "x": 1.0, + "y": 1.0, + "z": 1.0, + "w": 1.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "95c6440ec05e42cea53846aa79190fb4", + "m_Id": 2, + "m_DisplayName": "Y", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "Y", + "m_StageCapability": 3, + "m_Value": 0.5, + "m_DefaultValue": 0.0, + "m_Labels": [ + "Y" + ] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.BlockNode", + "m_ObjectId": "9793273e24544c1487e7f5a12fb16336", + "m_Group": { + "m_Id": "" + }, + "m_Name": "SurfaceDescription.BentNormal", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": 0.0, + "y": 0.0, + "width": 0.0, + "height": 0.0 + } + }, + "m_Slots": [ + { + "m_Id": "e89b366a22064048a074aafaf48a4670" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_SerializedDescriptor": "SurfaceDescription.BentNormal" +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "97e59b8276c74314a5d187b09c1505ed", + "m_Id": 2, + "m_DisplayName": "T", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "T", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector2MaterialSlot", + "m_ObjectId": "9b1065bcb626436588b791a345d2e3d7", + "m_Id": 3, + "m_DisplayName": "Out", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0 + }, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "9bc3a8ab7d954077ae6dafd1254e7e81", + "m_Id": 0, + "m_DisplayName": "Alpha", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "Alpha", + "m_StageCapability": 2, + "m_Value": 1.0, + "m_DefaultValue": 1.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.MultiplyNode", + "m_ObjectId": "9dd1c77fb00c4649a5d4c260bb5148d5", + "m_Group": { + "m_Id": "" + }, + "m_Name": "Multiply", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -1164.0, + "y": -106.99998474121094, + "width": 126.0, + "height": 118.0 + } + }, + "m_Slots": [ + { + "m_Id": "52b8db69a4c14f1c8cb0a1448bfec741" + }, + { + "m_Id": "83f1c8120d9c44de842b253b6866e3b3" + }, + { + "m_Id": "241f917cc8be4bcdbda8e5b470ee1d6d" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "9def10245fc44f68bfff3f9c00332ccf", + "m_Id": 0, + "m_DisplayName": "A", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "A", + "m_StageCapability": 3, + "m_Value": { + "x": 1.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.Rendering.HighDefinition.ShaderGraph.HDLitSubTarget", + "m_ObjectId": "a014f23373ea4c7dbb0fdf4620bf28ec" +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Texture2DInputMaterialSlot", + "m_ObjectId": "a42146fb84af483592af56fd3f884fa4", + "m_Id": 1, + "m_DisplayName": "Texture", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "Texture", + "m_StageCapability": 3, + "m_BareResource": false, + "m_Texture": { + "m_SerializedTexture": "{\"texture\":{\"instanceID\":0}}", + "m_Guid": "" + }, + "m_DefaultType": 0 +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicValueMaterialSlot", + "m_ObjectId": "a45955955d274df68f3bdaed76f315b7", + "m_Id": 0, + "m_DisplayName": "A", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "A", + "m_StageCapability": 3, + "m_Value": { + "e00": 0.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 0.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 0.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 0.0 + }, + "m_DefaultValue": { + "e00": 1.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 1.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 1.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.PositionMaterialSlot", + "m_ObjectId": "a47863e6d17b41afa7c199e1a6ed0d54", + "m_Id": 0, + "m_DisplayName": "Position", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "Position", + "m_StageCapability": 1, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0 + }, + "m_Labels": [], + "m_Space": 0 +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.BlockNode", + "m_ObjectId": "a4ac7b4160ba47c98dc6e20c28ba81ea", + "m_Group": { + "m_Id": "" + }, + "m_Name": "SurfaceDescription.Alpha", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": 12.999983787536621, + "y": 317.0, + "width": 200.00001525878907, + "height": 41.000003814697269 + } + }, + "m_Slots": [ + { + "m_Id": "9bc3a8ab7d954077ae6dafd1254e7e81" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_SerializedDescriptor": "SurfaceDescription.Alpha" +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "a8bfa723adfd4a24ba9bc82bbe5d29dd", + "m_Id": 0, + "m_DisplayName": "A", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "A", + "m_StageCapability": 3, + "m_Value": { + "x": 1.0, + "y": 1.0, + "z": 1.0, + "w": 1.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.PropertyNode", + "m_ObjectId": "ad0b8c720afc4dff858361e65627778b", + "m_Group": { + "m_Id": "" + }, + "m_Name": "Property", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -2258.0, + "y": 906.0, + "width": 133.0, + "height": 34.0 + } + }, + "m_Slots": [ + { + "m_Id": "dced7c8290b94cf4b7e9494d334a719a" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_Property": { + "m_Id": "8ece50505af046fab4f259d189770780" + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector4MaterialSlot", + "m_ObjectId": "b2202dfccca549a8b516b7ce9278b386", + "m_Id": 0, + "m_DisplayName": "RGBA", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "RGBA", + "m_StageCapability": 2, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.TangentMaterialSlot", + "m_ObjectId": "b2e23e8f51a04fa09119e52cb2a13bbc", + "m_Id": 0, + "m_DisplayName": "Tangent", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "Tangent", + "m_StageCapability": 1, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0 + }, + "m_Labels": [], + "m_Space": 0 +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "b33020cf882642958d217c21ad348d3b", + "m_Id": 5, + "m_DisplayName": "R", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "R", + "m_StageCapability": 3, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "b42f4dec14364c25b1f355bed3a3b47d", + "m_Id": 0, + "m_DisplayName": "Ambient Occlusion", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "Occlusion", + "m_StageCapability": 2, + "m_Value": 1.0, + "m_DefaultValue": 1.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector4MaterialSlot", + "m_ObjectId": "b5f630398c8f46d5a284578010a11e52", + "m_Id": 0, + "m_DisplayName": "RGBA", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "RGBA", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.RedirectNodeData", + "m_ObjectId": "ba28e30a615c49eead26ea0709253381", + "m_Group": { + "m_Id": "" + }, + "m_Name": "Redirect Node", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -2222.0, + "y": 958.0, + "width": 56.0, + "height": 24.000001907348634 + } + }, + "m_Slots": [ + { + "m_Id": "57563220c9e1430cb8c54fd1f53fe97d" + }, + { + "m_Id": "7c82496097944027abdc5faeb810856c" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.BlockNode", + "m_ObjectId": "bbb748d7daeb4992a717c5199d0bc690", + "m_Group": { + "m_Id": "" + }, + "m_Name": "SurfaceDescription.Emission", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": 0.0, + "y": 0.0, + "width": 0.0, + "height": 0.0 + } + }, + "m_Slots": [ + { + "m_Id": "6a3b16487d02465481e710ed226650fd" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_SerializedDescriptor": "SurfaceDescription.Emission" +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.BlockNode", + "m_ObjectId": "bcfdce6c0ab14b7990e1c860fcd647e2", + "m_Group": { + "m_Id": "" + }, + "m_Name": "VertexDescription.Position", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": 0.0, + "y": 0.0, + "width": 0.0, + "height": 0.0 + } + }, + "m_Slots": [ + { + "m_Id": "a47863e6d17b41afa7c199e1a6ed0d54" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_SerializedDescriptor": "VertexDescription.Position" +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.SamplerStateMaterialSlot", + "m_ObjectId": "c378d63dc9a74d89b8d9833ab398d7a9", + "m_Id": 3, + "m_DisplayName": "Sampler", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "Sampler", + "m_StageCapability": 3, + "m_BareResource": false +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.BlockNode", + "m_ObjectId": "c508a09dcb7f4f06aa0f8ecf9e96259c", + "m_Group": { + "m_Id": "" + }, + "m_Name": "SurfaceDescription.Smoothness", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": 15.999985694885254, + "y": 555.0, + "width": 200.00001525878907, + "height": 41.000003814697269 + } + }, + "m_Slots": [ + { + "m_Id": "81fe30b62be541bca04993f28c70907d" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_SerializedDescriptor": "SurfaceDescription.Smoothness" +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicValueMaterialSlot", + "m_ObjectId": "c823b277c66e444f929cf759a730f6d4", + "m_Id": 2, + "m_DisplayName": "Out", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": { + "e00": 0.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 0.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 0.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 0.0 + }, + "m_DefaultValue": { + "e00": 1.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 1.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 1.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.Rendering.HighDefinition.ShaderGraph.LightingData", + "m_ObjectId": "c8bd46e85aca4f1bbef633b6ce9b7b5b", + "m_NormalDropOffSpace": 0, + "m_BlendPreserveSpecular": true, + "m_ReceiveDecals": true, + "m_ReceiveSSR": true, + "m_ReceiveSSRTransparent": false, + "m_SpecularAA": false, + "m_SpecularOcclusionMode": 0, + "m_OverrideBakedGI": false +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "cfbd0be54c814652a62dd2c24979aba1", + "m_Id": 3, + "m_DisplayName": "Out", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.UVMaterialSlot", + "m_ObjectId": "d4f2907a973d4ecf92b023e7b18f43e3", + "m_Id": 2, + "m_DisplayName": "UV", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "UV", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0 + }, + "m_Labels": [], + "m_Channel": 0 +} + +{ + "m_SGVersion": 1, + "m_Type": "UnityEditor.ShaderGraph.Internal.Vector1ShaderProperty", + "m_ObjectId": "d5d122eed44b41ae84d69f8bb777e94b", + "m_Guid": { + "m_GuidSerialized": "70f711d0-f83e-47ba-b6d6-045b8b6b08d6" + }, + "m_Name": "Iris Depth", + "m_DefaultReferenceName": "Vector1_d5d122eed44b41ae84d69f8bb777e94b", + "m_OverrideReferenceName": "_IrisDepth", + "m_GeneratePropertyBlock": true, + "m_Precision": 0, + "overrideHLSLDeclaration": false, + "hlslDeclarationOverride": 0, + "m_Hidden": false, + "m_Value": 0.004000000189989805, + "m_FloatType": 1, + "m_RangeValues": { + "x": 0.0, + "y": 0.009999999776482582 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Texture2DMaterialSlot", + "m_ObjectId": "d7abcf29e4864a28a9f77a2a5124bf1d", + "m_Id": 0, + "m_DisplayName": "Base Color Map", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_BareResource": false +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.PropertyNode", + "m_ObjectId": "d7dfcec608db4609a4374b3c9a84ef32", + "m_Group": { + "m_Id": "" + }, + "m_Name": "Property", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -1468.0, + "y": 53.0, + "width": 127.0, + "height": 34.0 + } + }, + "m_Slots": [ + { + "m_Id": "1509113565e844429dd28d2957cda099" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_Property": { + "m_Id": "d5d122eed44b41ae84d69f8bb777e94b" + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.TilingAndOffsetNode", + "m_ObjectId": "d903631d751145939c27b46b27bdc593", + "m_Group": { + "m_Id": "" + }, + "m_Name": "Tiling And Offset", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -1186.999755859375, + "y": 795.0000610351563, + "width": 155.0, + "height": 142.0 + } + }, + "m_Slots": [ + { + "m_Id": "e8c01b21c53c476faf28c4c959815547" + }, + { + "m_Id": "fcc74d749b15491e9e5c99c95dba6d8f" + }, + { + "m_Id": "13d3baf753e845edbe96241a8bc59b3a" + }, + { + "m_Id": "9b1065bcb626436588b791a345d2e3d7" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "d93ae1729b65461c85c73a8178be4b1a", + "m_Id": 5, + "m_DisplayName": "G", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "G", + "m_StageCapability": 2, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector2Node", + "m_ObjectId": "d9954637b73947b99d89ef5a3fe791b8", + "m_Group": { + "m_Id": "" + }, + "m_Name": "Vector 2", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -1576.9998779296875, + "y": 1084.0001220703125, + "width": 128.0, + "height": 101.0 + } + }, + "m_Slots": [ + { + "m_Id": "921a4184990f418abbdc6758af2c7a9e" + }, + { + "m_Id": "95c6440ec05e42cea53846aa79190fb4" + }, + { + "m_Id": "1318e82d404f453dac6bb6db9d9ab786" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_Value": { + "x": 0.0, + "y": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicValueMaterialSlot", + "m_ObjectId": "d999bd4137f243f3b1420b3423035766", + "m_Id": 1, + "m_DisplayName": "B", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "B", + "m_StageCapability": 3, + "m_Value": { + "e00": 2.0, + "e01": 2.0, + "e02": 2.0, + "e03": 2.0, + "e10": 2.0, + "e11": 2.0, + "e12": 2.0, + "e13": 2.0, + "e20": 2.0, + "e21": 2.0, + "e22": 2.0, + "e23": 2.0, + "e30": 2.0, + "e31": 2.0, + "e32": 2.0, + "e33": 2.0 + }, + "m_DefaultValue": { + "e00": 1.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 1.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 1.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "dced7c8290b94cf4b7e9494d334a719a", + "m_Id": 0, + "m_DisplayName": "Pupil Scale", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "dd1c4182f9514bcf847c26a7c5aae174", + "m_Id": 2, + "m_DisplayName": "Y", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "Y", + "m_StageCapability": 3, + "m_Value": -1.0, + "m_DefaultValue": 0.0, + "m_Labels": [ + "Y" + ] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "dd945389630c4a5a896f72ab3750585a", + "m_Id": 6, + "m_DisplayName": "B", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "B", + "m_StageCapability": 2, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.PropertyNode", + "m_ObjectId": "ddf8b777a50c429fb122f94c58d1f101", + "m_Group": { + "m_Id": "" + }, + "m_Name": "Property", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -1187.0001220703125, + "y": 271.0, + "width": 136.0, + "height": 34.0 + } + }, + "m_Slots": [ + { + "m_Id": "d7abcf29e4864a28a9f77a2a5124bf1d" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_Property": { + "m_Id": "52f02aeee7404dfda840641c91caeddb" + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.BlockNode", + "m_ObjectId": "de0c01eb18a547fdbe20f493469a7c6d", + "m_Group": { + "m_Id": "" + }, + "m_Name": "VertexDescription.Normal", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": 0.0, + "y": 0.0, + "width": 0.0, + "height": 0.0 + } + }, + "m_Slots": [ + { + "m_Id": "71da8d209d9f42e5b1d60a290356fa7f" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_SerializedDescriptor": "VertexDescription.Normal" +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Internal.Texture2DShaderProperty", + "m_ObjectId": "dfba2e664b854d7da03879c577fca0d8", + "m_Guid": { + "m_GuidSerialized": "da3b3609-5347-47a8-a4ea-b25ea0d3124e" + }, + "m_Name": "Mask Map", + "m_DefaultReferenceName": "Texture2D_dfba2e664b854d7da03879c577fca0d8", + "m_OverrideReferenceName": "_MaskMap", + "m_GeneratePropertyBlock": true, + "m_Precision": 0, + "overrideHLSLDeclaration": false, + "hlslDeclarationOverride": 0, + "m_Hidden": false, + "m_Value": { + "m_SerializedTexture": "{\"texture\":{\"instanceID\":0}}", + "m_Guid": "" + }, + "m_Modifiable": true, + "m_DefaultType": 0 +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.UVMaterialSlot", + "m_ObjectId": "e5f45cf401034ee4bf97d73d48bb700e", + "m_Id": 2, + "m_DisplayName": "UV", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "UV", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0 + }, + "m_Labels": [], + "m_Channel": 0 +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.NormalMaterialSlot", + "m_ObjectId": "e89b366a22064048a074aafaf48a4670", + "m_Id": 0, + "m_DisplayName": "Bent Normal", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "BentNormal", + "m_StageCapability": 2, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0 + }, + "m_Labels": [], + "m_Space": 3 +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.UVMaterialSlot", + "m_ObjectId": "e8c01b21c53c476faf28c4c959815547", + "m_Id": 0, + "m_DisplayName": "UV", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "UV", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0 + }, + "m_Labels": [], + "m_Channel": 0 +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.BlockNode", + "m_ObjectId": "ec6f605ead8f4fd6a96a492279ce0302", + "m_Group": { + "m_Id": "" + }, + "m_Name": "SurfaceDescription.Occlusion", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": 17.000093460083009, + "y": 555.0, + "width": 200.00001525878907, + "height": 41.000003814697269 + } + }, + "m_Slots": [ + { + "m_Id": "b42f4dec14364c25b1f355bed3a3b47d" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_SerializedDescriptor": "SurfaceDescription.Occlusion" +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.BlockNode", + "m_ObjectId": "ee74bc357bc94231a7dfd0efd1b889f3", + "m_Group": { + "m_Id": "" + }, + "m_Name": "VertexDescription.Tangent", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": 0.0, + "y": 0.0, + "width": 0.0, + "height": 0.0 + } + }, + "m_Slots": [ + { + "m_Id": "b2e23e8f51a04fa09119e52cb2a13bbc" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_SerializedDescriptor": "VertexDescription.Tangent" +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.PropertyNode", + "m_ObjectId": "f037fecbc403464fb614598ba9c22b95", + "m_Group": { + "m_Id": "" + }, + "m_Name": "Property", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -2762.0, + "y": 653.0, + "width": 139.0, + "height": 34.0 + } + }, + "m_Slots": [ + { + "m_Id": "fcf3456bc5814a4f8a4f9ae19c517a0a" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_Property": { + "m_Id": "dfba2e664b854d7da03879c577fca0d8" + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "f04363b38c1846e9b050b04cdce9a74c", + "m_Id": 2, + "m_DisplayName": "Out", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "f78b6edcba8f42f8b15a2c6ba786ce62", + "m_Id": 4, + "m_DisplayName": "LOD", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "LOD", + "m_StageCapability": 3, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "fb4703bf852d4f4d904f8b9e02b4dd20", + "m_Id": 2, + "m_DisplayName": "Out", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector2MaterialSlot", + "m_ObjectId": "fcc74d749b15491e9e5c99c95dba6d8f", + "m_Id": 1, + "m_DisplayName": "Tiling", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "Tiling", + "m_StageCapability": 3, + "m_Value": { + "x": 1.0, + "y": 1.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0 + }, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Texture2DMaterialSlot", + "m_ObjectId": "fcf3456bc5814a4f8a4f9ae19c517a0a", + "m_Id": 0, + "m_DisplayName": "Mask Map", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_BareResource": false +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector4MaterialSlot", + "m_ObjectId": "fe45125fc1744e8993b5211ced384cb3", + "m_Id": 0, + "m_DisplayName": "RGBA", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "RGBA", + "m_StageCapability": 2, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_Labels": [] +} + diff --git a/HDRP/Shaders/RL_EyeShaderBaked_HDRP.shadergraph.meta b/HDRP/Shaders/RL_EyeShaderBaked_HDRP.shadergraph.meta new file mode 100644 index 0000000..20b35e4 --- /dev/null +++ b/HDRP/Shaders/RL_EyeShaderBaked_HDRP.shadergraph.meta @@ -0,0 +1,10 @@ +fileFormatVersion: 2 +guid: 1f94846e709e483448feea617906bc23 +ScriptedImporter: + internalIDToNameTable: [] + externalObjects: {} + serializedVersion: 2 + userData: + assetBundleName: + assetBundleVariant: + script: {fileID: 11500000, guid: 625f186215c104763be7675aa2d941aa, type: 3} diff --git a/HDRP/Shaders/RL_EyeShaderVariants_HDRP.shadergraph b/HDRP/Shaders/RL_EyeShaderVariants_HDRP.shadergraph new file mode 100644 index 0000000..09fb6d0 --- /dev/null +++ b/HDRP/Shaders/RL_EyeShaderVariants_HDRP.shadergraph @@ -0,0 +1,18477 @@ +{ + "m_SGVersion": 2, + "m_Type": "UnityEditor.ShaderGraph.GraphData", + "m_ObjectId": "f85a4e4b91df4a7db442a14fde53ed87", + "m_Properties": [ + { + "m_Id": "cb42572a46a74a588ef3935f3a667eb7" + }, + { + "m_Id": "0cbea652f4bf4177942231f39b7c2eea" + }, + { + "m_Id": "5f410167b9c14d43bc4da4f27fdd220a" + }, + { + "m_Id": "3345a7b9279a48b7ba4602df55d812ac" + }, + { + "m_Id": "8a49d2f872e946d4a29e2030ee291584" + }, + { + "m_Id": "daa99c4f268449b8a4e69fdaeafcfe49" + }, + { + "m_Id": "55bf621ad2394320a2ab49a3c7b34fe1" + }, + { + "m_Id": "451cc7559488456fb2d601ba459f41da" + }, + { + "m_Id": "410287977f3941ae86357b91bb50c332" + }, + { + "m_Id": "82fed9724f34448392b89bdd38fe7517" + }, + { + "m_Id": "85e5e0cd46aa44fc8e9f720d375bec49" + }, + { + "m_Id": "6106c8c4dc85475886881929b289ae65" + }, + { + "m_Id": "e2d236b8f7c740b1920bd65df0cef00f" + }, + { + "m_Id": "b618279ad2eb41bd9df25d9f412e0eb1" + }, + { + "m_Id": "596515c1061c4119b6831a17bd392746" + }, + { + "m_Id": "4e48a718329c454b8a46be0bc9bf8802" + }, + { + "m_Id": "a71b2a13bfe64b8fbb07597467c80fb2" + }, + { + "m_Id": "99ad21e27a3f4d3cb1b1736abc28020d" + }, + { + "m_Id": "308a2ce997744f8cb41204c209af692a" + }, + { + "m_Id": "cbcbb78812d84a3ea2eab90a08ba2f3b" + }, + { + "m_Id": "2fe3d3e44e8646f3a00409c36bc1a98e" + }, + { + "m_Id": "ed1d6ae0d0e14a009081ff66d328aa52" + }, + { + "m_Id": "8200a5c208dd40fabbab6b6aca910116" + }, + { + "m_Id": "195319a2066f492abb03e4f9fb29acfb" + }, + { + "m_Id": "ab45ac5b088b42518d305de12d5f3763" + }, + { + "m_Id": "3a3f4cc5a3574e32b762b0cb62cd67cf" + }, + { + "m_Id": "7a4f18355ba84582a3d56ed6b8c69762" + }, + { + "m_Id": "9be1515fae6d42c09957951f4f4fd357" + }, + { + "m_Id": "cd32d6c896b4474aa36ec555723b81ef" + }, + { + "m_Id": "b0ec1f6d5bd0419796b5090e7dffabf7" + }, + { + "m_Id": "f529da1a611a46cda7c335f575a5999b" + }, + { + "m_Id": "13125e3e576e4c76b403dab13948fd74" + }, + { + "m_Id": "424271c2190c4f42b931a851e201c75d" + }, + { + "m_Id": "526ce229950b48d0b6c7cdd0b66dd1e6" + } + ], + "m_Keywords": [ + { + "m_Id": "9d63910b86f7439f9642f08926860a8e" + } + ], + "m_Nodes": [ + { + "m_Id": "4b45669a84054c498babd493511b3189" + }, + { + "m_Id": "0153caa15e554a9bb37fea4238ebdc5b" + }, + { + "m_Id": "00ab9614abb14bfea39934b2abff144b" + }, + { + "m_Id": "8a7ae7a881424567bd38f733cff73869" + }, + { + "m_Id": "bc0c9bafa3544deaaba658da5d1457a2" + }, + { + "m_Id": "08c1176d7dfe406bb0f6283ca763d553" + }, + { + "m_Id": "e701720035d44304a33f4b64350fc6e3" + }, + { + "m_Id": "6a4b619cae09428e850340b327dc2247" + }, + { + "m_Id": "6b280d605cf34b63ae417129545c2f7d" + }, + { + "m_Id": "e1e6ea93dab24d4086de0ce0507e9306" + }, + { + "m_Id": "0556880e701d48e589655db291ee6099" + }, + { + "m_Id": "c2ce8f28915943d49e5539ae59b0b3bf" + }, + { + "m_Id": "84bdfaea919e418dbad1cf44d06dc11b" + }, + { + "m_Id": "c0f127f890774e2987f07ee8f1002231" + }, + { + "m_Id": "d86bbba2a7f544ccb8b0f954a6fd1a83" + }, + { + "m_Id": "42ba018b3a414c4485ab942ebf69a4ad" + }, + { + "m_Id": "8192b535ff4b4c02b8b979c205588649" + }, + { + "m_Id": "71d190547a3c44809862ff43703249c1" + }, + { + "m_Id": "953fa7f504094a569b4c7ca8216cd28c" + }, + { + "m_Id": "48e7aa14004241f09e40927e5502db5f" + }, + { + "m_Id": "63427a74f3e84bfaa8916b46984eb21e" + }, + { + "m_Id": "60690c6170544de7ab05a07916de81aa" + }, + { + "m_Id": "b74b3332d6fe43dda8b59f706cc29f29" + }, + { + "m_Id": "d4adb9f4c12448c78e98d14fb2000ab7" + }, + { + "m_Id": "3c7bca46d3ed4ae5b7df3592da5f774c" + }, + { + "m_Id": "365dce71ec05435a85200a53c1026b6d" + }, + { + "m_Id": "7d0d6e9fb5ad480fa2c294660a419754" + }, + { + "m_Id": "a72ad83bd1eb4a4691d245a59c9e41d5" + }, + { + "m_Id": "512f5c3810b44a6580d4a61380557afd" + }, + { + "m_Id": "2d62f4a8544b460b9f314e90db6ec04c" + }, + { + "m_Id": "6918af92d95c46dfa33f3b2b9331ebca" + }, + { + "m_Id": "15f48b8faeb64c0cb4b648989f149d63" + }, + { + "m_Id": "ef9a9ad73fb74bd087b55b476ba61119" + }, + { + "m_Id": "619d5f4976004545be9f7a054f6345c2" + }, + { + "m_Id": "c48f7c3cdcba457fa8d313e8ac2a2192" + }, + { + "m_Id": "789e70aabf5a4c52b8bb9861dcc75acb" + }, + { + "m_Id": "fce255c0160645c69de31bb99b688b0d" + }, + { + "m_Id": "9087b9a01e164fa490cb7d1132f0ee11" + }, + { + "m_Id": "2ec9dabee0914c97837fd58570d86f21" + }, + { + "m_Id": "dedf1c4c6ae84cb4b2905241cd8853c6" + }, + { + "m_Id": "7775f2e3bef641f9acfa32f315b8a049" + }, + { + "m_Id": "db2bfc69c41f47cea634ef69f9ad207e" + }, + { + "m_Id": "0213d335a7e4497b98bb447d6528c4f6" + }, + { + "m_Id": "742ba88a28af42aba6cf8af5187f2bc5" + }, + { + "m_Id": "212fcf1563454809ac6e02adac40b4cb" + }, + { + "m_Id": "368ef12a048b4592bec306aa78b6c949" + }, + { + "m_Id": "88f18d873f5c49058d48d6325df9b08c" + }, + { + "m_Id": "8d097bd0ba5d4813baa363e9331172b1" + }, + { + "m_Id": "426aa34785084a549dbd9d591d997b49" + }, + { + "m_Id": "bb4e2f399363435db48ee90bf23f23fc" + }, + { + "m_Id": "8dae98b4bffa4bdd8f7b5ca2822e97d2" + }, + { + "m_Id": "7988f0a070304aec8336a9a885eee20f" + }, + { + "m_Id": "49d17ba692cf4ddfa5689031410f9af7" + }, + { + "m_Id": "3c3d298450c64c50afd6e62d79cd27c3" + }, + { + "m_Id": "dbdf7da04f214f16ba536399a7105ad8" + }, + { + "m_Id": "015ad390771249429ee28c0274b20345" + }, + { + "m_Id": "b90305df41fa48359109b31d35717317" + }, + { + "m_Id": "f9e4ca9ef51f47f181f9674bfca66bc4" + }, + { + "m_Id": "c54f3fc163454592aeaf55657e4134a3" + }, + { + "m_Id": "bd3b495317c543eabf80d124290b4122" + }, + { + "m_Id": "bc1baf1bf1fc4b25a8c5e0d18e315afd" + }, + { + "m_Id": "8eda96c3858f479cbd78b61e73194ef7" + }, + { + "m_Id": "a11e0b5579d84698b53dcf812e56b73c" + }, + { + "m_Id": "afcfe1b0e92042a69deaf6315b6813a8" + }, + { + "m_Id": "bc5f2c0ad23b44eb96bc7b83b3e78b4f" + }, + { + "m_Id": "3853f500618142f187137289e75735bd" + }, + { + "m_Id": "6396fbb6050845dfb78251eb19cf1f3d" + }, + { + "m_Id": "08d60018618f4e9e95071c89fbeb6111" + }, + { + "m_Id": "2c091c6528664f6797d8a54f8327744d" + }, + { + "m_Id": "81e5fe7d81d8443da529cd0254c01e61" + }, + { + "m_Id": "a9d66e0df912494a9d80d1871739efd8" + }, + { + "m_Id": "abcb0bd1f0ef4265b7f3627c28ea272c" + }, + { + "m_Id": "4f7d58dc38cd4a4daa541a875022cf72" + }, + { + "m_Id": "183ef9a03d1240da96ad473c17fdffb6" + }, + { + "m_Id": "f7a1640f8cf941cca6d8024317680230" + }, + { + "m_Id": "0f3d1062075e4033a1a07b86ad18eac5" + }, + { + "m_Id": "fc728e1ada644514b5e3d38d1a9b24c1" + }, + { + "m_Id": "6302739ff3374cfaa8fcedd14e7f761c" + }, + { + "m_Id": "c422a5e7e9fa45de8b8127772c192150" + }, + { + "m_Id": "73deaf823d80459e99867f6faff97e65" + }, + { + "m_Id": "ab61ef9ae4eb4f74bd3712a4798c1b93" + }, + { + "m_Id": "5edeff0045f043628d7eec2ef5557e4f" + }, + { + "m_Id": "bde938d5baf14ecfbc7afa4925a31ecb" + }, + { + "m_Id": "17cf5ef067934eb8aaa86b71fff89018" + }, + { + "m_Id": "a174a97b68ea4d85a8eef303cc274672" + }, + { + "m_Id": "1ec2d9d1e5ea4e2b948b63854493990a" + }, + { + "m_Id": "0fb3b92667984c7daa4c297dacb989bd" + }, + { + "m_Id": "403fb33619f946bab63f336ed9285011" + }, + { + "m_Id": "0e4c01f55dbf4e6fb370280dc51683aa" + }, + { + "m_Id": "b3821699d55c4ecd875e215826c1fb16" + }, + { + "m_Id": "b60d45d8cc9c4110aaf40f244bed69c6" + }, + { + "m_Id": "939c0dcd55b443e29650f7cffa67c658" + }, + { + "m_Id": "989a5b6ec439465aa4eed4b75eeec61b" + }, + { + "m_Id": "a937a0903d924b98ae172912d6fa7a0f" + }, + { + "m_Id": "e0303ad684554dceae658e66a502696f" + }, + { + "m_Id": "3e65b49e5c9849f88b9fdadb71b1e174" + }, + { + "m_Id": "3e710f1fde3941e190479a99812135ab" + }, + { + "m_Id": "37e75d0888474abd902621830e017f7f" + }, + { + "m_Id": "7d1c7e05177342fca6ab9184d5038e66" + }, + { + "m_Id": "b8b4cd1faff44ef793a1757988d5d564" + }, + { + "m_Id": "93152c3843a142efa5ea3d8de29e187c" + }, + { + "m_Id": "8b50c6d9dfd14cd7813b6ca0dcaa3f94" + }, + { + "m_Id": "c32c318d23154d279902e9aa65cb5ca1" + }, + { + "m_Id": "4980ab94dd794acb861d2bff4da45b6c" + }, + { + "m_Id": "653d9a0466784556a30ea5f4a8ab15b4" + }, + { + "m_Id": "121c59319f834d9aae07910ab4759050" + }, + { + "m_Id": "1b552b98d9514ccbb5e169cb39964939" + }, + { + "m_Id": "30c9f960d0614a9c86d6adb950404ba4" + }, + { + "m_Id": "17dad3882c584470862c6e39310a2793" + }, + { + "m_Id": "3e5e7df4e7e54e6689aec588fd71466c" + }, + { + "m_Id": "b19b084a466d46849266805dbd24f45a" + }, + { + "m_Id": "c0c3c5c181cc4e3ea7ae03e90bd20b5d" + }, + { + "m_Id": "716c2c419d6c4e22b5e02d2cc6973fa9" + }, + { + "m_Id": "04c243e7ff774b59bc76dc6b1abdd5a7" + }, + { + "m_Id": "ce633f36651f4879adaa91879638782a" + }, + { + "m_Id": "5cb0acbaa8ec47f3949dd6f059ef08ac" + }, + { + "m_Id": "8a638e82aa1d4bf2a04304650d73fa8e" + }, + { + "m_Id": "63e87978e9a747f68093da34fdd729d1" + }, + { + "m_Id": "95eb2c3b36dd4d68a9e131e57395f7ba" + }, + { + "m_Id": "0fd9d87dd55e40e19062a26532caefbe" + }, + { + "m_Id": "59a7dc2461134f9397f43ffba658e922" + }, + { + "m_Id": "62fedfd3bd31470fa43da6a935690b2f" + }, + { + "m_Id": "c5ba3386d18b4c529ce7364f6151a623" + }, + { + "m_Id": "7ece220827684c28a423cf298a5dd94a" + }, + { + "m_Id": "550a06f5c5c94768ae7e3ac6f3a68718" + }, + { + "m_Id": "64b8f0b8e8ab453b82e60dbb2601810a" + }, + { + "m_Id": "5c6d79fa3de14efc88d0df8ae1161314" + }, + { + "m_Id": "ed23a5794fd04f4da4f8dc952d7bc921" + }, + { + "m_Id": "b89f3fca13474ebc98719fceb8054eb0" + }, + { + "m_Id": "d3cd1375c69343009337fb6036edb8cb" + }, + { + "m_Id": "7352305b756b4d149bb8ba57d17be328" + }, + { + "m_Id": "34f42febbc9c455296ef74e39666c168" + }, + { + "m_Id": "e4db4ba36bfa46638285444a51991c58" + }, + { + "m_Id": "fafe5ccffa2d4ec4ba5e9ba37d28b945" + }, + { + "m_Id": "e1f2bbba627a43ed95cdac40efa322fd" + }, + { + "m_Id": "a2d4f554a9b94d62a34604525368014f" + }, + { + "m_Id": "632471e337134d58abfeff04c801a3fc" + }, + { + "m_Id": "66d3dbbf263f41eb8f7fd3170e887590" + }, + { + "m_Id": "76cb50baf4d5435eae085a0baf1c43ab" + }, + { + "m_Id": "20f411cc610844238669a33ff803c095" + }, + { + "m_Id": "6929a4da74424497940ebe5e4cf64977" + }, + { + "m_Id": "2fdbc960f1a24a368326646c19f3916d" + }, + { + "m_Id": "237cca6b5408464591f064193a8b6ac5" + }, + { + "m_Id": "3d55130b7f36439aba23579a436a27e0" + }, + { + "m_Id": "a24eb45d2dc040fcae00289ece0bfbc4" + }, + { + "m_Id": "572a2f9ebb594d7f88dd96684e398195" + }, + { + "m_Id": "33bbe060abf846e885adc11afabebbff" + }, + { + "m_Id": "43387ad609f94947a6ae070b34ae1dcf" + }, + { + "m_Id": "51151e73375c46bfa12805410235fc45" + }, + { + "m_Id": "830b4ad0320847a695332b5d1caafdb6" + }, + { + "m_Id": "d10fb006fee641a2b5ac0071048cdade" + } + ], + "m_GroupDatas": [ + { + "m_Id": "e2d8030e74824bb48369331f4775f0ac" + }, + { + "m_Id": "47b971716ee4470f865fc5c885abcf66" + }, + { + "m_Id": "69bc229b1eb94e15a47d971b447a3198" + }, + { + "m_Id": "06ed9322d6854bb2b1d9cb30cd928b6d" + }, + { + "m_Id": "74c1d47e70e6422881a0e0f051febbb9" + }, + { + "m_Id": "3d2583bfe59949a280911e6c487c911f" + }, + { + "m_Id": "77f65f494a034b2a9cf1395ba40d3843" + }, + { + "m_Id": "9392ab8fa6934d1a81cbe54f6c435b52" + }, + { + "m_Id": "9be24d51d0344c13bc6aef014a27580b" + }, + { + "m_Id": "fa7b0f3ba7d84ba7a4d19d87b7a3c4b8" + }, + { + "m_Id": "862059ed0bf141dd9404f65a66b53cd8" + }, + { + "m_Id": "4e7801ae7f8b4090be5d458121207cec" + }, + { + "m_Id": "4a0e19aa85024f47a32faf9b1d3f2868" + }, + { + "m_Id": "8e986fb6ad9c4fdab0a043872278421b" + }, + { + "m_Id": "ac1d8910df764e109e212887850df3ab" + }, + { + "m_Id": "0ca230dd81f04c0ba5af42953674323c" + }, + { + "m_Id": "3366f611f8464c988208f0daa49f30d2" + }, + { + "m_Id": "a145967c42cb43d59d7699fc064ab763" + }, + { + "m_Id": "8797d77264e74bd38b2c09f136026a6b" + } + ], + "m_StickyNoteDatas": [ + { + "m_Id": "1445382bcb70439b8e2c097b4a733e73" + }, + { + "m_Id": "9d19945f6155442c8b409fda6b0d4e5d" + }, + { + "m_Id": "504ca61054e546f2bab2baa6c59b1c3c" + } + ], + "m_Edges": [ + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "015ad390771249429ee28c0274b20345" + }, + "m_SlotId": 1 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "9087b9a01e164fa490cb7d1132f0ee11" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "0213d335a7e4497b98bb447d6528c4f6" + }, + "m_SlotId": 2 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "7d1c7e05177342fca6ab9184d5038e66" + }, + "m_SlotId": 1 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "04c243e7ff774b59bc76dc6b1abdd5a7" + }, + "m_SlotId": 2 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "ce633f36651f4879adaa91879638782a" + }, + "m_SlotId": 1 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "0556880e701d48e589655db291ee6099" + }, + "m_SlotId": 5 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "93152c3843a142efa5ea3d8de29e187c" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "08d60018618f4e9e95071c89fbeb6111" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "6396fbb6050845dfb78251eb19cf1f3d" + }, + "m_SlotId": 1 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "0e4c01f55dbf4e6fb370280dc51683aa" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "1ec2d9d1e5ea4e2b948b63854493990a" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "0f3d1062075e4033a1a07b86ad18eac5" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "59a7dc2461134f9397f43ffba658e922" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "0fb3b92667984c7daa4c297dacb989bd" + }, + "m_SlotId": 2 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "939c0dcd55b443e29650f7cffa67c658" + }, + "m_SlotId": 2 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "0fd9d87dd55e40e19062a26532caefbe" + }, + "m_SlotId": 1 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "95eb2c3b36dd4d68a9e131e57395f7ba" + }, + "m_SlotId": 2 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "121c59319f834d9aae07910ab4759050" + }, + "m_SlotId": 2 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "30c9f960d0614a9c86d6adb950404ba4" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "15f48b8faeb64c0cb4b648989f149d63" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "6918af92d95c46dfa33f3b2b9331ebca" + }, + "m_SlotId": 1 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "17cf5ef067934eb8aaa86b71fff89018" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "5edeff0045f043628d7eec2ef5557e4f" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "17dad3882c584470862c6e39310a2793" + }, + "m_SlotId": 2 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "bc1baf1bf1fc4b25a8c5e0d18e315afd" + }, + "m_SlotId": 1 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "183ef9a03d1240da96ad473c17fdffb6" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "a11e0b5579d84698b53dcf812e56b73c" + }, + "m_SlotId": 1 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "1b552b98d9514ccbb5e169cb39964939" + }, + "m_SlotId": 2 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "17dad3882c584470862c6e39310a2793" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "1ec2d9d1e5ea4e2b948b63854493990a" + }, + "m_SlotId": 2 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "0fb3b92667984c7daa4c297dacb989bd" + }, + "m_SlotId": 1 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "20f411cc610844238669a33ff803c095" + }, + "m_SlotId": 1 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "4980ab94dd794acb861d2bff4da45b6c" + }, + "m_SlotId": 1 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "212fcf1563454809ac6e02adac40b4cb" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "742ba88a28af42aba6cf8af5187f2bc5" + }, + "m_SlotId": 1 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "237cca6b5408464591f064193a8b6ac5" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "6929a4da74424497940ebe5e4cf64977" + }, + "m_SlotId": 1 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "2c091c6528664f6797d8a54f8327744d" + }, + "m_SlotId": 2 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "81e5fe7d81d8443da529cd0254c01e61" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "2c091c6528664f6797d8a54f8327744d" + }, + "m_SlotId": 2 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "bc5f2c0ad23b44eb96bc7b83b3e78b4f" + }, + "m_SlotId": 1 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "2d62f4a8544b460b9f314e90db6ec04c" + }, + "m_SlotId": 2 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "512f5c3810b44a6580d4a61380557afd" + }, + "m_SlotId": 2 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "2ec9dabee0914c97837fd58570d86f21" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "7988f0a070304aec8336a9a885eee20f" + }, + "m_SlotId": 1 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "2fdbc960f1a24a368326646c19f3916d" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "3d55130b7f36439aba23579a436a27e0" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "30c9f960d0614a9c86d6adb950404ba4" + }, + "m_SlotId": 2 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "84bdfaea919e418dbad1cf44d06dc11b" + }, + "m_SlotId": 1 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "33bbe060abf846e885adc11afabebbff" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "43387ad609f94947a6ae070b34ae1dcf" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "34f42febbc9c455296ef74e39666c168" + }, + "m_SlotId": 1 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "7352305b756b4d149bb8ba57d17be328" + }, + "m_SlotId": 1 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "34f42febbc9c455296ef74e39666c168" + }, + "m_SlotId": 1 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "c422a5e7e9fa45de8b8127772c192150" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "365dce71ec05435a85200a53c1026b6d" + }, + "m_SlotId": 3 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "66d3dbbf263f41eb8f7fd3170e887590" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "368ef12a048b4592bec306aa78b6c949" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "88f18d873f5c49058d48d6325df9b08c" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "37e75d0888474abd902621830e017f7f" + }, + "m_SlotId": 1 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "3c3d298450c64c50afd6e62d79cd27c3" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "37e75d0888474abd902621830e017f7f" + }, + "m_SlotId": 1 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "bde938d5baf14ecfbc7afa4925a31ecb" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "3853f500618142f187137289e75735bd" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "63e87978e9a747f68093da34fdd729d1" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "3853f500618142f187137289e75735bd" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "d3cd1375c69343009337fb6036edb8cb" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "3c3d298450c64c50afd6e62d79cd27c3" + }, + "m_SlotId": 1 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "7988f0a070304aec8336a9a885eee20f" + }, + "m_SlotId": 2 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "3c7bca46d3ed4ae5b7df3592da5f774c" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "60690c6170544de7ab05a07916de81aa" + }, + "m_SlotId": 1 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "3d55130b7f36439aba23579a436a27e0" + }, + "m_SlotId": 2 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "237cca6b5408464591f064193a8b6ac5" + }, + "m_SlotId": 2 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "3e5e7df4e7e54e6689aec588fd71466c" + }, + "m_SlotId": 1 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "ed23a5794fd04f4da4f8dc952d7bc921" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "3e65b49e5c9849f88b9fdadb71b1e174" + }, + "m_SlotId": 1 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "632471e337134d58abfeff04c801a3fc" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "3e65b49e5c9849f88b9fdadb71b1e174" + }, + "m_SlotId": 1 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "989a5b6ec439465aa4eed4b75eeec61b" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "3e710f1fde3941e190479a99812135ab" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "e1e6ea93dab24d4086de0ce0507e9306" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "403fb33619f946bab63f336ed9285011" + }, + "m_SlotId": 2 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "1ec2d9d1e5ea4e2b948b63854493990a" + }, + "m_SlotId": 1 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "42ba018b3a414c4485ab942ebf69a4ad" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "121c59319f834d9aae07910ab4759050" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "43387ad609f94947a6ae070b34ae1dcf" + }, + "m_SlotId": 2 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "3d55130b7f36439aba23579a436a27e0" + }, + "m_SlotId": 1 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "48e7aa14004241f09e40927e5502db5f" + }, + "m_SlotId": 2 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "953fa7f504094a569b4c7ca8216cd28c" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "4980ab94dd794acb861d2bff4da45b6c" + }, + "m_SlotId": 2 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "e0303ad684554dceae658e66a502696f" + }, + "m_SlotId": 2 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "49d17ba692cf4ddfa5689031410f9af7" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "7988f0a070304aec8336a9a885eee20f" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "4f7d58dc38cd4a4daa541a875022cf72" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "8eda96c3858f479cbd78b61e73194ef7" + }, + "m_SlotId": 1 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "51151e73375c46bfa12805410235fc45" + }, + "m_SlotId": 1 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "6929a4da74424497940ebe5e4cf64977" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "512f5c3810b44a6580d4a61380557afd" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "365dce71ec05435a85200a53c1026b6d" + }, + "m_SlotId": 1 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "550a06f5c5c94768ae7e3ac6f3a68718" + }, + "m_SlotId": 3 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "6302739ff3374cfaa8fcedd14e7f761c" + }, + "m_SlotId": 3 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "572a2f9ebb594d7f88dd96684e398195" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "43387ad609f94947a6ae070b34ae1dcf" + }, + "m_SlotId": 1 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "59a7dc2461134f9397f43ffba658e922" + }, + "m_SlotId": 2 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "550a06f5c5c94768ae7e3ac6f3a68718" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "59a7dc2461134f9397f43ffba658e922" + }, + "m_SlotId": 2 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "5c6d79fa3de14efc88d0df8ae1161314" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "5c6d79fa3de14efc88d0df8ae1161314" + }, + "m_SlotId": 2 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "550a06f5c5c94768ae7e3ac6f3a68718" + }, + "m_SlotId": 1 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "5cb0acbaa8ec47f3949dd6f059ef08ac" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "7ece220827684c28a423cf298a5dd94a" + }, + "m_SlotId": 1 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "5edeff0045f043628d7eec2ef5557e4f" + }, + "m_SlotId": 3 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "73deaf823d80459e99867f6faff97e65" + }, + "m_SlotId": 2 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "60690c6170544de7ab05a07916de81aa" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "84bdfaea919e418dbad1cf44d06dc11b" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "619d5f4976004545be9f7a054f6345c2" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "c48f7c3cdcba457fa8d313e8ac2a2192" + }, + "m_SlotId": 1 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "62fedfd3bd31470fa43da6a935690b2f" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "59a7dc2461134f9397f43ffba658e922" + }, + "m_SlotId": 1 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "62fedfd3bd31470fa43da6a935690b2f" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "b89f3fca13474ebc98719fceb8054eb0" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "6302739ff3374cfaa8fcedd14e7f761c" + }, + "m_SlotId": 2 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "f7a1640f8cf941cca6d8024317680230" + }, + "m_SlotId": 2 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "632471e337134d58abfeff04c801a3fc" + }, + "m_SlotId": 1 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "a2d4f554a9b94d62a34604525368014f" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "63427a74f3e84bfaa8916b46984eb21e" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "48e7aa14004241f09e40927e5502db5f" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "6396fbb6050845dfb78251eb19cf1f3d" + }, + "m_SlotId": 2 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "bc5f2c0ad23b44eb96bc7b83b3e78b4f" + }, + "m_SlotId": 2 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "63e87978e9a747f68093da34fdd729d1" + }, + "m_SlotId": 2 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "95eb2c3b36dd4d68a9e131e57395f7ba" + }, + "m_SlotId": 1 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "64b8f0b8e8ab453b82e60dbb2601810a" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "b89f3fca13474ebc98719fceb8054eb0" + }, + "m_SlotId": 1 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "653d9a0466784556a30ea5f4a8ab15b4" + }, + "m_SlotId": 1 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "37e75d0888474abd902621830e017f7f" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "653d9a0466784556a30ea5f4a8ab15b4" + }, + "m_SlotId": 1 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "3e710f1fde3941e190479a99812135ab" + }, + "m_SlotId": 1 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "653d9a0466784556a30ea5f4a8ab15b4" + }, + "m_SlotId": 1 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "716c2c419d6c4e22b5e02d2cc6973fa9" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "653d9a0466784556a30ea5f4a8ab15b4" + }, + "m_SlotId": 1 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "c54f3fc163454592aeaf55657e4134a3" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "66d3dbbf263f41eb8f7fd3170e887590" + }, + "m_SlotId": 1 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "6918af92d95c46dfa33f3b2b9331ebca" + }, + "m_SlotId": 3 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "6918af92d95c46dfa33f3b2b9331ebca" + }, + "m_SlotId": 2 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "f7a1640f8cf941cca6d8024317680230" + }, + "m_SlotId": 1 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "6929a4da74424497940ebe5e4cf64977" + }, + "m_SlotId": 3 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "a24eb45d2dc040fcae00289ece0bfbc4" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "716c2c419d6c4e22b5e02d2cc6973fa9" + }, + "m_SlotId": 1 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "04c243e7ff774b59bc76dc6b1abdd5a7" + }, + "m_SlotId": 1 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "71d190547a3c44809862ff43703249c1" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "d86bbba2a7f544ccb8b0f954a6fd1a83" + }, + "m_SlotId": 1 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "7352305b756b4d149bb8ba57d17be328" + }, + "m_SlotId": 3 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "c0c3c5c181cc4e3ea7ae03e90bd20b5d" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "73deaf823d80459e99867f6faff97e65" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "6a4b619cae09428e850340b327dc2247" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "742ba88a28af42aba6cf8af5187f2bc5" + }, + "m_SlotId": 3 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "7775f2e3bef641f9acfa32f315b8a049" + }, + "m_SlotId": 2 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "76cb50baf4d5435eae085a0baf1c43ab" + }, + "m_SlotId": 1 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "0fd9d87dd55e40e19062a26532caefbe" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "7775f2e3bef641f9acfa32f315b8a049" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "0213d335a7e4497b98bb447d6528c4f6" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "789e70aabf5a4c52b8bb9861dcc75acb" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "ef9a9ad73fb74bd087b55b476ba61119" + }, + "m_SlotId": 3 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "7988f0a070304aec8336a9a885eee20f" + }, + "m_SlotId": 3 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "73deaf823d80459e99867f6faff97e65" + }, + "m_SlotId": 1 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "7d0d6e9fb5ad480fa2c294660a419754" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "2d62f4a8544b460b9f314e90db6ec04c" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "7d0d6e9fb5ad480fa2c294660a419754" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "512f5c3810b44a6580d4a61380557afd" + }, + "m_SlotId": 1 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "7d1c7e05177342fca6ab9184d5038e66" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "bc0c9bafa3544deaaba658da5d1457a2" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "7ece220827684c28a423cf298a5dd94a" + }, + "m_SlotId": 2 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "20f411cc610844238669a33ff803c095" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "7ece220827684c28a423cf298a5dd94a" + }, + "m_SlotId": 2 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "e4db4ba36bfa46638285444a51991c58" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "8192b535ff4b4c02b8b979c205588649" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "c0f127f890774e2987f07ee8f1002231" + }, + "m_SlotId": 1 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "81e5fe7d81d8443da529cd0254c01e61" + }, + "m_SlotId": 1 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "6396fbb6050845dfb78251eb19cf1f3d" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "830b4ad0320847a695332b5d1caafdb6" + }, + "m_SlotId": 2 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "51151e73375c46bfa12805410235fc45" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "84bdfaea919e418dbad1cf44d06dc11b" + }, + "m_SlotId": 2 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "c0f127f890774e2987f07ee8f1002231" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "8a638e82aa1d4bf2a04304650d73fa8e" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "63e87978e9a747f68093da34fdd729d1" + }, + "m_SlotId": 1 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "8b50c6d9dfd14cd7813b6ca0dcaa3f94" + }, + "m_SlotId": 2 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "c32c318d23154d279902e9aa65cb5ca1" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "8dae98b4bffa4bdd8f7b5ca2822e97d2" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "04c243e7ff774b59bc76dc6b1abdd5a7" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "8eda96c3858f479cbd78b61e73194ef7" + }, + "m_SlotId": 2 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "a11e0b5579d84698b53dcf812e56b73c" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "9087b9a01e164fa490cb7d1132f0ee11" + }, + "m_SlotId": 2 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "b74b3332d6fe43dda8b59f706cc29f29" + }, + "m_SlotId": 2 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "93152c3843a142efa5ea3d8de29e187c" + }, + "m_SlotId": 1 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "8b50c6d9dfd14cd7813b6ca0dcaa3f94" + }, + "m_SlotId": 1 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "939c0dcd55b443e29650f7cffa67c658" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "4b45669a84054c498babd493511b3189" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "953fa7f504094a569b4c7ca8216cd28c" + }, + "m_SlotId": 1 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "3e65b49e5c9849f88b9fdadb71b1e174" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "953fa7f504094a569b4c7ca8216cd28c" + }, + "m_SlotId": 1 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "7352305b756b4d149bb8ba57d17be328" + }, + "m_SlotId": 2 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "953fa7f504094a569b4c7ca8216cd28c" + }, + "m_SlotId": 1 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "b19b084a466d46849266805dbd24f45a" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "95eb2c3b36dd4d68a9e131e57395f7ba" + }, + "m_SlotId": 3 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "2c091c6528664f6797d8a54f8327744d" + }, + "m_SlotId": 1 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "989a5b6ec439465aa4eed4b75eeec61b" + }, + "m_SlotId": 3 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "76cb50baf4d5435eae085a0baf1c43ab" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "a11e0b5579d84698b53dcf812e56b73c" + }, + "m_SlotId": 2 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "6302739ff3374cfaa8fcedd14e7f761c" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "a174a97b68ea4d85a8eef303cc274672" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "0fb3b92667984c7daa4c297dacb989bd" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "a24eb45d2dc040fcae00289ece0bfbc4" + }, + "m_SlotId": 1 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "403fb33619f946bab63f336ed9285011" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "a2d4f554a9b94d62a34604525368014f" + }, + "m_SlotId": 1 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "365dce71ec05435a85200a53c1026b6d" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "a72ad83bd1eb4a4691d245a59c9e41d5" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "2d62f4a8544b460b9f314e90db6ec04c" + }, + "m_SlotId": 1 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "a937a0903d924b98ae172912d6fa7a0f" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "4980ab94dd794acb861d2bff4da45b6c" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "a9d66e0df912494a9d80d1871739efd8" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "afcfe1b0e92042a69deaf6315b6813a8" + }, + "m_SlotId": 1 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "ab61ef9ae4eb4f74bd3712a4798c1b93" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "5edeff0045f043628d7eec2ef5557e4f" + }, + "m_SlotId": 1 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "abcb0bd1f0ef4265b7f3627c28ea272c" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "1b552b98d9514ccbb5e169cb39964939" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "afcfe1b0e92042a69deaf6315b6813a8" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "bc1baf1bf1fc4b25a8c5e0d18e315afd" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "b19b084a466d46849266805dbd24f45a" + }, + "m_SlotId": 1 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "3e5e7df4e7e54e6689aec588fd71466c" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "b3821699d55c4ecd875e215826c1fb16" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "403fb33619f946bab63f336ed9285011" + }, + "m_SlotId": 1 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "b60d45d8cc9c4110aaf40f244bed69c6" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "939c0dcd55b443e29650f7cffa67c658" + }, + "m_SlotId": 1 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "b74b3332d6fe43dda8b59f706cc29f29" + }, + "m_SlotId": 3 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "60690c6170544de7ab05a07916de81aa" + }, + "m_SlotId": 2 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "b89f3fca13474ebc98719fceb8054eb0" + }, + "m_SlotId": 2 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "5c6d79fa3de14efc88d0df8ae1161314" + }, + "m_SlotId": 1 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "b8b4cd1faff44ef793a1757988d5d564" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "8b50c6d9dfd14cd7813b6ca0dcaa3f94" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "bc1baf1bf1fc4b25a8c5e0d18e315afd" + }, + "m_SlotId": 2 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "8eda96c3858f479cbd78b61e73194ef7" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "bc5f2c0ad23b44eb96bc7b83b3e78b4f" + }, + "m_SlotId": 3 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "afcfe1b0e92042a69deaf6315b6813a8" + }, + "m_SlotId": 2 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "bd3b495317c543eabf80d124290b4122" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "fafe5ccffa2d4ec4ba5e9ba37d28b945" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "bde938d5baf14ecfbc7afa4925a31ecb" + }, + "m_SlotId": 1 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "5edeff0045f043628d7eec2ef5557e4f" + }, + "m_SlotId": 2 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "c0c3c5c181cc4e3ea7ae03e90bd20b5d" + }, + "m_SlotId": 1 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "653d9a0466784556a30ea5f4a8ab15b4" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "c0f127f890774e2987f07ee8f1002231" + }, + "m_SlotId": 2 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "d86bbba2a7f544ccb8b0f954a6fd1a83" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "c2ce8f28915943d49e5539ae59b0b3bf" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "0556880e701d48e589655db291ee6099" + }, + "m_SlotId": 1 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "c32c318d23154d279902e9aa65cb5ca1" + }, + "m_SlotId": 1 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "6b280d605cf34b63ae417129545c2f7d" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "c422a5e7e9fa45de8b8127772c192150" + }, + "m_SlotId": 2 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "7352305b756b4d149bb8ba57d17be328" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "c48f7c3cdcba457fa8d313e8ac2a2192" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "ef9a9ad73fb74bd087b55b476ba61119" + }, + "m_SlotId": 1 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "c54f3fc163454592aeaf55657e4134a3" + }, + "m_SlotId": 1 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "f9e4ca9ef51f47f181f9674bfca66bc4" + }, + "m_SlotId": 1 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "c5ba3386d18b4c529ce7364f6151a623" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "7ece220827684c28a423cf298a5dd94a" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "ce633f36651f4879adaa91879638782a" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "bb4e2f399363435db48ee90bf23f23fc" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "d10fb006fee641a2b5ac0071048cdade" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "830b4ad0320847a695332b5d1caafdb6" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "d3cd1375c69343009337fb6036edb8cb" + }, + "m_SlotId": 1 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "95eb2c3b36dd4d68a9e131e57395f7ba" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "d4adb9f4c12448c78e98d14fb2000ab7" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "dbdf7da04f214f16ba536399a7105ad8" + }, + "m_SlotId": 1 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "d86bbba2a7f544ccb8b0f954a6fd1a83" + }, + "m_SlotId": 2 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "6918af92d95c46dfa33f3b2b9331ebca" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "db2bfc69c41f47cea634ef69f9ad207e" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "f9e4ca9ef51f47f181f9674bfca66bc4" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "dbdf7da04f214f16ba536399a7105ad8" + }, + "m_SlotId": 2 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "015ad390771249429ee28c0274b20345" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "dbdf7da04f214f16ba536399a7105ad8" + }, + "m_SlotId": 2 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "b74b3332d6fe43dda8b59f706cc29f29" + }, + "m_SlotId": 1 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "dedf1c4c6ae84cb4b2905241cd8853c6" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "7775f2e3bef641f9acfa32f315b8a049" + }, + "m_SlotId": 1 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "e0303ad684554dceae658e66a502696f" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "989a5b6ec439465aa4eed4b75eeec61b" + }, + "m_SlotId": 1 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "e1f2bbba627a43ed95cdac40efa322fd" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "fafe5ccffa2d4ec4ba5e9ba37d28b945" + }, + "m_SlotId": 1 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "e4db4ba36bfa46638285444a51991c58" + }, + "m_SlotId": 1 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "34f42febbc9c455296ef74e39666c168" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "ed23a5794fd04f4da4f8dc952d7bc921" + }, + "m_SlotId": 1 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "550a06f5c5c94768ae7e3ac6f3a68718" + }, + "m_SlotId": 2 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "ef9a9ad73fb74bd087b55b476ba61119" + }, + "m_SlotId": 2 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "8a7ae7a881424567bd38f733cff73869" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "f7a1640f8cf941cca6d8024317680230" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "ef9a9ad73fb74bd087b55b476ba61119" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "f9e4ca9ef51f47f181f9674bfca66bc4" + }, + "m_SlotId": 2 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "0213d335a7e4497b98bb447d6528c4f6" + }, + "m_SlotId": 1 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "fafe5ccffa2d4ec4ba5e9ba37d28b945" + }, + "m_SlotId": 2 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "c422a5e7e9fa45de8b8127772c192150" + }, + "m_SlotId": 1 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "fc728e1ada644514b5e3d38d1a9b24c1" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "6302739ff3374cfaa8fcedd14e7f761c" + }, + "m_SlotId": 1 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "fce255c0160645c69de31bb99b688b0d" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "9087b9a01e164fa490cb7d1132f0ee11" + }, + "m_SlotId": 1 + } + } + ], + "m_VertexContext": { + "m_Position": { + "x": 1353.000244140625, + "y": -3876.0 + }, + "m_Blocks": [ + { + "m_Id": "4b45669a84054c498babd493511b3189" + }, + { + "m_Id": "0153caa15e554a9bb37fea4238ebdc5b" + }, + { + "m_Id": "00ab9614abb14bfea39934b2abff144b" + } + ] + }, + "m_FragmentContext": { + "m_Position": { + "x": 1352.9998779296875, + "y": 9.999946594238282 + }, + "m_Blocks": [ + { + "m_Id": "8a7ae7a881424567bd38f733cff73869" + }, + { + "m_Id": "08c1176d7dfe406bb0f6283ca763d553" + }, + { + "m_Id": "e701720035d44304a33f4b64350fc6e3" + }, + { + "m_Id": "6a4b619cae09428e850340b327dc2247" + }, + { + "m_Id": "e1e6ea93dab24d4086de0ce0507e9306" + }, + { + "m_Id": "b90305df41fa48359109b31d35717317" + }, + { + "m_Id": "8d097bd0ba5d4813baa363e9331172b1" + }, + { + "m_Id": "88f18d873f5c49058d48d6325df9b08c" + }, + { + "m_Id": "426aa34785084a549dbd9d591d997b49" + }, + { + "m_Id": "bb4e2f399363435db48ee90bf23f23fc" + }, + { + "m_Id": "6b280d605cf34b63ae417129545c2f7d" + }, + { + "m_Id": "bc0c9bafa3544deaaba658da5d1457a2" + } + ] + }, + "m_PreviewData": { + "serializedMesh": { + "m_SerializedMesh": "{\"mesh\":{\"instanceID\":0}}", + "m_Guid": "" + } + }, + "m_Path": "Shader Graphs", + "m_ConcretePrecision": 0, + "m_PreviewMode": 2, + "m_OutputNode": { + "m_Id": "" + }, + "m_ActiveTargets": [ + { + "m_Id": "0083909e70ac4601afc22e423a6e3d2e" + } + ] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "005ebe2d787749ee84505cba884c9cb5", + "m_Id": 3, + "m_DisplayName": "Out", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "00688728415c4b408c64c6d51df12097", + "m_Id": 0, + "m_DisplayName": "Iris Scale", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector3MaterialSlot", + "m_ObjectId": "00759dbf8a6c41718edcdf0098844a45", + "m_Id": 0, + "m_DisplayName": "Out", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0 + }, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.Rendering.HighDefinition.ShaderGraph.HDTarget", + "m_ObjectId": "0083909e70ac4601afc22e423a6e3d2e", + "m_ActiveSubTarget": { + "m_Id": "33fbdbd78d05438187210437b060626d" + }, + "m_Datas": [ + { + "m_Id": "88f0b3d71738482fb6273b754134b4dd" + }, + { + "m_Id": "2a2960edadd1494c8e81b3d852cb3297" + }, + { + "m_Id": "5e856e0c3b704d14a6c36b84bf8d78f6" + }, + { + "m_Id": "df0ba3ae175741e3a29aeabdd7f3f88d" + } + ], + "m_CustomEditorGUI": "" +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.BlockNode", + "m_ObjectId": "00ab9614abb14bfea39934b2abff144b", + "m_Group": { + "m_Id": "" + }, + "m_Name": "VertexDescription.Tangent", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": 0.0, + "y": 0.0, + "width": 0.0, + "height": 0.0 + } + }, + "m_Slots": [ + { + "m_Id": "c996e165d42c4929928bc49c5e17d734" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_SerializedDescriptor": "VertexDescription.Tangent" +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.BlockNode", + "m_ObjectId": "0153caa15e554a9bb37fea4238ebdc5b", + "m_Group": { + "m_Id": "" + }, + "m_Name": "VertexDescription.Normal", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": 0.0, + "y": 0.0, + "width": 0.0, + "height": 0.0 + } + }, + "m_Slots": [ + { + "m_Id": "3b9bea9727174fc0b9e705617c9903db" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_SerializedDescriptor": "VertexDescription.Normal" +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.OneMinusNode", + "m_ObjectId": "015ad390771249429ee28c0274b20345", + "m_Group": { + "m_Id": "47b971716ee4470f865fc5c885abcf66" + }, + "m_Name": "One Minus", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -3115.99951171875, + "y": -2848.0, + "width": 127.99999237060547, + "height": 93.99999237060547 + } + }, + "m_Slots": [ + { + "m_Id": "6f917d5a97c54c23a798a0c664ac4d59" + }, + { + "m_Id": "e4852e9f556e4f6b8dbc7da69bda5d89" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "018aa566bd894a168b0a4f4ef557f03a", + "m_Id": 1, + "m_DisplayName": "B", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "B", + "m_StageCapability": 3, + "m_Value": { + "x": 0.5, + "y": 0.5, + "z": 0.0, + "w": 1.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.NormalStrengthNode", + "m_ObjectId": "0213d335a7e4497b98bb447d6528c4f6", + "m_Group": { + "m_Id": "4a0e19aa85024f47a32faf9b1d3f2868" + }, + "m_Name": "Normal Strength", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -484.99993896484377, + "y": 913.9998779296875, + "width": 165.99998474121095, + "height": 118.0 + } + }, + "m_Slots": [ + { + "m_Id": "5bc4216d9dc84d618eba447f916fb3ab" + }, + { + "m_Id": "9b49235025f24121a3127a3e9a2aac35" + }, + { + "m_Id": "bb1d6125da5b40f78b383f9b323b60e1" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector3MaterialSlot", + "m_ObjectId": "02d0ef52726545c6a6974e90fcf0d2cf", + "m_Id": 2, + "m_DisplayName": "Out", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0 + }, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicValueMaterialSlot", + "m_ObjectId": "036f995e5f0a4cae9bd9218c9faf6aaf", + "m_Id": 2, + "m_DisplayName": "Out", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": { + "e00": 0.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 0.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 0.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 0.0 + }, + "m_DefaultValue": { + "e00": 1.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 1.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 1.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "041fe88e98ba4393a9279d84780e6b0a", + "m_Id": 0, + "m_DisplayName": "Base", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "Base", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "043a14f8d2584d1d832ae0dbea54093d", + "m_Id": 1, + "m_DisplayName": "Out", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.MultiplyNode", + "m_ObjectId": "04c243e7ff774b59bc76dc6b1abdd5a7", + "m_Group": { + "m_Id": "8e986fb6ad9c4fdab0a043872278421b" + }, + "m_Name": "Multiply", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -923.0, + "y": 95.99989318847656, + "width": 126.0, + "height": 118.0 + } + }, + "m_Slots": [ + { + "m_Id": "8f9e9efa12d24f51a67dbfa72bce5597" + }, + { + "m_Id": "b8d296770e2d493c9dc81da32fcfd3a7" + }, + { + "m_Id": "249bdbf3a7b54c81995f0c6b7ee261e4" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "04e97b02b2fd425ea097ad32cb34402e", + "m_Id": 3, + "m_DisplayName": "Out", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "051195f4293c4e5aa58dde243d4c0166", + "m_Id": 7, + "m_DisplayName": "A", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "A", + "m_StageCapability": 2, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.SampleTexture2DNode", + "m_ObjectId": "0556880e701d48e589655db291ee6099", + "m_Group": { + "m_Id": "9be24d51d0344c13bc6aef014a27580b" + }, + "m_Name": "Sample Texture 2D", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -1401.999755859375, + "y": 479.99993896484377, + "width": 184.0, + "height": 253.0 + } + }, + "m_Slots": [ + { + "m_Id": "86b897ab597140d59a473d807e980628" + }, + { + "m_Id": "5d77a606937f44feb8860c6501cc4557" + }, + { + "m_Id": "37502e011dba43adad5a4c1965f0daf5" + }, + { + "m_Id": "b384faa820304f82807176601dd16753" + }, + { + "m_Id": "ad46a176c1ac40b78ee3a38ad5846d4d" + }, + { + "m_Id": "7c52d0c211b148baa2dee264ed442794" + }, + { + "m_Id": "8c95ccd4e8fd4bf29cc1afa00cc39223" + }, + { + "m_Id": "85c5c76f4845488eb95392938396f2b9" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_TextureType": 0, + "m_NormalMapSpace": 0 +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "05838f59e6b4412ca70a8a90b5f6f1ce", + "m_Id": 3, + "m_DisplayName": "Out", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "058edbfc60e64768aa440ef74321056e", + "m_Id": 0, + "m_DisplayName": "Sclera Smoothness", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicValueMaterialSlot", + "m_ObjectId": "06d5e9feef0b415f9aadb19d0f0c13f7", + "m_Id": 0, + "m_DisplayName": "A", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "A", + "m_StageCapability": 3, + "m_Value": { + "e00": 0.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 0.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 0.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 0.0 + }, + "m_DefaultValue": { + "e00": 1.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 1.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 1.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.GroupData", + "m_ObjectId": "06ed9322d6854bb2b1d9cb30cd928b6d", + "m_Title": "Cornea Smoothness", + "m_Position": { + "x": -1177.0006103515625, + "y": -629.0000610351563 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "082b9d3ca32646dda65c8939d76f75b6", + "m_Id": 0, + "m_DisplayName": "IsCornea", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.BlockNode", + "m_ObjectId": "08c1176d7dfe406bb0f6283ca763d553", + "m_Group": { + "m_Id": "" + }, + "m_Name": "SurfaceDescription.BentNormal", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": 0.0, + "y": 0.0, + "width": 0.0, + "height": 0.0 + } + }, + "m_Slots": [ + { + "m_Id": "c4b6c46dc8b348b8a5ecd4e2aead24c0" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_SerializedDescriptor": "SurfaceDescription.BentNormal" +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector2Node", + "m_ObjectId": "08d60018618f4e9e95071c89fbeb6111", + "m_Group": { + "m_Id": "74c1d47e70e6422881a0e0f051febbb9" + }, + "m_Name": "Vector 2", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -2968.0, + "y": -1476.0001220703125, + "width": 128.0, + "height": 101.0 + } + }, + "m_Slots": [ + { + "m_Id": "d582cbfa200549ef87ec256a60e5804a" + }, + { + "m_Id": "70e23667bbef42dcbd03ce61656f6801" + }, + { + "m_Id": "bec42110e435494787084b07261f13ab" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_Value": { + "x": 0.0, + "y": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.UVMaterialSlot", + "m_ObjectId": "0a037dce630b4fc9a60ae94f82fae69c", + "m_Id": 0, + "m_DisplayName": "UV", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "UV", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0 + }, + "m_Labels": [], + "m_Channel": 0 +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Texture2DMaterialSlot", + "m_ObjectId": "0a6dc616dfe9402dbf46406552b3a409", + "m_Id": 0, + "m_DisplayName": "Color Blend Map", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_BareResource": false +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "0ac3739d49144e9eb1f564c686a1d69f", + "m_Id": 1, + "m_DisplayName": "", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.GroupData", + "m_ObjectId": "0ca230dd81f04c0ba5af42953674323c", + "m_Title": "Radial Gradient", + "m_Position": { + "x": -6266.99951171875, + "y": -826.9999389648438 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Internal.Texture2DShaderProperty", + "m_ObjectId": "0cbea652f4bf4177942231f39b7c2eea", + "m_Guid": { + "m_GuidSerialized": "952a961a-d57d-42a9-94d4-433e00db7cfa" + }, + "m_Name": "Cornea Diffuse Map", + "m_DefaultReferenceName": "", + "m_OverrideReferenceName": "_CorneaDiffuseMap", + "m_GeneratePropertyBlock": true, + "m_Precision": 0, + "overrideHLSLDeclaration": false, + "hlslDeclarationOverride": 0, + "m_Hidden": false, + "m_Value": { + "m_SerializedTexture": "{\"texture\":{\"instanceID\":0}}", + "m_Guid": "" + }, + "m_Modifiable": true, + "m_DefaultType": 0 +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "0d28e9b96829486b9a93fb4b4493ec53", + "m_Id": 0, + "m_DisplayName": "Smoothness", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "Smoothness", + "m_StageCapability": 2, + "m_Value": 0.800000011920929, + "m_DefaultValue": 0.5, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "0dc836f256a647d4a2a3e9289272310e", + "m_Id": 0, + "m_DisplayName": "A", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "A", + "m_StageCapability": 3, + "m_Value": { + "x": 1.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.NormalMaterialSlot", + "m_ObjectId": "0e03c873ccc040dd8417724de5eaf36d", + "m_Id": 0, + "m_DisplayName": "Normal (Tangent Space)", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "NormalTS", + "m_StageCapability": 2, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0 + }, + "m_Labels": [], + "m_Space": 3 +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector3Node", + "m_ObjectId": "0e4c01f55dbf4e6fb370280dc51683aa", + "m_Group": { + "m_Id": "9392ab8fa6934d1a81cbe54f6c435b52" + }, + "m_Name": "Vector 3", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -130.99990844726563, + "y": -3650.0, + "width": 128.0, + "height": 124.99999237060547 + } + }, + "m_Slots": [ + { + "m_Id": "3bb9c7ad43ad42a680432cca5d69479f" + }, + { + "m_Id": "13555c6f540e46318c38dde20c6a0bef" + }, + { + "m_Id": "9c6d7a3a80c44bc2abca376bd090c0c0" + }, + { + "m_Id": "927d5dd6ac0941f8b8081127482ab289" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicValueMaterialSlot", + "m_ObjectId": "0f0f4ffc9fc247e0b2b23170a98dc7f4", + "m_Id": 1, + "m_DisplayName": "B", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "B", + "m_StageCapability": 3, + "m_Value": { + "e00": 2.0, + "e01": 2.0, + "e02": 2.0, + "e03": 2.0, + "e10": 2.0, + "e11": 2.0, + "e12": 2.0, + "e13": 2.0, + "e20": 2.0, + "e21": 2.0, + "e22": 2.0, + "e23": 2.0, + "e30": 2.0, + "e31": 2.0, + "e32": 2.0, + "e33": 2.0 + }, + "m_DefaultValue": { + "e00": 1.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 1.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 1.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.PropertyNode", + "m_ObjectId": "0f3d1062075e4033a1a07b86ad18eac5", + "m_Group": { + "m_Id": "4e7801ae7f8b4090be5d458121207cec" + }, + "m_Name": "Property", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -2261.0, + "y": -1178.0001220703125, + "width": 179.0, + "height": 34.0 + } + }, + "m_Slots": [ + { + "m_Id": "15136efc839e4710a95d38ddbc0238e1" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_Property": { + "m_Id": "99ad21e27a3f4d3cb1b1736abc28020d" + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.SubtractNode", + "m_ObjectId": "0fb3b92667984c7daa4c297dacb989bd", + "m_Group": { + "m_Id": "9392ab8fa6934d1a81cbe54f6c435b52" + }, + "m_Name": "Subtract", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": 337.0000305175781, + "y": -3758.0, + "width": 130.0, + "height": 117.99999237060547 + } + }, + "m_Slots": [ + { + "m_Id": "6b3cfb7f6e6b4a1794a6a9593f9a1dcc" + }, + { + "m_Id": "d9eb1465e8f14de4a6a52532ce9cc78e" + }, + { + "m_Id": "9b067b8ba62842f3a304c73318db241e" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.RedirectNodeData", + "m_ObjectId": "0fd9d87dd55e40e19062a26532caefbe", + "m_Group": { + "m_Id": "74c1d47e70e6422881a0e0f051febbb9" + }, + "m_Name": "Redirect Node", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -3827.0, + "y": -1359.0001220703125, + "width": 56.0, + "height": 24.0 + } + }, + "m_Slots": [ + { + "m_Id": "a30a9dd090df46038d0a14b857f11104" + }, + { + "m_Id": "d8ee3c89930d492b9319833d4889a7ea" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector3MaterialSlot", + "m_ObjectId": "10235c7bfd8241f9b461e2bb6da33a75", + "m_Id": 0, + "m_DisplayName": "In", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "In", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0 + }, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector3MaterialSlot", + "m_ObjectId": "10e5715ba6254eaaa741ce19ac481909", + "m_Id": 0, + "m_DisplayName": "In", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "In", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0 + }, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "1187631eba89423095054f58dc91993f", + "m_Id": 0, + "m_DisplayName": "Pupil Scale", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.MultiplyNode", + "m_ObjectId": "121c59319f834d9aae07910ab4759050", + "m_Group": { + "m_Id": "47b971716ee4470f865fc5c885abcf66" + }, + "m_Name": "Multiply", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -2229.0, + "y": -2779.999755859375, + "width": 126.0, + "height": 118.0 + } + }, + "m_Slots": [ + { + "m_Id": "2f063a1902e04bab9a0091ec269faf6d" + }, + { + "m_Id": "d21bc6827f54443b8394d13d6ffe892f" + }, + { + "m_Id": "609f2251422d4c2caabc1e7617e4fc77" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 1, + "m_Type": "UnityEditor.ShaderGraph.Internal.Vector1ShaderProperty", + "m_ObjectId": "13125e3e576e4c76b403dab13948fd74", + "m_Guid": { + "m_GuidSerialized": "d5986d33-a844-43ca-b102-b2817c8ba9fd" + }, + "m_Name": "Iris Depth", + "m_DefaultReferenceName": "", + "m_OverrideReferenceName": "_IrisDepth", + "m_GeneratePropertyBlock": true, + "m_Precision": 0, + "overrideHLSLDeclaration": false, + "hlslDeclarationOverride": 0, + "m_Hidden": false, + "m_Value": 0.004000000189989805, + "m_FloatType": 1, + "m_RangeValues": { + "x": 0.0, + "y": 0.009999999776482582 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.SamplerStateMaterialSlot", + "m_ObjectId": "13164f3fb38245228ea76bb6244912dc", + "m_Id": 3, + "m_DisplayName": "Sampler", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "Sampler", + "m_StageCapability": 3, + "m_BareResource": false +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "13555c6f540e46318c38dde20c6a0bef", + "m_Id": 2, + "m_DisplayName": "Y", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "Y", + "m_StageCapability": 3, + "m_Value": -1.0, + "m_DefaultValue": 0.0, + "m_Labels": [ + "Y" + ] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "13a56aed4baf40aead35c19bf77c6b17", + "m_Id": 0, + "m_DisplayName": "Shadow Hardness", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "142fa490279d434dbbdd86c9e939a7b4", + "m_Id": 4, + "m_DisplayName": "R", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "R", + "m_StageCapability": 2, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.StickyNoteData", + "m_ObjectId": "1445382bcb70439b8e2c097b4a733e73", + "m_Title": "HDRP", + "m_Content": "R = Metallic\nG = AO\nB = Micro Normal Mask\nA = Smoothness", + "m_TextSize": 0, + "m_Theme": 0, + "m_Position": { + "serializedVersion": "2", + "x": -1412.0, + "y": 371.0, + "width": 200.0, + "height": 100.0 + }, + "m_Group": { + "m_Id": "9be24d51d0344c13bc6aef014a27580b" + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicValueMaterialSlot", + "m_ObjectId": "147ad926e7fc4d2f9c2b449f7d6d0823", + "m_Id": 2, + "m_DisplayName": "Out", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": { + "e00": 0.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 0.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 0.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 0.0 + }, + "m_DefaultValue": { + "e00": 1.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 1.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 1.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "15136efc839e4710a95d38ddbc0238e1", + "m_Id": 0, + "m_DisplayName": "Limbus Dark Radius", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicValueMaterialSlot", + "m_ObjectId": "15170d0132fd48dba2b418c404c7ccb0", + "m_Id": 2, + "m_DisplayName": "Out", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": { + "e00": 0.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 0.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 0.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 0.0 + }, + "m_DefaultValue": { + "e00": 1.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 1.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 1.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.PropertyNode", + "m_ObjectId": "15f48b8faeb64c0cb4b648989f149d63", + "m_Group": { + "m_Id": "" + }, + "m_Name": "Property", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -1289.0001220703125, + "y": -2504.000244140625, + "width": 191.0, + "height": 34.000003814697269 + } + }, + "m_Slots": [ + { + "m_Id": "9cdf3221230e4655b7ddd4206eb1e16d" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_Property": { + "m_Id": "8200a5c208dd40fabbab6b6aca910116" + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.PropertyNode", + "m_ObjectId": "17cf5ef067934eb8aaa86b71fff89018", + "m_Group": { + "m_Id": "3d2583bfe59949a280911e6c487c911f" + }, + "m_Name": "Property", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -1131.000244140625, + "y": -301.99993896484377, + "width": 161.0, + "height": 34.0 + } + }, + "m_Slots": [ + { + "m_Id": "58e3c2f796054301922dfca0d44c8488" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_Property": { + "m_Id": "7a4f18355ba84582a3d56ed6b8c69762" + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.SubtractNode", + "m_ObjectId": "17dad3882c584470862c6e39310a2793", + "m_Group": { + "m_Id": "74c1d47e70e6422881a0e0f051febbb9" + }, + "m_Name": "Subtract", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -2107.999755859375, + "y": -1442.0001220703125, + "width": 126.00000762939453, + "height": 118.0 + } + }, + "m_Slots": [ + { + "m_Id": "c58f2ff8e21c49bba9f1dd24f1914bfc" + }, + { + "m_Id": "1d3f39f433a646b8858465d9562f2782" + }, + { + "m_Id": "b3326238a76649fb9cbf27c70039dddd" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.PropertyNode", + "m_ObjectId": "183ef9a03d1240da96ad473c17fdffb6", + "m_Group": { + "m_Id": "74c1d47e70e6422881a0e0f051febbb9" + }, + "m_Name": "Property", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -1706.9996337890625, + "y": -1444.0001220703125, + "width": 151.0, + "height": 34.0 + } + }, + "m_Slots": [ + { + "m_Id": "7d181f5420e94c97bedceb5dae5c368e" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_Property": { + "m_Id": "b618279ad2eb41bd9df25d9f412e0eb1" + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicValueMaterialSlot", + "m_ObjectId": "186d195e42d84be1876f2ec4fb35bd24", + "m_Id": 1, + "m_DisplayName": "B", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "B", + "m_StageCapability": 3, + "m_Value": { + "e00": 2.0, + "e01": 2.0, + "e02": 2.0, + "e03": 2.0, + "e10": 2.0, + "e11": 2.0, + "e12": 2.0, + "e13": 2.0, + "e20": 2.0, + "e21": 2.0, + "e22": 2.0, + "e23": 2.0, + "e30": 2.0, + "e31": 2.0, + "e32": 2.0, + "e33": 2.0 + }, + "m_DefaultValue": { + "e00": 1.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 1.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 1.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "1894eb32dcd549a2aa6479480e2df0f5", + "m_Id": 1, + "m_DisplayName": "B", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "B", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 1, + "m_Type": "UnityEditor.ShaderGraph.Internal.Vector1ShaderProperty", + "m_ObjectId": "195319a2066f492abb03e4f9fb29acfb", + "m_Guid": { + "m_GuidSerialized": "f766b3a7-886a-42c4-b340-a2b551b0639d" + }, + "m_Name": "Color Blend Strength", + "m_DefaultReferenceName": "Vector1_195319a2066f492abb03e4f9fb29acfb", + "m_OverrideReferenceName": "_ColorBlendStrength", + "m_GeneratePropertyBlock": true, + "m_Precision": 0, + "overrideHLSLDeclaration": false, + "hlslDeclarationOverride": 0, + "m_Hidden": false, + "m_Value": 0.20000000298023225, + "m_FloatType": 1, + "m_RangeValues": { + "x": 0.0, + "y": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicValueMaterialSlot", + "m_ObjectId": "19839492c9ce49f8974373551f2672ff", + "m_Id": 0, + "m_DisplayName": "A", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "A", + "m_StageCapability": 3, + "m_Value": { + "e00": 0.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 0.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 0.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 0.0 + }, + "m_DefaultValue": { + "e00": 1.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 1.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 1.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Texture2DMaterialSlot", + "m_ObjectId": "1a6dccb88a494fbebd6d32ab0323405b", + "m_Id": 0, + "m_DisplayName": "Mask Map", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_BareResource": false +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "1a81c47dfad348048ae6649ab8b3d627", + "m_Id": 0, + "m_DisplayName": "Sclera Hue", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicValueMaterialSlot", + "m_ObjectId": "1aa70d25934a4da3bf3c0298a76e9f76", + "m_Id": 2, + "m_DisplayName": "Out", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": { + "e00": 0.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 0.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 0.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 0.0 + }, + "m_DefaultValue": { + "e00": 1.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 1.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 1.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.MultiplyNode", + "m_ObjectId": "1b552b98d9514ccbb5e169cb39964939", + "m_Group": { + "m_Id": "74c1d47e70e6422881a0e0f051febbb9" + }, + "m_Name": "Multiply", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -2264.999755859375, + "y": -1504.0001220703125, + "width": 126.00000762939453, + "height": 118.0 + } + }, + "m_Slots": [ + { + "m_Id": "65595c71f75b4f48ac8e75db61ce6926" + }, + { + "m_Id": "b931e42ddc6a40bc8806b30b73d94b39" + }, + { + "m_Id": "cfcd38de19244c0884e93dbfc528a7ff" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "1ba8718d8a33493e9c2fb5fec78b8b36", + "m_Id": 1, + "m_DisplayName": "Out", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "1d3f39f433a646b8858465d9562f2782", + "m_Id": 1, + "m_DisplayName": "B", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "B", + "m_StageCapability": 3, + "m_Value": { + "x": 180.0, + "y": 1.0, + "z": 1.0, + "w": 1.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "1dd067f750724bbc991357e710efc4e2", + "m_Id": 3, + "m_DisplayName": "Out", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "1e5317f353e6433b9a72c5d9cf2aa656", + "m_Id": 3, + "m_DisplayName": "Opacity", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "Opacity", + "m_StageCapability": 3, + "m_Value": 1.0, + "m_DefaultValue": 1.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.MultiplyNode", + "m_ObjectId": "1ec2d9d1e5ea4e2b948b63854493990a", + "m_Group": { + "m_Id": "9392ab8fa6934d1a81cbe54f6c435b52" + }, + "m_Name": "Multiply", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": 148.00010681152345, + "y": -3574.0, + "width": 130.0, + "height": 117.99999237060547 + } + }, + "m_Slots": [ + { + "m_Id": "53fdffd517c74097b4a92066bbe36456" + }, + { + "m_Id": "3a66d951de9649f8980c353d9341fb7d" + }, + { + "m_Id": "c082e1fff8084103a2377f8707917419" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "1f7600f576a144378c1b967f51ce97fd", + "m_Id": 0, + "m_DisplayName": "Sclera Brightness", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector2MaterialSlot", + "m_ObjectId": "1ffc4b6a652d4a45856b15ca84a6c3e3", + "m_Id": 1, + "m_DisplayName": "In Min Max", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "InMinMax", + "m_StageCapability": 3, + "m_Value": { + "x": -1.0, + "y": 1.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0 + }, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "203ac1fb2a184cd5bb42f0b2422b2d57", + "m_Id": 0, + "m_DisplayName": "In", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "In", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.RedirectNodeData", + "m_ObjectId": "20f411cc610844238669a33ff803c095", + "m_Group": { + "m_Id": "" + }, + "m_Name": "Redirect Node", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -6242.0, + "y": -1192.9998779296875, + "width": 55.999996185302737, + "height": 24.0 + } + }, + "m_Slots": [ + { + "m_Id": "a316e6e915c54b1aa1fcddb9dda15182" + }, + { + "m_Id": "95251db95bb34e64b4a84ec66799e009" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "20f4ac75903d4ff5b93ae1dbda55208f", + "m_Id": 0, + "m_DisplayName": "", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.PropertyNode", + "m_ObjectId": "212fcf1563454809ac6e02adac40b4cb", + "m_Group": { + "m_Id": "4a0e19aa85024f47a32faf9b1d3f2868" + }, + "m_Name": "Property", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -1564.9998779296875, + "y": 1034.0, + "width": 180.99998474121095, + "height": 34.0 + } + }, + "m_Slots": [ + { + "m_Id": "f872667b17f0412db6b76772fe301fa5" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_Property": { + "m_Id": "cd32d6c896b4474aa36ec555723b81ef" + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicValueMaterialSlot", + "m_ObjectId": "220d1478c3bf468aa1c158cc00240820", + "m_Id": 0, + "m_DisplayName": "A", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "A", + "m_StageCapability": 3, + "m_Value": { + "e00": 0.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 0.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 0.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 0.0 + }, + "m_DefaultValue": { + "e00": 1.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 1.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 1.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector2Node", + "m_ObjectId": "237cca6b5408464591f064193a8b6ac5", + "m_Group": { + "m_Id": "3366f611f8464c988208f0daa49f30d2" + }, + "m_Name": "Vector 2", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -1190.9996337890625, + "y": -3548.0, + "width": 128.0, + "height": 100.99999237060547 + } + }, + "m_Slots": [ + { + "m_Id": "309ba45b875d45819f6978d7ae3464ff" + }, + { + "m_Id": "c20ea245c4f243039fc4190ff1ccbffd" + }, + { + "m_Id": "f846dbf7c3344ec3912b7e42211aa123" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_Value": { + "x": 0.0, + "y": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicValueMaterialSlot", + "m_ObjectId": "23dc2c9219da401294112932b2517141", + "m_Id": 0, + "m_DisplayName": "A", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "A", + "m_StageCapability": 3, + "m_Value": { + "e00": 0.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 0.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 0.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 0.0 + }, + "m_DefaultValue": { + "e00": 1.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 1.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 1.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "23e7e1ff7e7a47e7b01446d915db2fd1", + "m_Id": 1, + "m_DisplayName": "B", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "B", + "m_StageCapability": 3, + "m_Value": { + "x": 180.0, + "y": 1.0, + "z": 1.0, + "w": 1.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "24528f9eefb74c90808567a74939c239", + "m_Id": 0, + "m_DisplayName": "", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicValueMaterialSlot", + "m_ObjectId": "249bdbf3a7b54c81995f0c6b7ee261e4", + "m_Id": 2, + "m_DisplayName": "Out", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": { + "e00": 0.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 0.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 0.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 0.0 + }, + "m_DefaultValue": { + "e00": 1.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 1.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 1.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "2665f44e25394fda89ce9578c3341a73", + "m_Id": 5, + "m_DisplayName": "G", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "G", + "m_StageCapability": 2, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "2761123d8c004cf69bf09bf1893cda1f", + "m_Id": 0, + "m_DisplayName": "Limbus Dark Width", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "28292acb81814d0aa8a183f319e5bff8", + "m_Id": 4, + "m_DisplayName": "R", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "R", + "m_StageCapability": 2, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "288904dfd46f4601ad2559e9e2754b1b", + "m_Id": 0, + "m_DisplayName": "In", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "In", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "29a57cacc8dd476298c59cbc7701687a", + "m_Id": 4, + "m_DisplayName": "R", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "R", + "m_StageCapability": 2, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "29b7b989e16e4e458499d6ded4245332", + "m_Id": 1, + "m_DisplayName": "", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.Rendering.HighDefinition.ShaderGraph.LightingData", + "m_ObjectId": "2a2960edadd1494c8e81b3d852cb3297", + "m_NormalDropOffSpace": 0, + "m_BlendPreserveSpecular": true, + "m_ReceiveDecals": true, + "m_ReceiveSSR": true, + "m_ReceiveSSRTransparent": true, + "m_SpecularAA": false, + "m_SpecularOcclusionMode": 1, + "m_OverrideBakedGI": false +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "2aeea975d6b34a0391f0bea14cbe2821", + "m_Id": 2, + "m_DisplayName": "Out", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DivideNode", + "m_ObjectId": "2c091c6528664f6797d8a54f8327744d", + "m_Group": { + "m_Id": "74c1d47e70e6422881a0e0f051febbb9" + }, + "m_Name": "Divide", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -3140.999755859375, + "y": -1740.0001220703125, + "width": 126.00000762939453, + "height": 118.0 + } + }, + "m_Slots": [ + { + "m_Id": "32b3f5bfdc8f49739913cda2bbd73cab" + }, + { + "m_Id": "b7dbd6eb03894ec9a37f938cc3dee429" + }, + { + "m_Id": "db1536b3565145a5ad2cc1af0c4a7af8" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Texture2DInputMaterialSlot", + "m_ObjectId": "2c2d2e77a319444db369b815efb9541b", + "m_Id": 1, + "m_DisplayName": "Texture", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "Texture", + "m_StageCapability": 3, + "m_BareResource": false, + "m_Texture": { + "m_SerializedTexture": "{\"texture\":{\"instanceID\":0}}", + "m_Guid": "" + }, + "m_DefaultType": 0 +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "2d0e21ace72d4af6a4418e6c9be82a69", + "m_Id": 2, + "m_DisplayName": "Out", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.MultiplyNode", + "m_ObjectId": "2d62f4a8544b460b9f314e90db6ec04c", + "m_Group": { + "m_Id": "69bc229b1eb94e15a47d971b447a3198" + }, + "m_Name": "Multiply", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -2307.000244140625, + "y": -2193.999755859375, + "width": 126.0, + "height": 118.0 + } + }, + "m_Slots": [ + { + "m_Id": "06d5e9feef0b415f9aadb19d0f0c13f7" + }, + { + "m_Id": "4df2a7d633e841eda213de8a22f05734" + }, + { + "m_Id": "f1c8d35381fc40158eddade6c98f2385" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.SamplerStateMaterialSlot", + "m_ObjectId": "2e4fbebcdf1e4ae1845461d0f6ad3cdb", + "m_Id": 3, + "m_DisplayName": "Sampler", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "Sampler", + "m_StageCapability": 3, + "m_BareResource": false +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "2e678ee544dd4562b0e91ec084af54fb", + "m_Id": 2, + "m_DisplayName": "Out", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.PropertyNode", + "m_ObjectId": "2ec9dabee0914c97837fd58570d86f21", + "m_Group": { + "m_Id": "06ed9322d6854bb2b1d9cb30cd928b6d" + }, + "m_Name": "Property", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -1147.000244140625, + "y": -527.0, + "width": 177.0, + "height": 34.0 + } + }, + "m_Slots": [ + { + "m_Id": "058edbfc60e64768aa440ef74321056e" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_Property": { + "m_Id": "ab45ac5b088b42518d305de12d5f3763" + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "2ecf355b89624f87b560fa1a7a89cb0a", + "m_Id": 0, + "m_DisplayName": "In", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "In", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicValueMaterialSlot", + "m_ObjectId": "2f063a1902e04bab9a0091ec269faf6d", + "m_Id": 0, + "m_DisplayName": "A", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "A", + "m_StageCapability": 3, + "m_Value": { + "e00": 0.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 0.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 0.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 0.0 + }, + "m_DefaultValue": { + "e00": 1.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 1.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 1.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "2f61fbdc45164b15b904d7180446c877", + "m_Id": 2, + "m_DisplayName": "Out", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "2f7c8f0930a54914b0e28ad3a01aff66", + "m_Id": 0, + "m_DisplayName": "Cornea Smoothness", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.PropertyNode", + "m_ObjectId": "2fdbc960f1a24a368326646c19f3916d", + "m_Group": { + "m_Id": "3366f611f8464c988208f0daa49f30d2" + }, + "m_Name": "Property", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -1600.999755859375, + "y": -3432.0, + "width": 146.0, + "height": 34.0 + } + }, + "m_Slots": [ + { + "m_Id": "98a0f05c542d4304b34e1574db1c11ac" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_Property": { + "m_Id": "424271c2190c4f42b931a851e201c75d" + } +} + +{ + "m_SGVersion": 1, + "m_Type": "UnityEditor.ShaderGraph.Internal.Vector1ShaderProperty", + "m_ObjectId": "2fe3d3e44e8646f3a00409c36bc1a98e", + "m_Guid": { + "m_GuidSerialized": "790d7842-1738-458e-9df2-9be5de05085d" + }, + "m_Name": "Shadow Radius", + "m_DefaultReferenceName": "Vector1_2fe3d3e44e8646f3a00409c36bc1a98e", + "m_OverrideReferenceName": "_ShadowRadius", + "m_GeneratePropertyBlock": true, + "m_Precision": 0, + "overrideHLSLDeclaration": false, + "hlslDeclarationOverride": 0, + "m_Hidden": false, + "m_Value": 0.2750000059604645, + "m_FloatType": 1, + "m_RangeValues": { + "x": 0.0, + "y": 1.0 + } +} + +{ + "m_SGVersion": 1, + "m_Type": "UnityEditor.ShaderGraph.Internal.Vector1ShaderProperty", + "m_ObjectId": "308a2ce997744f8cb41204c209af692a", + "m_Guid": { + "m_GuidSerialized": "e58405f8-10e7-4c76-a323-5d60d1cf4415" + }, + "m_Name": "Limbus Dark Width", + "m_DefaultReferenceName": "Vector1_308a2ce997744f8cb41204c209af692a", + "m_OverrideReferenceName": "_LimbusDarkWidth", + "m_GeneratePropertyBlock": true, + "m_Precision": 0, + "overrideHLSLDeclaration": false, + "hlslDeclarationOverride": 0, + "m_Hidden": false, + "m_Value": 0.054999999701976779, + "m_FloatType": 1, + "m_RangeValues": { + "x": 0.009999999776482582, + "y": 0.10000000149011612 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "3098d75fac454ef0a3a6c126d80701cc", + "m_Id": 0, + "m_DisplayName": "IsCornea", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "309ba45b875d45819f6978d7ae3464ff", + "m_Id": 1, + "m_DisplayName": "X", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "X", + "m_StageCapability": 3, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "30c24ea480ef4f75a17e162be363f368", + "m_Id": 5, + "m_DisplayName": "G", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "G", + "m_StageCapability": 2, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.SubtractNode", + "m_ObjectId": "30c9f960d0614a9c86d6adb950404ba4", + "m_Group": { + "m_Id": "47b971716ee4470f865fc5c885abcf66" + }, + "m_Name": "Subtract", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -2042.0001220703125, + "y": -2708.999755859375, + "width": 126.0, + "height": 118.0 + } + }, + "m_Slots": [ + { + "m_Id": "7ebf2a5e35ee4bcc92611c69e93b5692" + }, + { + "m_Id": "23e7e1ff7e7a47e7b01446d915db2fd1" + }, + { + "m_Id": "64008aecf2ef48278ac62d0e32a0afe2" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "32b3f5bfdc8f49739913cda2bbd73cab", + "m_Id": 0, + "m_DisplayName": "A", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "A", + "m_StageCapability": 3, + "m_Value": { + "x": 1.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Internal.Texture2DShaderProperty", + "m_ObjectId": "3345a7b9279a48b7ba4602df55d812ac", + "m_Guid": { + "m_GuidSerialized": "11573659-5da7-4813-a954-c0a0d3d0de68" + }, + "m_Name": "Mask Map", + "m_DefaultReferenceName": "Texture2D_3345a7b9279a48b7ba4602df55d812ac", + "m_OverrideReferenceName": "_MaskMap", + "m_GeneratePropertyBlock": true, + "m_Precision": 0, + "overrideHLSLDeclaration": false, + "hlslDeclarationOverride": 0, + "m_Hidden": false, + "m_Value": { + "m_SerializedTexture": "{\"texture\":{\"instanceID\":0}}", + "m_Guid": "" + }, + "m_Modifiable": true, + "m_DefaultType": 0 +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "3348a973507449dea65b44492af527fa", + "m_Id": 3, + "m_DisplayName": "Out", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "33511b23ad3544aeb14caf923295944e", + "m_Id": 0, + "m_DisplayName": "IsCornea", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.GroupData", + "m_ObjectId": "3366f611f8464c988208f0daa49f30d2", + "m_Title": "Iris Depth Mask", + "m_Position": { + "x": -1625.9998779296875, + "y": -3633.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.PropertyNode", + "m_ObjectId": "33bbe060abf846e885adc11afabebbff", + "m_Group": { + "m_Id": "a145967c42cb43d59d7699fc064ab763" + }, + "m_Name": "Property", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -2006.9996337890625, + "y": -3412.0, + "width": 123.0, + "height": 34.0 + } + }, + "m_Slots": [ + { + "m_Id": "df223b2eb4414442838bccf1e46f2d17" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_Property": { + "m_Id": "85e5e0cd46aa44fc8e9f720d375bec49" + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.Rendering.HighDefinition.ShaderGraph.HDLitSubTarget", + "m_ObjectId": "33fbdbd78d05438187210437b060626d" +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector2MaterialSlot", + "m_ObjectId": "34e1a46a7dfb4a82abdb3da5e3a851f2", + "m_Id": 2, + "m_DisplayName": "Out Min Max", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "OutMinMax", + "m_StageCapability": 3, + "m_Value": { + "x": 1.0, + "y": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0 + }, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.RedirectNodeData", + "m_ObjectId": "34f42febbc9c455296ef74e39666c168", + "m_Group": { + "m_Id": "e2d8030e74824bb48369331f4775f0ac" + }, + "m_Name": "Redirect Node", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -5525.0, + "y": -299.0000305175781, + "width": 56.0, + "height": 23.999998092651368 + } + }, + "m_Slots": [ + { + "m_Id": "f85cbec02ced4f41bdff94e6aef90240" + }, + { + "m_Id": "798fd82b00f54b18b0cb9dfdb83a2ac2" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "3544150e55ab4845ae13aa533e6504b0", + "m_Id": 5, + "m_DisplayName": "G", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "G", + "m_StageCapability": 2, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector2MaterialSlot", + "m_ObjectId": "3642fc47c2b344049dc360a662bad5f8", + "m_Id": 1, + "m_DisplayName": "Tiling", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "Tiling", + "m_StageCapability": 3, + "m_Value": { + "x": 1.0, + "y": 1.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0 + }, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.RemapNode", + "m_ObjectId": "365dce71ec05435a85200a53c1026b6d", + "m_Group": { + "m_Id": "69bc229b1eb94e15a47d971b447a3198" + }, + "m_Name": "Remap", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -1814.0, + "y": -2452.999755859375, + "width": 207.99998474121095, + "height": 326.0 + } + }, + "m_Slots": [ + { + "m_Id": "398ac8877ad2432fbfcc6a77b69e2286" + }, + { + "m_Id": "1ffc4b6a652d4a45856b15ca84a6c3e3" + }, + { + "m_Id": "ab2ac5232d8b43beb48733b10113e874" + }, + { + "m_Id": "04e97b02b2fd425ea097ad32cb34402e" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.PropertyNode", + "m_ObjectId": "368ef12a048b4592bec306aa78b6c949", + "m_Group": { + "m_Id": "" + }, + "m_Name": "Property", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": 1156.0, + "y": 323.0, + "width": 94.0, + "height": 34.0 + } + }, + "m_Slots": [ + { + "m_Id": "72746d264455473282191757b9235a6d" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_Property": { + "m_Id": "b0ec1f6d5bd0419796b5090e7dffabf7" + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicValueMaterialSlot", + "m_ObjectId": "36da7aa1936b4139bf77b6393a2e73b8", + "m_Id": 0, + "m_DisplayName": "A", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "A", + "m_StageCapability": 3, + "m_Value": { + "e00": 0.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 0.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 0.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 0.0 + }, + "m_DefaultValue": { + "e00": 1.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 1.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 1.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "37502e011dba43adad5a4c1965f0daf5", + "m_Id": 5, + "m_DisplayName": "G", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "G", + "m_StageCapability": 2, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.RedirectNodeData", + "m_ObjectId": "37e75d0888474abd902621830e017f7f", + "m_Group": { + "m_Id": "" + }, + "m_Name": "Redirect Node", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -1800.999755859375, + "y": -369.0000305175781, + "width": 56.0, + "height": 23.999998092651368 + } + }, + "m_Slots": [ + { + "m_Id": "5ba3432ec167402f85822cc0e7557309" + }, + { + "m_Id": "681fb86a7ece4cf1a5b3da0c95dc2d8f" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.PropertyNode", + "m_ObjectId": "3853f500618142f187137289e75735bd", + "m_Group": { + "m_Id": "74c1d47e70e6422881a0e0f051febbb9" + }, + "m_Name": "Property", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -3885.0, + "y": -1737.0, + "width": 123.0, + "height": 34.0 + } + }, + "m_Slots": [ + { + "m_Id": "a21a119790b24b098e7e4112b39bbdc6" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_Property": { + "m_Id": "85e5e0cd46aa44fc8e9f720d375bec49" + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "39386b6507884a3e8917400adc0c599b", + "m_Id": 0, + "m_DisplayName": "Thickness", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "Thickness", + "m_StageCapability": 2, + "m_Value": 0.12999999523162843, + "m_DefaultValue": 1.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "398ac8877ad2432fbfcc6a77b69e2286", + "m_Id": 0, + "m_DisplayName": "In", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "In", + "m_StageCapability": 3, + "m_Value": { + "x": -1.0, + "y": -1.0, + "z": -1.0, + "w": -1.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 1, + "m_Type": "UnityEditor.ShaderGraph.Internal.Vector1ShaderProperty", + "m_ObjectId": "3a3f4cc5a3574e32b762b0cb62cd67cf", + "m_Guid": { + "m_GuidSerialized": "eea42818-ed87-4721-86fe-cdc624288d38" + }, + "m_Name": "Cornea Smoothness", + "m_DefaultReferenceName": "", + "m_OverrideReferenceName": "_CorneaSmoothness", + "m_GeneratePropertyBlock": true, + "m_Precision": 0, + "overrideHLSLDeclaration": false, + "hlslDeclarationOverride": 0, + "m_Hidden": false, + "m_Value": 1.0, + "m_FloatType": 1, + "m_RangeValues": { + "x": 0.0, + "y": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicValueMaterialSlot", + "m_ObjectId": "3a66d951de9649f8980c353d9341fb7d", + "m_Id": 1, + "m_DisplayName": "B", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "B", + "m_StageCapability": 3, + "m_Value": { + "e00": 2.0, + "e01": 2.0, + "e02": 2.0, + "e03": 2.0, + "e10": 2.0, + "e11": 2.0, + "e12": 2.0, + "e13": 2.0, + "e20": 2.0, + "e21": 2.0, + "e22": 2.0, + "e23": 2.0, + "e30": 2.0, + "e31": 2.0, + "e32": 2.0, + "e33": 2.0 + }, + "m_DefaultValue": { + "e00": 1.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 1.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 1.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector4MaterialSlot", + "m_ObjectId": "3afeb051dfc6480fbba18c4838ea4db2", + "m_Id": 0, + "m_DisplayName": "RGBA", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "RGBA", + "m_StageCapability": 2, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicValueMaterialSlot", + "m_ObjectId": "3b2b8f934cd14b73ab7474da780b18ee", + "m_Id": 0, + "m_DisplayName": "A", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "A", + "m_StageCapability": 3, + "m_Value": { + "e00": 0.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 0.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 0.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 0.0 + }, + "m_DefaultValue": { + "e00": 1.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 1.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 1.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector3MaterialSlot", + "m_ObjectId": "3b2c7f94386c4c438dbb37d39b762857", + "m_Id": 0, + "m_DisplayName": "In", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "In", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0 + }, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector2MaterialSlot", + "m_ObjectId": "3b65f7d41ee44ad3a71241e0f6862213", + "m_Id": 2, + "m_DisplayName": "Out Min Max", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "OutMinMax", + "m_StageCapability": 3, + "m_Value": { + "x": 1.0, + "y": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0 + }, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "3b6726149f5f41b0bbb0c78e613474bf", + "m_Id": 0, + "m_DisplayName": "A", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "A", + "m_StageCapability": 3, + "m_Value": { + "x": 1.0, + "y": 1.0, + "z": 1.0, + "w": 1.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.NormalMaterialSlot", + "m_ObjectId": "3b9bea9727174fc0b9e705617c9903db", + "m_Id": 0, + "m_DisplayName": "Normal", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "Normal", + "m_StageCapability": 1, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0 + }, + "m_Labels": [], + "m_Space": 0 +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "3bb9c7ad43ad42a680432cca5d69479f", + "m_Id": 1, + "m_DisplayName": "X", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "X", + "m_StageCapability": 3, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.RedirectNodeData", + "m_ObjectId": "3c3d298450c64c50afd6e62d79cd27c3", + "m_Group": { + "m_Id": "06ed9322d6854bb2b1d9cb30cd928b6d" + }, + "m_Name": "Redirect Node", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -1147.000244140625, + "y": -469.0000305175781, + "width": 56.0, + "height": 23.999998092651368 + } + }, + "m_Slots": [ + { + "m_Id": "f91e66ff4138405a8f08e2819edc9647" + }, + { + "m_Id": "571a527f603a43bca479373face210b4" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "3c46e274f0324cd0b81a99270196c3d4", + "m_Id": 2, + "m_DisplayName": "T", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "T", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.PropertyNode", + "m_ObjectId": "3c7bca46d3ed4ae5b7df3592da5f774c", + "m_Group": { + "m_Id": "47b971716ee4470f865fc5c885abcf66" + }, + "m_Name": "Property", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -2760.0, + "y": -3017.999755859375, + "width": 183.0, + "height": 34.0 + } + }, + "m_Slots": [ + { + "m_Id": "54c417981f6748e8b7660477bf48c8a9" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_Property": { + "m_Id": "cb42572a46a74a588ef3935f3a667eb7" + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.GroupData", + "m_ObjectId": "3d2583bfe59949a280911e6c487c911f", + "m_Title": "Eye Smoothness", + "m_Position": { + "x": -1172.0006103515625, + "y": -374.0000915527344 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "3d37ddc8f42f42f59c61f8fa5fa31616", + "m_Id": 1, + "m_DisplayName": "", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.MultiplyNode", + "m_ObjectId": "3d55130b7f36439aba23579a436a27e0", + "m_Group": { + "m_Id": "3366f611f8464c988208f0daa49f30d2" + }, + "m_Name": "Multiply", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -1404.9998779296875, + "y": -3433.0, + "width": 126.0, + "height": 117.99999237060547 + } + }, + "m_Slots": [ + { + "m_Id": "19839492c9ce49f8974373551f2672ff" + }, + { + "m_Id": "9bc98f2daa24404fbc5f9721fd4113f6" + }, + { + "m_Id": "694521ea103a41cb984a053f05ef204f" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "3e1e74cd69784bce98955b9cc58c2b70", + "m_Id": 0, + "m_DisplayName": "Limbus Width", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.RedirectNodeData", + "m_ObjectId": "3e5e7df4e7e54e6689aec588fd71466c", + "m_Group": { + "m_Id": "4e7801ae7f8b4090be5d458121207cec" + }, + "m_Name": "Redirect Node", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -2252.999755859375, + "y": -886.000244140625, + "width": 56.0, + "height": 24.0 + } + }, + "m_Slots": [ + { + "m_Id": "acadc79c12b24f04899ef27da96d24b8" + }, + { + "m_Id": "d9be8f35b6704ecd81573ad62cda5351" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.RedirectNodeData", + "m_ObjectId": "3e65b49e5c9849f88b9fdadb71b1e174", + "m_Group": { + "m_Id": "fa7b0f3ba7d84ba7a4d19d87b7a3c4b8" + }, + "m_Name": "Redirect Node", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -4988.0, + "y": -1169.0001220703125, + "width": 56.0, + "height": 24.0 + } + }, + "m_Slots": [ + { + "m_Id": "24528f9eefb74c90808567a74939c239" + }, + { + "m_Id": "9abd7eee5b4f4b1ca3bd01fc278fde82" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.KeywordNode", + "m_ObjectId": "3e710f1fde3941e190479a99812135ab", + "m_Group": { + "m_Id": "77f65f494a034b2a9cf1395ba40d3843" + }, + "m_Name": "IsCornea", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -25.99995231628418, + "y": -146.9999542236328, + "width": 163.0, + "height": 118.0 + } + }, + "m_Slots": [ + { + "m_Id": "33511b23ad3544aeb14caf923295944e" + }, + { + "m_Id": "ce15578385444ba8846416a053838b72" + }, + { + "m_Id": "d3050bb948f34c6c9c1458f64c3e6b9f" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_Keyword": { + "m_Id": "9d63910b86f7439f9642f08926860a8e" + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "3ed6c2670f1c4f1a9248bb3bc7cef75e", + "m_Id": 1, + "m_DisplayName": "Out", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.UVMaterialSlot", + "m_ObjectId": "3fc77882b22d49258fdd335de5111e96", + "m_Id": 2, + "m_DisplayName": "UV", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "UV", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0 + }, + "m_Labels": [], + "m_Channel": 0 +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.MultiplyNode", + "m_ObjectId": "403fb33619f946bab63f336ed9285011", + "m_Group": { + "m_Id": "9392ab8fa6934d1a81cbe54f6c435b52" + }, + "m_Name": "Multiply", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -58.99945831298828, + "y": -3450.0, + "width": 126.0, + "height": 117.99999237060547 + } + }, + "m_Slots": [ + { + "m_Id": "4670d175599d4f099082fcd055cdd1bf" + }, + { + "m_Id": "926f9ec0aedf47b0b73aa80ebf531fbc" + }, + { + "m_Id": "dfda96da820644e885551676c785ce72" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 1, + "m_Type": "UnityEditor.ShaderGraph.Internal.Vector1ShaderProperty", + "m_ObjectId": "410287977f3941ae86357b91bb50c332", + "m_Guid": { + "m_GuidSerialized": "3cfb40c6-754d-4909-b812-a16a145a6a93" + }, + "m_Name": "Sclera Saturation", + "m_DefaultReferenceName": "Vector1_410287977f3941ae86357b91bb50c332", + "m_OverrideReferenceName": "_ScleraSaturation", + "m_GeneratePropertyBlock": true, + "m_Precision": 0, + "overrideHLSLDeclaration": false, + "hlslDeclarationOverride": 0, + "m_Hidden": false, + "m_Value": 1.0, + "m_FloatType": 1, + "m_RangeValues": { + "x": 0.0, + "y": 2.0 + } +} + +{ + "m_SGVersion": 1, + "m_Type": "UnityEditor.ShaderGraph.Internal.Vector1ShaderProperty", + "m_ObjectId": "424271c2190c4f42b931a851e201c75d", + "m_Guid": { + "m_GuidSerialized": "77cf6243-66d3-41f0-b3fd-5d821cd6d1ce" + }, + "m_Name": "Depth Radius", + "m_DefaultReferenceName": "", + "m_OverrideReferenceName": "_DepthRadius", + "m_GeneratePropertyBlock": true, + "m_Precision": 0, + "overrideHLSLDeclaration": false, + "hlslDeclarationOverride": 0, + "m_Hidden": false, + "m_Value": 0.800000011920929, + "m_FloatType": 1, + "m_RangeValues": { + "x": 0.0, + "y": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "424b313138944a21bc404c418bcb085e", + "m_Id": 0, + "m_DisplayName": "Alpha", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "Alpha", + "m_StageCapability": 2, + "m_Value": 1.0, + "m_DefaultValue": 1.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.BlockNode", + "m_ObjectId": "426aa34785084a549dbd9d591d997b49", + "m_Group": { + "m_Id": "" + }, + "m_Name": "SurfaceDescription.RefractionDistance", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": 1333.0, + "y": 156.0, + "width": 200.0, + "height": 41.0 + } + }, + "m_Slots": [ + { + "m_Id": "761ab34284dd4f13a33ee4ad69c23305" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_SerializedDescriptor": "SurfaceDescription.RefractionDistance" +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "42b641249a6f420f9a02a643c7b4ff03", + "m_Id": 0, + "m_DisplayName": "", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.PropertyNode", + "m_ObjectId": "42ba018b3a414c4485ab942ebf69a4ad", + "m_Group": { + "m_Id": "47b971716ee4470f865fc5c885abcf66" + }, + "m_Name": "Property", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -2451.0, + "y": -2739.999755859375, + "width": 131.0, + "height": 34.0 + } + }, + "m_Slots": [ + { + "m_Id": "1a81c47dfad348048ae6649ab8b3d627" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_Property": { + "m_Id": "451cc7559488456fb2d601ba459f41da" + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.MultiplyNode", + "m_ObjectId": "43387ad609f94947a6ae070b34ae1dcf", + "m_Group": { + "m_Id": "a145967c42cb43d59d7699fc064ab763" + }, + "m_Name": "Multiply", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -1836.9998779296875, + "y": -3412.0, + "width": 126.0, + "height": 117.99999237060547 + } + }, + "m_Slots": [ + { + "m_Id": "eba76b95d2f24b7ea8461e9724a32b43" + }, + { + "m_Id": "0f0f4ffc9fc247e0b2b23170a98dc7f4" + }, + { + "m_Id": "6bb3949a13e14dc38afcbf2c05bd6eda" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "4352269c252a44fab28c58e0f79731b8", + "m_Id": 0, + "m_DisplayName": "", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicValueMaterialSlot", + "m_ObjectId": "43ed3a5249a9482fa5cdcab24c533cb5", + "m_Id": 1, + "m_DisplayName": "B", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "B", + "m_StageCapability": 3, + "m_Value": { + "e00": 2.0, + "e01": 2.0, + "e02": 2.0, + "e03": 2.0, + "e10": 2.0, + "e11": 2.0, + "e12": 2.0, + "e13": 2.0, + "e20": 2.0, + "e21": 2.0, + "e22": 2.0, + "e23": 2.0, + "e30": 2.0, + "e31": 2.0, + "e32": 2.0, + "e33": 2.0 + }, + "m_DefaultValue": { + "e00": 1.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 1.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 1.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 1.0 + } +} + +{ + "m_SGVersion": 1, + "m_Type": "UnityEditor.ShaderGraph.Internal.Vector1ShaderProperty", + "m_ObjectId": "451cc7559488456fb2d601ba459f41da", + "m_Guid": { + "m_GuidSerialized": "c89f899d-e213-482e-ae96-a031053cff9a" + }, + "m_Name": "Sclera Hue", + "m_DefaultReferenceName": "Vector1_451cc7559488456fb2d601ba459f41da", + "m_OverrideReferenceName": "_ScleraHue", + "m_GeneratePropertyBlock": true, + "m_Precision": 0, + "overrideHLSLDeclaration": false, + "hlslDeclarationOverride": 0, + "m_Hidden": false, + "m_Value": 0.5, + "m_FloatType": 1, + "m_RangeValues": { + "x": 0.0, + "y": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "453efad891df44bc980eb92f8308d21d", + "m_Id": 0, + "m_DisplayName": "A", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "A", + "m_StageCapability": 3, + "m_Value": { + "x": 1.0, + "y": 1.0, + "z": 1.0, + "w": 1.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "464bdc58fcf04a0bb78dfc88d781b5c8", + "m_Id": 0, + "m_DisplayName": "Edge1", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "Edge1", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector3MaterialSlot", + "m_ObjectId": "46519d6a33a448aaa3c5ea5132944065", + "m_Id": 0, + "m_DisplayName": "In", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "In", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0 + }, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicValueMaterialSlot", + "m_ObjectId": "4670d175599d4f099082fcd055cdd1bf", + "m_Id": 0, + "m_DisplayName": "A", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "A", + "m_StageCapability": 3, + "m_Value": { + "e00": 0.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 0.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 0.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 0.0 + }, + "m_DefaultValue": { + "e00": 1.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 1.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 1.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.GroupData", + "m_ObjectId": "47b971716ee4470f865fc5c885abcf66", + "m_Title": "Cornea (Sclera) Base Color", + "m_Position": { + "x": -3560.99951171875, + "y": -3076.999755859375 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.SubtractNode", + "m_ObjectId": "48e7aa14004241f09e40927e5502db5f", + "m_Group": { + "m_Id": "0ca230dd81f04c0ba5af42953674323c" + }, + "m_Name": "Subtract", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -5802.99951171875, + "y": -767.9999389648438, + "width": 207.99998474121095, + "height": 301.9999694824219 + } + }, + "m_Slots": [ + { + "m_Id": "453efad891df44bc980eb92f8308d21d" + }, + { + "m_Id": "018aa566bd894a168b0a4f4ef557f03a" + }, + { + "m_Id": "2f61fbdc45164b15b904d7180446c877" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicValueMaterialSlot", + "m_ObjectId": "492946e2a17a4cdaa02fa523c6e6a17b", + "m_Id": 2, + "m_DisplayName": "Out", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": { + "e00": 0.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 0.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 0.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 0.0 + }, + "m_DefaultValue": { + "e00": 1.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 1.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 1.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "492d9879d2ee4029ac205d75fc74acb1", + "m_Id": 0, + "m_DisplayName": "Iris Depth", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.MultiplyNode", + "m_ObjectId": "4980ab94dd794acb861d2bff4da45b6c", + "m_Group": { + "m_Id": "fa7b0f3ba7d84ba7a4d19d87b7a3c4b8" + }, + "m_Name": "Multiply", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -5246.0, + "y": -1263.0001220703125, + "width": 126.00000762939453, + "height": 118.0 + } + }, + "m_Slots": [ + { + "m_Id": "f7fa5689a92f4268ae519412e2edfc2d" + }, + { + "m_Id": "a5ef1c379ba648e19eb6388b655b8bd9" + }, + { + "m_Id": "542f0cf230a9407aa67a4f4a75ac8cd0" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.PropertyNode", + "m_ObjectId": "49d17ba692cf4ddfa5689031410f9af7", + "m_Group": { + "m_Id": "06ed9322d6854bb2b1d9cb30cd928b6d" + }, + "m_Name": "Property", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -1152.000244140625, + "y": -570.0, + "width": 182.0, + "height": 34.0 + } + }, + "m_Slots": [ + { + "m_Id": "2f7c8f0930a54914b0e28ad3a01aff66" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_Property": { + "m_Id": "3a3f4cc5a3574e32b762b0cb62cd67cf" + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.GroupData", + "m_ObjectId": "4a0e19aa85024f47a32faf9b1d3f2868", + "m_Title": "Sclera (Micro) Normals", + "m_Position": { + "x": -1590.00048828125, + "y": 850.0001831054688 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "4a493e2360004ad3b5f9be266ddcebef", + "m_Id": 0, + "m_DisplayName": "Color Blend Strength", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "4abf288a6e92496a981ad403c6f7dec4", + "m_Id": 7, + "m_DisplayName": "A", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "A", + "m_StageCapability": 2, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.BlockNode", + "m_ObjectId": "4b45669a84054c498babd493511b3189", + "m_Group": { + "m_Id": "" + }, + "m_Name": "VertexDescription.Position", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": 0.0, + "y": 0.0, + "width": 0.0, + "height": 0.0 + } + }, + "m_Slots": [ + { + "m_Id": "cb901263bb9a42489ac84d9e84023477" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_SerializedDescriptor": "VertexDescription.Position" +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "4d4936585ecf42d39881f4232a063496", + "m_Id": 2, + "m_DisplayName": "Off", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "Off", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicValueMaterialSlot", + "m_ObjectId": "4df2a7d633e841eda213de8a22f05734", + "m_Id": 1, + "m_DisplayName": "B", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "B", + "m_StageCapability": 3, + "m_Value": { + "e00": 2.0, + "e01": 2.0, + "e02": 2.0, + "e03": 2.0, + "e10": 2.0, + "e11": 2.0, + "e12": 2.0, + "e13": 2.0, + "e20": 2.0, + "e21": 2.0, + "e22": 2.0, + "e23": 2.0, + "e30": 2.0, + "e31": 2.0, + "e32": 2.0, + "e33": 2.0 + }, + "m_DefaultValue": { + "e00": 1.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 1.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 1.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 1.0 + } +} + +{ + "m_SGVersion": 1, + "m_Type": "UnityEditor.ShaderGraph.Internal.Vector1ShaderProperty", + "m_ObjectId": "4e48a718329c454b8a46be0bc9bf8802", + "m_Guid": { + "m_GuidSerialized": "f2c7ead8-1119-4b60-90b6-25d5065da726" + }, + "m_Name": "Iris Radius", + "m_DefaultReferenceName": "", + "m_OverrideReferenceName": "_IrisRadius", + "m_GeneratePropertyBlock": true, + "m_Precision": 0, + "overrideHLSLDeclaration": false, + "hlslDeclarationOverride": 0, + "m_Hidden": false, + "m_Value": 0.15000000596046449, + "m_FloatType": 1, + "m_RangeValues": { + "x": 0.009999999776482582, + "y": 0.20000000298023225 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "4e77649b872f4e6b80539e146d8012fe", + "m_Id": 1, + "m_DisplayName": "Edge2", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "Edge2", + "m_StageCapability": 3, + "m_Value": { + "x": 1.0, + "y": 1.0, + "z": 1.0, + "w": 1.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.GroupData", + "m_ObjectId": "4e7801ae7f8b4090be5d458121207cec", + "m_Title": "Eye (Iris) Limbus Mask", + "m_Position": { + "x": -2286.0, + "y": -1247.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "4f3fe4c8a1f344128cfb112679fcf140", + "m_Id": 5, + "m_DisplayName": "G", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "G", + "m_StageCapability": 2, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.PropertyNode", + "m_ObjectId": "4f7d58dc38cd4a4daa541a875022cf72", + "m_Group": { + "m_Id": "74c1d47e70e6422881a0e0f051febbb9" + }, + "m_Name": "Property", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -1908.9996337890625, + "y": -1504.0001220703125, + "width": 148.0, + "height": 34.0 + } + }, + "m_Slots": [ + { + "m_Id": "608ab6732307474e869ec0e4051b5eaa" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_Property": { + "m_Id": "e2d236b8f7c740b1920bd65df0cef00f" + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.ColorRGBMaterialSlot", + "m_ObjectId": "4fbf6229bad74e91afb7ff4f2a7f0018", + "m_Id": 0, + "m_DisplayName": "Emission", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "Emission", + "m_StageCapability": 2, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0 + }, + "m_Labels": [], + "m_ColorMode": 1, + "m_DefaultColor": { + "r": 0.0, + "g": 0.0, + "b": 0.0, + "a": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.StickyNoteData", + "m_ObjectId": "504ca61054e546f2bab2baa6c59b1c3c", + "m_Title": "Vertex Shader", + "m_Content": "This section generates the iris vertex displacement on the inner eyeball mesh. Though it possible to resuse the nodes from the fragment shader, shader graph gets confused easily and it becomes difficult to edit. So the relevant node sections are reproduced here just for the vertex shader.", + "m_TextSize": 0, + "m_Theme": 0, + "m_Position": { + "serializedVersion": "2", + "x": -807.0, + "y": -3891.0, + "width": 330.0, + "height": 160.0 + }, + "m_Group": { + "m_Id": "" + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.LengthNode", + "m_ObjectId": "51151e73375c46bfa12805410235fc45", + "m_Group": { + "m_Id": "8797d77264e74bd38b2c09f136026a6b" + }, + "m_Name": "Length", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -1278.9998779296875, + "y": -4003.0, + "width": 208.0, + "height": 278.0 + } + }, + "m_Slots": [ + { + "m_Id": "2ecf355b89624f87b560fa1a7a89cb0a" + }, + { + "m_Id": "1ba8718d8a33493e9c2fb5fec78b8b36" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "511900913e5f425abd566c8ed5bf2988", + "m_Id": 3, + "m_DisplayName": "Opacity", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "Opacity", + "m_StageCapability": 3, + "m_Value": 1.0, + "m_DefaultValue": 1.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector2Node", + "m_ObjectId": "512f5c3810b44a6580d4a61380557afd", + "m_Group": { + "m_Id": "69bc229b1eb94e15a47d971b447a3198" + }, + "m_Name": "Vector 2", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -2085.0, + "y": -2270.999755859375, + "width": 128.0, + "height": 101.0 + } + }, + "m_Slots": [ + { + "m_Id": "9539b68ac0384351bd380dce56e448ab" + }, + { + "m_Id": "e8eee264259841dfa019499d140ad93b" + }, + { + "m_Id": "7cc0fc95b66b4211b7a3872f11033a39" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_Value": { + "x": 0.0, + "y": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "514442bdf0db4b2582e14f6d65394c75", + "m_Id": 0, + "m_DisplayName": "In", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "In", + "m_StageCapability": 3, + "m_Value": { + "x": -1.0, + "y": -1.0, + "z": -1.0, + "w": -1.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "514b54cbe2634f3cb48cd8beee102796", + "m_Id": 1, + "m_DisplayName": "B", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "B", + "m_StageCapability": 3, + "m_Value": { + "x": 0.5, + "y": 0.5, + "z": 0.0, + "w": 1.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "51b5c0e34478418da4df9c35a336b14c", + "m_Id": 2, + "m_DisplayName": "Out", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Internal.BooleanShaderProperty", + "m_ObjectId": "526ce229950b48d0b6c7cdd0b66dd1e6", + "m_Guid": { + "m_GuidSerialized": "57191268-66f8-404b-9a60-922c962905a0" + }, + "m_Name": "IsLeftEye", + "m_DefaultReferenceName": "Boolean_526ce229950b48d0b6c7cdd0b66dd1e6", + "m_OverrideReferenceName": "_IsLeftEye", + "m_GeneratePropertyBlock": true, + "m_Precision": 0, + "overrideHLSLDeclaration": false, + "hlslDeclarationOverride": 0, + "m_Hidden": false, + "m_Value": false +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector4MaterialSlot", + "m_ObjectId": "52bf23cb822748d2a9b4e04617c3f43e", + "m_Id": 0, + "m_DisplayName": "Out", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicValueMaterialSlot", + "m_ObjectId": "53fdffd517c74097b4a92066bbe36456", + "m_Id": 0, + "m_DisplayName": "A", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "A", + "m_StageCapability": 3, + "m_Value": { + "e00": 0.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 0.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 0.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 0.0 + }, + "m_DefaultValue": { + "e00": 1.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 1.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 1.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicValueMaterialSlot", + "m_ObjectId": "542f0cf230a9407aa67a4f4a75ac8cd0", + "m_Id": 2, + "m_DisplayName": "Out", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": { + "e00": 0.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 0.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 0.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 0.0 + }, + "m_DefaultValue": { + "e00": 1.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 1.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 1.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Texture2DMaterialSlot", + "m_ObjectId": "54c417981f6748e8b7660477bf48c8a9", + "m_Id": 0, + "m_DisplayName": "Sclera Diffuse Map", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_BareResource": false +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.SmoothstepNode", + "m_ObjectId": "550a06f5c5c94768ae7e3ac6f3a68718", + "m_Group": { + "m_Id": "4e7801ae7f8b4090be5d458121207cec" + }, + "m_Name": "Smoothstep", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -1567.9996337890625, + "y": -1188.0001220703125, + "width": 208.0, + "height": 326.0 + } + }, + "m_Slots": [ + { + "m_Id": "e0295ddbefb94b799ce4616eeb0f4dd6" + }, + { + "m_Id": "4e77649b872f4e6b80539e146d8012fe" + }, + { + "m_Id": "ea01102eb2eb476e84ae2b95ef095d12" + }, + { + "m_Id": "dcd0f818c5ac4124a8f81c2e0d64e484" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 1, + "m_Type": "UnityEditor.ShaderGraph.Internal.Vector1ShaderProperty", + "m_ObjectId": "55bf621ad2394320a2ab49a3c7b34fe1", + "m_Guid": { + "m_GuidSerialized": "a442da55-b5f4-4a93-8e32-f02731bcb853" + }, + "m_Name": "Sclera Scale", + "m_DefaultReferenceName": "Vector1_55bf621ad2394320a2ab49a3c7b34fe1", + "m_OverrideReferenceName": "_ScleraScale", + "m_GeneratePropertyBlock": true, + "m_Precision": 0, + "overrideHLSLDeclaration": false, + "hlslDeclarationOverride": 0, + "m_Hidden": false, + "m_Value": 1.0, + "m_FloatType": 1, + "m_RangeValues": { + "x": 0.5, + "y": 2.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "571a527f603a43bca479373face210b4", + "m_Id": 1, + "m_DisplayName": "", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.PropertyNode", + "m_ObjectId": "572a2f9ebb594d7f88dd96684e398195", + "m_Group": { + "m_Id": "a145967c42cb43d59d7699fc064ab763" + }, + "m_Name": "Property", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -2012.999755859375, + "y": -3329.0, + "width": 130.0, + "height": 34.0 + } + }, + "m_Slots": [ + { + "m_Id": "6450045b37724b658b0b05d276924c34" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_Property": { + "m_Id": "4e48a718329c454b8a46be0bc9bf8802" + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "58e3c2f796054301922dfca0d44c8488", + "m_Id": 0, + "m_DisplayName": "Iris Smoothness", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicValueMaterialSlot", + "m_ObjectId": "58f9cd9e75a048feb43bee9beca8a303", + "m_Id": 0, + "m_DisplayName": "A", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "A", + "m_StageCapability": 3, + "m_Value": { + "e00": 0.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 0.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 0.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 0.0 + }, + "m_DefaultValue": { + "e00": 1.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 1.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 1.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 1.0 + } +} + +{ + "m_SGVersion": 1, + "m_Type": "UnityEditor.ShaderGraph.Internal.Vector1ShaderProperty", + "m_ObjectId": "596515c1061c4119b6831a17bd392746", + "m_Guid": { + "m_GuidSerialized": "a668ef77-b686-4cf0-b08a-76a517528ff3" + }, + "m_Name": "Pupil Scale", + "m_DefaultReferenceName": "", + "m_OverrideReferenceName": "_PupilScale", + "m_GeneratePropertyBlock": true, + "m_Precision": 0, + "overrideHLSLDeclaration": false, + "hlslDeclarationOverride": 0, + "m_Hidden": false, + "m_Value": 0.800000011920929, + "m_FloatType": 1, + "m_RangeValues": { + "x": 0.25, + "y": 2.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.MultiplyNode", + "m_ObjectId": "59a7dc2461134f9397f43ffba658e922", + "m_Group": { + "m_Id": "4e7801ae7f8b4090be5d458121207cec" + }, + "m_Name": "Multiply", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -2024.9998779296875, + "y": -1188.0001220703125, + "width": 126.00000762939453, + "height": 118.0 + } + }, + "m_Slots": [ + { + "m_Id": "23dc2c9219da401294112932b2517141" + }, + { + "m_Id": "43ed3a5249a9482fa5cdcab24c533cb5" + }, + { + "m_Id": "ba15e9218b0b4d888d04b4a844594894" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "59fbf80ca91749a1a29340d6d378b546", + "m_Id": 6, + "m_DisplayName": "B", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "B", + "m_StageCapability": 2, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector2MaterialSlot", + "m_ObjectId": "5a20adba64ee4d6f8de83c6f0e40047d", + "m_Id": 1, + "m_DisplayName": "Tiling", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "Tiling", + "m_StageCapability": 3, + "m_Value": { + "x": 1.0, + "y": 1.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0 + }, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "5ba3432ec167402f85822cc0e7557309", + "m_Id": 0, + "m_DisplayName": "", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector3MaterialSlot", + "m_ObjectId": "5bc4216d9dc84d618eba447f916fb3ab", + "m_Id": 0, + "m_DisplayName": "In", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "In", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 1.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0 + }, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "5bde4ddb9736488d9e22f857e3009e29", + "m_Id": 0, + "m_DisplayName": "", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicValueMaterialSlot", + "m_ObjectId": "5c1c4b78b82946fa98a9392ad630019a", + "m_Id": 1, + "m_DisplayName": "B", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "B", + "m_StageCapability": 3, + "m_Value": { + "e00": 2.0, + "e01": 2.0, + "e02": 2.0, + "e03": 2.0, + "e10": 2.0, + "e11": 2.0, + "e12": 2.0, + "e13": 2.0, + "e20": 2.0, + "e21": 2.0, + "e22": 2.0, + "e23": 2.0, + "e30": 2.0, + "e31": 2.0, + "e32": 2.0, + "e33": 2.0 + }, + "m_DefaultValue": { + "e00": 1.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 1.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 1.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.AddNode", + "m_ObjectId": "5c6d79fa3de14efc88d0df8ae1161314", + "m_Group": { + "m_Id": "4e7801ae7f8b4090be5d458121207cec" + }, + "m_Name": "Add", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -1812.9996337890625, + "y": -1118.0001220703125, + "width": 126.00000762939453, + "height": 118.0 + } + }, + "m_Slots": [ + { + "m_Id": "7508ed36eb9245499cbc4ece2e7e6c7b" + }, + { + "m_Id": "1894eb32dcd549a2aa6479480e2df0f5" + }, + { + "m_Id": "e6412f2413614b22be377c9703f53e5e" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.PropertyNode", + "m_ObjectId": "5cb0acbaa8ec47f3949dd6f059ef08ac", + "m_Group": { + "m_Id": "ac1d8910df764e109e212887850df3ab" + }, + "m_Name": "Property", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -7027.00048828125, + "y": -472.0000305175781, + "width": 130.0, + "height": 34.0 + } + }, + "m_Slots": [ + { + "m_Id": "c43f686ac4aa4ea6ba206a9e52ecc3ad" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_Property": { + "m_Id": "4e48a718329c454b8a46be0bc9bf8802" + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "5d77a606937f44feb8860c6501cc4557", + "m_Id": 4, + "m_DisplayName": "R", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "R", + "m_StageCapability": 2, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.Rendering.HighDefinition.ShaderGraph.SystemData", + "m_ObjectId": "5e856e0c3b704d14a6c36b84bf8d78f6", + "m_MaterialNeedsUpdateHash": 12719, + "m_SurfaceType": 1, + "m_RenderingPass": 4, + "m_BlendMode": 0, + "m_ZTest": 4, + "m_ZWrite": false, + "m_TransparentCullMode": 2, + "m_OpaqueCullMode": 2, + "m_SortPriority": 0, + "m_AlphaTest": false, + "m_TransparentDepthPrepass": false, + "m_TransparentDepthPostpass": false, + "m_SupportLodCrossFade": false, + "m_DoubleSidedMode": 0, + "m_DOTSInstancing": false, + "m_Version": 0, + "m_FirstTimeMigrationExecuted": true, + "inspectorFoldoutMask": 11 +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.LerpNode", + "m_ObjectId": "5edeff0045f043628d7eec2ef5557e4f", + "m_Group": { + "m_Id": "3d2583bfe59949a280911e6c487c911f" + }, + "m_Name": "Lerp", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -780.9998168945313, + "y": -315.0000305175781, + "width": 126.0, + "height": 142.0 + } + }, + "m_Slots": [ + { + "m_Id": "6947347143114b909c3078bf11a8c150" + }, + { + "m_Id": "b6d031bcce734f6f87a6454702ce62d9" + }, + { + "m_Id": "5f220aed07ca4d6b985c170f762588ba" + }, + { + "m_Id": "005ebe2d787749ee84505cba884c9cb5" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "5f220aed07ca4d6b985c170f762588ba", + "m_Id": 2, + "m_DisplayName": "T", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "T", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Internal.Texture2DShaderProperty", + "m_ObjectId": "5f410167b9c14d43bc4da4f27fdd220a", + "m_Guid": { + "m_GuidSerialized": "4e8de280-ae9a-4cd0-bcb4-c38ce1060b4b" + }, + "m_Name": "Color Blend Map", + "m_DefaultReferenceName": "Texture2D_5f410167b9c14d43bc4da4f27fdd220a", + "m_OverrideReferenceName": "_ColorBlendMap", + "m_GeneratePropertyBlock": true, + "m_Precision": 0, + "overrideHLSLDeclaration": false, + "hlslDeclarationOverride": 0, + "m_Hidden": false, + "m_Value": { + "m_SerializedTexture": "{\"texture\":{\"instanceID\":0}}", + "m_Guid": "" + }, + "m_Modifiable": true, + "m_DefaultType": 0 +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "5f7b447e6b5d4420b6a095697ad9b8b4", + "m_Id": 0, + "m_DisplayName": "Sclera Normal Strength", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "5fba5b929e8949f0b44415bac2f4f979", + "m_Id": 7, + "m_DisplayName": "A", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "A", + "m_StageCapability": 2, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.SampleTexture2DNode", + "m_ObjectId": "60690c6170544de7ab05a07916de81aa", + "m_Group": { + "m_Id": "47b971716ee4470f865fc5c885abcf66" + }, + "m_Name": "Sample Texture 2D", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -2504.0, + "y": -3011.999755859375, + "width": 184.0, + "height": 253.0 + } + }, + "m_Slots": [ + { + "m_Id": "f647b0c6be8042e996570315ae2f07a2" + }, + { + "m_Id": "29a57cacc8dd476298c59cbc7701687a" + }, + { + "m_Id": "30c24ea480ef4f75a17e162be363f368" + }, + { + "m_Id": "59fbf80ca91749a1a29340d6d378b546" + }, + { + "m_Id": "051195f4293c4e5aa58dde243d4c0166" + }, + { + "m_Id": "80387019b099485ba1f1f9ac278a384f" + }, + { + "m_Id": "c045ae097b974009a6323f09c7478315" + }, + { + "m_Id": "13164f3fb38245228ea76bb6244912dc" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_TextureType": 0, + "m_NormalMapSpace": 0 +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "608ab6732307474e869ec0e4051b5eaa", + "m_Id": 0, + "m_DisplayName": "Iris Saturation", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicValueMaterialSlot", + "m_ObjectId": "609f2251422d4c2caabc1e7617e4fc77", + "m_Id": 2, + "m_DisplayName": "Out", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": { + "e00": 0.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 0.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 0.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 0.0 + }, + "m_DefaultValue": { + "e00": 1.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 1.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 1.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 1.0 + } +} + +{ + "m_SGVersion": 1, + "m_Type": "UnityEditor.ShaderGraph.Internal.Vector1ShaderProperty", + "m_ObjectId": "6106c8c4dc85475886881929b289ae65", + "m_Guid": { + "m_GuidSerialized": "b150a3ed-778e-4e12-91c5-0764371d1582" + }, + "m_Name": "Iris Hue", + "m_DefaultReferenceName": "", + "m_OverrideReferenceName": "_IrisHue", + "m_GeneratePropertyBlock": true, + "m_Precision": 0, + "overrideHLSLDeclaration": false, + "hlslDeclarationOverride": 0, + "m_Hidden": false, + "m_Value": 0.5, + "m_FloatType": 1, + "m_RangeValues": { + "x": 0.0, + "y": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector2MaterialSlot", + "m_ObjectId": "6187435caaca41ae8d759cd1fdba1bb9", + "m_Id": 2, + "m_DisplayName": "Offset", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "Offset", + "m_StageCapability": 3, + "m_Value": { + "x": -0.5, + "y": -0.5 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0 + }, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.PropertyNode", + "m_ObjectId": "619d5f4976004545be9f7a054f6345c2", + "m_Group": { + "m_Id": "862059ed0bf141dd9404f65a66b53cd8" + }, + "m_Name": "Property", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": 361.00018310546877, + "y": -877.0000610351563, + "width": 172.0, + "height": 34.0 + } + }, + "m_Slots": [ + { + "m_Id": "0a6dc616dfe9402dbf46406552b3a409" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_Property": { + "m_Id": "5f410167b9c14d43bc4da4f27fdd220a" + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector3MaterialSlot", + "m_ObjectId": "61fcdc9fb80e4d76a367f036ae0bd122", + "m_Id": 2, + "m_DisplayName": "Out", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0 + }, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "62de1b2542194ba99cb7e5ce12901a34", + "m_Id": 0, + "m_DisplayName": "", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "62f91fac8f3a411a98a1e5dbfa41bf97", + "m_Id": 0, + "m_DisplayName": "", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.PropertyNode", + "m_ObjectId": "62fedfd3bd31470fa43da6a935690b2f", + "m_Group": { + "m_Id": "4e7801ae7f8b4090be5d458121207cec" + }, + "m_Name": "Property", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -2204.999755859375, + "y": -1076.0001220703125, + "width": 123.00000762939453, + "height": 34.0 + } + }, + "m_Slots": [ + { + "m_Id": "00688728415c4b408c64c6d51df12097" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_Property": { + "m_Id": "85e5e0cd46aa44fc8e9f720d375bec49" + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.BlendNode", + "m_ObjectId": "6302739ff3374cfaa8fcedd14e7f761c", + "m_Group": { + "m_Id": "" + }, + "m_Name": "Blend", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -976.9999389648438, + "y": -1337.9998779296875, + "width": 207.99998474121095, + "height": 362.0 + } + }, + "m_Slots": [ + { + "m_Id": "041fe88e98ba4393a9279d84780e6b0a" + }, + { + "m_Id": "6fc282b2d52f4d87b33db749abdbf58f" + }, + { + "m_Id": "1e5317f353e6433b9a72c5d9cf2aa656" + }, + { + "m_Id": "2d0e21ace72d4af6a4418e6c9be82a69" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_BlendMode": 13 +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.RedirectNodeData", + "m_ObjectId": "632471e337134d58abfeff04c801a3fc", + "m_Group": { + "m_Id": "" + }, + "m_Name": "Redirect Node", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -4315.00048828125, + "y": -2422.0, + "width": 56.0, + "height": 24.0 + } + }, + "m_Slots": [ + { + "m_Id": "42b641249a6f420f9a02a643c7b4ff03" + }, + { + "m_Id": "f2ab5067b82746dbbb965aecf46591b0" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.UVNode", + "m_ObjectId": "63427a74f3e84bfaa8916b46984eb21e", + "m_Group": { + "m_Id": "0ca230dd81f04c0ba5af42953674323c" + }, + "m_Name": "UV", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -6241.99951171875, + "y": -767.9999389648438, + "width": 207.99998474121095, + "height": 313.9999694824219 + } + }, + "m_Slots": [ + { + "m_Id": "52bf23cb822748d2a9b4e04617c3f43e" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_OutputChannel": 0 +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.MultiplyNode", + "m_ObjectId": "6396fbb6050845dfb78251eb19cf1f3d", + "m_Group": { + "m_Id": "74c1d47e70e6422881a0e0f051febbb9" + }, + "m_Name": "Multiply", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -2791.999755859375, + "y": -1560.0001220703125, + "width": 130.0, + "height": 118.0 + } + }, + "m_Slots": [ + { + "m_Id": "58f9cd9e75a048feb43bee9beca8a303" + }, + { + "m_Id": "5c1c4b78b82946fa98a9392ad630019a" + }, + { + "m_Id": "1aa70d25934a4da3bf3c0298a76e9f76" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.MultiplyNode", + "m_ObjectId": "63e87978e9a747f68093da34fdd729d1", + "m_Group": { + "m_Id": "74c1d47e70e6422881a0e0f051febbb9" + }, + "m_Name": "Multiply", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -3698.0, + "y": -1696.0001220703125, + "width": 126.00000762939453, + "height": 118.0 + } + }, + "m_Slots": [ + { + "m_Id": "220d1478c3bf468aa1c158cc00240820" + }, + { + "m_Id": "8eaaff414f4a4910a9d7140948dea838" + }, + { + "m_Id": "036f995e5f0a4cae9bd9218c9faf6aaf" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "64008aecf2ef48278ac62d0e32a0afe2", + "m_Id": 2, + "m_DisplayName": "Out", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "6450045b37724b658b0b05d276924c34", + "m_Id": 0, + "m_DisplayName": "Iris Radius", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.PropertyNode", + "m_ObjectId": "64b8f0b8e8ab453b82e60dbb2601810a", + "m_Group": { + "m_Id": "4e7801ae7f8b4090be5d458121207cec" + }, + "m_Name": "Property", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -2256.999755859375, + "y": -975.0001220703125, + "width": 175.0, + "height": 34.0 + } + }, + "m_Slots": [ + { + "m_Id": "2761123d8c004cf69bf09bf1893cda1f" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_Property": { + "m_Id": "308a2ce997744f8cb41204c209af692a" + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.RedirectNodeData", + "m_ObjectId": "653d9a0466784556a30ea5f4a8ab15b4", + "m_Group": { + "m_Id": "" + }, + "m_Name": "Redirect Node", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -2195.000244140625, + "y": -92.0, + "width": 56.0, + "height": 23.999998092651368 + } + }, + "m_Slots": [ + { + "m_Id": "62de1b2542194ba99cb7e5ce12901a34" + }, + { + "m_Id": "0ac3739d49144e9eb1f564c686a1d69f" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicValueMaterialSlot", + "m_ObjectId": "65595c71f75b4f48ac8e75db61ce6926", + "m_Id": 0, + "m_DisplayName": "A", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "A", + "m_StageCapability": 3, + "m_Value": { + "e00": 0.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 0.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 0.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 0.0 + }, + "m_DefaultValue": { + "e00": 1.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 1.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 1.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector2MaterialSlot", + "m_ObjectId": "6617e76d6bb94faaa1723e87bfeae2d7", + "m_Id": 2, + "m_DisplayName": "Offset", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "Offset", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0 + }, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.SaturateNode", + "m_ObjectId": "66d3dbbf263f41eb8f7fd3170e887590", + "m_Group": { + "m_Id": "69bc229b1eb94e15a47d971b447a3198" + }, + "m_Name": "Saturate", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -1494.0, + "y": -2453.0, + "width": 128.0, + "height": 94.0 + } + }, + "m_Slots": [ + { + "m_Id": "d4d186059ec04179a1b26be0a8f41b44" + }, + { + "m_Id": "a510d45ac04c4809b146f25429b6ec58" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "681fb86a7ece4cf1a5b3da0c95dc2d8f", + "m_Id": 1, + "m_DisplayName": "", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.BlendNode", + "m_ObjectId": "6918af92d95c46dfa33f3b2b9331ebca", + "m_Group": { + "m_Id": "" + }, + "m_Name": "Blend", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -977.0000610351563, + "y": -2569.000244140625, + "width": 208.0, + "height": 362.0 + } + }, + "m_Slots": [ + { + "m_Id": "7e445e85c43747fea4b554a3564627f7" + }, + { + "m_Id": "cfccabb8ddef4f3baf378b07fa236189" + }, + { + "m_Id": "511900913e5f425abd566c8ed5bf2988" + }, + { + "m_Id": "2e678ee544dd4562b0e91ec084af54fb" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_BlendMode": 13 +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.RemapNode", + "m_ObjectId": "6929a4da74424497940ebe5e4cf64977", + "m_Group": { + "m_Id": "3366f611f8464c988208f0daa49f30d2" + }, + "m_Name": "Remap", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -878.999755859375, + "y": -3574.0, + "width": 208.0, + "height": 326.0 + } + }, + "m_Slots": [ + { + "m_Id": "514442bdf0db4b2582e14f6d65394c75" + }, + { + "m_Id": "c8564bab88154be6977cc712d928c6d2" + }, + { + "m_Id": "3b65f7d41ee44ad3a71241e0f6862213" + }, + { + "m_Id": "3348a973507449dea65b44492af527fa" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicValueMaterialSlot", + "m_ObjectId": "694521ea103a41cb984a053f05ef204f", + "m_Id": 2, + "m_DisplayName": "Out", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": { + "e00": 0.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 0.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 0.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 0.0 + }, + "m_DefaultValue": { + "e00": 1.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 1.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 1.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "6947347143114b909c3078bf11a8c150", + "m_Id": 0, + "m_DisplayName": "A", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "A", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector2MaterialSlot", + "m_ObjectId": "695889ce196d44858dd74c2389f59705", + "m_Id": 0, + "m_DisplayName": "Out", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0 + }, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.GroupData", + "m_ObjectId": "69bc229b1eb94e15a47d971b447a3198", + "m_Title": "Cornea (Sclera) Corner Shadow", + "m_Position": { + "x": -2598.0, + "y": -2512.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "69bffe78d536404bad016260e8b60d58", + "m_Id": 2, + "m_DisplayName": "Out", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "6a04b4b8c9f44c39b9149aa0ee3d0775", + "m_Id": 1, + "m_DisplayName": "", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.BlockNode", + "m_ObjectId": "6a4b619cae09428e850340b327dc2247", + "m_Group": { + "m_Id": "" + }, + "m_Name": "SurfaceDescription.Smoothness", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": 1177.0, + "y": 393.0, + "width": 200.0, + "height": 41.0 + } + }, + "m_Slots": [ + { + "m_Id": "0d28e9b96829486b9a93fb4b4493ec53" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_SerializedDescriptor": "SurfaceDescription.Smoothness" +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.BlockNode", + "m_ObjectId": "6b280d605cf34b63ae417129545c2f7d", + "m_Group": { + "m_Id": "" + }, + "m_Name": "SurfaceDescription.Occlusion", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": 1366.0001220703125, + "y": 517.0, + "width": 200.00001525878907, + "height": 41.000003814697269 + } + }, + "m_Slots": [ + { + "m_Id": "b7bc60a4dd2f4474b6ee37d8ae231bc3" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_SerializedDescriptor": "SurfaceDescription.Occlusion" +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "6b3cfb7f6e6b4a1794a6a9593f9a1dcc", + "m_Id": 0, + "m_DisplayName": "A", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "A", + "m_StageCapability": 3, + "m_Value": { + "x": 1.0, + "y": 1.0, + "z": 1.0, + "w": 1.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicValueMaterialSlot", + "m_ObjectId": "6bb3949a13e14dc38afcbf2c05bd6eda", + "m_Id": 2, + "m_DisplayName": "Out", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": { + "e00": 0.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 0.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 0.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 0.0 + }, + "m_DefaultValue": { + "e00": 1.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 1.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 1.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector2MaterialSlot", + "m_ObjectId": "6d13f68ae9544ad6b19be8a313811709", + "m_Id": 0, + "m_DisplayName": "Out", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0 + }, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicValueMaterialSlot", + "m_ObjectId": "6dd35d61d74d4a38b4cb484f6280bee0", + "m_Id": 1, + "m_DisplayName": "B", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "B", + "m_StageCapability": 3, + "m_Value": { + "e00": 2.0, + "e01": 2.0, + "e02": 2.0, + "e03": 2.0, + "e10": 2.0, + "e11": 2.0, + "e12": 2.0, + "e13": 2.0, + "e20": 2.0, + "e21": 2.0, + "e22": 2.0, + "e23": 2.0, + "e30": 2.0, + "e31": 2.0, + "e32": 2.0, + "e33": 2.0 + }, + "m_DefaultValue": { + "e00": 1.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 1.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 1.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "6f917d5a97c54c23a798a0c664ac4d59", + "m_Id": 0, + "m_DisplayName": "In", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "In", + "m_StageCapability": 3, + "m_Value": { + "x": 1.0, + "y": 1.0, + "z": 1.0, + "w": 1.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "6fc282b2d52f4d87b33db749abdbf58f", + "m_Id": 1, + "m_DisplayName": "Blend", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "Blend", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "705ba2d004364516b5f20746b6685f6f", + "m_Id": 0, + "m_DisplayName": "In", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "In", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "70e23667bbef42dcbd03ce61656f6801", + "m_Id": 2, + "m_DisplayName": "Y", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "Y", + "m_StageCapability": 3, + "m_Value": 0.5, + "m_DefaultValue": 0.0, + "m_Labels": [ + "Y" + ] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.OneMinusNode", + "m_ObjectId": "716c2c419d6c4e22b5e02d2cc6973fa9", + "m_Group": { + "m_Id": "8e986fb6ad9c4fdab0a043872278421b" + }, + "m_Name": "One Minus", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -1193.0, + "y": 119.00003814697266, + "width": 128.0, + "height": 94.0 + } + }, + "m_Slots": [ + { + "m_Id": "837ef6506d354e23828ff6caa45dfe78" + }, + { + "m_Id": "3ed6c2670f1c4f1a9248bb3bc7cef75e" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.PropertyNode", + "m_ObjectId": "71d190547a3c44809862ff43703249c1", + "m_Group": { + "m_Id": "47b971716ee4470f865fc5c885abcf66" + }, + "m_Name": "Property", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -1663.0, + "y": -2681.999755859375, + "width": 166.99998474121095, + "height": 34.0 + } + }, + "m_Slots": [ + { + "m_Id": "1f7600f576a144378c1b967f51ce97fd" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_Property": { + "m_Id": "82fed9724f34448392b89bdd38fe7517" + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "725655db4db54f2aa27fdd6ad21e0f67", + "m_Id": 0, + "m_DisplayName": "A", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "A", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "72746d264455473282191757b9235a6d", + "m_Id": 0, + "m_DisplayName": "IOR", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "72d01c55dcf44b8a8b300b720fcb51a1", + "m_Id": 0, + "m_DisplayName": "Depth Radius", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector2MaterialSlot", + "m_ObjectId": "72feafecbe3942249d01e018787a06fd", + "m_Id": 3, + "m_DisplayName": "Out", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0 + }, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.SmoothstepNode", + "m_ObjectId": "7352305b756b4d149bb8ba57d17be328", + "m_Group": { + "m_Id": "e2d8030e74824bb48369331f4775f0ac" + }, + "m_Name": "Smoothstep", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -5092.0, + "y": -361.0000305175781, + "width": 152.99998474121095, + "height": 142.0 + } + }, + "m_Slots": [ + { + "m_Id": "464bdc58fcf04a0bb78dfc88d781b5c8" + }, + { + "m_Id": "801cc6200094421e8279d3be26d564f6" + }, + { + "m_Id": "8e772a4c6d814ac59021f87dd1faa3f3" + }, + { + "m_Id": "05838f59e6b4412ca70a8a90b5f6f1ce" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.KeywordNode", + "m_ObjectId": "73deaf823d80459e99867f6faff97e65", + "m_Group": { + "m_Id": "77f65f494a034b2a9cf1395ba40d3843" + }, + "m_Name": "IsCornea", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -25.99995231628418, + "y": -570.0, + "width": 163.0, + "height": 118.0 + } + }, + "m_Slots": [ + { + "m_Id": "fda96693aa6340009499290ed5c289c5" + }, + { + "m_Id": "95778f59c98f490dbbb8c92d435bf27b" + }, + { + "m_Id": "b04cecfbb56c4fab94441c7113126635" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_Keyword": { + "m_Id": "9d63910b86f7439f9642f08926860a8e" + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.TilingAndOffsetNode", + "m_ObjectId": "742ba88a28af42aba6cf8af5187f2bc5", + "m_Group": { + "m_Id": "4a0e19aa85024f47a32faf9b1d3f2868" + }, + "m_Name": "Tiling And Offset", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -1239.000244140625, + "y": 970.9998779296875, + "width": 155.0, + "height": 142.0 + } + }, + "m_Slots": [ + { + "m_Id": "aa5c9d8fd9624bcf973c3d409da1ba70" + }, + { + "m_Id": "5a20adba64ee4d6f8de83c6f0e40047d" + }, + { + "m_Id": "6617e76d6bb94faaa1723e87bfeae2d7" + }, + { + "m_Id": "72feafecbe3942249d01e018787a06fd" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.ColorRGBMaterialSlot", + "m_ObjectId": "745ea487c66c466f84d2c16a08c4b1b6", + "m_Id": 0, + "m_DisplayName": "Base Color", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "BaseColor", + "m_StageCapability": 2, + "m_Value": { + "x": 0.5, + "y": 0.5, + "z": 0.5 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0 + }, + "m_Labels": [], + "m_ColorMode": 0, + "m_DefaultColor": { + "r": 0.5, + "g": 0.5, + "b": 0.5, + "a": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.GroupData", + "m_ObjectId": "74c1d47e70e6422881a0e0f051febbb9", + "m_Title": "Eye (Iris)Base Color", + "m_Position": { + "x": -3920.0, + "y": -1876.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "74d5e7aa152145f696521594ef66188c", + "m_Id": 6, + "m_DisplayName": "B", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "B", + "m_StageCapability": 2, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "7506948833b144c8867c0e7bfb8b93e3", + "m_Id": 0, + "m_DisplayName": "In", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "In", + "m_StageCapability": 3, + "m_Value": { + "x": 1.0, + "y": 1.0, + "z": 1.0, + "w": 1.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "7508ed36eb9245499cbc4ece2e7e6c7b", + "m_Id": 0, + "m_DisplayName": "A", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "A", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "761ab34284dd4f13a33ee4ad69c23305", + "m_Id": 0, + "m_DisplayName": "Refraction Distance", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "RefractionDistance", + "m_StageCapability": 2, + "m_Value": 1.0, + "m_DefaultValue": 1.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.SaturateNode", + "m_ObjectId": "76cb50baf4d5435eae085a0baf1c43ab", + "m_Group": { + "m_Id": "fa7b0f3ba7d84ba7a4d19d87b7a3c4b8" + }, + "m_Name": "Saturate", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -4415.0, + "y": -1404.0, + "width": 128.0, + "height": 94.0 + } + }, + "m_Slots": [ + { + "m_Id": "705ba2d004364516b5f20746b6685f6f" + }, + { + "m_Id": "e38caaff8b6e4d0ebdf033799dc52974" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.SampleTexture2DNode", + "m_ObjectId": "7775f2e3bef641f9acfa32f315b8a049", + "m_Group": { + "m_Id": "4a0e19aa85024f47a32faf9b1d3f2868" + }, + "m_Name": "Sample Texture 2D", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -1045.9998779296875, + "y": 908.9998779296875, + "width": 184.0, + "height": 253.0 + } + }, + "m_Slots": [ + { + "m_Id": "f2cd52962a934444a0cb5e555d009001" + }, + { + "m_Id": "142fa490279d434dbbdd86c9e939a7b4" + }, + { + "m_Id": "3544150e55ab4845ae13aa533e6504b0" + }, + { + "m_Id": "b4adfd03694943e28ce6d5233fdf5dbc" + }, + { + "m_Id": "996a51c0a47f42f7b52a3570ce9e0a33" + }, + { + "m_Id": "ed9c59938c234fa394e71efcbec4d5c6" + }, + { + "m_Id": "9c09e8f492ec402e966b5e430a391251" + }, + { + "m_Id": "e434602e31c7473890452c7faeebe5f3" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_TextureType": 1, + "m_NormalMapSpace": 0 +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.GroupData", + "m_ObjectId": "77f65f494a034b2a9cf1395ba40d3843", + "m_Title": "Cornea / Eye Switch", + "m_Position": { + "x": -54.99925231933594, + "y": -1742.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.PropertyNode", + "m_ObjectId": "789e70aabf5a4c52b8bb9861dcc75acb", + "m_Group": { + "m_Id": "862059ed0bf141dd9404f65a66b53cd8" + }, + "m_Name": "Property", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": 565.9999389648438, + "y": -926.9999389648438, + "width": 184.99998474121095, + "height": 34.0 + } + }, + "m_Slots": [ + { + "m_Id": "4a493e2360004ad3b5f9be266ddcebef" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_Property": { + "m_Id": "195319a2066f492abb03e4f9fb29acfb" + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.LerpNode", + "m_ObjectId": "7988f0a070304aec8336a9a885eee20f", + "m_Group": { + "m_Id": "06ed9322d6854bb2b1d9cb30cd928b6d" + }, + "m_Name": "Lerp", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -780.9998168945313, + "y": -570.0, + "width": 126.0, + "height": 142.0 + } + }, + "m_Slots": [ + { + "m_Id": "725655db4db54f2aa27fdd6ad21e0f67" + }, + { + "m_Id": "ec23a22af2da495ea133a205a4fe0887" + }, + { + "m_Id": "da09529fd2fa407e8b34349dc240337e" + }, + { + "m_Id": "afc342d4828b42509da0bac49db15c31" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "798fd82b00f54b18b0cb9dfdb83a2ac2", + "m_Id": 1, + "m_DisplayName": "", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 1, + "m_Type": "UnityEditor.ShaderGraph.Internal.Vector1ShaderProperty", + "m_ObjectId": "7a4f18355ba84582a3d56ed6b8c69762", + "m_Guid": { + "m_GuidSerialized": "e29101e0-3265-4088-9aec-3e0d859daf8b" + }, + "m_Name": "Iris Smoothness", + "m_DefaultReferenceName": "", + "m_OverrideReferenceName": "_IrisSmoothness", + "m_GeneratePropertyBlock": true, + "m_Precision": 0, + "overrideHLSLDeclaration": false, + "hlslDeclarationOverride": 0, + "m_Hidden": false, + "m_Value": 0.0, + "m_FloatType": 1, + "m_RangeValues": { + "x": 0.0, + "y": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Texture2DInputMaterialSlot", + "m_ObjectId": "7c52d0c211b148baa2dee264ed442794", + "m_Id": 1, + "m_DisplayName": "Texture", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "Texture", + "m_StageCapability": 3, + "m_BareResource": false, + "m_Texture": { + "m_SerializedTexture": "{\"texture\":{\"instanceID\":0}}", + "m_Guid": "" + }, + "m_DefaultType": 0 +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector2MaterialSlot", + "m_ObjectId": "7cc0fc95b66b4211b7a3872f11033a39", + "m_Id": 0, + "m_DisplayName": "Out", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0 + }, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.PropertyNode", + "m_ObjectId": "7d0d6e9fb5ad480fa2c294660a419754", + "m_Group": { + "m_Id": "69bc229b1eb94e15a47d971b447a3198" + }, + "m_Name": "Property", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -2559.0, + "y": -2232.999755859375, + "width": 157.0, + "height": 34.0 + } + }, + "m_Slots": [ + { + "m_Id": "d9d673cccaa54a629af5595f7f13e94a" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_Property": { + "m_Id": "2fe3d3e44e8646f3a00409c36bc1a98e" + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "7d181f5420e94c97bedceb5dae5c368e", + "m_Id": 0, + "m_DisplayName": "Iris Brightness", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.KeywordNode", + "m_ObjectId": "7d1c7e05177342fca6ab9184d5038e66", + "m_Group": { + "m_Id": "77f65f494a034b2a9cf1395ba40d3843" + }, + "m_Name": "IsCornea", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -25.99995231628418, + "y": 913.9998779296875, + "width": 166.99998474121095, + "height": 118.0 + } + }, + "m_Slots": [ + { + "m_Id": "3098d75fac454ef0a3a6c126d80701cc" + }, + { + "m_Id": "a1de380471f2433e9a9eaccf85b0dd03" + }, + { + "m_Id": "ccb350f68b9d429395bfc64eb0ae9a5f" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_Keyword": { + "m_Id": "9d63910b86f7439f9642f08926860a8e" + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "7e0b1b95c7b7415b89b926d448eace82", + "m_Id": 1, + "m_DisplayName": "Offset", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "Offset", + "m_StageCapability": 3, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "7e445e85c43747fea4b554a3564627f7", + "m_Id": 0, + "m_DisplayName": "Base", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "Base", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "7ebf2a5e35ee4bcc92611c69e93b5692", + "m_Id": 0, + "m_DisplayName": "A", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "A", + "m_StageCapability": 3, + "m_Value": { + "x": 1.0, + "y": 1.0, + "z": 1.0, + "w": 1.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.MultiplyNode", + "m_ObjectId": "7ece220827684c28a423cf298a5dd94a", + "m_Group": { + "m_Id": "ac1d8910df764e109e212887850df3ab" + }, + "m_Name": "Multiply", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -6851.00048828125, + "y": -554.9999389648438, + "width": 126.00000762939453, + "height": 118.0 + } + }, + "m_Slots": [ + { + "m_Id": "3b2b8f934cd14b73ab7474da780b18ee" + }, + { + "m_Id": "b40ad7731cb1456aad2b951f672995ae" + }, + { + "m_Id": "ad05bf088cd441d4b377f73ec51d6ceb" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "801cc6200094421e8279d3be26d564f6", + "m_Id": 1, + "m_DisplayName": "Edge2", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "Edge2", + "m_StageCapability": 3, + "m_Value": { + "x": 1.0, + "y": 1.0, + "z": 1.0, + "w": 1.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Texture2DInputMaterialSlot", + "m_ObjectId": "80387019b099485ba1f1f9ac278a384f", + "m_Id": 1, + "m_DisplayName": "Texture", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "Texture", + "m_StageCapability": 3, + "m_BareResource": false, + "m_Texture": { + "m_SerializedTexture": "{\"texture\":{\"instanceID\":0}}", + "m_Guid": "" + }, + "m_DefaultType": 0 +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.PropertyNode", + "m_ObjectId": "8192b535ff4b4c02b8b979c205588649", + "m_Group": { + "m_Id": "47b971716ee4470f865fc5c885abcf66" + }, + "m_Name": "Property", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -1858.0, + "y": -2800.999755859375, + "width": 164.0, + "height": 34.0 + } + }, + "m_Slots": [ + { + "m_Id": "d3801702336d4543b434c7f7134efdb0" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_Property": { + "m_Id": "410287977f3941ae86357b91bb50c332" + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.OneMinusNode", + "m_ObjectId": "81e5fe7d81d8443da529cd0254c01e61", + "m_Group": { + "m_Id": "74c1d47e70e6422881a0e0f051febbb9" + }, + "m_Name": "One Minus", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -2966.999755859375, + "y": -1620.0001220703125, + "width": 128.0, + "height": 94.0 + } + }, + "m_Slots": [ + { + "m_Id": "e4fe32e8c70c42b79919d7d7fa484332" + }, + { + "m_Id": "d37dfdae103d4efab5974c0cbbf809f3" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 3, + "m_Type": "UnityEditor.ShaderGraph.Internal.ColorShaderProperty", + "m_ObjectId": "8200a5c208dd40fabbab6b6aca910116", + "m_Guid": { + "m_GuidSerialized": "e5d26f4f-5767-47a9-921c-52d228191ee7" + }, + "m_Name": "Corner Shadow Color", + "m_DefaultReferenceName": "Color_8200a5c208dd40fabbab6b6aca910116", + "m_OverrideReferenceName": "_CornerShadowColor", + "m_GeneratePropertyBlock": true, + "m_Precision": 0, + "overrideHLSLDeclaration": false, + "hlslDeclarationOverride": 0, + "m_Hidden": false, + "m_Value": { + "r": 1.0, + "g": 0.7333333492279053, + "b": 0.6980392336845398, + "a": 0.0 + }, + "m_ColorMode": 0 +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicValueMaterialSlot", + "m_ObjectId": "82d40884687e41559a1046be16c70db9", + "m_Id": 2, + "m_DisplayName": "Out", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": { + "e00": 0.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 0.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 0.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 0.0 + }, + "m_DefaultValue": { + "e00": 1.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 1.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 1.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 1.0 + } +} + +{ + "m_SGVersion": 1, + "m_Type": "UnityEditor.ShaderGraph.Internal.Vector1ShaderProperty", + "m_ObjectId": "82fed9724f34448392b89bdd38fe7517", + "m_Guid": { + "m_GuidSerialized": "8b328558-7863-4ba1-bbf2-2bdaad38e3fa" + }, + "m_Name": "Sclera Brightness", + "m_DefaultReferenceName": "Vector1_82fed9724f34448392b89bdd38fe7517", + "m_OverrideReferenceName": "_ScleraBrightness", + "m_GeneratePropertyBlock": true, + "m_Precision": 0, + "overrideHLSLDeclaration": false, + "hlslDeclarationOverride": 0, + "m_Hidden": false, + "m_Value": 0.6499999761581421, + "m_FloatType": 1, + "m_RangeValues": { + "x": 0.0, + "y": 2.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.SubtractNode", + "m_ObjectId": "830b4ad0320847a695332b5d1caafdb6", + "m_Group": { + "m_Id": "8797d77264e74bd38b2c09f136026a6b" + }, + "m_Name": "Subtract", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -1498.9998779296875, + "y": -4003.0, + "width": 130.0, + "height": 117.99999237060547 + } + }, + "m_Slots": [ + { + "m_Id": "8f596fbf558e4beab6a73e52d6c60d19" + }, + { + "m_Id": "514b54cbe2634f3cb48cd8beee102796" + }, + { + "m_Id": "51b5c0e34478418da4df9c35a336b14c" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "837ef6506d354e23828ff6caa45dfe78", + "m_Id": 0, + "m_DisplayName": "In", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "In", + "m_StageCapability": 3, + "m_Value": { + "x": 1.0, + "y": 1.0, + "z": 1.0, + "w": 1.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.HueNode", + "m_ObjectId": "84bdfaea919e418dbad1cf44d06dc11b", + "m_Group": { + "m_Id": "47b971716ee4470f865fc5c885abcf66" + }, + "m_Name": "Hue", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -1844.000244140625, + "y": -2980.999755859375, + "width": 152.99998474121095, + "height": 153.99998474121095 + } + }, + "m_Slots": [ + { + "m_Id": "10e5715ba6254eaaa741ce19ac481909" + }, + { + "m_Id": "a862f5725fd84600bf7e292f9c8fcab2" + }, + { + "m_Id": "02d0ef52726545c6a6974e90fcf0d2cf" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_HueMode": 0 +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "84fc79c7cb9344158930cd2f920a16cb", + "m_Id": 0, + "m_DisplayName": "IsCornea", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "8560af1b51c34bdbb978a24d00c1f908", + "m_Id": 0, + "m_DisplayName": "IsCornea", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "858394ee88624b5f9553e36483a98aa2", + "m_Id": 1, + "m_DisplayName": "", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.SamplerStateMaterialSlot", + "m_ObjectId": "85c5c76f4845488eb95392938396f2b9", + "m_Id": 3, + "m_DisplayName": "Sampler", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "Sampler", + "m_StageCapability": 3, + "m_BareResource": false +} + +{ + "m_SGVersion": 1, + "m_Type": "UnityEditor.ShaderGraph.Internal.Vector1ShaderProperty", + "m_ObjectId": "85e5e0cd46aa44fc8e9f720d375bec49", + "m_Guid": { + "m_GuidSerialized": "25d1ad42-2b6a-4ab3-b172-f5e2c2e8c800" + }, + "m_Name": "Iris Scale", + "m_DefaultReferenceName": "Vector1_85e5e0cd46aa44fc8e9f720d375bec49", + "m_OverrideReferenceName": "_IrisScale", + "m_GeneratePropertyBlock": true, + "m_Precision": 0, + "overrideHLSLDeclaration": false, + "hlslDeclarationOverride": 0, + "m_Hidden": false, + "m_Value": 1.0, + "m_FloatType": 1, + "m_RangeValues": { + "x": 0.25, + "y": 2.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.GroupData", + "m_ObjectId": "862059ed0bf141dd9404f65a66b53cd8", + "m_Title": "Color Blend", + "m_Position": { + "x": 336.000732421875, + "y": -1077.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector4MaterialSlot", + "m_ObjectId": "86b897ab597140d59a473d807e980628", + "m_Id": 0, + "m_DisplayName": "RGBA", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "RGBA", + "m_StageCapability": 2, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector2MaterialSlot", + "m_ObjectId": "873fbd213cf2402aac9e0175a27af9f9", + "m_Id": 1, + "m_DisplayName": "In Min Max", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "InMinMax", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.10000000149011612 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0 + }, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.GroupData", + "m_ObjectId": "8797d77264e74bd38b2c09f136026a6b", + "m_Title": "Radial Gradient", + "m_Position": { + "x": -1963.0, + "y": -4062.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.Rendering.HighDefinition.ShaderGraph.BuiltinData", + "m_ObjectId": "88f0b3d71738482fb6273b754134b4dd", + "m_Distortion": false, + "m_DistortionMode": 0, + "m_DistortionDepthTest": true, + "m_AddPrecomputedVelocity": false, + "m_TransparentWritesMotionVec": false, + "m_AlphaToMask": true, + "m_DepthOffset": false, + "m_TransparencyFog": true, + "m_AlphaTestShadow": true, + "m_BackThenFrontRendering": false, + "m_TransparentDepthPrepass": false, + "m_TransparentDepthPostpass": false, + "m_SupportLodCrossFade": false +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.BlockNode", + "m_ObjectId": "88f18d873f5c49058d48d6325df9b08c", + "m_Group": { + "m_Id": "" + }, + "m_Name": "SurfaceDescription.RefractionIndex", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": 1376.0, + "y": 372.0000305175781, + "width": 200.00001525878907, + "height": 41.000003814697269 + } + }, + "m_Slots": [ + { + "m_Id": "f4043b2118f342699d2327c2adcc8f9e" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_SerializedDescriptor": "SurfaceDescription.RefractionIndex" +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Internal.Texture2DShaderProperty", + "m_ObjectId": "8a49d2f872e946d4a29e2030ee291584", + "m_Guid": { + "m_GuidSerialized": "79f607da-c2f1-46b1-8320-f91a0aef3386" + }, + "m_Name": "Sclera Normal Map", + "m_DefaultReferenceName": "Texture2D_8a49d2f872e946d4a29e2030ee291584", + "m_OverrideReferenceName": "_ScleraNormalMap", + "m_GeneratePropertyBlock": true, + "m_Precision": 0, + "overrideHLSLDeclaration": false, + "hlslDeclarationOverride": 0, + "m_Hidden": false, + "m_Value": { + "m_SerializedTexture": "{\"texture\":{\"instanceID\":0}}", + "m_Guid": "" + }, + "m_Modifiable": true, + "m_DefaultType": 0 +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.PropertyNode", + "m_ObjectId": "8a638e82aa1d4bf2a04304650d73fa8e", + "m_Group": { + "m_Id": "74c1d47e70e6422881a0e0f051febbb9" + }, + "m_Name": "Property", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -3895.0, + "y": -1612.0001220703125, + "width": 133.0, + "height": 34.0 + } + }, + "m_Slots": [ + { + "m_Id": "1187631eba89423095054f58dc91993f" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_Property": { + "m_Id": "596515c1061c4119b6831a17bd392746" + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "8a652b9a6a2b4d338c9a592cf6fbc1d5", + "m_Id": 1, + "m_DisplayName": "", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.BlockNode", + "m_ObjectId": "8a7ae7a881424567bd38f733cff73869", + "m_Group": { + "m_Id": "" + }, + "m_Name": "SurfaceDescription.BaseColor", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": 0.0, + "y": 0.0, + "width": 0.0, + "height": 0.0 + } + }, + "m_Slots": [ + { + "m_Id": "745ea487c66c466f84d2c16a08c4b1b6" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_SerializedDescriptor": "SurfaceDescription.BaseColor" +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "8abe382886744592b515d58977576689", + "m_Id": 0, + "m_DisplayName": "", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.MultiplyNode", + "m_ObjectId": "8b50c6d9dfd14cd7813b6ca0dcaa3f94", + "m_Group": { + "m_Id": "9be24d51d0344c13bc6aef014a27580b" + }, + "m_Name": "Multiply", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -715.000244140625, + "y": 479.99993896484377, + "width": 126.0, + "height": 118.0 + } + }, + "m_Slots": [ + { + "m_Id": "ad7dda04817d417ab375101274d94327" + }, + { + "m_Id": "6dd35d61d74d4a38b4cb484f6280bee0" + }, + { + "m_Id": "492946e2a17a4cdaa02fa523c6e6a17b" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector3MaterialSlot", + "m_ObjectId": "8b5e754d8d084c759ba900f27d26973f", + "m_Id": 2, + "m_DisplayName": "Out", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0 + }, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.UVMaterialSlot", + "m_ObjectId": "8c95ccd4e8fd4bf29cc1afa00cc39223", + "m_Id": 2, + "m_DisplayName": "UV", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "UV", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0 + }, + "m_Labels": [], + "m_Channel": 0 +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicValueMaterialSlot", + "m_ObjectId": "8ccbcc814ac74f2d87b7d2f3762ad407", + "m_Id": 2, + "m_DisplayName": "Out", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": { + "e00": 0.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 0.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 0.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 0.0 + }, + "m_DefaultValue": { + "e00": 1.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 1.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 1.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.BlockNode", + "m_ObjectId": "8d097bd0ba5d4813baa363e9331172b1", + "m_Group": { + "m_Id": "" + }, + "m_Name": "SurfaceDescription.RefractionColor", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": 1346.0, + "y": 120.0, + "width": 200.0, + "height": 41.0 + } + }, + "m_Slots": [ + { + "m_Id": "97120e33ff604c9caae2e84e58df1aa9" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_SerializedDescriptor": "SurfaceDescription.RefractionColor" +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector2MaterialSlot", + "m_ObjectId": "8d2248a7c58e45049c94fb19467eea91", + "m_Id": 1, + "m_DisplayName": "Tiling", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "Tiling", + "m_StageCapability": 3, + "m_Value": { + "x": 1.0, + "y": 1.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0 + }, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.PropertyNode", + "m_ObjectId": "8dae98b4bffa4bdd8f7b5ca2822e97d2", + "m_Group": { + "m_Id": "8e986fb6ad9c4fdab0a043872278421b" + }, + "m_Name": "Property", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -1147.999755859375, + "y": 62.00000762939453, + "width": 185.0, + "height": 34.0 + } + }, + "m_Slots": [ + { + "m_Id": "a19172356276426b913eb437aa587a7c" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_Property": { + "m_Id": "f529da1a611a46cda7c335f575a5999b" + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "8e772a4c6d814ac59021f87dd1faa3f3", + "m_Id": 2, + "m_DisplayName": "In", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "In", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.GroupData", + "m_ObjectId": "8e986fb6ad9c4fdab0a043872278421b", + "m_Title": "Refraction Thickness", + "m_Position": { + "x": -1218.0006103515625, + "y": 3.000446319580078 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicValueMaterialSlot", + "m_ObjectId": "8eaaff414f4a4910a9d7140948dea838", + "m_Id": 1, + "m_DisplayName": "B", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "B", + "m_StageCapability": 3, + "m_Value": { + "e00": 2.0, + "e01": 2.0, + "e02": 2.0, + "e03": 2.0, + "e10": 2.0, + "e11": 2.0, + "e12": 2.0, + "e13": 2.0, + "e20": 2.0, + "e21": 2.0, + "e22": 2.0, + "e23": 2.0, + "e30": 2.0, + "e31": 2.0, + "e32": 2.0, + "e33": 2.0 + }, + "m_DefaultValue": { + "e00": 1.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 1.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 1.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.SaturationNode", + "m_ObjectId": "8eda96c3858f479cbd78b61e73194ef7", + "m_Group": { + "m_Id": "74c1d47e70e6422881a0e0f051febbb9" + }, + "m_Name": "Saturation", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -1683.9998779296875, + "y": -1630.0001220703125, + "width": 174.0, + "height": 118.0 + } + }, + "m_Slots": [ + { + "m_Id": "46519d6a33a448aaa3c5ea5132944065" + }, + { + "m_Id": "d28cb622c4904e2d8373c94ba88a38dd" + }, + { + "m_Id": "61fcdc9fb80e4d76a367f036ae0bd122" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "8f596fbf558e4beab6a73e52d6c60d19", + "m_Id": 0, + "m_DisplayName": "A", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "A", + "m_StageCapability": 3, + "m_Value": { + "x": 1.0, + "y": 1.0, + "z": 1.0, + "w": 1.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicValueMaterialSlot", + "m_ObjectId": "8f9e9efa12d24f51a67dbfa72bce5597", + "m_Id": 0, + "m_DisplayName": "A", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "A", + "m_StageCapability": 3, + "m_Value": { + "e00": 0.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 0.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 0.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 0.0 + }, + "m_DefaultValue": { + "e00": 1.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 1.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 1.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "9063dddf00454b7c8d9b1cc9d82d56e3", + "m_Id": 1, + "m_DisplayName": "X", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "X", + "m_StageCapability": 3, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.MultiplyNode", + "m_ObjectId": "9087b9a01e164fa490cb7d1132f0ee11", + "m_Group": { + "m_Id": "47b971716ee4470f865fc5c885abcf66" + }, + "m_Name": "Multiply", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -2946.999755859375, + "y": -2799.0, + "width": 129.99998474121095, + "height": 117.99999237060547 + } + }, + "m_Slots": [ + { + "m_Id": "975a74b35d7e43ff85fc139459a7d1cf" + }, + { + "m_Id": "186d195e42d84be1876f2ec4fb35bd24" + }, + { + "m_Id": "8ccbcc814ac74f2d87b7d2f3762ad407" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Texture2DMaterialSlot", + "m_ObjectId": "91003272cd724136acd73ab4f3955049", + "m_Id": 0, + "m_DisplayName": "Sclera Normal Map", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_BareResource": false +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicValueMaterialSlot", + "m_ObjectId": "926f9ec0aedf47b0b73aa80ebf531fbc", + "m_Id": 1, + "m_DisplayName": "B", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "B", + "m_StageCapability": 3, + "m_Value": { + "e00": 2.0, + "e01": 2.0, + "e02": 2.0, + "e03": 2.0, + "e10": 2.0, + "e11": 2.0, + "e12": 2.0, + "e13": 2.0, + "e20": 2.0, + "e21": 2.0, + "e22": 2.0, + "e23": 2.0, + "e30": 2.0, + "e31": 2.0, + "e32": 2.0, + "e33": 2.0 + }, + "m_DefaultValue": { + "e00": 1.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 1.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 1.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector3MaterialSlot", + "m_ObjectId": "927d5dd6ac0941f8b8081127482ab289", + "m_Id": 0, + "m_DisplayName": "Out", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0 + }, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "92f484ab7aff42778b244cc29b9beb21", + "m_Id": 1, + "m_DisplayName": "Out", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "92fad1cdc19144d4b327a6da9f9c9867", + "m_Id": 0, + "m_DisplayName": "Ambient Occlusion Strength", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.OneMinusNode", + "m_ObjectId": "93152c3843a142efa5ea3d8de29e187c", + "m_Group": { + "m_Id": "9be24d51d0344c13bc6aef014a27580b" + }, + "m_Name": "One Minus", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -1012.000244140625, + "y": 522.0001220703125, + "width": 128.0, + "height": 94.0 + } + }, + "m_Slots": [ + { + "m_Id": "7506948833b144c8867c0e7bfb8b93e3" + }, + { + "m_Id": "92f484ab7aff42778b244cc29b9beb21" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.GroupData", + "m_ObjectId": "9392ab8fa6934d1a81cbe54f6c435b52", + "m_Title": "Iris Vertex Depth", + "m_Position": { + "x": -295.99951171875, + "y": -4124.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.KeywordNode", + "m_ObjectId": "939c0dcd55b443e29650f7cffa67c658", + "m_Group": { + "m_Id": "" + }, + "m_Name": "IsCornea", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": 685.0001220703125, + "y": -3876.0, + "width": 167.0, + "height": 117.99999237060547 + } + }, + "m_Slots": [ + { + "m_Id": "8560af1b51c34bdbb978a24d00c1f908" + }, + { + "m_Id": "d82a4147c9244e349a09e0ca8ca00b5e" + }, + { + "m_Id": "eccc70d10a654ecca8ee83017f5a7f3c" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_Keyword": { + "m_Id": "9d63910b86f7439f9642f08926860a8e" + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "93a342717d3045b5a8a3d949c6a802fc", + "m_Id": 1, + "m_DisplayName": "", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicValueMaterialSlot", + "m_ObjectId": "947643dc698142759a730c2590959491", + "m_Id": 1, + "m_DisplayName": "B", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "B", + "m_StageCapability": 3, + "m_Value": { + "e00": 2.0, + "e01": 2.0, + "e02": 2.0, + "e03": 2.0, + "e10": 2.0, + "e11": 2.0, + "e12": 2.0, + "e13": 2.0, + "e20": 2.0, + "e21": 2.0, + "e22": 2.0, + "e23": 2.0, + "e30": 2.0, + "e31": 2.0, + "e32": 2.0, + "e33": 2.0 + }, + "m_DefaultValue": { + "e00": 1.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 1.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 1.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "95251db95bb34e64b4a84ec66799e009", + "m_Id": 1, + "m_DisplayName": "", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "9539b68ac0384351bd380dce56e448ab", + "m_Id": 1, + "m_DisplayName": "X", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "X", + "m_StageCapability": 3, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.LengthNode", + "m_ObjectId": "953fa7f504094a569b4c7ca8216cd28c", + "m_Group": { + "m_Id": "0ca230dd81f04c0ba5af42953674323c" + }, + "m_Name": "Length", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -5503.99951171875, + "y": -605.0, + "width": 207.99998474121095, + "height": 278.0 + } + }, + "m_Slots": [ + { + "m_Id": "203ac1fb2a184cd5bb42f0b2422b2d57" + }, + { + "m_Id": "d03529e496f14651aa4279692c918977" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "95778f59c98f490dbbb8c92d435bf27b", + "m_Id": 1, + "m_DisplayName": "On", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "On", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicValueMaterialSlot", + "m_ObjectId": "95db3152a1514a9d93e495d197f3666b", + "m_Id": 0, + "m_DisplayName": "A", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "A", + "m_StageCapability": 3, + "m_Value": { + "e00": 0.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 0.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 0.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 0.0 + }, + "m_DefaultValue": { + "e00": 1.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 1.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 1.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.LerpNode", + "m_ObjectId": "95eb2c3b36dd4d68a9e131e57395f7ba", + "m_Group": { + "m_Id": "74c1d47e70e6422881a0e0f051febbb9" + }, + "m_Name": "Lerp", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -3397.999755859375, + "y": -1720.0001220703125, + "width": 126.00000762939453, + "height": 142.00001525878907 + } + }, + "m_Slots": [ + { + "m_Id": "bf42457ac1024715a51b6e02cd9828d8" + }, + { + "m_Id": "ef190842659c4e7f89f23feb471ca3e4" + }, + { + "m_Id": "3c46e274f0324cd0b81a99270196c3d4" + }, + { + "m_Id": "e315690100b446f48267f5562c1e8883" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.ColorRGBMaterialSlot", + "m_ObjectId": "97120e33ff604c9caae2e84e58df1aa9", + "m_Id": 0, + "m_DisplayName": "Refraction Color", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "RefractionColor", + "m_StageCapability": 2, + "m_Value": { + "x": 1.0, + "y": 1.0, + "z": 1.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0 + }, + "m_Labels": [], + "m_ColorMode": 0, + "m_DefaultColor": { + "r": 1.0, + "g": 1.0, + "b": 1.0, + "a": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicValueMaterialSlot", + "m_ObjectId": "975a74b35d7e43ff85fc139459a7d1cf", + "m_Id": 0, + "m_DisplayName": "A", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "A", + "m_StageCapability": 3, + "m_Value": { + "e00": 0.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 0.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 0.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 0.0 + }, + "m_DefaultValue": { + "e00": 1.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 1.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 1.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.RemapNode", + "m_ObjectId": "989a5b6ec439465aa4eed4b75eeec61b", + "m_Group": { + "m_Id": "fa7b0f3ba7d84ba7a4d19d87b7a3c4b8" + }, + "m_Name": "Remap", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -4720.0, + "y": -1404.0001220703125, + "width": 208.0, + "height": 326.0 + } + }, + "m_Slots": [ + { + "m_Id": "b2c7f801df48402986c0ce3c2f330830" + }, + { + "m_Id": "873fbd213cf2402aac9e0175a27af9f9" + }, + { + "m_Id": "34e1a46a7dfb4a82abdb3da5e3a851f2" + }, + { + "m_Id": "1dd067f750724bbc991357e710efc4e2" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "98a0f05c542d4304b34e1574db1c11ac", + "m_Id": 0, + "m_DisplayName": "Depth Radius", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.UVMaterialSlot", + "m_ObjectId": "9945fac9868c413a90372bad00df3a53", + "m_Id": 0, + "m_DisplayName": "UV", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "UV", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0 + }, + "m_Labels": [], + "m_Channel": 0 +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "996a51c0a47f42f7b52a3570ce9e0a33", + "m_Id": 7, + "m_DisplayName": "A", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "A", + "m_StageCapability": 2, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 1, + "m_Type": "UnityEditor.ShaderGraph.Internal.Vector1ShaderProperty", + "m_ObjectId": "99ad21e27a3f4d3cb1b1736abc28020d", + "m_Guid": { + "m_GuidSerialized": "8fbe50ee-42d2-4cb1-8019-b8e5df5a5274" + }, + "m_Name": "Limbus Dark Radius", + "m_DefaultReferenceName": "Vector1_99ad21e27a3f4d3cb1b1736abc28020d", + "m_OverrideReferenceName": "_LimbusDarkRadius", + "m_GeneratePropertyBlock": true, + "m_Precision": 0, + "overrideHLSLDeclaration": false, + "hlslDeclarationOverride": 0, + "m_Hidden": false, + "m_Value": 0.10000000149011612, + "m_FloatType": 1, + "m_RangeValues": { + "x": 0.009999999776482582, + "y": 0.20000000298023225 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "9abd7eee5b4f4b1ca3bd01fc278fde82", + "m_Id": 1, + "m_DisplayName": "", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "9b067b8ba62842f3a304c73318db241e", + "m_Id": 2, + "m_DisplayName": "Out", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicValueMaterialSlot", + "m_ObjectId": "9b4847f7397d4127823ef8811603c40b", + "m_Id": 2, + "m_DisplayName": "Out", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": { + "e00": 0.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 0.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 0.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 0.0 + }, + "m_DefaultValue": { + "e00": 1.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 1.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 1.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "9b49235025f24121a3127a3e9a2aac35", + "m_Id": 1, + "m_DisplayName": "Strength", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "Strength", + "m_StageCapability": 3, + "m_Value": 1.0, + "m_DefaultValue": 1.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicValueMaterialSlot", + "m_ObjectId": "9bc98f2daa24404fbc5f9721fd4113f6", + "m_Id": 1, + "m_DisplayName": "B", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "B", + "m_StageCapability": 3, + "m_Value": { + "e00": 2.0, + "e01": 2.0, + "e02": 2.0, + "e03": 2.0, + "e10": 2.0, + "e11": 2.0, + "e12": 2.0, + "e13": 2.0, + "e20": 2.0, + "e21": 2.0, + "e22": 2.0, + "e23": 2.0, + "e30": 2.0, + "e31": 2.0, + "e32": 2.0, + "e33": 2.0 + }, + "m_DefaultValue": { + "e00": 1.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 1.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 1.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 1.0 + } +} + +{ + "m_SGVersion": 1, + "m_Type": "UnityEditor.ShaderGraph.Internal.Vector1ShaderProperty", + "m_ObjectId": "9be1515fae6d42c09957951f4f4fd357", + "m_Guid": { + "m_GuidSerialized": "13430cdf-5441-4beb-a06f-dc1285c3c91d" + }, + "m_Name": "Sclera Normal Strength", + "m_DefaultReferenceName": "Vector1_9be1515fae6d42c09957951f4f4fd357", + "m_OverrideReferenceName": "_ScleraNormalStrength", + "m_GeneratePropertyBlock": true, + "m_Precision": 0, + "overrideHLSLDeclaration": false, + "hlslDeclarationOverride": 0, + "m_Hidden": false, + "m_Value": 0.10000000149011612, + "m_FloatType": 1, + "m_RangeValues": { + "x": 0.0, + "y": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.GroupData", + "m_ObjectId": "9be24d51d0344c13bc6aef014a27580b", + "m_Title": "Ambient Occlusion", + "m_Position": { + "x": -1573.0, + "y": 312.00048828125 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.UVMaterialSlot", + "m_ObjectId": "9c09e8f492ec402e966b5e430a391251", + "m_Id": 2, + "m_DisplayName": "UV", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "UV", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0 + }, + "m_Labels": [], + "m_Channel": 0 +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "9c6d7a3a80c44bc2abca376bd090c0c0", + "m_Id": 3, + "m_DisplayName": "Z", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "Z", + "m_StageCapability": 3, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [ + "Z" + ] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector4MaterialSlot", + "m_ObjectId": "9cdf3221230e4655b7ddd4206eb1e16d", + "m_Id": 0, + "m_DisplayName": "Corner Shadow Color", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "9ce532d7c7304925818587d13614c0cd", + "m_Id": 0, + "m_DisplayName": "Metallic", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "Metallic", + "m_StageCapability": 2, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.StickyNoteData", + "m_ObjectId": "9d19945f6155442c8b409fda6b0d4e5d", + "m_Title": "Radial Gradient", + "m_Content": "Generates a radial gradient pattern centered at 0.5, 0.5.\n\ni.e. radial = length(uv - 0.5)\n\nThis is used to generate the iris, limbus, depth and shadow blend masks.", + "m_TextSize": 0, + "m_Theme": 0, + "m_Position": { + "serializedVersion": "2", + "x": -5497.0, + "y": -808.0, + "width": 200.0, + "height": 160.0 + }, + "m_Group": { + "m_Id": "0ca230dd81f04c0ba5af42953674323c" + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.ShaderKeyword", + "m_ObjectId": "9d63910b86f7439f9642f08926860a8e", + "m_Guid": { + "m_GuidSerialized": "5ef0060d-37c5-49f1-a2d1-d8a505fe9d09" + }, + "m_Name": "IsCornea", + "m_DefaultReferenceName": "BOOLEAN_9D63910B86F7439F9642F08926860A8E_ON", + "m_OverrideReferenceName": "BOOLEAN_ISCORNEA_ON", + "m_GeneratePropertyBlock": true, + "m_KeywordType": 0, + "m_KeywordDefinition": 1, + "m_KeywordScope": 0, + "m_Entries": [], + "m_Value": 0, + "m_IsEditable": true +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "9ee3e1ad7c7e41229c48dda8fccc9d84", + "m_Id": 1, + "m_DisplayName": "Blend", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "Blend", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.MultiplyNode", + "m_ObjectId": "a11e0b5579d84698b53dcf812e56b73c", + "m_Group": { + "m_Id": "74c1d47e70e6422881a0e0f051febbb9" + }, + "m_Name": "Multiply", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -1485.9998779296875, + "y": -1510.0001220703125, + "width": 130.0, + "height": 118.0 + } + }, + "m_Slots": [ + { + "m_Id": "e1d0ea24b65d4c8e9a48fa545c45fe0b" + }, + { + "m_Id": "b2d465d971324ac78b5823423d539f0c" + }, + { + "m_Id": "be63ae9fc4ed49fbb82b21a1a8158bba" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.GroupData", + "m_ObjectId": "a145967c42cb43d59d7699fc064ab763", + "m_Title": "Scaled Iris Radius", + "m_Position": { + "x": -2037.9998779296875, + "y": -3471.0 + } +} + +{ + "m_SGVersion": 1, + "m_Type": "UnityEditor.ShaderGraph.PositionNode", + "m_ObjectId": "a174a97b68ea4d85a8eef303cc274672", + "m_Group": { + "m_Id": "9392ab8fa6934d1a81cbe54f6c435b52" + }, + "m_Name": "Position", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -91.9996337890625, + "y": -3862.0, + "width": 206.0, + "height": 132.0 + } + }, + "m_Slots": [ + { + "m_Id": "00759dbf8a6c41718edcdf0098844a45" + } + ], + "synonyms": [], + "m_Precision": 1, + "m_PreviewExpanded": false, + "m_PreviewMode": 2, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_Space": 0 +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "a19172356276426b913eb437aa587a7c", + "m_Id": 0, + "m_DisplayName": "Refraction Thickness", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "a1de380471f2433e9a9eaccf85b0dd03", + "m_Id": 1, + "m_DisplayName": "On", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "On", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "a21a119790b24b098e7e4112b39bbdc6", + "m_Id": 0, + "m_DisplayName": "Iris Scale", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.SaturateNode", + "m_ObjectId": "a24eb45d2dc040fcae00289ece0bfbc4", + "m_Group": { + "m_Id": "3366f611f8464c988208f0daa49f30d2" + }, + "m_Name": "Saturate", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -573.9995727539063, + "y": -3574.0, + "width": 128.0, + "height": 94.0 + } + }, + "m_Slots": [ + { + "m_Id": "288904dfd46f4601ad2559e9e2754b1b" + }, + { + "m_Id": "d45b8fd243e84bc3b05cfc78d34e3fdd" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.RedirectNodeData", + "m_ObjectId": "a2d4f554a9b94d62a34604525368014f", + "m_Group": { + "m_Id": "69bc229b1eb94e15a47d971b447a3198" + }, + "m_Name": "Redirect Node", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -2559.0, + "y": -2409.999755859375, + "width": 56.0, + "height": 23.999998092651368 + } + }, + "m_Slots": [ + { + "m_Id": "62f91fac8f3a411a98a1e5dbfa41bf97" + }, + { + "m_Id": "b124de9419db4a8f97b0917e6f364f04" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "a30a9dd090df46038d0a14b857f11104", + "m_Id": 0, + "m_DisplayName": "", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "a316e6e915c54b1aa1fcddb9dda15182", + "m_Id": 0, + "m_DisplayName": "", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "a3f0262ccdb34734ada80e49c3a3957b", + "m_Id": 0, + "m_DisplayName": "", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "a450f19a9c7345688ec499271818654e", + "m_Id": 0, + "m_DisplayName": "Base", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "Base", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "a510d45ac04c4809b146f25429b6ec58", + "m_Id": 1, + "m_DisplayName": "Out", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicValueMaterialSlot", + "m_ObjectId": "a5ef1c379ba648e19eb6388b655b8bd9", + "m_Id": 1, + "m_DisplayName": "B", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "B", + "m_StageCapability": 3, + "m_Value": { + "e00": 2.0, + "e01": 2.0, + "e02": 2.0, + "e03": 2.0, + "e10": 2.0, + "e11": 2.0, + "e12": 2.0, + "e13": 2.0, + "e20": 2.0, + "e21": 2.0, + "e22": 2.0, + "e23": 2.0, + "e30": 2.0, + "e31": 2.0, + "e32": 2.0, + "e33": 2.0 + }, + "m_DefaultValue": { + "e00": 1.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 1.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 1.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 1.0 + } +} + +{ + "m_SGVersion": 1, + "m_Type": "UnityEditor.ShaderGraph.Internal.Vector1ShaderProperty", + "m_ObjectId": "a71b2a13bfe64b8fbb07597467c80fb2", + "m_Guid": { + "m_GuidSerialized": "e0c7e921-f77e-4ee2-9217-d54cca974110" + }, + "m_Name": "Limbus Width", + "m_DefaultReferenceName": "Vector1_a71b2a13bfe64b8fbb07597467c80fb2", + "m_OverrideReferenceName": "_LimbusWidth", + "m_GeneratePropertyBlock": true, + "m_Precision": 0, + "overrideHLSLDeclaration": false, + "hlslDeclarationOverride": 0, + "m_Hidden": false, + "m_Value": 0.054999999701976779, + "m_FloatType": 1, + "m_RangeValues": { + "x": 0.009999999776482582, + "y": 0.10000000149011612 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.PropertyNode", + "m_ObjectId": "a72ad83bd1eb4a4691d245a59c9e41d5", + "m_Group": { + "m_Id": "69bc229b1eb94e15a47d971b447a3198" + }, + "m_Name": "Property", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -2573.0, + "y": -2204.999755859375, + "width": 171.0, + "height": 34.0 + } + }, + "m_Slots": [ + { + "m_Id": "13a56aed4baf40aead35c19bf77c6b17" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_Property": { + "m_Id": "ed1d6ae0d0e14a009081ff66d328aa52" + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "a862f5725fd84600bf7e292f9c8fcab2", + "m_Id": 1, + "m_DisplayName": "Offset", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "Offset", + "m_StageCapability": 3, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.PropertyNode", + "m_ObjectId": "a937a0903d924b98ae172912d6fa7a0f", + "m_Group": { + "m_Id": "fa7b0f3ba7d84ba7a4d19d87b7a3c4b8" + }, + "m_Name": "Property", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -5442.0, + "y": -1262.0, + "width": 146.0, + "height": 34.0 + } + }, + "m_Slots": [ + { + "m_Id": "72d01c55dcf44b8a8b300b720fcb51a1" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_Property": { + "m_Id": "424271c2190c4f42b931a851e201c75d" + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.PropertyNode", + "m_ObjectId": "a9d66e0df912494a9d80d1871739efd8", + "m_Group": { + "m_Id": "74c1d47e70e6422881a0e0f051febbb9" + }, + "m_Name": "Property", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -2610.999755859375, + "y": -1817.0001220703125, + "width": 188.0, + "height": 34.0 + } + }, + "m_Slots": [ + { + "m_Id": "c07c26aaf5b04d83bfa012cb924c62d8" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_Property": { + "m_Id": "0cbea652f4bf4177942231f39b7c2eea" + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.UVMaterialSlot", + "m_ObjectId": "aa5c9d8fd9624bcf973c3d409da1ba70", + "m_Id": 0, + "m_DisplayName": "UV", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "UV", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0 + }, + "m_Labels": [], + "m_Channel": 0 +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Texture2DInputMaterialSlot", + "m_ObjectId": "aa91de3a7a0d4046b57d6043a588a9f1", + "m_Id": 1, + "m_DisplayName": "Texture", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "Texture", + "m_StageCapability": 3, + "m_BareResource": false, + "m_Texture": { + "m_SerializedTexture": "{\"texture\":{\"instanceID\":0}}", + "m_Guid": "" + }, + "m_DefaultType": 0 +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicValueMaterialSlot", + "m_ObjectId": "aa95b263f0cf4341aaf3354154ebaec6", + "m_Id": 0, + "m_DisplayName": "A", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "A", + "m_StageCapability": 3, + "m_Value": { + "e00": 0.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 0.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 0.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 0.0 + }, + "m_DefaultValue": { + "e00": 1.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 1.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 1.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector2MaterialSlot", + "m_ObjectId": "ab2ac5232d8b43beb48733b10113e874", + "m_Id": 2, + "m_DisplayName": "Out Min Max", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "OutMinMax", + "m_StageCapability": 3, + "m_Value": { + "x": 1.0, + "y": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0 + }, + "m_Labels": [] +} + +{ + "m_SGVersion": 1, + "m_Type": "UnityEditor.ShaderGraph.Internal.Vector1ShaderProperty", + "m_ObjectId": "ab45ac5b088b42518d305de12d5f3763", + "m_Guid": { + "m_GuidSerialized": "703d6dbf-878a-41a3-a336-e855c6045dad" + }, + "m_Name": "Sclera Smoothness", + "m_DefaultReferenceName": "Vector1_ab45ac5b088b42518d305de12d5f3763", + "m_OverrideReferenceName": "_ScleraSmoothness", + "m_GeneratePropertyBlock": true, + "m_Precision": 0, + "overrideHLSLDeclaration": false, + "hlslDeclarationOverride": 0, + "m_Hidden": false, + "m_Value": 0.800000011920929, + "m_FloatType": 1, + "m_RangeValues": { + "x": 0.0, + "y": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.PropertyNode", + "m_ObjectId": "ab61ef9ae4eb4f74bd3712a4798c1b93", + "m_Group": { + "m_Id": "3d2583bfe59949a280911e6c487c911f" + }, + "m_Name": "Property", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -1147.000244140625, + "y": -258.99993896484377, + "width": 177.0, + "height": 34.0 + } + }, + "m_Slots": [ + { + "m_Id": "e5b5667fe2b844a9bc3d760d4fd55b31" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_Property": { + "m_Id": "ab45ac5b088b42518d305de12d5f3763" + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.PropertyNode", + "m_ObjectId": "abcb0bd1f0ef4265b7f3627c28ea272c", + "m_Group": { + "m_Id": "74c1d47e70e6422881a0e0f051febbb9" + }, + "m_Name": "Property", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -2436.999755859375, + "y": -1504.0001220703125, + "width": 115.0, + "height": 34.0 + } + }, + "m_Slots": [ + { + "m_Id": "b9974f5f442746f2adbc1f0bef607d4a" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_Property": { + "m_Id": "6106c8c4dc85475886881929b289ae65" + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.GroupData", + "m_ObjectId": "ac1d8910df764e109e212887850df3ab", + "m_Title": "Scaled Iris Radius", + "m_Position": { + "x": -7051.99951171875, + "y": -663.999755859375 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "ac2a34b9eaf94336a5819a4c89e02a2c", + "m_Id": 2, + "m_DisplayName": "Out", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicValueMaterialSlot", + "m_ObjectId": "ac41c78fc4e44dd98341288e64855202", + "m_Id": 0, + "m_DisplayName": "A", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "A", + "m_StageCapability": 3, + "m_Value": { + "e00": 0.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 0.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 0.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 0.0 + }, + "m_DefaultValue": { + "e00": 1.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 1.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 1.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "acadc79c12b24f04899ef27da96d24b8", + "m_Id": 0, + "m_DisplayName": "", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicValueMaterialSlot", + "m_ObjectId": "ad05bf088cd441d4b377f73ec51d6ceb", + "m_Id": 2, + "m_DisplayName": "Out", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": { + "e00": 0.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 0.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 0.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 0.0 + }, + "m_DefaultValue": { + "e00": 1.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 1.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 1.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "ad17646de25046f2ba4d37247775eaa7", + "m_Id": 1, + "m_DisplayName": "", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "ad46a176c1ac40b78ee3a38ad5846d4d", + "m_Id": 7, + "m_DisplayName": "A", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "A", + "m_StageCapability": 2, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicValueMaterialSlot", + "m_ObjectId": "ad7dda04817d417ab375101274d94327", + "m_Id": 0, + "m_DisplayName": "A", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "A", + "m_StageCapability": 3, + "m_Value": { + "e00": 0.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 0.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 0.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 0.0 + }, + "m_DefaultValue": { + "e00": 1.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 1.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 1.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "afc342d4828b42509da0bac49db15c31", + "m_Id": 3, + "m_DisplayName": "Out", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.SampleTexture2DNode", + "m_ObjectId": "afcfe1b0e92042a69deaf6315b6813a8", + "m_Group": { + "m_Id": "74c1d47e70e6422881a0e0f051febbb9" + }, + "m_Name": "Sample Texture 2D", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -2312.999755859375, + "y": -1785.0001220703125, + "width": 184.0, + "height": 252.99998474121095 + } + }, + "m_Slots": [ + { + "m_Id": "3afeb051dfc6480fbba18c4838ea4db2" + }, + { + "m_Id": "28292acb81814d0aa8a183f319e5bff8" + }, + { + "m_Id": "2665f44e25394fda89ce9578c3341a73" + }, + { + "m_Id": "bd6474d58cb3437f8d39fe1389e7f8a9" + }, + { + "m_Id": "4abf288a6e92496a981ad403c6f7dec4" + }, + { + "m_Id": "2c2d2e77a319444db369b815efb9541b" + }, + { + "m_Id": "e878d0ee617a430ea8991a6f147f451b" + }, + { + "m_Id": "2e4fbebcdf1e4ae1845461d0f6ad3cdb" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_TextureType": 0, + "m_NormalMapSpace": 0 +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "b04cecfbb56c4fab94441c7113126635", + "m_Id": 2, + "m_DisplayName": "Off", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "Off", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 1, + "m_Type": "UnityEditor.ShaderGraph.Internal.Vector1ShaderProperty", + "m_ObjectId": "b0ec1f6d5bd0419796b5090e7dffabf7", + "m_Guid": { + "m_GuidSerialized": "f6a8c263-b63d-48bc-86ec-13f1edcc87e4" + }, + "m_Name": "IOR", + "m_DefaultReferenceName": "Vector1_b0ec1f6d5bd0419796b5090e7dffabf7", + "m_OverrideReferenceName": "_IOR", + "m_GeneratePropertyBlock": true, + "m_Precision": 0, + "overrideHLSLDeclaration": false, + "hlslDeclarationOverride": 0, + "m_Hidden": false, + "m_Value": 1.399999976158142, + "m_FloatType": 1, + "m_RangeValues": { + "x": 1.0, + "y": 2.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "b124de9419db4a8f97b0917e6f364f04", + "m_Id": 1, + "m_DisplayName": "", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.RedirectNodeData", + "m_ObjectId": "b19b084a466d46849266805dbd24f45a", + "m_Group": { + "m_Id": "0ca230dd81f04c0ba5af42953674323c" + }, + "m_Name": "Redirect Node", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -4944.0, + "y": -889.0000610351563, + "width": 55.999996185302737, + "height": 23.999998092651368 + } + }, + "m_Slots": [ + { + "m_Id": "a3f0262ccdb34734ada80e49c3a3957b" + }, + { + "m_Id": "8a652b9a6a2b4d338c9a592cf6fbc1d5" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "b1adb0a0c54546a9903689c280e2583b", + "m_Id": 3, + "m_DisplayName": "Opacity", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "Opacity", + "m_StageCapability": 3, + "m_Value": 1.0, + "m_DefaultValue": 1.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "b2c7f801df48402986c0ce3c2f330830", + "m_Id": 0, + "m_DisplayName": "In", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "In", + "m_StageCapability": 3, + "m_Value": { + "x": -1.0, + "y": -1.0, + "z": -1.0, + "w": -1.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicValueMaterialSlot", + "m_ObjectId": "b2d465d971324ac78b5823423d539f0c", + "m_Id": 1, + "m_DisplayName": "B", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "B", + "m_StageCapability": 3, + "m_Value": { + "e00": 2.0, + "e01": 2.0, + "e02": 2.0, + "e03": 2.0, + "e10": 2.0, + "e11": 2.0, + "e12": 2.0, + "e13": 2.0, + "e20": 2.0, + "e21": 2.0, + "e22": 2.0, + "e23": 2.0, + "e30": 2.0, + "e31": 2.0, + "e32": 2.0, + "e33": 2.0 + }, + "m_DefaultValue": { + "e00": 1.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 1.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 1.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "b2fd080dc2604adf9233e13419eefd34", + "m_Id": 4, + "m_DisplayName": "R", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "R", + "m_StageCapability": 2, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "b3326238a76649fb9cbf27c70039dddd", + "m_Id": 2, + "m_DisplayName": "Out", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.PropertyNode", + "m_ObjectId": "b3821699d55c4ecd875e215826c1fb16", + "m_Group": { + "m_Id": "9392ab8fa6934d1a81cbe54f6c435b52" + }, + "m_Name": "Property", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -270.9998474121094, + "y": -3332.0, + "width": 127.0, + "height": 34.0 + } + }, + "m_Slots": [ + { + "m_Id": "492d9879d2ee4029ac205d75fc74acb1" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_Property": { + "m_Id": "13125e3e576e4c76b403dab13948fd74" + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "b384faa820304f82807176601dd16753", + "m_Id": 6, + "m_DisplayName": "B", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "B", + "m_StageCapability": 2, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicValueMaterialSlot", + "m_ObjectId": "b40ad7731cb1456aad2b951f672995ae", + "m_Id": 1, + "m_DisplayName": "B", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "B", + "m_StageCapability": 3, + "m_Value": { + "e00": 2.0, + "e01": 2.0, + "e02": 2.0, + "e03": 2.0, + "e10": 2.0, + "e11": 2.0, + "e12": 2.0, + "e13": 2.0, + "e20": 2.0, + "e21": 2.0, + "e22": 2.0, + "e23": 2.0, + "e30": 2.0, + "e31": 2.0, + "e32": 2.0, + "e33": 2.0 + }, + "m_DefaultValue": { + "e00": 1.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 1.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 1.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "b4adfd03694943e28ce6d5233fdf5dbc", + "m_Id": 6, + "m_DisplayName": "B", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "B", + "m_StageCapability": 2, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 1, + "m_Type": "UnityEditor.ShaderGraph.PositionNode", + "m_ObjectId": "b60d45d8cc9c4110aaf40f244bed69c6", + "m_Group": { + "m_Id": "9392ab8fa6934d1a81cbe54f6c435b52" + }, + "m_Name": "Position", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": 337.0000305175781, + "y": -4065.0, + "width": 206.0, + "height": 132.0 + } + }, + "m_Slots": [ + { + "m_Id": "f4ffe23f117a416ab21227a4927042d6" + } + ], + "synonyms": [], + "m_Precision": 1, + "m_PreviewExpanded": false, + "m_PreviewMode": 2, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_Space": 0 +} + +{ + "m_SGVersion": 1, + "m_Type": "UnityEditor.ShaderGraph.Internal.Vector1ShaderProperty", + "m_ObjectId": "b618279ad2eb41bd9df25d9f412e0eb1", + "m_Guid": { + "m_GuidSerialized": "10c1754f-6c68-4a79-9899-af50832769ae" + }, + "m_Name": "Iris Brightness", + "m_DefaultReferenceName": "", + "m_OverrideReferenceName": "_IrisBrightness", + "m_GeneratePropertyBlock": true, + "m_Precision": 0, + "overrideHLSLDeclaration": false, + "hlslDeclarationOverride": 0, + "m_Hidden": false, + "m_Value": 1.0, + "m_FloatType": 1, + "m_RangeValues": { + "x": 0.0, + "y": 2.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "b6d031bcce734f6f87a6454702ce62d9", + "m_Id": 1, + "m_DisplayName": "B", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "B", + "m_StageCapability": 3, + "m_Value": { + "x": 0.10000000149011612, + "y": 1.0, + "z": 1.0, + "w": 1.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.TilingAndOffsetNode", + "m_ObjectId": "b74b3332d6fe43dda8b59f706cc29f29", + "m_Group": { + "m_Id": "47b971716ee4470f865fc5c885abcf66" + }, + "m_Name": "Tiling And Offset", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -2755.0, + "y": -2967.999755859375, + "width": 155.0, + "height": 142.0 + } + }, + "m_Slots": [ + { + "m_Id": "9945fac9868c413a90372bad00df3a53" + }, + { + "m_Id": "8d2248a7c58e45049c94fb19467eea91" + }, + { + "m_Id": "6187435caaca41ae8d759cd1fdba1bb9" + }, + { + "m_Id": "cbb094df15814f8a9fe1e10bbb4bd6f7" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "b7bc60a4dd2f4474b6ee37d8ae231bc3", + "m_Id": 0, + "m_DisplayName": "Ambient Occlusion", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "Occlusion", + "m_StageCapability": 2, + "m_Value": 0.0, + "m_DefaultValue": 1.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "b7dbd6eb03894ec9a37f938cc3dee429", + "m_Id": 1, + "m_DisplayName": "B", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "B", + "m_StageCapability": 3, + "m_Value": { + "x": 2.0, + "y": 2.0, + "z": 2.0, + "w": 2.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.MultiplyNode", + "m_ObjectId": "b89f3fca13474ebc98719fceb8054eb0", + "m_Group": { + "m_Id": "4e7801ae7f8b4090be5d458121207cec" + }, + "m_Name": "Multiply", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -2024.9998779296875, + "y": -1059.0001220703125, + "width": 126.00000762939453, + "height": 118.0 + } + }, + "m_Slots": [ + { + "m_Id": "ac41c78fc4e44dd98341288e64855202" + }, + { + "m_Id": "947643dc698142759a730c2590959491" + }, + { + "m_Id": "82d40884687e41559a1046be16c70db9" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.PropertyNode", + "m_ObjectId": "b8b4cd1faff44ef793a1757988d5d564", + "m_Group": { + "m_Id": "9be24d51d0344c13bc6aef014a27580b" + }, + "m_Name": "Property", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -1024.9998779296875, + "y": 454.9998779296875, + "width": 220.99998474121095, + "height": 34.0 + } + }, + "m_Slots": [ + { + "m_Id": "92fad1cdc19144d4b327a6da9f9c9867" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_Property": { + "m_Id": "daa99c4f268449b8a4e69fdaeafcfe49" + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicValueMaterialSlot", + "m_ObjectId": "b8d296770e2d493c9dc81da32fcfd3a7", + "m_Id": 1, + "m_DisplayName": "B", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "B", + "m_StageCapability": 3, + "m_Value": { + "e00": 2.0, + "e01": 2.0, + "e02": 2.0, + "e03": 2.0, + "e10": 2.0, + "e11": 2.0, + "e12": 2.0, + "e13": 2.0, + "e20": 2.0, + "e21": 2.0, + "e22": 2.0, + "e23": 2.0, + "e30": 2.0, + "e31": 2.0, + "e32": 2.0, + "e33": 2.0 + }, + "m_DefaultValue": { + "e00": 1.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 1.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 1.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.BlockNode", + "m_ObjectId": "b90305df41fa48359109b31d35717317", + "m_Group": { + "m_Id": "" + }, + "m_Name": "SurfaceDescription.Metallic", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": 0.0, + "y": 0.0, + "width": 0.0, + "height": 0.0 + } + }, + "m_Slots": [ + { + "m_Id": "9ce532d7c7304925818587d13614c0cd" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_SerializedDescriptor": "SurfaceDescription.Metallic" +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicValueMaterialSlot", + "m_ObjectId": "b931e42ddc6a40bc8806b30b73d94b39", + "m_Id": 1, + "m_DisplayName": "B", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "B", + "m_StageCapability": 3, + "m_Value": { + "e00": 360.0, + "e01": 2.0, + "e02": 2.0, + "e03": 2.0, + "e10": 2.0, + "e11": 2.0, + "e12": 2.0, + "e13": 2.0, + "e20": 2.0, + "e21": 2.0, + "e22": 2.0, + "e23": 2.0, + "e30": 2.0, + "e31": 2.0, + "e32": 2.0, + "e33": 2.0 + }, + "m_DefaultValue": { + "e00": 1.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 1.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 1.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "b9974f5f442746f2adbc1f0bef607d4a", + "m_Id": 0, + "m_DisplayName": "Iris Hue", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicValueMaterialSlot", + "m_ObjectId": "ba15e9218b0b4d888d04b4a844594894", + "m_Id": 2, + "m_DisplayName": "Out", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": { + "e00": 0.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 0.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 0.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 0.0 + }, + "m_DefaultValue": { + "e00": 1.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 1.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 1.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector3MaterialSlot", + "m_ObjectId": "bb1d6125da5b40f78b383f9b323b60e1", + "m_Id": 2, + "m_DisplayName": "Out", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0 + }, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.BlockNode", + "m_ObjectId": "bb4e2f399363435db48ee90bf23f23fc", + "m_Group": { + "m_Id": "" + }, + "m_Name": "SurfaceDescription.Thickness", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": 1366.0001220703125, + "y": 455.0000305175781, + "width": 200.00001525878907, + "height": 41.000003814697269 + } + }, + "m_Slots": [ + { + "m_Id": "39386b6507884a3e8917400adc0c599b" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_SerializedDescriptor": "SurfaceDescription.Thickness" +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector3MaterialSlot", + "m_ObjectId": "bbf7f1f578454d75bc4a86614e5898ba", + "m_Id": 2, + "m_DisplayName": "Out", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0 + }, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.BlockNode", + "m_ObjectId": "bc0c9bafa3544deaaba658da5d1457a2", + "m_Group": { + "m_Id": "" + }, + "m_Name": "SurfaceDescription.NormalTS", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": 1374.0, + "y": 505.0000305175781, + "width": 200.00001525878907, + "height": 41.000003814697269 + } + }, + "m_Slots": [ + { + "m_Id": "0e03c873ccc040dd8417724de5eaf36d" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_SerializedDescriptor": "SurfaceDescription.NormalTS" +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.HueNode", + "m_ObjectId": "bc1baf1bf1fc4b25a8c5e0d18e315afd", + "m_Group": { + "m_Id": "74c1d47e70e6422881a0e0f051febbb9" + }, + "m_Name": "Hue", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -1859.999755859375, + "y": -1785.0001220703125, + "width": 153.0, + "height": 154.0 + } + }, + "m_Slots": [ + { + "m_Id": "3b2c7f94386c4c438dbb37d39b762857" + }, + { + "m_Id": "7e0b1b95c7b7415b89b926d448eace82" + }, + { + "m_Id": "8b5e754d8d084c759ba900f27d26973f" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_HueMode": 0 +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.TilingAndOffsetNode", + "m_ObjectId": "bc5f2c0ad23b44eb96bc7b83b3e78b4f", + "m_Group": { + "m_Id": "74c1d47e70e6422881a0e0f051febbb9" + }, + "m_Name": "Tiling And Offset", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -2577.999755859375, + "y": -1765.0001220703125, + "width": 155.0, + "height": 142.00001525878907 + } + }, + "m_Slots": [ + { + "m_Id": "0a037dce630b4fc9a60ae94f82fae69c" + }, + { + "m_Id": "3642fc47c2b344049dc360a662bad5f8" + }, + { + "m_Id": "dd3f96ef52694c30b2688a39d1c06025" + }, + { + "m_Id": "ebeb3767ef7d416ba24708085bd39a01" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.PropertyNode", + "m_ObjectId": "bd3b495317c543eabf80d124290b4122", + "m_Group": { + "m_Id": "e2d8030e74824bb48369331f4775f0ac" + }, + "m_Name": "Property", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -5799.0, + "y": -228.9999237060547, + "width": 148.0, + "height": 34.0 + } + }, + "m_Slots": [ + { + "m_Id": "3e1e74cd69784bce98955b9cc58c2b70" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_Property": { + "m_Id": "a71b2a13bfe64b8fbb07597467c80fb2" + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "bd6474d58cb3437f8d39fe1389e7f8a9", + "m_Id": 6, + "m_DisplayName": "B", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "B", + "m_StageCapability": 2, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.RedirectNodeData", + "m_ObjectId": "bde938d5baf14ecfbc7afa4925a31ecb", + "m_Group": { + "m_Id": "3d2583bfe59949a280911e6c487c911f" + }, + "m_Name": "Redirect Node", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -1147.000244140625, + "y": -213.99990844726563, + "width": 56.0, + "height": 23.999998092651368 + } + }, + "m_Slots": [ + { + "m_Id": "8abe382886744592b515d58977576689" + }, + { + "m_Id": "ad17646de25046f2ba4d37247775eaa7" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicValueMaterialSlot", + "m_ObjectId": "be63ae9fc4ed49fbb82b21a1a8158bba", + "m_Id": 2, + "m_DisplayName": "Out", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": { + "e00": 0.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 0.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 0.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 0.0 + }, + "m_DefaultValue": { + "e00": 1.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 1.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 1.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector2MaterialSlot", + "m_ObjectId": "bec42110e435494787084b07261f13ab", + "m_Id": 0, + "m_DisplayName": "Out", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0 + }, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "bf42457ac1024715a51b6e02cd9828d8", + "m_Id": 0, + "m_DisplayName": "A", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "A", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.UVMaterialSlot", + "m_ObjectId": "c045ae097b974009a6323f09c7478315", + "m_Id": 2, + "m_DisplayName": "UV", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "UV", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0 + }, + "m_Labels": [], + "m_Channel": 0 +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Texture2DMaterialSlot", + "m_ObjectId": "c07c26aaf5b04d83bfa012cb924c62d8", + "m_Id": 0, + "m_DisplayName": "Cornea Diffuse Map", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_BareResource": false +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicValueMaterialSlot", + "m_ObjectId": "c082e1fff8084103a2377f8707917419", + "m_Id": 2, + "m_DisplayName": "Out", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": { + "e00": 0.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 0.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 0.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 0.0 + }, + "m_DefaultValue": { + "e00": 1.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 1.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 1.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.RedirectNodeData", + "m_ObjectId": "c0c3c5c181cc4e3ea7ae03e90bd20b5d", + "m_Group": { + "m_Id": "e2d8030e74824bb48369331f4775f0ac" + }, + "m_Name": "Redirect Node", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -4751.0, + "y": -92.0, + "width": 56.0, + "height": 23.999998092651368 + } + }, + "m_Slots": [ + { + "m_Id": "fe7938b10bab4867b7f7537b54298c09" + }, + { + "m_Id": "29b7b989e16e4e458499d6ded4245332" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.SaturationNode", + "m_ObjectId": "c0f127f890774e2987f07ee8f1002231", + "m_Group": { + "m_Id": "47b971716ee4470f865fc5c885abcf66" + }, + "m_Name": "Saturation", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -1668.0, + "y": -2825.999755859375, + "width": 174.0, + "height": 118.0 + } + }, + "m_Slots": [ + { + "m_Id": "10235c7bfd8241f9b461e2bb6da33a75" + }, + { + "m_Id": "df12d0f26f5a4d81a55e3f1873258b8b" + }, + { + "m_Id": "bbf7f1f578454d75bc4a86614e5898ba" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "c20ea245c4f243039fc4190ff1ccbffd", + "m_Id": 2, + "m_DisplayName": "Y", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "Y", + "m_StageCapability": 3, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [ + "Y" + ] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.PropertyNode", + "m_ObjectId": "c2ce8f28915943d49e5539ae59b0b3bf", + "m_Group": { + "m_Id": "9be24d51d0344c13bc6aef014a27580b" + }, + "m_Name": "Property", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -1547.9998779296875, + "y": 490.0001525878906, + "width": 139.0, + "height": 34.0 + } + }, + "m_Slots": [ + { + "m_Id": "1a6dccb88a494fbebd6d32ab0323405b" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_Property": { + "m_Id": "3345a7b9279a48b7ba4602df55d812ac" + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.OneMinusNode", + "m_ObjectId": "c32c318d23154d279902e9aa65cb5ca1", + "m_Group": { + "m_Id": "9be24d51d0344c13bc6aef014a27580b" + }, + "m_Name": "One Minus", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -448.0000305175781, + "y": 479.99993896484377, + "width": 128.0, + "height": 94.0 + } + }, + "m_Slots": [ + { + "m_Id": "e0b9083ebb1149538c26d099d788f078" + }, + { + "m_Id": "043a14f8d2584d1d832ae0dbea54093d" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.SubtractNode", + "m_ObjectId": "c422a5e7e9fa45de8b8127772c192150", + "m_Group": { + "m_Id": "e2d8030e74824bb48369331f4775f0ac" + }, + "m_Name": "Subtract", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -5280.0, + "y": -253.00003051757813, + "width": 126.0, + "height": 118.0 + } + }, + "m_Slots": [ + { + "m_Id": "3b6726149f5f41b0bbb0c78e613474bf" + }, + { + "m_Id": "de6fe2bfaf0a4adf95d35bbc7132a65c" + }, + { + "m_Id": "2aeea975d6b34a0391f0bea14cbe2821" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "c43f686ac4aa4ea6ba206a9e52ecc3ad", + "m_Id": 0, + "m_DisplayName": "Iris Radius", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.SampleTexture2DNode", + "m_ObjectId": "c48f7c3cdcba457fa8d313e8ac2a2192", + "m_Group": { + "m_Id": "862059ed0bf141dd9404f65a66b53cd8" + }, + "m_Name": "Sample Texture 2D", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": 562.0003051757813, + "y": -877.0000610351563, + "width": 184.0, + "height": 252.99998474121095 + } + }, + "m_Slots": [ + { + "m_Id": "d70ac386610f458c8c0cb3f5994decbd" + }, + { + "m_Id": "b2fd080dc2604adf9233e13419eefd34" + }, + { + "m_Id": "4f3fe4c8a1f344128cfb112679fcf140" + }, + { + "m_Id": "74d5e7aa152145f696521594ef66188c" + }, + { + "m_Id": "5fba5b929e8949f0b44415bac2f4f979" + }, + { + "m_Id": "aa91de3a7a0d4046b57d6043a588a9f1" + }, + { + "m_Id": "3fc77882b22d49258fdd335de5111e96" + }, + { + "m_Id": "d1f01bca2dec495db59c73f25f45f92f" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_TextureType": 0, + "m_NormalMapSpace": 0 +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.NormalMaterialSlot", + "m_ObjectId": "c4b6c46dc8b348b8a5ecd4e2aead24c0", + "m_Id": 0, + "m_DisplayName": "Bent Normal", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "BentNormal", + "m_StageCapability": 2, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0 + }, + "m_Labels": [], + "m_Space": 3 +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.RedirectNodeData", + "m_ObjectId": "c54f3fc163454592aeaf55657e4134a3", + "m_Group": { + "m_Id": "" + }, + "m_Name": "Redirect Node", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -1745.0001220703125, + "y": 1289.0001220703125, + "width": 56.0, + "height": 23.999998092651368 + } + }, + "m_Slots": [ + { + "m_Id": "fefb0524ed434583b04165689bd1c207" + }, + { + "m_Id": "858394ee88624b5f9553e36483a98aa2" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "c58f2ff8e21c49bba9f1dd24f1914bfc", + "m_Id": 0, + "m_DisplayName": "A", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "A", + "m_StageCapability": 3, + "m_Value": { + "x": 1.0, + "y": 1.0, + "z": 1.0, + "w": 1.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.PropertyNode", + "m_ObjectId": "c5ba3386d18b4c529ce7364f6151a623", + "m_Group": { + "m_Id": "ac1d8910df764e109e212887850df3ab" + }, + "m_Name": "Property", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -7021.00048828125, + "y": -554.9999389648438, + "width": 123.00000762939453, + "height": 34.0 + } + }, + "m_Slots": [ + { + "m_Id": "d6774f691b68404bbc8c64571be57e6e" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_Property": { + "m_Id": "85e5e0cd46aa44fc8e9f720d375bec49" + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector2MaterialSlot", + "m_ObjectId": "c8564bab88154be6977cc712d928c6d2", + "m_Id": 1, + "m_DisplayName": "In Min Max", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "InMinMax", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.10000000149011612 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0 + }, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.TangentMaterialSlot", + "m_ObjectId": "c996e165d42c4929928bc49c5e17d734", + "m_Id": 0, + "m_DisplayName": "Tangent", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "Tangent", + "m_StageCapability": 1, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0 + }, + "m_Labels": [], + "m_Space": 0 +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "ca0ba5c25dfb4d7f845661ab3e8ee317", + "m_Id": 1, + "m_DisplayName": "On", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "On", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Internal.Texture2DShaderProperty", + "m_ObjectId": "cb42572a46a74a588ef3935f3a667eb7", + "m_Guid": { + "m_GuidSerialized": "36af1c96-8f78-4132-a591-a5b10a01324f" + }, + "m_Name": "Sclera Diffuse Map", + "m_DefaultReferenceName": "Texture2D_cb42572a46a74a588ef3935f3a667eb7", + "m_OverrideReferenceName": "_ScleraDiffuseMap", + "m_GeneratePropertyBlock": true, + "m_Precision": 0, + "overrideHLSLDeclaration": false, + "hlslDeclarationOverride": 0, + "m_Hidden": false, + "m_Value": { + "m_SerializedTexture": "{\"texture\":{\"instanceID\":0}}", + "m_Guid": "" + }, + "m_Modifiable": true, + "m_DefaultType": 0 +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "cb6e8072ceb24ce4ac0cb7dce5ad194b", + "m_Id": 0, + "m_DisplayName": "Sclera Scale", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.PositionMaterialSlot", + "m_ObjectId": "cb901263bb9a42489ac84d9e84023477", + "m_Id": 0, + "m_DisplayName": "Position", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "Position", + "m_StageCapability": 1, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0 + }, + "m_Labels": [], + "m_Space": 0 +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector2MaterialSlot", + "m_ObjectId": "cbb094df15814f8a9fe1e10bbb4bd6f7", + "m_Id": 3, + "m_DisplayName": "Out", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0 + }, + "m_Labels": [] +} + +{ + "m_SGVersion": 3, + "m_Type": "UnityEditor.ShaderGraph.Internal.ColorShaderProperty", + "m_ObjectId": "cbcbb78812d84a3ea2eab90a08ba2f3b", + "m_Guid": { + "m_GuidSerialized": "106b70aa-16d9-4889-890d-7244a695a9dc" + }, + "m_Name": "Limbus Color", + "m_DefaultReferenceName": "", + "m_OverrideReferenceName": "_LimbusColor", + "m_GeneratePropertyBlock": true, + "m_Precision": 0, + "overrideHLSLDeclaration": false, + "hlslDeclarationOverride": 0, + "m_Hidden": false, + "m_Value": { + "r": 0.0, + "g": 0.0, + "b": 0.0, + "a": 0.0 + }, + "m_ColorMode": 0 +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "ccb350f68b9d429395bfc64eb0ae9a5f", + "m_Id": 2, + "m_DisplayName": "Off", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "Off", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 1.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 1, + "m_Type": "UnityEditor.ShaderGraph.Internal.Vector1ShaderProperty", + "m_ObjectId": "cd32d6c896b4474aa36ec555723b81ef", + "m_Guid": { + "m_GuidSerialized": "5a26b99b-14f5-430c-883e-4d012db00a41" + }, + "m_Name": "Sclera Normal Tiling", + "m_DefaultReferenceName": "Vector1_cd32d6c896b4474aa36ec555723b81ef", + "m_OverrideReferenceName": "_ScleraNormalTiling", + "m_GeneratePropertyBlock": true, + "m_Precision": 0, + "overrideHLSLDeclaration": false, + "hlslDeclarationOverride": 0, + "m_Hidden": false, + "m_Value": 2.0, + "m_FloatType": 1, + "m_RangeValues": { + "x": 1.0, + "y": 10.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "ce15578385444ba8846416a053838b72", + "m_Id": 1, + "m_DisplayName": "On", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "On", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.KeywordNode", + "m_ObjectId": "ce633f36651f4879adaa91879638782a", + "m_Group": { + "m_Id": "77f65f494a034b2a9cf1395ba40d3843" + }, + "m_Name": "IsCornea", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -25.99995231628418, + "y": 95.99989318847656, + "width": 163.0, + "height": 118.0 + } + }, + "m_Slots": [ + { + "m_Id": "84fc79c7cb9344158930cd2f920a16cb" + }, + { + "m_Id": "fd7dfa035e9f4315add2305816736959" + }, + { + "m_Id": "4d4936585ecf42d39881f4232a063496" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_Keyword": { + "m_Id": "9d63910b86f7439f9642f08926860a8e" + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicValueMaterialSlot", + "m_ObjectId": "cf50ef7e2db946c2bf7f3f526797f24f", + "m_Id": 1, + "m_DisplayName": "B", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "B", + "m_StageCapability": 3, + "m_Value": { + "e00": 2.0, + "e01": 2.0, + "e02": 2.0, + "e03": 2.0, + "e10": 2.0, + "e11": 2.0, + "e12": 2.0, + "e13": 2.0, + "e20": 2.0, + "e21": 2.0, + "e22": 2.0, + "e23": 2.0, + "e30": 2.0, + "e31": 2.0, + "e32": 2.0, + "e33": 2.0 + }, + "m_DefaultValue": { + "e00": 1.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 1.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 1.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "cfccabb8ddef4f3baf378b07fa236189", + "m_Id": 1, + "m_DisplayName": "Blend", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "Blend", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicValueMaterialSlot", + "m_ObjectId": "cfcd38de19244c0884e93dbfc528a7ff", + "m_Id": 2, + "m_DisplayName": "Out", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": { + "e00": 0.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 0.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 0.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 0.0 + }, + "m_DefaultValue": { + "e00": 1.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 1.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 1.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "d03529e496f14651aa4279692c918977", + "m_Id": 1, + "m_DisplayName": "Out", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "d077352241884e4ea3c0b36be4df897c", + "m_Id": 1, + "m_DisplayName": "X", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "X", + "m_StageCapability": 3, + "m_Value": 0.5, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.UVNode", + "m_ObjectId": "d10fb006fee641a2b5ac0071048cdade", + "m_Group": { + "m_Id": "8797d77264e74bd38b2c09f136026a6b" + }, + "m_Name": "UV", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -1937.99951171875, + "y": -4003.0, + "width": 145.0, + "height": 130.0 + } + }, + "m_Slots": [ + { + "m_Id": "ddbdf39cf2d7478ba14d6d9bee083a5b" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_OutputChannel": 0 +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.SamplerStateMaterialSlot", + "m_ObjectId": "d1f01bca2dec495db59c73f25f45f92f", + "m_Id": 3, + "m_DisplayName": "Sampler", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "Sampler", + "m_StageCapability": 3, + "m_BareResource": false +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicValueMaterialSlot", + "m_ObjectId": "d21bc6827f54443b8394d13d6ffe892f", + "m_Id": 1, + "m_DisplayName": "B", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "B", + "m_StageCapability": 3, + "m_Value": { + "e00": 360.0, + "e01": 2.0, + "e02": 2.0, + "e03": 2.0, + "e10": 2.0, + "e11": 2.0, + "e12": 2.0, + "e13": 2.0, + "e20": 2.0, + "e21": 2.0, + "e22": 2.0, + "e23": 2.0, + "e30": 2.0, + "e31": 2.0, + "e32": 2.0, + "e33": 2.0 + }, + "m_DefaultValue": { + "e00": 1.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 1.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 1.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "d28cb622c4904e2d8373c94ba88a38dd", + "m_Id": 1, + "m_DisplayName": "Saturation", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "Saturation", + "m_StageCapability": 3, + "m_Value": 1.0, + "m_DefaultValue": 1.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "d3050bb948f34c6c9c1458f64c3e6b9f", + "m_Id": 2, + "m_DisplayName": "Off", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "Off", + "m_StageCapability": 3, + "m_Value": { + "x": 1.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "d37dfdae103d4efab5974c0cbbf809f3", + "m_Id": 1, + "m_DisplayName": "Out", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "d3801702336d4543b434c7f7134efdb0", + "m_Id": 0, + "m_DisplayName": "Sclera Saturation", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.RedirectNodeData", + "m_ObjectId": "d3cd1375c69343009337fb6036edb8cb", + "m_Group": { + "m_Id": "74c1d47e70e6422881a0e0f051febbb9" + }, + "m_Name": "Redirect Node", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -3628.0, + "y": -1732.0, + "width": 56.0, + "height": 24.0 + } + }, + "m_Slots": [ + { + "m_Id": "4352269c252a44fab28c58e0f79731b8" + }, + { + "m_Id": "3d37ddc8f42f42f59c61f8fa5fa31616" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "d45b8fd243e84bc3b05cfc78d34e3fdd", + "m_Id": 1, + "m_DisplayName": "Out", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.PropertyNode", + "m_ObjectId": "d4adb9f4c12448c78e98d14fb2000ab7", + "m_Group": { + "m_Id": "47b971716ee4470f865fc5c885abcf66" + }, + "m_Name": "Property", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -3472.0, + "y": -2843.0, + "width": 139.0, + "height": 34.0 + } + }, + "m_Slots": [ + { + "m_Id": "cb6e8072ceb24ce4ac0cb7dce5ad194b" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_Property": { + "m_Id": "55bf621ad2394320a2ab49a3c7b34fe1" + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "d4d186059ec04179a1b26be0a8f41b44", + "m_Id": 0, + "m_DisplayName": "In", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "In", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "d582cbfa200549ef87ec256a60e5804a", + "m_Id": 1, + "m_DisplayName": "X", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "X", + "m_StageCapability": 3, + "m_Value": 0.5, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "d6774f691b68404bbc8c64571be57e6e", + "m_Id": 0, + "m_DisplayName": "Iris Scale", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector4MaterialSlot", + "m_ObjectId": "d70ac386610f458c8c0cb3f5994decbd", + "m_Id": 0, + "m_DisplayName": "RGBA", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "RGBA", + "m_StageCapability": 2, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "d82a4147c9244e349a09e0ca8ca00b5e", + "m_Id": 1, + "m_DisplayName": "On", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "On", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.MultiplyNode", + "m_ObjectId": "d86bbba2a7f544ccb8b0f954a6fd1a83", + "m_Group": { + "m_Id": "47b971716ee4470f865fc5c885abcf66" + }, + "m_Name": "Multiply", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -1470.0001220703125, + "y": -2705.999755859375, + "width": 130.0, + "height": 118.0 + } + }, + "m_Slots": [ + { + "m_Id": "aa95b263f0cf4341aaf3354154ebaec6" + }, + { + "m_Id": "fdb4573911454ab7ba8c5e98f2a6a901" + }, + { + "m_Id": "15170d0132fd48dba2b418c404c7ccb0" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicValueMaterialSlot", + "m_ObjectId": "d86e0c1f9a3945cb871e93a92f9478fb", + "m_Id": 1, + "m_DisplayName": "B", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "B", + "m_StageCapability": 3, + "m_Value": { + "e00": 2.0, + "e01": 2.0, + "e02": 2.0, + "e03": 2.0, + "e10": 2.0, + "e11": 2.0, + "e12": 2.0, + "e13": 2.0, + "e20": 2.0, + "e21": 2.0, + "e22": 2.0, + "e23": 2.0, + "e30": 2.0, + "e31": 2.0, + "e32": 2.0, + "e33": 2.0 + }, + "m_DefaultValue": { + "e00": 1.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 1.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 1.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "d8ee3c89930d492b9319833d4889a7ea", + "m_Id": 1, + "m_DisplayName": "", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "d9be8f35b6704ecd81573ad62cda5351", + "m_Id": 1, + "m_DisplayName": "", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "d9d673cccaa54a629af5595f7f13e94a", + "m_Id": 0, + "m_DisplayName": "Shadow Radius", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "d9eb1465e8f14de4a6a52532ce9cc78e", + "m_Id": 1, + "m_DisplayName": "B", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "B", + "m_StageCapability": 3, + "m_Value": { + "x": 1.0, + "y": 1.0, + "z": 1.0, + "w": 1.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "da09529fd2fa407e8b34349dc240337e", + "m_Id": 2, + "m_DisplayName": "T", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "T", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 1, + "m_Type": "UnityEditor.ShaderGraph.Internal.Vector1ShaderProperty", + "m_ObjectId": "daa99c4f268449b8a4e69fdaeafcfe49", + "m_Guid": { + "m_GuidSerialized": "b78117bf-f0d9-48f7-8c0e-59b04f502b60" + }, + "m_Name": "Ambient Occlusion Strength", + "m_DefaultReferenceName": "Vector1_daa99c4f268449b8a4e69fdaeafcfe49", + "m_OverrideReferenceName": "_AOStrength", + "m_GeneratePropertyBlock": true, + "m_Precision": 0, + "overrideHLSLDeclaration": false, + "hlslDeclarationOverride": 0, + "m_Hidden": false, + "m_Value": 0.20000000298023225, + "m_FloatType": 1, + "m_RangeValues": { + "x": 0.0, + "y": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "db1536b3565145a5ad2cc1af0c4a7af8", + "m_Id": 2, + "m_DisplayName": "Out", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.PropertyNode", + "m_ObjectId": "db2bfc69c41f47cea634ef69f9ad207e", + "m_Group": { + "m_Id": "4a0e19aa85024f47a32faf9b1d3f2868" + }, + "m_Name": "Property", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -1352.000244140625, + "y": 1219.0001220703125, + "width": 197.0, + "height": 34.0 + } + }, + "m_Slots": [ + { + "m_Id": "5f7b447e6b5d4420b6a095697ad9b8b4" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_Property": { + "m_Id": "9be1515fae6d42c09957951f4f4fd357" + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DivideNode", + "m_ObjectId": "dbdf7da04f214f16ba536399a7105ad8", + "m_Group": { + "m_Id": "47b971716ee4470f865fc5c885abcf66" + }, + "m_Name": "Divide", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -3296.0, + "y": -2944.0, + "width": 126.0, + "height": 117.99999237060547 + } + }, + "m_Slots": [ + { + "m_Id": "0dc836f256a647d4a2a3e9289272310e" + }, + { + "m_Id": "f7ef5e98f7cc442fa9f1bf5c0155cced" + }, + { + "m_Id": "ac2a34b9eaf94336a5819a4c89e02a2c" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "dcd0f818c5ac4124a8f81c2e0d64e484", + "m_Id": 3, + "m_DisplayName": "Out", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector2MaterialSlot", + "m_ObjectId": "dd3f96ef52694c30b2688a39d1c06025", + "m_Id": 2, + "m_DisplayName": "Offset", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "Offset", + "m_StageCapability": 3, + "m_Value": { + "x": -0.5, + "y": -0.5 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0 + }, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector4MaterialSlot", + "m_ObjectId": "ddbdf39cf2d7478ba14d6d9bee083a5b", + "m_Id": 0, + "m_DisplayName": "Out", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "de6fe2bfaf0a4adf95d35bbc7132a65c", + "m_Id": 1, + "m_DisplayName": "B", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "B", + "m_StageCapability": 3, + "m_Value": { + "x": 1.0, + "y": 1.0, + "z": 1.0, + "w": 1.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.PropertyNode", + "m_ObjectId": "dedf1c4c6ae84cb4b2905241cd8853c6", + "m_Group": { + "m_Id": "4a0e19aa85024f47a32faf9b1d3f2868" + }, + "m_Name": "Property", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -1267.9998779296875, + "y": 908.9998779296875, + "width": 184.0, + "height": 34.0 + } + }, + "m_Slots": [ + { + "m_Id": "91003272cd724136acd73ab4f3955049" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_Property": { + "m_Id": "8a49d2f872e946d4a29e2030ee291584" + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.Rendering.HighDefinition.ShaderGraph.HDLitData", + "m_ObjectId": "df0ba3ae175741e3a29aeabdd7f3f88d", + "m_RayTracing": false, + "m_MaterialType": 0, + "m_RefractionModel": 1, + "m_SSSTransmission": true, + "m_EnergyConservingSpecular": true, + "m_ClearCoat": false +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "df12d0f26f5a4d81a55e3f1873258b8b", + "m_Id": 1, + "m_DisplayName": "Saturation", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "Saturation", + "m_StageCapability": 3, + "m_Value": 1.0, + "m_DefaultValue": 1.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "df223b2eb4414442838bccf1e46f2d17", + "m_Id": 0, + "m_DisplayName": "Iris Scale", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicValueMaterialSlot", + "m_ObjectId": "dfda96da820644e885551676c785ce72", + "m_Id": 2, + "m_DisplayName": "Out", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": { + "e00": 0.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 0.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 0.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 0.0 + }, + "m_DefaultValue": { + "e00": 1.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 1.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 1.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "e0295ddbefb94b799ce4616eeb0f4dd6", + "m_Id": 0, + "m_DisplayName": "Edge1", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "Edge1", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector2Node", + "m_ObjectId": "e0303ad684554dceae658e66a502696f", + "m_Group": { + "m_Id": "fa7b0f3ba7d84ba7a4d19d87b7a3c4b8" + }, + "m_Name": "Vector 2", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -5032.0, + "y": -1378.0001220703125, + "width": 128.0, + "height": 101.0 + } + }, + "m_Slots": [ + { + "m_Id": "9063dddf00454b7c8d9b1cc9d82d56e3" + }, + { + "m_Id": "fdc15f8b7b5044f989866ffe8a1954b2" + }, + { + "m_Id": "6d13f68ae9544ad6b19be8a313811709" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_Value": { + "x": 0.0, + "y": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "e0b9083ebb1149538c26d099d788f078", + "m_Id": 0, + "m_DisplayName": "In", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "In", + "m_StageCapability": 3, + "m_Value": { + "x": 1.0, + "y": 1.0, + "z": 1.0, + "w": 1.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicValueMaterialSlot", + "m_ObjectId": "e1d0ea24b65d4c8e9a48fa545c45fe0b", + "m_Id": 0, + "m_DisplayName": "A", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "A", + "m_StageCapability": 3, + "m_Value": { + "e00": 0.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 0.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 0.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 0.0 + }, + "m_DefaultValue": { + "e00": 1.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 1.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 1.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.BlockNode", + "m_ObjectId": "e1e6ea93dab24d4086de0ce0507e9306", + "m_Group": { + "m_Id": "" + }, + "m_Name": "SurfaceDescription.Alpha", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": 1188.0, + "y": 405.0, + "width": 200.0, + "height": 41.0 + } + }, + "m_Slots": [ + { + "m_Id": "424b313138944a21bc404c418bcb085e" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_SerializedDescriptor": "SurfaceDescription.Alpha" +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.PropertyNode", + "m_ObjectId": "e1f2bbba627a43ed95cdac40efa322fd", + "m_Group": { + "m_Id": "e2d8030e74824bb48369331f4775f0ac" + }, + "m_Name": "Property", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -5774.0, + "y": -145.00003051757813, + "width": 122.99999237060547, + "height": 34.0 + } + }, + "m_Slots": [ + { + "m_Id": "e4edb7acaa0047a8a29d97f1a581a5b1" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_Property": { + "m_Id": "85e5e0cd46aa44fc8e9f720d375bec49" + } +} + +{ + "m_SGVersion": 1, + "m_Type": "UnityEditor.ShaderGraph.Internal.Vector1ShaderProperty", + "m_ObjectId": "e2d236b8f7c740b1920bd65df0cef00f", + "m_Guid": { + "m_GuidSerialized": "dbde8c57-8676-4367-91e9-21b08eba46a7" + }, + "m_Name": "Iris Saturation", + "m_DefaultReferenceName": "", + "m_OverrideReferenceName": "_IrisSaturation", + "m_GeneratePropertyBlock": true, + "m_Precision": 0, + "overrideHLSLDeclaration": false, + "hlslDeclarationOverride": 0, + "m_Hidden": false, + "m_Value": 1.0, + "m_FloatType": 1, + "m_RangeValues": { + "x": 0.0, + "y": 2.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.GroupData", + "m_ObjectId": "e2d8030e74824bb48369331f4775f0ac", + "m_Title": "Iris Mask", + "m_Position": { + "x": -6263.0, + "y": -420.000244140625 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "e315690100b446f48267f5562c1e8883", + "m_Id": 3, + "m_DisplayName": "Out", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "e38caaff8b6e4d0ebdf033799dc52974", + "m_Id": 1, + "m_DisplayName": "Out", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.SamplerStateMaterialSlot", + "m_ObjectId": "e434602e31c7473890452c7faeebe5f3", + "m_Id": 3, + "m_DisplayName": "Sampler", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "Sampler", + "m_StageCapability": 3, + "m_BareResource": false +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "e4852e9f556e4f6b8dbc7da69bda5d89", + "m_Id": 1, + "m_DisplayName": "Out", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.RedirectNodeData", + "m_ObjectId": "e4db4ba36bfa46638285444a51991c58", + "m_Group": { + "m_Id": "e2d8030e74824bb48369331f4775f0ac" + }, + "m_Name": "Redirect Node", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -6238.0, + "y": -299.0000305175781, + "width": 56.0, + "height": 23.999998092651368 + } + }, + "m_Slots": [ + { + "m_Id": "5bde4ddb9736488d9e22f857e3009e29" + }, + { + "m_Id": "93a342717d3045b5a8a3d949c6a802fc" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "e4edb7acaa0047a8a29d97f1a581a5b1", + "m_Id": 0, + "m_DisplayName": "Iris Scale", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "e4fe32e8c70c42b79919d7d7fa484332", + "m_Id": 0, + "m_DisplayName": "In", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "In", + "m_StageCapability": 3, + "m_Value": { + "x": 1.0, + "y": 1.0, + "z": 1.0, + "w": 1.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "e5b5667fe2b844a9bc3d760d4fd55b31", + "m_Id": 0, + "m_DisplayName": "Sclera Smoothness", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "e6412f2413614b22be377c9703f53e5e", + "m_Id": 2, + "m_DisplayName": "Out", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.BlockNode", + "m_ObjectId": "e701720035d44304a33f4b64350fc6e3", + "m_Group": { + "m_Id": "" + }, + "m_Name": "SurfaceDescription.Emission", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": 0.0, + "y": 0.0, + "width": 0.0, + "height": 0.0 + } + }, + "m_Slots": [ + { + "m_Id": "4fbf6229bad74e91afb7ff4f2a7f0018" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_SerializedDescriptor": "SurfaceDescription.Emission" +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.UVMaterialSlot", + "m_ObjectId": "e878d0ee617a430ea8991a6f147f451b", + "m_Id": 2, + "m_DisplayName": "UV", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "UV", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0 + }, + "m_Labels": [], + "m_Channel": 0 +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "e8eee264259841dfa019499d140ad93b", + "m_Id": 2, + "m_DisplayName": "Y", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "Y", + "m_StageCapability": 3, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [ + "Y" + ] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "ea01102eb2eb476e84ae2b95ef095d12", + "m_Id": 2, + "m_DisplayName": "In", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "In", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector4MaterialSlot", + "m_ObjectId": "eac303e75ce34945982b8f75387918dd", + "m_Id": 0, + "m_DisplayName": "Limbus Color", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicValueMaterialSlot", + "m_ObjectId": "eba76b95d2f24b7ea8461e9724a32b43", + "m_Id": 0, + "m_DisplayName": "A", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "A", + "m_StageCapability": 3, + "m_Value": { + "e00": 0.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 0.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 0.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 0.0 + }, + "m_DefaultValue": { + "e00": 1.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 1.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 1.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector2MaterialSlot", + "m_ObjectId": "ebeb3767ef7d416ba24708085bd39a01", + "m_Id": 3, + "m_DisplayName": "Out", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0 + }, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "ec23a22af2da495ea133a205a4fe0887", + "m_Id": 1, + "m_DisplayName": "B", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "B", + "m_StageCapability": 3, + "m_Value": { + "x": 1.0, + "y": 1.0, + "z": 1.0, + "w": 1.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "eccc70d10a654ecca8ee83017f5a7f3c", + "m_Id": 2, + "m_DisplayName": "Off", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "Off", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 1, + "m_Type": "UnityEditor.ShaderGraph.Internal.Vector1ShaderProperty", + "m_ObjectId": "ed1d6ae0d0e14a009081ff66d328aa52", + "m_Guid": { + "m_GuidSerialized": "fe2a54fe-e53e-4e1c-b122-fecc79b1a9c6" + }, + "m_Name": "Shadow Hardness", + "m_DefaultReferenceName": "Vector1_ed1d6ae0d0e14a009081ff66d328aa52", + "m_OverrideReferenceName": "_ShadowHardness", + "m_GeneratePropertyBlock": true, + "m_Precision": 0, + "overrideHLSLDeclaration": false, + "hlslDeclarationOverride": 0, + "m_Hidden": false, + "m_Value": 0.5, + "m_FloatType": 1, + "m_RangeValues": { + "x": 0.009999999776482582, + "y": 0.9900000095367432 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.RedirectNodeData", + "m_ObjectId": "ed23a5794fd04f4da4f8dc952d7bc921", + "m_Group": { + "m_Id": "4e7801ae7f8b4090be5d458121207cec" + }, + "m_Name": "Redirect Node", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -1742.9998779296875, + "y": -886.000244140625, + "width": 56.0, + "height": 24.0 + } + }, + "m_Slots": [ + { + "m_Id": "20f4ac75903d4ff5b93ae1dbda55208f" + }, + { + "m_Id": "6a04b4b8c9f44c39b9149aa0ee3d0775" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Texture2DInputMaterialSlot", + "m_ObjectId": "ed9c59938c234fa394e71efcbec4d5c6", + "m_Id": 1, + "m_DisplayName": "Texture", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "Texture", + "m_StageCapability": 3, + "m_BareResource": false, + "m_Texture": { + "m_SerializedTexture": "{\"texture\":{\"instanceID\":0}}", + "m_Guid": "" + }, + "m_DefaultType": 3 +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "ef190842659c4e7f89f23feb471ca3e4", + "m_Id": 1, + "m_DisplayName": "B", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "B", + "m_StageCapability": 3, + "m_Value": { + "x": 1.0, + "y": 1.0, + "z": 1.0, + "w": 1.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.BlendNode", + "m_ObjectId": "ef9a9ad73fb74bd087b55b476ba61119", + "m_Group": { + "m_Id": "862059ed0bf141dd9404f65a66b53cd8" + }, + "m_Name": "Blend", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": 844.0000610351563, + "y": -1018.0000610351563, + "width": 208.0, + "height": 362.0 + } + }, + "m_Slots": [ + { + "m_Id": "a450f19a9c7345688ec499271818654e" + }, + { + "m_Id": "9ee3e1ad7c7e41229c48dda8fccc9d84" + }, + { + "m_Id": "b1adb0a0c54546a9903689c280e2583b" + }, + { + "m_Id": "69bffe78d536404bad016260e8b60d58" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_BlendMode": 13 +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "f1064b0ae2c44fabb1423408fca67ecd", + "m_Id": 2, + "m_DisplayName": "Y", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "Y", + "m_StageCapability": 3, + "m_Value": 0.5, + "m_DefaultValue": 0.0, + "m_Labels": [ + "Y" + ] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicValueMaterialSlot", + "m_ObjectId": "f1c8d35381fc40158eddade6c98f2385", + "m_Id": 2, + "m_DisplayName": "Out", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": { + "e00": 0.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 0.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 0.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 0.0 + }, + "m_DefaultValue": { + "e00": 1.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 1.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 1.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "f2ab5067b82746dbbb965aecf46591b0", + "m_Id": 1, + "m_DisplayName": "", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector4MaterialSlot", + "m_ObjectId": "f2cd52962a934444a0cb5e555d009001", + "m_Id": 0, + "m_DisplayName": "RGBA", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "RGBA", + "m_StageCapability": 2, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "f4043b2118f342699d2327c2adcc8f9e", + "m_Id": 0, + "m_DisplayName": "Refraction Index", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "RefractionIndex", + "m_StageCapability": 2, + "m_Value": 1.399999976158142, + "m_DefaultValue": 1.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector3MaterialSlot", + "m_ObjectId": "f4ffe23f117a416ab21227a4927042d6", + "m_Id": 0, + "m_DisplayName": "Out", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0 + }, + "m_Labels": [] +} + +{ + "m_SGVersion": 1, + "m_Type": "UnityEditor.ShaderGraph.Internal.Vector1ShaderProperty", + "m_ObjectId": "f529da1a611a46cda7c335f575a5999b", + "m_Guid": { + "m_GuidSerialized": "8aac5897-d30d-4c67-bfa4-a29e1cfe6bac" + }, + "m_Name": "Refraction Thickness", + "m_DefaultReferenceName": "Vector1_f529da1a611a46cda7c335f575a5999b", + "m_OverrideReferenceName": "_RefractionThickness", + "m_GeneratePropertyBlock": true, + "m_Precision": 0, + "overrideHLSLDeclaration": false, + "hlslDeclarationOverride": 0, + "m_Hidden": false, + "m_Value": 0.009999999776482582, + "m_FloatType": 1, + "m_RangeValues": { + "x": 0.0, + "y": 0.02500000037252903 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector4MaterialSlot", + "m_ObjectId": "f647b0c6be8042e996570315ae2f07a2", + "m_Id": 0, + "m_DisplayName": "RGBA", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "RGBA", + "m_StageCapability": 2, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.KeywordNode", + "m_ObjectId": "f7a1640f8cf941cca6d8024317680230", + "m_Group": { + "m_Id": "77f65f494a034b2a9cf1395ba40d3843" + }, + "m_Name": "IsCornea", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -29.999773025512697, + "y": -1683.0, + "width": 208.0, + "height": 302.0 + } + }, + "m_Slots": [ + { + "m_Id": "082b9d3ca32646dda65c8939d76f75b6" + }, + { + "m_Id": "ca0ba5c25dfb4d7f845661ab3e8ee317" + }, + { + "m_Id": "fba15d4308bc48feaea53397531ca824" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_Keyword": { + "m_Id": "9d63910b86f7439f9642f08926860a8e" + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "f7ef5e98f7cc442fa9f1bf5c0155cced", + "m_Id": 1, + "m_DisplayName": "B", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "B", + "m_StageCapability": 3, + "m_Value": { + "x": 2.0, + "y": 2.0, + "z": 2.0, + "w": 2.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicValueMaterialSlot", + "m_ObjectId": "f7fa5689a92f4268ae519412e2edfc2d", + "m_Id": 0, + "m_DisplayName": "A", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "A", + "m_StageCapability": 3, + "m_Value": { + "e00": 0.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 0.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 0.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 0.0 + }, + "m_DefaultValue": { + "e00": 1.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 1.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 1.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector2MaterialSlot", + "m_ObjectId": "f846dbf7c3344ec3912b7e42211aa123", + "m_Id": 0, + "m_DisplayName": "Out", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0 + }, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "f85cbec02ced4f41bdff94e6aef90240", + "m_Id": 0, + "m_DisplayName": "", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "f872667b17f0412db6b76772fe301fa5", + "m_Id": 0, + "m_DisplayName": "Sclera Normal Tiling", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "f91e66ff4138405a8f08e2819edc9647", + "m_Id": 0, + "m_DisplayName": "", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.MultiplyNode", + "m_ObjectId": "f9e4ca9ef51f47f181f9674bfca66bc4", + "m_Group": { + "m_Id": "4a0e19aa85024f47a32faf9b1d3f2868" + }, + "m_Name": "Multiply", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -1070.0001220703125, + "y": 1219.0001220703125, + "width": 126.0, + "height": 118.0 + } + }, + "m_Slots": [ + { + "m_Id": "36da7aa1936b4139bf77b6393a2e73b8" + }, + { + "m_Id": "cf50ef7e2db946c2bf7f3f526797f24f" + }, + { + "m_Id": "147ad926e7fc4d2f9c2b449f7d6d0823" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.GroupData", + "m_ObjectId": "fa7b0f3ba7d84ba7a4d19d87b7a3c4b8", + "m_Title": "Iris Depth Mask", + "m_Position": { + "x": -5467.0, + "y": -1463.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.MultiplyNode", + "m_ObjectId": "fafe5ccffa2d4ec4ba5e9ba37d28b945", + "m_Group": { + "m_Id": "e2d8030e74824bb48369331f4775f0ac" + }, + "m_Name": "Multiply", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -5595.0, + "y": -228.9999237060547, + "width": 126.0, + "height": 118.0 + } + }, + "m_Slots": [ + { + "m_Id": "95db3152a1514a9d93e495d197f3666b" + }, + { + "m_Id": "d86e0c1f9a3945cb871e93a92f9478fb" + }, + { + "m_Id": "9b4847f7397d4127823ef8811603c40b" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "fba15d4308bc48feaea53397531ca824", + "m_Id": 2, + "m_DisplayName": "Off", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "Off", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.PropertyNode", + "m_ObjectId": "fc728e1ada644514b5e3d38d1a9b24c1", + "m_Group": { + "m_Id": "" + }, + "m_Name": "Property", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -1246.0, + "y": -1274.9998779296875, + "width": 147.99998474121095, + "height": 33.999996185302737 + } + }, + "m_Slots": [ + { + "m_Id": "eac303e75ce34945982b8f75387918dd" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_Property": { + "m_Id": "cbcbb78812d84a3ea2eab90a08ba2f3b" + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector2Node", + "m_ObjectId": "fce255c0160645c69de31bb99b688b0d", + "m_Group": { + "m_Id": "47b971716ee4470f865fc5c885abcf66" + }, + "m_Name": "Vector 2", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -3116.999755859375, + "y": -2717.0, + "width": 127.99999237060547, + "height": 101.0 + } + }, + "m_Slots": [ + { + "m_Id": "d077352241884e4ea3c0b36be4df897c" + }, + { + "m_Id": "f1064b0ae2c44fabb1423408fca67ecd" + }, + { + "m_Id": "695889ce196d44858dd74c2389f59705" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_Value": { + "x": 0.0, + "y": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "fd7dfa035e9f4315add2305816736959", + "m_Id": 1, + "m_DisplayName": "On", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "On", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "fda96693aa6340009499290ed5c289c5", + "m_Id": 0, + "m_DisplayName": "IsCornea", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicValueMaterialSlot", + "m_ObjectId": "fdb4573911454ab7ba8c5e98f2a6a901", + "m_Id": 1, + "m_DisplayName": "B", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "B", + "m_StageCapability": 3, + "m_Value": { + "e00": 2.0, + "e01": 2.0, + "e02": 2.0, + "e03": 2.0, + "e10": 2.0, + "e11": 2.0, + "e12": 2.0, + "e13": 2.0, + "e20": 2.0, + "e21": 2.0, + "e22": 2.0, + "e23": 2.0, + "e30": 2.0, + "e31": 2.0, + "e32": 2.0, + "e33": 2.0 + }, + "m_DefaultValue": { + "e00": 1.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 1.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 1.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "fdc15f8b7b5044f989866ffe8a1954b2", + "m_Id": 2, + "m_DisplayName": "Y", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "Y", + "m_StageCapability": 3, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [ + "Y" + ] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "fe7938b10bab4867b7f7537b54298c09", + "m_Id": 0, + "m_DisplayName": "", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "fefb0524ed434583b04165689bd1c207", + "m_Id": 0, + "m_DisplayName": "", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + diff --git a/HDRP/Shaders/RL_EyeShaderVariants_HDRP.shadergraph.meta b/HDRP/Shaders/RL_EyeShaderVariants_HDRP.shadergraph.meta new file mode 100644 index 0000000..0957dc0 --- /dev/null +++ b/HDRP/Shaders/RL_EyeShaderVariants_HDRP.shadergraph.meta @@ -0,0 +1,10 @@ +fileFormatVersion: 2 +guid: 48cccd4fafd06264c9dcce2137ba5738 +ScriptedImporter: + internalIDToNameTable: [] + externalObjects: {} + serializedVersion: 2 + userData: + assetBundleName: + assetBundleVariant: + script: {fileID: 11500000, guid: 625f186215c104763be7675aa2d941aa, type: 3} diff --git a/HDRP/Shaders/RL_HairShaderBaked_HDRP.shadergraph b/HDRP/Shaders/RL_HairShaderBaked_HDRP.shadergraph new file mode 100644 index 0000000..d03a43d --- /dev/null +++ b/HDRP/Shaders/RL_HairShaderBaked_HDRP.shadergraph @@ -0,0 +1,8847 @@ +{ + "m_SGVersion": 2, + "m_Type": "UnityEditor.ShaderGraph.GraphData", + "m_ObjectId": "a316bd3ad5b24db79164c15659fdb4d3", + "m_Properties": [ + { + "m_Id": "62ba90b39c554829b983338182c6db53" + }, + { + "m_Id": "6dc6a8e2ab304a639656ee2082845e1c" + }, + { + "m_Id": "ac27b0d8beef493a80956330658fb3e7" + }, + { + "m_Id": "b304178995574d4b8dceaf0eade7e621" + }, + { + "m_Id": "bc814cd1e05d4e94b3b180cbe5f42bfd" + }, + { + "m_Id": "a8fac80485344a489b31db2a226e0489" + }, + { + "m_Id": "5ef8aef8a81b4183b2aa03d38ada5d75" + }, + { + "m_Id": "d962fe658f9a4982b62bd75d03b2276e" + }, + { + "m_Id": "d5ea19d7fc704761908396f642de59c8" + }, + { + "m_Id": "7a9dca43a15c41859b95c7edb930b3db" + }, + { + "m_Id": "1b66a7533fa643888276c4f6de382ca9" + }, + { + "m_Id": "5d4c697aa2e74bdbb12725c42b2313e7" + }, + { + "m_Id": "1728986d8b5d4a60a610dc8f863ef11d" + }, + { + "m_Id": "7ad41145b0c646049037af434d423fc6" + }, + { + "m_Id": "a73bbe07bf634ae6a2f595dac0d74ea3" + }, + { + "m_Id": "8197dc419ed34d5e8c22c7c35775566a" + }, + { + "m_Id": "629bfa855bb345f5b11dd44954fbddba" + }, + { + "m_Id": "ed8f4e5d62a34a71a82aedc1436a6cae" + }, + { + "m_Id": "ddc2f22573d241e787bf84f06e4ba049" + } + ], + "m_Keywords": [ + { + "m_Id": "a9c42cd3aa674f4b8cd880751469f0f3" + } + ], + "m_Nodes": [ + { + "m_Id": "2704a97326044be09a54d3e3810db15f" + }, + { + "m_Id": "0b7af971d63e4166afd190de3b9e9172" + }, + { + "m_Id": "fe4907798c1644289607e0d2603a9a68" + }, + { + "m_Id": "d0f957ba1d13421b96ab67ec531eefa7" + }, + { + "m_Id": "ca5e280a68af4a45a358d1f7b9cff2e2" + }, + { + "m_Id": "76ac26031b7c43a6a78d7e9db5db64be" + }, + { + "m_Id": "8277bdd1ba5e486788875b590047b626" + }, + { + "m_Id": "687659d5f2844131913f3ebec5692c99" + }, + { + "m_Id": "43b2f53e22494f52ad836aba700da7c7" + }, + { + "m_Id": "358a13893c98426abb6bc4c3984c2dc8" + }, + { + "m_Id": "5f984a05a60b4f76afa0ec01041e1d96" + }, + { + "m_Id": "5bc2e2ebb6e84033be0c02d88425a9d9" + }, + { + "m_Id": "4e86ff273f104b47a35a04b03339a9d7" + }, + { + "m_Id": "f15873d7cae54a328809df9a8d76bbf7" + }, + { + "m_Id": "fe251668acaf4cc1a186f88895925031" + }, + { + "m_Id": "454e8678d7fa4d8583459d67c01c0d1d" + }, + { + "m_Id": "6cf2216245ca4c94a226d2a52deb5633" + }, + { + "m_Id": "af7e3800e2f34908a3a77b8948d2fd32" + }, + { + "m_Id": "91e279bc4ab24de6baf584d64e36b2ae" + }, + { + "m_Id": "fe89101ff92d49e9a630a987e854fb0a" + }, + { + "m_Id": "883fa0154dc245788e90a0983dac686e" + }, + { + "m_Id": "e7adb047317f4e8f97e8758b79640e35" + }, + { + "m_Id": "a61b9632fcd344bbb50f017fe9662523" + }, + { + "m_Id": "bc220c2be8a74249ac65d93a8ae5cbdf" + }, + { + "m_Id": "2b74cde8bed7456b968b7b795a741d50" + }, + { + "m_Id": "4239ae5618e54aada26f71dc47c73c18" + }, + { + "m_Id": "2643e290df8a4963bc3741b72302fe4f" + }, + { + "m_Id": "04aea1edd8694d7f84d7852ec4078ce2" + }, + { + "m_Id": "9fe0bae8095e488fab536e1bbc11bb66" + }, + { + "m_Id": "860c97ed98f348e0942b9e5eb0916c14" + }, + { + "m_Id": "5b7fb36f8a124e63b24b1f4891c7d268" + }, + { + "m_Id": "eba48f1e544d455986b250277b538909" + }, + { + "m_Id": "2b1f8f17f34d4d07bfa9a061a97ed745" + }, + { + "m_Id": "e2bec6c3826047c8a8ca759c60bb19ff" + }, + { + "m_Id": "f769abb9b5a74ec89369a250e2c8d39b" + }, + { + "m_Id": "627b5ab6400f4b94ae60bfcab74b4ab5" + }, + { + "m_Id": "151656766f524322aecfdf73999cda54" + }, + { + "m_Id": "e00fd7cf1bf84eb8af3423a5f84f02da" + }, + { + "m_Id": "ed083dc9dc3c4f5fa9248d1b99d92da4" + }, + { + "m_Id": "b3602abd3e6c4110bd7c0c759e4b9c20" + }, + { + "m_Id": "f0eca0bb90df4ad88ca3cef5c34fc766" + }, + { + "m_Id": "72d4a986e38a498bae8f34613460f37e" + }, + { + "m_Id": "60f1e7e5998d42d5be5bf1c40597f04f" + }, + { + "m_Id": "30fe193f31ba43ba9fef9f94f9cd4c10" + }, + { + "m_Id": "20ec913f194d4acd871be539f0ceffd0" + }, + { + "m_Id": "a95c92619dc0485d83dce69c60ceca6d" + }, + { + "m_Id": "6c82b6ddafb64673b5161a23abfc93e4" + }, + { + "m_Id": "b158210403a647c485660b84c2aaa857" + }, + { + "m_Id": "8fa9e59236e64861945859b2bb07fb53" + }, + { + "m_Id": "601c6eaea0204053a13a8ac70dd09d06" + }, + { + "m_Id": "aa3b6d90bb2d442e989158ba90f12906" + }, + { + "m_Id": "6069340092004c1191a211a8d3274b3d" + }, + { + "m_Id": "debaaee10b654011933a2346630b5137" + }, + { + "m_Id": "9654b153a4f246f899a7ce0aab379a79" + }, + { + "m_Id": "b337e8061fa24e6bb1d267bc90b18e02" + }, + { + "m_Id": "c896751d379b48b793ac05bbc6687f65" + }, + { + "m_Id": "a4abc46300494294b321ea368512e48c" + }, + { + "m_Id": "8a2128b069e046c9992344d5c8d7f5c8" + }, + { + "m_Id": "030f5fb2b7a44537b270b4c404971915" + }, + { + "m_Id": "6b2e66277a7943f5800e4557cd983757" + }, + { + "m_Id": "8dc18247ab4b4e5caf09faf953798497" + }, + { + "m_Id": "6e7f71ec59fb413b942f9ce72cf1967c" + }, + { + "m_Id": "d2920db565474984a8eae456eca16597" + }, + { + "m_Id": "07affa6d03af4e71be5df2863dc3cf00" + }, + { + "m_Id": "106c4319f0c8421a9295b557df9f94a3" + }, + { + "m_Id": "28e145da8a3747de8be1fbeb7dbc5cae" + }, + { + "m_Id": "ac0c1810cc7b43eca36a78a32992055e" + }, + { + "m_Id": "815740e575684a18ae4f7aced285fb16" + }, + { + "m_Id": "d971314bc5f54cdab9c09233077b1881" + }, + { + "m_Id": "c11ee2e3010d48a9a45e803c58cceaa3" + }, + { + "m_Id": "45445a2f270b47348746e62d75ebd6c7" + }, + { + "m_Id": "4be5e95fcd374b61bd561cf5a7bec49a" + }, + { + "m_Id": "1f325b3e26a640949036a22e6af17a00" + }, + { + "m_Id": "7a473df09e9b4bd3b82814666640158f" + }, + { + "m_Id": "366fe14bae29480a8d870a61047f38bf" + }, + { + "m_Id": "bc03bc7dc2ec45c58768cf357d7ef079" + }, + { + "m_Id": "23d0a726bc0d4c95bc67d874b0a46fbf" + }, + { + "m_Id": "1390ac11bb8548bfbe91e6eab457f759" + }, + { + "m_Id": "3230324be61b4cf0a9b15d53e5f48151" + }, + { + "m_Id": "418e89bc480d45bb8dd81a829a1ce810" + }, + { + "m_Id": "ab291a3748ee4efba44081f662392b9c" + }, + { + "m_Id": "bdfe061154bb4a70b4961bf28fdc1ff4" + }, + { + "m_Id": "bc27cfd52e154c9c83ffa6eef20c94f5" + } + ], + "m_GroupDatas": [ + { + "m_Id": "72585dd91b3d4da7b55123bae128c48b" + }, + { + "m_Id": "b773332f12a640f2961cff577b07701f" + }, + { + "m_Id": "be2cb7795a6143a498576442f64713d6" + }, + { + "m_Id": "b3823636393244d99c581f1785baf857" + }, + { + "m_Id": "4754e47d61844a86908699d8a6f31a28" + }, + { + "m_Id": "9cdb7847683948c99034141805213a61" + } + ], + "m_StickyNoteDatas": [ + { + "m_Id": "c3448cd8492948db8adf7a079b6fcd8e" + } + ], + "m_Edges": [ + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "030f5fb2b7a44537b270b4c404971915" + }, + "m_SlotId": 1 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "a61b9632fcd344bbb50f017fe9662523" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "07affa6d03af4e71be5df2863dc3cf00" + }, + "m_SlotId": 1 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "43b2f53e22494f52ad836aba700da7c7" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "106c4319f0c8421a9295b557df9f94a3" + }, + "m_SlotId": 1 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "91e279bc4ab24de6baf584d64e36b2ae" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "1390ac11bb8548bfbe91e6eab457f759" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "3230324be61b4cf0a9b15d53e5f48151" + }, + "m_SlotId": 1 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "151656766f524322aecfdf73999cda54" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "2b74cde8bed7456b968b7b795a741d50" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "1f325b3e26a640949036a22e6af17a00" + }, + "m_SlotId": 2 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "bc220c2be8a74249ac65d93a8ae5cbdf" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "20ec913f194d4acd871be539f0ceffd0" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "30fe193f31ba43ba9fef9f94f9cd4c10" + }, + "m_SlotId": 1 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "23d0a726bc0d4c95bc67d874b0a46fbf" + }, + "m_SlotId": 3 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "8dc18247ab4b4e5caf09faf953798497" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "28e145da8a3747de8be1fbeb7dbc5cae" + }, + "m_SlotId": 1 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "b3602abd3e6c4110bd7c0c759e4b9c20" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "2b1f8f17f34d4d07bfa9a061a97ed745" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "e2bec6c3826047c8a8ca759c60bb19ff" + }, + "m_SlotId": 1 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "30fe193f31ba43ba9fef9f94f9cd4c10" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "106c4319f0c8421a9295b557df9f94a3" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "3230324be61b4cf0a9b15d53e5f48151" + }, + "m_SlotId": 2 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "23d0a726bc0d4c95bc67d874b0a46fbf" + }, + "m_SlotId": 2 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "366fe14bae29480a8d870a61047f38bf" + }, + "m_SlotId": 2 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "4239ae5618e54aada26f71dc47c73c18" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "418e89bc480d45bb8dd81a829a1ce810" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "bdfe061154bb4a70b4961bf28fdc1ff4" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "45445a2f270b47348746e62d75ebd6c7" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "c11ee2e3010d48a9a45e803c58cceaa3" + }, + "m_SlotId": 1 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "454e8678d7fa4d8583459d67c01c0d1d" + }, + "m_SlotId": 5 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "07affa6d03af4e71be5df2863dc3cf00" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "454e8678d7fa4d8583459d67c01c0d1d" + }, + "m_SlotId": 6 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "815740e575684a18ae4f7aced285fb16" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "454e8678d7fa4d8583459d67c01c0d1d" + }, + "m_SlotId": 7 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "d2920db565474984a8eae456eca16597" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "4be5e95fcd374b61bd561cf5a7bec49a" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "1f325b3e26a640949036a22e6af17a00" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "4e86ff273f104b47a35a04b03339a9d7" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "6cf2216245ca4c94a226d2a52deb5633" + }, + "m_SlotId": 1 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "5b7fb36f8a124e63b24b1f4891c7d268" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "b337e8061fa24e6bb1d267bc90b18e02" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "5bc2e2ebb6e84033be0c02d88425a9d9" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "454e8678d7fa4d8583459d67c01c0d1d" + }, + "m_SlotId": 1 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "5f984a05a60b4f76afa0ec01041e1d96" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "fe251668acaf4cc1a186f88895925031" + }, + "m_SlotId": 1 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "601c6eaea0204053a13a8ac70dd09d06" + }, + "m_SlotId": 2 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "30fe193f31ba43ba9fef9f94f9cd4c10" + }, + "m_SlotId": 3 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "6069340092004c1191a211a8d3274b3d" + }, + "m_SlotId": 2 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "9654b153a4f246f899a7ce0aab379a79" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "60f1e7e5998d42d5be5bf1c40597f04f" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "c896751d379b48b793ac05bbc6687f65" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "627b5ab6400f4b94ae60bfcab74b4ab5" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "e7adb047317f4e8f97e8758b79640e35" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "6b2e66277a7943f5800e4557cd983757" + }, + "m_SlotId": 1 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "8277bdd1ba5e486788875b590047b626" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "6c82b6ddafb64673b5161a23abfc93e4" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "a95c92619dc0485d83dce69c60ceca6d" + }, + "m_SlotId": 1 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "6cf2216245ca4c94a226d2a52deb5633" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "d971314bc5f54cdab9c09233077b1881" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "6e7f71ec59fb413b942f9ce72cf1967c" + }, + "m_SlotId": 1 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "358a13893c98426abb6bc4c3984c2dc8" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "72d4a986e38a498bae8f34613460f37e" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "ac0c1810cc7b43eca36a78a32992055e" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "7a473df09e9b4bd3b82814666640158f" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "366fe14bae29480a8d870a61047f38bf" + }, + "m_SlotId": 1 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "815740e575684a18ae4f7aced285fb16" + }, + "m_SlotId": 2 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "1f325b3e26a640949036a22e6af17a00" + }, + "m_SlotId": 1 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "815740e575684a18ae4f7aced285fb16" + }, + "m_SlotId": 2 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "366fe14bae29480a8d870a61047f38bf" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "860c97ed98f348e0942b9e5eb0916c14" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "9fe0bae8095e488fab536e1bbc11bb66" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "8a2128b069e046c9992344d5c8d7f5c8" + }, + "m_SlotId": 1 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "a95c92619dc0485d83dce69c60ceca6d" + }, + "m_SlotId": 2 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "8dc18247ab4b4e5caf09faf953798497" + }, + "m_SlotId": 1 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "883fa0154dc245788e90a0983dac686e" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "8dc18247ab4b4e5caf09faf953798497" + }, + "m_SlotId": 1 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "d0f957ba1d13421b96ab67ec531eefa7" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "8fa9e59236e64861945859b2bb07fb53" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "601c6eaea0204053a13a8ac70dd09d06" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "9654b153a4f246f899a7ce0aab379a79" + }, + "m_SlotId": 1 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "a95c92619dc0485d83dce69c60ceca6d" + }, + "m_SlotId": 3 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "9fe0bae8095e488fab536e1bbc11bb66" + }, + "m_SlotId": 2 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "a4abc46300494294b321ea368512e48c" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "9fe0bae8095e488fab536e1bbc11bb66" + }, + "m_SlotId": 2 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "b337e8061fa24e6bb1d267bc90b18e02" + }, + "m_SlotId": 1 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "a4abc46300494294b321ea368512e48c" + }, + "m_SlotId": 2 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "8a2128b069e046c9992344d5c8d7f5c8" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "a95c92619dc0485d83dce69c60ceca6d" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "28e145da8a3747de8be1fbeb7dbc5cae" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "aa3b6d90bb2d442e989158ba90f12906" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "601c6eaea0204053a13a8ac70dd09d06" + }, + "m_SlotId": 1 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "aa3b6d90bb2d442e989158ba90f12906" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "6069340092004c1191a211a8d3274b3d" + }, + "m_SlotId": 1 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "ab291a3748ee4efba44081f662392b9c" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "23d0a726bc0d4c95bc67d874b0a46fbf" + }, + "m_SlotId": 1 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "ac0c1810cc7b43eca36a78a32992055e" + }, + "m_SlotId": 1 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "f0eca0bb90df4ad88ca3cef5c34fc766" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "af7e3800e2f34908a3a77b8948d2fd32" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "c11ee2e3010d48a9a45e803c58cceaa3" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "b158210403a647c485660b84c2aaa857" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "debaaee10b654011933a2346630b5137" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "b337e8061fa24e6bb1d267bc90b18e02" + }, + "m_SlotId": 2 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "30fe193f31ba43ba9fef9f94f9cd4c10" + }, + "m_SlotId": 2 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "bc03bc7dc2ec45c58768cf357d7ef079" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "418e89bc480d45bb8dd81a829a1ce810" + }, + "m_SlotId": 1 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "bc27cfd52e154c9c83ffa6eef20c94f5" + }, + "m_SlotId": 1 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "23d0a726bc0d4c95bc67d874b0a46fbf" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "bdfe061154bb4a70b4961bf28fdc1ff4" + }, + "m_SlotId": 1 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "3230324be61b4cf0a9b15d53e5f48151" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "c11ee2e3010d48a9a45e803c58cceaa3" + }, + "m_SlotId": 2 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "ca5e280a68af4a45a358d1f7b9cff2e2" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "c896751d379b48b793ac05bbc6687f65" + }, + "m_SlotId": 1 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "a4abc46300494294b321ea368512e48c" + }, + "m_SlotId": 1 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "d2920db565474984a8eae456eca16597" + }, + "m_SlotId": 1 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "687659d5f2844131913f3ebec5692c99" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "d971314bc5f54cdab9c09233077b1881" + }, + "m_SlotId": 1 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "6b2e66277a7943f5800e4557cd983757" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "debaaee10b654011933a2346630b5137" + }, + "m_SlotId": 1 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "6069340092004c1191a211a8d3274b3d" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "e00fd7cf1bf84eb8af3423a5f84f02da" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "04aea1edd8694d7f84d7852ec4078ce2" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "e2bec6c3826047c8a8ca759c60bb19ff" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "030f5fb2b7a44537b270b4c404971915" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "eba48f1e544d455986b250277b538909" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "fe89101ff92d49e9a630a987e854fb0a" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "ed083dc9dc3c4f5fa9248d1b99d92da4" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "2643e290df8a4963bc3741b72302fe4f" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "f15873d7cae54a328809df9a8d76bbf7" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "af7e3800e2f34908a3a77b8948d2fd32" + }, + "m_SlotId": 1 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "f769abb9b5a74ec89369a250e2c8d39b" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "815740e575684a18ae4f7aced285fb16" + }, + "m_SlotId": 1 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "fe251668acaf4cc1a186f88895925031" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "bc27cfd52e154c9c83ffa6eef20c94f5" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "fe251668acaf4cc1a186f88895925031" + }, + "m_SlotId": 7 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "6e7f71ec59fb413b942f9ce72cf1967c" + }, + "m_SlotId": 0 + } + } + ], + "m_VertexContext": { + "m_Position": { + "x": 47.99997329711914, + "y": -670.0000610351563 + }, + "m_Blocks": [ + { + "m_Id": "2704a97326044be09a54d3e3810db15f" + }, + { + "m_Id": "0b7af971d63e4166afd190de3b9e9172" + }, + { + "m_Id": "fe4907798c1644289607e0d2603a9a68" + } + ] + }, + "m_FragmentContext": { + "m_Position": { + "x": 46.99992752075195, + "y": -12.000000953674317 + }, + "m_Blocks": [ + { + "m_Id": "d0f957ba1d13421b96ab67ec531eefa7" + }, + { + "m_Id": "358a13893c98426abb6bc4c3984c2dc8" + }, + { + "m_Id": "ca5e280a68af4a45a358d1f7b9cff2e2" + }, + { + "m_Id": "76ac26031b7c43a6a78d7e9db5db64be" + }, + { + "m_Id": "8277bdd1ba5e486788875b590047b626" + }, + { + "m_Id": "687659d5f2844131913f3ebec5692c99" + }, + { + "m_Id": "a61b9632fcd344bbb50f017fe9662523" + }, + { + "m_Id": "43b2f53e22494f52ad836aba700da7c7" + }, + { + "m_Id": "91e279bc4ab24de6baf584d64e36b2ae" + }, + { + "m_Id": "fe89101ff92d49e9a630a987e854fb0a" + }, + { + "m_Id": "bc220c2be8a74249ac65d93a8ae5cbdf" + }, + { + "m_Id": "2b74cde8bed7456b968b7b795a741d50" + }, + { + "m_Id": "4239ae5618e54aada26f71dc47c73c18" + }, + { + "m_Id": "2643e290df8a4963bc3741b72302fe4f" + }, + { + "m_Id": "04aea1edd8694d7f84d7852ec4078ce2" + }, + { + "m_Id": "883fa0154dc245788e90a0983dac686e" + }, + { + "m_Id": "e7adb047317f4e8f97e8758b79640e35" + }, + { + "m_Id": "b3602abd3e6c4110bd7c0c759e4b9c20" + }, + { + "m_Id": "f0eca0bb90df4ad88ca3cef5c34fc766" + } + ] + }, + "m_PreviewData": { + "serializedMesh": { + "m_SerializedMesh": "{\"mesh\":{\"instanceID\":0}}", + "m_Guid": "" + } + }, + "m_Path": "Shader Graphs", + "m_ConcretePrecision": 0, + "m_PreviewMode": 2, + "m_OutputNode": { + "m_Id": "" + }, + "m_ActiveTargets": [ + { + "m_Id": "b68cdcc63047409381c5e594c02463cd" + } + ] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "0185960fa34547a8b2a5593e937eaf49", + "m_Id": 1, + "m_DisplayName": "X", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "X", + "m_StageCapability": 3, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "03014458088c4ce5abc7a07b694efe86", + "m_Id": 0, + "m_DisplayName": "Depth Postpass", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.RedirectNodeData", + "m_ObjectId": "030f5fb2b7a44537b270b4c404971915", + "m_Group": { + "m_Id": "" + }, + "m_Name": "Redirect Node", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -411.99981689453127, + "y": 191.99998474121095, + "width": 56.0, + "height": 23.999998092651368 + } + }, + "m_Slots": [ + { + "m_Id": "493b4f4104c2438f8498f6de58ada442" + }, + { + "m_Id": "0d4c4d21d5d94b838efc01ec0235fed8" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.BlockNode", + "m_ObjectId": "04aea1edd8694d7f84d7852ec4078ce2", + "m_Group": { + "m_Id": "" + }, + "m_Name": "SurfaceDescription.SecondarySpecularShift", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": 0.0, + "y": 0.0, + "width": 0.0, + "height": 0.0 + } + }, + "m_Slots": [ + { + "m_Id": "95f38f9e439d46f6b767d7f992ae0e60" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_SerializedDescriptor": "SurfaceDescription.SecondarySpecularShift" +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Texture2DInputMaterialSlot", + "m_ObjectId": "05fbfae444844c6fba5d11a68dde77d9", + "m_Id": 1, + "m_DisplayName": "Texture", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "Texture", + "m_StageCapability": 3, + "m_BareResource": false, + "m_Texture": { + "m_SerializedTexture": "{\"texture\":{\"instanceID\":0}}", + "m_Guid": "" + }, + "m_DefaultType": 0 +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicValueMaterialSlot", + "m_ObjectId": "07835af3a85d4387bbd3386865feb0bd", + "m_Id": 1, + "m_DisplayName": "B", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "B", + "m_StageCapability": 3, + "m_Value": { + "e00": 2.0, + "e01": 2.0, + "e02": 2.0, + "e03": 2.0, + "e10": 2.0, + "e11": 2.0, + "e12": 2.0, + "e13": 2.0, + "e20": 2.0, + "e21": 2.0, + "e22": 2.0, + "e23": 2.0, + "e30": 2.0, + "e31": 2.0, + "e32": 2.0, + "e33": 2.0 + }, + "m_DefaultValue": { + "e00": 1.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 1.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 1.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.RedirectNodeData", + "m_ObjectId": "07affa6d03af4e71be5df2863dc3cf00", + "m_Group": { + "m_Id": "" + }, + "m_Name": "Redirect Node", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -411.99981689453127, + "y": 143.99998474121095, + "width": 56.0, + "height": 23.999998092651368 + } + }, + "m_Slots": [ + { + "m_Id": "4a76173cb56049afb4021ffc98a09359" + }, + { + "m_Id": "35929c4279f84659bfcaada01f537c9e" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicValueMaterialSlot", + "m_ObjectId": "07d3bd34837d49efac457b1dd4f21469", + "m_Id": 2, + "m_DisplayName": "Out", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": { + "e00": 0.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 0.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 0.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 0.0 + }, + "m_DefaultValue": { + "e00": 1.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 1.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 1.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "08ccc7ab660441e99b582e3f493ce062", + "m_Id": 5, + "m_DisplayName": "G", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "G", + "m_StageCapability": 2, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.BlockNode", + "m_ObjectId": "0b7af971d63e4166afd190de3b9e9172", + "m_Group": { + "m_Id": "" + }, + "m_Name": "VertexDescription.Normal", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": 0.0, + "y": 0.0, + "width": 0.0, + "height": 0.0 + } + }, + "m_Slots": [ + { + "m_Id": "48748e76259b4423af31e7017f1b1967" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_SerializedDescriptor": "VertexDescription.Normal" +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "0c722f49f92545a4b12a022983a9346c", + "m_Id": 2, + "m_DisplayName": "Out", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "0d4c4d21d5d94b838efc01ec0235fed8", + "m_Id": 1, + "m_DisplayName": "", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "0e22fca13e234609afab56d5e9dc57e2", + "m_Id": 1, + "m_DisplayName": "Out", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.RedirectNodeData", + "m_ObjectId": "106c4319f0c8421a9295b557df9f94a3", + "m_Group": { + "m_Id": "" + }, + "m_Name": "Redirect Node", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -618.9998168945313, + "y": 1524.0, + "width": 56.0, + "height": 23.999998092651368 + } + }, + "m_Slots": [ + { + "m_Id": "3c80f97dbdf64454b8313bf869c39b0d" + }, + { + "m_Id": "cc8fa1bf760b4fd584f1204d418bd893" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.UVMaterialSlot", + "m_ObjectId": "10fcfa37830d4e02851aae7950225694", + "m_Id": 2, + "m_DisplayName": "UV", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "UV", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0 + }, + "m_Labels": [], + "m_Channel": 0 +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "11b80c01acff493e8d25da0eeae5b521", + "m_Id": 6, + "m_DisplayName": "B", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "B", + "m_StageCapability": 2, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.PropertyNode", + "m_ObjectId": "1390ac11bb8548bfbe91e6eab457f759", + "m_Group": { + "m_Id": "9cdb7847683948c99034141805213a61" + }, + "m_Name": "Property", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -1665.0, + "y": -881.9999389648438, + "width": 189.0, + "height": 34.0 + } + }, + "m_Slots": [ + { + "m_Id": "bcee9c8d22514bdb97fb3a1b776cebf1" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_Property": { + "m_Id": "5ef8aef8a81b4183b2aa03d38ada5d75" + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "14ae49d9f448412f9e48b712d1468f27", + "m_Id": 0, + "m_DisplayName": "Secondary Specular Multiplier", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.PropertyNode", + "m_ObjectId": "151656766f524322aecfdf73999cda54", + "m_Group": { + "m_Id": "" + }, + "m_Name": "Property", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -504.00006103515627, + "y": 475.0, + "width": 149.0, + "height": 34.0 + } + }, + "m_Slots": [ + { + "m_Id": "45dfc44534f541209f64118a5e0e118d" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_Property": { + "m_Id": "a73bbe07bf634ae6a2f595dac0d74ea3" + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "15a95450e5e046cbb66c50e363aa6f5c", + "m_Id": 7, + "m_DisplayName": "A", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "A", + "m_StageCapability": 2, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "15bc9145e40041e2b9da7df6f07eeee9", + "m_Id": 4, + "m_DisplayName": "R", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "R", + "m_StageCapability": 2, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 3, + "m_Type": "UnityEditor.ShaderGraph.Internal.ColorShaderProperty", + "m_ObjectId": "1728986d8b5d4a60a610dc8f863ef11d", + "m_Guid": { + "m_GuidSerialized": "5b6c3d61-7bba-4042-b1f0-3799fd7bc7a2" + }, + "m_Name": "Specular Tint", + "m_DefaultReferenceName": "Color_1728986d8b5d4a60a610dc8f863ef11d", + "m_OverrideReferenceName": "_SpecularTint", + "m_GeneratePropertyBlock": true, + "m_Precision": 0, + "overrideHLSLDeclaration": false, + "hlslDeclarationOverride": 0, + "m_Hidden": false, + "m_Value": { + "r": 1.0, + "g": 1.0, + "b": 1.0, + "a": 1.0 + }, + "m_ColorMode": 0 +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.NormalMaterialSlot", + "m_ObjectId": "1748e4e9d24e4de7932315b2e25527ce", + "m_Id": 0, + "m_DisplayName": "Bent Normal", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "BentNormal", + "m_StageCapability": 2, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0 + }, + "m_Labels": [], + "m_Space": 3 +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "17d3d431592e4c2bb1780a1e0a9f03a2", + "m_Id": 1, + "m_DisplayName": "", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "1846dfbb5b1441829b77365754ab377d", + "m_Id": 0, + "m_DisplayName": "Secondary Specular Shift", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector4MaterialSlot", + "m_ObjectId": "1b344d261ec648189f8ff9340b0ed20c", + "m_Id": 0, + "m_DisplayName": "RGBA", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "RGBA", + "m_StageCapability": 2, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_Labels": [] +} + +{ + "m_SGVersion": 1, + "m_Type": "UnityEditor.ShaderGraph.Internal.Vector1ShaderProperty", + "m_ObjectId": "1b66a7533fa643888276c4f6de382ca9", + "m_Guid": { + "m_GuidSerialized": "eba3fc22-41c1-494e-a739-60172ed1e541" + }, + "m_Name": "Depth Postpass", + "m_DefaultReferenceName": "Vector1_1b66a7533fa643888276c4f6de382ca9", + "m_OverrideReferenceName": "_DepthPostpass", + "m_GeneratePropertyBlock": true, + "m_Precision": 0, + "overrideHLSLDeclaration": false, + "hlslDeclarationOverride": 0, + "m_Hidden": false, + "m_Value": 1.0, + "m_FloatType": 1, + "m_RangeValues": { + "x": 0.0, + "y": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector3MaterialSlot", + "m_ObjectId": "1bbfb308461446debb1bfaf74fb9d0fb", + "m_Id": 2, + "m_DisplayName": "Out", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0 + }, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicValueMaterialSlot", + "m_ObjectId": "1dff7ccda7c2459fabb9d759da4ebbd8", + "m_Id": 0, + "m_DisplayName": "A", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "A", + "m_StageCapability": 3, + "m_Value": { + "e00": 0.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 0.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 0.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 0.0 + }, + "m_DefaultValue": { + "e00": 1.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 1.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 1.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.UVMaterialSlot", + "m_ObjectId": "1e559a52f2cf4d6282a91a6f552dfcb8", + "m_Id": 2, + "m_DisplayName": "UV", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "UV", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0 + }, + "m_Labels": [], + "m_Channel": 0 +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.MultiplyNode", + "m_ObjectId": "1f325b3e26a640949036a22e6af17a00", + "m_Group": { + "m_Id": "" + }, + "m_Name": "Multiply", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -744.0, + "y": 363.0, + "width": 130.0, + "height": 118.00000762939453 + } + }, + "m_Slots": [ + { + "m_Id": "c55f572322244a4dae2badfed69c29e6" + }, + { + "m_Id": "07835af3a85d4387bbd3386865feb0bd" + }, + { + "m_Id": "faa11926f42c42ea8e9f2f14d3afd2b2" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.PropertyNode", + "m_ObjectId": "20ec913f194d4acd871be539f0ceffd0", + "m_Group": { + "m_Id": "be2cb7795a6143a498576442f64713d6" + }, + "m_Name": "Property", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -1603.999755859375, + "y": 1185.0, + "width": 130.0, + "height": 34.0 + } + }, + "m_Slots": [ + { + "m_Id": "80957726e3df45db966134a9418138f8" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_Property": { + "m_Id": "d962fe658f9a4982b62bd75d03b2276e" + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "22d366686d314c62ab9ea7700c1b42e7", + "m_Id": 0, + "m_DisplayName": "Smoothness", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "Smoothness", + "m_StageCapability": 2, + "m_Value": 0.5, + "m_DefaultValue": 0.5, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.LerpNode", + "m_ObjectId": "23d0a726bc0d4c95bc67d874b0a46fbf", + "m_Group": { + "m_Id": "9cdb7847683948c99034141805213a61" + }, + "m_Name": "Lerp", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -1007.0001220703125, + "y": -1100.0, + "width": 130.0, + "height": 142.0 + } + }, + "m_Slots": [ + { + "m_Id": "4c5b180b461d43f784844d8e9b3b6845" + }, + { + "m_Id": "4fd79aba098f40abadfcb6a788df8bf4" + }, + { + "m_Id": "67c850c6bae045d38afb3d813793f00d" + }, + { + "m_Id": "55f16b899e4042349c060935f8e3c882" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.BlockNode", + "m_ObjectId": "2643e290df8a4963bc3741b72302fe4f", + "m_Group": { + "m_Id": "" + }, + "m_Name": "SurfaceDescription.SecondarySmoothness", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": 61.0, + "y": 540.0, + "width": 200.0, + "height": 41.0 + } + }, + "m_Slots": [ + { + "m_Id": "7ac7d38819cb49fbadbfc71413a3da76" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_SerializedDescriptor": "SurfaceDescription.SecondarySmoothness" +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.BlockNode", + "m_ObjectId": "2704a97326044be09a54d3e3810db15f", + "m_Group": { + "m_Id": "" + }, + "m_Name": "VertexDescription.Position", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": 0.0, + "y": 0.0, + "width": 0.0, + "height": 0.0 + } + }, + "m_Slots": [ + { + "m_Id": "fc09e913712c46d780c50a50e6df747c" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_SerializedDescriptor": "VertexDescription.Position" +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicValueMaterialSlot", + "m_ObjectId": "27233a528aeb411280889b3cc096ce6d", + "m_Id": 1, + "m_DisplayName": "B", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "B", + "m_StageCapability": 3, + "m_Value": { + "e00": 2.0, + "e01": 2.0, + "e02": 2.0, + "e03": 2.0, + "e10": 2.0, + "e11": 2.0, + "e12": 2.0, + "e13": 2.0, + "e20": 2.0, + "e21": 2.0, + "e22": 2.0, + "e23": 2.0, + "e30": 2.0, + "e31": 2.0, + "e32": 2.0, + "e33": 2.0 + }, + "m_DefaultValue": { + "e00": 1.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 1.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 1.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.ColorRGBMaterialSlot", + "m_ObjectId": "2848c38716704c6da99bb5bfd339a5c4", + "m_Id": 0, + "m_DisplayName": "Secondary Specular Tint", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "SecondarySpecularTint", + "m_StageCapability": 2, + "m_Value": { + "x": 0.5, + "y": 0.5, + "z": 0.5 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0 + }, + "m_Labels": [], + "m_ColorMode": 0, + "m_DefaultColor": { + "r": 0.5, + "g": 0.5, + "b": 0.5, + "a": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.RedirectNodeData", + "m_ObjectId": "28e145da8a3747de8be1fbeb7dbc5cae", + "m_Group": { + "m_Id": "" + }, + "m_Name": "Redirect Node", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -618.9998168945313, + "y": 1548.0, + "width": 56.0, + "height": 23.999998092651368 + } + }, + "m_Slots": [ + { + "m_Id": "45ab6695a89b4c0d9656a3ba1ad00c29" + }, + { + "m_Id": "2c6b1e90145d4977b64b33ab8da9392b" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector4MaterialSlot", + "m_ObjectId": "28e5ad56a0cc4bd3acbf0cf95dafcd99", + "m_Id": 0, + "m_DisplayName": "Specular Tint", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "2b0c15c346474e47bba4edea7f4d00ed", + "m_Id": 0, + "m_DisplayName": "Specular Shift", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "SpecularShift", + "m_StageCapability": 2, + "m_Value": 0.10000000149011612, + "m_DefaultValue": 0.10000000149011612, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.PropertyNode", + "m_ObjectId": "2b1f8f17f34d4d07bfa9a061a97ed745", + "m_Group": { + "m_Id": "" + }, + "m_Name": "Property", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -1836.0, + "y": 125.99999237060547, + "width": 136.00001525878907, + "height": 34.000003814697269 + } + }, + "m_Slots": [ + { + "m_Id": "ee9cd55adc774c31a6f4699792680829" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_Property": { + "m_Id": "bc814cd1e05d4e94b3b180cbe5f42bfd" + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.BlockNode", + "m_ObjectId": "2b74cde8bed7456b968b7b795a741d50", + "m_Group": { + "m_Id": "" + }, + "m_Name": "SurfaceDescription.SpecularShift", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": 57.0, + "y": 428.0, + "width": 200.0, + "height": 41.0 + } + }, + "m_Slots": [ + { + "m_Id": "2b0c15c346474e47bba4edea7f4d00ed" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_SerializedDescriptor": "SurfaceDescription.SpecularShift" +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Texture2DMaterialSlot", + "m_ObjectId": "2c3d261d1f3443b4b06b82a9e110faef", + "m_Id": 0, + "m_DisplayName": "Base Color Map", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_BareResource": false +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "2c6b1e90145d4977b64b33ab8da9392b", + "m_Id": 1, + "m_DisplayName": "", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "2c932aab8a0447e09e2733f0afcd0feb", + "m_Id": 0, + "m_DisplayName": "Rim Transmission Intensity", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector4MaterialSlot", + "m_ObjectId": "2cee3bb09b784906b68914fdfd279c7d", + "m_Id": 0, + "m_DisplayName": "RGBA", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "RGBA", + "m_StageCapability": 2, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "2d0ca58a54814172a8890b7463d193fd", + "m_Id": 0, + "m_DisplayName": "In", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "In", + "m_StageCapability": 3, + "m_Value": { + "x": 1.0, + "y": 1.0, + "z": 1.0, + "w": 1.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "30892a065ace490aa42fa50990585547", + "m_Id": 0, + "m_DisplayName": "Alpha Clip", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.KeywordNode", + "m_ObjectId": "30fe193f31ba43ba9fef9f94f9cd4c10", + "m_Group": { + "m_Id": "4754e47d61844a86908699d8a6f31a28" + }, + "m_Name": "Clip Quality", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -1044.999755859375, + "y": 1361.0, + "width": 166.0, + "height": 142.0 + } + }, + "m_Slots": [ + { + "m_Id": "52d52b0d72fa46d2a8c3b5761f07299b" + }, + { + "m_Id": "d0c5c3ec172a44dbb55d75c9f6261716" + }, + { + "m_Id": "694656ca8fa54c51800375119dcf4738" + }, + { + "m_Id": "f766d98305ef4a969d378fbe95628bb8" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_Keyword": { + "m_Id": "a9c42cd3aa674f4b8cd880751469f0f3" + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.MultiplyNode", + "m_ObjectId": "3230324be61b4cf0a9b15d53e5f48151", + "m_Group": { + "m_Id": "9cdb7847683948c99034141805213a61" + }, + "m_Name": "Multiply", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -1426.0, + "y": -999.9999389648438, + "width": 126.00000762939453, + "height": 118.00000762939453 + } + }, + "m_Slots": [ + { + "m_Id": "c8894712474d492484deac572139b543" + }, + { + "m_Id": "5dc293eeb61d40f6a2e60dee2d39993b" + }, + { + "m_Id": "75e80dd8acf54011ad81c68fa7643fad" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "334baaea25334886ba55b47a00a70600", + "m_Id": 0, + "m_DisplayName": "", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicValueMaterialSlot", + "m_ObjectId": "33c3cf79ca494675bf7feafe0ed9594f", + "m_Id": 0, + "m_DisplayName": "A", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "A", + "m_StageCapability": 3, + "m_Value": { + "e00": 0.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 0.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 0.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 0.0 + }, + "m_DefaultValue": { + "e00": 1.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 1.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 1.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "35548bbcfdf246118323976e19cad65e", + "m_Id": 5, + "m_DisplayName": "G", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "G", + "m_StageCapability": 2, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.BlockNode", + "m_ObjectId": "358a13893c98426abb6bc4c3984c2dc8", + "m_Group": { + "m_Id": "" + }, + "m_Name": "SurfaceDescription.Alpha", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": 51.00004196166992, + "y": 62.000003814697269, + "width": 200.0, + "height": 41.0 + } + }, + "m_Slots": [ + { + "m_Id": "5bf37270ba754ed7ad94fb22e0a5a6be" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_SerializedDescriptor": "SurfaceDescription.Alpha" +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "35929c4279f84659bfcaada01f537c9e", + "m_Id": 1, + "m_DisplayName": "", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "359ed959f5ae49cc8ffb169c40b8e27c", + "m_Id": 1, + "m_DisplayName": "Out", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.NormalMaterialSlot", + "m_ObjectId": "364bf0711ec54f028805cfb78c3b2936", + "m_Id": 0, + "m_DisplayName": "Normal (Tangent Space)", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "NormalTS", + "m_StageCapability": 2, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0 + }, + "m_Labels": [], + "m_Space": 3 +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.MultiplyNode", + "m_ObjectId": "366fe14bae29480a8d870a61047f38bf", + "m_Group": { + "m_Id": "" + }, + "m_Name": "Multiply", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -744.0, + "y": 504.0000305175781, + "width": 130.0, + "height": 118.00000762939453 + } + }, + "m_Slots": [ + { + "m_Id": "407171467b584927aba0bcd728e9e0cf" + }, + { + "m_Id": "27233a528aeb411280889b3cc096ce6d" + }, + { + "m_Id": "07d3bd34837d49efac457b1dd4f21469" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.TangentMaterialSlot", + "m_ObjectId": "36a7e27cf2f142179340d6911fb6702e", + "m_Id": 0, + "m_DisplayName": "Tangent", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "Tangent", + "m_StageCapability": 1, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0 + }, + "m_Labels": [], + "m_Space": 0 +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "38ad6bc9c98e4a37b8ace60514a07bfa", + "m_Id": 0, + "m_DisplayName": "", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "3a36e0af1d014dd79a48ede02af5c854", + "m_Id": 0, + "m_DisplayName": "Ambient Occlusion", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "Occlusion", + "m_StageCapability": 2, + "m_Value": 1.0, + "m_DefaultValue": 1.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "3b929e8fca7e47e89ef8b8ebcbddf16b", + "m_Id": 0, + "m_DisplayName": "Depth Prepass", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "3c80f97dbdf64454b8313bf869c39b0d", + "m_Id": 0, + "m_DisplayName": "", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "3ead7aeb80554142b1b8acd0ff2e0d13", + "m_Id": 0, + "m_DisplayName": "Alpha Clip Threshold Depth Postpass", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "AlphaClipThresholdDepthPostpass", + "m_StageCapability": 2, + "m_Value": 0.5, + "m_DefaultValue": 0.5, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicValueMaterialSlot", + "m_ObjectId": "407171467b584927aba0bcd728e9e0cf", + "m_Id": 0, + "m_DisplayName": "A", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "A", + "m_StageCapability": 3, + "m_Value": { + "e00": 0.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 0.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 0.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 0.0 + }, + "m_DefaultValue": { + "e00": 1.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 1.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 1.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicValueMaterialSlot", + "m_ObjectId": "4154ea606af6442987588d72a76c3c3d", + "m_Id": 1, + "m_DisplayName": "B", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "B", + "m_StageCapability": 3, + "m_Value": { + "e00": 2.0, + "e01": 2.0, + "e02": 2.0, + "e03": 2.0, + "e10": 2.0, + "e11": 2.0, + "e12": 2.0, + "e13": 2.0, + "e20": 2.0, + "e21": 2.0, + "e22": 2.0, + "e23": 2.0, + "e30": 2.0, + "e31": 2.0, + "e32": 2.0, + "e33": 2.0 + }, + "m_DefaultValue": { + "e00": 1.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 1.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 1.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1Node", + "m_ObjectId": "418e89bc480d45bb8dd81a829a1ce810", + "m_Group": { + "m_Id": "9cdb7847683948c99034141805213a61" + }, + "m_Name": "Float", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -1773.0, + "y": -999.9999389648438, + "width": 126.00000762939453, + "height": 77.0 + } + }, + "m_Slots": [ + { + "m_Id": "0185960fa34547a8b2a5593e937eaf49" + }, + { + "m_Id": "b80731bafa324b21a25802913ebc37cb" + } + ], + "synonyms": [ + "Vector 1" + ], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_Value": 0.0 +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.BlockNode", + "m_ObjectId": "4239ae5618e54aada26f71dc47c73c18", + "m_Group": { + "m_Id": "" + }, + "m_Name": "SurfaceDescription.SecondarySpecularTint", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": 61.0, + "y": 496.0, + "width": 200.0, + "height": 41.0 + } + }, + "m_Slots": [ + { + "m_Id": "2848c38716704c6da99bb5bfd339a5c4" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_SerializedDescriptor": "SurfaceDescription.SecondarySpecularTint" +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.BlockNode", + "m_ObjectId": "43b2f53e22494f52ad836aba700da7c7", + "m_Group": { + "m_Id": "" + }, + "m_Name": "SurfaceDescription.Occlusion", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": 0.0, + "y": 0.0, + "width": 0.0, + "height": 0.0 + } + }, + "m_Slots": [ + { + "m_Id": "3a36e0af1d014dd79a48ede02af5c854" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_SerializedDescriptor": "SurfaceDescription.Occlusion" +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "43f7b6d9bf324f8fba8b51d9b2d533ee", + "m_Id": 1, + "m_DisplayName": "Out", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.PropertyNode", + "m_ObjectId": "45445a2f270b47348746e62d75ebd6c7", + "m_Group": { + "m_Id": "" + }, + "m_Name": "Property", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -1650.0, + "y": 978.0000610351563, + "width": 162.0, + "height": 34.0 + } + }, + "m_Slots": [ + { + "m_Id": "f84ab63ad59d473790240bbae5312104" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_Property": { + "m_Id": "ddc2f22573d241e787bf84f06e4ba049" + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.SampleTexture2DNode", + "m_ObjectId": "454e8678d7fa4d8583459d67c01c0d1d", + "m_Group": { + "m_Id": "" + }, + "m_Name": "Sample Texture 2D", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -1672.0, + "y": -182.0, + "width": 184.0, + "height": 253.0 + } + }, + "m_Slots": [ + { + "m_Id": "9434105a0b564544a9d1f31216367712" + }, + { + "m_Id": "15bc9145e40041e2b9da7df6f07eeee9" + }, + { + "m_Id": "f27d637587474cacb94bfd396d77089d" + }, + { + "m_Id": "fca9ffe88cae49efa8c33c1354e48c1d" + }, + { + "m_Id": "787d961abdfd4d58a8bd0b2a1e2db47d" + }, + { + "m_Id": "decdf89d9b1c47e49e07623e017ab4f8" + }, + { + "m_Id": "f04fd49f51ba4fb684bf9e7cfe737a4c" + }, + { + "m_Id": "c37c97a92c19442dad070dbf06704ded" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_TextureType": 0, + "m_NormalMapSpace": 0 +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "45ab6695a89b4c0d9656a3ba1ad00c29", + "m_Id": 0, + "m_DisplayName": "", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "45caa412775943ba95db5ef93db99949", + "m_Id": 0, + "m_DisplayName": "Alpha Clip", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "45dfc44534f541209f64118a5e0e118d", + "m_Id": 0, + "m_DisplayName": "Specular Shift", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.SamplerStateMaterialSlot", + "m_ObjectId": "46c045243fd947a3bf8f480d04000881", + "m_Id": 3, + "m_DisplayName": "Sampler", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "Sampler", + "m_StageCapability": 3, + "m_BareResource": false +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.GroupData", + "m_ObjectId": "4754e47d61844a86908699d8a6f31a28", + "m_Title": "Clip Quality Keywords", + "m_Position": { + "x": -1070.0, + "y": 1302.0001220703125 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.NormalMaterialSlot", + "m_ObjectId": "48748e76259b4423af31e7017f1b1967", + "m_Id": 0, + "m_DisplayName": "Normal", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "Normal", + "m_StageCapability": 1, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0 + }, + "m_Labels": [], + "m_Space": 0 +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "493b4f4104c2438f8498f6de58ada442", + "m_Id": 0, + "m_DisplayName": "", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "49cec6f655c34b46a219eed9fed64e30", + "m_Id": 0, + "m_DisplayName": "", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "4a76173cb56049afb4021ffc98a09359", + "m_Id": 0, + "m_DisplayName": "", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "4b31cead930147bdadc33a292daeed85", + "m_Id": 1, + "m_DisplayName": "Standard", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "STANDARD", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.PropertyNode", + "m_ObjectId": "4be5e95fcd374b61bd561cf5a7bec49a", + "m_Group": { + "m_Id": "" + }, + "m_Name": "Property", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -1014.0, + "y": 360.0, + "width": 173.00001525878907, + "height": 34.0 + } + }, + "m_Slots": [ + { + "m_Id": "e9bda8c3d270475490b2b7838f87a7de" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_Property": { + "m_Id": "7ad41145b0c646049037af434d423fc6" + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "4c5b180b461d43f784844d8e9b3b6845", + "m_Id": 0, + "m_DisplayName": "A", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "A", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector3MaterialSlot", + "m_ObjectId": "4e4c5ea5d3094e1595676fdb82c3c6f2", + "m_Id": 0, + "m_DisplayName": "Hair Strand Direction", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "HairStrandDirection", + "m_StageCapability": 2, + "m_Value": { + "x": 0.0, + "y": -1.0, + "z": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0 + }, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.PropertyNode", + "m_ObjectId": "4e86ff273f104b47a35a04b03339a9d7", + "m_Group": { + "m_Id": "" + }, + "m_Name": "Property", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -1889.0, + "y": 432.0, + "width": 159.0, + "height": 34.000003814697269 + } + }, + "m_Slots": [ + { + "m_Id": "8f90b16bec664b40969b8192f7069d7e" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_Property": { + "m_Id": "ac27b0d8beef493a80956330658fb3e7" + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "4e971251d58043798122a4510a3e233e", + "m_Id": 0, + "m_DisplayName": "In", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "In", + "m_StageCapability": 3, + "m_Value": { + "x": 1.0, + "y": 1.0, + "z": 1.0, + "w": 1.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "4fd79aba098f40abadfcb6a788df8bf4", + "m_Id": 1, + "m_DisplayName": "B", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "B", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 1.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector4MaterialSlot", + "m_ObjectId": "51d12b88dbe54204b4dca4f289ac9b91", + "m_Id": 0, + "m_DisplayName": "Vertex Base Color", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "52d52b0d72fa46d2a8c3b5761f07299b", + "m_Id": 0, + "m_DisplayName": "Out", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "5344a6989aba47fd9ea911a2503f6363", + "m_Id": 1, + "m_DisplayName": "", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector3MaterialSlot", + "m_ObjectId": "5511d7e8ad5044bcb20cbb1224be4cd3", + "m_Id": 0, + "m_DisplayName": "Transmittance", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "Transmittance", + "m_StageCapability": 2, + "m_Value": { + "x": 0.30000001192092898, + "y": 0.19500000774860383, + "z": 0.09000000357627869 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0 + }, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "55f16b899e4042349c060935f8e3c882", + "m_Id": 3, + "m_DisplayName": "Out", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.SamplerStateMaterialSlot", + "m_ObjectId": "5874a8cec8cf4abf8f56c8ee53245f1a", + "m_Id": 3, + "m_DisplayName": "Sampler", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "Sampler", + "m_StageCapability": 3, + "m_BareResource": false +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.PropertyNode", + "m_ObjectId": "5b7fb36f8a124e63b24b1f4891c7d268", + "m_Group": { + "m_Id": "b773332f12a640f2961cff577b07701f" + }, + "m_Name": "Property", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -1882.9998779296875, + "y": 1395.0, + "width": 130.0, + "height": 34.0 + } + }, + "m_Slots": [ + { + "m_Id": "45caa412775943ba95db5ef93db99949" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_Property": { + "m_Id": "d962fe658f9a4982b62bd75d03b2276e" + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicValueMaterialSlot", + "m_ObjectId": "5b8032c360414a4a9f95bd5c607c118c", + "m_Id": 2, + "m_DisplayName": "Out", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": { + "e00": 0.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 0.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 0.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 0.0 + }, + "m_DefaultValue": { + "e00": 1.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 1.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 1.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.PropertyNode", + "m_ObjectId": "5bc2e2ebb6e84033be0c02d88425a9d9", + "m_Group": { + "m_Id": "" + }, + "m_Name": "Property", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -1897.0, + "y": -180.0, + "width": 139.0, + "height": 34.0 + } + }, + "m_Slots": [ + { + "m_Id": "baf616c41c254dcca387f1819d9a2a42" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_Property": { + "m_Id": "6dc6a8e2ab304a639656ee2082845e1c" + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "5bf37270ba754ed7ad94fb22e0a5a6be", + "m_Id": 0, + "m_DisplayName": "Alpha", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "Alpha", + "m_StageCapability": 2, + "m_Value": 1.0, + "m_DefaultValue": 1.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "5c85d658386b4b13bd3a308504910663", + "m_Id": 5, + "m_DisplayName": "G", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "G", + "m_StageCapability": 2, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 1, + "m_Type": "UnityEditor.ShaderGraph.Internal.Vector1ShaderProperty", + "m_ObjectId": "5d4c697aa2e74bdbb12725c42b2313e7", + "m_Guid": { + "m_GuidSerialized": "5b5af7c1-d733-4406-ad7f-139ef1fb78c5" + }, + "m_Name": "Rim Transmission Intensity", + "m_DefaultReferenceName": "", + "m_OverrideReferenceName": "_RimTransmissionIntensity", + "m_GeneratePropertyBlock": true, + "m_Precision": 0, + "overrideHLSLDeclaration": false, + "hlslDeclarationOverride": 2, + "m_Hidden": false, + "m_Value": 0.05000000074505806, + "m_FloatType": 1, + "m_RangeValues": { + "x": 0.0, + "y": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicValueMaterialSlot", + "m_ObjectId": "5dc293eeb61d40f6a2e60dee2d39993b", + "m_Id": 1, + "m_DisplayName": "B", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "B", + "m_StageCapability": 3, + "m_Value": { + "e00": 2.0, + "e01": 2.0, + "e02": 2.0, + "e03": 2.0, + "e10": 2.0, + "e11": 2.0, + "e12": 2.0, + "e13": 2.0, + "e20": 2.0, + "e21": 2.0, + "e22": 2.0, + "e23": 2.0, + "e30": 2.0, + "e31": 2.0, + "e32": 2.0, + "e33": 2.0 + }, + "m_DefaultValue": { + "e00": 1.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 1.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 1.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector4MaterialSlot", + "m_ObjectId": "5e0fe5e94dc24bf6813a9916ddf06b19", + "m_Id": 0, + "m_DisplayName": "Out", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "5e351a9c13a74f909cf032de19e6ecba", + "m_Id": 0, + "m_DisplayName": "", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 1, + "m_Type": "UnityEditor.ShaderGraph.Internal.Vector1ShaderProperty", + "m_ObjectId": "5ef8aef8a81b4183b2aa03d38ada5d75", + "m_Guid": { + "m_GuidSerialized": "c99cfa48-2a38-421d-b471-4979b348a1c3" + }, + "m_Name": "Vertex Color Strength", + "m_DefaultReferenceName": "Vector1_5ef8aef8a81b4183b2aa03d38ada5d75", + "m_OverrideReferenceName": "_VertexColorStrength", + "m_GeneratePropertyBlock": true, + "m_Precision": 0, + "overrideHLSLDeclaration": false, + "hlslDeclarationOverride": 0, + "m_Hidden": false, + "m_Value": 0.5, + "m_FloatType": 1, + "m_RangeValues": { + "x": 0.0, + "y": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.PropertyNode", + "m_ObjectId": "5f984a05a60b4f76afa0ec01041e1d96", + "m_Group": { + "m_Id": "72585dd91b3d4da7b55123bae128c48b" + }, + "m_Name": "Property", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -2546.0, + "y": -829.9999389648438, + "width": 148.0, + "height": 34.0 + } + }, + "m_Slots": [ + { + "m_Id": "2c3d261d1f3443b4b06b82a9e110faef" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_Property": { + "m_Id": "62ba90b39c554829b983338182c6db53" + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DitherNode", + "m_ObjectId": "601c6eaea0204053a13a8ac70dd09d06", + "m_Group": { + "m_Id": "b3823636393244d99c581f1785baf857" + }, + "m_Name": "Dither", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -1607.9998779296875, + "y": 1834.0, + "width": 202.0, + "height": 118.0 + } + }, + "m_Slots": [ + { + "m_Id": "8bbf0bdfb6cd4cb7b1070a2ecd46a157" + }, + { + "m_Id": "aee77a08299944a9b9d28832d825355c" + }, + { + "m_Id": "e30d33c3db434bae88da4c3b97aae575" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DitherNode", + "m_ObjectId": "6069340092004c1191a211a8d3274b3d", + "m_Group": { + "m_Id": "b3823636393244d99c581f1785baf857" + }, + "m_Name": "Dither", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -1882.9998779296875, + "y": 1952.0, + "width": 202.0, + "height": 118.0 + } + }, + "m_Slots": [ + { + "m_Id": "c6b2bdeea61f477c8613fc7f050fa911" + }, + { + "m_Id": "c397f7900ec14147bae4c9c1de892440" + }, + { + "m_Id": "8a33ae3b6dc04e9ea7202337a7bdb983" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.PropertyNode", + "m_ObjectId": "60f1e7e5998d42d5be5bf1c40597f04f", + "m_Group": { + "m_Id": "b773332f12a640f2961cff577b07701f" + }, + "m_Name": "Property", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -2177.0, + "y": 1685.0, + "width": 153.0, + "height": 34.0 + } + }, + "m_Slots": [ + { + "m_Id": "3b929e8fca7e47e89ef8b8ebcbddf16b" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_Property": { + "m_Id": "7a9dca43a15c41859b95c7edb930b3db" + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Texture2DInputMaterialSlot", + "m_ObjectId": "60f5c5dda134431287bf9b6f82a257ce", + "m_Id": 1, + "m_DisplayName": "Texture", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "Texture", + "m_StageCapability": 3, + "m_BareResource": false, + "m_Texture": { + "m_SerializedTexture": "{\"texture\":{\"instanceID\":0}}", + "m_Guid": "" + }, + "m_DefaultType": 0 +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "61b1fa4982b349249be7fc970cde0912", + "m_Id": 0, + "m_DisplayName": "In", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "In", + "m_StageCapability": 3, + "m_Value": { + "x": 1.0, + "y": 1.0, + "z": 1.0, + "w": 1.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.PropertyNode", + "m_ObjectId": "627b5ab6400f4b94ae60bfcab74b4ab5", + "m_Group": { + "m_Id": "" + }, + "m_Name": "Property", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -571.0, + "y": 360.0, + "width": 216.00001525878907, + "height": 34.0 + } + }, + "m_Slots": [ + { + "m_Id": "2c932aab8a0447e09e2733f0afcd0feb" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_Property": { + "m_Id": "5d4c697aa2e74bdbb12725c42b2313e7" + } +} + +{ + "m_SGVersion": 1, + "m_Type": "UnityEditor.ShaderGraph.Internal.Vector1ShaderProperty", + "m_ObjectId": "629bfa855bb345f5b11dd44954fbddba", + "m_Guid": { + "m_GuidSerialized": "a82edcba-4fed-4ba8-9007-3a79175ba3b7" + }, + "m_Name": "Secondary Specular Shift", + "m_DefaultReferenceName": "", + "m_OverrideReferenceName": "_SecondarySpecularShift", + "m_GeneratePropertyBlock": true, + "m_Precision": 0, + "overrideHLSLDeclaration": false, + "hlslDeclarationOverride": 0, + "m_Hidden": false, + "m_Value": -0.10000000149011612, + "m_FloatType": 1, + "m_RangeValues": { + "x": -1.0, + "y": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Internal.Texture2DShaderProperty", + "m_ObjectId": "62ba90b39c554829b983338182c6db53", + "m_Guid": { + "m_GuidSerialized": "ffcaae55-d07d-4e7a-a6b5-45d201ee4df5" + }, + "m_Name": "Base Color Map", + "m_DefaultReferenceName": "Texture2D_62ba90b39c554829b983338182c6db53", + "m_OverrideReferenceName": "_BaseColorMap", + "m_GeneratePropertyBlock": true, + "m_Precision": 0, + "overrideHLSLDeclaration": false, + "hlslDeclarationOverride": 2, + "m_Hidden": false, + "m_Value": { + "m_SerializedTexture": "{\"texture\":{\"instanceID\":0}}", + "m_Guid": "" + }, + "m_Modifiable": true, + "m_DefaultType": 0 +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.ColorRGBMaterialSlot", + "m_ObjectId": "62d6d2cb38b34a8dae2f3582eadc51fd", + "m_Id": 0, + "m_DisplayName": "Emission", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "Emission", + "m_StageCapability": 2, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0 + }, + "m_Labels": [], + "m_ColorMode": 1, + "m_DefaultColor": { + "r": 0.0, + "g": 0.0, + "b": 0.0, + "a": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Texture2DInputMaterialSlot", + "m_ObjectId": "645f90c185f2471d9630858b570a39ca", + "m_Id": 1, + "m_DisplayName": "Texture", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "Texture", + "m_StageCapability": 3, + "m_BareResource": false, + "m_Texture": { + "m_SerializedTexture": "{\"texture\":{\"instanceID\":0}}", + "m_Guid": "" + }, + "m_DefaultType": 3 +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "649c1c4ff7a549e2a6ca39dac06f31c2", + "m_Id": 0, + "m_DisplayName": "In", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "In", + "m_StageCapability": 3, + "m_Value": { + "x": 1.0, + "y": 1.0, + "z": 1.0, + "w": 1.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.Rendering.HighDefinition.ShaderGraph.LightingData", + "m_ObjectId": "6642d27020f646129f5cda404c16ec41", + "m_NormalDropOffSpace": 0, + "m_BlendPreserveSpecular": true, + "m_ReceiveDecals": true, + "m_ReceiveSSR": true, + "m_ReceiveSSRTransparent": false, + "m_SpecularAA": false, + "m_SpecularOcclusionMode": 1, + "m_OverrideBakedGI": false +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "67c850c6bae045d38afb3d813793f00d", + "m_Id": 2, + "m_DisplayName": "T", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "T", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 1.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.BlockNode", + "m_ObjectId": "687659d5f2844131913f3ebec5692c99", + "m_Group": { + "m_Id": "" + }, + "m_Name": "SurfaceDescription.Smoothness", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": 58.9999885559082, + "y": 272.0, + "width": 200.00001525878907, + "height": 41.000003814697269 + } + }, + "m_Slots": [ + { + "m_Id": "22d366686d314c62ab9ea7700c1b42e7" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_SerializedDescriptor": "SurfaceDescription.Smoothness" +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "694656ca8fa54c51800375119dcf4738", + "m_Id": 2, + "m_DisplayName": "Noise", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "NOISE", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.RedirectNodeData", + "m_ObjectId": "6b2e66277a7943f5800e4557cd983757", + "m_Group": { + "m_Id": "" + }, + "m_Name": "Redirect Node", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -411.99981689453127, + "y": 215.99998474121095, + "width": 56.0, + "height": 23.999998092651368 + } + }, + "m_Slots": [ + { + "m_Id": "38ad6bc9c98e4a37b8ace60514a07bfa" + }, + { + "m_Id": "eac54b5f186d486e80825976e56c5237" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "6b5deda71f474aee97807127ea957961", + "m_Id": 4, + "m_DisplayName": "R", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "R", + "m_StageCapability": 2, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.PropertyNode", + "m_ObjectId": "6c82b6ddafb64673b5161a23abfc93e4", + "m_Group": { + "m_Id": "be2cb7795a6143a498576442f64713d6" + }, + "m_Name": "Property", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -1603.999755859375, + "y": 1236.0, + "width": 153.0, + "height": 34.0 + } + }, + "m_Slots": [ + { + "m_Id": "95c2bc57f4dd42d7b05fd17539661814" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_Property": { + "m_Id": "7a9dca43a15c41859b95c7edb930b3db" + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.SampleTexture2DNode", + "m_ObjectId": "6cf2216245ca4c94a226d2a52deb5633", + "m_Group": { + "m_Id": "" + }, + "m_Name": "Sample Texture 2D", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -1672.0, + "y": 412.9999694824219, + "width": 184.0, + "height": 253.00001525878907 + } + }, + "m_Slots": [ + { + "m_Id": "1b344d261ec648189f8ff9340b0ed20c" + }, + { + "m_Id": "6cf943c0e05c4227a451bfe832fb0e00" + }, + { + "m_Id": "ab63acc371ab4765a2800d13b87b7152" + }, + { + "m_Id": "864866bcd4e4447fbe0cc68f600714d4" + }, + { + "m_Id": "db66712351c04b3eb291dd17798f7b1c" + }, + { + "m_Id": "60f5c5dda134431287bf9b6f82a257ce" + }, + { + "m_Id": "8fe0ba5e3f2845ec8b9295f68c04d12d" + }, + { + "m_Id": "e97c3fa8ab4d480faefb7391b4a9c808" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_TextureType": 0, + "m_NormalMapSpace": 0 +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "6cf943c0e05c4227a451bfe832fb0e00", + "m_Id": 4, + "m_DisplayName": "R", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "R", + "m_StageCapability": 2, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Internal.Texture2DShaderProperty", + "m_ObjectId": "6dc6a8e2ab304a639656ee2082845e1c", + "m_Guid": { + "m_GuidSerialized": "553fed75-2c32-4ba5-9e11-bc8403abcfc3" + }, + "m_Name": "Mask Map", + "m_DefaultReferenceName": "Texture2D_6dc6a8e2ab304a639656ee2082845e1c", + "m_OverrideReferenceName": "_MaskMap", + "m_GeneratePropertyBlock": true, + "m_Precision": 0, + "overrideHLSLDeclaration": false, + "hlslDeclarationOverride": 0, + "m_Hidden": false, + "m_Value": { + "m_SerializedTexture": "{\"texture\":{\"instanceID\":0}}", + "m_Guid": "" + }, + "m_Modifiable": true, + "m_DefaultType": 0 +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.RedirectNodeData", + "m_ObjectId": "6e7f71ec59fb413b942f9ce72cf1967c", + "m_Group": { + "m_Id": "" + }, + "m_Name": "Redirect Node", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -411.0000305175781, + "y": -670.0000610351563, + "width": 56.0, + "height": 24.000001907348634 + } + }, + "m_Slots": [ + { + "m_Id": "334baaea25334886ba55b47a00a70600" + }, + { + "m_Id": "927b00c341304144a459a766397301d6" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "6f3540c2049c407f8b731f2c50534ed8", + "m_Id": 0, + "m_DisplayName": "", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "6f484dea1069470eb479d882654b3ea7", + "m_Id": 7, + "m_DisplayName": "A", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "A", + "m_StageCapability": 2, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "72408d8c59e6451f8a9f8fe57493ee3b", + "m_Id": 0, + "m_DisplayName": "In", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "In", + "m_StageCapability": 3, + "m_Value": { + "x": 1.0, + "y": 1.0, + "z": 1.0, + "w": 1.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.GroupData", + "m_ObjectId": "72585dd91b3d4da7b55123bae128c48b", + "m_Title": "Diffuse and Alpha", + "m_Position": { + "x": -2571.0, + "y": -888.9999389648438 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "7260c54475d24fdc9dc73a6544edaa9c", + "m_Id": 6, + "m_DisplayName": "B", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "B", + "m_StageCapability": 2, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.PropertyNode", + "m_ObjectId": "72d4a986e38a498bae8f34613460f37e", + "m_Group": { + "m_Id": "" + }, + "m_Name": "Property", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -1038.999755859375, + "y": 1867.9998779296875, + "width": 160.0, + "height": 34.0 + } + }, + "m_Slots": [ + { + "m_Id": "03014458088c4ce5abc7a07b694efe86" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_Property": { + "m_Id": "1b66a7533fa643888276c4f6de382ca9" + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicValueMaterialSlot", + "m_ObjectId": "75e80dd8acf54011ad81c68fa7643fad", + "m_Id": 2, + "m_DisplayName": "Out", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": { + "e00": 0.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 0.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 0.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 0.0 + }, + "m_DefaultValue": { + "e00": 1.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 1.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 1.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.BlockNode", + "m_ObjectId": "76ac26031b7c43a6a78d7e9db5db64be", + "m_Group": { + "m_Id": "" + }, + "m_Name": "SurfaceDescription.BentNormal", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": 32.000003814697269, + "y": 610.0, + "width": 200.0, + "height": 41.0 + } + }, + "m_Slots": [ + { + "m_Id": "1748e4e9d24e4de7932315b2e25527ce" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_SerializedDescriptor": "SurfaceDescription.BentNormal" +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "7756e79b76714e4396a582857d12cbeb", + "m_Id": 3, + "m_DisplayName": "Dither", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "DITHER", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "787d961abdfd4d58a8bd0b2a1e2db47d", + "m_Id": 7, + "m_DisplayName": "A", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "A", + "m_StageCapability": 2, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.PropertyNode", + "m_ObjectId": "7a473df09e9b4bd3b82814666640158f", + "m_Group": { + "m_Id": "" + }, + "m_Name": "Property", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -1213.0, + "y": 565.0, + "width": 231.0, + "height": 34.0 + } + }, + "m_Slots": [ + { + "m_Id": "14ae49d9f448412f9e48b712d1468f27" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_Property": { + "m_Id": "8197dc419ed34d5e8c22c7c35775566a" + } +} + +{ + "m_SGVersion": 1, + "m_Type": "UnityEditor.ShaderGraph.Internal.Vector1ShaderProperty", + "m_ObjectId": "7a9dca43a15c41859b95c7edb930b3db", + "m_Guid": { + "m_GuidSerialized": "8ec5925d-958a-4990-8d66-01bb95754728" + }, + "m_Name": "Depth Prepass", + "m_DefaultReferenceName": "Vector1_7a9dca43a15c41859b95c7edb930b3db", + "m_OverrideReferenceName": "_DepthPrepass", + "m_GeneratePropertyBlock": true, + "m_Precision": 0, + "overrideHLSLDeclaration": false, + "hlslDeclarationOverride": 0, + "m_Hidden": false, + "m_Value": 0.8999999761581421, + "m_FloatType": 1, + "m_RangeValues": { + "x": 0.0, + "y": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "7ac7d38819cb49fbadbfc71413a3da76", + "m_Id": 0, + "m_DisplayName": "Secondary Smoothness", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "SecondarySmoothness", + "m_StageCapability": 2, + "m_Value": 0.5, + "m_DefaultValue": 0.5, + "m_Labels": [] +} + +{ + "m_SGVersion": 1, + "m_Type": "UnityEditor.ShaderGraph.Internal.Vector1ShaderProperty", + "m_ObjectId": "7ad41145b0c646049037af434d423fc6", + "m_Guid": { + "m_GuidSerialized": "8ba45b1e-7fc1-426d-84e0-33d302945c1a" + }, + "m_Name": "Specular Multiplier", + "m_DefaultReferenceName": "", + "m_OverrideReferenceName": "_SpecularMultiplier", + "m_GeneratePropertyBlock": true, + "m_Precision": 0, + "overrideHLSLDeclaration": false, + "hlslDeclarationOverride": 0, + "m_Hidden": false, + "m_Value": 1.0, + "m_FloatType": 1, + "m_RangeValues": { + "x": 0.0, + "y": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector4MaterialSlot", + "m_ObjectId": "7dbf0eb7f73346f89d219731f4e3b02a", + "m_Id": 0, + "m_DisplayName": "RGBA", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "RGBA", + "m_StageCapability": 2, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "7ebc51c5ee6542f483e212e0a309011a", + "m_Id": 1, + "m_DisplayName": "Strength", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "Strength", + "m_StageCapability": 3, + "m_Value": 1.0, + "m_DefaultValue": 1.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "8026cfb04de041b082f4f67ec8866e35", + "m_Id": 0, + "m_DisplayName": "Depth Prepass", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "80957726e3df45db966134a9418138f8", + "m_Id": 0, + "m_DisplayName": "Alpha Clip", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.MultiplyNode", + "m_ObjectId": "815740e575684a18ae4f7aced285fb16", + "m_Group": { + "m_Id": "" + }, + "m_Name": "Multiply", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -970.9999389648438, + "y": 427.0000305175781, + "width": 130.0, + "height": 118.0 + } + }, + "m_Slots": [ + { + "m_Id": "1dff7ccda7c2459fabb9d759da4ebbd8" + }, + { + "m_Id": "a1bd16c0f006490ea28c3fd3a27df8f0" + }, + { + "m_Id": "e7665d3760434dc88e41ba34f6d09177" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 1, + "m_Type": "UnityEditor.ShaderGraph.Internal.Vector1ShaderProperty", + "m_ObjectId": "8197dc419ed34d5e8c22c7c35775566a", + "m_Guid": { + "m_GuidSerialized": "ad5c7094-5822-4685-bf0c-ae8d59ca1faf" + }, + "m_Name": "Secondary Specular Multiplier", + "m_DefaultReferenceName": "", + "m_OverrideReferenceName": "_SecondarySpecularMultiplier", + "m_GeneratePropertyBlock": true, + "m_Precision": 0, + "overrideHLSLDeclaration": false, + "hlslDeclarationOverride": 0, + "m_Hidden": false, + "m_Value": 0.10000000149011612, + "m_FloatType": 1, + "m_RangeValues": { + "x": 0.0, + "y": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.BlockNode", + "m_ObjectId": "8277bdd1ba5e486788875b590047b626", + "m_Group": { + "m_Id": "" + }, + "m_Name": "SurfaceDescription.Emission", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": 57.000003814697269, + "y": 227.99998474121095, + "width": 200.0, + "height": 41.0 + } + }, + "m_Slots": [ + { + "m_Id": "62d6d2cb38b34a8dae2f3582eadc51fd" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_SerializedDescriptor": "SurfaceDescription.Emission" +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "83ccede77bf347b5ada7f22a90a71e54", + "m_Id": 4, + "m_DisplayName": "R", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "R", + "m_StageCapability": 2, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "8608d2b6360a457a818cd7857bf72ad4", + "m_Id": 0, + "m_DisplayName": "Alpha Clip Threshold Depth Prepass", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "AlphaClipThresholdDepthPrepass", + "m_StageCapability": 2, + "m_Value": 0.5, + "m_DefaultValue": 0.5, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.ScreenPositionNode", + "m_ObjectId": "860c97ed98f348e0942b9e5eb0916c14", + "m_Group": { + "m_Id": "b773332f12a640f2961cff577b07701f" + }, + "m_Name": "Screen Position", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -2168.999755859375, + "y": 1454.0, + "width": 145.0, + "height": 130.0 + } + }, + "m_Slots": [ + { + "m_Id": "f6e8c313d5084dee886ad054638ec381" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_ScreenSpaceType": 3 +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "864866bcd4e4447fbe0cc68f600714d4", + "m_Id": 6, + "m_DisplayName": "B", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "B", + "m_StageCapability": 2, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.BlockNode", + "m_ObjectId": "883fa0154dc245788e90a0983dac686e", + "m_Group": { + "m_Id": "" + }, + "m_Name": "SurfaceDescription.Transmittance", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": 63.0, + "y": 347.0, + "width": 200.0, + "height": 41.0 + } + }, + "m_Slots": [ + { + "m_Id": "5511d7e8ad5044bcb20cbb1224be4cd3" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_SerializedDescriptor": "SurfaceDescription.Transmittance" +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.OneMinusNode", + "m_ObjectId": "8a2128b069e046c9992344d5c8d7f5c8", + "m_Group": { + "m_Id": "b773332f12a640f2961cff577b07701f" + }, + "m_Name": "One Minus", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -1533.999755859375, + "y": 1625.0, + "width": 128.0, + "height": 94.0 + } + }, + "m_Slots": [ + { + "m_Id": "61b1fa4982b349249be7fc970cde0912" + }, + { + "m_Id": "43f7b6d9bf324f8fba8b51d9b2d533ee" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "8a33ae3b6dc04e9ea7202337a7bdb983", + "m_Id": 2, + "m_DisplayName": "Out", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicValueMaterialSlot", + "m_ObjectId": "8bb14fe492e84a57a67f49618f3e308c", + "m_Id": 1, + "m_DisplayName": "B", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "B", + "m_StageCapability": 3, + "m_Value": { + "e00": 2.0, + "e01": 2.0, + "e02": 2.0, + "e03": 2.0, + "e10": 2.0, + "e11": 2.0, + "e12": 2.0, + "e13": 2.0, + "e20": 2.0, + "e21": 2.0, + "e22": 2.0, + "e23": 2.0, + "e30": 2.0, + "e31": 2.0, + "e32": 2.0, + "e33": 2.0 + }, + "m_DefaultValue": { + "e00": 1.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 1.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 1.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "8bbf0bdfb6cd4cb7b1070a2ecd46a157", + "m_Id": 0, + "m_DisplayName": "In", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "In", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.RedirectNodeData", + "m_ObjectId": "8dc18247ab4b4e5caf09faf953798497", + "m_Group": { + "m_Id": "" + }, + "m_Name": "Redirect Node", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -411.0000305175781, + "y": -694.0, + "width": 56.0, + "height": 24.000001907348634 + } + }, + "m_Slots": [ + { + "m_Id": "49cec6f655c34b46a219eed9fed64e30" + }, + { + "m_Id": "5344a6989aba47fd9ea911a2503f6363" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "8f7592f0a88049148d7a20c1cb1e22cb", + "m_Id": 0, + "m_DisplayName": "", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Texture2DMaterialSlot", + "m_ObjectId": "8f90b16bec664b40969b8192f7069d7e", + "m_Id": 0, + "m_DisplayName": "Emission Map", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_BareResource": false +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.PropertyNode", + "m_ObjectId": "8fa9e59236e64861945859b2bb07fb53", + "m_Group": { + "m_Id": "b3823636393244d99c581f1785baf857" + }, + "m_Name": "Property", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -1882.9998779296875, + "y": 1834.0, + "width": 130.0, + "height": 34.0 + } + }, + "m_Slots": [ + { + "m_Id": "30892a065ace490aa42fa50990585547" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_Property": { + "m_Id": "d962fe658f9a4982b62bd75d03b2276e" + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.UVMaterialSlot", + "m_ObjectId": "8fe0ba5e3f2845ec8b9295f68c04d12d", + "m_Id": 2, + "m_DisplayName": "UV", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "UV", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0 + }, + "m_Labels": [], + "m_Channel": 0 +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.BlockNode", + "m_ObjectId": "91e279bc4ab24de6baf584d64e36b2ae", + "m_Group": { + "m_Id": "" + }, + "m_Name": "SurfaceDescription.AlphaClipThreshold", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": 68.99986267089844, + "y": 697.0, + "width": 200.0, + "height": 40.999996185302737 + } + }, + "m_Slots": [ + { + "m_Id": "a39ba9aad8d348e1b9d547f1f8c0685d" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_SerializedDescriptor": "SurfaceDescription.AlphaClipThreshold" +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "927b00c341304144a459a766397301d6", + "m_Id": 1, + "m_DisplayName": "", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "94181a41d1b84df5829bc1191f6a2ee4", + "m_Id": 2, + "m_DisplayName": "Noise", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "NOISE", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector4MaterialSlot", + "m_ObjectId": "9434105a0b564544a9d1f31216367712", + "m_Id": 0, + "m_DisplayName": "RGBA", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "RGBA", + "m_StageCapability": 2, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "95c2bc57f4dd42d7b05fd17539661814", + "m_Id": 0, + "m_DisplayName": "Depth Prepass", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "95f38f9e439d46f6b767d7f992ae0e60", + "m_Id": 0, + "m_DisplayName": "Secondary Specular Shift", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "SecondarySpecularShift", + "m_StageCapability": 2, + "m_Value": -0.10000000149011612, + "m_DefaultValue": -0.10000000149011612, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.OneMinusNode", + "m_ObjectId": "9654b153a4f246f899a7ce0aab379a79", + "m_Group": { + "m_Id": "b3823636393244d99c581f1785baf857" + }, + "m_Name": "One Minus", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -1537.9998779296875, + "y": 1982.0, + "width": 128.0, + "height": 94.0 + } + }, + "m_Slots": [ + { + "m_Id": "649c1c4ff7a549e2a6ca39dac06f31c2" + }, + { + "m_Id": "bec14e41986f40ceb443e419826d6152" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "976db38438d44e13a156bab6235d2198", + "m_Id": 1, + "m_DisplayName": "Scale", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "Scale", + "m_StageCapability": 3, + "m_Value": 2000.0, + "m_DefaultValue": 500.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "97fe11918115427b831d4ee7b93b40eb", + "m_Id": 7, + "m_DisplayName": "A", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "A", + "m_StageCapability": 2, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "9c661df801f348f0ad7991ba68cbe2d5", + "m_Id": 0, + "m_DisplayName": "", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.GroupData", + "m_ObjectId": "9cdb7847683948c99034141805213a61", + "m_Title": "Vertex Color Mask and Depth Blend", + "m_Position": { + "x": -1965.0, + "y": -1159.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.NoiseNode", + "m_ObjectId": "9fe0bae8095e488fab536e1bbc11bb66", + "m_Group": { + "m_Id": "b773332f12a640f2961cff577b07701f" + }, + "m_Name": "Simple Noise", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -1903.9998779296875, + "y": 1454.0, + "width": 147.0, + "height": 118.0 + } + }, + "m_Slots": [ + { + "m_Id": "aad9226057ad4461a38b52b6cd9f2006" + }, + { + "m_Id": "976db38438d44e13a156bab6235d2198" + }, + { + "m_Id": "0c722f49f92545a4b12a022983a9346c" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicValueMaterialSlot", + "m_ObjectId": "a1b5ae04eaa4441aac1e35bd9ea8b20f", + "m_Id": 2, + "m_DisplayName": "Out", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": { + "e00": 0.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 0.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 0.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 0.0 + }, + "m_DefaultValue": { + "e00": 1.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 1.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 1.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicValueMaterialSlot", + "m_ObjectId": "a1bd16c0f006490ea28c3fd3a27df8f0", + "m_Id": 1, + "m_DisplayName": "B", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "B", + "m_StageCapability": 3, + "m_Value": { + "e00": 2.0, + "e01": 2.0, + "e02": 2.0, + "e03": 2.0, + "e10": 2.0, + "e11": 2.0, + "e12": 2.0, + "e13": 2.0, + "e20": 2.0, + "e21": 2.0, + "e22": 2.0, + "e23": 2.0, + "e30": 2.0, + "e31": 2.0, + "e32": 2.0, + "e33": 2.0 + }, + "m_DefaultValue": { + "e00": 1.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 1.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 1.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "a2b446a108624f4ea43455c92d25610e", + "m_Id": 0, + "m_DisplayName": "Alpha Clip Threshold Shadow", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "AlphaClipThresholdShadow", + "m_StageCapability": 2, + "m_Value": 0.5, + "m_DefaultValue": 0.5, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "a39ba9aad8d348e1b9d547f1f8c0685d", + "m_Id": 0, + "m_DisplayName": "Alpha Clip Threshold", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "AlphaClipThreshold", + "m_StageCapability": 2, + "m_Value": 0.5, + "m_DefaultValue": 0.5, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.MultiplyNode", + "m_ObjectId": "a4abc46300494294b321ea368512e48c", + "m_Group": { + "m_Id": "b773332f12a640f2961cff577b07701f" + }, + "m_Name": "Multiply", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -1701.999755859375, + "y": 1584.0, + "width": 125.99999237060547, + "height": 118.0 + } + }, + "m_Slots": [ + { + "m_Id": "33c3cf79ca494675bf7feafe0ed9594f" + }, + { + "m_Id": "8bb14fe492e84a57a67f49618f3e308c" + }, + { + "m_Id": "a1b5ae04eaa4441aac1e35bd9ea8b20f" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.BlockNode", + "m_ObjectId": "a61b9632fcd344bbb50f017fe9662523", + "m_Group": { + "m_Id": "" + }, + "m_Name": "SurfaceDescription.HairStrandDirection", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": 58.9999885559082, + "y": 224.00001525878907, + "width": 200.00001525878907, + "height": 41.000003814697269 + } + }, + "m_Slots": [ + { + "m_Id": "4e4c5ea5d3094e1595676fdb82c3c6f2" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_SerializedDescriptor": "SurfaceDescription.HairStrandDirection" +} + +{ + "m_SGVersion": 1, + "m_Type": "UnityEditor.ShaderGraph.Internal.Vector1ShaderProperty", + "m_ObjectId": "a73bbe07bf634ae6a2f595dac0d74ea3", + "m_Guid": { + "m_GuidSerialized": "984b5df2-eeb1-40fd-bd35-496888fe0ccf" + }, + "m_Name": "Specular Shift", + "m_DefaultReferenceName": "Vector1_a73bbe07bf634ae6a2f595dac0d74ea3", + "m_OverrideReferenceName": "_SpecularShift", + "m_GeneratePropertyBlock": true, + "m_Precision": 0, + "overrideHLSLDeclaration": false, + "hlslDeclarationOverride": 0, + "m_Hidden": false, + "m_Value": 0.25, + "m_FloatType": 1, + "m_RangeValues": { + "x": -1.0, + "y": 1.0 + } +} + +{ + "m_SGVersion": 3, + "m_Type": "UnityEditor.ShaderGraph.Internal.ColorShaderProperty", + "m_ObjectId": "a8fac80485344a489b31db2a226e0489", + "m_Guid": { + "m_GuidSerialized": "3a62cbe1-292f-42d4-8678-d1dc0695eb3b" + }, + "m_Name": "Vertex Base Color", + "m_DefaultReferenceName": "Color_a8fac80485344a489b31db2a226e0489", + "m_OverrideReferenceName": "_VertexBaseColor", + "m_GeneratePropertyBlock": true, + "m_Precision": 0, + "overrideHLSLDeclaration": false, + "hlslDeclarationOverride": 0, + "m_Hidden": false, + "m_Value": { + "r": 0.0, + "g": 0.0, + "b": 0.0, + "a": 0.0 + }, + "m_ColorMode": 0 +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.KeywordNode", + "m_ObjectId": "a95c92619dc0485d83dce69c60ceca6d", + "m_Group": { + "m_Id": "4754e47d61844a86908699d8a6f31a28" + }, + "m_Name": "Clip Quality", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -1044.999755859375, + "y": 1601.0, + "width": 166.0, + "height": 142.0 + } + }, + "m_Slots": [ + { + "m_Id": "b8ebe5bed87e404994efe09218ca4b45" + }, + { + "m_Id": "4b31cead930147bdadc33a292daeed85" + }, + { + "m_Id": "94181a41d1b84df5829bc1191f6a2ee4" + }, + { + "m_Id": "7756e79b76714e4396a582857d12cbeb" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_Keyword": { + "m_Id": "a9c42cd3aa674f4b8cd880751469f0f3" + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.ShaderKeyword", + "m_ObjectId": "a9c42cd3aa674f4b8cd880751469f0f3", + "m_Guid": { + "m_GuidSerialized": "f54a4cd9-4fbe-436d-b8ba-15ea3468fb67" + }, + "m_Name": "Clip Quality", + "m_DefaultReferenceName": "ENUM_A9C42CD3AA674F4B8CD880751469F0F3", + "m_OverrideReferenceName": "_ENUMCLIPQUALITY_ON", + "m_GeneratePropertyBlock": true, + "m_KeywordType": 1, + "m_KeywordDefinition": 1, + "m_KeywordScope": 0, + "m_Entries": [ + { + "id": 1, + "displayName": "Standard", + "referenceName": "STANDARD" + }, + { + "id": 2, + "displayName": "Noise", + "referenceName": "NOISE" + }, + { + "id": 3, + "displayName": "Dither", + "referenceName": "DITHER" + } + ], + "m_Value": 0, + "m_IsEditable": true +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.ScreenPositionNode", + "m_ObjectId": "aa3b6d90bb2d442e989158ba90f12906", + "m_Group": { + "m_Id": "b3823636393244d99c581f1785baf857" + }, + "m_Name": "Screen Position", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -2095.999755859375, + "y": 1852.0, + "width": 145.0, + "height": 130.0 + } + }, + "m_Slots": [ + { + "m_Id": "5e0fe5e94dc24bf6813a9916ddf06b19" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_ScreenSpaceType": 0 +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.UVMaterialSlot", + "m_ObjectId": "aad9226057ad4461a38b52b6cd9f2006", + "m_Id": 0, + "m_DisplayName": "UV", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "UV", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0 + }, + "m_Labels": [], + "m_Channel": 0 +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.PropertyNode", + "m_ObjectId": "ab291a3748ee4efba44081f662392b9c", + "m_Group": { + "m_Id": "9cdb7847683948c99034141805213a61" + }, + "m_Name": "Property", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -1262.0, + "y": -1033.9998779296875, + "width": 171.00001525878907, + "height": 34.0 + } + }, + "m_Slots": [ + { + "m_Id": "51d12b88dbe54204b4dca4f289ac9b91" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_Property": { + "m_Id": "a8fac80485344a489b31db2a226e0489" + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "ab63acc371ab4765a2800d13b87b7152", + "m_Id": 5, + "m_DisplayName": "G", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "G", + "m_StageCapability": 2, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.RedirectNodeData", + "m_ObjectId": "ac0c1810cc7b43eca36a78a32992055e", + "m_Group": { + "m_Id": "" + }, + "m_Name": "Redirect Node", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -618.9998168945313, + "y": 1572.0, + "width": 56.0, + "height": 23.999998092651368 + } + }, + "m_Slots": [ + { + "m_Id": "5e351a9c13a74f909cf032de19e6ecba" + }, + { + "m_Id": "f2ad0036164a41018d0e761ccde52714" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Internal.Texture2DShaderProperty", + "m_ObjectId": "ac27b0d8beef493a80956330658fb3e7", + "m_Guid": { + "m_GuidSerialized": "7cefccf5-1b01-4a43-ad9e-5c90373d8f44" + }, + "m_Name": "Emission Map", + "m_DefaultReferenceName": "Texture2D_ac27b0d8beef493a80956330658fb3e7", + "m_OverrideReferenceName": "_EmissionMap", + "m_GeneratePropertyBlock": true, + "m_Precision": 0, + "overrideHLSLDeclaration": false, + "hlslDeclarationOverride": 0, + "m_Hidden": false, + "m_Value": { + "m_SerializedTexture": "{\"texture\":{\"instanceID\":0}}", + "m_Guid": "" + }, + "m_Modifiable": true, + "m_DefaultType": 1 +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.Rendering.HighDefinition.ShaderGraph.HairSubTarget", + "m_ObjectId": "ae695df4997e40b2ae5fccf1dbc75884" +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.SamplerStateMaterialSlot", + "m_ObjectId": "ae6aeab78fad43109257fd5685aca7ad", + "m_Id": 3, + "m_DisplayName": "Sampler", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "Sampler", + "m_StageCapability": 3, + "m_BareResource": false +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.ScreenPositionMaterialSlot", + "m_ObjectId": "aee77a08299944a9b9d28832d825355c", + "m_Id": 1, + "m_DisplayName": "Screen Position", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "ScreenPosition", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_Labels": [], + "m_ScreenSpaceType": 0 +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "af325e529f144f119f865552aeb01d6b", + "m_Id": 0, + "m_DisplayName": "Rim Transmission Intensity", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "RimTransmissionIntensity", + "m_StageCapability": 2, + "m_Value": 0.05000000074505806, + "m_DefaultValue": 0.20000000298023225, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.SampleTexture2DNode", + "m_ObjectId": "af7e3800e2f34908a3a77b8948d2fd32", + "m_Group": { + "m_Id": "" + }, + "m_Name": "Sample Texture 2D", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -1672.0, + "y": 712.0, + "width": 184.0, + "height": 253.0 + } + }, + "m_Slots": [ + { + "m_Id": "7dbf0eb7f73346f89d219731f4e3b02a" + }, + { + "m_Id": "d40713f2096b42e38a0c7e5f8926687d" + }, + { + "m_Id": "35548bbcfdf246118323976e19cad65e" + }, + { + "m_Id": "7260c54475d24fdc9dc73a6544edaa9c" + }, + { + "m_Id": "97fe11918115427b831d4ee7b93b40eb" + }, + { + "m_Id": "ea85740a0e1e4ec5bcd3084711e2da2f" + }, + { + "m_Id": "10fcfa37830d4e02851aae7950225694" + }, + { + "m_Id": "5874a8cec8cf4abf8f56c8ee53245f1a" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_TextureType": 1, + "m_NormalMapSpace": 0 +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.PropertyNode", + "m_ObjectId": "b158210403a647c485660b84c2aaa857", + "m_Group": { + "m_Id": "b3823636393244d99c581f1785baf857" + }, + "m_Name": "Property", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -2252.999755859375, + "y": 2023.0, + "width": 153.0, + "height": 34.0 + } + }, + "m_Slots": [ + { + "m_Id": "8026cfb04de041b082f4f67ec8866e35" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_Property": { + "m_Id": "7a9dca43a15c41859b95c7edb930b3db" + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Internal.Texture2DShaderProperty", + "m_ObjectId": "b304178995574d4b8dceaf0eade7e621", + "m_Guid": { + "m_GuidSerialized": "716a1137-cfb1-4c9d-bc69-04632fcd9cd6" + }, + "m_Name": "Normal Map", + "m_DefaultReferenceName": "Texture2D_b304178995574d4b8dceaf0eade7e621", + "m_OverrideReferenceName": "_NormalMap", + "m_GeneratePropertyBlock": true, + "m_Precision": 0, + "overrideHLSLDeclaration": false, + "hlslDeclarationOverride": 0, + "m_Hidden": false, + "m_Value": { + "m_SerializedTexture": "{\"texture\":{\"instanceID\":0}}", + "m_Guid": "" + }, + "m_Modifiable": true, + "m_DefaultType": 3 +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.MultiplyNode", + "m_ObjectId": "b337e8061fa24e6bb1d267bc90b18e02", + "m_Group": { + "m_Id": "b773332f12a640f2961cff577b07701f" + }, + "m_Name": "Multiply", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -1531.999755859375, + "y": 1385.0, + "width": 125.99999237060547, + "height": 118.0 + } + }, + "m_Slots": [ + { + "m_Id": "c60878de532b40f18b8873bf81da94c3" + }, + { + "m_Id": "4154ea606af6442987588d72a76c3c3d" + }, + { + "m_Id": "5b8032c360414a4a9f95bd5c607c118c" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.BlockNode", + "m_ObjectId": "b3602abd3e6c4110bd7c0c759e4b9c20", + "m_Group": { + "m_Id": "" + }, + "m_Name": "SurfaceDescription.AlphaClipThresholdDepthPrepass", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": 0.0, + "y": 0.0, + "width": 0.0, + "height": 0.0 + } + }, + "m_Slots": [ + { + "m_Id": "8608d2b6360a457a818cd7857bf72ad4" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_SerializedDescriptor": "SurfaceDescription.AlphaClipThresholdDepthPrepass" +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.GroupData", + "m_ObjectId": "b3823636393244d99c581f1785baf857", + "m_Title": "Dithered Alpha Clip", + "m_Position": { + "x": -2277.999755859375, + "y": 1774.9998779296875 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.Rendering.HighDefinition.ShaderGraph.HDTarget", + "m_ObjectId": "b68cdcc63047409381c5e594c02463cd", + "m_ActiveSubTarget": { + "m_Id": "ae695df4997e40b2ae5fccf1dbc75884" + }, + "m_Datas": [ + { + "m_Id": "f907ec2614f64fee9511dbed58f101b9" + }, + { + "m_Id": "6642d27020f646129f5cda404c16ec41" + }, + { + "m_Id": "ca7dd4e86229499ea82f26ce21b18c9f" + }, + { + "m_Id": "f5f54dac45ca4f98b35bfd8055240a0f" + } + ], + "m_CustomEditorGUI": "" +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.GroupData", + "m_ObjectId": "b773332f12a640f2961cff577b07701f", + "m_Title": "Noise Alpha Clip", + "m_Position": { + "x": -2202.0, + "y": 1326.0001220703125 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "b80731bafa324b21a25802913ebc37cb", + "m_Id": 0, + "m_DisplayName": "Out", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "b8ebe5bed87e404994efe09218ca4b45", + "m_Id": 0, + "m_DisplayName": "Out", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "ba480ecbddef4b438d53b2d86976cab9", + "m_Id": 0, + "m_DisplayName": "Shadow Clip", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Texture2DMaterialSlot", + "m_ObjectId": "baf616c41c254dcca387f1819d9a2a42", + "m_Id": 0, + "m_DisplayName": "Mask Map", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_BareResource": false +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.VertexColorNode", + "m_ObjectId": "bc03bc7dc2ec45c58768cf357d7ef079", + "m_Group": { + "m_Id": "9cdb7847683948c99034141805213a61" + }, + "m_Name": "Vertex Color", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -1940.0, + "y": -999.9999389648438, + "width": 116.0, + "height": 94.0 + } + }, + "m_Slots": [ + { + "m_Id": "bf448c84a8af45968459b416d02c69a3" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 2, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.BlockNode", + "m_ObjectId": "bc220c2be8a74249ac65d93a8ae5cbdf", + "m_Group": { + "m_Id": "" + }, + "m_Name": "SurfaceDescription.SpecularTint", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": 69.0, + "y": 416.0, + "width": 200.0, + "height": 41.0 + } + }, + "m_Slots": [ + { + "m_Id": "da2ed9a7347d45adabf135aa710395f0" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_SerializedDescriptor": "SurfaceDescription.SpecularTint" +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.RedirectNodeData", + "m_ObjectId": "bc27cfd52e154c9c83ffa6eef20c94f5", + "m_Group": { + "m_Id": "9cdb7847683948c99034141805213a61" + }, + "m_Name": "Redirect Node", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -1940.0, + "y": -1057.9998779296875, + "width": 56.0, + "height": 24.000001907348634 + } + }, + "m_Slots": [ + { + "m_Id": "6f3540c2049c407f8b731f2c50534ed8" + }, + { + "m_Id": "fbabbd7d9e264747b9ec6a8f021bc5d7" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Internal.Texture2DShaderProperty", + "m_ObjectId": "bc814cd1e05d4e94b3b180cbe5f42bfd", + "m_Guid": { + "m_GuidSerialized": "01fa32ed-9744-41c4-a9f3-8f45ff507022" + }, + "m_Name": "Flow Map", + "m_DefaultReferenceName": "Texture2D_bc814cd1e05d4e94b3b180cbe5f42bfd", + "m_OverrideReferenceName": "_FlowMap", + "m_GeneratePropertyBlock": true, + "m_Precision": 0, + "overrideHLSLDeclaration": false, + "hlslDeclarationOverride": 0, + "m_Hidden": false, + "m_Value": { + "m_SerializedTexture": "{\"texture\":{\"instanceID\":0}}", + "m_Guid": "" + }, + "m_Modifiable": true, + "m_DefaultType": 2 +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "bcee9c8d22514bdb97fb3a1b776cebf1", + "m_Id": 0, + "m_DisplayName": "Vertex Color Strength", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.OneMinusNode", + "m_ObjectId": "bdfe061154bb4a70b4961bf28fdc1ff4", + "m_Group": { + "m_Id": "9cdb7847683948c99034141805213a61" + }, + "m_Name": "One Minus", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -1612.0, + "y": -999.9999389648438, + "width": 128.0, + "height": 94.0 + } + }, + "m_Slots": [ + { + "m_Id": "4e971251d58043798122a4510a3e233e" + }, + { + "m_Id": "f0cfa449191f4171b27dcc76ab6a2da1" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.GroupData", + "m_ObjectId": "be2cb7795a6143a498576442f64713d6", + "m_Title": "Standard Alpha Clip", + "m_Position": { + "x": -1628.999755859375, + "y": 1126.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "bec14e41986f40ceb443e419826d6152", + "m_Id": 1, + "m_DisplayName": "Out", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector4MaterialSlot", + "m_ObjectId": "bf448c84a8af45968459b416d02c69a3", + "m_Id": 0, + "m_DisplayName": "Out", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": { + "x": 1.0, + "y": 1.0, + "z": 1.0, + "w": 1.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.NormalStrengthNode", + "m_ObjectId": "c11ee2e3010d48a9a45e803c58cceaa3", + "m_Group": { + "m_Id": "" + }, + "m_Name": "Normal Strength", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -1393.0001220703125, + "y": 796.0, + "width": 166.0, + "height": 117.99999237060547 + } + }, + "m_Slots": [ + { + "m_Id": "cd0678aa9ec34c438304e160465603a1" + }, + { + "m_Id": "7ebc51c5ee6542f483e212e0a309011a" + }, + { + "m_Id": "1bbfb308461446debb1bfaf74fb9d0fb" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.StickyNoteData", + "m_ObjectId": "c3448cd8492948db8adf7a079b6fcd8e", + "m_Title": "HDRP", + "m_Content": "R = Metallic\nG = AO\nB = Micro Normal Mask\nA = Smoothness", + "m_TextSize": 0, + "m_Theme": 0, + "m_Position": { + "serializedVersion": "2", + "x": -1682.0, + "y": -285.0, + "width": 200.0, + "height": 100.0 + }, + "m_Group": { + "m_Id": "" + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.SamplerStateMaterialSlot", + "m_ObjectId": "c37c97a92c19442dad070dbf06704ded", + "m_Id": 3, + "m_DisplayName": "Sampler", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "Sampler", + "m_StageCapability": 3, + "m_BareResource": false +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.ScreenPositionMaterialSlot", + "m_ObjectId": "c397f7900ec14147bae4c9c1de892440", + "m_Id": 1, + "m_DisplayName": "Screen Position", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "ScreenPosition", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_Labels": [], + "m_ScreenSpaceType": 0 +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "c47e9f8f06464bcaba87ddfdec2550d1", + "m_Id": 6, + "m_DisplayName": "B", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "B", + "m_StageCapability": 2, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicValueMaterialSlot", + "m_ObjectId": "c55f572322244a4dae2badfed69c29e6", + "m_Id": 0, + "m_DisplayName": "A", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "A", + "m_StageCapability": 3, + "m_Value": { + "e00": 0.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 0.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 0.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 0.0 + }, + "m_DefaultValue": { + "e00": 1.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 1.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 1.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicValueMaterialSlot", + "m_ObjectId": "c60878de532b40f18b8873bf81da94c3", + "m_Id": 0, + "m_DisplayName": "A", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "A", + "m_StageCapability": 3, + "m_Value": { + "e00": 0.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 0.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 0.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 0.0 + }, + "m_DefaultValue": { + "e00": 1.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 1.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 1.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "c6b2bdeea61f477c8613fc7f050fa911", + "m_Id": 0, + "m_DisplayName": "In", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "In", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicValueMaterialSlot", + "m_ObjectId": "c8894712474d492484deac572139b543", + "m_Id": 0, + "m_DisplayName": "A", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "A", + "m_StageCapability": 3, + "m_Value": { + "e00": 0.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 0.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 0.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 0.0 + }, + "m_DefaultValue": { + "e00": 1.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 1.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 1.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.OneMinusNode", + "m_ObjectId": "c896751d379b48b793ac05bbc6687f65", + "m_Group": { + "m_Id": "b773332f12a640f2961cff577b07701f" + }, + "m_Name": "One Minus", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -1884.9998779296875, + "y": 1625.0, + "width": 128.0, + "height": 94.0 + } + }, + "m_Slots": [ + { + "m_Id": "72408d8c59e6451f8a9f8fe57493ee3b" + }, + { + "m_Id": "0e22fca13e234609afab56d5e9dc57e2" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.BlockNode", + "m_ObjectId": "ca5e280a68af4a45a358d1f7b9cff2e2", + "m_Group": { + "m_Id": "" + }, + "m_Name": "SurfaceDescription.NormalTS", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": 87.99999237060547, + "y": 647.9999389648438, + "width": 200.0, + "height": 41.0 + } + }, + "m_Slots": [ + { + "m_Id": "364bf0711ec54f028805cfb78c3b2936" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_SerializedDescriptor": "SurfaceDescription.NormalTS" +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.Rendering.HighDefinition.ShaderGraph.SystemData", + "m_ObjectId": "ca7dd4e86229499ea82f26ce21b18c9f", + "m_MaterialNeedsUpdateHash": 12719, + "m_SurfaceType": 1, + "m_RenderingPass": 4, + "m_BlendMode": 0, + "m_ZTest": 4, + "m_ZWrite": true, + "m_TransparentCullMode": 2, + "m_OpaqueCullMode": 2, + "m_SortPriority": 2, + "m_AlphaTest": true, + "m_TransparentDepthPrepass": false, + "m_TransparentDepthPostpass": false, + "m_SupportLodCrossFade": false, + "m_DoubleSidedMode": 1, + "m_DOTSInstancing": false, + "m_Version": 0, + "m_FirstTimeMigrationExecuted": true, + "inspectorFoldoutMask": 9 +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "cc8fa1bf760b4fd584f1204d418bd893", + "m_Id": 1, + "m_DisplayName": "", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector3MaterialSlot", + "m_ObjectId": "cd0678aa9ec34c438304e160465603a1", + "m_Id": 0, + "m_DisplayName": "In", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "In", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 1.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0 + }, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "d0c5c3ec172a44dbb55d75c9f6261716", + "m_Id": 1, + "m_DisplayName": "Standard", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "STANDARD", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.BlockNode", + "m_ObjectId": "d0f957ba1d13421b96ab67ec531eefa7", + "m_Group": { + "m_Id": "" + }, + "m_Name": "SurfaceDescription.BaseColor", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": 0.0, + "y": 0.0, + "width": 0.0, + "height": 0.0 + } + }, + "m_Slots": [ + { + "m_Id": "efd248053249470994c19338779f963b" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_SerializedDescriptor": "SurfaceDescription.BaseColor" +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "d2879013cac543e893122f0eacba141b", + "m_Id": 1, + "m_DisplayName": "", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.RedirectNodeData", + "m_ObjectId": "d2920db565474984a8eae456eca16597", + "m_Group": { + "m_Id": "" + }, + "m_Name": "Redirect Node", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -411.99981689453127, + "y": 167.99998474121095, + "width": 56.0, + "height": 23.999998092651368 + } + }, + "m_Slots": [ + { + "m_Id": "9c661df801f348f0ad7991ba68cbe2d5" + }, + { + "m_Id": "17d3d431592e4c2bb1780a1e0a9f03a2" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "d40713f2096b42e38a0c7e5f8926687d", + "m_Id": 4, + "m_DisplayName": "R", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "R", + "m_StageCapability": 2, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 1, + "m_Type": "UnityEditor.ShaderGraph.Internal.Vector1ShaderProperty", + "m_ObjectId": "d5ea19d7fc704761908396f642de59c8", + "m_Guid": { + "m_GuidSerialized": "4c15fac4-6456-4d6a-b272-cbe501cb8e12" + }, + "m_Name": "Shadow Clip", + "m_DefaultReferenceName": "Vector1_d5ea19d7fc704761908396f642de59c8", + "m_OverrideReferenceName": "_ShadowClip", + "m_GeneratePropertyBlock": true, + "m_Precision": 0, + "overrideHLSLDeclaration": false, + "hlslDeclarationOverride": 0, + "m_Hidden": false, + "m_Value": 0.25, + "m_FloatType": 1, + "m_RangeValues": { + "x": 0.0, + "y": 1.0 + } +} + +{ + "m_SGVersion": 1, + "m_Type": "UnityEditor.ShaderGraph.Internal.Vector1ShaderProperty", + "m_ObjectId": "d962fe658f9a4982b62bd75d03b2276e", + "m_Guid": { + "m_GuidSerialized": "6c26b18b-16d4-4524-a7d2-0120218bb0fc" + }, + "m_Name": "Alpha Clip", + "m_DefaultReferenceName": "Vector1_d962fe658f9a4982b62bd75d03b2276e", + "m_OverrideReferenceName": "_AlphaClip", + "m_GeneratePropertyBlock": true, + "m_Precision": 0, + "overrideHLSLDeclaration": false, + "hlslDeclarationOverride": 0, + "m_Hidden": false, + "m_Value": 0.10000000149011612, + "m_FloatType": 1, + "m_RangeValues": { + "x": 0.0, + "y": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.RedirectNodeData", + "m_ObjectId": "d971314bc5f54cdab9c09233077b1881", + "m_Group": { + "m_Id": "" + }, + "m_Name": "Redirect Node", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -1321.0, + "y": 226.0, + "width": 56.000003814697269, + "height": 24.000001907348634 + } + }, + "m_Slots": [ + { + "m_Id": "8f7592f0a88049148d7a20c1cb1e22cb" + }, + { + "m_Id": "d2879013cac543e893122f0eacba141b" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.ColorRGBMaterialSlot", + "m_ObjectId": "da2ed9a7347d45adabf135aa710395f0", + "m_Id": 0, + "m_DisplayName": "Specular Tint", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "SpecularTint", + "m_StageCapability": 2, + "m_Value": { + "x": 1.0, + "y": 1.0, + "z": 1.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0 + }, + "m_Labels": [], + "m_ColorMode": 0, + "m_DefaultColor": { + "r": 1.0, + "g": 1.0, + "b": 1.0, + "a": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "db66712351c04b3eb291dd17798f7b1c", + "m_Id": 7, + "m_DisplayName": "A", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "A", + "m_StageCapability": 2, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 1, + "m_Type": "UnityEditor.ShaderGraph.Internal.Vector1ShaderProperty", + "m_ObjectId": "ddc2f22573d241e787bf84f06e4ba049", + "m_Guid": { + "m_GuidSerialized": "896ff0e2-487e-462b-97a9-d76d74fab136" + }, + "m_Name": "Normal Strength", + "m_DefaultReferenceName": "", + "m_OverrideReferenceName": "_NormalStrength", + "m_GeneratePropertyBlock": true, + "m_Precision": 0, + "overrideHLSLDeclaration": false, + "hlslDeclarationOverride": 0, + "m_Hidden": false, + "m_Value": 1.0, + "m_FloatType": 1, + "m_RangeValues": { + "x": 0.0, + "y": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.OneMinusNode", + "m_ObjectId": "debaaee10b654011933a2346630b5137", + "m_Group": { + "m_Id": "b3823636393244d99c581f1785baf857" + }, + "m_Name": "One Minus", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -2079.0, + "y": 2023.0, + "width": 128.0, + "height": 94.0 + } + }, + "m_Slots": [ + { + "m_Id": "2d0ca58a54814172a8890b7463d193fd" + }, + { + "m_Id": "359ed959f5ae49cc8ffb169c40b8e27c" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Texture2DInputMaterialSlot", + "m_ObjectId": "decdf89d9b1c47e49e07623e017ab4f8", + "m_Id": 1, + "m_DisplayName": "Texture", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "Texture", + "m_StageCapability": 3, + "m_BareResource": false, + "m_Texture": { + "m_SerializedTexture": "{\"texture\":{\"instanceID\":0}}", + "m_Guid": "" + }, + "m_DefaultType": 0 +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.PropertyNode", + "m_ObjectId": "e00fd7cf1bf84eb8af3423a5f84f02da", + "m_Group": { + "m_Id": "" + }, + "m_Name": "Property", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -563.0, + "y": 618.0, + "width": 207.0, + "height": 34.0 + } + }, + "m_Slots": [ + { + "m_Id": "1846dfbb5b1441829b77365754ab377d" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_Property": { + "m_Id": "629bfa855bb345f5b11dd44954fbddba" + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector4MaterialSlot", + "m_ObjectId": "e1b8260eccc44d31ab1d3217779a2c4d", + "m_Id": 0, + "m_DisplayName": "RGBA", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "RGBA", + "m_StageCapability": 2, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.SampleTexture2DNode", + "m_ObjectId": "e2bec6c3826047c8a8ca759c60bb19ff", + "m_Group": { + "m_Id": "" + }, + "m_Name": "Sample Texture 2D", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -1672.0, + "y": 114.0, + "width": 184.0, + "height": 253.00001525878907 + } + }, + "m_Slots": [ + { + "m_Id": "2cee3bb09b784906b68914fdfd279c7d" + }, + { + "m_Id": "83ccede77bf347b5ada7f22a90a71e54" + }, + { + "m_Id": "08ccc7ab660441e99b582e3f493ce062" + }, + { + "m_Id": "11b80c01acff493e8d25da0eeae5b521" + }, + { + "m_Id": "15a95450e5e046cbb66c50e363aa6f5c" + }, + { + "m_Id": "645f90c185f2471d9630858b570a39ca" + }, + { + "m_Id": "f8768b5697a64470ae1a4e107cec1277" + }, + { + "m_Id": "46c045243fd947a3bf8f480d04000881" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_TextureType": 1, + "m_NormalMapSpace": 0 +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "e30d33c3db434bae88da4c3b97aae575", + "m_Id": 2, + "m_DisplayName": "Out", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "e620d929496248c68291cd132b8cf818", + "m_Id": 0, + "m_DisplayName": "Secondary Smoothness", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicValueMaterialSlot", + "m_ObjectId": "e7665d3760434dc88e41ba34f6d09177", + "m_Id": 2, + "m_DisplayName": "Out", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": { + "e00": 0.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 0.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 0.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 0.0 + }, + "m_DefaultValue": { + "e00": 1.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 1.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 1.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.BlockNode", + "m_ObjectId": "e7adb047317f4e8f97e8758b79640e35", + "m_Group": { + "m_Id": "" + }, + "m_Name": "SurfaceDescription.RimTransmissionIntensity", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": 81.0, + "y": 375.0, + "width": 200.0, + "height": 41.0 + } + }, + "m_Slots": [ + { + "m_Id": "af325e529f144f119f865552aeb01d6b" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_SerializedDescriptor": "SurfaceDescription.RimTransmissionIntensity" +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.SamplerStateMaterialSlot", + "m_ObjectId": "e97c3fa8ab4d480faefb7391b4a9c808", + "m_Id": 3, + "m_DisplayName": "Sampler", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "Sampler", + "m_StageCapability": 3, + "m_BareResource": false +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "e9bda8c3d270475490b2b7838f87a7de", + "m_Id": 0, + "m_DisplayName": "Specular Multiplier", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Texture2DInputMaterialSlot", + "m_ObjectId": "ea85740a0e1e4ec5bcd3084711e2da2f", + "m_Id": 1, + "m_DisplayName": "Texture", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "Texture", + "m_StageCapability": 3, + "m_BareResource": false, + "m_Texture": { + "m_SerializedTexture": "{\"texture\":{\"instanceID\":0}}", + "m_Guid": "" + }, + "m_DefaultType": 3 +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "eac54b5f186d486e80825976e56c5237", + "m_Id": 1, + "m_DisplayName": "", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.PropertyNode", + "m_ObjectId": "eba48f1e544d455986b250277b538909", + "m_Group": { + "m_Id": "" + }, + "m_Name": "Property", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -498.00006103515627, + "y": 292.0, + "width": 143.0, + "height": 34.0 + } + }, + "m_Slots": [ + { + "m_Id": "ba480ecbddef4b438d53b2d86976cab9" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_Property": { + "m_Id": "d5ea19d7fc704761908396f642de59c8" + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.PropertyNode", + "m_ObjectId": "ed083dc9dc3c4f5fa9248d1b99d92da4", + "m_Group": { + "m_Id": "" + }, + "m_Name": "Property", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -556.0, + "y": 582.0, + "width": 200.0, + "height": 34.0 + } + }, + "m_Slots": [ + { + "m_Id": "e620d929496248c68291cd132b8cf818" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_Property": { + "m_Id": "ed8f4e5d62a34a71a82aedc1436a6cae" + } +} + +{ + "m_SGVersion": 1, + "m_Type": "UnityEditor.ShaderGraph.Internal.Vector1ShaderProperty", + "m_ObjectId": "ed8f4e5d62a34a71a82aedc1436a6cae", + "m_Guid": { + "m_GuidSerialized": "4d72e239-9ff8-45d3-ae3a-d432cdd807b0" + }, + "m_Name": "Secondary Smoothness", + "m_DefaultReferenceName": "", + "m_OverrideReferenceName": "_SecondarySmoothness", + "m_GeneratePropertyBlock": true, + "m_Precision": 0, + "overrideHLSLDeclaration": false, + "hlslDeclarationOverride": 0, + "m_Hidden": false, + "m_Value": 0.5, + "m_FloatType": 1, + "m_RangeValues": { + "x": 0.0, + "y": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Texture2DMaterialSlot", + "m_ObjectId": "ee9cd55adc774c31a6f4699792680829", + "m_Id": 0, + "m_DisplayName": "Flow Map", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_BareResource": false +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.ColorRGBMaterialSlot", + "m_ObjectId": "efd248053249470994c19338779f963b", + "m_Id": 0, + "m_DisplayName": "Base Color", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "BaseColor", + "m_StageCapability": 2, + "m_Value": { + "x": 0.5, + "y": 0.5, + "z": 0.5 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0 + }, + "m_Labels": [], + "m_ColorMode": 0, + "m_DefaultColor": { + "r": 0.5, + "g": 0.5, + "b": 0.5, + "a": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.UVMaterialSlot", + "m_ObjectId": "f04fd49f51ba4fb684bf9e7cfe737a4c", + "m_Id": 2, + "m_DisplayName": "UV", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "UV", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0 + }, + "m_Labels": [], + "m_Channel": 0 +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "f0cfa449191f4171b27dcc76ab6a2da1", + "m_Id": 1, + "m_DisplayName": "Out", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.BlockNode", + "m_ObjectId": "f0eca0bb90df4ad88ca3cef5c34fc766", + "m_Group": { + "m_Id": "" + }, + "m_Name": "SurfaceDescription.AlphaClipThresholdDepthPostpass", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": 0.0, + "y": 0.0, + "width": 0.0, + "height": 0.0 + } + }, + "m_Slots": [ + { + "m_Id": "3ead7aeb80554142b1b8acd0ff2e0d13" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_SerializedDescriptor": "SurfaceDescription.AlphaClipThresholdDepthPostpass" +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.PropertyNode", + "m_ObjectId": "f15873d7cae54a328809df9a8d76bbf7", + "m_Group": { + "m_Id": "" + }, + "m_Name": "Property", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -1852.0, + "y": 728.0, + "width": 149.0, + "height": 34.0 + } + }, + "m_Slots": [ + { + "m_Id": "f4ab81528cf24272a9605474cff4b6b0" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_Property": { + "m_Id": "b304178995574d4b8dceaf0eade7e621" + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "f27d637587474cacb94bfd396d77089d", + "m_Id": 5, + "m_DisplayName": "G", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "G", + "m_StageCapability": 2, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "f2ad0036164a41018d0e761ccde52714", + "m_Id": 1, + "m_DisplayName": "", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Texture2DMaterialSlot", + "m_ObjectId": "f4ab81528cf24272a9605474cff4b6b0", + "m_Id": 0, + "m_DisplayName": "Normal Map", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_BareResource": false +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.Rendering.HighDefinition.ShaderGraph.HairData", + "m_ObjectId": "f5f54dac45ca4f98b35bfd8055240a0f", + "m_MaterialType": 0, + "m_UseLightFacingNormal": false +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector4MaterialSlot", + "m_ObjectId": "f6e8c313d5084dee886ad054638ec381", + "m_Id": 0, + "m_DisplayName": "Out", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "f766d98305ef4a969d378fbe95628bb8", + "m_Id": 3, + "m_DisplayName": "Dither", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "DITHER", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.PropertyNode", + "m_ObjectId": "f769abb9b5a74ec89369a250e2c8d39b", + "m_Group": { + "m_Id": "" + }, + "m_Name": "Property", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -1201.0, + "y": 487.00006103515627, + "width": 146.00001525878907, + "height": 34.0 + } + }, + "m_Slots": [ + { + "m_Id": "28e5ad56a0cc4bd3acbf0cf95dafcd99" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_Property": { + "m_Id": "1728986d8b5d4a60a610dc8f863ef11d" + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "f84ab63ad59d473790240bbae5312104", + "m_Id": 0, + "m_DisplayName": "Normal Strength", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.UVMaterialSlot", + "m_ObjectId": "f8768b5697a64470ae1a4e107cec1277", + "m_Id": 2, + "m_DisplayName": "UV", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "UV", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0 + }, + "m_Labels": [], + "m_Channel": 0 +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.Rendering.HighDefinition.ShaderGraph.BuiltinData", + "m_ObjectId": "f907ec2614f64fee9511dbed58f101b9", + "m_Distortion": false, + "m_DistortionMode": 0, + "m_DistortionDepthTest": true, + "m_AddPrecomputedVelocity": false, + "m_TransparentWritesMotionVec": false, + "m_AlphaToMask": true, + "m_DepthOffset": false, + "m_TransparencyFog": true, + "m_AlphaTestShadow": true, + "m_BackThenFrontRendering": true, + "m_TransparentDepthPrepass": true, + "m_TransparentDepthPostpass": true, + "m_SupportLodCrossFade": false +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicValueMaterialSlot", + "m_ObjectId": "faa11926f42c42ea8e9f2f14d3afd2b2", + "m_Id": 2, + "m_DisplayName": "Out", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": { + "e00": 0.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 0.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 0.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 0.0 + }, + "m_DefaultValue": { + "e00": 1.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 1.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 1.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "fbabbd7d9e264747b9ec6a8f021bc5d7", + "m_Id": 1, + "m_DisplayName": "", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.PositionMaterialSlot", + "m_ObjectId": "fc09e913712c46d780c50a50e6df747c", + "m_Id": 0, + "m_DisplayName": "Position", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "Position", + "m_StageCapability": 1, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0 + }, + "m_Labels": [], + "m_Space": 0 +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "fca9ffe88cae49efa8c33c1354e48c1d", + "m_Id": 6, + "m_DisplayName": "B", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "B", + "m_StageCapability": 2, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.SampleTexture2DNode", + "m_ObjectId": "fe251668acaf4cc1a186f88895925031", + "m_Group": { + "m_Id": "72585dd91b3d4da7b55123bae128c48b" + }, + "m_Name": "Sample Texture 2D", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -2319.0, + "y": -829.9999389648438, + "width": 184.0, + "height": 253.00001525878907 + } + }, + "m_Slots": [ + { + "m_Id": "e1b8260eccc44d31ab1d3217779a2c4d" + }, + { + "m_Id": "6b5deda71f474aee97807127ea957961" + }, + { + "m_Id": "5c85d658386b4b13bd3a308504910663" + }, + { + "m_Id": "c47e9f8f06464bcaba87ddfdec2550d1" + }, + { + "m_Id": "6f484dea1069470eb479d882654b3ea7" + }, + { + "m_Id": "05fbfae444844c6fba5d11a68dde77d9" + }, + { + "m_Id": "1e559a52f2cf4d6282a91a6f552dfcb8" + }, + { + "m_Id": "ae6aeab78fad43109257fd5685aca7ad" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_TextureType": 0, + "m_NormalMapSpace": 0 +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.BlockNode", + "m_ObjectId": "fe4907798c1644289607e0d2603a9a68", + "m_Group": { + "m_Id": "" + }, + "m_Name": "VertexDescription.Tangent", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": 0.0, + "y": 0.0, + "width": 0.0, + "height": 0.0 + } + }, + "m_Slots": [ + { + "m_Id": "36a7e27cf2f142179340d6911fb6702e" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_SerializedDescriptor": "VertexDescription.Tangent" +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.BlockNode", + "m_ObjectId": "fe89101ff92d49e9a630a987e854fb0a", + "m_Group": { + "m_Id": "" + }, + "m_Name": "SurfaceDescription.AlphaClipThresholdShadow", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": 86.0, + "y": 298.0, + "width": 200.0, + "height": 41.0 + } + }, + "m_Slots": [ + { + "m_Id": "a2b446a108624f4ea43455c92d25610e" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_SerializedDescriptor": "SurfaceDescription.AlphaClipThresholdShadow" +} + diff --git a/HDRP/Shaders/RL_HairShaderBaked_HDRP.shadergraph.meta b/HDRP/Shaders/RL_HairShaderBaked_HDRP.shadergraph.meta new file mode 100644 index 0000000..2908409 --- /dev/null +++ b/HDRP/Shaders/RL_HairShaderBaked_HDRP.shadergraph.meta @@ -0,0 +1,10 @@ +fileFormatVersion: 2 +guid: a081e115c7c82634aa606dafdcb27d08 +ScriptedImporter: + internalIDToNameTable: [] + externalObjects: {} + serializedVersion: 2 + userData: + assetBundleName: + assetBundleVariant: + script: {fileID: 11500000, guid: 625f186215c104763be7675aa2d941aa, type: 3} diff --git a/HDRP/Shaders/RL_HairShaderVariants_HDRP.shadergraph b/HDRP/Shaders/RL_HairShaderVariants_HDRP.shadergraph new file mode 100644 index 0000000..ff1dda2 --- /dev/null +++ b/HDRP/Shaders/RL_HairShaderVariants_HDRP.shadergraph @@ -0,0 +1,18694 @@ +{ + "m_SGVersion": 2, + "m_Type": "UnityEditor.ShaderGraph.GraphData", + "m_ObjectId": "a316bd3ad5b24db79164c15659fdb4d3", + "m_Properties": [ + { + "m_Id": "62ba90b39c554829b983338182c6db53" + }, + { + "m_Id": "6dc6a8e2ab304a639656ee2082845e1c" + }, + { + "m_Id": "ac27b0d8beef493a80956330658fb3e7" + }, + { + "m_Id": "b304178995574d4b8dceaf0eade7e621" + }, + { + "m_Id": "bc814cd1e05d4e94b3b180cbe5f42bfd" + }, + { + "m_Id": "1f7de34ad6cf475f840313717441d77c" + }, + { + "m_Id": "72d65bc7d4664f6aae2853e9a0fcb1e9" + }, + { + "m_Id": "2f97d87b4e54435a8e9aab991aa2ca95" + }, + { + "m_Id": "a07bfbc05b904ff6b24292a9d830a741" + }, + { + "m_Id": "9797716d61f541a994b33c73d00c450a" + }, + { + "m_Id": "a89b7eb5908949b7a8ff733c487aa014" + }, + { + "m_Id": "da00c269686246c39fbda3af5e79189b" + }, + { + "m_Id": "c89f13cfecbd4fdb8a873b05073b0e11" + }, + { + "m_Id": "a8fac80485344a489b31db2a226e0489" + }, + { + "m_Id": "5ef8aef8a81b4183b2aa03d38ada5d75" + }, + { + "m_Id": "b638b475ea844c8f953ca43f5b9f3316" + }, + { + "m_Id": "34d0f0bff6e74c40b4cf4609487b8cd6" + }, + { + "m_Id": "9194e285b5944b798d84abcebaa562f1" + }, + { + "m_Id": "d962fe658f9a4982b62bd75d03b2276e" + }, + { + "m_Id": "d5ea19d7fc704761908396f642de59c8" + }, + { + "m_Id": "7a9dca43a15c41859b95c7edb930b3db" + }, + { + "m_Id": "1b66a7533fa643888276c4f6de382ca9" + }, + { + "m_Id": "2d574f97db4a422aa1faa8f38ef8ab5f" + }, + { + "m_Id": "1fc40334fcb74e05a6f086c3e4645288" + }, + { + "m_Id": "b2b5bf0810fd490d81e06a42ff3ba8ed" + }, + { + "m_Id": "f2294eaa0dfc4e4a83519ed20321e66d" + }, + { + "m_Id": "f3db2a837d7d47aea3d00d54af30b29d" + }, + { + "m_Id": "a6fa4ad2f38b44f991f1e519e0cfd03c" + }, + { + "m_Id": "a6f49c7b1ba2462aa864ed200a6a2b11" + }, + { + "m_Id": "7a7ff89b265c40a9aeaad4f27130fb28" + }, + { + "m_Id": "a63d692b98084be8b8748b7cd4391a19" + }, + { + "m_Id": "ab6f8c0fc8fc4dd78cf1810dbf288488" + }, + { + "m_Id": "05cd8ff0d3ab48a7b776a221ff36b8ad" + }, + { + "m_Id": "2824b0c4fe6c4ff3b6d72dcfe453a320" + }, + { + "m_Id": "1eba045aa0eb497597cd205664aeb8ec" + }, + { + "m_Id": "f832572ded9b45b69c1711ca629a49f1" + }, + { + "m_Id": "77ed3559eef14481b5a4ecb0f498dd93" + }, + { + "m_Id": "8e1a9a245d834611bbba5516f764638c" + }, + { + "m_Id": "7f66c6abce0e4576b0c98c2f4e19050c" + }, + { + "m_Id": "56ba91985bbb4952a91b73ed158b776b" + }, + { + "m_Id": "d0cb7f74d07a479c8d2528bb0485e008" + }, + { + "m_Id": "5d4c697aa2e74bdbb12725c42b2313e7" + }, + { + "m_Id": "1728986d8b5d4a60a610dc8f863ef11d" + }, + { + "m_Id": "7ad41145b0c646049037af434d423fc6" + }, + { + "m_Id": "a73bbe07bf634ae6a2f595dac0d74ea3" + }, + { + "m_Id": "8197dc419ed34d5e8c22c7c35775566a" + }, + { + "m_Id": "629bfa855bb345f5b11dd44954fbddba" + }, + { + "m_Id": "ed8f4e5d62a34a71a82aedc1436a6cae" + }, + { + "m_Id": "ddc2f22573d241e787bf84f06e4ba049" + } + ], + "m_Keywords": [ + { + "m_Id": "a9c42cd3aa674f4b8cd880751469f0f3" + }, + { + "m_Id": "d7616bdb7fec4d338db92ff5b42d8172" + } + ], + "m_Nodes": [ + { + "m_Id": "2704a97326044be09a54d3e3810db15f" + }, + { + "m_Id": "0b7af971d63e4166afd190de3b9e9172" + }, + { + "m_Id": "fe4907798c1644289607e0d2603a9a68" + }, + { + "m_Id": "d0f957ba1d13421b96ab67ec531eefa7" + }, + { + "m_Id": "ca5e280a68af4a45a358d1f7b9cff2e2" + }, + { + "m_Id": "76ac26031b7c43a6a78d7e9db5db64be" + }, + { + "m_Id": "8277bdd1ba5e486788875b590047b626" + }, + { + "m_Id": "687659d5f2844131913f3ebec5692c99" + }, + { + "m_Id": "43b2f53e22494f52ad836aba700da7c7" + }, + { + "m_Id": "358a13893c98426abb6bc4c3984c2dc8" + }, + { + "m_Id": "5f984a05a60b4f76afa0ec01041e1d96" + }, + { + "m_Id": "5bc2e2ebb6e84033be0c02d88425a9d9" + }, + { + "m_Id": "4e86ff273f104b47a35a04b03339a9d7" + }, + { + "m_Id": "f15873d7cae54a328809df9a8d76bbf7" + }, + { + "m_Id": "fe251668acaf4cc1a186f88895925031" + }, + { + "m_Id": "454e8678d7fa4d8583459d67c01c0d1d" + }, + { + "m_Id": "6cf2216245ca4c94a226d2a52deb5633" + }, + { + "m_Id": "af7e3800e2f34908a3a77b8948d2fd32" + }, + { + "m_Id": "91e279bc4ab24de6baf584d64e36b2ae" + }, + { + "m_Id": "fe89101ff92d49e9a630a987e854fb0a" + }, + { + "m_Id": "883fa0154dc245788e90a0983dac686e" + }, + { + "m_Id": "e7adb047317f4e8f97e8758b79640e35" + }, + { + "m_Id": "a61b9632fcd344bbb50f017fe9662523" + }, + { + "m_Id": "bc220c2be8a74249ac65d93a8ae5cbdf" + }, + { + "m_Id": "2b74cde8bed7456b968b7b795a741d50" + }, + { + "m_Id": "4239ae5618e54aada26f71dc47c73c18" + }, + { + "m_Id": "2643e290df8a4963bc3741b72302fe4f" + }, + { + "m_Id": "04aea1edd8694d7f84d7852ec4078ce2" + }, + { + "m_Id": "9fe0bae8095e488fab536e1bbc11bb66" + }, + { + "m_Id": "860c97ed98f348e0942b9e5eb0916c14" + }, + { + "m_Id": "5b7fb36f8a124e63b24b1f4891c7d268" + }, + { + "m_Id": "6b630368d3bb456ca8c23ca7e50298d2" + }, + { + "m_Id": "d007bea8b7874cd3983c3448fe35b232" + }, + { + "m_Id": "32d9e2980d2647e9865f97b452ae9e72" + }, + { + "m_Id": "eba48f1e544d455986b250277b538909" + }, + { + "m_Id": "e0b7f015d0b949be87c33efde8fa3b69" + }, + { + "m_Id": "2b1f8f17f34d4d07bfa9a061a97ed745" + }, + { + "m_Id": "e2bec6c3826047c8a8ca759c60bb19ff" + }, + { + "m_Id": "f769abb9b5a74ec89369a250e2c8d39b" + }, + { + "m_Id": "627b5ab6400f4b94ae60bfcab74b4ab5" + }, + { + "m_Id": "151656766f524322aecfdf73999cda54" + }, + { + "m_Id": "e00fd7cf1bf84eb8af3423a5f84f02da" + }, + { + "m_Id": "ed083dc9dc3c4f5fa9248d1b99d92da4" + }, + { + "m_Id": "b3602abd3e6c4110bd7c0c759e4b9c20" + }, + { + "m_Id": "f0eca0bb90df4ad88ca3cef5c34fc766" + }, + { + "m_Id": "72d4a986e38a498bae8f34613460f37e" + }, + { + "m_Id": "60f1e7e5998d42d5be5bf1c40597f04f" + }, + { + "m_Id": "30fe193f31ba43ba9fef9f94f9cd4c10" + }, + { + "m_Id": "20ec913f194d4acd871be539f0ceffd0" + }, + { + "m_Id": "a95c92619dc0485d83dce69c60ceca6d" + }, + { + "m_Id": "6c82b6ddafb64673b5161a23abfc93e4" + }, + { + "m_Id": "b158210403a647c485660b84c2aaa857" + }, + { + "m_Id": "8fa9e59236e64861945859b2bb07fb53" + }, + { + "m_Id": "601c6eaea0204053a13a8ac70dd09d06" + }, + { + "m_Id": "aa3b6d90bb2d442e989158ba90f12906" + }, + { + "m_Id": "6069340092004c1191a211a8d3274b3d" + }, + { + "m_Id": "debaaee10b654011933a2346630b5137" + }, + { + "m_Id": "9654b153a4f246f899a7ce0aab379a79" + }, + { + "m_Id": "8c8d7b4a3900435e88cf2280ae4ada94" + }, + { + "m_Id": "51595b2e0ca547c0a312a7b88240ed30" + }, + { + "m_Id": "114b289fef094d4fb9b6da23caaeb079" + }, + { + "m_Id": "b337e8061fa24e6bb1d267bc90b18e02" + }, + { + "m_Id": "c896751d379b48b793ac05bbc6687f65" + }, + { + "m_Id": "a4abc46300494294b321ea368512e48c" + }, + { + "m_Id": "8a2128b069e046c9992344d5c8d7f5c8" + }, + { + "m_Id": "eb866c4039374f098844e0d54b0d2c13" + }, + { + "m_Id": "1580b7ab05d74620b015c851f432a785" + }, + { + "m_Id": "de2a22dd96324e7992af5f4b781aec04" + }, + { + "m_Id": "d0cc3b3b53f440678f753c7d24288c01" + }, + { + "m_Id": "3b743ddc9ad64097a3679e91b83ab546" + }, + { + "m_Id": "0569c2035ccd497a872ea10ea40d4e43" + }, + { + "m_Id": "aebc93c2df364b09b9e5468dfa8ac99b" + }, + { + "m_Id": "030f5fb2b7a44537b270b4c404971915" + }, + { + "m_Id": "6b2e66277a7943f5800e4557cd983757" + }, + { + "m_Id": "8dc18247ab4b4e5caf09faf953798497" + }, + { + "m_Id": "6e7f71ec59fb413b942f9ce72cf1967c" + }, + { + "m_Id": "d2920db565474984a8eae456eca16597" + }, + { + "m_Id": "07affa6d03af4e71be5df2863dc3cf00" + }, + { + "m_Id": "106c4319f0c8421a9295b557df9f94a3" + }, + { + "m_Id": "28e145da8a3747de8be1fbeb7dbc5cae" + }, + { + "m_Id": "ac0c1810cc7b43eca36a78a32992055e" + }, + { + "m_Id": "f82f65e9659e476a81e3fd01ec59c77d" + }, + { + "m_Id": "6f6152d8538648468b848cd049b3d36d" + }, + { + "m_Id": "86455e4666b643bf91cfbaf131d45eb1" + }, + { + "m_Id": "2c24de69dbf540b1be983740c589ab5a" + }, + { + "m_Id": "d2e83ab99d6c4bf48651e111f4c6e88b" + }, + { + "m_Id": "a092fae44e0b454cb3b18c1769b66a72" + }, + { + "m_Id": "815740e575684a18ae4f7aced285fb16" + }, + { + "m_Id": "d971314bc5f54cdab9c09233077b1881" + }, + { + "m_Id": "c11ee2e3010d48a9a45e803c58cceaa3" + }, + { + "m_Id": "45445a2f270b47348746e62d75ebd6c7" + }, + { + "m_Id": "fdc1fb91fa83476caa363209cb103fd5" + }, + { + "m_Id": "a9b949905222445081591fa1fd11be88" + }, + { + "m_Id": "d2a1a0932aa14dd0b783f2ed23c7be39" + }, + { + "m_Id": "f4274b5ff3ad4120a550c1bfb31fe327" + }, + { + "m_Id": "6ecff3af82ac40418c956f8a38fda7d3" + }, + { + "m_Id": "bfcbbb8f16894a09b2943bd4af0e7e17" + }, + { + "m_Id": "26c479b9431748d3ada12cae1f15805e" + }, + { + "m_Id": "2f6eee5e06e14a1e92aaeb7d8f08d5ac" + }, + { + "m_Id": "04af8ce2ede54180b9c27045bc9d754e" + }, + { + "m_Id": "bad53b94aae6409696fad7c2840f0972" + }, + { + "m_Id": "b61ad6685d834336a04cd2ba0d129607" + }, + { + "m_Id": "414946c7e4fa4c1cb0a557ded20ecba2" + }, + { + "m_Id": "b86246fa0fff40a284f03275fff93bcf" + }, + { + "m_Id": "c24cb266ce15442eb0f5153676058cf1" + }, + { + "m_Id": "f2b7d300cc4c41a09579db62531aa14a" + }, + { + "m_Id": "2f84847c491547739e60664b75884634" + }, + { + "m_Id": "e37f421af20040a6bf27c01f0c1ea39e" + }, + { + "m_Id": "2df3c191066849dea8989f82ffc388f4" + }, + { + "m_Id": "b5033b6eae774ee281774f8a5ebd6867" + }, + { + "m_Id": "1e6a1a093dfc4253ab60cb89cdbd500a" + }, + { + "m_Id": "c2f112e363d049f68f0c3b3031c18f06" + }, + { + "m_Id": "866a17817870451e9971f9f71e910e19" + }, + { + "m_Id": "9f627f64b90e48a5891d127f88ac4c50" + }, + { + "m_Id": "a690192754a849e589743764dd23ed67" + }, + { + "m_Id": "69305a34e02b4af4bbb8430ee60baa8f" + }, + { + "m_Id": "89491350ac6841c3a2b4c3034afd4d94" + }, + { + "m_Id": "37d47e939df243e19df140caeabc6088" + }, + { + "m_Id": "00b0c6f8a9d74c8dac48bfde16ff2e40" + }, + { + "m_Id": "5b2deb6b50d54492944439b12c257cfa" + }, + { + "m_Id": "f43a277c26e34eee8f21c22daafd4054" + }, + { + "m_Id": "5cd5b507a13647d4a17df6f6a63455bc" + }, + { + "m_Id": "d135a9d074e34f8a82f5f778a5fc8a77" + }, + { + "m_Id": "a336e37bead841ab80818f6c8488f3aa" + }, + { + "m_Id": "ad570f188c754df88dfa5790b811ca07" + }, + { + "m_Id": "e00715f93656411ba7edbb256c828294" + }, + { + "m_Id": "c3875f35cac14d3ab6d3ae545d281df7" + }, + { + "m_Id": "7f3672a3eba44aecb5dec9bdd7ea6ca3" + }, + { + "m_Id": "51bf0ed28e374cbe8ac7e34dab4a7ba2" + }, + { + "m_Id": "f78692b5ae6b4dc3b9e2333153a1ac99" + }, + { + "m_Id": "81429d7c3ed74f599b76aa7b8bfe9c7f" + }, + { + "m_Id": "ac6803728e7549dd87a233c309559c0a" + }, + { + "m_Id": "4664443c430b46538a01bbf9ce9ce1fc" + }, + { + "m_Id": "e1da77b3145d43e9a95e681afd6c3b82" + }, + { + "m_Id": "fa23d0762b1842e38b1ce87344837242" + }, + { + "m_Id": "7885d7a85a524469bed829c26fcc314a" + }, + { + "m_Id": "9f8c21dd3c144973a99de8440ff1910d" + }, + { + "m_Id": "4be5e95fcd374b61bd561cf5a7bec49a" + }, + { + "m_Id": "1f325b3e26a640949036a22e6af17a00" + }, + { + "m_Id": "7a473df09e9b4bd3b82814666640158f" + }, + { + "m_Id": "366fe14bae29480a8d870a61047f38bf" + }, + { + "m_Id": "6ae52db55a2846f28176b9aa785e3cb4" + }, + { + "m_Id": "6d00c754a1b5489990a6a6f802a8492c" + }, + { + "m_Id": "d39a9113840a4a86b90ff79526878a19" + }, + { + "m_Id": "cd5616f7b08c4b37bb7a7b56afc8ca2b" + }, + { + "m_Id": "a55dd75f45944956a01d8fd91c85994a" + }, + { + "m_Id": "d875584c381349c8be1fd7ec51b347ee" + }, + { + "m_Id": "68ff830c789148479896d5d8c55d6283" + }, + { + "m_Id": "1a2f023d4d4640a597aa9599903ca696" + }, + { + "m_Id": "e8e39fa5d225482fbd621c6cd82b6e5a" + }, + { + "m_Id": "520e6dc597e44dc9bebe93b078837c7b" + }, + { + "m_Id": "aaa78c08909d49449406d49a312d31a3" + }, + { + "m_Id": "e914554d54e64faf9720389438495a70" + }, + { + "m_Id": "77356f6efe684b15bacc81e99c0fc187" + }, + { + "m_Id": "c82337ad5b6a41fba467321b6a383a9f" + }, + { + "m_Id": "dd6f6572051e4d659f72bb5b91baefdc" + }, + { + "m_Id": "ac70eb9a271a4e2eb7c2e15fb1d4c989" + }, + { + "m_Id": "b8e284dd58dd45a6b6c14058a8baffad" + }, + { + "m_Id": "4a5109af1dce4a4ba5e917126d8eb1ab" + }, + { + "m_Id": "1470e378ade24d0380105fd3f3278773" + }, + { + "m_Id": "992ac25d9f3d4157a9e18ffb29f0b5ba" + }, + { + "m_Id": "22b41ca9fba047ea8d41791afecc4b1b" + }, + { + "m_Id": "0917d75185d9443586c46f1f88fff814" + } + ], + "m_GroupDatas": [ + { + "m_Id": "72585dd91b3d4da7b55123bae128c48b" + }, + { + "m_Id": "b773332f12a640f2961cff577b07701f" + }, + { + "m_Id": "be2cb7795a6143a498576442f64713d6" + }, + { + "m_Id": "b3823636393244d99c581f1785baf857" + }, + { + "m_Id": "4754e47d61844a86908699d8a6f31a28" + }, + { + "m_Id": "244280d6eea94f08bb23a8e3db3784a3" + }, + { + "m_Id": "03640179a61e456c8a3f77f11616681e" + }, + { + "m_Id": "3aedb1a4a3f540528911bf5344ee2e15" + }, + { + "m_Id": "184a4bbd54744e36ac8fcee9b32aafbf" + }, + { + "m_Id": "0e8b3d01fbd24a99bdb2e8e85a456a90" + }, + { + "m_Id": "1bf156e34830433f9d5347d334ce2f5d" + }, + { + "m_Id": "0da3d5800b834357824042477eb483dd" + } + ], + "m_StickyNoteDatas": [ + { + "m_Id": "c3448cd8492948db8adf7a079b6fcd8e" + } + ], + "m_Edges": [ + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "00b0c6f8a9d74c8dac48bfde16ff2e40" + }, + "m_SlotId": 1 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "69305a34e02b4af4bbb8430ee60baa8f" + }, + "m_SlotId": 3 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "030f5fb2b7a44537b270b4c404971915" + }, + "m_SlotId": 1 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "a61b9632fcd344bbb50f017fe9662523" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "04af8ce2ede54180b9c27045bc9d754e" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "bad53b94aae6409696fad7c2840f0972" + }, + "m_SlotId": 1 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "0569c2035ccd497a872ea10ea40d4e43" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "3b743ddc9ad64097a3679e91b83ab546" + }, + "m_SlotId": 1 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "07affa6d03af4e71be5df2863dc3cf00" + }, + "m_SlotId": 1 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "43b2f53e22494f52ad836aba700da7c7" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "0917d75185d9443586c46f1f88fff814" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "22b41ca9fba047ea8d41791afecc4b1b" + }, + "m_SlotId": 3 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "106c4319f0c8421a9295b557df9f94a3" + }, + "m_SlotId": 1 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "91e279bc4ab24de6baf584d64e36b2ae" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "114b289fef094d4fb9b6da23caaeb079" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "8c8d7b4a3900435e88cf2280ae4ada94" + }, + "m_SlotId": 1 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "1470e378ade24d0380105fd3f3278773" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "992ac25d9f3d4157a9e18ffb29f0b5ba" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "151656766f524322aecfdf73999cda54" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "2b74cde8bed7456b968b7b795a741d50" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "1580b7ab05d74620b015c851f432a785" + }, + "m_SlotId": 2 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "de2a22dd96324e7992af5f4b781aec04" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "1a2f023d4d4640a597aa9599903ca696" + }, + "m_SlotId": 1 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "e8e39fa5d225482fbd621c6cd82b6e5a" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "1e6a1a093dfc4253ab60cb89cdbd500a" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "b5033b6eae774ee281774f8a5ebd6867" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "1f325b3e26a640949036a22e6af17a00" + }, + "m_SlotId": 2 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "bc220c2be8a74249ac65d93a8ae5cbdf" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "20ec913f194d4acd871be539f0ceffd0" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "30fe193f31ba43ba9fef9f94f9cd4c10" + }, + "m_SlotId": 1 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "22b41ca9fba047ea8d41791afecc4b1b" + }, + "m_SlotId": 2 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "4a5109af1dce4a4ba5e917126d8eb1ab" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "26c479b9431748d3ada12cae1f15805e" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "77356f6efe684b15bacc81e99c0fc187" + }, + "m_SlotId": 1 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "28e145da8a3747de8be1fbeb7dbc5cae" + }, + "m_SlotId": 1 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "b3602abd3e6c4110bd7c0c759e4b9c20" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "2b1f8f17f34d4d07bfa9a061a97ed745" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "e2bec6c3826047c8a8ca759c60bb19ff" + }, + "m_SlotId": 1 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "2c24de69dbf540b1be983740c589ab5a" + }, + "m_SlotId": 4 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "51bf0ed28e374cbe8ac7e34dab4a7ba2" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "2c24de69dbf540b1be983740c589ab5a" + }, + "m_SlotId": 4 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "a690192754a849e589743764dd23ed67" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "2df3c191066849dea8989f82ffc388f4" + }, + "m_SlotId": 1 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "f43a277c26e34eee8f21c22daafd4054" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "2f6eee5e06e14a1e92aaeb7d8f08d5ac" + }, + "m_SlotId": 1 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "bad53b94aae6409696fad7c2840f0972" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "2f84847c491547739e60664b75884634" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "68ff830c789148479896d5d8c55d6283" + }, + "m_SlotId": 2 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "30fe193f31ba43ba9fef9f94f9cd4c10" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "106c4319f0c8421a9295b557df9f94a3" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "32d9e2980d2647e9865f97b452ae9e72" + }, + "m_SlotId": 2 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "4a5109af1dce4a4ba5e917126d8eb1ab" + }, + "m_SlotId": 3 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "366fe14bae29480a8d870a61047f38bf" + }, + "m_SlotId": 2 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "4239ae5618e54aada26f71dc47c73c18" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "37d47e939df243e19df140caeabc6088" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "c3875f35cac14d3ab6d3ae545d281df7" + }, + "m_SlotId": 1 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "3b743ddc9ad64097a3679e91b83ab546" + }, + "m_SlotId": 2 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "8c8d7b4a3900435e88cf2280ae4ada94" + }, + "m_SlotId": 2 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "414946c7e4fa4c1cb0a557ded20ecba2" + }, + "m_SlotId": 2 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "b61ad6685d834336a04cd2ba0d129607" + }, + "m_SlotId": 1 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "45445a2f270b47348746e62d75ebd6c7" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "c11ee2e3010d48a9a45e803c58cceaa3" + }, + "m_SlotId": 1 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "454e8678d7fa4d8583459d67c01c0d1d" + }, + "m_SlotId": 5 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "eb866c4039374f098844e0d54b0d2c13" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "454e8678d7fa4d8583459d67c01c0d1d" + }, + "m_SlotId": 7 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "aebc93c2df364b09b9e5468dfa8ac99b" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "4664443c430b46538a01bbf9ce9ce1fc" + }, + "m_SlotId": 1 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "520e6dc597e44dc9bebe93b078837c7b" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "4a5109af1dce4a4ba5e917126d8eb1ab" + }, + "m_SlotId": 2 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "8dc18247ab4b4e5caf09faf953798497" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "4be5e95fcd374b61bd561cf5a7bec49a" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "1f325b3e26a640949036a22e6af17a00" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "4e86ff273f104b47a35a04b03339a9d7" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "6cf2216245ca4c94a226d2a52deb5633" + }, + "m_SlotId": 1 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "51595b2e0ca547c0a312a7b88240ed30" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "8c8d7b4a3900435e88cf2280ae4ada94" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "51bf0ed28e374cbe8ac7e34dab4a7ba2" + }, + "m_SlotId": 1 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "e1da77b3145d43e9a95e681afd6c3b82" + }, + "m_SlotId": 4 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "520e6dc597e44dc9bebe93b078837c7b" + }, + "m_SlotId": 1 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "aaa78c08909d49449406d49a312d31a3" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "5b2deb6b50d54492944439b12c257cfa" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "e8e39fa5d225482fbd621c6cd82b6e5a" + }, + "m_SlotId": 1 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "5b7fb36f8a124e63b24b1f4891c7d268" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "b337e8061fa24e6bb1d267bc90b18e02" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "5bc2e2ebb6e84033be0c02d88425a9d9" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "454e8678d7fa4d8583459d67c01c0d1d" + }, + "m_SlotId": 1 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "5cd5b507a13647d4a17df6f6a63455bc" + }, + "m_SlotId": 1 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "4664443c430b46538a01bbf9ce9ce1fc" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "5cd5b507a13647d4a17df6f6a63455bc" + }, + "m_SlotId": 1 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "a336e37bead841ab80818f6c8488f3aa" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "5f984a05a60b4f76afa0ec01041e1d96" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "fe251668acaf4cc1a186f88895925031" + }, + "m_SlotId": 1 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "601c6eaea0204053a13a8ac70dd09d06" + }, + "m_SlotId": 2 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "30fe193f31ba43ba9fef9f94f9cd4c10" + }, + "m_SlotId": 3 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "6069340092004c1191a211a8d3274b3d" + }, + "m_SlotId": 2 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "9654b153a4f246f899a7ce0aab379a79" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "60f1e7e5998d42d5be5bf1c40597f04f" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "c896751d379b48b793ac05bbc6687f65" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "627b5ab6400f4b94ae60bfcab74b4ab5" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "e7adb047317f4e8f97e8758b79640e35" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "68ff830c789148479896d5d8c55d6283" + }, + "m_SlotId": 1 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "b5033b6eae774ee281774f8a5ebd6867" + }, + "m_SlotId": 3 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "69305a34e02b4af4bbb8430ee60baa8f" + }, + "m_SlotId": 2 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "f78692b5ae6b4dc3b9e2333153a1ac99" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "6ae52db55a2846f28176b9aa785e3cb4" + }, + "m_SlotId": 1 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "f82f65e9659e476a81e3fd01ec59c77d" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "6b2e66277a7943f5800e4557cd983757" + }, + "m_SlotId": 1 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "8277bdd1ba5e486788875b590047b626" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "6b630368d3bb456ca8c23ca7e50298d2" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "1470e378ade24d0380105fd3f3278773" + }, + "m_SlotId": 1 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "6c82b6ddafb64673b5161a23abfc93e4" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "a95c92619dc0485d83dce69c60ceca6d" + }, + "m_SlotId": 1 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "6cf2216245ca4c94a226d2a52deb5633" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "d971314bc5f54cdab9c09233077b1881" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "6d00c754a1b5489990a6a6f802a8492c" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "c3875f35cac14d3ab6d3ae545d281df7" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "6e7f71ec59fb413b942f9ce72cf1967c" + }, + "m_SlotId": 1 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "358a13893c98426abb6bc4c3984c2dc8" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "6ecff3af82ac40418c956f8a38fda7d3" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "bfcbbb8f16894a09b2943bd4af0e7e17" + }, + "m_SlotId": 1 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "6f6152d8538648468b848cd049b3d36d" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "f82f65e9659e476a81e3fd01ec59c77d" + }, + "m_SlotId": 1 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "72d4a986e38a498bae8f34613460f37e" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "ac0c1810cc7b43eca36a78a32992055e" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "77356f6efe684b15bacc81e99c0fc187" + }, + "m_SlotId": 2 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "d2a1a0932aa14dd0b783f2ed23c7be39" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "7885d7a85a524469bed829c26fcc314a" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "e1da77b3145d43e9a95e681afd6c3b82" + }, + "m_SlotId": 1 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "7a473df09e9b4bd3b82814666640158f" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "366fe14bae29480a8d870a61047f38bf" + }, + "m_SlotId": 1 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "7f3672a3eba44aecb5dec9bdd7ea6ca3" + }, + "m_SlotId": 1 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "69305a34e02b4af4bbb8430ee60baa8f" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "81429d7c3ed74f599b76aa7b8bfe9c7f" + }, + "m_SlotId": 1 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "f78692b5ae6b4dc3b9e2333153a1ac99" + }, + "m_SlotId": 3 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "815740e575684a18ae4f7aced285fb16" + }, + "m_SlotId": 2 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "1f325b3e26a640949036a22e6af17a00" + }, + "m_SlotId": 1 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "815740e575684a18ae4f7aced285fb16" + }, + "m_SlotId": 2 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "366fe14bae29480a8d870a61047f38bf" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "860c97ed98f348e0942b9e5eb0916c14" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "9fe0bae8095e488fab536e1bbc11bb66" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "86455e4666b643bf91cfbaf131d45eb1" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "2c24de69dbf540b1be983740c589ab5a" + }, + "m_SlotId": 1 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "866a17817870451e9971f9f71e910e19" + }, + "m_SlotId": 2 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "7f3672a3eba44aecb5dec9bdd7ea6ca3" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "89491350ac6841c3a2b4c3034afd4d94" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "69305a34e02b4af4bbb8430ee60baa8f" + }, + "m_SlotId": 1 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "8a2128b069e046c9992344d5c8d7f5c8" + }, + "m_SlotId": 1 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "a95c92619dc0485d83dce69c60ceca6d" + }, + "m_SlotId": 2 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "8c8d7b4a3900435e88cf2280ae4ada94" + }, + "m_SlotId": 3 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "d2920db565474984a8eae456eca16597" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "8dc18247ab4b4e5caf09faf953798497" + }, + "m_SlotId": 1 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "883fa0154dc245788e90a0983dac686e" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "8dc18247ab4b4e5caf09faf953798497" + }, + "m_SlotId": 1 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "d0f957ba1d13421b96ab67ec531eefa7" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "8fa9e59236e64861945859b2bb07fb53" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "601c6eaea0204053a13a8ac70dd09d06" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "9654b153a4f246f899a7ce0aab379a79" + }, + "m_SlotId": 1 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "a95c92619dc0485d83dce69c60ceca6d" + }, + "m_SlotId": 3 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "992ac25d9f3d4157a9e18ffb29f0b5ba" + }, + "m_SlotId": 1 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "32d9e2980d2647e9865f97b452ae9e72" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "9f627f64b90e48a5891d127f88ac4c50" + }, + "m_SlotId": 1 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "866a17817870451e9971f9f71e910e19" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "9f8c21dd3c144973a99de8440ff1910d" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "f78692b5ae6b4dc3b9e2333153a1ac99" + }, + "m_SlotId": 1 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "9fe0bae8095e488fab536e1bbc11bb66" + }, + "m_SlotId": 2 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "a4abc46300494294b321ea368512e48c" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "9fe0bae8095e488fab536e1bbc11bb66" + }, + "m_SlotId": 2 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "b337e8061fa24e6bb1d267bc90b18e02" + }, + "m_SlotId": 1 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "a092fae44e0b454cb3b18c1769b66a72" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "815740e575684a18ae4f7aced285fb16" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "a336e37bead841ab80818f6c8488f3aa" + }, + "m_SlotId": 1 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "1a2f023d4d4640a597aa9599903ca696" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "a4abc46300494294b321ea368512e48c" + }, + "m_SlotId": 2 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "8a2128b069e046c9992344d5c8d7f5c8" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "a55dd75f45944956a01d8fd91c85994a" + }, + "m_SlotId": 2 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "9f627f64b90e48a5891d127f88ac4c50" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "a690192754a849e589743764dd23ed67" + }, + "m_SlotId": 1 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "c3875f35cac14d3ab6d3ae545d281df7" + }, + "m_SlotId": 4 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "a95c92619dc0485d83dce69c60ceca6d" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "28e145da8a3747de8be1fbeb7dbc5cae" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "a9b949905222445081591fa1fd11be88" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "d2a1a0932aa14dd0b783f2ed23c7be39" + }, + "m_SlotId": 1 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "aa3b6d90bb2d442e989158ba90f12906" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "601c6eaea0204053a13a8ac70dd09d06" + }, + "m_SlotId": 1 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "aa3b6d90bb2d442e989158ba90f12906" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "6069340092004c1191a211a8d3274b3d" + }, + "m_SlotId": 1 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "aaa78c08909d49449406d49a312d31a3" + }, + "m_SlotId": 2 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "ac6803728e7549dd87a233c309559c0a" + }, + "m_SlotId": 1 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "ac0c1810cc7b43eca36a78a32992055e" + }, + "m_SlotId": 1 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "f0eca0bb90df4ad88ca3cef5c34fc766" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "ac6803728e7549dd87a233c309559c0a" + }, + "m_SlotId": 2 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "81429d7c3ed74f599b76aa7b8bfe9c7f" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "ac70eb9a271a4e2eb7c2e15fb1d4c989" + }, + "m_SlotId": 2 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "b8e284dd58dd45a6b6c14058a8baffad" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "ad570f188c754df88dfa5790b811ca07" + }, + "m_SlotId": 1 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "6e7f71ec59fb413b942f9ce72cf1967c" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "aebc93c2df364b09b9e5468dfa8ac99b" + }, + "m_SlotId": 1 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "3b743ddc9ad64097a3679e91b83ab546" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "af7e3800e2f34908a3a77b8948d2fd32" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "c11ee2e3010d48a9a45e803c58cceaa3" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "b158210403a647c485660b84c2aaa857" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "debaaee10b654011933a2346630b5137" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "b337e8061fa24e6bb1d267bc90b18e02" + }, + "m_SlotId": 2 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "30fe193f31ba43ba9fef9f94f9cd4c10" + }, + "m_SlotId": 2 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "b5033b6eae774ee281774f8a5ebd6867" + }, + "m_SlotId": 2 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "866a17817870451e9971f9f71e910e19" + }, + "m_SlotId": 1 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "b61ad6685d834336a04cd2ba0d129607" + }, + "m_SlotId": 2 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "c24cb266ce15442eb0f5153676058cf1" + }, + "m_SlotId": 1 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "b86246fa0fff40a284f03275fff93bcf" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "414946c7e4fa4c1cb0a557ded20ecba2" + }, + "m_SlotId": 1 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "b8e284dd58dd45a6b6c14058a8baffad" + }, + "m_SlotId": 1 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "ad570f188c754df88dfa5790b811ca07" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "bad53b94aae6409696fad7c2840f0972" + }, + "m_SlotId": 2 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "b61ad6685d834336a04cd2ba0d129607" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "bfcbbb8f16894a09b2943bd4af0e7e17" + }, + "m_SlotId": 4 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "2f6eee5e06e14a1e92aaeb7d8f08d5ac" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "bfcbbb8f16894a09b2943bd4af0e7e17" + }, + "m_SlotId": 4 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "414946c7e4fa4c1cb0a557ded20ecba2" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "bfcbbb8f16894a09b2943bd4af0e7e17" + }, + "m_SlotId": 4 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "68ff830c789148479896d5d8c55d6283" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "bfcbbb8f16894a09b2943bd4af0e7e17" + }, + "m_SlotId": 4 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "e37f421af20040a6bf27c01f0c1ea39e" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "c11ee2e3010d48a9a45e803c58cceaa3" + }, + "m_SlotId": 2 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "ca5e280a68af4a45a358d1f7b9cff2e2" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "c24cb266ce15442eb0f5153676058cf1" + }, + "m_SlotId": 2 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "866a17817870451e9971f9f71e910e19" + }, + "m_SlotId": 3 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "c2f112e363d049f68f0c3b3031c18f06" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "b5033b6eae774ee281774f8a5ebd6867" + }, + "m_SlotId": 1 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "c3875f35cac14d3ab6d3ae545d281df7" + }, + "m_SlotId": 3 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "d135a9d074e34f8a82f5f778a5fc8a77" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "c82337ad5b6a41fba467321b6a383a9f" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "77356f6efe684b15bacc81e99c0fc187" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "c896751d379b48b793ac05bbc6687f65" + }, + "m_SlotId": 1 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "a4abc46300494294b321ea368512e48c" + }, + "m_SlotId": 1 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "cd5616f7b08c4b37bb7a7b56afc8ca2b" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "a55dd75f45944956a01d8fd91c85994a" + }, + "m_SlotId": 3 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "d007bea8b7874cd3983c3448fe35b232" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "32d9e2980d2647e9865f97b452ae9e72" + }, + "m_SlotId": 1 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "d0cc3b3b53f440678f753c7d24288c01" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "1580b7ab05d74620b015c851f432a785" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "d135a9d074e34f8a82f5f778a5fc8a77" + }, + "m_SlotId": 2 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "00b0c6f8a9d74c8dac48bfde16ff2e40" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "d2920db565474984a8eae456eca16597" + }, + "m_SlotId": 1 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "687659d5f2844131913f3ebec5692c99" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "d2a1a0932aa14dd0b783f2ed23c7be39" + }, + "m_SlotId": 2 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "22b41ca9fba047ea8d41791afecc4b1b" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "d2e83ab99d6c4bf48651e111f4c6e88b" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "a092fae44e0b454cb3b18c1769b66a72" + }, + "m_SlotId": 1 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "d39a9113840a4a86b90ff79526878a19" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "e1da77b3145d43e9a95e681afd6c3b82" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "d875584c381349c8be1fd7ec51b347ee" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "1a2f023d4d4640a597aa9599903ca696" + }, + "m_SlotId": 2 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "d971314bc5f54cdab9c09233077b1881" + }, + "m_SlotId": 1 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "6b2e66277a7943f5800e4557cd983757" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "dd6f6572051e4d659f72bb5b91baefdc" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "ac70eb9a271a4e2eb7c2e15fb1d4c989" + }, + "m_SlotId": 1 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "de2a22dd96324e7992af5f4b781aec04" + }, + "m_SlotId": 1 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "07affa6d03af4e71be5df2863dc3cf00" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "de2a22dd96324e7992af5f4b781aec04" + }, + "m_SlotId": 1 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "22b41ca9fba047ea8d41791afecc4b1b" + }, + "m_SlotId": 1 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "debaaee10b654011933a2346630b5137" + }, + "m_SlotId": 1 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "6069340092004c1191a211a8d3274b3d" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "e00715f93656411ba7edbb256c828294" + }, + "m_SlotId": 1 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "26c479b9431748d3ada12cae1f15805e" + }, + "m_SlotId": 2 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "e00fd7cf1bf84eb8af3423a5f84f02da" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "04aea1edd8694d7f84d7852ec4078ce2" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "e0b7f015d0b949be87c33efde8fa3b69" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "4a5109af1dce4a4ba5e917126d8eb1ab" + }, + "m_SlotId": 1 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "e1da77b3145d43e9a95e681afd6c3b82" + }, + "m_SlotId": 3 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "ac6803728e7549dd87a233c309559c0a" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "e2bec6c3826047c8a8ca759c60bb19ff" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "030f5fb2b7a44537b270b4c404971915" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "e37f421af20040a6bf27c01f0c1ea39e" + }, + "m_SlotId": 1 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "2df3c191066849dea8989f82ffc388f4" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "e8e39fa5d225482fbd621c6cd82b6e5a" + }, + "m_SlotId": 2 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "d135a9d074e34f8a82f5f778a5fc8a77" + }, + "m_SlotId": 1 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "e914554d54e64faf9720389438495a70" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "520e6dc597e44dc9bebe93b078837c7b" + }, + "m_SlotId": 2 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "eb866c4039374f098844e0d54b0d2c13" + }, + "m_SlotId": 1 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "1580b7ab05d74620b015c851f432a785" + }, + "m_SlotId": 1 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "eba48f1e544d455986b250277b538909" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "fe89101ff92d49e9a630a987e854fb0a" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "ed083dc9dc3c4f5fa9248d1b99d92da4" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "2643e290df8a4963bc3741b72302fe4f" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "f15873d7cae54a328809df9a8d76bbf7" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "af7e3800e2f34908a3a77b8948d2fd32" + }, + "m_SlotId": 1 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "f2b7d300cc4c41a09579db62531aa14a" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "c24cb266ce15442eb0f5153676058cf1" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "f4274b5ff3ad4120a550c1bfb31fe327" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "d2a1a0932aa14dd0b783f2ed23c7be39" + }, + "m_SlotId": 3 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "f43a277c26e34eee8f21c22daafd4054" + }, + "m_SlotId": 1 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "5cd5b507a13647d4a17df6f6a63455bc" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "f769abb9b5a74ec89369a250e2c8d39b" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "815740e575684a18ae4f7aced285fb16" + }, + "m_SlotId": 1 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "f78692b5ae6b4dc3b9e2333153a1ac99" + }, + "m_SlotId": 2 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "26c479b9431748d3ada12cae1f15805e" + }, + "m_SlotId": 1 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "f82f65e9659e476a81e3fd01ec59c77d" + }, + "m_SlotId": 2 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "ac70eb9a271a4e2eb7c2e15fb1d4c989" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "fa23d0762b1842e38b1ce87344837242" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "aaa78c08909d49449406d49a312d31a3" + }, + "m_SlotId": 1 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "fdc1fb91fa83476caa363209cb103fd5" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "a9b949905222445081591fa1fd11be88" + }, + "m_SlotId": 1 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "fe251668acaf4cc1a186f88895925031" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "a55dd75f45944956a01d8fd91c85994a" + }, + "m_SlotId": 1 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "fe251668acaf4cc1a186f88895925031" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "e00715f93656411ba7edbb256c828294" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "fe251668acaf4cc1a186f88895925031" + }, + "m_SlotId": 7 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "6ae52db55a2846f28176b9aa785e3cb4" + }, + "m_SlotId": 0 + } + } + ], + "m_VertexContext": { + "m_Position": { + "x": 47.99997329711914, + "y": -670.0000610351563 + }, + "m_Blocks": [ + { + "m_Id": "2704a97326044be09a54d3e3810db15f" + }, + { + "m_Id": "0b7af971d63e4166afd190de3b9e9172" + }, + { + "m_Id": "fe4907798c1644289607e0d2603a9a68" + } + ] + }, + "m_FragmentContext": { + "m_Position": { + "x": 46.99992752075195, + "y": -12.000000953674317 + }, + "m_Blocks": [ + { + "m_Id": "d0f957ba1d13421b96ab67ec531eefa7" + }, + { + "m_Id": "358a13893c98426abb6bc4c3984c2dc8" + }, + { + "m_Id": "ca5e280a68af4a45a358d1f7b9cff2e2" + }, + { + "m_Id": "76ac26031b7c43a6a78d7e9db5db64be" + }, + { + "m_Id": "8277bdd1ba5e486788875b590047b626" + }, + { + "m_Id": "43b2f53e22494f52ad836aba700da7c7" + }, + { + "m_Id": "a61b9632fcd344bbb50f017fe9662523" + }, + { + "m_Id": "687659d5f2844131913f3ebec5692c99" + }, + { + "m_Id": "91e279bc4ab24de6baf584d64e36b2ae" + }, + { + "m_Id": "fe89101ff92d49e9a630a987e854fb0a" + }, + { + "m_Id": "bc220c2be8a74249ac65d93a8ae5cbdf" + }, + { + "m_Id": "2b74cde8bed7456b968b7b795a741d50" + }, + { + "m_Id": "4239ae5618e54aada26f71dc47c73c18" + }, + { + "m_Id": "2643e290df8a4963bc3741b72302fe4f" + }, + { + "m_Id": "04aea1edd8694d7f84d7852ec4078ce2" + }, + { + "m_Id": "883fa0154dc245788e90a0983dac686e" + }, + { + "m_Id": "e7adb047317f4e8f97e8758b79640e35" + }, + { + "m_Id": "b3602abd3e6c4110bd7c0c759e4b9c20" + }, + { + "m_Id": "f0eca0bb90df4ad88ca3cef5c34fc766" + } + ] + }, + "m_PreviewData": { + "serializedMesh": { + "m_SerializedMesh": "{\"mesh\":{\"instanceID\":0}}", + "m_Guid": "" + } + }, + "m_Path": "Shader Graphs", + "m_ConcretePrecision": 0, + "m_PreviewMode": 2, + "m_OutputNode": { + "m_Id": "" + }, + "m_ActiveTargets": [ + { + "m_Id": "b68cdcc63047409381c5e594c02463cd" + } + ] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "002f41d7623b419ebf0383bac58d55bf", + "m_Id": 3, + "m_DisplayName": "Opacity", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "Opacity", + "m_StageCapability": 3, + "m_Value": 1.0, + "m_DefaultValue": 1.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.SaturateNode", + "m_ObjectId": "00b0c6f8a9d74c8dac48bfde16ff2e40", + "m_Group": { + "m_Id": "3aedb1a4a3f540528911bf5344ee2e15" + }, + "m_Name": "Saturate", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -3402.999755859375, + "y": -2772.0, + "width": 128.0, + "height": 94.0 + } + }, + "m_Slots": [ + { + "m_Id": "47327438d4404b2aa0f090a73c62fec1" + }, + { + "m_Id": "82f081e4a28545b4870f059eaf9ec02b" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.UVMaterialSlot", + "m_ObjectId": "00baaaa5003c4088b756f5c193d00dc8", + "m_Id": 2, + "m_DisplayName": "UV", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "UV", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0 + }, + "m_Labels": [], + "m_Channel": 0 +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "010417d0c9bb421fa8c265f9afbc36ae", + "m_Id": 0, + "m_DisplayName": "", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "02681404df3b49b3b4a882e63c352cae", + "m_Id": 2, + "m_DisplayName": "Out", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "029d6201ad5b43e7b3542e71b5800a86", + "m_Id": 0, + "m_DisplayName": "In", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "In", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "03014458088c4ce5abc7a07b694efe86", + "m_Id": 0, + "m_DisplayName": "Depth Postpass", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.RedirectNodeData", + "m_ObjectId": "030f5fb2b7a44537b270b4c404971915", + "m_Group": { + "m_Id": "" + }, + "m_Name": "Redirect Node", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -411.99981689453127, + "y": 191.99998474121095, + "width": 56.0, + "height": 23.999998092651368 + } + }, + "m_Slots": [ + { + "m_Id": "493b4f4104c2438f8498f6de58ada442" + }, + { + "m_Id": "0d4c4d21d5d94b838efc01ec0235fed8" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.GroupData", + "m_ObjectId": "03640179a61e456c8a3f77f11616681e", + "m_Title": "Vertex Color Mask and Depth Blend", + "m_Position": { + "x": -2482.0, + "y": -1548.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "037a4a0d094d48ef8dc680484249458d", + "m_Id": 2, + "m_DisplayName": "Out", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.BlockNode", + "m_ObjectId": "04aea1edd8694d7f84d7852ec4078ce2", + "m_Group": { + "m_Id": "" + }, + "m_Name": "SurfaceDescription.SecondarySpecularShift", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": 0.0, + "y": 0.0, + "width": 0.0, + "height": 0.0 + } + }, + "m_Slots": [ + { + "m_Id": "95f38f9e439d46f6b767d7f992ae0e60" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_SerializedDescriptor": "SurfaceDescription.SecondarySpecularShift" +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.PropertyNode", + "m_ObjectId": "04af8ce2ede54180b9c27045bc9d754e", + "m_Group": { + "m_Id": "244280d6eea94f08bb23a8e3db3784a3" + }, + "m_Name": "Property", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -6275.0, + "y": -3358.0, + "width": 181.0, + "height": 34.0 + } + }, + "m_Slots": [ + { + "m_Id": "e43275d96a9043989d6b9320a9b3a8e4" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_Property": { + "m_Id": "f3db2a837d7d47aea3d00d54af30b29d" + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.PropertyNode", + "m_ObjectId": "0569c2035ccd497a872ea10ea40d4e43", + "m_Group": { + "m_Id": "0da3d5800b834357824042477eb483dd" + }, + "m_Name": "Property", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -1907.0, + "y": -13.000069618225098, + "width": 178.0, + "height": 34.0 + } + }, + "m_Slots": [ + { + "m_Id": "e31bf6dc23e84624bbffe7d762c0b242" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_Property": { + "m_Id": "b2b5bf0810fd490d81e06a42ff3ba8ed" + } +} + +{ + "m_SGVersion": 3, + "m_Type": "UnityEditor.ShaderGraph.Internal.ColorShaderProperty", + "m_ObjectId": "05cd8ff0d3ab48a7b776a221ff36b8ad", + "m_Guid": { + "m_GuidSerialized": "7542dc85-225f-446a-9ca4-9bbe8d4cebc6" + }, + "m_Name": "Highlight A Color", + "m_DefaultReferenceName": "", + "m_OverrideReferenceName": "_HighlightAColor", + "m_GeneratePropertyBlock": true, + "m_Precision": 0, + "overrideHLSLDeclaration": false, + "hlslDeclarationOverride": 0, + "m_Hidden": false, + "m_Value": { + "r": 0.9137254953384399, + "g": 0.7803921699523926, + "b": 0.6352941393852234, + "a": 0.0 + }, + "m_ColorMode": 0 +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "05e0b56d248c4ad9b98081c41f893ac4", + "m_Id": 1, + "m_DisplayName": "B", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "B", + "m_StageCapability": 3, + "m_Value": { + "x": 1.0, + "y": 1.0, + "z": 1.0, + "w": 1.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Texture2DInputMaterialSlot", + "m_ObjectId": "05fbfae444844c6fba5d11a68dde77d9", + "m_Id": 1, + "m_DisplayName": "Texture", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "Texture", + "m_StageCapability": 3, + "m_BareResource": false, + "m_Texture": { + "m_SerializedTexture": "{\"texture\":{\"instanceID\":0}}", + "m_Guid": "" + }, + "m_DefaultType": 0 +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "06841118c17a4855862cdcae1d830883", + "m_Id": 1, + "m_DisplayName": "Blend", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "Blend", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicValueMaterialSlot", + "m_ObjectId": "07835af3a85d4387bbd3386865feb0bd", + "m_Id": 1, + "m_DisplayName": "B", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "B", + "m_StageCapability": 3, + "m_Value": { + "e00": 2.0, + "e01": 2.0, + "e02": 2.0, + "e03": 2.0, + "e10": 2.0, + "e11": 2.0, + "e12": 2.0, + "e13": 2.0, + "e20": 2.0, + "e21": 2.0, + "e22": 2.0, + "e23": 2.0, + "e30": 2.0, + "e31": 2.0, + "e32": 2.0, + "e33": 2.0 + }, + "m_DefaultValue": { + "e00": 1.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 1.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 1.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.RedirectNodeData", + "m_ObjectId": "07affa6d03af4e71be5df2863dc3cf00", + "m_Group": { + "m_Id": "" + }, + "m_Name": "Redirect Node", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -411.99981689453127, + "y": 143.99998474121095, + "width": 56.0, + "height": 23.999998092651368 + } + }, + "m_Slots": [ + { + "m_Id": "4a76173cb56049afb4021ffc98a09359" + }, + { + "m_Id": "35929c4279f84659bfcaada01f537c9e" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicValueMaterialSlot", + "m_ObjectId": "07d3bd34837d49efac457b1dd4f21469", + "m_Id": 2, + "m_DisplayName": "Out", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": { + "e00": 0.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 0.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 0.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 0.0 + }, + "m_DefaultValue": { + "e00": 1.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 1.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 1.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "08ccc7ab660441e99b582e3f493ce062", + "m_Id": 5, + "m_DisplayName": "G", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "G", + "m_StageCapability": 2, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.PropertyNode", + "m_ObjectId": "0917d75185d9443586c46f1f88fff814", + "m_Group": { + "m_Id": "03640179a61e456c8a3f77f11616681e" + }, + "m_Name": "Property", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -1287.0, + "y": -1145.0, + "width": 152.0, + "height": 34.0 + } + }, + "m_Slots": [ + { + "m_Id": "110c2d098e354aedb30b265776569686" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_Property": { + "m_Id": "a89b7eb5908949b7a8ff733c487aa014" + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicValueMaterialSlot", + "m_ObjectId": "0a4b66f4c7904331a220c621d4c4e2ff", + "m_Id": 1, + "m_DisplayName": "B", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "B", + "m_StageCapability": 3, + "m_Value": { + "e00": 2.0, + "e01": 2.0, + "e02": 2.0, + "e03": 2.0, + "e10": 2.0, + "e11": 2.0, + "e12": 2.0, + "e13": 2.0, + "e20": 2.0, + "e21": 2.0, + "e22": 2.0, + "e23": 2.0, + "e30": 2.0, + "e31": 2.0, + "e32": 2.0, + "e33": 2.0 + }, + "m_DefaultValue": { + "e00": 1.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 1.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 1.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.BlockNode", + "m_ObjectId": "0b7af971d63e4166afd190de3b9e9172", + "m_Group": { + "m_Id": "" + }, + "m_Name": "VertexDescription.Normal", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": 0.0, + "y": 0.0, + "width": 0.0, + "height": 0.0 + } + }, + "m_Slots": [ + { + "m_Id": "48748e76259b4423af31e7017f1b1967" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_SerializedDescriptor": "VertexDescription.Normal" +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "0c722f49f92545a4b12a022983a9346c", + "m_Id": 2, + "m_DisplayName": "Out", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "0d4c4d21d5d94b838efc01ec0235fed8", + "m_Id": 1, + "m_DisplayName": "", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.GroupData", + "m_ObjectId": "0da3d5800b834357824042477eb483dd", + "m_Title": "Smoothness", + "m_Position": { + "x": -1931.9998779296875, + "y": -304.9999694824219 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "0e22fca13e234609afab56d5e9dc57e2", + "m_Id": 1, + "m_DisplayName": "Out", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.GroupData", + "m_ObjectId": "0e8b3d01fbd24a99bdb2e8e85a456a90", + "m_Title": "Highlight B", + "m_Position": { + "x": -4064.999755859375, + "y": -2208.999755859375 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "0f20239df8ac41b097e0a197dd5f1135", + "m_Id": 0, + "m_DisplayName": "In", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "In", + "m_StageCapability": 3, + "m_Value": { + "x": 1.0, + "y": 1.0, + "z": 1.0, + "w": 1.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "0f4e336f41354f7d80263f32580a32b3", + "m_Id": 0, + "m_DisplayName": "A", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "A", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "103fe7e5bb18457685d64a677f52d7fd", + "m_Id": 4, + "m_DisplayName": "In", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "In", + "m_StageCapability": 3, + "m_Value": 1.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector3MaterialSlot", + "m_ObjectId": "106b7a1cedb94596a16d44ae0c54951f", + "m_Id": 0, + "m_DisplayName": "Highlight A Distribution", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0 + }, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.RedirectNodeData", + "m_ObjectId": "106c4319f0c8421a9295b557df9f94a3", + "m_Group": { + "m_Id": "" + }, + "m_Name": "Redirect Node", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -618.9998168945313, + "y": 1524.0, + "width": 56.0, + "height": 23.999998092651368 + } + }, + "m_Slots": [ + { + "m_Id": "3c80f97dbdf64454b8313bf869c39b0d" + }, + { + "m_Id": "cc8fa1bf760b4fd584f1204d418bd893" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "10beb564410244fbb91a20b5492d40cd", + "m_Id": 0, + "m_DisplayName": "In", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "In", + "m_StageCapability": 3, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "10e7d59f5c0f4a2e945fa4e44a1728bc", + "m_Id": 1, + "m_DisplayName": "", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.UVMaterialSlot", + "m_ObjectId": "10fcfa37830d4e02851aae7950225694", + "m_Id": 2, + "m_DisplayName": "UV", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "UV", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0 + }, + "m_Labels": [], + "m_Channel": 0 +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "110c2d098e354aedb30b265776569686", + "m_Id": 0, + "m_DisplayName": "AO Occlude All", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.PropertyNode", + "m_ObjectId": "114b289fef094d4fb9b6da23caaeb079", + "m_Group": { + "m_Id": "0da3d5800b834357824042477eb483dd" + }, + "m_Name": "Property", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -1617.0, + "y": -190.00006103515626, + "width": 167.0, + "height": 34.0 + } + }, + "m_Slots": [ + { + "m_Id": "5b27aa17be4b4644916146c205290a85" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_Property": { + "m_Id": "1fc40334fcb74e05a6f086c3e4645288" + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "11b80c01acff493e8d25da0eeae5b521", + "m_Id": 6, + "m_DisplayName": "B", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "B", + "m_StageCapability": 2, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "13649b671ad94c90a236768ce90cb3d5", + "m_Id": 1, + "m_DisplayName": "Out", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1Node", + "m_ObjectId": "1470e378ade24d0380105fd3f3278773", + "m_Group": { + "m_Id": "03640179a61e456c8a3f77f11616681e" + }, + "m_Name": "Float", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -1808.0, + "y": -963.0000610351563, + "width": 126.0, + "height": 77.0 + } + }, + "m_Slots": [ + { + "m_Id": "7ac4a2ee1dae4aefb1476b682c617c73" + }, + { + "m_Id": "3ccf05f3e603432394a0a8cf219e6463" + } + ], + "synonyms": [ + "Vector 1" + ], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_Value": 0.0 +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.SamplerStateMaterialSlot", + "m_ObjectId": "147eb2a0fa474862ad3e999175f89197", + "m_Id": 3, + "m_DisplayName": "Sampler", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "Sampler", + "m_StageCapability": 3, + "m_BareResource": false +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "14ae49d9f448412f9e48b712d1468f27", + "m_Id": 0, + "m_DisplayName": "Secondary Specular Multiplier", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.PropertyNode", + "m_ObjectId": "151656766f524322aecfdf73999cda54", + "m_Group": { + "m_Id": "" + }, + "m_Name": "Property", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -504.00006103515627, + "y": 475.0, + "width": 149.0, + "height": 34.0 + } + }, + "m_Slots": [ + { + "m_Id": "45dfc44534f541209f64118a5e0e118d" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_Property": { + "m_Id": "a73bbe07bf634ae6a2f595dac0d74ea3" + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicValueMaterialSlot", + "m_ObjectId": "156cedca2c32409499c3d5aeb67364dd", + "m_Id": 0, + "m_DisplayName": "A", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "A", + "m_StageCapability": 3, + "m_Value": { + "e00": 0.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 0.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 0.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 0.0 + }, + "m_DefaultValue": { + "e00": 1.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 1.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 1.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.MultiplyNode", + "m_ObjectId": "1580b7ab05d74620b015c851f432a785", + "m_Group": { + "m_Id": "1bf156e34830433f9d5347d334ce2f5d" + }, + "m_Name": "Multiply", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -1587.0, + "y": -547.0, + "width": 126.0, + "height": 117.99999237060547 + } + }, + "m_Slots": [ + { + "m_Id": "46b4fa9e809b4c358aab59de95e73ff9" + }, + { + "m_Id": "b47b692c98e84d2e87278ffbaaf253c6" + }, + { + "m_Id": "fad7135d3acf435aa4649d22d2463e53" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "15a95450e5e046cbb66c50e363aa6f5c", + "m_Id": 7, + "m_DisplayName": "A", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "A", + "m_StageCapability": 2, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "15bc9145e40041e2b9da7df6f07eeee9", + "m_Id": 4, + "m_DisplayName": "R", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "R", + "m_StageCapability": 2, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 3, + "m_Type": "UnityEditor.ShaderGraph.Internal.ColorShaderProperty", + "m_ObjectId": "1728986d8b5d4a60a610dc8f863ef11d", + "m_Guid": { + "m_GuidSerialized": "5b6c3d61-7bba-4042-b1f0-3799fd7bc7a2" + }, + "m_Name": "Specular Tint", + "m_DefaultReferenceName": "Color_1728986d8b5d4a60a610dc8f863ef11d", + "m_OverrideReferenceName": "_SpecularTint", + "m_GeneratePropertyBlock": true, + "m_Precision": 0, + "overrideHLSLDeclaration": false, + "hlslDeclarationOverride": 0, + "m_Hidden": false, + "m_Value": { + "r": 1.0, + "g": 1.0, + "b": 1.0, + "a": 1.0 + }, + "m_ColorMode": 0 +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.NormalMaterialSlot", + "m_ObjectId": "1748e4e9d24e4de7932315b2e25527ce", + "m_Id": 0, + "m_DisplayName": "Bent Normal", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "BentNormal", + "m_StageCapability": 2, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0 + }, + "m_Labels": [], + "m_Space": 3 +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "174d538819664420a4c03320ca98f5ca", + "m_Id": 7, + "m_DisplayName": "A", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "A", + "m_StageCapability": 2, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicValueMaterialSlot", + "m_ObjectId": "17cc7fe3c33f422f8283e532bf1777f1", + "m_Id": 1, + "m_DisplayName": "B", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "B", + "m_StageCapability": 3, + "m_Value": { + "e00": 2.0, + "e01": 2.0, + "e02": 2.0, + "e03": 2.0, + "e10": 2.0, + "e11": 2.0, + "e12": 2.0, + "e13": 2.0, + "e20": 2.0, + "e21": 2.0, + "e22": 2.0, + "e23": 2.0, + "e30": 2.0, + "e31": 2.0, + "e32": 2.0, + "e33": 2.0 + }, + "m_DefaultValue": { + "e00": 1.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 1.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 1.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "17d3d431592e4c2bb1780a1e0a9f03a2", + "m_Id": 1, + "m_DisplayName": "", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "1846dfbb5b1441829b77365754ab377d", + "m_Id": 0, + "m_DisplayName": "Secondary Specular Shift", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.GroupData", + "m_ObjectId": "184a4bbd54744e36ac8fcee9b32aafbf", + "m_Title": "ID Map", + "m_Position": { + "x": -5324.0, + "y": -2646.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "1916f5588320445385b044aa53702e1e", + "m_Id": 0, + "m_DisplayName": "In", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "In", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicValueMaterialSlot", + "m_ObjectId": "198b443bd3f14dc8988cc66463ed7085", + "m_Id": 0, + "m_DisplayName": "A", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "A", + "m_StageCapability": 3, + "m_Value": { + "e00": 0.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 0.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 0.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 0.0 + }, + "m_DefaultValue": { + "e00": 1.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 1.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 1.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 1.0 + } +} + +{ + "m_SGVersion": 1, + "m_Type": "UnityEditor.ShaderGraph.CustomFunctionNode", + "m_ObjectId": "1a2f023d4d4640a597aa9599903ca696", + "m_Group": { + "m_Id": "3aedb1a4a3f540528911bf5344ee2e15" + }, + "m_Name": "_InvertByOneMinusFac (Custom Function)", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -4207.0, + "y": -2488.000244140625, + "width": 283.0, + "height": 118.00000762939453 + } + }, + "m_Slots": [ + { + "m_Id": "10beb564410244fbb91a20b5492d40cd" + }, + { + "m_Id": "ad5413aaafc44260b8a6486126167921" + }, + { + "m_Id": "42c406f1f550402f890e56f95f9808b3" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_SourceType": 1, + "m_FunctionName": "_InvertByOneMinusFac", + "m_FunctionSource": "", + "m_FunctionBody": "Out = lerp(In, 1.0 - In, 1.0 - Fac);" +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector4MaterialSlot", + "m_ObjectId": "1b344d261ec648189f8ff9340b0ed20c", + "m_Id": 0, + "m_DisplayName": "RGBA", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "RGBA", + "m_StageCapability": 2, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_Labels": [] +} + +{ + "m_SGVersion": 1, + "m_Type": "UnityEditor.ShaderGraph.Internal.Vector1ShaderProperty", + "m_ObjectId": "1b66a7533fa643888276c4f6de382ca9", + "m_Guid": { + "m_GuidSerialized": "eba3fc22-41c1-494e-a739-60172ed1e541" + }, + "m_Name": "Depth Postpass", + "m_DefaultReferenceName": "Vector1_1b66a7533fa643888276c4f6de382ca9", + "m_OverrideReferenceName": "_DepthPostpass", + "m_GeneratePropertyBlock": true, + "m_Precision": 0, + "overrideHLSLDeclaration": false, + "hlslDeclarationOverride": 0, + "m_Hidden": false, + "m_Value": 0.20000000298023225, + "m_FloatType": 1, + "m_RangeValues": { + "x": 0.0, + "y": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector3MaterialSlot", + "m_ObjectId": "1bbfb308461446debb1bfaf74fb9d0fb", + "m_Id": 2, + "m_DisplayName": "Out", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0 + }, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.GroupData", + "m_ObjectId": "1bf156e34830433f9d5347d334ce2f5d", + "m_Title": "Ambient Occlusion", + "m_Position": { + "x": -1914.9998779296875, + "y": -606.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicValueMaterialSlot", + "m_ObjectId": "1dff7ccda7c2459fabb9d759da4ebbd8", + "m_Id": 0, + "m_DisplayName": "A", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "A", + "m_StageCapability": 3, + "m_Value": { + "e00": 0.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 0.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 0.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 0.0 + }, + "m_DefaultValue": { + "e00": 1.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 1.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 1.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.UVMaterialSlot", + "m_ObjectId": "1e559a52f2cf4d6282a91a6f552dfcb8", + "m_Id": 2, + "m_DisplayName": "UV", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "UV", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0 + }, + "m_Labels": [], + "m_Channel": 0 +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.PropertyNode", + "m_ObjectId": "1e6a1a093dfc4253ab60cb89cdbd500a", + "m_Group": { + "m_Id": "244280d6eea94f08bb23a8e3db3784a3" + }, + "m_Name": "Property", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -5621.0, + "y": -3138.0, + "width": 135.0, + "height": 34.0 + } + }, + "m_Slots": [ + { + "m_Id": "a6847bbd696147b7a3bede53269a3b97" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_Property": { + "m_Id": "7a7ff89b265c40a9aeaad4f27130fb28" + } +} + +{ + "m_SGVersion": 1, + "m_Type": "UnityEditor.ShaderGraph.Internal.Vector1ShaderProperty", + "m_ObjectId": "1eba045aa0eb497597cd205664aeb8ec", + "m_Guid": { + "m_GuidSerialized": "fdd216c7-b3dd-4d4c-bec3-2f34979e0c8b" + }, + "m_Name": "Highlight A Overlap End", + "m_DefaultReferenceName": "", + "m_OverrideReferenceName": "_HighlightAOverlapEnd", + "m_GeneratePropertyBlock": true, + "m_Precision": 0, + "overrideHLSLDeclaration": false, + "hlslDeclarationOverride": 0, + "m_Hidden": false, + "m_Value": 1.0, + "m_FloatType": 1, + "m_RangeValues": { + "x": 0.0, + "y": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.MultiplyNode", + "m_ObjectId": "1f325b3e26a640949036a22e6af17a00", + "m_Group": { + "m_Id": "" + }, + "m_Name": "Multiply", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -744.0, + "y": 363.0, + "width": 130.0, + "height": 118.00000762939453 + } + }, + "m_Slots": [ + { + "m_Id": "c55f572322244a4dae2badfed69c29e6" + }, + { + "m_Id": "07835af3a85d4387bbd3386865feb0bd" + }, + { + "m_Id": "faa11926f42c42ea8e9f2f14d3afd2b2" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "1f72e700f69040cfac4e379dba843e71", + "m_Id": 1, + "m_DisplayName": "Out", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Internal.Texture2DShaderProperty", + "m_ObjectId": "1f7de34ad6cf475f840313717441d77c", + "m_Guid": { + "m_GuidSerialized": "06201a0c-4dae-4efb-8a8c-9557e9de623f" + }, + "m_Name": "ID Map", + "m_DefaultReferenceName": "", + "m_OverrideReferenceName": "_IDMap", + "m_GeneratePropertyBlock": true, + "m_Precision": 0, + "overrideHLSLDeclaration": false, + "hlslDeclarationOverride": 0, + "m_Hidden": false, + "m_Value": { + "m_SerializedTexture": "{\"texture\":{\"instanceID\":0}}", + "m_Guid": "" + }, + "m_Modifiable": true, + "m_DefaultType": 2 +} + +{ + "m_SGVersion": 1, + "m_Type": "UnityEditor.ShaderGraph.Internal.Vector1ShaderProperty", + "m_ObjectId": "1fc40334fcb74e05a6f086c3e4645288", + "m_Guid": { + "m_GuidSerialized": "2d81f29f-bc0a-49d3-addb-ab29719bd48d" + }, + "m_Name": "Smoothness Max", + "m_DefaultReferenceName": "", + "m_OverrideReferenceName": "_SmoothnessMax", + "m_GeneratePropertyBlock": true, + "m_Precision": 0, + "overrideHLSLDeclaration": false, + "hlslDeclarationOverride": 0, + "m_Hidden": false, + "m_Value": 0.800000011920929, + "m_FloatType": 1, + "m_RangeValues": { + "x": 0.0, + "y": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.PropertyNode", + "m_ObjectId": "20ec913f194d4acd871be539f0ceffd0", + "m_Group": { + "m_Id": "be2cb7795a6143a498576442f64713d6" + }, + "m_Name": "Property", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -1603.999755859375, + "y": 1185.0, + "width": 130.0, + "height": 34.0 + } + }, + "m_Slots": [ + { + "m_Id": "80957726e3df45db966134a9418138f8" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_Property": { + "m_Id": "d962fe658f9a4982b62bd75d03b2276e" + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.BlendNode", + "m_ObjectId": "22b41ca9fba047ea8d41791afecc4b1b", + "m_Group": { + "m_Id": "03640179a61e456c8a3f77f11616681e" + }, + "m_Name": "Blend", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -1021.0, + "y": -1234.0, + "width": 161.0, + "height": 178.0 + } + }, + "m_Slots": [ + { + "m_Id": "d82ebec1ca59449cb43e46802671cb2a" + }, + { + "m_Id": "06841118c17a4855862cdcae1d830883" + }, + { + "m_Id": "3835c9076d2842a1ad2bdbf2b0b22d3f" + }, + { + "m_Id": "6851ee7b471645219d7bf0ce950d3312" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_BlendMode": 13 +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "22d366686d314c62ab9ea7700c1b42e7", + "m_Id": 0, + "m_DisplayName": "Smoothness", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "Smoothness", + "m_StageCapability": 2, + "m_Value": 0.5, + "m_DefaultValue": 0.5, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "236a7df61557494b8f4abdc666852d98", + "m_Id": 1, + "m_DisplayName": "Blend", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "Blend", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.GroupData", + "m_ObjectId": "244280d6eea94f08bb23a8e3db3784a3", + "m_Title": "Root / End Blending", + "m_Position": { + "x": -6824.00048828125, + "y": -3531.000244140625 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicValueMaterialSlot", + "m_ObjectId": "249f8c2e63b24345b026d975bf380539", + "m_Id": 2, + "m_DisplayName": "Out", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": { + "e00": 0.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 0.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 0.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 0.0 + }, + "m_DefaultValue": { + "e00": 1.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 1.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 1.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "2585413badda4f19acdc1dfe6349c8c4", + "m_Id": 2, + "m_DisplayName": "Off", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "Off", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.BlockNode", + "m_ObjectId": "2643e290df8a4963bc3741b72302fe4f", + "m_Group": { + "m_Id": "" + }, + "m_Name": "SurfaceDescription.SecondarySmoothness", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": 61.0, + "y": 540.0, + "width": 200.0, + "height": 41.0 + } + }, + "m_Slots": [ + { + "m_Id": "7ac7d38819cb49fbadbfc71413a3da76" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_SerializedDescriptor": "SurfaceDescription.SecondarySmoothness" +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.KeywordNode", + "m_ObjectId": "26c479b9431748d3ada12cae1f15805e", + "m_Group": { + "m_Id": "03640179a61e456c8a3f77f11616681e" + }, + "m_Name": "Enable Color", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -2321.999755859375, + "y": -1318.0001220703125, + "width": 139.0, + "height": 118.0 + } + }, + "m_Slots": [ + { + "m_Id": "eb77128ab4c94f07bcb9c760a1b2d6ff" + }, + { + "m_Id": "2a0bb20f4ec7429f954c34b06737bf38" + }, + { + "m_Id": "2585413badda4f19acdc1dfe6349c8c4" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_Keyword": { + "m_Id": "d7616bdb7fec4d338db92ff5b42d8172" + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.BlockNode", + "m_ObjectId": "2704a97326044be09a54d3e3810db15f", + "m_Group": { + "m_Id": "" + }, + "m_Name": "VertexDescription.Position", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": 0.0, + "y": 0.0, + "width": 0.0, + "height": 0.0 + } + }, + "m_Slots": [ + { + "m_Id": "fc09e913712c46d780c50a50e6df747c" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_SerializedDescriptor": "VertexDescription.Position" +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicValueMaterialSlot", + "m_ObjectId": "27233a528aeb411280889b3cc096ce6d", + "m_Id": 1, + "m_DisplayName": "B", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "B", + "m_StageCapability": 3, + "m_Value": { + "e00": 2.0, + "e01": 2.0, + "e02": 2.0, + "e03": 2.0, + "e10": 2.0, + "e11": 2.0, + "e12": 2.0, + "e13": 2.0, + "e20": 2.0, + "e21": 2.0, + "e22": 2.0, + "e23": 2.0, + "e30": 2.0, + "e31": 2.0, + "e32": 2.0, + "e33": 2.0 + }, + "m_DefaultValue": { + "e00": 1.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 1.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 1.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 1.0 + } +} + +{ + "m_SGVersion": 1, + "m_Type": "UnityEditor.ShaderGraph.Internal.Vector3ShaderProperty", + "m_ObjectId": "2824b0c4fe6c4ff3b6d72dcfe453a320", + "m_Guid": { + "m_GuidSerialized": "5925d4e8-d09a-4519-8c6c-1b396573d42c" + }, + "m_Name": "Highlight A Distribution", + "m_DefaultReferenceName": "", + "m_OverrideReferenceName": "_HighlightADistribution", + "m_GeneratePropertyBlock": true, + "m_Precision": 0, + "overrideHLSLDeclaration": false, + "hlslDeclarationOverride": 0, + "m_Hidden": false, + "m_Value": { + "x": 0.10000000149011612, + "y": 0.20000000298023225, + "z": 0.30000001192092898, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.ColorRGBMaterialSlot", + "m_ObjectId": "2848c38716704c6da99bb5bfd339a5c4", + "m_Id": 0, + "m_DisplayName": "Secondary Specular Tint", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "SecondarySpecularTint", + "m_StageCapability": 2, + "m_Value": { + "x": 0.5, + "y": 0.5, + "z": 0.5 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0 + }, + "m_Labels": [], + "m_ColorMode": 0, + "m_DefaultColor": { + "r": 0.5, + "g": 0.5, + "b": 0.5, + "a": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.RedirectNodeData", + "m_ObjectId": "28e145da8a3747de8be1fbeb7dbc5cae", + "m_Group": { + "m_Id": "" + }, + "m_Name": "Redirect Node", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -618.9998168945313, + "y": 1548.0, + "width": 56.0, + "height": 23.999998092651368 + } + }, + "m_Slots": [ + { + "m_Id": "45ab6695a89b4c0d9656a3ba1ad00c29" + }, + { + "m_Id": "2c6b1e90145d4977b64b33ab8da9392b" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector4MaterialSlot", + "m_ObjectId": "28e5ad56a0cc4bd3acbf0cf95dafcd99", + "m_Id": 0, + "m_DisplayName": "Specular Tint", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "2a0bb20f4ec7429f954c34b06737bf38", + "m_Id": 1, + "m_DisplayName": "On", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "On", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "2b0c15c346474e47bba4edea7f4d00ed", + "m_Id": 0, + "m_DisplayName": "Specular Shift", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "SpecularShift", + "m_StageCapability": 2, + "m_Value": 0.10000000149011612, + "m_DefaultValue": 0.10000000149011612, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.PropertyNode", + "m_ObjectId": "2b1f8f17f34d4d07bfa9a061a97ed745", + "m_Group": { + "m_Id": "" + }, + "m_Name": "Property", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -1836.0, + "y": 125.99999237060547, + "width": 136.00001525878907, + "height": 34.000003814697269 + } + }, + "m_Slots": [ + { + "m_Id": "ee9cd55adc774c31a6f4699792680829" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_Property": { + "m_Id": "bc814cd1e05d4e94b3b180cbe5f42bfd" + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.BlockNode", + "m_ObjectId": "2b74cde8bed7456b968b7b795a741d50", + "m_Group": { + "m_Id": "" + }, + "m_Name": "SurfaceDescription.SpecularShift", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": 57.0, + "y": 428.0, + "width": 200.0, + "height": 41.0 + } + }, + "m_Slots": [ + { + "m_Id": "2b0c15c346474e47bba4edea7f4d00ed" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_SerializedDescriptor": "SurfaceDescription.SpecularShift" +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.SampleTexture2DNode", + "m_ObjectId": "2c24de69dbf540b1be983740c589ab5a", + "m_Group": { + "m_Id": "184a4bbd54744e36ac8fcee9b32aafbf" + }, + "m_Name": "Sample Texture 2D", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -5113.0, + "y": -2587.0, + "width": 184.0, + "height": 253.0 + } + }, + "m_Slots": [ + { + "m_Id": "c8a9429d23f04410ad03af22a1cc6b1d" + }, + { + "m_Id": "eaa026e6c1f64f6580cf34205cb823dc" + }, + { + "m_Id": "4c5025f9b1c24d89834e1e31376274db" + }, + { + "m_Id": "8a1378435e654e268ca60e605cf8852a" + }, + { + "m_Id": "7cbfe02cd2444b10b44b7bdec5e6e78b" + }, + { + "m_Id": "33a2d3bccd7148248f2ccdc568010ec1" + }, + { + "m_Id": "46a96a7d50a048188a0c1709db4421de" + }, + { + "m_Id": "48c97f375641468a90e44d106c97fc6a" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_TextureType": 0, + "m_NormalMapSpace": 0 +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Texture2DMaterialSlot", + "m_ObjectId": "2c3d261d1f3443b4b06b82a9e110faef", + "m_Id": 0, + "m_DisplayName": "Diffuse Map", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_BareResource": false +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "2c6b1e90145d4977b64b33ab8da9392b", + "m_Id": 1, + "m_DisplayName": "", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "2c932aab8a0447e09e2733f0afcd0feb", + "m_Id": 0, + "m_DisplayName": "Rim Transmission Intensity", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector4MaterialSlot", + "m_ObjectId": "2cee3bb09b784906b68914fdfd279c7d", + "m_Id": 0, + "m_DisplayName": "RGBA", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "RGBA", + "m_StageCapability": 2, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "2d0ca58a54814172a8890b7463d193fd", + "m_Id": 0, + "m_DisplayName": "In", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "In", + "m_StageCapability": 3, + "m_Value": { + "x": 1.0, + "y": 1.0, + "z": 1.0, + "w": 1.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 1, + "m_Type": "UnityEditor.ShaderGraph.Internal.Vector1ShaderProperty", + "m_ObjectId": "2d574f97db4a422aa1faa8f38ef8ab5f", + "m_Guid": { + "m_GuidSerialized": "3836b74d-9bbf-48aa-88b1-b2016f6225de" + }, + "m_Name": "Smoothness Min", + "m_DefaultReferenceName": "", + "m_OverrideReferenceName": "_SmoothnessMin", + "m_GeneratePropertyBlock": true, + "m_Precision": 0, + "overrideHLSLDeclaration": false, + "hlslDeclarationOverride": 0, + "m_Hidden": false, + "m_Value": 0.0, + "m_FloatType": 1, + "m_RangeValues": { + "x": 0.0, + "y": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "2de1c1fb5e4d46c19c8e78d80438fd1f", + "m_Id": 0, + "m_DisplayName": "Highlight A Overlap Invert", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.RedirectNodeData", + "m_ObjectId": "2df3c191066849dea8989f82ffc388f4", + "m_Group": { + "m_Id": "244280d6eea94f08bb23a8e3db3784a3" + }, + "m_Name": "Redirect Node", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -5928.0, + "y": -2856.0, + "width": 56.0, + "height": 23.999998092651368 + } + }, + "m_Slots": [ + { + "m_Id": "50faa87c66fe4c4b8090f1991390a20b" + }, + { + "m_Id": "ff1deab0710a4f9f95f6501e49cd6be6" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.OneMinusNode", + "m_ObjectId": "2f6eee5e06e14a1e92aaeb7d8f08d5ac", + "m_Group": { + "m_Id": "244280d6eea94f08bb23a8e3db3784a3" + }, + "m_Name": "One Minus", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -6222.0, + "y": -3472.0, + "width": 128.0, + "height": 94.0 + } + }, + "m_Slots": [ + { + "m_Id": "6b144959660d498b94f292e09d9ef69a" + }, + { + "m_Id": "fd0b99eaceeb4cc29b30e534ecffab7e" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.PropertyNode", + "m_ObjectId": "2f84847c491547739e60664b75884634", + "m_Group": { + "m_Id": "244280d6eea94f08bb23a8e3db3784a3" + }, + "m_Name": "Property", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -6147.0, + "y": -2962.999755859375, + "width": 159.0, + "height": 34.0 + } + }, + "m_Slots": [ + { + "m_Id": "ce22b01ae86b49498fc7433b4774a23d" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_Property": { + "m_Id": "a6f49c7b1ba2462aa864ed200a6a2b11" + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Internal.Texture2DShaderProperty", + "m_ObjectId": "2f97d87b4e54435a8e9aab991aa2ca95", + "m_Guid": { + "m_GuidSerialized": "df69a574-d404-4aee-827d-463b3eb702da" + }, + "m_Name": "Root Map", + "m_DefaultReferenceName": "", + "m_OverrideReferenceName": "_RootMap", + "m_GeneratePropertyBlock": true, + "m_Precision": 0, + "overrideHLSLDeclaration": false, + "hlslDeclarationOverride": 0, + "m_Hidden": false, + "m_Value": { + "m_SerializedTexture": "{\"texture\":{\"instanceID\":0}}", + "m_Guid": "" + }, + "m_Modifiable": true, + "m_DefaultType": 2 +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "30892a065ace490aa42fa50990585547", + "m_Id": 0, + "m_DisplayName": "Alpha Clip", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.KeywordNode", + "m_ObjectId": "30fe193f31ba43ba9fef9f94f9cd4c10", + "m_Group": { + "m_Id": "4754e47d61844a86908699d8a6f31a28" + }, + "m_Name": "Clip Quality", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -1044.999755859375, + "y": 1361.0, + "width": 166.0, + "height": 142.0 + } + }, + "m_Slots": [ + { + "m_Id": "52d52b0d72fa46d2a8c3b5761f07299b" + }, + { + "m_Id": "d0c5c3ec172a44dbb55d75c9f6261716" + }, + { + "m_Id": "694656ca8fa54c51800375119dcf4738" + }, + { + "m_Id": "f766d98305ef4a969d378fbe95628bb8" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_Keyword": { + "m_Id": "a9c42cd3aa674f4b8cd880751469f0f3" + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "31ee6324d28641d8afacb839dcf420eb", + "m_Id": 3, + "m_DisplayName": "Opacity", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "Opacity", + "m_StageCapability": 3, + "m_Value": 1.0, + "m_DefaultValue": 1.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector3MaterialSlot", + "m_ObjectId": "329147dd2e8542a78c6caf48245f7cda", + "m_Id": 0, + "m_DisplayName": "Highlight B Distribution", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0 + }, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.MultiplyNode", + "m_ObjectId": "32d9e2980d2647e9865f97b452ae9e72", + "m_Group": { + "m_Id": "03640179a61e456c8a3f77f11616681e" + }, + "m_Name": "Multiply", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -1435.0, + "y": -962.9999389648438, + "width": 126.0, + "height": 117.99999237060547 + } + }, + "m_Slots": [ + { + "m_Id": "ac60b4d7d6d44ccab304e372da3b5301" + }, + { + "m_Id": "17cc7fe3c33f422f8283e532bf1777f1" + }, + { + "m_Id": "9ba47033530747e9afd09228f0e29be6" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "333d7eef2c2e4a54bd96738ef0fb83e4", + "m_Id": 2, + "m_DisplayName": "Out", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "334baaea25334886ba55b47a00a70600", + "m_Id": 0, + "m_DisplayName": "", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Texture2DInputMaterialSlot", + "m_ObjectId": "33a2d3bccd7148248f2ccdc568010ec1", + "m_Id": 1, + "m_DisplayName": "Texture", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "Texture", + "m_StageCapability": 3, + "m_BareResource": false, + "m_Texture": { + "m_SerializedTexture": "{\"texture\":{\"instanceID\":0}}", + "m_Guid": "" + }, + "m_DefaultType": 0 +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicValueMaterialSlot", + "m_ObjectId": "33c3cf79ca494675bf7feafe0ed9594f", + "m_Id": 0, + "m_DisplayName": "A", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "A", + "m_StageCapability": 3, + "m_Value": { + "e00": 0.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 0.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 0.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 0.0 + }, + "m_DefaultValue": { + "e00": 1.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 1.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 1.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 1.0 + } +} + +{ + "m_SGVersion": 1, + "m_Type": "UnityEditor.ShaderGraph.Internal.Vector1ShaderProperty", + "m_ObjectId": "34d0f0bff6e74c40b4cf4609487b8cd6", + "m_Guid": { + "m_GuidSerialized": "5c366567-c261-4592-920e-ef7971399030" + }, + "m_Name": "Alpha Power", + "m_DefaultReferenceName": "", + "m_OverrideReferenceName": "_AlphaPower", + "m_GeneratePropertyBlock": true, + "m_Precision": 0, + "overrideHLSLDeclaration": false, + "hlslDeclarationOverride": 0, + "m_Hidden": false, + "m_Value": 0.800000011920929, + "m_FloatType": 1, + "m_RangeValues": { + "x": 0.009999999776482582, + "y": 2.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "35548bbcfdf246118323976e19cad65e", + "m_Id": 5, + "m_DisplayName": "G", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "G", + "m_StageCapability": 2, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.BlockNode", + "m_ObjectId": "358a13893c98426abb6bc4c3984c2dc8", + "m_Group": { + "m_Id": "" + }, + "m_Name": "SurfaceDescription.Alpha", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": 51.00004196166992, + "y": 62.000003814697269, + "width": 200.0, + "height": 41.0 + } + }, + "m_Slots": [ + { + "m_Id": "5bf37270ba754ed7ad94fb22e0a5a6be" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_SerializedDescriptor": "SurfaceDescription.Alpha" +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "35929c4279f84659bfcaada01f537c9e", + "m_Id": 1, + "m_DisplayName": "", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "359ed959f5ae49cc8ffb169c40b8e27c", + "m_Id": 1, + "m_DisplayName": "Out", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector3MaterialSlot", + "m_ObjectId": "35a13a4d1682463fa62dfeb696f6c3d6", + "m_Id": 0, + "m_DisplayName": "From", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "From", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 1.0, + "z": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0 + }, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.NormalMaterialSlot", + "m_ObjectId": "364bf0711ec54f028805cfb78c3b2936", + "m_Id": 0, + "m_DisplayName": "Normal (Tangent Space)", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "NormalTS", + "m_StageCapability": 2, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0 + }, + "m_Labels": [], + "m_Space": 3 +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "365cd65c568c4c9382b06b223f378be1", + "m_Id": 1, + "m_DisplayName": "Out", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.MultiplyNode", + "m_ObjectId": "366fe14bae29480a8d870a61047f38bf", + "m_Group": { + "m_Id": "" + }, + "m_Name": "Multiply", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -744.0, + "y": 504.0000305175781, + "width": 130.0, + "height": 118.00000762939453 + } + }, + "m_Slots": [ + { + "m_Id": "407171467b584927aba0bcd728e9e0cf" + }, + { + "m_Id": "27233a528aeb411280889b3cc096ce6d" + }, + { + "m_Id": "07d3bd34837d49efac457b1dd4f21469" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.TangentMaterialSlot", + "m_ObjectId": "36a7e27cf2f142179340d6911fb6702e", + "m_Id": 0, + "m_DisplayName": "Tangent", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "Tangent", + "m_StageCapability": 1, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0 + }, + "m_Labels": [], + "m_Space": 0 +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.PropertyNode", + "m_ObjectId": "37d47e939df243e19df140caeabc6088", + "m_Group": { + "m_Id": "3aedb1a4a3f540528911bf5344ee2e15" + }, + "m_Name": "Property", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -4461.0, + "y": -2664.0, + "width": 183.0, + "height": 34.0 + } + }, + "m_Slots": [ + { + "m_Id": "c9f72ba214714e51823232f53b68f2f9" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_Property": { + "m_Id": "ab6f8c0fc8fc4dd78cf1810dbf288488" + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "3811ccaba7684393bfb8069f4e4a016a", + "m_Id": 0, + "m_DisplayName": "Base", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "Base", + "m_StageCapability": 3, + "m_Value": { + "x": 1.0, + "y": 1.0, + "z": 1.0, + "w": 1.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "3835c9076d2842a1ad2bdbf2b0b22d3f", + "m_Id": 3, + "m_DisplayName": "Opacity", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "Opacity", + "m_StageCapability": 3, + "m_Value": 1.0, + "m_DefaultValue": 1.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "38ad6bc9c98e4a37b8ace60514a07bfa", + "m_Id": 0, + "m_DisplayName": "", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "3a36e0af1d014dd79a48ede02af5c854", + "m_Id": 0, + "m_DisplayName": "Ambient Occlusion", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "Occlusion", + "m_StageCapability": 2, + "m_Value": 1.0, + "m_DefaultValue": 1.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.GroupData", + "m_ObjectId": "3aedb1a4a3f540528911bf5344ee2e15", + "m_Title": "Highlight A", + "m_Position": { + "x": -4485.99951171875, + "y": -3022.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "3b62bae183e64b548cc5d7fc2f4888ee", + "m_Id": 3, + "m_DisplayName": "Out", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.PowerNode", + "m_ObjectId": "3b743ddc9ad64097a3679e91b83ab546", + "m_Group": { + "m_Id": "0da3d5800b834357824042477eb483dd" + }, + "m_Name": "Power", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -1658.0, + "y": -126.00003814697266, + "width": 126.0, + "height": 117.99999237060547 + } + }, + "m_Slots": [ + { + "m_Id": "c2c2e79a9d5247ada27d118ccad239ae" + }, + { + "m_Id": "60bc6a0a94e24dc0a088e70c10bcde39" + }, + { + "m_Id": "02681404df3b49b3b4a882e63c352cae" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "3b8a544f699c423c88e443f3c022627c", + "m_Id": 2, + "m_DisplayName": "Fac", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "Fac", + "m_StageCapability": 3, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "3b929e8fca7e47e89ef8b8ebcbddf16b", + "m_Id": 0, + "m_DisplayName": "Depth Prepass", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "3c80f97dbdf64454b8313bf869c39b0d", + "m_Id": 0, + "m_DisplayName": "", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "3ccf05f3e603432394a0a8cf219e6463", + "m_Id": 0, + "m_DisplayName": "Out", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "3ead7aeb80554142b1b8acd0ff2e0d13", + "m_Id": 0, + "m_DisplayName": "Alpha Clip Threshold Depth Postpass", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "AlphaClipThresholdDepthPostpass", + "m_StageCapability": 2, + "m_Value": 0.5, + "m_DefaultValue": 0.5, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "3fe87bcaf15d46d8a48659f7b2c426fe", + "m_Id": 1, + "m_DisplayName": "Out", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "40298bdf4a0e49b5b758a4ddc6cb9b9d", + "m_Id": 1, + "m_DisplayName": "Fac", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "Fac", + "m_StageCapability": 3, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicValueMaterialSlot", + "m_ObjectId": "407171467b584927aba0bcd728e9e0cf", + "m_Id": 0, + "m_DisplayName": "A", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "A", + "m_StageCapability": 3, + "m_Value": { + "e00": 0.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 0.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 0.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 0.0 + }, + "m_DefaultValue": { + "e00": 1.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 1.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 1.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.MultiplyNode", + "m_ObjectId": "414946c7e4fa4c1cb0a557ded20ecba2", + "m_Group": { + "m_Id": "244280d6eea94f08bb23a8e3db3784a3" + }, + "m_Name": "Multiply", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -6023.0, + "y": -3284.0, + "width": 125.99999237060547, + "height": 118.0 + } + }, + "m_Slots": [ + { + "m_Id": "b3ebad9010e044268b41a59a236ea578" + }, + { + "m_Id": "87d87188fc8445a78fdd8e9f2b5f9743" + }, + { + "m_Id": "5004a6abb602474a9f28c0b52b5d56f0" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicValueMaterialSlot", + "m_ObjectId": "4154ea606af6442987588d72a76c3c3d", + "m_Id": 1, + "m_DisplayName": "B", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "B", + "m_StageCapability": 3, + "m_Value": { + "e00": 2.0, + "e01": 2.0, + "e02": 2.0, + "e03": 2.0, + "e10": 2.0, + "e11": 2.0, + "e12": 2.0, + "e13": 2.0, + "e20": 2.0, + "e21": 2.0, + "e22": 2.0, + "e23": 2.0, + "e30": 2.0, + "e31": 2.0, + "e32": 2.0, + "e33": 2.0 + }, + "m_DefaultValue": { + "e00": 1.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 1.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 1.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.BlockNode", + "m_ObjectId": "4239ae5618e54aada26f71dc47c73c18", + "m_Group": { + "m_Id": "" + }, + "m_Name": "SurfaceDescription.SecondarySpecularTint", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": 61.0, + "y": 496.0, + "width": 200.0, + "height": 41.0 + } + }, + "m_Slots": [ + { + "m_Id": "2848c38716704c6da99bb5bfd339a5c4" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_SerializedDescriptor": "SurfaceDescription.SecondarySpecularTint" +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "42c406f1f550402f890e56f95f9808b3", + "m_Id": 1, + "m_DisplayName": "Out", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.BlockNode", + "m_ObjectId": "43b2f53e22494f52ad836aba700da7c7", + "m_Group": { + "m_Id": "" + }, + "m_Name": "SurfaceDescription.Occlusion", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": 0.0, + "y": 0.0, + "width": 0.0, + "height": 0.0 + } + }, + "m_Slots": [ + { + "m_Id": "3a36e0af1d014dd79a48ede02af5c854" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_SerializedDescriptor": "SurfaceDescription.Occlusion" +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "43f7b6d9bf324f8fba8b51d9b2d533ee", + "m_Id": 1, + "m_DisplayName": "Out", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.PropertyNode", + "m_ObjectId": "45445a2f270b47348746e62d75ebd6c7", + "m_Group": { + "m_Id": "" + }, + "m_Name": "Property", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -1650.0, + "y": 978.0000610351563, + "width": 162.0, + "height": 34.0 + } + }, + "m_Slots": [ + { + "m_Id": "f84ab63ad59d473790240bbae5312104" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_Property": { + "m_Id": "ddc2f22573d241e787bf84f06e4ba049" + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.SampleTexture2DNode", + "m_ObjectId": "454e8678d7fa4d8583459d67c01c0d1d", + "m_Group": { + "m_Id": "" + }, + "m_Name": "Sample Texture 2D", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -2294.000244140625, + "y": -290.99993896484377, + "width": 184.0, + "height": 253.00001525878907 + } + }, + "m_Slots": [ + { + "m_Id": "9434105a0b564544a9d1f31216367712" + }, + { + "m_Id": "15bc9145e40041e2b9da7df6f07eeee9" + }, + { + "m_Id": "f27d637587474cacb94bfd396d77089d" + }, + { + "m_Id": "fca9ffe88cae49efa8c33c1354e48c1d" + }, + { + "m_Id": "787d961abdfd4d58a8bd0b2a1e2db47d" + }, + { + "m_Id": "decdf89d9b1c47e49e07623e017ab4f8" + }, + { + "m_Id": "f04fd49f51ba4fb684bf9e7cfe737a4c" + }, + { + "m_Id": "c37c97a92c19442dad070dbf06704ded" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_TextureType": 0, + "m_NormalMapSpace": 0 +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "45ab6695a89b4c0d9656a3ba1ad00c29", + "m_Id": 0, + "m_DisplayName": "", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "45caa412775943ba95db5ef93db99949", + "m_Id": 0, + "m_DisplayName": "Alpha Clip", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "45dfc44534f541209f64118a5e0e118d", + "m_Id": 0, + "m_DisplayName": "Specular Shift", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.RedirectNodeData", + "m_ObjectId": "4664443c430b46538a01bbf9ce9ce1fc", + "m_Group": { + "m_Id": "0e8b3d01fbd24a99bdb2e8e85a456a90" + }, + "m_Name": "Redirect Node", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -4017.0, + "y": -1634.0001220703125, + "width": 56.000003814697269, + "height": 24.0 + } + }, + "m_Slots": [ + { + "m_Id": "6ae9fe3d09764fe5b3c77368298e37f3" + }, + { + "m_Id": "6054723e67ea472ca1360a7e6c797471" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "4694257c527b45868c3cac0b5e63b38a", + "m_Id": 1, + "m_DisplayName": "", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.UVMaterialSlot", + "m_ObjectId": "46a96a7d50a048188a0c1709db4421de", + "m_Id": 2, + "m_DisplayName": "UV", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "UV", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0 + }, + "m_Labels": [], + "m_Channel": 0 +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicValueMaterialSlot", + "m_ObjectId": "46b4fa9e809b4c358aab59de95e73ff9", + "m_Id": 0, + "m_DisplayName": "A", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "A", + "m_StageCapability": 3, + "m_Value": { + "e00": 0.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 0.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 0.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 0.0 + }, + "m_DefaultValue": { + "e00": 1.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 1.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 1.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.SamplerStateMaterialSlot", + "m_ObjectId": "46c045243fd947a3bf8f480d04000881", + "m_Id": 3, + "m_DisplayName": "Sampler", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "Sampler", + "m_StageCapability": 3, + "m_BareResource": false +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "46d72f7b7ef94239ab86a6ead5a8f8e6", + "m_Id": 0, + "m_DisplayName": "", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicValueMaterialSlot", + "m_ObjectId": "46febb3245ae4f47961062ce3ef3bda8", + "m_Id": 1, + "m_DisplayName": "", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "", + "m_StageCapability": 3, + "m_Value": { + "e00": 0.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 0.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 0.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 0.0 + }, + "m_DefaultValue": { + "e00": 1.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 1.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 1.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "47327438d4404b2aa0f090a73c62fec1", + "m_Id": 0, + "m_DisplayName": "In", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "In", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.GroupData", + "m_ObjectId": "4754e47d61844a86908699d8a6f31a28", + "m_Title": "Clip Quality Keywords", + "m_Position": { + "x": -1070.0, + "y": 1302.0001220703125 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.NormalMaterialSlot", + "m_ObjectId": "48748e76259b4423af31e7017f1b1967", + "m_Id": 0, + "m_DisplayName": "Normal", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "Normal", + "m_StageCapability": 1, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0 + }, + "m_Labels": [], + "m_Space": 0 +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.SamplerStateMaterialSlot", + "m_ObjectId": "48c97f375641468a90e44d106c97fc6a", + "m_Id": 3, + "m_DisplayName": "Sampler", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "Sampler", + "m_StageCapability": 3, + "m_BareResource": false +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "493b4f4104c2438f8498f6de58ada442", + "m_Id": 0, + "m_DisplayName": "", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "49cec6f655c34b46a219eed9fed64e30", + "m_Id": 0, + "m_DisplayName": "", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.BlendNode", + "m_ObjectId": "4a5109af1dce4a4ba5e917126d8eb1ab", + "m_Group": { + "m_Id": "03640179a61e456c8a3f77f11616681e" + }, + "m_Name": "Blend", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -767.9998779296875, + "y": -1017.0000610351563, + "width": 161.0, + "height": 178.0 + } + }, + "m_Slots": [ + { + "m_Id": "4b5d1faffbf74e9fb86118a9cbb814da" + }, + { + "m_Id": "7bb3bad3f14444c583f452e8fe543d8e" + }, + { + "m_Id": "31ee6324d28641d8afacb839dcf420eb" + }, + { + "m_Id": "9e198c5ab1424949bbdcd87af6c2666d" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_BlendMode": 21 +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "4a76173cb56049afb4021ffc98a09359", + "m_Id": 0, + "m_DisplayName": "", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "4ab8da5b661247edbcb394eddf59a155", + "m_Id": 3, + "m_DisplayName": "Opacity", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "Opacity", + "m_StageCapability": 3, + "m_Value": 1.0, + "m_DefaultValue": 1.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "4b31cead930147bdadc33a292daeed85", + "m_Id": 1, + "m_DisplayName": "Standard", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "STANDARD", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "4b5c95d79f4f4e1f80a4247ccff8ef70", + "m_Id": 4, + "m_DisplayName": "R", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "R", + "m_StageCapability": 2, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "4b5d1faffbf74e9fb86118a9cbb814da", + "m_Id": 0, + "m_DisplayName": "Base", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "Base", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.PropertyNode", + "m_ObjectId": "4be5e95fcd374b61bd561cf5a7bec49a", + "m_Group": { + "m_Id": "" + }, + "m_Name": "Property", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -1168.9998779296875, + "y": 306.9999694824219, + "width": 173.00001525878907, + "height": 34.000003814697269 + } + }, + "m_Slots": [ + { + "m_Id": "e9bda8c3d270475490b2b7838f87a7de" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_Property": { + "m_Id": "7ad41145b0c646049037af434d423fc6" + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "4c5025f9b1c24d89834e1e31376274db", + "m_Id": 5, + "m_DisplayName": "G", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "G", + "m_StageCapability": 2, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "4c9fb2a427ce450e9999c9f82a4ad54f", + "m_Id": 1, + "m_DisplayName": "Blend", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "Blend", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector3MaterialSlot", + "m_ObjectId": "4e4c5ea5d3094e1595676fdb82c3c6f2", + "m_Id": 0, + "m_DisplayName": "Hair Strand Direction", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "HairStrandDirection", + "m_StageCapability": 2, + "m_Value": { + "x": 0.0, + "y": -1.0, + "z": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0 + }, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "4e7893784aea4b66977da5d201763cfc", + "m_Id": 0, + "m_DisplayName": "Diffuse Strength", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.PropertyNode", + "m_ObjectId": "4e86ff273f104b47a35a04b03339a9d7", + "m_Group": { + "m_Id": "" + }, + "m_Name": "Property", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -1889.0, + "y": 432.0, + "width": 159.0, + "height": 34.000003814697269 + } + }, + "m_Slots": [ + { + "m_Id": "8f90b16bec664b40969b8192f7069d7e" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_Property": { + "m_Id": "ac27b0d8beef493a80956330658fb3e7" + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicValueMaterialSlot", + "m_ObjectId": "5004a6abb602474a9f28c0b52b5d56f0", + "m_Id": 2, + "m_DisplayName": "Out", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": { + "e00": 0.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 0.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 0.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 0.0 + }, + "m_DefaultValue": { + "e00": 1.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 1.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 1.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "509b6964be884e32b35af1b3b3e1de75", + "m_Id": 3, + "m_DisplayName": "Opacity", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "Opacity", + "m_StageCapability": 3, + "m_Value": 1.0, + "m_DefaultValue": 1.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "50faa87c66fe4c4b8090f1991390a20b", + "m_Id": 0, + "m_DisplayName": "", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.PropertyNode", + "m_ObjectId": "51595b2e0ca547c0a312a7b88240ed30", + "m_Group": { + "m_Id": "0da3d5800b834357824042477eb483dd" + }, + "m_Name": "Property", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -1614.0, + "y": -246.00009155273438, + "width": 164.0, + "height": 34.0 + } + }, + "m_Slots": [ + { + "m_Id": "d5dcab95cbd5417d88c86a4905d524cc" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_Property": { + "m_Id": "2d574f97db4a422aa1faa8f38ef8ab5f" + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.RedirectNodeData", + "m_ObjectId": "51bf0ed28e374cbe8ac7e34dab4a7ba2", + "m_Group": { + "m_Id": "0e8b3d01fbd24a99bdb2e8e85a456a90" + }, + "m_Name": "Redirect Node", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -4017.0, + "y": -1963.0001220703125, + "width": 56.0, + "height": 24.000001907348634 + } + }, + "m_Slots": [ + { + "m_Id": "6cacf3111f744fd694538ed03ec622d4" + }, + { + "m_Id": "10e7d59f5c0f4a2e945fa4e44a1728bc" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 1, + "m_Type": "UnityEditor.ShaderGraph.CustomFunctionNode", + "m_ObjectId": "520e6dc597e44dc9bebe93b078837c7b", + "m_Group": { + "m_Id": "0e8b3d01fbd24a99bdb2e8e85a456a90" + }, + "m_Name": "_InvertByOneMinusFac (Custom Function)", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -3753.0, + "y": -1680.0001220703125, + "width": 283.0, + "height": 118.0 + } + }, + "m_Slots": [ + { + "m_Id": "9e0785f63695465d9790652651774be3" + }, + { + "m_Id": "75c7c07763cf4d6e8e9bc0e7a67318a4" + }, + { + "m_Id": "e7ddd7819ca24c6ba7389b2c7c3917b2" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_SourceType": 1, + "m_FunctionName": "_InvertByOneMinusFac", + "m_FunctionSource": "", + "m_FunctionBody": "Out = lerp(In, 1.0 - In, 1.0 - Fac);" +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "52d52b0d72fa46d2a8c3b5761f07299b", + "m_Id": 0, + "m_DisplayName": "Out", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "5344a6989aba47fd9ea911a2503f6363", + "m_Id": 1, + "m_DisplayName": "", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "53d94da82d9d4a40b135feffa6178406", + "m_Id": 6, + "m_DisplayName": "B", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "B", + "m_StageCapability": 2, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector4MaterialSlot", + "m_ObjectId": "5459634fea3c44e59fdc9b6414840445", + "m_Id": 0, + "m_DisplayName": "Highlight B Color", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "5481c6230bcc4766b4a4b7e1486a01ca", + "m_Id": 0, + "m_DisplayName": "", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Texture2DMaterialSlot", + "m_ObjectId": "5491ec68c8244c85a00abd535ba9b720", + "m_Id": 0, + "m_DisplayName": "ID Map", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_BareResource": false +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector3MaterialSlot", + "m_ObjectId": "5511d7e8ad5044bcb20cbb1224be4cd3", + "m_Id": 0, + "m_DisplayName": "Transmittance", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "Transmittance", + "m_StageCapability": 2, + "m_Value": { + "x": 0.30000001192092898, + "y": 0.19500000774860383, + "z": 0.09000000357627869 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0 + }, + "m_Labels": [] +} + +{ + "m_SGVersion": 1, + "m_Type": "UnityEditor.ShaderGraph.Internal.Vector1ShaderProperty", + "m_ObjectId": "56ba91985bbb4952a91b73ed158b776b", + "m_Guid": { + "m_GuidSerialized": "c17b50b5-6f5e-4322-98eb-9cad49c410ad" + }, + "m_Name": "Highlight B Overlap End", + "m_DefaultReferenceName": "", + "m_OverrideReferenceName": "_HighlightBOverlapEnd", + "m_GeneratePropertyBlock": true, + "m_Precision": 0, + "overrideHLSLDeclaration": false, + "hlslDeclarationOverride": 0, + "m_Hidden": false, + "m_Value": 1.0, + "m_FloatType": 1, + "m_RangeValues": { + "x": 0.0, + "y": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector4MaterialSlot", + "m_ObjectId": "58711163a142498093e1638e6ecf2aa1", + "m_Id": 0, + "m_DisplayName": "Vertex Base Color", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.SamplerStateMaterialSlot", + "m_ObjectId": "5874a8cec8cf4abf8f56c8ee53245f1a", + "m_Id": 3, + "m_DisplayName": "Sampler", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "Sampler", + "m_StageCapability": 3, + "m_BareResource": false +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Texture2DInputMaterialSlot", + "m_ObjectId": "58fa216e5e6f4b7c9ac858c6790c22fb", + "m_Id": 1, + "m_DisplayName": "Texture", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "Texture", + "m_StageCapability": 3, + "m_BareResource": false, + "m_Texture": { + "m_SerializedTexture": "{\"texture\":{\"instanceID\":0}}", + "m_Guid": "" + }, + "m_DefaultType": 0 +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "5b27aa17be4b4644916146c205290a85", + "m_Id": 0, + "m_DisplayName": "Smoothness Max", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.PropertyNode", + "m_ObjectId": "5b2deb6b50d54492944439b12c257cfa", + "m_Group": { + "m_Id": "3aedb1a4a3f540528911bf5344ee2e15" + }, + "m_Name": "Property", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -4456.0, + "y": -2522.0, + "width": 201.0, + "height": 34.0 + } + }, + "m_Slots": [ + { + "m_Id": "82339627a5a54df19277dfe2c539f52a" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_Property": { + "m_Id": "1eba045aa0eb497597cd205664aeb8ec" + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "5b6eb9a8e89544fca1dbfd7d39558f67", + "m_Id": 3, + "m_DisplayName": "Opacity", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "Opacity", + "m_StageCapability": 3, + "m_Value": 1.0, + "m_DefaultValue": 1.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.PropertyNode", + "m_ObjectId": "5b7fb36f8a124e63b24b1f4891c7d268", + "m_Group": { + "m_Id": "b773332f12a640f2961cff577b07701f" + }, + "m_Name": "Property", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -1882.9998779296875, + "y": 1395.0, + "width": 130.0, + "height": 34.0 + } + }, + "m_Slots": [ + { + "m_Id": "45caa412775943ba95db5ef93db99949" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_Property": { + "m_Id": "d962fe658f9a4982b62bd75d03b2276e" + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicValueMaterialSlot", + "m_ObjectId": "5b8032c360414a4a9f95bd5c607c118c", + "m_Id": 2, + "m_DisplayName": "Out", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": { + "e00": 0.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 0.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 0.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 0.0 + }, + "m_DefaultValue": { + "e00": 1.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 1.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 1.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "5b98637dcaf04243918163b5170b55da", + "m_Id": 5, + "m_DisplayName": "G", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "G", + "m_StageCapability": 2, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.PropertyNode", + "m_ObjectId": "5bc2e2ebb6e84033be0c02d88425a9d9", + "m_Group": { + "m_Id": "" + }, + "m_Name": "Property", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -2519.000244140625, + "y": -288.99993896484377, + "width": 139.0, + "height": 34.000003814697269 + } + }, + "m_Slots": [ + { + "m_Id": "baf616c41c254dcca387f1819d9a2a42" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_Property": { + "m_Id": "6dc6a8e2ab304a639656ee2082845e1c" + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "5bf37270ba754ed7ad94fb22e0a5a6be", + "m_Id": 0, + "m_DisplayName": "Alpha", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "Alpha", + "m_StageCapability": 2, + "m_Value": 1.0, + "m_DefaultValue": 1.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "5c85d658386b4b13bd3a308504910663", + "m_Id": 5, + "m_DisplayName": "G", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "G", + "m_StageCapability": 2, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.RedirectNodeData", + "m_ObjectId": "5cd5b507a13647d4a17df6f6a63455bc", + "m_Group": { + "m_Id": "" + }, + "m_Name": "Redirect Node", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -4985.0, + "y": -2288.0, + "width": 56.000003814697269, + "height": 24.000001907348634 + } + }, + "m_Slots": [ + { + "m_Id": "46d72f7b7ef94239ab86a6ead5a8f8e6" + }, + { + "m_Id": "d387dd07da1e4951a0e8ed8ac88c0e9a" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 1, + "m_Type": "UnityEditor.ShaderGraph.Internal.Vector1ShaderProperty", + "m_ObjectId": "5d4c697aa2e74bdbb12725c42b2313e7", + "m_Guid": { + "m_GuidSerialized": "5b5af7c1-d733-4406-ad7f-139ef1fb78c5" + }, + "m_Name": "Rim Transmission Intensity", + "m_DefaultReferenceName": "", + "m_OverrideReferenceName": "_RimTransmissionIntensity", + "m_GeneratePropertyBlock": true, + "m_Precision": 0, + "overrideHLSLDeclaration": false, + "hlslDeclarationOverride": 2, + "m_Hidden": false, + "m_Value": 0.05000000074505806, + "m_FloatType": 1, + "m_RangeValues": { + "x": 0.0, + "y": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.UVMaterialSlot", + "m_ObjectId": "5dab28517be2484da7f0b376f4ba025e", + "m_Id": 2, + "m_DisplayName": "UV", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "UV", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0 + }, + "m_Labels": [], + "m_Channel": 0 +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector4MaterialSlot", + "m_ObjectId": "5e0fe5e94dc24bf6813a9916ddf06b19", + "m_Id": 0, + "m_DisplayName": "Out", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "5e351a9c13a74f909cf032de19e6ecba", + "m_Id": 0, + "m_DisplayName": "", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "5e41c4bbce0b4e3497c96545d2282b08", + "m_Id": 0, + "m_DisplayName": "In", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "In", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 1, + "m_Type": "UnityEditor.ShaderGraph.Internal.Vector1ShaderProperty", + "m_ObjectId": "5ef8aef8a81b4183b2aa03d38ada5d75", + "m_Guid": { + "m_GuidSerialized": "c99cfa48-2a38-421d-b471-4979b348a1c3" + }, + "m_Name": "Vertex Color Strength", + "m_DefaultReferenceName": "Vector1_5ef8aef8a81b4183b2aa03d38ada5d75", + "m_OverrideReferenceName": "_VertexColorStrength", + "m_GeneratePropertyBlock": true, + "m_Precision": 0, + "overrideHLSLDeclaration": false, + "hlslDeclarationOverride": 0, + "m_Hidden": false, + "m_Value": 0.5, + "m_FloatType": 1, + "m_RangeValues": { + "x": 0.0, + "y": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "5f33a7f72ce84cc485cb00c5e93aa01a", + "m_Id": 1, + "m_DisplayName": "B", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "B", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.PropertyNode", + "m_ObjectId": "5f984a05a60b4f76afa0ec01041e1d96", + "m_Group": { + "m_Id": "72585dd91b3d4da7b55123bae128c48b" + }, + "m_Name": "Property", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -6434.0, + "y": -2167.0, + "width": 148.0, + "height": 34.0 + } + }, + "m_Slots": [ + { + "m_Id": "2c3d261d1f3443b4b06b82a9e110faef" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_Property": { + "m_Id": "62ba90b39c554829b983338182c6db53" + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DitherNode", + "m_ObjectId": "601c6eaea0204053a13a8ac70dd09d06", + "m_Group": { + "m_Id": "b3823636393244d99c581f1785baf857" + }, + "m_Name": "Dither", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -1607.9998779296875, + "y": 1834.0, + "width": 202.0, + "height": 118.0 + } + }, + "m_Slots": [ + { + "m_Id": "8bbf0bdfb6cd4cb7b1070a2ecd46a157" + }, + { + "m_Id": "aee77a08299944a9b9d28832d825355c" + }, + { + "m_Id": "e30d33c3db434bae88da4c3b97aae575" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "6054723e67ea472ca1360a7e6c797471", + "m_Id": 1, + "m_DisplayName": "", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DitherNode", + "m_ObjectId": "6069340092004c1191a211a8d3274b3d", + "m_Group": { + "m_Id": "b3823636393244d99c581f1785baf857" + }, + "m_Name": "Dither", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -1882.9998779296875, + "y": 1952.0, + "width": 202.0, + "height": 118.0 + } + }, + "m_Slots": [ + { + "m_Id": "c6b2bdeea61f477c8613fc7f050fa911" + }, + { + "m_Id": "c397f7900ec14147bae4c9c1de892440" + }, + { + "m_Id": "8a33ae3b6dc04e9ea7202337a7bdb983" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "60bc6a0a94e24dc0a088e70c10bcde39", + "m_Id": 1, + "m_DisplayName": "B", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "B", + "m_StageCapability": 3, + "m_Value": { + "x": 2.0, + "y": 2.0, + "z": 2.0, + "w": 2.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.PropertyNode", + "m_ObjectId": "60f1e7e5998d42d5be5bf1c40597f04f", + "m_Group": { + "m_Id": "b773332f12a640f2961cff577b07701f" + }, + "m_Name": "Property", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -2177.0, + "y": 1685.0, + "width": 153.0, + "height": 34.0 + } + }, + "m_Slots": [ + { + "m_Id": "3b929e8fca7e47e89ef8b8ebcbddf16b" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_Property": { + "m_Id": "7a9dca43a15c41859b95c7edb930b3db" + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Texture2DInputMaterialSlot", + "m_ObjectId": "60f5c5dda134431287bf9b6f82a257ce", + "m_Id": 1, + "m_DisplayName": "Texture", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "Texture", + "m_StageCapability": 3, + "m_BareResource": false, + "m_Texture": { + "m_SerializedTexture": "{\"texture\":{\"instanceID\":0}}", + "m_Guid": "" + }, + "m_DefaultType": 0 +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicValueMaterialSlot", + "m_ObjectId": "618c44c9290e44378601d9b89b5f9b83", + "m_Id": 1, + "m_DisplayName": "B", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "B", + "m_StageCapability": 3, + "m_Value": { + "e00": 2.0, + "e01": 2.0, + "e02": 2.0, + "e03": 2.0, + "e10": 2.0, + "e11": 2.0, + "e12": 2.0, + "e13": 2.0, + "e20": 2.0, + "e21": 2.0, + "e22": 2.0, + "e23": 2.0, + "e30": 2.0, + "e31": 2.0, + "e32": 2.0, + "e33": 2.0 + }, + "m_DefaultValue": { + "e00": 1.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 1.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 1.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "61b1fa4982b349249be7fc970cde0912", + "m_Id": 0, + "m_DisplayName": "In", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "In", + "m_StageCapability": 3, + "m_Value": { + "x": 1.0, + "y": 1.0, + "z": 1.0, + "w": 1.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.PropertyNode", + "m_ObjectId": "627b5ab6400f4b94ae60bfcab74b4ab5", + "m_Group": { + "m_Id": "" + }, + "m_Name": "Property", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -571.0, + "y": 360.0, + "width": 216.00001525878907, + "height": 34.0 + } + }, + "m_Slots": [ + { + "m_Id": "2c932aab8a0447e09e2733f0afcd0feb" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_Property": { + "m_Id": "5d4c697aa2e74bdbb12725c42b2313e7" + } +} + +{ + "m_SGVersion": 1, + "m_Type": "UnityEditor.ShaderGraph.Internal.Vector1ShaderProperty", + "m_ObjectId": "629bfa855bb345f5b11dd44954fbddba", + "m_Guid": { + "m_GuidSerialized": "a82edcba-4fed-4ba8-9007-3a79175ba3b7" + }, + "m_Name": "Secondary Specular Shift", + "m_DefaultReferenceName": "", + "m_OverrideReferenceName": "_SecondarySpecularShift", + "m_GeneratePropertyBlock": true, + "m_Precision": 0, + "overrideHLSLDeclaration": false, + "hlslDeclarationOverride": 0, + "m_Hidden": false, + "m_Value": 0.15000000596046449, + "m_FloatType": 1, + "m_RangeValues": { + "x": -1.0, + "y": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Internal.Texture2DShaderProperty", + "m_ObjectId": "62ba90b39c554829b983338182c6db53", + "m_Guid": { + "m_GuidSerialized": "ffcaae55-d07d-4e7a-a6b5-45d201ee4df5" + }, + "m_Name": "Diffuse Map", + "m_DefaultReferenceName": "Texture2D_62ba90b39c554829b983338182c6db53", + "m_OverrideReferenceName": "_DiffuseMap", + "m_GeneratePropertyBlock": true, + "m_Precision": 0, + "overrideHLSLDeclaration": false, + "hlslDeclarationOverride": 2, + "m_Hidden": false, + "m_Value": { + "m_SerializedTexture": "{\"texture\":{\"instanceID\":0}}", + "m_Guid": "" + }, + "m_Modifiable": true, + "m_DefaultType": 0 +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.ColorRGBMaterialSlot", + "m_ObjectId": "62d6d2cb38b34a8dae2f3582eadc51fd", + "m_Id": 0, + "m_DisplayName": "Emission", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "Emission", + "m_StageCapability": 2, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0 + }, + "m_Labels": [], + "m_ColorMode": 1, + "m_DefaultColor": { + "r": 0.0, + "g": 0.0, + "b": 0.0, + "a": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "63d8248fcb2844c3a311456a94427691", + "m_Id": 0, + "m_DisplayName": "End Color Strength", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "643250ef0d8741a19386e415a95301b8", + "m_Id": 0, + "m_DisplayName": "Alpha Remap", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Texture2DInputMaterialSlot", + "m_ObjectId": "645f90c185f2471d9630858b570a39ca", + "m_Id": 1, + "m_DisplayName": "Texture", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "Texture", + "m_StageCapability": 3, + "m_BareResource": false, + "m_Texture": { + "m_SerializedTexture": "{\"texture\":{\"instanceID\":0}}", + "m_Guid": "" + }, + "m_DefaultType": 3 +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "649c1c4ff7a549e2a6ca39dac06f31c2", + "m_Id": 0, + "m_DisplayName": "In", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "In", + "m_StageCapability": 3, + "m_Value": { + "x": 1.0, + "y": 1.0, + "z": 1.0, + "w": 1.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicValueMaterialSlot", + "m_ObjectId": "64baa9795a224e1d897c57704d370950", + "m_Id": 2, + "m_DisplayName": "Out", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": { + "e00": 0.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 0.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 0.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 0.0 + }, + "m_DefaultValue": { + "e00": 1.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 1.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 1.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicValueMaterialSlot", + "m_ObjectId": "65201543557f4f3383d0127291d0f110", + "m_Id": 2, + "m_DisplayName": "Out", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": { + "e00": 0.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 0.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 0.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 0.0 + }, + "m_DefaultValue": { + "e00": 1.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 1.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 1.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "65a7bf4f97f840ca96e663885f94ada4", + "m_Id": 0, + "m_DisplayName": "Ambient Occlusion Strength", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.Rendering.HighDefinition.ShaderGraph.LightingData", + "m_ObjectId": "6642d27020f646129f5cda404c16ec41", + "m_NormalDropOffSpace": 0, + "m_BlendPreserveSpecular": true, + "m_ReceiveDecals": true, + "m_ReceiveSSR": true, + "m_ReceiveSSRTransparent": false, + "m_SpecularAA": false, + "m_SpecularOcclusionMode": 1, + "m_OverrideBakedGI": false +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "66c44281292d4a29a4209f12788c935b", + "m_Id": 5, + "m_DisplayName": "G", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "G", + "m_StageCapability": 2, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "6851ee7b471645219d7bf0ce950d3312", + "m_Id": 2, + "m_DisplayName": "Out", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.BlockNode", + "m_ObjectId": "687659d5f2844131913f3ebec5692c99", + "m_Group": { + "m_Id": "" + }, + "m_Name": "SurfaceDescription.Smoothness", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": 58.9999885559082, + "y": 272.0, + "width": 200.00001525878907, + "height": 41.000003814697269 + } + }, + "m_Slots": [ + { + "m_Id": "22d366686d314c62ab9ea7700c1b42e7" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_SerializedDescriptor": "SurfaceDescription.Smoothness" +} + +{ + "m_SGVersion": 1, + "m_Type": "UnityEditor.ShaderGraph.CustomFunctionNode", + "m_ObjectId": "68ff830c789148479896d5d8c55d6283", + "m_Group": { + "m_Id": "244280d6eea94f08bb23a8e3db3784a3" + }, + "m_Name": "_InvertByFac (Custom Function)", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -5928.0, + "y": -3047.0, + "width": 225.99998474121095, + "height": 117.99999237060547 + } + }, + "m_Slots": [ + { + "m_Id": "abdcfcac97c640f7a0e4286449cbbd92" + }, + { + "m_Id": "3b8a544f699c423c88e443f3c022627c" + }, + { + "m_Id": "b35ce8b14ba249288521774971ed2f94" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_SourceType": 1, + "m_FunctionName": "_InvertByFac", + "m_FunctionSource": "", + "m_FunctionBody": "Out = lerp(In, 1.0 - In, Fac);" +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.BlendNode", + "m_ObjectId": "69305a34e02b4af4bbb8430ee60baa8f", + "m_Group": { + "m_Id": "3aedb1a4a3f540528911bf5344ee2e15" + }, + "m_Name": "Blend", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -3223.0, + "y": -2962.999755859375, + "width": 161.0, + "height": 177.99998474121095 + } + }, + "m_Slots": [ + { + "m_Id": "ca5234deb5234b29b26df2134352eaed" + }, + { + "m_Id": "b388214065ad4683980684e100cf0de6" + }, + { + "m_Id": "ee0b9fe103af4a44b35f4380cd3b3973" + }, + { + "m_Id": "72062fe7a2b3405c81f5a969ee69db8e" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_BlendMode": 21 +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "694656ca8fa54c51800375119dcf4738", + "m_Id": 2, + "m_DisplayName": "Noise", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "NOISE", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "6a4ddba6f8a446449e5aafa335b28022", + "m_Id": 4, + "m_DisplayName": "R", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "R", + "m_StageCapability": 2, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "6a503b2086f54950b079d6857a4e807d", + "m_Id": 6, + "m_DisplayName": "B", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "B", + "m_StageCapability": 2, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.SaturateNode", + "m_ObjectId": "6ae52db55a2846f28176b9aa785e3cb4", + "m_Group": { + "m_Id": "72585dd91b3d4da7b55123bae128c48b" + }, + "m_Name": "Saturate", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -5970.0, + "y": -1986.0, + "width": 128.0, + "height": 94.0 + } + }, + "m_Slots": [ + { + "m_Id": "1916f5588320445385b044aa53702e1e" + }, + { + "m_Id": "13649b671ad94c90a236768ce90cb3d5" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "6ae9fe3d09764fe5b3c77368298e37f3", + "m_Id": 0, + "m_DisplayName": "", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "6b144959660d498b94f292e09d9ef69a", + "m_Id": 0, + "m_DisplayName": "In", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "In", + "m_StageCapability": 3, + "m_Value": { + "x": 1.0, + "y": 1.0, + "z": 1.0, + "w": 1.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.RedirectNodeData", + "m_ObjectId": "6b2e66277a7943f5800e4557cd983757", + "m_Group": { + "m_Id": "" + }, + "m_Name": "Redirect Node", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -411.99981689453127, + "y": 215.99998474121095, + "width": 56.0, + "height": 23.999998092651368 + } + }, + "m_Slots": [ + { + "m_Id": "38ad6bc9c98e4a37b8ace60514a07bfa" + }, + { + "m_Id": "eac54b5f186d486e80825976e56c5237" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "6b5deda71f474aee97807127ea957961", + "m_Id": 4, + "m_DisplayName": "R", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "R", + "m_StageCapability": 2, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.VertexColorNode", + "m_ObjectId": "6b630368d3bb456ca8c23ca7e50298d2", + "m_Group": { + "m_Id": "03640179a61e456c8a3f77f11616681e" + }, + "m_Name": "Vertex Color", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -2033.0001220703125, + "y": -963.0, + "width": 116.00000762939453, + "height": 94.0 + } + }, + "m_Slots": [ + { + "m_Id": "ddcb7341ea314d2a9dfbbc1d9d9f4fbd" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 2, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "6b773772c1d047e0bcbf0c12e2a24b3c", + "m_Id": 0, + "m_DisplayName": "A", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "A", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector4MaterialSlot", + "m_ObjectId": "6c3bedec93094896bde411fafa3e8dc6", + "m_Id": 0, + "m_DisplayName": "RGBA", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "RGBA", + "m_StageCapability": 2, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.PropertyNode", + "m_ObjectId": "6c82b6ddafb64673b5161a23abfc93e4", + "m_Group": { + "m_Id": "be2cb7795a6143a498576442f64713d6" + }, + "m_Name": "Property", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -1603.999755859375, + "y": 1236.0, + "width": 153.0, + "height": 34.0 + } + }, + "m_Slots": [ + { + "m_Id": "95c2bc57f4dd42d7b05fd17539661814" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_Property": { + "m_Id": "7a9dca43a15c41859b95c7edb930b3db" + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "6cacf3111f744fd694538ed03ec622d4", + "m_Id": 0, + "m_DisplayName": "", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.SampleTexture2DNode", + "m_ObjectId": "6cf2216245ca4c94a226d2a52deb5633", + "m_Group": { + "m_Id": "" + }, + "m_Name": "Sample Texture 2D", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -1672.0, + "y": 412.9999694824219, + "width": 184.0, + "height": 253.00001525878907 + } + }, + "m_Slots": [ + { + "m_Id": "1b344d261ec648189f8ff9340b0ed20c" + }, + { + "m_Id": "6cf943c0e05c4227a451bfe832fb0e00" + }, + { + "m_Id": "ab63acc371ab4765a2800d13b87b7152" + }, + { + "m_Id": "864866bcd4e4447fbe0cc68f600714d4" + }, + { + "m_Id": "db66712351c04b3eb291dd17798f7b1c" + }, + { + "m_Id": "60f5c5dda134431287bf9b6f82a257ce" + }, + { + "m_Id": "8fe0ba5e3f2845ec8b9295f68c04d12d" + }, + { + "m_Id": "e97c3fa8ab4d480faefb7391b4a9c808" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_TextureType": 0, + "m_NormalMapSpace": 0 +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "6cf943c0e05c4227a451bfe832fb0e00", + "m_Id": 4, + "m_DisplayName": "R", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "R", + "m_StageCapability": 2, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.PropertyNode", + "m_ObjectId": "6d00c754a1b5489990a6a6f802a8492c", + "m_Group": { + "m_Id": "3aedb1a4a3f540528911bf5344ee2e15" + }, + "m_Name": "Property", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -4461.0, + "y": -2772.0, + "width": 201.0, + "height": 34.0 + } + }, + "m_Slots": [ + { + "m_Id": "106b7a1cedb94596a16d44ae0c54951f" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_Property": { + "m_Id": "2824b0c4fe6c4ff3b6d72dcfe453a320" + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Internal.Texture2DShaderProperty", + "m_ObjectId": "6dc6a8e2ab304a639656ee2082845e1c", + "m_Guid": { + "m_GuidSerialized": "553fed75-2c32-4ba5-9e11-bc8403abcfc3" + }, + "m_Name": "Mask Map", + "m_DefaultReferenceName": "Texture2D_6dc6a8e2ab304a639656ee2082845e1c", + "m_OverrideReferenceName": "_MaskMap", + "m_GeneratePropertyBlock": true, + "m_Precision": 0, + "overrideHLSLDeclaration": false, + "hlslDeclarationOverride": 0, + "m_Hidden": false, + "m_Value": { + "m_SerializedTexture": "{\"texture\":{\"instanceID\":0}}", + "m_Guid": "" + }, + "m_Modifiable": true, + "m_DefaultType": 0 +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "6df8942427534735b1532b35c0b04100", + "m_Id": 0, + "m_DisplayName": "Highlight B Overlap End", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "6e0af7bfd7ad496491185bdd505e04dc", + "m_Id": 0, + "m_DisplayName": "Base", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "Base", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.RedirectNodeData", + "m_ObjectId": "6e7f71ec59fb413b942f9ce72cf1967c", + "m_Group": { + "m_Id": "" + }, + "m_Name": "Redirect Node", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -411.0000305175781, + "y": -670.0000610351563, + "width": 56.0, + "height": 24.000001907348634 + } + }, + "m_Slots": [ + { + "m_Id": "334baaea25334886ba55b47a00a70600" + }, + { + "m_Id": "927b00c341304144a459a766397301d6" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.PropertyNode", + "m_ObjectId": "6ecff3af82ac40418c956f8a38fda7d3", + "m_Group": { + "m_Id": "244280d6eea94f08bb23a8e3db3784a3" + }, + "m_Name": "Property", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -6799.0, + "y": -3314.0, + "width": 136.0, + "height": 34.0 + } + }, + "m_Slots": [ + { + "m_Id": "92314ee51e1e4c09a6c0c4ec16b976c2" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_Property": { + "m_Id": "2f97d87b4e54435a8e9aab991aa2ca95" + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "6f484dea1069470eb479d882654b3ea7", + "m_Id": 7, + "m_DisplayName": "A", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "A", + "m_StageCapability": 2, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.PropertyNode", + "m_ObjectId": "6f6152d8538648468b848cd049b3d36d", + "m_Group": { + "m_Id": "72585dd91b3d4da7b55123bae128c48b" + }, + "m_Name": "Property", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -6170.0, + "y": -1838.9998779296875, + "width": 142.0, + "height": 34.0 + } + }, + "m_Slots": [ + { + "m_Id": "983c74ad11d14734b9f6bf6b848387f9" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_Property": { + "m_Id": "34d0f0bff6e74c40b4cf4609487b8cd6" + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "706c65f8499a462787a6fa1aa6d4c4a0", + "m_Id": 0, + "m_DisplayName": "In", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "In", + "m_StageCapability": 3, + "m_Value": { + "x": 1.0, + "y": 1.0, + "z": 1.0, + "w": 1.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "72062fe7a2b3405c81f5a969ee69db8e", + "m_Id": 2, + "m_DisplayName": "Out", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "720effcec7324554ad9df79acddac33a", + "m_Id": 1, + "m_DisplayName": "B", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "B", + "m_StageCapability": 3, + "m_Value": { + "x": 2.0, + "y": 2.0, + "z": 2.0, + "w": 2.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "72408d8c59e6451f8a9f8fe57493ee3b", + "m_Id": 0, + "m_DisplayName": "In", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "In", + "m_StageCapability": 3, + "m_Value": { + "x": 1.0, + "y": 1.0, + "z": 1.0, + "w": 1.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.GroupData", + "m_ObjectId": "72585dd91b3d4da7b55123bae128c48b", + "m_Title": "Diffuse and Alpha", + "m_Position": { + "x": -6459.00048828125, + "y": -2226.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "7260c54475d24fdc9dc73a6544edaa9c", + "m_Id": 6, + "m_DisplayName": "B", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "B", + "m_StageCapability": 2, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.PropertyNode", + "m_ObjectId": "72d4a986e38a498bae8f34613460f37e", + "m_Group": { + "m_Id": "" + }, + "m_Name": "Property", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -1038.999755859375, + "y": 1867.9998779296875, + "width": 160.0, + "height": 34.0 + } + }, + "m_Slots": [ + { + "m_Id": "03014458088c4ce5abc7a07b694efe86" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_Property": { + "m_Id": "1b66a7533fa643888276c4f6de382ca9" + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Internal.Texture2DShaderProperty", + "m_ObjectId": "72d65bc7d4664f6aae2853e9a0fcb1e9", + "m_Guid": { + "m_GuidSerialized": "fd8dc417-4020-44d4-8787-166a98bd721e" + }, + "m_Name": "Blend Map", + "m_DefaultReferenceName": "", + "m_OverrideReferenceName": "_BlendMap", + "m_GeneratePropertyBlock": true, + "m_Precision": 0, + "overrideHLSLDeclaration": false, + "hlslDeclarationOverride": 0, + "m_Hidden": false, + "m_Value": { + "m_SerializedTexture": "{\"texture\":{\"instanceID\":0}}", + "m_Guid": "" + }, + "m_Modifiable": true, + "m_DefaultType": 0 +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "74013a788cdf497dbb1045c3e26fedac", + "m_Id": 1, + "m_DisplayName": "Blend", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "Blend", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "7428c719b8fa4b99a1a64c81167a2d93", + "m_Id": 3, + "m_DisplayName": "Out", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "745de5ab8f8745b8aea6ee647a2a5804", + "m_Id": 1, + "m_DisplayName": "Blend", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "Blend", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "75c7c07763cf4d6e8e9bc0e7a67318a4", + "m_Id": 2, + "m_DisplayName": "Fac", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "Fac", + "m_StageCapability": 3, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.BlockNode", + "m_ObjectId": "76ac26031b7c43a6a78d7e9db5db64be", + "m_Group": { + "m_Id": "" + }, + "m_Name": "SurfaceDescription.BentNormal", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": 32.000003814697269, + "y": 610.0, + "width": 200.0, + "height": 41.0 + } + }, + "m_Slots": [ + { + "m_Id": "1748e4e9d24e4de7932315b2e25527ce" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_SerializedDescriptor": "SurfaceDescription.BentNormal" +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.MultiplyNode", + "m_ObjectId": "77356f6efe684b15bacc81e99c0fc187", + "m_Group": { + "m_Id": "03640179a61e456c8a3f77f11616681e" + }, + "m_Name": "Multiply", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -2130.0, + "y": -1341.0, + "width": 130.0, + "height": 118.00000762939453 + } + }, + "m_Slots": [ + { + "m_Id": "198b443bd3f14dc8988cc66463ed7085" + }, + { + "m_Id": "618c44c9290e44378601d9b89b5f9b83" + }, + { + "m_Id": "249f8c2e63b24345b026d975bf380539" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "7756e79b76714e4396a582857d12cbeb", + "m_Id": 3, + "m_DisplayName": "Dither", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "DITHER", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 1, + "m_Type": "UnityEditor.ShaderGraph.Internal.Vector1ShaderProperty", + "m_ObjectId": "77ed3559eef14481b5a4ecb0f498dd93", + "m_Guid": { + "m_GuidSerialized": "e68a7e54-faab-4cdd-8a8d-d20f2d455b0c" + }, + "m_Name": "Highlight B Strength", + "m_DefaultReferenceName": "", + "m_OverrideReferenceName": "_HighlightBStrength", + "m_GeneratePropertyBlock": true, + "m_Precision": 0, + "overrideHLSLDeclaration": false, + "hlslDeclarationOverride": 0, + "m_Hidden": false, + "m_Value": 0.0, + "m_FloatType": 1, + "m_RangeValues": { + "x": 0.0, + "y": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "787d961abdfd4d58a8bd0b2a1e2db47d", + "m_Id": 7, + "m_DisplayName": "A", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "A", + "m_StageCapability": 2, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.PropertyNode", + "m_ObjectId": "7885d7a85a524469bed829c26fcc314a", + "m_Group": { + "m_Id": "0e8b3d01fbd24a99bdb2e8e85a456a90" + }, + "m_Name": "Property", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -4017.0, + "y": -1899.000244140625, + "width": 183.00001525878907, + "height": 34.0 + } + }, + "m_Slots": [ + { + "m_Id": "f3096cdb279c45eeb8214d88c6601146" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_Property": { + "m_Id": "77ed3559eef14481b5a4ecb0f498dd93" + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.PropertyNode", + "m_ObjectId": "7a473df09e9b4bd3b82814666640158f", + "m_Group": { + "m_Id": "" + }, + "m_Name": "Property", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -1227.0, + "y": 628.0, + "width": 231.00001525878907, + "height": 34.000003814697269 + } + }, + "m_Slots": [ + { + "m_Id": "14ae49d9f448412f9e48b712d1468f27" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_Property": { + "m_Id": "8197dc419ed34d5e8c22c7c35775566a" + } +} + +{ + "m_SGVersion": 3, + "m_Type": "UnityEditor.ShaderGraph.Internal.ColorShaderProperty", + "m_ObjectId": "7a7ff89b265c40a9aeaad4f27130fb28", + "m_Guid": { + "m_GuidSerialized": "e48be876-7481-4d92-b95d-08c685906c05" + }, + "m_Name": "Root Color", + "m_DefaultReferenceName": "", + "m_OverrideReferenceName": "_RootColor", + "m_GeneratePropertyBlock": true, + "m_Precision": 0, + "overrideHLSLDeclaration": false, + "hlslDeclarationOverride": 0, + "m_Hidden": false, + "m_Value": { + "r": 0.3294117748737335, + "g": 0.1411764770746231, + "b": 0.05098039284348488, + "a": 0.0 + }, + "m_ColorMode": 0 +} + +{ + "m_SGVersion": 1, + "m_Type": "UnityEditor.ShaderGraph.Internal.Vector1ShaderProperty", + "m_ObjectId": "7a9dca43a15c41859b95c7edb930b3db", + "m_Guid": { + "m_GuidSerialized": "8ec5925d-958a-4990-8d66-01bb95754728" + }, + "m_Name": "Depth Prepass", + "m_DefaultReferenceName": "Vector1_7a9dca43a15c41859b95c7edb930b3db", + "m_OverrideReferenceName": "_DepthPrepass", + "m_GeneratePropertyBlock": true, + "m_Precision": 0, + "overrideHLSLDeclaration": false, + "hlslDeclarationOverride": 0, + "m_Hidden": false, + "m_Value": 0.8999999761581421, + "m_FloatType": 1, + "m_RangeValues": { + "x": 0.0, + "y": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "7ac4a2ee1dae4aefb1476b682c617c73", + "m_Id": 1, + "m_DisplayName": "X", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "X", + "m_StageCapability": 3, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "7ac7d38819cb49fbadbfc71413a3da76", + "m_Id": 0, + "m_DisplayName": "Secondary Smoothness", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "SecondarySmoothness", + "m_StageCapability": 2, + "m_Value": 0.5, + "m_DefaultValue": 0.5, + "m_Labels": [] +} + +{ + "m_SGVersion": 1, + "m_Type": "UnityEditor.ShaderGraph.Internal.Vector1ShaderProperty", + "m_ObjectId": "7ad41145b0c646049037af434d423fc6", + "m_Guid": { + "m_GuidSerialized": "8ba45b1e-7fc1-426d-84e0-33d302945c1a" + }, + "m_Name": "Specular Multiplier", + "m_DefaultReferenceName": "", + "m_OverrideReferenceName": "_SpecularMultiplier", + "m_GeneratePropertyBlock": true, + "m_Precision": 0, + "overrideHLSLDeclaration": false, + "hlslDeclarationOverride": 0, + "m_Hidden": false, + "m_Value": 0.5, + "m_FloatType": 1, + "m_RangeValues": { + "x": 0.0, + "y": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "7bb3bad3f14444c583f452e8fe543d8e", + "m_Id": 1, + "m_DisplayName": "Blend", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "Blend", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "7cbfe02cd2444b10b44b7bdec5e6e78b", + "m_Id": 7, + "m_DisplayName": "A", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "A", + "m_StageCapability": 2, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector4MaterialSlot", + "m_ObjectId": "7dbf0eb7f73346f89d219731f4e3b02a", + "m_Id": 0, + "m_DisplayName": "RGBA", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "RGBA", + "m_StageCapability": 2, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "7dc34a9bd8474c6db1ed46da3b63360c", + "m_Id": 2, + "m_DisplayName": "Out", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "7ea1e68a05354ad18b0e3014fb336186", + "m_Id": 0, + "m_DisplayName": "A", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "A", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "7ebc51c5ee6542f483e212e0a309011a", + "m_Id": 1, + "m_DisplayName": "Strength", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "Strength", + "m_StageCapability": 3, + "m_Value": 1.0, + "m_DefaultValue": 1.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.RedirectNodeData", + "m_ObjectId": "7f3672a3eba44aecb5dec9bdd7ea6ca3", + "m_Group": { + "m_Id": "3aedb1a4a3f540528911bf5344ee2e15" + }, + "m_Name": "Redirect Node", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -4456.0, + "y": -2920.999755859375, + "width": 56.0, + "height": 23.999998092651368 + } + }, + "m_Slots": [ + { + "m_Id": "010417d0c9bb421fa8c265f9afbc36ae" + }, + { + "m_Id": "f1f92f2e0bdf4aa899175eac8b32f2d6" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 1, + "m_Type": "UnityEditor.ShaderGraph.Internal.Vector3ShaderProperty", + "m_ObjectId": "7f66c6abce0e4576b0c98c2f4e19050c", + "m_Guid": { + "m_GuidSerialized": "42165121-c282-437e-86d8-edf47f695e85" + }, + "m_Name": "Highlight B Distribution", + "m_DefaultReferenceName": "Vector3_7f66c6abce0e4576b0c98c2f4e19050c", + "m_OverrideReferenceName": "_HighlightBDistribution", + "m_GeneratePropertyBlock": true, + "m_Precision": 0, + "overrideHLSLDeclaration": false, + "hlslDeclarationOverride": 0, + "m_Hidden": false, + "m_Value": { + "x": 0.6000000238418579, + "y": 0.699999988079071, + "z": 0.800000011920929, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "8026cfb04de041b082f4f67ec8866e35", + "m_Id": 0, + "m_DisplayName": "Depth Prepass", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.UVMaterialSlot", + "m_ObjectId": "8090a7638fc34eccbcbd70857701b7b4", + "m_Id": 2, + "m_DisplayName": "UV", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "UV", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0 + }, + "m_Labels": [], + "m_Channel": 0 +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "80957726e3df45db966134a9418138f8", + "m_Id": 0, + "m_DisplayName": "Alpha Clip", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "80a84d9d1dc34c60a7f53615da6a701b", + "m_Id": 0, + "m_DisplayName": "", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "811ad31b15994929a93a9dcd3651d6af", + "m_Id": 1, + "m_DisplayName": "Fac", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "Fac", + "m_StageCapability": 3, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.SaturateNode", + "m_ObjectId": "81429d7c3ed74f599b76aa7b8bfe9c7f", + "m_Group": { + "m_Id": "0e8b3d01fbd24a99bdb2e8e85a456a90" + }, + "m_Name": "Saturate", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -2952.0, + "y": -2007.000244140625, + "width": 128.0, + "height": 94.0 + } + }, + "m_Slots": [ + { + "m_Id": "5e41c4bbce0b4e3497c96545d2282b08" + }, + { + "m_Id": "dc1b9877907b479a88d384c2e3e55bff" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.MultiplyNode", + "m_ObjectId": "815740e575684a18ae4f7aced285fb16", + "m_Group": { + "m_Id": "" + }, + "m_Name": "Multiply", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -970.9999389648438, + "y": 427.0000305175781, + "width": 130.0, + "height": 118.0 + } + }, + "m_Slots": [ + { + "m_Id": "1dff7ccda7c2459fabb9d759da4ebbd8" + }, + { + "m_Id": "a1bd16c0f006490ea28c3fd3a27df8f0" + }, + { + "m_Id": "e7665d3760434dc88e41ba34f6d09177" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 1, + "m_Type": "UnityEditor.ShaderGraph.Internal.Vector1ShaderProperty", + "m_ObjectId": "8197dc419ed34d5e8c22c7c35775566a", + "m_Guid": { + "m_GuidSerialized": "ad5c7094-5822-4685-bf0c-ae8d59ca1faf" + }, + "m_Name": "Secondary Specular Multiplier", + "m_DefaultReferenceName": "", + "m_OverrideReferenceName": "_SecondarySpecularMultiplier", + "m_GeneratePropertyBlock": true, + "m_Precision": 0, + "overrideHLSLDeclaration": false, + "hlslDeclarationOverride": 0, + "m_Hidden": false, + "m_Value": 0.05000000074505806, + "m_FloatType": 1, + "m_RangeValues": { + "x": 0.0, + "y": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "82339627a5a54df19277dfe2c539f52a", + "m_Id": 0, + "m_DisplayName": "Highlight A Overlap End", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.BlockNode", + "m_ObjectId": "8277bdd1ba5e486788875b590047b626", + "m_Group": { + "m_Id": "" + }, + "m_Name": "SurfaceDescription.Emission", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": 57.000003814697269, + "y": 227.99998474121095, + "width": 200.0, + "height": 41.0 + } + }, + "m_Slots": [ + { + "m_Id": "62d6d2cb38b34a8dae2f3582eadc51fd" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_SerializedDescriptor": "SurfaceDescription.Emission" +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "82f081e4a28545b4870f059eaf9ec02b", + "m_Id": 1, + "m_DisplayName": "Out", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "83ccede77bf347b5ada7f22a90a71e54", + "m_Id": 4, + "m_DisplayName": "R", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "R", + "m_StageCapability": 2, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "843521d5bed044cf9b6d0d6034f14cd9", + "m_Id": 0, + "m_DisplayName": "In", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "In", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "8608d2b6360a457a818cd7857bf72ad4", + "m_Id": 0, + "m_DisplayName": "Alpha Clip Threshold Depth Prepass", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "AlphaClipThresholdDepthPrepass", + "m_StageCapability": 2, + "m_Value": 0.5, + "m_DefaultValue": 0.5, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.ScreenPositionNode", + "m_ObjectId": "860c97ed98f348e0942b9e5eb0916c14", + "m_Group": { + "m_Id": "b773332f12a640f2961cff577b07701f" + }, + "m_Name": "Screen Position", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -2168.999755859375, + "y": 1454.0, + "width": 145.0, + "height": 130.0 + } + }, + "m_Slots": [ + { + "m_Id": "f6e8c313d5084dee886ad054638ec381" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_ScreenSpaceType": 3 +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.PropertyNode", + "m_ObjectId": "86455e4666b643bf91cfbaf131d45eb1", + "m_Group": { + "m_Id": "184a4bbd54744e36ac8fcee9b32aafbf" + }, + "m_Name": "Property", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -5299.0, + "y": -2587.0, + "width": 122.0, + "height": 34.0 + } + }, + "m_Slots": [ + { + "m_Id": "5491ec68c8244c85a00abd535ba9b720" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_Property": { + "m_Id": "1f7de34ad6cf475f840313717441d77c" + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "864866bcd4e4447fbe0cc68f600714d4", + "m_Id": 6, + "m_DisplayName": "B", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "B", + "m_StageCapability": 2, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.BlendNode", + "m_ObjectId": "866a17817870451e9971f9f71e910e19", + "m_Group": { + "m_Id": "244280d6eea94f08bb23a8e3db3784a3" + }, + "m_Name": "Blend", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -5066.0, + "y": -3273.0, + "width": 161.0, + "height": 178.0 + } + }, + "m_Slots": [ + { + "m_Id": "bf113cf12d084dd78b5cf10c04731f09" + }, + { + "m_Id": "4c9fb2a427ce450e9999c9f82a4ad54f" + }, + { + "m_Id": "5b6eb9a8e89544fca1dbfd7d39558f67" + }, + { + "m_Id": "bb939f6d6c10443fbda6386f4dd6400f" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_BlendMode": 21 +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicValueMaterialSlot", + "m_ObjectId": "87d87188fc8445a78fdd8e9f2b5f9743", + "m_Id": 1, + "m_DisplayName": "B", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "B", + "m_StageCapability": 3, + "m_Value": { + "e00": 2.0, + "e01": 2.0, + "e02": 2.0, + "e03": 2.0, + "e10": 2.0, + "e11": 2.0, + "e12": 2.0, + "e13": 2.0, + "e20": 2.0, + "e21": 2.0, + "e22": 2.0, + "e23": 2.0, + "e30": 2.0, + "e31": 2.0, + "e32": 2.0, + "e33": 2.0 + }, + "m_DefaultValue": { + "e00": 1.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 1.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 1.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.BlockNode", + "m_ObjectId": "883fa0154dc245788e90a0983dac686e", + "m_Group": { + "m_Id": "" + }, + "m_Name": "SurfaceDescription.Transmittance", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": 63.0, + "y": 347.0, + "width": 200.0, + "height": 41.0 + } + }, + "m_Slots": [ + { + "m_Id": "5511d7e8ad5044bcb20cbb1224be4cd3" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_SerializedDescriptor": "SurfaceDescription.Transmittance" +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "88bf21a720444ffb9202127a0174d65e", + "m_Id": 2, + "m_DisplayName": "Out", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.PropertyNode", + "m_ObjectId": "89491350ac6841c3a2b4c3034afd4d94", + "m_Group": { + "m_Id": "3aedb1a4a3f540528911bf5344ee2e15" + }, + "m_Name": "Property", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -3443.999755859375, + "y": -2843.0, + "width": 169.0, + "height": 34.0 + } + }, + "m_Slots": [ + { + "m_Id": "bd8dbe748a0043779fb75c4c5ef472d2" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_Property": { + "m_Id": "05cd8ff0d3ab48a7b776a221ff36b8ad" + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "8a1378435e654e268ca60e605cf8852a", + "m_Id": 6, + "m_DisplayName": "B", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "B", + "m_StageCapability": 2, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.OneMinusNode", + "m_ObjectId": "8a2128b069e046c9992344d5c8d7f5c8", + "m_Group": { + "m_Id": "b773332f12a640f2961cff577b07701f" + }, + "m_Name": "One Minus", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -1533.999755859375, + "y": 1625.0, + "width": 128.0, + "height": 94.0 + } + }, + "m_Slots": [ + { + "m_Id": "61b1fa4982b349249be7fc970cde0912" + }, + { + "m_Id": "43f7b6d9bf324f8fba8b51d9b2d533ee" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "8a33ae3b6dc04e9ea7202337a7bdb983", + "m_Id": 2, + "m_DisplayName": "Out", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicValueMaterialSlot", + "m_ObjectId": "8b2165f4b38547d1bbe7d804f72d7f6a", + "m_Id": 1, + "m_DisplayName": "B", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "B", + "m_StageCapability": 3, + "m_Value": { + "e00": 2.0, + "e01": 2.0, + "e02": 2.0, + "e03": 2.0, + "e10": 2.0, + "e11": 2.0, + "e12": 2.0, + "e13": 2.0, + "e20": 2.0, + "e21": 2.0, + "e22": 2.0, + "e23": 2.0, + "e30": 2.0, + "e31": 2.0, + "e32": 2.0, + "e33": 2.0 + }, + "m_DefaultValue": { + "e00": 1.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 1.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 1.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicValueMaterialSlot", + "m_ObjectId": "8bb14fe492e84a57a67f49618f3e308c", + "m_Id": 1, + "m_DisplayName": "B", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "B", + "m_StageCapability": 3, + "m_Value": { + "e00": 2.0, + "e01": 2.0, + "e02": 2.0, + "e03": 2.0, + "e10": 2.0, + "e11": 2.0, + "e12": 2.0, + "e13": 2.0, + "e20": 2.0, + "e21": 2.0, + "e22": 2.0, + "e23": 2.0, + "e30": 2.0, + "e31": 2.0, + "e32": 2.0, + "e33": 2.0 + }, + "m_DefaultValue": { + "e00": 1.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 1.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 1.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "8bbf0bdfb6cd4cb7b1070a2ecd46a157", + "m_Id": 0, + "m_DisplayName": "In", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "In", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "8c8b7048c4454481bfeb2bb2a48354e1", + "m_Id": 4, + "m_DisplayName": "R", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "R", + "m_StageCapability": 2, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.LerpNode", + "m_ObjectId": "8c8d7b4a3900435e88cf2280ae4ada94", + "m_Group": { + "m_Id": "0da3d5800b834357824042477eb483dd" + }, + "m_Name": "Lerp", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -1340.0, + "y": -209.0000457763672, + "width": 126.0, + "height": 142.0 + } + }, + "m_Slots": [ + { + "m_Id": "0f4e336f41354f7d80263f32580a32b3" + }, + { + "m_Id": "05e0b56d248c4ad9b98081c41f893ac4" + }, + { + "m_Id": "963d6d2c5ac040268d44060e3ab5379c" + }, + { + "m_Id": "7428c719b8fa4b99a1a64c81167a2d93" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicValueMaterialSlot", + "m_ObjectId": "8d2276fdbc7b4be0899c5705eb302e91", + "m_Id": 0, + "m_DisplayName": "", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "", + "m_StageCapability": 3, + "m_Value": { + "e00": 0.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 0.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 0.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 0.0 + }, + "m_DefaultValue": { + "e00": 1.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 1.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 1.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.RedirectNodeData", + "m_ObjectId": "8dc18247ab4b4e5caf09faf953798497", + "m_Group": { + "m_Id": "" + }, + "m_Name": "Redirect Node", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -411.0000305175781, + "y": -694.0, + "width": 56.0, + "height": 24.000001907348634 + } + }, + "m_Slots": [ + { + "m_Id": "49cec6f655c34b46a219eed9fed64e30" + }, + { + "m_Id": "5344a6989aba47fd9ea911a2503f6363" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 3, + "m_Type": "UnityEditor.ShaderGraph.Internal.ColorShaderProperty", + "m_ObjectId": "8e1a9a245d834611bbba5516f764638c", + "m_Guid": { + "m_GuidSerialized": "d8958d01-dd86-4141-b9b2-350aff5e46ef" + }, + "m_Name": "Highlight B Color", + "m_DefaultReferenceName": "", + "m_OverrideReferenceName": "_HighlightBColor", + "m_GeneratePropertyBlock": true, + "m_Precision": 0, + "overrideHLSLDeclaration": false, + "hlslDeclarationOverride": 0, + "m_Hidden": false, + "m_Value": { + "r": 1.0, + "g": 1.0, + "b": 1.0, + "a": 0.0 + }, + "m_ColorMode": 0 +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "8f7592f0a88049148d7a20c1cb1e22cb", + "m_Id": 0, + "m_DisplayName": "", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Texture2DMaterialSlot", + "m_ObjectId": "8f90b16bec664b40969b8192f7069d7e", + "m_Id": 0, + "m_DisplayName": "Emission Map", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_BareResource": false +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.PropertyNode", + "m_ObjectId": "8fa9e59236e64861945859b2bb07fb53", + "m_Group": { + "m_Id": "b3823636393244d99c581f1785baf857" + }, + "m_Name": "Property", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -1882.9998779296875, + "y": 1834.0, + "width": 130.0, + "height": 34.0 + } + }, + "m_Slots": [ + { + "m_Id": "30892a065ace490aa42fa50990585547" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_Property": { + "m_Id": "d962fe658f9a4982b62bd75d03b2276e" + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.UVMaterialSlot", + "m_ObjectId": "8fe0ba5e3f2845ec8b9295f68c04d12d", + "m_Id": 2, + "m_DisplayName": "UV", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "UV", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0 + }, + "m_Labels": [], + "m_Channel": 0 +} + +{ + "m_SGVersion": 1, + "m_Type": "UnityEditor.ShaderGraph.Internal.Vector1ShaderProperty", + "m_ObjectId": "9194e285b5944b798d84abcebaa562f1", + "m_Guid": { + "m_GuidSerialized": "b8ebb0b8-b1af-418a-97be-18d0127607ea" + }, + "m_Name": "Alpha Remap", + "m_DefaultReferenceName": "", + "m_OverrideReferenceName": "_AlphaRemap", + "m_GeneratePropertyBlock": true, + "m_Precision": 0, + "overrideHLSLDeclaration": false, + "hlslDeclarationOverride": 0, + "m_Hidden": false, + "m_Value": 0.5, + "m_FloatType": 1, + "m_RangeValues": { + "x": 0.5, + "y": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "91c237c8315c4982965849dd84cd9956", + "m_Id": 0, + "m_DisplayName": "", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.BlockNode", + "m_ObjectId": "91e279bc4ab24de6baf584d64e36b2ae", + "m_Group": { + "m_Id": "" + }, + "m_Name": "SurfaceDescription.AlphaClipThreshold", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": 68.99986267089844, + "y": 697.0, + "width": 200.0, + "height": 40.999996185302737 + } + }, + "m_Slots": [ + { + "m_Id": "a39ba9aad8d348e1b9d547f1f8c0685d" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_SerializedDescriptor": "SurfaceDescription.AlphaClipThreshold" +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Texture2DMaterialSlot", + "m_ObjectId": "92314ee51e1e4c09a6c0c4ec16b976c2", + "m_Id": 0, + "m_DisplayName": "Root Map", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_BareResource": false +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "927b00c341304144a459a766397301d6", + "m_Id": 1, + "m_DisplayName": "", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "94181a41d1b84df5829bc1191f6a2ee4", + "m_Id": 2, + "m_DisplayName": "Noise", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "NOISE", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector4MaterialSlot", + "m_ObjectId": "9434105a0b564544a9d1f31216367712", + "m_Id": 0, + "m_DisplayName": "RGBA", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "RGBA", + "m_StageCapability": 2, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "95bf0e65e5994db19f2572f3a52509c4", + "m_Id": 0, + "m_DisplayName": "A", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "A", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "95c2bc57f4dd42d7b05fd17539661814", + "m_Id": 0, + "m_DisplayName": "Depth Prepass", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "95f38f9e439d46f6b767d7f992ae0e60", + "m_Id": 0, + "m_DisplayName": "Secondary Specular Shift", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "SecondarySpecularShift", + "m_StageCapability": 2, + "m_Value": -0.10000000149011612, + "m_DefaultValue": -0.10000000149011612, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "963d6d2c5ac040268d44060e3ab5379c", + "m_Id": 2, + "m_DisplayName": "T", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "T", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.OneMinusNode", + "m_ObjectId": "9654b153a4f246f899a7ce0aab379a79", + "m_Group": { + "m_Id": "b3823636393244d99c581f1785baf857" + }, + "m_Name": "One Minus", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -1537.9998779296875, + "y": 1982.0, + "width": 128.0, + "height": 94.0 + } + }, + "m_Slots": [ + { + "m_Id": "649c1c4ff7a549e2a6ca39dac06f31c2" + }, + { + "m_Id": "bec14e41986f40ceb443e419826d6152" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicValueMaterialSlot", + "m_ObjectId": "96f29f5a114341779a003463de81c96f", + "m_Id": 1, + "m_DisplayName": "B", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "B", + "m_StageCapability": 3, + "m_Value": { + "e00": 2.0, + "e01": 2.0, + "e02": 2.0, + "e03": 2.0, + "e10": 2.0, + "e11": 2.0, + "e12": 2.0, + "e13": 2.0, + "e20": 2.0, + "e21": 2.0, + "e22": 2.0, + "e23": 2.0, + "e30": 2.0, + "e31": 2.0, + "e32": 2.0, + "e33": 2.0 + }, + "m_DefaultValue": { + "e00": 1.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 1.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 1.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicValueMaterialSlot", + "m_ObjectId": "97329b0263264ba9ab8fe3ee9be7ea2f", + "m_Id": 0, + "m_DisplayName": "A", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "A", + "m_StageCapability": 3, + "m_Value": { + "e00": 0.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 0.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 0.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 0.0 + }, + "m_DefaultValue": { + "e00": 1.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 1.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 1.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "976db38438d44e13a156bab6235d2198", + "m_Id": 1, + "m_DisplayName": "Scale", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "Scale", + "m_StageCapability": 3, + "m_Value": 2000.0, + "m_DefaultValue": 500.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 1, + "m_Type": "UnityEditor.ShaderGraph.Internal.Vector1ShaderProperty", + "m_ObjectId": "9797716d61f541a994b33c73d00c450a", + "m_Guid": { + "m_GuidSerialized": "21844bbc-f2d6-457c-a47a-b2cd6ae00b61" + }, + "m_Name": "Ambient Occlusion Strength", + "m_DefaultReferenceName": "", + "m_OverrideReferenceName": "_AOStrength", + "m_GeneratePropertyBlock": true, + "m_Precision": 0, + "overrideHLSLDeclaration": false, + "hlslDeclarationOverride": 0, + "m_Hidden": false, + "m_Value": 1.0, + "m_FloatType": 1, + "m_RangeValues": { + "x": 0.0, + "y": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "97fe11918115427b831d4ee7b93b40eb", + "m_Id": 7, + "m_DisplayName": "A", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "A", + "m_StageCapability": 2, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "983c74ad11d14734b9f6bf6b848387f9", + "m_Id": 0, + "m_DisplayName": "Alpha Power", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "98c193a2ab6744b9abbb233198c041da", + "m_Id": 2, + "m_DisplayName": "Out", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "98cc454f33f14038a2538ee65246a02d", + "m_Id": 2, + "m_DisplayName": "Out", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "98d9a946b79043339f138bde8e8dce7a", + "m_Id": 0, + "m_DisplayName": "", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.OneMinusNode", + "m_ObjectId": "992ac25d9f3d4157a9e18ffb29f0b5ba", + "m_Group": { + "m_Id": "03640179a61e456c8a3f77f11616681e" + }, + "m_Name": "One Minus", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -1621.0, + "y": -963.0000610351563, + "width": 128.0, + "height": 94.0 + } + }, + "m_Slots": [ + { + "m_Id": "706c65f8499a462787a6fa1aa6d4c4a0" + }, + { + "m_Id": "1f72e700f69040cfac4e379dba843e71" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "9a217da0aef34eaba6b9c096a97aa6b0", + "m_Id": 3, + "m_DisplayName": "Out", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicValueMaterialSlot", + "m_ObjectId": "9ba47033530747e9afd09228f0e29be6", + "m_Id": 2, + "m_DisplayName": "Out", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": { + "e00": 0.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 0.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 0.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 0.0 + }, + "m_DefaultValue": { + "e00": 1.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 1.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 1.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicValueMaterialSlot", + "m_ObjectId": "9bf574dcda5040cf93b8751674650022", + "m_Id": 0, + "m_DisplayName": "A", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "A", + "m_StageCapability": 3, + "m_Value": { + "e00": 0.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 0.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 0.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 0.0 + }, + "m_DefaultValue": { + "e00": 1.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 1.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 1.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "9c661df801f348f0ad7991ba68cbe2d5", + "m_Id": 0, + "m_DisplayName": "", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicValueMaterialSlot", + "m_ObjectId": "9d7f124043e54a428039054135ee5e65", + "m_Id": 2, + "m_DisplayName": "Out", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": { + "e00": 0.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 0.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 0.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 0.0 + }, + "m_DefaultValue": { + "e00": 1.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 1.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 1.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "9da31e3009c14bc09ce06ce0ee9ad590", + "m_Id": 4, + "m_DisplayName": "In", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "In", + "m_StageCapability": 3, + "m_Value": 1.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "9e0785f63695465d9790652651774be3", + "m_Id": 0, + "m_DisplayName": "In", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "In", + "m_StageCapability": 3, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "9e198c5ab1424949bbdcd87af6c2666d", + "m_Id": 2, + "m_DisplayName": "Out", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "9f07c928ca7842c086718cd229013f2a", + "m_Id": 1, + "m_DisplayName": "B", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "B", + "m_StageCapability": 3, + "m_Value": { + "x": 2.0, + "y": 2.0, + "z": 2.0, + "w": 2.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.RedirectNodeData", + "m_ObjectId": "9f627f64b90e48a5891d127f88ac4c50", + "m_Group": { + "m_Id": "244280d6eea94f08bb23a8e3db3784a3" + }, + "m_Name": "Redirect Node", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -5294.0, + "y": -2963.0, + "width": 56.0, + "height": 23.999998092651368 + } + }, + "m_Slots": [ + { + "m_Id": "e162ae534d3c4d45a392aaf9ecd7d16f" + }, + { + "m_Id": "46febb3245ae4f47961062ce3ef3bda8" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.PropertyNode", + "m_ObjectId": "9f8c21dd3c144973a99de8440ff1910d", + "m_Group": { + "m_Id": "0e8b3d01fbd24a99bdb2e8e85a456a90" + }, + "m_Name": "Property", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -2993.0, + "y": -2065.000244140625, + "width": 169.0, + "height": 34.0 + } + }, + "m_Slots": [ + { + "m_Id": "5459634fea3c44e59fdc9b6414840445" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_Property": { + "m_Id": "8e1a9a245d834611bbba5516f764638c" + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.NoiseNode", + "m_ObjectId": "9fe0bae8095e488fab536e1bbc11bb66", + "m_Group": { + "m_Id": "b773332f12a640f2961cff577b07701f" + }, + "m_Name": "Simple Noise", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -1903.9998779296875, + "y": 1454.0, + "width": 147.0, + "height": 118.0 + } + }, + "m_Slots": [ + { + "m_Id": "aad9226057ad4461a38b52b6cd9f2006" + }, + { + "m_Id": "976db38438d44e13a156bab6235d2198" + }, + { + "m_Id": "0c722f49f92545a4b12a022983a9346c" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Internal.Texture2DShaderProperty", + "m_ObjectId": "a07bfbc05b904ff6b24292a9d830a741", + "m_Guid": { + "m_GuidSerialized": "8fe2ef39-e5c9-47ee-8635-8e16ee83d054" + }, + "m_Name": "Specular Map", + "m_DefaultReferenceName": "", + "m_OverrideReferenceName": "_SpecularMap", + "m_GeneratePropertyBlock": true, + "m_Precision": 0, + "overrideHLSLDeclaration": false, + "hlslDeclarationOverride": 0, + "m_Hidden": false, + "m_Value": { + "m_SerializedTexture": "{\"texture\":{\"instanceID\":0}}", + "m_Guid": "" + }, + "m_Modifiable": true, + "m_DefaultType": 0 +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.SampleTexture2DNode", + "m_ObjectId": "a092fae44e0b454cb3b18c1769b66a72", + "m_Group": { + "m_Id": "" + }, + "m_Name": "Sample Texture 2D", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -1179.9998779296875, + "y": 341.0000305175781, + "width": 184.0, + "height": 253.00001525878907 + } + }, + "m_Slots": [ + { + "m_Id": "f21deaaac67345a0aab4507845b25c51" + }, + { + "m_Id": "8c8b7048c4454481bfeb2bb2a48354e1" + }, + { + "m_Id": "def655a2d68e4f6b9fe2e956de18548a" + }, + { + "m_Id": "53d94da82d9d4a40b135feffa6178406" + }, + { + "m_Id": "e25ec37da9a34626b6bed14250468f40" + }, + { + "m_Id": "a4951dd1b8d84944a2db444eea9097fc" + }, + { + "m_Id": "8090a7638fc34eccbcbd70857701b7b4" + }, + { + "m_Id": "a56a6adfc4724725841c4909001c9b46" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_TextureType": 0, + "m_NormalMapSpace": 0 +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "a11bad06f9874030afdb3e20727370ec", + "m_Id": 0, + "m_DisplayName": "Base", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "Base", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicValueMaterialSlot", + "m_ObjectId": "a1b5ae04eaa4441aac1e35bd9ea8b20f", + "m_Id": 2, + "m_DisplayName": "Out", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": { + "e00": 0.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 0.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 0.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 0.0 + }, + "m_DefaultValue": { + "e00": 1.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 1.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 1.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicValueMaterialSlot", + "m_ObjectId": "a1bd16c0f006490ea28c3fd3a27df8f0", + "m_Id": 1, + "m_DisplayName": "B", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "B", + "m_StageCapability": 3, + "m_Value": { + "e00": 2.0, + "e01": 2.0, + "e02": 2.0, + "e03": 2.0, + "e10": 2.0, + "e11": 2.0, + "e12": 2.0, + "e13": 2.0, + "e20": 2.0, + "e21": 2.0, + "e22": 2.0, + "e23": 2.0, + "e30": 2.0, + "e31": 2.0, + "e32": 2.0, + "e33": 2.0 + }, + "m_DefaultValue": { + "e00": 1.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 1.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 1.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "a27e4e19b2784093a7979238abae6ade", + "m_Id": 0, + "m_DisplayName": "In", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "In", + "m_StageCapability": 3, + "m_Value": { + "x": 1.0, + "y": 1.0, + "z": 1.0, + "w": 1.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "a2b446a108624f4ea43455c92d25610e", + "m_Id": 0, + "m_DisplayName": "Alpha Clip Threshold Shadow", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "AlphaClipThresholdShadow", + "m_StageCapability": 2, + "m_Value": 0.5, + "m_DefaultValue": 0.5, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "a334f298d25b489b9f31602a14f562ae", + "m_Id": 1, + "m_DisplayName": "Out", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.RedirectNodeData", + "m_ObjectId": "a336e37bead841ab80818f6c8488f3aa", + "m_Group": { + "m_Id": "3aedb1a4a3f540528911bf5344ee2e15" + }, + "m_Name": "Redirect Node", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -4456.0, + "y": -2440.000244140625, + "width": 56.000003814697269, + "height": 24.000001907348634 + } + }, + "m_Slots": [ + { + "m_Id": "91c237c8315c4982965849dd84cd9956" + }, + { + "m_Id": "4694257c527b45868c3cac0b5e63b38a" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "a39ba9aad8d348e1b9d547f1f8c0685d", + "m_Id": 0, + "m_DisplayName": "Alpha Clip Threshold", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "AlphaClipThreshold", + "m_StageCapability": 2, + "m_Value": 0.5, + "m_DefaultValue": 0.5, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Texture2DInputMaterialSlot", + "m_ObjectId": "a4951dd1b8d84944a2db444eea9097fc", + "m_Id": 1, + "m_DisplayName": "Texture", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "Texture", + "m_StageCapability": 3, + "m_BareResource": false, + "m_Texture": { + "m_SerializedTexture": "{\"texture\":{\"instanceID\":0}}", + "m_Guid": "" + }, + "m_DefaultType": 0 +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.MultiplyNode", + "m_ObjectId": "a4abc46300494294b321ea368512e48c", + "m_Group": { + "m_Id": "b773332f12a640f2961cff577b07701f" + }, + "m_Name": "Multiply", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -1701.999755859375, + "y": 1584.0, + "width": 125.99999237060547, + "height": 118.0 + } + }, + "m_Slots": [ + { + "m_Id": "33c3cf79ca494675bf7feafe0ed9594f" + }, + { + "m_Id": "8bb14fe492e84a57a67f49618f3e308c" + }, + { + "m_Id": "a1b5ae04eaa4441aac1e35bd9ea8b20f" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.BlendNode", + "m_ObjectId": "a55dd75f45944956a01d8fd91c85994a", + "m_Group": { + "m_Id": "244280d6eea94f08bb23a8e3db3784a3" + }, + "m_Name": "Blend", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -5546.99951171875, + "y": -2942.0, + "width": 161.0, + "height": 178.0 + } + }, + "m_Slots": [ + { + "m_Id": "3811ccaba7684393bfb8069f4e4a016a" + }, + { + "m_Id": "745de5ab8f8745b8aea6ee647a2a5804" + }, + { + "m_Id": "002f41d7623b419ebf0383bac58d55bf" + }, + { + "m_Id": "037a4a0d094d48ef8dc680484249458d" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_BlendMode": 21 +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.SamplerStateMaterialSlot", + "m_ObjectId": "a56a6adfc4724725841c4909001c9b46", + "m_Id": 3, + "m_DisplayName": "Sampler", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "Sampler", + "m_StageCapability": 3, + "m_BareResource": false +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.BlockNode", + "m_ObjectId": "a61b9632fcd344bbb50f017fe9662523", + "m_Group": { + "m_Id": "" + }, + "m_Name": "SurfaceDescription.HairStrandDirection", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": 58.9999885559082, + "y": 224.00001525878907, + "width": 200.00001525878907, + "height": 41.000003814697269 + } + }, + "m_Slots": [ + { + "m_Id": "4e4c5ea5d3094e1595676fdb82c3c6f2" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_SerializedDescriptor": "SurfaceDescription.HairStrandDirection" +} + +{ + "m_SGVersion": 3, + "m_Type": "UnityEditor.ShaderGraph.Internal.ColorShaderProperty", + "m_ObjectId": "a63d692b98084be8b8748b7cd4391a19", + "m_Guid": { + "m_GuidSerialized": "88c94231-16e4-4b20-8f00-d7b8381a0637" + }, + "m_Name": "End Color", + "m_DefaultReferenceName": "", + "m_OverrideReferenceName": "_EndColor", + "m_GeneratePropertyBlock": true, + "m_Precision": 0, + "overrideHLSLDeclaration": false, + "hlslDeclarationOverride": 0, + "m_Hidden": false, + "m_Value": { + "r": 0.6039215922355652, + "g": 0.45490196347236636, + "b": 0.2862745225429535, + "a": 0.0 + }, + "m_ColorMode": 0 +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector4MaterialSlot", + "m_ObjectId": "a6847bbd696147b7a3bede53269a3b97", + "m_Id": 0, + "m_DisplayName": "Root Color", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.RedirectNodeData", + "m_ObjectId": "a690192754a849e589743764dd23ed67", + "m_Group": { + "m_Id": "3aedb1a4a3f540528911bf5344ee2e15" + }, + "m_Name": "Redirect Node", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -4461.0, + "y": -2728.0, + "width": 56.0, + "height": 24.0 + } + }, + "m_Slots": [ + { + "m_Id": "5481c6230bcc4766b4a4b7e1486a01ca" + }, + { + "m_Id": "bfd33bef84114dd0900f4fba28e38750" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 1, + "m_Type": "UnityEditor.ShaderGraph.Internal.Vector1ShaderProperty", + "m_ObjectId": "a6f49c7b1ba2462aa864ed200a6a2b11", + "m_Guid": { + "m_GuidSerialized": "49e606fc-d2fb-4e97-8715-0c933979bb09" + }, + "m_Name": "Invert Root Map", + "m_DefaultReferenceName": "", + "m_OverrideReferenceName": "_InvertRootMap", + "m_GeneratePropertyBlock": true, + "m_Precision": 0, + "overrideHLSLDeclaration": false, + "hlslDeclarationOverride": 0, + "m_Hidden": false, + "m_Value": 0.0, + "m_FloatType": 1, + "m_RangeValues": { + "x": 0.0, + "y": 1.0 + } +} + +{ + "m_SGVersion": 1, + "m_Type": "UnityEditor.ShaderGraph.Internal.Vector1ShaderProperty", + "m_ObjectId": "a6fa4ad2f38b44f991f1e519e0cfd03c", + "m_Guid": { + "m_GuidSerialized": "497b1e55-61e1-4e62-b0d9-15be2bdd5bbd" + }, + "m_Name": "End Color Strength", + "m_DefaultReferenceName": "", + "m_OverrideReferenceName": "_EndColorStrength", + "m_GeneratePropertyBlock": true, + "m_Precision": 0, + "overrideHLSLDeclaration": false, + "hlslDeclarationOverride": 0, + "m_Hidden": false, + "m_Value": 1.0, + "m_FloatType": 1, + "m_RangeValues": { + "x": 0.0, + "y": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "a710a079401c4deaab938e01aa147af8", + "m_Id": 0, + "m_DisplayName": "In", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "In", + "m_StageCapability": 3, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 1, + "m_Type": "UnityEditor.ShaderGraph.Internal.Vector1ShaderProperty", + "m_ObjectId": "a73bbe07bf634ae6a2f595dac0d74ea3", + "m_Guid": { + "m_GuidSerialized": "984b5df2-eeb1-40fd-bd35-496888fe0ccf" + }, + "m_Name": "Specular Shift", + "m_DefaultReferenceName": "Vector1_a73bbe07bf634ae6a2f595dac0d74ea3", + "m_OverrideReferenceName": "_SpecularShift", + "m_GeneratePropertyBlock": true, + "m_Precision": 0, + "overrideHLSLDeclaration": false, + "hlslDeclarationOverride": 0, + "m_Hidden": false, + "m_Value": 0.15000000596046449, + "m_FloatType": 1, + "m_RangeValues": { + "x": -1.0, + "y": 1.0 + } +} + +{ + "m_SGVersion": 1, + "m_Type": "UnityEditor.ShaderGraph.Internal.Vector1ShaderProperty", + "m_ObjectId": "a89b7eb5908949b7a8ff733c487aa014", + "m_Guid": { + "m_GuidSerialized": "0a5d5360-948a-481e-a2c1-13ecde3fe3ac" + }, + "m_Name": "AO Occlude All", + "m_DefaultReferenceName": "", + "m_OverrideReferenceName": "_AOOccludeAll", + "m_GeneratePropertyBlock": true, + "m_Precision": 0, + "overrideHLSLDeclaration": false, + "hlslDeclarationOverride": 0, + "m_Hidden": false, + "m_Value": 0.0, + "m_FloatType": 1, + "m_RangeValues": { + "x": 0.0, + "y": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "a8dcc8405c90479ab17d757638e58443", + "m_Id": 6, + "m_DisplayName": "B", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "B", + "m_StageCapability": 2, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 3, + "m_Type": "UnityEditor.ShaderGraph.Internal.ColorShaderProperty", + "m_ObjectId": "a8fac80485344a489b31db2a226e0489", + "m_Guid": { + "m_GuidSerialized": "3a62cbe1-292f-42d4-8678-d1dc0695eb3b" + }, + "m_Name": "Vertex Base Color", + "m_DefaultReferenceName": "Color_a8fac80485344a489b31db2a226e0489", + "m_OverrideReferenceName": "_VertexBaseColor", + "m_GeneratePropertyBlock": true, + "m_Precision": 0, + "overrideHLSLDeclaration": false, + "hlslDeclarationOverride": 0, + "m_Hidden": false, + "m_Value": { + "r": 0.0, + "g": 0.0, + "b": 0.0, + "a": 0.0 + }, + "m_ColorMode": 0 +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector4MaterialSlot", + "m_ObjectId": "a9153f25127543e5976afb8c735fd8f6", + "m_Id": 0, + "m_DisplayName": "RGBA", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "RGBA", + "m_StageCapability": 2, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.KeywordNode", + "m_ObjectId": "a95c92619dc0485d83dce69c60ceca6d", + "m_Group": { + "m_Id": "4754e47d61844a86908699d8a6f31a28" + }, + "m_Name": "Clip Quality", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -1044.999755859375, + "y": 1601.0, + "width": 166.0, + "height": 142.0 + } + }, + "m_Slots": [ + { + "m_Id": "b8ebe5bed87e404994efe09218ca4b45" + }, + { + "m_Id": "4b31cead930147bdadc33a292daeed85" + }, + { + "m_Id": "94181a41d1b84df5829bc1191f6a2ee4" + }, + { + "m_Id": "7756e79b76714e4396a582857d12cbeb" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_Keyword": { + "m_Id": "a9c42cd3aa674f4b8cd880751469f0f3" + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.SampleTexture2DNode", + "m_ObjectId": "a9b949905222445081591fa1fd11be88", + "m_Group": { + "m_Id": "03640179a61e456c8a3f77f11616681e" + }, + "m_Name": "Sample Texture 2D", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -2294.0, + "y": -1150.0, + "width": 184.0, + "height": 253.0 + } + }, + "m_Slots": [ + { + "m_Id": "a9153f25127543e5976afb8c735fd8f6" + }, + { + "m_Id": "6a4ddba6f8a446449e5aafa335b28022" + }, + { + "m_Id": "5b98637dcaf04243918163b5170b55da" + }, + { + "m_Id": "6a503b2086f54950b079d6857a4e807d" + }, + { + "m_Id": "bfbef448f50049129a27cbe3ca7f792b" + }, + { + "m_Id": "58fa216e5e6f4b7c9ac858c6790c22fb" + }, + { + "m_Id": "5dab28517be2484da7f0b376f4ba025e" + }, + { + "m_Id": "147eb2a0fa474862ad3e999175f89197" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_TextureType": 0, + "m_NormalMapSpace": 0 +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.ShaderKeyword", + "m_ObjectId": "a9c42cd3aa674f4b8cd880751469f0f3", + "m_Guid": { + "m_GuidSerialized": "f54a4cd9-4fbe-436d-b8ba-15ea3468fb67" + }, + "m_Name": "Clip Quality", + "m_DefaultReferenceName": "ENUM_A9C42CD3AA674F4B8CD880751469F0F3", + "m_OverrideReferenceName": "_ENUMCLIPQUALITY_ON", + "m_GeneratePropertyBlock": true, + "m_KeywordType": 1, + "m_KeywordDefinition": 1, + "m_KeywordScope": 0, + "m_Entries": [ + { + "id": 1, + "displayName": "Standard", + "referenceName": "STANDARD" + }, + { + "id": 2, + "displayName": "Noise", + "referenceName": "NOISE" + }, + { + "id": 3, + "displayName": "Dither", + "referenceName": "DITHER" + } + ], + "m_Value": 0, + "m_IsEditable": true +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.ScreenPositionNode", + "m_ObjectId": "aa3b6d90bb2d442e989158ba90f12906", + "m_Group": { + "m_Id": "b3823636393244d99c581f1785baf857" + }, + "m_Name": "Screen Position", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -2095.999755859375, + "y": 1852.0, + "width": 145.0, + "height": 130.0 + } + }, + "m_Slots": [ + { + "m_Id": "5e0fe5e94dc24bf6813a9916ddf06b19" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_ScreenSpaceType": 0 +} + +{ + "m_SGVersion": 1, + "m_Type": "UnityEditor.ShaderGraph.CustomFunctionNode", + "m_ObjectId": "aaa78c08909d49449406d49a312d31a3", + "m_Group": { + "m_Id": "0e8b3d01fbd24a99bdb2e8e85a456a90" + }, + "m_Name": "_ScaleToOne (Custom Function)", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -3434.0, + "y": -1814.0001220703125, + "width": 228.0, + "height": 118.0 + } + }, + "m_Slots": [ + { + "m_Id": "ecacf623d41b4d40b943f5b704cefe0b" + }, + { + "m_Id": "811ad31b15994929a93a9dcd3651d6af" + }, + { + "m_Id": "7dc34a9bd8474c6db1ed46da3b63360c" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_SourceType": 1, + "m_FunctionName": "_ScaleToOne", + "m_FunctionSource": "", + "m_FunctionBody": "Out = 1.0 - ((1.0 - In) * Fac);" +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.UVMaterialSlot", + "m_ObjectId": "aad9226057ad4461a38b52b6cd9f2006", + "m_Id": 0, + "m_DisplayName": "UV", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "UV", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0 + }, + "m_Labels": [], + "m_Channel": 0 +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "ab63acc371ab4765a2800d13b87b7152", + "m_Id": 5, + "m_DisplayName": "G", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "G", + "m_StageCapability": 2, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 1, + "m_Type": "UnityEditor.ShaderGraph.Internal.Vector1ShaderProperty", + "m_ObjectId": "ab6f8c0fc8fc4dd78cf1810dbf288488", + "m_Guid": { + "m_GuidSerialized": "1cb60b8a-867d-41f3-ac60-7ba9942da4c4" + }, + "m_Name": "Highlight A Strength", + "m_DefaultReferenceName": "", + "m_OverrideReferenceName": "_HighlightAStrength", + "m_GeneratePropertyBlock": true, + "m_Precision": 0, + "overrideHLSLDeclaration": false, + "hlslDeclarationOverride": 0, + "m_Hidden": false, + "m_Value": 1.0, + "m_FloatType": 1, + "m_RangeValues": { + "x": 0.0, + "y": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "abdcfcac97c640f7a0e4286449cbbd92", + "m_Id": 0, + "m_DisplayName": "In", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "In", + "m_StageCapability": 3, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.RedirectNodeData", + "m_ObjectId": "ac0c1810cc7b43eca36a78a32992055e", + "m_Group": { + "m_Id": "" + }, + "m_Name": "Redirect Node", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -618.9998168945313, + "y": 1572.0, + "width": 56.0, + "height": 23.999998092651368 + } + }, + "m_Slots": [ + { + "m_Id": "5e351a9c13a74f909cf032de19e6ecba" + }, + { + "m_Id": "f2ad0036164a41018d0e761ccde52714" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Internal.Texture2DShaderProperty", + "m_ObjectId": "ac27b0d8beef493a80956330658fb3e7", + "m_Guid": { + "m_GuidSerialized": "7cefccf5-1b01-4a43-ad9e-5c90373d8f44" + }, + "m_Name": "Emission Map", + "m_DefaultReferenceName": "Texture2D_ac27b0d8beef493a80956330658fb3e7", + "m_OverrideReferenceName": "_EmissionMap", + "m_GeneratePropertyBlock": true, + "m_Precision": 0, + "overrideHLSLDeclaration": false, + "hlslDeclarationOverride": 0, + "m_Hidden": false, + "m_Value": { + "m_SerializedTexture": "{\"texture\":{\"instanceID\":0}}", + "m_Guid": "" + }, + "m_Modifiable": true, + "m_DefaultType": 1 +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Texture2DMaterialSlot", + "m_ObjectId": "ac491fb4bb4341d192f0f74e368b5af7", + "m_Id": 0, + "m_DisplayName": "Specular Map", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_BareResource": false +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicValueMaterialSlot", + "m_ObjectId": "ac60b4d7d6d44ccab304e372da3b5301", + "m_Id": 0, + "m_DisplayName": "A", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "A", + "m_StageCapability": 3, + "m_Value": { + "e00": 0.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 0.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 0.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 0.0 + }, + "m_DefaultValue": { + "e00": 1.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 1.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 1.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.MultiplyNode", + "m_ObjectId": "ac6803728e7549dd87a233c309559c0a", + "m_Group": { + "m_Id": "0e8b3d01fbd24a99bdb2e8e85a456a90" + }, + "m_Name": "Multiply", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -3149.0, + "y": -2007.000244140625, + "width": 126.00000762939453, + "height": 118.00000762939453 + } + }, + "m_Slots": [ + { + "m_Id": "c021d49d87464e5c92f577f0d4147b48" + }, + { + "m_Id": "c022e7d9bc3c4318a84b31d3148f6e7c" + }, + { + "m_Id": "65201543557f4f3383d0127291d0f110" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DivideNode", + "m_ObjectId": "ac70eb9a271a4e2eb7c2e15fb1d4c989", + "m_Group": { + "m_Id": "72585dd91b3d4da7b55123bae128c48b" + }, + "m_Name": "Divide", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -5586.0, + "y": -1805.0, + "width": 126.0, + "height": 118.0 + } + }, + "m_Slots": [ + { + "m_Id": "7ea1e68a05354ad18b0e3014fb336186" + }, + { + "m_Id": "720effcec7324554ad9df79acddac33a" + }, + { + "m_Id": "98cc454f33f14038a2538ee65246a02d" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "ad5413aaafc44260b8a6486126167921", + "m_Id": 2, + "m_DisplayName": "Fac", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "Fac", + "m_StageCapability": 3, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.RedirectNodeData", + "m_ObjectId": "ad570f188c754df88dfa5790b811ca07", + "m_Group": { + "m_Id": "" + }, + "m_Name": "Redirect Node", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -3079.000732421875, + "y": -645.9999389648438, + "width": 56.000003814697269, + "height": 24.0 + } + }, + "m_Slots": [ + { + "m_Id": "bdedaba0281844b89560fdae6a68b49d" + }, + { + "m_Id": "b1a2faf8b255401bab3737fc55723ec0" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.Rendering.HighDefinition.ShaderGraph.HairSubTarget", + "m_ObjectId": "ae695df4997e40b2ae5fccf1dbc75884" +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.SamplerStateMaterialSlot", + "m_ObjectId": "ae6aeab78fad43109257fd5685aca7ad", + "m_Id": 3, + "m_DisplayName": "Sampler", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "Sampler", + "m_StageCapability": 3, + "m_BareResource": false +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "ae7156f33d8c4ac68f9c29a9092780a0", + "m_Id": 2, + "m_DisplayName": "Out", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.SaturateNode", + "m_ObjectId": "aebc93c2df364b09b9e5468dfa8ac99b", + "m_Group": { + "m_Id": "0da3d5800b834357824042477eb483dd" + }, + "m_Name": "Saturate", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -1857.0, + "y": -145.00003051757813, + "width": 128.0, + "height": 94.0 + } + }, + "m_Slots": [ + { + "m_Id": "843521d5bed044cf9b6d0d6034f14cd9" + }, + { + "m_Id": "3fe87bcaf15d46d8a48659f7b2c426fe" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.ScreenPositionMaterialSlot", + "m_ObjectId": "aee77a08299944a9b9d28832d825355c", + "m_Id": 1, + "m_DisplayName": "Screen Position", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "ScreenPosition", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_Labels": [], + "m_ScreenSpaceType": 0 +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "af325e529f144f119f865552aeb01d6b", + "m_Id": 0, + "m_DisplayName": "Rim Transmission Intensity", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "RimTransmissionIntensity", + "m_StageCapability": 2, + "m_Value": 0.05000000074505806, + "m_DefaultValue": 0.20000000298023225, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.SampleTexture2DNode", + "m_ObjectId": "af7e3800e2f34908a3a77b8948d2fd32", + "m_Group": { + "m_Id": "" + }, + "m_Name": "Sample Texture 2D", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -1672.0, + "y": 712.0, + "width": 184.0, + "height": 253.0 + } + }, + "m_Slots": [ + { + "m_Id": "7dbf0eb7f73346f89d219731f4e3b02a" + }, + { + "m_Id": "d40713f2096b42e38a0c7e5f8926687d" + }, + { + "m_Id": "35548bbcfdf246118323976e19cad65e" + }, + { + "m_Id": "7260c54475d24fdc9dc73a6544edaa9c" + }, + { + "m_Id": "97fe11918115427b831d4ee7b93b40eb" + }, + { + "m_Id": "ea85740a0e1e4ec5bcd3084711e2da2f" + }, + { + "m_Id": "10fcfa37830d4e02851aae7950225694" + }, + { + "m_Id": "5874a8cec8cf4abf8f56c8ee53245f1a" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_TextureType": 1, + "m_NormalMapSpace": 0 +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.PropertyNode", + "m_ObjectId": "b158210403a647c485660b84c2aaa857", + "m_Group": { + "m_Id": "b3823636393244d99c581f1785baf857" + }, + "m_Name": "Property", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -2252.999755859375, + "y": 2023.0, + "width": 153.0, + "height": 34.0 + } + }, + "m_Slots": [ + { + "m_Id": "8026cfb04de041b082f4f67ec8866e35" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_Property": { + "m_Id": "7a9dca43a15c41859b95c7edb930b3db" + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "b1a2faf8b255401bab3737fc55723ec0", + "m_Id": 1, + "m_DisplayName": "", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 1, + "m_Type": "UnityEditor.ShaderGraph.Internal.Vector1ShaderProperty", + "m_ObjectId": "b2b5bf0810fd490d81e06a42ff3ba8ed", + "m_Guid": { + "m_GuidSerialized": "fefd83bf-1cdc-4afe-9663-90de25ec3307" + }, + "m_Name": "Smoothness Power", + "m_DefaultReferenceName": "", + "m_OverrideReferenceName": "_SmoothnessPower", + "m_GeneratePropertyBlock": true, + "m_Precision": 0, + "overrideHLSLDeclaration": false, + "hlslDeclarationOverride": 0, + "m_Hidden": false, + "m_Value": 1.0, + "m_FloatType": 1, + "m_RangeValues": { + "x": 0.5, + "y": 2.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Internal.Texture2DShaderProperty", + "m_ObjectId": "b304178995574d4b8dceaf0eade7e621", + "m_Guid": { + "m_GuidSerialized": "716a1137-cfb1-4c9d-bc69-04632fcd9cd6" + }, + "m_Name": "Normal Map", + "m_DefaultReferenceName": "Texture2D_b304178995574d4b8dceaf0eade7e621", + "m_OverrideReferenceName": "_NormalMap", + "m_GeneratePropertyBlock": true, + "m_Precision": 0, + "overrideHLSLDeclaration": false, + "hlslDeclarationOverride": 0, + "m_Hidden": false, + "m_Value": { + "m_SerializedTexture": "{\"texture\":{\"instanceID\":0}}", + "m_Guid": "" + }, + "m_Modifiable": true, + "m_DefaultType": 3 +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.MultiplyNode", + "m_ObjectId": "b337e8061fa24e6bb1d267bc90b18e02", + "m_Group": { + "m_Id": "b773332f12a640f2961cff577b07701f" + }, + "m_Name": "Multiply", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -1531.999755859375, + "y": 1385.0, + "width": 125.99999237060547, + "height": 118.0 + } + }, + "m_Slots": [ + { + "m_Id": "c60878de532b40f18b8873bf81da94c3" + }, + { + "m_Id": "4154ea606af6442987588d72a76c3c3d" + }, + { + "m_Id": "5b8032c360414a4a9f95bd5c607c118c" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "b35ce8b14ba249288521774971ed2f94", + "m_Id": 1, + "m_DisplayName": "Out", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.BlockNode", + "m_ObjectId": "b3602abd3e6c4110bd7c0c759e4b9c20", + "m_Group": { + "m_Id": "" + }, + "m_Name": "SurfaceDescription.AlphaClipThresholdDepthPrepass", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": 0.0, + "y": 0.0, + "width": 0.0, + "height": 0.0 + } + }, + "m_Slots": [ + { + "m_Id": "8608d2b6360a457a818cd7857bf72ad4" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_SerializedDescriptor": "SurfaceDescription.AlphaClipThresholdDepthPrepass" +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.GroupData", + "m_ObjectId": "b3823636393244d99c581f1785baf857", + "m_Title": "Dithered Alpha Clip", + "m_Position": { + "x": -2277.999755859375, + "y": 1774.9998779296875 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "b388214065ad4683980684e100cf0de6", + "m_Id": 1, + "m_DisplayName": "Blend", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "Blend", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicValueMaterialSlot", + "m_ObjectId": "b3ebad9010e044268b41a59a236ea578", + "m_Id": 0, + "m_DisplayName": "A", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "A", + "m_StageCapability": 3, + "m_Value": { + "e00": 0.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 0.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 0.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 0.0 + }, + "m_DefaultValue": { + "e00": 1.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 1.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 1.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicValueMaterialSlot", + "m_ObjectId": "b47b692c98e84d2e87278ffbaaf253c6", + "m_Id": 1, + "m_DisplayName": "B", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "B", + "m_StageCapability": 3, + "m_Value": { + "e00": 2.0, + "e01": 2.0, + "e02": 2.0, + "e03": 2.0, + "e10": 2.0, + "e11": 2.0, + "e12": 2.0, + "e13": 2.0, + "e20": 2.0, + "e21": 2.0, + "e22": 2.0, + "e23": 2.0, + "e30": 2.0, + "e31": 2.0, + "e32": 2.0, + "e33": 2.0 + }, + "m_DefaultValue": { + "e00": 1.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 1.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 1.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.BlendNode", + "m_ObjectId": "b5033b6eae774ee281774f8a5ebd6867", + "m_Group": { + "m_Id": "244280d6eea94f08bb23a8e3db3784a3" + }, + "m_Name": "Blend", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -5399.0, + "y": -3166.0, + "width": 161.0, + "height": 178.0 + } + }, + "m_Slots": [ + { + "m_Id": "6e0af7bfd7ad496491185bdd505e04dc" + }, + { + "m_Id": "74013a788cdf497dbb1045c3e26fedac" + }, + { + "m_Id": "509b6964be884e32b35af1b3b3e1de75" + }, + { + "m_Id": "98c193a2ab6744b9abbb233198c041da" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_BlendMode": 21 +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.AddNode", + "m_ObjectId": "b61ad6685d834336a04cd2ba0d129607", + "m_Group": { + "m_Id": "244280d6eea94f08bb23a8e3db3784a3" + }, + "m_Name": "Add", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -5820.0, + "y": -3343.0, + "width": 125.99999237060547, + "height": 118.0 + } + }, + "m_Slots": [ + { + "m_Id": "95bf0e65e5994db19f2572f3a52509c4" + }, + { + "m_Id": "5f33a7f72ce84cc485cb00c5e93aa01a" + }, + { + "m_Id": "c904bc3c3ffd44ed9e3e0564288be1eb" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 1, + "m_Type": "UnityEditor.ShaderGraph.Internal.Vector1ShaderProperty", + "m_ObjectId": "b638b475ea844c8f953ca43f5b9f3316", + "m_Guid": { + "m_GuidSerialized": "cf52d018-bc65-47fd-a096-a72c03e3dc7e" + }, + "m_Name": "Base Color Strength", + "m_DefaultReferenceName": "", + "m_OverrideReferenceName": "_BaseColorStrength", + "m_GeneratePropertyBlock": true, + "m_Precision": 0, + "overrideHLSLDeclaration": false, + "hlslDeclarationOverride": 0, + "m_Hidden": false, + "m_Value": 1.0, + "m_FloatType": 1, + "m_RangeValues": { + "x": 0.0, + "y": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.Rendering.HighDefinition.ShaderGraph.HDTarget", + "m_ObjectId": "b68cdcc63047409381c5e594c02463cd", + "m_ActiveSubTarget": { + "m_Id": "ae695df4997e40b2ae5fccf1dbc75884" + }, + "m_Datas": [ + { + "m_Id": "f907ec2614f64fee9511dbed58f101b9" + }, + { + "m_Id": "6642d27020f646129f5cda404c16ec41" + }, + { + "m_Id": "ca7dd4e86229499ea82f26ce21b18c9f" + }, + { + "m_Id": "f5f54dac45ca4f98b35bfd8055240a0f" + } + ], + "m_CustomEditorGUI": "" +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.GroupData", + "m_ObjectId": "b773332f12a640f2961cff577b07701f", + "m_Title": "Noise Alpha Clip", + "m_Position": { + "x": -2202.0, + "y": 1326.0001220703125 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "b8146107abf54cceaccead24f962517e", + "m_Id": 1, + "m_DisplayName": "Blend", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "Blend", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.PropertyNode", + "m_ObjectId": "b86246fa0fff40a284f03275fff93bcf", + "m_Group": { + "m_Id": "244280d6eea94f08bb23a8e3db3784a3" + }, + "m_Name": "Property", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -6275.0, + "y": -3200.0, + "width": 176.0, + "height": 34.0 + } + }, + "m_Slots": [ + { + "m_Id": "63d8248fcb2844c3a311456a94427691" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_Property": { + "m_Id": "a6fa4ad2f38b44f991f1e519e0cfd03c" + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.SaturateNode", + "m_ObjectId": "b8e284dd58dd45a6b6c14058a8baffad", + "m_Group": { + "m_Id": "72585dd91b3d4da7b55123bae128c48b" + }, + "m_Name": "Saturate", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -5425.0, + "y": -1718.0, + "width": 128.0, + "height": 94.00000762939453 + } + }, + "m_Slots": [ + { + "m_Id": "029d6201ad5b43e7b3542e71b5800a86" + }, + { + "m_Id": "a334f298d25b489b9f31602a14f562ae" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "b8ebe5bed87e404994efe09218ca4b45", + "m_Id": 0, + "m_DisplayName": "Out", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "ba480ecbddef4b438d53b2d86976cab9", + "m_Id": 0, + "m_DisplayName": "Shadow Clip", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.MultiplyNode", + "m_ObjectId": "bad53b94aae6409696fad7c2840f0972", + "m_Group": { + "m_Id": "244280d6eea94f08bb23a8e3db3784a3" + }, + "m_Name": "Multiply", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -6040.0, + "y": -3451.0, + "width": 125.99999237060547, + "height": 118.0 + } + }, + "m_Slots": [ + { + "m_Id": "9bf574dcda5040cf93b8751674650022" + }, + { + "m_Id": "0a4b66f4c7904331a220c621d4c4e2ff" + }, + { + "m_Id": "9d7f124043e54a428039054135ee5e65" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Texture2DMaterialSlot", + "m_ObjectId": "baf616c41c254dcca387f1819d9a2a42", + "m_Id": 0, + "m_DisplayName": "Mask Map", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_BareResource": false +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "bb939f6d6c10443fbda6386f4dd6400f", + "m_Id": 2, + "m_DisplayName": "Out", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.BlockNode", + "m_ObjectId": "bc220c2be8a74249ac65d93a8ae5cbdf", + "m_Group": { + "m_Id": "" + }, + "m_Name": "SurfaceDescription.SpecularTint", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": 69.0, + "y": 416.0, + "width": 200.0, + "height": 41.0 + } + }, + "m_Slots": [ + { + "m_Id": "da2ed9a7347d45adabf135aa710395f0" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_SerializedDescriptor": "SurfaceDescription.SpecularTint" +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Internal.Texture2DShaderProperty", + "m_ObjectId": "bc814cd1e05d4e94b3b180cbe5f42bfd", + "m_Guid": { + "m_GuidSerialized": "01fa32ed-9744-41c4-a9f3-8f45ff507022" + }, + "m_Name": "Flow Map", + "m_DefaultReferenceName": "Texture2D_bc814cd1e05d4e94b3b180cbe5f42bfd", + "m_OverrideReferenceName": "_FlowMap", + "m_GeneratePropertyBlock": true, + "m_Precision": 0, + "overrideHLSLDeclaration": false, + "hlslDeclarationOverride": 0, + "m_Hidden": false, + "m_Value": { + "m_SerializedTexture": "{\"texture\":{\"instanceID\":0}}", + "m_Guid": "" + }, + "m_Modifiable": true, + "m_DefaultType": 2 +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector4MaterialSlot", + "m_ObjectId": "bd8dbe748a0043779fb75c4c5ef472d2", + "m_Id": 0, + "m_DisplayName": "Highlight A Color", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "bdedaba0281844b89560fdae6a68b49d", + "m_Id": 0, + "m_DisplayName": "", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.GroupData", + "m_ObjectId": "be2cb7795a6143a498576442f64713d6", + "m_Title": "Standard Alpha Clip", + "m_Position": { + "x": -1628.999755859375, + "y": 1126.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "bec14e41986f40ceb443e419826d6152", + "m_Id": 1, + "m_DisplayName": "Out", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "bf113cf12d084dd78b5cf10c04731f09", + "m_Id": 0, + "m_DisplayName": "Base", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "Base", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "bfbef448f50049129a27cbe3ca7f792b", + "m_Id": 7, + "m_DisplayName": "A", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "A", + "m_StageCapability": 2, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.SampleTexture2DNode", + "m_ObjectId": "bfcbbb8f16894a09b2943bd4af0e7e17", + "m_Group": { + "m_Id": "244280d6eea94f08bb23a8e3db3784a3" + }, + "m_Name": "Sample Texture 2D", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -6634.0, + "y": -3314.0, + "width": 184.0, + "height": 253.0 + } + }, + "m_Slots": [ + { + "m_Id": "6c3bedec93094896bde411fafa3e8dc6" + }, + { + "m_Id": "4b5c95d79f4f4e1f80a4247ccff8ef70" + }, + { + "m_Id": "66c44281292d4a29a4209f12788c935b" + }, + { + "m_Id": "a8dcc8405c90479ab17d757638e58443" + }, + { + "m_Id": "174d538819664420a4c03320ca98f5ca" + }, + { + "m_Id": "e47b6bae5ac24221aa3afefdc300437b" + }, + { + "m_Id": "00baaaa5003c4088b756f5c193d00dc8" + }, + { + "m_Id": "ce78c7fe3fb94341be9c6ba4578154dc" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_TextureType": 0, + "m_NormalMapSpace": 0 +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "bfd33bef84114dd0900f4fba28e38750", + "m_Id": 1, + "m_DisplayName": "", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "bff604d608624e4b9d2d0b96434e725f", + "m_Id": 0, + "m_DisplayName": "Vertex Color Strength", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicValueMaterialSlot", + "m_ObjectId": "c021d49d87464e5c92f577f0d4147b48", + "m_Id": 0, + "m_DisplayName": "A", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "A", + "m_StageCapability": 3, + "m_Value": { + "e00": 0.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 0.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 0.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 0.0 + }, + "m_DefaultValue": { + "e00": 1.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 1.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 1.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicValueMaterialSlot", + "m_ObjectId": "c022e7d9bc3c4318a84b31d3148f6e7c", + "m_Id": 1, + "m_DisplayName": "B", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "B", + "m_StageCapability": 3, + "m_Value": { + "e00": 2.0, + "e01": 2.0, + "e02": 2.0, + "e03": 2.0, + "e10": 2.0, + "e11": 2.0, + "e12": 2.0, + "e13": 2.0, + "e20": 2.0, + "e21": 2.0, + "e22": 2.0, + "e23": 2.0, + "e30": 2.0, + "e31": 2.0, + "e32": 2.0, + "e33": 2.0 + }, + "m_DefaultValue": { + "e00": 1.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 1.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 1.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.NormalStrengthNode", + "m_ObjectId": "c11ee2e3010d48a9a45e803c58cceaa3", + "m_Group": { + "m_Id": "" + }, + "m_Name": "Normal Strength", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -1393.0001220703125, + "y": 796.0, + "width": 166.0, + "height": 117.99999237060547 + } + }, + "m_Slots": [ + { + "m_Id": "cd0678aa9ec34c438304e160465603a1" + }, + { + "m_Id": "7ebc51c5ee6542f483e212e0a309011a" + }, + { + "m_Id": "1bbfb308461446debb1bfaf74fb9d0fb" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "c1b39d019e5f4a919445734f14e17383", + "m_Id": 1, + "m_DisplayName": "", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.MultiplyNode", + "m_ObjectId": "c24cb266ce15442eb0f5153676058cf1", + "m_Group": { + "m_Id": "244280d6eea94f08bb23a8e3db3784a3" + }, + "m_Name": "Multiply", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -5536.0, + "y": -3392.0, + "width": 125.99999237060547, + "height": 118.0 + } + }, + "m_Slots": [ + { + "m_Id": "97329b0263264ba9ab8fe3ee9be7ea2f" + }, + { + "m_Id": "96f29f5a114341779a003463de81c96f" + }, + { + "m_Id": "64baa9795a224e1d897c57704d370950" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "c2c2e79a9d5247ada27d118ccad239ae", + "m_Id": 0, + "m_DisplayName": "A", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "A", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.PropertyNode", + "m_ObjectId": "c2f112e363d049f68f0c3b3031c18f06", + "m_Group": { + "m_Id": "244280d6eea94f08bb23a8e3db3784a3" + }, + "m_Name": "Property", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -5621.0, + "y": -3095.0, + "width": 130.0, + "height": 34.0 + } + }, + "m_Slots": [ + { + "m_Id": "ec0565f1704140d696b67fae0c738932" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_Property": { + "m_Id": "a63d692b98084be8b8748b7cd4391a19" + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.StickyNoteData", + "m_ObjectId": "c3448cd8492948db8adf7a079b6fcd8e", + "m_Title": "HDRP", + "m_Content": "R = Metallic\nG = AO\nB = Micro Normal Mask\nA = Smoothness", + "m_TextSize": 0, + "m_Theme": 0, + "m_Position": { + "serializedVersion": "2", + "x": -2304.0, + "y": -394.0, + "width": 200.0, + "height": 100.0 + }, + "m_Group": { + "m_Id": "" + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.SamplerStateMaterialSlot", + "m_ObjectId": "c37c97a92c19442dad070dbf06704ded", + "m_Id": 3, + "m_DisplayName": "Sampler", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "Sampler", + "m_StageCapability": 3, + "m_BareResource": false +} + +{ + "m_SGVersion": 1, + "m_Type": "UnityEditor.ShaderGraph.CustomFunctionNode", + "m_ObjectId": "c3875f35cac14d3ab6d3ae545d281df7", + "m_Group": { + "m_Id": "3aedb1a4a3f540528911bf5344ee2e15" + }, + "m_Name": "_3PointDist (Custom Function)", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -4092.0, + "y": -2772.0, + "width": 227.00001525878907, + "height": 142.00001525878907 + } + }, + "m_Slots": [ + { + "m_Id": "9da31e3009c14bc09ce06ce0ee9ad590" + }, + { + "m_Id": "ee90ae827af64f9b89184e239fe4761c" + }, + { + "m_Id": "dbca081fff064bb2891f3eb49b95a30a" + }, + { + "m_Id": "9a217da0aef34eaba6b9c096a97aa6b0" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_SourceType": 1, + "m_FunctionName": "_3PointDist", + "m_FunctionSource": "", + "m_FunctionBody": "float lower = smoothstep(From.x, From.y, In);\nfloat upper = 1.0 - smoothstep(From.y, From.z, In);\nOut = Fac * lerp(lower, upper, step(From.y, In));" +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.ScreenPositionMaterialSlot", + "m_ObjectId": "c397f7900ec14147bae4c9c1de892440", + "m_Id": 1, + "m_DisplayName": "Screen Position", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "ScreenPosition", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_Labels": [], + "m_ScreenSpaceType": 0 +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "c47e9f8f06464bcaba87ddfdec2550d1", + "m_Id": 6, + "m_DisplayName": "B", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "B", + "m_StageCapability": 2, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "c4d85aabf28d46bb9a7f20519197a24a", + "m_Id": 0, + "m_DisplayName": "Base", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "Base", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicValueMaterialSlot", + "m_ObjectId": "c55f572322244a4dae2badfed69c29e6", + "m_Id": 0, + "m_DisplayName": "A", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "A", + "m_StageCapability": 3, + "m_Value": { + "e00": 0.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 0.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 0.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 0.0 + }, + "m_DefaultValue": { + "e00": 1.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 1.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 1.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicValueMaterialSlot", + "m_ObjectId": "c60878de532b40f18b8873bf81da94c3", + "m_Id": 0, + "m_DisplayName": "A", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "A", + "m_StageCapability": 3, + "m_Value": { + "e00": 0.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 0.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 0.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 0.0 + }, + "m_DefaultValue": { + "e00": 1.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 1.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 1.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "c6b2bdeea61f477c8613fc7f050fa911", + "m_Id": 0, + "m_DisplayName": "In", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "In", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "c72d2de9789b4e71993157a522a61ba7", + "m_Id": 2, + "m_DisplayName": "Out", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "c8052818c52d489d8a306ac8686991dc", + "m_Id": 1, + "m_DisplayName": "", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.PropertyNode", + "m_ObjectId": "c82337ad5b6a41fba467321b6a383a9f", + "m_Group": { + "m_Id": "03640179a61e456c8a3f77f11616681e" + }, + "m_Name": "Property", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -2343.0, + "y": -1358.0, + "width": 161.00001525878907, + "height": 34.0 + } + }, + "m_Slots": [ + { + "m_Id": "4e7893784aea4b66977da5d201763cfc" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_Property": { + "m_Id": "da00c269686246c39fbda3af5e79189b" + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.OneMinusNode", + "m_ObjectId": "c896751d379b48b793ac05bbc6687f65", + "m_Group": { + "m_Id": "b773332f12a640f2961cff577b07701f" + }, + "m_Name": "One Minus", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -1884.9998779296875, + "y": 1625.0, + "width": 128.0, + "height": 94.0 + } + }, + "m_Slots": [ + { + "m_Id": "72408d8c59e6451f8a9f8fe57493ee3b" + }, + { + "m_Id": "0e22fca13e234609afab56d5e9dc57e2" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 1, + "m_Type": "UnityEditor.ShaderGraph.Internal.Vector1ShaderProperty", + "m_ObjectId": "c89f13cfecbd4fdb8a873b05073b0e11", + "m_Guid": { + "m_GuidSerialized": "90f11c74-56bc-4364-8e29-5ac4ffc92aca" + }, + "m_Name": "Blend Strength", + "m_DefaultReferenceName": "", + "m_OverrideReferenceName": "_BlendStrength", + "m_GeneratePropertyBlock": true, + "m_Precision": 0, + "overrideHLSLDeclaration": false, + "hlslDeclarationOverride": 0, + "m_Hidden": false, + "m_Value": 1.0, + "m_FloatType": 1, + "m_RangeValues": { + "x": 0.0, + "y": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector4MaterialSlot", + "m_ObjectId": "c8a9429d23f04410ad03af22a1cc6b1d", + "m_Id": 0, + "m_DisplayName": "RGBA", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "RGBA", + "m_StageCapability": 2, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "c904bc3c3ffd44ed9e3e0564288be1eb", + "m_Id": 2, + "m_DisplayName": "Out", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "c9f72ba214714e51823232f53b68f2f9", + "m_Id": 0, + "m_DisplayName": "Highlight A Strength", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "ca5234deb5234b29b26df2134352eaed", + "m_Id": 0, + "m_DisplayName": "Base", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "Base", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.BlockNode", + "m_ObjectId": "ca5e280a68af4a45a358d1f7b9cff2e2", + "m_Group": { + "m_Id": "" + }, + "m_Name": "SurfaceDescription.NormalTS", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": 87.99999237060547, + "y": 647.9999389648438, + "width": 200.0, + "height": 41.0 + } + }, + "m_Slots": [ + { + "m_Id": "364bf0711ec54f028805cfb78c3b2936" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_SerializedDescriptor": "SurfaceDescription.NormalTS" +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.Rendering.HighDefinition.ShaderGraph.SystemData", + "m_ObjectId": "ca7dd4e86229499ea82f26ce21b18c9f", + "m_MaterialNeedsUpdateHash": 12719, + "m_SurfaceType": 1, + "m_RenderingPass": 4, + "m_BlendMode": 0, + "m_ZTest": 4, + "m_ZWrite": true, + "m_TransparentCullMode": 2, + "m_OpaqueCullMode": 2, + "m_SortPriority": 2, + "m_AlphaTest": true, + "m_TransparentDepthPrepass": false, + "m_TransparentDepthPostpass": false, + "m_SupportLodCrossFade": false, + "m_DoubleSidedMode": 1, + "m_DOTSInstancing": false, + "m_Version": 0, + "m_FirstTimeMigrationExecuted": true, + "inspectorFoldoutMask": 9 +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Texture2DMaterialSlot", + "m_ObjectId": "cc15a8fb0b364f469593fef4f259db42", + "m_Id": 0, + "m_DisplayName": "Blend Map", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_BareResource": false +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "cc8fa1bf760b4fd584f1204d418bd893", + "m_Id": 1, + "m_DisplayName": "", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector3MaterialSlot", + "m_ObjectId": "cd0678aa9ec34c438304e160465603a1", + "m_Id": 0, + "m_DisplayName": "In", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "In", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 1.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0 + }, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.PropertyNode", + "m_ObjectId": "cd5616f7b08c4b37bb7a7b56afc8ca2b", + "m_Group": { + "m_Id": "244280d6eea94f08bb23a8e3db3784a3" + }, + "m_Name": "Property", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -5783.99951171875, + "y": -2855.0, + "width": 181.0, + "height": 34.0 + } + }, + "m_Slots": [ + { + "m_Id": "d366f876b9b14a159e4e8d372a2ed4f4" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_Property": { + "m_Id": "b638b475ea844c8f953ca43f5b9f3316" + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "ce22b01ae86b49498fc7433b4774a23d", + "m_Id": 0, + "m_DisplayName": "Invert Root Map", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.SamplerStateMaterialSlot", + "m_ObjectId": "ce78c7fe3fb94341be9c6ba4578154dc", + "m_Id": 3, + "m_DisplayName": "Sampler", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "Sampler", + "m_StageCapability": 3, + "m_BareResource": false +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.PropertyNode", + "m_ObjectId": "d007bea8b7874cd3983c3448fe35b232", + "m_Group": { + "m_Id": "03640179a61e456c8a3f77f11616681e" + }, + "m_Name": "Property", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -1682.0, + "y": -839.0, + "width": 189.00001525878907, + "height": 34.0 + } + }, + "m_Slots": [ + { + "m_Id": "bff604d608624e4b9d2d0b96434e725f" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_Property": { + "m_Id": "5ef8aef8a81b4183b2aa03d38ada5d75" + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "d0c5c3ec172a44dbb55d75c9f6261716", + "m_Id": 1, + "m_DisplayName": "Standard", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "STANDARD", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 1, + "m_Type": "UnityEditor.ShaderGraph.Internal.Vector1ShaderProperty", + "m_ObjectId": "d0cb7f74d07a479c8d2528bb0485e008", + "m_Guid": { + "m_GuidSerialized": "d3fbf4e4-ec33-421c-afb7-ec0413815312" + }, + "m_Name": "Highlight B Overlap Invert", + "m_DefaultReferenceName": "", + "m_OverrideReferenceName": "_HighlightBOverlapInvert", + "m_GeneratePropertyBlock": true, + "m_Precision": 0, + "overrideHLSLDeclaration": false, + "hlslDeclarationOverride": 0, + "m_Hidden": false, + "m_Value": 1.0, + "m_FloatType": 1, + "m_RangeValues": { + "x": 0.0, + "y": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.PropertyNode", + "m_ObjectId": "d0cc3b3b53f440678f753c7d24288c01", + "m_Group": { + "m_Id": "1bf156e34830433f9d5347d334ce2f5d" + }, + "m_Name": "Property", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -1890.0, + "y": -547.0, + "width": 221.00001525878907, + "height": 34.0 + } + }, + "m_Slots": [ + { + "m_Id": "65a7bf4f97f840ca96e663885f94ada4" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_Property": { + "m_Id": "9797716d61f541a994b33c73d00c450a" + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.BlockNode", + "m_ObjectId": "d0f957ba1d13421b96ab67ec531eefa7", + "m_Group": { + "m_Id": "" + }, + "m_Name": "SurfaceDescription.BaseColor", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": 0.0, + "y": 0.0, + "width": 0.0, + "height": 0.0 + } + }, + "m_Slots": [ + { + "m_Id": "efd248053249470994c19338779f963b" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_SerializedDescriptor": "SurfaceDescription.BaseColor" +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.MultiplyNode", + "m_ObjectId": "d135a9d074e34f8a82f5f778a5fc8a77", + "m_Group": { + "m_Id": "3aedb1a4a3f540528911bf5344ee2e15" + }, + "m_Name": "Multiply", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -3592.999755859375, + "y": -2772.0, + "width": 126.00000762939453, + "height": 118.0 + } + }, + "m_Slots": [ + { + "m_Id": "156cedca2c32409499c3d5aeb67364dd" + }, + { + "m_Id": "8b2165f4b38547d1bbe7d804f72d7f6a" + }, + { + "m_Id": "ef5f12b7b24246c78bac076d7f052554" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "d2879013cac543e893122f0eacba141b", + "m_Id": 1, + "m_DisplayName": "", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.RedirectNodeData", + "m_ObjectId": "d2920db565474984a8eae456eca16597", + "m_Group": { + "m_Id": "" + }, + "m_Name": "Redirect Node", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -411.99981689453127, + "y": 167.99998474121095, + "width": 56.0, + "height": 23.999998092651368 + } + }, + "m_Slots": [ + { + "m_Id": "9c661df801f348f0ad7991ba68cbe2d5" + }, + { + "m_Id": "17d3d431592e4c2bb1780a1e0a9f03a2" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.BlendNode", + "m_ObjectId": "d2a1a0932aa14dd0b783f2ed23c7be39", + "m_Group": { + "m_Id": "03640179a61e456c8a3f77f11616681e" + }, + "m_Name": "Blend", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -1958.0001220703125, + "y": -1234.0, + "width": 161.0, + "height": 178.0 + } + }, + "m_Slots": [ + { + "m_Id": "c4d85aabf28d46bb9a7f20519197a24a" + }, + { + "m_Id": "236a7df61557494b8f4abdc666852d98" + }, + { + "m_Id": "4ab8da5b661247edbcb394eddf59a155" + }, + { + "m_Id": "ae7156f33d8c4ac68f9c29a9092780a0" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_BlendMode": 13 +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.PropertyNode", + "m_ObjectId": "d2e83ab99d6c4bf48651e111f4c6e88b", + "m_Group": { + "m_Id": "" + }, + "m_Name": "Property", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -1371.0, + "y": 341.0000305175781, + "width": 156.0, + "height": 34.000003814697269 + } + }, + "m_Slots": [ + { + "m_Id": "ac491fb4bb4341d192f0f74e368b5af7" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_Property": { + "m_Id": "a07bfbc05b904ff6b24292a9d830a741" + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicValueMaterialSlot", + "m_ObjectId": "d2efab0214c14cf6ab4420240505eab6", + "m_Id": 1, + "m_DisplayName": "", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "", + "m_StageCapability": 3, + "m_Value": { + "e00": 0.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 0.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 0.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 0.0 + }, + "m_DefaultValue": { + "e00": 1.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 1.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 1.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "d366f876b9b14a159e4e8d372a2ed4f4", + "m_Id": 0, + "m_DisplayName": "Base Color Strength", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "d387dd07da1e4951a0e8ed8ac88c0e9a", + "m_Id": 1, + "m_DisplayName": "", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.PropertyNode", + "m_ObjectId": "d39a9113840a4a86b90ff79526878a19", + "m_Group": { + "m_Id": "0e8b3d01fbd24a99bdb2e8e85a456a90" + }, + "m_Name": "Property", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -4022.0, + "y": -2007.000244140625, + "width": 201.00001525878907, + "height": 34.0 + } + }, + "m_Slots": [ + { + "m_Id": "329147dd2e8542a78c6caf48245f7cda" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_Property": { + "m_Id": "7f66c6abce0e4576b0c98c2f4e19050c" + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "d40713f2096b42e38a0c7e5f8926687d", + "m_Id": 4, + "m_DisplayName": "R", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "R", + "m_StageCapability": 2, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "d5dcab95cbd5417d88c86a4905d524cc", + "m_Id": 0, + "m_DisplayName": "Smoothness Min", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 1, + "m_Type": "UnityEditor.ShaderGraph.Internal.Vector1ShaderProperty", + "m_ObjectId": "d5ea19d7fc704761908396f642de59c8", + "m_Guid": { + "m_GuidSerialized": "4c15fac4-6456-4d6a-b272-cbe501cb8e12" + }, + "m_Name": "Shadow Clip", + "m_DefaultReferenceName": "Vector1_d5ea19d7fc704761908396f642de59c8", + "m_OverrideReferenceName": "_ShadowClip", + "m_GeneratePropertyBlock": true, + "m_Precision": 0, + "overrideHLSLDeclaration": false, + "hlslDeclarationOverride": 0, + "m_Hidden": false, + "m_Value": 0.20000000298023225, + "m_FloatType": 1, + "m_RangeValues": { + "x": 0.0, + "y": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.ShaderKeyword", + "m_ObjectId": "d7616bdb7fec4d338db92ff5b42d8172", + "m_Guid": { + "m_GuidSerialized": "1b452c1c-453a-474f-af12-1003911449be" + }, + "m_Name": "Enable Color", + "m_DefaultReferenceName": "BOOLEAN_D7616BDB7FEC4D338DB92FF5B42D8172_ON", + "m_OverrideReferenceName": "BOOLEAN_ENABLECOLOR_ON", + "m_GeneratePropertyBlock": true, + "m_KeywordType": 0, + "m_KeywordDefinition": 1, + "m_KeywordScope": 0, + "m_Entries": [], + "m_Value": 0, + "m_IsEditable": true +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "d82ebec1ca59449cb43e46802671cb2a", + "m_Id": 0, + "m_DisplayName": "Base", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "Base", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.PropertyNode", + "m_ObjectId": "d875584c381349c8be1fd7ec51b347ee", + "m_Group": { + "m_Id": "3aedb1a4a3f540528911bf5344ee2e15" + }, + "m_Name": "Property", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -4460.0, + "y": -2404.000244140625, + "width": 210.0, + "height": 34.0 + } + }, + "m_Slots": [ + { + "m_Id": "2de1c1fb5e4d46c19c8e78d80438fd1f" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_Property": { + "m_Id": "f832572ded9b45b69c1711ca629a49f1" + } +} + +{ + "m_SGVersion": 1, + "m_Type": "UnityEditor.ShaderGraph.Internal.Vector1ShaderProperty", + "m_ObjectId": "d962fe658f9a4982b62bd75d03b2276e", + "m_Guid": { + "m_GuidSerialized": "6c26b18b-16d4-4524-a7d2-0120218bb0fc" + }, + "m_Name": "Alpha Clip", + "m_DefaultReferenceName": "Vector1_d962fe658f9a4982b62bd75d03b2276e", + "m_OverrideReferenceName": "_AlphaClip", + "m_GeneratePropertyBlock": true, + "m_Precision": 0, + "overrideHLSLDeclaration": false, + "hlslDeclarationOverride": 0, + "m_Hidden": false, + "m_Value": 0.20000000298023225, + "m_FloatType": 1, + "m_RangeValues": { + "x": 0.0, + "y": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.RedirectNodeData", + "m_ObjectId": "d971314bc5f54cdab9c09233077b1881", + "m_Group": { + "m_Id": "" + }, + "m_Name": "Redirect Node", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -1321.0, + "y": 226.0, + "width": 56.000003814697269, + "height": 24.000001907348634 + } + }, + "m_Slots": [ + { + "m_Id": "8f7592f0a88049148d7a20c1cb1e22cb" + }, + { + "m_Id": "d2879013cac543e893122f0eacba141b" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 1, + "m_Type": "UnityEditor.ShaderGraph.Internal.Vector1ShaderProperty", + "m_ObjectId": "da00c269686246c39fbda3af5e79189b", + "m_Guid": { + "m_GuidSerialized": "33f3229b-e4c1-444e-ab50-df47a4a9571f" + }, + "m_Name": "Diffuse Strength", + "m_DefaultReferenceName": "", + "m_OverrideReferenceName": "_DiffuseStrength", + "m_GeneratePropertyBlock": true, + "m_Precision": 0, + "overrideHLSLDeclaration": false, + "hlslDeclarationOverride": 0, + "m_Hidden": false, + "m_Value": 1.0, + "m_FloatType": 1, + "m_RangeValues": { + "x": 0.0, + "y": 2.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.ColorRGBMaterialSlot", + "m_ObjectId": "da2ed9a7347d45adabf135aa710395f0", + "m_Id": 0, + "m_DisplayName": "Specular Tint", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "SpecularTint", + "m_StageCapability": 2, + "m_Value": { + "x": 1.0, + "y": 1.0, + "z": 1.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0 + }, + "m_Labels": [], + "m_ColorMode": 0, + "m_DefaultColor": { + "r": 1.0, + "g": 1.0, + "b": 1.0, + "a": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "db66712351c04b3eb291dd17798f7b1c", + "m_Id": 7, + "m_DisplayName": "A", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "A", + "m_StageCapability": 2, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "dbca081fff064bb2891f3eb49b95a30a", + "m_Id": 1, + "m_DisplayName": "Fac", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "Fac", + "m_StageCapability": 3, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "dc1b9877907b479a88d384c2e3e55bff", + "m_Id": 1, + "m_DisplayName": "Out", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "dc9f32ed8d964c4b8ef28c011088ac6b", + "m_Id": 0, + "m_DisplayName": "Blend Strength", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.PropertyNode", + "m_ObjectId": "dd6f6572051e4d659f72bb5b91baefdc", + "m_Group": { + "m_Id": "72585dd91b3d4da7b55123bae128c48b" + }, + "m_Name": "Property", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -5882.0, + "y": -1739.0001220703125, + "width": 145.0, + "height": 34.0 + } + }, + "m_Slots": [ + { + "m_Id": "643250ef0d8741a19386e415a95301b8" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_Property": { + "m_Id": "9194e285b5944b798d84abcebaa562f1" + } +} + +{ + "m_SGVersion": 1, + "m_Type": "UnityEditor.ShaderGraph.Internal.Vector1ShaderProperty", + "m_ObjectId": "ddc2f22573d241e787bf84f06e4ba049", + "m_Guid": { + "m_GuidSerialized": "896ff0e2-487e-462b-97a9-d76d74fab136" + }, + "m_Name": "Normal Strength", + "m_DefaultReferenceName": "", + "m_OverrideReferenceName": "_NormalStrength", + "m_GeneratePropertyBlock": true, + "m_Precision": 0, + "overrideHLSLDeclaration": false, + "hlslDeclarationOverride": 0, + "m_Hidden": false, + "m_Value": 1.0, + "m_FloatType": 1, + "m_RangeValues": { + "x": 0.0, + "y": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector4MaterialSlot", + "m_ObjectId": "ddcb7341ea314d2a9dfbbc1d9d9f4fbd", + "m_Id": 0, + "m_DisplayName": "Out", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": { + "x": 1.0, + "y": 1.0, + "z": 1.0, + "w": 1.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.OneMinusNode", + "m_ObjectId": "de2a22dd96324e7992af5f4b781aec04", + "m_Group": { + "m_Id": "1bf156e34830433f9d5347d334ce2f5d" + }, + "m_Name": "One Minus", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -1373.0, + "y": -458.0000305175781, + "width": 128.0, + "height": 94.0 + } + }, + "m_Slots": [ + { + "m_Id": "a27e4e19b2784093a7979238abae6ade" + }, + { + "m_Id": "e31166814d3742f0be3f264aa7be94d3" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.OneMinusNode", + "m_ObjectId": "debaaee10b654011933a2346630b5137", + "m_Group": { + "m_Id": "b3823636393244d99c581f1785baf857" + }, + "m_Name": "One Minus", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -2079.0, + "y": 2023.0, + "width": 128.0, + "height": 94.0 + } + }, + "m_Slots": [ + { + "m_Id": "2d0ca58a54814172a8890b7463d193fd" + }, + { + "m_Id": "359ed959f5ae49cc8ffb169c40b8e27c" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Texture2DInputMaterialSlot", + "m_ObjectId": "decdf89d9b1c47e49e07623e017ab4f8", + "m_Id": 1, + "m_DisplayName": "Texture", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "Texture", + "m_StageCapability": 3, + "m_BareResource": false, + "m_Texture": { + "m_SerializedTexture": "{\"texture\":{\"instanceID\":0}}", + "m_Guid": "" + }, + "m_DefaultType": 0 +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "def655a2d68e4f6b9fe2e956de18548a", + "m_Id": 5, + "m_DisplayName": "G", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "G", + "m_StageCapability": 2, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.RedirectNodeData", + "m_ObjectId": "e00715f93656411ba7edbb256c828294", + "m_Group": { + "m_Id": "" + }, + "m_Name": "Redirect Node", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -4181.0, + "y": -1252.0, + "width": 56.0, + "height": 23.999998092651368 + } + }, + "m_Slots": [ + { + "m_Id": "8d2276fdbc7b4be0899c5705eb302e91" + }, + { + "m_Id": "d2efab0214c14cf6ab4420240505eab6" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.PropertyNode", + "m_ObjectId": "e00fd7cf1bf84eb8af3423a5f84f02da", + "m_Group": { + "m_Id": "" + }, + "m_Name": "Property", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -563.0, + "y": 618.0, + "width": 207.0, + "height": 34.0 + } + }, + "m_Slots": [ + { + "m_Id": "1846dfbb5b1441829b77365754ab377d" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_Property": { + "m_Id": "629bfa855bb345f5b11dd44954fbddba" + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.PropertyNode", + "m_ObjectId": "e0b7f015d0b949be87c33efde8fa3b69", + "m_Group": { + "m_Id": "03640179a61e456c8a3f77f11616681e" + }, + "m_Name": "Property", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -1031.0, + "y": -954.0, + "width": 171.0, + "height": 34.0 + } + }, + "m_Slots": [ + { + "m_Id": "58711163a142498093e1638e6ecf2aa1" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_Property": { + "m_Id": "a8fac80485344a489b31db2a226e0489" + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicValueMaterialSlot", + "m_ObjectId": "e162ae534d3c4d45a392aaf9ecd7d16f", + "m_Id": 0, + "m_DisplayName": "", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "", + "m_StageCapability": 3, + "m_Value": { + "e00": 0.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 0.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 0.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 0.0 + }, + "m_DefaultValue": { + "e00": 1.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 1.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 1.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector4MaterialSlot", + "m_ObjectId": "e1b8260eccc44d31ab1d3217779a2c4d", + "m_Id": 0, + "m_DisplayName": "RGBA", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "RGBA", + "m_StageCapability": 2, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_Labels": [] +} + +{ + "m_SGVersion": 1, + "m_Type": "UnityEditor.ShaderGraph.CustomFunctionNode", + "m_ObjectId": "e1da77b3145d43e9a95e681afd6c3b82", + "m_Group": { + "m_Id": "0e8b3d01fbd24a99bdb2e8e85a456a90" + }, + "m_Name": "_3PointDist (Custom Function)", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -3648.000244140625, + "y": -2007.0, + "width": 217.0, + "height": 142.0 + } + }, + "m_Slots": [ + { + "m_Id": "103fe7e5bb18457685d64a677f52d7fd" + }, + { + "m_Id": "35a13a4d1682463fa62dfeb696f6c3d6" + }, + { + "m_Id": "e81e36d12ea947f586c98d385006d438" + }, + { + "m_Id": "3b62bae183e64b548cc5d7fc2f4888ee" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_SourceType": 1, + "m_FunctionName": "_3PointDist", + "m_FunctionSource": "", + "m_FunctionBody": "float lower = smoothstep(From.x, From.y, In);\nfloat upper = 1.0 - smoothstep(From.y, From.z, In);\nOut = Fac * lerp(lower, upper, step(From.y, In));" +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "e25ec37da9a34626b6bed14250468f40", + "m_Id": 7, + "m_DisplayName": "A", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "A", + "m_StageCapability": 2, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.SampleTexture2DNode", + "m_ObjectId": "e2bec6c3826047c8a8ca759c60bb19ff", + "m_Group": { + "m_Id": "" + }, + "m_Name": "Sample Texture 2D", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -1672.0, + "y": 114.0, + "width": 184.0, + "height": 253.00001525878907 + } + }, + "m_Slots": [ + { + "m_Id": "2cee3bb09b784906b68914fdfd279c7d" + }, + { + "m_Id": "83ccede77bf347b5ada7f22a90a71e54" + }, + { + "m_Id": "08ccc7ab660441e99b582e3f493ce062" + }, + { + "m_Id": "11b80c01acff493e8d25da0eeae5b521" + }, + { + "m_Id": "15a95450e5e046cbb66c50e363aa6f5c" + }, + { + "m_Id": "645f90c185f2471d9630858b570a39ca" + }, + { + "m_Id": "f8768b5697a64470ae1a4e107cec1277" + }, + { + "m_Id": "46c045243fd947a3bf8f480d04000881" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_TextureType": 1, + "m_NormalMapSpace": 0 +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "e30d33c3db434bae88da4c3b97aae575", + "m_Id": 2, + "m_DisplayName": "Out", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "e31166814d3742f0be3f264aa7be94d3", + "m_Id": 1, + "m_DisplayName": "Out", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "e31bf6dc23e84624bbffe7d762c0b242", + "m_Id": 0, + "m_DisplayName": "Smoothness Power", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.RedirectNodeData", + "m_ObjectId": "e37f421af20040a6bf27c01f0c1ea39e", + "m_Group": { + "m_Id": "244280d6eea94f08bb23a8e3db3784a3" + }, + "m_Name": "Redirect Node", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -6267.0, + "y": -2855.0, + "width": 56.0, + "height": 23.999998092651368 + } + }, + "m_Slots": [ + { + "m_Id": "98d9a946b79043339f138bde8e8dce7a" + }, + { + "m_Id": "c1b39d019e5f4a919445734f14e17383" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "e43275d96a9043989d6b9320a9b3a8e4", + "m_Id": 0, + "m_DisplayName": "Root Color Strength", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Texture2DInputMaterialSlot", + "m_ObjectId": "e47b6bae5ac24221aa3afefdc300437b", + "m_Id": 1, + "m_DisplayName": "Texture", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "Texture", + "m_StageCapability": 3, + "m_BareResource": false, + "m_Texture": { + "m_SerializedTexture": "{\"texture\":{\"instanceID\":0}}", + "m_Guid": "" + }, + "m_DefaultType": 0 +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "e523c37eaeb640a8a0c8a2a8e88198d8", + "m_Id": 0, + "m_DisplayName": "Highlight B Overlap Invert", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "e610edbefd4e4785848f57751e777e85", + "m_Id": 3, + "m_DisplayName": "Opacity", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "Opacity", + "m_StageCapability": 3, + "m_Value": 1.0, + "m_DefaultValue": 1.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "e620d929496248c68291cd132b8cf818", + "m_Id": 0, + "m_DisplayName": "Secondary Smoothness", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicValueMaterialSlot", + "m_ObjectId": "e7665d3760434dc88e41ba34f6d09177", + "m_Id": 2, + "m_DisplayName": "Out", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": { + "e00": 0.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 0.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 0.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 0.0 + }, + "m_DefaultValue": { + "e00": 1.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 1.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 1.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.BlockNode", + "m_ObjectId": "e7adb047317f4e8f97e8758b79640e35", + "m_Group": { + "m_Id": "" + }, + "m_Name": "SurfaceDescription.RimTransmissionIntensity", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": 81.0, + "y": 375.0, + "width": 200.0, + "height": 41.0 + } + }, + "m_Slots": [ + { + "m_Id": "af325e529f144f119f865552aeb01d6b" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_SerializedDescriptor": "SurfaceDescription.RimTransmissionIntensity" +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "e7ddd7819ca24c6ba7389b2c7c3917b2", + "m_Id": 1, + "m_DisplayName": "Out", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "e81e36d12ea947f586c98d385006d438", + "m_Id": 1, + "m_DisplayName": "Fac", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "Fac", + "m_StageCapability": 3, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 1, + "m_Type": "UnityEditor.ShaderGraph.CustomFunctionNode", + "m_ObjectId": "e8e39fa5d225482fbd621c6cd82b6e5a", + "m_Group": { + "m_Id": "3aedb1a4a3f540528911bf5344ee2e15" + }, + "m_Name": "_ScaleToOne (Custom Function)", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -3876.0, + "y": -2590.0, + "width": 228.00001525878907, + "height": 118.00000762939453 + } + }, + "m_Slots": [ + { + "m_Id": "a710a079401c4deaab938e01aa147af8" + }, + { + "m_Id": "40298bdf4a0e49b5b758a4ddc6cb9b9d" + }, + { + "m_Id": "c72d2de9789b4e71993157a522a61ba7" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_SourceType": 1, + "m_FunctionName": "_ScaleToOne", + "m_FunctionSource": "", + "m_FunctionBody": "Out = 1.0 - ((1.0 - In) * Fac);" +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.PropertyNode", + "m_ObjectId": "e914554d54e64faf9720389438495a70", + "m_Group": { + "m_Id": "0e8b3d01fbd24a99bdb2e8e85a456a90" + }, + "m_Name": "Property", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -4017.0, + "y": -1596.000244140625, + "width": 210.00001525878907, + "height": 34.0 + } + }, + "m_Slots": [ + { + "m_Id": "e523c37eaeb640a8a0c8a2a8e88198d8" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_Property": { + "m_Id": "d0cb7f74d07a479c8d2528bb0485e008" + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.SamplerStateMaterialSlot", + "m_ObjectId": "e97c3fa8ab4d480faefb7391b4a9c808", + "m_Id": 3, + "m_DisplayName": "Sampler", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "Sampler", + "m_StageCapability": 3, + "m_BareResource": false +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "e9bda8c3d270475490b2b7838f87a7de", + "m_Id": 0, + "m_DisplayName": "Specular Multiplier", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Texture2DInputMaterialSlot", + "m_ObjectId": "ea85740a0e1e4ec5bcd3084711e2da2f", + "m_Id": 1, + "m_DisplayName": "Texture", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "Texture", + "m_StageCapability": 3, + "m_BareResource": false, + "m_Texture": { + "m_SerializedTexture": "{\"texture\":{\"instanceID\":0}}", + "m_Guid": "" + }, + "m_DefaultType": 3 +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "ea9e36b0bc4d43a58de6c25b038e8c46", + "m_Id": 0, + "m_DisplayName": "Global Strength", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "eaa026e6c1f64f6580cf34205cb823dc", + "m_Id": 4, + "m_DisplayName": "R", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "R", + "m_StageCapability": 2, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "eac54b5f186d486e80825976e56c5237", + "m_Id": 1, + "m_DisplayName": "", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "eb77128ab4c94f07bcb9c760a1b2d6ff", + "m_Id": 0, + "m_DisplayName": "Out", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.OneMinusNode", + "m_ObjectId": "eb866c4039374f098844e0d54b0d2c13", + "m_Group": { + "m_Id": "1bf156e34830433f9d5347d334ce2f5d" + }, + "m_Name": "One Minus", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -1797.0, + "y": -491.00006103515627, + "width": 128.0, + "height": 94.0 + } + }, + "m_Slots": [ + { + "m_Id": "0f20239df8ac41b097e0a197dd5f1135" + }, + { + "m_Id": "365cd65c568c4c9382b06b223f378be1" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.PropertyNode", + "m_ObjectId": "eba48f1e544d455986b250277b538909", + "m_Group": { + "m_Id": "" + }, + "m_Name": "Property", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -498.00006103515627, + "y": 292.0, + "width": 143.0, + "height": 34.0 + } + }, + "m_Slots": [ + { + "m_Id": "ba480ecbddef4b438d53b2d86976cab9" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_Property": { + "m_Id": "d5ea19d7fc704761908396f642de59c8" + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector4MaterialSlot", + "m_ObjectId": "ec0565f1704140d696b67fae0c738932", + "m_Id": 0, + "m_DisplayName": "End Color", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "ecacf623d41b4d40b943f5b704cefe0b", + "m_Id": 0, + "m_DisplayName": "In", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "In", + "m_StageCapability": 3, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.PropertyNode", + "m_ObjectId": "ed083dc9dc3c4f5fa9248d1b99d92da4", + "m_Group": { + "m_Id": "" + }, + "m_Name": "Property", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -556.0, + "y": 582.0, + "width": 200.0, + "height": 34.0 + } + }, + "m_Slots": [ + { + "m_Id": "e620d929496248c68291cd132b8cf818" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_Property": { + "m_Id": "ed8f4e5d62a34a71a82aedc1436a6cae" + } +} + +{ + "m_SGVersion": 1, + "m_Type": "UnityEditor.ShaderGraph.Internal.Vector1ShaderProperty", + "m_ObjectId": "ed8f4e5d62a34a71a82aedc1436a6cae", + "m_Guid": { + "m_GuidSerialized": "4d72e239-9ff8-45d3-ae3a-d432cdd807b0" + }, + "m_Name": "Secondary Smoothness", + "m_DefaultReferenceName": "", + "m_OverrideReferenceName": "_SecondarySmoothness", + "m_GeneratePropertyBlock": true, + "m_Precision": 0, + "overrideHLSLDeclaration": false, + "hlslDeclarationOverride": 0, + "m_Hidden": false, + "m_Value": 0.6499999761581421, + "m_FloatType": 1, + "m_RangeValues": { + "x": 0.0, + "y": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "ee0b9fe103af4a44b35f4380cd3b3973", + "m_Id": 3, + "m_DisplayName": "Opacity", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "Opacity", + "m_StageCapability": 3, + "m_Value": 1.0, + "m_DefaultValue": 1.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector3MaterialSlot", + "m_ObjectId": "ee90ae827af64f9b89184e239fe4761c", + "m_Id": 0, + "m_DisplayName": "From", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "From", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 1.0, + "z": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0 + }, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Texture2DMaterialSlot", + "m_ObjectId": "ee9cd55adc774c31a6f4699792680829", + "m_Id": 0, + "m_DisplayName": "Flow Map", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_BareResource": false +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicValueMaterialSlot", + "m_ObjectId": "ef5f12b7b24246c78bac076d7f052554", + "m_Id": 2, + "m_DisplayName": "Out", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": { + "e00": 0.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 0.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 0.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 0.0 + }, + "m_DefaultValue": { + "e00": 1.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 1.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 1.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.ColorRGBMaterialSlot", + "m_ObjectId": "efd248053249470994c19338779f963b", + "m_Id": 0, + "m_DisplayName": "Base Color", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "BaseColor", + "m_StageCapability": 2, + "m_Value": { + "x": 0.5, + "y": 0.5, + "z": 0.5 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0 + }, + "m_Labels": [], + "m_ColorMode": 0, + "m_DefaultColor": { + "r": 0.5, + "g": 0.5, + "b": 0.5, + "a": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.UVMaterialSlot", + "m_ObjectId": "f04fd49f51ba4fb684bf9e7cfe737a4c", + "m_Id": 2, + "m_DisplayName": "UV", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "UV", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0 + }, + "m_Labels": [], + "m_Channel": 0 +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.BlockNode", + "m_ObjectId": "f0eca0bb90df4ad88ca3cef5c34fc766", + "m_Group": { + "m_Id": "" + }, + "m_Name": "SurfaceDescription.AlphaClipThresholdDepthPostpass", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": 0.0, + "y": 0.0, + "width": 0.0, + "height": 0.0 + } + }, + "m_Slots": [ + { + "m_Id": "3ead7aeb80554142b1b8acd0ff2e0d13" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_SerializedDescriptor": "SurfaceDescription.AlphaClipThresholdDepthPostpass" +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.PropertyNode", + "m_ObjectId": "f15873d7cae54a328809df9a8d76bbf7", + "m_Group": { + "m_Id": "" + }, + "m_Name": "Property", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -1852.0, + "y": 728.0, + "width": 149.0, + "height": 34.0 + } + }, + "m_Slots": [ + { + "m_Id": "f4ab81528cf24272a9605474cff4b6b0" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_Property": { + "m_Id": "b304178995574d4b8dceaf0eade7e621" + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "f1f92f2e0bdf4aa899175eac8b32f2d6", + "m_Id": 1, + "m_DisplayName": "", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector4MaterialSlot", + "m_ObjectId": "f21deaaac67345a0aab4507845b25c51", + "m_Id": 0, + "m_DisplayName": "RGBA", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "RGBA", + "m_StageCapability": 2, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_Labels": [] +} + +{ + "m_SGVersion": 1, + "m_Type": "UnityEditor.ShaderGraph.Internal.Vector1ShaderProperty", + "m_ObjectId": "f2294eaa0dfc4e4a83519ed20321e66d", + "m_Guid": { + "m_GuidSerialized": "c3d43021-10b5-4855-9251-55fdfaf3831e" + }, + "m_Name": "Global Strength", + "m_DefaultReferenceName": "", + "m_OverrideReferenceName": "_GlobalStrength", + "m_GeneratePropertyBlock": true, + "m_Precision": 0, + "overrideHLSLDeclaration": false, + "hlslDeclarationOverride": 0, + "m_Hidden": false, + "m_Value": 1.0, + "m_FloatType": 1, + "m_RangeValues": { + "x": 0.0, + "y": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "f27d637587474cacb94bfd396d77089d", + "m_Id": 5, + "m_DisplayName": "G", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "G", + "m_StageCapability": 2, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "f2ad0036164a41018d0e761ccde52714", + "m_Id": 1, + "m_DisplayName": "", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.PropertyNode", + "m_ObjectId": "f2b7d300cc4c41a09579db62531aa14a", + "m_Group": { + "m_Id": "244280d6eea94f08bb23a8e3db3784a3" + }, + "m_Name": "Property", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -5820.0, + "y": -3426.0, + "width": 158.0, + "height": 34.0 + } + }, + "m_Slots": [ + { + "m_Id": "ea9e36b0bc4d43a58de6c25b038e8c46" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_Property": { + "m_Id": "f2294eaa0dfc4e4a83519ed20321e66d" + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "f3096cdb279c45eeb8214d88c6601146", + "m_Id": 0, + "m_DisplayName": "Highlight B Strength", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 1, + "m_Type": "UnityEditor.ShaderGraph.Internal.Vector1ShaderProperty", + "m_ObjectId": "f3db2a837d7d47aea3d00d54af30b29d", + "m_Guid": { + "m_GuidSerialized": "ea3d45c4-87b3-4ee2-9eb3-7fcc41a991cf" + }, + "m_Name": "Root Color Strength", + "m_DefaultReferenceName": "", + "m_OverrideReferenceName": "_RootColorStrength", + "m_GeneratePropertyBlock": true, + "m_Precision": 0, + "overrideHLSLDeclaration": false, + "hlslDeclarationOverride": 0, + "m_Hidden": false, + "m_Value": 1.0, + "m_FloatType": 1, + "m_RangeValues": { + "x": 0.0, + "y": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.PropertyNode", + "m_ObjectId": "f4274b5ff3ad4120a550c1bfb31fe327", + "m_Group": { + "m_Id": "03640179a61e456c8a3f77f11616681e" + }, + "m_Name": "Property", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -2263.000244140625, + "y": -880.0, + "width": 153.0, + "height": 34.0 + } + }, + "m_Slots": [ + { + "m_Id": "dc9f32ed8d964c4b8ef28c011088ac6b" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_Property": { + "m_Id": "c89f13cfecbd4fdb8a873b05073b0e11" + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.RedirectNodeData", + "m_ObjectId": "f43a277c26e34eee8f21c22daafd4054", + "m_Group": { + "m_Id": "" + }, + "m_Name": "Redirect Node", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -5113.0, + "y": -2288.0, + "width": 56.000003814697269, + "height": 24.000001907348634 + } + }, + "m_Slots": [ + { + "m_Id": "80a84d9d1dc34c60a7f53615da6a701b" + }, + { + "m_Id": "c8052818c52d489d8a306ac8686991dc" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Texture2DMaterialSlot", + "m_ObjectId": "f4ab81528cf24272a9605474cff4b6b0", + "m_Id": 0, + "m_DisplayName": "Normal Map", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_BareResource": false +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.Rendering.HighDefinition.ShaderGraph.HairData", + "m_ObjectId": "f5f54dac45ca4f98b35bfd8055240a0f", + "m_MaterialType": 0, + "m_UseLightFacingNormal": false +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector4MaterialSlot", + "m_ObjectId": "f6e8c313d5084dee886ad054638ec381", + "m_Id": 0, + "m_DisplayName": "Out", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "f766d98305ef4a969d378fbe95628bb8", + "m_Id": 3, + "m_DisplayName": "Dither", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "DITHER", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.PropertyNode", + "m_ObjectId": "f769abb9b5a74ec89369a250e2c8d39b", + "m_Group": { + "m_Id": "" + }, + "m_Name": "Property", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -1142.0001220703125, + "y": 593.9999389648438, + "width": 146.0, + "height": 34.000003814697269 + } + }, + "m_Slots": [ + { + "m_Id": "28e5ad56a0cc4bd3acbf0cf95dafcd99" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_Property": { + "m_Id": "1728986d8b5d4a60a610dc8f863ef11d" + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.BlendNode", + "m_ObjectId": "f78692b5ae6b4dc3b9e2333153a1ac99", + "m_Group": { + "m_Id": "0e8b3d01fbd24a99bdb2e8e85a456a90" + }, + "m_Name": "Blend", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -2776.0, + "y": -2150.000244140625, + "width": 161.0, + "height": 178.0 + } + }, + "m_Slots": [ + { + "m_Id": "a11bad06f9874030afdb3e20727370ec" + }, + { + "m_Id": "b8146107abf54cceaccead24f962517e" + }, + { + "m_Id": "e610edbefd4e4785848f57751e777e85" + }, + { + "m_Id": "333d7eef2c2e4a54bd96738ef0fb83e4" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_BlendMode": 21 +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.PowerNode", + "m_ObjectId": "f82f65e9659e476a81e3fd01ec59c77d", + "m_Group": { + "m_Id": "72585dd91b3d4da7b55123bae128c48b" + }, + "m_Name": "Power", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -5784.0, + "y": -1905.0, + "width": 126.00000762939453, + "height": 118.00000762939453 + } + }, + "m_Slots": [ + { + "m_Id": "6b773772c1d047e0bcbf0c12e2a24b3c" + }, + { + "m_Id": "9f07c928ca7842c086718cd229013f2a" + }, + { + "m_Id": "88bf21a720444ffb9202127a0174d65e" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 1, + "m_Type": "UnityEditor.ShaderGraph.Internal.Vector1ShaderProperty", + "m_ObjectId": "f832572ded9b45b69c1711ca629a49f1", + "m_Guid": { + "m_GuidSerialized": "d1a728e5-ad3d-414d-ac51-ab9a8c8b440e" + }, + "m_Name": "Highlight A Overlap Invert", + "m_DefaultReferenceName": "", + "m_OverrideReferenceName": "_HighlightAOverlapInvert", + "m_GeneratePropertyBlock": true, + "m_Precision": 0, + "overrideHLSLDeclaration": false, + "hlslDeclarationOverride": 0, + "m_Hidden": false, + "m_Value": 1.0, + "m_FloatType": 1, + "m_RangeValues": { + "x": 0.0, + "y": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "f84ab63ad59d473790240bbae5312104", + "m_Id": 0, + "m_DisplayName": "Normal Strength", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.UVMaterialSlot", + "m_ObjectId": "f8768b5697a64470ae1a4e107cec1277", + "m_Id": 2, + "m_DisplayName": "UV", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "UV", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0 + }, + "m_Labels": [], + "m_Channel": 0 +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.Rendering.HighDefinition.ShaderGraph.BuiltinData", + "m_ObjectId": "f907ec2614f64fee9511dbed58f101b9", + "m_Distortion": false, + "m_DistortionMode": 0, + "m_DistortionDepthTest": true, + "m_AddPrecomputedVelocity": false, + "m_TransparentWritesMotionVec": false, + "m_AlphaToMask": true, + "m_DepthOffset": false, + "m_TransparencyFog": true, + "m_AlphaTestShadow": true, + "m_BackThenFrontRendering": true, + "m_TransparentDepthPrepass": true, + "m_TransparentDepthPostpass": true, + "m_SupportLodCrossFade": false +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.PropertyNode", + "m_ObjectId": "fa23d0762b1842e38b1ce87344837242", + "m_Group": { + "m_Id": "0e8b3d01fbd24a99bdb2e8e85a456a90" + }, + "m_Name": "Property", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -4017.0, + "y": -1751.000244140625, + "width": 201.00001525878907, + "height": 34.0 + } + }, + "m_Slots": [ + { + "m_Id": "6df8942427534735b1532b35c0b04100" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_Property": { + "m_Id": "56ba91985bbb4952a91b73ed158b776b" + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicValueMaterialSlot", + "m_ObjectId": "faa11926f42c42ea8e9f2f14d3afd2b2", + "m_Id": 2, + "m_DisplayName": "Out", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": { + "e00": 0.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 0.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 0.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 0.0 + }, + "m_DefaultValue": { + "e00": 1.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 1.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 1.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicValueMaterialSlot", + "m_ObjectId": "fad7135d3acf435aa4649d22d2463e53", + "m_Id": 2, + "m_DisplayName": "Out", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": { + "e00": 0.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 0.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 0.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 0.0 + }, + "m_DefaultValue": { + "e00": 1.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 1.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 1.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.PositionMaterialSlot", + "m_ObjectId": "fc09e913712c46d780c50a50e6df747c", + "m_Id": 0, + "m_DisplayName": "Position", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "Position", + "m_StageCapability": 1, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0 + }, + "m_Labels": [], + "m_Space": 0 +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "fca9ffe88cae49efa8c33c1354e48c1d", + "m_Id": 6, + "m_DisplayName": "B", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "B", + "m_StageCapability": 2, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "fd0b99eaceeb4cc29b30e534ecffab7e", + "m_Id": 1, + "m_DisplayName": "Out", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.PropertyNode", + "m_ObjectId": "fdc1fb91fa83476caa363209cb103fd5", + "m_Group": { + "m_Id": "03640179a61e456c8a3f77f11616681e" + }, + "m_Name": "Property", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -2457.0, + "y": -1150.0, + "width": 140.0, + "height": 34.0 + } + }, + "m_Slots": [ + { + "m_Id": "cc15a8fb0b364f469593fef4f259db42" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_Property": { + "m_Id": "72d65bc7d4664f6aae2853e9a0fcb1e9" + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.SampleTexture2DNode", + "m_ObjectId": "fe251668acaf4cc1a186f88895925031", + "m_Group": { + "m_Id": "72585dd91b3d4da7b55123bae128c48b" + }, + "m_Name": "Sample Texture 2D", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -6207.0, + "y": -2167.0, + "width": 184.0, + "height": 253.00001525878907 + } + }, + "m_Slots": [ + { + "m_Id": "e1b8260eccc44d31ab1d3217779a2c4d" + }, + { + "m_Id": "6b5deda71f474aee97807127ea957961" + }, + { + "m_Id": "5c85d658386b4b13bd3a308504910663" + }, + { + "m_Id": "c47e9f8f06464bcaba87ddfdec2550d1" + }, + { + "m_Id": "6f484dea1069470eb479d882654b3ea7" + }, + { + "m_Id": "05fbfae444844c6fba5d11a68dde77d9" + }, + { + "m_Id": "1e559a52f2cf4d6282a91a6f552dfcb8" + }, + { + "m_Id": "ae6aeab78fad43109257fd5685aca7ad" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_TextureType": 0, + "m_NormalMapSpace": 0 +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.BlockNode", + "m_ObjectId": "fe4907798c1644289607e0d2603a9a68", + "m_Group": { + "m_Id": "" + }, + "m_Name": "VertexDescription.Tangent", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": 0.0, + "y": 0.0, + "width": 0.0, + "height": 0.0 + } + }, + "m_Slots": [ + { + "m_Id": "36a7e27cf2f142179340d6911fb6702e" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_SerializedDescriptor": "VertexDescription.Tangent" +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.BlockNode", + "m_ObjectId": "fe89101ff92d49e9a630a987e854fb0a", + "m_Group": { + "m_Id": "" + }, + "m_Name": "SurfaceDescription.AlphaClipThresholdShadow", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": 86.0, + "y": 298.0, + "width": 200.0, + "height": 41.0 + } + }, + "m_Slots": [ + { + "m_Id": "a2b446a108624f4ea43455c92d25610e" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_SerializedDescriptor": "SurfaceDescription.AlphaClipThresholdShadow" +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "ff1deab0710a4f9f95f6501e49cd6be6", + "m_Id": 1, + "m_DisplayName": "", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + diff --git a/HDRP/Shaders/RL_HairShaderVariants_HDRP.shadergraph.meta b/HDRP/Shaders/RL_HairShaderVariants_HDRP.shadergraph.meta new file mode 100644 index 0000000..491f852 --- /dev/null +++ b/HDRP/Shaders/RL_HairShaderVariants_HDRP.shadergraph.meta @@ -0,0 +1,10 @@ +fileFormatVersion: 2 +guid: 1b1fb9190f9a21344931aa2df1b6a845 +ScriptedImporter: + internalIDToNameTable: [] + externalObjects: {} + serializedVersion: 2 + userData: + assetBundleName: + assetBundleVariant: + script: {fileID: 11500000, guid: 625f186215c104763be7675aa2d941aa, type: 3} diff --git a/HDRP/Shaders/RL_SkinShaderVariants_HDRP.shadergraph b/HDRP/Shaders/RL_SkinShaderVariants_HDRP.shadergraph new file mode 100644 index 0000000..46f74b0 --- /dev/null +++ b/HDRP/Shaders/RL_SkinShaderVariants_HDRP.shadergraph @@ -0,0 +1,20086 @@ +{ + "m_SGVersion": 2, + "m_Type": "UnityEditor.ShaderGraph.GraphData", + "m_ObjectId": "f85a4e4b91df4a7db442a14fde53ed87", + "m_Properties": [ + { + "m_Id": "cb42572a46a74a588ef3935f3a667eb7" + }, + { + "m_Id": "40b34821d493419797f0cb0b43e6e690" + }, + { + "m_Id": "028c7c4762f843e5818661e89e339595" + }, + { + "m_Id": "4ef79e9b5e3e473abf150852f1ee2eaa" + }, + { + "m_Id": "40ad0182bb1c42b9b661c6e1e59e3b8e" + }, + { + "m_Id": "6a6959874a9c4ee382311d4d6f1c7f76" + }, + { + "m_Id": "8a49d2f872e946d4a29e2030ee291584" + }, + { + "m_Id": "6d2408803a794f2e9368d5529b79a574" + }, + { + "m_Id": "c70d342b1a0b4d6bbf1ff3c98fd338ea" + }, + { + "m_Id": "c4024195aefa495695710ffb5997a875" + }, + { + "m_Id": "daa99c4f268449b8a4e69fdaeafcfe49" + }, + { + "m_Id": "833ac99096aa4e25ac67e1440763f977" + }, + { + "m_Id": "229e12ce054c4003affcf25346b88151" + }, + { + "m_Id": "90d2f8ddb28645b0bddff4de92e61369" + }, + { + "m_Id": "a6dd3195bd6d4a298423e889b02d7c82" + }, + { + "m_Id": "45aabf6161ff4a45a137dd21f95c2d3c" + }, + { + "m_Id": "e31101d048044951bdf13cbddcd0f930" + }, + { + "m_Id": "da213d6a9621401f9a5ffc93e4383f77" + }, + { + "m_Id": "3ddb1de457ce4a0d84f7586eaac11b9a" + }, + { + "m_Id": "d2788286d5f347d4ad6c739e7a423501" + }, + { + "m_Id": "5172aa37e7034721a702d02156b0c3a6" + }, + { + "m_Id": "2cc11af55d6b4faea215407e60307db4" + }, + { + "m_Id": "7089c3af8c734661957df22d8b965d0c" + }, + { + "m_Id": "be9afefb417e4737b75985dc8aaa3962" + }, + { + "m_Id": "500ba94d31a4430589839a4ee489195e" + }, + { + "m_Id": "056e224982a4418783cc9a754ebd4920" + }, + { + "m_Id": "11d663a4721749668b26f021655222e3" + }, + { + "m_Id": "18e7067ff74c497eb92e133c7111aef2" + }, + { + "m_Id": "23347c24053e478b8cfdb9644cccccaf" + }, + { + "m_Id": "f59399cdc25c46fc8f26233a7f05270f" + }, + { + "m_Id": "0f24de491c834c9e804aa21dd58f65af" + }, + { + "m_Id": "73d5befbcccc4534aa3c49586ca61402" + }, + { + "m_Id": "167f8d77ee5e478ab5c3c33cb26ad3c0" + }, + { + "m_Id": "4bbc052da7aa4bb59c0765662e464374" + }, + { + "m_Id": "8f920b195f6f4ae79f14b6daf5d7a75d" + }, + { + "m_Id": "f0d88fda47be4d4b9b1614b6313411df" + }, + { + "m_Id": "e8cdc35a911841ea94f4e76dc4ec9395" + }, + { + "m_Id": "f72531ddf88f4deeb7706f3ee8563193" + }, + { + "m_Id": "1b299f10f9db46719d10fb61b53094c1" + }, + { + "m_Id": "971eb675ce25417c8f423a316a778a4a" + }, + { + "m_Id": "5c244cc3e1824793bbb81324a733903c" + }, + { + "m_Id": "2aff406bc0ff49feab0b75f503b042f0" + }, + { + "m_Id": "c12e83169aaf40a39eef85aea07d238b" + }, + { + "m_Id": "e55f9a75fb6b42608280338c0f6f0543" + }, + { + "m_Id": "f9cefb04dde84a5eb85a204200a3f7ca" + }, + { + "m_Id": "bb4fd70018f64db2a8ce8eb4c3f1fc66" + }, + { + "m_Id": "43ccb360c88d4573b568d5486e4504e5" + }, + { + "m_Id": "0cae67e06abe458f8f01660cbb4221de" + }, + { + "m_Id": "3a7a76a7000244e4b3de2b879f66a390" + }, + { + "m_Id": "a0dea5230a33428cb6bffe7ab816e628" + } + ], + "m_Keywords": [ + { + "m_Id": "4479b5f90a784db6b7291eba881239a9" + } + ], + "m_Nodes": [ + { + "m_Id": "4b45669a84054c498babd493511b3189" + }, + { + "m_Id": "0153caa15e554a9bb37fea4238ebdc5b" + }, + { + "m_Id": "00ab9614abb14bfea39934b2abff144b" + }, + { + "m_Id": "8a7ae7a881424567bd38f733cff73869" + }, + { + "m_Id": "bc0c9bafa3544deaaba658da5d1457a2" + }, + { + "m_Id": "08c1176d7dfe406bb0f6283ca763d553" + }, + { + "m_Id": "e701720035d44304a33f4b64350fc6e3" + }, + { + "m_Id": "6a4b619cae09428e850340b327dc2247" + }, + { + "m_Id": "6b280d605cf34b63ae417129545c2f7d" + }, + { + "m_Id": "e1e6ea93dab24d4086de0ce0507e9306" + }, + { + "m_Id": "d04a1ba74b404509b3874993b5771fe4" + }, + { + "m_Id": "847ac5df0b2d4dd58b05ed5100fd2d88" + }, + { + "m_Id": "e222cb2bff344522873e60fba8643903" + }, + { + "m_Id": "57d17176266344f3bdf544fcd3993330" + }, + { + "m_Id": "35d381f3a7994da39121a67ca007c2ed" + }, + { + "m_Id": "d0f639d2d1ac4285b4ee05ffd5db4009" + }, + { + "m_Id": "273f61f0afd2438d95da7144e127460e" + }, + { + "m_Id": "8d0e91598db04dc39429e4727f60af22" + }, + { + "m_Id": "fce699c8ebf3428887ef6a715d55d4f9" + }, + { + "m_Id": "03f70d9a000b4f7486d44ca34a72624d" + }, + { + "m_Id": "76c23cf23e734562b54dc8d34763eadf" + }, + { + "m_Id": "2573b278f94f489baa02b6e4f8abf14e" + }, + { + "m_Id": "e177d7f1d3284a96a99e4967794fde8e" + }, + { + "m_Id": "69822902c84c428080db9893d32ee267" + }, + { + "m_Id": "c48b0bc83f544969b8903ab18833641f" + }, + { + "m_Id": "9203aadcc7e34fcbb60c753b4a4bd252" + }, + { + "m_Id": "f4c8ed6045604a808bfc1aa7cdbbd81a" + }, + { + "m_Id": "2a43d5b227114bb2b6f245cbdffd15e5" + }, + { + "m_Id": "92460f8b665b4a03bb23e7fe80bdff90" + }, + { + "m_Id": "959bbc37ca814b42be52d1bd1b64e66f" + }, + { + "m_Id": "be0b6de023f04f3c8f86fdf44da92670" + }, + { + "m_Id": "b5303edc98994295a7b3d47c8554f4eb" + }, + { + "m_Id": "9abeb9fdadd74574b4e6738541daa06a" + }, + { + "m_Id": "1ceaea2d8a314216847b3e129a914f2c" + }, + { + "m_Id": "a5dc0c9495c34a1cbc486e1eae20b24a" + }, + { + "m_Id": "281c2fab10a54a88ace70a99836fe852" + }, + { + "m_Id": "d487e51cc2ea47f7a3736b88a760f012" + }, + { + "m_Id": "5b5d90ab491f441884a78ece78c6e7a1" + }, + { + "m_Id": "09ca3df97218446e983a962c74cc98f4" + }, + { + "m_Id": "66179ca98b2a453b960048dd690efe80" + }, + { + "m_Id": "fd18b6af75854a368c145540f011523c" + }, + { + "m_Id": "41d505aa97584e2ca6e2f617918967fe" + }, + { + "m_Id": "3d60b782c9dd4e5494f6fc269bee5bfa" + }, + { + "m_Id": "cada9cea9620451d83525a727c0f7769" + }, + { + "m_Id": "fe3d443bbd14473a94a276dc64eb6dcb" + }, + { + "m_Id": "44bc17bcc71c4ae19156bb362cae14ae" + }, + { + "m_Id": "627a6231a44a450daea568ab3d65e599" + }, + { + "m_Id": "1a4e31eab9704113869dc9709d4c4539" + }, + { + "m_Id": "a6f6bb8f46874779a5286682c043e521" + }, + { + "m_Id": "3edf889a2311455d94539d91d4840ace" + }, + { + "m_Id": "30c679946250441ab393a854e7e04a57" + }, + { + "m_Id": "264f5393ca9048c48c034aa0c00fe754" + }, + { + "m_Id": "fbd8a56452444ca6aae3067d4c1a6f4e" + }, + { + "m_Id": "5e600846744441f691aacca6271d740a" + }, + { + "m_Id": "9c2a7707ea0049638b2b48ac9f03a14a" + }, + { + "m_Id": "b8dcd461a8b34ed6b2c77a51052430bb" + }, + { + "m_Id": "2a91b4210c2540408a5f7008c3a6ae59" + }, + { + "m_Id": "263ec88ed5b14e64b2f477156c8df843" + }, + { + "m_Id": "e4854a73e1f1473a9ad71dc1f45fb158" + }, + { + "m_Id": "aa34ae8be16d4885996fe17a972057f8" + }, + { + "m_Id": "e750faa0e3d44f9e9973ff8e08aa9dd9" + }, + { + "m_Id": "8360103f39bf4473b53bff12b89d4193" + }, + { + "m_Id": "53dba8790d2442ed8f1b1de382253a0e" + }, + { + "m_Id": "a07e525b0a0e425bb3348c1bded0c9b6" + }, + { + "m_Id": "d851bd5557a04ed4b753f5deab9ab7b3" + }, + { + "m_Id": "67bfdd4a87d54c4eb0e6fd97ea8bde3b" + }, + { + "m_Id": "f766681671b24953a25310189a3931a6" + }, + { + "m_Id": "4f74e65e559a414caef040647a6517ce" + }, + { + "m_Id": "08daa7a83f7b4889850c944add52dbb1" + }, + { + "m_Id": "953f2f4ce7334fa3b917c18a10d71bca" + }, + { + "m_Id": "b7d3ea63e79f48f3a8c42957ac61a8b5" + }, + { + "m_Id": "84f1f5cdd3724f5398e1a2c6b9bd0cd8" + }, + { + "m_Id": "4082d083d2a14f029ccf2324754b1d9c" + }, + { + "m_Id": "133fbe260a9a47af92f464ef0088253a" + }, + { + "m_Id": "ac3a80b81e024f529669ce414320f8b0" + }, + { + "m_Id": "b8dca6839b2546f4add1900701779c26" + }, + { + "m_Id": "07db0a29efc54042ade27bb8935d48a6" + }, + { + "m_Id": "2fb263a485e1422cb255f3f4b19781a7" + }, + { + "m_Id": "a75487134df7415f955b33cff9f98ab4" + }, + { + "m_Id": "2458b50b3a4a48f1a639ea1f301ae84b" + }, + { + "m_Id": "a702998ed7684a6695b2c1b063948449" + }, + { + "m_Id": "b8c774fc9cac433b99c4b9b826c29cfd" + }, + { + "m_Id": "9837f852dbc445ec90140a8c9089b97b" + }, + { + "m_Id": "31ebcab334ed4edb8643d897a0fe281b" + }, + { + "m_Id": "97ed7b3c251541af836cf9d87cf8d819" + }, + { + "m_Id": "2e9f729099a7471b905328ce4ab3d62d" + }, + { + "m_Id": "05825271cdd44659ac6f7b39697db616" + }, + { + "m_Id": "a65fd5b8249049cfa4978cb95f2906dd" + }, + { + "m_Id": "39abf23a0de14b4f9a35f8bda206a3f5" + }, + { + "m_Id": "7c140dfa3ad541778295a2628ecf3520" + }, + { + "m_Id": "9c9b0e360b6a4384991b11c8bd5d1b90" + }, + { + "m_Id": "1fbe2c60822445559fe2af3b7355397d" + }, + { + "m_Id": "d7abef3c272c480098cee3b4808d7d3f" + }, + { + "m_Id": "3f04ec4c0414483791e7e56388b25b1f" + }, + { + "m_Id": "5c71ced646a0493ea0562df9d7a1ec33" + }, + { + "m_Id": "6b1bfcb0a944448491e4361744eadcad" + }, + { + "m_Id": "e2ec96e135f9461382359ae7e3f6df33" + }, + { + "m_Id": "33989d390d0244088b0a2ac22e778165" + }, + { + "m_Id": "9e53b02950a74aaeac3b759695803b53" + }, + { + "m_Id": "6bd5468e24044965901c2f8235874ad4" + }, + { + "m_Id": "1c1675bdbec14ef98f5a45f8100d0b82" + }, + { + "m_Id": "752c6f7e5a64401783aef6ba46c5907f" + }, + { + "m_Id": "91850bdf7dcc4bf499f0b38e269d38f1" + }, + { + "m_Id": "4b8aae1832a34ca98002df9614e79836" + }, + { + "m_Id": "192263bfabbf44cfb1f9f99b834e186a" + }, + { + "m_Id": "32f21a4535e54ce48c097e51586c2235" + }, + { + "m_Id": "4d5d4124bf664f4d9af264e412e1b431" + }, + { + "m_Id": "d12453dda1c34b6f833d8eda4eaf2c27" + }, + { + "m_Id": "6829c94d9a2c4e83bf28f1f2c0c38d78" + }, + { + "m_Id": "3e9ea45a5cf94973bb74662f6dfa67d7" + }, + { + "m_Id": "c6f506199a9c4cdb882b3aebb87c4245" + }, + { + "m_Id": "d9fffa5b0642499e9cfb4904fa579915" + }, + { + "m_Id": "efb12c27a80d4b58b763e55ec9cda203" + }, + { + "m_Id": "ecee4b316f804aaabfb9ab9d90fe4712" + }, + { + "m_Id": "2e7b1b44474a40d6be90556281a77042" + }, + { + "m_Id": "e4feeb6b4fe6422c99a6d9f7204b3f77" + }, + { + "m_Id": "c8762bfc89e1476c9208f214d2cf9621" + }, + { + "m_Id": "1acd2114eeca41e1931e48aa19b1a1c8" + }, + { + "m_Id": "248c9a1da008405ba7595e996125bef3" + }, + { + "m_Id": "c46af3d4a47a4a879990007d0abb9155" + }, + { + "m_Id": "efab06ea88604aa284d3d113d48d4342" + }, + { + "m_Id": "352c5e7ba2f8421e9a1628d45c6167c1" + }, + { + "m_Id": "968eb1260de247a6ae11d93ffb62c370" + }, + { + "m_Id": "dbe8c88f1fed41489b58cb2c624b07f5" + }, + { + "m_Id": "d3318e127b3b43748fe6886e280d5ff7" + }, + { + "m_Id": "fa47195d70db452ab131f74751df00f8" + }, + { + "m_Id": "1284b21313e24c299fc3593aae4be71c" + }, + { + "m_Id": "b4402ce3ccf04a048863239aedbe87a8" + }, + { + "m_Id": "ef7077cb966f4e20aab711392aff03e5" + }, + { + "m_Id": "57155e8356c9460d9ba3eae891883065" + }, + { + "m_Id": "678c1a3aa5044ec5ba32ead9f37e83db" + }, + { + "m_Id": "92c4cda2a4a24f8eab60734f342fe4b7" + }, + { + "m_Id": "7197fa9eff284d16b2d3d70d424e637a" + }, + { + "m_Id": "726753be6bb047f896bf629f180df013" + }, + { + "m_Id": "2729e7307ce74d9f835081689bd089c3" + }, + { + "m_Id": "a5535127f7b24e0cb24732d098701601" + }, + { + "m_Id": "5829e6acf7d8498c8a97e0b64f4f7bed" + }, + { + "m_Id": "5b77a116b0324bf3a9ff4a6fbd7be00e" + }, + { + "m_Id": "b80337ac31e04b05a002e9f81ddbea8c" + }, + { + "m_Id": "8f8ca0a3b0dd4e448dbb945df2bfa639" + }, + { + "m_Id": "0903703114694cb880a37e61d972fe9a" + }, + { + "m_Id": "74c7f8c267824f2c8b0ca2fe1be022b7" + }, + { + "m_Id": "fb95eeb30d884d54b358cca7f6a99063" + }, + { + "m_Id": "dccc1e0050614b2398bfce4b52a305ca" + }, + { + "m_Id": "959ff1148b3349e48ee64a4e9b62185f" + }, + { + "m_Id": "e8a9cd81d6544753bf2cb708ed17484f" + }, + { + "m_Id": "91518443319044bc8e4fd05de7e2581b" + }, + { + "m_Id": "24f9c2c72d194b8b871004f37990ecb0" + }, + { + "m_Id": "338d630ac3c44089856d8e5240554ff8" + }, + { + "m_Id": "98b06805412b431fa26ce0a69aa10e25" + }, + { + "m_Id": "67af7fa748e34ea1b3e235d0cafc0af4" + }, + { + "m_Id": "e8b85c1ce5af4459860b542e1afc8d84" + }, + { + "m_Id": "d689efd5ae68433590c7ff751c0edd9f" + }, + { + "m_Id": "a493db744a314454a97fc48bf63029fa" + }, + { + "m_Id": "054d372238b9453397bdd30799bcae8c" + }, + { + "m_Id": "0514eb06c8e64135b177afb0301976e3" + }, + { + "m_Id": "e74d1c75dc2045d287c81ef5ddb0993e" + }, + { + "m_Id": "c234d329286d44ecb1b0b7d5805e8726" + }, + { + "m_Id": "15c4fec5ae0a40cfae514e94cf634394" + }, + { + "m_Id": "88099319861e4e23be99db174b2b7c9e" + }, + { + "m_Id": "01236fb612fe46b2b32f87bc2763fe1c" + }, + { + "m_Id": "a7ef162d13a2481c86a37f4989904269" + }, + { + "m_Id": "325fc7a821234c9ba300ca38df3ce945" + }, + { + "m_Id": "c87c14db1c69414da7ecf06ddd7254af" + }, + { + "m_Id": "107e6f3ae5554f7d9ba33015710bfb0f" + }, + { + "m_Id": "24ecf124b43a45489b00d17d1bdaec5a" + } + ], + "m_GroupDatas": [ + { + "m_Id": "063dd08ef7054b98834ef43a93ef035d" + }, + { + "m_Id": "9a9b9423c348490d8c6550520a46754b" + }, + { + "m_Id": "c39c85064c8b4914bb957db1b59e0e49" + }, + { + "m_Id": "ef85247de4c745dcbc6ddca88875b14d" + }, + { + "m_Id": "b9e0ebc6ab434f5786efec886c52a16c" + }, + { + "m_Id": "ab191acedb9b44b7b3bbc68b89055a73" + }, + { + "m_Id": "f9a36441a7674212a626b4e29ac4024e" + }, + { + "m_Id": "66c69fb10be74462b9dfdbda883bd934" + }, + { + "m_Id": "d2a14e6d2148432cb883f7e72b690cff" + }, + { + "m_Id": "7e0bc17feda14e9686f73d30823bef26" + }, + { + "m_Id": "f56aec43c38a433ca25a9aab19b2e18b" + }, + { + "m_Id": "dfa824146c2f43d5a5ea6bd8b9c3463a" + }, + { + "m_Id": "cb23790c1b9143928df829b7a26d1423" + }, + { + "m_Id": "5afd5b10bac94af98e61ab4df0f1d432" + }, + { + "m_Id": "3cd206490c954ca5a821100d4380764f" + }, + { + "m_Id": "da79511a40004c349d114e88532d1e86" + }, + { + "m_Id": "9077599ecffb44679d301bdc68b79f81" + } + ], + "m_StickyNoteDatas": [ + { + "m_Id": "aa6ca9dd588548b692498eb660b00833" + }, + { + "m_Id": "6f29e5b195f94b39825562b57958989a" + } + ], + "m_Edges": [ + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "01236fb612fe46b2b32f87bc2763fe1c" + }, + "m_SlotId": 1 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "325fc7a821234c9ba300ca38df3ce945" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "03f70d9a000b4f7486d44ca34a72624d" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "2573b278f94f489baa02b6e4f8abf14e" + }, + "m_SlotId": 1 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "0514eb06c8e64135b177afb0301976e3" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "6829c94d9a2c4e83bf28f1f2c0c38d78" + }, + "m_SlotId": 9 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "054d372238b9453397bdd30799bcae8c" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "6829c94d9a2c4e83bf28f1f2c0c38d78" + }, + "m_SlotId": 8 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "05825271cdd44659ac6f7b39697db616" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "a5535127f7b24e0cb24732d098701601" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "07db0a29efc54042ade27bb8935d48a6" + }, + "m_SlotId": 1 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "4082d083d2a14f029ccf2324754b1d9c" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "08daa7a83f7b4889850c944add52dbb1" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "53dba8790d2442ed8f1b1de382253a0e" + }, + "m_SlotId": 1 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "0903703114694cb880a37e61d972fe9a" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "5b77a116b0324bf3a9ff4a6fbd7be00e" + }, + "m_SlotId": 3 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "09ca3df97218446e983a962c74cc98f4" + }, + "m_SlotId": 5 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "fd18b6af75854a368c145540f011523c" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "09ca3df97218446e983a962c74cc98f4" + }, + "m_SlotId": 6 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "fe3d443bbd14473a94a276dc64eb6dcb" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "09ca3df97218446e983a962c74cc98f4" + }, + "m_SlotId": 7 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "07db0a29efc54042ade27bb8935d48a6" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "107e6f3ae5554f7d9ba33015710bfb0f" + }, + "m_SlotId": 1 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "c87c14db1c69414da7ecf06ddd7254af" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "1284b21313e24c299fc3593aae4be71c" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "2e7b1b44474a40d6be90556281a77042" + }, + "m_SlotId": 4 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "133fbe260a9a47af92f464ef0088253a" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "4082d083d2a14f029ccf2324754b1d9c" + }, + "m_SlotId": 1 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "15c4fec5ae0a40cfae514e94cf634394" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "88099319861e4e23be99db174b2b7c9e" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "192263bfabbf44cfb1f9f99b834e186a" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "4b8aae1832a34ca98002df9614e79836" + }, + "m_SlotId": 1 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "1a4e31eab9704113869dc9709d4c4539" + }, + "m_SlotId": 2 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "627a6231a44a450daea568ab3d65e599" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "1acd2114eeca41e1931e48aa19b1a1c8" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "e4feeb6b4fe6422c99a6d9f7204b3f77" + }, + "m_SlotId": 1 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "1c1675bdbec14ef98f5a45f8100d0b82" + }, + "m_SlotId": 2 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "6bd5468e24044965901c2f8235874ad4" + }, + "m_SlotId": 1 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "1ceaea2d8a314216847b3e129a914f2c" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "f4c8ed6045604a808bfc1aa7cdbbd81a" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "1fbe2c60822445559fe2af3b7355397d" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "d9fffa5b0642499e9cfb4904fa579915" + }, + "m_SlotId": 3 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "2458b50b3a4a48f1a639ea1f301ae84b" + }, + "m_SlotId": 1 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "2a91b4210c2540408a5f7008c3a6ae59" + }, + "m_SlotId": 2 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "248c9a1da008405ba7595e996125bef3" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "e4feeb6b4fe6422c99a6d9f7204b3f77" + }, + "m_SlotId": 2 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "24ecf124b43a45489b00d17d1bdaec5a" + }, + "m_SlotId": 1 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "8360103f39bf4473b53bff12b89d4193" + }, + "m_SlotId": 3 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "24f9c2c72d194b8b871004f37990ecb0" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "c6f506199a9c4cdb882b3aebb87c4245" + }, + "m_SlotId": 16 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "2573b278f94f489baa02b6e4f8abf14e" + }, + "m_SlotId": 4 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "84f1f5cdd3724f5398e1a2c6b9bd0cd8" + }, + "m_SlotId": 1 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "263ec88ed5b14e64b2f477156c8df843" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "e1e6ea93dab24d4086de0ce0507e9306" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "264f5393ca9048c48c034aa0c00fe754" + }, + "m_SlotId": 1 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "4f74e65e559a414caef040647a6517ce" + }, + "m_SlotId": 2 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "264f5393ca9048c48c034aa0c00fe754" + }, + "m_SlotId": 1 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "a07e525b0a0e425bb3348c1bded0c9b6" + }, + "m_SlotId": 1 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "2729e7307ce74d9f835081689bd089c3" + }, + "m_SlotId": 1 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "c6f506199a9c4cdb882b3aebb87c4245" + }, + "m_SlotId": 5 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "281c2fab10a54a88ace70a99836fe852" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "9abeb9fdadd74574b4e6738541daa06a" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "2a43d5b227114bb2b6f245cbdffd15e5" + }, + "m_SlotId": 3 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "281c2fab10a54a88ace70a99836fe852" + }, + "m_SlotId": 2 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "2a91b4210c2540408a5f7008c3a6ae59" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "8a7ae7a881424567bd38f733cff73869" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "2e7b1b44474a40d6be90556281a77042" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "92c4cda2a4a24f8eab60734f342fe4b7" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "2e9f729099a7471b905328ce4ab3d62d" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "39abf23a0de14b4f9a35f8bda206a3f5" + }, + "m_SlotId": 1 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "2fb263a485e1422cb255f3f4b19781a7" + }, + "m_SlotId": 2 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "a702998ed7684a6695b2c1b063948449" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "30c679946250441ab393a854e7e04a57" + }, + "m_SlotId": 1 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "a6f6bb8f46874779a5286682c043e521" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "31ebcab334ed4edb8643d897a0fe281b" + }, + "m_SlotId": 1 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "aa34ae8be16d4885996fe17a972057f8" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "325fc7a821234c9ba300ca38df3ce945" + }, + "m_SlotId": 1 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "84f1f5cdd3724f5398e1a2c6b9bd0cd8" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "32f21a4535e54ce48c097e51586c2235" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "c234d329286d44ecb1b0b7d5805e8726" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "338d630ac3c44089856d8e5240554ff8" + }, + "m_SlotId": 1 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "01236fb612fe46b2b32f87bc2763fe1c" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "33989d390d0244088b0a2ac22e778165" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "efb12c27a80d4b58b763e55ec9cda203" + }, + "m_SlotId": 3 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "352c5e7ba2f8421e9a1628d45c6167c1" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "c8762bfc89e1476c9208f214d2cf9621" + }, + "m_SlotId": 2 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "35d381f3a7994da39121a67ca007c2ed" + }, + "m_SlotId": 2 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "2fb263a485e1422cb255f3f4b19781a7" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "39abf23a0de14b4f9a35f8bda206a3f5" + }, + "m_SlotId": 4 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "a493db744a314454a97fc48bf63029fa" + }, + "m_SlotId": 1 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "39abf23a0de14b4f9a35f8bda206a3f5" + }, + "m_SlotId": 5 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "a493db744a314454a97fc48bf63029fa" + }, + "m_SlotId": 2 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "3d60b782c9dd4e5494f6fc269bee5bfa" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "41d505aa97584e2ca6e2f617918967fe" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "3e9ea45a5cf94973bb74662f6dfa67d7" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "107e6f3ae5554f7d9ba33015710bfb0f" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "3e9ea45a5cf94973bb74662f6dfa67d7" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "67af7fa748e34ea1b3e235d0cafc0af4" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "3e9ea45a5cf94973bb74662f6dfa67d7" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "98b06805412b431fa26ce0a69aa10e25" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "3e9ea45a5cf94973bb74662f6dfa67d7" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "d689efd5ae68433590c7ff751c0edd9f" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "3e9ea45a5cf94973bb74662f6dfa67d7" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "e8b85c1ce5af4459860b542e1afc8d84" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "3edf889a2311455d94539d91d4840ace" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "a6f6bb8f46874779a5286682c043e521" + }, + "m_SlotId": 1 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "3f04ec4c0414483791e7e56388b25b1f" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "ecee4b316f804aaabfb9ab9d90fe4712" + }, + "m_SlotId": 2 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "4082d083d2a14f029ccf2324754b1d9c" + }, + "m_SlotId": 2 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "41d505aa97584e2ca6e2f617918967fe" + }, + "m_SlotId": 2 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "41d505aa97584e2ca6e2f617918967fe" + }, + "m_SlotId": 3 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "1c1675bdbec14ef98f5a45f8100d0b82" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "41d505aa97584e2ca6e2f617918967fe" + }, + "m_SlotId": 3 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "6bd5468e24044965901c2f8235874ad4" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "44bc17bcc71c4ae19156bb362cae14ae" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "1a4e31eab9704113869dc9709d4c4539" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "4b8aae1832a34ca98002df9614e79836" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "6829c94d9a2c4e83bf28f1f2c0c38d78" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "4d5d4124bf664f4d9af264e412e1b431" + }, + "m_SlotId": 1 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "6a4b619cae09428e850340b327dc2247" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "4f74e65e559a414caef040647a6517ce" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "6b280d605cf34b63ae417129545c2f7d" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "53dba8790d2442ed8f1b1de382253a0e" + }, + "m_SlotId": 2 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "67bfdd4a87d54c4eb0e6fd97ea8bde3b" + }, + "m_SlotId": 1 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "57155e8356c9460d9ba3eae891883065" + }, + "m_SlotId": 1 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "c6f506199a9c4cdb882b3aebb87c4245" + }, + "m_SlotId": 10 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "57d17176266344f3bdf544fcd3993330" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "35d381f3a7994da39121a67ca007c2ed" + }, + "m_SlotId": 1 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "5829e6acf7d8498c8a97e0b64f4f7bed" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "5b77a116b0324bf3a9ff4a6fbd7be00e" + }, + "m_SlotId": 4 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "5b5d90ab491f441884a78ece78c6e7a1" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "d487e51cc2ea47f7a3736b88a760f012" + }, + "m_SlotId": 1 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "5b77a116b0324bf3a9ff4a6fbd7be00e" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "6829c94d9a2c4e83bf28f1f2c0c38d78" + }, + "m_SlotId": 5 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "5c71ced646a0493ea0562df9d7a1ec33" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "ecee4b316f804aaabfb9ab9d90fe4712" + }, + "m_SlotId": 1 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "5e600846744441f691aacca6271d740a" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "2458b50b3a4a48f1a639ea1f301ae84b" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "5e600846744441f691aacca6271d740a" + }, + "m_SlotId": 7 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "9837f852dbc445ec90140a8c9089b97b" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "627a6231a44a450daea568ab3d65e599" + }, + "m_SlotId": 1 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "8d0e91598db04dc39429e4727f60af22" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "66179ca98b2a453b960048dd690efe80" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "09ca3df97218446e983a962c74cc98f4" + }, + "m_SlotId": 1 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "678c1a3aa5044ec5ba32ead9f37e83db" + }, + "m_SlotId": 1 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "57155e8356c9460d9ba3eae891883065" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "67af7fa748e34ea1b3e235d0cafc0af4" + }, + "m_SlotId": 1 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "a65fd5b8249049cfa4978cb95f2906dd" + }, + "m_SlotId": 3 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "67bfdd4a87d54c4eb0e6fd97ea8bde3b" + }, + "m_SlotId": 2 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "f766681671b24953a25310189a3931a6" + }, + "m_SlotId": 1 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "6829c94d9a2c4e83bf28f1f2c0c38d78" + }, + "m_SlotId": 4 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "32f21a4535e54ce48c097e51586c2235" + }, + "m_SlotId": 2 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "6829c94d9a2c4e83bf28f1f2c0c38d78" + }, + "m_SlotId": 7 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "91518443319044bc8e4fd05de7e2581b" + }, + "m_SlotId": 2 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "69822902c84c428080db9893d32ee267" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "1ceaea2d8a314216847b3e129a914f2c" + }, + "m_SlotId": 1 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "6b1bfcb0a944448491e4361744eadcad" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "efb12c27a80d4b58b763e55ec9cda203" + }, + "m_SlotId": 1 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "6bd5468e24044965901c2f8235874ad4" + }, + "m_SlotId": 2 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "4d5d4124bf664f4d9af264e412e1b431" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "7197fa9eff284d16b2d3d70d424e637a" + }, + "m_SlotId": 1 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "b4402ce3ccf04a048863239aedbe87a8" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "726753be6bb047f896bf629f180df013" + }, + "m_SlotId": 1 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "c6f506199a9c4cdb882b3aebb87c4245" + }, + "m_SlotId": 6 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "74c7f8c267824f2c8b0ca2fe1be022b7" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "6829c94d9a2c4e83bf28f1f2c0c38d78" + }, + "m_SlotId": 6 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "752c6f7e5a64401783aef6ba46c5907f" + }, + "m_SlotId": 1 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "a7ef162d13a2481c86a37f4989904269" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "76c23cf23e734562b54dc8d34763eadf" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "e177d7f1d3284a96a99e4967794fde8e" + }, + "m_SlotId": 1 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "7c140dfa3ad541778295a2628ecf3520" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "d9fffa5b0642499e9cfb4904fa579915" + }, + "m_SlotId": 1 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "8360103f39bf4473b53bff12b89d4193" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "ac3a80b81e024f529669ce414320f8b0" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "847ac5df0b2d4dd58b05ed5100fd2d88" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "35d381f3a7994da39121a67ca007c2ed" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "847ac5df0b2d4dd58b05ed5100fd2d88" + }, + "m_SlotId": 7 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "31ebcab334ed4edb8643d897a0fe281b" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "84f1f5cdd3724f5398e1a2c6b9bd0cd8" + }, + "m_SlotId": 2 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "273f61f0afd2438d95da7144e127460e" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "88099319861e4e23be99db174b2b7c9e" + }, + "m_SlotId": 2 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "338d630ac3c44089856d8e5240554ff8" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "8f8ca0a3b0dd4e448dbb945df2bfa639" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "5b77a116b0324bf3a9ff4a6fbd7be00e" + }, + "m_SlotId": 2 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "91518443319044bc8e4fd05de7e2581b" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "88099319861e4e23be99db174b2b7c9e" + }, + "m_SlotId": 1 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "91850bdf7dcc4bf499f0b38e269d38f1" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "05825271cdd44659ac6f7b39697db616" + }, + "m_SlotId": 1 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "9203aadcc7e34fcbb60c753b4a4bd252" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "281c2fab10a54a88ace70a99836fe852" + }, + "m_SlotId": 1 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "92460f8b665b4a03bb23e7fe80bdff90" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "2a43d5b227114bb2b6f245cbdffd15e5" + }, + "m_SlotId": 1 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "92c4cda2a4a24f8eab60734f342fe4b7" + }, + "m_SlotId": 1 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "ef7077cb966f4e20aab711392aff03e5" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "953f2f4ce7334fa3b917c18a10d71bca" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "d851bd5557a04ed4b753f5deab9ab7b3" + }, + "m_SlotId": 1 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "959bbc37ca814b42be52d1bd1b64e66f" + }, + "m_SlotId": 2 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "bc0c9bafa3544deaaba658da5d1457a2" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "959ff1148b3349e48ee64a4e9b62185f" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "74c7f8c267824f2c8b0ca2fe1be022b7" + }, + "m_SlotId": 3 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "968eb1260de247a6ae11d93ffb62c370" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "c8762bfc89e1476c9208f214d2cf9621" + }, + "m_SlotId": 1 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "97ed7b3c251541af836cf9d87cf8d819" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "a65fd5b8249049cfa4978cb95f2906dd" + }, + "m_SlotId": 1 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "9837f852dbc445ec90140a8c9089b97b" + }, + "m_SlotId": 1 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "263ec88ed5b14e64b2f477156c8df843" + }, + "m_SlotId": 2 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "98b06805412b431fa26ce0a69aa10e25" + }, + "m_SlotId": 1 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "05825271cdd44659ac6f7b39697db616" + }, + "m_SlotId": 3 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "9abeb9fdadd74574b4e6738541daa06a" + }, + "m_SlotId": 2 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "959bbc37ca814b42be52d1bd1b64e66f" + }, + "m_SlotId": 1 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "9c2a7707ea0049638b2b48ac9f03a14a" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "b8dcd461a8b34ed6b2c77a51052430bb" + }, + "m_SlotId": 1 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "9c9b0e360b6a4384991b11c8bd5d1b90" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "d9fffa5b0642499e9cfb4904fa579915" + }, + "m_SlotId": 2 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "9e53b02950a74aaeac3b759695803b53" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "efb12c27a80d4b58b763e55ec9cda203" + }, + "m_SlotId": 4 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "a07e525b0a0e425bb3348c1bded0c9b6" + }, + "m_SlotId": 2 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "4f74e65e559a414caef040647a6517ce" + }, + "m_SlotId": 1 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "a493db744a314454a97fc48bf63029fa" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "726753be6bb047f896bf629f180df013" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "a5535127f7b24e0cb24732d098701601" + }, + "m_SlotId": 1 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "c6f506199a9c4cdb882b3aebb87c4245" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "a5dc0c9495c34a1cbc486e1eae20b24a" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "be0b6de023f04f3c8f86fdf44da92670" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "a65fd5b8249049cfa4978cb95f2906dd" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "2729e7307ce74d9f835081689bd089c3" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "a6f6bb8f46874779a5286682c043e521" + }, + "m_SlotId": 2 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "264f5393ca9048c48c034aa0c00fe754" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "a702998ed7684a6695b2c1b063948449" + }, + "m_SlotId": 1 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "2a91b4210c2540408a5f7008c3a6ae59" + }, + "m_SlotId": 1 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "a75487134df7415f955b33cff9f98ab4" + }, + "m_SlotId": 2 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "f766681671b24953a25310189a3931a6" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "a7ef162d13a2481c86a37f4989904269" + }, + "m_SlotId": 1 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "1c1675bdbec14ef98f5a45f8100d0b82" + }, + "m_SlotId": 1 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "aa34ae8be16d4885996fe17a972057f8" + }, + "m_SlotId": 1 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "b8c774fc9cac433b99c4b9b826c29cfd" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "ac3a80b81e024f529669ce414320f8b0" + }, + "m_SlotId": 3 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "b8dca6839b2546f4add1900701779c26" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "b4402ce3ccf04a048863239aedbe87a8" + }, + "m_SlotId": 1 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "c6f506199a9c4cdb882b3aebb87c4245" + }, + "m_SlotId": 12 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "b5303edc98994295a7b3d47c8554f4eb" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "be0b6de023f04f3c8f86fdf44da92670" + }, + "m_SlotId": 1 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "b7d3ea63e79f48f3a8c42957ac61a8b5" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "a75487134df7415f955b33cff9f98ab4" + }, + "m_SlotId": 1 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "b80337ac31e04b05a002e9f81ddbea8c" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "5b77a116b0324bf3a9ff4a6fbd7be00e" + }, + "m_SlotId": 1 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "b8c774fc9cac433b99c4b9b826c29cfd" + }, + "m_SlotId": 1 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "263ec88ed5b14e64b2f477156c8df843" + }, + "m_SlotId": 1 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "b8dca6839b2546f4add1900701779c26" + }, + "m_SlotId": 2 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "a75487134df7415f955b33cff9f98ab4" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "b8dca6839b2546f4add1900701779c26" + }, + "m_SlotId": 3 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "d851bd5557a04ed4b753f5deab9ab7b3" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "b8dca6839b2546f4add1900701779c26" + }, + "m_SlotId": 4 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "53dba8790d2442ed8f1b1de382253a0e" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "b8dcd461a8b34ed6b2c77a51052430bb" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "e4854a73e1f1473a9ad71dc1f45fb158" + }, + "m_SlotId": 2 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "be0b6de023f04f3c8f86fdf44da92670" + }, + "m_SlotId": 2 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "f4c8ed6045604a808bfc1aa7cdbbd81a" + }, + "m_SlotId": 1 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "c234d329286d44ecb1b0b7d5805e8726" + }, + "m_SlotId": 2 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "752c6f7e5a64401783aef6ba46c5907f" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "c46af3d4a47a4a879990007d0abb9155" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "e4feeb6b4fe6422c99a6d9f7204b3f77" + }, + "m_SlotId": 3 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "c48b0bc83f544969b8903ab18833641f" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "a5dc0c9495c34a1cbc486e1eae20b24a" + }, + "m_SlotId": 1 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "c6f506199a9c4cdb882b3aebb87c4245" + }, + "m_SlotId": 13 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "32f21a4535e54ce48c097e51586c2235" + }, + "m_SlotId": 1 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "c6f506199a9c4cdb882b3aebb87c4245" + }, + "m_SlotId": 14 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "91518443319044bc8e4fd05de7e2581b" + }, + "m_SlotId": 1 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "c8762bfc89e1476c9208f214d2cf9621" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "7197fa9eff284d16b2d3d70d424e637a" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "c87c14db1c69414da7ecf06ddd7254af" + }, + "m_SlotId": 1 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "24ecf124b43a45489b00d17d1bdaec5a" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "cada9cea9620451d83525a727c0f7769" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "41d505aa97584e2ca6e2f617918967fe" + }, + "m_SlotId": 1 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "d04a1ba74b404509b3874993b5771fe4" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "847ac5df0b2d4dd58b05ed5100fd2d88" + }, + "m_SlotId": 1 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "d0f639d2d1ac4285b4ee05ffd5db4009" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "35d381f3a7994da39121a67ca007c2ed" + }, + "m_SlotId": 3 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "d12453dda1c34b6f833d8eda4eaf2c27" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "c6f506199a9c4cdb882b3aebb87c4245" + }, + "m_SlotId": 15 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "d3318e127b3b43748fe6886e280d5ff7" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "2e7b1b44474a40d6be90556281a77042" + }, + "m_SlotId": 2 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "d487e51cc2ea47f7a3736b88a760f012" + }, + "m_SlotId": 2 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "9abeb9fdadd74574b4e6738541daa06a" + }, + "m_SlotId": 1 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "d689efd5ae68433590c7ff751c0edd9f" + }, + "m_SlotId": 1 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "4b8aae1832a34ca98002df9614e79836" + }, + "m_SlotId": 3 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "d7abef3c272c480098cee3b4808d7d3f" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "d9fffa5b0642499e9cfb4904fa579915" + }, + "m_SlotId": 4 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "d851bd5557a04ed4b753f5deab9ab7b3" + }, + "m_SlotId": 2 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "67bfdd4a87d54c4eb0e6fd97ea8bde3b" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "d9fffa5b0642499e9cfb4904fa579915" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "c6f506199a9c4cdb882b3aebb87c4245" + }, + "m_SlotId": 7 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "dbe8c88f1fed41489b58cb2c624b07f5" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "2e7b1b44474a40d6be90556281a77042" + }, + "m_SlotId": 1 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "dccc1e0050614b2398bfce4b52a305ca" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "74c7f8c267824f2c8b0ca2fe1be022b7" + }, + "m_SlotId": 2 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "e177d7f1d3284a96a99e4967794fde8e" + }, + "m_SlotId": 4 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "1a4e31eab9704113869dc9709d4c4539" + }, + "m_SlotId": 1 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "e222cb2bff344522873e60fba8643903" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "57d17176266344f3bdf544fcd3993330" + }, + "m_SlotId": 1 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "e2ec96e135f9461382359ae7e3f6df33" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "efb12c27a80d4b58b763e55ec9cda203" + }, + "m_SlotId": 2 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "e4854a73e1f1473a9ad71dc1f45fb158" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "959bbc37ca814b42be52d1bd1b64e66f" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "e4feeb6b4fe6422c99a6d9f7204b3f77" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "678c1a3aa5044ec5ba32ead9f37e83db" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "e74d1c75dc2045d287c81ef5ddb0993e" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "c234d329286d44ecb1b0b7d5805e8726" + }, + "m_SlotId": 1 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "e750faa0e3d44f9e9973ff8e08aa9dd9" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "8360103f39bf4473b53bff12b89d4193" + }, + "m_SlotId": 1 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "e8a9cd81d6544753bf2cb708ed17484f" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "74c7f8c267824f2c8b0ca2fe1be022b7" + }, + "m_SlotId": 4 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "e8b85c1ce5af4459860b542e1afc8d84" + }, + "m_SlotId": 1 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "39abf23a0de14b4f9a35f8bda206a3f5" + }, + "m_SlotId": 3 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "ecee4b316f804aaabfb9ab9d90fe4712" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "c6f506199a9c4cdb882b3aebb87c4245" + }, + "m_SlotId": 9 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "ef7077cb966f4e20aab711392aff03e5" + }, + "m_SlotId": 1 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "c6f506199a9c4cdb882b3aebb87c4245" + }, + "m_SlotId": 11 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "efab06ea88604aa284d3d113d48d4342" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "e4feeb6b4fe6422c99a6d9f7204b3f77" + }, + "m_SlotId": 4 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "efb12c27a80d4b58b763e55ec9cda203" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "c6f506199a9c4cdb882b3aebb87c4245" + }, + "m_SlotId": 8 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "f4c8ed6045604a808bfc1aa7cdbbd81a" + }, + "m_SlotId": 2 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "e4854a73e1f1473a9ad71dc1f45fb158" + }, + "m_SlotId": 1 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "f766681671b24953a25310189a3931a6" + }, + "m_SlotId": 2 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "2fb263a485e1422cb255f3f4b19781a7" + }, + "m_SlotId": 1 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "f766681671b24953a25310189a3931a6" + }, + "m_SlotId": 2 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "a07e525b0a0e425bb3348c1bded0c9b6" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "fa47195d70db452ab131f74751df00f8" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "2e7b1b44474a40d6be90556281a77042" + }, + "m_SlotId": 3 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "fb95eeb30d884d54b358cca7f6a99063" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "74c7f8c267824f2c8b0ca2fe1be022b7" + }, + "m_SlotId": 1 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "fbd8a56452444ca6aae3067d4c1a6f4e" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "5e600846744441f691aacca6271d740a" + }, + "m_SlotId": 1 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "fd18b6af75854a368c145540f011523c" + }, + "m_SlotId": 1 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "30c679946250441ab393a854e7e04a57" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "fe3d443bbd14473a94a276dc64eb6dcb" + }, + "m_SlotId": 1 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "d487e51cc2ea47f7a3736b88a760f012" + }, + "m_SlotId": 0 + } + } + ], + "m_VertexContext": { + "m_Position": { + "x": 583.0001220703125, + "y": -137.00001525878907 + }, + "m_Blocks": [ + { + "m_Id": "4b45669a84054c498babd493511b3189" + }, + { + "m_Id": "0153caa15e554a9bb37fea4238ebdc5b" + }, + { + "m_Id": "00ab9614abb14bfea39934b2abff144b" + } + ] + }, + "m_FragmentContext": { + "m_Position": { + "x": 583.0001220703125, + "y": 174.00006103515626 + }, + "m_Blocks": [ + { + "m_Id": "8a7ae7a881424567bd38f733cff73869" + }, + { + "m_Id": "e1e6ea93dab24d4086de0ce0507e9306" + }, + { + "m_Id": "6b280d605cf34b63ae417129545c2f7d" + }, + { + "m_Id": "08c1176d7dfe406bb0f6283ca763d553" + }, + { + "m_Id": "fce699c8ebf3428887ef6a715d55d4f9" + }, + { + "m_Id": "e701720035d44304a33f4b64350fc6e3" + }, + { + "m_Id": "273f61f0afd2438d95da7144e127460e" + }, + { + "m_Id": "8d0e91598db04dc39429e4727f60af22" + }, + { + "m_Id": "6a4b619cae09428e850340b327dc2247" + }, + { + "m_Id": "bc0c9bafa3544deaaba658da5d1457a2" + } + ] + }, + "m_PreviewData": { + "serializedMesh": { + "m_SerializedMesh": "{\"mesh\":{\"instanceID\":0}}", + "m_Guid": "" + } + }, + "m_Path": "Shader Graphs", + "m_ConcretePrecision": 0, + "m_PreviewMode": 2, + "m_OutputNode": { + "m_Id": "" + }, + "m_ActiveTargets": [ + { + "m_Id": "0083909e70ac4601afc22e423a6e3d2e" + } + ] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.Rendering.HighDefinition.ShaderGraph.HDTarget", + "m_ObjectId": "0083909e70ac4601afc22e423a6e3d2e", + "m_ActiveSubTarget": { + "m_Id": "650ef699f8534d05b11661f3db2c1e50" + }, + "m_Datas": [ + { + "m_Id": "b00f1b66025c4b25a6f709e3c0ab54f4" + }, + { + "m_Id": "88f0b3d71738482fb6273b754134b4dd" + }, + { + "m_Id": "2a2960edadd1494c8e81b3d852cb3297" + }, + { + "m_Id": "5e856e0c3b704d14a6c36b84bf8d78f6" + } + ], + "m_CustomEditorGUI": "" +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.BlockNode", + "m_ObjectId": "00ab9614abb14bfea39934b2abff144b", + "m_Group": { + "m_Id": "" + }, + "m_Name": "VertexDescription.Tangent", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": 0.0, + "y": 0.0, + "width": 0.0, + "height": 0.0 + } + }, + "m_Slots": [ + { + "m_Id": "c996e165d42c4929928bc49c5e17d734" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_SerializedDescriptor": "VertexDescription.Tangent" +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "00fc4f6ddbc44cffb8cf67dc13aa9e7c", + "m_Id": 2, + "m_DisplayName": "Y", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "Y", + "m_StageCapability": 3, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [ + "Y" + ] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.RedirectNodeData", + "m_ObjectId": "01236fb612fe46b2b32f87bc2763fe1c", + "m_Group": { + "m_Id": "7e0bc17feda14e9686f73d30823bef26" + }, + "m_Name": "Redirect Node", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -910.0, + "y": 340.0, + "width": 55.999996185302737, + "height": 24.0 + } + }, + "m_Slots": [ + { + "m_Id": "da3d5a689e494e92801f395f3085490f" + }, + { + "m_Id": "0ee666fc4145421c9bf23c75383d199e" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.BlockNode", + "m_ObjectId": "0153caa15e554a9bb37fea4238ebdc5b", + "m_Group": { + "m_Id": "" + }, + "m_Name": "VertexDescription.Normal", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": 0.0, + "y": 0.0, + "width": 0.0, + "height": 0.0 + } + }, + "m_Slots": [ + { + "m_Id": "3b9bea9727174fc0b9e705617c9903db" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_SerializedDescriptor": "VertexDescription.Normal" +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.UVMaterialSlot", + "m_ObjectId": "01a8f5bfdcbf49b89b73d8e8596d4a96", + "m_Id": 2, + "m_DisplayName": "UV", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "UV", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0 + }, + "m_Labels": [], + "m_Channel": 0 +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "01ed385bc89446c5b327cacc69bcce37", + "m_Id": 6, + "m_DisplayName": "B", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "B", + "m_StageCapability": 2, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Internal.Texture2DShaderProperty", + "m_ObjectId": "028c7c4762f843e5818661e89e339595", + "m_Guid": { + "m_GuidSerialized": "fe28c848-a268-4f7b-88d8-5706f970fabb" + }, + "m_Name": "Occlusion Map", + "m_DefaultReferenceName": "", + "m_OverrideReferenceName": "_AOMap", + "m_GeneratePropertyBlock": true, + "m_Precision": 0, + "overrideHLSLDeclaration": false, + "hlslDeclarationOverride": 0, + "m_Hidden": false, + "m_Value": { + "m_SerializedTexture": "{\"texture\":{\"instanceID\":0}}", + "m_Guid": "" + }, + "m_Modifiable": true, + "m_DefaultType": 0 +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.UVMaterialSlot", + "m_ObjectId": "02e510ee2ef34b6aa52e075af163f348", + "m_Id": 2, + "m_DisplayName": "UV", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "UV", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0 + }, + "m_Labels": [], + "m_Channel": 0 +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicValueMaterialSlot", + "m_ObjectId": "0337e07f559541ec96585a6182657f0a", + "m_Id": 0, + "m_DisplayName": "A", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "A", + "m_StageCapability": 3, + "m_Value": { + "e00": 0.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 0.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 0.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 0.0 + }, + "m_DefaultValue": { + "e00": 1.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 1.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 1.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.SamplerStateMaterialSlot", + "m_ObjectId": "03e431f2cc564c7d824423b1da73db58", + "m_Id": 3, + "m_DisplayName": "Sampler", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "Sampler", + "m_StageCapability": 3, + "m_BareResource": false +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.PropertyNode", + "m_ObjectId": "03f70d9a000b4f7486d44ca34a72624d", + "m_Group": { + "m_Id": "7e0bc17feda14e9686f73d30823bef26" + }, + "m_Name": "Property", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -1808.9998779296875, + "y": 379.9999694824219, + "width": 169.0, + "height": 34.0 + } + }, + "m_Slots": [ + { + "m_Id": "84a278ec2cbb499fa6157d16923afda1" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_Property": { + "m_Id": "40ad0182bb1c42b9b661c6e1e59e3b8e" + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicValueMaterialSlot", + "m_ObjectId": "048cb4a590ce4968b7b917a490150ec5", + "m_Id": 0, + "m_DisplayName": "A", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "A", + "m_StageCapability": 3, + "m_Value": { + "e00": 0.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 0.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 0.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 0.0 + }, + "m_DefaultValue": { + "e00": 1.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 1.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 1.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.SamplerStateMaterialSlot", + "m_ObjectId": "04bc5aa9cb144da6ba346c5a217bce7c", + "m_Id": 1, + "m_DisplayName": "", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "", + "m_StageCapability": 3, + "m_BareResource": false +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "04fe9d14c348421c843b990188e29c0b", + "m_Id": 0, + "m_DisplayName": "", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.PropertyNode", + "m_ObjectId": "0514eb06c8e64135b177afb0301976e3", + "m_Group": { + "m_Id": "cb23790c1b9143928df829b7a26d1423" + }, + "m_Name": "Property", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -5033.0, + "y": 1594.0, + "width": 202.0, + "height": 34.0 + } + }, + "m_Slots": [ + { + "m_Id": "fb85edc4ce8e4362a1d1e12547d260cb" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_Property": { + "m_Id": "a0dea5230a33428cb6bffe7ab816e628" + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.PropertyNode", + "m_ObjectId": "054d372238b9453397bdd30799bcae8c", + "m_Group": { + "m_Id": "cb23790c1b9143928df829b7a26d1423" + }, + "m_Name": "Property", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -5058.0, + "y": 1560.0, + "width": 227.00001525878907, + "height": 34.0 + } + }, + "m_Slots": [ + { + "m_Id": "e989b91cd55343fd98fda6e8bf964491" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_Property": { + "m_Id": "1b299f10f9db46719d10fb61b53094c1" + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Texture2DInputMaterialSlot", + "m_ObjectId": "0559f5b0e7274ee09cdcddde77d06b3d", + "m_Id": 1, + "m_DisplayName": "Texture", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "Texture", + "m_StageCapability": 3, + "m_BareResource": false, + "m_Texture": { + "m_SerializedTexture": "{\"texture\":{\"instanceID\":0}}", + "m_Guid": "" + }, + "m_DefaultType": 0 +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Internal.Texture2DShaderProperty", + "m_ObjectId": "056e224982a4418783cc9a754ebd4920", + "m_Guid": { + "m_GuidSerialized": "b66fda54-ec55-4ec2-8f9e-c6601e0efbc3" + }, + "m_Name": "CFULC Mask", + "m_DefaultReferenceName": "", + "m_OverrideReferenceName": "_CFULCMask", + "m_GeneratePropertyBlock": true, + "m_Precision": 0, + "overrideHLSLDeclaration": false, + "hlslDeclarationOverride": 0, + "m_Hidden": false, + "m_Value": { + "m_SerializedTexture": "{\"texture\":{\"instanceID\":0}}", + "m_Guid": "" + }, + "m_Modifiable": true, + "m_DefaultType": 1 +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.SampleTexture2DNode", + "m_ObjectId": "05825271cdd44659ac6f7b39697db616", + "m_Group": { + "m_Id": "dfa824146c2f43d5a5ea6bd8b9c3463a" + }, + "m_Name": "Sample Texture 2D", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -5220.0, + "y": -402.0, + "width": 184.0, + "height": 252.99998474121095 + } + }, + "m_Slots": [ + { + "m_Id": "4b88b55388ef4664baf654b1bed1e87f" + }, + { + "m_Id": "358c191e589441cb9ab0497275a6866f" + }, + { + "m_Id": "c0d2e3f5038b4df2ab225ad3103ca3fe" + }, + { + "m_Id": "0b404c564fc6464ebee5bdda608c385d" + }, + { + "m_Id": "1889829402464bd2a7640dd5e6f60b3b" + }, + { + "m_Id": "4686d5fe337b46f28a9b367786c7087b" + }, + { + "m_Id": "44ea5acfb2d4456ea052aa45beb63793" + }, + { + "m_Id": "fb80921dc3724b67876bf7f60fff4662" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_TextureType": 0, + "m_NormalMapSpace": 0 +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicValueMaterialSlot", + "m_ObjectId": "05a08ecd924a44bba69d2b0cef175cec", + "m_Id": 1, + "m_DisplayName": "B", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "B", + "m_StageCapability": 3, + "m_Value": { + "e00": 2.0, + "e01": 2.0, + "e02": 2.0, + "e03": 2.0, + "e10": 2.0, + "e11": 2.0, + "e12": 2.0, + "e13": 2.0, + "e20": 2.0, + "e21": 2.0, + "e22": 2.0, + "e23": 2.0, + "e30": 2.0, + "e31": 2.0, + "e32": 2.0, + "e33": 2.0 + }, + "m_DefaultValue": { + "e00": 1.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 1.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 1.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "05efbcd28970432bab2f0280997fc441", + "m_Id": 7, + "m_DisplayName": "A", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "A", + "m_StageCapability": 2, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "060fd61d7b8a48d19e884b7fcfa36d56", + "m_Id": 2, + "m_DisplayName": "Y", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "Y", + "m_StageCapability": 3, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [ + "Y" + ] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.GroupData", + "m_ObjectId": "063dd08ef7054b98834ef43a93ef035d", + "m_Title": "Head Color Blend", + "m_Position": { + "x": -2073.0, + "y": -1729.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.UVMaterialSlot", + "m_ObjectId": "0647cd09207e46a99623889e73580759", + "m_Id": 2, + "m_DisplayName": "UV", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "UV", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0 + }, + "m_Labels": [], + "m_Channel": 0 +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.SaturateNode", + "m_ObjectId": "07db0a29efc54042ade27bb8935d48a6", + "m_Group": { + "m_Id": "f56aec43c38a433ca25a9aab19b2e18b" + }, + "m_Name": "Saturate", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -1768.0, + "y": 1118.0, + "width": 128.0, + "height": 94.0 + } + }, + "m_Slots": [ + { + "m_Id": "238aff0108304d08bc76c1f13198d281" + }, + { + "m_Id": "784dfbda34cb491aa18d22a388dac528" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.BlockNode", + "m_ObjectId": "08c1176d7dfe406bb0f6283ca763d553", + "m_Group": { + "m_Id": "" + }, + "m_Name": "SurfaceDescription.BentNormal", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": 0.0, + "y": 0.0, + "width": 0.0, + "height": 0.0 + } + }, + "m_Slots": [ + { + "m_Id": "c4b6c46dc8b348b8a5ecd4e2aead24c0" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_SerializedDescriptor": "SurfaceDescription.BentNormal" +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.PropertyNode", + "m_ObjectId": "08daa7a83f7b4889850c944add52dbb1", + "m_Group": { + "m_Id": "66c69fb10be74462b9dfdbda883bd934" + }, + "m_Name": "Property", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -2351.0, + "y": -110.00004577636719, + "width": 152.0, + "height": 34.0 + } + }, + "m_Slots": [ + { + "m_Id": "cf1f15de83894e24b940127ff7098e7e" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_Property": { + "m_Id": "5172aa37e7034721a702d02156b0c3a6" + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "08ea3079bc4b42ce96fe727e667b8e72", + "m_Id": 4, + "m_DisplayName": "R", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "R", + "m_StageCapability": 2, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.PropertyNode", + "m_ObjectId": "0903703114694cb880a37e61d972fe9a", + "m_Group": { + "m_Id": "cb23790c1b9143928df829b7a26d1423" + }, + "m_Name": "Property", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -5262.0, + "y": 1313.0, + "width": 234.00001525878907, + "height": 34.0 + } + }, + "m_Slots": [ + { + "m_Id": "5f285cf6e93d448cb5c6ea67e742007d" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_Property": { + "m_Id": "0f24de491c834c9e804aa21dd58f65af" + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector3MaterialSlot", + "m_ObjectId": "09847344f8004a26bdad187ff3b528cd", + "m_Id": 1, + "m_DisplayName": "B", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "B", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 1.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0 + }, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.SampleTexture2DNode", + "m_ObjectId": "09ca3df97218446e983a962c74cc98f4", + "m_Group": { + "m_Id": "3cd206490c954ca5a821100d4380764f" + }, + "m_Name": "Sample Texture 2D", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -2935.999755859375, + "y": 744.0001220703125, + "width": 184.0, + "height": 253.0 + } + }, + "m_Slots": [ + { + "m_Id": "ee20fbde14b8401da12d7aa5225b7517" + }, + { + "m_Id": "cc95f826c4ae496383d43b50bf0a0757" + }, + { + "m_Id": "4e8603f0303e4fccad59b551b5bec709" + }, + { + "m_Id": "39cab34d69114123b38ed04b3bb55c23" + }, + { + "m_Id": "6e188f2f78af432dbb36b20ec758c9dc" + }, + { + "m_Id": "413e9c5250a640a5bc2df5e6d4676ff8" + }, + { + "m_Id": "93c9fb5ea5864c6eaae0cda4f420ff84" + }, + { + "m_Id": "d03b89c54bcd458089f04ed4c0afe8bc" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_TextureType": 0, + "m_NormalMapSpace": 0 +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector3MaterialSlot", + "m_ObjectId": "09e79952160e4143bfc0aebcff87ce18", + "m_Id": 1, + "m_DisplayName": "B", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "B", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 1.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0 + }, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.SamplerStateMaterialSlot", + "m_ObjectId": "0a097787cd474a819a023f25002203f6", + "m_Id": 1, + "m_DisplayName": "", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "", + "m_StageCapability": 3, + "m_BareResource": false +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "0a38a26b7f6443e5a17e47c0484ef2a3", + "m_Id": 1, + "m_DisplayName": "B", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "B", + "m_StageCapability": 3, + "m_Value": { + "x": 2.5, + "y": 2.0, + "z": 2.0, + "w": 2.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "0b404c564fc6464ebee5bdda608c385d", + "m_Id": 6, + "m_DisplayName": "B", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "B", + "m_StageCapability": 2, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 1, + "m_Type": "UnityEditor.ShaderGraph.Internal.Vector1ShaderProperty", + "m_ObjectId": "0cae67e06abe458f8f01660cbb4221de", + "m_Guid": { + "m_GuidSerialized": "b79804d9-7a81-47d1-9a94-5379869e972c" + }, + "m_Name": "Upper Lip Scatter Scale", + "m_DefaultReferenceName": "", + "m_OverrideReferenceName": "_UpperLipScatterScale", + "m_GeneratePropertyBlock": true, + "m_Precision": 0, + "overrideHLSLDeclaration": false, + "hlslDeclarationOverride": 0, + "m_Hidden": false, + "m_Value": 1.0, + "m_FloatType": 1, + "m_RangeValues": { + "x": 0.0, + "y": 2.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "0d28e9b96829486b9a93fb4b4493ec53", + "m_Id": 0, + "m_DisplayName": "Smoothness", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "Smoothness", + "m_StageCapability": 2, + "m_Value": 0.5, + "m_DefaultValue": 0.5, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.NormalMaterialSlot", + "m_ObjectId": "0e03c873ccc040dd8417724de5eaf36d", + "m_Id": 0, + "m_DisplayName": "Normal (Tangent Space)", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "NormalTS", + "m_StageCapability": 2, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0 + }, + "m_Labels": [], + "m_Space": 3 +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "0e7df1d9c08e4ef9b64a1bd18349ce81", + "m_Id": 4, + "m_DisplayName": "W", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "W", + "m_StageCapability": 3, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [ + "W" + ] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "0ed7d1df69484eb7bc57fa367591d14b", + "m_Id": 0, + "m_DisplayName": "Inner Lid/A Scatter Scale", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "0ed9acaed6d8417fad8b86edf7faf7b5", + "m_Id": 0, + "m_DisplayName": "In", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "In", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "0ee666fc4145421c9bf23c75383d199e", + "m_Id": 1, + "m_DisplayName": "", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 1, + "m_Type": "UnityEditor.ShaderGraph.Internal.Vector1ShaderProperty", + "m_ObjectId": "0f24de491c834c9e804aa21dd58f65af", + "m_Guid": { + "m_GuidSerialized": "d4acc844-d4cb-4a78-a48f-4e786abe1516" + }, + "m_Name": "Upper Lid/B Smoothness Mod", + "m_DefaultReferenceName": "", + "m_OverrideReferenceName": "_BSmoothnessMod", + "m_GeneratePropertyBlock": true, + "m_Precision": 0, + "overrideHLSLDeclaration": false, + "hlslDeclarationOverride": 0, + "m_Hidden": false, + "m_Value": 0.0, + "m_FloatType": 1, + "m_RangeValues": { + "x": -1.5, + "y": 1.5 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicValueMaterialSlot", + "m_ObjectId": "0f68c661ee204af89506956f32be13cb", + "m_Id": 1, + "m_DisplayName": "B", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "B", + "m_StageCapability": 3, + "m_Value": { + "e00": 2.0, + "e01": 2.0, + "e02": 2.0, + "e03": 2.0, + "e10": 2.0, + "e11": 2.0, + "e12": 2.0, + "e13": 2.0, + "e20": 2.0, + "e21": 2.0, + "e22": 2.0, + "e23": 2.0, + "e30": 2.0, + "e31": 2.0, + "e32": 2.0, + "e33": 2.0 + }, + "m_DefaultValue": { + "e00": 1.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 1.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 1.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicValueMaterialSlot", + "m_ObjectId": "0ff7e0cbcc4147afa6a5e57e00dcc27e", + "m_Id": 1, + "m_DisplayName": "B", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "B", + "m_StageCapability": 3, + "m_Value": { + "e00": 2.0, + "e01": 2.0, + "e02": 2.0, + "e03": 2.0, + "e10": 2.0, + "e11": 2.0, + "e12": 2.0, + "e13": 2.0, + "e20": 2.0, + "e21": 2.0, + "e22": 2.0, + "e23": 2.0, + "e30": 2.0, + "e31": 2.0, + "e32": 2.0, + "e33": 2.0 + }, + "m_DefaultValue": { + "e00": 1.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 1.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 1.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.RedirectNodeData", + "m_ObjectId": "107e6f3ae5554f7d9ba33015710bfb0f", + "m_Group": { + "m_Id": "" + }, + "m_Name": "Redirect Node", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -5442.0, + "y": -537.9999389648438, + "width": 56.0, + "height": 24.0 + } + }, + "m_Slots": [ + { + "m_Id": "d88def6869fc49d3bc653b65a14f4035" + }, + { + "m_Id": "886088b6c7a14bd8903dcc64845691de" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "1090fc812c164ffa8276b79e749d6d1a", + "m_Id": 0, + "m_DisplayName": "Chin Scatter Scale", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Internal.Texture2DShaderProperty", + "m_ObjectId": "11d663a4721749668b26f021655222e3", + "m_Guid": { + "m_GuidSerialized": "2f169b8d-56f7-40ec-bbe0-cccbf9fbd1c2" + }, + "m_Name": "Ear Neck Mask", + "m_DefaultReferenceName": "", + "m_OverrideReferenceName": "_EarNeckMask", + "m_GeneratePropertyBlock": true, + "m_Precision": 0, + "overrideHLSLDeclaration": false, + "hlslDeclarationOverride": 0, + "m_Hidden": false, + "m_Value": { + "m_SerializedTexture": "{\"texture\":{\"instanceID\":0}}", + "m_Guid": "" + }, + "m_Modifiable": true, + "m_DefaultType": 1 +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "1215ed0b592e4af4b86adbf923212768", + "m_Id": 1, + "m_DisplayName": "X", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "X", + "m_StageCapability": 3, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.PropertyNode", + "m_ObjectId": "1284b21313e24c299fc3593aae4be71c", + "m_Group": { + "m_Id": "dfa824146c2f43d5a5ea6bd8b9c3463a" + }, + "m_Name": "Property", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -5404.0, + "y": 647.0, + "width": 171.0, + "height": 34.0 + } + }, + "m_Slots": [ + { + "m_Id": "1090fc812c164ffa8276b79e749d6d1a" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_Property": { + "m_Id": "3a7a76a7000244e4b3de2b879f66a390" + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector4MaterialSlot", + "m_ObjectId": "12e263ae9342430fbd23ddd2c8f51ea8", + "m_Id": 5, + "m_DisplayName": "Mod1", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "Mod1", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.PropertyNode", + "m_ObjectId": "133fbe260a9a47af92f464ef0088253a", + "m_Group": { + "m_Id": "f56aec43c38a433ca25a9aab19b2e18b" + }, + "m_Name": "Property", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -1818.0, + "y": 1219.0, + "width": 178.00001525878907, + "height": 34.0 + } + }, + "m_Slots": [ + { + "m_Id": "30fa119b4c8e49d69305bb791bfee0ef" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_Property": { + "m_Id": "833ac99096aa4e25ac67e1440763f977" + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Texture2DInputMaterialSlot", + "m_ObjectId": "144e3366a62e4ce39bb941e6eef5bbe6", + "m_Id": 1, + "m_DisplayName": "Texture", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "Texture", + "m_StageCapability": 3, + "m_BareResource": false, + "m_Texture": { + "m_SerializedTexture": "{\"texture\":{\"instanceID\":0}}", + "m_Guid": "" + }, + "m_DefaultType": 0 +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "14691abbdb8c44868b2fbf943456a214", + "m_Id": 4, + "m_DisplayName": "R", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "R", + "m_StageCapability": 2, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.PropertyNode", + "m_ObjectId": "15c4fec5ae0a40cfae514e94cf634394", + "m_Group": { + "m_Id": "5afd5b10bac94af98e61ab4df0f1d432" + }, + "m_Name": "Property", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -3769.0, + "y": 246.99998474121095, + "width": 165.0, + "height": 34.0 + } + }, + "m_Slots": [ + { + "m_Id": "36cf58cdc6114de09fa380c277e06693" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_Property": { + "m_Id": "a6dd3195bd6d4a298423e889b02d7c82" + } +} + +{ + "m_SGVersion": 1, + "m_Type": "UnityEditor.ShaderGraph.Internal.Vector1ShaderProperty", + "m_ObjectId": "167f8d77ee5e478ab5c3c33cb26ad3c0", + "m_Guid": { + "m_GuidSerialized": "127069c4-4651-454d-be83-1fd921a8f943" + }, + "m_Name": "Ear Smoothness Mod", + "m_DefaultReferenceName": "", + "m_OverrideReferenceName": "_EarSmoothnessMod", + "m_GeneratePropertyBlock": true, + "m_Precision": 0, + "overrideHLSLDeclaration": false, + "hlslDeclarationOverride": 0, + "m_Hidden": false, + "m_Value": 0.0, + "m_FloatType": 1, + "m_RangeValues": { + "x": -1.5, + "y": 1.5 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "16a964c42caa4ca3afed97077c6b7bbe", + "m_Id": 0, + "m_DisplayName": "", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector4MaterialSlot", + "m_ObjectId": "186cb51092954fe39e95085fa462302e", + "m_Id": 0, + "m_DisplayName": "RGBA", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "RGBA", + "m_StageCapability": 2, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "1889829402464bd2a7640dd5e6f60b3b", + "m_Id": 7, + "m_DisplayName": "A", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "A", + "m_StageCapability": 2, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 1, + "m_Type": "UnityEditor.ShaderGraph.Internal.Vector1ShaderProperty", + "m_ObjectId": "18e7067ff74c497eb92e133c7111aef2", + "m_Guid": { + "m_GuidSerialized": "e225779f-b080-4c10-9dae-3e0f398e205b" + }, + "m_Name": "Micro Smoothness Mod", + "m_DefaultReferenceName": "Vector1_18e7067ff74c497eb92e133c7111aef2", + "m_OverrideReferenceName": "_MicroSmoothnessMod", + "m_GeneratePropertyBlock": true, + "m_Precision": 0, + "overrideHLSLDeclaration": false, + "hlslDeclarationOverride": 0, + "m_Hidden": false, + "m_Value": 0.0, + "m_FloatType": 1, + "m_RangeValues": { + "x": -1.5, + "y": 1.5 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "191e915f49e24dfcace38066cf12bd48", + "m_Id": 2, + "m_DisplayName": "Out", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "192012161b4245a7b5d79fc52657b74d", + "m_Id": 0, + "m_DisplayName": "Chin Smoothness Mod", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.PropertyNode", + "m_ObjectId": "192263bfabbf44cfb1f9f99b834e186a", + "m_Group": { + "m_Id": "cb23790c1b9143928df829b7a26d1423" + }, + "m_Name": "Property", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -5212.0, + "y": 991.9999389648438, + "width": 184.0, + "height": 34.0 + } + }, + "m_Slots": [ + { + "m_Id": "b749ee7701af45a69020770d171d1a51" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_Property": { + "m_Id": "500ba94d31a4430589839a4ee489195e" + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "1a09dbf5f5cf4dac8496ffcb3a3088ab", + "m_Id": 1, + "m_DisplayName": "", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.MultiplyNode", + "m_ObjectId": "1a4e31eab9704113869dc9709d4c4539", + "m_Group": { + "m_Id": "7e0bc17feda14e9686f73d30823bef26" + }, + "m_Name": "Multiply", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -1151.0001220703125, + "y": 657.0, + "width": 126.0, + "height": 117.99999237060547 + } + }, + "m_Slots": [ + { + "m_Id": "ace0328dc85b49cb8532e46ed6f51e18" + }, + { + "m_Id": "0f68c661ee204af89506956f32be13cb" + }, + { + "m_Id": "b5ac1432065540238e51147cdd5998ff" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "1aa5508d563a46628cfbbc83f8ab9519", + "m_Id": 1, + "m_DisplayName": "X", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "X", + "m_StageCapability": 3, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.PropertyNode", + "m_ObjectId": "1acd2114eeca41e1931e48aa19b1a1c8", + "m_Group": { + "m_Id": "dfa824146c2f43d5a5ea6bd8b9c3463a" + }, + "m_Name": "Property", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -5418.0, + "y": 393.00006103515627, + "width": 185.0, + "height": 34.0 + } + }, + "m_Slots": [ + { + "m_Id": "8f548b1b59b143b5ae7436740ad9a91a" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_Property": { + "m_Id": "971eb675ce25417c8f423a316a778a4a" + } +} + +{ + "m_SGVersion": 1, + "m_Type": "UnityEditor.ShaderGraph.Internal.Vector1ShaderProperty", + "m_ObjectId": "1b299f10f9db46719d10fb61b53094c1", + "m_Guid": { + "m_GuidSerialized": "0887accf-69ae-4141-a559-543ceb038a67" + }, + "m_Name": "Unmasked Smoothness Mod", + "m_DefaultReferenceName": "", + "m_OverrideReferenceName": "_UnmaskedSmoothnessMod", + "m_GeneratePropertyBlock": true, + "m_Precision": 0, + "overrideHLSLDeclaration": false, + "hlslDeclarationOverride": 0, + "m_Hidden": false, + "m_Value": 0.0, + "m_FloatType": 1, + "m_RangeValues": { + "x": -1.5, + "y": 1.5 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector4MaterialSlot", + "m_ObjectId": "1ba549139d0549719e0aefced25cc144", + "m_Id": 9, + "m_DisplayName": "Mod3", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "Mod3", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "1bd571593dad401bb7989b84e4e7618f", + "m_Id": 0, + "m_DisplayName": "A", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "A", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.MultiplyNode", + "m_ObjectId": "1c1675bdbec14ef98f5a45f8100d0b82", + "m_Group": { + "m_Id": "da79511a40004c349d114e88532d1e86" + }, + "m_Name": "Multiply", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -965.0001220703125, + "y": 1184.0, + "width": 126.00000762939453, + "height": 118.00000762939453 + } + }, + "m_Slots": [ + { + "m_Id": "4f2d617b37f746f284e4dfe07ef81f72" + }, + { + "m_Id": "ad33cb57558d417f9569ffd8bee68eb5" + }, + { + "m_Id": "2aadbd0646e74ba3b18a441127e297cc" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "1c6c411c5130458f84cb5a96efc1686e", + "m_Id": 0, + "m_DisplayName": "Upper Lid/B Scatter Scale", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "1c77679adfa54ab8893eccb5cc5c8380", + "m_Id": 5, + "m_DisplayName": "G", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "G", + "m_StageCapability": 2, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "1cbd49ba99204373b697c4ab58a7f853", + "m_Id": 3, + "m_DisplayName": "Out", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.SampleTexture2DNode", + "m_ObjectId": "1ceaea2d8a314216847b3e129a914f2c", + "m_Group": { + "m_Id": "ef85247de4c745dcbc6ddca88875b14d" + }, + "m_Name": "Sample Texture 2D", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -1362.9998779296875, + "y": 1469.9998779296875, + "width": 184.0, + "height": 252.99998474121095 + } + }, + "m_Slots": [ + { + "m_Id": "186cb51092954fe39e95085fa462302e" + }, + { + "m_Id": "14691abbdb8c44868b2fbf943456a214" + }, + { + "m_Id": "40093fdb515740a6b89991c27475fb70" + }, + { + "m_Id": "62cce88aaad1405d9a4f9103c020132e" + }, + { + "m_Id": "b1d4b45693af46a3a723b2ffb1b8b88a" + }, + { + "m_Id": "eb7f26266d4d47c9a57e818a9e6890dc" + }, + { + "m_Id": "b959e24d88ea43f5bf4256f07ae90ec0" + }, + { + "m_Id": "96f36c732c8e47529d446f73fa12dd82" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_TextureType": 1, + "m_NormalMapSpace": 0 +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "1d1ca274b5fe42e69ce56945c39a8ea7", + "m_Id": 6, + "m_DisplayName": "B", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "B", + "m_StageCapability": 2, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.Rendering.HighDefinition.DiffusionProfileInputMaterialSlot", + "m_ObjectId": "1d4e4c975a3241d5ab63d4debf2aec6a", + "m_Id": 0, + "m_DisplayName": "Diffusion Profile", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "DiffusionProfileHash", + "m_StageCapability": 2, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [], + "m_DiffusionProfile": { + "selectedEntry": 0, + "popupEntries": [] + }, + "m_SerializedDiffusionProfile": "{\n \"diffusionProfileAsset\": {\n \"fileID\": 11400000,\n \"guid\": \"26bdddf49760c61438938733f07fa2a2\",\n \"type\": 2\n }\n}", + "m_Version": 1 +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "1fb80260b80947a887e0bf25a6301900", + "m_Id": 0, + "m_DisplayName": "", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.PropertyNode", + "m_ObjectId": "1fbe2c60822445559fe2af3b7355397d", + "m_Group": { + "m_Id": "dfa824146c2f43d5a5ea6bd8b9c3463a" + }, + "m_Name": "Property", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -4990.0, + "y": 284.9999084472656, + "width": 234.00001525878907, + "height": 34.0 + } + }, + "m_Slots": [ + { + "m_Id": "6113c1fd69f245d4a66862ce1c3c8f41" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_Property": { + "m_Id": "0f24de491c834c9e804aa21dd58f65af" + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "1fc42ad5bac146df9339a267cdfdfb03", + "m_Id": 1, + "m_DisplayName": "", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "21bdd2a34cdb4aa185d61d6ec0cca7a0", + "m_Id": 0, + "m_DisplayName": "A", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "A", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 1, + "m_Type": "UnityEditor.ShaderGraph.Internal.Vector1ShaderProperty", + "m_ObjectId": "229e12ce054c4003affcf25346b88151", + "m_Guid": { + "m_GuidSerialized": "2bb55888-515a-40aa-8e09-1204f3c80b17" + }, + "m_Name": "Smoothness Min", + "m_DefaultReferenceName": "", + "m_OverrideReferenceName": "_SmoothnessMin", + "m_GeneratePropertyBlock": true, + "m_Precision": 0, + "overrideHLSLDeclaration": false, + "hlslDeclarationOverride": 0, + "m_Hidden": false, + "m_Value": 0.0, + "m_FloatType": 1, + "m_RangeValues": { + "x": 0.0, + "y": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "22c8235a46f04dd59f7c65d42934e58b", + "m_Id": 0, + "m_DisplayName": "Ambient Occlusion Strength", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.SamplerStateMaterialSlot", + "m_ObjectId": "230ead4436b64146a60a64dd8575fc7d", + "m_Id": 0, + "m_DisplayName": "", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "", + "m_StageCapability": 3, + "m_BareResource": false +} + +{ + "m_SGVersion": 1, + "m_Type": "UnityEditor.ShaderGraph.Internal.Vector1ShaderProperty", + "m_ObjectId": "23347c24053e478b8cfdb9644cccccaf", + "m_Guid": { + "m_GuidSerialized": "8cfbdc60-52ad-4df3-a4f1-be09fb3d2d54" + }, + "m_Name": "Nose/R Smoothness Mod", + "m_DefaultReferenceName": "", + "m_OverrideReferenceName": "_RSmoothnessMod", + "m_GeneratePropertyBlock": true, + "m_Precision": 0, + "overrideHLSLDeclaration": false, + "hlslDeclarationOverride": 0, + "m_Hidden": false, + "m_Value": 0.0, + "m_FloatType": 1, + "m_RangeValues": { + "x": -1.5, + "y": 1.5 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "238aff0108304d08bc76c1f13198d281", + "m_Id": 0, + "m_DisplayName": "In", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "In", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.RedirectNodeData", + "m_ObjectId": "2458b50b3a4a48f1a639ea1f301ae84b", + "m_Group": { + "m_Id": "" + }, + "m_Name": "Redirect Node", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -347.0001220703125, + "y": -610.0000610351563, + "width": 56.0, + "height": 24.000001907348634 + } + }, + "m_Slots": [ + { + "m_Id": "2fc73300a2a343358f07fa10504f8ee4" + }, + { + "m_Id": "e3e86916a3964c158328500eb1239f82" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.PropertyNode", + "m_ObjectId": "248c9a1da008405ba7595e996125bef3", + "m_Group": { + "m_Id": "dfa824146c2f43d5a5ea6bd8b9c3463a" + }, + "m_Name": "Property", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -5426.0, + "y": 427.0000305175781, + "width": 193.0, + "height": 34.0 + } + }, + "m_Slots": [ + { + "m_Id": "84dc0cfb436548b5b6322ae3547f92c3" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_Property": { + "m_Id": "5c244cc3e1824793bbb81324a733903c" + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "24e451e857044fbcaf92b7742568ed87", + "m_Id": 0, + "m_DisplayName": "A", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "A", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.RedirectNodeData", + "m_ObjectId": "24ecf124b43a45489b00d17d1bdaec5a", + "m_Group": { + "m_Id": "66c69fb10be74462b9dfdbda883bd934" + }, + "m_Name": "Redirect Node", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -3215.0, + "y": -284.0, + "width": 56.0, + "height": 24.0 + } + }, + "m_Slots": [ + { + "m_Id": "45e8085e201e4a5aa9203cce144ecbba" + }, + { + "m_Id": "859c3811943c4b02896b724448c90800" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.PropertyNode", + "m_ObjectId": "24f9c2c72d194b8b871004f37990ecb0", + "m_Group": { + "m_Id": "dfa824146c2f43d5a5ea6bd8b9c3463a" + }, + "m_Name": "Property", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -4752.0, + "y": 797.0, + "width": 202.0, + "height": 34.0 + } + }, + "m_Slots": [ + { + "m_Id": "d14f2f050ac44a56ba46aef4c4655a49" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_Property": { + "m_Id": "a0dea5230a33428cb6bffe7ab816e628" + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.SampleTexture2DNode", + "m_ObjectId": "2573b278f94f489baa02b6e4f8abf14e", + "m_Group": { + "m_Id": "7e0bc17feda14e9686f73d30823bef26" + }, + "m_Name": "Sample Texture 2D", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -1592.9998779296875, + "y": 379.9999694824219, + "width": 184.0, + "height": 253.0 + } + }, + "m_Slots": [ + { + "m_Id": "d4bcdda4715f41acb0dec6f5f0b399a5" + }, + { + "m_Id": "e17a9e2e0ec344d680b399ed8197e67a" + }, + { + "m_Id": "2fdb1b75f7ae453aad54eae3c39e033e" + }, + { + "m_Id": "94c83c44ac0b4bc2b6071eac09c7a6cb" + }, + { + "m_Id": "a3fd7b2e19fc4e95949902ca103e1a30" + }, + { + "m_Id": "fecf7d06ef38474991bf0c06800e8aae" + }, + { + "m_Id": "2fa16f2c17ff43778f25befb7b0695bf" + }, + { + "m_Id": "d55629a774674bdcbc3a5ba1e9e32dc0" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_TextureType": 0, + "m_NormalMapSpace": 0 +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.SamplerStateMaterialSlot", + "m_ObjectId": "2589dbf9a864406eb2102c86a9ebb9b4", + "m_Id": 3, + "m_DisplayName": "Sampler", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "Sampler", + "m_StageCapability": 3, + "m_BareResource": false +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "26019c742e5c4c7a9615882e4ec44265", + "m_Id": 2, + "m_DisplayName": "Off", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "Off", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "2601a264f4d14f4c902f8008895c54cc", + "m_Id": 1, + "m_DisplayName": "Strength", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "Strength", + "m_StageCapability": 3, + "m_Value": 1.0, + "m_DefaultValue": 1.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.UVMaterialSlot", + "m_ObjectId": "261a1463774f402ea6cf22be3927056d", + "m_Id": 0, + "m_DisplayName": "UV", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "UV", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0 + }, + "m_Labels": [], + "m_Channel": 0 +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.KeywordNode", + "m_ObjectId": "263ec88ed5b14e64b2f477156c8df843", + "m_Group": { + "m_Id": "f9a36441a7674212a626b4e29ac4024e" + }, + "m_Name": "Is Head", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -164.00003051757813, + "y": -457.0000305175781, + "width": 135.0, + "height": 118.00000762939453 + } + }, + "m_Slots": [ + { + "m_Id": "329aacad948d406dafafb13de30b816e" + }, + { + "m_Id": "313b7b412ac44263b11790df9dbf2758" + }, + { + "m_Id": "c4665f5d8d5b4498b43072687bee29a3" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_Keyword": { + "m_Id": "4479b5f90a784db6b7291eba881239a9" + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.OneMinusNode", + "m_ObjectId": "264f5393ca9048c48c034aa0c00fe754", + "m_Group": { + "m_Id": "d2a14e6d2148432cb883f7e72b690cff" + }, + "m_Name": "One Minus", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -1720.0001220703125, + "y": 53.000057220458987, + "width": 128.0, + "height": 94.0 + } + }, + "m_Slots": [ + { + "m_Id": "f09f3b7abb124588b87ec35e2f70c5c9" + }, + { + "m_Id": "bc6e2d6b699e4a54ae4a604b9015969e" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector4MaterialSlot", + "m_ObjectId": "26adc51b91984d0685d31ac994b799e2", + "m_Id": 0, + "m_DisplayName": "Out", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Texture2DInputMaterialSlot", + "m_ObjectId": "26d61b36c9a4458b99c9cf5016233792", + "m_Id": 1, + "m_DisplayName": "Texture", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "Texture", + "m_StageCapability": 3, + "m_BareResource": false, + "m_Texture": { + "m_SerializedTexture": "{\"texture\":{\"instanceID\":0}}", + "m_Guid": "" + }, + "m_DefaultType": 3 +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.RedirectNodeData", + "m_ObjectId": "2729e7307ce74d9f835081689bd089c3", + "m_Group": { + "m_Id": "dfa824146c2f43d5a5ea6bd8b9c3463a" + }, + "m_Name": "Redirect Node", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -4615.0, + "y": 134.99996948242188, + "width": 56.0, + "height": 24.0 + } + }, + "m_Slots": [ + { + "m_Id": "ac761ccfb4db460cbf872e7439eb051e" + }, + { + "m_Id": "413a172c3fe848bb98bf09b10dfd0870" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.BlockNode", + "m_ObjectId": "273f61f0afd2438d95da7144e127460e", + "m_Group": { + "m_Id": "" + }, + "m_Name": "SurfaceDescription.SubsurfaceMask", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": 0.0, + "y": 0.0, + "width": 0.0, + "height": 0.0 + } + }, + "m_Slots": [ + { + "m_Id": "e8362fd7f2884d1ab1ac906ae9c28004" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_SerializedDescriptor": "SurfaceDescription.SubsurfaceMask" +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "27816559ecca46af9c4e56da83727fd7", + "m_Id": 6, + "m_DisplayName": "B", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "B", + "m_StageCapability": 2, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.SampleTexture2DNode", + "m_ObjectId": "281c2fab10a54a88ace70a99836fe852", + "m_Group": { + "m_Id": "c39c85064c8b4914bb957db1b59e0e49" + }, + "m_Name": "Sample Texture 2D", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -1462.9998779296875, + "y": 2524.0, + "width": 184.0, + "height": 252.99998474121095 + } + }, + "m_Slots": [ + { + "m_Id": "69d54d6c4ba64a468f042e25e1f1a0ca" + }, + { + "m_Id": "2af5165093084217aac61b4af29a730d" + }, + { + "m_Id": "c9c382f96969430ca6a46ac85b576bb2" + }, + { + "m_Id": "383a3e546b014329b0e83fd4ea9c0506" + }, + { + "m_Id": "05efbcd28970432bab2f0280997fc441" + }, + { + "m_Id": "26d61b36c9a4458b99c9cf5016233792" + }, + { + "m_Id": "0647cd09207e46a99623889e73580759" + }, + { + "m_Id": "ba586a643825415d9395e0095ddd8d8a" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_TextureType": 1, + "m_NormalMapSpace": 0 +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.SamplerStateMaterialSlot", + "m_ObjectId": "29049c4f567047b7864950da33af235e", + "m_Id": 3, + "m_DisplayName": "Sampler", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "Sampler", + "m_StageCapability": 3, + "m_BareResource": false +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "2999b99dcc9e47fdba5b859b41e2cce3", + "m_Id": 0, + "m_DisplayName": "A", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "A", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.Rendering.HighDefinition.ShaderGraph.LightingData", + "m_ObjectId": "2a2960edadd1494c8e81b3d852cb3297", + "m_NormalDropOffSpace": 0, + "m_BlendPreserveSpecular": true, + "m_ReceiveDecals": true, + "m_ReceiveSSR": true, + "m_ReceiveSSRTransparent": false, + "m_SpecularAA": false, + "m_SpecularOcclusionMode": 1, + "m_OverrideBakedGI": false +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.TilingAndOffsetNode", + "m_ObjectId": "2a43d5b227114bb2b6f245cbdffd15e5", + "m_Group": { + "m_Id": "c39c85064c8b4914bb957db1b59e0e49" + }, + "m_Name": "Tiling And Offset", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -1693.0, + "y": 2586.0, + "width": 155.0, + "height": 142.00001525878907 + } + }, + "m_Slots": [ + { + "m_Id": "261a1463774f402ea6cf22be3927056d" + }, + { + "m_Id": "f9b331b1062048d6b94590012e2f4adb" + }, + { + "m_Id": "c083ca9475264d81936b2f64c2ae9982" + }, + { + "m_Id": "89d785e9bb6c413687505ab305a7ebf9" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector4MaterialSlot", + "m_ObjectId": "2a44eebe53c34fd688481ea636e72502", + "m_Id": 6, + "m_DisplayName": "Scatter1", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "Scatter1", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.KeywordNode", + "m_ObjectId": "2a91b4210c2540408a5f7008c3a6ae59", + "m_Group": { + "m_Id": "f9a36441a7674212a626b4e29ac4024e" + }, + "m_Name": "Is Head", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -164.00003051757813, + "y": -812.0000610351563, + "width": 139.0, + "height": 118.00000762939453 + } + }, + "m_Slots": [ + { + "m_Id": "bac1a1097e9c4e0590a6fc721aaf8c06" + }, + { + "m_Id": "2e490a5e1ee24904ad9f435dc013f693" + }, + { + "m_Id": "26019c742e5c4c7a9615882e4ec44265" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_Keyword": { + "m_Id": "4479b5f90a784db6b7291eba881239a9" + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicValueMaterialSlot", + "m_ObjectId": "2aadbd0646e74ba3b18a441127e297cc", + "m_Id": 2, + "m_DisplayName": "Out", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": { + "e00": 0.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 0.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 0.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 0.0 + }, + "m_DefaultValue": { + "e00": 1.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 1.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 1.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "2adb539eb1334a5db44b4729bd9b575c", + "m_Id": 3, + "m_DisplayName": "Z", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "Z", + "m_StageCapability": 3, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [ + "Z" + ] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "2af5165093084217aac61b4af29a730d", + "m_Id": 4, + "m_DisplayName": "R", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "R", + "m_StageCapability": 2, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 1, + "m_Type": "UnityEditor.ShaderGraph.Internal.Vector1ShaderProperty", + "m_ObjectId": "2aff406bc0ff49feab0b75f503b042f0", + "m_Guid": { + "m_GuidSerialized": "e4cf905b-6998-4808-8f8a-23912148240b" + }, + "m_Name": "Upper Lid/B Scatter Scale", + "m_DefaultReferenceName": "", + "m_OverrideReferenceName": "_BScatterScale", + "m_GeneratePropertyBlock": true, + "m_Precision": 0, + "overrideHLSLDeclaration": false, + "hlslDeclarationOverride": 0, + "m_Hidden": false, + "m_Value": 1.0, + "m_FloatType": 1, + "m_RangeValues": { + "x": 0.0, + "y": 2.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "2b081408a7e24e398594d062ea1a971f", + "m_Id": 4, + "m_DisplayName": "R", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "R", + "m_StageCapability": 2, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector4MaterialSlot", + "m_ObjectId": "2b2b2d07a8f24b6eb6bfeebf714d9597", + "m_Id": 6, + "m_DisplayName": "In3", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "In3", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "2b709efed97245e39e8efd16cce3a25e", + "m_Id": 0, + "m_DisplayName": "Mouth/G Smoothness Mod", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "2c66e4d810324e0b9f9719d4a714952d", + "m_Id": 0, + "m_DisplayName": "", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Internal.Texture2DShaderProperty", + "m_ObjectId": "2cc11af55d6b4faea215407e60307db4", + "m_Guid": { + "m_GuidSerialized": "af4fc7b2-efb5-49d3-ab39-9a7996790eb6" + }, + "m_Name": "Normal Blend Map (Head)", + "m_DefaultReferenceName": "Texture2D_2cc11af55d6b4faea215407e60307db4", + "m_OverrideReferenceName": "_NormalBlendMap", + "m_GeneratePropertyBlock": true, + "m_Precision": 0, + "overrideHLSLDeclaration": false, + "hlslDeclarationOverride": 0, + "m_Hidden": false, + "m_Value": { + "m_SerializedTexture": "{\"texture\":{\"instanceID\":0}}", + "m_Guid": "" + }, + "m_Modifiable": true, + "m_DefaultType": 0 +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "2cf64e195b80497f89585eb10f547802", + "m_Id": 0, + "m_DisplayName": "Out", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector4MaterialSlot", + "m_ObjectId": "2cfe2b87003046fba7904a4c6b6c79dc", + "m_Id": 7, + "m_DisplayName": "Mod1", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "Mod1", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "2d00f62acd904c94b88139b3936f5d00", + "m_Id": 2, + "m_DisplayName": "Out", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.UVMaterialSlot", + "m_ObjectId": "2d09a2a1464e4042993ea2181230532c", + "m_Id": 2, + "m_DisplayName": "UV", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "UV", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0 + }, + "m_Labels": [], + "m_Channel": 0 +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "2ddf62a8e5c74c50ab6a1fc5aed3d039", + "m_Id": 1, + "m_DisplayName": "Out", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "2e490a5e1ee24904ad9f435dc013f693", + "m_Id": 1, + "m_DisplayName": "On", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "On", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector4Node", + "m_ObjectId": "2e7b1b44474a40d6be90556281a77042", + "m_Group": { + "m_Id": "dfa824146c2f43d5a5ea6bd8b9c3463a" + }, + "m_Name": "Vector 4", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -5167.0, + "y": 544.9998779296875, + "width": 131.0, + "height": 149.0 + } + }, + "m_Slots": [ + { + "m_Id": "1aa5508d563a46628cfbbc83f8ab9519" + }, + { + "m_Id": "54d535b7368c4a89a598835dffe7911c" + }, + { + "m_Id": "2adb539eb1334a5db44b4729bd9b575c" + }, + { + "m_Id": "0e7df1d9c08e4ef9b64a1bd18349ce81" + }, + { + "m_Id": "4dfb5d9f77cf49cfab4aa11ef098160d" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.PropertyNode", + "m_ObjectId": "2e9f729099a7471b905328ce4ab3d62d", + "m_Group": { + "m_Id": "dfa824146c2f43d5a5ea6bd8b9c3463a" + }, + "m_Name": "Property", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -5428.0, + "y": 105.0, + "width": 162.0, + "height": 34.0 + } + }, + "m_Slots": [ + { + "m_Id": "2f3e24070c184dfdaed5e23420b44776" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_Property": { + "m_Id": "11d663a4721749668b26f021655222e3" + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Texture2DMaterialSlot", + "m_ObjectId": "2f3e24070c184dfdaed5e23420b44776", + "m_Id": 0, + "m_DisplayName": "Ear Neck Mask", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_BareResource": false +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.UVMaterialSlot", + "m_ObjectId": "2fa16f2c17ff43778f25befb7b0695bf", + "m_Id": 2, + "m_DisplayName": "UV", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "UV", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0 + }, + "m_Labels": [], + "m_Channel": 0 +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.MultiplyNode", + "m_ObjectId": "2fb263a485e1422cb255f3f4b19781a7", + "m_Group": { + "m_Id": "063dd08ef7054b98834ef43a93ef035d" + }, + "m_Name": "Multiply", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -690.9999389648438, + "y": -1204.0, + "width": 130.0, + "height": 118.00000762939453 + } + }, + "m_Slots": [ + { + "m_Id": "f69b9026c9f34b6c875f95a45f10a2c0" + }, + { + "m_Id": "b7c396adc2074b9e90f2631e905ffdf5" + }, + { + "m_Id": "e594ef18acbd4c88a458248568ecdf8f" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "2fc73300a2a343358f07fa10504f8ee4", + "m_Id": 0, + "m_DisplayName": "", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "2fdb1b75f7ae453aad54eae3c39e033e", + "m_Id": 5, + "m_DisplayName": "G", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "G", + "m_StageCapability": 2, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.OneMinusNode", + "m_ObjectId": "30c679946250441ab393a854e7e04a57", + "m_Group": { + "m_Id": "d2a14e6d2148432cb883f7e72b690cff" + }, + "m_Name": "One Minus", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -2075.0, + "y": 53.000057220458987, + "width": 128.0, + "height": 94.0 + } + }, + "m_Slots": [ + { + "m_Id": "b1702efc476344c3960ea02ce540f393" + }, + { + "m_Id": "2ddf62a8e5c74c50ab6a1fc5aed3d039" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "30fa119b4c8e49d69305bb791bfee0ef", + "m_Id": 0, + "m_DisplayName": "Smoothness Power", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "313b7b412ac44263b11790df9dbf2758", + "m_Id": 1, + "m_DisplayName": "On", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "On", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "315af748590c43e98863cdc26b38904f", + "m_Id": 0, + "m_DisplayName": "Micro Normal Strength", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.RedirectNodeData", + "m_ObjectId": "31ebcab334ed4edb8643d897a0fe281b", + "m_Group": { + "m_Id": "063dd08ef7054b98834ef43a93ef035d" + }, + "m_Name": "Redirect Node", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -1317.0, + "y": -1288.0, + "width": 56.0, + "height": 24.000001907348634 + } + }, + "m_Slots": [ + { + "m_Id": "2c66e4d810324e0b9f9719d4a714952d" + }, + { + "m_Id": "afe49abcf9354889acf24c07191e3f82" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "320b7f56c48046afad2ace44ca49de50", + "m_Id": 3, + "m_DisplayName": "Z", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "Z", + "m_StageCapability": 3, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [ + "Z" + ] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "3259710122434acb8c2cc37879ef7a95", + "m_Id": 2, + "m_DisplayName": "Out", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.RedirectNodeData", + "m_ObjectId": "325fc7a821234c9ba300ca38df3ce945", + "m_Group": { + "m_Id": "9077599ecffb44679d301bdc68b79f81" + }, + "m_Name": "Redirect Node", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -745.9999389648438, + "y": 340.0000305175781, + "width": 56.000003814697269, + "height": 24.000001907348634 + } + }, + "m_Slots": [ + { + "m_Id": "04fe9d14c348421c843b990188e29c0b" + }, + { + "m_Id": "6bec06617c55433a86183662f587ba04" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "329aacad948d406dafafb13de30b816e", + "m_Id": 0, + "m_DisplayName": "Out", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "32adb951b7c34c899a609927b1208e67", + "m_Id": 5, + "m_DisplayName": "G", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "G", + "m_StageCapability": 2, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "32c9c8124f1d4c23a2e1e4cbf1d00fbd", + "m_Id": 1, + "m_DisplayName": "", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.KeywordNode", + "m_ObjectId": "32f21a4535e54ce48c097e51586c2235", + "m_Group": { + "m_Id": "5afd5b10bac94af98e61ab4df0f1d432" + }, + "m_Name": "Is Head", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -3832.0, + "y": 1029.0, + "width": 135.0, + "height": 118.0 + } + }, + "m_Slots": [ + { + "m_Id": "2cf64e195b80497f89585eb10f547802" + }, + { + "m_Id": "8c8679659b1c423da2705f4192a9518b" + }, + { + "m_Id": "e668d6b76d8549e2aa913b336c0b7589" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_Keyword": { + "m_Id": "4479b5f90a784db6b7291eba881239a9" + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.RedirectNodeData", + "m_ObjectId": "338d630ac3c44089856d8e5240554ff8", + "m_Group": { + "m_Id": "7e0bc17feda14e9686f73d30823bef26" + }, + "m_Name": "Redirect Node", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -1804.0, + "y": 340.0000305175781, + "width": 56.000003814697269, + "height": 24.000001907348634 + } + }, + "m_Slots": [ + { + "m_Id": "16a964c42caa4ca3afed97077c6b7bbe" + }, + { + "m_Id": "93535619bc6f4e8aab83bd4126f7843b" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.PropertyNode", + "m_ObjectId": "33989d390d0244088b0a2ac22e778165", + "m_Group": { + "m_Id": "dfa824146c2f43d5a5ea6bd8b9c3463a" + }, + "m_Name": "Property", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -4979.0, + "y": 436.99993896484377, + "width": 223.00001525878907, + "height": 34.0 + } + }, + "m_Slots": [ + { + "m_Id": "b3816536558e4d5bb5f5ab8c9171e12c" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_Property": { + "m_Id": "e8cdc35a911841ea94f4e76dc4ec9395" + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "33cd59ca32c444f0a0912f3daa9403ab", + "m_Id": 5, + "m_DisplayName": "G", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "G", + "m_StageCapability": 2, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector4MaterialSlot", + "m_ObjectId": "342fb2c74a0745c9912bc08443777606", + "m_Id": 0, + "m_DisplayName": "In1", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "In1", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "351cfe5ef83646b6b88dcad462309730", + "m_Id": 0, + "m_DisplayName": "Nostril Cavity AO", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.PropertyNode", + "m_ObjectId": "352c5e7ba2f8421e9a1628d45c6167c1", + "m_Group": { + "m_Id": "dfa824146c2f43d5a5ea6bd8b9c3463a" + }, + "m_Name": "Property", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -5397.0, + "y": 729.0, + "width": 164.0, + "height": 34.0 + } + }, + "m_Slots": [ + { + "m_Id": "67ce2d247d3e4a07aad4c63cea64571d" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_Property": { + "m_Id": "e55f9a75fb6b42608280338c0f6f0543" + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "355345a19dfa41b2a36d0dcc2f06088a", + "m_Id": 0, + "m_DisplayName": "Smoothness Min", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "358c191e589441cb9ab0497275a6866f", + "m_Id": 4, + "m_DisplayName": "R", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "R", + "m_StageCapability": 2, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.BlendNode", + "m_ObjectId": "35d381f3a7994da39121a67ca007c2ed", + "m_Group": { + "m_Id": "063dd08ef7054b98834ef43a93ef035d" + }, + "m_Name": "Blend", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -1321.0, + "y": -1487.0, + "width": 161.0, + "height": 178.0 + } + }, + "m_Slots": [ + { + "m_Id": "547377dca39c41e09bae114510db1a87" + }, + { + "m_Id": "688faa8da3b14091a4958198db5bea66" + }, + { + "m_Id": "bb7bdf3a76704b8db4a45ba32c2e001d" + }, + { + "m_Id": "b8cbf18017a24aa7b494ec5231b60920" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_BlendMode": 15 +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "36cf58cdc6114de09fa380c277e06693", + "m_Id": 0, + "m_DisplayName": "Subsurface Scale", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "36eecdef2b294c59a439232db1d40c95", + "m_Id": 5, + "m_DisplayName": "G", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "G", + "m_StageCapability": 2, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "3781cd6f06144262831c126dc6c516a1", + "m_Id": 2, + "m_DisplayName": "Off", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "Off", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "383a3e546b014329b0e83fd4ea9c0506", + "m_Id": 6, + "m_DisplayName": "B", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "B", + "m_StageCapability": 2, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "39a1b3de165b4ff6beecaebd677c6e3a", + "m_Id": 5, + "m_DisplayName": "G", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "G", + "m_StageCapability": 2, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.SampleTexture2DNode", + "m_ObjectId": "39abf23a0de14b4f9a35f8bda206a3f5", + "m_Group": { + "m_Id": "dfa824146c2f43d5a5ea6bd8b9c3463a" + }, + "m_Name": "Sample Texture 2D", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -5220.0, + "y": 105.0, + "width": 184.0, + "height": 252.99998474121095 + } + }, + "m_Slots": [ + { + "m_Id": "64a83542b6d843c7b637379509d8a3cf" + }, + { + "m_Id": "4968d302e5e940f8b9a88a6f70d2c852" + }, + { + "m_Id": "899ac35f1d074b8ba17c6cedd02aed08" + }, + { + "m_Id": "7700ac8514144e75956f81002597b33e" + }, + { + "m_Id": "4025c72a40cb42848d28a618067d0136" + }, + { + "m_Id": "934cb2a0d12e441292d9259cc4ca24f9" + }, + { + "m_Id": "cc38707bb3d748838a23f4574a063781" + }, + { + "m_Id": "03e431f2cc564c7d824423b1da73db58" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_TextureType": 0, + "m_NormalMapSpace": 0 +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "39cab34d69114123b38ed04b3bb55c23", + "m_Id": 6, + "m_DisplayName": "B", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "B", + "m_StageCapability": 2, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "3a447476a53a4423b705358147d98bee", + "m_Id": 7, + "m_DisplayName": "A", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "A", + "m_StageCapability": 2, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 1, + "m_Type": "UnityEditor.ShaderGraph.Internal.Vector1ShaderProperty", + "m_ObjectId": "3a7a76a7000244e4b3de2b879f66a390", + "m_Guid": { + "m_GuidSerialized": "f7de4c2c-5122-40a0-8daf-9e03b4b9dcba" + }, + "m_Name": "Chin Scatter Scale", + "m_DefaultReferenceName": "", + "m_OverrideReferenceName": "_ChinScatterScale", + "m_GeneratePropertyBlock": true, + "m_Precision": 0, + "overrideHLSLDeclaration": false, + "hlslDeclarationOverride": 0, + "m_Hidden": false, + "m_Value": 1.0, + "m_FloatType": 1, + "m_RangeValues": { + "x": 0.0, + "y": 2.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.NormalMaterialSlot", + "m_ObjectId": "3b9bea9727174fc0b9e705617c9903db", + "m_Id": 0, + "m_DisplayName": "Normal", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "Normal", + "m_StageCapability": 1, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0 + }, + "m_Labels": [], + "m_Space": 0 +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "3c351ac12c7644e888732457ce8c7535", + "m_Id": 0, + "m_DisplayName": "", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "3c55dbafb6a64d44812a529932b5620e", + "m_Id": 0, + "m_DisplayName": "", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "3cb22f2017f24943ac729606ac833859", + "m_Id": 0, + "m_DisplayName": "Nose/R Smoothness Mod", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.GroupData", + "m_ObjectId": "3cd206490c954ca5a821100d4380764f", + "m_Title": "HDRP Mask", + "m_Position": { + "x": -3139.0, + "y": 565.0001831054688 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.PropertyNode", + "m_ObjectId": "3d60b782c9dd4e5494f6fc269bee5bfa", + "m_Group": { + "m_Id": "f56aec43c38a433ca25a9aab19b2e18b" + }, + "m_Name": "Property", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -1436.0, + "y": 1016.0, + "width": 164.00001525878907, + "height": 34.0 + } + }, + "m_Slots": [ + { + "m_Id": "355345a19dfa41b2a36d0dcc2f06088a" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_Property": { + "m_Id": "229e12ce054c4003affcf25346b88151" + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Texture2DInputMaterialSlot", + "m_ObjectId": "3db60fa0adee4b2c9e05d88f48ac010c", + "m_Id": 1, + "m_DisplayName": "Texture", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "Texture", + "m_StageCapability": 3, + "m_BareResource": false, + "m_Texture": { + "m_SerializedTexture": "{\"texture\":{\"instanceID\":0}}", + "m_Guid": "" + }, + "m_DefaultType": 0 +} + +{ + "m_SGVersion": 1, + "m_Type": "UnityEditor.ShaderGraph.Internal.Vector1ShaderProperty", + "m_ObjectId": "3ddb1de457ce4a0d84f7586eaac11b9a", + "m_Guid": { + "m_GuidSerialized": "7ec79208-c8b6-4243-8651-235530397e0a" + }, + "m_Name": "Mouth Cavity AO", + "m_DefaultReferenceName": "Vector1_3ddb1de457ce4a0d84f7586eaac11b9a", + "m_OverrideReferenceName": "_MouthCavityAO", + "m_GeneratePropertyBlock": true, + "m_Precision": 0, + "overrideHLSLDeclaration": false, + "hlslDeclarationOverride": 0, + "m_Hidden": false, + "m_Value": 2.5, + "m_FloatType": 1, + "m_RangeValues": { + "x": 0.0, + "y": 5.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "3e9175b413cd41c38eab6fa851e47c7b", + "m_Id": 0, + "m_DisplayName": "Cheek Smoothness Mod", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.SamplerStateNode", + "m_ObjectId": "3e9ea45a5cf94973bb74662f6dfa67d7", + "m_Group": { + "m_Id": "" + }, + "m_Name": "Sampler State", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -6032.0, + "y": 343.99993896484377, + "width": 145.00001525878907, + "height": 140.0 + } + }, + "m_Slots": [ + { + "m_Id": "a2d9dba0a09d436f9258d6d6acfd2c3f" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_filter": 0, + "m_wrap": 0 +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "3ed5515d3a0d4580ac6215bc07afbe14", + "m_Id": 0, + "m_DisplayName": "In", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "In", + "m_StageCapability": 3, + "m_Value": { + "x": 1.0, + "y": 1.0, + "z": 1.0, + "w": 1.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "3ed7d11623c440e78d14cff8a90541ef", + "m_Id": 0, + "m_DisplayName": "Inner Lid/A Smoothness Mod", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "3edc70b7a09341289b41280ab3454925", + "m_Id": 0, + "m_DisplayName": "", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.PropertyNode", + "m_ObjectId": "3edf889a2311455d94539d91d4840ace", + "m_Group": { + "m_Id": "d2a14e6d2148432cb883f7e72b690cff" + }, + "m_Name": "Property", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -2168.0, + "y": 147.0000457763672, + "width": 221.0, + "height": 34.0 + } + }, + "m_Slots": [ + { + "m_Id": "22c8235a46f04dd59f7c65d42934e58b" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_Property": { + "m_Id": "daa99c4f268449b8a4e69fdaeafcfe49" + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "3ee61b5f19fa4d698aa68fbb921589e0", + "m_Id": 4, + "m_DisplayName": "A", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "A", + "m_StageCapability": 3, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "3ee6739c842f4fa196fda9c1b2d0a599", + "m_Id": 7, + "m_DisplayName": "ScatterMask", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "ScatterMask", + "m_StageCapability": 3, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "3efa8f51ec2c4c22962c1a8468f69d68", + "m_Id": 1, + "m_DisplayName": "", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.UVMaterialSlot", + "m_ObjectId": "3f02984ee456476b86071667e9c321eb", + "m_Id": 2, + "m_DisplayName": "UV", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "UV", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0 + }, + "m_Labels": [], + "m_Channel": 0 +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.PropertyNode", + "m_ObjectId": "3f04ec4c0414483791e7e56388b25b1f", + "m_Group": { + "m_Id": "dfa824146c2f43d5a5ea6bd8b9c3463a" + }, + "m_Name": "Property", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -4945.0, + "y": 551.9999389648438, + "width": 189.0, + "height": 34.0 + } + }, + "m_Slots": [ + { + "m_Id": "a56d065198b44d74a5c4bb7083ff11eb" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_Property": { + "m_Id": "167f8d77ee5e478ab5c3c33cb26ad3c0" + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "3f512c43b1ab463b89c3b482a631dd13", + "m_Id": 0, + "m_DisplayName": "", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector4MaterialSlot", + "m_ObjectId": "3ff0a4ef798b42fa80b0a932530531a2", + "m_Id": 0, + "m_DisplayName": "RGBA", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "RGBA", + "m_StageCapability": 2, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "40093fdb515740a6b89991c27475fb70", + "m_Id": 5, + "m_DisplayName": "G", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "G", + "m_StageCapability": 2, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "4025c72a40cb42848d28a618067d0136", + "m_Id": 7, + "m_DisplayName": "A", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "A", + "m_StageCapability": 2, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "402c0e183c66416e95e93c455f89f4ae", + "m_Id": 1, + "m_DisplayName": "Out", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Texture2DInputMaterialSlot", + "m_ObjectId": "40411d53b935493097fbc12e892291fa", + "m_Id": 1, + "m_DisplayName": "Texture", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "Texture", + "m_StageCapability": 3, + "m_BareResource": false, + "m_Texture": { + "m_SerializedTexture": "{\"texture\":{\"instanceID\":0}}", + "m_Guid": "" + }, + "m_DefaultType": 0 +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.PowerNode", + "m_ObjectId": "4082d083d2a14f029ccf2324754b1d9c", + "m_Group": { + "m_Id": "f56aec43c38a433ca25a9aab19b2e18b" + }, + "m_Name": "Power", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -1568.0, + "y": 1118.0, + "width": 126.0, + "height": 118.0 + } + }, + "m_Slots": [ + { + "m_Id": "21bdd2a34cdb4aa185d61d6ec0cca7a0" + }, + { + "m_Id": "e1fbb5c2a74741dd8a53af2a1f19ccff" + }, + { + "m_Id": "cd68a4bd5a87465aa9979957b2c99b57" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Internal.Texture2DShaderProperty", + "m_ObjectId": "40ad0182bb1c42b9b661c6e1e59e3b8e", + "m_Guid": { + "m_GuidSerialized": "b3f525e2-6c74-48e8-a89d-7086819a0576" + }, + "m_Name": "Subsurface Map", + "m_DefaultReferenceName": "Texture2D_40ad0182bb1c42b9b661c6e1e59e3b8e", + "m_OverrideReferenceName": "_SSSMap", + "m_GeneratePropertyBlock": true, + "m_Precision": 0, + "overrideHLSLDeclaration": false, + "hlslDeclarationOverride": 0, + "m_Hidden": false, + "m_Value": { + "m_SerializedTexture": "{\"texture\":{\"instanceID\":0}}", + "m_Guid": "" + }, + "m_Modifiable": true, + "m_DefaultType": 0 +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Internal.Texture2DShaderProperty", + "m_ObjectId": "40b34821d493419797f0cb0b43e6e690", + "m_Guid": { + "m_GuidSerialized": "a7611428-bb15-4696-ae63-ed37061ec474" + }, + "m_Name": "Metallic Alpha Map", + "m_DefaultReferenceName": "", + "m_OverrideReferenceName": "_MetallicAlphaMap", + "m_GeneratePropertyBlock": true, + "m_Precision": 0, + "overrideHLSLDeclaration": false, + "hlslDeclarationOverride": 0, + "m_Hidden": false, + "m_Value": { + "m_SerializedTexture": "{\"texture\":{\"instanceID\":0}}", + "m_Guid": "" + }, + "m_Modifiable": true, + "m_DefaultType": 0 +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector4MaterialSlot", + "m_ObjectId": "40fcf31603c04fa0919b02d5b43650c7", + "m_Id": 0, + "m_DisplayName": "Out", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector3MaterialSlot", + "m_ObjectId": "410bebff5a4c4691b70fcbc06f01c0af", + "m_Id": 2, + "m_DisplayName": "Out", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0 + }, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "413a172c3fe848bb98bf09b10dfd0870", + "m_Id": 1, + "m_DisplayName": "", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Texture2DInputMaterialSlot", + "m_ObjectId": "413e9c5250a640a5bc2df5e6d4676ff8", + "m_Id": 1, + "m_DisplayName": "Texture", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "Texture", + "m_StageCapability": 3, + "m_BareResource": false, + "m_Texture": { + "m_SerializedTexture": "{\"texture\":{\"instanceID\":0}}", + "m_Guid": "" + }, + "m_DefaultType": 0 +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.LerpNode", + "m_ObjectId": "41d505aa97584e2ca6e2f617918967fe", + "m_Group": { + "m_Id": "f56aec43c38a433ca25a9aab19b2e18b" + }, + "m_Name": "Lerp", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -1181.0, + "y": 1070.0, + "width": 126.0, + "height": 142.0 + } + }, + "m_Slots": [ + { + "m_Id": "24e451e857044fbcaf92b7742568ed87" + }, + { + "m_Id": "f46f5e593ceb4b55a0d2e476533c6bc6" + }, + { + "m_Id": "aa9f7127505c4939873c9702771da1c8" + }, + { + "m_Id": "88df3c9762cd417f9a56746f48f9289e" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "420210b0bace45fd9fe7069700274d32", + "m_Id": 2, + "m_DisplayName": "Out", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "4220346c81a44c979bd63ba9a98b160f", + "m_Id": 4, + "m_DisplayName": "W", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "W", + "m_StageCapability": 3, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [ + "W" + ] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "424b313138944a21bc404c418bcb085e", + "m_Id": 0, + "m_DisplayName": "Alpha", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "Alpha", + "m_StageCapability": 2, + "m_Value": 1.0, + "m_DefaultValue": 1.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "4303fb6376b84abdbaae6bfd9d78a39f", + "m_Id": 7, + "m_DisplayName": "A", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "A", + "m_StageCapability": 2, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 1, + "m_Type": "UnityEditor.ShaderGraph.Internal.Vector1ShaderProperty", + "m_ObjectId": "43ccb360c88d4573b568d5486e4504e5", + "m_Guid": { + "m_GuidSerialized": "576ac089-7fcd-4804-9a87-656aa88531f0" + }, + "m_Name": "Forehead Scatter Scale", + "m_DefaultReferenceName": "", + "m_OverrideReferenceName": "_ForeheadScatterScale", + "m_GeneratePropertyBlock": true, + "m_Precision": 0, + "overrideHLSLDeclaration": false, + "hlslDeclarationOverride": 0, + "m_Hidden": false, + "m_Value": 1.0, + "m_FloatType": 1, + "m_RangeValues": { + "x": 0.0, + "y": 2.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.ShaderKeyword", + "m_ObjectId": "4479b5f90a784db6b7291eba881239a9", + "m_Guid": { + "m_GuidSerialized": "db30be96-2715-4bf0-b018-69a0617c0051" + }, + "m_Name": "Is Head", + "m_DefaultReferenceName": "BOOLEAN_4479B5F90A784DB6B7291EBA881239A9_ON", + "m_OverrideReferenceName": "BOOLEAN_IS_HEAD_ON", + "m_GeneratePropertyBlock": true, + "m_KeywordType": 0, + "m_KeywordDefinition": 1, + "m_KeywordScope": 0, + "m_Entries": [], + "m_Value": 1, + "m_IsEditable": true +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Texture2DInputMaterialSlot", + "m_ObjectId": "44ae0b91aec34fc1ac3c082e36065ea1", + "m_Id": 1, + "m_DisplayName": "Texture", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "Texture", + "m_StageCapability": 3, + "m_BareResource": false, + "m_Texture": { + "m_SerializedTexture": "{\"texture\":{\"instanceID\":0}}", + "m_Guid": "" + }, + "m_DefaultType": 3 +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.PropertyNode", + "m_ObjectId": "44bc17bcc71c4ae19156bb362cae14ae", + "m_Group": { + "m_Id": "7e0bc17feda14e9686f73d30823bef26" + }, + "m_Name": "Property", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -1373.9998779296875, + "y": 603.0, + "width": 160.0, + "height": 34.0 + } + }, + "m_Slots": [ + { + "m_Id": "af1c3e2053234885a04a449a03b4b891" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_Property": { + "m_Id": "45aabf6161ff4a45a137dd21f95c2d3c" + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.UVMaterialSlot", + "m_ObjectId": "44ea5acfb2d4456ea052aa45beb63793", + "m_Id": 2, + "m_DisplayName": "UV", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "UV", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0 + }, + "m_Labels": [], + "m_Channel": 0 +} + +{ + "m_SGVersion": 1, + "m_Type": "UnityEditor.ShaderGraph.Internal.Vector1ShaderProperty", + "m_ObjectId": "45aabf6161ff4a45a137dd21f95c2d3c", + "m_Guid": { + "m_GuidSerialized": "e3a0e8b1-5d98-495a-819b-fa468f472ce9" + }, + "m_Name": "Thickness Scale", + "m_DefaultReferenceName": "Vector1_45aabf6161ff4a45a137dd21f95c2d3c", + "m_OverrideReferenceName": "_ThicknessScale", + "m_GeneratePropertyBlock": true, + "m_Precision": 0, + "overrideHLSLDeclaration": false, + "hlslDeclarationOverride": 0, + "m_Hidden": false, + "m_Value": 0.4000000059604645, + "m_FloatType": 1, + "m_RangeValues": { + "x": 0.0, + "y": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.SamplerStateMaterialSlot", + "m_ObjectId": "45e8085e201e4a5aa9203cce144ecbba", + "m_Id": 0, + "m_DisplayName": "", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "", + "m_StageCapability": 3, + "m_BareResource": false +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector4MaterialSlot", + "m_ObjectId": "465e315e462143fc807a7b9a4c29d2bd", + "m_Id": 0, + "m_DisplayName": "RGBA", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "RGBA", + "m_StageCapability": 2, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Texture2DInputMaterialSlot", + "m_ObjectId": "4686d5fe337b46f28a9b367786c7087b", + "m_Id": 1, + "m_DisplayName": "Texture", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "Texture", + "m_StageCapability": 3, + "m_BareResource": false, + "m_Texture": { + "m_SerializedTexture": "{\"texture\":{\"instanceID\":0}}", + "m_Guid": "" + }, + "m_DefaultType": 0 +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector4MaterialSlot", + "m_ObjectId": "474330843c344b21a039e14e11acd1db", + "m_Id": 5, + "m_DisplayName": "In2", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "In2", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Texture2DMaterialSlot", + "m_ObjectId": "49685b48928947cd8c266ae2ac7de7c4", + "m_Id": 0, + "m_DisplayName": "Mask Map", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_BareResource": false +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "4968d302e5e940f8b9a88a6f70d2c852", + "m_Id": 4, + "m_DisplayName": "R", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "R", + "m_StageCapability": 2, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "4a8082a47b0245d995015f80ed9085b6", + "m_Id": 1, + "m_DisplayName": "B", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "B", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.BlockNode", + "m_ObjectId": "4b45669a84054c498babd493511b3189", + "m_Group": { + "m_Id": "" + }, + "m_Name": "VertexDescription.Position", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": 0.0, + "y": 0.0, + "width": 0.0, + "height": 0.0 + } + }, + "m_Slots": [ + { + "m_Id": "cb901263bb9a42489ac84d9e84023477" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_SerializedDescriptor": "VertexDescription.Position" +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector4MaterialSlot", + "m_ObjectId": "4b88b55388ef4664baf654b1bed1e87f", + "m_Id": 0, + "m_DisplayName": "RGBA", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "RGBA", + "m_StageCapability": 2, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.SampleTexture2DNode", + "m_ObjectId": "4b8aae1832a34ca98002df9614e79836", + "m_Group": { + "m_Id": "cb23790c1b9143928df829b7a26d1423" + }, + "m_Name": "Sample Texture 2D", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -5015.0, + "y": 991.9999389648438, + "width": 184.0, + "height": 252.99998474121095 + } + }, + "m_Slots": [ + { + "m_Id": "e612418ec5dc4c8ba3d06fc562572c3f" + }, + { + "m_Id": "4e877332d8f44f4e89117a67b99c25a4" + }, + { + "m_Id": "1c77679adfa54ab8893eccb5cc5c8380" + }, + { + "m_Id": "90e122d7b5aa42dba9440db15c0d6b9f" + }, + { + "m_Id": "4303fb6376b84abdbaae6bfd9d78a39f" + }, + { + "m_Id": "6176c27a8edf4b18856f209e42b8d163" + }, + { + "m_Id": "74584acee8b94a7a94948b1b5a7094a4" + }, + { + "m_Id": "2589dbf9a864406eb2102c86a9ebb9b4" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_TextureType": 0, + "m_NormalMapSpace": 0 +} + +{ + "m_SGVersion": 1, + "m_Type": "UnityEditor.ShaderGraph.Internal.Vector1ShaderProperty", + "m_ObjectId": "4bbc052da7aa4bb59c0765662e464374", + "m_Guid": { + "m_GuidSerialized": "415cb15d-07fc-4ac7-876d-052b9200c2ed" + }, + "m_Name": "Neck Smoothness Mod", + "m_DefaultReferenceName": "", + "m_OverrideReferenceName": "_NeckSmoothnessMod", + "m_GeneratePropertyBlock": true, + "m_Precision": 0, + "overrideHLSLDeclaration": false, + "hlslDeclarationOverride": 0, + "m_Hidden": false, + "m_Value": 0.0, + "m_FloatType": 1, + "m_RangeValues": { + "x": -1.5, + "y": 1.5 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector4MaterialSlot", + "m_ObjectId": "4c2a4014b7ad4035bb8339bd87074c5a", + "m_Id": 8, + "m_DisplayName": "Mod2", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "Mod2", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "4cc666179ce842b5ab953aa2cd889661", + "m_Id": 3, + "m_DisplayName": "Z", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "Z", + "m_StageCapability": 3, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [ + "Z" + ] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.SaturateNode", + "m_ObjectId": "4d5d4124bf664f4d9af264e412e1b431", + "m_Group": { + "m_Id": "da79511a40004c349d114e88532d1e86" + }, + "m_Name": "Saturate", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -595.0000610351563, + "y": 1071.0, + "width": 128.0, + "height": 94.0 + } + }, + "m_Slots": [ + { + "m_Id": "0ed9acaed6d8417fad8b86edf7faf7b5" + }, + { + "m_Id": "402c0e183c66416e95e93c455f89f4ae" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector4MaterialSlot", + "m_ObjectId": "4dfb5d9f77cf49cfab4aa11ef098160d", + "m_Id": 0, + "m_DisplayName": "Out", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "4e8603f0303e4fccad59b551b5bec709", + "m_Id": 5, + "m_DisplayName": "G", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "G", + "m_StageCapability": 2, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "4e877332d8f44f4e89117a67b99c25a4", + "m_Id": 4, + "m_DisplayName": "R", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "R", + "m_StageCapability": 2, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Internal.Texture2DShaderProperty", + "m_ObjectId": "4ef79e9b5e3e473abf150852f1ee2eaa", + "m_Guid": { + "m_GuidSerialized": "f0206a5c-967a-4540-9bec-583b8380c2d8" + }, + "m_Name": "Mask Map", + "m_DefaultReferenceName": "Texture2D_4ef79e9b5e3e473abf150852f1ee2eaa", + "m_OverrideReferenceName": "_MaskMap", + "m_GeneratePropertyBlock": true, + "m_Precision": 0, + "overrideHLSLDeclaration": false, + "hlslDeclarationOverride": 0, + "m_Hidden": false, + "m_Value": { + "m_SerializedTexture": "{\"texture\":{\"instanceID\":0}}", + "m_Guid": "" + }, + "m_Modifiable": true, + "m_DefaultType": 0 +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicValueMaterialSlot", + "m_ObjectId": "4f2d617b37f746f284e4dfe07ef81f72", + "m_Id": 0, + "m_DisplayName": "A", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "A", + "m_StageCapability": 3, + "m_Value": { + "e00": 0.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 0.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 0.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 0.0 + }, + "m_DefaultValue": { + "e00": 1.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 1.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 1.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.KeywordNode", + "m_ObjectId": "4f74e65e559a414caef040647a6517ce", + "m_Group": { + "m_Id": "f9a36441a7674212a626b4e29ac4024e" + }, + "m_Name": "Is Head", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -159.9999237060547, + "y": 39.00004577636719, + "width": 135.0, + "height": 118.00000762939453 + } + }, + "m_Slots": [ + { + "m_Id": "7fe0d92f36a0453dbdb794d34fad1cb9" + }, + { + "m_Id": "7eecf860a85240dba440643599fd8135" + }, + { + "m_Id": "e97a748e1fff420fa01450f86c5a0fb7" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_Keyword": { + "m_Id": "4479b5f90a784db6b7291eba881239a9" + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.ColorRGBMaterialSlot", + "m_ObjectId": "4fbf6229bad74e91afb7ff4f2a7f0018", + "m_Id": 0, + "m_DisplayName": "Emission", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "Emission", + "m_StageCapability": 2, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0 + }, + "m_Labels": [], + "m_ColorMode": 1, + "m_DefaultColor": { + "r": 0.0, + "g": 0.0, + "b": 0.0, + "a": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Internal.Texture2DShaderProperty", + "m_ObjectId": "500ba94d31a4430589839a4ee489195e", + "m_Guid": { + "m_GuidSerialized": "7722d747-1753-4051-ac03-bc427a7e4efc" + }, + "m_Name": "RGBA/NMUIL Mask", + "m_DefaultReferenceName": "", + "m_OverrideReferenceName": "_RGBAMask", + "m_GeneratePropertyBlock": true, + "m_Precision": 0, + "overrideHLSLDeclaration": false, + "hlslDeclarationOverride": 0, + "m_Hidden": false, + "m_Value": { + "m_SerializedTexture": "{\"texture\":{\"instanceID\":0}}", + "m_Guid": "" + }, + "m_Modifiable": true, + "m_DefaultType": 1 +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "516d1bc0967c4d24b23169d4e819ddf9", + "m_Id": 1, + "m_DisplayName": "X", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "X", + "m_StageCapability": 3, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 1, + "m_Type": "UnityEditor.ShaderGraph.Internal.Vector1ShaderProperty", + "m_ObjectId": "5172aa37e7034721a702d02156b0c3a6", + "m_Guid": { + "m_GuidSerialized": "73e30c5a-2038-4d36-841d-8bb8ea0a5ee7" + }, + "m_Name": "Lips Cavity AO", + "m_DefaultReferenceName": "", + "m_OverrideReferenceName": "_LipsCavityAO", + "m_GeneratePropertyBlock": true, + "m_Precision": 0, + "overrideHLSLDeclaration": false, + "hlslDeclarationOverride": 0, + "m_Hidden": false, + "m_Value": 2.5, + "m_FloatType": 1, + "m_RangeValues": { + "x": 0.0, + "y": 5.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "530f0c109bb5439c9271a9f33fb2b22c", + "m_Id": 1, + "m_DisplayName": "", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "53acf58404e74f82a59485242edce7da", + "m_Id": 0, + "m_DisplayName": "Mouth/G Scatter Scale", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "53da2d36048349d9a2949b75e0122804", + "m_Id": 4, + "m_DisplayName": "R", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "R", + "m_StageCapability": 2, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.PowerNode", + "m_ObjectId": "53dba8790d2442ed8f1b1de382253a0e", + "m_Group": { + "m_Id": "66c69fb10be74462b9dfdbda883bd934" + }, + "m_Name": "Power", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -2155.0, + "y": -181.99998474121095, + "width": 126.00000762939453, + "height": 118.00000762939453 + } + }, + "m_Slots": [ + { + "m_Id": "1bd571593dad401bb7989b84e4e7618f" + }, + { + "m_Id": "67ad59bcd1bc468e8ffdb0ff5dd815d1" + }, + { + "m_Id": "191e915f49e24dfcace38066cf12bd48" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "546334f7078549df9ed981c8e26c23b5", + "m_Id": 0, + "m_DisplayName": "", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "547377dca39c41e09bae114510db1a87", + "m_Id": 0, + "m_DisplayName": "Base", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "Base", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "54d535b7368c4a89a598835dffe7911c", + "m_Id": 2, + "m_DisplayName": "Y", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "Y", + "m_StageCapability": 3, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [ + "Y" + ] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "5608685f8fa04124b51f5a4ca9cc179b", + "m_Id": 0, + "m_DisplayName": "Micro Normal Tiling", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "563200795e744005b668ac534af54996", + "m_Id": 1, + "m_DisplayName": "On", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "On", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Texture2DMaterialSlot", + "m_ObjectId": "565c01cd27814834acd27d2472d0033f", + "m_Id": 0, + "m_DisplayName": "Diffuse Map", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_BareResource": false +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicValueMaterialSlot", + "m_ObjectId": "56d70a68c7554d11a583f6ed0aa4083c", + "m_Id": 1, + "m_DisplayName": "B", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "B", + "m_StageCapability": 3, + "m_Value": { + "e00": 2.0, + "e01": 2.0, + "e02": 2.0, + "e03": 2.0, + "e10": 2.0, + "e11": 2.0, + "e12": 2.0, + "e13": 2.0, + "e20": 2.0, + "e21": 2.0, + "e22": 2.0, + "e23": 2.0, + "e30": 2.0, + "e31": 2.0, + "e32": 2.0, + "e33": 2.0 + }, + "m_DefaultValue": { + "e00": 1.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 1.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 1.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.RedirectNodeData", + "m_ObjectId": "57155e8356c9460d9ba3eae891883065", + "m_Group": { + "m_Id": "dfa824146c2f43d5a5ea6bd8b9c3463a" + }, + "m_Name": "Redirect Node", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -4615.0, + "y": 682.9998779296875, + "width": 56.0, + "height": 24.0 + } + }, + "m_Slots": [ + { + "m_Id": "3edc70b7a09341289b41280ab3454925" + }, + { + "m_Id": "ee3ab1ccb0b24074a91a736c76fdc04b" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "5767323a8a0945d382ebb8f13d3c1188", + "m_Id": 1, + "m_DisplayName": "", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.SampleTexture2DNode", + "m_ObjectId": "57d17176266344f3bdf544fcd3993330", + "m_Group": { + "m_Id": "063dd08ef7054b98834ef43a93ef035d" + }, + "m_Name": "Sample Texture 2D", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -1790.0, + "y": -1398.0, + "width": 184.0, + "height": 253.00001525878907 + } + }, + "m_Slots": [ + { + "m_Id": "e02a692b96b546ac8c43ece35b3d68d0" + }, + { + "m_Id": "98f73fc382f648f99bbc5b95ad0e2072" + }, + { + "m_Id": "fe165afcc73d41289342c986c308f461" + }, + { + "m_Id": "f6cc7e8352fd4fdf93be133b5c0a5226" + }, + { + "m_Id": "dd81cdb3e3c14eadaeb77b468f1348c1" + }, + { + "m_Id": "f83484ce0dc3434192636d37b20b951d" + }, + { + "m_Id": "2d09a2a1464e4042993ea2181230532c" + }, + { + "m_Id": "cd7f93e374a743b5b562bcd4d7cbe682" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_TextureType": 0, + "m_NormalMapSpace": 0 +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.SamplerStateMaterialSlot", + "m_ObjectId": "5826ab701e7448659bcf0714cf1a7a5e", + "m_Id": 3, + "m_DisplayName": "Sampler", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "Sampler", + "m_StageCapability": 3, + "m_BareResource": false +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.PropertyNode", + "m_ObjectId": "5829e6acf7d8498c8a97e0b64f4f7bed", + "m_Group": { + "m_Id": "cb23790c1b9143928df829b7a26d1423" + }, + "m_Name": "Property", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -5255.0, + "y": 1346.9998779296875, + "width": 227.00001525878907, + "height": 34.0 + } + }, + "m_Slots": [ + { + "m_Id": "58e349bc5a1542e0bd3c1efb480dc8c3" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_Property": { + "m_Id": "73d5befbcccc4534aa3c49586ca61402" + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "58e349bc5a1542e0bd3c1efb480dc8c3", + "m_Id": 0, + "m_DisplayName": "Inner Lid/A Smoothness Mod", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicValueMaterialSlot", + "m_ObjectId": "5967fb250f654a76a95a1760aa2aa663", + "m_Id": 1, + "m_DisplayName": "B", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "B", + "m_StageCapability": 3, + "m_Value": { + "e00": 2.0, + "e01": 2.0, + "e02": 2.0, + "e03": 2.0, + "e10": 2.0, + "e11": 2.0, + "e12": 2.0, + "e13": 2.0, + "e20": 2.0, + "e21": 2.0, + "e22": 2.0, + "e23": 2.0, + "e30": 2.0, + "e31": 2.0, + "e32": 2.0, + "e33": 2.0 + }, + "m_DefaultValue": { + "e00": 1.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 1.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 1.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "597d96c22619414c8ab2a5c6652137eb", + "m_Id": 0, + "m_DisplayName": "", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "59af546e75fe4911b6c1ab6694ef23c9", + "m_Id": 4, + "m_DisplayName": "W", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "W", + "m_StageCapability": 3, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [ + "W" + ] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector3MaterialSlot", + "m_ObjectId": "59c97f8e8e844cf28a41d80c5328b750", + "m_Id": 0, + "m_DisplayName": "In", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "In", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 1.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0 + }, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.GroupData", + "m_ObjectId": "5afd5b10bac94af98e61ab4df0f1d432", + "m_Title": "Micro Smoothness & Scatter Mask Combine", + "m_Position": { + "x": -3924.0, + "y": 277.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.PropertyNode", + "m_ObjectId": "5b5d90ab491f441884a78ece78c6e7a1", + "m_Group": { + "m_Id": "c39c85064c8b4914bb957db1b59e0e49" + }, + "m_Name": "Property", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -1641.0, + "y": 2896.0, + "width": 195.00001525878907, + "height": 34.0 + } + }, + "m_Slots": [ + { + "m_Id": "315af748590c43e98863cdc26b38904f" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_Property": { + "m_Id": "c70d342b1a0b4d6bbf1ff3c98fd338ea" + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector4Node", + "m_ObjectId": "5b77a116b0324bf3a9ff4a6fbd7be00e", + "m_Group": { + "m_Id": "cb23790c1b9143928df829b7a26d1423" + }, + "m_Name": "Vector 4", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -4962.0, + "y": 1245.0, + "width": 131.0, + "height": 149.0 + } + }, + "m_Slots": [ + { + "m_Id": "acfbabbe6e0747cd98a736d2a5248d34" + }, + { + "m_Id": "00fc4f6ddbc44cffb8cf67dc13aa9e7c" + }, + { + "m_Id": "7ea06866cbfa41c5976a74c381b5b164" + }, + { + "m_Id": "bb31313b4f7b4258b65e560ccb4020cf" + }, + { + "m_Id": "9c974e3b5e5343099d49bec01c0b803b" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 1, + "m_Type": "UnityEditor.ShaderGraph.Internal.Vector1ShaderProperty", + "m_ObjectId": "5c244cc3e1824793bbb81324a733903c", + "m_Guid": { + "m_GuidSerialized": "1a48d4ed-570f-462b-86dd-91a71e85496a" + }, + "m_Name": "Mouth/G Scatter Scale", + "m_DefaultReferenceName": "", + "m_OverrideReferenceName": "_GScatterScale", + "m_GeneratePropertyBlock": true, + "m_Precision": 0, + "overrideHLSLDeclaration": false, + "hlslDeclarationOverride": 0, + "m_Hidden": false, + "m_Value": 1.0, + "m_FloatType": 1, + "m_RangeValues": { + "x": 0.0, + "y": 2.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.PropertyNode", + "m_ObjectId": "5c71ced646a0493ea0562df9d7a1ec33", + "m_Group": { + "m_Id": "dfa824146c2f43d5a5ea6bd8b9c3463a" + }, + "m_Name": "Property", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -4954.0, + "y": 518.0, + "width": 198.00001525878907, + "height": 34.0 + } + }, + "m_Slots": [ + { + "m_Id": "a5a001c420774cd2b675799c215dd46c" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_Property": { + "m_Id": "4bbc052da7aa4bb59c0765662e464374" + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "5cfb509a08ad43ab9a35ca03537ef270", + "m_Id": 0, + "m_DisplayName": "A", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "A", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.SampleTexture2DNode", + "m_ObjectId": "5e600846744441f691aacca6271d740a", + "m_Group": { + "m_Id": "9a9b9423c348490d8c6550520a46754b" + }, + "m_Name": "Sample Texture 2D", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -1148.0, + "y": -926.0, + "width": 184.0, + "height": 253.00001525878907 + } + }, + "m_Slots": [ + { + "m_Id": "3ff0a4ef798b42fa80b0a932530531a2" + }, + { + "m_Id": "53da2d36048349d9a2949b75e0122804" + }, + { + "m_Id": "32adb951b7c34c899a609927b1208e67" + }, + { + "m_Id": "e9d33e371c984ef093e8e959a305fb9d" + }, + { + "m_Id": "8c1c6384ef2e4d30821d5703c4f5a865" + }, + { + "m_Id": "0559f5b0e7274ee09cdcddde77d06b3d" + }, + { + "m_Id": "fe9bcc80f8e24f968b8fe8afe3f3ab9e" + }, + { + "m_Id": "ff0815a316df4c70a19309d6d2f6daeb" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_TextureType": 0, + "m_NormalMapSpace": 0 +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "5e7090bd17ba46b1b7c9bce897a803b1", + "m_Id": 2, + "m_DisplayName": "G", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "G", + "m_StageCapability": 3, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.Rendering.HighDefinition.ShaderGraph.SystemData", + "m_ObjectId": "5e856e0c3b704d14a6c36b84bf8d78f6", + "m_MaterialNeedsUpdateHash": 530, + "m_SurfaceType": 0, + "m_RenderingPass": 1, + "m_BlendMode": 0, + "m_ZTest": 4, + "m_ZWrite": false, + "m_TransparentCullMode": 2, + "m_OpaqueCullMode": 2, + "m_SortPriority": 0, + "m_AlphaTest": false, + "m_TransparentDepthPrepass": false, + "m_TransparentDepthPostpass": false, + "m_SupportLodCrossFade": false, + "m_DoubleSidedMode": 0, + "m_DOTSInstancing": false, + "m_Version": 0, + "m_FirstTimeMigrationExecuted": true, + "inspectorFoldoutMask": 9 +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "5ea5986fe4424371b5ab1740f6e5e570", + "m_Id": 6, + "m_DisplayName": "B", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "B", + "m_StageCapability": 2, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector4MaterialSlot", + "m_ObjectId": "5f09a07b549d4957ba2a6965373163f3", + "m_Id": 0, + "m_DisplayName": "Out", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "5f285cf6e93d448cb5c6ea67e742007d", + "m_Id": 0, + "m_DisplayName": "Upper Lid/B Smoothness Mod", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "5f2bbaecc908441384a1272f3179437f", + "m_Id": 0, + "m_DisplayName": "A", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "A", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "600c30467017413596e51d0ec93b6338", + "m_Id": 0, + "m_DisplayName": "Upper Lip Scatter Scale", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "60d1bdfe086c42fab4ebe271f252a091", + "m_Id": 7, + "m_DisplayName": "A", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "A", + "m_StageCapability": 2, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "6113c1fd69f245d4a66862ce1c3c8f41", + "m_Id": 0, + "m_DisplayName": "Upper Lid/B Smoothness Mod", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Texture2DInputMaterialSlot", + "m_ObjectId": "6176c27a8edf4b18856f209e42b8d163", + "m_Id": 1, + "m_DisplayName": "Texture", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "Texture", + "m_StageCapability": 3, + "m_BareResource": false, + "m_Texture": { + "m_SerializedTexture": "{\"texture\":{\"instanceID\":0}}", + "m_Guid": "" + }, + "m_DefaultType": 0 +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "62146672be544ee490b73a99ef55aba1", + "m_Id": 1, + "m_DisplayName": "R", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "R", + "m_StageCapability": 3, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.OneMinusNode", + "m_ObjectId": "627a6231a44a450daea568ab3d65e599", + "m_Group": { + "m_Id": "7e0bc17feda14e9686f73d30823bef26" + }, + "m_Name": "One Minus", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -980.0001220703125, + "y": 657.0, + "width": 128.0, + "height": 94.0 + } + }, + "m_Slots": [ + { + "m_Id": "3ed5515d3a0d4580ac6215bc07afbe14" + }, + { + "m_Id": "fb16df88280a4452ab1f3673bd754881" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "62cce88aaad1405d9a4f9103c020132e", + "m_Id": 6, + "m_DisplayName": "B", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "B", + "m_StageCapability": 2, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "631afc5ff5154c97bbba0b1040e8cca5", + "m_Id": 0, + "m_DisplayName": "Mouth/G Smoothness Mod", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Texture2DMaterialSlot", + "m_ObjectId": "63ebe719b3a04613a7ac7add1a0be657", + "m_Id": 0, + "m_DisplayName": "Thickness Map", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_BareResource": false +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector4MaterialSlot", + "m_ObjectId": "64a83542b6d843c7b637379509d8a3cf", + "m_Id": 0, + "m_DisplayName": "RGBA", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "RGBA", + "m_StageCapability": 2, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.Rendering.HighDefinition.ShaderGraph.HDLitSubTarget", + "m_ObjectId": "650ef699f8534d05b11661f3db2c1e50" +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.PropertyNode", + "m_ObjectId": "66179ca98b2a453b960048dd690efe80", + "m_Group": { + "m_Id": "3cd206490c954ca5a821100d4380764f" + }, + "m_Name": "Property", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -3114.0, + "y": 735.0000610351563, + "width": 139.0, + "height": 34.0 + } + }, + "m_Slots": [ + { + "m_Id": "49685b48928947cd8c266ae2ac7de7c4" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_Property": { + "m_Id": "4ef79e9b5e3e473abf150852f1ee2eaa" + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.GroupData", + "m_ObjectId": "66c69fb10be74462b9dfdbda883bd934", + "m_Title": "Head Cavity Mask", + "m_Position": { + "x": -3240.0, + "y": -613.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.RedirectNodeData", + "m_ObjectId": "678c1a3aa5044ec5ba32ead9f37e83db", + "m_Group": { + "m_Id": "dfa824146c2f43d5a5ea6bd8b9c3463a" + }, + "m_Name": "Redirect Node", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -4897.0, + "y": 682.9998779296875, + "width": 56.0, + "height": 24.0 + } + }, + "m_Slots": [ + { + "m_Id": "83ee37c0b7bc44f99fb9103a68e5a5c4" + }, + { + "m_Id": "bd27c39e1f39416f9127a46121d626f1" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "67ad59bcd1bc468e8ffdb0ff5dd815d1", + "m_Id": 1, + "m_DisplayName": "B", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "B", + "m_StageCapability": 3, + "m_Value": { + "x": 2.5, + "y": 2.0, + "z": 2.0, + "w": 2.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.RedirectNodeData", + "m_ObjectId": "67af7fa748e34ea1b3e235d0cafc0af4", + "m_Group": { + "m_Id": "dfa824146c2f43d5a5ea6bd8b9c3463a" + }, + "m_Name": "Redirect Node", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -5445.0, + "y": -56.00008010864258, + "width": 56.0, + "height": 24.0 + } + }, + "m_Slots": [ + { + "m_Id": "ee215b26074e4dcc8abfd2ffc197aaa2" + }, + { + "m_Id": "0a097787cd474a819a023f25002203f6" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.MultiplyNode", + "m_ObjectId": "67bfdd4a87d54c4eb0e6fd97ea8bde3b", + "m_Group": { + "m_Id": "66c69fb10be74462b9dfdbda883bd934" + }, + "m_Name": "Multiply", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -1767.0, + "y": -298.0000305175781, + "width": 126.0, + "height": 117.99999237060547 + } + }, + "m_Slots": [ + { + "m_Id": "bd4a31a592364967a4f65d6d51ef8b2b" + }, + { + "m_Id": "05a08ecd924a44bba69d2b0cef175cec" + }, + { + "m_Id": "b3ba3eca0edb4f438315fa68a4c6327a" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "67ce2d247d3e4a07aad4c63cea64571d", + "m_Id": 0, + "m_DisplayName": "Ear Scatter Scale", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Texture2DMaterialSlot", + "m_ObjectId": "67f3c5040dff441a98156cb5eda89ac3", + "m_Id": 0, + "m_DisplayName": "Micro Normal Map", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_BareResource": false +} + +{ + "m_SGVersion": 1, + "m_Type": "UnityEditor.ShaderGraph.CustomFunctionNode", + "m_ObjectId": "6829c94d9a2c4e83bf28f1f2c0c38d78", + "m_Group": { + "m_Id": "cb23790c1b9143928df829b7a26d1423" + }, + "m_Name": "BodyMask (Custom Function)", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -4287.0, + "y": 963.9999389648438, + "width": 235.0, + "height": 190.0 + } + }, + "m_Slots": [ + { + "m_Id": "342fb2c74a0745c9912bc08443777606" + }, + { + "m_Id": "12e263ae9342430fbd23ddd2c8f51ea8" + }, + { + "m_Id": "2a44eebe53c34fd688481ea636e72502" + }, + { + "m_Id": "f14dfbec05c94c2db512559daa14ad34" + }, + { + "m_Id": "bcff3bd536c7417aa929d67434fc2af0" + }, + { + "m_Id": "3ee6739c842f4fa196fda9c1b2d0a599" + }, + { + "m_Id": "fb2aef27282447deb8bbb701f6c568f4" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_SourceType": 1, + "m_FunctionName": "BodyMask", + "m_FunctionSource": "", + "m_FunctionBody": "float mask = saturate(In1.r + In1.g + In1.b + In1.a);\r\nfloat unmask = 1.0 - mask;\r\n\r\nfloat4 ms = In1 * Mod1;\r\nSmoothnessMod = ms.x + ms.y + ms.z + ms.w + (UMMS * unmask);\n\r\nfloat4 ss = In1 * Scatter1;\r\nScatterMask = ss.x + ss.y + ss.z + ss.w + (UMSS * unmask);" +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "687b7b8b4ab2496bb2affcdeeeea0305", + "m_Id": 7, + "m_DisplayName": "A", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "A", + "m_StageCapability": 2, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "688faa8da3b14091a4958198db5bea66", + "m_Id": 1, + "m_DisplayName": "Blend", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "Blend", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Texture2DMaterialSlot", + "m_ObjectId": "68cdfea8b0024f65a81894ca6b214a69", + "m_Id": 0, + "m_DisplayName": "Diffuse Map", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_BareResource": false +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "6900b1e0fc0b422b8af2eebacbad2380", + "m_Id": 2, + "m_DisplayName": "Y", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "Y", + "m_StageCapability": 3, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [ + "Y" + ] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicValueMaterialSlot", + "m_ObjectId": "6949bd2eabcd4e10a82a6f570a9bdfc3", + "m_Id": 2, + "m_DisplayName": "Out", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": { + "e00": 0.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 0.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 0.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 0.0 + }, + "m_DefaultValue": { + "e00": 1.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 1.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 1.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.PropertyNode", + "m_ObjectId": "69822902c84c428080db9893d32ee267", + "m_Group": { + "m_Id": "ef85247de4c745dcbc6ddca88875b14d" + }, + "m_Name": "Property", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -1571.999755859375, + "y": 1484.0, + "width": 148.99998474121095, + "height": 33.999996185302737 + } + }, + "m_Slots": [ + { + "m_Id": "7002af4c98ac4f479b13782f0e1a1cdb" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_Property": { + "m_Id": "8a49d2f872e946d4a29e2030ee291584" + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "6987bd0f82084c918b15e6d4ad38a8af", + "m_Id": 4, + "m_DisplayName": "W", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "W", + "m_StageCapability": 3, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [ + "W" + ] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector4MaterialSlot", + "m_ObjectId": "69d54d6c4ba64a468f042e25e1f1a0ca", + "m_Id": 0, + "m_DisplayName": "RGBA", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "RGBA", + "m_StageCapability": 2, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector3MaterialSlot", + "m_ObjectId": "69d93e6f052745178a36317d34d8efd0", + "m_Id": 0, + "m_DisplayName": "A", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "A", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 1.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0 + }, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.BlockNode", + "m_ObjectId": "6a4b619cae09428e850340b327dc2247", + "m_Group": { + "m_Id": "" + }, + "m_Name": "SurfaceDescription.Smoothness", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": 596.0, + "y": 544.0, + "width": 200.00001525878907, + "height": 41.0 + } + }, + "m_Slots": [ + { + "m_Id": "0d28e9b96829486b9a93fb4b4493ec53" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_SerializedDescriptor": "SurfaceDescription.Smoothness" +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Internal.Texture2DShaderProperty", + "m_ObjectId": "6a6959874a9c4ee382311d4d6f1c7f76", + "m_Guid": { + "m_GuidSerialized": "4057e40a-a150-44de-9642-4c2096efd5ca" + }, + "m_Name": "Thickness Map", + "m_DefaultReferenceName": "Texture2D_6a6959874a9c4ee382311d4d6f1c7f76", + "m_OverrideReferenceName": "_ThicknessMap", + "m_GeneratePropertyBlock": true, + "m_Precision": 0, + "overrideHLSLDeclaration": false, + "hlslDeclarationOverride": 0, + "m_Hidden": false, + "m_Value": { + "m_SerializedTexture": "{\"texture\":{\"instanceID\":0}}", + "m_Guid": "" + }, + "m_Modifiable": true, + "m_DefaultType": 0 +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.PropertyNode", + "m_ObjectId": "6b1bfcb0a944448491e4361744eadcad", + "m_Group": { + "m_Id": "dfa824146c2f43d5a5ea6bd8b9c3463a" + }, + "m_Name": "Property", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -4961.0, + "y": 368.9999694824219, + "width": 205.0, + "height": 34.0 + } + }, + "m_Slots": [ + { + "m_Id": "3e9175b413cd41c38eab6fa851e47c7b" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_Property": { + "m_Id": "8f920b195f6f4ae79f14b6daf5d7a75d" + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.BlockNode", + "m_ObjectId": "6b280d605cf34b63ae417129545c2f7d", + "m_Group": { + "m_Id": "" + }, + "m_Name": "SurfaceDescription.Occlusion", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": 599.0, + "y": 286.0, + "width": 200.0, + "height": 41.0 + } + }, + "m_Slots": [ + { + "m_Id": "b7bc60a4dd2f4474b6ee37d8ae231bc3" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_SerializedDescriptor": "SurfaceDescription.Occlusion" +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.AddNode", + "m_ObjectId": "6bd5468e24044965901c2f8235874ad4", + "m_Group": { + "m_Id": "da79511a40004c349d114e88532d1e86" + }, + "m_Name": "Add", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -790.0001220703125, + "y": 1071.0, + "width": 126.0, + "height": 118.0 + } + }, + "m_Slots": [ + { + "m_Id": "5cfb509a08ad43ab9a35ca03537ef270" + }, + { + "m_Id": "4a8082a47b0245d995015f80ed9085b6" + }, + { + "m_Id": "2d00f62acd904c94b88139b3936f5d00" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "6bec06617c55433a86183662f587ba04", + "m_Id": 1, + "m_DisplayName": "", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Internal.Texture2DShaderProperty", + "m_ObjectId": "6d2408803a794f2e9368d5529b79a574", + "m_Guid": { + "m_GuidSerialized": "6b8dd5b3-e04a-4e6c-b8b8-f3e9ef85e56e" + }, + "m_Name": "Micro Normal Map", + "m_DefaultReferenceName": "Texture2D_6d2408803a794f2e9368d5529b79a574", + "m_OverrideReferenceName": "_MicroNormalMap", + "m_GeneratePropertyBlock": true, + "m_Precision": 0, + "overrideHLSLDeclaration": false, + "hlslDeclarationOverride": 0, + "m_Hidden": false, + "m_Value": { + "m_SerializedTexture": "{\"texture\":{\"instanceID\":0}}", + "m_Guid": "" + }, + "m_Modifiable": true, + "m_DefaultType": 0 +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "6dcbda6993304137a1f8f543f3a5e43f", + "m_Id": 0, + "m_DisplayName": "Normal Blend Strength (Head)", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "6e188f2f78af432dbb36b20ec758c9dc", + "m_Id": 7, + "m_DisplayName": "A", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "A", + "m_StageCapability": 2, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.SamplerStateMaterialSlot", + "m_ObjectId": "6e44eca753194908a0cea9c7b05a1cbd", + "m_Id": 1, + "m_DisplayName": "", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "", + "m_StageCapability": 3, + "m_BareResource": false +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "6e852629012b47a5b5d989e41236bfe0", + "m_Id": 4, + "m_DisplayName": "W", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "W", + "m_StageCapability": 3, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [ + "W" + ] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.StickyNoteData", + "m_ObjectId": "6f29e5b195f94b39825562b57958989a", + "m_Title": "MNAO Map", + "m_Content": "R - mouth cavity mask\nG - mouth gradient\nB - nostril gradient\nA - lip gradient", + "m_TextSize": 0, + "m_Theme": 0, + "m_Position": { + "serializedVersion": "2", + "x": -2967.0, + "y": -554.0, + "width": 200.0, + "height": 110.0 + }, + "m_Group": { + "m_Id": "66c69fb10be74462b9dfdbda883bd934" + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Texture2DMaterialSlot", + "m_ObjectId": "7002af4c98ac4f479b13782f0e1a1cdb", + "m_Id": 0, + "m_DisplayName": "Normal Map", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_BareResource": false +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "7049a86d23634f3a8ca9fac0128344e9", + "m_Id": 15, + "m_DisplayName": "UMMS", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "UMMS", + "m_StageCapability": 3, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 1, + "m_Type": "UnityEditor.ShaderGraph.Internal.Vector1ShaderProperty", + "m_ObjectId": "7089c3af8c734661957df22d8b965d0c", + "m_Guid": { + "m_GuidSerialized": "13040406-ce0e-43ee-a7e7-73cd51296b1f" + }, + "m_Name": "Color Blend Strength (Head)", + "m_DefaultReferenceName": "Vector1_7089c3af8c734661957df22d8b965d0c", + "m_OverrideReferenceName": "_ColorBlendStrength", + "m_GeneratePropertyBlock": true, + "m_Precision": 0, + "overrideHLSLDeclaration": false, + "hlslDeclarationOverride": 0, + "m_Hidden": false, + "m_Value": 0.5, + "m_FloatType": 1, + "m_RangeValues": { + "x": 0.0, + "y": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicValueMaterialSlot", + "m_ObjectId": "711e4a3e376d4478891865ba58e5d57e", + "m_Id": 2, + "m_DisplayName": "Out", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": { + "e00": 0.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 0.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 0.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 0.0 + }, + "m_DefaultValue": { + "e00": 1.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 1.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 1.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector3MaterialSlot", + "m_ObjectId": "71842e43cbf0437480a255269101cb72", + "m_Id": 2, + "m_DisplayName": "Out", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0 + }, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.RedirectNodeData", + "m_ObjectId": "7197fa9eff284d16b2d3d70d424e637a", + "m_Group": { + "m_Id": "dfa824146c2f43d5a5ea6bd8b9c3463a" + }, + "m_Name": "Redirect Node", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -4897.0, + "y": 729.0, + "width": 56.0, + "height": 24.0 + } + }, + "m_Slots": [ + { + "m_Id": "78fcb2e65cda4582918ca82a93211151" + }, + { + "m_Id": "32c9c8124f1d4c23a2e1e4cbf1d00fbd" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.RedirectNodeData", + "m_ObjectId": "726753be6bb047f896bf629f180df013", + "m_Group": { + "m_Id": "dfa824146c2f43d5a5ea6bd8b9c3463a" + }, + "m_Name": "Redirect Node", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -4615.0, + "y": 158.99996948242188, + "width": 56.0, + "height": 24.0 + } + }, + "m_Slots": [ + { + "m_Id": "3f512c43b1ab463b89c3b482a631dd13" + }, + { + "m_Id": "9750f667182e4d00b10fd2f434688dd8" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicValueMaterialSlot", + "m_ObjectId": "72ce712583814f84822a85a8dcbc5699", + "m_Id": 2, + "m_DisplayName": "Out", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": { + "e00": 0.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 0.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 0.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 0.0 + }, + "m_DefaultValue": { + "e00": 1.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 1.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 1.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 1.0 + } +} + +{ + "m_SGVersion": 1, + "m_Type": "UnityEditor.ShaderGraph.Internal.Vector1ShaderProperty", + "m_ObjectId": "73d5befbcccc4534aa3c49586ca61402", + "m_Guid": { + "m_GuidSerialized": "e8a8dce4-b19d-40e3-b9f2-b699418c6650" + }, + "m_Name": "Inner Lid/A Smoothness Mod", + "m_DefaultReferenceName": "", + "m_OverrideReferenceName": "_ASmoothnessMod", + "m_GeneratePropertyBlock": true, + "m_Precision": 0, + "overrideHLSLDeclaration": false, + "hlslDeclarationOverride": 0, + "m_Hidden": false, + "m_Value": 0.0, + "m_FloatType": 1, + "m_RangeValues": { + "x": -1.5, + "y": 1.5 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.UVMaterialSlot", + "m_ObjectId": "7441ca030e3b43e3a61d7932a08fcf81", + "m_Id": 2, + "m_DisplayName": "UV", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "UV", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0 + }, + "m_Labels": [], + "m_Channel": 0 +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.UVMaterialSlot", + "m_ObjectId": "74584acee8b94a7a94948b1b5a7094a4", + "m_Id": 2, + "m_DisplayName": "UV", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "UV", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0 + }, + "m_Labels": [], + "m_Channel": 0 +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.ColorRGBMaterialSlot", + "m_ObjectId": "745ea487c66c466f84d2c16a08c4b1b6", + "m_Id": 0, + "m_DisplayName": "Base Color", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "BaseColor", + "m_StageCapability": 2, + "m_Value": { + "x": 0.5, + "y": 0.5, + "z": 0.5 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0 + }, + "m_Labels": [], + "m_ColorMode": 0, + "m_DefaultColor": { + "r": 0.5, + "g": 0.5, + "b": 0.5, + "a": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "7471d8f34a6047678811773da95dd15a", + "m_Id": 3, + "m_DisplayName": "Z", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "Z", + "m_StageCapability": 3, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [ + "Z" + ] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector4Node", + "m_ObjectId": "74c7f8c267824f2c8b0ca2fe1be022b7", + "m_Group": { + "m_Id": "cb23790c1b9143928df829b7a26d1423" + }, + "m_Name": "Vector 4", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -4962.0, + "y": 1394.0, + "width": 131.0, + "height": 149.0 + } + }, + "m_Slots": [ + { + "m_Id": "516d1bc0967c4d24b23169d4e819ddf9" + }, + { + "m_Id": "8129602064014625abfdcb937f1119ee" + }, + { + "m_Id": "eee3f57a4736440085a28d696808b920" + }, + { + "m_Id": "99ead2a5aae24c8581c6e77dbabebe5f" + }, + { + "m_Id": "9e78528ebece4ca9bd35139fa6d1372c" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Texture2DInputMaterialSlot", + "m_ObjectId": "74d1ebe2a75744a385fdceebc89e0bf7", + "m_Id": 1, + "m_DisplayName": "Texture", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "Texture", + "m_StageCapability": 3, + "m_BareResource": false, + "m_Texture": { + "m_SerializedTexture": "{\"texture\":{\"instanceID\":0}}", + "m_Guid": "" + }, + "m_DefaultType": 3 +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "74f2c0e90a354438929337b3ec279b9c", + "m_Id": 6, + "m_DisplayName": "B", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "B", + "m_StageCapability": 2, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector4MaterialSlot", + "m_ObjectId": "751b7b23dcf04a738c068d047d632741", + "m_Id": 0, + "m_DisplayName": "RGBA", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "RGBA", + "m_StageCapability": 2, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.RedirectNodeData", + "m_ObjectId": "752c6f7e5a64401783aef6ba46c5907f", + "m_Group": { + "m_Id": "f56aec43c38a433ca25a9aab19b2e18b" + }, + "m_Name": "Redirect Node", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -1830.0, + "y": 1278.0, + "width": 56.000003814697269, + "height": 24.000001907348634 + } + }, + "m_Slots": [ + { + "m_Id": "3c55dbafb6a64d44812a529932b5620e" + }, + { + "m_Id": "a67c9e6bed1842f4b0199c07e09baea0" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.PropertyNode", + "m_ObjectId": "76c23cf23e734562b54dc8d34763eadf", + "m_Group": { + "m_Id": "7e0bc17feda14e9686f73d30823bef26" + }, + "m_Name": "Property", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -1803.9998779296875, + "y": 657.0000610351563, + "width": 164.0, + "height": 34.0 + } + }, + "m_Slots": [ + { + "m_Id": "63ebe719b3a04613a7ac7add1a0be657" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_Property": { + "m_Id": "6a6959874a9c4ee382311d4d6f1c7f76" + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "7700ac8514144e75956f81002597b33e", + "m_Id": 6, + "m_DisplayName": "B", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "B", + "m_StageCapability": 2, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.SamplerStateMaterialSlot", + "m_ObjectId": "780f271d73f64e4297adcfa728a69bad", + "m_Id": 3, + "m_DisplayName": "Sampler", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "Sampler", + "m_StageCapability": 3, + "m_BareResource": false +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "7815477c477c4768ba8b407ecd90a927", + "m_Id": 4, + "m_DisplayName": "W", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "W", + "m_StageCapability": 3, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [ + "W" + ] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicValueMaterialSlot", + "m_ObjectId": "782a837085ed47e68824a838329a24b7", + "m_Id": 0, + "m_DisplayName": "A", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "A", + "m_StageCapability": 3, + "m_Value": { + "e00": 0.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 0.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 0.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 0.0 + }, + "m_DefaultValue": { + "e00": 1.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 1.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 1.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "784dfbda34cb491aa18d22a388dac528", + "m_Id": 1, + "m_DisplayName": "Out", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector4MaterialSlot", + "m_ObjectId": "78d8c7ac4d3a4344bed88b41e88a7523", + "m_Id": 0, + "m_DisplayName": "Out", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "78fcb2e65cda4582918ca82a93211151", + "m_Id": 0, + "m_DisplayName": "", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "7a7c989c7ed640799ec5da82e08b7d8b", + "m_Id": 0, + "m_DisplayName": "Nose/R Scatter Scale", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.PropertyNode", + "m_ObjectId": "7c140dfa3ad541778295a2628ecf3520", + "m_Group": { + "m_Id": "dfa824146c2f43d5a5ea6bd8b9c3463a" + }, + "m_Name": "Property", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -4966.0, + "y": 216.99993896484376, + "width": 210.0, + "height": 34.0 + } + }, + "m_Slots": [ + { + "m_Id": "e3b06bda84974a839aa6157bb6b02e78" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_Property": { + "m_Id": "23347c24053e478b8cfdb9644cccccaf" + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector4MaterialSlot", + "m_ObjectId": "7d80173f61844d72948b4e2a6404ddf0", + "m_Id": 10, + "m_DisplayName": "Scatter1", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "Scatter1", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.GroupData", + "m_ObjectId": "7e0bc17feda14e9686f73d30823bef26", + "m_Title": "Subsurface Scattering & Transmission Thickness", + "m_Position": { + "x": -1834.0, + "y": 281.0000305175781 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "7ea06866cbfa41c5976a74c381b5b164", + "m_Id": 3, + "m_DisplayName": "Z", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "Z", + "m_StageCapability": 3, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [ + "Z" + ] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "7eecf860a85240dba440643599fd8135", + "m_Id": 1, + "m_DisplayName": "On", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "On", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "7fe0d92f36a0453dbdb794d34fad1cb9", + "m_Id": 0, + "m_DisplayName": "Out", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "801ca5524c6a4b998d2f32c5dd11ec00", + "m_Id": 1, + "m_DisplayName": "", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "802d8ab1ca68407c805992c3cc6cc797", + "m_Id": 2, + "m_DisplayName": "Y", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "Y", + "m_StageCapability": 3, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [ + "Y" + ] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Texture2DInputMaterialSlot", + "m_ObjectId": "80937093d31f4240acfac03d78580480", + "m_Id": 1, + "m_DisplayName": "Texture", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "Texture", + "m_StageCapability": 3, + "m_BareResource": false, + "m_Texture": { + "m_SerializedTexture": "{\"texture\":{\"instanceID\":0}}", + "m_Guid": "" + }, + "m_DefaultType": 0 +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "8129602064014625abfdcb937f1119ee", + "m_Id": 2, + "m_DisplayName": "Y", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "Y", + "m_StageCapability": 3, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [ + "Y" + ] +} + +{ + "m_SGVersion": 1, + "m_Type": "UnityEditor.ShaderGraph.Internal.Vector1ShaderProperty", + "m_ObjectId": "833ac99096aa4e25ac67e1440763f977", + "m_Guid": { + "m_GuidSerialized": "2f975da3-1ae4-4732-8c0f-1b73c27343dd" + }, + "m_Name": "Smoothness Power", + "m_DefaultReferenceName": "", + "m_OverrideReferenceName": "_SmoothnessPower", + "m_GeneratePropertyBlock": true, + "m_Precision": 0, + "overrideHLSLDeclaration": false, + "hlslDeclarationOverride": 0, + "m_Hidden": false, + "m_Value": 1.0, + "m_FloatType": 1, + "m_RangeValues": { + "x": 0.5, + "y": 2.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "833d7e6a9bcd446f99b67b6cbd31446b", + "m_Id": 1, + "m_DisplayName": "X", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "X", + "m_StageCapability": 3, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicValueMaterialSlot", + "m_ObjectId": "833e26b13f814b739d5516eb6b94c3c0", + "m_Id": 0, + "m_DisplayName": "A", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "A", + "m_StageCapability": 3, + "m_Value": { + "e00": 0.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 0.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 0.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 0.0 + }, + "m_DefaultValue": { + "e00": 1.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 1.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 1.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.SampleTexture2DNode", + "m_ObjectId": "8360103f39bf4473b53bff12b89d4193", + "m_Group": { + "m_Id": "66c69fb10be74462b9dfdbda883bd934" + }, + "m_Name": "Sample Texture 2D", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -2972.0, + "y": -376.9999694824219, + "width": 184.0, + "height": 253.00001525878907 + } + }, + "m_Slots": [ + { + "m_Id": "465e315e462143fc807a7b9a4c29d2bd" + }, + { + "m_Id": "a86b47514163421d8b05b187898c2a47" + }, + { + "m_Id": "33cd59ca32c444f0a0912f3daa9403ab" + }, + { + "m_Id": "01ed385bc89446c5b327cacc69bcce37" + }, + { + "m_Id": "60d1bdfe086c42fab4ebe271f252a091" + }, + { + "m_Id": "144e3366a62e4ce39bb941e6eef5bbe6" + }, + { + "m_Id": "3f02984ee456476b86071667e9c321eb" + }, + { + "m_Id": "d679ce9b5aea4015b15f95e2e892a932" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_TextureType": 0, + "m_NormalMapSpace": 0 +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "83ee37c0b7bc44f99fb9103a68e5a5c4", + "m_Id": 0, + "m_DisplayName": "", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.SampleTexture2DNode", + "m_ObjectId": "847ac5df0b2d4dd58b05ed5100fd2d88", + "m_Group": { + "m_Id": "063dd08ef7054b98834ef43a93ef035d" + }, + "m_Name": "Sample Texture 2D", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -1790.0, + "y": -1670.0, + "width": 184.0, + "height": 253.00001525878907 + } + }, + "m_Slots": [ + { + "m_Id": "df0dc984590847b19bd2f24e1aba8374" + }, + { + "m_Id": "2b081408a7e24e398594d062ea1a971f" + }, + { + "m_Id": "39a1b3de165b4ff6beecaebd677c6e3a" + }, + { + "m_Id": "1d1ca274b5fe42e69ce56945c39a8ea7" + }, + { + "m_Id": "687b7b8b4ab2496bb2affcdeeeea0305" + }, + { + "m_Id": "40411d53b935493097fbc12e892291fa" + }, + { + "m_Id": "7441ca030e3b43e3a61d7932a08fcf81" + }, + { + "m_Id": "780f271d73f64e4297adcfa728a69bad" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_TextureType": 0, + "m_NormalMapSpace": 0 +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Texture2DMaterialSlot", + "m_ObjectId": "84a278ec2cbb499fa6157d16923afda1", + "m_Id": 0, + "m_DisplayName": "Subsurface Map", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_BareResource": false +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "84dc0cfb436548b5b6322ae3547f92c3", + "m_Id": 0, + "m_DisplayName": "Mouth/G Scatter Scale", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.MultiplyNode", + "m_ObjectId": "84f1f5cdd3724f5398e1a2c6b9bd0cd8", + "m_Group": { + "m_Id": "9077599ecffb44679d301bdc68b79f81" + }, + "m_Name": "Multiply", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -592.9999389648438, + "y": 379.0, + "width": 126.00000762939453, + "height": 118.0 + } + }, + "m_Slots": [ + { + "m_Id": "782a837085ed47e68824a838329a24b7" + }, + { + "m_Id": "5967fb250f654a76a95a1760aa2aa663" + }, + { + "m_Id": "6949bd2eabcd4e10a82a6f570a9bdfc3" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "850d7cf1555940c0baf75aa1333db9aa", + "m_Id": 14, + "m_DisplayName": "ScatterMask", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "ScatterMask", + "m_StageCapability": 3, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "85170a86e8d0471a823cab0978c7bb38", + "m_Id": 0, + "m_DisplayName": "Out", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "858a17c61a794a5d85c8187664ecbfc6", + "m_Id": 1, + "m_DisplayName": "", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.SamplerStateMaterialSlot", + "m_ObjectId": "859c3811943c4b02896b724448c90800", + "m_Id": 1, + "m_DisplayName": "", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "", + "m_StageCapability": 3, + "m_BareResource": false +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "863b853f19434a53bd7d61ac14edb3ee", + "m_Id": 0, + "m_DisplayName": "Out", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.SamplerStateMaterialSlot", + "m_ObjectId": "870f6ba0c76349d39b41b9222af45f3a", + "m_Id": 0, + "m_DisplayName": "", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "", + "m_StageCapability": 3, + "m_BareResource": false +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "87bd634cfab446d0a5d1b2d12267d918", + "m_Id": 1, + "m_DisplayName": "B", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "B", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.MultiplyNode", + "m_ObjectId": "88099319861e4e23be99db174b2b7c9e", + "m_Group": { + "m_Id": "5afd5b10bac94af98e61ab4df0f1d432" + }, + "m_Name": "Multiply", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -3516.000244140625, + "y": 294.0000305175781, + "width": 126.00000762939453, + "height": 118.0 + } + }, + "m_Slots": [ + { + "m_Id": "e7fcccc1875d4914841bc5cf71fa7fdf" + }, + { + "m_Id": "b74e5b3f23db4cf7b246fe3da3919441" + }, + { + "m_Id": "72ce712583814f84822a85a8dcbc5699" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.SamplerStateMaterialSlot", + "m_ObjectId": "886088b6c7a14bd8903dcc64845691de", + "m_Id": 1, + "m_DisplayName": "", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "", + "m_StageCapability": 3, + "m_BareResource": false +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "88df3c9762cd417f9a56746f48f9289e", + "m_Id": 3, + "m_DisplayName": "Out", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.Rendering.HighDefinition.ShaderGraph.BuiltinData", + "m_ObjectId": "88f0b3d71738482fb6273b754134b4dd", + "m_Distortion": false, + "m_DistortionMode": 0, + "m_DistortionDepthTest": true, + "m_AddPrecomputedVelocity": false, + "m_TransparentWritesMotionVec": false, + "m_AlphaToMask": false, + "m_DepthOffset": false, + "m_TransparencyFog": true, + "m_AlphaTestShadow": false, + "m_BackThenFrontRendering": false, + "m_TransparentDepthPrepass": false, + "m_TransparentDepthPostpass": false, + "m_SupportLodCrossFade": false +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "89181465bdb746559e49854f2eeca903", + "m_Id": 1, + "m_DisplayName": "B", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "B", + "m_StageCapability": 3, + "m_Value": { + "x": 2.0, + "y": 2.0, + "z": 2.0, + "w": 2.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "899ac35f1d074b8ba17c6cedd02aed08", + "m_Id": 5, + "m_DisplayName": "G", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "G", + "m_StageCapability": 2, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector2MaterialSlot", + "m_ObjectId": "89d785e9bb6c413687505ab305a7ebf9", + "m_Id": 3, + "m_DisplayName": "Out", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0 + }, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Internal.Texture2DShaderProperty", + "m_ObjectId": "8a49d2f872e946d4a29e2030ee291584", + "m_Guid": { + "m_GuidSerialized": "79f607da-c2f1-46b1-8320-f91a0aef3386" + }, + "m_Name": "Normal Map", + "m_DefaultReferenceName": "Texture2D_8a49d2f872e946d4a29e2030ee291584", + "m_OverrideReferenceName": "_NormalMap", + "m_GeneratePropertyBlock": true, + "m_Precision": 0, + "overrideHLSLDeclaration": false, + "hlslDeclarationOverride": 0, + "m_Hidden": false, + "m_Value": { + "m_SerializedTexture": "{\"texture\":{\"instanceID\":0}}", + "m_Guid": "" + }, + "m_Modifiable": true, + "m_DefaultType": 0 +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "8a6a303a66f34aaea8fd6e5cb568a39b", + "m_Id": 5, + "m_DisplayName": "G", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "G", + "m_StageCapability": 2, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.BlockNode", + "m_ObjectId": "8a7ae7a881424567bd38f733cff73869", + "m_Group": { + "m_Id": "" + }, + "m_Name": "SurfaceDescription.BaseColor", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": 0.0, + "y": 0.0, + "width": 0.0, + "height": 0.0 + } + }, + "m_Slots": [ + { + "m_Id": "745ea487c66c466f84d2c16a08c4b1b6" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_SerializedDescriptor": "SurfaceDescription.BaseColor" +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "8b6b1d9fa04d45dbb74a9973878960aa", + "m_Id": 0, + "m_DisplayName": "Unmasked Smoothness Mod", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "8c1c6384ef2e4d30821d5703c4f5a865", + "m_Id": 7, + "m_DisplayName": "A", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "A", + "m_StageCapability": 2, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "8c8679659b1c423da2705f4192a9518b", + "m_Id": 1, + "m_DisplayName": "On", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "On", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.BlockNode", + "m_ObjectId": "8d0e91598db04dc39429e4727f60af22", + "m_Group": { + "m_Id": "" + }, + "m_Name": "SurfaceDescription.Thickness", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": 0.0, + "y": 0.0, + "width": 0.0, + "height": 0.0 + } + }, + "m_Slots": [ + { + "m_Id": "e51e934d740f4369a721de0c664eeee0" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_SerializedDescriptor": "SurfaceDescription.Thickness" +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "8d73d89b0a7f48d1bbe48f87e5f35a33", + "m_Id": 6, + "m_DisplayName": "B", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "B", + "m_StageCapability": 2, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "8db68f4f3e7641dca12cfa564f74dc6e", + "m_Id": 4, + "m_DisplayName": "R", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "R", + "m_StageCapability": 2, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "8dc56439c1ea4c6281d29c6e7bc64a4d", + "m_Id": 2, + "m_DisplayName": "Y", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "Y", + "m_StageCapability": 3, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [ + "Y" + ] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "8f40ac1493a94bdfbdd325a66dd1ffd3", + "m_Id": 5, + "m_DisplayName": "G", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "G", + "m_StageCapability": 2, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "8f548b1b59b143b5ae7436740ad9a91a", + "m_Id": 0, + "m_DisplayName": "Nose/R Scatter Scale", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.PropertyNode", + "m_ObjectId": "8f8ca0a3b0dd4e448dbb945df2bfa639", + "m_Group": { + "m_Id": "cb23790c1b9143928df829b7a26d1423" + }, + "m_Name": "Property", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -5246.0, + "y": 1279.0, + "width": 218.0, + "height": 34.0 + } + }, + "m_Slots": [ + { + "m_Id": "2b709efed97245e39e8efd16cce3a25e" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_Property": { + "m_Id": "f59399cdc25c46fc8f26233a7f05270f" + } +} + +{ + "m_SGVersion": 1, + "m_Type": "UnityEditor.ShaderGraph.Internal.Vector1ShaderProperty", + "m_ObjectId": "8f920b195f6f4ae79f14b6daf5d7a75d", + "m_Guid": { + "m_GuidSerialized": "c8b8780f-e412-4038-a1f8-1aad50f378a6" + }, + "m_Name": "Cheek Smoothness Mod", + "m_DefaultReferenceName": "", + "m_OverrideReferenceName": "_CheekSmoothnessMod", + "m_GeneratePropertyBlock": true, + "m_Precision": 0, + "overrideHLSLDeclaration": false, + "hlslDeclarationOverride": 0, + "m_Hidden": false, + "m_Value": 0.0, + "m_FloatType": 1, + "m_RangeValues": { + "x": -1.5, + "y": 1.5 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.GroupData", + "m_ObjectId": "9077599ecffb44679d301bdc68b79f81", + "m_Title": "Subsurface Scatter Scale", + "m_Position": { + "x": -770.9998168945313, + "y": 320.0 + } +} + +{ + "m_SGVersion": 1, + "m_Type": "UnityEditor.ShaderGraph.Internal.Vector1ShaderProperty", + "m_ObjectId": "90d2f8ddb28645b0bddff4de92e61369", + "m_Guid": { + "m_GuidSerialized": "0a220a60-4052-4e71-a51d-3bd326106298" + }, + "m_Name": "Smoothness Max", + "m_DefaultReferenceName": "Vector1_90d2f8ddb28645b0bddff4de92e61369", + "m_OverrideReferenceName": "_SmoothnessMax", + "m_GeneratePropertyBlock": true, + "m_Precision": 0, + "overrideHLSLDeclaration": false, + "hlslDeclarationOverride": 0, + "m_Hidden": false, + "m_Value": 0.800000011920929, + "m_FloatType": 1, + "m_RangeValues": { + "x": 0.0, + "y": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "90d9869551714e4b9137db8a78c67ea2", + "m_Id": 1, + "m_DisplayName": "X", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "X", + "m_StageCapability": 3, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "90e122d7b5aa42dba9440db15c0d6b9f", + "m_Id": 6, + "m_DisplayName": "B", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "B", + "m_StageCapability": 2, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.KeywordNode", + "m_ObjectId": "91518443319044bc8e4fd05de7e2581b", + "m_Group": { + "m_Id": "5afd5b10bac94af98e61ab4df0f1d432" + }, + "m_Name": "Is Head", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -3837.000244140625, + "y": 344.0, + "width": 135.0, + "height": 118.0 + } + }, + "m_Slots": [ + { + "m_Id": "85170a86e8d0471a823cab0978c7bb38" + }, + { + "m_Id": "563200795e744005b668ac534af54996" + }, + { + "m_Id": "a288db79022a4528b3043ea47e064cea" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_Keyword": { + "m_Id": "4479b5f90a784db6b7291eba881239a9" + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.PropertyNode", + "m_ObjectId": "91850bdf7dcc4bf499f0b38e269d38f1", + "m_Group": { + "m_Id": "dfa824146c2f43d5a5ea6bd8b9c3463a" + }, + "m_Name": "Property", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -5417.0, + "y": -402.0, + "width": 184.0, + "height": 34.0 + } + }, + "m_Slots": [ + { + "m_Id": "d3e255ddbc22463499a344692822cea5" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_Property": { + "m_Id": "500ba94d31a4430589839a4ee489195e" + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.PropertyNode", + "m_ObjectId": "9203aadcc7e34fcbb60c753b4a4bd252", + "m_Group": { + "m_Id": "c39c85064c8b4914bb957db1b59e0e49" + }, + "m_Name": "Property", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -1693.9998779296875, + "y": 2533.0, + "width": 182.0, + "height": 34.0 + } + }, + "m_Slots": [ + { + "m_Id": "67f3c5040dff441a98156cb5eda89ac3" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_Property": { + "m_Id": "6d2408803a794f2e9368d5529b79a574" + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.PropertyNode", + "m_ObjectId": "92460f8b665b4a03bb23e7fe80bdff90", + "m_Group": { + "m_Id": "c39c85064c8b4914bb957db1b59e0e49" + }, + "m_Name": "Property", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -2006.9998779296875, + "y": 2647.000244140625, + "width": 179.0, + "height": 34.0 + } + }, + "m_Slots": [ + { + "m_Id": "5608685f8fa04124b51f5a4ca9cc179b" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_Property": { + "m_Id": "c4024195aefa495695710ffb5997a875" + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "92b3e601c9d54050b5e693c0bdeddb43", + "m_Id": 2, + "m_DisplayName": "Y", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "Y", + "m_StageCapability": 3, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [ + "Y" + ] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.RedirectNodeData", + "m_ObjectId": "92c4cda2a4a24f8eab60734f342fe4b7", + "m_Group": { + "m_Id": "dfa824146c2f43d5a5ea6bd8b9c3463a" + }, + "m_Name": "Redirect Node", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -4897.0, + "y": 704.9998779296875, + "width": 56.0, + "height": 24.0 + } + }, + "m_Slots": [ + { + "m_Id": "546334f7078549df9ed981c8e26c23b5" + }, + { + "m_Id": "e8ef85abd49b47699cb9ea3faccd627a" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Texture2DInputMaterialSlot", + "m_ObjectId": "934cb2a0d12e441292d9259cc4ca24f9", + "m_Id": 1, + "m_DisplayName": "Texture", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "Texture", + "m_StageCapability": 3, + "m_BareResource": false, + "m_Texture": { + "m_SerializedTexture": "{\"texture\":{\"instanceID\":0}}", + "m_Guid": "" + }, + "m_DefaultType": 0 +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "93535619bc6f4e8aab83bd4126f7843b", + "m_Id": 1, + "m_DisplayName": "", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "93635d08e5684dd08bc9ace175abf670", + "m_Id": 0, + "m_DisplayName": "Micro Smoothness Mod", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "93899d10fa1e4acc903882b2e5f421e2", + "m_Id": 0, + "m_DisplayName": "Upper Lid/B Scatter Scale", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.UVMaterialSlot", + "m_ObjectId": "93c9fb5ea5864c6eaae0cda4f420ff84", + "m_Id": 2, + "m_DisplayName": "UV", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "UV", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0 + }, + "m_Labels": [], + "m_Channel": 0 +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.SamplerStateMaterialSlot", + "m_ObjectId": "944bb55aac11474291c452e1ae6e919e", + "m_Id": 3, + "m_DisplayName": "Sampler", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "Sampler", + "m_StageCapability": 3, + "m_BareResource": false +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "94c83c44ac0b4bc2b6071eac09c7a6cb", + "m_Id": 6, + "m_DisplayName": "B", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "B", + "m_StageCapability": 2, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.PropertyNode", + "m_ObjectId": "953f2f4ce7334fa3b917c18a10d71bca", + "m_Group": { + "m_Id": "66c69fb10be74462b9dfdbda883bd934" + }, + "m_Name": "Property", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -2364.0, + "y": -227.00001525878907, + "width": 165.0, + "height": 34.0 + } + }, + "m_Slots": [ + { + "m_Id": "351cfe5ef83646b6b88dcad462309730" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_Property": { + "m_Id": "d2788286d5f347d4ad6c739e7a423501" + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "955628c8fc1149ecbee2fa9171a57548", + "m_Id": 1, + "m_DisplayName": "X", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "X", + "m_StageCapability": 3, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.NormalBlendNode", + "m_ObjectId": "959bbc37ca814b42be52d1bd1b64e66f", + "m_Group": { + "m_Id": "" + }, + "m_Name": "Normal Blend", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -225.99989318847657, + "y": 1810.0001220703125, + "width": 145.00001525878907, + "height": 154.0 + } + }, + "m_Slots": [ + { + "m_Id": "a004a2846d3d495287310bdf7e8a3185" + }, + { + "m_Id": "09847344f8004a26bdad187ff3b528cd" + }, + { + "m_Id": "410bebff5a4c4691b70fcbc06f01c0af" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_BlendMode": 0 +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.PropertyNode", + "m_ObjectId": "959ff1148b3349e48ee64a4e9b62185f", + "m_Group": { + "m_Id": "cb23790c1b9143928df829b7a26d1423" + }, + "m_Name": "Property", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -5237.0, + "y": 1462.0, + "width": 209.0, + "height": 34.0 + } + }, + "m_Slots": [ + { + "m_Id": "1c6c411c5130458f84cb5a96efc1686e" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_Property": { + "m_Id": "2aff406bc0ff49feab0b75f503b042f0" + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "95c802a64e6b43cd8bf621d61a790809", + "m_Id": 0, + "m_DisplayName": "", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.PropertyNode", + "m_ObjectId": "968eb1260de247a6ae11d93ffb62c370", + "m_Group": { + "m_Id": "dfa824146c2f43d5a5ea6bd8b9c3463a" + }, + "m_Name": "Property", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -5406.0, + "y": 695.0, + "width": 173.00001525878907, + "height": 34.0 + } + }, + "m_Slots": [ + { + "m_Id": "ffa946115b334519a2b730b59a68c2a2" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_Property": { + "m_Id": "f9cefb04dde84a5eb85a204200a3f7ca" + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.SamplerStateMaterialSlot", + "m_ObjectId": "96f36c732c8e47529d446f73fa12dd82", + "m_Id": 3, + "m_DisplayName": "Sampler", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "Sampler", + "m_StageCapability": 3, + "m_BareResource": false +} + +{ + "m_SGVersion": 1, + "m_Type": "UnityEditor.ShaderGraph.Internal.Vector1ShaderProperty", + "m_ObjectId": "971eb675ce25417c8f423a316a778a4a", + "m_Guid": { + "m_GuidSerialized": "0668444d-e8f6-4194-9d68-56ac9be39282" + }, + "m_Name": "Nose/R Scatter Scale", + "m_DefaultReferenceName": "", + "m_OverrideReferenceName": "_RScatterScale", + "m_GeneratePropertyBlock": true, + "m_Precision": 0, + "overrideHLSLDeclaration": false, + "hlslDeclarationOverride": 0, + "m_Hidden": false, + "m_Value": 1.0, + "m_FloatType": 1, + "m_RangeValues": { + "x": 0.0, + "y": 2.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "9750f667182e4d00b10fd2f434688dd8", + "m_Id": 1, + "m_DisplayName": "", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.PropertyNode", + "m_ObjectId": "97ed7b3c251541af836cf9d87cf8d819", + "m_Group": { + "m_Id": "dfa824146c2f43d5a5ea6bd8b9c3463a" + }, + "m_Name": "Property", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -5418.0, + "y": -148.0000457763672, + "width": 152.0, + "height": 34.0 + } + }, + "m_Slots": [ + { + "m_Id": "9d1bc44a41ea4b76b9399ad3fe44fd17" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_Property": { + "m_Id": "056e224982a4418783cc9a754ebd4920" + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.RedirectNodeData", + "m_ObjectId": "9837f852dbc445ec90140a8c9089b97b", + "m_Group": { + "m_Id": "" + }, + "m_Name": "Redirect Node", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -347.0001220703125, + "y": -562.0000610351563, + "width": 56.0, + "height": 24.000001907348634 + } + }, + "m_Slots": [ + { + "m_Id": "3c351ac12c7644e888732457ce8c7535" + }, + { + "m_Id": "5767323a8a0945d382ebb8f13d3c1188" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.RedirectNodeData", + "m_ObjectId": "98b06805412b431fa26ce0a69aa10e25", + "m_Group": { + "m_Id": "dfa824146c2f43d5a5ea6bd8b9c3463a" + }, + "m_Name": "Redirect Node", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -5442.0, + "y": -307.00006103515627, + "width": 56.0, + "height": 24.0 + } + }, + "m_Slots": [ + { + "m_Id": "fcff2b7833bf4dee91d80076aa597fb0" + }, + { + "m_Id": "d4ad5f42806a41938118ab2170a6a7d9" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "98f73fc382f648f99bbc5b95ad0e2072", + "m_Id": 4, + "m_DisplayName": "R", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "R", + "m_StageCapability": 2, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "99ead2a5aae24c8581c6e77dbabebe5f", + "m_Id": 4, + "m_DisplayName": "W", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "W", + "m_StageCapability": 3, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [ + "W" + ] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.GroupData", + "m_ObjectId": "9a9b9423c348490d8c6550520a46754b", + "m_Title": "Body/Arm/Leg Skin Color", + "m_Position": { + "x": -1349.0, + "y": -985.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.NormalStrengthNode", + "m_ObjectId": "9abeb9fdadd74574b4e6738541daa06a", + "m_Group": { + "m_Id": "c39c85064c8b4914bb957db1b59e0e49" + }, + "m_Name": "Normal Strength", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -1136.9998779296875, + "y": 2637.0, + "width": 166.0, + "height": 118.0 + } + }, + "m_Slots": [ + { + "m_Id": "fcb5df76291e43d59d9d2c723f6e78ea" + }, + { + "m_Id": "a9f777000a804b03927bcaba4e4f94de" + }, + { + "m_Id": "af803c535eac431a995ab70febb2049e" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.PropertyNode", + "m_ObjectId": "9c2a7707ea0049638b2b48ac9f03a14a", + "m_Group": { + "m_Id": "b9e0ebc6ab434f5786efec886c52a16c" + }, + "m_Name": "Property", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -1293.9998779296875, + "y": 2142.0, + "width": 149.0, + "height": 34.0 + } + }, + "m_Slots": [ + { + "m_Id": "afa3133cd4ef4de99495cb3f4651efd2" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_Property": { + "m_Id": "8a49d2f872e946d4a29e2030ee291584" + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector4MaterialSlot", + "m_ObjectId": "9c974e3b5e5343099d49bec01c0b803b", + "m_Id": 0, + "m_DisplayName": "Out", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.PropertyNode", + "m_ObjectId": "9c9b0e360b6a4384991b11c8bd5d1b90", + "m_Group": { + "m_Id": "dfa824146c2f43d5a5ea6bd8b9c3463a" + }, + "m_Name": "Property", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -4974.0, + "y": 250.9999237060547, + "width": 218.0, + "height": 34.0 + } + }, + "m_Slots": [ + { + "m_Id": "631afc5ff5154c97bbba0b1040e8cca5" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_Property": { + "m_Id": "f59399cdc25c46fc8f26233a7f05270f" + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Texture2DMaterialSlot", + "m_ObjectId": "9d1bc44a41ea4b76b9399ad3fe44fd17", + "m_Id": 0, + "m_DisplayName": "CFULC Mask", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_BareResource": false +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector4MaterialSlot", + "m_ObjectId": "9db27a086e5f4f61a7c29bb49c7f5437", + "m_Id": 0, + "m_DisplayName": "RGBA", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "RGBA", + "m_StageCapability": 2, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector4MaterialSlot", + "m_ObjectId": "9df2b57f5a4e491d8677ab2c0b7bdb9c", + "m_Id": 0, + "m_DisplayName": "RGBA", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "RGBA", + "m_StageCapability": 2, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector4MaterialSlot", + "m_ObjectId": "9e0aba568c2948e3a6b20358bc082038", + "m_Id": 11, + "m_DisplayName": "Scatter2", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "Scatter2", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.PropertyNode", + "m_ObjectId": "9e53b02950a74aaeac3b759695803b53", + "m_Group": { + "m_Id": "dfa824146c2f43d5a5ea6bd8b9c3463a" + }, + "m_Name": "Property", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -4952.0, + "y": 470.9999084472656, + "width": 196.0, + "height": 34.0 + } + }, + "m_Slots": [ + { + "m_Id": "192012161b4245a7b5d79fc52657b74d" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_Property": { + "m_Id": "f72531ddf88f4deeb7706f3ee8563193" + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector4MaterialSlot", + "m_ObjectId": "9e78528ebece4ca9bd35139fa6d1372c", + "m_Id": 0, + "m_DisplayName": "Out", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector3MaterialSlot", + "m_ObjectId": "a004a2846d3d495287310bdf7e8a3185", + "m_Id": 0, + "m_DisplayName": "A", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "A", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 1.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0 + }, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.MultiplyNode", + "m_ObjectId": "a07e525b0a0e425bb3348c1bded0c9b6", + "m_Group": { + "m_Id": "66c69fb10be74462b9dfdbda883bd934" + }, + "m_Name": "Multiply", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -1341.0001220703125, + "y": -182.0, + "width": 126.00000762939453, + "height": 118.00000762939453 + } + }, + "m_Slots": [ + { + "m_Id": "048cb4a590ce4968b7b917a490150ec5" + }, + { + "m_Id": "56d70a68c7554d11a583f6ed0aa4083c" + }, + { + "m_Id": "ba11baca0339432586bbed4ba10ad47f" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 1, + "m_Type": "UnityEditor.ShaderGraph.Internal.Vector1ShaderProperty", + "m_ObjectId": "a0dea5230a33428cb6bffe7ab816e628", + "m_Guid": { + "m_GuidSerialized": "c74f652f-3c85-48e9-8506-0cbd78426a2b" + }, + "m_Name": "Unmasked Scatter Scale", + "m_DefaultReferenceName": "", + "m_OverrideReferenceName": "_UnmaskedScatterScale", + "m_GeneratePropertyBlock": true, + "m_Precision": 0, + "overrideHLSLDeclaration": false, + "hlslDeclarationOverride": 0, + "m_Hidden": false, + "m_Value": 1.0, + "m_FloatType": 1, + "m_RangeValues": { + "x": 0.0, + "y": 2.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "a288db79022a4528b3043ea47e064cea", + "m_Id": 2, + "m_DisplayName": "Off", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "Off", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.SamplerStateMaterialSlot", + "m_ObjectId": "a2d9dba0a09d436f9258d6d6acfd2c3f", + "m_Id": 0, + "m_DisplayName": "Out", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_BareResource": false +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "a3fd7b2e19fc4e95949902ca103e1a30", + "m_Id": 7, + "m_DisplayName": "A", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "A", + "m_StageCapability": 2, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector4MaterialSlot", + "m_ObjectId": "a41bd2d113e74441b095bf1de66ae302", + "m_Id": 0, + "m_DisplayName": "RGBA", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "RGBA", + "m_StageCapability": 2, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector4Node", + "m_ObjectId": "a493db744a314454a97fc48bf63029fa", + "m_Group": { + "m_Id": "dfa824146c2f43d5a5ea6bd8b9c3463a" + }, + "m_Name": "Vector 4", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -4961.0, + "y": 63.999900817871097, + "width": 131.0, + "height": 149.0 + } + }, + "m_Slots": [ + { + "m_Id": "833d7e6a9bcd446f99b67b6cbd31446b" + }, + { + "m_Id": "6900b1e0fc0b422b8af2eebacbad2380" + }, + { + "m_Id": "ad1b646a178846de9bdfddfb1483ce0a" + }, + { + "m_Id": "7815477c477c4768ba8b407ecd90a927" + }, + { + "m_Id": "bde4bb65369c477984df0b27f6494bd1" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.RedirectNodeData", + "m_ObjectId": "a5535127f7b24e0cb24732d098701601", + "m_Group": { + "m_Id": "dfa824146c2f43d5a5ea6bd8b9c3463a" + }, + "m_Name": "Redirect Node", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -4615.0, + "y": 110.99996948242188, + "width": 56.0, + "height": 24.0 + } + }, + "m_Slots": [ + { + "m_Id": "e784a6e1ddea4401b1cd88cdc267d374" + }, + { + "m_Id": "1fc42ad5bac146df9339a267cdfdfb03" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "a56d065198b44d74a5c4bb7083ff11eb", + "m_Id": 0, + "m_DisplayName": "Ear Smoothness Mod", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "a5a001c420774cd2b675799c215dd46c", + "m_Id": 0, + "m_DisplayName": "Neck Smoothness Mod", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "a5be9fd94a7f42979450b484d0bf35f1", + "m_Id": 1, + "m_DisplayName": "Min", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "Min", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.SampleTexture2DNode", + "m_ObjectId": "a5dc0c9495c34a1cbc486e1eae20b24a", + "m_Group": { + "m_Id": "ef85247de4c745dcbc6ddca88875b14d" + }, + "m_Name": "Sample Texture 2D", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -1606.999755859375, + "y": 1722.9998779296875, + "width": 184.0, + "height": 252.99998474121095 + } + }, + "m_Slots": [ + { + "m_Id": "9db27a086e5f4f61a7c29bb49c7f5437" + }, + { + "m_Id": "8db68f4f3e7641dca12cfa564f74dc6e" + }, + { + "m_Id": "abd681366440457f8c70c1e555fc11d3" + }, + { + "m_Id": "27816559ecca46af9c4e56da83727fd7" + }, + { + "m_Id": "d3cab878627d409aa486976b5e0a63fb" + }, + { + "m_Id": "44ae0b91aec34fc1ac3c082e36065ea1" + }, + { + "m_Id": "02e510ee2ef34b6aa52e075af163f348" + }, + { + "m_Id": "944bb55aac11474291c452e1ae6e919e" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_TextureType": 1, + "m_NormalMapSpace": 0 +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.SampleTexture2DNode", + "m_ObjectId": "a65fd5b8249049cfa4978cb95f2906dd", + "m_Group": { + "m_Id": "dfa824146c2f43d5a5ea6bd8b9c3463a" + }, + "m_Name": "Sample Texture 2D", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -5220.0, + "y": -148.0000457763672, + "width": 184.0, + "height": 252.99998474121095 + } + }, + "m_Slots": [ + { + "m_Id": "9df2b57f5a4e491d8677ab2c0b7bdb9c" + }, + { + "m_Id": "cbe642f7ace24fb6a64095d5d1915fe1" + }, + { + "m_Id": "8a6a303a66f34aaea8fd6e5cb568a39b" + }, + { + "m_Id": "5ea5986fe4424371b5ab1740f6e5e570" + }, + { + "m_Id": "af302df4eb4744f6a316947ac8caf57d" + }, + { + "m_Id": "80937093d31f4240acfac03d78580480" + }, + { + "m_Id": "01a8f5bfdcbf49b89b73d8e8596d4a96" + }, + { + "m_Id": "5826ab701e7448659bcf0714cf1a7a5e" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_TextureType": 0, + "m_NormalMapSpace": 0 +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "a67c9e6bed1842f4b0199c07e09baea0", + "m_Id": 1, + "m_DisplayName": "", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 1, + "m_Type": "UnityEditor.ShaderGraph.Internal.Vector1ShaderProperty", + "m_ObjectId": "a6dd3195bd6d4a298423e889b02d7c82", + "m_Guid": { + "m_GuidSerialized": "207e2751-0d86-4b7c-9142-7c2ec92e6ab9" + }, + "m_Name": "Subsurface Scale", + "m_DefaultReferenceName": "", + "m_OverrideReferenceName": "_SubsurfaceScale", + "m_GeneratePropertyBlock": true, + "m_Precision": 0, + "overrideHLSLDeclaration": false, + "hlslDeclarationOverride": 0, + "m_Hidden": false, + "m_Value": 1.0, + "m_FloatType": 1, + "m_RangeValues": { + "x": 0.0, + "y": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.MultiplyNode", + "m_ObjectId": "a6f6bb8f46874779a5286682c043e521", + "m_Group": { + "m_Id": "d2a14e6d2148432cb883f7e72b690cff" + }, + "m_Name": "Multiply", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -1893.0, + "y": 53.000057220458987, + "width": 126.00000762939453, + "height": 118.00000762939453 + } + }, + "m_Slots": [ + { + "m_Id": "0337e07f559541ec96585a6182657f0a" + }, + { + "m_Id": "bba25f51560c42e58fb9fdf59f6cdf99" + }, + { + "m_Id": "e9b271cd684b4678b3f00c819396e66a" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.RedirectNodeData", + "m_ObjectId": "a702998ed7684a6695b2c1b063948449", + "m_Group": { + "m_Id": "" + }, + "m_Name": "Redirect Node", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -347.0001220703125, + "y": -634.0, + "width": 56.0, + "height": 24.000001907348634 + } + }, + "m_Slots": [ + { + "m_Id": "f3ebff254aee4ffc8cfd7a9480a33238" + }, + { + "m_Id": "e39ef042f42b40f1ade7b7cdaede1b5d" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "a71851b38a2645a9b22b620349ff15df", + "m_Id": 0, + "m_DisplayName": "", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.PowerNode", + "m_ObjectId": "a75487134df7415f955b33cff9f98ab4", + "m_Group": { + "m_Id": "66c69fb10be74462b9dfdbda883bd934" + }, + "m_Name": "Power", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -2155.0, + "y": -420.9999694824219, + "width": 126.00000762939453, + "height": 118.00000762939453 + } + }, + "m_Slots": [ + { + "m_Id": "bf14c6480cc64055b5d6c3e62e17310d" + }, + { + "m_Id": "89181465bdb746559e49854f2eeca903" + }, + { + "m_Id": "daaa1953ccf74241bcd51b7e3d914c19" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.RedirectNodeData", + "m_ObjectId": "a7ef162d13a2481c86a37f4989904269", + "m_Group": { + "m_Id": "f56aec43c38a433ca25a9aab19b2e18b" + }, + "m_Name": "Redirect Node", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -1111.0, + "y": 1278.0, + "width": 56.0, + "height": 24.0 + } + }, + "m_Slots": [ + { + "m_Id": "95c802a64e6b43cd8bf621d61a790809" + }, + { + "m_Id": "3efa8f51ec2c4c22962c1a8468f69d68" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "a83e37a17d1545c29b0437defee3c63f", + "m_Id": 0, + "m_DisplayName": "Mouth Cavity AO", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "a86b47514163421d8b05b187898c2a47", + "m_Id": 4, + "m_DisplayName": "R", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "R", + "m_StageCapability": 2, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "a9f777000a804b03927bcaba4e4f94de", + "m_Id": 1, + "m_DisplayName": "Strength", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "Strength", + "m_StageCapability": 3, + "m_Value": 1.0, + "m_DefaultValue": 1.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.RedirectNodeData", + "m_ObjectId": "aa34ae8be16d4885996fe17a972057f8", + "m_Group": { + "m_Id": "063dd08ef7054b98834ef43a93ef035d" + }, + "m_Name": "Redirect Node", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -655.0000610351563, + "y": -1066.0, + "width": 56.0, + "height": 24.000001907348634 + } + }, + "m_Slots": [ + { + "m_Id": "df7e230e2cde49938e554823b385f06c" + }, + { + "m_Id": "1a09dbf5f5cf4dac8496ffcb3a3088ab" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.StickyNoteData", + "m_ObjectId": "aa6ca9dd588548b692498eb660b00833", + "m_Title": "", + "m_Content": "R = Metallic\nG = AO\nB = Micro Normal Mask\nA = Smoothness", + "m_TextSize": 0, + "m_Theme": 0, + "m_Position": { + "serializedVersion": "2", + "x": -2957.0, + "y": 624.0, + "width": 200.0, + "height": 100.0 + }, + "m_Group": { + "m_Id": "3cd206490c954ca5a821100d4380764f" + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "aa9f7127505c4939873c9702771da1c8", + "m_Id": 2, + "m_DisplayName": "T", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "T", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.GroupData", + "m_ObjectId": "ab191acedb9b44b7b3bbc68b89055a73", + "m_Title": "IsHead Keyword", + "m_Position": { + "x": -695.0, + "y": 1751.393310546875 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "abd681366440457f8c70c1e555fc11d3", + "m_Id": 5, + "m_DisplayName": "G", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "G", + "m_StageCapability": 2, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.ClampNode", + "m_ObjectId": "ac3a80b81e024f529669ce414320f8b0", + "m_Group": { + "m_Id": "66c69fb10be74462b9dfdbda883bd934" + }, + "m_Name": "Clamp", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -2720.0, + "y": -504.0000305175781, + "width": 145.0, + "height": 142.0 + } + }, + "m_Slots": [ + { + "m_Id": "eed2ff4e2c97461bb64d466ea7ff5d1b" + }, + { + "m_Id": "a5be9fd94a7f42979450b484d0bf35f1" + }, + { + "m_Id": "b9ee6dfad58c4e819798f26eaeba6ea3" + }, + { + "m_Id": "1cbd49ba99204373b697c4ab58a7f853" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "ac577c0bf0f64fc28cfec2c15b3edb1b", + "m_Id": 0, + "m_DisplayName": "Cheek Scatter Scale", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "ac761ccfb4db460cbf872e7439eb051e", + "m_Id": 0, + "m_DisplayName": "", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicValueMaterialSlot", + "m_ObjectId": "ace0328dc85b49cb8532e46ed6f51e18", + "m_Id": 0, + "m_DisplayName": "A", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "A", + "m_StageCapability": 3, + "m_Value": { + "e00": 0.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 0.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 0.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 0.0 + }, + "m_DefaultValue": { + "e00": 1.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 1.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 1.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "acfbabbe6e0747cd98a736d2a5248d34", + "m_Id": 1, + "m_DisplayName": "X", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "X", + "m_StageCapability": 3, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "ad1b646a178846de9bdfddfb1483ce0a", + "m_Id": 3, + "m_DisplayName": "Z", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "Z", + "m_StageCapability": 3, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [ + "Z" + ] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicValueMaterialSlot", + "m_ObjectId": "ad33cb57558d417f9569ffd8bee68eb5", + "m_Id": 1, + "m_DisplayName": "B", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "B", + "m_StageCapability": 3, + "m_Value": { + "e00": 2.0, + "e01": 2.0, + "e02": 2.0, + "e03": 2.0, + "e10": 2.0, + "e11": 2.0, + "e12": 2.0, + "e13": 2.0, + "e20": 2.0, + "e21": 2.0, + "e22": 2.0, + "e23": 2.0, + "e30": 2.0, + "e31": 2.0, + "e32": 2.0, + "e33": 2.0 + }, + "m_DefaultValue": { + "e00": 1.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 1.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 1.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "ad4d6c245829480d83cddfc7ba7373f5", + "m_Id": 1, + "m_DisplayName": "X", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "X", + "m_StageCapability": 3, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "ae28ec32b49048588c6ceb48dbe1cbfb", + "m_Id": 4, + "m_DisplayName": "W", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "W", + "m_StageCapability": 3, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [ + "W" + ] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "af1c3e2053234885a04a449a03b4b891", + "m_Id": 0, + "m_DisplayName": "Thickness Scale", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "af302df4eb4744f6a316947ac8caf57d", + "m_Id": 7, + "m_DisplayName": "A", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "A", + "m_StageCapability": 2, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector3MaterialSlot", + "m_ObjectId": "af803c535eac431a995ab70febb2049e", + "m_Id": 2, + "m_DisplayName": "Out", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0 + }, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Texture2DMaterialSlot", + "m_ObjectId": "afa3133cd4ef4de99495cb3f4651efd2", + "m_Id": 0, + "m_DisplayName": "Normal Map", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_BareResource": false +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "afe49abcf9354889acf24c07191e3f82", + "m_Id": 1, + "m_DisplayName": "", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.Rendering.HighDefinition.ShaderGraph.HDLitData", + "m_ObjectId": "b00f1b66025c4b25a6f709e3c0ab54f4", + "m_RayTracing": false, + "m_MaterialType": 1, + "m_RefractionModel": 0, + "m_SSSTransmission": true, + "m_EnergyConservingSpecular": true, + "m_ClearCoat": false +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "b1702efc476344c3960ea02ce540f393", + "m_Id": 0, + "m_DisplayName": "In", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "In", + "m_StageCapability": 3, + "m_Value": { + "x": 1.0, + "y": 1.0, + "z": 1.0, + "w": 1.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "b1d4b45693af46a3a723b2ffb1b8b88a", + "m_Id": 7, + "m_DisplayName": "A", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "A", + "m_StageCapability": 2, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "b3816536558e4d5bb5f5ab8c9171e12c", + "m_Id": 0, + "m_DisplayName": "Upper Lip Smoothness Mod", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicValueMaterialSlot", + "m_ObjectId": "b3ba3eca0edb4f438315fa68a4c6327a", + "m_Id": 2, + "m_DisplayName": "Out", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": { + "e00": 0.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 0.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 0.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 0.0 + }, + "m_DefaultValue": { + "e00": 1.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 1.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 1.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.SamplerStateMaterialSlot", + "m_ObjectId": "b3f9e17afed244f8ba0d3001d6fca640", + "m_Id": 3, + "m_DisplayName": "Sampler", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "Sampler", + "m_StageCapability": 3, + "m_BareResource": false +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.RedirectNodeData", + "m_ObjectId": "b4402ce3ccf04a048863239aedbe87a8", + "m_Group": { + "m_Id": "dfa824146c2f43d5a5ea6bd8b9c3463a" + }, + "m_Name": "Redirect Node", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -4615.0, + "y": 729.0, + "width": 56.0, + "height": 24.0 + } + }, + "m_Slots": [ + { + "m_Id": "a71851b38a2645a9b22b620349ff15df" + }, + { + "m_Id": "801ca5524c6a4b998d2f32c5dd11ec00" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.PropertyNode", + "m_ObjectId": "b5303edc98994295a7b3d47c8554f4eb", + "m_Group": { + "m_Id": "ef85247de4c745dcbc6ddca88875b14d" + }, + "m_Name": "Property", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -1617.999755859375, + "y": 1992.9998779296875, + "width": 231.99998474121095, + "height": 33.999996185302737 + } + }, + "m_Slots": [ + { + "m_Id": "6dcbda6993304137a1f8f543f3a5e43f" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_Property": { + "m_Id": "be9afefb417e4737b75985dc8aaa3962" + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicValueMaterialSlot", + "m_ObjectId": "b5ac1432065540238e51147cdd5998ff", + "m_Id": 2, + "m_DisplayName": "Out", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": { + "e00": 0.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 0.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 0.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 0.0 + }, + "m_DefaultValue": { + "e00": 1.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 1.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 1.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Texture2DMaterialSlot", + "m_ObjectId": "b749ee7701af45a69020770d171d1a51", + "m_Id": 0, + "m_DisplayName": "RGBA/NMUIL Mask", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_BareResource": false +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicValueMaterialSlot", + "m_ObjectId": "b74e5b3f23db4cf7b246fe3da3919441", + "m_Id": 1, + "m_DisplayName": "B", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "B", + "m_StageCapability": 3, + "m_Value": { + "e00": 2.0, + "e01": 2.0, + "e02": 2.0, + "e03": 2.0, + "e10": 2.0, + "e11": 2.0, + "e12": 2.0, + "e13": 2.0, + "e20": 2.0, + "e21": 2.0, + "e22": 2.0, + "e23": 2.0, + "e30": 2.0, + "e31": 2.0, + "e32": 2.0, + "e33": 2.0 + }, + "m_DefaultValue": { + "e00": 1.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 1.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 1.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "b7bc60a4dd2f4474b6ee37d8ae231bc3", + "m_Id": 0, + "m_DisplayName": "Ambient Occlusion", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "Occlusion", + "m_StageCapability": 2, + "m_Value": 1.0, + "m_DefaultValue": 1.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicValueMaterialSlot", + "m_ObjectId": "b7c396adc2074b9e90f2631e905ffdf5", + "m_Id": 1, + "m_DisplayName": "B", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "B", + "m_StageCapability": 3, + "m_Value": { + "e00": 2.0, + "e01": 2.0, + "e02": 2.0, + "e03": 2.0, + "e10": 2.0, + "e11": 2.0, + "e12": 2.0, + "e13": 2.0, + "e20": 2.0, + "e21": 2.0, + "e22": 2.0, + "e23": 2.0, + "e30": 2.0, + "e31": 2.0, + "e32": 2.0, + "e33": 2.0 + }, + "m_DefaultValue": { + "e00": 1.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 1.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 1.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.PropertyNode", + "m_ObjectId": "b7d3ea63e79f48f3a8c42957ac61a8b5", + "m_Group": { + "m_Id": "66c69fb10be74462b9dfdbda883bd934" + }, + "m_Name": "Property", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -2363.0, + "y": -284.0, + "width": 164.0, + "height": 34.0 + } + }, + "m_Slots": [ + { + "m_Id": "a83e37a17d1545c29b0437defee3c63f" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_Property": { + "m_Id": "3ddb1de457ce4a0d84f7586eaac11b9a" + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.PropertyNode", + "m_ObjectId": "b80337ac31e04b05a002e9f81ddbea8c", + "m_Group": { + "m_Id": "cb23790c1b9143928df829b7a26d1423" + }, + "m_Name": "Property", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -5238.0, + "y": 1245.0, + "width": 210.0, + "height": 34.0 + } + }, + "m_Slots": [ + { + "m_Id": "3cb22f2017f24943ac729606ac833859" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_Property": { + "m_Id": "23347c24053e478b8cfdb9644cccccaf" + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.UVMaterialSlot", + "m_ObjectId": "b8864bb29fa0433d9cd5ae242ba02cce", + "m_Id": 2, + "m_DisplayName": "UV", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "UV", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0 + }, + "m_Labels": [], + "m_Channel": 0 +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.RedirectNodeData", + "m_ObjectId": "b8c774fc9cac433b99c4b9b826c29cfd", + "m_Group": { + "m_Id": "" + }, + "m_Name": "Redirect Node", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -347.0001220703125, + "y": -586.0000610351563, + "width": 56.0, + "height": 24.000001907348634 + } + }, + "m_Slots": [ + { + "m_Id": "d70e084a67404dc2bc9f31834bc250d3" + }, + { + "m_Id": "530f0c109bb5439c9271a9f33fb2b22c" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "b8cbf18017a24aa7b494ec5231b60920", + "m_Id": 2, + "m_DisplayName": "Out", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.SplitNode", + "m_ObjectId": "b8dca6839b2546f4add1900701779c26", + "m_Group": { + "m_Id": "66c69fb10be74462b9dfdbda883bd934" + }, + "m_Name": "Split", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -2546.0, + "y": -342.0000305175781, + "width": 120.0, + "height": 149.0 + } + }, + "m_Slots": [ + { + "m_Id": "cd51ae14ea28454faf2bb18eb3edd986" + }, + { + "m_Id": "62146672be544ee490b73a99ef55aba1" + }, + { + "m_Id": "5e7090bd17ba46b1b7c9bce897a803b1" + }, + { + "m_Id": "c1dbebf975594599aa94cdad3afced79" + }, + { + "m_Id": "3ee61b5f19fa4d698aa68fbb921589e0" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.SampleTexture2DNode", + "m_ObjectId": "b8dcd461a8b34ed6b2c77a51052430bb", + "m_Group": { + "m_Id": "b9e0ebc6ab434f5786efec886c52a16c" + }, + "m_Name": "Sample Texture 2D", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -1132.0, + "y": 2131.0, + "width": 184.0, + "height": 252.99998474121095 + } + }, + "m_Slots": [ + { + "m_Id": "751b7b23dcf04a738c068d047d632741" + }, + { + "m_Id": "08ea3079bc4b42ce96fe727e667b8e72" + }, + { + "m_Id": "8f40ac1493a94bdfbdd325a66dd1ffd3" + }, + { + "m_Id": "74f2c0e90a354438929337b3ec279b9c" + }, + { + "m_Id": "e549cd1b33c04ff58c888d33196d6e82" + }, + { + "m_Id": "74d1ebe2a75744a385fdceebc89e0bf7" + }, + { + "m_Id": "b8864bb29fa0433d9cd5ae242ba02cce" + }, + { + "m_Id": "29049c4f567047b7864950da33af235e" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_TextureType": 1, + "m_NormalMapSpace": 0 +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.UVMaterialSlot", + "m_ObjectId": "b959e24d88ea43f5bf4256f07ae90ec0", + "m_Id": 2, + "m_DisplayName": "UV", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "UV", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0 + }, + "m_Labels": [], + "m_Channel": 0 +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.GroupData", + "m_ObjectId": "b9e0ebc6ab434f5786efec886c52a16c", + "m_Title": "Body/Arm/Leg Skin Normal", + "m_Position": { + "x": -1318.9998779296875, + "y": 2072.393310546875 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "b9ee6dfad58c4e819798f26eaeba6ea3", + "m_Id": 2, + "m_DisplayName": "Max", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "Max", + "m_StageCapability": 3, + "m_Value": { + "x": 1.0, + "y": 1.0, + "z": 1.0, + "w": 1.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicValueMaterialSlot", + "m_ObjectId": "ba11baca0339432586bbed4ba10ad47f", + "m_Id": 2, + "m_DisplayName": "Out", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": { + "e00": 0.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 0.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 0.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 0.0 + }, + "m_DefaultValue": { + "e00": 1.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 1.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 1.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.SamplerStateMaterialSlot", + "m_ObjectId": "ba586a643825415d9395e0095ddd8d8a", + "m_Id": 3, + "m_DisplayName": "Sampler", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "Sampler", + "m_StageCapability": 3, + "m_BareResource": false +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "bac1a1097e9c4e0590a6fc721aaf8c06", + "m_Id": 0, + "m_DisplayName": "Out", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "bb31313b4f7b4258b65e560ccb4020cf", + "m_Id": 4, + "m_DisplayName": "W", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "W", + "m_StageCapability": 3, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [ + "W" + ] +} + +{ + "m_SGVersion": 1, + "m_Type": "UnityEditor.ShaderGraph.Internal.Vector1ShaderProperty", + "m_ObjectId": "bb4fd70018f64db2a8ce8eb4c3f1fc66", + "m_Guid": { + "m_GuidSerialized": "5cf3af35-343a-4c50-a72e-e2f2c75853e0" + }, + "m_Name": "Cheek Scatter Scale", + "m_DefaultReferenceName": "", + "m_OverrideReferenceName": "_CheekScatterScale", + "m_GeneratePropertyBlock": true, + "m_Precision": 0, + "overrideHLSLDeclaration": false, + "hlslDeclarationOverride": 0, + "m_Hidden": false, + "m_Value": 1.0, + "m_FloatType": 1, + "m_RangeValues": { + "x": 0.0, + "y": 2.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "bb7bdf3a76704b8db4a45ba32c2e001d", + "m_Id": 3, + "m_DisplayName": "Opacity", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "Opacity", + "m_StageCapability": 3, + "m_Value": 1.0, + "m_DefaultValue": 1.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicValueMaterialSlot", + "m_ObjectId": "bba25f51560c42e58fb9fdf59f6cdf99", + "m_Id": 1, + "m_DisplayName": "B", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "B", + "m_StageCapability": 3, + "m_Value": { + "e00": 2.0, + "e01": 2.0, + "e02": 2.0, + "e03": 2.0, + "e10": 2.0, + "e11": 2.0, + "e12": 2.0, + "e13": 2.0, + "e20": 2.0, + "e21": 2.0, + "e22": 2.0, + "e23": 2.0, + "e30": 2.0, + "e31": 2.0, + "e32": 2.0, + "e33": 2.0 + }, + "m_DefaultValue": { + "e00": 1.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 1.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 1.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.BlockNode", + "m_ObjectId": "bc0c9bafa3544deaaba658da5d1457a2", + "m_Group": { + "m_Id": "" + }, + "m_Name": "SurfaceDescription.NormalTS", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": 584.0, + "y": 602.0000610351563, + "width": 200.00001525878907, + "height": 41.0 + } + }, + "m_Slots": [ + { + "m_Id": "0e03c873ccc040dd8417724de5eaf36d" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_SerializedDescriptor": "SurfaceDescription.NormalTS" +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "bc6e2d6b699e4a54ae4a604b9015969e", + "m_Id": 1, + "m_DisplayName": "Out", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "bcff3bd536c7417aa929d67434fc2af0", + "m_Id": 9, + "m_DisplayName": "UMSS", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "UMSS", + "m_StageCapability": 3, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "bd27c39e1f39416f9127a46121d626f1", + "m_Id": 1, + "m_DisplayName": "", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicValueMaterialSlot", + "m_ObjectId": "bd4a31a592364967a4f65d6d51ef8b2b", + "m_Id": 0, + "m_DisplayName": "A", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "A", + "m_StageCapability": 3, + "m_Value": { + "e00": 0.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 0.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 0.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 0.0 + }, + "m_DefaultValue": { + "e00": 1.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 1.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 1.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector4MaterialSlot", + "m_ObjectId": "bde4bb65369c477984df0b27f6494bd1", + "m_Id": 0, + "m_DisplayName": "Out", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.NormalStrengthNode", + "m_ObjectId": "be0b6de023f04f3c8f86fdf44da92670", + "m_Group": { + "m_Id": "ef85247de4c745dcbc6ddca88875b14d" + }, + "m_Name": "Normal Strength", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -1344.999755859375, + "y": 1836.9998779296875, + "width": 166.0, + "height": 117.99999237060547 + } + }, + "m_Slots": [ + { + "m_Id": "59c97f8e8e844cf28a41d80c5328b750" + }, + { + "m_Id": "2601a264f4d14f4c902f8008895c54cc" + }, + { + "m_Id": "c5a0d33e78f2457389f24400de1c6b51" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 1, + "m_Type": "UnityEditor.ShaderGraph.Internal.Vector1ShaderProperty", + "m_ObjectId": "be9afefb417e4737b75985dc8aaa3962", + "m_Guid": { + "m_GuidSerialized": "66f03f0f-2d93-41ca-8d12-eac83a5628e7" + }, + "m_Name": "Normal Blend Strength (Head)", + "m_DefaultReferenceName": "Vector1_be9afefb417e4737b75985dc8aaa3962", + "m_OverrideReferenceName": "_NormalBlendStrength", + "m_GeneratePropertyBlock": true, + "m_Precision": 0, + "overrideHLSLDeclaration": false, + "hlslDeclarationOverride": 0, + "m_Hidden": false, + "m_Value": 0.5, + "m_FloatType": 1, + "m_RangeValues": { + "x": 0.0, + "y": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "bf14c6480cc64055b5d6c3e62e17310d", + "m_Id": 0, + "m_DisplayName": "A", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "A", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector2MaterialSlot", + "m_ObjectId": "c083ca9475264d81936b2f64c2ae9982", + "m_Id": 2, + "m_DisplayName": "Offset", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "Offset", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0 + }, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "c0d2e3f5038b4df2ab225ad3103ca3fe", + "m_Id": 5, + "m_DisplayName": "G", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "G", + "m_StageCapability": 2, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 1, + "m_Type": "UnityEditor.ShaderGraph.Internal.Vector1ShaderProperty", + "m_ObjectId": "c12e83169aaf40a39eef85aea07d238b", + "m_Guid": { + "m_GuidSerialized": "e3f0749c-9b5a-4f0b-b799-174a5c0b6a9b" + }, + "m_Name": "Inner Lid/A Scatter Scale", + "m_DefaultReferenceName": "", + "m_OverrideReferenceName": "_AScatterScale", + "m_GeneratePropertyBlock": true, + "m_Precision": 0, + "overrideHLSLDeclaration": false, + "hlslDeclarationOverride": 0, + "m_Hidden": false, + "m_Value": 1.0, + "m_FloatType": 1, + "m_RangeValues": { + "x": 0.0, + "y": 2.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "c1dbebf975594599aa94cdad3afced79", + "m_Id": 3, + "m_DisplayName": "B", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "B", + "m_StageCapability": 3, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.AddNode", + "m_ObjectId": "c234d329286d44ecb1b0b7d5805e8726", + "m_Group": { + "m_Id": "5afd5b10bac94af98e61ab4df0f1d432" + }, + "m_Name": "Add", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -3516.000244140625, + "y": 1227.0001220703125, + "width": 126.00000762939453, + "height": 118.0 + } + }, + "m_Slots": [ + { + "m_Id": "2999b99dcc9e47fdba5b859b41e2cce3" + }, + { + "m_Id": "87bd634cfab446d0a5d1b2d12267d918" + }, + { + "m_Id": "420210b0bace45fd9fe7069700274d32" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.GroupData", + "m_ObjectId": "c39c85064c8b4914bb957db1b59e0e49", + "m_Title": "Micro Normal", + "m_Position": { + "x": -2075.0, + "y": 2465.393310546875 + } +} + +{ + "m_SGVersion": 1, + "m_Type": "UnityEditor.ShaderGraph.Internal.Vector1ShaderProperty", + "m_ObjectId": "c4024195aefa495695710ffb5997a875", + "m_Guid": { + "m_GuidSerialized": "c5f39fcf-3943-48fe-ab5c-46ba6c3eeee2" + }, + "m_Name": "Micro Normal Tiling", + "m_DefaultReferenceName": "Vector1_c4024195aefa495695710ffb5997a875", + "m_OverrideReferenceName": "_MicroNormalTiling", + "m_GeneratePropertyBlock": true, + "m_Precision": 0, + "overrideHLSLDeclaration": false, + "hlslDeclarationOverride": 0, + "m_Hidden": false, + "m_Value": 25.0, + "m_FloatType": 1, + "m_RangeValues": { + "x": 0.0, + "y": 50.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "c4665f5d8d5b4498b43072687bee29a3", + "m_Id": 2, + "m_DisplayName": "Off", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "Off", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.PropertyNode", + "m_ObjectId": "c46af3d4a47a4a879990007d0abb9155", + "m_Group": { + "m_Id": "dfa824146c2f43d5a5ea6bd8b9c3463a" + }, + "m_Name": "Property", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -5442.0, + "y": 461.0000305175781, + "width": 209.0, + "height": 34.0 + } + }, + "m_Slots": [ + { + "m_Id": "93899d10fa1e4acc903882b2e5f421e2" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_Property": { + "m_Id": "2aff406bc0ff49feab0b75f503b042f0" + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.PropertyNode", + "m_ObjectId": "c48b0bc83f544969b8903ab18833641f", + "m_Group": { + "m_Id": "ef85247de4c745dcbc6ddca88875b14d" + }, + "m_Name": "Property", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -1868.999755859375, + "y": 1722.9998779296875, + "width": 218.99998474121095, + "height": 33.999996185302737 + } + }, + "m_Slots": [ + { + "m_Id": "f5746ecd4733458d9881a4a7ed8ae69c" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_Property": { + "m_Id": "2cc11af55d6b4faea215407e60307db4" + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.NormalMaterialSlot", + "m_ObjectId": "c4b6c46dc8b348b8a5ecd4e2aead24c0", + "m_Id": 0, + "m_DisplayName": "Bent Normal", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "BentNormal", + "m_StageCapability": 2, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0 + }, + "m_Labels": [], + "m_Space": 3 +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector3MaterialSlot", + "m_ObjectId": "c5a0d33e78f2457389f24400de1c6b51", + "m_Id": 2, + "m_DisplayName": "Out", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0 + }, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "c6062e858d4343e5a5764fb40e7e36a2", + "m_Id": 0, + "m_DisplayName": "Forehead Smoothness Mod", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.UVMaterialSlot", + "m_ObjectId": "c68af561c48d4ea9bc1be4a573395586", + "m_Id": 2, + "m_DisplayName": "UV", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "UV", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0 + }, + "m_Labels": [], + "m_Channel": 0 +} + +{ + "m_SGVersion": 1, + "m_Type": "UnityEditor.ShaderGraph.CustomFunctionNode", + "m_ObjectId": "c6f506199a9c4cdb882b3aebb87c4245", + "m_Group": { + "m_Id": "dfa824146c2f43d5a5ea6bd8b9c3463a" + }, + "m_Name": "HeadMask (Custom Function)", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -4289.00048828125, + "y": 373.0, + "width": 237.0, + "height": 334.0 + } + }, + "m_Slots": [ + { + "m_Id": "fd54d8eb8bd74acba90bdeca7ec6b790" + }, + { + "m_Id": "474330843c344b21a039e14e11acd1db" + }, + { + "m_Id": "2b2b2d07a8f24b6eb6bfeebf714d9597" + }, + { + "m_Id": "2cfe2b87003046fba7904a4c6b6c79dc" + }, + { + "m_Id": "4c2a4014b7ad4035bb8339bd87074c5a" + }, + { + "m_Id": "1ba549139d0549719e0aefced25cc144" + }, + { + "m_Id": "7d80173f61844d72948b4e2a6404ddf0" + }, + { + "m_Id": "9e0aba568c2948e3a6b20358bc082038" + }, + { + "m_Id": "ea8543b1da0c4a21adbcb9d155103c52" + }, + { + "m_Id": "7049a86d23634f3a8ca9fac0128344e9" + }, + { + "m_Id": "f8ae466dedda43058150600807d8ca55" + }, + { + "m_Id": "850d7cf1555940c0baf75aa1333db9aa" + }, + { + "m_Id": "f937fa9c43514a8bbfe3aa630f908f40" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_SourceType": 1, + "m_FunctionName": "HeadMask", + "m_FunctionSource": "", + "m_FunctionBody": "float4 m = In1 + In2 + In3;\nfloat mask = saturate(m.x + m.y + m.z + m.w);\nfloat unmask = 1.0 - mask;\n\nfloat4 ms = (In1 * Mod1) + (In2 * Mod2) + (In3 * Mod3);\nSmoothnessMod = ms.x + ms.y + ms.z + ms.w + (UMMS * unmask);\n\nfloat4 ss = (In1 * Scatter1) + (In2 * Scatter2) + (In3 * Scatter3);\nScatterMask = ss.x + ss.y + ss.z + ss.w + (UMSS * unmask);" +} + +{ + "m_SGVersion": 1, + "m_Type": "UnityEditor.ShaderGraph.Internal.Vector1ShaderProperty", + "m_ObjectId": "c70d342b1a0b4d6bbf1ff3c98fd338ea", + "m_Guid": { + "m_GuidSerialized": "d09cbcc1-0d27-4582-afd2-8528e6e51f97" + }, + "m_Name": "Micro Normal Strength", + "m_DefaultReferenceName": "Vector1_c70d342b1a0b4d6bbf1ff3c98fd338ea", + "m_OverrideReferenceName": "_MicroNormalStrength", + "m_GeneratePropertyBlock": true, + "m_Precision": 0, + "overrideHLSLDeclaration": false, + "hlslDeclarationOverride": 0, + "m_Hidden": false, + "m_Value": 0.5, + "m_FloatType": 1, + "m_RangeValues": { + "x": 0.0, + "y": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector4Node", + "m_ObjectId": "c8762bfc89e1476c9208f214d2cf9621", + "m_Group": { + "m_Id": "dfa824146c2f43d5a5ea6bd8b9c3463a" + }, + "m_Name": "Vector 4", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -5167.0, + "y": 695.0, + "width": 131.0, + "height": 149.0 + } + }, + "m_Slots": [ + { + "m_Id": "90d9869551714e4b9137db8a78c67ea2" + }, + { + "m_Id": "802d8ab1ca68407c805992c3cc6cc797" + }, + { + "m_Id": "7471d8f34a6047678811773da95dd15a" + }, + { + "m_Id": "ae28ec32b49048588c6ceb48dbe1cbfb" + }, + { + "m_Id": "78d8c7ac4d3a4344bed88b41e88a7523" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.RedirectNodeData", + "m_ObjectId": "c87c14db1c69414da7ecf06ddd7254af", + "m_Group": { + "m_Id": "" + }, + "m_Name": "Redirect Node", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -4108.0, + "y": -537.9999389648438, + "width": 56.0, + "height": 24.0 + } + }, + "m_Slots": [ + { + "m_Id": "870f6ba0c76349d39b41b9222af45f3a" + }, + { + "m_Id": "6e44eca753194908a0cea9c7b05a1cbd" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.TangentMaterialSlot", + "m_ObjectId": "c996e165d42c4929928bc49c5e17d734", + "m_Id": 0, + "m_DisplayName": "Tangent", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "Tangent", + "m_StageCapability": 1, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0 + }, + "m_Labels": [], + "m_Space": 0 +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "c9c382f96969430ca6a46ac85b576bb2", + "m_Id": 5, + "m_DisplayName": "G", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "G", + "m_StageCapability": 2, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.SamplerStateMaterialSlot", + "m_ObjectId": "ca0a563b18044b67a8edca0e1b806428", + "m_Id": 0, + "m_DisplayName": "", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "", + "m_StageCapability": 3, + "m_BareResource": false +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.PropertyNode", + "m_ObjectId": "cada9cea9620451d83525a727c0f7769", + "m_Group": { + "m_Id": "f56aec43c38a433ca25a9aab19b2e18b" + }, + "m_Name": "Property", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -1435.0, + "y": 1063.0, + "width": 167.0, + "height": 34.0 + } + }, + "m_Slots": [ + { + "m_Id": "d92360b1e67c416684ce1d28cb4c9c5d" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_Property": { + "m_Id": "90d2f8ddb28645b0bddff4de92e61369" + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.GroupData", + "m_ObjectId": "cb23790c1b9143928df829b7a26d1423", + "m_Title": "Micro Smoothness & Scatter Mask Body", + "m_Position": { + "x": -5471.0, + "y": 904.9998168945313 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Internal.Texture2DShaderProperty", + "m_ObjectId": "cb42572a46a74a588ef3935f3a667eb7", + "m_Guid": { + "m_GuidSerialized": "36af1c96-8f78-4132-a591-a5b10a01324f" + }, + "m_Name": "Diffuse Map", + "m_DefaultReferenceName": "Texture2D_cb42572a46a74a588ef3935f3a667eb7", + "m_OverrideReferenceName": "_DiffuseMap", + "m_GeneratePropertyBlock": true, + "m_Precision": 0, + "overrideHLSLDeclaration": false, + "hlslDeclarationOverride": 0, + "m_Hidden": false, + "m_Value": { + "m_SerializedTexture": "{\"texture\":{\"instanceID\":0}}", + "m_Guid": "" + }, + "m_Modifiable": true, + "m_DefaultType": 0 +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.PositionMaterialSlot", + "m_ObjectId": "cb901263bb9a42489ac84d9e84023477", + "m_Id": 0, + "m_DisplayName": "Position", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "Position", + "m_StageCapability": 1, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0 + }, + "m_Labels": [], + "m_Space": 0 +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "cbd2ba5f22e445698eede034cd03afc3", + "m_Id": 1, + "m_DisplayName": "", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "cbe642f7ace24fb6a64095d5d1915fe1", + "m_Id": 4, + "m_DisplayName": "R", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "R", + "m_StageCapability": 2, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "cc10edbdd1a9484d8ecd726b3b2a9d5e", + "m_Id": 3, + "m_DisplayName": "Z", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "Z", + "m_StageCapability": 3, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [ + "Z" + ] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.UVMaterialSlot", + "m_ObjectId": "cc38707bb3d748838a23f4574a063781", + "m_Id": 2, + "m_DisplayName": "UV", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "UV", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0 + }, + "m_Labels": [], + "m_Channel": 0 +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "cc95f826c4ae496383d43b50bf0a0757", + "m_Id": 4, + "m_DisplayName": "R", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "R", + "m_StageCapability": 2, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "cd51ae14ea28454faf2bb18eb3edd986", + "m_Id": 0, + "m_DisplayName": "In", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "In", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "cd68a4bd5a87465aa9979957b2c99b57", + "m_Id": 2, + "m_DisplayName": "Out", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.SamplerStateMaterialSlot", + "m_ObjectId": "cd7f93e374a743b5b562bcd4d7cbe682", + "m_Id": 3, + "m_DisplayName": "Sampler", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "Sampler", + "m_StageCapability": 3, + "m_BareResource": false +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "cf1f15de83894e24b940127ff7098e7e", + "m_Id": 0, + "m_DisplayName": "Lips Cavity AO", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.SamplerStateMaterialSlot", + "m_ObjectId": "d03b89c54bcd458089f04ed4c0afe8bc", + "m_Id": 3, + "m_DisplayName": "Sampler", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "Sampler", + "m_StageCapability": 3, + "m_BareResource": false +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.PropertyNode", + "m_ObjectId": "d04a1ba74b404509b3874993b5771fe4", + "m_Group": { + "m_Id": "063dd08ef7054b98834ef43a93ef035d" + }, + "m_Name": "Property", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -1986.0, + "y": -1670.0, + "width": 148.0, + "height": 34.0 + } + }, + "m_Slots": [ + { + "m_Id": "565c01cd27814834acd27d2472d0033f" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_Property": { + "m_Id": "cb42572a46a74a588ef3935f3a667eb7" + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.PropertyNode", + "m_ObjectId": "d0f639d2d1ac4285b4ee05ffd5db4009", + "m_Group": { + "m_Id": "063dd08ef7054b98834ef43a93ef035d" + }, + "m_Name": "Property", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -1829.0, + "y": -1131.0, + "width": 223.0, + "height": 34.0 + } + }, + "m_Slots": [ + { + "m_Id": "dbe2f127221f403aab892539351b8ed2" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_Property": { + "m_Id": "7089c3af8c734661957df22d8b965d0c" + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.PropertyNode", + "m_ObjectId": "d12453dda1c34b6f833d8eda4eaf2c27", + "m_Group": { + "m_Id": "dfa824146c2f43d5a5ea6bd8b9c3463a" + }, + "m_Name": "Property", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -4777.0, + "y": 763.0, + "width": 227.00001525878907, + "height": 34.0 + } + }, + "m_Slots": [ + { + "m_Id": "8b6b1d9fa04d45dbb74a9973878960aa" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_Property": { + "m_Id": "1b299f10f9db46719d10fb61b53094c1" + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "d14f2f050ac44a56ba46aef4c4655a49", + "m_Id": 0, + "m_DisplayName": "Unmasked Scatter Scale", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicValueMaterialSlot", + "m_ObjectId": "d1980bb9f451498b87c737f321c2e72a", + "m_Id": 1, + "m_DisplayName": "B", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "B", + "m_StageCapability": 3, + "m_Value": { + "e00": 2.0, + "e01": 2.0, + "e02": 2.0, + "e03": 2.0, + "e10": 2.0, + "e11": 2.0, + "e12": 2.0, + "e13": 2.0, + "e20": 2.0, + "e21": 2.0, + "e22": 2.0, + "e23": 2.0, + "e30": 2.0, + "e31": 2.0, + "e32": 2.0, + "e33": 2.0 + }, + "m_DefaultValue": { + "e00": 1.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 1.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 1.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 1.0 + } +} + +{ + "m_SGVersion": 1, + "m_Type": "UnityEditor.ShaderGraph.Internal.Vector1ShaderProperty", + "m_ObjectId": "d2788286d5f347d4ad6c739e7a423501", + "m_Guid": { + "m_GuidSerialized": "03d22c03-f22b-4667-b043-f6361a393d69" + }, + "m_Name": "Nostril Cavity AO", + "m_DefaultReferenceName": "", + "m_OverrideReferenceName": "_NostrilCavityAO", + "m_GeneratePropertyBlock": true, + "m_Precision": 0, + "overrideHLSLDeclaration": false, + "hlslDeclarationOverride": 0, + "m_Hidden": false, + "m_Value": 2.5, + "m_FloatType": 1, + "m_RangeValues": { + "x": 0.0, + "y": 5.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.GroupData", + "m_ObjectId": "d2a14e6d2148432cb883f7e72b690cff", + "m_Title": "Ambient Occlusion Remapping", + "m_Position": { + "x": -2305.0, + "y": -6.000007629394531 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.PropertyNode", + "m_ObjectId": "d3318e127b3b43748fe6886e280d5ff7", + "m_Group": { + "m_Id": "dfa824146c2f43d5a5ea6bd8b9c3463a" + }, + "m_Name": "Property", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -5429.0, + "y": 579.0000610351563, + "width": 196.0, + "height": 34.0 + } + }, + "m_Slots": [ + { + "m_Id": "ec82bbcd8c6c4c49afbed9510f1406cd" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_Property": { + "m_Id": "43ccb360c88d4573b568d5486e4504e5" + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "d3cab878627d409aa486976b5e0a63fb", + "m_Id": 7, + "m_DisplayName": "A", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "A", + "m_StageCapability": 2, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Texture2DMaterialSlot", + "m_ObjectId": "d3e255ddbc22463499a344692822cea5", + "m_Id": 0, + "m_DisplayName": "RGBA/NMUIL Mask", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_BareResource": false +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.MultiplyNode", + "m_ObjectId": "d487e51cc2ea47f7a3736b88a760f012", + "m_Group": { + "m_Id": "c39c85064c8b4914bb957db1b59e0e49" + }, + "m_Name": "Multiply", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -1405.9998779296875, + "y": 2811.0, + "width": 126.00000762939453, + "height": 118.0 + } + }, + "m_Slots": [ + { + "m_Id": "d993a0ee28674e2fa782c918a03ceebe" + }, + { + "m_Id": "0ff7e0cbcc4147afa6a5e57e00dcc27e" + }, + { + "m_Id": "711e4a3e376d4478891865ba58e5d57e" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.SamplerStateMaterialSlot", + "m_ObjectId": "d4ad5f42806a41938118ab2170a6a7d9", + "m_Id": 1, + "m_DisplayName": "", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "", + "m_StageCapability": 3, + "m_BareResource": false +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector4MaterialSlot", + "m_ObjectId": "d4bcdda4715f41acb0dec6f5f0b399a5", + "m_Id": 0, + "m_DisplayName": "RGBA", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "RGBA", + "m_StageCapability": 2, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.SamplerStateMaterialSlot", + "m_ObjectId": "d55629a774674bdcbc3a5ba1e9e32dc0", + "m_Id": 3, + "m_DisplayName": "Sampler", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "Sampler", + "m_StageCapability": 3, + "m_BareResource": false +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "d55d3c9d3ea44d3c84b03bcfec6ac226", + "m_Id": 3, + "m_DisplayName": "Z", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "Z", + "m_StageCapability": 3, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [ + "Z" + ] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.SamplerStateMaterialSlot", + "m_ObjectId": "d679ce9b5aea4015b15f95e2e892a932", + "m_Id": 3, + "m_DisplayName": "Sampler", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "Sampler", + "m_StageCapability": 3, + "m_BareResource": false +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.RedirectNodeData", + "m_ObjectId": "d689efd5ae68433590c7ff751c0edd9f", + "m_Group": { + "m_Id": "cb23790c1b9143928df829b7a26d1423" + }, + "m_Name": "Redirect Node", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -5446.0, + "y": 1082.0, + "width": 56.0, + "height": 24.0 + } + }, + "m_Slots": [ + { + "m_Id": "ca0a563b18044b67a8edca0e1b806428" + }, + { + "m_Id": "04bc5aa9cb144da6ba346c5a217bce7c" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "d70e084a67404dc2bc9f31834bc250d3", + "m_Id": 0, + "m_DisplayName": "", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.PropertyNode", + "m_ObjectId": "d7abef3c272c480098cee3b4808d7d3f", + "m_Group": { + "m_Id": "dfa824146c2f43d5a5ea6bd8b9c3463a" + }, + "m_Name": "Property", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -4983.0, + "y": 318.9999084472656, + "width": 227.00001525878907, + "height": 34.0 + } + }, + "m_Slots": [ + { + "m_Id": "3ed7d11623c440e78d14cff8a90541ef" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_Property": { + "m_Id": "73d5befbcccc4534aa3c49586ca61402" + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.PowerNode", + "m_ObjectId": "d851bd5557a04ed4b753f5deab9ab7b3", + "m_Group": { + "m_Id": "66c69fb10be74462b9dfdbda883bd934" + }, + "m_Name": "Power", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -2155.0, + "y": -298.0000305175781, + "width": 126.00000762939453, + "height": 118.00000762939453 + } + }, + "m_Slots": [ + { + "m_Id": "5f2bbaecc908441384a1272f3179437f" + }, + { + "m_Id": "0a38a26b7f6443e5a17e47c0484ef2a3" + }, + { + "m_Id": "3259710122434acb8c2cc37879ef7a95" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.SamplerStateMaterialSlot", + "m_ObjectId": "d88def6869fc49d3bc653b65a14f4035", + "m_Id": 0, + "m_DisplayName": "", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "", + "m_StageCapability": 3, + "m_BareResource": false +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "d92360b1e67c416684ce1d28cb4c9c5d", + "m_Id": 0, + "m_DisplayName": "Smoothness Max", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicValueMaterialSlot", + "m_ObjectId": "d993a0ee28674e2fa782c918a03ceebe", + "m_Id": 0, + "m_DisplayName": "A", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "A", + "m_StageCapability": 3, + "m_Value": { + "e00": 0.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 0.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 0.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 0.0 + }, + "m_DefaultValue": { + "e00": 1.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 1.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 1.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector4Node", + "m_ObjectId": "d9fffa5b0642499e9cfb4904fa579915", + "m_Group": { + "m_Id": "dfa824146c2f43d5a5ea6bd8b9c3463a" + }, + "m_Name": "Vector 4", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -4690.0, + "y": 216.99993896484376, + "width": 131.0, + "height": 149.0 + } + }, + "m_Slots": [ + { + "m_Id": "1215ed0b592e4af4b86adbf923212768" + }, + { + "m_Id": "df91a0749bee4bf880f627a67b8931cb" + }, + { + "m_Id": "cc10edbdd1a9484d8ecd726b3b2a9d5e" + }, + { + "m_Id": "6e852629012b47a5b5d989e41236bfe0" + }, + { + "m_Id": "f94a55b9938f414aab6546801672aa84" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Internal.Texture2DShaderProperty", + "m_ObjectId": "da213d6a9621401f9a5ffc93e4383f77", + "m_Guid": { + "m_GuidSerialized": "545ca05a-a357-4462-af83-3e9f5bea1b90" + }, + "m_Name": "Cavity AO Map (Head)", + "m_DefaultReferenceName": "Texture2D_da213d6a9621401f9a5ffc93e4383f77", + "m_OverrideReferenceName": "_MNAOMap", + "m_GeneratePropertyBlock": true, + "m_Precision": 0, + "overrideHLSLDeclaration": false, + "hlslDeclarationOverride": 0, + "m_Hidden": false, + "m_Value": { + "m_SerializedTexture": "{\"texture\":{\"instanceID\":0}}", + "m_Guid": "" + }, + "m_Modifiable": true, + "m_DefaultType": 0 +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "da3d5a689e494e92801f395f3085490f", + "m_Id": 0, + "m_DisplayName": "", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.GroupData", + "m_ObjectId": "da79511a40004c349d114e88532d1e86", + "m_Title": "Micro Smoothness Mod", + "m_Position": { + "x": -1005.0001220703125, + "y": 958.0 + } +} + +{ + "m_SGVersion": 1, + "m_Type": "UnityEditor.ShaderGraph.Internal.Vector1ShaderProperty", + "m_ObjectId": "daa99c4f268449b8a4e69fdaeafcfe49", + "m_Guid": { + "m_GuidSerialized": "b78117bf-f0d9-48f7-8c0e-59b04f502b60" + }, + "m_Name": "Ambient Occlusion Strength", + "m_DefaultReferenceName": "Vector1_daa99c4f268449b8a4e69fdaeafcfe49", + "m_OverrideReferenceName": "_AOStrength", + "m_GeneratePropertyBlock": true, + "m_Precision": 0, + "overrideHLSLDeclaration": false, + "hlslDeclarationOverride": 0, + "m_Hidden": false, + "m_Value": 1.0, + "m_FloatType": 1, + "m_RangeValues": { + "x": 0.0, + "y": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "daaa1953ccf74241bcd51b7e3d914c19", + "m_Id": 2, + "m_DisplayName": "Out", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "dbe2f127221f403aab892539351b8ed2", + "m_Id": 0, + "m_DisplayName": "Color Blend Strength (Head)", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.PropertyNode", + "m_ObjectId": "dbe8c88f1fed41489b58cb2c624b07f5", + "m_Group": { + "m_Id": "dfa824146c2f43d5a5ea6bd8b9c3463a" + }, + "m_Name": "Property", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -5413.0, + "y": 544.9998779296875, + "width": 180.0, + "height": 34.0 + } + }, + "m_Slots": [ + { + "m_Id": "ac577c0bf0f64fc28cfec2c15b3edb1b" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_Property": { + "m_Id": "bb4fd70018f64db2a8ce8eb4c3f1fc66" + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.PropertyNode", + "m_ObjectId": "dccc1e0050614b2398bfce4b52a305ca", + "m_Group": { + "m_Id": "cb23790c1b9143928df829b7a26d1423" + }, + "m_Name": "Property", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -5221.0, + "y": 1428.0, + "width": 193.0, + "height": 34.0 + } + }, + "m_Slots": [ + { + "m_Id": "53acf58404e74f82a59485242edce7da" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_Property": { + "m_Id": "5c244cc3e1824793bbb81324a733903c" + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "dd81cdb3e3c14eadaeb77b468f1348c1", + "m_Id": 7, + "m_DisplayName": "A", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "A", + "m_StageCapability": 2, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "ddf65bdd0922413e97099a575b4186ca", + "m_Id": 1, + "m_DisplayName": "X", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "X", + "m_StageCapability": 3, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector4MaterialSlot", + "m_ObjectId": "df0dc984590847b19bd2f24e1aba8374", + "m_Id": 0, + "m_DisplayName": "RGBA", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "RGBA", + "m_StageCapability": 2, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "df7e230e2cde49938e554823b385f06c", + "m_Id": 0, + "m_DisplayName": "", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "df91a0749bee4bf880f627a67b8931cb", + "m_Id": 2, + "m_DisplayName": "Y", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "Y", + "m_StageCapability": 3, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [ + "Y" + ] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.GroupData", + "m_ObjectId": "dfa824146c2f43d5a5ea6bd8b9c3463a", + "m_Title": "Micro Smoothness & Scatter Mask Head", + "m_Position": { + "x": -5471.0, + "y": -460.99993896484377 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector4MaterialSlot", + "m_ObjectId": "e02a692b96b546ac8c43ece35b3d68d0", + "m_Id": 0, + "m_DisplayName": "RGBA", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "RGBA", + "m_StageCapability": 2, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.SampleTexture2DNode", + "m_ObjectId": "e177d7f1d3284a96a99e4967794fde8e", + "m_Group": { + "m_Id": "7e0bc17feda14e9686f73d30823bef26" + }, + "m_Name": "Sample Texture 2D", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -1589.9998779296875, + "y": 657.0000610351563, + "width": 184.0, + "height": 253.0 + } + }, + "m_Slots": [ + { + "m_Id": "a41bd2d113e74441b095bf1de66ae302" + }, + { + "m_Id": "e93edcd87c1140b1aae8644b980b0f88" + }, + { + "m_Id": "36eecdef2b294c59a439232db1d40c95" + }, + { + "m_Id": "8d73d89b0a7f48d1bbe48f87e5f35a33" + }, + { + "m_Id": "3a447476a53a4423b705358147d98bee" + }, + { + "m_Id": "3db60fa0adee4b2c9e05d88f48ac010c" + }, + { + "m_Id": "c68af561c48d4ea9bc1be4a573395586" + }, + { + "m_Id": "b3f9e17afed244f8ba0d3001d6fca640" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_TextureType": 0, + "m_NormalMapSpace": 0 +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "e17a9e2e0ec344d680b399ed8197e67a", + "m_Id": 4, + "m_DisplayName": "R", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "R", + "m_StageCapability": 2, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.BlockNode", + "m_ObjectId": "e1e6ea93dab24d4086de0ce0507e9306", + "m_Group": { + "m_Id": "" + }, + "m_Name": "SurfaceDescription.Alpha", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": 582.9999389648438, + "y": 558.0, + "width": 200.0, + "height": 40.999996185302737 + } + }, + "m_Slots": [ + { + "m_Id": "424b313138944a21bc404c418bcb085e" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_SerializedDescriptor": "SurfaceDescription.Alpha" +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "e1fbb5c2a74741dd8a53af2a1f19ccff", + "m_Id": 1, + "m_DisplayName": "B", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "B", + "m_StageCapability": 3, + "m_Value": { + "x": 2.0, + "y": 2.0, + "z": 2.0, + "w": 2.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.PropertyNode", + "m_ObjectId": "e222cb2bff344522873e60fba8643903", + "m_Group": { + "m_Id": "063dd08ef7054b98834ef43a93ef035d" + }, + "m_Name": "Property", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -2048.0, + "y": -1398.0, + "width": 210.0, + "height": 34.0 + } + }, + "m_Slots": [ + { + "m_Id": "f42566bae1d64bdea55283c7904a6c5d" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_Property": { + "m_Id": "e31101d048044951bdf13cbddcd0f930" + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.SamplerStateMaterialSlot", + "m_ObjectId": "e27216b47939497d855299dafa3b577d", + "m_Id": 1, + "m_DisplayName": "", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "", + "m_StageCapability": 3, + "m_BareResource": false +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.PropertyNode", + "m_ObjectId": "e2ec96e135f9461382359ae7e3f6df33", + "m_Group": { + "m_Id": "dfa824146c2f43d5a5ea6bd8b9c3463a" + }, + "m_Name": "Property", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -4977.0, + "y": 402.99993896484377, + "width": 221.0, + "height": 34.0 + } + }, + "m_Slots": [ + { + "m_Id": "c6062e858d4343e5a5764fb40e7e36a2" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_Property": { + "m_Id": "f0d88fda47be4d4b9b1614b6313411df" + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Internal.Texture2DShaderProperty", + "m_ObjectId": "e31101d048044951bdf13cbddcd0f930", + "m_Guid": { + "m_GuidSerialized": "cdc40d99-2bab-48d4-8dc7-1360840840a8" + }, + "m_Name": "Color Blend Map (Head)", + "m_DefaultReferenceName": "Texture2D_e31101d048044951bdf13cbddcd0f930", + "m_OverrideReferenceName": "_ColorBlendMap", + "m_GeneratePropertyBlock": true, + "m_Precision": 0, + "overrideHLSLDeclaration": false, + "hlslDeclarationOverride": 0, + "m_Hidden": false, + "m_Value": { + "m_SerializedTexture": "{\"texture\":{\"instanceID\":0}}", + "m_Guid": "" + }, + "m_Modifiable": true, + "m_DefaultType": 0 +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicValueMaterialSlot", + "m_ObjectId": "e39ef042f42b40f1ade7b7cdaede1b5d", + "m_Id": 1, + "m_DisplayName": "", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "", + "m_StageCapability": 3, + "m_Value": { + "e00": 0.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 0.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 0.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 0.0 + }, + "m_DefaultValue": { + "e00": 1.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 1.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 1.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "e3b06bda84974a839aa6157bb6b02e78", + "m_Id": 0, + "m_DisplayName": "Nose/R Smoothness Mod", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "e3e86916a3964c158328500eb1239f82", + "m_Id": 1, + "m_DisplayName": "", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.KeywordNode", + "m_ObjectId": "e4854a73e1f1473a9ad71dc1f45fb158", + "m_Group": { + "m_Id": "ab191acedb9b44b7b3bbc68b89055a73" + }, + "m_Name": "Is Head", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -670.0, + "y": 1810.0001220703125, + "width": 139.0, + "height": 118.0 + } + }, + "m_Slots": [ + { + "m_Id": "863b853f19434a53bd7d61ac14edb3ee" + }, + { + "m_Id": "e8de084d292d452881575a9a4f349565" + }, + { + "m_Id": "3781cd6f06144262831c126dc6c516a1" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_Keyword": { + "m_Id": "4479b5f90a784db6b7291eba881239a9" + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector4Node", + "m_ObjectId": "e4feeb6b4fe6422c99a6d9f7204b3f77", + "m_Group": { + "m_Id": "dfa824146c2f43d5a5ea6bd8b9c3463a" + }, + "m_Name": "Vector 4", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -5167.0, + "y": 393.00006103515627, + "width": 131.0, + "height": 149.0 + } + }, + "m_Slots": [ + { + "m_Id": "ddf65bdd0922413e97099a575b4186ca" + }, + { + "m_Id": "8dc56439c1ea4c6281d29c6e7bc64a4d" + }, + { + "m_Id": "d55d3c9d3ea44d3c84b03bcfec6ac226" + }, + { + "m_Id": "6987bd0f82084c918b15e6d4ad38a8af" + }, + { + "m_Id": "40fcf31603c04fa0919b02d5b43650c7" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "e51e934d740f4369a721de0c664eeee0", + "m_Id": 0, + "m_DisplayName": "Thickness", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "Thickness", + "m_StageCapability": 2, + "m_Value": 1.0, + "m_DefaultValue": 1.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "e549cd1b33c04ff58c888d33196d6e82", + "m_Id": 7, + "m_DisplayName": "A", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "A", + "m_StageCapability": 2, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 1, + "m_Type": "UnityEditor.ShaderGraph.Internal.Vector1ShaderProperty", + "m_ObjectId": "e55f9a75fb6b42608280338c0f6f0543", + "m_Guid": { + "m_GuidSerialized": "1154d8c1-4581-4acc-a59d-70baa2e70e03" + }, + "m_Name": "Ear Scatter Scale", + "m_DefaultReferenceName": "", + "m_OverrideReferenceName": "_EarScatterScale", + "m_GeneratePropertyBlock": true, + "m_Precision": 0, + "overrideHLSLDeclaration": false, + "hlslDeclarationOverride": 0, + "m_Hidden": false, + "m_Value": 1.0, + "m_FloatType": 1, + "m_RangeValues": { + "x": 0.0, + "y": 2.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicValueMaterialSlot", + "m_ObjectId": "e594ef18acbd4c88a458248568ecdf8f", + "m_Id": 2, + "m_DisplayName": "Out", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": { + "e00": 0.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 0.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 0.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 0.0 + }, + "m_DefaultValue": { + "e00": 1.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 1.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 1.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector4MaterialSlot", + "m_ObjectId": "e612418ec5dc4c8ba3d06fc562572c3f", + "m_Id": 0, + "m_DisplayName": "RGBA", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "RGBA", + "m_StageCapability": 2, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "e668d6b76d8549e2aa913b336c0b7589", + "m_Id": 2, + "m_DisplayName": "Off", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "Off", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.BlockNode", + "m_ObjectId": "e701720035d44304a33f4b64350fc6e3", + "m_Group": { + "m_Id": "" + }, + "m_Name": "SurfaceDescription.Emission", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": 0.0, + "y": 0.0, + "width": 0.0, + "height": 0.0 + } + }, + "m_Slots": [ + { + "m_Id": "4fbf6229bad74e91afb7ff4f2a7f0018" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_SerializedDescriptor": "SurfaceDescription.Emission" +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.PropertyNode", + "m_ObjectId": "e74d1c75dc2045d287c81ef5ddb0993e", + "m_Group": { + "m_Id": "5afd5b10bac94af98e61ab4df0f1d432" + }, + "m_Name": "Property", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -3817.0, + "y": 1291.0, + "width": 202.0, + "height": 34.0 + } + }, + "m_Slots": [ + { + "m_Id": "93635d08e5684dd08bc9ace175abf670" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_Property": { + "m_Id": "18e7067ff74c497eb92e133c7111aef2" + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.PropertyNode", + "m_ObjectId": "e750faa0e3d44f9e9973ff8e08aa9dd9", + "m_Group": { + "m_Id": "66c69fb10be74462b9dfdbda883bd934" + }, + "m_Name": "Property", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -3215.0, + "y": -380.0000305175781, + "width": 200.0, + "height": 34.0 + } + }, + "m_Slots": [ + { + "m_Id": "f4418db0f4444e9b81b920bf29b0f185" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_Property": { + "m_Id": "da213d6a9621401f9a5ffc93e4383f77" + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "e784a6e1ddea4401b1cd88cdc267d374", + "m_Id": 0, + "m_DisplayName": "", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicValueMaterialSlot", + "m_ObjectId": "e7fcccc1875d4914841bc5cf71fa7fdf", + "m_Id": 0, + "m_DisplayName": "A", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "A", + "m_StageCapability": 3, + "m_Value": { + "e00": 0.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 0.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 0.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 0.0 + }, + "m_DefaultValue": { + "e00": 1.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 1.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 1.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "e8362fd7f2884d1ab1ac906ae9c28004", + "m_Id": 0, + "m_DisplayName": "Subsurface Mask", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "SubsurfaceMask", + "m_StageCapability": 2, + "m_Value": 1.0, + "m_DefaultValue": 1.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.PropertyNode", + "m_ObjectId": "e8a9cd81d6544753bf2cb708ed17484f", + "m_Group": { + "m_Id": "cb23790c1b9143928df829b7a26d1423" + }, + "m_Name": "Property", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -5230.0, + "y": 1496.0, + "width": 202.0, + "height": 34.0 + } + }, + "m_Slots": [ + { + "m_Id": "ec0f558abf31474faf7928a55b8340a3" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_Property": { + "m_Id": "c12e83169aaf40a39eef85aea07d238b" + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.RedirectNodeData", + "m_ObjectId": "e8b85c1ce5af4459860b542e1afc8d84", + "m_Group": { + "m_Id": "dfa824146c2f43d5a5ea6bd8b9c3463a" + }, + "m_Name": "Redirect Node", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -5446.0, + "y": 192.9999542236328, + "width": 56.0, + "height": 24.0 + } + }, + "m_Slots": [ + { + "m_Id": "230ead4436b64146a60a64dd8575fc7d" + }, + { + "m_Id": "e27216b47939497d855299dafa3b577d" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 1, + "m_Type": "UnityEditor.ShaderGraph.Internal.Vector1ShaderProperty", + "m_ObjectId": "e8cdc35a911841ea94f4e76dc4ec9395", + "m_Guid": { + "m_GuidSerialized": "53e81bce-8345-4439-ad45-6b2f3f41eeb3" + }, + "m_Name": "Upper Lip Smoothness Mod", + "m_DefaultReferenceName": "", + "m_OverrideReferenceName": "_UpperLipSmoothnessMod", + "m_GeneratePropertyBlock": true, + "m_Precision": 0, + "overrideHLSLDeclaration": false, + "hlslDeclarationOverride": 0, + "m_Hidden": false, + "m_Value": 0.0, + "m_FloatType": 1, + "m_RangeValues": { + "x": -1.5, + "y": 1.5 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "e8de084d292d452881575a9a4f349565", + "m_Id": 1, + "m_DisplayName": "On", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "On", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "e8ef85abd49b47699cb9ea3faccd627a", + "m_Id": 1, + "m_DisplayName": "", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "e93edcd87c1140b1aae8644b980b0f88", + "m_Id": 4, + "m_DisplayName": "R", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "R", + "m_StageCapability": 2, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "e97a748e1fff420fa01450f86c5a0fb7", + "m_Id": 2, + "m_DisplayName": "Off", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "Off", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "e989b91cd55343fd98fda6e8bf964491", + "m_Id": 0, + "m_DisplayName": "Unmasked Smoothness Mod", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicValueMaterialSlot", + "m_ObjectId": "e9b271cd684b4678b3f00c819396e66a", + "m_Id": 2, + "m_DisplayName": "Out", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": { + "e00": 0.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 0.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 0.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 0.0 + }, + "m_DefaultValue": { + "e00": 1.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 1.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 1.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "e9d33e371c984ef093e8e959a305fb9d", + "m_Id": 6, + "m_DisplayName": "B", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "B", + "m_StageCapability": 2, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector4MaterialSlot", + "m_ObjectId": "ea8543b1da0c4a21adbcb9d155103c52", + "m_Id": 12, + "m_DisplayName": "Scatter3", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "Scatter3", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Texture2DInputMaterialSlot", + "m_ObjectId": "eb7f26266d4d47c9a57e818a9e6890dc", + "m_Id": 1, + "m_DisplayName": "Texture", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "Texture", + "m_StageCapability": 3, + "m_BareResource": false, + "m_Texture": { + "m_SerializedTexture": "{\"texture\":{\"instanceID\":0}}", + "m_Guid": "" + }, + "m_DefaultType": 3 +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "ebc19c33c9df459895e22ea4b4d08507", + "m_Id": 1, + "m_DisplayName": "", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "ec0f558abf31474faf7928a55b8340a3", + "m_Id": 0, + "m_DisplayName": "Inner Lid/A Scatter Scale", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "ec82bbcd8c6c4c49afbed9510f1406cd", + "m_Id": 0, + "m_DisplayName": "Forehead Scatter Scale", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector4Node", + "m_ObjectId": "ecee4b316f804aaabfb9ab9d90fe4712", + "m_Group": { + "m_Id": "dfa824146c2f43d5a5ea6bd8b9c3463a" + }, + "m_Name": "Vector 4", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -4690.0, + "y": 518.0, + "width": 131.0, + "height": 149.0 + } + }, + "m_Slots": [ + { + "m_Id": "955628c8fc1149ecbee2fa9171a57548" + }, + { + "m_Id": "92b3e601c9d54050b5e693c0bdeddb43" + }, + { + "m_Id": "320b7f56c48046afad2ace44ca49de50" + }, + { + "m_Id": "4220346c81a44c979bd63ba9a98b160f" + }, + { + "m_Id": "5f09a07b549d4957ba2a6965373163f3" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector4MaterialSlot", + "m_ObjectId": "ee20fbde14b8401da12d7aa5225b7517", + "m_Id": 0, + "m_DisplayName": "RGBA", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "RGBA", + "m_StageCapability": 2, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.SamplerStateMaterialSlot", + "m_ObjectId": "ee215b26074e4dcc8abfd2ffc197aaa2", + "m_Id": 0, + "m_DisplayName": "", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "", + "m_StageCapability": 3, + "m_BareResource": false +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "ee3ab1ccb0b24074a91a736c76fdc04b", + "m_Id": 1, + "m_DisplayName": "", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "eed2ff4e2c97461bb64d466ea7ff5d1b", + "m_Id": 0, + "m_DisplayName": "In", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "In", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "eee3f57a4736440085a28d696808b920", + "m_Id": 3, + "m_DisplayName": "Z", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "Z", + "m_StageCapability": 3, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [ + "Z" + ] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.RedirectNodeData", + "m_ObjectId": "ef7077cb966f4e20aab711392aff03e5", + "m_Group": { + "m_Id": "dfa824146c2f43d5a5ea6bd8b9c3463a" + }, + "m_Name": "Redirect Node", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -4615.0, + "y": 704.9998779296875, + "width": 56.0, + "height": 24.0 + } + }, + "m_Slots": [ + { + "m_Id": "1fb80260b80947a887e0bf25a6301900" + }, + { + "m_Id": "858a17c61a794a5d85c8187664ecbfc6" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.GroupData", + "m_ObjectId": "ef85247de4c745dcbc6ddca88875b14d", + "m_Title": "Head Normal Blend", + "m_Position": { + "x": -1893.999755859375, + "y": 1411.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.PropertyNode", + "m_ObjectId": "efab06ea88604aa284d3d113d48d4342", + "m_Group": { + "m_Id": "dfa824146c2f43d5a5ea6bd8b9c3463a" + }, + "m_Name": "Property", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -5435.0, + "y": 495.0000305175781, + "width": 202.0, + "height": 34.0 + } + }, + "m_Slots": [ + { + "m_Id": "0ed7d1df69484eb7bc57fa367591d14b" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_Property": { + "m_Id": "c12e83169aaf40a39eef85aea07d238b" + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector4Node", + "m_ObjectId": "efb12c27a80d4b58b763e55ec9cda203", + "m_Group": { + "m_Id": "dfa824146c2f43d5a5ea6bd8b9c3463a" + }, + "m_Name": "Vector 4", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -4690.0, + "y": 368.9999694824219, + "width": 131.0, + "height": 149.0 + } + }, + "m_Slots": [ + { + "m_Id": "ad4d6c245829480d83cddfc7ba7373f5" + }, + { + "m_Id": "060fd61d7b8a48d19e884b7fcfa36d56" + }, + { + "m_Id": "4cc666179ce842b5ab953aa2cd889661" + }, + { + "m_Id": "59af546e75fe4911b6c1ab6694ef23c9" + }, + { + "m_Id": "26adc51b91984d0685d31ac994b799e2" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "f09f3b7abb124588b87ec35e2f70c5c9", + "m_Id": 0, + "m_DisplayName": "In", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "In", + "m_StageCapability": 3, + "m_Value": { + "x": 1.0, + "y": 1.0, + "z": 1.0, + "w": 1.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 1, + "m_Type": "UnityEditor.ShaderGraph.Internal.Vector1ShaderProperty", + "m_ObjectId": "f0d88fda47be4d4b9b1614b6313411df", + "m_Guid": { + "m_GuidSerialized": "c6ff43fe-c20b-4abf-b275-b6dad2ac7b3a" + }, + "m_Name": "Forehead Smoothness Mod", + "m_DefaultReferenceName": "", + "m_OverrideReferenceName": "_ForeheadSmoothnessMod", + "m_GeneratePropertyBlock": true, + "m_Precision": 0, + "overrideHLSLDeclaration": false, + "hlslDeclarationOverride": 0, + "m_Hidden": false, + "m_Value": 0.0, + "m_FloatType": 1, + "m_RangeValues": { + "x": -1.5, + "y": 1.5 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "f14dfbec05c94c2db512559daa14ad34", + "m_Id": 8, + "m_DisplayName": "UMMS", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "UMMS", + "m_StageCapability": 3, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "f3e9cc1f665441248d88fd2ec50feea5", + "m_Id": 0, + "m_DisplayName": "", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicValueMaterialSlot", + "m_ObjectId": "f3ebff254aee4ffc8cfd7a9480a33238", + "m_Id": 0, + "m_DisplayName": "", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "", + "m_StageCapability": 3, + "m_Value": { + "e00": 0.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 0.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 0.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 0.0 + }, + "m_DefaultValue": { + "e00": 1.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 1.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 1.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Texture2DMaterialSlot", + "m_ObjectId": "f42566bae1d64bdea55283c7904a6c5d", + "m_Id": 0, + "m_DisplayName": "Color Blend Map (Head)", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_BareResource": false +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Texture2DMaterialSlot", + "m_ObjectId": "f4418db0f4444e9b81b920bf29b0f185", + "m_Id": 0, + "m_DisplayName": "Cavity AO Map (Head)", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_BareResource": false +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "f46f5e593ceb4b55a0d2e476533c6bc6", + "m_Id": 1, + "m_DisplayName": "B", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "B", + "m_StageCapability": 3, + "m_Value": { + "x": 1.0, + "y": 1.0, + "z": 1.0, + "w": 1.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.NormalBlendNode", + "m_ObjectId": "f4c8ed6045604a808bfc1aa7cdbbd81a", + "m_Group": { + "m_Id": "ef85247de4c745dcbc6ddca88875b14d" + }, + "m_Name": "Normal Blend", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -1089.9998779296875, + "y": 1691.9998779296875, + "width": 145.0, + "height": 153.99998474121095 + } + }, + "m_Slots": [ + { + "m_Id": "69d93e6f052745178a36317d34d8efd0" + }, + { + "m_Id": "09e79952160e4143bfc0aebcff87ce18" + }, + { + "m_Id": "71842e43cbf0437480a255269101cb72" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_BlendMode": 0 +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.GroupData", + "m_ObjectId": "f56aec43c38a433ca25a9aab19b2e18b", + "m_Title": "Smoothness Remapping", + "m_Position": { + "x": -1855.0, + "y": 962.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Texture2DMaterialSlot", + "m_ObjectId": "f5746ecd4733458d9881a4a7ed8ae69c", + "m_Id": 0, + "m_DisplayName": "Normal Blend Map (Head)", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_BareResource": false +} + +{ + "m_SGVersion": 1, + "m_Type": "UnityEditor.ShaderGraph.Internal.Vector1ShaderProperty", + "m_ObjectId": "f59399cdc25c46fc8f26233a7f05270f", + "m_Guid": { + "m_GuidSerialized": "728c82ea-4205-4fa8-8a1c-afa2d4d2d176" + }, + "m_Name": "Mouth/G Smoothness Mod", + "m_DefaultReferenceName": "", + "m_OverrideReferenceName": "_GSmoothnessMod", + "m_GeneratePropertyBlock": true, + "m_Precision": 0, + "overrideHLSLDeclaration": false, + "hlslDeclarationOverride": 0, + "m_Hidden": false, + "m_Value": 0.0, + "m_FloatType": 1, + "m_RangeValues": { + "x": -1.5, + "y": 1.5 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicValueMaterialSlot", + "m_ObjectId": "f69b9026c9f34b6c875f95a45f10a2c0", + "m_Id": 0, + "m_DisplayName": "A", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "A", + "m_StageCapability": 3, + "m_Value": { + "e00": 0.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 0.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 0.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 0.0 + }, + "m_DefaultValue": { + "e00": 1.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 1.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 1.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "f6cc7e8352fd4fdf93be133b5c0a5226", + "m_Id": 6, + "m_DisplayName": "B", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "B", + "m_StageCapability": 2, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 1, + "m_Type": "UnityEditor.ShaderGraph.Internal.Vector1ShaderProperty", + "m_ObjectId": "f72531ddf88f4deeb7706f3ee8563193", + "m_Guid": { + "m_GuidSerialized": "0f63b607-fa7c-470a-961e-c2382d49bb83" + }, + "m_Name": "Chin Smoothness Mod", + "m_DefaultReferenceName": "", + "m_OverrideReferenceName": "_ChinSmoothnessMod", + "m_GeneratePropertyBlock": true, + "m_Precision": 0, + "overrideHLSLDeclaration": false, + "hlslDeclarationOverride": 0, + "m_Hidden": false, + "m_Value": 0.0, + "m_FloatType": 1, + "m_RangeValues": { + "x": -1.5, + "y": 1.5 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.MultiplyNode", + "m_ObjectId": "f766681671b24953a25310189a3931a6", + "m_Group": { + "m_Id": "66c69fb10be74462b9dfdbda883bd934" + }, + "m_Name": "Multiply", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -1566.0, + "y": -421.0, + "width": 126.0, + "height": 117.99999237060547 + } + }, + "m_Slots": [ + { + "m_Id": "833e26b13f814b739d5516eb6b94c3c0" + }, + { + "m_Id": "d1980bb9f451498b87c737f321c2e72a" + }, + { + "m_Id": "fa6045ac11b4497e9d66eb93c98cb36b" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Texture2DInputMaterialSlot", + "m_ObjectId": "f83484ce0dc3434192636d37b20b951d", + "m_Id": 1, + "m_DisplayName": "Texture", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "Texture", + "m_StageCapability": 3, + "m_BareResource": false, + "m_Texture": { + "m_SerializedTexture": "{\"texture\":{\"instanceID\":0}}", + "m_Guid": "" + }, + "m_DefaultType": 0 +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "f8ae466dedda43058150600807d8ca55", + "m_Id": 16, + "m_DisplayName": "UMSS", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "UMSS", + "m_StageCapability": 3, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "f937fa9c43514a8bbfe3aa630f908f40", + "m_Id": 13, + "m_DisplayName": "SmoothnessMod", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "SmoothnessMod", + "m_StageCapability": 3, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector4MaterialSlot", + "m_ObjectId": "f94a55b9938f414aab6546801672aa84", + "m_Id": 0, + "m_DisplayName": "Out", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.GroupData", + "m_ObjectId": "f9a36441a7674212a626b4e29ac4024e", + "m_Title": "IsHead Keyword", + "m_Position": { + "x": -189.0, + "y": -871.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector2MaterialSlot", + "m_ObjectId": "f9b331b1062048d6b94590012e2f4adb", + "m_Id": 1, + "m_DisplayName": "Tiling", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "Tiling", + "m_StageCapability": 3, + "m_Value": { + "x": 1.0, + "y": 1.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0 + }, + "m_Labels": [] +} + +{ + "m_SGVersion": 1, + "m_Type": "UnityEditor.ShaderGraph.Internal.Vector1ShaderProperty", + "m_ObjectId": "f9cefb04dde84a5eb85a204200a3f7ca", + "m_Guid": { + "m_GuidSerialized": "90b73bb5-8966-4ef9-a2ca-36fe5774550b" + }, + "m_Name": "Neck Scatter Scale", + "m_DefaultReferenceName": "", + "m_OverrideReferenceName": "_NeckScatterScale", + "m_GeneratePropertyBlock": true, + "m_Precision": 0, + "overrideHLSLDeclaration": false, + "hlslDeclarationOverride": 0, + "m_Hidden": false, + "m_Value": 1.0, + "m_FloatType": 1, + "m_RangeValues": { + "x": 0.0, + "y": 2.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.PropertyNode", + "m_ObjectId": "fa47195d70db452ab131f74751df00f8", + "m_Group": { + "m_Id": "dfa824146c2f43d5a5ea6bd8b9c3463a" + }, + "m_Name": "Property", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -5431.0, + "y": 613.0000610351563, + "width": 198.00001525878907, + "height": 34.0 + } + }, + "m_Slots": [ + { + "m_Id": "600c30467017413596e51d0ec93b6338" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_Property": { + "m_Id": "0cae67e06abe458f8f01660cbb4221de" + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicValueMaterialSlot", + "m_ObjectId": "fa6045ac11b4497e9d66eb93c98cb36b", + "m_Id": 2, + "m_DisplayName": "Out", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": { + "e00": 0.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 0.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 0.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 0.0 + }, + "m_DefaultValue": { + "e00": 1.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 1.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 1.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "fb16df88280a4452ab1f3673bd754881", + "m_Id": 1, + "m_DisplayName": "Out", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "fb2aef27282447deb8bbb701f6c568f4", + "m_Id": 4, + "m_DisplayName": "SmoothnessMod", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "SmoothnessMod", + "m_StageCapability": 3, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.SamplerStateMaterialSlot", + "m_ObjectId": "fb80921dc3724b67876bf7f60fff4662", + "m_Id": 3, + "m_DisplayName": "Sampler", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "Sampler", + "m_StageCapability": 3, + "m_BareResource": false +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "fb85edc4ce8e4362a1d1e12547d260cb", + "m_Id": 0, + "m_DisplayName": "Unmasked Scatter Scale", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.PropertyNode", + "m_ObjectId": "fb95eeb30d884d54b358cca7f6a99063", + "m_Group": { + "m_Id": "cb23790c1b9143928df829b7a26d1423" + }, + "m_Name": "Property", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -5213.0, + "y": 1394.0, + "width": 185.0, + "height": 34.0 + } + }, + "m_Slots": [ + { + "m_Id": "7a7c989c7ed640799ec5da82e08b7d8b" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_Property": { + "m_Id": "971eb675ce25417c8f423a316a778a4a" + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.PropertyNode", + "m_ObjectId": "fbd8a56452444ca6aae3067d4c1a6f4e", + "m_Group": { + "m_Id": "9a9b9423c348490d8c6550520a46754b" + }, + "m_Name": "Property", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -1324.0, + "y": -922.0, + "width": 148.0, + "height": 34.0 + } + }, + "m_Slots": [ + { + "m_Id": "68cdfea8b0024f65a81894ca6b214a69" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_Property": { + "m_Id": "cb42572a46a74a588ef3935f3a667eb7" + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector3MaterialSlot", + "m_ObjectId": "fcb5df76291e43d59d9d2c723f6e78ea", + "m_Id": 0, + "m_DisplayName": "In", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "In", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 1.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0 + }, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.BlockNode", + "m_ObjectId": "fce699c8ebf3428887ef6a715d55d4f9", + "m_Group": { + "m_Id": "" + }, + "m_Name": "SurfaceDescription.DiffusionProfileHash", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": 593.0, + "y": 725.0, + "width": 200.0, + "height": 41.0 + } + }, + "m_Slots": [ + { + "m_Id": "1d4e4c975a3241d5ab63d4debf2aec6a" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_SerializedDescriptor": "SurfaceDescription.DiffusionProfileHash" +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.SamplerStateMaterialSlot", + "m_ObjectId": "fcff2b7833bf4dee91d80076aa597fb0", + "m_Id": 0, + "m_DisplayName": "", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "", + "m_StageCapability": 3, + "m_BareResource": false +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.RedirectNodeData", + "m_ObjectId": "fd18b6af75854a368c145540f011523c", + "m_Group": { + "m_Id": "d2a14e6d2148432cb883f7e72b690cff" + }, + "m_Name": "Redirect Node", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -2280.0, + "y": 99.99996948242188, + "width": 56.0, + "height": 24.000001907348634 + } + }, + "m_Slots": [ + { + "m_Id": "f3e9cc1f665441248d88fd2ec50feea5" + }, + { + "m_Id": "ebc19c33c9df459895e22ea4b4d08507" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector4MaterialSlot", + "m_ObjectId": "fd54d8eb8bd74acba90bdeca7ec6b790", + "m_Id": 0, + "m_DisplayName": "In1", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "In1", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "fe165afcc73d41289342c986c308f461", + "m_Id": 5, + "m_DisplayName": "G", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "G", + "m_StageCapability": 2, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.RedirectNodeData", + "m_ObjectId": "fe3d443bbd14473a94a276dc64eb6dcb", + "m_Group": { + "m_Id": "c39c85064c8b4914bb957db1b59e0e49" + }, + "m_Name": "Redirect Node", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -2050.0, + "y": 2847.000244140625, + "width": 56.0, + "height": 24.0 + } + }, + "m_Slots": [ + { + "m_Id": "597d96c22619414c8ab2a5c6652137eb" + }, + { + "m_Id": "cbd2ba5f22e445698eede034cd03afc3" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.UVMaterialSlot", + "m_ObjectId": "fe9bcc80f8e24f968b8fe8afe3f3ab9e", + "m_Id": 2, + "m_DisplayName": "UV", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "UV", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0 + }, + "m_Labels": [], + "m_Channel": 0 +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Texture2DInputMaterialSlot", + "m_ObjectId": "fecf7d06ef38474991bf0c06800e8aae", + "m_Id": 1, + "m_DisplayName": "Texture", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "Texture", + "m_StageCapability": 3, + "m_BareResource": false, + "m_Texture": { + "m_SerializedTexture": "{\"texture\":{\"instanceID\":0}}", + "m_Guid": "" + }, + "m_DefaultType": 0 +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.SamplerStateMaterialSlot", + "m_ObjectId": "ff0815a316df4c70a19309d6d2f6daeb", + "m_Id": 3, + "m_DisplayName": "Sampler", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "Sampler", + "m_StageCapability": 3, + "m_BareResource": false +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "ffa946115b334519a2b730b59a68c2a2", + "m_Id": 0, + "m_DisplayName": "Neck Scatter Scale", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + diff --git a/HDRP/Shaders/RL_SkinShaderVariants_HDRP.shadergraph.meta b/HDRP/Shaders/RL_SkinShaderVariants_HDRP.shadergraph.meta new file mode 100644 index 0000000..5a12297 --- /dev/null +++ b/HDRP/Shaders/RL_SkinShaderVariants_HDRP.shadergraph.meta @@ -0,0 +1,10 @@ +fileFormatVersion: 2 +guid: e4b1192022fa52046868c000971f662c +ScriptedImporter: + internalIDToNameTable: [] + externalObjects: {} + serializedVersion: 2 + userData: + assetBundleName: + assetBundleVariant: + script: {fileID: 11500000, guid: 625f186215c104763be7675aa2d941aa, type: 3} diff --git a/HDRP/Shaders/RL_TearlineShader_HDRP.shadergraph b/HDRP/Shaders/RL_TearlineShader_HDRP.shadergraph new file mode 100644 index 0000000..7590ab9 --- /dev/null +++ b/HDRP/Shaders/RL_TearlineShader_HDRP.shadergraph @@ -0,0 +1,3159 @@ +{ + "m_SGVersion": 2, + "m_Type": "UnityEditor.ShaderGraph.GraphData", + "m_ObjectId": "608ecbf5a503475e99b294342318619a", + "m_Properties": [ + { + "m_Id": "2fd9bed3ea22484c8fd8fb96b6721875" + }, + { + "m_Id": "176f796389af4a2db4eccc60e9a2db9f" + }, + { + "m_Id": "0b61b839117148d081fd62370f39c4fa" + }, + { + "m_Id": "8fe532ea543d401da0e49bd95ab3df2e" + }, + { + "m_Id": "1ce71cb986934c28b90d4c23d3f8a95b" + }, + { + "m_Id": "527b2200125f4198be5a7b45d50aa84f" + } + ], + "m_Keywords": [], + "m_Nodes": [ + { + "m_Id": "f00b5059a12a49239ef22d406a1dffdc" + }, + { + "m_Id": "fb462c5b218249f8a70924bdad87751b" + }, + { + "m_Id": "fa0f7d95093e470fa5e98df9d2c6ff99" + }, + { + "m_Id": "6f8db90efdd247a6ac3fead2f1fd4855" + }, + { + "m_Id": "f4a4d483d73849b2b0d1a60c8f64de8b" + }, + { + "m_Id": "59e81431d9574d9189b75346cd7886ac" + }, + { + "m_Id": "6e21aade13a14946a4a3369e57908a65" + }, + { + "m_Id": "9f9efe7a498c41f99d37c36416dfe120" + }, + { + "m_Id": "2998ccc64387468f9150399f8ce5fae5" + }, + { + "m_Id": "9db9de202b6a48a9b9fb6042812610c9" + }, + { + "m_Id": "21381f5bc9e643dc98eba41b35310413" + }, + { + "m_Id": "4ee9f05412bb42c3a11650f866a89a98" + }, + { + "m_Id": "8309ce333a1f49fc9985776db2ad48df" + }, + { + "m_Id": "248f3b483e074df690c154579b6f5dfa" + }, + { + "m_Id": "65b74c74a44b4a548fe6adeb28c67843" + }, + { + "m_Id": "6b99729f67904be4aea86bc755303534" + }, + { + "m_Id": "a7e4508bd4204559b53ab7057c2ea47a" + }, + { + "m_Id": "4bd23d3e0d564e58ba57b0c9f74eda7b" + }, + { + "m_Id": "455c27229c4143d5a246debd93cc5ef2" + }, + { + "m_Id": "6d1dc4795b264f5bbdd976496fa4f0db" + }, + { + "m_Id": "efb8f07140584e32994ba4294d738beb" + }, + { + "m_Id": "7c697b79a9b54c9ab6076867dd485bfb" + }, + { + "m_Id": "81588ca3909941f0a3ff8839d013ed92" + }, + { + "m_Id": "f8a5371f09f94ce58feafce392601b0f" + }, + { + "m_Id": "4ee0b87b8c2f4369b7aab711fb885466" + }, + { + "m_Id": "df8884e1293144aeb491e2aede5bc401" + }, + { + "m_Id": "bf427c58b55946b998c92182f024b9cc" + }, + { + "m_Id": "fd758c07e8984094a39d3836ef942fa2" + }, + { + "m_Id": "7e564e61322144d38ed80873315bb755" + }, + { + "m_Id": "16e0bcbc24db4823918ca3d5d5baa2cd" + } + ], + "m_GroupDatas": [], + "m_StickyNoteDatas": [], + "m_Edges": [ + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "16e0bcbc24db4823918ca3d5d5baa2cd" + }, + "m_SlotId": 2 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "2998ccc64387468f9150399f8ce5fae5" + }, + "m_SlotId": 1 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "21381f5bc9e643dc98eba41b35310413" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "2998ccc64387468f9150399f8ce5fae5" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "2998ccc64387468f9150399f8ce5fae5" + }, + "m_SlotId": 2 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "9db9de202b6a48a9b9fb6042812610c9" + }, + "m_SlotId": 1 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "455c27229c4143d5a246debd93cc5ef2" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "efb8f07140584e32994ba4294d738beb" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "4bd23d3e0d564e58ba57b0c9f74eda7b" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "65b74c74a44b4a548fe6adeb28c67843" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "4ee0b87b8c2f4369b7aab711fb885466" + }, + "m_SlotId": 1 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "df8884e1293144aeb491e2aede5bc401" + }, + "m_SlotId": 2 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "6b99729f67904be4aea86bc755303534" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "6e21aade13a14946a4a3369e57908a65" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "6b99729f67904be4aea86bc755303534" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "efb8f07140584e32994ba4294d738beb" + }, + "m_SlotId": 1 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "6d1dc4795b264f5bbdd976496fa4f0db" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "16e0bcbc24db4823918ca3d5d5baa2cd" + }, + "m_SlotId": 1 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "7c697b79a9b54c9ab6076867dd485bfb" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "81588ca3909941f0a3ff8839d013ed92" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "7e564e61322144d38ed80873315bb755" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "fd758c07e8984094a39d3836ef942fa2" + }, + "m_SlotId": 1 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "81588ca3909941f0a3ff8839d013ed92" + }, + "m_SlotId": 1 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "f8a5371f09f94ce58feafce392601b0f" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "9db9de202b6a48a9b9fb6042812610c9" + }, + "m_SlotId": 2 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "f00b5059a12a49239ef22d406a1dffdc" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "9f9efe7a498c41f99d37c36416dfe120" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "9db9de202b6a48a9b9fb6042812610c9" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "a7e4508bd4204559b53ab7057c2ea47a" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "59e81431d9574d9189b75346cd7886ac" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "bf427c58b55946b998c92182f024b9cc" + }, + "m_SlotId": 1 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "fd758c07e8984094a39d3836ef942fa2" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "df8884e1293144aeb491e2aede5bc401" + }, + "m_SlotId": 3 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "bf427c58b55946b998c92182f024b9cc" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "efb8f07140584e32994ba4294d738beb" + }, + "m_SlotId": 2 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "6f8db90efdd247a6ac3fead2f1fd4855" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "f8a5371f09f94ce58feafce392601b0f" + }, + "m_SlotId": 2 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "4ee0b87b8c2f4369b7aab711fb885466" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "fd758c07e8984094a39d3836ef942fa2" + }, + "m_SlotId": 2 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "16e0bcbc24db4823918ca3d5d5baa2cd" + }, + "m_SlotId": 0 + } + } + ], + "m_VertexContext": { + "m_Position": { + "x": 0.0, + "y": 0.0 + }, + "m_Blocks": [ + { + "m_Id": "f00b5059a12a49239ef22d406a1dffdc" + }, + { + "m_Id": "fb462c5b218249f8a70924bdad87751b" + }, + { + "m_Id": "fa0f7d95093e470fa5e98df9d2c6ff99" + } + ] + }, + "m_FragmentContext": { + "m_Position": { + "x": 0.0, + "y": 200.0 + }, + "m_Blocks": [ + { + "m_Id": "6f8db90efdd247a6ac3fead2f1fd4855" + }, + { + "m_Id": "f4a4d483d73849b2b0d1a60c8f64de8b" + }, + { + "m_Id": "59e81431d9574d9189b75346cd7886ac" + }, + { + "m_Id": "6e21aade13a14946a4a3369e57908a65" + }, + { + "m_Id": "4ee9f05412bb42c3a11650f866a89a98" + }, + { + "m_Id": "8309ce333a1f49fc9985776db2ad48df" + }, + { + "m_Id": "248f3b483e074df690c154579b6f5dfa" + }, + { + "m_Id": "65b74c74a44b4a548fe6adeb28c67843" + } + ] + }, + "m_PreviewData": { + "serializedMesh": { + "m_SerializedMesh": "{\"mesh\":{\"instanceID\":0}}", + "m_Guid": "" + } + }, + "m_Path": "Shader Graphs", + "m_ConcretePrecision": 1, + "m_PreviewMode": 2, + "m_OutputNode": { + "m_Id": "" + }, + "m_ActiveTargets": [ + { + "m_Id": "7c95dbc72baf49c786b6c536d2840f92" + } + ] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicValueMaterialSlot", + "m_ObjectId": "0159e546079e4b75bb170398218fdaa8", + "m_Id": 1, + "m_DisplayName": "B", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "B", + "m_StageCapability": 3, + "m_Value": { + "e00": 2.0, + "e01": 2.0, + "e02": 2.0, + "e03": 2.0, + "e10": 2.0, + "e11": 2.0, + "e12": 2.0, + "e13": 2.0, + "e20": 2.0, + "e21": 2.0, + "e22": 2.0, + "e23": 2.0, + "e30": 2.0, + "e31": 2.0, + "e32": 2.0, + "e33": 2.0 + }, + "m_DefaultValue": { + "e00": 1.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 1.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 1.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.NormalMaterialSlot", + "m_ObjectId": "031560bebbf14091bba33714fb220f2b", + "m_Id": 0, + "m_DisplayName": "Normal", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "Normal", + "m_StageCapability": 1, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0 + }, + "m_Labels": [], + "m_Space": 0 +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicValueMaterialSlot", + "m_ObjectId": "083e38fcd29c4b29b0143ab7dedc9a67", + "m_Id": 0, + "m_DisplayName": "A", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "A", + "m_StageCapability": 3, + "m_Value": { + "e00": 0.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 0.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 0.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 0.0 + }, + "m_DefaultValue": { + "e00": 1.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 1.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 1.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.ColorRGBMaterialSlot", + "m_ObjectId": "08a1278372be48f6b292c6fe8b0eea09", + "m_Id": 0, + "m_DisplayName": "Base Color", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "BaseColor", + "m_StageCapability": 2, + "m_Value": { + "x": 0.25471699237823489, + "y": 0.25471699237823489, + "z": 0.25471699237823489 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0 + }, + "m_Labels": [], + "m_ColorMode": 0, + "m_DefaultColor": { + "r": 0.5, + "g": 0.5, + "b": 0.5, + "a": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicValueMaterialSlot", + "m_ObjectId": "0ac65750fc84498c9719b6a27672a4e5", + "m_Id": 2, + "m_DisplayName": "Out", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": { + "e00": 0.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 0.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 0.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 0.0 + }, + "m_DefaultValue": { + "e00": 1.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 1.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 1.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 1.0 + } +} + +{ + "m_SGVersion": 1, + "m_Type": "UnityEditor.ShaderGraph.Internal.Vector1ShaderProperty", + "m_ObjectId": "0b61b839117148d081fd62370f39c4fa", + "m_Guid": { + "m_GuidSerialized": "6a5e3c10-8882-4531-97a3-0f73b580a9cb" + }, + "m_Name": "Smoothness", + "m_DefaultReferenceName": "Vector1_0b61b839117148d081fd62370f39c4fa", + "m_OverrideReferenceName": "_Smoothness", + "m_GeneratePropertyBlock": true, + "m_Precision": 0, + "overrideHLSLDeclaration": false, + "hlslDeclarationOverride": 0, + "m_Hidden": false, + "m_Value": 1.0, + "m_FloatType": 1, + "m_RangeValues": { + "x": 0.0, + "y": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "12f6147f8d4b4711839d556551b1ca4f", + "m_Id": 1, + "m_DisplayName": "B", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "B", + "m_StageCapability": 3, + "m_Value": { + "x": 0.5, + "y": 1.0, + "z": 1.0, + "w": 1.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "15b5aedfa2a74b5f8c413bf09594fe46", + "m_Id": 0, + "m_DisplayName": "A", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "A", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.AddNode", + "m_ObjectId": "16e0bcbc24db4823918ca3d5d5baa2cd", + "m_Group": { + "m_Id": "" + }, + "m_Name": "Add", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -820.0000610351563, + "y": -331.0000305175781, + "width": 126.0, + "height": 118.0 + } + }, + "m_Slots": [ + { + "m_Id": "21e97b18f66f4c91a99c961f7dc83005" + }, + { + "m_Id": "a6d421ce8cb448ffab1dcb14456961c7" + }, + { + "m_Id": "7d2ed2a8f2104866905859364b1f77de" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 1, + "m_Type": "UnityEditor.ShaderGraph.Internal.Vector1ShaderProperty", + "m_ObjectId": "176f796389af4a2db4eccc60e9a2db9f", + "m_Guid": { + "m_GuidSerialized": "8c162d66-2194-47d6-8668-6c0fe351c722" + }, + "m_Name": "Alpha", + "m_DefaultReferenceName": "Vector1_176f796389af4a2db4eccc60e9a2db9f", + "m_OverrideReferenceName": "_Alpha", + "m_GeneratePropertyBlock": true, + "m_Precision": 0, + "overrideHLSLDeclaration": false, + "hlslDeclarationOverride": 0, + "m_Hidden": false, + "m_Value": 0.0, + "m_FloatType": 1, + "m_RangeValues": { + "x": 0.0, + "y": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "1cba112901114c43bf3f197e9d8ec653", + "m_Id": 0, + "m_DisplayName": "In", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "In", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 3, + "m_Type": "UnityEditor.ShaderGraph.Internal.ColorShaderProperty", + "m_ObjectId": "1ce71cb986934c28b90d4c23d3f8a95b", + "m_Guid": { + "m_GuidSerialized": "6e0216b2-3f24-48de-a0d4-0cf9c17c6e7b" + }, + "m_Name": "Color", + "m_DefaultReferenceName": "Color_1ce71cb986934c28b90d4c23d3f8a95b", + "m_OverrideReferenceName": "_BaseColor", + "m_GeneratePropertyBlock": true, + "m_Precision": 0, + "overrideHLSLDeclaration": false, + "hlslDeclarationOverride": 0, + "m_Hidden": false, + "m_Value": { + "r": 0.0, + "g": 0.0, + "b": 0.0, + "a": 0.0 + }, + "m_ColorMode": 0 +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.ColorRGBMaterialSlot", + "m_ObjectId": "1dc6d745820944edbf7d15e76310ee6d", + "m_Id": 0, + "m_DisplayName": "Emission", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "Emission", + "m_StageCapability": 2, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0 + }, + "m_Labels": [], + "m_ColorMode": 1, + "m_DefaultColor": { + "r": 0.0, + "g": 0.0, + "b": 0.0, + "a": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.Rendering.HighDefinition.ShaderGraph.HDLitSubTarget", + "m_ObjectId": "2077fc8640eb453f8f42a6a219f51ad0" +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector3Node", + "m_ObjectId": "21381f5bc9e643dc98eba41b35310413", + "m_Group": { + "m_Id": "" + }, + "m_Name": "Vector 3", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -872.0, + "y": -574.0, + "width": 128.0, + "height": 125.0 + } + }, + "m_Slots": [ + { + "m_Id": "3fbfb846199a4c4784c0959db43aa16c" + }, + { + "m_Id": "a57351a3cc594b43b53cea3eef447edc" + }, + { + "m_Id": "8abf13ba92a44c07b3c81b2e1e3db26a" + }, + { + "m_Id": "477cb8cf4d9c473f809aa884c894ee7b" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "21e97b18f66f4c91a99c961f7dc83005", + "m_Id": 0, + "m_DisplayName": "A", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "A", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.BlockNode", + "m_ObjectId": "248f3b483e074df690c154579b6f5dfa", + "m_Group": { + "m_Id": "" + }, + "m_Name": "SurfaceDescription.NormalTS", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": 0.0, + "y": 0.0, + "width": 0.0, + "height": 0.0 + } + }, + "m_Slots": [ + { + "m_Id": "fbf2398fe0c54757b73aa17996db52b1" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_SerializedDescriptor": "SurfaceDescription.NormalTS" +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "28961bf51e8c4cf8a6fad28f3611651e", + "m_Id": 4, + "m_DisplayName": "A", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "A", + "m_StageCapability": 3, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.MultiplyNode", + "m_ObjectId": "2998ccc64387468f9150399f8ce5fae5", + "m_Group": { + "m_Id": "" + }, + "m_Name": "Multiply", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -585.0000610351563, + "y": -449.0, + "width": 130.0, + "height": 118.00000762939453 + } + }, + "m_Slots": [ + { + "m_Id": "083e38fcd29c4b29b0143ab7dedc9a67" + }, + { + "m_Id": "0159e546079e4b75bb170398218fdaa8" + }, + { + "m_Id": "0ac65750fc84498c9719b6a27672a4e5" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "2b815d8c124446babe3b8506497c4a1a", + "m_Id": 0, + "m_DisplayName": "Metallic", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicValueMaterialSlot", + "m_ObjectId": "2e40d06b8dad4c65a4a1ce9b7cb5993d", + "m_Id": 1, + "m_DisplayName": "B", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "B", + "m_StageCapability": 3, + "m_Value": { + "e00": 2.0, + "e01": 2.0, + "e02": 2.0, + "e03": 2.0, + "e10": 2.0, + "e11": 2.0, + "e12": 2.0, + "e13": 2.0, + "e20": 2.0, + "e21": 2.0, + "e22": 2.0, + "e23": 2.0, + "e30": 2.0, + "e31": 2.0, + "e32": 2.0, + "e33": 2.0 + }, + "m_DefaultValue": { + "e00": 1.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 1.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 1.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 1.0 + } +} + +{ + "m_SGVersion": 1, + "m_Type": "UnityEditor.ShaderGraph.Internal.Vector1ShaderProperty", + "m_ObjectId": "2fd9bed3ea22484c8fd8fb96b6721875", + "m_Guid": { + "m_GuidSerialized": "9353f657-4aac-4443-896c-fee05b0421e6" + }, + "m_Name": "Depth Offset", + "m_DefaultReferenceName": "Vector1_2fd9bed3ea22484c8fd8fb96b6721875", + "m_OverrideReferenceName": "_DepthOffset", + "m_GeneratePropertyBlock": true, + "m_Precision": 0, + "overrideHLSLDeclaration": false, + "hlslDeclarationOverride": 0, + "m_Hidden": false, + "m_Value": 0.0, + "m_FloatType": 1, + "m_RangeValues": { + "x": -0.0010000000474974514, + "y": 0.0010000000474974514 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicValueMaterialSlot", + "m_ObjectId": "37449710b47441c68337d68de5216b32", + "m_Id": 2, + "m_DisplayName": "Out", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": { + "e00": 0.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 0.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 0.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 0.0 + }, + "m_DefaultValue": { + "e00": 1.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 1.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 1.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector3MaterialSlot", + "m_ObjectId": "390b7ae958e849318d2dc40c1658ee87", + "m_Id": 0, + "m_DisplayName": "Out", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0 + }, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "39a8792212bf427b9c9ad49205266f12", + "m_Id": 0, + "m_DisplayName": "In", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "In", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "3fbfb846199a4c4784c0959db43aa16c", + "m_Id": 1, + "m_DisplayName": "X", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "X", + "m_StageCapability": 3, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "435de479889847978ed7bfd0b41a5d8c", + "m_Id": 1, + "m_DisplayName": "Out", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "4480df450181490f8932319d9e328884", + "m_Id": 0, + "m_DisplayName": "Metallic", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "Metallic", + "m_StageCapability": 2, + "m_Value": 1.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.NormalMaterialSlot", + "m_ObjectId": "4505f7d1a3424fe6bec52e3260ae57e1", + "m_Id": 0, + "m_DisplayName": "Bent Normal", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "BentNormal", + "m_StageCapability": 2, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0 + }, + "m_Labels": [], + "m_Space": 3 +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.PropertyNode", + "m_ObjectId": "455c27229c4143d5a246debd93cc5ef2", + "m_Group": { + "m_Id": "" + }, + "m_Name": "Property", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -757.0, + "y": 200.0, + "width": 107.0, + "height": 34.0 + } + }, + "m_Slots": [ + { + "m_Id": "9f820a8d782644b28a83e495dc5518f7" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_Property": { + "m_Id": "1ce71cb986934c28b90d4c23d3f8a95b" + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector3MaterialSlot", + "m_ObjectId": "477cb8cf4d9c473f809aa884c894ee7b", + "m_Id": 0, + "m_DisplayName": "Out", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0 + }, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.PropertyNode", + "m_ObjectId": "4bd23d3e0d564e58ba57b0c9f74eda7b", + "m_Group": { + "m_Id": "" + }, + "m_Name": "Property", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -631.0000610351563, + "y": 745.0, + "width": 117.0, + "height": 34.0 + } + }, + "m_Slots": [ + { + "m_Id": "2b815d8c124446babe3b8506497c4a1a" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_Property": { + "m_Id": "8fe532ea543d401da0e49bd95ab3df2e" + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.AbsoluteNode", + "m_ObjectId": "4ee0b87b8c2f4369b7aab711fb885466", + "m_Group": { + "m_Id": "" + }, + "m_Name": "Absolute", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -2025.0, + "y": -529.0000610351563, + "width": 208.0, + "height": 278.0 + } + }, + "m_Slots": [ + { + "m_Id": "1cba112901114c43bf3f197e9d8ec653" + }, + { + "m_Id": "a8e357608d4a4b4a991814f36bc9a165" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.BlockNode", + "m_ObjectId": "4ee9f05412bb42c3a11650f866a89a98", + "m_Group": { + "m_Id": "" + }, + "m_Name": "SurfaceDescription.BentNormal", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": 0.0, + "y": 0.0, + "width": 0.0, + "height": 0.0 + } + }, + "m_Slots": [ + { + "m_Id": "4505f7d1a3424fe6bec52e3260ae57e1" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_SerializedDescriptor": "SurfaceDescription.BentNormal" +} + +{ + "m_SGVersion": 1, + "m_Type": "UnityEditor.ShaderGraph.Internal.Vector1ShaderProperty", + "m_ObjectId": "527b2200125f4198be5a7b45d50aa84f", + "m_Guid": { + "m_GuidSerialized": "ee1f2bef-f6a0-4a60-84e4-ea00c7d648b9" + }, + "m_Name": "Inner Offset", + "m_DefaultReferenceName": "Vector1_527b2200125f4198be5a7b45d50aa84f", + "m_OverrideReferenceName": "_InnerOffset", + "m_GeneratePropertyBlock": true, + "m_Precision": 0, + "overrideHLSLDeclaration": false, + "hlslDeclarationOverride": 0, + "m_Hidden": false, + "m_Value": 0.0010000000474974514, + "m_FloatType": 1, + "m_RangeValues": { + "x": -0.0010000000474974514, + "y": 0.0010000000474974514 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "551b66c4ba5f4460bc0c0a975d80998e", + "m_Id": 0, + "m_DisplayName": "A", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "A", + "m_StageCapability": 3, + "m_Value": { + "x": 1.0, + "y": 1.0, + "z": 1.0, + "w": 1.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "55873bf4efd44a7ab7e799ea89fb1f33", + "m_Id": 0, + "m_DisplayName": "Inner Offset", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.Rendering.HighDefinition.ShaderGraph.SystemData", + "m_ObjectId": "589350db00704ba7bc103b29f988ae67", + "m_MaterialNeedsUpdateHash": 529, + "m_SurfaceType": 1, + "m_RenderingPass": 4, + "m_BlendMode": 4, + "m_ZTest": 4, + "m_ZWrite": false, + "m_TransparentCullMode": 2, + "m_OpaqueCullMode": 2, + "m_SortPriority": -2, + "m_AlphaTest": false, + "m_TransparentDepthPrepass": false, + "m_TransparentDepthPostpass": false, + "m_SupportLodCrossFade": false, + "m_DoubleSidedMode": 0, + "m_DOTSInstancing": false, + "m_Version": 0, + "m_FirstTimeMigrationExecuted": true, + "inspectorFoldoutMask": 11 +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.BlockNode", + "m_ObjectId": "59e81431d9574d9189b75346cd7886ac", + "m_Group": { + "m_Id": "" + }, + "m_Name": "SurfaceDescription.Smoothness", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": 0.0, + "y": 0.0, + "width": 0.0, + "height": 0.0 + } + }, + "m_Slots": [ + { + "m_Id": "68843a1530364884828bf50100da3587" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_SerializedDescriptor": "SurfaceDescription.Smoothness" +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "5d7643b08d804f31bd41f5a3bfac87d0", + "m_Id": 2, + "m_DisplayName": "G", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "G", + "m_StageCapability": 3, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.BlockNode", + "m_ObjectId": "65b74c74a44b4a548fe6adeb28c67843", + "m_Group": { + "m_Id": "" + }, + "m_Name": "SurfaceDescription.Metallic", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": 0.0, + "y": 0.0, + "width": 0.0, + "height": 0.0 + } + }, + "m_Slots": [ + { + "m_Id": "4480df450181490f8932319d9e328884" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_SerializedDescriptor": "SurfaceDescription.Metallic" +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "68843a1530364884828bf50100da3587", + "m_Id": 0, + "m_DisplayName": "Smoothness", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "Smoothness", + "m_StageCapability": 2, + "m_Value": 1.0, + "m_DefaultValue": 0.5, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.PropertyNode", + "m_ObjectId": "6b99729f67904be4aea86bc755303534", + "m_Group": { + "m_Id": "" + }, + "m_Name": "Property", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -757.0, + "y": 354.0, + "width": 106.0, + "height": 34.0 + } + }, + "m_Slots": [ + { + "m_Id": "9234b5d618654b758c0cff32271ecc3c" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_Property": { + "m_Id": "176f796389af4a2db4eccc60e9a2db9f" + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.PropertyNode", + "m_ObjectId": "6d1dc4795b264f5bbdd976496fa4f0db", + "m_Group": { + "m_Id": "" + }, + "m_Name": "Property", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -1041.0, + "y": -167.00003051757813, + "width": 143.0, + "height": 34.0 + } + }, + "m_Slots": [ + { + "m_Id": "f832297ee7574988a54c2eff2deee91b" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_Property": { + "m_Id": "2fd9bed3ea22484c8fd8fb96b6721875" + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.BlockNode", + "m_ObjectId": "6e21aade13a14946a4a3369e57908a65", + "m_Group": { + "m_Id": "" + }, + "m_Name": "SurfaceDescription.Alpha", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": 0.0, + "y": 0.0, + "width": 0.0, + "height": 0.0 + } + }, + "m_Slots": [ + { + "m_Id": "e9356d6806194ca1804cf13a388a1a1a" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_SerializedDescriptor": "SurfaceDescription.Alpha" +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.BlockNode", + "m_ObjectId": "6f8db90efdd247a6ac3fead2f1fd4855", + "m_Group": { + "m_Id": "" + }, + "m_Name": "SurfaceDescription.BaseColor", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": 0.0, + "y": 0.0, + "width": 0.0, + "height": 0.0 + } + }, + "m_Slots": [ + { + "m_Id": "08a1278372be48f6b292c6fe8b0eea09" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_SerializedDescriptor": "SurfaceDescription.BaseColor" +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicValueMaterialSlot", + "m_ObjectId": "7be6792ef51f4b5a90b474d9dab7231c", + "m_Id": 0, + "m_DisplayName": "A", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "A", + "m_StageCapability": 3, + "m_Value": { + "e00": 0.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 0.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 0.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 0.0 + }, + "m_DefaultValue": { + "e00": 1.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 1.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 1.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.UVNode", + "m_ObjectId": "7c697b79a9b54c9ab6076867dd485bfb", + "m_Group": { + "m_Id": "" + }, + "m_Name": "UV", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -2683.0, + "y": -527.0000610351563, + "width": 208.0, + "height": 313.9999694824219 + } + }, + "m_Slots": [ + { + "m_Id": "c3eb306ca09745cfb56811516bf4a2fe" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_OutputChannel": 0 +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.Rendering.HighDefinition.ShaderGraph.HDTarget", + "m_ObjectId": "7c95dbc72baf49c786b6c536d2840f92", + "m_ActiveSubTarget": { + "m_Id": "2077fc8640eb453f8f42a6a219f51ad0" + }, + "m_Datas": [ + { + "m_Id": "c83a7c4d6b9c48668c0ac278af0f3b1a" + }, + { + "m_Id": "dbcba7487daa4d538cd5e2c340e72e4a" + }, + { + "m_Id": "aa3e357fd1db49ef8292fd547f95a0b6" + }, + { + "m_Id": "589350db00704ba7bc103b29f988ae67" + } + ], + "m_CustomEditorGUI": "" +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "7cbea127a83d41f8845e88541a991773", + "m_Id": 1, + "m_DisplayName": "B", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "B", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "7cddc28459f0407da8ca31d1d121d70e", + "m_Id": 0, + "m_DisplayName": "Ambient Occlusion", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "Occlusion", + "m_StageCapability": 2, + "m_Value": 1.0, + "m_DefaultValue": 1.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "7d2ed2a8f2104866905859364b1f77de", + "m_Id": 2, + "m_DisplayName": "Out", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.PropertyNode", + "m_ObjectId": "7e564e61322144d38ed80873315bb755", + "m_Group": { + "m_Id": "" + }, + "m_Name": "Property", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -1418.0, + "y": -244.00001525878907, + "width": 136.0, + "height": 34.0 + } + }, + "m_Slots": [ + { + "m_Id": "55873bf4efd44a7ab7e799ea89fb1f33" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_Property": { + "m_Id": "527b2200125f4198be5a7b45d50aa84f" + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.SplitNode", + "m_ObjectId": "81588ca3909941f0a3ff8839d013ed92", + "m_Group": { + "m_Id": "" + }, + "m_Name": "Split", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -2451.0, + "y": -527.0000610351563, + "width": 119.99999237060547, + "height": 149.0 + } + }, + "m_Slots": [ + { + "m_Id": "39a8792212bf427b9c9ad49205266f12" + }, + { + "m_Id": "96445295e1364965bf0ed8a2d7950a8f" + }, + { + "m_Id": "5d7643b08d804f31bd41f5a3bfac87d0" + }, + { + "m_Id": "d922ec7d3d5540f1b71a5a6dfdf3d024" + }, + { + "m_Id": "28961bf51e8c4cf8a6fad28f3611651e" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.BlockNode", + "m_ObjectId": "8309ce333a1f49fc9985776db2ad48df", + "m_Group": { + "m_Id": "" + }, + "m_Name": "SurfaceDescription.Occlusion", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": 0.0, + "y": 0.0, + "width": 0.0, + "height": 0.0 + } + }, + "m_Slots": [ + { + "m_Id": "7cddc28459f0407da8ca31d1d121d70e" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_SerializedDescriptor": "SurfaceDescription.Occlusion" +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.TangentMaterialSlot", + "m_ObjectId": "849e35819aa9411d975e93ff521ce8f3", + "m_Id": 0, + "m_DisplayName": "Tangent", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "Tangent", + "m_StageCapability": 1, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0 + }, + "m_Labels": [], + "m_Space": 0 +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicValueMaterialSlot", + "m_ObjectId": "8773c57b01824dc298009432c0bb6bf0", + "m_Id": 2, + "m_DisplayName": "Out", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": { + "e00": 0.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 0.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 0.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 0.0 + }, + "m_DefaultValue": { + "e00": 1.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 1.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 1.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "8abf13ba92a44c07b3c81b2e1e3db26a", + "m_Id": 3, + "m_DisplayName": "Z", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "Z", + "m_StageCapability": 3, + "m_Value": 1.0, + "m_DefaultValue": 0.0, + "m_Labels": [ + "Z" + ] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.PositionMaterialSlot", + "m_ObjectId": "8f161e67e50c4463a34685b1e7e53e58", + "m_Id": 0, + "m_DisplayName": "Position", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "Position", + "m_StageCapability": 1, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0 + }, + "m_Labels": [], + "m_Space": 0 +} + +{ + "m_SGVersion": 1, + "m_Type": "UnityEditor.ShaderGraph.Internal.Vector1ShaderProperty", + "m_ObjectId": "8fe532ea543d401da0e49bd95ab3df2e", + "m_Guid": { + "m_GuidSerialized": "6b3ee90f-1421-4dce-9a4e-601507c34374" + }, + "m_Name": "Metallic", + "m_DefaultReferenceName": "Vector1_8fe532ea543d401da0e49bd95ab3df2e", + "m_OverrideReferenceName": "_Metallic", + "m_GeneratePropertyBlock": true, + "m_Precision": 0, + "overrideHLSLDeclaration": false, + "hlslDeclarationOverride": 0, + "m_Hidden": false, + "m_Value": 0.0, + "m_FloatType": 1, + "m_RangeValues": { + "x": 0.0, + "y": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "9234b5d618654b758c0cff32271ecc3c", + "m_Id": 0, + "m_DisplayName": "Alpha", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "96445295e1364965bf0ed8a2d7950a8f", + "m_Id": 1, + "m_DisplayName": "R", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "R", + "m_StageCapability": 3, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "98e1ca9e565c47f0b37c7c5bd5bbf6a3", + "m_Id": 3, + "m_DisplayName": "Out", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.AddNode", + "m_ObjectId": "9db9de202b6a48a9b9fb6042812610c9", + "m_Group": { + "m_Id": "" + }, + "m_Name": "Add", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -407.0000305175781, + "y": -559.0, + "width": 130.0, + "height": 118.00000762939453 + } + }, + "m_Slots": [ + { + "m_Id": "15b5aedfa2a74b5f8c413bf09594fe46" + }, + { + "m_Id": "7cbea127a83d41f8845e88541a991773" + }, + { + "m_Id": "c5b72ad88e634eb485989cba89946154" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector4MaterialSlot", + "m_ObjectId": "9f820a8d782644b28a83e495dc5518f7", + "m_Id": 0, + "m_DisplayName": "Color", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_Labels": [] +} + +{ + "m_SGVersion": 1, + "m_Type": "UnityEditor.ShaderGraph.PositionNode", + "m_ObjectId": "9f9efe7a498c41f99d37c36416dfe120", + "m_Group": { + "m_Id": "" + }, + "m_Name": "Position", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -853.0, + "y": -776.0, + "width": 206.0, + "height": 131.99998474121095 + } + }, + "m_Slots": [ + { + "m_Id": "390b7ae958e849318d2dc40c1658ee87" + } + ], + "synonyms": [], + "m_Precision": 1, + "m_PreviewExpanded": false, + "m_PreviewMode": 2, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_Space": 0 +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "a0f68f9c8425405b98a2dabcfc7b10e0", + "m_Id": 2, + "m_DisplayName": "Out", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "a57351a3cc594b43b53cea3eef447edc", + "m_Id": 2, + "m_DisplayName": "Y", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "Y", + "m_StageCapability": 3, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [ + "Y" + ] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "a6d421ce8cb448ffab1dcb14456961c7", + "m_Id": 1, + "m_DisplayName": "B", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "B", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.PropertyNode", + "m_ObjectId": "a7e4508bd4204559b53ab7057c2ea47a", + "m_Group": { + "m_Id": "" + }, + "m_Name": "Property", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -577.0, + "y": 320.0, + "width": 142.0, + "height": 34.0 + } + }, + "m_Slots": [ + { + "m_Id": "ec83e57af8d9405e803e7f731a79dd6f" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_Property": { + "m_Id": "0b61b839117148d081fd62370f39c4fa" + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "a8e357608d4a4b4a991814f36bc9a165", + "m_Id": 1, + "m_DisplayName": "Out", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.Rendering.HighDefinition.ShaderGraph.LightingData", + "m_ObjectId": "aa3e357fd1db49ef8292fd547f95a0b6", + "m_NormalDropOffSpace": 0, + "m_BlendPreserveSpecular": true, + "m_ReceiveDecals": true, + "m_ReceiveSSR": true, + "m_ReceiveSSRTransparent": false, + "m_SpecularAA": false, + "m_SpecularOcclusionMode": 1, + "m_OverrideBakedGI": false +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicValueMaterialSlot", + "m_ObjectId": "ae67931482db4ed6b367cca41195adc6", + "m_Id": 0, + "m_DisplayName": "A", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "A", + "m_StageCapability": 3, + "m_Value": { + "e00": 0.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 0.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 0.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 0.0 + }, + "m_DefaultValue": { + "e00": 1.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 1.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 1.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.OneMinusNode", + "m_ObjectId": "bf427c58b55946b998c92182f024b9cc", + "m_Group": { + "m_Id": "" + }, + "m_Name": "One Minus", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -1472.0, + "y": -577.0, + "width": 208.00001525878907, + "height": 278.0 + } + }, + "m_Slots": [ + { + "m_Id": "f081538a324b47ce8c45d5f98052cb5f" + }, + { + "m_Id": "435de479889847978ed7bfd0b41a5d8c" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector4MaterialSlot", + "m_ObjectId": "c3eb306ca09745cfb56811516bf4a2fe", + "m_Id": 0, + "m_DisplayName": "Out", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicValueMaterialSlot", + "m_ObjectId": "c58c3bd2939c4cb5ba3fa52f9b33cec8", + "m_Id": 1, + "m_DisplayName": "B", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "B", + "m_StageCapability": 3, + "m_Value": { + "e00": 2.0, + "e01": 2.0, + "e02": 2.0, + "e03": 2.0, + "e10": 2.0, + "e11": 2.0, + "e12": 2.0, + "e13": 2.0, + "e20": 2.0, + "e21": 2.0, + "e22": 2.0, + "e23": 2.0, + "e30": 2.0, + "e31": 2.0, + "e32": 2.0, + "e33": 2.0 + }, + "m_DefaultValue": { + "e00": 1.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 1.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 1.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "c5b72ad88e634eb485989cba89946154", + "m_Id": 2, + "m_DisplayName": "Out", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.Rendering.HighDefinition.ShaderGraph.HDLitData", + "m_ObjectId": "c83a7c4d6b9c48668c0ac278af0f3b1a", + "m_RayTracing": false, + "m_MaterialType": 0, + "m_RefractionModel": 0, + "m_SSSTransmission": true, + "m_EnergyConservingSpecular": false, + "m_ClearCoat": false +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "cf0a4a1618ba4479ae52f976062629eb", + "m_Id": 0, + "m_DisplayName": "Edge1", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "Edge1", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "d49e833a67814491870648c0d301da2d", + "m_Id": 1, + "m_DisplayName": "Edge2", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "Edge2", + "m_StageCapability": 3, + "m_Value": { + "x": 0.05000000074505806, + "y": 1.0, + "z": 1.0, + "w": 1.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "d922ec7d3d5540f1b71a5a6dfdf3d024", + "m_Id": 3, + "m_DisplayName": "B", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "B", + "m_StageCapability": 3, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.Rendering.HighDefinition.ShaderGraph.BuiltinData", + "m_ObjectId": "dbcba7487daa4d538cd5e2c340e72e4a", + "m_Distortion": false, + "m_DistortionMode": 0, + "m_DistortionDepthTest": true, + "m_AddPrecomputedVelocity": false, + "m_TransparentWritesMotionVec": false, + "m_AlphaToMask": false, + "m_DepthOffset": false, + "m_TransparencyFog": true, + "m_AlphaTestShadow": false, + "m_BackThenFrontRendering": false, + "m_TransparentDepthPrepass": false, + "m_TransparentDepthPostpass": false, + "m_SupportLodCrossFade": false +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.SmoothstepNode", + "m_ObjectId": "df8884e1293144aeb491e2aede5bc401", + "m_Group": { + "m_Id": "" + }, + "m_Name": "Smoothstep", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -1741.0, + "y": -577.0, + "width": 208.0, + "height": 326.0 + } + }, + "m_Slots": [ + { + "m_Id": "cf0a4a1618ba4479ae52f976062629eb" + }, + { + "m_Id": "d49e833a67814491870648c0d301da2d" + }, + { + "m_Id": "fbc5e8c5f585494b8f944fd982a3918a" + }, + { + "m_Id": "98e1ca9e565c47f0b37c7c5bd5bbf6a3" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "e9356d6806194ca1804cf13a388a1a1a", + "m_Id": 0, + "m_DisplayName": "Alpha", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "Alpha", + "m_StageCapability": 2, + "m_Value": 0.0, + "m_DefaultValue": 1.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "ec83e57af8d9405e803e7f731a79dd6f", + "m_Id": 0, + "m_DisplayName": "Smoothness", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.MultiplyNode", + "m_ObjectId": "efb8f07140584e32994ba4294d738beb", + "m_Group": { + "m_Id": "" + }, + "m_Name": "Multiply", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -571.0, + "y": 200.0, + "width": 130.0, + "height": 118.0 + } + }, + "m_Slots": [ + { + "m_Id": "7be6792ef51f4b5a90b474d9dab7231c" + }, + { + "m_Id": "c58c3bd2939c4cb5ba3fa52f9b33cec8" + }, + { + "m_Id": "37449710b47441c68337d68de5216b32" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.BlockNode", + "m_ObjectId": "f00b5059a12a49239ef22d406a1dffdc", + "m_Group": { + "m_Id": "" + }, + "m_Name": "VertexDescription.Position", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": 0.0, + "y": 0.0, + "width": 0.0, + "height": 0.0 + } + }, + "m_Slots": [ + { + "m_Id": "8f161e67e50c4463a34685b1e7e53e58" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_SerializedDescriptor": "VertexDescription.Position" +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "f081538a324b47ce8c45d5f98052cb5f", + "m_Id": 0, + "m_DisplayName": "In", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "In", + "m_StageCapability": 3, + "m_Value": { + "x": 1.0, + "y": 1.0, + "z": 1.0, + "w": 1.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.BlockNode", + "m_ObjectId": "f4a4d483d73849b2b0d1a60c8f64de8b", + "m_Group": { + "m_Id": "" + }, + "m_Name": "SurfaceDescription.Emission", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": 0.0, + "y": 0.0, + "width": 0.0, + "height": 0.0 + } + }, + "m_Slots": [ + { + "m_Id": "1dc6d745820944edbf7d15e76310ee6d" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_SerializedDescriptor": "SurfaceDescription.Emission" +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "f832297ee7574988a54c2eff2deee91b", + "m_Id": 0, + "m_DisplayName": "Depth Offset", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.SubtractNode", + "m_ObjectId": "f8a5371f09f94ce58feafce392601b0f", + "m_Group": { + "m_Id": "" + }, + "m_Name": "Subtract", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -2277.0, + "y": -529.0000610351563, + "width": 208.0, + "height": 301.9999694824219 + } + }, + "m_Slots": [ + { + "m_Id": "551b66c4ba5f4460bc0c0a975d80998e" + }, + { + "m_Id": "12f6147f8d4b4711839d556551b1ca4f" + }, + { + "m_Id": "a0f68f9c8425405b98a2dabcfc7b10e0" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.BlockNode", + "m_ObjectId": "fa0f7d95093e470fa5e98df9d2c6ff99", + "m_Group": { + "m_Id": "" + }, + "m_Name": "VertexDescription.Tangent", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": 0.0, + "y": 0.0, + "width": 0.0, + "height": 0.0 + } + }, + "m_Slots": [ + { + "m_Id": "849e35819aa9411d975e93ff521ce8f3" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_SerializedDescriptor": "VertexDescription.Tangent" +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.BlockNode", + "m_ObjectId": "fb462c5b218249f8a70924bdad87751b", + "m_Group": { + "m_Id": "" + }, + "m_Name": "VertexDescription.Normal", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": 0.0, + "y": 0.0, + "width": 0.0, + "height": 0.0 + } + }, + "m_Slots": [ + { + "m_Id": "031560bebbf14091bba33714fb220f2b" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_SerializedDescriptor": "VertexDescription.Normal" +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "fbc5e8c5f585494b8f944fd982a3918a", + "m_Id": 2, + "m_DisplayName": "In", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "In", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.NormalMaterialSlot", + "m_ObjectId": "fbf2398fe0c54757b73aa17996db52b1", + "m_Id": 0, + "m_DisplayName": "Normal (Tangent Space)", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "NormalTS", + "m_StageCapability": 2, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0 + }, + "m_Labels": [], + "m_Space": 3 +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.MultiplyNode", + "m_ObjectId": "fd758c07e8984094a39d3836ef942fa2", + "m_Group": { + "m_Id": "" + }, + "m_Name": "Multiply", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -1194.0, + "y": -405.0000305175781, + "width": 126.0, + "height": 118.0 + } + }, + "m_Slots": [ + { + "m_Id": "ae67931482db4ed6b367cca41195adc6" + }, + { + "m_Id": "2e40d06b8dad4c65a4a1ce9b7cb5993d" + }, + { + "m_Id": "8773c57b01824dc298009432c0bb6bf0" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + diff --git a/HDRP/Shaders/RL_TearlineShader_HDRP.shadergraph.meta b/HDRP/Shaders/RL_TearlineShader_HDRP.shadergraph.meta new file mode 100644 index 0000000..217620c --- /dev/null +++ b/HDRP/Shaders/RL_TearlineShader_HDRP.shadergraph.meta @@ -0,0 +1,10 @@ +fileFormatVersion: 2 +guid: 5acd4540882388b44adfb140c6c6290b +ScriptedImporter: + internalIDToNameTable: [] + externalObjects: {} + serializedVersion: 2 + userData: + assetBundleName: + assetBundleVariant: + script: {fileID: 11500000, guid: 625f186215c104763be7675aa2d941aa, type: 3} diff --git a/HDRP/Shaders/RL_TeethShader_HDRP.shadergraph b/HDRP/Shaders/RL_TeethShader_HDRP.shadergraph new file mode 100644 index 0000000..79fba60 --- /dev/null +++ b/HDRP/Shaders/RL_TeethShader_HDRP.shadergraph @@ -0,0 +1,7740 @@ +{ + "m_SGVersion": 2, + "m_Type": "UnityEditor.ShaderGraph.GraphData", + "m_ObjectId": "f85a4e4b91df4a7db442a14fde53ed87", + "m_Properties": [ + { + "m_Id": "cb42572a46a74a588ef3935f3a667eb7" + }, + { + "m_Id": "3345a7b9279a48b7ba4602df55d812ac" + }, + { + "m_Id": "8a49d2f872e946d4a29e2030ee291584" + }, + { + "m_Id": "6d2408803a794f2e9368d5529b79a574" + }, + { + "m_Id": "221c3eb893034a10a0e04ad5230e2bb0" + }, + { + "m_Id": "2adde9b6c89f49aa838e8cfc38e04353" + }, + { + "m_Id": "c70d342b1a0b4d6bbf1ff3c98fd338ea" + }, + { + "m_Id": "c4024195aefa495695710ffb5997a875" + }, + { + "m_Id": "daa99c4f268449b8a4e69fdaeafcfe49" + }, + { + "m_Id": "a1eb91167291491694bf1bdf8d2f3e16" + }, + { + "m_Id": "229e12ce054c4003affcf25346b88151" + }, + { + "m_Id": "94ca5b7030dd47cf8a414dd9fee0ecde" + }, + { + "m_Id": "66cc0b010f5647d5bf80ded4825cab7c" + }, + { + "m_Id": "769181578f94433984a73faf6e153757" + }, + { + "m_Id": "1550f5487be34993bc1704c8c3d8ba14" + }, + { + "m_Id": "fb85416d2e4d4df7b227e0bc2bdd6a71" + }, + { + "m_Id": "ddd87d19404f41b8bbbd24232f4338ac" + }, + { + "m_Id": "fd115c5a3bec4b6eabfabdb2fdf437e6" + }, + { + "m_Id": "554e041e04cb41379e9bbb0c5e80d80c" + }, + { + "m_Id": "e25a1c81f1374f178c8f27b6264a5f1b" + }, + { + "m_Id": "fea586edf5974ba687a3f05c3d4b6623" + }, + { + "m_Id": "0132cd9db49941618ed4bec849f97956" + }, + { + "m_Id": "3c380077c517483f8c6dbb95eb0de6b7" + } + ], + "m_Keywords": [], + "m_Nodes": [ + { + "m_Id": "4b45669a84054c498babd493511b3189" + }, + { + "m_Id": "0153caa15e554a9bb37fea4238ebdc5b" + }, + { + "m_Id": "00ab9614abb14bfea39934b2abff144b" + }, + { + "m_Id": "8a7ae7a881424567bd38f733cff73869" + }, + { + "m_Id": "bc0c9bafa3544deaaba658da5d1457a2" + }, + { + "m_Id": "08c1176d7dfe406bb0f6283ca763d553" + }, + { + "m_Id": "e701720035d44304a33f4b64350fc6e3" + }, + { + "m_Id": "6a4b619cae09428e850340b327dc2247" + }, + { + "m_Id": "6b280d605cf34b63ae417129545c2f7d" + }, + { + "m_Id": "e1e6ea93dab24d4086de0ce0507e9306" + }, + { + "m_Id": "d04a1ba74b404509b3874993b5771fe4" + }, + { + "m_Id": "847ac5df0b2d4dd58b05ed5100fd2d88" + }, + { + "m_Id": "0556880e701d48e589655db291ee6099" + }, + { + "m_Id": "273f61f0afd2438d95da7144e127460e" + }, + { + "m_Id": "8d0e91598db04dc39429e4727f60af22" + }, + { + "m_Id": "fce699c8ebf3428887ef6a715d55d4f9" + }, + { + "m_Id": "69822902c84c428080db9893d32ee267" + }, + { + "m_Id": "9203aadcc7e34fcbb60c753b4a4bd252" + }, + { + "m_Id": "2a43d5b227114bb2b6f245cbdffd15e5" + }, + { + "m_Id": "92460f8b665b4a03bb23e7fe80bdff90" + }, + { + "m_Id": "959bbc37ca814b42be52d1bd1b64e66f" + }, + { + "m_Id": "9abeb9fdadd74574b4e6738541daa06a" + }, + { + "m_Id": "2083576ab59b4225b9973e37eb2c681d" + }, + { + "m_Id": "1ceaea2d8a314216847b3e129a914f2c" + }, + { + "m_Id": "281c2fab10a54a88ace70a99836fe852" + }, + { + "m_Id": "5b5d90ab491f441884a78ece78c6e7a1" + }, + { + "m_Id": "ac06b0e4495e41ed855cc55978b80d86" + }, + { + "m_Id": "c2ce8f28915943d49e5539ae59b0b3bf" + }, + { + "m_Id": "d906043505fc466c9a6cd86bdf86c0a5" + }, + { + "m_Id": "12dd7939821a43b79a61d2ffaeb5c849" + }, + { + "m_Id": "3ab5c0ee94fd444da94411d41e7fa2fd" + }, + { + "m_Id": "9580d9a4456845628acd8d7bef5397c7" + }, + { + "m_Id": "71d1e8a063514b2680bf1f014cbf9938" + }, + { + "m_Id": "85bba8f52afa4634a8cdd48d4a82cf0f" + }, + { + "m_Id": "04e6d8d885c84b27b65b379ce432f20d" + }, + { + "m_Id": "3843f3d297af4a55ac742acfed12ffcd" + }, + { + "m_Id": "252fe33b41ea44cc8726e40323b8fcdd" + }, + { + "m_Id": "8f9edc1bf1ec427e838b9955e23e472c" + }, + { + "m_Id": "488966045eba4552923a1ce35c8dd3ad" + }, + { + "m_Id": "095b3273b8844071b47eee774677bf1d" + }, + { + "m_Id": "369e9b41ff1541cd848d3e2e3d27a296" + }, + { + "m_Id": "4ee3e3b188a4495fb5be187a9f57cc27" + }, + { + "m_Id": "10d4a3e3e58e4ff790ff2d946010a94b" + }, + { + "m_Id": "de23ea96dbbf4a4c9b9f59fe819fe830" + }, + { + "m_Id": "b26e5b0f3f8e4e07b17ce5d3e9ec04f3" + }, + { + "m_Id": "e28e83ed9ea04d5d9fea68c35524c5c0" + }, + { + "m_Id": "62b5be26cb11438e9889eb7804f65072" + }, + { + "m_Id": "1b9c7cb2fc9a436886a8562251d803ba" + }, + { + "m_Id": "945b619d201d4c6990c808ef712b4bef" + }, + { + "m_Id": "186d4331956b49ab9881ec6c6a1171de" + }, + { + "m_Id": "0aaaf2cdbe3a40b79ff5a3f1aef6e5cb" + }, + { + "m_Id": "28ae424fd1a4444bb0837c1aeea72544" + }, + { + "m_Id": "f3f278701bf042e09eb0e843b0ff4647" + }, + { + "m_Id": "ceb473d265c546e3ab12eb99b9035c9e" + }, + { + "m_Id": "6c08aa06107d4f5ea147fda94e1e3b45" + }, + { + "m_Id": "021582fda07349f398f3c9f02f57225f" + }, + { + "m_Id": "179e8569173e4d38804675280e97dd7a" + }, + { + "m_Id": "1be46edca1ea4d9cb6baccbe5025e1cd" + }, + { + "m_Id": "8c2615acff244d42be930682540c2f44" + }, + { + "m_Id": "3eef59649e0d4bb995c91e89f7d8a40e" + }, + { + "m_Id": "79276f373c29455fb1e2f5d0bc8b37bd" + }, + { + "m_Id": "b0b996e73e264d88b95284c03a428f41" + }, + { + "m_Id": "f0c7d06b68da4a81b05e5961b1cb89b8" + }, + { + "m_Id": "3d43204b11764dad841dd7d29c54794d" + }, + { + "m_Id": "65bdb854bdc642a89bb995ee784e4d0d" + } + ], + "m_GroupDatas": [], + "m_StickyNoteDatas": [ + { + "m_Id": "1445382bcb70439b8e2c097b4a733e73" + } + ], + "m_Edges": [ + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "021582fda07349f398f3c9f02f57225f" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "1be46edca1ea4d9cb6baccbe5025e1cd" + }, + "m_SlotId": 1 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "04e6d8d885c84b27b65b379ce432f20d" + }, + "m_SlotId": 4 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "b26e5b0f3f8e4e07b17ce5d3e9ec04f3" + }, + "m_SlotId": 2 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "04e6d8d885c84b27b65b379ce432f20d" + }, + "m_SlotId": 5 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "b26e5b0f3f8e4e07b17ce5d3e9ec04f3" + }, + "m_SlotId": 1 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "0556880e701d48e589655db291ee6099" + }, + "m_SlotId": 5 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "3d43204b11764dad841dd7d29c54794d" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "0556880e701d48e589655db291ee6099" + }, + "m_SlotId": 7 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "79276f373c29455fb1e2f5d0bc8b37bd" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "095b3273b8844071b47eee774677bf1d" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "369e9b41ff1541cd848d3e2e3d27a296" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "0aaaf2cdbe3a40b79ff5a3f1aef6e5cb" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "1b9c7cb2fc9a436886a8562251d803ba" + }, + "m_SlotId": 1 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "10d4a3e3e58e4ff790ff2d946010a94b" + }, + "m_SlotId": 2 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "8a7ae7a881424567bd38f733cff73869" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "12dd7939821a43b79a61d2ffaeb5c849" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "ac06b0e4495e41ed855cc55978b80d86" + }, + "m_SlotId": 1 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "179e8569173e4d38804675280e97dd7a" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "1be46edca1ea4d9cb6baccbe5025e1cd" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "186d4331956b49ab9881ec6c6a1171de" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "e28e83ed9ea04d5d9fea68c35524c5c0" + }, + "m_SlotId": 1 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "1b9c7cb2fc9a436886a8562251d803ba" + }, + "m_SlotId": 2 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "ceb473d265c546e3ab12eb99b9035c9e" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "1be46edca1ea4d9cb6baccbe5025e1cd" + }, + "m_SlotId": 3 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "3eef59649e0d4bb995c91e89f7d8a40e" + }, + "m_SlotId": 1 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "1be46edca1ea4d9cb6baccbe5025e1cd" + }, + "m_SlotId": 3 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "4ee3e3b188a4495fb5be187a9f57cc27" + }, + "m_SlotId": 2 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "1be46edca1ea4d9cb6baccbe5025e1cd" + }, + "m_SlotId": 3 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "8c2615acff244d42be930682540c2f44" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "1ceaea2d8a314216847b3e129a914f2c" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "959bbc37ca814b42be52d1bd1b64e66f" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "2083576ab59b4225b9973e37eb2c681d" + }, + "m_SlotId": 2 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "ac06b0e4495e41ed855cc55978b80d86" + }, + "m_SlotId": 2 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "252fe33b41ea44cc8726e40323b8fcdd" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "8f9edc1bf1ec427e838b9955e23e472c" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "281c2fab10a54a88ace70a99836fe852" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "9abeb9fdadd74574b4e6738541daa06a" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "28ae424fd1a4444bb0837c1aeea72544" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "62b5be26cb11438e9889eb7804f65072" + }, + "m_SlotId": 1 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "2a43d5b227114bb2b6f245cbdffd15e5" + }, + "m_SlotId": 3 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "281c2fab10a54a88ace70a99836fe852" + }, + "m_SlotId": 2 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "369e9b41ff1541cd848d3e2e3d27a296" + }, + "m_SlotId": 3 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "8d0e91598db04dc39429e4727f60af22" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "3843f3d297af4a55ac742acfed12ffcd" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "8f9edc1bf1ec427e838b9955e23e472c" + }, + "m_SlotId": 1 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "3ab5c0ee94fd444da94411d41e7fa2fd" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "2083576ab59b4225b9973e37eb2c681d" + }, + "m_SlotId": 1 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "3d43204b11764dad841dd7d29c54794d" + }, + "m_SlotId": 1 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "f0c7d06b68da4a81b05e5961b1cb89b8" + }, + "m_SlotId": 1 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "3eef59649e0d4bb995c91e89f7d8a40e" + }, + "m_SlotId": 2 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "273f61f0afd2438d95da7144e127460e" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "488966045eba4552923a1ce35c8dd3ad" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "369e9b41ff1541cd848d3e2e3d27a296" + }, + "m_SlotId": 1 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "4ee3e3b188a4495fb5be187a9f57cc27" + }, + "m_SlotId": 3 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "6a4b619cae09428e850340b327dc2247" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "5b5d90ab491f441884a78ece78c6e7a1" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "9abeb9fdadd74574b4e6738541daa06a" + }, + "m_SlotId": 1 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "62b5be26cb11438e9889eb7804f65072" + }, + "m_SlotId": 2 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "945b619d201d4c6990c808ef712b4bef" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "65bdb854bdc642a89bb995ee784e4d0d" + }, + "m_SlotId": 1 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "6b280d605cf34b63ae417129545c2f7d" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "69822902c84c428080db9893d32ee267" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "1ceaea2d8a314216847b3e129a914f2c" + }, + "m_SlotId": 1 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "6c08aa06107d4f5ea147fda94e1e3b45" + }, + "m_SlotId": 1 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "ceb473d265c546e3ab12eb99b9035c9e" + }, + "m_SlotId": 2 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "71d1e8a063514b2680bf1f014cbf9938" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "04e6d8d885c84b27b65b379ce432f20d" + }, + "m_SlotId": 1 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "79276f373c29455fb1e2f5d0bc8b37bd" + }, + "m_SlotId": 3 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "2083576ab59b4225b9973e37eb2c681d" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "847ac5df0b2d4dd58b05ed5100fd2d88" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "62b5be26cb11438e9889eb7804f65072" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "847ac5df0b2d4dd58b05ed5100fd2d88" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "e28e83ed9ea04d5d9fea68c35524c5c0" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "85bba8f52afa4634a8cdd48d4a82cf0f" + }, + "m_SlotId": 4 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "369e9b41ff1541cd848d3e2e3d27a296" + }, + "m_SlotId": 2 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "85bba8f52afa4634a8cdd48d4a82cf0f" + }, + "m_SlotId": 4 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "6c08aa06107d4f5ea147fda94e1e3b45" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "85bba8f52afa4634a8cdd48d4a82cf0f" + }, + "m_SlotId": 4 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "8f9edc1bf1ec427e838b9955e23e472c" + }, + "m_SlotId": 2 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "8c2615acff244d42be930682540c2f44" + }, + "m_SlotId": 1 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "10d4a3e3e58e4ff790ff2d946010a94b" + }, + "m_SlotId": 1 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "8f9edc1bf1ec427e838b9955e23e472c" + }, + "m_SlotId": 3 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "3eef59649e0d4bb995c91e89f7d8a40e" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "9203aadcc7e34fcbb60c753b4a4bd252" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "281c2fab10a54a88ace70a99836fe852" + }, + "m_SlotId": 1 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "92460f8b665b4a03bb23e7fe80bdff90" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "2a43d5b227114bb2b6f245cbdffd15e5" + }, + "m_SlotId": 1 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "945b619d201d4c6990c808ef712b4bef" + }, + "m_SlotId": 2 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "ceb473d265c546e3ab12eb99b9035c9e" + }, + "m_SlotId": 1 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "9580d9a4456845628acd8d7bef5397c7" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "85bba8f52afa4634a8cdd48d4a82cf0f" + }, + "m_SlotId": 1 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "959bbc37ca814b42be52d1bd1b64e66f" + }, + "m_SlotId": 2 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "bc0c9bafa3544deaaba658da5d1457a2" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "9abeb9fdadd74574b4e6738541daa06a" + }, + "m_SlotId": 2 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "959bbc37ca814b42be52d1bd1b64e66f" + }, + "m_SlotId": 1 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "ac06b0e4495e41ed855cc55978b80d86" + }, + "m_SlotId": 3 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "4ee3e3b188a4495fb5be187a9f57cc27" + }, + "m_SlotId": 1 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "b0b996e73e264d88b95284c03a428f41" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "f0c7d06b68da4a81b05e5961b1cb89b8" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "b26e5b0f3f8e4e07b17ce5d3e9ec04f3" + }, + "m_SlotId": 3 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "1be46edca1ea4d9cb6baccbe5025e1cd" + }, + "m_SlotId": 2 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "c2ce8f28915943d49e5539ae59b0b3bf" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "0556880e701d48e589655db291ee6099" + }, + "m_SlotId": 1 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "ceb473d265c546e3ab12eb99b9035c9e" + }, + "m_SlotId": 3 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "10d4a3e3e58e4ff790ff2d946010a94b" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "d04a1ba74b404509b3874993b5771fe4" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "847ac5df0b2d4dd58b05ed5100fd2d88" + }, + "m_SlotId": 1 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "d906043505fc466c9a6cd86bdf86c0a5" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "ac06b0e4495e41ed855cc55978b80d86" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "de23ea96dbbf4a4c9b9f59fe819fe830" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "b26e5b0f3f8e4e07b17ce5d3e9ec04f3" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "e28e83ed9ea04d5d9fea68c35524c5c0" + }, + "m_SlotId": 2 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "1b9c7cb2fc9a436886a8562251d803ba" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "f0c7d06b68da4a81b05e5961b1cb89b8" + }, + "m_SlotId": 2 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "65bdb854bdc642a89bb995ee784e4d0d" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "f3f278701bf042e09eb0e843b0ff4647" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "945b619d201d4c6990c808ef712b4bef" + }, + "m_SlotId": 1 + } + } + ], + "m_VertexContext": { + "m_Position": { + "x": 1170.9998779296875, + "y": 1.9999842643737794 + }, + "m_Blocks": [ + { + "m_Id": "4b45669a84054c498babd493511b3189" + }, + { + "m_Id": "0153caa15e554a9bb37fea4238ebdc5b" + }, + { + "m_Id": "00ab9614abb14bfea39934b2abff144b" + } + ] + }, + "m_FragmentContext": { + "m_Position": { + "x": 1171.9998779296875, + "y": 248.9999542236328 + }, + "m_Blocks": [ + { + "m_Id": "8a7ae7a881424567bd38f733cff73869" + }, + { + "m_Id": "08c1176d7dfe406bb0f6283ca763d553" + }, + { + "m_Id": "e701720035d44304a33f4b64350fc6e3" + }, + { + "m_Id": "e1e6ea93dab24d4086de0ce0507e9306" + }, + { + "m_Id": "273f61f0afd2438d95da7144e127460e" + }, + { + "m_Id": "8d0e91598db04dc39429e4727f60af22" + }, + { + "m_Id": "6b280d605cf34b63ae417129545c2f7d" + }, + { + "m_Id": "fce699c8ebf3428887ef6a715d55d4f9" + }, + { + "m_Id": "6a4b619cae09428e850340b327dc2247" + }, + { + "m_Id": "bc0c9bafa3544deaaba658da5d1457a2" + } + ] + }, + "m_PreviewData": { + "serializedMesh": { + "m_SerializedMesh": "{\"mesh\":{\"instanceID\":0}}", + "m_Guid": "" + } + }, + "m_Path": "Shader Graphs", + "m_ConcretePrecision": 0, + "m_PreviewMode": 2, + "m_OutputNode": { + "m_Id": "" + }, + "m_ActiveTargets": [ + { + "m_Id": "0083909e70ac4601afc22e423a6e3d2e" + } + ] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.Rendering.HighDefinition.ShaderGraph.HDTarget", + "m_ObjectId": "0083909e70ac4601afc22e423a6e3d2e", + "m_ActiveSubTarget": { + "m_Id": "650ef699f8534d05b11661f3db2c1e50" + }, + "m_Datas": [ + { + "m_Id": "b00f1b66025c4b25a6f709e3c0ab54f4" + }, + { + "m_Id": "88f0b3d71738482fb6273b754134b4dd" + }, + { + "m_Id": "2a2960edadd1494c8e81b3d852cb3297" + }, + { + "m_Id": "5e856e0c3b704d14a6c36b84bf8d78f6" + } + ], + "m_CustomEditorGUI": "" +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.BlockNode", + "m_ObjectId": "00ab9614abb14bfea39934b2abff144b", + "m_Group": { + "m_Id": "" + }, + "m_Name": "VertexDescription.Tangent", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": 0.0, + "y": 0.0, + "width": 0.0, + "height": 0.0 + } + }, + "m_Slots": [ + { + "m_Id": "c996e165d42c4929928bc49c5e17d734" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_SerializedDescriptor": "VertexDescription.Tangent" +} + +{ + "m_SGVersion": 1, + "m_Type": "UnityEditor.ShaderGraph.Internal.Vector1ShaderProperty", + "m_ObjectId": "0132cd9db49941618ed4bec849f97956", + "m_Guid": { + "m_GuidSerialized": "7e7ba2c7-42da-4e3d-8475-98e98400f0ed" + }, + "m_Name": "Gums Thickness", + "m_DefaultReferenceName": "Vector1_0132cd9db49941618ed4bec849f97956", + "m_OverrideReferenceName": "_GumsThickness", + "m_GeneratePropertyBlock": true, + "m_Precision": 0, + "overrideHLSLDeclaration": false, + "hlslDeclarationOverride": 0, + "m_Hidden": false, + "m_Value": 0.8500000238418579, + "m_FloatType": 1, + "m_RangeValues": { + "x": 0.0, + "y": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.BlockNode", + "m_ObjectId": "0153caa15e554a9bb37fea4238ebdc5b", + "m_Group": { + "m_Id": "" + }, + "m_Name": "VertexDescription.Normal", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": 0.0, + "y": 0.0, + "width": 0.0, + "height": 0.0 + } + }, + "m_Slots": [ + { + "m_Id": "3b9bea9727174fc0b9e705617c9903db" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_SerializedDescriptor": "VertexDescription.Normal" +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.PropertyNode", + "m_ObjectId": "021582fda07349f398f3c9f02f57225f", + "m_Group": { + "m_Id": "" + }, + "m_Name": "Property", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -2697.0, + "y": 126.0, + "width": 121.00000762939453, + "height": 34.0 + } + }, + "m_Slots": [ + { + "m_Id": "ea77c3a609ba400e9d279d2e74c1b9bc" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_Property": { + "m_Id": "ddd87d19404f41b8bbbd24232f4338ac" + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "0248b9b1bf9046a59ae067423c1cef66", + "m_Id": 0, + "m_DisplayName": "Rear AO", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Texture2DMaterialSlot", + "m_ObjectId": "03e2818f83814498bb9178cea7ffb00d", + "m_Id": 0, + "m_DisplayName": "Gradient AO Map", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_BareResource": false +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicValueMaterialSlot", + "m_ObjectId": "045329d77ce54209bc36d64001ad3d8d", + "m_Id": 0, + "m_DisplayName": "A", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "A", + "m_StageCapability": 3, + "m_Value": { + "e00": 0.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 0.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 0.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 0.0 + }, + "m_DefaultValue": { + "e00": 1.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 1.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 1.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.SampleTexture2DNode", + "m_ObjectId": "04e6d8d885c84b27b65b379ce432f20d", + "m_Group": { + "m_Id": "" + }, + "m_Name": "Sample Texture 2D", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -3225.000244140625, + "y": 131.0, + "width": 208.0, + "height": 437.0000305175781 + } + }, + "m_Slots": [ + { + "m_Id": "9341dc5c4cf94d6b960a964876b3d428" + }, + { + "m_Id": "32f3a8d8864f407483bdfb32a02f37ea" + }, + { + "m_Id": "4819726fa0474485b5d29c8087c3516e" + }, + { + "m_Id": "39d0eb30a6fc470d8614c68053a81004" + }, + { + "m_Id": "ebadab64ba5e4222bde9e2423849c96c" + }, + { + "m_Id": "4484d7a3020247eeab08441067990b9b" + }, + { + "m_Id": "eeb935f5191a4a59a9bc1ec799914d58" + }, + { + "m_Id": "1e93ca7bb12b4a4cad349c060d01f1a9" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_TextureType": 0, + "m_NormalMapSpace": 0 +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.SampleTexture2DNode", + "m_ObjectId": "0556880e701d48e589655db291ee6099", + "m_Group": { + "m_Id": "" + }, + "m_Name": "Sample Texture 2D", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -3101.0, + "y": 914.0, + "width": 208.0, + "height": 437.0 + } + }, + "m_Slots": [ + { + "m_Id": "86b897ab597140d59a473d807e980628" + }, + { + "m_Id": "5d77a606937f44feb8860c6501cc4557" + }, + { + "m_Id": "37502e011dba43adad5a4c1965f0daf5" + }, + { + "m_Id": "b384faa820304f82807176601dd16753" + }, + { + "m_Id": "ad46a176c1ac40b78ee3a38ad5846d4d" + }, + { + "m_Id": "7c52d0c211b148baa2dee264ed442794" + }, + { + "m_Id": "8c95ccd4e8fd4bf29cc1afa00cc39223" + }, + { + "m_Id": "85c5c76f4845488eb95392938396f2b9" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_TextureType": 0, + "m_NormalMapSpace": 0 +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "05efbcd28970432bab2f0280997fc441", + "m_Id": 7, + "m_DisplayName": "A", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "A", + "m_StageCapability": 2, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.UVMaterialSlot", + "m_ObjectId": "0647cd09207e46a99623889e73580759", + "m_Id": 2, + "m_DisplayName": "UV", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "UV", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0 + }, + "m_Labels": [], + "m_Channel": 0 +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.BlockNode", + "m_ObjectId": "08c1176d7dfe406bb0f6283ca763d553", + "m_Group": { + "m_Id": "" + }, + "m_Name": "SurfaceDescription.BentNormal", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": 0.0, + "y": 0.0, + "width": 0.0, + "height": 0.0 + } + }, + "m_Slots": [ + { + "m_Id": "c4b6c46dc8b348b8a5ecd4e2aead24c0" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_SerializedDescriptor": "SurfaceDescription.BentNormal" +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.PropertyNode", + "m_ObjectId": "095b3273b8844071b47eee774677bf1d", + "m_Group": { + "m_Id": "" + }, + "m_Name": "Property", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -645.0001220703125, + "y": 395.0, + "width": 162.0, + "height": 34.000003814697269 + } + }, + "m_Slots": [ + { + "m_Id": "3de68672d00143c09300da7a5df0f89f" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_Property": { + "m_Id": "0132cd9db49941618ed4bec849f97956" + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector3MaterialSlot", + "m_ObjectId": "09847344f8004a26bdad187ff3b528cd", + "m_Id": 1, + "m_DisplayName": "B", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "B", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 1.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0 + }, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.PropertyNode", + "m_ObjectId": "0aaaf2cdbe3a40b79ff5a3f1aef6e5cb", + "m_Group": { + "m_Id": "" + }, + "m_Name": "Property", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -1733.0, + "y": -1906.0, + "width": 165.0, + "height": 34.0 + } + }, + "m_Slots": [ + { + "m_Id": "ada7147b76d2440ab2f288313b8bc05e" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_Property": { + "m_Id": "769181578f94433984a73faf6e153757" + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicValueMaterialSlot", + "m_ObjectId": "0af9e511272b410c9be3e0b86381e6d0", + "m_Id": 1, + "m_DisplayName": "B", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "B", + "m_StageCapability": 3, + "m_Value": { + "e00": 2.0, + "e01": 2.0, + "e02": 2.0, + "e03": 2.0, + "e10": 2.0, + "e11": 2.0, + "e12": 2.0, + "e13": 2.0, + "e20": 2.0, + "e21": 2.0, + "e22": 2.0, + "e23": 2.0, + "e30": 2.0, + "e31": 2.0, + "e32": 2.0, + "e33": 2.0 + }, + "m_DefaultValue": { + "e00": 1.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 1.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 1.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "0bd3147b039a4a1981a74b5d8942f3bd", + "m_Id": 0, + "m_DisplayName": "Smoothness Power", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "0c32519e62164bb680633ab535302f38", + "m_Id": 3, + "m_DisplayName": "Out", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "0d28e9b96829486b9a93fb4b4493ec53", + "m_Id": 0, + "m_DisplayName": "Smoothness", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "Smoothness", + "m_StageCapability": 2, + "m_Value": 0.5, + "m_DefaultValue": 0.5, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector3MaterialSlot", + "m_ObjectId": "0e019497420c44a9a0fa6321c5d69d66", + "m_Id": 0, + "m_DisplayName": "In", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "In", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0 + }, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.NormalMaterialSlot", + "m_ObjectId": "0e03c873ccc040dd8417724de5eaf36d", + "m_Id": 0, + "m_DisplayName": "Normal (Tangent Space)", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "NormalTS", + "m_StageCapability": 2, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0 + }, + "m_Labels": [], + "m_Space": 3 +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.BlendNode", + "m_ObjectId": "10d4a3e3e58e4ff790ff2d946010a94b", + "m_Group": { + "m_Id": "" + }, + "m_Name": "Blend", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -785.9998779296875, + "y": -853.0, + "width": 208.0, + "height": 362.0 + } + }, + "m_Slots": [ + { + "m_Id": "9d15f391a5b8409498aa0f6fb041d2e4" + }, + { + "m_Id": "3b29885e48574179a150490f9f750a18" + }, + { + "m_Id": "69751d3d0ec748138109118d6e00f2b0" + }, + { + "m_Id": "f84d048317084b7395671a17f7f17fd2" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_BlendMode": 13 +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.PropertyNode", + "m_ObjectId": "12dd7939821a43b79a61d2ffaeb5c849", + "m_Group": { + "m_Id": "" + }, + "m_Name": "Property", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -706.0, + "y": 1188.9998779296875, + "width": 215.99998474121095, + "height": 33.999996185302737 + } + }, + "m_Slots": [ + { + "m_Id": "dab7b0ac196344f9a829a1307ef0b532" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_Property": { + "m_Id": "94ca5b7030dd47cf8a414dd9fee0ecde" + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.StickyNoteData", + "m_ObjectId": "1445382bcb70439b8e2c097b4a733e73", + "m_Title": "HDRP", + "m_Content": "R = Metallic\nG = AO\nB = Micro Normal Mask\nA = Smoothness", + "m_TextSize": 0, + "m_Theme": 0, + "m_Position": { + "serializedVersion": "2", + "x": -3099.0, + "y": 805.0, + "width": 200.0, + "height": 100.0 + }, + "m_Group": { + "m_Id": "" + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "14691abbdb8c44868b2fbf943456a214", + "m_Id": 4, + "m_DisplayName": "R", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "R", + "m_StageCapability": 2, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 1, + "m_Type": "UnityEditor.ShaderGraph.Internal.Vector1ShaderProperty", + "m_ObjectId": "1550f5487be34993bc1704c8c3d8ba14", + "m_Guid": { + "m_GuidSerialized": "916413d1-8f52-4916-b31f-e59f8be81115" + }, + "m_Name": "Teeth Saturation", + "m_DefaultReferenceName": "Vector1_1550f5487be34993bc1704c8c3d8ba14", + "m_OverrideReferenceName": "_TeethSaturation", + "m_GeneratePropertyBlock": true, + "m_Precision": 0, + "overrideHLSLDeclaration": false, + "hlslDeclarationOverride": 0, + "m_Hidden": false, + "m_Value": 0.8999999761581421, + "m_FloatType": 1, + "m_RangeValues": { + "x": 0.0, + "y": 2.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.PropertyNode", + "m_ObjectId": "179e8569173e4d38804675280e97dd7a", + "m_Group": { + "m_Id": "" + }, + "m_Name": "Property", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -2698.0, + "y": 77.00000762939453, + "width": 117.0, + "height": 34.0 + } + }, + "m_Slots": [ + { + "m_Id": "0248b9b1bf9046a59ae067423c1cef66" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_Property": { + "m_Id": "fd115c5a3bec4b6eabfabdb2fdf437e6" + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector4MaterialSlot", + "m_ObjectId": "186cb51092954fe39e95085fa462302e", + "m_Id": 0, + "m_DisplayName": "RGBA", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "RGBA", + "m_StageCapability": 2, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.PropertyNode", + "m_ObjectId": "186d4331956b49ab9881ec6c6a1171de", + "m_Group": { + "m_Id": "" + }, + "m_Name": "Property", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -2137.0, + "y": -1905.0, + "width": 162.0, + "height": 34.0 + } + }, + "m_Slots": [ + { + "m_Id": "f5c37d6cf3c045f4919e914024af7a9b" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_Property": { + "m_Id": "66cc0b010f5647d5bf80ded4825cab7c" + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "1a3d70b35523456698eca34460e6f8b9", + "m_Id": 2, + "m_DisplayName": "False", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "False", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Texture2DMaterialSlot", + "m_ObjectId": "1a6dccb88a494fbebd6d32ab0323405b", + "m_Id": 0, + "m_DisplayName": "Mask Map", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_BareResource": false +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "1b0b004aaf264ca3ada8021ced56d35f", + "m_Id": 0, + "m_DisplayName": "A", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "A", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.MultiplyNode", + "m_ObjectId": "1b9c7cb2fc9a436886a8562251d803ba", + "m_Group": { + "m_Id": "" + }, + "m_Name": "Multiply", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -1550.0, + "y": -1910.0, + "width": 207.99998474121095, + "height": 301.9999694824219 + } + }, + "m_Slots": [ + { + "m_Id": "fa90e5cc1119495385fb038ba542652c" + }, + { + "m_Id": "0af9e511272b410c9be3e0b86381e6d0" + }, + { + "m_Id": "535c5126e61841099e1ad49b42eaefc8" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.LerpNode", + "m_ObjectId": "1be46edca1ea4d9cb6baccbe5025e1cd", + "m_Group": { + "m_Id": "" + }, + "m_Name": "Lerp", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -2512.000244140625, + "y": 63.00000762939453, + "width": 208.00001525878907, + "height": 326.0 + } + }, + "m_Slots": [ + { + "m_Id": "afeed83e13514dbc900674d049c51ac2" + }, + { + "m_Id": "d0dd5fc7d9b24ff3b7471468a1cefe77" + }, + { + "m_Id": "f1e1a955bdb8443eab2e79ba7647a2d0" + }, + { + "m_Id": "c91f545cd7394558a0f4c3fee98fcf42" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "1caef40575a14fb289b47f3bff7861bb", + "m_Id": 3, + "m_DisplayName": "Out", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.SampleTexture2DNode", + "m_ObjectId": "1ceaea2d8a314216847b3e129a914f2c", + "m_Group": { + "m_Id": "" + }, + "m_Name": "Sample Texture 2D", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -872.0, + "y": 1556.0, + "width": 208.0, + "height": 437.0 + } + }, + "m_Slots": [ + { + "m_Id": "186cb51092954fe39e95085fa462302e" + }, + { + "m_Id": "14691abbdb8c44868b2fbf943456a214" + }, + { + "m_Id": "40093fdb515740a6b89991c27475fb70" + }, + { + "m_Id": "62cce88aaad1405d9a4f9103c020132e" + }, + { + "m_Id": "b1d4b45693af46a3a723b2ffb1b8b88a" + }, + { + "m_Id": "eb7f26266d4d47c9a57e818a9e6890dc" + }, + { + "m_Id": "b959e24d88ea43f5bf4256f07ae90ec0" + }, + { + "m_Id": "96f36c732c8e47529d446f73fa12dd82" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_TextureType": 1, + "m_NormalMapSpace": 0 +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "1d1ca274b5fe42e69ce56945c39a8ea7", + "m_Id": 6, + "m_DisplayName": "B", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "B", + "m_StageCapability": 2, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.Rendering.HighDefinition.DiffusionProfileInputMaterialSlot", + "m_ObjectId": "1d4e4c975a3241d5ab63d4debf2aec6a", + "m_Id": 0, + "m_DisplayName": "Diffusion Profile", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "DiffusionProfileHash", + "m_StageCapability": 2, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [], + "m_DiffusionProfile": { + "selectedEntry": 0, + "popupEntries": [] + }, + "m_SerializedDiffusionProfile": "{\n \"diffusionProfileAsset\": {\n \"fileID\": 11400000,\n \"guid\": \"26bdddf49760c61438938733f07fa2a2\",\n \"type\": 2\n }\n}", + "m_Version": 1 +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "1e4b69c907194d94a55567f4a99d7231", + "m_Id": 1, + "m_DisplayName": "", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.SamplerStateMaterialSlot", + "m_ObjectId": "1e93ca7bb12b4a4cad349c060d01f1a9", + "m_Id": 3, + "m_DisplayName": "Sampler", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "Sampler", + "m_StageCapability": 3, + "m_BareResource": false +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicValueMaterialSlot", + "m_ObjectId": "1fe97e2a31024c39bf59ccba87f11b54", + "m_Id": 2, + "m_DisplayName": "Out", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": { + "e00": 0.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 0.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 0.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 0.0 + }, + "m_DefaultValue": { + "e00": 1.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 1.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 1.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.PowerNode", + "m_ObjectId": "2083576ab59b4225b9973e37eb2c681d", + "m_Group": { + "m_Id": "" + }, + "m_Name": "Power", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -699.0, + "y": 1238.9998779296875, + "width": 207.99998474121095, + "height": 301.9999694824219 + } + }, + "m_Slots": [ + { + "m_Id": "4267a37b446f48b88f36740206176441" + }, + { + "m_Id": "bdb35f0f256944dfafd7981d98006c9f" + }, + { + "m_Id": "8547d55cd06b487d8d347cc2a2c0bb74" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Internal.Texture2DShaderProperty", + "m_ObjectId": "221c3eb893034a10a0e04ad5230e2bb0", + "m_Guid": { + "m_GuidSerialized": "39eb79db-b18b-4450-9133-6226333c2052" + }, + "m_Name": "Gums Mask Map", + "m_DefaultReferenceName": "Texture2D_221c3eb893034a10a0e04ad5230e2bb0", + "m_OverrideReferenceName": "_GumsMaskMap", + "m_GeneratePropertyBlock": true, + "m_Precision": 0, + "overrideHLSLDeclaration": false, + "hlslDeclarationOverride": 0, + "m_Hidden": false, + "m_Value": { + "m_SerializedTexture": "{\"texture\":{\"instanceID\":0}}", + "m_Guid": "" + }, + "m_Modifiable": true, + "m_DefaultType": 0 +} + +{ + "m_SGVersion": 1, + "m_Type": "UnityEditor.ShaderGraph.Internal.Vector1ShaderProperty", + "m_ObjectId": "229e12ce054c4003affcf25346b88151", + "m_Guid": { + "m_GuidSerialized": "2bb55888-515a-40aa-8e09-1204f3c80b17" + }, + "m_Name": "Smoothness Min", + "m_DefaultReferenceName": "", + "m_OverrideReferenceName": "_SmoothnessMin", + "m_GeneratePropertyBlock": true, + "m_Precision": 0, + "overrideHLSLDeclaration": false, + "hlslDeclarationOverride": 0, + "m_Hidden": false, + "m_Value": 0.25, + "m_FloatType": 1, + "m_RangeValues": { + "x": 0.0, + "y": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "24c50ccb0f0f46348776e001012f34f7", + "m_Id": 1, + "m_DisplayName": "Out", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.PropertyNode", + "m_ObjectId": "252fe33b41ea44cc8726e40323b8fcdd", + "m_Group": { + "m_Id": "" + }, + "m_Name": "Property", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -650.0000610351563, + "y": -127.99999237060547, + "width": 207.0, + "height": 34.0 + } + }, + "m_Slots": [ + { + "m_Id": "d729776e47ca458d9f698b924845442d" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_Property": { + "m_Id": "e25a1c81f1374f178c8f27b6264a5f1b" + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "2538d7514e264e388d6b89854b05eeb1", + "m_Id": 3, + "m_DisplayName": "Out", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "257e80db9eb84e22a5f409d59f06a941", + "m_Id": 0, + "m_DisplayName": "In", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "In", + "m_StageCapability": 3, + "m_Value": { + "x": 1.0, + "y": 1.0, + "z": 1.0, + "w": 1.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector3MaterialSlot", + "m_ObjectId": "25d3c8e1fdbb4c4fbfd4868867b08f5a", + "m_Id": 0, + "m_DisplayName": "In", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "In", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0 + }, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.UVMaterialSlot", + "m_ObjectId": "261a1463774f402ea6cf22be3927056d", + "m_Id": 0, + "m_DisplayName": "UV", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "UV", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0 + }, + "m_Labels": [], + "m_Channel": 0 +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Texture2DInputMaterialSlot", + "m_ObjectId": "26d61b36c9a4458b99c9cf5016233792", + "m_Id": 1, + "m_DisplayName": "Texture", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "Texture", + "m_StageCapability": 3, + "m_BareResource": false, + "m_Texture": { + "m_SerializedTexture": "{\"texture\":{\"instanceID\":0}}", + "m_Guid": "" + }, + "m_DefaultType": 3 +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.BlockNode", + "m_ObjectId": "273f61f0afd2438d95da7144e127460e", + "m_Group": { + "m_Id": "" + }, + "m_Name": "SurfaceDescription.SubsurfaceMask", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": 0.0, + "y": 0.0, + "width": 0.0, + "height": 0.0 + } + }, + "m_Slots": [ + { + "m_Id": "e8362fd7f2884d1ab1ac906ae9c28004" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_SerializedDescriptor": "SurfaceDescription.SubsurfaceMask" +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.SampleTexture2DNode", + "m_ObjectId": "281c2fab10a54a88ace70a99836fe852", + "m_Group": { + "m_Id": "" + }, + "m_Name": "Sample Texture 2D", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -1171.0001220703125, + "y": 2012.0001220703125, + "width": 184.0, + "height": 253.00001525878907 + } + }, + "m_Slots": [ + { + "m_Id": "69d54d6c4ba64a468f042e25e1f1a0ca" + }, + { + "m_Id": "2af5165093084217aac61b4af29a730d" + }, + { + "m_Id": "c9c382f96969430ca6a46ac85b576bb2" + }, + { + "m_Id": "383a3e546b014329b0e83fd4ea9c0506" + }, + { + "m_Id": "05efbcd28970432bab2f0280997fc441" + }, + { + "m_Id": "26d61b36c9a4458b99c9cf5016233792" + }, + { + "m_Id": "0647cd09207e46a99623889e73580759" + }, + { + "m_Id": "ba586a643825415d9395e0095ddd8d8a" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_TextureType": 1, + "m_NormalMapSpace": 0 +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.PropertyNode", + "m_ObjectId": "28ae424fd1a4444bb0837c1aeea72544", + "m_Group": { + "m_Id": "" + }, + "m_Name": "Property", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -2143.0, + "y": -1304.0001220703125, + "width": 162.0, + "height": 34.0 + } + }, + "m_Slots": [ + { + "m_Id": "4988f5f033184216ad23ac633acc7698" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_Property": { + "m_Id": "1550f5487be34993bc1704c8c3d8ba14" + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.Rendering.HighDefinition.ShaderGraph.LightingData", + "m_ObjectId": "2a2960edadd1494c8e81b3d852cb3297", + "m_NormalDropOffSpace": 0, + "m_BlendPreserveSpecular": true, + "m_ReceiveDecals": true, + "m_ReceiveSSR": true, + "m_ReceiveSSRTransparent": false, + "m_SpecularAA": false, + "m_SpecularOcclusionMode": 1, + "m_OverrideBakedGI": false +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.TilingAndOffsetNode", + "m_ObjectId": "2a43d5b227114bb2b6f245cbdffd15e5", + "m_Group": { + "m_Id": "" + }, + "m_Name": "Tiling And Offset", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -1366.0001220703125, + "y": 2074.0, + "width": 155.0, + "height": 142.0 + } + }, + "m_Slots": [ + { + "m_Id": "261a1463774f402ea6cf22be3927056d" + }, + { + "m_Id": "f9b331b1062048d6b94590012e2f4adb" + }, + { + "m_Id": "c083ca9475264d81936b2f64c2ae9982" + }, + { + "m_Id": "89d785e9bb6c413687505ab305a7ebf9" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Internal.Texture2DShaderProperty", + "m_ObjectId": "2adde9b6c89f49aa838e8cfc38e04353", + "m_Guid": { + "m_GuidSerialized": "26038d6e-7102-4cb8-bc85-ef0263e8d130" + }, + "m_Name": "Gradient AO Map", + "m_DefaultReferenceName": "Texture2D_2adde9b6c89f49aa838e8cfc38e04353", + "m_OverrideReferenceName": "_GradientAOMap", + "m_GeneratePropertyBlock": true, + "m_Precision": 0, + "overrideHLSLDeclaration": false, + "hlslDeclarationOverride": 0, + "m_Hidden": false, + "m_Value": { + "m_SerializedTexture": "{\"texture\":{\"instanceID\":0}}", + "m_Guid": "" + }, + "m_Modifiable": true, + "m_DefaultType": 0 +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "2af5165093084217aac61b4af29a730d", + "m_Id": 4, + "m_DisplayName": "R", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "R", + "m_StageCapability": 2, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "2b081408a7e24e398594d062ea1a971f", + "m_Id": 4, + "m_DisplayName": "R", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "R", + "m_StageCapability": 2, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "315af748590c43e98863cdc26b38904f", + "m_Id": 0, + "m_DisplayName": "Micro Normal Strength", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "32f3a8d8864f407483bdfb32a02f37ea", + "m_Id": 4, + "m_DisplayName": "R", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "R", + "m_StageCapability": 2, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Internal.Texture2DShaderProperty", + "m_ObjectId": "3345a7b9279a48b7ba4602df55d812ac", + "m_Guid": { + "m_GuidSerialized": "11573659-5da7-4813-a954-c0a0d3d0de68" + }, + "m_Name": "Mask Map", + "m_DefaultReferenceName": "Texture2D_3345a7b9279a48b7ba4602df55d812ac", + "m_OverrideReferenceName": "_MaskMap", + "m_GeneratePropertyBlock": true, + "m_Precision": 0, + "overrideHLSLDeclaration": false, + "hlslDeclarationOverride": 0, + "m_Hidden": false, + "m_Value": { + "m_SerializedTexture": "{\"texture\":{\"instanceID\":0}}", + "m_Guid": "" + }, + "m_Modifiable": true, + "m_DefaultType": 0 +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.LerpNode", + "m_ObjectId": "369e9b41ff1541cd848d3e2e3d27a296", + "m_Group": { + "m_Id": "" + }, + "m_Name": "Lerp", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -381.00006103515627, + "y": 453.0000305175781, + "width": 208.0, + "height": 326.0 + } + }, + "m_Slots": [ + { + "m_Id": "fc13441d8fab4afeb1a24d8250857829" + }, + { + "m_Id": "aa57cd915b1a47ab87462336f5cfa58d" + }, + { + "m_Id": "374862fc9e4d4355bbb6c6a708f1fa86" + }, + { + "m_Id": "2538d7514e264e388d6b89854b05eeb1" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "374862fc9e4d4355bbb6c6a708f1fa86", + "m_Id": 2, + "m_DisplayName": "T", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "T", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "37502e011dba43adad5a4c1965f0daf5", + "m_Id": 5, + "m_DisplayName": "G", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "G", + "m_StageCapability": 2, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "383a3e546b014329b0e83fd4ea9c0506", + "m_Id": 6, + "m_DisplayName": "B", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "B", + "m_StageCapability": 2, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.PropertyNode", + "m_ObjectId": "3843f3d297af4a55ac742acfed12ffcd", + "m_Group": { + "m_Id": "" + }, + "m_Name": "Property", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -650.0000610351563, + "y": -94.0, + "width": 207.0, + "height": 34.0 + } + }, + "m_Slots": [ + { + "m_Id": "c1ed2288401e4ce6b01f3171b5355389" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_Property": { + "m_Id": "554e041e04cb41379e9bbb0c5e80d80c" + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "39a1b3de165b4ff6beecaebd677c6e3a", + "m_Id": 5, + "m_DisplayName": "G", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "G", + "m_StageCapability": 2, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "39d0eb30a6fc470d8614c68053a81004", + "m_Id": 6, + "m_DisplayName": "B", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "B", + "m_StageCapability": 2, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.PropertyNode", + "m_ObjectId": "3ab5c0ee94fd444da94411d41e7fa2fd", + "m_Group": { + "m_Id": "" + }, + "m_Name": "Property", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -927.0, + "y": 1328.0, + "width": 178.0, + "height": 34.0 + } + }, + "m_Slots": [ + { + "m_Id": "0bd3147b039a4a1981a74b5d8942f3bd" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_Property": { + "m_Id": "a1eb91167291491694bf1bdf8d2f3e16" + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "3b29885e48574179a150490f9f750a18", + "m_Id": 1, + "m_DisplayName": "Blend", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "Blend", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.NormalMaterialSlot", + "m_ObjectId": "3b9bea9727174fc0b9e705617c9903db", + "m_Id": 0, + "m_DisplayName": "Normal", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "Normal", + "m_StageCapability": 1, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0 + }, + "m_Labels": [], + "m_Space": 0 +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Internal.BooleanShaderProperty", + "m_ObjectId": "3c380077c517483f8c6dbb95eb0de6b7", + "m_Guid": { + "m_GuidSerialized": "ea521638-750d-49c4-9246-707cd6f78e4c" + }, + "m_Name": "Is Upper Teeth", + "m_DefaultReferenceName": "Boolean_3c380077c517483f8c6dbb95eb0de6b7", + "m_OverrideReferenceName": "_IsUpperTeeth", + "m_GeneratePropertyBlock": true, + "m_Precision": 0, + "overrideHLSLDeclaration": false, + "hlslDeclarationOverride": 0, + "m_Hidden": false, + "m_Value": false +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.OneMinusNode", + "m_ObjectId": "3d43204b11764dad841dd7d29c54794d", + "m_Group": { + "m_Id": "" + }, + "m_Name": "One Minus", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -245.0, + "y": 725.0, + "width": 128.0, + "height": 94.0 + } + }, + "m_Slots": [ + { + "m_Id": "257e80db9eb84e22a5f409d59f06a941" + }, + { + "m_Id": "24c50ccb0f0f46348776e001012f34f7" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "3de68672d00143c09300da7a5df0f89f", + "m_Id": 0, + "m_DisplayName": "Gums Thickness", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.MultiplyNode", + "m_ObjectId": "3eef59649e0d4bb995c91e89f7d8a40e", + "m_Group": { + "m_Id": "" + }, + "m_Name": "Multiply", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -19.000064849853517, + "y": 249.00003051757813, + "width": 125.99999237060547, + "height": 118.0 + } + }, + "m_Slots": [ + { + "m_Id": "d40c8622dec94a06911bbce96041139a" + }, + { + "m_Id": "d6cb425ab7764480b45b76e4c73ebac2" + }, + { + "m_Id": "49901c27fbe442d1bfc407aed369bf09" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "40093fdb515740a6b89991c27475fb70", + "m_Id": 5, + "m_DisplayName": "G", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "G", + "m_StageCapability": 2, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Texture2DInputMaterialSlot", + "m_ObjectId": "40411d53b935493097fbc12e892291fa", + "m_Id": 1, + "m_DisplayName": "Texture", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "Texture", + "m_StageCapability": 3, + "m_BareResource": false, + "m_Texture": { + "m_SerializedTexture": "{\"texture\":{\"instanceID\":0}}", + "m_Guid": "" + }, + "m_DefaultType": 0 +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector3MaterialSlot", + "m_ObjectId": "410bebff5a4c4691b70fcbc06f01c0af", + "m_Id": 2, + "m_DisplayName": "Out", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0 + }, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "424b313138944a21bc404c418bcb085e", + "m_Id": 0, + "m_DisplayName": "Alpha", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "Alpha", + "m_StageCapability": 2, + "m_Value": 1.0, + "m_DefaultValue": 1.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "4267a37b446f48b88f36740206176441", + "m_Id": 0, + "m_DisplayName": "A", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "A", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "434134de69c149dd8650ae88a3c426ad", + "m_Id": 1, + "m_DisplayName": "Min", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "Min", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Texture2DInputMaterialSlot", + "m_ObjectId": "4484d7a3020247eeab08441067990b9b", + "m_Id": 1, + "m_DisplayName": "Texture", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "Texture", + "m_StageCapability": 3, + "m_BareResource": false, + "m_Texture": { + "m_SerializedTexture": "{\"texture\":{\"instanceID\":0}}", + "m_Guid": "" + }, + "m_DefaultType": 0 +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "4819726fa0474485b5d29c8087c3516e", + "m_Id": 5, + "m_DisplayName": "G", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "G", + "m_StageCapability": 2, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.PropertyNode", + "m_ObjectId": "488966045eba4552923a1ce35c8dd3ad", + "m_Group": { + "m_Id": "" + }, + "m_Name": "Property", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -642.0000610351563, + "y": 441.0000305175781, + "width": 162.0, + "height": 34.000003814697269 + } + }, + "m_Slots": [ + { + "m_Id": "e845fedb78f54a69a2b33f13e631c4ea" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_Property": { + "m_Id": "fea586edf5974ba687a3f05c3d4b6623" + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "497022c0ba274a6fb575cf7c142d01eb", + "m_Id": 0, + "m_DisplayName": "A", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "A", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "4988f5f033184216ad23ac633acc7698", + "m_Id": 0, + "m_DisplayName": "Teeth Saturation", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicValueMaterialSlot", + "m_ObjectId": "49901c27fbe442d1bfc407aed369bf09", + "m_Id": 2, + "m_DisplayName": "Out", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": { + "e00": 0.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 0.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 0.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 0.0 + }, + "m_DefaultValue": { + "e00": 1.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 1.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 1.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.BlockNode", + "m_ObjectId": "4b45669a84054c498babd493511b3189", + "m_Group": { + "m_Id": "" + }, + "m_Name": "VertexDescription.Position", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": 0.0, + "y": 0.0, + "width": 0.0, + "height": 0.0 + } + }, + "m_Slots": [ + { + "m_Id": "cb901263bb9a42489ac84d9e84023477" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_SerializedDescriptor": "VertexDescription.Position" +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.LerpNode", + "m_ObjectId": "4ee3e3b188a4495fb5be187a9f57cc27", + "m_Group": { + "m_Id": "" + }, + "m_Name": "Lerp", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -18.99986457824707, + "y": 935.0, + "width": 207.99998474121095, + "height": 326.0 + } + }, + "m_Slots": [ + { + "m_Id": "497022c0ba274a6fb575cf7c142d01eb" + }, + { + "m_Id": "9eb92eca01e24b8f85337980637997fb" + }, + { + "m_Id": "54eeca54225f43fd8f2e73f6f7611014" + }, + { + "m_Id": "d86ff386dec24b5e9bc2b39657d6d1af" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.ColorRGBMaterialSlot", + "m_ObjectId": "4fbf6229bad74e91afb7ff4f2a7f0018", + "m_Id": 0, + "m_DisplayName": "Emission", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "Emission", + "m_StageCapability": 2, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0 + }, + "m_Labels": [], + "m_ColorMode": 1, + "m_DefaultColor": { + "r": 0.0, + "g": 0.0, + "b": 0.0, + "a": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicValueMaterialSlot", + "m_ObjectId": "535c5126e61841099e1ad49b42eaefc8", + "m_Id": 2, + "m_DisplayName": "Out", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": { + "e00": 0.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 0.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 0.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 0.0 + }, + "m_DefaultValue": { + "e00": 1.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 1.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 1.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "54eeca54225f43fd8f2e73f6f7611014", + "m_Id": 2, + "m_DisplayName": "T", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "T", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 1, + "m_Type": "UnityEditor.ShaderGraph.Internal.Vector1ShaderProperty", + "m_ObjectId": "554e041e04cb41379e9bbb0c5e80d80c", + "m_Guid": { + "m_GuidSerialized": "93bb17c5-261b-4523-a050-45035be659cb" + }, + "m_Name": "Teeth Subsurface Scatter", + "m_DefaultReferenceName": "Vector1_554e041e04cb41379e9bbb0c5e80d80c", + "m_OverrideReferenceName": "_TeethSSS", + "m_GeneratePropertyBlock": true, + "m_Precision": 0, + "overrideHLSLDeclaration": false, + "hlslDeclarationOverride": 0, + "m_Hidden": false, + "m_Value": 0.5, + "m_FloatType": 1, + "m_RangeValues": { + "x": 0.0, + "y": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "5608685f8fa04124b51f5a4ca9cc179b", + "m_Id": 0, + "m_DisplayName": "Micro Normal Tiling", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Texture2DMaterialSlot", + "m_ObjectId": "565c01cd27814834acd27d2472d0033f", + "m_Id": 0, + "m_DisplayName": "Diffuse Map", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_BareResource": false +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.PropertyNode", + "m_ObjectId": "5b5d90ab491f441884a78ece78c6e7a1", + "m_Group": { + "m_Id": "" + }, + "m_Name": "Property", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -1155.9998779296875, + "y": 2470.0, + "width": 195.0, + "height": 34.0 + } + }, + "m_Slots": [ + { + "m_Id": "315af748590c43e98863cdc26b38904f" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_Property": { + "m_Id": "c70d342b1a0b4d6bbf1ff3c98fd338ea" + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "5d77a606937f44feb8860c6501cc4557", + "m_Id": 4, + "m_DisplayName": "R", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "R", + "m_StageCapability": 2, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.Rendering.HighDefinition.ShaderGraph.SystemData", + "m_ObjectId": "5e856e0c3b704d14a6c36b84bf8d78f6", + "m_MaterialNeedsUpdateHash": 530, + "m_SurfaceType": 0, + "m_RenderingPass": 1, + "m_BlendMode": 0, + "m_ZTest": 4, + "m_ZWrite": false, + "m_TransparentCullMode": 2, + "m_OpaqueCullMode": 2, + "m_SortPriority": 0, + "m_AlphaTest": false, + "m_TransparentDepthPrepass": false, + "m_TransparentDepthPostpass": false, + "m_SupportLodCrossFade": false, + "m_DoubleSidedMode": 0, + "m_DOTSInstancing": false, + "m_Version": 0, + "m_FirstTimeMigrationExecuted": true, + "inspectorFoldoutMask": 9 +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "607cddc768aa4008a82ae2a97082aede", + "m_Id": 2, + "m_DisplayName": "T", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "T", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.SaturationNode", + "m_ObjectId": "62b5be26cb11438e9889eb7804f65072", + "m_Group": { + "m_Id": "" + }, + "m_Name": "Saturation", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -1955.0, + "y": -1363.0, + "width": 207.99998474121095, + "height": 301.9999694824219 + } + }, + "m_Slots": [ + { + "m_Id": "0e019497420c44a9a0fa6321c5d69d66" + }, + { + "m_Id": "d13d7d90125242d2b860889e5b9e0fb1" + }, + { + "m_Id": "ce13794f3eab4196be9358dbff6664ab" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "62cce88aaad1405d9a4f9103c020132e", + "m_Id": 6, + "m_DisplayName": "B", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "B", + "m_StageCapability": 2, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "6321e82512d8494fa6bc1f1890a53823", + "m_Id": 2, + "m_DisplayName": "T", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "T", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "64d7c00094f349f39b960559156f78d1", + "m_Id": 0, + "m_DisplayName": "Ambient Occlusion Strength", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.Rendering.HighDefinition.ShaderGraph.HDLitSubTarget", + "m_ObjectId": "650ef699f8534d05b11661f3db2c1e50" +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "6574d6ca0bb24871b8226477233c11fe", + "m_Id": 0, + "m_DisplayName": "Smoothness Min", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.OneMinusNode", + "m_ObjectId": "65bdb854bdc642a89bb995ee784e4d0d", + "m_Group": { + "m_Id": "" + }, + "m_Name": "One Minus", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": 240.0, + "y": 688.0, + "width": 128.0, + "height": 94.0 + } + }, + "m_Slots": [ + { + "m_Id": "e3804042c65348b7b4c8781cf1828b95" + }, + { + "m_Id": "a00021ad550c4eb8998030c38ebf572f" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 1, + "m_Type": "UnityEditor.ShaderGraph.Internal.Vector1ShaderProperty", + "m_ObjectId": "66cc0b010f5647d5bf80ded4825cab7c", + "m_Guid": { + "m_GuidSerialized": "dc8aa899-adef-4c83-8bf1-94f1fe78285d" + }, + "m_Name": "Gums Saturation", + "m_DefaultReferenceName": "Vector1_66cc0b010f5647d5bf80ded4825cab7c", + "m_OverrideReferenceName": "_GumsSaturation", + "m_GeneratePropertyBlock": true, + "m_Precision": 0, + "overrideHLSLDeclaration": false, + "hlslDeclarationOverride": 0, + "m_Hidden": false, + "m_Value": 1.0, + "m_FloatType": 1, + "m_RangeValues": { + "x": 0.0, + "y": 2.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Texture2DMaterialSlot", + "m_ObjectId": "67f3c5040dff441a98156cb5eda89ac3", + "m_Id": 0, + "m_DisplayName": "Micro Normal Map", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_BareResource": false +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "687b7b8b4ab2496bb2affcdeeeea0305", + "m_Id": 7, + "m_DisplayName": "A", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "A", + "m_StageCapability": 2, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "69751d3d0ec748138109118d6e00f2b0", + "m_Id": 3, + "m_DisplayName": "Opacity", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "Opacity", + "m_StageCapability": 3, + "m_Value": 1.0, + "m_DefaultValue": 1.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.PropertyNode", + "m_ObjectId": "69822902c84c428080db9893d32ee267", + "m_Group": { + "m_Id": "" + }, + "m_Name": "Property", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -1022.9999389648438, + "y": 1560.0001220703125, + "width": 123.0, + "height": 34.0 + } + }, + "m_Slots": [ + { + "m_Id": "7002af4c98ac4f479b13782f0e1a1cdb" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_Property": { + "m_Id": "8a49d2f872e946d4a29e2030ee291584" + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector4MaterialSlot", + "m_ObjectId": "69d54d6c4ba64a468f042e25e1f1a0ca", + "m_Id": 0, + "m_DisplayName": "RGBA", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "RGBA", + "m_StageCapability": 2, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.BlockNode", + "m_ObjectId": "6a4b619cae09428e850340b327dc2247", + "m_Group": { + "m_Id": "" + }, + "m_Name": "SurfaceDescription.Smoothness", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": 1196.0001220703125, + "y": 620.0000610351563, + "width": 200.00001525878907, + "height": 41.0 + } + }, + "m_Slots": [ + { + "m_Id": "0d28e9b96829486b9a93fb4b4493ec53" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_SerializedDescriptor": "SurfaceDescription.Smoothness" +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.BlockNode", + "m_ObjectId": "6b280d605cf34b63ae417129545c2f7d", + "m_Group": { + "m_Id": "" + }, + "m_Name": "SurfaceDescription.Occlusion", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": 1193.0, + "y": 550.0000610351563, + "width": 200.00001525878907, + "height": 41.0 + } + }, + "m_Slots": [ + { + "m_Id": "b7bc60a4dd2f4474b6ee37d8ae231bc3" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_SerializedDescriptor": "SurfaceDescription.Occlusion" +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.UVMaterialSlot", + "m_ObjectId": "6b8bd214466246b3a4e7a1dde27d6958", + "m_Id": 2, + "m_DisplayName": "UV", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "UV", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0 + }, + "m_Labels": [], + "m_Channel": 0 +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.RedirectNodeData", + "m_ObjectId": "6c08aa06107d4f5ea147fda94e1e3b45", + "m_Group": { + "m_Id": "" + }, + "m_Name": "Redirect Node", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -1946.0, + "y": -1449.0, + "width": 56.0, + "height": 24.000001907348634 + } + }, + "m_Slots": [ + { + "m_Id": "974d5eff41cc4901939fc40e4ea8a8a5" + }, + { + "m_Id": "1e4b69c907194d94a55567f4a99d7231" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "6d067fe894e74ae799df9bd381e44ca1", + "m_Id": 5, + "m_DisplayName": "G", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "G", + "m_StageCapability": 2, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Internal.Texture2DShaderProperty", + "m_ObjectId": "6d2408803a794f2e9368d5529b79a574", + "m_Guid": { + "m_GuidSerialized": "6b8dd5b3-e04a-4e6c-b8b8-f3e9ef85e56e" + }, + "m_Name": "Micro Normal Map", + "m_DefaultReferenceName": "Texture2D_6d2408803a794f2e9368d5529b79a574", + "m_OverrideReferenceName": "_MicroNormalMap", + "m_GeneratePropertyBlock": true, + "m_Precision": 0, + "overrideHLSLDeclaration": false, + "hlslDeclarationOverride": 0, + "m_Hidden": false, + "m_Value": { + "m_SerializedTexture": "{\"texture\":{\"instanceID\":0}}", + "m_Guid": "" + }, + "m_Modifiable": true, + "m_DefaultType": 3 +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Texture2DMaterialSlot", + "m_ObjectId": "7002af4c98ac4f479b13782f0e1a1cdb", + "m_Id": 0, + "m_DisplayName": "Normal Map", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_BareResource": false +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.PropertyNode", + "m_ObjectId": "71d1e8a063514b2680bf1f014cbf9938", + "m_Group": { + "m_Id": "" + }, + "m_Name": "Property", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -3441.0, + "y": 135.0, + "width": 150.0, + "height": 34.0 + } + }, + "m_Slots": [ + { + "m_Id": "03e2818f83814498bb9178cea7ffb00d" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_Property": { + "m_Id": "2adde9b6c89f49aa838e8cfc38e04353" + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "72c2d86ee74142c7875964e0fffbd7a4", + "m_Id": 1, + "m_DisplayName": "B", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "B", + "m_StageCapability": 3, + "m_Value": { + "x": 1.0, + "y": 1.0, + "z": 1.0, + "w": 1.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.UVMaterialSlot", + "m_ObjectId": "7441ca030e3b43e3a61d7932a08fcf81", + "m_Id": 2, + "m_DisplayName": "UV", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "UV", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0 + }, + "m_Labels": [], + "m_Channel": 0 +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.ColorRGBMaterialSlot", + "m_ObjectId": "745ea487c66c466f84d2c16a08c4b1b6", + "m_Id": 0, + "m_DisplayName": "Base Color", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "BaseColor", + "m_StageCapability": 2, + "m_Value": { + "x": 0.5, + "y": 0.5, + "z": 0.5 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0 + }, + "m_Labels": [], + "m_ColorMode": 0, + "m_DefaultColor": { + "r": 0.5, + "g": 0.5, + "b": 0.5, + "a": 1.0 + } +} + +{ + "m_SGVersion": 1, + "m_Type": "UnityEditor.ShaderGraph.Internal.Vector1ShaderProperty", + "m_ObjectId": "769181578f94433984a73faf6e153757", + "m_Guid": { + "m_GuidSerialized": "1d430310-7d4b-4543-a3f5-5e6aa15add25" + }, + "m_Name": "Gums Brightness", + "m_DefaultReferenceName": "", + "m_OverrideReferenceName": "_GumsBrightness", + "m_GeneratePropertyBlock": true, + "m_Precision": 0, + "overrideHLSLDeclaration": false, + "hlslDeclarationOverride": 0, + "m_Hidden": false, + "m_Value": 0.8999999761581421, + "m_FloatType": 1, + "m_RangeValues": { + "x": 0.0, + "y": 2.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.SamplerStateMaterialSlot", + "m_ObjectId": "780f271d73f64e4297adcfa728a69bad", + "m_Id": 3, + "m_DisplayName": "Sampler", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "Sampler", + "m_StageCapability": 3, + "m_BareResource": false +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.ClampNode", + "m_ObjectId": "79276f373c29455fb1e2f5d0bc8b37bd", + "m_Group": { + "m_Id": "" + }, + "m_Name": "Clamp", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -1128.0, + "y": 1233.0001220703125, + "width": 141.0, + "height": 142.0 + } + }, + "m_Slots": [ + { + "m_Id": "c4026aaf89fa4c1d80a1cbf919753a6d" + }, + { + "m_Id": "434134de69c149dd8650ae88a3c426ad" + }, + { + "m_Id": "80513a5d7f2b4302a8afa9a2105235a4" + }, + { + "m_Id": "9b629742975648d4b443050643a4956e" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "79674131981f4da1945bfab5e13813b6", + "m_Id": 0, + "m_DisplayName": "Teeth Brightness", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Texture2DInputMaterialSlot", + "m_ObjectId": "7c52d0c211b148baa2dee264ed442794", + "m_Id": 1, + "m_DisplayName": "Texture", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "Texture", + "m_StageCapability": 3, + "m_BareResource": false, + "m_Texture": { + "m_SerializedTexture": "{\"texture\":{\"instanceID\":0}}", + "m_Guid": "" + }, + "m_DefaultType": 0 +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.BooleanMaterialSlot", + "m_ObjectId": "7e0e978a306b4e378819c12a41c09bac", + "m_Id": 0, + "m_DisplayName": "Is Upper Teeth", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": false, + "m_DefaultValue": false +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "80513a5d7f2b4302a8afa9a2105235a4", + "m_Id": 2, + "m_DisplayName": "Max", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "Max", + "m_StageCapability": 3, + "m_Value": { + "x": 1.0, + "y": 1.0, + "z": 1.0, + "w": 1.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.SampleTexture2DNode", + "m_ObjectId": "847ac5df0b2d4dd58b05ed5100fd2d88", + "m_Group": { + "m_Id": "" + }, + "m_Name": "Sample Texture 2D", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -2461.999755859375, + "y": -1720.0, + "width": 208.0, + "height": 436.9999694824219 + } + }, + "m_Slots": [ + { + "m_Id": "df0dc984590847b19bd2f24e1aba8374" + }, + { + "m_Id": "2b081408a7e24e398594d062ea1a971f" + }, + { + "m_Id": "39a1b3de165b4ff6beecaebd677c6e3a" + }, + { + "m_Id": "1d1ca274b5fe42e69ce56945c39a8ea7" + }, + { + "m_Id": "687b7b8b4ab2496bb2affcdeeeea0305" + }, + { + "m_Id": "40411d53b935493097fbc12e892291fa" + }, + { + "m_Id": "7441ca030e3b43e3a61d7932a08fcf81" + }, + { + "m_Id": "780f271d73f64e4297adcfa728a69bad" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_TextureType": 0, + "m_NormalMapSpace": 0 +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "8547d55cd06b487d8d347cc2a2c0bb74", + "m_Id": 2, + "m_DisplayName": "Out", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.SampleTexture2DNode", + "m_ObjectId": "85bba8f52afa4634a8cdd48d4a82cf0f", + "m_Group": { + "m_Id": "" + }, + "m_Name": "Sample Texture 2D", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -3225.0, + "y": -352.9999694824219, + "width": 208.00001525878907, + "height": 437.0 + } + }, + "m_Slots": [ + { + "m_Id": "b3b9fda9f6894fa487bfdeac44f98631" + }, + { + "m_Id": "8e57be411ac04e049abbd3666d6d8d99" + }, + { + "m_Id": "6d067fe894e74ae799df9bd381e44ca1" + }, + { + "m_Id": "ab2886761167461bba8c0787504525ad" + }, + { + "m_Id": "9611fc8ba4814c4a9b41d1d58853c9ce" + }, + { + "m_Id": "d3235c7ba1fc4c428993a5583f22e663" + }, + { + "m_Id": "6b8bd214466246b3a4e7a1dde27d6958" + }, + { + "m_Id": "a5528de362834aa980e49f4d5578fafb" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_TextureType": 0, + "m_NormalMapSpace": 0 +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.SamplerStateMaterialSlot", + "m_ObjectId": "85c5c76f4845488eb95392938396f2b9", + "m_Id": 3, + "m_DisplayName": "Sampler", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "Sampler", + "m_StageCapability": 3, + "m_BareResource": false +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector4MaterialSlot", + "m_ObjectId": "86b897ab597140d59a473d807e980628", + "m_Id": 0, + "m_DisplayName": "RGBA", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "RGBA", + "m_StageCapability": 2, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.Rendering.HighDefinition.ShaderGraph.BuiltinData", + "m_ObjectId": "88f0b3d71738482fb6273b754134b4dd", + "m_Distortion": false, + "m_DistortionMode": 0, + "m_DistortionDepthTest": true, + "m_AddPrecomputedVelocity": false, + "m_TransparentWritesMotionVec": false, + "m_AlphaToMask": false, + "m_DepthOffset": false, + "m_TransparencyFog": true, + "m_AlphaTestShadow": false, + "m_BackThenFrontRendering": false, + "m_TransparentDepthPrepass": false, + "m_TransparentDepthPostpass": false, + "m_SupportLodCrossFade": false +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector2MaterialSlot", + "m_ObjectId": "89d785e9bb6c413687505ab305a7ebf9", + "m_Id": 3, + "m_DisplayName": "Out", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0 + }, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "89fc6b59daa7410cbc9b145255e398db", + "m_Id": 0, + "m_DisplayName": "A", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "A", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Internal.Texture2DShaderProperty", + "m_ObjectId": "8a49d2f872e946d4a29e2030ee291584", + "m_Guid": { + "m_GuidSerialized": "79f607da-c2f1-46b1-8320-f91a0aef3386" + }, + "m_Name": "Normal Map", + "m_DefaultReferenceName": "Texture2D_8a49d2f872e946d4a29e2030ee291584", + "m_OverrideReferenceName": "_NormalMap", + "m_GeneratePropertyBlock": true, + "m_Precision": 0, + "overrideHLSLDeclaration": false, + "hlslDeclarationOverride": 0, + "m_Hidden": false, + "m_Value": { + "m_SerializedTexture": "{\"texture\":{\"instanceID\":0}}", + "m_Guid": "" + }, + "m_Modifiable": true, + "m_DefaultType": 3 +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.BlockNode", + "m_ObjectId": "8a7ae7a881424567bd38f733cff73869", + "m_Group": { + "m_Id": "" + }, + "m_Name": "SurfaceDescription.BaseColor", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": 0.0, + "y": 0.0, + "width": 0.0, + "height": 0.0 + } + }, + "m_Slots": [ + { + "m_Id": "745ea487c66c466f84d2c16a08c4b1b6" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_SerializedDescriptor": "SurfaceDescription.BaseColor" +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "8ad57b1b098b473099cfc3bb9d5a5e58", + "m_Id": 0, + "m_DisplayName": "", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.RedirectNodeData", + "m_ObjectId": "8c2615acff244d42be930682540c2f44", + "m_Group": { + "m_Id": "" + }, + "m_Name": "Redirect Node", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -1099.0, + "y": -788.9999389648438, + "width": 56.000003814697269, + "height": 24.000001907348634 + } + }, + "m_Slots": [ + { + "m_Id": "8ad57b1b098b473099cfc3bb9d5a5e58" + }, + { + "m_Id": "960ee6b03d6c4bf3a5cdaab097be98b9" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.UVMaterialSlot", + "m_ObjectId": "8c95ccd4e8fd4bf29cc1afa00cc39223", + "m_Id": 2, + "m_DisplayName": "UV", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "UV", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0 + }, + "m_Labels": [], + "m_Channel": 0 +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.BlockNode", + "m_ObjectId": "8d0e91598db04dc39429e4727f60af22", + "m_Group": { + "m_Id": "" + }, + "m_Name": "SurfaceDescription.Thickness", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": 0.0, + "y": 0.0, + "width": 0.0, + "height": 0.0 + } + }, + "m_Slots": [ + { + "m_Id": "e51e934d740f4369a721de0c664eeee0" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_SerializedDescriptor": "SurfaceDescription.Thickness" +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "8e57be411ac04e049abbd3666d6d8d99", + "m_Id": 4, + "m_DisplayName": "R", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "R", + "m_StageCapability": 2, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.LerpNode", + "m_ObjectId": "8f9edc1bf1ec427e838b9955e23e472c", + "m_Group": { + "m_Id": "" + }, + "m_Name": "Lerp", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -381.0000305175781, + "y": -76.9999771118164, + "width": 208.0, + "height": 326.0 + } + }, + "m_Slots": [ + { + "m_Id": "be358d293c294677a5a397993ce738f3" + }, + { + "m_Id": "a87eec3afde4452c97e4c7229de5f5f6" + }, + { + "m_Id": "607cddc768aa4008a82ae2a97082aede" + }, + { + "m_Id": "1caef40575a14fb289b47f3bff7861bb" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.PropertyNode", + "m_ObjectId": "9203aadcc7e34fcbb60c753b4a4bd252", + "m_Group": { + "m_Id": "" + }, + "m_Name": "Property", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -1367.0001220703125, + "y": 2021.0, + "width": 156.0, + "height": 34.000003814697269 + } + }, + "m_Slots": [ + { + "m_Id": "67f3c5040dff441a98156cb5eda89ac3" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_Property": { + "m_Id": "6d2408803a794f2e9368d5529b79a574" + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.PropertyNode", + "m_ObjectId": "92460f8b665b4a03bb23e7fe80bdff90", + "m_Group": { + "m_Id": "" + }, + "m_Name": "Property", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -1681.0, + "y": 2138.0, + "width": 179.00001525878907, + "height": 34.0 + } + }, + "m_Slots": [ + { + "m_Id": "5608685f8fa04124b51f5a4ca9cc179b" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_Property": { + "m_Id": "c4024195aefa495695710ffb5997a875" + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector4MaterialSlot", + "m_ObjectId": "9341dc5c4cf94d6b960a964876b3d428", + "m_Id": 0, + "m_DisplayName": "RGBA", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "RGBA", + "m_StageCapability": 2, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.MultiplyNode", + "m_ObjectId": "945b619d201d4c6990c808ef712b4bef", + "m_Group": { + "m_Id": "" + }, + "m_Name": "Multiply", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -1545.0, + "y": -1361.0, + "width": 207.99998474121095, + "height": 301.9999694824219 + } + }, + "m_Slots": [ + { + "m_Id": "efe6d06fc42b46e4b3fc5ac9a0946f94" + }, + { + "m_Id": "e4f6c51df8a7454a90aed183972587a1" + }, + { + "m_Id": "9957f07506ed4aa9b286051fa95c44d1" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicValueMaterialSlot", + "m_ObjectId": "94793cab87ab4827b1367f947b59ad60", + "m_Id": 1, + "m_DisplayName": "B", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "B", + "m_StageCapability": 3, + "m_Value": { + "e00": 2.0, + "e01": 2.0, + "e02": 2.0, + "e03": 2.0, + "e10": 2.0, + "e11": 2.0, + "e12": 2.0, + "e13": 2.0, + "e20": 2.0, + "e21": 2.0, + "e22": 2.0, + "e23": 2.0, + "e30": 2.0, + "e31": 2.0, + "e32": 2.0, + "e33": 2.0 + }, + "m_DefaultValue": { + "e00": 1.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 1.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 1.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 1.0 + } +} + +{ + "m_SGVersion": 1, + "m_Type": "UnityEditor.ShaderGraph.Internal.Vector1ShaderProperty", + "m_ObjectId": "94ca5b7030dd47cf8a414dd9fee0ecde", + "m_Guid": { + "m_GuidSerialized": "0fe985ff-ae47-4bd0-8c8b-4c47581db61f" + }, + "m_Name": "Smoothness Max", + "m_DefaultReferenceName": "Vector1_94ca5b7030dd47cf8a414dd9fee0ecde", + "m_OverrideReferenceName": "_SmoothnessMax", + "m_GeneratePropertyBlock": true, + "m_Precision": 0, + "overrideHLSLDeclaration": false, + "hlslDeclarationOverride": 0, + "m_Hidden": false, + "m_Value": 1.0, + "m_FloatType": 1, + "m_RangeValues": { + "x": 0.0, + "y": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.PropertyNode", + "m_ObjectId": "9580d9a4456845628acd8d7bef5397c7", + "m_Group": { + "m_Id": "" + }, + "m_Name": "Property", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -3440.000244140625, + "y": -353.0, + "width": 172.00001525878907, + "height": 34.0 + } + }, + "m_Slots": [ + { + "m_Id": "d51f371b1d144ea2810f05289d0de2d2" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_Property": { + "m_Id": "221c3eb893034a10a0e04ad5230e2bb0" + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.NormalBlendNode", + "m_ObjectId": "959bbc37ca814b42be52d1bd1b64e66f", + "m_Group": { + "m_Id": "" + }, + "m_Name": "Normal Blend", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -522.0000610351563, + "y": 1825.0, + "width": 145.0, + "height": 154.0 + } + }, + "m_Slots": [ + { + "m_Id": "a004a2846d3d495287310bdf7e8a3185" + }, + { + "m_Id": "09847344f8004a26bdad187ff3b528cd" + }, + { + "m_Id": "410bebff5a4c4691b70fcbc06f01c0af" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_BlendMode": 0 +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "960ee6b03d6c4bf3a5cdaab097be98b9", + "m_Id": 1, + "m_DisplayName": "", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "9611fc8ba4814c4a9b41d1d58853c9ce", + "m_Id": 7, + "m_DisplayName": "A", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "A", + "m_StageCapability": 2, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.SamplerStateMaterialSlot", + "m_ObjectId": "96f36c732c8e47529d446f73fa12dd82", + "m_Id": 3, + "m_DisplayName": "Sampler", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "Sampler", + "m_StageCapability": 3, + "m_BareResource": false +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector3MaterialSlot", + "m_ObjectId": "9710862b6a1444fba64a2a8d42eb908f", + "m_Id": 2, + "m_DisplayName": "Out", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0 + }, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "974d5eff41cc4901939fc40e4ea8a8a5", + "m_Id": 0, + "m_DisplayName": "", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicValueMaterialSlot", + "m_ObjectId": "9957f07506ed4aa9b286051fa95c44d1", + "m_Id": 2, + "m_DisplayName": "Out", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": { + "e00": 0.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 0.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 0.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 0.0 + }, + "m_DefaultValue": { + "e00": 1.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 1.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 1.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.NormalStrengthNode", + "m_ObjectId": "9abeb9fdadd74574b4e6738541daa06a", + "m_Group": { + "m_Id": "" + }, + "m_Name": "Normal Strength", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -858.0001831054688, + "y": 2013.0, + "width": 166.0, + "height": 118.0 + } + }, + "m_Slots": [ + { + "m_Id": "fcb5df76291e43d59d9d2c723f6e78ea" + }, + { + "m_Id": "a9f777000a804b03927bcaba4e4f94de" + }, + { + "m_Id": "af803c535eac431a995ab70febb2049e" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "9b27124867b04d63abeb9187f733e4f4", + "m_Id": 3, + "m_DisplayName": "Out", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "9b629742975648d4b443050643a4956e", + "m_Id": 3, + "m_DisplayName": "Out", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "9d15f391a5b8409498aa0f6fb041d2e4", + "m_Id": 0, + "m_DisplayName": "Base", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "Base", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "9eb92eca01e24b8f85337980637997fb", + "m_Id": 1, + "m_DisplayName": "B", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "B", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 1.0, + "z": 1.0, + "w": 1.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "a00021ad550c4eb8998030c38ebf572f", + "m_Id": 1, + "m_DisplayName": "Out", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector3MaterialSlot", + "m_ObjectId": "a004a2846d3d495287310bdf7e8a3185", + "m_Id": 0, + "m_DisplayName": "A", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "A", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 1.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0 + }, + "m_Labels": [] +} + +{ + "m_SGVersion": 1, + "m_Type": "UnityEditor.ShaderGraph.Internal.Vector1ShaderProperty", + "m_ObjectId": "a1eb91167291491694bf1bdf8d2f3e16", + "m_Guid": { + "m_GuidSerialized": "090da4ee-aa3e-42cb-bbd9-cecc3b09a474" + }, + "m_Name": "Smoothness Power", + "m_DefaultReferenceName": "Vector1_a1eb91167291491694bf1bdf8d2f3e16", + "m_OverrideReferenceName": "_SmoothnessPower", + "m_GeneratePropertyBlock": true, + "m_Precision": 0, + "overrideHLSLDeclaration": false, + "hlslDeclarationOverride": 0, + "m_Hidden": false, + "m_Value": 1.0, + "m_FloatType": 1, + "m_RangeValues": { + "x": 0.5, + "y": 2.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.SamplerStateMaterialSlot", + "m_ObjectId": "a5528de362834aa980e49f4d5578fafb", + "m_Id": 3, + "m_DisplayName": "Sampler", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "Sampler", + "m_StageCapability": 3, + "m_BareResource": false +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "a87eec3afde4452c97e4c7229de5f5f6", + "m_Id": 1, + "m_DisplayName": "B", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "B", + "m_StageCapability": 3, + "m_Value": { + "x": 1.0, + "y": 1.0, + "z": 1.0, + "w": 1.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "a9f777000a804b03927bcaba4e4f94de", + "m_Id": 1, + "m_DisplayName": "Strength", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "Strength", + "m_StageCapability": 3, + "m_Value": 1.0, + "m_DefaultValue": 1.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "aa57cd915b1a47ab87462336f5cfa58d", + "m_Id": 1, + "m_DisplayName": "B", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "B", + "m_StageCapability": 3, + "m_Value": { + "x": 1.0, + "y": 1.0, + "z": 1.0, + "w": 1.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "ab2886761167461bba8c0787504525ad", + "m_Id": 6, + "m_DisplayName": "B", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "B", + "m_StageCapability": 2, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.LerpNode", + "m_ObjectId": "ac06b0e4495e41ed855cc55978b80d86", + "m_Group": { + "m_Id": "" + }, + "m_Name": "Lerp", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -388.9999694824219, + "y": 1164.0, + "width": 207.99998474121095, + "height": 326.0 + } + }, + "m_Slots": [ + { + "m_Id": "89fc6b59daa7410cbc9b145255e398db" + }, + { + "m_Id": "72c2d86ee74142c7875964e0fffbd7a4" + }, + { + "m_Id": "6321e82512d8494fa6bc1f1890a53823" + }, + { + "m_Id": "e361532d11934944aec2a8d874a0bf13" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "aced51bf11dd4f3680945ff52a48ebee", + "m_Id": 2, + "m_DisplayName": "T", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "T", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "ad46a176c1ac40b78ee3a38ad5846d4d", + "m_Id": 7, + "m_DisplayName": "A", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "A", + "m_StageCapability": 2, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "ada7147b76d2440ab2f288313b8bc05e", + "m_Id": 0, + "m_DisplayName": "Gums Brightness", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector3MaterialSlot", + "m_ObjectId": "af803c535eac431a995ab70febb2049e", + "m_Id": 2, + "m_DisplayName": "Out", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0 + }, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "afeed83e13514dbc900674d049c51ac2", + "m_Id": 0, + "m_DisplayName": "A", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "A", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.Rendering.HighDefinition.ShaderGraph.HDLitData", + "m_ObjectId": "b00f1b66025c4b25a6f709e3c0ab54f4", + "m_RayTracing": false, + "m_MaterialType": 1, + "m_RefractionModel": 0, + "m_SSSTransmission": true, + "m_EnergyConservingSpecular": true, + "m_ClearCoat": false +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.PropertyNode", + "m_ObjectId": "b0b996e73e264d88b95284c03a428f41", + "m_Group": { + "m_Id": "" + }, + "m_Name": "Property", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -291.0, + "y": 671.0, + "width": 221.0, + "height": 34.0 + } + }, + "m_Slots": [ + { + "m_Id": "64d7c00094f349f39b960559156f78d1" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_Property": { + "m_Id": "daa99c4f268449b8a4e69fdaeafcfe49" + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "b1d4b45693af46a3a723b2ffb1b8b88a", + "m_Id": 7, + "m_DisplayName": "A", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "A", + "m_StageCapability": 2, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.BranchNode", + "m_ObjectId": "b26e5b0f3f8e4e07b17ce5d3e9ec04f3", + "m_Group": { + "m_Id": "" + }, + "m_Name": "Branch", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -2904.0, + "y": 132.0, + "width": 170.0, + "height": 142.0 + } + }, + "m_Slots": [ + { + "m_Id": "f6df72d302d149b59b06efca28607171" + }, + { + "m_Id": "c9eeb3cc61cc4e69a1436030a6963ac9" + }, + { + "m_Id": "1a3d70b35523456698eca34460e6f8b9" + }, + { + "m_Id": "9b27124867b04d63abeb9187f733e4f4" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "b384faa820304f82807176601dd16753", + "m_Id": 6, + "m_DisplayName": "B", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "B", + "m_StageCapability": 2, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector4MaterialSlot", + "m_ObjectId": "b3b9fda9f6894fa487bfdeac44f98631", + "m_Id": 0, + "m_DisplayName": "RGBA", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "RGBA", + "m_StageCapability": 2, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "b7bc60a4dd2f4474b6ee37d8ae231bc3", + "m_Id": 0, + "m_DisplayName": "Ambient Occlusion", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "Occlusion", + "m_StageCapability": 2, + "m_Value": 1.0, + "m_DefaultValue": 1.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.UVMaterialSlot", + "m_ObjectId": "b959e24d88ea43f5bf4256f07ae90ec0", + "m_Id": 2, + "m_DisplayName": "UV", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "UV", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0 + }, + "m_Labels": [], + "m_Channel": 0 +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.SamplerStateMaterialSlot", + "m_ObjectId": "ba586a643825415d9395e0095ddd8d8a", + "m_Id": 3, + "m_DisplayName": "Sampler", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "Sampler", + "m_StageCapability": 3, + "m_BareResource": false +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.BlockNode", + "m_ObjectId": "bc0c9bafa3544deaaba658da5d1457a2", + "m_Group": { + "m_Id": "" + }, + "m_Name": "SurfaceDescription.NormalTS", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": 1190.0001220703125, + "y": 665.0000610351563, + "width": 200.00001525878907, + "height": 41.0 + } + }, + "m_Slots": [ + { + "m_Id": "0e03c873ccc040dd8417724de5eaf36d" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_SerializedDescriptor": "SurfaceDescription.NormalTS" +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "bdb35f0f256944dfafd7981d98006c9f", + "m_Id": 1, + "m_DisplayName": "B", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "B", + "m_StageCapability": 3, + "m_Value": { + "x": 0.5, + "y": 2.0, + "z": 2.0, + "w": 2.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "be358d293c294677a5a397993ce738f3", + "m_Id": 0, + "m_DisplayName": "A", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "A", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "c0233299f62d4bf989edb701cb048b31", + "m_Id": 1, + "m_DisplayName": "Saturation", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "Saturation", + "m_StageCapability": 3, + "m_Value": 1.0, + "m_DefaultValue": 1.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector2MaterialSlot", + "m_ObjectId": "c083ca9475264d81936b2f64c2ae9982", + "m_Id": 2, + "m_DisplayName": "Offset", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "Offset", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0 + }, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "c1ed2288401e4ce6b01f3171b5355389", + "m_Id": 0, + "m_DisplayName": "Teeth Subsurface Scatter", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.PropertyNode", + "m_ObjectId": "c2ce8f28915943d49e5539ae59b0b3bf", + "m_Group": { + "m_Id": "" + }, + "m_Name": "Property", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -3235.0, + "y": 924.0, + "width": 115.00000762939453, + "height": 34.0 + } + }, + "m_Slots": [ + { + "m_Id": "1a6dccb88a494fbebd6d32ab0323405b" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_Property": { + "m_Id": "3345a7b9279a48b7ba4602df55d812ac" + } +} + +{ + "m_SGVersion": 1, + "m_Type": "UnityEditor.ShaderGraph.Internal.Vector1ShaderProperty", + "m_ObjectId": "c4024195aefa495695710ffb5997a875", + "m_Guid": { + "m_GuidSerialized": "c5f39fcf-3943-48fe-ab5c-46ba6c3eeee2" + }, + "m_Name": "Micro Normal Tiling", + "m_DefaultReferenceName": "Vector1_c4024195aefa495695710ffb5997a875", + "m_OverrideReferenceName": "_MicroNormalTiling", + "m_GeneratePropertyBlock": true, + "m_Precision": 0, + "overrideHLSLDeclaration": false, + "hlslDeclarationOverride": 0, + "m_Hidden": false, + "m_Value": 10.0, + "m_FloatType": 1, + "m_RangeValues": { + "x": 0.0, + "y": 50.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "c4026aaf89fa4c1d80a1cbf919753a6d", + "m_Id": 0, + "m_DisplayName": "In", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "In", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.NormalMaterialSlot", + "m_ObjectId": "c4b6c46dc8b348b8a5ecd4e2aead24c0", + "m_Id": 0, + "m_DisplayName": "Bent Normal", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "BentNormal", + "m_StageCapability": 2, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0 + }, + "m_Labels": [], + "m_Space": 3 +} + +{ + "m_SGVersion": 1, + "m_Type": "UnityEditor.ShaderGraph.Internal.Vector1ShaderProperty", + "m_ObjectId": "c70d342b1a0b4d6bbf1ff3c98fd338ea", + "m_Guid": { + "m_GuidSerialized": "d09cbcc1-0d27-4582-afd2-8528e6e51f97" + }, + "m_Name": "Micro Normal Strength", + "m_DefaultReferenceName": "Vector1_c70d342b1a0b4d6bbf1ff3c98fd338ea", + "m_OverrideReferenceName": "_MicroNormalStrength", + "m_GeneratePropertyBlock": true, + "m_Precision": 0, + "overrideHLSLDeclaration": false, + "hlslDeclarationOverride": 0, + "m_Hidden": false, + "m_Value": 0.30000001192092898, + "m_FloatType": 1, + "m_RangeValues": { + "x": 0.0, + "y": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "c91f545cd7394558a0f4c3fee98fcf42", + "m_Id": 3, + "m_DisplayName": "Out", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.TangentMaterialSlot", + "m_ObjectId": "c996e165d42c4929928bc49c5e17d734", + "m_Id": 0, + "m_DisplayName": "Tangent", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "Tangent", + "m_StageCapability": 1, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0 + }, + "m_Labels": [], + "m_Space": 0 +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "c9c382f96969430ca6a46ac85b576bb2", + "m_Id": 5, + "m_DisplayName": "G", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "G", + "m_StageCapability": 2, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "c9eeb3cc61cc4e69a1436030a6963ac9", + "m_Id": 1, + "m_DisplayName": "True", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "True", + "m_StageCapability": 3, + "m_Value": { + "x": 1.0, + "y": 1.0, + "z": 1.0, + "w": 1.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Internal.Texture2DShaderProperty", + "m_ObjectId": "cb42572a46a74a588ef3935f3a667eb7", + "m_Guid": { + "m_GuidSerialized": "36af1c96-8f78-4132-a591-a5b10a01324f" + }, + "m_Name": "Diffuse Map", + "m_DefaultReferenceName": "Texture2D_cb42572a46a74a588ef3935f3a667eb7", + "m_OverrideReferenceName": "_DiffuseMap", + "m_GeneratePropertyBlock": true, + "m_Precision": 0, + "overrideHLSLDeclaration": false, + "hlslDeclarationOverride": 0, + "m_Hidden": false, + "m_Value": { + "m_SerializedTexture": "{\"texture\":{\"instanceID\":0}}", + "m_Guid": "" + }, + "m_Modifiable": true, + "m_DefaultType": 0 +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.PositionMaterialSlot", + "m_ObjectId": "cb901263bb9a42489ac84d9e84023477", + "m_Id": 0, + "m_DisplayName": "Position", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "Position", + "m_StageCapability": 1, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0 + }, + "m_Labels": [], + "m_Space": 0 +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector3MaterialSlot", + "m_ObjectId": "ce13794f3eab4196be9358dbff6664ab", + "m_Id": 2, + "m_DisplayName": "Out", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0 + }, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.LerpNode", + "m_ObjectId": "ceb473d265c546e3ab12eb99b9035c9e", + "m_Group": { + "m_Id": "" + }, + "m_Name": "Lerp", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -1139.5625, + "y": -1551.5626220703125, + "width": 208.0, + "height": 326.0 + } + }, + "m_Slots": [ + { + "m_Id": "1b0b004aaf264ca3ada8021ced56d35f" + }, + { + "m_Id": "e33088af50ad4381b87a7d77f9d27c1f" + }, + { + "m_Id": "aced51bf11dd4f3680945ff52a48ebee" + }, + { + "m_Id": "0c32519e62164bb680633ab535302f38" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.PropertyNode", + "m_ObjectId": "d04a1ba74b404509b3874993b5771fe4", + "m_Group": { + "m_Id": "" + }, + "m_Name": "Property", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -2684.0, + "y": -1720.0, + "width": 148.0, + "height": 34.0 + } + }, + "m_Slots": [ + { + "m_Id": "565c01cd27814834acd27d2472d0033f" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_Property": { + "m_Id": "cb42572a46a74a588ef3935f3a667eb7" + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "d0dd5fc7d9b24ff3b7471468a1cefe77", + "m_Id": 1, + "m_DisplayName": "B", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "B", + "m_StageCapability": 3, + "m_Value": { + "x": 1.0, + "y": 1.0, + "z": 1.0, + "w": 1.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "d13d7d90125242d2b860889e5b9e0fb1", + "m_Id": 1, + "m_DisplayName": "Saturation", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "Saturation", + "m_StageCapability": 3, + "m_Value": 1.0, + "m_DefaultValue": 1.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Texture2DInputMaterialSlot", + "m_ObjectId": "d3235c7ba1fc4c428993a5583f22e663", + "m_Id": 1, + "m_DisplayName": "Texture", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "Texture", + "m_StageCapability": 3, + "m_BareResource": false, + "m_Texture": { + "m_SerializedTexture": "{\"texture\":{\"instanceID\":0}}", + "m_Guid": "" + }, + "m_DefaultType": 0 +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicValueMaterialSlot", + "m_ObjectId": "d40c8622dec94a06911bbce96041139a", + "m_Id": 0, + "m_DisplayName": "A", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "A", + "m_StageCapability": 3, + "m_Value": { + "e00": 0.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 0.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 0.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 0.0 + }, + "m_DefaultValue": { + "e00": 1.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 1.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 1.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Texture2DMaterialSlot", + "m_ObjectId": "d51f371b1d144ea2810f05289d0de2d2", + "m_Id": 0, + "m_DisplayName": "Gums Mask Map", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_BareResource": false +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicValueMaterialSlot", + "m_ObjectId": "d6cb425ab7764480b45b76e4c73ebac2", + "m_Id": 1, + "m_DisplayName": "B", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "B", + "m_StageCapability": 3, + "m_Value": { + "e00": 2.0, + "e01": 2.0, + "e02": 2.0, + "e03": 2.0, + "e10": 2.0, + "e11": 2.0, + "e12": 2.0, + "e13": 2.0, + "e20": 2.0, + "e21": 2.0, + "e22": 2.0, + "e23": 2.0, + "e30": 2.0, + "e31": 2.0, + "e32": 2.0, + "e33": 2.0 + }, + "m_DefaultValue": { + "e00": 1.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 1.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 1.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "d729776e47ca458d9f698b924845442d", + "m_Id": 0, + "m_DisplayName": "Gums Subsurface Scatter", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "d86ff386dec24b5e9bc2b39657d6d1af", + "m_Id": 3, + "m_DisplayName": "Out", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.PropertyNode", + "m_ObjectId": "d906043505fc466c9a6cd86bdf86c0a5", + "m_Group": { + "m_Id": "" + }, + "m_Name": "Property", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -702.0, + "y": 1142.9998779296875, + "width": 215.99998474121095, + "height": 33.999996185302737 + } + }, + "m_Slots": [ + { + "m_Id": "6574d6ca0bb24871b8226477233c11fe" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_Property": { + "m_Id": "229e12ce054c4003affcf25346b88151" + } +} + +{ + "m_SGVersion": 1, + "m_Type": "UnityEditor.ShaderGraph.Internal.Vector1ShaderProperty", + "m_ObjectId": "daa99c4f268449b8a4e69fdaeafcfe49", + "m_Guid": { + "m_GuidSerialized": "b78117bf-f0d9-48f7-8c0e-59b04f502b60" + }, + "m_Name": "Ambient Occlusion Strength", + "m_DefaultReferenceName": "Vector1_daa99c4f268449b8a4e69fdaeafcfe49", + "m_OverrideReferenceName": "_AOStrength", + "m_GeneratePropertyBlock": true, + "m_Precision": 0, + "overrideHLSLDeclaration": false, + "hlslDeclarationOverride": 0, + "m_Hidden": false, + "m_Value": 1.0, + "m_FloatType": 1, + "m_RangeValues": { + "x": 0.0, + "y": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "dab7b0ac196344f9a829a1307ef0b532", + "m_Id": 0, + "m_DisplayName": "Smoothness Max", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 1, + "m_Type": "UnityEditor.ShaderGraph.Internal.Vector1ShaderProperty", + "m_ObjectId": "ddd87d19404f41b8bbbd24232f4338ac", + "m_Guid": { + "m_GuidSerialized": "e6da8922-0f01-437d-b398-050d263017d5" + }, + "m_Name": "Front AO", + "m_DefaultReferenceName": "Vector1_ddd87d19404f41b8bbbd24232f4338ac", + "m_OverrideReferenceName": "_FrontAO", + "m_GeneratePropertyBlock": true, + "m_Precision": 0, + "overrideHLSLDeclaration": false, + "hlslDeclarationOverride": 0, + "m_Hidden": false, + "m_Value": 1.0, + "m_FloatType": 1, + "m_RangeValues": { + "x": 0.0, + "y": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.PropertyNode", + "m_ObjectId": "de23ea96dbbf4a4c9b9f59fe819fe830", + "m_Group": { + "m_Id": "" + }, + "m_Name": "Property", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -3084.000244140625, + "y": 92.00000762939453, + "width": 143.0, + "height": 34.0 + } + }, + "m_Slots": [ + { + "m_Id": "7e0e978a306b4e378819c12a41c09bac" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_Property": { + "m_Id": "3c380077c517483f8c6dbb95eb0de6b7" + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector4MaterialSlot", + "m_ObjectId": "df0dc984590847b19bd2f24e1aba8374", + "m_Id": 0, + "m_DisplayName": "RGBA", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "RGBA", + "m_StageCapability": 2, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.BlockNode", + "m_ObjectId": "e1e6ea93dab24d4086de0ce0507e9306", + "m_Group": { + "m_Id": "" + }, + "m_Name": "SurfaceDescription.Alpha", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": 0.0, + "y": 0.0, + "width": 0.0, + "height": 0.0 + } + }, + "m_Slots": [ + { + "m_Id": "424b313138944a21bc404c418bcb085e" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_SerializedDescriptor": "SurfaceDescription.Alpha" +} + +{ + "m_SGVersion": 1, + "m_Type": "UnityEditor.ShaderGraph.Internal.Vector1ShaderProperty", + "m_ObjectId": "e25a1c81f1374f178c8f27b6264a5f1b", + "m_Guid": { + "m_GuidSerialized": "1936e4b8-ae9b-4eb2-8ca8-295956f61a96" + }, + "m_Name": "Gums Subsurface Scatter", + "m_DefaultReferenceName": "Vector1_e25a1c81f1374f178c8f27b6264a5f1b", + "m_OverrideReferenceName": "_GumsSSS", + "m_GeneratePropertyBlock": true, + "m_Precision": 0, + "overrideHLSLDeclaration": false, + "hlslDeclarationOverride": 0, + "m_Hidden": false, + "m_Value": 1.0, + "m_FloatType": 1, + "m_RangeValues": { + "x": 0.0, + "y": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.SaturationNode", + "m_ObjectId": "e28e83ed9ea04d5d9fea68c35524c5c0", + "m_Group": { + "m_Id": "" + }, + "m_Name": "Saturation", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -1957.9998779296875, + "y": -1909.9998779296875, + "width": 207.99998474121095, + "height": 301.9999694824219 + } + }, + "m_Slots": [ + { + "m_Id": "25d3c8e1fdbb4c4fbfd4868867b08f5a" + }, + { + "m_Id": "c0233299f62d4bf989edb701cb048b31" + }, + { + "m_Id": "9710862b6a1444fba64a2a8d42eb908f" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "e33088af50ad4381b87a7d77f9d27c1f", + "m_Id": 1, + "m_DisplayName": "B", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "B", + "m_StageCapability": 3, + "m_Value": { + "x": 1.0, + "y": 1.0, + "z": 1.0, + "w": 1.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "e361532d11934944aec2a8d874a0bf13", + "m_Id": 3, + "m_DisplayName": "Out", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "e3804042c65348b7b4c8781cf1828b95", + "m_Id": 0, + "m_DisplayName": "In", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "In", + "m_StageCapability": 3, + "m_Value": { + "x": 1.0, + "y": 1.0, + "z": 1.0, + "w": 1.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicValueMaterialSlot", + "m_ObjectId": "e4f6c51df8a7454a90aed183972587a1", + "m_Id": 1, + "m_DisplayName": "B", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "B", + "m_StageCapability": 3, + "m_Value": { + "e00": 2.0, + "e01": 2.0, + "e02": 2.0, + "e03": 2.0, + "e10": 2.0, + "e11": 2.0, + "e12": 2.0, + "e13": 2.0, + "e20": 2.0, + "e21": 2.0, + "e22": 2.0, + "e23": 2.0, + "e30": 2.0, + "e31": 2.0, + "e32": 2.0, + "e33": 2.0 + }, + "m_DefaultValue": { + "e00": 1.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 1.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 1.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "e51e934d740f4369a721de0c664eeee0", + "m_Id": 0, + "m_DisplayName": "Thickness", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "Thickness", + "m_StageCapability": 2, + "m_Value": 1.0, + "m_DefaultValue": 1.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.BlockNode", + "m_ObjectId": "e701720035d44304a33f4b64350fc6e3", + "m_Group": { + "m_Id": "" + }, + "m_Name": "SurfaceDescription.Emission", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": 0.0, + "y": 0.0, + "width": 0.0, + "height": 0.0 + } + }, + "m_Slots": [ + { + "m_Id": "4fbf6229bad74e91afb7ff4f2a7f0018" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_SerializedDescriptor": "SurfaceDescription.Emission" +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "e8362fd7f2884d1ab1ac906ae9c28004", + "m_Id": 0, + "m_DisplayName": "Subsurface Mask", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "SubsurfaceMask", + "m_StageCapability": 2, + "m_Value": 1.0, + "m_DefaultValue": 1.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "e845fedb78f54a69a2b33f13e631c4ea", + "m_Id": 0, + "m_DisplayName": "Teeth Thickness", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "ea77c3a609ba400e9d279d2e74c1b9bc", + "m_Id": 0, + "m_DisplayName": "Front AO", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Texture2DInputMaterialSlot", + "m_ObjectId": "eb7f26266d4d47c9a57e818a9e6890dc", + "m_Id": 1, + "m_DisplayName": "Texture", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "Texture", + "m_StageCapability": 3, + "m_BareResource": false, + "m_Texture": { + "m_SerializedTexture": "{\"texture\":{\"instanceID\":0}}", + "m_Guid": "" + }, + "m_DefaultType": 3 +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "ebadab64ba5e4222bde9e2423849c96c", + "m_Id": 7, + "m_DisplayName": "A", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "A", + "m_StageCapability": 2, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.UVMaterialSlot", + "m_ObjectId": "eeb935f5191a4a59a9bc1ec799914d58", + "m_Id": 2, + "m_DisplayName": "UV", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "UV", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0 + }, + "m_Labels": [], + "m_Channel": 0 +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicValueMaterialSlot", + "m_ObjectId": "efe6d06fc42b46e4b3fc5ac9a0946f94", + "m_Id": 0, + "m_DisplayName": "A", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "A", + "m_StageCapability": 3, + "m_Value": { + "e00": 0.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 0.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 0.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 0.0 + }, + "m_DefaultValue": { + "e00": 1.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 1.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 1.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.MultiplyNode", + "m_ObjectId": "f0c7d06b68da4a81b05e5961b1cb89b8", + "m_Group": { + "m_Id": "" + }, + "m_Name": "Multiply", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": 3.0, + "y": 688.0, + "width": 126.0, + "height": 118.0 + } + }, + "m_Slots": [ + { + "m_Id": "045329d77ce54209bc36d64001ad3d8d" + }, + { + "m_Id": "94793cab87ab4827b1367f947b59ad60" + }, + { + "m_Id": "1fe97e2a31024c39bf59ccba87f11b54" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "f1e1a955bdb8443eab2e79ba7647a2d0", + "m_Id": 2, + "m_DisplayName": "T", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "T", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.PropertyNode", + "m_ObjectId": "f3f278701bf042e09eb0e843b0ff4647", + "m_Group": { + "m_Id": "" + }, + "m_Name": "Property", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -1738.0001220703125, + "y": -1359.0, + "width": 165.0, + "height": 34.0 + } + }, + "m_Slots": [ + { + "m_Id": "79674131981f4da1945bfab5e13813b6" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_Property": { + "m_Id": "fb85416d2e4d4df7b227e0bc2bdd6a71" + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "f5c37d6cf3c045f4919e914024af7a9b", + "m_Id": 0, + "m_DisplayName": "Gums Saturation", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.BooleanMaterialSlot", + "m_ObjectId": "f6df72d302d149b59b06efca28607171", + "m_Id": 0, + "m_DisplayName": "Predicate", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "Predicate", + "m_StageCapability": 3, + "m_Value": false, + "m_DefaultValue": false +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "f84d048317084b7395671a17f7f17fd2", + "m_Id": 2, + "m_DisplayName": "Out", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector2MaterialSlot", + "m_ObjectId": "f9b331b1062048d6b94590012e2f4adb", + "m_Id": 1, + "m_DisplayName": "Tiling", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "Tiling", + "m_StageCapability": 3, + "m_Value": { + "x": 1.0, + "y": 1.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0 + }, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicValueMaterialSlot", + "m_ObjectId": "fa90e5cc1119495385fb038ba542652c", + "m_Id": 0, + "m_DisplayName": "A", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "A", + "m_StageCapability": 3, + "m_Value": { + "e00": 0.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 0.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 0.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 0.0 + }, + "m_DefaultValue": { + "e00": 1.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 1.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 1.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 1.0 + } +} + +{ + "m_SGVersion": 1, + "m_Type": "UnityEditor.ShaderGraph.Internal.Vector1ShaderProperty", + "m_ObjectId": "fb85416d2e4d4df7b227e0bc2bdd6a71", + "m_Guid": { + "m_GuidSerialized": "bf9f1066-5dfe-4b46-aaeb-9152ace85ae8" + }, + "m_Name": "Teeth Brightness", + "m_DefaultReferenceName": "Vector1_fb85416d2e4d4df7b227e0bc2bdd6a71", + "m_OverrideReferenceName": "_TeethBrightness", + "m_GeneratePropertyBlock": true, + "m_Precision": 0, + "overrideHLSLDeclaration": false, + "hlslDeclarationOverride": 0, + "m_Hidden": false, + "m_Value": 0.699999988079071, + "m_FloatType": 1, + "m_RangeValues": { + "x": 0.0, + "y": 2.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "fc13441d8fab4afeb1a24d8250857829", + "m_Id": 0, + "m_DisplayName": "A", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "A", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector3MaterialSlot", + "m_ObjectId": "fcb5df76291e43d59d9d2c723f6e78ea", + "m_Id": 0, + "m_DisplayName": "In", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "In", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 1.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0 + }, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.BlockNode", + "m_ObjectId": "fce699c8ebf3428887ef6a715d55d4f9", + "m_Group": { + "m_Id": "" + }, + "m_Name": "SurfaceDescription.DiffusionProfileHash", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": 0.0, + "y": 0.0, + "width": 0.0, + "height": 0.0 + } + }, + "m_Slots": [ + { + "m_Id": "1d4e4c975a3241d5ab63d4debf2aec6a" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_SerializedDescriptor": "SurfaceDescription.DiffusionProfileHash" +} + +{ + "m_SGVersion": 1, + "m_Type": "UnityEditor.ShaderGraph.Internal.Vector1ShaderProperty", + "m_ObjectId": "fd115c5a3bec4b6eabfabdb2fdf437e6", + "m_Guid": { + "m_GuidSerialized": "e20c72c1-5528-4c1f-b415-f650f8626057" + }, + "m_Name": "Rear AO", + "m_DefaultReferenceName": "Vector1_fd115c5a3bec4b6eabfabdb2fdf437e6", + "m_OverrideReferenceName": "_RearAO", + "m_GeneratePropertyBlock": true, + "m_Precision": 0, + "overrideHLSLDeclaration": false, + "hlslDeclarationOverride": 0, + "m_Hidden": false, + "m_Value": 0.0, + "m_FloatType": 1, + "m_RangeValues": { + "x": 0.0, + "y": 1.0 + } +} + +{ + "m_SGVersion": 1, + "m_Type": "UnityEditor.ShaderGraph.Internal.Vector1ShaderProperty", + "m_ObjectId": "fea586edf5974ba687a3f05c3d4b6623", + "m_Guid": { + "m_GuidSerialized": "d548697a-b718-4882-bea1-9d72fb0dc53c" + }, + "m_Name": "Teeth Thickness", + "m_DefaultReferenceName": "Vector1_fea586edf5974ba687a3f05c3d4b6623", + "m_OverrideReferenceName": "_TeethThickness", + "m_GeneratePropertyBlock": true, + "m_Precision": 0, + "overrideHLSLDeclaration": false, + "hlslDeclarationOverride": 0, + "m_Hidden": false, + "m_Value": 0.699999988079071, + "m_FloatType": 1, + "m_RangeValues": { + "x": 0.0, + "y": 1.0 + } +} + diff --git a/HDRP/Shaders/RL_TeethShader_HDRP.shadergraph.meta b/HDRP/Shaders/RL_TeethShader_HDRP.shadergraph.meta new file mode 100644 index 0000000..e1cf387 --- /dev/null +++ b/HDRP/Shaders/RL_TeethShader_HDRP.shadergraph.meta @@ -0,0 +1,10 @@ +fileFormatVersion: 2 +guid: bade89290ffb11a468a4957d7cfbb4bd +ScriptedImporter: + internalIDToNameTable: [] + externalObjects: {} + serializedVersion: 2 + userData: + assetBundleName: + assetBundleVariant: + script: {fileID: 11500000, guid: 625f186215c104763be7675aa2d941aa, type: 3} diff --git a/HDRP/Shaders/RL_TongueShader_HDRP.shadergraph b/HDRP/Shaders/RL_TongueShader_HDRP.shadergraph new file mode 100644 index 0000000..6b3284c --- /dev/null +++ b/HDRP/Shaders/RL_TongueShader_HDRP.shadergraph @@ -0,0 +1,6125 @@ +{ + "m_SGVersion": 2, + "m_Type": "UnityEditor.ShaderGraph.GraphData", + "m_ObjectId": "f85a4e4b91df4a7db442a14fde53ed87", + "m_Properties": [ + { + "m_Id": "cb42572a46a74a588ef3935f3a667eb7" + }, + { + "m_Id": "3345a7b9279a48b7ba4602df55d812ac" + }, + { + "m_Id": "8a49d2f872e946d4a29e2030ee291584" + }, + { + "m_Id": "6d2408803a794f2e9368d5529b79a574" + }, + { + "m_Id": "2adde9b6c89f49aa838e8cfc38e04353" + }, + { + "m_Id": "c70d342b1a0b4d6bbf1ff3c98fd338ea" + }, + { + "m_Id": "c4024195aefa495695710ffb5997a875" + }, + { + "m_Id": "daa99c4f268449b8a4e69fdaeafcfe49" + }, + { + "m_Id": "a1eb91167291491694bf1bdf8d2f3e16" + }, + { + "m_Id": "229e12ce054c4003affcf25346b88151" + }, + { + "m_Id": "94ca5b7030dd47cf8a414dd9fee0ecde" + }, + { + "m_Id": "66cc0b010f5647d5bf80ded4825cab7c" + }, + { + "m_Id": "769181578f94433984a73faf6e153757" + }, + { + "m_Id": "ddd87d19404f41b8bbbd24232f4338ac" + }, + { + "m_Id": "fd115c5a3bec4b6eabfabdb2fdf437e6" + }, + { + "m_Id": "e25a1c81f1374f178c8f27b6264a5f1b" + }, + { + "m_Id": "0132cd9db49941618ed4bec849f97956" + } + ], + "m_Keywords": [], + "m_Nodes": [ + { + "m_Id": "4b45669a84054c498babd493511b3189" + }, + { + "m_Id": "0153caa15e554a9bb37fea4238ebdc5b" + }, + { + "m_Id": "00ab9614abb14bfea39934b2abff144b" + }, + { + "m_Id": "8a7ae7a881424567bd38f733cff73869" + }, + { + "m_Id": "bc0c9bafa3544deaaba658da5d1457a2" + }, + { + "m_Id": "08c1176d7dfe406bb0f6283ca763d553" + }, + { + "m_Id": "e701720035d44304a33f4b64350fc6e3" + }, + { + "m_Id": "6a4b619cae09428e850340b327dc2247" + }, + { + "m_Id": "6b280d605cf34b63ae417129545c2f7d" + }, + { + "m_Id": "e1e6ea93dab24d4086de0ce0507e9306" + }, + { + "m_Id": "d04a1ba74b404509b3874993b5771fe4" + }, + { + "m_Id": "847ac5df0b2d4dd58b05ed5100fd2d88" + }, + { + "m_Id": "0556880e701d48e589655db291ee6099" + }, + { + "m_Id": "273f61f0afd2438d95da7144e127460e" + }, + { + "m_Id": "8d0e91598db04dc39429e4727f60af22" + }, + { + "m_Id": "fce699c8ebf3428887ef6a715d55d4f9" + }, + { + "m_Id": "69822902c84c428080db9893d32ee267" + }, + { + "m_Id": "9203aadcc7e34fcbb60c753b4a4bd252" + }, + { + "m_Id": "2a43d5b227114bb2b6f245cbdffd15e5" + }, + { + "m_Id": "92460f8b665b4a03bb23e7fe80bdff90" + }, + { + "m_Id": "959bbc37ca814b42be52d1bd1b64e66f" + }, + { + "m_Id": "9abeb9fdadd74574b4e6738541daa06a" + }, + { + "m_Id": "2083576ab59b4225b9973e37eb2c681d" + }, + { + "m_Id": "1ceaea2d8a314216847b3e129a914f2c" + }, + { + "m_Id": "281c2fab10a54a88ace70a99836fe852" + }, + { + "m_Id": "5b5d90ab491f441884a78ece78c6e7a1" + }, + { + "m_Id": "ac06b0e4495e41ed855cc55978b80d86" + }, + { + "m_Id": "c2ce8f28915943d49e5539ae59b0b3bf" + }, + { + "m_Id": "d906043505fc466c9a6cd86bdf86c0a5" + }, + { + "m_Id": "12dd7939821a43b79a61d2ffaeb5c849" + }, + { + "m_Id": "3ab5c0ee94fd444da94411d41e7fa2fd" + }, + { + "m_Id": "71d1e8a063514b2680bf1f014cbf9938" + }, + { + "m_Id": "04e6d8d885c84b27b65b379ce432f20d" + }, + { + "m_Id": "252fe33b41ea44cc8726e40323b8fcdd" + }, + { + "m_Id": "095b3273b8844071b47eee774677bf1d" + }, + { + "m_Id": "4ee3e3b188a4495fb5be187a9f57cc27" + }, + { + "m_Id": "e28e83ed9ea04d5d9fea68c35524c5c0" + }, + { + "m_Id": "1b9c7cb2fc9a436886a8562251d803ba" + }, + { + "m_Id": "186d4331956b49ab9881ec6c6a1171de" + }, + { + "m_Id": "0aaaf2cdbe3a40b79ff5a3f1aef6e5cb" + }, + { + "m_Id": "5c1e15e64f344ffeb3dedb5d8961e21a" + }, + { + "m_Id": "88cc9c5e6d654dc59bdfa9d842b52c6c" + }, + { + "m_Id": "8b7bdce147474150867a58aa57473f58" + }, + { + "m_Id": "de3c1d50eb1848c6944a6a985e67a774" + }, + { + "m_Id": "529285465fc84b92a45a8fa283b80986" + }, + { + "m_Id": "691692b7141c4a62ad06471b9beb9a30" + }, + { + "m_Id": "f95e06c7a46249598a90d2cae4ca15c9" + }, + { + "m_Id": "353258cc828b4906a5b229836298d0fa" + }, + { + "m_Id": "7162b2f1f572448786eb9c07065a6d45" + }, + { + "m_Id": "679aaaf8b60147a8b91bfde9c26bec3e" + }, + { + "m_Id": "0a48a36898e24a35bee802cf4585c55a" + }, + { + "m_Id": "46b1bc1ddb4a4dc89010f96559aec714" + }, + { + "m_Id": "25da8d7d5d6b4be9bcfb213b299c71b1" + } + ], + "m_GroupDatas": [], + "m_StickyNoteDatas": [ + { + "m_Id": "1445382bcb70439b8e2c097b4a733e73" + } + ], + "m_Edges": [ + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "04e6d8d885c84b27b65b379ce432f20d" + }, + "m_SlotId": 6 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "5c1e15e64f344ffeb3dedb5d8961e21a" + }, + "m_SlotId": 2 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "0556880e701d48e589655db291ee6099" + }, + "m_SlotId": 5 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "46b1bc1ddb4a4dc89010f96559aec714" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "0556880e701d48e589655db291ee6099" + }, + "m_SlotId": 7 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "691692b7141c4a62ad06471b9beb9a30" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "095b3273b8844071b47eee774677bf1d" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "8d0e91598db04dc39429e4727f60af22" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "0a48a36898e24a35bee802cf4585c55a" + }, + "m_SlotId": 1 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "6b280d605cf34b63ae417129545c2f7d" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "0aaaf2cdbe3a40b79ff5a3f1aef6e5cb" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "1b9c7cb2fc9a436886a8562251d803ba" + }, + "m_SlotId": 1 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "12dd7939821a43b79a61d2ffaeb5c849" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "ac06b0e4495e41ed855cc55978b80d86" + }, + "m_SlotId": 1 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "186d4331956b49ab9881ec6c6a1171de" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "e28e83ed9ea04d5d9fea68c35524c5c0" + }, + "m_SlotId": 1 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "1b9c7cb2fc9a436886a8562251d803ba" + }, + "m_SlotId": 2 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "f95e06c7a46249598a90d2cae4ca15c9" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "1ceaea2d8a314216847b3e129a914f2c" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "959bbc37ca814b42be52d1bd1b64e66f" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "2083576ab59b4225b9973e37eb2c681d" + }, + "m_SlotId": 2 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "ac06b0e4495e41ed855cc55978b80d86" + }, + "m_SlotId": 2 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "252fe33b41ea44cc8726e40323b8fcdd" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "de3c1d50eb1848c6944a6a985e67a774" + }, + "m_SlotId": 1 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "25da8d7d5d6b4be9bcfb213b299c71b1" + }, + "m_SlotId": 2 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "0a48a36898e24a35bee802cf4585c55a" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "281c2fab10a54a88ace70a99836fe852" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "9abeb9fdadd74574b4e6738541daa06a" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "2a43d5b227114bb2b6f245cbdffd15e5" + }, + "m_SlotId": 3 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "281c2fab10a54a88ace70a99836fe852" + }, + "m_SlotId": 2 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "353258cc828b4906a5b229836298d0fa" + }, + "m_SlotId": 1 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "7162b2f1f572448786eb9c07065a6d45" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "3ab5c0ee94fd444da94411d41e7fa2fd" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "2083576ab59b4225b9973e37eb2c681d" + }, + "m_SlotId": 1 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "46b1bc1ddb4a4dc89010f96559aec714" + }, + "m_SlotId": 1 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "25da8d7d5d6b4be9bcfb213b299c71b1" + }, + "m_SlotId": 1 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "4ee3e3b188a4495fb5be187a9f57cc27" + }, + "m_SlotId": 3 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "6a4b619cae09428e850340b327dc2247" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "529285465fc84b92a45a8fa283b80986" + }, + "m_SlotId": 3 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "4ee3e3b188a4495fb5be187a9f57cc27" + }, + "m_SlotId": 2 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "529285465fc84b92a45a8fa283b80986" + }, + "m_SlotId": 3 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "de3c1d50eb1848c6944a6a985e67a774" + }, + "m_SlotId": 2 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "529285465fc84b92a45a8fa283b80986" + }, + "m_SlotId": 3 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "f95e06c7a46249598a90d2cae4ca15c9" + }, + "m_SlotId": 1 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "5b5d90ab491f441884a78ece78c6e7a1" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "9abeb9fdadd74574b4e6738541daa06a" + }, + "m_SlotId": 1 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "5c1e15e64f344ffeb3dedb5d8961e21a" + }, + "m_SlotId": 3 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "529285465fc84b92a45a8fa283b80986" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "679aaaf8b60147a8b91bfde9c26bec3e" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "25da8d7d5d6b4be9bcfb213b299c71b1" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "691692b7141c4a62ad06471b9beb9a30" + }, + "m_SlotId": 1 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "2083576ab59b4225b9973e37eb2c681d" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "69822902c84c428080db9893d32ee267" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "1ceaea2d8a314216847b3e129a914f2c" + }, + "m_SlotId": 1 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "7162b2f1f572448786eb9c07065a6d45" + }, + "m_SlotId": 1 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "e1e6ea93dab24d4086de0ce0507e9306" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "71d1e8a063514b2680bf1f014cbf9938" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "04e6d8d885c84b27b65b379ce432f20d" + }, + "m_SlotId": 1 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "847ac5df0b2d4dd58b05ed5100fd2d88" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "e28e83ed9ea04d5d9fea68c35524c5c0" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "847ac5df0b2d4dd58b05ed5100fd2d88" + }, + "m_SlotId": 7 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "353258cc828b4906a5b229836298d0fa" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "88cc9c5e6d654dc59bdfa9d842b52c6c" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "5c1e15e64f344ffeb3dedb5d8961e21a" + }, + "m_SlotId": 1 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "8b7bdce147474150867a58aa57473f58" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "5c1e15e64f344ffeb3dedb5d8961e21a" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "9203aadcc7e34fcbb60c753b4a4bd252" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "281c2fab10a54a88ace70a99836fe852" + }, + "m_SlotId": 1 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "92460f8b665b4a03bb23e7fe80bdff90" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "2a43d5b227114bb2b6f245cbdffd15e5" + }, + "m_SlotId": 1 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "959bbc37ca814b42be52d1bd1b64e66f" + }, + "m_SlotId": 2 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "bc0c9bafa3544deaaba658da5d1457a2" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "9abeb9fdadd74574b4e6738541daa06a" + }, + "m_SlotId": 2 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "959bbc37ca814b42be52d1bd1b64e66f" + }, + "m_SlotId": 1 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "ac06b0e4495e41ed855cc55978b80d86" + }, + "m_SlotId": 3 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "4ee3e3b188a4495fb5be187a9f57cc27" + }, + "m_SlotId": 1 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "c2ce8f28915943d49e5539ae59b0b3bf" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "0556880e701d48e589655db291ee6099" + }, + "m_SlotId": 1 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "d04a1ba74b404509b3874993b5771fe4" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "847ac5df0b2d4dd58b05ed5100fd2d88" + }, + "m_SlotId": 1 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "d906043505fc466c9a6cd86bdf86c0a5" + }, + "m_SlotId": 0 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "ac06b0e4495e41ed855cc55978b80d86" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "de3c1d50eb1848c6944a6a985e67a774" + }, + "m_SlotId": 3 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "273f61f0afd2438d95da7144e127460e" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "e28e83ed9ea04d5d9fea68c35524c5c0" + }, + "m_SlotId": 2 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "1b9c7cb2fc9a436886a8562251d803ba" + }, + "m_SlotId": 0 + } + }, + { + "m_OutputSlot": { + "m_Node": { + "m_Id": "f95e06c7a46249598a90d2cae4ca15c9" + }, + "m_SlotId": 2 + }, + "m_InputSlot": { + "m_Node": { + "m_Id": "8a7ae7a881424567bd38f733cff73869" + }, + "m_SlotId": 0 + } + } + ], + "m_VertexContext": { + "m_Position": { + "x": 1170.9998779296875, + "y": 1.9999842643737794 + }, + "m_Blocks": [ + { + "m_Id": "4b45669a84054c498babd493511b3189" + }, + { + "m_Id": "0153caa15e554a9bb37fea4238ebdc5b" + }, + { + "m_Id": "00ab9614abb14bfea39934b2abff144b" + } + ] + }, + "m_FragmentContext": { + "m_Position": { + "x": 1171.9998779296875, + "y": 248.9999542236328 + }, + "m_Blocks": [ + { + "m_Id": "8a7ae7a881424567bd38f733cff73869" + }, + { + "m_Id": "08c1176d7dfe406bb0f6283ca763d553" + }, + { + "m_Id": "e701720035d44304a33f4b64350fc6e3" + }, + { + "m_Id": "e1e6ea93dab24d4086de0ce0507e9306" + }, + { + "m_Id": "273f61f0afd2438d95da7144e127460e" + }, + { + "m_Id": "bc0c9bafa3544deaaba658da5d1457a2" + }, + { + "m_Id": "8d0e91598db04dc39429e4727f60af22" + }, + { + "m_Id": "6a4b619cae09428e850340b327dc2247" + }, + { + "m_Id": "fce699c8ebf3428887ef6a715d55d4f9" + }, + { + "m_Id": "6b280d605cf34b63ae417129545c2f7d" + } + ] + }, + "m_PreviewData": { + "serializedMesh": { + "m_SerializedMesh": "{\"mesh\":{\"instanceID\":0}}", + "m_Guid": "" + } + }, + "m_Path": "Shader Graphs", + "m_ConcretePrecision": 0, + "m_PreviewMode": 2, + "m_OutputNode": { + "m_Id": "" + }, + "m_ActiveTargets": [ + { + "m_Id": "0083909e70ac4601afc22e423a6e3d2e" + } + ] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.Rendering.HighDefinition.ShaderGraph.HDTarget", + "m_ObjectId": "0083909e70ac4601afc22e423a6e3d2e", + "m_ActiveSubTarget": { + "m_Id": "650ef699f8534d05b11661f3db2c1e50" + }, + "m_Datas": [ + { + "m_Id": "b00f1b66025c4b25a6f709e3c0ab54f4" + }, + { + "m_Id": "88f0b3d71738482fb6273b754134b4dd" + }, + { + "m_Id": "2a2960edadd1494c8e81b3d852cb3297" + }, + { + "m_Id": "5e856e0c3b704d14a6c36b84bf8d78f6" + } + ], + "m_CustomEditorGUI": "" +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.BlockNode", + "m_ObjectId": "00ab9614abb14bfea39934b2abff144b", + "m_Group": { + "m_Id": "" + }, + "m_Name": "VertexDescription.Tangent", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": 0.0, + "y": 0.0, + "width": 0.0, + "height": 0.0 + } + }, + "m_Slots": [ + { + "m_Id": "c996e165d42c4929928bc49c5e17d734" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_SerializedDescriptor": "VertexDescription.Tangent" +} + +{ + "m_SGVersion": 1, + "m_Type": "UnityEditor.ShaderGraph.Internal.Vector1ShaderProperty", + "m_ObjectId": "0132cd9db49941618ed4bec849f97956", + "m_Guid": { + "m_GuidSerialized": "7e7ba2c7-42da-4e3d-8475-98e98400f0ed" + }, + "m_Name": "Tongue Thickness", + "m_DefaultReferenceName": "Vector1_0132cd9db49941618ed4bec849f97956", + "m_OverrideReferenceName": "_TongueThickness", + "m_GeneratePropertyBlock": true, + "m_Precision": 0, + "overrideHLSLDeclaration": false, + "hlslDeclarationOverride": 0, + "m_Hidden": false, + "m_Value": 0.75, + "m_FloatType": 1, + "m_RangeValues": { + "x": 0.0, + "y": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.BlockNode", + "m_ObjectId": "0153caa15e554a9bb37fea4238ebdc5b", + "m_Group": { + "m_Id": "" + }, + "m_Name": "VertexDescription.Normal", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": 0.0, + "y": 0.0, + "width": 0.0, + "height": 0.0 + } + }, + "m_Slots": [ + { + "m_Id": "3b9bea9727174fc0b9e705617c9903db" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_SerializedDescriptor": "VertexDescription.Normal" +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "032a7bb9e8a4477cad21efd3a69bff0a", + "m_Id": 2, + "m_DisplayName": "T", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "T", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "03653dd0f9ee454b820eb0296d49215f", + "m_Id": 0, + "m_DisplayName": "", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Texture2DMaterialSlot", + "m_ObjectId": "03e2818f83814498bb9178cea7ffb00d", + "m_Id": 0, + "m_DisplayName": "Gradient AO Map", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_BareResource": false +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.SampleTexture2DNode", + "m_ObjectId": "04e6d8d885c84b27b65b379ce432f20d", + "m_Group": { + "m_Id": "" + }, + "m_Name": "Sample Texture 2D", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -3107.0, + "y": 149.0, + "width": 208.00001525878907, + "height": 437.0 + } + }, + "m_Slots": [ + { + "m_Id": "9341dc5c4cf94d6b960a964876b3d428" + }, + { + "m_Id": "32f3a8d8864f407483bdfb32a02f37ea" + }, + { + "m_Id": "4819726fa0474485b5d29c8087c3516e" + }, + { + "m_Id": "39d0eb30a6fc470d8614c68053a81004" + }, + { + "m_Id": "ebadab64ba5e4222bde9e2423849c96c" + }, + { + "m_Id": "4484d7a3020247eeab08441067990b9b" + }, + { + "m_Id": "eeb935f5191a4a59a9bc1ec799914d58" + }, + { + "m_Id": "1e93ca7bb12b4a4cad349c060d01f1a9" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_TextureType": 0, + "m_NormalMapSpace": 0 +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.SampleTexture2DNode", + "m_ObjectId": "0556880e701d48e589655db291ee6099", + "m_Group": { + "m_Id": "" + }, + "m_Name": "Sample Texture 2D", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -3101.0, + "y": 914.0, + "width": 208.0, + "height": 437.0 + } + }, + "m_Slots": [ + { + "m_Id": "86b897ab597140d59a473d807e980628" + }, + { + "m_Id": "5d77a606937f44feb8860c6501cc4557" + }, + { + "m_Id": "37502e011dba43adad5a4c1965f0daf5" + }, + { + "m_Id": "b384faa820304f82807176601dd16753" + }, + { + "m_Id": "ad46a176c1ac40b78ee3a38ad5846d4d" + }, + { + "m_Id": "7c52d0c211b148baa2dee264ed442794" + }, + { + "m_Id": "8c95ccd4e8fd4bf29cc1afa00cc39223" + }, + { + "m_Id": "85c5c76f4845488eb95392938396f2b9" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_TextureType": 0, + "m_NormalMapSpace": 0 +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "05efbcd28970432bab2f0280997fc441", + "m_Id": 7, + "m_DisplayName": "A", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "A", + "m_StageCapability": 2, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.UVMaterialSlot", + "m_ObjectId": "0647cd09207e46a99623889e73580759", + "m_Id": 2, + "m_DisplayName": "UV", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "UV", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0 + }, + "m_Labels": [], + "m_Channel": 0 +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "06d5e593464346e08c0ac58e9a83fb5f", + "m_Id": 1, + "m_DisplayName": "B", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "B", + "m_StageCapability": 3, + "m_Value": { + "x": 1.0, + "y": 1.0, + "z": 1.0, + "w": 1.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicValueMaterialSlot", + "m_ObjectId": "07accfe4489345b5bc9732581dc1c844", + "m_Id": 2, + "m_DisplayName": "Out", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": { + "e00": 0.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 0.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 0.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 0.0 + }, + "m_DefaultValue": { + "e00": 1.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 1.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 1.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.BlockNode", + "m_ObjectId": "08c1176d7dfe406bb0f6283ca763d553", + "m_Group": { + "m_Id": "" + }, + "m_Name": "SurfaceDescription.BentNormal", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": 0.0, + "y": 0.0, + "width": 0.0, + "height": 0.0 + } + }, + "m_Slots": [ + { + "m_Id": "c4b6c46dc8b348b8a5ecd4e2aead24c0" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_SerializedDescriptor": "SurfaceDescription.BentNormal" +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.PropertyNode", + "m_ObjectId": "095b3273b8844071b47eee774677bf1d", + "m_Group": { + "m_Id": "" + }, + "m_Name": "Property", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": 687.0, + "y": 531.0, + "width": 171.00001525878907, + "height": 34.000003814697269 + } + }, + "m_Slots": [ + { + "m_Id": "3de68672d00143c09300da7a5df0f89f" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_Property": { + "m_Id": "0132cd9db49941618ed4bec849f97956" + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector3MaterialSlot", + "m_ObjectId": "09847344f8004a26bdad187ff3b528cd", + "m_Id": 1, + "m_DisplayName": "B", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "B", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 1.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0 + }, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.OneMinusNode", + "m_ObjectId": "0a48a36898e24a35bee802cf4585c55a", + "m_Group": { + "m_Id": "" + }, + "m_Name": "One Minus", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -1137.0, + "y": 767.0, + "width": 128.0, + "height": 94.0 + } + }, + "m_Slots": [ + { + "m_Id": "d04c9803937e4542b898dda59caa7140" + }, + { + "m_Id": "117b8e5a0b2f48fb8abe8fc13105e4a4" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.PropertyNode", + "m_ObjectId": "0aaaf2cdbe3a40b79ff5a3f1aef6e5cb", + "m_Group": { + "m_Id": "" + }, + "m_Name": "Property", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -1815.000244140625, + "y": -639.0, + "width": 174.0, + "height": 34.0 + } + }, + "m_Slots": [ + { + "m_Id": "ada7147b76d2440ab2f288313b8bc05e" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_Property": { + "m_Id": "769181578f94433984a73faf6e153757" + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicValueMaterialSlot", + "m_ObjectId": "0af9e511272b410c9be3e0b86381e6d0", + "m_Id": 1, + "m_DisplayName": "B", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "B", + "m_StageCapability": 3, + "m_Value": { + "e00": 2.0, + "e01": 2.0, + "e02": 2.0, + "e03": 2.0, + "e10": 2.0, + "e11": 2.0, + "e12": 2.0, + "e13": 2.0, + "e20": 2.0, + "e21": 2.0, + "e22": 2.0, + "e23": 2.0, + "e30": 2.0, + "e31": 2.0, + "e32": 2.0, + "e33": 2.0 + }, + "m_DefaultValue": { + "e00": 1.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 1.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 1.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "0bd3147b039a4a1981a74b5d8942f3bd", + "m_Id": 0, + "m_DisplayName": "Smoothness Power", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "0d28e9b96829486b9a93fb4b4493ec53", + "m_Id": 0, + "m_DisplayName": "Smoothness", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "Smoothness", + "m_StageCapability": 2, + "m_Value": 0.5, + "m_DefaultValue": 0.5, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.NormalMaterialSlot", + "m_ObjectId": "0e03c873ccc040dd8417724de5eaf36d", + "m_Id": 0, + "m_DisplayName": "Normal (Tangent Space)", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "NormalTS", + "m_StageCapability": 2, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0 + }, + "m_Labels": [], + "m_Space": 3 +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "117b8e5a0b2f48fb8abe8fc13105e4a4", + "m_Id": 1, + "m_DisplayName": "Out", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.PropertyNode", + "m_ObjectId": "12dd7939821a43b79a61d2ffaeb5c849", + "m_Group": { + "m_Id": "" + }, + "m_Name": "Property", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -706.0, + "y": 1188.9998779296875, + "width": 215.99998474121095, + "height": 33.999996185302737 + } + }, + "m_Slots": [ + { + "m_Id": "dab7b0ac196344f9a829a1307ef0b532" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_Property": { + "m_Id": "94ca5b7030dd47cf8a414dd9fee0ecde" + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.StickyNoteData", + "m_ObjectId": "1445382bcb70439b8e2c097b4a733e73", + "m_Title": "HDRP", + "m_Content": "R = Metallic\nG = AO\nB = Micro Normal Mask\nA = Smoothness", + "m_TextSize": 0, + "m_Theme": 0, + "m_Position": { + "serializedVersion": "2", + "x": -3099.0, + "y": 805.0, + "width": 200.0, + "height": 100.0 + }, + "m_Group": { + "m_Id": "" + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "14691abbdb8c44868b2fbf943456a214", + "m_Id": 4, + "m_DisplayName": "R", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "R", + "m_StageCapability": 2, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector4MaterialSlot", + "m_ObjectId": "186cb51092954fe39e95085fa462302e", + "m_Id": 0, + "m_DisplayName": "RGBA", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "RGBA", + "m_StageCapability": 2, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.PropertyNode", + "m_ObjectId": "186d4331956b49ab9881ec6c6a1171de", + "m_Group": { + "m_Id": "" + }, + "m_Name": "Property", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -2120.000244140625, + "y": -559.0, + "width": 171.00001525878907, + "height": 34.0 + } + }, + "m_Slots": [ + { + "m_Id": "f5c37d6cf3c045f4919e914024af7a9b" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_Property": { + "m_Id": "66cc0b010f5647d5bf80ded4825cab7c" + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Texture2DMaterialSlot", + "m_ObjectId": "1a6dccb88a494fbebd6d32ab0323405b", + "m_Id": 0, + "m_DisplayName": "Mask Map", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_BareResource": false +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.MultiplyNode", + "m_ObjectId": "1b9c7cb2fc9a436886a8562251d803ba", + "m_Group": { + "m_Id": "" + }, + "m_Name": "Multiply", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -1546.000244140625, + "y": -747.0000610351563, + "width": 130.0, + "height": 118.00000762939453 + } + }, + "m_Slots": [ + { + "m_Id": "fa90e5cc1119495385fb038ba542652c" + }, + { + "m_Id": "0af9e511272b410c9be3e0b86381e6d0" + }, + { + "m_Id": "535c5126e61841099e1ad49b42eaefc8" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.SampleTexture2DNode", + "m_ObjectId": "1ceaea2d8a314216847b3e129a914f2c", + "m_Group": { + "m_Id": "" + }, + "m_Name": "Sample Texture 2D", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -872.0, + "y": 1556.0, + "width": 208.0, + "height": 437.0 + } + }, + "m_Slots": [ + { + "m_Id": "186cb51092954fe39e95085fa462302e" + }, + { + "m_Id": "14691abbdb8c44868b2fbf943456a214" + }, + { + "m_Id": "40093fdb515740a6b89991c27475fb70" + }, + { + "m_Id": "62cce88aaad1405d9a4f9103c020132e" + }, + { + "m_Id": "b1d4b45693af46a3a723b2ffb1b8b88a" + }, + { + "m_Id": "eb7f26266d4d47c9a57e818a9e6890dc" + }, + { + "m_Id": "b959e24d88ea43f5bf4256f07ae90ec0" + }, + { + "m_Id": "96f36c732c8e47529d446f73fa12dd82" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_TextureType": 1, + "m_NormalMapSpace": 0 +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "1d1ca274b5fe42e69ce56945c39a8ea7", + "m_Id": 6, + "m_DisplayName": "B", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "B", + "m_StageCapability": 2, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.Rendering.HighDefinition.DiffusionProfileInputMaterialSlot", + "m_ObjectId": "1d4e4c975a3241d5ab63d4debf2aec6a", + "m_Id": 0, + "m_DisplayName": "Diffusion Profile", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "DiffusionProfileHash", + "m_StageCapability": 2, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [], + "m_DiffusionProfile": { + "selectedEntry": 0, + "popupEntries": [] + }, + "m_SerializedDiffusionProfile": "{\n \"diffusionProfileAsset\": {\n \"fileID\": 11400000,\n \"guid\": \"26bdddf49760c61438938733f07fa2a2\",\n \"type\": 2\n }\n}", + "m_Version": 1 +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.SamplerStateMaterialSlot", + "m_ObjectId": "1e93ca7bb12b4a4cad349c060d01f1a9", + "m_Id": 3, + "m_DisplayName": "Sampler", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "Sampler", + "m_StageCapability": 3, + "m_BareResource": false +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.PowerNode", + "m_ObjectId": "2083576ab59b4225b9973e37eb2c681d", + "m_Group": { + "m_Id": "" + }, + "m_Name": "Power", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -699.0, + "y": 1238.9998779296875, + "width": 207.99998474121095, + "height": 301.9999694824219 + } + }, + "m_Slots": [ + { + "m_Id": "4267a37b446f48b88f36740206176441" + }, + { + "m_Id": "bdb35f0f256944dfafd7981d98006c9f" + }, + { + "m_Id": "8547d55cd06b487d8d347cc2a2c0bb74" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 1, + "m_Type": "UnityEditor.ShaderGraph.Internal.Vector1ShaderProperty", + "m_ObjectId": "229e12ce054c4003affcf25346b88151", + "m_Guid": { + "m_GuidSerialized": "2bb55888-515a-40aa-8e09-1204f3c80b17" + }, + "m_Name": "Smoothness Min", + "m_DefaultReferenceName": "", + "m_OverrideReferenceName": "_SmoothnessMin", + "m_GeneratePropertyBlock": true, + "m_Precision": 0, + "overrideHLSLDeclaration": false, + "hlslDeclarationOverride": 0, + "m_Hidden": false, + "m_Value": 0.25, + "m_FloatType": 1, + "m_RangeValues": { + "x": 0.0, + "y": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.PropertyNode", + "m_ObjectId": "252fe33b41ea44cc8726e40323b8fcdd", + "m_Group": { + "m_Id": "" + }, + "m_Name": "Property", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -646.0001831054688, + "y": 2.0000205039978029, + "width": 216.0, + "height": 34.000003814697269 + } + }, + "m_Slots": [ + { + "m_Id": "d729776e47ca458d9f698b924845442d" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_Property": { + "m_Id": "e25a1c81f1374f178c8f27b6264a5f1b" + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector3MaterialSlot", + "m_ObjectId": "25d3c8e1fdbb4c4fbfd4868867b08f5a", + "m_Id": 0, + "m_DisplayName": "In", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "In", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0 + }, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.MultiplyNode", + "m_ObjectId": "25da8d7d5d6b4be9bcfb213b299c71b1", + "m_Group": { + "m_Id": "" + }, + "m_Name": "Multiply", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -1424.0, + "y": 727.0, + "width": 208.00001525878907, + "height": 302.0 + } + }, + "m_Slots": [ + { + "m_Id": "ee25af686468440597f42316525acc5d" + }, + { + "m_Id": "cdb77f064fef46a6b98e0247d00a7054" + }, + { + "m_Id": "07accfe4489345b5bc9732581dc1c844" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.UVMaterialSlot", + "m_ObjectId": "261a1463774f402ea6cf22be3927056d", + "m_Id": 0, + "m_DisplayName": "UV", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "UV", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0 + }, + "m_Labels": [], + "m_Channel": 0 +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Texture2DInputMaterialSlot", + "m_ObjectId": "26d61b36c9a4458b99c9cf5016233792", + "m_Id": 1, + "m_DisplayName": "Texture", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "Texture", + "m_StageCapability": 3, + "m_BareResource": false, + "m_Texture": { + "m_SerializedTexture": "{\"texture\":{\"instanceID\":0}}", + "m_Guid": "" + }, + "m_DefaultType": 3 +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.BlockNode", + "m_ObjectId": "273f61f0afd2438d95da7144e127460e", + "m_Group": { + "m_Id": "" + }, + "m_Name": "SurfaceDescription.SubsurfaceMask", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": 0.0, + "y": 0.0, + "width": 0.0, + "height": 0.0 + } + }, + "m_Slots": [ + { + "m_Id": "e8362fd7f2884d1ab1ac906ae9c28004" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_SerializedDescriptor": "SurfaceDescription.SubsurfaceMask" +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.SampleTexture2DNode", + "m_ObjectId": "281c2fab10a54a88ace70a99836fe852", + "m_Group": { + "m_Id": "" + }, + "m_Name": "Sample Texture 2D", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -1171.0001220703125, + "y": 2012.0001220703125, + "width": 184.0, + "height": 253.00001525878907 + } + }, + "m_Slots": [ + { + "m_Id": "69d54d6c4ba64a468f042e25e1f1a0ca" + }, + { + "m_Id": "2af5165093084217aac61b4af29a730d" + }, + { + "m_Id": "c9c382f96969430ca6a46ac85b576bb2" + }, + { + "m_Id": "383a3e546b014329b0e83fd4ea9c0506" + }, + { + "m_Id": "05efbcd28970432bab2f0280997fc441" + }, + { + "m_Id": "26d61b36c9a4458b99c9cf5016233792" + }, + { + "m_Id": "0647cd09207e46a99623889e73580759" + }, + { + "m_Id": "ba586a643825415d9395e0095ddd8d8a" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_TextureType": 1, + "m_NormalMapSpace": 0 +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.Rendering.HighDefinition.ShaderGraph.LightingData", + "m_ObjectId": "2a2960edadd1494c8e81b3d852cb3297", + "m_NormalDropOffSpace": 0, + "m_BlendPreserveSpecular": true, + "m_ReceiveDecals": true, + "m_ReceiveSSR": true, + "m_ReceiveSSRTransparent": false, + "m_SpecularAA": false, + "m_SpecularOcclusionMode": 1, + "m_OverrideBakedGI": false +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.TilingAndOffsetNode", + "m_ObjectId": "2a43d5b227114bb2b6f245cbdffd15e5", + "m_Group": { + "m_Id": "" + }, + "m_Name": "Tiling And Offset", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -1366.0001220703125, + "y": 2074.0, + "width": 155.0, + "height": 142.0 + } + }, + "m_Slots": [ + { + "m_Id": "261a1463774f402ea6cf22be3927056d" + }, + { + "m_Id": "f9b331b1062048d6b94590012e2f4adb" + }, + { + "m_Id": "c083ca9475264d81936b2f64c2ae9982" + }, + { + "m_Id": "89d785e9bb6c413687505ab305a7ebf9" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Internal.Texture2DShaderProperty", + "m_ObjectId": "2adde9b6c89f49aa838e8cfc38e04353", + "m_Guid": { + "m_GuidSerialized": "26038d6e-7102-4cb8-bc85-ef0263e8d130" + }, + "m_Name": "Gradient AO Map", + "m_DefaultReferenceName": "Texture2D_2adde9b6c89f49aa838e8cfc38e04353", + "m_OverrideReferenceName": "_GradientAOMap", + "m_GeneratePropertyBlock": true, + "m_Precision": 0, + "overrideHLSLDeclaration": false, + "hlslDeclarationOverride": 0, + "m_Hidden": false, + "m_Value": { + "m_SerializedTexture": "{\"texture\":{\"instanceID\":0}}", + "m_Guid": "" + }, + "m_Modifiable": true, + "m_DefaultType": 0 +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "2af5165093084217aac61b4af29a730d", + "m_Id": 4, + "m_DisplayName": "R", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "R", + "m_StageCapability": 2, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "2b081408a7e24e398594d062ea1a971f", + "m_Id": 4, + "m_DisplayName": "R", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "R", + "m_StageCapability": 2, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "315af748590c43e98863cdc26b38904f", + "m_Id": 0, + "m_DisplayName": "Micro Normal Strength", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicValueMaterialSlot", + "m_ObjectId": "32d0ac1b6af24b7a9438b0207f520fe3", + "m_Id": 1, + "m_DisplayName": "B", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "B", + "m_StageCapability": 3, + "m_Value": { + "e00": 2.0, + "e01": 2.0, + "e02": 2.0, + "e03": 2.0, + "e10": 2.0, + "e11": 2.0, + "e12": 2.0, + "e13": 2.0, + "e20": 2.0, + "e21": 2.0, + "e22": 2.0, + "e23": 2.0, + "e30": 2.0, + "e31": 2.0, + "e32": 2.0, + "e33": 2.0 + }, + "m_DefaultValue": { + "e00": 1.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 1.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 1.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "32f3a8d8864f407483bdfb32a02f37ea", + "m_Id": 4, + "m_DisplayName": "R", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "R", + "m_StageCapability": 2, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Internal.Texture2DShaderProperty", + "m_ObjectId": "3345a7b9279a48b7ba4602df55d812ac", + "m_Guid": { + "m_GuidSerialized": "11573659-5da7-4813-a954-c0a0d3d0de68" + }, + "m_Name": "Mask Map", + "m_DefaultReferenceName": "Texture2D_3345a7b9279a48b7ba4602df55d812ac", + "m_OverrideReferenceName": "_MaskMap", + "m_GeneratePropertyBlock": true, + "m_Precision": 0, + "overrideHLSLDeclaration": false, + "hlslDeclarationOverride": 0, + "m_Hidden": false, + "m_Value": { + "m_SerializedTexture": "{\"texture\":{\"instanceID\":0}}", + "m_Guid": "" + }, + "m_Modifiable": true, + "m_DefaultType": 0 +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "33bd9f0db88e4408a8c55746b350ccee", + "m_Id": 3, + "m_DisplayName": "Out", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.RedirectNodeData", + "m_ObjectId": "353258cc828b4906a5b229836298d0fa", + "m_Group": { + "m_Id": "" + }, + "m_Name": "Redirect Node", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -1023.0, + "y": -269.0000305175781, + "width": 56.0, + "height": 23.999998092651368 + } + }, + "m_Slots": [ + { + "m_Id": "e0939e0be9914105a29d68faf0cba8c8" + }, + { + "m_Id": "7089df8d8eea4ce6bd4682b076eb7ba4" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "37502e011dba43adad5a4c1965f0daf5", + "m_Id": 5, + "m_DisplayName": "G", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "G", + "m_StageCapability": 2, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "383a3e546b014329b0e83fd4ea9c0506", + "m_Id": 6, + "m_DisplayName": "B", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "B", + "m_StageCapability": 2, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "39a1b3de165b4ff6beecaebd677c6e3a", + "m_Id": 5, + "m_DisplayName": "G", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "G", + "m_StageCapability": 2, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "39d0eb30a6fc470d8614c68053a81004", + "m_Id": 6, + "m_DisplayName": "B", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "B", + "m_StageCapability": 2, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.PropertyNode", + "m_ObjectId": "3ab5c0ee94fd444da94411d41e7fa2fd", + "m_Group": { + "m_Id": "" + }, + "m_Name": "Property", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -927.9999389648438, + "y": 1227.9998779296875, + "width": 177.99998474121095, + "height": 33.999996185302737 + } + }, + "m_Slots": [ + { + "m_Id": "0bd3147b039a4a1981a74b5d8942f3bd" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_Property": { + "m_Id": "a1eb91167291491694bf1bdf8d2f3e16" + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.NormalMaterialSlot", + "m_ObjectId": "3b9bea9727174fc0b9e705617c9903db", + "m_Id": 0, + "m_DisplayName": "Normal", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "Normal", + "m_StageCapability": 1, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0 + }, + "m_Labels": [], + "m_Space": 0 +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "3de68672d00143c09300da7a5df0f89f", + "m_Id": 0, + "m_DisplayName": "Tongue Thickness", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "3ea31f42e0004d18b71cf3948e2bced7", + "m_Id": 0, + "m_DisplayName": "A", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "A", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "40093fdb515740a6b89991c27475fb70", + "m_Id": 5, + "m_DisplayName": "G", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "G", + "m_StageCapability": 2, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Texture2DInputMaterialSlot", + "m_ObjectId": "40411d53b935493097fbc12e892291fa", + "m_Id": 1, + "m_DisplayName": "Texture", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "Texture", + "m_StageCapability": 3, + "m_BareResource": false, + "m_Texture": { + "m_SerializedTexture": "{\"texture\":{\"instanceID\":0}}", + "m_Guid": "" + }, + "m_DefaultType": 0 +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector3MaterialSlot", + "m_ObjectId": "410bebff5a4c4691b70fcbc06f01c0af", + "m_Id": 2, + "m_DisplayName": "Out", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0 + }, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "424b313138944a21bc404c418bcb085e", + "m_Id": 0, + "m_DisplayName": "Alpha", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "Alpha", + "m_StageCapability": 2, + "m_Value": 1.0, + "m_DefaultValue": 1.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "4267a37b446f48b88f36740206176441", + "m_Id": 0, + "m_DisplayName": "A", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "A", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Texture2DInputMaterialSlot", + "m_ObjectId": "4484d7a3020247eeab08441067990b9b", + "m_Id": 1, + "m_DisplayName": "Texture", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "Texture", + "m_StageCapability": 3, + "m_BareResource": false, + "m_Texture": { + "m_SerializedTexture": "{\"texture\":{\"instanceID\":0}}", + "m_Guid": "" + }, + "m_DefaultType": 0 +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.OneMinusNode", + "m_ObjectId": "46b1bc1ddb4a4dc89010f96559aec714", + "m_Group": { + "m_Id": "" + }, + "m_Name": "One Minus", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -1729.0, + "y": 751.0, + "width": 208.00001525878907, + "height": 278.0 + } + }, + "m_Slots": [ + { + "m_Id": "81d92deb1aa34b7e876da6ea11def4ab" + }, + { + "m_Id": "a5fcb9dea25f4e4583ddcbf27785720f" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "4819726fa0474485b5d29c8087c3516e", + "m_Id": 5, + "m_DisplayName": "G", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "G", + "m_StageCapability": 2, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "497022c0ba274a6fb575cf7c142d01eb", + "m_Id": 0, + "m_DisplayName": "A", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "A", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.BlockNode", + "m_ObjectId": "4b45669a84054c498babd493511b3189", + "m_Group": { + "m_Id": "" + }, + "m_Name": "VertexDescription.Position", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": 0.0, + "y": 0.0, + "width": 0.0, + "height": 0.0 + } + }, + "m_Slots": [ + { + "m_Id": "cb901263bb9a42489ac84d9e84023477" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_SerializedDescriptor": "VertexDescription.Position" +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "4b74a689ec434dd59f47dc609c975fe2", + "m_Id": 0, + "m_DisplayName": "In", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "In", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "4d052f48b2bc4730aae5151d854ea582", + "m_Id": 2, + "m_DisplayName": "Max", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "Max", + "m_StageCapability": 3, + "m_Value": { + "x": 1.0, + "y": 1.0, + "z": 1.0, + "w": 1.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.LerpNode", + "m_ObjectId": "4ee3e3b188a4495fb5be187a9f57cc27", + "m_Group": { + "m_Id": "" + }, + "m_Name": "Lerp", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -18.99986457824707, + "y": 935.0, + "width": 207.99998474121095, + "height": 326.0 + } + }, + "m_Slots": [ + { + "m_Id": "497022c0ba274a6fb575cf7c142d01eb" + }, + { + "m_Id": "9eb92eca01e24b8f85337980637997fb" + }, + { + "m_Id": "54eeca54225f43fd8f2e73f6f7611014" + }, + { + "m_Id": "d86ff386dec24b5e9bc2b39657d6d1af" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.ColorRGBMaterialSlot", + "m_ObjectId": "4fbf6229bad74e91afb7ff4f2a7f0018", + "m_Id": 0, + "m_DisplayName": "Emission", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "Emission", + "m_StageCapability": 2, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0 + }, + "m_Labels": [], + "m_ColorMode": 1, + "m_DefaultColor": { + "r": 0.0, + "g": 0.0, + "b": 0.0, + "a": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.ClampNode", + "m_ObjectId": "529285465fc84b92a45a8fa283b80986", + "m_Group": { + "m_Id": "" + }, + "m_Name": "Clamp", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -2342.0, + "y": 41.00000762939453, + "width": 208.0, + "height": 326.0000305175781 + } + }, + "m_Slots": [ + { + "m_Id": "9153020f03ef49b7bc43bd9bdc109f86" + }, + { + "m_Id": "74b82f61cd1d45fda5ae6fff99ab24a6" + }, + { + "m_Id": "4d052f48b2bc4730aae5151d854ea582" + }, + { + "m_Id": "33bd9f0db88e4408a8c55746b350ccee" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicValueMaterialSlot", + "m_ObjectId": "535c5126e61841099e1ad49b42eaefc8", + "m_Id": 2, + "m_DisplayName": "Out", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": { + "e00": 0.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 0.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 0.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 0.0 + }, + "m_DefaultValue": { + "e00": 1.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 1.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 1.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "54eeca54225f43fd8f2e73f6f7611014", + "m_Id": 2, + "m_DisplayName": "T", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "T", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "5608685f8fa04124b51f5a4ca9cc179b", + "m_Id": 0, + "m_DisplayName": "Micro Normal Tiling", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Texture2DMaterialSlot", + "m_ObjectId": "565c01cd27814834acd27d2472d0033f", + "m_Id": 0, + "m_DisplayName": "Diffuse Map", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_BareResource": false +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.PropertyNode", + "m_ObjectId": "5b5d90ab491f441884a78ece78c6e7a1", + "m_Group": { + "m_Id": "" + }, + "m_Name": "Property", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -1155.9998779296875, + "y": 2470.0, + "width": 195.0, + "height": 34.0 + } + }, + "m_Slots": [ + { + "m_Id": "315af748590c43e98863cdc26b38904f" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_Property": { + "m_Id": "c70d342b1a0b4d6bbf1ff3c98fd338ea" + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.LerpNode", + "m_ObjectId": "5c1e15e64f344ffeb3dedb5d8961e21a", + "m_Group": { + "m_Id": "" + }, + "m_Name": "Lerp", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -2648.0, + "y": 41.0000114440918, + "width": 208.0, + "height": 326.0 + } + }, + "m_Slots": [ + { + "m_Id": "3ea31f42e0004d18b71cf3948e2bced7" + }, + { + "m_Id": "06d5e593464346e08c0ac58e9a83fb5f" + }, + { + "m_Id": "eb35f412fd8f4581af8767cf900abd35" + }, + { + "m_Id": "e5725a1cc09748b68df4a7edb1c07f9c" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "5cd0b7447b494a5986677121c0e50a48", + "m_Id": 1, + "m_DisplayName": "Out", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "5d77a606937f44feb8860c6501cc4557", + "m_Id": 4, + "m_DisplayName": "R", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "R", + "m_StageCapability": 2, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.Rendering.HighDefinition.ShaderGraph.SystemData", + "m_ObjectId": "5e856e0c3b704d14a6c36b84bf8d78f6", + "m_MaterialNeedsUpdateHash": 530, + "m_SurfaceType": 0, + "m_RenderingPass": 1, + "m_BlendMode": 0, + "m_ZTest": 4, + "m_ZWrite": false, + "m_TransparentCullMode": 2, + "m_OpaqueCullMode": 2, + "m_SortPriority": 0, + "m_AlphaTest": false, + "m_TransparentDepthPrepass": false, + "m_TransparentDepthPostpass": false, + "m_SupportLodCrossFade": false, + "m_DoubleSidedMode": 0, + "m_DOTSInstancing": false, + "m_Version": 0, + "m_FirstTimeMigrationExecuted": true, + "inspectorFoldoutMask": 9 +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "62cce88aaad1405d9a4f9103c020132e", + "m_Id": 6, + "m_DisplayName": "B", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "B", + "m_StageCapability": 2, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "6321e82512d8494fa6bc1f1890a53823", + "m_Id": 2, + "m_DisplayName": "T", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "T", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.Rendering.HighDefinition.ShaderGraph.HDLitSubTarget", + "m_ObjectId": "650ef699f8534d05b11661f3db2c1e50" +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "6574d6ca0bb24871b8226477233c11fe", + "m_Id": 0, + "m_DisplayName": "Smoothness Min", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 1, + "m_Type": "UnityEditor.ShaderGraph.Internal.Vector1ShaderProperty", + "m_ObjectId": "66cc0b010f5647d5bf80ded4825cab7c", + "m_Guid": { + "m_GuidSerialized": "dc8aa899-adef-4c83-8bf1-94f1fe78285d" + }, + "m_Name": "Tongue Saturation", + "m_DefaultReferenceName": "Vector1_66cc0b010f5647d5bf80ded4825cab7c", + "m_OverrideReferenceName": "_TongueSaturation", + "m_GeneratePropertyBlock": true, + "m_Precision": 0, + "overrideHLSLDeclaration": false, + "hlslDeclarationOverride": 0, + "m_Hidden": false, + "m_Value": 0.949999988079071, + "m_FloatType": 1, + "m_RangeValues": { + "x": 0.0, + "y": 2.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.PropertyNode", + "m_ObjectId": "679aaaf8b60147a8b91bfde9c26bec3e", + "m_Group": { + "m_Id": "" + }, + "m_Name": "Property", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -1729.0001220703125, + "y": 676.0000610351563, + "width": 221.00001525878907, + "height": 34.0 + } + }, + "m_Slots": [ + { + "m_Id": "e0c4d8f51fa947b0befb8685a85d5e09" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_Property": { + "m_Id": "daa99c4f268449b8a4e69fdaeafcfe49" + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Texture2DMaterialSlot", + "m_ObjectId": "67f3c5040dff441a98156cb5eda89ac3", + "m_Id": 0, + "m_DisplayName": "Micro Normal Map", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_BareResource": false +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "687b7b8b4ab2496bb2affcdeeeea0305", + "m_Id": 7, + "m_DisplayName": "A", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "A", + "m_StageCapability": 2, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.AbsoluteNode", + "m_ObjectId": "691692b7141c4a62ad06471b9beb9a30", + "m_Group": { + "m_Id": "" + }, + "m_Name": "Absolute", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -903.0000610351563, + "y": 1272.0, + "width": 128.0, + "height": 94.0 + } + }, + "m_Slots": [ + { + "m_Id": "4b74a689ec434dd59f47dc609c975fe2" + }, + { + "m_Id": "5cd0b7447b494a5986677121c0e50a48" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.PropertyNode", + "m_ObjectId": "69822902c84c428080db9893d32ee267", + "m_Group": { + "m_Id": "" + }, + "m_Name": "Property", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -1022.9999389648438, + "y": 1560.0001220703125, + "width": 123.0, + "height": 34.0 + } + }, + "m_Slots": [ + { + "m_Id": "7002af4c98ac4f479b13782f0e1a1cdb" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_Property": { + "m_Id": "8a49d2f872e946d4a29e2030ee291584" + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector4MaterialSlot", + "m_ObjectId": "69d54d6c4ba64a468f042e25e1f1a0ca", + "m_Id": 0, + "m_DisplayName": "RGBA", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "RGBA", + "m_StageCapability": 2, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.BlockNode", + "m_ObjectId": "6a4b619cae09428e850340b327dc2247", + "m_Group": { + "m_Id": "" + }, + "m_Name": "SurfaceDescription.Smoothness", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": 1180.0, + "y": 593.0000610351563, + "width": 200.0, + "height": 41.0 + } + }, + "m_Slots": [ + { + "m_Id": "0d28e9b96829486b9a93fb4b4493ec53" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_SerializedDescriptor": "SurfaceDescription.Smoothness" +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.BlockNode", + "m_ObjectId": "6b280d605cf34b63ae417129545c2f7d", + "m_Group": { + "m_Id": "" + }, + "m_Name": "SurfaceDescription.Occlusion", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": 1182.0, + "y": 550.0, + "width": 200.0, + "height": 41.0 + } + }, + "m_Slots": [ + { + "m_Id": "b7bc60a4dd2f4474b6ee37d8ae231bc3" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_SerializedDescriptor": "SurfaceDescription.Occlusion" +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Internal.Texture2DShaderProperty", + "m_ObjectId": "6d2408803a794f2e9368d5529b79a574", + "m_Guid": { + "m_GuidSerialized": "6b8dd5b3-e04a-4e6c-b8b8-f3e9ef85e56e" + }, + "m_Name": "Micro Normal Map", + "m_DefaultReferenceName": "Texture2D_6d2408803a794f2e9368d5529b79a574", + "m_OverrideReferenceName": "_MicroNormalMap", + "m_GeneratePropertyBlock": true, + "m_Precision": 0, + "overrideHLSLDeclaration": false, + "hlslDeclarationOverride": 0, + "m_Hidden": false, + "m_Value": { + "m_SerializedTexture": "{\"texture\":{\"instanceID\":0}}", + "m_Guid": "" + }, + "m_Modifiable": true, + "m_DefaultType": 3 +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "6d985a41588a4b82b1e9bc357e24c6f4", + "m_Id": 0, + "m_DisplayName": "A", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "A", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Texture2DMaterialSlot", + "m_ObjectId": "7002af4c98ac4f479b13782f0e1a1cdb", + "m_Id": 0, + "m_DisplayName": "Normal Map", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_BareResource": false +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "7089df8d8eea4ce6bd4682b076eb7ba4", + "m_Id": 1, + "m_DisplayName": "", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.RedirectNodeData", + "m_ObjectId": "7162b2f1f572448786eb9c07065a6d45", + "m_Group": { + "m_Id": "" + }, + "m_Name": "Redirect Node", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -18.99991798400879, + "y": -64.00004577636719, + "width": 56.0, + "height": 23.999998092651368 + } + }, + "m_Slots": [ + { + "m_Id": "03653dd0f9ee454b820eb0296d49215f" + }, + { + "m_Id": "81f87d8534a14af2b21178907556c5cf" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.PropertyNode", + "m_ObjectId": "71d1e8a063514b2680bf1f014cbf9938", + "m_Group": { + "m_Id": "" + }, + "m_Name": "Property", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -3292.0, + "y": 137.00001525878907, + "width": 150.0, + "height": 34.0 + } + }, + "m_Slots": [ + { + "m_Id": "03e2818f83814498bb9178cea7ffb00d" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_Property": { + "m_Id": "2adde9b6c89f49aa838e8cfc38e04353" + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "72c2d86ee74142c7875964e0fffbd7a4", + "m_Id": 1, + "m_DisplayName": "B", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "B", + "m_StageCapability": 3, + "m_Value": { + "x": 1.0, + "y": 1.0, + "z": 1.0, + "w": 1.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.UVMaterialSlot", + "m_ObjectId": "7441ca030e3b43e3a61d7932a08fcf81", + "m_Id": 2, + "m_DisplayName": "UV", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "UV", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0 + }, + "m_Labels": [], + "m_Channel": 0 +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.ColorRGBMaterialSlot", + "m_ObjectId": "745ea487c66c466f84d2c16a08c4b1b6", + "m_Id": 0, + "m_DisplayName": "Base Color", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "BaseColor", + "m_StageCapability": 2, + "m_Value": { + "x": 0.5, + "y": 0.5, + "z": 0.5 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0 + }, + "m_Labels": [], + "m_ColorMode": 0, + "m_DefaultColor": { + "r": 0.5, + "g": 0.5, + "b": 0.5, + "a": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "74b82f61cd1d45fda5ae6fff99ab24a6", + "m_Id": 1, + "m_DisplayName": "Min", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "Min", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 1, + "m_Type": "UnityEditor.ShaderGraph.Internal.Vector1ShaderProperty", + "m_ObjectId": "769181578f94433984a73faf6e153757", + "m_Guid": { + "m_GuidSerialized": "1d430310-7d4b-4543-a3f5-5e6aa15add25" + }, + "m_Name": "Tongue Brightness", + "m_DefaultReferenceName": "", + "m_OverrideReferenceName": "_TongueBrightness", + "m_GeneratePropertyBlock": true, + "m_Precision": 0, + "overrideHLSLDeclaration": false, + "hlslDeclarationOverride": 0, + "m_Hidden": false, + "m_Value": 1.0, + "m_FloatType": 1, + "m_RangeValues": { + "x": 0.0, + "y": 2.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.SamplerStateMaterialSlot", + "m_ObjectId": "780f271d73f64e4297adcfa728a69bad", + "m_Id": 3, + "m_DisplayName": "Sampler", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "Sampler", + "m_StageCapability": 3, + "m_BareResource": false +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Texture2DInputMaterialSlot", + "m_ObjectId": "7c52d0c211b148baa2dee264ed442794", + "m_Id": 1, + "m_DisplayName": "Texture", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "Texture", + "m_StageCapability": 3, + "m_BareResource": false, + "m_Texture": { + "m_SerializedTexture": "{\"texture\":{\"instanceID\":0}}", + "m_Guid": "" + }, + "m_DefaultType": 0 +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "81d92deb1aa34b7e876da6ea11def4ab", + "m_Id": 0, + "m_DisplayName": "In", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "In", + "m_StageCapability": 3, + "m_Value": { + "x": 1.0, + "y": 1.0, + "z": 1.0, + "w": 1.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "81f87d8534a14af2b21178907556c5cf", + "m_Id": 1, + "m_DisplayName": "", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.SampleTexture2DNode", + "m_ObjectId": "847ac5df0b2d4dd58b05ed5100fd2d88", + "m_Group": { + "m_Id": "" + }, + "m_Name": "Sample Texture 2D", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -2133.0, + "y": -835.0, + "width": 208.0, + "height": 436.9999694824219 + } + }, + "m_Slots": [ + { + "m_Id": "df0dc984590847b19bd2f24e1aba8374" + }, + { + "m_Id": "2b081408a7e24e398594d062ea1a971f" + }, + { + "m_Id": "39a1b3de165b4ff6beecaebd677c6e3a" + }, + { + "m_Id": "1d1ca274b5fe42e69ce56945c39a8ea7" + }, + { + "m_Id": "687b7b8b4ab2496bb2affcdeeeea0305" + }, + { + "m_Id": "40411d53b935493097fbc12e892291fa" + }, + { + "m_Id": "7441ca030e3b43e3a61d7932a08fcf81" + }, + { + "m_Id": "780f271d73f64e4297adcfa728a69bad" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_TextureType": 0, + "m_NormalMapSpace": 0 +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "8547d55cd06b487d8d347cc2a2c0bb74", + "m_Id": 2, + "m_DisplayName": "Out", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.SamplerStateMaterialSlot", + "m_ObjectId": "85c5c76f4845488eb95392938396f2b9", + "m_Id": 3, + "m_DisplayName": "Sampler", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "Sampler", + "m_StageCapability": 3, + "m_BareResource": false +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector4MaterialSlot", + "m_ObjectId": "86b897ab597140d59a473d807e980628", + "m_Id": 0, + "m_DisplayName": "RGBA", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "RGBA", + "m_StageCapability": 2, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicValueMaterialSlot", + "m_ObjectId": "88af60f0a40044d0baca24b8ad959a38", + "m_Id": 2, + "m_DisplayName": "Out", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": { + "e00": 0.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 0.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 0.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 0.0 + }, + "m_DefaultValue": { + "e00": 1.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 1.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 1.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.PropertyNode", + "m_ObjectId": "88cc9c5e6d654dc59bdfa9d842b52c6c", + "m_Group": { + "m_Id": "" + }, + "m_Name": "Property", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -2868.0, + "y": 119.00000762939453, + "width": 121.0, + "height": 34.0 + } + }, + "m_Slots": [ + { + "m_Id": "90f46abcf88247529c590ce763cb51bc" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_Property": { + "m_Id": "ddd87d19404f41b8bbbd24232f4338ac" + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.Rendering.HighDefinition.ShaderGraph.BuiltinData", + "m_ObjectId": "88f0b3d71738482fb6273b754134b4dd", + "m_Distortion": false, + "m_DistortionMode": 0, + "m_DistortionDepthTest": true, + "m_AddPrecomputedVelocity": false, + "m_TransparentWritesMotionVec": false, + "m_AlphaToMask": false, + "m_DepthOffset": false, + "m_TransparencyFog": true, + "m_AlphaTestShadow": false, + "m_BackThenFrontRendering": false, + "m_TransparentDepthPrepass": false, + "m_TransparentDepthPostpass": false, + "m_SupportLodCrossFade": false +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector2MaterialSlot", + "m_ObjectId": "89d785e9bb6c413687505ab305a7ebf9", + "m_Id": 3, + "m_DisplayName": "Out", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0 + }, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "89fc6b59daa7410cbc9b145255e398db", + "m_Id": 0, + "m_DisplayName": "A", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "A", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Internal.Texture2DShaderProperty", + "m_ObjectId": "8a49d2f872e946d4a29e2030ee291584", + "m_Guid": { + "m_GuidSerialized": "79f607da-c2f1-46b1-8320-f91a0aef3386" + }, + "m_Name": "Normal Map", + "m_DefaultReferenceName": "Texture2D_8a49d2f872e946d4a29e2030ee291584", + "m_OverrideReferenceName": "_NormalMap", + "m_GeneratePropertyBlock": true, + "m_Precision": 0, + "overrideHLSLDeclaration": false, + "hlslDeclarationOverride": 0, + "m_Hidden": false, + "m_Value": { + "m_SerializedTexture": "{\"texture\":{\"instanceID\":0}}", + "m_Guid": "" + }, + "m_Modifiable": true, + "m_DefaultType": 3 +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.BlockNode", + "m_ObjectId": "8a7ae7a881424567bd38f733cff73869", + "m_Group": { + "m_Id": "" + }, + "m_Name": "SurfaceDescription.BaseColor", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": 0.0, + "y": 0.0, + "width": 0.0, + "height": 0.0 + } + }, + "m_Slots": [ + { + "m_Id": "745ea487c66c466f84d2c16a08c4b1b6" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_SerializedDescriptor": "SurfaceDescription.BaseColor" +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.PropertyNode", + "m_ObjectId": "8b7bdce147474150867a58aa57473f58", + "m_Group": { + "m_Id": "" + }, + "m_Name": "Property", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -2865.0, + "y": 69.0, + "width": 117.0, + "height": 34.0 + } + }, + "m_Slots": [ + { + "m_Id": "e80a7b6cd06742879ed8da06212b1d81" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_Property": { + "m_Id": "fd115c5a3bec4b6eabfabdb2fdf437e6" + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.UVMaterialSlot", + "m_ObjectId": "8c95ccd4e8fd4bf29cc1afa00cc39223", + "m_Id": 2, + "m_DisplayName": "UV", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "UV", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0 + }, + "m_Labels": [], + "m_Channel": 0 +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.BlockNode", + "m_ObjectId": "8d0e91598db04dc39429e4727f60af22", + "m_Group": { + "m_Id": "" + }, + "m_Name": "SurfaceDescription.Thickness", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": 0.0, + "y": 0.0, + "width": 0.0, + "height": 0.0 + } + }, + "m_Slots": [ + { + "m_Id": "e51e934d740f4369a721de0c664eeee0" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_SerializedDescriptor": "SurfaceDescription.Thickness" +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "90f46abcf88247529c590ce763cb51bc", + "m_Id": 0, + "m_DisplayName": "Front AO", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "9153020f03ef49b7bc43bd9bdc109f86", + "m_Id": 0, + "m_DisplayName": "In", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "In", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.PropertyNode", + "m_ObjectId": "9203aadcc7e34fcbb60c753b4a4bd252", + "m_Group": { + "m_Id": "" + }, + "m_Name": "Property", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -1367.0001220703125, + "y": 2021.0, + "width": 156.0, + "height": 34.000003814697269 + } + }, + "m_Slots": [ + { + "m_Id": "67f3c5040dff441a98156cb5eda89ac3" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_Property": { + "m_Id": "6d2408803a794f2e9368d5529b79a574" + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.PropertyNode", + "m_ObjectId": "92460f8b665b4a03bb23e7fe80bdff90", + "m_Group": { + "m_Id": "" + }, + "m_Name": "Property", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -1681.0, + "y": 2138.0, + "width": 179.00001525878907, + "height": 34.0 + } + }, + "m_Slots": [ + { + "m_Id": "5608685f8fa04124b51f5a4ca9cc179b" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_Property": { + "m_Id": "c4024195aefa495695710ffb5997a875" + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector4MaterialSlot", + "m_ObjectId": "9341dc5c4cf94d6b960a964876b3d428", + "m_Id": 0, + "m_DisplayName": "RGBA", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "RGBA", + "m_StageCapability": 2, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_Labels": [] +} + +{ + "m_SGVersion": 1, + "m_Type": "UnityEditor.ShaderGraph.Internal.Vector1ShaderProperty", + "m_ObjectId": "94ca5b7030dd47cf8a414dd9fee0ecde", + "m_Guid": { + "m_GuidSerialized": "0fe985ff-ae47-4bd0-8c8b-4c47581db61f" + }, + "m_Name": "Smoothness Max", + "m_DefaultReferenceName": "Vector1_94ca5b7030dd47cf8a414dd9fee0ecde", + "m_OverrideReferenceName": "_SmoothnessMax", + "m_GeneratePropertyBlock": true, + "m_Precision": 0, + "overrideHLSLDeclaration": false, + "hlslDeclarationOverride": 0, + "m_Hidden": false, + "m_Value": 1.0, + "m_FloatType": 1, + "m_RangeValues": { + "x": 0.0, + "y": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.NormalBlendNode", + "m_ObjectId": "959bbc37ca814b42be52d1bd1b64e66f", + "m_Group": { + "m_Id": "" + }, + "m_Name": "Normal Blend", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -522.0000610351563, + "y": 1825.0, + "width": 145.0, + "height": 154.0 + } + }, + "m_Slots": [ + { + "m_Id": "a004a2846d3d495287310bdf7e8a3185" + }, + { + "m_Id": "09847344f8004a26bdad187ff3b528cd" + }, + { + "m_Id": "410bebff5a4c4691b70fcbc06f01c0af" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_BlendMode": 0 +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.SamplerStateMaterialSlot", + "m_ObjectId": "96f36c732c8e47529d446f73fa12dd82", + "m_Id": 3, + "m_DisplayName": "Sampler", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "Sampler", + "m_StageCapability": 3, + "m_BareResource": false +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector3MaterialSlot", + "m_ObjectId": "9710862b6a1444fba64a2a8d42eb908f", + "m_Id": 2, + "m_DisplayName": "Out", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0 + }, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.NormalStrengthNode", + "m_ObjectId": "9abeb9fdadd74574b4e6738541daa06a", + "m_Group": { + "m_Id": "" + }, + "m_Name": "Normal Strength", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -858.0001831054688, + "y": 2013.0, + "width": 166.0, + "height": 118.0 + } + }, + "m_Slots": [ + { + "m_Id": "fcb5df76291e43d59d9d2c723f6e78ea" + }, + { + "m_Id": "a9f777000a804b03927bcaba4e4f94de" + }, + { + "m_Id": "af803c535eac431a995ab70febb2049e" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "9eb92eca01e24b8f85337980637997fb", + "m_Id": 1, + "m_DisplayName": "B", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "B", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 1.0, + "z": 1.0, + "w": 1.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector3MaterialSlot", + "m_ObjectId": "a004a2846d3d495287310bdf7e8a3185", + "m_Id": 0, + "m_DisplayName": "A", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "A", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 1.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0 + }, + "m_Labels": [] +} + +{ + "m_SGVersion": 1, + "m_Type": "UnityEditor.ShaderGraph.Internal.Vector1ShaderProperty", + "m_ObjectId": "a1eb91167291491694bf1bdf8d2f3e16", + "m_Guid": { + "m_GuidSerialized": "090da4ee-aa3e-42cb-bbd9-cecc3b09a474" + }, + "m_Name": "Smoothness Power", + "m_DefaultReferenceName": "Vector1_a1eb91167291491694bf1bdf8d2f3e16", + "m_OverrideReferenceName": "_SmoothnessPower", + "m_GeneratePropertyBlock": true, + "m_Precision": 0, + "overrideHLSLDeclaration": false, + "hlslDeclarationOverride": 0, + "m_Hidden": false, + "m_Value": 1.0, + "m_FloatType": 1, + "m_RangeValues": { + "x": 0.5, + "y": 2.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "a5fcb9dea25f4e4583ddcbf27785720f", + "m_Id": 1, + "m_DisplayName": "Out", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "a9f777000a804b03927bcaba4e4f94de", + "m_Id": 1, + "m_DisplayName": "Strength", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "Strength", + "m_StageCapability": 3, + "m_Value": 1.0, + "m_DefaultValue": 1.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.LerpNode", + "m_ObjectId": "ac06b0e4495e41ed855cc55978b80d86", + "m_Group": { + "m_Id": "" + }, + "m_Name": "Lerp", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -388.9999694824219, + "y": 1164.0, + "width": 207.99998474121095, + "height": 326.0 + } + }, + "m_Slots": [ + { + "m_Id": "89fc6b59daa7410cbc9b145255e398db" + }, + { + "m_Id": "72c2d86ee74142c7875964e0fffbd7a4" + }, + { + "m_Id": "6321e82512d8494fa6bc1f1890a53823" + }, + { + "m_Id": "e361532d11934944aec2a8d874a0bf13" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "ad46a176c1ac40b78ee3a38ad5846d4d", + "m_Id": 7, + "m_DisplayName": "A", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "A", + "m_StageCapability": 2, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "ada7147b76d2440ab2f288313b8bc05e", + "m_Id": 0, + "m_DisplayName": "Tongue Brightness", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector3MaterialSlot", + "m_ObjectId": "af803c535eac431a995ab70febb2049e", + "m_Id": 2, + "m_DisplayName": "Out", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0 + }, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.Rendering.HighDefinition.ShaderGraph.HDLitData", + "m_ObjectId": "b00f1b66025c4b25a6f709e3c0ab54f4", + "m_RayTracing": false, + "m_MaterialType": 1, + "m_RefractionModel": 0, + "m_SSSTransmission": true, + "m_EnergyConservingSpecular": true, + "m_ClearCoat": false +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "b1d4b45693af46a3a723b2ffb1b8b88a", + "m_Id": 7, + "m_DisplayName": "A", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "A", + "m_StageCapability": 2, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "b384faa820304f82807176601dd16753", + "m_Id": 6, + "m_DisplayName": "B", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "B", + "m_StageCapability": 2, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "b7416f21dc5f4578ad9bfcfdaafde6bf", + "m_Id": 3, + "m_DisplayName": "Out", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "b7bc60a4dd2f4474b6ee37d8ae231bc3", + "m_Id": 0, + "m_DisplayName": "Ambient Occlusion", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "Occlusion", + "m_StageCapability": 2, + "m_Value": 1.0, + "m_DefaultValue": 1.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.UVMaterialSlot", + "m_ObjectId": "b959e24d88ea43f5bf4256f07ae90ec0", + "m_Id": 2, + "m_DisplayName": "UV", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "UV", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0 + }, + "m_Labels": [], + "m_Channel": 0 +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.SamplerStateMaterialSlot", + "m_ObjectId": "ba586a643825415d9395e0095ddd8d8a", + "m_Id": 3, + "m_DisplayName": "Sampler", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "Sampler", + "m_StageCapability": 3, + "m_BareResource": false +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.BlockNode", + "m_ObjectId": "bc0c9bafa3544deaaba658da5d1457a2", + "m_Group": { + "m_Id": "" + }, + "m_Name": "SurfaceDescription.NormalTS", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": 1179.0, + "y": 672.0, + "width": 200.0, + "height": 41.0 + } + }, + "m_Slots": [ + { + "m_Id": "0e03c873ccc040dd8417724de5eaf36d" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_SerializedDescriptor": "SurfaceDescription.NormalTS" +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "bdb35f0f256944dfafd7981d98006c9f", + "m_Id": 1, + "m_DisplayName": "B", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "B", + "m_StageCapability": 3, + "m_Value": { + "x": 0.5, + "y": 2.0, + "z": 2.0, + "w": 2.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "c0233299f62d4bf989edb701cb048b31", + "m_Id": 1, + "m_DisplayName": "Saturation", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "Saturation", + "m_StageCapability": 3, + "m_Value": 1.0, + "m_DefaultValue": 1.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector2MaterialSlot", + "m_ObjectId": "c083ca9475264d81936b2f64c2ae9982", + "m_Id": 2, + "m_DisplayName": "Offset", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "Offset", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0 + }, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.PropertyNode", + "m_ObjectId": "c2ce8f28915943d49e5539ae59b0b3bf", + "m_Group": { + "m_Id": "" + }, + "m_Name": "Property", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -3235.0, + "y": 924.0, + "width": 115.00000762939453, + "height": 34.0 + } + }, + "m_Slots": [ + { + "m_Id": "1a6dccb88a494fbebd6d32ab0323405b" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_Property": { + "m_Id": "3345a7b9279a48b7ba4602df55d812ac" + } +} + +{ + "m_SGVersion": 1, + "m_Type": "UnityEditor.ShaderGraph.Internal.Vector1ShaderProperty", + "m_ObjectId": "c4024195aefa495695710ffb5997a875", + "m_Guid": { + "m_GuidSerialized": "c5f39fcf-3943-48fe-ab5c-46ba6c3eeee2" + }, + "m_Name": "Micro Normal Tiling", + "m_DefaultReferenceName": "Vector1_c4024195aefa495695710ffb5997a875", + "m_OverrideReferenceName": "_MicroNormalTiling", + "m_GeneratePropertyBlock": true, + "m_Precision": 0, + "overrideHLSLDeclaration": false, + "hlslDeclarationOverride": 0, + "m_Hidden": false, + "m_Value": 4.0, + "m_FloatType": 1, + "m_RangeValues": { + "x": 0.0, + "y": 10.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.NormalMaterialSlot", + "m_ObjectId": "c4b6c46dc8b348b8a5ecd4e2aead24c0", + "m_Id": 0, + "m_DisplayName": "Bent Normal", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "BentNormal", + "m_StageCapability": 2, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0 + }, + "m_Labels": [], + "m_Space": 3 +} + +{ + "m_SGVersion": 1, + "m_Type": "UnityEditor.ShaderGraph.Internal.Vector1ShaderProperty", + "m_ObjectId": "c70d342b1a0b4d6bbf1ff3c98fd338ea", + "m_Guid": { + "m_GuidSerialized": "d09cbcc1-0d27-4582-afd2-8528e6e51f97" + }, + "m_Name": "Micro Normal Strength", + "m_DefaultReferenceName": "Vector1_c70d342b1a0b4d6bbf1ff3c98fd338ea", + "m_OverrideReferenceName": "_MicroNormalStrength", + "m_GeneratePropertyBlock": true, + "m_Precision": 0, + "overrideHLSLDeclaration": false, + "hlslDeclarationOverride": 0, + "m_Hidden": false, + "m_Value": 0.5, + "m_FloatType": 1, + "m_RangeValues": { + "x": 0.0, + "y": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.TangentMaterialSlot", + "m_ObjectId": "c996e165d42c4929928bc49c5e17d734", + "m_Id": 0, + "m_DisplayName": "Tangent", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "Tangent", + "m_StageCapability": 1, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0 + }, + "m_Labels": [], + "m_Space": 0 +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "c9c382f96969430ca6a46ac85b576bb2", + "m_Id": 5, + "m_DisplayName": "G", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "G", + "m_StageCapability": 2, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Internal.Texture2DShaderProperty", + "m_ObjectId": "cb42572a46a74a588ef3935f3a667eb7", + "m_Guid": { + "m_GuidSerialized": "36af1c96-8f78-4132-a591-a5b10a01324f" + }, + "m_Name": "Diffuse Map", + "m_DefaultReferenceName": "Texture2D_cb42572a46a74a588ef3935f3a667eb7", + "m_OverrideReferenceName": "_DiffuseMap", + "m_GeneratePropertyBlock": true, + "m_Precision": 0, + "overrideHLSLDeclaration": false, + "hlslDeclarationOverride": 0, + "m_Hidden": false, + "m_Value": { + "m_SerializedTexture": "{\"texture\":{\"instanceID\":0}}", + "m_Guid": "" + }, + "m_Modifiable": true, + "m_DefaultType": 0 +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.PositionMaterialSlot", + "m_ObjectId": "cb901263bb9a42489ac84d9e84023477", + "m_Id": 0, + "m_DisplayName": "Position", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "Position", + "m_StageCapability": 1, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0 + }, + "m_Labels": [], + "m_Space": 0 +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicValueMaterialSlot", + "m_ObjectId": "cdb77f064fef46a6b98e0247d00a7054", + "m_Id": 1, + "m_DisplayName": "B", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "B", + "m_StageCapability": 3, + "m_Value": { + "e00": 2.0, + "e01": 2.0, + "e02": 2.0, + "e03": 2.0, + "e10": 2.0, + "e11": 2.0, + "e12": 2.0, + "e13": 2.0, + "e20": 2.0, + "e21": 2.0, + "e22": 2.0, + "e23": 2.0, + "e30": 2.0, + "e31": 2.0, + "e32": 2.0, + "e33": 2.0 + }, + "m_DefaultValue": { + "e00": 1.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 1.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 1.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.PropertyNode", + "m_ObjectId": "d04a1ba74b404509b3874993b5771fe4", + "m_Group": { + "m_Id": "" + }, + "m_Name": "Property", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -2310.0, + "y": -832.0000610351563, + "width": 122.0, + "height": 34.0 + } + }, + "m_Slots": [ + { + "m_Id": "565c01cd27814834acd27d2472d0033f" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_Property": { + "m_Id": "cb42572a46a74a588ef3935f3a667eb7" + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "d04c9803937e4542b898dda59caa7140", + "m_Id": 0, + "m_DisplayName": "In", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "In", + "m_StageCapability": 3, + "m_Value": { + "x": 1.0, + "y": 1.0, + "z": 1.0, + "w": 1.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "d729776e47ca458d9f698b924845442d", + "m_Id": 0, + "m_DisplayName": "Tongue Subsurface Scatter", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "d86ff386dec24b5e9bc2b39657d6d1af", + "m_Id": 3, + "m_DisplayName": "Out", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.PropertyNode", + "m_ObjectId": "d906043505fc466c9a6cd86bdf86c0a5", + "m_Group": { + "m_Id": "" + }, + "m_Name": "Property", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -702.0, + "y": 1142.9998779296875, + "width": 215.99998474121095, + "height": 33.999996185302737 + } + }, + "m_Slots": [ + { + "m_Id": "6574d6ca0bb24871b8226477233c11fe" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_Property": { + "m_Id": "229e12ce054c4003affcf25346b88151" + } +} + +{ + "m_SGVersion": 1, + "m_Type": "UnityEditor.ShaderGraph.Internal.Vector1ShaderProperty", + "m_ObjectId": "daa99c4f268449b8a4e69fdaeafcfe49", + "m_Guid": { + "m_GuidSerialized": "b78117bf-f0d9-48f7-8c0e-59b04f502b60" + }, + "m_Name": "Ambient Occlusion Strength", + "m_DefaultReferenceName": "Vector1_daa99c4f268449b8a4e69fdaeafcfe49", + "m_OverrideReferenceName": "_AOStrength", + "m_GeneratePropertyBlock": true, + "m_Precision": 0, + "overrideHLSLDeclaration": false, + "hlslDeclarationOverride": 0, + "m_Hidden": false, + "m_Value": 1.0, + "m_FloatType": 1, + "m_RangeValues": { + "x": 0.0, + "y": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "dab7b0ac196344f9a829a1307ef0b532", + "m_Id": 0, + "m_DisplayName": "Smoothness Max", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 1, + "m_Type": "UnityEditor.ShaderGraph.Internal.Vector1ShaderProperty", + "m_ObjectId": "ddd87d19404f41b8bbbd24232f4338ac", + "m_Guid": { + "m_GuidSerialized": "e6da8922-0f01-437d-b398-050d263017d5" + }, + "m_Name": "Front AO", + "m_DefaultReferenceName": "Vector1_ddd87d19404f41b8bbbd24232f4338ac", + "m_OverrideReferenceName": "_FrontAO", + "m_GeneratePropertyBlock": true, + "m_Precision": 0, + "overrideHLSLDeclaration": false, + "hlslDeclarationOverride": 0, + "m_Hidden": false, + "m_Value": 1.0, + "m_FloatType": 1, + "m_RangeValues": { + "x": 0.0, + "y": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.LerpNode", + "m_ObjectId": "de3c1d50eb1848c6944a6a985e67a774", + "m_Group": { + "m_Id": "" + }, + "m_Name": "Lerp", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -383.0000305175781, + "y": 2.0000205039978029, + "width": 208.0, + "height": 326.0 + } + }, + "m_Slots": [ + { + "m_Id": "6d985a41588a4b82b1e9bc357e24c6f4" + }, + { + "m_Id": "dee3aff567734999aacfe7a085d0faff" + }, + { + "m_Id": "032a7bb9e8a4477cad21efd3a69bff0a" + }, + { + "m_Id": "b7416f21dc5f4578ad9bfcfdaafde6bf" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "dee3aff567734999aacfe7a085d0faff", + "m_Id": 1, + "m_DisplayName": "B", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "B", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 1.0, + "z": 1.0, + "w": 1.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector4MaterialSlot", + "m_ObjectId": "df0dc984590847b19bd2f24e1aba8374", + "m_Id": 0, + "m_DisplayName": "RGBA", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "RGBA", + "m_StageCapability": 2, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicValueMaterialSlot", + "m_ObjectId": "e024419d1e8e409793b08e65faff7c2e", + "m_Id": 0, + "m_DisplayName": "A", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "A", + "m_StageCapability": 3, + "m_Value": { + "e00": 0.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 0.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 0.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 0.0 + }, + "m_DefaultValue": { + "e00": 1.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 1.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 1.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "e0939e0be9914105a29d68faf0cba8c8", + "m_Id": 0, + "m_DisplayName": "", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "e0c4d8f51fa947b0befb8685a85d5e09", + "m_Id": 0, + "m_DisplayName": "Ambient Occlusion Strength", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.BlockNode", + "m_ObjectId": "e1e6ea93dab24d4086de0ce0507e9306", + "m_Group": { + "m_Id": "" + }, + "m_Name": "SurfaceDescription.Alpha", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": 0.0, + "y": 0.0, + "width": 0.0, + "height": 0.0 + } + }, + "m_Slots": [ + { + "m_Id": "424b313138944a21bc404c418bcb085e" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_SerializedDescriptor": "SurfaceDescription.Alpha" +} + +{ + "m_SGVersion": 1, + "m_Type": "UnityEditor.ShaderGraph.Internal.Vector1ShaderProperty", + "m_ObjectId": "e25a1c81f1374f178c8f27b6264a5f1b", + "m_Guid": { + "m_GuidSerialized": "1936e4b8-ae9b-4eb2-8ca8-295956f61a96" + }, + "m_Name": "Tongue Subsurface Scatter", + "m_DefaultReferenceName": "Vector1_e25a1c81f1374f178c8f27b6264a5f1b", + "m_OverrideReferenceName": "_TongueSSS", + "m_GeneratePropertyBlock": true, + "m_Precision": 0, + "overrideHLSLDeclaration": false, + "hlslDeclarationOverride": 0, + "m_Hidden": false, + "m_Value": 1.0, + "m_FloatType": 1, + "m_RangeValues": { + "x": 0.0, + "y": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.SaturationNode", + "m_ObjectId": "e28e83ed9ea04d5d9fea68c35524c5c0", + "m_Group": { + "m_Id": "" + }, + "m_Name": "Saturation", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -1815.000244140625, + "y": -774.0000610351563, + "width": 174.0, + "height": 118.00000762939453 + } + }, + "m_Slots": [ + { + "m_Id": "25d3c8e1fdbb4c4fbfd4868867b08f5a" + }, + { + "m_Id": "c0233299f62d4bf989edb701cb048b31" + }, + { + "m_Id": "9710862b6a1444fba64a2a8d42eb908f" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": false, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "e361532d11934944aec2a8d874a0bf13", + "m_Id": 3, + "m_DisplayName": "Out", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "e51e934d740f4369a721de0c664eeee0", + "m_Id": 0, + "m_DisplayName": "Thickness", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "Thickness", + "m_StageCapability": 2, + "m_Value": 1.0, + "m_DefaultValue": 1.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "e5725a1cc09748b68df4a7edb1c07f9c", + "m_Id": 3, + "m_DisplayName": "Out", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.BlockNode", + "m_ObjectId": "e701720035d44304a33f4b64350fc6e3", + "m_Group": { + "m_Id": "" + }, + "m_Name": "SurfaceDescription.Emission", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": 0.0, + "y": 0.0, + "width": 0.0, + "height": 0.0 + } + }, + "m_Slots": [ + { + "m_Id": "4fbf6229bad74e91afb7ff4f2a7f0018" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_SerializedDescriptor": "SurfaceDescription.Emission" +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "e80a7b6cd06742879ed8da06212b1d81", + "m_Id": 0, + "m_DisplayName": "Rear AO", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "e8362fd7f2884d1ab1ac906ae9c28004", + "m_Id": 0, + "m_DisplayName": "Subsurface Mask", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "SubsurfaceMask", + "m_StageCapability": 2, + "m_Value": 1.0, + "m_DefaultValue": 1.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot", + "m_ObjectId": "eb35f412fd8f4581af8767cf900abd35", + "m_Id": 2, + "m_DisplayName": "T", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "T", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0, + "w": 0.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Texture2DInputMaterialSlot", + "m_ObjectId": "eb7f26266d4d47c9a57e818a9e6890dc", + "m_Id": 1, + "m_DisplayName": "Texture", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "Texture", + "m_StageCapability": 3, + "m_BareResource": false, + "m_Texture": { + "m_SerializedTexture": "{\"texture\":{\"instanceID\":0}}", + "m_Guid": "" + }, + "m_DefaultType": 3 +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "ebadab64ba5e4222bde9e2423849c96c", + "m_Id": 7, + "m_DisplayName": "A", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "A", + "m_StageCapability": 2, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicValueMaterialSlot", + "m_ObjectId": "ee25af686468440597f42316525acc5d", + "m_Id": 0, + "m_DisplayName": "A", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "A", + "m_StageCapability": 3, + "m_Value": { + "e00": 0.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 0.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 0.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 0.0 + }, + "m_DefaultValue": { + "e00": 1.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 1.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 1.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.UVMaterialSlot", + "m_ObjectId": "eeb935f5191a4a59a9bc1ec799914d58", + "m_Id": 2, + "m_DisplayName": "UV", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "UV", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0 + }, + "m_Labels": [], + "m_Channel": 0 +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot", + "m_ObjectId": "f5c37d6cf3c045f4919e914024af7a9b", + "m_Id": 0, + "m_DisplayName": "Tongue Saturation", + "m_SlotType": 1, + "m_Hidden": false, + "m_ShaderOutputName": "Out", + "m_StageCapability": 3, + "m_Value": 0.0, + "m_DefaultValue": 0.0, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.MultiplyNode", + "m_ObjectId": "f95e06c7a46249598a90d2cae4ca15c9", + "m_Group": { + "m_Id": "" + }, + "m_Name": "Multiply", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": -1031.0001220703125, + "y": -605.0, + "width": 208.0, + "height": 302.0 + } + }, + "m_Slots": [ + { + "m_Id": "e024419d1e8e409793b08e65faff7c2e" + }, + { + "m_Id": "32d0ac1b6af24b7a9438b0207f520fe3" + }, + { + "m_Id": "88af60f0a40044d0baca24b8ad959a38" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector2MaterialSlot", + "m_ObjectId": "f9b331b1062048d6b94590012e2f4adb", + "m_Id": 1, + "m_DisplayName": "Tiling", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "Tiling", + "m_StageCapability": 3, + "m_Value": { + "x": 1.0, + "y": 1.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0 + }, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.DynamicValueMaterialSlot", + "m_ObjectId": "fa90e5cc1119495385fb038ba542652c", + "m_Id": 0, + "m_DisplayName": "A", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "A", + "m_StageCapability": 3, + "m_Value": { + "e00": 0.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 0.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 0.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 0.0 + }, + "m_DefaultValue": { + "e00": 1.0, + "e01": 0.0, + "e02": 0.0, + "e03": 0.0, + "e10": 0.0, + "e11": 1.0, + "e12": 0.0, + "e13": 0.0, + "e20": 0.0, + "e21": 0.0, + "e22": 1.0, + "e23": 0.0, + "e30": 0.0, + "e31": 0.0, + "e32": 0.0, + "e33": 1.0 + } +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.Vector3MaterialSlot", + "m_ObjectId": "fcb5df76291e43d59d9d2c723f6e78ea", + "m_Id": 0, + "m_DisplayName": "In", + "m_SlotType": 0, + "m_Hidden": false, + "m_ShaderOutputName": "In", + "m_StageCapability": 3, + "m_Value": { + "x": 0.0, + "y": 0.0, + "z": 1.0 + }, + "m_DefaultValue": { + "x": 0.0, + "y": 0.0, + "z": 0.0 + }, + "m_Labels": [] +} + +{ + "m_SGVersion": 0, + "m_Type": "UnityEditor.ShaderGraph.BlockNode", + "m_ObjectId": "fce699c8ebf3428887ef6a715d55d4f9", + "m_Group": { + "m_Id": "" + }, + "m_Name": "SurfaceDescription.DiffusionProfileHash", + "m_DrawState": { + "m_Expanded": true, + "m_Position": { + "serializedVersion": "2", + "x": 0.0, + "y": 0.0, + "width": 0.0, + "height": 0.0 + } + }, + "m_Slots": [ + { + "m_Id": "1d4e4c975a3241d5ab63d4debf2aec6a" + } + ], + "synonyms": [], + "m_Precision": 0, + "m_PreviewExpanded": true, + "m_PreviewMode": 0, + "m_CustomColors": { + "m_SerializableColors": [] + }, + "m_SerializedDescriptor": "SurfaceDescription.DiffusionProfileHash" +} + +{ + "m_SGVersion": 1, + "m_Type": "UnityEditor.ShaderGraph.Internal.Vector1ShaderProperty", + "m_ObjectId": "fd115c5a3bec4b6eabfabdb2fdf437e6", + "m_Guid": { + "m_GuidSerialized": "e20c72c1-5528-4c1f-b415-f650f8626057" + }, + "m_Name": "Rear AO", + "m_DefaultReferenceName": "Vector1_fd115c5a3bec4b6eabfabdb2fdf437e6", + "m_OverrideReferenceName": "_RearAO", + "m_GeneratePropertyBlock": true, + "m_Precision": 0, + "overrideHLSLDeclaration": false, + "hlslDeclarationOverride": 0, + "m_Hidden": false, + "m_Value": 0.0, + "m_FloatType": 1, + "m_RangeValues": { + "x": 0.0, + "y": 1.0 + } +} + diff --git a/HDRP/Shaders/RL_TongueShader_HDRP.shadergraph.meta b/HDRP/Shaders/RL_TongueShader_HDRP.shadergraph.meta new file mode 100644 index 0000000..6ab4481 --- /dev/null +++ b/HDRP/Shaders/RL_TongueShader_HDRP.shadergraph.meta @@ -0,0 +1,10 @@ +fileFormatVersion: 2 +guid: 9cea8e6ce656ff148a2ec8e1550340ce +ScriptedImporter: + internalIDToNameTable: [] + externalObjects: {} + serializedVersion: 2 + userData: + assetBundleName: + assetBundleVariant: + script: {fileID: 11500000, guid: 625f186215c104763be7675aa2d941aa, type: 3} diff --git a/Icons.meta b/Icons.meta new file mode 100644 index 0000000..9eaeff4 --- /dev/null +++ b/Icons.meta @@ -0,0 +1,8 @@ +fileFormatVersion: 2 +guid: 9cc51310337c1904db9ce26c51bea20e +folderAsset: yes +DefaultImporter: + externalObjects: {} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Icons/RLICon_UnprocessedChar.png b/Icons/RLICon_UnprocessedChar.png new file mode 100644 index 0000000..d16bdb4 Binary files /dev/null and b/Icons/RLICon_UnprocessedChar.png differ diff --git a/Icons/RLICon_UnprocessedChar.png.meta b/Icons/RLICon_UnprocessedChar.png.meta new file mode 100644 index 0000000..0589807 --- /dev/null +++ b/Icons/RLICon_UnprocessedChar.png.meta @@ -0,0 +1,108 @@ +fileFormatVersion: 2 +guid: 07240ea5c8d08b0458d2ecaf8c5c9b28 +TextureImporter: + internalIDToNameTable: [] + externalObjects: {} + serializedVersion: 11 + mipmaps: + mipMapMode: 0 + enableMipMap: 1 + sRGBTexture: 1 + linearTexture: 0 + fadeOut: 0 + borderMipMap: 0 + mipMapsPreserveCoverage: 0 + alphaTestReferenceValue: 0.5 + mipMapFadeDistanceStart: 1 + mipMapFadeDistanceEnd: 3 + bumpmap: + convertToNormalMap: 0 + externalNormalMap: 0 + heightScale: 0.25 + normalMapFilter: 0 + isReadable: 0 + streamingMipmaps: 0 + streamingMipmapsPriority: 0 + vTOnly: 0 + grayScaleToAlpha: 0 + generateCubemap: 6 + cubemapConvolution: 0 + seamlessCubemap: 0 + textureFormat: 1 + maxTextureSize: 2048 + textureSettings: + serializedVersion: 2 + filterMode: 1 + aniso: 1 + mipBias: 0 + wrapU: 0 + wrapV: 0 + wrapW: 0 + nPOTScale: 1 + lightmap: 0 + compressionQuality: 50 + spriteMode: 0 + spriteExtrude: 1 + spriteMeshType: 1 + alignment: 0 + spritePivot: {x: 0.5, y: 0.5} + spritePixelsToUnits: 100 + spriteBorder: {x: 0, y: 0, z: 0, w: 0} + spriteGenerateFallbackPhysicsShape: 1 + alphaUsage: 1 + alphaIsTransparency: 1 + spriteTessellationDetail: -1 + textureType: 0 + textureShape: 1 + singleChannelComponent: 0 + flipbookRows: 1 + flipbookColumns: 1 + maxTextureSizeSet: 0 + compressionQualitySet: 0 + textureFormatSet: 0 + ignorePngGamma: 0 + applyGammaDecoding: 0 + platformSettings: + - serializedVersion: 3 + buildTarget: DefaultTexturePlatform + maxTextureSize: 2048 + resizeAlgorithm: 0 + textureFormat: -1 + textureCompression: 1 + compressionQuality: 50 + crunchedCompression: 0 + allowsAlphaSplitting: 0 + overridden: 0 + androidETC2FallbackOverride: 0 + forceMaximumCompressionQuality_BC6H_BC7: 0 + - serializedVersion: 3 + buildTarget: Standalone + maxTextureSize: 2048 + resizeAlgorithm: 0 + textureFormat: -1 + textureCompression: 1 + compressionQuality: 50 + crunchedCompression: 0 + allowsAlphaSplitting: 0 + overridden: 0 + androidETC2FallbackOverride: 0 + forceMaximumCompressionQuality_BC6H_BC7: 0 + spriteSheet: + serializedVersion: 2 + sprites: [] + outline: [] + physicsShape: [] + bones: [] + spriteID: + internalID: 0 + vertices: [] + indices: + edges: [] + weights: [] + secondaryTextures: [] + spritePackingTag: + pSDRemoveMatte: 0 + pSDShowRemoveMatteOption: 0 + userData: + assetBundleName: + assetBundleVariant: diff --git a/Icons/RLIcon_BakedChar.png b/Icons/RLIcon_BakedChar.png new file mode 100644 index 0000000..d987415 Binary files /dev/null and b/Icons/RLIcon_BakedChar.png differ diff --git a/Icons/RLIcon_BakedChar.png.meta b/Icons/RLIcon_BakedChar.png.meta new file mode 100644 index 0000000..1b51bd1 --- /dev/null +++ b/Icons/RLIcon_BakedChar.png.meta @@ -0,0 +1,108 @@ +fileFormatVersion: 2 +guid: 4466fbc5d670a3249802cf246a88801a +TextureImporter: + internalIDToNameTable: [] + externalObjects: {} + serializedVersion: 11 + mipmaps: + mipMapMode: 0 + enableMipMap: 1 + sRGBTexture: 1 + linearTexture: 0 + fadeOut: 0 + borderMipMap: 0 + mipMapsPreserveCoverage: 0 + alphaTestReferenceValue: 0.5 + mipMapFadeDistanceStart: 1 + mipMapFadeDistanceEnd: 3 + bumpmap: + convertToNormalMap: 0 + externalNormalMap: 0 + heightScale: 0.25 + normalMapFilter: 0 + isReadable: 0 + streamingMipmaps: 0 + streamingMipmapsPriority: 0 + vTOnly: 0 + grayScaleToAlpha: 0 + generateCubemap: 6 + cubemapConvolution: 0 + seamlessCubemap: 0 + textureFormat: 1 + maxTextureSize: 2048 + textureSettings: + serializedVersion: 2 + filterMode: 1 + aniso: 1 + mipBias: 0 + wrapU: 0 + wrapV: 0 + wrapW: 0 + nPOTScale: 1 + lightmap: 0 + compressionQuality: 50 + spriteMode: 0 + spriteExtrude: 1 + spriteMeshType: 1 + alignment: 0 + spritePivot: {x: 0.5, y: 0.5} + spritePixelsToUnits: 100 + spriteBorder: {x: 0, y: 0, z: 0, w: 0} + spriteGenerateFallbackPhysicsShape: 1 + alphaUsage: 1 + alphaIsTransparency: 1 + spriteTessellationDetail: -1 + textureType: 0 + textureShape: 1 + singleChannelComponent: 0 + flipbookRows: 1 + flipbookColumns: 1 + maxTextureSizeSet: 0 + compressionQualitySet: 0 + textureFormatSet: 0 + ignorePngGamma: 0 + applyGammaDecoding: 0 + platformSettings: + - serializedVersion: 3 + buildTarget: DefaultTexturePlatform + maxTextureSize: 2048 + resizeAlgorithm: 0 + textureFormat: -1 + textureCompression: 1 + compressionQuality: 50 + crunchedCompression: 0 + allowsAlphaSplitting: 0 + overridden: 0 + androidETC2FallbackOverride: 0 + forceMaximumCompressionQuality_BC6H_BC7: 0 + - serializedVersion: 3 + buildTarget: Standalone + maxTextureSize: 2048 + resizeAlgorithm: 0 + textureFormat: -1 + textureCompression: 1 + compressionQuality: 50 + crunchedCompression: 0 + allowsAlphaSplitting: 0 + overridden: 0 + androidETC2FallbackOverride: 0 + forceMaximumCompressionQuality_BC6H_BC7: 0 + spriteSheet: + serializedVersion: 2 + sprites: [] + outline: [] + physicsShape: [] + bones: [] + spriteID: + internalID: 0 + vertices: [] + indices: + edges: [] + weights: [] + secondaryTextures: [] + spritePackingTag: + pSDRemoveMatte: 0 + pSDShowRemoveMatteOption: 0 + userData: + assetBundleName: + assetBundleVariant: diff --git a/Icons/RLIcon_BasicChar.png b/Icons/RLIcon_BasicChar.png new file mode 100644 index 0000000..c26a2ab Binary files /dev/null and b/Icons/RLIcon_BasicChar.png differ diff --git a/Icons/RLIcon_BasicChar.png.meta b/Icons/RLIcon_BasicChar.png.meta new file mode 100644 index 0000000..e4acc2e --- /dev/null +++ b/Icons/RLIcon_BasicChar.png.meta @@ -0,0 +1,108 @@ +fileFormatVersion: 2 +guid: e22a6eae5159b06429b699fb6dde7c0f +TextureImporter: + internalIDToNameTable: [] + externalObjects: {} + serializedVersion: 11 + mipmaps: + mipMapMode: 0 + enableMipMap: 1 + sRGBTexture: 1 + linearTexture: 0 + fadeOut: 0 + borderMipMap: 0 + mipMapsPreserveCoverage: 0 + alphaTestReferenceValue: 0.5 + mipMapFadeDistanceStart: 1 + mipMapFadeDistanceEnd: 3 + bumpmap: + convertToNormalMap: 0 + externalNormalMap: 0 + heightScale: 0.25 + normalMapFilter: 0 + isReadable: 0 + streamingMipmaps: 0 + streamingMipmapsPriority: 0 + vTOnly: 0 + grayScaleToAlpha: 0 + generateCubemap: 6 + cubemapConvolution: 0 + seamlessCubemap: 0 + textureFormat: 1 + maxTextureSize: 2048 + textureSettings: + serializedVersion: 2 + filterMode: 1 + aniso: 1 + mipBias: 0 + wrapU: 0 + wrapV: 0 + wrapW: 0 + nPOTScale: 1 + lightmap: 0 + compressionQuality: 50 + spriteMode: 0 + spriteExtrude: 1 + spriteMeshType: 1 + alignment: 0 + spritePivot: {x: 0.5, y: 0.5} + spritePixelsToUnits: 100 + spriteBorder: {x: 0, y: 0, z: 0, w: 0} + spriteGenerateFallbackPhysicsShape: 1 + alphaUsage: 1 + alphaIsTransparency: 1 + spriteTessellationDetail: -1 + textureType: 0 + textureShape: 1 + singleChannelComponent: 0 + flipbookRows: 1 + flipbookColumns: 1 + maxTextureSizeSet: 0 + compressionQualitySet: 0 + textureFormatSet: 0 + ignorePngGamma: 0 + applyGammaDecoding: 0 + platformSettings: + - serializedVersion: 3 + buildTarget: DefaultTexturePlatform + maxTextureSize: 2048 + resizeAlgorithm: 0 + textureFormat: -1 + textureCompression: 1 + compressionQuality: 50 + crunchedCompression: 0 + allowsAlphaSplitting: 0 + overridden: 0 + androidETC2FallbackOverride: 0 + forceMaximumCompressionQuality_BC6H_BC7: 0 + - serializedVersion: 3 + buildTarget: Standalone + maxTextureSize: 2048 + resizeAlgorithm: 0 + textureFormat: -1 + textureCompression: 1 + compressionQuality: 50 + crunchedCompression: 0 + allowsAlphaSplitting: 0 + overridden: 0 + androidETC2FallbackOverride: 0 + forceMaximumCompressionQuality_BC6H_BC7: 0 + spriteSheet: + serializedVersion: 2 + sprites: [] + outline: [] + physicsShape: [] + bones: [] + spriteID: + internalID: 0 + vertices: [] + indices: + edges: [] + weights: [] + secondaryTextures: [] + spritePackingTag: + pSDRemoveMatte: 0 + pSDShowRemoveMatteOption: 0 + userData: + assetBundleName: + assetBundleVariant: diff --git a/Icons/RLIcon_HQChar.png b/Icons/RLIcon_HQChar.png new file mode 100644 index 0000000..45ddbd7 Binary files /dev/null and b/Icons/RLIcon_HQChar.png differ diff --git a/Icons/RLIcon_HQChar.png.meta b/Icons/RLIcon_HQChar.png.meta new file mode 100644 index 0000000..1e3b903 --- /dev/null +++ b/Icons/RLIcon_HQChar.png.meta @@ -0,0 +1,108 @@ +fileFormatVersion: 2 +guid: eeed440bc397f0d439d7ab5b1e898a6d +TextureImporter: + internalIDToNameTable: [] + externalObjects: {} + serializedVersion: 11 + mipmaps: + mipMapMode: 0 + enableMipMap: 1 + sRGBTexture: 1 + linearTexture: 0 + fadeOut: 0 + borderMipMap: 0 + mipMapsPreserveCoverage: 0 + alphaTestReferenceValue: 0.5 + mipMapFadeDistanceStart: 1 + mipMapFadeDistanceEnd: 3 + bumpmap: + convertToNormalMap: 0 + externalNormalMap: 0 + heightScale: 0.25 + normalMapFilter: 0 + isReadable: 0 + streamingMipmaps: 0 + streamingMipmapsPriority: 0 + vTOnly: 0 + grayScaleToAlpha: 0 + generateCubemap: 6 + cubemapConvolution: 0 + seamlessCubemap: 0 + textureFormat: 1 + maxTextureSize: 2048 + textureSettings: + serializedVersion: 2 + filterMode: 1 + aniso: 1 + mipBias: 0 + wrapU: 0 + wrapV: 0 + wrapW: 0 + nPOTScale: 1 + lightmap: 0 + compressionQuality: 50 + spriteMode: 0 + spriteExtrude: 1 + spriteMeshType: 1 + alignment: 0 + spritePivot: {x: 0.5, y: 0.5} + spritePixelsToUnits: 100 + spriteBorder: {x: 0, y: 0, z: 0, w: 0} + spriteGenerateFallbackPhysicsShape: 1 + alphaUsage: 1 + alphaIsTransparency: 1 + spriteTessellationDetail: -1 + textureType: 0 + textureShape: 1 + singleChannelComponent: 0 + flipbookRows: 1 + flipbookColumns: 1 + maxTextureSizeSet: 0 + compressionQualitySet: 0 + textureFormatSet: 0 + ignorePngGamma: 0 + applyGammaDecoding: 0 + platformSettings: + - serializedVersion: 3 + buildTarget: DefaultTexturePlatform + maxTextureSize: 2048 + resizeAlgorithm: 0 + textureFormat: -1 + textureCompression: 1 + compressionQuality: 50 + crunchedCompression: 0 + allowsAlphaSplitting: 0 + overridden: 0 + androidETC2FallbackOverride: 0 + forceMaximumCompressionQuality_BC6H_BC7: 0 + - serializedVersion: 3 + buildTarget: Standalone + maxTextureSize: 2048 + resizeAlgorithm: 0 + textureFormat: -1 + textureCompression: 1 + compressionQuality: 50 + crunchedCompression: 0 + allowsAlphaSplitting: 0 + overridden: 0 + androidETC2FallbackOverride: 0 + forceMaximumCompressionQuality_BC6H_BC7: 0 + spriteSheet: + serializedVersion: 2 + sprites: [] + outline: [] + physicsShape: [] + bones: [] + spriteID: + internalID: 0 + vertices: [] + indices: + edges: [] + weights: [] + secondaryTextures: [] + spritePackingTag: + pSDRemoveMatte: 0 + pSDShowRemoveMatteOption: 0 + userData: + assetBundleName: + assetBundleVariant: diff --git a/Icons/RLIcon_MixedChar.png b/Icons/RLIcon_MixedChar.png new file mode 100644 index 0000000..fed5984 Binary files /dev/null and b/Icons/RLIcon_MixedChar.png differ diff --git a/Icons/RLIcon_MixedChar.png.meta b/Icons/RLIcon_MixedChar.png.meta new file mode 100644 index 0000000..772ba56 --- /dev/null +++ b/Icons/RLIcon_MixedChar.png.meta @@ -0,0 +1,108 @@ +fileFormatVersion: 2 +guid: 0238089a669f3364d98d6c56ba4b32ab +TextureImporter: + internalIDToNameTable: [] + externalObjects: {} + serializedVersion: 11 + mipmaps: + mipMapMode: 0 + enableMipMap: 1 + sRGBTexture: 1 + linearTexture: 0 + fadeOut: 0 + borderMipMap: 0 + mipMapsPreserveCoverage: 0 + alphaTestReferenceValue: 0.5 + mipMapFadeDistanceStart: 1 + mipMapFadeDistanceEnd: 3 + bumpmap: + convertToNormalMap: 0 + externalNormalMap: 0 + heightScale: 0.25 + normalMapFilter: 0 + isReadable: 0 + streamingMipmaps: 0 + streamingMipmapsPriority: 0 + vTOnly: 0 + grayScaleToAlpha: 0 + generateCubemap: 6 + cubemapConvolution: 0 + seamlessCubemap: 0 + textureFormat: 1 + maxTextureSize: 2048 + textureSettings: + serializedVersion: 2 + filterMode: 1 + aniso: 1 + mipBias: 0 + wrapU: 0 + wrapV: 0 + wrapW: 0 + nPOTScale: 1 + lightmap: 0 + compressionQuality: 50 + spriteMode: 0 + spriteExtrude: 1 + spriteMeshType: 1 + alignment: 0 + spritePivot: {x: 0.5, y: 0.5} + spritePixelsToUnits: 100 + spriteBorder: {x: 0, y: 0, z: 0, w: 0} + spriteGenerateFallbackPhysicsShape: 1 + alphaUsage: 1 + alphaIsTransparency: 1 + spriteTessellationDetail: -1 + textureType: 0 + textureShape: 1 + singleChannelComponent: 0 + flipbookRows: 1 + flipbookColumns: 1 + maxTextureSizeSet: 0 + compressionQualitySet: 0 + textureFormatSet: 0 + ignorePngGamma: 0 + applyGammaDecoding: 0 + platformSettings: + - serializedVersion: 3 + buildTarget: DefaultTexturePlatform + maxTextureSize: 2048 + resizeAlgorithm: 0 + textureFormat: -1 + textureCompression: 1 + compressionQuality: 50 + crunchedCompression: 0 + allowsAlphaSplitting: 0 + overridden: 0 + androidETC2FallbackOverride: 0 + forceMaximumCompressionQuality_BC6H_BC7: 0 + - serializedVersion: 3 + buildTarget: Standalone + maxTextureSize: 2048 + resizeAlgorithm: 0 + textureFormat: -1 + textureCompression: 1 + compressionQuality: 50 + crunchedCompression: 0 + allowsAlphaSplitting: 0 + overridden: 0 + androidETC2FallbackOverride: 0 + forceMaximumCompressionQuality_BC6H_BC7: 0 + spriteSheet: + serializedVersion: 2 + sprites: [] + outline: [] + physicsShape: [] + bones: [] + spriteID: + internalID: 0 + vertices: [] + indices: + edges: [] + weights: [] + secondaryTextures: [] + spritePackingTag: + pSDRemoveMatte: 0 + pSDShowRemoveMatteOption: 0 + userData: + assetBundleName: + assetBundleVariant: diff --git a/LICENSE b/LICENSE new file mode 100644 index 0000000..e62ec04 --- /dev/null +++ b/LICENSE @@ -0,0 +1,674 @@ +GNU GENERAL PUBLIC LICENSE + Version 3, 29 June 2007 + + Copyright (C) 2007 Free Software Foundation, Inc. + Everyone is permitted to copy and distribute verbatim copies + of this license document, but changing it is not allowed. + + Preamble + + The GNU General Public License is a free, copyleft license for +software and other kinds of works. + + The licenses for most software and other practical works are designed +to take away your freedom to share and change the works. By contrast, +the GNU General Public License is intended to guarantee your freedom to +share and change all versions of a program--to make sure it remains free +software for all its users. We, the Free Software Foundation, use the +GNU General Public License for most of our software; it applies also to +any other work released this way by its authors. You can apply it to +your programs, too. + + When we speak of free software, we are referring to freedom, not +price. Our General Public Licenses are designed to make sure that you +have the freedom to distribute copies of free software (and charge for +them if you wish), that you receive source code or can get it if you +want it, that you can change the software or use pieces of it in new +free programs, and that you know you can do these things. + + To protect your rights, we need to prevent others from denying you +these rights or asking you to surrender the rights. Therefore, you have +certain responsibilities if you distribute copies of the software, or if +you modify it: responsibilities to respect the freedom of others. + + For example, if you distribute copies of such a program, whether +gratis or for a fee, you must pass on to the recipients the same +freedoms that you received. You must make sure that they, too, receive +or can get the source code. And you must show them these terms so they +know their rights. + + Developers that use the GNU GPL protect your rights with two steps: +(1) assert copyright on the software, and (2) offer you this License +giving you legal permission to copy, distribute and/or modify it. + + For the developers' and authors' protection, the GPL clearly explains +that there is no warranty for this free software. For both users' and +authors' sake, the GPL requires that modified versions be marked as +changed, so that their problems will not be attributed erroneously to +authors of previous versions. + + Some devices are designed to deny users access to install or run +modified versions of the software inside them, although the manufacturer +can do so. This is fundamentally incompatible with the aim of +protecting users' freedom to change the software. The systematic +pattern of such abuse occurs in the area of products for individuals to +use, which is precisely where it is most unacceptable. Therefore, we +have designed this version of the GPL to prohibit the practice for those +products. If such problems arise substantially in other domains, we +stand ready to extend this provision to those domains in future versions +of the GPL, as needed to protect the freedom of users. + + Finally, every program is threatened constantly by software patents. +States should not allow patents to restrict development and use of +software on general-purpose computers, but in those that do, we wish to +avoid the special danger that patents applied to a free program could +make it effectively proprietary. To prevent this, the GPL assures that +patents cannot be used to render the program non-free. + + The precise terms and conditions for copying, distribution and +modification follow. + + TERMS AND CONDITIONS + + 0. Definitions. + + "This License" refers to version 3 of the GNU General Public License. + + "Copyright" also means copyright-like laws that apply to other kinds of +works, such as semiconductor masks. + + "The Program" refers to any copyrightable work licensed under this +License. Each licensee is addressed as "you". "Licensees" and +"recipients" may be individuals or organizations. + + To "modify" a work means to copy from or adapt all or part of the work +in a fashion requiring copyright permission, other than the making of an +exact copy. The resulting work is called a "modified version" of the +earlier work or a work "based on" the earlier work. + + A "covered work" means either the unmodified Program or a work based +on the Program. + + To "propagate" a work means to do anything with it that, without +permission, would make you directly or secondarily liable for +infringement under applicable copyright law, except executing it on a +computer or modifying a private copy. Propagation includes copying, +distribution (with or without modification), making available to the +public, and in some countries other activities as well. + + To "convey" a work means any kind of propagation that enables other +parties to make or receive copies. Mere interaction with a user through +a computer network, with no transfer of a copy, is not conveying. + + An interactive user interface displays "Appropriate Legal Notices" +to the extent that it includes a convenient and prominently visible +feature that (1) displays an appropriate copyright notice, and (2) +tells the user that there is no warranty for the work (except to the +extent that warranties are provided), that licensees may convey the +work under this License, and how to view a copy of this License. If +the interface presents a list of user commands or options, such as a +menu, a prominent item in the list meets this criterion. + + 1. Source Code. + + The "source code" for a work means the preferred form of the work +for making modifications to it. "Object code" means any non-source +form of a work. + + A "Standard Interface" means an interface that either is an official +standard defined by a recognized standards body, or, in the case of +interfaces specified for a particular programming language, one that +is widely used among developers working in that language. + + The "System Libraries" of an executable work include anything, other +than the work as a whole, that (a) is included in the normal form of +packaging a Major Component, but which is not part of that Major +Component, and (b) serves only to enable use of the work with that +Major Component, or to implement a Standard Interface for which an +implementation is available to the public in source code form. A +"Major Component", in this context, means a major essential component +(kernel, window system, and so on) of the specific operating system +(if any) on which the executable work runs, or a compiler used to +produce the work, or an object code interpreter used to run it. + + The "Corresponding Source" for a work in object code form means all +the source code needed to generate, install, and (for an executable +work) run the object code and to modify the work, including scripts to +control those activities. However, it does not include the work's +System Libraries, or general-purpose tools or generally available free +programs which are used unmodified in performing those activities but +which are not part of the work. For example, Corresponding Source +includes interface definition files associated with source files for +the work, and the source code for shared libraries and dynamically +linked subprograms that the work is specifically designed to require, +such as by intimate data communication or control flow between those +subprograms and other parts of the work. + + The Corresponding Source need not include anything that users +can regenerate automatically from other parts of the Corresponding +Source. + + The Corresponding Source for a work in source code form is that +same work. + + 2. Basic Permissions. + + All rights granted under this License are granted for the term of +copyright on the Program, and are irrevocable provided the stated +conditions are met. This License explicitly affirms your unlimited +permission to run the unmodified Program. The output from running a +covered work is covered by this License only if the output, given its +content, constitutes a covered work. This License acknowledges your +rights of fair use or other equivalent, as provided by copyright law. + + You may make, run and propagate covered works that you do not +convey, without conditions so long as your license otherwise remains +in force. You may convey covered works to others for the sole purpose +of having them make modifications exclusively for you, or provide you +with facilities for running those works, provided that you comply with +the terms of this License in conveying all material for which you do +not control copyright. Those thus making or running the covered works +for you must do so exclusively on your behalf, under your direction +and control, on terms that prohibit them from making any copies of +your copyrighted material outside their relationship with you. + + Conveying under any other circumstances is permitted solely under +the conditions stated below. Sublicensing is not allowed; section 10 +makes it unnecessary. + + 3. Protecting Users' Legal Rights From Anti-Circumvention Law. + + No covered work shall be deemed part of an effective technological +measure under any applicable law fulfilling obligations under article +11 of the WIPO copyright treaty adopted on 20 December 1996, or +similar laws prohibiting or restricting circumvention of such +measures. + + When you convey a covered work, you waive any legal power to forbid +circumvention of technological measures to the extent such circumvention +is effected by exercising rights under this License with respect to +the covered work, and you disclaim any intention to limit operation or +modification of the work as a means of enforcing, against the work's +users, your or third parties' legal rights to forbid circumvention of +technological measures. + + 4. Conveying Verbatim Copies. + + You may convey verbatim copies of the Program's source code as you +receive it, in any medium, provided that you conspicuously and +appropriately publish on each copy an appropriate copyright notice; +keep intact all notices stating that this License and any +non-permissive terms added in accord with section 7 apply to the code; +keep intact all notices of the absence of any warranty; and give all +recipients a copy of this License along with the Program. + + You may charge any price or no price for each copy that you convey, +and you may offer support or warranty protection for a fee. + + 5. Conveying Modified Source Versions. + + You may convey a work based on the Program, or the modifications to +produce it from the Program, in the form of source code under the +terms of section 4, provided that you also meet all of these conditions: + + a) The work must carry prominent notices stating that you modified + it, and giving a relevant date. + + b) The work must carry prominent notices stating that it is + released under this License and any conditions added under section + 7. This requirement modifies the requirement in section 4 to + "keep intact all notices". + + c) You must license the entire work, as a whole, under this + License to anyone who comes into possession of a copy. This + License will therefore apply, along with any applicable section 7 + additional terms, to the whole of the work, and all its parts, + regardless of how they are packaged. This License gives no + permission to license the work in any other way, but it does not + invalidate such permission if you have separately received it. + + d) If the work has interactive user interfaces, each must display + Appropriate Legal Notices; however, if the Program has interactive + interfaces that do not display Appropriate Legal Notices, your + work need not make them do so. + + A compilation of a covered work with other separate and independent +works, which are not by their nature extensions of the covered work, +and which are not combined with it such as to form a larger program, +in or on a volume of a storage or distribution medium, is called an +"aggregate" if the compilation and its resulting copyright are not +used to limit the access or legal rights of the compilation's users +beyond what the individual works permit. Inclusion of a covered work +in an aggregate does not cause this License to apply to the other +parts of the aggregate. + + 6. Conveying Non-Source Forms. + + You may convey a covered work in object code form under the terms +of sections 4 and 5, provided that you also convey the +machine-readable Corresponding Source under the terms of this License, +in one of these ways: + + a) Convey the object code in, or embodied in, a physical product + (including a physical distribution medium), accompanied by the + Corresponding Source fixed on a durable physical medium + customarily used for software interchange. + + b) Convey the object code in, or embodied in, a physical product + (including a physical distribution medium), accompanied by a + written offer, valid for at least three years and valid for as + long as you offer spare parts or customer support for that product + model, to give anyone who possesses the object code either (1) a + copy of the Corresponding Source for all the software in the + product that is covered by this License, on a durable physical + medium customarily used for software interchange, for a price no + more than your reasonable cost of physically performing this + conveying of source, or (2) access to copy the + Corresponding Source from a network server at no charge. + + c) Convey individual copies of the object code with a copy of the + written offer to provide the Corresponding Source. This + alternative is allowed only occasionally and noncommercially, and + only if you received the object code with such an offer, in accord + with subsection 6b. + + d) Convey the object code by offering access from a designated + place (gratis or for a charge), and offer equivalent access to the + Corresponding Source in the same way through the same place at no + further charge. You need not require recipients to copy the + Corresponding Source along with the object code. If the place to + copy the object code is a network server, the Corresponding Source + may be on a different server (operated by you or a third party) + that supports equivalent copying facilities, provided you maintain + clear directions next to the object code saying where to find the + Corresponding Source. Regardless of what server hosts the + Corresponding Source, you remain obligated to ensure that it is + available for as long as needed to satisfy these requirements. + + e) Convey the object code using peer-to-peer transmission, provided + you inform other peers where the object code and Corresponding + Source of the work are being offered to the general public at no + charge under subsection 6d. + + A separable portion of the object code, whose source code is excluded +from the Corresponding Source as a System Library, need not be +included in conveying the object code work. + + A "User Product" is either (1) a "consumer product", which means any +tangible personal property which is normally used for personal, family, +or household purposes, or (2) anything designed or sold for incorporation +into a dwelling. In determining whether a product is a consumer product, +doubtful cases shall be resolved in favor of coverage. For a particular +product received by a particular user, "normally used" refers to a +typical or common use of that class of product, regardless of the status +of the particular user or of the way in which the particular user +actually uses, or expects or is expected to use, the product. A product +is a consumer product regardless of whether the product has substantial +commercial, industrial or non-consumer uses, unless such uses represent +the only significant mode of use of the product. + + "Installation Information" for a User Product means any methods, +procedures, authorization keys, or other information required to install +and execute modified versions of a covered work in that User Product from +a modified version of its Corresponding Source. The information must +suffice to ensure that the continued functioning of the modified object +code is in no case prevented or interfered with solely because +modification has been made. + + If you convey an object code work under this section in, or with, or +specifically for use in, a User Product, and the conveying occurs as +part of a transaction in which the right of possession and use of the +User Product is transferred to the recipient in perpetuity or for a +fixed term (regardless of how the transaction is characterized), the +Corresponding Source conveyed under this section must be accompanied +by the Installation Information. But this requirement does not apply +if neither you nor any third party retains the ability to install +modified object code on the User Product (for example, the work has +been installed in ROM). + + The requirement to provide Installation Information does not include a +requirement to continue to provide support service, warranty, or updates +for a work that has been modified or installed by the recipient, or for +the User Product in which it has been modified or installed. Access to a +network may be denied when the modification itself materially and +adversely affects the operation of the network or violates the rules and +protocols for communication across the network. + + Corresponding Source conveyed, and Installation Information provided, +in accord with this section must be in a format that is publicly +documented (and with an implementation available to the public in +source code form), and must require no special password or key for +unpacking, reading or copying. + + 7. Additional Terms. + + "Additional permissions" are terms that supplement the terms of this +License by making exceptions from one or more of its conditions. +Additional permissions that are applicable to the entire Program shall +be treated as though they were included in this License, to the extent +that they are valid under applicable law. If additional permissions +apply only to part of the Program, that part may be used separately +under those permissions, but the entire Program remains governed by +this License without regard to the additional permissions. + + When you convey a copy of a covered work, you may at your option +remove any additional permissions from that copy, or from any part of +it. (Additional permissions may be written to require their own +removal in certain cases when you modify the work.) You may place +additional permissions on material, added by you to a covered work, +for which you have or can give appropriate copyright permission. + + Notwithstanding any other provision of this License, for material you +add to a covered work, you may (if authorized by the copyright holders of +that material) supplement the terms of this License with terms: + + a) Disclaiming warranty or limiting liability differently from the + terms of sections 15 and 16 of this License; or + + b) Requiring preservation of specified reasonable legal notices or + author attributions in that material or in the Appropriate Legal + Notices displayed by works containing it; or + + c) Prohibiting misrepresentation of the origin of that material, or + requiring that modified versions of such material be marked in + reasonable ways as different from the original version; or + + d) Limiting the use for publicity purposes of names of licensors or + authors of the material; or + + e) Declining to grant rights under trademark law for use of some + trade names, trademarks, or service marks; or + + f) Requiring indemnification of licensors and authors of that + material by anyone who conveys the material (or modified versions of + it) with contractual assumptions of liability to the recipient, for + any liability that these contractual assumptions directly impose on + those licensors and authors. + + All other non-permissive additional terms are considered "further +restrictions" within the meaning of section 10. If the Program as you +received it, or any part of it, contains a notice stating that it is +governed by this License along with a term that is a further +restriction, you may remove that term. If a license document contains +a further restriction but permits relicensing or conveying under this +License, you may add to a covered work material governed by the terms +of that license document, provided that the further restriction does +not survive such relicensing or conveying. + + If you add terms to a covered work in accord with this section, you +must place, in the relevant source files, a statement of the +additional terms that apply to those files, or a notice indicating +where to find the applicable terms. + + Additional terms, permissive or non-permissive, may be stated in the +form of a separately written license, or stated as exceptions; +the above requirements apply either way. + + 8. Termination. + + You may not propagate or modify a covered work except as expressly +provided under this License. Any attempt otherwise to propagate or +modify it is void, and will automatically terminate your rights under +this License (including any patent licenses granted under the third +paragraph of section 11). + + However, if you cease all violation of this License, then your +license from a particular copyright holder is reinstated (a) +provisionally, unless and until the copyright holder explicitly and +finally terminates your license, and (b) permanently, if the copyright +holder fails to notify you of the violation by some reasonable means +prior to 60 days after the cessation. + + Moreover, your license from a particular copyright holder is +reinstated permanently if the copyright holder notifies you of the +violation by some reasonable means, this is the first time you have +received notice of violation of this License (for any work) from that +copyright holder, and you cure the violation prior to 30 days after +your receipt of the notice. + + Termination of your rights under this section does not terminate the +licenses of parties who have received copies or rights from you under +this License. If your rights have been terminated and not permanently +reinstated, you do not qualify to receive new licenses for the same +material under section 10. + + 9. Acceptance Not Required for Having Copies. + + You are not required to accept this License in order to receive or +run a copy of the Program. Ancillary propagation of a covered work +occurring solely as a consequence of using peer-to-peer transmission +to receive a copy likewise does not require acceptance. However, +nothing other than this License grants you permission to propagate or +modify any covered work. These actions infringe copyright if you do +not accept this License. Therefore, by modifying or propagating a +covered work, you indicate your acceptance of this License to do so. + + 10. Automatic Licensing of Downstream Recipients. + + Each time you convey a covered work, the recipient automatically +receives a license from the original licensors, to run, modify and +propagate that work, subject to this License. You are not responsible +for enforcing compliance by third parties with this License. + + An "entity transaction" is a transaction transferring control of an +organization, or substantially all assets of one, or subdividing an +organization, or merging organizations. If propagation of a covered +work results from an entity transaction, each party to that +transaction who receives a copy of the work also receives whatever +licenses to the work the party's predecessor in interest had or could +give under the previous paragraph, plus a right to possession of the +Corresponding Source of the work from the predecessor in interest, if +the predecessor has it or can get it with reasonable efforts. + + You may not impose any further restrictions on the exercise of the +rights granted or affirmed under this License. For example, you may +not impose a license fee, royalty, or other charge for exercise of +rights granted under this License, and you may not initiate litigation +(including a cross-claim or counterclaim in a lawsuit) alleging that +any patent claim is infringed by making, using, selling, offering for +sale, or importing the Program or any portion of it. + + 11. Patents. + + A "contributor" is a copyright holder who authorizes use under this +License of the Program or a work on which the Program is based. The +work thus licensed is called the contributor's "contributor version". + + A contributor's "essential patent claims" are all patent claims +owned or controlled by the contributor, whether already acquired or +hereafter acquired, that would be infringed by some manner, permitted +by this License, of making, using, or selling its contributor version, +but do not include claims that would be infringed only as a +consequence of further modification of the contributor version. For +purposes of this definition, "control" includes the right to grant +patent sublicenses in a manner consistent with the requirements of +this License. + + Each contributor grants you a non-exclusive, worldwide, royalty-free +patent license under the contributor's essential patent claims, to +make, use, sell, offer for sale, import and otherwise run, modify and +propagate the contents of its contributor version. + + In the following three paragraphs, a "patent license" is any express +agreement or commitment, however denominated, not to enforce a patent +(such as an express permission to practice a patent or covenant not to +sue for patent infringement). To "grant" such a patent license to a +party means to make such an agreement or commitment not to enforce a +patent against the party. + + If you convey a covered work, knowingly relying on a patent license, +and the Corresponding Source of the work is not available for anyone +to copy, free of charge and under the terms of this License, through a +publicly available network server or other readily accessible means, +then you must either (1) cause the Corresponding Source to be so +available, or (2) arrange to deprive yourself of the benefit of the +patent license for this particular work, or (3) arrange, in a manner +consistent with the requirements of this License, to extend the patent +license to downstream recipients. "Knowingly relying" means you have +actual knowledge that, but for the patent license, your conveying the +covered work in a country, or your recipient's use of the covered work +in a country, would infringe one or more identifiable patents in that +country that you have reason to believe are valid. + + If, pursuant to or in connection with a single transaction or +arrangement, you convey, or propagate by procuring conveyance of, a +covered work, and grant a patent license to some of the parties +receiving the covered work authorizing them to use, propagate, modify +or convey a specific copy of the covered work, then the patent license +you grant is automatically extended to all recipients of the covered +work and works based on it. + + A patent license is "discriminatory" if it does not include within +the scope of its coverage, prohibits the exercise of, or is +conditioned on the non-exercise of one or more of the rights that are +specifically granted under this License. You may not convey a covered +work if you are a party to an arrangement with a third party that is +in the business of distributing software, under which you make payment +to the third party based on the extent of your activity of conveying +the work, and under which the third party grants, to any of the +parties who would receive the covered work from you, a discriminatory +patent license (a) in connection with copies of the covered work +conveyed by you (or copies made from those copies), or (b) primarily +for and in connection with specific products or compilations that +contain the covered work, unless you entered into that arrangement, +or that patent license was granted, prior to 28 March 2007. + + Nothing in this License shall be construed as excluding or limiting +any implied license or other defenses to infringement that may +otherwise be available to you under applicable patent law. + + 12. No Surrender of Others' Freedom. + + If conditions are imposed on you (whether by court order, agreement or +otherwise) that contradict the conditions of this License, they do not +excuse you from the conditions of this License. If you cannot convey a +covered work so as to satisfy simultaneously your obligations under this +License and any other pertinent obligations, then as a consequence you may +not convey it at all. For example, if you agree to terms that obligate you +to collect a royalty for further conveying from those to whom you convey +the Program, the only way you could satisfy both those terms and this +License would be to refrain entirely from conveying the Program. + + 13. Use with the GNU Affero General Public License. + + Notwithstanding any other provision of this License, you have +permission to link or combine any covered work with a work licensed +under version 3 of the GNU Affero General Public License into a single +combined work, and to convey the resulting work. The terms of this +License will continue to apply to the part which is the covered work, +but the special requirements of the GNU Affero General Public License, +section 13, concerning interaction through a network will apply to the +combination as such. + + 14. Revised Versions of this License. + + The Free Software Foundation may publish revised and/or new versions of +the GNU General Public License from time to time. Such new versions will +be similar in spirit to the present version, but may differ in detail to +address new problems or concerns. + + Each version is given a distinguishing version number. If the +Program specifies that a certain numbered version of the GNU General +Public License "or any later version" applies to it, you have the +option of following the terms and conditions either of that numbered +version or of any later version published by the Free Software +Foundation. If the Program does not specify a version number of the +GNU General Public License, you may choose any version ever published +by the Free Software Foundation. + + If the Program specifies that a proxy can decide which future +versions of the GNU General Public License can be used, that proxy's +public statement of acceptance of a version permanently authorizes you +to choose that version for the Program. + + Later license versions may give you additional or different +permissions. However, no additional obligations are imposed on any +author or copyright holder as a result of your choosing to follow a +later version. + + 15. Disclaimer of Warranty. + + THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY +APPLICABLE LAW. EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT +HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY +OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, +THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR +PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM +IS WITH YOU. SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF +ALL NECESSARY SERVICING, REPAIR OR CORRECTION. + + 16. Limitation of Liability. + + IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING +WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS +THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY +GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE +USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF +DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD +PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS), +EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF +SUCH DAMAGES. + + 17. Interpretation of Sections 15 and 16. + + If the disclaimer of warranty and limitation of liability provided +above cannot be given local legal effect according to their terms, +reviewing courts shall apply local law that most closely approximates +an absolute waiver of all civil liability in connection with the +Program, unless a warranty or assumption of liability accompanies a +copy of the Program in return for a fee. + + END OF TERMS AND CONDITIONS + + How to Apply These Terms to Your New Programs + + If you develop a new program, and you want it to be of the greatest +possible use to the public, the best way to achieve this is to make it +free software which everyone can redistribute and change under these terms. + + To do so, attach the following notices to the program. It is safest +to attach them to the start of each source file to most effectively +state the exclusion of warranty; and each file should have at least +the "copyright" line and a pointer to where the full notice is found. + + + Copyright (C) + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see . + +Also add information on how to contact you by electronic and paper mail. + + If the program does terminal interaction, make it output a short +notice like this when it starts in an interactive mode: + + Copyright (C) + This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'. + This is free software, and you are welcome to redistribute it + under certain conditions; type `show c' for details. + +The hypothetical commands `show w' and `show c' should show the appropriate +parts of the General Public License. Of course, your program's commands +might be different; for a GUI interface, you would use an "about box". + + You should also get your employer (if you work as a programmer) or school, +if any, to sign a "copyright disclaimer" for the program, if necessary. +For more information on this, and how to apply and follow the GNU GPL, see +. + + The GNU General Public License does not permit incorporating your program +into proprietary programs. If your program is a subroutine library, you +may consider it more useful to permit linking proprietary applications with +the library. If this is what you want to do, use the GNU Lesser General +Public License instead of this License. But first, please read +. diff --git a/LICENSE.meta b/LICENSE.meta new file mode 100644 index 0000000..e350868 --- /dev/null +++ b/LICENSE.meta @@ -0,0 +1,7 @@ +fileFormatVersion: 2 +guid: 35e0284351c5ba74f8c4083c3e93c689 +DefaultImporter: + externalObjects: {} + userData: + assetBundleName: + assetBundleVariant: diff --git a/README.md b/README.md new file mode 100644 index 0000000..d248fed --- /dev/null +++ b/README.md @@ -0,0 +1,36 @@ +# proto_cc3_tools + +Read Me +======= + +Welcome to the [Unity](https://www.unity.com/) import and auto setup tool for **Character Creator 3** and **iClone 7** from [Reallusion](https://www.reallusion.com/). + +This is a fully featured tool to take exports from CC3/iClone and set them up in Unity with complete visual fidelity. + +The tool can produce characters of the highest visual quality using custom Shadergraph shaders. +Additionally, more performance focussed characters can be produced using simpler shaders with a minimal loss of visual quality. + +How it works +============ + +Character exports from CC3 and iClone can be dragged into Unity, the import tool can then be opened and the character processed with a single click. + +For full details of the workflow, see the [documentation](https://www.github.com/soupday). + + +Obtaining the Tool +================== + +The tool can be installed using Unity's internal package manager from either the Stable branch of this [git repository](https://www.github.com/soupday) or via download of the .zip of the [latest release](https://github.com/soupday/cc3_unity_tools_hdrp/releases/latest/download/cc3_unity_tools_hdrp.zip). + +This process is discussed in detail in the [documentation](https://www.github.com/soupday). + +**Removal** + +Unity's internal packagage manager allows the simple and safe removal of the tool. + + +**Updating** + +Simply remove the existing tool as above and install the lastest version. + diff --git a/README.md.meta b/README.md.meta new file mode 100644 index 0000000..09741db --- /dev/null +++ b/README.md.meta @@ -0,0 +1,7 @@ +fileFormatVersion: 2 +guid: 0854f1b24db1594409f683e56a8b9102 +TextScriptImporter: + externalObjects: {} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Scenes.meta b/Scenes.meta new file mode 100644 index 0000000..99e76c5 --- /dev/null +++ b/Scenes.meta @@ -0,0 +1,8 @@ +fileFormatVersion: 2 +guid: 217bf5dab25bcf2488d5f7f24adc79d5 +folderAsset: yes +DefaultImporter: + externalObjects: {} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Scenes/PreviewScene.meta b/Scenes/PreviewScene.meta new file mode 100644 index 0000000..64f48fd --- /dev/null +++ b/Scenes/PreviewScene.meta @@ -0,0 +1,8 @@ +fileFormatVersion: 2 +guid: d53465a993fbb9e42a3a5a9ed32e54c3 +folderAsset: yes +DefaultImporter: + externalObjects: {} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Scenes/PreviewScene.unity b/Scenes/PreviewScene.unity new file mode 100644 index 0000000..6c72bde --- /dev/null +++ b/Scenes/PreviewScene.unity @@ -0,0 +1,817 @@ +%YAML 1.1 +%TAG !u! tag:unity3d.com,2011: +--- !u!29 &1 +OcclusionCullingSettings: + m_ObjectHideFlags: 0 + serializedVersion: 2 + m_OcclusionBakeSettings: + smallestOccluder: 5 + smallestHole: 0.25 + backfaceThreshold: 100 + m_SceneGUID: 00000000000000000000000000000000 + m_OcclusionCullingData: {fileID: 0} +--- !u!104 &2 +RenderSettings: + m_ObjectHideFlags: 0 + serializedVersion: 9 + m_Fog: 0 + m_FogColor: {r: 0.5, g: 0.5, b: 0.5, a: 1} + m_FogMode: 3 + m_FogDensity: 0.01 + m_LinearFogStart: 0 + m_LinearFogEnd: 300 + m_AmbientSkyColor: {r: 0.212, g: 0.227, b: 0.259, a: 1} + m_AmbientEquatorColor: {r: 0.114, g: 0.125, b: 0.133, a: 1} + m_AmbientGroundColor: {r: 0.047, g: 0.043, b: 0.035, a: 1} + m_AmbientIntensity: 1 + m_AmbientMode: 0 + m_SubtractiveShadowColor: {r: 0.42, g: 0.478, b: 0.627, a: 1} + m_SkyboxMaterial: {fileID: 0} + m_HaloStrength: 0.5 + m_FlareStrength: 1 + m_FlareFadeSpeed: 3 + m_HaloTexture: {fileID: 0} + m_SpotCookie: {fileID: 10001, guid: 0000000000000000e000000000000000, type: 0} + m_DefaultReflectionMode: 0 + m_DefaultReflectionResolution: 128 + m_ReflectionBounces: 1 + m_ReflectionIntensity: 1 + m_CustomReflection: {fileID: 0} + m_Sun: {fileID: 0} + m_IndirectSpecularColor: {r: 1.5231128, g: 2.542428, b: 2.8420537, a: 1} + m_UseRadianceAmbientProbe: 0 +--- !u!157 &3 +LightmapSettings: + m_ObjectHideFlags: 0 + serializedVersion: 12 + m_GIWorkflowMode: 1 + m_GISettings: + serializedVersion: 2 + m_BounceScale: 1 + m_IndirectOutputScale: 1 + m_AlbedoBoost: 1 + m_EnvironmentLightingMode: 0 + m_EnableBakedLightmaps: 1 + m_EnableRealtimeLightmaps: 0 + m_LightmapEditorSettings: + serializedVersion: 12 + m_Resolution: 2 + m_BakeResolution: 40 + m_AtlasSize: 1024 + m_AO: 0 + m_AOMaxDistance: 1 + m_CompAOExponent: 1 + m_CompAOExponentDirect: 0 + m_ExtractAmbientOcclusion: 0 + m_Padding: 2 + m_LightmapParameters: {fileID: 0} + m_LightmapsBakeMode: 1 + m_TextureCompression: 1 + m_FinalGather: 0 + m_FinalGatherFiltering: 1 + m_FinalGatherRayCount: 256 + m_ReflectionCompression: 2 + m_MixedBakeMode: 2 + m_BakeBackend: 1 + m_PVRSampling: 1 + m_PVRDirectSampleCount: 32 + m_PVRSampleCount: 512 + m_PVRBounces: 2 + m_PVREnvironmentSampleCount: 256 + m_PVREnvironmentReferencePointCount: 2048 + m_PVRFilteringMode: 1 + m_PVRDenoiserTypeDirect: 1 + m_PVRDenoiserTypeIndirect: 1 + m_PVRDenoiserTypeAO: 1 + m_PVRFilterTypeDirect: 0 + m_PVRFilterTypeIndirect: 0 + m_PVRFilterTypeAO: 0 + m_PVREnvironmentMIS: 1 + m_PVRCulling: 1 + m_PVRFilteringGaussRadiusDirect: 1 + m_PVRFilteringGaussRadiusIndirect: 5 + m_PVRFilteringGaussRadiusAO: 2 + m_PVRFilteringAtrousPositionSigmaDirect: 0.5 + m_PVRFilteringAtrousPositionSigmaIndirect: 2 + m_PVRFilteringAtrousPositionSigmaAO: 1 + m_ExportTrainingData: 0 + m_TrainingDataDestination: TrainingData + m_LightProbeSampleCountMultiplier: 4 + m_LightingDataAsset: {fileID: 112000000, guid: 8c4cfd98c061ca04a85530d07d8a7113, type: 2} + m_LightingSettings: {fileID: 4890085278179872738, guid: b0818917b2bb80d4187e4524fb0966eb, type: 2} +--- !u!196 &4 +NavMeshSettings: + serializedVersion: 2 + m_ObjectHideFlags: 0 + m_BuildSettings: + serializedVersion: 2 + agentTypeID: 0 + agentRadius: 0.5 + agentHeight: 2 + agentSlope: 45 + agentClimb: 0.4 + ledgeDropHeight: 0 + maxJumpAcrossDistance: 0 + minRegionArea: 2 + manualCellSize: 0 + cellSize: 0.16666667 + manualTileSize: 0 + tileSize: 256 + accuratePlacement: 0 + maxJobWorkers: 0 + preserveTilesOutsideBounds: 0 + debug: + m_Flags: 0 + m_NavMeshData: {fileID: 0} +--- !u!1 &32887118 +GameObject: + m_ObjectHideFlags: 1 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + serializedVersion: 6 + m_Component: + - component: {fileID: 32887120} + - component: {fileID: 32887119} + m_Layer: 0 + m_Name: StaticLightingSky + m_TagString: Untagged + m_Icon: {fileID: 0} + m_NavMeshLayer: 0 + m_StaticEditorFlags: 0 + m_IsActive: 1 +--- !u!114 &32887119 +MonoBehaviour: + m_ObjectHideFlags: 1 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 32887118} + m_Enabled: 1 + m_EditorHideFlags: 0 + m_Script: {fileID: 11500000, guid: 441482e8936e35048a1dffac814e3ef8, type: 3} + m_Name: + m_EditorClassIdentifier: + m_Profile: {fileID: 11400000, guid: 4a8c54a78ed444349bedaea62cec828f, type: 2} + m_StaticLightingSkyUniqueID: 1 +--- !u!4 &32887120 +Transform: + m_ObjectHideFlags: 1 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 32887118} + m_LocalRotation: {x: 0, y: 0, z: 0, w: 1} + m_LocalPosition: {x: 0, y: 0, z: 0} + m_LocalScale: {x: 1, y: 1, z: 1} + m_Children: [] + m_Father: {fileID: 0} + m_RootOrder: 0 + m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0} +--- !u!115 &60541185 +MonoScript: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_Name: + serializedVersion: 5 + m_Script: + m_DefaultReferences: {} + m_Icon: {fileID: 0} + m_ExecutionOrder: 0 + m_ClassName: SceneObjectIDMapSceneAsset + m_Namespace: UnityEngine.Rendering.HighDefinition +--- !u!1 &494497244 stripped +GameObject: + m_CorrespondingSourceObject: {fileID: 494497244, guid: d68c18d6affcb744a9e2642485d8fe1e, type: 3} + m_PrefabInstance: {fileID: 3478961713162174924} + m_PrefabAsset: {fileID: 0} +--- !u!1 &785208099 +GameObject: + m_ObjectHideFlags: 19 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + serializedVersion: 6 + m_Component: + - component: {fileID: 785208101} + - component: {fileID: 785208100} + m_Layer: 0 + m_Name: SceneIDMap + m_TagString: Untagged + m_Icon: {fileID: 0} + m_NavMeshLayer: 0 + m_StaticEditorFlags: 0 + m_IsActive: 1 +--- !u!114 &785208100 +MonoBehaviour: + m_ObjectHideFlags: 19 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 785208099} + m_Enabled: 1 + m_EditorHideFlags: 0 + m_Script: {fileID: 1827911020} + m_Name: + m_EditorClassIdentifier: + m_Entries: [] +--- !u!4 &785208101 +Transform: + m_ObjectHideFlags: 19 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 785208099} + m_LocalRotation: {x: 0, y: 0, z: 0, w: 1} + m_LocalPosition: {x: 0, y: 0, z: 0} + m_LocalScale: {x: 1, y: 1, z: 1} + m_Children: [] + m_Father: {fileID: 0} + m_RootOrder: 2 + m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0} +--- !u!1 &976227547 +GameObject: + m_ObjectHideFlags: 19 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + serializedVersion: 6 + m_Component: + - component: {fileID: 976227549} + - component: {fileID: 976227548} + m_Layer: 0 + m_Name: SceneIDMap + m_TagString: Untagged + m_Icon: {fileID: 0} + m_NavMeshLayer: 0 + m_StaticEditorFlags: 0 + m_IsActive: 1 +--- !u!114 &976227548 +MonoBehaviour: + m_ObjectHideFlags: 19 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 976227547} + m_Enabled: 1 + m_EditorHideFlags: 0 + m_Script: {fileID: 60541185} + m_Name: + m_EditorClassIdentifier: + m_Entries: + - id: 0 + category: 0 + gameObject: {fileID: 494497244} +--- !u!4 &976227549 +Transform: + m_ObjectHideFlags: 19 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 976227547} + m_LocalRotation: {x: 0, y: 0, z: 0, w: 1} + m_LocalPosition: {x: 0, y: 0, z: 0} + m_LocalScale: {x: 1, y: 1, z: 1} + m_Children: [] + m_Father: {fileID: 0} + m_RootOrder: 4 + m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0} +--- !u!1 &1172690501 +GameObject: + m_ObjectHideFlags: 19 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + serializedVersion: 6 + m_Component: + - component: {fileID: 1172690503} + - component: {fileID: 1172690502} + m_Layer: 0 + m_Name: SceneIDMap + m_TagString: Untagged + m_Icon: {fileID: 0} + m_NavMeshLayer: 0 + m_StaticEditorFlags: 0 + m_IsActive: 1 +--- !u!114 &1172690502 +MonoBehaviour: + m_ObjectHideFlags: 19 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 1172690501} + m_Enabled: 1 + m_EditorHideFlags: 0 + m_Script: {fileID: 1484299943} + m_Name: + m_EditorClassIdentifier: + m_Entries: [] +--- !u!4 &1172690503 +Transform: + m_ObjectHideFlags: 19 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 1172690501} + m_LocalRotation: {x: 0, y: 0, z: 0, w: 1} + m_LocalPosition: {x: 0, y: 0, z: 0} + m_LocalScale: {x: 1, y: 1, z: 1} + m_Children: [] + m_Father: {fileID: 0} + m_RootOrder: 3 + m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0} +--- !u!115 &1484299943 +MonoScript: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_Name: + serializedVersion: 5 + m_Script: + m_DefaultReferences: {} + m_Icon: {fileID: 0} + m_ExecutionOrder: 0 + m_ClassName: SceneObjectIDMapSceneAsset + m_Namespace: UnityEngine.Rendering.HighDefinition +--- !u!115 &1827911020 +MonoScript: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_Name: + serializedVersion: 5 + m_Script: + m_DefaultReferences: {} + m_Icon: {fileID: 0} + m_ExecutionOrder: 0 + m_ClassName: SceneObjectIDMapSceneAsset + m_Namespace: UnityEngine.Rendering.HighDefinition +--- !u!1001 &3478961713162174924 +PrefabInstance: + m_ObjectHideFlags: 0 + serializedVersion: 2 + m_Modification: + m_TransformParent: {fileID: 0} + m_Modifications: + - target: {fileID: 2059096377, guid: d68c18d6affcb744a9e2642485d8fe1e, type: 3} + propertyPath: field of view + value: 45 + objectReference: {fileID: 0} + - target: {fileID: 2059096378, guid: d68c18d6affcb744a9e2642485d8fe1e, type: 3} + propertyPath: m_LocalPosition.x + value: 1.1654013 + objectReference: {fileID: 0} + - target: {fileID: 2059096378, guid: d68c18d6affcb744a9e2642485d8fe1e, type: 3} + propertyPath: m_LocalPosition.y + value: 1.8630592 + objectReference: {fileID: 0} + - target: {fileID: 2059096378, guid: d68c18d6affcb744a9e2642485d8fe1e, type: 3} + propertyPath: m_LocalPosition.z + value: 2.997405 + objectReference: {fileID: 0} + - target: {fileID: 2059096378, guid: d68c18d6affcb744a9e2642485d8fe1e, type: 3} + propertyPath: m_LocalRotation.w + value: 0.19996828 + objectReference: {fileID: 0} + - target: {fileID: 2059096378, guid: d68c18d6affcb744a9e2642485d8fe1e, type: 3} + propertyPath: m_LocalRotation.x + value: 0.020029841 + objectReference: {fileID: 0} + - target: {fileID: 2059096378, guid: d68c18d6affcb744a9e2642485d8fe1e, type: 3} + propertyPath: m_LocalRotation.y + value: -0.96892583 + objectReference: {fileID: 0} + - target: {fileID: 2059096378, guid: d68c18d6affcb744a9e2642485d8fe1e, type: 3} + propertyPath: m_LocalRotation.z + value: 0.14420216 + objectReference: {fileID: 0} + - target: {fileID: 2059096379, guid: d68c18d6affcb744a9e2642485d8fe1e, type: 3} + propertyPath: stopNaNs + value: 0 + objectReference: {fileID: 0} + - target: {fileID: 2059096379, guid: d68c18d6affcb744a9e2642485d8fe1e, type: 3} + propertyPath: dithering + value: 0 + objectReference: {fileID: 0} + - target: {fileID: 2059096379, guid: d68c18d6affcb744a9e2642485d8fe1e, type: 3} + propertyPath: antialiasing + value: 2 + objectReference: {fileID: 0} + - target: {fileID: 332079474543392766, guid: d68c18d6affcb744a9e2642485d8fe1e, type: 3} + propertyPath: m_Name + value: PreviewScenePrefab + objectReference: {fileID: 0} + - target: {fileID: 343734690788986213, guid: d68c18d6affcb744a9e2642485d8fe1e, type: 3} + propertyPath: m_Intensity + value: 400 + objectReference: {fileID: 0} + - target: {fileID: 343734690788986213, guid: d68c18d6affcb744a9e2642485d8fe1e, type: 3} + propertyPath: m_ShapeWidth + value: 1 + objectReference: {fileID: 0} + - target: {fileID: 343734690788986213, guid: d68c18d6affcb744a9e2642485d8fe1e, type: 3} + propertyPath: m_ShapeHeight + value: 1 + objectReference: {fileID: 0} + - target: {fileID: 343734690788986213, guid: d68c18d6affcb744a9e2642485d8fe1e, type: 3} + propertyPath: m_ShapeRadius + value: 0.25 + objectReference: {fileID: 0} + - target: {fileID: 343734690788986213, guid: d68c18d6affcb744a9e2642485d8fe1e, type: 3} + propertyPath: useVolumetric + value: 1 + objectReference: {fileID: 0} + - target: {fileID: 343734690788986213, guid: d68c18d6affcb744a9e2642485d8fe1e, type: 3} + propertyPath: m_SpotLightShape + value: 0 + objectReference: {fileID: 0} + - target: {fileID: 343734690788986213, guid: d68c18d6affcb744a9e2642485d8fe1e, type: 3} + propertyPath: m_InnerSpotPercent + value: 50 + objectReference: {fileID: 0} + - target: {fileID: 343734690788986213, guid: d68c18d6affcb744a9e2642485d8fe1e, type: 3} + propertyPath: m_PointlightHDType + value: 1 + objectReference: {fileID: 0} + - target: {fileID: 773716982743449794, guid: d68c18d6affcb744a9e2642485d8fe1e, type: 3} + propertyPath: m_Type + value: 0 + objectReference: {fileID: 0} + - target: {fileID: 773716982743449794, guid: d68c18d6affcb744a9e2642485d8fe1e, type: 3} + propertyPath: m_Range + value: 9 + objectReference: {fileID: 0} + - target: {fileID: 773716982743449794, guid: d68c18d6affcb744a9e2642485d8fe1e, type: 3} + propertyPath: m_Color.b + value: 1 + objectReference: {fileID: 0} + - target: {fileID: 773716982743449794, guid: d68c18d6affcb744a9e2642485d8fe1e, type: 3} + propertyPath: m_Color.g + value: 1 + objectReference: {fileID: 0} + - target: {fileID: 773716982743449794, guid: d68c18d6affcb744a9e2642485d8fe1e, type: 3} + propertyPath: m_Color.r + value: 1 + objectReference: {fileID: 0} + - target: {fileID: 773716982743449794, guid: d68c18d6affcb744a9e2642485d8fe1e, type: 3} + propertyPath: m_Intensity + value: 127.32395 + objectReference: {fileID: 0} + - target: {fileID: 773716982743449794, guid: d68c18d6affcb744a9e2642485d8fe1e, type: 3} + propertyPath: m_SpotAngle + value: 120 + objectReference: {fileID: 0} + - target: {fileID: 773716982743449794, guid: d68c18d6affcb744a9e2642485d8fe1e, type: 3} + propertyPath: m_AreaSize.x + value: 1 + objectReference: {fileID: 0} + - target: {fileID: 773716982743449794, guid: d68c18d6affcb744a9e2642485d8fe1e, type: 3} + propertyPath: m_AreaSize.y + value: 1 + objectReference: {fileID: 0} + - target: {fileID: 773716982743449794, guid: d68c18d6affcb744a9e2642485d8fe1e, type: 3} + propertyPath: m_ShadowRadius + value: 0.25 + objectReference: {fileID: 0} + - target: {fileID: 773716982743449794, guid: d68c18d6affcb744a9e2642485d8fe1e, type: 3} + propertyPath: m_ColorTemperature + value: 6800 + objectReference: {fileID: 0} + - target: {fileID: 773716982743449794, guid: d68c18d6affcb744a9e2642485d8fe1e, type: 3} + propertyPath: m_BoundingSphereOverride.w + value: 10 + objectReference: {fileID: 0} + - target: {fileID: 773716982743449794, guid: d68c18d6affcb744a9e2642485d8fe1e, type: 3} + propertyPath: m_BoundingSphereOverride.z + value: 0 + objectReference: {fileID: 0} + - target: {fileID: 773716982743449794, guid: d68c18d6affcb744a9e2642485d8fe1e, type: 3} + propertyPath: m_UseBoundingSphereOverride + value: 0 + objectReference: {fileID: 0} + - target: {fileID: 773716982743449794, guid: d68c18d6affcb744a9e2642485d8fe1e, type: 3} + propertyPath: m_Shadows.m_UseCullingMatrixOverride + value: 0 + objectReference: {fileID: 0} + - target: {fileID: 773716982743449794, guid: d68c18d6affcb744a9e2642485d8fe1e, type: 3} + propertyPath: m_Shadows.m_CullingMatrixOverride.e00 + value: 0.57735026 + objectReference: {fileID: 0} + - target: {fileID: 773716982743449794, guid: d68c18d6affcb744a9e2642485d8fe1e, type: 3} + propertyPath: m_Shadows.m_CullingMatrixOverride.e11 + value: 0.57735026 + objectReference: {fileID: 0} + - target: {fileID: 773716982743449794, guid: d68c18d6affcb744a9e2642485d8fe1e, type: 3} + propertyPath: m_Shadows.m_CullingMatrixOverride.e22 + value: 1.02 + objectReference: {fileID: 0} + - target: {fileID: 773716982743449794, guid: d68c18d6affcb744a9e2642485d8fe1e, type: 3} + propertyPath: m_Shadows.m_CullingMatrixOverride.e23 + value: -0.202 + objectReference: {fileID: 0} + - target: {fileID: 773716982743449794, guid: d68c18d6affcb744a9e2642485d8fe1e, type: 3} + propertyPath: m_Shadows.m_CullingMatrixOverride.e32 + value: 1 + objectReference: {fileID: 0} + - target: {fileID: 773716982743449794, guid: d68c18d6affcb744a9e2642485d8fe1e, type: 3} + propertyPath: m_Shadows.m_CullingMatrixOverride.e33 + value: 0 + objectReference: {fileID: 0} + - target: {fileID: 1051193941811274113, guid: d68c18d6affcb744a9e2642485d8fe1e, type: 3} + propertyPath: m_IsActive + value: 1 + objectReference: {fileID: 0} + - target: {fileID: 2569123291528499557, guid: d68c18d6affcb744a9e2642485d8fe1e, type: 3} + propertyPath: m_LocalPosition.x + value: -0.019 + objectReference: {fileID: 0} + - target: {fileID: 2569123291528499557, guid: d68c18d6affcb744a9e2642485d8fe1e, type: 3} + propertyPath: m_LocalPosition.y + value: 1.638 + objectReference: {fileID: 0} + - target: {fileID: 2569123291528499557, guid: d68c18d6affcb744a9e2642485d8fe1e, type: 3} + propertyPath: m_LocalPosition.z + value: -1.344 + objectReference: {fileID: 0} + - target: {fileID: 2831752391173089184, guid: d68c18d6affcb744a9e2642485d8fe1e, type: 3} + propertyPath: m_IsActive + value: 1 + objectReference: {fileID: 0} + - target: {fileID: 3737093066198893668, guid: d68c18d6affcb744a9e2642485d8fe1e, type: 3} + propertyPath: m_RootOrder + value: 1 + objectReference: {fileID: 0} + - target: {fileID: 3737093066198893668, guid: d68c18d6affcb744a9e2642485d8fe1e, type: 3} + propertyPath: m_LocalPosition.x + value: 0 + objectReference: {fileID: 0} + - target: {fileID: 3737093066198893668, guid: d68c18d6affcb744a9e2642485d8fe1e, type: 3} + propertyPath: m_LocalPosition.y + value: 0 + objectReference: {fileID: 0} + - target: {fileID: 3737093066198893668, guid: d68c18d6affcb744a9e2642485d8fe1e, type: 3} + propertyPath: m_LocalPosition.z + value: 0 + objectReference: {fileID: 0} + - target: {fileID: 3737093066198893668, guid: d68c18d6affcb744a9e2642485d8fe1e, type: 3} + propertyPath: m_LocalRotation.w + value: 1 + objectReference: {fileID: 0} + - target: {fileID: 3737093066198893668, guid: d68c18d6affcb744a9e2642485d8fe1e, type: 3} + propertyPath: m_LocalRotation.x + value: 0 + objectReference: {fileID: 0} + - target: {fileID: 3737093066198893668, guid: d68c18d6affcb744a9e2642485d8fe1e, type: 3} + propertyPath: m_LocalRotation.y + value: 0 + objectReference: {fileID: 0} + - target: {fileID: 3737093066198893668, guid: d68c18d6affcb744a9e2642485d8fe1e, type: 3} + propertyPath: m_LocalRotation.z + value: 0 + objectReference: {fileID: 0} + - target: {fileID: 3737093066198893668, guid: d68c18d6affcb744a9e2642485d8fe1e, type: 3} + propertyPath: m_LocalEulerAnglesHint.x + value: 0 + objectReference: {fileID: 0} + - target: {fileID: 3737093066198893668, guid: d68c18d6affcb744a9e2642485d8fe1e, type: 3} + propertyPath: m_LocalEulerAnglesHint.y + value: 0 + objectReference: {fileID: 0} + - target: {fileID: 3737093066198893668, guid: d68c18d6affcb744a9e2642485d8fe1e, type: 3} + propertyPath: m_LocalEulerAnglesHint.z + value: 0 + objectReference: {fileID: 0} + - target: {fileID: 4750504114698822654, guid: d68c18d6affcb744a9e2642485d8fe1e, type: 3} + propertyPath: m_Type + value: 0 + objectReference: {fileID: 0} + - target: {fileID: 4750504114698822654, guid: d68c18d6affcb744a9e2642485d8fe1e, type: 3} + propertyPath: m_Range + value: 9 + objectReference: {fileID: 0} + - target: {fileID: 4750504114698822654, guid: d68c18d6affcb744a9e2642485d8fe1e, type: 3} + propertyPath: m_Color.b + value: 0.9529412 + objectReference: {fileID: 0} + - target: {fileID: 4750504114698822654, guid: d68c18d6affcb744a9e2642485d8fe1e, type: 3} + propertyPath: m_Color.g + value: 0.9843137 + objectReference: {fileID: 0} + - target: {fileID: 4750504114698822654, guid: d68c18d6affcb744a9e2642485d8fe1e, type: 3} + propertyPath: m_Intensity + value: 63.661972 + objectReference: {fileID: 0} + - target: {fileID: 4750504114698822654, guid: d68c18d6affcb744a9e2642485d8fe1e, type: 3} + propertyPath: m_SpotAngle + value: 120 + objectReference: {fileID: 0} + - target: {fileID: 4750504114698822654, guid: d68c18d6affcb744a9e2642485d8fe1e, type: 3} + propertyPath: m_AreaSize.x + value: 1 + objectReference: {fileID: 0} + - target: {fileID: 4750504114698822654, guid: d68c18d6affcb744a9e2642485d8fe1e, type: 3} + propertyPath: m_AreaSize.y + value: 1 + objectReference: {fileID: 0} + - target: {fileID: 4750504114698822654, guid: d68c18d6affcb744a9e2642485d8fe1e, type: 3} + propertyPath: m_ShadowRadius + value: 0.25 + objectReference: {fileID: 0} + - target: {fileID: 4750504114698822654, guid: d68c18d6affcb744a9e2642485d8fe1e, type: 3} + propertyPath: m_ColorTemperature + value: 6800 + objectReference: {fileID: 0} + - target: {fileID: 4750504114698822654, guid: d68c18d6affcb744a9e2642485d8fe1e, type: 3} + propertyPath: m_BoundingSphereOverride.w + value: 10 + objectReference: {fileID: 0} + - target: {fileID: 4750504114698822654, guid: d68c18d6affcb744a9e2642485d8fe1e, type: 3} + propertyPath: m_BoundingSphereOverride.z + value: 0 + objectReference: {fileID: 0} + - target: {fileID: 4750504114698822654, guid: d68c18d6affcb744a9e2642485d8fe1e, type: 3} + propertyPath: m_UseBoundingSphereOverride + value: 0 + objectReference: {fileID: 0} + - target: {fileID: 4750504114698822654, guid: d68c18d6affcb744a9e2642485d8fe1e, type: 3} + propertyPath: m_Shadows.m_UseCullingMatrixOverride + value: 0 + objectReference: {fileID: 0} + - target: {fileID: 4750504114698822654, guid: d68c18d6affcb744a9e2642485d8fe1e, type: 3} + propertyPath: m_Shadows.m_CullingMatrixOverride.e00 + value: 0.57735026 + objectReference: {fileID: 0} + - target: {fileID: 4750504114698822654, guid: d68c18d6affcb744a9e2642485d8fe1e, type: 3} + propertyPath: m_Shadows.m_CullingMatrixOverride.e11 + value: 0.57735026 + objectReference: {fileID: 0} + - target: {fileID: 4750504114698822654, guid: d68c18d6affcb744a9e2642485d8fe1e, type: 3} + propertyPath: m_Shadows.m_CullingMatrixOverride.e22 + value: 1.02 + objectReference: {fileID: 0} + - target: {fileID: 4750504114698822654, guid: d68c18d6affcb744a9e2642485d8fe1e, type: 3} + propertyPath: m_Shadows.m_CullingMatrixOverride.e23 + value: -0.202 + objectReference: {fileID: 0} + - target: {fileID: 4750504114698822654, guid: d68c18d6affcb744a9e2642485d8fe1e, type: 3} + propertyPath: m_Shadows.m_CullingMatrixOverride.e32 + value: 1 + objectReference: {fileID: 0} + - target: {fileID: 4750504114698822654, guid: d68c18d6affcb744a9e2642485d8fe1e, type: 3} + propertyPath: m_Shadows.m_CullingMatrixOverride.e33 + value: 0 + objectReference: {fileID: 0} + - target: {fileID: 6218605643134089497, guid: d68c18d6affcb744a9e2642485d8fe1e, type: 3} + propertyPath: m_Intensity + value: 200 + objectReference: {fileID: 0} + - target: {fileID: 6218605643134089497, guid: d68c18d6affcb744a9e2642485d8fe1e, type: 3} + propertyPath: m_ShapeWidth + value: 1 + objectReference: {fileID: 0} + - target: {fileID: 6218605643134089497, guid: d68c18d6affcb744a9e2642485d8fe1e, type: 3} + propertyPath: m_ShapeHeight + value: 1 + objectReference: {fileID: 0} + - target: {fileID: 6218605643134089497, guid: d68c18d6affcb744a9e2642485d8fe1e, type: 3} + propertyPath: m_ShapeRadius + value: 0.25 + objectReference: {fileID: 0} + - target: {fileID: 6218605643134089497, guid: d68c18d6affcb744a9e2642485d8fe1e, type: 3} + propertyPath: useVolumetric + value: 1 + objectReference: {fileID: 0} + - target: {fileID: 6218605643134089497, guid: d68c18d6affcb744a9e2642485d8fe1e, type: 3} + propertyPath: m_SpotLightShape + value: 0 + objectReference: {fileID: 0} + - target: {fileID: 6218605643134089497, guid: d68c18d6affcb744a9e2642485d8fe1e, type: 3} + propertyPath: m_InnerSpotPercent + value: 50.2 + objectReference: {fileID: 0} + - target: {fileID: 6218605643134089497, guid: d68c18d6affcb744a9e2642485d8fe1e, type: 3} + propertyPath: m_PointlightHDType + value: 0 + objectReference: {fileID: 0} + - target: {fileID: 7375704023635195177, guid: d68c18d6affcb744a9e2642485d8fe1e, type: 3} + propertyPath: m_Intensity + value: 400 + objectReference: {fileID: 0} + - target: {fileID: 7375704023635195177, guid: d68c18d6affcb744a9e2642485d8fe1e, type: 3} + propertyPath: m_ShapeWidth + value: 1 + objectReference: {fileID: 0} + - target: {fileID: 7375704023635195177, guid: d68c18d6affcb744a9e2642485d8fe1e, type: 3} + propertyPath: m_ShapeHeight + value: 1 + objectReference: {fileID: 0} + - target: {fileID: 7375704023635195177, guid: d68c18d6affcb744a9e2642485d8fe1e, type: 3} + propertyPath: m_ShapeRadius + value: 0.25 + objectReference: {fileID: 0} + - target: {fileID: 7375704023635195177, guid: d68c18d6affcb744a9e2642485d8fe1e, type: 3} + propertyPath: useVolumetric + value: 1 + objectReference: {fileID: 0} + - target: {fileID: 7375704023635195177, guid: d68c18d6affcb744a9e2642485d8fe1e, type: 3} + propertyPath: m_SpotLightShape + value: 0 + objectReference: {fileID: 0} + - target: {fileID: 7375704023635195177, guid: d68c18d6affcb744a9e2642485d8fe1e, type: 3} + propertyPath: m_InnerSpotPercent + value: 50 + objectReference: {fileID: 0} + - target: {fileID: 7375704023635195177, guid: d68c18d6affcb744a9e2642485d8fe1e, type: 3} + propertyPath: m_PointlightHDType + value: 0 + objectReference: {fileID: 0} + - target: {fileID: 9223163883438719360, guid: d68c18d6affcb744a9e2642485d8fe1e, type: 3} + propertyPath: m_Type + value: 0 + objectReference: {fileID: 0} + - target: {fileID: 9223163883438719360, guid: d68c18d6affcb744a9e2642485d8fe1e, type: 3} + propertyPath: m_Range + value: 9 + objectReference: {fileID: 0} + - target: {fileID: 9223163883438719360, guid: d68c18d6affcb744a9e2642485d8fe1e, type: 3} + propertyPath: m_Color.b + value: 1 + objectReference: {fileID: 0} + - target: {fileID: 9223163883438719360, guid: d68c18d6affcb744a9e2642485d8fe1e, type: 3} + propertyPath: m_Color.g + value: 1 + objectReference: {fileID: 0} + - target: {fileID: 9223163883438719360, guid: d68c18d6affcb744a9e2642485d8fe1e, type: 3} + propertyPath: m_Color.r + value: 1 + objectReference: {fileID: 0} + - target: {fileID: 9223163883438719360, guid: d68c18d6affcb744a9e2642485d8fe1e, type: 3} + propertyPath: m_Intensity + value: 127.323944 + objectReference: {fileID: 0} + - target: {fileID: 9223163883438719360, guid: d68c18d6affcb744a9e2642485d8fe1e, type: 3} + propertyPath: m_SpotAngle + value: 120 + objectReference: {fileID: 0} + - target: {fileID: 9223163883438719360, guid: d68c18d6affcb744a9e2642485d8fe1e, type: 3} + propertyPath: m_AreaSize.x + value: 1 + objectReference: {fileID: 0} + - target: {fileID: 9223163883438719360, guid: d68c18d6affcb744a9e2642485d8fe1e, type: 3} + propertyPath: m_AreaSize.y + value: 1 + objectReference: {fileID: 0} + - target: {fileID: 9223163883438719360, guid: d68c18d6affcb744a9e2642485d8fe1e, type: 3} + propertyPath: m_ShadowRadius + value: 0.25 + objectReference: {fileID: 0} + - target: {fileID: 9223163883438719360, guid: d68c18d6affcb744a9e2642485d8fe1e, type: 3} + propertyPath: m_ColorTemperature + value: 6800 + objectReference: {fileID: 0} + - target: {fileID: 9223163883438719360, guid: d68c18d6affcb744a9e2642485d8fe1e, type: 3} + propertyPath: m_BoundingSphereOverride.w + value: 10 + objectReference: {fileID: 0} + - target: {fileID: 9223163883438719360, guid: d68c18d6affcb744a9e2642485d8fe1e, type: 3} + propertyPath: m_BoundingSphereOverride.z + value: 0 + objectReference: {fileID: 0} + - target: {fileID: 9223163883438719360, guid: d68c18d6affcb744a9e2642485d8fe1e, type: 3} + propertyPath: m_UseBoundingSphereOverride + value: 0 + objectReference: {fileID: 0} + - target: {fileID: 9223163883438719360, guid: d68c18d6affcb744a9e2642485d8fe1e, type: 3} + propertyPath: m_Shadows.m_UseCullingMatrixOverride + value: 0 + objectReference: {fileID: 0} + - target: {fileID: 9223163883438719360, guid: d68c18d6affcb744a9e2642485d8fe1e, type: 3} + propertyPath: m_Shadows.m_CullingMatrixOverride.e00 + value: 0.57735026 + objectReference: {fileID: 0} + - target: {fileID: 9223163883438719360, guid: d68c18d6affcb744a9e2642485d8fe1e, type: 3} + propertyPath: m_Shadows.m_CullingMatrixOverride.e11 + value: 0.57735026 + objectReference: {fileID: 0} + - target: {fileID: 9223163883438719360, guid: d68c18d6affcb744a9e2642485d8fe1e, type: 3} + propertyPath: m_Shadows.m_CullingMatrixOverride.e22 + value: 1.02 + objectReference: {fileID: 0} + - target: {fileID: 9223163883438719360, guid: d68c18d6affcb744a9e2642485d8fe1e, type: 3} + propertyPath: m_Shadows.m_CullingMatrixOverride.e23 + value: -0.202 + objectReference: {fileID: 0} + - target: {fileID: 9223163883438719360, guid: d68c18d6affcb744a9e2642485d8fe1e, type: 3} + propertyPath: m_Shadows.m_CullingMatrixOverride.e32 + value: 1 + objectReference: {fileID: 0} + - target: {fileID: 9223163883438719360, guid: d68c18d6affcb744a9e2642485d8fe1e, type: 3} + propertyPath: m_Shadows.m_CullingMatrixOverride.e33 + value: 0 + objectReference: {fileID: 0} + m_RemovedComponents: [] + m_SourcePrefab: {fileID: 100100000, guid: d68c18d6affcb744a9e2642485d8fe1e, type: 3} diff --git a/Scenes/PreviewScene.unity.meta b/Scenes/PreviewScene.unity.meta new file mode 100644 index 0000000..9c22f0d --- /dev/null +++ b/Scenes/PreviewScene.unity.meta @@ -0,0 +1,7 @@ +fileFormatVersion: 2 +guid: b805cc6c24f39ef4a9cb8f2c9a4ce4ce +DefaultImporter: + externalObjects: {} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Scenes/PreviewScene/Materials.meta b/Scenes/PreviewScene/Materials.meta new file mode 100644 index 0000000..92e709c --- /dev/null +++ b/Scenes/PreviewScene/Materials.meta @@ -0,0 +1,8 @@ +fileFormatVersion: 2 +guid: e40e0a020dea9934f8fd3f3f29533fc5 +folderAsset: yes +DefaultImporter: + externalObjects: {} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Scenes/PreviewScene/Materials/floorSpot.mat b/Scenes/PreviewScene/Materials/floorSpot.mat new file mode 100644 index 0000000..43591bd --- /dev/null +++ b/Scenes/PreviewScene/Materials/floorSpot.mat @@ -0,0 +1,258 @@ +%YAML 1.1 +%TAG !u! tag:unity3d.com,2011: +--- !u!21 &2100000 +Material: + serializedVersion: 6 + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_Name: floorSpot + m_Shader: {fileID: 4800000, guid: 6e4ae4064600d784cac1e41a9e6f2e59, type: 3} + m_ShaderKeywords: _DISABLE_SSR_TRANSPARENT _NORMALMAP_TANGENT_SPACE + m_LightmapFlags: 4 + m_EnableInstancingVariants: 0 + m_DoubleSidedGI: 0 + m_CustomRenderQueue: 2225 + stringTagMap: {} + disabledShaderPasses: + - TransparentDepthPrepass + - TransparentDepthPostpass + - TransparentBackface + - RayTracingPrepass + - MOTIONVECTORS + m_SavedProperties: + serializedVersion: 3 + m_TexEnvs: + - _AnisotropyMap: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - _BaseColorMap: + m_Texture: {fileID: 2800000, guid: 94004008529895e4bbbc36e65043c8b0, type: 3} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - _BentNormalMap: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - _BentNormalMapOS: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - _CoatMaskMap: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - _DetailMap: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - _EmissiveColorMap: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - _HeightMap: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - _IridescenceMaskMap: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - _IridescenceThicknessMap: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - _MainTex: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - _MaskMap: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - _NormalMap: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - _NormalMapOS: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - _SpecularColorMap: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - _SubsurfaceMaskMap: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - _TangentMap: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - _TangentMapOS: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - _ThicknessMap: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - _TransmittanceColorMap: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - unity_Lightmaps: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - unity_LightmapsInd: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - unity_ShadowMasks: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + m_Floats: + - _AORemapMax: 1 + - _AORemapMin: 0 + - _ATDistance: 1 + - _AddPrecomputedVelocity: 0 + - _AlbedoAffectEmissive: 0 + - _AlphaCutoff: 0.5 + - _AlphaCutoffEnable: 0 + - _AlphaCutoffPostpass: 0.5 + - _AlphaCutoffPrepass: 0.5 + - _AlphaCutoffShadow: 0.5 + - _AlphaDstBlend: 0 + - _AlphaSrcBlend: 1 + - _AlphaToMask: 0 + - _AlphaToMaskInspectorValue: 0 + - _Anisotropy: 0 + - _BlendMode: 0 + - _CoatMask: 0 + - _CullMode: 2 + - _CullModeForward: 2 + - _Cutoff: 0.5 + - _DepthOffsetEnable: 0 + - _DetailAlbedoScale: 1 + - _DetailNormalScale: 1 + - _DetailSmoothnessScale: 1 + - _DiffusionProfile: 0 + - _DiffusionProfileHash: 0 + - _DisplacementLockObjectScale: 1 + - _DisplacementLockTilingScale: 1 + - _DisplacementMode: 0 + - _DoubleSidedEnable: 0 + - _DoubleSidedNormalMode: 1 + - _DstBlend: 0 + - _EmissiveColorMode: 1 + - _EmissiveExposureWeight: 1 + - _EmissiveIntensity: 1 + - _EmissiveIntensityUnit: 0 + - _EnableBlendModePreserveSpecularLighting: 1 + - _EnableFogOnTransparent: 1 + - _EnableGeometricSpecularAA: 0 + - _EnergyConservingSpecularColor: 1 + - _HeightAmplitude: 0.02 + - _HeightCenter: 0.5 + - _HeightMapParametrization: 0 + - _HeightMax: 1 + - _HeightMin: -1 + - _HeightOffset: 0 + - _HeightPoMAmplitude: 2 + - _HeightTessAmplitude: 2 + - _HeightTessCenter: 0.5 + - _InvTilingScale: 1 + - _Ior: 1.5 + - _IridescenceMask: 1 + - _IridescenceThickness: 1 + - _LinkDetailsWithBase: 1 + - _MaterialID: 1 + - _Metallic: 0 + - _MetallicRemapMax: 1 + - _MetallicRemapMin: 0 + - _NormalMapSpace: 0 + - _NormalScale: 1 + - _OpaqueCullMode: 2 + - _PPDLodThreshold: 5 + - _PPDMaxSamples: 15 + - _PPDMinSamples: 5 + - _PPDPrimitiveLength: 1 + - _PPDPrimitiveWidth: 1 + - _RayTracing: 0 + - _ReceivesSSR: 1 + - _ReceivesSSRTransparent: 0 + - _RefractionModel: 0 + - _Smoothness: 0.5 + - _SmoothnessRemapMax: 1 + - _SmoothnessRemapMin: 0 + - _SpecularAAScreenSpaceVariance: 0.1 + - _SpecularAAThreshold: 0.2 + - _SpecularOcclusionMode: 1 + - _SrcBlend: 1 + - _StencilRef: 0 + - _StencilRefDepth: 8 + - _StencilRefGBuffer: 10 + - _StencilRefMV: 40 + - _StencilWriteMask: 6 + - _StencilWriteMaskDepth: 8 + - _StencilWriteMaskGBuffer: 14 + - _StencilWriteMaskMV: 40 + - _SubsurfaceMask: 1 + - _SupportDecals: 1 + - _SurfaceType: 0 + - _TexWorldScale: 1 + - _TexWorldScaleEmissive: 1 + - _Thickness: 1 + - _TransmissionEnable: 1 + - _TransparentBackfaceEnable: 0 + - _TransparentCullMode: 2 + - _TransparentDepthPostpassEnable: 0 + - _TransparentDepthPrepassEnable: 0 + - _TransparentSortPriority: 0 + - _TransparentWritingMotionVec: 0 + - _TransparentZWrite: 0 + - _UVBase: 0 + - _UVDetail: 0 + - _UVEmissive: 0 + - _UseEmissiveIntensity: 0 + - _UseShadowThreshold: 0 + - _ZTestDepthEqualForOpaque: 3 + - _ZTestGBuffer: 4 + - _ZTestTransparent: 4 + - _ZWrite: 1 + m_Colors: + - _BaseColor: {r: 1, g: 1, b: 1, a: 1} + - _BaseColorMap_MipInfo: {r: 0, g: 0, b: 0, a: 0} + - _Color: {r: 1, g: 1, b: 1, a: 1} + - _DiffusionProfileAsset: {r: 0, g: 0, b: 0, a: 0} + - _DoubleSidedConstants: {r: 1, g: 1, b: -1, a: 0} + - _EmissionColor: {r: 1, g: 1, b: 1, a: 1} + - _EmissiveColor: {r: 0, g: 0, b: 0, a: 1} + - _EmissiveColorLDR: {r: 0, g: 0, b: 0, a: 1} + - _InvPrimScale: {r: 1, g: 1, b: 0, a: 0} + - _IridescenceThicknessRemap: {r: 0, g: 1, b: 0, a: 0} + - _SpecularColor: {r: 1, g: 1, b: 1, a: 1} + - _ThicknessRemap: {r: 0, g: 1, b: 0, a: 0} + - _TransmittanceColor: {r: 1, g: 1, b: 1, a: 1} + - _UVDetailsMappingMask: {r: 1, g: 0, b: 0, a: 0} + - _UVMappingMask: {r: 1, g: 0, b: 0, a: 0} + - _UVMappingMaskEmissive: {r: 1, g: 0, b: 0, a: 0} + m_BuildTextureStacks: [] +--- !u!114 &2976362039153845447 +MonoBehaviour: + m_ObjectHideFlags: 11 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 0} + m_Enabled: 1 + m_EditorHideFlags: 0 + m_Script: {fileID: 11500000, guid: da692e001514ec24dbc4cca1949ff7e8, type: 3} + m_Name: + m_EditorClassIdentifier: + version: 11 diff --git a/Scenes/PreviewScene/Materials/floorSpot.mat.meta b/Scenes/PreviewScene/Materials/floorSpot.mat.meta new file mode 100644 index 0000000..70fa72e --- /dev/null +++ b/Scenes/PreviewScene/Materials/floorSpot.mat.meta @@ -0,0 +1,8 @@ +fileFormatVersion: 2 +guid: 4ce5021a1900ab745a10e11db4f67b32 +NativeFormatImporter: + externalObjects: {} + mainObjectFileID: 2100000 + userData: + assetBundleName: + assetBundleVariant: diff --git a/Scenes/PreviewScene/ReflectionProbe-0.exr b/Scenes/PreviewScene/ReflectionProbe-0.exr new file mode 100644 index 0000000..86b8f25 Binary files /dev/null and b/Scenes/PreviewScene/ReflectionProbe-0.exr differ diff --git a/Scenes/PreviewScene/ReflectionProbe-0.exr.meta b/Scenes/PreviewScene/ReflectionProbe-0.exr.meta new file mode 100644 index 0000000..ad60499 --- /dev/null +++ b/Scenes/PreviewScene/ReflectionProbe-0.exr.meta @@ -0,0 +1,96 @@ +fileFormatVersion: 2 +guid: 0b93c66b9c385ea4ea734dc76601ff3e +TextureImporter: + internalIDToNameTable: [] + externalObjects: {} + serializedVersion: 11 + mipmaps: + mipMapMode: 0 + enableMipMap: 1 + sRGBTexture: 1 + linearTexture: 0 + fadeOut: 0 + borderMipMap: 0 + mipMapsPreserveCoverage: 0 + alphaTestReferenceValue: 0.5 + mipMapFadeDistanceStart: 1 + mipMapFadeDistanceEnd: 3 + bumpmap: + convertToNormalMap: 0 + externalNormalMap: 0 + heightScale: 0.25 + normalMapFilter: 0 + isReadable: 0 + streamingMipmaps: 0 + streamingMipmapsPriority: 0 + vTOnly: 0 + grayScaleToAlpha: 0 + generateCubemap: 6 + cubemapConvolution: 1 + seamlessCubemap: 1 + textureFormat: 1 + maxTextureSize: 2048 + textureSettings: + serializedVersion: 2 + filterMode: 2 + aniso: 0 + mipBias: 0 + wrapU: 1 + wrapV: 1 + wrapW: 1 + nPOTScale: 1 + lightmap: 0 + compressionQuality: 50 + spriteMode: 0 + spriteExtrude: 1 + spriteMeshType: 1 + alignment: 0 + spritePivot: {x: 0.5, y: 0.5} + spritePixelsToUnits: 100 + spriteBorder: {x: 0, y: 0, z: 0, w: 0} + spriteGenerateFallbackPhysicsShape: 1 + alphaUsage: 1 + alphaIsTransparency: 0 + spriteTessellationDetail: -1 + textureType: 0 + textureShape: 2 + singleChannelComponent: 0 + flipbookRows: 1 + flipbookColumns: 1 + maxTextureSizeSet: 0 + compressionQualitySet: 0 + textureFormatSet: 0 + ignorePngGamma: 0 + applyGammaDecoding: 0 + platformSettings: + - serializedVersion: 3 + buildTarget: DefaultTexturePlatform + maxTextureSize: 2048 + resizeAlgorithm: 0 + textureFormat: -1 + textureCompression: 1 + compressionQuality: 100 + crunchedCompression: 0 + allowsAlphaSplitting: 0 + overridden: 0 + androidETC2FallbackOverride: 0 + forceMaximumCompressionQuality_BC6H_BC7: 0 + spriteSheet: + serializedVersion: 2 + sprites: [] + outline: [] + physicsShape: [] + bones: [] + spriteID: + internalID: 0 + vertices: [] + indices: + edges: [] + weights: [] + secondaryTextures: [] + spritePackingTag: + pSDRemoveMatte: 0 + pSDShowRemoveMatteOption: 0 + userData: + assetBundleName: + assetBundleVariant: diff --git a/Scenes/PreviewScene/floorSpot.png b/Scenes/PreviewScene/floorSpot.png new file mode 100644 index 0000000..9f501cc Binary files /dev/null and b/Scenes/PreviewScene/floorSpot.png differ diff --git a/Scenes/PreviewScene/floorSpot.png.meta b/Scenes/PreviewScene/floorSpot.png.meta new file mode 100644 index 0000000..8e52caf --- /dev/null +++ b/Scenes/PreviewScene/floorSpot.png.meta @@ -0,0 +1,96 @@ +fileFormatVersion: 2 +guid: 94004008529895e4bbbc36e65043c8b0 +TextureImporter: + internalIDToNameTable: [] + externalObjects: {} + serializedVersion: 11 + mipmaps: + mipMapMode: 0 + enableMipMap: 1 + sRGBTexture: 1 + linearTexture: 0 + fadeOut: 0 + borderMipMap: 0 + mipMapsPreserveCoverage: 0 + alphaTestReferenceValue: 0.5 + mipMapFadeDistanceStart: 1 + mipMapFadeDistanceEnd: 3 + bumpmap: + convertToNormalMap: 0 + externalNormalMap: 0 + heightScale: 0.25 + normalMapFilter: 0 + isReadable: 0 + streamingMipmaps: 0 + streamingMipmapsPriority: 0 + vTOnly: 0 + grayScaleToAlpha: 0 + generateCubemap: 6 + cubemapConvolution: 0 + seamlessCubemap: 0 + textureFormat: 1 + maxTextureSize: 2048 + textureSettings: + serializedVersion: 2 + filterMode: 1 + aniso: 1 + mipBias: 0 + wrapU: 0 + wrapV: 0 + wrapW: 0 + nPOTScale: 1 + lightmap: 0 + compressionQuality: 50 + spriteMode: 0 + spriteExtrude: 1 + spriteMeshType: 1 + alignment: 0 + spritePivot: {x: 0.5, y: 0.5} + spritePixelsToUnits: 100 + spriteBorder: {x: 0, y: 0, z: 0, w: 0} + spriteGenerateFallbackPhysicsShape: 1 + alphaUsage: 1 + alphaIsTransparency: 0 + spriteTessellationDetail: -1 + textureType: 0 + textureShape: 1 + singleChannelComponent: 0 + flipbookRows: 1 + flipbookColumns: 1 + maxTextureSizeSet: 0 + compressionQualitySet: 0 + textureFormatSet: 0 + ignorePngGamma: 0 + applyGammaDecoding: 0 + platformSettings: + - serializedVersion: 3 + buildTarget: DefaultTexturePlatform + maxTextureSize: 2048 + resizeAlgorithm: 0 + textureFormat: -1 + textureCompression: 1 + compressionQuality: 50 + crunchedCompression: 0 + allowsAlphaSplitting: 0 + overridden: 0 + androidETC2FallbackOverride: 0 + forceMaximumCompressionQuality_BC6H_BC7: 0 + spriteSheet: + serializedVersion: 2 + sprites: [] + outline: [] + physicsShape: [] + bones: [] + spriteID: + internalID: 0 + vertices: [] + indices: + edges: [] + weights: [] + secondaryTextures: [] + spritePackingTag: + pSDRemoveMatte: 0 + pSDShowRemoveMatteOption: 0 + userData: + assetBundleName: + assetBundleVariant: diff --git a/Scenes/PreviewScene/previewVolumeProfile.asset b/Scenes/PreviewScene/previewVolumeProfile.asset new file mode 100644 index 0000000..8e05d62 --- /dev/null +++ b/Scenes/PreviewScene/previewVolumeProfile.asset @@ -0,0 +1,609 @@ +%YAML 1.1 +%TAG !u! tag:unity3d.com,2011: +--- !u!114 &-5756600513109043636 +MonoBehaviour: + m_ObjectHideFlags: 3 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 0} + m_Enabled: 1 + m_EditorHideFlags: 0 + m_Script: {fileID: 11500000, guid: f034cba68ab55e046ae1445a42f18c0e, type: 3} + m_Name: IndirectLightingController + m_EditorClassIdentifier: + active: 1 + m_AdvancedMode: 0 + indirectDiffuseLightingMultiplier: + m_OverrideState: 1 + m_Value: 10 + min: 0 + indirectDiffuseLightingLayers: + m_OverrideState: 0 + m_Value: 255 + reflectionLightingMultiplier: + m_OverrideState: 1 + m_Value: 10 + min: 0 + reflectionLightingLayers: + m_OverrideState: 0 + m_Value: 255 + reflectionProbeIntensityMultiplier: + m_OverrideState: 0 + m_Value: 1 + min: 0 +--- !u!114 &-4758912127805933462 +MonoBehaviour: + m_ObjectHideFlags: 3 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 0} + m_Enabled: 1 + m_EditorHideFlags: 0 + m_Script: {fileID: 11500000, guid: 598e2d32e2c7b0c418e030c3236d663a, type: 3} + m_Name: ChromaticAberration + m_EditorClassIdentifier: + active: 1 + m_AdvancedMode: 0 + quality: + m_OverrideState: 1 + m_Value: 2 + spectralLut: + m_OverrideState: 0 + m_Value: {fileID: 0} + intensity: + m_OverrideState: 1 + m_Value: 0.15 + min: 0 + max: 1 + m_MaxSamples: + m_OverrideState: 1 + m_Value: 12 + min: 3 + max: 24 +--- !u!114 &-3614212076672368529 +MonoBehaviour: + m_ObjectHideFlags: 3 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 0} + m_Enabled: 1 + m_EditorHideFlags: 0 + m_Script: {fileID: 11500000, guid: 5e17fad69ea181b4483974138b566975, type: 3} + m_Name: ScreenSpaceRefraction + m_EditorClassIdentifier: + active: 1 + m_AdvancedMode: 0 + screenFadeDistance: + m_OverrideState: 1 + m_Value: 0.001 + min: 0.001 + max: 1 +--- !u!114 &-3594994451260070540 +MonoBehaviour: + m_ObjectHideFlags: 3 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 0} + m_Enabled: 1 + m_EditorHideFlags: 0 + m_Script: {fileID: 11500000, guid: 56b145d2b9ee1ac4f846968484e7485a, type: 3} + m_Name: ContactShadows + m_EditorClassIdentifier: + active: 1 + m_AdvancedMode: 0 + quality: + m_OverrideState: 1 + m_Value: 3 + enable: + m_OverrideState: 1 + m_Value: 1 + length: + m_OverrideState: 1 + m_Value: 0.5 + min: 0 + max: 1 + opacity: + m_OverrideState: 1 + m_Value: 0.501 + min: 0 + max: 1 + distanceScaleFactor: + m_OverrideState: 1 + m_Value: 0.5 + min: 0 + max: 1 + maxDistance: + m_OverrideState: 1 + m_Value: 50 + min: 0 + minDistance: + m_OverrideState: 1 + m_Value: 1 + min: 0 + fadeDistance: + m_OverrideState: 1 + m_Value: 5 + min: 0 + fadeInDistance: + m_OverrideState: 1 + m_Value: 0 + min: 0 + rayBias: + m_OverrideState: 1 + m_Value: 0.501 + min: 0 + max: 1 + thicknessScale: + m_OverrideState: 1 + m_Value: 0.1 + min: 0.02 + max: 1 + m_SampleCount: + m_OverrideState: 1 + m_Value: 10 + min: 4 + max: 64 +--- !u!114 &-1355376055549233226 +MonoBehaviour: + m_ObjectHideFlags: 3 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 0} + m_Enabled: 1 + m_EditorHideFlags: 0 + m_Script: {fileID: 11500000, guid: 9008a067f4d626c4d8bc4bc48f04bb89, type: 3} + m_Name: AmbientOcclusion + m_EditorClassIdentifier: + active: 1 + m_AdvancedMode: 0 + quality: + m_OverrideState: 1 + m_Value: 2 + rayTracing: + m_OverrideState: 0 + m_Value: 0 + intensity: + m_OverrideState: 1 + m_Value: 1.43 + min: 0 + max: 4 + directLightingStrength: + m_OverrideState: 1 + m_Value: 0.14 + min: 0 + max: 1 + radius: + m_OverrideState: 1 + m_Value: 0.66 + min: 0.25 + max: 5 + spatialBilateralAggressiveness: + m_OverrideState: 0 + m_Value: 0.15 + min: 0 + max: 1 + temporalAccumulation: + m_OverrideState: 0 + m_Value: 1 + ghostingReduction: + m_OverrideState: 0 + m_Value: 0.5 + min: 0 + max: 1 + blurSharpness: + m_OverrideState: 0 + m_Value: 0.1 + min: 0 + max: 1 + layerMask: + m_OverrideState: 0 + m_Value: + serializedVersion: 2 + m_Bits: 4294967295 + m_StepCount: + m_OverrideState: 1 + m_Value: 6 + min: 2 + max: 32 + m_FullResolution: + m_OverrideState: 1 + m_Value: 0 + m_MaximumRadiusInPixels: + m_OverrideState: 1 + m_Value: 40 + min: 16 + max: 256 + m_BilateralUpsample: + m_OverrideState: 1 + m_Value: 1 + m_DirectionCount: + m_OverrideState: 1 + m_Value: 2 + min: 1 + max: 6 + m_RayLength: + m_OverrideState: 1 + m_Value: 20 + min: 0 + m_SampleCount: + m_OverrideState: 1 + m_Value: 8 + min: 1 + max: 64 + m_Denoise: + m_OverrideState: 1 + m_Value: 1 + m_DenoiserRadius: + m_OverrideState: 1 + m_Value: 0.65 + min: 0.001 + max: 1 +--- !u!114 &-466525434632250678 +MonoBehaviour: + m_ObjectHideFlags: 3 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 0} + m_Enabled: 1 + m_EditorHideFlags: 0 + m_Script: {fileID: 11500000, guid: a81bcacc415a1f743bfdf703afc52027, type: 3} + m_Name: GradientSky + m_EditorClassIdentifier: + active: 1 + m_AdvancedMode: 0 + rotation: + m_OverrideState: 0 + m_Value: 0 + min: 0 + max: 360 + skyIntensityMode: + m_OverrideState: 1 + m_Value: 0 + exposure: + m_OverrideState: 1 + m_Value: 2 + multiplier: + m_OverrideState: 1 + m_Value: 2 + min: 0 + upperHemisphereLuxValue: + m_OverrideState: 0 + m_Value: 1 + min: 0 + upperHemisphereLuxColor: + m_OverrideState: 0 + m_Value: {x: 0, y: 0, z: 0} + desiredLuxValue: + m_OverrideState: 0 + m_Value: 20000 + updateMode: + m_OverrideState: 0 + m_Value: 0 + updatePeriod: + m_OverrideState: 0 + m_Value: 0 + min: 0 + includeSunInBaking: + m_OverrideState: 0 + m_Value: 0 + top: + m_OverrideState: 1 + m_Value: {r: 0, g: 0, b: 0, a: 1} + hdr: 1 + showAlpha: 0 + showEyeDropper: 1 + middle: + m_OverrideState: 1 + m_Value: {r: 0.5372549, g: 0.5372549, b: 0.5372549, a: 1} + hdr: 1 + showAlpha: 0 + showEyeDropper: 1 + bottom: + m_OverrideState: 1 + m_Value: {r: 0, g: 0, b: 0, a: 1} + hdr: 1 + showAlpha: 0 + showEyeDropper: 1 + gradientDiffusion: + m_OverrideState: 1 + m_Value: 4 +--- !u!114 &11400000 +MonoBehaviour: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 0} + m_Enabled: 1 + m_EditorHideFlags: 0 + m_Script: {fileID: 11500000, guid: d7fd9488000d3734a9e00ee676215985, type: 3} + m_Name: previewVolumeProfile + m_EditorClassIdentifier: + components: + - {fileID: 6742904436121154172} + - {fileID: -466525434632250678} + - {fileID: 4745465664678062571} + - {fileID: -3614212076672368529} + - {fileID: -3594994451260070540} + - {fileID: -4758912127805933462} + - {fileID: 8737792840871171769} + - {fileID: -1355376055549233226} + - {fileID: 7677725660589811616} + - {fileID: -5756600513109043636} +--- !u!114 &4745465664678062571 +MonoBehaviour: + m_ObjectHideFlags: 3 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 0} + m_Enabled: 1 + m_EditorHideFlags: 0 + m_Script: {fileID: 11500000, guid: 2d08ce26990eb1a4a9177b860541e702, type: 3} + m_Name: Exposure + m_EditorClassIdentifier: + active: 1 + m_AdvancedMode: 0 + mode: + m_OverrideState: 1 + m_Value: 0 + meteringMode: + m_OverrideState: 1 + m_Value: 0 + luminanceSource: + m_OverrideState: 0 + m_Value: 1 + fixedExposure: + m_OverrideState: 1 + m_Value: 3 + compensation: + m_OverrideState: 1 + m_Value: 0 + limitMin: + m_OverrideState: 1 + m_Value: 0.41981167 + limitMax: + m_OverrideState: 1 + m_Value: 10.488009 + curveMap: + m_OverrideState: 0 + m_Value: + serializedVersion: 2 + m_Curve: + - serializedVersion: 3 + time: -10 + value: -10 + inSlope: 0 + outSlope: 1 + tangentMode: 0 + weightedMode: 0 + inWeight: 0 + outWeight: 0 + - serializedVersion: 3 + time: 20 + value: 20 + inSlope: 1 + outSlope: 0 + tangentMode: 0 + weightedMode: 0 + inWeight: 0 + outWeight: 0 + m_PreInfinity: 2 + m_PostInfinity: 2 + m_RotationOrder: 4 + limitMinCurveMap: + m_OverrideState: 0 + m_Value: + serializedVersion: 2 + m_Curve: + - serializedVersion: 3 + time: -10 + value: -12 + inSlope: 0 + outSlope: 1 + tangentMode: 0 + weightedMode: 0 + inWeight: 0 + outWeight: 0 + - serializedVersion: 3 + time: 20 + value: 18 + inSlope: 1 + outSlope: 0 + tangentMode: 0 + weightedMode: 0 + inWeight: 0 + outWeight: 0 + m_PreInfinity: 2 + m_PostInfinity: 2 + m_RotationOrder: 4 + limitMaxCurveMap: + m_OverrideState: 0 + m_Value: + serializedVersion: 2 + m_Curve: + - serializedVersion: 3 + time: -10 + value: -8 + inSlope: 0 + outSlope: 1 + tangentMode: 0 + weightedMode: 0 + inWeight: 0 + outWeight: 0 + - serializedVersion: 3 + time: 20 + value: 22 + inSlope: 1 + outSlope: 0 + tangentMode: 0 + weightedMode: 0 + inWeight: 0 + outWeight: 0 + m_PreInfinity: 2 + m_PostInfinity: 2 + m_RotationOrder: 4 + adaptationMode: + m_OverrideState: 1 + m_Value: 1 + adaptationSpeedDarkToLight: + m_OverrideState: 1 + m_Value: 4 + min: 0.001 + adaptationSpeedLightToDark: + m_OverrideState: 1 + m_Value: 4 + min: 0.001 + weightTextureMask: + m_OverrideState: 0 + m_Value: {fileID: 0} + histogramPercentages: + m_OverrideState: 1 + m_Value: {x: 11.1951, y: 85.219604} + min: 0 + max: 100 + histogramUseCurveRemapping: + m_OverrideState: 1 + m_Value: 0 + targetMidGray: + m_OverrideState: 0 + m_Value: 0 + centerAroundExposureTarget: + m_OverrideState: 0 + m_Value: 0 + proceduralCenter: + m_OverrideState: 0 + m_Value: {x: 0.5, y: 0.5} + proceduralRadii: + m_OverrideState: 1 + m_Value: {x: 0.5, y: 0.5} + maskMinIntensity: + m_OverrideState: 0 + m_Value: -30 + maskMaxIntensity: + m_OverrideState: 0 + m_Value: 30 + proceduralSoftness: + m_OverrideState: 1 + m_Value: 1 + min: 0 +--- !u!114 &6742904436121154172 +MonoBehaviour: + m_ObjectHideFlags: 3 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 0} + m_Enabled: 1 + m_EditorHideFlags: 0 + m_Script: {fileID: 11500000, guid: 0d7593b3a9277ac4696b20006c21dde2, type: 3} + m_Name: + m_EditorClassIdentifier: + active: 1 + m_AdvancedMode: 0 + skyType: + m_OverrideState: 1 + m_Value: 3 + skyAmbientMode: + m_OverrideState: 1 + m_Value: 1 + fogType: + m_OverrideState: 1 + m_Value: 0 +--- !u!114 &7677725660589811616 +MonoBehaviour: + m_ObjectHideFlags: 3 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 0} + m_Enabled: 1 + m_EditorHideFlags: 0 + m_Script: {fileID: 11500000, guid: 4b8bcdf71d7fafa419fca1ed162f5fc9, type: 3} + m_Name: ColorAdjustments + m_EditorClassIdentifier: + active: 1 + m_AdvancedMode: 0 + postExposure: + m_OverrideState: 0 + m_Value: 0.2 + contrast: + m_OverrideState: 1 + m_Value: 10 + min: -100 + max: 100 + colorFilter: + m_OverrideState: 0 + m_Value: {r: 1, g: 1, b: 1, a: 1} + hdr: 1 + showAlpha: 0 + showEyeDropper: 1 + hueShift: + m_OverrideState: 0 + m_Value: 0 + min: -180 + max: 180 + saturation: + m_OverrideState: 0 + m_Value: 0 + min: -100 + max: 100 +--- !u!114 &8737792840871171769 +MonoBehaviour: + m_ObjectHideFlags: 3 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 0} + m_Enabled: 1 + m_EditorHideFlags: 0 + m_Script: {fileID: 11500000, guid: f086a068d4c5889438831b3ae9afc11c, type: 3} + m_Name: Tonemapping + m_EditorClassIdentifier: + active: 1 + m_AdvancedMode: 0 + mode: + m_OverrideState: 1 + m_Value: 2 + toeStrength: + m_OverrideState: 0 + m_Value: 0 + min: 0 + max: 1 + toeLength: + m_OverrideState: 0 + m_Value: 0.5 + min: 0 + max: 1 + shoulderStrength: + m_OverrideState: 0 + m_Value: 0 + min: 0 + max: 1 + shoulderLength: + m_OverrideState: 0 + m_Value: 0.5 + min: 0 + shoulderAngle: + m_OverrideState: 0 + m_Value: 0 + min: 0 + max: 1 + gamma: + m_OverrideState: 0 + m_Value: 1 + min: 0.001 + lutTexture: + m_OverrideState: 0 + m_Value: {fileID: 0} + lutContribution: + m_OverrideState: 0 + m_Value: 1 + min: 0 + max: 1 diff --git a/Scenes/PreviewScene/previewVolumeProfile.asset.meta b/Scenes/PreviewScene/previewVolumeProfile.asset.meta new file mode 100644 index 0000000..c6e10c0 --- /dev/null +++ b/Scenes/PreviewScene/previewVolumeProfile.asset.meta @@ -0,0 +1,8 @@ +fileFormatVersion: 2 +guid: 4a8c54a78ed444349bedaea62cec828f +NativeFormatImporter: + externalObjects: {} + mainObjectFileID: 11400000 + userData: + assetBundleName: + assetBundleVariant: diff --git a/Scenes/PreviewScenePrefab.prefab b/Scenes/PreviewScenePrefab.prefab new file mode 100644 index 0000000..4af032f --- /dev/null +++ b/Scenes/PreviewScenePrefab.prefab @@ -0,0 +1,1643 @@ +%YAML 1.1 +%TAG !u! tag:unity3d.com,2011: +--- !u!1 &140582583 +GameObject: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + serializedVersion: 6 + m_Component: + - component: {fileID: 140582587} + - component: {fileID: 140582586} + - component: {fileID: 140582585} + - component: {fileID: 140582584} + m_Layer: 0 + m_Name: Plane + m_TagString: Untagged + m_Icon: {fileID: 0} + m_NavMeshLayer: 0 + m_StaticEditorFlags: 0 + m_IsActive: 1 +--- !u!4 &140582587 +Transform: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 140582583} + m_LocalRotation: {x: -0, y: -0, z: -0, w: 1} + m_LocalPosition: {x: 0, y: 0, z: 0} + m_LocalScale: {x: 1, y: 1, z: 1} + m_Children: [] + m_Father: {fileID: 7745821555454708197} + m_RootOrder: 4 + m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0} +--- !u!33 &140582586 +MeshFilter: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 140582583} + m_Mesh: {fileID: 10209, guid: 0000000000000000e000000000000000, type: 0} +--- !u!23 &140582585 +MeshRenderer: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 140582583} + m_Enabled: 1 + m_CastShadows: 1 + m_ReceiveShadows: 1 + m_DynamicOccludee: 1 + m_MotionVectors: 1 + m_LightProbeUsage: 1 + m_ReflectionProbeUsage: 1 + m_RayTracingMode: 2 + m_RayTraceProcedural: 0 + m_RenderingLayerMask: 1 + m_RendererPriority: 0 + m_Materials: + - {fileID: 2100000, guid: 4ce5021a1900ab745a10e11db4f67b32, type: 2} + m_StaticBatchInfo: + firstSubMesh: 0 + subMeshCount: 0 + m_StaticBatchRoot: {fileID: 0} + m_ProbeAnchor: {fileID: 0} + m_LightProbeVolumeOverride: {fileID: 0} + m_ScaleInLightmap: 1 + m_ReceiveGI: 1 + m_PreserveUVs: 0 + m_IgnoreNormalsForChartDetection: 0 + m_ImportantGI: 0 + m_StitchLightmapSeams: 1 + m_SelectedEditorRenderState: 3 + m_MinimumChartSize: 4 + m_AutoUVMaxDistance: 0.5 + m_AutoUVMaxAngle: 89 + m_LightmapParameters: {fileID: 0} + m_SortingLayerID: 0 + m_SortingLayer: 0 + m_SortingOrder: 0 + m_AdditionalVertexStreams: {fileID: 0} +--- !u!64 &140582584 +MeshCollider: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 140582583} + m_Material: {fileID: 0} + m_IsTrigger: 0 + m_Enabled: 1 + serializedVersion: 4 + m_Convex: 0 + m_CookingOptions: 30 + m_Mesh: {fileID: 10209, guid: 0000000000000000e000000000000000, type: 0} +--- !u!1 &494497244 +GameObject: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + serializedVersion: 6 + m_Component: + - component: {fileID: 494497247} + - component: {fileID: 494497246} + - component: {fileID: 494497245} + m_Layer: 0 + m_Name: Reflection Probe + m_TagString: Untagged + m_Icon: {fileID: 0} + m_NavMeshLayer: 0 + m_StaticEditorFlags: 0 + m_IsActive: 1 +--- !u!4 &494497247 +Transform: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 494497244} + m_LocalRotation: {x: -0, y: -0, z: -0, w: 1} + m_LocalPosition: {x: 0, y: 1.9910369, z: 0} + m_LocalScale: {x: 1, y: 1, z: 1} + m_Children: [] + m_Father: {fileID: 7745821555454708197} + m_RootOrder: 3 + m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0} +--- !u!215 &494497246 +ReflectionProbe: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 494497244} + m_Enabled: 1 + serializedVersion: 2 + m_Type: 0 + m_Mode: 2 + m_RefreshMode: 2 + m_TimeSlicingMode: 0 + m_Resolution: 128 + m_UpdateFrequency: 0 + m_BoxSize: {x: 10, y: 4.118122, z: 10} + m_BoxOffset: {x: 0, y: 0, z: 0} + m_NearClip: 0.3 + m_FarClip: 1000 + m_ShadowDistance: 100 + m_ClearFlags: 1 + m_BackGroundColor: {r: 0.19215687, g: 0.3019608, b: 0.4745098, a: 0} + m_CullingMask: + serializedVersion: 2 + m_Bits: 4294967295 + m_IntensityMultiplier: 1 + m_BlendDistance: 0 + m_HDR: 1 + m_BoxProjection: 0 + m_RenderDynamicObjects: 0 + m_UseOcclusionCulling: 1 + m_Importance: 1 + m_CustomBakedTexture: {fileID: 0} +--- !u!114 &494497245 +MonoBehaviour: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 494497244} + m_Enabled: 1 + m_EditorHideFlags: 0 + m_Script: {fileID: 11500000, guid: d0ef8dc2c2eabfa4e8cb77be57a837c0, type: 3} + m_Name: + m_EditorClassIdentifier: + m_HDProbeVersion: 3 + m_ObsoleteInfiniteProjection: 1 + m_ObsoleteInfluenceVolume: + m_EditorAdvancedModeBlendDistancePositive: {x: 0, y: 0, z: 0} + m_EditorAdvancedModeBlendDistanceNegative: {x: 0, y: 0, z: 0} + m_EditorSimplifiedModeBlendDistance: 0 + m_EditorAdvancedModeBlendNormalDistancePositive: {x: 0, y: 0, z: 0} + m_EditorAdvancedModeBlendNormalDistanceNegative: {x: 0, y: 0, z: 0} + m_EditorSimplifiedModeBlendNormalDistance: 0 + m_EditorAdvancedModeEnabled: 0 + m_EditorAdvancedModeFaceFadePositive: {x: 1, y: 1, z: 1} + m_EditorAdvancedModeFaceFadeNegative: {x: 1, y: 1, z: 1} + m_Version: 1 + m_ObsoleteSphereBaseOffset: {x: 0, y: 0, z: 0} + m_ObsoleteOffset: {x: 0, y: 0, z: 0} + m_Shape: 0 + m_BoxSize: {x: 10, y: 10, z: 10} + m_BoxBlendDistancePositive: {x: 1, y: 1, z: 1} + m_BoxBlendDistanceNegative: {x: 1, y: 1, z: 1} + m_BoxBlendNormalDistancePositive: {x: 0, y: 0, z: 0} + m_BoxBlendNormalDistanceNegative: {x: 0, y: 0, z: 0} + m_BoxSideFadePositive: {x: 1, y: 1, z: 1} + m_BoxSideFadeNegative: {x: 1, y: 1, z: 1} + m_SphereRadius: 3 + m_SphereBlendDistance: 0 + m_SphereBlendNormalDistance: 0 + m_ObsoleteFrameSettings: + overrides: 0 + enableShadow: 0 + enableContactShadows: 0 + enableShadowMask: 0 + enableSSR: 0 + enableSSAO: 0 + enableSubsurfaceScattering: 0 + enableTransmission: 0 + enableAtmosphericScattering: 0 + enableVolumetrics: 0 + enableReprojectionForVolumetrics: 0 + enableLightLayers: 0 + enableExposureControl: 1 + diffuseGlobalDimmer: 0 + specularGlobalDimmer: 0 + shaderLitMode: 0 + enableDepthPrepassWithDeferredRendering: 0 + enableTransparentPrepass: 0 + enableMotionVectors: 0 + enableObjectMotionVectors: 0 + enableDecals: 0 + enableRoughRefraction: 0 + enableTransparentPostpass: 0 + enableDistortion: 0 + enablePostprocess: 0 + enableOpaqueObjects: 0 + enableTransparentObjects: 0 + enableRealtimePlanarReflection: 0 + enableMSAA: 0 + enableAsyncCompute: 0 + runLightListAsync: 0 + runSSRAsync: 0 + runSSAOAsync: 0 + runContactShadowsAsync: 0 + runVolumeVoxelizationAsync: 0 + lightLoopSettings: + overrides: 0 + enableDeferredTileAndCluster: 0 + enableComputeLightEvaluation: 0 + enableComputeLightVariants: 0 + enableComputeMaterialVariants: 0 + enableFptlForForwardOpaque: 0 + enableBigTilePrepass: 0 + isFptlEnabled: 0 + m_ObsoleteMultiplier: 1 + m_ObsoleteWeight: 1 + m_ObsoleteMode: 0 + m_ObsoleteLightLayers: 1 + m_ObsoleteCaptureSettings: + overrides: 0 + clearColorMode: 0 + backgroundColorHDR: {r: 0.023529412, g: 0.07058824, b: 0.1882353, a: 0} + clearDepth: 1 + cullingMask: + serializedVersion: 2 + m_Bits: 4294967295 + useOcclusionCulling: 1 + volumeLayerMask: + serializedVersion: 2 + m_Bits: 1 + volumeAnchorOverride: {fileID: 0} + projection: 0 + nearClipPlane: 0.3 + farClipPlane: 1000 + fieldOfView: 90 + orthographicSize: 5 + renderingPath: 0 + shadowDistance: 100 + m_ProbeSettings: + frustum: + fieldOfViewMode: 1 + fixedValue: 90 + automaticScale: 1 + viewerScale: 1 + type: 0 + mode: 0 + realtimeMode: 1 + lighting: + multiplier: 1 + weight: 1 + lightLayer: 1 + fadeDistance: 10000 + rangeCompressionFactor: 1 + influence: + m_EditorAdvancedModeBlendDistancePositive: {x: 1, y: 1, z: 1} + m_EditorAdvancedModeBlendDistanceNegative: {x: 1, y: 1, z: 1} + m_EditorSimplifiedModeBlendDistance: 5 + m_EditorAdvancedModeBlendNormalDistancePositive: {x: 0, y: 0, z: 0} + m_EditorAdvancedModeBlendNormalDistanceNegative: {x: 0, y: 0, z: 0} + m_EditorSimplifiedModeBlendNormalDistance: 0 + m_EditorAdvancedModeEnabled: 0 + m_EditorAdvancedModeFaceFadePositive: {x: 1, y: 1, z: 1} + m_EditorAdvancedModeFaceFadeNegative: {x: 1, y: 1, z: 1} + m_Version: 1 + m_ObsoleteSphereBaseOffset: {x: 0, y: 0, z: 0} + m_ObsoleteOffset: {x: 0, y: 0, z: 0} + m_Shape: 0 + m_BoxSize: {x: 10, y: 4.118122, z: 10} + m_BoxBlendDistancePositive: {x: 2.059061, y: 2.059061, z: 2.059061} + m_BoxBlendDistanceNegative: {x: 2.059061, y: 2.059061, z: 2.059061} + m_BoxBlendNormalDistancePositive: {x: 0, y: 0, z: 0} + m_BoxBlendNormalDistanceNegative: {x: 0, y: 0, z: 0} + m_BoxSideFadePositive: {x: 1, y: 1, z: 1} + m_BoxSideFadeNegative: {x: 1, y: 1, z: 1} + m_SphereRadius: 3 + m_SphereBlendDistance: 0 + m_SphereBlendNormalDistance: 0 + proxy: + m_CSVersion: 1 + m_ObsoleteSphereInfiniteProjection: 0 + m_ObsoleteBoxInfiniteProjection: 0 + m_Shape: 0 + m_BoxSize: {x: 1, y: 1, z: 1} + m_SphereRadius: 1 + proxySettings: + useInfluenceVolumeAsProxyVolume: 0 + capturePositionProxySpace: {x: 0, y: 0, z: 0} + captureRotationProxySpace: {x: 0, y: 0, z: 0, w: 1} + mirrorPositionProxySpace: {x: 0, y: 0, z: 0} + mirrorRotationProxySpace: {x: 0, y: 0, z: 0, w: 0} + resolutionScalable: + m_Override: 512 + m_UseOverride: 0 + m_Level: 0 + resolution: 0 + cameraSettings: + customRenderingSettings: 0 + renderingPathCustomFrameSettings: + bitDatas: + data1: 72198262773251917 + data2: 13763000468760363032 + lodBias: 1 + lodBiasMode: 0 + lodBiasQualityLevel: 0 + maximumLODLevel: 0 + maximumLODLevelMode: 0 + maximumLODLevelQualityLevel: 0 + sssQualityMode: 0 + sssQualityLevel: 0 + sssCustomSampleBudget: 20 + materialQuality: 0 + renderingPathCustomFrameSettingsOverrideMask: + mask: + data1: 0 + data2: 0 + bufferClearing: + clearColorMode: 0 + backgroundColorHDR: {r: 0.023529412, g: 0.07058824, b: 0.1882353, a: 0} + clearDepth: 1 + volumes: + layerMask: + serializedVersion: 2 + m_Bits: 1 + anchorOverride: {fileID: 0} + frustum: + mode: 0 + aspect: 1 + farClipPlaneRaw: 1000 + nearClipPlaneRaw: 0.3 + fieldOfView: 90 + projectionMatrix: + e00: 1 + e01: 0 + e02: 0 + e03: 0 + e10: 0 + e11: 1 + e12: 0 + e13: 0 + e20: 0 + e21: 0 + e22: 1 + e23: 0 + e30: 0 + e31: 0 + e32: 0 + e33: 1 + culling: + useOcclusionCulling: 1 + cullingMask: + serializedVersion: 2 + m_Bits: 4294967295 + sceneCullingMaskOverride: 0 + invertFaceCulling: 0 + flipYMode: 0 + probeLayerMask: + serializedVersion: 2 + m_Bits: 4294967295 + defaultFrameSettings: 0 + m_ObsoleteRenderingPath: 0 + m_ObsoleteFrameSettings: + overrides: 0 + enableShadow: 0 + enableContactShadows: 0 + enableShadowMask: 0 + enableSSR: 0 + enableSSAO: 0 + enableSubsurfaceScattering: 0 + enableTransmission: 0 + enableAtmosphericScattering: 0 + enableVolumetrics: 0 + enableReprojectionForVolumetrics: 0 + enableLightLayers: 0 + enableExposureControl: 1 + diffuseGlobalDimmer: 0 + specularGlobalDimmer: 0 + shaderLitMode: 0 + enableDepthPrepassWithDeferredRendering: 0 + enableTransparentPrepass: 0 + enableMotionVectors: 0 + enableObjectMotionVectors: 0 + enableDecals: 0 + enableRoughRefraction: 0 + enableTransparentPostpass: 0 + enableDistortion: 0 + enablePostprocess: 0 + enableOpaqueObjects: 0 + enableTransparentObjects: 0 + enableRealtimePlanarReflection: 0 + enableMSAA: 0 + enableAsyncCompute: 0 + runLightListAsync: 0 + runSSRAsync: 0 + runSSAOAsync: 0 + runContactShadowsAsync: 0 + runVolumeVoxelizationAsync: 0 + lightLoopSettings: + overrides: 0 + enableDeferredTileAndCluster: 0 + enableComputeLightEvaluation: 0 + enableComputeLightVariants: 0 + enableComputeMaterialVariants: 0 + enableFptlForForwardOpaque: 0 + enableBigTilePrepass: 0 + isFptlEnabled: 0 + roughReflections: 1 + distanceBasedRoughness: 0 + m_ProbeSettingsOverride: + probe: 0 + camera: + camera: 0 + m_ProxyVolume: {fileID: 1860914725} + m_BakedTexture: {fileID: 8900000, guid: 0b93c66b9c385ea4ea734dc76601ff3e, type: 3} + m_CustomTexture: {fileID: 0} + m_BakedRenderData: + m_WorldToCameraRHS: + e00: 0 + e01: 0 + e02: 0 + e03: 0 + e10: 0 + e11: 0 + e12: 0 + e13: 0 + e20: 0 + e21: 0 + e22: 0 + e23: 0 + e30: 0 + e31: 0 + e32: 0 + e33: 0 + m_ProjectionMatrix: + e00: 0 + e01: 0 + e02: 0 + e03: 0 + e10: 0 + e11: 0 + e12: 0 + e13: 0 + e20: 0 + e21: 0 + e22: 0 + e23: 0 + e30: 0 + e31: 0 + e32: 0 + e33: 0 + m_CapturePosition: {x: 0, y: 0, z: 0} + m_CaptureRotation: {x: 0, y: 0, z: 0, w: 0} + m_FieldOfView: 0 + m_Aspect: 0 + m_CustomRenderData: + m_WorldToCameraRHS: + e00: 0 + e01: 0 + e02: 0 + e03: 0 + e10: 0 + e11: 0 + e12: 0 + e13: 0 + e20: 0 + e21: 0 + e22: 0 + e23: 0 + e30: 0 + e31: 0 + e32: 0 + e33: 0 + m_ProjectionMatrix: + e00: 0 + e01: 0 + e02: 0 + e03: 0 + e10: 0 + e11: 0 + e12: 0 + e13: 0 + e20: 0 + e21: 0 + e22: 0 + e23: 0 + e30: 0 + e31: 0 + e32: 0 + e33: 0 + m_CapturePosition: {x: 0, y: 0, z: 0} + m_CaptureRotation: {x: 0, y: 0, z: 0, w: 0} + m_FieldOfView: 0 + m_Aspect: 0 + m_EditorOnlyData: 0 + m_ReflectionProbeVersion: 9 + m_ObsoleteInfluenceShape: 0 + m_ObsoleteInfluenceSphereRadius: 3 + m_ObsoleteBlendDistancePositive: {x: 1, y: 1, z: 1} + m_ObsoleteBlendDistanceNegative: {x: 1, y: 1, z: 1} + m_ObsoleteBlendNormalDistancePositive: {x: 0, y: 0, z: 0} + m_ObsoleteBlendNormalDistanceNegative: {x: 0, y: 0, z: 0} + m_ObsoleteBoxSideFadePositive: {x: 1, y: 1, z: 1} + m_ObsoleteBoxSideFadeNegative: {x: 1, y: 1, z: 1} +--- !u!1 &1509821796 +GameObject: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + serializedVersion: 6 + m_Component: + - component: {fileID: 1509821798} + - component: {fileID: 1509821797} + m_Layer: 0 + m_Name: Sky and Fog Volume + m_TagString: Untagged + m_Icon: {fileID: 0} + m_NavMeshLayer: 0 + m_StaticEditorFlags: 0 + m_IsActive: 1 +--- !u!4 &1509821798 +Transform: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 1509821796} + m_LocalRotation: {x: -0, y: -0, z: -0, w: 1} + m_LocalPosition: {x: 0, y: 0, z: 0} + m_LocalScale: {x: 1, y: 1, z: 1} + m_Children: [] + m_Father: {fileID: 3737093066198893668} + m_RootOrder: 3 + m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0} +--- !u!114 &1509821797 +MonoBehaviour: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 1509821796} + m_Enabled: 1 + m_EditorHideFlags: 0 + m_Script: {fileID: 11500000, guid: 172515602e62fb746b5d573b38a5fe58, type: 3} + m_Name: + m_EditorClassIdentifier: + isGlobal: 1 + priority: 0 + blendDistance: 0 + weight: 1 + sharedProfile: {fileID: 11400000, guid: 4a8c54a78ed444349bedaea62cec828f, type: 2} +--- !u!1 &1860914724 +GameObject: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + serializedVersion: 6 + m_Component: + - component: {fileID: 1860914729} + - component: {fileID: 1860914728} + - component: {fileID: 1860914727} + - component: {fileID: 1860914726} + - component: {fileID: 1860914725} + m_Layer: 0 + m_Name: Reflection Proxy Volume + m_TagString: Untagged + m_Icon: {fileID: 0} + m_NavMeshLayer: 0 + m_StaticEditorFlags: 0 + m_IsActive: 1 +--- !u!4 &1860914729 +Transform: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 1860914724} + m_LocalRotation: {x: -0, y: -0, z: -0, w: 1} + m_LocalPosition: {x: -0.0871705, y: 1.6952034, z: -0.087703735} + m_LocalScale: {x: 10, y: 10, z: 10} + m_Children: [] + m_Father: {fileID: 7745821555454708197} + m_RootOrder: 5 + m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0} +--- !u!33 &1860914728 +MeshFilter: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 1860914724} + m_Mesh: {fileID: 10202, guid: 0000000000000000e000000000000000, type: 0} +--- !u!23 &1860914727 +MeshRenderer: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 1860914724} + m_Enabled: 0 + m_CastShadows: 1 + m_ReceiveShadows: 1 + m_DynamicOccludee: 1 + m_MotionVectors: 1 + m_LightProbeUsage: 1 + m_ReflectionProbeUsage: 1 + m_RayTracingMode: 2 + m_RayTraceProcedural: 0 + m_RenderingLayerMask: 257 + m_RendererPriority: 0 + m_Materials: + - {fileID: 2100000, guid: 73c176f402d2c2f4d929aa5da7585d17, type: 2} + m_StaticBatchInfo: + firstSubMesh: 0 + subMeshCount: 0 + m_StaticBatchRoot: {fileID: 0} + m_ProbeAnchor: {fileID: 0} + m_LightProbeVolumeOverride: {fileID: 0} + m_ScaleInLightmap: 1 + m_ReceiveGI: 1 + m_PreserveUVs: 0 + m_IgnoreNormalsForChartDetection: 0 + m_ImportantGI: 0 + m_StitchLightmapSeams: 1 + m_SelectedEditorRenderState: 3 + m_MinimumChartSize: 4 + m_AutoUVMaxDistance: 0.5 + m_AutoUVMaxAngle: 89 + m_LightmapParameters: {fileID: 0} + m_SortingLayerID: 0 + m_SortingLayer: 0 + m_SortingOrder: 0 + m_AdditionalVertexStreams: {fileID: 0} +--- !u!65 &1860914726 +BoxCollider: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 1860914724} + m_Material: {fileID: 0} + m_IsTrigger: 1 + m_Enabled: 1 + serializedVersion: 2 + m_Size: {x: 1, y: 1, z: 1} + m_Center: {x: 0, y: 0, z: 0} +--- !u!114 &1860914725 +MonoBehaviour: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 1860914724} + m_Enabled: 1 + m_EditorHideFlags: 0 + m_Script: {fileID: 11500000, guid: d5c61b7a04f29ad49a0985f4fb6c436d, type: 3} + m_Name: + m_EditorClassIdentifier: + m_ProxyVolume: + m_CSVersion: 1 + m_ObsoleteSphereInfiniteProjection: 0 + m_ObsoleteBoxInfiniteProjection: 0 + m_Shape: 0 + m_BoxSize: {x: 1, y: 1, z: 1} + m_SphereRadius: 1 +--- !u!1 &2009223284 +GameObject: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + serializedVersion: 6 + m_Component: + - component: {fileID: 2009223285} + m_Layer: 0 + m_Name: Character Container + m_TagString: Untagged + m_Icon: {fileID: 0} + m_NavMeshLayer: 0 + m_StaticEditorFlags: 0 + m_IsActive: 1 +--- !u!4 &2009223285 +Transform: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 2009223284} + m_LocalRotation: {x: -0, y: -0, z: -0, w: 1} + m_LocalPosition: {x: 0, y: 0, z: 0} + m_LocalScale: {x: 1, y: 1, z: 1} + m_Children: [] + m_Father: {fileID: 3737093066198893668} + m_RootOrder: 2 + m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0} +--- !u!1 &2059096375 +GameObject: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + serializedVersion: 6 + m_Component: + - component: {fileID: 2059096378} + - component: {fileID: 2059096377} + - component: {fileID: 2059096376} + - component: {fileID: 2059096379} + m_Layer: 0 + m_Name: Main Camera + m_TagString: MainCamera + m_Icon: {fileID: 0} + m_NavMeshLayer: 0 + m_StaticEditorFlags: 0 + m_IsActive: 1 +--- !u!4 &2059096378 +Transform: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 2059096375} + m_LocalRotation: {x: -0.028312098, y: 0.96722096, z: -0.12580113, w: -0.21876028} + m_LocalPosition: {x: 0.52318436, y: 1.595138, z: 1.042582} + m_LocalScale: {x: 1, y: 1, z: 1} + m_Children: [] + m_Father: {fileID: 3737093066198893668} + m_RootOrder: 0 + m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0} +--- !u!20 &2059096377 +Camera: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 2059096375} + m_Enabled: 1 + serializedVersion: 2 + m_ClearFlags: 1 + m_BackGroundColor: {r: 0.19215687, g: 0.3019608, b: 0.4745098, a: 0} + m_projectionMatrixMode: 1 + m_GateFitMode: 2 + m_FOVAxisMode: 0 + m_SensorSize: {x: 36, y: 24} + m_LensShift: {x: 0, y: 0} + m_FocalLength: 50 + m_NormalizedViewPortRect: + serializedVersion: 2 + x: 0 + y: 0 + width: 1 + height: 1 + near clip plane: 0.3 + far clip plane: 1000 + field of view: 60 + orthographic: 0 + orthographic size: 5 + m_Depth: -1 + m_CullingMask: + serializedVersion: 2 + m_Bits: 4294967295 + m_RenderingPath: -1 + m_TargetTexture: {fileID: 0} + m_TargetDisplay: 0 + m_TargetEye: 3 + m_HDR: 0 + m_AllowMSAA: 0 + m_AllowDynamicResolution: 0 + m_ForceIntoRT: 0 + m_OcclusionCulling: 1 + m_StereoConvergence: 10 + m_StereoSeparation: 0.022 +--- !u!81 &2059096376 +AudioListener: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 2059096375} + m_Enabled: 1 +--- !u!114 &2059096379 +MonoBehaviour: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 2059096375} + m_Enabled: 1 + m_EditorHideFlags: 0 + m_Script: {fileID: 11500000, guid: 23c1ce4fb46143f46bc5cb5224c934f6, type: 3} + m_Name: + m_EditorClassIdentifier: + m_Version: 7 + m_ObsoleteRenderingPath: 0 + m_ObsoleteFrameSettings: + overrides: 0 + enableShadow: 0 + enableContactShadows: 0 + enableShadowMask: 0 + enableSSR: 0 + enableSSAO: 0 + enableSubsurfaceScattering: 0 + enableTransmission: 0 + enableAtmosphericScattering: 0 + enableVolumetrics: 0 + enableReprojectionForVolumetrics: 0 + enableLightLayers: 0 + enableExposureControl: 1 + diffuseGlobalDimmer: 0 + specularGlobalDimmer: 0 + shaderLitMode: 0 + enableDepthPrepassWithDeferredRendering: 0 + enableTransparentPrepass: 0 + enableMotionVectors: 0 + enableObjectMotionVectors: 0 + enableDecals: 0 + enableRoughRefraction: 0 + enableTransparentPostpass: 0 + enableDistortion: 0 + enablePostprocess: 0 + enableOpaqueObjects: 0 + enableTransparentObjects: 0 + enableRealtimePlanarReflection: 0 + enableMSAA: 0 + enableAsyncCompute: 0 + runLightListAsync: 0 + runSSRAsync: 0 + runSSAOAsync: 0 + runContactShadowsAsync: 0 + runVolumeVoxelizationAsync: 0 + lightLoopSettings: + overrides: 0 + enableDeferredTileAndCluster: 0 + enableComputeLightEvaluation: 0 + enableComputeLightVariants: 0 + enableComputeMaterialVariants: 0 + enableFptlForForwardOpaque: 0 + enableBigTilePrepass: 0 + isFptlEnabled: 0 + clearColorMode: 0 + backgroundColorHDR: {r: 0.025, g: 0.07, b: 0.19, a: 0} + clearDepth: 1 + volumeLayerMask: + serializedVersion: 2 + m_Bits: 1 + volumeAnchorOverride: {fileID: 0} + antialiasing: 2 + SMAAQuality: 2 + dithering: 0 + stopNaNs: 0 + taaSharpenStrength: 0.5 + TAAQuality: 1 + taaHistorySharpening: 0.35 + taaAntiFlicker: 0.5 + taaMotionVectorRejection: 0 + taaAntiHistoryRinging: 0 + physicalParameters: + m_Iso: 200 + m_ShutterSpeed: 0.005 + m_Aperture: 16 + m_BladeCount: 5 + m_Curvature: {x: 2, y: 11} + m_BarrelClipping: 0.25 + m_Anamorphism: 0 + flipYMode: 0 + xrRendering: 1 + fullscreenPassthrough: 0 + allowDynamicResolution: 0 + customRenderingSettings: 0 + invertFaceCulling: 0 + probeLayerMask: + serializedVersion: 2 + m_Bits: 4294967295 + hasPersistentHistory: 0 + exposureTarget: {fileID: 0} + m_RenderingPathCustomFrameSettings: + bitDatas: + data1: 72198262773251917 + data2: 13763000464465395712 + lodBias: 1 + lodBiasMode: 0 + lodBiasQualityLevel: 0 + maximumLODLevel: 0 + maximumLODLevelMode: 0 + maximumLODLevelQualityLevel: 0 + sssQualityMode: 0 + sssQualityLevel: 0 + sssCustomSampleBudget: 20 + materialQuality: 0 + renderingPathCustomFrameSettingsOverrideMask: + mask: + data1: 0 + data2: 0 + defaultFrameSettings: 0 +--- !u!1 &332079474543392766 +GameObject: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + serializedVersion: 6 + m_Component: + - component: {fileID: 3737093066198893668} + m_Layer: 0 + m_Name: PreviewScenePrefab + m_TagString: Untagged + m_Icon: {fileID: 0} + m_NavMeshLayer: 0 + m_StaticEditorFlags: 0 + m_IsActive: 1 +--- !u!4 &3737093066198893668 +Transform: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 332079474543392766} + m_LocalRotation: {x: 0, y: 0, z: 0, w: 1} + m_LocalPosition: {x: 0, y: 0, z: 0} + m_LocalScale: {x: 1, y: 1, z: 1} + m_Children: + - {fileID: 2059096378} + - {fileID: 7745821555454708197} + - {fileID: 2009223285} + - {fileID: 1509821798} + m_Father: {fileID: 0} + m_RootOrder: 0 + m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0} +--- !u!1 &1051193941811274113 +GameObject: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + serializedVersion: 6 + m_Component: + - component: {fileID: 1080182669305253312} + - component: {fileID: 9223163883438719360} + - component: {fileID: 7375704023635195177} + m_Layer: 0 + m_Name: Key1 + m_TagString: Untagged + m_Icon: {fileID: 0} + m_NavMeshLayer: 0 + m_StaticEditorFlags: 0 + m_IsActive: 1 +--- !u!4 &1080182669305253312 +Transform: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 1051193941811274113} + m_LocalRotation: {x: 0.9353448, y: 0.20450015, z: 0.20450015, w: 0.2036896} + m_LocalPosition: {x: -0.71149, y: 2.04134, z: 1.49019} + m_LocalScale: {x: 0.99999994, y: 1, z: 1} + m_Children: [] + m_Father: {fileID: 7745821555454708197} + m_RootOrder: 1 + m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0} +--- !u!108 &9223163883438719360 +Light: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 1051193941811274113} + m_Enabled: 1 + serializedVersion: 10 + m_Type: 0 + m_Shape: 0 + m_Color: {r: 1, g: 1, b: 1, a: 1} + m_Intensity: 79.57746 + m_Range: 9 + m_SpotAngle: 120 + m_InnerSpotAngle: 1 + m_CookieSize: 10 + m_Shadows: + m_Type: 2 + m_Resolution: -1 + m_CustomResolution: -1 + m_Strength: 1 + m_Bias: 0.05 + m_NormalBias: 0.4 + m_NearPlane: 0.2 + m_CullingMatrixOverride: + e00: 1 + e01: 0 + e02: 0 + e03: 0 + e10: 0 + e11: 1 + e12: 0 + e13: 0 + e20: 0 + e21: 0 + e22: 1 + e23: 0 + e30: 0 + e31: 0 + e32: 0 + e33: 1 + m_UseCullingMatrixOverride: 0 + m_Cookie: {fileID: 0} + m_DrawHalo: 0 + m_Flare: {fileID: 0} + m_RenderMode: 0 + m_CullingMask: + serializedVersion: 2 + m_Bits: 4294967295 + m_RenderingLayerMask: 1 + m_Lightmapping: 4 + m_LightShadowCasterMode: 2 + m_AreaSize: {x: 0.5, y: 0.5} + m_BounceIntensity: 1 + m_ColorTemperature: 6800 + m_UseColorTemperature: 1 + m_BoundingSphereOverride: {x: 0, y: 0, z: 0, w: 10} + m_UseBoundingSphereOverride: 0 + m_UseViewFrustumForShadowCasterCull: 1 + m_ShadowRadius: 0.25 + m_ShadowAngle: 0 +--- !u!114 &7375704023635195177 +MonoBehaviour: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 1051193941811274113} + m_Enabled: 1 + m_EditorHideFlags: 0 + m_Script: {fileID: 11500000, guid: 7a68c43fe1f2a47cfa234b5eeaa98012, type: 3} + m_Name: + m_EditorClassIdentifier: + m_Version: 11 + m_ObsoleteShadowResolutionTier: 1 + m_ObsoleteUseShadowQualitySettings: 0 + m_ObsoleteCustomShadowResolution: 512 + m_ObsoleteContactShadows: 0 + m_PointlightHDType: 0 + m_SpotLightShape: 0 + m_AreaLightShape: 0 + m_Intensity: 250 + m_EnableSpotReflector: 1 + m_LuxAtDistance: 1 + m_InnerSpotPercent: 50 + m_SpotIESCutoffPercent: 100 + m_LightDimmer: 1 + m_VolumetricDimmer: 1 + m_LightUnit: 0 + m_FadeDistance: 10000 + m_VolumetricFadeDistance: 10000 + m_AffectDiffuse: 1 + m_AffectSpecular: 1 + m_NonLightmappedOnly: 0 + m_ShapeWidth: 0.5 + m_ShapeHeight: 0.5 + m_AspectRatio: 1 + m_ShapeRadius: 0.25 + m_SoftnessScale: 1 + m_UseCustomSpotLightShadowCone: 0 + m_CustomSpotLightShadowCone: 1 + m_MaxSmoothness: 0.99 + m_ApplyRangeAttenuation: 1 + m_DisplayAreaLightEmissiveMesh: 0 + m_AreaLightCookie: {fileID: 0} + m_IESPoint: {fileID: 0} + m_IESSpot: {fileID: 0} + m_IncludeForRayTracing: 1 + m_AreaLightShadowCone: 120 + m_UseScreenSpaceShadows: 0 + m_InteractsWithSky: 1 + m_AngularDiameter: 0.5 + m_FlareSize: 2 + m_FlareTint: {r: 1, g: 1, b: 1, a: 1} + m_FlareFalloff: 4 + m_SurfaceTexture: {fileID: 0} + m_SurfaceTint: {r: 1, g: 1, b: 1, a: 1} + m_Distance: 1.5e+11 + m_UseRayTracedShadows: 0 + m_NumRayTracingSamples: 4 + m_FilterTracedShadow: 1 + m_FilterSizeTraced: 16 + m_SunLightConeAngle: 0.5 + m_LightShadowRadius: 0.5 + m_SemiTransparentShadow: 0 + m_ColorShadow: 1 + m_DistanceBasedFiltering: 0 + m_EvsmExponent: 15 + m_EvsmLightLeakBias: 0 + m_EvsmVarianceBias: 0.00001 + m_EvsmBlurPasses: 0 + m_LightlayersMask: 1 + m_LinkShadowLayers: 1 + m_ShadowNearPlane: 0.1 + m_BlockerSampleCount: 24 + m_FilterSampleCount: 16 + m_MinFilterSize: 0.1 + m_KernelSize: 5 + m_LightAngle: 1 + m_MaxDepthBias: 0.001 + m_ShadowResolution: + m_Override: 512 + m_UseOverride: 1 + m_Level: 0 + m_ShadowDimmer: 1 + m_VolumetricShadowDimmer: 1 + m_ShadowFadeDistance: 10000 + m_UseContactShadow: + m_Override: 1 + m_UseOverride: 0 + m_Level: 2 + m_RayTracedContactShadow: 0 + m_ShadowTint: {r: 0, g: 0, b: 0, a: 1} + m_PenumbraTint: 0 + m_NormalBias: 0.75 + m_SlopeBias: 0.5 + m_ShadowUpdateMode: 0 + m_AlwaysDrawDynamicShadows: 0 + m_UpdateShadowOnLightMovement: 0 + m_CachedShadowTranslationThreshold: 0.01 + m_CachedShadowAngularThreshold: 0.5 + m_BarnDoorAngle: 90 + m_BarnDoorLength: 0.05 + m_preserveCachedShadow: 0 + m_ShadowCascadeRatios: + - 0.05 + - 0.2 + - 0.3 + m_ShadowCascadeBorders: + - 0.2 + - 0.2 + - 0.2 + - 0.2 + m_ShadowAlgorithm: 0 + m_ShadowVariant: 0 + m_ShadowPrecision: 0 + useOldInspector: 0 + useVolumetric: 1 + featuresFoldout: 1 + showAdditionalSettings: 0 + m_AreaLightEmissiveMeshShadowCastingMode: 0 + m_AreaLightEmissiveMeshMotionVectorGenerationMode: 0 + m_AreaLightEmissiveMeshLayer: -1 +--- !u!1 &2831752391173089184 +GameObject: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + serializedVersion: 6 + m_Component: + - component: {fileID: 37565078320470209} + - component: {fileID: 4750504114698822654} + - component: {fileID: 6218605643134089497} + m_Layer: 0 + m_Name: Key2 + m_TagString: Untagged + m_Icon: {fileID: 0} + m_NavMeshLayer: 0 + m_StaticEditorFlags: 0 + m_IsActive: 1 +--- !u!4 &37565078320470209 +Transform: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 2831752391173089184} + m_LocalRotation: {x: 0.91548073, y: 0.28117004, z: 0.28116998, w: -0.06149787} + m_LocalPosition: {x: -0.63999, y: 0.1199, z: 1.36} + m_LocalScale: {x: 1, y: 1, z: 0.99999994} + m_Children: [] + m_Father: {fileID: 7745821555454708197} + m_RootOrder: 2 + m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0} +--- !u!108 &4750504114698822654 +Light: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 2831752391173089184} + m_Enabled: 1 + serializedVersion: 10 + m_Type: 0 + m_Shape: 0 + m_Color: {r: 1, g: 1, b: 1, a: 1} + m_Intensity: 79.57746 + m_Range: 9 + m_SpotAngle: 120 + m_InnerSpotAngle: 1 + m_CookieSize: 10 + m_Shadows: + m_Type: 2 + m_Resolution: -1 + m_CustomResolution: -1 + m_Strength: 1 + m_Bias: 0.05 + m_NormalBias: 0.4 + m_NearPlane: 0.2 + m_CullingMatrixOverride: + e00: 1 + e01: 0 + e02: 0 + e03: 0 + e10: 0 + e11: 1 + e12: 0 + e13: 0 + e20: 0 + e21: 0 + e22: 1 + e23: 0 + e30: 0 + e31: 0 + e32: 0 + e33: 1 + m_UseCullingMatrixOverride: 0 + m_Cookie: {fileID: 0} + m_DrawHalo: 0 + m_Flare: {fileID: 0} + m_RenderMode: 0 + m_CullingMask: + serializedVersion: 2 + m_Bits: 4294967295 + m_RenderingLayerMask: 1 + m_Lightmapping: 4 + m_LightShadowCasterMode: 2 + m_AreaSize: {x: 0.5, y: 0.5} + m_BounceIntensity: 1 + m_ColorTemperature: 6800 + m_UseColorTemperature: 1 + m_BoundingSphereOverride: {x: 0, y: 0, z: 0, w: 10} + m_UseBoundingSphereOverride: 0 + m_UseViewFrustumForShadowCasterCull: 1 + m_ShadowRadius: 0.25 + m_ShadowAngle: 0 +--- !u!114 &6218605643134089497 +MonoBehaviour: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 2831752391173089184} + m_Enabled: 1 + m_EditorHideFlags: 0 + m_Script: {fileID: 11500000, guid: 7a68c43fe1f2a47cfa234b5eeaa98012, type: 3} + m_Name: + m_EditorClassIdentifier: + m_Version: 11 + m_ObsoleteShadowResolutionTier: 1 + m_ObsoleteUseShadowQualitySettings: 0 + m_ObsoleteCustomShadowResolution: 512 + m_ObsoleteContactShadows: 0 + m_PointlightHDType: 0 + m_SpotLightShape: 0 + m_AreaLightShape: 0 + m_Intensity: 250 + m_EnableSpotReflector: 1 + m_LuxAtDistance: 1 + m_InnerSpotPercent: 50 + m_SpotIESCutoffPercent: 100 + m_LightDimmer: 1 + m_VolumetricDimmer: 1 + m_LightUnit: 0 + m_FadeDistance: 10000 + m_VolumetricFadeDistance: 10000 + m_AffectDiffuse: 1 + m_AffectSpecular: 1 + m_NonLightmappedOnly: 0 + m_ShapeWidth: 0.5 + m_ShapeHeight: 0.5 + m_AspectRatio: 1 + m_ShapeRadius: 0.25 + m_SoftnessScale: 1 + m_UseCustomSpotLightShadowCone: 0 + m_CustomSpotLightShadowCone: 1 + m_MaxSmoothness: 0.99 + m_ApplyRangeAttenuation: 1 + m_DisplayAreaLightEmissiveMesh: 0 + m_AreaLightCookie: {fileID: 0} + m_IESPoint: {fileID: 0} + m_IESSpot: {fileID: 0} + m_IncludeForRayTracing: 1 + m_AreaLightShadowCone: 120 + m_UseScreenSpaceShadows: 0 + m_InteractsWithSky: 1 + m_AngularDiameter: 0.5 + m_FlareSize: 2 + m_FlareTint: {r: 1, g: 1, b: 1, a: 1} + m_FlareFalloff: 4 + m_SurfaceTexture: {fileID: 0} + m_SurfaceTint: {r: 1, g: 1, b: 1, a: 1} + m_Distance: 1.5e+11 + m_UseRayTracedShadows: 0 + m_NumRayTracingSamples: 4 + m_FilterTracedShadow: 1 + m_FilterSizeTraced: 16 + m_SunLightConeAngle: 0.5 + m_LightShadowRadius: 0.5 + m_SemiTransparentShadow: 0 + m_ColorShadow: 1 + m_DistanceBasedFiltering: 0 + m_EvsmExponent: 15 + m_EvsmLightLeakBias: 0 + m_EvsmVarianceBias: 0.00001 + m_EvsmBlurPasses: 0 + m_LightlayersMask: 1 + m_LinkShadowLayers: 1 + m_ShadowNearPlane: 0.1 + m_BlockerSampleCount: 24 + m_FilterSampleCount: 16 + m_MinFilterSize: 0.1 + m_KernelSize: 5 + m_LightAngle: 1 + m_MaxDepthBias: 0.001 + m_ShadowResolution: + m_Override: 512 + m_UseOverride: 1 + m_Level: 0 + m_ShadowDimmer: 1 + m_VolumetricShadowDimmer: 1 + m_ShadowFadeDistance: 10000 + m_UseContactShadow: + m_Override: 1 + m_UseOverride: 0 + m_Level: 2 + m_RayTracedContactShadow: 0 + m_ShadowTint: {r: 0, g: 0, b: 0, a: 1} + m_PenumbraTint: 0 + m_NormalBias: 0.75 + m_SlopeBias: 0.5 + m_ShadowUpdateMode: 0 + m_AlwaysDrawDynamicShadows: 0 + m_UpdateShadowOnLightMovement: 0 + m_CachedShadowTranslationThreshold: 0.01 + m_CachedShadowAngularThreshold: 0.5 + m_BarnDoorAngle: 90 + m_BarnDoorLength: 0.05 + m_preserveCachedShadow: 0 + m_ShadowCascadeRatios: + - 0.05 + - 0.2 + - 0.3 + m_ShadowCascadeBorders: + - 0.2 + - 0.2 + - 0.2 + - 0.2 + m_ShadowAlgorithm: 0 + m_ShadowVariant: 0 + m_ShadowPrecision: 0 + useOldInspector: 0 + useVolumetric: 1 + featuresFoldout: 1 + showAdditionalSettings: 0 + m_AreaLightEmissiveMeshShadowCastingMode: 0 + m_AreaLightEmissiveMeshMotionVectorGenerationMode: 0 + m_AreaLightEmissiveMeshLayer: -1 +--- !u!1 &3790502862561998288 +GameObject: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + serializedVersion: 6 + m_Component: + - component: {fileID: 2569123291528499557} + - component: {fileID: 773716982743449794} + - component: {fileID: 343734690788986213} + m_Layer: 0 + m_Name: Back + m_TagString: Untagged + m_Icon: {fileID: 0} + m_NavMeshLayer: 0 + m_StaticEditorFlags: 0 + m_IsActive: 1 +--- !u!4 &2569123291528499557 +Transform: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 3790502862561998288} + m_LocalRotation: {x: 0.13143855, y: -0.010624347, z: 0.05923246, w: 0.9894962} + m_LocalPosition: {x: -0, y: 1.69, z: -2.0199} + m_LocalScale: {x: 1, y: 1, z: 1} + m_Children: [] + m_Father: {fileID: 7745821555454708197} + m_RootOrder: 0 + m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0} +--- !u!108 &773716982743449794 +Light: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 3790502862561998288} + m_Enabled: 1 + serializedVersion: 10 + m_Type: 0 + m_Shape: 0 + m_Color: {r: 1, g: 1, b: 1, a: 1} + m_Intensity: 127.323944 + m_Range: 9 + m_SpotAngle: 120 + m_InnerSpotAngle: 1 + m_CookieSize: 10 + m_Shadows: + m_Type: 2 + m_Resolution: -1 + m_CustomResolution: -1 + m_Strength: 1 + m_Bias: 0.05 + m_NormalBias: 0.4 + m_NearPlane: 0.2 + m_CullingMatrixOverride: + e00: 1 + e01: 0 + e02: 0 + e03: 0 + e10: 0 + e11: 1 + e12: 0 + e13: 0 + e20: 0 + e21: 0 + e22: 1 + e23: 0 + e30: 0 + e31: 0 + e32: 0 + e33: 1 + m_UseCullingMatrixOverride: 0 + m_Cookie: {fileID: 0} + m_DrawHalo: 0 + m_Flare: {fileID: 0} + m_RenderMode: 0 + m_CullingMask: + serializedVersion: 2 + m_Bits: 4294967295 + m_RenderingLayerMask: 1 + m_Lightmapping: 4 + m_LightShadowCasterMode: 2 + m_AreaSize: {x: 0.5, y: 0.5} + m_BounceIntensity: 1 + m_ColorTemperature: 6800 + m_UseColorTemperature: 1 + m_BoundingSphereOverride: {x: 0, y: 0, z: 0, w: 10} + m_UseBoundingSphereOverride: 0 + m_UseViewFrustumForShadowCasterCull: 1 + m_ShadowRadius: 0.5 + m_ShadowAngle: 0 +--- !u!114 &343734690788986213 +MonoBehaviour: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 3790502862561998288} + m_Enabled: 1 + m_EditorHideFlags: 0 + m_Script: {fileID: 11500000, guid: 7a68c43fe1f2a47cfa234b5eeaa98012, type: 3} + m_Name: + m_EditorClassIdentifier: + m_Version: 11 + m_ObsoleteShadowResolutionTier: 1 + m_ObsoleteUseShadowQualitySettings: 0 + m_ObsoleteCustomShadowResolution: 512 + m_ObsoleteContactShadows: 0 + m_PointlightHDType: 0 + m_SpotLightShape: 0 + m_AreaLightShape: 0 + m_Intensity: 400 + m_EnableSpotReflector: 1 + m_LuxAtDistance: 1 + m_InnerSpotPercent: 50 + m_SpotIESCutoffPercent: 100 + m_LightDimmer: 1 + m_VolumetricDimmer: 1 + m_LightUnit: 0 + m_FadeDistance: 10000 + m_VolumetricFadeDistance: 10000 + m_AffectDiffuse: 1 + m_AffectSpecular: 1 + m_NonLightmappedOnly: 0 + m_ShapeWidth: 0.5 + m_ShapeHeight: 0.5 + m_AspectRatio: 1 + m_ShapeRadius: 0.5 + m_SoftnessScale: 1 + m_UseCustomSpotLightShadowCone: 0 + m_CustomSpotLightShadowCone: 1 + m_MaxSmoothness: 0.99 + m_ApplyRangeAttenuation: 1 + m_DisplayAreaLightEmissiveMesh: 0 + m_AreaLightCookie: {fileID: 0} + m_IESPoint: {fileID: 0} + m_IESSpot: {fileID: 0} + m_IncludeForRayTracing: 1 + m_AreaLightShadowCone: 120 + m_UseScreenSpaceShadows: 0 + m_InteractsWithSky: 1 + m_AngularDiameter: 0.5 + m_FlareSize: 2 + m_FlareTint: {r: 1, g: 1, b: 1, a: 1} + m_FlareFalloff: 4 + m_SurfaceTexture: {fileID: 0} + m_SurfaceTint: {r: 1, g: 1, b: 1, a: 1} + m_Distance: 1.5e+11 + m_UseRayTracedShadows: 0 + m_NumRayTracingSamples: 4 + m_FilterTracedShadow: 1 + m_FilterSizeTraced: 16 + m_SunLightConeAngle: 0.5 + m_LightShadowRadius: 0.5 + m_SemiTransparentShadow: 0 + m_ColorShadow: 1 + m_DistanceBasedFiltering: 0 + m_EvsmExponent: 15 + m_EvsmLightLeakBias: 0 + m_EvsmVarianceBias: 0.00001 + m_EvsmBlurPasses: 0 + m_LightlayersMask: 1 + m_LinkShadowLayers: 1 + m_ShadowNearPlane: 0.1 + m_BlockerSampleCount: 24 + m_FilterSampleCount: 16 + m_MinFilterSize: 0.1 + m_KernelSize: 5 + m_LightAngle: 1 + m_MaxDepthBias: 0.001 + m_ShadowResolution: + m_Override: 512 + m_UseOverride: 1 + m_Level: 0 + m_ShadowDimmer: 1 + m_VolumetricShadowDimmer: 1 + m_ShadowFadeDistance: 10000 + m_UseContactShadow: + m_Override: 1 + m_UseOverride: 0 + m_Level: 2 + m_RayTracedContactShadow: 0 + m_ShadowTint: {r: 0, g: 0, b: 0, a: 1} + m_PenumbraTint: 0 + m_NormalBias: 0.75 + m_SlopeBias: 0.5 + m_ShadowUpdateMode: 0 + m_AlwaysDrawDynamicShadows: 0 + m_UpdateShadowOnLightMovement: 0 + m_CachedShadowTranslationThreshold: 0.01 + m_CachedShadowAngularThreshold: 0.5 + m_BarnDoorAngle: 90 + m_BarnDoorLength: 0.05 + m_preserveCachedShadow: 0 + m_ShadowCascadeRatios: + - 0.05 + - 0.2 + - 0.3 + m_ShadowCascadeBorders: + - 0.2 + - 0.2 + - 0.2 + - 0.2 + m_ShadowAlgorithm: 0 + m_ShadowVariant: 0 + m_ShadowPrecision: 0 + useOldInspector: 0 + useVolumetric: 1 + featuresFoldout: 1 + showAdditionalSettings: 0 + m_AreaLightEmissiveMeshShadowCastingMode: 0 + m_AreaLightEmissiveMeshMotionVectorGenerationMode: 0 + m_AreaLightEmissiveMeshLayer: -1 +--- !u!1 &6932586869326697311 +GameObject: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + serializedVersion: 6 + m_Component: + - component: {fileID: 7745821555454708197} + m_Layer: 0 + m_Name: Scene + m_TagString: Untagged + m_Icon: {fileID: 0} + m_NavMeshLayer: 0 + m_StaticEditorFlags: 0 + m_IsActive: 1 +--- !u!4 &7745821555454708197 +Transform: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 6932586869326697311} + m_LocalRotation: {x: -0, y: -0, z: -0, w: 1} + m_LocalPosition: {x: 0, y: 0, z: 0} + m_LocalScale: {x: 1, y: 1, z: 1} + m_Children: + - {fileID: 2569123291528499557} + - {fileID: 1080182669305253312} + - {fileID: 37565078320470209} + - {fileID: 494497247} + - {fileID: 140582587} + - {fileID: 1860914729} + m_Father: {fileID: 3737093066198893668} + m_RootOrder: 1 + m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0} diff --git a/Scenes/PreviewScenePrefab.prefab.meta b/Scenes/PreviewScenePrefab.prefab.meta new file mode 100644 index 0000000..b78f342 --- /dev/null +++ b/Scenes/PreviewScenePrefab.prefab.meta @@ -0,0 +1,7 @@ +fileFormatVersion: 2 +guid: d68c18d6affcb744a9e2642485d8fe1e +PrefabImporter: + externalObjects: {} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Textures.meta b/Textures.meta new file mode 100644 index 0000000..063552b --- /dev/null +++ b/Textures.meta @@ -0,0 +1,8 @@ +fileFormatVersion: 2 +guid: c6307c34c8020834693c306a66fbf4ce +folderAsset: yes +DefaultImporter: + externalObjects: {} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Textures/EyeOcclusion.png b/Textures/EyeOcclusion.png new file mode 100644 index 0000000..093319f Binary files /dev/null and b/Textures/EyeOcclusion.png differ diff --git a/Textures/EyeOcclusion.png.meta b/Textures/EyeOcclusion.png.meta new file mode 100644 index 0000000..96a5745 --- /dev/null +++ b/Textures/EyeOcclusion.png.meta @@ -0,0 +1,108 @@ +fileFormatVersion: 2 +guid: 230860268a3447e4580272984b20846a +TextureImporter: + internalIDToNameTable: [] + externalObjects: {} + serializedVersion: 11 + mipmaps: + mipMapMode: 0 + enableMipMap: 1 + sRGBTexture: 1 + linearTexture: 0 + fadeOut: 0 + borderMipMap: 0 + mipMapsPreserveCoverage: 0 + alphaTestReferenceValue: 0.5 + mipMapFadeDistanceStart: 1 + mipMapFadeDistanceEnd: 3 + bumpmap: + convertToNormalMap: 0 + externalNormalMap: 0 + heightScale: 0.25 + normalMapFilter: 0 + isReadable: 0 + streamingMipmaps: 0 + streamingMipmapsPriority: 0 + vTOnly: 0 + grayScaleToAlpha: 0 + generateCubemap: 6 + cubemapConvolution: 0 + seamlessCubemap: 0 + textureFormat: 1 + maxTextureSize: 2048 + textureSettings: + serializedVersion: 2 + filterMode: 1 + aniso: 1 + mipBias: 0 + wrapU: 1 + wrapV: 1 + wrapW: 1 + nPOTScale: 1 + lightmap: 0 + compressionQuality: 50 + spriteMode: 0 + spriteExtrude: 1 + spriteMeshType: 1 + alignment: 0 + spritePivot: {x: 0.5, y: 0.5} + spritePixelsToUnits: 100 + spriteBorder: {x: 0, y: 0, z: 0, w: 0} + spriteGenerateFallbackPhysicsShape: 1 + alphaUsage: 1 + alphaIsTransparency: 0 + spriteTessellationDetail: -1 + textureType: 0 + textureShape: 1 + singleChannelComponent: 0 + flipbookRows: 1 + flipbookColumns: 1 + maxTextureSizeSet: 0 + compressionQualitySet: 0 + textureFormatSet: 0 + ignorePngGamma: 0 + applyGammaDecoding: 0 + platformSettings: + - serializedVersion: 3 + buildTarget: DefaultTexturePlatform + maxTextureSize: 2048 + resizeAlgorithm: 0 + textureFormat: -1 + textureCompression: 1 + compressionQuality: 50 + crunchedCompression: 0 + allowsAlphaSplitting: 0 + overridden: 0 + androidETC2FallbackOverride: 0 + forceMaximumCompressionQuality_BC6H_BC7: 0 + - serializedVersion: 3 + buildTarget: Standalone + maxTextureSize: 2048 + resizeAlgorithm: 0 + textureFormat: -1 + textureCompression: 1 + compressionQuality: 50 + crunchedCompression: 0 + allowsAlphaSplitting: 0 + overridden: 0 + androidETC2FallbackOverride: 0 + forceMaximumCompressionQuality_BC6H_BC7: 0 + spriteSheet: + serializedVersion: 2 + sprites: [] + outline: [] + physicsShape: [] + bones: [] + spriteID: + internalID: 0 + vertices: [] + indices: + edges: [] + weights: [] + secondaryTextures: [] + spritePackingTag: + pSDRemoveMatte: 0 + pSDShowRemoveMatteOption: 0 + userData: + assetBundleName: + assetBundleVariant: diff --git a/Textures/IrisDisplacement.hdr b/Textures/IrisDisplacement.hdr new file mode 100644 index 0000000..867d946 Binary files /dev/null and b/Textures/IrisDisplacement.hdr differ diff --git a/Textures/IrisDisplacement.hdr.meta b/Textures/IrisDisplacement.hdr.meta new file mode 100644 index 0000000..053eee2 --- /dev/null +++ b/Textures/IrisDisplacement.hdr.meta @@ -0,0 +1,108 @@ +fileFormatVersion: 2 +guid: 4809c10b14c13fe4c88679de3360b290 +TextureImporter: + internalIDToNameTable: [] + externalObjects: {} + serializedVersion: 11 + mipmaps: + mipMapMode: 0 + enableMipMap: 1 + sRGBTexture: 1 + linearTexture: 0 + fadeOut: 0 + borderMipMap: 0 + mipMapsPreserveCoverage: 0 + alphaTestReferenceValue: 0.5 + mipMapFadeDistanceStart: 1 + mipMapFadeDistanceEnd: 3 + bumpmap: + convertToNormalMap: 0 + externalNormalMap: 0 + heightScale: 0.25 + normalMapFilter: 0 + isReadable: 0 + streamingMipmaps: 0 + streamingMipmapsPriority: 0 + vTOnly: 0 + grayScaleToAlpha: 0 + generateCubemap: 6 + cubemapConvolution: 0 + seamlessCubemap: 0 + textureFormat: 1 + maxTextureSize: 2048 + textureSettings: + serializedVersion: 2 + filterMode: 1 + aniso: 1 + mipBias: 0 + wrapU: 1 + wrapV: 1 + wrapW: 1 + nPOTScale: 1 + lightmap: 0 + compressionQuality: 50 + spriteMode: 0 + spriteExtrude: 1 + spriteMeshType: 1 + alignment: 0 + spritePivot: {x: 0.5, y: 0.5} + spritePixelsToUnits: 100 + spriteBorder: {x: 0, y: 0, z: 0, w: 0} + spriteGenerateFallbackPhysicsShape: 1 + alphaUsage: 1 + alphaIsTransparency: 0 + spriteTessellationDetail: -1 + textureType: 0 + textureShape: 1 + singleChannelComponent: 0 + flipbookRows: 1 + flipbookColumns: 1 + maxTextureSizeSet: 0 + compressionQualitySet: 0 + textureFormatSet: 0 + ignorePngGamma: 0 + applyGammaDecoding: 0 + platformSettings: + - serializedVersion: 3 + buildTarget: DefaultTexturePlatform + maxTextureSize: 2048 + resizeAlgorithm: 0 + textureFormat: -1 + textureCompression: 1 + compressionQuality: 50 + crunchedCompression: 0 + allowsAlphaSplitting: 0 + overridden: 0 + androidETC2FallbackOverride: 0 + forceMaximumCompressionQuality_BC6H_BC7: 0 + - serializedVersion: 3 + buildTarget: Standalone + maxTextureSize: 2048 + resizeAlgorithm: 0 + textureFormat: -1 + textureCompression: 1 + compressionQuality: 50 + crunchedCompression: 0 + allowsAlphaSplitting: 0 + overridden: 0 + androidETC2FallbackOverride: 0 + forceMaximumCompressionQuality_BC6H_BC7: 0 + spriteSheet: + serializedVersion: 2 + sprites: [] + outline: [] + physicsShape: [] + bones: [] + spriteID: + internalID: 0 + vertices: [] + indices: + edges: [] + weights: [] + secondaryTextures: [] + spritePackingTag: + pSDRemoveMatte: 0 + pSDShowRemoveMatteOption: 0 + userData: + assetBundleName: + assetBundleVariant: diff --git a/Textures/RL_Default_EyeOcclusion.png b/Textures/RL_Default_EyeOcclusion.png new file mode 100644 index 0000000..d1b98ef Binary files /dev/null and b/Textures/RL_Default_EyeOcclusion.png differ diff --git a/Textures/RL_Default_EyeOcclusion.png.meta b/Textures/RL_Default_EyeOcclusion.png.meta new file mode 100644 index 0000000..adefb45 --- /dev/null +++ b/Textures/RL_Default_EyeOcclusion.png.meta @@ -0,0 +1,120 @@ +fileFormatVersion: 2 +guid: de8717c950fc50a4a837155e7e31cae2 +TextureImporter: + internalIDToNameTable: [] + externalObjects: {} + serializedVersion: 11 + mipmaps: + mipMapMode: 0 + enableMipMap: 1 + sRGBTexture: 1 + linearTexture: 0 + fadeOut: 0 + borderMipMap: 0 + mipMapsPreserveCoverage: 0 + alphaTestReferenceValue: 0.5 + mipMapFadeDistanceStart: 1 + mipMapFadeDistanceEnd: 3 + bumpmap: + convertToNormalMap: 0 + externalNormalMap: 0 + heightScale: 0.25 + normalMapFilter: 0 + isReadable: 0 + streamingMipmaps: 0 + streamingMipmapsPriority: 0 + vTOnly: 0 + grayScaleToAlpha: 0 + generateCubemap: 6 + cubemapConvolution: 0 + seamlessCubemap: 0 + textureFormat: 1 + maxTextureSize: 2048 + textureSettings: + serializedVersion: 2 + filterMode: 1 + aniso: 1 + mipBias: 0 + wrapU: 0 + wrapV: 0 + wrapW: 0 + nPOTScale: 1 + lightmap: 0 + compressionQuality: 50 + spriteMode: 0 + spriteExtrude: 1 + spriteMeshType: 1 + alignment: 0 + spritePivot: {x: 0.5, y: 0.5} + spritePixelsToUnits: 100 + spriteBorder: {x: 0, y: 0, z: 0, w: 0} + spriteGenerateFallbackPhysicsShape: 1 + alphaUsage: 1 + alphaIsTransparency: 1 + spriteTessellationDetail: -1 + textureType: 0 + textureShape: 1 + singleChannelComponent: 0 + flipbookRows: 1 + flipbookColumns: 1 + maxTextureSizeSet: 0 + compressionQualitySet: 0 + textureFormatSet: 0 + ignorePngGamma: 0 + applyGammaDecoding: 0 + platformSettings: + - serializedVersion: 3 + buildTarget: DefaultTexturePlatform + maxTextureSize: 2048 + resizeAlgorithm: 0 + textureFormat: -1 + textureCompression: 1 + compressionQuality: 50 + crunchedCompression: 0 + allowsAlphaSplitting: 0 + overridden: 0 + androidETC2FallbackOverride: 0 + forceMaximumCompressionQuality_BC6H_BC7: 0 + - serializedVersion: 3 + buildTarget: Standalone + maxTextureSize: 2048 + resizeAlgorithm: 0 + textureFormat: -1 + textureCompression: 1 + compressionQuality: 50 + crunchedCompression: 0 + allowsAlphaSplitting: 0 + overridden: 0 + androidETC2FallbackOverride: 0 + forceMaximumCompressionQuality_BC6H_BC7: 0 + - serializedVersion: 3 + buildTarget: WebGL + maxTextureSize: 2048 + resizeAlgorithm: 0 + textureFormat: -1 + textureCompression: 1 + compressionQuality: 50 + crunchedCompression: 0 + allowsAlphaSplitting: 0 + overridden: 0 + androidETC2FallbackOverride: 0 + forceMaximumCompressionQuality_BC6H_BC7: 0 + spriteSheet: + serializedVersion: 2 + sprites: [] + outline: [] + physicsShape: [] + bones: [] + spriteID: + internalID: 0 + vertices: [] + indices: + edges: [] + weights: [] + secondaryTextures: [] + spritePackingTag: + pSDRemoveMatte: 0 + pSDShowRemoveMatteOption: 0 + userData: + assetBundleName: + assetBundleVariant: diff --git a/Textures/RL_DummyTex_Diffuse.png b/Textures/RL_DummyTex_Diffuse.png new file mode 100644 index 0000000..90e15a2 Binary files /dev/null and b/Textures/RL_DummyTex_Diffuse.png differ diff --git a/Textures/RL_DummyTex_Diffuse.png.meta b/Textures/RL_DummyTex_Diffuse.png.meta new file mode 100644 index 0000000..797b029 --- /dev/null +++ b/Textures/RL_DummyTex_Diffuse.png.meta @@ -0,0 +1,120 @@ +fileFormatVersion: 2 +guid: 2e6930762defd9149a4115ecb5f1a3f8 +TextureImporter: + internalIDToNameTable: [] + externalObjects: {} + serializedVersion: 11 + mipmaps: + mipMapMode: 0 + enableMipMap: 1 + sRGBTexture: 1 + linearTexture: 0 + fadeOut: 0 + borderMipMap: 0 + mipMapsPreserveCoverage: 0 + alphaTestReferenceValue: 0.5 + mipMapFadeDistanceStart: 1 + mipMapFadeDistanceEnd: 3 + bumpmap: + convertToNormalMap: 0 + externalNormalMap: 0 + heightScale: 0.25 + normalMapFilter: 0 + isReadable: 0 + streamingMipmaps: 0 + streamingMipmapsPriority: 0 + vTOnly: 0 + grayScaleToAlpha: 0 + generateCubemap: 6 + cubemapConvolution: 0 + seamlessCubemap: 0 + textureFormat: 1 + maxTextureSize: 2048 + textureSettings: + serializedVersion: 2 + filterMode: -1 + aniso: -1 + mipBias: -100 + wrapU: -1 + wrapV: -1 + wrapW: -1 + nPOTScale: 1 + lightmap: 0 + compressionQuality: 50 + spriteMode: 0 + spriteExtrude: 1 + spriteMeshType: 1 + alignment: 0 + spritePivot: {x: 0.5, y: 0.5} + spritePixelsToUnits: 100 + spriteBorder: {x: 0, y: 0, z: 0, w: 0} + spriteGenerateFallbackPhysicsShape: 1 + alphaUsage: 1 + alphaIsTransparency: 1 + spriteTessellationDetail: -1 + textureType: 0 + textureShape: 1 + singleChannelComponent: 0 + flipbookRows: 1 + flipbookColumns: 1 + maxTextureSizeSet: 0 + compressionQualitySet: 0 + textureFormatSet: 0 + ignorePngGamma: 0 + applyGammaDecoding: 0 + platformSettings: + - serializedVersion: 3 + buildTarget: DefaultTexturePlatform + maxTextureSize: 2048 + resizeAlgorithm: 0 + textureFormat: -1 + textureCompression: 1 + compressionQuality: 50 + crunchedCompression: 0 + allowsAlphaSplitting: 0 + overridden: 0 + androidETC2FallbackOverride: 0 + forceMaximumCompressionQuality_BC6H_BC7: 0 + - serializedVersion: 3 + buildTarget: Standalone + maxTextureSize: 2048 + resizeAlgorithm: 0 + textureFormat: -1 + textureCompression: 1 + compressionQuality: 50 + crunchedCompression: 0 + allowsAlphaSplitting: 0 + overridden: 0 + androidETC2FallbackOverride: 0 + forceMaximumCompressionQuality_BC6H_BC7: 0 + - serializedVersion: 3 + buildTarget: WebGL + maxTextureSize: 2048 + resizeAlgorithm: 0 + textureFormat: -1 + textureCompression: 1 + compressionQuality: 50 + crunchedCompression: 0 + allowsAlphaSplitting: 0 + overridden: 0 + androidETC2FallbackOverride: 0 + forceMaximumCompressionQuality_BC6H_BC7: 0 + spriteSheet: + serializedVersion: 2 + sprites: [] + outline: [] + physicsShape: [] + bones: [] + spriteID: + internalID: 0 + vertices: [] + indices: + edges: [] + weights: [] + secondaryTextures: [] + spritePackingTag: + pSDRemoveMatte: 0 + pSDShowRemoveMatteOption: 0 + userData: + assetBundleName: + assetBundleVariant: diff --git a/Textures/RL_DummyTex_Map.png b/Textures/RL_DummyTex_Map.png new file mode 100644 index 0000000..57ce838 Binary files /dev/null and b/Textures/RL_DummyTex_Map.png differ diff --git a/Textures/RL_DummyTex_Map.png.meta b/Textures/RL_DummyTex_Map.png.meta new file mode 100644 index 0000000..72a7c06 --- /dev/null +++ b/Textures/RL_DummyTex_Map.png.meta @@ -0,0 +1,120 @@ +fileFormatVersion: 2 +guid: fba38fae484e7574a946d1527940b2b2 +TextureImporter: + internalIDToNameTable: [] + externalObjects: {} + serializedVersion: 11 + mipmaps: + mipMapMode: 0 + enableMipMap: 1 + sRGBTexture: 0 + linearTexture: 0 + fadeOut: 0 + borderMipMap: 0 + mipMapsPreserveCoverage: 0 + alphaTestReferenceValue: 0.5 + mipMapFadeDistanceStart: 1 + mipMapFadeDistanceEnd: 3 + bumpmap: + convertToNormalMap: 0 + externalNormalMap: 0 + heightScale: 0.25 + normalMapFilter: 0 + isReadable: 0 + streamingMipmaps: 0 + streamingMipmapsPriority: 0 + vTOnly: 0 + grayScaleToAlpha: 0 + generateCubemap: 6 + cubemapConvolution: 0 + seamlessCubemap: 0 + textureFormat: 1 + maxTextureSize: 2048 + textureSettings: + serializedVersion: 2 + filterMode: -1 + aniso: -1 + mipBias: -100 + wrapU: -1 + wrapV: -1 + wrapW: -1 + nPOTScale: 1 + lightmap: 0 + compressionQuality: 50 + spriteMode: 0 + spriteExtrude: 1 + spriteMeshType: 1 + alignment: 0 + spritePivot: {x: 0.5, y: 0.5} + spritePixelsToUnits: 100 + spriteBorder: {x: 0, y: 0, z: 0, w: 0} + spriteGenerateFallbackPhysicsShape: 1 + alphaUsage: 1 + alphaIsTransparency: 0 + spriteTessellationDetail: -1 + textureType: 0 + textureShape: 1 + singleChannelComponent: 0 + flipbookRows: 1 + flipbookColumns: 1 + maxTextureSizeSet: 0 + compressionQualitySet: 0 + textureFormatSet: 0 + ignorePngGamma: 0 + applyGammaDecoding: 0 + platformSettings: + - serializedVersion: 3 + buildTarget: DefaultTexturePlatform + maxTextureSize: 2048 + resizeAlgorithm: 0 + textureFormat: -1 + textureCompression: 1 + compressionQuality: 50 + crunchedCompression: 0 + allowsAlphaSplitting: 0 + overridden: 0 + androidETC2FallbackOverride: 0 + forceMaximumCompressionQuality_BC6H_BC7: 0 + - serializedVersion: 3 + buildTarget: Standalone + maxTextureSize: 2048 + resizeAlgorithm: 0 + textureFormat: -1 + textureCompression: 1 + compressionQuality: 50 + crunchedCompression: 0 + allowsAlphaSplitting: 0 + overridden: 0 + androidETC2FallbackOverride: 0 + forceMaximumCompressionQuality_BC6H_BC7: 0 + - serializedVersion: 3 + buildTarget: WebGL + maxTextureSize: 2048 + resizeAlgorithm: 0 + textureFormat: -1 + textureCompression: 1 + compressionQuality: 50 + crunchedCompression: 0 + allowsAlphaSplitting: 0 + overridden: 0 + androidETC2FallbackOverride: 0 + forceMaximumCompressionQuality_BC6H_BC7: 0 + spriteSheet: + serializedVersion: 2 + sprites: [] + outline: [] + physicsShape: [] + bones: [] + spriteID: + internalID: 0 + vertices: [] + indices: + edges: [] + weights: [] + secondaryTextures: [] + spritePackingTag: + pSDRemoveMatte: 0 + pSDShowRemoveMatteOption: 0 + userData: + assetBundleName: + assetBundleVariant: diff --git a/Textures/RL_DummyTex_Normal.png b/Textures/RL_DummyTex_Normal.png new file mode 100644 index 0000000..ba0f790 Binary files /dev/null and b/Textures/RL_DummyTex_Normal.png differ diff --git a/Textures/RL_DummyTex_Normal.png.meta b/Textures/RL_DummyTex_Normal.png.meta new file mode 100644 index 0000000..a8d417b --- /dev/null +++ b/Textures/RL_DummyTex_Normal.png.meta @@ -0,0 +1,120 @@ +fileFormatVersion: 2 +guid: 924fb7f1705312d48b04eb5be69569ec +TextureImporter: + internalIDToNameTable: [] + externalObjects: {} + serializedVersion: 11 + mipmaps: + mipMapMode: 0 + enableMipMap: 1 + sRGBTexture: 0 + linearTexture: 0 + fadeOut: 0 + borderMipMap: 0 + mipMapsPreserveCoverage: 0 + alphaTestReferenceValue: 0.5 + mipMapFadeDistanceStart: 1 + mipMapFadeDistanceEnd: 3 + bumpmap: + convertToNormalMap: 0 + externalNormalMap: 0 + heightScale: 0.25 + normalMapFilter: 0 + isReadable: 0 + streamingMipmaps: 0 + streamingMipmapsPriority: 0 + vTOnly: 0 + grayScaleToAlpha: 0 + generateCubemap: 6 + cubemapConvolution: 0 + seamlessCubemap: 0 + textureFormat: 1 + maxTextureSize: 2048 + textureSettings: + serializedVersion: 2 + filterMode: -1 + aniso: -1 + mipBias: -100 + wrapU: -1 + wrapV: -1 + wrapW: -1 + nPOTScale: 1 + lightmap: 0 + compressionQuality: 50 + spriteMode: 0 + spriteExtrude: 1 + spriteMeshType: 1 + alignment: 0 + spritePivot: {x: 0.5, y: 0.5} + spritePixelsToUnits: 100 + spriteBorder: {x: 0, y: 0, z: 0, w: 0} + spriteGenerateFallbackPhysicsShape: 1 + alphaUsage: 1 + alphaIsTransparency: 0 + spriteTessellationDetail: -1 + textureType: 1 + textureShape: 1 + singleChannelComponent: 0 + flipbookRows: 1 + flipbookColumns: 1 + maxTextureSizeSet: 0 + compressionQualitySet: 0 + textureFormatSet: 0 + ignorePngGamma: 0 + applyGammaDecoding: 0 + platformSettings: + - serializedVersion: 3 + buildTarget: DefaultTexturePlatform + maxTextureSize: 2048 + resizeAlgorithm: 0 + textureFormat: -1 + textureCompression: 1 + compressionQuality: 50 + crunchedCompression: 0 + allowsAlphaSplitting: 0 + overridden: 0 + androidETC2FallbackOverride: 0 + forceMaximumCompressionQuality_BC6H_BC7: 0 + - serializedVersion: 3 + buildTarget: Standalone + maxTextureSize: 2048 + resizeAlgorithm: 0 + textureFormat: -1 + textureCompression: 1 + compressionQuality: 50 + crunchedCompression: 0 + allowsAlphaSplitting: 0 + overridden: 0 + androidETC2FallbackOverride: 0 + forceMaximumCompressionQuality_BC6H_BC7: 0 + - serializedVersion: 3 + buildTarget: WebGL + maxTextureSize: 2048 + resizeAlgorithm: 0 + textureFormat: -1 + textureCompression: 1 + compressionQuality: 50 + crunchedCompression: 0 + allowsAlphaSplitting: 0 + overridden: 0 + androidETC2FallbackOverride: 0 + forceMaximumCompressionQuality_BC6H_BC7: 0 + spriteSheet: + serializedVersion: 2 + sprites: [] + outline: [] + physicsShape: [] + bones: [] + spriteID: + internalID: 0 + vertices: [] + indices: + edges: [] + weights: [] + secondaryTextures: [] + spritePackingTag: + pSDRemoveMatte: 0 + pSDShowRemoveMatteOption: 0 + userData: + assetBundleName: + assetBundleVariant: diff --git a/package.json b/package.json new file mode 100644 index 0000000..b1ecc1e --- /dev/null +++ b/package.json @@ -0,0 +1,25 @@ +{ + "name": "com.soupday.cc3_unity_tools", + "version": "0.1.0", + "displayName": "CC3 Unity Tools", + "description": "This is a prototype of the Unity importer for Character Creator 3/iClone 7", + "unity": "2020.3", + "unityRelease": "4f1", + "documentationUrl": "https://soupday.github.io/cc3_unity_tools/index.html", + "changelogUrl": "https://github.com/soupday/CHANGELOG.md", + "licensesUrl": "https://github.com/soupday/cc3_unity_tools/blob/stable/LICENSE", + "keywords": [ + "Reallusion", + "Character Creator", + "iClone" + ], + "author": { + "name": "Victor Soupday", + "email": "user@noreply.com", + "url": "https://github.com/soupday" + }, + "type": "tool", + "dependencies": { + "com.unity.render-pipelines.high-definition": "10.5.0" + } +} \ No newline at end of file diff --git a/package.json.meta b/package.json.meta new file mode 100644 index 0000000..33b9b40 --- /dev/null +++ b/package.json.meta @@ -0,0 +1,7 @@ +fileFormatVersion: 2 +guid: c3b7b1852cdac7142b804e5233db3531 +PackageManifestImporter: + externalObjects: {} + userData: + assetBundleName: + assetBundleVariant: