Added the project.

Assets/TubeLight/Shaders/TubeLight.cginc

@@ -0,0 +1,189 @@
+// Based on 'Real Shading in Unreal Engine 4'
+// http://blog.selfshadow.com/publications/s2013-shading-course/#course_content
+
+#include "TubeLightAttenuation.cginc"
+
+#ifndef SHADOW_PLANES
+#define SHADOW_PLANES 1
+#endif
+
+#if SHADOW_PLANES
+#include "TubeLightShadowPlanes.cginc"
+#endif
+
+#define SHARP_EDGE_FIX 1
+
+void SphereLightToPointLight(float3 pos, float3 lightPos, float3 eyeVec, half3 normal, float sphereRad, half rangeSqInv, inout UnityLight light, out half lightDist)
+{
+	half3 viewDir = -eyeVec;
+	half3 r = reflect (viewDir, normal);
+
+	float3 L = lightPos - pos;
+	float3 centerToRay	= dot (L, r) * r - L;
+	float3 closestPoint	= L + centerToRay * saturate(sphereRad / length(centerToRay));
+
+	lightDist = length(closestPoint);
+	light.dir = closestPoint / lightDist;
+
+	half distLSq = dot(L, L);
+	light.ndotl = saturate(dot(normal, L/sqrt(distLSq)));
+
+	float distNorm = distLSq * rangeSqInv;
+	float atten = AttenuationToZero(distNorm);
+	light.color *= atten;
+}
+
+void TubeLightToPointLight(float3 pos, float3 tubeStart, float3 tubeEnd, float3 normal, float tubeRad, float rangeSqInv, float3 representativeDir, float3 lightColor, out float3 outLightColor, out float3 outLightDir, out float outNdotL, out half outLightDist)
+{
+	half3 N = normal;
+	float3 L0 = tubeStart - pos;
+	float3 L1 = tubeEnd - pos;
+	float L0dotL0 = dot(L0, L0);
+	float distL0 = sqrt(L0dotL0);
+	float distL1 = length(L1);
+	
+	float NdotL0 = dot(L0, N) / (2.0 * distL0);
+	float NdotL1 = dot(L1, N) / (2.0 * distL1);
+	outNdotL = saturate(NdotL0 + NdotL1);
+	
+	float3 Ldir = L1 - L0;
+	float RepdotL0 = dot(representativeDir, L0);
+	float RepdotLdir = dot(representativeDir, Ldir);
+	float L0dotLdir	= dot(L0, Ldir);
+	float LdirdotLdir = dot(Ldir, Ldir);
+	float distLdir = sqrt(LdirdotLdir);
+	
+#if SHARP_EDGE_FIX
+	// There's a very visible discontinuity if we just take the closest distance to ray,
+	// as the original paper suggests. This is an attempt to fix it, but it gets slightly more expensive and
+	// has its own artifact, although this time at least C0 smooth.
+
+	// Smallest angle to ray
+	float t = (L0dotLdir * RepdotL0 - L0dotL0 * RepdotLdir) / (L0dotLdir * RepdotLdir - LdirdotLdir * RepdotL0);
+	t = saturate(t);
+
+	// As representativeDir becomes parallel (well, in some plane) to Ldir and then points away, t flips from 0 to 1 (or vv) and a discontinuity shows up.
+	// Counteract by detecting that relative angle/position and flip t. The discontinuity in t moves to the back side.
+	float3 L0xLdir = cross(L0, Ldir);
+	float3 LdirxR = cross(Ldir, representativeDir);
+	float RepAtLdir = dot(L0xLdir, LdirxR);
+
+	// RepAtLdir is negative if R points away from Ldir.
+	// TODO: check if lerp below is indeed cheaper.
+	// if (RepAtLdir < 0)
+	// 	t = 1 - t;
+	t = lerp(1 - t, t, step(0, RepAtLdir));
+
+#else
+	// Original by Karis
+	// Closest distance to ray
+	float t = (RepdotL0 * RepdotLdir - L0dotLdir) / (distLdir * distLdir - RepdotLdir * RepdotLdir);
+	t = saturate(t);
+
+#endif
+
+	float3 closestPoint = L0 + Ldir * t;
+	float3 centerToRay = dot(closestPoint, representativeDir) * representativeDir - closestPoint;
+
+	closestPoint = closestPoint + centerToRay * saturate(tubeRad / length(centerToRay));
+
+	outLightDist = length(closestPoint);
+	outLightDir = closestPoint / outLightDist;
+
+	float distNorm = 0.5f * (distL0 * distL1 + dot(L0, L1)) * rangeSqInv;
+	outLightColor = lightColor * AttenuationToZero(distNorm);
+}
+
+void TubeLightToPointLight(float3 pos, float3 tubeStart, float3 tubeEnd, float3 eyeVec, float3 normal, float tubeRad, float rangeSqInv, float3 lightColor, out float3 outLightColor, out float3 outLightDir, out float outNdotL, out half outLightDist)
+{
+	half3 viewDir = -eyeVec;
+	half3 representativeDir = reflect (viewDir, normal);
+
+	TubeLightToPointLight(pos, tubeStart, tubeEnd, normal, tubeRad, rangeSqInv, representativeDir, lightColor, outLightColor, outLightDir, outNdotL, outLightDist);
+}
+
+inline half GGXTerm_Area (half NdotH, half roughness, half lightDist, half lightRadius)
+{
+	half a = roughness * roughness;
+	half a2 = a * a;
+	half d = NdotH * NdotH * (a2 - 1.f) + 1.f;
+	d = max(d, 0.000001);
+
+	half aP = saturate( lightRadius / (lightDist*2.0) + a);
+	half aP2 = aP * aP;
+
+	return a2 * a2 / (UNITY_PI * d * d * aP2);
+}
+
+half4 BRDF1_Unity_PBS_Area (half3 diffColor, half3 specColor, half oneMinusReflectivity, half oneMinusRoughness,
+	half3 normal, half3 viewDir,
+	UnityLight light, UnityIndirect gi, half lightDist, half lightRadius)
+{
+	half roughness = 1-oneMinusRoughness;
+	half3 halfDir = Unity_SafeNormalize (light.dir + viewDir);
+
+	half nl = light.ndotl;
+	half nh = BlinnTerm (normal, halfDir);
+	half nv = DotClamped (normal, viewDir);
+	half lv = DotClamped (light.dir, viewDir);
+	half lh = DotClamped (light.dir, halfDir);
+
+	half V = SmithGGXVisibilityTerm (nl, nv, roughness);
+	half D = GGXTerm_Area (nh, roughness, lightDist, lightRadius);
+
+	half nlPow5 = Pow5 (1-nl);
+	half nvPow5 = Pow5 (1-nv);
+	half Fd90 = 0.5 + 2 * lh * lh * roughness;
+	half disneyDiffuse = (1 + (Fd90-1) * nlPow5) * (1 + (Fd90-1) * nvPow5);
+	
+	// HACK: theoretically we should divide by Pi diffuseTerm and not multiply specularTerm!
+	// BUT 1) that will make shader look significantly darker than Legacy ones
+	// and 2) on engine side "Non-important" lights have to be divided by Pi to in cases when they are injected into ambient SH
+	// NOTE: multiplication by Pi is part of single constant together with 1/4 now
+
+	half specularTerm = (V * D) * (UNITY_PI/4); // Torrance-Sparrow model, Fresnel is applied later (for optimization reasons)
+	if (IsGammaSpace())
+		specularTerm = sqrt(max(1e-4h, specularTerm));
+	specularTerm = max(0, specularTerm * nl);
+	half diffuseTerm = disneyDiffuse * nl;
+	
+	half grazingTerm = saturate(oneMinusRoughness + (1-oneMinusReflectivity));
+    half3 color =	diffColor * (gi.diffuse + light.color * diffuseTerm)
+                    + specularTerm * light.color * FresnelTerm (specColor, lh)
+					+ gi.specular * FresnelLerp (specColor, grazingTerm, nv);
+
+	return half4(color, 1);
+}
+
+half4 CalculateLight (float3 worldPos, float2 uv, half3 baseColor, half3 specColor, half oneMinusRoughness, half3 normalWorld,
+	half3 lightStart, half3 lightEnd, half3 lightColor, half lightRadius, half lightRangeSqInv)
+{
+	UnityLight light = (UnityLight)0;
+
+	float3 eyeVec = normalize(worldPos - _WorldSpaceCameraPos);
+	half lightDist = 0;
+
+#if 0
+	// Can't use a keyword, because no keywords in material property blocks.
+	// TODO: is it worth the dynamic branch?
+	if (sphereLight)
+		SphereLightToPointLight (worldPos, lightStart, eyeVec, normalWorld, lightRadius, lightRangeSqInv, light, lightDist);
+	else
+#else
+		TubeLightToPointLight (worldPos, lightStart, lightEnd, eyeVec, normalWorld, lightRadius, lightRangeSqInv, lightColor, light.color, light.dir, light.ndotl, lightDist);
+#endif
+
+#if SHADOW_PLANES
+	light.color *= ShadowPlanes(worldPos);
+#endif
+
+	half oneMinusReflectivity = 1 - SpecularStrength(specColor.rgb);
+	
+	UnityIndirect ind;
+	UNITY_INITIALIZE_OUTPUT(UnityIndirect, ind);
+	ind.diffuse = 0;
+	ind.specular = 0;
+
+    half4 res = BRDF1_Unity_PBS_Area (baseColor, specColor, oneMinusReflectivity, oneMinusRoughness, normalWorld, -eyeVec, light, ind, lightDist, lightRadius);
+	return res;
+}

