squash commits
This commit is contained in:
+139
@@ -0,0 +1,139 @@
|
||||
//#ifndef UNITY_ANISOTROPIC_BRDF_INCLUDED
|
||||
//#define UNITY_ANISOTROPIC_BRDF_INCLUDED
|
||||
|
||||
// Anisotropic GGX
|
||||
// From HDRenderPipeline
|
||||
float D_GGXAnisotropic(float TdotH, float BdotH, float NdotH, float roughnessT, float roughnessB)
|
||||
{
|
||||
float f = TdotH * TdotH / (roughnessT * roughnessT) + BdotH * BdotH / (roughnessB * roughnessB) + NdotH * NdotH;
|
||||
return 1.0 / (roughnessT * roughnessB * f * f);
|
||||
}
|
||||
|
||||
// Smith Joint GGX Anisotropic Visibility
|
||||
// Taken from https://cedec.cesa.or.jp/2015/session/ENG/14698.html
|
||||
float SmithJointGGXAnisotropic(float TdotV, float BdotV, float NdotV, float TdotL, float BdotL, float NdotL, float roughnessT, float roughnessB)
|
||||
{
|
||||
float aT = roughnessT;
|
||||
float aT2 = aT * aT;
|
||||
float aB = roughnessB;
|
||||
float aB2 = aB * aB;
|
||||
|
||||
float lambdaV = NdotL * sqrt(aT2 * TdotV * TdotV + aB2 * BdotV * BdotV + NdotV * NdotV);
|
||||
float lambdaL = NdotV * sqrt(aT2 * TdotL * TdotL + aB2 * BdotL * BdotL + NdotL * NdotL);
|
||||
|
||||
return 0.5 / (lambdaV + lambdaL);
|
||||
}
|
||||
|
||||
// Convert Anistropy to roughness
|
||||
void ConvertAnisotropyToRoughness(float roughness, float anisotropy, out float roughnessT, out float roughnessB)
|
||||
{
|
||||
// (0 <= anisotropy <= 1), therefore (0 <= anisoAspect <= 1)
|
||||
// The 0.9 factor limits the aspect ratio to 10:1.
|
||||
float anisoAspect = sqrt(1.0 - 0.9 * anisotropy);
|
||||
roughnessT = roughness / anisoAspect; // Distort along tangent (rougher)
|
||||
roughnessB = roughness * anisoAspect; // Straighten along bitangent (smoother)
|
||||
}
|
||||
|
||||
// Schlick Fresnel
|
||||
float FresnelSchlick(float f0, float f90, float u)
|
||||
{
|
||||
float x = 1.0 - u;
|
||||
float x5 = x * x;
|
||||
x5 = x5 * x5 * x;
|
||||
return (f90 - f0) * x5 + f0; // sub mul mul mul sub mad
|
||||
}
|
||||
|
||||
//Clamp roughness
|
||||
float ClampRoughnessForAnalyticalLights(float roughness)
|
||||
{
|
||||
return max(roughness, 0.000001);
|
||||
}
|
||||
|
||||
// Ref: Donald Revie - Implementing Fur Using Deferred Shading (GPU Pro 2)
|
||||
// The grain direction (e.g. hair or brush direction) is assumed to be orthogonal to the normal.
|
||||
// The returned normal is NOT normalized.
|
||||
float3 ComputeGrainNormal(float3 grainDir, float3 V)
|
||||
{
|
||||
float3 B = cross(-V, grainDir);
|
||||
return cross(B, grainDir);
|
||||
}
|
||||
|
||||
//Modify Normal for Anisotropic IBL (Realtime version)
|
||||
// Fake anisotropic by distorting the normal.
|
||||
// The grain direction (e.g. hair or brush direction) is assumed to be orthogonal to N.
|
||||
// Anisotropic ratio (0->no isotropic; 1->full anisotropy in tangent direction)
|
||||
float3 GetAnisotropicModifiedNormal(float3 grainDir, float3 N, float3 V, float anisotropy)
|
||||
{
|
||||
float3 grainNormal = ComputeGrainNormal(grainDir, V);
|
||||
// TODO: test whether normalizing 'grainNormal' is worth it.
|
||||
return normalize(lerp(N, grainNormal, anisotropy));
|
||||
}
|
||||
|
||||
float4 AnisotropicBRDF(float3 diffColor, float3 specColor, float oneMinusReflectivity, float smoothness, float3 normal, float3x3 worldVectors,
|
||||
float anisotropy, float metallic, float3 viewDir, UnityLight light, UnityIndirect gi)
|
||||
{
|
||||
//Unpack world vectors
|
||||
float3 tangent = worldVectors[0];
|
||||
float3 bitangent = worldVectors[1];
|
||||
//Normal shift
|
||||
float shiftAmount = dot(normal, viewDir);
|
||||
normal = shiftAmount < 0.0f ? normal + viewDir * (-shiftAmount + 1e-5f) : normal;
|
||||
//Regular vectors
|
||||
float NdotL = saturate(dot(normal, light.dir));
|
||||
float NdotV = abs(dot(normal, viewDir));
|
||||
float LdotV = dot(light.dir, viewDir);
|
||||
float3 H = Unity_SafeNormalize(light.dir + viewDir);
|
||||
float invLenLV = rsqrt(abs(2 + 2 * normalize(LdotV)));
|
||||
float NdotH = saturate(dot(normal, H));
|
||||
float LdotH = saturate(dot(light.dir, H));
|
||||
//Tangent vectors
|
||||
float TdotH = dot(tangent, H);
|
||||
float TdotL = dot(tangent, light.dir);
|
||||
float BdotH = dot(bitangent, H);
|
||||
float BdotL = dot(bitangent, light.dir);
|
||||
float TdotV = dot(viewDir, tangent);
|
||||
float BdotV = dot(viewDir, bitangent);
|
||||
//Fresnels
|
||||
half grazingTerm = saturate(smoothness + (1 - oneMinusReflectivity));
|
||||
float3 F = FresnelLerp(specColor, grazingTerm, NdotV); //Original Schlick - Replace from SRP?
|
||||
//float3 fresnel0 = lerp(specColor, diffColor, metallic);
|
||||
//float3 F = FresnelSchlick(fresnel0, 1.0, LdotH);
|
||||
//Calculate roughness
|
||||
float roughnessT;
|
||||
float roughnessB;
|
||||
float perceptualRoughness = SmoothnessToPerceptualRoughness(smoothness);
|
||||
float roughness = PerceptualRoughnessToRoughness(perceptualRoughness);
|
||||
ConvertAnisotropyToRoughness(roughness, anisotropy, roughnessT, roughnessB);
|
||||
//Clamp roughness
|
||||
roughnessT = ClampRoughnessForAnalyticalLights(roughnessT);
|
||||
roughnessB = ClampRoughnessForAnalyticalLights(roughnessB);
|
||||
//Visibility & Distribution terms
|
||||
float V = SmithJointGGXAnisotropic(TdotV, BdotV, NdotV, TdotL, BdotL, NdotL, roughnessT, roughnessB);
|
||||
float D = D_GGXAnisotropic(TdotH, BdotH, NdotH, roughnessT, roughnessB);
|
||||
//Specular term
|
||||
float3 specularTerm = V * D;
|
||||
# ifdef UNITY_COLORSPACE_GAMMA
|
||||
specularTerm = sqrt(max(1e-4h, specularTerm));
|
||||
# endif
|
||||
// specularTerm * nl can be NaN on Metal in some cases, use max() to make sure it's a sane value
|
||||
specularTerm = max(0, specularTerm * NdotL);
|
||||
#if defined(_SPECULARHIGHLIGHTS_OFF)
|
||||
specularTerm = 0.0;
|
||||
#endif
|
||||
//Diffuse term
|
||||
float diffuseTerm = DisneyDiffuse(NdotV, NdotL, LdotH, perceptualRoughness) * NdotL;// - Need this NdotL multiply?
|
||||
//Reduction
|
||||
half surfaceReduction;
|
||||
# ifdef UNITY_COLORSPACE_GAMMA
|
||||
surfaceReduction = 1.0 - 0.28*roughness*perceptualRoughness; // 1-0.28*x^3 as approximation for (1/(x^4+1))^(1/2.2) on the domain [0;1]
|
||||
# else
|
||||
surfaceReduction = 1.0 / (roughness*roughness + 1.0); // fade \in [0.5;1]
|
||||
# endif
|
||||
//Final
|
||||
half3 color = (diffColor * (gi.diffuse + light.color * diffuseTerm))
|
||||
+ specularTerm * light.color * FresnelTerm(specColor, LdotH)
|
||||
+ surfaceReduction * gi.specular * FresnelLerp(specColor, grazingTerm, NdotV);
|
||||
return half4(color, 1);
|
||||
}
|
||||
|
||||
//#endif UNITY_ANISOTROPIC_BRDF_INCLUDED
|
||||
+16
@@ -0,0 +1,16 @@
|
||||
fileFormatVersion: 2
|
||||
guid: 6e08e7908d12f204dad78c6dd65d4fe2
|
||||
timeCreated: 1498921366
|
||||
licenseType: Store
|
||||
ShaderImporter:
|
||||
defaultTextures: []
|
||||
userData:
|
||||
assetBundleName:
|
||||
assetBundleVariant:
|
||||
AssetOrigin:
|
||||
serializedVersion: 1
|
||||
productId: 35611
|
||||
packageName: UMA 2
|
||||
packageVersion: 2.13
|
||||
assetPath: Assets/UMA/Content/Hair/Shader/UnityHairShader-master/Version6/CGIncludes/UnityAnisotropicBRDF.cginc
|
||||
uploadId: 679826
|
||||
+37
@@ -0,0 +1,37 @@
|
||||
//#ifndef UNITY_ANISOTROPIC_COMMON_INCLUDED
|
||||
//#define UNITY_ANISOTROPIC_COMMON_INCLUDED
|
||||
|
||||
// ------------------------------------------------------------------
|
||||
// Maths helpers
|
||||
|
||||
// Octahedron Normal Vectors
|
||||
// [Cigolle 2014, "A Survey of Efficient Representations for Independent Unit Vectors"]
|
||||
// Mean Max
|
||||
// oct 8:8 0.33709 0.94424
|
||||
// snorm 8:8:8 0.17015 0.38588
|
||||
// oct 10:10 0.08380 0.23467
|
||||
// snorm 10:10:10 0.04228 0.09598
|
||||
// oct 12:12 0.02091 0.05874
|
||||
|
||||
float2 UnitVectorToOctahedron(float3 N)
|
||||
{
|
||||
N.xy /= dot(1, abs(N));
|
||||
if (N.z <= 0)
|
||||
{
|
||||
N.xy = (1 - abs(N.yx)) * (N.xy >= 0 ? float2(1, 1) : float2(-1, -1));
|
||||
}
|
||||
return N.xy;
|
||||
}
|
||||
|
||||
float3 OctahedronToUnitVector(float2 Oct)
|
||||
{
|
||||
float3 N = float3(Oct, 1 - dot(1, abs(Oct)));
|
||||
if (N.z < 0)
|
||||
{
|
||||
N.xy = (1 - abs(N.yx)) * (N.xy >= 0 ? float2(1, 1) : float2(-1, -1));
|
||||
}
|
||||
return float3(1, 1, 1);
|
||||
return normalize(N);
|
||||
}
|
||||
|
||||
//#endif UNITY_ANISOTROPIC_COMMON_INCLUDED
|
||||
+16
@@ -0,0 +1,16 @@
|
||||
fileFormatVersion: 2
|
||||
guid: de3fb915cf4202344beb5b90d05c7fda
|
||||
timeCreated: 1491560472
|
||||
licenseType: Store
|
||||
ShaderImporter:
|
||||
defaultTextures: []
|
||||
userData:
|
||||
assetBundleName:
|
||||
assetBundleVariant:
|
||||
AssetOrigin:
|
||||
serializedVersion: 1
|
||||
productId: 35611
|
||||
packageName: UMA 2
|
||||
packageVersion: 2.13
|
||||
assetPath: Assets/UMA/Content/Hair/Shader/UnityHairShader-master/Version6/CGIncludes/UnityAnisotropicCommon.cginc
|
||||
uploadId: 679826
|
||||
+669
@@ -0,0 +1,669 @@
|
||||
// Unity built-in shader source. Copyright (c) 2016 Unity Technologies. MIT license (see license.txt)
|
||||
|
||||
#ifndef UNITY_ANISOTROPIC_CORE_INCLUDED
|
||||
#define UNITY_ANISOTROPIC_CORE_INCLUDED
|
||||
|
||||
#include "UnityCG.cginc"
|
||||
#include "UnityStandardConfig.cginc"
|
||||
#include "UnityAnisotropicInput.cginc"
|
||||
#include "UnityAnisotropicBRDF.cginc"
|
||||
#include "UnityAnisotropicLighting.cginc"
|
||||
#include "UnityStandardUtils.cginc"
|
||||
#include "UnityGBuffer.cginc"
|
||||
#include "AutoLight.cginc"
|
||||
|
||||
//-------------------------------------------------------------------------------------
|
||||
// counterpart for NormalizePerPixelNormal
|
||||
// skips normalization per-vertex and expects normalization to happen per-pixel
|
||||
half3 NormalizePerVertexNormal (float3 n) // takes float to avoid overflow
|
||||
{
|
||||
#if (SHADER_TARGET < 30) || UNITY_STANDARD_SIMPLE
|
||||
return normalize(n);
|
||||
#else
|
||||
return n; // will normalize per-pixel instead
|
||||
#endif
|
||||
}
|
||||
|
||||
half3 NormalizePerPixelNormal (half3 n)
|
||||
{
|
||||
#if (SHADER_TARGET < 30) || UNITY_STANDARD_SIMPLE
|
||||
return n;
|
||||
#else
|
||||
return normalize(n);
|
||||
#endif
|
||||
}
|
||||
|
||||
//-------------------------------------------------------------------------------------
|
||||
UnityLight MainLight ()
|
||||
{
|
||||
UnityLight l;
|
||||
|
||||
l.color = _LightColor0.rgb;
|
||||
l.dir = _WorldSpaceLightPos0.xyz;
|
||||
return l;
|
||||
}
|
||||
|
||||
UnityLight AdditiveLight (half3 lightDir, half atten)
|
||||
{
|
||||
UnityLight l;
|
||||
|
||||
l.color = _LightColor0.rgb;
|
||||
l.dir = lightDir;
|
||||
#ifndef USING_DIRECTIONAL_LIGHT
|
||||
l.dir = NormalizePerPixelNormal(l.dir);
|
||||
#endif
|
||||
|
||||
// shadow the light
|
||||
l.color *= atten;
|
||||
return l;
|
||||
}
|
||||
|
||||
UnityLight DummyLight ()
|
||||
{
|
||||
UnityLight l;
|
||||
l.color = 0;
|
||||
l.dir = half3 (0,1,0);
|
||||
return l;
|
||||
}
|
||||
|
||||
UnityIndirect ZeroIndirect ()
|
||||
{
|
||||
UnityIndirect ind;
|
||||
ind.diffuse = 0;
|
||||
ind.specular = 0;
|
||||
return ind;
|
||||
}
|
||||
|
||||
//-------------------------------------------------------------------------------------
|
||||
// Common fragment setup
|
||||
|
||||
// deprecated
|
||||
half3 WorldNormal(half4 tan2world[3])
|
||||
{
|
||||
return normalize(tan2world[2].xyz);
|
||||
}
|
||||
|
||||
// deprecated
|
||||
#ifdef _TANGENT_TO_WORLD
|
||||
half3x3 ExtractTangentToWorldPerPixel(half4 tan2world[3])
|
||||
{
|
||||
half3 t = tan2world[0].xyz;
|
||||
half3 b = tan2world[1].xyz;
|
||||
half3 n = tan2world[2].xyz;
|
||||
|
||||
#if UNITY_TANGENT_ORTHONORMALIZE
|
||||
n = NormalizePerPixelNormal(n);
|
||||
|
||||
// ortho-normalize Tangent
|
||||
t = normalize (t - n * dot(t, n));
|
||||
|
||||
// recalculate Binormal
|
||||
half3 newB = cross(n, t);
|
||||
b = newB * sign (dot (newB, b));
|
||||
#endif
|
||||
|
||||
return half3x3(t, b, n);
|
||||
}
|
||||
#else
|
||||
half3x3 ExtractTangentToWorldPerPixel(half4 tan2world[3])
|
||||
{
|
||||
return half3x3(0,0,0,0,0,0,0,0,0);
|
||||
}
|
||||
#endif
|
||||
|
||||
half3 PerPixelWorldNormal(float4 i_tex, half4 tangentToWorld[3])
|
||||
{
|
||||
#ifdef _NORMALMAP
|
||||
half3 tangent = tangentToWorld[0].xyz;
|
||||
half3 binormal = tangentToWorld[1].xyz;
|
||||
half3 normal = tangentToWorld[2].xyz;
|
||||
|
||||
#if UNITY_TANGENT_ORTHONORMALIZE
|
||||
normal = NormalizePerPixelNormal(normal);
|
||||
|
||||
// ortho-normalize Tangent
|
||||
tangent = normalize (tangent - normal * dot(tangent, normal));
|
||||
|
||||
// recalculate Binormal
|
||||
half3 newB = cross(normal, tangent);
|
||||
binormal = newB * sign (dot (newB, binormal));
|
||||
#endif
|
||||
|
||||
half3 normalTangent = NormalInTangentSpace(i_tex);
|
||||
half3 normalWorld = NormalizePerPixelNormal(tangent * normalTangent.x + binormal * normalTangent.y + normal * normalTangent.z); // @TODO: see if we can squeeze this normalize on SM2.0 as well
|
||||
#else
|
||||
half3 normalWorld = normalize(tangentToWorld[2].xyz);
|
||||
#endif
|
||||
return normalWorld;
|
||||
}
|
||||
|
||||
#ifdef _PARALLAXMAP
|
||||
#define IN_VIEWDIR4PARALLAX(i) NormalizePerPixelNormal(half3(i.tangentToWorldAndPackedData[0].w,i.tangentToWorldAndPackedData[1].w,i.tangentToWorldAndPackedData[2].w))
|
||||
#define IN_VIEWDIR4PARALLAX_FWDADD(i) NormalizePerPixelNormal(i.viewDirForParallax.xyz)
|
||||
#else
|
||||
#define IN_VIEWDIR4PARALLAX(i) half3(0,0,0)
|
||||
#define IN_VIEWDIR4PARALLAX_FWDADD(i) half3(0,0,0)
|
||||
#endif
|
||||
|
||||
#if UNITY_REQUIRE_FRAG_WORLDPOS
|
||||
#if UNITY_PACK_WORLDPOS_WITH_TANGENT
|
||||
#define IN_WORLDPOS(i) half3(i.tangentToWorldAndPackedData[0].w,i.tangentToWorldAndPackedData[1].w,i.tangentToWorldAndPackedData[2].w)
|
||||
#else
|
||||
#define IN_WORLDPOS(i) i.posWorld
|
||||
#endif
|
||||
#define IN_WORLDPOS_FWDADD(i) i.posWorld
|
||||
#else
|
||||
#define IN_WORLDPOS(i) half3(0,0,0)
|
||||
#define IN_WORLDPOS_FWDADD(i) half3(0,0,0)
|
||||
#endif
|
||||
|
||||
#define IN_LIGHTDIR_FWDADD(i) half3(i.tangentToWorldAndLightDir[0].w, i.tangentToWorldAndLightDir[1].w, i.tangentToWorldAndLightDir[2].w)
|
||||
|
||||
#define FRAGMENT_SETUP(x) FragmentCommonData x = \
|
||||
FragmentSetup(i.tex, i.eyeVec, IN_VIEWDIR4PARALLAX(i), i.tangentToWorldAndPackedData, IN_WORLDPOS(i));
|
||||
|
||||
#define FRAGMENT_SETUP_FWDADD(x) FragmentCommonData x = \
|
||||
FragmentSetup(i.tex, i.eyeVec, IN_VIEWDIR4PARALLAX_FWDADD(i), i.tangentToWorldAndLightDir, IN_WORLDPOS_FWDADD(i));
|
||||
|
||||
struct FragmentCommonData
|
||||
{
|
||||
half3 diffColor, specColor;
|
||||
// Note: smoothness & oneMinusReflectivity for optimization purposes, mostly for DX9 SM2.0 level.
|
||||
// Most of the math is being done on these (1-x) values, and that saves a few precious ALU slots.
|
||||
half oneMinusReflectivity, smoothness, metallic, anisotropy;
|
||||
half3 normalWorld, eyeVec, posWorld;
|
||||
half3x3 worldVectors;
|
||||
half alpha;
|
||||
|
||||
#if UNITY_STANDARD_SIMPLE
|
||||
half3 reflUVW;
|
||||
#endif
|
||||
|
||||
#if UNITY_STANDARD_SIMPLE
|
||||
half3 tangentSpaceNormal;
|
||||
#endif
|
||||
};
|
||||
|
||||
#ifndef UNITY_SETUP_BRDF_INPUT
|
||||
#define UNITY_SETUP_BRDF_INPUT SpecularSetup
|
||||
#endif
|
||||
|
||||
inline FragmentCommonData AnisotropicMetallicSetup (float4 i_tex)
|
||||
{
|
||||
half2 metallicGloss = MetallicGloss(i_tex.xy);
|
||||
half metallic = metallicGloss.x;
|
||||
half smoothness = metallicGloss.y; // this is 1 minus the square root of real roughness m.
|
||||
|
||||
half oneMinusReflectivity;
|
||||
half3 specColor;
|
||||
half3 diffColor = DiffuseAndSpecularFromMetallic (Albedo(i_tex), metallic, /*out*/ specColor, /*out*/ oneMinusReflectivity);
|
||||
|
||||
FragmentCommonData o = (FragmentCommonData)0;
|
||||
o.diffColor = diffColor;
|
||||
o.specColor = specColor;
|
||||
o.oneMinusReflectivity = oneMinusReflectivity;
|
||||
o.smoothness = smoothness;
|
||||
o.metallic = metallic;
|
||||
o.anisotropy = Anisotropy(i_tex.xy);
|
||||
|
||||
return o;
|
||||
}
|
||||
|
||||
inline FragmentCommonData FragmentSetup (float4 i_tex, half3 i_eyeVec, half3 i_viewDirForParallax, half4 tangentToWorld[3], half3 i_posWorld)
|
||||
{
|
||||
i_tex = Parallax(i_tex, i_viewDirForParallax);
|
||||
|
||||
half alpha = Alpha(i_tex.xy);
|
||||
#if defined(_ALPHATEST_ON)
|
||||
clip (alpha - _Cutoff);
|
||||
#endif
|
||||
|
||||
FragmentCommonData o = AnisotropicMetallicSetup(i_tex);
|
||||
o.normalWorld = PerPixelWorldNormal(i_tex, tangentToWorld);
|
||||
o.worldVectors = WorldVectors(i_tex, tangentToWorld);
|
||||
o.eyeVec = NormalizePerPixelNormal(i_eyeVec);
|
||||
o.posWorld = i_posWorld;
|
||||
|
||||
// NOTE: shader relies on pre-multiply alpha-blend (_SrcBlend = One, _DstBlend = OneMinusSrcAlpha)
|
||||
o.diffColor = PreMultiplyAlpha (o.diffColor, alpha, o.oneMinusReflectivity, /*out*/ o.alpha);
|
||||
return o;
|
||||
}
|
||||
|
||||
inline UnityGI FragmentGI (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;
|
||||
#else
|
||||
g.reflUVW = reflect(s.eyeVec, s.normalWorld);
|
||||
#endif
|
||||
return UnityAnisotropicGlobalIllumination(d, occlusion, s.normalWorld, g, s.anisotropy, s.worldVectors);
|
||||
}
|
||||
else
|
||||
{
|
||||
return UnityGlobalIllumination(d, occlusion, s.normalWorld);
|
||||
}
|
||||
}
|
||||
|
||||
inline UnityGI FragmentGI (FragmentCommonData s, half occlusion, half4 i_ambientOrLightmapUV, half atten, UnityLight light)
|
||||
{
|
||||
return FragmentGI(s, occlusion, i_ambientOrLightmapUV, atten, light, true);
|
||||
}
|
||||
|
||||
|
||||
//-------------------------------------------------------------------------------------
|
||||
half4 OutputForward (half4 output, half alphaFromSurface)
|
||||
{
|
||||
#if defined(_ALPHABLEND_ON) || defined(_ALPHAPREMULTIPLY_ON)
|
||||
output.a = alphaFromSurface;
|
||||
#else
|
||||
UNITY_OPAQUE_ALPHA(output.a);
|
||||
#endif
|
||||
return output;
|
||||
}
|
||||
|
||||
inline half4 VertexGIForward(VertexInput v, float3 posWorld, half3 normalWorld)
|
||||
{
|
||||
half4 ambientOrLightmapUV = 0;
|
||||
// Static lightmaps
|
||||
#ifdef LIGHTMAP_ON
|
||||
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
|
||||
|
||||
return ambientOrLightmapUV;
|
||||
}
|
||||
|
||||
// ------------------------------------------------------------------
|
||||
// Base forward pass (directional light, emission, lightmaps, ...)
|
||||
|
||||
struct VertexOutputForwardBase
|
||||
{
|
||||
float4 pos : SV_POSITION;
|
||||
float4 tex : TEXCOORD0;
|
||||
half3 eyeVec : TEXCOORD1;
|
||||
half4 tangentToWorldAndPackedData[3] : TEXCOORD2; // [3x3:tangentToWorld | 1x3:viewDirForParallax]
|
||||
half4 ambientOrLightmapUV : TEXCOORD5; // SH or Lightmap UV
|
||||
UNITY_SHADOW_COORDS(6)
|
||||
UNITY_FOG_COORDS(7)
|
||||
float3 posWorld : TEXCOORD8; //Removed #if UNITY_SPECCUBE_BOX_PROJECTION, need world pos for curvature calculation
|
||||
|
||||
UNITY_VERTEX_INPUT_INSTANCE_ID
|
||||
UNITY_VERTEX_OUTPUT_STEREO
|
||||
};
|
||||
|
||||
VertexOutputForwardBase vertForwardBase (VertexInput v)
|
||||
{
|
||||
UNITY_SETUP_INSTANCE_ID(v);
|
||||
VertexOutputForwardBase o;
|
||||
UNITY_INITIALIZE_OUTPUT(VertexOutputForwardBase, o);
|
||||
UNITY_TRANSFER_INSTANCE_ID(v, o);
|
||||
UNITY_INITIALIZE_VERTEX_OUTPUT_STEREO(o);
|
||||
|
||||
float4 posWorld = mul(unity_ObjectToWorld, v.vertex);
|
||||
o.posWorld = posWorld.xyz; //Removed #if UNITY_SPECCUBE_BOX_PROJECTION, need world pos for curvature calculation
|
||||
o.pos = UnityObjectToClipPos(v.vertex);
|
||||
o.tex = TexCoords(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
|
||||
|
||||
//We need this for shadow receving
|
||||
UNITY_TRANSFER_SHADOW(o, v.uv1);
|
||||
|
||||
o.ambientOrLightmapUV = VertexGIForward(v, posWorld, normalWorld);
|
||||
|
||||
#ifdef _PARALLAXMAP
|
||||
TANGENT_SPACE_ROTATION;
|
||||
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 UNITY_OPTIMIZE_TEXCUBELOD
|
||||
o.reflUVW = reflect(o.eyeVec, normalWorld);
|
||||
#endif
|
||||
|
||||
UNITY_TRANSFER_FOG(o,o.pos);
|
||||
return o;
|
||||
}
|
||||
|
||||
half4 fragForwardBaseInternal (VertexOutputForwardBase i)
|
||||
{
|
||||
FRAGMENT_SETUP(s)
|
||||
|
||||
#if UNITY_OPTIMIZE_TEXCUBELOD
|
||||
s.reflUVW = i.reflUVW;
|
||||
#endif
|
||||
|
||||
UNITY_SETUP_INSTANCE_ID(i);
|
||||
UNITY_SETUP_STEREO_EYE_INDEX_POST_VERTEX(i);
|
||||
|
||||
UnityLight mainLight = MainLight ();
|
||||
UNITY_LIGHT_ATTENUATION(atten, i, s.posWorld);
|
||||
|
||||
half occlusion = Occlusion(i.tex.xy);
|
||||
UnityGI gi = FragmentGI (s, occlusion, i.ambientOrLightmapUV, atten, mainLight);
|
||||
|
||||
half4 c = AnisotropicBRDF(s.diffColor, s.specColor, s.oneMinusReflectivity, s.smoothness, s.normalWorld, s.worldVectors, s.anisotropy, s.metallic, -s.eyeVec, gi.light, gi.indirect);
|
||||
c.rgb += Emission(i.tex.xy);
|
||||
|
||||
UNITY_APPLY_FOG(i.fogCoord, c.rgb);
|
||||
return OutputForward (c, s.alpha);
|
||||
}
|
||||
|
||||
half4 fragForwardBase (VertexOutputForwardBase i) : SV_Target // backward compatibility (this used to be the fragment entry function)
|
||||
{
|
||||
return fragForwardBaseInternal(i);
|
||||
}
|
||||
|
||||
// ------------------------------------------------------------------
|
||||
// Additive forward pass (one light per pass)
|
||||
|
||||
struct VertexOutputForwardAdd
|
||||
{
|
||||
float4 pos : SV_POSITION;
|
||||
float4 tex : TEXCOORD0;
|
||||
half3 eyeVec : TEXCOORD1;
|
||||
half4 tangentToWorldAndLightDir[3] : TEXCOORD2; // [3x3:tangentToWorld | 1x3:lightDir]
|
||||
//float3 posWorld : TEXCOORD5;
|
||||
LIGHTING_COORDS(5, 6)
|
||||
//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
|
||||
float3 posWorld : TEXCOORD9;
|
||||
UNITY_VERTEX_OUTPUT_STEREO
|
||||
};
|
||||
|
||||
VertexOutputForwardAdd vertForwardAdd (VertexInput v)
|
||||
{
|
||||
UNITY_SETUP_INSTANCE_ID(v);
|
||||
VertexOutputForwardAdd o;
|
||||
UNITY_INITIALIZE_OUTPUT(VertexOutputForwardAdd, o);
|
||||
UNITY_INITIALIZE_VERTEX_OUTPUT_STEREO(o);
|
||||
|
||||
float4 posWorld = mul(unity_ObjectToWorld, v.vertex);
|
||||
o.posWorld = posWorld.xyz;
|
||||
o.pos = UnityObjectToClipPos(v.vertex);
|
||||
o.tex = TexCoords(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.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 receiving
|
||||
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
|
||||
|
||||
UNITY_TRANSFER_FOG(o,o.pos);
|
||||
return o;
|
||||
}
|
||||
|
||||
half4 fragForwardAddInternal (VertexOutputForwardAdd i)
|
||||
{
|
||||
FRAGMENT_SETUP_FWDADD(s)
|
||||
|
||||
UNITY_LIGHT_ATTENUATION(atten, i, s.posWorld)
|
||||
UnityLight light = AdditiveLight (IN_LIGHTDIR_FWDADD(i), atten);
|
||||
UnityIndirect noIndirect = ZeroIndirect ();
|
||||
|
||||
half4 c = AnisotropicBRDF(s.diffColor, s.specColor, s.oneMinusReflectivity, s.smoothness, s.normalWorld, s.worldVectors, s.anisotropy, s.metallic, -s.eyeVec, light, noIndirect);
|
||||
|
||||
UNITY_APPLY_FOG_COLOR(i.fogCoord, c.rgb, half4(0,0,0,0)); // fog towards black in additive pass
|
||||
return OutputForward (c, s.alpha);
|
||||
}
|
||||
|
||||
half4 fragForwardAdd (VertexOutputForwardAdd i) : SV_Target // backward compatibility (this used to be the fragment entry function)
|
||||
{
|
||||
return fragForwardAddInternal(i);
|
||||
}
|
||||
|
||||
// ------------------------------------------------------------------
|
||||
// Deferred pass
|
||||
|
||||
struct VertexOutputDeferred
|
||||
{
|
||||
float4 pos : SV_POSITION;
|
||||
float4 tex : TEXCOORD0;
|
||||
half3 eyeVec : TEXCOORD1;
|
||||
half4 tangentToWorldAndPackedData[3]: TEXCOORD2; // [3x3:tangentToWorld | 1x3:viewDirForParallax or worldPos]
|
||||
half4 ambientOrLightmapUV : TEXCOORD5; // SH or Lightmap UVs
|
||||
|
||||
#if UNITY_REQUIRE_FRAG_WORLDPOS && !UNITY_PACK_WORLDPOS_WITH_TANGENT
|
||||
float3 posWorld : TEXCOORD6;
|
||||
#endif
|
||||
|
||||
UNITY_VERTEX_OUTPUT_STEREO
|
||||
};
|
||||
|
||||
|
||||
VertexOutputDeferred vertDeferred (VertexInput v)
|
||||
{
|
||||
UNITY_SETUP_INSTANCE_ID(v);
|
||||
VertexOutputDeferred o;
|
||||
UNITY_INITIALIZE_OUTPUT(VertexOutputDeferred, 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);
|
||||
|
||||
o.tex = TexCoords(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;
|
||||
#ifdef LIGHTMAP_ON
|
||||
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 _PARALLAXMAP
|
||||
TANGENT_SPACE_ROTATION;
|
||||
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
|
||||
|
||||
return o;
|
||||
}
|
||||
|
||||
void fragDeferred (
|
||||
VertexOutputDeferred i,
|
||||
out half4 outGBuffer0 : SV_Target0,
|
||||
out half4 outGBuffer1 : SV_Target1,
|
||||
out half4 outGBuffer2 : SV_Target2,
|
||||
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)
|
||||
outGBuffer0 = 1;
|
||||
outGBuffer1 = 1;
|
||||
outGBuffer2 = 0;
|
||||
outEmission = 0;
|
||||
#if defined(SHADOWS_SHADOWMASK) && (UNITY_ALLOWED_MRT_COUNT > 4)
|
||||
outShadowMask = 1;
|
||||
#endif
|
||||
return;
|
||||
#endif
|
||||
|
||||
FRAGMENT_SETUP(s)
|
||||
|
||||
// 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);
|
||||
|
||||
half3 emissiveColor = UNITY_BRDF_PBS (s.diffColor, s.specColor, s.oneMinusReflectivity, s.smoothness, s.normalWorld, -s.eyeVec, gi.light, gi.indirect).rgb;
|
||||
|
||||
#ifdef _EMISSION
|
||||
emissiveColor += Emission (i.tex.xy);
|
||||
#endif
|
||||
|
||||
#ifndef UNITY_HDR_ON
|
||||
emissiveColor.rgb = exp2(-emissiveColor.rgb);
|
||||
#endif
|
||||
|
||||
UnityStandardData data;
|
||||
data.diffuseColor = s.diffColor;
|
||||
data.occlusion = occlusion;
|
||||
data.specularColor = s.specColor;
|
||||
data.smoothness = s.smoothness;
|
||||
data.normalWorld = s.normalWorld;
|
||||
|
||||
UnityStandardDataToGbuffer(data, outGBuffer0, outGBuffer1, outGBuffer2);
|
||||
|
||||
// Emissive lighting buffer
|
||||
outEmission = half4(emissiveColor, 1);
|
||||
|
||||
// Baked direct lighting occlusion if any
|
||||
#if defined(SHADOWS_SHADOWMASK) && (UNITY_ALLOWED_MRT_COUNT > 4)
|
||||
outShadowMask = UnityGetRawBakedOcclusions(i.ambientOrLightmapUV.xy, IN_WORLDPOS(i));
|
||||
#endif
|
||||
}
|
||||
|
||||
|
||||
//
|
||||
// Old FragmentGI signature. Kept only for backward compatibility and will be removed soon
|
||||
//
|
||||
|
||||
inline UnityGI FragmentGI(
|
||||
float3 posWorld,
|
||||
half occlusion, half4 i_ambientOrLightmapUV, half atten, half smoothness, half3 normalWorld, half3 eyeVec,
|
||||
UnityLight light,
|
||||
bool reflections)
|
||||
{
|
||||
// we init only fields actually used
|
||||
FragmentCommonData s = (FragmentCommonData)0;
|
||||
s.smoothness = smoothness;
|
||||
s.normalWorld = normalWorld;
|
||||
s.eyeVec = eyeVec;
|
||||
s.posWorld = posWorld;
|
||||
return FragmentGI(s, occlusion, i_ambientOrLightmapUV, atten, light, reflections);
|
||||
}
|
||||
inline UnityGI FragmentGI (
|
||||
float3 posWorld,
|
||||
half occlusion, half4 i_ambientOrLightmapUV, half atten, half smoothness, half3 normalWorld, half3 eyeVec,
|
||||
UnityLight light)
|
||||
{
|
||||
return FragmentGI (posWorld, occlusion, i_ambientOrLightmapUV, atten, smoothness, normalWorld, eyeVec, light, true);
|
||||
}
|
||||
|
||||
#endif // UNITY_STANDARD_ANISOTROPIC_CORE_INCLUDED
|
||||
+16
@@ -0,0 +1,16 @@
|
||||
fileFormatVersion: 2
|
||||
guid: 1ebd6ffe27d4a4d42aa2e158e878d1f9
|
||||
timeCreated: 1491659087
|
||||
licenseType: Store
|
||||
ShaderImporter:
|
||||
defaultTextures: []
|
||||
userData:
|
||||
assetBundleName:
|
||||
assetBundleVariant:
|
||||
AssetOrigin:
|
||||
serializedVersion: 1
|
||||
productId: 35611
|
||||
packageName: UMA 2
|
||||
packageVersion: 2.13
|
||||
assetPath: Assets/UMA/Content/Hair/Shader/UnityHairShader-master/Version6/CGIncludes/UnityAnisotropicCore.cginc
|
||||
uploadId: 679826
|
||||
+26
@@ -0,0 +1,26 @@
|
||||
// Unity built-in shader source. Copyright (c) 2016 Unity Technologies. MIT license (see license.txt)
|
||||
|
||||
//#ifndef UNITY_ANISOTROPIC_CORE_FORWARD_INCLUDED
|
||||
//#define UNITY_ANISOTROPIC_CORE_FORWARD_INCLUDED
|
||||
|
||||
#if defined(UNITY_NO_FULL_STANDARD_SHADER)
|
||||
#define UNITY_STANDARD_SIMPLE 1
|
||||
#endif
|
||||
|
||||
#include "UnityStandardConfig.cginc"
|
||||
|
||||
#if UNITY_STANDARD_SIMPLE
|
||||
#include "UnityAnisotropicCoreForwardSimple.cginc"
|
||||
VertexOutputBaseSimple vertBase (VertexInput v) { return vertForwardBaseSimple(v); }
|
||||
VertexOutputForwardAddSimple vertAdd (VertexInput v) { return vertForwardAddSimple(v); }
|
||||
half4 fragBase (VertexOutputBaseSimple i) : SV_Target { return fragForwardBaseSimpleInternal(i); }
|
||||
half4 fragAdd (VertexOutputForwardAddSimple i) : SV_Target { return fragForwardAddSimpleInternal(i); }
|
||||
#else
|
||||
#include "UnityAnisotropicCore.cginc"
|
||||
VertexOutputForwardBase vertBase (VertexInput v) { return vertForwardBase(v); }
|
||||
VertexOutputForwardAdd vertAdd (VertexInput v) { return vertForwardAdd(v); }
|
||||
half4 fragBase (VertexOutputForwardBase i) : SV_Target { return fragForwardBaseInternal(i); }
|
||||
half4 fragAdd (VertexOutputForwardAdd i) : SV_Target { return fragForwardAddInternal(i); }
|
||||
#endif
|
||||
|
||||
//#endif UNITY_STANDARD_ANISOTROPIC_CORE_FORWARD_INCLUDED
|
||||
+16
@@ -0,0 +1,16 @@
|
||||
fileFormatVersion: 2
|
||||
guid: a2a85c2eb385f0442a6276470ab73685
|
||||
timeCreated: 1491659087
|
||||
licenseType: Store
|
||||
ShaderImporter:
|
||||
defaultTextures: []
|
||||
userData:
|
||||
assetBundleName:
|
||||
assetBundleVariant:
|
||||
AssetOrigin:
|
||||
serializedVersion: 1
|
||||
productId: 35611
|
||||
packageName: UMA 2
|
||||
packageVersion: 2.13
|
||||
assetPath: Assets/UMA/Content/Hair/Shader/UnityHairShader-master/Version6/CGIncludes/UnityAnisotropicCoreForward.cginc
|
||||
uploadId: 679826
|
||||
+364
@@ -0,0 +1,364 @@
|
||||
// Unity built-in shader source. Copyright (c) 2016 Unity Technologies. MIT license (see license.txt)
|
||||
|
||||
#ifndef UNITY_ANISOTROPIC_CORE_FORWARD_SIMPLE_INCLUDED
|
||||
#define UNITY_ANISOTROPIC_CORE_FORWARD_SIMPLE_INCLUDED
|
||||
|
||||
#include "UnityAnisotropicCore.cginc"
|
||||
|
||||
// Does not support: _PARALLAXMAP, DIRLIGHTMAP_COMBINED
|
||||
#define GLOSSMAP (defined(_SPECGLOSSMAP) || defined(_METALLICGLOSSMAP))
|
||||
|
||||
#ifndef SPECULAR_HIGHLIGHTS
|
||||
#define SPECULAR_HIGHLIGHTS (!defined(_SPECULAR_HIGHLIGHTS_OFF))
|
||||
#endif
|
||||
|
||||
struct VertexOutputBaseSimple
|
||||
{
|
||||
float4 pos : SV_POSITION;
|
||||
float4 tex : TEXCOORD0;
|
||||
half4 eyeVec : TEXCOORD1; // w: grazingTerm
|
||||
|
||||
half4 ambientOrLightmapUV : TEXCOORD2; // SH or Lightmap UV
|
||||
SHADOW_COORDS(3)
|
||||
UNITY_FOG_COORDS_PACKED(4, half4) // x: fogCoord, yzw: reflectVec
|
||||
|
||||
half4 normalWorld : TEXCOORD5; // w: fresnelTerm
|
||||
|
||||
#ifdef _NORMALMAP
|
||||
half3 tangentSpaceLightDir : TEXCOORD6;
|
||||
#if SPECULAR_HIGHLIGHTS
|
||||
half3 tangentSpaceEyeVec : TEXCOORD7;
|
||||
#endif
|
||||
#endif
|
||||
#if UNITY_REQUIRE_FRAG_WORLDPOS
|
||||
float3 posWorld : TEXCOORD8;
|
||||
#endif
|
||||
|
||||
UNITY_VERTEX_OUTPUT_STEREO
|
||||
};
|
||||
|
||||
// UNIFORM_REFLECTIVITY(): workaround to get (uniform) reflecivity based on UNITY_SETUP_BRDF_INPUT
|
||||
half MetallicSetup_Reflectivity()
|
||||
{
|
||||
return 1.0h - OneMinusReflectivityFromMetallic(_Metallic);
|
||||
}
|
||||
|
||||
half SpecularSetup_Reflectivity()
|
||||
{
|
||||
return SpecularStrength(_SpecColor.rgb);
|
||||
}
|
||||
|
||||
#define JOIN2(a, b) a##b
|
||||
#define JOIN(a, b) JOIN2(a,b)
|
||||
#define UNIFORM_REFLECTIVITY JOIN(UNITY_SETUP_BRDF_INPUT, _Reflectivity)
|
||||
|
||||
|
||||
#ifdef _NORMALMAP
|
||||
|
||||
half3 TransformToTangentSpace(half3 tangent, half3 binormal, half3 normal, half3 v)
|
||||
{
|
||||
// Mali400 shader compiler prefers explicit dot product over using a half3x3 matrix
|
||||
return half3(dot(tangent, v), dot(binormal, v), dot(normal, v));
|
||||
}
|
||||
|
||||
void TangentSpaceLightingInput(half3 normalWorld, half4 vTangent, half3 lightDirWorld, half3 eyeVecWorld, out half3 tangentSpaceLightDir, out half3 tangentSpaceEyeVec)
|
||||
{
|
||||
half3 tangentWorld = UnityObjectToWorldDir(vTangent.xyz);
|
||||
half sign = half(vTangent.w) * half(unity_WorldTransformParams.w);
|
||||
half3 binormalWorld = cross(normalWorld, tangentWorld) * sign;
|
||||
tangentSpaceLightDir = TransformToTangentSpace(tangentWorld, binormalWorld, normalWorld, lightDirWorld);
|
||||
#if SPECULAR_HIGHLIGHTS
|
||||
tangentSpaceEyeVec = normalize(TransformToTangentSpace(tangentWorld, binormalWorld, normalWorld, eyeVecWorld));
|
||||
#else
|
||||
tangentSpaceEyeVec = 0;
|
||||
#endif
|
||||
}
|
||||
|
||||
#endif // _NORMALMAP
|
||||
|
||||
VertexOutputBaseSimple vertForwardBaseSimple (VertexInput v)
|
||||
{
|
||||
UNITY_SETUP_INSTANCE_ID(v);
|
||||
VertexOutputBaseSimple o;
|
||||
UNITY_INITIALIZE_OUTPUT(VertexOutputBaseSimple, o);
|
||||
UNITY_INITIALIZE_VERTEX_OUTPUT_STEREO(o);
|
||||
|
||||
float4 posWorld = mul(unity_ObjectToWorld, v.vertex);
|
||||
o.pos = UnityObjectToClipPos(v.vertex);
|
||||
o.tex = TexCoords(v);
|
||||
|
||||
half3 eyeVec = normalize(posWorld.xyz - _WorldSpaceCameraPos);
|
||||
half3 normalWorld = UnityObjectToWorldNormal(v.normal);
|
||||
|
||||
o.normalWorld.xyz = normalWorld;
|
||||
o.eyeVec.xyz = eyeVec;
|
||||
|
||||
#ifdef _NORMALMAP
|
||||
half3 tangentSpaceEyeVec;
|
||||
TangentSpaceLightingInput(normalWorld, v.tangent, _WorldSpaceLightPos0.xyz, eyeVec, o.tangentSpaceLightDir, tangentSpaceEyeVec);
|
||||
#if SPECULAR_HIGHLIGHTS
|
||||
o.tangentSpaceEyeVec = tangentSpaceEyeVec;
|
||||
#endif
|
||||
#endif
|
||||
|
||||
//We need this for shadow receiving
|
||||
TRANSFER_SHADOW(o);
|
||||
|
||||
o.ambientOrLightmapUV = VertexGIForward(v, posWorld, normalWorld);
|
||||
|
||||
o.fogCoord.yzw = reflect(eyeVec, normalWorld);
|
||||
|
||||
o.normalWorld.w = Pow4(1 - saturate(dot(normalWorld, -eyeVec))); // fresnel term
|
||||
#if !GLOSSMAP
|
||||
o.eyeVec.w = saturate(_Glossiness + UNIFORM_REFLECTIVITY()); // grazing term
|
||||
#endif
|
||||
|
||||
UNITY_TRANSFER_FOG(o, o.pos);
|
||||
return o;
|
||||
}
|
||||
|
||||
|
||||
FragmentCommonData FragmentSetupSimple(VertexOutputBaseSimple i)
|
||||
{
|
||||
half alpha = Alpha(i.tex.xy);
|
||||
#if defined(_ALPHATEST_ON)
|
||||
clip (alpha - _Cutoff);
|
||||
#endif
|
||||
|
||||
FragmentCommonData s = UNITY_SETUP_BRDF_INPUT (i.tex);
|
||||
|
||||
// NOTE: shader relies on pre-multiply alpha-blend (_SrcBlend = One, _DstBlend = OneMinusSrcAlpha)
|
||||
s.diffColor = PreMultiplyAlpha (s.diffColor, alpha, s.oneMinusReflectivity, /*out*/ s.alpha);
|
||||
|
||||
s.normalWorld = i.normalWorld.xyz;
|
||||
s.eyeVec = i.eyeVec.xyz;
|
||||
s.posWorld = IN_WORLDPOS(i);
|
||||
s.reflUVW = i.fogCoord.yzw;
|
||||
|
||||
#ifdef _NORMALMAP
|
||||
s.tangentSpaceNormal = NormalInTangentSpace(i.tex);
|
||||
#else
|
||||
s.tangentSpaceNormal = 0;
|
||||
#endif
|
||||
|
||||
return s;
|
||||
}
|
||||
|
||||
UnityLight MainLightSimple(VertexOutputBaseSimple i, FragmentCommonData s)
|
||||
{
|
||||
UnityLight mainLight = MainLight();
|
||||
return mainLight;
|
||||
}
|
||||
|
||||
half PerVertexGrazingTerm(VertexOutputBaseSimple i, FragmentCommonData s)
|
||||
{
|
||||
#if GLOSSMAP
|
||||
return saturate(s.smoothness + (1-s.oneMinusReflectivity));
|
||||
#else
|
||||
return i.eyeVec.w;
|
||||
#endif
|
||||
}
|
||||
|
||||
half PerVertexFresnelTerm(VertexOutputBaseSimple i)
|
||||
{
|
||||
return i.normalWorld.w;
|
||||
}
|
||||
|
||||
#if !SPECULAR_HIGHLIGHTS
|
||||
# define REFLECTVEC_FOR_SPECULAR(i, s) half3(0, 0, 0)
|
||||
#elif defined(_NORMALMAP)
|
||||
# define REFLECTVEC_FOR_SPECULAR(i, s) reflect(i.tangentSpaceEyeVec, s.tangentSpaceNormal)
|
||||
#else
|
||||
# define REFLECTVEC_FOR_SPECULAR(i, s) s.reflUVW
|
||||
#endif
|
||||
|
||||
half3 LightDirForSpecular(VertexOutputBaseSimple i, UnityLight mainLight)
|
||||
{
|
||||
#if SPECULAR_HIGHLIGHTS && defined(_NORMALMAP)
|
||||
return i.tangentSpaceLightDir;
|
||||
#else
|
||||
return mainLight.dir;
|
||||
#endif
|
||||
}
|
||||
|
||||
half3 BRDF3DirectSimple(half3 diffColor, half3 specColor, half smoothness, half rl)
|
||||
{
|
||||
#if SPECULAR_HIGHLIGHTS
|
||||
return BRDF3_Direct(diffColor, specColor, Pow4(rl), smoothness);
|
||||
#else
|
||||
return diffColor;
|
||||
#endif
|
||||
}
|
||||
|
||||
half4 fragForwardBaseSimpleInternal (VertexOutputBaseSimple i)
|
||||
{
|
||||
FragmentCommonData s = FragmentSetupSimple(i);
|
||||
|
||||
UnityLight mainLight = MainLightSimple(i, s);
|
||||
|
||||
#if !defined(LIGHTMAP_ON) && defined(_NORMALMAP)
|
||||
half ndotl = saturate(dot(s.tangentSpaceNormal, i.tangentSpaceLightDir));
|
||||
#else
|
||||
half ndotl = saturate(dot(s.normalWorld, mainLight.dir));
|
||||
#endif
|
||||
|
||||
//we can't have worldpos here (not enough interpolator on SM 2.0) so no shadow fade in that case.
|
||||
half shadowMaskAttenuation = UnitySampleBakedOcclusion(i.ambientOrLightmapUV, 0);
|
||||
half realtimeShadowAttenuation = SHADOW_ATTENUATION(i);
|
||||
half atten = UnityMixRealtimeAndBakedShadows(realtimeShadowAttenuation, shadowMaskAttenuation, 0);
|
||||
|
||||
half occlusion = Occlusion(i.tex.xy);
|
||||
half rl = dot(REFLECTVEC_FOR_SPECULAR(i, s), LightDirForSpecular(i, mainLight));
|
||||
|
||||
UnityGI gi = FragmentGI (s, occlusion, i.ambientOrLightmapUV, atten, mainLight);
|
||||
half3 attenuatedLightColor = gi.light.color * ndotl;
|
||||
|
||||
half3 c = BRDF3_Indirect(s.diffColor, s.specColor, gi.indirect, PerVertexGrazingTerm(i, s), PerVertexFresnelTerm(i));
|
||||
c += BRDF3DirectSimple(s.diffColor, s.specColor, s.smoothness, rl) * attenuatedLightColor;
|
||||
c += Emission(i.tex.xy);
|
||||
|
||||
UNITY_APPLY_FOG(i.fogCoord, c);
|
||||
|
||||
return OutputForward (half4(c, 1), s.alpha);
|
||||
}
|
||||
|
||||
half4 fragForwardBaseSimple (VertexOutputBaseSimple i) : SV_Target // backward compatibility (this used to be the fragment entry function)
|
||||
{
|
||||
return fragForwardBaseSimpleInternal(i);
|
||||
}
|
||||
|
||||
struct VertexOutputForwardAddSimple
|
||||
{
|
||||
float4 pos : SV_POSITION;
|
||||
float4 tex : TEXCOORD0;
|
||||
float3 posWorld : TEXCOORD1;
|
||||
|
||||
UNITY_SHADOW_COORDS(2)
|
||||
|
||||
#if !defined(_NORMALMAP) && SPECULAR_HIGHLIGHTS
|
||||
UNITY_FOG_COORDS_PACKED(3, half4) // x: fogCoord, yzw: reflectVec
|
||||
#else
|
||||
UNITY_FOG_COORDS_PACKED(3, half1)
|
||||
#endif
|
||||
|
||||
half3 lightDir : TEXCOORD4;
|
||||
|
||||
#if defined(_NORMALMAP)
|
||||
#if SPECULAR_HIGHLIGHTS
|
||||
half3 tangentSpaceEyeVec : TEXCOORD5;
|
||||
#endif
|
||||
#else
|
||||
half3 normalWorld : TEXCOORD5;
|
||||
#endif
|
||||
|
||||
UNITY_VERTEX_OUTPUT_STEREO
|
||||
};
|
||||
|
||||
VertexOutputForwardAddSimple vertForwardAddSimple (VertexInput v)
|
||||
{
|
||||
VertexOutputForwardAddSimple o;
|
||||
UNITY_SETUP_INSTANCE_ID(v);
|
||||
UNITY_INITIALIZE_OUTPUT(VertexOutputForwardAddSimple, o);
|
||||
UNITY_INITIALIZE_VERTEX_OUTPUT_STEREO(o);
|
||||
|
||||
float4 posWorld = mul(unity_ObjectToWorld, v.vertex);
|
||||
o.pos = UnityObjectToClipPos(v.vertex);
|
||||
o.tex = TexCoords(v);
|
||||
o.posWorld = posWorld.xyz;
|
||||
|
||||
//We need this for shadow receiving
|
||||
UNITY_TRANSFER_SHADOW(o, v.uv1);
|
||||
|
||||
half3 lightDir = _WorldSpaceLightPos0.xyz - posWorld.xyz * _WorldSpaceLightPos0.w;
|
||||
#ifndef USING_DIRECTIONAL_LIGHT
|
||||
lightDir = NormalizePerVertexNormal(lightDir);
|
||||
#endif
|
||||
|
||||
#if SPECULAR_HIGHLIGHTS
|
||||
half3 eyeVec = normalize(posWorld.xyz - _WorldSpaceCameraPos);
|
||||
#endif
|
||||
|
||||
half3 normalWorld = UnityObjectToWorldNormal(v.normal);
|
||||
|
||||
#ifdef _NORMALMAP
|
||||
#if SPECULAR_HIGHLIGHTS
|
||||
TangentSpaceLightingInput(normalWorld, v.tangent, lightDir, eyeVec, o.lightDir, o.tangentSpaceEyeVec);
|
||||
#else
|
||||
half3 ignore;
|
||||
TangentSpaceLightingInput(normalWorld, v.tangent, lightDir, 0, o.lightDir, ignore);
|
||||
#endif
|
||||
#else
|
||||
o.lightDir = lightDir;
|
||||
o.normalWorld = normalWorld;
|
||||
#if SPECULAR_HIGHLIGHTS
|
||||
o.fogCoord.yzw = reflect(eyeVec, normalWorld);
|
||||
#endif
|
||||
#endif
|
||||
|
||||
UNITY_TRANSFER_FOG(o,o.pos);
|
||||
return o;
|
||||
}
|
||||
|
||||
FragmentCommonData FragmentSetupSimpleAdd(VertexOutputForwardAddSimple i)
|
||||
{
|
||||
half alpha = Alpha(i.tex.xy);
|
||||
#if defined(_ALPHATEST_ON)
|
||||
clip (alpha - _Cutoff);
|
||||
#endif
|
||||
|
||||
FragmentCommonData s = UNITY_SETUP_BRDF_INPUT (i.tex);
|
||||
|
||||
// NOTE: shader relies on pre-multiply alpha-blend (_SrcBlend = One, _DstBlend = OneMinusSrcAlpha)
|
||||
s.diffColor = PreMultiplyAlpha (s.diffColor, alpha, s.oneMinusReflectivity, /*out*/ s.alpha);
|
||||
|
||||
s.eyeVec = 0;
|
||||
s.posWorld = i.posWorld;
|
||||
|
||||
#ifdef _NORMALMAP
|
||||
s.tangentSpaceNormal = NormalInTangentSpace(i.tex);
|
||||
s.normalWorld = 0;
|
||||
#else
|
||||
s.tangentSpaceNormal = 0;
|
||||
s.normalWorld = i.normalWorld;
|
||||
#endif
|
||||
|
||||
#if SPECULAR_HIGHLIGHTS && !defined(_NORMALMAP)
|
||||
s.reflUVW = i.fogCoord.yzw;
|
||||
#else
|
||||
s.reflUVW = 0;
|
||||
#endif
|
||||
|
||||
return s;
|
||||
}
|
||||
|
||||
half3 LightSpaceNormal(VertexOutputForwardAddSimple i, FragmentCommonData s)
|
||||
{
|
||||
#ifdef _NORMALMAP
|
||||
return s.tangentSpaceNormal;
|
||||
#else
|
||||
return i.normalWorld;
|
||||
#endif
|
||||
}
|
||||
|
||||
half4 fragForwardAddSimpleInternal (VertexOutputForwardAddSimple i)
|
||||
{
|
||||
FragmentCommonData s = FragmentSetupSimpleAdd(i);
|
||||
|
||||
half3 c = BRDF3DirectSimple(s.diffColor, s.specColor, s.smoothness, dot(REFLECTVEC_FOR_SPECULAR(i, s), i.lightDir));
|
||||
|
||||
#if SPECULAR_HIGHLIGHTS // else diffColor has premultiplied light color
|
||||
c *= _LightColor0.rgb;
|
||||
#endif
|
||||
|
||||
c *= UNITY_SHADOW_ATTENUATION(i, s.posWorld) * saturate(dot(LightSpaceNormal(i, s), i.lightDir));
|
||||
|
||||
UNITY_APPLY_FOG_COLOR(i.fogCoord, c.rgb, half4(0,0,0,0)); // fog towards black in additive pass
|
||||
return OutputForward (half4(c, 1), s.alpha);
|
||||
}
|
||||
|
||||
half4 fragForwardAddSimple (VertexOutputForwardAddSimple i) : SV_Target // backward compatibility (this used to be the fragment entry function)
|
||||
{
|
||||
return fragForwardAddSimpleInternal(i);
|
||||
}
|
||||
|
||||
#endif // UNITY_STANDARD_CORE_FORWARD_SIMPLE_INCLUDED
|
||||
+16
@@ -0,0 +1,16 @@
|
||||
fileFormatVersion: 2
|
||||
guid: 69a4cf203a666c846ad901831f8d4dc2
|
||||
timeCreated: 1491659086
|
||||
licenseType: Store
|
||||
ShaderImporter:
|
||||
defaultTextures: []
|
||||
userData:
|
||||
assetBundleName:
|
||||
assetBundleVariant:
|
||||
AssetOrigin:
|
||||
serializedVersion: 1
|
||||
productId: 35611
|
||||
packageName: UMA 2
|
||||
packageVersion: 2.13
|
||||
assetPath: Assets/UMA/Content/Hair/Shader/UnityHairShader-master/Version6/CGIncludes/UnityAnisotropicCoreForwardSimple.cginc
|
||||
uploadId: 679826
|
||||
+264
@@ -0,0 +1,264 @@
|
||||
// Unity built-in shader source. Copyright (c) 2016 Unity Technologies. MIT license (see license.txt)
|
||||
|
||||
#ifndef UNITY_ANISOTROPIC_INPUT_INCLUDED
|
||||
#define UNITY_ANISOTROPIC_INPUT_INCLUDED
|
||||
|
||||
#include "UnityCG.cginc"
|
||||
#include "UnityAnisotropicCommon.cginc"
|
||||
#include "UnityStandardConfig.cginc"
|
||||
#include "UnityPBSLighting.cginc"
|
||||
#include "UnityStandardUtils.cginc"
|
||||
|
||||
//---------------------------------------
|
||||
// Directional lightmaps & Parallax require tangent space too
|
||||
//#if (_NORMALMAP || DIRLIGHTMAP_COMBINED || _PARALLAXMAP)
|
||||
#define _TANGENT_TO_WORLD 1
|
||||
#define UNITY_REQUIRE_FRAG_WORLDPOS 1
|
||||
//#define UNITY_PACK_WORLDPOS_WITH_TANGENT 0
|
||||
//#endif
|
||||
|
||||
#if (_DETAIL_MULX2 || _DETAIL_MUL || _DETAIL_ADD || _DETAIL_LERP)
|
||||
#define _DETAIL 1
|
||||
#endif
|
||||
|
||||
//-------------------------------------------------------------------------------------
|
||||
// Standard material parameters
|
||||
|
||||
half4 _Color;
|
||||
half _Cutoff;
|
||||
|
||||
sampler2D _MainTex;
|
||||
float4 _MainTex_ST;
|
||||
|
||||
sampler2D _DetailAlbedoMap;
|
||||
float4 _DetailAlbedoMap_ST;
|
||||
|
||||
sampler2D _BumpMap;
|
||||
half _BumpScale;
|
||||
|
||||
sampler2D _DetailMask;
|
||||
sampler2D _DetailNormalMap;
|
||||
half _DetailNormalMapScale;
|
||||
|
||||
sampler2D _SpecGlossMap;
|
||||
sampler2D _MetallicGlossMap;
|
||||
half _Metallic;
|
||||
half _Glossiness;
|
||||
half _GlossMapScale;
|
||||
|
||||
sampler2D _AnisotropyMap;
|
||||
half _Anisotropy;
|
||||
sampler2D _TangentMap;
|
||||
|
||||
|
||||
sampler2D _OcclusionMap;
|
||||
half _OcclusionStrength;
|
||||
|
||||
sampler2D _ParallaxMap;
|
||||
half _Parallax;
|
||||
half _UVSec;
|
||||
|
||||
half4 _EmissionColor;
|
||||
sampler2D _EmissionMap;
|
||||
|
||||
//-------------------------------------------------------------------------------------
|
||||
// Input functions
|
||||
|
||||
struct VertexInput
|
||||
{
|
||||
float4 vertex : POSITION;
|
||||
half3 normal : NORMAL;
|
||||
float2 uv0 : TEXCOORD0;
|
||||
float2 uv1 : TEXCOORD1;
|
||||
#if defined(DYNAMICLIGHTMAP_ON) || defined(UNITY_PASS_META)
|
||||
float2 uv2 : TEXCOORD2;
|
||||
#endif
|
||||
#ifdef _TANGENT_TO_WORLD
|
||||
half4 tangent : TANGENT;
|
||||
#endif
|
||||
UNITY_VERTEX_INPUT_INSTANCE_ID
|
||||
};
|
||||
|
||||
float4 TexCoords(VertexInput 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;
|
||||
}
|
||||
|
||||
half DetailMask(float2 uv)
|
||||
{
|
||||
return tex2D (_DetailMask, uv).a;
|
||||
}
|
||||
|
||||
half3 Albedo(float4 texcoords)
|
||||
{
|
||||
half3 albedo = _Color.rgb * tex2D (_MainTex, texcoords.xy).rgb;
|
||||
#if _DETAIL
|
||||
#if (SHADER_TARGET < 30)
|
||||
// SM20: instruction count limitation
|
||||
// SM20: no detail mask
|
||||
half mask = 1;
|
||||
#else
|
||||
half mask = DetailMask(texcoords.xy);
|
||||
#endif
|
||||
half3 detailAlbedo = tex2D (_DetailAlbedoMap, texcoords.zw).rgb;
|
||||
#if _DETAIL_MULX2
|
||||
albedo *= LerpWhiteTo (detailAlbedo * unity_ColorSpaceDouble.rgb, mask);
|
||||
#elif _DETAIL_MUL
|
||||
albedo *= LerpWhiteTo (detailAlbedo, mask);
|
||||
#elif _DETAIL_ADD
|
||||
albedo += detailAlbedo * mask;
|
||||
#elif _DETAIL_LERP
|
||||
albedo = lerp (albedo, detailAlbedo, mask);
|
||||
#endif
|
||||
#endif
|
||||
return albedo;
|
||||
}
|
||||
|
||||
half Alpha(float2 uv)
|
||||
{
|
||||
#if defined(_SMOOTHNESS_TEXTURE_ALBEDO_CHANNEL_A)
|
||||
return _Color.a;
|
||||
#else
|
||||
return tex2D(_MainTex, uv).a * _Color.a;
|
||||
#endif
|
||||
}
|
||||
|
||||
half Occlusion(float2 uv)
|
||||
{
|
||||
#if (SHADER_TARGET < 30)
|
||||
// SM20: instruction count limitation
|
||||
// SM20: simpler occlusion
|
||||
return tex2D(_OcclusionMap, uv).g;
|
||||
#else
|
||||
half occ = tex2D(_OcclusionMap, uv).g;
|
||||
return LerpOneTo (occ, _OcclusionStrength);
|
||||
#endif
|
||||
}
|
||||
|
||||
half4 SpecularGloss(float2 uv)
|
||||
{
|
||||
half4 sg;
|
||||
#ifdef _SPECGLOSSMAP
|
||||
#if defined(_SMOOTHNESS_TEXTURE_ALBEDO_CHANNEL_A)
|
||||
sg.rgb = tex2D(_SpecGlossMap, uv).rgb;
|
||||
sg.a = tex2D(_MainTex, uv).a;
|
||||
#else
|
||||
sg = tex2D(_SpecGlossMap, uv);
|
||||
#endif
|
||||
sg.a *= _GlossMapScale;
|
||||
#else
|
||||
sg.rgb = _SpecColor.rgb;
|
||||
#ifdef _SMOOTHNESS_TEXTURE_ALBEDO_CHANNEL_A
|
||||
sg.a = tex2D(_MainTex, uv).a * _GlossMapScale;
|
||||
#else
|
||||
sg.a = _Glossiness;
|
||||
#endif
|
||||
#endif
|
||||
return sg;
|
||||
}
|
||||
|
||||
half2 MetallicGloss(float2 uv)
|
||||
{
|
||||
half2 mg;
|
||||
|
||||
#ifdef _METALLICGLOSSMAP
|
||||
#ifdef _SMOOTHNESS_TEXTURE_ALBEDO_CHANNEL_A
|
||||
mg.r = tex2D(_MetallicGlossMap, uv).r;
|
||||
mg.g = tex2D(_MainTex, uv).a;
|
||||
#else
|
||||
mg = tex2D(_MetallicGlossMap, uv).ra;
|
||||
#endif
|
||||
mg.g *= _GlossMapScale;
|
||||
#else
|
||||
mg.r = _Metallic;
|
||||
#ifdef _SMOOTHNESS_TEXTURE_ALBEDO_CHANNEL_A
|
||||
mg.g = tex2D(_MainTex, uv).a * _GlossMapScale;
|
||||
#else
|
||||
mg.g = _Glossiness;
|
||||
#endif
|
||||
#endif
|
||||
return mg;
|
||||
}
|
||||
|
||||
half Anisotropy(float2 uv)
|
||||
{
|
||||
return tex2D(_AnisotropyMap, uv) * _Anisotropy;
|
||||
}
|
||||
|
||||
half3x3 WorldVectors(float2 uv, half4 input[3])
|
||||
{
|
||||
float3 tangent = input[0];
|
||||
float3 bitangent = input[1];
|
||||
float3 normal = input[2];
|
||||
float3x3 worldToTangent;
|
||||
worldToTangent[0] = float3(1, 0, 0);
|
||||
worldToTangent[1] = float3(0, 1, 0);
|
||||
worldToTangent[2] = float3(0, 0, 1);
|
||||
|
||||
float3 tangentTS = tex2D(_TangentMap, uv);
|
||||
float3 tangentTWS = mul(tangentTS, worldToTangent);
|
||||
float3 fTangent;
|
||||
if (tangentTS.z < 1)
|
||||
fTangent = tangentTWS;
|
||||
else
|
||||
fTangent = tangent;
|
||||
return float3x3(fTangent, bitangent, normal);
|
||||
}
|
||||
|
||||
half3 Emission(float2 uv)
|
||||
{
|
||||
#ifndef _EMISSION
|
||||
return 0;
|
||||
#else
|
||||
return tex2D(_EmissionMap, uv).rgb * _EmissionColor.rgb;
|
||||
#endif
|
||||
}
|
||||
|
||||
#ifdef _NORMALMAP
|
||||
half3 NormalInTangentSpace(float4 texcoords)
|
||||
{
|
||||
half3 normalTangent = UnpackScaleNormal(tex2D (_BumpMap, texcoords.xy), _BumpScale);
|
||||
|
||||
#if _DETAIL && defined(UNITY_ENABLE_DETAIL_NORMALMAP)
|
||||
half mask = DetailMask(texcoords.xy);
|
||||
half3 detailNormalTangent = UnpackScaleNormal(tex2D (_DetailNormalMap, texcoords.zw), _DetailNormalMapScale);
|
||||
#if _DETAIL_LERP
|
||||
normalTangent = lerp(
|
||||
normalTangent,
|
||||
detailNormalTangent,
|
||||
mask);
|
||||
#else
|
||||
normalTangent = lerp(
|
||||
normalTangent,
|
||||
BlendNormals(normalTangent, detailNormalTangent),
|
||||
mask);
|
||||
#endif
|
||||
#endif
|
||||
|
||||
return normalTangent;
|
||||
}
|
||||
#endif
|
||||
|
||||
float4 Parallax (float4 texcoords, half3 viewDir)
|
||||
{
|
||||
// D3D9/SM30 supports up to 16 samplers, skip the parallax map in case we exceed the limit
|
||||
#define EXCEEDS_D3D9_SM3_MAX_SAMPLER_COUNT (defined(LIGHTMAP_ON) && defined(SHADOWS_SHADOWMASK) && defined(SHADOWS_SCREEN) && defined(_NORMALMAP) && \
|
||||
defined(_EMISSION) && defined(_DETAIL) && (defined(_METALLICGLOSSMAP) || defined(_SPECGLOSSMAP)))
|
||||
|
||||
#if !defined(_PARALLAXMAP) || (SHADER_TARGET < 30) || (defined(SHADER_API_D3D9) && EXCEEDS_D3D9_SM3_MAX_SAMPLER_COUNT)
|
||||
// SM20: instruction count limitation
|
||||
// SM20: no parallax
|
||||
return texcoords;
|
||||
#else
|
||||
half h = tex2D (_ParallaxMap, texcoords.xy).g;
|
||||
float2 offset = ParallaxOffset1Step (h, _Parallax, viewDir);
|
||||
return float4(texcoords.xy + offset, texcoords.zw + offset);
|
||||
#endif
|
||||
|
||||
#undef EXCEEDS_D3D9_SM3_MAX_SAMPLER_COUNT
|
||||
}
|
||||
|
||||
#endif // UNITY_ANISOTROPIC_INPUT_INCLUDED
|
||||
+16
@@ -0,0 +1,16 @@
|
||||
fileFormatVersion: 2
|
||||
guid: 4595336270a165b4da957d93d2adb7a7
|
||||
timeCreated: 1491659087
|
||||
licenseType: Store
|
||||
ShaderImporter:
|
||||
defaultTextures: []
|
||||
userData:
|
||||
assetBundleName:
|
||||
assetBundleVariant:
|
||||
AssetOrigin:
|
||||
serializedVersion: 1
|
||||
productId: 35611
|
||||
packageName: UMA 2
|
||||
packageVersion: 2.13
|
||||
assetPath: Assets/UMA/Content/Hair/Shader/UnityHairShader-master/Version6/CGIncludes/UnityAnisotropicInput.cginc
|
||||
uploadId: 679826
|
||||
+165
@@ -0,0 +1,165 @@
|
||||
//#ifndef UNITY_ANISOTROPIC_LIGHTING_INCLUDED
|
||||
//#define UNITY_ANISOTROPIC_LIGHTING_INCLUDED
|
||||
|
||||
#include "UnityPBSLighting.cginc"
|
||||
#include "UnityShaderVariables.cginc"
|
||||
#include "UnityStandardConfig.cginc"
|
||||
#include "UnityLightingCommon.cginc"
|
||||
#include "UnityGBuffer.cginc"
|
||||
#include "UnityGlobalIllumination.cginc"
|
||||
|
||||
//-------------------------------------------------------------------------------------
|
||||
// Lighting Helpers
|
||||
|
||||
// Glossy Environment
|
||||
half3 Unity_AnisotropicGlossyEnvironment(UNITY_ARGS_TEXCUBE(tex), half4 hdr, Unity_GlossyEnvironmentData glossIn, half anisotropy) //Reference IBL from HD Pipe (Add half3 L input and replace R)
|
||||
{
|
||||
half perceptualRoughness = glossIn.roughness /* perceptualRoughness */;
|
||||
#if 0
|
||||
float m = PerceptualRoughnessToRoughness(perceptualRoughness); // m is the real roughness parameter
|
||||
const float fEps = 1.192092896e-07F; // smallest such that 1.0+FLT_EPSILON != 1.0 (+1e-4h is NOT good here. is visibly very wrong)
|
||||
float n = (2.0 / max(fEps, m*m)) - 2.0; // remap to spec power. See eq. 21 in --> https://dl.dropboxusercontent.com/u/55891920/papers/mm_brdf.pdf
|
||||
|
||||
n /= 4; // remap from n_dot_h formulatino to n_dot_r. See section "Pre-convolved Cube Maps vs Path Tracers" --> https://s3.amazonaws.com/docs.knaldtech.com/knald/1.0.0/lys_power_drops.html
|
||||
|
||||
perceptualRoughness = pow(2 / (n + 2), 0.25); // remap back to square root of real roughness (0.25 include both the sqrt root of the conversion and sqrt for going from roughness to perceptualRoughness)
|
||||
#else
|
||||
// MM: came up with a surprisingly close approximation to what the #if 0'ed out code above does.
|
||||
perceptualRoughness = perceptualRoughness*(1.7 - 0.7*perceptualRoughness);
|
||||
#endif
|
||||
|
||||
|
||||
half mip = perceptualRoughnessToMipmapLevel(perceptualRoughness);
|
||||
half3 R = glossIn.reflUVW;// -half3(anisotropy, 0, 0);
|
||||
half4 rgbm = UNITY_SAMPLE_TEXCUBE_LOD(tex, R, mip);
|
||||
|
||||
return DecodeHDR(rgbm, hdr);
|
||||
}
|
||||
|
||||
// Indirect Specular
|
||||
inline half3 UnityGI_AnisotropicIndirectSpecular(UnityGIInput data, half occlusion, Unity_GlossyEnvironmentData glossIn, half anisotropy, half3x3 worldVectors)
|
||||
{
|
||||
half3 specular;
|
||||
|
||||
float3 tangentX = worldVectors[0];
|
||||
float3 tangentY = worldVectors[1];
|
||||
float3 N = worldVectors[2];
|
||||
float3 V = data.worldViewDir;
|
||||
float3 iblNormalWS = GetAnisotropicModifiedNormal(tangentY, N, V, anisotropy);
|
||||
float3 iblR = reflect(-V, iblNormalWS);
|
||||
|
||||
#ifdef UNITY_SPECCUBE_BOX_PROJECTION
|
||||
// we will tweak reflUVW in glossIn directly (as we pass it to Unity_GlossyEnvironment twice for probe0 and probe1), so keep original to pass into BoxProjectedCubemapDirection
|
||||
|
||||
half3 originalReflUVW = glossIn.reflUVW;
|
||||
glossIn.reflUVW = BoxProjectedCubemapDirection(iblR, data.worldPos, data.probePosition[0], data.boxMin[0], data.boxMax[0]);
|
||||
#endif
|
||||
|
||||
#ifdef _GLOSSYREFLECTIONS_OFF
|
||||
specular = unity_IndirectSpecColor.rgb;
|
||||
#else
|
||||
half3 env0 = Unity_AnisotropicGlossyEnvironment(UNITY_PASS_TEXCUBE(unity_SpecCube0), data.probeHDR[0], glossIn, anisotropy);
|
||||
#ifdef UNITY_SPECCUBE_BLENDING
|
||||
const float kBlendFactor = 0.99999;
|
||||
float blendLerp = data.boxMin[0].w;
|
||||
UNITY_BRANCH
|
||||
if (blendLerp < kBlendFactor)
|
||||
{
|
||||
#ifdef UNITY_SPECCUBE_BOX_PROJECTION
|
||||
glossIn.reflUVW = BoxProjectedCubemapDirection(iblR, data.worldPos, data.probePosition[1], data.boxMin[1], data.boxMax[1]);
|
||||
#endif
|
||||
half3 env1 = Unity_AnisotropicGlossyEnvironment(UNITY_PASS_TEXCUBE_SAMPLER(unity_SpecCube1, unity_SpecCube0), data.probeHDR[1], glossIn, anisotropy);
|
||||
specular = lerp(env1, env0, blendLerp);
|
||||
}
|
||||
else
|
||||
{
|
||||
specular = env0;
|
||||
}
|
||||
#else
|
||||
specular = env0;
|
||||
#endif
|
||||
#endif
|
||||
|
||||
return specular * occlusion;
|
||||
}
|
||||
|
||||
// Global Illumination
|
||||
inline UnityGI UnityAnisotropicGlobalIllumination(UnityGIInput data, half occlusion, half3 normalWorld, Unity_GlossyEnvironmentData glossIn, half anisotropy, half3x3 worldVectors)
|
||||
{
|
||||
UnityGI o_gi = UnityGI_Base(data, occlusion, normalWorld);
|
||||
o_gi.indirect.specular = UnityGI_AnisotropicIndirectSpecular(data, occlusion, glossIn, anisotropy, worldVectors);
|
||||
return o_gi;
|
||||
}
|
||||
|
||||
// Surface shader output structure to be used with physically
|
||||
// based shading model.
|
||||
|
||||
//-------------------------------------------------------------------------------------
|
||||
// Anisotropic workflow
|
||||
|
||||
struct SurfaceOutputStandardAnisotropic
|
||||
{
|
||||
fixed3 Albedo; // base (diffuse or specular) color
|
||||
fixed3 Normal; // tangent space normal, if written
|
||||
half3 Emission;
|
||||
half Metallic; // 0=non-metal, 1=metal
|
||||
// Smoothness is the user facing name, it should be perceptual smoothness but user should not have to deal with it.
|
||||
// Everywhere in the code you meet smoothness it is perceptual smoothness
|
||||
half Smoothness; // 0=rough, 1=smooth
|
||||
half Occlusion; // occlusion (default 1)
|
||||
fixed Alpha; // alpha for transparencies
|
||||
half Anisotropy;
|
||||
float3x3 WorldVectors;
|
||||
};
|
||||
|
||||
inline half4 LightingStandardAnisotropic(SurfaceOutputStandardAnisotropic s, half3 viewDir, UnityGI gi)
|
||||
{
|
||||
s.Normal = normalize(s.Normal);
|
||||
|
||||
half oneMinusReflectivity;
|
||||
half3 specColor;
|
||||
s.Albedo = DiffuseAndSpecularFromMetallic(s.Albedo, s.Metallic, /*out*/ specColor, /*out*/ oneMinusReflectivity);
|
||||
|
||||
// shader relies on pre-multiply alpha-blend (_SrcBlend = One, _DstBlend = OneMinusSrcAlpha)
|
||||
// this is necessary to handle transparency in physically correct way - only diffuse component gets affected by alpha
|
||||
half outputAlpha;
|
||||
s.Albedo = PreMultiplyAlpha(s.Albedo, s.Alpha, oneMinusReflectivity, /*out*/ outputAlpha);
|
||||
|
||||
half4 c = AnisotropicBRDF(s.Albedo, specColor, oneMinusReflectivity, s.Smoothness, s.Normal, s.WorldVectors, s.Anisotropy, s.Metallic, viewDir, gi.light, gi.indirect);
|
||||
c.a = outputAlpha;
|
||||
return c;
|
||||
}
|
||||
|
||||
//This is pointless as always forward?
|
||||
inline half4 LightingStandardAnisotropic_Deferred(SurfaceOutputStandardAnisotropic s, half3 viewDir, UnityGI gi, out half4 outGBuffer0, out half4 outGBuffer1, out half4 outGBuffer2)
|
||||
{
|
||||
half oneMinusReflectivity;
|
||||
half3 specColor;
|
||||
s.Albedo = DiffuseAndSpecularFromMetallic(s.Albedo, s.Metallic, /*out*/ specColor, /*out*/ oneMinusReflectivity);
|
||||
|
||||
half4 c = AnisotropicBRDF(s.Albedo, specColor, oneMinusReflectivity, s.Smoothness, s.Normal, s.WorldVectors, s.Anisotropy, s.Metallic, viewDir, gi.light, gi.indirect);
|
||||
|
||||
UnityStandardData data;
|
||||
data.diffuseColor = s.Albedo;
|
||||
data.occlusion = s.Occlusion;
|
||||
data.specularColor = specColor;
|
||||
data.smoothness = s.Smoothness;
|
||||
data.normalWorld = s.Normal;
|
||||
|
||||
UnityStandardDataToGbuffer(data, outGBuffer0, outGBuffer1, outGBuffer2);
|
||||
|
||||
half4 emission = half4(s.Emission + c.rgb, 1);
|
||||
return emission;
|
||||
}
|
||||
|
||||
inline void LightingStandardAnisotropic_GI(SurfaceOutputStandardAnisotropic s, UnityGIInput data, inout UnityGI gi)
|
||||
{
|
||||
#if defined(UNITY_PASS_DEFERRED) && UNITY_ENABLE_REFLECTION_BUFFERS
|
||||
gi = UnityGlobalIllumination(data, s.Occlusion, s.Normal);
|
||||
#else
|
||||
Unity_GlossyEnvironmentData g = UnityGlossyEnvironmentSetup(s.Smoothness, data.worldViewDir, s.Normal, lerp(unity_ColorSpaceDielectricSpec.rgb, s.Albedo, s.Metallic));
|
||||
gi = UnityAnisotropicGlobalIllumination(data, s.Occlusion, s.Normal, g, s.Anisotropy, s.WorldVectors);
|
||||
#endif
|
||||
}
|
||||
|
||||
//#endif UNITY_ANISOTROPIC_LIGHTING_INCLUDED
|
||||
+16
@@ -0,0 +1,16 @@
|
||||
fileFormatVersion: 2
|
||||
guid: dce578206c4306a4286cf1474f7802c3
|
||||
timeCreated: 1491560472
|
||||
licenseType: Store
|
||||
ShaderImporter:
|
||||
defaultTextures: []
|
||||
userData:
|
||||
assetBundleName:
|
||||
assetBundleVariant:
|
||||
AssetOrigin:
|
||||
serializedVersion: 1
|
||||
productId: 35611
|
||||
packageName: UMA 2
|
||||
packageVersion: 2.13
|
||||
assetPath: Assets/UMA/Content/Hair/Shader/UnityHairShader-master/Version6/CGIncludes/UnityAnisotropicLighting.cginc
|
||||
uploadId: 679826
|
||||
+63
@@ -0,0 +1,63 @@
|
||||
// Unity built-in shader source. Copyright (c) 2016 Unity Technologies. MIT license (see license.txt)
|
||||
|
||||
#ifndef UNITY_ANISOTROPIC_META_INCLUDED
|
||||
#define UNITY_ANISOTROPIC_META_INCLUDED
|
||||
|
||||
// Functionality for Standard shader "meta" pass
|
||||
// (extracts albedo/emission for lightmapper etc.)
|
||||
|
||||
// define meta pass before including other files; they have conditions
|
||||
// on that in some places
|
||||
#define UNITY_PASS_META 1
|
||||
|
||||
#include "UnityCG.cginc"
|
||||
#include "UnityAnisotropicInput.cginc"
|
||||
#include "UnityMetaPass.cginc"
|
||||
#include "UnityAnisotropicCore.cginc"
|
||||
|
||||
struct v2f_meta
|
||||
{
|
||||
float4 uv : TEXCOORD0;
|
||||
float4 pos : SV_POSITION;
|
||||
};
|
||||
|
||||
v2f_meta vert_meta (VertexInput v)
|
||||
{
|
||||
v2f_meta o;
|
||||
o.pos = UnityMetaVertexPosition(v.vertex, v.uv1.xy, v.uv2.xy, unity_LightmapST, unity_DynamicLightmapST);
|
||||
o.uv = TexCoords(v);
|
||||
return o;
|
||||
}
|
||||
|
||||
// Albedo for lightmapping should basically be diffuse color.
|
||||
// But rough metals (black diffuse) still scatter quite a lot of light around, so
|
||||
// we want to take some of that into account too.
|
||||
half3 UnityLightmappingAlbedo (half3 diffuse, half3 specular, half smoothness)
|
||||
{
|
||||
half roughness = SmoothnessToRoughness(smoothness);
|
||||
half3 res = diffuse;
|
||||
res += specular * roughness * 0.5;
|
||||
return res;
|
||||
}
|
||||
|
||||
float4 frag_meta (v2f_meta i) : SV_Target
|
||||
{
|
||||
// we're interested in diffuse & specular colors,
|
||||
// and surface roughness to produce final albedo.
|
||||
FragmentCommonData data = UNITY_SETUP_BRDF_INPUT (i.uv);
|
||||
|
||||
UnityMetaInput o;
|
||||
UNITY_INITIALIZE_OUTPUT(UnityMetaInput, o);
|
||||
|
||||
#if defined(EDITOR_VISUALIZATION)
|
||||
o.Albedo = data.diffColor;
|
||||
#else
|
||||
o.Albedo = UnityLightmappingAlbedo (data.diffColor, data.specColor, data.smoothness);
|
||||
#endif
|
||||
o.SpecularColor = data.specColor;
|
||||
o.Emission = Emission(i.uv.xy);
|
||||
|
||||
return UnityMetaFragment(o);
|
||||
}
|
||||
|
||||
#endif // UNITY_ADVANCED_META_INCLUDED
|
||||
+16
@@ -0,0 +1,16 @@
|
||||
fileFormatVersion: 2
|
||||
guid: 2141ceac909e56b4f95ee0ba16769f82
|
||||
timeCreated: 1491659086
|
||||
licenseType: Store
|
||||
ShaderImporter:
|
||||
defaultTextures: []
|
||||
userData:
|
||||
assetBundleName:
|
||||
assetBundleVariant:
|
||||
AssetOrigin:
|
||||
serializedVersion: 1
|
||||
productId: 35611
|
||||
packageName: UMA 2
|
||||
packageVersion: 2.13
|
||||
assetPath: Assets/UMA/Content/Hair/Shader/UnityHairShader-master/Version6/CGIncludes/UnityAnisotropicMeta.cginc
|
||||
uploadId: 679826
|
||||
+194
@@ -0,0 +1,194 @@
|
||||
// Unity built-in shader source. Copyright (c) 2016 Unity Technologies. MIT license (see license.txt)
|
||||
|
||||
#ifndef UNITY_ANISOTROPIC_SHADOW_INCLUDED
|
||||
#define UNITY_ANISOTROPIC_SHADOW_INCLUDED
|
||||
|
||||
// NOTE: had to split shadow functions into separate file,
|
||||
// otherwise compiler gives trouble with LIGHTING_COORDS macro (in UnityStandardCore.cginc)
|
||||
|
||||
|
||||
#include "UnityCG.cginc"
|
||||
#include "UnityStandardConfig.cginc"
|
||||
#include "UnityStandardUtils.cginc"
|
||||
|
||||
#if (defined(_ALPHABLEND_ON) || defined(_ALPHAPREMULTIPLY_ON)) && defined(UNITY_USE_DITHER_MASK_FOR_ALPHABLENDED_SHADOWS)
|
||||
#define UNITY_STANDARD_USE_DITHER_MASK 1
|
||||
#endif
|
||||
|
||||
// Need to output UVs in shadow caster, since we need to sample texture and do clip/dithering based on it
|
||||
#if defined(_ALPHATEST_ON) || defined(_ALPHABLEND_ON) || defined(_ALPHAPREMULTIPLY_ON)
|
||||
#define UNITY_STANDARD_USE_SHADOW_UVS 1
|
||||
#endif
|
||||
|
||||
// Has a non-empty shadow caster output struct (it's an error to have empty structs on some platforms...)
|
||||
#if !defined(V2F_SHADOW_CASTER_NOPOS_IS_EMPTY) || defined(UNITY_STANDARD_USE_SHADOW_UVS)
|
||||
#define UNITY_STANDARD_USE_SHADOW_OUTPUT_STRUCT 1
|
||||
#endif
|
||||
|
||||
#ifdef UNITY_STEREO_INSTANCING_ENABLED
|
||||
#define UNITY_STANDARD_USE_STEREO_SHADOW_OUTPUT_STRUCT 1
|
||||
#endif
|
||||
|
||||
|
||||
half4 _Color;
|
||||
half _Cutoff;
|
||||
sampler2D _MainTex;
|
||||
float4 _MainTex_ST;
|
||||
#ifdef UNITY_STANDARD_USE_DITHER_MASK
|
||||
sampler3D _DitherMaskLOD;
|
||||
#endif
|
||||
|
||||
// Handle PremultipliedAlpha from Fade or Transparent shading mode
|
||||
half4 _SpecColor;
|
||||
half _Metallic;
|
||||
#ifdef _SPECGLOSSMAP
|
||||
sampler2D _SpecGlossMap;
|
||||
#endif
|
||||
#ifdef _METALLICGLOSSMAP
|
||||
sampler2D _MetallicGlossMap;
|
||||
#endif
|
||||
|
||||
#if defined(UNITY_STANDARD_USE_SHADOW_UVS) && defined(_PARALLAXMAP)
|
||||
sampler2D _ParallaxMap;
|
||||
half _Parallax;
|
||||
#endif
|
||||
|
||||
half AnisotropicMetallicSetup_ShadowGetOneMinusReflectivity(half2 uv)
|
||||
{
|
||||
half metallicity = _Metallic;
|
||||
#ifdef _METALLICGLOSSMAP
|
||||
metallicity = tex2D(_MetallicGlossMap, uv).r;
|
||||
#endif
|
||||
return OneMinusReflectivityFromMetallic(metallicity);
|
||||
}
|
||||
|
||||
half MetallicSetup_ShadowGetOneMinusReflectivity(half2 uv)
|
||||
{
|
||||
half metallicity = _Metallic;
|
||||
#ifdef _METALLICGLOSSMAP
|
||||
metallicity = tex2D(_MetallicGlossMap, uv).r;
|
||||
#endif
|
||||
return OneMinusReflectivityFromMetallic(metallicity);
|
||||
}
|
||||
|
||||
half SpecularSetup_ShadowGetOneMinusReflectivity(half2 uv)
|
||||
{
|
||||
half3 specColor = _SpecColor.rgb;
|
||||
#ifdef _SPECGLOSSMAP
|
||||
specColor = tex2D(_SpecGlossMap, uv).rgb;
|
||||
#endif
|
||||
return (1 - SpecularStrength(specColor));
|
||||
}
|
||||
|
||||
// SHADOW_ONEMINUSREFLECTIVITY(): workaround to get one minus reflectivity based on UNITY_SETUP_BRDF_INPUT
|
||||
#define SHADOW_JOIN2(a, b) a##b
|
||||
#define SHADOW_JOIN(a, b) SHADOW_JOIN2(a,b)
|
||||
#define SHADOW_ONEMINUSREFLECTIVITY SHADOW_JOIN(UNITY_SETUP_BRDF_INPUT, _ShadowGetOneMinusReflectivity)
|
||||
|
||||
struct VertexInput
|
||||
{
|
||||
float4 vertex : POSITION;
|
||||
float3 normal : NORMAL;
|
||||
float2 uv0 : TEXCOORD0;
|
||||
#if defined(UNITY_STANDARD_USE_SHADOW_UVS) && defined(_PARALLAXMAP)
|
||||
half4 tangent : TANGENT;
|
||||
#endif
|
||||
UNITY_VERTEX_INPUT_INSTANCE_ID
|
||||
};
|
||||
|
||||
#ifdef UNITY_STANDARD_USE_SHADOW_OUTPUT_STRUCT
|
||||
struct VertexOutputShadowCaster
|
||||
{
|
||||
V2F_SHADOW_CASTER_NOPOS
|
||||
#if defined(UNITY_STANDARD_USE_SHADOW_UVS)
|
||||
float2 tex : TEXCOORD1;
|
||||
|
||||
#if defined(_PARALLAXMAP)
|
||||
half4 tangentToWorldAndParallax[3]: TEXCOORD2; // [3x3:tangentToWorld | 1x3:viewDirForParallax]
|
||||
#endif
|
||||
#endif
|
||||
};
|
||||
#endif
|
||||
|
||||
#ifdef UNITY_STANDARD_USE_STEREO_SHADOW_OUTPUT_STRUCT
|
||||
struct VertexOutputStereoShadowCaster
|
||||
{
|
||||
UNITY_VERTEX_OUTPUT_STEREO
|
||||
};
|
||||
#endif
|
||||
|
||||
// We have to do these dances of outputting SV_POSITION separately from the vertex shader,
|
||||
// and inputting VPOS in the pixel shader, since they both map to "POSITION" semantic on
|
||||
// some platforms, and then things don't go well.
|
||||
|
||||
|
||||
void vertShadowCaster (VertexInput v,
|
||||
#ifdef UNITY_STANDARD_USE_SHADOW_OUTPUT_STRUCT
|
||||
out VertexOutputShadowCaster o,
|
||||
#endif
|
||||
#ifdef UNITY_STANDARD_USE_STEREO_SHADOW_OUTPUT_STRUCT
|
||||
out VertexOutputStereoShadowCaster os,
|
||||
#endif
|
||||
out float4 opos : SV_POSITION)
|
||||
{
|
||||
UNITY_SETUP_INSTANCE_ID(v);
|
||||
#ifdef UNITY_STANDARD_USE_STEREO_SHADOW_OUTPUT_STRUCT
|
||||
UNITY_INITIALIZE_VERTEX_OUTPUT_STEREO(os);
|
||||
#endif
|
||||
TRANSFER_SHADOW_CASTER_NOPOS(o,opos)
|
||||
#if defined(UNITY_STANDARD_USE_SHADOW_UVS)
|
||||
o.tex = TRANSFORM_TEX(v.uv0, _MainTex);
|
||||
|
||||
#ifdef _PARALLAXMAP
|
||||
TANGENT_SPACE_ROTATION;
|
||||
half3 viewDirForParallax = mul (rotation, ObjSpaceViewDir(v.vertex));
|
||||
o.tangentToWorldAndParallax[0].w = viewDirForParallax.x;
|
||||
o.tangentToWorldAndParallax[1].w = viewDirForParallax.y;
|
||||
o.tangentToWorldAndParallax[2].w = viewDirForParallax.z;
|
||||
#endif
|
||||
#endif
|
||||
}
|
||||
|
||||
half4 fragShadowCaster (
|
||||
#ifdef UNITY_STANDARD_USE_SHADOW_OUTPUT_STRUCT
|
||||
VertexOutputShadowCaster i
|
||||
#endif
|
||||
#ifdef UNITY_STANDARD_USE_DITHER_MASK
|
||||
, UNITY_VPOS_TYPE vpos : VPOS
|
||||
#endif
|
||||
) : SV_Target
|
||||
{
|
||||
#if defined(UNITY_STANDARD_USE_SHADOW_UVS)
|
||||
#if defined(_PARALLAXMAP) && (SHADER_TARGET >= 30)
|
||||
//On d3d9 parallax can also be disabled on the fwd pass when too many sampler are used. See EXCEEDS_D3D9_SM3_MAX_SAMPLER_COUNT. Ideally we should account for that here as well.
|
||||
half3 viewDirForParallax = normalize( half3(i.tangentToWorldAndParallax[0].w,i.tangentToWorldAndParallax[1].w,i.tangentToWorldAndParallax[2].w) );
|
||||
fixed h = tex2D (_ParallaxMap, i.tex.xy).g;
|
||||
half2 offset = ParallaxOffset1Step (h, _Parallax, viewDirForParallax);
|
||||
i.tex.xy += offset;
|
||||
#endif
|
||||
|
||||
half alpha = tex2D(_MainTex, i.tex).a * _Color.a;
|
||||
#if defined(_ALPHATEST_ON)
|
||||
clip (alpha - _Cutoff);
|
||||
#endif
|
||||
#if defined(_ALPHABLEND_ON) || defined(_ALPHAPREMULTIPLY_ON)
|
||||
#if defined(_ALPHAPREMULTIPLY_ON)
|
||||
half outModifiedAlpha;
|
||||
PreMultiplyAlpha(half3(0, 0, 0), alpha, SHADOW_ONEMINUSREFLECTIVITY(i.tex), outModifiedAlpha);
|
||||
alpha = outModifiedAlpha;
|
||||
#endif
|
||||
#if defined(UNITY_STANDARD_USE_DITHER_MASK)
|
||||
// Use dither mask for alpha blended shadows, based on pixel position xy
|
||||
// and alpha level. Our dither texture is 4x4x16.
|
||||
half alphaRef = tex3D(_DitherMaskLOD, float3(vpos.xy*0.25,alpha*0.9375)).a;
|
||||
clip (alphaRef - 0.01);
|
||||
#else
|
||||
clip (alpha - _Cutoff);
|
||||
#endif
|
||||
#endif
|
||||
#endif // #if defined(UNITY_STANDARD_USE_SHADOW_UVS)
|
||||
|
||||
SHADOW_CASTER_FRAGMENT(i)
|
||||
}
|
||||
|
||||
#endif // UNITY_ANISOTROPIC_SHADOW_INCLUDED
|
||||
+16
@@ -0,0 +1,16 @@
|
||||
fileFormatVersion: 2
|
||||
guid: 60605e25f711155479e7c2a6e8aadf99
|
||||
timeCreated: 1492766711
|
||||
licenseType: Store
|
||||
ShaderImporter:
|
||||
defaultTextures: []
|
||||
userData:
|
||||
assetBundleName:
|
||||
assetBundleVariant:
|
||||
AssetOrigin:
|
||||
serializedVersion: 1
|
||||
productId: 35611
|
||||
packageName: UMA 2
|
||||
packageVersion: 2.13
|
||||
assetPath: Assets/UMA/Content/Hair/Shader/UnityHairShader-master/Version6/CGIncludes/UnityAnisotropicShadow.cginc
|
||||
uploadId: 679826
|
||||
+151
@@ -0,0 +1,151 @@
|
||||
float _Distortion;
|
||||
float _Scale;
|
||||
float _Power;
|
||||
float _Fresnel;
|
||||
float _FresnelDamp;
|
||||
|
||||
float4 TranslucentBRDF(float3 diffColor, float3 specColor, float oneMinusReflectivity, float smoothness, float3 normal, float3x3 worldVectors,
|
||||
float anisotropy, float metallic, float3 viewDir, UnityLight light, UnityIndirect gi)
|
||||
{
|
||||
//Unpack world vectors
|
||||
float3 tangent = worldVectors[0];
|
||||
float3 bitangent = worldVectors[1];
|
||||
//Normal shift
|
||||
float shiftAmount = dot(normal, viewDir);
|
||||
normal = shiftAmount < 0.0f ? normal + viewDir * (-shiftAmount + 1e-5f) : normal;
|
||||
//Regular vectors
|
||||
float NdotL = saturate(dot(normal, light.dir));
|
||||
float NdotV = abs(dot(normal, viewDir));
|
||||
float LdotV = dot(light.dir, viewDir);
|
||||
float3 H = Unity_SafeNormalize(light.dir + viewDir);
|
||||
float invLenLV = rsqrt(abs(2 + 2 * normalize(LdotV)));
|
||||
float NdotH = saturate(dot(normal, H));
|
||||
float LdotH = saturate(dot(light.dir, H));
|
||||
//Tangent vectors
|
||||
float TdotH = dot(tangent, H);
|
||||
float TdotL = dot(tangent, light.dir);
|
||||
float BdotH = dot(bitangent, H);
|
||||
float BdotL = dot(bitangent, light.dir);
|
||||
float TdotV = dot(viewDir, tangent);
|
||||
float BdotV = dot(viewDir, bitangent);
|
||||
//Fresnels
|
||||
half grazingTerm = saturate(smoothness + (1 - oneMinusReflectivity));
|
||||
float3 F = FresnelLerp(specColor, grazingTerm, NdotV); //Original Schlick - Replace from SRP?
|
||||
//float3 fresnel0 = lerp(specColor, diffColor, metallic);
|
||||
//float3 F = FresnelSchlick(fresnel0, 1.0, LdotH);
|
||||
//Calculate roughness
|
||||
float roughnessT;
|
||||
float roughnessB;
|
||||
float perceptualRoughness = SmoothnessToPerceptualRoughness(smoothness);
|
||||
float roughness = PerceptualRoughnessToRoughness(perceptualRoughness);
|
||||
ConvertAnisotropyToRoughness(roughness, anisotropy, roughnessT, roughnessB);
|
||||
//Clamp roughness
|
||||
roughnessT = ClampRoughnessForAnalyticalLights(roughnessT);
|
||||
roughnessB = ClampRoughnessForAnalyticalLights(roughnessB);
|
||||
//Visibility & Distribution terms
|
||||
float V = SmithJointGGXAnisotropic(TdotV, BdotV, NdotV, TdotL, BdotL, NdotL, roughnessT, roughnessB);
|
||||
float D = D_GGXAnisotropic(TdotH, BdotH, NdotH, roughnessT, roughnessB);
|
||||
//Specular term
|
||||
float3 specularTerm = V * D;
|
||||
# ifdef UNITY_COLORSPACE_GAMMA
|
||||
specularTerm = sqrt(max(1e-4h, specularTerm));
|
||||
# endif
|
||||
// specularTerm * nl can be NaN on Metal in some cases, use max() to make sure it's a sane value
|
||||
specularTerm = max(0, specularTerm * NdotL);
|
||||
#if defined(_SPECULARHIGHLIGHTS_OFF)
|
||||
specularTerm = 0.0;
|
||||
#endif
|
||||
//Diffuse term
|
||||
float diffuseTerm = DisneyDiffuse(NdotV, NdotL, LdotH, perceptualRoughness) * NdotL;// - Need this NdotL multiply?
|
||||
//Reduction
|
||||
half surfaceReduction;
|
||||
# ifdef UNITY_COLORSPACE_GAMMA
|
||||
surfaceReduction = 1.0 - 0.28*roughness*perceptualRoughness; // 1-0.28*x^3 as approximation for (1/(x^4+1))^(1/2.2) on the domain [0;1]
|
||||
# else
|
||||
surfaceReduction = 1.0 / (roughness*roughness + 1.0); // fade \in [0.5;1]
|
||||
# endif
|
||||
//Final
|
||||
half3 color = (diffColor * (gi.diffuse + light.color * diffuseTerm))
|
||||
+ specularTerm * light.color * (FresnelTerm(specColor, LdotH))
|
||||
+ (surfaceReduction * gi.specular * FresnelLerp(specColor, grazingTerm, NdotV) * _Fresnel * lerp(float3(1,1,1),specColor,_FresnelDamp));
|
||||
return half4(color, 1);
|
||||
}
|
||||
|
||||
inline half4 LightFunctionStandardAnisotropic(SurfaceOutputStandardAnisotropic s, half3 viewDir, UnityGI gi)
|
||||
{
|
||||
s.Normal = normalize(s.Normal);
|
||||
|
||||
half oneMinusReflectivity;
|
||||
half3 specColor;
|
||||
s.Albedo = DiffuseAndSpecularFromMetallic(s.Albedo, s.Metallic, /*out*/ specColor, /*out*/ oneMinusReflectivity);
|
||||
|
||||
// shader relies on pre-multiply alpha-blend (_SrcBlend = One, _DstBlend = OneMinusSrcAlpha)
|
||||
// this is necessary to handle transparency in physically correct way - only diffuse component gets affected by alpha
|
||||
half outputAlpha;
|
||||
s.Albedo = PreMultiplyAlpha(s.Albedo, s.Alpha, oneMinusReflectivity, /*out*/ outputAlpha);
|
||||
|
||||
half4 c = TranslucentBRDF(s.Albedo, specColor, oneMinusReflectivity, s.Smoothness, s.Normal, s.WorldVectors, s.Anisotropy, s.Metallic, viewDir, gi.light, gi.indirect);
|
||||
c.a = outputAlpha;
|
||||
return c;
|
||||
}
|
||||
|
||||
|
||||
inline fixed4 LightingStandardTranslucent(SurfaceOutputStandardAnisotropic s, fixed3 viewDir, UnityGI gi)
|
||||
{
|
||||
// Original colour
|
||||
fixed4 pbr = LightFunctionStandardAnisotropic(s, viewDir, gi);
|
||||
|
||||
// --- Translucency ---
|
||||
float3 L = gi.light.dir;
|
||||
float3 V = viewDir;
|
||||
float3 N = s.Normal;
|
||||
|
||||
float3 H = normalize(L + N * _Distortion);
|
||||
float I = (pow(saturate(dot(V, -H)), _Power) * _Scale);
|
||||
|
||||
// Final add
|
||||
pbr.rgb = pbr.rgb + gi.light.color * (I*s.Albedo);
|
||||
|
||||
return pbr;
|
||||
}
|
||||
|
||||
//This is pointless as always forward?
|
||||
inline half4 LightingStandardTranslucent_Deferred(SurfaceOutputStandardAnisotropic s, half3 viewDir, UnityGI gi, out half4 outGBuffer0, out half4 outGBuffer1, out half4 outGBuffer2)
|
||||
{
|
||||
half oneMinusReflectivity;
|
||||
half3 specColor;
|
||||
s.Albedo = DiffuseAndSpecularFromMetallic(s.Albedo, s.Metallic, /*out*/ specColor, /*out*/ oneMinusReflectivity);
|
||||
|
||||
half4 c = TranslucentBRDF(s.Albedo, specColor, oneMinusReflectivity, s.Smoothness, s.Normal, s.WorldVectors, s.Anisotropy, s.Metallic, viewDir, gi.light, gi.indirect);
|
||||
|
||||
UnityStandardData data;
|
||||
data.diffuseColor = s.Albedo;
|
||||
data.occlusion = s.Occlusion;
|
||||
data.specularColor = specColor;
|
||||
data.smoothness = s.Smoothness;
|
||||
data.normalWorld = s.Normal;
|
||||
|
||||
UnityStandardDataToGbuffer(data, outGBuffer0, outGBuffer1, outGBuffer2);
|
||||
|
||||
// --- Translucency ---
|
||||
float3 L = gi.light.dir;
|
||||
float3 V = viewDir;
|
||||
float3 N = s.Normal;
|
||||
|
||||
float3 H = normalize(L + N * _Distortion);
|
||||
float I = (pow(saturate(dot(V, -H)), _Power) * _Scale);
|
||||
|
||||
|
||||
half4 emission = half4(s.Emission + c.rgb, 1);
|
||||
return emission * (float4(1,1,1,1) + float4(I * c.rgb,0));
|
||||
}
|
||||
|
||||
inline void LightingStandardTranslucent_GI(SurfaceOutputStandardAnisotropic s, UnityGIInput data, inout UnityGI gi)
|
||||
{
|
||||
#if defined(UNITY_PASS_DEFERRED) && UNITY_ENABLE_REFLECTION_BUFFERS
|
||||
gi = UnityGlobalIllumination(data, s.Occlusion, s.Normal);
|
||||
#else
|
||||
Unity_GlossyEnvironmentData g = UnityGlossyEnvironmentSetup(s.Smoothness, data.worldViewDir, s.Normal, lerp(unity_ColorSpaceDielectricSpec.rgb, s.Albedo, s.Metallic));
|
||||
gi = UnityAnisotropicGlobalIllumination(data, s.Occlusion, s.Normal, g, s.Anisotropy, s.WorldVectors);
|
||||
#endif
|
||||
}
|
||||
+16
@@ -0,0 +1,16 @@
|
||||
fileFormatVersion: 2
|
||||
guid: 425d0f8540bbd10439244394bada8c7f
|
||||
timeCreated: 1507206596
|
||||
licenseType: Store
|
||||
ShaderImporter:
|
||||
defaultTextures: []
|
||||
userData:
|
||||
assetBundleName:
|
||||
assetBundleVariant:
|
||||
AssetOrigin:
|
||||
serializedVersion: 1
|
||||
productId: 35611
|
||||
packageName: UMA 2
|
||||
packageVersion: 2.13
|
||||
assetPath: Assets/UMA/Content/Hair/Shader/UnityHairShader-master/Version6/CGIncludes/UnityTranslucentLighting.cginc
|
||||
uploadId: 679826
|
||||
Reference in New Issue
Block a user