Added the project.

Assets/AreaLight/AreaLight.prefab

@@ -0,0 +1,179 @@
+%YAML 1.1
+%TAG !u! tag:unity3d.com,2011:
+--- !u!1001 &100100000
+Prefab:
+  m_ObjectHideFlags: 1
+  serializedVersion: 2
+  m_Modification:
+    m_TransformParent: {fileID: 0}
+    m_Modifications:
+    - target: {fileID: 0}
+      propertyPath: m_ProxyShader
+      value: 
+      objectReference: {fileID: 4800000, guid: 2b28be3523d190a41910088d1ee68ef7, type: 3}
+    - target: {fileID: 0}
+      propertyPath: m_Cube
+      value: 
+      objectReference: {fileID: 10202, guid: 0000000000000000e000000000000000, type: 0}
+    - target: {fileID: 0}
+      propertyPath: m_LocalPosition.x
+      value: 0
+      objectReference: {fileID: 0}
+    - target: {fileID: 0}
+      propertyPath: m_LocalPosition.y
+      value: 0
+      objectReference: {fileID: 0}
+    - target: {fileID: 0}
+      propertyPath: m_LocalPosition.z
+      value: 0
+      objectReference: {fileID: 0}
+    - target: {fileID: 0}
+      propertyPath: m_LocalRotation.y
+      value: 0
+      objectReference: {fileID: 0}
+    - target: {fileID: 0}
+      propertyPath: m_LocalRotation.w
+      value: 1
+      objectReference: {fileID: 0}
+    - target: {fileID: 0}
+      propertyPath: m_Intensity
+      value: 0.8
+      objectReference: {fileID: 0}
+    - target: {fileID: 0}
+      propertyPath: m_BlurShadowmapShader
+      value: 
+      objectReference: {fileID: 4800000, guid: 701192b62a7678549918bc87434699fe, type: 3}
+    - target: {fileID: 0}
+      propertyPath: m_ShadowmapRes
+      value: 2048
+      objectReference: {fileID: 0}
+    - target: {fileID: 0}
+      propertyPath: m_Shadows
+      value: 0
+      objectReference: {fileID: 0}
+    m_RemovedComponents: []
+  m_ParentPrefab: {fileID: 0}
+  m_RootGameObject: {fileID: 1000010046428508}
+  m_IsPrefabParent: 1
+--- !u!1 &1000010046428508
+GameObject:
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 100100000}
+  serializedVersion: 4
+  m_Component:
+  - 4: {fileID: 4000014113918066}
+  - 114: {fileID: 114000011647635530}
+  - 33: {fileID: 33000012356353452}
+  - 23: {fileID: 23000012433474804}
+  - 114: {fileID: 114000013519192348}
+  m_Layer: 0
+  m_Name: AreaLight
+  m_TagString: Untagged
+  m_Icon: {fileID: 0}
+  m_NavMeshLayer: 0
+  m_StaticEditorFlags: 0
+  m_IsActive: 1
+--- !u!4 &4000014113918066
+Transform:
+  m_ObjectHideFlags: 1
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 100100000}
+  m_GameObject: {fileID: 1000010046428508}
+  m_LocalRotation: {x: 0, y: 0, z: 0, w: 1}
+  m_LocalPosition: {x: 0, y: 0, z: 0}
+  m_LocalScale: {x: 1, y: 1, z: 1}
+  m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
+  m_Children: []
+  m_Father: {fileID: 0}
+  m_RootOrder: 0
+--- !u!23 &23000012433474804
+MeshRenderer:
+  m_ObjectHideFlags: 1
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 100100000}
+  m_GameObject: {fileID: 1000010046428508}
+  m_Enabled: 1
+  m_CastShadows: 1
+  m_ReceiveShadows: 1
+  m_MotionVectors: 1
+  m_LightProbeUsage: 0
+  m_ReflectionProbeUsage: 1
+  m_Materials:
+  - {fileID: 2100000, guid: 1eb056d70e23cc34a9e926d8c8c887a5, type: 2}
+  m_SubsetIndices: 
+  m_StaticBatchRoot: {fileID: 0}
+  m_ProbeAnchor: {fileID: 0}
+  m_LightProbeVolumeOverride: {fileID: 0}
+  m_ScaleInLightmap: 1
+  m_PreserveUVs: 1
+  m_IgnoreNormalsForChartDetection: 0
+  m_ImportantGI: 0
+  m_SelectedWireframeHidden: 0
+  m_MinimumChartSize: 4
+  m_AutoUVMaxDistance: 0.5
+  m_AutoUVMaxAngle: 89
+  m_LightmapParameters: {fileID: 0}
+  m_SortingLayerID: 0
+  m_SortingOrder: 0
+--- !u!33 &33000012356353452
+MeshFilter:
+  m_ObjectHideFlags: 1
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 100100000}
+  m_GameObject: {fileID: 1000010046428508}
+  m_Mesh: {fileID: 0}
+--- !u!114 &114000011647635530
+MonoBehaviour:
+  m_ObjectHideFlags: 1
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 100100000}
+  m_GameObject: {fileID: 1000010046428508}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 11500000, guid: 792909cacf2415c48a1d7eebef426b5d, type: 3}
+  m_Name: 
+  m_EditorClassIdentifier: 
+  m_Cube: {fileID: 10202, guid: 0000000000000000e000000000000000, type: 0}
+  m_ProxyShader: {fileID: 4800000, guid: 2b28be3523d190a41910088d1ee68ef7, type: 3}
+  m_ShadowmapShader: {fileID: 4800000, guid: 2c4cd42b134f7864fa579350e9cf6896, type: 3}
+  m_BlurShadowmapShader: {fileID: 4800000, guid: 701192b62a7678549918bc87434699fe,
+    type: 3}
+  m_RenderSource: 1
+  m_Size: {x: 2, y: 2, z: 6}
+  m_Angle: 100
+  m_Intensity: 0.8
+  m_Color: {r: 1, g: 1, b: 1, a: 1}
+  m_Shadows: 0
+  m_ShadowCullingMask:
+    serializedVersion: 2
+    m_Bits: 4294967295
+  m_ShadowmapRes: 2048
+  m_ReceiverSearchDistance: 24
+  m_ReceiverDistanceScale: 5
+  m_LightNearSize: 4
+  m_LightFarSize: 22
+  m_ShadowBias: 0.02
+  m_Quad: {fileID: 10210, guid: 0000000000000000e000000000000000, type: 0}
+--- !u!114 &114000013519192348
+MonoBehaviour:
+  m_ObjectHideFlags: 1
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 100100000}
+  m_GameObject: {fileID: 1000010046428508}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 11500000, guid: 097385f2a510795498370c4d62e61572, type: 3}
+  m_Name: 
+  m_EditorClassIdentifier: 
+  m_IntensityMult: 1
+  m_RangeMult: 1
+  m_BlurShadowmapShader: {fileID: 0}
+  m_CopyShadowParamsShader: {fileID: 0}
+  m_ForceOnForFog: 0
+  m_Shadows: 0
+  m_ShadowmapRes: 512
+  m_BlurIterations: 0
+  m_BlurSize: 1
+  m_ESMExponent: 40
+  m_Bounded: 1