Assets/TubeLight/Shaders/TubeLight.cginc.meta

@@ -0,0 +1,9 @@
+fileFormatVersion: 2
+guid: bea54fea6aabea841b90651d989d88f5
+timeCreated: 1452380090
+licenseType: Pro
+ShaderImporter:
+  defaultTextures: []
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/TubeLight/Shaders/TubeLight.shader

@@ -0,0 +1,87 @@
+Shader "Hidden/TubeLight" {
+SubShader {
+	Tags { "Queue"="Geometry-1" }
+
+CGINCLUDE
+#include "UnityCG.cginc"
+#include "UnityPBSLighting.cginc"
+#include "UnityDeferredLibrary.cginc"
+
+#define SHADOW_PLANES 1
+#include "TubeLight.cginc"
+
+sampler2D _CameraGBufferTexture0;
+sampler2D _CameraGBufferTexture1;
+sampler2D _CameraGBufferTexture2;
+
+float _LightRadius;
+float _LightLength;
+float4 _LightAxis;
+
+
+void DeferredCalculateLightParams (
+	unity_v2f_deferred i,
+	out float3 outWorldPos,
+	out float2 outUV)
+{
+	i.ray = i.ray * (_ProjectionParams.z / i.ray.z);
+	float2 uv = i.uv.xy / i.uv.w;
+	
+	// read depth and reconstruct world position
+	float depth = SAMPLE_DEPTH_TEXTURE(_CameraDepthTexture, uv);
+	depth = Linear01Depth (depth);
+	float4 vpos = float4(i.ray * depth,1);
+	float3 wpos = mul (unity_CameraToWorld, vpos).xyz;
+
+	outWorldPos = wpos;
+	outUV = uv;
+}
+
+half4 CalculateLightDeferred (unity_v2f_deferred i)
+{
+	float3 worldPos;
+	float2 uv;
+	DeferredCalculateLightParams (i, worldPos, uv);
+
+	half4 gbuffer0 = tex2D (_CameraGBufferTexture0, uv);
+	half4 gbuffer1 = tex2D (_CameraGBufferTexture1, uv);
+	half4 gbuffer2 = tex2D (_CameraGBufferTexture2, uv);
+
+	half3 baseColor = gbuffer0.rgb;
+	half3 specColor = gbuffer1.rgb;
+	half oneMinusRoughness = gbuffer1.a;
+	half3 normalWorld = gbuffer2.rgb * 2 - 1;
+	normalWorld = normalize(normalWorld);
+	
+	return CalculateLight (worldPos, uv, baseColor, specColor, oneMinusRoughness, normalWorld,
+		_LightPos.xyz, _LightPos.xyz + _LightAxis.xyz * _LightLength, _LightColor.xyz, _LightRadius, _LightPos.w);
+}
+ENDCG
+
+Pass {
+	Fog { Mode Off }
+	ZWrite Off
+	Blend One One
+	Cull Front
+	ZTest Always
+
+	
+CGPROGRAM
+#pragma target 3.0
+#pragma vertex vert_deferred
+#pragma fragment frag
+#pragma exclude_renderers nomrt
+
+fixed4 frag (unity_v2f_deferred i) : SV_Target
+{
+	half4 light = CalculateLightDeferred(i);
+	// TODO: squash those NaNs at their source
+	return isnan(light) ? 0 : light;
+}
+
+ENDCG
+}
+
+}
+Fallback Off
+}

