您最多选择25个主题
主题必须以中文或者字母或数字开头，可以包含连字符 (-)，并且长度不得超过35个字符
456 行
16 KiB
456 行
16 KiB
// GENERATED BY SHADER GRAPH
|
|
// Question for shader graph: how to handle dynamic parameter data like matData0 that can change name
|
|
|
|
// No guard header!
|
|
|
|
#define UNITY_MATERIAL_LIT // Need to be define before including Material.hlsl
|
|
#include "Lighting/Lighting.hlsl" // This include Material.hlsl
|
|
#include "ShaderVariables.hlsl"
|
|
#include "Debug/DebugViewMaterial.hlsl"
|
|
|
|
// This files is generated by the ShaderGraph or written by hand
|
|
|
|
// Note for ShaderGraph:
|
|
// ShaderGraph should generate the vertex shader output to add the variable that may be required
|
|
// For example if we require view vector in shader graph, the output must contain positionWS and we calcualte the view vector with it.
|
|
// Still some input are mandatory depends on the type of loop. positionWS is mandatory in this current framework. So the ShaderGraph should always generate it.
|
|
|
|
|
|
#define PROP_DECL(type, name) type name, name##0, name##1, name##2, name##3;
|
|
#define PROP_DECL_TEX2D(name)\
|
|
UNITY_DECLARE_TEX2D(name##0);\
|
|
UNITY_DECLARE_TEX2D_NOSAMPLER(name##1);\
|
|
UNITY_DECLARE_TEX2D_NOSAMPLER(name##2);\
|
|
UNITY_DECLARE_TEX2D_NOSAMPLER(name##3);
|
|
#define PROP_SAMPLE(name, textureName, texcoord, swizzle)\
|
|
name##0 = UNITY_SAMPLE_TEX2D_SAMPLER(textureName##0, textureName##0, texcoord).##swizzle; \
|
|
name##1 = UNITY_SAMPLE_TEX2D_SAMPLER(textureName##1, textureName##0, texcoord).##swizzle; \
|
|
name##2 = UNITY_SAMPLE_TEX2D_SAMPLER(textureName##2, textureName##0, texcoord).##swizzle; \
|
|
name##3 = UNITY_SAMPLE_TEX2D_SAMPLER(textureName##3, textureName##0, texcoord).##swizzle;
|
|
#define PROP_MUL(name, multiplier, swizzle)\
|
|
name##0 *= multiplier##0.##swizzle; \
|
|
name##1 *= multiplier##1.##swizzle; \
|
|
name##2 *= multiplier##2.##swizzle; \
|
|
name##3 *= multiplier##3.##swizzle;
|
|
#define PROP_ASSIGN(name, input, swizzle)\
|
|
name##0 = input##0.##swizzle; \
|
|
name##1 = input##1.##swizzle; \
|
|
name##2 = input##2.##swizzle; \
|
|
name##3 = input##3.##swizzle;
|
|
#define PROP_ASSIGN_VALUE(name, input)\
|
|
name##0 = input; \
|
|
name##1 = input; \
|
|
name##2 = input; \
|
|
name##3 = input;
|
|
#define PROP_BLEND_COLOR(name, mask) name = BlendLayeredColor(name##0, name##1, name##2, name##3, mask);
|
|
#define PROP_BLEND_SCALAR(name, mask) name = BlendLayeredScalar(name##0, name##1, name##2, name##3, mask);
|
|
|
|
#define _MAX_LAYER 4
|
|
|
|
#if defined(_LAYEREDLIT_4_LAYERS)
|
|
# define _LAYER_COUNT 4
|
|
#elif defined(_LAYEREDLIT_3_LAYERS)
|
|
# define _LAYER_COUNT 3
|
|
#else
|
|
# define _LAYER_COUNT 2
|
|
#endif
|
|
|
|
//-------------------------------------------------------------------------------------
|
|
// variable declaration
|
|
//-------------------------------------------------------------------------------------
|
|
|
|
// Set of users variables
|
|
PROP_DECL(float4, _BaseColor);
|
|
PROP_DECL_TEX2D(_BaseColorMap);
|
|
PROP_DECL(float, _Metalic);
|
|
PROP_DECL(float, _Smoothness);
|
|
PROP_DECL_TEX2D(_MaskMap);
|
|
PROP_DECL_TEX2D(_SpecularOcclusionMap);
|
|
PROP_DECL_TEX2D(_NormalMap);
|
|
PROP_DECL_TEX2D(_Heightmap);
|
|
PROP_DECL(float, _HeightScale);
|
|
PROP_DECL(float, _HeightBias);
|
|
PROP_DECL(float4, _EmissiveColor);
|
|
PROP_DECL(float, _EmissiveIntensity);
|
|
|
|
float _AlphaCutoff;
|
|
UNITY_DECLARE_TEX2D(_LayerMaskMap);
|
|
|
|
//-------------------------------------------------------------------------------------
|
|
// Lighting architecture
|
|
//-------------------------------------------------------------------------------------
|
|
|
|
// TODO: Check if we will have different Varyings based on different pass, not sure about that...
|
|
|
|
// Forward
|
|
struct Attributes
|
|
{
|
|
float3 positionOS : POSITION;
|
|
float3 normalOS : NORMAL;
|
|
float2 uv0 : TEXCOORD0;
|
|
float4 tangentOS : TANGENT;
|
|
float4 color : TANGENT;
|
|
};
|
|
|
|
struct Varyings
|
|
{
|
|
float4 positionHS;
|
|
float3 positionWS;
|
|
float2 texCoord0;
|
|
float4 tangentToWorld[3]; // [3x3:tangentToWorld | 1x3:viewDirForParallax]
|
|
float4 vertexColor;
|
|
|
|
#ifdef SHADER_STAGE_FRAGMENT
|
|
#if defined(_DOUBLESIDED_LIGHTING_FLIP) || defined(_DOUBLESIDED_LIGHTING_MIRROR)
|
|
FRONT_FACE_TYPE cullFace;
|
|
#endif
|
|
#endif
|
|
};
|
|
|
|
struct PackedVaryings
|
|
{
|
|
float4 positionHS : SV_Position;
|
|
float4 interpolators[6] : TEXCOORD0;
|
|
|
|
#ifdef SHADER_STAGE_FRAGMENT
|
|
#if defined(_DOUBLESIDED_LIGHTING_FLIP) || defined(_DOUBLESIDED_LIGHTING_MIRROR)
|
|
FRONT_FACE_TYPE cullFace : FRONT_FACE_SEMATIC;
|
|
#endif
|
|
#endif
|
|
};
|
|
|
|
// Function to pack data to use as few interpolator as possible, the ShaderGraph should generate these functions
|
|
PackedVaryings PackVaryings(Varyings input)
|
|
{
|
|
PackedVaryings output;
|
|
output.positionHS = input.positionHS;
|
|
output.interpolators[0].xyz = input.positionWS.xyz;
|
|
output.interpolators[0].w = input.texCoord0.x;
|
|
output.interpolators[1] = input.tangentToWorld[0];
|
|
output.interpolators[2] = input.tangentToWorld[1];
|
|
output.interpolators[3] = input.tangentToWorld[2];
|
|
output.interpolators[4].x = input.texCoord0.y;
|
|
output.interpolators[4].yzw = float3(0.0, 0.0, 0.0);
|
|
output.interpolators[5] = input.vertexColor;
|
|
|
|
return output;
|
|
}
|
|
|
|
Varyings UnpackVaryings(PackedVaryings input)
|
|
{
|
|
Varyings output;
|
|
output.positionHS = input.positionHS;
|
|
output.positionWS.xyz = input.interpolators[0].xyz;
|
|
output.texCoord0.x = input.interpolators[0].w;
|
|
output.texCoord0.y = input.interpolators[4].x;
|
|
output.tangentToWorld[0] = input.interpolators[1];
|
|
output.tangentToWorld[1] = input.interpolators[2];
|
|
output.tangentToWorld[2] = input.interpolators[3];
|
|
output.vertexColor = input.interpolators[5];
|
|
|
|
#ifdef SHADER_STAGE_FRAGMENT
|
|
#if defined(_DOUBLESIDED_LIGHTING_FLIP) || defined(_DOUBLESIDED_LIGHTING_MIRROR)
|
|
output.cullFace = input.cullFace;
|
|
#endif
|
|
#endif
|
|
|
|
return output;
|
|
}
|
|
|
|
// TODO: Here we will also have all the vertex deformation (GPU skinning, vertex animation, morph target...) or we will need to generate a compute shaders instead (better! but require work to deal with unpacking like fp16)
|
|
PackedVaryings VertDefault(Attributes input)
|
|
{
|
|
Varyings output;
|
|
|
|
output.positionWS = TransformObjectToWorld(input.positionOS);
|
|
// TODO deal with camera center rendering and instancing (This is the reason why we always perform tow steps transform to clip space + instancing matrix)
|
|
output.positionHS = TransformWorldToHClip(output.positionWS);
|
|
|
|
float3 normalWS = TransformObjectToWorldNormal(input.normalOS);
|
|
|
|
output.texCoord0 = input.uv0;
|
|
|
|
float4 tangentWS = float4(TransformObjectToWorldDir(input.tangentOS.xyz), input.tangentOS.w);
|
|
|
|
float3x3 tangentToWorld = CreateTangentToWorld(normalWS, tangentWS.xyz, tangentWS.w);
|
|
output.tangentToWorld[0].xyz = tangentToWorld[0];
|
|
output.tangentToWorld[1].xyz = tangentToWorld[1];
|
|
output.tangentToWorld[2].xyz = tangentToWorld[2];
|
|
|
|
output.tangentToWorld[0].w = 0;
|
|
output.tangentToWorld[1].w = 0;
|
|
output.tangentToWorld[2].w = 0;
|
|
|
|
output.vertexColor = input.color;
|
|
|
|
return PackVaryings(output);
|
|
}
|
|
|
|
|
|
//-------------------------------------------------------------------------------------
|
|
// Fill SurfaceData/Lighting data function
|
|
//-------------------------------------------------------------------------------------
|
|
|
|
float3 TransformTangentToWorld(float3 normalTS, float4 tangentToWorld[3])
|
|
{
|
|
// TODO check: do we need to normalize ?
|
|
return normalize(mul(normalTS, float3x3(tangentToWorld[0].xyz, tangentToWorld[1].xyz, tangentToWorld[2].xyz)));
|
|
}
|
|
|
|
#if SHADER_STAGE_FRAGMENT
|
|
|
|
float3 BlendLayeredColor(float3 rgb0, float3 rgb1, float3 rgb2, float3 rgb3, float weight[4])
|
|
{
|
|
float3 result = float3(0.0, 0.0, 0.0);
|
|
|
|
result = rgb0 * weight[0] + rgb1 * weight[1];
|
|
#if _LAYER_COUNT >= 3
|
|
result += (rgb2 * weight[2]);
|
|
#endif
|
|
#if _LAYER_COUNT >= 4
|
|
result += rgb3 * weight[3];
|
|
#endif
|
|
|
|
return result;
|
|
}
|
|
|
|
float3 BlendLayeredNormal(float3 normal0, float3 normal1, float3 normal2, float3 normal3, float weight[4])
|
|
{
|
|
float3 result = float3(0.0, 0.0, 0.0);
|
|
|
|
// TODO : real normal map blending function
|
|
result = normal0 * weight[0] + normal1 * weight[1];
|
|
#if _LAYER_COUNT >= 3
|
|
result += normal2 * weight[2];
|
|
#endif
|
|
#if _LAYER_COUNT >= 4
|
|
result += normal3 * weight[3];
|
|
#endif
|
|
|
|
return result;
|
|
}
|
|
|
|
float BlendLayeredScalar(float x0, float x1, float x2, float x3, float weight[4])
|
|
{
|
|
float result = 0.0;
|
|
|
|
result = x0 * weight[0] + x1 * weight[1];
|
|
#if _LAYER_COUNT >= 3
|
|
result += x2 * weight[2];
|
|
#endif
|
|
#if _LAYER_COUNT >= 4
|
|
result += x3 * weight[3];
|
|
#endif
|
|
|
|
return result;
|
|
}
|
|
|
|
void ComputeMaskWeights(float4 inputMasks, out float outWeights[_MAX_LAYER])
|
|
{
|
|
float masks[_MAX_LAYER];
|
|
masks[0] = inputMasks.r;
|
|
masks[1] = inputMasks.g;
|
|
masks[2] = inputMasks.b;
|
|
masks[3] = inputMasks.a;
|
|
|
|
// calculate weight of each layers
|
|
float left = 1.0f;
|
|
|
|
// ATTRIBUTE_UNROLL
|
|
for (int i = _LAYER_COUNT - 1; i > 0; --i)
|
|
{
|
|
outWeights[i] = masks[i] * left;
|
|
left -= outWeights[i];
|
|
}
|
|
outWeights[0] = left;
|
|
}
|
|
|
|
void GetSurfaceAndBuiltinData(Varyings input, out SurfaceData surfaceData, out BuiltinData builtinData)
|
|
{
|
|
float4 maskValues = float4(1.0, 1.0, 1.0, 1.0);// input.vertexColor;
|
|
|
|
#ifdef _LAYERMASKMAP
|
|
float4 maskMap = UNITY_SAMPLE_TEX2D(_LayerMaskMap, input.texCoord0);
|
|
maskValues *= maskMap;
|
|
#endif
|
|
|
|
float weights[_MAX_LAYER];
|
|
ComputeMaskWeights(maskValues, weights);
|
|
|
|
PROP_DECL(float3, baseColor);
|
|
PROP_SAMPLE(baseColor, _BaseColorMap, input.texCoord0, rgb);
|
|
PROP_MUL(baseColor, _BaseColor, rgb);
|
|
PROP_BLEND_COLOR(baseColor, weights);
|
|
|
|
surfaceData.baseColor = baseColor;
|
|
|
|
PROP_DECL(float, alpha);
|
|
#ifdef _SMOOTHNESS_TEXTURE_ALBEDO_CHANNEL_A
|
|
PROP_ASSIGN(alpha, _BaseColor, a);
|
|
#else
|
|
PROP_SAMPLE(alpha, _BaseColorMap, input.texCoord0, a);
|
|
PROP_MUL(alpha, _BaseColor, a);
|
|
#endif
|
|
PROP_BLEND_SCALAR(alpha, weights);
|
|
|
|
#ifdef _ALPHATEST_ON
|
|
clip(alpha - _AlphaCutoff);
|
|
#endif
|
|
|
|
builtinData.opacity = alpha;
|
|
|
|
PROP_DECL(float, specularOcclusion);
|
|
#ifdef _SPECULAROCCLUSIONMAP
|
|
// TODO: Do something. For now just take alpha channel
|
|
PROP_SAMPLE(specularOcclusion, _SpecularOcclusionMap, input.texCoord0, a);
|
|
#else
|
|
// Horizon Occlusion for Normal Mapped Reflections: http://marmosetco.tumblr.com/post/81245981087
|
|
//surfaceData.specularOcclusion = saturate(1.0 + horizonFade * dot(r, input.tangentToWorld[2].xyz);
|
|
// smooth it
|
|
//surfaceData.specularOcclusion *= surfaceData.specularOcclusion;
|
|
PROP_ASSIGN_VALUE(specularOcclusion, 1.0);
|
|
#endif
|
|
PROP_BLEND_SCALAR(specularOcclusion, weights);
|
|
surfaceData.specularOcclusion = specularOcclusion;
|
|
|
|
// TODO: think about using BC5
|
|
float3 vertexNormalWS = input.tangentToWorld[2].xyz;
|
|
|
|
#ifdef _NORMALMAP
|
|
#ifdef _NORMALMAP_TANGENT_SPACE
|
|
float3 normalTS0 = UnpackNormalAG(UNITY_SAMPLE_TEX2D_SAMPLER(_NormalMap0, _NormalMap0, input.texCoord0));
|
|
float3 normalTS1 = UnpackNormalAG(UNITY_SAMPLE_TEX2D_SAMPLER(_NormalMap1, _NormalMap0, input.texCoord0));
|
|
float3 normalTS2 = UnpackNormalAG(UNITY_SAMPLE_TEX2D_SAMPLER(_NormalMap2, _NormalMap0, input.texCoord0));
|
|
float3 normalTS3 = UnpackNormalAG(UNITY_SAMPLE_TEX2D_SAMPLER(_NormalMap3, _NormalMap0, input.texCoord0));
|
|
|
|
float3 normalTS = BlendLayeredNormal(normalTS0, normalTS1, normalTS2, normalTS3, weights);
|
|
|
|
surfaceData.normalWS = TransformTangentToWorld(normalTS, input.tangentToWorld);
|
|
#else // Object space (TODO: We need to apply the world rotation here!)
|
|
surfaceData.normalWS = UNITY_SAMPLE_TEX2D(_NormalMap, input.texCoord0).rgb;
|
|
#endif
|
|
#else
|
|
surfaceData.normalWS = vertexNormalWS;
|
|
#endif
|
|
|
|
#if defined(_DOUBLESIDED_LIGHTING_FLIP) || defined(_DOUBLESIDED_LIGHTING_MIRROR)
|
|
#ifdef _DOUBLESIDED_LIGHTING_FLIP
|
|
float3 oppositeNormalWS = -surfaceData.normalWS;
|
|
#else
|
|
// Mirror the normal with the plane define by vertex normal
|
|
float3 oppositeNormalWS = reflect(surfaceData.normalWS, vertexNormalWS);
|
|
#endif
|
|
// TODO : Test if GetOdddNegativeScale() is necessary here in case of normal map, as GetOdddNegativeScale is take into account in CreateTangentToWorld();
|
|
surfaceData.normalWS = IS_FRONT_VFACE(input.cullFace, GetOdddNegativeScale() >= 0.0 ? surfaceData.normalWS : oppositeNormalWS, -GetOdddNegativeScale() >= 0.0 ? surfaceData.normalWS : oppositeNormalWS);
|
|
#endif
|
|
|
|
|
|
PROP_DECL(float, perceptualSmoothness);
|
|
#ifdef _SMOOTHNESS_TEXTURE_ALBEDO_CHANNEL_A
|
|
PROP_SAMPLE(perceptualSmoothness, _BaseColorMap, input.texCoord0, a);
|
|
#elif defined(_MASKMAP)
|
|
PROP_SAMPLE(perceptualSmoothness, _MaskMap, input.texCoord0, a);
|
|
#else
|
|
PROP_ASSIGN_VALUE(perceptualSmoothness, 1.0);
|
|
#endif
|
|
PROP_MUL(perceptualSmoothness, _Smoothness, r);
|
|
PROP_BLEND_SCALAR(perceptualSmoothness, weights);
|
|
|
|
surfaceData.perceptualSmoothness = perceptualSmoothness;
|
|
|
|
surfaceData.materialId = 0;
|
|
|
|
// MaskMap is Metalic, Ambient Occlusion, (Optional) - emissive Mask, Optional - Smoothness (in alpha)
|
|
PROP_DECL(float, metalic);
|
|
PROP_DECL(float, ambientOcclusion);
|
|
#ifdef _MASKMAP
|
|
PROP_SAMPLE(metalic, _MaskMap, input.texCoord0, a);
|
|
PROP_SAMPLE(ambientOcclusion, _MaskMap, input.texCoord0, g);
|
|
#else
|
|
PROP_ASSIGN_VALUE(metalic, 1.0);
|
|
PROP_ASSIGN_VALUE(ambientOcclusion, 1.0);
|
|
#endif
|
|
PROP_MUL(metalic, _Metalic, r);
|
|
|
|
PROP_BLEND_SCALAR(metalic, weights);
|
|
PROP_BLEND_SCALAR(ambientOcclusion, weights);
|
|
|
|
surfaceData.metalic = metalic;
|
|
surfaceData.ambientOcclusion = ambientOcclusion;
|
|
|
|
surfaceData.tangentWS = float3(1.0, 0.0, 0.0);
|
|
surfaceData.anisotropy = 0;
|
|
surfaceData.specular = 0.04;
|
|
|
|
surfaceData.subSurfaceRadius = 1.0;
|
|
surfaceData.thickness = 0.0;
|
|
surfaceData.subSurfaceProfile = 0;
|
|
|
|
surfaceData.coatNormalWS = float3(1.0, 0.0, 0.0);
|
|
surfaceData.coatPerceptualSmoothness = 1.0;
|
|
surfaceData.specularColor = float3(0.0, 0.0, 0.0);
|
|
|
|
// Builtin Data
|
|
|
|
// TODO: Sample lightmap/lightprobe/volume proxy
|
|
// This should also handle projective lightmap
|
|
// Note that data input above can be use to sample into lightmap (like normal)
|
|
builtinData.bakeDiffuseLighting = float3(0.0, 0.0, 0.0);// tex2D(_DiffuseLightingMap, input.texCoord0).rgb;
|
|
|
|
// If we chose an emissive color, we have a dedicated texture for it and don't use MaskMap
|
|
PROP_DECL(float3, emissiveColor);
|
|
#ifdef _EMISSIVE_COLOR
|
|
#ifdef _EMISSIVE_COLOR_MAP
|
|
PROP_SAMPLE(emissiveColor, _EmissiveColorMap, input.texCoord0, rgb);
|
|
#else
|
|
PROP_ASSIGN(emissiveColor, _EmissiveColor, rgb);
|
|
#endif
|
|
#elif defined(_MASKMAP) // If we have a MaskMap, use emissive slot as a mask on baseColor
|
|
PROP_SAMPLE(emissiveColor, _MaskMap, input.texCoord0, bbb);
|
|
PROP_MUL(emissiveColor, baseColor, rgb);
|
|
#else
|
|
PROP_ASSIGN_VALUE(emissiveColor, float3(0.0, 0.0, 0.0));
|
|
#endif
|
|
PROP_BLEND_COLOR(emissiveColor, weights);
|
|
builtinData.emissiveColor = emissiveColor;
|
|
|
|
PROP_DECL(float, emissiveIntensity);
|
|
PROP_ASSIGN(emissiveIntensity, _EmissiveIntensity, r);
|
|
PROP_BLEND_SCALAR(emissiveIntensity, weights);
|
|
builtinData.emissiveIntensity = emissiveIntensity;
|
|
|
|
builtinData.velocity = float2(0.0, 0.0);
|
|
|
|
builtinData.distortion = float2(0.0, 0.0);
|
|
builtinData.distortionBlur = 0.0;
|
|
}
|
|
|
|
void GetVaryingsDataDebug(uint paramId, Varyings input, inout float3 result, inout bool needLinearToSRGB)
|
|
{
|
|
switch (paramId)
|
|
{
|
|
case DEBUGVIEW_VARYING_DEPTH:
|
|
// TODO: provide a customize parameter (like a slider)
|
|
float linearDepth = frac(LinearEyeDepth(input.positionHS.z, _ZBufferParams) * 0.1);
|
|
result = linearDepth.xxx;
|
|
break;
|
|
case DEBUGVIEW_VARYING_TEXCOORD0:
|
|
// TODO: require a remap
|
|
result = float3(input.texCoord0, 0.0);
|
|
break;
|
|
case DEBUGVIEW_VARYING_VERTEXNORMALWS:
|
|
result = input.tangentToWorld[2].xyz * 0.5 + 0.5;
|
|
break;
|
|
case DEBUGVIEW_VARYING_VERTEXTANGENTWS:
|
|
result = input.tangentToWorld[0].xyz * 0.5 + 0.5;
|
|
break;
|
|
case DEBUGVIEW_VARYING_VERTEXBITANGENTWS:
|
|
result = input.tangentToWorld[1].xyz * 0.5 + 0.5;
|
|
break;
|
|
case DEBUGVIEW_VARYING_VERTEXCOLOR:
|
|
result = input.vertexColor.xyz;
|
|
break;
|
|
}
|
|
}
|
|
|
|
#endif // #if SHADER_STAGE_FRAGMENT
|