Assets/AreaLight/AreaLight.prefab.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: c946fa75949b4b0469e29c6e49bd3577
+timeCreated: 1450870880
+licenseType: Pro
+NativeFormatImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/AreaLight/Scripts.meta

@@ -0,0 +1,9 @@
+fileFormatVersion: 2
+guid: 26b199722eb73ad45b1ee21d58a9242f
+folderAsset: yes
+timeCreated: 1477748665
+licenseType: Pro
+DefaultImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/AreaLight/Scripts/AreaLight.Direct.cs

@@ -0,0 +1,143 @@
+using UnityEngine;
+using UnityEngine.Rendering;
+using System.Collections.Generic;
+
+public partial class AreaLight : MonoBehaviour
+{
+	[HideInInspector]
+	public Mesh m_Cube;
+	[HideInInspector]
+	public Shader m_ProxyShader;
+	Material m_ProxyMaterial;
+	static Texture2D s_TransformInvTexture_Specular;
+	static Texture2D s_TransformInvTexture_Diffuse;
+	static Texture2D s_AmpDiffAmpSpecFresnel;
+
+	Dictionary<Camera, CommandBuffer> m_Cameras = new Dictionary<Camera, CommandBuffer>();
+	static CameraEvent kCameraEvent = CameraEvent.AfterLighting;
+
+	bool InitDirect()
+	{
+		if (m_ProxyShader == null || m_Cube  == null)
+			return false;
+
+		// Proxy
+		m_ProxyMaterial = new Material(m_ProxyShader);
+		m_ProxyMaterial.hideFlags = HideFlags.HideAndDontSave;
+
+		return true;
+	}
+
+	void SetUpLUTs()
+	{
+		if (s_TransformInvTexture_Diffuse == null)
+			s_TransformInvTexture_Diffuse = AreaLightLUT.LoadLUT(AreaLightLUT.LUTType.TransformInv_DisneyDiffuse);
+		if (s_TransformInvTexture_Specular == null)
+			s_TransformInvTexture_Specular = AreaLightLUT.LoadLUT(AreaLightLUT.LUTType.TransformInv_GGX);
+		if (s_AmpDiffAmpSpecFresnel == null)
+			s_AmpDiffAmpSpecFresnel = AreaLightLUT.LoadLUT(AreaLightLUT.LUTType.AmpDiffAmpSpecFresnel);
+
+		m_ProxyMaterial.SetTexture("_TransformInv_Diffuse", s_TransformInvTexture_Diffuse);
+		m_ProxyMaterial.SetTexture("_TransformInv_Specular", s_TransformInvTexture_Specular);
+		m_ProxyMaterial.SetTexture("_AmpDiffAmpSpecFresnel", s_AmpDiffAmpSpecFresnel);
+	}
+
+	void Cleanup()
+	{
+		for(var e = m_Cameras.GetEnumerator(); e.MoveNext();)
+		{
+			var cam = e.Current;
+			if (cam.Key != null && cam.Value != null)
+			{
+				cam.Key.RemoveCommandBuffer (kCameraEvent, cam.Value);
+			}
+		}
+		m_Cameras.Clear();
+	}
+
+	static readonly float[,] offsets = new float[4,2] {{1, 1}, {1, -1}, {-1, -1}, {-1, 1}};
+
+	CommandBuffer GetOrCreateCommandBuffer(Camera cam)
+	{
+		if(cam == null)
+			return null;
+
+		CommandBuffer buf = null;
+		if(!m_Cameras.ContainsKey(cam)) {
+			buf = new CommandBuffer();
+			buf.name = /*"Area light: " +*/ gameObject.name;
+			m_Cameras[cam] = buf;
+			cam.AddCommandBuffer(kCameraEvent, buf);
+			cam.depthTextureMode |= DepthTextureMode.Depth;
+		} else {
+			buf = m_Cameras[cam];
+			buf.Clear();
+		}
+
+		return buf;
+	}
+
+	public void SetUpCommandBuffer()
+	{
+		if (InsideShadowmapCameraRender())
+			return;
+
+		Camera cam = Camera.current;
+		CommandBuffer buf = GetOrCreateCommandBuffer(cam);
+
+		buf.SetGlobalVector("_LightPos", transform.position);
+		buf.SetGlobalVector("_LightColor", GetColor());
+		SetUpLUTs();
+
+		// Needed as we're using the vert_deferred vertex shader from UnityDeferredLibrary.cginc
+		// TODO: Make the light render as quad if it intersects both near and far plane.
+		// (Also missing: rendering as front faces when near doesn't intersect, stencil optimisations)
+		buf.SetGlobalFloat("_LightAsQuad", 0);
+		
+		// A little bit of bias to prevent the light from lighting itself - the source quad
+		float z = 0.01f;
+		Transform t = transform;
+
+		Matrix4x4 lightVerts = new Matrix4x4();
+		for (int i = 0; i < 4; i++)
+			lightVerts.SetRow(i, t.TransformPoint(new Vector3(m_Size.x * offsets[i,0], m_Size.y * offsets[i,1], z) * 0.5f));
+		buf.SetGlobalMatrix("_LightVerts", lightVerts);
+
+		if (m_Shadows)
+			SetUpShadowmapForSampling(buf);
+
+		Matrix4x4 m = Matrix4x4.TRS(new Vector3(0, 0, 10.0f), Quaternion.identity, Vector3.one * 20);
+		buf.DrawMesh(m_Cube, t.localToWorldMatrix * m, m_ProxyMaterial, 0, m_Shadows ? /*shadows*/ 0 : /*no shadows*/ 1);
+	}
+
+	void SetKeyword(string keyword, bool on)
+	{
+		if (on)
+			m_ProxyMaterial.EnableKeyword(keyword);
+		else
+			m_ProxyMaterial.DisableKeyword(keyword);
+	}
+
+	void ReleaseTemporary(ref RenderTexture rt)
+	{
+		if (rt == null)
+			return;
+
+		RenderTexture.ReleaseTemporary(rt);
+		rt = null;
+	}
+
+	Color GetColor()
+	{
+		if (QualitySettings.activeColorSpace == ColorSpace.Gamma)
+			return m_Color * m_Intensity;
+
+		return new Color(
+			Mathf.GammaToLinearSpace(m_Color.r * m_Intensity),
+			Mathf.GammaToLinearSpace(m_Color.g * m_Intensity),
+			Mathf.GammaToLinearSpace(m_Color.b * m_Intensity),
+			1.0f
+		);
+	}
+
+}

Assets/AreaLight/Scripts/AreaLight.Direct.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: f166f8247b9668b45bd44bb7d17f3e1d
+timeCreated: 1453074905
+licenseType: Pro
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/AreaLight/Scripts/AreaLight.Shadow.cs