Assets/TubeLight/Shaders/TubeLight.shader.meta

@@ -0,0 +1,9 @@
+fileFormatVersion: 2
+guid: 2e6fd90941a3e3c458d01f851dca21ed
+timeCreated: 1442344786
+licenseType: Pro
+ShaderImporter:
+  defaultTextures: []
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/TubeLight/Shaders/TubeLightAttenuation.cginc

@@ -0,0 +1,55 @@
+#ifndef TUBE_LIGHT_ATTENUATION_LEGACY
+	#define TUBE_LIGHT_ATTENUATION_LEGACY 0
+#endif
+
+#if TUBE_LIGHT_ATTENUATION_LEGACY
+
+	float Attenuation(float distNorm)
+	{
+		return 1.0 / (1.0 + 25.0 * distNorm);
+	}
+
+	float AttenuationToZero(float distNorm)
+	{
+		float att = Attenuation(distNorm);
+		
+		// Replicating unity light attenuation - pulled to 0 at range
+		// if (distNorm > 0.8 * 0.8)
+		// 		att *= 1 - (distNorm - 0.8 * 0.8) / (1 - 0.8 * 0.8);
+		// Same, simplified
+		float oneDistNorm = 1.0 - distNorm;
+		att *= lerp(1.0, oneDistNorm * 2.78, step(0.64, distNorm));
+
+		att *= step(0.0, oneDistNorm);
+
+		return att;
+	}
+
+#else
+
+	float Attenuation(float distSqr)
+	{
+		float d = sqrt(distSqr);
+		float kDefaultPointLightRadius = 0.25;
+		return 1.0 / pow(1.0 +   d/kDefaultPointLightRadius, 2);
+	}
+
+	float AttenuationToZero(float distSqr)
+	{
+		// attenuation = 1 / (1 + distance_to_light / light_radius)^2
+		//             = 1 / (1 + 2*(d/r) + (d/r)^2)
+		// For more details see: https://imdoingitwrong.wordpress.com/2011/01/31/light-attenuation/
+		float d = sqrt(distSqr);
+		float kDefaultPointLightRadius = 0.25;
+		float atten =         1.0 / pow(1.0 +   d/kDefaultPointLightRadius, 2);
+		float kCutoff = 1.0 / pow(1.0 + 1.0/kDefaultPointLightRadius, 2); // cutoff equal to attenuation at distance 1.0
+
+		// Force attenuation to fall towards zero at distance 1.0
+		atten = (atten - kCutoff) / (1.f - kCutoff);
+		if (d >= 1.f)
+			atten = 0.f;
+		
+		return atten;
+	}
+
+#endif

