Adaug proiectul Unity

Assets/ColbyO/VNTG/Shaders/HLSL.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 02caa120d49aae3438fe9978efe955d3
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/ColbyO/VNTG/Shaders/HLSL/ColorSpace.hlsl

@@ -0,0 +1,260 @@
+#ifndef COLBYO_VNTG_COLOR_SPACE_INCLUDED
+#define COLBYO_VNTG_COLOR_SPACE_INCLUDED
+
+#include "Packages/com.unity.render-pipelines.core/ShaderLibrary/Color.hlsl"
+
+float3 VNTG_SRGBToLinear(float3 c)
+{
+    return SRGBToLinear(c);
+}
+
+float3 VNTG_LinearToSRGB(float3 c)
+{
+    return LinearToSRGB(c);
+}
+
+float GetChromaAtLightness(float L)
+{
+    float t = abs(L - 50.0) / 50.0;
+    return 128.0 * (1.0 - t);
+}
+
+float GetOklabChromaAtLightness(float L)
+{
+    float t = abs(L - 0.5) / 0.5;
+    return 0.4 * (1.0 - t);
+}
+
+float3 HSVToHSL(float3 hsv)
+{
+    float h = hsv.x;
+    float s = hsv.y;
+    float v = hsv.z;
+    float l = v * (1.0 - s / 2.0);
+    float minVal = min(l, 1.0 - l);
+    float newS = (minVal < 0.0001) ? 0.0 : (v - l) / minVal;
+    return float3(h, newS, l);
+}
+
+float3 HSLToHSV(float3 hsl)
+{
+    float h = hsl.x;
+    float s = hsl.y;
+    float l = hsl.z;
+    float v = l + s * min(l, 1.0 - l);
+    float newS = (v < 0.0001) ? 0.0 : 2.0 * (1.0 - l / v);
+    return float3(h, newS, v);
+}
+
+float3 HSVToRGB(float3 hsv)
+{
+    float4 K = float4(1.0, 2.0 / 3.0, 1.0 / 3.0, 3.0);
+    float3 p = abs(frac(hsv.xxx + K.xyz) * 6.0 - K.www);
+    return hsv.z * lerp(K.xxx, clamp(p - K.xxx, 0.0, 1.0), hsv.y);
+}
+
+float3 RGBToHSV(float3 rgb)
+{
+    float4 K = float4(0.0, -1.0 / 3.0, 2.0 / 3.0, -1.0);  
+    float4 p = lerp(float4(rgb.bg, K.wz), float4(rgb.gb, K.xy), step(rgb.b, rgb.g));
+    float4 q = lerp(float4(p.xyw, rgb.r), float4(rgb.r, p.yzx), step(p.x, rgb.r));
+
+    float d = q.x - min(q.w, q.y);
+    float e = 1.0e-10;
+    
+    return float3(abs(q.z + (q.w - q.y) / (6.0 * d + e)), d / (q.x + e), q.x);
+}
+
+float3 HSLToRGB(float3 hsl)
+{
+    float4 K = float4(1.0, 2.0 / 3.0, 1.0 / 3.0, 3.0);
+    float3 p = abs(frac(hsl.xxx + K.xyz) * 6.0 - K.www);
+    float3 rgb = lerp(K.xxx, clamp(p - K.xxx, 0.0, 1.0), hsl.y);
+    return hsl.z + hsl.y * (rgb - 0.5) * (1.0 - abs(2.0 * hsl.z - 1.0));
+}
+
+float3 RGBToHSL(float3 rgb)
+{
+    float4 K = float4(0.0, -1.0 / 3.0, 2.0 / 3.0, -1.0);
+    float4 p = lerp(float4(rgb.bg, K.wz), float4(rgb.gb, K.xy), step(rgb.b, rgb.g));
+    float4 q = lerp(float4(p.xyw, rgb.r), float4(rgb.r, p.yzx), step(p.x, rgb.r));
+
+    float maxVal = q.x;
+    float minVal = min(q.w, q.y);
+    float d = maxVal - minVal;
+    float e = 1.0e-10;
+    
+    float h = abs(q.z + (q.w - q.y) / (6.0 * d + e));
+    float l = (maxVal + minVal) * 0.5;
+    float s = d / (1.0 - abs(2.0 * l - 1.0) + e);
+    
+    return float3(h, s, l);
+}
+
+float3 RGBToLab(float3 rgb)
+{
+    float3 linearColor = VNTG_SRGBToLinear(rgb);
+
+    float x = linearColor.r * 0.4124564 + linearColor.g * 0.3575761 + linearColor.b * 0.1804375;
+    float y = linearColor.r * 0.2126729 + linearColor.g * 0.7151522 + linearColor.b * 0.0721750;
+    float z = linearColor.r * 0.0193339 + linearColor.g * 0.1191920 + linearColor.b * 0.9503041;
+
+    x /= 0.95047;
+    y /= 1.00000;
+    z /= 1.08883;
+
+    float3 v;
+    v.x = (x > 0.008856) ? pow(x, 1.0 / 3.0) : (7.787 * x) + (16.0 / 116.0);
+    v.y = (y > 0.008856) ? pow(y, 1.0 / 3.0) : (7.787 * y) + (16.0 / 116.0);
+    v.z = (z > 0.008856) ? pow(z, 1.0 / 3.0) : (7.787 * z) + (16.0 / 116.0);
+
+    float L = (116.0 * v.y) - 16.0;
+    float a = 500.0 * (v.x - v.y);
+    float b = 200.0 * (v.y - v.z);
+
+    return float3(L, a, b);
+}
+
+float3 LabToRGB(float L, float a, float b)
+{
+    float y = (L + 16.0) / 116.0;
+    float x = (a / 500.0) + y;
+    float z = y - (b / 200.0);
+
+    float x3 = x * x * x;
+    float y3 = y * y * y;
+    float z3 = z * z * z;
+
+    x = (x3 > 0.008856) ? x3 : (x - 16.0 / 116.0) / 7.787;
+    y = (y3 > 0.008856) ? y3 : (y - 16.0 / 116.0) / 7.787;
+    z = (z3 > 0.008856) ? z3 : (z - 16.0 / 116.0) / 7.787;
+
+    x *= 0.95047;
+    y *= 1.00000;
+    z *= 1.08883;
+
+    float r = x * 3.2404542 + y * -1.5371385 + z * -0.4985314;
+    float g = x * -0.9692660 + y * 1.8760108 + z * 0.0415560;
+    float b_val = x * 0.0556434 + y * -0.2040259 + z * 1.0572252;
+
+    float3 rgb = float3(r, g, b_val);
+
+    return VNTG_LinearToSRGB(rgb);;
+}
+
+float3 RGBToOklab(float3 rgb)
+{
+    float3 linearColor = VNTG_SRGBToLinear(rgb);
+
+    float l_cone = linearColor.r * 0.4122214708 + linearColor.g * 0.5363325363 + linearColor.b * 0.0514459929;
+    float m_cone = linearColor.r * 0.2119034982 + linearColor.g * 0.6806995451 + linearColor.b * 0.1073969566;
+    float s_cone = linearColor.r * 0.0883024619 + linearColor.g * 0.2817188376 + linearColor.b * 0.6299787005;
+
+    float l_ = pow(max(0.0, l_cone), 1.0 / 3.0);
+    float m_ = pow(max(0.0, m_cone), 1.0 / 3.0);
+    float s_ = pow(max(0.0, s_cone), 1.0 / 3.0);
+
+    float L = l_ * 0.2104542553 + m_ * 0.7936177850 - s_ * 0.0040720468;
+    float a = l_ * 1.9779984951 - m_ * 2.4285922050 + s_ * 0.4505937099;
+    float b = l_ * 0.0259040371 + m_ * 0.7827717662 - s_ * 0.8086757660;
+
+    return float3(L, a, b);
+}
+
+float3 OklabToRGB(float L, float a, float b)
+{
+    float l_ = L + 0.3963377774 * a + 0.2158037573 * b;
+    float m_ = L - 0.1055613458 * a - 0.0638541728 * b;
+    float s_ = L - 0.0894841775 * a - 1.2914855480 * b;
+
+    float l_cone = l_ * l_ * l_;
+    float m_cone = m_ * m_ * m_;
+    float s_cone = s_ * s_ * s_;
+
+    float r = l_cone * 4.0767416621 + m_cone * -3.3077115913 + s_cone * 0.2309699292;
+    float g = l_cone * -1.2684380046 + m_cone * 2.6097574011 + s_cone * -0.3413190470;
+    float b_val = l_cone * -0.0041960863 + m_cone * -0.7034186147 + s_cone * 1.7076147010;
+
+    float3 rgb = float3(r, g, b_val);
+
+    return VNTG_LinearToSRGB(rgb);
+}
+
+float ApplyPQ(float x)
+{
+    if (x <= 0.0)
+        return 0.0;
+
+    const float m1 = 2610.0 / 16384.0;
+    const float m2 = 2523.0 / 32.0;
+    const float c1 = 3424.0 / 4064.0;
+    const float c2 = 2413.0 / 4096.0;
+    const float c3 = 2392.0 / 4096.0;
+
+    float xPowM1 = pow(x, m1);
+    float num = c1 + c2 * xPowM1;
+    float den = 1.0 + c3 * xPowM1;
+
+    return pow(num / den, m2);
+}
+
+float InverseApplyPQ(float y)
+{
+    if (y <= 0.0)
+        return 0.0;
+
+    const float m1 = 2610.0 / 16384.0;
+    const float m2 = 2523.0 / 32.0;
+    const float c1 = 3424.0 / 4064.0;
+    const float c2 = 2413.0 / 4096.0;
+    const float c3 = 2392.0 / 4096.0;
+
+    float yPowInvM2 = pow(y, 1.0 / m2);
+    float num = max(0.0, yPowInvM2 - c1);
+    float den = c2 - c3 * yPowInvM2;
+
+    return pow(num / den, 1.0 / m1);
+}
+
+float3 RGBToITP(float3 rgb)
+{
+    float3 linearColor = VNTG_SRGBToLinear(rgb);
+
+    float l = linearColor.r * 0.3592 + linearColor.g * 0.5134 + linearColor.b * 0.1274;
+    float m = linearColor.r * 0.1344 + linearColor.g * 0.7453 + linearColor.b * 0.1203;
+    float s = linearColor.r * 0.0619 + linearColor.g * 0.1916 + linearColor.b * 0.7465;
+
+    l = ApplyPQ(l);
+    m = ApplyPQ(m);
+    s = ApplyPQ(s);
+
+    float I = 0.5 * l + 0.5 * m;
+    float Ct = 1.6137 * l - 3.3234 * m + 1.7097 * s;
+    float Cp = 4.3781 * l - 4.2455 * m - 0.1325 * s;
+
+    return float3(I, 0.5 * Ct, Cp);
+}
+
+float3 ITPToRGB(float3 itp)
+{
+    float I = itp.x;
+    float Ct = itp.y / 0.5;
+    float Cp = itp.z;
+
+    float l = I * 1.0 + Ct * 0.008609037 + Cp * 0.11102962;
+    float m = I * 1.0 + Ct * -0.008609037 + Cp * -0.11102962;
+    float s = I * 1.0 + Ct * 0.5600313 + Cp * -0.32062714;
+
+    l = InverseApplyPQ(l);
+    m = InverseApplyPQ(m);
+    s = InverseApplyPQ(s);
+
+    float r = l * 3.4366066 + m * -2.506452 + s * 0.06984555;
+    float g = l * -0.7913296 + m * 1.9779913 + s * -0.18666175;
+    float b = l * -0.0259497 + m * -0.2434954 + s * 1.269445;
+
+    float3 rgb = float3(r, g, b);
+    return VNTG_LinearToSRGB(rgb);
+}
+
+#endif

Assets/ColbyO/VNTG/Shaders/HLSL/ColorSpace.hlsl.meta

@@ -0,0 +1,7 @@
+fileFormatVersion: 2
+guid: d957d60b78a98be41b7533302cacba14
+ShaderIncludeImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/ColbyO/VNTG/Shaders/HLSL/HSVConversion.hlsl

@@ -0,0 +1,53 @@
+//-----------------------------------------------------------------------
+// Author:  Colby-O
+// File:    HSVConversion.hlsl
+//-----------------------------------------------------------------------
+
+#ifndef COLBYO_VNTG_HSV_CONVERSION_INCLUDED
+#define COLBYO_VNTG_HSV_CONVERSION_INCLUDED
+
+void RgbToHsv_float(float3 RGB, out float3 HSV)
+{
+    float4 K = float4(0.0, -1.0 / 3.0, 2.0 / 3.0, -1.0);
+    
+    float4 p = lerp(float4(RGB.bg, K.wz), float4(RGB.gb, K.xy), step(RGB.b, RGB.g));
+    float4 q = lerp(float4(p.xyw, RGB.r), float4(RGB.r, p.yzx), step(p.x, RGB.r));
+
+    float d = q.x - min(q.w, q.y);
+    float e = 1.0e-10;
+    
+    HSV = float3(abs(q.z + (q.w - q.y) / (6.0 * d + e)), d / (q.x + e), q.x);
+}
+
+void RgbToHsv_half(half3 RGB, out half3 HSV)
+{
+    half4 K = half4(0.0, -1.0 / 3.0, 2.0 / 3.0, -1.0);
+    
+    half4 p = lerp(half4(RGB.bg, K.wz), half4(RGB.gb, K.xy), step(RGB.b, RGB.g));
+    half4 q = lerp(half4(p.xyw, RGB.r), half4(RGB.r, p.yzx), step(p.x, RGB.r));
+
+    half d = q.x - min(q.w, q.y);
+    half e = 1e-4;
+    
+    HSV = half3(abs(q.z + (q.w - q.y) / (6.0 * d + e)), d / (q.x + e), q.x);
+}
+
+void HsvToRgb_float(float3 HSV, out float3 RGB)
+{
+    float4 K = float4(1.0, 2.0 / 3.0, 1.0 / 3.0, 3.0);
+    
+    float3 p = abs(frac(HSV.xxx + K.xyz) * 6.0 - K.www);
+    
+    RGB = HSV.z * lerp(K.xxx, saturate(p - K.xxx), HSV.y);
+}
+
+void HsvToRgb_half(half3 HSV, out half3 RGB)
+{
+    half4 K = half4(1.0, 2.0 / 3.0, 1.0 / 3.0, 3.0);
+    
+    half3 p = abs(frac(HSV.xxx + K.xyz) * 6.0 - K.www);
+    
+    RGB = HSV.z * lerp(K.xxx, saturate(p - K.xxx), HSV.y);
+}
+
+#endif

Assets/ColbyO/VNTG/Shaders/HLSL/HSVConversion.hlsl.meta

@@ -0,0 +1,7 @@
+fileFormatVersion: 2
+guid: 50998adb9d812e149b8c7fbb1dae6663
+ShaderIncludeImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/ColbyO/VNTG/Shaders/HLSL/N64Sampler.hlsl

@@ -0,0 +1,257 @@
+//-----------------------------------------------------------------------
+// Author:  Colby-O
+// File:    N64Sampler.hlsl
+//-----------------------------------------------------------------------
+
+#ifndef COLBYO_VNTG_N64_SAMPLER_INCLUDED
+#define COLBYO_VNTG_N64_SAMPLER_INCLUDED
+
+void N64Sampler_float(UnityTexture2D Texture, UnitySamplerState Sampler, float4 TexelSize, float2 UV, out float4 Out)
+{
+    uint width, height;
+    Texture.tex.GetDimensions(width, height);
+    TexelSize = float4(1.0 / width, 1.0 / height, width, height);
+    
+    float2 texels = UV * TexelSize.zw;
+    
+    //TexelSize.xy *= -1.0;
+    texels = texels - 0.5;
+    
+    float2 fracTexel = frac(texels);
+    float3 blend = float3(
+        abs(fracTexel.x + fracTexel.y - 1),
+        min(abs(fracTexel.xx - float2(0.0, 1.0)), abs(fracTexel.yy - float2(1.0, 0.0)))
+    );
+    
+    float2 uvA = (floor(texels + fracTexel.yx) + 0.5) * TexelSize.xy;
+    float2 uvB = (floor(texels) + float2(1.5, 0.5)) * TexelSize.xy;
+    float2 uvC = (floor(texels) + float2(0.5, 1.5)) * TexelSize.xy;
+    
+    float4 A = SAMPLE_TEXTURE2D_LOD(Texture.tex, Sampler.samplerstate, uvA, 0.0);
+    float4 B = SAMPLE_TEXTURE2D_LOD(Texture.tex, Sampler.samplerstate, uvB, 0.0);
+    float4 C = SAMPLE_TEXTURE2D_LOD(Texture.tex, Sampler.samplerstate, uvC, 0.0);
+    
+    Out = A * blend.x + B * blend.y + C * blend.z;
+}
+
+void N64Sampler_half(UnityTexture2D Texture, UnitySamplerState Sampler, half4 TexelSize, half2 UV, out half4 Out)
+{
+    half width, height;
+    Texture.tex.GetDimensions(width, height);
+    TexelSize = half4(1.0 / width, 1.0 / height, width, height);
+    
+    half2 texels = UV * TexelSize.zw;
+    
+    //TexelSize.xy *= -1.0;
+    texels = texels - 0.5;
+    
+    half2 fracTexel = frac(texels);
+    half3 blend = half3(
+        abs(fracTexel.x + fracTexel.y - 1),
+        min(abs(fracTexel.xx - half2(0.0, 1.0)), abs(fracTexel.yy - half2(1.0, 0.0)))
+    );
+    
+    half2 uvA = (floor(texels + fracTexel.yx) + 0.5) * TexelSize.xy;
+    half2 uvB = (floor(texels) + half2(1.5, 0.5)) * TexelSize.xy;
+    half2 uvC = (floor(texels) + half2(0.5, 1.5)) * TexelSize.xy;
+    
+    half4 A = SAMPLE_TEXTURE2D_LOD(Texture, Sampler, uvA, 0.0);
+    half4 B = SAMPLE_TEXTURE2D_LOD(Texture, Sampler, uvB, 0.0);
+    half4 C = SAMPLE_TEXTURE2D_LOD(Texture, Sampler, uvC, 0.0);
+    
+    Out = A * blend.x + B * blend.y + C * blend.z;
+}
+
+void DirToCubeFaceUV_float(float3 dir, out int faceIndex, out float2 uv)
+{
+    float3 absDir = abs(dir);
+    float maxAxis;
+
+    if (absDir.x >= absDir.y && absDir.x >= absDir.z)
+    {
+        faceIndex = (dir.x > 0.0) ? 0 : 1;
+        maxAxis = absDir.x;
+        uv = float2((dir.x > 0.0) ? -dir.z : dir.z, -dir.y);
+    }
+    else if (absDir.y >= absDir.x && absDir.y >= absDir.z)
+    {
+        faceIndex = (dir.y > 0.0) ? 2 : 3;
+        maxAxis = absDir.y;
+        uv = float2(dir.x, (dir.y > 0.0) ? dir.z : -dir.z);
+    }
+    else
+    {
+        faceIndex = (dir.z > 0.0) ? 4 : 5;
+        maxAxis = absDir.z;
+        uv = float2((dir.z > 0.0) ? dir.x : -dir.x, -dir.y);
+    }
+
+    uv = 0.5 * (uv / maxAxis + 1.0);
+}
+
+void DirToCubeFaceUV_half(half3 dir, out int faceIndex, out half2 uv)
+{
+    half3 absDir = abs(dir);
+    half maxAxis;
+
+    if (absDir.x >= absDir.y && absDir.x >= absDir.z)
+    {
+        faceIndex = (dir.x > 0.0) ? 0 : 1;
+        maxAxis = absDir.x;
+        uv = half2((dir.x > 0.0) ? -dir.z : dir.z, -dir.y);
+    }
+    else if (absDir.y >= absDir.x && absDir.y >= absDir.z)
+    {
+        faceIndex = (dir.y > 0.0) ? 2 : 3;
+        maxAxis = absDir.y;
+        uv = half2(dir.x, (dir.y > 0.0) ? dir.z : -dir.z);
+    }
+    else
+    {
+        faceIndex = (dir.z > 0.0) ? 4 : 5;
+        maxAxis = absDir.z;
+        uv = half2((dir.z > 0.0) ? dir.x : -dir.x, -dir.y);
+    }
+
+    uv = 0.5 * (uv / maxAxis + 1.0);
+}
+
+float3 CubeFaceUVToDir_float(int faceIndex, float2 uv)
+{
+    float2 uc = uv * 2.0 - 1.0;
+    float3 dir = float3(0, 0, 0);
+
+    switch (faceIndex)
+    {
+        case 0:
+            dir = float3(1.0, -uc.y, -uc.x);
+            break;
+        case 1:
+            dir = float3(-1.0, -uc.y, uc.x);
+            break;
+        case 2:
+            dir = float3(uc.x, 1.0, uc.y);
+            break;
+        case 3:
+            dir = float3(uc.x, -1.0, -uc.y);
+            break;
+        case 4:
+            dir = float3(uc.x, -uc.y, 1.0);
+            break;
+        case 5:
+            dir = float3(-uc.x, -uc.y, -1.0);
+            break;
+    }
+
+    return normalize(dir);
+}
+
+half3 CubeFaceUVToDir_half(int faceIndex, half2 uv)
+{
+    half2 uc = uv * 2.0 - 1.0;
+    half3 dir = half3(0, 0, 0);
+
+    switch (faceIndex)
+    {
+        case 0:
+            dir = half3(1.0, -uc.y, -uc.x);
+            break;
+        case 1:
+            dir = half3(-1.0, -uc.y, uc.x);
+            break;
+        case 2:
+            dir = half3(uc.x, 1.0, uc.y);
+            break;
+        case 3:
+            dir = half3(uc.x, -1.0, -uc.y);
+            break;
+        case 4:
+            dir = half3(uc.x, -uc.y, 1.0);
+            break;
+        case 5:
+            dir = half3(-uc.x, -uc.y, -1.0);
+            break;
+    }
+
+    return normalize(dir);
+}
+
+void N64SamplerCube_float(
+    UnityTextureCube Cube, 
+    UnitySamplerState Sampler, 
+    float3 Dir, 
+
+    out float4 Out
+)
+{
+    uint width, height;
+    Cube.tex.GetDimensions(width, height);
+    
+    int faceIndex;
+    float2 UV;
+    DirToCubeFaceUV_float(Dir, faceIndex, UV);
+
+    float4 TexelSize = float4(1.0 / width, 1.0 / height, width, height);
+    float2 texels = UV * TexelSize.zw - 0.5;
+
+    float2 fracTexel = frac(texels);
+    float3 blend = float3(
+        abs(fracTexel.x + fracTexel.y - 1.0),
+        min(abs(fracTexel.xx - float2(0.0, 1.0)), abs(fracTexel.yy - float2(1.0, 0.0)))
+    );
+
+    float2 uvA = (floor(texels + fracTexel.yx) + 0.5) * TexelSize.xy;
+    float2 uvB = (floor(texels) + float2(1.5, 0.5)) * TexelSize.xy;
+    float2 uvC = (floor(texels) + float2(0.5, 1.5)) * TexelSize.xy;
+
+    float3 dirA = CubeFaceUVToDir_float(faceIndex, uvA);
+    float3 dirB = CubeFaceUVToDir_float(faceIndex, uvB);
+    float3 dirC = CubeFaceUVToDir_float(faceIndex, uvC);
+
+    float4 A = SAMPLE_TEXTURECUBE_LOD(Cube.tex, Sampler.samplerstate, dirA, 0.0);
+    float4 B = SAMPLE_TEXTURECUBE_LOD(Cube.tex, Sampler.samplerstate, dirB, 0.0);
+    float4 C = SAMPLE_TEXTURECUBE_LOD(Cube.tex, Sampler.samplerstate, dirC, 0.0);
+
+    Out = A * blend.x + B * blend.y + C * blend.z;
+}
+
+void N64SamplerCube_half(
+    UnityTextureCube Cube,
+    UnitySamplerState Sampler,
+    half3 Dir,
+
+    out half4 Out
+)
+{
+    uint width, height;
+    Cube.tex.GetDimensions(width, height);
+    
+    int faceIndex;
+    half2 UV;
+    DirToCubeFaceUV_half(Dir, faceIndex, UV);
+
+    half4 TexelSize = half4(1.0 / width, 1.0 / height, width, height);
+    half2 texels = UV * TexelSize.zw - 0.5;
+
+    half2 fracTexel = frac(texels);
+    half3 blend = half3(
+        abs(fracTexel.x + fracTexel.y - 1.0),
+        min(abs(fracTexel.xx - half2(0.0, 1.0)), abs(fracTexel.yy - half2(1.0, 0.0)))
+    );
+
+    half2 uvA = (floor(texels + fracTexel.yx) + 0.5) * TexelSize.xy;
+    half2 uvB = (floor(texels) + half2(1.5, 0.5)) * TexelSize.xy;
+    half2 uvC = (floor(texels) + half2(0.5, 1.5)) * TexelSize.xy;
+
+    half3 dirA = CubeFaceUVToDir_half(faceIndex, uvA);
+    half3 dirB = CubeFaceUVToDir_half(faceIndex, uvB);
+    half3 dirC = CubeFaceUVToDir_half(faceIndex, uvC);
+
+    half4 A = SAMPLE_TEXTURECUBE_LOD(Cube.tex, Sampler.samplerstate, dirA, 0.0);
+    half4 B = SAMPLE_TEXTURECUBE_LOD(Cube.tex, Sampler.samplerstate, dirB, 0.0);
+    half4 C = SAMPLE_TEXTURECUBE_LOD(Cube.tex, Sampler.samplerstate, dirC, 0.0);
+
+    Out = A * blend.x + B * blend.y + C * blend.z;
+}
+
+#endif

Assets/ColbyO/VNTG/Shaders/HLSL/N64Sampler.hlsl.meta