@@ -0,0 +1,303 @@
+using UnityEngine;
+using UnityEngine.Rendering;
+
+public partial class AreaLight : MonoBehaviour
+{
+	Camera m_ShadowmapCamera;
+	Transform m_ShadowmapCameraTransform;
+	
+	[HideInInspector]
+	public Shader m_ShadowmapShader;
+	[HideInInspector]
+	public Shader m_BlurShadowmapShader;
+	Material m_BlurShadowmapMaterial;
+	RenderTexture m_Shadowmap = null;
+	RenderTexture m_BlurredShadowmap = null;
+	Texture2D m_ShadowmapDummy = null;
+
+	int m_ShadowmapRenderTime = -1;
+	int m_BlurredShadowmapRenderTime = -1;
+	FogLight m_FogLight = null;
+
+	public enum TextureSize
+	{
+		x512 = 512,
+		x1024 = 1024,
+		x2048 = 2048,
+		x4096 = 4096,
+	}
+
+	void UpdateShadowmap(int res)
+	{
+		if (m_Shadowmap != null && m_ShadowmapRenderTime == Time.renderedFrameCount)
+			return;
+
+		// Create the camera
+		if (m_ShadowmapCamera == null)
+		{
+			if (m_ShadowmapShader == null)
+			{
+				Debug.LogError("AreaLight's shadowmap shader not assigned.", this);
+				return;
+			}
+
+			GameObject go = new GameObject("Shadowmap Camera");
+			go.AddComponent(typeof(Camera));
+			m_ShadowmapCamera = go.GetComponent<Camera>();
+			go.hideFlags = HideFlags.HideAndDontSave;
+			m_ShadowmapCamera.enabled = false;
+			m_ShadowmapCamera.clearFlags = CameraClearFlags.SolidColor;
+			m_ShadowmapCamera.renderingPath = RenderingPath.Forward;
+			// exp(EXPONENT) for ESM, white for VSM
+			// m_ShadowmapCamera.backgroundColor = new Color(Mathf.Exp(EXPONENT), 0, 0, 0);
+			m_ShadowmapCamera.backgroundColor = Color.white;
+			m_ShadowmapCameraTransform = go.transform;
+			m_ShadowmapCameraTransform.parent = transform;
+			m_ShadowmapCameraTransform.localRotation = Quaternion.identity;
+		}
+
+		if (m_Angle == 0.0f)
+		{
+			m_ShadowmapCamera.orthographic = true;
+			m_ShadowmapCameraTransform.localPosition = Vector3.zero;
+			m_ShadowmapCamera.nearClipPlane = 0;
+			m_ShadowmapCamera.farClipPlane = m_Size.z;
+			m_ShadowmapCamera.orthographicSize = 0.5f * m_Size.y;
+			m_ShadowmapCamera.aspect = m_Size.x / m_Size.y;
+		}
+		else
+		{
+			m_ShadowmapCamera.orthographic = false;
+			float near = GetNearToCenter();
+			m_ShadowmapCameraTransform.localPosition = -near * Vector3.forward;
+			m_ShadowmapCamera.nearClipPlane = near;
+			m_ShadowmapCamera.farClipPlane = near + m_Size.z;
+			m_ShadowmapCamera.fieldOfView = m_Angle;
+			m_ShadowmapCamera.aspect = m_Size.x / m_Size.y;
+		}
+
+		ReleaseTemporary(ref m_Shadowmap);
+		m_Shadowmap = RenderTexture.GetTemporary(res, res, 24, RenderTextureFormat.Shadowmap);
+		m_Shadowmap.name = "AreaLight Shadowmap";
+		m_Shadowmap.filterMode = FilterMode.Bilinear;
+		m_Shadowmap.wrapMode = TextureWrapMode.Clamp;
+
+		m_ShadowmapCamera.targetTexture = m_Shadowmap;
+
+		// Clear. RenderWithShader() should clear too, but it doesn't.
+		// TODO: Check if it's a bug.
+		m_ShadowmapCamera.cullingMask = 0;
+		m_ShadowmapCamera.Render();
+		m_ShadowmapCamera.cullingMask = m_ShadowCullingMask;
+
+		// We might be rendering inside PlaneReflections, which invert culling. Disable temporarily.
+		var oldCulling = GL.invertCulling;
+		GL.invertCulling = false;
+
+		m_ShadowmapCamera.RenderWithShader(m_ShadowmapShader, "RenderType");
+
+		// Back to whatever was the culling mode.
+		GL.invertCulling = oldCulling;
+
+		m_ShadowmapRenderTime = Time.renderedFrameCount;
+	}
+
+	public RenderTexture GetBlurredShadowmap()
+	{
+		UpdateBlurredShadowmap();
+		return m_BlurredShadowmap;
+	}
+
+	RenderTexture[] temp;
+
+	void UpdateBlurredShadowmap()
+	{
+		if (m_BlurredShadowmap != null && m_BlurredShadowmapRenderTime == Time.renderedFrameCount)
+			return;
+
+		InitFogLight();
+
+		int startRes = (int)m_ShadowmapRes;
+		int targetRes = (int)m_FogLight.m_ShadowmapRes;
+
+		// To make things easier, blurred shadowmap is at most half the size of the regular.
+		if (isActiveAndEnabled && m_Shadows)
+		{
+			targetRes = Mathf.Min(targetRes, startRes/2);
+		}
+		else
+		{
+			// If the area light or the shadows on it are disabled, we can
+			// just get the most convenient resolution for us.
+			startRes = 2 * startRes;
+		}
+
+		UpdateShadowmap(startRes);
+
+		RenderTexture originalRT = RenderTexture.active;
+
+		// Downsample
+		ReleaseTemporary(ref m_BlurredShadowmap);
+		InitMaterial(ref m_BlurShadowmapMaterial, m_BlurShadowmapShader);
+		int downsampleSteps = (int)Mathf.Log(startRes / targetRes, 2);
+		if (temp == null || temp.Length != downsampleSteps)
+			temp = new RenderTexture[downsampleSteps];
+		// RFloat for ESM, RGHalf for VSM
+		RenderTextureFormat format = RenderTextureFormat.RGHalf;
+
+		for(int i = 0, currentRes = startRes/2; i < downsampleSteps; i++)
+		{
+			temp[i] = RenderTexture.GetTemporary(currentRes, currentRes, 0, format, RenderTextureReadWrite.Linear);
+			temp[i].name = "AreaLight Shadow Downsample";
+			temp[i].filterMode = FilterMode.Bilinear;
+			temp[i].wrapMode = TextureWrapMode.Clamp;
+			m_BlurShadowmapMaterial.SetVector("_TexelSize", new Vector4(0.5f/currentRes, 0.5f/currentRes, 0, 0));
+
+			if (i == 0)
+			{
+				m_BlurShadowmapMaterial.SetTexture("_Shadowmap", m_Shadowmap);
+				InitShadowmapDummy();
+				m_BlurShadowmapMaterial.SetTexture("_ShadowmapDummy", m_ShadowmapDummy);
+				m_BlurShadowmapMaterial.SetVector("_ZParams", GetZParams());
+				m_BlurShadowmapMaterial.SetFloat("_ESMExponent", m_FogLight.m_ESMExponent);
+				Blur(m_Shadowmap, temp[i], /*sample & convert shadowmap*/ 0);
+			}
+			else
+			{
+				m_BlurShadowmapMaterial.SetTexture("_MainTex", temp[i - 1]);
+				Blur(temp[i - 1], temp[i], /*regular sample*/ 1);
+			}
+
+			currentRes /= 2;
+		}
+
+		for (int i = 0; i < downsampleSteps - 1; i++)
+			RenderTexture.ReleaseTemporary(temp[i]);
+
+		m_BlurredShadowmap = temp[downsampleSteps - 1];
+
+		// Blur
+		if (m_FogLight.m_BlurIterations > 0)
+		{
+			RenderTexture tempBlur = RenderTexture.GetTemporary (targetRes, targetRes, 0, format, RenderTextureReadWrite.Linear);
+			tempBlur.name = "AreaLight Shadow Blur";
+			tempBlur.filterMode = FilterMode.Bilinear;
+			tempBlur.wrapMode = TextureWrapMode.Clamp;
+
+			m_BlurShadowmapMaterial.SetVector("_MainTex_TexelSize", new Vector4(1.0f/targetRes, 1.0f/targetRes, 0, 0));
+
+			float blurSize = m_FogLight.m_BlurSize;
+			for(int i = 0; i < m_FogLight.m_BlurIterations; i++)
+			{
+				m_BlurShadowmapMaterial.SetFloat ("_BlurSize", blurSize);
+				Blur(m_BlurredShadowmap, tempBlur,   /*vertical blur*/2);
+				Blur(tempBlur, m_BlurredShadowmap, /*horizontal blur*/3);
+				blurSize *= 1.2f;
+			}
+
+			RenderTexture.ReleaseTemporary(tempBlur);
+		}
+
+		RenderTexture.active = originalRT;
+
+		m_BlurredShadowmapRenderTime = Time.renderedFrameCount;
+	}
+
+	// Normally would've used Graphics.Blit(), but it breaks picking in the scene view.
+	// TODO: bug report
+	void Blur(RenderTexture src, RenderTexture dst, int pass)
+	{
+		RenderTexture.active = dst;
+		m_BlurShadowmapMaterial.SetTexture("_MainTex", src);
+		m_BlurShadowmapMaterial.SetPass(pass);
+		RenderQuad();
+	}
+
+	void RenderQuad()
+	{
+		GL.Begin(GL.QUADS);
+		GL.TexCoord2( 0, 0);
+		GL.Vertex3	(-1, 1, 0);
+		GL.TexCoord2( 0, 1);
+		GL.Vertex3	(-1,-1, 0);
+		GL.TexCoord2( 1, 1);
+		GL.Vertex3	( 1,-1, 0);
+		GL.TexCoord2( 1, 0);
+		GL.Vertex3	( 1, 1, 0);
+		GL.End();
+	}
+
+	void SetUpShadowmapForSampling(CommandBuffer buf)
+	{
+		UpdateShadowmap((int)m_ShadowmapRes);
+		
+		buf.SetGlobalTexture("_Shadowmap", m_Shadowmap);
+		InitShadowmapDummy();
+		m_ProxyMaterial.SetTexture("_ShadowmapDummy", m_ShadowmapDummy);
+		buf.SetGlobalMatrix("_ShadowProjectionMatrix", GetProjectionMatrix());
+
+		float texelsInMap = (int)m_ShadowmapRes;
+		float relativeTexelSize = texelsInMap / 2048.0f;
+
+		buf.SetGlobalFloat("_ShadowReceiverWidth", relativeTexelSize * m_ReceiverSearchDistance / texelsInMap);
+
+		buf.SetGlobalFloat("_ShadowReceiverDistanceScale", m_ReceiverDistanceScale * 0.5f / 10.0f); // 10 samples in shader
+		
+		Vector2 shadowLightWidth = new Vector2(m_LightNearSize, m_LightFarSize) * relativeTexelSize / texelsInMap;
+		buf.SetGlobalVector("_ShadowLightWidth", shadowLightWidth);
+
+		buf.SetGlobalFloat("_ShadowBias", m_ShadowBias);
+	}
+
+	void InitMaterial(ref Material material, Shader shader)
+	{
+		if (material)
+			return;
+
+		if (!shader)
+		{
+			Debug.LogError("Missing shader");
+			return;
+		}
+
+		material = new Material(shader);
+		material.hideFlags = HideFlags.HideAndDontSave;
+	}
+
+	void InitShadowmapDummy()
+	{
+		if(m_ShadowmapDummy != null)
+			return;
+		m_ShadowmapDummy = new Texture2D(1, 1, TextureFormat.Alpha8, false, true);
+		m_ShadowmapDummy.filterMode = FilterMode.Point;
+		m_ShadowmapDummy.SetPixel(0, 0, new Color(0f, 0f, 0f, 0f));
+		m_ShadowmapDummy.Apply(false, true);
+	}
+
+	void InitFogLight()
+	{
+		if (m_FogLight != null)
+			return;
+
+		// It should always be here, because it triggered this code path in the first place.
+		m_FogLight = GetComponent<FogLight>();
+	}
+
+	bool InsideShadowmapCameraRender()
+	{
+		RenderTexture target = Camera.current.targetTexture;
+		return target != null && target.format == RenderTextureFormat.Shadowmap;
+	}
+
+	Vector4 GetZParams()
+	{
+		float n = GetNearToCenter();
+		float f = n + m_Size.z;
+		// linear z, 0 near, 1 far
+		// linearz = A * (z + 1.0) / (z + B);
+		// A = n/(n - f)
+		// B = (n + f)/(n - f)
+
+		return new Vector4(n/(n - f), (n + f)/(n - f), 0, 0);
+	}
+}

