LuminousUnity.shader

// Copyright (c) Microsoft Corporation. All rights reserved.
// Licensed under the MIT License. See LICENSE in the project root for license information.

// Unity port of HoloFX Shell shader
//
// v0.1 Mathew Lamb
// based upon work by Doug Service
//
// This shader implements the surface properties of the Prototype Shader, implemented in
// the Fulcrum render engine. It does so shackled by Unity's lighting engine which limits the
// number and type of lights used in a render pass.
//
// It is a two pass shader, the first pass computes the major Directional light and all additive
// sources (emission, reflection etc), the second pass captures the first 4 spot lights.
//
// All computation based upon lighting is code-identical to the HLSL equivalent.
//
// To Do:
// - implement lights as parameters to the shader and wrap filling in the relevant values with a script
//   run from within Unity

Shader "Custom/MayaHLSL4" {
	Properties {
		_fDiffuseIntensity("Diffuse Intensity", Float) = 1
		_cAlbedo("Albedo Color", Color) = (0.0,0.0,0.0)
		_txAlbedo("Albedo Texture (RGB Texture)", 2D) = "white" {}
		_bEnableHalfLambert("Half Lambert Toggle",Range(0,1)) = 0
		_fHalfLambertExp("Half Lambert Exponent", Float) = 1

		_cSpecular("Specular Color", Color) = (0.0,0.0,0.0)
		_txSpecular("Specular Texture (RGB Texture)", 2D) = "white" {}
		_fSpecularPower("Specular Power", Float) = 1
		_bEnableFresnel("Fresnel Toggle",Range(0,1)) = 0
		_bEnableAlphaFresnel("Alpha Fresnel Toggle",Range(0,1)) = 0
		_fFresnelExp("Fresnel Exponent", Float) = 1
		_fFresnelMin("Fresnel Minimum", Float) = 1
		_cReflection("Reflection Color", Color) = (0.0,0.0,0.0)
		_txReflection("Reflection Texture (RGB Cubemap)", Cube) = "white" {}

		_cEmission("Emission Color", Color) = (0.0,0.0,0.0)
		_txEmission("Emission Texture (RGB Texture)", 2D) = "white" {}

		_cAmbient("Ambient Color", Color) = (0.0,0.0,0.0)
		_txAmbient("Ambient Texture (RGB Cubemap)", Cube) = "white" {}

		_fAlphaScale("Alpha Scale", Float) = 1
		_txAlpha("Alpha Texture (RGB Texture)", 2D) = "white" {}

		_txOcclusion("Occlusion Texture (RGB Texture)", 2D) = "white" {}

		_txNormal("Normal Texture (RGB Texture)", 2D) = "white" { TexGen CubeNormal }
	}

	SubShader {
		Tags {
			"Queue" = "Transparent"
			"RenderType" = "Transparent"
		}

		// 1 directional light and 4 point lights go with this pass
		// total Unity nastiness
		// all reflective and emissive terms are here as this pass is only evaluated once
		Pass {
			Tags {
				"LightMode" = "ForwardBase"
			}

			Cull Back
			Lighting On
			ZWrite On
			ZTest LEqual
			Blend SrcAlpha OneMinusSrcAlpha

			CGPROGRAM

			#pragma only_renderers d3d11
			#pragma vertex vert
			#pragma fragment frag
			#pragma multi_compile_fwdbase

			#pragma target 5.0

			#include "UnityCG.cginc"
			#include "AutoLight.cginc"

			uniform float4 _LightColor0;	// color of light source - from Lighting.cginc

			uniform float3 _cEmission;
			uniform float3 _cAmbient;
			uniform float3 _cAlbedo;
			uniform float3 _cSpecular;
			uniform float3 _cReflection;

			uniform float _fDiffuseIntensity;
			uniform float _fSpecularPower;
			uniform float _fHalfLambertExp;
			uniform float _fFresnelMin;
			uniform float _fFresnelExp;
			uniform float _fAlphaScale;

			uniform bool _bEnableFresnel;
			uniform bool _bEnableAlphaFresnel;
			uniform bool _bEnableHalfLambert;

			uniform sampler2D _txEmission;
			uniform samplerCUBE _txAmbient;
			uniform sampler2D _txOcclusion;
			uniform sampler2D _txAlbedo;
			uniform sampler2D _txNormal;
			uniform sampler2D _txSpecular;
			uniform samplerCUBE _txReflection;
			uniform sampler2D _txAlpha;

			struct VsIn {
				float4 vPosition 		: POSITION;
				float4 vTangent	 		: TANGENT;
				float3 vNormal 			: NORMAL;
				float4 vTexCoord0 		: TEXCOORD0;
			};

			struct Vs2Ps {
				float4 vPosition 		: SV_POSITION;
				float3 vWorldPosition	: TEXCOORD0;
				float3 vToEye 			: TEXCOORD1;
				float3 vWorldNormal 	: TEXCOORD2;
				float3 vWorldTangent 	: TEXCOORD3;
				float3 vWorldBitangent 	: TEXCOORD4;
				float2 vTexCoord0 		: TEXCOORD5;
			};

			Vs2Ps vert(in VsIn vsIn)
			{
				Vs2Ps vsOut;

				// vertex from model space to view space and world space
				// normally a geometry shader would come next, in which case we would only go to world space
				vsOut.vPosition = UnityObjectToClipPos(vsIn.vPosition);
				vsOut.vWorldPosition = mul(unity_ObjectToWorld,vsIn.vPosition).xyz;

				vsOut.vToEye = normalize(WorldSpaceViewDir(vsIn.vPosition));

				// tangent space basis vector from model space to view space
				// normally a geometry shader would come next, in which case we would only go to world space
				vsOut.vWorldNormal = normalize(mul((float3x3)unity_ObjectToWorld,vsIn.vNormal));
				vsOut.vWorldTangent = normalize(mul((float3x3)unity_ObjectToWorld,vsIn.vTangent));
				float3 BiTangent = cross(vsIn.vNormal,vsIn.vTangent.xyz) * vsIn.vTangent.w;
				vsOut.vWorldBitangent = normalize(mul((float3x3)unity_ObjectToWorld,BiTangent));

				// pass through the texture coordinates
				vsOut.vTexCoord0 = vsIn.vTexCoord0;

				return vsOut;
			}

			//
			// wrap-around lambertian
			//
			float HalfLambert(float nDotL)
			{
				return saturate((nDotL + _fHalfLambertExp) / ((1 + _fHalfLambertExp) * (1 + _fHalfLambertExp)));
			}

			//
			// this class is the per-light computation of the illuminance
			//
			class Material
			{

				// Material properties used in lighting calculation.
				float  fFresnelMin;
				float  fFresnelExp;
				float  fSpecPower;
				float3 cSpecular;
				float3 cAlbedo;
				float3 cOcclusion;
				float3 cResult;

				void Illuminate(
					in float3 nVertex,     // Iterated world space vertex normal
					in float3 nLight,      // World space surface normal for lighting
					in float3 vToLight,    // Direction to light.
					in float3 vToEye,      // Direction to the eye.
					in float3 cIrradiance  // Light irradiance.
					)
				{
					//
					// this next piece of code is the fulcrum illuminance loop
					//

					float nDotL = dot(nLight,vToLight);	// normal due to the normal map
					float nDotLVert = dot(nVertex,vToLight); // interpolated vertex normal

					// calculate the reflection vector from the light
					float3 vReflect = 2.0f * nDotL * nLight - vToLight;

					// Calculate the diffuse intensity and clamp lighting 
					// on backside normal map normals.
					float fBackClamp = 1.0;
					float fIDiffuse = 0.0;

					if (_bEnableHalfLambert)
					{
						fBackClamp = HalfLambert(nDotLVert);
						fIDiffuse = _fDiffuseIntensity * fBackClamp;
					}
					else
					{
						fBackClamp = step(0, nDotLVert);
						fIDiffuse = fBackClamp * _fDiffuseIntensity * saturate(nDotL);
					}

					// Calculate the Fresnel term for the light.
					float2 vCoeff = float2(1, 1);
					if (_bEnableFresnel)
					{
						float fReflect = _fFresnelMin + (1.0 - _fFresnelMin) * pow(1.0 - fIDiffuse, _fFresnelExp);
						vCoeff = float2(1 - fReflect, fReflect);
					}

					// Calculate the specular intensity.
					float fISpecular = fBackClamp* pow(saturate(dot(vReflect, vToEye)), _fSpecularPower);

					//
					// bring the two color computations together
					//
					cResult = cOcclusion * cIrradiance * (vCoeff.x * fIDiffuse * cAlbedo + vCoeff.y * fISpecular * cSpecular);
				}
			};

			float4 frag(in Vs2Ps psIn) : SV_TARGET
			{
				float gamma = 1.0;

				//
				// the following code is more-or-less lifted straight from the fulcrum shader
				// cubemap implementation differs
				//

				// read emissive, ambient, diffuse and specular maps
				// correct gamma to linear
				float3 ctEmission = pow(tex2D(_txEmission, psIn.vTexCoord0).rgb, gamma);
				float3 ctOcclusion = pow(tex2D(_txOcclusion, psIn.vTexCoord0).rgb, gamma);
				float3 ctAlbedo = pow(tex2D(_txAlbedo, psIn.vTexCoord0).rgb, gamma);
				float3 ctSpecular = pow(tex2D(_txSpecular, psIn.vTexCoord0).rgb, gamma);

				// read normal map and Eye, Normal, Tangent and Bitangent vectors
				// from the vertex shader data structure
				float3 vtNormal = tex2D(_txNormal, psIn.vTexCoord0).rgb;
				float3 vToEye = normalize(psIn.vToEye);
				float3 nVertex = normalize(psIn.vWorldNormal);
				float3 nTangent = normalize(psIn.vWorldTangent);
				float3 nBitangent = normalize(psIn.vWorldBitangent);

				// convert the normal map from normalized range [0,1] to [-1,1]
				vtNormal.xyz = 2 * vtNormal - 1;

				// build the tangent space to world space transform and transform
				// the normal map normal from tangent space to world space
				float3x3 mTangentToWorld = { nTangent, nBitangent, nVertex };
				float3 nLight = mul(vtNormal, mTangentToWorld);
				nLight = normalize(nLight);

				// get the ambient illumination along the normal
				float3 ctAmbient = pow(texCUBE(_txAmbient, nLight).rgb, gamma);

				// calculate the eye reflection vector and get reflection map color
				float3 vEyeReflect = 2.0f * dot(nLight,vToEye) * nLight - vToEye;
				float3 ctReflection = pow(texCUBE(_txReflection,vEyeReflect).rgb, gamma);

				// add the emissive and ambient irradiance colorized by albedo
				float3 cOut = _cEmission * ctEmission + _cAmbient * ctAmbient * ctOcclusion * _cAlbedo * ctAlbedo;

				// at this point in the fulcrum shader the illuminance loop is called
				// due to the idiosyncrasies of Unity at this point we sample the one light that is known to be calling
				// this shader - a  single directional light
				// additional (spot) lights are computed in the next pass
				// in this pass we compute the light due to the directional and all non-light related quantities

				// work with the directional light (if it exists) - compute its direction and attenuation
				float3 L;
				float atten;
				if (0.0 == _WorldSpaceLightPos0.w)   // directional light
				{
					atten = 1.0;
					L = normalize(float3(_WorldSpaceLightPos0.xyz));
				}
				else
				{
					L = float3(_WorldSpaceLightPos0 - psIn.vWorldPosition);
					float dist = length(L);
					atten = 1.0 / dist;
					L = normalize(L);
				}

				// hide the material characteristics in class and call its Illuminate() method
				// to light it
				Material obj;
				obj.fFresnelMin = _fFresnelMin;
				obj.fFresnelExp = _fFresnelExp;
				obj.fSpecPower = _fSpecularPower;
				obj.cSpecular = ctSpecular * _cSpecular;
				obj.cAlbedo = ctAlbedo * _cAlbedo;
				obj.cOcclusion = ctOcclusion;
				obj.cResult = float3(0,0,0);

				obj.Illuminate(nVertex,nLight,L,vToEye,float3(_LightColor0.rgb) * atten);

				cOut = cOut + obj.cResult;

				// transparency - modulated by the 'r' channel of the Alpha texture
				float alpha = _fAlphaScale * tex2D(_txAlpha,psIn.vTexCoord0).r;


				// calculate the Fresnel term for the reflected light
				float fFresnelReflect = lerp(1.0f, _fFresnelMin + (1.0f - _fFresnelMin) *
					pow(1.0f - saturate(dot(vEyeReflect,nLight)), _fFresnelExp), _bEnableFresnel);
				cOut += fFresnelReflect * ctSpecular * _cReflection * ctReflection;

				return float4(cOut,alpha);
			}

			ENDCG
		}

		// additional light sources
		// and all light sources with cookies - i.e. spot lights - for these use cookies to achieve the correct angle
		Pass {
			Tags {
				"LightMode" = "ForwardAdd"
			}
			Blend One One		// additive blending for additional lights

			CGPROGRAM

			#pragma only_renderers d3d11
			#pragma vertex vert
			#pragma fragment frag
			#pragma multi_compile_fwdbase

			#pragma target 5.0

			#include "UnityCG.cginc"
			#include "AutoLight.cginc"

			uniform float4 _LightColor0;	// color of light source - from Lighting.cginc

			uniform float3 _cAlbedo;
			uniform float3 _cSpecular;

			uniform float _fDiffuseIntensity;
			uniform float _fSpecularPower;
			uniform float _fHalfLambertExp;
			uniform float _fFresnelMin;
			uniform float _fFresnelExp;
			uniform float _fAlphaScale;

			uniform bool _bEnableFresnel;
			uniform bool _bEnableAlphaFresnel;
			uniform bool _bEnableHalfLambert;

			uniform sampler2D _txOcclusion;
			uniform sampler2D _txAlbedo;
			uniform sampler2D _txNormal;
			uniform sampler2D _txSpecular;
			uniform sampler2D _txAlpha;

			struct VsIn {
				float4 vPosition 		: POSITION;
				float4 vTangent	 		: TANGENT;
				float3 vNormal 			: NORMAL;
				float4 vTexCoord0 		: TEXCOORD0;
			};

			struct Vs2Ps {
				float4 vPosition 		: SV_POSITION;
				float3 vWorldPosition	: TEXCOORD0;
				float3 vToEye 			: TEXCOORD1;
				float3 vWorldNormal 	: TEXCOORD2;
				float3 vWorldTangent 	: TEXCOORD3;
				float3 vWorldBitangent 	: TEXCOORD4;
				float2 vTexCoord0 		: TEXCOORD5;
				LIGHTING_COORDS(6,7)
			};

			Vs2Ps vert(in VsIn vsIn)
			{
				Vs2Ps vsOut;

				// vertex from model space to view space and world space
				// normally a geometry shader would come next, in which case we would only go to world space
				vsOut.vPosition = UnityObjectToClipPos(vsIn.vPosition);
				vsOut.vWorldPosition = mul(unity_ObjectToWorld,vsIn.vPosition).xyz;

				vsOut.vToEye = normalize(WorldSpaceViewDir(vsIn.vPosition));

				// tangent space basis vector from model space to view space
				// normally a geometry shader would come next, in which case we would only go to world space
				vsOut.vWorldNormal = normalize(mul((float3x3)unity_ObjectToWorld,vsIn.vNormal));
				vsOut.vWorldTangent = normalize(mul((float3x3)unity_ObjectToWorld,vsIn.vTangent));
				float3 BiTangent = cross(vsIn.vNormal,vsIn.vTangent.xyz) * vsIn.vTangent.w;
				vsOut.vWorldBitangent = normalize(mul((float3x3)unity_ObjectToWorld,BiTangent));

				// pass through the texture coord
				vsOut.vTexCoord0 = vsIn.vTexCoord0;

				return vsOut;
			}

			// wrap-around lambertian
			float HalfLambert(float nDotL)
			{
				return saturate((nDotL + _fHalfLambertExp) / ((1 + _fHalfLambertExp) * (1 + _fHalfLambertExp)));
			}

			//
			// this class is the per-light computation of the illuminance
			//
			class Material
			{
				// Material properties used in lighting calculation.
				float  fFresnelMin;
				float  fFresnelExp;
				float  fSpecPower;
				float3 cSpecular;
				float3 cAlbedo;
				float3 cOcclusion;
				float3 cResult;

				void Illuminate(
					in float3 nVertex,     // Iterated world space vertex normal
					in float3 nLight,      // World space surface normal for lighting
					in float3 vToLight,    // Direction to light.
					in float3 vToEye,      // Direction to the eye.
					in float3 cIrradiance  // Light irradiance.
					)
				{
					// this next piece of code is the fulcrum illuminance loop

					float nDotL = dot(nLight,vToLight);	// normal due to the normal map
					float nDotLVert = dot(nVertex,vToLight); // interpolated vertex normal

					// calculate the reflection vector from the light
					float3 vReflect = 2.0f * nDotL * nLight - vToLight;

					// Calculate the diffuse intensity and clamp lighting 
					// on backside normal map normals.
					float fBackClamp = 1.0;
					float fIDiffuse = 0.0;

					if (_bEnableHalfLambert)
					{
						fBackClamp = HalfLambert(nDotLVert);
						fIDiffuse = _fDiffuseIntensity * fBackClamp;
					}
					else
					{
						fBackClamp = step(0, nDotLVert);
						fIDiffuse = fBackClamp * _fDiffuseIntensity * saturate(nDotL);
					}

					// Calculate the Fresnel term for the light.
					float2 vCoeff = float2(1, 1);
					if (_bEnableFresnel)
					{
						float fReflect = _fFresnelMin + (1.0 - _fFresnelMin) * pow(1.0 - fIDiffuse, _fFresnelExp);
						vCoeff = float2(1 - fReflect, fReflect);
					}

					// Calculate the specular intensity.
					float fISpecular = fBackClamp * pow(saturate(dot(vReflect, vToEye)), _fSpecularPower);

					// bring the two color computations together
					cResult = cOcclusion * cIrradiance * (vCoeff.x * fIDiffuse * _cAlbedo + vCoeff.y * fISpecular * _cSpecular);
				}
			};

			float4 frag(in Vs2Ps psIn) : SV_TARGET
			{

				// the following code is more-or-less lifted straight from the fulcrum shader
				// cubemap implementation differs

				// read emissive, ambient, diffuse and specular maps
				// correct gamma to linear
				float3 ctOcclusion = pow(tex2D(_txOcclusion, psIn.vTexCoord0).rgb, 2.2);
				float3 ctAlbedo = pow(tex2D(_txAlbedo, psIn.vTexCoord0).rgb, 2.2);
				float3 ctSpecular = pow(tex2D(_txSpecular, psIn.vTexCoord0).rgb, 2.2);

				// read normal map and Eye, Normal, Tangent and Bitangent vectors
				// from the vertex shader data structure
				float3 vtNormal = tex2D(_txNormal, psIn.vTexCoord0).rgb;
				float3 V = normalize(psIn.vToEye);
				float3 nVertex = normalize(psIn.vWorldNormal);
				float3 nTangent = normalize(psIn.vWorldTangent);
				float3 nBitangent = normalize(psIn.vWorldBitangent);

				// convert the normal map from normalized range [0,1] to [-1,1]
				vtNormal.xyz = 2 * vtNormal - 1;

				// build the tangent space to world space transform and transform
				// the normal map normal from tangent space to world space
				float3x3 mTangentToWorld = { nTangent, nBitangent, nVertex };
				float3 N = mul(vtNormal, mTangentToWorld);
				N = normalize(N);

				// calculate the eye reflection vector and get reflection map color
				float3 vEyeReflect = 2.0f * dot(N,V) * N - V;

				// at this point in the fulcrum shader the illuminance loop is called
				// due to the idiosyncrasies of Unity at this point we sample the one light that is known to be calling
				// this shader - a  single directional light
				// additional (spot) lights are computed in the next pass
				// in this pass we compute the light due to the directional and all non-light related quantities

				// work with the directional light (if it exists) - compute its direction and attenuation
				float3 L;
				float atten;
				if (0.0 == _WorldSpaceLightPos0.w)   // directional light
				{
					atten = 1.0;
					L = normalize(float3(_WorldSpaceLightPos0.xyz));
				}
				else
				{
					L = float3(_WorldSpaceLightPos0 - psIn.vWorldPosition);
					float dist = length(L);
					atten = 1.0 / dist;
					L = normalize(L);
				}

				// hide the material characteristics in class and call its Illuminate() method
				// to light it
				Material obj;
				obj.fFresnelMin = _fFresnelMin;
				obj.fFresnelExp = _fFresnelExp;
				obj.fSpecPower = _fSpecularPower;
				obj.cSpecular = ctSpecular * _cSpecular;
				obj.cAlbedo = ctAlbedo * _cAlbedo;
				obj.cOcclusion = ctOcclusion;
				obj.cResult = float3(0,0,0);

				obj.Illuminate(nVertex,N,L,V,float3(_LightColor0.rgb) * atten);

				float3 cOut = obj.cResult;

				// transparency - modulated by the 'r' channel of the Alpha texture
				float alpha = _fAlphaScale * tex2D(_txAlpha,psIn.vTexCoord0).r;

				//cOut=float3(0,0,0);

				return float4(cOut,alpha);
			}
			ENDCG
		}
	}
}