Assets/TubeLight/Shaders/TubeLightAttenuation.cginc.meta

@@ -0,0 +1,9 @@
+fileFormatVersion: 2
+guid: 3d6df6428d576d147994b0b7ac0d5ea5
+timeCreated: 1456703457
+licenseType: Pro
+ShaderImporter:
+  defaultTextures: []
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/TubeLight/Shaders/TubeLightShadowPlanes.cginc

@@ -0,0 +1,38 @@
+half ShadowPlane(half3 worldPos, half4 plane, half feather)
+{
+	half x = plane.w - dot(worldPos, plane.xyz);
+	// Compiler bug workaround
+	x += 0.0001;
+	return smoothstep(-feather, feather, x);
+}
+
+float4 _ShadowPlane0;
+float _ShadowPlaneFeather0;
+float4 _ShadowPlane1;
+float _ShadowPlaneFeather1;
+
+half ShadowPlanes(half3 worldPos)
+{
+	half att = 1;
+	att *= ShadowPlane(worldPos, _ShadowPlane0, _ShadowPlaneFeather0);
+	att *= ShadowPlane(worldPos, _ShadowPlane1, _ShadowPlaneFeather1);
+	return att;
+}
+
+struct TubeLightShadowPlane
+{
+	float4 plane0;
+	float4 plane1;
+	float feather0;
+	float feather1;
+	float padding0;
+	float padding1;
+};
+
+half ShadowPlanes(half3 worldPos, TubeLightShadowPlane params)
+{
+	half att = 1;
+	att *= ShadowPlane(worldPos, params.plane0, params.feather0);
+	att *= ShadowPlane(worldPos, params.plane1, params.feather1);
+	return att;
+}

Assets/TubeLight/Shaders/TubeLightShadowPlanes.cginc.meta

@@ -0,0 +1,9 @@
+fileFormatVersion: 2
+guid: f4ec63bd62722b840b982641528198db
+timeCreated: 1457385992
+licenseType: Pro
+ShaderImporter:
+  defaultTextures: []
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/TubeLight/Shaders/TubeLightSource.mat

@@ -0,0 +1,190 @@
+%YAML 1.1
+%TAG !u! tag:unity3d.com,2011:
+--- !u!21 &2100000
+Material:
+  serializedVersion: 6
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  m_Name: TubeLightSource
+  m_Shader: {fileID: 46, guid: 0000000000000000f000000000000000, type: 0}
+  m_ShaderKeywords: _EMISSION
+  m_LightmapFlags: 0
+  m_CustomRenderQueue: -1
+  stringTagMap: {}
+  m_SavedProperties:
+    serializedVersion: 2
+    m_TexEnvs:
+    - first:
+        name: _BumpMap
+      second:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - first:
+        name: _DetailAlbedoMap
+      second:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - first:
+        name: _DetailMask
+      second:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - first:
+        name: _DetailNormalMap
+      second:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - first:
+        name: _EmissionMap
+      second:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - first:
+        name: _MainTex
+      second:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - first:
+        name: _MetallicGlossMap
+      second:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - first:
+        name: _OcclusionMap
+      second:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - first:
+        name: _ParallaxMap
+      second:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - first:
+        name: _SpecGlossMap
+      second:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    m_Floats:
+    - first:
+        name: _BumpScale
+      second: 1
+    - first:
+        name: _CullMode
+      second: 2
+    - first:
+        name: _Cutoff
+      second: 0.5
+    - first:
+        name: _DetailMode
+      second: 0
+    - first:
+        name: _DetailNormalMapScale
+      second: 1
+    - first:
+        name: _DstBlend
+      second: 0
+    - first:
+        name: _GlossMapScale
+      second: 1
+    - first:
+        name: _Glossiness
+      second: 0.234
+    - first:
+        name: _GlossyReflections
+      second: 1
+    - first:
+        name: _LightProbeScale
+      second: 1
+    - first:
+        name: _MetaDiffuseScale
+      second: 1
+    - first:
+        name: _MetaEmissionScale
+      second: 1
+    - first:
+        name: _MetaMetallicSoup
+      second: 1
+    - first:
+        name: _MetaSpecularScale
+      second: 1
+    - first:
+        name: _MetaUseCustom
+      second: 0
+    - first:
+        name: _Metallic
+      second: 0
+    - first:
+        name: _Mode
+      second: 0
+    - first:
+        name: _OcclusionStrength
+      second: 1
+    - first:
+        name: _Parallax
+      second: 0.02
+    - first:
+        name: _ReflectionProbeBoost
+      second: 1
+    - first:
+        name: _SmoothnessTextureChannel
+      second: 0
+    - first:
+        name: _SpecularHighlights
+      second: 1
+    - first:
+        name: _SrcBlend
+      second: 1
+    - first:
+        name: _Translucency
+      second: 0
+    - first:
+        name: _UVDetailMask
+      second: 0
+    - first:
+        name: _UVSec
+      second: 0
+    - first:
+        name: _VertexOcclusionPower
+      second: 1
+    - first:
+        name: _ZWrite
+      second: 1
+    m_Colors:
+    - first:
+        name: _Color
+      second: {r: 0.47794116, g: 1, b: 0.85685486, a: 1}
+    - first:
+        name: _EmissionColor
+      second: {r: 1, g: 1, b: 1, a: 1}
+    - first:
+        name: _MetaDiffuseAdd
+      second: {r: 0, g: 0, b: 0, a: 1}
+    - first:
+        name: _MetaDiffuseTint
+      second: {r: 1, g: 1, b: 1, a: 1}
+    - first:
+        name: _MetaEmissionAdd
+      second: {r: 0, g: 0, b: 0, a: 1}
+    - first:
+        name: _MetaEmissionTint
+      second: {r: 1, g: 1, b: 1, a: 1}
+    - first:
+        name: _MetaSpecularAdd
+      second: {r: 0, g: 0, b: 0, a: 1}
+    - first:
+        name: _MetaSpecularTint
+      second: {r: 1, g: 1, b: 1, a: 1}
+    - first:
+        name: _SpecColor
+      second: {r: 0.19999996, g: 0.19999996, b: 0.19999996, a: 1}

Assets/TubeLight/Shaders/TubeLightSource.mat.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 86b3c638dc56298409890ac32f9e6baf
+timeCreated: 1446644410
+licenseType: Pro
+NativeFormatImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: