1108 lines
48 KiB
HLSL
1108 lines
48 KiB
HLSL
|
#ifndef ADVANCED_DISSOLVE_CORE_CGINC
|
||
|
|
#define ADVANCED_DISSOLVE_CORE_CGINC
|
||
|
|
|
||
|
|
#if defined(ADVANCED_DISSOLVE_BUILTIN_RENDER_PIPELINE)
|
||
|
|
#include "UnityCG.cginc"
|
||
|
|
#endif
|
||
|
|
|
||
|
|
#include "Defines.cginc"
|
||
|
|
|
||
|
|
#if defined(_ADVANCED_DISSOLVE_KEYWORDS_BAKED)
|
||
|
|
#if defined(_AD_GLOBAL_CONTROL_ID_ONE) || defined(_AD_GLOBAL_CONTROL_ID_TWO) || defined(_AD_GLOBAL_CONTROL_ID_THREE) || defined(_AD_GLOBAL_CONTROL_ID_FOUR)
|
||
|
|
#include "Variables.cginc"
|
||
|
|
#else
|
||
|
|
//No need to inlcude variables here, they are already defined in shader cbuffer
|
||
|
|
#endif
|
||
|
|
#else
|
||
|
|
#include "Variables.cginc"
|
||
|
|
#endif
|
||
|
|
|
||
|
|
#include "SpaceTransforms.cginc"
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
float ADBlendGradientEdges(float a, float b)
|
||
|
|
{
|
||
|
|
return saturate(1 - min(a, b));
|
||
|
|
}
|
||
|
|
|
||
|
|
float ADBlendGradientEdges(float a, float b, float c)
|
||
|
|
{
|
||
|
|
return saturate(1 - min(min(a, b), c));
|
||
|
|
}
|
||
|
|
|
||
|
|
float ADBlendGradientEdges(float a, float b, float c, float d)
|
||
|
|
{
|
||
|
|
return saturate(1 - min(min(a, b), min(c, d)));
|
||
|
|
}
|
||
|
|
|
||
|
|
inline float ProjectT(float3 origin, float3 normal, float height, float3 vertex)
|
||
|
|
{
|
||
|
|
return saturate(dot(vertex - origin, normal) / height);
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
#if defined(ADVANCED_DISSOLVE_CUTOUT_GEOMETRIC_ENABLED)
|
||
|
|
inline float ADReadGeometricValue(float3 positionOS, float3 positionAbsolute, float noise)
|
||
|
|
{
|
||
|
|
float cutout = -1;
|
||
|
|
|
||
|
|
// 1 - without invert
|
||
|
|
//-1 - with invert enabled
|
||
|
|
noise *= (1 - 2 * VALUE_GEOMETRIC_INVERT);
|
||
|
|
|
||
|
|
|
||
|
|
#if defined(_AD_CUTOUT_GEOMETRIC_TYPE_XYZ)
|
||
|
|
|
||
|
|
int xyzAxis = (int)VALUE_GEOMETRIC_XYZ_AXIS;
|
||
|
|
|
||
|
|
float vertexPos = (lerp(positionAbsolute, positionOS, VALUE_GEOMETRIC_XYZ_SPACE))[xyzAxis];
|
||
|
|
|
||
|
|
//Linear
|
||
|
|
float l = vertexPos - VALUE_GEOMETRIC_XYZ_POSITION[xyzAxis] + noise + VALUE_GEOMETRIC_INVERT;
|
||
|
|
|
||
|
|
//Rollout
|
||
|
|
float r = abs(vertexPos - VALUE_GEOMETRIC_XYZ_POSITION[xyzAxis]) - VALUE_GEOMETRIC_XYZ_ROLLOUT + saturate(VALUE_GEOMETRIC_XYZ_ROLLOUT) * noise + VALUE_GEOMETRIC_INVERT;
|
||
|
|
|
||
|
|
|
||
|
|
cutout = saturate(lerp(l, r, VALUE_GEOMETRIC_XYZ_STYLE));
|
||
|
|
|
||
|
|
#elif defined(_AD_CUTOUT_GEOMETRIC_TYPE_PLANE)
|
||
|
|
|
||
|
|
#if defined(_AD_CUTOUT_GEOMETRIC_COUNT_FOUR)
|
||
|
|
|
||
|
|
float4 d = float4(dot(VALUE_GEOMETRIC_NORMAL, (positionAbsolute - VALUE_GEOMETRIC_POSITION)), dot(VALUE_GEOMETRIC_2_NORMAL, (positionAbsolute - VALUE_GEOMETRIC_2_POSITION)), dot(VALUE_GEOMETRIC_3_NORMAL, (positionAbsolute - VALUE_GEOMETRIC_3_POSITION)), dot(VALUE_GEOMETRIC_4_NORMAL, (positionAbsolute - VALUE_GEOMETRIC_4_POSITION)));
|
||
|
|
|
||
|
|
d += noise.xxxx + VALUE_GEOMETRIC_INVERT;
|
||
|
|
|
||
|
|
d = saturate(d);
|
||
|
|
|
||
|
|
cutout = 1 - ADBlendGradientEdges(d.x, d.y, d.z, d.w);
|
||
|
|
|
||
|
|
#elif defined(_AD_CUTOUT_GEOMETRIC_COUNT_THREE)
|
||
|
|
|
||
|
|
float3 d = float3(dot(VALUE_GEOMETRIC_NORMAL, (positionAbsolute - VALUE_GEOMETRIC_POSITION)), dot(VALUE_GEOMETRIC_2_NORMAL, (positionAbsolute - VALUE_GEOMETRIC_2_POSITION)), dot(VALUE_GEOMETRIC_3_NORMAL, (positionAbsolute - VALUE_GEOMETRIC_3_POSITION)));
|
||
|
|
|
||
|
|
d += noise.xxx + VALUE_GEOMETRIC_INVERT;
|
||
|
|
|
||
|
|
d = saturate(d);
|
||
|
|
|
||
|
|
cutout = 1 - ADBlendGradientEdges(d.x, d.y, d.z);
|
||
|
|
|
||
|
|
#elif defined(_AD_CUTOUT_GEOMETRIC_COUNT_TWO)
|
||
|
|
|
||
|
|
float2 d = float2(dot(VALUE_GEOMETRIC_NORMAL, (positionAbsolute - VALUE_GEOMETRIC_POSITION)), dot(VALUE_GEOMETRIC_2_NORMAL, (positionAbsolute - VALUE_GEOMETRIC_2_POSITION)));
|
||
|
|
|
||
|
|
d += noise.xx + VALUE_GEOMETRIC_INVERT;
|
||
|
|
|
||
|
|
d = saturate(d);
|
||
|
|
|
||
|
|
cutout = 1 - ADBlendGradientEdges(d.x, d.y);
|
||
|
|
|
||
|
|
#else
|
||
|
|
|
||
|
|
float d = dot(VALUE_GEOMETRIC_NORMAL, (positionAbsolute - VALUE_GEOMETRIC_POSITION));
|
||
|
|
|
||
|
|
d += noise + VALUE_GEOMETRIC_INVERT;
|
||
|
|
|
||
|
|
cutout = saturate(d);
|
||
|
|
|
||
|
|
#endif
|
||
|
|
|
||
|
|
#elif defined(_AD_CUTOUT_GEOMETRIC_TYPE_SPHERE)
|
||
|
|
|
||
|
|
#if defined(_AD_CUTOUT_GEOMETRIC_COUNT_FOUR)
|
||
|
|
|
||
|
|
float4 d = float4(distance(positionAbsolute, VALUE_GEOMETRIC_POSITION), distance(positionAbsolute, VALUE_GEOMETRIC_2_POSITION), distance(positionAbsolute, VALUE_GEOMETRIC_3_POSITION), distance(positionAbsolute, VALUE_GEOMETRIC_4_POSITION));
|
||
|
|
float4 radius = float4(VALUE_GEOMETRIC_RADIUS, VALUE_GEOMETRIC_2_RADIUS, VALUE_GEOMETRIC_3_RADIUS, VALUE_GEOMETRIC_4_RADIUS);
|
||
|
|
|
||
|
|
float4 e = saturate(max(0, d - radius + lerp(1, 0, VALUE_GEOMETRIC_INVERT).xxxx - saturate(radius) * noise));
|
||
|
|
|
||
|
|
cutout = ADBlendGradientEdges(e.x, e.y, e.z, e.w);
|
||
|
|
|
||
|
|
#elif defined(_AD_CUTOUT_GEOMETRIC_COUNT_THREE)
|
||
|
|
|
||
|
|
float3 d = float3(distance(positionAbsolute, VALUE_GEOMETRIC_POSITION), distance(positionAbsolute, VALUE_GEOMETRIC_2_POSITION), distance(positionAbsolute, VALUE_GEOMETRIC_3_POSITION));
|
||
|
|
float3 radius = float3(VALUE_GEOMETRIC_RADIUS, VALUE_GEOMETRIC_2_RADIUS, VALUE_GEOMETRIC_3_RADIUS);
|
||
|
|
|
||
|
|
float3 e = saturate(max(0, d - radius + lerp(1, 0, VALUE_GEOMETRIC_INVERT).xxx - saturate(radius) * noise));
|
||
|
|
|
||
|
|
cutout = ADBlendGradientEdges(e.x, e.y, e.z);
|
||
|
|
|
||
|
|
#elif defined(_AD_CUTOUT_GEOMETRIC_COUNT_TWO)
|
||
|
|
|
||
|
|
float2 d = float2(distance(positionAbsolute, VALUE_GEOMETRIC_POSITION), distance(positionAbsolute, VALUE_GEOMETRIC_2_POSITION));
|
||
|
|
float2 radius = float2(VALUE_GEOMETRIC_RADIUS, VALUE_GEOMETRIC_2_RADIUS);
|
||
|
|
|
||
|
|
float2 e = saturate(max(0, d - radius + lerp(1, 0, VALUE_GEOMETRIC_INVERT).xx - saturate(radius) * noise));
|
||
|
|
|
||
|
|
cutout = ADBlendGradientEdges(e.x, e.y);
|
||
|
|
|
||
|
|
#else
|
||
|
|
|
||
|
|
float d = distance(positionAbsolute, VALUE_GEOMETRIC_POSITION);
|
||
|
|
|
||
|
|
float radius = VALUE_GEOMETRIC_RADIUS - lerp(1, 0, VALUE_GEOMETRIC_INVERT);
|
||
|
|
|
||
|
|
cutout = 1 - saturate(max(0, d - radius - saturate(VALUE_GEOMETRIC_RADIUS) * noise));
|
||
|
|
|
||
|
|
#endif
|
||
|
|
|
||
|
|
#elif defined(_AD_CUTOUT_GEOMETRIC_TYPE_CUBE)
|
||
|
|
|
||
|
|
float boundsEdge = lerp(0, 1, VALUE_GEOMETRIC_INVERT);
|
||
|
|
|
||
|
|
|
||
|
|
#if defined(_AD_CUTOUT_GEOMETRIC_COUNT_FOUR)
|
||
|
|
|
||
|
|
//1////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
||
|
|
float3 vertexInverseTransform = mul(VALUE_GEOMETRIC_MATRIX_TRS, float4(positionAbsolute, 1)).xyz;
|
||
|
|
|
||
|
|
float3 absSize = abs(VALUE_GEOMETRIC_SIZE);
|
||
|
|
float3 b = abs(vertexInverseTransform) - (absSize + boundsEdge) - saturate(absSize) * noise;
|
||
|
|
float c1 = saturate(length(max(b, 0.0)) + min(max(b.x, max(b.y, b.z)), 0.0) + 1);
|
||
|
|
|
||
|
|
//2////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
||
|
|
vertexInverseTransform = mul(VALUE_GEOMETRIC_2_TRS, float4(positionAbsolute, 1)).xyz;
|
||
|
|
|
||
|
|
absSize = abs(VALUE_GEOMETRIC_2_SIZE);
|
||
|
|
b = abs(vertexInverseTransform) - (absSize + boundsEdge) - saturate(absSize) * noise;
|
||
|
|
float c2 = saturate(length(max(b, 0.0)) + min(max(b.x, max(b.y, b.z)), 0.0) + 1);
|
||
|
|
|
||
|
|
//3////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
||
|
|
vertexInverseTransform = mul(VALUE_GEOMETRIC_3_TRS, float4(positionAbsolute, 1)).xyz;
|
||
|
|
|
||
|
|
absSize = abs(VALUE_GEOMETRIC_3_SIZE);
|
||
|
|
b = abs(vertexInverseTransform) - (absSize + boundsEdge) - saturate(absSize) * noise;
|
||
|
|
float c3 = saturate(length(max(b, 0.0)) + min(max(b.x, max(b.y, b.z)), 0.0) + 1);
|
||
|
|
|
||
|
|
//4////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
||
|
|
vertexInverseTransform = mul(VALUE_GEOMETRIC_4_TRS, float4(positionAbsolute, 1)).xyz;
|
||
|
|
|
||
|
|
absSize = abs(VALUE_GEOMETRIC_4_SIZE);
|
||
|
|
b = abs(vertexInverseTransform) - (absSize + boundsEdge) - saturate(absSize) * noise;
|
||
|
|
float c4 = saturate(length(max(b, 0.0)) + min(max(b.x, max(b.y, b.z)), 0.0) + 1);
|
||
|
|
|
||
|
|
//Final
|
||
|
|
cutout = ADBlendGradientEdges(c1, c2 ,c3, c4);
|
||
|
|
|
||
|
|
#elif defined(_AD_CUTOUT_GEOMETRIC_COUNT_THREE)
|
||
|
|
|
||
|
|
//1////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
||
|
|
float3 vertexInverseTransform = mul(VALUE_GEOMETRIC_MATRIX_TRS, float4(positionAbsolute, 1)).xyz;
|
||
|
|
|
||
|
|
float3 absSize = abs(VALUE_GEOMETRIC_SIZE);
|
||
|
|
float3 b = abs(vertexInverseTransform) - (absSize + boundsEdge) - saturate(absSize) * noise;
|
||
|
|
float c1 = saturate(length(max(b, 0.0)) + min(max(b.x, max(b.y, b.z)), 0.0) + 1);
|
||
|
|
|
||
|
|
//2////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
||
|
|
vertexInverseTransform = mul(VALUE_GEOMETRIC_2_TRS, float4(positionAbsolute, 1)).xyz;
|
||
|
|
|
||
|
|
absSize = abs(VALUE_GEOMETRIC_2_SIZE);
|
||
|
|
b = abs(vertexInverseTransform) - (absSize + boundsEdge) - saturate(absSize) * noise;
|
||
|
|
float c2 = saturate(length(max(b, 0.0)) + min(max(b.x, max(b.y, b.z)), 0.0) + 1);
|
||
|
|
|
||
|
|
//3////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
||
|
|
vertexInverseTransform = mul(VALUE_GEOMETRIC_3_TRS, float4(positionAbsolute, 1)).xyz;
|
||
|
|
|
||
|
|
absSize = abs(VALUE_GEOMETRIC_3_SIZE);
|
||
|
|
b = abs(vertexInverseTransform) - (absSize + boundsEdge) - saturate(absSize) * noise;
|
||
|
|
float c3 = saturate(length(max(b, 0.0)) + min(max(b.x, max(b.y, b.z)), 0.0) + 1);
|
||
|
|
|
||
|
|
//Final
|
||
|
|
cutout = ADBlendGradientEdges(c1, c2 ,c3);
|
||
|
|
|
||
|
|
#elif defined(_AD_CUTOUT_GEOMETRIC_COUNT_TWO)
|
||
|
|
|
||
|
|
//1////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
||
|
|
float3 vertexInverseTransform = mul(VALUE_GEOMETRIC_MATRIX_TRS, float4(positionAbsolute, 1)).xyz;
|
||
|
|
|
||
|
|
float3 absSize = abs(VALUE_GEOMETRIC_SIZE);
|
||
|
|
float3 b = abs(vertexInverseTransform) - (absSize + boundsEdge) - saturate(absSize) * noise;
|
||
|
|
float c1 = saturate(length(max(b, 0.0)) + min(max(b.x, max(b.y, b.z)), 0.0) + 1);
|
||
|
|
|
||
|
|
//2////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
||
|
|
vertexInverseTransform = mul(VALUE_GEOMETRIC_2_TRS, float4(positionAbsolute, 1)).xyz;
|
||
|
|
|
||
|
|
absSize = abs(VALUE_GEOMETRIC_2_SIZE);
|
||
|
|
b = abs(vertexInverseTransform) - (absSize + boundsEdge) - saturate(absSize) * noise;
|
||
|
|
float c2 = saturate(length(max(b, 0.0)) + min(max(b.x, max(b.y, b.z)), 0.0) + 1);
|
||
|
|
|
||
|
|
//Final
|
||
|
|
cutout = ADBlendGradientEdges(c1, c2);
|
||
|
|
|
||
|
|
#else
|
||
|
|
|
||
|
|
float3 vertexInverseTransform = mul(VALUE_GEOMETRIC_MATRIX_TRS, float4(positionAbsolute, 1)).xyz;
|
||
|
|
|
||
|
|
float3 absSize = abs(VALUE_GEOMETRIC_SIZE);
|
||
|
|
float3 b = abs(vertexInverseTransform) - (absSize + boundsEdge) - saturate(absSize) * noise;
|
||
|
|
|
||
|
|
cutout = 1 - saturate(length(max(b, 0.0)) + min(max(b.x, max(b.y, b.z)), 0.0) + 1);
|
||
|
|
#endif
|
||
|
|
|
||
|
|
#elif defined(_AD_CUTOUT_GEOMETRIC_TYPE_CAPSULE)
|
||
|
|
|
||
|
|
#if defined(_AD_CUTOUT_GEOMETRIC_COUNT_FOUR)
|
||
|
|
|
||
|
|
//1////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
||
|
|
float t1 = saturate(dot(positionAbsolute - VALUE_GEOMETRIC_POSITION, VALUE_GEOMETRIC_NORMAL) / VALUE_GEOMETRIC_HEIGHT);
|
||
|
|
float3 projection1 = VALUE_GEOMETRIC_POSITION + t1 * VALUE_GEOMETRIC_NORMAL * VALUE_GEOMETRIC_HEIGHT;
|
||
|
|
|
||
|
|
float d1 = distance(positionAbsolute, projection1);
|
||
|
|
|
||
|
|
|
||
|
|
//2////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
||
|
|
float t2 = saturate(dot(positionAbsolute - VALUE_GEOMETRIC_2_POSITION, VALUE_GEOMETRIC_2_NORMAL) / VALUE_GEOMETRIC_2_HEIGHT);
|
||
|
|
float3 projection2 = VALUE_GEOMETRIC_2_POSITION + t2 * VALUE_GEOMETRIC_2_NORMAL * VALUE_GEOMETRIC_2_HEIGHT;
|
||
|
|
|
||
|
|
float d2 = distance(positionAbsolute, projection2);
|
||
|
|
|
||
|
|
//3////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
||
|
|
float t3 = saturate(dot(positionAbsolute - VALUE_GEOMETRIC_3_POSITION, VALUE_GEOMETRIC_3_NORMAL) / VALUE_GEOMETRIC_3_HEIGHT);
|
||
|
|
float3 projection3 = VALUE_GEOMETRIC_3_POSITION + t3 * VALUE_GEOMETRIC_3_NORMAL * VALUE_GEOMETRIC_3_HEIGHT;
|
||
|
|
|
||
|
|
float d3 = distance(positionAbsolute, projection3);
|
||
|
|
|
||
|
|
//4////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
||
|
|
float t4 = saturate(dot(positionAbsolute - VALUE_GEOMETRIC_4_POSITION, VALUE_GEOMETRIC_4_NORMAL) / VALUE_GEOMETRIC_4_HEIGHT);
|
||
|
|
float3 projection4 = VALUE_GEOMETRIC_4_POSITION + t4 * VALUE_GEOMETRIC_4_NORMAL * VALUE_GEOMETRIC_4_HEIGHT;
|
||
|
|
|
||
|
|
float d4 = distance(positionAbsolute, projection4);
|
||
|
|
|
||
|
|
//Sum
|
||
|
|
float4 radius = float4(VALUE_GEOMETRIC_RADIUS, VALUE_GEOMETRIC_2_RADIUS, VALUE_GEOMETRIC_3_RADIUS, VALUE_GEOMETRIC_4_RADIUS);
|
||
|
|
float4 e = saturate(max(0, float4(d1, d2, d3, d4) - radius + lerp(1, 0, VALUE_GEOMETRIC_INVERT) - saturate(radius) * noise));
|
||
|
|
|
||
|
|
|
||
|
|
cutout = ADBlendGradientEdges(e.x, e.y, e.z, e.w);
|
||
|
|
|
||
|
|
#elif defined(_AD_CUTOUT_GEOMETRIC_COUNT_THREE)
|
||
|
|
|
||
|
|
//1////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
||
|
|
float t1 = saturate(dot(positionAbsolute - VALUE_GEOMETRIC_POSITION, VALUE_GEOMETRIC_NORMAL) / VALUE_GEOMETRIC_HEIGHT);
|
||
|
|
float3 projection1 = VALUE_GEOMETRIC_POSITION + t1 * VALUE_GEOMETRIC_NORMAL * VALUE_GEOMETRIC_HEIGHT;
|
||
|
|
|
||
|
|
float d1 = distance(positionAbsolute, projection1);
|
||
|
|
|
||
|
|
|
||
|
|
//2////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
||
|
|
float t2 = saturate(dot(positionAbsolute - VALUE_GEOMETRIC_2_POSITION, VALUE_GEOMETRIC_2_NORMAL) / VALUE_GEOMETRIC_2_HEIGHT);
|
||
|
|
float3 projection2 = VALUE_GEOMETRIC_2_POSITION + t2 * VALUE_GEOMETRIC_2_NORMAL * VALUE_GEOMETRIC_2_HEIGHT;
|
||
|
|
|
||
|
|
float d2 = distance(positionAbsolute, projection2);
|
||
|
|
|
||
|
|
//3////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
||
|
|
float t3 = saturate(dot(positionAbsolute - VALUE_GEOMETRIC_3_POSITION, VALUE_GEOMETRIC_3_NORMAL) / VALUE_GEOMETRIC_3_HEIGHT);
|
||
|
|
float3 projection3 = VALUE_GEOMETRIC_3_POSITION + t3 * VALUE_GEOMETRIC_3_NORMAL * VALUE_GEOMETRIC_3_HEIGHT;
|
||
|
|
|
||
|
|
float d3 = distance(positionAbsolute, projection3);
|
||
|
|
|
||
|
|
//Sum
|
||
|
|
float3 radius = float3(VALUE_GEOMETRIC_RADIUS, VALUE_GEOMETRIC_2_RADIUS, VALUE_GEOMETRIC_3_RADIUS);
|
||
|
|
float3 e = saturate(max(0, float3(d1, d2, d3) - radius + lerp(1, 0, VALUE_GEOMETRIC_INVERT) - saturate(radius) * noise));
|
||
|
|
|
||
|
|
|
||
|
|
cutout = ADBlendGradientEdges(e.x, e.y, e.z);
|
||
|
|
|
||
|
|
#elif defined(_AD_CUTOUT_GEOMETRIC_COUNT_TWO)
|
||
|
|
|
||
|
|
//1////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
||
|
|
float t1 = saturate(dot(positionAbsolute - VALUE_GEOMETRIC_POSITION, VALUE_GEOMETRIC_NORMAL) / VALUE_GEOMETRIC_HEIGHT);
|
||
|
|
float3 projection1 = VALUE_GEOMETRIC_POSITION + t1 * VALUE_GEOMETRIC_NORMAL * VALUE_GEOMETRIC_HEIGHT;
|
||
|
|
|
||
|
|
float d1 = distance(positionAbsolute, projection1);
|
||
|
|
|
||
|
|
|
||
|
|
//2////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
||
|
|
float t2 = saturate(dot(positionAbsolute - VALUE_GEOMETRIC_2_POSITION, VALUE_GEOMETRIC_2_NORMAL) / VALUE_GEOMETRIC_2_HEIGHT);
|
||
|
|
float3 projection2 = VALUE_GEOMETRIC_2_POSITION + t2 * VALUE_GEOMETRIC_2_NORMAL * VALUE_GEOMETRIC_2_HEIGHT;
|
||
|
|
|
||
|
|
float d2 = distance(positionAbsolute, projection2);
|
||
|
|
|
||
|
|
//Sum
|
||
|
|
float2 radius = float2(VALUE_GEOMETRIC_RADIUS, VALUE_GEOMETRIC_2_RADIUS);
|
||
|
|
float2 e = saturate(max(0, float2(d1, d2) - radius + lerp(1, 0, VALUE_GEOMETRIC_INVERT) - saturate(radius) * noise));
|
||
|
|
|
||
|
|
|
||
|
|
cutout = ADBlendGradientEdges(e.x, e.y);
|
||
|
|
|
||
|
|
#else
|
||
|
|
|
||
|
|
//float coreDist = dot(positionAbsolute - VALUE_GEOMETRIC_POSITION, VALUE_GEOMETRIC_NORMAL);
|
||
|
|
//float orthDist = length((positionAbsolute - VALUE_GEOMETRIC_POSITION) - VALUE_GEOMETRIC_NORMAL * coreDist);
|
||
|
|
//float mainC = orthDist - VALUE_GEOMETRIC_RADIUS;
|
||
|
|
|
||
|
|
//float top = dot(VALUE_GEOMETRIC_NORMAL, (positionAbsolute - VALUE_GEOMETRIC_POSITION));
|
||
|
|
//float bottom = dot(VALUE_GEOMETRIC_NORMAL, ((VALUE_GEOMETRIC_POSITION + VALUE_GEOMETRIC_NORMAL * VALUE_GEOMETRIC_HEIGHT) - positionAbsolute));
|
||
|
|
|
||
|
|
//float3 k = saturate(float3(mainC, top, bottom) + boundsEdge);
|
||
|
|
|
||
|
|
//cutout = 1 - ADBlendGradientEdges((1 - k.x), k.y, k.z);
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
float t = saturate(dot(positionAbsolute - VALUE_GEOMETRIC_POSITION, VALUE_GEOMETRIC_NORMAL) / VALUE_GEOMETRIC_HEIGHT);
|
||
|
|
float3 projection = VALUE_GEOMETRIC_POSITION + t * VALUE_GEOMETRIC_NORMAL * VALUE_GEOMETRIC_HEIGHT;
|
||
|
|
|
||
|
|
float d = distance(positionAbsolute, projection);
|
||
|
|
|
||
|
|
cutout = 1 - saturate(max(0, d - VALUE_GEOMETRIC_RADIUS + lerp(1, 0, VALUE_GEOMETRIC_INVERT) - noise * saturate(VALUE_GEOMETRIC_RADIUS)));
|
||
|
|
|
||
|
|
#endif
|
||
|
|
|
||
|
|
#elif defined(_AD_CUTOUT_GEOMETRIC_TYPE_CONE_SMOOTH)
|
||
|
|
|
||
|
|
#if defined(_AD_CUTOUT_GEOMETRIC_COUNT_FOUR)
|
||
|
|
|
||
|
|
//1////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
||
|
|
float t1 = saturate(dot(positionAbsolute - VALUE_GEOMETRIC_POSITION, VALUE_GEOMETRIC_NORMAL) / VALUE_GEOMETRIC_HEIGHT);
|
||
|
|
float3 projection1 = VALUE_GEOMETRIC_POSITION + t1 * VALUE_GEOMETRIC_NORMAL * VALUE_GEOMETRIC_HEIGHT;
|
||
|
|
|
||
|
|
float d1 = distance(positionAbsolute, projection1);
|
||
|
|
|
||
|
|
|
||
|
|
//2////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
||
|
|
float t2 = saturate(dot(positionAbsolute - VALUE_GEOMETRIC_2_POSITION, VALUE_GEOMETRIC_2_NORMAL) / VALUE_GEOMETRIC_2_HEIGHT);
|
||
|
|
float3 projection2 = VALUE_GEOMETRIC_2_POSITION + t2 * VALUE_GEOMETRIC_2_NORMAL * VALUE_GEOMETRIC_2_HEIGHT;
|
||
|
|
|
||
|
|
float d2 = distance(positionAbsolute, projection2);
|
||
|
|
|
||
|
|
//3////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
||
|
|
float t3 = saturate(dot(positionAbsolute - VALUE_GEOMETRIC_3_POSITION, VALUE_GEOMETRIC_3_NORMAL) / VALUE_GEOMETRIC_3_HEIGHT);
|
||
|
|
float3 projection3 = VALUE_GEOMETRIC_3_POSITION + t3 * VALUE_GEOMETRIC_3_NORMAL * VALUE_GEOMETRIC_3_HEIGHT;
|
||
|
|
|
||
|
|
float d3 = distance(positionAbsolute, projection3);
|
||
|
|
|
||
|
|
//4////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
||
|
|
float t4 = saturate(dot(positionAbsolute - VALUE_GEOMETRIC_4_POSITION, VALUE_GEOMETRIC_4_NORMAL) / VALUE_GEOMETRIC_4_HEIGHT);
|
||
|
|
float3 projection4 = VALUE_GEOMETRIC_4_POSITION + t4 * VALUE_GEOMETRIC_4_NORMAL * VALUE_GEOMETRIC_4_HEIGHT;
|
||
|
|
|
||
|
|
float d4 = distance(positionAbsolute, projection4);
|
||
|
|
|
||
|
|
//Sum
|
||
|
|
float4 radius = lerp(float4(0, 0, 0, 0), float4(VALUE_GEOMETRIC_RADIUS, VALUE_GEOMETRIC_2_RADIUS, VALUE_GEOMETRIC_3_RADIUS, VALUE_GEOMETRIC_4_RADIUS), float4(t1, t2, t3, t4));
|
||
|
|
float4 e = saturate(max(float4(0, 0, 0, 0), float4(d1, d2, d3, d4) - radius + lerp(1, 0, VALUE_GEOMETRIC_INVERT).xxxx - saturate(radius) * noise));
|
||
|
|
|
||
|
|
|
||
|
|
cutout = ADBlendGradientEdges(e.x, e.y, e.z, e.w);
|
||
|
|
|
||
|
|
#elif defined(_AD_CUTOUT_GEOMETRIC_COUNT_THREE)
|
||
|
|
|
||
|
|
//1////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
||
|
|
float t1 = saturate(dot(positionAbsolute - VALUE_GEOMETRIC_POSITION, VALUE_GEOMETRIC_NORMAL) / VALUE_GEOMETRIC_HEIGHT);
|
||
|
|
float3 projection1 = VALUE_GEOMETRIC_POSITION + t1 * VALUE_GEOMETRIC_NORMAL * VALUE_GEOMETRIC_HEIGHT;
|
||
|
|
|
||
|
|
float d1 = distance(positionAbsolute, projection1);
|
||
|
|
|
||
|
|
|
||
|
|
//2////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
||
|
|
float t2 = saturate(dot(positionAbsolute - VALUE_GEOMETRIC_2_POSITION, VALUE_GEOMETRIC_2_NORMAL) / VALUE_GEOMETRIC_2_HEIGHT);
|
||
|
|
float3 projection2 = VALUE_GEOMETRIC_2_POSITION + t2 * VALUE_GEOMETRIC_2_NORMAL * VALUE_GEOMETRIC_2_HEIGHT;
|
||
|
|
|
||
|
|
float d2 = distance(positionAbsolute, projection2);
|
||
|
|
|
||
|
|
//3////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
||
|
|
float t3 = saturate(dot(positionAbsolute - VALUE_GEOMETRIC_3_POSITION, VALUE_GEOMETRIC_3_NORMAL) / VALUE_GEOMETRIC_3_HEIGHT);
|
||
|
|
float3 projection3 = VALUE_GEOMETRIC_3_POSITION + t3 * VALUE_GEOMETRIC_3_NORMAL * VALUE_GEOMETRIC_3_HEIGHT;
|
||
|
|
|
||
|
|
float d3 = distance(positionAbsolute, projection3);
|
||
|
|
|
||
|
|
//Sum
|
||
|
|
float3 radius = lerp(float3(0, 0, 0), float3(VALUE_GEOMETRIC_RADIUS, VALUE_GEOMETRIC_2_RADIUS, VALUE_GEOMETRIC_3_RADIUS), float3(t1, t2, t3));
|
||
|
|
float3 e = saturate(max(float3(0, 0, 0), float3(d1, d2, d3) - radius + lerp(1, 0, VALUE_GEOMETRIC_INVERT).xxx - saturate(radius) * noise));
|
||
|
|
|
||
|
|
|
||
|
|
cutout = ADBlendGradientEdges(e.x, e.y, e.z);
|
||
|
|
|
||
|
|
#elif defined(_AD_CUTOUT_GEOMETRIC_COUNT_TWO)
|
||
|
|
|
||
|
|
//1////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
||
|
|
float t1 = saturate(dot(positionAbsolute - VALUE_GEOMETRIC_POSITION, VALUE_GEOMETRIC_NORMAL) / VALUE_GEOMETRIC_HEIGHT);
|
||
|
|
float3 projection1 = VALUE_GEOMETRIC_POSITION + t1 * VALUE_GEOMETRIC_NORMAL * VALUE_GEOMETRIC_HEIGHT;
|
||
|
|
|
||
|
|
float d1 = distance(positionAbsolute, projection1);
|
||
|
|
|
||
|
|
|
||
|
|
//2////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
||
|
|
float t2 = saturate(dot(positionAbsolute - VALUE_GEOMETRIC_2_POSITION, VALUE_GEOMETRIC_2_NORMAL) / VALUE_GEOMETRIC_2_HEIGHT);
|
||
|
|
float3 projection2 = VALUE_GEOMETRIC_2_POSITION + t2 * VALUE_GEOMETRIC_2_NORMAL * VALUE_GEOMETRIC_2_HEIGHT;
|
||
|
|
|
||
|
|
float d2 = distance(positionAbsolute, projection2);
|
||
|
|
|
||
|
|
//Sum
|
||
|
|
float2 radius = lerp(float2(0, 0), float2(VALUE_GEOMETRIC_RADIUS, VALUE_GEOMETRIC_2_RADIUS), float2(t1, t2));
|
||
|
|
float2 e = saturate(max(float2(0, 0), float2(d1, d2) - radius + lerp(1, 0, VALUE_GEOMETRIC_INVERT).xx - saturate(radius) * noise));
|
||
|
|
|
||
|
|
|
||
|
|
cutout = ADBlendGradientEdges(e.x, e.y);
|
||
|
|
|
||
|
|
#else
|
||
|
|
|
||
|
|
float t = saturate(dot(positionAbsolute - VALUE_GEOMETRIC_POSITION, VALUE_GEOMETRIC_NORMAL) / VALUE_GEOMETRIC_HEIGHT);
|
||
|
|
float3 projectPosition = VALUE_GEOMETRIC_POSITION + t * VALUE_GEOMETRIC_NORMAL * VALUE_GEOMETRIC_HEIGHT;
|
||
|
|
|
||
|
|
float d = distance(positionAbsolute, projectPosition);
|
||
|
|
|
||
|
|
float radius = lerp(0, VALUE_GEOMETRIC_RADIUS, t);
|
||
|
|
cutout = 1 - saturate(max(0, d - radius + lerp(1, 0, VALUE_GEOMETRIC_INVERT) - saturate(radius) * noise));
|
||
|
|
|
||
|
|
#endif
|
||
|
|
|
||
|
|
#endif
|
||
|
|
|
||
|
|
|
||
|
|
return lerp(cutout, 1 - cutout, VALUE_GEOMETRIC_INVERT);
|
||
|
|
}
|
||
|
|
#endif
|
||
|
|
|
||
|
|
|
||
|
|
#ifdef _AD_CUTOUT_STANDARD_SOURCE_MAPS_MAPPING_TYPE_TRIPLANAR
|
||
|
|
|
||
|
|
#if defined(_AD_CUTOUT_STANDARD_SOURCE_CUSTOM_MAP) || defined(_AD_CUTOUT_STANDARD_SOURCE_TWO_CUSTOM_MAPS) || defined(_AD_CUTOUT_STANDARD_SOURCE_THREE_CUSTOM_MAPS)
|
||
|
|
inline float4 ReadTriplanarTextureMap1(float3 coords, float3 blend, float intensity)
|
||
|
|
{
|
||
|
|
coords = coords * VALUE_CUTOUT_STANDARD_MAP1_TILING + VALUE_CUTOUT_STANDARD_MAP1_OFFSET + VALUE_CUTOUT_STANDARD_MAP1_SCROLL * _Time.x;
|
||
|
|
|
||
|
|
float4 cx = READ_TEXTURE_2D(VALUE_CUTOUT_STANDARD_MAP1, VALUE_CUTOUT_STANDARD_MAP1_SAMPLER, coords.yz, intensity);
|
||
|
|
float4 cy = READ_TEXTURE_2D(VALUE_CUTOUT_STANDARD_MAP1, VALUE_CUTOUT_STANDARD_MAP1_SAMPLER, coords.xz, intensity);
|
||
|
|
float4 cz = READ_TEXTURE_2D(VALUE_CUTOUT_STANDARD_MAP1, VALUE_CUTOUT_STANDARD_MAP1_SAMPLER, coords.xy, intensity);
|
||
|
|
|
||
|
|
cx.a = cx[VALUE_CUTOUT_STANDARD_MAP1_CHANNEL];
|
||
|
|
cy.a = cy[VALUE_CUTOUT_STANDARD_MAP1_CHANNEL];
|
||
|
|
cz.a = cz[VALUE_CUTOUT_STANDARD_MAP1_CHANNEL];
|
||
|
|
|
||
|
|
return (cx * blend.x + cy * blend.y + cz * blend.z);
|
||
|
|
}
|
||
|
|
#endif
|
||
|
|
|
||
|
|
#if defined(_AD_CUTOUT_STANDARD_SOURCE_TWO_CUSTOM_MAPS) || defined(_AD_CUTOUT_STANDARD_SOURCE_THREE_CUSTOM_MAPS)
|
||
|
|
inline float4 ReadTriplanarTextureMap2(float3 coords, float3 blend, float intensity)
|
||
|
|
{
|
||
|
|
coords = coords * VALUE_CUTOUT_STANDARD_MAP2_TILING + VALUE_CUTOUT_STANDARD_MAP2_OFFSET + VALUE_CUTOUT_STANDARD_MAP2_SCROLL * _Time.x;
|
||
|
|
|
||
|
|
float4 cx = READ_TEXTURE_2D(VALUE_CUTOUT_STANDARD_MAP2, VALUE_CUTOUT_STANDARD_MAP2_SAMPLER, coords.yz, intensity);
|
||
|
|
float4 cy = READ_TEXTURE_2D(VALUE_CUTOUT_STANDARD_MAP2, VALUE_CUTOUT_STANDARD_MAP2_SAMPLER, coords.xz, intensity);
|
||
|
|
float4 cz = READ_TEXTURE_2D(VALUE_CUTOUT_STANDARD_MAP2, VALUE_CUTOUT_STANDARD_MAP2_SAMPLER, coords.xy, intensity);
|
||
|
|
|
||
|
|
cx.a = cx[VALUE_CUTOUT_STANDARD_MAP2_CHANNEL];
|
||
|
|
cy.a = cy[VALUE_CUTOUT_STANDARD_MAP2_CHANNEL];
|
||
|
|
cz.a = cz[VALUE_CUTOUT_STANDARD_MAP2_CHANNEL];
|
||
|
|
|
||
|
|
return (cx * blend.x + cy * blend.y + cz * blend.z);
|
||
|
|
}
|
||
|
|
#endif
|
||
|
|
|
||
|
|
#ifdef _AD_CUTOUT_STANDARD_SOURCE_THREE_CUSTOM_MAPS
|
||
|
|
inline float4 ReadTriplanarTextureMap3(float3 coords, float3 blend, float intensity)
|
||
|
|
{
|
||
|
|
coords = coords * VALUE_CUTOUT_STANDARD_MAP3_TILING + VALUE_CUTOUT_STANDARD_MAP3_OFFSET + VALUE_CUTOUT_STANDARD_MAP3_SCROLL * _Time.x;
|
||
|
|
|
||
|
|
float4 cx = READ_TEXTURE_2D(VALUE_CUTOUT_STANDARD_MAP3, VALUE_CUTOUT_STANDARD_MAP3_SAMPLER, coords.yz, intensity);
|
||
|
|
float4 cy = READ_TEXTURE_2D(VALUE_CUTOUT_STANDARD_MAP3, VALUE_CUTOUT_STANDARD_MAP3_SAMPLER, coords.xz, intensity);
|
||
|
|
float4 cz = READ_TEXTURE_2D(VALUE_CUTOUT_STANDARD_MAP3, VALUE_CUTOUT_STANDARD_MAP3_SAMPLER, coords.xy, intensity);
|
||
|
|
|
||
|
|
cx.a = cx[VALUE_CUTOUT_STANDARD_MAP3_CHANNEL];
|
||
|
|
cy.a = cy[VALUE_CUTOUT_STANDARD_MAP3_CHANNEL];
|
||
|
|
cz.a = cz[VALUE_CUTOUT_STANDARD_MAP3_CHANNEL];
|
||
|
|
|
||
|
|
return (cx * blend.x + cy * blend.y + cz * blend.z);
|
||
|
|
}
|
||
|
|
#endif
|
||
|
|
|
||
|
|
|
||
|
|
inline float4 ADReadCutoutSource(float3 positionOS, float3 positionAbsolute, float3 normalOS, float3 normalWS)
|
||
|
|
{
|
||
|
|
float3 vertexPos = lerp(positionAbsolute, positionOS, VALUE_CUTOUT_STANDARD_MAPS_TRIPLANAR_MAPPING_SPACE);
|
||
|
|
float3 vertexNorm = lerp(normalWS, normalOS, VALUE_CUTOUT_STANDARD_MAPS_TRIPLANAR_MAPPING_SPACE);
|
||
|
|
|
||
|
|
float3 blend = abs(vertexNorm);
|
||
|
|
blend /= dot(blend, 1.0);
|
||
|
|
|
||
|
|
|
||
|
|
float4 alphaSource = 1;
|
||
|
|
#if defined(_AD_CUTOUT_STANDARD_SOURCE_CUSTOM_MAP)
|
||
|
|
|
||
|
|
alphaSource = ReadTriplanarTextureMap1(vertexPos, blend, 1);
|
||
|
|
|
||
|
|
alphaSource.a = lerp(alphaSource.a, 1 - alphaSource.a, VALUE_CUTOUT_STANDARD_MAP1_INVERT);
|
||
|
|
|
||
|
|
#elif defined(_AD_CUTOUT_STANDARD_SOURCE_TWO_CUSTOM_MAPS)
|
||
|
|
|
||
|
|
float4 t1 = ReadTriplanarTextureMap1(vertexPos, blend, VALUE_CUTOUT_STANDARD_MAP1_INTENSITY);
|
||
|
|
float4 t2 = ReadTriplanarTextureMap2(vertexPos, blend, VALUE_CUTOUT_STANDARD_MAP2_INTENSITY);
|
||
|
|
|
||
|
|
t1.a = lerp(t1.a, 1 - t1.a, VALUE_CUTOUT_STANDARD_MAP1_INVERT);
|
||
|
|
t2.a = lerp(t2.a, 1 - t2.a, VALUE_CUTOUT_STANDARD_MAP2_INVERT);
|
||
|
|
|
||
|
|
alphaSource = lerp((t1 * t2), (t1 + t2) * 0.5, VALUE_CUTOUT_STANDARD_MAPS_BLEND_TYPE);
|
||
|
|
|
||
|
|
#elif defined(_AD_CUTOUT_STANDARD_SOURCE_THREE_CUSTOM_MAPS)
|
||
|
|
|
||
|
|
float4 t1 = ReadTriplanarTextureMap1(vertexPos, blend, VALUE_CUTOUT_STANDARD_MAP1_INTENSITY);
|
||
|
|
float4 t2 = ReadTriplanarTextureMap2(vertexPos, blend, VALUE_CUTOUT_STANDARD_MAP2_INTENSITY);
|
||
|
|
float4 t3 = ReadTriplanarTextureMap3(vertexPos, blend, VALUE_CUTOUT_STANDARD_MAP3_INTENSITY);
|
||
|
|
|
||
|
|
t1.a = lerp(t1.a, 1 - t1.a, VALUE_CUTOUT_STANDARD_MAP1_INVERT);
|
||
|
|
t2.a = lerp(t2.a, 1 - t2.a, VALUE_CUTOUT_STANDARD_MAP2_INVERT);
|
||
|
|
t3.a = lerp(t3.a, 1 - t3.a, VALUE_CUTOUT_STANDARD_MAP3_INVERT);
|
||
|
|
|
||
|
|
|
||
|
|
alphaSource = lerp((t1 * t2 * t3), (t1 + t2 + t3) / 3.0, VALUE_CUTOUT_STANDARD_MAPS_BLEND_TYPE);
|
||
|
|
|
||
|
|
#else
|
||
|
|
|
||
|
|
//No triplanar mapping for Basemap
|
||
|
|
|
||
|
|
#endif
|
||
|
|
|
||
|
|
|
||
|
|
alphaSource = saturate(alphaSource);
|
||
|
|
|
||
|
|
|
||
|
|
#if defined(ADVANCED_DISSOLVE_CUTOUT_GEOMETRIC_ENABLED)
|
||
|
|
|
||
|
|
#if defined(_AD_CUTOUT_STANDARD_SOURCE_NONE)
|
||
|
|
alphaSource.b = ADReadGeometricValue(positionOS, positionAbsolute, noise);
|
||
|
|
#else
|
||
|
|
float noise = ((alphaSource.a - 0.5) * 2) * VALUE_GEOMETRIC_NOISE;
|
||
|
|
|
||
|
|
alphaSource.b = ADReadGeometricValue(positionOS, positionAbsolute, noise * (1 - VALUE_CUTOUT_STANDARD_CLIP));
|
||
|
|
#endif
|
||
|
|
|
||
|
|
#endif
|
||
|
|
|
||
|
|
|
||
|
|
return alphaSource;
|
||
|
|
}
|
||
|
|
|
||
|
|
#else
|
||
|
|
|
||
|
|
inline float4 ADReadCutoutSource(float4 baseAlbedo, float4 dissolveUV, float3 positionOS, float3 positionAbsolute, float customCutoutAlphaSource)
|
||
|
|
{
|
||
|
|
float4 alphaSource = float4(0, 0, 0, 1);
|
||
|
|
|
||
|
|
|
||
|
|
#ifdef _AD_CUTOUT_STANDARD_SOURCE_MAPS_MAPPING_TYPE_SCREEN_SPACE
|
||
|
|
float2 screenUV = dissolveUV.xy / dissolveUV.w;
|
||
|
|
screenUV.x *= _ScreenParams.x / _ScreenParams.y;
|
||
|
|
|
||
|
|
screenUV *= lerp(1, distance(ADGetCameraPositionWS(), ADTransformObjectToWorld(float3(0, 0, 0))) * 0.1, VALUE_CUTOUT_STANDARD_MAPS_SCREEN_SPACE_UV_SCALE);
|
||
|
|
#endif
|
||
|
|
|
||
|
|
|
||
|
|
#if defined(_AD_CUTOUT_STANDARD_SOURCE_CUSTOM_MAP)
|
||
|
|
|
||
|
|
#ifdef _AD_CUTOUT_STANDARD_SOURCE_MAPS_MAPPING_TYPE_SCREEN_SPACE
|
||
|
|
screenUV = screenUV * VALUE_CUTOUT_STANDARD_MAP1_TILING.xy + VALUE_CUTOUT_STANDARD_MAP1_OFFSET.xy + VALUE_CUTOUT_STANDARD_MAP1_SCROLL.xy * _Time.x;
|
||
|
|
|
||
|
|
alphaSource = READ_TEXTURE_2D(VALUE_CUTOUT_STANDARD_MAP1, VALUE_CUTOUT_STANDARD_MAP1_SAMPLER, screenUV, 1);
|
||
|
|
#else
|
||
|
|
float2 uv1 = dissolveUV.xy * VALUE_CUTOUT_STANDARD_MAP1_TILING.xy + VALUE_CUTOUT_STANDARD_MAP1_OFFSET.xy + VALUE_CUTOUT_STANDARD_MAP1_SCROLL.xy * _Time.x;
|
||
|
|
|
||
|
|
alphaSource = READ_TEXTURE_2D(VALUE_CUTOUT_STANDARD_MAP1, VALUE_CUTOUT_STANDARD_MAP1_SAMPLER, uv1, 1);
|
||
|
|
#endif
|
||
|
|
|
||
|
|
alphaSource.a = alphaSource[VALUE_CUTOUT_STANDARD_MAP1_CHANNEL];
|
||
|
|
alphaSource.a = lerp(alphaSource.a, 1 - alphaSource.a, VALUE_CUTOUT_STANDARD_MAP1_INVERT);
|
||
|
|
|
||
|
|
#elif defined(_AD_CUTOUT_STANDARD_SOURCE_TWO_CUSTOM_MAPS)
|
||
|
|
|
||
|
|
#ifdef _AD_CUTOUT_STANDARD_SOURCE_MAPS_MAPPING_TYPE_SCREEN_SPACE
|
||
|
|
float2 uv1 = screenUV * VALUE_CUTOUT_STANDARD_MAP1_TILING.xy + VALUE_CUTOUT_STANDARD_MAP1_OFFSET.xy + VALUE_CUTOUT_STANDARD_MAP1_SCROLL.xy * _Time.x;
|
||
|
|
float2 uv2 = screenUV * VALUE_CUTOUT_STANDARD_MAP2_TILING.xy + VALUE_CUTOUT_STANDARD_MAP2_OFFSET.xy + VALUE_CUTOUT_STANDARD_MAP2_SCROLL.xy * _Time.x;
|
||
|
|
|
||
|
|
float4 t1 = READ_TEXTURE_2D(VALUE_CUTOUT_STANDARD_MAP1, VALUE_CUTOUT_STANDARD_MAP1_SAMPLER, uv1, VALUE_CUTOUT_STANDARD_MAP1_INTENSITY);
|
||
|
|
float4 t2 = READ_TEXTURE_2D(VALUE_CUTOUT_STANDARD_MAP2, VALUE_CUTOUT_STANDARD_MAP2_SAMPLER, uv2, VALUE_CUTOUT_STANDARD_MAP2_INTENSITY);
|
||
|
|
#else
|
||
|
|
float2 uv1 = dissolveUV.xy * VALUE_CUTOUT_STANDARD_MAP1_TILING.xy + VALUE_CUTOUT_STANDARD_MAP1_OFFSET.xy + VALUE_CUTOUT_STANDARD_MAP1_SCROLL.xy * _Time.x;
|
||
|
|
float2 uv2 = dissolveUV.xy * VALUE_CUTOUT_STANDARD_MAP2_TILING.xy + VALUE_CUTOUT_STANDARD_MAP2_OFFSET.xy + VALUE_CUTOUT_STANDARD_MAP2_SCROLL.xy * _Time.x;
|
||
|
|
|
||
|
|
float4 t1 = READ_TEXTURE_2D(VALUE_CUTOUT_STANDARD_MAP1, VALUE_CUTOUT_STANDARD_MAP1_SAMPLER, uv1, VALUE_CUTOUT_STANDARD_MAP1_INTENSITY);
|
||
|
|
float4 t2 = READ_TEXTURE_2D(VALUE_CUTOUT_STANDARD_MAP2, VALUE_CUTOUT_STANDARD_MAP2_SAMPLER, uv2, VALUE_CUTOUT_STANDARD_MAP2_INTENSITY);
|
||
|
|
#endif
|
||
|
|
|
||
|
|
t1.a = t1[VALUE_CUTOUT_STANDARD_MAP1_CHANNEL];
|
||
|
|
t2.a = t2[VALUE_CUTOUT_STANDARD_MAP2_CHANNEL];
|
||
|
|
|
||
|
|
t1.a = lerp(t1.a, 1 - t1.a, VALUE_CUTOUT_STANDARD_MAP1_INVERT);
|
||
|
|
t2.a = lerp(t2.a, 1 - t2.a, VALUE_CUTOUT_STANDARD_MAP2_INVERT);
|
||
|
|
|
||
|
|
alphaSource = lerp((t1 * t2), (t1 + t2) * 0.5, VALUE_CUTOUT_STANDARD_MAPS_BLEND_TYPE);
|
||
|
|
|
||
|
|
#elif defined(_AD_CUTOUT_STANDARD_SOURCE_THREE_CUSTOM_MAPS)
|
||
|
|
|
||
|
|
#ifdef _AD_CUTOUT_STANDARD_SOURCE_MAPS_MAPPING_TYPE_SCREEN_SPACE
|
||
|
|
float2 uv1 = screenUV * VALUE_CUTOUT_STANDARD_MAP1_TILING.xy + VALUE_CUTOUT_STANDARD_MAP1_OFFSET.xy + VALUE_CUTOUT_STANDARD_MAP1_SCROLL.xy * _Time.x;
|
||
|
|
float2 uv2 = screenUV * VALUE_CUTOUT_STANDARD_MAP2_TILING.xy + VALUE_CUTOUT_STANDARD_MAP2_OFFSET.xy + VALUE_CUTOUT_STANDARD_MAP2_SCROLL.xy * _Time.x;
|
||
|
|
float2 uv3 = screenUV * VALUE_CUTOUT_STANDARD_MAP3_TILING.xy + VALUE_CUTOUT_STANDARD_MAP3_OFFSET.xy + VALUE_CUTOUT_STANDARD_MAP3_SCROLL.xy * _Time.x;
|
||
|
|
#else
|
||
|
|
float2 uv1 = dissolveUV.xy * VALUE_CUTOUT_STANDARD_MAP1_TILING.xy + VALUE_CUTOUT_STANDARD_MAP1_OFFSET.xy + VALUE_CUTOUT_STANDARD_MAP1_SCROLL.xy * _Time.x;
|
||
|
|
float2 uv2 = dissolveUV.xy * VALUE_CUTOUT_STANDARD_MAP2_TILING.xy + VALUE_CUTOUT_STANDARD_MAP2_OFFSET.xy + VALUE_CUTOUT_STANDARD_MAP2_SCROLL.xy * _Time.x;
|
||
|
|
float2 uv3 = dissolveUV.xy * VALUE_CUTOUT_STANDARD_MAP3_TILING.xy + VALUE_CUTOUT_STANDARD_MAP3_OFFSET.xy + VALUE_CUTOUT_STANDARD_MAP3_SCROLL.xy * _Time.x;
|
||
|
|
#endif
|
||
|
|
|
||
|
|
float4 t1 = READ_TEXTURE_2D(VALUE_CUTOUT_STANDARD_MAP1, VALUE_CUTOUT_STANDARD_MAP1_SAMPLER, uv1, VALUE_CUTOUT_STANDARD_MAP1_INTENSITY);
|
||
|
|
float4 t2 = READ_TEXTURE_2D(VALUE_CUTOUT_STANDARD_MAP2, VALUE_CUTOUT_STANDARD_MAP2_SAMPLER, uv2, VALUE_CUTOUT_STANDARD_MAP2_INTENSITY);
|
||
|
|
float4 t3 = READ_TEXTURE_2D(VALUE_CUTOUT_STANDARD_MAP3, VALUE_CUTOUT_STANDARD_MAP3_SAMPLER, uv3, VALUE_CUTOUT_STANDARD_MAP3_INTENSITY);
|
||
|
|
|
||
|
|
t1.a = t1[VALUE_CUTOUT_STANDARD_MAP1_CHANNEL];
|
||
|
|
t2.a = t2[VALUE_CUTOUT_STANDARD_MAP2_CHANNEL];
|
||
|
|
t3.a = t3[VALUE_CUTOUT_STANDARD_MAP3_CHANNEL];
|
||
|
|
|
||
|
|
t1.a = lerp(t1.a, 1 - t1.a, VALUE_CUTOUT_STANDARD_MAP1_INVERT);
|
||
|
|
t2.a = lerp(t2.a, 1 - t2.a, VALUE_CUTOUT_STANDARD_MAP2_INVERT);
|
||
|
|
t3.a = lerp(t3.a, 1 - t3.a, VALUE_CUTOUT_STANDARD_MAP3_INVERT);
|
||
|
|
|
||
|
|
alphaSource = lerp((t1 * t2 * t3), (t1 + t2 + t3) / 3.0, VALUE_CUTOUT_STANDARD_MAPS_BLEND_TYPE);
|
||
|
|
|
||
|
|
#elif defined(_AD_CUTOUT_STANDARD_SOURCE_USER_DEFINED)
|
||
|
|
|
||
|
|
alphaSource = saturate(customCutoutAlphaSource).xxxx;
|
||
|
|
|
||
|
|
alphaSource.a = lerp(alphaSource.a, 1 - alphaSource.a, VALUE_CUTOUT_STANDARD_BASE_INVERT);
|
||
|
|
|
||
|
|
#elif defined(_AD_CUTOUT_STANDARD_SOURCE_BASE_ALPHA)
|
||
|
|
|
||
|
|
alphaSource = baseAlbedo;
|
||
|
|
|
||
|
|
alphaSource.a = lerp(alphaSource.a, 1 - alphaSource.a, VALUE_CUTOUT_STANDARD_BASE_INVERT);
|
||
|
|
|
||
|
|
#endif
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
#if defined(ADVANCED_DISSOLVE_CUTOUT_GEOMETRIC_ENABLED)
|
||
|
|
|
||
|
|
#if defined(_AD_CUTOUT_STANDARD_SOURCE_NONE)
|
||
|
|
float geometric = ADReadGeometricValue(positionOS, positionAbsolute, 0);
|
||
|
|
#else
|
||
|
|
float noise = ((alphaSource.a - 0.5) * 2) * VALUE_GEOMETRIC_NOISE;
|
||
|
|
|
||
|
|
float geometric = ADReadGeometricValue(positionOS, positionAbsolute, noise * (1 - VALUE_CUTOUT_STANDARD_CLIP));
|
||
|
|
#endif
|
||
|
|
|
||
|
|
|
||
|
|
#if defined(_AD_CUTOUT_STANDARD_SOURCE_NONE)
|
||
|
|
alphaSource.a = geometric > 0 ? saturate(geometric) : 0;
|
||
|
|
#endif
|
||
|
|
|
||
|
|
|
||
|
|
alphaSource.b = geometric;
|
||
|
|
|
||
|
|
#endif
|
||
|
|
|
||
|
|
return alphaSource;
|
||
|
|
}
|
||
|
|
|
||
|
|
#endif
|
||
|
|
|
||
|
|
|
||
|
|
inline void AdvancedDissolveClip(float4 cutoutSource)
|
||
|
|
{
|
||
|
|
#if defined(_AD_CUTOUT_STANDARD_SOURCE_NONE)
|
||
|
|
|
||
|
|
#if defined(ADVANCED_DISSOLVE_CUTOUT_GEOMETRIC_ENABLED)
|
||
|
|
clip(cutoutSource.a > 0 ? 1 : -1);
|
||
|
|
#else
|
||
|
|
//Noting to clip from
|
||
|
|
#endif
|
||
|
|
|
||
|
|
#else
|
||
|
|
|
||
|
|
#if defined(ADVANCED_DISSOLVE_CUTOUT_GEOMETRIC_ENABLED)
|
||
|
|
|
||
|
|
float cutoutEdge = (cutoutSource.a - VALUE_CUTOUT_STANDARD_CLIP * CUTOUT_CLIP_COEF);
|
||
|
|
float geometricEdge = cutoutSource.b > 0 ? 0 : CUTOUT_CLIP_COEF;
|
||
|
|
|
||
|
|
clip(cutoutEdge - geometricEdge);
|
||
|
|
|
||
|
|
#else
|
||
|
|
|
||
|
|
clip(cutoutSource.a - VALUE_CUTOUT_STANDARD_CLIP * CUTOUT_CLIP_COEF);
|
||
|
|
|
||
|
|
#endif
|
||
|
|
|
||
|
|
#endif
|
||
|
|
}
|
||
|
|
|
||
|
|
void AdvancedDissolveCalculateAlphaAndClip(float4 cutoutSource, inout float alpha, inout float alphaClip)
|
||
|
|
{
|
||
|
|
#if defined(_AD_CUTOUT_STANDARD_SOURCE_NONE)
|
||
|
|
|
||
|
|
#if defined(ADVANCED_DISSOLVE_CUTOUT_GEOMETRIC_ENABLED)
|
||
|
|
|
||
|
|
float blend = cutoutSource.a > 0 ? 0 : 1;
|
||
|
|
|
||
|
|
alpha = lerp(alpha, 0, blend);
|
||
|
|
alphaClip = lerp(alphaClip, 1, blend);
|
||
|
|
|
||
|
|
#else
|
||
|
|
//Noting to clip from
|
||
|
|
#endif
|
||
|
|
|
||
|
|
#else
|
||
|
|
|
||
|
|
#if defined(ADVANCED_DISSOLVE_CUTOUT_GEOMETRIC_ENABLED)
|
||
|
|
|
||
|
|
float standardBlend = cutoutSource.a - VALUE_CUTOUT_STANDARD_CLIP * CUTOUT_CLIP_COEF;
|
||
|
|
float geometricBlend = cutoutSource.b > 0 ? 0 : CUTOUT_CLIP_COEF;
|
||
|
|
|
||
|
|
float blend = (standardBlend - geometricBlend) < 0 ? 1 : 0;
|
||
|
|
float bledLerp = max(standardBlend, geometricBlend);
|
||
|
|
|
||
|
|
alpha = lerp(alpha, lerp(cutoutSource.a, 0, bledLerp), blend);
|
||
|
|
alphaClip = lerp(alphaClip, lerp(VALUE_CUTOUT_STANDARD_CLIP * CUTOUT_CLIP_COEF, 1, bledLerp), blend);
|
||
|
|
|
||
|
|
#else
|
||
|
|
|
||
|
|
float blend = (cutoutSource.a - VALUE_CUTOUT_STANDARD_CLIP * CUTOUT_CLIP_COEF) < 0 ? 1 : 0;
|
||
|
|
|
||
|
|
alpha = lerp(alpha, cutoutSource.a, blend);
|
||
|
|
alphaClip = lerp(alphaClip, VALUE_CUTOUT_STANDARD_CLIP * CUTOUT_CLIP_COEF, blend);
|
||
|
|
|
||
|
|
#endif
|
||
|
|
|
||
|
|
#endif
|
||
|
|
}
|
||
|
|
|
||
|
|
//cutoutSource.rg - uv distortion
|
||
|
|
//cutoutSource.b - geometric
|
||
|
|
//cutoutSource.a - texture
|
||
|
|
|
||
|
|
#if defined(ADVANCED_DISSOLVE_SHADER_GRAPH)
|
||
|
|
float AdvancedDissolveAlbedoEmission(float4 cutoutSource, float4 baseAlbedo, float4 customEdgeColor, inout float3 albedo, inout float3 emission, inout float2 uv)
|
||
|
|
#else
|
||
|
|
float AdvancedDissolveAlbedoEmission(float4 cutoutSource, float4 baseAlbedo, inout float3 albedo, inout float3 emission, inout float2 uv)
|
||
|
|
#endif
|
||
|
|
{
|
||
|
|
float retValue = 0;
|
||
|
|
|
||
|
|
#if defined(_AD_EDGE_BASE_SOURCE_CUTOUT_STANDARD) || defined(_AD_EDGE_BASE_SOURCE_CUTOUT_GEOMETRIC) || defined(_AD_EDGE_BASE_SOURCE_ALL)
|
||
|
|
|
||
|
|
float dissolveValue = 0;
|
||
|
|
float dissolveEdgeWidth = 0;
|
||
|
|
|
||
|
|
|
||
|
|
#if defined(_AD_CUTOUT_STANDARD_SOURCE_NONE)
|
||
|
|
|
||
|
|
#if defined(ADVANCED_DISSOLVE_CUTOUT_GEOMETRIC_ENABLED)
|
||
|
|
|
||
|
|
dissolveValue = cutoutSource.a;
|
||
|
|
dissolveEdgeWidth = VALUE_EDGE_BASE_WIDTH_GEOMETRIC;
|
||
|
|
|
||
|
|
#if defined(_AD_CUTOUT_GEOMETRIC_TYPE_XYZ)
|
||
|
|
dissolveEdgeWidth *= lerp(1, saturate(VALUE_GEOMETRIC_XYZ_ROLLOUT * 5), VALUE_GEOMETRIC_XYZ_STYLE);
|
||
|
|
#endif
|
||
|
|
|
||
|
|
#endif
|
||
|
|
|
||
|
|
#else
|
||
|
|
|
||
|
|
#if defined(ADVANCED_DISSOLVE_CUTOUT_GEOMETRIC_ENABLED)
|
||
|
|
|
||
|
|
#if defined (_AD_EDGE_BASE_SOURCE_CUTOUT_STANDARD)
|
||
|
|
|
||
|
|
dissolveValue = cutoutSource.a - VALUE_CUTOUT_STANDARD_CLIP;
|
||
|
|
dissolveEdgeWidth = VALUE_EDGE_BASE_WIDTH_STANDARD * (VALUE_CUTOUT_STANDARD_CLIP < 0.1 ? (VALUE_CUTOUT_STANDARD_CLIP * 10) : 1);
|
||
|
|
|
||
|
|
#elif defined(_AD_EDGE_BASE_SOURCE_CUTOUT_GEOMETRIC)
|
||
|
|
|
||
|
|
dissolveValue = cutoutSource.b;
|
||
|
|
dissolveEdgeWidth = VALUE_EDGE_BASE_WIDTH_GEOMETRIC;
|
||
|
|
|
||
|
|
#if defined(_AD_CUTOUT_GEOMETRIC_TYPE_XYZ)
|
||
|
|
dissolveEdgeWidth *= lerp(1, saturate(VALUE_GEOMETRIC_XYZ_ROLLOUT * 5), VALUE_GEOMETRIC_XYZ_STYLE);
|
||
|
|
#endif
|
||
|
|
|
||
|
|
#elif defined(_AD_EDGE_BASE_SOURCE_ALL)
|
||
|
|
|
||
|
|
//Cutout
|
||
|
|
float dissolveValue1 = cutoutSource.a - VALUE_CUTOUT_STANDARD_CLIP;
|
||
|
|
float dissolveEdgeWidth1 = VALUE_EDGE_BASE_WIDTH_STANDARD * (VALUE_CUTOUT_STANDARD_CLIP < 0.1 ? (VALUE_CUTOUT_STANDARD_CLIP * 10) : 1);
|
||
|
|
|
||
|
|
|
||
|
|
//Geometric
|
||
|
|
float dissolveValue2 = cutoutSource.b;
|
||
|
|
float dissolveEdgeWidth2 = VALUE_EDGE_BASE_WIDTH_GEOMETRIC;
|
||
|
|
|
||
|
|
float xyzAxisCoef = 0.998;
|
||
|
|
#if defined(_AD_CUTOUT_GEOMETRIC_TYPE_XYZ)
|
||
|
|
xyzAxisCoef *= lerp(1, saturate(VALUE_GEOMETRIC_XYZ_ROLLOUT * 5), VALUE_GEOMETRIC_XYZ_STYLE);
|
||
|
|
dissolveEdgeWidth2 *= xyzAxisCoef;
|
||
|
|
#endif
|
||
|
|
|
||
|
|
|
||
|
|
//Lerp
|
||
|
|
float lerpValue = (cutoutSource.b - VALUE_EDGE_BASE_WIDTH_GEOMETRIC * xyzAxisCoef);
|
||
|
|
lerpValue = lerpValue > 0 ? 1 : 0;
|
||
|
|
|
||
|
|
|
||
|
|
dissolveValue = lerp(dissolveValue2, dissolveValue1, lerpValue);
|
||
|
|
dissolveEdgeWidth = lerp(dissolveEdgeWidth2, dissolveEdgeWidth1, lerpValue);
|
||
|
|
|
||
|
|
#endif
|
||
|
|
|
||
|
|
#else
|
||
|
|
|
||
|
|
dissolveValue = cutoutSource.a - VALUE_CUTOUT_STANDARD_CLIP;
|
||
|
|
dissolveEdgeWidth = VALUE_EDGE_BASE_WIDTH_STANDARD * (VALUE_CUTOUT_STANDARD_CLIP < 0.1 ? (VALUE_CUTOUT_STANDARD_CLIP * 10) : 1);
|
||
|
|
|
||
|
|
#endif
|
||
|
|
|
||
|
|
#endif
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
if (dissolveEdgeWidth > 0 && dissolveEdgeWidth > dissolveValue)
|
||
|
|
{
|
||
|
|
float edgeGradient = saturate(dissolveValue) * (1.0 / saturate(dissolveEdgeWidth));
|
||
|
|
float invertGradient = 1 - edgeGradient;
|
||
|
|
|
||
|
|
|
||
|
|
//Only 'Solid' shape
|
||
|
|
#if defined(_AD_EDGE_BASE_SOURCE_ALL)
|
||
|
|
float shapeStyle = 1;
|
||
|
|
#else
|
||
|
|
float3 shape;
|
||
|
|
shape.x = 1;
|
||
|
|
shape.y = invertGradient;
|
||
|
|
shape.z = invertGradient * invertGradient * invertGradient;
|
||
|
|
float shapeStyle = shape[(int)VALUE_EDGE_BASE_SHAPE];
|
||
|
|
#endif
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
#if !defined(ADVANCED_DISSOLVE_SHADER_GRAPH) && !defined(ADVANCED_DISSOLVE_TEXT_MESH_PRO)
|
||
|
|
|
||
|
|
float2 distortion = 0;
|
||
|
|
#if defined(_AD_EDGE_UV_DISTORTION_SOURCE_CUSTOM_MAP)
|
||
|
|
distortion = READ_TEXTURE_2D(VALUE_EDGE_UV_DISTORTION_MAP, VALUE_EDGE_UV_DISTORTION_MAP_SAMPLER, uv * VALUE_EDGE_UV_DISTORTION_MAP_TILING + VALUE_EDGE_UV_DISTORTION_MAP_OFFSET + VALUE_EDGE_UV_DISTORTION_MAP_SCROLL * _Time.x, 1).rg;
|
||
|
|
#else
|
||
|
|
distortion = cutoutSource.rg;
|
||
|
|
#endif
|
||
|
|
|
||
|
|
uv += (distortion - 0.5) * VALUE_EDGE_UV_DISTORTION_STRENGTH * shapeStyle;
|
||
|
|
#endif
|
||
|
|
|
||
|
|
|
||
|
|
float4 edgeColor = float4(VALUE_EDGE_BASE_COLOR.rgb, VALUE_EDGE_BASE_COLOR_TRANSPARENCY);
|
||
|
|
float colorIntensity = VALUE_EDGE_BASE_COLOR_INTENSITY.y * VALUE_EDGE_BASE_COLOR_TRANSPARENCY * (shapeStyle * shapeStyle); //x - default value, y - exponental
|
||
|
|
|
||
|
|
|
||
|
|
#if defined(_AD_EDGE_ADDITIONAL_COLOR_BASE_COLOR)
|
||
|
|
|
||
|
|
float4 edgeAdditionalColor = baseAlbedo;
|
||
|
|
|
||
|
|
edgeAdditionalColor.a = saturate(edgeAdditionalColor.a + VALUE_EDGE_ADDITIONAL_COLOR_ALPHA_OFFSET);
|
||
|
|
|
||
|
|
edgeColor *= edgeAdditionalColor;
|
||
|
|
|
||
|
|
#elif defined(_AD_EDGE_ADDITIONAL_COLOR_CUSTOM_MAP)
|
||
|
|
|
||
|
|
float4 edgeAdditionalColor = READ_TEXTURE_2D_LOD(VALUE_EDGE_ADDITIONAL_COLOR_MAP, VALUE_EDGE_ADDITIONAL_COLOR_MAP_SAMPLER, uv * VALUE_EDGE_ADDITIONAL_COLOR_MAP_TILING + VALUE_EDGE_ADDITIONAL_COLOR_MAP_OFFSET + VALUE_EDGE_ADDITIONAL_COLOR_MAP_SCROLL * _Time.x, VALUE_EDGE_ADDITIONAL_COLOR_MAP_MIPMAP);
|
||
|
|
|
||
|
|
edgeAdditionalColor.a = saturate(edgeAdditionalColor.a + VALUE_EDGE_ADDITIONAL_COLOR_ALPHA_OFFSET);
|
||
|
|
|
||
|
|
edgeColor *= edgeAdditionalColor;
|
||
|
|
|
||
|
|
#elif defined(_AD_EDGE_ADDITIONAL_COLOR_GRADIENT_MAP)
|
||
|
|
|
||
|
|
#if defined(_AD_CUTOUT_STANDARD_SOURCE_NONE)
|
||
|
|
float u1 = lerp(invertGradient, edgeGradient, VALUE_EDGE_ADDITIONAL_COLOR_MAP_REVERSE);
|
||
|
|
u1 = u1 * VALUE_EDGE_ADDITIONAL_COLOR_MAP_TILING.x + VALUE_EDGE_ADDITIONAL_COLOR_MAP_OFFSET.x + VALUE_EDGE_ADDITIONAL_COLOR_MAP_SCROLL.x * _Time.x;
|
||
|
|
|
||
|
|
float4 edgeAdditionalColor = READ_TEXTURE_2D(VALUE_EDGE_ADDITIONAL_COLOR_MAP, VALUE_EDGE_ADDITIONAL_COLOR_MAP_SAMPLER, float2(u1, 0.5), 1);
|
||
|
|
#else
|
||
|
|
float u1 = lerp(invertGradient, edgeGradient, VALUE_EDGE_ADDITIONAL_COLOR_MAP_REVERSE);
|
||
|
|
u1 = u1 * VALUE_EDGE_ADDITIONAL_COLOR_MAP_TILING.x + VALUE_EDGE_ADDITIONAL_COLOR_MAP_OFFSET.x + VALUE_EDGE_ADDITIONAL_COLOR_MAP_SCROLL.x * _Time.x;
|
||
|
|
|
||
|
|
float u2 = lerp(VALUE_CUTOUT_STANDARD_CLIP, 1 - VALUE_CUTOUT_STANDARD_CLIP, VALUE_EDGE_ADDITIONAL_COLOR_MAP_REVERSE);
|
||
|
|
u2 *= VALUE_EDGE_ADDITIONAL_COLOR_MAP_TILING.x;
|
||
|
|
|
||
|
|
float4 edgeAdditionalColor = READ_TEXTURE_2D(VALUE_EDGE_ADDITIONAL_COLOR_MAP, VALUE_EDGE_ADDITIONAL_COLOR_MAP_SAMPLER, float2(lerp(u1, u2, VALUE_EDGE_ADDITIONAL_COLOR_CLIP_INTERPOLATION), 0.5), 1);
|
||
|
|
#endif
|
||
|
|
|
||
|
|
edgeAdditionalColor.a = saturate(edgeAdditionalColor.a + VALUE_EDGE_ADDITIONAL_COLOR_ALPHA_OFFSET);
|
||
|
|
|
||
|
|
edgeColor *= edgeAdditionalColor;
|
||
|
|
|
||
|
|
#elif defined(_AD_EDGE_ADDITIONAL_COLOR_GRADIENT_COLOR)
|
||
|
|
|
||
|
|
#if defined(_AD_CUTOUT_STANDARD_SOURCE_NONE)
|
||
|
|
float lerpValue = saturate(edgeGradient + VALUE_EDGE_ADDITIONAL_COLOR_PHASE_OFFSET);
|
||
|
|
#else
|
||
|
|
float lerpValue = lerp(saturate(edgeGradient + VALUE_EDGE_ADDITIONAL_COLOR_PHASE_OFFSET), VALUE_CUTOUT_STANDARD_CLIP + VALUE_EDGE_ADDITIONAL_COLOR_PHASE_OFFSET, VALUE_EDGE_ADDITIONAL_COLOR_CLIP_INTERPOLATION);
|
||
|
|
#endif
|
||
|
|
|
||
|
|
float3 c1 = lerp(float3(0, 0, 0), edgeColor.rgb, edgeColor.a);
|
||
|
|
float3 c2 = lerp(float3(0, 0, 0), VALUE_EDGE_ADDITIONAL_COLOR.rgb, VALUE_EDGE_ADDITIONAL_COLOR_TRANSPARENCY);
|
||
|
|
|
||
|
|
edgeColor = lerp(float4(c1, edgeColor.a), float4(c2, VALUE_EDGE_ADDITIONAL_COLOR_TRANSPARENCY), lerpValue);
|
||
|
|
colorIntensity = lerp(colorIntensity, VALUE_EDGE_ADDITIONAL_COLOR_INTENSITY .y * VALUE_EDGE_ADDITIONAL_COLOR_TRANSPARENCY, lerpValue);
|
||
|
|
|
||
|
|
#elif defined(_AD_EDGE_ADDITIONAL_COLOR_USER_DEFINED)
|
||
|
|
|
||
|
|
float4 edgeAdditionalColor = customEdgeColor;
|
||
|
|
|
||
|
|
edgeAdditionalColor.a = saturate(edgeAdditionalColor.a + VALUE_EDGE_ADDITIONAL_COLOR_ALPHA_OFFSET);
|
||
|
|
|
||
|
|
edgeColor *= edgeAdditionalColor;
|
||
|
|
|
||
|
|
#endif
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
edgeColor.a *= shapeStyle;
|
||
|
|
edgeColor = saturate(edgeColor);
|
||
|
|
|
||
|
|
albedo = edgeColor.rgb;
|
||
|
|
|
||
|
|
#ifdef ADVANCED_DISSOLVE_META_PASS
|
||
|
|
emission = edgeColor.rgb * (1 + colorIntensity) * VALUE_EDGE_GI_META_PASS_MULTIPLIER;
|
||
|
|
#else
|
||
|
|
emission = edgeColor.rgb * colorIntensity;
|
||
|
|
#endif
|
||
|
|
|
||
|
|
|
||
|
|
retValue = edgeColor.a;
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
#ifdef ADVANCED_DISSOLVE_META_PASS
|
||
|
|
emission *= dissolveValue <= 0 ? 0 : 1;
|
||
|
|
#endif
|
||
|
|
|
||
|
|
#endif
|
||
|
|
|
||
|
|
return retValue;
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
#if defined(ADVANCED_DISSOLVE_SHADER_GRAPH)
|
||
|
|
float4 ADCalculateDissolveUV(float2 texcoord, float3 positionWS)
|
||
|
|
#else
|
||
|
|
float4 ADCalculateDissolveUV(float2 texcoord, float4 positionCS)
|
||
|
|
#endif
|
||
|
|
{
|
||
|
|
#if defined(_AD_CUTOUT_STANDARD_SOURCE_MAPS_MAPPING_TYPE_SCREEN_SPACE)
|
||
|
|
|
||
|
|
#if defined(ADVANCED_DISSOLVE_SHADER_GRAPH)
|
||
|
|
return ComputeScreenPos(TransformWorldToHClip(positionWS), _ProjectionParams.x);
|
||
|
|
#else
|
||
|
|
return ComputeScreenPos(positionCS);
|
||
|
|
#endif
|
||
|
|
|
||
|
|
#else
|
||
|
|
|
||
|
|
return float4(texcoord, 0, 0);
|
||
|
|
|
||
|
|
#endif
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
float4 ADCalculateCutoutSource(float4 baseAlbedo, float4 dissolveUV, float3 positionOS, float3 positionAbsolute, float3 normalOS, float3 normalWS, float customCutoutAlphaSource)
|
||
|
|
{
|
||
|
|
#if defined(_AD_CUTOUT_STANDARD_SOURCE_MAPS_MAPPING_TYPE_TRIPLANAR)
|
||
|
|
return ADReadCutoutSource(positionOS, positionAbsolute, normalOS, normalWS);
|
||
|
|
#else
|
||
|
|
return ADReadCutoutSource(baseAlbedo, dissolveUV, positionOS, positionAbsolute, customCutoutAlphaSource);
|
||
|
|
#endif
|
||
|
|
}
|
||
|
|
|
||
|
|
float4 ADCalculateCutoutSourceOS(float4 baseAlbedo, float4 dissolveUV, float3 positionOS, float3 normalOS)
|
||
|
|
{
|
||
|
|
float3 positionAbsolute = positionOS;
|
||
|
|
#if defined(_AD_CUTOUT_STANDARD_SOURCE_MAPS_MAPPING_TYPE_TRIPLANAR) || defined(ADVANCED_DISSOLVE_CUTOUT_GEOMETRIC_ENABLED)
|
||
|
|
positionAbsolute = ADTransformObjectToWorld(positionOS);
|
||
|
|
#endif
|
||
|
|
|
||
|
|
float3 normalWS = normalOS;
|
||
|
|
#if defined(_AD_CUTOUT_STANDARD_SOURCE_MAPS_MAPPING_TYPE_TRIPLANAR)
|
||
|
|
normalWS = ADTransformObjectToWorldNormal(float3(normalOS));
|
||
|
|
#endif
|
||
|
|
|
||
|
|
|
||
|
|
return ADCalculateCutoutSource(baseAlbedo, dissolveUV, positionOS, positionAbsolute, normalOS, normalWS, 0);
|
||
|
|
}
|
||
|
|
|
||
|
|
float4 ADCalculateCutoutSourceWS(float4 baseAlbedo, float4 dissolveUV, float3 positionAbsolute, float3 normalWS)
|
||
|
|
{
|
||
|
|
float3 positionOS = 0;
|
||
|
|
#if defined(_AD_CUTOUT_STANDARD_SOURCE_MAPS_MAPPING_TYPE_TRIPLANAR) || defined(_AD_CUTOUT_GEOMETRIC_TYPE_XYZ)
|
||
|
|
positionOS = ADTransformWorldToObject(positionAbsolute);
|
||
|
|
#endif
|
||
|
|
|
||
|
|
float3 normalOS = 0;
|
||
|
|
#if defined(_AD_CUTOUT_STANDARD_SOURCE_MAPS_MAPPING_TYPE_TRIPLANAR)
|
||
|
|
normalOS = ADTransformWorldToObjectNormal(normalWS);
|
||
|
|
#endif
|
||
|
|
|
||
|
|
|
||
|
|
return ADCalculateCutoutSource(baseAlbedo, dissolveUV, positionOS, positionAbsolute, normalOS, normalWS, 0);
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
#if defined(ADVANCED_DISSOLVE_SHADER_GRAPH)
|
||
|
|
#define ADVANCED_DISSOLVE_SETUP_CUTOUT_SOURCE(baseAlbedo, texcoord, positionOS, positionWS, positionAbsolute, normalOS, normalWS, customCutoutAlphaSource) float4 advancedDissolveUV = ADCalculateDissolveUV(texcoord, positionWS); \
|
||
|
|
float4 cutoutSource = ADCalculateCutoutSource(baseAlbedo, advancedDissolveUV, positionOS, positionAbsolute, normalOS, normalWS, customCutoutAlphaSource);
|
||
|
|
#else
|
||
|
|
#define ADVANCED_DISSOLVE_UV(index) float4 advancedDissolveUV : TEXCOORD##index;
|
||
|
|
#define ADVANCED_DISSOLVE_INIT_UV(i, texcoord, positionCS) i.advancedDissolveUV = ADCalculateDissolveUV(texcoord.xy, positionCS);
|
||
|
|
#define ADVANCED_DISSOLVE_SETUP_CUTOUT_SOURCE_USING_OS(i, baseAlbedo, positionOS, normalOS) float4 cutoutSource = ADCalculateCutoutSourceOS(baseAlbedo, i.advancedDissolveUV, positionOS, normalOS);
|
||
|
|
#define ADVANCED_DISSOLVE_SETUP_CUTOUT_SOURCE_USING_WS(i, baseAlbedo, positionAbsolute, normalWS) float4 cutoutSource = ADCalculateCutoutSourceWS(baseAlbedo, i.advancedDissolveUV, positionAbsolute, normalWS);
|
||
|
|
#endif
|
||
|
|
|
||
|
|
|
||
|
|
#if defined(ADVANCED_DISSOLVE_SHADER_GRAPH)
|
||
|
|
void AdvancedDissolveShaderGraph(float2 uv, float3 positionOS, float3 positionWS, float3 positionAbsolute, float3 normalOS, float3 normalWS, float customCutoutAlphaSource, float4 customEdgeColor, inout float3 color, inout float3 emission, inout float alpha, inout float alphaClip)
|
||
|
|
{
|
||
|
|
#if defined(_AD_STATE_ENABLED)
|
||
|
|
float4 baseAlbedo = float4(color, alpha);
|
||
|
|
|
||
|
|
ADVANCED_DISSOLVE_SETUP_CUTOUT_SOURCE(baseAlbedo, uv, positionOS, positionWS, positionAbsolute, normalOS, normalWS, customCutoutAlphaSource)
|
||
|
|
|
||
|
|
float3 dissolveAlbedo = 0;
|
||
|
|
float3 dissolveEmission = 0;
|
||
|
|
float dissolveBlend = AdvancedDissolveAlbedoEmission(cutoutSource, baseAlbedo, customEdgeColor, dissolveAlbedo, dissolveEmission, uv);
|
||
|
|
|
||
|
|
color = lerp(color, dissolveAlbedo, dissolveBlend);
|
||
|
|
emission = lerp(emission, dissolveEmission, dissolveBlend);
|
||
|
|
|
||
|
|
AdvancedDissolveCalculateAlphaAndClip(cutoutSource, alpha, alphaClip);
|
||
|
|
#endif
|
||
|
|
}
|
||
|
|
|
||
|
|
void AdvancedDissolveShaderGraph(float2 uv, float3 positionOS, float3 positionWS, float3 positionAbsolute, float3 normalOS, float3 normalWS, float customCutoutAlphaSource, float4 customEdgeColor, inout float3 color, inout float alpha, inout float alphaClip)
|
||
|
|
{
|
||
|
|
#if defined(_AD_STATE_ENABLED)
|
||
|
|
float4 baseAlbedo = float4(color, alpha);
|
||
|
|
|
||
|
|
ADVANCED_DISSOLVE_SETUP_CUTOUT_SOURCE(baseAlbedo, uv, positionOS, positionWS, positionAbsolute, normalOS, normalWS, customCutoutAlphaSource)
|
||
|
|
|
||
|
|
float3 dissolveAlbedo = 0;
|
||
|
|
float3 dissolveEmission = 0;
|
||
|
|
float dissolveBlend = AdvancedDissolveAlbedoEmission(cutoutSource, baseAlbedo, customEdgeColor, dissolveAlbedo, dissolveEmission, uv);
|
||
|
|
|
||
|
|
color = lerp(color, dissolveAlbedo, dissolveBlend);
|
||
|
|
color += lerp(float3(0, 0, 0), dissolveEmission, dissolveBlend);
|
||
|
|
|
||
|
|
AdvancedDissolveCalculateAlphaAndClip(cutoutSource, alpha, alphaClip);
|
||
|
|
#endif
|
||
|
|
}
|
||
|
|
|
||
|
|
void AdvancedDissolveShaderGraph(float2 uv, float3 positionOS, float3 positionWS, float3 positionAbsolute, float3 normalOS, float3 normalWS, float customCutoutAlphaSource, float4 customEdgeColor, inout float alpha, inout float alphaClip)
|
||
|
|
{
|
||
|
|
#if defined(_AD_STATE_ENABLED)
|
||
|
|
float4 baseAlbedo = float4(0, 0, 0, alpha);
|
||
|
|
|
||
|
|
ADVANCED_DISSOLVE_SETUP_CUTOUT_SOURCE(baseAlbedo, uv, positionOS, positionWS, positionAbsolute, normalOS, normalWS, customCutoutAlphaSource)
|
||
|
|
|
||
|
|
AdvancedDissolveCalculateAlphaAndClip(cutoutSource, alpha, alphaClip);
|
||
|
|
#endif
|
||
|
|
}
|
||
|
|
#endif
|
||
|
|
|
||
|
|
#endif //ADVANCED_DISSOLVE_CORE_CGINC
|