First Commit

Voltes · Feb 10, 2017 · d33ddb4 · d33ddb4
commit d33ddb4
Show file tree

Hide file tree

Showing 807 changed files with 16,668 additions and 0 deletions.
diff --git a/Assets/Resources.meta b/Assets/Resources.meta
diff --git a/Assets/Resources/FakeVolumetricLightMat.mat b/Assets/Resources/FakeVolumetricLightMat.mat
diff --git a/Assets/Resources/FakeVolumetricLightMat.mat.meta b/Assets/Resources/FakeVolumetricLightMat.mat.meta
diff --git a/Assets/Resources/FakeVolumetricLightShader.shader b/Assets/Resources/FakeVolumetricLightShader.shader
@@ -0,0 +1,106 @@
+// Upgrade NOTE: replaced '_Object2World' with 'unity_ObjectToWorld'
+
+ Shader "Custom/FakeVolumetricLightShader" {
+ Properties {
+     _Fresnel("Fresnel", Range (0., 10.)) = 1.
+     _AlphaOffset("Alpha Offset", Range(0., 1.)) = 1.
+     _NoiseSpeed("Noise Speed", Range(0., 1.)) = .5
+     _Ambient("Ambient", Range(0., 1.)) = .3
+     _Intensity("Intensity", Range(0., 1.5)) = .2
+     _Fade("Fade", Range(1., 10.)) = 1.
+     _Wind("Wind", Range(0., 1.)) = .1
+ }
+
+ SubShader {
+	 // set render type for transparency
+	 // transparent will draw after all the opaque geometry drawn 
+     Tags {"RenderType" = "Transparent" "Queue" = "Transparent"} 
+     LOD 100 // set level of detail minimum
+
+     ZWrite Off // we don't need depth buffer due to transparency
+     Blend SrcAlpha One // blend mode - additive with transparency
+
+     Pass {  
+         CGPROGRAM
+             #pragma vertex vert
+             #pragma fragment frag
+
+             #include "UnityCG.cginc"
+             #include "classicNoise3d.cginc" // import noise functions
+
+             struct appdata_t {
+                 float4 vertex : POSITION;
+                 float3 normal : NORMAL;
+                 float2 uv : TEXCOORD0;
+             };
+
+             struct v2f {
+	             float4 vertex : SV_POSITION;
+                 float3 worldPos : TEXCOORD1;
+                 half2 uv : TEXCOORD0;
+                 float3 normal : NORMAL;
+             };
+
+             float _Fresnel;
+             float _AlphaOffset;
+             float _NoiseSpeed;
+             float _Ambient;
+             float _Intensity;
+             float _Fade;
+             float _Wind;
+
+             v2f vert (appdata_t v){
+				v2f o;
+
+				// move model's vertices to screen position 
+				float noise = _Wind * cnoise(v.normal + _Time.y);
+				float4 nv = float4(v.vertex.xyz + noise * v.normal, v.vertex.w);
+				o.vertex = UnityObjectToClipPos(nv);
+				// get vertex's world position 
+				o.worldPos = mul(unity_ObjectToWorld, v.vertex).xyz; 
+				// get world mormal
+				o.normal = UnityObjectToWorldNormal(v.normal);
+				o.uv = v.uv;
+
+				return o;
+             }
+
+             fixed4 frag (v2f i) : SV_Target{
+				float nu = (i.uv.x < .5)? i.uv.x : (1. - i.uv.x);
+				nu = pow(nu, 2.);
+				float2 n_uv = float2(nu, i.uv.y);
+
+				float n_a = cnoise(float3(n_uv * 5., 1.) + _Time.y * _NoiseSpeed * -1.) * _Intensity + _Ambient; 
+				float n_b = cnoise(float3(n_uv * 10., 1.) + _Time.y * _NoiseSpeed * -1.) * .9; 
+				float n_c = cnoise(float3(n_uv * 20., 1.) + _Time.y * _NoiseSpeed * -2.) * .9; 
+				float n_d = pow(cnoise(float3(n_uv * 30., 1.) + _Time.y * _NoiseSpeed * -2.), 2.) * .9; 
+				float noise = n_a + n_b + n_c + n_d;
+				noise = (noise < 0.)? 0. : noise;
+				float4 col = float4(noise, noise, noise, 1.);
+
+                 // get vertices directions toward world camera
+                 // *note that UnityWorldSpaceViewDir return vertices' direction (not cam's direction)
+                 // - float3 WorldSpaceViewDir (float4 v)	
+                 // - Returns world space direction (not normalized) from given object space vertex position 
+                 // - towards the camera.
+                 // - https://docs.unity3d.com/Manual/SL-BuiltinFunctions.html
+				 half3 viewDir = normalize(UnityWorldSpaceViewDir(i.worldPos));
+				 // get raycast between vertice's dir and normal
+				 // discard vertices facing opposite way with view direction 
+				 // if the value is closer to 1 then that means the vertex is facing more towards the camera
+                 float raycast = saturate(dot(viewDir, i.normal));
+                 // make extreme distribution
+                 float fresnel = pow(raycast, _Fresnel);
+
+                 // fade out
+				 float fade = saturate(pow(1. - i.uv.y, _Fade));
+
+			     col.a *= fresnel * _AlphaOffset * fade;
+
+                 return col;
+             }
+         ENDCG
+		}
+	}
+}
+
diff --git a/Assets/Resources/FakeVolumetricLightShader.shader.meta b/Assets/Resources/FakeVolumetricLightShader.shader.meta
diff --git a/Assets/Resources/classicNoise3d.cginc b/Assets/Resources/classicNoise3d.cginc
@@ -0,0 +1,194 @@
+//
+// Noise Shader Library for Unity - https://github.com/keijiro/NoiseShader
+//
+// Original work (webgl-noise) Copyright (C) 2011 Stefan Gustavson
+// Translation and modification was made by Keijiro Takahashi.
+//
+// This shader is based on the webgl-noise GLSL shader. For further details
+// of the original shader, please see the following description from the
+// original source code.
+//
+
+//
+// GLSL textureless classic 3D noise "cnoise",
+// with an RSL-style periodic variant "pnoise".
+// Author:  Stefan Gustavson (stefan.gustavson@liu.se)
+// Version: 2011-10-11
+//
+// Many thanks to Ian McEwan of Ashima Arts for the
+// ideas for permutation and gradient selection.
+//
+// Copyright (c) 2011 Stefan Gustavson. All rights reserved.
+// Distributed under the MIT license. See LICENSE file.
+// https://github.com/ashima/webgl-noise
+//
+
+float3 mod(float3 x, float3 y)
+{
+  return x - y * floor(x / y);
+}
+
+float3 mod289(float3 x)
+{
+  return x - floor(x / 289.0) * 289.0;
+}
+
+float4 mod289(float4 x)
+{
+  return x - floor(x / 289.0) * 289.0;
+}
+
+float4 permute(float4 x)
+{
+  return mod289(((x*34.0)+1.0)*x);
+}
+
+float4 taylorInvSqrt(float4 r)
+{
+  return (float4)1.79284291400159 - r * 0.85373472095314;
+}
+
+float3 fade(float3 t) {
+  return t*t*t*(t*(t*6.0-15.0)+10.0);
+}
+
+// Classic Perlin noise
+float cnoise(float3 P)
+{
+  float3 Pi0 = floor(P); // Integer part for indexing
+  float3 Pi1 = Pi0 + (float3)1.0; // Integer part + 1
+  Pi0 = mod289(Pi0);
+  Pi1 = mod289(Pi1);
+  float3 Pf0 = frac(P); // Fractional part for interpolation
+  float3 Pf1 = Pf0 - (float3)1.0; // Fractional part - 1.0
+  float4 ix = float4(Pi0.x, Pi1.x, Pi0.x, Pi1.x);
+  float4 iy = float4(Pi0.y, Pi0.y, Pi1.y, Pi1.y);
+  float4 iz0 = (float4)Pi0.z;
+  float4 iz1 = (float4)Pi1.z;
+
+  float4 ixy = permute(permute(ix) + iy);
+  float4 ixy0 = permute(ixy + iz0);
+  float4 ixy1 = permute(ixy + iz1);
+
+  float4 gx0 = ixy0 / 7.0;
+  float4 gy0 = frac(floor(gx0) / 7.0) - 0.5;
+  gx0 = frac(gx0);
+  float4 gz0 = (float4)0.5 - abs(gx0) - abs(gy0);
+  float4 sz0 = step(gz0, (float4)0.0);
+  gx0 -= sz0 * (step((float4)0.0, gx0) - 0.5);
+  gy0 -= sz0 * (step((float4)0.0, gy0) - 0.5);
+
+  float4 gx1 = ixy1 / 7.0;
+  float4 gy1 = frac(floor(gx1) / 7.0) - 0.5;
+  gx1 = frac(gx1);
+  float4 gz1 = (float4)0.5 - abs(gx1) - abs(gy1);
+  float4 sz1 = step(gz1, (float4)0.0);
+  gx1 -= sz1 * (step((float4)0.0, gx1) - 0.5);
+  gy1 -= sz1 * (step((float4)0.0, gy1) - 0.5);
+
+  float3 g000 = float3(gx0.x,gy0.x,gz0.x);
+  float3 g100 = float3(gx0.y,gy0.y,gz0.y);
+  float3 g010 = float3(gx0.z,gy0.z,gz0.z);
+  float3 g110 = float3(gx0.w,gy0.w,gz0.w);
+  float3 g001 = float3(gx1.x,gy1.x,gz1.x);
+  float3 g101 = float3(gx1.y,gy1.y,gz1.y);
+  float3 g011 = float3(gx1.z,gy1.z,gz1.z);
+  float3 g111 = float3(gx1.w,gy1.w,gz1.w);
+
+  float4 norm0 = taylorInvSqrt(float4(dot(g000, g000), dot(g010, g010), dot(g100, g100), dot(g110, g110)));
+  g000 *= norm0.x;
+  g010 *= norm0.y;
+  g100 *= norm0.z;
+  g110 *= norm0.w;
+
+  float4 norm1 = taylorInvSqrt(float4(dot(g001, g001), dot(g011, g011), dot(g101, g101), dot(g111, g111)));
+  g001 *= norm1.x;
+  g011 *= norm1.y;
+  g101 *= norm1.z;
+  g111 *= norm1.w;
+
+  float n000 = dot(g000, Pf0);
+  float n100 = dot(g100, float3(Pf1.x, Pf0.y, Pf0.z));
+  float n010 = dot(g010, float3(Pf0.x, Pf1.y, Pf0.z));
+  float n110 = dot(g110, float3(Pf1.x, Pf1.y, Pf0.z));
+  float n001 = dot(g001, float3(Pf0.x, Pf0.y, Pf1.z));
+  float n101 = dot(g101, float3(Pf1.x, Pf0.y, Pf1.z));
+  float n011 = dot(g011, float3(Pf0.x, Pf1.y, Pf1.z));
+  float n111 = dot(g111, Pf1);
+
+  float3 fade_xyz = fade(Pf0);
+  float4 n_z = lerp(float4(n000, n100, n010, n110), float4(n001, n101, n011, n111), fade_xyz.z);
+  float2 n_yz = lerp(n_z.xy, n_z.zw, fade_xyz.y);
+  float n_xyz = lerp(n_yz.x, n_yz.y, fade_xyz.x);
+  return 2.2 * n_xyz;
+}
+
+// Classic Perlin noise, periodic variant
+float pnoise(float3 P, float3 rep)
+{
+  float3 Pi0 = mod(floor(P), rep); // Integer part, modulo period
+  float3 Pi1 = mod(Pi0 + (float3)1.0, rep); // Integer part + 1, mod period
+  Pi0 = mod289(Pi0);
+  Pi1 = mod289(Pi1);
+  float3 Pf0 = frac(P); // Fractional part for interpolation
+  float3 Pf1 = Pf0 - (float3)1.0; // Fractional part - 1.0
+  float4 ix = float4(Pi0.x, Pi1.x, Pi0.x, Pi1.x);
+  float4 iy = float4(Pi0.y, Pi0.y, Pi1.y, Pi1.y);
+  float4 iz0 = (float4)Pi0.z;
+  float4 iz1 = (float4)Pi1.z;
+
+  float4 ixy = permute(permute(ix) + iy);
+  float4 ixy0 = permute(ixy + iz0);
+  float4 ixy1 = permute(ixy + iz1);
+
+  float4 gx0 = ixy0 / 7.0;
+  float4 gy0 = frac(floor(gx0) / 7.0) - 0.5;
+  gx0 = frac(gx0);
+  float4 gz0 = (float4)0.5 - abs(gx0) - abs(gy0);
+  float4 sz0 = step(gz0, (float4)0.0);
+  gx0 -= sz0 * (step((float4)0.0, gx0) - 0.5);
+  gy0 -= sz0 * (step((float4)0.0, gy0) - 0.5);
+
+  float4 gx1 = ixy1 / 7.0;
+  float4 gy1 = frac(floor(gx1) / 7.0) - 0.5;
+  gx1 = frac(gx1);
+  float4 gz1 = (float4)0.5 - abs(gx1) - abs(gy1);
+  float4 sz1 = step(gz1, (float4)0.0);
+  gx1 -= sz1 * (step((float4)0.0, gx1) - 0.5);
+  gy1 -= sz1 * (step((float4)0.0, gy1) - 0.5);
+
+  float3 g000 = float3(gx0.x,gy0.x,gz0.x);
+  float3 g100 = float3(gx0.y,gy0.y,gz0.y);
+  float3 g010 = float3(gx0.z,gy0.z,gz0.z);
+  float3 g110 = float3(gx0.w,gy0.w,gz0.w);
+  float3 g001 = float3(gx1.x,gy1.x,gz1.x);
+  float3 g101 = float3(gx1.y,gy1.y,gz1.y);
+  float3 g011 = float3(gx1.z,gy1.z,gz1.z);
+  float3 g111 = float3(gx1.w,gy1.w,gz1.w);
+
+  float4 norm0 = taylorInvSqrt(float4(dot(g000, g000), dot(g010, g010), dot(g100, g100), dot(g110, g110)));
+  g000 *= norm0.x;
+  g010 *= norm0.y;
+  g100 *= norm0.z;
+  g110 *= norm0.w;
+  float4 norm1 = taylorInvSqrt(float4(dot(g001, g001), dot(g011, g011), dot(g101, g101), dot(g111, g111)));
+  g001 *= norm1.x;
+  g011 *= norm1.y;
+  g101 *= norm1.z;
+  g111 *= norm1.w;
+
+  float n000 = dot(g000, Pf0);
+  float n100 = dot(g100, float3(Pf1.x, Pf0.y, Pf0.z));
+  float n010 = dot(g010, float3(Pf0.x, Pf1.y, Pf0.z));
+  float n110 = dot(g110, float3(Pf1.x, Pf1.y, Pf0.z));
+  float n001 = dot(g001, float3(Pf0.x, Pf0.y, Pf1.z));
+  float n101 = dot(g101, float3(Pf1.x, Pf0.y, Pf1.z));
+  float n011 = dot(g011, float3(Pf0.x, Pf1.y, Pf1.z));
+  float n111 = dot(g111, Pf1);
+
+  float3 fade_xyz = fade(Pf0);
+  float4 n_z = lerp(float4(n000, n100, n010, n110), float4(n001, n101, n011, n111), fade_xyz.z);
+  float2 n_yz = lerp(n_z.xy, n_z.zw, fade_xyz.y);
+  float n_xyz = lerp(n_yz.x, n_yz.y, fade_xyz.x);
+  return 2.2 * n_xyz;
+}
diff --git a/Assets/Resources/classicNoise3d.cginc.meta b/Assets/Resources/classicNoise3d.cginc.meta
diff --git a/Assets/Resources/lightBulb.mat b/Assets/Resources/lightBulb.mat
diff --git a/Assets/Resources/lightBulb.mat.meta b/Assets/Resources/lightBulb.mat.meta