264 lines
6.6 KiB
HLSL
264 lines
6.6 KiB
HLSL
// SPDX-FileCopyrightText: 2023 Unity Technologies and the glTFast authors
|
|
// SPDX-License-Identifier: Apache-2.0
|
|
|
|
// Based on Unity built-in shader source. Copyright (c) 2016 Unity Technologies. MIT license (see license.txt)
|
|
|
|
|
|
#ifndef UNITY_STANDARD_INPUT_INCLUDED
|
|
#define UNITY_STANDARD_INPUT_INCLUDED
|
|
|
|
#include "UnityCG.cginc"
|
|
#include "UnityStandardConfig.cginc"
|
|
#include "UnityPBSLighting.cginc" // TBD: remove
|
|
#include "UnityStandardUtils.cginc"
|
|
|
|
//---------------------------------------
|
|
// Directional lightmaps & Parallax require tangent space too
|
|
#if (_NORMALMAP || DIRLIGHTMAP_COMBINED || _PARALLAXMAP)
|
|
#define _TANGENT_TO_WORLD 1
|
|
#endif
|
|
|
|
#if (_DETAIL_MULX2 || _DETAIL_MUL || _DETAIL_ADD || _DETAIL_LERP)
|
|
#define _DETAIL 1
|
|
#endif
|
|
|
|
//---------------------------------------
|
|
half4 baseColorFactor;
|
|
half alphaCutoff;
|
|
|
|
sampler2D baseColorTexture;
|
|
float4 baseColorTexture_ST;
|
|
float2 baseColorTexture_Rotation;
|
|
half baseColorTexture_texCoord;
|
|
|
|
sampler2D _DetailAlbedoMap;
|
|
float4 _DetailAlbedoMap_ST;
|
|
|
|
sampler2D normalTexture;
|
|
float4 normalTexture_ST;
|
|
float2 normalTexture_Rotation;
|
|
half normalTexture_texCoord;
|
|
half normalTexture_scale;
|
|
|
|
sampler2D _DetailMask;
|
|
sampler2D _DetailNormalMap;
|
|
half _DetailNormalMapScale;
|
|
|
|
sampler2D specularGlossinessTexture;
|
|
float4 specularGlossinessTexture_ST;
|
|
float2 specularGlossinessTexture_Rotation;
|
|
half specularGlossinessTexture_texCoord;
|
|
|
|
sampler2D metallicRoughnessTexture;
|
|
float4 metallicRoughnessTexture_ST;
|
|
float2 metallicRoughnessTexture_Rotation;
|
|
half metallicRoughnessTexture_texCoord;
|
|
half metallicFactor;
|
|
float glossinessFactor;
|
|
float roughnessFactor;
|
|
|
|
sampler2D occlusionTexture;
|
|
float4 occlusionTexture_ST;
|
|
float2 occlusionTexture_Rotation;
|
|
half occlusionTexture_texCoord;
|
|
half occlusionTexture_strength;
|
|
|
|
sampler2D _ParallaxMap;
|
|
half _Parallax;
|
|
half _UVSec;
|
|
|
|
half4 emissiveFactor;
|
|
sampler2D emissiveTexture;
|
|
float4 emissiveTexture_ST;
|
|
float2 emissiveTexture_Rotation;
|
|
half emissiveTexture_texCoord;
|
|
|
|
half4 specularFactor;
|
|
|
|
//-------------------------------------------------------------------------------------
|
|
// Input functions
|
|
|
|
struct VertexInput
|
|
{
|
|
float4 vertex : POSITION;
|
|
half3 normal : NORMAL;
|
|
float2 uv0 : TEXCOORD0;
|
|
float2 uv1 : TEXCOORD1;
|
|
#if defined(DYNAMICLIGHTMAP_ON) || defined(UNITY_PASS_META)
|
|
float2 uv2 : TEXCOORD2;
|
|
#endif
|
|
#ifdef _TANGENT_TO_WORLD
|
|
half4 tangent : TANGENT;
|
|
#endif
|
|
half4 color : COLOR;
|
|
UNITY_VERTEX_INPUT_INSTANCE_ID
|
|
};
|
|
|
|
float4 TexCoords(VertexInput v)
|
|
{
|
|
float4 texcoord;
|
|
#ifdef _TEXTURE_TRANSFORM
|
|
|
|
// Scale and Rotation: 2x2 matrix multiplication
|
|
texcoord.z = v.uv0.x * baseColorTexture_ST.x + v.uv0.y * baseColorTexture_Rotation.y;
|
|
texcoord.w = v.uv0.x * baseColorTexture_Rotation.x + v.uv0.y * baseColorTexture_ST.y;
|
|
|
|
// Transform/Offset
|
|
texcoord.xy = texcoord.zw + baseColorTexture_ST.zw;
|
|
|
|
texcoord.zw = TRANSFORM_TEX(((_UVSec == 0) ? v.uv0 : v.uv1), _DetailAlbedoMap);
|
|
#else
|
|
texcoord.xy = TRANSFORM_TEX(v.uv0, baseColorTexture); // Always source from uv0
|
|
texcoord.zw = TRANSFORM_TEX(((_UVSec == 0) ? v.uv0 : v.uv1), _DetailAlbedoMap);
|
|
#endif
|
|
return texcoord;
|
|
}
|
|
|
|
#ifdef _TEXTURE_TRANSFORM
|
|
#define TexCoordsSingle(uv,map) TexCoordsSingleIntern(uv,map##_ST,map##_Rotation);
|
|
#else
|
|
#define TexCoordsSingle(uv,map) uv
|
|
#endif
|
|
|
|
float2 TexCoordsSingleSimple(float2 uv, float4 st)
|
|
{
|
|
return uv * st.xy + st.zw;
|
|
}
|
|
|
|
float2 TexCoordsSingleIntern(float2 uv, float4 st, float2 rotation)
|
|
{
|
|
float2 texcoord;
|
|
// Scale and Rotation: 2x2 matrix multiplication
|
|
float2 sr;
|
|
sr.x = uv.x * st.x + uv.y * rotation.y;
|
|
sr.y = uv.x * rotation.x + uv.y * st.y;
|
|
// Transform/Offset
|
|
texcoord.xy = sr + st.zw;
|
|
return texcoord;
|
|
}
|
|
|
|
half DetailMask(float2 uv)
|
|
{
|
|
return tex2D (_DetailMask, uv).a;
|
|
}
|
|
|
|
half3 Albedo(float2 texcoords)
|
|
{
|
|
half3 albedo = baseColorFactor.rgb * tex2D (baseColorTexture, texcoords).rgb;
|
|
return albedo;
|
|
}
|
|
|
|
half Alpha(float2 uv)
|
|
{
|
|
#if defined(_SMOOTHNESS_TEXTURE_ALBEDO_CHANNEL_A)
|
|
return baseColorFactor.a;
|
|
#else
|
|
half alpha = tex2D(baseColorTexture, uv).a;
|
|
#ifndef UNITY_COLORSPACE_GAMMA
|
|
alpha = GammaToLinearSpace(alpha);
|
|
#endif
|
|
return alpha * baseColorFactor.a;
|
|
#endif
|
|
}
|
|
|
|
half Occlusion(float2 uv)
|
|
{
|
|
#if (SHADER_TARGET < 30)
|
|
// SM20: instruction count limitation
|
|
// SM20: simpler occlusion
|
|
return tex2D(occlusionTexture, uv).r;
|
|
#else
|
|
half occ = tex2D(occlusionTexture, uv).r;
|
|
return LerpOneTo (occ, occlusionTexture_strength);
|
|
#endif
|
|
}
|
|
|
|
half4 SpecularGloss(float2 uv)
|
|
{
|
|
half4 sg;
|
|
#ifdef _SPECGLOSSMAP
|
|
sg = tex2D(specularGlossinessTexture, uv);
|
|
sg.rgb = sg.rgb * specularFactor.rgb;
|
|
sg.a *= glossinessFactor;
|
|
#else
|
|
sg.rgb = specularFactor.rgb;
|
|
sg.a = glossinessFactor;
|
|
#endif
|
|
return sg;
|
|
}
|
|
|
|
half2 MetallicGloss(float2 uv)
|
|
{
|
|
half2 mg;
|
|
|
|
#ifdef _METALLICGLOSSMAP
|
|
mg.rg = tex2D(metallicRoughnessTexture, uv).bg;
|
|
mg.r *= metallicFactor;
|
|
mg.g = 1-(mg.g*roughnessFactor);
|
|
#else
|
|
mg.r = metallicFactor;
|
|
mg.g = 1-roughnessFactor;
|
|
#endif
|
|
return mg;
|
|
}
|
|
|
|
half2 MetallicRough(float2 uv)
|
|
{
|
|
half2 mg;
|
|
#ifdef _METALLICGLOSSMAP
|
|
mg.r = tex2D(metallicRoughnessTexture, uv).b * metallicFactor;
|
|
#else
|
|
mg.r = metallicFactor;
|
|
#endif
|
|
|
|
#ifdef _SPECGLOSSMAP
|
|
mg.g = 1.0f - (tex2D(specularGlossinessTexture, uv).a*glossinessFactor);
|
|
#else
|
|
mg.g = 1.0f - glossinessFactor;
|
|
#endif
|
|
return mg;
|
|
}
|
|
|
|
half3 Emission(float2 uv)
|
|
{
|
|
#ifndef _EMISSION
|
|
return 0;
|
|
#else
|
|
return tex2D(emissiveTexture, uv).rgb * emissiveFactor.rgb;
|
|
#endif
|
|
}
|
|
|
|
#ifdef _NORMALMAP
|
|
half3 NormalInTangentSpace(float2 texcoords)
|
|
{
|
|
// This is a replacement for UnityStandardUtils UnpackScaleNormal to use XYZ normals even with DXT5nm enabled
|
|
half4 packedNormal = tex2D(normalTexture, texcoords);
|
|
packedNormal.x *= packedNormal.w;
|
|
|
|
half3 normal;
|
|
normal.xy = packedNormal.xy * 2 - 1;
|
|
#if (SHADER_TARGET >= 30)
|
|
// SM2.0: instruction count limitation
|
|
// SM2.0: normal scaler is not supported
|
|
normal.xy *= normalTexture_scale;
|
|
#endif
|
|
normal.z = sqrt(1.0 - saturate(dot(normal.xy, normal.xy)));
|
|
return normal;
|
|
}
|
|
#endif
|
|
|
|
float4 Parallax (float4 texcoords, half3 viewDir)
|
|
{
|
|
#if !defined(_PARALLAXMAP) || (SHADER_TARGET < 30)
|
|
// Disable parallax on pre-SM3.0 shader target models
|
|
return texcoords;
|
|
#else
|
|
half h = tex2D (_ParallaxMap, texcoords.xy).g;
|
|
float2 offset = ParallaxOffset1Step (h, _Parallax, viewDir);
|
|
return float4(texcoords.xy + offset, texcoords.zw + offset);
|
|
#endif
|
|
|
|
}
|
|
|
|
#endif // UNITY_STANDARD_INPUT_INCLUDED
|