您最多选择25个主题
主题必须以中文或者字母或数字开头，可以包含连字符 (-)，并且长度不得超过35个字符
589 行
25 KiB
589 行
25 KiB
//UTS2/UniversalToon
|
|
//v.2.2.0
|
|
//nobuyuki@unity3d.com
|
|
//toshiyuki@unity3d.com (Univerasl RP/HDRP)
|
|
//https://github.com/unity3d-jp/UnityChanToonShaderVer2_Project
|
|
//(C)Unity Technologies Japan/UCL
|
|
//
|
|
|
|
#if (SHADER_LIBRARY_VERSION_MAJOR ==7 && SHADER_LIBRARY_VERSION_MINOR >= 3) || (SHADER_LIBRARY_VERSION_MAJOR >= 8)
|
|
|
|
|
|
# ifdef _ADDITIONAL_LIGHTS
|
|
# ifndef REQUIRES_WORLD_SPACE_POS_INTERPOLATOR
|
|
# define REQUIRES_WORLD_SPACE_POS_INTERPOLATOR
|
|
# endif
|
|
# endif
|
|
#else
|
|
# ifdef _MAIN_LIGHT_SHADOWS
|
|
//# if !defined(_MAIN_LIGHT_SHADOWS_CASCADE)
|
|
# ifndef REQUIRES_VERTEX_SHADOW_COORD_INTERPOLATOR
|
|
# define REQUIRES_VERTEX_SHADOW_COORD_INTERPOLATOR
|
|
# endif
|
|
//# endif
|
|
# endif
|
|
# ifdef _ADDITIONAL_LIGHTS
|
|
# ifndef REQUIRES_WORLD_SPACE_POS_INTERPOLATOR
|
|
# define REQUIRES_WORLD_SPACE_POS_INTERPOLATOR
|
|
# endif
|
|
# endif
|
|
#endif
|
|
|
|
uniform float _utsTechnique;
|
|
uniform sampler2D _MainTex; uniform float4 _MainTex_ST;
|
|
#if UCTS_LWRP
|
|
#else
|
|
uniform float4 _BaseColor;
|
|
#endif
|
|
//v.2.0.5
|
|
uniform float4 _Color;
|
|
uniform fixed _Use_BaseAs1st;
|
|
uniform fixed _Use_1stAs2nd;
|
|
//
|
|
uniform fixed _Is_LightColor_Base;
|
|
uniform sampler2D _1st_ShadeMap; uniform float4 _1st_ShadeMap_ST;
|
|
uniform float4 _1st_ShadeColor;
|
|
uniform fixed _Is_LightColor_1st_Shade;
|
|
uniform sampler2D _2nd_ShadeMap; uniform float4 _2nd_ShadeMap_ST;
|
|
uniform float4 _2nd_ShadeColor;
|
|
uniform fixed _Is_LightColor_2nd_Shade;
|
|
uniform sampler2D _NormalMap; uniform float4 _NormalMap_ST;
|
|
uniform fixed _Is_NormalMapToBase;
|
|
uniform fixed _Set_SystemShadowsToBase;
|
|
uniform float _Tweak_SystemShadowsLevel;
|
|
uniform float _BaseColor_Step;
|
|
uniform float _BaseShade_Feather;
|
|
uniform sampler2D _Set_1st_ShadePosition; uniform float4 _Set_1st_ShadePosition_ST;
|
|
uniform float _ShadeColor_Step;
|
|
uniform float _1st2nd_Shades_Feather;
|
|
uniform sampler2D _Set_2nd_ShadePosition; uniform float4 _Set_2nd_ShadePosition_ST;
|
|
|
|
// ShadingGradeMap
|
|
#if defined(_SHADINGGRADEMAP)
|
|
uniform sampler2D _ShadingGradeMap; uniform float4 _ShadingGradeMap_ST;
|
|
#endif
|
|
//v.2.0.6
|
|
uniform float _Tweak_ShadingGradeMapLevel;
|
|
uniform fixed _BlurLevelSGM;
|
|
//
|
|
uniform float _1st_ShadeColor_Step;
|
|
uniform float _1st_ShadeColor_Feather;
|
|
uniform float _2nd_ShadeColor_Step;
|
|
uniform float _2nd_ShadeColor_Feather;
|
|
// ShadingGradeMap
|
|
|
|
uniform float4 _HighColor;
|
|
uniform sampler2D _HighColor_Tex; uniform float4 _HighColor_Tex_ST;
|
|
uniform fixed _Is_LightColor_HighColor;
|
|
uniform fixed _Is_NormalMapToHighColor;
|
|
uniform float _HighColor_Power;
|
|
uniform fixed _Is_SpecularToHighColor;
|
|
uniform fixed _Is_BlendAddToHiColor;
|
|
uniform fixed _Is_UseTweakHighColorOnShadow;
|
|
uniform float _TweakHighColorOnShadow;
|
|
uniform sampler2D _Set_HighColorMask; uniform float4 _Set_HighColorMask_ST;
|
|
uniform float _Tweak_HighColorMaskLevel;
|
|
uniform fixed _RimLight;
|
|
uniform float4 _RimLightColor;
|
|
uniform fixed _Is_LightColor_RimLight;
|
|
uniform fixed _Is_NormalMapToRimLight;
|
|
uniform float _RimLight_Power;
|
|
uniform float _RimLight_InsideMask;
|
|
uniform fixed _RimLight_FeatherOff;
|
|
uniform fixed _LightDirection_MaskOn;
|
|
uniform float _Tweak_LightDirection_MaskLevel;
|
|
uniform fixed _Add_Antipodean_RimLight;
|
|
uniform float4 _Ap_RimLightColor;
|
|
uniform fixed _Is_LightColor_Ap_RimLight;
|
|
uniform float _Ap_RimLight_Power;
|
|
uniform fixed _Ap_RimLight_FeatherOff;
|
|
uniform sampler2D _Set_RimLightMask; uniform float4 _Set_RimLightMask_ST;
|
|
uniform float _Tweak_RimLightMaskLevel;
|
|
uniform fixed _MatCap;
|
|
|
|
uniform sampler2D _MatCap_Sampler; uniform float4 _MatCap_Sampler_ST;
|
|
|
|
uniform float4 _MatCapColor;
|
|
uniform fixed _Is_LightColor_MatCap;
|
|
uniform fixed _Is_BlendAddToMatCap;
|
|
uniform float _Tweak_MatCapUV;
|
|
uniform float _Rotate_MatCapUV;
|
|
uniform fixed _Is_NormalMapForMatCap;
|
|
uniform sampler2D _NormalMapForMatCap; uniform float4 _NormalMapForMatCap_ST;
|
|
uniform float _Rotate_NormalMapForMatCapUV;
|
|
uniform fixed _Is_UseTweakMatCapOnShadow;
|
|
uniform float _TweakMatCapOnShadow;
|
|
//MatcapMask
|
|
uniform sampler2D _Set_MatcapMask; uniform float4 _Set_MatcapMask_ST;
|
|
uniform float _Tweak_MatcapMaskLevel;
|
|
//v.2.0.5
|
|
uniform fixed _Is_Ortho;
|
|
//v.2.0.6
|
|
uniform float _CameraRolling_Stabilizer;
|
|
uniform fixed _BlurLevelMatcap;
|
|
uniform fixed _Inverse_MatcapMask;
|
|
#if UCTS_LWRP
|
|
#else
|
|
uniform float _BumpScale;
|
|
#endif
|
|
uniform float _BumpScaleMatcap;
|
|
//Emissive
|
|
uniform sampler2D _Emissive_Tex; uniform float4 _Emissive_Tex_ST;
|
|
uniform float4 _Emissive_Color;
|
|
//v.2.0.7
|
|
uniform fixed _Is_ViewCoord_Scroll;
|
|
uniform float _Rotate_EmissiveUV;
|
|
uniform float _Base_Speed;
|
|
uniform float _Scroll_EmissiveU;
|
|
uniform float _Scroll_EmissiveV;
|
|
uniform fixed _Is_PingPong_Base;
|
|
uniform float4 _ColorShift;
|
|
uniform float4 _ViewShift;
|
|
uniform float _ColorShift_Speed;
|
|
uniform fixed _Is_ColorShift;
|
|
uniform fixed _Is_ViewShift;
|
|
uniform float3 emissive;
|
|
//
|
|
uniform float _Unlit_Intensity;
|
|
//v.2.0.5
|
|
uniform fixed _Is_Filter_HiCutPointLightColor;
|
|
uniform fixed _Is_Filter_LightColor;
|
|
//v.2.0.4.4
|
|
uniform float _StepOffset;
|
|
uniform fixed _Is_BLD;
|
|
uniform float _Offset_X_Axis_BLD;
|
|
uniform float _Offset_Y_Axis_BLD;
|
|
uniform fixed _Inverse_Z_Axis_BLD;
|
|
//v.2.0.4
|
|
#ifdef _IS_CLIPPING_MODE
|
|
//DoubleShadeWithFeather_Clipping
|
|
uniform sampler2D _ClippingMask; uniform float4 _ClippingMask_ST;
|
|
uniform float _Clipping_Level;
|
|
uniform fixed _Inverse_Clipping;
|
|
#elif defined(_IS_CLIPPING_TRANSMODE) || defined(_IS_TRANSCLIPPING_ON)
|
|
//DoubleShadeWithFeather_TransClipping
|
|
uniform sampler2D _ClippingMask; uniform float4 _ClippingMask_ST;
|
|
uniform fixed _IsBaseMapAlphaAsClippingMask;
|
|
uniform float _Clipping_Level;
|
|
uniform fixed _Inverse_Clipping;
|
|
uniform float _Tweak_transparency;
|
|
#elif defined(_IS_CLIPPING_OFF) || defined(_IS_TRANSCLIPPING_OFF)
|
|
//DoubleShadeWithFeather
|
|
#endif
|
|
// RaytracedHardShadow
|
|
#define UNITY_PROJ_COORD(a) a
|
|
#define UNITY_SAMPLE_SCREEN_SHADOW(tex, uv) tex2Dproj( tex, UNITY_PROJ_COORD(uv) ).r
|
|
// TEXTURE2D_SHADOW(_RaytracedHardShadow);
|
|
// SAMPLER_CMP(sampler__RaytracedHardShadow);
|
|
#define TEXTURE2D_SAMPLER2D(textureName, samplerName) Texture2D textureName; SamplerState samplerName
|
|
TEXTURE2D_SAMPLER2D(_RaytracedHardShadow, sampler_RaytracedHardShadow);
|
|
// uniform sampler2D _RaytracedHardShadow;
|
|
float4 _RaytracedHardShadow_TexelSize;
|
|
uniform int UtsUseRaytracingShadow;
|
|
|
|
// UV回転をする関数：RotateUV()
|
|
//float2 rotatedUV = RotateUV(i.uv0, (_angular_Verocity*3.141592654), float2(0.5, 0.5), _Time.g);
|
|
float2 RotateUV(float2 _uv, float _radian, float2 _piv, float _time)
|
|
{
|
|
float RotateUV_ang = _radian;
|
|
float RotateUV_cos = cos(_time*RotateUV_ang);
|
|
float RotateUV_sin = sin(_time*RotateUV_ang);
|
|
return (mul(_uv - _piv, float2x2( RotateUV_cos, -RotateUV_sin, RotateUV_sin, RotateUV_cos)) + _piv);
|
|
}
|
|
//
|
|
fixed3 DecodeLightProbe( fixed3 N ){
|
|
return ShadeSH9(float4(N,1));
|
|
}
|
|
|
|
|
|
inline void InitializeStandardLitSurfaceDataUTS(float2 uv, out SurfaceData outSurfaceData)
|
|
{
|
|
// half4 albedoAlpha = SampleAlbedoAlpha(uv, TEXTURE2D_ARGS(_BaseMap, sampler_BaseMap));
|
|
half4 albedoAlpha = half4(1.0,1.0,1.0,1.0);
|
|
|
|
outSurfaceData.alpha = Alpha(albedoAlpha.a, _BaseColor, _Cutoff);
|
|
|
|
half4 specGloss = SampleMetallicSpecGloss(uv, albedoAlpha.a);
|
|
outSurfaceData.albedo = albedoAlpha.rgb * _BaseColor.rgb;
|
|
|
|
#if _SPECULAR_SETUP
|
|
outSurfaceData.metallic = 1.0h;
|
|
outSurfaceData.specular = specGloss.rgb;
|
|
#else
|
|
outSurfaceData.metallic = specGloss.r;
|
|
outSurfaceData.specular = half3(0.0h, 0.0h, 0.0h);
|
|
#endif
|
|
|
|
outSurfaceData.smoothness = specGloss.a;
|
|
outSurfaceData.normalTS = SampleNormal(uv, TEXTURE2D_ARGS(_BumpMap, sampler_BumpMap), _BumpScale);
|
|
outSurfaceData.occlusion = SampleOcclusion(uv);
|
|
outSurfaceData.emission = SampleEmission(uv, _EmissionColor.rgb, TEXTURE2D_ARGS(_EmissionMap, sampler_EmissionMap));
|
|
}
|
|
half3 GlobalIlluminationUTS(BRDFData brdfData, half3 bakedGI, half occlusion, half3 normalWS, half3 viewDirectionWS)
|
|
{
|
|
half3 reflectVector = reflect(-viewDirectionWS, normalWS);
|
|
half fresnelTerm = Pow4(1.0 - saturate(dot(normalWS, viewDirectionWS)));
|
|
|
|
half3 indirectDiffuse = bakedGI * occlusion;
|
|
half3 indirectSpecular = GlossyEnvironmentReflection(reflectVector, brdfData.perceptualRoughness, occlusion);
|
|
|
|
return EnvironmentBRDF(brdfData, indirectDiffuse, indirectSpecular, fresnelTerm);
|
|
}
|
|
uniform float _GI_Intensity;
|
|
|
|
//v.2.0.4
|
|
#if defined(_SHADINGGRADEMAP)
|
|
|
|
#ifdef _IS_ANGELRING_OFF
|
|
//
|
|
#elif _IS_ANGELRING_ON
|
|
uniform fixed _AngelRing;
|
|
|
|
uniform sampler2D _AngelRing_Sampler; uniform float4 _AngelRing_Sampler_ST;
|
|
uniform float4 _AngelRing_Color;
|
|
uniform fixed _Is_LightColor_AR;
|
|
uniform float _AR_OffsetU;
|
|
uniform float _AR_OffsetV;
|
|
uniform fixed _ARSampler_AlphaOn;
|
|
|
|
#endif
|
|
#endif //#if defined(_SHADINGGRADEMP)
|
|
struct VertexInput {
|
|
float4 vertex : POSITION;
|
|
float3 normal : NORMAL;
|
|
float4 tangent : TANGENT;
|
|
float2 texcoord0 : TEXCOORD0;
|
|
|
|
|
|
#ifdef _IS_ANGELRING_OFF
|
|
float2 lightmapUV : TEXCOORD1;
|
|
#elif _IS_ANGELRING_ON
|
|
float2 texcoord1 : TEXCOORD1;
|
|
float2 lightmapUV : TEXCOORD2;
|
|
#endif
|
|
UNITY_VERTEX_INPUT_INSTANCE_ID
|
|
|
|
};
|
|
struct VertexOutput {
|
|
float4 pos : SV_POSITION;
|
|
float2 uv0 : TEXCOORD0;
|
|
//v.2.0.4
|
|
#ifdef _IS_ANGELRING_OFF
|
|
float4 posWorld : TEXCOORD1;
|
|
float3 normalDir : TEXCOORD2;
|
|
float3 tangentDir : TEXCOORD3;
|
|
float3 bitangentDir : TEXCOORD4;
|
|
//v.2.0.7
|
|
float mirrorFlag : TEXCOORD5;
|
|
|
|
DECLARE_LIGHTMAP_OR_SH(lightmapUV, vertexSH, 6);
|
|
half4 fogFactorAndVertexLight : TEXCOORD7; // x: fogFactor, yzw: vertex light
|
|
# ifndef _MAIN_LIGHT_SHADOWS
|
|
float4 positionCS : TEXCOORD8;
|
|
int mainLightID : TEXCOORD9;
|
|
# else
|
|
float4 shadowCoord : TEXCOORD8;
|
|
float4 positionCS : TEXCOORD9;
|
|
int mainLightID : TEXCOORD10;
|
|
# endif
|
|
UNITY_VERTEX_INPUT_INSTANCE_ID
|
|
UNITY_VERTEX_OUTPUT_STEREO
|
|
|
|
//
|
|
#elif _IS_ANGELRING_ON
|
|
float2 uv1 : TEXCOORD1;
|
|
float4 posWorld : TEXCOORD2;
|
|
float3 normalDir : TEXCOORD3;
|
|
float3 tangentDir : TEXCOORD4;
|
|
float3 bitangentDir : TEXCOORD5;
|
|
//v.2.0.7
|
|
float mirrorFlag : TEXCOORD6;
|
|
|
|
DECLARE_LIGHTMAP_OR_SH(lightmapUV, vertexSH, 7);
|
|
half4 fogFactorAndVertexLight : TEXCOORD8; // x: fogFactor, yzw: vertex light
|
|
# ifndef _MAIN_LIGHT_SHADOWS
|
|
float4 positionCS : TEXCOORD9;
|
|
int mainLightID : TEXCOORD10;
|
|
# else
|
|
float4 shadowCoord : TEXCOORD9;
|
|
float4 positionCS : TEXCOORD10;
|
|
int mainLightID : TEXCOORD11;
|
|
# endif
|
|
UNITY_VERTEX_INPUT_INSTANCE_ID
|
|
UNITY_VERTEX_OUTPUT_STEREO
|
|
#else
|
|
LIGHTING_COORDS(7,8)
|
|
UNITY_FOG_COORDS(9)
|
|
#endif
|
|
//
|
|
|
|
};
|
|
|
|
// Abstraction over Light shading data.
|
|
struct UtsLight
|
|
{
|
|
float3 direction;
|
|
float3 color;
|
|
float distanceAttenuation;
|
|
real shadowAttenuation;
|
|
int type;
|
|
};
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
// Light Abstraction //
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
real MainLightRealtimeShadowUTS(float4 shadowCoord, float4 positionCS)
|
|
{
|
|
#if !defined(MAIN_LIGHT_CALCULATE_SHADOWS)
|
|
return 1.0h;
|
|
#endif
|
|
ShadowSamplingData shadowSamplingData = GetMainLightShadowSamplingData();
|
|
half4 shadowParams = GetMainLightShadowParams();
|
|
#if defined(UTS_USE_RAYTRACING_SHADOW)
|
|
float4 screenPos = ComputeScreenPos(positionCS/ positionCS.w);
|
|
return SAMPLE_TEXTURE2D(_RaytracedHardShadow, sampler_RaytracedHardShadow, screenPos);
|
|
#endif
|
|
|
|
return SampleShadowmap(TEXTURE2D_ARGS(_MainLightShadowmapTexture, sampler_MainLightShadowmapTexture), shadowCoord, shadowSamplingData, shadowParams, false);
|
|
}
|
|
|
|
real AdditionalLightRealtimeShadowUTS(int lightIndex, float3 positionWS, float4 positionCS)
|
|
{
|
|
#if defined(UTS_USE_RAYTRACING_SHADOW)
|
|
float4 screenPos = ComputeScreenPos(positionCS / positionCS.w);
|
|
return SAMPLE_TEXTURE2D(_RaytracedHardShadow, sampler_RaytracedHardShadow, screenPos);
|
|
#endif // UTS_USE_RAYTRACING_SHADOW
|
|
|
|
#if !defined(ADDITIONAL_LIGHT_CALCULATE_SHADOWS)
|
|
return 1.0h;
|
|
#endif
|
|
|
|
ShadowSamplingData shadowSamplingData = GetAdditionalLightShadowSamplingData();
|
|
|
|
#if USE_STRUCTURED_BUFFER_FOR_LIGHT_DATA
|
|
lightIndex = _AdditionalShadowsIndices[lightIndex];
|
|
|
|
// We have to branch here as otherwise we would sample buffer with lightIndex == -1.
|
|
// However this should be ok for platforms that store light in SSBO.
|
|
UNITY_BRANCH
|
|
if (lightIndex < 0)
|
|
return 1.0;
|
|
|
|
float4 shadowCoord = mul(_AdditionalShadowsBuffer[lightIndex].worldToShadowMatrix, float4(positionWS, 1.0));
|
|
#else
|
|
float4 shadowCoord = mul(_AdditionalLightsWorldToShadow[lightIndex], float4(positionWS, 1.0));
|
|
#endif
|
|
|
|
half4 shadowParams = GetAdditionalLightShadowParams(lightIndex);
|
|
return SampleShadowmap(TEXTURE2D_ARGS(_AdditionalLightsShadowmapTexture, sampler_AdditionalLightsShadowmapTexture), shadowCoord, shadowSamplingData, shadowParams, true);
|
|
}
|
|
|
|
|
|
|
|
UtsLight GetMainUtsLight()
|
|
{
|
|
UtsLight light;
|
|
light.direction = _MainLightPosition.xyz;
|
|
// unity_LightData.z is 1 when not culled by the culling mask, otherwise 0.
|
|
light.distanceAttenuation = unity_LightData.z;
|
|
#if defined(LIGHTMAP_ON) || defined(_MIXED_LIGHTING_SUBTRACTIVE)
|
|
// unity_ProbesOcclusion.x is the mixed light probe occlusion data
|
|
light.distanceAttenuation *= unity_ProbesOcclusion.x;
|
|
#endif
|
|
light.shadowAttenuation = 1.0;
|
|
light.color = _MainLightColor.rgb;
|
|
light.type = _MainLightPosition.w;
|
|
return light;
|
|
}
|
|
|
|
UtsLight GetMainUtsLight(float4 shadowCoord, float4 positionCS)
|
|
{
|
|
UtsLight light = GetMainUtsLight();
|
|
light.shadowAttenuation = MainLightRealtimeShadowUTS(shadowCoord, positionCS);
|
|
return light;
|
|
}
|
|
|
|
// Fills a light struct given a perObjectLightIndex
|
|
UtsLight GetAdditionalPerObjectUtsLight(int perObjectLightIndex, float3 positionWS,float4 positionCS)
|
|
{
|
|
// Abstraction over Light input constants
|
|
#if USE_STRUCTURED_BUFFER_FOR_LIGHT_DATA
|
|
float4 lightPositionWS = _AdditionalLightsBuffer[perObjectLightIndex].position;
|
|
half3 color = _AdditionalLightsBuffer[perObjectLightIndex].color.rgb;
|
|
half4 distanceAndSpotAttenuation = _AdditionalLightsBuffer[perObjectLightIndex].attenuation;
|
|
half4 spotDirection = _AdditionalLightsBuffer[perObjectLightIndex].spotDirection;
|
|
half4 lightOcclusionProbeInfo = _AdditionalLightsBuffer[perObjectLightIndex].occlusionProbeChannels;
|
|
#else
|
|
float4 lightPositionWS = _AdditionalLightsPosition[perObjectLightIndex];
|
|
half3 color = _AdditionalLightsColor[perObjectLightIndex].rgb;
|
|
half4 distanceAndSpotAttenuation = _AdditionalLightsAttenuation[perObjectLightIndex];
|
|
half4 spotDirection = _AdditionalLightsSpotDir[perObjectLightIndex];
|
|
half4 lightOcclusionProbeInfo = _AdditionalLightsOcclusionProbes[perObjectLightIndex];
|
|
#endif
|
|
|
|
// Directional lights store direction in lightPosition.xyz and have .w set to 0.0.
|
|
// This way the following code will work for both directional and punctual lights.
|
|
float3 lightVector = lightPositionWS.xyz - positionWS * lightPositionWS.w;
|
|
float distanceSqr = max(dot(lightVector, lightVector), HALF_MIN);
|
|
|
|
half3 lightDirection = half3(lightVector * rsqrt(distanceSqr));
|
|
half attenuation = DistanceAttenuation(distanceSqr, distanceAndSpotAttenuation.xy) * AngleAttenuation(spotDirection.xyz, lightDirection, distanceAndSpotAttenuation.zw);
|
|
|
|
UtsLight light;
|
|
light.direction = lightDirection;
|
|
light.distanceAttenuation = attenuation;
|
|
light.shadowAttenuation = AdditionalLightRealtimeShadowUTS(perObjectLightIndex, positionWS, positionCS);
|
|
light.color = color;
|
|
light.type = lightPositionWS.w;
|
|
|
|
// In case we're using light probes, we can sample the attenuation from the `unity_ProbesOcclusion`
|
|
#if defined(LIGHTMAP_ON) || defined(_MIXED_LIGHTING_SUBTRACTIVE)
|
|
// First find the probe channel from the light.
|
|
// Then sample `unity_ProbesOcclusion` for the baked occlusion.
|
|
// If the light is not baked, the channel is -1, and we need to apply no occlusion.
|
|
|
|
// probeChannel is the index in 'unity_ProbesOcclusion' that holds the proper occlusion value.
|
|
int probeChannel = lightOcclusionProbeInfo.x;
|
|
|
|
// lightProbeContribution is set to 0 if we are indeed using a probe, otherwise set to 1.
|
|
half lightProbeContribution = lightOcclusionProbeInfo.y;
|
|
|
|
half probeOcclusionValue = unity_ProbesOcclusion[probeChannel];
|
|
light.distanceAttenuation *= max(probeOcclusionValue, lightProbeContribution);
|
|
#endif
|
|
|
|
return light;
|
|
}
|
|
|
|
// Fills a light struct given a loop i index. This will convert the i
|
|
// index to a perObjectLightIndex
|
|
UtsLight GetAdditionalUtsLight(uint i, float3 positionWS,float4 positionCS)
|
|
{
|
|
int perObjectLightIndex = GetPerObjectLightIndex(i);
|
|
return GetAdditionalPerObjectUtsLight(perObjectLightIndex, positionWS, positionCS);
|
|
}
|
|
|
|
half3 GetLightColor(UtsLight light)
|
|
{
|
|
return light.color * light.distanceAttenuation;
|
|
}
|
|
|
|
|
|
#define INIT_UTSLIGHT(utslight) \
|
|
utslight.direction = 0; \
|
|
utslight.color = 0; \
|
|
utslight.distanceAttenuation = 0; \
|
|
utslight.shadowAttenuation = 0; \
|
|
utslight.type = 0
|
|
|
|
|
|
int DetermineUTS_MainLightIndex(float3 posW, float4 shadowCoord, float4 positionCS)
|
|
{
|
|
UtsLight mainLight;
|
|
INIT_UTSLIGHT(mainLight);
|
|
|
|
int mainLightIndex = -2;
|
|
UtsLight nextLight = GetMainUtsLight(shadowCoord, positionCS);
|
|
if (nextLight.distanceAttenuation > mainLight.distanceAttenuation && nextLight.type == 0)
|
|
{
|
|
mainLight = nextLight;
|
|
mainLightIndex = -1;
|
|
}
|
|
int lightCount = GetAdditionalLightsCount();
|
|
for (int ii = 0; ii < lightCount; ++ii)
|
|
{
|
|
nextLight = GetAdditionalUtsLight(ii, posW, positionCS);
|
|
if (nextLight.distanceAttenuation > mainLight.distanceAttenuation && nextLight.type == 0)
|
|
{
|
|
mainLight = nextLight;
|
|
mainLightIndex = ii;
|
|
}
|
|
}
|
|
|
|
return mainLightIndex;
|
|
}
|
|
|
|
UtsLight GetMainUtsLightByID(int index,float3 posW, float4 shadowCoord, float4 positionCS)
|
|
{
|
|
UtsLight mainLight;
|
|
INIT_UTSLIGHT(mainLight);
|
|
if (index == -2)
|
|
{
|
|
return mainLight;
|
|
}
|
|
if (index == -1)
|
|
{
|
|
return GetMainUtsLight(shadowCoord, positionCS);
|
|
}
|
|
return GetAdditionalUtsLight(index, posW, positionCS);
|
|
}
|
|
VertexOutput vert (VertexInput v) {
|
|
VertexOutput o = (VertexOutput)0;
|
|
|
|
UNITY_SETUP_INSTANCE_ID(v);
|
|
UNITY_TRANSFER_INSTANCE_ID(v, o);
|
|
UNITY_INITIALIZE_VERTEX_OUTPUT_STEREO(o);
|
|
|
|
o.uv0 = v.texcoord0;
|
|
//v.2.0.4
|
|
#ifdef _IS_ANGELRING_OFF
|
|
//
|
|
#elif _IS_ANGELRING_ON
|
|
o.uv1 = v.texcoord1;
|
|
#endif
|
|
o.normalDir = UnityObjectToWorldNormal(v.normal);
|
|
o.tangentDir = normalize( mul( unity_ObjectToWorld, float4( v.tangent.xyz, 0.0 ) ).xyz );
|
|
o.bitangentDir = normalize(cross(o.normalDir, o.tangentDir) * v.tangent.w);
|
|
o.posWorld = mul(unity_ObjectToWorld, v.vertex);
|
|
|
|
o.pos = UnityObjectToClipPos( v.vertex );
|
|
//v.2.0.7 鏡の中判定（右手座標系か、左手座標系かの判定）o.mirrorFlag = -1 なら鏡の中.
|
|
float3 crossFwd = cross(UNITY_MATRIX_V[0], UNITY_MATRIX_V[1]);
|
|
o.mirrorFlag = dot(crossFwd, UNITY_MATRIX_V[2]) < 0 ? 1 : -1;
|
|
//
|
|
|
|
float3 positionWS = TransformObjectToWorld(v.vertex);
|
|
float4 positionCS = TransformWorldToHClip(positionWS);
|
|
half3 vertexLight = VertexLighting(o.posWorld, o.normalDir);
|
|
half fogFactor = ComputeFogFactor(positionCS.z);
|
|
|
|
OUTPUT_LIGHTMAP_UV(v.lightmapUV, unity_LightmapST, o.lightmapUV);
|
|
OUTPUT_SH(o.normalDir.xyz, o.vertexSH);
|
|
|
|
o.fogFactorAndVertexLight = half4(fogFactor, vertexLight);
|
|
o.positionCS = positionCS;
|
|
#if defined(_MAIN_LIGHT_SHADOWS) && !defined(_RECEIVE_SHADOWS_OFF)
|
|
#if SHADOWS_SCREEN
|
|
o.shadowCoord = ComputeScreenPos(positionCS);
|
|
#else
|
|
o.shadowCoord = TransformWorldToShadowCoord(o.posWorld);
|
|
#endif
|
|
o.mainLightID = DetermineUTS_MainLightIndex(o.posWorld, o.shadowCoord, positionCS);
|
|
#else
|
|
o.mainLightID = DetermineUTS_MainLightIndex(o.posWorld, 0, positionCS);
|
|
#endif
|
|
|
|
|
|
return o;
|
|
}
|
|
|
|
|
|
|
|
#if defined(_SHADINGGRADEMAP)
|
|
|
|
#include "UniversalToonBodyShadingGradeMap.hlsl"
|
|
|
|
#else //#if defined(_SHADINGGRADEMAP)
|
|
|
|
#include "UniversalToonBodyDoubleShadeWithFeather.hlsl"
|
|
|
|
#endif //#if defined(_SHADINGGRADEMAP)
|
|
|
|
float4 frag(VertexOutput i, fixed facing : VFACE) : SV_TARGET
|
|
{
|
|
#if defined(_SHADINGGRADEMAP)
|
|
return fragShadingGradeMap(i, facing);
|
|
#else
|
|
return fragDoubleShadeFeather(i, facing);
|
|
#endif
|
|
}
|