saad
/
ArabDesert
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
ArabDesert/Assets/Bakery/shader/Bakery.cginc

1399 lines
49 KiB
HLSL
Raw Permalink Normal View History

1st
2024-05-25 09:10:35 +03:00
#ifndef BAKERY_INCLUDED
#define BAKERY_INCLUDED
float bakeryLightmapMode;
//float2 bakeryLightmapSize;
#define BAKERYMODE_DEFAULT 0
#define BAKERYMODE_VERTEXLM 1.0f
#define BAKERYMODE_RNM 2.0f
#define BAKERYMODE_SH 3.0f
//#define BAKERY_SSBUMP
//#define BAKERY_COMPRESSED_VOLUME_RGBM
// can't fit vertexLM SH to sm3_0 interpolators
#if defined(SHADER_API_GLCORE) || defined(SHADER_API_GLES) || defined(SHADER_API_D3D11_9X)
#undef BAKERY_VERTEXLMSH
#endif
// can't do stuff on sm2_0 due to standard shader alrady taking up all instructions
#if SHADER_TARGET < 30
#undef BAKERY_BICUBIC
#undef BAKERY_LMSPEC
#undef BAKERY_RNM
#undef BAKERY_SH
#undef BAKERY_MONOSH
#undef BAKERY_VERTEXLM
#endif
#ifndef _NORMALMAP
#undef BAKERY_RNM
//#undef BAKERY_SH
#endif
#ifndef UNITY_SHOULD_SAMPLE_SH
#undef BAKERY_PROBESHNONLINEAR
#endif
#if defined(BAKERY_RNM) && defined(BAKERY_LMSPEC)
#define BAKERY_RNMSPEC
#endif
#ifndef BAKERY_VERTEXLM
#undef BAKERY_VERTEXLMDIR
#undef BAKERY_VERTEXLMSH
#undef BAKERY_VERTEXLMMASK
#endif
#define lumaConv float3(0.2125f, 0.7154f, 0.0721f)
#if defined(BAKERY_SH) || defined(BAKERY_MONOSH) || defined(BAKERY_VERTEXLMSH) || defined(BAKERY_PROBESHNONLINEAR) || defined(BAKERY_VOLUME)
float shEvaluateDiffuseL1Geomerics(float L0, float3 L1, float3 n)
{
// average energy
float R0 = L0;
// avg direction of incoming light
float3 R1 = 0.5f * L1;
// directional brightness
float lenR1 = length(R1);
// linear angle between normal and direction 0-1
//float q = 0.5f * (1.0f + dot(R1 / lenR1, n));
//float q = dot(R1 / lenR1, n) * 0.5 + 0.5;
float q = dot(normalize(R1), n) * 0.5 + 0.5;
// power for q
// lerps from 1 (linear) to 3 (cubic) based on directionality
float p = 1.0f + 2.0f * lenR1 / R0;
// dynamic range constant
// should vary between 4 (highly directional) and 0 (ambient)
float a = (1.0f - lenR1 / R0) / (1.0f + lenR1 / R0);
return R0 * (a + (1.0f - a) * (p + 1.0f) * pow(q, p));
}
#endif
#ifdef BAKERY_VERTEXLM
float4 unpack4NFloats(float src) {
//return fmod(float4(src / 262144.0, src / 4096.0, src / 64.0, src), 64.0)/64.0;
return frac(float4(src / (262144.0*64), src / (4096.0*64), src / (64.0*64), src));
}
float3 unpack3NFloats(float src) {
float r = frac(src);
float g = frac(src * 256.0);
float b = frac(src * 65536.0);
return float3(r, g, b);
}
#if defined(BAKERY_VERTEXLMDIR)
#ifdef BAKERY_MONOSH
void BakeryVertexLMMonoSH(inout float3 diffuseColor, inout float3 specularColor, float3 nL1, float3 normalWorld, float3 viewDir, float smoothness)
{
nL1 = nL1;
float3 L0 = diffuseColor;
float3 L1x = nL1.x * L0 * 2;
float3 L1y = nL1.y * L0 * 2;
float3 L1z = nL1.z * L0 * 2;
float3 sh;
#if BAKERY_SHNONLINEAR
//sh.r = shEvaluateDiffuseL1Geomerics(L0.r, float3(L1x.r, L1y.r, L1z.r), normalWorld);
//sh.g = shEvaluateDiffuseL1Geomerics(L0.g, float3(L1x.g, L1y.g, L1z.g), normalWorld);
//sh.b = shEvaluateDiffuseL1Geomerics(L0.b, float3(L1x.b, L1y.b, L1z.b), normalWorld);
float lumaL0 = dot(L0, 1);
float lumaL1x = dot(L1x, 1);
float lumaL1y = dot(L1y, 1);
float lumaL1z = dot(L1z, 1);
float lumaSH = shEvaluateDiffuseL1Geomerics(lumaL0, float3(lumaL1x, lumaL1y, lumaL1z), normalWorld);
sh = L0 + normalWorld.x * L1x + normalWorld.y * L1y + normalWorld.z * L1z;
float regularLumaSH = dot(sh, 1);
//sh *= regularLumaSH < 0.001 ? 1 : (lumaSH / regularLumaSH);
sh *= lerp(1, lumaSH / regularLumaSH, saturate(regularLumaSH*16));
#else
sh = L0 + normalWorld.x * L1x + normalWorld.y * L1y + normalWorld.z * L1z;
#endif
diffuseColor = max(sh, 0.0);
#ifdef BAKERY_LMSPEC
float3 dominantDir = nL1;
float focus = saturate(length(dominantDir));
half3 halfDir = Unity_SafeNormalize(normalize(dominantDir) - viewDir);
half nh = saturate(dot(normalWorld, halfDir));
half perceptualRoughness = SmoothnessToPerceptualRoughness(smoothness );//* sqrt(focus));
half roughness = PerceptualRoughnessToRoughness(perceptualRoughness);
half spec = GGXTerm(nh, roughness);
specularColor = max(spec * sh, 0.0);
#endif
}
#endif
void BakeryVertexLMDirection(inout float3 diffuseColor, inout float3 specularColor, float3 lightDirection, float3 vertexNormalWorld, float3 normalWorld, float3 viewDir, float smoothness)
{
float3 dominantDir = Unity_SafeNormalize(lightDirection);
half halfLambert = dot(normalWorld, dominantDir) * 0.5 + 0.5;
half flatNormalHalfLambert = dot(vertexNormalWorld, dominantDir) * 0.5 + 0.5;
#ifdef BAKERY_LMSPEC
half3 halfDir = Unity_SafeNormalize(normalize(dominantDir) - viewDir);
half nh = saturate(dot(normalWorld, halfDir));
half perceptualRoughness = SmoothnessToPerceptualRoughness(smoothness);
half roughness = PerceptualRoughnessToRoughness(perceptualRoughness);
half spec = GGXTerm(nh, roughness);
specularColor = spec * diffuseColor;
#endif
diffuseColor *= halfLambert / max(1e-4h, flatNormalHalfLambert);
}
#elif defined(BAKERY_VERTEXLMSH)
void BakeryVertexLMSH(inout float3 diffuseColor, inout float3 specularColor, float3 shL1x, float3 shL1y, float3 shL1z, float3 normalWorld, float3 viewDir, float smoothness)
{
float3 L0 = diffuseColor;
float3 nL1x = shL1x;
float3 nL1y = shL1y;
float3 nL1z = shL1z;
float3 L1x = nL1x * L0 * 2;
float3 L1y = nL1y * L0 * 2;
float3 L1z = nL1z * L0 * 2;
float3 sh;
#if BAKERY_SHNONLINEAR
//sh.r = shEvaluateDiffuseL1Geomerics(L0.r, float3(L1x.r, L1y.r, L1z.r), normalWorld);
//sh.g = shEvaluateDiffuseL1Geomerics(L0.g, float3(L1x.g, L1y.g, L1z.g), normalWorld);
//sh.b = shEvaluateDiffuseL1Geomerics(L0.b, float3(L1x.b, L1y.b, L1z.b), normalWorld);
float lumaL0 = dot(L0, 1);
float lumaL1x = dot(L1x, 1);
float lumaL1y = dot(L1y, 1);
float lumaL1z = dot(L1z, 1);
float lumaSH = shEvaluateDiffuseL1Geomerics(lumaL0, float3(lumaL1x, lumaL1y, lumaL1z), normalWorld);
sh = L0 + normalWorld.x * L1x + normalWorld.y * L1y + normalWorld.z * L1z;
float regularLumaSH = dot(sh, 1);
//sh *= regularLumaSH < 0.001 ? 1 : (lumaSH / regularLumaSH);
sh *= lerp(1, lumaSH / regularLumaSH, saturate(regularLumaSH*16));
#else
sh = L0 + normalWorld.x * L1x + normalWorld.y * L1y + normalWorld.z * L1z;
#endif
diffuseColor = max(sh, 0.0);
#ifdef BAKERY_LMSPEC
float3 dominantDir = float3(dot(nL1x, lumaConv), dot(nL1y, lumaConv), dot(nL1z, lumaConv));
float focus = saturate(length(dominantDir));
half3 halfDir = Unity_SafeNormalize(normalize(dominantDir) - viewDir);
half nh = saturate(dot(normalWorld, halfDir));
half perceptualRoughness = SmoothnessToPerceptualRoughness(smoothness );//* sqrt(focus));
half roughness = PerceptualRoughnessToRoughness(perceptualRoughness);
half spec = GGXTerm(nh, roughness);
specularColor = max(spec * sh, 0.0);
#endif
}
#endif
#endif
#ifdef BAKERY_BICUBIC
float BakeryBicubic_w0(float a)
{
return (1.0f/6.0f)*(a*(a*(-a + 3.0f) - 3.0f) + 1.0f);
}
float BakeryBicubic_w1(float a)
{
return (1.0f/6.0f)*(a*a*(3.0f*a - 6.0f) + 4.0f);
}
float BakeryBicubic_w2(float a)
{
return (1.0f/6.0f)*(a*(a*(-3.0f*a + 3.0f) + 3.0f) + 1.0f);
}
float BakeryBicubic_w3(float a)
{
return (1.0f/6.0f)*(a*a*a);
}
float BakeryBicubic_g0(float a)
{
return BakeryBicubic_w0(a) + BakeryBicubic_w1(a);
}
float BakeryBicubic_g1(float a)
{
return BakeryBicubic_w2(a) + BakeryBicubic_w3(a);
}
float BakeryBicubic_h0(float a)
{
return -1.0f + BakeryBicubic_w1(a) / (BakeryBicubic_w0(a) + BakeryBicubic_w1(a)) + 0.5f;
}
float BakeryBicubic_h1(float a)
{
return 1.0f + BakeryBicubic_w3(a) / (BakeryBicubic_w2(a) + BakeryBicubic_w3(a)) + 0.5f;
}
#endif
struct BakeryVertexInput
{
float4 vertex : POSITION;
#ifdef BAKERY_VERTEXLM
fixed4 color : COLOR;
#ifdef BAKERY_VERTEXLMSH
float2 uv3 : TEXCOORD3;
#endif
#endif
half3 normal : NORMAL;
float2 uv0 : TEXCOORD0;
float2 uv1 : TEXCOORD1;
#if defined(DYNAMICLIGHTMAP_ON) || defined(UNITY_PASS_META)
float2 uv2 : TEXCOORD2;
#endif
#if defined(_TANGENT_TO_WORLD) || defined(BAKERY_RNMSPEC)
half4 tangent : TANGENT;
#endif
UNITY_VERTEX_INPUT_INSTANCE_ID
};
float4 BakeryTexCoords(BakeryVertexInput v)
{
float4 texcoord;
texcoord.xy = TRANSFORM_TEX(v.uv0, _MainTex); // Always source from uv0
texcoord.zw = TRANSFORM_TEX(((_UVSec == 0) ? v.uv0 : v.uv1), _DetailAlbedoMap);
return texcoord;
}
inline half4 BakeryVertexGIForward(BakeryVertexInput v, float3 posWorld, half3 normalWorld)
{
half4 ambientOrLightmapUV = 0;
// Static lightmaps
#ifndef LIGHTMAP_OFF
ambientOrLightmapUV.xy = v.uv1.xy * unity_LightmapST.xy + unity_LightmapST.zw;
ambientOrLightmapUV.zw = 0;
// Sample light probe for Dynamic objects only (no static or dynamic lightmaps)
#elif UNITY_SHOULD_SAMPLE_SH
#ifdef VERTEXLIGHT_ON
// Approximated illumination from non-important point lights
ambientOrLightmapUV.rgb = Shade4PointLights(
unity_4LightPosX0, unity_4LightPosY0, unity_4LightPosZ0,
unity_LightColor[0].rgb, unity_LightColor[1].rgb, unity_LightColor[2].rgb, unity_LightColor[3].rgb,
unity_4LightAtten0, posWorld, normalWorld);
#endif
ambientOrLightmapUV.rgb = ShadeSHPerVertex(normalWorld, ambientOrLightmapUV.rgb);
#endif
#ifdef DYNAMICLIGHTMAP_ON
ambientOrLightmapUV.zw = v.uv2.xy * unity_DynamicLightmapST.xy + unity_DynamicLightmapST.zw;
#endif
#ifdef BAKERY_VERTEXLM
if (bakeryLightmapMode == BAKERYMODE_VERTEXLM)
{
#ifdef BAKERY_VERTEXLMMASK
ambientOrLightmapUV = unpack4NFloats(v.uv1.x);
#endif
}
#endif
return ambientOrLightmapUV;
}
//Forward Pass
struct BakeryVertexOutputForwardBase
{
float4 pos : SV_POSITION;
float4 tex : TEXCOORD0;
half3 eyeVec : TEXCOORD1;
#if UNITY_VERSION >= 201740
float4 tangentToWorldAndPackedData[3] : TEXCOORD2; // [3x3:tangentToWorld | 1x3:viewDirForParallax]
#else
half4 tangentToWorldAndPackedData[3] : TEXCOORD2; // [3x3:tangentToWorld | 1x3:viewDirForParallax]
#endif
#if defined(BAKERY_RNMSPEC)
half3 viewDirForParallax : TEXCOORD13;
#endif
half4 ambientOrLightmapUV : TEXCOORD5; // SH or Lightmap UV
UNITY_SHADOW_COORDS(6)
UNITY_FOG_COORDS(7)
#ifdef BAKERY_VERTEXLM
float4 color : COLOR_centroid;
#if defined(BAKERY_VERTEXLMDIR)
float3 lightDirection : TEXCOORD10_centroid; // is this even legal
#elif defined(BAKERY_VERTEXLMSH)
float3 shL1x : TEXCOORD10_centroid;
float3 shL1y : TEXCOORD11_centroid;
float3 shL1z : TEXCOORD12_centroid;
#endif
#endif
// next ones would not fit into SM2.0 limits, but they are always for SM3.0+
#if UNITY_SPECCUBE_BOX_PROJECTION || UNITY_LIGHT_PROBE_PROXY_VOLUME || (UNITY_REQUIRE_FRAG_WORLDPOS && !UNITY_PACK_WORLDPOS_WITH_TANGENT)
float3 posWorld : TEXCOORD8;
#endif
#if UNITY_OPTIMIZE_TEXCUBELOD
#if UNITY_SPECCUBE_BOX_PROJECTION
half3 reflUVW : TEXCOORD9;
#else
half3 reflUVW : TEXCOORD8;
#endif
#endif
UNITY_VERTEX_INPUT_INSTANCE_ID
UNITY_VERTEX_OUTPUT_STEREO
};
BakeryVertexOutputForwardBase bakeryVertForwardBase(BakeryVertexInput v)
{
UNITY_SETUP_INSTANCE_ID(v);
BakeryVertexOutputForwardBase o;
UNITY_INITIALIZE_OUTPUT(BakeryVertexOutputForwardBase, o);
UNITY_TRANSFER_INSTANCE_ID(v, o);
UNITY_INITIALIZE_VERTEX_OUTPUT_STEREO(o);
float4 posWorld = mul(unity_ObjectToWorld, v.vertex);
#if UNITY_REQUIRE_FRAG_WORLDPOS
#if UNITY_PACK_WORLDPOS_WITH_TANGENT
o.tangentToWorldAndPackedData[0].w = posWorld.x;
o.tangentToWorldAndPackedData[1].w = posWorld.y;
o.tangentToWorldAndPackedData[2].w = posWorld.z;
#else
o.posWorld = posWorld.xyz;
#endif
#endif
o.pos = UnityObjectToClipPos(v.vertex);
float3 normalWorld = UnityObjectToWorldNormal(v.normal);
o.eyeVec = NormalizePerVertexNormal(posWorld.xyz - _WorldSpaceCameraPos);
o.tex = BakeryTexCoords(v);
#ifdef _TANGENT_TO_WORLD
float4 tangentWorld = float4(UnityObjectToWorldDir(v.tangent.xyz), v.tangent.w);
float3x3 tangentToWorld = CreateTangentToWorldPerVertex(normalWorld, tangentWorld.xyz, tangentWorld.w);
o.tangentToWorldAndPackedData[0].xyz = tangentToWorld[0];
o.tangentToWorldAndPackedData[1].xyz = tangentToWorld[1];
o.tangentToWorldAndPackedData[2].xyz = tangentToWorld[2];
#else
o.tangentToWorldAndPackedData[0].xyz = 0;
o.tangentToWorldAndPackedData[1].xyz = 0;
o.tangentToWorldAndPackedData[2].xyz = normalWorld;
#endif
//We need this for shadow receving
UNITY_TRANSFER_SHADOW(o, v.uv1);
o.ambientOrLightmapUV = BakeryVertexGIForward(v, posWorld, normalWorld);
#if defined(_PARALLAXMAP) || defined(BAKERY_RNMSPEC)
TANGENT_SPACE_ROTATION;
#endif
#if defined(_PARALLAXMAP)
half3 viewDirForParallax = mul(rotation, ObjSpaceViewDir(v.vertex));
o.tangentToWorldAndPackedData[0].w = viewDirForParallax.x;
o.tangentToWorldAndPackedData[1].w = viewDirForParallax.y;
o.tangentToWorldAndPackedData[2].w = viewDirForParallax.z;
#endif
#if defined(BAKERY_RNMSPEC)
o.viewDirForParallax = mul(rotation, ObjSpaceViewDir(v.vertex));
#endif
#if UNITY_OPTIMIZE_TEXCUBELOD
o.reflUVW = reflect(o.eyeVec, normalWorld);
#endif
#ifdef BAKERY_VERTEXLM
// Unpack from RGBM
o.color = v.color;
o.color.rgb *= o.color.a * 8.0f;
o.color.rgb *= o.color.rgb;
#if defined(BAKERY_VERTEXLMDIR)
o.lightDirection = unpack3NFloats(v.uv1.y) * 2 - 1;
#elif defined(BAKERY_VERTEXLMSH)
o.shL1x = unpack3NFloats(v.uv1.y) * 2 - 1;
o.shL1y = unpack3NFloats(v.uv3.x) * 2 - 1;
o.shL1z = unpack3NFloats(v.uv3.y) * 2 - 1;
#endif
#endif
UNITY_TRANSFER_FOG(o, o.pos);
return o;
}
/*
inline UnityGI BakeryFragmentGI (FragmentCommonData s, half occlusion, half4 i_ambientOrLightmapUV, half atten, UnityLight light, bool reflections)
{
UnityGIInput d;
d.light = light;
d.worldPos = s.posWorld;
d.worldViewDir = -s.eyeVec;
d.atten = atten;
#if defined(LIGHTMAP_ON) || defined(DYNAMICLIGHTMAP_ON)
d.ambient = 0;
d.lightmapUV = i_ambientOrLightmapUV;
#else
d.ambient = i_ambientOrLightmapUV.rgb;
d.lightmapUV = 0;
#endif
d.probeHDR[0] = unity_SpecCube0_HDR;
d.probeHDR[1] = unity_SpecCube1_HDR;
#if defined(UNITY_SPECCUBE_BLENDING) || defined(UNITY_SPECCUBE_BOX_PROJECTION)
d.boxMin[0] = unity_SpecCube0_BoxMin; // .w holds lerp value for blending
#endif
#ifdef UNITY_SPECCUBE_BOX_PROJECTION
d.boxMax[0] = unity_SpecCube0_BoxMax;
d.probePosition[0] = unity_SpecCube0_ProbePosition;
d.boxMax[1] = unity_SpecCube1_BoxMax;
d.boxMin[1] = unity_SpecCube1_BoxMin;
d.probePosition[1] = unity_SpecCube1_ProbePosition;
#endif
if(reflections)
{
Unity_GlossyEnvironmentData g = UnityGlossyEnvironmentSetup(s.smoothness, -s.eyeVec, s.normalWorld, s.specColor);
// Replace the reflUVW if it has been compute in Vertex shader. Note: the compiler will optimize the calcul in UnityGlossyEnvironmentSetup itself
#if UNITY_STANDARD_SIMPLE
g.reflUVW = s.reflUVW;
#endif
return UnityGlobalIllumination (d, occlusion, s.normalWorld, g);
}
else
{
return UnityGlobalIllumination (d, occlusion, s.normalWorld);
}
}
*/
#if defined(BAKERY_RNM) || defined(BAKERY_SH)
sampler2D _RNM0, _RNM1, _RNM2;
float4 _RNM0_TexelSize;
#endif
#if UNITY_VERSION >= 201740
SamplerState bakery_trilinear_clamp_sampler;
#endif
#ifdef BAKERY_VOLUME
Texture3D _Volume0, _Volume1, _Volume2, _VolumeMask;
SamplerState sampler_Volume0;
float3 _VolumeMin, _VolumeInvSize;
float3 _GlobalVolumeMin, _GlobalVolumeInvSize;
#ifdef BAKERY_COMPRESSED_VOLUME
Texture3D _Volume3;
#endif
#ifdef BAKERY_VOLROTATION
float4x4 _GlobalVolumeMatrix, _VolumeMatrix;
#endif
#endif
#ifdef BAKERY_BICUBIC
// Bicubic
float4 BakeryTex2D(sampler2D tex, float2 uv, float4 texelSize)
{
float x = uv.x * texelSize.z;
float y = uv.y * texelSize.z;
x -= 0.5f;
y -= 0.5f;
float px = floor(x);
float py = floor(y);
float fx = x - px;
float fy = y - py;
float g0x = BakeryBicubic_g0(fx);
float g1x = BakeryBicubic_g1(fx);
float h0x = BakeryBicubic_h0(fx);
float h1x = BakeryBicubic_h1(fx);
float h0y = BakeryBicubic_h0(fy);
float h1y = BakeryBicubic_h1(fy);
return BakeryBicubic_g0(fy) * ( g0x * tex2D(tex, (float2(px + h0x, py + h0y) * texelSize.x)) +
g1x * tex2D(tex, (float2(px + h1x, py + h0y) * texelSize.x))) +
BakeryBicubic_g1(fy) * ( g0x * tex2D(tex, (float2(px + h0x, py + h1y) * texelSize.x)) +
g1x * tex2D(tex, (float2(px + h1x, py + h1y) * texelSize.x)));
}
float4 BakeryTex2D(Texture2D tex, SamplerState s, float2 uv, float4 texelSize)
{
float x = uv.x * texelSize.z;
float y = uv.y * texelSize.z;
x -= 0.5f;
y -= 0.5f;
float px = floor(x);
float py = floor(y);
float fx = x - px;
float fy = y - py;
float g0x = BakeryBicubic_g0(fx);
float g1x = BakeryBicubic_g1(fx);
float h0x = BakeryBicubic_h0(fx);
float h1x = BakeryBicubic_h1(fx);
float h0y = BakeryBicubic_h0(fy);
float h1y = BakeryBicubic_h1(fy);
return BakeryBicubic_g0(fy) * ( g0x * tex.Sample(s, (float2(px + h0x, py + h0y) * texelSize.x)) +
g1x * tex.Sample(s, (float2(px + h1x, py + h0y) * texelSize.x))) +
BakeryBicubic_g1(fy) * ( g0x * tex.Sample(s, (float2(px + h0x, py + h1y) * texelSize.x)) +
g1x * tex.Sample(s, (float2(px + h1x, py + h1y) * texelSize.x)));
}
#else
// Bilinear
float4 BakeryTex2D(sampler2D tex, float2 uv, float4 texelSize)
{
return tex2D(tex, uv);
}
float4 BakeryTex2D(Texture2D tex, SamplerState s, float2 uv, float4 texelSize)
{
return tex.Sample(s, uv);
}
#endif
#ifdef DIRLIGHTMAP_COMBINED
#ifdef BAKERY_LMSPEC
float BakeryDirectionalLightmapSpecular(float2 lmUV, float3 normalWorld, float3 viewDir, float smoothness)
{
#if UNITY_VERSION >= 201740
float3 dominantDir = unity_LightmapInd.Sample(bakery_trilinear_clamp_sampler, lmUV).xyz * 2 - 1;
#else
float3 dominantDir = UNITY_SAMPLE_TEX2D_SAMPLER(unity_LightmapInd, unity_Lightmap, lmUV).xyz * 2 - 1;
#endif
half3 halfDir = Unity_SafeNormalize(normalize(dominantDir) - viewDir);
half nh = saturate(dot(normalWorld, halfDir));
half perceptualRoughness = SmoothnessToPerceptualRoughness(smoothness);
half roughness = PerceptualRoughnessToRoughness(perceptualRoughness);
half spec = GGXTerm(nh, roughness);
return spec;
}
#endif
#endif
#ifdef BAKERY_RNM
void BakeryRNM(inout float3 diffuseColor, inout float3 specularColor, float2 lmUV, float3 normalMap, float smoothness, float3 viewDirT)
{
const float3 rnmBasis0 = float3(0.816496580927726f, 0, 0.5773502691896258f);
const float3 rnmBasis1 = float3(-0.4082482904638631f, 0.7071067811865475f, 0.5773502691896258f);
const float3 rnmBasis2 = float3(-0.4082482904638631f, -0.7071067811865475f, 0.5773502691896258f);
float3 rnm0 = DecodeLightmap(BakeryTex2D(_RNM0, lmUV, _RNM0_TexelSize));
float3 rnm1 = DecodeLightmap(BakeryTex2D(_RNM1, lmUV, _RNM0_TexelSize));
float3 rnm2 = DecodeLightmap(BakeryTex2D(_RNM2, lmUV, _RNM0_TexelSize));
#ifdef BAKERY_SSBUMP
diffuseColor = normalMap.x * rnm0
+ normalMap.z * rnm1
+ normalMap.y * rnm2;
diffuseColor *= 2;
#else
diffuseColor = saturate(dot(rnmBasis0, normalMap)) * rnm0
+ saturate(dot(rnmBasis1, normalMap)) * rnm1
+ saturate(dot(rnmBasis2, normalMap)) * rnm2;
#endif
#ifdef BAKERY_LMSPEC
float3 dominantDirT = rnmBasis0 * dot(rnm0, lumaConv) +
rnmBasis1 * dot(rnm1, lumaConv) +
rnmBasis2 * dot(rnm2, lumaConv);
float3 dominantDirTN = NormalizePerPixelNormal(dominantDirT);
float3 specColor = saturate(dot(rnmBasis0, dominantDirTN)) * rnm0 +
saturate(dot(rnmBasis1, dominantDirTN)) * rnm1 +
saturate(dot(rnmBasis2, dominantDirTN)) * rnm2;
half3 halfDir = Unity_SafeNormalize(dominantDirTN - viewDirT);
half nh = saturate(dot(normalMap, halfDir));
half perceptualRoughness = SmoothnessToPerceptualRoughness(smoothness);
half roughness = PerceptualRoughnessToRoughness(perceptualRoughness);
half spec = GGXTerm(nh, roughness);
specularColor = spec * specColor;
#endif
}
#endif
#ifdef BAKERY_SH
void BakerySH(inout float3 diffuseColor, inout float3 specularColor, float2 lmUV, float3 normalWorld, float3 viewDir, float smoothness)
{
/*
#ifdef SHADER_API_D3D11
#if UNITY_VERSION >= 201740
float3 L0 = DecodeLightmap(BakeryTex2D(unity_Lightmap, bakery_trilinear_clamp_sampler, lmUV, _RNM0_TexelSize));
#else
float3 L0 = DecodeLightmap(BakeryTex2D(unity_Lightmap, samplerunity_Lightmap, lmUV, _RNM0_TexelSize));
#endif
#else
float3 L0 = DecodeLightmap(UNITY_SAMPLE_TEX2D(unity_Lightmap, lmUV));
#endif
*/
// already sampled
float3 L0 = diffuseColor;
float3 nL1x = BakeryTex2D(_RNM0, lmUV, _RNM0_TexelSize) * 2 - 1;
float3 nL1y = BakeryTex2D(_RNM1, lmUV, _RNM0_TexelSize) * 2 - 1;
float3 nL1z = BakeryTex2D(_RNM2, lmUV, _RNM0_TexelSize) * 2 - 1;
float3 L1x = nL1x * L0 * 2;
float3 L1y = nL1y * L0 * 2;
float3 L1z = nL1z * L0 * 2;
float3 sh;
#if BAKERY_SHNONLINEAR
float lumaL0 = dot(L0, 1);
float lumaL1x = dot(L1x, 1);
float lumaL1y = dot(L1y, 1);
float lumaL1z = dot(L1z, 1);
float lumaSH = shEvaluateDiffuseL1Geomerics(lumaL0, float3(lumaL1x, lumaL1y, lumaL1z), normalWorld);
sh = L0 + normalWorld.x * L1x + normalWorld.y * L1y + normalWorld.z * L1z;
float regularLumaSH = dot(sh, 1);
//sh *= regularLumaSH < 0.001 ? 1 : (lumaSH / regularLumaSH);
sh *= lerp(1, lumaSH / regularLumaSH, saturate(regularLumaSH*16));
//sh.r = shEvaluateDiffuseL1Geomerics(L0.r, float3(L1x.r, L1y.r, L1z.r), normalWorld);
//sh.g = shEvaluateDiffuseL1Geomerics(L0.g, float3(L1x.g, L1y.g, L1z.g), normalWorld);
//sh.b = shEvaluateDiffuseL1Geomerics(L0.b, float3(L1x.b, L1y.b, L1z.b), normalWorld);
#else
sh = L0 + normalWorld.x * L1x + normalWorld.y * L1y + normalWorld.z * L1z;
#endif
diffuseColor = max(sh, 0.0);
specularColor = 0;
#ifdef BAKERY_LMSPEC
float3 dominantDir = float3(dot(nL1x, lumaConv), dot(nL1y, lumaConv), dot(nL1z, lumaConv));
float focus = saturate(length(dominantDir));
half3 halfDir = Unity_SafeNormalize(normalize(dominantDir) - viewDir);
half nh = saturate(dot(normalWorld, halfDir));
half perceptualRoughness = SmoothnessToPerceptualRoughness(smoothness );//* sqrt(focus));
half roughness = PerceptualRoughnessToRoughness(perceptualRoughness);
half spec = GGXTerm(nh, roughness);
sh = L0 + dominantDir.x * L1x + dominantDir.y * L1y + dominantDir.z * L1z;
specularColor = max(spec * sh, 0.0);
#endif
}
#endif
#ifdef BAKERY_MONOSH
void BakeryMonoSH(inout float3 diffuseColor, inout float3 specularColor, float2 lmUV, float3 normalWorld, float3 viewDir, float smoothness)
{
#if UNITY_VERSION >= 201740
float3 dominantDir = unity_LightmapInd.Sample(bakery_trilinear_clamp_sampler, lmUV).xyz;
float3 L0 = DecodeLightmap(unity_Lightmap.Sample(bakery_trilinear_clamp_sampler, lmUV));
#else
float3 dominantDir = UNITY_SAMPLE_TEX2D_SAMPLER(unity_LightmapInd, unity_Lightmap, lmUV).xyz;
float3 L0 = DecodeLightmap(UNITY_SAMPLE_TEX2D_SAMPLER(unity_Lightmap, unity_Lightmap, lmUV));
#endif
float3 nL1 = dominantDir * 2 - 1;
float3 L1x = nL1.x * L0 * 2;
float3 L1y = nL1.y * L0 * 2;
float3 L1z = nL1.z * L0 * 2;
float3 sh;
#if BAKERY_SHNONLINEAR
float lumaL0 = dot(L0, 1);
float lumaL1x = dot(L1x, 1);
float lumaL1y = dot(L1y, 1);
float lumaL1z = dot(L1z, 1);
float lumaSH = shEvaluateDiffuseL1Geomerics(lumaL0, float3(lumaL1x, lumaL1y, lumaL1z), normalWorld);
sh = L0 + normalWorld.x * L1x + normalWorld.y * L1y + normalWorld.z * L1z;
float regularLumaSH = dot(sh, 1);
//sh *= regularLumaSH < 0.001 ? 1 : (lumaSH / regularLumaSH);
sh *= lerp(1, lumaSH / regularLumaSH, saturate(regularLumaSH*16));
//sh.r = shEvaluateDiffuseL1Geomerics(L0.r, float3(L1x.r, L1y.r, L1z.r), normalWorld);
//sh.g = shEvaluateDiffuseL1Geomerics(L0.g, float3(L1x.g, L1y.g, L1z.g), normalWorld);
//sh.b = shEvaluateDiffuseL1Geomerics(L0.b, float3(L1x.b, L1y.b, L1z.b), normalWorld);
#else
sh = L0 + normalWorld.x * L1x + normalWorld.y * L1y + normalWorld.z * L1z;
#endif
diffuseColor = max(sh, 0.0);
specularColor = 0;
#ifdef BAKERY_LMSPEC
dominantDir = nL1;
float focus = saturate(length(dominantDir));
half3 halfDir = Unity_SafeNormalize(normalize(dominantDir) - viewDir);
half nh = saturate(dot(normalWorld, halfDir));
half perceptualRoughness = SmoothnessToPerceptualRoughness(smoothness );//* sqrt(focus));
half roughness = PerceptualRoughnessToRoughness(perceptualRoughness);
half spec = GGXTerm(nh, roughness);
sh = L0 + dominantDir.x * L1x + dominantDir.y * L1y + dominantDir.z * L1z;
specularColor = max(spec * sh, 0.0);
#endif
}
#endif
half4 bakeryFragForwardBase(BakeryVertexOutputForwardBase i) : SV_Target
{
FRAGMENT_SETUP(s)
#if UNITY_OPTIMIZE_TEXCUBELOD
s.reflUVW = i.reflUVW;
#endif
UnityLight mainLight = MainLight ();
UNITY_LIGHT_ATTENUATION(atten, i, s.posWorld);
#ifdef BAKERY_VOLUME
bool isGlobal = _VolumeInvSize.x > 1000000; // ~inf
float3 volViewDir = s.eyeVec;
#ifdef BAKERY_VOLROTATION
float4x4 volMatrix = (isGlobal ? _GlobalVolumeMatrix : _VolumeMatrix);
float3 volInvSize = (isGlobal ? _GlobalVolumeInvSize : _VolumeInvSize);
float3 lpUV = mul(volMatrix, float4(s.posWorld,1)).xyz * volInvSize + 0.5f;
float3 volNormal = mul((float3x3)volMatrix, s.normalWorld);
#ifdef BAKERY_LMSPEC
volViewDir = mul((float3x3)volMatrix, volViewDir);
#endif
#else
float3 lpUV = (s.posWorld - (isGlobal ? _GlobalVolumeMin : _VolumeMin)) * (isGlobal ? _GlobalVolumeInvSize : _VolumeInvSize);
float3 volNormal = s.normalWorld;
#endif
#endif
#ifdef BAKERY_VOLUME
mainLight.color *= saturate(dot(_VolumeMask.Sample(sampler_Volume0, lpUV), unity_OcclusionMaskSelector));
#elif BAKERY_VERTEXLMMASK
if (bakeryLightmapMode == BAKERYMODE_VERTEXLM)
{
mainLight.color *= saturate(dot(i.ambientOrLightmapUV, unity_OcclusionMaskSelector));
}
#endif
half occlusion = Occlusion(i.tex.xy);
UnityGI gi = FragmentGI(s, occlusion, i.ambientOrLightmapUV, atten, mainLight);
#ifdef BAKERY_VOLUME
#ifdef BAKERY_COMPRESSED_VOLUME
float4 tex0, tex1, tex2, tex3;
float3 L0, L1x, L1y, L1z;
tex0 = _Volume0.Sample(sampler_Volume0, lpUV);
tex1 = _Volume1.Sample(sampler_Volume0, lpUV) * 2 - 1;
tex2 = _Volume2.Sample(sampler_Volume0, lpUV) * 2 - 1;
tex3 = _Volume3.Sample(sampler_Volume0, lpUV) * 2 - 1;
#ifdef BAKERY_COMPRESSED_VOLUME_RGBM
L0 = tex0.xyz * (tex0.w * 8.0f);
L0 *= L0;
#else
L0 = tex0.xyz;
#endif
L1x = tex1.xyz * L0;
L1y = tex2.xyz * L0;
L1z = tex3.xyz * L0;
#else
float4 tex0, tex1, tex2;
float3 L0, L1x, L1y, L1z;
tex0 = _Volume0.Sample(sampler_Volume0, lpUV);
tex1 = _Volume1.Sample(sampler_Volume0, lpUV);
tex2 = _Volume2.Sample(sampler_Volume0, lpUV);
L0 = tex0.xyz;
L1x = tex1.xyz;
L1y = tex2.xyz;
L1z = float3(tex0.w, tex1.w, tex2.w);
#endif
gi.indirect.diffuse.r = shEvaluateDiffuseL1Geomerics(L0.r, float3(L1x.r, L1y.r, L1z.r), volNormal);
gi.indirect.diffuse.g = shEvaluateDiffuseL1Geomerics(L0.g, float3(L1x.g, L1y.g, L1z.g), volNormal);
gi.indirect.diffuse.b = shEvaluateDiffuseL1Geomerics(L0.b, float3(L1x.b, L1y.b, L1z.b), volNormal);
#ifdef UNITY_COLORSPACE_GAMMA
gi.indirect.diffuse = pow(gi.indirect.diffuse, 1.0f / 2.2f);
#endif
#ifdef BAKERY_LMSPEC
float3 nL1x = L1x / L0;
float3 nL1y = L1y / L0;
float3 nL1z = L1z / L0;
float3 dominantDir = float3(dot(nL1x, lumaConv), dot(nL1y, lumaConv), dot(nL1z, lumaConv));
half3 halfDir = Unity_SafeNormalize(normalize(dominantDir) - volViewDir);
half nh = saturate(dot(volNormal, halfDir));
half perceptualRoughness = SmoothnessToPerceptualRoughness(s.smoothness);
half roughness = PerceptualRoughnessToRoughness(perceptualRoughness);
half spec = GGXTerm(nh, roughness);
float3 sh = L0 + dominantDir.x * L1x + dominantDir.y * L1y + dominantDir.z * L1z;
gi.indirect.specular += max(spec * sh, 0.0);
#endif
#elif BAKERY_PROBESHNONLINEAR
float3 L0 = float3(unity_SHAr.w, unity_SHAg.w, unity_SHAb.w);
gi.indirect.diffuse.r = shEvaluateDiffuseL1Geomerics(L0.r, unity_SHAr.xyz, s.normalWorld);
gi.indirect.diffuse.g = shEvaluateDiffuseL1Geomerics(L0.g, unity_SHAg.xyz, s.normalWorld);
gi.indirect.diffuse.b = shEvaluateDiffuseL1Geomerics(L0.b, unity_SHAb.xyz, s.normalWorld);
#endif
#ifdef DIRLIGHTMAP_COMBINED
#ifdef BAKERY_LMSPEC
#ifndef BAKERY_MONOSH
if (bakeryLightmapMode == BAKERYMODE_DEFAULT)
{
gi.indirect.specular += BakeryDirectionalLightmapSpecular(i.ambientOrLightmapUV.xy, s.normalWorld, s.eyeVec, s.smoothness) * gi.indirect.diffuse;
}
#endif
#endif
#endif
#ifdef BAKERY_VERTEXLM
if (bakeryLightmapMode == BAKERYMODE_VERTEXLM)
{
gi.indirect.diffuse = i.color.rgb;
float3 prevSpec = gi.indirect.specular;
#if defined(BAKERY_VERTEXLMDIR)
#ifdef BAKERY_MONOSH
BakeryVertexLMMonoSH(gi.indirect.diffuse, gi.indirect.specular, i.lightDirection, s.normalWorld, s.eyeVec, s.smoothness);
#else
BakeryVertexLMDirection(gi.indirect.diffuse, gi.indirect.specular, i.lightDirection, i.tangentToWorldAndPackedData[2].xyz, s.normalWorld, s.eyeVec, s.smoothness);
#endif
gi.indirect.specular += prevSpec;
#elif defined (BAKERY_VERTEXLMSH)
BakeryVertexLMSH(gi.indirect.diffuse, gi.indirect.specular, i.shL1x, i.shL1y, i.shL1z, s.normalWorld, s.eyeVec, s.smoothness);
gi.indirect.specular += prevSpec;
#endif
}
#endif
#ifdef BAKERY_RNM
if (bakeryLightmapMode == BAKERYMODE_RNM)
{
#ifdef BAKERY_SSBUMP
float3 normalMap = tex2D(_BumpMap, i.tex.xy).xyz;
#else
float3 normalMap = NormalInTangentSpace(i.tex);
#endif
float3 eyeVecT = 0;
#ifdef BAKERY_LMSPEC
eyeVecT = -NormalizePerPixelNormal(i.viewDirForParallax);
#endif
float3 prevSpec = gi.indirect.specular;
BakeryRNM(gi.indirect.diffuse, gi.indirect.specular, i.ambientOrLightmapUV.xy, normalMap, s.smoothness, eyeVecT);
gi.indirect.specular += prevSpec;
}
#endif
#ifdef BAKERY_SH
#if SHADER_TARGET >= 30
if (bakeryLightmapMode == BAKERYMODE_SH)
#endif
{
float3 prevSpec = gi.indirect.specular;
BakerySH(gi.indirect.diffuse, gi.indirect.specular, i.ambientOrLightmapUV.xy, s.normalWorld, s.eyeVec, s.smoothness);
gi.indirect.specular += prevSpec;
}
#endif
#ifdef DIRLIGHTMAP_COMBINED
#ifdef BAKERY_MONOSH
if (bakeryLightmapMode != BAKERYMODE_VERTEXLM)
{
float3 prevSpec = gi.indirect.specular;
BakeryMonoSH(gi.indirect.diffuse, gi.indirect.specular, i.ambientOrLightmapUV.xy, s.normalWorld, s.eyeVec, s.smoothness);
gi.indirect.specular += prevSpec;
}
#endif
#endif
half4 c = UNITY_BRDF_PBS(s.diffColor, s.specColor, s.oneMinusReflectivity, s.smoothness, s.normalWorld, -s.eyeVec, gi.light, gi.indirect);
c.rgb += UNITY_BRDF_GI(s.diffColor, s.specColor, s.oneMinusReflectivity, s.smoothness, s.normalWorld, -s.eyeVec, occlusion, gi);
c.rgb += Emission(i.tex.xy);
UNITY_APPLY_FOG(i.fogCoord, c.rgb);
return OutputForward(c, s.alpha);
}
// Additive forward pass (one light per pass)
struct BakeryVertexOutputForwardAdd
{
float4 pos : SV_POSITION;
float4 tex : TEXCOORD0;
half3 eyeVec : TEXCOORD1;
#if UNITY_VERSION >= 201740
float4 tangentToWorldAndLightDir[3] : TEXCOORD2; // [3x3:tangentToWorld | 1x3:viewDirForParallax]
#else
half4 tangentToWorldAndLightDir[3] : TEXCOORD2; // [3x3:tangentToWorld | 1x3:viewDirForParallax]
#endif
float3 posWorld : TEXCOORD5;
UNITY_SHADOW_COORDS(6)
UNITY_FOG_COORDS(7)
// next ones would not fit into SM2.0 limits, but they are always for SM3.0+
#if defined(_PARALLAXMAP)
half3 viewDirForParallax : TEXCOORD8;
#endif
#ifdef BAKERY_VERTEXLMMASK
fixed4 shadowMask : COLOR;
#endif
UNITY_VERTEX_OUTPUT_STEREO
};
BakeryVertexOutputForwardAdd bakeryVertForwardAdd(BakeryVertexInput v)
{
UNITY_SETUP_INSTANCE_ID(v);
BakeryVertexOutputForwardAdd o;
UNITY_INITIALIZE_OUTPUT(BakeryVertexOutputForwardAdd, o);
UNITY_INITIALIZE_VERTEX_OUTPUT_STEREO(o);
float4 posWorld = mul(unity_ObjectToWorld, v.vertex);
o.pos = UnityObjectToClipPos(v.vertex);
o.tex = BakeryTexCoords(v);
o.eyeVec = NormalizePerVertexNormal(posWorld.xyz - _WorldSpaceCameraPos);
o.posWorld = posWorld.xyz;
float3 normalWorld = UnityObjectToWorldNormal(v.normal);
#ifdef _TANGENT_TO_WORLD
float4 tangentWorld = float4(UnityObjectToWorldDir(v.tangent.xyz), v.tangent.w);
float3x3 tangentToWorld = CreateTangentToWorldPerVertex(normalWorld, tangentWorld.xyz, tangentWorld.w);
o.tangentToWorldAndLightDir[0].xyz = tangentToWorld[0];
o.tangentToWorldAndLightDir[1].xyz = tangentToWorld[1];
o.tangentToWorldAndLightDir[2].xyz = tangentToWorld[2];
#else
o.tangentToWorldAndLightDir[0].xyz = 0;
o.tangentToWorldAndLightDir[1].xyz = 0;
o.tangentToWorldAndLightDir[2].xyz = normalWorld;
#endif
//We need this for shadow receving
UNITY_TRANSFER_SHADOW(o, v.uv1);
float3 lightDir = _WorldSpaceLightPos0.xyz - posWorld.xyz * _WorldSpaceLightPos0.w;
#ifndef USING_DIRECTIONAL_LIGHT
lightDir = NormalizePerVertexNormal(lightDir);
#endif
o.tangentToWorldAndLightDir[0].w = lightDir.x;
o.tangentToWorldAndLightDir[1].w = lightDir.y;
o.tangentToWorldAndLightDir[2].w = lightDir.z;
#ifdef _PARALLAXMAP
TANGENT_SPACE_ROTATION;
o.viewDirForParallax = mul(rotation, ObjSpaceViewDir(v.vertex));
#endif
#ifdef BAKERY_VERTEXLMMASK
o.shadowMask = unpack4NFloats(v.uv1.x);
#endif
UNITY_TRANSFER_FOG(o, o.pos);
return o;
}
half4 bakeryFragForwardAdd(BakeryVertexOutputForwardAdd i) : SV_Target
{
FRAGMENT_SETUP_FWDADD(s)
UNITY_LIGHT_ATTENUATION(atten, i, s.posWorld)
UnityLight light = AdditiveLight (IN_LIGHTDIR_FWDADD(i), atten);
UnityIndirect noIndirect = ZeroIndirect ();
half4 c = UNITY_BRDF_PBS(s.diffColor, s.specColor, s.oneMinusReflectivity, s.smoothness, s.normalWorld, -s.eyeVec, light, noIndirect);
#ifdef BAKERY_VOLUME
bool isGlobal = _VolumeInvSize.x > 1000000; // ~inf
#ifdef BAKERY_VOLROTATION
float4x4 volMatrix = (isGlobal ? _GlobalVolumeMatrix : _VolumeMatrix);
float3 volInvSize = (isGlobal ? _GlobalVolumeInvSize : _VolumeInvSize);
float3 lpUV = mul(volMatrix, float4(s.posWorld,1)).xyz * volInvSize + 0.5f;
#else
float3 lpUV = (s.posWorld - (isGlobal ? _GlobalVolumeMin : _VolumeMin)) * (isGlobal ? _GlobalVolumeInvSize : _VolumeInvSize);
#endif
c *= saturate(dot(_VolumeMask.Sample(sampler_Volume0, lpUV), unity_OcclusionMaskSelector));
#elif BAKERY_VERTEXLMMASK
if (bakeryLightmapMode == BAKERYMODE_VERTEXLM)
{
c *= saturate(dot(i.shadowMask, unity_OcclusionMaskSelector));
}
#endif
UNITY_APPLY_FOG_COLOR(i.fogCoord, c.rgb, half4(0,0,0,0)); // fog towards black in additive pass
return OutputForward(c, s.alpha);
}
//Deferred Pass
struct BakeryVertexOutputDeferred
{
float4 pos : SV_POSITION;
float4 tex : TEXCOORD0;
half3 eyeVec : TEXCOORD1;
#if UNITY_VERSION >= 201740
float4 tangentToWorldAndPackedData[3] : TEXCOORD2; // [3x3:tangentToWorld | 1x3:viewDirForParallax]
#else
half4 tangentToWorldAndPackedData[3] : TEXCOORD2; // [3x3:tangentToWorld | 1x3:viewDirForParallax]
#endif
#if defined(BAKERY_RNMSPEC)
half3 viewDirForParallax : TEXCOORD9;
#endif
half4 ambientOrLightmapUV : TEXCOORD5; // SH or Lightmap UVs
#ifdef BAKERY_VERTEXLM
fixed4 color : COLOR;
#if defined(BAKERY_VERTEXLMDIR)
float3 lightDirection : TEXCOORD8;
#elif defined(BAKERY_VERTEXLMSH)
float3 shL1x : TEXCOORD8_centroid;
float3 shL1y : TEXCOORD10_centroid;
float3 shL1z : TEXCOORD11_centroid;
#endif
#endif
#if UNITY_SPECCUBE_BOX_PROJECTION || UNITY_LIGHT_PROBE_PROXY_VOLUME || (UNITY_REQUIRE_FRAG_WORLDPOS && !UNITY_PACK_WORLDPOS_WITH_TANGENT) || BAKERY_VOLUME
float3 posWorld : TEXCOORD6;
#endif
#if UNITY_OPTIMIZE_TEXCUBELOD
#if UNITY_SPECCUBE_BOX_PROJECTION
half3 reflUVW : TEXCOORD7;
#else
half3 reflUVW : TEXCOORD6;
#endif
#endif
UNITY_VERTEX_OUTPUT_STEREO
};
BakeryVertexOutputDeferred bakeryVertDeferred(BakeryVertexInput v)
{
UNITY_SETUP_INSTANCE_ID(v);
BakeryVertexOutputDeferred o;
UNITY_INITIALIZE_OUTPUT(BakeryVertexOutputDeferred, o);
UNITY_INITIALIZE_VERTEX_OUTPUT_STEREO(o);
float4 posWorld = mul(unity_ObjectToWorld, v.vertex);
#if UNITY_SPECCUBE_BOX_PROJECTION || UNITY_LIGHT_PROBE_PROXY_VOLUME || BAKERY_VOLUME
o.posWorld = posWorld;
#endif
o.pos = UnityObjectToClipPos(v.vertex);
o.tex = BakeryTexCoords(v);
o.eyeVec = NormalizePerVertexNormal(posWorld.xyz - _WorldSpaceCameraPos);
float3 normalWorld = UnityObjectToWorldNormal(v.normal);
#ifdef _TANGENT_TO_WORLD
float4 tangentWorld = float4(UnityObjectToWorldDir(v.tangent.xyz), v.tangent.w);
float3x3 tangentToWorld = CreateTangentToWorldPerVertex(normalWorld, tangentWorld.xyz, tangentWorld.w);
o.tangentToWorldAndPackedData[0].xyz = tangentToWorld[0];
o.tangentToWorldAndPackedData[1].xyz = tangentToWorld[1];
o.tangentToWorldAndPackedData[2].xyz = tangentToWorld[2];
#else
o.tangentToWorldAndPackedData[0].xyz = 0;
o.tangentToWorldAndPackedData[1].xyz = 0;
o.tangentToWorldAndPackedData[2].xyz = normalWorld;
#endif
o.ambientOrLightmapUV = 0;
#ifndef LIGHTMAP_OFF
o.ambientOrLightmapUV.xy = v.uv1.xy * unity_LightmapST.xy + unity_LightmapST.zw;
#elif UNITY_SHOULD_SAMPLE_SH
o.ambientOrLightmapUV.rgb = ShadeSHPerVertex(normalWorld, o.ambientOrLightmapUV.rgb);
#endif
#ifdef DYNAMICLIGHTMAP_ON
o.ambientOrLightmapUV.zw = v.uv2.xy * unity_DynamicLightmapST.xy + unity_DynamicLightmapST.zw;
#endif
#ifdef BAKERY_VERTEXLMMASK
if (bakeryLightmapMode == BAKERYMODE_VERTEXLM)
{
o.ambientOrLightmapUV = unpack4NFloats(v.uv1);
}
#endif
#if defined(_PARALLAXMAP) || defined(BAKERY_RNMSPEC)
TANGENT_SPACE_ROTATION;
#endif
#if defined(_PARALLAXMAP)
half3 viewDirForParallax = mul(rotation, ObjSpaceViewDir(v.vertex));
o.tangentToWorldAndPackedData[0].w = viewDirForParallax.x;
o.tangentToWorldAndPackedData[1].w = viewDirForParallax.y;
o.tangentToWorldAndPackedData[2].w = viewDirForParallax.z;
#endif
#if defined(BAKERY_RNMSPEC)
o.viewDirForParallax = mul(rotation, ObjSpaceViewDir(v.vertex));
#endif
#ifdef BAKERY_VERTEXLM
// Unpack from RGBM
o.color = v.color;
o.color.rgb *= o.color.a * 8.0f;
o.color.rgb *= o.color.rgb;
#if defined(BAKERY_VERTEXLMDIR)
o.lightDirection = unpack3NFloats(v.uv1.y) * 2 - 1;
#elif defined(BAKERY_VERTEXLMSH)
o.shL1x = unpack3NFloats(v.uv1.y) * 2 - 1;
o.shL1y = unpack3NFloats(v.uv3.x) * 2 - 1;
o.shL1z = unpack3NFloats(v.uv3.y) * 2 - 1;
#endif
#endif
#if UNITY_OPTIMIZE_TEXCUBELOD
o.reflUVW = reflect(o.eyeVec, normalWorld);
#endif
return o;
}
void bakeryFragDeferred(
BakeryVertexOutputDeferred i,
out half4 outDiffuse : SV_Target0, // RT0: diffuse color (rgb), occlusion (a)
out half4 outSpecSmoothness : SV_Target1, // RT1: spec color (rgb), smoothness (a)
out half4 outNormal : SV_Target2, // RT2: normal (rgb), --unused, very low precision-- (a)
out half4 outEmission : SV_Target3 // RT3: emission (rgb), --unused-- (a)
#if defined(SHADOWS_SHADOWMASK) && (UNITY_ALLOWED_MRT_COUNT > 4)
,out half4 outShadowMask : SV_Target4 // RT4: shadowmask (rgba)
#endif
)
{
#if (SHADER_TARGET < 30)
outDiffuse = 1;
outSpecSmoothness = 1;
outNormal = 0;
outEmission = 0;
#if defined(SHADOWS_SHADOWMASK) && (UNITY_ALLOWED_MRT_COUNT > 4)
outShadowMask = 1;
#endif
return;
#endif
FRAGMENT_SETUP(s)
#if UNITY_OPTIMIZE_TEXCUBELOD
s.reflUVW = i.reflUVW;
#endif
// no analytic lights in this pass
UnityLight dummyLight = DummyLight();
half atten = 1;
// only GI
half occlusion = Occlusion(i.tex.xy);
#if UNITY_ENABLE_REFLECTION_BUFFERS
bool sampleReflectionsInDeferred = false;
#else
bool sampleReflectionsInDeferred = true;
#endif
UnityGI gi = FragmentGI(s, occlusion, i.ambientOrLightmapUV, atten, dummyLight, sampleReflectionsInDeferred);
#ifdef BAKERY_VOLUME
bool isGlobal = _VolumeInvSize.x > 1000000; // ~inf
float3 volViewDir = s.eyeVec;
#ifdef BAKERY_VOLROTATION
float4x4 volMatrix = (isGlobal ? _GlobalVolumeMatrix : _VolumeMatrix);
float3 volInvSize = (isGlobal ? _GlobalVolumeInvSize : _VolumeInvSize);
float3 lpUV = mul(volMatrix, float4(i.posWorld,1)).xyz * volInvSize + 0.5f;
float3 volNormal = mul((float3x3)volMatrix, s.normalWorld);
#ifdef BAKERY_LMSPEC
volViewDir = mul((float3x3)volMatrix, volViewDir);
#endif
#else
float3 lpUV = (i.posWorld - (isGlobal ? _GlobalVolumeMin : _VolumeMin)) * (isGlobal ? _GlobalVolumeInvSize : _VolumeInvSize);
float3 volNormal = s.normalWorld;
#endif
#ifdef BAKERY_COMPRESSED_VOLUME
float4 tex0, tex1, tex2, tex3;
float3 L0, L1x, L1y, L1z;
tex0 = _Volume0.Sample(sampler_Volume0, lpUV);
tex1 = _Volume1.Sample(sampler_Volume0, lpUV) * 2 - 1;
tex2 = _Volume2.Sample(sampler_Volume0, lpUV) * 2 - 1;
tex3 = _Volume3.Sample(sampler_Volume0, lpUV) * 2 - 1;
#ifdef BAKERY_COMPRESSED_VOLUME_RGBM
L0 = tex0.xyz * (tex0.w * 8.0f);
L0 *= L0;
#else
L0 = tex0.xyz;
#endif
L1x = tex1.xyz * L0;
L1y = tex2.xyz * L0;
L1z = tex3.xyz * L0;
#else
float4 tex0, tex1, tex2;
float3 L0, L1x, L1y, L1z;
tex0 = _Volume0.Sample(sampler_Volume0, lpUV);
tex1 = _Volume1.Sample(sampler_Volume0, lpUV);
tex2 = _Volume2.Sample(sampler_Volume0, lpUV);
L0 = tex0.xyz;
L1x = tex1.xyz;
L1y = tex2.xyz;
L1z = float3(tex0.w, tex1.w, tex2.w);
#endif
gi.indirect.diffuse.r = shEvaluateDiffuseL1Geomerics(L0.r, float3(L1x.r, L1y.r, L1z.r), volNormal);
gi.indirect.diffuse.g = shEvaluateDiffuseL1Geomerics(L0.g, float3(L1x.g, L1y.g, L1z.g), volNormal);
gi.indirect.diffuse.b = shEvaluateDiffuseL1Geomerics(L0.b, float3(L1x.b, L1y.b, L1z.b), volNormal);
#ifdef UNITY_COLORSPACE_GAMMA
gi.indirect.diffuse = pow(gi.indirect.diffuse, 1.0f / 2.2f);
#endif
#ifdef BAKERY_LMSPEC
float3 nL1x = L1x / L0;
float3 nL1y = L1y / L0;
float3 nL1z = L1z / L0;
float3 dominantDir = float3(dot(nL1x, lumaConv), dot(nL1y, lumaConv), dot(nL1z, lumaConv));
half3 halfDir = Unity_SafeNormalize(normalize(dominantDir) - volViewDir);
half nh = saturate(dot(volNormal, halfDir));
half perceptualRoughness = SmoothnessToPerceptualRoughness(s.smoothness);
half roughness = PerceptualRoughnessToRoughness(perceptualRoughness);
half spec = GGXTerm(nh, roughness);
float3 sh = L0 + dominantDir.x * L1x + dominantDir.y * L1y + dominantDir.z * L1z;
gi.indirect.specular += max(spec * sh, 0.0);
#endif
#elif BAKERY_PROBESHNONLINEAR
float3 L0 = float3(unity_SHAr.w, unity_SHAg.w, unity_SHAb.w);
gi.indirect.diffuse.r = shEvaluateDiffuseL1Geomerics(L0.r, unity_SHAr.xyz, s.normalWorld);
gi.indirect.diffuse.g = shEvaluateDiffuseL1Geomerics(L0.g, unity_SHAg.xyz, s.normalWorld);
gi.indirect.diffuse.b = shEvaluateDiffuseL1Geomerics(L0.b, unity_SHAb.xyz, s.normalWorld);
#endif
#ifdef DIRLIGHTMAP_COMBINED
#ifdef BAKERY_LMSPEC
#ifndef BAKERY_MONOSH
if (bakeryLightmapMode == BAKERYMODE_DEFAULT)
{
gi.indirect.specular += BakeryDirectionalLightmapSpecular(i.ambientOrLightmapUV.xy, s.normalWorld, s.eyeVec, s.smoothness) * gi.indirect.diffuse;
}
#endif
#endif
#endif
#ifdef BAKERY_VERTEXLM
if (bakeryLightmapMode == BAKERYMODE_VERTEXLM)
{
gi.indirect.diffuse = i.color.rgb;
float3 prevSpec = gi.indirect.specular;
#if defined(BAKERY_VERTEXLMDIR)
#ifdef BAKERY_MONOSH
BakeryVertexLMMonoSH(gi.indirect.diffuse, gi.indirect.specular, i.lightDirection, s.normalWorld, s.eyeVec, s.smoothness);
#else
BakeryVertexLMDirection(gi.indirect.diffuse, gi.indirect.specular, i.lightDirection, i.tangentToWorldAndPackedData[2].xyz, s.normalWorld, s.eyeVec, s.smoothness);
#endif
gi.indirect.specular += prevSpec;
#elif defined (BAKERY_VERTEXLMSH)
BakeryVertexLMSH(gi.indirect.diffuse, gi.indirect.specular, i.shL1x, i.shL1y, i.shL1z, s.normalWorld, s.eyeVec, s.smoothness);
gi.indirect.specular += prevSpec;
#endif
}
#endif
#ifdef BAKERY_RNM
if (bakeryLightmapMode == BAKERYMODE_RNM)
{
#ifdef BAKERY_SSBUMP
float3 normalMap = tex2D(_BumpMap, i.tex.xy).xyz;
#else
float3 normalMap = NormalInTangentSpace(i.tex);
#endif
float3 eyeVecT = 0;
#ifdef BAKERY_LMSPEC
eyeVecT = -NormalizePerPixelNormal(i.viewDirForParallax);
#endif
float3 prevSpec = gi.indirect.specular;
BakeryRNM(gi.indirect.diffuse, gi.indirect.specular, i.ambientOrLightmapUV.xy, normalMap, s.smoothness, eyeVecT);
gi.indirect.specular += prevSpec;
}
#endif
#ifdef BAKERY_SH
#if SHADER_TARGET >= 30
if (bakeryLightmapMode == BAKERYMODE_SH)
#endif
{
float3 prevSpec = gi.indirect.specular;
BakerySH(gi.indirect.diffuse, gi.indirect.specular, i.ambientOrLightmapUV.xy, s.normalWorld, s.eyeVec, s.smoothness);
gi.indirect.specular += prevSpec;
}
#endif
#ifdef DIRLIGHTMAP_COMBINED
#ifdef BAKERY_MONOSH
if (bakeryLightmapMode != BAKERYMODE_VERTEXLM)
{
float3 prevSpec = gi.indirect.specular;
BakeryMonoSH(gi.indirect.diffuse, gi.indirect.specular, i.ambientOrLightmapUV.xy, s.normalWorld, s.eyeVec, s.smoothness);
gi.indirect.specular += prevSpec;
}
#endif
#endif
half3 color = UNITY_BRDF_PBS(s.diffColor, s.specColor, s.oneMinusReflectivity, s.smoothness, s.normalWorld, -s.eyeVec, gi.light, gi.indirect).rgb;
color += UNITY_BRDF_GI(s.diffColor, s.specColor, s.oneMinusReflectivity, s.smoothness, s.normalWorld, -s.eyeVec, occlusion, gi);
#ifdef _EMISSION
color += Emission(i.tex.xy);
#endif
#ifndef UNITY_HDR_ON
color.rgb = exp2(-color.rgb);
#endif
outDiffuse = half4(s.diffColor, occlusion);
outSpecSmoothness = half4(s.specColor, s.smoothness);
outNormal = half4(s.normalWorld*0.5 + 0.5, 1);
outEmission = half4(color, 1);
// Baked direct lighting occlusion if any
#if defined(SHADOWS_SHADOWMASK) && (UNITY_ALLOWED_MRT_COUNT > 4)
#ifdef BAKERY_VOLUME
outShadowMask = _VolumeMask.Sample(sampler_Volume0, lpUV);
#elif BAKERY_VERTEXLMMASK
outShadowMask = i.ambientOrLightmapUV;
#else
outShadowMask = UnityGetRawBakedOcclusions(i.ambientOrLightmapUV.xy, IN_WORLDPOS(i));
#endif
#endif
}
#endif