Shader "Futile/SRLighting" {

	Properties {
		_MainTex ("Base RGBA", 2D) = "white" {}
		_NormalTex ("Normalmap", 2D) = "bump" {}
		_Color ("Diffuse Material Color", Color) = (1.0, 1.0, 1.0, 1.0)
		_SpecularColor ("Specular Material Color", Color) = (1.0, 1.0, 1.0, 1.0)
		_Shininess ("Shininess", Float) = 5
	}

	SubShader {
		// these are applied to all of the Passes in this SubShader
		ZWrite Off
		ZTest Always
		Fog { Mode Off }
		Lighting On
		Cull Off

		// -------------------------------------
		// Base pass:
		// -------------------------------------
		Pass {

			Tags { "LightMode" = "ForwardBase" "Queue"="Transparent" "IgnoreProjector"="True" "RenderType"="Transparent" }
			Blend SrcAlpha OneMinusSrcAlpha

CGPROGRAM

#pragma vertex vert
#pragma fragment frag

#include "UnityCG.cginc"

uniform sampler2D _MainTex;

struct VertexInput {

	float4 vertex : POSITION;
	float4 color : COLOR;
	float4 uv : TEXCOORD0;
};

struct VertexOutput {

	float4 pos : POSITION;
	float4 color : COLOR;
	float2 uv : TEXCOORD0;
};

VertexOutput vert(VertexInput i){

	VertexOutput o;

	o.pos = mul(UNITY_MATRIX_MVP, i.vertex);
	o.color = i.color;
	o.uv = float2(i.uv);

	return o;
}

float4 frag(VertexOutput i) : COLOR {

	float4 diffuseColor = tex2D(_MainTex, i.uv);
	float3 ambientLighting = float3(UNITY_LIGHTMODEL_AMBIENT) * float3(diffuseColor) * float3(i.color);

	return float4(ambientLighting, diffuseColor.a);
}

ENDCG
		}

		// -------------------------------------
		// Lighting Pass: Lights must be set to Important
		// -------------------------------------
		Pass {

			Tags { "LightMode" = "ForwardAdd" "Queue"="Transparent" "IgnoreProjector"="True" "RenderType"="Transparent" }
			Blend One One // additive blending

CGPROGRAM

#pragma vertex vert
#pragma fragment frag

#include "UnityCG.cginc"

// shader uniforms
uniform sampler2D _MainTex;   // source diffuse texture
uniform sampler2D _NormalTex; // normal map lighting texture (set to import type: Lightmap)
uniform float4 _LightColor0;  // color of light source
uniform float4 _SpecularColor;
uniform float _Shininess;

struct vertexInput {
	float4 vertex : POSITION;
	float4 color : COLOR;
	float4 uv : TEXCOORD0;
};

struct fragmentInput {
	float4 pos : SV_POSITION;
	float4 color : COLOR0;
	float2 uv : TEXCOORD0;
	float4 posWorld : TEXCOORD1; // change this to distance to light and pass from vert to frag
};

// -------------------------------------
fragmentInput vert(vertexInput i){

	fragmentInput o;

	o.pos = mul(UNITY_MATRIX_MVP, i.vertex);
	o.posWorld = mul(_Object2World, i.vertex);

	o.uv = float2(i.uv);
	o.color = i.color;

	return o;
}

// -------------------------------------
float4 frag(fragmentInput i) : COLOR {

	// get value from normal map and sub 0.5 and mul by 2 to change RGB range 0..1 to normal range -1..1
	float3 normalDirection = (tex2D(_NormalTex, i.uv).xyz - 0.5f) * 2.0f;

	// mul by world to object matrix, which handles rotation, etc
	normalDirection = float3(mul(float4(normalDirection, 0.5f), _World2Object));

	// negate Z so that lighting works as expected (sprites further away from the camera than a light are lit, etc.)
	normalDirection.z *= -1;

	// normalize direction
	normalDirection = normalize(normalDirection);

	// dist to point light
	float3 vertexToLightSource = float3(_WorldSpaceLightPos0) - i.posWorld;
	float3 distance = length(vertexToLightSource);

	// calc attenuation
	float attenuation = 1.0 / distance;
	float3 lightDirection = normalize(vertexToLightSource);

	// calc diffuse lighting
	float normalDotLight = dot(normalDirection, lightDirection);
	float diffuseLevel = attenuation * max(0.0, normalDotLight);

	// calc specular ligthing
	float specularLevel = 0.0;
	// make sure the light is on the proper side
	if (normalDotLight > 0.0){

		// since orthographic
		float3 viewDirection = float3(0.0, 0.0, -1.0);
		specularLevel = attenuation * pow(max(0.0, dot(reflect(-lightDirection, normalDirection), viewDirection)), _Shininess);
	}

	// calc color components
	float4 diffuseColor = tex2D(_MainTex, i.uv);
	float3 diffuseReflection = float3(diffuseColor) * diffuseLevel * i.color * float3(_LightColor0);
	float3 specularReflection = float3(_SpecularColor) * specularLevel * i.color * float3(_LightColor0);

	// use the alpha from diffuse. mul by diffuseColor.a to resolve issues with transparency on overlapping sprites in same FRenderLayer
	return diffuseColor.a * float4(diffuseReflection + specularReflection, diffuseColor.a);
}

ENDCG
		} // end Pass
// -------------------------------------
// -------------------------------------

	} // end SubShader

	// fallback shader - comment out during dev
	// Fallback "Diffuse"
}

using UnityEngine;

// ------------------------------------------------------------------------
// Supports normal mapped lighting
// ------------------------------------------------------------------------
public class SRLightingShader : FShader {

	private string _normalTexture;
	private float _shininess;
	private Color _diffuseColor;
	private Color _specularColor;

	// ------------------------------------------------------------------------
	// normalTexture = full path/name to normal map for corresponding main texture for this mat: e.g. Images/tiles_n
	// ------------------------------------------------------------------------
	public SRLightingShader(string normalTexture, float shininess, Color diffuseColor, Color specularColor) :
						base("SRLighting", Shader.Find("Futile/SRLighting")){

		// assign parms
		_normalTexture = normalTexture;
		_shininess = shininess;
		_diffuseColor = diffuseColor;
		_specularColor = specularColor;

		// ensure Apply gets called
		needsApply = true;
	}

	// ------------------------------------------------------------------------
	// applies these parameters to the material for the shader
	// ------------------------------------------------------------------------
	override public void Apply(Material mat){

		// load normal texture for this shader
		Texture2D normalTex = Resources.Load(_normalTexture) as Texture2D;
		mat.SetTexture("_NormalTex", normalTex);
		mat.SetFloat("_Shininess", _shininess);
		mat.SetColor("_Color", _diffuseColor); // diffuse
		mat.SetColor("_SpecColor", _specularColor);
	}
}

// SRLightingShader(string normalTexture, float shininess, Color diffuseColor, Color specularColor)
SRLightingShader lightingShader = new SRLightingShader(ROCKS_NORMAL, 2.5f, Color.white, Color.white);

// sprite uses the SRLightingShader for normal mapped lighting
FSprite rockSprite = new FSprite(ROCKS_SPRITE);
// all sprites in same atlas must use same shader instance to properly batch
rockSprite.shader = lightingShader;
Futile.stage.AddChild(rockSprite);

// add light gameobject
lightGameObject = new GameObject("Light");
lightGameObject.transform.localPosition = new Vector3(0, 0, lightDepth);

// add lightsource to it and configure
lightSource = lightGameObject.AddComponent<Light>();
lightSource.color = Color.white;
lightSource.intensity = 8;
lightSource.range = 375;
lightSource.type = LightType.Point;
lightSource.renderMode = LightRenderMode.ForcePixel; // ForcePixel = Important

		// use the alpha from diffuse. mul by diffuseColor.a to resolve issues with transparency on overlapping sprites in same FRenderLayer
		return diffuseColor.a * float4(diffuseReflection + specularReflection, diffuseColor.a);