diff --git a/GLSL-shaders.md b/GLSL-shaders.md new file mode 100644 index 0000000..0123ed1 --- /dev/null +++ b/GLSL-shaders.md @@ -0,0 +1,562 @@ +////////////////////////////////////////// +// +// NOTE: This is *not* a valid shader file +// +/////////////////////////////////////////// +Shader "WalkingFat/SkySystem/DynamicSky" +{ + Properties + { + _NoiseTex ("Noise Texture", 2D) = "white" { } + _MoonTex ("Moon Texture", 2D) = "white" { } + _MoonScale ("Moon Scale", Range(1, 20)) = 10 + _StarColor ("Star Color", Color) = (1,1,1,1) + _GalaxyCloudColor1 ("Galaxy Cloud Color 1", Color) = (1,0,0,1) + _GalaxyCloudColor2 ("Galaxy Cloud Color 2", Color) = (0,0,1,1) + _CloudSpeed ("Cloud Speed", Range(0, 30)) = 3 + _CloudSize ("Cloud Size", Range(1, 10)) = 10 + _CloudFadeDist ("Cloud Fade Distance", Float) = 10000 + _CloudFadeRate ("Cloud Fade Rate", Float) = 6 + _OffsetDistance ("Offset Distance", Range(0, 1)) = 0.1 + _BackLitStrength ("BackLight Strength", Range(0.1, 20)) = 5 + _EdgeLitPower ("Edge Lit Power", Range(0.1, 10)) = 1 + _EdgeLitStrength ("Edge Light Strength", Range(0.1, 20)) = 1 + } + SubShader + { + LOD 100 + Tags { "IGNOREPROJECTOR" = "true" "QUEUE" = "Geometry" "RenderPipeline" = "UniversalPipeline" "RenderType" = "Opaque" } + Pass + { + Name "Unlit" + LOD 100 + Tags { "IGNOREPROJECTOR" = "true" "QUEUE" = "Geometry" "RenderPipeline" = "UniversalPipeline" "RenderType" = "Opaque" } + ZTest Less + Cull Off + GpuProgramID 28434 + Program "vp" + { + SubProgram "gles3 " + { + "#ifdef VERTEX + #version 300 es + + #define HLSLCC_ENABLE_UNIFORM_BUFFERS 1 + #if HLSLCC_ENABLE_UNIFORM_BUFFERS + #define UNITY_UNIFORM + #else + #define UNITY_UNIFORM uniform + #endif + #define UNITY_SUPPORTS_UNIFORM_LOCATION 1 + #if UNITY_SUPPORTS_UNIFORM_LOCATION + #define UNITY_LOCATION(x) layout(location = x) + #define UNITY_BINDING(x) layout(binding = x, std140) + #else + #define UNITY_LOCATION(x) + #define UNITY_BINDING(x) layout(std140) + #endif + uniform vec3 _WorldSpaceCameraPos; + uniform vec4 _ProjectionParams; + uniform vec4 hlslcc_mtx4x4unity_MatrixV[4]; + uniform vec4 hlslcc_mtx4x4unity_MatrixVP[4]; + #if HLSLCC_ENABLE_UNIFORM_BUFFERS + UNITY_BINDING(1) uniform UnityPerDraw { + #endif + UNITY_UNIFORM vec4 hlslcc_mtx4x4unity_ObjectToWorld[4]; + UNITY_UNIFORM vec4 hlslcc_mtx4x4unity_WorldToObject[4]; + UNITY_UNIFORM vec4 unity_LODFade; + UNITY_UNIFORM vec4 unity_WorldTransformParams; + UNITY_UNIFORM vec4 unity_LightData; + UNITY_UNIFORM vec4 unity_LightIndices[2]; + UNITY_UNIFORM vec4 unity_ProbesOcclusion; + UNITY_UNIFORM vec4 unity_SpecCube0_HDR; + UNITY_UNIFORM vec4 unity_LightmapST; + UNITY_UNIFORM vec4 unity_DynamicLightmapST; + UNITY_UNIFORM vec4 unity_SHAr; + UNITY_UNIFORM vec4 unity_SHAg; + UNITY_UNIFORM vec4 unity_SHAb; + UNITY_UNIFORM vec4 unity_SHBr; + UNITY_UNIFORM vec4 unity_SHBg; + UNITY_UNIFORM vec4 unity_SHBb; + UNITY_UNIFORM vec4 unity_SHC; + #if HLSLCC_ENABLE_UNIFORM_BUFFERS + }; + #endif + #if HLSLCC_ENABLE_UNIFORM_BUFFERS + UNITY_BINDING(0) uniform UnityPerMaterial { + #endif + UNITY_UNIFORM vec4 _NoiseTex_ST; + UNITY_UNIFORM float _MoonScale; + UNITY_UNIFORM vec4 _StarColor; + UNITY_UNIFORM vec4 _GalaxyCloudColor1; + UNITY_UNIFORM vec4 _GalaxyCloudColor2; + UNITY_UNIFORM float _CloudSpeed; + UNITY_UNIFORM float _CloudSize; + UNITY_UNIFORM float _CloudFadeDist; + UNITY_UNIFORM float _CloudFadeRate; + UNITY_UNIFORM float _OffsetDistance; + UNITY_UNIFORM float _BackLitStrength; + UNITY_UNIFORM float _EdgeLitPower; + UNITY_UNIFORM float _EdgeLitStrength; + #if HLSLCC_ENABLE_UNIFORM_BUFFERS + }; + #endif + in highp vec4 in_POSITION0; + in highp vec2 in_TEXCOORD0; + in highp vec2 in_TEXCOORD1; + in highp vec3 in_NORMAL0; + out highp vec2 vs_TEXCOORD0; + out highp vec2 vs_TEXCOORD1; + out highp vec3 vs_TEXCOORD2; + out highp vec3 vs_TEXCOORD3; + out highp vec4 vs_TEXCOORD4; + out highp vec4 vs_TEXCOORD5; + out highp vec3 vs_TEXCOORD6; + out highp vec3 vs_TEXCOORD7; + vec4 u_xlat0; + vec4 u_xlat1; + vec3 u_xlat2; + float u_xlat9; + void main() + { + u_xlat0.xyz = in_POSITION0.yyy * hlslcc_mtx4x4unity_ObjectToWorld[1].xyz; + u_xlat0.xyz = hlslcc_mtx4x4unity_ObjectToWorld[0].xyz * in_POSITION0.xxx + u_xlat0.xyz; + u_xlat0.xyz = hlslcc_mtx4x4unity_ObjectToWorld[2].xyz * in_POSITION0.zzz + u_xlat0.xyz; + u_xlat0.xyz = u_xlat0.xyz + hlslcc_mtx4x4unity_ObjectToWorld[3].xyz; + u_xlat1 = u_xlat0.yyyy * hlslcc_mtx4x4unity_MatrixVP[1]; + u_xlat1 = hlslcc_mtx4x4unity_MatrixVP[0] * u_xlat0.xxxx + u_xlat1; + u_xlat1 = hlslcc_mtx4x4unity_MatrixVP[2] * u_xlat0.zzzz + u_xlat1; + u_xlat1 = u_xlat1 + hlslcc_mtx4x4unity_MatrixVP[3]; + gl_Position = u_xlat1; + vs_TEXCOORD0.xy = in_TEXCOORD0.xy * _NoiseTex_ST.xy + _NoiseTex_ST.zw; + vs_TEXCOORD1.xy = in_TEXCOORD1.xy; + vs_TEXCOORD2.xyz = u_xlat0.xyz; + u_xlat2.xyz = u_xlat0.yyy * hlslcc_mtx4x4unity_MatrixV[1].xyz; + u_xlat2.xyz = hlslcc_mtx4x4unity_MatrixV[0].xyz * u_xlat0.xxx + u_xlat2.xyz; + u_xlat2.xyz = hlslcc_mtx4x4unity_MatrixV[2].xyz * u_xlat0.zzz + u_xlat2.xyz; + vs_TEXCOORD6.xyz = (-u_xlat0.xyz) + _WorldSpaceCameraPos.xyz; + vs_TEXCOORD3.xyz = u_xlat2.xyz + hlslcc_mtx4x4unity_MatrixV[3].xyz; + vs_TEXCOORD4 = u_xlat1; + u_xlat0.x = u_xlat1.y * _ProjectionParams.x; + u_xlat0.w = u_xlat0.x * 0.5; + u_xlat0.xz = u_xlat1.xw * vec2(0.5, 0.5); + vs_TEXCOORD5.zw = u_xlat1.zw; + vs_TEXCOORD5.xy = u_xlat0.zz + u_xlat0.xw; + u_xlat0.x = dot(in_NORMAL0.xyz, hlslcc_mtx4x4unity_WorldToObject[0].xyz); + u_xlat0.y = dot(in_NORMAL0.xyz, hlslcc_mtx4x4unity_WorldToObject[1].xyz); + u_xlat0.z = dot(in_NORMAL0.xyz, hlslcc_mtx4x4unity_WorldToObject[2].xyz); + u_xlat9 = dot(u_xlat0.xyz, u_xlat0.xyz); + u_xlat9 = max(u_xlat9, 1.17549435e-38); + u_xlat9 = inversesqrt(u_xlat9); + u_xlat0.xyz = vec3(u_xlat9) * u_xlat0.xyz; + u_xlat9 = dot(u_xlat0.xyz, u_xlat0.xyz); + u_xlat9 = inversesqrt(u_xlat9); + vs_TEXCOORD7.xyz = vec3(u_xlat9) * u_xlat0.xyz; + return; + } + + #endif + #ifdef FRAGMENT + #version 300 es + + precision highp float; + precision highp int; + #define HLSLCC_ENABLE_UNIFORM_BUFFERS 1 + #if HLSLCC_ENABLE_UNIFORM_BUFFERS + #define UNITY_UNIFORM + #else + #define UNITY_UNIFORM uniform + #endif + #define UNITY_SUPPORTS_UNIFORM_LOCATION 1 + #if UNITY_SUPPORTS_UNIFORM_LOCATION + #define UNITY_LOCATION(x) layout(location = x) + #define UNITY_BINDING(x) layout(binding = x, std140) + #else + #define UNITY_LOCATION(x) + #define UNITY_BINDING(x) layout(std140) + #endif + uniform vec4 _MainLightPosition; + uniform vec4 _MainLightColor; + uniform vec4 _Time; + uniform vec4 _ScreenParams; + uniform vec4 hlslcc_mtx4x4unity_MatrixVP[4]; + uniform vec4 _SunPos; + uniform float _Timecycle; + uniform float _HasSunMoon; + uniform float _LitRateTime; + uniform vec4 _SkyColor0; + uniform vec4 _SkyColor1; + uniform vec4 _SkyColor2; + uniform vec4 _HaloColor; + uniform float _SkyColorMTime; + uniform float _HaloRadius; + uniform float _SunRadius; + uniform float _DayNightTime; + uniform float _CloudyRate; + uniform vec4 _CloudParams; + uniform vec4 _CloudColor0; + uniform vec4 _CloudColor1; + uniform vec4 _CloudColor2; + uniform float _CloudColorMTime; + #if HLSLCC_ENABLE_UNIFORM_BUFFERS + UNITY_BINDING(0) uniform UnityPerMaterial { + #endif + UNITY_UNIFORM vec4 _NoiseTex_ST; + UNITY_UNIFORM float _MoonScale; + UNITY_UNIFORM vec4 _StarColor; + UNITY_UNIFORM vec4 _GalaxyCloudColor1; + UNITY_UNIFORM vec4 _GalaxyCloudColor2; + UNITY_UNIFORM float _CloudSpeed; + UNITY_UNIFORM float _CloudSize; + UNITY_UNIFORM float _CloudFadeDist; + UNITY_UNIFORM float _CloudFadeRate; + UNITY_UNIFORM float _OffsetDistance; + UNITY_UNIFORM float _BackLitStrength; + UNITY_UNIFORM float _EdgeLitPower; + UNITY_UNIFORM float _EdgeLitStrength; + #if HLSLCC_ENABLE_UNIFORM_BUFFERS + }; + #endif + UNITY_LOCATION(0) uniform mediump sampler2D _NoiseTex; + UNITY_LOCATION(1) uniform mediump sampler2D _MoonTex; + in highp vec2 vs_TEXCOORD0; + in highp vec2 vs_TEXCOORD1; + in highp vec4 vs_TEXCOORD4; + in highp vec4 vs_TEXCOORD5; + layout(location = 0) out highp vec4 SV_Target0; + vec3 u_xlat0; + vec4 u_xlat1; + bool u_xlatb1; + vec2 u_xlat2; + vec4 u_xlat3; + vec3 u_xlat4; + vec4 u_xlat5; + vec3 u_xlat6; + vec3 u_xlat7; + vec3 u_xlat9; + vec3 u_xlat10; + bool u_xlatb10; + vec2 u_xlat11; + vec2 u_xlat17; + bool u_xlatb17; + vec2 u_xlat18; + vec2 u_xlat19; + float u_xlat24; + bool u_xlatb24; + float u_xlat25; + float u_xlat26; + void main() + { + u_xlat0.xyz = log2(_SkyColor2.xyz); + u_xlat0.xyz = u_xlat0.xyz * vec3(2.20000005, 2.20000005, 2.20000005); + u_xlat0.xyz = exp2(u_xlat0.xyz); + u_xlat1.xyz = log2(_SkyColor1.xyz); + u_xlat1.xyz = u_xlat1.xyz * vec3(2.20000005, 2.20000005, 2.20000005); + u_xlat1.xyz = exp2(u_xlat1.xyz); + u_xlat0.xyz = u_xlat0.xyz + (-u_xlat1.xyz); + u_xlat24 = vs_TEXCOORD1.y + (-_SkyColorMTime); + u_xlat2.xy = (-vec2(_DayNightTime, _SkyColorMTime)) + vec2(1.0, 1.0); + u_xlat24 = u_xlat24 / u_xlat2.y; + u_xlat2.x = u_xlat2.x; + #ifdef UNITY_ADRENO_ES3 + u_xlat2.x = min(max(u_xlat2.x, 0.0), 1.0); + #else + u_xlat2.x = clamp(u_xlat2.x, 0.0, 1.0); + #endif + u_xlat0.xyz = vec3(u_xlat24) * u_xlat0.xyz + u_xlat1.xyz; + u_xlat10.xyz = log2(_SkyColor0.xyz); + u_xlat10.xyz = u_xlat10.xyz * vec3(2.20000005, 2.20000005, 2.20000005); + u_xlat10.xyz = exp2(u_xlat10.xyz); + u_xlat1.xyz = u_xlat1.xyz + (-u_xlat10.xyz); + u_xlat24 = vs_TEXCOORD1.y / _SkyColorMTime; + u_xlat1.xyz = vec3(u_xlat24) * u_xlat1.xyz + u_xlat10.xyz; + u_xlat0.xyz = u_xlat0.xyz + (-u_xlat1.xyz); + #ifdef UNITY_ADRENO_ES3 + u_xlatb24 = !!(vs_TEXCOORD1.y>=_SkyColorMTime); + #else + u_xlatb24 = vs_TEXCOORD1.y>=_SkyColorMTime; + #endif + u_xlat24 = u_xlatb24 ? 1.0 : float(0.0); + u_xlat0.xyz = vec3(u_xlat24) * u_xlat0.xyz + u_xlat1.xyz; + u_xlat1.xy = vec2(_Timecycle) * vec2(24.0, 288.0); + #ifdef UNITY_ADRENO_ES3 + u_xlatb24 = !!(u_xlat1.y>=(-u_xlat1.y)); + #else + u_xlatb24 = u_xlat1.y>=(-u_xlat1.y); + #endif + u_xlat9.xy = (bool(u_xlatb24)) ? vec2(12.0, 0.0833333358) : vec2(-12.0, -0.0833333358); + u_xlat24 = u_xlat9.y * u_xlat1.x; + u_xlat24 = fract(u_xlat24); + u_xlat24 = (-u_xlat9.x) * u_xlat24 + 6.0; + u_xlat24 = min(abs(u_xlat24), 1.0); + u_xlat1.xy = _MainLightPosition.xz * vec2(_OffsetDistance); + u_xlat1.xy = vec2(u_xlat24) * u_xlat1.xy; + u_xlat3 = vs_TEXCOORD0.xyxy * vec4(22.0, 22.0, 1.70000005, 1.70000005); + u_xlat17.xy = (-_CloudParams.xy) * vec2(_CloudSpeed) + u_xlat3.zw; + u_xlat24 = texture(_NoiseTex, u_xlat3.xy).y; + u_xlat10.xy = u_xlat17.xy * vec2(vec2(_CloudSize, _CloudSize)) + u_xlat1.xy; + u_xlat10.x = texture(_NoiseTex, u_xlat10.xy).x; + u_xlat18.xy = (-_CloudParams.xy) * vec2(_CloudSpeed) + vs_TEXCOORD0.xy; + u_xlat3.x = _CloudSize + 0.230000004; + u_xlat11.xy = u_xlat18.xy * u_xlat3.xx + u_xlat1.xy; + u_xlat11.x = texture(_NoiseTex, u_xlat11.xy).x; + u_xlat10.x = u_xlat10.x * u_xlat11.x; + u_xlat11.x = _CloudyRate * 2.5; + u_xlat10.x = u_xlat10.x * u_xlat11.x; + #ifdef UNITY_ADRENO_ES3 + u_xlat10.x = min(max(u_xlat10.x, 0.0), 1.0); + #else + u_xlat10.x = clamp(u_xlat10.x, 0.0, 1.0); + #endif + u_xlat19.xy = u_xlat18.xy * u_xlat3.xx + (-u_xlat1.xy); + u_xlat1.xy = u_xlat17.xy * vec2(vec2(_CloudSize, _CloudSize)) + (-u_xlat1.xy); + u_xlat17.xy = u_xlat17.xy * vec2(vec2(_CloudSize, _CloudSize)); + u_xlat17.x = texture(_NoiseTex, u_xlat17.xy).x; + u_xlat1.x = texture(_NoiseTex, u_xlat1.xy).x; + u_xlat9.xz = u_xlat18.xy * u_xlat3.xx; + u_xlat9.x = texture(_NoiseTex, u_xlat9.xz).x; + u_xlat9.x = u_xlat17.x * u_xlat9.x; + u_xlat9.x = u_xlat11.x * u_xlat9.x; + #ifdef UNITY_ADRENO_ES3 + u_xlat9.x = min(max(u_xlat9.x, 0.0), 1.0); + #else + u_xlat9.x = clamp(u_xlat9.x, 0.0, 1.0); + #endif + u_xlat17.x = texture(_NoiseTex, u_xlat19.xy).x; + u_xlat1.x = u_xlat1.x * u_xlat17.x; + u_xlat1.x = u_xlat11.x * u_xlat1.x; + #ifdef UNITY_ADRENO_ES3 + u_xlat1.x = min(max(u_xlat1.x, 0.0), 1.0); + #else + u_xlat1.x = clamp(u_xlat1.x, 0.0, 1.0); + #endif + u_xlat1.x = (-u_xlat1.x) + u_xlat10.x; + u_xlat10.xyz = hlslcc_mtx4x4unity_MatrixVP[1].xyw * _SunPos.yyy; + u_xlat10.xyz = hlslcc_mtx4x4unity_MatrixVP[0].xyw * _SunPos.xxx + u_xlat10.xyz; + u_xlat10.xyz = hlslcc_mtx4x4unity_MatrixVP[2].xyw * _SunPos.zzz + u_xlat10.xyz; + u_xlat10.xyz = u_xlat10.xyz + hlslcc_mtx4x4unity_MatrixVP[3].xyw; + u_xlat3.yz = u_xlat10.xy / u_xlat10.zz; + #ifdef UNITY_ADRENO_ES3 + u_xlatb17 = !!(u_xlat10.z>=0.0); + #else + u_xlatb17 = u_xlat10.z>=0.0; + #endif + u_xlat17.x = u_xlatb17 ? 1.0 : float(0.0); + u_xlat4.yz = vs_TEXCOORD4.xy / vs_TEXCOORD4.ww; + u_xlat25 = _ScreenParams.x / _ScreenParams.y; + u_xlat3.x = u_xlat25 * u_xlat3.y; + u_xlat4.x = u_xlat25 * u_xlat4.y; + u_xlat10.xy = (-u_xlat3.xz) + u_xlat4.xz; + u_xlat10.x = dot(u_xlat10.xy, u_xlat10.xy); + u_xlat10.x = sqrt(u_xlat10.x); + u_xlat10.xy = u_xlat10.xx / vec2(_HaloRadius, _SunRadius); + u_xlat10.xy = (-u_xlat10.xy) + vec2(1.0, 1.0); + #ifdef UNITY_ADRENO_ES3 + u_xlat10.xy = min(max(u_xlat10.xy, 0.0), 1.0); + #else + u_xlat10.xy = clamp(u_xlat10.xy, 0.0, 1.0); + #endif + u_xlat10.x = u_xlat17.x * u_xlat10.x; + u_xlat18.x = u_xlat10.y + -0.5; + u_xlat18.x = u_xlat18.x * 9.99999809; + #ifdef UNITY_ADRENO_ES3 + u_xlat18.x = min(max(u_xlat18.x, 0.0), 1.0); + #else + u_xlat18.x = clamp(u_xlat18.x, 0.0, 1.0); + #endif + u_xlat26 = u_xlat10.x * u_xlat10.x; + u_xlat26 = u_xlat26 * u_xlat26; + u_xlat26 = u_xlat26 * u_xlat10.x; + u_xlat10.x = u_xlat26 * 3.0 + u_xlat10.x; + u_xlat26 = _CloudyRate + -0.5; + #ifdef UNITY_ADRENO_ES3 + u_xlat26 = min(max(u_xlat26, 0.0), 1.0); + #else + u_xlat26 = clamp(u_xlat26, 0.0, 1.0); + #endif + u_xlat26 = u_xlat26 + 0.5; + u_xlat3.xw = (-vec2(u_xlat26)) + vec2(1.5, 1.0); + u_xlat26 = u_xlat10.x * u_xlat3.x + 0.600000024; + u_xlat10.x = u_xlat10.x * u_xlat3.x; + u_xlat26 = min(u_xlat26, 1.0); + u_xlat3.x = (-u_xlat9.x) + 1.0; + u_xlat3.x = log2(u_xlat3.x); + u_xlat3.x = u_xlat3.x * _EdgeLitPower; + u_xlat3.x = exp2(u_xlat3.x); + u_xlat3.x = u_xlat3.x * _EdgeLitStrength; + u_xlat1.x = u_xlat3.x * u_xlat26 + u_xlat1.x; + #ifdef UNITY_ADRENO_ES3 + u_xlat1.x = min(max(u_xlat1.x, 0.0), 1.0); + #else + u_xlat1.x = clamp(u_xlat1.x, 0.0, 1.0); + #endif + u_xlat26 = u_xlat1.x + (-_CloudColorMTime); + u_xlat3.x = (-_CloudColorMTime) + 1.0; + u_xlat26 = u_xlat26 / u_xlat3.x; + u_xlat4.xyz = log2(_CloudColor2.xyz); + u_xlat4.xyz = u_xlat4.xyz * vec3(2.20000005, 2.20000005, 2.20000005); + u_xlat4.xyz = exp2(u_xlat4.xyz); + u_xlat5.xyz = log2(_CloudColor1.xyz); + u_xlat5.xyz = u_xlat5.xyz * vec3(2.20000005, 2.20000005, 2.20000005); + u_xlat5.xyz = exp2(u_xlat5.xyz); + u_xlat6.xyz = u_xlat4.xyz + (-u_xlat5.xyz); + u_xlat4.xyz = u_xlat10.xxx * u_xlat4.xyz; + u_xlat4.xyz = u_xlat1.xxx * u_xlat4.xyz; + u_xlat6.xyz = vec3(u_xlat26) * u_xlat6.xyz + u_xlat5.xyz; + u_xlat7.xyz = log2(_CloudColor0.xyz); + u_xlat7.xyz = u_xlat7.xyz * vec3(2.20000005, 2.20000005, 2.20000005); + u_xlat7.xyz = exp2(u_xlat7.xyz); + u_xlat5.xyz = u_xlat5.xyz + (-u_xlat7.xyz); + u_xlat26 = u_xlat1.x / _CloudColorMTime; + #ifdef UNITY_ADRENO_ES3 + u_xlatb1 = !!(u_xlat1.x>=_CloudColorMTime); + #else + u_xlatb1 = u_xlat1.x>=_CloudColorMTime; + #endif + u_xlat1.x = u_xlatb1 ? 1.0 : float(0.0); + u_xlat5.xyz = vec3(u_xlat26) * u_xlat5.xyz + u_xlat7.xyz; + u_xlat6.xyz = (-u_xlat5.xyz) + u_xlat6.xyz; + u_xlat5.xyz = u_xlat1.xxx * u_xlat6.xyz + u_xlat5.xyz; + u_xlat5.xyz = (-u_xlat0.xyz) + u_xlat5.xyz; + u_xlat6.xy = vs_TEXCOORD0.xy + vec2(-0.5, -0.5); + u_xlat1.x = dot(u_xlat6.xy, u_xlat6.xy); + u_xlat1.x = sqrt(u_xlat1.x); + u_xlat26 = (-u_xlat1.x) * 1.89999998 + 1.0; + u_xlat6.xy = u_xlat1.xx * vec2(1.89999998, 0.949999988); + u_xlat1.x = u_xlat26 * 0.400000006; + u_xlat5.xyz = u_xlat1.xxx * u_xlat5.xyz + u_xlat0.xyz; + u_xlat4.xyz = u_xlat4.xyz * vec3(vec3(_BackLitStrength, _BackLitStrength, _BackLitStrength)) + u_xlat5.xyz; + #ifdef UNITY_ADRENO_ES3 + u_xlat4.xyz = min(max(u_xlat4.xyz, 0.0), 1.0); + #else + u_xlat4.xyz = clamp(u_xlat4.xyz, 0.0, 1.0); + #endif + u_xlat3.x = u_xlat3.y * u_xlat25 + u_xlat25; + u_xlat3.y = u_xlat3.z + 1.0; + u_xlat3.xy = u_xlat3.xy * vec2(_MoonScale); + u_xlat3.xy = u_xlat3.xy * vec2(0.5, 0.5); + u_xlat5.x = u_xlat25 * vs_TEXCOORD5.x; + u_xlat5.y = vs_TEXCOORD5.y; + u_xlat1.xw = u_xlat5.xy / vs_TEXCOORD5.ww; + u_xlat26 = 0.5 / _MoonScale; + u_xlat1.xw = u_xlat1.xw + vec2(u_xlat26); + u_xlat1.xw = u_xlat1.xw * vec2(_MoonScale) + (-u_xlat3.xy); + u_xlat1.xw = texture(_MoonTex, u_xlat1.xw).xy; + u_xlat25 = (-u_xlat1.x) + u_xlat1.w; + u_xlat1.x = _CloudyRate * u_xlat25 + u_xlat1.x; + u_xlat25 = (-_HasSunMoon) + 1.0; + u_xlat1.x = u_xlat25 * u_xlat1.x; + u_xlat1.x = u_xlat17.x * u_xlat1.x; + u_xlat25 = u_xlat9.x * 1.5 + u_xlat6.y; + u_xlat9.x = log2(u_xlat9.x); + u_xlat9.x = u_xlat9.x * 1.5; + u_xlat9.x = exp2(u_xlat9.x); + u_xlat9.x = u_xlat9.x * 3.0; + u_xlat9.x = min(u_xlat9.x, 1.0); + u_xlat9.x = u_xlat9.x + -0.600000024; + u_xlat9.x = u_xlat9.x * 2.50000024; + u_xlat9.x = max(u_xlat9.x, 0.0); + u_xlat26 = u_xlat25 * u_xlat25; + u_xlat26 = u_xlat26 * u_xlat26; + u_xlat3.x = log2(u_xlat6.x); + u_xlat11.x = u_xlat6.x * u_xlat6.x; + u_xlat11.x = (-u_xlat11.x) * 1.29999995 + 1.0; + u_xlat3.x = u_xlat3.x * 10.0; + u_xlat3.x = exp2(u_xlat3.x); + u_xlat25 = u_xlat25 * u_xlat26 + u_xlat3.x; + u_xlat25 = min(u_xlat25, 1.0); + u_xlat1.x = u_xlat25 * (-u_xlat1.x) + u_xlat1.x; + u_xlat26 = u_xlat18.x * -2.0 + 3.0; + u_xlat18.x = u_xlat18.x * u_xlat18.x; + u_xlat18.x = u_xlat18.x * u_xlat26; + u_xlat26 = (-_CloudyRate) + 1.0; + u_xlat18.x = u_xlat26 * u_xlat18.x; + u_xlat26 = u_xlat26; + #ifdef UNITY_ADRENO_ES3 + u_xlat26 = min(max(u_xlat26, 0.0), 1.0); + #else + u_xlat26 = clamp(u_xlat26, 0.0, 1.0); + #endif + u_xlat2.x = u_xlat26 * u_xlat2.x; + u_xlat18.x = inversesqrt(u_xlat18.x); + u_xlat18.x = float(1.0) / u_xlat18.x; + u_xlat5.xyz = u_xlat18.xxx * _MainLightColor.xyz; + u_xlat5.xyz = u_xlat5.xyz * vec3(10.0, 10.0, 10.0); + u_xlat5.xyz = u_xlat5.xyz * vec3(vec3(_HasSunMoon, _HasSunMoon, _HasSunMoon)); + u_xlat5.xyz = u_xlat17.xxx * u_xlat5.xyz; + u_xlat5.xyz = vec3(u_xlat25) * (-u_xlat5.xyz) + u_xlat5.xyz; + u_xlat1.xzw = u_xlat1.xxx + u_xlat5.xyz; + u_xlat5.xyz = log2(_HaloColor.xyz); + u_xlat5.xyz = u_xlat5.xyz * vec3(2.20000005, 2.20000005, 2.20000005); + u_xlat5.xyz = exp2(u_xlat5.xyz); + u_xlat10.xyz = u_xlat10.xxx * u_xlat5.xyz; + u_xlat0.xyz = u_xlat10.xyz * u_xlat3.www + u_xlat0.xyz; + #ifdef UNITY_ADRENO_ES3 + u_xlatb10 = !!(_LitRateTime>=0.899999976); + #else + u_xlatb10 = _LitRateTime>=0.899999976; + #endif + u_xlat10.x = u_xlatb10 ? 1.0 : float(0.0); + u_xlat0.xyz = u_xlat1.xzw * u_xlat10.xxx + u_xlat0.xyz; + u_xlat5 = vs_TEXCOORD0.xyxy * vec4(7.0, 7.0, 35.0, 35.0); + u_xlat1.x = texture(_NoiseTex, u_xlat5.zw).y; + u_xlat17.x = texture(_NoiseTex, u_xlat5.xy).x; + u_xlat24 = u_xlat24 + u_xlat1.x; + u_xlat24 = u_xlat17.x * u_xlat24; + u_xlat24 = u_xlat24 * u_xlat24; + u_xlat1.xzw = vec3(u_xlat24) * _StarColor.xyz; + u_xlat1.xzw = u_xlat1.xzw * vec3(4.0, 4.0, 4.0); + u_xlat0.xyz = u_xlat1.xzw * u_xlat2.xxx + u_xlat0.xyz; + u_xlat24 = u_xlat0.y + u_xlat0.x; + u_xlat24 = u_xlat0.z + u_xlat24; + #ifdef UNITY_ADRENO_ES3 + u_xlat24 = min(max(u_xlat24, 0.0), 1.0); + #else + u_xlat24 = clamp(u_xlat24, 0.0, 1.0); + #endif + #ifdef UNITY_ADRENO_ES3 + u_xlatb1 = !!(_Time.x>=(-_Time.x)); + #else + u_xlatb1 = _Time.x>=(-_Time.x); + #endif + u_xlat1.x = (u_xlatb1) ? 1.0 : -1.0; + u_xlat17.x = u_xlat1.x * _Time.x; + u_xlat17.x = fract(u_xlat17.x); + u_xlat1.x = u_xlat17.x * u_xlat1.x; + u_xlat17.x = vs_TEXCOORD5.y + vs_TEXCOORD5.x; + u_xlat17.x = u_xlat17.x * 10000.0; + u_xlat1.x = u_xlat1.x * u_xlat17.x; + u_xlat1.x = sin(u_xlat1.x); + u_xlat1.x = u_xlat1.x * 2.0 + -0.5; + u_xlat1.x = u_xlat1.x * 0.00392156886; + u_xlat0.xyz = u_xlat1.xxx * vec3(u_xlat24) + u_xlat0.xyz; + u_xlat1.xzw = (-u_xlat0.xyz) + u_xlat4.xyz; + u_xlat24 = u_xlat9.x * -2.0 + 3.0; + u_xlat9.x = u_xlat9.x * u_xlat9.x; + u_xlat24 = u_xlat24 * u_xlat9.x; + u_xlat24 = u_xlat11.x * u_xlat24; + #ifdef UNITY_ADRENO_ES3 + u_xlat24 = min(max(u_xlat24, 0.0), 1.0); + #else + u_xlat24 = clamp(u_xlat24, 0.0, 1.0); + #endif + SV_Target0.xyz = vec3(u_xlat24) * u_xlat1.xzw + u_xlat0.xyz; + SV_Target0.w = 1.0; + return; + } + + #endif + " + } + } + Program "fp" + { + SubProgram "gles3 " + { + "" + } + } + } + } + Fallback "Hidden/InternalErrorShader" +} \ No newline at end of file