@@ -0,0 +1,7 @@
+fileFormatVersion: 2
+guid: 04975814c73fcca4b938b0d8b3595590
+ShaderIncludeImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/ColbyO/VNTG/Shaders/HLSL/PSXLighting_URP.hlsl

@@ -0,0 +1,454 @@
+//-----------------------------------------------------------------------
+// Original Author:      Codrin-Mihail
+// Modifications Author: Colby-O
+// File:                 PSXLighting_URP.hlsl
+// 
+// This file is a derivative work based on code from Codrin-Mihail
+// https://github.com/Kodrin/URP-PSX/blob/master/URP-PSX/Assets/Shaders/HLSL/CustomLighting.hlsl
+//-----------------------------------------------------------------------
+// Key Modifications:
+// - Integrated texel snapping logic (Adapted from GreatestBear)
+// - Added support for Unlit shaders
+// - Refactored MainLight to handle lighting calculations internally
+// - Implemented URP LIGHT_LOOP macros for additional lights, supporting Forward+ and Deferred Rendering 
+//   in addition to Forward Rendering which was originally supported
+// - Fixed shadows for additional lights and added custom shadow tinting and distance cutoffs
+// - Added light cookie support
+// - Refactored overall code structure
+//-------------------------------------------------------------------------
+// The below license applies to the original portions of the code by Codrin-Mihail.
+//-------------------------------------------------------------------------
+// MIT License
+
+// Copyright (c) 2020 Codrin-Mihail
+
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
+//-------------------------------------------------------------------------
+// Modifications by Colby-O are released under The Unlicense
+//-------------------------------------------------------------------------
+// This is free and unencumbered software released into the public domain.
+
+// Anyone is free to copy, modify, publish, use, compile, sell, or
+// distribute this software, either in source code form or as a compiled
+// binary, for any purpose, commercial or non-commercial, and by any
+// means.
+
+// In jurisdictions that recognize copyright laws, the author or authors
+// of this software dedicate any and all copyright interest in the
+// software to the public domain. We make this dedication for the benefit
+// of the public at large and to the detriment of our heirs and
+// successors. We intend this dedication to be an overt act of
+// relinquishment in perpetuity of all present and future rights to this
+// software under copyright law.
+
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+// IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR
+// OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
+// ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+// OTHER DEALINGS IN THE SOFTWARE.
+//-------------------------------------------------------------------------
+
+#ifndef COLBYO_VNTG_PSX_LIGHTING_INCLUDED
+#define COLBYO_VNTG_PSX_LIGHTING_INCLUDED
+
+#if SHADERPASS == SHADERPASS_UNLIT || SHADERPASS == SHADERPASS_DBUFFER_PROJECTOR
+
+#pragma multi_compile _ _CLUSTER_LIGHT_LOOP
+#pragma multi_compile _ _ADDITIONAL_LIGHTS
+
+#pragma multi_compile _ _MAIN_LIGHT_SHADOWS _MAIN_LIGHT_SHADOWS_CASCADE _MAIN_LIGHT_SHADOWS_SCREEN
+#pragma multi_compile _ _ADDITIONAL_LIGHT_SHADOWS
+
+#endif
+
+
+float4 _VNTGAmbientColor;
+
+void SnapInterpolatorToTexel_float(
+    float3 Interpolator,
+    float2 UV,
+    float4 TexelSize,
+    out float3 SnappedInterpolator
+)
+{
+    SnappedInterpolator = Interpolator;
+    if (TexelSize.z < 0.001 || TexelSize.w < 0.001) return;
+    
+#if defined(SHADER_STAGE_FRAGMENT) || !defined(SHADER_STAGE_VERTEX)
+    
+    float2 originalUV = UV;
+    float2 centerUV = floor(originalUV * (TexelSize.zw)) / TexelSize.zw + (TexelSize.xy / 2.0);
+    float2 dUV = (centerUV - originalUV);
+
+    float2 dUVdS = ddx(originalUV);
+    float2 dUVdT = ddy(originalUV);
+
+    float2x2 dSTdUV = float2x2(dUVdT[1], -dUVdT[0], -dUVdS[1], dUVdS[0]) * (1.0f / (dUVdS[0] * dUVdT[1] - dUVdT[0] * dUVdS[1]));
+
+    float2 dST = mul(dSTdUV, dUV);
+
+    float3 dValuedS = ddx(Interpolator);
+    float3 dValuedT = ddy(Interpolator);
+
+    float3 dValue = dValuedS * dST[0] + dValuedT * dST[1];
+
+    SnappedInterpolator = Interpolator + dValue;
+    
+#endif
+}
+
+void SnapInterpolatorToTexel_half(
+    half3 Interpolator,
+    half2 UV,
+    half4 TexelSize,
+    out half3 SnappedInterpolator
+)
+{
+    SnappedInterpolator = Interpolator;
+    if (TexelSize.z < 0.001 || TexelSize.w < 0.001) return;
+    
+#if defined(SHADER_STAGE_FRAGMENT) || !defined(SHADER_STAGE_VERTEX)
+    
+    half2 originalUV = UV;
+    half2 centerUV = floor(originalUV * (TexelSize.zw)) / TexelSize.zw + (TexelSize.xy / 2.0);
+    half2 dUV = (centerUV - originalUV);
+
+    half2 dUVdS = ddx(originalUV);
+    half2 dUVdT = ddy(originalUV);
+
+    half2x2 dSTdUV = half2x2(dUVdT[1], -dUVdT[0], -dUVdS[1], dUVdS[0]) * (1.0f / (dUVdS[0] * dUVdT[1] - dUVdT[0] * dUVdS[1]));
+
+    half2 dST = mul(dSTdUV, dUV);
+
+    half3 dValuedS = ddx(Interpolator);
+    half3 dValuedT = ddy(Interpolator);
+
+    half3 dValue = dValuedS * dST[0] + dValuedT * dST[1];
+
+    SnappedInterpolator = Interpolator + dValue;
+    
+#endif
+}
+
+/** 
+    Code is adapted from GreatestBear
+
+    References:
+        [1] https://discussions.unity.com/t/the-quest-for-efficient-per-texel-lighting/700574
+*/
+void SnapPositionToTexel_float(
+    float3 WorldPosition,
+    float2 UV,
+    float4 TexelSize,
+
+    out float3 SnappedWorldPosition
+
+)
+{
+    SnappedWorldPosition = WorldPosition;
+    if (TexelSize.z < 0.001 || TexelSize.w < 0.001) return;
+    
+#if defined(SHADER_STAGE_FRAGMENT) || !defined(SHADER_STAGE_VERTEX)
+    
+    float2 originalUV = UV;
+    float2 centerUV = floor(originalUV * (TexelSize.zw)) / TexelSize.zw + (TexelSize.xy / 2.0);
+    float2 dUV = (centerUV - originalUV);
+
+    float2 dUVdS = ddx(originalUV);
+    float2 dUVdT = ddy(originalUV);
+
+    float2x2 dSTdUV = float2x2(dUVdT[1], -dUVdT[0], -dUVdS[1], dUVdS[0]) * (1.0f / (dUVdS[0] * dUVdT[1] - dUVdT[0] * dUVdS[1]));
+
+    float2 dST = mul(dSTdUV, dUV);
+
+    float3 dXYZdS = ddx(WorldPosition);
+    float3 dXYZdT = ddy(WorldPosition);
+
+    float3 dXYZ = dXYZdS * dST[0] + dXYZdT * dST[1];
+    dXYZ = clamp(dXYZ, -1, 1);
+
+    SnappedWorldPosition = (WorldPosition + dXYZ);
+    
+#endif
+}
+
+/** 
+    Code is adapted from GreatestBear
+
+    References:
+        [1] https://discussions.unity.com/t/the-quest-for-efficient-per-texel-lighting/700574
+*/
+void SnapPositionToTexel_half(
+    half3 WorldPosition,
+    half2 UV,
+    half4 TexelSize,
+
+    out half3 SnappedWorldPosition
+
+)
+{
+    SnappedWorldPosition = WorldPosition;   
+    if (TexelSize.z < 0.001 || TexelSize.w < 0.001) return;   
+    
+#if defined(SHADER_STAGE_FRAGMENT) || !defined(SHADER_STAGE_VERTEX)
+    
+    half2 originalUV = UV;
+    half2 centerUV = floor(originalUV * (TexelSize.zw)) / TexelSize.zw + (TexelSize.xy / 2.0);
+    half2 dUV = (centerUV - originalUV);
+
+    half2 dUVdS = ddx(originalUV);
+    half2 dUVdT = ddy(originalUV);
+
+    half2x2 dSTdUV = half2x2(dUVdT[1], -dUVdT[0], -dUVdS[1], dUVdS[0]) * (1.0f / (dUVdS[0] * dUVdT[1] - dUVdT[0] * dUVdS[1]));
+
+    half2 dST = mul(dSTdUV, dUV);
+
+    half3 dXYZdS = ddx(WorldPosition);
+    half3 dXYZdT = ddy(WorldPosition);
+
+    half3 dXYZ = dXYZdS * dST[0] + dXYZdT * dST[1];
+    dXYZ = clamp(dXYZ, -1, 1);
+
+    SnappedWorldPosition = (WorldPosition + dXYZ);
+    
+#endif
+}
+
+void MainLight_float(
+    float3 WorldPosition,
+    float3 WorldNormal,
+    float3 WorldView,
+    float3 SpecColor,
+    float Smoothness,
+    bool EnableShadows,
+    float3 ShadowTint,
+    float ShadowDistCutoff,
+    float ShadowOffset,
+
+    out float3 Diffuse, 
+    out float3 Specular
+)
+{
+    float3 diffuseColor = 0;
+    float3 specularColor = 0;
+
+#ifndef SHADERGRAPH_PREVIEW
+    Smoothness = exp2(10 * Smoothness + 1);
+    WorldNormal = normalize(WorldNormal);
+    WorldView = SafeNormalize(WorldView);
+    
+#if SHADOWS_SCREEN
+    half4 clipPos = TransformWorldToHClip(WorldPosition);
+    half4 shadowCoord = ComputeScreenPos(clipPos);
+#else
+    half4 shadowCoord = TransformWorldToShadowCoord(WorldPosition);
+#endif
+    
+    // TODO FIX: Shadows are kinda borken (with severe acene) due to the vertex jitter. 
+    // ShadowCorrd.z + ShadowOffset is a hack and casue peter paning artifacts.
+    // For now set the offset to a small number and max out the shadow bias 
+    // in the renderer asset for shadows.
+    shadowCoord.z += ShadowOffset;
+    
+    Light mainLight = GetMainLight(shadowCoord);
+    
+    float distToCamera = distance(_WorldSpaceCameraPos, WorldPosition);
+    float shadowAtten = (EnableShadows && distToCamera < ShadowDistCutoff) ? mainLight.shadowAttenuation : 1.0;
+    float3 attenuatedLightColor = mainLight.color * (mainLight.distanceAttenuation * shadowAtten) + ShadowTint * (1.0 - shadowAtten);
+
+    diffuseColor = saturate(LightingLambert(attenuatedLightColor, mainLight.direction, WorldNormal) + _VNTGAmbientColor);
+    specularColor = LightingSpecular(attenuatedLightColor, mainLight.direction, WorldNormal, WorldView, float4(SpecColor, 0), Smoothness);
+    
+#endif
+    
+    Diffuse = diffuseColor;
+    Specular = specularColor;
+}
+
+void MainLight_half(
+    half3 WorldPosition,
+    half3 WorldNormal,
+    half3 WorldView,
+    half3 SpecColor,
+    half Smoothness,
+    bool EnableShadows,
+    half3 ShadowTint,
+    half ShadowDistCutoff,
+    half ShadowOffset,
+
+    out half3 Diffuse,
+    out half3 Specular
+)
+{
+    half3 diffuseColor = 0;
+    half3 specularColor = 0;
+
+#ifndef SHADERGRAPH_PREVIEW
+    Smoothness = exp2(10 * Smoothness + 1);
+    WorldNormal = normalize(WorldNormal);
+    WorldView = SafeNormalize(WorldView);
+    
+#if SHADOWS_SCREEN
+    half4 clipPos = TransformWorldToHClip(WorldPosition);
+    half4 shadowCoord = ComputeScreenPos(clipPos);
+#else
+    half4 shadowCoord = TransformWorldToShadowCoord(WorldPosition);
+#endif
+    
+    // TODO FIX: Shadows are kinda borken (with serve acene) due to the vertex jitter. 
+    // ShadowCorrd.z + ShadowOffset is a hack and casue peter paning artifacts.
+    // For now set the offset to a small number and max out the shadow bias 
+    // in the renderer asset for shadows.
+    shadowCoord.z += ShadowOffset;
+    
+    Light mainLight = GetMainLight(shadowCoord);
+    
+    half distToCamera = distance(_WorldSpaceCameraPos, WorldPosition);
+    half shadowAtten = (EnableShadows && distToCamera < ShadowDistCutoff) ? mainLight.shadowAttenuation : 1.0;
+    half3 attenuatedLightColor = mainLight.color * (mainLight.distanceAttenuation * shadowAtten) + ShadowTint * (1.0 - shadowAtten);
+
+    diffuseColor = saturate(LightingLambert(attenuatedLightColor, mainLight.direction, WorldNormal) + _VNTGAmbientColor);
+    specularColor = LightingSpecular(attenuatedLightColor, mainLight.direction, WorldNormal, WorldView, half4(SpecColor, 0), Smoothness);
+    
+#endif
+    
+    Diffuse = diffuseColor;
+    Specular = specularColor;
+}
+
+void AdditionalLights_float(
+    float3 SpecColor, 
+    float Smoothness, 
+    float3 WorldPosition, 
+    float3 WorldNormal, 
+    float3 WorldView, 
+    bool EnableShadows,
+    float3 ShadowTint,
+    float ShadowDistCutoff,
+
+    out float3 Diffuse, 
+    out float3 Specular
+)
+{
+    float3 diffuseColor = 0;
+    float3 specularColor = 0;
+
+#ifndef SHADERGRAPH_PREVIEW
+    Smoothness = exp2(10 * Smoothness + 1);
+    WorldNormal = normalize(WorldNormal);
+    WorldView = SafeNormalize(WorldView);
+
+    uint pixelLightCount = GetAdditionalLightsCount();
+
+    InputData inputData = (InputData) 0;
+    inputData.positionWS = WorldPosition;
+    
+    float4 clipPos = TransformWorldToHClip(WorldPosition);
+    float4 screenPos = ComputeScreenPos(clipPos);
+    inputData.normalizedScreenSpaceUV = screenPos.xy / (screenPos.w + 0.00001);
+    
+    float distToCamera = distance(_WorldSpaceCameraPos, WorldPosition);
+    
+    LIGHT_LOOP_BEGIN(pixelLightCount)
+
+    // TODO FIX: Shadows are kinda borken (with severe acene) due to the vertex jitter. 
+    // ShadowCoord seems to do nothing for additional lights so to fix you'll need to max out the depth
+    // bias in your renderer asset for now.
+    half4 shadowCoord = CalculateShadowMask(inputData);
+    
+    Light light = GetAdditionalLight(lightIndex, WorldPosition, shadowCoord);
+        
+#ifdef _LIGHT_COOKIES
+            light.color *= SampleAdditionalLightCookie(lightIndex, WorldPosition);
+#endif
+    
+    float shadowAtten = (EnableShadows && distToCamera < ShadowDistCutoff) ? light.shadowAttenuation : 1.0;
+    float3 attenuatedLightColor = light.color * (light.distanceAttenuation * shadowAtten) + ShadowTint * (1.0 - shadowAtten);
+        
+    diffuseColor += LightingLambert(attenuatedLightColor, light.direction, WorldNormal);
+    specularColor += LightingSpecular(attenuatedLightColor, light.direction, WorldNormal, WorldView, float4(SpecColor, 0), Smoothness);
+    
+    LIGHT_LOOP_END
+#endif
+
+    Diffuse = diffuseColor;
+    Specular = specularColor;
+}
+
+void AdditionalLights_half(
+    half3 SpecColor,
+    half Smoothness,
+    half3 WorldPosition,
+    half3 WorldNormal,
+    half3 WorldView,
+    bool EnableShadows,
+    half3 ShadowTint,
+    half ShadowDistCutoff,
+
+    out half3 Diffuse,
+    out half3 Specular
+)
+{
+    half3 diffuseColor = 0;
+    half3 specularColor = 0;
+
+#ifndef SHADERGRAPH_PREVIEW
+    Smoothness = exp2(10 * Smoothness + 1);
+    WorldNormal = normalize(WorldNormal);
+    WorldView = SafeNormalize(WorldView);
+
+    uint pixelLightCount = GetAdditionalLightsCount();
+
+    InputData inputData = (InputData) 0;
+    inputData.positionWS = WorldPosition;
+    
+    half4 clipPos = TransformWorldToHClip(WorldPosition);
+    half4 screenPos = ComputeScreenPos(clipPos);
+    inputData.normalizedScreenSpaceUV = screenPos.xy / (screenPos.w + 0.00001);
+    
+    half distToCamera = distance(_WorldSpaceCameraPos, WorldPosition);
+    
+    LIGHT_LOOP_BEGIN(pixelLightCount)
+
+    // TODO FIX: Shadows are kinda borken (with serve acene) due to the vertex jitter. 
+    // ShadowCoord seems to do nothing for additional lights so to fix you'll need to max out the depth
+    // bias in your renderer asset for now.
+    half4 shadowCoord = CalculateShadowMask(inputData);
+    Light light = GetAdditionalLight(lightIndex, WorldPosition, shadowCoord);
+        
+#ifdef _LIGHT_COOKIES
+            light.color *= SampleAdditionalLightCookie(lightIndex, WorldPosition);
+#endif
+
+    half shadowAtten = (EnableShadows && distToCamera < ShadowDistCutoff) ? light.shadowAttenuation : 1.0;
+    half3 attenuatedLightColor = light.color * (light.distanceAttenuation * shadowAtten) + ShadowTint * (1.0 - shadowAtten);
+        
+    diffuseColor += LightingLambert(attenuatedLightColor, light.direction, WorldNormal);
+    specularColor += LightingSpecular(attenuatedLightColor, light.direction, WorldNormal, WorldView, half4(SpecColor, 0), Smoothness);
+    
+    LIGHT_LOOP_END
+#endif
+
+    Diffuse = diffuseColor;
+    Specular = specularColor;
+}
+
+#endif

Assets/ColbyO/VNTG/Shaders/HLSL/PSXLighting_URP.hlsl.meta

@@ -0,0 +1,7 @@
+fileFormatVersion: 2
+guid: c17b1d34fba9c6b488aa65b97f09548f
+ShaderIncludeImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/ColbyO/VNTG/Shaders/PSXDecal_URP.shadergraph.meta

@@ -0,0 +1,18 @@
+fileFormatVersion: 2
+guid: d62425031816f1f4bbf90a161f7cc711
+ScriptedImporter:
+  internalIDToNameTable: []
+  externalObjects: {}
+  serializedVersion: 2
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+  script: {fileID: 11500000, guid: 625f186215c104763be7675aa2d941aa, type: 3}
+  useAsTemplate: 0
+  exposeTemplateAsShader: 0
+  template:
+    name: 
+    category: 
+    description: 
+    icon: {instanceID: 0}
+    thumbnail: {instanceID: 0}

Assets/ColbyO/VNTG/Shaders/PSXMaster_URP.shadergraph.meta

@@ -0,0 +1,18 @@
+fileFormatVersion: 2
+guid: 2668c7952a46ee1419e6d867b9bdd3dc
+ScriptedImporter:
+  internalIDToNameTable: []
+  externalObjects: {}
+  serializedVersion: 2
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+  script: {fileID: 11500000, guid: 625f186215c104763be7675aa2d941aa, type: 3}
+  useAsTemplate: 0
+  exposeTemplateAsShader: 0
+  template:
+    name: 
+    category: 
+    description: 
+    icon: {instanceID: 0}
+    thumbnail: {instanceID: 0}

Assets/ColbyO/VNTG/Shaders/PSXSkybox_URP.shadergraph.meta

@@ -0,0 +1,18 @@
+fileFormatVersion: 2
+guid: 1de64af38ad918a479e9e5882f4d8f86
+ScriptedImporter:
+  internalIDToNameTable: []
+  externalObjects: {}
+  serializedVersion: 2
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+  script: {fileID: 11500000, guid: 625f186215c104763be7675aa2d941aa, type: 3}
+  useAsTemplate: 0
+  exposeTemplateAsShader: 0
+  template:
+    name: 
+    category: 
+    description: 
+    icon: {instanceID: 0}
+    thumbnail: {instanceID: 0}

Assets/ColbyO/VNTG/Shaders/PSXTerrian_URP.shadergraph.meta

@@ -0,0 +1,18 @@
+fileFormatVersion: 2
+guid: 08689d0f8f30c1542b9d82b785967c38
+ScriptedImporter:
+  internalIDToNameTable: []
+  externalObjects: {}
+  serializedVersion: 2
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+  script: {fileID: 11500000, guid: 625f186215c104763be7675aa2d941aa, type: 3}
+  useAsTemplate: 0
+  exposeTemplateAsShader: 0
+  template:
+    name: 
+    category: 
+    description: 
+    icon: {instanceID: 0}
+    thumbnail: {instanceID: 0}

Assets/ColbyO/VNTG/Shaders/PSXWater_URP.shadergraph.meta

@@ -0,0 +1,18 @@
+fileFormatVersion: 2
+guid: 22f423f19b193dc428c0014aa2a2ecb5
+ScriptedImporter:
+  internalIDToNameTable: []
+  externalObjects: {}
+  serializedVersion: 2
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+  script: {fileID: 11500000, guid: 625f186215c104763be7675aa2d941aa, type: 3}
+  useAsTemplate: 0
+  exposeTemplateAsShader: 0
+  template:
+    name: 
+    category: 
+    description: 
+    icon: {instanceID: 0}
+    thumbnail: {instanceID: 0}

Assets/ColbyO/VNTG/Shaders/ShaderLab.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 08151d6606d24c54cb348304d491e1d3
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/ColbyO/VNTG/Shaders/ShaderLab/CRTFilter_URP.shader

@@ -0,0 +1,689 @@
+//-----------------------------------------------------------------------
+// Author:  Colby-O
+// File:    CRTFilter_URP.shader
+//-----------------------------------------------------------------------
+
+Shader "Hidden/CRTFilter_URP"
+{
+    Properties
+    {
+        [HideInInspector] _MainTex("InputTex", 2D) = "white" {}
+    }
+
+    SubShader
+    {
+        Tags { "RenderType" = "Opaque" "RenderPipeline" = "UniversalPipeline" }
+        LOD 100
+        ZTest Always ZWrite Off Cull Off
+
+        Pass
+        {
+            Name "CRTFilterPass"
+
+            HLSLPROGRAM
+            #pragma vertex Vert
+            #pragma fragment frag
+
+            #include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/Core.hlsl"
+            #include "Packages/com.unity.render-pipelines.core/Runtime/Utilities/Blit.hlsl"
+
+            TEXTURE2D(_PrevFrameTex);
+
+            int _InterlaceOffset;
+            float _ShouldRefresh;
+            float _ForceRefresh;
+            float _RefreshRate;
+            float _DecayRate;
+            int _EnableInterlacedRendering;
+            int _IsMonochrome;
+            
+            float _NoiseSpeed, _NoiseScale, _NoiseFade;
+            float2 _NoiseRGBOffset;
+            int _EnableScreenBend;
+            float _ScreenBend, _ScreenRoundness, _VignetteOpacity;
+            float2 _ScreenResolution;
+            float2 _ScanLineOpacity, _ScanLineSpeed;
+            float _ScanLineStrength;
+            float _Brightness, _Contrast, _Saturation, _Gamma, _Hue;
+            float _RedShift, _BlueShift, _GreenShift;
+            float _ChromaticOffset, _ChromaticSpeed;
+
+            float _VHSSmear;          
+            float _UnsharpAmount;     
+            float _UnsharpRadius;     
+            float _UnsharpThreshold;  
+            float _ClampBlack;        
+            float _ClampWhite;        
+            float3 _TintShadowsColor; 
+            
+            int _EnableTrackerLine;
+            float _TrackingSpeed;     
+            float _TrackingJitter; 
+            int _EnableSignalInterference;
+            float _InterferenceFrequency;   
+            float _InterferenceAmplitude;
+
+            int _SubPixelMode;
+            float _SubPixelDesnity; 
+
+            float _GlitchChance;
+            float _GlitchLength;
+
+            /**
+            * Pushes UV coordinates outward towards the endge of the screen base on _ScreenBend factor.
+            *
+            * @param uv  The input coordinate..
+            * @return    The distorted UV coordinates.          
+            */
+            float2 CurveRemap(float2 uv) 
+            {
+                // Remaps uvs from [0, 1] -> [-1, 1]
+                uv = uv * 2.0 - 1.0f;
+
+                // Calculates distortion offset
+                float2 offset = abs(uv.yx) / _ScreenBend;
+                uv = uv + uv * offset * offset;
+
+                // Remaps uvs from [-1, 1] -> [0, 1]
+                uv = uv * 0.5 + 0.5;
+                return uv;
+            }
+
+            /**
+            * Creates a vignette mask based on the screen uv and _VignetteOpacity and _ScreenRoundness.
+            *
+            * @param uv  The input coordinate.
+            * @return    The intensity of the vignette          
+            */
+            float GetVignetteMask(float2 uv) 
+            {
+                // Calculates the distance from the edge
+                uv *= 1.0 - uv.yx;
+
+                // Scales the distance by opacity
+                float vig = abs(uv.x * uv.y * 100.0 * _VignetteOpacity);
+
+                // Apply power function for roundness/falloff control
+                return clamp(pow(vig, _ScreenRoundness), 0.0, 1.0);
+            } 
+
+            /**
+            * Generates a pseudo-random white noise value based on coordinates.
+            *
+            * @param p      The input coordinate.
+            * @param phase  A constant to offset the noise pattern.
+            * @param seed   Changes the generated noise map.
+            * @return       A random float value in the range [0.0, 1.0].     
+            */
+            float WhiteNoise(float2 p, float phase, float seed)
+            {
+                float2 magic = float2(12.9898 + seed, 78.233 + seed);
+                return frac(sin(dot(p + phase, magic)) * 43758.5453);
+            }
+
+            /**
+            * Generates Value Noise by interpolating random values at grid corners.
+            *
+            * @param uv      The input coordinate.
+            * @return        A random valaue in the range [0.0, 1.0].
+            */
+            float ValueNoise(float2 uv) 
+            {
+                // Generate noise map seed based on _NoiseSpeed and _RefreshRate
+                float seed = fmod(floor(_Time.y * _NoiseSpeed * _RefreshRate) / _RefreshRate, 100.0);
+
+                // Fetch current grid cell.
+                float2 ip = floor(uv);
+                float2 fp = frac(uv);
+
+                // Get random values for the four corners of the current grid cell.
+                float a = WhiteNoise(ip, 0, seed);
+                float b = WhiteNoise(ip + float2(1.0, 0.0), 0, seed);
+                float c = WhiteNoise(ip + float2(0.0, 1.0), 0, seed);
+                float d = WhiteNoise(ip + float2(1.0, 1.0), 0, seed);
+
+                // Blends the 4 corner values together
+                float2 e = smoothstep(0.0, 1.0, fp);
+                return lerp(
+                    lerp(a, b, e.x),
+                    lerp(c, d, e.x),
+                    e.y
+                );
+            }
+
+            /**
+            * Generates a 3-channel chromatic noise effect by offsetting samples per color channel.
+            *
+            * @param uv      The input coordinate.
+            * @return        A float3 containing randomized values for R, G, and B.
+            */
+            inline float3 GetChromaticNoise(float2 uv) 
+            {
+                // Scale the coordinates
+                float2 noiseUV = uv * 250.0 * _NoiseScale;
+
+                // Shift the UVs for the Red and Blue channels
+                float r = ValueNoise(noiseUV + _NoiseRGBOffset);
+                float g = ValueNoise(noiseUV);
+                float b = ValueNoise(noiseUV - _NoiseRGBOffset);
+
+                float3 finalNoise = float3(r, g, b);
+
+                return finalNoise;
+            }
+
+            /**
+            * Generates a scanline modulation factor based on screen coordinates and time.
+            *
+            * @param uv      The input coordinate.
+            * @return        A scaling factor used to darken or brighten pixels to simulate CRT scanlines.
+            */
+            inline float GetScanlineFactor(float2 uv) 
+            {
+                // Calculates a value from a 2D sin wave between [-1, 1]. 
+                float2 intensity = float2(
+                    sin(uv.x * _ScreenResolution.x + _Time.y * _ScanLineSpeed.x * 100.0), 
+                    cos(uv.y * _ScreenResolution.y + _Time.y * _ScanLineSpeed.y * 100.0)
+                ) * _ScanLineStrength;
+
+                // Remaps value from [-1, 1] -> [0, 1]
+                intensity = (0.5 * intensity) + 0.5;
+
+                //  Weighs the individual scanline contribution 
+                float scanVal = dot(intensity, _ScanLineOpacity);
+
+                // Normalization factor
+                float weight = 0.5 * (_ScanLineOpacity.x + _ScanLineOpacity.y);
+
+                return (weight > 0.0) ? scanVal / weight : 1.0;
+            }
+
+            /**
+             * Determines whether the current pixel should be updated.
+             *
+             * @param uv    The input coordinate.
+             * @return      True if the pixel should be refreshed; false if it should retain previous data.
+             */
+            inline bool ShouldRefresh(float2 uv) 
+            {
+                // Identify if the current row is even or odd, adjusted by a frame-toggled offset
+                float lin = floor(uv.y * _ScreenResolution.y);
+                bool isInteralcedRow = ((int(lin) + _InterlaceOffset) & 1) == 0;
+
+                // Refresh if: 
+                // 1. Interlacing is OFF and it is the active row
+                // 2. CRT is in a refresh frame (_Refresh = 1)
+                return !(isInteralcedRow && _EnableInterlacedRendering) * (_ShouldRefresh > 0.5);
+            }
+
+            /**
+             * Retrieves the color from the previous frame and applies a time-based 
+             * exponential decay to simulate phosphorus persistence.
+             *
+             * @param uv    The input coordinate.
+             * @return      The decayed RGB color value from the previous frame.
+             */
+            inline float3 GetLastFrameColor(float2 uv) 
+            {
+                float3 prevFrame = SAMPLE_TEXTURE2D(_PrevFrameTex, sampler_LinearClamp, uv).rgb;
+                float decay = pow(abs(_DecayRate), unity_DeltaTime.x);
+                return prevFrame * decay;
+            }
+            
+            /**
+             * Calculates a horizontal displacement to simulate signal interference.
+             *
+             * @param uv      The input coordinate.
+             * @return        A horizontal offset value for the UV coordinates.
+             */
+            inline float CalculateInterference(float2 uv) 
+            {
+                // Divide the screen into discrete horizontal bands based on frequency.
+                float phaseNumber = floor(uv.y * _InterferenceFrequency / _ScreenResolution.y);
+                
+                // Generate a random value for each band.
+                float offsetNoiseModifier = WhiteNoise(float2(phaseNumber + 1, phaseNumber), 0.0, 10.0);
+                
+                // Calculate the offset.
+                float offsetUV = sin((uv.y + frac(_Time.y * 0.05)) * 6.28318 * _InterferenceFrequency) * (0.002 * offsetNoiseModifier);
+                
+                // Scales the offset. 
+                return offsetUV * _InterferenceAmplitude * _EnableSignalInterference;
+            }
+
+            /**
+             * Resamples UV coordinates to snap them to the nearest pixel grid.
+             *
+             * @param rawUV The original UV coordinate.
+             * @return      The UV coordinate snapped to the screen resolution.
+             */
+            inline float2 CalculateResampledUVs(float2 rawUV) 
+            {
+                return floor(rawUV * _ScreenResolution) / _ScreenResolution;
+            }
+
+            /**
+             * Calculates a horizontal UV offset to simulate analog VCR tracking errors.
+             *
+             * @param uv    The input coordinate.
+             * @return      A horizontal offset value for the UV coordinates.
+             */
+            inline float CalculateScanlineShift(float2 uv)
+            {
+                // Create a normalized time factor (0 to 1)
+                float t = 1.0 - fmod(_Time.y, _TrackingSpeed) / _TrackingSpeed;
+                
+                // Map the time factor to a specific vertical pixel position on the screen
+                float trackingStart = fmod(t * _ScreenResolution.y, _ScreenResolution.y);
+                
+                // Add high-frequency randomness to the bar's position
+                float trackingJitter = WhiteNoise(float2(5000.0, 5000.0), 0.0, frac(_Time.y)) * _TrackingJitter;
+                trackingStart += trackingJitter;
+
+                // Determine if the current pixel's vertical position is below the tracking line
+                float isBelow = step(trackingStart, uv.y * _ScreenResolution.y);
+                
+                float offset = 0.003;
+                return (isBelow * offset) * _EnableTrackerLine;
+            }
+
+            /**
+             * Generates a adding bright, noisy blocks at random vertical positions.
+             *
+             * @param originalSceneColor  The current pixel's color.
+             * @param uv                  The input coordinate.
+             * @return                    The modified scene color with potential glitch artifacts.
+             */
+            inline float3 CalculateGlitchArtifact(float3 originalSceneColor, float2 uv) 
+            {
+                float3 scene = originalSceneColor;
+
+                // Determine if a glitch line should trigger for this frame
+                if(_GlitchChance > 0.001 && WhiteNoise(float2(600.0, 500.0), 0.0, frac(_Time.y * 20.0)) > 1.0 - _GlitchChance)
+                {
+                    // Pick a random y coordinate for the line to appear
+                    float randomY = WhiteNoise(float2(800.0, 50.0), 0.0, frac(_Time.y));
+                    float lineStart = floor(randomY * _ScreenResolution.y);
+        
+                    float thickness = 2.0; 
+                    float currentPixelY = uv.y * _ScreenResolution.y;
+
+                    // Check if the current pixel falls within the vertical thickness of the glitch line
+                    if(currentPixelY >= lineStart && currentPixelY < lineStart + thickness)
+                    {
+                        // Calculate randomized horizontal block scaling
+                        float lengthVar = WhiteNoise(float2(lineStart, 123.45), 0.0, frac(_Time.y * 2.0));
+                        float horizontalScale = _GlitchLength * lerp(0.5, 1.0, lengthVar);
+                        float xBlock = floor(uv.x * horizontalScale);
+            
+                        // Create blocky noise patterns along the horizontal line
+                        float blockNoise = WhiteNoise(float2(xBlock, lineStart), 0.0, frac(_Time.y * 5.0));
+            
+                        if(blockNoise > 0.8) 
+                        {
+                            // Apply high frequency grit to the block
+                            float xSeed = floor(uv.x * _ScreenResolution.x);
+                            float grit = WhiteNoise(float2(xSeed, lineStart), 0.0, frac(_Time.y * 15.0));
+
+                            // Applies the artifact
+                            scene.rgb += max(0.8 - grit, 0.0) * 2.0; 
+                        }
+                    }
+                }
+
+                return saturate(scene);
+            }
+
+            /**
+             * Rotates the hue of an RGB color using the Rodrigues' rotation formula.
+             *
+             * @param aColor  The input RGB color.
+             * @param aHue    The rotation angle in degrees.
+             * @return        The color with the shifted hue.
+             */
+            inline half3 ApplyHue(half3 aColor, float aHue)
+            {
+                half angle = radians(aHue);
+
+                // The normalized vector (1,1,1) / sqrt(3)
+                half3 k = half3(0.57735, 0.57735, 0.57735);
+                
+                half cosAngle = cos(angle);
+
+                // Rodrigues' rotation formula: Vrot = V*cos(th) + (K x V)*sin(th) + K*(K . V)*(1 - cos(th))
+                return aColor * cosAngle + cross(k, aColor) * sin(angle) + k * dot(k, aColor) * (1.0 - cosAngle);
+            }
+
+            /**
+             * Applies a Hue, Saturation, Brightness and 
+             * grading effects including Contrast, Gamma, and Saturation.
+             *
+             * @param startColor  The input RGB color.
+             * @return            The final processed color.
+             */
+            inline half3 ApplyHSBEffect(half3 startColor)
+            {
+                // Remap normalized input parameters
+                float hue = 360.0 * _Hue;
+                float brightness = _Brightness * 2.0 - 1.0; 
+                float contrast = _Contrast * 2.0;           
+                float saturation = _Saturation * 2.0;       
+                float gamma = (_Gamma < 0.5) 
+                    ? lerp(0.1, 1.0, _Gamma * 2.0) 
+                    : lerp(1.0, 4.0, (_Gamma - 0.5) * 2.0);
+
+                // Shift Hue using Rodrigues' rotation formula
+                half3 outputColor = ApplyHue(startColor, hue);
+
+                // Adjust Contrast (scales around the 0.5 middle point)
+                outputColor = (outputColor - 0.5f) * contrast + 0.5f;
+
+                // Adjust Brightness
+                outputColor = outputColor + brightness;
+
+                // Apply Gamma Correction
+                outputColor = pow(max(outputColor, 0.0), 1.0 / max(gamma, 0.01));
+
+                // Adjust Saturation by interpolating between grayscale and color
+                half3 intensity = dot(outputColor, half3(0.299, 0.587, 0.114));
+                outputColor = lerp(intensity, outputColor, saturation);
+
+                return saturate(outputColor);
+            }
+
+            /**
+             * Enhances image sharpness by isolating high-frequency details and amplifying them.
+             *
+             * @param col        The input RGB color.
+             * @param uv         The input coordinate.
+             * @param amount     The strength of the sharpening effect.
+             * @param radius     The distance (in pixels) used to sample the surrounding blur.
+             * @param threshold  The minimum luminance difference required to apply sharpening.
+             * @return           The sharpened color.
+             */
+            inline float3 UnsharpMask(float3 col, float2 uv, float amount, float radius, float threshold)
+            {
+                // Calculate the size of a single pixel relative to the screen resolution
+                float2 texel = 1.0 / _ScreenResolution;
+                
+                // Create a simple 4-tap box blur by sampling corners around the pixel
+                float3 blur = 0;
+                blur += SAMPLE_TEXTURE2D(_BlitTexture, sampler_LinearClamp, uv + float2(-radius, -radius) * texel).rgb;
+                blur += SAMPLE_TEXTURE2D(_BlitTexture, sampler_LinearClamp, uv + float2( radius, -radius) * texel).rgb;
+                blur += SAMPLE_TEXTURE2D(_BlitTexture, sampler_LinearClamp, uv + float2(-radius,  radius) * texel).rgb;
+                blur += SAMPLE_TEXTURE2D(_BlitTexture, sampler_LinearClamp, uv + float2( radius,  radius) * texel).rgb;
+                blur *= 0.25; // Average the four samples
+
+                // Isolate the detail
+                float3 detail = col - blur;
+
+                // Apply a noise threshold so subtle gradients aren't over-sharpened
+                float lumDiff = abs(dot(detail, float3(0.299, 0.587, 0.114)));
+                if(lumDiff < threshold) detail = float3(0, 0, 0);
+
+                // Add the weighted detail back to the original image
+                col += detail * amount;
+
+                return saturate(col);
+            }
+
+            /**
+             * Restricts the color components to a specified range.
+             *
+             * @param col         The input RGB color.
+             * @param blackLevel  The minimum allowable value.
+             * @param whiteLevel  The maximum allowable value.
+             * @return            The color restricted to the [blackLevel, whiteLevel].
+             */
+            inline float3 ClampLevels(float3 col, float blackLevel, float whiteLevel)
+            {
+                col.rgb = clamp(col, blackLevel, whiteLevel);
+                return col;
+            }
+
+             /**
+             * Calculates the perceived brightness (Luminance) of an RGB color
+             *
+             * @param c  The input RGB color.
+             * @return   The brightness of the color.
+             */
+            inline float GetLuminance(float3 c)
+            {
+                return dot(c, float3(0.299, 0.587, 0.114));
+            }
+
+            /**
+             * Applies a color tint to the darker regions of the image.
+             *
+             * @param col          The input RGB color.
+             * @param shadowColor  The color to be multiplied into the shadow regions.
+             * @return             The color with tinted shadows.
+             */
+            inline float3 TintShadows(float3 col, float3 shadowColor)
+            {
+                float lum = GetLuminance(col);
+                float shadowMask = smoothstep(0.0, 0.3, 0.3 - lum); 
+                col = lerp(col, col * shadowColor, shadowMask);
+                return col;
+            }
+
+            /**
+             * Simulates VHS style horizontal blurring and signal degradation.
+             *
+             * @param uv       The original texture coordinates.
+             * @param ratio    The resolution reduction factor.
+             * @param xOffset  Horizontal shift for the signal.
+             * @return         The color at the shifted, quantized, and interpolated coordinate.
+             */
+            inline float3 GetVHSColor(float2 uv, float ratio, float xOffset)
+            {
+                // Calculate the width of a single band in UV space
+                float bandWidth = 1.0 / max(_ScreenResolution.x * ratio, 1e-5);
+
+                // Apply the horizontal offset to the current coordinate
+                float2 shiftedUV = float2(uv.x + xOffset, uv.y);
+
+                // Quantize the X coordinate to find the pixel boundaries
+                float quantizedX = floor(shiftedUV.x / bandWidth) * bandWidth;
+                float2 uvA = float2(quantizedX, shiftedUV.y);
+                float2 uvB = float2(quantizedX + bandWidth, shiftedUV.y);
+
+                // Calculate the interpolation weight between the two bands
+                float t = (shiftedUV.x - quantizedX) / bandWidth;
+
+                // Sample the texture at the two nearest horizontal quantized points
+                float3 colA = SAMPLE_TEXTURE2D(_BlitTexture, sampler_LinearClamp, uvA).rgb;
+                float3 colB = SAMPLE_TEXTURE2D(_BlitTexture, sampler_LinearClamp, uvB).rgb;
+
+                return lerp(colA, colB, t);
+            }
+
+            /**
+             * Clamps out-of-range colors while preserving the original hue and luminance.
+             *
+             * @param    The input RGB color.
+             * @return   The color remapped into the valid range.
+             */
+            inline float3 ClipColor(float3 c) {
+                float l = GetLuminance(c);
+                float n = min(min(c.r, c.g), c.b);
+                float x = max(max(c.r, c.g), c.b);
+                if (n < 0.0) c = l + (((c - l) * l) / (l - n));
+                if (x > 1.0) c = l + (((c - l) * (1.0 - l)) / (x - l));
+                return c;
+            }
+
+            /**
+             * Adjusts the color to a specific target luminance while preserving hue and saturation.
+             *
+             * @param c  The input RGB color.
+             * @param l  The target luminance value.
+             * @return   A color with the new luminance.
+             */
+            inline float3 SetLum(float3 c, float l) {
+                float d = l - GetLuminance(c);
+                c += d;
+                return ClipColor(c);
+            }
+
+            /**
+             * Combining smear effects with chromatic aberration.
+             *
+             * @param scene  The current scene color.
+             * @param uv     The input coordinates.
+             * @return       A reconstructed color where RGB channels are horizontally misaligned.
+             */
+            inline float3 CalculateVHSDamage(float3 scene, float2 uv)
+            {
+                float chromOffset = _ChromaticOffset * cos(_Time.y * _ChromaticSpeed) / 10.0;
+
+                float colVHSR = GetVHSColor(uv, _VHSSmear, -chromOffset).r;
+                float colVHSG = GetVHSColor(uv, _VHSSmear,  chromOffset).g;
+                float colVHSB = GetVHSColor(uv, _VHSSmear, 0.0).b;
+                return float3(colVHSR, colVHSG, colVHSB);
+            }
+
+            /**
+             * Performs a color shift while preserving luminance.
+             *
+             * @param scene  The input RGB color.
+             * @return       The color with shifted tones.
+             */
+            inline float3 ApplyColorShift(float3 scene)
+            {
+                float3 shiftedCol = scene;
+                shiftedCol.r *= (1.0 + _RedShift);
+                shiftedCol.g *= (1.0 + _GreenShift);
+                shiftedCol.b *= (1.0 + _BlueShift);
+
+                float originalLuminance = GetLuminance(scene);
+
+                return SetLum(shiftedCol, originalLuminance);
+            }
+
+            /**
+             * Simulates the physical subpixel structure of various CRT monitors.
+             *
+             * @param uv       The input coordinate.
+             * @param col      The input RGB color.
+             * @param density  The frequency of the mask.
+             * @param mode     The CRT type: 1 = Shadow Mask, 2 = Aperture Grille, 3 = Slot Mask.
+             * @return         The color multiplied by the simulated phosphor grid.
+             */
+            inline float3 ApplyCRTSubPixels(float2 uv, float3 col, float density, int mode)
+            {
+                float aspect = _ScreenResolution.x / _ScreenResolution.y;
+                float3 finalColor = col;
+
+                if (mode == 1) 
+                {
+                    // Shadow Mask
+
+                    // Creates a staggered grid of circular phosphor dots.
+                    float2 gv = uv * float2(aspect * density, density * 1.732);
+                    float row = floor(gv.y);
+                    
+                    // Stagger every other row to create the hexagonal triad pattern
+                    gv.x += (frac(row * 0.5) > 0.0) ? 0.5 : 0.0;
+
+                    float2 f = frac(gv);
+                    // Determine if the current dot is Red, Green, or Blue
+                    int index = int(fmod(floor(gv.x) + floor(gv.y) * 1.5, 3.0));
+                    float3 maskColor = float3(index == 0, index == 1, index == 2);
+
+                    // Create the circular shape for the phosphor dot
+                    float dist = distance(f, float2(0.5, 0.5));
+                    float dot = smoothstep(0.45, 0.35, dist);
+
+                    finalColor = col * maskColor * dot * 2.0;
+                }
+                else if (mode == 2) 
+                {
+                    // Aperture Grille
+
+                    float2 gv = uv * float2(aspect * density, density);
+                    int index = int(fmod(floor(gv.x), 3.0));
+                    float3 maskColor = float3(index == 0, index == 1, index == 2);
+
+                    finalColor = col * maskColor;
+                }
+                else if (mode == 3) 
+                {
+                    // Slot Mask
+
+                    float2 gv = uv * float2(aspect * density, density * 0.5); 
+        
+                    float row = floor(gv.y);
+
+                    // Stagger the columns per row
+                    gv.x += (frac(row * 0.5) > 0.0) ? 0.5 : 0.0;
+
+                    float2 f = frac(gv);
+                    int index = int(fmod(floor(gv.x) + floor(gv.y), 3.0));
+                    float3 maskColor = float3(index == 0, index == 1, index == 2);
+
+                    // Shape the mask into elongated vertical rectangles
+                    float2 distScale = float2(1.5, 1.0); 
+                    float dist = length((f - 0.5) * distScale);
+                    float brick = smoothstep(0.45, 0.35, dist);
+
+                    finalColor = col * maskColor * brick * 3.0;
+                }
+
+                return finalColor;
+            }
+
+            float4 frag(Varyings IN) : SV_Target
+            {
+                if (!ShouldRefresh(IN.texcoord) && _ForceRefresh < 0.5) 
+                {
+                    return float4(GetLastFrameColor(IN.texcoord), 1.0);
+                }
+
+                float2 uv = (_EnableScreenBend == 1) ? CurveRemap(IN.texcoord) : IN.texcoord;
+
+                uv.x += CalculateInterference(uv);
+                uv.x += CalculateScanlineShift(uv);
+                uv = CalculateResampledUVs(uv);
+
+                if (uv.x < 0.0 || uv.y < 0.0 || uv.x > 1.0 || uv.y > 1.0) 
+                {
+                    return float4(0.0, 0.0, 0.0, 1.0);
+                } 
+
+                float3 scene = SAMPLE_TEXTURE2D(_BlitTexture, sampler_LinearClamp, uv).rgb;
+
+                float3 combinedVHS = CalculateVHSDamage(scene, uv);
+
+                float3 unsharpCol = UnsharpMask(scene, uv, _UnsharpAmount, _UnsharpRadius, _UnsharpThreshold).rgb;
+
+                float3 col =  SetLum(combinedVHS, GetLuminance(unsharpCol));
+
+                col = ApplyHSBEffect(col);
+                col = ClampLevels(col, _ClampBlack, _ClampWhite);
+                col = TintShadows(col, _TintShadowsColor);
+
+                col = CalculateGlitchArtifact(col, uv);
+                col = lerp(col, col * GetChromaticNoise(uv), _NoiseFade);
+
+                if (_IsMonochrome == 1) 
+                {
+                    col.rgb = dot(col.rgb, float3(0.2125, 0.7154, 0.0721));
+                }
+
+                col = ApplyColorShift(col);
+
+                col = ApplyCRTSubPixels(uv, col, _SubPixelDesnity, _SubPixelMode);
+
+                // TODO: Should be in curved coordinates but using uv causes Moire artifacting.
+                col *= GetScanlineFactor(IN.texcoord);
+
+                col *= GetVignetteMask(uv);
+
+                return float4(col, 1.0);
+
+            }
+            ENDHLSL
+        }
+    }
+}

Assets/ColbyO/VNTG/Shaders/ShaderLab/CRTFilter_URP.shader.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 22c8e59f6a328e04f81d588008473cb8
+ShaderImporter:
+  externalObjects: {}
+  defaultTextures:
+  - _BaseMap: {instanceID: 0}
+  - _MainTex: {instanceID: 0}
+  nonModifiableTextures: []
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/ColbyO/VNTG/Shaders/ShaderLab/PSXMaster_URP.shader

@@ -0,0 +1,483 @@
+//-----------------------------------------------------------------------
+// Author:  Colby-O
+// File:    PSXMaster_URP.shader
+//-----------------------------------------------------------------------
+
+Shader "Hidden/PSXMaster_URP"
+{
+    Properties
+    {
+        [Header(Internal)]
+        _VNTGScreenParams ("Screen Width/Height", Vector) = (1920, 1080, 0, 0)
+
+        [Header(Resolution)]
+        _EnablePixelation ("Enable Pixelation", Float) = 1
+        _EnableLetterbox ("Letterbox To Perserve Aspect Ratio", Float) = 1.0
+        _PixelResolution ("Pixelation Resolution", Vector) = (256, 256, 0, 0)
+        
+        [Header(Color and Dither)]
+        _EnableColorPrecision ("Enable Color Precision", Float) = 1
+        _ColorPrecision ("Color Steps", Float) = 32
+        _DitherPattern ("Dither Pattern", Float) = 1.0
+        _DitherPixelPerfect ("Use Pixel Perfect Dither", Float) = 1.0
+        _DitherRelativeScale("Use Relative Dither Scale", Float) = 1.0
+        _DitherReferenceResolution ("Dither Reference Resolution", Vector) = (1920, 1080, 0, 0)
+        _DitherScale ("Dither Pattern Scale", Float) = 1.0
+        _DitherThreshold ("Dither Sensitivity", Float) = 1.0
+        
+        [Header(Palette)]
+        _EnablePalette ("Enable Color Palette", Float) = 0
+        [Toggle] _PaletteNormalizeLuminance ("Palette Normalize Luminance", Float) = 0
+        [Toggle] _PreserveLighting ("Preserve Lighting Intensity", Float) = 0
+        _PaletteLUT ("3D Color Palette Map", 3D) = "white" {}
+
+        [Header(Fog)]
+        _EnableFog ("Enable Fog", Float) = 0
+        _IgnoreSkybox ("Ignore Skybox", Float) = 0
+        _FogDensity ("Fog Density", Float) = 1.0
+        _FogColor ("Fog Color", Color) = (0, 0, 0, 1)
+        _FogNoiseStrength ("Fog Noise Strength", Float) = 0.1
+        _FogNoiseScale ("Fog Noise Scale", Float) = 10.0
+        _FogNoiseStart ("Fog Noise Start", Float) = 0.7
+        _FogEdgeSmoothness ("Fog Edge Smoothness", Float) = 0.5
+    }
+
+    SubShader
+    {
+        Tags { "RenderPipeline"="UniversalPipeline" }
+        ZWrite Off ZTest Always Cull Off
+
+        Pass
+        {
+            HLSLPROGRAM
+            #pragma vertex Vert
+            #pragma fragment Frag
+
+            #include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/Core.hlsl"
+            #include "Packages/com.unity.render-pipelines.core/Runtime/Utilities/Blit.hlsl"
+            #include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/DeclareDepthTexture.hlsl"
+
+            float2 _VNTGScreenParams;
+
+            float _EnablePixelation;
+            float _EnableLetterbox;
+            float2 _PixelResolution;
+
+            float _EnableColorPrecision;
+            float _ColorPrecision;
+
+            float _EnableDither;
+            float _DitherMode;
+            int _DitherPattern;
+            float _DitherPixelPerfect;
+            float _DitherRelativeScale;
+            float2 _DitherReferenceResolution;
+            float _DitherScale;
+            float _DitherThreshold;
+            
+            float _EnablePalette;
+            float _PaletteNormalizeLuminance;
+            float _PreserveLighting;
+            TEXTURE3D(_PaletteLUT);
+            SAMPLER(sampler_PaletteLUT);
+
+            int _EnableFog;
+            float _IgnoreSkybox;
+            float4 _FogColor;
+            float _FogDensity;
+            float _FogEdgeSmoothness;
+            float _FogNoiseStrength;
+            float _FogNoiseScale;
+            float _FogNoiseStart;
+
+            /**
+            * Generates a random value from a 3D vector.
+            *
+            * @param p  The input 3D coordinates.
+            * @return   A random float value in the range [0.0, 1.0].
+            */
+            inline float Hash31(float3 p)
+            {
+                p = frac(p * 0.1031);
+                p += dot(p, p.yzx + 33.33);
+                return frac((p.x + p.y) * p.z);
+            }
+
+            /**
+            * Calculates a andom gradient vector for a given 3D point.
+            *
+            * @param p  The input 3D coordinates.
+            * @return   A gradient direction.
+            */
+            inline float3 Gradient(float3 p)
+            {
+                float h = Hash31(p) * 6.2831853;
+                return float3(cos(h), sin(h), cos(h * 0.5));
+            }
+
+            /**
+            * Computes the quintic smoothing for Perlin noise.
+            *
+            * @param t  The distance [0, 1] within a cell.
+            * @return   The smoothed weight.
+            */
+            inline float3 Fade(float3 t)
+            {
+                return t * t * t * (t * (t * 6 - 15) + 10);
+            }
+
+            /**
+            * Generates 3D Perlin Noise for a given coordinate.
+            *
+            * @param p  The input 3D coordinates.
+            * @return   A noise value in the range [0.0, 1.0].
+            */
+            inline float Perlin3D(float3 p)
+            {
+                float3 pi = floor(p);
+                float3 pf = frac(p);
+
+                float3 f = Fade(pf);
+
+                // Calculate dot products between corner gradients and distance vectors
+                float n000 = dot(Gradient(pi + float3(0,0,0)), pf - float3(0,0,0));
+                float n100 = dot(Gradient(pi + float3(1,0,0)), pf - float3(1,0,0));
+                float n010 = dot(Gradient(pi + float3(0,1,0)), pf - float3(0,1,0));
+                float n110 = dot(Gradient(pi + float3(1,1,0)), pf - float3(1,1,0));
+                float n001 = dot(Gradient(pi + float3(0,0,1)), pf - float3(0,0,1));
+                float n101 = dot(Gradient(pi + float3(1,0,1)), pf - float3(1,0,1));
+                float n011 = dot(Gradient(pi + float3(0,1,1)), pf - float3(0,1,1));
+                float n111 = dot(Gradient(pi + float3(1,1,1)), pf - float3(1,1,1));
+
+                // Trilinear interpolation
+                float nx00 = lerp(n000, n100, f.x);
+                float nx10 = lerp(n010, n110, f.x);
+                float nx01 = lerp(n001, n101, f.x);
+                float nx11 = lerp(n011, n111, f.x);
+
+                float nxy0 = lerp(nx00, nx10, f.y);
+                float nxy1 = lerp(nx01, nx11, f.y);
+
+                return lerp(nxy0, nxy1, f.z) * 0.5 + 0.5;
+            }
+
+             /**
+             * Calculates the perceived brightness (Luminance) of an RGB color
+             *
+             * @param c  The input RGB color.
+             * @return   The brightness of the color.
+             */
+            inline float GetLuminance(float3 c)
+            {
+                return dot(c, float3(0.299, 0.587, 0.114));
+            }
+
+            /**
+            * Retrieves a predefined 4x4 dither matrix.
+            *
+            * @param index  The index of the desired pattern.
+            * @return       A 4x4 matrix containing the dither pattern.
+            */
+            inline float4x4 GetDitherPattern(int index) {
+                if (index == 0) 
+                {
+                    return float4x4(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
+                }
+                else if (index == 1)
+                {
+                    return float4x4(0, 1, 0, 1, 1, 0, 1, 0, 0, 1, 0, 1, 1, 0, 1, 0);
+                }
+                else if (index == 2)
+                {
+                    return float4x4(0, 8, 2, 10, 12, 4, 14, 6, 3, 11, 1, 9, 15, 7, 13, 5) / 16.0;
+                }
+                else if (index == 3)
+                {
+                    return float4x4(2.0, 0.0, 0.0,  2.0, 0.0,  4.0,  4.0, 0.0, 0.0,  4.0,  4.0, 0.0, 2.0, 0.0, 0.0,  2.0) / 4.0;
+                }
+                else if (index == 4)
+                {
+                    return float4x4(0, 2, 0, 2, 3, 1, 3, 1, 0, 2, 0, 2, 3, 1, 3, 1) / 4.0;
+                }
+                else if (index == 5)
+                {
+                    return float4x4(0, 4, 8, 12, 0, 4, 8, 12, 0, 4, 8, 12, 0, 4, 8, 12) / 16.0;
+                }
+                else if (index == 6)
+                {
+                    return float4x4(0, 0, 0, 0, 8, 8, 8, 8, 15, 15, 15, 15, 8, 8, 8, 8) / 16.0;
+                }
+                else if (index == 7)
+                {
+                    return float4x4(3, 6, 9, 12, 6, 9, 12, 3, 9, 12, 3, 6, 12, 3, 6, 9) / 16.0;
+                }
+                else if (index == 8)
+                {
+                    return float4x4(13, 10, 11, 14, 6, 1, 2, 7, 5, 0, 3, 8, 12, 9, 4, 15) / 16.0;
+                }
+                else if (index == 9)
+                {
+                    return float4x4(0.1, 0.7, 0.3, 0.9, 0.5, 0.2, 0.8, 0.4, 0.9, 0.3, 0.7, 0.1, 0.4, 0.8, 0.2, 0.5);
+                }
+                else if (index == 10)
+                {
+                    return float4x4(1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1);
+                }
+                
+                 return float4x4(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
+            }
+
+            /**
+            * Performs a binary dither check against a 4x4 matrix based on screen coordinates.
+            * Compares the luminance of the scene color against a pattern threshold to decide visibility.
+            *
+            * @param uv         The input coordinate.
+            * @param scene      The input RGB color.
+            * @param pattern    A 4x4 dither matrix.
+            * @param perChannel If 1 uses per channel dithering else uses overall luminance.
+            * @return         1.0 if the scaled luminance exceeds the threshold, otherwise 0.0.
+            */
+            inline float3 GetDitherValue(uint2 uv, float3 scene, float4x4 pattern, int perChannel) 
+            {
+                uint x = uv.x % 4;
+                uint y = uv.y % 4;
+                float threshold = pattern[y][x];
+                float ditherThreshold = _DitherThreshold * 20.0;
+
+                float lum = GetLuminance(scene);
+                float3 lumDither = step(threshold, lum * ditherThreshold);
+                float3 perChannelDither = step(threshold, scene * ditherThreshold);
+
+                return lerp(lumDither, perChannelDither, perChannel);
+            }
+
+            /**
+             * Retrieves the dither offset from a 4x4 pattern for a given screen coordinate.
+             * This value is centered around 0 by subtracting 0.5, allowing additive dithering adjustments.
+             *
+             * @param uv       The input coordinate.
+             * @param pattern  A 4x4 dither matrix.
+             * @return         A float value in the range [-0.5, 0.5] representing the dither shift at the given coordinate.
+             */
+            inline float GetDitherShift(uint2 uv, float4x4 pattern) 
+            {
+                uint x = uv.x % 4;
+                uint y = uv.y % 4;
+                return pattern[y][x] - 0.5;
+            }
+
+            /**
+            * Reduces the color depth of an RGB color into a discrete number of levels.
+            *
+            * @param color  The input RGB color.
+            * @param steps  The number of color levels per channel.
+            * @return       The quantized color vector.
+            */
+            inline float3 Quantize(float3 color, float steps)
+            {
+                return (_EnableColorPrecision > 0.5) ? floor(color * steps) / steps : color;
+            }
+
+            /**
+            * Converts screen space coordinates and depth buffer values back into 3D world space.
+            *
+            * @param uv        The input coordinate.
+            * @param rawDepth  The raw depth value from the Depth Texture.
+            * @return          The reconstructed 3D position.
+            */
+            inline float3 ReconstructWorldPosition(float2 uv, float rawDepth)
+            {
+                float2 screenPos = uv * _ScreenSize.xy;
+                float3 positionRWS = ComputeWorldSpacePosition(uv, rawDepth, UNITY_MATRIX_I_VP);
+                float3 absoluteWS = GetAbsolutePositionWS(positionRWS);
+                return absoluteWS; 
+            }
+
+            /**
+            * Computes the scene color with fog at a coordiante.
+            *
+            * @param uv     The input coordinate.
+            * @param scene  The input RGB color.
+            * @return       The final RGB color with fog.
+            */
+            inline float3 CalculateFog(float2 uv, float3 scene) 
+            {
+                float3 fogColor = scene;
+                if(_EnableFog) 
+                {
+                    // Convert raw depth to linear eye space distance
+                    float rawDepth = SampleSceneDepth(uv);
+                    float linearDepth = LinearEyeDepth(rawDepth, _ZBufferParams);
+
+                    // Exponential squared fog calculation
+                    float fogFactor = abs(1.0 - exp2(-linearDepth * _FogDensity));
+
+                    // 3D noise based on world position
+                    float3 worldPos = ReconstructWorldPosition(uv, rawDepth);
+                    float noise = Perlin3D(worldPos * _FogNoiseScale);
+
+                    // Generate masks to control where noise appears
+                    float noiseMask = pow(fogFactor, _FogNoiseStart);
+                    float edgeMask = abs(fogFactor * (1.0 - fogFactor) * 4.0); 
+                    float speckledMask = pow(edgeMask, _FogEdgeSmoothness); 
+
+                    // Combine fog with noise
+                    float dynamicFog = fogFactor + ((noise - 0.5) * _FogNoiseStrength * speckledMask * noiseMask);
+
+                    fogColor = lerp(scene, _FogColor.rgb, saturate(dynamicFog));
+
+                    #if UNITY_REVERSED_Z
+                        if (_IgnoreSkybox < 0.5 && rawDepth < 0.00001) return lerp(scene, fogColor, pow(_FogDensity, 0.1));
+                    #else
+                        if (_IgnoreSkybox < 0.5 && rawDepth > 0.99999) return lerp(scene, fogColor, pow(_FogDensity, 0.1));
+                    #endif
+                }
+
+                return fogColor;
+            }
+
+            /**
+             * Applies a dithering effect to a scene color at a given screen coordinate.
+             * Supports both luminance-based and per-channel dithering, as well as additive or multiplicative modes.
+             *
+             * @param uv     The input coordinate.
+             * @param scene  The input RGB color.
+             * @return       The dithered RGB color after applying the selected dither mode.
+             */
+            inline float3 ApplyDither(float2 uv, float3 scene) 
+            {
+                float3 finalCol = scene;
+
+                float screenAspect = _VNTGScreenParams.x / _VNTGScreenParams.y;
+                float targetAspect = _DitherReferenceResolution.x / _DitherReferenceResolution.y;
+
+                float aspectScale = (screenAspect < targetAspect) ? (_VNTGScreenParams.y / _DitherReferenceResolution.y) : (_VNTGScreenParams.x / _DitherReferenceResolution.x);
+   
+                float useRelative = step(0.5, _DitherRelativeScale);
+                float scale = useRelative * aspectScale + (1.0 - useRelative);
+
+                float2 pixelCoords = uv * lerp(_VNTGScreenParams, _PixelResolution, _EnablePixelation * _DitherPixelPerfect);
+
+                uint2 ditherCoord = (uint2)(pixelCoords / (scale * max(1.0, _DitherScale)));
+
+                float4x4 pattern = GetDitherPattern(_DitherPattern);
+
+                float perChannelDither = step(0.5, _DitherMode);
+
+                float3 ditherMult = GetDitherValue(ditherCoord, scene.rgb, pattern, perChannelDither); 
+
+                float ditherShift = GetDitherShift(ditherCoord, pattern);
+                float additiveValue = ditherShift * (1.0 / _ColorPrecision) * (1.0 - _DitherThreshold);
+
+                float isMultiplicative = step(_DitherMode, 1.5);
+
+                float3 multCol = finalCol * ditherMult;
+                float3 addCol = saturate(finalCol + additiveValue);
+
+                finalCol = lerp(addCol, multCol, isMultiplicative);
+
+                finalCol = lerp(scene, finalCol, _EnableDither);
+
+                return finalCol;
+            }
+
+             /**
+             * Applies a color palette lookup using a 3D LUT.
+             *
+             * @param  The input RGB color. 
+             * @return Remapped RGB color from the palette LUT      
+             */
+            inline float3 ApplyPaletteLookup(float3 color)
+            {
+                float originalLength = length(color);
+                float originalLum = GetLuminance(color);
+
+                if (_PaletteNormalizeLuminance > 0.5)
+                {
+                    if (originalLength < 0.0001)
+                    {
+                        return float3(0.0, 0.0, 0.0);
+                    }
+        
+                    float3 normalizedColor = color / originalLength;
+                    float3 uvw = normalizedColor * (31.0 / 32.0) + (0.5 / 32.0);
+                    float3 matchedColor = SAMPLE_TEXTURE3D(_PaletteLUT, sampler_PaletteLUT, uvw).rgb;
+
+                    if (_PreserveLighting > 0.5)
+                    {
+                        float matchedLum = GetLuminance(matchedColor);
+
+                        if (matchedLum > 0.0001)
+                        {
+                            matchedColor *= (originalLum / matchedLum);
+                        }
+                    }
+
+                    return matchedColor;
+                }
+                else
+                {
+                    float3 uvw = color * (31.0 / 32.0) + (0.5 / 32.0);
+                    float3 matchedColor = SAMPLE_TEXTURE3D(_PaletteLUT, sampler_PaletteLUT, uvw).rgb;
+
+                    if (_PreserveLighting > 0.5)
+                    {
+                        float matchedLum = GetLuminance(matchedColor);
+
+                        if (matchedLum > 0.0001)
+                        {
+                            matchedColor *= (originalLum / matchedLum);
+                        }
+                    }
+
+                    return matchedColor;
+                }
+            }
+
+            float4 Frag(Varyings IN) : SV_Target
+            {
+                float2 uv = IN.texcoord;
+                float mask = 1.0;
+                if (_EnableLetterbox > 0.5 && _EnablePixelation > 0.5)
+                {
+                    float targetAspect = _PixelResolution.x / _PixelResolution.y;
+                    float screenAspect = _VNTGScreenParams.x / _VNTGScreenParams.y;
+
+                    float2 scale = 1.0;
+                    if (screenAspect > targetAspect)
+                    {
+                        scale.x = screenAspect / targetAspect;
+                    }
+                    else 
+                    {
+                        scale.y = targetAspect / screenAspect;
+                    }
+
+                    uv = (IN.texcoord - 0.5) * scale + 0.5;
+
+                    float2 border = step(0.0, uv) * step(uv, 1.0);
+                    mask = border.x * border.y;
+                }
+
+                float2 pixel = floor(uv * _PixelResolution);
+                float2 downsampledUV = (_EnablePixelation > 0.5) ? (pixel + 0.5) / _PixelResolution : uv;
+
+                float4 scene = SAMPLE_TEXTURE2D_X(_BlitTexture, sampler_PointClamp, downsampledUV);
+
+                float3 finalCol = ApplyDither((_DitherPixelPerfect > 0.5) ? uv : IN.texcoord, scene.rgb);
+
+                finalCol = Quantize(finalCol, _ColorPrecision);
+
+                if (_EnablePalette > 0.5)
+                {
+                    finalCol = ApplyPaletteLookup(finalCol);
+                }
+
+                finalCol = CalculateFog(downsampledUV, finalCol);
+
+                return float4(finalCol * mask, scene.a);
+            }
+            ENDHLSL
+        }
+    }
+}

Assets/ColbyO/VNTG/Shaders/ShaderLab/PSXMaster_URP.shader.meta

@@ -0,0 +1,9 @@
+fileFormatVersion: 2
+guid: 715bb3216359838429a3cdf88e70e962
+ShaderImporter:
+  externalObjects: {}
+  defaultTextures: []
+  nonModifiableTextures: []
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/ColbyO/VNTG/Shaders/ShaderLab/UnlitWhite.shader

@@ -0,0 +1,55 @@
+Shader "Hidden/ColbyO/VNTG/UnlitWhite"
+{
+    SubShader
+    {
+        Tags { "RenderType"="Opaque" "Queue"="Geometry" "InteractionNormalPass" = "Enabled"}
+        Pass
+        {
+            ZTest LEqual
+            ZWrite On
+            Cull Off
+
+            HLSLPROGRAM
+            #pragma vertex vert
+            #pragma fragment frag
+            #include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/Core.hlsl"
+
+            struct Attributes
+            {
+                float4 posOS   : POSITION;
+                float3 normalOS : NORMAL;
+            };
+
+            struct Varyings
+            {
+                float4 posCS    : SV_POSITION;
+                float3 normalWS : TEXCOORD0;
+            };
+
+            struct FragmentOutput {
+                float4 mask   : SV_Target0;
+                float4 normal : SV_Target1;
+            };
+
+            Varyings vert(Attributes IN)
+            {
+                Varyings OUT;
+                OUT.posCS = TransformObjectToHClip(IN.posOS.xyz);
+                OUT.normalWS = TransformObjectToWorldNormal(IN.normalOS);
+                return OUT;
+            }
+
+            FragmentOutput frag(Varyings IN) : SV_Target
+            {
+                FragmentOutput output;
+                output.mask = float4(1, 1, 1, 1);
+                
+                float3 normal = normalize(IN.normalWS);
+                output.normal = float4(normal * 0.5 + 0.5, 1.0); 
+                
+                return output;
+            }
+            ENDHLSL
+        }
+    }
+}

Assets/ColbyO/VNTG/Shaders/ShaderLab/UnlitWhite.shader.meta

@@ -0,0 +1,9 @@
+fileFormatVersion: 2
+guid: e8d89ea5aecc78841ae69d0531a28b9d
+ShaderImporter:
+  externalObjects: {}
+  defaultTextures: []
+  nonModifiableTextures: []
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/ColbyO/VNTG/Shaders/SubGraphs.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 750ea32c45f0e1e4992926415c38eb93
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/ColbyO/VNTG/Shaders/SubGraphs/Color.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 242986c8533b25b48a567056513e6627
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/ColbyO/VNTG/Shaders/SubGraphs/Color/ApplyPalette.shadersubgraph.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 7dbb064d17522094796e90cf1caf1f10
+ScriptedImporter:
+  internalIDToNameTable: []
+  externalObjects: {}
+  serializedVersion: 2
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+  script: {fileID: 11500000, guid: 60072b568d64c40a485e0fc55012dc9f, type: 3}
+  documentationPath: 

Assets/ColbyO/VNTG/Shaders/SubGraphs/Color/HSVAdjustment.shadersubgraph.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 23fbc3645af98634e8fd53ad4cde92b3
+ScriptedImporter:
+  internalIDToNameTable: []
+  externalObjects: {}
+  serializedVersion: 2
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+  script: {fileID: 11500000, guid: 60072b568d64c40a485e0fc55012dc9f, type: 3}
+  documentationPath: 

Assets/ColbyO/VNTG/Shaders/SubGraphs/Color/HSVToRGB.shadersubgraph

@@ -0,0 +1,341 @@
+{
+    "m_SGVersion": 3,
+    "m_Type": "UnityEditor.ShaderGraph.GraphData",
+    "m_ObjectId": "4d95310cb76940b998fc09a65b2ba2fb",
+    "m_Properties": [
+        {
+            "m_Id": "71a062c74bec4becb202b5f941113a4c"
+        }
+    ],
+    "m_Keywords": [],
+    "m_Dropdowns": [],
+    "m_CategoryData": [
+        {
+            "m_Id": "ff1b363c78fb446ea8a8e78e4c8eda90"
+        }
+    ],
+    "m_Nodes": [
+        {
+            "m_Id": "2cd3d06e0f9549098608e4899a5376bd"
+        },
+        {
+            "m_Id": "791727392c2d4422a020ae5e42a26c20"
+        },
+        {
+            "m_Id": "d4dcaaf6f1d7418f8b5df3997d75dc35"
+        }
+    ],
+    "m_GroupDatas": [],
+    "m_StickyNoteDatas": [],
+    "m_Edges": [
+        {
+            "m_OutputSlot": {
+                "m_Node": {
+                    "m_Id": "791727392c2d4422a020ae5e42a26c20"
+                },
+                "m_SlotId": 1
+            },
+            "m_InputSlot": {
+                "m_Node": {
+                    "m_Id": "2cd3d06e0f9549098608e4899a5376bd"
+                },
+                "m_SlotId": 1
+            }
+        },
+        {
+            "m_OutputSlot": {
+                "m_Node": {
+                    "m_Id": "d4dcaaf6f1d7418f8b5df3997d75dc35"
+                },
+                "m_SlotId": 0
+            },
+            "m_InputSlot": {
+                "m_Node": {
+                    "m_Id": "791727392c2d4422a020ae5e42a26c20"
+                },
+                "m_SlotId": 0
+            }
+        }
+    ],
+    "m_VertexContext": {
+        "m_Position": {
+            "x": 0.0,
+            "y": 0.0
+        },
+        "m_Blocks": []
+    },
+    "m_FragmentContext": {
+        "m_Position": {
+            "x": 0.0,
+            "y": 0.0
+        },
+        "m_Blocks": []
+    },
+    "m_PreviewData": {
+        "serializedMesh": {
+            "m_SerializedMesh": "{\"mesh\":{\"instanceID\":0}}",
+            "m_Guid": ""
+        },
+        "preventRotation": false
+    },
+    "m_Path": "VNTG/Color",
+    "m_GraphPrecision": 1,
+    "m_PreviewMode": 2,
+    "m_OutputNode": {
+        "m_Id": "2cd3d06e0f9549098608e4899a5376bd"
+    },
+    "m_SubDatas": [],
+    "m_ActiveTargets": []
+}
+
+{
+    "m_SGVersion": 0,
+    "m_Type": "UnityEditor.ShaderGraph.Vector3MaterialSlot",
+    "m_ObjectId": "1887faf33cab47df9e3d5b3ecdfff4e4",
+    "m_Id": 0,
+    "m_DisplayName": "HSV",
+    "m_SlotType": 0,
+    "m_Hidden": false,
+    "m_ShaderOutputName": "HSV",
+    "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.SubGraphOutputNode",
+    "m_ObjectId": "2cd3d06e0f9549098608e4899a5376bd",
+    "m_Group": {
+        "m_Id": ""
+    },
+    "m_Name": "Output",
+    "m_DrawState": {
+        "m_Expanded": true,
+        "m_Position": {
+            "serializedVersion": "2",
+            "x": 1.0,
+            "y": -1.0,
+            "width": 119.0,
+            "height": 77.0
+        }
+    },
+    "m_Slots": [
+        {
+            "m_Id": "84def6a780874fe0bf2139d1966cf9de"
+        }
+    ],
+    "synonyms": [],
+    "m_Precision": 0,
+    "m_PreviewExpanded": true,
+    "m_DismissedVersion": 0,
+    "m_PreviewMode": 0,
+    "m_CustomColors": {
+        "m_SerializableColors": []
+    },
+    "IsFirstSlotValid": true
+}
+
+{
+    "m_SGVersion": 1,
+    "m_Type": "UnityEditor.ShaderGraph.Internal.Vector3ShaderProperty",
+    "m_ObjectId": "71a062c74bec4becb202b5f941113a4c",
+    "m_Guid": {
+        "m_GuidSerialized": "31692188-e263-426b-b514-663c500779bd"
+    },
+    "promotedFromAssetID": "",
+    "promotedFromCategoryName": "",
+    "promotedOrdering": -1,
+    "m_Name": "HSV",
+    "m_DefaultRefNameVersion": 1,
+    "m_RefNameGeneratedByDisplayName": "HSV",
+    "m_DefaultReferenceName": "_HSV",
+    "m_OverrideReferenceName": "",
+    "m_GeneratePropertyBlock": true,
+    "m_UseCustomSlotLabel": false,
+    "m_CustomSlotLabel": "",
+    "m_DismissedVersion": 0,
+    "m_Precision": 0,
+    "overrideHLSLDeclaration": false,
+    "hlslDeclarationOverride": 0,
+    "m_Hidden": false,
+    "m_PerRendererData": false,
+    "m_customAttributes": [],
+    "m_Value": {
+        "x": 0.0,
+        "y": 0.0,
+        "z": 0.0,
+        "w": 0.0
+    }
+}
+
+{
+    "m_SGVersion": 1,
+    "m_Type": "UnityEditor.ShaderGraph.CustomFunctionNode",
+    "m_ObjectId": "791727392c2d4422a020ae5e42a26c20",
+    "m_Group": {
+        "m_Id": ""
+    },
+    "m_Name": "HsvToRgb (Custom Function)",
+    "m_DrawState": {
+        "m_Expanded": true,
+        "m_Position": {
+            "serializedVersion": "2",
+            "x": -571.0,
+            "y": -33.0,
+            "width": 142.0,
+            "height": 45.0
+        }
+    },
+    "m_Slots": [
+        {
+            "m_Id": "1887faf33cab47df9e3d5b3ecdfff4e4"
+        },
+        {
+            "m_Id": "c1a7ca30fad644a8b33d1618ab071f54"
+        }
+    ],
+    "synonyms": [
+        "code",
+        "HLSL"
+    ],
+    "m_Precision": 0,
+    "m_PreviewExpanded": false,
+    "m_DismissedVersion": 0,
+    "m_PreviewMode": 0,
+    "m_CustomColors": {
+        "m_SerializableColors": []
+    },
+    "m_SourceType": 0,
+    "m_FunctionName": "HsvToRgb",
+    "m_FunctionSource": "50998adb9d812e149b8c7fbb1dae6663",
+    "m_FunctionSourceUsePragmas": true,
+    "m_FunctionBody": "Enter function body here..."
+}
+
+{
+    "m_SGVersion": 0,
+    "m_Type": "UnityEditor.ShaderGraph.Vector3MaterialSlot",
+    "m_ObjectId": "84def6a780874fe0bf2139d1966cf9de",
+    "m_Id": 1,
+    "m_DisplayName": "RGB",
+    "m_SlotType": 0,
+    "m_Hidden": false,
+    "m_ShaderOutputName": "RGB",
+    "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": "c1a7ca30fad644a8b33d1618ab071f54",
+    "m_Id": 1,
+    "m_DisplayName": "RGB",
+    "m_SlotType": 1,
+    "m_Hidden": false,
+    "m_ShaderOutputName": "RGB",
+    "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": "d4dcaaf6f1d7418f8b5df3997d75dc35",
+    "m_Group": {
+        "m_Id": ""
+    },
+    "m_Name": "Property",
+    "m_DrawState": {
+        "m_Expanded": true,
+        "m_Position": {
+            "serializedVersion": "2",
+            "x": -820.9999389648438,
+            "y": -63.00000762939453,
+            "width": 99.99993896484375,
+            "height": 33.99998474121094
+        }
+    },
+    "m_Slots": [
+        {
+            "m_Id": "f74fe03488ae4b8b9e803d1305313803"
+        }
+    ],
+    "synonyms": [],
+    "m_Precision": 0,
+    "m_PreviewExpanded": true,
+    "m_DismissedVersion": 0,
+    "m_PreviewMode": 0,
+    "m_CustomColors": {
+        "m_SerializableColors": []
+    },
+    "m_Property": {
+        "m_Id": "71a062c74bec4becb202b5f941113a4c"
+    }
+}
+
+{
+    "m_SGVersion": 0,
+    "m_Type": "UnityEditor.ShaderGraph.Vector3MaterialSlot",
+    "m_ObjectId": "f74fe03488ae4b8b9e803d1305313803",
+    "m_Id": 0,
+    "m_DisplayName": "HSV",
+    "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.CategoryData",
+    "m_ObjectId": "ff1b363c78fb446ea8a8e78e4c8eda90",
+    "m_Name": "",
+    "m_ChildObjectList": [
+        {
+            "m_Id": "71a062c74bec4becb202b5f941113a4c"
+        }
+    ]
+}
+

Assets/ColbyO/VNTG/Shaders/SubGraphs/Color/HSVToRGB.shadersubgraph.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: de1d61ab03055e241b3224087f190823
+ScriptedImporter:
+  internalIDToNameTable: []
+  externalObjects: {}
+  serializedVersion: 2
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+  script: {fileID: 11500000, guid: 60072b568d64c40a485e0fc55012dc9f, type: 3}
+  documentationPath: 

Assets/ColbyO/VNTG/Shaders/SubGraphs/Color/QuantizeColor.shadersubgraph.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 8534ca0019437444da23f09042e4d965
+ScriptedImporter:
+  internalIDToNameTable: []
+  externalObjects: {}
+  serializedVersion: 2
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+  script: {fileID: 11500000, guid: 60072b568d64c40a485e0fc55012dc9f, type: 3}
+  documentationPath: 

Assets/ColbyO/VNTG/Shaders/SubGraphs/Color/RGBToHSV.shadersubgraph

@@ -0,0 +1,341 @@
+{
+    "m_SGVersion": 3,
+    "m_Type": "UnityEditor.ShaderGraph.GraphData",
+    "m_ObjectId": "e29230623bf742cea5871e98e6a5d077",
+    "m_Properties": [
+        {
+            "m_Id": "4cd54ae89785476eabae32e57d1371ef"
+        }
+    ],
+    "m_Keywords": [],
+    "m_Dropdowns": [],
+    "m_CategoryData": [
+        {
+            "m_Id": "dc1a0c93d20f46d8b95cd29b2e206c43"
+        }
+    ],
+    "m_Nodes": [
+        {
+            "m_Id": "26a6ecd0b60a42179c04a1dd4fa6b22d"
+        },
+        {
+            "m_Id": "a04bad2e2a3341e5a3d4095cf2b57dd9"
+        },
+        {
+            "m_Id": "a1507a7f4f434975af253f17e40baffd"
+        }
+    ],
+    "m_GroupDatas": [],
+    "m_StickyNoteDatas": [],
+    "m_Edges": [
+        {
+            "m_OutputSlot": {
+                "m_Node": {
+                    "m_Id": "a04bad2e2a3341e5a3d4095cf2b57dd9"
+                },
+                "m_SlotId": 0
+            },
+            "m_InputSlot": {
+                "m_Node": {
+                    "m_Id": "26a6ecd0b60a42179c04a1dd4fa6b22d"
+                },
+                "m_SlotId": 1
+            }
+        },
+        {
+            "m_OutputSlot": {
+                "m_Node": {
+                    "m_Id": "a1507a7f4f434975af253f17e40baffd"
+                },
+                "m_SlotId": 0
+            },
+            "m_InputSlot": {
+                "m_Node": {
+                    "m_Id": "a04bad2e2a3341e5a3d4095cf2b57dd9"
+                },
+                "m_SlotId": 1
+            }
+        }
+    ],
+    "m_VertexContext": {
+        "m_Position": {
+            "x": 0.0,
+            "y": 0.0
+        },
+        "m_Blocks": []
+    },
+    "m_FragmentContext": {
+        "m_Position": {
+            "x": 0.0,
+            "y": 0.0
+        },
+        "m_Blocks": []
+    },
+    "m_PreviewData": {
+        "serializedMesh": {
+            "m_SerializedMesh": "{\"mesh\":{\"instanceID\":0}}",
+            "m_Guid": ""
+        },
+        "preventRotation": false
+    },
+    "m_Path": "VNTG/Color",
+    "m_GraphPrecision": 1,
+    "m_PreviewMode": 2,
+    "m_OutputNode": {
+        "m_Id": "26a6ecd0b60a42179c04a1dd4fa6b22d"
+    },
+    "m_SubDatas": [],
+    "m_ActiveTargets": []
+}
+
+{
+    "m_SGVersion": 0,
+    "m_Type": "UnityEditor.ShaderGraph.SubGraphOutputNode",
+    "m_ObjectId": "26a6ecd0b60a42179c04a1dd4fa6b22d",
+    "m_Group": {
+        "m_Id": ""
+    },
+    "m_Name": "Output",
+    "m_DrawState": {
+        "m_Expanded": true,
+        "m_Position": {
+            "serializedVersion": "2",
+            "x": 2.0000290870666506,
+            "y": -1.0000207424163819,
+            "width": 118.99996948242188,
+            "height": 77.00001525878906
+        }
+    },
+    "m_Slots": [
+        {
+            "m_Id": "6a50ce992a1641a6ac47f155194608d3"
+        }
+    ],
+    "synonyms": [],
+    "m_Precision": 0,
+    "m_PreviewExpanded": true,
+    "m_DismissedVersion": 0,
+    "m_PreviewMode": 0,
+    "m_CustomColors": {
+        "m_SerializableColors": []
+    },
+    "IsFirstSlotValid": true
+}
+
+{
+    "m_SGVersion": 1,
+    "m_Type": "UnityEditor.ShaderGraph.Internal.Vector3ShaderProperty",
+    "m_ObjectId": "4cd54ae89785476eabae32e57d1371ef",
+    "m_Guid": {
+        "m_GuidSerialized": "44766a02-91b4-4d0e-81df-19c8040288ba"
+    },
+    "promotedFromAssetID": "",
+    "promotedFromCategoryName": "",
+    "promotedOrdering": -1,
+    "m_Name": "RGB",
+    "m_DefaultRefNameVersion": 1,
+    "m_RefNameGeneratedByDisplayName": "RGB",
+    "m_DefaultReferenceName": "_RGB",
+    "m_OverrideReferenceName": "",
+    "m_GeneratePropertyBlock": true,
+    "m_UseCustomSlotLabel": false,
+    "m_CustomSlotLabel": "",
+    "m_DismissedVersion": 0,
+    "m_Precision": 0,
+    "overrideHLSLDeclaration": false,
+    "hlslDeclarationOverride": 0,
+    "m_Hidden": false,
+    "m_PerRendererData": false,
+    "m_customAttributes": [],
+    "m_Value": {
+        "x": 0.0,
+        "y": 0.0,
+        "z": 0.0,
+        "w": 0.0
+    }
+}
+
+{
+    "m_SGVersion": 0,
+    "m_Type": "UnityEditor.ShaderGraph.Vector3MaterialSlot",
+    "m_ObjectId": "6a50ce992a1641a6ac47f155194608d3",
+    "m_Id": 1,
+    "m_DisplayName": "HSV",
+    "m_SlotType": 0,
+    "m_Hidden": false,
+    "m_ShaderOutputName": "HSV",
+    "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": "7d8d98858e264bf1a1d8f0dddd3191dd",
+    "m_Id": 0,
+    "m_DisplayName": "RGB",
+    "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.CustomFunctionNode",
+    "m_ObjectId": "a04bad2e2a3341e5a3d4095cf2b57dd9",
+    "m_Group": {
+        "m_Id": ""
+    },
+    "m_Name": "RgbToHsv (Custom Function)",
+    "m_DrawState": {
+        "m_Expanded": true,
+        "m_Position": {
+            "serializedVersion": "2",
+            "x": -550.0000610351563,
+            "y": 3.0000150203704836,
+            "width": 212.00003051757813,
+            "height": 76.9999771118164
+        }
+    },
+    "m_Slots": [
+        {
+            "m_Id": "de6fd4363f554cfa8cf18f3cdab05fde"
+        },
+        {
+            "m_Id": "b30e215a4af44bd8a03006ed65a1a249"
+        }
+    ],
+    "synonyms": [
+        "code",
+        "HLSL"
+    ],
+    "m_Precision": 0,
+    "m_PreviewExpanded": false,
+    "m_DismissedVersion": 0,
+    "m_PreviewMode": 0,
+    "m_CustomColors": {
+        "m_SerializableColors": []
+    },
+    "m_SourceType": 0,
+    "m_FunctionName": "RgbToHsv",
+    "m_FunctionSource": "50998adb9d812e149b8c7fbb1dae6663",
+    "m_FunctionSourceUsePragmas": true,
+    "m_FunctionBody": "Enter function body here..."
+}
+
+{
+    "m_SGVersion": 0,
+    "m_Type": "UnityEditor.ShaderGraph.PropertyNode",
+    "m_ObjectId": "a1507a7f4f434975af253f17e40baffd",
+    "m_Group": {
+        "m_Id": ""
+    },
+    "m_Name": "Property",
+    "m_DrawState": {
+        "m_Expanded": true,
+        "m_Position": {
+            "serializedVersion": "2",
+            "x": -776.6978759765625,
+            "y": 34.840946197509769,
+            "width": 0.0,
+            "height": 0.0
+        }
+    },
+    "m_Slots": [
+        {
+            "m_Id": "7d8d98858e264bf1a1d8f0dddd3191dd"
+        }
+    ],
+    "synonyms": [],
+    "m_Precision": 0,
+    "m_PreviewExpanded": true,
+    "m_DismissedVersion": 0,
+    "m_PreviewMode": 0,
+    "m_CustomColors": {
+        "m_SerializableColors": []
+    },
+    "m_Property": {
+        "m_Id": "4cd54ae89785476eabae32e57d1371ef"
+    }
+}
+
+{
+    "m_SGVersion": 0,
+    "m_Type": "UnityEditor.ShaderGraph.Vector3MaterialSlot",
+    "m_ObjectId": "b30e215a4af44bd8a03006ed65a1a249",
+    "m_Id": 0,
+    "m_DisplayName": "HSV",
+    "m_SlotType": 1,
+    "m_Hidden": false,
+    "m_ShaderOutputName": "HSV",
+    "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.CategoryData",
+    "m_ObjectId": "dc1a0c93d20f46d8b95cd29b2e206c43",
+    "m_Name": "",
+    "m_ChildObjectList": [
+        {
+            "m_Id": "4cd54ae89785476eabae32e57d1371ef"
+        }
+    ]
+}
+
+{
+    "m_SGVersion": 0,
+    "m_Type": "UnityEditor.ShaderGraph.Vector3MaterialSlot",
+    "m_ObjectId": "de6fd4363f554cfa8cf18f3cdab05fde",
+    "m_Id": 1,
+    "m_DisplayName": "RGB",
+    "m_SlotType": 0,
+    "m_Hidden": false,
+    "m_ShaderOutputName": "RGB",
+    "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": []
+}
+

Assets/ColbyO/VNTG/Shaders/SubGraphs/Color/RGBToHSV.shadersubgraph.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 72886544bdc7c3b4e8b43d71b3452568
+ScriptedImporter:
+  internalIDToNameTable: []
+  externalObjects: {}
+  serializedVersion: 2
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+  script: {fileID: 11500000, guid: 60072b568d64c40a485e0fc55012dc9f, type: 3}
+  documentationPath: 

Assets/ColbyO/VNTG/Shaders/SubGraphs/Fragment.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 3a1ef7f275e716f4db684bda07958de8
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/ColbyO/VNTG/Shaders/SubGraphs/Fragment/PSXFragmentColorCorrection.shadersubgraph.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 36ff5c81b0a56134eb8c95ca114bd1dd
+ScriptedImporter:
+  internalIDToNameTable: []
+  externalObjects: {}
+  serializedVersion: 2
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+  script: {fileID: 11500000, guid: 60072b568d64c40a485e0fc55012dc9f, type: 3}
+  documentationPath: 

Assets/ColbyO/VNTG/Shaders/SubGraphs/Fragment/PSXFragmentLighting.shadersubgraph.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: ccd14ba740be7ff4a865df5a7ab6ac57
+ScriptedImporter:
+  internalIDToNameTable: []
+  externalObjects: {}
+  serializedVersion: 2
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+  script: {fileID: 11500000, guid: 60072b568d64c40a485e0fc55012dc9f, type: 3}
+  documentationPath: 

Assets/ColbyO/VNTG/Shaders/SubGraphs/Fragment/PSXFragmentSampleCubemap.shadersubgraph.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: be60ef89f6432814ca0186ef85dda249
+ScriptedImporter:
+  internalIDToNameTable: []
+  externalObjects: {}
+  serializedVersion: 2
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+  script: {fileID: 11500000, guid: 60072b568d64c40a485e0fc55012dc9f, type: 3}
+  documentationPath: 

Assets/ColbyO/VNTG/Shaders/SubGraphs/Fragment/PSXFragmentSampleTexture.shadersubgraph.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 8232870c913aef44dbb3fb4000ec4841
+ScriptedImporter:
+  internalIDToNameTable: []
+  externalObjects: {}
+  serializedVersion: 2
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+  script: {fileID: 11500000, guid: 60072b568d64c40a485e0fc55012dc9f, type: 3}
+  documentationPath: 

Assets/ColbyO/VNTG/Shaders/SubGraphs/Fragment/PSXFragmentTexelSize.shadersubgraph

@@ -0,0 +1,956 @@
+{
+    "m_SGVersion": 3,
+    "m_Type": "UnityEditor.ShaderGraph.GraphData",
+    "m_ObjectId": "c61fba9d91e74a139c3c16cb66c568d7",
+    "m_Properties": [
+        {
+            "m_Id": "2129eff030784130a53bff09b9b0eb4d"
+        },
+        {
+            "m_Id": "c778a14a321142afa24a8b244c8c69d0"
+        },
+        {
+            "m_Id": "655119e77aef4cce8c618454fc149a8b"
+        }
+    ],
+    "m_Keywords": [],
+    "m_Dropdowns": [],
+    "m_CategoryData": [
+        {
+            "m_Id": "a3fbc4a259074d7f86fc6f35108bc993"
+        }
+    ],
+    "m_Nodes": [
+        {
+            "m_Id": "8afb68adda6941ff828073a720cfa2cd"
+        },
+        {
+            "m_Id": "f2a9e39cc6a44175b88144b530ec0cbf"
+        },
+        {
+            "m_Id": "f0349a2fd1ce4561b08f22ff0e4363bf"
+        },
+        {
+            "m_Id": "b6a0dde9619042d9a6392261ac45bd25"
+        },
+        {
+            "m_Id": "eb7bde187fb14ba48816b45afc0d5082"
+        },
+        {
+            "m_Id": "498792b3624047e08f88f0e1878f94d4"
+        },
+        {
+            "m_Id": "478c580dd3f64deb8a4d58394851c849"
+        }
+    ],
+    "m_GroupDatas": [],
+    "m_StickyNoteDatas": [],
+    "m_Edges": [
+        {
+            "m_OutputSlot": {
+                "m_Node": {
+                    "m_Id": "478c580dd3f64deb8a4d58394851c849"
+                },
+                "m_SlotId": 0
+            },
+            "m_InputSlot": {
+                "m_Node": {
+                    "m_Id": "b6a0dde9619042d9a6392261ac45bd25"
+                },
+                "m_SlotId": 1
+            }
+        },
+        {
+            "m_OutputSlot": {
+                "m_Node": {
+                    "m_Id": "498792b3624047e08f88f0e1878f94d4"
+                },
+                "m_SlotId": 0
+            },
+            "m_InputSlot": {
+                "m_Node": {
+                    "m_Id": "b6a0dde9619042d9a6392261ac45bd25"
+                },
+                "m_SlotId": 0
+            }
+        },
+        {
+            "m_OutputSlot": {
+                "m_Node": {
+                    "m_Id": "b6a0dde9619042d9a6392261ac45bd25"
+                },
+                "m_SlotId": 3
+            },
+            "m_InputSlot": {
+                "m_Node": {
+                    "m_Id": "8afb68adda6941ff828073a720cfa2cd"
+                },
+                "m_SlotId": 2
+            }
+        },
+        {
+            "m_OutputSlot": {
+                "m_Node": {
+                    "m_Id": "eb7bde187fb14ba48816b45afc0d5082"
+                },
+                "m_SlotId": 0
+            },
+            "m_InputSlot": {
+                "m_Node": {
+                    "m_Id": "f2a9e39cc6a44175b88144b530ec0cbf"
+                },
+                "m_SlotId": 1
+            }
+        },
+        {
+            "m_OutputSlot": {
+                "m_Node": {
+                    "m_Id": "f0349a2fd1ce4561b08f22ff0e4363bf"
+                },
+                "m_SlotId": 0
+            },
+            "m_InputSlot": {
+                "m_Node": {
+                    "m_Id": "b6a0dde9619042d9a6392261ac45bd25"
+                },
+                "m_SlotId": 2
+            }
+        },
+        {
+            "m_OutputSlot": {
+                "m_Node": {
+                    "m_Id": "f2a9e39cc6a44175b88144b530ec0cbf"
+                },
+                "m_SlotId": 0
+            },
+            "m_InputSlot": {
+                "m_Node": {
+                    "m_Id": "f0349a2fd1ce4561b08f22ff0e4363bf"
+                },
+                "m_SlotId": 3
+            }
+        },
+        {
+            "m_OutputSlot": {
+                "m_Node": {
+                    "m_Id": "f2a9e39cc6a44175b88144b530ec0cbf"
+                },
+                "m_SlotId": 2
+            },
+            "m_InputSlot": {
+                "m_Node": {
+                    "m_Id": "f0349a2fd1ce4561b08f22ff0e4363bf"
+                },
+                "m_SlotId": 4
+            }
+        },
+        {
+            "m_OutputSlot": {
+                "m_Node": {
+                    "m_Id": "f2a9e39cc6a44175b88144b530ec0cbf"
+                },
+                "m_SlotId": 3
+            },
+            "m_InputSlot": {
+                "m_Node": {
+                    "m_Id": "f0349a2fd1ce4561b08f22ff0e4363bf"
+                },
+                "m_SlotId": 1
+            }
+        },
+        {
+            "m_OutputSlot": {
+                "m_Node": {
+                    "m_Id": "f2a9e39cc6a44175b88144b530ec0cbf"
+                },
+                "m_SlotId": 4
+            },
+            "m_InputSlot": {
+                "m_Node": {
+                    "m_Id": "f0349a2fd1ce4561b08f22ff0e4363bf"
+                },
+                "m_SlotId": 2
+            }
+        }
+    ],
+    "m_VertexContext": {
+        "m_Position": {
+            "x": 0.0,
+            "y": 0.0
+        },
+        "m_Blocks": []
+    },
+    "m_FragmentContext": {
+        "m_Position": {
+            "x": 0.0,
+            "y": 0.0
+        },
+        "m_Blocks": []
+    },
+    "m_PreviewData": {
+        "serializedMesh": {
+            "m_SerializedMesh": "{\"mesh\":{\"instanceID\":0}}",
+            "m_Guid": ""
+        },
+        "preventRotation": false
+    },
+    "m_Path": "VNTG/Fragment",
+    "m_GraphPrecision": 1,
+    "m_PreviewMode": 2,
+    "m_OutputNode": {
+        "m_Id": "8afb68adda6941ff828073a720cfa2cd"
+    },
+    "m_SubDatas": [],
+    "m_ActiveTargets": []
+}
+
+{
+    "m_SGVersion": 0,
+    "m_Type": "UnityEditor.ShaderGraph.Texture2DInputMaterialSlot",
+    "m_ObjectId": "005f5a83cd014479bb1c509d65dd96af",
+    "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": "",
+        "m_Guid": ""
+    },
+    "m_DefaultType": 0
+}
+
+{
+    "m_SGVersion": 0,
+    "m_Type": "UnityEditor.ShaderGraph.BooleanMaterialSlot",
+    "m_ObjectId": "0a2daf56399644dca93e3725d3b55389",
+    "m_Id": 0,
+    "m_DisplayName": "EnableTextureDownsampling",
+    "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.Vector1MaterialSlot",
+    "m_ObjectId": "18db8d451f154603847127d227344683",
+    "m_Id": 2,
+    "m_DisplayName": "Height",
+    "m_SlotType": 1,
+    "m_Hidden": false,
+    "m_ShaderOutputName": "Height",
+    "m_StageCapability": 3,
+    "m_Value": 0.0,
+    "m_DefaultValue": 0.0,
+    "m_Labels": [],
+    "m_LiteralMode": false
+}
+
+{
+    "m_SGVersion": 0,
+    "m_Type": "UnityEditor.ShaderGraph.Internal.Texture2DShaderProperty",
+    "m_ObjectId": "2129eff030784130a53bff09b9b0eb4d",
+    "m_Guid": {
+        "m_GuidSerialized": "7eae65c5-da28-4038-a6d1-65c4b582973c"
+    },
+    "promotedFromAssetID": "",
+    "promotedFromCategoryName": "",
+    "promotedOrdering": -1,
+    "m_Name": "MainTex",
+    "m_DefaultRefNameVersion": 1,
+    "m_RefNameGeneratedByDisplayName": "MainTex",
+    "m_DefaultReferenceName": "_MainTex",
+    "m_OverrideReferenceName": "",
+    "m_GeneratePropertyBlock": true,
+    "m_UseCustomSlotLabel": false,
+    "m_CustomSlotLabel": "",
+    "m_DismissedVersion": 0,
+    "m_Precision": 0,
+    "overrideHLSLDeclaration": false,
+    "hlslDeclarationOverride": 0,
+    "m_Hidden": false,
+    "m_PerRendererData": false,
+    "m_customAttributes": [],
+    "m_Value": {
+        "m_SerializedTexture": "",
+        "m_Guid": ""
+    },
+    "isMainTexture": false,
+    "useTilingAndOffset": false,
+    "useTexelSize": true,
+    "isHDR": false,
+    "m_Modifiable": true,
+    "m_DefaultType": 0
+}
+
+{
+    "m_SGVersion": 0,
+    "m_Type": "UnityEditor.ShaderGraph.Vector4MaterialSlot",
+    "m_ObjectId": "2467311c3e0240cdab03f17d2fbbcfec",
+    "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": "257d61e134bb4e098e6c94a6b1136bb6",
+    "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_LiteralMode": false
+}
+
+{
+    "m_SGVersion": 0,
+    "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot",
+    "m_ObjectId": "3a373ef73c7b4ad2b83283b3706afa66",
+    "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_LiteralMode": true
+}
+
+{
+    "m_SGVersion": 0,
+    "m_Type": "UnityEditor.ShaderGraph.PropertyNode",
+    "m_ObjectId": "478c580dd3f64deb8a4d58394851c849",
+    "m_Group": {
+        "m_Id": ""
+    },
+    "m_Name": "Property",
+    "m_DrawState": {
+        "m_Expanded": true,
+        "m_Position": {
+            "serializedVersion": "2",
+            "x": -22.0,
+            "y": -52.0,
+            "width": 200.0,
+            "height": 34.0
+        }
+    },
+    "m_Slots": [
+        {
+            "m_Id": "830c6fc9ae9140db8936caaac0824ea4"
+        }
+    ],
+    "synonyms": [],
+    "m_Precision": 0,
+    "m_PreviewExpanded": true,
+    "m_DismissedVersion": 0,
+    "m_PreviewMode": 0,
+    "m_CustomColors": {
+        "m_SerializableColors": []
+    },
+    "m_Property": {
+        "m_Id": "655119e77aef4cce8c618454fc149a8b"
+    }
+}
+
+{
+    "m_SGVersion": 0,
+    "m_Type": "UnityEditor.ShaderGraph.PropertyNode",
+    "m_ObjectId": "498792b3624047e08f88f0e1878f94d4",
+    "m_Group": {
+        "m_Id": ""
+    },
+    "m_Name": "Property",
+    "m_DrawState": {
+        "m_Expanded": true,
+        "m_Position": {
+            "serializedVersion": "2",
+            "x": -32.0,
+            "y": -100.0,
+            "width": 227.0,
+            "height": 34.0
+        }
+    },
+    "m_Slots": [
+        {
+            "m_Id": "0a2daf56399644dca93e3725d3b55389"
+        }
+    ],
+    "synonyms": [],
+    "m_Precision": 0,
+    "m_PreviewExpanded": true,
+    "m_DismissedVersion": 0,
+    "m_PreviewMode": 0,
+    "m_CustomColors": {
+        "m_SerializableColors": []
+    },
+    "m_Property": {
+        "m_Id": "c778a14a321142afa24a8b244c8c69d0"
+    }
+}
+
+{
+    "m_SGVersion": 0,
+    "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot",
+    "m_ObjectId": "5046cd3eb1ec413da0e6873fdb48eeec",
+    "m_Id": 4,
+    "m_DisplayName": "Texel Height",
+    "m_SlotType": 1,
+    "m_Hidden": false,
+    "m_ShaderOutputName": "Texel Height",
+    "m_StageCapability": 3,
+    "m_Value": 0.0,
+    "m_DefaultValue": 0.0,
+    "m_Labels": [],
+    "m_LiteralMode": false
+}
+
+{
+    "m_SGVersion": 0,
+    "m_Type": "UnityEditor.ShaderGraph.Vector4MaterialSlot",
+    "m_ObjectId": "52addcecad954b2c81867c29909feb6c",
+    "m_Id": 2,
+    "m_DisplayName": "TexekSize",
+    "m_SlotType": 0,
+    "m_Hidden": false,
+    "m_ShaderOutputName": "TexekSize",
+    "m_StageCapability": 3,
+    "m_Value": {
+        "x": 0.0,
+        "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": "62da0a6228e043fd9bd5e75779b91b21",
+    "m_Id": 3,
+    "m_DisplayName": "Texel Width",
+    "m_SlotType": 1,
+    "m_Hidden": false,
+    "m_ShaderOutputName": "Texel Width",
+    "m_StageCapability": 3,
+    "m_Value": 0.0,
+    "m_DefaultValue": 0.0,
+    "m_Labels": [],
+    "m_LiteralMode": false
+}
+
+{
+    "m_SGVersion": 1,
+    "m_Type": "UnityEditor.ShaderGraph.Internal.Vector4ShaderProperty",
+    "m_ObjectId": "655119e77aef4cce8c618454fc149a8b",
+    "m_Guid": {
+        "m_GuidSerialized": "73c54be3-e366-4864-9f39-6c94cdfe74cb"
+    },
+    "promotedFromAssetID": "",
+    "promotedFromCategoryName": "",
+    "promotedOrdering": -1,
+    "m_Name": "DownsampledTexelSize",
+    "m_DefaultRefNameVersion": 1,
+    "m_RefNameGeneratedByDisplayName": "DownsampledTexelSize",
+    "m_DefaultReferenceName": "_DownsampledTexelSize",
+    "m_OverrideReferenceName": "",
+    "m_GeneratePropertyBlock": true,
+    "m_UseCustomSlotLabel": false,
+    "m_CustomSlotLabel": "",
+    "m_DismissedVersion": 0,
+    "m_Precision": 0,
+    "overrideHLSLDeclaration": false,
+    "hlslDeclarationOverride": 0,
+    "m_Hidden": false,
+    "m_PerRendererData": false,
+    "m_customAttributes": [],
+    "m_Value": {
+        "x": 0.0,
+        "y": 0.0,
+        "z": 0.0,
+        "w": 0.0
+    }
+}
+
+{
+    "m_SGVersion": 0,
+    "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot",
+    "m_ObjectId": "6d751614da2c4e938106c463aa09d3da",
+    "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_LiteralMode": false
+}
+
+{
+    "m_SGVersion": 0,
+    "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot",
+    "m_ObjectId": "7bbd91b52e6e4ba88326eefaa4ba5dd0",
+    "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_LiteralMode": false
+}
+
+{
+    "m_SGVersion": 0,
+    "m_Type": "UnityEditor.ShaderGraph.Vector4MaterialSlot",
+    "m_ObjectId": "830c6fc9ae9140db8936caaac0824ea4",
+    "m_Id": 0,
+    "m_DisplayName": "DownsampledTexelSize",
+    "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.SubGraphOutputNode",
+    "m_ObjectId": "8afb68adda6941ff828073a720cfa2cd",
+    "m_Group": {
+        "m_Id": ""
+    },
+    "m_Name": "Output",
+    "m_DrawState": {
+        "m_Expanded": true,
+        "m_Position": {
+            "serializedVersion": "2",
+            "x": 516.5,
+            "y": 0.0,
+            "width": 0.0,
+            "height": 0.0
+        }
+    },
+    "m_Slots": [
+        {
+            "m_Id": "52addcecad954b2c81867c29909feb6c"
+        }
+    ],
+    "synonyms": [],
+    "m_Precision": 0,
+    "m_PreviewExpanded": true,
+    "m_DismissedVersion": 0,
+    "m_PreviewMode": 0,
+    "m_CustomColors": {
+        "m_SerializableColors": []
+    },
+    "IsFirstSlotValid": true
+}
+
+{
+    "m_SGVersion": 0,
+    "m_Type": "UnityEditor.ShaderGraph.BooleanMaterialSlot",
+    "m_ObjectId": "8d868d5581824afbacacd49c0002c9ae",
+    "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.Texture2DMaterialSlot",
+    "m_ObjectId": "91e12c34b74a4e5899c1cd4536f4a02f",
+    "m_Id": 0,
+    "m_DisplayName": "MainTex",
+    "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": "93a04074746144dabb22c93ff7f777cf",
+    "m_Id": 0,
+    "m_DisplayName": "Width",
+    "m_SlotType": 1,
+    "m_Hidden": false,
+    "m_ShaderOutputName": "Width",
+    "m_StageCapability": 3,
+    "m_Value": 0.0,
+    "m_DefaultValue": 0.0,
+    "m_Labels": [],
+    "m_LiteralMode": false
+}
+
+{
+    "m_SGVersion": 0,
+    "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot",
+    "m_ObjectId": "9fa1a00445674d8eb242539e0b96431c",
+    "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_LiteralMode": false
+}
+
+{
+    "m_SGVersion": 0,
+    "m_Type": "UnityEditor.ShaderGraph.CategoryData",
+    "m_ObjectId": "a3fbc4a259074d7f86fc6f35108bc993",
+    "m_Name": "",
+    "m_ChildObjectList": [
+        {
+            "m_Id": "2129eff030784130a53bff09b9b0eb4d"
+        },
+        {
+            "m_Id": "c778a14a321142afa24a8b244c8c69d0"
+        },
+        {
+            "m_Id": "655119e77aef4cce8c618454fc149a8b"
+        }
+    ]
+}
+
+{
+    "m_SGVersion": 0,
+    "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot",
+    "m_ObjectId": "a5cf3305305c4156b9e838ecaebf4f9d",
+    "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_LiteralMode": false
+}
+
+{
+    "m_SGVersion": 0,
+    "m_Type": "UnityEditor.ShaderGraph.BranchNode",
+    "m_ObjectId": "b6a0dde9619042d9a6392261ac45bd25",
+    "m_Group": {
+        "m_Id": ""
+    },
+    "m_Name": "Branch",
+    "m_DrawState": {
+        "m_Expanded": true,
+        "m_Position": {
+            "serializedVersion": "2",
+            "x": 230.5,
+            "y": -91.75006103515625,
+            "width": 171.99993896484376,
+            "height": 142.00006103515626
+        }
+    },
+    "m_Slots": [
+        {
+            "m_Id": "8d868d5581824afbacacd49c0002c9ae"
+        },
+        {
+            "m_Id": "a5cf3305305c4156b9e838ecaebf4f9d"
+        },
+        {
+            "m_Id": "6d751614da2c4e938106c463aa09d3da"
+        },
+        {
+            "m_Id": "3a373ef73c7b4ad2b83283b3706afa66"
+        }
+    ],
+    "synonyms": [
+        "switch",
+        "if",
+        "else"
+    ],
+    "m_Precision": 0,
+    "m_PreviewExpanded": true,
+    "m_DismissedVersion": 0,
+    "m_PreviewMode": 0,
+    "m_CustomColors": {
+        "m_SerializableColors": []
+    }
+}
+
+{
+    "m_SGVersion": 0,
+    "m_Type": "UnityEditor.ShaderGraph.Internal.BooleanShaderProperty",
+    "m_ObjectId": "c778a14a321142afa24a8b244c8c69d0",
+    "m_Guid": {
+        "m_GuidSerialized": "4a15f425-42ee-41e3-aa88-bd04fc06465d"
+    },
+    "promotedFromAssetID": "",
+    "promotedFromCategoryName": "",
+    "promotedOrdering": -1,
+    "m_Name": "EnableTextureDownsampling",
+    "m_DefaultRefNameVersion": 1,
+    "m_RefNameGeneratedByDisplayName": "EnableTextureDownsampling",
+    "m_DefaultReferenceName": "_EnableTextureDownsampling",
+    "m_OverrideReferenceName": "",
+    "m_GeneratePropertyBlock": true,
+    "m_UseCustomSlotLabel": false,
+    "m_CustomSlotLabel": "",
+    "m_DismissedVersion": 0,
+    "m_Precision": 0,
+    "overrideHLSLDeclaration": false,
+    "hlslDeclarationOverride": 0,
+    "m_Hidden": false,
+    "m_PerRendererData": false,
+    "m_customAttributes": [],
+    "m_Value": false
+}
+
+{
+    "m_SGVersion": 0,
+    "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot",
+    "m_ObjectId": "e7b4326c3a8e4f819955569bc3cbb62d",
+    "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_LiteralMode": false
+}
+
+{
+    "m_SGVersion": 0,
+    "m_Type": "UnityEditor.ShaderGraph.PropertyNode",
+    "m_ObjectId": "eb7bde187fb14ba48816b45afc0d5082",
+    "m_Group": {
+        "m_Id": ""
+    },
+    "m_Name": "Property",
+    "m_DrawState": {
+        "m_Expanded": true,
+        "m_Position": {
+            "serializedVersion": "2",
+            "x": -562.0,
+            "y": -60.0,
+            "width": 127.0,
+            "height": 34.0
+        }
+    },
+    "m_Slots": [
+        {
+            "m_Id": "91e12c34b74a4e5899c1cd4536f4a02f"
+        }
+    ],
+    "synonyms": [],
+    "m_Precision": 0,
+    "m_PreviewExpanded": true,
+    "m_DismissedVersion": 0,
+    "m_PreviewMode": 0,
+    "m_CustomColors": {
+        "m_SerializableColors": []
+    },
+    "m_Property": {
+        "m_Id": "2129eff030784130a53bff09b9b0eb4d"
+    }
+}
+
+{
+    "m_SGVersion": 0,
+    "m_Type": "UnityEditor.ShaderGraph.Vector4Node",
+    "m_ObjectId": "f0349a2fd1ce4561b08f22ff0e4363bf",
+    "m_Group": {
+        "m_Id": ""
+    },
+    "m_Name": "Vector 4",
+    "m_DrawState": {
+        "m_Expanded": true,
+        "m_Position": {
+            "serializedVersion": "2",
+            "x": -187.0000457763672,
+            "y": -55.0000114440918,
+            "width": 131.00003051757813,
+            "height": 148.99998474121095
+        }
+    },
+    "m_Slots": [
+        {
+            "m_Id": "7bbd91b52e6e4ba88326eefaa4ba5dd0"
+        },
+        {
+            "m_Id": "257d61e134bb4e098e6c94a6b1136bb6"
+        },
+        {
+            "m_Id": "9fa1a00445674d8eb242539e0b96431c"
+        },
+        {
+            "m_Id": "e7b4326c3a8e4f819955569bc3cbb62d"
+        },
+        {
+            "m_Id": "2467311c3e0240cdab03f17d2fbbcfec"
+        }
+    ],
+    "synonyms": [
+        "4",
+        "v4",
+        "vec4",
+        "float4"
+    ],
+    "m_Precision": 0,
+    "m_PreviewExpanded": true,
+    "m_DismissedVersion": 0,
+    "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.Texture2DPropertiesNode",
+    "m_ObjectId": "f2a9e39cc6a44175b88144b530ec0cbf",
+    "m_Group": {
+        "m_Id": ""
+    },
+    "m_Name": "Texture Size",
+    "m_DrawState": {
+        "m_Expanded": true,
+        "m_Position": {
+            "serializedVersion": "2",
+            "x": -424.0000305175781,
+            "y": -54.0000114440918,
+            "width": 212.0,
+            "height": 149.0
+        }
+    },
+    "m_Slots": [
+        {
+            "m_Id": "93a04074746144dabb22c93ff7f777cf"
+        },
+        {
+            "m_Id": "18db8d451f154603847127d227344683"
+        },
+        {
+            "m_Id": "62da0a6228e043fd9bd5e75779b91b21"
+        },
+        {
+            "m_Id": "5046cd3eb1ec413da0e6873fdb48eeec"
+        },
+        {
+            "m_Id": "005f5a83cd014479bb1c509d65dd96af"
+        }
+    ],
+    "synonyms": [
+        "texel size"
+    ],
+    "m_Precision": 0,
+    "m_PreviewExpanded": true,
+    "m_DismissedVersion": 0,
+    "m_PreviewMode": 0,
+    "m_CustomColors": {
+        "m_SerializableColors": []
+    }
+}
+

Assets/ColbyO/VNTG/Shaders/SubGraphs/Fragment/PSXFragmentTexelSize.shadersubgraph.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 5d738eb01540d074e94b193c7f2bec15
+ScriptedImporter:
+  internalIDToNameTable: []
+  externalObjects: {}
+  serializedVersion: 2
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+  script: {fileID: 11500000, guid: 60072b568d64c40a485e0fc55012dc9f, type: 3}
+  documentationPath: 

Assets/ColbyO/VNTG/Shaders/SubGraphs/Fragment/PSXFragmentUV.shadersubgraph.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 2421ec3e9a3b4e3418e9e9a170a73ba3
+ScriptedImporter:
+  internalIDToNameTable: []
+  externalObjects: {}
+  serializedVersion: 2
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+  script: {fileID: 11500000, guid: 60072b568d64c40a485e0fc55012dc9f, type: 3}
+  documentationPath: 

Assets/ColbyO/VNTG/Shaders/SubGraphs/Helper.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 98b786eb6b5470e4db1b4c20e6fe12c7
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/ColbyO/VNTG/Shaders/SubGraphs/Helper/GetNeighbors.shadersubgraph.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: bb4b393daa835e948a1a833448cbcb5b
+ScriptedImporter:
+  internalIDToNameTable: []
+  externalObjects: {}
+  serializedVersion: 2
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+  script: {fileID: 11500000, guid: 60072b568d64c40a485e0fc55012dc9f, type: 3}
+  documentationPath: 

Assets/ColbyO/VNTG/Shaders/SubGraphs/Helper/GetNormalFromNeighbors.shadersubgraph.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 0617b939bddae8544869feb835827abf
+ScriptedImporter:
+  internalIDToNameTable: []
+  externalObjects: {}
+  serializedVersion: 2
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+  script: {fileID: 11500000, guid: 60072b568d64c40a485e0fc55012dc9f, type: 3}
+  documentationPath: 

Assets/ColbyO/VNTG/Shaders/SubGraphs/Helper/Quantize.shadersubgraph

@@ -0,0 +1,867 @@
+{
+    "m_SGVersion": 3,
+    "m_Type": "UnityEditor.ShaderGraph.GraphData",
+    "m_ObjectId": "14fa71fd27f344d98187fd7b2cc733de",
+    "m_Properties": [
+        {
+            "m_Id": "e579a845e5f64128a1a9af9ae8cd90a7"
+        },
+        {
+            "m_Id": "b6a3150fd8d74e77af45b0f522032222"
+        }
+    ],
+    "m_Keywords": [],
+    "m_Dropdowns": [],
+    "m_CategoryData": [
+        {
+            "m_Id": "9446638e8fa44162bc15ef8a22d4adc2"
+        }
+    ],
+    "m_Nodes": [
+        {
+            "m_Id": "615d34b0ab694eaaba9f2b9db5d6049c"
+        },
+        {
+            "m_Id": "6cf6bad9f48d4eea9672d74d6fe21824"
+        },
+        {
+            "m_Id": "b2105f4377cc41589553e2a61a602da8"
+        },
+        {
+            "m_Id": "fe5d471b2a11492eac6a36ab8184f4b2"
+        },
+        {
+            "m_Id": "09486f6549e248cf853671aa3896b181"
+        },
+        {
+            "m_Id": "096c0043ca2642e88ff3abf9d7d5c0c2"
+        },
+        {
+            "m_Id": "099954c26681463599c20d2753b1ecc3"
+        }
+    ],
+    "m_GroupDatas": [],
+    "m_StickyNoteDatas": [],
+    "m_Edges": [
+        {
+            "m_OutputSlot": {
+                "m_Node": {
+                    "m_Id": "09486f6549e248cf853671aa3896b181"
+                },
+                "m_SlotId": 1
+            },
+            "m_InputSlot": {
+                "m_Node": {
+                    "m_Id": "096c0043ca2642e88ff3abf9d7d5c0c2"
+                },
+                "m_SlotId": 0
+            }
+        },
+        {
+            "m_OutputSlot": {
+                "m_Node": {
+                    "m_Id": "096c0043ca2642e88ff3abf9d7d5c0c2"
+                },
+                "m_SlotId": 2
+            },
+            "m_InputSlot": {
+                "m_Node": {
+                    "m_Id": "615d34b0ab694eaaba9f2b9db5d6049c"
+                },
+                "m_SlotId": 1
+            }
+        },
+        {
+            "m_OutputSlot": {
+                "m_Node": {
+                    "m_Id": "099954c26681463599c20d2753b1ecc3"
+                },
+                "m_SlotId": 0
+            },
+            "m_InputSlot": {
+                "m_Node": {
+                    "m_Id": "096c0043ca2642e88ff3abf9d7d5c0c2"
+                },
+                "m_SlotId": 1
+            }
+        },
+        {
+            "m_OutputSlot": {
+                "m_Node": {
+                    "m_Id": "6cf6bad9f48d4eea9672d74d6fe21824"
+                },
+                "m_SlotId": 2
+            },
+            "m_InputSlot": {
+                "m_Node": {
+                    "m_Id": "09486f6549e248cf853671aa3896b181"
+                },
+                "m_SlotId": 0
+            }
+        },
+        {
+            "m_OutputSlot": {
+                "m_Node": {
+                    "m_Id": "b2105f4377cc41589553e2a61a602da8"
+                },
+                "m_SlotId": 0
+            },
+            "m_InputSlot": {
+                "m_Node": {
+                    "m_Id": "6cf6bad9f48d4eea9672d74d6fe21824"
+                },
+                "m_SlotId": 0
+            }
+        },
+        {
+            "m_OutputSlot": {
+                "m_Node": {
+                    "m_Id": "fe5d471b2a11492eac6a36ab8184f4b2"
+                },
+                "m_SlotId": 0
+            },
+            "m_InputSlot": {
+                "m_Node": {
+                    "m_Id": "6cf6bad9f48d4eea9672d74d6fe21824"
+                },
+                "m_SlotId": 1
+            }
+        }
+    ],
+    "m_VertexContext": {
+        "m_Position": {
+            "x": 0.0,
+            "y": 0.0
+        },
+        "m_Blocks": []
+    },
+    "m_FragmentContext": {
+        "m_Position": {
+            "x": 0.0,
+            "y": 0.0
+        },
+        "m_Blocks": []
+    },
+    "m_PreviewData": {
+        "serializedMesh": {
+            "m_SerializedMesh": "{\"mesh\":{\"instanceID\":0}}",
+            "m_Guid": ""
+        },
+        "preventRotation": false
+    },
+    "m_Path": "VNTG/Helper",
+    "m_GraphPrecision": 1,
+    "m_PreviewMode": 2,
+    "m_OutputNode": {
+        "m_Id": "615d34b0ab694eaaba9f2b9db5d6049c"
+    },
+    "m_SubDatas": [],
+    "m_ActiveTargets": []
+}
+
+{
+    "m_SGVersion": 0,
+    "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot",
+    "m_ObjectId": "05d5a11e53de4518b84a5dfc12412f7c",
+    "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_LiteralMode": false
+}
+
+{
+    "m_SGVersion": 0,
+    "m_Type": "UnityEditor.ShaderGraph.FloorNode",
+    "m_ObjectId": "09486f6549e248cf853671aa3896b181",
+    "m_Group": {
+        "m_Id": ""
+    },
+    "m_Name": "Floor",
+    "m_DrawState": {
+        "m_Expanded": true,
+        "m_Position": {
+            "serializedVersion": "2",
+            "x": -668.0000610351563,
+            "y": -75.00003051757813,
+            "width": 131.99993896484376,
+            "height": 94.00003814697266
+        }
+    },
+    "m_Slots": [
+        {
+            "m_Id": "672791e9561d47b1b1b44eec602c3c2b"
+        },
+        {
+            "m_Id": "ef2f097dfa294445a4ccca23502ede43"
+        }
+    ],
+    "synonyms": [
+        "down"
+    ],
+    "m_Precision": 0,
+    "m_PreviewExpanded": false,
+    "m_DismissedVersion": 0,
+    "m_PreviewMode": 0,
+    "m_CustomColors": {
+        "m_SerializableColors": []
+    }
+}
+
+{
+    "m_SGVersion": 0,
+    "m_Type": "UnityEditor.ShaderGraph.DivideNode",
+    "m_ObjectId": "096c0043ca2642e88ff3abf9d7d5c0c2",
+    "m_Group": {
+        "m_Id": ""
+    },
+    "m_Name": "Divide",
+    "m_DrawState": {
+        "m_Expanded": true,
+        "m_Position": {
+            "serializedVersion": "2",
+            "x": -419.0,
+            "y": -69.0,
+            "width": 130.0,
+            "height": 118.0
+        }
+    },
+    "m_Slots": [
+        {
+            "m_Id": "2d724569263a477d9ee9a881bc052c55"
+        },
+        {
+            "m_Id": "05d5a11e53de4518b84a5dfc12412f7c"
+        },
+        {
+            "m_Id": "b8e0290614c148c0b0068429b5b3cdb3"
+        }
+    ],
+    "synonyms": [
+        "division",
+        "divided by"
+    ],
+    "m_Precision": 0,
+    "m_PreviewExpanded": false,
+    "m_DismissedVersion": 0,
+    "m_PreviewMode": 0,
+    "m_CustomColors": {
+        "m_SerializableColors": []
+    }
+}
+
+{
+    "m_SGVersion": 0,
+    "m_Type": "UnityEditor.ShaderGraph.PropertyNode",
+    "m_ObjectId": "099954c26681463599c20d2753b1ecc3",
+    "m_Group": {
+        "m_Id": ""
+    },
+    "m_Name": "Property",
+    "m_DrawState": {
+        "m_Expanded": true,
+        "m_Position": {
+            "serializedVersion": "2",
+            "x": -578.0,
+            "y": 48.0,
+            "width": 0.0,
+            "height": 0.0
+        }
+    },
+    "m_Slots": [
+        {
+            "m_Id": "58a30cd8f3c348a09d6bedad855270d4"
+        }
+    ],
+    "synonyms": [],
+    "m_Precision": 0,
+    "m_PreviewExpanded": true,
+    "m_DismissedVersion": 0,
+    "m_PreviewMode": 0,
+    "m_CustomColors": {
+        "m_SerializableColors": []
+    },
+    "m_Property": {
+        "m_Id": "b6a3150fd8d74e77af45b0f522032222"
+    }
+}
+
+{
+    "m_SGVersion": 0,
+    "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot",
+    "m_ObjectId": "2d724569263a477d9ee9a881bc052c55",
+    "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_LiteralMode": false
+}
+
+{
+    "m_SGVersion": 0,
+    "m_Type": "UnityEditor.ShaderGraph.DynamicValueMaterialSlot",
+    "m_ObjectId": "4394e22abdd244c79c61ab3d899addb4",
+    "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": "58a30cd8f3c348a09d6bedad855270d4",
+    "m_Id": 0,
+    "m_DisplayName": "StepSize",
+    "m_SlotType": 1,
+    "m_Hidden": false,
+    "m_ShaderOutputName": "Out",
+    "m_StageCapability": 3,
+    "m_Value": 0.0,
+    "m_DefaultValue": 0.0,
+    "m_Labels": [],
+    "m_LiteralMode": false
+}
+
+{
+    "m_SGVersion": 0,
+    "m_Type": "UnityEditor.ShaderGraph.Vector3MaterialSlot",
+    "m_ObjectId": "58d548ae6aea4a43bd4da7f1e7e2eab0",
+    "m_Id": 0,
+    "m_DisplayName": "Value",
+    "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": "612553acf62a4201bdca9bd3aa18046e",
+    "m_Id": 0,
+    "m_DisplayName": "StepSize",
+    "m_SlotType": 1,
+    "m_Hidden": false,
+    "m_ShaderOutputName": "Out",
+    "m_StageCapability": 3,
+    "m_Value": 0.0,
+    "m_DefaultValue": 0.0,
+    "m_Labels": [],
+    "m_LiteralMode": false
+}
+
+{
+    "m_SGVersion": 0,
+    "m_Type": "UnityEditor.ShaderGraph.SubGraphOutputNode",
+    "m_ObjectId": "615d34b0ab694eaaba9f2b9db5d6049c",
+    "m_Group": {
+        "m_Id": ""
+    },
+    "m_Name": "Output",
+    "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": "7538aa99415f463784da920b9ccfa7b3"
+        }
+    ],
+    "synonyms": [],
+    "m_Precision": 0,
+    "m_PreviewExpanded": true,
+    "m_DismissedVersion": 0,
+    "m_PreviewMode": 0,
+    "m_CustomColors": {
+        "m_SerializableColors": []
+    },
+    "IsFirstSlotValid": true
+}
+
+{
+    "m_SGVersion": 0,
+    "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot",
+    "m_ObjectId": "672791e9561d47b1b1b44eec602c3c2b",
+    "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_LiteralMode": false
+}
+
+{
+    "m_SGVersion": 0,
+    "m_Type": "UnityEditor.ShaderGraph.DynamicValueMaterialSlot",
+    "m_ObjectId": "67a2071ee08d4836a957908d09d9e256",
+    "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": "6cf6bad9f48d4eea9672d74d6fe21824",
+    "m_Group": {
+        "m_Id": ""
+    },
+    "m_Name": "Multiply",
+    "m_DrawState": {
+        "m_Expanded": true,
+        "m_Position": {
+            "serializedVersion": "2",
+            "x": -871.0000610351563,
+            "y": -103.00000762939453,
+            "width": 208.0,
+            "height": 302.0
+        }
+    },
+    "m_Slots": [
+        {
+            "m_Id": "4394e22abdd244c79c61ab3d899addb4"
+        },
+        {
+            "m_Id": "e6b8cf91df65421ca2fe049830776dda"
+        },
+        {
+            "m_Id": "67a2071ee08d4836a957908d09d9e256"
+        }
+    ],
+    "synonyms": [
+        "multiplication",
+        "times",
+        "x"
+    ],
+    "m_Precision": 0,
+    "m_PreviewExpanded": false,
+    "m_DismissedVersion": 0,
+    "m_PreviewMode": 0,
+    "m_CustomColors": {
+        "m_SerializableColors": []
+    }
+}
+
+{
+    "m_SGVersion": 0,
+    "m_Type": "UnityEditor.ShaderGraph.Vector4MaterialSlot",
+    "m_ObjectId": "7538aa99415f463784da920b9ccfa7b3",
+    "m_Id": 1,
+    "m_DisplayName": "Out",
+    "m_SlotType": 0,
+    "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.CategoryData",
+    "m_ObjectId": "9446638e8fa44162bc15ef8a22d4adc2",
+    "m_Name": "",
+    "m_ChildObjectList": [
+        {
+            "m_Id": "e579a845e5f64128a1a9af9ae8cd90a7"
+        },
+        {
+            "m_Id": "b6a3150fd8d74e77af45b0f522032222"
+        }
+    ]
+}
+
+{
+    "m_SGVersion": 0,
+    "m_Type": "UnityEditor.ShaderGraph.PropertyNode",
+    "m_ObjectId": "b2105f4377cc41589553e2a61a602da8",
+    "m_Group": {
+        "m_Id": ""
+    },
+    "m_Name": "Property",
+    "m_DrawState": {
+        "m_Expanded": true,
+        "m_Position": {
+            "serializedVersion": "2",
+            "x": -1070.0,
+            "y": -76.0,
+            "width": 106.0,
+            "height": 34.0
+        }
+    },
+    "m_Slots": [
+        {
+            "m_Id": "58d548ae6aea4a43bd4da7f1e7e2eab0"
+        }
+    ],
+    "synonyms": [],
+    "m_Precision": 0,
+    "m_PreviewExpanded": true,
+    "m_DismissedVersion": 0,
+    "m_PreviewMode": 0,
+    "m_CustomColors": {
+        "m_SerializableColors": []
+    },
+    "m_Property": {
+        "m_Id": "e579a845e5f64128a1a9af9ae8cd90a7"
+    }
+}
+
+{
+    "m_SGVersion": 1,
+    "m_Type": "UnityEditor.ShaderGraph.Internal.Vector1ShaderProperty",
+    "m_ObjectId": "b6a3150fd8d74e77af45b0f522032222",
+    "m_Guid": {
+        "m_GuidSerialized": "8f370270-ad47-405d-9cb1-2b4eea1df128"
+    },
+    "promotedFromAssetID": "",
+    "promotedFromCategoryName": "",
+    "promotedOrdering": -1,
+    "m_Name": "StepSize",
+    "m_DefaultRefNameVersion": 1,
+    "m_RefNameGeneratedByDisplayName": "StepSize",
+    "m_DefaultReferenceName": "_StepSize",
+    "m_OverrideReferenceName": "",
+    "m_GeneratePropertyBlock": true,
+    "m_UseCustomSlotLabel": false,
+    "m_CustomSlotLabel": "",
+    "m_DismissedVersion": 0,
+    "m_Precision": 0,
+    "overrideHLSLDeclaration": false,
+    "hlslDeclarationOverride": 0,
+    "m_Hidden": false,
+    "m_PerRendererData": false,
+    "m_customAttributes": [],
+    "m_Value": 1.0,
+    "m_FloatType": 0,
+    "m_LiteralFloatMode": false,
+    "m_RangeValues": {
+        "x": 0.0,
+        "y": 1.0
+    },
+    "m_SliderType": 0,
+    "m_SliderPower": 3.0,
+    "m_EnumType": 0,
+    "m_CSharpEnumString": "",
+    "m_EnumNames": [
+        "Default"
+    ],
+    "m_EnumValues": [
+        0
+    ]
+}
+
+{
+    "m_SGVersion": 0,
+    "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot",
+    "m_ObjectId": "b8e0290614c148c0b0068429b5b3cdb3",
+    "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_LiteralMode": false
+}
+
+{
+    "m_SGVersion": 1,
+    "m_Type": "UnityEditor.ShaderGraph.Internal.Vector3ShaderProperty",
+    "m_ObjectId": "e579a845e5f64128a1a9af9ae8cd90a7",
+    "m_Guid": {
+        "m_GuidSerialized": "a9ec2a6a-35aa-4caa-a0b8-a90b202a6998"
+    },
+    "promotedFromAssetID": "",
+    "promotedFromCategoryName": "",
+    "promotedOrdering": -1,
+    "m_Name": "Value",
+    "m_DefaultRefNameVersion": 1,
+    "m_RefNameGeneratedByDisplayName": "Value",
+    "m_DefaultReferenceName": "_Value",
+    "m_OverrideReferenceName": "",
+    "m_GeneratePropertyBlock": true,
+    "m_UseCustomSlotLabel": false,
+    "m_CustomSlotLabel": "",
+    "m_DismissedVersion": 0,
+    "m_Precision": 0,
+    "overrideHLSLDeclaration": false,
+    "hlslDeclarationOverride": 0,
+    "m_Hidden": false,
+    "m_PerRendererData": false,
+    "m_customAttributes": [],
+    "m_Value": {
+        "x": 0.0,
+        "y": 0.0,
+        "z": 0.0,
+        "w": 0.0
+    }
+}
+
+{
+    "m_SGVersion": 0,
+    "m_Type": "UnityEditor.ShaderGraph.DynamicValueMaterialSlot",
+    "m_ObjectId": "e6b8cf91df65421ca2fe049830776dda",
+    "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": "ef2f097dfa294445a4ccca23502ede43",
+    "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_LiteralMode": false
+}
+
+{
+    "m_SGVersion": 0,
+    "m_Type": "UnityEditor.ShaderGraph.PropertyNode",
+    "m_ObjectId": "fe5d471b2a11492eac6a36ab8184f4b2",
+    "m_Group": {
+        "m_Id": ""
+    },
+    "m_Name": "Property",
+    "m_DrawState": {
+        "m_Expanded": true,
+        "m_Position": {
+            "serializedVersion": "2",
+            "x": -1071.0,
+            "y": -17.0,
+            "width": 121.0,
+            "height": 34.0
+        }
+    },
+    "m_Slots": [
+        {
+            "m_Id": "612553acf62a4201bdca9bd3aa18046e"
+        }
+    ],
+    "synonyms": [],
+    "m_Precision": 0,
+    "m_PreviewExpanded": true,
+    "m_DismissedVersion": 0,
+    "m_PreviewMode": 0,
+    "m_CustomColors": {
+        "m_SerializableColors": []
+    },
+    "m_Property": {
+        "m_Id": "b6a3150fd8d74e77af45b0f522032222"
+    }
+}
+

Assets/ColbyO/VNTG/Shaders/SubGraphs/Helper/Quantize.shadersubgraph.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: c8c251a1aa6fa004199bbe75b803b38b
+ScriptedImporter:
+  internalIDToNameTable: []
+  externalObjects: {}
+  serializedVersion: 2
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+  script: {fileID: 11500000, guid: 60072b568d64c40a485e0fc55012dc9f, type: 3}
+  documentationPath: 

Assets/ColbyO/VNTG/Shaders/SubGraphs/Helper/SphericalCoordinates.shadersubgraph.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 34d4210a11037df45940a8671bc64e78
+ScriptedImporter:
+  internalIDToNameTable: []
+  externalObjects: {}
+  serializedVersion: 2
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+  script: {fileID: 11500000, guid: 60072b568d64c40a485e0fc55012dc9f, type: 3}
+  documentationPath: 

Assets/ColbyO/VNTG/Shaders/SubGraphs/Helper/TriplanarNoise.shadersubgraph.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 7955c934384714f49a0801e51005060b
+ScriptedImporter:
+  internalIDToNameTable: []
+  externalObjects: {}
+  serializedVersion: 2
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+  script: {fileID: 11500000, guid: 60072b568d64c40a485e0fc55012dc9f, type: 3}
+  documentationPath: 

Assets/ColbyO/VNTG/Shaders/SubGraphs/Lighting.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: ac67eeea9b4fe2d4684094af04321052
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/ColbyO/VNTG/Shaders/SubGraphs/Lighting/ApplyLighting.shadersubgraph.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 2234e94c32dd24740b0f9730f25bd32f
+ScriptedImporter:
+  internalIDToNameTable: []
+  externalObjects: {}
+  serializedVersion: 2
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+  script: {fileID: 11500000, guid: 60072b568d64c40a485e0fc55012dc9f, type: 3}
+  documentationPath: 

Assets/ColbyO/VNTG/Shaders/SubGraphs/Lighting/CalculateLighting.shadersubgraph.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: be24eacae2883704a91ef15e2bf04420
+ScriptedImporter:
+  internalIDToNameTable: []
+  externalObjects: {}
+  serializedVersion: 2
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+  script: {fileID: 11500000, guid: 60072b568d64c40a485e0fc55012dc9f, type: 3}
+  documentationPath: 

Assets/ColbyO/VNTG/Shaders/SubGraphs/Lighting/PSXLighting.shadersubgraph.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 8f9b396071a84bf41904d0defd84c35d
+ScriptedImporter:
+  internalIDToNameTable: []
+  externalObjects: {}
+  serializedVersion: 2
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+  script: {fileID: 11500000, guid: 60072b568d64c40a485e0fc55012dc9f, type: 3}
+  documentationPath: 

Assets/ColbyO/VNTG/Shaders/SubGraphs/Scene.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 10b22e270a6eb034d95e50080b3e9553
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/ColbyO/VNTG/Shaders/SubGraphs/Scene/FetchDepth.shadersubgraph.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 737c0dc51b88a1444b46be29442da633
+ScriptedImporter:
+  internalIDToNameTable: []
+  externalObjects: {}
+  serializedVersion: 2
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+  script: {fileID: 11500000, guid: 60072b568d64c40a485e0fc55012dc9f, type: 3}
+  documentationPath: 

Assets/ColbyO/VNTG/Shaders/SubGraphs/Skybox.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 8b6ae01dd85dd914d97695d968e1e669
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/ColbyO/VNTG/Shaders/SubGraphs/Skybox/FlatGradientSkybox.shadersubgraph.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 7bd9e33dfdd07344293d1231a113976e
+ScriptedImporter:
+  internalIDToNameTable: []
+  externalObjects: {}
+  serializedVersion: 2
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+  script: {fileID: 11500000, guid: 60072b568d64c40a485e0fc55012dc9f, type: 3}
+  documentationPath: 

Assets/ColbyO/VNTG/Shaders/SubGraphs/Skybox/SpaceSkybox.shadersubgraph.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 6a3d459f63a946f498db3179c1126e1c
+ScriptedImporter:
+  internalIDToNameTable: []
+  externalObjects: {}
+  serializedVersion: 2
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+  script: {fileID: 11500000, guid: 60072b568d64c40a485e0fc55012dc9f, type: 3}
+  documentationPath: 

Assets/ColbyO/VNTG/Shaders/SubGraphs/Terrian.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 1c7db3e379282964c84a8268f7663eb8
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/ColbyO/VNTG/Shaders/SubGraphs/Terrian/PSXTerrianColor.shadersubgraph.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 99bb9fb7a62940c4688da678eaba5705
+ScriptedImporter:
+  internalIDToNameTable: []
+  externalObjects: {}
+  serializedVersion: 2
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+  script: {fileID: 11500000, guid: 60072b568d64c40a485e0fc55012dc9f, type: 3}
+  documentationPath: 

Assets/ColbyO/VNTG/Shaders/SubGraphs/Texture.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 5fe5f243110222d41811910af3f3a2a9
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/ColbyO/VNTG/Shaders/SubGraphs/Texture/DownsampleTexture.shadersubgraph

@@ -0,0 +1,937 @@
+{
+    "m_SGVersion": 3,
+    "m_Type": "UnityEditor.ShaderGraph.GraphData",
+    "m_ObjectId": "d5b6dad1920e4366ac6913a313a7d1d1",
+    "m_Properties": [
+        {
+            "m_Id": "4e6844a99dc742b7b0f1706e67646eea"
+        },
+        {
+            "m_Id": "6ed765bdda2f439997835986b14036b3"
+        }
+    ],
+    "m_Keywords": [],
+    "m_Dropdowns": [],
+    "m_CategoryData": [
+        {
+            "m_Id": "0187bdba60bc48e182f732fa7cd0e50e"
+        }
+    ],
+    "m_Nodes": [
+        {
+            "m_Id": "9130d4d01093429d8056430e8c6d5e9d"
+        },
+        {
+            "m_Id": "a27d7df02b9f450da840ee5eb6e49f3d"
+        },
+        {
+            "m_Id": "45e654c59813428389a4f8f9d7d82868"
+        },
+        {
+            "m_Id": "03c47cf72d984268814922b6be7d7b4c"
+        },
+        {
+            "m_Id": "271f3803e0f74ea4a8d774251eeb968f"
+        },
+        {
+            "m_Id": "59604637b9b54ac3bc4917bf22cb6b5f"
+        },
+        {
+            "m_Id": "d1a340ccf5024d0a95e00ce2c780b15f"
+        }
+    ],
+    "m_GroupDatas": [],
+    "m_StickyNoteDatas": [],
+    "m_Edges": [
+        {
+            "m_OutputSlot": {
+                "m_Node": {
+                    "m_Id": "03c47cf72d984268814922b6be7d7b4c"
+                },
+                "m_SlotId": 0
+            },
+            "m_InputSlot": {
+                "m_Node": {
+                    "m_Id": "a27d7df02b9f450da840ee5eb6e49f3d"
+                },
+                "m_SlotId": 1
+            }
+        },
+        {
+            "m_OutputSlot": {
+                "m_Node": {
+                    "m_Id": "03c47cf72d984268814922b6be7d7b4c"
+                },
+                "m_SlotId": 0
+            },
+            "m_InputSlot": {
+                "m_Node": {
+                    "m_Id": "d1a340ccf5024d0a95e00ce2c780b15f"
+                },
+                "m_SlotId": 0
+            }
+        },
+        {
+            "m_OutputSlot": {
+                "m_Node": {
+                    "m_Id": "271f3803e0f74ea4a8d774251eeb968f"
+                },
+                "m_SlotId": 1
+            },
+            "m_InputSlot": {
+                "m_Node": {
+                    "m_Id": "59604637b9b54ac3bc4917bf22cb6b5f"
+                },
+                "m_SlotId": 0
+            }
+        },
+        {
+            "m_OutputSlot": {
+                "m_Node": {
+                    "m_Id": "45e654c59813428389a4f8f9d7d82868"
+                },
+                "m_SlotId": 0
+            },
+            "m_InputSlot": {
+                "m_Node": {
+                    "m_Id": "a27d7df02b9f450da840ee5eb6e49f3d"
+                },
+                "m_SlotId": 0
+            }
+        },
+        {
+            "m_OutputSlot": {
+                "m_Node": {
+                    "m_Id": "59604637b9b54ac3bc4917bf22cb6b5f"
+                },
+                "m_SlotId": 2
+            },
+            "m_InputSlot": {
+                "m_Node": {
+                    "m_Id": "9130d4d01093429d8056430e8c6d5e9d"
+                },
+                "m_SlotId": 1
+            }
+        },
+        {
+            "m_OutputSlot": {
+                "m_Node": {
+                    "m_Id": "a27d7df02b9f450da840ee5eb6e49f3d"
+                },
+                "m_SlotId": 2
+            },
+            "m_InputSlot": {
+                "m_Node": {
+                    "m_Id": "271f3803e0f74ea4a8d774251eeb968f"
+                },
+                "m_SlotId": 0
+            }
+        },
+        {
+            "m_OutputSlot": {
+                "m_Node": {
+                    "m_Id": "d1a340ccf5024d0a95e00ce2c780b15f"
+                },
+                "m_SlotId": 2
+            },
+            "m_InputSlot": {
+                "m_Node": {
+                    "m_Id": "59604637b9b54ac3bc4917bf22cb6b5f"
+                },
+                "m_SlotId": 1
+            }
+        }
+    ],
+    "m_VertexContext": {
+        "m_Position": {
+            "x": 0.0,
+            "y": 0.0
+        },
+        "m_Blocks": []
+    },
+    "m_FragmentContext": {
+        "m_Position": {
+            "x": 0.0,
+            "y": 0.0
+        },
+        "m_Blocks": []
+    },
+    "m_PreviewData": {
+        "serializedMesh": {
+            "m_SerializedMesh": "{\"mesh\":{\"instanceID\":0}}",
+            "m_Guid": ""
+        },
+        "preventRotation": false
+    },
+    "m_Path": "VNTG/Texture",
+    "m_GraphPrecision": 1,
+    "m_PreviewMode": 2,
+    "m_OutputNode": {
+        "m_Id": "9130d4d01093429d8056430e8c6d5e9d"
+    },
+    "m_SubDatas": [],
+    "m_ActiveTargets": []
+}
+
+{
+    "m_SGVersion": 0,
+    "m_Type": "UnityEditor.ShaderGraph.CategoryData",
+    "m_ObjectId": "0187bdba60bc48e182f732fa7cd0e50e",
+    "m_Name": "",
+    "m_ChildObjectList": [
+        {
+            "m_Id": "6ed765bdda2f439997835986b14036b3"
+        },
+        {
+            "m_Id": "4e6844a99dc742b7b0f1706e67646eea"
+        }
+    ]
+}
+
+{
+    "m_SGVersion": 0,
+    "m_Type": "UnityEditor.ShaderGraph.PropertyNode",
+    "m_ObjectId": "03c47cf72d984268814922b6be7d7b4c",
+    "m_Group": {
+        "m_Id": ""
+    },
+    "m_Name": "Property",
+    "m_DrawState": {
+        "m_Expanded": true,
+        "m_Position": {
+            "serializedVersion": "2",
+            "x": -1054.0,
+            "y": 111.0,
+            "width": 169.0,
+            "height": 34.0
+        }
+    },
+    "m_Slots": [
+        {
+            "m_Id": "ed2972d008394e43ae87a6ae1e6864a4"
+        }
+    ],
+    "synonyms": [],
+    "m_Precision": 0,
+    "m_PreviewExpanded": true,
+    "m_DismissedVersion": 0,
+    "m_PreviewMode": 0,
+    "m_CustomColors": {
+        "m_SerializableColors": []
+    },
+    "m_Property": {
+        "m_Id": "4e6844a99dc742b7b0f1706e67646eea"
+    }
+}
+
+{
+    "m_SGVersion": 0,
+    "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot",
+    "m_ObjectId": "0bfcc8e0fda949feb40a1256d7c413ed",
+    "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_LiteralMode": false
+}
+
+{
+    "m_SGVersion": 0,
+    "m_Type": "UnityEditor.ShaderGraph.Vector2MaterialSlot",
+    "m_ObjectId": "0d2d7742416a435e900de6fd591d07e8",
+    "m_Id": 1,
+    "m_DisplayName": "Out",
+    "m_SlotType": 0,
+    "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": "235a6d92bccd44729a244fba6d7f2ea3",
+    "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.FloorNode",
+    "m_ObjectId": "271f3803e0f74ea4a8d774251eeb968f",
+    "m_Group": {
+        "m_Id": ""
+    },
+    "m_Name": "Floor",
+    "m_DrawState": {
+        "m_Expanded": true,
+        "m_Position": {
+            "serializedVersion": "2",
+            "x": -650.0,
+            "y": -162.0,
+            "width": 131.0,
+            "height": 94.0
+        }
+    },
+    "m_Slots": [
+        {
+            "m_Id": "5b3b7782da8b4688b02c9c360a64d108"
+        },
+        {
+            "m_Id": "935e347214394605a05ca43799400431"
+        }
+    ],
+    "synonyms": [
+        "down"
+    ],
+    "m_Precision": 0,
+    "m_PreviewExpanded": false,
+    "m_DismissedVersion": 0,
+    "m_PreviewMode": 0,
+    "m_CustomColors": {
+        "m_SerializableColors": []
+    }
+}
+
+{
+    "m_SGVersion": 0,
+    "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot",
+    "m_ObjectId": "377e0007f48c4ca89c7927e957534306",
+    "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_LiteralMode": false
+}
+
+{
+    "m_SGVersion": 0,
+    "m_Type": "UnityEditor.ShaderGraph.PropertyNode",
+    "m_ObjectId": "45e654c59813428389a4f8f9d7d82868",
+    "m_Group": {
+        "m_Id": ""
+    },
+    "m_Name": "Property",
+    "m_DrawState": {
+        "m_Expanded": true,
+        "m_Position": {
+            "serializedVersion": "2",
+            "x": -1040.0,
+            "y": -206.0,
+            "width": 93.0,
+            "height": 34.0
+        }
+    },
+    "m_Slots": [
+        {
+            "m_Id": "581ce94269ae45b09b686d521a484d63"
+        }
+    ],
+    "synonyms": [],
+    "m_Precision": 0,
+    "m_PreviewExpanded": true,
+    "m_DismissedVersion": 0,
+    "m_PreviewMode": 0,
+    "m_CustomColors": {
+        "m_SerializableColors": []
+    },
+    "m_Property": {
+        "m_Id": "6ed765bdda2f439997835986b14036b3"
+    }
+}
+
+{
+    "m_SGVersion": 0,
+    "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot",
+    "m_ObjectId": "4a6a172e0bf9414c916860c8200bcaff",
+    "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_LiteralMode": false
+}
+
+{
+    "m_SGVersion": 1,
+    "m_Type": "UnityEditor.ShaderGraph.Internal.Vector1ShaderProperty",
+    "m_ObjectId": "4e6844a99dc742b7b0f1706e67646eea",
+    "m_Guid": {
+        "m_GuidSerialized": "317cd29d-7474-408b-b387-be6f0ea4e75c"
+    },
+    "promotedFromAssetID": "",
+    "promotedFromCategoryName": "",
+    "promotedOrdering": -1,
+    "m_Name": "TextureResolution",
+    "m_DefaultRefNameVersion": 1,
+    "m_RefNameGeneratedByDisplayName": "TextureResolution",
+    "m_DefaultReferenceName": "_TextureResolution",
+    "m_OverrideReferenceName": "",
+    "m_GeneratePropertyBlock": true,
+    "m_UseCustomSlotLabel": false,
+    "m_CustomSlotLabel": "",
+    "m_DismissedVersion": 0,
+    "m_Precision": 0,
+    "overrideHLSLDeclaration": false,
+    "hlslDeclarationOverride": 0,
+    "m_Hidden": false,
+    "m_PerRendererData": false,
+    "m_customAttributes": [],
+    "m_Value": 0.0,
+    "m_FloatType": 0,
+    "m_LiteralFloatMode": false,
+    "m_RangeValues": {
+        "x": 0.0,
+        "y": 1.0
+    },
+    "m_SliderType": 0,
+    "m_SliderPower": 3.0,
+    "m_EnumType": 0,
+    "m_CSharpEnumString": "",
+    "m_EnumNames": [
+        "Default"
+    ],
+    "m_EnumValues": [
+        0
+    ]
+}
+
+{
+    "m_SGVersion": 0,
+    "m_Type": "UnityEditor.ShaderGraph.Vector2MaterialSlot",
+    "m_ObjectId": "581ce94269ae45b09b686d521a484d63",
+    "m_Id": 0,
+    "m_DisplayName": "UV",
+    "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.DivideNode",
+    "m_ObjectId": "59604637b9b54ac3bc4917bf22cb6b5f",
+    "m_Group": {
+        "m_Id": ""
+    },
+    "m_Name": "Divide",
+    "m_DrawState": {
+        "m_Expanded": true,
+        "m_Position": {
+            "serializedVersion": "2",
+            "x": -483.0,
+            "y": 22.0,
+            "width": 130.0,
+            "height": 118.0
+        }
+    },
+    "m_Slots": [
+        {
+            "m_Id": "4a6a172e0bf9414c916860c8200bcaff"
+        },
+        {
+            "m_Id": "0bfcc8e0fda949feb40a1256d7c413ed"
+        },
+        {
+            "m_Id": "b2a0160e63614cfc8d42f0bd2d9044b8"
+        }
+    ],
+    "synonyms": [
+        "division",
+        "divided by"
+    ],
+    "m_Precision": 0,
+    "m_PreviewExpanded": false,
+    "m_DismissedVersion": 0,
+    "m_PreviewMode": 0,
+    "m_CustomColors": {
+        "m_SerializableColors": []
+    }
+}
+
+{
+    "m_SGVersion": 0,
+    "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot",
+    "m_ObjectId": "5b3b7782da8b4688b02c9c360a64d108",
+    "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_LiteralMode": false
+}
+
+{
+    "m_SGVersion": 0,
+    "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot",
+    "m_ObjectId": "5b48d3746a2644a4a950584945573400",
+    "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_LiteralMode": false
+}
+
+{
+    "m_SGVersion": 1,
+    "m_Type": "UnityEditor.ShaderGraph.Internal.Vector2ShaderProperty",
+    "m_ObjectId": "6ed765bdda2f439997835986b14036b3",
+    "m_Guid": {
+        "m_GuidSerialized": "596093a4-179c-4de5-8c2e-c763e7dd8f3b"
+    },
+    "promotedFromAssetID": "",
+    "promotedFromCategoryName": "",
+    "promotedOrdering": -1,
+    "m_Name": "UV",
+    "m_DefaultRefNameVersion": 1,
+    "m_RefNameGeneratedByDisplayName": "UV",
+    "m_DefaultReferenceName": "_UV",
+    "m_OverrideReferenceName": "",
+    "m_GeneratePropertyBlock": true,
+    "m_UseCustomSlotLabel": false,
+    "m_CustomSlotLabel": "",
+    "m_DismissedVersion": 0,
+    "m_Precision": 0,
+    "overrideHLSLDeclaration": false,
+    "hlslDeclarationOverride": 0,
+    "m_Hidden": false,
+    "m_PerRendererData": false,
+    "m_customAttributes": [],
+    "m_Value": {
+        "x": 0.0,
+        "y": 0.0,
+        "z": 0.0,
+        "w": 0.0
+    }
+}
+
+{
+    "m_SGVersion": 0,
+    "m_Type": "UnityEditor.ShaderGraph.DynamicValueMaterialSlot",
+    "m_ObjectId": "8781a705d0c143419016ba44f6402586",
+    "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.SubGraphOutputNode",
+    "m_ObjectId": "9130d4d01093429d8056430e8c6d5e9d",
+    "m_Group": {
+        "m_Id": ""
+    },
+    "m_Name": "Output",
+    "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": "0d2d7742416a435e900de6fd591d07e8"
+        }
+    ],
+    "synonyms": [],
+    "m_Precision": 0,
+    "m_PreviewExpanded": true,
+    "m_DismissedVersion": 0,
+    "m_PreviewMode": 0,
+    "m_CustomColors": {
+        "m_SerializableColors": []
+    },
+    "IsFirstSlotValid": true
+}
+
+{
+    "m_SGVersion": 0,
+    "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot",
+    "m_ObjectId": "935e347214394605a05ca43799400431",
+    "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_LiteralMode": false
+}
+
+{
+    "m_SGVersion": 0,
+    "m_Type": "UnityEditor.ShaderGraph.MultiplyNode",
+    "m_ObjectId": "a27d7df02b9f450da840ee5eb6e49f3d",
+    "m_Group": {
+        "m_Id": ""
+    },
+    "m_Name": "Multiply",
+    "m_DrawState": {
+        "m_Expanded": true,
+        "m_Position": {
+            "serializedVersion": "2",
+            "x": -844.0,
+            "y": -182.0,
+            "width": 208.0,
+            "height": 302.0
+        }
+    },
+    "m_Slots": [
+        {
+            "m_Id": "235a6d92bccd44729a244fba6d7f2ea3"
+        },
+        {
+            "m_Id": "a6e51050135d47d8999ec6784711e286"
+        },
+        {
+            "m_Id": "8781a705d0c143419016ba44f6402586"
+        }
+    ],
+    "synonyms": [
+        "multiplication",
+        "times",
+        "x"
+    ],
+    "m_Precision": 0,
+    "m_PreviewExpanded": false,
+    "m_DismissedVersion": 0,
+    "m_PreviewMode": 0,
+    "m_CustomColors": {
+        "m_SerializableColors": []
+    }
+}
+
+{
+    "m_SGVersion": 0,
+    "m_Type": "UnityEditor.ShaderGraph.DynamicValueMaterialSlot",
+    "m_ObjectId": "a6e51050135d47d8999ec6784711e286",
+    "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": "b2a0160e63614cfc8d42f0bd2d9044b8",
+    "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_LiteralMode": false
+}
+
+{
+    "m_SGVersion": 0,
+    "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot",
+    "m_ObjectId": "d086462db85449a284aae653084ea78a",
+    "m_Id": 1,
+    "m_DisplayName": "B",
+    "m_SlotType": 0,
+    "m_Hidden": false,
+    "m_ShaderOutputName": "B",
+    "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_LiteralMode": false
+}
+
+{
+    "m_SGVersion": 0,
+    "m_Type": "UnityEditor.ShaderGraph.MaximumNode",
+    "m_ObjectId": "d1a340ccf5024d0a95e00ce2c780b15f",
+    "m_Group": {
+        "m_Id": ""
+    },
+    "m_Name": "Maximum",
+    "m_DrawState": {
+        "m_Expanded": true,
+        "m_Position": {
+            "serializedVersion": "2",
+            "x": -706.0,
+            "y": 143.0,
+            "width": 126.0,
+            "height": 118.0
+        }
+    },
+    "m_Slots": [
+        {
+            "m_Id": "377e0007f48c4ca89c7927e957534306"
+        },
+        {
+            "m_Id": "d086462db85449a284aae653084ea78a"
+        },
+        {
+            "m_Id": "5b48d3746a2644a4a950584945573400"
+        }
+    ],
+    "synonyms": [],
+    "m_Precision": 0,
+    "m_PreviewExpanded": false,
+    "m_DismissedVersion": 0,
+    "m_PreviewMode": 0,
+    "m_CustomColors": {
+        "m_SerializableColors": []
+    }
+}
+
+{
+    "m_SGVersion": 0,
+    "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot",
+    "m_ObjectId": "ed2972d008394e43ae87a6ae1e6864a4",
+    "m_Id": 0,
+    "m_DisplayName": "TextureResolution",
+    "m_SlotType": 1,
+    "m_Hidden": false,
+    "m_ShaderOutputName": "Out",
+    "m_StageCapability": 3,
+    "m_Value": 0.0,
+    "m_DefaultValue": 0.0,
+    "m_Labels": [],
+    "m_LiteralMode": false
+}
+

Assets/ColbyO/VNTG/Shaders/SubGraphs/Texture/DownsampleTexture.shadersubgraph.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 7d6099a683a8bb047b0d2f3bc9919687
+ScriptedImporter:
+  internalIDToNameTable: []
+  externalObjects: {}
+  serializedVersion: 2
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+  script: {fileID: 11500000, guid: 60072b568d64c40a485e0fc55012dc9f, type: 3}
+  documentationPath: 

Assets/ColbyO/VNTG/Shaders/SubGraphs/Texture/N64CubemapSampler.shadersubgraph

@@ -0,0 +1,552 @@
+{
+    "m_SGVersion": 3,
+    "m_Type": "UnityEditor.ShaderGraph.GraphData",
+    "m_ObjectId": "3b8199c20e4748469ee91c6a19eb5d61",
+    "m_Properties": [
+        {
+            "m_Id": "27eee78a6bac4e5ab12172f8b20433ab"
+        },
+        {
+            "m_Id": "f3ee5b4cfe8047649c1ffdad4e16555b"
+        }
+    ],
+    "m_Keywords": [],
+    "m_Dropdowns": [],
+    "m_CategoryData": [
+        {
+            "m_Id": "86fd225afa7548ae9397eba309ec4357"
+        }
+    ],
+    "m_Nodes": [
+        {
+            "m_Id": "1469a6c853d147ab973ea28b1df9a6ab"
+        },
+        {
+            "m_Id": "6515a5f18d274024bbaffb7ecb96e024"
+        },
+        {
+            "m_Id": "2c00d8e0740d455e805908dcfc4383f2"
+        },
+        {
+            "m_Id": "bca84da76f0a4f77aed6cb63f3f1a37d"
+        },
+        {
+            "m_Id": "d5c4a75f2a054dfa8ae6ae56767769a8"
+        }
+    ],
+    "m_GroupDatas": [],
+    "m_StickyNoteDatas": [],
+    "m_Edges": [
+        {
+            "m_OutputSlot": {
+                "m_Node": {
+                    "m_Id": "2c00d8e0740d455e805908dcfc4383f2"
+                },
+                "m_SlotId": 0
+            },
+            "m_InputSlot": {
+                "m_Node": {
+                    "m_Id": "bca84da76f0a4f77aed6cb63f3f1a37d"
+                },
+                "m_SlotId": 1
+            }
+        },
+        {
+            "m_OutputSlot": {
+                "m_Node": {
+                    "m_Id": "6515a5f18d274024bbaffb7ecb96e024"
+                },
+                "m_SlotId": 0
+            },
+            "m_InputSlot": {
+                "m_Node": {
+                    "m_Id": "bca84da76f0a4f77aed6cb63f3f1a37d"
+                },
+                "m_SlotId": 2
+            }
+        },
+        {
+            "m_OutputSlot": {
+                "m_Node": {
+                    "m_Id": "bca84da76f0a4f77aed6cb63f3f1a37d"
+                },
+                "m_SlotId": 0
+            },
+            "m_InputSlot": {
+                "m_Node": {
+                    "m_Id": "1469a6c853d147ab973ea28b1df9a6ab"
+                },
+                "m_SlotId": 1
+            }
+        },
+        {
+            "m_OutputSlot": {
+                "m_Node": {
+                    "m_Id": "d5c4a75f2a054dfa8ae6ae56767769a8"
+                },
+                "m_SlotId": 0
+            },
+            "m_InputSlot": {
+                "m_Node": {
+                    "m_Id": "bca84da76f0a4f77aed6cb63f3f1a37d"
+                },
+                "m_SlotId": 3
+            }
+        }
+    ],
+    "m_VertexContext": {
+        "m_Position": {
+            "x": 0.0,
+            "y": 0.0
+        },
+        "m_Blocks": []
+    },
+    "m_FragmentContext": {
+        "m_Position": {
+            "x": 0.0,
+            "y": 0.0
+        },
+        "m_Blocks": []
+    },
+    "m_PreviewData": {
+        "serializedMesh": {
+            "m_SerializedMesh": "{\"mesh\":{\"instanceID\":0}}",
+            "m_Guid": ""
+        },
+        "preventRotation": false
+    },
+    "m_Path": "VNTG/Texture/N64",
+    "m_GraphPrecision": 1,
+    "m_PreviewMode": 2,
+    "m_OutputNode": {
+        "m_Id": "1469a6c853d147ab973ea28b1df9a6ab"
+    },
+    "m_SubDatas": [],
+    "m_ActiveTargets": []
+}
+
+{
+    "m_SGVersion": 0,
+    "m_Type": "UnityEditor.ShaderGraph.Vector4MaterialSlot",
+    "m_ObjectId": "00a0d4ffe3384465aaaa1cd43cf6950a",
+    "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.SubGraphOutputNode",
+    "m_ObjectId": "1469a6c853d147ab973ea28b1df9a6ab",
+    "m_Group": {
+        "m_Id": ""
+    },
+    "m_Name": "Output",
+    "m_DrawState": {
+        "m_Expanded": true,
+        "m_Position": {
+            "serializedVersion": "2",
+            "x": -85.00003051757813,
+            "y": -93.00000762939453,
+            "width": 86.00001525878906,
+            "height": 77.00001525878906
+        }
+    },
+    "m_Slots": [
+        {
+            "m_Id": "9946ea8e7c86457ba2333a092334c3b9"
+        }
+    ],
+    "synonyms": [],
+    "m_Precision": 0,
+    "m_PreviewExpanded": true,
+    "m_DismissedVersion": 0,
+    "m_PreviewMode": 0,
+    "m_CustomColors": {
+        "m_SerializableColors": []
+    },
+    "IsFirstSlotValid": true
+}
+
+{
+    "m_SGVersion": 0,
+    "m_Type": "UnityEditor.ShaderGraph.Vector3MaterialSlot",
+    "m_ObjectId": "23248ea74d304545b0e26ee9e75ebd62",
+    "m_Id": 0,
+    "m_DisplayName": "Dir",
+    "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.Internal.CubemapShaderProperty",
+    "m_ObjectId": "27eee78a6bac4e5ab12172f8b20433ab",
+    "m_Guid": {
+        "m_GuidSerialized": "e5cfcbb6-68e9-4e04-9229-116a2dcb902b"
+    },
+    "promotedFromAssetID": "",
+    "promotedFromCategoryName": "",
+    "promotedOrdering": -1,
+    "m_Name": "Cubemap",
+    "m_DefaultRefNameVersion": 1,
+    "m_RefNameGeneratedByDisplayName": "Cubemap",
+    "m_DefaultReferenceName": "_Cubemap",
+    "m_OverrideReferenceName": "",
+    "m_GeneratePropertyBlock": true,
+    "m_UseCustomSlotLabel": false,
+    "m_CustomSlotLabel": "",
+    "m_DismissedVersion": 0,
+    "m_Precision": 0,
+    "overrideHLSLDeclaration": false,
+    "hlslDeclarationOverride": 0,
+    "m_Hidden": false,
+    "m_PerRendererData": false,
+    "m_customAttributes": [],
+    "m_Value": {
+        "m_SerializedCubemap": "{\"cubemap\":{\"instanceID\":0}}",
+        "m_Guid": ""
+    },
+    "isHDR": false,
+    "m_Modifiable": true
+}
+
+{
+    "m_SGVersion": 0,
+    "m_Type": "UnityEditor.ShaderGraph.PropertyNode",
+    "m_ObjectId": "2c00d8e0740d455e805908dcfc4383f2",
+    "m_Group": {
+        "m_Id": ""
+    },
+    "m_Name": "Property",
+    "m_DrawState": {
+        "m_Expanded": true,
+        "m_Position": {
+            "serializedVersion": "2",
+            "x": -638.0000610351563,
+            "y": -115.9999771118164,
+            "width": 128.99996948242188,
+            "height": 34.00000762939453
+        }
+    },
+    "m_Slots": [
+        {
+            "m_Id": "bffcb8d49aa74f40be6d2eea929e4e07"
+        }
+    ],
+    "synonyms": [],
+    "m_Precision": 0,
+    "m_PreviewExpanded": true,
+    "m_DismissedVersion": 0,
+    "m_PreviewMode": 0,
+    "m_CustomColors": {
+        "m_SerializableColors": []
+    },
+    "m_Property": {
+        "m_Id": "27eee78a6bac4e5ab12172f8b20433ab"
+    }
+}
+
+{
+    "m_SGVersion": 0,
+    "m_Type": "UnityEditor.ShaderGraph.SamplerStateMaterialSlot",
+    "m_ObjectId": "604056d64bc04c568df0110118c84d5a",
+    "m_Id": 2,
+    "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.SamplerStateNode",
+    "m_ObjectId": "6515a5f18d274024bbaffb7ecb96e024",
+    "m_Group": {
+        "m_Id": ""
+    },
+    "m_Name": "Sampler State",
+    "m_DrawState": {
+        "m_Expanded": true,
+        "m_Position": {
+            "serializedVersion": "2",
+            "x": -651.0000610351563,
+            "y": -70.9999771118164,
+            "width": 145.00003051757813,
+            "height": 136.0
+        }
+    },
+    "m_Slots": [
+        {
+            "m_Id": "9b59456a1a7847569cebcd8c603c0702"
+        }
+    ],
+    "synonyms": [],
+    "m_Precision": 0,
+    "m_PreviewExpanded": true,
+    "m_DismissedVersion": 0,
+    "m_PreviewMode": 0,
+    "m_CustomColors": {
+        "m_SerializableColors": []
+    },
+    "m_filter": 1,
+    "m_wrap": 0,
+    "m_aniso": 0
+}
+
+{
+    "m_SGVersion": 0,
+    "m_Type": "UnityEditor.ShaderGraph.CubemapInputMaterialSlot",
+    "m_ObjectId": "7b35340817c340308f6b6136143213d3",
+    "m_Id": 1,
+    "m_DisplayName": "Cube",
+    "m_SlotType": 0,
+    "m_Hidden": false,
+    "m_ShaderOutputName": "Cube",
+    "m_StageCapability": 3,
+    "m_BareResource": false,
+    "m_Cubemap": {
+        "m_SerializedCubemap": "{\"cubemap\":{\"instanceID\":0}}",
+        "m_Guid": ""
+    }
+}
+
+{
+    "m_SGVersion": 0,
+    "m_Type": "UnityEditor.ShaderGraph.CategoryData",
+    "m_ObjectId": "86fd225afa7548ae9397eba309ec4357",
+    "m_Name": "",
+    "m_ChildObjectList": [
+        {
+            "m_Id": "27eee78a6bac4e5ab12172f8b20433ab"
+        },
+        {
+            "m_Id": "f3ee5b4cfe8047649c1ffdad4e16555b"
+        }
+    ]
+}
+
+{
+    "m_SGVersion": 0,
+    "m_Type": "UnityEditor.ShaderGraph.Vector4MaterialSlot",
+    "m_ObjectId": "9946ea8e7c86457ba2333a092334c3b9",
+    "m_Id": 1,
+    "m_DisplayName": "Out",
+    "m_SlotType": 0,
+    "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": "9b59456a1a7847569cebcd8c603c0702",
+    "m_Id": 0,
+    "m_DisplayName": "Out",
+    "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": "bca84da76f0a4f77aed6cb63f3f1a37d",
+    "m_Group": {
+        "m_Id": ""
+    },
+    "m_Name": "N64SamplerCube (Custom Function)",
+    "m_DrawState": {
+        "m_Expanded": true,
+        "m_Position": {
+            "serializedVersion": "2",
+            "x": -457.0000305175781,
+            "y": -93.00000762939453,
+            "width": 254.99998474121095,
+            "height": 142.00001525878907
+        }
+    },
+    "m_Slots": [
+        {
+            "m_Id": "7b35340817c340308f6b6136143213d3"
+        },
+        {
+            "m_Id": "604056d64bc04c568df0110118c84d5a"
+        },
+        {
+            "m_Id": "ed12f4cd1e5246fdb5d276f2f5f735ac"
+        },
+        {
+            "m_Id": "00a0d4ffe3384465aaaa1cd43cf6950a"
+        }
+    ],
+    "synonyms": [
+        "code",
+        "HLSL"
+    ],
+    "m_Precision": 0,
+    "m_PreviewExpanded": false,
+    "m_DismissedVersion": 0,
+    "m_PreviewMode": 0,
+    "m_CustomColors": {
+        "m_SerializableColors": []
+    },
+    "m_SourceType": 0,
+    "m_FunctionName": "N64SamplerCube",
+    "m_FunctionSource": "04975814c73fcca4b938b0d8b3595590",
+    "m_FunctionSourceUsePragmas": true,
+    "m_FunctionBody": "Enter function body here..."
+}
+
+{
+    "m_SGVersion": 0,
+    "m_Type": "UnityEditor.ShaderGraph.CubemapMaterialSlot",
+    "m_ObjectId": "bffcb8d49aa74f40be6d2eea929e4e07",
+    "m_Id": 0,
+    "m_DisplayName": "Cubemap",
+    "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": "d5c4a75f2a054dfa8ae6ae56767769a8",
+    "m_Group": {
+        "m_Id": ""
+    },
+    "m_Name": "Property",
+    "m_DrawState": {
+        "m_Expanded": true,
+        "m_Position": {
+            "serializedVersion": "2",
+            "x": -605.0000610351563,
+            "y": 71.00000762939453,
+            "width": 92.0,
+            "height": 34.0
+        }
+    },
+    "m_Slots": [
+        {
+            "m_Id": "23248ea74d304545b0e26ee9e75ebd62"
+        }
+    ],
+    "synonyms": [],
+    "m_Precision": 0,
+    "m_PreviewExpanded": true,
+    "m_DismissedVersion": 0,
+    "m_PreviewMode": 0,
+    "m_CustomColors": {
+        "m_SerializableColors": []
+    },
+    "m_Property": {
+        "m_Id": "f3ee5b4cfe8047649c1ffdad4e16555b"
+    }
+}
+
+{
+    "m_SGVersion": 0,
+    "m_Type": "UnityEditor.ShaderGraph.Vector3MaterialSlot",
+    "m_ObjectId": "ed12f4cd1e5246fdb5d276f2f5f735ac",
+    "m_Id": 3,
+    "m_DisplayName": "DIr",
+    "m_SlotType": 0,
+    "m_Hidden": false,
+    "m_ShaderOutputName": "DIr",
+    "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.Vector3ShaderProperty",
+    "m_ObjectId": "f3ee5b4cfe8047649c1ffdad4e16555b",
+    "m_Guid": {
+        "m_GuidSerialized": "c79938d5-f337-4713-9f91-cfc6ae363b0a"
+    },
+    "promotedFromAssetID": "",
+    "promotedFromCategoryName": "",
+    "promotedOrdering": -1,
+    "m_Name": "Dir",
+    "m_DefaultRefNameVersion": 1,
+    "m_RefNameGeneratedByDisplayName": "Dir",
+    "m_DefaultReferenceName": "_Dir",
+    "m_OverrideReferenceName": "",
+    "m_GeneratePropertyBlock": true,
+    "m_UseCustomSlotLabel": false,
+    "m_CustomSlotLabel": "",
+    "m_DismissedVersion": 0,
+    "m_Precision": 0,
+    "overrideHLSLDeclaration": false,
+    "hlslDeclarationOverride": 0,
+    "m_Hidden": false,
+    "m_PerRendererData": false,
+    "m_customAttributes": [],
+    "m_Value": {
+        "x": 0.0,
+        "y": 0.0,
+        "z": 1.0,
+        "w": 0.0
+    }
+}
+

Assets/ColbyO/VNTG/Shaders/SubGraphs/Texture/N64CubemapSampler.shadersubgraph.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 181402b2695088145a35a8842c6f7894
+ScriptedImporter:
+  internalIDToNameTable: []
+  externalObjects: {}
+  serializedVersion: 2
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+  script: {fileID: 11500000, guid: 60072b568d64c40a485e0fc55012dc9f, type: 3}
+  documentationPath: 

Assets/ColbyO/VNTG/Shaders/SubGraphs/Texture/N64TextureSampler.shadersubgraph.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: f75248847bc3fa649a2fa01e7b221d3d
+ScriptedImporter:
+  internalIDToNameTable: []
+  externalObjects: {}
+  serializedVersion: 2
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+  script: {fileID: 11500000, guid: 60072b568d64c40a485e0fc55012dc9f, type: 3}
+  documentationPath: 

Assets/ColbyO/VNTG/Shaders/SubGraphs/Texture/PSXCubemapSampler.shadersubgraph.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: a3449289308fde046b2999cef8ed0ac5
+ScriptedImporter:
+  internalIDToNameTable: []
+  externalObjects: {}
+  serializedVersion: 2
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+  script: {fileID: 11500000, guid: 60072b568d64c40a485e0fc55012dc9f, type: 3}
+  documentationPath: 

Assets/ColbyO/VNTG/Shaders/SubGraphs/Texture/PSXTextureSampler.shadersubgraph.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 7f1683f7607bdbf47aa3cb1e3b204469
+ScriptedImporter:
+  internalIDToNameTable: []
+  externalObjects: {}
+  serializedVersion: 2
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+  script: {fileID: 11500000, guid: 60072b568d64c40a485e0fc55012dc9f, type: 3}
+  documentationPath: 

Assets/ColbyO/VNTG/Shaders/SubGraphs/Vertex.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: b0b22d13fcf02ce4ba4558784326385a
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/ColbyO/VNTG/Shaders/SubGraphs/Vertex/ApplyVertexPrecision.shadersubgraph.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: c4c592fe73067094780ad516fb4dbf24
+ScriptedImporter:
+  internalIDToNameTable: []
+  externalObjects: {}
+  serializedVersion: 2
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+  script: {fileID: 11500000, guid: 60072b568d64c40a485e0fc55012dc9f, type: 3}
+  documentationPath: 

Assets/ColbyO/VNTG/Shaders/SubGraphs/Vertex/PSXVertexStage.shadersubgraph.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 57e6c25c65808f34c9f76ca74e6229b7
+ScriptedImporter:
+  internalIDToNameTable: []
+  externalObjects: {}
+  serializedVersion: 2
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+  script: {fileID: 11500000, guid: 60072b568d64c40a485e0fc55012dc9f, type: 3}
+  documentationPath: 

Assets/ColbyO/VNTG/Shaders/SubGraphs/Vertex/VertexPrecision.shadersubgraph.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 13c55773d504863488f57c14a229f6f3
+ScriptedImporter:
+  internalIDToNameTable: []
+  externalObjects: {}
+  serializedVersion: 2
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+  script: {fileID: 11500000, guid: 60072b568d64c40a485e0fc55012dc9f, type: 3}
+  documentationPath: