修复技能输入并更新战斗资源
This commit is contained in:
ud18010
@@ -0,0 +1,408 @@
|
||||
#ifndef CHARACTER_CORE_INCLUDED
|
||||
#define CHARACTER_CORE_INCLUDED
|
||||
#include "CharacterPBR_Inputs.hlsl"
|
||||
|
||||
////INPUTS////////////////////////////////////////////////////////////
|
||||
///////////////////////////////////
|
||||
#if defined(_EMISSION_ON) || defined(_ANISO_GGX_ON) || defined(ANISO_KAJIYA_KAY)
|
||||
TEXTURE2D(_MaskMap2); SAMPLER(sampler_MaskMap2);
|
||||
#endif
|
||||
|
||||
CBUFFER_START(UnityPerMaterial)
|
||||
half4 _MainTex_ST; half4 _NormalMap_ST;
|
||||
half _CutoffThres;
|
||||
half _HighLightLerp; half4 _HighLightLerpColor; half _OriColorAdd; half4 _Color;
|
||||
half _NormalMapScale;half _ColorLerpMask; half4 _LerpMaskColor; half4 _AmbientColor;
|
||||
half4 _MaskMap_ST; half4 _MaskMap2_ST;
|
||||
half4 _EmissionColor; half _EmissionStrength;
|
||||
half _SmoothnessScale; half _MetallicScale; half _Occlusion; half _DiffuseWrap;
|
||||
half _CameraLightIntensityMin; half _CameraLightIntensityMax;
|
||||
half _SkinNormalBias; half _SkinBlurStrength; half _SkinCurvature; half _SkinAmbientIntensity;
|
||||
half4 _SSSLut_ST; half _ReflectionCubeLod; half _ReflectionYOffset;
|
||||
|
||||
#if defined(TRANSLUCENCY_ON)
|
||||
half3 _SkinTranslucencyColor;
|
||||
#endif
|
||||
#if defined(_ANISO_GGX_ON)
|
||||
half _AnisoSmoothnessScale;
|
||||
half _AnisoMetallicScale;
|
||||
half _AnisoSpecAlbedoScale;
|
||||
half _AmbientReflectionStrength;
|
||||
#endif
|
||||
CBUFFER_END
|
||||
/////////////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
TEXTURE2D(_MainTex); SAMPLER(sampler_MainTex);
|
||||
TEXTURE2D(_MaskMap); SAMPLER(sampler_MaskMap);
|
||||
TEXTURE2D(_SSSLut); SAMPLER(sampler_SSSLut);
|
||||
TEXTURE2D(_NormalMap); SAMPLER(sampler_NormalMap);
|
||||
TEXTURECUBE(_ReflectionCube); SAMPLER(sampler_ReflectionCube);
|
||||
|
||||
struct SurfaceOutputStandardCustom
|
||||
{
|
||||
half3 Albedo; half3 Normal; half3 Emission;
|
||||
half Metallic; half Smoothness; half Occlusion; half Alpha;
|
||||
half IsSkin; half3 SkinNormal; half SkinCurvature;
|
||||
half3 TranslucencyColor; half Anisotropy; half3 WorldTangent; half3 WorldBitangent;
|
||||
half3 HighlightColor; half3 AnisoSpecColor;
|
||||
half MainShift; half MainExponent; half SubShift; half SubExponent;
|
||||
};
|
||||
struct VertexInput
|
||||
{
|
||||
half4 vertex : POSITION;
|
||||
half4 normal : NORMAL;
|
||||
half4 tangent: TANGENT;
|
||||
half2 texcoord : TEXCOORD0;
|
||||
half2 lightmapUV : TEXCOORD1;
|
||||
|
||||
UNITY_VERTEX_INPUT_INSTANCE_ID
|
||||
};
|
||||
struct VertexOutput
|
||||
{
|
||||
half4 pos : SV_POSITION;
|
||||
half2 texcoord : TEXCOORD0;
|
||||
half4 tSpace0 : TEXCOORD1;
|
||||
half4 tSpace1 : TEXCOORD2;
|
||||
half4 tSpace2 : TEXCOORD3;
|
||||
|
||||
half3 normal : TEXCOORD4;
|
||||
|
||||
float4 shadowCoord : TEXCOORD5;
|
||||
|
||||
UNITY_VERTEX_INPUT_INSTANCE_ID
|
||||
UNITY_VERTEX_OUTPUT_STEREO
|
||||
};
|
||||
#define WorldNormalVector(i, normal) normalize(half3(dot(i.tSpace0.xyz,normal), dot(i.tSpace1.xyz,normal), dot(i.tSpace2.xyz,normal)))
|
||||
////BRDF/////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
half3 Unity_GlossyEnvironment (half4 hdr, Unity_GlossyEnvironmentData glossIn)
|
||||
{
|
||||
half perceptualRoughness = glossIn.roughness /* perceptualRoughness */ ;
|
||||
#if 0
|
||||
float m = PerceptualRoughnessToRoughness(perceptualRoughness);
|
||||
const float fEps = 1.192092896e-07F;
|
||||
float n = (2.0/max(fEps, m*m))-2.0;
|
||||
n /= 4;
|
||||
perceptualRoughness = pow( 2/(n+2), 0.25);
|
||||
#else
|
||||
perceptualRoughness = perceptualRoughness*(1.7 - 0.7*perceptualRoughness);
|
||||
#endif
|
||||
half3 R = glossIn.reflUVW;
|
||||
half4 rgbm = SAMPLE_TEXTURECUBE_LOD(_ReflectionCube, sampler_ReflectionCube, R, 3);
|
||||
return DecodeHDR(rgbm, hdr);
|
||||
}
|
||||
inline half GGXSpecularTerm(half roughness, half nh, half lh)
|
||||
{
|
||||
half a = roughness;
|
||||
float a2 = a * a;
|
||||
float d = nh * nh * (a2 - 1.f) + 1.00001f;
|
||||
float specularTerm = a2 / (max(0.1f, lh * lh) * (roughness + 0.5f) * (d * d) * 4);
|
||||
#if defined (SHADER_API_MOBILE)
|
||||
specularTerm = clamp(specularTerm - 1e-4f, 0.0, 100.0); // Prevent FP16 overflow on mobiles
|
||||
#endif
|
||||
return specularTerm;
|
||||
}
|
||||
#if defined(_SKIN_ON)
|
||||
inline half3 SkinDiffuseTerm(half3 normal, half3 lightDir, half skinCurvature)
|
||||
{
|
||||
half NoL = dot(normal, lightDir);
|
||||
NoL = NoL * 0.5 + 0.5;
|
||||
half3 diffuseTerm = SAMPLE_TEXTURE2D(_SSSLut, sampler_SSSLut, half2(NoL, skinCurvature));
|
||||
return diffuseTerm;
|
||||
}
|
||||
#endif
|
||||
#if defined(_ANISO_GGX_ON)
|
||||
inline half D_GGXAniso_SGame(half TdotH, half BdotH, half mt, half mb, half nh)
|
||||
{
|
||||
half d = TdotH * TdotH / (mt * mt) + BdotH * BdotH / (mb * mb) + nh * nh;
|
||||
return (1.0 / (3.14 * mt * mb * d * d));
|
||||
}
|
||||
inline half V_SmithJointGGXAniso_SGame(half TdotV, half BdotV, half NdotV, half TdotL, half BdotL, half NdotL, half roughnessT, half roughnessB)
|
||||
{
|
||||
half lambdaV = NdotL * sqrt(roughnessT * TdotV * TdotV + roughnessB * BdotV * BdotV + NdotV * NdotV);
|
||||
half lambdaL = NdotV * sqrt(roughnessT * TdotL * TdotL + roughnessB * BdotL * BdotL + NdotL * NdotL);
|
||||
return 0.5 / max(1e-5f, (lambdaV + lambdaL));
|
||||
}
|
||||
inline half GGXSpecularTermAniso_SGame(half3 worldTangent, half3 worldBiTangent, half roughnessT, half roughnessB, half3 halfDir, half3 lightDir, half3 viewDir
|
||||
, half nl, half nh, half nv)
|
||||
{
|
||||
half mt = roughnessT;
|
||||
half mb = roughnessB;
|
||||
half TdotH = dot(worldTangent, halfDir);
|
||||
half BdotH = dot(worldBiTangent, halfDir);
|
||||
half TdotV = dot(worldTangent, viewDir);
|
||||
half BdotV = dot(worldBiTangent, viewDir);
|
||||
half TdotL = dot(worldTangent, lightDir);
|
||||
half BdotL = dot(worldBiTangent, lightDir);
|
||||
half D = D_GGXAniso_SGame(TdotH, BdotH, mt, mb, nh);
|
||||
half V = V_SmithJointGGXAniso_SGame(TdotV, BdotV, nv, TdotL, BdotL, nl, mt, mb);
|
||||
half specularTerm = (V * D) * 3.14;
|
||||
return clamp(specularTerm, 0, 5);
|
||||
}
|
||||
#endif
|
||||
half3 DirectDiffuse(SurfaceOutputStandardCustom s, half nl, half3 lightDir, half3 viewDir)
|
||||
{
|
||||
half3 diffColor = s.Albedo;
|
||||
half3 diffuseTerm = half3(nl, nl, nl);
|
||||
#if defined(_SKIN_ON)
|
||||
half3 skinDiffuseTerm = SkinDiffuseTerm(s.SkinNormal, lightDir, s.SkinCurvature);
|
||||
diffuseTerm = lerp(diffuseTerm, skinDiffuseTerm, s.IsSkin);
|
||||
#endif
|
||||
return diffColor * diffuseTerm;
|
||||
}
|
||||
half3 DirectSpecular(SurfaceOutputStandardCustom s, half nl, half3 lightDir, half smoothness, half roughness, half3 specColor, half3 viewDir)
|
||||
{
|
||||
half3 normal = s.Normal;
|
||||
#if defined(_ANISO_GGX_ON)
|
||||
half3 worldTangent = s.WorldTangent;
|
||||
half3 worldBitangent = s.WorldBitangent;
|
||||
#endif
|
||||
half3 halfDir = normalize(lightDir + viewDir);
|
||||
half nh = saturate(dot(normal, halfDir));
|
||||
half nv = abs(dot(normal, viewDir));
|
||||
half lh = saturate(dot(lightDir, halfDir));
|
||||
half specularTerm = GGXSpecularTerm(roughness, nh, lh);
|
||||
|
||||
#if defined(_ANISO_GGX_ON)
|
||||
half roughnessT = roughness;
|
||||
half roughnessB = 1.0;
|
||||
half anisoSpecularTerm = GGXSpecularTermAniso_SGame(worldTangent, worldBitangent, roughnessT, roughnessB, halfDir, lightDir, viewDir, nl, nh, nv);
|
||||
specularTerm = lerp(specularTerm, anisoSpecularTerm, s.Anisotropy);
|
||||
#endif
|
||||
specularTerm = max(0, specularTerm * nl);
|
||||
return specularTerm * specColor;
|
||||
}
|
||||
half3 DirectSpecular(SurfaceOutputStandardCustom s, half nl, half3 lightDir, half3 specColor, half3 viewDir) {
|
||||
half smoothness = s.Smoothness;
|
||||
half perceptualRoughness = PerceptualSmoothnessToPerceptualRoughness(smoothness);
|
||||
half roughness = PerceptualRoughnessToRoughness(perceptualRoughness);
|
||||
return DirectSpecular(s, nl, lightDir, smoothness, roughness, specColor, viewDir);
|
||||
}
|
||||
inline half4 Character_BRDF2_PBS(SurfaceOutputStandardCustom s, half3 specColor, half oneMinusReflectivity, half3 viewDir, UnityLight light) {
|
||||
half3 normal = s.Normal;
|
||||
half nl = saturate((dot(normal, light.dir) + _DiffuseWrap) / ((1 + _DiffuseWrap) * (1 + _DiffuseWrap)));
|
||||
half3 directDiffuse = DirectDiffuse(s, nl, light.dir, viewDir);
|
||||
half3 directSpecular = DirectSpecular(s, nl, light.dir, specColor, viewDir);
|
||||
half3 color = directDiffuse * light.color + directSpecular * light.color;
|
||||
return half4(color, 1);
|
||||
}
|
||||
half3 IndirectSpecular(half roughness, half3 specColor)
|
||||
{
|
||||
half surfaceReduction;
|
||||
surfaceReduction = 1.0 / (roughness * roughness + 1.0);
|
||||
return surfaceReduction * specColor;
|
||||
}
|
||||
inline half4 Character_BRDF2_PBS(SurfaceOutputStandardCustom s, half3 specColor, half oneMinusReflectivity,
|
||||
half3 viewDir, UnityLight light, UnityIndirect gi) {
|
||||
half3 diffColor = s.Albedo;
|
||||
half3 normal = s.Normal;
|
||||
half smoothness = s.Smoothness;
|
||||
half perceptualRoughness = PerceptualSmoothnessToPerceptualRoughness(smoothness);
|
||||
half roughness = PerceptualRoughnessToRoughness(perceptualRoughness);
|
||||
half nl = saturate((dot(normal, light.dir) + _DiffuseWrap) / ((1 + _DiffuseWrap) * (1 + _DiffuseWrap)));
|
||||
half3 directDiffuse = DirectDiffuse(s, nl, light.dir, viewDir);
|
||||
half3 directSpecular = DirectSpecular(s, nl, light.dir, smoothness, roughness, specColor, viewDir);
|
||||
half3 directColor = directDiffuse * light.color + directSpecular * light.color;
|
||||
half3 indirectSpecular = IndirectSpecular(roughness, specColor) * gi.specular;
|
||||
half3 indirectColor = diffColor * gi.diffuse + indirectSpecular;
|
||||
half3 finalColor = directColor + indirectColor;
|
||||
return half4(finalColor, 1);
|
||||
}
|
||||
/////////////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
/////LIGHTING////////////////////////////////////////////////////////////////////////////////////////////
|
||||
inline half4 LightingCharacter(SurfaceOutputStandardCustom s, half3 viewDir, UnityGI gi)
|
||||
{
|
||||
half3 mainLightDir = gi.light.dir;
|
||||
half3 normalizeLightDir = normalize(half3(mainLightDir.x, 0.0, mainLightDir.z));
|
||||
half3 normalizeViewDir = normalize(half3(viewDir.x, 0.0, viewDir.z));
|
||||
half3 dirFactor = dot(normalizeLightDir, normalizeViewDir) * 0.5 + 0.5;
|
||||
half cameraLightAtten = lerp(_CameraLightIntensityMax, _CameraLightIntensityMin, dirFactor);
|
||||
#if defined(TRANSLUCENCY_ON)
|
||||
half translucencyAtten = lerp(_CameraLightIntensityMin, _CameraLightIntensityMax, dirFactor);
|
||||
s.Albedo += s.TranslucencyColor * (saturate(dot(s.Normal, -mainLightDir)) + saturate(dot(s.Normal, viewDir)) * translucencyAtten);
|
||||
#endif
|
||||
half oneMinusReflectivity;
|
||||
half3 specColor;
|
||||
half outputAlpha;
|
||||
half3 albedo = DiffuseAndSpecularFromMetallic(s.Albedo, s.Metallic, /*out*/ specColor, /*out*/ oneMinusReflectivity);
|
||||
#if defined(_ANISO_GGX_ON)
|
||||
specColor = lerp(specColor, lerp(half4(0.04, 0.04, 0.04, 0.06), s.Albedo, _AnisoSpecAlbedoScale), s.Anisotropy);
|
||||
#endif
|
||||
half nv = dot(s.Normal, viewDir);
|
||||
// s.Albedo = PreMultiplyAlpha(albedo, s.Alpha, oneMinusReflectivity, /*out*/ outputAlpha);
|
||||
half4 c = Character_BRDF2_PBS(s, specColor, oneMinusReflectivity, viewDir, gi.light, gi.indirect);
|
||||
UnityGI gi2 = gi;
|
||||
// HSV Color Alter
|
||||
half3 hsvLightCol = RgbToHsv_SGame(GetMainLight().color.rgb);
|
||||
hsvLightCol.b = 1;
|
||||
hsvLightCol = HsvToRgb_SGame(hsvLightCol);
|
||||
gi2.light.color = hsvLightCol * cameraLightAtten;
|
||||
gi2.light.dir = viewDir;
|
||||
c.rgb += Character_BRDF2_PBS(s, specColor, oneMinusReflectivity, viewDir, gi2.light);
|
||||
c.a = outputAlpha;
|
||||
return c;
|
||||
}
|
||||
inline half3 CharacterGI_IndirectSpecular(UnityGIInput data, half occlusion, Unity_GlossyEnvironmentData glossIn)
|
||||
{
|
||||
half4 hdr = data.probeHDR[0];
|
||||
hdr.x = 1;
|
||||
glossIn.reflUVW = RotationY(glossIn.reflUVW, _ReflectionYOffset);
|
||||
half3 env0 = Unity_GlossyEnvironment(hdr, glossIn);
|
||||
return env0 * occlusion;
|
||||
}
|
||||
inline UnityGI CharacterGI_Base(UnityGIInput data, half occlusion, half3 normalWorld)
|
||||
{
|
||||
UnityGI o_gi;
|
||||
ResetUnityGI(o_gi);
|
||||
o_gi.light = data.light;
|
||||
half3 hsvLightCol = RgbToHsv_SGame(GetMainLight().color.rgb);
|
||||
hsvLightCol.b = 1;
|
||||
hsvLightCol = HsvToRgb_SGame(hsvLightCol);
|
||||
o_gi.light.color = hsvLightCol * data.atten;
|
||||
o_gi.indirect.diffuse = data.ambient;
|
||||
o_gi.indirect.diffuse *= occlusion;
|
||||
return o_gi;
|
||||
}
|
||||
inline UnityGI CharacterGlobalIllumination(UnityGIInput data, half occlusion, half3 normalWorld, Unity_GlossyEnvironmentData glossIn)
|
||||
{
|
||||
UnityGI o_gi = CharacterGI_Base(data, occlusion, normalWorld);
|
||||
o_gi.indirect.specular = CharacterGI_IndirectSpecular(data, occlusion, glossIn);
|
||||
return o_gi;
|
||||
}
|
||||
inline void LightingCharacter_GI(SurfaceOutputStandardCustom s, UnityGIInput data, inout UnityGI gi)
|
||||
{
|
||||
// Unity_GlossyEnvironmentData g = UnityGlossyEnvironmentSetup(_ReflectionCubeLod, data.worldViewDir, s.Normal, half3(0, 0, 0));
|
||||
Unity_GlossyEnvironmentData g = UnityGlossyEnvironmentSetup(s.Smoothness, data.worldViewDir, s.Normal, half3(0, 0, 0));
|
||||
gi = CharacterGlobalIllumination(data, s.Occlusion, s.Normal, g);
|
||||
#if defined(_SKIN_ON)
|
||||
gi.indirect.diffuse *= lerp(1, _SkinAmbientIntensity, s.IsSkin);
|
||||
#endif
|
||||
#if defined(_ANISO_GGX_ON)
|
||||
gi.indirect.specular *= lerp(1, _AmbientReflectionStrength, s.Anisotropy);
|
||||
#endif
|
||||
}
|
||||
/////////////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
VertexOutput VertBaseCore(VertexInput v)
|
||||
{
|
||||
VertexOutput o;
|
||||
VertexPositionInputs vertexInput = GetVertexPositionInputs(v.vertex.xyz);
|
||||
VertexNormalInputs normalInput = GetVertexNormalInputs(v.normal, v.tangent);
|
||||
|
||||
o.pos = vertexInput.positionCS;
|
||||
half3 worldPos = vertexInput.positionWS;
|
||||
float3 worldNormal = normalInput.normalWS;
|
||||
half3 worldViewDir = GetCameraPositionWS() - worldPos;
|
||||
o.tSpace0 = half4(normalInput.tangentWS.x, normalInput.bitangentWS.x, normalInput.normalWS.x, worldPos.x);
|
||||
o.tSpace1 = half4(normalInput.tangentWS.y, normalInput.bitangentWS.y, normalInput.normalWS.y, worldPos.y);
|
||||
o.tSpace2 = half4(normalInput.tangentWS.z, normalInput.bitangentWS.z, normalInput.normalWS.z, worldPos.z);
|
||||
o.texcoord = v.texcoord.xy;
|
||||
o.normal = worldNormal;
|
||||
o.shadowCoord = GetShadowCoord(vertexInput);
|
||||
|
||||
return o;
|
||||
}
|
||||
|
||||
half4 FragBaseCore(VertexOutput i, half3 worldPos, half3 worldViewDir, half3 worldTangent = half3(0, 0, 0))
|
||||
{
|
||||
half2 uv_MainTex = TRANSFORM_TEX(i.texcoord, _MainTex);
|
||||
half2 uv_NrmTex = TRANSFORM_TEX(i.texcoord, _NormalMap);
|
||||
half2 uv_mskTex = TRANSFORM_TEX(i.texcoord, _MaskMap);
|
||||
|
||||
half4 albedoColor = SAMPLE_TEXTURE2D(_MainTex, sampler_MainTex, uv_MainTex);
|
||||
half4 normalColor = SAMPLE_TEXTURE2D(_NormalMap, sampler_NormalMap, uv_NrmTex);
|
||||
half4 mask = SAMPLE_TEXTURE2D(_MaskMap, sampler_MaskMap, uv_mskTex);
|
||||
|
||||
#if defined(_CUTOFF_ON)
|
||||
clip(albedoColor.a - _CutoffThres / 255);
|
||||
#endif
|
||||
|
||||
SurfaceOutputStandardCustom o = (SurfaceOutputStandardCustom)0;
|
||||
o.Occlusion = 1.0;
|
||||
|
||||
half3 colorAddLerp = lerp(_Color.rgb * _OriColorAdd, _LerpMaskColor.rgb * 0.8, _ColorLerpMask * albedoColor.a);
|
||||
#if defined(_ANISO_GGX_ON)
|
||||
half4 mask2 = SAMPLE_TEXTURE2D(_MaskMap2, sampler_MaskMap2, TRANSFORM_TEX(i.texcoord, _MaskMap2));
|
||||
o.Albedo = albedoColor.rgb * colorAddLerp * step(0.5, mask2.g) + albedoColor.rgb * step(mask2.g, 0.5);
|
||||
#else
|
||||
o.Albedo = albedoColor.rgb * colorAddLerp;
|
||||
#endif
|
||||
o.Alpha = albedoColor.a * _Color.a;
|
||||
|
||||
half4 c = 0;
|
||||
#if defined(_USENORMALMAP_OFF)
|
||||
o.Normal = i.normal;
|
||||
#else
|
||||
o.Normal = lerp(half3(0, 0, 1), normalColor.rgb * 2 - 1, _NormalMapScale);
|
||||
#endif
|
||||
|
||||
o.Normal = WorldNormalVector(i, o.Normal);
|
||||
o.Metallic = mask.r * (_MetallicScale + 1);
|
||||
o.Emission = normalColor.a * _EmissionColor.rgb * _EmissionStrength;
|
||||
o.Occlusion = lerp(mask.b, 1, _Occlusion);
|
||||
o.Smoothness = (1 - mask.a) * (_SmoothnessScale + 1);
|
||||
|
||||
#if defined(_ANISO_GGX_ON)
|
||||
o.Anisotropy = mask2.g;
|
||||
half anisoMetallic = _AnisoMetallicScale;
|
||||
half anisoSmoothness = _AnisoSmoothnessScale;
|
||||
o.Metallic = lerp(o.Metallic, anisoMetallic, o.Anisotropy);
|
||||
o.Smoothness = lerp(o.Smoothness, anisoSmoothness, o.Anisotropy);
|
||||
o.WorldTangent = worldTangent;
|
||||
o.WorldBitangent = cross(o.Normal, o.WorldTangent);
|
||||
o.WorldTangent = cross(o.WorldBitangent, o.Normal);
|
||||
#endif
|
||||
|
||||
o.IsSkin = 0;
|
||||
#if defined(_SKIN_ON)
|
||||
o.IsSkin = mask.g;
|
||||
half3 skinNormal = UnpackNormal(SAMPLE_TEXTURE2D(_NormalMap, sampler_NormalMap, uv_NrmTex));
|
||||
o.SkinNormal = normalize(lerp(o.Normal, skinNormal, _SkinBlurStrength));
|
||||
o.SkinCurvature = _SkinCurvature;
|
||||
o.SkinNormal = WorldNormalVector(i, o.SkinNormal);
|
||||
#endif
|
||||
|
||||
half atten = 1;
|
||||
|
||||
UnityGI gi = (UnityGI)0;
|
||||
gi.indirect.diffuse = 0;
|
||||
gi.indirect.specular = 0;
|
||||
gi.light.color = GetMainLight().color.rgb;
|
||||
gi.light.dir = GetMainLight().direction;
|
||||
UnityGIInput giInput = (UnityGIInput)0;
|
||||
giInput.light = gi.light;
|
||||
giInput.worldPos = worldPos;
|
||||
giInput.worldViewDir = worldViewDir;
|
||||
giInput.atten = atten;
|
||||
giInput.ambient.rgb = _AmbientColor;
|
||||
giInput.probeHDR[0] = unity_SpecCube0_HDR;
|
||||
|
||||
LightingCharacter_GI(o, giInput, gi);
|
||||
c += LightingCharacter(o, worldViewDir, gi);
|
||||
c.rgb += o.Emission;
|
||||
c.rgb = clamp(c.rgb, 0, 3);
|
||||
c.rgb = lerp(c.rgb, c.rgb + pow(1 - saturate(dot(o.Normal, worldViewDir)), 2.5) * _HighLightLerpColor * 4, _HighLightLerp);
|
||||
c.a = albedoColor.a;
|
||||
return c;
|
||||
}
|
||||
|
||||
half4 FragBaseCore(VertexOutput i)
|
||||
{
|
||||
half3 worldPos = half3(i.tSpace0.w, i.tSpace1.w, i.tSpace2.w);
|
||||
half3 worldViewDir = normalize(GetCameraPositionWS() - worldPos);
|
||||
#if defined(_ANISO_GGX_ON)
|
||||
half3 worldTangent = normalize(half3(i.tSpace0.x, i.tSpace1.x, i.tSpace2.x));
|
||||
#else
|
||||
half3 worldTangent = half3(0, 0, 0);
|
||||
#endif
|
||||
return FragBaseCore(i, worldPos, worldViewDir, worldTangent);
|
||||
}
|
||||
|
||||
VertexOutput VertBase(VertexInput v)
|
||||
{
|
||||
return VertBaseCore(v);
|
||||
}
|
||||
half4 FragBase(VertexOutput i) : SV_Target
|
||||
{
|
||||
half4 finalColor = FragBaseCore(i);
|
||||
return finalColor;
|
||||
}
|
||||
#endif
|
||||
Reference in New Issue
Block a user