Assets/AreaLight/Scripts/AreaLight.Shadow.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: 263b59280b7c4e04aa70d3c9cb1a5586
+timeCreated: 1455014110
+licenseType: Pro
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/AreaLight/Scripts/AreaLight.cs

@@ -0,0 +1,297 @@
+using UnityEngine;
+
+[ExecuteInEditMode]
+public partial class AreaLight : MonoBehaviour
+{
+	public bool m_RenderSource = true;
+	public Vector3 m_Size = new Vector3(1, 1, 2);
+	[Range(0, 179)]
+	public float m_Angle = 0.0f;
+	[MinValue(0)]
+	public float m_Intensity = 0.8f;
+	public Color m_Color = Color.white;
+
+	[Header("Shadows")]
+	public bool m_Shadows = false;
+	public LayerMask m_ShadowCullingMask = ~0;
+	public TextureSize m_ShadowmapRes = TextureSize.x2048;
+	[MinValue(0)]
+	public float m_ReceiverSearchDistance = 24.0f;
+	[MinValue(0)]
+	public float m_ReceiverDistanceScale = 5.0f;
+	[MinValue(0)]
+	public float m_LightNearSize = 4.0f;
+	[MinValue(0)]
+	public float m_LightFarSize = 22.0f;
+	[Range(0, 0.1f)]
+	public float m_ShadowBias = 0.001f;
+
+	MeshRenderer m_SourceRenderer;
+	Mesh m_SourceMesh;
+	[HideInInspector]
+	public Mesh m_Quad;
+	Vector2 m_CurrentQuadSize = Vector2.zero;
+	Vector3 m_CurrentSize = Vector3.zero;
+	float m_CurrentAngle = -1.0f;
+
+	bool m_Initialized = false;
+	MaterialPropertyBlock m_props;
+
+	void Awake()
+	{
+		if(!Init())
+			return;
+		UpdateSourceMesh();
+	}
+
+	bool Init()
+	{
+		if (m_Initialized)
+			return true;
+
+		if (m_Quad == null || !InitDirect())
+			return false;
+
+		m_SourceRenderer = GetComponent<MeshRenderer>();
+		m_SourceRenderer.enabled = true;
+		m_SourceMesh = Instantiate<Mesh>(m_Quad);
+		m_SourceMesh.hideFlags = HideFlags.HideAndDontSave;
+		MeshFilter mfs = gameObject.GetComponent<MeshFilter>();
+		mfs.sharedMesh = m_SourceMesh;
+
+		Transform t = transform;
+		if (t.localScale != Vector3.one)
+		{
+#if UNITY_EDITOR
+			Debug.LogError("AreaLights don't like to be scaled. Setting local scale to 1.", this);
+#endif
+			t.localScale = Vector3.one;
+		}
+
+		SetUpLUTs();
+
+		m_Initialized = true;
+		return true;
+	}
+
+	void OnEnable()
+	{
+		m_props = new MaterialPropertyBlock();
+
+		if(!Init())
+			return;
+		UpdateSourceMesh();
+	}
+
+	void OnDisable()
+	{
+		if(!Application.isPlaying)
+			Cleanup();
+		else
+			for(var e = m_Cameras.GetEnumerator(); e.MoveNext();)
+				if(e.Current.Value != null)
+					e.Current.Value.Clear();
+	}
+
+	void OnDestroy()
+	{
+		if (m_ProxyMaterial != null)
+			DestroyImmediate(m_ProxyMaterial);
+		if (m_SourceMesh != null)
+			DestroyImmediate(m_SourceMesh);
+		Cleanup();
+	}
+
+	static Vector3[] vertices = new Vector3[4];
+
+	void UpdateSourceMesh()
+	{
+		m_Size.x = Mathf.Max(m_Size.x, 0);
+		m_Size.y = Mathf.Max(m_Size.y, 0);
+		m_Size.z = Mathf.Max(m_Size.z, 0);
+
+		Vector2 quadSize = m_RenderSource && enabled ? new Vector2(m_Size.x, m_Size.y) : Vector2.one * 0.0001f;
+		if (quadSize != m_CurrentQuadSize)
+		{
+
+			float x = quadSize.x * 0.5f;
+			float y = quadSize.y * 0.5f;
+			// To prevent the source quad from getting into the shadowmap, offset it back a bit.
+			float z = -0.001f;
+			vertices[0].Set(-x,  y, z);
+			vertices[1].Set( x, -y, z);
+			vertices[2].Set( x,  y, z);
+			vertices[3].Set(-x, -y, z);
+
+			m_SourceMesh.vertices = vertices;
+
+			m_CurrentQuadSize = quadSize;
+		}
+
+		if (m_Size != m_CurrentSize || m_Angle != m_CurrentAngle)
+		{
+			// Set the bounds of the mesh to large, so that they drive rendering of the entire light
+			// TODO: Make the bounds tight around the shape of the light. Right now they're just tight around
+			// the shadow frustum, which is fine if the shadows are enable (ok, maybe far plane should be more clever),
+			// but doesn't make sense if shadows are disabled.
+			m_SourceMesh.bounds = GetFrustumBounds();
+		}
+	}
+
+	void Update()
+	{
+		if (!gameObject.activeInHierarchy || !enabled)
+		{
+			Cleanup();
+			return;
+		}
+
+		if(!Init())
+			return;
+
+		UpdateSourceMesh();
+
+		if(Application.isPlaying)
+			for(var e = m_Cameras.GetEnumerator(); e.MoveNext();)
+				if(e.Current.Value != null)
+					e.Current.Value.Clear();
+	}
+
+	void OnWillRenderObject()
+	{
+		if(!Init())
+			return;
+
+		// TODO: This is just a very rough guess. Need to properly calculate the surface emission
+		// intensity based on light's intensity.
+		Color color = new Color(
+			Mathf.GammaToLinearSpace(m_Color.r),
+			Mathf.GammaToLinearSpace(m_Color.g),
+			Mathf.GammaToLinearSpace(m_Color.b),
+			1.0f);
+		m_props.SetVector("_EmissionColor", color * m_Intensity);
+		m_SourceRenderer.SetPropertyBlock(m_props);
+
+		SetUpCommandBuffer();
+	}
+
+	float GetNearToCenter()
+	{
+		if (m_Angle == 0.0f)
+			return 0;
+
+		return m_Size.y * 0.5f / Mathf.Tan(m_Angle * 0.5f * Mathf.Deg2Rad);
+	}
+
+	Matrix4x4 GetOffsetMatrix(float zOffset)
+	{
+		Matrix4x4 m = Matrix4x4.identity;
+		m.SetColumn(3, new Vector4(0, 0, zOffset, 1));
+		return m;
+	}
+
+	public Matrix4x4 GetProjectionMatrix(bool linearZ = false)
+	{
+		Matrix4x4 m;
+
+		if (m_Angle == 0.0f)
+		{
+			m = Matrix4x4.Ortho(-0.5f * m_Size.x, 0.5f * m_Size.x, -0.5f * m_Size.y, 0.5f * m_Size.y, 0, -m_Size.z);
+		}
+		else
+		{
+			float near = GetNearToCenter();
+			if (linearZ)
+			{
+				m = PerspectiveLinearZ(m_Angle, m_Size.x/m_Size.y, near, near + m_Size.z);
+			}
+			else
+			{
+				m = Matrix4x4.Perspective(m_Angle, m_Size.x/m_Size.y, near, near + m_Size.z);
+				m = m * Matrix4x4.Scale(new Vector3(1, 1, -1));
+			}
+			m = m * GetOffsetMatrix(near);
+		}
+		
+		return m * transform.worldToLocalMatrix;
+	}
+
+	public Vector4 MultiplyPoint(Matrix4x4 m, Vector3 v)
+	{
+		Vector4 res;
+		res.x = m.m00 * v.x + m.m01 * v.y + m.m02 * v.z + m.m03;
+		res.y = m.m10 * v.x + m.m11 * v.y + m.m12 * v.z + m.m13;
+		res.z = m.m20 * v.x + m.m21 * v.y + m.m22 * v.z + m.m23;
+		res.w = m.m30 * v.x + m.m31 * v.y + m.m32 * v.z + m.m33;
+		return res;
+	}
+
+	Matrix4x4 PerspectiveLinearZ(float fov, float aspect, float near, float far)
+	{
+		// A vector transformed with this matrix should get perspective division on x and y only:
+		// Vector4 vClip = MultiplyPoint(PerspectiveLinearZ(...), vEye);
+		// Vector3 vNDC = Vector3(vClip.x / vClip.w, vClip.y / vClip.w, vClip.z);
+		// vNDC is [-1, 1]^3 and z is linear, i.e. z = 0 is half way between near and far in world space.
+
+		float rad = Mathf.Deg2Rad * fov * 0.5f;
+		float cotan = Mathf.Cos(rad) / Mathf.Sin(rad);
+		float deltainv = 1.0f / (far - near);
+		Matrix4x4 m;
+
+		m.m00 = cotan / aspect;	m.m01 = 0.0f;	m.m02 = 0.0f;			 m.m03 = 0.0f;
+		m.m10 = 0.0f;			m.m11 = cotan; 	m.m12 = 0.0f;			 m.m13 = 0.0f;
+		m.m20 = 0.0f;			m.m21 = 0.0f;	m.m22 = 2.0f * deltainv; m.m23 = - (far + near) * deltainv;
+		m.m30 = 0.0f;			m.m31 = 0.0f;	m.m32 = 1.0f;			 m.m33 = 0.0f;
+
+		return m;
+	}
+
+	public Vector4 GetPosition()
+	{
+		Transform t = transform;
+
+		if (m_Angle == 0.0f)
+		{
+			Vector3 dir = -t.forward;
+			return new Vector4(dir.x, dir.y, dir.z, 0);
+		}
+
+		Vector3 pos = t.position - GetNearToCenter() * t.forward;
+		return new Vector4(pos.x, pos.y, pos.z, 1);
+	}
+
+	Bounds GetFrustumBounds()
+	{
+		if (m_Angle == 0.0f)
+			return new Bounds(Vector3.zero, m_Size);
+
+		float tanhalffov = Mathf.Tan(m_Angle * 0.5f * Mathf.Deg2Rad);
+		float near = m_Size.y * 0.5f / tanhalffov;
+		float z = m_Size.z;
+		float y = (near + m_Size.z) * tanhalffov * 2.0f;
+		float x = m_Size.x * y / m_Size.y;
+		return new Bounds(Vector3.forward * m_Size.z * 0.5f, new Vector3(x, y, z));
+	}
+
+	void OnDrawGizmosSelected()
+	{
+		Gizmos.color = Color.white;
+
+		if (m_Angle == 0.0f)
+		{
+			Gizmos.matrix = transform.localToWorldMatrix;
+			Gizmos.DrawWireCube(new Vector3(0, 0, 0.5f * m_Size.z), m_Size);
+			return;
+		}
+
+		float near = GetNearToCenter();
+		Gizmos.matrix = transform.localToWorldMatrix * GetOffsetMatrix(-near);
+
+		Gizmos.DrawFrustum(Vector3.zero, m_Angle, near + m_Size.z, near, m_Size.x/m_Size.y);
+
+		Gizmos.matrix = transform.localToWorldMatrix;
+		Gizmos.color = Color.yellow;
+		Bounds bounds = GetFrustumBounds();
+		Gizmos.DrawWireCube(bounds.center, bounds.size);
+	}
+}

