RMIT
/
vr-space-station


								//

								// OvrAvatar Mobile combined mesh expressive shader

								// For use on expressive face meshes

								// Texture array approach for rendering a combined mesh avatar with blend shape expression

								// Coupled with OvrAvatarMaterialManager to populate the texture arrays

								//

								// Unity vertex-fragnment implementation

								// Simplified lighting model recommended for use on mobile supporting one directional light

								// Surface shader recommended on PC

								//

								// Uses transparent queue for fade effects

								//

								// Color and appearance of the facial regions controlled via G&B channels in roughness texture

								// Pupil size controlled by manipulating UV coordinates

								//

								// Shader keywords:

								// - SECONDARY_LIGHT_ON SECONDARY_LIGHT_OFF

								//   Enable SECONDARY_LIGHT_ON for a second "light" comprised of _SecondaryLightDirection and

								//   _SecondaryLightColor This will influence the rim effect providing a lit contour to the avatar

								//


								Shader "OvrAvatar/Avatar_Mobile_CombinedMeshExpressive"

								{

								    Properties

								    {

								        [NoScaleOffset] _MainTex("Main Texture Array", 2DArray) = "white" {}

								        [NoScaleOffset] _NormalMap("Normal Map Array", 2DArray) = "bump" {}

								        [NoScaleOffset] _RoughnessMap("Roughness Map Array", 2DArray) = "black" {}


								        _Dimmer("Dimmer", Range(0.0,1.0)) = 1.0

								        _Alpha("Alpha", Range(0.0,1.0)) = 1.0


								        // Index into the texture array needs an offset for precision

								        _Slices("Texture Array Slices", int) = 4.97


								        _PupilSize("Pupil Size", Range(-1, 2)) = 0

								        _LipSmoothness("Lip Smoothness", Range(0, 1)) = 0


								        _MaskColorIris("Iris Color", Color) = (0.0,0.0,0.0,1.0)

								        _MaskColorLips("Lips Color", Color) = (0.0,0.0,0.0,1.0)

								        _MaskColorBrows("Brows Color", Color) = (0.0,0.0,0.0,1.0)

								        _MaskColorLashes("Lashes Color", Color) = (0.0,0.0,0.0,1.0)

								        _MaskColorSclera("Sclera Color", Color) = (0.0,0.0,0.0,1.0)

								        _MaskColorGums("Gums Color", Color) = (0.0,0.0,0.0,1.0)

								        _MaskColorTeeth("Teeth Color", Color) = (0.0,0.0,0.0,1.0)


								        [HideInInspector] _SrcBlend("", Float) = 1

								        [HideInInspector] _DstBlend("", Float) = 0

								    }


								    SubShader

								    {

								        Tags { "LightMode" = "ForwardBase" "IgnoreProjector" = "True"}

								        Pass

								        {

								            Blend [_SrcBlend] [_DstBlend]

								            Cull Back

								            CGPROGRAM

								            #pragma vertex vert

								            #pragma fragment frag

								            #pragma target 3.5

								            #pragma fragmentoption ARB_precision_hint_fastest

								            #pragma multi_compile SECONDARY_LIGHT_OFF SECONDARY_LIGHT_ON

								            #include "UnityCG.cginc"

								            #include "UnityLightingCommon.cginc"


								            UNITY_DECLARE_TEX2DARRAY(_MainTex);

								            UNITY_DECLARE_TEX2DARRAY(_NormalMap);

								            float4 _NormalMap_ST;

								            UNITY_DECLARE_TEX2DARRAY(_RoughnessMap);


								            int _Slices;


								            half _Dimmer;

								            half _Alpha;


								            half4 _BaseColor[5];

								            half _DiffuseIntensity[5];

								            half _RimIntensity[5];

								            half _ReflectionIntensity[5];


								            half3 _SecondaryLightDirection;

								            half4 _SecondaryLightColor;


								            half _PupilSize;

								            half _LipSmoothness;


								            fixed4 _MaskColorIris;

								            fixed4 _MaskColorSclera;

								            fixed4 _MaskColorBrows;

								            fixed4 _MaskColorLashes;

								            fixed4 _MaskColorLashesEnd;

								            fixed4 _MaskColorLips;

								            fixed4 _MaskColorGums;

								            fixed4 _MaskColorTeeth;


								            static const int ONE = 1;

								            static const fixed ALPHA_CLIP_THRESHOLD = 0.7;

								            static const int IRIS_BRIGHTNESS_MODIFIER = 2;

								            static const fixed SCLERA_BRIGHTNESS_MODIFIER = 1.2;

								            static const fixed LIP_SMOOTHNESS_MULTIPLIER = 0.5;

								            static const fixed LIP_SMOOTHNESS_MIN_NDOTL = 0.3;

								            static const fixed BROWS_LASHES_DIFFUSEINTENSITY = ONE - 0.25;

								            static const int COLOR_MULTIPLIER = 255;

								            static const half2 PUPIL_CENTER_UV = half2(0.127, 0.1175);

								            static const half DILATION_ENVELOPE = 0.024;

								            static const half2 EYE_REGION_UV = PUPIL_CENTER_UV + DILATION_ENVELOPE;


								            static const int MASK_SLICE_SIZE = 17;

								            static const half MASK_SLICE_THRESHOLD = MASK_SLICE_SIZE * 0.5f;

								            static const int MASK_INDEX_IRIS = 255;

								            static const int MASK_INDEX_SCLERA = 238;

								            static const int MASK_INDEX_LASHES = 221;

								            static const int MASK_INDEX_LIPS = 204;

								            static const int MASK_INDEX_GUMS = 187;

								            static const int MASK_INDEX_TEETH = 170;

								            static const int MASK_INDEX_BROWS = 153;


								            struct appdata

								            {

								                float4 vertex: POSITION;

								                float3 normal: NORMAL;

								                float4 tangent: TANGENT;

								                float2 texcoord: TEXCOORD0;

								                float4 vertexColor : COLOR0;

								            };


								            struct v2f

								            {

								                float4 pos : SV_POSITION;

								                float3 uv : TEXCOORD0;

								                float4 posWorld: TEXCOORD1;

								                float3 normalDir: TEXCOORD2;

								                float3 tangentDir: TEXCOORD3;

								                float3 bitangentDir: TEXCOORD4;

								            };


								            v2f vert(appdata v)

								            {

								                v2f o;


								                // Calculate tangents for normal mapping

								                o.normalDir = normalize(UnityObjectToWorldNormal(v.normal));

								                o.tangentDir = normalize(mul(unity_ObjectToWorld, half4(v.tangent.xyz, 0.0)).xyz);

								                o.bitangentDir = normalize(cross(o.normalDir, o.tangentDir) * v.tangent.w);


								                o.posWorld = mul(unity_ObjectToWorld, v.vertex);

								                o.pos = UnityObjectToClipPos(v.vertex);

								                o.uv.xy = v.texcoord;

								                o.uv.z = v.vertexColor.x * _Slices;

								                return o;

								            }


								            fixed4 frag(v2f i) : COLOR

								            {

								                // Pupil size offsets uv coords

								                if (all(i.uv.xy < EYE_REGION_UV))

								                {

								                    i.uv.xy -= PUPIL_CENTER_UV;

								                    half pupil = saturate(length(i.uv.xy) / DILATION_ENVELOPE);

								                    i.uv.xy *= lerp(1.0, pupil, _PupilSize);

								                    i.uv.xy += PUPIL_CENTER_UV;

								                }


								                // Diffuse texture sample

								                float4 albedoColor = UNITY_SAMPLE_TEX2DARRAY(_MainTex, i.uv);


								                // Process normal map

								                float3 transformedNormalUV = i.uv;

								                transformedNormalUV.xy = float2(TRANSFORM_TEX(i.uv.xy, _NormalMap));

								                float3 normalMap = UNITY_SAMPLE_TEX2DARRAY(_NormalMap, transformedNormalUV) * 2.0 - ONE;

								                float3x3 tangentTransform = float3x3(i.tangentDir, i.bitangentDir, i.normalDir);

								                float3 normalDirection = normalize(mul(normalMap.rgb, tangentTransform));


								                // Roughness contains metallic in r, smoothness in a, mask region in b and mask control in g

								                half4 roughnessTex = UNITY_SAMPLE_TEX2DARRAY(_RoughnessMap, i.uv);


								                // Normal/Light/View calculations

								                half3 viewDirection = normalize(_WorldSpaceCameraPos.xyz - i.posWorld.xyz);

								                half VdotN = saturate(dot(viewDirection, normalDirection));

								                half NdotL = saturate(dot(normalDirection, normalize(_WorldSpaceLightPos0.xyz)));


								                // Sample the default reflection cubemap using the reflection vector

								                float3 worldReflection = reflect(-viewDirection, normalDirection);

								                half4 skyData = UNITY_SAMPLE_TEXCUBE(unity_SpecCube0, worldReflection);

								                // Decode cubemap data into actual color

								                half3 reflectionColor = DecodeHDR(skyData, unity_SpecCube0_HDR);


								                // Get index into texture array

								                int componentIndex = floor(i.uv.z + 0.5);


								                // Base color from array

								                float4 baseColor = _BaseColor[componentIndex];


								                // Color space conversions if we are in linear

								#ifndef UNITY_COLORSPACE_GAMMA

								                _MaskColorIris.rgb = LinearToGammaSpace(_MaskColorIris.rgb);

								                _MaskColorLips.rgb = LinearToGammaSpace(_MaskColorLips.rgb);

								                _MaskColorBrows.rgb = LinearToGammaSpace(_MaskColorBrows.rgb);

								                _MaskColorLashes.rgb = LinearToGammaSpace(_MaskColorLashes.rgb);

								                _MaskColorLashesEnd.rgb = LinearToGammaSpace(_MaskColorLashesEnd.rgb);

								                _MaskColorSclera.rgb = LinearToGammaSpace(_MaskColorSclera.rgb);

								                _MaskColorGums.rgb = LinearToGammaSpace(_MaskColorGums.rgb);

								                _MaskColorTeeth.rgb = LinearToGammaSpace(_MaskColorTeeth.rgb);

								#endif


								                // Calculate color masks

								                half irisScalar = abs(roughnessTex.b * COLOR_MULTIPLIER - MASK_INDEX_IRIS) <= MASK_SLICE_THRESHOLD ? roughnessTex.g : 0.0f;

								                half lipsScalar = abs(roughnessTex.b * COLOR_MULTIPLIER - MASK_INDEX_LIPS) <= MASK_SLICE_THRESHOLD ? roughnessTex.g : 0.0f;

								                half browsScalar = abs(roughnessTex.b * COLOR_MULTIPLIER - MASK_INDEX_BROWS) <= MASK_SLICE_THRESHOLD ? roughnessTex.g : 0.0f;;

								                half lashesScalar = abs(roughnessTex.b * COLOR_MULTIPLIER - MASK_INDEX_LASHES) <= MASK_SLICE_THRESHOLD ? roughnessTex.g : 0.0f;

								                half scleraScalar = abs(roughnessTex.b * COLOR_MULTIPLIER - MASK_INDEX_SCLERA) <= MASK_SLICE_THRESHOLD ? roughnessTex.g : 0.0f;

								                half teethScalar = abs(roughnessTex.b * COLOR_MULTIPLIER - MASK_INDEX_TEETH) <= MASK_SLICE_THRESHOLD ? roughnessTex.g : 0.0f;;

								                half gumsScalar = abs(roughnessTex.b * COLOR_MULTIPLIER - MASK_INDEX_GUMS) <= MASK_SLICE_THRESHOLD ? roughnessTex.g : 0.0f;;


								                half3 maskIris = irisScalar * (_MaskColorIris * IRIS_BRIGHTNESS_MODIFIER - baseColor.rgb);

								                half3 maskBrows = browsScalar * (_MaskColorBrows - baseColor.rgb);

								                half3 maskLashes = lashesScalar * (_MaskColorLashes - baseColor.rgb);

								                half3 maskSclera = scleraScalar * (_MaskColorSclera * SCLERA_BRIGHTNESS_MODIFIER - baseColor.rgb);

								                half3 maskTeeth = teethScalar * (_MaskColorTeeth - baseColor.rgb);

								                half3 maskGums = gumsScalar * (_MaskColorGums - baseColor.rgb);

								                // Lip tint excluded from color mask as it lerps with texture color

								                half3 colorMask = maskIris + maskBrows + maskLashes + maskSclera + maskTeeth + maskGums;


								                // Diffuse intensity from array

								                half diffuseIntensity = _DiffuseIntensity[componentIndex];


								                // Lerp diffuseIntensity with roughness map

								                diffuseIntensity = lerp(diffuseIntensity, ONE, roughnessTex.a);


								                // Brows and lashes modify DiffuseIntensity

								                diffuseIntensity *= ONE - (saturate(browsScalar + lashesScalar) * BROWS_LASHES_DIFFUSEINTENSITY);


								                // Add in diffuseIntensity and main lighting to base color

								                baseColor.rgb += diffuseIntensity * NdotL * _LightColor0;


								                // Add in color mask to base color if this is the head component (index == 0)

								                baseColor.rgb += clamp(ONE - componentIndex, 0, ONE) * colorMask;


								                // Multiply texture with base color with special case for lips

								                albedoColor.rgb = lerp(albedoColor.rgb * baseColor.rgb, _MaskColorLips.rgb, lipsScalar * _MaskColorLips.a);


								                // Smoothness multiplier on lip region

								                albedoColor.rgb += lipsScalar * reflectionColor * (_LipSmoothness * LIP_SMOOTHNESS_MULTIPLIER) *

								                    lerp(LIP_SMOOTHNESS_MIN_NDOTL, ONE, NdotL);


								                // Reflection from cubemap

								                albedoColor.rgb += reflectionColor * (roughnessTex.a * _ReflectionIntensity[componentIndex]) * NdotL;


								                // Rim term

								#ifdef SECONDARY_LIGHT_ON

								                // Secondary light proxy (direction and color) passed into the rim term

								                NdotL = saturate(dot(normalDirection, _SecondaryLightDirection));

								                albedoColor.rgb += pow(ONE - VdotN, _RimIntensity[componentIndex]) * NdotL * _SecondaryLightColor;

								#else

								                albedoColor.rgb += pow(ONE - VdotN, _RimIntensity[componentIndex]) * NdotL;

								#endif


								                // Global dimmer

								                albedoColor.rgb *= _Dimmer;


								#if !defined(UNITY_COLORSPACE_GAMMA)

								                albedoColor.rgb = GammaToLinearSpace(albedoColor.rgb);

								#endif

								                albedoColor.rgb = saturate(albedoColor.rgb);


								                // Set alpha, with special case for lashes

								                albedoColor.a = saturate(albedoColor.a * lerp(ONE, _Alpha, ONE - lashesScalar) * _Alpha);


								                // Clip fragments in the lash region for clean lash transparency

								                clip(albedoColor.a - lerp(0.0, ALPHA_CLIP_THRESHOLD, lashesScalar));


								                // Return clamped final color

								                return albedoColor;

								            }

								            ENDCG

								        }

								    }

								}