diff options
Diffstat (limited to 'VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes')
120 files changed, 10547 insertions, 0 deletions
diff --git a/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_FunctionsArtistic.cginc b/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_FunctionsArtistic.cginc new file mode 100644 index 00000000..7d5e17c1 --- /dev/null +++ b/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_FunctionsArtistic.cginc @@ -0,0 +1,369 @@ +#ifndef POI_FUNCTIONS_ARTISTIC + #define POI_FUNCTIONS_ARTISTIC + + // Based on unity shader graph code + + // * Adjustments * // + + /* + * Channel Mixer + * + * Controls the amount each of the channels of input In contribute to each of the channels of output Out. The slider + * parameters on the node control the contribution of each of the input channels. The toggle button parameters control + * which of the output channels is currently being edited. Slider controls for editing the contribution of each input + * channnel range between -2 and 2. + */ + void poiChannelMixer(float3 In, float3 _ChannelMixer_Red, float3 _ChannelMixer_Green, float3 _ChannelMixer_Blue, out float3 Out) + { + Out = float3(dot(In, _ChannelMixer_Red), dot(In, _ChannelMixer_Green), dot(In, _ChannelMixer_Blue)); + } + + /* + * Contrast + * + * Adjusts the contrast of input In by the amount of input Contrast. A Contrast value of 1 will return the input + * unaltered. A Contrast value of 0 will return the midpoint of the input + */ + void poiContrast(float3 In, float Contrast, out float3 Out) + { + float midpoint = pow(0.5, 2.2); + Out = (In - midpoint) * Contrast + midpoint; + } + + + /* + * Invert Colors + * + * Inverts the colors of input In on a per channel basis. This Node assumes all input values are in the range 0 - 1. + */ + void poiInvertColors(float4 In, float4 InvertColors, out float4 Out) + { + Out = abs(InvertColors - In); + } + + /* + * Replace Color + * + * Replaces values in input In equal to input From to the value of input To. Input Range can be used to define a + * wider range of values around input From to replace. Input Fuzziness can be used to soften the edges around the + * selection similar to anti-aliasing. + */ + void poiReplaceColor(float3 In, float3 From, float3 To, float Range, float Fuzziness, out float3 Out) + { + float Distance = distance(From, In); + Out = lerp(To, In, saturate((Distance - Range) / max(Fuzziness, 0.00001))); + } + + /* + * Saturation + * + * Adjusts the saturation of input In by the amount of input Saturation. A Saturation value of 1 will return the input + * unaltered. A Saturation value of 0 will return the input completely desaturated. + */ + void poiSaturation(float3 In, float Saturation, out float3 Out) + { + float luma = dot(In, float3(0.2126729, 0.7151522, 0.0721750)); + Out = luma.xxx + Saturation.xxx * (In - luma.xxx); + } + + /* + * Dither Node + * + * Dither is an intentional form of noise used to randomize quantization error. It is used to prevent large-scale + * patterns such as color banding in images. The Dither node applies dithering in screen-space to ensure a uniform + * distribution of the pattern. This can be adjusted by connecting another node to input Screen Position. + * + * This Node is commonly used as an input to Alpha Clip Threshold on a Master Node to give the appearance of + * transparency to an opaque object. This is useful for creating objects that appear to be transparent but have + * the advantages of rendering as opaque, such as writing depth and/or being rendered in deferred. + */ + void poiDither(float4 In, float4 ScreenPosition, out float4 Out) + { + float2 uv = ScreenPosition.xy * _ScreenParams.xy; + float DITHER_THRESHOLDS[16] = { + 1.0 / 17.0, 9.0 / 17.0, 3.0 / 17.0, 11.0 / 17.0, + 13.0 / 17.0, 5.0 / 17.0, 15.0 / 17.0, 7.0 / 17.0, + 4.0 / 17.0, 12.0 / 17.0, 2.0 / 17.0, 10.0 / 17.0, + 16.0 / 17.0, 8.0 / 17.0, 14.0 / 17.0, 6.0 / 17.0 + }; + uint index = (uint(uv.x) % 4) * 4 + uint(uv.y) % 4; + Out = In - DITHER_THRESHOLDS[index]; + } + + /* + * Color Mask + * + * Creates a mask from values in input In equal to input Mask Color. Input Range can be used to define a wider + * range of values around input Mask Color to create the mask. Colors within this range will return 1, + * otherwise the node will return 0. Input Fuzziness can be used to soften the edges around the selection + * similar to anti-aliasing. + */ + void poiColorMask(float3 In, float3 MaskColor, float Range, float Fuzziness, out float4 Out) + { + float Distance = distance(MaskColor, In); + Out = saturate(1 - (Distance - Range) / max(Fuzziness, 0.00001)); + } + + float3 hueShift(float3 color, float Offset) + { + float4 K = float4(0.0, -1.0 / 3.0, 2.0 / 3.0, -1.0); + float4 P = lerp(float4(color.bg, K.wz), float4(color.gb, K.xy), step(color.b, color.g)); + float4 Q = lerp(float4(P.xyw, color.r), float4(color.r, P.yzx), step(P.x, color.r)); + float D = Q.x - min(Q.w, Q.y); + float E = 0.0000000001; + float3 hsv = float3(abs(Q.z + (Q.w - Q.y) / (6.0 * D + E)), D / (Q.x + E), Q.x); + + float hue = hsv.x + Offset; + hsv.x = frac(hue); + + float4 K2 = float4(1.0, 2.0 / 3.0, 1.0 / 3.0, 3.0); + float3 P2 = abs(frac(hsv.xxx + K2.xyz) * 6.0 - K2.www); + return hsv.z * lerp(K2.xxx, saturate(P2 - K2.xxx), hsv.y); + } + + static const float Epsilon = 1e-10; + // The weights of RGB contributions to luminance. + // Should sum to unity. + static const float3 HCYwts = float3(0.299, 0.587, 0.114); + static const float HCLgamma = 3; + static const float HCLy0 = 100; + static const float HCLmaxL = 0.530454533953517; // == exp(HCLgamma / HCLy0) - 0.5 + static const float3 wref = float3(1.0, 1.0, 1.0); + #define TAU 6.28318531 + + float3 HUEtoRGB(in float H) + { + float R = abs(H * 6 - 3) - 1; + float G = 2 - abs(H * 6 - 2); + float B = 2 - abs(H * 6 - 4); + return saturate(float3(R, G, B)); + } + + float3 RGBtoHCV(in float3 RGB) + { + // Based on work by Sam Hocevar and Emil Persson + float4 P = (RGB.g < RGB.b) ? float4(RGB.bg, -1.0, 2.0 / 3.0): float4(RGB.gb, 0.0, -1.0 / 3.0); + float4 Q = (RGB.r < P.x) ? float4(P.xyw, RGB.r): float4(RGB.r, P.yzx); + float C = Q.x - min(Q.w, Q.y); + float H = abs((Q.w - Q.y) / (6 * C + Epsilon) + Q.z); + return float3(H, C, Q.x); + } + + float3 HSVtoRGB(in float3 HSV) + { + float3 RGB = HUEtoRGB(HSV.x); + return((RGB - 1) * HSV.y + 1) * HSV.z; + } + + float3 RGBtoHSV(in float3 RGB) + { + float3 HCV = RGBtoHCV(RGB); + float S = HCV.y / (HCV.z + Epsilon); + return float3(HCV.x, S, HCV.z); + } + + float3 HSLtoRGB(in float3 HSL) + { + float3 RGB = HUEtoRGB(HSL.x); + float C = (1 - abs(2 * HSL.z - 1)) * HSL.y; + return(RGB - 0.5) * C + HSL.z; + } + + float3 RGBtoHSL(in float3 RGB) + { + float3 HCV = RGBtoHCV(RGB); + float L = HCV.z - HCV.y * 0.5; + float S = HCV.y / (1 - abs(L * 2 - 1) + Epsilon); + return float3(HCV.x, S, L); + } + + float3 HCYtoRGB(in float3 HCY) + { + + + float3 RGB = HUEtoRGB(HCY.x); + float Z = dot(RGB, HCYwts); + if (HCY.z < Z) + { + HCY.y *= HCY.z / Z; + } + else if(Z < 1) + { + HCY.y *= (1 - HCY.z) / (1 - Z); + } + return(RGB - Z) * HCY.y + HCY.z; + } + + float3 RGBtoHCY(in float3 RGB) + { + // Corrected by David Schaeffer + float3 HCV = RGBtoHCV(RGB); + float Y = dot(RGB, HCYwts); + float Z = dot(HUEtoRGB(HCV.x), HCYwts); + if (Y < Z) + { + HCV.y *= Z / (Epsilon + Y); + } + else + { + HCV.y *= (1 - Z) / (Epsilon + 1 - Y); + } + return float3(HCV.x, HCV.y, Y); + } + + float3 HCLtoRGB(in float3 HCL) + { + float3 RGB = 0; + if(HCL.z != 0) + { + float H = HCL.x; + float C = HCL.y; + float L = HCL.z * HCLmaxL; + float Q = exp((1 - C / (2 * L)) * (HCLgamma / HCLy0)); + float U = (2 * L - C) / (2 * Q - 1); + float V = C / Q; + float A = (H + min(frac(2 * H) / 4, frac(-2 * H) / 8)) * pi * 2; + float T; + H *= 6; + if(H <= 0.999) + { + T = tan(A); + RGB.r = 1; + RGB.g = T / (1 + T); + } + else if(H <= 1.001) + { + RGB.r = 1; + RGB.g = 1; + } + else if(H <= 2) + { + T = tan(A); + RGB.r = (1 + T) / T; + RGB.g = 1; + } + else if(H <= 3) + { + T = tan(A); + RGB.g = 1; + RGB.b = 1 + T; + } + else if(H <= 3.999) + { + T = tan(A); + RGB.g = 1 / (1 + T); + RGB.b = 1; + } + else if(H <= 4.001) + { + RGB.g = 0; + RGB.b = 1; + } + else if(H <= 5) + { + T = tan(A); + RGB.r = -1 / T; + RGB.b = 1; + } + else + { + T = tan(A); + RGB.r = 1; + RGB.b = -T; + } + RGB = RGB * V + U; + } + return RGB; + } + + float3 RGBtoHCL(in float3 RGB) + { + float3 HCL; + float H = 0; + float U = min(RGB.r, min(RGB.g, RGB.b)); + float V = max(RGB.r, max(RGB.g, RGB.b)); + float Q = HCLgamma / HCLy0; + HCL.y = V - U; + if(HCL.y != 0) + { + H = atan2(RGB.g - RGB.b, RGB.r - RGB.g) / pi; + Q *= U / V; + } + Q = exp(Q); + HCL.x = frac(H / 2 - min(frac(H), frac(-H)) / 6); + HCL.y *= Q; + HCL.z = lerp(-U, V, Q) / (HCLmaxL * 2); + return HCL; + } + + //HSL MODIFT + float3 ModifyViaHSL(float3 color, float3 HSLMod) + { + float3 colorHSL = RGBtoHSL(color); + colorHSL.r = frac(colorHSL.r + HSLMod.r); + colorHSL.g = saturate(colorHSL.g + HSLMod.g); + colorHSL.b = saturate(colorHSL.b + HSLMod.b); + return HSLtoRGB(colorHSL); + } + + float3 poiSaturation(float3 In, float Saturation) + { + float luma = dot(In, float3(0.2126729, 0.7151522, 0.0721750)); + return luma.xxx + Saturation.xxx * (In - luma.xxx); + } + // LCH + float xyzF(float t) + { + return lerp(pow(t, 1. / 3.), 7.787037 * t + 0.139731, step(t, 0.00885645)); + } + float xyzR(float t) + { + return lerp(t * t * t, 0.1284185 * (t - 0.139731), step(t, 0.20689655)); + } + float3 rgb2lch(in float3 c) + { + c = mul(float3x3(0.4124, 0.3576, 0.1805, + 0.2126, 0.7152, 0.0722, + 0.0193, 0.1192, 0.9505), c); + c.x = xyzF(c.x / wref.x); + c.y = xyzF(c.y / wref.y); + c.z = xyzF(c.z / wref.z); + float3 lab = float3(max(0., 116.0 * c.y - 16.0), 500.0 * (c.x - c.y), 200.0 * (c.y - c.z)); + return float3(lab.x, length(float2(lab.y, lab.z)), atan2(lab.z, lab.y)); + } + + float3 lch2rgb(in float3 c) + { + c = float3(c.x, cos(c.z) * c.y, sin(c.z) * c.y); + + float lg = 1. / 116. * (c.x + 16.); + float3 xyz = float3(wref.x * xyzR(lg + 0.002 * c.y), + wref.y * xyzR(lg), + wref.z * xyzR(lg - 0.005 * c.z)); + + float3 rgb = mul(float3x3(3.2406, -1.5372, -0.4986, + - 0.9689, 1.8758, 0.0415, + 0.0557, -0.2040, 1.0570), xyz); + + return rgb; + } + + //cheaply lerp around a circle + float lerpAng(in float a, in float b, in float x) + { + float ang = fmod(fmod((a - b), TAU) + pi * 3., TAU) - pi; + return ang * x + b; + } + + //Linear interpolation between two colors in Lch space + float3 lerpLch(in float3 a, in float3 b, in float x) + { + float hue = lerpAng(a.z, b.z, x); + return float3(lerp(b.xy, a.xy, x), hue); + } + + float3 poiExpensiveColorBlend(float3 col1, float3 col2, float alpha) + { + return lch2rgb(lerpLch(rgb2lch(col1), rgb2lch(col2), alpha)); + } +#endif diff --git a/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_FunctionsArtistic.cginc.meta b/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_FunctionsArtistic.cginc.meta new file mode 100644 index 00000000..5e84b13e --- /dev/null +++ b/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_FunctionsArtistic.cginc.meta @@ -0,0 +1,9 @@ +fileFormatVersion: 2 +guid: 2c03b6977adb61d418773067122b0fc0 +ShaderImporter: + externalObjects: {} + defaultTextures: [] + nonModifiableTextures: [] + userData: + assetBundleName: + assetBundleVariant: diff --git a/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_PoiAlphaToCoverage.cginc b/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_PoiAlphaToCoverage.cginc new file mode 100644 index 00000000..de3aaf9c --- /dev/null +++ b/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_PoiAlphaToCoverage.cginc @@ -0,0 +1,32 @@ +#ifndef POI_ALPHA_TO_COVERAGE + #define POI_ALPHA_TO_COVERAGE + + half _MainMipScale; + float _MainAlphaToCoverage; + + float CalcMipLevel(float2 texture_coord) + { + float2 dx = ddx(texture_coord); + float2 dy = ddy(texture_coord); + float delta_max_sqr = max(dot(dx, dx), dot(dy, dy)); + + return 0.5 * log2(delta_max_sqr); + } + + void ApplyAlphaToCoverage(inout float4 finalColor) + { + // Force Model Opacity to 1 if desired + + if (float(0) == 1) + { + + if(float(0)) + { + // rescale alpha by mip level + finalColor.a *= 1 + max(0, CalcMipLevel(poiMesh.uv[0] * float4(0.25,0.25,4,4).zw)) * float(0.25); + // rescale alpha by partial derivative + finalColor.a = (finalColor.a - float(0.5)) / max(fwidth(finalColor.a), 0.0001) + float(0.5); + } + } + } +#endif diff --git a/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_PoiAlphaToCoverage.cginc.meta b/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_PoiAlphaToCoverage.cginc.meta new file mode 100644 index 00000000..aad38a22 --- /dev/null +++ b/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_PoiAlphaToCoverage.cginc.meta @@ -0,0 +1,9 @@ +fileFormatVersion: 2 +guid: d815501f7c516d14e8aaf342df5725e1 +ShaderImporter: + externalObjects: {} + defaultTextures: [] + nonModifiableTextures: [] + userData: + assetBundleName: + assetBundleVariant: diff --git a/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_PoiAudioLink.cginc b/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_PoiAudioLink.cginc new file mode 100644 index 00000000..592dbf84 --- /dev/null +++ b/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_PoiAudioLink.cginc @@ -0,0 +1,127 @@ +#ifndef POI_AUDIOLINK +#define POI_AUDIOLINK + +UNITY_DECLARE_TEX2D(_AudioTexture); +float4 _AudioTexture_ST; +fixed _AudioLinkDelay; +fixed _AudioLinkAveraging; +fixed _AudioLinkAverageRange; + +// Debug +fixed _EnableAudioLinkDebug; +fixed _AudioLinkDebugTreble; +fixed _AudioLinkDebugHighMid; +fixed _AudioLinkDebugLowMid; +fixed _AudioLinkDebugBass; +fixed _AudioLinkDebugAnimate; +fixed _AudioLinkTextureVisualization; + +void AudioTextureExists() +{ + half testw = 0; + half testh = 0; + _AudioTexture.GetDimensions(testw, testh); + poiMods.audioLinkTextureExists = testw >= 32; + + switch(testw) + { + case 32: // V1 + poiMods.audioLinkVersion = 1; + break; + case 128: // V2 + poiMods.audioLinkVersion = 2; + break; + default: + poiMods.audioLinkVersion = 1; + break; + } +} + +float getBandAtTime(float band, fixed time, fixed width) +{ + float versionUvMultiplier = 1; + + if (poiMods.audioLinkVersion == 2) + { + versionUvMultiplier = 0.0625; + } + return UNITY_SAMPLE_TEX2D(_AudioTexture, float2(time * width, (band * .25 + .125) * versionUvMultiplier)).r; +} + +void initAudioBands() +{ + AudioTextureExists(); + + float versionUvMultiplier = 1; + + if (poiMods.audioLinkVersion == 2) + { + versionUvMultiplier = 0.0625; + } + + if (poiMods.audioLinkTextureExists) + { + poiMods.audioLink.x = UNITY_SAMPLE_TEX2D(_AudioTexture, float2(float(0), .125 * versionUvMultiplier)); + poiMods.audioLink.y = UNITY_SAMPLE_TEX2D(_AudioTexture, float2(float(0), .375 * versionUvMultiplier)); + poiMods.audioLink.z = UNITY_SAMPLE_TEX2D(_AudioTexture, float2(float(0), .625 * versionUvMultiplier)); + poiMods.audioLink.w = UNITY_SAMPLE_TEX2D(_AudioTexture, float2(float(0), .875 * versionUvMultiplier)); + + + if (float(0)) + { + float uv = saturate(float(0) + float(0.5) * .25); + poiMods.audioLink.x += UNITY_SAMPLE_TEX2D(_AudioTexture, float2(uv, .125 * versionUvMultiplier)); + poiMods.audioLink.y += UNITY_SAMPLE_TEX2D(_AudioTexture, float2(uv, .375 * versionUvMultiplier)); + poiMods.audioLink.z += UNITY_SAMPLE_TEX2D(_AudioTexture, float2(uv, .625 * versionUvMultiplier)); + poiMods.audioLink.w += UNITY_SAMPLE_TEX2D(_AudioTexture, float2(uv, .875 * versionUvMultiplier)); + + uv = saturate(float(0) + float(0.5) * .5); + poiMods.audioLink.x += UNITY_SAMPLE_TEX2D(_AudioTexture, float2(uv, .125 * versionUvMultiplier)); + poiMods.audioLink.y += UNITY_SAMPLE_TEX2D(_AudioTexture, float2(uv, .375 * versionUvMultiplier)); + poiMods.audioLink.z += UNITY_SAMPLE_TEX2D(_AudioTexture, float2(uv, .625 * versionUvMultiplier)); + poiMods.audioLink.w += UNITY_SAMPLE_TEX2D(_AudioTexture, float2(uv, .875 * versionUvMultiplier)); + + uv = saturate(float(0) + float(0.5) * .75); + poiMods.audioLink.x += UNITY_SAMPLE_TEX2D(_AudioTexture, float2(uv, .125 * versionUvMultiplier)); + poiMods.audioLink.y += UNITY_SAMPLE_TEX2D(_AudioTexture, float2(uv, .375 * versionUvMultiplier)); + poiMods.audioLink.z += UNITY_SAMPLE_TEX2D(_AudioTexture, float2(uv, .625 * versionUvMultiplier)); + poiMods.audioLink.w += UNITY_SAMPLE_TEX2D(_AudioTexture, float2(uv, .875 * versionUvMultiplier)); + + uv = saturate(float(0) + float(0.5)); + poiMods.audioLink.x += UNITY_SAMPLE_TEX2D(_AudioTexture, float2(uv, .125 * versionUvMultiplier)); + poiMods.audioLink.y += UNITY_SAMPLE_TEX2D(_AudioTexture, float2(uv, .375 * versionUvMultiplier)); + poiMods.audioLink.z += UNITY_SAMPLE_TEX2D(_AudioTexture, float2(uv, .625 * versionUvMultiplier)); + poiMods.audioLink.w += UNITY_SAMPLE_TEX2D(_AudioTexture, float2(uv, .875 * versionUvMultiplier)); + + poiMods.audioLink /= 5; + } + } + + #ifndef OPTIMIZER_ENABLED + + if (float(0)) + { + poiMods.audioLink.x = float(0); + poiMods.audioLink.y = float(0); + poiMods.audioLink.z = float(0); + poiMods.audioLink.w = float(0); + + if (float(0)) + { + poiMods.audioLink.x *= (sin(_Time.w * 3.1) + 1) * .5; + poiMods.audioLink.y *= (sin(_Time.w * 3.2) + 1) * .5; + poiMods.audioLink.z *= (sin(_Time.w * 3.3) + 1) * .5; + poiMods.audioLink.w *= (sin(_Time.w * 3) + 1) * .5; + } + poiMods.audioLinkTextureExists = 1; + } + + + if(float(0)) + { + poiMods.audioLinkTexture = UNITY_SAMPLE_TEX2D(_AudioTexture, poiMesh.uv[0]); + } + #endif +} + +#endif diff --git a/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_PoiAudioLink.cginc.meta b/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_PoiAudioLink.cginc.meta new file mode 100644 index 00000000..9e775121 --- /dev/null +++ b/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_PoiAudioLink.cginc.meta @@ -0,0 +1,9 @@ +fileFormatVersion: 2 +guid: c46d0b587713bf849b5402a30f07a635 +ShaderImporter: + externalObjects: {} + defaultTextures: [] + nonModifiableTextures: [] + userData: + assetBundleName: + assetBundleVariant: diff --git a/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_PoiBRDF.cginc b/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_PoiBRDF.cginc new file mode 100644 index 00000000..1c2aacd3 --- /dev/null +++ b/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_PoiBRDF.cginc @@ -0,0 +1,253 @@ +#ifndef POI_BRDF + #define POI_BRDF + + /* + * MIT License + * + * Copyright (c) 2020 Xiexe + * + * 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. + */ + + #if defined(PROP_BRDFMETALLICGLOSSMAP) || !defined(OPTIMIZER_ENABLED) + POI_TEXTURE_NOSAMPLER(_BRDFMetallicGlossMap); + #endif + #if defined(PROP_BRDFSPECULARMAP) || !defined(OPTIMIZER_ENABLED) + POI_TEXTURE_NOSAMPLER(_BRDFSpecularMap); + #endif + #if defined(PROP_BRDFMETALLICMAP) || !defined(OPTIMIZER_ENABLED) + POI_TEXTURE_NOSAMPLER(_BRDFMetallicMap); + #endif + + samplerCUBE _BRDFFallback; + + float _BRDFMetallic; + float _BRDFGlossiness; + float _BRDFReflectance; + float _BRDFAnisotropy; + float _BRDFReflectionsEnabled; + float _BRDFSpecularEnabled; + float _BRDFInvertGlossiness; + float _BRDFForceFallback; + + bool DoesReflectionProbeExist() + { + float4 envSample = UNITY_SAMPLE_TEXCUBE_LOD(unity_SpecCube0, poiCam.reflectionDir, UNITY_SPECCUBE_LOD_STEPS); + bool probeExists = !(unity_SpecCube0_HDR.a == 0 && envSample.a == 0); + return probeExists && !float(0); + } + + float getGeometricSpecularAA(float3 normal) + { + float3 vNormalWsDdx = ddx(normal.xyz); + float3 vNormalWsDdy = ddy(normal.xyz); + float flGeometricRoughnessFactor = pow(saturate(max(dot(vNormalWsDdx.xyz, vNormalWsDdx.xyz), dot(vNormalWsDdy.xyz, vNormalWsDdy.xyz))), 0.333); + return max(0, flGeometricRoughnessFactor); + } + + float3 getAnisotropicReflectionVector(float3 viewDir, float3 bitangent, float3 tangent, float3 normal, float roughness, float anisotropy) + { + float3 anisotropicDirection = anisotropy >= 0.0 ? bitangent: tangent; + float3 anisotropicTangent = cross(anisotropicDirection, viewDir); + float3 anisotropicNormal = cross(anisotropicTangent, anisotropicDirection); + float bendFactor = abs(anisotropy) * saturate(5.0 * roughness); + float3 bentNormal = normalize(lerp(normal, anisotropicNormal, bendFactor)); + return reflect(-viewDir, bentNormal); + } + + float3 F_Schlick(float u, float3 f0) + { + return f0 + (1.0 - f0) * pow(1.0 - u, 5.0); + } + + float3 F_Schlick(const float3 f0, float f90, float VoH) + { + // Schlick 1994, "An Inexpensive BRDF Model for Physically-Based Rendering" + float pow5 = 1.0 - VoH; + pow5 = pow5 * pow5 * pow5 * pow5 * pow5; + return f0 + (f90 - f0) * pow5; + } + + float D_GGX(float NoH, float roughness) + { + float a2 = roughness * roughness; + float f = (NoH * a2 - NoH) * NoH + 1.0; + return a2 / (UNITY_PI * f * f); + } + + float V_SmithGGXCorrelated(float NoV, float NoL, float a) + { + float a2 = a * a; + float GGXL = NoV * sqrt((-NoL * a2 + NoL) * NoL + a2); + float GGXV = NoL * sqrt((-NoV * a2 + NoV) * NoV + a2); + return 0.5 / (GGXV + GGXL); + } + + float D_GGX_Anisotropic(float NoH, const float3 h, const float3 t, const float3 b, float at, float ab) + { + float ToH = dot(t, h); + float BoH = dot(b, h); + float a2 = at * ab; + float3 v = float3(ab * ToH, at * BoH, a2 * NoH); + float v2 = dot(v, v); + float w2 = a2 / v2; + return a2 * w2 * w2 * (1.0 / UNITY_PI); + } + + float3 getBoxProjection(float3 direction, float3 position, float4 cubemapPosition, float3 boxMin, float3 boxMax) + { + // #if defined(UNITY_SPECCUBE_BOX_PROJECTION) // For some reason this doesn't work? + if (cubemapPosition.w > 0) + { + float3 factors = ((direction > 0 ? boxMax: boxMin) - position) / direction; + float scalar = min(min(factors.x, factors.y), factors.z); + direction = direction * scalar + (position - cubemapPosition.xyz); + } + // #endif + return direction; + } + + float3 getDirectSpecular(float roughness, float ndh, float vdn, float ndl, float ldh, float3 f0, float3 halfVector, float3 tangent, float3 bitangent, float anisotropy) + { + #if !defined(LIGHTMAP_ON) + float rough = max(roughness * roughness, 0.0045); + float Dn = D_GGX(ndh, rough); + float3 F = F_Schlick(ldh, f0); + float V = V_SmithGGXCorrelated(vdn, ndl, rough); + float3 directSpecularNonAniso = max(0, (Dn * V) * F); + + anisotropy *= saturate(5.0 * roughness); + float at = max(rough * (1.0 + anisotropy), 0.001); + float ab = max(rough * (1.0 - anisotropy), 0.001); + float D = D_GGX_Anisotropic(ndh, halfVector, tangent, bitangent, at, ab); + float3 directSpecularAniso = max(0, (D * V) * F); + + return lerp(directSpecularNonAniso, directSpecularAniso, saturate(abs(float(0) * 100))) * 3; // * 100 to prevent blending, blend because otherwise tangents are fucked on lightmapped object + #else + return 0; + #endif + } + + float3 getIndirectSpecular(float metallic, float roughness, float3 reflDir, float3 worldPos, float3 lightmap, float3 normal) + { + float3 spec = float3(0, 0, 0); + #if defined(UNITY_PASS_FORWARDBASE) + float3 indirectSpecular; + Unity_GlossyEnvironmentData envData; + envData.roughness = roughness; + envData.reflUVW = getBoxProjection( + reflDir, worldPos, + unity_SpecCube0_ProbePosition, + unity_SpecCube0_BoxMin.xyz, unity_SpecCube0_BoxMax.xyz + ); + float3 probe0 = Unity_GlossyEnvironment(UNITY_PASS_TEXCUBE(unity_SpecCube0), unity_SpecCube0_HDR, envData); + float interpolator = unity_SpecCube0_BoxMin.w; + + if (interpolator < 0.99999) + { + envData.reflUVW = getBoxProjection( + reflDir, worldPos, + unity_SpecCube1_ProbePosition, + unity_SpecCube1_BoxMin.xyz, unity_SpecCube1_BoxMax.xyz + ); + float3 probe1 = Unity_GlossyEnvironment(UNITY_PASS_TEXCUBE_SAMPLER(unity_SpecCube1, unity_SpecCube0), unity_SpecCube0_HDR, envData); + indirectSpecular = lerp(probe1, probe0, interpolator); + } + else + { + indirectSpecular = probe0; + } + + if(!DoesReflectionProbeExist()) + { + indirectSpecular = texCUBElod(_BRDFFallback, float4(envData.reflUVW, roughness * UNITY_SPECCUBE_LOD_STEPS)).rgb * poiLight.finalLighting; + } + + float horizon = min(1 + dot(reflDir, normal), 1); + indirectSpecular *= horizon * horizon; + + spec = indirectSpecular; + #if defined(LIGHTMAP_ON) + float specMultiplier = max(0, lerp(1, pow(length(lightmap), float(0.2)), float(0))); + spec *= specMultiplier; + #endif + #endif + return spec; + } + + void poiBRDF(inout float4 finalColor, const float4 finalColorBeforeLighting) + { + float4 ret = float4(1, 0, 0, 1); + #if defined(PROP_BRDFMETALLICGLOSSMAP) || !defined(OPTIMIZER_ENABLED) + float4 metallicGlossMap = POI2D_SAMPLER_PAN(_BRDFMetallicGlossMap, _MainTex, poiMesh.uv[float(0)], float4(0,0,0,0)); + #else + float4 metallicGlossMap = 1; + #endif + #if defined(PROP_BRDFSPECULARMAP) || !defined(OPTIMIZER_ENABLED) + float4 spcularTintMask = POI2D_SAMPLER_PAN(_BRDFSpecularMap, _MainTex, poiMesh.uv[float(0)], float4(0,0,0,0)); + #else + float4 spcularTintMask = 1; + #endif + #if defined(PROP_BRDFMETALLICMAP) || !defined(OPTIMIZER_ENABLED) + float4 metallicTintMask = POI2D_SAMPLER_PAN(_BRDFMetallicMap, _MainTex, poiMesh.uv[float(0)], float4(0,0,0,0)); + #else + float4 metallicTintMask = 1; + #endif + + if(float(0) == 1) + { + metallicGlossMap.a = 1 - metallicGlossMap.a; + } + + float metallic = metallicGlossMap.r * float(0); + float reflectance = metallicGlossMap.g * float(0.5); + float roughness = max(1 - (float(0) * metallicGlossMap.a), getGeometricSpecularAA(poiMesh.normals[1])); + finalColor.rgb *= lerp(1, 1 - metallic, float(1)); + + float3 reflViewDir = getAnisotropicReflectionVector(poiCam.viewDir, poiMesh.binormal, poiMesh.tangent.xyz, poiMesh.normals[1], roughness, float(0)); + float3 reflLightDir = reflect(poiLight.direction, poiMesh.normals[1]); + + #if defined(FORWARD_BASE_PASS) || defined(POI_META_PASS) + float attenuation = poiMax(poiLight.rampedLightMap); + #endif + #ifdef FORWARD_ADD_PASS + float attenuation = saturate(poiLight.nDotL); + #endif + + + float3 f0 = 0.16 * reflectance * reflectance * (1.0 - metallic) + finalColorBeforeLighting.rgb * metallic; + float3 fresnel = lerp(F_Schlick(poiLight.nDotV, f0), f0, metallic); //Kill fresnel on metallics, it looks bad. + float3 directSpecular = getDirectSpecular(roughness, saturate(poiLight.nDotH), max(poiLight.nDotV, 0.000001), attenuation, saturate(poiLight.lDotH), f0, poiLight.halfDir, poiMesh.tangent.xyz, poiMesh.binormal, float(0)) * poiLight.attenuation * attenuation * poiLight.color; + directSpecular = min(directSpecular, poiLight.color); + + float3 vDirectSpecular = 0; + #ifdef VERTEXLIGHT_ON + for (int index = 0; index < 4; index ++) + { + float3 v0directSpecular = getDirectSpecular(roughness, saturate(poiLight.vDotNH[index]), max(poiLight.nDotV, 0.000001), attenuation, saturate(poiLight.lDotH), f0, poiLight.vHalfDir[index], poiMesh.tangent, poiMesh.binormal, float(0)) * poiLight.attenuation * poiLight.vAttenuationDotNL[index] * poiLight.vColor[index]; + vDirectSpecular += min(v0directSpecular, poiLight.vColor[index]); + } + #endif + + float3 indirectSpecular = getIndirectSpecular(metallic, roughness, reflViewDir, poiMesh.worldPos, /*directDiffuse*/ finalColor.rgb, poiMesh.normals[1]) * lerp(fresnel, f0, roughness); + float3 specular = indirectSpecular * float(1) * metallicTintMask.a * metallicTintMask.rgb * poiLight.occlusion + (directSpecular + vDirectSpecular) * float(1) * spcularTintMask.a * spcularTintMask.rgb; + finalColor.rgb += specular; + } + +#endif diff --git a/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_PoiBRDF.cginc.meta b/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_PoiBRDF.cginc.meta new file mode 100644 index 00000000..403cdaae --- /dev/null +++ b/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_PoiBRDF.cginc.meta @@ -0,0 +1,9 @@ +fileFormatVersion: 2 +guid: 59b0b1e13669e624982a18ea3e4ad7ed +ShaderImporter: + externalObjects: {} + defaultTextures: [] + nonModifiableTextures: [] + userData: + assetBundleName: + assetBundleVariant: diff --git a/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_PoiBackFace.cginc b/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_PoiBackFace.cginc new file mode 100644 index 00000000..f08beb28 --- /dev/null +++ b/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_PoiBackFace.cginc @@ -0,0 +1,37 @@ +#ifndef POI_BACKFACE + #define POI_BACKFACE + + float _BackFaceEnabled; + float _BackFaceTextureUV; + float _BackFaceDetailIntensity; + float _BackFaceEmissionStrength; + float2 _BackFacePanning; + float _BackFaceHueShift; + float4 _BackFaceColor; + + #if defined(PROP_BACKFACETEXTURE) || !defined(OPTIMIZER_ENABLED) + UNITY_DECLARE_TEX2D_NOSAMPLER(_BackFaceTexture); float4 _BackFaceTexture_ST; + #endif + + float3 BackFaceColor; + void applyBackFaceTexture(inout float backFaceDetailIntensity, inout float mixedHueShift, inout float4 albedo, inout float3 backFaceEmission) + { + backFaceEmission = 0; + BackFaceColor = 0; + + if (float(0)) + { + if(!poiMesh.isFrontFace) + { + #if defined(PROP_BACKFACETEXTURE) || !defined(OPTIMIZER_ENABLED) + albedo = POI2D_SAMPLER_PAN(_BackFaceTexture, _MainTex, poiMesh.uv[float(0)], float4(0,0,0,0)) * float4(1,1,1,1); + #endif + backFaceDetailIntensity = float(1); + BackFaceColor = albedo.rgb; + mixedHueShift = float(0); + backFaceEmission = BackFaceColor * float(0); + } + } + } + +#endif diff --git a/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_PoiBackFace.cginc.meta b/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_PoiBackFace.cginc.meta new file mode 100644 index 00000000..9a733e87 --- /dev/null +++ b/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_PoiBackFace.cginc.meta @@ -0,0 +1,9 @@ +fileFormatVersion: 2 +guid: 5979a19b81d03aa4aa4753282df8f6da +ShaderImporter: + externalObjects: {} + defaultTextures: [] + nonModifiableTextures: [] + userData: + assetBundleName: + assetBundleVariant: diff --git a/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_PoiBlackLight.cginc b/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_PoiBlackLight.cginc new file mode 100644 index 00000000..8948e973 --- /dev/null +++ b/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_PoiBlackLight.cginc @@ -0,0 +1,56 @@ +#ifndef POI_BLACKLIGHT + #define POI_BLACKLIGHT + + float4 _BlackLightMaskStart; + float4 _BlackLightMaskEnd; + float4 _BlackLightMaskKeys; + float _BlackLightMaskDebug; + float _BlackLightMaskDissolve; + float _BlackLightAdjustDissolve; + float _BlackLightMaskMetallic; + float _BlackLightMaskClearCoat; + float _BlackLightMaskMatcap; + float _BlackLightMaskMatcap2; + float _BlackLightMaskEmission; + float _BlackLightMaskEmission2; + float _BlackLightMaskFlipbook; + float _BlackLightMaskPanosphere; + float _BlackLightMaskIridescence; + float _BlackLightMove; + + half _BlackLightMaskGlitter; + + half4 blackLightMask; + + void createBlackLightMask() + { + blackLightMask = 0; + #ifdef VERTEXLIGHT_ON + + for (int lightIndex = 0; lightIndex < 4; lightIndex ++) + { + float3 lightPos = float3(unity_4LightPosX0[lightIndex], unity_4LightPosY0[lightIndex], unity_4LightPosZ0[lightIndex]); + if (!distance(unity_LightColor[lightIndex].rgb, float3(0, 0, 0))) + { + for (int maskIndex = 0; maskIndex < 4; maskIndex ++) + { + float4 comparison = float4(2,3,4,5); + if(unity_LightColor[lightIndex].a == comparison[maskIndex]) + { + blackLightMask[maskIndex] = max(blackLightMask[maskIndex], smoothstep(float4(1,1,1,1)[maskIndex], float4(0,0,0,0)[maskIndex], distance(poiMesh.worldPos, lightPos))); + } + } + } + } + #endif + } +#endif + +/* +#ifdef POI_BLACKLIGHT + if (float(4) != 4) + { + blackLightMask[mask]; + } +#endif +*/ diff --git a/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_PoiBlackLight.cginc.meta b/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_PoiBlackLight.cginc.meta new file mode 100644 index 00000000..d333d701 --- /dev/null +++ b/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_PoiBlackLight.cginc.meta @@ -0,0 +1,9 @@ +fileFormatVersion: 2 +guid: 0a998dc7dfd14c1408c3eb2e478d8320 +ShaderImporter: + externalObjects: {} + defaultTextures: [] + nonModifiableTextures: [] + userData: + assetBundleName: + assetBundleVariant: diff --git a/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_PoiBlending.cginc b/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_PoiBlending.cginc new file mode 100644 index 00000000..da2630db --- /dev/null +++ b/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_PoiBlending.cginc @@ -0,0 +1,386 @@ +#ifndef POI_BLENDING + #define POI_BLENDING + + /* + 0: Zero float4(0.0, 0.0, 0.0, 0.0), + 1: One float4(1.0, 1.0, 1.0, 1.0), + 2: DstColor destinationColor, + 3: SrcColor sourceColor, + 4: OneMinusDstColor float4(1.0, 1.0, 1.0, 1.0) - destinationColor, + 5: SrcAlpha sourceColor.aaaa, + 6: OneMinusSrcColor float4(1.0, 1.0, 1.0, 1.0) - sourceColor, + 7: DstAlpha destinationColor.aaaa, + 8: OneMinusDstAlpha float4(1.0, 1.0, 1.0, 1.0) - destinationColor., + 9: SrcAlphaSaturate saturate(sourceColor.aaaa), + 10: OneMinusSrcAlpha float4(1.0, 1.0, 1.0, 1.0) - sourceColor.aaaa, + */ + + float4 poiBlend(const float sourceFactor, const float4 sourceColor, const float destinationFactor, const float4 destinationColor, const float4 blendFactor) + { + float4 sA = 1 - blendFactor; + const float4 blendData[11] = { + float4(0.0, 0.0, 0.0, 0.0), + float4(1.0, 1.0, 1.0, 1.0), + destinationColor, + sourceColor, + float4(1.0, 1.0, 1.0, 1.0) - destinationColor, + sA, + float4(1.0, 1.0, 1.0, 1.0) - sourceColor, + sA, + float4(1.0, 1.0, 1.0, 1.0) - sA, + saturate(sourceColor.aaaa), + 1 - sA, + }; + + return lerp(blendData[sourceFactor] * sourceColor + blendData[destinationFactor] * destinationColor, sourceColor, sA); + } + + // Average + float3 blendAverage(float3 base, float3 blend) + { + return(base + blend) / 2.0; + } + + // Color burn + float blendColorBurn(float base, float blend) + { + return(blend == 0.0)?blend: max((1.0 - ((1.0 - base) / blend)), 0.0); + } + + float3 blendColorBurn(float3 base, float3 blend) + { + return float3(blendColorBurn(base.r, blend.r), blendColorBurn(base.g, blend.g), blendColorBurn(base.b, blend.b)); + } + + // Color Dodge + float blendColorDodge(float base, float blend) + { + return(blend == 1.0)?blend: min(base / (1.0 - blend), 1.0); + } + + float3 blendColorDodge(float3 base, float3 blend) + { + return float3(blendColorDodge(base.r, blend.r), blendColorDodge(base.g, blend.g), blendColorDodge(base.b, blend.b)); + } + + // Darken + float blendDarken(float base, float blend) + { + return min(blend, base); + } + + float3 blendDarken(float3 base, float3 blend) + { + return float3(blendDarken(base.r, blend.r), blendDarken(base.g, blend.g), blendDarken(base.b, blend.b)); + } + + // Exclusion + float3 blendExclusion(float3 base, float3 blend) + { + return base + blend - 2.0 * base * blend; + } + + // Reflect + float blendReflect(float base, float blend) + { + return(blend == 1.0)?blend: min(base * base / (1.0 - blend), 1.0); + } + + float3 blendReflect(float3 base, float3 blend) + { + return float3(blendReflect(base.r, blend.r), blendReflect(base.g, blend.g), blendReflect(base.b, blend.b)); + } + + // Glow + float3 blendGlow(float3 base, float3 blend) + { + return blendReflect(blend, base); + } + + // Overlay + float blendOverlay(float base, float blend) + { + return base < 0.5?(2.0 * base * blend): (1.0 - 2.0 * (1.0 - base) * (1.0 - blend)); + } + + float3 blendOverlay(float3 base, float3 blend) + { + return float3(blendOverlay(base.r, blend.r), blendOverlay(base.g, blend.g), blendOverlay(base.b, blend.b)); + } + + // Hard Light + float3 blendHardLight(float3 base, float3 blend) + { + return blendOverlay(blend, base); + } + + // Vivid light + float blendVividLight(float base, float blend) + { + return(blend < 0.5)?blendColorBurn(base, (2.0 * blend)): blendColorDodge(base, (2.0 * (blend - 0.5))); + } + + float3 blendVividLight(float3 base, float3 blend) + { + return float3(blendVividLight(base.r, blend.r), blendVividLight(base.g, blend.g), blendVividLight(base.b, blend.b)); + } + + // Hard mix + float blendHardMix(float base, float blend) + { + return(blendVividLight(base, blend) < 0.5)?0.0: 1.0; + } + + float3 blendHardMix(float3 base, float3 blend) + { + return float3(blendHardMix(base.r, blend.r), blendHardMix(base.g, blend.g), blendHardMix(base.b, blend.b)); + } + + // Lighten + float blendLighten(float base, float blend) + { + return max(blend, base); + } + + float3 blendLighten(float3 base, float3 blend) + { + return float3(blendLighten(base.r, blend.r), blendLighten(base.g, blend.g), blendLighten(base.b, blend.b)); + } + + // Linear Burn + float blendLinearBurn(float base, float blend) + { + // Note : Same implementation as BlendSubtractf + return max(base + blend - 1.0, 0.0); + } + + float3 blendLinearBurn(float3 base, float3 blend) + { + // Note : Same implementation as BlendSubtract + return max(base + blend - float3(1.0, 1.0, 1.0), float3(0.0, 0.0, 0.0)); + } + + // Linear Dodge + float blendLinearDodge(float base, float blend) + { + // Note : Same implementation as BlendAddf + return min(base + blend, 1.0); + } + + float3 blendLinearDodge(float3 base, float3 blend) + { + // Note : Same implementation as BlendAdd + return min(base + blend, float3(1.0, 1.0, 1.0)); + } + + // Linear light + float blendLinearLight(float base, float blend) + { + return blend < 0.5?blendLinearBurn(base, (2.0 * blend)): blendLinearDodge(base, (2.0 * (blend - 0.5))); + } + + float3 blendLinearLight(float3 base, float3 blend) + { + return float3(blendLinearLight(base.r, blend.r), blendLinearLight(base.g, blend.g), blendLinearLight(base.b, blend.b)); + } + + // Multiply + float3 blendMultiply(float3 base, float3 blend) + { + return base * blend; + } + + // Negation + float3 blendNegation(float3 base, float3 blend) + { + return float3(1.0, 1.0, 1.0) - abs(float3(1.0, 1.0, 1.0) - base - blend); + } + + // Normal + float3 blendNormal(float3 base, float3 blend) + { + return blend; + } + + // Phoenix + float3 blendPhoenix(float3 base, float3 blend) + { + return min(base, blend) - max(base, blend) + float3(1.0, 1.0, 1.0); + } + + // Pin light + float blendPinLight(float base, float blend) + { + return(blend < 0.5)?blendDarken(base, (2.0 * blend)): blendLighten(base, (2.0 * (blend - 0.5))); + } + + float3 blendPinLight(float3 base, float3 blend) + { + return float3(blendPinLight(base.r, blend.r), blendPinLight(base.g, blend.g), blendPinLight(base.b, blend.b)); + } + + // Screen + float blendScreen(float base, float blend) + { + return 1.0 - ((1.0 - base) * (1.0 - blend)); + } + + float3 blendScreen(float3 base, float3 blend) + { + return float3(blendScreen(base.r, blend.r), blendScreen(base.g, blend.g), blendScreen(base.b, blend.b)); + } + + // Soft Light + float blendSoftLight(float base, float blend) + { + return(blend < 0.5)?(2.0 * base * blend + base * base * (1.0 - 2.0 * blend)): (sqrt(base) * (2.0 * blend - 1.0) + 2.0 * base * (1.0 - blend)); + } + + float3 blendSoftLight(float3 base, float3 blend) + { + return float3(blendSoftLight(base.r, blend.r), blendSoftLight(base.g, blend.g), blendSoftLight(base.b, blend.b)); + } + + // Subtract + float blendSubtract(float base, float blend) + { + return max(base - blend, 0.0); + } + + float3 blendSubtract(float3 base, float3 blend) + { + return max(base - blend, 0.0); + } + + // Difference + float blendDifference(float base, float blend) + { + return abs(base - blend); + } + + float3 blendDifference(float3 base, float3 blend) + { + return abs(base - blend); + } + + // Divide + float blendDivide(float base, float blend) + { + return base / max(blend, 0.0001); + } + + float3 blendDivide(float3 base, float3 blend) + { + return base / max(blend, 0.0001); + } + + float3 customBlend(float3 base, float3 blend, float blendType) + { + float3 ret = 0; + switch(blendType) + { + case 0: + { + ret = blendNormal(base, blend); + break; + } + case 1: + { + ret = blendDarken(base, blend); + break; + } + case 2: + { + ret = blendMultiply(base, blend); + break; + } + case 3: + { + ret = blendColorBurn(base, blend); + break; + } + case 4: + { + ret = blendLinearBurn(base, blend); + break; + } + case 5: + { + ret = blendLighten(base, blend); + break; + } + case 6: + { + ret = blendScreen(base, blend); + break; + } + case 7: + { + ret = blendColorDodge(base, blend); + break; + } + case 8: + { + ret = blendLinearDodge(base, blend); + break; + } + case 9: + { + ret = blendOverlay(base, blend); + break; + } + case 10: + { + ret = blendSoftLight(base, blend); + break; + } + case 11: + { + ret = blendHardLight(base, blend); + break; + } + case 12: + { + ret = blendVividLight(base, blend); + break; + } + case 13: + { + ret = blendLinearLight(base, blend); + break; + } + case 14: + { + ret = blendPinLight(base, blend); + break; + } + case 15: + { + ret = blendHardMix(base, blend); + break; + } + case 16: + { + ret = blendDifference(base, blend); + break; + } + case 17: + { + ret = blendExclusion(base, blend); + break; + } + case 18: + { + ret = blendSubtract(base, blend); + break; + } + case 19: + { + ret = blendDivide(base, blend); + break; + } + } + return ret; + } +#endif + diff --git a/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_PoiBlending.cginc.meta b/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_PoiBlending.cginc.meta new file mode 100644 index 00000000..10c757b7 --- /dev/null +++ b/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_PoiBlending.cginc.meta @@ -0,0 +1,9 @@ +fileFormatVersion: 2 +guid: d388a3878697cb646b325695dfc814b7 +ShaderImporter: + externalObjects: {} + defaultTextures: [] + nonModifiableTextures: [] + userData: + assetBundleName: + assetBundleVariant: diff --git a/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_PoiBulge.cginc b/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_PoiBulge.cginc new file mode 100644 index 00000000..9162579c --- /dev/null +++ b/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_PoiBulge.cginc @@ -0,0 +1,41 @@ +#ifndef POI_BULGE + #define POI_BULGE + + float _BuldgeFadeLength; + float _BuldgeHeight; + + #if defined(PROP_BULGEMASK) || !defined(OPTIMIZER_ENABLED) + sampler2D _BulgeMask; + #endif + + void bulgyWolgy(inout v2f o) + { + float depth = DecodeFloatRG(tex2Dlod(_CameraDepthTexture, float4(o.grabPos.xy / o.grabPos.w, 0, 0))); + #if defined(PROP_BULGEMASK) || !defined(OPTIMIZER_ENABLED) + float bulgeMask = tex2Dlod(_BulgeMask, float4(o.uv0.xy, 0, 0)); + #else + float bulgeMask = 1.0; + #endif + + depth = Linear01Depth(depth); + + float intersect = 0; + if (depth != 1) + { + float diff = distance(depth, Linear01Depth(o.pos.z / o.pos.w)); + if(diff > 0) + { + intersect = 1 - smoothstep(0, _ProjectionParams.w * float(0.02), diff); + } + } + float4 offset = intersect * float(0.02) * float4(o.normal, 0); + + offset = IsInMirror() ? 0: offset; + offset *= bulgeMask; + + o.worldPos = mul(unity_ObjectToWorld, o.localPos) + offset; + o.localPos = mul(unity_WorldToObject, o.worldPos); + o.pos = UnityObjectToClipPos(o.localPos); + } + +#endif diff --git a/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_PoiBulge.cginc.meta b/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_PoiBulge.cginc.meta new file mode 100644 index 00000000..ce347810 --- /dev/null +++ b/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_PoiBulge.cginc.meta @@ -0,0 +1,9 @@ +fileFormatVersion: 2 +guid: 7d2e5be9034d13a49a5b6599b30a61d0 +ShaderImporter: + externalObjects: {} + defaultTextures: [] + nonModifiableTextures: [] + userData: + assetBundleName: + assetBundleVariant: diff --git a/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_PoiClearCoat.cginc b/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_PoiClearCoat.cginc new file mode 100644 index 00000000..ce1084bd --- /dev/null +++ b/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_PoiClearCoat.cginc @@ -0,0 +1,327 @@ +#ifndef POI_CLEARCOAT + #define POI_CLEARCOAT + + float _Clearcoat; + float _ClearcoatGlossiness; + float _ClearcoatAnisotropy; + float _ClearcoatForceFallback; + float _ClearcoatEnableReflections; + float _ClearcoatEnableSpecular; + float _ClearcoatInvertSmoothness; + #if defined(PROP_CLEARCOATMAP) || !defined(OPTIMIZER_ENABLED) + POI_TEXTURE_NOSAMPLER(_ClearcoatMap); + #endif + + samplerCUBE _ClearcoatFallback; + /* + samplerCUBE _ClearCoatCubeMap; + float _ClearCoatSampleWorld; + float _ClearcoatInvertSmoothness; + float _Clearcoat; + float3 _ClearCoatTint; + float _ClearCoatNormalToUse; + float _ClearCoatForceLighting; + float lighty_clear_boy_uwu_var; + + #if defined(PROP_CLEARCOATSMOOTHNESSMAP) || !defined(OPTIMIZER_ENABLED) + POI_TEXTURE_NOSAMPLER(_ClearCoatSmoothnessMap); + #endif + + float3 CalculateClearCoatEnvironmentalReflections() + { + float3 reflectionColor; + + #if defined(PROP_CLEARCOATSMOOTHNESSMAP) || !defined(OPTIMIZER_ENABLED) + float smoothnessMap = (POI2D_SAMPLER_PAN(_ClearCoatSmoothnessMap, _MainTex, poiMesh.uv[_ClearCoatSmoothnessMapUV], _ClearCoatSmoothnessMapPan)); + #else + float smoothnessMap = 1.0; + #endif + + if (float(0) == 1) + { + smoothnessMap = 1 - smoothnessMap; + } + smoothnessMap *= _ClearCoatSmoothness; + float roughness = 1 - smoothnessMap; + + lighty_clear_boy_uwu_var = 0; + + float3 reflectedDir = _ClearCoatNormalToUse == 0 ? poiCam.vertexReflectionDir: poiCam.reflectionDir; + + float4 envSample = UNITY_SAMPLE_TEXCUBE_LOD(unity_SpecCube0, reflectedDir, roughness * UNITY_SPECCUBE_LOD_STEPS); + bool no_probe = unity_SpecCube0_HDR.a == 0 && envSample.a == 0; + + + if(_ClearCoatSampleWorld == 0 && no_probe == 0) + { + + Unity_GlossyEnvironmentData envData; + envData.roughness = roughness; + envData.reflUVW = BoxProjection( + reflectedDir, poiMesh.worldPos.xyz, + unity_SpecCube0_ProbePosition, + unity_SpecCube0_BoxMin, unity_SpecCube0_BoxMax + ); + float3 probe0 = Unity_GlossyEnvironment( + UNITY_PASS_TEXCUBE(unity_SpecCube0), unity_SpecCube0_HDR, envData + ); + envData.reflUVW = BoxProjection( + reflectedDir, poiMesh.worldPos.xyz, + unity_SpecCube1_ProbePosition, + unity_SpecCube1_BoxMin, unity_SpecCube1_BoxMax + ); + + float interpolator = unity_SpecCube0_BoxMin.w; + + if(interpolator < 0.99999) + { + float3 probe1 = Unity_GlossyEnvironment( + UNITY_PASS_TEXCUBE_SAMPLER(unity_SpecCube1, unity_SpecCube0), + unity_SpecCube0_HDR, envData + ); + reflectionColor = lerp(probe1, probe0, interpolator); + } + else + { + reflectionColor = probe0; + } + } + else + { + lighty_clear_boy_uwu_var = 1; + reflectionColor = texCUBElod(_ClearCoatCubeMap, float4(reflectedDir, roughness * UNITY_SPECCUBE_LOD_STEPS)); + } + + if(_ClearCoatForceLighting) + { + lighty_clear_boy_uwu_var = 1; + } + + return reflectionColor * _ClearCoatTint; + } + + void calculateAndApplyClearCoat(inout float4 finalColor) + { + #if defined(PROP_CLEARCOATMASK) || !defined(OPTIMIZER_ENABLED) + half clearCoatMap = POI2D_SAMPLER_PAN(_ClearcoatMap, _MainTex, poiMesh.uv[_ClearCoatMaskUV], _ClearCoatMaskPan); + #else + half clearCoatMap = 1; + #endif + + #ifdef POI_BLACKLIGHT + if(float(4) != 4) + { + clearCoatMap *= blackLightMask[float(4)]; + } + #endif + + half3 reflectionColor = CalculateClearCoatEnvironmentalReflections(); + + float NormalDotView = abs(dot(float(1), _ClearCoatNormalToUse == 0 ? poiLight.N0DotV: poiLight.nDotV).r); + #ifdef POI_LIGHTING + finalColor.rgb = lerp(finalColor.rgb, reflectionColor * lerp(1, poiLight.finalLighting, lighty_clear_boy_uwu_var), clearCoatMap * float(1) * clamp(FresnelTerm(float(1), NormalDotView), 0, 1)); + //finalColor.rgb += reflectionColor; + //finalColor.rgb = finalColor.rgb * (1- (reflectionColor.r + reflectionColor.g + reflectionColor.b)/3) + reflectionColor * clearCoatMap * lerp(1, poiLight.finalLighting, lighty_clear_boy_uwu_var); + #else + finalColor.rgb = lerp(finalColor.rgb, reflectionColor, clearCoatMap * float(1) * clamp(FresnelTerm(float(1), NormalDotView), 0, 1)); + #endif + } + */ + + bool clearcoatDoesReflectionProbeExist() + { + float4 envSample = UNITY_SAMPLE_TEXCUBE_LOD(unity_SpecCube0, poiCam.reflectionDir, UNITY_SPECCUBE_LOD_STEPS); + bool probeExists = !(unity_SpecCube0_HDR.a == 0 && envSample.a == 0); + return probeExists && !float(0); + } + + float3 clearcoatF_Schlick(float u, float3 f0) + { + return f0 + (1.0 - f0) * pow(1.0 - u, 5.0); + } + + float4 getClearcoatSmoothness(float4 clearcoatMap) + { + float roughness = 1 - (float(0) * clearcoatMap.a); + roughness = clamp(roughness, 0.0045, 1.0); + roughness = roughness * roughness; + + float reflectivity = float(1) * clearcoatMap.r; + return float4(reflectivity, 0, 0, roughness); + } + + float getGeometricClearCoatSpecularAA(float3 normal) + { + float3 vNormalWsDdx = ddx(normal.xyz); + float3 vNormalWsDdy = ddy(normal.xyz); + float flGeometricRoughnessFactor = pow(saturate(max(dot(vNormalWsDdx.xyz, vNormalWsDdx.xyz), dot(vNormalWsDdy.xyz, vNormalWsDdy.xyz))), 0.333); + return max(0, flGeometricRoughnessFactor); + } + + float3 getClearcoatAnisotropicReflectionVector(float3 viewDir, float3 bitangent, float3 tangent, float3 normal, float roughness, float anisotropy) + { + //_Anisotropy = lerp(-0.2, 0.2, sin(_Time.y / 20)); //This is pretty fun + float3 anisotropicDirection = anisotropy >= 0.0 ? bitangent: tangent; + float3 anisotropicTangent = cross(anisotropicDirection, viewDir); + float3 anisotropicNormal = cross(anisotropicTangent, anisotropicDirection); + float bendFactor = abs(anisotropy) * saturate(5.0 * roughness); + float3 bentNormal = normalize(lerp(normal, anisotropicNormal, bendFactor)); + return reflect(-viewDir, bentNormal); + } + + float D_GGXClearcoat(float NoH, float roughness) + { + float a2 = roughness * roughness; + float f = (NoH * a2 - NoH) * NoH + 1.0; + return a2 / (UNITY_PI * f * f); + } + + float D_GGXClearcoat_Anisotropic(float NoH, const float3 h, const float3 t, const float3 b, float at, float ab) + { + float ToH = dot(t, h); + float BoH = dot(b, h); + float a2 = at * ab; + float3 v = float3(ab * ToH, at * BoH, a2 * NoH); + float v2 = dot(v, v); + float w2 = a2 / v2; + return a2 * w2 * w2 * (1.0 / UNITY_PI); + } + + float V_SmithGGXClearcoatCorrelated(float NoV, float NoL, float a) + { + float a2 = a * a; + float GGXL = NoV * sqrt((-NoL * a2 + NoL) * NoL + a2); + float GGXV = NoL * sqrt((-NoV * a2 + NoV) * NoV + a2); + return 0.5 / (GGXV + GGXL); + } + + float3 getClearcoatDirectSpecular(float roughness, float ndh, float vdn, float ndl, float ldh, float3 f0, float3 halfVector, float3 tangent, float3 bitangent, float anisotropy) + { + #if !defined(LIGHTMAP_ON) + float rough = max(roughness * roughness, 0.0045); + float Dn = D_GGXClearcoat(ndh, rough); + float3 F = clearcoatF_Schlick(ldh, f0); + float V = V_SmithGGXClearcoatCorrelated(vdn, ndl, rough); + float3 directSpecularNonAniso = max(0, (Dn * V) * F); + + anisotropy *= saturate(5.0 * roughness); + float at = max(rough * (1.0 + anisotropy), 0.001); + float ab = max(rough * (1.0 - anisotropy), 0.001); + float D = D_GGXClearcoat_Anisotropic(ndh, halfVector, tangent, bitangent, at, ab); + float3 directSpecularAniso = max(0, (D * V) * F); + + return lerp(directSpecularNonAniso, directSpecularAniso, saturate(abs(float(0) * 100))) * 3; // * 100 to prevent blending, blend because otherwise tangents are fucked on lightmapped object + #else + return 0; + #endif + } + + float3 getClearCoatBoxProjection(float3 direction, float3 position, float4 cubemapPosition, float3 boxMin, float3 boxMax) + { + // #if defined(UNITY_SPECCUBE_BOX_PROJECTION) // For some reason this doesn't work? + if (cubemapPosition.w > 0) + { + float3 factors = ((direction > 0 ? boxMax: boxMin) - position) / direction; + float scalar = min(min(factors.x, factors.y), factors.z); + direction = direction * scalar + (position - cubemapPosition.xyz); + } + // #endif + return direction; + } + + float3 getClearcoatIndirectSpecular(float metallic, float roughness, float3 reflDir, float3 worldPos, float3 lightmap, float3 normal) + { + float3 spec = float3(0, 0, 0); + #if defined(UNITY_PASS_FORWARDBASE) + float3 indirectSpecular; + Unity_GlossyEnvironmentData envData; + envData.roughness = roughness; + envData.reflUVW = getClearCoatBoxProjection( + reflDir, worldPos, + unity_SpecCube0_ProbePosition, + unity_SpecCube0_BoxMin.xyz, unity_SpecCube0_BoxMax.xyz + ); + float3 probe0 = Unity_GlossyEnvironment(UNITY_PASS_TEXCUBE(unity_SpecCube0), unity_SpecCube0_HDR, envData); + float interpolator = unity_SpecCube0_BoxMin.w; + + if (interpolator < 0.99999) + { + envData.reflUVW = getClearCoatBoxProjection( + reflDir, worldPos, + unity_SpecCube1_ProbePosition, + unity_SpecCube1_BoxMin.xyz, unity_SpecCube1_BoxMax.xyz + ); + float3 probe1 = Unity_GlossyEnvironment(UNITY_PASS_TEXCUBE_SAMPLER(unity_SpecCube1, unity_SpecCube0), unity_SpecCube0_HDR, envData); + indirectSpecular = lerp(probe1, probe0, interpolator); + } + else + { + indirectSpecular = probe0; + } + + if(!clearcoatDoesReflectionProbeExist()) + { + indirectSpecular = texCUBElod(_ClearcoatFallback, float4(envData.reflUVW, roughness * UNITY_SPECCUBE_LOD_STEPS)).rgb * poiLight.finalLighting; + } + + float horizon = min(1 + dot(reflDir, normal), 1); + indirectSpecular *= horizon * horizon; + + spec = indirectSpecular; + #if defined(LIGHTMAP_ON) + float specMultiplier = max(0, lerp(1, pow(length(lightmap), float(0.2)), float(0))); + spec *= specMultiplier; + #endif + #endif + return spec; + } + + void calculateAndApplyClearCoat(inout float4 finalColor) + { + #if defined(PROP_CLEARCOATMAP) || !defined(OPTIMIZER_ENABLED) + float4 clearCoatMap = POI2D_SAMPLER_PAN(_ClearcoatMap, _MainTex, poiMesh.uv[float(0)], float4(0,0,0,0)); + #else + float4 clearCoatMap = 1; + #endif + + float4 clearcoatReflectivitySmoothness = getClearcoatSmoothness(clearCoatMap); + float clearcoatReflectivity = clearcoatReflectivitySmoothness.r; + float clearcoatRoughness = clearcoatReflectivitySmoothness.a; + + if(float(0)) + { + clearcoatRoughness = 1 - clearcoatRoughness; + } + float3 creflViewDir = getClearcoatAnisotropicReflectionVector(poiCam.viewDir, poiMesh.binormal, poiMesh.tangent.xyz, poiMesh.normals[0], clearcoatRoughness, float(0)); + float cndl = saturate(dot(poiLight.direction, poiMesh.normals[0])); + float cvdn = abs(dot(poiCam.viewDir, poiMesh.normals[0])); + float cndh = saturate(dot(poiMesh.normals[0], poiLight.halfDir)); + + float3 clearcoatf0 = 0.16 * clearcoatReflectivity * clearcoatReflectivity; + float3 clearcoatFresnel = clearcoatF_Schlick(cvdn, clearcoatf0); + + #if defined(FORWARD_BASE_PASS) || defined(POI_META_PASS) + float attenuation = poiLight.rampedLightMap; + #endif + #ifdef FORWARD_ADD_PASS + float attenuation = saturate(poiLight.nDotL); + #endif + + float3 vDirectSpecular = 0; + #ifdef VERTEXLIGHT_ON + for (int index = 0; index < 4; index ++) + { + float vcndh = saturate(dot(poiMesh.normals[0], poiLight.vHalfDir[index])); + float vcndl = saturate(dot(poiLight.vDirection[index], poiMesh.normals[0])); + float3 v0directSpecular = getClearcoatDirectSpecular(clearcoatRoughness, vcndh, cvdn, vcndl, saturate(poiLight.vDotLH[index]), clearcoatf0, poiLight.halfDir, poiMesh.tangent, poiMesh.binormal, float(0)) * poiLight.vAttenuation * vcndl * poiLight.vColor[index]; + vDirectSpecular += v0directSpecular; + } + #endif + + float3 clearcoatDirectSpecular = getClearcoatDirectSpecular(clearcoatRoughness, cndh, cvdn, attenuation, saturate(poiLight.lDotH), clearcoatf0, poiLight.halfDir, poiMesh.tangent, poiMesh.binormal, float(0)) * poiLight.attenuation * attenuation * poiLight.color; + float3 clearcoatIndirectSpecular = getClearcoatIndirectSpecular(0, clearcoatRoughness, creflViewDir, poiMesh.worldPos, finalColor, poiMesh.normals[0]); + float3 clearcoat = ((clearcoatDirectSpecular + vDirectSpecular) * clearCoatMap.g * float(1) + clearcoatIndirectSpecular * clearCoatMap.b * float(1)) * clearcoatReflectivity * clearcoatFresnel; + finalColor.rgb += clearcoat; + } + +#endif diff --git a/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_PoiClearCoat.cginc.meta b/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_PoiClearCoat.cginc.meta new file mode 100644 index 00000000..9bcb26fd --- /dev/null +++ b/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_PoiClearCoat.cginc.meta @@ -0,0 +1,9 @@ +fileFormatVersion: 2 +guid: c9d27593021b41741bc09410bf4594f0 +ShaderImporter: + externalObjects: {} + defaultTextures: [] + nonModifiableTextures: [] + userData: + assetBundleName: + assetBundleVariant: diff --git a/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_PoiData.cginc b/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_PoiData.cginc new file mode 100644 index 00000000..31e4dcbd --- /dev/null +++ b/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_PoiData.cginc @@ -0,0 +1,268 @@ +#ifndef POI_DATA +#define POI_DATA + +float _ParallaxBias; +float _LightingAdditiveLimitIntensity; +float _LightingAdditiveMaxIntensity; +POI_TEXTURE_NOSAMPLER(_BumpMap); +#ifdef FINALPASS + #if defined(PROP_DETAILMASK) || !defined(OPTIMIZER_ENABLED) + POI_TEXTURE_NOSAMPLER(_DetailMask); + #endif + #if defined(PROP_DETAILNORMALMAP) || !defined(OPTIMIZER_ENABLED) + POI_TEXTURE_NOSAMPLER(_DetailNormalMap); + #endif + float _DetailNormalMapScale; +#endif +float _BumpScale; + +void calculateAttenuation(v2f i) +{ + #ifdef FORWARD_ADD_PASS + #if defined(POINT) || defined(SPOT) + POI_LIGHT_ATTENUATION(attenuation, shadow, i, i.worldPos.xyz) + poiLight.additiveShadow = shadow; + #else + UNITY_LIGHT_ATTENUATION(attenuation, i, i.worldPos.xyz) + poiLight.additiveShadow == 0; + #endif + #else + UNITY_LIGHT_ATTENUATION(attenuation, i, i.worldPos.xyz) + // fix for rare bug where light atten is 0 when there is no directional light in the scene + #ifdef FORWARD_BASE_PASS + if (all(_LightColor0.rgb == 0.0)) + { + attenuation = 1.0; + } + #endif + #endif + poiLight.attenuation = attenuation; +} + +void calculateVertexLightingData(in v2f i) +{ + #ifdef VERTEXLIGHT_ON + float4 toLightX = unity_4LightPosX0 - i.worldPos.x; + float4 toLightY = unity_4LightPosY0 - i.worldPos.y; + float4 toLightZ = unity_4LightPosZ0 - i.worldPos.z; + float4 lengthSq = 0; + lengthSq += toLightX * toLightX; + lengthSq += toLightY * toLightY; + lengthSq += toLightZ * toLightZ; + + float4 lightAttenSq = unity_4LightAtten0; + float4 atten = 1.0 / (1.0 + lengthSq * lightAttenSq); + float4 vLightWeight = saturate(1 - (lengthSq * lightAttenSq / 25)); + poiLight.vAttenuation = min(atten, vLightWeight * vLightWeight); + + poiLight.vDotNL = 0; + poiLight.vDotNL += toLightX * poiMesh.normals[1].x; + poiLight.vDotNL += toLightY * poiMesh.normals[1].y; + poiLight.vDotNL += toLightZ * poiMesh.normals[1].z; + + float4 corr = rsqrt(lengthSq); + poiLight.vDotNL = max(0, poiLight.vDotNL * corr); + poiLight.vAttenuationDotNL = poiLight.vAttenuation * poiLight.vDotNL; + + for (int index = 0; index < 4; index++) + { + poiLight.vPosition[index] = float3(unity_4LightPosX0[index], unity_4LightPosY0[index], unity_4LightPosZ0[index]); + + float3 vertexToLightSource = poiLight.vPosition[index] - poiMesh.worldPos; + poiLight.vDirection[index] = normalize(vertexToLightSource); + //poiLight.vAttenuationDotNL[index] = 1.0 / (1.0 + unity_4LightAtten0[index] * poiLight.vDotNL[index]); + poiLight.vColor[index] = unity_LightColor[index].rgb; + + if (float(0) == 1) + { + float intensity = max(0.001, (0.299 * poiLight.vColor[index].r + 0.587 * poiLight.vColor[index].g + 0.114 * poiLight.vColor[index].b)); + poiLight.vColor[index] = min(poiLight.vColor[index], poiLight.vColor[index] / (intensity / float(1))); + } + poiLight.vHalfDir[index] = Unity_SafeNormalize(poiLight.vDirection[index] + poiCam.viewDir); + poiLight.vDotNL[index] = dot(poiMesh.normals[1], -poiLight.vDirection[index]); + poiLight.vCorrectedDotNL[index] = .5 * (poiLight.vDotNL[index] + 1); + poiLight.vDotLH[index] = saturate(dot(poiLight.vDirection[index], poiLight.vHalfDir[index])); + + poiLight.vDotNH[index] = saturate(dot(poiMesh.normals[1], poiLight.vHalfDir[index])); + } + #endif +} + +void calculateLightingData(in v2f i) +{ + poiLight.occlusion = 1; + #ifdef FORWARD_BASE_PASS + //poiLight.color = saturate(_LightColor0.rgb) + saturate(ShadeSH9(normalize(unity_SHAr + unity_SHAg + unity_SHAb))); + float3 magic = max(ShadeSH9(normalize(unity_SHAr + unity_SHAg + unity_SHAb)), 0); + float3 normalLight = _LightColor0.rgb; + poiLight.color = magic + normalLight; + #else + #ifdef FORWARD_ADD_PASS + poiLight.color = _LightColor0.rgb; + + + if (float(0) == 1) + { + float additiveLightIntensity = max(0.001, (0.299 * poiLight.color.r + 0.587 * poiLight.color.g + 0.114 * poiLight.color.b)); + poiLight.color = min(poiLight.color, poiLight.color / (additiveLightIntensity / float(1))); + } + #endif + #endif + + #ifdef FORWARD_BASE_PASS + poiLight.direction = normalize(_WorldSpaceLightPos0.xyz + unity_SHAr.xyz + unity_SHAg.xyz + unity_SHAb.xyz); + #else + #if defined(POINT) || defined(SPOT) + poiLight.direction = normalize(_WorldSpaceLightPos0.xyz - i.worldPos.xyz); + #else + poiLight.direction = _WorldSpaceLightPos0.xyz; + #endif + #endif + + poiLight.halfDir = normalize(poiLight.direction + poiCam.viewDir); + + #ifdef POI_VAR_DOTNH + poiLight.dotNH = saturate(dot(poiMesh.normals[1], poiLight.halfDir)); + #endif + + #ifdef POI_VAR_DOTLH + poiLight.dotLH = saturate(dot(poiLight.direction, poiLight.halfDir)); + #endif + + poiLight.nDotV = dot(poiMesh.normals[1], poiCam.viewDir); + poiLight.N0DotV = dot(poiMesh.normals[0], poiCam.viewDir); + poiLight.nDotL = dot(poiMesh.normals[1], poiLight.direction); + poiLight.nDotH = dot(poiMesh.normals[1], poiLight.halfDir); + poiLight.lDotv = dot(poiLight.direction, poiCam.viewDir); + poiLight.lDotH = dot(poiLight.direction, poiLight.halfDir); +} + +float3 CreateBinormal(float3 normal, float3 tangent, float binormalSign) +{ + return cross(normal, tangent.xyz) * (binormalSign * unity_WorldTransformParams.w); +} + +void InitializeMeshData(inout v2f i, uint facing) +{ + poiMesh.isFrontFace = facing; + poiMesh.normals[0] = normalize(i.normal); + poiMesh.binormal = CreateBinormal(i.normal, i.tangent.xyz, i.tangent.w); + poiMesh.tangent = i.tangent; + + #ifndef OUTLINE + if (!poiMesh.isFrontFace) + { + poiMesh.normals[0] *= -1; + poiMesh.tangent *= -1; + poiMesh.binormal *= -1; + } + #endif + + poiMesh.worldPos = i.worldPos.xyz; + poiMesh.localPos = i.localPos.xyz; + poiMesh.barycentricCoordinates = i.barycentricCoordinates; + poiMesh.uv[0] = i.uv0.xy; + poiMesh.uv[1] = i.uv0.zw; + poiMesh.uv[2] = i.uv1.xy; + poiMesh.uv[3] = i.uv1.zw; + + #ifdef POI_UV_DISTORTION + poiMesh.uv[4] = calculateDistortionUV(i.uv0.xy); + #else + poiMesh.uv[4] = poiMesh.uv[0]; + #endif + + poiMesh.vertexColor = i.vertexColor; + #if defined(LIGHTMAP_ON) || defined(DYNAMICLIGHTMAP_ON) + poiMesh.lightmapUV = i.lightmapUV; + #endif + poiMesh.modelPos = i.modelPos; + + #ifdef FUR + poiMesh.furAlpha = i.furAlpha; + #endif +} + +void initPoiMods() +{ + poiMods.audioLink = float4(0, 0, 0, 0); + poiMods.globalMasks = float4(0, 0, 0, 0); + #ifdef POI_AUDIOLINK + initAudioBands(); + #endif +} + +void initializeCamera(v2f i) +{ + poiCam.viewDir = normalize(_WorldSpaceCameraPos - i.worldPos.xyz); + poiCam.forwardDir = getCameraForward(); + poiCam.worldPos = _WorldSpaceCameraPos; + poiCam.distanceToModel = distance(poiMesh.modelPos, poiCam.worldPos); + poiCam.distanceToVert = distance(poiMesh.worldPos, poiCam.worldPos); + poiCam.grabPos = i.grabPos; + poiCam.screenUV = calcScreenUVs(i.grabPos); + poiCam.clipPos = i.pos; + #if defined(GRAIN) + poiCam.worldDirection = i.worldDirection; + #endif + + poiCam.tangentViewDir = normalize(i.tangentViewDir); + poiCam.decalTangentViewDir = poiCam.tangentViewDir; + poiCam.tangentViewDir.xy /= (poiCam.tangentViewDir.z + float(0.42)); +} + +void calculateTangentData() +{ + poiTData.tangentTransform = float3x3(poiMesh.tangent.xyz, poiMesh.binormal, poiMesh.normals[0]); + poiTData.tangentToWorld = transpose(float3x3(poiMesh.tangent.xyz, poiMesh.binormal, poiMesh.normals[0])); +} + +void CalculateReflectionData() +{ + #if defined(_METALLICGLOSSMAP) || defined(_COLORCOLOR_ON) + poiCam.reflectionDir = reflect(-poiCam.viewDir, poiMesh.normals[1]); + poiCam.vertexReflectionDir = reflect(-poiCam.viewDir, poiMesh.normals[0]); + #endif +} + +void calculateNormals(inout half3 detailMask) +{ + half3 mainNormal = UnpackScaleNormal(POI2D_SAMPLER_PAN(_BumpMap, _MainTex, poiMesh.uv[float(0)], float4(0,0,0,0)), float(1)); + + #ifdef FINALPASS + #if defined(PROP_DETAILMASK) || !defined(OPTIMIZER_ENABLED) + detailMask = POI2D_SAMPLER_PAN(_DetailMask, _MainTex, poiMesh.uv[float(0)], float4(0,0,0,0)).rgb; + #else + detailMask = 1; + #endif + + if (float(1) > 0) + { + #if defined(PROP_DETAILNORMALMAP) || !defined(OPTIMIZER_ENABLED) + half3 detailNormal = UnpackScaleNormal(POI2D_SAMPLER_PAN(_DetailNormalMap, _MainTex, poiMesh.uv[float(0)], float4(0,0,0,0)), float(1) * detailMask.g); + poiMesh.tangentSpaceNormal = BlendNormals(mainNormal, detailNormal); + #else + poiMesh.tangentSpaceNormal = mainNormal; + #endif + } + else + { + poiMesh.tangentSpaceNormal = mainNormal; + } + #else + poiMesh.tangentSpaceNormal = mainNormal; + #endif + + #ifdef POI_RGBMASK + calculateRGBNormals(poiMesh.tangentSpaceNormal); + #endif + + poiMesh.normals[1] = normalize( + poiMesh.tangentSpaceNormal.x * poiMesh.tangent.xyz + + poiMesh.tangentSpaceNormal.y * poiMesh.binormal + + poiMesh.tangentSpaceNormal.z * poiMesh.normals[0] + ); + + poiCam.viewDotNormal = abs(dot(poiCam.viewDir, poiMesh.normals[1])); +} +#endif diff --git a/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_PoiData.cginc.meta b/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_PoiData.cginc.meta new file mode 100644 index 00000000..04958934 --- /dev/null +++ b/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_PoiData.cginc.meta @@ -0,0 +1,9 @@ +fileFormatVersion: 2 +guid: 8f75a58afc3152548b250007753f0217 +ShaderImporter: + externalObjects: {} + defaultTextures: [] + nonModifiableTextures: [] + userData: + assetBundleName: + assetBundleVariant: diff --git a/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_PoiDebug.cginc b/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_PoiDebug.cginc new file mode 100644 index 00000000..125d2cd9 --- /dev/null +++ b/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_PoiDebug.cginc @@ -0,0 +1,107 @@ +#ifndef POI_DEBUG + #define POI_DEBUG + + float _DebugEnabled; + float _DebugMeshData; + float _DebugLightingData; + float _DebugCameraData; + + void displayDebugInfo(inout float4 finalColor) + { + + if (float(0) != 0) + { + //Mesh Data + if (float(0) == 1) + { + finalColor.rgb = poiMesh.normals[0]; + return; + } + else if(float(0) == 2) + { + finalColor.rgb = poiMesh.normals[1]; + return; + } + else if(float(0) == 3) + { + finalColor.rgb = poiMesh.tangent; + return; + } + else if(float(0) == 4) + { + finalColor.rgb = poiMesh.binormal; + return; + } + else if(float(0) == 5) + { + finalColor.rgb = poiMesh.localPos; + return; + } + + #ifdef POI_LIGHTING + if(float(0) == 1) + { + finalColor.rgb = poiLight.attenuation; + return; + } + else if(float(0) == 2) + { + finalColor.rgb = poiLight.directLighting; + return; + } + else if(float(0) == 3) + { + finalColor.rgb = poiLight.indirectLighting; + return; + } + else if(float(0) == 4) + { + finalColor.rgb = poiLight.lightMap; + return; + } + else if(float(0) == 5) + { + finalColor.rgb = poiLight.rampedLightMap; + return; + } + else if(float(0) == 6) + { + finalColor.rgb = poiLight.finalLighting; + return; + } + else if(float(0) == 7) + { + finalColor.rgb = poiLight.nDotL; + return; + } + #endif + + if(float(0) == 1) + { + finalColor.rgb = poiCam.viewDir; + return; + } + else if(float(0) == 2) + { + finalColor.rgb = poiCam.tangentViewDir; + return; + } + else if(float(0) == 3) + { + finalColor.rgb = poiCam.forwardDir; + return; + } + else if(float(0) == 4) + { + finalColor.rgb = poiCam.worldPos; + return; + } + else if(float(0) == 5) + { + finalColor.rgb = poiCam.viewDotNormal; + return; + } + } + } + +#endif diff --git a/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_PoiDebug.cginc.meta b/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_PoiDebug.cginc.meta new file mode 100644 index 00000000..a06a3257 --- /dev/null +++ b/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_PoiDebug.cginc.meta @@ -0,0 +1,9 @@ +fileFormatVersion: 2 +guid: a729b2092db4bc841aca76ef947fb6b6 +ShaderImporter: + externalObjects: {} + defaultTextures: [] + nonModifiableTextures: [] + userData: + assetBundleName: + assetBundleVariant: diff --git a/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_PoiDecal.cginc b/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_PoiDecal.cginc new file mode 100644 index 00000000..83ac70d9 --- /dev/null +++ b/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_PoiDecal.cginc @@ -0,0 +1,268 @@ +#ifndef POI_DECAL +#define POI_DECAL + + +#if defined(PROP_DECALMASK) || !defined(OPTIMIZER_ENABLED) + POI_TEXTURE_NOSAMPLER(_DecalMask); +#endif + +#if defined(PROP_DECALTEXTURE) || !defined(OPTIMIZER_ENABLED) + POI_TEXTURE_NOSAMPLER(_DecalTexture); +#else + float2 _DecalTextureUV; +#endif +float4 _DecalColor; +fixed _DecalTiled; +float _DecalBlendType; +half _DecalRotation; +half2 _DecalScale; +half2 _DecalPosition; +half _DecalRotationSpeed; +float _DecalEmissionStrength; +float _DecalBlendAlpha; +float _DecalHueShiftEnabled; +float _DecalHueShift; +float _DecalHueShiftSpeed; + +// Audio Link +half _AudioLinkDecal0ScaleBand; +float4 _AudioLinkDecal0Scale; +half _AudioLinkDecal0AlphaBand; +float2 _AudioLinkDecal0Alpha; +half _AudioLinkDecal0EmissionBand; +float2 _AudioLinkDecal0Emission; + +half _AudioLinkDecal1ScaleBand; +float4 _AudioLinkDecal1Scale; +half _AudioLinkDecal1AlphaBand; +float2 _AudioLinkDecal1Alpha; +half _AudioLinkDecal1EmissionBand; +float2 _AudioLinkDecal1Emission; + +half _AudioLinkDecal2ScaleBand; +float4 _AudioLinkDecal2Scale; +half _AudioLinkDecal2AlphaBand; +float2 _AudioLinkDecal2Alpha; +half _AudioLinkDecal2EmissionBand; +float2 _AudioLinkDecal2Emission; + +half _AudioLinkDecal3ScaleBand; +float4 _AudioLinkDecal3Scale; +half _AudioLinkDecal3AlphaBand; +float2 _AudioLinkDecal3Alpha; +half _AudioLinkDecal3EmissionBand; +float2 _AudioLinkDecal3Emission; + +#ifdef GEOM_TYPE_BRANCH_DETAIL + #if defined(PROP_DECALTEXTURE1) || !defined(OPTIMIZER_ENABLED) + POI_TEXTURE_NOSAMPLER(_DecalTexture1); + #else + float2 _DecalTexture1UV; + #endif + float4 _DecalColor1; + fixed _DecalTiled1; + float _DecalBlendType1; + half _DecalRotation1; + half2 _DecalScale1; + half2 _DecalPosition1; + half _DecalRotationSpeed1; + float _DecalEmissionStrength1; + float _DecalBlendAlpha1; + float _DecalHueShiftEnabled1; + float _DecalHueShift1; + float _DecalHueShiftSpeed1; +#endif + +#ifdef GEOM_TYPE_FROND + #if defined(PROP_DECALTEXTURE2) || !defined(OPTIMIZER_ENABLED) + POI_TEXTURE_NOSAMPLER(_DecalTexture2); + #else + float2 _DecalTexture2UV; + #endif + float4 _DecalColor2; + fixed _DecalTiled2; + float _DecalBlendType2; + half _DecalRotation2; + half2 _DecalScale2; + half2 _DecalPosition2; + half _DecalRotationSpeed2; + float _DecalEmissionStrength2; + float _DecalBlendAlpha2; + float _DecalHueShiftEnabled2; + float _DecalHueShift2; + float _DecalHueShiftSpeed2; +#endif + +#ifdef DEPTH_OF_FIELD_COC_VIEW + #if defined(PROP_DECALTEXTURE3) || !defined(OPTIMIZER_ENABLED) + POI_TEXTURE_NOSAMPLER(_DecalTexture3); + #else + float2 _DecalTexture3UV; + #endif + float4 _DecalColor3; + fixed _DecalTiled3; + float _DecalBlendType3; + half _DecalRotation3; + half2 _DecalScale3; + half2 _DecalPosition3; + half _DecalRotationSpeed3; + float _DecalEmissionStrength3; + float _DecalBlendAlpha3; + float _DecalHueShiftEnabled3; + float _DecalHueShift3; + float _DecalHueShiftSpeed3; +#endif + +// Parallax +float _Decal0Depth; +float _Decal1Depth; +float _Decal2Depth; +float _Decal3Depth; + +float2 calcParallax(float height) +{ + return((height * - 1) + 1) * (poiCam.decalTangentViewDir.xy / poiCam.decalTangentViewDir.z); +} + + +float2 decalUV(float uvNumber, float2 position, half rotation, half rotationSpeed, half2 scale, float depth) +{ + float2 uv = poiMesh.uv[uvNumber] + calcParallax(depth + 1); + float2 decalCenter = position; + float theta = radians(rotation + _Time.z * rotationSpeed); + float cs = cos(theta); + float sn = sin(theta); + uv = float2((uv.x - decalCenter.x) * cs - (uv.y - decalCenter.y) * sn + decalCenter.x, (uv.x - decalCenter.x) * sn + (uv.y - decalCenter.y) * cs + decalCenter.y); + uv = remap(uv, float2(0, 0) - scale / 2 + position, scale / 2 + position, float2(0, 0), float2(1, 1)); + return uv; +} + +inline float3 decalHueShift(float enabled, float3 color, float shift, float shiftSpeed) +{ + + if (enabled) + { + color = hueShift(color, shift + _Time.x * shiftSpeed); + } + return color; +} + +inline float applyTilingClipping(float enabled, float2 uv) +{ + float ret = 1; + + if (!enabled) + { + if (uv.x > 1 || uv.y > 1 || uv.x < 0 || uv.y < 0) + { + ret = 0; + } + } + return ret; +} + +void applyDecals(inout float4 albedo, inout float3 decalEmission) +{ + + #if defined(PROP_DECALMASK) || !defined(OPTIMIZER_ENABLED) + float4 decalMask = POI2D_SAMPLER_PAN(_DecalMask, _MainTex, poiMesh.uv[float(0)], float4(0,0,0,0)); + #else + float4 decalMask = 1; + #endif + + float4 decalColor = 1; + float2 uv = 0; + + // Decal 0 + float2 decalScale = float2(1, 1); + decalScale = float4(1,1,0,0); + #if defined(PROP_DECALTEXTURE) || !defined(OPTIMIZER_ENABLED) + #ifdef POI_AUDIOLINK + + if (poiMods.audioLinkTextureExists) + { + decalScale += lerp(float4(0,0,0,0).xy, float4(0,0,0,0).zw, poiMods.audioLink[float(0)]); + } + #endif + uv = decalUV(float(0), float4(0.5,0.5,0,0), float(0), float(0), decalScale, float(0)); + decalColor = POI2D_SAMPLER_PAN(_DecalTexture, _MainTex, uv, float4(0,0,0,0)) * float4(1,1,1,1); + #else + uv = decalUV(float(0), float4(0.5,0.5,0,0), float(0), float(0), decalScale, float(0)); + decalColor = float4(1,1,1,1); + #endif + decalColor.rgb = decalHueShift(float(0), decalColor.rgb, float(0), float(0)); + decalColor.a *= applyTilingClipping(float(0), uv) * decalMask.r; + albedo.rgb = lerp(albedo.rgb, customBlend(albedo.rgb, decalColor.rgb, float(0)), decalColor.a * saturate(float(1) + lerp(float4(0,0,0,0).x, float4(0,0,0,0).y, poiMods.audioLink[float(0)]))); + + decalEmission += decalColor.rgb * decalColor.a * max(float(0) + lerp(float4(0,0,0,0).x, float4(0,0,0,0).y, poiMods.audioLink[float(0)]), 0); + #ifdef GEOM_TYPE_BRANCH_DETAIL + // Decal 1 + decalScale = float4(1,1,0,0); + #if defined(PROP_DECALTEXTURE1) || !defined(OPTIMIZER_ENABLED) + #ifdef POI_AUDIOLINK + + if (poiMods.audioLinkTextureExists) + { + decalScale += lerp(float4(0,0,0,0).xy, float4(0,0,0,0).zw, poiMods.audioLink[float(0)]); + } + #endif + uv = decalUV(float(0), float4(0.5,0.5,0,0), float(0), float(0), decalScale, float(0)); + decalColor = POI2D_SAMPLER_PAN(_DecalTexture1, _MainTex, uv, float4(0,0,0,0)) * float4(1,1,1,1); + #else + uv = decalUV(float(0), float4(0.5,0.5,0,0), float(0), float(0), decalScale, float(0)); + decalColor = float4(1,1,1,1); + #endif + decalColor.rgb = decalHueShift(float(0), decalColor.rgb, float(0), float(0)); + decalColor.a *= applyTilingClipping(float(0), uv) * decalMask.g; + albedo.rgb = lerp(albedo.rgb, customBlend(albedo.rgb, decalColor.rgb, float(0)), decalColor.a * saturate(float(1) + lerp(float4(0,0,0,0).x, float4(0,0,0,0).y, poiMods.audioLink[float(0)]))); + decalEmission += decalColor.rgb * decalColor.a * max(float(0) + lerp(float4(0,0,0,0).x, float4(0,0,0,0).y, poiMods.audioLink[float(0)]), 0); + #endif + #ifdef GEOM_TYPE_FROND + // Decal 2 + decalScale = float4(1,1,0,0); + #if defined(PROP_DECALTEXTURE2) || !defined(OPTIMIZER_ENABLED) + #ifdef POI_AUDIOLINK + + if (poiMods.audioLinkTextureExists) + { + decalScale += lerp(float4(0,0,0,0).xy, float4(0,0,0,0).zw, poiMods.audioLink[float(0)]); + } + #endif + uv = decalUV(float(0), float4(0.5,0.5,0,0), float(0), float(0), decalScale, float(0)); + decalColor = POI2D_SAMPLER_PAN(_DecalTexture2, _MainTex, uv, float4(0,0,0,0)) * float4(1,1,1,1); + #else + uv = decalUV(float(0), float4(0.5,0.5,0,0), float(0), float(0), decalScale, float(0)); + decalColor = float4(1,1,1,1); + #endif + decalColor.rgb = decalHueShift(float(0), decalColor.rgb, float(0), float(0)); + decalColor.a *= applyTilingClipping(float(0), uv) * decalMask.b; + albedo.rgb = lerp(albedo.rgb, customBlend(albedo.rgb, decalColor.rgb, float(0)), decalColor.a * saturate(float(1) + lerp(float4(0,0,0,0).x, float4(0,0,0,0).y, poiMods.audioLink[float(0)]))); + decalEmission += decalColor.rgb * decalColor.a * max(float(0) + lerp(float4(0,0,0,0).x, float4(0,0,0,0).y, poiMods.audioLink[float(0)]), 0); + #endif + #ifdef DEPTH_OF_FIELD_COC_VIEW + // Decal 3 + decalScale = float4(1,1,0,0); + #if defined(PROP_DECALTEXTURE3) || !defined(OPTIMIZER_ENABLED) + #ifdef POI_AUDIOLINK + + if (poiMods.audioLinkTextureExists) + { + decalScale += lerp(float4(0,0,0,0).xy, float4(0,0,0,0).zw, poiMods.audioLink[float(0)]); + } + #endif + uv = decalUV(float(0), float4(0.5,0.5,0,0), float(0), float(0), decalScale, float(0)); + decalColor = POI2D_SAMPLER_PAN(_DecalTexture3, _MainTex, uv, float4(0,0,0,0)) * float4(1,1,1,1); + #else + uv = decalUV(float(0), float4(0.5,0.5,0,0), float(0), float(0), decalScale, float(0)); + decalColor = float4(1,1,1,1); + #endif + decalColor.rgb = decalHueShift(float(0), decalColor.rgb, float(0), float(0)); + decalColor.a *= applyTilingClipping(float(0), uv) * decalMask.a; + albedo.rgb = lerp(albedo.rgb, customBlend(albedo.rgb, decalColor.rgb, float(0)), decalColor.a * saturate(float(1) + lerp(float4(0,0,0,0).x, float4(0,0,0,0).y, poiMods.audioLink[float(0)]))); + decalEmission += decalColor.rgb * decalColor.a * max(float(0) + lerp(float4(0,0,0,0).x, float4(0,0,0,0).y, poiMods.audioLink[float(0)]), 0); + #endif + + albedo = saturate(albedo); +} + +#endif diff --git a/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_PoiDecal.cginc.meta b/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_PoiDecal.cginc.meta new file mode 100644 index 00000000..0df7b329 --- /dev/null +++ b/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_PoiDecal.cginc.meta @@ -0,0 +1,9 @@ +fileFormatVersion: 2 +guid: c278af7af950b704e9f032032a811509 +ShaderImporter: + externalObjects: {} + defaultTextures: [] + nonModifiableTextures: [] + userData: + assetBundleName: + assetBundleVariant: diff --git a/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_PoiDefines.cginc b/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_PoiDefines.cginc new file mode 100644 index 00000000..0422af76 --- /dev/null +++ b/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_PoiDefines.cginc @@ -0,0 +1,22 @@ +#ifndef POI_DEFINES + #define POI_DEFINES + + #define DielectricSpec float4(0.04, 0.04, 0.04, 1.0 - 0.04) + #define pi float(3.14159265359) + + #ifdef _SPECGLOSSMAP // Specular + #ifndef POI_VAR_DOTNH + #define POI_VAR_DOTNH + #endif + #ifndef POI_VAR_DOTLH + #define POI_VAR_DOTLH + #endif + #endif + + #ifdef VIGNETTE_MASKED // Lighting + #ifndef POI_VAR_DOTNL + #define POI_VAR_DOTNL + #endif + #endif + +#endif diff --git a/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_PoiDefines.cginc.meta b/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_PoiDefines.cginc.meta new file mode 100644 index 00000000..1592ec51 --- /dev/null +++ b/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_PoiDefines.cginc.meta @@ -0,0 +1,9 @@ +fileFormatVersion: 2 +guid: 5d5b8546f843fa549bdaeea5ca3efe8a +ShaderImporter: + externalObjects: {} + defaultTextures: [] + nonModifiableTextures: [] + userData: + assetBundleName: + assetBundleVariant: diff --git a/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_PoiDepthColor.cginc b/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_PoiDepthColor.cginc new file mode 100644 index 00000000..0a4210e9 --- /dev/null +++ b/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_PoiDepthColor.cginc @@ -0,0 +1,129 @@ +#ifndef POI_DEPTH_COLOR + #define POI_DEPTH_COLOR + + float4 _DepthGlowColor; + float _DepthGlowEmission; + float _FadeLength; + float _DepthAlphaMin; + float _DepthAlphaMax; + float _DepthGradientTextureUV; + float _DepthGradientBlend; + + #if defined(PROP_DEPTHGRADIENT) || !defined(OPTIMIZER_ENABLED) + POI_TEXTURE_NOSAMPLER(_DepthGradient); + #endif + #if defined(PROP_DEPTHMASK) || !defined(OPTIMIZER_ENABLED) + POI_TEXTURE_NOSAMPLER(_DepthMask); + #endif + + /* + void applyDepthColor(inout float4 finalColor, inout float3 depthTouchEmission, inout float3 finalEmission, float4 worldDirection, float4 clipPos) + { + float3 touchEmission = 0; + if (!IsInMirror()) + { + float fadeLength = float(20); + fadeLength *= 0.01; + float depth = DecodeFloatRG(tex2Dproj(_CameraDepthTexture, worldDirection)); + depth = Linear01Depth(depth); + if(depth != 1) + { + float diff = distance(depth, Linear01Depth(clipPos.z)); + float intersect = 0; + if(diff > 0) + { + intersect = clamp(1 - smoothstep(0, _ProjectionParams.w * fadeLength, diff), 0, 1); + } + half4 depthGradient = UNITY_SAMPLE_TEX2D_SAMPLER(_DepthGradient, _MainTex, intersect); + half3 depthMask = UNITY_SAMPLE_TEX2D_SAMPLER(_DepthMask, _MainTex, poiMesh.uv[0]); + half3 depthColor = depthGradient.rgb * float4(1,1,1,1).rgb; + finalColor.rgb = lerp(finalColor.rgb, depthColor, intersect * depthMask); + finalColor.a *= lerp(float(1), float(1), intersect); + touchEmission = depthColor * float(3) * intersect * depthMask; + } + } + depthTouchEmission = touchEmission; + } + */ + + inline float CorrectedLinearEyeDepth(float z, float B) + { + return 1.0 / (z / PM._34 + B); + } + + void applyDepthColor(inout float4 finalColor, inout float3 depthTouchEmission, inout float3 finalEmission, in float4 worldDirection) + { + float3 touchEmission = 0; + float fadeLength = float(20); + fadeLength *= 0.01; + + float perspectiveDivide = 1.0f / poiCam.clipPos.w; + float4 direction = worldDirection * perspectiveDivide; + float2 screenPos = poiCam.grabPos.xy * perspectiveDivide; + float z = SAMPLE_DEPTH_TEXTURE(_CameraDepthTexture, screenPos); + + #if UNITY_REVERSED_Z + if (z == 0) + #else + if(z == 1) + #endif + return; + + float depth = CorrectedLinearEyeDepth(z, direction.w); + float3 worldpos = direction * depth + _WorldSpaceCameraPos.xyz; + /* + finalColor.rgb = frac(worldpos); + return; + */ + + float diff = distance(worldpos, poiMesh.worldPos); + float intersect = 0; + intersect = clamp(1 - smoothstep(0, fadeLength, diff), 0, 1); + #if defined(PROP_DEPTHMASK) || !defined(OPTIMIZER_ENABLED) + half3 depthMask = POI2D_SAMPLER_PAN(_DepthMask, _MainTex, poiMesh.uv[float(0)], float4(0,0,0,0)); + #else + half3 depthMask = 1; + #endif + + half4 depthGradient = 0; + half3 depthColor = 0; + + + if (float(0) == 0) + { + #if defined(PROP_DEPTHGRADIENT) || !defined(OPTIMIZER_ENABLED) + depthGradient = POI2D_SAMPLER_PAN(_DepthGradient, _MainTex, float2(intersect, intersect), float4(0,0,0,0)); + #else + depthGradient = 1; + #endif + depthColor = depthGradient.rgb * float4(1,1,1,1).rgb; + } + else + { + #if defined(PROP_DEPTHGRADIENT) || !defined(OPTIMIZER_ENABLED) + depthGradient = POI2D_SAMPLER_PAN(_DepthGradient, _MainTex, poiMesh.uv[float(0)], float4(0,0,0,0)); + #else + depthGradient = 1; + #endif + depthColor = depthGradient.rgb * float4(1,1,1,1).rgb * intersect; + } + + + if(float(0) == 0) // rpelace + { + finalColor.rgb = lerp(finalColor.rgb, depthColor, intersect * depthMask); + } + else if (float(0) == 1) // add + { + finalColor.rgb += depthColor * intersect * depthMask; + } + else if (float(0) == 2) // multiply + { + finalColor.rgb *= lerp(1, depthColor, intersect * depthMask); + } + finalColor.a *= lerp(float(1), float(1), intersect * depthMask); + touchEmission = depthColor * float(3) * intersect * depthMask; + + depthTouchEmission = touchEmission; + } +#endif diff --git a/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_PoiDepthColor.cginc.meta b/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_PoiDepthColor.cginc.meta new file mode 100644 index 00000000..a3322e53 --- /dev/null +++ b/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_PoiDepthColor.cginc.meta @@ -0,0 +1,9 @@ +fileFormatVersion: 2 +guid: 2ae5707ee48794b45b45b86701ec42e7 +ShaderImporter: + externalObjects: {} + defaultTextures: [] + nonModifiableTextures: [] + userData: + assetBundleName: + assetBundleVariant: diff --git a/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_PoiDissolve.cginc b/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_PoiDissolve.cginc new file mode 100644 index 00000000..5ea738d2 --- /dev/null +++ b/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_PoiDissolve.cginc @@ -0,0 +1,237 @@ +#ifndef POI_DISSOLVE +#define POI_DISSOLVE + +float _DissolveType; +float _DissolveEdgeWidth; +float4 _DissolveEdgeColor; +sampler2D _DissolveEdgeGradient; float4 _DissolveEdgeGradient_ST; +float _DissolveEdgeEmission; +float4 _DissolveTextureColor; + +#if defined(PROP_DISSOLVETOTEXTURE) || !defined(OPTIMIZER_ENABLED) + POI_TEXTURE_NOSAMPLER(_DissolveToTexture); +#endif + +#if defined(PROP_DISSOLVENOISETEXTURE) || !defined(OPTIMIZER_ENABLED) + POI_TEXTURE_NOSAMPLER(_DissolveNoiseTexture); +#endif + +#if defined(PROP_DISSOLVEDETAILNOISE) || !defined(OPTIMIZER_ENABLED) + POI_TEXTURE_NOSAMPLER(_DissolveDetailNoise); +#endif + +#if defined(PROP_DISSOLVEMASK) || !defined(OPTIMIZER_ENABLED) + POI_TEXTURE_NOSAMPLER(_DissolveMask); +#endif + +float _DissolveMaskInvert; +float _DissolveAlpha; +float _ContinuousDissolve; +float _DissolveDetailStrength; +float _DissolveEdgeHardness; +float _DissolveInvertNoise; +float _DissolveInvertDetailNoise; +float _DissolveToEmissionStrength; + +// Point to Point +float _DissolveP2PWorldLocal; +float _DissolveP2PEdgeLength; +float4 _DissolveStartPoint; +float4 _DissolveEndPoint; + +// World Dissolve +float _DissolveWorldShape; +float4 _DissolveShapePosition; +float4 _DissolveShapeRotation; +float _DissolveShapeScale; +float _DissolveInvertShape; +float _DissolveShapeEdgeLength; + +float _DissolveAlpha0; +float _DissolveAlpha1; +float _DissolveAlpha2; +float _DissolveAlpha3; +float _DissolveAlpha4; +float _DissolveAlpha5; +float _DissolveAlpha6; +float _DissolveAlpha7; +float _DissolveAlpha8; +float _DissolveAlpha9; +// Masking +float _DissolveEmissionSide; +float _DissolveEmission1Side; +float _DissolveUseVertexColors; + +// Audio Link +#ifdef POI_AUDIOLINK + fixed _EnableDissolveAudioLink; + half _AudioLinkDissolveAlphaBand; + float2 _AudioLinkDissolveAlpha; + half _AudioLinkDissolveDetailBand; + float2 _AudioLinkDissolveDetail; +#endif + +float4 edgeColor; +float edgeAlpha; +float dissolveAlpha; +float4 dissolveToTexture; + +float _DissolveHueShiftEnabled; +float _DissolveHueShiftSpeed; +float _DissolveHueShift; +float _DissolveEdgeHueShiftEnabled; +float _DissolveEdgeHueShiftSpeed; +float _DissolveEdgeHueShift; +void calculateDissolve(inout float4 albedo, inout float3 dissolveEmission) +{ + #if defined(PROP_DISSOLVEMASK) || !defined(OPTIMIZER_ENABLED) + float dissolveMask = POI2D_SAMPLER_PAN(_DissolveMask, _MainTex, poiMesh.uv[float(0)], float4(0,0,0,0)).r; + #else + float dissolveMask = 1; + #endif + + if (float(0)) + { + // Vertex Color Imprecision hype + dissolveMask = ceil(poiMesh.vertexColor.g * 100000) / 100000; + } + + #if defined(PROP_DISSOLVETOTEXTURE) || !defined(OPTIMIZER_ENABLED) + dissolveToTexture = POI2D_SAMPLER_PAN(_DissolveToTexture, _MainTex, poiMesh.uv[float(0)], float4(0,0,0,0)) * float4(1,1,1,1); + #else + dissolveToTexture = float4(1,1,1,1); + #endif + + #if defined(PROP_DISSOLVENOISETEXTURE) || !defined(OPTIMIZER_ENABLED) + float dissolveNoiseTexture = POI2D_SAMPLER_PAN(_DissolveNoiseTexture, _MainTex, poiMesh.uv[float(0)], float4(0,0,0,0)).r; + #else + float dissolveNoiseTexture = 1; + #endif + + float da = float(0) + + float(0) + + float(0) + + float(0) + + float(0) + + float(0) + + float(0) + + float(0) + + float(0) + + float(0) + + float(0); + float dds = float(0.1); + + #ifdef POI_AUDIOLINK + + if (float(0) && poiMods.audioLinkTextureExists) + { + da += lerp(float4(0,0,-1,1).x, float4(0,0,-1,1).y, poiMods.audioLink[float(0)]); + dds += lerp(float4(0,0,-1,1).x, float4(0,0,-1,1).y, poiMods.audioLink[float(0)]); + } + #endif + + da = saturate(da); + dds = saturate(dds); + + #ifdef POI_BLACKLIGHT + if (float(4) != 4) + { + dissolveMask *= blackLightMask[float(4)]; + } + #endif + + if (float(0)) + { + dissolveMask = 1 - dissolveMask; + } + #if defined(PROP_DISSOLVEDETAILNOISE) || !defined(OPTIMIZER_ENABLED) + float dissolveDetailNoise = POI2D_SAMPLER_PAN(_DissolveDetailNoise, _MainTex, poiMesh.uv[float(0)], float4(0,0,0,0)); + #else + float dissolveDetailNoise = 0; + #endif + if (float(0)) + { + dissolveNoiseTexture = 1 - dissolveNoiseTexture; + } + if (float(0)) + { + dissolveDetailNoise = 1 - dissolveDetailNoise; + } + if (float(0) != 0) + { + da = sin(_Time.y * float(0)) * .5 + .5; + } + da *= dissolveMask; + dissolveAlpha = da; + edgeAlpha = 0; + + + if (float(1) == 1) // Basic + + { + da = remap(da, 0, 1, -float(0.025), 1); + dissolveAlpha = da; + //Adjust detail strength to avoid artifacts + dds *= smoothstep(1, .99, da); + float noise = saturate(dissolveNoiseTexture - dissolveDetailNoise * dds); + + noise = saturate(noise + 0.001); + //noise = remap(noise, 0, 1, float(0.025), 1 - float(0.025)); + dissolveAlpha = dissolveAlpha >= noise; + edgeAlpha = remapClamped(noise, da + float(0.025), da, 0, 1) * (1 - dissolveAlpha); + } + else if (float(1) == 2) // Point to Point + + { + float3 direction; + float3 currentPos; + float distanceTo = 0; + direction = normalize(float4(0,1,0,0) - float4(0,-1,0,0)); + currentPos = lerp(float4(0,-1,0,0), float4(0,1,0,0), dissolveAlpha); + + + if (float(0) != 1) + { + float3 pos = float(0) == 0 ? poiMesh.localPos.rgb: poiMesh.vertexColor.rgb; + distanceTo = dot(pos - currentPos, direction) - dissolveDetailNoise * dds; + edgeAlpha = smoothstep(float(0.1), 0, distanceTo); + dissolveAlpha = step(distanceTo, 0); + edgeAlpha *= 1 - dissolveAlpha; + } + else + { + distanceTo = dot(poiMesh.worldPos - currentPos, direction) - dissolveDetailNoise * dds; + edgeAlpha = smoothstep(float(0.1), 0, distanceTo); + dissolveAlpha = step(distanceTo, 0); + edgeAlpha *= 1 - dissolveAlpha; + } + } + + #ifndef POI_SHADOW + + if (float(0)) + { + dissolveToTexture.rgb = hueShift(dissolveToTexture.rgb, float(0) + _Time.x * float(0)); + } + #endif + albedo = lerp(albedo, dissolveToTexture, dissolveAlpha); + + + if (float(0.025)) + { + edgeColor = tex2D(_DissolveEdgeGradient, TRANSFORM_TEX(float2(edgeAlpha, edgeAlpha), _DissolveEdgeGradient)) * float4(1,1,1,1); + #ifndef POI_SHADOW + + if (float(0)) + { + edgeColor.rgb = hueShift(edgeColor.rgb, float(0) + _Time.x * float(0)); + } + #endif + albedo.rgb = lerp(albedo.rgb, edgeColor.rgb, smoothstep(0, 1 - float(0.5) * .99999999999, edgeAlpha)); + } + + dissolveEmission = lerp(0, dissolveToTexture * float(0), dissolveAlpha) + lerp(0, edgeColor.rgb * float(0), smoothstep(0, 1 - float(0.5) * .99999999999, edgeAlpha)); +} + + +#endif diff --git a/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_PoiDissolve.cginc.meta b/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_PoiDissolve.cginc.meta new file mode 100644 index 00000000..5e94d824 --- /dev/null +++ b/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_PoiDissolve.cginc.meta @@ -0,0 +1,9 @@ +fileFormatVersion: 2 +guid: 4ccc230b34600ad43b66271d4e71cdaf +ShaderImporter: + externalObjects: {} + defaultTextures: [] + nonModifiableTextures: [] + userData: + assetBundleName: + assetBundleVariant: diff --git a/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_PoiDithering.cginc b/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_PoiDithering.cginc new file mode 100644 index 00000000..91efad39 --- /dev/null +++ b/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_PoiDithering.cginc @@ -0,0 +1,34 @@ +#ifndef POI_DITHERING + #define POI_DITHERING + fixed _DitheringEnabled; + fixed _DitherGradient; + + half calcDither(half2 grabPos) + { + half dither = Dither8x8Bayer(fmod(grabPos.x, 8), fmod(grabPos.y, 8)); + return dither; + } + + #ifndef POI_SHADOW + void applyDithering(inout float4 finalColor) + { + + if (float(0)) + { + half dither = calcDither(poiCam.screenUV.xy); + finalColor.a = finalColor.a - (dither * (1 - finalColor.a) * float(0.1)); + } + } + #else + void applyShadowDithering(inout float alpha, float2 screenUV) + { + + if(float(0)) + { + half dither = calcDither(screenUV); + alpha = alpha - (dither * (1 - alpha) * float(0.1)); + } + } + #endif + +#endif diff --git a/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_PoiDithering.cginc.meta b/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_PoiDithering.cginc.meta new file mode 100644 index 00000000..80786ba6 --- /dev/null +++ b/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_PoiDithering.cginc.meta @@ -0,0 +1,9 @@ +fileFormatVersion: 2 +guid: 9ab276e4f136f71489e83b33245273cd +ShaderImporter: + externalObjects: {} + defaultTextures: [] + nonModifiableTextures: [] + userData: + assetBundleName: + assetBundleVariant: diff --git a/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_PoiEmission.cginc b/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_PoiEmission.cginc new file mode 100644 index 00000000..817056e8 --- /dev/null +++ b/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_PoiEmission.cginc @@ -0,0 +1,341 @@ +#ifndef POI_EMISSION +#define POI_EMISSION + +float4 _EmissionColor; +#if defined(PROP_EMISSIONMAP) || !defined(OPTIMIZER_ENABLED) + POI_TEXTURE_NOSAMPLER(_EmissionMap); +#endif +#if defined(PROP_EMISSIONMASK) || !defined(OPTIMIZER_ENABLED) + POI_TEXTURE_NOSAMPLER(_EmissionMask); +#endif +#if defined(PROP_EMISSIONSCROLLINGCURVE) || !defined(OPTIMIZER_ENABLED) + UNITY_DECLARE_TEX2D_NOSAMPLER(_EmissionScrollingCurve); float4 _EmissionScrollingCurve_ST; +#endif +float _EmissionBaseColorAsMap; +float _EmissionStrength; +float _EnableEmission; +float _EmissionHueShift; +float4 _EmissiveScroll_Direction; +float _EmissiveScroll_Width; +float _EmissiveScroll_Velocity; +float _EmissiveScroll_Interval; +float _EmissionBlinkingEnabled; +float _EmissiveBlink_Min; +float _EmissiveBlink_Max; +float _EmissiveBlink_Velocity; +float _ScrollingEmission; +float _EnableGITDEmission; +float _GITDEMinEmissionMultiplier; +float _GITDEMaxEmissionMultiplier; +float _GITDEMinLight; +float _GITDEMaxLight; +float _GITDEWorldOrMesh; +float _EmissionCenterOutEnabled; +float _EmissionCenterOutSpeed; +float _EmissionHueShiftEnabled; +float _EmissionBlinkingOffset; +float _EmissionScrollingOffset; +float _EmissionHueShiftSpeed; +float _EmissionHueShiftSpeed1; + +float4 _EmissionColor1; +#ifdef EFFECT_HUE_VARIATION + #if defined(PROP_EMISSIONMAP1) || !defined(OPTIMIZER_ENABLED) + POI_TEXTURE_NOSAMPLER(_EmissionMap1); + #endif + #if defined(PROP_EMISSIONMASK1) || !defined(OPTIMIZER_ENABLED) + POI_TEXTURE_NOSAMPLER(_EmissionMask1); + #endif + #if defined(PROP_EMISSIONSCROLLINGCURVE1) || !defined(OPTIMIZER_ENABLED) + UNITY_DECLARE_TEX2D_NOSAMPLER(_EmissionScrollingCurve1); float4 _EmissionScrollingCurve1_ST; + #endif +#endif +float _EmissionBaseColorAsMap1; +float _EmissionStrength1; +float _EnableEmission1; +float _EmissionHueShift1; +float4 _EmissiveScroll_Direction1; +float _EmissiveScroll_Width1; +float _EmissiveScroll_Velocity1; +float _EmissiveScroll_Interval1; +float _EmissionBlinkingEnabled1; +float _EmissiveBlink_Min1; +float _EmissiveBlink_Max1; +float _EmissiveBlink_Velocity1; +float _ScrollingEmission1; +float _EnableGITDEmission1; +float _GITDEMinEmissionMultiplier1; +float _GITDEMaxEmissionMultiplier1; +float _GITDEMinLight1; +float _GITDEMaxLight1; +float _GITDEWorldOrMesh1; +float _EmissionCenterOutEnabled1; +float _EmissionCenterOutSpeed1; +float _EmissionHueShiftEnabled1; +float _EmissionBlinkingOffset1; +float _EmissionScrollingOffset1; + +float _EmissionReplace; + +float _EmissionScrollingVertexColor; +float _EmissionScrollingVertexColor1; + +float _EmissionScrollingUseCurve; +float _EmissionScrollingUseCurve1; + +#ifdef POI_AUDIOLINK + half _EnableEmissionStrengthAudioLink; + half _AudioLinkEmissionStrengthBand; + half _EnableEmissionCenterOutAudioLink; + half _AudioLinkEmissionCenterOutBand; + float2 _AudioLinkAddEmission; + half _AudioLinkAddEmissionBand; + float2 _EmissionCenterOutAddAudioLink; + half _AudioLinkEmissionCenterOutAddBand; + + half _EnableEmission1StrengthAudioLink; + half _AudioLinkEmission1StrengthBand; + half _EnableEmission1CenterOutAudioLink; + half _AudioLinkEmission1CenterOutBand; + float2 _AudioLinkAddEmission1; + half _AudioLinkAddEmission1Band; + float2 _EmissionCenterOutAddAudioLink1; + half _AudioLinkEmission1CenterOutAddBand; + + fixed _EmissionCenterOutAudioLinkWidth; + fixed _EmissionCenterOutAddAudioLinkwidth; + fixed _Emission1CenterOutAudioLinkWidth; + fixed _Emission1CenterOutAddAudioLinkwidth; +#endif + +float calculateGlowInTheDark(in float minLight, in float maxLight, in float minEmissionMultiplier, in float maxEmissionMultiplier, in float enabled) +{ + float glowInTheDarkMultiplier = 1; + + if (enabled) + { + #ifdef POI_LIGHTING + float3 lightValue = float(0) ? poiLight.finalLighting.rgb: poiLight.directLighting.rgb; + float gitdeAlpha = (clamp(poiMax(lightValue), minLight, maxLight) - minLight) / (maxLight - minLight); + glowInTheDarkMultiplier = lerp(minEmissionMultiplier, maxEmissionMultiplier, gitdeAlpha); + #endif + } + return glowInTheDarkMultiplier; +} + +float calculateScrollingEmission(in float3 direction, in float velocity, in float interval, in float scrollWidth, float offset, float3 position) +{ + float phase = 0; + phase = dot(position, direction); + phase -= (_Time.y + offset) * velocity; + phase /= interval; + phase -= floor(phase); + phase = saturate(phase); + return(pow(phase, scrollWidth) + pow(1 - phase, scrollWidth * 4)) * 0.5; +} + +float calculateBlinkingEmission(in float blinkMin, in float blinkMax, in float blinkVelocity, float offset) +{ + float amplitude = (blinkMax - blinkMin) * 0.5f; + float base = blinkMin + amplitude; + return sin((_Time.y + offset) * blinkVelocity) * amplitude + base; +} + +float3 calculateEmissionNew(in float3 baseColor, inout float4 finalColor) +{ + // First Emission + float3 emission0 = 0; + float emissionStrength0 = float(1); + float3 emissionColor0 = 0; + + #ifdef POI_AUDIOLINK + + if (poiMods.audioLinkTextureExists) + { + + if (float(0)) + { + emissionStrength0 *= poiMods.audioLink[float(0)]; + } + + if (float(0)) + { + emissionStrength0 *= getBandAtTime(float(0), saturate(1 - poiLight.nDotV), float(1)); + } + emissionStrength0 += lerp(float4(0,0,0,0).x, float4(0,0,0,0).y, getBandAtTime(float(0), saturate(1 - poiLight.nDotV), float(1))); + emissionStrength0 += lerp(float4(0,0,-10,10).x, float4(0,0,-10,10).y, poiMods.audioLink[float(0)]); + emissionStrength0 = max(emissionStrength0, 0); + } + #endif + + float glowInTheDarkMultiplier0 = calculateGlowInTheDark(float(0), float(1), float(1), float(0), float(0)); + + #if defined(PROP_EMISSIONMAP) || !defined(OPTIMIZER_ENABLED) + + if (!float(0)) + { + emissionColor0 = POI2D_SAMPLER_PAN(_EmissionMap, _MainTex, poiMesh.uv[float(0)], float4(0,0,0,0)).rgb * lerp(1, baseColor, float(1)).rgb * float4(1,0.4729743,0.3066038,0).rgb; + } + else + { + emissionColor0 = UNITY_SAMPLE_TEX2D_SAMPLER(_EmissionMap, _MainTex, ((.5 + poiLight.nDotV * .5) * float4(1,1,0,0).xy) + _Time.x * float(5)).rgb * lerp(1, baseColor, float(1)).rgb * float4(1,0.4729743,0.3066038,0).rgb; + } + #else + emissionColor0 = lerp(1, baseColor, float(1)).rgb * float4(1,0.4729743,0.3066038,0).rgb; + #endif + + + if (float(1)) + { + float3 pos = poiMesh.localPos; + + if (float(0)) + { + pos = poiMesh.vertexColor.rgb; + } + + + if (float(0)) + { + #if defined(PROP_EMISSIONSCROLLINGCURVE) || !defined(OPTIMIZER_ENABLED) + emissionStrength0 *= UNITY_SAMPLE_TEX2D_SAMPLER(_EmissionScrollingCurve, _MainTex, TRANSFORM_TEX(poiMesh.uv[float(0)], _EmissionScrollingCurve) + (dot(pos, float4(0,0,10,0).xyz) * float(10)) + _Time.x * float(1)).r; + #endif + } + else + { + emissionStrength0 *= calculateScrollingEmission(float4(0,0,10,0).xyz, float(1), float(10), float(2), float(0), pos); + } + } + + + if (float(0)) + { + emissionStrength0 *= calculateBlinkingEmission(float(0), float(1), float(4), float(0)); + } + + emissionColor0 = hueShift(emissionColor0, frac(float(0) + float(0) * _Time.x) * float(0)); + + #if defined(PROP_EMISSIONMASK) || !defined(OPTIMIZER_ENABLED) + float emissionMask0 = UNITY_SAMPLE_TEX2D_SAMPLER(_EmissionMask, _MainTex, TRANSFORM_TEX(poiMesh.uv[float(0)], _EmissionMask) + _Time.x * float4(0,0,0,0)).r; + #else + float emissionMask0 = 1; + #endif + + #ifdef POI_BLACKLIGHT + if (float(4) != 4) + { + emissionMask0 *= blackLightMask[float(4)]; + } + #endif + + emissionStrength0 *= glowInTheDarkMultiplier0 * emissionMask0; + emission0 = emissionStrength0 * emissionColor0; + + #ifdef POI_DISSOLVE + + if (float(2) != 2) + { + emission0 *= lerp(1 - dissolveAlpha, dissolveAlpha, float(2)); + } + #endif + + // Second Emission + float3 emission1 = 0; + float emissionStrength1 = 0; + float3 emissionColor1 = 0; + + #ifdef EFFECT_HUE_VARIATION + emissionStrength1 = float(0); + + #ifdef POI_AUDIOLINK + + if (poiMods.audioLinkTextureExists) + { + + if (float(0)) + { + emissionStrength1 *= poiMods.audioLink[float(0)]; + } + + if (float(0)) + { + emissionStrength1 *= getBandAtTime(float(0), saturate(1 - poiLight.nDotV), float(1)); + } + emissionStrength1 += lerp(float4(0,0,0,0).x, float4(0,0,0,0).y, getBandAtTime(float(0), saturate(1 - poiLight.nDotV), float(1))); + emissionStrength1 += lerp(float4(0,0,-10,10).x, float4(0,0,-10,10).y, poiMods.audioLink[float(0)]); + emissionStrength1 = max(emissionStrength1, 0); + } + #endif + + float glowInTheDarkMultiplier1 = calculateGlowInTheDark(float(0), float(1), float(1), float(0), float(0)); + #if defined(PROP_EMISSIONMAP1) || !defined(OPTIMIZER_ENABLED) + + + if (!float(0)) + { + emissionColor1 = POI2D_SAMPLER_PAN(_EmissionMap1, _MainTex, poiMesh.uv[float(0)], float4(0,0,0,0)) * lerp(1, baseColor, float(0)).rgb * float4(1,1,1,1).rgb; + } + else + { + emissionColor1 = UNITY_SAMPLE_TEX2D_SAMPLER(_EmissionMap1, _MainTex, ((.5 + poiLight.nDotV * .5) * float4(1,1,0,0).xy) + _Time.x * float(5)).rgb * lerp(1, baseColor, float(0)).rgb * float4(1,1,1,1).rgb; + } + #else + emissionColor1 = lerp(1, baseColor, float(0)).rgb * float4(1,1,1,1).rgb;; + #endif + + if (float(0)) + { + float3 pos1 = poiMesh.localPos; + + if (float(0)) + { + pos1 = poiMesh.vertexColor.rgb; + } + + + if (float(0)) + { + #if defined(PROP_EMISSIONSCROLLINGCURVE1) || !defined(OPTIMIZER_ENABLED) + emissionStrength1 *= UNITY_SAMPLE_TEX2D_SAMPLER(_EmissionScrollingCurve1, _MainTex, TRANSFORM_TEX(poiMesh.uv[float(0)], _EmissionScrollingCurve1) + (dot(pos1, float4(0,-10,0,0)) * float(20)) + _Time.x * float(10)); + #endif + } + else + { + emissionStrength1 *= calculateScrollingEmission(float4(0,-10,0,0), float(10), float(20), float(10), float(0), pos1); + } + } + + if (float(0)) + { + emissionStrength1 *= calculateBlinkingEmission(float(0), float(1), float(4), float(0)); + } + + emissionColor1 = hueShift(emissionColor1, frac(float(0) + float(0) * _Time.x) * float(0)); + #if defined(PROP_EMISSIONMASK1) || !defined(OPTIMIZER_ENABLED) + float emissionMask1 = UNITY_SAMPLE_TEX2D_SAMPLER(_EmissionMask1, _MainTex, TRANSFORM_TEX(poiMesh.uv[float(0)], _EmissionMask1) + _Time.x * float4(0,0,0,0)); + #else + float emissionMask1 = 1; + #endif + + #ifdef POI_BLACKLIGHT + if (float(4) != 4) + { + emissionMask1 *= blackLightMask[float(4)]; + } + #endif + emissionStrength1 *= glowInTheDarkMultiplier1 * emissionMask1; + emission1 = emissionStrength1 * emissionColor1; + + #ifdef POI_DISSOLVE + if (float(2) != 2) + { + emission1 *= lerp(1 - dissolveAlpha, dissolveAlpha, float(2)); + } + #endif + #endif + finalColor.rgb = lerp(finalColor.rgb, saturate(emissionColor0 + emissionColor1), saturate(emissionStrength0 + emissionStrength1) * float(1) * poiMax(emission0 + emission1)); + + return emission0 + emission1; +} + +#endif diff --git a/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_PoiEmission.cginc.meta b/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_PoiEmission.cginc.meta new file mode 100644 index 00000000..26b94b4a --- /dev/null +++ b/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_PoiEmission.cginc.meta @@ -0,0 +1,9 @@ +fileFormatVersion: 2 +guid: aa5670524ba8fa049a27f972ab969589 +ShaderImporter: + externalObjects: {} + defaultTextures: [] + nonModifiableTextures: [] + userData: + assetBundleName: + assetBundleVariant: diff --git a/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_PoiEnvironmentalRimLighting.cginc b/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_PoiEnvironmentalRimLighting.cginc new file mode 100644 index 00000000..cb7629d0 --- /dev/null +++ b/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_PoiEnvironmentalRimLighting.cginc @@ -0,0 +1,48 @@ +#ifndef POI_ENVIRONMENTAL_RIM + #define POI_ENVIRONMENTAL_RIM + + //enviro rim + float _EnableEnvironmentalRim; + float _RimEnviroBlur; + float _RimEnviroMinBrightness; + float _RimEnviroWidth; + float _RimEnviroSharpness; + float _RimEnviroIntensity; + #if defined(PROP_RIMENVIROMASK) || !defined(OPTIMIZER_ENABLED) + POI_TEXTURE_NOSAMPLER(_RimEnviroMask); + #endif + + float3 calculateEnvironmentalRimLighting(in float4 albedo) + { + float enviroRimAlpha = saturate(1 - smoothstep(min(float(0), float(0.45)), float(0.45), poiCam.viewDotNormal)); + float(0.7) *= 1.7 - 0.7 * float(0.7); + + float3 enviroRimColor = 0; + float interpolator = unity_SpecCube0_BoxMin.w; + + if (interpolator < 0.99999) + { + //Probe 1 + float4 reflectionData0 = UNITY_SAMPLE_TEXCUBE_LOD(unity_SpecCube0, poiMesh.normals[1], float(0.7) * UNITY_SPECCUBE_LOD_STEPS); + float3 reflectionColor0 = DecodeHDR(reflectionData0, unity_SpecCube0_HDR); + + //Probe 2 + float4 reflectionData1 = UNITY_SAMPLE_TEXCUBE_SAMPLER_LOD(unity_SpecCube1, unity_SpecCube0, poiMesh.normals[1], float(0.7) * UNITY_SPECCUBE_LOD_STEPS); + float3 reflectionColor1 = DecodeHDR(reflectionData1, unity_SpecCube1_HDR); + + enviroRimColor = lerp(reflectionColor1, reflectionColor0, interpolator); + } + else + { + float4 reflectionData = UNITY_SAMPLE_TEXCUBE_LOD(unity_SpecCube0, poiMesh.normals[1], float(0.7) * UNITY_SPECCUBE_LOD_STEPS); + enviroRimColor = DecodeHDR(reflectionData, unity_SpecCube0_HDR); + } + #if defined(PROP_RIMENVIROMASK) || !defined(OPTIMIZER_ENABLED) + half enviroMask = poiMax(POI2D_SAMPLER_PAN(_RimEnviroMask, _MainTex, poiMesh.uv[float(0)], float4(0,0,0,0)).rgb); + #else + half enviroMask = 1; + #endif + return lerp(0, max(0, (enviroRimColor - float(0)) * albedo.rgb), enviroRimAlpha).rgb * enviroMask * float(1); + } + +#endif diff --git a/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_PoiEnvironmentalRimLighting.cginc.meta b/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_PoiEnvironmentalRimLighting.cginc.meta new file mode 100644 index 00000000..37313af3 --- /dev/null +++ b/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_PoiEnvironmentalRimLighting.cginc.meta @@ -0,0 +1,9 @@ +fileFormatVersion: 2 +guid: bd563d43868277f49b31724c005c0990 +ShaderImporter: + externalObjects: {} + defaultTextures: [] + nonModifiableTextures: [] + userData: + assetBundleName: + assetBundleVariant: diff --git a/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_PoiFlipbook.cginc b/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_PoiFlipbook.cginc new file mode 100644 index 00000000..6f48d597 --- /dev/null +++ b/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_PoiFlipbook.cginc @@ -0,0 +1,222 @@ +#ifndef POI_FLIPBOOK +#define POI_FLIPBOOK + +#if defined(PROP_FLIPBOOKTEXARRAY) || !defined(OPTIMIZER_ENABLED) + UNITY_DECLARE_TEX2DARRAY(_FlipbookTexArray); float4 _FlipbookTexArray_ST; +#endif +#if defined(PROP_FLIPBOOKMASK) || !defined(OPTIMIZER_ENABLED) + POI_TEXTURE_NOSAMPLER(_FlipbookMask); +#endif + +float4 _FlipbookColor; +float _FlipbookFPS; +float _FlipbookTotalFrames; +float4 _FlipbookScaleOffset; +float _FlipbookTiled; +float _FlipbookCurrentFrame; +float _FlipbookEmissionStrength; +float _FlipbookRotation; +float _EnableFlipbook; +float _FlipbookTexArrayUV; +float _FlipbookAlphaControlsFinalAlpha; +float _FlipbookRotationSpeed; +float _FlipbookIntensityControlsAlpha; +float _FlipbookColorReplaces; +float2 _FlipbookTexArrayPan; + +// blending +float _FlipbookReplace; +float _FlipbookMultiply; +float _FlipbookAdd; + +// anim +float _FlipbookMovementType; +float4 _FlipbookStartEndOffset; +float _FlipbookMovementSpeed; + +// Crossfade +float _FlipbookCrossfadeEnabled; +float2 _FlipbookCrossfadeRange; + +float _FlipbookHueShiftEnabled; +float _FlipbookHueShiftSpeed; +float _FlipbookHueShift; +// Global +float4 flipBookPixel; +float4 flipBookPixelMultiply; +float flipBookMask; + +// Audio Link +half _AudioLinkFlipbookScaleBand; +half4 _AudioLinkFlipbookScale; +half _AudioLinkFlipbookAlphaBand; +half2 _AudioLinkFlipbookAlpha; +half _AudioLinkFlipbookEmissionBand; +half2 _AudioLinkFlipbookEmission; +half _AudioLinkFlipbookFrameBand; +half2 _AudioLinkFlipbookFrame; + +#ifndef POI_SHADOW + + void applyFlipbook(inout float4 finalColor, inout float3 flipbookEmission) + { + + #if defined(PROP_FLIPBOOKMASK) || !defined(OPTIMIZER_ENABLED) + flipBookMask = POI2D_SAMPLER_PAN(_FlipbookMask, _MainTex, poiMesh.uv[float(0)], float4(0,0,0,0)).r; + #else + flipBookMask = 1; + #endif + float4 flipbookScaleOffset = float4(1,1,0,0); + + #ifdef POI_AUDIOLINK + flipbookScaleOffset.xy += lerp(float4(0,0,0,0).xy, float4(0,0,0,0).zw, poiMods.audioLink[float(0)]); + #endif + + flipbookScaleOffset.xy = 1 - flipbookScaleOffset.xy; + float2 uv = frac(poiMesh.uv[float(0)]); + float theta = radians(float(0) + _Time.z * float(0)); + float cs = cos(theta); + float sn = sin(theta); + float2 spriteCenter = flipbookScaleOffset.zw + .5; + // 2d rotation + uv = float2((uv.x - spriteCenter.x) * cs - (uv.y - spriteCenter.y) * sn + spriteCenter.x, (uv.x - spriteCenter.x) * sn + (uv.y - spriteCenter.y) * cs + spriteCenter.y); + + float2 newUV = remap(uv, float2(0, 0) + flipbookScaleOffset.xy / 2 + flipbookScaleOffset.zw, float2(1, 1) - flipbookScaleOffset.xy / 2 + flipbookScaleOffset.zw, float2(0, 0), float2(1, 1)); + + + if (float(0) == 0) + { + if (max(newUV.x, newUV.y) > 1 || min(newUV.x, newUV.y) < 0) + { + flipBookPixel = 0; + return; + } + } + #if defined(PROP_FLIPBOOKTEXARRAY) || !defined(OPTIMIZER_ENABLED) + float currentFrame = fmod(float(-1), float(1)); + if (float(-1) < 0) + { + currentFrame = (_Time.y / (1 / float(30))) % float(1); + } + #ifdef POI_AUDIOLINK + currentFrame += lerp(float4(0,0,0,0).x, float4(0,0,0,0).y, poiMods.audioLink[float(0)]); + #endif + flipBookPixel = UNITY_SAMPLE_TEX2DARRAY(_FlipbookTexArray, float3(TRANSFORM_TEX(newUV, _FlipbookTexArray) + _Time.x * float4(0,0,0,0), floor(currentFrame))); + + if (float(0)) + { + float4 flipbookNextPixel = UNITY_SAMPLE_TEX2DARRAY(_FlipbookTexArray, float3(TRANSFORM_TEX(newUV, _FlipbookTexArray) + _Time.x * float4(0,0,0,0), floor((currentFrame + 1) % float(1)))); + flipBookPixel = lerp(flipBookPixel, flipbookNextPixel, smoothstep(float4(0.75,1,0,1).x, float4(0.75,1,0,1).y, frac(currentFrame))); + } + #else + flipBookPixel = 1; + #endif + + + if (float(0)) + { + flipBookPixel.a = poiMax(flipBookPixel.rgb); + } + + if (float(0)) + { + flipBookPixel.rgb = float4(1,1,1,1).rgb; + } + else + { + flipBookPixel.rgb *= float4(1,1,1,1).rgb; + } + + #ifdef POI_BLACKLIGHT + + if (float(4) != 4) + { + flipBookMask *= blackLightMask[float(4)]; + } + #endif + + + if (float(0)) + { + flipBookPixel.rgb = hueShift(flipBookPixel.rgb, float(0) + _Time.x * float(0)); + } + half flipbookAlpha = 1; + #ifdef POI_AUDIOLINK + flipbookAlpha = saturate(lerp(float4(1,1,0,0).x, float4(1,1,0,0).y, poiMods.audioLink[float(0)])); + #endif + + finalColor.rgb = lerp(finalColor.rgb, flipBookPixel.rgb, flipBookPixel.a * float4(1,1,1,1).a * float(1) * flipBookMask * flipbookAlpha); + finalColor.rgb = finalColor + flipBookPixel.rgb * float(0) * flipBookMask * flipbookAlpha; + finalColor.rgb = finalColor * lerp(1, flipBookPixel.rgb, flipBookPixel.a * float4(1,1,1,1).a * flipBookMask * float(0) * flipbookAlpha); + + + if (float(0)) + { + finalColor.a = lerp(finalColor.a, flipBookPixel.a * float4(1,1,1,1).a, flipBookMask); + } + float flipbookEmissionStrength = float(0); + #ifdef POI_AUDIOLINK + flipbookEmissionStrength += max(lerp(float4(0,0,0,0).x, float4(0,0,0,0).y, poiMods.audioLink[float(0)]), 0); + #endif + flipbookEmission = lerp(0, flipBookPixel.rgb * flipbookEmissionStrength, flipBookPixel.a * float4(1,1,1,1).a * flipBookMask * flipbookAlpha); + } + +#else + + float applyFlipbookAlphaToShadow(float2 uv) + { + + if (float(0)) + { + float flipbookShadowAlpha = 0; + + float4 flipbookScaleOffset = float4(1,1,0,0); + flipbookScaleOffset.xy = 1 - flipbookScaleOffset.xy; + float theta = radians(float(0)); + + float cs = cos(theta); + float sn = sin(theta); + float2 spriteCenter = flipbookScaleOffset.zw + .5; + uv = float2((uv.x - spriteCenter.x) * cs - (uv.y - spriteCenter.y) * sn + spriteCenter.x, (uv.x - spriteCenter.x) * sn + (uv.y - spriteCenter.y) * cs + spriteCenter.y); + + float2 newUV = remap(uv, float2(0, 0) + flipbookScaleOffset.xy / 2 + flipbookScaleOffset.zw, float2(1, 1) - flipbookScaleOffset.xy / 2 + flipbookScaleOffset.zw, float2(0, 0), float2(1, 1)); + + #if defined(PROP_FLIPBOOKTEXARRAY) || !defined(OPTIMIZER_ENABLED) + float currentFrame = fmod(float(-1), float(1)); + if (float(-1) < 0) + { + currentFrame = (_Time.y / (1 / float(30))) % float(1); + } + + half4 flipbookColor = UNITY_SAMPLE_TEX2DARRAY(_FlipbookTexArray, float3(TRANSFORM_TEX(newUV, _FlipbookTexArray) + _Time.x * float4(0,0,0,0), floor(currentFrame))); + + if (float(0)) + { + float4 flipbookNextPixel = UNITY_SAMPLE_TEX2DARRAY(_FlipbookTexArray, float3(TRANSFORM_TEX(newUV, _FlipbookTexArray) + _Time.x * float4(0,0,0,0), floor((currentFrame + 1) % float(1)))); + flipbookColor = lerp(flipbookColor, flipbookNextPixel, smoothstep(float4(0.75,1,0,1).x, float4(0.75,1,0,1).y, frac(currentFrame))); + } + #else + half4 flipbookColor = 1; + #endif + + if (float(0)) + { + flipbookColor.a = poiMax(flipbookColor.rgb); + } + + + if (float(0) == 0) + { + if (max(newUV.x, newUV.y) > 1 || min(newUV.x, newUV.y) < 0) + { + flipbookColor.a = 0; + } + } + return flipbookColor.a * float4(1,1,1,1).a; + } + return 1; + } + +#endif +#endif + diff --git a/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_PoiFlipbook.cginc.meta b/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_PoiFlipbook.cginc.meta new file mode 100644 index 00000000..287277d3 --- /dev/null +++ b/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_PoiFlipbook.cginc.meta @@ -0,0 +1,9 @@ +fileFormatVersion: 2 +guid: 9f1d0df93bd712440b66984cec1a080d +ShaderImporter: + externalObjects: {} + defaultTextures: [] + nonModifiableTextures: [] + userData: + assetBundleName: + assetBundleVariant: diff --git a/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_PoiFrag.cginc b/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_PoiFrag.cginc new file mode 100644 index 00000000..5d46254f --- /dev/null +++ b/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_PoiFrag.cginc @@ -0,0 +1,401 @@ +#ifndef POIFRAG +#define POIFRAG + +float _MainEmissionStrength; +float _IgnoreFog; +half _GIEmissionMultiplier; +float _IridescenceTime; +float _AlphaToMask; +float _ForceOpaque; +float _commentIfZero_EnableGrabpass; +float _AlphaPremultiply; +float2 _MainTexPan; +float _MainTextureUV; +float _commentIfZero_LightingAdditiveEnable; + +float4 frag(v2f i, uint facing: SV_IsFrontFace): SV_Target +{ + #ifdef FORWARD_ADD_PASS + #if !defined(POI_LIGHTING) + return 0; + #endif + #if defined(_SMOOTHNESS_TEXTURE_ALBEDO_CHANNEL_A) && defined(DIRECTIONAL) + return 0; + #endif + #endif + #ifdef FORWARD_ADD_PASS + + if (float(1) == 0) + { + return 0; + } + #endif + UNITY_SETUP_INSTANCE_ID(i); + // Color + float4 albedo = 1; + float4 finalColor = 1; + + // Lighting + float bakedCubemap = 0; // Whether or not metallic should run before or after lighting multiplication + float3 finalSpecular0 = 0; + float3 finalSpecular1 = 0; + float3 finalSSS = 0; + fixed lightingAlpha = 1; + float3 finalEnvironmentalRim = 0; + + // Emissions + float3 finalEmission = 0; + float3 finalLighting = 1; + float3 emissionLighting = 1; + float3 IridescenceEmission = 0; + float3 spawnInEmission = 0; + float3 voronoiEmission = 0; + float3 matcapEmission = 0; + float3 depthTouchEmission = 0; + float3 decalEmission = 0; + float3 glitterEmission = 0; + float3 panosphereEmission = 0; + float3 backFaceEmission = 0; + float3 dissolveEmission = 0; + float3 rimLightEmission = 0; + float3 flipbookEmission = 0; + float3 textOverlayEmission = 0; + float3 videoEmission = 0; + /********************************************************************** + Initialize the base data that's needed everywhere else in the shader + **********************************************************************/ + calculateAttenuation(i); + InitializeMeshData(i, facing); + initPoiMods(); + initializeCamera(i); + calculateTangentData(); + + + #ifdef POI_BLACKLIGHT + createBlackLightMask(); + + if (float(0)) + { + return float4(blackLightMask.rgb, 1); + } + #endif + + // This has to happen in the initializbecause it alters UV data globally + #ifdef POI_PARALLAX + calculateandApplyParallax(); + #endif + + // Basically every texture relies on the maintex sampler to function and that's why this is here. + float4 mainTexture = UNITY_SAMPLE_TEX2D(_MainTex, TRANSFORM_TEX(poiMesh.uv[float(0)], _MainTex) + _Time.x * float4(0,0,0,0)); + half3 detailMask = 1; + calculateNormals(detailMask); + calculateVertexLightingData(i); + /********************************************************************** + Calculate Light Maps + **********************************************************************/ + #ifdef POI_DATA + calculateLightingData(i); + #endif + #ifdef POI_LIGHTING + calculateBasePassLightMaps(); + #endif + + /********************************************************************** + Calculate Color Data + **********************************************************************/ + + initTextureData(albedo, mainTexture, backFaceEmission, dissolveEmission, detailMask); + + #ifdef POI_DECAL + applyDecals(albedo, decalEmission); + #endif + + + #ifdef POI_IRIDESCENCE + + if (float(0) == 0) + { + applyIridescence(albedo, IridescenceEmission); + } + #endif + + #ifdef POI_VORONOI + applyVoronoi(albedo, voronoiEmission); + #endif + + #ifdef POI_MSDF + ApplyTextOverlayColor(albedo, textOverlayEmission); + #endif + + #ifdef POI_ENVIRONMENTAL_RIM + finalEnvironmentalRim = calculateEnvironmentalRimLighting(albedo); + #endif + + #if defined(POI_METAL) || defined(POI_CLEARCOAT) + CalculateReflectionData(); + #endif + + #ifdef POI_DATA + distanceFade(albedo); + #endif + + #ifdef POI_RANDOM + albedo.a *= i.angleAlpha; + #endif + + #ifdef MATCAP + applyMatcap(albedo, matcapEmission); + #endif + + #ifdef PANOSPHERE + applyPanosphereColor(albedo, panosphereEmission); + #endif + + #ifdef POI_FLIPBOOK + applyFlipbook(albedo, flipbookEmission); + #endif + + #ifdef POI_GLITTER + applyGlitter(albedo, glitterEmission); + #endif + + #ifdef POI_RIM + applyRimLighting(albedo, rimLightEmission); + #endif + + #ifdef POI_DEPTH_COLOR + applyDepthColor(albedo, depthTouchEmission, finalEmission, i.worldDirection); + #endif + + #ifdef POI_IRIDESCENCE + + if (float(0) == 1) + { + applyIridescence(albedo, IridescenceEmission); + } + #endif + + #ifdef POI_VIDEO + applyScreenEffect(albedo, videoEmission); + #endif + + applySpawnIn(albedo, spawnInEmission, poiMesh.uv[0], poiMesh.localPos); + + /********************************************************************** + Handle a few alpha options + **********************************************************************/ + + if (float(0) == 1) + { + + if (float(0) == 0) + { + applyDithering(albedo); + } + } + + albedo.a = max(float(0), albedo.a); + + + if (float(0) == 0) + { + albedo.a = 1; + } + + + if (float(0) >= 1) + { + clip(albedo.a - float(0.5)); + } + + + if (float(0)) + { + albedo.rgb *= saturate(albedo.a + 0.0000000001); + } + + /********************************************************************** + Lighting Time :) + **********************************************************************/ + + #ifdef POI_LIGHTING + finalLighting = calculateFinalLighting(albedo.rgb, finalColor); + + #ifdef SUBSURFACE + finalSSS = calculateSubsurfaceScattering(); + //finalSSS = calculateSubsurfaceScattering(albedo); + #endif + #endif + + float4 finalColorBeforeLighting = albedo; + finalColor = finalColorBeforeLighting; + + #ifdef POI_SPECULAR + finalSpecular0 = calculateSpecular(finalColorBeforeLighting); + #endif + #ifdef POI_PARALLAX + calculateAndApplyInternalParallax(finalColor); + #endif + + #ifdef POI_ALPHA_TO_COVERAGE + ApplyAlphaToCoverage(finalColor); + #endif + + + if (float(0) == 1) + { + + if (float(0) == 1) + { + applyDithering(finalColor); + } + } + + + #ifdef POI_METAL + calculateMetallicness(); + bool probeExists = shouldMetalHappenBeforeLighting(); + + if (!probeExists) + { + ApplyMetallicsFake(finalColor, albedo); + } + #endif + + + #ifdef POI_LIGHTING + emissionLighting = finalLighting; + #if defined(FORWARD_ADD_PASS) && defined(POI_METAL) + finalLighting *= 1 - metalicMap; + #endif + applyLighting(finalColor, finalLighting); + #endif + + #ifdef POI_BRDF + poiBRDF(finalColor, finalColorBeforeLighting); + #endif + + #ifdef POI_METAL + + if (probeExists) + { + ApplyMetallics(finalColor, albedo); + } + #endif + + finalColor.rgb += finalSpecular0 + finalEnvironmentalRim + finalSSS; + + #ifdef FORWARD_BASE_PASS + #ifdef POI_CLEARCOAT + calculateAndApplyClearCoat(finalColor); + #endif + #endif + + finalColor.a = saturate(finalColor.a); + + /********************************************************************** + Add Up all the emission values :D + **********************************************************************/ + //#if defined(FORWARD_BASE_PASS) || defined(POI_META_PASS) + finalEmission += finalColorBeforeLighting.rgb * float(0) * albedo.a; + finalEmission += wireframeEmission; + finalEmission += IridescenceEmission; + finalEmission += spawnInEmission; + finalEmission += voronoiEmission; + finalEmission += matcapEmission; + finalEmission += depthTouchEmission; + finalEmission += decalEmission; + finalEmission += glitterEmission; + finalEmission += panosphereEmission; + finalEmission += backFaceEmission; + finalEmission += rimLightEmission; + finalEmission += flipbookEmission; + finalEmission += videoEmission; + finalEmission += textOverlayEmission; + finalEmission += dissolveEmission; + #ifdef POI_EMISSION + finalEmission += calculateEmissionNew(finalColorBeforeLighting.rgb, finalColor); + #endif + //#endif + // Compensate for HDR lights + #if defined(FORWARD_ADD_PASS) + finalEmission *= emissionLighting; // TODO: add in vertex lights + #else + finalEmission *= max(1, emissionLighting); + #endif + + /********************************************************************** + Meta Pass Hype :D + **********************************************************************/ + #ifdef POI_META_PASS + UnityMetaInput meta; + UNITY_INITIALIZE_OUTPUT(UnityMetaInput, meta); + meta.Emission = finalEmission * float(1); + meta.Albedo = saturate(finalColor.rgb); + #ifdef POI_SPECULAR + meta.SpecularColor = poiLight.color.rgb * float4(1,1,1,1).rgb * lerp(1, albedo.rgb, float(0)) * float4(1,1,1,1).a; + #else + meta.SpecularColor = poiLight.color.rgb * albedo.rgb; + #endif + return UnityMetaFragment(meta); + #endif + + /********************************************************************** + Apply Emission to finalColor + **********************************************************************/ + finalColor.rgb += finalEmission; + + /********************************************************************** + Grabpass features + **********************************************************************/ + + + if (float(0)) + { + applyGrabEffects(finalColor); + } + + /********************************************************************** + Unity Fog + **********************************************************************/ + #ifdef FORWARD_BASE_PASS + + if (float(0) == 0) + { + UNITY_APPLY_FOG(i.fogCoord, finalColor); + } + #endif + + #ifdef FORWARD_ADD_PASS + if (float(0) > 0) + { + finalColor.rgb *= finalColor.a; + } + #endif + + + if (float(0) == 0) + { + finalColor.a = 1; + } + + #ifdef FORWARD_ADD_PASS + //finalColor.rgb = smoothstep(float(0), float(0.5), 1 - (.5 * poiLight.nDotL + .5)); + #endif + + #ifdef POI_DEBUG + displayDebugInfo(finalColor); + #endif + + #ifdef POI_AUDIOLINK + + if (float(0)) + { + finalColor = poiMods.audioLinkTexture; + } + #endif + + //finalColor.rgb = frac(finalColor.rgb); + return finalColor; +} +#endif diff --git a/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_PoiFrag.cginc.meta b/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_PoiFrag.cginc.meta new file mode 100644 index 00000000..b19d727e --- /dev/null +++ b/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_PoiFrag.cginc.meta @@ -0,0 +1,9 @@ +fileFormatVersion: 2 +guid: 16bfb97420fac7441907dad90f0afa29 +ShaderImporter: + externalObjects: {} + defaultTextures: [] + nonModifiableTextures: [] + userData: + assetBundleName: + assetBundleVariant: diff --git a/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_PoiGlitter.cginc b/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_PoiGlitter.cginc new file mode 100644 index 00000000..eebce5bb --- /dev/null +++ b/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_PoiGlitter.cginc @@ -0,0 +1,274 @@ +#ifndef POI_GLITTER + #define POI_GLITTER + + half3 _GlitterColor; + float2 _GlitterPan; + half _GlitterSpeed; + half _GlitterBrightness; + float _GlitterFrequency; + float _GlitterJitter; + half _GlitterSize; + half _GlitterContrast; + half _GlitterAngleRange; + half _GlitterMinBrightness; + half _GlitterBias; + float _GlitterRandomColors; + float2 _GlitterMinMaxSaturation; + float2 _GlitterMinMaxBrightness; + fixed _GlitterUseSurfaceColor; + float _GlitterBlendType; + float _GlitterMode; + float _GlitterShape; + float _GlitterCenterSize; + float _glitterFrequencyLinearEmissive; + float _GlitterJaggyFix; + float _GlitterRandomRotation; + float _GlitterTextureRotation; + float4 _GlitterMinMaxSize; + float _GlitterRandomSize; + float2 _GlitterUVPanning; + + float _GlitterHueShiftEnabled; + float _GlitterHueShiftSpeed; + float _GlitterHueShift; + float _GlitterHideInShadow; + + #if defined(PROP_GLITTERMASK) || !defined(OPTIMIZER_ENABLED) + POI_TEXTURE_NOSAMPLER(_GlitterMask); + #endif + #if defined(PROP_GLITTERCOLORMAP) || !defined(OPTIMIZER_ENABLED) + POI_TEXTURE_NOSAMPLER(_GlitterColorMap); + #endif + #if defined(PROP_GLITTERTEXTURE) || !defined(OPTIMIZER_ENABLED) + POI_TEXTURE_NOSAMPLER(_GlitterTexture); + #endif + + float3 randomFloat3(float2 Seed, float maximum) + { + return(.5 + float3( + frac(sin(dot(Seed.xy, float2(12.9898, 78.233))) * 43758.5453), + frac(sin(dot(Seed.yx, float2(12.9898, 78.233))) * 43758.5453), + frac(sin(dot(float2(Seed), float2(12.9898, 78.233))) * 43758.5453) + ) * .5) * (maximum); + } + + float3 randomFloat3Range(float2 Seed, float Range) + { + return(float3( + frac(sin(dot(Seed.xy, float2(12.9898, 78.233))) * 43758.5453), + frac(sin(dot(Seed.yx, float2(12.9898, 78.233))) * 43758.5453), + frac(sin(dot(float2(Seed.x * Seed.y, Seed.y + Seed.x), float2(12.9898, 78.233))) * 43758.5453) + ) * 2 - 1) * Range; + } + + float3 randomFloat3WiggleRange(float2 Seed, float Range) + { + float3 rando = (float3( + frac(sin(dot(Seed.xy, float2(12.9898, 78.233))) * 43758.5453), + frac(sin(dot(Seed.yx, float2(12.9898, 78.233))) * 43758.5453), + frac(sin(dot(float2(Seed.x * Seed.y, Seed.y + Seed.x), float2(12.9898, 78.233))) * 43758.5453) + ) * 2 - 1); + float speed = 1 + float(10); + return float3(sin((_Time.x + rando.x * pi) * speed), sin((_Time.x + rando.y * pi) * speed), sin((_Time.x + rando.z * pi) * speed)) * Range; + } + + void Unity_RandomRange_float(float2 Seed, float Min, float Max, out float Out) + { + float randomno = frac(sin(dot(Seed, float2(12.9898, 78.233))) * 43758.5453); + Out = lerp(Min, Max, randomno); + } + + float3 RandomColorFromPoint(float2 rando) + { + fixed hue = random2(rando.x + rando.y).x; + fixed saturation = lerp(float4(0.8,1,0,1).x, float4(0.8,1,0,1).y, rando.x); + fixed value = lerp(float4(0.8,1,0,1).x, float4(0.8,1,0,1).y, rando.y); + float3 hsv = float3(hue, saturation, value); + return HSVtoRGB(hsv); + } + + void applyGlitter(inout float4 albedo, inout float3 glitterEmission) + { + + + // Scale + float2 st = frac(poiMesh.uv[0] + float4(0,0,0,0).xy * _Time.x) * float(300); + + // Tile the space + float2 i_st = floor(st); + float2 f_st = frac(st); + + float m_dist = 10.; // minimun distance + float2 m_point = 0; // minimum point + float2 randoPoint = 0; + float2 dank; + for (int j = -1; j <= 1; j ++) + { + for (int i = -1; i <= 1; i ++) + { + float2 neighbor = float2(i, j); + float2 pos = random2(i_st + neighbor); + float2 rando = pos; + pos = 0.5 + 0.5 * sin(float(1) * 6.2831 * pos); + float2 diff = neighbor + pos - f_st; + float dist = length(diff); + + if (dist < m_dist) + { + dank = diff; + m_dist = dist; + m_point = pos; + randoPoint = rando; + } + } + } + + float randomFromPoint = random(randoPoint); + + float size = float(0.3); + + if(float(0)) + { + size = remapClamped(randomFromPoint, 0, 1, float4(0.1,0.5,0,1).x, float4(0.1,0.5,0,1).y); + } + + + // Assign a color using the closest point position + //color += dot(m_point, float2(.3, .6)); + + // Add distance field to closest point center + // color.g = m_dist; + + // Show isolines + //color -= abs(sin(40.0 * m_dist)) * 0.07; + + // Draw cell center + half glitterAlpha = 1; + switch(float(0)) + { + case 0: //circle + glitterAlpha = (1. - step(size, m_dist)); + break; + case 1: //sqaure + float jaggyFix = pow(poiCam.distanceToVert, 2) * float(0); + + + if (float(0) == 1 || float(0) != 0) + { + float2 center = float2(0, 0); + float randomBoy = 0; + + if(float(0)) + { + randomBoy = random(randoPoint); + } + float theta = radians((randomBoy + _Time.x * float(0)) * 360); + float cs = cos(theta); + float sn = sin(theta); + dank = float2((dank.x - center.x) * cs - (dank.y - center.y) * sn + center.x, (dank.x - center.x) * sn + (dank.y - center.y) * cs + center.y); + glitterAlpha = (1. - smoothstep(size - .1 * jaggyFix, size, abs(dank.x))) * (1. - smoothstep(size - .1 * jaggyFix, size, abs(dank.y))); + } + else + { + glitterAlpha = (1. - smoothstep(size - .1 * jaggyFix, size, abs(dank.x))) * (1. - smoothstep(size - .1 * jaggyFix, size, abs(dank.y))); + } + break; + } + + float3 finalGlitter = 0; + + switch(float(0)) + { + case 0: + float3 randomRotation = 0; + + if(float(10) > 0) + { + randomRotation = randomFloat3WiggleRange(randoPoint, float(90)); + } + else + { + randomRotation = randomFloat3Range(randoPoint, float(90)); + } + float3 norm = poiMesh.normals[0]; + + float3 glitterReflectionDirection = normalize(mul(poiRotationMatrixFromAngles(randomRotation), norm)); + finalGlitter = lerp(0, float(0) * glitterAlpha, glitterAlpha) + max(pow(saturate(dot(lerp(glitterReflectionDirection, poiCam.viewDir, float(0.8)), poiCam.viewDir)), float(300)), 0); + finalGlitter *= glitterAlpha; + break; + case 1: + float offset = random(randoPoint); + float brightness = sin((_Time.x + offset) * float(10)) * float(20) - (float(20) - 1); + finalGlitter = max(float(0) * glitterAlpha, brightness * glitterAlpha * smoothstep(0, 1, 1 - m_dist * float(0.08) * 10)); + break; + } + + + half3 glitterColor = float4(1,1,1,1); + glitterColor *= lerp(1, albedo, float(0)); + #if defined(PROP_GLITTERCOLORMAP) || !defined(OPTIMIZER_ENABLED) + glitterColor *= POI2D_SAMPLER_PAN(_GlitterColorMap, _MainTex, poiMesh.uv[float(0)], float4(0,0,0,0)).rgb; + #endif + float2 uv = remapClamped(dank, -size, size, 0, 1); + + if(float(0) == 1 || float(0) != 0 && !float(0)) + { + float2 fakeUVCenter = float2(.5, .5); + float randomBoy = 0; + + if(float(0)) + { + randomBoy = random(randoPoint); + } + float theta = radians((randomBoy + _Time.x * float(0)) * 360); + float cs = cos(theta); + float sn = sin(theta); + uv = float2((uv.x - fakeUVCenter.x) * cs - (uv.y - fakeUVCenter.y) * sn + fakeUVCenter.x, (uv.x - fakeUVCenter.x) * sn + (uv.y - fakeUVCenter.y) * cs + fakeUVCenter.y); + } + + #if defined(PROP_GLITTERTEXTURE) || !defined(OPTIMIZER_ENABLED) + float4 glitterTexture = POI2D_SAMPLER_PAN(_GlitterTexture, _MainTex, uv, float4(0,0,0,0)); + #else + float4 glitterTexture = 1; + #endif + //float4 glitterTexture = _GlitterTexture.SampleGrad(sampler_MainTex, frac(uv), ddx(uv), ddy(uv)); + glitterColor *= glitterTexture.rgb; + #if defined(PROP_GLITTERMASK) || !defined(OPTIMIZER_ENABLED) + float glitterMask = POI2D_SAMPLER_PAN(_GlitterMask, _MainTex, poiMesh.uv[float(0)], float4(0,0,0,0)); + #else + float glitterMask = 1; + #endif + + glitterMask *= lerp(1, poiLight.rampedLightMap, float(0)); + + #ifdef POI_BLACKLIGHT + if (float(4) != 4) + { + glitterMask *= blackLightMask[float(4)]; + } + #endif + + if(float(0)) + { + glitterColor *= RandomColorFromPoint(random2(randoPoint.x + randoPoint.y)); + } + + + if(float(0)) + { + glitterColor.rgb = hueShift(glitterColor.rgb, float(0) + _Time.x * float(0)); + } + + + if(float(0) == 1) + { + albedo.rgb = lerp(albedo.rgb, finalGlitter * glitterColor * float(3), finalGlitter * glitterTexture.a * glitterMask); + glitterEmission = finalGlitter * glitterColor * max(0, (float(3) - 1) * glitterTexture.a) * glitterMask; + } + else + { + glitterEmission = finalGlitter * glitterColor * float(3) * glitterTexture.a * glitterMask; + } + } + +#endif diff --git a/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_PoiGlitter.cginc.meta b/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_PoiGlitter.cginc.meta new file mode 100644 index 00000000..d9ba6bdf --- /dev/null +++ b/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_PoiGlitter.cginc.meta @@ -0,0 +1,9 @@ +fileFormatVersion: 2 +guid: 1673dcffcf570d047af4ec18e4dd3801 +ShaderImporter: + externalObjects: {} + defaultTextures: [] + nonModifiableTextures: [] + userData: + assetBundleName: + assetBundleVariant: diff --git a/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_PoiGrab.cginc b/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_PoiGrab.cginc new file mode 100644 index 00000000..87ffca25 --- /dev/null +++ b/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_PoiGrab.cginc @@ -0,0 +1,125 @@ +#ifndef POI_GRAB + #define POI_GRAB + + float _RefractionIndex; + float _RefractionOpacity; + float _RefractionChromaticAberattion; + float _RefractionEnabled; + float _GrabSrcBlend; + float _GrabDstBlend; + float _GrabPassUseAlpha; + float _GrabPassBlendFactor; + float _GrabBlurDistance; + float _GrabBlurQuality; + float _GrabBlurDirections; + POI_TEXTURE_NOSAMPLER(_GrabPassBlendMap); + + float4 blur(float2 uv) + { + float two_pi = 6.28318530718; + + float2 radius = float(0) / _ScreenParams.xy * 100; // Arbitrary constant to match old blur + float quality = floor(float(2)); + float directions = floor(float(4)); + + // Pixel colour + float4 color = tex2D(_PoiGrab, uv); + + float deltaAngle = two_pi / directions; + float deltaQuality = 1.0 / quality; + for (int i = 0; i < directions; i ++) + { + for (int j = 0; j < quality; j ++) + { + float angle = deltaAngle * i + j; + float offset = deltaQuality * (j + 1); + color += tex2D(_PoiGrab, uv + float2(cos(angle), sin(angle)) * radius * offset); + } + } + + // Output to screen + color /= quality * directions + 1; + return color; + } + + inline float4 Refraction(float indexOfRefraction, float chromaticAberration, float2 projectedGrabPos) + { + float4 refractionColor; + float3 worldViewDir = normalize(UnityWorldSpaceViewDir(poiMesh.worldPos)); + float3 refractionOffset = ((((indexOfRefraction - 1.0) * mul(UNITY_MATRIX_V, float4(poiMesh.normals[1], 0.0)).xyz) * (1.0 / (poiCam.grabPos.z + 1.0))) * (1.0 - dot(poiMesh.normals[1], worldViewDir))); + float2 cameraRefraction = float2(refractionOffset.x, - (refractionOffset.y * _ProjectionParams.x)); + + + if (float(0) > 0) + { + float4 redAlpha = tex2D(_PoiGrab, (projectedGrabPos + cameraRefraction)); + float green = tex2D(_PoiGrab, (projectedGrabPos + (cameraRefraction * (1.0 - chromaticAberration)))).g; + float blue = tex2D(_PoiGrab, (projectedGrabPos + (cameraRefraction * (1.0 + chromaticAberration)))).b; + refractionColor = float4(redAlpha.r, green, blue, redAlpha.a); + } + else + { + float2 refractedGrab = projectedGrabPos + cameraRefraction; + + #ifdef CHROMATIC_ABERRATION_LOW + refractionColor = blur(refractedGrab); + #else + refractionColor = tex2D(_PoiGrab, (refractedGrab)); + #endif + } + return refractionColor; + } + + void calculateRefraction(float2 projectedGrabPos, inout float4 finalColor) + { + float3 refraction = 1; + + if(float(0) == 1) + { + refraction = Refraction(float(1.333333), float(0), projectedGrabPos).rgb; + } + else + { + #ifdef CHROMATIC_ABERRATION_LOW + refraction = blur(projectedGrabPos); + #else + refraction = tex2Dproj(_PoiGrab, poiCam.grabPos).rgb; + #endif + } + + float blendFactor = float(1) * POI2D_SAMPLER_PAN(_GrabPassBlendMap, _MainTex, poiMesh.uv[float(0)], float4(0,0,0,0)).r; + + if(float(1)) + { + finalColor = poiBlend(float(2), finalColor, float(0), float4(refraction, 1), blendFactor * (1 - finalColor.a)); + finalColor.a = 1; + } + else + { + finalColor = poiBlend(float(2), finalColor, float(0), float4(refraction, 1), blendFactor); + } + } + + float2 calculateGrabPosition() + { + float4 grabPos = poiCam.grabPos; + #if UNITY_UV_STARTS_AT_TOP + float scale = -1.0; + #else + float scale = 1.0; + #endif + float halfPosW = grabPos.w * 0.5; + grabPos.y = (grabPos.y - halfPosW) * _ProjectionParams.x * scale + halfPosW; + #if SHADER_API_D3D9 || SHADER_API_D3D11 + grabPos.w += 0.00000000001; + #endif + return(grabPos / grabPos.w).xy; + } + + void applyGrabEffects(inout float4 finalColor) + { + float2 projectedGrabPos = calculateGrabPosition(); + calculateRefraction(projectedGrabPos, finalColor); + } + +#endif diff --git a/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_PoiGrab.cginc.meta b/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_PoiGrab.cginc.meta new file mode 100644 index 00000000..a6a4c04b --- /dev/null +++ b/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_PoiGrab.cginc.meta @@ -0,0 +1,9 @@ +fileFormatVersion: 2 +guid: 32b1c88b62978a447830f3d459194337 +ShaderImporter: + externalObjects: {} + defaultTextures: [] + nonModifiableTextures: [] + userData: + assetBundleName: + assetBundleVariant: diff --git a/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_PoiHelpers.cginc b/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_PoiHelpers.cginc new file mode 100644 index 00000000..45ad457a --- /dev/null +++ b/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_PoiHelpers.cginc @@ -0,0 +1,336 @@ +#ifndef POI_HELPER + #define POI_HELPER + + #ifndef pi + #define pi float(3.14159265359) + #endif + + float linearSin(float x) + { + return pow(min(cos(pi * x / 2.0), 1.0 - abs(x)), 1.0); + } + + float random(float2 p) + { + return frac(sin(dot(p, float2(12.9898, 78.2383))) * 43758.5453123); + } + + float2 random2(float2 p) + { + return frac(sin(float2(dot(p, float2(127.1, 311.7)), dot(p, float2(269.5, 183.3)))) * 43758.5453); + } + + float3 random3(float3 p) + { + return frac(sin(float3(dot(p, float3(127.1, 311.7, 248.6)), dot(p, float3(269.5, 183.3, 423.3)), dot(p, float3(248.3, 315.9, 184.2)))) * 43758.5453); + } + + float3 mod(float3 x, float y) + { + return x - y * floor(x / y); + } + float2 mod(float2 x, float y) + { + return x - y * floor(x / y); + } + + //1/7 + #define K 0.142857142857 + //3/7 + #define Ko 0.428571428571 + + // Permutation polynomial: (34x^2 + x) mod 289 + float3 Permutation(float3 x) + { + return mod((34.0 * x + 1.0) * x, 289.0); + } + + bool IsInMirror() + { + return unity_CameraProjection[2][0] != 0.f || unity_CameraProjection[2][1] != 0.f; + } + + float3 BoxProjection(float3 direction, float3 position, float4 cubemapPosition, float3 boxMin, float3 boxMax) + { + #if UNITY_SPECCUBE_BOX_PROJECTION + + if (cubemapPosition.w > 0) + { + float3 factors = ((direction > 0 ? boxMax: boxMin) - position) / direction; + float scalar = min(min(factors.x, factors.y), factors.z); + direction = direction * scalar + (position - cubemapPosition.xyz); + } + #endif + return direction; + } + + // Camera + float3 getCameraPosition() + { + #ifdef USING_STEREO_MATRICES + return lerp(unity_StereoWorldSpaceCameraPos[0], unity_StereoWorldSpaceCameraPos[1], 0.5); + #endif + return _WorldSpaceCameraPos; + } + + float3 getCameraForward() + { + #if UNITY_SINGLE_PASS_STEREO + float3 p1 = mul(unity_StereoCameraToWorld[0], float4(0, 0, 1, 1)); + float3 p2 = mul(unity_StereoCameraToWorld[0], float4(0, 0, 0, 1)); + #else + float3 p1 = mul(unity_CameraToWorld, float4(0, 0, 1, 1)).xyz; + float3 p2 = mul(unity_CameraToWorld, float4(0, 0, 0, 1)).xyz; + #endif + return normalize(p2 - p1); + } + + float3 grayscale_vector_node() + { + return float3(0, 0.3823529, 0.01845836); + } + + float3 grayscale_for_light() + { + return float3(0.298912, 0.586611, 0.114478); + } + + //Math Operators + + float remap(float x, float minOld, float maxOld, float minNew, float maxNew) + { + return minNew + (x - minOld) * (maxNew - minNew) / (maxOld - minOld); + } + + float2 remap(float2 x, float2 minOld, float2 maxOld, float2 minNew, float2 maxNew) + { + return minNew + (x - minOld) * (maxNew - minNew) / (maxOld - minOld); + } + + float3 remap(float3 x, float3 minOld, float3 maxOld, float3 minNew, float3 maxNew) + { + return minNew + (x - minOld) * (maxNew - minNew) / (maxOld - minOld); + } + + float4 remap(float4 x, float4 minOld, float4 maxOld, float4 minNew, float4 maxNew) + { + return minNew + (x - minOld) * (maxNew - minNew) / (maxOld - minOld); + } + + float remapClamped(float x, float minOld, float maxOld, float minNew, float maxNew) + { + return clamp(minNew + (x - minOld) * (maxNew - minNew) / (maxOld - minOld), minNew, maxNew); + } + + float2 remapClamped(float2 x, float2 minOld, float2 maxOld, float2 minNew, float2 maxNew) + { + return clamp(minNew + (x - minOld) * (maxNew - minNew) / (maxOld - minOld), minNew, maxNew); + } + + float3 remapClamped(float3 x, float3 minOld, float3 maxOld, float3 minNew, float3 maxNew) + { + return clamp(minNew + (x - minOld) * (maxNew - minNew) / (maxOld - minOld), minNew, maxNew); + } + + float4 remapClamped(float4 x, float4 minOld, float4 maxOld, float4 minNew, float4 maxNew) + { + return clamp(minNew + (x - minOld) * (maxNew - minNew) / (maxOld - minOld), minNew, maxNew); + } + + float poiMax(float2 i) + { + return max(i.x, i.y); + } + + float poiMax(float3 i) + { + return max(max(i.x, i.y), i.z); + } + + float poiMax(float4 i) + { + return max(max(max(i.x, i.y), i.z), i.w); + } + + float4x4 poiAngleAxisRotationMatrix(float angle, float3 axis) + { + axis = normalize(axis); + float s = sin(angle); + float c = cos(angle); + float oc = 1.0 - c; + + return float4x4(oc * axis.x * axis.x + c, oc * axis.x * axis.y - axis.z * s, oc * axis.z * axis.x + axis.y * s, 0.0, + oc * axis.x * axis.y + axis.z * s, oc * axis.y * axis.y + c, oc * axis.y * axis.z - axis.x * s, 0.0, + oc * axis.z * axis.x - axis.y * s, oc * axis.y * axis.z + axis.x * s, oc * axis.z * axis.z + c, 0.0, + 0.0, 0.0, 0.0, 1.0); + } + + float4x4 poiRotationMatrixFromAngles(float x, float y, float z) + { + float angleX = radians(x); + float c = cos(angleX); + float s = sin(angleX); + float4x4 rotateXMatrix = float4x4(1, 0, 0, 0, + 0, c, -s, 0, + 0, s, c, 0, + 0, 0, 0, 1); + + float angleY = radians(y); + c = cos(angleY); + s = sin(angleY); + float4x4 rotateYMatrix = float4x4(c, 0, s, 0, + 0, 1, 0, 0, + - s, 0, c, 0, + 0, 0, 0, 1); + + float angleZ = radians(z); + c = cos(angleZ); + s = sin(angleZ); + float4x4 rotateZMatrix = float4x4(c, -s, 0, 0, + s, c, 0, 0, + 0, 0, 1, 0, + 0, 0, 0, 1); + + return mul(mul(rotateXMatrix, rotateYMatrix), rotateZMatrix); + } + + float4x4 poiRotationMatrixFromAngles(float3 angles) + { + float angleX = radians(angles.x); + float c = cos(angleX); + float s = sin(angleX); + float4x4 rotateXMatrix = float4x4(1, 0, 0, 0, + 0, c, -s, 0, + 0, s, c, 0, + 0, 0, 0, 1); + + float angleY = radians(angles.y); + c = cos(angleY); + s = sin(angleY); + float4x4 rotateYMatrix = float4x4(c, 0, s, 0, + 0, 1, 0, 0, + - s, 0, c, 0, + 0, 0, 0, 1); + + float angleZ = radians(angles.z); + c = cos(angleZ); + s = sin(angleZ); + float4x4 rotateZMatrix = float4x4(c, -s, 0, 0, + s, c, 0, 0, + 0, 0, 1, 0, + 0, 0, 0, 1); + + return mul(mul(rotateXMatrix, rotateYMatrix), rotateZMatrix); + } + +#endif + +half2 calcScreenUVs(half4 grabPos) +{ + half2 uv = grabPos.xy / (grabPos.w + 0.0000000001); + #if UNITY_SINGLE_PASS_STEREO + uv.xy *= half2(_ScreenParams.x * 2, _ScreenParams.y); + #else + uv.xy *= _ScreenParams.xy; + #endif + + return uv; +} + +float inverseLerp(float A, float B, float T) +{ + return(T - A) / (B - A); +} + +float inverseLerp2(float2 a, float2 b, float2 value) +{ + float2 AB = b - a; + float2 AV = value - a; + return dot(AV, AB) / dot(AB, AB); +} + +float inverseLerp3(float3 a, float3 b, float3 value) +{ + float3 AB = b - a; + float3 AV = value - a; + return dot(AV, AB) / dot(AB, AB); +} + +float inverseLerp4(float4 a, float4 b, float4 value) +{ + float4 AB = b - a; + float4 AV = value - a; + return dot(AV, AB) / dot(AB, AB); +} + +// Dithering +inline half Dither8x8Bayer(int x, int y) +{ + const half dither[ 64 ] = { + 1, 49, 13, 61, 4, 52, 16, 64, + 33, 17, 45, 29, 36, 20, 48, 32, + 9, 57, 5, 53, 12, 60, 8, 56, + 41, 25, 37, 21, 44, 28, 40, 24, + 3, 51, 15, 63, 2, 50, 14, 62, + 35, 19, 47, 31, 34, 18, 46, 30, + 11, 59, 7, 55, 10, 58, 6, 54, + 43, 27, 39, 23, 42, 26, 38, 22 + }; + int r = y * 8 + x; + return dither[r] / 64; +} + +// UV Manipulation +float2 TransformUV(half2 offset, half rotation, half2 scale, float2 uv) +{ + float theta = radians(rotation); + scale = 1 - scale; + float cs = cos(theta); + float sn = sin(theta); + float2 centerPoint = offset + .5; + uv = float2((uv.x - centerPoint.x) * cs - (uv.y - centerPoint.y) * sn + centerPoint.x, (uv.x - centerPoint.x) * sn + (uv.y - centerPoint.y) * cs + centerPoint.y); + + return remap(uv, float2(0, 0) + offset + (scale * .5), float2(1, 1) + offset - (scale * .5), float2(0, 0), float2(1, 1)); +} + +bool isVR() +{ + // USING_STEREO_MATRICES + #if UNITY_SINGLE_PASS_STEREO + return true; + #else + return false; + #endif +} + +bool isVRHandCamera() +{ + return !isVR() && abs(UNITY_MATRIX_V[0].y) > 0.0000005; +} + +bool isDesktop() +{ + return !isVRHandCamera(); +} + +bool isVRHandCameraPreview() +{ + return isVRHandCamera() && _ScreenParams.y == 720; +} + +bool isVRHandCameraPicture() +{ + return isVRHandCamera() && _ScreenParams.y == 1080; +} + +bool isPanorama() +{ + // Crude method + // FOV=90=camproj=[1][1] + return unity_CameraProjection[1][1] == 1 && _ScreenParams.x == 1075 && _ScreenParams.y == 1025; +} + +float calculateluminance(float3 color) +{ + return color.r * 0.299 + color.g * 0.587 + color.b * 0.114; +} diff --git a/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_PoiHelpers.cginc.meta b/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_PoiHelpers.cginc.meta new file mode 100644 index 00000000..43d311d9 --- /dev/null +++ b/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_PoiHelpers.cginc.meta @@ -0,0 +1,9 @@ +fileFormatVersion: 2 +guid: f91629cbd1a254f4384e37e0b0781096 +ShaderImporter: + externalObjects: {} + defaultTextures: [] + nonModifiableTextures: [] + userData: + assetBundleName: + assetBundleVariant: diff --git a/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_PoiHologram.cginc b/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_PoiHologram.cginc new file mode 100644 index 00000000..0bd1cab5 --- /dev/null +++ b/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_PoiHologram.cginc @@ -0,0 +1,43 @@ +#ifndef POI_HOLOGRAM + #define POI_HOLOGRAM + + #if defined(PROP_HOLOALPHAMAP) || !defined(OPTIMIZER_ENABLED) + UNITY_DECLARE_TEX2D_NOSAMPLER(_HoloAlphaMap); float4 _HoloAlphaMap_ST; + #endif + float _HoloCoordinateSpace; // 0 World, 1 Local, 2 UV + float3 _HoloDirection; + float _HoloScrollSpeed; + float _HoloLineDensity; + + fixed _HoloFresnelAlpha; + fixed _HoloRimSharpness; + fixed _HoloRimWidth; + void ApplyHoloAlpha(inout float4 color) + { + float uv = 0; + + if (float(0) == 0) + { + uv = dot(normalize(float4(0,1,0,1)), poiMesh.worldPos * float(10)) + _Time.x * float(1); + } + + if(float(0) == 1) + { + uv = dot(normalize(float4(0,1,0,1)), poiMesh.localPos * float(10)) + _Time.x * float(1); + } + + if(float(0) == 2) + { + uv = dot(float4(0,1,0,1), poiMesh.uv[0] * float(10)) + _Time.x * float(1); + } + float holoRim = saturate(1 - smoothstep(min(float(0.5), float(0.5)), float(0.5), poiCam.viewDotNormal)); + holoRim = abs(lerp(1, holoRim, float(0))); + #if defined(PROP_HOLOALPHAMAP) || !defined(OPTIMIZER_ENABLED) + fixed holoAlpha = UNITY_SAMPLE_TEX2D_SAMPLER(_HoloAlphaMap, _MainTex, uv).r; + #else + fixed holoAlpha = 1; + #endif + color.a *= holoAlpha * holoRim; + } + +#endif diff --git a/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_PoiHologram.cginc.meta b/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_PoiHologram.cginc.meta new file mode 100644 index 00000000..25dbbe23 --- /dev/null +++ b/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_PoiHologram.cginc.meta @@ -0,0 +1,9 @@ +fileFormatVersion: 2 +guid: 6f2d091f51996774abb78e895f5efb03 +ShaderImporter: + externalObjects: {} + defaultTextures: [] + nonModifiableTextures: [] + userData: + assetBundleName: + assetBundleVariant: diff --git a/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_PoiIridescence.cginc b/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_PoiIridescence.cginc new file mode 100644 index 00000000..53b2044c --- /dev/null +++ b/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_PoiIridescence.cginc @@ -0,0 +1,77 @@ +#ifndef POI_IRIDESCENCE + #define POI_IRIDESCENCE + #if defined(PROP_IRIDESCENCERAMP) || !defined(OPTIMIZER_ENABLED) + UNITY_DECLARE_TEX2D_NOSAMPLER(_IridescenceRamp); float4 _IridescenceRamp_ST; + #endif + #if defined(PROP_IRIDESCENCEMASK) || !defined(OPTIMIZER_ENABLED) + UNITY_DECLARE_TEX2D_NOSAMPLER(_IridescenceMask); float4 _IridescenceMask_ST; + #endif + #if defined(PROP_IRIDESCENCENORMALMAP) || !defined(OPTIMIZER_ENABLED) + UNITY_DECLARE_TEX2D_NOSAMPLER(_IridescenceNormalMap); float4 _IridescenceNormalMap_ST; + #endif + float _IridescenceNormalUV; + float _IridescenceMaskUV; + float _IridescenceNormalSelection; + float _IridescenceNormalIntensity; + float _IridescenceNormalToggle; + float _IridescenceIntensity; + fixed _IridescenceAddBlend; + fixed _IridescenceReplaceBlend; + fixed _IridescenceMultiplyBlend; + float _IridescenceEmissionStrength; + + //global + #if defined(PROP_IRIDESCENCENORMALMAP) || !defined(OPTIMIZER_ENABLED) + float3 calculateNormal(float3 baseNormal) + { + + float3 normal = UnpackScaleNormal(UNITY_SAMPLE_TEX2D_SAMPLER(_IridescenceNormalMap, _MainTex, TRANSFORM_TEX(poiMesh.uv[float(0)], _IridescenceNormalMap)), float(1)); + return normalize( + normal.x * poiMesh.tangent + + normal.y * poiMesh.binormal + + normal.z * baseNormal + ); + } + #endif + void applyIridescence(inout float4 albedo, inout float3 IridescenceEmission) + { + float3 normal = poiMesh.normals[float(1)]; + + #if defined(PROP_IRIDESCENCENORMALMAP) || !defined(OPTIMIZER_ENABLED) + // Use custom normal map + + if (float(0)) + { + normal = calculateNormal(normal); + } + #endif + + float ndotv = dot(normal, poiCam.viewDir); + + #if defined(PROP_IRIDESCENCERAMP) || !defined(OPTIMIZER_ENABLED) + float4 iridescenceColor = UNITY_SAMPLE_TEX2D_SAMPLER(_IridescenceRamp, _MainTex, 1 - abs(ndotv)); + #else + float4 iridescenceColor = 1; + #endif + + #if defined(PROP_IRIDESCENCEMASK) || !defined(OPTIMIZER_ENABLED) + float4 iridescenceMask = UNITY_SAMPLE_TEX2D_SAMPLER(_IridescenceMask, _MainTex, TRANSFORM_TEX(poiMesh.uv[float(0)], _IridescenceMask)); + #else + float4 iridescenceMask = 1; + #endif + #ifdef POI_BLACKLIGHT + if(float(4) != 4) + { + iridescenceMask *= blackLightMask[float(4)]; + } + #endif + + + albedo.rgb = lerp(albedo.rgb, saturate(iridescenceColor.rgb * float(1)), iridescenceColor.a * float(0) * iridescenceMask); + albedo.rgb += saturate(iridescenceColor.rgb * float(1) * iridescenceColor.a * float(0) * iridescenceMask); + albedo.rgb *= saturate(lerp(1, iridescenceColor.rgb * float(1), iridescenceColor.a * float(0) * iridescenceMask)); + + IridescenceEmission = saturate(iridescenceColor.rgb * float(1)) * iridescenceColor.a * iridescenceMask * float(0); + } + +#endif diff --git a/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_PoiIridescence.cginc.meta b/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_PoiIridescence.cginc.meta new file mode 100644 index 00000000..a846e91d --- /dev/null +++ b/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_PoiIridescence.cginc.meta @@ -0,0 +1,9 @@ +fileFormatVersion: 2 +guid: 98e14302a2e62bd45a454f1dd2c00c07 +ShaderImporter: + externalObjects: {} + defaultTextures: [] + nonModifiableTextures: [] + userData: + assetBundleName: + assetBundleVariant: diff --git a/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_PoiLighting.cginc b/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_PoiLighting.cginc new file mode 100644 index 00000000..e464d812 --- /dev/null +++ b/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_PoiLighting.cginc @@ -0,0 +1,973 @@ + +#ifndef POI_LIGHTING +#define POI_LIGHTING + +float _LightingRampType; +float _LightingIgnoreAmbientColor; +float _UseShadowTexture; +float _LightingEnableAO; +float _LightingDetailShadowsEnabled; + +float _LightingOnlyUnityShadows; +float _LightingMode; +float _ForceLightDirection; +float _ShadowStrength; +float _OutlineShadowStrength; +float _ShadowOffset; +float3 _LightDirection; +float _ForceShadowStrength; +float _CastedShadowSmoothing; +float _AttenuationMultiplier; +float _EnableLighting; +float _LightingControlledUseLightColor; +fixed _LightingStandardSmoothness; +fixed _LightingStandardControlsToon; +fixed _LightingMinLightBrightness; +float _LightingUseShadowRamp; +float _LightingMinShadowBrightnessRatio; +fixed _LightingMonochromatic; + +fixed _LightingGradientStart; +fixed _LightingGradientEnd; +float3 _LightingShadowColor; +float _AOStrength; +fixed _LightingDetailStrength; +fixed _LightingAdditiveDetailStrength; +fixed _LightingNoIndirectMultiplier; +fixed _LightingNoIndirectThreshold; +float _LightingUncapped; + +float _LightingDirectColorMode; +float _LightingIndirectColorMode; +float _LightingAdditiveType; +fixed _LightingAdditiveGradientStart; +fixed _LightingAdditiveGradientEnd; +fixed _LightingAdditivePassthrough; +float _LightingDirectAdjustment; +float _LightingIndirect; +// HSL JUNK +float _LightingEnableHSL; +float _LightingShadowHue; +float _LightingShadowSaturation; +float _LightingShadowLightness; +float _LightingHSLIntensity; +// UTS Style Shade Mapping +float4 _1st_ShadeColor; +float _Use_BaseAs1st; +float4 _2nd_ShadeColor; +float _Use_1stAs2nd; +float _BaseColor_Step; +float _BaseShade_Feather; +float _ShadeColor_Step; +float _1st2nd_Shades_Feather; +float _Use_1stShadeMapAlpha_As_ShadowMask; +float _1stShadeMapMask_Inverse; +float _Tweak_1stShadingGradeMapLevel; +float _Use_2ndShadeMapAlpha_As_ShadowMask; +float _2ndShadeMapMask_Inverse; +float _Tweak_2ndShadingGradeMapLevel; +// Skin +float _SkinScatteringProperties; +float _SssWeight; +float _SssMaskCutoff ; +float _SssBias; +float _SssScale; +float _SssBumpBlur; +float4 _SssTransmissionAbsorption; +float4 _SssColorBleedAoWeights; +/* +UNITY_DECLARE_TEX2D_NOSAMPLER(_ToonRamp3); +half _LightingShadowStrength3; +half _ShadowOffset3; +*/ + +half4 shadowStrength; +sampler2D _SkinLUT; +UNITY_DECLARE_TEX2D(_ToonRamp); +POI_TEXTURE_NOSAMPLER(_1st_ShadeMap); +POI_TEXTURE_NOSAMPLER(_2nd_ShadeMap); +POI_TEXTURE_NOSAMPLER(_LightingDetailShadows); +POI_TEXTURE_NOSAMPLER(_LightingAOTex); +POI_TEXTURE_NOSAMPLER(_LightingShadowMask); + +float3 directLighting; +float3 indirectLighting; +/* +* DJLs code starts here +*/ +float _LightingWrappedWrap; +float _LightingWrappedNormalization; + +// Green’s model with adjustable energy +// http://blog.stevemcauley.com/2011/12/03/energy-conserving-wrapped-diffuse/ +// Modified for adjustable conservation ratio and over-wrap to directionless +float RTWrapFunc(in float dt, in float w, in float norm) +{ + float cw = saturate(w); + + float o = (dt + cw) / ((1.0 + cw) * (1.0 + cw * norm)); + float flt = 1.0 - 0.85 * norm; + if (w > 1.0) + { + o = lerp(o, flt, w - 1.0); + } + return o; +} +float3 GreenWrapSH(float fA) // Greens unoptimized and non-normalized + +{ + float fAs = saturate(fA); + float4 t = float4(fA + 1, fAs - 1, fA - 2, fAs + 1); // DJL edit: allow wrapping to L0-only at w=2 + return float3(t.x, -t.z * t.x / 3, 0.25 * t.y * t.y * t.w); +} +float3 GreenWrapSHOpt(float fW) // optimised and normalized https://blog.selfshadow.com/2012/01/07/righting-wrap-part-2/ + +{ + const float4 t0 = float4(0.0, 1.0 / 4.0, -1.0 / 3.0, -1.0 / 2.0); + const float4 t1 = float4(1.0, 2.0 / 3.0, 1.0 / 4.0, 0.0); + float3 fWs = float3(fW, fW, saturate(fW)); // DJL edit: allow wrapping to L0-only at w=2 + + float3 r; + r.xyz = t0.xxy * fWs + t0.xzw; + r.xyz = r.xyz * fWs + t1.xyz; + return r; +} +float3 ShadeSH9_wrapped(float3 normal, float wrap) +{ + float3 x0, x1, x2; + float3 conv = lerp(GreenWrapSH(wrap), GreenWrapSHOpt(wrap), float(0)); // Should try optimizing this... + conv *= float3(1, 1.5, 4); // Undo pre-applied cosine convolution by using the inverse + + // Constant (L0) + x0 = float3(unity_SHAr.w, unity_SHAg.w, unity_SHAb.w); + // Remove pre-applied constant part from L(2,0) to apply correct convolution + float3 L2_0 = float3(unity_SHBr.z, unity_SHBg.z, unity_SHBb.z) / - 3.0; + x0 -= L2_0; + + // Linear (L1) polynomial terms + x1.r = dot(unity_SHAr.xyz, normal); + x1.g = dot(unity_SHAg.xyz, normal); + x1.b = dot(unity_SHAb.xyz, normal); + + // 4 of the quadratic (L2) polynomials + float4 vB = normal.xyzz * normal.yzzx; + x2.r = dot(unity_SHBr, vB); + x2.g = dot(unity_SHBg, vB); + x2.b = dot(unity_SHBb, vB); + + // Final (5th) quadratic (L2) polynomial + float vC = normal.x * normal.x - normal.y * normal.y; + x2 += unity_SHC.rgb * vC; + // Move back the constant part of L(2,0) + x2 += L2_0; + + return x0 * conv.x + x1 * conv.y + x2 * conv.z; +} + +/* +* MIT License +* +* Copyright (c) 2018 s-ilent +* +* 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. +*/ + +/* +* Silent's code starts here +*/ + +float shEvaluateDiffuseL1Geomerics_local(float L0, float3 L1, float3 n) +{ + // average energy + float R0 = max(0, L0); + + // avg direction of incoming light + float3 R1 = 0.5f * L1; + + // directional brightness + float lenR1 = length(R1); + + // linear angle between normal and direction 0-1 + //float q = 0.5f * (1.0f + dot(R1 / lenR1, n)); + //float q = dot(R1 / lenR1, n) * 0.5 + 0.5; + float q = dot(normalize(R1), n) * 0.5 + 0.5; + q = saturate(q); // Thanks to ScruffyRuffles for the bug identity. + + // power for q + // lerps from 1 (linear) to 3 (cubic) based on directionality + float p = 1.0f + 2.0f * lenR1 / R0; + + // dynamic range constant + // should vary between 4 (highly directional) and 0 (ambient) + float a = (1.0f - lenR1 / R0) / (1.0f + lenR1 / R0); + + return R0 * (a + (1.0f - a) * (p + 1.0f) * pow(q, p)); +} + +half3 BetterSH9(half4 normal) +{ + float3 indirect; + float3 L0 = float3(unity_SHAr.w, unity_SHAg.w, unity_SHAb.w) + float3(unity_SHBr.z, unity_SHBg.z, unity_SHBb.z) / 3.0; + indirect.r = shEvaluateDiffuseL1Geomerics_local(L0.r, unity_SHAr.xyz, normal.xyz); + indirect.g = shEvaluateDiffuseL1Geomerics_local(L0.g, unity_SHAg.xyz, normal.xyz); + indirect.b = shEvaluateDiffuseL1Geomerics_local(L0.b, unity_SHAb.xyz, normal.xyz); + indirect = max(0, indirect); + indirect += SHEvalLinearL2(normal); + return indirect; +} + +float3 BetterSH9(float3 normal) +{ + return BetterSH9(float4(normal, 1)); +} + +/* +* Standard stuff starts here +*/ +UnityLight CreateLight(float3 normal, fixed detailShadowMap) +{ + UnityLight light; + light.dir = poiLight.direction; + light.color = saturate(_LightColor0.rgb * lerp(1, poiLight.attenuation, float(0)) * detailShadowMap); + light.ndotl = DotClamped(normal, poiLight.direction); + return light; +} + +float FadeShadows(float attenuation) +{ + #if HANDLE_SHADOWS_BLENDING_IN_GI || ADDITIONAL_MASKED_DIRECTIONAL_SHADOWS + // UNITY_LIGHT_ATTENUATION doesn't fade shadows for us. + + #if ADDITIONAL_MASKED_DIRECTIONAL_SHADOWS + attenuation = lerp(1, poiLight.attenuation, float(0)); + #endif + + float viewZ = dot(_WorldSpaceCameraPos - poiMesh.worldPos, UNITY_MATRIX_V[2].xyz); + float shadowFadeDistance = UnityComputeShadowFadeDistance(poiMesh.worldPos, viewZ); + float shadowFade = UnityComputeShadowFade(shadowFadeDistance); + float bakedAttenuation = UnitySampleBakedOcclusion(poiMesh.lightmapUV.xy, poiMesh.worldPos); + attenuation = UnityMixRealtimeAndBakedShadows( + attenuation, bakedAttenuation, shadowFade + ); + #endif + + return attenuation; +} + +void ApplySubtractiveLighting(inout UnityIndirect indirectLight) +{ + #if SUBTRACTIVE_LIGHTING + poiLight.attenuation = FadeShadows(lerp(1, poiLight.attenuation, float(0))); + + float ndotl = saturate(dot(i.normal, _WorldSpaceLightPos0.xyz)); + float3 shadowedLightEstimate = ndotl * (1 - poiLight.attenuation) * _LightColor0.rgb; + float3 subtractedLight = indirectLight.diffuse - shadowedLightEstimate; + subtractedLight = max(subtractedLight, unity_ShadowColor.rgb); + subtractedLight = lerp(subtractedLight, indirectLight.diffuse, _LightShadowData.x); + indirectLight.diffuse = min(subtractedLight, indirectLight.diffuse); + #endif +} + +float3 weightedBlend(float3 layer1, float3 layer2, float2 weights) +{ + return(weights.x * layer1 + weights.y * layer2) / (weights.x + weights.y); +} + +UnityIndirect CreateIndirectLight(float3 normal) +{ + UnityIndirect indirectLight; + indirectLight.diffuse = 0; + indirectLight.specular = 0; + + #if defined(FORWARD_BASE_PASS) + #if defined(LIGHTMAP_ON) + indirectLight.diffuse = DecodeLightmap(UNITY_SAMPLE_TEX2D(unity_Lightmap, poiMesh.lightmapUV.xy)); + + #if defined(DIRLIGHTMAP_COMBINED) + float4 lightmapDirection = UNITY_SAMPLE_TEX2D_SAMPLER( + unity_LightmapInd, unity_Lightmap, poiMesh.lightmapUV.xy + ); + indirectLight.diffuse = DecodeDirectionalLightmap( + indirectLight.diffuse, lightmapDirection, normal + ); + #endif + ApplySubtractiveLighting(indirectLight); + #endif + + #if defined(DYNAMICLIGHTMAP_ON) + float3 dynamicLightDiffuse = DecodeRealtimeLightmap( + UNITY_SAMPLE_TEX2D(unity_DynamicLightmap, poiMesh.lightmapUV.zw) + ); + + #if defined(DIRLIGHTMAP_COMBINED) + float4 dynamicLightmapDirection = UNITY_SAMPLE_TEX2D_SAMPLER( + unity_DynamicDirectionality, unity_DynamicLightmap, + poiMesh.lightmapUV.zw + ); + indirectLight.diffuse += DecodeDirectionalLightmap( + dynamicLightDiffuse, dynamicLightmapDirection, normal + ); + #else + indirectLight.diffuse += dynamicLightDiffuse; + #endif + #endif + + #if !defined(LIGHTMAP_ON) && !defined(DYNAMICLIGHTMAP_ON) + #if UNITY_LIGHT_PROBE_PROXY_VOLUME + if (unity_ProbeVolumeParams.x == 1) + { + indirectLight.diffuse = SHEvalLinearL0L1_SampleProbeVolume( + float4(normal, 1), poiMesh.worldPos + ); + indirectLight.diffuse = max(0, indirectLight.diffuse); + #if defined(UNITY_COLORSPACE_GAMMA) + indirectLight.diffuse = LinearToGammaSpace(indirectLight.diffuse); + #endif + } + else + { + indirectLight.diffuse += max(0, ShadeSH9(float4(normal, 1))); + } + #else + indirectLight.diffuse += max(0, ShadeSH9(float4(normal, 1))); + #endif + #endif + + float3 reflectionDir = reflect(-poiCam.viewDir, normal); + Unity_GlossyEnvironmentData envData; + envData.roughness = 1 - float(0); + envData.reflUVW = BoxProjection( + reflectionDir, poiMesh.worldPos.xyz, + unity_SpecCube0_ProbePosition, + unity_SpecCube0_BoxMin.xyz, unity_SpecCube0_BoxMax.xyz + ); + float3 probe0 = Unity_GlossyEnvironment( + UNITY_PASS_TEXCUBE(unity_SpecCube0), unity_SpecCube0_HDR, envData + ); + envData.reflUVW = BoxProjection( + reflectionDir, poiMesh.worldPos.xyz, + unity_SpecCube1_ProbePosition, + unity_SpecCube1_BoxMin.xyz, unity_SpecCube1_BoxMax.xyz + ); + #if UNITY_SPECCUBE_BLENDING + float interpolator = unity_SpecCube0_BoxMin.w; + + if (interpolator < 0.99999) + { + float3 probe1 = Unity_GlossyEnvironment( + UNITY_PASS_TEXCUBE_SAMPLER(unity_SpecCube1, unity_SpecCube0), + unity_SpecCube0_HDR, envData + ); + indirectLight.specular = lerp(probe1, probe0, interpolator); + } + else + { + indirectLight.specular = probe0; + } + #else + indirectLight.specular = probe0; + #endif + float occlusion = 1; + + if (float(0)) + { + occlusion = lerp(1, POI2D_SAMPLER_PAN(_LightingAOTex, _MainTex, poiMesh.uv[float(0)], float4(0,0,0,0)).r, float(1)); + } + + indirectLight.diffuse *= occlusion; + indirectLight.diffuse = max(indirectLight.diffuse, float(0)); + indirectLight.specular *= occlusion; + #endif + + return indirectLight; +} + +/* +* Poiyomi's cool as heck code starts here :smug: +*/ + +half PoiDiffuse(half NdotV, half NdotL, half LdotH) +{ + half fd90 = 0.5 + 2 * LdotH * LdotH * SmoothnessToPerceptualRoughness(.5); + // Two schlick fresnel term + half lightScatter = (1 + (fd90 - 1) * Pow5(1 - NdotL)); + half viewScatter = (1 + (fd90 - 1) * Pow5(1 - NdotV)); + + return lightScatter * viewScatter; +} + +float3 ShadeSH9Indirect() +{ + return ShadeSH9(half4(0.0, -1.0, 0.0, 1.0)); +} + +float3 ShadeSH9Direct() +{ + return ShadeSH9(half4(0.0, 1.0, 0.0, 1.0)); +} + +float3 ShadeSH9Normal(float3 normalDirection) +{ + return ShadeSH9(half4(normalDirection, 1.0)); +} + +half3 GetSHLength() +{ + half3 x, x1; + x.r = length(unity_SHAr); + x.g = length(unity_SHAg); + x.b = length(unity_SHAb); + x1.r = length(unity_SHBr); + x1.g = length(unity_SHBg); + x1.b = length(unity_SHBb); + return x + x1; +} +half3 GetSHDirectionL1() +{ + //float3 grayscale = float3(.3, .59, .11); + float3 grayscale = float3(.33333, .33333, .33333); + half3 r = Unity_SafeNormalize(half3(unity_SHAr.x, unity_SHAr.y, unity_SHAr.z)); + half3 g = Unity_SafeNormalize(half3(unity_SHAg.x, unity_SHAg.y, unity_SHAg.z)); + half3 b = Unity_SafeNormalize(half3(unity_SHAb.x, unity_SHAb.y, unity_SHAb.z)); + return Unity_SafeNormalize(grayscale.r * r + grayscale.g * g + grayscale.b * b); +} +float3 GetSHDirectionL1_() +{ + // For efficiency, we only get the direction from L1. + // Because getting it from L2 would be too hard! + return Unity_SafeNormalize((unity_SHAr.xyz + unity_SHAg.xyz + unity_SHAb.xyz)); +} +// Returns the value from SH in the lighting direction with the +// brightest intensity. +half3 GetSHMaxL1() +{ + float3 maxDirection = GetSHDirectionL1(); + return ShadeSH9_wrapped(maxDirection, 0); +} + + +float3 calculateRealisticLighting(float4 colorToLight, fixed detailShadowMap) +{ + return UNITY_BRDF_PBS(1, 0, 0, float(0), poiMesh.normals[1], poiCam.viewDir, CreateLight(poiMesh.normals[1], detailShadowMap), CreateIndirectLight(poiMesh.normals[1])).xyz; +} + +void calculateBasePassLightMaps() +{ + #if defined(FORWARD_BASE_PASS) || defined(POI_META_PASS) + float AOMap = 1; + float AOStrength = 0; + float3 lightColor = poiLight.color; + /* + * Generate Basic Light Maps + */ + + bool lightExists = false; + if (all(_LightColor0.rgb >= 0.002)) + { + lightExists = true; + } + #ifndef OUTLINE + + if (float(0)) + { + AOMap = POI2D_SAMPLER_PAN(_LightingAOTex, _MainTex, poiMesh.uv[float(0)], float4(0,0,0,0)).r; + AOStrength = float(1); + poiLight.occlusion = lerp(1, AOMap, AOStrength); + } + #ifdef FORWARD_BASE_PASS + //poiLight.color = saturate(_LightColor0.rgb) + saturate(ShadeSH9(normalize(unity_SHAr + unity_SHAg + unity_SHAb))); + if (lightExists) + { + lightColor = _LightColor0.rgb + BetterSH9(float4(0, 0, 0, 1)); + } + else + { + lightColor = max(BetterSH9(normalize(unity_SHAr + unity_SHAg + unity_SHAb)), 0); + } + + //lightColor = magic * magiratio + normalLight * normaRatio; + //lightColor = magic + normalLight; + #endif + #endif + + float3 grayscale_vector = float3(.33333, .33333, .33333); + float3 ShadeSH9Plus = GetSHLength(); + float3 ShadeSH9Minus = float3(unity_SHAr.w, unity_SHAg.w, unity_SHAb.w) + float3(unity_SHBr.z, unity_SHBg.z, unity_SHBb.z) / 3.0; + + shadowStrength = 1; + #ifndef OUTLINE + shadowStrength = POI2D_SAMPLER_PAN(_LightingShadowMask, _MainTex, poiMesh.uv[float(0)], float4(0,0,0,0)) * float(1); + #else + shadowStrength = float(1); + #endif + + float bw_lightColor = dot(lightColor, grayscale_vector); + float bw_directLighting = (((poiLight.nDotL * 0.5 + 0.5) * bw_lightColor * lerp(1, poiLight.attenuation, float(0))) + dot(ShadeSH9Normal(poiMesh.normals[1]), grayscale_vector)); + float bw_bottomIndirectLighting = dot(ShadeSH9Minus, grayscale_vector); + float bw_topIndirectLighting = dot(ShadeSH9Plus, grayscale_vector); + float lightDifference = ((bw_topIndirectLighting + bw_lightColor) - bw_bottomIndirectLighting); + + fixed detailShadow = 1; + + if (float(0)) + { + detailShadow = lerp(1, POI2D_SAMPLER_PAN(_LightingDetailShadows, _MainTex, poiMesh.uv[float(0)], float4(0,0,0,0)), float(1)).r; + } + + if (float(0)) + { + poiLight.lightMap = poiLight.attenuation; + } + else + { + poiLight.lightMap = smoothstep(0, lightDifference, bw_directLighting - bw_bottomIndirectLighting); + } + poiLight.lightMap *= detailShadow; + + /* + * Decide on light colors + */ + + indirectLighting = 0; + directLighting = 0; + + + + + if (float(0) == 1) + { + indirectLighting = BetterSH9(float4(poiMesh.normals[1], 1)); + } + else + { + indirectLighting = ShadeSH9Minus; + } + + poiLight.directLighting = lightColor; + poiLight.indirectLighting = indirectLighting; + + + if (float(0) == 0) + { + float3 magic = max(BetterSH9(normalize(unity_SHAr + unity_SHAg + unity_SHAb)), 0); + float3 normalLight = _LightColor0.rgb + BetterSH9(float4(0, 0, 0, 1)); + + float magiLumi = calculateluminance(magic); + float normaLumi = calculateluminance(normalLight); + float maginormalumi = magiLumi + normaLumi; + + float magiratio = magiLumi / maginormalumi; + float normaRatio = normaLumi / maginormalumi; + + float target = calculateluminance(magic * magiratio + normalLight * normaRatio); + float3 properLightColor = magic * AOMap + normalLight; + float properLuminance = calculateluminance(magic + normalLight); + directLighting = properLightColor * max(0.0001, (target / properLuminance)); + } + else + { + if (lightExists) + { + directLighting = _LightColor0.rgb + BetterSH9(float4(0, 0, 0, 1)) * AOMap; + } + else + { + directLighting = max(BetterSH9(normalize(unity_SHAr + unity_SHAg + unity_SHAb)), 0); + } + } + + + if (!float(0)) + { + float directluminance = calculateluminance(directLighting); + float indirectluminance = calculateluminance(indirectLighting); + directLighting = min(directLighting, directLighting / max(0.0001, (directluminance / 1))); + indirectLighting = min(indirectLighting, indirectLighting / max(0.0001, (indirectluminance / 1))); + } + + directLighting = lerp(directLighting, dot(directLighting, float3(0.299, 0.587, 0.114)), float(0)); + indirectLighting = lerp(indirectLighting, dot(indirectLighting, float3(0.299, 0.587, 0.114)), float(0)); + + if (max(max(indirectLighting.x, indirectLighting.y), indirectLighting.z) <= _LightingNoIndirectThreshold && max(max(directLighting.x, directLighting.y), directLighting.z) >= 0) + { + indirectLighting = directLighting * _LightingNoIndirectMultiplier; + } + + + if (float(0)) + { + float directluminance = clamp(directLighting.r * 0.299 + directLighting.g * 0.587 + directLighting.b * 0.114, 0, 1); + if (directluminance > 0) + { + indirectLighting = max(0.001, indirectLighting); + } + float indirectluminance = clamp(indirectLighting.r * 0.299 + indirectLighting.g * 0.587 + indirectLighting.b * 0.114, 0, 1); + float targetluminance = directluminance * float(0); + if (indirectluminance < targetluminance) + { + indirectLighting = indirectLighting / max(0.0001, indirectluminance / targetluminance); + } + } + + poiLight.rampedLightMap = 1 - smoothstep(0, .5, 1 - poiLight.lightMap); + poiLight.finalLighting = directLighting; + + /* + * Create Gradiant Maps + */ + switch(float(0)) + { + case 0: // Ramp Texture + + { + poiLight.rampedLightMap = lerp(1, UNITY_SAMPLE_TEX2D(_ToonRamp, poiLight.lightMap + float(0)).rgb, shadowStrength.r); + + if (float(0)) + { + poiLight.finalLighting = lerp(poiLight.rampedLightMap * directLighting * lerp(1, AOMap, AOStrength), directLighting, poiLight.rampedLightMap); + } + else + { + poiLight.finalLighting = lerp(indirectLighting * lerp(1, AOMap, AOStrength), directLighting, poiLight.rampedLightMap); + } + } + break; + case 1: // Math Gradient + + { + poiLight.rampedLightMap = saturate(1 - smoothstep(float(0) - .000001, float(0.5), 1 - poiLight.lightMap)); + float3 shadowColor = float4(1,1,1,1); + + if (_UseShadowTexture) + { + shadowColor = 1; + } + + if (float(0)) + { + poiLight.finalLighting = lerp((directLighting * shadowColor * lerp(1, AOMap, AOStrength)), (directLighting), saturate(poiLight.rampedLightMap + 1 - float(1))); + } + else + { + poiLight.finalLighting = lerp((indirectLighting * shadowColor * lerp(1, AOMap, AOStrength)), (directLighting), saturate(poiLight.rampedLightMap + 1 - float(1))); + } + } + break; + case 2: + { + poiLight.rampedLightMap = saturate(1 - smoothstep(0, .5, 1 - poiLight.lightMap)); + poiLight.finalLighting = directLighting; + } + break; + } + + // DJL stuff + if (float(4) == 2) // Wrapped + + { + float wrap = float(0); + + float3 directcolor = (_LightColor0.rgb) * saturate(RTWrapFunc(poiLight.nDotL, wrap, float(0))); + float directatten = lerp(1, poiLight.attenuation, float(0)); + + uint normalsindex = float(0) > 0 ? 1: 0; + // if (float(0) == 1) + // { + // surfnormals = poiMesh.normals[1]; + // } + // else + // { + // surfnormals = poiMesh.normals[0]; + // } + float3 envlight = ShadeSH9_wrapped(poiMesh.normals[normalsindex], wrap); + envlight *= lerp(1, AOMap, AOStrength); + + poiLight.directLighting = directcolor * detailShadow * directatten; + poiLight.indirectLighting = envlight; + + float3 ShadeSH9Plus_2 = GetSHMaxL1(); + float bw_topDirectLighting_2 = dot(_LightColor0.rgb, grayscale_vector); + float bw_directLighting = dot(poiLight.directLighting, grayscale_vector); + float bw_indirectLighting = dot(poiLight.indirectLighting, grayscale_vector); + float bw_topIndirectLighting = dot(ShadeSH9Plus_2, grayscale_vector); + + //poiLight.lightMap = saturate(dot(poiLight.indirectLighting + poiLight.directLighting, grayscale_vector)); + poiLight.lightMap = smoothstep(0, bw_topIndirectLighting + bw_topDirectLighting_2, bw_indirectLighting + bw_directLighting); + + poiLight.rampedLightMap = 1; + + if (float(0) == 0) // Ramp Texture + + { + poiLight.rampedLightMap = lerp(1, UNITY_SAMPLE_TEX2D(_ToonRamp, poiLight.lightMap + float(0)).rgb, shadowStrength.r); + } + else if (float(0) == 1) // Math Gradient + + { + poiLight.rampedLightMap = lerp(float4(1,1,1,1) * lerp(poiLight.indirectLighting, 1, float(0)), float3(1, 1, 1), saturate(1 - smoothstep(float(0) - .000001, float(0.5), 1 - poiLight.lightMap))); + poiLight.rampedLightMap = lerp(float3(1, 1, 1), poiLight.rampedLightMap, shadowStrength.r); + } + + poiLight.finalLighting = (poiLight.indirectLighting + poiLight.directLighting) * saturate(poiLight.rampedLightMap + 1 - float(1)); + } + + if (!float(0)) + { + poiLight.finalLighting = saturate(poiLight.finalLighting); + } + //poiLight.finalLighting *= .8; + #endif + } + + /* + void applyShadowTexture(inout float4 albedo) + { + + if (_UseShadowTexture && float(0) == 1) + { + albedo.rgb = lerp(albedo.rgb, POI2D_SAMPLER_PAN(_LightingShadowTexture, _MainTex, poiMesh.uv[_LightingShadowTextureUV], _LightingShadowTexturePan) * float4(1,1,1,1), (1 - poiLight.rampedLightMap) * shadowStrength); + } + } + */ + + float3 calculateNonImportantLighting(float attenuation, float attenuationDotNL, float3 albedo, float3 lightColor, half dotNL, half correctedDotNL) + { + fixed detailShadow = 1; + + if (float(0)) + { + detailShadow = lerp(1, POI2D_SAMPLER_PAN(_LightingDetailShadows, _MainTex, poiMesh.uv[float(0)], float4(0,0,0,0)), float(1)).r; + } + + if (float(1) == 0) + { + return lightColor * attenuationDotNL * detailShadow; // Realistic + + } + else if (float(1) == 1) // Toon + + { + return lerp(lightColor * attenuation, lightColor * float(0.5) * attenuation, smoothstep(float(0), float(0.5), dotNL)) * detailShadow; + } + else //if(float(1) == 2) // Wrapped + + { + float uv = saturate(RTWrapFunc(-dotNL, float(0), float(0))) * detailShadow; + + poiLight.rampedLightMap = 1; + if (float(0) == 1) // Math Gradient + poiLight.rampedLightMap = lerp(float4(1,1,1,1), float3(1, 1, 1), saturate(1 - smoothstep(float(0) - .000001, float(0.5), 1 - uv))); + // TODO: ramp texture or full shade/tint map for atlasing + + return lightColor * poiLight.rampedLightMap * saturate(attenuation * uv); + } + } + + void applyShadeMaps(inout float4 albedo) + { + + if (float(0) == 2) + { + float3 baseColor = albedo.rgb; + + float MainColorFeatherStep = float(0.5) - float(0.0001); + float firstColorFeatherStep = float(0) - float(0.0001); + + #if defined(PROP_1ST_SHADEMAP) || !defined(OPTIMIZER_ENABLED) + float4 firstShadeMap = POI2D_SAMPLER_PAN(_1st_ShadeMap, _MainTex, poiMesh.uv[float(0)], float4(0,0,0,0)); + #else + float4 firstShadeMap = float4(1, 1, 1, 1); + #endif + firstShadeMap = lerp(firstShadeMap, albedo, float(0)); + firstShadeMap.rgb *= float4(1,1,1,1).rgb; //* lighColor + + #if defined(PROP_2ND_SHADEMAP) || !defined(OPTIMIZER_ENABLED) + float4 secondShadeMap = POI2D_SAMPLER_PAN(_2nd_ShadeMap, _MainTex, poiMesh.uv[float(0)], float4(0,0,0,0)); + #else + float4 secondShadeMap = float4(1, 1, 1, 1); + #endif + secondShadeMap = lerp(secondShadeMap, firstShadeMap, float(0)); + secondShadeMap.rgb *= float4(1,1,1,1).rgb; //* LightColor; + + + float shadowMask = 1; + shadowMask *= float(0) ?(float(0) ?(1.0 - firstShadeMap.a): firstShadeMap.a): 1; + shadowMask *= float(0) ?(float(0) ?(1.0 - secondShadeMap.a): secondShadeMap.a): 1; + + float mainShadowMask = saturate(1 - ((poiLight.lightMap) - MainColorFeatherStep) / (float(0.5) - MainColorFeatherStep) * (shadowMask)); + float firstSecondShadowMask = saturate(1 - ((poiLight.lightMap) - firstColorFeatherStep) / (float(0) - firstColorFeatherStep) * (shadowMask)); + + #if defined(PROP_LIGHTINGSHADOWMASK) || !defined(OPTIMIZER_ENABLED) + float removeShadow = POI2D_SAMPLER_PAN(_LightingShadowMask, _MainTex, poiMesh.uv[float(0)], float4(0,0,0,0)).r; + #else + float removeShadow = 1; + #endif + mainShadowMask *= removeShadow; + firstSecondShadowMask *= removeShadow; + + albedo.rgb = lerp(albedo.rgb, lerp(firstShadeMap.rgb, secondShadeMap.rgb, firstSecondShadowMask), mainShadowMask); + } + } + + float3 calculateFinalLighting(inout float3 albedo, float4 finalColor) + { + float3 finalLighting = 1; + // Additive Lighting + #ifdef FORWARD_ADD_PASS + fixed detailShadow = 1; + + if (float(0)) + { + detailShadow = lerp(1, POI2D_SAMPLER_PAN(_LightingDetailShadows, _MainTex, poiMesh.uv[float(0)], float4(0,0,0,0)), float(1)).r; + } + + if (float(1) == 0) // Realistic + + { + finalLighting = poiLight.color * poiLight.attenuation * max(0, poiLight.nDotL) * detailShadow; + } + else if (float(1) == 1) // Toon + + { + #if defined(POINT) || defined(SPOT) + finalLighting = lerp(poiLight.color * max(poiLight.additiveShadow, float(0.5)), poiLight.color * float(0.5), smoothstep(float(0), float(0.5), 1 - (.5 * poiLight.nDotL + .5))) * poiLight.attenuation * detailShadow; + #else + finalLighting = lerp(poiLight.color * max(poiLight.attenuation, float(0.5)), poiLight.color * float(0.5), smoothstep(float(0), float(0.5), 1 - (.5 * poiLight.nDotL + .5))) * detailShadow; + #endif + } + else //if(float(1) == 2) // Wrapped + + { + float uv = saturate(RTWrapFunc(poiLight.nDotL, float(0), float(0))) * detailShadow; + + poiLight.rampedLightMap = 1; + + if (float(0) == 1) // Math Gradient + poiLight.rampedLightMap = lerp(float4(1,1,1,1), float3(1, 1, 1), saturate(1 - smoothstep(float(0) - .000001, float(0.5), 1 - uv))); + // TODO: ramp texture or full shade/tint map for atlasing + //poiLight.rampedLightMap = lerp(1, UNITY_SAMPLE_TEX2D(_ToonRamp, float2(uv + float(0), 1)), shadowStrength.r); + + float shadowatten = max(poiLight.additiveShadow, float(0.5)); + return poiLight.color * poiLight.rampedLightMap * saturate(poiLight.attenuation * uv * shadowatten); + } + #endif + + // Base and Meta Lighting + #if defined(FORWARD_BASE_PASS) || defined(POI_META_PASS) + #ifdef VERTEXLIGHT_ON + poiLight.vFinalLighting = 0; + + for (int index = 0; index < 4; index++) + { + poiLight.vFinalLighting += calculateNonImportantLighting(poiLight.vAttenuation[index], poiLight.vAttenuationDotNL[index], albedo, poiLight.vColor[index], poiLight.vDotNL[index], poiLight.vCorrectedDotNL[index]); + } + #endif + + switch(float(4)) + { + case 0: // Toon Lighting + case 2: // or wrapped + + { + // HSL Shading + + if (float(0)) + { + float3 HSLMod = float3(float(0.5) * 2 - 1, float(0.5) * 2 - 1, float(0.5) * 2 - 1) * (1 - poiLight.rampedLightMap); + albedo = lerp(albedo.rgb, ModifyViaHSL(albedo.rgb, HSLMod), float(1)); + } + + // Normal Shading + + if (float(0) > 0) + { + poiLight.finalLighting = max(0.001, poiLight.finalLighting); + float finalluminance = calculateluminance(poiLight.finalLighting); + finalLighting = max(poiLight.finalLighting, poiLight.finalLighting / max(0.0001, (finalluminance / float(0)))); + } + else + { + finalLighting = poiLight.finalLighting; + } + } + break; + case 1: // realistic + + { + fixed detailShadow = 1; + + if (float(0)) + { + detailShadow = lerp(1, POI2D_SAMPLER_PAN(_LightingDetailShadows, _MainTex, poiMesh.uv[float(0)], float4(0,0,0,0)), float(1)).r; + } + + float3 realisticLighting = calculateRealisticLighting(finalColor, detailShadow).rgb; + finalLighting = lerp(realisticLighting, dot(realisticLighting, float3(0.299, 0.587, 0.114)), float(0)); + } + break; + case 3: // Skin + + { + float subsurfaceShadowWeight = 0.0h; + float3 ambientNormalWorld = poiMesh.normals[1];//aTangentToWorld(s, s.blurredNormalTangent); + + // Scattering mask. + float subsurface = 1; + float skinScatteringMask = _SssWeight * saturate(1.0h / _SssMaskCutoff * subsurface); + float skinScattering = saturate(subsurface * float(1) * 2 + _SssBias); + + // Skin subsurface depth absorption tint. + // cf http://www.crytek.com/download/2014_03_25_CRYENGINE_GDC_Schultz.pdf pg 35 + half3 absorption = exp((1.0h - subsurface) * float4(-8,-40,-64,0).rgb); + + // Albedo scale for absorption assumes ~0.5 luminance for Caucasian skin. + absorption *= saturate(finalColor.rgb * unity_ColorSpaceDouble.rgb); + + // Blurred normals for indirect diffuse and direct scattering. + ambientNormalWorld = normalize(lerp(poiMesh.normals[1], ambientNormalWorld, float(0.7))); + + float ndlBlur = dot(poiMesh.normals[1], poiLight.direction) * 0.5h + 0.5h; + float lumi = dot(poiLight.color, half3(0.2126h, 0.7152h, 0.0722h)); + float4 sssLookupUv = float4(ndlBlur, skinScattering * lumi, 0.0f, 0.0f); + half3 sss = poiLight.lightMap * poiLight.attenuation * tex2Dlod(_SkinLUT, sssLookupUv).rgb; + finalLighting = min(lerp(indirectLighting * float4(1,1,1,1), float4(1,1,1,1), float(0)) + (sss * directLighting), directLighting); + } + break; + case 4: + { + finalLighting = directLighting; + } + break; + } + #endif + return finalLighting; + } + + + void applyLighting(inout float4 finalColor, float3 finalLighting) + { + #ifdef VERTEXLIGHT_ON + finalColor.rgb *= finalLighting + poiLight.vFinalLighting; + #else + //finalColor.rgb = blendSoftLight(finalColor.rgb, finalLighting); + //finalColor.rgb *= saturate(poiLight.directLighting); + finalColor.rgb *= finalLighting; + #endif + } + #endif diff --git a/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_PoiLighting.cginc.meta b/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_PoiLighting.cginc.meta new file mode 100644 index 00000000..a3be0d2b --- /dev/null +++ b/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_PoiLighting.cginc.meta @@ -0,0 +1,9 @@ +fileFormatVersion: 2 +guid: b83dba56032cbcc49b0f27ec45fa17b3 +ShaderImporter: + externalObjects: {} + defaultTextures: [] + nonModifiableTextures: [] + userData: + assetBundleName: + assetBundleVariant: diff --git a/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_PoiMSDF.cginc b/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_PoiMSDF.cginc new file mode 100644 index 00000000..c23736df --- /dev/null +++ b/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_PoiMSDF.cginc @@ -0,0 +1,243 @@ +#ifndef POI_MSDF + #define POI_MSDF + + sampler2D _TextGlyphs; + float4 _TextGlyphs_ST; + float4 _TextGlyphs_TexelSize; + float _TextFPSUV; + float _TextTimeUV; + float _TextPositionUV; + float _TextPixelRange; + + float _TextFPSEnabled; + float _TextPositionEnabled; + float _TextTimeEnabled; + + + float4 _TextFPSColor; + half _TextFPSEmissionStrength; + fixed4 _TextFPSPadding; + half2 _TextFPSOffset; + half2 _TextFPSScale; + half _TextFPSRotation; + + fixed _TextPositionVertical; + float4 _TextPositionColor; + half _TextPositionEmissionStrength; + fixed4 _TextPositionPadding; + half2 _TextPositionOffset; + half2 _TextPositionScale; + half _TextPositionRotation; + + float4 _TextTimeColor; + half _TextTimeEmissionStrength; + fixed4 _TextTimePadding; + half2 _TextTimeOffset; + half2 _TextTimeScale; + half _TextTimeRotation; + + #define glyphWidth 0.0625 + + #define ASCII_LEFT_PARENTHESIS 40 + #define ASCII_RIGHT_PARENTHESIS 41 + #define ASCII_POSITIVE 43 + #define ASCII_PERIOD 46 + #define ASCII_NEGATIVE 45 + #define ASCII_COMMA 44 + #define ASCII_E 69 + #define ASCII_F 70 + #define ASCII_I 73 + #define ASCII_M 77 + #define ASCII_O 79 + #define ASCII_P 80 + #define ASCII_S 83 + #define ASCII_T 54 + #define ASCII_SEMICOLON 58 + + float3 globalTextEmission; + + half2 getAsciiCoordinate(float index) + { + return half2((index - 1) / 16, 1 - ((floor(index / 16 - glyphWidth)) / 16)); + } + + float median(float r, float g, float b) + { + return max(min(r, g), min(max(r, g), b)); + } + + void ApplyPositionText(inout float4 albedo, float2 uv) + { + float3 cameraPos = clamp(getCameraPosition(), -999, 999); + float3 absCameraPos = abs(cameraPos); + float totalCharacters = 20; + float positionArray[20]; + positionArray[0] = cameraPos.x >= 0 ? ASCII_NEGATIVE: ASCII_POSITIVE; + positionArray[1] = floor((absCameraPos.x * .01) % 10) + 48; + positionArray[2] = floor((absCameraPos.x * .1) % 10) + 48; + positionArray[3] = floor(absCameraPos.x % 10) + 48; + positionArray[4] = ASCII_PERIOD; + positionArray[5] = floor((absCameraPos.x * 10) % 10) + 48; + positionArray[6] = ASCII_COMMA; + positionArray[7] = cameraPos.y >= 0 ? ASCII_NEGATIVE: ASCII_POSITIVE; + positionArray[8] = floor((absCameraPos.y * .01) % 10) + 48; + positionArray[9] = floor((absCameraPos.y * .1) % 10) + 48; + positionArray[10] = floor(absCameraPos.y % 10) + 48; + positionArray[11] = ASCII_PERIOD; + positionArray[12] = floor((absCameraPos.y * 10) % 10) + 48; + positionArray[13] = ASCII_COMMA; + positionArray[14] = cameraPos.z >= 0 ? ASCII_NEGATIVE: ASCII_POSITIVE; + positionArray[15] = floor((absCameraPos.z * .01) % 10) + 48; + positionArray[16] = floor((absCameraPos.z * .1) % 10) + 48; + positionArray[17] = floor(absCameraPos.z % 10) + 48; + positionArray[18] = ASCII_PERIOD; + positionArray[19] = floor((absCameraPos.z * 10) % 10) + 48; + + uv = TransformUV(float4(0,0,0,0), float(0), float4(1,1,1,1), uv); + + if (uv.x > 1 || uv.x < 0 || uv.y > 1 || uv.y < 0) + { + return; + } + + float currentCharacter = floor(uv.x * totalCharacters); + half2 glyphPos = getAsciiCoordinate(positionArray[currentCharacter]); + + float2 startUV = float2(1 / totalCharacters * currentCharacter, 0); + float2 endUV = float2(1 / totalCharacters * (currentCharacter + 1), 1); + + fixed4 textPositionPadding = float4(0,0,0,0); + textPositionPadding *= 1 / totalCharacters; + uv = remapClamped(uv, startUV, endUV, float2(glyphPos.x + textPositionPadding.x, glyphPos.y - glyphWidth + textPositionPadding.y), float2(glyphPos.x + glyphWidth - textPositionPadding.z, glyphPos.y - textPositionPadding.w)); + + if (uv.x > glyphPos.x + glyphWidth - textPositionPadding.z - .001 || uv.x < glyphPos.x + textPositionPadding.x + .001 || uv.y > glyphPos.y - textPositionPadding.w - .001 || uv.y < glyphPos.y - glyphWidth + textPositionPadding.y + .001) + { + return; + } + + float3 samp = tex2D(_TextGlyphs, TRANSFORM_TEX(uv, _TextGlyphs)).rgb; + float2 msdfUnit = float(4) / float4(1,1,1,1).zw; + float sigDist = median(samp.r, samp.g, samp.b) - 0.5; + sigDist *= max(dot(msdfUnit, 0.5 / fwidth(uv)), 1); + float opacity = clamp(sigDist + 0.5, 0, 1); + albedo.rgb = lerp(albedo.rgb, float4(1,0,1,1).rgb, opacity * float4(1,0,1,1).a); + globalTextEmission += float4(1,0,1,1).rgb * opacity * float(0); + } + + void ApplyTimeText(inout float4 albedo, float2 uv) + { + float instanceTime = _Time.y; + float hours = instanceTime / 3600; + float minutes = (instanceTime / 60) % 60; + float seconds = instanceTime % 60; + float totalCharacters = 8; + float timeArray[8]; + timeArray[0] = floor((hours * .1) % 10) + 48; + timeArray[1] = floor(hours % 10) + 48; + timeArray[2] = ASCII_SEMICOLON; + timeArray[3] = floor((minutes * .1) % 10) + 48; + timeArray[4] = floor(minutes % 10) + 48; + timeArray[5] = ASCII_SEMICOLON; + timeArray[6] = floor((seconds * .1) % 10) + 48; + timeArray[7] = floor(seconds % 10) + 48; + + uv = TransformUV(float4(0,0,0,0), float(0), float4(1,1,1,1), uv); + + if(uv.x > 1 || uv.x < 0 || uv.y > 1 || uv.y < 0) + { + return; + } + + float currentCharacter = floor(uv.x * totalCharacters); + half2 glyphPos = getAsciiCoordinate(timeArray[currentCharacter]); + // 0.1428571 = 1/7 = 1 / totalCharacters + float startUV = 1 / totalCharacters * currentCharacter; + float endUV = 1 / totalCharacters * (currentCharacter + 1); + fixed4 textTimePadding = float4(0,0,0,0); + textTimePadding *= 1 / totalCharacters; + uv = remapClamped(uv, float2(startUV, 0), float2(endUV, 1), float2(glyphPos.x + textTimePadding.x, glyphPos.y - glyphWidth + textTimePadding.y), float2(glyphPos.x + glyphWidth - textTimePadding.z, glyphPos.y - textTimePadding.w)); + + if (uv.x > glyphPos.x + glyphWidth - textTimePadding.z - .001 || uv.x < glyphPos.x + textTimePadding.x + .001 || uv.y > glyphPos.y - textTimePadding.w - .001 || uv.y < glyphPos.y - glyphWidth + textTimePadding.y + .001) + { + return; + } + + float3 samp = tex2D(_TextGlyphs, TRANSFORM_TEX(uv, _TextGlyphs)).rgb; + float2 msdfUnit = float(4) / float4(1,1,1,1).zw; + float sigDist = median(samp.r, samp.g, samp.b) - 0.5; + sigDist *= max(dot(msdfUnit, 0.5 / fwidth(uv)), 1); + float opacity = clamp(sigDist + 0.5, 0, 1); + albedo.rgb = lerp(albedo.rgb, float4(1,0,1,1).rgb, opacity * float4(1,0,1,1).a); + globalTextEmission += float4(1,0,1,1).rgb * opacity * float(0); + } + + void ApplyFPSText(inout float4 albedo, float2 uv) + { + float smoothDeltaTime = clamp(unity_DeltaTime.w, 0, 999); + float totalCharacters = 7; + float fpsArray[7]; + fpsArray[0] = ASCII_F; + fpsArray[1] = ASCII_P; + fpsArray[2] = ASCII_S; + fpsArray[3] = ASCII_SEMICOLON; + fpsArray[4] = floor((smoothDeltaTime * .01) % 10) + 48; + fpsArray[5] = floor((smoothDeltaTime * .1) % 10) + 48; + fpsArray[6] = floor(smoothDeltaTime % 10) + 48; + + uv = TransformUV(float4(0,0,0,0), float(0), float4(1,1,1,1), uv); + + if(uv.x > 1 || uv.x < 0 || uv.y > 1 || uv.y < 0) + { + return; + } + + float currentCharacter = floor(uv.x * totalCharacters); + half2 glyphPos = getAsciiCoordinate(fpsArray[currentCharacter]); + // 0.1428571 = 1/7 = 1 / totalCharacters + float startUV = 1 / totalCharacters * currentCharacter; + float endUV = 1 / totalCharacters * (currentCharacter + 1); + + fixed4 textFPSPadding = float4(0,0,0,0); + textFPSPadding *= 1 / totalCharacters; + uv = remapClamped(uv, float2(startUV, 0), float2(endUV, 1), float2(glyphPos.x + textFPSPadding.x, glyphPos.y - glyphWidth + textFPSPadding.y), float2(glyphPos.x + glyphWidth - textFPSPadding.z, glyphPos.y - textFPSPadding.w)); + + if (uv.x > glyphPos.x + glyphWidth - textFPSPadding.z - .001 || uv.x < glyphPos.x + textFPSPadding.x + .001 || uv.y > glyphPos.y - textFPSPadding.w - .001 || uv.y < glyphPos.y - glyphWidth + textFPSPadding.y + .001) + { + return; + } + + float3 samp = tex2D(_TextGlyphs, TRANSFORM_TEX(uv, _TextGlyphs)).rgb; + float2 msdfUnit = float(4) / float4(1,1,1,1).zw; + float sigDist = median(samp.r, samp.g, samp.b) - 0.5; + sigDist *= max(dot(msdfUnit, 0.5 / fwidth(uv)), 1); + float opacity = clamp(sigDist + 0.5, 0, 1); + albedo.rgb = lerp(albedo.rgb, float4(1,1,1,1).rgb, opacity * float4(1,1,1,1).a); + globalTextEmission += float4(1,1,1,1).rgb * opacity * float(0); + } + + void ApplyTextOverlayColor(inout float4 albedo, inout float3 textOverlayEmission) + { + globalTextEmission = 0; + half positionalOpacity = 0; + #ifdef EFFECT_BUMP + + if(float(0)) + { + ApplyFPSText(albedo, poiMesh.uv[float(0)]); + } + + if(float(0)) + { + ApplyPositionText(albedo, poiMesh.uv[float(0)]); + } + + if(float(0)) + { + ApplyTimeText(albedo, poiMesh.uv[float(0)]); + } + + textOverlayEmission = globalTextEmission; + #endif + } + +#endif diff --git a/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_PoiMSDF.cginc.meta b/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_PoiMSDF.cginc.meta new file mode 100644 index 00000000..a30d39c1 --- /dev/null +++ b/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_PoiMSDF.cginc.meta @@ -0,0 +1,9 @@ +fileFormatVersion: 2 +guid: fa528c7ab2180f84b990094c0cac283d +ShaderImporter: + externalObjects: {} + defaultTextures: [] + nonModifiableTextures: [] + userData: + assetBundleName: + assetBundleVariant: diff --git a/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_PoiMacros.cginc b/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_PoiMacros.cginc new file mode 100644 index 00000000..b7be4d0b --- /dev/null +++ b/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_PoiMacros.cginc @@ -0,0 +1,40 @@ +#ifndef POI_MACROS + #define POI_MACROS + + #define POI_TEXTURE_NOSAMPLER(tex) Texture2D tex; float4 tex##_ST; float2 tex##Pan; uint tex##UV + #define POI_TEXTURE(tex) UNITY_DECLARE_TEX2D(tex##); float4 tex##_ST; float2 tex##Pan; uint tex##UV + #define POI_NORMAL_NOSAMPLER(tex) Texture2D tex; float4 tex##_ST; float2 tex##Pan; uint tex##UV; float tex##Scale + + #define POI2D_SAMPLER_PAN(tex, texSampler, uv, pan) (UNITY_SAMPLE_TEX2D_SAMPLER(tex, texSampler, TRANSFORM_TEX(uv, tex) + _Time.x * pan)) + #define POI2D_SAMPLER(tex, texSampler, uv) (UNITY_SAMPLE_TEX2D_SAMPLER(tex, texSampler, TRANSFORM_TEX(uv, tex))) + #define POI2D_PAN(tex, uv, pan) (tex2D(tex, TRANSFORM_TEX(uv, tex) + _Time.x * pan)) + #define POI2D(tex, uv) (tex2D(tex, TRANSFORM_TEX(uv, tex))) + #define POI_SAMPLE_TEX2D(tex, uv) (UNITY_SAMPLE_TEX2D(tex, TRANSFORM_TEX(uv, tex))) + #define POI_SAMPLE_TEX2D_PAN(tex, uv, pan) (UNITY_SAMPLE_TEX2D(tex, TRANSFORM_TEX(uv, tex) + _Time.x * pan)) + + #ifdef POINT + # define POI_LIGHT_ATTENUATION(destName, shadow, input, worldPos) \ + unityShadowCoord3 lightCoord = mul(unity_WorldToLight, unityShadowCoord4(worldPos, 1)).xyz; \ + fixed shadow = UNITY_SHADOW_ATTENUATION(input, worldPos); \ + fixed destName = tex2D(_LightTexture0, dot(lightCoord, lightCoord).rr).r; + #endif + + #ifdef SPOT + #if !defined(UNITY_HALF_PRECISION_FRAGMENT_SHADER_REGISTERS) + #define DECLARE_LIGHT_COORD(input, worldPos) unityShadowCoord4 lightCoord = mul(unity_WorldToLight, unityShadowCoord4(worldPos, 1)) + #else + #define DECLARE_LIGHT_COORD(input, worldPos) unityShadowCoord4 lightCoord = input._LightCoord + #endif + # define POI_LIGHT_ATTENUATION(destName, shadow, input, worldPos) \ + DECLARE_LIGHT_COORD(input, worldPos); \ + fixed shadow = UNITY_SHADOW_ATTENUATION(input, worldPos); \ + fixed destName = (lightCoord.z > 0) * UnitySpotCookie(lightCoord) * UnitySpotAttenuate(lightCoord.xyz); + #endif + + #if defined(UNITY_COMPILER_HLSL) + #define PoiInitStruct(type,name) name = (type)0; + #else + #define PoiInitStruct(type,name) + #endif + +#endif diff --git a/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_PoiMacros.cginc.meta b/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_PoiMacros.cginc.meta new file mode 100644 index 00000000..1f58f9dd --- /dev/null +++ b/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_PoiMacros.cginc.meta @@ -0,0 +1,9 @@ +fileFormatVersion: 2 +guid: 1e91eb3b2b0ec8b4393d6aa2a3442b74 +ShaderImporter: + externalObjects: {} + defaultTextures: [] + nonModifiableTextures: [] + userData: + assetBundleName: + assetBundleVariant: diff --git a/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_PoiMainTex.cginc b/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_PoiMainTex.cginc new file mode 100644 index 00000000..0f8ead5d --- /dev/null +++ b/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_PoiMainTex.cginc @@ -0,0 +1,180 @@ +#ifndef POI_MAINTEXTURE +#define POI_MAINTEXTURE + + +#if defined(PROP_CLIPPINGMASK) || !defined(OPTIMIZER_ENABLED) + POI_TEXTURE_NOSAMPLER(_ClippingMask); +#endif +#if defined(PROP_MAINFADETEXTURE) || !defined(OPTIMIZER_ENABLED) + POI_TEXTURE_NOSAMPLER(_MainFadeTexture); +#endif + +float _Inverse_Clipping; +float4 _Color; +float _MainVertexColoring; +float _MainUseVertexColorAlpha; +float _Saturation; +float2 _MainDistanceFade; +half _MainMinAlpha; +float _MainHueShift; +#ifdef COLOR_GRADING_HDR + #if defined(PROP_MAINCOLORADJUSTTEXTURE) || !defined(OPTIMIZER_ENABLED) + POI_TEXTURE_NOSAMPLER(_MainColorAdjustTexture); + #endif + float _MainHueShiftToggle; + float _MainHueShiftSpeed; + float _MainHueShiftReplace; + float _MainSaturationShift; + float _MainBrightness; +#endif + +#ifdef FINALPASS + #if defined(PROP_DETAILTEX) || !defined(OPTIMIZER_ENABLED) + POI_TEXTURE_NOSAMPLER(_DetailTex); + #endif + half _DetailTexIntensity; + half3 _DetailTint; + float _DetailBrightness; +#endif +//globals +float alphaMask; +half3 diffColor; + +#include "CGI_PoiBackFace.cginc" + +float3 wireframeEmission; + +inline FragmentCommonData SpecularSetup(float4 i_tex, inout float4 albedo) +{ + half4 specGloss = 0; + half3 specColor = specGloss.rgb; + half smoothness = specGloss.a; + + half oneMinusReflectivity; + diffColor = EnergyConservationBetweenDiffuseAndSpecular(albedo.rgb, specColor, /*out*/ oneMinusReflectivity); + + FragmentCommonData o = (FragmentCommonData)0; + o.diffColor = diffColor; + o.specColor = specColor; + o.oneMinusReflectivity = oneMinusReflectivity; + o.smoothness = smoothness; + return o; +} + +inline FragmentCommonData FragmentSetup(float4 i_tex, half3 i_viewDirForParallax, float3 i_posWorld, inout float4 albedo) +{ + i_tex = i_tex; + + FragmentCommonData o = SpecularSetup(i_tex, albedo); + o.normalWorld = float3(0, 0, 0); + o.eyeVec = poiCam.viewDir; + o.posWorld = i_posWorld; + + // NOTE: shader relies on pre-multiply alpha-blend (float(1) = One, float(0) = OneMinusSrcAlpha) + o.diffColor = PreMultiplyAlpha(o.diffColor, 1, o.oneMinusReflectivity, /*out*/ o.alpha); + return o; +} + +void initTextureData(inout float4 albedo, inout float4 mainTexture, inout float3 backFaceEmission, inout float3 dissolveEmission, in half3 detailMask) +{ + dissolveEmission = 0; + + #if (defined(FORWARD_BASE_PASS) || defined(FORWARD_ADD_PASS)) + #ifdef POI_MIRROR + applyMirrorTexture(mainTexture); + #endif + #endif + #if defined(PROP_CLIPPINGMASK) || !defined(OPTIMIZER_ENABLED) + alphaMask = POI2D_SAMPLER_PAN(_ClippingMask, _MainTex, poiMesh.uv[float(0)], float4(0,0,0,0)).r; + #else + alphaMask = 1; + #endif + + if (float(0)) + { + alphaMask = 1 - alphaMask; + } + mainTexture.a *= alphaMask; + + #ifndef POI_SHADOW + albedo = float4(mainTexture.rgb * max(float4(1,0.8387991,0.701102,1).rgb, float3(0.000000001, 0.000000001, 0.000000001)) * lerp(1, GammaToLinearSpace(poiMesh.vertexColor.rgb), float(0)), mainTexture.a * max(float4(1,0.8387991,0.701102,1).a, 0.0000001)); + + #if defined(POI_LIGHTING) && defined(FORWARD_BASE_PASS) + applyShadeMaps(albedo); + #endif + + albedo *= lerp(1, poiMesh.vertexColor.a, float(0)); + #ifdef POI_RGBMASK + albedo.rgb = calculateRGBMask(albedo.rgb); + #endif + + albedo.a = saturate(float(0) + albedo.a); + + wireframeEmission = 0; + #ifdef POI_WIREFRAME + applyWireframe(wireframeEmission, albedo); + #endif + float backFaceDetailIntensity = 1; + + float mixedHueShift = float(0); + applyBackFaceTexture(backFaceDetailIntensity, mixedHueShift, albedo, backFaceEmission); + + #ifdef POI_FUR + calculateFur(); + #endif + + #ifdef COLOR_GRADING_HDR + #if defined(PROP_MAINCOLORADJUSTTEXTURE) || !defined(OPTIMIZER_ENABLED) + float4 hueShiftAlpha = POI2D_SAMPLER_PAN(_MainColorAdjustTexture, _MainTex, poiMesh.uv[float(0)], float4(0,0,0,0)); + #else + float4 hueShiftAlpha = 1; + #endif + + if (float(1)) + { + albedo.rgb = lerp(albedo.rgb, hueShift(albedo.rgb, mixedHueShift + float(0) * _Time.x), hueShiftAlpha.r); + } + else + { + albedo.rgb = hueShift(albedo.rgb, frac((mixedHueShift - (1 - hueShiftAlpha.r) + float(0) * _Time.x))); + } + + albedo.rgb = lerp(albedo.rgb, dot(albedo.rgb, float3(0.3, 0.59, 0.11)), -float(1) * hueShiftAlpha.b); + albedo.rgb = saturate(albedo.rgb + float(0) * hueShiftAlpha.g); + #endif + #ifdef FINALPASS + #if defined(PROP_DETAILTEX) || !defined(OPTIMIZER_ENABLED) + half3 detailTexture = POI2D_SAMPLER_PAN(_DetailTex, _MainTex, poiMesh.uv[float(0)], float4(0,0,0,0)).rgb * float4(1,1,1,1).rgb; + #else + half3 detailTexture = 0.21763764082 * float4(1,1,1,1).rgb; + #endif + albedo.rgb *= LerpWhiteTo(detailTexture * float(1) * unity_ColorSpaceDouble.rgb, detailMask.r * float(1) * backFaceDetailIntensity); + #endif + albedo.rgb = saturate(albedo.rgb); + + #ifdef POI_HOLOGRAM + ApplyHoloAlpha(albedo); + #endif + + s = FragmentSetup(float4(poiMesh.uv[0], 1, 1), poiCam.viewDir, poiMesh.worldPos, albedo); + #endif + + #ifdef DISTORT + calculateDissolve(albedo, dissolveEmission); + #endif +} + +void distanceFade(inout float4 albedo) +{ + #if defined(PROP_MAINFADETEXTURE) || !defined(OPTIMIZER_ENABLED) + half fadeMap = POI2D_SAMPLER_PAN(_MainFadeTexture, _MainTex, poiMesh.uv[float(0)], float4(0,0,0,0)).r; + #else + half fadeMap = 1; + #endif + if (fadeMap) + { + half fadeValue = max(smoothstep(float4(0,0,0,0).x, float4(0,0,0,0).y, poiCam.distanceToVert), float(0)); + albedo.a *= fadeValue; + } +} +#endif diff --git a/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_PoiMainTex.cginc.meta b/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_PoiMainTex.cginc.meta new file mode 100644 index 00000000..0e75ab66 --- /dev/null +++ b/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_PoiMainTex.cginc.meta @@ -0,0 +1,9 @@ +fileFormatVersion: 2 +guid: d5b8a0317646de245bd7f4f2eacc8156 +ShaderImporter: + externalObjects: {} + defaultTextures: [] + nonModifiableTextures: [] + userData: + assetBundleName: + assetBundleVariant: diff --git a/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_PoiMatcap.cginc b/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_PoiMatcap.cginc new file mode 100644 index 00000000..e08b96d6 --- /dev/null +++ b/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_PoiMatcap.cginc @@ -0,0 +1,160 @@ +#ifndef MATCAP + #define MATCAP + + #if defined(PROP_MATCAP) || !defined(OPTIMIZER_ENABLED) + UNITY_DECLARE_TEX2D_NOSAMPLER(_Matcap); float4 _Matcap_ST; + #endif + #if defined(PROP_MATCAPMASK) || !defined(OPTIMIZER_ENABLED) + POI_TEXTURE_NOSAMPLER(_MatcapMask); + #endif + float _MatcapMaskInvert; + float _MatcapBorder; + float4 _MatcapColor; + float _MatcapIntensity; + float _MatcapReplace; + float _MatcapMultiply; + float _MatcapAdd; + float _MatcapEnable; + float _MatcapLightMask; + float _MatcapEmissionStrength; + float _MatcapNormal; + float _MatcapHueShiftEnabled; + float _MatcapHueShiftSpeed; + float _MatcapHueShift; + + #ifdef COLOR_GRADING_HDR_3D + #if defined(PROP_MATCAP2) || !defined(OPTIMIZER_ENABLED) + UNITY_DECLARE_TEX2D_NOSAMPLER(_Matcap2);float4 _Matcap2_ST; + #endif + #if defined(PROP_MATCAP2MASK) || !defined(OPTIMIZER_ENABLED) + POI_TEXTURE_NOSAMPLER(_Matcap2Mask); + #endif + float _Matcap2MaskInvert; + float _Matcap2Border; + float4 _Matcap2Color; + float _Matcap2Intensity; + float _Matcap2Replace; + float _Matcap2Multiply; + float _Matcap2Add; + float _Matcap2Enable; + float _Matcap2LightMask; + float _Matcap2EmissionStrength; + float _Matcap2Normal; + float _Matcap2HueShiftEnabled; + float _Matcap2HueShiftSpeed; + float _Matcap2HueShift; + #endif + + void blendMatcap(inout float4 finalColor, float add, float multiply, float replace, float4 matcapColor, float matcapMask, inout float3 matcapEmission, float emissionStrength + #ifdef POI_LIGHTING + , float matcapLightMask + #endif + #ifdef POI_BLACKLIGHT + , uint blackLightMaskIndex + #endif + ) + { + #ifdef POI_LIGHTING + if (matcapLightMask) + { + matcapMask *= lerp(1, poiLight.rampedLightMap, matcapLightMask); + } + #endif + #ifdef POI_BLACKLIGHT + if(blackLightMaskIndex != 4) + { + matcapMask *= blackLightMask[blackLightMaskIndex]; + } + #endif + + finalColor.rgb = lerp(finalColor.rgb, matcapColor.rgb, replace * matcapMask * matcapColor.a * .999999); + finalColor.rgb *= lerp(1, matcapColor.rgb, multiply * matcapMask * matcapColor.a); + finalColor.rgb += matcapColor.rgb * add * matcapMask * matcapColor.a; + matcapEmission += matcapColor.rgb * emissionStrength * matcapMask * matcapColor.a; + } + + void applyMatcap(inout float4 finalColor, inout float3 matcapEmission) + { + float4 matcap = 0; + float matcapMask = 0; + float4 matcap2 = 0; + float matcap2Mask = 0; + + // Both matcaps use the same coordinates + half3 worldViewUp = normalize(half3(0, 1, 0) - poiCam.viewDir * dot(poiCam.viewDir, half3(0, 1, 0))); + half3 worldViewRight = normalize(cross(poiCam.viewDir, worldViewUp)); + + // Matcap 1 + half2 matcapUV = half2(dot(worldViewRight, poiMesh.normals[float(1)]), dot(worldViewUp, poiMesh.normals[float(1)])) * float(0.43) + 0.5; + + #if defined(PROP_MATCAP) || !defined(OPTIMIZER_ENABLED) + matcap = UNITY_SAMPLE_TEX2D_SAMPLER(_Matcap, _MainTex, TRANSFORM_TEX(matcapUV, _Matcap)) * float4(0.3139887,0.3139887,0.3139887,1); + #else + matcap = float4(0.3139887,0.3139887,0.3139887,1); + #endif + + matcap.rgb *= float(1); + #if defined(PROP_MATCAPMASK) || !defined(OPTIMIZER_ENABLED) + matcapMask = POI2D_SAMPLER_PAN(_MatcapMask, _MainTex, poiMesh.uv[float(0)], float4(0,0,0,0)); + #else + matcapMask = 1; + #endif + + if (float(0)) + { + matcapMask = 1 - matcapMask; + } + + + if(float(0)) + { + matcap.rgb = hueShift(matcap.rgb, float(0) + _Time.x * float(0)); + } + + blendMatcap(finalColor, float(0), float(0), float(1), matcap, matcapMask, matcapEmission, float(0) + #ifdef POI_LIGHTING + , float(0) + #endif + #ifdef POI_BLACKLIGHT + , float(4) + #endif + ); + + + // Matcap 2 + #ifdef COLOR_GRADING_HDR_3D + half2 matcapUV2 = half2(dot(worldViewRight, poiMesh.normals[float(1)]), dot(worldViewUp, poiMesh.normals[float(1)])) * float(0.43) + 0.5; + #if defined(PROP_MATCAP2) || !defined(OPTIMIZER_ENABLED) + matcap2 = UNITY_SAMPLE_TEX2D_SAMPLER(_Matcap2, _MainTex, TRANSFORM_TEX(matcapUV2, _Matcap2)) * float4(1,1,1,1); + #else + matcap2 = float4(1,1,1,1); + #endif + matcap2.rgb *= float(1); + #if defined(PROP_MATCAP2MASK) || !defined(OPTIMIZER_ENABLED) + matcap2Mask = POI2D_SAMPLER_PAN(_Matcap2Mask, _MainTex, poiMesh.uv[float(0)], float4(0,0,0,0)); + #else + matcap2Mask = 1; + #endif + if (float(0)) + { + matcap2Mask = 1 - matcap2Mask; + } + + + if(float(0)) + { + matcap2.rgb = hueShift(matcap2.rgb, float(0) + _Time.x * float(0)); + } + + blendMatcap(finalColor, float(0), float(0), float(0), matcap2, matcap2Mask, matcapEmission, float(0) + #ifdef POI_LIGHTING + , float(0) + #endif + #ifdef POI_BLACKLIGHT + , float(4) + #endif + ); + #endif + } + +#endif diff --git a/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_PoiMatcap.cginc.meta b/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_PoiMatcap.cginc.meta new file mode 100644 index 00000000..78099b2f --- /dev/null +++ b/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_PoiMatcap.cginc.meta @@ -0,0 +1,9 @@ +fileFormatVersion: 2 +guid: f6eea6f8122fc6e4b945c4cf3595bc6e +ShaderImporter: + externalObjects: {} + defaultTextures: [] + nonModifiableTextures: [] + userData: + assetBundleName: + assetBundleVariant: diff --git a/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_PoiMath.cginc b/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_PoiMath.cginc new file mode 100644 index 00000000..e626da6a --- /dev/null +++ b/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_PoiMath.cginc @@ -0,0 +1,100 @@ +/* +MIT License + +Copyright (c) 2019 wraikny + +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. + +VertexTransformShader is dependent on: +*/ + +#ifndef POI_MATH +#define POI_MATH + +#ifndef pi + #define pi float(3.14159265359) +#endif + +float4 quaternion_conjugate(float4 v) +{ + return float4( + v.x, -v.yzw + ); +} + +float4 quaternion_mul(float4 v1, float4 v2) +{ + float4 result1 = (v1.x * v2 + v1 * v2.x); + + float4 result2 = float4( + - dot(v1.yzw, v2.yzw), + cross(v1.yzw, v2.yzw) + ); + + return float4(result1 + result2); +} + +// angle : radians +float4 get_quaternion_from_angle(float3 axis, float angle) +{ + return float4( + cos(angle / 2.0), + normalize(axis) * sin(angle / 2.0) + ); +} + +float4 quaternion_from_vector(float3 inVec) +{ + return float4(0.0, inVec); +} + +float degree_to_radius(float degree) +{ + return( + degree / 180.0 * pi + ); +} + +float3 rotate_with_quaternion(float3 inVec, float3 rotation) +{ + float4 qx = get_quaternion_from_angle(float3(1, 0, 0), degree_to_radius(rotation.x)); + float4 qy = get_quaternion_from_angle(float3(0, 1, 0), degree_to_radius(rotation.y)); + float4 qz = get_quaternion_from_angle(float3(0, 0, 1), degree_to_radius(rotation.z)); + + #define MUL3(A, B, C) quaternion_mul(quaternion_mul((A), (B)), (C)) + float4 quaternion = normalize(MUL3(qx, qy, qz)); + float4 conjugate = quaternion_conjugate(quaternion); + + float4 inVecQ = quaternion_from_vector(inVec); + + float3 rotated = ( + MUL3(quaternion, inVecQ, conjugate) + ).yzw; + + return rotated; +} + +float4 transform(float4 input, float4 pos, float4 rotation, float4 scale) +{ + input.rgb *= (scale.xyz * scale.w); + input = float4(rotate_with_quaternion(input.xyz, rotation.xyz/* * rotation.w*/) + (pos.xyz/* * pos.w*/), input.w); + return input; +} + +#endif diff --git a/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_PoiMath.cginc.meta b/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_PoiMath.cginc.meta new file mode 100644 index 00000000..48840709 --- /dev/null +++ b/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_PoiMath.cginc.meta @@ -0,0 +1,9 @@ +fileFormatVersion: 2 +guid: 9c0555167e2c1d5479a6c652ca8adb8f +ShaderImporter: + externalObjects: {} + defaultTextures: [] + nonModifiableTextures: [] + userData: + assetBundleName: + assetBundleVariant: diff --git a/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_PoiMetal.cginc b/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_PoiMetal.cginc new file mode 100644 index 00000000..b3e1cf11 --- /dev/null +++ b/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_PoiMetal.cginc @@ -0,0 +1,130 @@ +#ifndef POI_METAL + #define POI_METAL + + samplerCUBE _CubeMap; + float _SampleWorld; + POI_TEXTURE_NOSAMPLER(_MetallicMask); + POI_TEXTURE_NOSAMPLER(_SmoothnessMask); + float _Metallic; + float _InvertSmoothness; + float _Smoothness; + float _EnableMetallic; + float3 _MetalReflectionTint; + POI_TEXTURE_NOSAMPLER(_MetallicTintMap); + + float3 finalreflections; + float metalicMap; + float3 reflection; + float roughness; + float lighty_boy_uwu_var; + + bool shouldMetalHappenBeforeLighting() + { + float4 envSample = UNITY_SAMPLE_TEXCUBE_LOD(unity_SpecCube0, poiCam.reflectionDir, roughness * UNITY_SPECCUBE_LOD_STEPS); + bool probeExists = !(unity_SpecCube0_HDR.a == 0 && envSample.a == 0); + return probeExists && !float(0); + } + + float3 fresnelRelflection(in float4 albedo) + { + half3 dotNV = 1 - abs(poiLight.nDotV); + half f = dotNV * dotNV * dotNV * dotNV; + //f *= i_sold.fresnel; + return lerp(lerp(DielectricSpec.rgb, albedo.rgb, metalicMap), saturate(1 - roughness + metalicMap), f); + } + + void calculateMetallicness() + { + metalicMap = POI2D_SAMPLER_PAN(_MetallicMask, _MainTex, poiMesh.uv[float(0)], float4(0,0,0,0)) * float(0); + } + + void ApplyMetallics(inout float4 finalColor, in float4 albedo) + { + #ifdef FORWARD_BASE_PASS + float smoothnessMap = (POI2D_SAMPLER_PAN(_SmoothnessMask, _MainTex, poiMesh.uv[float(0)], float4(0,0,0,0))); + + #ifdef POI_BLACKLIGHT + if (float(4) != 4) + { + metalicMap *= blackLightMask[float(4)]; + smoothnessMap *= blackLightMask[float(4)]; + } + #endif + + if(float(0) == 1) + { + smoothnessMap = 1 - smoothnessMap; + } + smoothnessMap *= float(0); + roughness = 1 - smoothnessMap; + + + Unity_GlossyEnvironmentData envData; + envData.roughness = roughness; + envData.reflUVW = BoxProjection( + poiCam.reflectionDir, poiMesh.worldPos.xyz, + unity_SpecCube0_ProbePosition, + unity_SpecCube0_BoxMin, unity_SpecCube0_BoxMax + ); + float3 probe0 = Unity_GlossyEnvironment( + UNITY_PASS_TEXCUBE(unity_SpecCube0), unity_SpecCube0_HDR, envData + ); + envData.reflUVW = BoxProjection( + poiCam.reflectionDir, poiMesh.worldPos.xyz, + unity_SpecCube1_ProbePosition, + unity_SpecCube1_BoxMin, unity_SpecCube1_BoxMax + ); + + float interpolator = unity_SpecCube0_BoxMin.w; + + if(interpolator < 0.99999) + { + float3 probe1 = Unity_GlossyEnvironment( + UNITY_PASS_TEXCUBE_SAMPLER(unity_SpecCube1, unity_SpecCube0), + unity_SpecCube0_HDR, envData + ); + reflection = lerp(probe1, probe0, interpolator); + } + else + { + reflection = probe0; + } + + float reflecty_lighty_boy_uwu_var_2 = 1.0 / (roughness * roughness + 1.0); + + half4 tintMap = POI2D_SAMPLER_PAN(_MetallicTintMap, _MainTex, poiMesh.uv[float(0)], float4(0,0,0,0)); + finalColor.rgb *= (1 - metalicMap * tintMap.a); + finalColor.rgb += reflecty_lighty_boy_uwu_var_2 * reflection.rgb * fresnelRelflection(albedo) * float4(1,1,1,1) * tintMap.rgb * tintMap.a; + #endif + } + + void ApplyMetallicsFake(inout float4 finalColor, in float4 albedo) + { + #ifdef FORWARD_BASE_PASS + metalicMap = POI2D_SAMPLER_PAN(_MetallicMask, _MainTex, poiMesh.uv[float(0)], float4(0,0,0,0)) * float(0); + float smoothnessMap = (POI2D_SAMPLER_PAN(_SmoothnessMask, _MainTex, poiMesh.uv[float(0)], float4(0,0,0,0))); + + #ifdef POI_BLACKLIGHT + if(float(4) != 4) + { + metalicMap *= blackLightMask[float(4)]; + smoothnessMap *= blackLightMask[float(4)]; + } + #endif + + if(float(0) == 1) + { + smoothnessMap = 1 - smoothnessMap; + } + smoothnessMap *= float(0); + roughness = 1 - smoothnessMap; + + reflection = texCUBElod(_CubeMap, float4(poiCam.reflectionDir, roughness * UNITY_SPECCUBE_LOD_STEPS)); + + float reflecty_lighty_boy_uwu_var_2 = 1.0 / (roughness * roughness + 1.0); + half4 tintMap = POI2D_SAMPLER_PAN(_MetallicTintMap, _MainTex, poiMesh.uv[float(0)], float4(0,0,0,0)); + finalColor.rgb *= (1 - metalicMap * tintMap.a); + finalColor.rgb += reflecty_lighty_boy_uwu_var_2 * reflection.rgb * fresnelRelflection(albedo) * float4(1,1,1,1) * tintMap.rgb * tintMap.a; + #endif + } +#endif diff --git a/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_PoiMetal.cginc.meta b/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_PoiMetal.cginc.meta new file mode 100644 index 00000000..84e74475 --- /dev/null +++ b/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_PoiMetal.cginc.meta @@ -0,0 +1,9 @@ +fileFormatVersion: 2 +guid: c1089143910b5b24d94772ca82939390 +ShaderImporter: + externalObjects: {} + defaultTextures: [] + nonModifiableTextures: [] + userData: + assetBundleName: + assetBundleVariant: diff --git a/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_PoiMirror.cginc b/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_PoiMirror.cginc new file mode 100644 index 00000000..3a42160c --- /dev/null +++ b/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_PoiMirror.cginc @@ -0,0 +1,81 @@ +#ifndef POI_MIRROR + #define POI_MIRROR + + float _Mirror; + float _EnableMirrorTexture; + #if defined(PROP_MIRRORTEXTURE) || !defined(OPTIMIZER_ENABLED) + POI_TEXTURE_NOSAMPLER(_MirrorTexture); + #endif + + + void applyMirrorRenderVert(inout float4 vertex) + { + + if (float(0) != 0) + { + bool inMirror = IsInMirror(); + if(float(0) == 1 && inMirror) + { + return; + } + if(float(0) == 1 && !inMirror) + { + vertex = -1; + return; + } + if(float(0) == 2 && inMirror) + { + vertex = -1; + return; + } + if(float(0) == 2 && !inMirror) + { + return; + } + } + } + + void applyMirrorRenderFrag() + { + + if(float(0) != 0) + { + bool inMirror = IsInMirror(); + if(float(0) == 1 && inMirror) + { + return; + } + if(float(0) == 1 && !inMirror) + { + clip(-1); + return; + } + if(float(0) == 2 && inMirror) + { + clip(-1); + return; + } + if(float(0) == 2 && !inMirror) + { + return; + } + } + } + + #if(defined(FORWARD_BASE_PASS) || defined(FORWARD_ADD_PASS)) + void applyMirrorTexture(inout float4 mainTexture) + { + + if(float(0)) + { + if(IsInMirror()) + { + #if defined(PROP_MIRRORTEXTURE) || !defined(OPTIMIZER_ENABLED) + mainTexture = POI2D_SAMPLER_PAN(_MirrorTexture, _MainTex, poiMesh.uv[float(0)], float4(0,0,0,0)); + #endif + } + } + } + #endif + +#endif diff --git a/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_PoiMirror.cginc.meta b/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_PoiMirror.cginc.meta new file mode 100644 index 00000000..18ffb09e --- /dev/null +++ b/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_PoiMirror.cginc.meta @@ -0,0 +1,9 @@ +fileFormatVersion: 2 +guid: f992ed35f2a0f7c469cfc321a1b9d798 +ShaderImporter: + externalObjects: {} + defaultTextures: [] + nonModifiableTextures: [] + userData: + assetBundleName: + assetBundleVariant: diff --git a/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_PoiOutlineFrag.cginc b/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_PoiOutlineFrag.cginc new file mode 100644 index 00000000..62e63c91 --- /dev/null +++ b/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_PoiOutlineFrag.cginc @@ -0,0 +1,107 @@ +float _OutlineRimLightBlend; +float _OutlineLit; +float _OutlineTintMix; +float2 _MainTexPan; +float _MainTextureUV; + +float4 frag(v2f i, uint facing: SV_IsFrontFace): COLOR +{ + float4 finalColor = 1; + + if (float(0)) + { + UNITY_SETUP_INSTANCE_ID(i); + + float3 finalEmission = 0; + float4 albedo = 1; + + poiMesh.uv[0] = i.uv0.xy; + poiMesh.uv[1] = i.uv0.zw; + poiMesh.uv[2] = i.uv1.xy; + poiMesh.uv[3] = i.uv1.zw; + + calculateAttenuation(i); + InitializeMeshData(i, facing); + initializeCamera(i); + calculateTangentData(); + + float4 mainTexture = UNITY_SAMPLE_TEX2D(_MainTex, TRANSFORM_TEX(poiMesh.uv[float(0)], _MainTex) + _Time.x * float4(0,0,0,0)); + half3 detailMask = 1; + calculateNormals(detailMask); + + #ifdef POI_DATA + calculateLightingData(i); + #endif + #ifdef POI_LIGHTING + calculateBasePassLightMaps(); + #endif + + float3 uselessData0; + float3 uselessData1; + initTextureData(albedo, mainTexture, uselessData0, uselessData1, detailMask); + + + fixed4 col = mainTexture; + float alphaMultiplier = smoothstep(float4(0,0,0,0).x, float4(0,0,0,0).y, distance(getCameraPosition(), i.worldPos)); + float OutlineMask = tex2D(_OutlineMask, TRANSFORM_TEX(poiMesh.uv[float(0)], _OutlineMask) + _Time.x * float4(0,0,0,0)).r; + clip(OutlineMask * float(0) - 0.001); + + col = col * 0.00000000001 + tex2D(_OutlineTexture, TRANSFORM_TEX(poiMesh.uv[float(0)], _OutlineTexture) + _Time.x * float4(0,0,0,0) ); + col.a *= albedo.a; + col.a *= alphaMultiplier; + + #ifdef POI_RANDOM + col.a *= i.angleAlpha; + #endif + + poiCam.screenUV = calcScreenUVs(i.grabPos); + col.a *= float4(1,1,1,1).a; + + + if(float(0) == 1) + { + applyDithering(col); + } + + clip(col.a - float(0.5)); + + #ifdef POI_MIRROR + applyMirrorRenderFrag(); + #endif + + + if(float(0) == 1) + { + #ifdef POI_MIRROR + applyMirrorTexture(mainTexture); + #endif + col.rgb = mainTexture.rgb; + } + else if(float(0) == 2) + { + col.rgb = lerp(col.rgb, poiLight.color, float(0)); + } + col.rgb *= float4(1,1,1,1).rgb; + + if(float(0) == 1) + { + col.rgb = lerp(col.rgb, mainTexture.rgb, float(0)); + } + + finalColor = col; + + #ifdef POI_LIGHTING + + if(float(1)) + { + finalColor.rgb *= calculateFinalLighting(finalColor.rgb, finalColor); + } + #endif + finalColor.rgb += (col.rgb * float(0)); + } + else + { + clip(-1); + } + return finalColor; +} diff --git a/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_PoiOutlineFrag.cginc.meta b/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_PoiOutlineFrag.cginc.meta new file mode 100644 index 00000000..2767ee30 --- /dev/null +++ b/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_PoiOutlineFrag.cginc.meta @@ -0,0 +1,9 @@ +fileFormatVersion: 2 +guid: 581a9e582e57173469d943e35dfc2cb1 +ShaderImporter: + externalObjects: {} + defaultTextures: [] + nonModifiableTextures: [] + userData: + assetBundleName: + assetBundleVariant: diff --git a/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_PoiOutlineVert.cginc b/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_PoiOutlineVert.cginc new file mode 100644 index 00000000..637ec16d --- /dev/null +++ b/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_PoiOutlineVert.cginc @@ -0,0 +1,115 @@ +#ifndef OutlineVert + #define OutlineVert + + #include "CGI_PoiV2F.cginc" + + float _OutlineMode; + float4 _OutlinePersonaDirection; + float4 _OutlineDropShadowOffset; + float _OutlineUseVertexColors; + float _OutlineFixedSize; + float _commentIfZero_EnableOutlinePass; + float _OutlinesMaxDistance; + + sampler2D _OutlineMask; float4 _OutlineMask_ST; float2 _OutlineMaskPan; float _OutlineMaskUV; + v2f vert(appdata v) + { + + UNITY_SETUP_INSTANCE_ID(v); + v2f o; + UNITY_INITIALIZE_OUTPUT(v2f, o); + UNITY_TRANSFER_INSTANCE_ID(v, o); + UNITY_INITIALIZE_VERTEX_OUTPUT_STEREO(o); + + #ifdef RALIV_PENETRATION + applyRalivDynamicOrifaceSystem(v); + #endif + + o.uv0.xy = v.uv0.xy; + o.uv0.zw = v.uv1.xy; + o.uv1.xy = v.uv2.xy; + o.uv1.zw = v.uv3.xy; + + float2 uvArray[4]; + uvArray[0] = o.uv0.xy; + uvArray[1] = o.uv0.zw; + uvArray[2] = o.uv1.xy; + uvArray[3] = o.uv1.zw; + + #ifdef POI_MIRROR + applyMirrorRenderVert(v.vertex); + #endif + + o.uv0.xy = v.uv0 + _OutlineGlobalPan.xy * _Time.y; + float outlineMask = 1; + + outlineMask = poiMax(tex2Dlod(_OutlineMask, float4(TRANSFORM_TEX(uvArray[float(0)], _OutlineMask) + _Time.x * float4(0,0,0,0), 0, 0)).rgb); + + if (float(0) == 2) + { + outlineMask *= v.color.r; + } + + + if(float(0) != 1) + { + o.normal = UnityObjectToWorldNormal(v.normal); + } + else + { + o.normal = UnityObjectToWorldNormal(v.color); + } + + float4 localPos = v.vertex; + + #ifdef RALIV_PENETRATION + applyRalivDynamicPenetrationSystem(localPos.rgb, o.normal.rgb, v); + #endif + + half offsetMultiplier = 1; + half distanceOffset = 1; + + if(float(0)) + { + distanceOffset *= min(distance(_WorldSpaceCameraPos, mul(unity_ObjectToWorld, localPos).xyz), float(9999)); + } + + float3 offset = o.normal * (float(0) * float(0) / 100) * outlineMask * distanceOffset; + + + if(float(0) == 2) + { + float3 lightDirection = poiLight.direction = normalize(_WorldSpaceLightPos0 + unity_SHAr.xyz + unity_SHAg.xyz + unity_SHAb.xyz); + offsetMultiplier = saturate(dot(lightDirection, o.normal)); + offset *= offsetMultiplier; + offset *= distanceOffset; + } + else if(float(0) == 3) + { + half3 viewNormal = mul((float3x3)UNITY_MATRIX_V, o.normal); + offsetMultiplier = saturate(dot(viewNormal.xy, normalize(float4(1,0,0,0).xy))); + + offset *= offsetMultiplier; + offset *= distanceOffset; + } + else if(float(0) == 4) + { + offset = mul((float3x3)transpose(UNITY_MATRIX_V), float4(1,0,0,0)); + offset *= distanceOffset; + } + + o.worldPos = mul(unity_ObjectToWorld, localPos) + float4(offset, 0); + o.modelPos = mul(unity_ObjectToWorld, float4(0, 0, 0, 1)); + o.pos = UnityWorldToClipPos(o.worldPos); + o.grabPos = ComputeGrabScreenPos(o.pos); + o.angleAlpha = 1; + #ifdef POI_RANDOM + o.angleAlpha = ApplyAngleBasedRendering(o.modelPos, o.worldPos); + #endif + + UNITY_TRANSFER_SHADOW(o, o.uv0); + UNITY_TRANSFER_FOG(o, o.pos); + return o; + } + +#endif diff --git a/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_PoiOutlineVert.cginc.meta b/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_PoiOutlineVert.cginc.meta new file mode 100644 index 00000000..4dc56172 --- /dev/null +++ b/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_PoiOutlineVert.cginc.meta @@ -0,0 +1,9 @@ +fileFormatVersion: 2 +guid: 03aa6aec0b4851143af9a643594926d9 +ShaderImporter: + externalObjects: {} + defaultTextures: [] + nonModifiableTextures: [] + userData: + assetBundleName: + assetBundleVariant: diff --git a/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_PoiPanosphere.cginc b/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_PoiPanosphere.cginc new file mode 100644 index 00000000..eca50756 --- /dev/null +++ b/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_PoiPanosphere.cginc @@ -0,0 +1,81 @@ +#ifndef PANOSPHERE + #define PANOSPHERE + + float _PanoEmission; + float _PanoBlend; + float4 _PanosphereColor; + float3 _PanospherePan; + float _PanoToggle; + float _PanoCubeMapToggle; + float _PanoInfiniteStereoToggle; + + float3 panoColor; + float panoMask; + + #if defined(PROP_PANOSPHERETEXTURE) || !defined(OPTIMIZER_ENABLED) + sampler2D _PanosphereTexture; float4 _PanosphereTexture_ST; + #endif + #if defined(PROP_PANOCUBEMAP) || !defined(OPTIMIZER_ENABLED) + samplerCUBE _PanoCubeMap; half4 _PanoCubeMap_HDR; + #endif + #if defined(PROP_PANOMASK) || !defined(OPTIMIZER_ENABLED) + POI_TEXTURE_NOSAMPLER(_PanoMask); + #endif + + float2 projectIt(float3 coords) + { + float3 normalizedCoords = normalize(coords); + float latitude = acos(normalizedCoords.y); + float longitude = atan2(normalizedCoords.z, normalizedCoords.x); + float2 sphereCoords = float2(longitude + _Time.y * float4(0,0,0,0).x, latitude + _Time.y * float4(0,0,0,0).y) * float2(1.0 / UNITY_PI, 1.0 / UNITY_PI); + sphereCoords = float2(1.0, 1.0) - sphereCoords; + return(sphereCoords + float4(0, 1 - unity_StereoEyeIndex, 1, 1.0).xy) * float4(0, 1 - unity_StereoEyeIndex, 1, 1.0).zw; + } + + void applyPanosphereColor(inout float4 albedo, inout float3 panosphereEmission) + { + #if defined(PROP_PANOMASK) || !defined(OPTIMIZER_ENABLED) + panoMask = POI2D_SAMPLER_PAN(_PanoMask, _MainTex, poiMesh.uv[float(0)], float4(0,0,0,0)); + #else + panoMask = 1; + #endif + #ifdef POI_BLACKLIGHT + if (float(4) != 4) + { + panoMask *= blackLightMask[float(4)]; + } + #endif + + + if(float(0)) + { + #if defined(PROP_PANOCUBEMAP) || !defined(OPTIMIZER_ENABLED) + float3 cubeUV = mul(poiRotationMatrixFromAngles(float4(0,0,0,0).xyz * _Time.y), float4(-poiCam.viewDir, 1)); + half4 cubemap = texCUBE(_PanoCubeMap, cubeUV); + panoColor = DecodeHDR(cubemap, _PanoCubeMap_HDR) * float4(1,1,1,1).rgb; + #else + panoColor = float4(1,1,1,1).rgb; + #endif + } + else + { + float2 uv = projectIt(normalize(lerp(getCameraPosition().xyz, poiCam.worldPos.xyz, float(0)) - poiMesh.worldPos.xyz) * - 1); + + float2 ddxuv = ddx(uv); + float2 ddyuv = ddy(uv); + if(any(fwidth(uv) > .5)) + { + ddxuv = ddyuv = 0.001; + } + #if defined(PROP_PANOSPHERETEXTURE) || !defined(OPTIMIZER_ENABLED) + panoColor = tex2D(_PanosphereTexture, TRANSFORM_TEX(uv, _PanosphereTexture), ddxuv, ddyuv).rgb * float4(1,1,1,1).rgb; + #else + panoColor = float4(1,1,1,1).rgb; + #endif + } + panosphereEmission = panoColor * float(0) * panoMask * float(0); + albedo.rgb = lerp(albedo.rgb, panoColor, float(0) * .9999999 * panoMask); + } + +#endif + diff --git a/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_PoiPanosphere.cginc.meta b/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_PoiPanosphere.cginc.meta new file mode 100644 index 00000000..ec27ebe0 --- /dev/null +++ b/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_PoiPanosphere.cginc.meta @@ -0,0 +1,9 @@ +fileFormatVersion: 2 +guid: 39c0a1f16f9d5c14faed448e5a947051 +ShaderImporter: + externalObjects: {} + defaultTextures: [] + nonModifiableTextures: [] + userData: + assetBundleName: + assetBundleVariant: diff --git a/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_PoiParallax.cginc b/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_PoiParallax.cginc new file mode 100644 index 00000000..a533210c --- /dev/null +++ b/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_PoiParallax.cginc @@ -0,0 +1,166 @@ +#ifndef POI_PARALLAX + #define POI_PARALLAX + + #if defined(PROP_PARALLAXHEIGHTMAP) || !defined(OPTIMIZER_ENABLED) + UNITY_DECLARE_TEX2D_NOSAMPLER(_ParallaxHeightMap); float4 _ParallaxHeightMap_ST; + #endif + #if defined(PROP_PARALLAXHEIGHTMAPMASK) || !defined(OPTIMIZER_ENABLED) + POI_TEXTURE_NOSAMPLER(_ParallaxHeightMapMask); + #endif + float2 _ParallaxHeightMapPan; + float _ParallaxStrength; + float _ParallaxHeightMapEnabled; + float _ParallaxUV; + + //Internal + float _ParallaxInternalMapEnabled; + #if defined(PROP_PARALLAXINTERNALMAP) || !defined(OPTIMIZER_ENABLED) + UNITY_DECLARE_TEX2D_NOSAMPLER(_ParallaxInternalMap); float4 _ParallaxInternalMap_ST; + #endif + #if defined(PROP_PARALLAXINTERNALMAPMASK) || !defined(OPTIMIZER_ENABLED) + POI_TEXTURE_NOSAMPLER(_ParallaxInternalMapMask); + #endif + float _ParallaxInternalIterations; + float _ParallaxInternalMinDepth; + float _ParallaxInternalMaxDepth; + float _ParallaxInternalMinFade; + float _ParallaxInternalMaxFade; + float4 _ParallaxInternalMinColor; + float4 _ParallaxInternalMaxColor; + float4 _ParallaxInternalPanSpeed; + float4 _ParallaxInternalPanDepthSpeed; + float _ParallaxInternalHeightmapMode; + float _ParallaxInternalHeightFromAlpha; + + float GetParallaxHeight(float2 uv) + { + #if defined(PROP_PARALLAXHEIGHTMAP) || !defined(OPTIMIZER_ENABLED) + return clamp(UNITY_SAMPLE_TEX2D_SAMPLER(_ParallaxHeightMap, _MainTex, TRANSFORM_TEX(uv, _ParallaxHeightMap) + _Time.x * float4(0,0,0,0)).g, 0, .99999); + #else + return 0; + #endif + } + /* + float2 ParallaxOffset(float2 viewDir) + { + float height = GetParallaxHeight(); + height -= 0.5; + height *= float(0); + return viewDir * height; + } + */ + float2 ParallaxRaymarching(float2 viewDir) + { + float2 uvOffset = 0; + float stepSize = 0.1; + float2 uvDelta = viewDir * (stepSize * float(0)); + + float stepHeight = 1; + float surfaceHeight = GetParallaxHeight(poiMesh.uv[float(0)]); + + + float2 prevUVOffset = uvOffset; + float prevStepHeight = stepHeight; + float prevSurfaceHeight = surfaceHeight; + + for (int i = 1; i < 10 && stepHeight > surfaceHeight; i ++) + { + prevUVOffset = uvOffset; + prevStepHeight = stepHeight; + prevSurfaceHeight = surfaceHeight; + + uvOffset -= uvDelta; + stepHeight -= stepSize; + surfaceHeight = GetParallaxHeight(poiMesh.uv[float(0)] + uvOffset); + } + + float prevDifference = prevStepHeight - prevSurfaceHeight; + float difference = surfaceHeight - stepHeight; + float t = prevDifference / (prevDifference + difference); + uvOffset = prevUVOffset -uvDelta * t; + #if defined(PROP_PARALLAXHEIGHTMAPMASK) || !defined(OPTIMIZER_ENABLED) + return uvOffset *= POI2D_SAMPLER_PAN(_ParallaxHeightMapMask, _MainTex, poiMesh.uv[float(0)], float4(0,0,0,0)).r; + #else + return uvOffset; + #endif + } + + void calculateandApplyParallax() + { + + if (float(0)) + { + float2 parallaxOffset = ParallaxRaymarching(poiCam.tangentViewDir.xy); + + if(float(0) == 0) + { + poiMesh.uv[0] += parallaxOffset; + } + + if(float(0) == 1) + { + poiMesh.uv[1] += parallaxOffset; + } + + if(float(0) == 2) + { + poiMesh.uv[2] += parallaxOffset; + } + + if(float(0) == 3) + { + poiMesh.uv[3] += parallaxOffset; + } + } + } + + void calculateAndApplyInternalParallax(inout float4 finalColor) + { + #if defined(_PARALLAXMAP) + + if(float(0)) + { + float3 parallax = 0; + + for (int j = float(1); j > 0; j --) + { + float ratio = (float)j / float(1); + float2 parallaxOffset = _Time.y * (float4(0,0,0,0) + (1 - ratio) * float4(0,0,0,0)); + float fade = lerp(float(0), float(1), ratio); + #if defined(PROP_PARALLAXINTERNALMAP) || !defined(OPTIMIZER_ENABLED) + float4 parallaxColor = UNITY_SAMPLE_TEX2D_SAMPLER(_ParallaxInternalMap, _MainTex, TRANSFORM_TEX(poiMesh.uv[0], _ParallaxInternalMap) + lerp(float(0), float(1), ratio) * - poiCam.tangentViewDir.xy + parallaxOffset); + #else + float4 parallaxColor = 0; + #endif + float3 parallaxTint = lerp(float4(1,1,1,1), float4(1,1,1,1), ratio); + float parallaxHeight; + if(float(0)) + { + parallaxTint *= parallaxColor.rgb; + parallaxHeight = parallaxColor.a; + } + else + { + parallaxHeight = parallaxColor.r; + } + //float parallaxColor *= lerp(float4(1,1,1,1), float4(1,1,1,1), 1 - ratio); + + if (float(0) == 1) + { + parallax = lerp(parallax, parallaxTint * fade, parallaxHeight >= 1 - ratio); + } + else + { + parallax += parallaxTint * parallaxHeight * fade; + } + } + //parallax /= float(1); + #if defined(PROP_PARALLAXINTERNALMAPMASK) || !defined(OPTIMIZER_ENABLED) + finalColor.rgb += parallax * POI2D_SAMPLER_PAN(_ParallaxInternalMapMask, _MainTex, poiMesh.uv[float(0)], float4(0,0,0,0)).r; + #else + finalColor.rgb += parallax; + #endif + } + #endif + } +#endif diff --git a/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_PoiParallax.cginc.meta b/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_PoiParallax.cginc.meta new file mode 100644 index 00000000..d1aceac9 --- /dev/null +++ b/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_PoiParallax.cginc.meta @@ -0,0 +1,9 @@ +fileFormatVersion: 2 +guid: 6fddd034ada8a244f97d51ab9fb9c13a +ShaderImporter: + externalObjects: {} + defaultTextures: [] + nonModifiableTextures: [] + userData: + assetBundleName: + assetBundleVariant: diff --git a/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_PoiPass.cginc b/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_PoiPass.cginc new file mode 100644 index 00000000..eb52e4d6 --- /dev/null +++ b/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_PoiPass.cginc @@ -0,0 +1,248 @@ +/* +USED--------------------------------------------- +"_PARALLAXMAP" +"_REQUIRE_UV2" +"_SUNDISK_NONE" +"_DETAIL_MULX2" +"_GLOSSYREFLECTIONS_OFF" +"_METALLICGLOSSMAP" +"_COLORADDSUBDIFF_ON" +"_SPECGLOSSMAP" +"_TERRAIN_NORMAL_MAP" +"_SUNDISK_SIMPLE" +"_EMISSION" +"_COLORCOLOR_ON" +"_COLOROVERLAY_ON" +"_ALPHAMODULATE_ON" +"_SUNDISK_HIGH_QUALITY" +"_MAPPING_6_FRAMES_LAYOUT" +"_NORMALMAP +"EFFECT_BUMP" +"BLOOM" +"BLOOM_LOW" +"GRAIN" +"DEPTH_OF_FIELD" +"USER_LUT" +"CHROMATIC_ABERRATION_LOW" +"BLOOM_LENS_DIRT" +"_FADING_ON" +"CHROMATIC_ABERRATION" +"DISTORT" +"GEOM_TYPE_BRANCH" +"_SPECULARHIGHLIGHTS_OFF" +"_SMOOTHNESS_TEXTURE_ALBEDO_CHANNEL_A" +"EFFECT_HUE_VARIATION" +"GEOM_TYPE_LEAF" +"GEOM_TYPE_MESH" +"FINALPASS" +"AUTO_EXPOSURE +"VIGNETTE" +"VIGNETTE_MASKED" +"COLOR_GRADING_HDR" +"COLOR_GRADING_HDR_3D" +"DITHERING" +"VIGNETTE_CLASSIC" +"GEOM_TYPE_BRANCH_DETAIL" +"GEOM_TYPE_FROND" +"DEPTH_OF_FIELD_COC_VIEW" +"COLOR_GRADING_LOG_VIEW" + +UNUSED------------------------------------------- +"_ALPHABLEND_ON" +"_ALPHAPREMULTIPLY_ON" +"_ALPHATEST_ON" +"PIXELSNAP_ON" +"TONEMAPPING_FILMIC" +"TONEMAPPING_NEUTRAL" +"TONEMAPPING_ACES" +"TONEMAPPING_CUSTOM" +"COLOR_GRADING" + +DO NOT USE ----------------------------------------- +"BILLBOARD_FACE_CAMERA_POS" +SOFTPARTICLES_ON +*/ + + +#ifndef POI_PASS +#define POI_PASS + +#include "UnityCG.cginc" +#include "Lighting.cginc" +#include "UnityPBSLighting.cginc" +#include "AutoLight.cginc" +#include "UnityShaderVariables.cginc" + +#ifdef POI_META_PASS + #include "UnityMetaPass.cginc" +#endif + +//#pragma warning (default : 3206) // implicit truncation + +#include "CGI_PoiMacros.cginc" +#include "CGI_PoiDefines.cginc" +#include "CGI_FunctionsArtistic.cginc" + +#include "CGI_Poicludes.cginc" +#include "CGI_PoiHelpers.cginc" +#include "CGI_PoiBlending.cginc" + +#ifdef _SUNDISK_NONE + #include "CGI_PoiRandom.cginc" +#endif + +#ifdef _REQUIRE_UV2 + #include "CGI_PoiMirror.cginc" +#endif + +#include "CGI_PoiPenetration.cginc" +#include "CGI_PoiVertexManipulations.cginc" + +#include "CGI_PoiSpawnInVert.cginc" + +#include "CGI_PoiV2F.cginc" + +#ifdef BLOOM_LOW + #include "CGI_PoiBulge.cginc" +#endif + +#include "CGI_PoiVert.cginc" + +#ifdef TESSELATION + #include "CGI_PoiTessellation.cginc" +#endif + +#include "CGI_PoiDithering.cginc" + +#ifdef _PARALLAXMAP + #include "CGI_PoiParallax.cginc" +#endif + +#ifdef USER_LUT + #include "CGI_PoiUVDistortion.cginc" +#endif + +#ifdef VIGNETTE + #include "CGI_PoiRGBMask.cginc" +#endif + +#ifdef COLOR_GRADING_LOG_VIEW + #include "CGI_PoiAudioLink.cginc" +#endif + +#include "CGI_PoiData.cginc" + +#ifdef _SPECULARHIGHLIGHTS_OFF + #include "CGI_PoiBlackLight.cginc" +#endif + +#include "CGI_PoiSpawnInFrag.cginc" + +#ifdef WIREFRAME + #include "CGI_PoiWireframe.cginc" +#endif + +#ifdef DISTORT + #include "CGI_PoiDissolve.cginc" +#endif + +#ifdef DEPTH_OF_FIELD + #include "CGI_PoiHologram.cginc" +#endif + +#ifdef BLOOM_LENS_DIRT + #include "CGI_PoiIridescence.cginc" +#endif + + +#ifdef FUR + //#include "CGI_PoiFur.cginc" + //#include "CGI_PoiGeomFur.cginc" +#endif + +#ifdef VIGNETTE_MASKED + #include "CGI_PoiLighting.cginc" +#endif + +#include "CGI_PoiMainTex.cginc" + +#ifdef GEOM_TYPE_BRANCH + #include "CGI_PoiDecal.cginc" +#endif + +#ifdef CHROMATIC_ABERRATION + #include "CGI_PoiVoronoi.cginc" +#endif + +#ifdef _DETAIL_MULX2 + #include "CGI_PoiPanosphere.cginc" +#endif + +#ifdef EFFECT_BUMP + #include "CGI_PoiMSDF.cginc" +#endif + +#ifdef GRAIN + #include "CGI_PoiDepthColor.cginc" +#endif + + +#ifdef _SUNDISK_HIGH_QUALITY + #include "CGI_PoiFlipbook.cginc" +#endif + +#ifdef _GLOSSYREFLECTIONS_OFF + #include "CGI_PoiRimLighting.cginc" +#endif + +#ifdef _MAPPING_6_FRAMES_LAYOUT + #include "CGI_PoiEnvironmentalRimLighting.cginc" +#endif + +#ifdef VIGNETTE_CLASSIC + #include "CGI_PoiBRDF.cginc" +#endif + +#ifdef _METALLICGLOSSMAP + #include "CGI_PoiMetal.cginc" +#endif + +#ifdef _COLORADDSUBDIFF_ON + #include "CGI_PoiMatcap.cginc" +#endif + +#ifdef _SPECGLOSSMAP + #include "CGI_PoiSpecular.cginc" +#endif + +#ifdef BLOOM + #include "CGI_PoiVideo.cginc" +#endif + +#ifdef _TERRAIN_NORMAL_MAP + #include "CGI_PoiSubsurfaceScattering.cginc" +#endif + +#include "CGI_PoiBlending.cginc" +#include "CGI_PoiGrab.cginc" + +#ifdef _SUNDISK_SIMPLE + #include "CGI_PoiGlitter.cginc" +#endif + +#ifdef _EMISSION + #include "CGI_PoiEmission.cginc" +#endif + +#ifdef _COLORCOLOR_ON + #include "CGI_PoiClearCoat.cginc" +#endif + +#include "CGI_PoiAlphaToCoverage.cginc" + +#ifdef _COLOROVERLAY_ON + #include "CGI_PoiDebug.cginc" +#endif +#include "CGI_PoiFrag.cginc" + +#endif diff --git a/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_PoiPass.cginc.meta b/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_PoiPass.cginc.meta new file mode 100644 index 00000000..0dbdf030 --- /dev/null +++ b/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_PoiPass.cginc.meta @@ -0,0 +1,9 @@ +fileFormatVersion: 2 +guid: 63f28ff14a6ec68439a24745753cf57c +ShaderImporter: + externalObjects: {} + defaultTextures: [] + nonModifiableTextures: [] + userData: + assetBundleName: + assetBundleVariant: diff --git a/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_PoiPassOutline.cginc b/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_PoiPassOutline.cginc new file mode 100644 index 00000000..4fa298f3 --- /dev/null +++ b/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_PoiPassOutline.cginc @@ -0,0 +1,30 @@ +#ifndef POI_PASS_OUTLINE + #define POI_PASS_OUTLINE + + #include "UnityCG.cginc" + #include "Lighting.cginc" + #include "UnityPBSLighting.cginc" + #include "AutoLight.cginc" + #include "CGI_PoiMacros.cginc" + #include "CGI_PoiDefines.cginc" + #include "CGI_FunctionsArtistic.cginc" + #include "CGI_Poicludes.cginc" + #include "CGI_PoiHelpers.cginc" + #include "CGI_PoiBlending.cginc" + #include "CGI_PoiPenetration.cginc" + #include "CGI_PoiOutlineVert.cginc" + #ifdef TESSELATION + #include "CGI_PoiTessellation.cginc" + #endif + #ifdef _REQUIRE_UV2 + #include "CGI_PoiMirror.cginc" + #endif + #ifdef DISTORT + #include "CGI_PoiDissolve.cginc" + #endif + #include "CGI_PoiLighting.cginc" + #include "CGI_PoiMainTex.cginc" + #include "CGI_PoiData.cginc" + #include "CGI_PoiDithering.cginc" + #include "CGI_PoiOutlineFrag.cginc" +#endif diff --git a/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_PoiPassOutline.cginc.meta b/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_PoiPassOutline.cginc.meta new file mode 100644 index 00000000..29f6e202 --- /dev/null +++ b/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_PoiPassOutline.cginc.meta @@ -0,0 +1,9 @@ +fileFormatVersion: 2 +guid: ee1f99c6010b52c4e83e0d53c383893c +ShaderImporter: + externalObjects: {} + defaultTextures: [] + nonModifiableTextures: [] + userData: + assetBundleName: + assetBundleVariant: diff --git a/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_PoiPassShadow.cginc b/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_PoiPassShadow.cginc new file mode 100644 index 00000000..3748a40c --- /dev/null +++ b/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_PoiPassShadow.cginc @@ -0,0 +1,46 @@ +#ifndef POI_PASS_SHADOW + #define POI_PASS_SHADOW + + #pragma multi_compile_shadowcaster + #include "UnityCG.cginc" + #include "UnityShaderVariables.cginc" + #include "UnityCG.cginc" + #include "Lighting.cginc" + #include "UnityPBSLighting.cginc" + #include "AutoLight.cginc" + + #include "CGI_PoiMacros.cginc" + #include "CGI_PoiDefines.cginc" + + #include "CGI_Poicludes.cginc" + #include "CGI_PoiShadowIncludes.cginc" + #include "CGI_PoiHelpers.cginc" + #include "CGI_PoiMirror.cginc" + #include "CGI_PoiSpawnInFrag.cginc" + + #include "CGI_PoiV2F.cginc" + #include "CGI_PoiData.cginc" + + #ifdef WIREFRAME + #include "CGI_PoiWireframe.cginc" + #endif + + #ifdef _SUNDISK_HIGH_QUALITY + #include "CGI_PoiFlipbook.cginc" + #endif + + #ifdef _SUNDISK_NONE + #include "CGI_PoiRandom.cginc" + #endif + #include "CGI_PoiDithering.cginc" + #ifdef DISTORT + #include "CGI_PoiDissolve.cginc" + #endif + #include "CGI_PoiPenetration.cginc" + #include "CGI_PoiVertexManipulations.cginc" + + #include "CGI_PoiSpawnInVert.cginc" + #include "CGI_PoiShadowVert.cginc" + #include "CGI_PoiShadowFrag.cginc" + +#endif diff --git a/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_PoiPassShadow.cginc.meta b/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_PoiPassShadow.cginc.meta new file mode 100644 index 00000000..02abd675 --- /dev/null +++ b/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_PoiPassShadow.cginc.meta @@ -0,0 +1,9 @@ +fileFormatVersion: 2 +guid: eb45206ef4a23274aa7c2c31bb85809f +ShaderImporter: + externalObjects: {} + defaultTextures: [] + nonModifiableTextures: [] + userData: + assetBundleName: + assetBundleVariant: diff --git a/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_PoiPenetration.cginc b/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_PoiPenetration.cginc new file mode 100644 index 00000000..de540bfd --- /dev/null +++ b/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_PoiPenetration.cginc @@ -0,0 +1,210 @@ +#ifndef RALIV_PENETRATION + #define RALIV_PENETRATION + + float _PenetratorEnabled; + float _squeeze; + float _SqueezeDist; + float _BulgeOffset; + float _BulgePower; + float _Length; + float _EntranceStiffness; + float _Curvature; + float _ReCurvature; + float _WriggleSpeed; + float _Wriggle; + float _OrificeChannel; + float __dirty; + + float _OrifaceEnabled; + sampler2D _OrificeData; + float _EntryOpenDuration; + float _Shape1Depth; + float _Shape1Duration; + float _Shape2Depth; + float _Shape2Duration; + float _Shape3Depth; + float _Shape3Duration; + float _BlendshapePower; + float _BlendshapeBadScaleFix; + + void GetBestLights(float Channel, inout int orificeType, inout float3 orificePositionTracker, inout float3 orificeNormalTracker, inout float3 penetratorPositionTracker, inout float penetratorLength) + { + float ID = step(0.5, Channel); + float baseID = (ID * 0.02); + float holeID = (baseID + 0.01); + float ringID = (baseID + 0.02); + float normalID = (0.05 + (ID * 0.01)); + float penetratorID = (0.09 + (ID * - 0.01)); + float4 orificeWorld; + float4 orificeNormalWorld; + float4 penetratorWorld; + float penetratorDist = 100; + for (int i = 0; i < 4; i ++) + { + float range = (0.005 * sqrt(1000000 - unity_4LightAtten0[i])) / sqrt(unity_4LightAtten0[i]); + if (length(unity_LightColor[i].rgb) < 0.01) + { + if(abs(fmod(range, 0.1) - holeID) < 0.005) + { + orificeType = 0; + orificeWorld = float4(unity_4LightPosX0[i], unity_4LightPosY0[i], unity_4LightPosZ0[i], 1); + orificePositionTracker = mul(unity_WorldToObject, orificeWorld).xyz; + } + if(abs(fmod(range, 0.1) - ringID) < 0.005) + { + orificeType = 1; + orificeWorld = float4(unity_4LightPosX0[i], unity_4LightPosY0[i], unity_4LightPosZ0[i], 1); + orificePositionTracker = mul(unity_WorldToObject, orificeWorld).xyz; + } + if(abs(fmod(range, 0.1) - normalID) < 0.005) + { + orificeNormalWorld = float4(unity_4LightPosX0[i], unity_4LightPosY0[i], unity_4LightPosZ0[i], 1); + orificeNormalTracker = mul(unity_WorldToObject, orificeNormalWorld).xyz; + } + if(abs(fmod(range, 0.1) - penetratorID) < 0.005) + { + float3 tempPenetratorPositionTracker = penetratorPositionTracker; + penetratorWorld = float4(unity_4LightPosX0[i], unity_4LightPosY0[i], unity_4LightPosZ0[i], 1); + penetratorPositionTracker = mul(unity_WorldToObject, penetratorWorld).xyz; + if(length(penetratorPositionTracker) > length(tempPenetratorPositionTracker)) + { + penetratorPositionTracker = tempPenetratorPositionTracker; + } + else + { + penetratorLength = unity_LightColor[i].a; + } + } + } + } + } + + #ifdef POI_SHADOW + void applyRalivDynamicPenetrationSystem(inout float3 VertexPosition, inout float3 VertexNormal, inout VertexInputShadow v) + #else + void applyRalivDynamicPenetrationSystem(inout float3 VertexPosition, inout float3 VertexNormal, inout appdata v) + #endif + { + + if(float(1)) + { + float orificeType = 0; + float3 orificePositionTracker = float3(0, 0, 100); + float3 orificeNormalTracker = float3(0, 0, 99); + float3 penetratorPositionTracker = float3(0, 0, 1); + float pl = 0; + GetBestLights(float(0), orificeType, orificePositionTracker, orificeNormalTracker, penetratorPositionTracker, pl); + float3 orificeNormal = normalize(lerp((orificePositionTracker - orificeNormalTracker), orificePositionTracker, max(float(0.01), 0.01))); + float3 PhysicsNormal = normalize(penetratorPositionTracker.xyz) * float(0.52) * 0.3; + float wriggleTime = _Time.y * float(6.2); + float temp_output_257_0 = (float(0.52) * ((cos(wriggleTime) * float(0)) + float(0))); + float wiggleTime = _Time.y * (float(6.2) * 0.39); + float distanceToOrifice = length(orificePositionTracker); + float enterFactor = smoothstep((float(0.52) + - 0.05), float(0.52), distanceToOrifice); + float3 finalOrificeNormal = normalize(lerp(orificeNormal, (PhysicsNormal + ((float3(0, 1, 0) * (temp_output_257_0 + (float(0.52) * (float(0) + ((sin(wriggleTime) * 0.3) * float(0))) * 2.0))) + (float3(0.5, 0, 0) * (cos(wiggleTime) * float(0))))), enterFactor)); + float smoothstepResult186 = smoothstep(float(0.52), (float(0.52) + 0.05), distanceToOrifice); + float3 finalOrificePosition = lerp(orificePositionTracker, ((normalize(penetratorPositionTracker) * float(0.52)) + (float3(0, 0.2, 0) * (sin((wriggleTime + UNITY_PI)) * float(0)) * float(0.52)) + (float3(0.2, 0, 0) * float(0.52) * (sin((wiggleTime + UNITY_PI)) * float(0)))), smoothstepResult186); + float finalOrificeDistance = length(finalOrificePosition); + float3 bezierBasePosition = float3(0, 0, 0); + float temp_output_59_0 = (finalOrificeDistance / 3.0); + float3 lerpResult274 = lerp(float3(0, 0, 0), (float3(0, 1, 0) * (temp_output_257_0 * - 0.2)), saturate((distanceToOrifice / float(0.52)))); + float3 temp_output_267_0 = ((temp_output_59_0 * float3(0, 0, 1)) + lerpResult274); + float3 bezierBaseNormal = temp_output_267_0; + float3 temp_output_63_0 = (finalOrificePosition - (temp_output_59_0 * finalOrificeNormal)); + float3 bezierOrificeNormal = temp_output_63_0; + float3 bezierOrificePosition = finalOrificePosition; + float vertexBaseTipPosition = (v.vertex.z / finalOrificeDistance); + float t = saturate(vertexBaseTipPosition); + float oneMinusT = 1 - t; + float3 bezierPoint = oneMinusT * oneMinusT * oneMinusT * bezierBasePosition + 3 * oneMinusT * oneMinusT * t * bezierBaseNormal + 3 * oneMinusT * t * t * bezierOrificeNormal + t * t * t * bezierOrificePosition; + float3 straightLine = (float3(0.0, 0.0, v.vertex.z)); + float baseFactor = smoothstep(0.05, -0.05, v.vertex.z); + bezierPoint = lerp(bezierPoint, straightLine, baseFactor); + bezierPoint = lerp(((finalOrificeNormal * (v.vertex.z - finalOrificeDistance)) + finalOrificePosition), bezierPoint, step(vertexBaseTipPosition, 1.0)); + float3 bezierDerivitive = 3 * oneMinusT * oneMinusT * (bezierBaseNormal - bezierBasePosition) + 6 * oneMinusT * t * (bezierOrificeNormal - bezierBaseNormal) + 3 * t * t * (bezierOrificePosition - bezierOrificeNormal); + bezierDerivitive = normalize(lerp(bezierDerivitive, float3(0, 0, 1), baseFactor)); + float bezierUpness = dot(bezierDerivitive, float3(0, 1, 0)); + float3 bezierUp = lerp(float3(0, 1, 0), float3(0, 0, -1), saturate(bezierUpness)); + float bezierDownness = dot(bezierDerivitive, float3(0, -1, 0)); + bezierUp = normalize(lerp(bezierUp, float3(0, 0, 1), saturate(bezierDownness))); + float3 bezierSpaceX = normalize(cross(bezierDerivitive, bezierUp)); + float3 bezierSpaceY = normalize(cross(bezierDerivitive, -bezierSpaceX)); + float3 bezierSpaceVertexOffset = ((v.vertex.y * bezierSpaceY) + (v.vertex.x * - bezierSpaceX)); + float3 bezierSpaceVertexOffsetNormal = normalize(bezierSpaceVertexOffset); + float distanceFromTip = (finalOrificeDistance - v.vertex.z); + float squeezeFactor = smoothstep(0.0, float(0.0259), -distanceFromTip); + squeezeFactor = max(squeezeFactor, smoothstep(0.0, float(0.0259), distanceFromTip)); + float3 bezierSpaceVertexOffsetSqueezed = lerp((bezierSpaceVertexOffsetNormal * min(length(bezierSpaceVertexOffset), float(0.032))), bezierSpaceVertexOffset, squeezeFactor); + float bulgeFactor = smoothstep(0.0, float(0.158), abs((finalOrificeDistance - v.vertex.z))); + float bulgeFactorBaseClip = smoothstep(0.0, 0.05, v.vertex.z); + float bezierSpaceVertexOffsetBulged = lerp(1.0, (1.0 + float(0.00127)), ((1.0 - bulgeFactor) * 100.0 * bulgeFactorBaseClip)); + float3 bezierSpaceVertexOffsetFinal = lerp((bezierSpaceVertexOffsetSqueezed * bezierSpaceVertexOffsetBulged), bezierSpaceVertexOffset, enterFactor); + float3 bezierConstructedVertex = (bezierPoint + bezierSpaceVertexOffsetFinal); + float3 sphereifyDistance = (bezierConstructedVertex - finalOrificePosition); + float3 sphereifyNormal = normalize(sphereifyDistance); + float sphereifyFactor = smoothstep(0.05, -0.05, distanceFromTip); + float killSphereifyForRing = lerp(sphereifyFactor, 0.0, orificeType); + bezierConstructedVertex = lerp(bezierConstructedVertex, ((min(length(sphereifyDistance), float(0.032)) * sphereifyNormal) + finalOrificePosition), killSphereifyForRing); + float3 ase_worldPos = mul(unity_ObjectToWorld, v.vertex); + float3 ase_worldViewDir = normalize(UnityWorldSpaceViewDir(ase_worldPos)); + bezierConstructedVertex = lerp(bezierConstructedVertex, (-ase_worldViewDir * float3(10000, 10000, 10000)), _WorldSpaceLightPos0.w); + //v.normal = normalize( ( ( -bezierSpaceX * v.normal.x ) + ( bezierSpaceY * v.normal.y ) + ( bezierDerivitive * v.normal.z ) ) ); + //v.vertex.xyz = bezierConstructedVertex; + //v.vertex.w = 1; + VertexPosition = bezierConstructedVertex; + v.vertex.w = 1; + VertexNormal = normalize(((-bezierSpaceX * VertexNormal.x) + (bezierSpaceY * VertexNormal.y) + (bezierDerivitive * VertexNormal.z))); + } + } + + float3 getBlendOffset(float blendSampleIndex, float activationDepth, float activationSmooth, int vertexID, float penetrationDepth, float3 normal, float3 tangent, float3 binormal) + { + float blendTextureSize = 1024; + float2 blendSampleUV = (float2(((fmod((float)vertexID, blendTextureSize) + 0.5) / (blendTextureSize)), (((floor((vertexID / (blendTextureSize))) + 0.5) / (blendTextureSize)) + blendSampleIndex / 8))); + float3 sampledBlend = tex2Dlod(_OrificeData, float4(blendSampleUV, 0, 0.0)).rgb; + float blendActivation = smoothstep((activationDepth), (activationDepth + activationSmooth), penetrationDepth); + blendActivation = -cos(blendActivation * 3.1416) * 0.5 + 0.5; + float3 blendOffset = ((sampledBlend - float3(1, 1, 1)) * (blendActivation) * float(1) * float(1)); + return((blendOffset.x * normal) + (blendOffset.y * tangent) + (blendOffset.z * binormal)); + } + + #ifdef POI_SHADOW + void applyRalivDynamicOrifaceSystem(inout VertexInputShadow v) + #else + void applyRalivDynamicOrifaceSystem(inout appdata v) + #endif + { + + if (float(0)) + { + float penetratorLength = 0.1; + float penetratorDistance; + float3 orificePositionTracker = float3(0, 0, -100); + float3 orificeNormalTracker = float3(0, 0, -99); + float3 penetratorPositionTracker = float3(0, 0, 100); + float orificeType = 0; + + GetBestLights(float(0), orificeType, orificePositionTracker, orificeNormalTracker, penetratorPositionTracker, penetratorLength); + penetratorDistance = distance(orificePositionTracker, penetratorPositionTracker); + + float penetrationDepth = (penetratorLength - penetratorDistance); + + float3 normal = normalize(v.normal); + float3 tangent = normalize(v.tangent.xyz); + float3 binormal = normalize(cross(normal, tangent)); + + v.vertex.xyz += getBlendOffset(0, 0, float(0.1), v.vertexId, penetrationDepth, normal, tangent, binormal); + v.vertex.xyz += getBlendOffset(2, float(0.1), float(0.1), v.vertexId, penetrationDepth, normal, tangent, binormal); + v.vertex.xyz += getBlendOffset(4, float(0.2), float(0.1), v.vertexId, penetrationDepth, normal, tangent, binormal); + v.vertex.xyz += getBlendOffset(6, float(0.3), float(0.1), v.vertexId, penetrationDepth, normal, tangent, binormal); + v.vertex.w = 1; + + v.normal += getBlendOffset(1, 0, float(0.1), v.vertexId, penetrationDepth, normal, tangent, binormal); + v.normal += getBlendOffset(3, float(0.1), float(0.1), v.vertexId, penetrationDepth, normal, tangent, binormal); + v.normal += getBlendOffset(5, float(0.2), float(0.1), v.vertexId, penetrationDepth, normal, tangent, binormal); + v.normal += getBlendOffset(7, float(0.3), float(0.1), v.vertexId, penetrationDepth, normal, tangent, binormal); + v.normal = normalize(v.normal); + } + } + +#endif diff --git a/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_PoiPenetration.cginc.meta b/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_PoiPenetration.cginc.meta new file mode 100644 index 00000000..d0f2e328 --- /dev/null +++ b/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_PoiPenetration.cginc.meta @@ -0,0 +1,9 @@ +fileFormatVersion: 2 +guid: b2db505aa0ff66542aed70ea5a6c7192 +ShaderImporter: + externalObjects: {} + defaultTextures: [] + nonModifiableTextures: [] + userData: + assetBundleName: + assetBundleVariant: diff --git a/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_PoiRGBMask.cginc b/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_PoiRGBMask.cginc new file mode 100644 index 00000000..d2cba777 --- /dev/null +++ b/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_PoiRGBMask.cginc @@ -0,0 +1,168 @@ +#ifndef POI_RGBMASK + #define POI_RGBMASK + #if defined(PROP_RGBMASK) || !defined(OPTIMIZER_ENABLED) + UNITY_DECLARE_TEX2D_NOSAMPLER(_RGBMask); float4 _RGBMask_ST; + #endif + #if defined(PROP_REDTEXURE) || !defined(OPTIMIZER_ENABLED) + UNITY_DECLARE_TEX2D_NOSAMPLER(_RedTexure); float4 _RedTexure_ST; + #endif + #if defined(PROP_GREENTEXTURE) || !defined(OPTIMIZER_ENABLED) + UNITY_DECLARE_TEX2D_NOSAMPLER(_GreenTexture); float4 _GreenTexture_ST; + #endif + #if defined(PROP_BLUETEXTURE) || !defined(OPTIMIZER_ENABLED) + UNITY_DECLARE_TEX2D_NOSAMPLER(_BlueTexture); float4 _BlueTexture_ST; + #endif + + #ifdef GEOM_TYPE_MESH + #if defined(PROP_RGBNORMALR) || !defined(OPTIMIZER_ENABLED) + #endif + #if defined(PROP_RGBNORMALG) || !defined(OPTIMIZER_ENABLED) + #endif + #if defined(PROP_RGBNORMALB) || !defined(OPTIMIZER_ENABLED) + #endif + POI_NORMAL_NOSAMPLER(_RgbNormalR); + POI_NORMAL_NOSAMPLER(_RgbNormalG); + POI_NORMAL_NOSAMPLER(_RgbNormalB); + float _RgbNormalsEnabled; + #endif + + float4 _RedColor; + float4 _GreenColor; + float4 _BlueColor; + + float2 _RGBMaskPanning; + float2 _RGBRedPanning; + float2 _RGBGreenPanning; + float2 _RGBBluePanning; + + float _RGBBlendMultiplicative; + + float _RGBMaskUV; + float _RGBRed_UV; + float _RGBGreen_UV; + float _RGBBlue_UV; + float _RGBUseVertexColors; + float _RGBNormalBlend; + + static float3 rgbMask; + + void calculateRGBNormals(inout half3 mainTangentSpaceNormal) + { + #ifdef GEOM_TYPE_MESH + #ifndef RGB_MASK_TEXTURE + #define RGB_MASK_TEXTURE + + if (float(0)) + { + rgbMask = poiMesh.vertexColor.rgb; + } + else + { + #if defined(PROP_RGBMASK) || !defined(OPTIMIZER_ENABLED) + rgbMask = POI2D_SAMPLER_PAN(_RGBMask, _MainTex, poiMesh.uv[float(0)], float4(0,0,0,0)).rgb; + #else + rgbMask = 1; + #endif + } + #endif + + + if(float(0)) + { + + if(float(0) == 0) + { + + if(float(0) > 0) + { + half3 normalToBlendWith = UnpackScaleNormal(POI2D_SAMPLER_PAN(_RgbNormalR, _MainTex, poiMesh.uv[float(0)], float4(0,0,0,0)), float(0)); + mainTangentSpaceNormal = lerp(mainTangentSpaceNormal, normalToBlendWith, rgbMask.r); + } + + + if(float(0) > 0) + { + half3 normalToBlendWith = UnpackScaleNormal(POI2D_SAMPLER_PAN(_RgbNormalG, _MainTex, poiMesh.uv[float(0)], float4(0,0,0,0)), float(0)); + mainTangentSpaceNormal = lerp(mainTangentSpaceNormal, normalToBlendWith, rgbMask.g); + } + + + if(float(0) > 0) + { + half3 normalToBlendWith = UnpackScaleNormal(POI2D_SAMPLER_PAN(_RgbNormalB, _MainTex, poiMesh.uv[float(0)], float4(0,0,0,0)), float(0)); + mainTangentSpaceNormal = lerp(mainTangentSpaceNormal, normalToBlendWith, rgbMask.b); + } + + return; + } + else + { + half3 newNormal = UnpackScaleNormal(POI2D_SAMPLER_PAN(_RgbNormalR, _MainTex, poiMesh.uv[float(0)], float4(0,0,0,0)), float(0) * rgbMask.r); + half3 normalToBlendWith = UnpackScaleNormal(POI2D_SAMPLER_PAN(_RgbNormalG, _MainTex, poiMesh.uv[float(0)], float4(0,0,0,0)), float(0) * rgbMask.g); + newNormal = BlendNormals(newNormal, normalToBlendWith); + normalToBlendWith = UnpackScaleNormal(POI2D_SAMPLER_PAN(_RgbNormalB, _MainTex, poiMesh.uv[float(0)], float4(0,0,0,0)), float(0) * rgbMask.b); + newNormal = BlendNormals(newNormal, normalToBlendWith); + mainTangentSpaceNormal = BlendNormals(newNormal, mainTangentSpaceNormal); + return; + } + } + #endif + } + + float3 calculateRGBMask(float3 baseColor) + { + //If RGB normals are in use this data will already exist + #ifndef RGB_MASK_TEXTURE + #define RGB_MASK_TEXTURE + + + if (float(0)) + { + rgbMask = poiMesh.vertexColor.rgb; + } + else + { + #if defined(PROP_RGBMASK) || !defined(OPTIMIZER_ENABLED) + rgbMask = POI2D_SAMPLER_PAN(_RGBMask, _MainTex, poiMesh.uv[float(0)], float4(0,0,0,0)).rgb; + #else + rgbMask = 1; + #endif + } + #endif + #if defined(PROP_REDTEXURE) || !defined(OPTIMIZER_ENABLED) + float4 red = POI2D_SAMPLER_PAN(_RedTexure, _MainTex, poiMesh.uv[float(0)], float4(0,0,0,0)); + #else + float4 red = 1; + #endif + #if defined(PROP_GREENTEXTURE) || !defined(OPTIMIZER_ENABLED) + float4 green = POI2D_SAMPLER_PAN(_GreenTexture, _MainTex, poiMesh.uv[float(0)], float4(0,0,0,0)); + #else + float4 green = 1; + #endif + #if defined(PROP_BLUETEXTURE) || !defined(OPTIMIZER_ENABLED) + float4 blue = POI2D_SAMPLER_PAN(_BlueTexture, _MainTex, poiMesh.uv[float(0)], float4(0,0,0,0)); + #else + float4 blue = 1; + #endif + + + if(float(0)) + { + float3 RGBColor = 1; + RGBColor = lerp(RGBColor, red.rgb * float4(1,1,1,1).rgb, rgbMask.r * red.a * float4(1,1,1,1).a); + RGBColor = lerp(RGBColor, green.rgb * float4(1,1,1,1).rgb, rgbMask.g * green.a * float4(1,1,1,1).a); + RGBColor = lerp(RGBColor, blue.rgb * float4(1,1,1,1).rgb, rgbMask.b * blue.a * float4(1,1,1,1).a); + + baseColor *= RGBColor; + } + else + { + baseColor = lerp(baseColor, red.rgb * float4(1,1,1,1).rgb, rgbMask.r * red.a * float4(1,1,1,1).a); + baseColor = lerp(baseColor, green.rgb * float4(1,1,1,1).rgb, rgbMask.g * green.a * float4(1,1,1,1).a); + baseColor = lerp(baseColor, blue.rgb * float4(1,1,1,1).rgb, rgbMask.b * blue.a * float4(1,1,1,1).a); + } + + return baseColor; + } + +#endif diff --git a/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_PoiRGBMask.cginc.meta b/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_PoiRGBMask.cginc.meta new file mode 100644 index 00000000..1237abfc --- /dev/null +++ b/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_PoiRGBMask.cginc.meta @@ -0,0 +1,9 @@ +fileFormatVersion: 2 +guid: e84cde95cf78a9949a1d92f795841684 +ShaderImporter: + externalObjects: {} + defaultTextures: [] + nonModifiableTextures: [] + userData: + assetBundleName: + assetBundleVariant: diff --git a/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_PoiRandom.cginc b/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_PoiRandom.cginc new file mode 100644 index 00000000..11f3eea2 --- /dev/null +++ b/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_PoiRandom.cginc @@ -0,0 +1,41 @@ +#ifndef POI_RANDOM + #define POI_RANDOM + + float _EnableRandom; + float m_start_Angle; + float _AngleType; + float3 _AngleForwardDirection; + float _CameraAngleMin; + float _CameraAngleMax; + float _ModelAngleMin; + float _ModelAngleMax; + float _AngleMinAlpha; + float _AngleCompareTo; + + float ApplyAngleBasedRendering(float3 modelPos, float3 worldPos) + { + half cameraAngleMin = float(45) / 180; + half cameraAngleMax = float(90) / 180; + half modelAngleMin = float(45) / 180; + half modelAngleMax = float(90) / 180; + float3 pos = float(0) == 0 ? modelPos : worldPos; + half3 cameraToModelDirection = normalize(pos - getCameraPosition()); + half3 modelForwardDirection = normalize(mul(unity_ObjectToWorld, normalize(float4(0,0,1,0)))); + half cameraLookAtModel = remapClamped(.5 * dot(cameraToModelDirection, getCameraForward()) + .5, cameraAngleMax, cameraAngleMin, 0, 1); + half modelLookAtCamera = remapClamped(.5 * dot(-cameraToModelDirection, modelForwardDirection) + .5, modelAngleMax, modelAngleMin, 0, 1); + if (float(0) == 0) + { + return max(cameraLookAtModel, float(0)); + } + else if(float(0) == 1) + { + return max(modelLookAtCamera, float(0)); + } + else if(float(0) == 2) + { + return max(cameraLookAtModel * modelLookAtCamera, float(0)); + } + return 1; + } + +#endif diff --git a/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_PoiRandom.cginc.meta b/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_PoiRandom.cginc.meta new file mode 100644 index 00000000..e50fbb75 --- /dev/null +++ b/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_PoiRandom.cginc.meta @@ -0,0 +1,9 @@ +fileFormatVersion: 2 +guid: 49d80e1d8af174b489934c135ae1475e +ShaderImporter: + externalObjects: {} + defaultTextures: [] + nonModifiableTextures: [] + userData: + assetBundleName: + assetBundleVariant: diff --git a/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_PoiRimLighting.cginc b/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_PoiRimLighting.cginc new file mode 100644 index 00000000..45410495 --- /dev/null +++ b/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_PoiRimLighting.cginc @@ -0,0 +1,76 @@ +#ifndef POI_RIM + #define POI_RIM + + float4 _RimLightColor; + float _RimLightingInvert; + float _RimWidth; + float _RimStrength; + float _RimSharpness; + float _RimLightColorBias; + float _ShadowMix; + float _ShadowMixThreshold; + float _ShadowMixWidthMod; + float _EnableRimLighting; + float _RimBrighten; + float _RimLightNormal; + float _RimHueShiftEnabled; + float _RimHueShiftSpeed; + float _RimHueShift; + + #if defined(PROP_RIMTEX) || !defined(OPTIMIZER_ENABLED) + POI_TEXTURE_NOSAMPLER(_RimTex); + #endif + #if defined(PROP_RIMMASK) || !defined(OPTIMIZER_ENABLED) + POI_TEXTURE_NOSAMPLER(_RimMask); + #endif + #if defined(PROP_RIMWIDTHNOISETEXTURE) || !defined(OPTIMIZER_ENABLED) + POI_TEXTURE_NOSAMPLER(_RimWidthNoiseTexture); + #endif + + float _RimWidthNoiseStrength; + + float4 rimColor = float4(0, 0, 0, 0); + float rim = 0; + + void applyRimLighting(inout float4 albedo, inout float3 rimLightEmission) + { + #if defined(PROP_RIMWIDTHNOISETEXTURE) || !defined(OPTIMIZER_ENABLED) + float rimNoise = POI2D_SAMPLER_PAN(_RimWidthNoiseTexture, _MainTex, poiMesh.uv[float(0)], float4(0,0,0,0)); + #else + float rimNoise = 0; + #endif + rimNoise = (rimNoise - .5) * float(0.1); + + float viewDotNormal = abs(dot(poiCam.viewDir, poiMesh.normals[float(1)])); + + if (float(0)) + { + viewDotNormal = 1 - abs(dot(poiCam.viewDir, poiMesh.normals[float(1)])); + } + float rimWidth = float(0.8); + rimWidth -= rimNoise; + #if defined(PROP_RIMMASK) || !defined(OPTIMIZER_ENABLED) + float rimMask = POI2D_SAMPLER_PAN(_RimMask, _MainTex, poiMesh.uv[float(0)], float4(0,0,0,0)); + #else + float rimMask = 1; + #endif + + #if defined(PROP_RIMTEX) || !defined(OPTIMIZER_ENABLED) + rimColor = POI2D_SAMPLER_PAN(_RimTex, _MainTex, poiMesh.uv[float(0)], float4(0,0,0,0)) * float4(1,1,1,1); + #else + rimColor = float4(1,1,1,1); + #endif + + + if(float(0)) + { + rimColor.rgb = hueShift(rimColor.rgb, float(0) + _Time.x * float(0)); + } + + rimWidth = max(lerp(rimWidth, rimWidth * lerp(0, 1, poiLight.lightMap - float(0.5)) * float(0.5), float(0)), 0); + rim = 1 - smoothstep(min(float(0.233), rimWidth), rimWidth, viewDotNormal); + rim *= float4(1,1,1,1).a * rimColor.a * rimMask; + rimLightEmission = rim * lerp(albedo, rimColor, float(1)) * float(0); + albedo.rgb = lerp(albedo.rgb, lerp(albedo.rgb, rimColor, float(1)) + lerp(albedo.rgb, rimColor, float(1)) * float(0), rim); + } +#endif diff --git a/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_PoiRimLighting.cginc.meta b/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_PoiRimLighting.cginc.meta new file mode 100644 index 00000000..39e7c816 --- /dev/null +++ b/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_PoiRimLighting.cginc.meta @@ -0,0 +1,9 @@ +fileFormatVersion: 2 +guid: 64ddf76dff241134bab052e80bddfd14 +ShaderImporter: + externalObjects: {} + defaultTextures: [] + nonModifiableTextures: [] + userData: + assetBundleName: + assetBundleVariant: diff --git a/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_PoiShadowFrag.cginc b/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_PoiShadowFrag.cginc new file mode 100644 index 00000000..3d58e673 --- /dev/null +++ b/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_PoiShadowFrag.cginc @@ -0,0 +1,123 @@ +#ifndef SHADOW_FRAG + #define SHADOW_FRAG + + float2 _MainDistanceFade; + float _ForceOpaque; + float _MainShadowClipMod; + float2 _ClippingMaskPan; + float _ClippingMaskUV; + sampler3D _DitherMaskLOD; + float2 _MainTexPan; + float _MainTextureUV; + float _Inverse_Clipping; + + half4 fragShadowCaster( + #if !defined(V2F_SHADOW_CASTER_NOPOS_IS_EMPTY) || defined(UNITY_STANDARD_USE_SHADOW_UVS) + V2FShadow i, uint facing: SV_IsFrontFace + #endif + ): SV_Target + { + poiMesh.uv[0] = i.uv; + poiMesh.uv[1] = i.uv1; + poiMesh.uv[2] = i.uv2; + poiMesh.uv[3] = i.uv3; + + // Basically every texture relies on the maintex sampler to function and that's why this is here. + float4 mainTexture = UNITY_SAMPLE_TEX2D(_MainTex, TRANSFORM_TEX(poiMesh.uv[float(0)], _MainTex) + _Time.x * float4(0,0,0,0)); + + + //Possible Bug with clip + float clipValue = clamp(float(0.5) + float(0), - .001, 1.001); + + poiMesh.vertexColor = saturate(i.vertexColor); + poiMesh.worldPos = i.worldPos; + poiMesh.localPos = i.localPos; + + #ifdef POI_MIRROR + applyMirrorRenderFrag(); + #endif + + #if defined(UNITY_STANDARD_USE_SHADOW_UVS) + + half4 alpha = mainTexture; + + #if defined(PROP_MIRRORTEXTURE) || !defined(OPTIMIZER_ENABLED) + + if (float(0)) + { + if(IsInMirror()) + { + alpha.a = UNITY_SAMPLE_TEX2D_SAMPLER(_MirrorTexture, _MainTex, TRANSFORM_TEX(i.uv, _MirrorTexture)).a; + } + } + #endif + + alpha.a *= smoothstep(float4(0,0,0,0).x, float4(0,0,0,0).y, distance(i.modelPos, _WorldSpaceCameraPos)); + half alphaMask = POI2D_PAN(_ClippingMask, poiMesh.uv[float(0)], float4(0,0,0,0)); + + if(float(0)) + { + alphaMask = 1 - alphaMask; + } + alpha.a *= alphaMask; + alpha.a *= float4(1,0.8387991,0.701102,1).a + .0001; + alpha.a += float(0); + alpha.a = saturate(alpha.a); + + + if(float(0) == 0) + { + alpha.a = 1; + } + + + if(float(0) == 1) + { + applyShadowDithering(alpha.a, calcScreenUVs(i.grabPos).xy); + } + + #ifdef POI_DISSOLVE + float3 fakeEmission = 1; + calculateDissolve(alpha, fakeEmission); + #endif + + if(float(0) == 1) + { + clip(alpha.a - 0.001); + } + + /* + return poiMesh.vertexColor.g; + + #ifdef POI_RANDOM + alpha.a *= i.angleAlpha; + #endif + + + if(float(0) >= 1) + { + applySpawnInShadow(uv[0], i.localPos); + + #if defined(POI_FLIPBOOK) + alpha.a *= applyFlipbookAlphaToShadow(uv[float(0)]); + #endif + } + */ + + if (float(0) == 1) + { + clip(alpha.a - clipValue); + } + + + if(float(0) > 1) + { + float dither = tex3D(_DitherMaskLOD, float3(i.pos.xy * .25, alpha.a * 0.9375)).a; + clip(dither - 0.01); + } + + #endif + SHADOW_CASTER_FRAGMENT(i) + } + + #endif diff --git a/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_PoiShadowFrag.cginc.meta b/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_PoiShadowFrag.cginc.meta new file mode 100644 index 00000000..d51a5e94 --- /dev/null +++ b/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_PoiShadowFrag.cginc.meta @@ -0,0 +1,9 @@ +fileFormatVersion: 2 +guid: be400a2861140f9418622003c3ecfb57 +ShaderImporter: + externalObjects: {} + defaultTextures: [] + nonModifiableTextures: [] + userData: + assetBundleName: + assetBundleVariant: diff --git a/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_PoiShadowIncludes.cginc b/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_PoiShadowIncludes.cginc new file mode 100644 index 00000000..0ad76364 --- /dev/null +++ b/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_PoiShadowIncludes.cginc @@ -0,0 +1,44 @@ +#ifndef SHADOW_INCLUDES + #define SHADOW_INCLUDES + + #define UNITY_STANDARD_USE_SHADOW_UVS 1 + + float4 _Color; + sampler2D _ClippingMask; float4 _ClippingMask_ST; + + struct VertexInputShadow + { + float4 vertex: POSITION; + float3 normal: NORMAL; + float4 tangent: TANGENT; + float4 color: COLOR; + float2 uv0: TEXCOORD0; + float2 uv1: TEXCOORD1; + float2 uv2: TEXCOORD2; + float2 uv3: TEXCOORD3; + uint vertexId : SV_VertexID; + UNITY_VERTEX_INPUT_INSTANCE_ID + }; + + #if !defined(V2F_SHADOW_CASTER_NOPOS_IS_EMPTY) || defined(UNITY_STANDARD_USE_SHADOW_UVS) + struct V2FShadow + { + V2F_SHADOW_CASTER_NOPOS + float4 pos: SV_POSITION; + float2 uv: TEXCOORD1; + float2 uv1: TEXCOORD2; + float2 uv2: TEXCOORD3; + float2 uv3: TEXCOORD4; + float3 modelPos: TEXCOORD5; + float4 worldPos: TEXCOORD6; + float4 localPos: TEXCOORD7; + float3 angleAlpha: TEXCOORD8; + float4 grabPos: TEXCOORD9; + fixed3 barycentricCoordinates: TEXCOORD10; + float4 vertexColor: TEXCOORD11; + UNITY_VERTEX_INPUT_INSTANCE_ID + UNITY_VERTEX_OUTPUT_STEREO + }; + #endif + +#endif diff --git a/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_PoiShadowIncludes.cginc.meta b/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_PoiShadowIncludes.cginc.meta new file mode 100644 index 00000000..4592c023 --- /dev/null +++ b/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_PoiShadowIncludes.cginc.meta @@ -0,0 +1,9 @@ +fileFormatVersion: 2 +guid: 181b44be3ab5a314686ac55da49888bb +ShaderImporter: + externalObjects: {} + defaultTextures: [] + nonModifiableTextures: [] + userData: + assetBundleName: + assetBundleVariant: diff --git a/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_PoiShadowVert.cginc b/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_PoiShadowVert.cginc new file mode 100644 index 00000000..8a786e19 --- /dev/null +++ b/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_PoiShadowVert.cginc @@ -0,0 +1,86 @@ +float _EnableTouchGlow; +float _EnableBulge; +float _VertexManipulationHeightUV; + +V2FShadow vertShadowCaster(VertexInputShadow v) +{ + V2FShadow o; + UNITY_SETUP_INSTANCE_ID(v); + #ifdef RALIV_PENETRATION + applyRalivDynamicOrifaceSystem(v); + #endif + #ifdef AUTO_EXPOSURE + applyLocalVertexTransformation(v.normal, v.vertex); + #endif + + UNITY_INITIALIZE_OUTPUT(V2FShadow, o); + UNITY_TRANSFER_INSTANCE_ID(v, o); + UNITY_INITIALIZE_VERTEX_OUTPUT_STEREO(o); + + o.localPos = v.vertex; + o.worldPos = mul(unity_ObjectToWorld, o.localPos); + + #ifdef RALIV_PENETRATION + applyRalivDynamicPenetrationSystem(o.localPos.rgb, v.normal.rgb, v); + #endif + + o.modelPos = mul(unity_ObjectToWorld, float4(0, 0, 0, 1)); + o.uv = v.uv0; + o.uv1 = v.uv1; + o.uv2 = v.uv2; + o.uv3 = v.uv3; + + + float2 uvToUse = 0; + + if (float(0) == 0) + { + uvToUse = v.uv0.xy; + } + + if(float(0) == 1) + { + uvToUse = v.uv1.xy; + } + + if(float(0) == 2) + { + uvToUse = v.uv2.xy; + } + + if(float(0) == 3) + { + uvToUse = v.uv3.xy; + } + #ifdef AUTO_EXPOSURE + applyWorldVertexTransformation(o.worldPos, o.localPos, v.normal, uvToUse); + #endif + applyVertexGlitching(o.worldPos, o.localPos); + applySpawnInVert(o.worldPos, o.localPos, v.uv0.xy); + #ifdef AUTO_EXPOSURE + applyVertexRounding(o.worldPos, o.localPos); + #endif + o.pos = UnityObjectToClipPos(o.localPos); + o.grabPos = ComputeGrabScreenPos(o.pos); + o.modelPos = mul(unity_ObjectToWorld, float4(0, 0, 0, 1)); + o.vertexColor = v.color; + + + if(float(0) || float(0)) + { + o.pos = UnityObjectToClipPos(float3(0, 0, -5)); + o.localPos.xyz = float3(0, 0, -5); + o.worldPos = mul(unity_ObjectToWorld, o.localPos); + } + + o.angleAlpha = 1; + #ifdef POI_RANDOM + o.angleAlpha = ApplyAngleBasedRendering(o.modelPos, o.worldPos); + #endif + + + o.pos = UnityClipSpaceShadowCasterPos(o.localPos, v.normal); + o.pos = UnityApplyLinearShadowBias(o.pos); + + return o; +} diff --git a/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_PoiShadowVert.cginc.meta b/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_PoiShadowVert.cginc.meta new file mode 100644 index 00000000..a1120c1b --- /dev/null +++ b/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_PoiShadowVert.cginc.meta @@ -0,0 +1,9 @@ +fileFormatVersion: 2 +guid: 22faeb431eb70264c984d6451dc57169 +ShaderImporter: + externalObjects: {} + defaultTextures: [] + nonModifiableTextures: [] + userData: + assetBundleName: + assetBundleVariant: diff --git a/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_PoiSpawnInFrag.cginc b/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_PoiSpawnInFrag.cginc new file mode 100644 index 00000000..20e0a841 --- /dev/null +++ b/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_PoiSpawnInFrag.cginc @@ -0,0 +1,58 @@ +#ifndef POI_SPAWN_IN_FRAG + #define POI_SPAWN_FRAG + + #ifndef SPAWN_IN_VARIABLES + #define SPAWN_IN_VARIABLES + + float3 _SpawnInGradientStart; + float3 _SpawnInGradientFinish; + fixed _SpawnInAlpha; + fixed _SpawnInNoiseIntensity; + float3 _SpawnInEmissionColor; + float _SpawnInEmissionOffset; + float _SpawnInVertOffset; + float _SpawnInVertOffsetOffset; + float _EnableScifiSpawnIn; + #endif + + UNITY_DECLARE_TEX2D_NOSAMPLER(_SpawnInNoise); float4 _SpawnInNoise_ST; + + float calculateGradientValueFrag(float3 start, float3 finish, float3 localPos) + { + return inverseLerp3(start, finish, localPos); + } + + void applySpawnIn(inout float4 finalColor, inout float3 spawnInEmission, float2 uv, float3 localPos) + { + + if (float(0)) + { + float noise = UNITY_SAMPLE_TEX2D_SAMPLER(_SpawnInNoise, _MainTex, TRANSFORM_TEX(uv, _SpawnInNoise)).r * float(0) * float(0.35); + float gradient = calculateGradientValueFrag(float4(0,2,0,1), float4(0,-2,0,1), localPos); + float inverseGradient = 1 - gradient; + float alpha = gradient - float(0) - noise; + spawnInEmission = saturate(inverseGradient + float(0) + float(0.1) +noise - 1) * float4(1,1,1,1); + + if(float(0) >= 1) + { + clip(ceil(alpha) - 0.001); + } + } + } + + void applySpawnInShadow(float2 uv, float3 localPos) + { + + if(float(0)) + { + float noise = UNITY_SAMPLE_TEX2D_SAMPLER(_SpawnInNoise, _MainTex, TRANSFORM_TEX(uv, _SpawnInNoise)).r * float(0) * float(0.35); + float gradient = calculateGradientValueFrag(float4(0,2,0,1), float4(0,-2,0,1), localPos); + float alpha = gradient - float(0) - noise + length(float(10)); + + if(float(0) >= 1) + { + clip(ceil(alpha) - 0.001); + } + } + } +#endif diff --git a/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_PoiSpawnInFrag.cginc.meta b/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_PoiSpawnInFrag.cginc.meta new file mode 100644 index 00000000..f88b63b2 --- /dev/null +++ b/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_PoiSpawnInFrag.cginc.meta @@ -0,0 +1,9 @@ +fileFormatVersion: 2 +guid: 135a1f78064fd194eb1e98b376358010 +ShaderImporter: + externalObjects: {} + defaultTextures: [] + nonModifiableTextures: [] + userData: + assetBundleName: + assetBundleVariant: diff --git a/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_PoiSpawnInVert.cginc b/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_PoiSpawnInVert.cginc new file mode 100644 index 00000000..26b32eff --- /dev/null +++ b/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_PoiSpawnInVert.cginc @@ -0,0 +1,40 @@ +#ifndef POI_SPAWN_IN_FRAG + #define POI_SPAWN_FRAG + + #ifndef SPAWN_IN_VARIABLES + #define SPAWN_IN_VARIABLES + + float3 _SpawnInGradientStart; + float3 _SpawnInGradientFinish; + fixed _SpawnInAlpha; + fixed _SpawnInNoiseIntensity; + float3 _SpawnInEmissionColor; + float _SpawnInEmissionOffset; + float _SpawnInVertOffset; + float _SpawnInVertOffsetOffset; + float _EnableScifiSpawnIn; + + #endif + //sampler2D _SpawnInNoiseVert; float4 _SpawnInNoiseVert_ST; + + float calculateGradientValueVert(float3 start, float3 finish, float3 localPos) + { + return inverseLerp3(start, finish, localPos); + } + + void applySpawnInVert(inout float4 worldPos, inout float4 localPos, float2 uv) + { + + if (float(0)) + { + float noise = 0; + float gradient = calculateGradientValueVert(float4(0,2,0,1), float4(0,-2,0,1), localPos.xyz); + float inverseGradient = 1 - gradient; + float alpha = gradient - float(0) - noise; + worldPos.xyz += saturate(inverseGradient + float(0) + float(0.1) -1) * float3(0, float(10), 0); + localPos.xyz = mul(unity_WorldToObject, worldPos).xyz; + } + //float noise = tex2Dlod(_SpawnInNoise, float4(TRANSFORM_TEX(uv, _SpawnInNoise))).r * float(0) * float(0.35); + } + +#endif diff --git a/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_PoiSpawnInVert.cginc.meta b/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_PoiSpawnInVert.cginc.meta new file mode 100644 index 00000000..a8bb6230 --- /dev/null +++ b/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_PoiSpawnInVert.cginc.meta @@ -0,0 +1,9 @@ +fileFormatVersion: 2 +guid: 8ff9572c1c305cd40b2a8b4634edab54 +ShaderImporter: + externalObjects: {} + defaultTextures: [] + nonModifiableTextures: [] + userData: + assetBundleName: + assetBundleVariant: diff --git a/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_PoiSpecular.cginc b/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_PoiSpecular.cginc new file mode 100644 index 00000000..1e89f5c5 --- /dev/null +++ b/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_PoiSpecular.cginc @@ -0,0 +1,483 @@ +#ifndef POI_SPECULAR + #define POI_SPECULAR + float _SpecWhatTangent; + float _SpecularType; + float _SmoothnessFrom; + POI_TEXTURE_NOSAMPLER(_SpecularMetallicMap); + POI_TEXTURE_NOSAMPLER(_SpecularMap); + fixed _CenterOutSpecColor; + POI_TEXTURE_NOSAMPLER(_SpecularAnisoJitterMicro); + float _SpecularAnisoJitterMirrored; + POI_TEXTURE_NOSAMPLER(_SpecularAnisoJitterMacro); + POI_TEXTURE_NOSAMPLER(_SpecularAnisoFakeUV); + POI_TEXTURE_NOSAMPLER(_AnisoTangentMap); + POI_TEXTURE_NOSAMPLER(_SpecularMask); + float _SpecularAnisoJitterMicroMultiplier; + float _SpecularAnisoJitterMacroMultiplier; + float4 _SpecularTint; + float _SpecularSmoothness; + float _Spec1Offset; + float _Spec1JitterStrength; + float _Spec2Smoothness; + float _Spec2Offset; + float _Spec2JitterStrength; + float _AnisoUseTangentMap; + float _AnisoSpec1Alpha; + float _AnisoSpec2Alpha; + float _SpecularInvertSmoothness; + half _SpecularMetallic; + float _SpecularNormal; + float _SpecularNormal1; + // Toon + fixed _SpecularToonStart; + fixed _SpecularToonEnd; + half4 _SpecularToonInnerOuter; + + #ifdef DITHERING + float _EnableSpecular1; + float _SpecWhatTangent1; + float _SpecularType1; + float _SmoothnessFrom1; + POI_TEXTURE_NOSAMPLER(_SpecularMetallicMap1); + POI_TEXTURE_NOSAMPLER(_SpecularMap1); + POI_TEXTURE_NOSAMPLER(_SpecularAnisoJitterMicro1); + POI_TEXTURE_NOSAMPLER(_SpecularAnisoJitterMacro1); + float _SpecularAnisoJitterMirrored1; + POI_TEXTURE_NOSAMPLER(_AnisoTangentMap1); + POI_TEXTURE_NOSAMPLER(_SpecularMask1); + float _SpecularAnisoJitterMicroMultiplier1; + float _SpecularAnisoJitterMacroMultiplier1; + float4 _SpecularTint1; + float _SpecularSmoothness1; + float _Spec1Offset1; + float _Spec1JitterStrength1; + float _Spec2Smoothness1; + float _Spec2Offset1; + float _Spec2JitterStrength1; + float _AnisoUseTangentMap1; + float _AnisoSpec1Alpha1; + float _AnisoSpec2Alpha1; + float _SpecularInvertSmoothness1; + half _SpecularMetallic1; + // Toon + half4 _SpecularToonInnerOuter1; + fixed _SpecularToonStart1; + fixed _SpecularToonEnd1; + #endif + UnityIndirect ZeroIndirect() + { + UnityIndirect ind; + ind.diffuse = 0; + ind.specular = 0; + return ind; + } + + // From unity just putting it here in case I want to mod it + half4 poiRealisticSpecular(half3 diffColor, half3 specColor, half oneMinusReflectivity, half smoothness, + float3 normal, float3 halfDir, + UnityLight light, UnityIndirect gi) + { + float perceptualRoughness = SmoothnessToPerceptualRoughness(smoothness); + #define UNITY_HANDLE_CORRECTLY_NEGATIVE_NDOTV 0 + + #if UNITY_HANDLE_CORRECTLY_NEGATIVE_NDOTV + half shiftAmount = dot(normal, poiCam.viewDir); + normal = shiftAmount < 0.0f ? normal + poiCam.viewDir * (-shiftAmount + 1e-5f): normal; + float nv = saturate(dot(normal, poiCam.viewDir)); + #else + half nv = abs(dot(normal, poiCam.viewDir)); + #endif + + float nl = saturate(dot(normal, light.dir)); + float nh = saturate(dot(normal, halfDir)); + + half lv = saturate(dot(light.dir, poiCam.viewDir)); + half lh = saturate(dot(light.dir, halfDir)); + + half diffuseTerm = DisneyDiffuse(nv, nl, lh, perceptualRoughness) * nl; + + float roughness = PerceptualRoughnessToRoughness(perceptualRoughness); + + roughness = max(roughness, 0.002); + float V = SmithJointGGXVisibilityTerm(nl, nv, roughness); + float D = GGXTerm(nh, roughness); + + float specularTerm = V * D * UNITY_PI; + + #ifdef UNITY_COLORSPACE_GAMMA + specularTerm = sqrt(max(1e-4h, specularTerm)); + #endif + + specularTerm = max(0, specularTerm * nl); + #if defined(_POI_SPECULARHIGHLIGHTS_OFF) + specularTerm = 0.0; + #endif + + half surfaceReduction; + #ifdef UNITY_COLORSPACE_GAMMA + surfaceReduction = 1.0 - 0.28 * roughness * perceptualRoughness; + #else + surfaceReduction = 1.0 / (roughness * roughness + 1.0); + #endif + + specularTerm *= any(specColor) ? 1.0: 0.0; + + half grazingTerm = saturate(smoothness + (1 - oneMinusReflectivity)); + half3 color = diffColor * (gi.diffuse + light.color * diffuseTerm) + + specularTerm * light.color * FresnelTerm(specColor, lh) + + surfaceReduction * gi.specular * FresnelLerp(specColor, grazingTerm, nv); + + return half4(color, 1); + } + + half3 calculateRealisticSpecular(float4 albedo, float2 uv, float4 specularTint, float specularSmoothness, float invertSmoothness, float mixAlbedoWithTint, float4 specularMap, float3 specularLight, float3 normal, float attenuation, float3 lightDirection, float nDotL, float3 halfDir) + { + half oneMinusReflectivity; + half3 finalSpecular; + UnityLight unityLight; + unityLight.color = specularLight; + unityLight.dir = lightDirection; + unityLight.ndotl = nDotL; + + + if (float(1) == 0) + { + half3 diffColor = EnergyConservationBetweenDiffuseAndSpecular(albedo, specularMap.rgb * specularTint.rgb, /*out*/ oneMinusReflectivity); + finalSpecular = poiRealisticSpecular(diffColor, specularMap.rgb, oneMinusReflectivity, specularMap.a * specularSmoothness * lerp(1, -1, invertSmoothness), normal, halfDir, unityLight, ZeroIndirect()); + } + else + { + half3 diffColor = EnergyConservationBetweenDiffuseAndSpecular(albedo, specularTint.rgb, /*out*/ oneMinusReflectivity); + float smoothness = max(max(specularMap.r, specularMap.g), specularMap.b); + finalSpecular = poiRealisticSpecular(diffColor, 1, oneMinusReflectivity, smoothness * specularSmoothness * lerp(1, -1, invertSmoothness), normal, halfDir, unityLight, ZeroIndirect()); + } + finalSpecular *= lerp(1, albedo.rgb, mixAlbedoWithTint); + return finalSpecular; + } + + half3 calculateToonSpecular(float4 albedo, float2 uv, float2 specularToonInnerOuter, float specularMixAlbedoIntoTint, float smoothnessFrom, float4 specularMap, float3 specularLight, float3 normal, float3 halfDir, float attenuation) + { + half3 finalSpecular = smoothstep(1 - specularToonInnerOuter.y, 1 - specularToonInnerOuter.x, dot(halfDir, normal)) * specularLight; + + if (smoothnessFrom == 0) + { + finalSpecular.rgb *= specularMap.rgb * lerp(1, albedo.rgb, specularMixAlbedoIntoTint); + finalSpecular *= specularMap.a; + } + else + { + finalSpecular *= specularMap.r * lerp(1, albedo.rgb, specularMixAlbedoIntoTint); + } + return finalSpecular; + } + + float3 strandSpecular(float TdotL, float TdotV, float specPower, float nDotL) + { + #ifdef FORWARD_ADD_PASS + nDotL *= poiLight.attenuation * poiLight.additiveShadow; + #endif + float Specular = saturate(nDotL) * pow(saturate(sqrt(1.0 - (TdotL * TdotL)) * sqrt(1.0 - (TdotV * TdotV)) - TdotL * TdotV), specPower); + half normalization = sqrt((specPower + 1) * ((specPower) + 1)) / (8 * pi); + Specular *= normalization; + return Specular; + } + + half3 AnisotropicSpecular( + float specWhatTangent, float anisoUseTangentMap, float specularSmoothness, float spec2Smoothness, + float anisoSpec1Alpha, float anisoSpec2Alpha, float4 specularTint, float specularMixAlbedoIntoTint, float4 specularMap, float3 specularLight, float3 lightDirection, float3 halfDir, float nDotL, float jitter, float4 packedTangentMap, in float4 albedo) + { + float3 tangentOrBinormal = specWhatTangent ? poiMesh.tangent: poiMesh.binormal; + + + float3 normalLocalAniso = lerp(float3(0, 0, 1), UnpackNormal(packedTangentMap), anisoUseTangentMap); + normalLocalAniso = BlendNormals(normalLocalAniso, poiMesh.tangentSpaceNormal); + //float3 normalDirection = normalize(mul(poiMesh.normals[float(1)], poiTData.tangentTransform)); + float3 normalDirectionAniso = Unity_SafeNormalize(mul(normalLocalAniso, poiTData.tangentTransform)); + float3 tangentDirection = mul(poiTData.tangentTransform, tangentOrBinormal).xyz; + float3 viewReflectDirectionAniso = reflect(-poiCam.viewDir, normalDirectionAniso); // possible bad negation + float3 tangentDirectionMap = mul(poiTData.tangentToWorld, float3(normalLocalAniso.rg, 0.0)).xyz; + tangentDirectionMap = normalize(lerp(tangentOrBinormal, tangentDirectionMap, anisoUseTangentMap)); + + tangentDirectionMap += float(0) +jitter; + + float TdotL = dot(lightDirection, tangentDirectionMap); + float TdotV = dot(poiCam.viewDir, tangentDirectionMap); + float TdotH = dot(halfDir, tangentDirectionMap); + half specPower = RoughnessToSpecPower(1.0 - specularSmoothness * specularMap.a); + half spec2Power = RoughnessToSpecPower(1.0 - spec2Smoothness * specularMap.a); + half Specular = 0; + + float3 spec = strandSpecular(TdotL, TdotV, specPower, nDotL) * anisoSpec1Alpha; + float3 spec2 = strandSpecular(TdotL, TdotV, spec2Power, nDotL) * anisoSpec2Alpha; + + return max(spec, spec2) * specularMap.rgb * specularTint.a * specularLight * lerp(1, albedo.rgb, specularMixAlbedoIntoTint); + } + + inline float3 toonAnisoSpecular(float specWhatTangent, float anisoUseTangentMap, float3 lightDirection, float halfDir, float4 specularMap, float nDotL, fixed gradientStart, fixed gradientEnd, float4 specColor, float4 finalColor, fixed metallic, float jitter, float mirrored, float4 packedTangentMap) + { + float3 tangentOrBinormal = specWhatTangent ? poiMesh.tangent: poiMesh.binormal; + + float3 normalLocalAniso = lerp(float3(0, 0, 1), UnpackNormal(packedTangentMap), anisoUseTangentMap); + normalLocalAniso = BlendNormals(normalLocalAniso, poiMesh.tangentSpaceNormal); + //float3 normalDirection = normalize(mul(poiMesh.normals[float(1)], poiTData.tangentTransform)); + float3 normalDirectionAniso = Unity_SafeNormalize(mul(normalLocalAniso, poiTData.tangentTransform)); + float3 tangentDirection = mul(poiTData.tangentTransform, tangentOrBinormal).xyz; + float3 viewReflectDirectionAniso = reflect(-poiCam.viewDir, normalDirectionAniso); // possible bad negation + float3 tangentDirectionMap = mul(poiTData.tangentToWorld, float3(normalLocalAniso.rg, 0.0)).xyz; + tangentDirectionMap = normalize(lerp(tangentOrBinormal, tangentDirectionMap, anisoUseTangentMap)); + + if (!mirrored) + { + tangentDirectionMap += jitter; + } + + float TdotL = dot(lightDirection, tangentDirectionMap); + float TdotV = dot(poiCam.viewDir, tangentDirectionMap); + float TdotH = dot(halfDir, tangentDirectionMap); + + float specular = saturate(sqrt(1.0 - (TdotL * TdotL)) * sqrt(1.0 - (TdotV * TdotV)) - TdotL * TdotV); + + fixed smoothAlpha = specular; + if(mirrored) + { + smoothAlpha = max(specular - jitter, 0); + } + + specular = smoothstep(gradientStart, gradientEnd, smoothAlpha); + + /* + + if(_CenterOutSpecColor) + { + specularMap = POI2D_SAMPLER_PAN(_SpecularMap, _MainTex, clamp(float2(specular, specular), 0.01, .99), float4(0,0,0,0)); + } + */ + + #ifdef FORWARD_ADD_PASS + nDotL *= poiLight.attenuation * poiLight.additiveShadow; + #endif + + return saturate(nDotL) * specular * poiLight.color * specColor * specularMap.rgb * lerp(1, finalColor, metallic) * specularMap.a; + } + + inline float SpecularHQ(half roughness, half dotNH, half dotLH) + { + roughness = saturate(roughness); + roughness = max((roughness * roughness), 0.002); + half roughnessX2 = roughness * roughness; + + half denom = dotNH * dotNH * (roughnessX2 - 1.0) + 1.0f; + half D = roughnessX2 / (3.14159 * denom * denom); + + half k = roughness / 2.0f; + half k2 = k * k; + half invK2 = 1.0f - k2; + + half vis = rcp(dotLH * dotLH * invK2 + k2); + + float specTerm = vis * D; + + return specTerm; + } + + float3 calculateNewSpecular(in float3 specularMap, uint colorFrom, in float4 albedo, in float3 specularTint, in float specularMetallic, in float specularSmoothness, in half dotNH, in half dotLH, in float3 lightColor, in float attenuation) + { + float3 specColor = specularTint; + float metallic = specularMetallic; + float roughness = 1 - specularSmoothness; + float perceptualRoughness = roughness; + //float reflectInverse = DielectricSpec.a - metallic * DielectricSpec.a; + //float reflectivity = 1.0h - reflectInverse; + float3 specMapColor = lerp(specularMap, 1, colorFrom); + float3 specularColor = lerp(DielectricSpec.rgb * specMapColor, lerp(specularMap, albedo.rgb, colorFrom), metallic); + //albedo.rgb *= reflectInverse; + return clamp(specularColor * lightColor * attenuation * specularTint * SpecularHQ(perceptualRoughness, dotNH, dotLH), 0, lightColor * specularTint); + } + + float3 calculateSpecular(in float4 albedo) + { + half3 finalSpecular = 0; + half3 finalSpecular1 = 0; + float4 realisticAlbedo = albedo; + float4 realisticAlbedo1 = albedo; + float4 specularMap = POI2D_SAMPLER_PAN(_SpecularMap, _MainTex, poiMesh.uv[float(0)], float4(0,0,0,0)); + half metallic = POI2D_SAMPLER_PAN(_SpecularMetallicMap, _MainTex, poiMesh.uv[float(0)], float4(0,0,0,0)).r * float(0); + half specularMask = POI2D_SAMPLER_PAN(_SpecularMask, _MainTex, poiMesh.uv[float(0)], float4(0,0,0,0)).r; + float attenuation = saturate(poiLight.nDotL); + + #ifdef FORWARD_ADD_PASS + attenuation *= poiLight.attenuation * poiLight.additiveShadow; + #endif + + #ifdef POI_LIGHTING + + if (float(4) == 0 && float(0) == 1) + { + attenuation = poiLight.rampedLightMap; + } + #endif + + + if(float(1) == 1) // Realistic + { + if (float(1) == 1) + { + specularMap.a = specularMap.r; + specularMap.rgb = 1; + } + + if(float(0)) + { + specularMap.a = 1 - specularMap.a; + } + + finalSpecular += calculateNewSpecular(specularMap.rgb, float(1), realisticAlbedo, float4(1,1,1,1), metallic, float(1) * specularMap.a, poiLight.dotNH, poiLight.dotLH, poiLight.color, attenuation); + } + + + if(float(1) == 4) + { + float jitter = 0; + float microJitter = POI2D_SAMPLER_PAN(_SpecularAnisoJitterMicro, _MainTex, float2(poiMesh.uv[float(0)]), float4(0,0,0,0)).r; + fixed jitterOffset = (1 - float(0)) * .5; + jitter += (POI2D_SAMPLER_PAN(_SpecularAnisoJitterMicro, _MainTex, float2(poiMesh.uv[float(0)]), float4(0,0,0,0)).r - jitterOffset) * float(0); + jitter += (POI2D_SAMPLER_PAN(_SpecularAnisoJitterMacro, _MainTex, float2(poiMesh.uv[float(0)]), float4(0,0,0,0)).r - jitterOffset) * float(0); + jitter += float(0); + + float4 packedTangentMap = POI2D_SAMPLER_PAN(_AnisoTangentMap, _MainTex, poiMesh.uv[float(0)], float4(0,0,0,0)); + + finalSpecular += toonAnisoSpecular(float(0), float(0), poiLight.direction, poiLight.halfDir, specularMap, poiLight.nDotL, float(0.95), float(1), float4(1,1,1,1), albedo, metallic, jitter, float(0), packedTangentMap); + finalSpecular *= attenuation; + } + + #ifdef FORWARD_BASE_PASS + + if(float(1) == 2) // Toon + { + finalSpecular += calculateToonSpecular(albedo, poiMesh.uv[0], float4(0.25,0.3,0,1), metallic, float(1), specularMap, poiLight.color, poiMesh.normals[float(1)], poiLight.halfDir, poiLight.attenuation); + finalSpecular *= float4(1,1,1,1); + } + + if (float(1) == 3) // anisotropic + { + float jitter = 0; + float microJitter = POI2D_SAMPLER_PAN(_SpecularAnisoJitterMicro, _MainTex, float2(poiMesh.uv[float(0)]), float4(0,0,0,0)).r; + fixed jitterOffset = (1 - float(0)) * .5; + jitter += (POI2D_SAMPLER_PAN(_SpecularAnisoJitterMicro, _MainTex, float2(poiMesh.uv[float(0)]), float4(0,0,0,0)).r - jitterOffset) * float(0); + jitter += (POI2D_SAMPLER_PAN(_SpecularAnisoJitterMacro, _MainTex, float2(poiMesh.uv[float(0)]), float4(0,0,0,0)).r - jitterOffset) * float(0); + jitter += float(0); + + float4 packedTangentMap = POI2D_SAMPLER_PAN(_AnisoTangentMap, _MainTex, poiMesh.uv[float(0)], float4(0,0,0,0)); + + finalSpecular += AnisotropicSpecular(float(0), float(0), float(1), float(0), float(1), float(1), float4(1,1,1,1), metallic, specularMap, poiLight.color, poiLight.direction, poiLight.halfDir, poiLight.nDotL, jitter, packedTangentMap, albedo); + finalSpecular *= float4(1,1,1,1); + finalSpecular *= attenuation; + } + #endif + + #ifdef VERTEXLIGHT_ON + // Non Important Lights + for (int index = 0; index < 4; index ++) + { + attenuation = poiLight.vAttenuationDotNL[index]; + + if (float(1) == 1) // Realistic + { + finalSpecular += calculateNewSpecular(specularMap.rgb, float(1), realisticAlbedo, float4(1,1,1,1), metallic, float(1) * specularMap.a, poiLight.vDotNH[index], poiLight.vDotLH[index], poiLight.vColor[index], poiLight.vAttenuationDotNL[index]); + } + } + #endif + + finalSpecular *= float4(1,1,1,1).a; + finalSpecular = finalSpecular.rgb; + finalSpecular *= specularMask; + #ifdef DITHERING + float4 specularMap1 = POI2D_SAMPLER_PAN(_SpecularMap1, _MainTex, poiMesh.uv[float(0)], float4(0,0,0,0)); + half specularMask1 = POI2D_SAMPLER_PAN(_SpecularMask1, _MainTex, poiMesh.uv[float(0)], float4(0,0,0,0)).r; + half metallic1 = POI2D_SAMPLER_PAN(_SpecularMetallicMap1, _MainTex, poiMesh.uv[float(0)], float4(0,0,0,0)).r * float(0); + + if (float(1) == 1) // Realistic + { + + if (float(1) == 1) + { + specularMap1.a = specularMap1.r; + specularMap1.rgb = 1; + } + else + { + realisticAlbedo1.rgb = specularMap1.rgb; + } + + + if(float(0)) + { + specularMap1.a = 1 - specularMap1.a; + } + + finalSpecular1 = calculateNewSpecular(specularMap1.rgb, float(1), realisticAlbedo1, float4(1,1,1,1), metallic1, float(0.75) * specularMap1.a, poiLight.dotNH, poiLight.dotLH, poiLight.color, attenuation); + } + + + if(float(1) == 4) + { + float jitter = 0; + float microJitter = POI2D_SAMPLER_PAN(_SpecularAnisoJitterMicro1, _MainTex, float2(poiMesh.uv[float(0)]), float4(0,0,0,0)).r; + fixed jitterOffset = (1 - float(0)) * .5; + jitter += (POI2D_SAMPLER_PAN(_SpecularAnisoJitterMicro1, _MainTex, float2(poiMesh.uv[float(0)]), float4(0,0,0,0)).r - jitterOffset) * float(0); + jitter += (POI2D_SAMPLER_PAN(_SpecularAnisoJitterMacro1, _MainTex, float2(poiMesh.uv[float(0)]), float4(0,0,0,0)).r - jitterOffset) * float(0); + jitter += float(0); + + float4 packedTangentMap = POI2D_SAMPLER_PAN(_AnisoTangentMap1, _MainTex, poiMesh.uv[float(0)], float4(0,0,0,0)); + + finalSpecular1 += toonAnisoSpecular(float(0), float(0), poiLight.direction, poiLight.halfDir, specularMap1, poiLight.nDotL, float(0.95), float(1), float4(1,1,1,1), albedo, metallic1, jitter, float(0), packedTangentMap); + finalSpecular1 *= poiLight.attenuation; + } + + + if(float(1) == 2) // Toon + { + finalSpecular1 = calculateToonSpecular(albedo, poiMesh.uv[0], float4(0.25,0.3,0,1), metallic1, float(1), specularMap1, poiLight.color, poiMesh.normals[float(1)], poiLight.halfDir, poiLight.attenuation); + finalSpecular1 *= float4(1,1,1,1); + } + + if (float(1) == 3) // anisotropic + { + float jitter = 0; + float microJitter = POI2D_SAMPLER_PAN(_SpecularAnisoJitterMicro1, _MainTex, float2(poiMesh.uv[float(0)]), float4(0,0,0,0)).r; + fixed jitterOffset = (1 - float(0)) * .5; + jitter += (POI2D_SAMPLER_PAN(_SpecularAnisoJitterMicro1, _MainTex, float2(poiMesh.uv[float(0)]), float4(0,0,0,0)).r - jitterOffset) * float(0); + jitter += (POI2D_SAMPLER_PAN(_SpecularAnisoJitterMacro1, _MainTex, float2(poiMesh.uv[float(0)]), float4(0,0,0,0)).r - jitterOffset) * float(0); + jitter += float(0); + + float4 packedTangentMap = POI2D_SAMPLER_PAN(_AnisoTangentMap1, _MainTex, poiMesh.uv[float(0)], float4(0,0,0,0)); + + finalSpecular1 = AnisotropicSpecular(float(0), float(0), float(0.75), float(0), float(1), float(1), float4(1,1,1,1), metallic1, specularMap1, poiLight.color, poiLight.direction, poiLight.halfDir, poiLight.nDotL, jitter, packedTangentMap, albedo); + finalSpecular1 *= float4(1,1,1,1); + finalSpecular1 *= poiLight.attenuation; + } + + #ifdef FORWARD_BASE_PASS + // Non Important Lights + #ifdef VERTEXLIGHT_ON + for (int index = 0; index < 4; index ++) + { + attenuation = poiLight.vAttenuationDotNL[index]; + + if (float(1) == 1) // Realistic + { + finalSpecular1 += calculateNewSpecular(specularMap1.rgb, float(1), realisticAlbedo1, float4(1,1,1,1), metallic1, float(0.75) * specularMap1.a, poiLight.vDotNH[index], poiLight.vDotLH[index], poiLight.vColor[index], poiLight.vAttenuationDotNL[index]); + } + } + #endif + #endif + + finalSpecular1 *= float4(1,1,1,1).a; + finalSpecular1 = finalSpecular1.rgb; + finalSpecular1 *= specularMask1; + + #endif + return finalSpecular + finalSpecular1; + } + +#endif diff --git a/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_PoiSpecular.cginc.meta b/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_PoiSpecular.cginc.meta new file mode 100644 index 00000000..15509d27 --- /dev/null +++ b/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_PoiSpecular.cginc.meta @@ -0,0 +1,9 @@ +fileFormatVersion: 2 +guid: d18690467b309934baf40fea1b541a47 +ShaderImporter: + externalObjects: {} + defaultTextures: [] + nonModifiableTextures: [] + userData: + assetBundleName: + assetBundleVariant: diff --git a/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_PoiSubsurfaceScattering.cginc b/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_PoiSubsurfaceScattering.cginc new file mode 100644 index 00000000..fe4836ee --- /dev/null +++ b/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_PoiSubsurfaceScattering.cginc @@ -0,0 +1,75 @@ +#ifndef SUBSURFACE + #define SUBSURFACE + /* + float _SSSThickness; + half4 _SSSColor; + float _SSSPointLightDirectionality; + float _SSSNormalOffset; + float _SSSStrength; + float _SSSExponent; + float _SSSNDotL; + float _SSSConstant; + + #if defined(PROP_SSSTHICKNESSMAP) || !defined(OPTIMIZER_ENABLED) + POI_TEXTURE_NOSAMPLER(_SSSThicknessMap); + #endif + + half3 calculateSubsurfaceScattering(const float4 albedo) + { + #if defined(PROP_SSSTHICKNESSMAP) || !defined(OPTIMIZER_ENABLED) + float thicknessMap = 1 - POI2D_SAMPLER_PAN(_SSSThicknessMap, _MainTex, poiMesh.uv[float(0)], float4(0,0,0,0)); + #else + float thicknessMap = 1; + #endif + + half4 translucencyColor = float4(1,0,0,1); + float3 lightDir = poiLight.direction; + + #ifdef FORWARD_BASE_PASS + half tLitDot = saturate(dot((poiLight.direction + poiMesh.normals[1] * _SSSNormalOffset), -poiCam.viewDir)); + #else + float3 lightDirectional = normalize(_WorldSpaceLightPos0.xyz - poiCam.worldPos); + lightDir = normalize(lerp(poiLight.direction, lightDirectional, _SSSPointLightDirectionality)); + half tLitDot = saturate(dot((poiLight.direction + poiMesh.normals[1] * _SSSNormalOffset), -poiCam.viewDir)); + #endif + + tLitDot = exp2(-_SSSExponent * (1 - tLitDot)) * _SSSStrength; + float NDotL = abs(dot(poiLight.direction, poiMesh.normals[1])); + tLitDot *= lerp(1, NDotL, _SSSNDotL); + + half translucencyOcclusion = lerp(1, thicknessMap, _SSSThickness); + half translucencyAtten = (tLitDot + _SSSConstant * (NDotL + 0.1)) * translucencyOcclusion; + + return translucencyAtten * albedo.rgb * translucencyColor.rgb * poiLight.lightMap * poiLight.color; + } + */ + + float _SSSThicknessMod; + float _SSSSCale; + float _SSSPower; + float _SSSDistortion; + float4 _SSSColor; + float _EnableSSS; + + #if defined(PROP_SSSTHICKNESSMAP) || !defined(OPTIMIZER_ENABLED) + POI_TEXTURE_NOSAMPLER(_SSSThicknessMap); + #endif + + float3 calculateSubsurfaceScattering() + { + #if defined(PROP_SSSTHICKNESSMAP) || !defined(OPTIMIZER_ENABLED) + float SSS = 1 - POI2D_SAMPLER_PAN(_SSSThicknessMap, _MainTex, poiMesh.uv[float(0)], float4(0,0,0,0)); + #else + float SSS = 1; + #endif + half3 vLTLight = poiLight.direction + poiMesh.normals[0] * float(1); + half flTDot = pow(saturate(dot(poiCam.viewDir, -vLTLight)), float(5)) * float(0.25); + #ifdef FORWARD_BASE_PASS + half3 fLT = (flTDot) * saturate(SSS + - 1 * float(0)); + #else + half3 fLT = poiLight.attenuation * (flTDot) * saturate(SSS + - 1 * float(0)); + #endif + + return fLT * poiLight.color * float4(1,0,0,1) * poiLight.attenuation; + } +#endif diff --git a/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_PoiSubsurfaceScattering.cginc.meta b/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_PoiSubsurfaceScattering.cginc.meta new file mode 100644 index 00000000..01822438 --- /dev/null +++ b/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_PoiSubsurfaceScattering.cginc.meta @@ -0,0 +1,9 @@ +fileFormatVersion: 2 +guid: fe3f0e7edc07f7c448520f356bdd8b91 +ShaderImporter: + externalObjects: {} + defaultTextures: [] + nonModifiableTextures: [] + userData: + assetBundleName: + assetBundleVariant: diff --git a/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_PoiTessellation.cginc b/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_PoiTessellation.cginc new file mode 100644 index 00000000..4912473d --- /dev/null +++ b/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_PoiTessellation.cginc @@ -0,0 +1,117 @@ +#ifndef POI_TESSELLATION + #define POI_TESSELLATION + + float _TessellationPhongStrength; + float _TessellationEdgeLength; + float _TessellationExtrusionAmount; + float _TessellationUniform; + + struct TessellationControlPoint + { + float4 vertex: INTERNALTESSPOS; + float3 normal: NORMAL; + float4 tangent: TANGENT; + float4 color: COLOR; + float2 uv0: TEXCOORD0; + float2 uv1: TEXCOORD1; + float2 uv2: TEXCOORD2; + float2 uv3: TEXCOORD3; + }; + + struct TessellationFactors + { + float edge[3]: SV_TessFactor; + float inside: SV_InsideTessFactor; + }; + + TessellationControlPoint poiTessellationVert(appdata v) + { + TessellationControlPoint p; + p.vertex = v.vertex; + p.normal = v.normal; + p.tangent = v.tangent; + p.color = v.color; + p.uv0 = v.uv0; + p.uv1 = v.uv1; + p.uv2 = v.uv2; + p.uv3 = v.uv3; + return p; + } + + float TessellationEdgeFactor(float3 p0, float3 p1) + { + #ifndef _FADING_ON + float edgeLength = distance(p0, p1); + + float3 edgeCenter = (p0 + p1) * 0.5; + float viewDistance = distance(edgeCenter, _WorldSpaceCameraPos); + + return edgeLength * _ScreenParams.y / + (_TessellationEdgeLength * viewDistance); + #else + return _TessellationUniform; + #endif + } + + TessellationFactors poiPatchConst( + InputPatch < TessellationControlPoint, 3 > patch + ) + { + + TessellationFactors f; + float3 p0 = mul(unity_ObjectToWorld, patch[0].vertex).xyz; + float3 p1 = mul(unity_ObjectToWorld, patch[1].vertex).xyz; + float3 p2 = mul(unity_ObjectToWorld, patch[2].vertex).xyz; + f.edge[0] = TessellationEdgeFactor(p1, p2); + f.edge[1] = TessellationEdgeFactor(p2, p0); + f.edge[2] = TessellationEdgeFactor(p0, p1); + f.inside = (TessellationEdgeFactor(p1, p2) + + TessellationEdgeFactor(p2, p0) + + TessellationEdgeFactor(p0, p1)) * (1 / 3.0); + return f; + } + + [UNITY_domain("tri")] + [UNITY_outputcontrolpoints(3)] + [UNITY_outputtopology("triangle_cw")] + [UNITY_partitioning("fractional_odd")] + [UNITY_patchconstantfunc("poiPatchConst")] + TessellationControlPoint poiHull( + InputPatch < TessellationControlPoint, 3 > patch, + uint id: SV_OutputControlPointID + ) + { + return patch[id]; + } + + [UNITY_domain("tri")] + v2f poiDomain( + TessellationFactors factors, + OutputPatch < TessellationControlPoint, 3 > patch, + float3 barycentricCoordinates: SV_DomainLocation + ) + { + appdata data; + + #define MY_DOMAIN_PROGRAM_INTERPOLATE(fieldName) data.fieldName = patch[0].fieldName * barycentricCoordinates.x + patch[1].fieldName * barycentricCoordinates.y + patch[2].fieldName * barycentricCoordinates.z; + + MY_DOMAIN_PROGRAM_INTERPOLATE(vertex) + float3 pp[3]; + for (int i = 0; i < 3; ++ i) + { + pp[i] = data.vertex.xyz - patch[i].normal * (dot(data.vertex.xyz, patch[i].normal) - dot(patch[i].vertex.xyz, patch[i].normal)); + } + data.vertex.xyz = _TessellationPhongStrength * (pp[0] * barycentricCoordinates.x + pp[1] * barycentricCoordinates.y + pp[2] * barycentricCoordinates.z) + (1.0f - _TessellationPhongStrength) * data.vertex.xyz; + MY_DOMAIN_PROGRAM_INTERPOLATE(normal) + data.vertex.xyz += data.normal.xyz * _TessellationExtrusionAmount; + MY_DOMAIN_PROGRAM_INTERPOLATE(tangent) + MY_DOMAIN_PROGRAM_INTERPOLATE(color) + MY_DOMAIN_PROGRAM_INTERPOLATE(uv0) + MY_DOMAIN_PROGRAM_INTERPOLATE(uv1) + MY_DOMAIN_PROGRAM_INTERPOLATE(uv2) + MY_DOMAIN_PROGRAM_INTERPOLATE(uv3) + + return vert(data); + } + +#endif diff --git a/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_PoiTessellation.cginc.meta b/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_PoiTessellation.cginc.meta new file mode 100644 index 00000000..590ecc4f --- /dev/null +++ b/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_PoiTessellation.cginc.meta @@ -0,0 +1,9 @@ +fileFormatVersion: 2 +guid: 3694934b8372256468e4edbb9ee8cdc9 +ShaderImporter: + externalObjects: {} + defaultTextures: [] + nonModifiableTextures: [] + userData: + assetBundleName: + assetBundleVariant: diff --git a/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_PoiUVDistortion.cginc b/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_PoiUVDistortion.cginc new file mode 100644 index 00000000..0daef159 --- /dev/null +++ b/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_PoiUVDistortion.cginc @@ -0,0 +1,53 @@ +#ifndef POI_UV_DISTORTION + #define POI_UV_DISTORTION + + #if defined(PROP_DISTORTIONFLOWTEXTURE) || !defined(OPTIMIZER_ENABLED) + UNITY_DECLARE_TEX2D_NOSAMPLER(_DistortionFlowTexture); float4 _DistortionFlowTexture_ST; + #endif + #if defined(PROP_DISTORTIONFLOWTEXTURE1) || !defined(OPTIMIZER_ENABLED) + UNITY_DECLARE_TEX2D_NOSAMPLER(_DistortionFlowTexture1); float4 _DistortionFlowTexture1_ST; + #endif + #if defined(PROP_DISTORTIONMASK) || !defined(OPTIMIZER_ENABLED) + POI_TEXTURE_NOSAMPLER(_DistortionMask); + #endif + + float _DistortionStrength; + float _DistortionStrength1; + float2 _DistortionSpeed; + float2 _DistortionSpeed1; + + float2 getTorusUv(float2 uv) + { + // translated to hlsl from https://www.shadertoy.com/view/Md3Bz7 + // http://web.cs.ucdavis.edu/~amenta/s12/findnorm.pdf + float phi = 6.28318530718f * uv.x; + float theta = 6.28318530718f * uv.y; + float3 c = cos(float3(phi, phi + 1.57079632679f, theta)); + float2 result = float2(c.x * c.z, -c.y * c.z); + return result * 0.5 + 0.5; + } + + float2 calculateDistortionUV(float2 uv) + { + #if defined(PROP_DISTORTIONFLOWTEXTURE) || !defined(OPTIMIZER_ENABLED) + float4 flowVector = UNITY_SAMPLE_TEX2D_SAMPLER(_DistortionFlowTexture, _MainTex, TRANSFORM_TEX(poiMesh.uv[0], _DistortionFlowTexture) + _Time.x * float4(0.5,0.5,0,0)) * 2 - 1; + #else + float4 flowVector = 0; + #endif + #if defined(PROP_DISTORTIONFLOWTEXTURE1) || !defined(OPTIMIZER_ENABLED) + float4 flowVector1 = UNITY_SAMPLE_TEX2D_SAMPLER(_DistortionFlowTexture1, _MainTex, TRANSFORM_TEX(poiMesh.uv[0], _DistortionFlowTexture1) + _Time.x * float4(0.5,0.5,0,0)) * 2 - 1; + #else + float4 flowVector1 = 0; + #endif + #if defined(PROP_DISTORTIONMASK) || !defined(OPTIMIZER_ENABLED) + half distortionMask = POI2D_SAMPLER_PAN(_DistortionMask, _MainTex, poiMesh.uv[float(0)], float4(0,0,0,0)).r; + #else + half distortionMask = 1; + #endif + + flowVector *= float(0.5); + flowVector1 *= float(0.5); + return uv + ((flowVector.xy + flowVector1.xy) / 2) * distortionMask; + } + +#endif diff --git a/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_PoiUVDistortion.cginc.meta b/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_PoiUVDistortion.cginc.meta new file mode 100644 index 00000000..47f5ffd1 --- /dev/null +++ b/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_PoiUVDistortion.cginc.meta @@ -0,0 +1,9 @@ +fileFormatVersion: 2 +guid: 5b028d60dc160b14d95ca39498875d27 +ShaderImporter: + externalObjects: {} + defaultTextures: [] + nonModifiableTextures: [] + userData: + assetBundleName: + assetBundleVariant: diff --git a/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_PoiV2F.cginc b/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_PoiV2F.cginc new file mode 100644 index 00000000..0e29a179 --- /dev/null +++ b/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_PoiV2F.cginc @@ -0,0 +1,34 @@ +#ifndef POI_V2F + #define POI_V2F + + struct v2f + { + float4 pos: SV_POSITION; + float4 uv0: TEXCOORD0; + float4 uv1: TEXCOORD1; + float3 normal: TEXCOORD2; + float3 tangentViewDir: TEXCOORD3; + float4 tangent: TEXCOORD4; + float4 worldPos: TEXCOORD5; + float4 localPos: TEXCOORD6; + float4 grabPos: TEXCOORD7; + float3 barycentricCoordinates: TEXCOORD8; + #if defined(GRAIN) + float4 worldDirection: TEXCOORD9; + #endif + #if defined(LIGHTMAP_ON) || defined(DYNAMICLIGHTMAP_ON) + float4 lightmapUV: TEXCOORD10; + #endif + float3 modelPos: TEXCOORD11; + float angleAlpha: TEXCOORD12; + float4 vertexColor: TEXCOORD14; + #ifdef FUR + float furAlpha: TEXCOORD15; + #endif + UNITY_SHADOW_COORDS(16) + UNITY_FOG_COORDS(17) + UNITY_VERTEX_INPUT_INSTANCE_ID + UNITY_VERTEX_OUTPUT_STEREO + }; + +#endif diff --git a/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_PoiV2F.cginc.meta b/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_PoiV2F.cginc.meta new file mode 100644 index 00000000..d10c287c --- /dev/null +++ b/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_PoiV2F.cginc.meta @@ -0,0 +1,9 @@ +fileFormatVersion: 2 +guid: 4b095176eb8a3d147b56629faf250009 +ShaderImporter: + externalObjects: {} + defaultTextures: [] + nonModifiableTextures: [] + userData: + assetBundleName: + assetBundleVariant: diff --git a/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_PoiVert.cginc b/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_PoiVert.cginc new file mode 100644 index 00000000..a2486f3b --- /dev/null +++ b/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_PoiVert.cginc @@ -0,0 +1,137 @@ +#ifndef POI_VERT +#define POI_VERT + +float _VertexManipulationHeightUV; +float _VertexUnwrap; + +#define PM UNITY_MATRIX_P + +inline float4 CalculateFrustumCorrection() +{ + float x1 = -PM._31 / (PM._11 * PM._34); + float x2 = -PM._32 / (PM._22 * PM._34); + return float4(x1, x2, 0, PM._33 / PM._34 + x1 * PM._13 + x2 * PM._23); +} + +v2f vert(appdata v) +{ + UNITY_SETUP_INSTANCE_ID(v); + v2f o; + + #ifdef _COLOROVERLAY_ON + v.vertex.xyz = lerp(v.vertex.xyz, float3(v.uv0.x - .5, v.uv0.y - .5, 0), float(0)); + #endif + + #ifdef RALIV_PENETRATION + applyRalivDynamicOrifaceSystem(v); + #endif + + #ifdef AUTO_EXPOSURE + applyLocalVertexTransformation(v.normal, v.tangent, v.vertex); + #endif + + + UNITY_INITIALIZE_OUTPUT(v2f, o); + UNITY_TRANSFER_INSTANCE_ID(v, o); + UNITY_INITIALIZE_VERTEX_OUTPUT_STEREO(o); + + + #ifdef _REQUIRE_UV2 //POI_MIRROR + applyMirrorRenderVert(v.vertex); + #endif + + TANGENT_SPACE_ROTATION; + o.localPos = v.vertex; + o.worldPos = mul(unity_ObjectToWorld, o.localPos); + o.normal = UnityObjectToWorldNormal(v.normal); + + #ifdef RALIV_PENETRATION + applyRalivDynamicPenetrationSystem(o.localPos.rgb, o.normal.rgb, v); + #endif + + //o.localPos.x *= -1; + //o.localPos.xz += sin(o.localPos.y * 100 + _Time.y * 5) * .0025; + + float2 uvToUse = 0; + + if (float(0) == 0) + { + uvToUse = v.uv0.xy; + } + + if (float(0) == 1) + { + uvToUse = v.uv1.xy; + } + + if (float(0) == 2) + { + uvToUse = v.uv2.xy; + } + + if (float(0) == 3) + { + uvToUse = v.uv3.xy; + } + #ifdef AUTO_EXPOSURE + applyWorldVertexTransformation(o.worldPos, o.localPos, o.normal, uvToUse); + #endif + applyVertexGlitching(o.worldPos, o.localPos); + applySpawnInVert(o.worldPos, o.localPos, v.uv0.xy); + #ifdef AUTO_EXPOSURE + applyVertexRounding(o.worldPos, o.localPos); + #endif + o.pos = UnityObjectToClipPos(o.localPos); + o.grabPos = ComputeGrabScreenPos(o.pos); + o.uv0.xy = v.uv0.xy; + o.uv0.zw = v.uv1.xy; + o.uv1.xy = v.uv2.xy; + o.uv1.zw = v.uv3.xy; + o.vertexColor = v.color; + o.modelPos = mul(unity_ObjectToWorld, float4(0, 0, 0, 1)).xyz; + o.tangent = float4(UnityObjectToWorldDir(v.tangent.xyz), v.tangent.w); + + #ifdef POI_BULGE + bulgyWolgy(o); + #endif + + + o.angleAlpha = 1; + #ifdef _SUNDISK_NONE //POI_RANDOM + o.angleAlpha = ApplyAngleBasedRendering(o.modelPos, o.worldPos); + #endif + + #if defined(LIGHTMAP_ON) + o.lightmapUV.xy = v.uv1.xy * unity_LightmapST.xy + unity_LightmapST.zw; + #endif + #ifdef DYNAMICLIGHTMAP_ON + o.lightmapUV.zw = v.uv2.xy * unity_DynamicLightmapST.xy + unity_DynamicLightmapST.zw; + #endif + + UNITY_TRANSFER_SHADOW(o, o.uv0.xy); + UNITY_TRANSFER_FOG(o, o.pos); + + v.tangent.xyz = normalize(v.tangent.xyz); + v.normal = normalize(v.normal); + float3x3 objectToTangent = float3x3( + v.tangent.xyz, + cross(v.normal, v.tangent.xyz) * v.tangent.w, + v.normal + ); + o.tangentViewDir = mul(objectToTangent, ObjSpaceViewDir(v.vertex)); + + #ifdef POI_META_PASS + o.pos = UnityMetaVertexPosition(v.vertex, v.uv1.xy, v.uv2.xy, unity_LightmapST, unity_DynamicLightmapST); + #endif + + #if defined(GRAIN) + float4 worldDirection; + + worldDirection.xyz = o.worldPos.xyz - _WorldSpaceCameraPos; + worldDirection.w = dot(o.pos, CalculateFrustumCorrection()); + o.worldDirection = worldDirection; + #endif + + return o; +} +#endif diff --git a/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_PoiVert.cginc.meta b/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_PoiVert.cginc.meta new file mode 100644 index 00000000..c765c940 --- /dev/null +++ b/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_PoiVert.cginc.meta @@ -0,0 +1,9 @@ +fileFormatVersion: 2 +guid: 69908520daad6e24f93b7d8eda8a511c +ShaderImporter: + externalObjects: {} + defaultTextures: [] + nonModifiableTextures: [] + userData: + assetBundleName: + assetBundleVariant: diff --git a/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_PoiVertexManipulations.cginc b/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_PoiVertexManipulations.cginc new file mode 100644 index 00000000..1de2c191 --- /dev/null +++ b/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_PoiVertexManipulations.cginc @@ -0,0 +1,102 @@ +#ifndef POI_VERTEX_MANIPULATION + #define POI_VERTEX_MANIPULATION + + #include "CGI_PoiMath.cginc" + + float4 _VertexManipulationLocalTranslation; + float4 _VertexManipulationLocalRotation; + float4 _VertexManipulationLocalScale; + float4 _VertexManipulationWorldTranslation; + + float _VertexManipulationHeight; + float _VertexManipulationHeightBias; + #if defined(PROP_VERTEXMANIPULATIONHEIGHTMASK) || !defined(OPTIMIZER_ENABLED) + sampler2D _VertexManipulationHeightMask; float4 _VertexManipulationHeightMask_ST; + #endif + float2 _VertexManipulationHeightPan; + + + //Vertex Glitching + float _EnableVertexGlitch; + float _VertexGlitchThreshold; + float _VertexGlitchFrequency; + float _VertexGlitchStrength; + // Rounding + float _VertexRoundingDivision; + float _VertexRoundingEnabled; + + void applyLocalVertexTransformation(inout float3 normal, inout float4 tangent, inout float4 vertex) + { + normal = rotate_with_quaternion(normal, float4(0,0,0,1).xyz); + tangent.xyz = rotate_with_quaternion(tangent.xyz, float4(0,0,0,1).xyz); + vertex = transform(vertex, float4(0,0,0,1), float4(0,0,0,1), float4(1,1,1,1)); + + //vertex = float4(vertex.x + sin(_Time.y*1.5 + vertex.y * 50) * .75 * smoothstep( .3, -1, vertex.y), vertex.y, vertex.z + cos(_Time.y*1.5 + vertex.y * 50) * .75 * smoothstep( .3, -1, vertex.y), 1); + } + + void applyLocalVertexTransformation(inout float3 normal, inout float4 vertex) + { + normal = rotate_with_quaternion(normal, float4(0,0,0,1).xyz); + vertex = transform(vertex, float4(0,0,0,1), float4(0,0,0,1), float4(1,1,1,1)); + + //vertex = float4(vertex.x + sin(_Time.y*1.5 + vertex.y * 50) * .75 * smoothstep( .3, -1, vertex.y), vertex.y, vertex.z + cos(_Time.y*1.5 + vertex.y * 50) * .75 * smoothstep( .3, -1, vertex.y), 1); + } + + void applyWorldVertexTransformation(inout float4 worldPos, inout float4 localPos, inout float3 worldNormal, float2 uv) + { + #if defined(PROP_VERTEXMANIPULATIONHEIGHTMASK) || !defined(OPTIMIZER_ENABLED) + float3 heightOffset = (tex2Dlod(_VertexManipulationHeightMask, float4(TRANSFORM_TEX(uv, _VertexManipulationHeightMask) + float4(0,0,0,0) * _Time.x, 0, 0)).r - float(0)) * float(0) * worldNormal; + #else + float3 heightOffset = float(0) * worldNormal; + #endif + worldPos.rgb += float4(0,0,0,1).xyz/* * float4(0,0,0,1).w*/ + heightOffset; + localPos.xyz = mul(unity_WorldToObject, worldPos).xyz; + } + + void applyWorldVertexTransformationShadow(inout float4 worldPos, inout float4 localPos, float3 worldNormal, float2 uv) + { + #if defined(PROP_VERTEXMANIPULATIONHEIGHTMASK) || !defined(OPTIMIZER_ENABLED) + float3 heightOffset = (tex2Dlod(_VertexManipulationHeightMask, float4(TRANSFORM_TEX(uv, _VertexManipulationHeightMask) + float4(0,0,0,0) * _Time.x, 0, 0)).r - float(0)) * float(0) * worldNormal; + #else + float3 heightOffset = float(0) * worldNormal; + #endif + worldPos.rgb += float4(0,0,0,1).xyz/* * float4(0,0,0,1).w*/ + heightOffset; + localPos.xyz = mul(unity_WorldToObject, worldPos).xyz; + } + + void applyVertexRounding(inout float4 worldPos, inout float4 localPos) + { + + if (float(0)) + { + worldPos.xyz = (ceil(worldPos.xyz * float(500)) / float(500)) - 1 / float(500) * .5; + localPos = mul(unity_WorldToObject, worldPos); + } + } + + void applyVertexGlitching(inout float4 worldPos, inout float4 localPos) + { + + if(float(0)) + { + float3 forward = getCameraPosition() - mul(unity_ObjectToWorld, float4(0, 0, 0, 1)).xyz; + forward.y = 0; + forward = normalize(forward); + float3 glitchDirection = normalize(cross(float3(0, 1, 0), forward)); + float glitchAmount = frac(sin(dot(_Time.xy + worldPos.y, float2(12.9898, 78.233))) * 43758.5453123) * 2 - 1; + /* + float uvl = worldPos.y * _VertexGlitchDensity + _Time.x * _VertexGlitchMapPanSpeed; + float uvr = worldPos.y * _VertexGlitchDensity - _Time.x * _VertexGlitchMapPanSpeed; + float glitchAmountLeft = tex2Dlod(_VertexGlitchMap, float4(uvl, uvl, 0, 0)).r; + float glitchAmountRight = -tex2Dlod(_VertexGlitchMap, float4(uvr, uvr, 0, 0)).r; + float glitchAmount = glitchAmountLeft + glitchAmountRight; + */ + float time = _Time.y * float(0); + float randomGlitch = (sin(time) + sin(2.2 * time + 5.52) + sin(2.9 * time + 0.93) + sin(4.6 * time + 8.94)) / 4; + worldPos.xyz += glitchAmount * glitchDirection * (float(1) * .01) * step(float(1), randomGlitch); + localPos = mul(unity_WorldToObject, worldPos); + } + } + +#endif +// diff --git a/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_PoiVertexManipulations.cginc.meta b/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_PoiVertexManipulations.cginc.meta new file mode 100644 index 00000000..51ced287 --- /dev/null +++ b/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_PoiVertexManipulations.cginc.meta @@ -0,0 +1,9 @@ +fileFormatVersion: 2 +guid: 0368d8ca1888cd744a187a09b37cf43d +ShaderImporter: + externalObjects: {} + defaultTextures: [] + nonModifiableTextures: [] + userData: + assetBundleName: + assetBundleVariant: diff --git a/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_PoiVideo.cginc b/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_PoiVideo.cginc new file mode 100644 index 00000000..b6739cd9 --- /dev/null +++ b/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_PoiVideo.cginc @@ -0,0 +1,297 @@ +#ifndef POI_VIDEO + #define POI_VIDEO + + #if defined(PROP_VIDEOPIXELTEXTURE) || !defined(OPTIMIZER_ENABLED) + UNITY_DECLARE_TEX2D_NOSAMPLER(_VideoPixelTexture); float4 _VideoPixelTexture_ST; + #endif + #if defined(PROP_VIDEOMASKTEXTURE) || !defined(OPTIMIZER_ENABLED) + UNITY_DECLARE_TEX2D_NOSAMPLER(_VideoMaskTexture); float4 _VideoMaskTexture_ST; + #endif + #if defined(PROP_VIDEOGAMEBOYRAMP) || !defined(OPTIMIZER_ENABLED) + sampler2D _VideoGameboyRamp; + #endif + #if defined(PROP_VIDEODEBUGTEXTURE) || !defined(OPTIMIZER_ENABLED) + UNITY_DECLARE_TEX2D_NOSAMPLER(_VideoDebugTexture); float4 _VideoDebugTexture_ST; + #endif + + float _VideoUVNumber; + float _VideoType; + float3 pixels; + float2 _VideoResolution; + half _VideoBacklight; + half _VideoCRTRefreshRate; + half _VideoCRTPixelEnergizedTime; + half _VideoEnableVideoPlayer; + half _VideoRepeatVideoTexture; + half _VideoPixelateToResolution; + float2 _VideoMaskPanning; + float _VideoEmissionEnabled; + // Video Settings + half _VideoSaturation; + half _VideoContrast; + float2 _VideoTiling; + float2 _VideoOffset; + float2 _VideoPanning; + + //Debug + half _VideoEnableDebug; + + + + sampler2D _VRChat_VideoPlayer; + float4 _VRChat_VideoPlayer_TexelSize; + + float4 globalVideoPlayerColor; + float3 globalColorToDisplayOnScreen; + float globalVideoOn; + + float3 applyBacklight(float3 albedo, half backlightStrength) + { + return max(backlightStrength, albedo.rgb); + } + + float3 applyViewAngleTN(float3 albedo) + { + float3 reflectionVector = normalize(reflect(poiCam.viewDir.rgb, poiMesh.normals[1].rgb)); + float upwardShift = dot(reflectionVector, poiMesh.binormal); + upwardShift = pow(upwardShift, 1); + float sideShift = dot(reflectionVector, poiMesh.tangent); + sideShift *= pow(sideShift, 3); + #if !UNITY_COLORSPACE_GAMMA + albedo = LinearToGammaSpace(albedo); + #endif + albedo = saturate(lerp(half3(0.5, 0.5, 0.5), albedo, upwardShift + 1)); + #if !UNITY_COLORSPACE_GAMMA + albedo = GammaToLinearSpace(albedo); + #endif + albedo = (lerp(albedo, albedo.gbr, sideShift)); + return albedo; + } + + float calculateCRTPixelBrightness() + { + float totalPixels = float4(1280,720,0,1).x * float4(1280,720,0,1).y; + float2 uvPixel = float2((floor((1 - poiMesh.uv[float(0)].y) * float4(1280,720,0,1).y)) / float4(1280,720,0,1).y, (floor(poiMesh.uv[float(0)].x * float4(1280,720,0,1).x)) / float4(1280,720,0,1).x); + float currentPixelNumber = float4(1280,720,0,1).x * (float4(1280,720,0,1).y * uvPixel.x) + float4(1280,720,0,1).y * uvPixel.y; + float currentPixelAlpha = currentPixelNumber / totalPixels; + half electronBeamAlpha = frac(_Time.y * float(24)); + float electronBeamPixelNumber = totalPixels * electronBeamAlpha; + + float DistanceInPixelsFromCurrentElectronBeamPixel = 0; + if (electronBeamPixelNumber >= currentPixelNumber) + { + DistanceInPixelsFromCurrentElectronBeamPixel = electronBeamPixelNumber - currentPixelNumber; + } + else + { + DistanceInPixelsFromCurrentElectronBeamPixel = electronBeamPixelNumber + (totalPixels - currentPixelNumber); + } + float CRTFrameTime = 1 / float(24); + float timeSincecurrentPixelWasHitByElectronBeam = (DistanceInPixelsFromCurrentElectronBeamPixel / totalPixels); + + return saturate(float(1.9) - timeSincecurrentPixelWasHitByElectronBeam); + } + + void applyContrastSettings(inout float3 pixel) + { + #if !UNITY_COLORSPACE_GAMMA + pixel = LinearToGammaSpace(pixel); + #endif + pixel = saturate(lerp(half3(0.5, 0.5, 0.5), pixel, float(0) + 1)); + #if !UNITY_COLORSPACE_GAMMA + pixel = GammaToLinearSpace(pixel); + #endif + } + + void applySaturationSettings(inout float3 pixel) + { + pixel = lerp(pixel.rgb, dot(pixel.rgb, float3(0.3, 0.59, 0.11)), -float(0)); + } + + void applyVideoSettings(inout float3 pixel) + { + applySaturationSettings(pixel); + applyContrastSettings(pixel); + } + + void calculateLCD(inout float4 albedo) + { + + if(float(0) == 0) + { + globalColorToDisplayOnScreen = albedo; + } + globalColorToDisplayOnScreen = applyBacklight(globalColorToDisplayOnScreen, float(1) * .01); + applyVideoSettings(globalColorToDisplayOnScreen); + albedo.rgb = globalColorToDisplayOnScreen * pixels * float(1) + albedo * .000001; + } + void calculateTN(inout float4 albedo) + { + if(float(0) == 0) + { + globalColorToDisplayOnScreen = albedo; + } + globalColorToDisplayOnScreen = applyBacklight(globalColorToDisplayOnScreen, float(1) * .01); + globalColorToDisplayOnScreen = applyViewAngleTN(globalColorToDisplayOnScreen); + applyVideoSettings(globalColorToDisplayOnScreen); + albedo.rgb = globalColorToDisplayOnScreen * pixels * float(1) + albedo * .000001; + } + void calculateCRT(inout float4 albedo) + { + + if(float(0) == 0) + { + globalColorToDisplayOnScreen = albedo; + } + float brightness = calculateCRTPixelBrightness(); + applyVideoSettings(globalColorToDisplayOnScreen); + albedo.rgb = globalColorToDisplayOnScreen * pixels * brightness * float(1) + albedo * .000001; + } + void calculateOLED(inout float4 albedo) + { + + if(float(0) == 0) + { + globalColorToDisplayOnScreen = albedo; + } + applyVideoSettings(globalColorToDisplayOnScreen); + albedo.rgb = globalColorToDisplayOnScreen * pixels * float(1) + albedo * .000001; + } + void calculateGameboy(inout float4 albedo) + { + + if(float(0) == 0) + { + globalColorToDisplayOnScreen = albedo; + } + applyVideoSettings(globalColorToDisplayOnScreen); + half brightness = saturate((globalColorToDisplayOnScreen.r + globalColorToDisplayOnScreen.g + globalColorToDisplayOnScreen.b) * .3333333); + #if defined(PROP_VIDEOGAMEBOYRAMP) || !defined(OPTIMIZER_ENABLED) + albedo.rgb = tex2D(_VideoGameboyRamp, brightness); + #endif + } + void calculateProjector(inout float4 albedo) + { + + if(float(0) == 0) + { + globalColorToDisplayOnScreen = albedo; + } + applyVideoSettings(globalColorToDisplayOnScreen); + + float3 projectorColor = albedo * globalColorToDisplayOnScreen * float(1); + albedo.r = clamp(projectorColor.r, albedo.r, 1000); + albedo.g = clamp(projectorColor.g, albedo.g, 1000); + albedo.b = clamp(projectorColor.b, albedo.b, 1000); + } + + void applyScreenEffect(inout float4 albedo, inout float3 videoEmission) + { + float4 albedoBeforeScreen = albedo; + #if defined(PROP_VIDEOPIXELTEXTURE) || !defined(OPTIMIZER_ENABLED) + pixels = UNITY_SAMPLE_TEX2D_SAMPLER(_VideoPixelTexture, _MainTex, TRANSFORM_TEX(poiMesh.uv[float(0)], _VideoPixelTexture) * float4(1280,720,0,1)); + #else + pixels = 1; + #endif + globalVideoOn = 0; + + if(float(0) == 1) + { + float4 videoTexture = 0; + + if(float(0)) + { + + if(float(0)) + { + #if defined(PROP_VIDEODEBUGTEXTURE) || !defined(OPTIMIZER_ENABLED) + videoTexture = UNITY_SAMPLE_TEX2D_SAMPLER(_VideoDebugTexture, _MainTex, round(TRANSFORM_TEX(poiMesh.uv[float(0)], _VideoDebugTexture) * float4(1280,720,0,1) + .5) / float4(1280,720,0,1)); + #else + videoTexture = 1; + #endif + } + else + { + videoTexture = tex2D(_VRChat_VideoPlayer, round(poiMesh.uv[float(0)] * float4(1280,720,0,1) + .5) / float4(1280,720,0,1)); + } + } + else + { + + if(float(0)) + { + #if defined(PROP_VIDEODEBUGTEXTURE) || !defined(OPTIMIZER_ENABLED) + videoTexture = UNITY_SAMPLE_TEX2D_SAMPLER(_VideoDebugTexture, _MainTex, TRANSFORM_TEX(poiMesh.uv[float(0)], _VideoDebugTexture) * float4(1,1,0,0) + float4(0,0,0,0)); + #else + videoTexture = 1; + #endif + } + else + { + videoTexture = tex2D(_VRChat_VideoPlayer, ((poiMesh.uv[float(0)] + _Time.x * float4(0,0,0,0)) * float4(1,1,0,0)) + float4(0,0,0,0)); + } + } + if(videoTexture.a == 1) + { + globalColorToDisplayOnScreen = videoTexture.rgb; + globalVideoOn = 1; + } + } + + + if(float(0) == 1) + { + if(poiMesh.uv[float(0)].x > 1 || poiMesh.uv[float(0)].x < 0 || poiMesh.uv[float(0)].y > 1 || poiMesh.uv[float(0)].y < 0) + { + return; + } + } + + switch(float(3)) + { + case 0: // LCD + { + calculateLCD(albedo); + break; + } + case 1: // TN + { + calculateTN(albedo); + break; + } + case 2: // CRT + { + calculateCRT(albedo); + break; + } + case 3: // OLED + { + calculateOLED(albedo); + break; + } + case 4: // Gameboy + { + calculateGameboy(albedo); + break; + } + case 5: // Projector + { + calculateProjector(albedo); + break; + } + } + #if defined(PROP_VIDEOMASKTEXTURE) || !defined(OPTIMIZER_ENABLED) + float screenMask = UNITY_SAMPLE_TEX2D_SAMPLER(_VideoMaskTexture, _MainTex, TRANSFORM_TEX(poiMesh.uv[float(0)], _VideoMaskTexture) + _Time.x * float4(0,0,0,0)); + #else + float screenMask = 1; + #endif + + albedo = lerp(albedoBeforeScreen, albedo, screenMask); + + if (float(1)) + { + videoEmission = albedo.rgb * screenMask; + } + } + +#endif diff --git a/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_PoiVideo.cginc.meta b/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_PoiVideo.cginc.meta new file mode 100644 index 00000000..9d5812f1 --- /dev/null +++ b/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_PoiVideo.cginc.meta @@ -0,0 +1,9 @@ +fileFormatVersion: 2 +guid: 4db8e488540cc4c4fb40e7efb7bacc9e +ShaderImporter: + externalObjects: {} + defaultTextures: [] + nonModifiableTextures: [] + userData: + assetBundleName: + assetBundleVariant: diff --git a/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_PoiVoronoi.cginc b/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_PoiVoronoi.cginc new file mode 100644 index 00000000..90f22caa --- /dev/null +++ b/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_PoiVoronoi.cginc @@ -0,0 +1,312 @@ +#ifndef POI_VORONOI + #define POI_VORONOI + + float _VoronoiSpace; + float _VoronoiBlend; + float _VoronoiType; + float4 _VoronoiColor0; + float _VoronoiEmission0; + float4 _VoronoiColor1; + float _VoronoiEmission1; + float2 _VoronoiGradient; + float _VoronoiScale; + float3 _VoronoiSpeed; + float _VoronoiEnableRandomCellColor; + float2 _VoronoiRandomMinMaxSaturation; + float2 _VoronoiRandomMinMaxBrightness; + float3 randomPoint; + float _VoronoiEffectsMaterialAlpha; + + #if defined(PROP_VORONOIMASK) || !defined(OPTIMIZER_ENABLED) + POI_TEXTURE_NOSAMPLER(_VoronoiMask); + #endif + #if defined(PROP_VORONOINOISE) || !defined(OPTIMIZER_ENABLED) + POI_TEXTURE_NOSAMPLER(_VoronoiNoise); + #endif + float _VoronoiNoiseIntensity; + + float2 inoise(float3 P, float jitter) + { + float3 Pi = mod(floor(P), 289.0); + float3 Pf = frac(P); + float3 oi = float3(-1.0, 0.0, 1.0); + float3 of = float3(-0.5, 0.5, 1.5); + float3 px = Permutation(Pi.x + oi); + float3 py = Permutation(Pi.y + oi); + + float3 p, ox, oy, oz, dx, dy, dz; + float2 F = 1e6; + + for (int i = 0; i < 3; i ++) + { + for (int j = 0; j < 3; j ++) + { + p = Permutation(px[i] + py[j] + Pi.z + oi); // pij1, pij2, pij3 + + ox = frac(p * K) - Ko; + oy = mod(floor(p * K), 7.0) * K - Ko; + + p = Permutation(p); + + oz = frac(p * K) - Ko; + + dx = Pf.x - of[i] + jitter * ox; + dy = Pf.y - of[j] + jitter * oy; + dz = Pf.z - of + jitter * oz; + + float3 d = dx * dx + dy * dy + dz * dz; // dij1, dij2 and dij3, squared + + //Find lowest and second lowest distances + for (int n = 0; n < 3; n ++) + { + if (d[n] < F[0]) + { + F[1] = F[0]; + F[0] = d[n]; + randomPoint = p; + } + else if(d[n] < F[1]) + { + F[1] = d[n]; + } + } + } + } + + return F; + } + + float voronoi2D(in float2 x, float scale, float2 speed) + { + x *= scale; + x += speed * _Time.x; + float2 n = floor(x); + float2 f = frac(x); + + // first pass: regular voronoi + float2 mg, mr; + float md = 8.0; + for (int j = -1; j <= 1; j ++) + { + for (int i = -1; i <= 1; i ++) + { + float2 g = float2(float(i), float(j)); + float2 o = random2(n + g); + float2 currentPoint = o; + + float2 r = g + o - f; + float d = dot(r, r); + + if (d < md) + { + md = d; + mr = r; + mg = g; + randomPoint.xy = currentPoint; + } + } + } + + // second pass: distance to borders + md = 8.0; + for (int r = -2; r <= 2; r ++) + { + for (int q = -2; q <= 2; q ++) + { + float2 g = mg + float2(float(q), float(r)); + float2 o = random2(n + g); + + float2 r = g + o - f; + + if (dot(mr - r, mr - r) > 0.00001) + { + md = min(md, dot(0.5 * (mr + r), normalize(r - mr))); + } + } + } + return md; + } + + float voronoi3D(in float3 x, float scale, float3 speed) + { + x *= scale; + x += speed * _Time.x; + float3 n = floor(x); + float3 f = frac(x); + + // first pass: regular voronoi + float3 mg, mr; + float md = 8.0; + for (int j = -1; j <= 1; j ++) + { + for (int i = -1; i <= 1; i ++) + { + for (int h = -1; h <= 1; h ++) + { + float3 g = float3(float(h), float(i), float(j)); + float3 o = random3(n + g); + float3 currentPoint = o; + + float3 r = g + o - f; + float d = dot(r, r); + + if (d < md) + { + md = d; + mr = r; + mg = g; + randomPoint = currentPoint; + } + } + } + } + + // second pass: distance to borders + md = 8.0; + for (int r = -2; r <= 2; r ++) + { + for (int q = -2; q <= 2; q ++) + { + for (int p = -2; p <= 2; p ++) + { + float3 g = mg + float3(float(p), float(q), float(r)); + float3 o = random3(n + g); + + float3 r = g + o - f; + + if (dot(mr - r, mr - r) > 0.00001) + { + md = min(md, dot(0.5 * (mr + r), normalize(r - mr))); + } + } + } + } + return md; + } + + + + // fracal sum, range -1.0 - 1.0 + float VoronoiNoise_Octaves(float3 p, float scale, float3 speed, int octaveNumber, float octaveScale, float octaveAttenuation, float jitter, float time) + { + float freq = scale; + float weight = 1.0f; + float sum = 0; + for (int i = 0; i < octaveNumber; i ++) + { + float2 F = inoise(p * freq + time * speed, jitter) * weight; + + sum += sqrt(F[0]); + + freq *= octaveScale; + weight *= 1.0f - octaveAttenuation; + } + return sum; + } + + float VoronoiNoiseDiff_Octaves(float3 p, float scale, float3 speed, int octaveNumber, float octaveScale, float octaveAttenuation, float jitter, float time) + { + float freq = scale; + float weight = 1.0f; + float sum = 0; + for (int i = 0; i < octaveNumber; i ++) + { + float2 F = inoise(p * freq + time * speed, jitter) * weight; + + sum += sqrt(F[1]) - sqrt(F[0]); + + freq *= octaveScale; + weight *= 1.0f - octaveAttenuation; + } + return sum; + } + + void applyVoronoi(inout float4 finalColor, inout float3 VoronoiEmission) + { + float voronoiOctaveNumber = 1; + float voronoiOctaveScale = 1; + float voronoiOctaveAttenuation = 1; + randomPoint = 0; + float4 voronoiColor1 = float4(1,1,1,1); + + float voronoi = 0; + + float3 position = 0; + + + if (float(0) == 0) + { + position = poiMesh.localPos; + } + + if(float(0) == 1) + { + position = poiMesh.worldPos; + } + + if(float(0) == 2) + { + position = float3(poiMesh.uv[0].x, poiMesh.uv[0].y, 0); + } + #if defined(PROP_VORONOIMASK) || !defined(OPTIMIZER_ENABLED) + float mask = POI2D_SAMPLER_PAN(_VoronoiMask, _MainTex, poiMesh.uv[float(0)], float4(0,0,0,0)).r; + #else + float mask = 1; + #endif + #if defined(PROP_VORONOINOISE) || !defined(OPTIMIZER_ENABLED) + float edgeNoise = POI2D_SAMPLER_PAN(_VoronoiNoise, _MainTex, poiMesh.uv[float(0)], float4(0,0,0,0)).r * float(0.1); + #else + float edgeNoise = 0; + #endif + + if(float(1) == 0) // Basic + { + voronoi = voronoi2D(position.xy, float(5), float4(3,3,3,1)); + } + + if (float(1) == 1) // Diff + { + voronoi = VoronoiNoiseDiff_Octaves(position, float(5), float4(3,3,3,1), voronoiOctaveNumber, voronoiOctaveScale, voronoiOctaveAttenuation, 1, _Time.x); + } + + if (float(1) == 2) // Fixed Border + { + voronoi = voronoi3D(position, float(5), float4(3,3,3,1)); + // isolines + //color = c.x * (0.5 + 0.5 * sin(64.0 * c.x)) * 1.0; + } + + if (float(0) == 1) + { + float3 rando = random3(randomPoint); + fixed hue = rando.x; + fixed saturation = lerp(float4(0.8,1,0,1).x, float4(0.8,1,0,1).y, rando.y); + fixed value = lerp(float4(0.8,1,0,1).x, float4(0.8,1,0,1).y, rando.z); + float3 hsv = float3(hue, saturation, value); + + voronoiColor1.rgb = HSVtoRGB(hsv); + } + + float2 voronoiGradient = float4(0.04,0.05,0,0); + voronoiGradient.xy += edgeNoise; + float ramp = smoothstep(voronoiGradient.x, voronoiGradient.y, voronoi); + + + if(float(0) == 0) + { + float4 voronoiColor = lerp(float4(0,0,0,1), voronoiColor1, ramp); + + if(float(0)) + { + finalColor.rgba = lerp(finalColor, voronoiColor, mask); + } + else + { + finalColor.rgb = lerp(finalColor.rgb, voronoiColor.rgb, mask * voronoiColor.a); + } + } + float4 voronoiEmissionColor = lerp(float4(0,0,0,1) * float(0), voronoiColor1 * float(0), ramp); + VoronoiEmission = voronoiEmissionColor.rgb * mask * voronoiEmissionColor.a; + } + +#endif diff --git a/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_PoiVoronoi.cginc.meta b/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_PoiVoronoi.cginc.meta new file mode 100644 index 00000000..61fd6ce1 --- /dev/null +++ b/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_PoiVoronoi.cginc.meta @@ -0,0 +1,9 @@ +fileFormatVersion: 2 +guid: ceeef7657dc2aa4438ec765a4c849d44 +ShaderImporter: + externalObjects: {} + defaultTextures: [] + nonModifiableTextures: [] + userData: + assetBundleName: + assetBundleVariant: diff --git a/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_PoiWireframe.cginc b/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_PoiWireframe.cginc new file mode 100644 index 00000000..49c602c0 --- /dev/null +++ b/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_PoiWireframe.cginc @@ -0,0 +1,111 @@ +#ifndef POI_WIREFRAME + #define POI_WIREFRAME + + UNITY_DECLARE_TEX2D_NOSAMPLER(_WireframeTexture); float4 _WireframeTexture_ST; + float2 _WireframeTexturePan; + float _WireframeSmoothing; + float _WireframeThickness; + float4 _WireframeColor; + float _WireframeAlpha; + float _WireframeEnable; + float _WireframeWaveEnabled; + float _WireframeWaveDensity; + float _WireframeWaveSpeed; + float _WireframeEdgeOpacity; + float _WireframeFaceOpacity; + half _WireframeEmissionAlpha; + float _WireframeEmissionStrength; + float _WireframeQuad; + float _WireframeUV; + + #ifndef POI_SHADOW + void applyWireframe(inout float3 wireframeEmission, inout float4 albedo) + { + + if (_WireframeEnable) + { + float4 colorMap = UNITY_SAMPLE_TEX2D_SAMPLER(_WireframeTexture, _MainTex, TRANSFORM_TEX(poiMesh.uv[_WireframeUV], _WireframeTexture) + _Time.x * _WireframeTexturePan); + float size = _WireframeThickness; + half3 width = abs(ddx(poiMesh.barycentricCoordinates)) + abs(ddy(poiMesh.barycentricCoordinates)); + half3 eF = smoothstep(0, width * size, poiMesh.barycentricCoordinates); + half minBary = size > 0 ? min(min(eF.x, eF.y), eF.z): 1; + + float4 wireframeColor = _WireframeColor * colorMap; + + albedo.a *= lerp(_WireframeEdgeOpacity, _WireframeFaceOpacity, minBary); + albedo.rgb = lerp(lerp(albedo.rgb, wireframeColor.rgb, wireframeColor.a), albedo.rgb, minBary); + wireframeEmission = wireframeColor.rgb * _WireframeEmissionStrength * (1 - minBary) * _WireframeColor.a; + } + } + + [maxvertexcount(3)] + void wireframeGeom(triangle v2f IN[3], inout TriangleStream < v2f > tristream) + { + + if(_WireframeQuad) + { + float e1 = length(IN[0].localPos - IN[1].localPos); + float e2 = length(IN[1].localPos - IN[2].localPos); + float e3 = length(IN[2].localPos - IN[0].localPos); + + float3 quad = 0; + if(e1 > e2 && e1 > e3) + quad.y = 1.; + else if(e2 > e3 && e2 > e1) + quad.x = 1; + else + quad.z = 1; + + IN[0].barycentricCoordinates = fixed3(1, 0, 0) + quad; + IN[1].barycentricCoordinates = fixed3(0, 0, 1) + quad; + IN[2].barycentricCoordinates = fixed3(0, 1, 0) + quad; + } + else + { + IN[0].barycentricCoordinates = fixed3(1, 0, 0); + IN[1].barycentricCoordinates = fixed3(0, 1, 0); + IN[2].barycentricCoordinates = fixed3(0, 0, 1); + } + + + + tristream.Append(IN[0]); + tristream.Append(IN[1]); + tristream.Append(IN[2]); + } + #else + + float applyShadowWireframe(float2 uv, float3 barycentricCoordinates, float3 normal, float3 worldPos) + { + + if(_WireframeEnable) + { + float wireframeFadeAlpha = _WireframeAlpha; + float3 finalWireframeColor = 0; + + float3 barys; + barys.xy = barycentricCoordinates; + barys.z = 1 - barys.x - barys.y; + float3 deltas = fwidth(barys); + float3 smoothing = deltas * _WireframeSmoothing; + float wireframeThickness = _WireframeThickness; + float3 thickness = deltas * wireframeThickness; + barys = smoothstep(thickness, thickness + smoothing, barys); + float minBary = min(barys.x, min(barys.y, barys.z)); + + return lerp(_WireframeEdgeOpacity, _WireframeFaceOpacity, minBary); + } + } + + [maxvertexcount(3)] + void wireframeGeom(triangle V2FShadow IN[3], inout TriangleStream < V2FShadow > tristream) + { + IN[0].barycentricCoordinates = fixed3(1, 0, 0); + IN[1].barycentricCoordinates = fixed3(0, 1, 0); + IN[2].barycentricCoordinates = fixed3(0, 0, 1); + tristream.Append(IN[0]); + tristream.Append(IN[1]); + tristream.Append(IN[2]); + } + #endif +#endif diff --git a/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_PoiWireframe.cginc.meta b/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_PoiWireframe.cginc.meta new file mode 100644 index 00000000..fa350141 --- /dev/null +++ b/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_PoiWireframe.cginc.meta @@ -0,0 +1,9 @@ +fileFormatVersion: 2 +guid: a59b658529984d045a0cacbfcf2d57c8 +ShaderImporter: + externalObjects: {} + defaultTextures: [] + nonModifiableTextures: [] + userData: + assetBundleName: + assetBundleVariant: diff --git a/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_Poicludes.cginc b/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_Poicludes.cginc new file mode 100644 index 00000000..0cf468e1 --- /dev/null +++ b/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_Poicludes.cginc @@ -0,0 +1,180 @@ +#ifndef POICLUDES +#define POICLUDES + +UNITY_DECLARE_TEX2D(_MainTex); float4 _MainTex_ST; float4 _MainTex_TexelSize; +float _SpecularLMOcclusion; +float _SpecLMOcclusionAdjust; +sampler2D _PoiGrab; +sampler2D _CameraDepthTexture; +float _Cutoff; +float _AlphaMod; + +//Structs +struct appdata +{ + float4 vertex: POSITION; + float3 normal: NORMAL; + float4 tangent: TANGENT; + float4 color: COLOR; + float2 uv0: TEXCOORD0; + float2 uv1: TEXCOORD1; + float2 uv2: TEXCOORD2; + float2 uv3: TEXCOORD3; + uint vertexId: SV_VertexID; + UNITY_VERTEX_INPUT_INSTANCE_ID +}; + +#ifdef OUTLINE + float _LineWidth; + float _OutlineEmission; + float4 _LineColor; + sampler2D _OutlineTexture; float4 _OutlineTexture_ST; float2 _OutlineTexturePan; float _OutlineTextureUV; + float4 _OutlineFadeDistance; + float4 _OutlineGlobalPan; +#endif + +struct PoiLighting +{ + half3 direction; + half3 color; + fixed attenuation; + #ifdef FORWARD_ADD_PASS + fixed additiveShadow; + #endif + half3 directLighting; + half3 indirectLighting; + half lightMap; + float3 rampedLightMap; + half3 finalLighting; + half3 halfDir; + half nDotL; + half nDotH; + half lDotv; + half lDotH; + half nDotV; + half N0DotV; + half diffuseTerm; + half occlusion; + // World normal dot half direction + #ifdef POI_VAR_DOTNH + half dotNH; + #endif + + // Light direction dot half direction + #ifdef POI_VAR_DOTLH + half dotLH; + #endif + + #ifdef VERTEXLIGHT_ON + // Non Important Lights + float4 vDotNL; + float3 vColor[4]; + float4 vCorrectedDotNL; + float4 vAttenuation; + float4 vAttenuationDotNL; + float3 vPosition[4]; + float3 vDirection[4]; + float3 vFinalLighting; + float3 vHalfDir[4]; + half4 vDotNH; + half4 vDotLH; + + + #endif +}; + +struct PoiCamera +{ + half3 viewDir; + half3 tangentViewDir; + half3 decalTangentViewDir; + half3 forwardDir; + half3 worldPos; + float viewDotNormal; + float distanceToModel; + float distanceToVert; + float3 reflectionDir; + float3 vertexReflectionDir; + float2 screenUV; + float4 clipPos; + #if defined(GRAIN) + float4 worldDirection; + #endif + float4 grabPos; +}; + +struct PoiMesh +{ + float3 normals[2]; + float4 tangent; + float3 binormal; + float3 localPos; + float3 worldPos; + float3 modelPos; + float3 tangentSpaceNormal; + float2 uv[5]; + float4 vertexColor; + fixed3 barycentricCoordinates; + #if defined(LIGHTMAP_ON) || defined(DYNAMICLIGHTMAP_ON) + float4 lightmapUV; + #endif + float isFrontFace; + #ifdef FUR + float furAlpha; + #endif +}; + +struct PoiTangentData +{ + float3x3 tangentTransform; + float3x3 tangentToWorld; +}; + +struct FragmentCommonData +{ + half3 diffColor, specColor; + // Note: smoothness & oneMinusReflectivity for optimization purposes, mostly for DX9 SM2.0 level. + // Most of the math is being done on these (1-x) values, and that saves a few precious ALU slots. + half oneMinusReflectivity, smoothness; + float3 normalWorld; + float3 eyeVec; + half alpha; + float3 posWorld; + + #if UNITY_STANDARD_SIMPLE + half3 reflUVW; + #endif + + #if UNITY_STANDARD_SIMPLE + half3 tangentSpaceNormal; + #endif +}; + +struct Debug +{ + float debug1; + float2 debug2; + float3 debug3; + float4 debug4; +}; + +struct PoiMods +{ + float4 audioLink; + fixed audioLinkTextureExists; + float4 globalMasks; + float audioLinkVersion; + float4 audioLinkTexture; +}; + +static Debug debug; +static PoiLighting poiLight; +static PoiCamera poiCam; +static PoiMesh poiMesh; +static PoiMods poiMods; +static UnityGI gi; +static FragmentCommonData s; +static PoiTangentData poiTData; + +#endif + diff --git a/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_Poicludes.cginc.meta b/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_Poicludes.cginc.meta new file mode 100644 index 00000000..2f4320a4 --- /dev/null +++ b/VRCSDK3AvatarsLegacy/Assets/Avatars/Auri/materials/OptimizedShaders/auri poiyomi pro dps toy/Includes/CGI_Poicludes.cginc.meta @@ -0,0 +1,9 @@ +fileFormatVersion: 2 +guid: 0793cc34dab574f4eb6214170235b52a +ShaderImporter: + externalObjects: {} + defaultTextures: [] + nonModifiableTextures: [] + userData: + assetBundleName: + assetBundleVariant: |