Assets/AreaLight/Scripts/AreaLight.cs.meta

@@ -0,0 +1,16 @@
+fileFormatVersion: 2
+guid: 792909cacf2415c48a1d7eebef426b5d
+timeCreated: 1453121021
+licenseType: Pro
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences:
+  - m_Cube: {fileID: 10202, guid: 0000000000000000e000000000000000, type: 0}
+  - m_ProxyShader: {fileID: 4800000, guid: 2b28be3523d190a41910088d1ee68ef7, type: 3}
+  - m_Quad: {fileID: 10210, guid: 0000000000000000e000000000000000, type: 0}
+  - m_ShadowmapShader: {fileID: 4800000, guid: 2c4cd42b134f7864fa579350e9cf6896, type: 3}
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/AreaLight/Scripts/AreaLightLUT.DisneyDiffuse.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: 9cbf86f9b2114924a91acc43796a307b
+timeCreated: 1454419446
+licenseType: Pro
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/AreaLight/Scripts/AreaLightLUT.GGX.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: 2b0041ac2ad0ef8459f7565f64f4d731
+timeCreated: 1453066169
+licenseType: Pro
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/AreaLight/Scripts/AreaLightLUT.Load.cs

@@ -0,0 +1,68 @@
+using UnityEngine;
+
+public partial class AreaLightLUT
+{
+	const int kLUTResolution = 64;
+	const int kLUTMatrixDim = 3;
+
+	public enum LUTType
+	{
+		TransformInv_DisneyDiffuse,
+		TransformInv_GGX,
+		AmpDiffAmpSpecFresnel
+	}
+
+	public static Texture2D LoadLUT(LUTType type)
+	{
+		switch(type)
+		{
+			case LUTType.TransformInv_DisneyDiffuse: return LoadLUT(s_LUTTransformInv_DisneyDiffuse);
+			case LUTType.TransformInv_GGX: return LoadLUT(s_LUTTransformInv_GGX);
+			case LUTType.AmpDiffAmpSpecFresnel: return LoadLUT(s_LUTAmplitude_DisneyDiffuse, s_LUTAmplitude_GGX, s_LUTFresnel_GGX);
+		}
+
+		return null;
+	}
+
+	static Texture2D CreateLUT(TextureFormat format, Color[] pixels)
+	{
+		Texture2D tex = new Texture2D(kLUTResolution, kLUTResolution, format, false /*mipmap*/, true /*linear*/);
+		tex.hideFlags = HideFlags.HideAndDontSave;
+		tex.wrapMode = TextureWrapMode.Clamp;
+		tex.SetPixels(pixels);
+		tex.Apply();
+		return tex;
+	}
+
+	static Texture2D LoadLUT(double[,] LUTTransformInv)
+	{
+		const int count = kLUTResolution * kLUTResolution;
+		Color[] pixels = new Color[count];
+		
+		// transformInv
+		for (int i = 0; i < count; i++)
+		{
+			// Only columns 0, 2, 4 and 6 contain interesting values (at least in the case of GGX).
+			pixels[i] = new Color(	(float)LUTTransformInv[i, 0],
+									(float)LUTTransformInv[i, 2],
+									(float)LUTTransformInv[i, 4],
+									(float)LUTTransformInv[i, 6]);
+		}
+
+		return CreateLUT(TextureFormat.RGBAHalf, pixels);
+	}
+
+	static Texture2D LoadLUT(float[] LUTScalar0, float[] LUTScalar1, float[] LUTScalar2)
+	{
+		const int count = kLUTResolution * kLUTResolution;
+		Color[] pixels = new Color[count];
+
+		// amplitude
+		for (int i = 0; i < count; i++)
+		{
+			pixels[i] = new Color(LUTScalar0[i], LUTScalar1[i], LUTScalar2[i], 0);
+		}
+
+		return CreateLUT(TextureFormat.RGBAHalf, pixels);
+	}
+}

Assets/AreaLight/Scripts/AreaLightLUT.Load.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: 0c08d6c4951e30c42a4bd6209323dfb8
+timeCreated: 1453070529
+licenseType: Pro
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/AreaLight/Shaders.meta

@@ -0,0 +1,9 @@
+fileFormatVersion: 2
+guid: d622c47de56b9e84e971b5a72b861f95
+folderAsset: yes
+timeCreated: 1477749207
+licenseType: Pro
+DefaultImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/AreaLight/Shaders/AreaLight.cginc

@@ -0,0 +1,224 @@
+// Based on 'Real-Time Polygonal-Light Shading with Linearly Transformed Cosines'
+// https://labs.unity.com/article/real-time-polygonal-light-shading-linearly-transformed-cosines
+
+#if AREA_LIGHT_ENABLE_DIFFUSE
+sampler2D _TransformInv_Diffuse;
+#endif
+sampler2D _TransformInv_Specular;
+sampler2D _AmpDiffAmpSpecFresnel;
+float4x4 _LightVerts;
+
+half IntegrateEdge(half3 v1, half3 v2)
+{
+	half d = dot(v1,v2);
+	half theta = acos(max(-0.9999, dot(v1,v2)));
+	half theta_sintheta = theta / sin(theta);
+	return theta_sintheta * (v1.x*v2.y - v1.y*v2.x);
+}
+
+// Baum's equation
+// Expects non-normalized vertex positions
+half PolygonRadiance(half4x3 L)
+{
+	// detect clipping config	
+	uint config = 0;
+	if (L[0].z > 0) config += 1;
+	if (L[1].z > 0) config += 2;
+	if (L[2].z > 0) config += 4;
+	if (L[3].z > 0) config += 8;
+
+
+	// The fifth vertex for cases when clipping cuts off one corner.
+	// Due to a compiler bug, copying L into a vector array with 5 rows
+	// messes something up, so we need to stick with the matrix + the L4 vertex.
+	half3 L4 = L[3];
+
+	// This switch is surprisingly fast. Tried replacing it with a lookup array of vertices.
+	// Even though that replaced the switch with just some indexing and no branches, it became
+	// way, way slower - mem fetch stalls?
+
+	// clip
+	uint n = 0;
+	switch(config)
+	{
+		case 0: // clip all
+			break;
+			
+		case 1: // V1 clip V2 V3 V4
+			n = 3;
+			L[1] = -L[1].z * L[0] + L[0].z * L[1];
+			L[2] = -L[3].z * L[0] + L[0].z * L[3];
+			break;
+			
+		case 2: // V2 clip V1 V3 V4
+			n = 3;
+			L[0] = -L[0].z * L[1] + L[1].z * L[0];
+			L[2] = -L[2].z * L[1] + L[1].z * L[2];
+			break;
+			
+		case 3: // V1 V2 clip V3 V4
+			n = 4;
+			L[2] = -L[2].z * L[1] + L[1].z * L[2];
+			L[3] = -L[3].z * L[0] + L[0].z * L[3];
+			break;
+			
+		case 4: // V3 clip V1 V2 V4
+			n = 3;	
+			L[0] = -L[3].z * L[2] + L[2].z * L[3];
+			L[1] = -L[1].z * L[2] + L[2].z * L[1];				
+			break;
+			
+		case 5: // V1 V3 clip V2 V4: impossible
+			break;
+			
+		case 6: // V2 V3 clip V1 V4
+			n = 4;
+			L[0] = -L[0].z * L[1] + L[1].z * L[0];
+			L[3] = -L[3].z * L[2] + L[2].z * L[3];			
+			break;
+			
+		case 7: // V1 V2 V3 clip V4
+			n = 5;
+			L4 = -L[3].z * L[0] + L[0].z * L[3];
+			L[3] = -L[3].z * L[2] + L[2].z * L[3];
+			break;
+			
+		case 8: // V4 clip V1 V2 V3
+			n = 3;
+			L[0] = -L[0].z * L[3] + L[3].z * L[0];
+			L[1] = -L[2].z * L[3] + L[3].z * L[2];
+			L[2] =  L[3];
+			break;
+			
+		case 9: // V1 V4 clip V2 V3
+			n = 4;
+			L[1] = -L[1].z * L[0] + L[0].z * L[1];
+			L[2] = -L[2].z * L[3] + L[3].z * L[2];
+			break;
+			
+		case 10: // V2 V4 clip V1 V3: impossible
+			break;
+			
+		case 11: // V1 V2 V4 clip V3
+			n = 5;
+			L[3] = -L[2].z * L[3] + L[3].z * L[2];
+			L[2] = -L[2].z * L[1] + L[1].z * L[2];			
+			break;
+			
+		case 12: // V3 V4 clip V1 V2
+			n = 4;
+			L[1] = -L[1].z * L[2] + L[2].z * L[1];
+			L[0] = -L[0].z * L[3] + L[3].z * L[0];
+			break;
+			
+		case 13: // V1 V3 V4 clip V2
+			n = 5;
+			L[3] = L[2];
+			L[2] = -L[1].z * L[2] + L[2].z * L[1];
+			L[1] = -L[1].z * L[0] + L[0].z * L[1];
+			break;
+			
+		case 14: // V2 V3 V4 clip V1
+			n = 5;
+			L4 = -L[0].z * L[3] + L[3].z * L[0];
+			L[0] = -L[0].z * L[1] + L[1].z * L[0];
+			break;
+			
+		case 15: // V1 V2 V3 V4
+			n = 4;
+			break;
+	}
+
+	if (n == 0)
+		return 0;
+
+	// normalize
+	L[0] = normalize(L[0]);
+	L[1] = normalize(L[1]);
+	L[2] = normalize(L[2]);
+	if(n == 3)
+		L[3] = L[0];
+	else
+	{
+		L[3] = normalize(L[3]);
+		if (n == 4)
+			L4 = L[0];
+		else
+			L4 = normalize(L4);
+	}
+	
+	// integrate
+	half sum = 0;
+	sum += IntegrateEdge(L[0], L[1]);
+	sum += IntegrateEdge(L[1], L[2]);
+	sum += IntegrateEdge(L[2], L[3]);
+	if(n >= 4)	
+		sum += IntegrateEdge(L[3], L4);
+	if(n == 5)
+		sum += IntegrateEdge(L4, L[0]);
+	
+	sum *= 0.15915; // 1/2pi
+
+	return max(0, sum);
+}
+
+half TransformedPolygonRadiance(half4x3 L, half2 uv, sampler2D transformInv, half amplitude)
+{
+	// Get the inverse LTC matrix M
+	half3x3 Minv = 0;
+	Minv._m22 = 1;
+	Minv._m00_m02_m11_m20 = tex2D(transformInv, uv);
+			
+	// Transform light vertices into diffuse configuration
+	half4x3 LTransformed = mul(L, Minv);
+
+	// Polygon radiance in transformed configuration - specular
+	return PolygonRadiance(LTransformed) * amplitude;
+}
+
+half3 CalculateLight (half3 position, half3 diffColor, half3 specColor, half oneMinusRoughness, half3 N,
+	half3 lightPos, half3 lightColor)
+{
+#if AREA_LIGHT_SHADOWS
+	half shadow = Shadow(position);
+	if (shadow == 0.0)
+		return 0;
+#endif
+	// TODO: larger and smaller values cause artifacts - why?
+	oneMinusRoughness = clamp(oneMinusRoughness, 0.01, 0.93);
+	half roughness = 1 - oneMinusRoughness;
+	half3 V = normalize(_WorldSpaceCameraPos - position);
+
+	// Construct orthonormal basis around N, aligned with V
+	half3x3 basis;
+	basis[0] = normalize(V - N * dot(V, N));
+	basis[1] = normalize(cross(N, basis[0]));
+	basis[2] = N;
+		
+	// Transform light vertices into that space
+	half4x3 L;
+	L = _LightVerts - half4x3(position, position, position, position);
+	L = mul(L, transpose(basis));
+
+	// UVs for sampling the LUTs
+	half theta = acos(dot(V, N));
+	half2 uv = half2(roughness, theta/1.57);
+
+	half3 AmpDiffAmpSpecFresnel = tex2D(_AmpDiffAmpSpecFresnel, uv).rgb;
+
+	half3 result = 0;
+#if AREA_LIGHT_ENABLE_DIFFUSE
+	half diffuseTerm = TransformedPolygonRadiance(L, uv, _TransformInv_Diffuse, AmpDiffAmpSpecFresnel.x);
+	result = diffuseTerm * diffColor;
+#endif
+
+	half specularTerm = TransformedPolygonRadiance(L, uv, _TransformInv_Specular, AmpDiffAmpSpecFresnel.y);
+	half fresnelTerm = specColor + (1.0 - specColor) * AmpDiffAmpSpecFresnel.z;
+	result += specularTerm * fresnelTerm * UNITY_PI;
+
+#if AREA_LIGHT_SHADOWS
+	result *= shadow;
+#endif
+
+	return result * lightColor;
+}

Assets/AreaLight/Shaders/AreaLight.cginc.meta

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

Assets/AreaLight/Shaders/AreaLight.shader

@@ -0,0 +1,110 @@
+Shader "Hidden/AreaLight" {
+SubShader {
+	Tags { "Queue"="Geometry-1" }
+
+CGINCLUDE
+#include "UnityCG.cginc"
+#include "UnityPBSLighting.cginc"
+#include "UnityDeferredLibrary.cginc"
+
+#define AREA_LIGHT_ENABLE_DIFFUSE 1
+
+#if AREA_LIGHT_SHADOWS
+#include "AreaLightShadows.cginc"
+#endif
+#include "AreaLight.cginc"
+
+sampler2D _CameraGBufferTexture0;
+sampler2D _CameraGBufferTexture1;
+sampler2D _CameraGBufferTexture2;
+
+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, baseColor, specColor, oneMinusRoughness, normalWorld,
+		_LightPos.xyz, _LightColor.xyz).rgbb;
+}
+ENDCG
+
+// shadows
+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
+	// only one option, so it will always be set and before any includes
+	#pragma multi_compile AREA_LIGHT_SHADOWS
+
+	fixed4 frag (unity_v2f_deferred i) : SV_Target
+	{
+		return CalculateLightDeferred(i);
+	}
+
+	ENDCG
+}
+
+// no shadows
+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
+	{
+		return CalculateLightDeferred(i);
+	}
+
+	ENDCG
+}
+
+}
+Fallback Off
+}

Assets/AreaLight/Shaders/AreaLight.shader.meta

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

Assets/AreaLight/Shaders/AreaLightShadows.cginc

@@ -0,0 +1,103 @@
+cbuffer POISSON_DISKS {
+	static half2 poisson[40] = {
+		half2(0.02971195f, 0.8905211f),
+		half2(0.2495298f, 0.732075f),
+		half2(-0.3469206f, 0.6437836f),
+		half2(-0.01878909f, 0.4827394f),
+		half2(-0.2725213f, 0.896188f),
+		half2(-0.6814336f, 0.6480481f),
+		half2(0.4152045f, 0.2794172f),
+		half2(0.1310554f, 0.2675925f),
+		half2(0.5344744f, 0.5624411f),
+		half2(0.8385689f, 0.5137348f),
+		half2(0.6045052f, 0.08393857f),
+		half2(0.4643163f, 0.8684642f),
+		half2(0.335507f, -0.110113f),
+		half2(0.03007669f, -0.0007075319f),
+		half2(0.8077537f, 0.2551664f),
+		half2(-0.1521498f, 0.2429521f),
+		half2(-0.2997617f, 0.0234927f),
+		half2(0.2587779f, -0.4226915f),
+		half2(-0.01448214f, -0.2720358f),
+		half2(-0.3937779f, -0.228529f),
+		half2(-0.7833176f, 0.1737299f),
+		half2(-0.4447537f, 0.2582748f),
+		half2(-0.9030743f, 0.406874f),
+		half2(-0.729588f, -0.2115215f),
+		half2(-0.5383645f, -0.6681151f),
+		half2(-0.07709587f, -0.5395499f),
+		half2(-0.3402214f, -0.4782109f),
+		half2(-0.5580465f, 0.01399586f),
+		half2(-0.105644f, -0.9191031f),
+		half2(-0.8343651f, -0.4750755f),
+		half2(-0.9959937f, -0.0540134f),
+		half2(0.1747736f, -0.936202f),
+		half2(-0.3642297f, -0.926432f),
+		half2(0.1719682f, -0.6798802f),
+		half2(0.4424475f, -0.7744268f),
+		half2(0.6849481f, -0.3031401f),
+		half2(0.5453879f, -0.5152272f),
+		half2(0.9634013f, -0.2050581f),
+		half2(0.9907925f, 0.08320642f),
+		half2(0.8386722f, -0.5428791f)
+	};
+};
+
+Texture2D _Shadowmap;
+SamplerComparisonState sampler_Shadowmap;
+
+// To get a sampler, which doesn't do comparison
+Texture2D _ShadowmapDummy;
+SamplerState sampler_ShadowmapDummy;
+
+half _ShadowReceiverWidth;
+half _ShadowReceiverDistanceScale;
+half2 _ShadowLightWidth;
+half _ShadowBias;
+float4x4 _ShadowProjectionMatrix;
+
+half EdgeSmooth(half2 xy)
+{
+	// Magic tweaks to the shape
+	float corner = 0.4;
+	float outset = 1.0;
+	float smooth = 0.5;
+
+	float d = length(max(abs(xy) - 1 + corner*outset, 0.0)) - corner;
+	return saturate(1 - smoothstep(-smooth, 0, d));	
+}
+
+half Shadow(half3 position)
+{
+	half4 pClip = mul(_ShadowProjectionMatrix, half4(position, 1));
+	half3 p = pClip.xyz/pClip.w;
+	if (any(step(1.0, abs(p.xy))))
+		return 0;
+
+	// The texture contains just 0. But we need to sample it somewhere for Unity to initialize the corresponding sampler.
+	float dist = _ShadowmapDummy.Sample(sampler_ShadowmapDummy, 0).a;
+
+	half edgeSmooth = EdgeSmooth(p.xy);
+	p = p * 0.5 + 0.5;
+
+	for(int j = 0; j < 10; ++j)
+	{
+		half2 offset = poisson[j + 24] * _ShadowReceiverWidth;
+		float depth = _Shadowmap.SampleLevel(sampler_ShadowmapDummy, p.xy + offset, 0).r;
+
+		dist += max(0.0, p.z - depth);
+	}
+
+	dist *= _ShadowReceiverDistanceScale;
+
+	p.z -= _ShadowBias/pClip.w;
+	half shadow = 0;
+	for(int i = 0; i < 32; ++i)
+	{
+		half lightWidth = lerp(_ShadowLightWidth.x, _ShadowLightWidth.y, min(1.0, dist));
+		const half2 offset = poisson[i] * lightWidth;
+		shadow += _Shadowmap.SampleCmpLevelZero(sampler_Shadowmap, p.xy + offset, p.z);
+	} 
+
+	return shadow * edgeSmooth / 32.0;
+}

Assets/AreaLight/Shaders/AreaLightShadows.cginc.meta

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

Assets/AreaLight/Shaders/AreaLightSource.mat

@@ -0,0 +1,184 @@
+%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: AreaLightSource
+  m_Shader: {fileID: 46, guid: 0000000000000000f000000000000000, type: 0}
+  m_ShaderKeywords: _EMISSION
+  m_LightmapFlags: 1
+  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
+    - first:
+        name: _GlossyReflections
+      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: _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, g: 0, b: 0, 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/AreaLight/Shaders/AreaLightSource.mat.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 1eb056d70e23cc34a9e926d8c8c887a5
+timeCreated: 1450296949
+licenseType: Pro
+NativeFormatImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: