Sebastien Lagarde
7 年前
当前提交
3f0b2e50
共有 36 个文件被更改，包括 3462 次插入 和 1804 次删除
-
2ScriptableRenderPipeline/HDRenderPipeline/Material/Character/Character.shader
-
5ScriptableRenderPipeline/HDRenderPipeline/Material/Eye/Editor.meta
-
222ScriptableRenderPipeline/HDRenderPipeline/Material/Eye/Editor/BaseEyeUI.cs
-
7ScriptableRenderPipeline/HDRenderPipeline/Material/Eye/Editor/BaseEyeUI.cs.meta
-
629ScriptableRenderPipeline/HDRenderPipeline/Material/Eye/Editor/EyeUI.cs
-
7ScriptableRenderPipeline/HDRenderPipeline/Material/Eye/Editor/EyeUI.cs.meta
-
331ScriptableRenderPipeline/HDRenderPipeline/Material/Eye/Eye.cs
-
5ScriptableRenderPipeline/HDRenderPipeline/Material/Eye/Eye.cs.meta
-
179ScriptableRenderPipeline/HDRenderPipeline/Material/Eye/Eye.hlsl
-
5ScriptableRenderPipeline/HDRenderPipeline/Material/Eye/Eye.hlsl.meta
-
328ScriptableRenderPipeline/HDRenderPipeline/Material/Eye/Eye.shader
-
5ScriptableRenderPipeline/HDRenderPipeline/Material/Eye/Eye.shader.meta
-
984ScriptableRenderPipeline/HDRenderPipeline/Material/Eye/EyeData.hlsl
-
7ScriptableRenderPipeline/HDRenderPipeline/Material/Eye/EyeData.hlsl.meta
-
192ScriptableRenderPipeline/HDRenderPipeline/Material/Eye/EyeProperties.hlsl
-
5ScriptableRenderPipeline/HDRenderPipeline/Material/Eye/EyeProperties.hlsl.meta
-
2ScriptableRenderPipeline/HDRenderPipeline/Material/Fabric/Fabric.shader
-
5ScriptableRenderPipeline/HDRenderPipeline/Material/Hair/Hair.hlsl
-
10ScriptableRenderPipeline/HDRenderPipeline/Material/Vegetation.meta
-
10ScriptableRenderPipeline/HDRenderPipeline/Material/Vegetation/Editor.meta
-
460ScriptableRenderPipeline/HDRenderPipeline/Material/Vegetation/Editor/BaseVegetationUI.cs
-
13ScriptableRenderPipeline/HDRenderPipeline/Material/Vegetation/Editor/BaseVegetationUI.cs.meta
-
749ScriptableRenderPipeline/HDRenderPipeline/Material/Vegetation/Editor/VegetationUI.cs
-
13ScriptableRenderPipeline/HDRenderPipeline/Material/Vegetation/Editor/VegetationUI.cs.meta
-
519ScriptableRenderPipeline/HDRenderPipeline/Material/Vegetation/Vegetation.shader
-
10ScriptableRenderPipeline/HDRenderPipeline/Material/Vegetation/Vegetation.shader.meta
-
269ScriptableRenderPipeline/HDRenderPipeline/Material/Vegetation/VegetationData.hlsl
-
10ScriptableRenderPipeline/HDRenderPipeline/Material/Vegetation/VegetationData.hlsl.meta
-
176ScriptableRenderPipeline/HDRenderPipeline/Material/Vegetation/VegetationDataMeshModification.hlsl
-
10ScriptableRenderPipeline/HDRenderPipeline/Material/Vegetation/VegetationDataMeshModification.hlsl.meta
-
21ScriptableRenderPipeline/HDRenderPipeline/Material/Vegetation/VegetationProperties.hlsl
-
10ScriptableRenderPipeline/HDRenderPipeline/Material/Vegetation/VegetationProperties.hlsl.meta
-
56ScriptableRenderPipeline/HDRenderPipeline/Material/Vegetation/VegetationWind.hlsl
-
10ScriptableRenderPipeline/HDRenderPipeline/Material/Vegetation/VegetationWind.hlsl.meta
|
|||
fileFormatVersion: 2 |
|||
guid: 5cacfca84329cc344aab142e0642329b |
|||
folderAsset: yes |
|||
timeCreated: 1497326931 |
|||
licenseType: Free |
|||
timeCreated: 1509660636 |
|||
licenseType: Pro |
|||
externalObjects: {} |
|||
userData: |
|||
assetBundleName: |
|||
assetBundleVariant: |
|||
|
|||
using UnityEngine.Rendering; |
|||
|
|||
namespace UnityEngine.Experimental.Rendering.HDPipeline |
|||
{ |
|||
public partial class Eye : RenderPipelineMaterial |
|||
{ |
|||
[GenerateHLSL(PackingRules.Exact)] |
|||
public enum MaterialId |
|||
{ |
|||
LitSSS = 0, |
|||
LitStandard = 1, |
|||
LitUnused0 = 2, |
|||
LitUnused1 = 3, |
|||
LitAniso = 4, // Should be the last as it is not setup by the users but generated based on anisotropy property
|
|||
LitSpecular = 5, // Should be the last as it is not setup by the users but generated based on anisotropy property and specular
|
|||
}; |
|||
|
|||
[GenerateHLSL] |
|||
public enum MaterialFeatureFlags |
|||
{ |
|||
LitSSS = 1 << 12, |
|||
LitStandard = 1 << 13, |
|||
LitAniso = 1 << 14, |
|||
LitSpecular = 1 << 15 |
|||
} |
|||
|
|||
//-----------------------------------------------------------------------------
|
|||
// SurfaceData
|
|||
//-----------------------------------------------------------------------------
|
|||
|
|||
// Main structure that store the user data (i.e user input of master node in material graph)
|
|||
[GenerateHLSL(PackingRules.Exact, false, true, 1000)] |
|||
public struct SurfaceData |
|||
{ |
|||
[SurfaceDataAttributes("Base Color", false, true)] |
|||
public Vector3 baseColor; |
|||
[SurfaceDataAttributes("Specular Occlusion")] |
|||
public float specularOcclusion; |
|||
|
|||
[SurfaceDataAttributes("Normal", true)] |
|||
public Vector3 normalWS; |
|||
[SurfaceDataAttributes("Smoothness")] |
|||
public float perceptualSmoothness; |
|||
[SurfaceDataAttributes("Material ID")] |
|||
public int materialId; |
|||
|
|||
[SurfaceDataAttributes("Ambient Occlusion")] |
|||
public float ambientOcclusion; |
|||
|
|||
// standard
|
|||
[SurfaceDataAttributes("Tangent", true)] |
|||
public Vector3 tangentWS; |
|||
[SurfaceDataAttributes("Anisotropy")] |
|||
public float anisotropy; // anisotropic ratio(0->no isotropic; 1->full anisotropy in tangent direction)
|
|||
[SurfaceDataAttributes("Specular")] |
|||
public float specular; // 0.02, 0.04, 0.16, 0.2
|
|||
|
|||
// SSS
|
|||
[SurfaceDataAttributes("Subsurface Radius")] |
|||
public float subsurfaceRadius; |
|||
[SurfaceDataAttributes("Thickness")] |
|||
public float thickness; |
|||
[SurfaceDataAttributes("Subsurface Profile")] |
|||
public int subsurfaceProfile; |
|||
|
|||
// SpecColor
|
|||
[SurfaceDataAttributes("Specular Color", false, true)] |
|||
public Vector3 specularColor; |
|||
}; |
|||
|
|||
//-----------------------------------------------------------------------------
|
|||
// BSDFData
|
|||
//-----------------------------------------------------------------------------
|
|||
|
|||
[GenerateHLSL(PackingRules.Exact)] |
|||
public enum TransmissionType |
|||
{ |
|||
None = 0, |
|||
Regular = 1, |
|||
ThinObject = 2, |
|||
}; |
|||
|
|||
[GenerateHLSL(PackingRules.Exact, false, true, 1030)] |
|||
public struct BSDFData |
|||
{ |
|||
[SurfaceDataAttributes("", false, true)] |
|||
public Vector3 diffuseColor; |
|||
|
|||
public Vector3 fresnel0; |
|||
|
|||
public float specularOcclusion; |
|||
|
|||
[SurfaceDataAttributes("", true)] |
|||
public Vector3 normalWS; |
|||
public float perceptualRoughness; |
|||
public float roughness; |
|||
public int materialId; |
|||
|
|||
// standard
|
|||
[SurfaceDataAttributes("", true)] |
|||
public Vector3 tangentWS; |
|||
[SurfaceDataAttributes("", true)] |
|||
public Vector3 bitangentWS; |
|||
public float roughnessT; |
|||
public float roughnessB; |
|||
public float anisotropy; |
|||
|
|||
// fold into fresnel0
|
|||
|
|||
// SSS
|
|||
public float subsurfaceRadius; |
|||
public float thickness; |
|||
public int subsurfaceProfile; |
|||
public bool enableTransmission; // Read from the SSS profile
|
|||
public bool useThinObjectMode; // Read from the SSS profile
|
|||
public Vector3 transmittance; |
|||
|
|||
// SpecColor
|
|||
// fold into fresnel0
|
|||
}; |
|||
|
|||
//-----------------------------------------------------------------------------
|
|||
// RenderLoop management
|
|||
//-----------------------------------------------------------------------------
|
|||
|
|||
[GenerateHLSL(PackingRules.Exact)] |
|||
public enum GBufferMaterial |
|||
{ |
|||
// Note: This count doesn't include the velocity buffer. On shader and csharp side the velocity buffer will be added by the framework
|
|||
Count = (ShaderConfig.k_PackgbufferInU16 == 1) ? 2 : 4 |
|||
}; |
|||
|
|||
//-----------------------------------------------------------------------------
|
|||
// GBuffer management
|
|||
//-----------------------------------------------------------------------------
|
|||
|
|||
public override int GetMaterialGBufferCount() { return (int)GBufferMaterial.Count; } |
|||
|
|||
public override void GetMaterialGBufferDescription(out RenderTextureFormat[] RTFormat, out RenderTextureReadWrite[] RTReadWrite) |
|||
{ |
|||
RTFormat = new RenderTextureFormat[(int)GBufferMaterial.Count]; |
|||
RTReadWrite = new RenderTextureReadWrite[(int)GBufferMaterial.Count]; |
|||
|
|||
if (ShaderConfig.s_PackgbufferInU16 == 1) |
|||
{ |
|||
// TODO: Just discovered that Unity doesn't support unsigned 16 RT format.
|
|||
RTFormat[0] = RenderTextureFormat.ARGBInt; RTReadWrite[0] = RenderTextureReadWrite.Linear; |
|||
RTFormat[1] = RenderTextureFormat.ARGBInt; RTReadWrite[1] = RenderTextureReadWrite.Linear; |
|||
} |
|||
else |
|||
{ |
|||
RTFormat[0] = RenderTextureFormat.ARGB32; RTReadWrite[0] = RenderTextureReadWrite.sRGB; |
|||
RTFormat[1] = RenderTextureFormat.ARGB2101010; RTReadWrite[1] = RenderTextureReadWrite.Linear; |
|||
RTFormat[2] = RenderTextureFormat.ARGB32; RTReadWrite[2] = RenderTextureReadWrite.Linear; |
|||
RTFormat[3] = RenderTextureFormat.RGB111110Float; RTReadWrite[3] = RenderTextureReadWrite.Linear; |
|||
} |
|||
} |
|||
|
|||
//-----------------------------------------------------------------------------
|
|||
// Init precomputed texture
|
|||
//-----------------------------------------------------------------------------
|
|||
|
|||
bool m_isInit; |
|||
|
|||
// For image based lighting
|
|||
Material m_InitPreFGD; |
|||
RenderTexture m_PreIntegratedFGD; |
|||
|
|||
// For area lighting - We pack all texture inside a texture array to reduce the number of resource required
|
|||
Texture2DArray m_LtcData; // 0: m_LtcGGXMatrix - RGBA, 2: m_LtcDisneyDiffuseMatrix - RGBA, 3: m_LtcMultiGGXFresnelDisneyDiffuse - RGB, A unused
|
|||
|
|||
const int k_LtcLUTMatrixDim = 3; // size of the matrix (3x3)
|
|||
const int k_LtcLUTResolution = 64; |
|||
|
|||
|
|||
// Load LUT with one scalar in alpha of a tex2D
|
|||
void LoadLUT(Texture2DArray tex, int arrayElement, TextureFormat format, float[] LUTScalar) |
|||
{ |
|||
const int count = k_LtcLUTResolution * k_LtcLUTResolution; |
|||
Color[] pixels = new Color[count]; |
|||
|
|||
for (int i = 0; i < count; i++) |
|||
{ |
|||
pixels[i] = new Color(0, 0, 0, LUTScalar[i]); |
|||
} |
|||
|
|||
tex.SetPixels(pixels, arrayElement); |
|||
} |
|||
|
|||
// Load LUT with 3x3 matrix in RGBA of a tex2D (some part are zero)
|
|||
void LoadLUT(Texture2DArray tex, int arrayElement, TextureFormat format, double[,] LUTTransformInv) |
|||
{ |
|||
const int count = k_LtcLUTResolution * k_LtcLUTResolution; |
|||
Color[] pixels = new Color[count]; |
|||
|
|||
for (int i = 0; i < count; i++) |
|||
{ |
|||
// Both GGX and Disney Diffuse BRDFs have zero values in columns 1, 3, 5, 7.
|
|||
// Column 8 contains only ones.
|
|||
pixels[i] = new Color((float)LUTTransformInv[i, 0], |
|||
(float)LUTTransformInv[i, 2], |
|||
(float)LUTTransformInv[i, 4], |
|||
(float)LUTTransformInv[i, 6]); |
|||
} |
|||
|
|||
tex.SetPixels(pixels, arrayElement); |
|||
} |
|||
|
|||
// Special-case function for 'm_LtcMultiGGXFresnelDisneyDiffuse'.
|
|||
void LoadLUT(Texture2DArray tex, int arrayElement, TextureFormat format, float[] LtcGGXMagnitudeData, |
|||
float[] LtcGGXFresnelData, |
|||
float[] LtcDisneyDiffuseMagnitudeData) |
|||
{ |
|||
const int count = k_LtcLUTResolution * k_LtcLUTResolution; |
|||
Color[] pixels = new Color[count]; |
|||
|
|||
for (int i = 0; i < count; i++) |
|||
{ |
|||
// We store the result of the subtraction as a run-time optimization.
|
|||
// See the footnote 2 of "LTC Fresnel Approximation" by Stephen Hill.
|
|||
pixels[i] = new Color(LtcGGXMagnitudeData[i] - LtcGGXFresnelData[i], |
|||
LtcGGXFresnelData[i], LtcDisneyDiffuseMagnitudeData[i], 1); |
|||
} |
|||
|
|||
tex.SetPixels(pixels, arrayElement); |
|||
} |
|||
|
|||
public Eye() { } |
|||
|
|||
public override void Build(RenderPipelineResources renderPipelineResources) |
|||
{ |
|||
m_InitPreFGD = CoreUtils.CreateEngineMaterial("Hidden/HDRenderPipeline/PreIntegratedFGD"); |
|||
|
|||
// For DisneyDiffuse integration values goes from (0.5 to 1.53125). GGX need 0 to 1. Use float format.
|
|||
m_PreIntegratedFGD = new RenderTexture(128, 128, 0, RenderTextureFormat.RGB111110Float, RenderTextureReadWrite.Linear); |
|||
m_PreIntegratedFGD.filterMode = FilterMode.Bilinear; |
|||
m_PreIntegratedFGD.wrapMode = TextureWrapMode.Clamp; |
|||
m_PreIntegratedFGD.hideFlags = HideFlags.DontSave; |
|||
m_PreIntegratedFGD.Create(); |
|||
|
|||
m_LtcData = new Texture2DArray(k_LtcLUTResolution, k_LtcLUTResolution, 3, TextureFormat.RGBAHalf, false /*mipmap*/, true /* linear */) |
|||
{ |
|||
hideFlags = HideFlags.HideAndDontSave, |
|||
wrapMode = TextureWrapMode.Clamp, |
|||
filterMode = FilterMode.Bilinear |
|||
}; |
|||
|
|||
LoadLUT(m_LtcData, 0, TextureFormat.RGBAHalf, Lit.s_LtcGGXMatrixData); |
|||
LoadLUT(m_LtcData, 1, TextureFormat.RGBAHalf, Lit.s_LtcDisneyDiffuseMatrixData); |
|||
// TODO: switch to RGBA64 when it becomes available.
|
|||
LoadLUT(m_LtcData, 2, TextureFormat.RGBAHalf, Lit.s_LtcGGXMagnitudeData, Lit.s_LtcGGXFresnelData, Lit.s_LtcDisneyDiffuseMagnitudeData); |
|||
|
|||
m_LtcData.Apply(); |
|||
|
|||
m_isInit = false; |
|||
} |
|||
|
|||
public override void Cleanup() |
|||
{ |
|||
CoreUtils.Destroy(m_InitPreFGD); |
|||
|
|||
// TODO: how to delete RenderTexture ? or do we need to do it ?
|
|||
m_isInit = false; |
|||
} |
|||
|
|||
public override void RenderInit(CommandBuffer cmd) |
|||
{ |
|||
if (m_isInit) |
|||
return; |
|||
|
|||
using (new ProfilingSample(cmd, "Init PreFGD")) |
|||
{ |
|||
CoreUtils.DrawFullScreen(cmd, m_InitPreFGD, new RenderTargetIdentifier(m_PreIntegratedFGD)); |
|||
} |
|||
m_isInit = true; |
|||
} |
|||
|
|||
public override void Bind() |
|||
{ |
|||
Shader.SetGlobalTexture("_PreIntegratedFGD", m_PreIntegratedFGD); |
|||
Shader.SetGlobalTexture("_LtcData", m_LtcData); |
|||
} |
|||
} |
|||
} |
|||
��u s i n g U n i t y E n g i n e ; |
|||
|
|||
[ E x e c u t e I n E d i t M o d e ] |
|||
[ R e q u i r e C o m p o n e n t ( t y p e o f ( R e n d e r e r ) ) ] |
|||
p u b l i c c l a s s E y e : M o n o B e h a v i o u r { |
|||
|
|||
p u b l i c e n u m L o o k A x i s { |
|||
X P o s i t i v e = 0 , |
|||
Y P o s i t i v e , |
|||
Z P o s i t i v e , |
|||
X N e g a t i v e , |
|||
Y N e g a t i v e , |
|||
Z N e g a t i v e |
|||
} |
|||
|
|||
p u b l i c T r a n s f o r m m _ E y e B o n e ; |
|||
p u b l i c L o o k A x i s m _ L o o k A x i s I n O b j e c t S p a c e ; |
|||
|
|||
p r i v a t e R e n d e r e r m _ R e n d e r e r ; |
|||
p r i v a t e M a t e r i a l P r o p e r t y B l o c k m _ P r o p e r t y B l o c k ; |
|||
|
|||
v o i d A w a k e ( ) { |
|||
m _ R e n d e r e r = G e t C o m p o n e n t < R e n d e r e r > ( ) ; |
|||
m _ P r o p e r t y B l o c k = n e w M a t e r i a l P r o p e r t y B l o c k ( ) ; |
|||
} |
|||
|
|||
V e c t o r 3 G e t L o o k V e c t o r ( T r a n s f o r m b o n e ) { |
|||
s w i t c h ( m _ L o o k A x i s I n O b j e c t S p a c e ) { |
|||
c a s e L o o k A x i s . X P o s i t i v e : r e t u r n b o n e . r i g h t ; |
|||
c a s e L o o k A x i s . Y P o s i t i v e : r e t u r n b o n e . u p ; |
|||
c a s e L o o k A x i s . Z P o s i t i v e : r e t u r n b o n e . f o r w a r d ; |
|||
c a s e L o o k A x i s . X N e g a t i v e : r e t u r n - b o n e . r i g h t ; |
|||
c a s e L o o k A x i s . Y N e g a t i v e : r e t u r n - b o n e . u p ; |
|||
c a s e L o o k A x i s . Z N e g a t i v e : r e t u r n - b o n e . f o r w a r d ; |
|||
d e f a u l t : r e t u r n V e c t o r 3 . z e r o ; |
|||
} |
|||
} |
|||
|
|||
v o i d U p d a t e ( ) { |
|||
i f ( m _ R e n d e r e r = = n u l l | | m _ P r o p e r t y B l o c k = = n u l l | | m _ E y e B o n e = = n u l l ) r e t u r n ; |
|||
|
|||
m _ P r o p e r t y B l o c k . S e t V e c t o r ( " _ E y e L o o k V e c t o r " , G e t L o o k V e c t o r ( m _ E y e B o n e ) ) ; |
|||
m _ R e n d e r e r . S e t P r o p e r t y B l o c k ( m _ P r o p e r t y B l o c k ) ; |
|||
} |
|||
|
|||
} |
|||
|
|||
|
|||
//----------------------------------------------------------------------------- |
|||
// SurfaceData and BSDFData |
|||
//----------------------------------------------------------------------------- |
|||
|
|||
// SurfaceData is define in Eye.cs which generate Eye.cs.hlsl |
|||
#include "Eye.cs.hlsl" |
|||
#include "../Lit/SubsurfaceScatteringSettings.cs.hlsl" |
|||
#ifndef EYE |
|||
#define EYE |
|||
#define WANT_SSS_CODE |
|||
#include "../LightEvaluationShare1.hlsl" |
|||
|
|||
void FillMaterialIdStandardData(float3 baseColor, float specular, float metallic, float roughness, float3 normalWS, float3 tangentWS, float anisotropy, inout BSDFData bsdfData) |
|||
void EyeParallax(inout float2 uv, float3 normalWS, float3 viewWS) |
|||
bsdfData.diffuseColor = baseColor*0.5; |
|||
bsdfData.fresnel0 = baseColor; |
|||
|
|||
// TODO: encode specular |
|||
|
|||
bsdfData.tangentWS = tangentWS; |
|||
bsdfData.bitangentWS = cross(normalWS, tangentWS); |
|||
ConvertAnisotropyToRoughness(roughness, anisotropy, bsdfData.roughnessT, bsdfData.roughnessB); |
|||
bsdfData.anisotropy = 0; |
|||
} |
|||
|
|||
//----------------------------------------------------------------------------- |
|||
// conversion function for forward |
|||
//----------------------------------------------------------------------------- |
|||
|
|||
BSDFData ConvertSurfaceDataToBSDFData(SurfaceData surfaceData) |
|||
{ |
|||
ApplyDebugToSurfaceData(surfaceData); |
|||
|
|||
BSDFData bsdfData; |
|||
ZERO_INITIALIZE(BSDFData, bsdfData); |
|||
|
|||
bsdfData.specularOcclusion = surfaceData.specularOcclusion; |
|||
bsdfData.normalWS = surfaceData.normalWS; |
|||
bsdfData.perceptualRoughness = PerceptualSmoothnessToPerceptualRoughness(surfaceData.perceptualSmoothness); |
|||
bsdfData.roughness = PerceptualRoughnessToRoughness(bsdfData.perceptualRoughness); |
|||
bsdfData.materialId = surfaceData.materialId; |
|||
|
|||
FillMaterialIdStandardData(surfaceData.baseColor, surfaceData.specular, 0, bsdfData.roughness, surfaceData.normalWS, surfaceData.tangentWS, surfaceData.anisotropy, bsdfData); |
|||
bsdfData.materialId = surfaceData.anisotropy > 0.0 ? MATERIALID_LIT_ANISO : bsdfData.materialId; |
|||
|
|||
FillMaterialIdSSSData(surfaceData.baseColor, surfaceData.subsurfaceProfile, surfaceData.subsurfaceRadius, surfaceData.thickness, bsdfData); |
|||
float height = _EyeIrisDepth * saturate( 1.0 - 0.736 * _EyeIrisRadius * _EyeIrisRadius ); |
|||
return bsdfData; |
|||
} |
|||
// Refraction |
|||
float w = _EyeIOR * dot( normalWS, viewWS ); |
|||
float k = sqrt( 1.0 + ( w - _EyeIOR ) * ( w + _EyeIOR ) ); |
|||
float3 refractedW = ( w - k ) * normalWS - _EyeIOR * viewWS; |
|||
float4 EncodeSplitLightingGBuffer0(SurfaceData surfaceData) |
|||
{ |
|||
return float4(surfaceData.baseColor, 1.0); |
|||
} |
|||
float cosAlpha = dot(_EyeLookVector, -refractedW); |
|||
float dist = height / cosAlpha; |
|||
float4 EncodeSplitLightingGBuffer1(SurfaceData surfaceData) |
|||
{ |
|||
return float4(surfaceData.subsurfaceRadius, 1.0, 0.0, PackByte(surfaceData.subsurfaceProfile)); //TODO: Eye UI |
|||
} |
|||
float3 offsetW = dist * refractedW; |
|||
float2 offsetL = mul(offsetW, (float3x2)GetObjectToWorldMatrix()); |
|||
//----------------------------------------------------------------------------- |
|||
// bake lighting function |
|||
//----------------------------------------------------------------------------- |
|||
|
|||
// GetBakedDiffuseLigthing function compute the bake lighting + emissive color to be store in emissive buffer (Deferred case) |
|||
// In forward it must be add to the final contribution. |
|||
// This function require the 3 structure surfaceData, builtinData, bsdfData because it may require both the engine side data, and data that will not be store inside the gbuffer. |
|||
float3 GetBakedDiffuseLigthing(SurfaceData surfaceData, BuiltinData builtinData, BSDFData bsdfData, PreLightData preLightData) |
|||
{ |
|||
// Premultiply bake diffuse lighting information with DisneyDiffuse pre-integration |
|||
return builtinData.bakeDiffuseLighting * preLightData.diffuseFGD * surfaceData.ambientOcclusion * bsdfData.diffuseColor + builtinData.emissiveColor; |
|||
float m = SAMPLE_TEXTURE2D(_MaskMap, sampler_MaskMap, uv).r; |
|||
uv += float2(m, -m) * offsetL; |
|||
//----------------------------------------------------------------------------- |
|||
// light transport functions |
|||
//----------------------------------------------------------------------------- |
|||
|
|||
LightTransportData GetLightTransportData(SurfaceData surfaceData, BuiltinData builtinData, BSDFData bsdfData) |
|||
{ |
|||
LightTransportData lightTransportData; |
|||
|
|||
// diffuseColor for lightmapping should basically be diffuse color. |
|||
// But rough metals (black diffuse) still scatter quite a lot of light around, so |
|||
// we want to take some of that into account too. |
|||
|
|||
lightTransportData.diffuseColor = bsdfData.diffuseColor; |
|||
lightTransportData.emissiveColor = builtinData.emissiveColor; |
|||
|
|||
return lightTransportData; |
|||
} |
|||
|
|||
//----------------------------------------------------------------------------- |
|||
// LightLoop related function (Only include if required) |
|||
// HAS_LIGHTLOOP is define in Lighting.hlsl |
|||
//----------------------------------------------------------------------------- |
|||
|
|||
#ifdef HAS_LIGHTLOOP |
|||
|
|||
//----------------------------------------------------------------------------- |
|||
// BSDF share between directional light, punctual light and area light (reference) |
|||
//----------------------------------------------------------------------------- |
|||
|
|||
#define BSDF BSDF_EYE |
|||
|
|||
|
|||
void BSDF_EYE(float3 V, float3 L, float3 positionWS, PreLightData preLightData, BSDFData bsdfData, |
|||
out float3 diffuseLighting, |
|||
out float3 specularLighting) |
|||
{ |
|||
// Optimized math. Ref: PBR Diffuse Lighting for GGX + Smith Microsurfaces (slide 114). |
|||
float NdotL = saturate(dot(bsdfData.normalWS, L)); // Must have the same value without the clamp |
|||
float NdotV = preLightData.NdotV; // Get the unaltered (geometric) version |
|||
float LdotV = dot(L, V); |
|||
float invLenLV = rsqrt(abs(2 * LdotV + 2)); // invLenLV = rcp(length(L + V)) |
|||
float NdotH = saturate((NdotL + NdotV) * invLenLV); |
|||
float LdotH = saturate(invLenLV * LdotV + invLenLV); |
|||
|
|||
NdotV = max(NdotV, MIN_N_DOT_V); // Use the modified (clamped) version |
|||
|
|||
float3 F = F_Schlick(bsdfData.fresnel0, LdotH); |
|||
|
|||
float DV; |
|||
|
|||
if (bsdfData.materialId == MATERIALID_LIT_ANISO) |
|||
{ |
|||
float3 H = (L + V) * invLenLV; |
|||
// For anisotropy we must not saturate these values |
|||
float TdotH = dot(bsdfData.tangentWS, H); |
|||
float TdotL = dot(bsdfData.tangentWS, L); |
|||
float BdotH = dot(bsdfData.bitangentWS, H); |
|||
float BdotL = dot(bsdfData.bitangentWS, L); |
|||
|
|||
bsdfData.roughnessT = ClampRoughnessForAnalyticalLights(bsdfData.roughnessT); |
|||
bsdfData.roughnessB = ClampRoughnessForAnalyticalLights(bsdfData.roughnessB); |
|||
|
|||
// TODO: Do comparison between this correct version and the one from isotropic and see if there is any visual difference |
|||
DV = DV_SmithJointGGXAniso(TdotH, BdotH, NdotH, |
|||
preLightData.TdotV, preLightData.BdotV, preLightData.NdotV, |
|||
TdotL, BdotL, NdotL, |
|||
bsdfData.roughnessT, bsdfData.roughnessB |
|||
#ifdef LIT_USE_BSDF_PRE_LAMBDAV |
|||
, preLightData.partLambdaV); |
|||
#else |
|||
); |
|||
#endif |
|||
} |
|||
else |
|||
{ |
|||
bsdfData.roughness = ClampRoughnessForAnalyticalLights(bsdfData.roughness); |
|||
|
|||
DV = DV_SmithJointGGX(NdotH, NdotL, NdotV, bsdfData.roughness |
|||
#ifdef LIT_USE_BSDF_PRE_LAMBDAV |
|||
, preLightData partLambdaV); |
|||
#else |
|||
); |
|||
#endif |
|||
} |
|||
specularLighting = 10 * F * DV; |
|||
|
|||
#ifdef LIT_DIFFUSE_LAMBERT_BRDF |
|||
float diffuseTerm = Lambert(); |
|||
#elif LIT_DIFFUSE_GGX_BRDF |
|||
float3 diffuseTerm = DiffuseGGX(bsdfData.diffuseColor, NdotV, NdotL, NdotH, LdotV, bsdfData.roughness); |
|||
#else |
|||
float diffuseTerm = DisneyDiffuse(NdotV, NdotL, LdotV, bsdfData.perceptualRoughness); |
|||
#endif |
|||
|
|||
diffuseLighting = bsdfData.diffuseColor * diffuseTerm; |
|||
} |
|||
|
|||
#endif // #ifdef HAS_LIGHTLOOP |
|||
|
|||
#include "../LightEvaluationShare2.hlsl" |
|||
#endif//EYE |
|||
|
|||
fileFormatVersion: 2 |
|||
guid: 04104d8f9ef87224fa781b53467029a1 |
|||
timeCreated: 1497327754 |
|||
licenseType: Free |
|||
timeCreated: 1509666487 |
|||
licenseType: Pro |
|||
externalObjects: {} |
|||
defaultTextures: [] |
|||
userData: |
|||
assetBundleName: |
|||
|
|||
fileFormatVersion: 2 |
|||
guid: 77d8497f1dc6a9d49a9673c6ee9dd173 |
|||
timeCreated: 1497329675 |
|||
licenseType: Free |
|||
timeCreated: 1509660640 |
|||
licenseType: Pro |
|||
externalObjects: {} |
|||
defaultTextures: [] |
|||
userData: |
|||
assetBundleName: |
|||
984
ScriptableRenderPipeline/HDRenderPipeline/Material/Eye/EyeData.hlsl
文件差异内容过多而无法显示
查看文件
文件差异内容过多而无法显示
查看文件
|
|||
fileFormatVersion: 2 |
|||
guid: 99fa4d9af3aaaf748af345101d8b5aea |
|||
timeCreated: 1497327794 |
|||
licenseType: Free |
|||
guid: 7624a88859fa9b347966fcd774d7befb |
|||
timeCreated: 1509660850 |
|||
licenseType: Pro |
|||
externalObjects: {} |
|||
defaultTextures: [] |
|||
userData: |
|||
assetBundleName: |
|||
|
|||
CBUFFER_START(_PerMaterial) |
|||
|
|||
float _HorizonFade; |
|||
|
|||
float _PPDMaxSamples; |
|||
float _PPDMinSamples; |
|||
float _PPDLodThreshold; |
|||
|
|||
float _IrisDepth; |
|||
float _IrisRadius; |
|||
float _Ior; |
|||
float3 _frontNormalWS; |
|||
|
|||
TEXTURE2D(_DiffuseLightingMap); |
|||
SAMPLER2D(sampler_DiffuseLightingMap); |
|||
|
|||
TEXTURE2D(_DistortionVectorMap); |
|||
SAMPLER2D(sampler_DistortionVectorMap); |
|||
|
|||
float3 _EmissiveColor; |
|||
TEXTURE2D(_EmissiveColorMap); |
|||
SAMPLER2D(sampler_EmissiveColorMap); |
|||
float _EmissiveIntensity; |
|||
|
|||
// Caution: C# code in BaseLitUI.cs call LightmapEmissionFlagsProperty() which assume that there is an existing "_EmissionColor" |
|||
// value that exist to identify if the GI emission need to be enabled. |
|||
// In our case we don't use such a mechanism but need to keep the code quiet. We declare the value and always enable it. |
|||
// TODO: Fix the code in legacy unity so we can customize the beahvior for GI |
|||
float3 _EmissionColor; |
|||
|
|||
// Wind |
|||
float _InitialBend; |
|||
float _Stiffness; |
|||
float _Drag; |
|||
float _ShiverDrag; |
|||
float _ShiverDirectionality; |
|||
|
|||
#ifndef LAYERED_LIT_SHADER |
|||
|
|||
// Set of users variables |
|||
float4 _BaseColor; |
|||
TEXTURE2D(_BaseColorMap); |
|||
SAMPLER2D(sampler_BaseColorMap); |
|||
float4 _BaseColorMap_ST; |
|||
|
|||
float _Smoothness; |
|||
TEXTURE2D(_MaskMap); |
|||
SAMPLER2D(sampler_MaskMap); |
|||
TEXTURE2D(_SpecularOcclusionMap); |
|||
SAMPLER2D(sampler_SpecularOcclusionMap); |
|||
|
|||
TEXTURE2D(_NormalMap); |
|||
SAMPLER2D(sampler_NormalMap); |
|||
TEXTURE2D(_NormalMapOS); |
|||
SAMPLER2D(sampler_NormalMapOS); |
|||
|
|||
float _NormalScale; |
|||
|
|||
TEXTURE2D(_HeightMap); |
|||
SAMPLER2D(sampler_HeightMap); |
|||
float4 _HeightMap_TexelSize; // Unity facility. This will provide the size of the heightmap to the shader |
|||
|
|||
float _HeightAmplitude; |
|||
float _HeightCenter; |
|||
|
|||
TEXTURE2D(_TangentMap); |
|||
SAMPLER2D(sampler_TangentMap); |
|||
TEXTURE2D(_TangentMapOS); |
|||
SAMPLER2D(sampler_TangentMapOS); |
|||
|
|||
|
|||
int _MaterialID; |
|||
int _SubsurfaceProfile; |
|||
float _SubsurfaceRadius; |
|||
float _Thickness; |
|||
TEXTURE2D(_SubsurfaceRadiusMap); |
|||
SAMPLER2D(sampler_SubsurfaceRadiusMap); |
|||
TEXTURE2D(_ThicknessMap); |
|||
SAMPLER2D(sampler_ThicknessMap); |
|||
|
|||
float4 _SpecularColor; |
|||
TEXTURE2D(_SpecularColorMap); |
|||
SAMPLER2D(sampler_SpecularColorMap); |
|||
|
|||
float _TexWorldScale; |
|||
float4 _UVMappingMask; |
|||
float4 _UVDetailsMappingMask; |
|||
|
|||
#else // LAYERED_LIT_SHADER |
|||
|
|||
// Set of users variables |
|||
#define PROP_DECL(type, name) type name##0, name##1, name##2, name##3 |
|||
// sampler are share by texture type inside a layered material but we need to support that a particualr layer have no texture, so we take the first sampler of available texture as the share one |
|||
// mean we must declare all sampler |
|||
#define PROP_DECL_TEX2D(name)\ |
|||
TEXTURE2D(MERGE_NAME(name, 0)); \ |
|||
SAMPLER2D(MERGE_NAME(MERGE_NAME(sampler, name), 0)); \ |
|||
TEXTURE2D(MERGE_NAME(name, 1)); \ |
|||
SAMPLER2D(MERGE_NAME(MERGE_NAME(sampler, name), 1)); \ |
|||
TEXTURE2D(MERGE_NAME(name, 2)); \ |
|||
SAMPLER2D(MERGE_NAME(MERGE_NAME(sampler, name), 2)); \ |
|||
TEXTURE2D(MERGE_NAME(name, 3)); \ |
|||
SAMPLER2D(MERGE_NAME(MERGE_NAME(sampler, name), 3)) |
|||
|
|||
// Set of users variables |
|||
PROP_DECL(float4, _BaseColor); |
|||
PROP_DECL_TEX2D(_BaseColorMap); |
|||
float4 _BaseColorMap0_ST; |
|||
float4 _BaseColorMap1_ST; |
|||
float4 _BaseColorMap2_ST; |
|||
float4 _BaseColorMap3_ST; |
|||
|
|||
PROP_DECL(float, _Smoothness); |
|||
PROP_DECL_TEX2D(_MaskMap); |
|||
PROP_DECL_TEX2D(_SpecularOcclusionMap); |
|||
|
|||
PROP_DECL_TEX2D(_NormalMap); |
|||
PROP_DECL_TEX2D(_NormalMapOS); |
|||
PROP_DECL(float, _NormalScale); |
|||
float4 _NormalMap0_TexelSize; // Unity facility. This will provide the size of the base normal to the shader |
|||
|
|||
PROP_DECL_TEX2D(_HeightMap); |
|||
float4 _HeightMap0_TexelSize; |
|||
float4 _HeightMap1_TexelSize; |
|||
float4 _HeightMap2_TexelSize; |
|||
float4 _HeightMap3_TexelSize; |
|||
|
|||
PROP_DECL_TEX2D(_DetailMask); |
|||
PROP_DECL_TEX2D(_DetailMap); |
|||
float4 _DetailMap0_ST; |
|||
float4 _DetailMap1_ST; |
|||
float4 _DetailMap2_ST; |
|||
float4 _DetailMap3_ST; |
|||
PROP_DECL(float, _UVDetail); |
|||
PROP_DECL(float, _DetailFuzz1); |
|||
PROP_DECL(float, _DetailAlbedoScale); |
|||
PROP_DECL(float, _DetailNormalScale); |
|||
PROP_DECL(float, _DetailSmoothnessScale); |
|||
|
|||
PROP_DECL(float, _HeightAmplitude); |
|||
PROP_DECL(float, _HeightCenter); |
|||
|
|||
TEXTURE2D(_LayerMaskMap); |
|||
SAMPLER2D(sampler_LayerMaskMap); |
|||
|
|||
float _BlendUsingHeight1; |
|||
float _BlendUsingHeight2; |
|||
float _BlendUsingHeight3; |
|||
PROP_DECL(float, _LayerHeightAmplitude); |
|||
PROP_DECL(float, _LayerCenterOffset); |
|||
PROP_DECL(float, _MinimumOpacity); |
|||
PROP_DECL(float, _OpacityAsDensity); |
|||
float _InheritBaseNormal1; |
|||
float _InheritBaseNormal2; |
|||
float _InheritBaseNormal3; |
|||
float _InheritBaseHeight1; |
|||
float _InheritBaseHeight2; |
|||
float _InheritBaseHeight3; |
|||
float _InheritBaseColor1; |
|||
float _InheritBaseColor2; |
|||
float _InheritBaseColor3; |
|||
float _InheritBaseColorThreshold1; |
|||
float _InheritBaseColorThreshold2; |
|||
float _InheritBaseColorThreshold3; |
|||
float _LayerTilingBlendMask; |
|||
PROP_DECL(float, _LayerTiling); |
|||
|
|||
float _TexWorldScaleBlendMask; |
|||
PROP_DECL(float, _TexWorldScale); |
|||
PROP_DECL(float4, _UVMappingMask); |
|||
PROP_DECL(float4, _UVDetailsMappingMask); |
|||
|
|||
#endif // LAYERED_LIT_SHADER |
|||
|
|||
// Tessellation specific |
|||
|
|||
#ifdef TESSELLATION_ON |
|||
float _TessellationFactor; |
|||
float _TessellationFactorMinDistance; |
|||
float _TessellationFactorMaxDistance; |
|||
float _TessellationFactorTriangleSize; |
|||
float _TessellationShapeFactor; |
|||
float _TessellationBackFaceCullEpsilon; |
|||
float _TessellationObjectScale; |
|||
float _TessellationTilingScale; |
|||
#endif |
|||
|
|||
CBUFFER_END |
|||
float _EyeIrisDepth; |
|||
float _EyeIrisRadius; |
|||
float _EyeIOR; |
|||
float3 _EyeLookVector; |
|||
|
|||
fileFormatVersion: 2 |
|||
guid: 6a31ec614cff66b4d8bf9920c4a0b862 |
|||
timeCreated: 1497327650 |
|||
licenseType: Free |
|||
timeCreated: 1509663820 |
|||
licenseType: Pro |
|||
externalObjects: {} |
|||
defaultTextures: [] |
|||
userData: |
|||
assetBundleName: |
|||
|
|||
fileFormatVersion: 2 |
|||
guid: d528849495b23584f85182d370ce3e97 |
|||
folderAsset: yes |
|||
timeCreated: 1509471263 |
|||
licenseType: Pro |
|||
DefaultImporter: |
|||
externalObjects: {} |
|||
userData: |
|||
assetBundleName: |
|||
assetBundleVariant: |
|||
|
|||
fileFormatVersion: 2 |
|||
guid: 54b9705bf1629c84182fedacf5a1ef62 |
|||
folderAsset: yes |
|||
timeCreated: 1509479695 |
|||
licenseType: Pro |
|||
DefaultImporter: |
|||
externalObjects: {} |
|||
userData: |
|||
assetBundleName: |
|||
assetBundleVariant: |
|||
|
|||
using System; |
|||
using UnityEngine; |
|||
using UnityEngine.Experimental.Rendering.HDPipeline; |
|||
|
|||
namespace UnityEditor.Experimental.Rendering.HDPipeline |
|||
{ |
|||
// A Material can be authored from the shader graph or by hand. When written by hand we need to provide an inspector.
|
|||
// Such a Material will share some properties between it various variant (shader graph variant or hand authored variant).
|
|||
// This is the purpose of BaseLitGUI. It contain all properties that are common to all Material based on Lit template.
|
|||
// For the default hand written Lit material see LitUI.cs that contain specific properties for our default implementation.
|
|||
public abstract class BaseVegetationGUI : BaseUnlitGUI |
|||
{ |
|||
protected static class StylesBaseLit |
|||
{ |
|||
public static GUIContent doubleSidedNormalModeText = new GUIContent("Normal mode", "This will modify the normal base on the selected mode. None: untouch, Mirror: Mirror the normal with vertex normal plane, Flip: Flip the normal"); |
|||
public static GUIContent depthOffsetEnableText = new GUIContent("Enable Depth Offset", "EnableDepthOffset on this shader (Use with heightmap)"); |
|||
|
|||
// Displacement mapping (POM, tessellation, per vertex)
|
|||
//public static GUIContent enablePerPixelDisplacementText = new GUIContent("Enable Per Pixel Displacement", "");
|
|||
|
|||
public static GUIContent displacementModeText = new GUIContent("Displacement mode", "Apply heightmap displacement to the selected element: Vertex, pixel or tessellated vertex. Pixel displacement must be use with flat surfaces, it is an expensive features and typical usage is paved road."); |
|||
public static GUIContent lockWithObjectScaleText = new GUIContent("Lock with object scale", "Displacement mapping will take the absolute value of the scale of the object into account."); |
|||
public static GUIContent lockWithTilingRateText = new GUIContent("Lock with height map tiling rate", "Displacement mapping will take the absolute value of the tiling rate of the height map into account."); |
|||
|
|||
// Material ID
|
|||
public static GUIContent materialIDText = new GUIContent("Material type", "Subsurface Scattering: enable for translucent materials such as skin, vegetation, fruit, marble, wax and milk."); |
|||
|
|||
// Per pixel displacement
|
|||
public static GUIContent ppdMinSamplesText = new GUIContent("Minimum steps", "Minimum steps (texture sample) to use with per pixel displacement mapping"); |
|||
public static GUIContent ppdMaxSamplesText = new GUIContent("Maximum steps", "Maximum steps (texture sample) to use with per pixel displacement mapping"); |
|||
public static GUIContent ppdLodThresholdText = new GUIContent("Fading mip level start", "Starting heightmap mipmap lod number where the parallax occlusion mapping effect start to disappear"); |
|||
public static GUIContent ppdPrimitiveLength = new GUIContent("Primitive length", "Dimensions of the primitive (with the scale of 1) to which the per-pixel displacement mapping is being applied. For example, the standard quad is 1 x 1 meter, while the standard plane is 10 x 10 meters."); |
|||
public static GUIContent ppdPrimitiveWidth = new GUIContent("Primitive width", "Dimensions of the primitive (with the scale of 1) to which the per-pixel displacement mapping is being applied. For example, the standard quad is 1 x 1 meter, while the standard plane is 10 x 10 meters."); |
|||
|
|||
// Tessellation
|
|||
public static string tessellationModeStr = "Tessellation Mode"; |
|||
public static readonly string[] tessellationModeNames = Enum.GetNames(typeof(TessellationMode)); |
|||
|
|||
public static GUIContent tessellationText = new GUIContent("Tessellation options", "Tessellation options"); |
|||
public static GUIContent tessellationFactorText = new GUIContent("Tessellation factor", "This value is the tessellation factor use for tessellation, higher mean more tessellated"); |
|||
public static GUIContent tessellationFactorMinDistanceText = new GUIContent("Start fade distance", "Distance (in unity unit) at which the tessellation start to fade out. Must be inferior at Max distance"); |
|||
public static GUIContent tessellationFactorMaxDistanceText = new GUIContent("End fade distance", "Maximum distance (in unity unit) to the camera where triangle are tessellated"); |
|||
public static GUIContent tessellationFactorTriangleSizeText = new GUIContent("Triangle size", "Desired screen space sized of triangle (in pixel). Smaller value mean smaller triangle."); |
|||
public static GUIContent tessellationShapeFactorText = new GUIContent("Shape factor", "Strength of Phong tessellation shape (lerp factor)"); |
|||
public static GUIContent tessellationBackFaceCullEpsilonText = new GUIContent("Triangle culling Epsilon", "If -1.0 back face culling is enabled for tessellation, higher number mean more aggressive culling and better performance"); |
|||
|
|||
// Vertex animation
|
|||
public static string vertexAnimation = "Vertex animation"; |
|||
|
|||
// Wind
|
|||
public static GUIContent windText = new GUIContent("Enable Wind"); |
|||
public static GUIContent windInitialBendText = new GUIContent("Initial Bend"); |
|||
public static GUIContent windStiffnessText = new GUIContent("Stiffness"); |
|||
public static GUIContent windDragText = new GUIContent("Drag"); |
|||
public static GUIContent windShiverDragText = new GUIContent("Shiver Drag"); |
|||
public static GUIContent windShiverDirectionalityText = new GUIContent("Shiver Directionality"); |
|||
|
|||
// Windup Vegetation Wind
|
|||
public static GUIContent vegWindText = new GUIContent("Vegetation Wind"); |
|||
public static GUIContent vegNoise = new GUIContent("Wind Noise"); |
|||
public static GUIContent vegWindMask = new GUIContent("Wind Mask"); |
|||
public static GUIContent vegPivot = new GUIContent("Pivot"); |
|||
public static GUIContent vegStiffness = new GUIContent("Stiffness"); |
|||
public static GUIContent vegAssistantDirectional = new GUIContent("Assist. Directional"); |
|||
public static GUIContent vegWindDirection = new GUIContent("Wind Direction"); |
|||
public static GUIContent vegWindIntensity = new GUIContent("Wind Intensity"); |
|||
public static GUIContent vegWindSpeed = new GUIContent("Wind Speed"); |
|||
public static GUIContent vegDetailVariation = new GUIContent("Detail Variation"); |
|||
public static GUIContent vegLeafShakeScale = new GUIContent("Leaf Shake Scale"); |
|||
public static GUIContent vegLeafShakeSpeed = new GUIContent("Leaf Shake Speed"); |
|||
public static GUIContent vegLeafShakePower = new GUIContent("Leaf Shake Power"); |
|||
public static GUIContent vegPerLeafBendScale = new GUIContent("Per-Leaf Bend Scale"); |
|||
public static GUIContent vegPerLeafBendSpeed = new GUIContent("Per-Leaf Bend Speed"); |
|||
public static GUIContent vegPerLeafBendPower = new GUIContent("Per-Leaf Bend Power"); |
|||
|
|||
} |
|||
|
|||
public enum DoubleSidedNormalMode |
|||
{ |
|||
None, |
|||
Mirror, |
|||
Flip |
|||
} |
|||
|
|||
public enum TessellationMode |
|||
{ |
|||
None, |
|||
Phong |
|||
} |
|||
|
|||
public enum DisplacementMode |
|||
{ |
|||
None, |
|||
Vertex, |
|||
Pixel, |
|||
Tessellation |
|||
} |
|||
|
|||
protected MaterialProperty doubleSidedNormalMode = null; |
|||
protected const string kDoubleSidedNormalMode = "_DoubleSidedNormalMode"; |
|||
protected MaterialProperty depthOffsetEnable = null; |
|||
protected const string kDepthOffsetEnable = "_DepthOffsetEnable"; |
|||
|
|||
// Properties
|
|||
// Material ID
|
|||
protected MaterialProperty materialID = null; |
|||
protected const string kMaterialID = "_MaterialID"; |
|||
|
|||
protected const string kStencilRef = "_StencilRef"; |
|||
|
|||
protected MaterialProperty displacementMode = null; |
|||
protected const string kDisplacementMode = "_DisplacementMode"; |
|||
protected MaterialProperty displacementLockObjectScale = null; |
|||
protected const string kDisplacementLockObjectScale = "_DisplacementLockObjectScale"; |
|||
protected MaterialProperty displacementLockTilingScale = null; |
|||
protected const string kDisplacementLockTilingScale = "_DisplacementLockTilingScale"; |
|||
|
|||
// Per pixel displacement params
|
|||
protected MaterialProperty ppdMinSamples = null; |
|||
protected const string kPpdMinSamples = "_PPDMinSamples"; |
|||
protected MaterialProperty ppdMaxSamples = null; |
|||
protected const string kPpdMaxSamples = "_PPDMaxSamples"; |
|||
protected MaterialProperty ppdLodThreshold = null; |
|||
protected const string kPpdLodThreshold = "_PPDLodThreshold"; |
|||
protected MaterialProperty ppdPrimitiveLength = null; |
|||
protected const string kPpdPrimitiveLength = "_PPDPrimitiveLength"; |
|||
protected MaterialProperty ppdPrimitiveWidth = null; |
|||
protected const string kPpdPrimitiveWidth = "_PPDPrimitiveWidth"; |
|||
protected MaterialProperty invPrimScale = null; |
|||
protected const string kInvPrimScale = "_InvPrimScale"; |
|||
|
|||
// Wind
|
|||
protected MaterialProperty windEnable = null; |
|||
protected const string kWindEnabled = "_EnableWind"; |
|||
protected MaterialProperty windInitialBend = null; |
|||
protected const string kWindInitialBend = "_InitialBend"; |
|||
protected MaterialProperty windStiffness = null; |
|||
protected const string kWindStiffness = "_Stiffness"; |
|||
protected MaterialProperty windDrag = null; |
|||
protected const string kWindDrag = "_Drag"; |
|||
protected MaterialProperty windShiverDrag = null; |
|||
protected const string kWindShiverDrag = "_ShiverDrag"; |
|||
protected MaterialProperty windShiverDirectionality = null; |
|||
protected const string kWindShiverDirectionality = "_ShiverDirectionality"; |
|||
|
|||
// Windup Vegetation Wind
|
|||
protected MaterialProperty vegNoise = null; |
|||
protected const string kVegNoise = "_VegNoise"; |
|||
protected MaterialProperty vegWindMask = null; |
|||
protected const string kVegWindMask = "_VegWindMask"; |
|||
protected MaterialProperty vegPivot = null; |
|||
protected const string kVegPivot = "_VegPivot"; |
|||
protected MaterialProperty vegStiffness = null; |
|||
protected const string kVegStiffness = "_VegStiffness"; |
|||
protected MaterialProperty vegAssistantDirectional = null; |
|||
protected const string kVegAssistantDirectional = "_VegAssistantDirectional"; |
|||
protected MaterialProperty vegWindDirection = null; |
|||
protected const string kVegWindDirection = "_VegWindDirection"; |
|||
protected MaterialProperty vegWindIntensity = null; |
|||
protected const string kVegWindIntensity = "_VegWindIntensity"; |
|||
protected MaterialProperty vegWindSpeed = null; |
|||
protected const string kVegWindSpeed = "_VegWindSpeed"; |
|||
protected MaterialProperty vegDetailVariation = null; |
|||
protected const string kVegDetailVariation = "_VegDetailVariation"; |
|||
protected MaterialProperty vegLeafShakeScale = null; |
|||
protected const string kVegLeafShakeScale = "_VegLeafShakeScale"; |
|||
protected MaterialProperty vegLeafShakeSpeed = null; |
|||
protected const string kVegLeafShakeSpeed = "_VegLeafShakeSpeed"; |
|||
protected MaterialProperty vegLeafShakePower = null; |
|||
protected const string kVegLeafShakePower = "_VegLeafShakePower"; |
|||
protected MaterialProperty vegPerLeafBendScale = null; |
|||
protected const string kVegPerLeafBendScale = "_VegPerLeafBendScale"; |
|||
protected MaterialProperty vegPerLeafBendSpeed = null; |
|||
protected const string kVegPerLeafBendSpeed = "_VegPerLeafBendSpeed"; |
|||
protected MaterialProperty vegPerLeafBendPower = null; |
|||
protected const string kVegPerLeafBendPower = "_VegPerLeafBendPower"; |
|||
|
|||
// tessellation params
|
|||
protected MaterialProperty tessellationMode = null; |
|||
protected const string kTessellationMode = "_TessellationMode"; |
|||
protected MaterialProperty tessellationFactor = null; |
|||
protected const string kTessellationFactor = "_TessellationFactor"; |
|||
protected MaterialProperty tessellationFactorMinDistance = null; |
|||
protected const string kTessellationFactorMinDistance = "_TessellationFactorMinDistance"; |
|||
protected MaterialProperty tessellationFactorMaxDistance = null; |
|||
protected const string kTessellationFactorMaxDistance = "_TessellationFactorMaxDistance"; |
|||
protected MaterialProperty tessellationFactorTriangleSize = null; |
|||
protected const string kTessellationFactorTriangleSize = "_TessellationFactorTriangleSize"; |
|||
protected MaterialProperty tessellationShapeFactor = null; |
|||
protected const string kTessellationShapeFactor = "_TessellationShapeFactor"; |
|||
protected MaterialProperty tessellationBackFaceCullEpsilon = null; |
|||
protected const string kTessellationBackFaceCullEpsilon = "_TessellationBackFaceCullEpsilon"; |
|||
|
|||
protected override void FindBaseMaterialProperties(MaterialProperty[] props) |
|||
{ |
|||
base.FindBaseMaterialProperties(props); |
|||
|
|||
doubleSidedNormalMode = FindProperty(kDoubleSidedNormalMode, props); |
|||
depthOffsetEnable = FindProperty(kDepthOffsetEnable, props); |
|||
|
|||
// MaterialID
|
|||
materialID = FindProperty(kMaterialID, props); |
|||
|
|||
displacementMode = FindProperty(kDisplacementMode, props); |
|||
displacementLockObjectScale = FindProperty(kDisplacementLockObjectScale, props); |
|||
displacementLockTilingScale = FindProperty(kDisplacementLockTilingScale, props); |
|||
|
|||
// Per pixel displacement
|
|||
ppdMinSamples = FindProperty(kPpdMinSamples, props); |
|||
ppdMaxSamples = FindProperty(kPpdMaxSamples, props); |
|||
ppdLodThreshold = FindProperty(kPpdLodThreshold, props); |
|||
ppdPrimitiveLength = FindProperty(kPpdPrimitiveLength, props); |
|||
ppdPrimitiveWidth = FindProperty(kPpdPrimitiveWidth, props); |
|||
invPrimScale = FindProperty(kInvPrimScale, props); |
|||
|
|||
// tessellation specific, silent if not found
|
|||
tessellationMode = FindProperty(kTessellationMode, props, false); |
|||
tessellationFactor = FindProperty(kTessellationFactor, props, false); |
|||
tessellationFactorMinDistance = FindProperty(kTessellationFactorMinDistance, props, false); |
|||
tessellationFactorMaxDistance = FindProperty(kTessellationFactorMaxDistance, props, false); |
|||
tessellationFactorTriangleSize = FindProperty(kTessellationFactorTriangleSize, props, false); |
|||
tessellationShapeFactor = FindProperty(kTessellationShapeFactor, props, false); |
|||
tessellationBackFaceCullEpsilon = FindProperty(kTessellationBackFaceCullEpsilon, props, false); |
|||
|
|||
// Wind
|
|||
windEnable = FindProperty(kWindEnabled, props); |
|||
windInitialBend = FindProperty(kWindInitialBend, props); |
|||
windStiffness = FindProperty(kWindStiffness, props); |
|||
windDrag = FindProperty(kWindDrag, props); |
|||
windShiverDrag = FindProperty(kWindShiverDrag, props); |
|||
windShiverDirectionality = FindProperty(kWindShiverDirectionality, props); |
|||
|
|||
// Windup Vegetation Wind
|
|||
vegNoise = FindProperty(kVegNoise, props); |
|||
vegWindMask = FindProperty(kVegWindMask, props); |
|||
vegPivot = FindProperty(kVegPivot, props); |
|||
vegStiffness = FindProperty(kVegStiffness, props); |
|||
vegAssistantDirectional = FindProperty(kVegAssistantDirectional, props); |
|||
vegWindDirection = FindProperty(kVegWindDirection, props); |
|||
vegWindIntensity = FindProperty(kVegWindIntensity, props); |
|||
vegWindSpeed = FindProperty(kVegWindSpeed, props); |
|||
vegDetailVariation = FindProperty(kVegDetailVariation, props); |
|||
vegLeafShakeScale = FindProperty(kVegLeafShakeScale, props); |
|||
vegLeafShakeSpeed = FindProperty(kVegLeafShakeSpeed, props); |
|||
vegLeafShakePower = FindProperty(kVegLeafShakePower, props); |
|||
vegPerLeafBendScale = FindProperty(kVegPerLeafBendScale, props); |
|||
vegPerLeafBendSpeed = FindProperty(kVegPerLeafBendSpeed, props); |
|||
vegPerLeafBendPower = FindProperty(kVegPerLeafBendPower, props); |
|||
} |
|||
|
|||
void TessellationModePopup() |
|||
{ |
|||
EditorGUI.showMixedValue = tessellationMode.hasMixedValue; |
|||
var mode = (TessellationMode)tessellationMode.floatValue; |
|||
|
|||
EditorGUI.BeginChangeCheck(); |
|||
mode = (TessellationMode)EditorGUILayout.Popup(StylesBaseLit.tessellationModeStr, (int)mode, StylesBaseLit.tessellationModeNames); |
|||
if (EditorGUI.EndChangeCheck()) |
|||
{ |
|||
m_MaterialEditor.RegisterPropertyChangeUndo("Tessellation Mode"); |
|||
tessellationMode.floatValue = (float)mode; |
|||
} |
|||
|
|||
EditorGUI.showMixedValue = false; |
|||
} |
|||
|
|||
protected override void BaseMaterialPropertiesGUI() |
|||
{ |
|||
base.BaseMaterialPropertiesGUI(); |
|||
|
|||
EditorGUI.indentLevel++; |
|||
|
|||
// This follow double sided option
|
|||
if (doubleSidedEnable.floatValue > 0.0f) |
|||
{ |
|||
EditorGUI.indentLevel++; |
|||
m_MaterialEditor.ShaderProperty(doubleSidedNormalMode, StylesBaseLit.doubleSidedNormalModeText); |
|||
EditorGUI.indentLevel--; |
|||
} |
|||
|
|||
m_MaterialEditor.ShaderProperty(materialID, StylesBaseLit.materialIDText); |
|||
|
|||
m_MaterialEditor.ShaderProperty(displacementMode, StylesBaseLit.displacementModeText); |
|||
if ((DisplacementMode)displacementMode.floatValue != DisplacementMode.None) |
|||
{ |
|||
EditorGUI.indentLevel++; |
|||
m_MaterialEditor.ShaderProperty(displacementLockObjectScale, StylesBaseLit.lockWithObjectScaleText); |
|||
m_MaterialEditor.ShaderProperty(displacementLockTilingScale, StylesBaseLit.lockWithTilingRateText); |
|||
EditorGUI.indentLevel--; |
|||
} |
|||
|
|||
if ((DisplacementMode)displacementMode.floatValue == DisplacementMode.Pixel) |
|||
{ |
|||
EditorGUILayout.Space(); |
|||
EditorGUI.indentLevel++; |
|||
m_MaterialEditor.ShaderProperty(ppdMinSamples, StylesBaseLit.ppdMinSamplesText); |
|||
m_MaterialEditor.ShaderProperty(ppdMaxSamples, StylesBaseLit.ppdMaxSamplesText); |
|||
ppdMinSamples.floatValue = Mathf.Min(ppdMinSamples.floatValue, ppdMaxSamples.floatValue); |
|||
m_MaterialEditor.ShaderProperty(ppdLodThreshold, StylesBaseLit.ppdLodThresholdText); |
|||
m_MaterialEditor.ShaderProperty(ppdPrimitiveLength, StylesBaseLit.ppdPrimitiveLength); |
|||
ppdPrimitiveLength.floatValue = Mathf.Max(0.01f, ppdPrimitiveLength.floatValue); |
|||
m_MaterialEditor.ShaderProperty(ppdPrimitiveWidth, StylesBaseLit.ppdPrimitiveWidth); |
|||
ppdPrimitiveWidth.floatValue = Mathf.Max(0.01f, ppdPrimitiveWidth.floatValue); |
|||
invPrimScale.vectorValue = new Vector4(1.0f / ppdPrimitiveLength.floatValue, 1.0f / ppdPrimitiveWidth.floatValue); // Precompute
|
|||
m_MaterialEditor.ShaderProperty(depthOffsetEnable, StylesBaseLit.depthOffsetEnableText); |
|||
EditorGUI.indentLevel--; |
|||
} |
|||
|
|||
EditorGUI.indentLevel--; |
|||
|
|||
// Display tessellation option if it exist
|
|||
if (tessellationMode != null) |
|||
{ |
|||
EditorGUILayout.Space(); |
|||
EditorGUILayout.LabelField(StylesBaseLit.tessellationText, EditorStyles.boldLabel); |
|||
EditorGUI.indentLevel++; |
|||
TessellationModePopup(); |
|||
m_MaterialEditor.ShaderProperty(tessellationFactor, StylesBaseLit.tessellationFactorText); |
|||
m_MaterialEditor.ShaderProperty(tessellationFactorMinDistance, StylesBaseLit.tessellationFactorMinDistanceText); |
|||
m_MaterialEditor.ShaderProperty(tessellationFactorMaxDistance, StylesBaseLit.tessellationFactorMaxDistanceText); |
|||
// clamp min distance to be below max distance
|
|||
tessellationFactorMinDistance.floatValue = Math.Min(tessellationFactorMaxDistance.floatValue, tessellationFactorMinDistance.floatValue); |
|||
m_MaterialEditor.ShaderProperty(tessellationFactorTriangleSize, StylesBaseLit.tessellationFactorTriangleSizeText); |
|||
if ((TessellationMode)tessellationMode.floatValue == TessellationMode.Phong) |
|||
{ |
|||
m_MaterialEditor.ShaderProperty(tessellationShapeFactor, StylesBaseLit.tessellationShapeFactorText); |
|||
} |
|||
if (doubleSidedEnable.floatValue == 0.0) |
|||
{ |
|||
m_MaterialEditor.ShaderProperty(tessellationBackFaceCullEpsilon, StylesBaseLit.tessellationBackFaceCullEpsilonText); |
|||
} |
|||
EditorGUI.indentLevel--; |
|||
} |
|||
} |
|||
|
|||
protected override void VertexAnimationPropertiesGUI() |
|||
{ |
|||
EditorGUILayout.LabelField(StylesBaseLit.vegWindText, EditorStyles.boldLabel); |
|||
|
|||
EditorGUI.indentLevel++; |
|||
m_MaterialEditor.TexturePropertySingleLine(StylesBaseLit.vegWindMask, vegWindMask); |
|||
m_MaterialEditor.TexturePropertySingleLine(StylesBaseLit.vegNoise, vegNoise); |
|||
|
|||
EditorGUILayout.Space(); |
|||
|
|||
m_MaterialEditor.ShaderProperty(vegPivot, StylesBaseLit.vegPivot); |
|||
m_MaterialEditor.ShaderProperty(vegAssistantDirectional, StylesBaseLit.vegAssistantDirectional); |
|||
m_MaterialEditor.ShaderProperty(vegWindDirection, StylesBaseLit.vegWindDirection); |
|||
m_MaterialEditor.ShaderProperty(vegStiffness, StylesBaseLit.vegStiffness); |
|||
m_MaterialEditor.ShaderProperty(vegWindIntensity, StylesBaseLit.vegWindIntensity); |
|||
m_MaterialEditor.ShaderProperty(vegWindSpeed, StylesBaseLit.vegWindSpeed); |
|||
m_MaterialEditor.ShaderProperty(vegDetailVariation, StylesBaseLit.vegDetailVariation); |
|||
|
|||
EditorGUILayout.Space(); |
|||
|
|||
m_MaterialEditor.ShaderProperty(vegLeafShakeScale, StylesBaseLit.vegLeafShakeScale); |
|||
m_MaterialEditor.ShaderProperty(vegLeafShakeSpeed, StylesBaseLit.vegLeafShakeSpeed); |
|||
m_MaterialEditor.ShaderProperty(vegLeafShakePower, StylesBaseLit.vegLeafShakePower); |
|||
|
|||
EditorGUILayout.Space(); |
|||
|
|||
m_MaterialEditor.ShaderProperty(vegPerLeafBendScale, StylesBaseLit.vegPerLeafBendScale); |
|||
m_MaterialEditor.ShaderProperty(vegPerLeafBendSpeed, StylesBaseLit.vegPerLeafBendSpeed); |
|||
m_MaterialEditor.ShaderProperty(vegPerLeafBendPower, StylesBaseLit.vegPerLeafBendPower); |
|||
EditorGUI.indentLevel--; |
|||
|
|||
/* |
|||
EditorGUILayout.LabelField(StylesBaseLit.vertexAnimation, EditorStyles.boldLabel); |
|||
|
|||
EditorGUI.indentLevel++; |
|||
|
|||
m_MaterialEditor.ShaderProperty(windEnable, StylesBaseLit.windText); |
|||
if (!windEnable.hasMixedValue && windEnable.floatValue > 0.0f) |
|||
{ |
|||
EditorGUI.indentLevel++; |
|||
m_MaterialEditor.ShaderProperty(windInitialBend, StylesBaseLit.windInitialBendText); |
|||
m_MaterialEditor.ShaderProperty(windStiffness, StylesBaseLit.windStiffnessText); |
|||
m_MaterialEditor.ShaderProperty(windDrag, StylesBaseLit.windDragText); |
|||
m_MaterialEditor.ShaderProperty(windShiverDrag, StylesBaseLit.windShiverDragText); |
|||
m_MaterialEditor.ShaderProperty(windShiverDirectionality, StylesBaseLit.windShiverDirectionalityText); |
|||
EditorGUI.indentLevel--; |
|||
} |
|||
|
|||
EditorGUI.indentLevel--; |
|||
*/ |
|||
} |
|||
|
|||
// All Setup Keyword functions must be static. It allow to create script to automatically update the shaders with a script if code change
|
|||
static public void SetupBaseLitKeywords(Material material) |
|||
{ |
|||
SetupBaseUnlitKeywords(material); |
|||
|
|||
bool doubleSidedEnable = material.GetFloat(kDoubleSidedEnable) > 0.0f; |
|||
|
|||
if (doubleSidedEnable) |
|||
{ |
|||
DoubleSidedNormalMode doubleSidedNormalMode = (DoubleSidedNormalMode)material.GetFloat(kDoubleSidedNormalMode); |
|||
switch (doubleSidedNormalMode) |
|||
{ |
|||
case DoubleSidedNormalMode.None: |
|||
material.SetVector("_DoubleSidedConstants", new Vector4(1.0f, 1.0f, 1.0f, 0.0f)); |
|||
break; |
|||
|
|||
case DoubleSidedNormalMode.Mirror: // Mirror mode (in tangent space)
|
|||
material.SetVector("_DoubleSidedConstants", new Vector4(1.0f, 1.0f, -1.0f, 0.0f)); |
|||
break; |
|||
|
|||
case DoubleSidedNormalMode.Flip: // Flip mode (in tangent space)
|
|||
material.SetVector("_DoubleSidedConstants", new Vector4(-1.0f, -1.0f, -1.0f, 0.0f)); |
|||
break; |
|||
} |
|||
} |
|||
|
|||
// Set the reference value for the stencil test.
|
|||
int stencilRef = (int)StencilLightingUsage.RegularLighting; |
|||
if ((int)material.GetFloat(kMaterialID) == (int)Lit.MaterialId.LitSSS) |
|||
{ |
|||
stencilRef = (int)StencilLightingUsage.SplitLighting; |
|||
} |
|||
material.SetInt(kStencilRef, stencilRef); |
|||
|
|||
bool enableDisplacement = (DisplacementMode)material.GetFloat(kDisplacementMode) != DisplacementMode.None; |
|||
bool enableVertexDisplacement = (DisplacementMode)material.GetFloat(kDisplacementMode) == DisplacementMode.Vertex; |
|||
bool enablePixelDisplacement = (DisplacementMode)material.GetFloat(kDisplacementMode) == DisplacementMode.Pixel; |
|||
bool enableTessellationDisplacement = ((DisplacementMode)material.GetFloat(kDisplacementMode) == DisplacementMode.Tessellation) && material.HasProperty(kTessellationMode); |
|||
|
|||
SetKeyword(material, "_VERTEX_DISPLACEMENT", enableVertexDisplacement); |
|||
SetKeyword(material, "_PIXEL_DISPLACEMENT", enablePixelDisplacement); |
|||
// Only set if tessellation exist
|
|||
SetKeyword(material, "_TESSELLATION_DISPLACEMENT", enableTessellationDisplacement); |
|||
|
|||
bool displacementLockObjectScale = material.GetFloat(kDisplacementLockObjectScale) > 0.0; |
|||
bool displacementLockTilingScale = material.GetFloat(kDisplacementLockTilingScale) > 0.0; |
|||
// Tessellation reuse vertex flag.
|
|||
SetKeyword(material, "_VERTEX_DISPLACEMENT_LOCK_OBJECT_SCALE", displacementLockObjectScale && (enableVertexDisplacement || enableTessellationDisplacement)); |
|||
SetKeyword(material, "_PIXEL_DISPLACEMENT_LOCK_OBJECT_SCALE", displacementLockObjectScale && enablePixelDisplacement); |
|||
SetKeyword(material, "_DISPLACEMENT_LOCK_TILING_SCALE", displacementLockTilingScale && enableDisplacement); |
|||
|
|||
bool windEnabled = material.GetFloat(kWindEnabled) > 0.0f; |
|||
SetKeyword(material, "_VERTEX_WIND", windEnabled); |
|||
|
|||
// Depth offset is only enabled if per pixel displacement is
|
|||
bool depthOffsetEnable = (material.GetFloat(kDepthOffsetEnable) > 0.0f) && enablePixelDisplacement; |
|||
SetKeyword(material, "_DEPTHOFFSET_ON", depthOffsetEnable); |
|||
|
|||
if (material.HasProperty(kTessellationMode)) |
|||
{ |
|||
TessellationMode tessMode = (TessellationMode)material.GetFloat(kTessellationMode); |
|||
SetKeyword(material, "_TESSELLATION_PHONG", tessMode == TessellationMode.Phong); |
|||
} |
|||
|
|||
SetupMainTexForAlphaTestGI("_BaseColorMap", "_BaseColor", material); |
|||
} |
|||
|
|||
static public void SetupBaseLitMaterialPass(Material material) |
|||
{ |
|||
SetupBaseUnlitMaterialPass(material); |
|||
} |
|||
} |
|||
} // namespace UnityEditor
|
|||
|
|||
fileFormatVersion: 2 |
|||
guid: afec5f69b463f2d498b3516a94f2f07c |
|||
timeCreated: 1509480126 |
|||
licenseType: Pro |
|||
MonoImporter: |
|||
externalObjects: {} |
|||
serializedVersion: 2 |
|||
defaultReferences: [] |
|||
executionOrder: 0 |
|||
icon: {instanceID: 0} |
|||
userData: |
|||
assetBundleName: |
|||
assetBundleVariant: |
|||
|
|||
using System; |
|||
using UnityEngine; |
|||
using UnityEngine.Experimental.Rendering; |
|||
using UnityEngine.Experimental.Rendering.HDPipeline; |
|||
|
|||
namespace UnityEditor.Experimental.Rendering.HDPipeline |
|||
{ |
|||
class VegetationGUI : BaseVegetationGUI |
|||
{ |
|||
protected static class Styles |
|||
{ |
|||
public static string InputsText = "Inputs"; |
|||
|
|||
public static GUIContent baseColorText = new GUIContent("Base Color + Opacity", "Albedo (RGB) and Opacity (A)"); |
|||
|
|||
public static GUIContent smoothnessMapChannelText = new GUIContent("Smoothness Source", "Smoothness texture and channel"); |
|||
public static GUIContent metallicText = new GUIContent("Metallic", "Metallic scale factor"); |
|||
public static GUIContent smoothnessText = new GUIContent("Smoothness", "Smoothness scale factor"); |
|||
public static GUIContent smoothnessRemappingText = new GUIContent("Smoothness Remapping", "Smoothness remapping"); |
|||
public static GUIContent maskMapSText = new GUIContent("Mask Map - M(R), AO(G), D(B), S(A)", "Mask map"); |
|||
public static GUIContent maskMapSpecularText = new GUIContent("Mask Map - AO(G), D(B), S(A)", "Mask map"); |
|||
|
|||
public static GUIContent normalMapSpaceText = new GUIContent("Normal Map space", ""); |
|||
public static GUIContent normalMapText = new GUIContent("Normal Map", "Normal Map (BC7/BC5/DXT5(nm))"); |
|||
public static GUIContent normalMapOSText = new GUIContent("Normal Map OS", "Normal Map (BC7/DXT1/RGB)"); |
|||
public static GUIContent bentNormalMapText = new GUIContent("Bent normal map", "Use only with indirect diffuse lighting (Lightmap/lightprobe) - Cosine weighted Bent Normal Map (average unoccluded direction) (BC7/BC5/DXT5(nm))"); |
|||
public static GUIContent bentNormalMapOSText = new GUIContent("Bent normal map OS", "Use only with indirect diffuse lighting (Lightmap/lightprobe) - Bent Normal Map (BC7/DXT1/RGB)"); |
|||
|
|||
public static GUIContent heightMapText = new GUIContent("Height Map (R)", "Height Map.\nFor floating point textures, min, max and base value should be 0, 1 and 0."); |
|||
public static GUIContent heightMapCenterText = new GUIContent("Height Map Base", "Base of the heightmap in the texture (between 0 and 1)"); |
|||
public static GUIContent heightMapMinText = new GUIContent("Height Min (cm)", "Minimum value in the heightmap (in centimeters)"); |
|||
public static GUIContent heightMapMaxText = new GUIContent("Height Max (cm)", "Maximum value in the heightmap (in centimeters)"); |
|||
|
|||
public static GUIContent tangentMapText = new GUIContent("Tangent Map", "Tangent Map (BC7/BC5/DXT5(nm))"); |
|||
public static GUIContent tangentMapOSText = new GUIContent("Tangent Map OS", "Tangent Map (BC7/DXT1/RGB)"); |
|||
public static GUIContent anisotropyText = new GUIContent("Anisotropy", "Anisotropy scale factor"); |
|||
public static GUIContent anisotropyMapText = new GUIContent("Anisotropy Map (R)", "Anisotropy"); |
|||
|
|||
public static GUIContent UVBaseMappingText = new GUIContent("Base UV mapping", ""); |
|||
public static GUIContent texWorldScaleText = new GUIContent("World scale", "Tiling factor applied to Planar/Trilinear mapping"); |
|||
|
|||
// Details
|
|||
public static string detailText = "Detail Inputs"; |
|||
public static GUIContent UVDetailMappingText = new GUIContent("Detail UV mapping", ""); |
|||
public static GUIContent detailMapNormalText = new GUIContent("Detail Map A(R) Ny(G) S(B) Nx(A)", "Detail Map"); |
|||
public static GUIContent detailAlbedoScaleText = new GUIContent("Detail AlbedoScale", "Detail Albedo Scale factor"); |
|||
public static GUIContent detailNormalScaleText = new GUIContent("Detail NormalScale", "Normal Scale factor"); |
|||
public static GUIContent detailSmoothnessScaleText = new GUIContent("Detail SmoothnessScale", "Smoothness Scale factor"); |
|||
public static GUIContent linkDetailsWithBaseText = new GUIContent("Lock to Base Tiling/Offset", "Lock details Tiling/Offset to Base Tiling/Offset"); |
|||
|
|||
// Subsurface
|
|||
public static GUIContent subsurfaceProfileText = new GUIContent("Subsurface profile", "A profile determines the shape of the blur filter."); |
|||
public static GUIContent subsurfaceRadiusText = new GUIContent("Subsurface radius", "Determines the range of the blur."); |
|||
public static GUIContent subsurfaceRadiusMapText = new GUIContent("Subsurface radius map (R)", "Determines the range of the blur."); |
|||
public static GUIContent thicknessText = new GUIContent("Thickness", "If subsurface scattering is enabled, low values allow some light to be transmitted through the object."); |
|||
public static GUIContent thicknessMapText = new GUIContent("Thickness map (R)", "If subsurface scattering is enabled, low values allow some light to be transmitted through the object."); |
|||
public static GUIContent thicknessRemapText = new GUIContent("Thickness Remap", "Remaps values of the thickness map from [0, 1] to the specified range."); |
|||
|
|||
// Clear Coat
|
|||
public static GUIContent coatCoverageText = new GUIContent("Coat Coverage", "Percentage of clear coat coverage"); |
|||
public static GUIContent coatIORText = new GUIContent("Coat IOR", "IOR of clear coat, value is [0..1] + 1.0. i.e 0.5 is IOR 1.5"); |
|||
|
|||
// Specular color
|
|||
public static GUIContent specularColorText = new GUIContent("Specular Color", "Specular color (RGB)"); |
|||
|
|||
// Specular occlusion
|
|||
public static GUIContent enableSpecularOcclusionText = new GUIContent("Enable Specular Occlusion from Bent normal", "Require cosine weighted bent normal and cosine weighted ambient occlusion. Specular occlusion for reflection probe"); |
|||
public static GUIContent specularOcclusionWarning = new GUIContent("Require a cosine weighted bent normal and ambient occlusion maps"); |
|||
|
|||
// Emissive
|
|||
public static string lightingText = "Lighting Inputs"; |
|||
public static GUIContent emissiveText = new GUIContent("Emissive Color", "Emissive"); |
|||
public static GUIContent emissiveIntensityText = new GUIContent("Emissive Intensity", "Emissive"); |
|||
public static GUIContent albedoAffectEmissiveText = new GUIContent("Albedo Affect Emissive", "Specifies whether or not the emissive color is multiplied by the albedo."); |
|||
|
|||
public static GUIContent normalMapSpaceWarning = new GUIContent("Object space normal can't be use with triplanar mapping."); |
|||
|
|||
// Transparency
|
|||
public static string refractionModeText = "Refraction Mode"; |
|||
public static GUIContent refractionIORText = new GUIContent("Indice of refraction", "Indice of refraction"); |
|||
public static GUIContent refractionThicknessText = new GUIContent("Refraction Thickness", "Thickness for rough refraction"); |
|||
public static GUIContent refractionThicknessMultiplierText = new GUIContent("Refraction Thickness multiplier", "Thickness multiplier"); |
|||
public static GUIContent refractionThicknessMapText = new GUIContent("Refraction Thickness Map (R)", "Thickness multiplier"); |
|||
// Transparency absorption
|
|||
public static GUIContent transmittanceColorText = new GUIContent("Transmittance Color", "Absorption color (RGB)"); |
|||
public static GUIContent atDistanceText = new GUIContent("Transmittance Absorption Distance", "Absorption distance reference"); |
|||
|
|||
public static GUIContent perPixelDisplacementDetailsWarning = new GUIContent("For pixel displacement to work correctly, details and base map must use same UV mapping"); |
|||
} |
|||
|
|||
// Lit shader is not layered but some layered materials inherit from it. In order to share code we need LitUI to account for this.
|
|||
protected const int kMaxLayerCount = 4; |
|||
|
|||
protected int m_LayerCount = 1; |
|||
protected string[] m_PropertySuffixes = { "", "", "", "" }; |
|||
|
|||
public enum UVBaseMapping |
|||
{ |
|||
UV0, |
|||
UV1, |
|||
UV2, |
|||
UV3, |
|||
Planar, |
|||
Triplanar |
|||
} |
|||
|
|||
public enum NormalMapSpace |
|||
{ |
|||
TangentSpace, |
|||
ObjectSpace, |
|||
} |
|||
|
|||
public enum HeightmapMode |
|||
{ |
|||
Parallax, |
|||
Displacement, |
|||
} |
|||
|
|||
public enum UVDetailMapping |
|||
{ |
|||
UV0, |
|||
UV1, |
|||
UV2, |
|||
UV3 |
|||
} |
|||
|
|||
protected MaterialProperty[] UVBase = new MaterialProperty[kMaxLayerCount]; |
|||
protected const string kUVBase = "_UVBase"; |
|||
protected MaterialProperty[] TexWorldScale = new MaterialProperty[kMaxLayerCount]; |
|||
protected const string kTexWorldScale = "_TexWorldScale"; |
|||
protected MaterialProperty[] InvTilingScale = new MaterialProperty[kMaxLayerCount]; |
|||
protected const string kInvTilingScale = "_InvTilingScale"; |
|||
protected MaterialProperty[] UVMappingMask = new MaterialProperty[kMaxLayerCount]; |
|||
protected const string kUVMappingMask = "_UVMappingMask"; |
|||
|
|||
protected MaterialProperty[] baseColor = new MaterialProperty[kMaxLayerCount]; |
|||
protected const string kBaseColor = "_BaseColor"; |
|||
protected MaterialProperty[] baseColorMap = new MaterialProperty[kMaxLayerCount]; |
|||
protected const string kBaseColorMap = "_BaseColorMap"; |
|||
protected MaterialProperty[] metallic = new MaterialProperty[kMaxLayerCount]; |
|||
protected const string kMetallic = "_Metallic"; |
|||
protected MaterialProperty[] smoothness = new MaterialProperty[kMaxLayerCount]; |
|||
protected const string kSmoothness = "_Smoothness"; |
|||
protected MaterialProperty[] smoothnessRemapMin = new MaterialProperty[kMaxLayerCount]; |
|||
protected const string kSmoothnessRemapMin = "_SmoothnessRemapMin"; |
|||
protected MaterialProperty[] smoothnessRemapMax = new MaterialProperty[kMaxLayerCount]; |
|||
protected const string kSmoothnessRemapMax = "_SmoothnessRemapMax"; |
|||
protected MaterialProperty[] maskMap = new MaterialProperty[kMaxLayerCount]; |
|||
protected const string kMaskMap = "_MaskMap"; |
|||
protected MaterialProperty[] normalScale = new MaterialProperty[kMaxLayerCount]; |
|||
protected const string kNormalScale = "_NormalScale"; |
|||
protected MaterialProperty[] normalMap = new MaterialProperty[kMaxLayerCount]; |
|||
protected const string kNormalMap = "_NormalMap"; |
|||
protected MaterialProperty[] normalMapOS = new MaterialProperty[kMaxLayerCount]; |
|||
protected const string kNormalMapOS = "_NormalMapOS"; |
|||
protected MaterialProperty[] bentNormalMap = new MaterialProperty[kMaxLayerCount]; |
|||
protected const string kBentNormalMap = "_BentNormalMap"; |
|||
protected MaterialProperty[] bentNormalMapOS = new MaterialProperty[kMaxLayerCount]; |
|||
protected const string kBentNormalMapOS = "_BentNormalMapOS"; |
|||
protected MaterialProperty[] normalMapSpace = new MaterialProperty[kMaxLayerCount]; |
|||
protected const string kNormalMapSpace = "_NormalMapSpace"; |
|||
protected MaterialProperty[] heightMap = new MaterialProperty[kMaxLayerCount]; |
|||
protected const string kHeightMap = "_HeightMap"; |
|||
protected MaterialProperty[] heightAmplitude = new MaterialProperty[kMaxLayerCount]; |
|||
protected const string kHeightAmplitude = "_HeightAmplitude"; |
|||
protected MaterialProperty[] heightCenter = new MaterialProperty[kMaxLayerCount]; |
|||
protected const string kHeightCenter = "_HeightCenter"; |
|||
protected MaterialProperty[] heightMin = new MaterialProperty[kMaxLayerCount]; |
|||
protected const string kHeightMin = "_HeightMin"; |
|||
protected MaterialProperty[] heightMax = new MaterialProperty[kMaxLayerCount]; |
|||
protected const string kHeightMax = "_HeightMax"; |
|||
|
|||
protected MaterialProperty[] subsurfaceProfileID = new MaterialProperty[kMaxLayerCount]; |
|||
protected const string kSubsurfaceProfileID = "_SubsurfaceProfile"; |
|||
protected MaterialProperty[] subsurfaceRadius = new MaterialProperty[kMaxLayerCount]; |
|||
protected const string kSubsurfaceRadius = "_SubsurfaceRadius"; |
|||
protected MaterialProperty[] subsurfaceRadiusMap = new MaterialProperty[kMaxLayerCount]; |
|||
protected const string kSubsurfaceRadiusMap = "_SubsurfaceRadiusMap"; |
|||
protected MaterialProperty[] thickness = new MaterialProperty[kMaxLayerCount]; |
|||
protected const string kThickness = "_Thickness"; |
|||
protected MaterialProperty[] thicknessMap = new MaterialProperty[kMaxLayerCount]; |
|||
protected const string kThicknessMap = "_ThicknessMap"; |
|||
protected MaterialProperty[] thicknessRemap = new MaterialProperty[kMaxLayerCount]; |
|||
protected const string kThicknessRemap = "_ThicknessRemap"; |
|||
|
|||
protected MaterialProperty[] UVDetail = new MaterialProperty[kMaxLayerCount]; |
|||
protected const string kUVDetail = "_UVDetail"; |
|||
protected MaterialProperty[] UVDetailsMappingMask = new MaterialProperty[kMaxLayerCount]; |
|||
protected const string kUVDetailsMappingMask = "_UVDetailsMappingMask"; |
|||
protected MaterialProperty[] detailMap = new MaterialProperty[kMaxLayerCount]; |
|||
protected const string kDetailMap = "_DetailMap"; |
|||
protected MaterialProperty[] linkDetailsWithBase = new MaterialProperty[kMaxLayerCount]; |
|||
protected const string kLinkDetailsWithBase = "_LinkDetailsWithBase"; |
|||
protected MaterialProperty[] detailAlbedoScale = new MaterialProperty[kMaxLayerCount]; |
|||
protected const string kDetailAlbedoScale = "_DetailAlbedoScale"; |
|||
protected MaterialProperty[] detailNormalScale = new MaterialProperty[kMaxLayerCount]; |
|||
protected const string kDetailNormalScale = "_DetailNormalScale"; |
|||
protected MaterialProperty[] detailSmoothnessScale = new MaterialProperty[kMaxLayerCount]; |
|||
protected const string kDetailSmoothnessScale = "_DetailSmoothnessScale"; |
|||
|
|||
protected MaterialProperty specularColor = null; |
|||
protected const string kSpecularColor = "_SpecularColor"; |
|||
protected MaterialProperty specularColorMap = null; |
|||
protected const string kSpecularColorMap = "_SpecularColorMap"; |
|||
|
|||
protected MaterialProperty tangentMap = null; |
|||
protected const string kTangentMap = "_TangentMap"; |
|||
protected MaterialProperty tangentMapOS = null; |
|||
protected const string kTangentMapOS = "_TangentMapOS"; |
|||
protected MaterialProperty anisotropy = null; |
|||
protected const string kAnisotropy = "_Anisotropy"; |
|||
protected MaterialProperty anisotropyMap = null; |
|||
protected const string kAnisotropyMap = "_AnisotropyMap"; |
|||
|
|||
protected MaterialProperty coatCoverage = null; |
|||
protected const string kCoatCoverage = "_CoatCoverage"; |
|||
protected MaterialProperty coatIOR = null; |
|||
protected const string kCoatIOR = "_CoatIOR"; |
|||
|
|||
protected MaterialProperty emissiveColorMode = null; |
|||
protected const string kEmissiveColorMode = "_EmissiveColorMode"; |
|||
protected MaterialProperty emissiveColor = null; |
|||
protected const string kEmissiveColor = "_EmissiveColor"; |
|||
protected MaterialProperty emissiveColorMap = null; |
|||
protected const string kEmissiveColorMap = "_EmissiveColorMap"; |
|||
protected MaterialProperty emissiveIntensity = null; |
|||
protected const string kEmissiveIntensity = "_EmissiveIntensity"; |
|||
protected MaterialProperty albedoAffectEmissive = null; |
|||
protected const string kAlbedoAffectEmissive = "_AlbedoAffectEmissive"; |
|||
protected MaterialProperty enableSpecularOcclusion = null; |
|||
protected const string kEnableSpecularOcclusion = "_EnableSpecularOcclusion"; |
|||
|
|||
// transparency params
|
|||
protected MaterialProperty ior = null; |
|||
protected const string kIOR = "_IOR"; |
|||
protected MaterialProperty transmittanceColor = null; |
|||
protected const string kTransmittanceColor = "_TransmittanceColor"; |
|||
protected MaterialProperty atDistance = null; |
|||
protected const string kATDistance = "_ATDistance"; |
|||
protected MaterialProperty thicknessMultiplier = null; |
|||
protected const string kThicknessMultiplier = "_ThicknessMultiplier"; |
|||
protected MaterialProperty refractionMode = null; |
|||
protected const string kRefractionMode = "_RefractionMode"; |
|||
|
|||
protected override bool showBlendModePopup |
|||
{ |
|||
get { return refractionMode == null || refractionMode.floatValue == 0f; } |
|||
} |
|||
|
|||
protected void FindMaterialLayerProperties(MaterialProperty[] props) |
|||
{ |
|||
for (int i = 0; i < m_LayerCount; ++i) |
|||
{ |
|||
UVBase[i] = FindProperty(string.Format("{0}{1}", kUVBase, m_PropertySuffixes[i]), props); |
|||
TexWorldScale[i] = FindProperty(string.Format("{0}{1}", kTexWorldScale, m_PropertySuffixes[i]), props); |
|||
InvTilingScale[i] = FindProperty(string.Format("{0}{1}", kInvTilingScale, m_PropertySuffixes[i]), props); |
|||
UVMappingMask[i] = FindProperty(string.Format("{0}{1}", kUVMappingMask, m_PropertySuffixes[i]), props); |
|||
|
|||
baseColor[i] = FindProperty(string.Format("{0}{1}", kBaseColor, m_PropertySuffixes[i]), props); |
|||
baseColorMap[i] = FindProperty(string.Format("{0}{1}", kBaseColorMap, m_PropertySuffixes[i]), props); |
|||
metallic[i] = FindProperty(string.Format("{0}{1}", kMetallic, m_PropertySuffixes[i]), props); |
|||
smoothness[i] = FindProperty(string.Format("{0}{1}", kSmoothness, m_PropertySuffixes[i]), props); |
|||
smoothnessRemapMin[i] = FindProperty(string.Format("{0}{1}", kSmoothnessRemapMin, m_PropertySuffixes[i]), props); |
|||
smoothnessRemapMax[i] = FindProperty(string.Format("{0}{1}", kSmoothnessRemapMax, m_PropertySuffixes[i]), props); |
|||
maskMap[i] = FindProperty(string.Format("{0}{1}", kMaskMap, m_PropertySuffixes[i]), props); |
|||
normalMap[i] = FindProperty(string.Format("{0}{1}", kNormalMap, m_PropertySuffixes[i]), props); |
|||
normalMapOS[i] = FindProperty(string.Format("{0}{1}", kNormalMapOS, m_PropertySuffixes[i]), props); |
|||
normalScale[i] = FindProperty(string.Format("{0}{1}", kNormalScale, m_PropertySuffixes[i]), props); |
|||
bentNormalMap[i] = FindProperty(string.Format("{0}{1}", kBentNormalMap, m_PropertySuffixes[i]), props); |
|||
bentNormalMapOS[i] = FindProperty(string.Format("{0}{1}", kBentNormalMapOS, m_PropertySuffixes[i]), props); |
|||
normalMapSpace[i] = FindProperty(string.Format("{0}{1}", kNormalMapSpace, m_PropertySuffixes[i]), props); |
|||
heightMap[i] = FindProperty(string.Format("{0}{1}", kHeightMap, m_PropertySuffixes[i]), props); |
|||
heightAmplitude[i] = FindProperty(string.Format("{0}{1}", kHeightAmplitude, m_PropertySuffixes[i]), props); |
|||
heightMin[i] = FindProperty(string.Format("{0}{1}", kHeightMin, m_PropertySuffixes[i]), props); |
|||
heightMax[i] = FindProperty(string.Format("{0}{1}", kHeightMax, m_PropertySuffixes[i]), props); |
|||
heightCenter[i] = FindProperty(string.Format("{0}{1}", kHeightCenter, m_PropertySuffixes[i]), props); |
|||
|
|||
// Sub surface
|
|||
subsurfaceProfileID[i] = FindProperty(string.Format("{0}{1}", kSubsurfaceProfileID, m_PropertySuffixes[i]), props); |
|||
subsurfaceRadius[i] = FindProperty(string.Format("{0}{1}", kSubsurfaceRadius, m_PropertySuffixes[i]), props); |
|||
subsurfaceRadiusMap[i] = FindProperty(string.Format("{0}{1}", kSubsurfaceRadiusMap, m_PropertySuffixes[i]), props); |
|||
thickness[i] = FindProperty(string.Format("{0}{1}", kThickness, m_PropertySuffixes[i]), props); |
|||
thicknessMap[i] = FindProperty(string.Format("{0}{1}", kThicknessMap, m_PropertySuffixes[i]), props); |
|||
thicknessRemap[i] = FindProperty(string.Format("{0}{1}", kThicknessRemap, m_PropertySuffixes[i]), props); |
|||
|
|||
// Details
|
|||
UVDetail[i] = FindProperty(string.Format("{0}{1}", kUVDetail, m_PropertySuffixes[i]), props); |
|||
UVDetailsMappingMask[i] = FindProperty(string.Format("{0}{1}", kUVDetailsMappingMask, m_PropertySuffixes[i]), props); |
|||
linkDetailsWithBase[i] = FindProperty(string.Format("{0}{1}", kLinkDetailsWithBase, m_PropertySuffixes[i]), props); |
|||
detailMap[i] = FindProperty(string.Format("{0}{1}", kDetailMap, m_PropertySuffixes[i]), props); |
|||
detailAlbedoScale[i] = FindProperty(string.Format("{0}{1}", kDetailAlbedoScale, m_PropertySuffixes[i]), props); |
|||
detailNormalScale[i] = FindProperty(string.Format("{0}{1}", kDetailNormalScale, m_PropertySuffixes[i]), props); |
|||
detailSmoothnessScale[i] = FindProperty(string.Format("{0}{1}", kDetailSmoothnessScale, m_PropertySuffixes[i]), props); |
|||
} |
|||
} |
|||
|
|||
protected void FindMaterialEmissiveProperties(MaterialProperty[] props) |
|||
{ |
|||
emissiveColorMode = FindProperty(kEmissiveColorMode, props); |
|||
emissiveColor = FindProperty(kEmissiveColor, props); |
|||
emissiveColorMap = FindProperty(kEmissiveColorMap, props); |
|||
emissiveIntensity = FindProperty(kEmissiveIntensity, props); |
|||
albedoAffectEmissive = FindProperty(kAlbedoAffectEmissive, props); |
|||
enableSpecularOcclusion = FindProperty(kEnableSpecularOcclusion, props); |
|||
} |
|||
|
|||
protected override void FindMaterialProperties(MaterialProperty[] props) |
|||
{ |
|||
FindMaterialLayerProperties(props); |
|||
FindMaterialEmissiveProperties(props); |
|||
|
|||
// The next properties are only supported for regular Lit shader (not layered ones) because it's complicated to blend those parameters if they are different on a per layer basis.
|
|||
|
|||
// Specular Color
|
|||
specularColor = FindProperty(kSpecularColor, props); |
|||
specularColorMap = FindProperty(kSpecularColorMap, props); |
|||
|
|||
// Anisotropy
|
|||
tangentMap = FindProperty(kTangentMap, props); |
|||
tangentMapOS = FindProperty(kTangentMapOS, props); |
|||
anisotropy = FindProperty(kAnisotropy, props); |
|||
anisotropyMap = FindProperty(kAnisotropyMap, props); |
|||
|
|||
// clear coat
|
|||
coatCoverage = FindProperty(kCoatCoverage, props); |
|||
coatIOR = FindProperty(kCoatIOR, props); |
|||
|
|||
// Transparency
|
|||
refractionMode = FindProperty(kRefractionMode, props, false); |
|||
transmittanceColor = FindProperty(kTransmittanceColor, props, false); |
|||
atDistance = FindProperty(kATDistance, props, false); |
|||
thicknessMultiplier = FindProperty(kThicknessMultiplier, props, false); |
|||
ior = FindProperty(kIOR, props, false); |
|||
// We reuse thickness from SSS
|
|||
} |
|||
|
|||
protected void ShaderSSSInputGUI(Material material, int layerIndex) |
|||
{ |
|||
var hdPipeline = RenderPipelineManager.currentPipeline as HDRenderPipeline; |
|||
var sssSettings = hdPipeline.sssSettings; |
|||
|
|||
if (sssSettings == null) |
|||
{ |
|||
EditorGUILayout.HelpBox("No Subsurface Scattering Settings have been assigned to the render pipeline asset.", MessageType.Warning); |
|||
return; |
|||
} |
|||
|
|||
// TODO: Optimize me
|
|||
var profiles = hdPipeline.sssSettings.profiles; |
|||
var names = new GUIContent[profiles.Length + 1]; |
|||
names[0] = new GUIContent("None"); |
|||
|
|||
var values = new int[names.Length]; |
|||
values[0] = SssConstants.SSS_NEUTRAL_PROFILE_ID; |
|||
|
|||
for (int i = 0; i < profiles.Length; i++) |
|||
{ |
|||
names[i + 1] = new GUIContent(profiles[i].name); |
|||
values[i + 1] = i + 1; |
|||
} |
|||
|
|||
using (var scope = new EditorGUI.ChangeCheckScope()) |
|||
{ |
|||
int profileID = (int)subsurfaceProfileID[layerIndex].floatValue; |
|||
|
|||
using (new EditorGUILayout.HorizontalScope()) |
|||
{ |
|||
EditorGUILayout.PrefixLabel(Styles.subsurfaceProfileText); |
|||
|
|||
using (new EditorGUILayout.HorizontalScope()) |
|||
{ |
|||
profileID = EditorGUILayout.IntPopup(profileID, names, values); |
|||
|
|||
if (GUILayout.Button("Goto", EditorStyles.miniButton, GUILayout.Width(50f))) |
|||
Selection.activeObject = sssSettings; |
|||
} |
|||
} |
|||
|
|||
if (scope.changed) |
|||
subsurfaceProfileID[layerIndex].floatValue = profileID; |
|||
} |
|||
|
|||
m_MaterialEditor.ShaderProperty(subsurfaceRadius[layerIndex], Styles.subsurfaceRadiusText); |
|||
m_MaterialEditor.TexturePropertySingleLine(Styles.subsurfaceRadiusMapText, subsurfaceRadiusMap[layerIndex]); |
|||
m_MaterialEditor.TexturePropertySingleLine(Styles.thicknessMapText, thicknessMap[layerIndex]); |
|||
if (thicknessMap[layerIndex].textureValue != null) |
|||
{ |
|||
// Display the remap of texture values.
|
|||
Vector2 remap = thicknessRemap[layerIndex].vectorValue; |
|||
EditorGUI.BeginChangeCheck(); |
|||
EditorGUILayout.MinMaxSlider(Styles.thicknessRemapText, ref remap.x, ref remap.y, 0.0f, 1.0f); |
|||
if (EditorGUI.EndChangeCheck()) |
|||
{ |
|||
thicknessRemap[layerIndex].vectorValue = remap; |
|||
} |
|||
} |
|||
else |
|||
{ |
|||
// Allow the user to set the constant value of thickness if no thickness map is provided.
|
|||
m_MaterialEditor.ShaderProperty(thickness[layerIndex], Styles.thicknessText); |
|||
} |
|||
} |
|||
|
|||
protected void ShaderClearCoatInputGUI() |
|||
{ |
|||
m_MaterialEditor.ShaderProperty(coatCoverage, Styles.coatCoverageText); |
|||
m_MaterialEditor.ShaderProperty(coatIOR, Styles.coatIORText); |
|||
} |
|||
|
|||
protected void ShaderAnisoInputGUI() |
|||
{ |
|||
if ((NormalMapSpace)normalMapSpace[0].floatValue == NormalMapSpace.TangentSpace) |
|||
{ |
|||
m_MaterialEditor.TexturePropertySingleLine(Styles.tangentMapText, tangentMap); |
|||
} |
|||
else |
|||
{ |
|||
m_MaterialEditor.TexturePropertySingleLine(Styles.tangentMapOSText, tangentMapOS); |
|||
} |
|||
m_MaterialEditor.ShaderProperty(anisotropy, Styles.anisotropyText); |
|||
m_MaterialEditor.TexturePropertySingleLine(Styles.anisotropyMapText, anisotropyMap); |
|||
} |
|||
|
|||
protected void DoLayerGUI(Material material, int layerIndex) |
|||
{ |
|||
EditorGUILayout.LabelField(Styles.InputsText, EditorStyles.boldLabel); |
|||
|
|||
EditorGUI.indentLevel++; |
|||
|
|||
m_MaterialEditor.TexturePropertySingleLine(Styles.baseColorText, baseColorMap[layerIndex], baseColor[layerIndex]); |
|||
|
|||
if ((Lit.MaterialId)materialID.floatValue == Lit.MaterialId.LitStandard || (Lit.MaterialId)materialID.floatValue == Lit.MaterialId.LitAniso) |
|||
{ |
|||
m_MaterialEditor.ShaderProperty(metallic[layerIndex], Styles.metallicText); |
|||
} |
|||
|
|||
if(maskMap[layerIndex].textureValue == null) |
|||
{ |
|||
m_MaterialEditor.ShaderProperty(smoothness[layerIndex], Styles.smoothnessText); |
|||
|
|||
} |
|||
else |
|||
{ |
|||
float remapMin = smoothnessRemapMin[layerIndex].floatValue; |
|||
float remapMax = smoothnessRemapMax[layerIndex].floatValue; |
|||
EditorGUI.BeginChangeCheck(); |
|||
EditorGUILayout.MinMaxSlider(Styles.smoothnessRemappingText, ref remapMin, ref remapMax, 0.0f, 1.0f); |
|||
if (EditorGUI.EndChangeCheck()) |
|||
{ |
|||
smoothnessRemapMin[layerIndex].floatValue = remapMin; |
|||
smoothnessRemapMax[layerIndex].floatValue = remapMax; |
|||
} |
|||
} |
|||
|
|||
m_MaterialEditor.TexturePropertySingleLine(((Lit.MaterialId)materialID.floatValue == Lit.MaterialId.LitSpecular) ? Styles.maskMapSpecularText : Styles.maskMapSText, maskMap[layerIndex]); |
|||
|
|||
m_MaterialEditor.ShaderProperty(normalMapSpace[layerIndex], Styles.normalMapSpaceText); |
|||
|
|||
// Triplanar only work with tangent space normal
|
|||
if ((NormalMapSpace)normalMapSpace[layerIndex].floatValue == NormalMapSpace.ObjectSpace && ((UVBaseMapping)UVBase[layerIndex].floatValue == UVBaseMapping.Triplanar)) |
|||
{ |
|||
EditorGUILayout.HelpBox(Styles.normalMapSpaceWarning.text, MessageType.Error); |
|||
} |
|||
|
|||
// We have two different property for object space and tangent space normal map to allow
|
|||
// 1. to go back and forth
|
|||
// 2. to avoid the warning that ask to fix the object normal map texture (normalOS are just linear RGB texture
|
|||
if ((NormalMapSpace)normalMapSpace[layerIndex].floatValue == NormalMapSpace.TangentSpace) |
|||
{ |
|||
m_MaterialEditor.TexturePropertySingleLine(Styles.normalMapText, normalMap[layerIndex], normalScale[layerIndex]); |
|||
m_MaterialEditor.TexturePropertySingleLine(Styles.bentNormalMapText, bentNormalMap[layerIndex]); |
|||
} |
|||
else |
|||
{ |
|||
// No scaling in object space
|
|||
m_MaterialEditor.TexturePropertySingleLine(Styles.normalMapOSText, normalMapOS[layerIndex]); |
|||
m_MaterialEditor.TexturePropertySingleLine(Styles.bentNormalMapOSText, bentNormalMapOS[layerIndex]); |
|||
} |
|||
|
|||
EditorGUI.BeginChangeCheck(); |
|||
m_MaterialEditor.TexturePropertySingleLine(Styles.heightMapText, heightMap[layerIndex]); |
|||
if (!heightMap[layerIndex].hasMixedValue && heightMap[layerIndex].textureValue != null) |
|||
{ |
|||
EditorGUI.indentLevel++; |
|||
m_MaterialEditor.ShaderProperty(heightMin[layerIndex], Styles.heightMapMinText); |
|||
m_MaterialEditor.ShaderProperty(heightMax[layerIndex], Styles.heightMapMaxText); |
|||
m_MaterialEditor.ShaderProperty(heightCenter[layerIndex], Styles.heightMapCenterText); |
|||
EditorGUI.showMixedValue = false; |
|||
EditorGUI.indentLevel--; |
|||
} |
|||
// Note: We should only enclose min/max property here for change detection. However heightAmplitude may not be correctly initialize if default value was not correct
|
|||
// force a refresh when the user setup a heightmap, so we are sure it is correct
|
|||
if (EditorGUI.EndChangeCheck()) |
|||
{ |
|||
heightAmplitude[layerIndex].floatValue = (heightMax[layerIndex].floatValue - heightMin[layerIndex].floatValue) * 0.01f; // Conversion centimeters to meters.
|
|||
} |
|||
|
|||
switch ((Lit.MaterialId)materialID.floatValue) |
|||
{ |
|||
case Lit.MaterialId.LitSSS: |
|||
ShaderSSSInputGUI(material, layerIndex); |
|||
break; |
|||
case Lit.MaterialId.LitStandard: |
|||
// Nothing
|
|||
break; |
|||
|
|||
// Following mode are not supported by layered lit and will not be call by it
|
|||
// as the MaterialId enum don't define it
|
|||
case Lit.MaterialId.LitAniso: |
|||
ShaderAnisoInputGUI(); |
|||
break; |
|||
case Lit.MaterialId.LitSpecular: |
|||
m_MaterialEditor.TexturePropertySingleLine(Styles.specularColorText, specularColorMap, specularColor); |
|||
break; |
|||
case Lit.MaterialId.LitClearCoat: |
|||
ShaderClearCoatInputGUI(); |
|||
break; |
|||
default: |
|||
Debug.Assert(false, "Encountered an unsupported MaterialID."); |
|||
break; |
|||
} |
|||
|
|||
EditorGUILayout.Space(); |
|||
|
|||
EditorGUI.BeginChangeCheck(); |
|||
m_MaterialEditor.ShaderProperty(UVBase[layerIndex], Styles.UVBaseMappingText); |
|||
|
|||
UVBaseMapping uvBaseMapping = (UVBaseMapping)UVBase[layerIndex].floatValue; |
|||
|
|||
float X, Y, Z, W; |
|||
X = (uvBaseMapping == UVBaseMapping.UV0) ? 1.0f : 0.0f; |
|||
Y = (uvBaseMapping == UVBaseMapping.UV1) ? 1.0f : 0.0f; |
|||
Z = (uvBaseMapping == UVBaseMapping.UV2) ? 1.0f : 0.0f; |
|||
W = (uvBaseMapping == UVBaseMapping.UV3) ? 1.0f : 0.0f; |
|||
|
|||
UVMappingMask[layerIndex].colorValue = new Color(X, Y, Z, W); |
|||
|
|||
if ((uvBaseMapping == UVBaseMapping.Planar) || (uvBaseMapping == UVBaseMapping.Triplanar)) |
|||
{ |
|||
m_MaterialEditor.ShaderProperty(TexWorldScale[layerIndex], Styles.texWorldScaleText); |
|||
} |
|||
m_MaterialEditor.TextureScaleOffsetProperty(baseColorMap[layerIndex]); |
|||
if (EditorGUI.EndChangeCheck()) |
|||
{ |
|||
// Precompute.
|
|||
InvTilingScale[layerIndex].floatValue = 2.0f / (Mathf.Abs(baseColorMap[layerIndex].textureScaleAndOffset.x) + Mathf.Abs(baseColorMap[layerIndex].textureScaleAndOffset.y)); |
|||
if ((uvBaseMapping == UVBaseMapping.Planar) || (uvBaseMapping == UVBaseMapping.Triplanar)) |
|||
{ |
|||
InvTilingScale[layerIndex].floatValue = InvTilingScale[layerIndex].floatValue / TexWorldScale[layerIndex].floatValue; |
|||
} |
|||
} |
|||
|
|||
EditorGUI.indentLevel--; |
|||
EditorGUILayout.Space(); |
|||
EditorGUILayout.LabelField(Styles.detailText, EditorStyles.boldLabel); |
|||
|
|||
EditorGUI.indentLevel++; |
|||
m_MaterialEditor.TexturePropertySingleLine(Styles.detailMapNormalText, detailMap[layerIndex]); |
|||
|
|||
// When Planar or Triplanar is enable the UVDetail use the same mode, so we disable the choice on UVDetail
|
|||
if (uvBaseMapping == UVBaseMapping.Planar) |
|||
{ |
|||
EditorGUILayout.LabelField(Styles.UVDetailMappingText.text + ": Planar"); |
|||
} |
|||
else if (uvBaseMapping == UVBaseMapping.Triplanar) |
|||
{ |
|||
EditorGUILayout.LabelField(Styles.UVDetailMappingText.text + ": Triplanar"); |
|||
} |
|||
else |
|||
{ |
|||
m_MaterialEditor.ShaderProperty(UVDetail[layerIndex], Styles.UVDetailMappingText); |
|||
} |
|||
|
|||
// Setup the UVSet for detail, if planar/triplanar is use for base, it will override the mapping of detail (See shader code)
|
|||
X = ((UVDetailMapping)UVDetail[layerIndex].floatValue == UVDetailMapping.UV0) ? 1.0f : 0.0f; |
|||
Y = ((UVDetailMapping)UVDetail[layerIndex].floatValue == UVDetailMapping.UV1) ? 1.0f : 0.0f; |
|||
Z = ((UVDetailMapping)UVDetail[layerIndex].floatValue == UVDetailMapping.UV2) ? 1.0f : 0.0f; |
|||
W = ((UVDetailMapping)UVDetail[layerIndex].floatValue == UVDetailMapping.UV3) ? 1.0f : 0.0f; |
|||
UVDetailsMappingMask[layerIndex].colorValue = new Color(X, Y, Z, W); |
|||
|
|||
EditorGUI.indentLevel++; |
|||
m_MaterialEditor.ShaderProperty(linkDetailsWithBase[layerIndex], Styles.linkDetailsWithBaseText); |
|||
EditorGUI.indentLevel--; |
|||
m_MaterialEditor.TextureScaleOffsetProperty(detailMap[layerIndex]); |
|||
if ((DisplacementMode)displacementMode.floatValue == DisplacementMode.Pixel && (UVDetail[layerIndex].floatValue != UVBase[layerIndex].floatValue)) |
|||
{ |
|||
if (material.GetTexture(kDetailMap + m_PropertySuffixes[layerIndex])) |
|||
EditorGUILayout.HelpBox(Styles.perPixelDisplacementDetailsWarning.text, MessageType.Warning); |
|||
} |
|||
m_MaterialEditor.ShaderProperty(detailAlbedoScale[layerIndex], Styles.detailAlbedoScaleText); |
|||
m_MaterialEditor.ShaderProperty(detailNormalScale[layerIndex], Styles.detailNormalScaleText); |
|||
m_MaterialEditor.ShaderProperty(detailSmoothnessScale[layerIndex], Styles.detailSmoothnessScaleText); |
|||
|
|||
EditorGUI.indentLevel--; |
|||
|
|||
var surfaceTypeValue = (SurfaceType)surfaceType.floatValue; |
|||
if (surfaceTypeValue == SurfaceType.Transparent |
|||
&& refractionMode != null) |
|||
{ |
|||
EditorGUILayout.Space(); |
|||
EditorGUILayout.LabelField(StylesBaseUnlit.TransparencyInputsText, EditorStyles.boldLabel); |
|||
++EditorGUI.indentLevel; |
|||
|
|||
var isPrePass = material.HasProperty(kPreRefractionPass) && material.GetFloat(kPreRefractionPass) > 0.0; |
|||
if (refractionMode != null |
|||
// Refraction is not available for pre-refraction objects
|
|||
&& !isPrePass) |
|||
{ |
|||
m_MaterialEditor.ShaderProperty(refractionMode, Styles.refractionModeText); |
|||
var mode = (Lit.RefractionMode)refractionMode.floatValue; |
|||
if (mode != Lit.RefractionMode.None) |
|||
{ |
|||
++EditorGUI.indentLevel; |
|||
|
|||
m_MaterialEditor.ShaderProperty(ior, Styles.refractionIORText); |
|||
|
|||
blendMode.floatValue = (float)BlendMode.Alpha; |
|||
|
|||
if (thicknessMap[0].textureValue == null) |
|||
m_MaterialEditor.ShaderProperty(thickness[0], Styles.refractionThicknessText); |
|||
m_MaterialEditor.TexturePropertySingleLine(Styles.refractionThicknessMapText, thicknessMap[0]); |
|||
|
|||
++EditorGUI.indentLevel; |
|||
m_MaterialEditor.ShaderProperty(thicknessMultiplier, Styles.refractionThicknessMultiplierText); |
|||
--EditorGUI.indentLevel; |
|||
|
|||
m_MaterialEditor.ShaderProperty(transmittanceColor, Styles.transmittanceColorText); |
|||
++EditorGUI.indentLevel; |
|||
m_MaterialEditor.ShaderProperty(atDistance, Styles.atDistanceText); |
|||
atDistance.floatValue = Mathf.Max(atDistance.floatValue, 0); |
|||
--EditorGUI.indentLevel; |
|||
|
|||
--EditorGUI.indentLevel; |
|||
} |
|||
} |
|||
|
|||
DoDistortionInputsGUI(); |
|||
|
|||
--EditorGUI.indentLevel; |
|||
} |
|||
} |
|||
|
|||
private void DoEmissiveGUI(Material material) |
|||
{ |
|||
EditorGUILayout.Space(); |
|||
EditorGUILayout.LabelField(Styles.lightingText, EditorStyles.boldLabel); |
|||
m_MaterialEditor.ShaderProperty(enableSpecularOcclusion, Styles.enableSpecularOcclusionText); |
|||
// TODO: display warning if we don't have bent normal (either OS or TS) and ambient occlusion
|
|||
//if (enableSpecularOcclusion.floatValue > 0.0f)
|
|||
{ |
|||
//EditorGUILayout.HelpBox(Styles.specularOcclusionWarning.text, MessageType.Error);
|
|||
} |
|||
EditorGUI.indentLevel++; |
|||
m_MaterialEditor.TexturePropertySingleLine(Styles.emissiveText, emissiveColorMap, emissiveColor); |
|||
m_MaterialEditor.ShaderProperty(emissiveIntensity, Styles.emissiveIntensityText); |
|||
m_MaterialEditor.ShaderProperty(albedoAffectEmissive, Styles.albedoAffectEmissiveText); |
|||
EditorGUI.indentLevel--; |
|||
} |
|||
|
|||
protected override void MaterialPropertiesGUI(Material material) |
|||
{ |
|||
DoLayerGUI(material, 0); |
|||
DoEmissiveGUI(material); |
|||
// The parent Base.ShaderPropertiesGUI will call DoEmissionArea
|
|||
} |
|||
|
|||
protected override bool ShouldEmissionBeEnabled(Material mat) |
|||
{ |
|||
return mat.GetFloat(kEmissiveIntensity) > 0.0f; |
|||
} |
|||
|
|||
protected override void SetupMaterialKeywordsAndPassInternal(Material material) |
|||
{ |
|||
SetupMaterialKeywordsAndPass(material); |
|||
} |
|||
|
|||
// All Setup Keyword functions must be static. It allow to create script to automatically update the shaders with a script if code change
|
|||
static public void SetupMaterialKeywordsAndPass(Material material) |
|||
{ |
|||
SetupBaseLitKeywords(material); |
|||
SetupBaseLitMaterialPass(material); |
|||
|
|||
NormalMapSpace normalMapSpace = (NormalMapSpace)material.GetFloat(kNormalMapSpace); |
|||
|
|||
// Note: keywords must be based on Material value not on MaterialProperty due to multi-edit & material animation
|
|||
// (MaterialProperty value might come from renderer material property block)
|
|||
SetKeyword(material, "_MAPPING_PLANAR", ((UVBaseMapping)material.GetFloat(kUVBase)) == UVBaseMapping.Planar); |
|||
SetKeyword(material, "_MAPPING_TRIPLANAR", ((UVBaseMapping)material.GetFloat(kUVBase)) == UVBaseMapping.Triplanar); |
|||
SetKeyword(material, "_NORMALMAP_TANGENT_SPACE", (normalMapSpace == NormalMapSpace.TangentSpace)); |
|||
|
|||
if (normalMapSpace == NormalMapSpace.TangentSpace) |
|||
{ |
|||
// With details map, we always use a normal map and Unity provide a default (0, 0, 1) normal map for it
|
|||
SetKeyword(material, "_NORMALMAP", material.GetTexture(kNormalMap) || material.GetTexture(kDetailMap)); |
|||
SetKeyword(material, "_TANGENTMAP", material.GetTexture(kTangentMap)); |
|||
SetKeyword(material, "_BENTNORMALMAP", material.GetTexture(kBentNormalMap)); |
|||
} |
|||
else // Object space
|
|||
{ |
|||
// With details map, we always use a normal map but in case of objects space there is no good default, so the result will be weird until users fix it
|
|||
SetKeyword(material, "_NORMALMAP", material.GetTexture(kNormalMapOS) || material.GetTexture(kDetailMap)); |
|||
SetKeyword(material, "_TANGENTMAP", material.GetTexture(kTangentMapOS)); |
|||
SetKeyword(material, "_BENTNORMALMAP", material.GetTexture(kBentNormalMapOS)); |
|||
} |
|||
SetKeyword(material, "_MASKMAP", material.GetTexture(kMaskMap)); |
|||
SetKeyword(material, "_EMISSIVE_COLOR_MAP", material.GetTexture(kEmissiveColorMap)); |
|||
SetKeyword(material, "_ENABLESPECULAROCCLUSION", material.GetFloat(kEnableSpecularOcclusion) > 0.0f); |
|||
SetKeyword(material, "_HEIGHTMAP", material.GetTexture(kHeightMap)); |
|||
SetKeyword(material, "_ANISOTROPYMAP", material.GetTexture(kAnisotropyMap)); |
|||
SetKeyword(material, "_DETAIL_MAP", material.GetTexture(kDetailMap)); |
|||
SetKeyword(material, "_SUBSURFACE_RADIUS_MAP", material.GetTexture(kSubsurfaceRadiusMap)); |
|||
SetKeyword(material, "_THICKNESSMAP", material.GetTexture(kThicknessMap)); |
|||
SetKeyword(material, "_SPECULARCOLORMAP", material.GetTexture(kSpecularColorMap)); |
|||
|
|||
bool needUV2 = (UVDetailMapping)material.GetFloat(kUVDetail) == UVDetailMapping.UV2 && (UVBaseMapping)material.GetFloat(kUVBase) == UVBaseMapping.UV0; |
|||
bool needUV3 = (UVDetailMapping)material.GetFloat(kUVDetail) == UVDetailMapping.UV3 && (UVBaseMapping)material.GetFloat(kUVBase) == UVBaseMapping.UV0; |
|||
|
|||
if (needUV3) |
|||
{ |
|||
material.DisableKeyword("_REQUIRE_UV2"); |
|||
material.EnableKeyword("_REQUIRE_UV3"); |
|||
} |
|||
else if (needUV2) |
|||
{ |
|||
material.EnableKeyword("_REQUIRE_UV2"); |
|||
material.DisableKeyword("_REQUIRE_UV3"); |
|||
} |
|||
else |
|||
{ |
|||
material.DisableKeyword("_REQUIRE_UV2"); |
|||
material.DisableKeyword("_REQUIRE_UV3"); |
|||
} |
|||
|
|||
Lit.MaterialId materialId = (Lit.MaterialId)material.GetFloat(kMaterialID); |
|||
|
|||
SetKeyword(material, "_MATID_SSS", materialId == Lit.MaterialId.LitSSS); |
|||
//SetKeyword(material, "_MATID_STANDARD", materialId == Lit.MaterialId.LitStandard); // See comment in Lit.shader, it is the default, we don't define it
|
|||
SetKeyword(material, "_MATID_ANISO", materialId == Lit.MaterialId.LitAniso); |
|||
SetKeyword(material, "_MATID_SPECULAR", materialId == Lit.MaterialId.LitSpecular); |
|||
SetKeyword(material, "_MATID_CLEARCOAT", materialId == Lit.MaterialId.LitClearCoat); |
|||
|
|||
var refractionModeValue = (Lit.RefractionMode)material.GetFloat(kRefractionMode); |
|||
// We can't have refraction in pre-refraction queue
|
|||
var canHaveRefraction = !material.HasProperty(kPreRefractionPass) || material.GetFloat(kPreRefractionPass) <= 0.0; |
|||
SetKeyword(material, "_REFRACTION_PLANE", (refractionModeValue == Lit.RefractionMode.Plane) && canHaveRefraction); |
|||
SetKeyword(material, "_REFRACTION_SPHERE", (refractionModeValue == Lit.RefractionMode.Sphere) && canHaveRefraction); |
|||
} |
|||
} |
|||
} // namespace UnityEditor
|
|||
|
|||
fileFormatVersion: 2 |
|||
guid: 9edd3532e964f694e90a49a5dd8ec0e5 |
|||
timeCreated: 1509479758 |
|||
licenseType: Pro |
|||
MonoImporter: |
|||
externalObjects: {} |
|||
serializedVersion: 2 |
|||
defaultReferences: [] |
|||
executionOrder: 0 |
|||
icon: {instanceID: 0} |
|||
userData: |
|||
assetBundleName: |
|||
assetBundleVariant: |
|||
|
|||
Shader "HDRenderPipeline/Vegetation" |
|||
{ |
|||
Properties |
|||
{ |
|||
// Following set of parameters represent the parameters node inside the MaterialGraph. |
|||
// They are use to fill a SurfaceData. With a MaterialGraph this should not exist. |
|||
|
|||
// Reminder. Color here are in linear but the UI (color picker) do the conversion sRGB to linear |
|||
_BaseColor("BaseColor", Color) = (1,1,1,1) |
|||
_BaseColorMap("BaseColorMap", 2D) = "white" {} |
|||
|
|||
_Metallic("_Metallic", Range(0.0, 1.0)) = 0 |
|||
_Smoothness("Smoothness", Range(0.0, 1.0)) = 1.0 |
|||
_MaskMap("MaskMap", 2D) = "white" {} |
|||
_SmoothnessRemapMin("SmoothnessRemapMin", Float) = 0.0 |
|||
_SmoothnessRemapMax("SmoothnessRemapMax", Float) = 1.0 |
|||
|
|||
_NormalMap("NormalMap", 2D) = "bump" {} // Tangent space normal map |
|||
_NormalMapOS("NormalMapOS", 2D) = "white" {} // Object space normal map - no good default value |
|||
_NormalScale("_NormalScale", Range(0.0, 2.0)) = 1 |
|||
|
|||
_BentNormalMap("_BentNormalMap", 2D) = "bump" {} |
|||
_BentNormalMapOS("_BentNormalMapOS", 2D) = "white" {} |
|||
|
|||
_HeightMap("HeightMap", 2D) = "black" {} |
|||
// Caution: Default value of _HeightAmplitude must be (_HeightMax - _HeightMin) * 0.01 |
|||
[HideInInspector] _HeightAmplitude("Height Amplitude", Float) = 0.02 // In world units. This will be computed in the UI. |
|||
_HeightMin("Heightmap Min", Float) = -1 |
|||
_HeightMax("Heightmap Max", Float) = 1 |
|||
_HeightCenter("Height Center", Range(0.0, 1.0)) = 0.5 // In texture space |
|||
|
|||
_DetailMap("DetailMap", 2D) = "black" {} |
|||
_DetailAlbedoScale("_DetailAlbedoScale", Range(0.0, 2.0)) = 1 |
|||
_DetailNormalScale("_DetailNormalScale", Range(0.0, 2.0)) = 1 |
|||
_DetailSmoothnessScale("_DetailSmoothnessScale", Range(0.0, 2.0)) = 1 |
|||
|
|||
_TangentMap("TangentMap", 2D) = "bump" {} |
|||
_TangentMapOS("TangentMapOS", 2D) = "white" {} |
|||
_Anisotropy("Anisotropy", Range(-1.0, 1.0)) = 0 |
|||
_AnisotropyMap("AnisotropyMap", 2D) = "white" {} |
|||
|
|||
_SubsurfaceProfile("Subsurface Profile", Int) = 0 |
|||
_SubsurfaceRadius("Subsurface Radius", Range(0.0, 1.0)) = 1.0 |
|||
_SubsurfaceRadiusMap("Subsurface Radius Map", 2D) = "white" {} |
|||
_Thickness("Thickness", Range(0.0, 1.0)) = 1.0 |
|||
_ThicknessMap("Thickness Map", 2D) = "white" {} |
|||
_ThicknessRemap("Thickness Remap", Vector) = (0, 1, 0, 0) |
|||
|
|||
_CoatCoverage("Coat Coverage", Range(0.0, 1.0)) = 1.0 |
|||
_CoatIOR("Coat IOR", Range(0.0, 1.0)) = 0.5 |
|||
|
|||
_SpecularColor("SpecularColor", Color) = (1, 1, 1, 1) |
|||
_SpecularColorMap("SpecularColorMap", 2D) = "white" {} |
|||
|
|||
// Following options are for the GUI inspector and different from the input parameters above |
|||
// These option below will cause different compilation flag. |
|||
[ToggleOff] _EnableSpecularOcclusion("Enable specular occlusion", Float) = 0.0 |
|||
|
|||
_EmissiveColor("EmissiveColor", Color) = (0, 0, 0) |
|||
_EmissiveColorMap("EmissiveColorMap", 2D) = "white" {} |
|||
_EmissiveIntensity("EmissiveIntensity", Float) = 0 |
|||
[ToggleOff] _AlbedoAffectEmissive("Albedo Affect Emissive", Float) = 0.0 |
|||
|
|||
_DistortionVectorMap("DistortionVectorMap", 2D) = "black" {} |
|||
[ToggleOff] _DistortionEnable("Enable Distortion", Float) = 0.0 |
|||
[ToggleOff] _DistortionDepthTest("Distortion Depth Test Enable", Float) = 1.0 |
|||
[Enum(Add, 0, Multiply, 1)] _DistortionBlendMode("Distortion Blend Mode", Int) = 0 |
|||
[HideInInspector] _DistortionSrcBlend("Distortion Blend Src", Int) = 0 |
|||
[HideInInspector] _DistortionDstBlend("Distortion Blend Dst", Int) = 0 |
|||
[HideInInspector] _DistortionBlurSrcBlend("Distortion Blur Blend Src", Int) = 0 |
|||
[HideInInspector] _DistortionBlurDstBlend("Distortion Blur Blend Dst", Int) = 0 |
|||
[HideInInspector] _DistortionBlurBlendMode("Distortion Blur Blend Mode", Int) = 0 |
|||
_DistortionScale("Distortion Scale", Float) = 1 |
|||
_DistortionBlurScale("Distortion Blur Scale", Float) = 1 |
|||
_DistortionBlurRemapMin("DistortionBlurRemapMin", Float) = 0.0 |
|||
_DistortionBlurRemapMax("DistortionBlurRemapMax", Float) = 1.0 |
|||
|
|||
[ToggleOff] _AlphaCutoffEnable("Alpha Cutoff Enable", Float) = 0.0 |
|||
_AlphaCutoff("Alpha Cutoff", Range(0.0, 1.0)) = 0.5 |
|||
|
|||
// Transparency |
|||
[Enum(None, 0, Plane, 1, Sphere, 2)]_RefractionMode("Refraction Mode", Int) = 0 |
|||
_IOR("Indice Of Refraction", Range(1.0, 2.5)) = 1.0 |
|||
_ThicknessMultiplier("Thickness Multiplier", Float) = 1.0 |
|||
_TransmittanceColor("Transmittance Color", Color) = (1.0, 1.0, 1.0) |
|||
_ATDistance("Transmittance Absorption Distance", Float) = 1.0 |
|||
[ToggleOff] _PreRefractionPass("PreRefractionPass", Float) = 0.0 |
|||
|
|||
// Stencil state |
|||
[HideInInspector] _StencilRef("_StencilRef", Int) = 2 // StencilLightingUsage.RegularLighting (fixed at compile time) |
|||
|
|||
// Blending state |
|||
[HideInInspector] _SurfaceType("__surfacetype", Float) = 0.0 |
|||
[HideInInspector] _BlendMode("__blendmode", Float) = 0.0 |
|||
[HideInInspector] _SrcBlend("__src", Float) = 1.0 |
|||
[HideInInspector] _DstBlend("__dst", Float) = 0.0 |
|||
[HideInInspector] _ZWrite("__zw", Float) = 1.0 |
|||
[HideInInspector] _CullMode("__cullmode", Float) = 2.0 |
|||
[HideInInspector] _ZTestMode("_ZTestMode", Int) = 8 |
|||
|
|||
[ToggleOff] _EnableFogOnTransparent("Enable Fog", Float) = 1.0 |
|||
[ToggleOff] _EnableBlendModePreserveSpecularLighting("Enable Blend Mode Preserve Specular Lighting", Float) = 1.0 |
|||
|
|||
[ToggleOff] _DoubleSidedEnable("Double sided enable", Float) = 0.0 |
|||
[Enum(None, 0, Mirror, 1, Flip, 2)] _DoubleSidedNormalMode("Double sided normal mode", Float) = 1 |
|||
[HideInInspector] _DoubleSidedConstants("_DoubleSidedConstants", Vector) = (1, 1, -1, 0) |
|||
|
|||
[Enum(UV0, 0, Planar, 4, TriPlanar, 5)] _UVBase("UV Set for base", Float) = 0 |
|||
_TexWorldScale("Scale to apply on world coordinate", Float) = 1.0 |
|||
[HideInInspector] _InvTilingScale("Inverse tiling scale = 2 / (abs(_BaseColorMap_ST.x) + abs(_BaseColorMap_ST.y))", Float) = 1 |
|||
[HideInInspector] _UVMappingMask("_UVMappingMask", Color) = (1, 0, 0, 0) |
|||
[Enum(TangentSpace, 0, ObjectSpace, 1)] _NormalMapSpace("NormalMap space", Float) = 0 |
|||
|
|||
[Enum(Subsurface Scattering, 0, Standard, 1, Anisotropy, 2, ClearCoat, 3, Specular Color, 4)] _MaterialID("MaterialId", Int) = 1 // MaterialId.RegularLighting |
|||
|
|||
[Enum(None, 0, Vertex displacement, 1, Pixel displacement, 2)] _DisplacementMode("DisplacementMode", Int) = 0 |
|||
[ToggleOff] _DisplacementLockObjectScale("displacement lock object scale", Float) = 1.0 |
|||
[ToggleOff] _DisplacementLockTilingScale("displacement lock tiling scale", Float) = 1.0 |
|||
[ToggleOff] _DepthOffsetEnable("Depth Offset View space", Float) = 0.0 |
|||
|
|||
_PPDMinSamples("Min sample for POM", Range(1.0, 64.0)) = 5 |
|||
_PPDMaxSamples("Max sample for POM", Range(1.0, 64.0)) = 15 |
|||
_PPDLodThreshold("Start lod to fade out the POM effect", Range(0.0, 16.0)) = 5 |
|||
_PPDPrimitiveLength("Primitive length for POM", Float) = 1 |
|||
_PPDPrimitiveWidth("Primitive width for POM", Float) = 1 |
|||
[HideInInspector] _InvPrimScale("Inverse primitive scale for non-planar POM", Vector) = (1, 1, 0, 0) |
|||
|
|||
[Enum(UV0, 0, UV1, 1, UV2, 2, UV3, 3)] _UVDetail("UV Set for detail", Float) = 0 |
|||
[HideInInspector] _UVDetailsMappingMask("_UVDetailsMappingMask", Color) = (1, 0, 0, 0) |
|||
[ToggleOff] _LinkDetailsWithBase("LinkDetailsWithBase", Float) = 1.0 |
|||
[Enum(Use Emissive Color, 0, Use Emissive Mask, 1)] _EmissiveColorMode("Emissive color mode", Float) = 1 |
|||
|
|||
// Wind |
|||
[ToggleOff] _EnableWind("Enable Wind", Float) = 0.0 |
|||
_InitialBend("Initial Bend", float) = 1.0 |
|||
_Stiffness("Stiffness", float) = 1.0 |
|||
_Drag("Drag", float) = 1.0 |
|||
_ShiverDrag("Shiver Drag", float) = 0.2 |
|||
_ShiverDirectionality("Shiver Directionality", Range(0.0, 1.0)) = 0.5 |
|||
|
|||
//------------------------------------------------------- |
|||
//Windup Vegetation Wind |
|||
_VegNoise("Noise", 2D) = "white" {} |
|||
_VegWindMask("Wind Mask", 2D) = "white" {} |
|||
_VegPivot("Pivot", Vector) = (0, 0, 0, 0) |
|||
_VegStiffness("Stiffness", Range(0.1, 3.0)) = 1.0 |
|||
_VegAssistantDirectional("Assistant Directional", Vector) = (0, 0, 0, 0) |
|||
_VegWindDirection("Wind Direction", Vector) = (0, 0, 0, 0) |
|||
_VegWindIntensity("Wind Intensity", Range(0.0, 1.0)) = 1.0 |
|||
_VegWindSpeed("Wind Speed", Range(0.0, 2.0)) = 1.0 |
|||
_VegDetailVariation("Detail Variation", Range(0.0, 100.0)) = 1.0 |
|||
_VegLeafShakeScale("Leaf Shake Scale", Range(0.01, 8.0)) = 1.0 |
|||
_VegLeafShakeSpeed("Leaf Shake Speed", Range(0.0, 1.0)) = 1.0 |
|||
_VegLeafShakePower("Leaf Shake Power", Range(0.0, 3.0)) = 1.0 |
|||
_VegPerLeafBendScale("Per-Leaf Bend Scale", Range(0.01, 3.0)) = 1.0 |
|||
_VegPerLeafBendSpeed("Per-Leaf Bend Speed", Range(0.0, 1.0)) = 1.0 |
|||
_VegPerLeafBendPower("Per-Leaf Bend Power", Range(0.0, 5.0)) = 1.0 |
|||
//------------------------------------------------------- |
|||
|
|||
// Caution: C# code in BaseLitUI.cs call LightmapEmissionFlagsProperty() which assume that there is an existing "_EmissionColor" |
|||
// value that exist to identify if the GI emission need to be enabled. |
|||
// In our case we don't use such a mechanism but need to keep the code quiet. We declare the value and always enable it. |
|||
// TODO: Fix the code in legacy unity so we can customize the beahvior for GI |
|||
_EmissionColor("Color", Color) = (1, 1, 1) |
|||
|
|||
// HACK: GI Baking system relies on some properties existing in the shader ("_MainTex", "_Cutoff" and "_Color") for opacity handling, so we need to store our version of those parameters in the hard-coded name the GI baking system recognizes. |
|||
_MainTex("Albedo", 2D) = "white" {} |
|||
_Color("Color", Color) = (1,1,1,1) |
|||
_Cutoff("Alpha Cutoff", Range(0.0, 1.0)) = 0.5 |
|||
} |
|||
|
|||
HLSLINCLUDE |
|||
|
|||
#pragma target 4.5 |
|||
#pragma only_renderers d3d11 ps4 metal // TEMP: until we go futher in dev |
|||
//#pragma enable_d3d11_debug_symbols |
|||
|
|||
//------------------------------------------------------------------------------------- |
|||
// Variant |
|||
//------------------------------------------------------------------------------------- |
|||
|
|||
#pragma shader_feature _ALPHATEST_ON |
|||
#pragma shader_feature _DEPTHOFFSET_ON |
|||
#pragma shader_feature _DOUBLESIDED_ON |
|||
#pragma shader_feature _ _VERTEX_DISPLACEMENT _PIXEL_DISPLACEMENT |
|||
#pragma shader_feature _VERTEX_DISPLACEMENT_LOCK_OBJECT_SCALE |
|||
#pragma shader_feature _DISPLACEMENT_LOCK_TILING_SCALE |
|||
#pragma shader_feature _PIXEL_DISPLACEMENT_LOCK_OBJECT_SCALE |
|||
#pragma shader_feature _VERTEX_WIND |
|||
#pragma shader_feature _ _REFRACTION_PLANE _REFRACTION_SPHERE |
|||
|
|||
#pragma shader_feature _ _MAPPING_PLANAR _MAPPING_TRIPLANAR |
|||
#pragma shader_feature _NORMALMAP_TANGENT_SPACE |
|||
#pragma shader_feature _ _REQUIRE_UV2 _REQUIRE_UV3 |
|||
|
|||
#pragma shader_feature _NORMALMAP |
|||
#pragma shader_feature _MASKMAP |
|||
#pragma shader_feature _BENTNORMALMAP |
|||
#pragma shader_feature _EMISSIVE_COLOR_MAP |
|||
#pragma shader_feature _ENABLESPECULAROCCLUSION |
|||
#pragma shader_feature _HEIGHTMAP |
|||
#pragma shader_feature _TANGENTMAP |
|||
#pragma shader_feature _ANISOTROPYMAP |
|||
#pragma shader_feature _DETAIL_MAP |
|||
#pragma shader_feature _SUBSURFACE_RADIUS_MAP |
|||
#pragma shader_feature _THICKNESSMAP |
|||
#pragma shader_feature _SPECULARCOLORMAP |
|||
|
|||
// Keyword for transparent |
|||
#pragma shader_feature _SURFACE_TYPE_TRANSPARENT |
|||
#pragma shader_feature _ _BLENDMODE_ALPHA _BLENDMODE_ADD _BLENDMODE_MULTIPLY _BLENDMODE_PRE_MULTIPLY |
|||
#pragma shader_feature _BLENDMODE_PRESERVE_SPECULAR_LIGHTING |
|||
#pragma shader_feature _ENABLE_FOG_ON_TRANSPARENT |
|||
|
|||
// MaterialId are used as shader feature to allow compiler to optimize properly |
|||
// Note _MATID_STANDARD is not define as there is always the default case "_". We assign default as _MATID_STANDARD, so we never test _MATID_STANDARD |
|||
#pragma shader_feature _ _MATID_SSS _MATID_ANISO _MATID_SPECULAR _MATID_CLEARCOAT |
|||
|
|||
#pragma multi_compile LIGHTMAP_OFF LIGHTMAP_ON |
|||
#pragma multi_compile DIRLIGHTMAP_OFF DIRLIGHTMAP_COMBINED |
|||
#pragma multi_compile DYNAMICLIGHTMAP_OFF DYNAMICLIGHTMAP_ON |
|||
// enable dithering LOD crossfade |
|||
#pragma multi_compile _ LOD_FADE_CROSSFADE |
|||
// TODO: We should have this keyword only if VelocityInGBuffer is enable, how to do that ? |
|||
//#pragma multi_compile VELOCITYOUTPUT_OFF VELOCITYOUTPUT_ON |
|||
|
|||
//------------------------------------------------------------------------------------- |
|||
// Define |
|||
//------------------------------------------------------------------------------------- |
|||
|
|||
#define UNITY_MATERIAL_LIT // Need to be define before including Material.hlsl |
|||
// Use surface gradient normal mapping as it handle correctly triplanar normal mapping and multiple UVSet |
|||
#define SURFACE_GRADIENT |
|||
// This shader support vertex modification |
|||
#define HAVE_VERTEX_MODIFICATION |
|||
|
|||
//------------------------------------------------------------------------------------- |
|||
// Include |
|||
//------------------------------------------------------------------------------------- |
|||
|
|||
#include "../../../Core/ShaderLibrary/Common.hlsl" |
|||
#include "../../../Core/ShaderLibrary/Wind.hlsl" |
|||
#include "../../ShaderPass/FragInputs.hlsl" |
|||
#include "../../ShaderPass/ShaderPass.cs.hlsl" |
|||
|
|||
|
|||
//------------------------------------------------------------------------------------- |
|||
// variable declaration |
|||
//------------------------------------------------------------------------------------- |
|||
|
|||
#include "../../Material/Lit/LitProperties.hlsl" |
|||
|
|||
// All our shaders use same name for entry point |
|||
#pragma vertex Vert |
|||
#pragma fragment Frag |
|||
|
|||
ENDHLSL |
|||
|
|||
SubShader |
|||
{ |
|||
Pass |
|||
{ |
|||
Name "GBuffer" // Name is not used |
|||
Tags { "LightMode" = "GBuffer" } // This will be only for opaque object based on the RenderQueue index |
|||
|
|||
Cull [_CullMode] |
|||
|
|||
Stencil |
|||
{ |
|||
Ref [_StencilRef] |
|||
Comp Always |
|||
Pass Replace |
|||
} |
|||
|
|||
HLSLPROGRAM |
|||
|
|||
#define ATTRIBUTES_NEED_TEXCOORD0 |
|||
#define ATTRIBUTES_NEED_COLOR |
|||
|
|||
#define SHADERPASS SHADERPASS_GBUFFER |
|||
#include "../../ShaderVariables.hlsl" |
|||
#include "../../Material/Material.hlsl" |
|||
#include "../Lit/ShaderPass/LitSharePass.hlsl" |
|||
#include "VegetationData.hlsl" |
|||
#include "../../ShaderPass/ShaderPassGBuffer.hlsl" |
|||
|
|||
ENDHLSL |
|||
} |
|||
|
|||
// This pass is the same as GBuffer only it does not do alpha test (the clip instruction is removed) |
|||
// This is due to the fact that on GCN, any shader with a clip instruction cannot benefit from HiZ so when we do a prepass, in order to get the most performance, we need to make a special case in the subsequent GBuffer pass. |
|||
Pass |
|||
{ |
|||
Name "GBufferWithPrepass" // Name is not used |
|||
Tags { "LightMode" = "GBufferWithPrepass" } // This will be only for opaque object based on the RenderQueue index |
|||
|
|||
Cull [_CullMode] |
|||
|
|||
Stencil |
|||
{ |
|||
Ref [_StencilRef] |
|||
Comp Always |
|||
Pass Replace |
|||
} |
|||
|
|||
HLSLPROGRAM |
|||
|
|||
#define SHADERPASS SHADERPASS_GBUFFER |
|||
#define SHADERPASS_GBUFFER_BYPASS_ALPHA_TEST |
|||
#include "../../ShaderVariables.hlsl" |
|||
#include "../../Material/Material.hlsl" |
|||
#include "../Lit/ShaderPass/LitSharePass.hlsl" |
|||
#include "VegetationData.hlsl" |
|||
#include "../../ShaderPass/ShaderPassGBuffer.hlsl" |
|||
|
|||
ENDHLSL |
|||
} |
|||
|
|||
Pass |
|||
{ |
|||
Name "GBufferDebugDisplay" // Name is not used |
|||
Tags{ "LightMode" = "GBufferDebugDisplay" } // This will be only for opaque object based on the RenderQueue index |
|||
|
|||
Cull [_CullMode] |
|||
|
|||
Stencil |
|||
{ |
|||
Ref [_StencilRef] |
|||
Comp Always |
|||
Pass Replace |
|||
} |
|||
|
|||
HLSLPROGRAM |
|||
|
|||
#define DEBUG_DISPLAY |
|||
#define SHADERPASS SHADERPASS_GBUFFER |
|||
#include "../../ShaderVariables.hlsl" |
|||
#include "../../Debug/DebugDisplay.hlsl" |
|||
#include "../../Material/Material.hlsl" |
|||
#include "../Lit/ShaderPass/LitSharePass.hlsl" |
|||
#include "VegetationData.hlsl" |
|||
#include "../../ShaderPass/ShaderPassGBuffer.hlsl" |
|||
|
|||
ENDHLSL |
|||
} |
|||
|
|||
// Extracts information for lightmapping, GI (emission, albedo, ...) |
|||
// This pass it not used during regular rendering. |
|||
Pass |
|||
{ |
|||
Name "META" |
|||
Tags{ "LightMode" = "Meta" } |
|||
|
|||
Cull Off |
|||
|
|||
HLSLPROGRAM |
|||
|
|||
// Lightmap memo |
|||
// DYNAMICLIGHTMAP_ON is used when we have an "enlighten lightmap" ie a lightmap updated at runtime by enlighten.This lightmap contain indirect lighting from realtime lights and realtime emissive material.Offline baked lighting(from baked material / light, |
|||
// both direct and indirect lighting) will hand up in the "regular" lightmap->LIGHTMAP_ON. |
|||
|
|||
#define SHADERPASS SHADERPASS_LIGHT_TRANSPORT |
|||
#include "../../ShaderVariables.hlsl" |
|||
#include "../../Material/Material.hlsl" |
|||
#include "../Lit/ShaderPass/LitSharePass.hlsl" |
|||
#include "VegetationData.hlsl" |
|||
#include "../../ShaderPass/ShaderPassLightTransport.hlsl" |
|||
|
|||
ENDHLSL |
|||
} |
|||
|
|||
Pass |
|||
{ |
|||
Name "ShadowCaster" |
|||
Tags{ "LightMode" = "ShadowCaster" } |
|||
|
|||
Cull[_CullMode] |
|||
|
|||
ZClip Off |
|||
ZWrite On |
|||
ZTest LEqual |
|||
|
|||
HLSLPROGRAM |
|||
|
|||
//Need to force reading of uv + color for vertex animated shadows. |
|||
#define ATTRIBUTES_NEED_TEXCOORD0 |
|||
#define ATTRIBUTES_NEED_COLOR |
|||
|
|||
#define SHADERPASS SHADERPASS_SHADOWS |
|||
#define USE_LEGACY_UNITY_MATRIX_VARIABLES |
|||
#include "../../ShaderVariables.hlsl" |
|||
#include "../../Material/Material.hlsl" |
|||
#include "../Lit/ShaderPass/LitDepthPass.hlsl" |
|||
#include "VegetationData.hlsl" |
|||
#include "../../ShaderPass/ShaderPassDepthOnly.hlsl" |
|||
|
|||
ENDHLSL |
|||
} |
|||
|
|||
Pass |
|||
{ |
|||
Name "DepthOnly" |
|||
Tags{ "LightMode" = "DepthOnly" } |
|||
|
|||
Cull[_CullMode] |
|||
|
|||
ZWrite On |
|||
|
|||
HLSLPROGRAM |
|||
|
|||
#define SHADERPASS SHADERPASS_DEPTH_ONLY |
|||
#include "../../ShaderVariables.hlsl" |
|||
#include "../../Material/Material.hlsl" |
|||
#include "../Lit/ShaderPass/LitDepthPass.hlsl" |
|||
#include "VegetationData.hlsl" |
|||
#include "../../ShaderPass/ShaderPassDepthOnly.hlsl" |
|||
|
|||
ENDHLSL |
|||
} |
|||
|
|||
Pass |
|||
{ |
|||
Name "Motion Vectors" |
|||
Tags{ "LightMode" = "MotionVectors" } // Caution, this need to be call like this to setup the correct parameters by C++ (legacy Unity) |
|||
|
|||
Cull[_CullMode] |
|||
|
|||
ZWrite Off // TODO: Test Z equal here. |
|||
|
|||
HLSLPROGRAM |
|||
|
|||
#define SHADERPASS SHADERPASS_VELOCITY |
|||
#include "../../ShaderVariables.hlsl" |
|||
#include "../../Material/Material.hlsl" |
|||
#include "../Lit/ShaderPass/LitVelocityPass.hlsl" |
|||
#include "VegetationData.hlsl" |
|||
#include "../../ShaderPass/ShaderPassVelocity.hlsl" |
|||
|
|||
ENDHLSL |
|||
} |
|||
|
|||
Pass |
|||
{ |
|||
Name "Distortion" // Name is not used |
|||
Tags { "LightMode" = "DistortionVectors" } // This will be only for transparent object based on the RenderQueue index |
|||
|
|||
Blend [_DistortionSrcBlend] [_DistortionDstBlend], [_DistortionBlurSrcBlend] [_DistortionBlurDstBlend] |
|||
BlendOp Add, [_DistortionBlurBlendOp] |
|||
ZTest [_ZTestMode] |
|||
ZWrite off |
|||
Cull [_CullMode] |
|||
|
|||
HLSLPROGRAM |
|||
|
|||
#define SHADERPASS SHADERPASS_DISTORTION |
|||
#include "../../ShaderVariables.hlsl" |
|||
#include "../../Material/Material.hlsl" |
|||
#include "../Lit/ShaderPass/LitDistortionPass.hlsl" |
|||
#include "VegetationData.hlsl" |
|||
#include "../../ShaderPass/ShaderPassDistortion.hlsl" |
|||
|
|||
ENDHLSL |
|||
} |
|||
|
|||
Pass |
|||
{ |
|||
Name "Forward" // Name is not used |
|||
Tags { "LightMode" = "Forward" } // This will be only for transparent object based on the RenderQueue index |
|||
|
|||
Blend [_SrcBlend] [_DstBlend] |
|||
ZWrite [_ZWrite] |
|||
Cull [_CullMode] |
|||
|
|||
HLSLPROGRAM |
|||
|
|||
#define SHADERPASS SHADERPASS_FORWARD |
|||
#include "../../ShaderVariables.hlsl" |
|||
#include "../../Lighting/Forward.hlsl" |
|||
// TEMP until pragma work in include |
|||
#pragma multi_compile LIGHTLOOP_SINGLE_PASS LIGHTLOOP_TILE_PASS |
|||
|
|||
#include "../../Lighting/Lighting.hlsl" |
|||
#include "../Lit/ShaderPass/LitSharePass.hlsl" |
|||
#include "VegetationData.hlsl" |
|||
#include "../../ShaderPass/ShaderPassForward.hlsl" |
|||
|
|||
ENDHLSL |
|||
} |
|||
|
|||
Pass |
|||
{ |
|||
Name "ForwardDebugDisplay" // Name is not used |
|||
Tags{ "LightMode" = "ForwardDebugDisplay" } // This will be only for transparent object based on the RenderQueue index |
|||
|
|||
Blend[_SrcBlend][_DstBlend] |
|||
ZWrite[_ZWrite] |
|||
Cull[_CullMode] |
|||
|
|||
HLSLPROGRAM |
|||
|
|||
#define DEBUG_DISPLAY |
|||
#define SHADERPASS SHADERPASS_FORWARD |
|||
#include "../../ShaderVariables.hlsl" |
|||
#include "../../Debug/DebugDisplay.hlsl" |
|||
#include "../../Lighting/Forward.hlsl" |
|||
// TEMP until pragma work in include |
|||
#pragma multi_compile LIGHTLOOP_SINGLE_PASS LIGHTLOOP_TILE_PASS |
|||
|
|||
#include "../../Lighting/Lighting.hlsl" |
|||
#include "../Lit/ShaderPass/LitSharePass.hlsl" |
|||
#include "VegetationData.hlsl" |
|||
#include "../../ShaderPass/ShaderPassForward.hlsl" |
|||
|
|||
ENDHLSL |
|||
} |
|||
} |
|||
|
|||
CustomEditor "Experimental.Rendering.HDPipeline.VegetationGUI" |
|||
} |
|||
|
|||
fileFormatVersion: 2 |
|||
guid: ff1b756ebf5550048bed17a617e8f5b0 |
|||
timeCreated: 1509479425 |
|||
licenseType: Pro |
|||
ShaderImporter: |
|||
externalObjects: {} |
|||
defaultTextures: [] |
|||
userData: |
|||
assetBundleName: |
|||
assetBundleVariant: |
|||
|
|||
#include "../../../Core/ShaderLibrary/SampleUVMapping.hlsl" |
|||
#include "../MaterialUtilities.hlsl" |
|||
|
|||
//------------------------------------------------------------------------------------- |
|||
// Fill SurfaceData/Builtin data function |
|||
//------------------------------------------------------------------------------------- |
|||
|
|||
// TODO: move this function to commonLighting.hlsl once validated it work correctly |
|||
float GetSpecularOcclusionFromBentAO(float3 V, float3 bentNormalWS, SurfaceData surfaceData) |
|||
{ |
|||
// Retrieve cone angle |
|||
// Ambient occlusion is cosine weighted, thus use following equation. See slide 129 |
|||
float cosAv = sqrt(1.0 - surfaceData.ambientOcclusion); |
|||
float roughness = max(PerceptualSmoothnessToRoughness(surfaceData.perceptualSmoothness), 0.01); // Clamp to 0.01 to avoid edge cases |
|||
float cosAs = exp2(-3.32193 * Sqr(roughness)); |
|||
float cosB = dot(bentNormalWS, reflect(-V, surfaceData.normalWS)); |
|||
|
|||
return SphericalCapIntersectionSolidArea(cosAv, cosAs, cosB) / (TWO_PI * (1.0 - cosAs)); |
|||
} |
|||
|
|||
void GetBuiltinData(FragInputs input, SurfaceData surfaceData, float alpha, float3 bentNormalWS, float depthOffset, out BuiltinData builtinData) |
|||
{ |
|||
// Builtin Data |
|||
builtinData.opacity = alpha; |
|||
|
|||
// TODO: Sample lightmap/lightprobe/volume proxy |
|||
// This should also handle projective lightmap |
|||
builtinData.bakeDiffuseLighting = SampleBakedGI(input.positionWS, bentNormalWS, input.texCoord1, input.texCoord2); |
|||
|
|||
// It is safe to call this function here as surfaceData have been filled |
|||
// We want to know if we must enable transmission on GI for SSS material, if the material have no SSS, this code will be remove by the compiler. |
|||
BSDFData bsdfData = ConvertSurfaceDataToBSDFData(surfaceData); |
|||
if (bsdfData.enableTransmission) |
|||
{ |
|||
// For now simply recall the function with inverted normal, the compiler should be able to optimize the lightmap case to not resample the directional lightmap |
|||
// however it will not optimize the lightprobe case due to the proxy volume relying on dynamic if (we rely must get right of this dynamic if), not a problem for SH9, but a problem for proxy volume. |
|||
// TODO: optimize more this code. |
|||
// Add GI transmission contribution by resampling the GI for inverted vertex normal |
|||
builtinData.bakeDiffuseLighting += SampleBakedGI(input.positionWS, -input.worldToTangent[2], input.texCoord1, input.texCoord2) * bsdfData.transmittance; |
|||
} |
|||
|
|||
// Emissive Intensity is only use here, but is part of BuiltinData to enforce UI parameters as we want the users to fill one color and one intensity |
|||
builtinData.emissiveIntensity = _EmissiveIntensity; // We still store intensity here so we can reuse it with debug code |
|||
|
|||
builtinData.emissiveColor = _EmissiveColor * builtinData.emissiveIntensity * lerp(float3(1.0, 1.0, 1.0), surfaceData.baseColor.rgb, _AlbedoAffectEmissive); |
|||
#ifdef _EMISSIVE_COLOR_MAP |
|||
builtinData.emissiveColor *= SAMPLE_TEXTURE2D(_EmissiveColorMap, sampler_EmissiveColorMap, input.texCoord0).rgb; |
|||
#endif |
|||
|
|||
builtinData.velocity = float2(0.0, 0.0); |
|||
|
|||
#if (SHADERPASS == SHADERPASS_DISTORTION) || defined(DEBUG_DISPLAY) |
|||
float3 distortion = SAMPLE_TEXTURE2D(_DistortionVectorMap, sampler_DistortionVectorMap, input.texCoord0).rgb; |
|||
builtinData.distortion = distortion.rg * _DistortionScale; |
|||
builtinData.distortionBlur = clamp(distortion.b * _DistortionBlurScale, 0.0, 1.0) * (_DistortionBlurRemapMax - _DistortionBlurRemapMin) + _DistortionBlurRemapMin; |
|||
#else |
|||
builtinData.distortion = float2(0.0, 0.0); |
|||
builtinData.distortionBlur = 0.0; |
|||
#endif |
|||
|
|||
builtinData.depthOffset = depthOffset; |
|||
} |
|||
|
|||
// Struct that gather UVMapping info of all layers + common calculation |
|||
// This is use to abstract the mapping that can differ on layers |
|||
struct LayerTexCoord |
|||
{ |
|||
#ifndef LAYERED_LIT_SHADER |
|||
UVMapping base; |
|||
UVMapping details; |
|||
#else |
|||
// Regular texcoord |
|||
UVMapping base0; |
|||
UVMapping base1; |
|||
UVMapping base2; |
|||
UVMapping base3; |
|||
|
|||
UVMapping details0; |
|||
UVMapping details1; |
|||
UVMapping details2; |
|||
UVMapping details3; |
|||
|
|||
// Dedicated for blend mask |
|||
UVMapping blendMask; |
|||
#endif |
|||
|
|||
// Store information that will be share by all UVMapping |
|||
float3 vertexNormalWS; // TODO: store also object normal map for object triplanar |
|||
float3 triplanarWeights; |
|||
|
|||
#ifdef SURFACE_GRADIENT |
|||
// tangent basis for each UVSet - up to 4 for now |
|||
float3 vertexTangentWS0, vertexBitangentWS0; |
|||
float3 vertexTangentWS1, vertexBitangentWS1; |
|||
float3 vertexTangentWS2, vertexBitangentWS2; |
|||
float3 vertexTangentWS3, vertexBitangentWS3; |
|||
#endif |
|||
}; |
|||
|
|||
#ifdef SURFACE_GRADIENT |
|||
void GenerateLayerTexCoordBasisTB(FragInputs input, inout LayerTexCoord layerTexCoord) |
|||
{ |
|||
float3 vertexNormalWS = input.worldToTangent[2]; |
|||
|
|||
layerTexCoord.vertexTangentWS0 = input.worldToTangent[0]; |
|||
layerTexCoord.vertexBitangentWS0 = input.worldToTangent[1]; |
|||
|
|||
// TODO: We should use relative camera position here - This will be automatic when we will move to camera relative space. |
|||
float3 dPdx = ddx_fine(input.positionWS); |
|||
float3 dPdy = ddy_fine(input.positionWS); |
|||
|
|||
float3 sigmaX = dPdx - dot(dPdx, vertexNormalWS) * vertexNormalWS; |
|||
float3 sigmaY = dPdy - dot(dPdy, vertexNormalWS) * vertexNormalWS; |
|||
//float flipSign = dot(sigmaY, cross(vertexNormalWS, sigmaX) ) ? -1.0 : 1.0; |
|||
float flipSign = dot(dPdy, cross(vertexNormalWS, dPdx)) < 0.0 ? -1.0 : 1.0; // gives same as the commented out line above |
|||
|
|||
// TODO: Optimize! The compiler will not be able to remove the tangent space that are not use because it can't know due to our UVMapping constant we use for both base and details |
|||
// To solve this we should track which UVSet is use for normal mapping... Maybe not as simple as it sounds |
|||
SurfaceGradientGenBasisTB(vertexNormalWS, sigmaX, sigmaY, flipSign, input.texCoord1, layerTexCoord.vertexTangentWS1, layerTexCoord.vertexBitangentWS1); |
|||
#if defined(_REQUIRE_UV2) || defined(_REQUIRE_UV3) |
|||
SurfaceGradientGenBasisTB(vertexNormalWS, sigmaX, sigmaY, flipSign, input.texCoord2, layerTexCoord.vertexTangentWS2, layerTexCoord.vertexBitangentWS2); |
|||
#endif |
|||
#if defined(_REQUIRE_UV3) |
|||
SurfaceGradientGenBasisTB(vertexNormalWS, sigmaX, sigmaY, flipSign, input.texCoord3, layerTexCoord.vertexTangentWS3, layerTexCoord.vertexBitangentWS3); |
|||
#endif |
|||
} |
|||
#endif |
|||
|
|||
#ifndef LAYERED_LIT_SHADER |
|||
|
|||
// Want to use only one sampler for normalmap/bentnormalmap either we use OS or TS. And either we have normal map or bent normal or both. |
|||
#ifdef _NORMALMAP_TANGENT_SPACE |
|||
#if defined(_NORMALMAP) |
|||
#define SAMPLER_NORMALMAP_IDX sampler_NormalMap |
|||
#elif defined(_BENTNORMALMAP) |
|||
#define SAMPLER_NORMALMAP_IDX sampler_BentNormalMap |
|||
#endif |
|||
#else |
|||
#if defined(_NORMALMAP) |
|||
#define SAMPLER_NORMALMAP_IDX sampler_NormalMapOS |
|||
#elif defined(_BENTNORMALMAP) |
|||
#define SAMPLER_NORMALMAP_IDX sampler_BentNormalMapOS |
|||
#endif |
|||
#endif |
|||
|
|||
#define SAMPLER_DETAILMAP_IDX sampler_DetailMap |
|||
#define SAMPLER_MASKMAP_IDX sampler_MaskMap |
|||
#define SAMPLER_HEIGHTMAP_IDX sampler_HeightMap |
|||
|
|||
#define SAMPLER_SUBSURFACE_RADIUSMAP_IDX sampler_SubsurfaceRadiusMap |
|||
#define SAMPLER_THICKNESSMAP_IDX sampler_ThicknessMap |
|||
|
|||
// include LitDataIndividualLayer to define GetSurfaceData |
|||
#define LAYER_INDEX 0 |
|||
#define ADD_IDX(Name) Name |
|||
#define ADD_ZERO_IDX(Name) Name |
|||
#ifdef _NORMALMAP |
|||
#define _NORMALMAP_IDX |
|||
#endif |
|||
#ifdef _NORMALMAP_TANGENT_SPACE |
|||
#define _NORMALMAP_TANGENT_SPACE_IDX |
|||
#endif |
|||
#ifdef _DETAIL_MAP |
|||
#define _DETAIL_MAP_IDX |
|||
#endif |
|||
#ifdef _SUBSURFACE_RADIUS_MAP |
|||
#define _SUBSURFACE_RADIUS_MAP_IDX |
|||
#endif |
|||
#ifdef _THICKNESSMAP |
|||
#define _THICKNESSMAP_IDX |
|||
#endif |
|||
#ifdef _MASKMAP |
|||
#define _MASKMAP_IDX |
|||
#endif |
|||
#ifdef _BENTNORMALMAP |
|||
#define _BENTNORMALMAP_IDX |
|||
#endif |
|||
#include "../Lit/LitDataIndividualLayer.hlsl" |
|||
|
|||
// This maybe call directly by tessellation (domain) shader, thus all part regarding surface gradient must be done |
|||
// in function with FragInputs input as parameters |
|||
// layerTexCoord must have been initialize to 0 outside of this function |
|||
void GetLayerTexCoord(float2 texCoord0, float2 texCoord1, float2 texCoord2, float2 texCoord3, |
|||
float3 positionWS, float3 vertexNormalWS, inout LayerTexCoord layerTexCoord) |
|||
{ |
|||
layerTexCoord.vertexNormalWS = vertexNormalWS; |
|||
layerTexCoord.triplanarWeights = ComputeTriplanarWeights(vertexNormalWS); |
|||
|
|||
int mappingType = UV_MAPPING_UVSET; |
|||
#if defined(_MAPPING_PLANAR) |
|||
mappingType = UV_MAPPING_PLANAR; |
|||
#elif defined(_MAPPING_TRIPLANAR) |
|||
mappingType = UV_MAPPING_TRIPLANAR; |
|||
#endif |
|||
|
|||
// Be sure that the compiler is aware that we don't use UV1 to UV3 for main layer so it can optimize code |
|||
ComputeLayerTexCoord( texCoord0, texCoord1, texCoord2, texCoord3, float4(1.0, 0.0, 0.0, 0.0), _UVDetailsMappingMask, |
|||
_BaseColorMap_ST.xy, _BaseColorMap_ST.zw, _DetailMap_ST.xy, _DetailMap_ST.zw, 1.0, _LinkDetailsWithBase, |
|||
positionWS, _TexWorldScale, |
|||
mappingType, layerTexCoord); |
|||
} |
|||
|
|||
// This is call only in this file |
|||
// layerTexCoord must have been initialize to 0 outside of this function |
|||
void GetLayerTexCoord(FragInputs input, inout LayerTexCoord layerTexCoord) |
|||
{ |
|||
#ifdef SURFACE_GRADIENT |
|||
GenerateLayerTexCoordBasisTB(input, layerTexCoord); |
|||
#endif |
|||
|
|||
GetLayerTexCoord( input.texCoord0, input.texCoord1, input.texCoord2, input.texCoord3, |
|||
input.positionWS, input.worldToTangent[2].xyz, layerTexCoord); |
|||
} |
|||
|
|||
#include "../Lit/LitDataDisplacement.hlsl" |
|||
|
|||
void GetSurfaceAndBuiltinData(FragInputs input, float3 V, inout PositionInputs posInput, out SurfaceData surfaceData, out BuiltinData builtinData) |
|||
{ |
|||
#ifdef LOD_FADE_CROSSFADE // enable dithering LOD transition if user select CrossFade transition in LOD group |
|||
LODDitheringTransition(posInput.unPositionSS, unity_LODFade.x); |
|||
#endif |
|||
|
|||
ApplyDoubleSidedFlipOrMirror(input); // Apply double sided flip on the vertex normal |
|||
|
|||
LayerTexCoord layerTexCoord; |
|||
ZERO_INITIALIZE(LayerTexCoord, layerTexCoord); |
|||
GetLayerTexCoord(input, layerTexCoord); |
|||
|
|||
float depthOffset = ApplyPerPixelDisplacement(input, V, layerTexCoord); |
|||
|
|||
#ifdef _DEPTHOFFSET_ON |
|||
ApplyDepthOffsetPositionInput(V, depthOffset, GetWorldToHClipMatrix(), posInput); |
|||
#endif |
|||
|
|||
// We perform the conversion to world of the normalTS outside of the GetSurfaceData |
|||
// so it allow us to correctly deal with detail normal map and optimize the code for the layered shaders |
|||
float3 normalTS; |
|||
float3 bentNormalTS; |
|||
float3 bentNormalWS; |
|||
float alpha = GetSurfaceData(input, layerTexCoord, surfaceData, normalTS, bentNormalTS); |
|||
GetNormalWS(input, V, normalTS, surfaceData.normalWS); |
|||
// Use bent normal to sample GI if available |
|||
#ifdef _BENTNORMALMAP |
|||
GetNormalWS(input, V, bentNormalTS, bentNormalWS); |
|||
#else |
|||
bentNormalWS = surfaceData.normalWS; |
|||
#endif |
|||
|
|||
// By default we use the ambient occlusion with Tri-ace trick (apply outside) for specular occlusion. |
|||
// If user provide bent normal then we process a better term |
|||
#if defined(_BENTNORMALMAP) && defined(_ENABLESPECULAROCCLUSION) |
|||
// If we have bent normal and ambient occlusion, process a specular occlusion |
|||
surfaceData.specularOcclusion = GetSpecularOcclusionFromBentAO(V, bentNormalWS, surfaceData); |
|||
#elif defined(_MASKMAP) |
|||
surfaceData.specularOcclusion = GetSpecularOcclusionFromAmbientOcclusion(dot(surfaceData.normalWS, V), surfaceData.ambientOcclusion, PerceptualSmoothnessToRoughness(surfaceData.perceptualSmoothness)); |
|||
#else |
|||
surfaceData.specularOcclusion = 1.0; |
|||
#endif |
|||
|
|||
// This is use with anisotropic material |
|||
surfaceData.tangentWS = Orthonormalize(surfaceData.tangentWS, surfaceData.normalWS); |
|||
|
|||
// Caution: surfaceData must be fully initialize before calling GetBuiltinData |
|||
GetBuiltinData(input, surfaceData, alpha, bentNormalWS, depthOffset, builtinData); |
|||
} |
|||
|
|||
#include "VegetationDataMeshModification.hlsl" |
|||
|
|||
#endif // #ifndef LAYERED_LIT_SHADER |
|||
|
|||
fileFormatVersion: 2 |
|||
guid: 5b0a17e7a97f28a4db53bcf95737633f |
|||
timeCreated: 1509483930 |
|||
licenseType: Pro |
|||
ShaderImporter: |
|||
externalObjects: {} |
|||
defaultTextures: [] |
|||
userData: |
|||
assetBundleName: |
|||
assetBundleVariant: |
|||
|
|||
float3 GetVertexDisplacement(float3 positionWS, float3 normalWS, float2 texCoord0, float2 texCoord1, float2 texCoord2, float2 texCoord3, float4 vertexColor) |
|||
{ |
|||
// This call will work for both LayeredLit and Lit shader |
|||
LayerTexCoord layerTexCoord; |
|||
ZERO_INITIALIZE(LayerTexCoord, layerTexCoord); |
|||
GetLayerTexCoord(texCoord0, texCoord1, texCoord2, texCoord3, positionWS, normalWS, layerTexCoord); |
|||
|
|||
// TODO: do this algorithm for lod fetching as lod not available in vertex/domain shader |
|||
// http://www.sebastiansylvan.com/post/the-problem-with-tessellation-in-directx-11/ |
|||
float lod = 0.0; |
|||
return ComputePerVertexDisplacement(layerTexCoord, vertexColor, lod) * normalWS; |
|||
} |
|||
|
|||
#include "VegetationWind.hlsl" |
|||
|
|||
void ApplyVertexModification(AttributesMesh input, float3 normalWS, inout float3 positionWS) |
|||
{ |
|||
#if defined(_VERTEX_DISPLACEMENT) |
|||
|
|||
positionWS += GetVertexDisplacement(positionWS, normalWS, |
|||
#ifdef ATTRIBUTES_NEED_TEXCOORD0 |
|||
input.uv0, |
|||
#else |
|||
float2(0.0, 0.0), |
|||
#endif |
|||
#ifdef ATTRIBUTES_NEED_TEXCOORD1 |
|||
input.uv1, |
|||
#else |
|||
float2(0.0, 0.0), |
|||
#endif |
|||
#ifdef ATTRIBUTES_NEED_TEXCOORD2 |
|||
input.uv2, |
|||
#else |
|||
float2(0.0, 0.0), |
|||
#endif |
|||
#ifdef ATTRIBUTES_NEED_TEXCOORD3 |
|||
input.uv3, |
|||
#else |
|||
float2(0.0, 0.0), |
|||
#endif |
|||
#ifdef ATTRIBUTES_NEED_COLOR |
|||
input.color |
|||
#else |
|||
float4(0.0, 0.0, 0.0, 0.0) |
|||
#endif |
|||
); |
|||
#endif |
|||
|
|||
#ifdef _VERTEX_WIND |
|||
float3 rootWP = mul(GetObjectToWorldMatrix(), float4(0, 0, 0, 1)).xyz; |
|||
ApplyWindDisplacement(positionWS, normalWS, rootWP, _Stiffness, _Drag, _ShiverDrag, _ShiverDirectionality, _InitialBend, input.color.a, _Time); |
|||
#endif |
|||
|
|||
//Main entry point to custom Windup vegetation wind |
|||
//------------------------------------------------- |
|||
#if defined(ATTRIBUTES_NEED_TEXCOORD0) && defined(ATTRIBUTES_NEED_COLOR) |
|||
ApplyVegetationWind(positionWS, input.positionOS, normalWS, input.uv0, input.color, _Time); |
|||
#endif |
|||
//------------------------------------------------- |
|||
} |
|||
|
|||
#ifdef TESSELLATION_ON |
|||
|
|||
float4 GetTessellationFactors(float3 p0, float3 p1, float3 p2, float3 n0, float3 n1, float3 n2) |
|||
{ |
|||
float maxDisplacement = GetMaxDisplacement(); |
|||
|
|||
|
|||
// For tessellation we want to process tessellation factor always from the point of view of the camera (to be consistent and avoid Z-fight). |
|||
// For the culling part however we want to use the current view (shadow view). |
|||
// Thus the following code play with both. |
|||
|
|||
#if defined(SHADERPASS) && (SHADERPASS != SHADERPASS_SHADOWS) |
|||
bool frustumCulledCurrentView = WorldViewFrustumCull(p0, p1, p2, maxDisplacement, (float4[4])_FrustumPlanes); // _FrustumPlanes are primary camera planes |
|||
bool frustumCulledMainView = false; |
|||
#else |
|||
bool frustumCulledCurrentView = WorldViewFrustumCull(p0, p1, p2, maxDisplacement, (float4[4])unity_CameraWorldClipPlanes); // unity_CameraWorldClipPlanes is set by legacy Unity in case of shadow and contain shadow view plan |
|||
// In the case of shadow, we don't want to tessellate anything that is not seen by the main view frustum. It can result in minor popping of tessellation into a shadow but we can't afford it anyway. |
|||
bool frustumCulledMainView = WorldViewFrustumCull(p0, p1, p2, maxDisplacement, (float4[4])_FrustumPlanes); |
|||
#endif |
|||
|
|||
bool faceCull = false; |
|||
|
|||
#ifndef _DOUBLESIDED_ON |
|||
if (_TessellationBackFaceCullEpsilon > -0.99) // Is backface culling enabled ? |
|||
{ |
|||
// Handle transform mirroring (like negative scaling) |
|||
// Caution: don't change p1/p2 directly as it is use later |
|||
float3 backfaceP1 = unity_WorldTransformParams.w < 0.0 ? p2 : p1; |
|||
float3 backfaceP2 = unity_WorldTransformParams.w < 0.0 ? p1 : p2; |
|||
|
|||
faceCull = BackFaceCullTriangle(p0, backfaceP1, backfaceP2, _TessellationBackFaceCullEpsilon, GetCurrentViewPosition()); // Use shadow view |
|||
} |
|||
#endif |
|||
|
|||
if (frustumCulledCurrentView || faceCull) |
|||
{ |
|||
// Settings factor to 0 will kill the triangle |
|||
return float4(0.0, 0.0, 0.0, 0.0); |
|||
} |
|||
|
|||
// See comment above: |
|||
// During shadow passes, we decide that anything outside the main view frustum should not be tessellated. |
|||
if (frustumCulledMainView) |
|||
{ |
|||
return float4(1.0, 1.0, 1.0, 1.0); |
|||
} |
|||
|
|||
// We use the parameters of the primary (scene view) camera in order |
|||
// to have identical tessellation levels for both the scene view and |
|||
// shadow views. Otherwise, depth comparisons become meaningless! |
|||
float3 tessFactor = float3(1.0, 1.0, 1.0); |
|||
|
|||
// Adaptive screen space tessellation |
|||
if (_TessellationFactorTriangleSize > 0.0) |
|||
{ |
|||
// return a value between 0 and 1 |
|||
tessFactor *= GetScreenSpaceTessFactor( p0, p1, p2, _ViewProjMatrix, _ScreenSize, _TessellationFactorTriangleSize); // Use primary camera view |
|||
} |
|||
|
|||
// Distance based tessellation |
|||
if (_TessellationFactorMaxDistance > 0.0) |
|||
{ |
|||
float3 distFactor = GetDistanceBasedTessFactor(p0, p1, p2, GetPrimaryCameraPosition(), _TessellationFactorMinDistance, _TessellationFactorMaxDistance); // Use primary camera view |
|||
// We square the disance factor as it allow a better percptual descrease of vertex density. |
|||
tessFactor *= distFactor * distFactor; |
|||
} |
|||
|
|||
tessFactor *= _TessellationFactor; |
|||
|
|||
// TessFactor below 1.0 have no effect. At 0 it kill the triangle, so clamp it to 1.0 |
|||
tessFactor.xyz = float3(max(1.0, tessFactor.x), max(1.0, tessFactor.y), max(1.0, tessFactor.z)); |
|||
|
|||
return CalcTriEdgeTessFactors(tessFactor); |
|||
} |
|||
|
|||
// tessellationFactors |
|||
// x - 1->2 edge |
|||
// y - 2->0 edge |
|||
// z - 0->1 edge |
|||
// w - inside tessellation factor |
|||
void ApplyTessellationModification(VaryingsMeshToDS input, float3 normalWS, inout float3 positionWS) |
|||
{ |
|||
#if defined(_TESSELLATION_DISPLACEMENT) |
|||
|
|||
positionWS += GetVertexDisplacement(positionWS, normalWS, |
|||
#ifdef VARYINGS_DS_NEED_TEXCOORD0 |
|||
input.texCoord0, |
|||
#else |
|||
float2(0.0, 0.0), |
|||
#endif |
|||
#ifdef VARYINGS_DS_NEED_TEXCOORD1 |
|||
input.texCoord1, |
|||
#else |
|||
float2(0.0, 0.0), |
|||
#endif |
|||
#ifdef VARYINGS_DS_NEED_TEXCOORD2 |
|||
input.texCoord2, |
|||
#else |
|||
float2(0.0, 0.0), |
|||
#endif |
|||
#ifdef VARYINGS_DS_NEED_TEXCOORD3 |
|||
input.texCoord3, |
|||
#else |
|||
float2(0.0, 0.0), |
|||
#endif |
|||
#ifdef VARYINGS_DS_NEED_COLOR |
|||
input.color |
|||
#else |
|||
float4(0.0, 0.0, 0.0, 0.0) |
|||
#endif |
|||
); |
|||
#endif // _TESSELLATION_DISPLACEMENT |
|||
} |
|||
|
|||
#endif // #ifdef TESSELLATION_ON |
|||
|
|||
fileFormatVersion: 2 |
|||
guid: d90d65d4c99d26c4e92f6677ac35cbba |
|||
timeCreated: 1509484407 |
|||
licenseType: Pro |
|||
ShaderImporter: |
|||
externalObjects: {} |
|||
defaultTextures: [] |
|||
userData: |
|||
assetBundleName: |
|||
assetBundleVariant: |
|||
|
|||
TEXTURE2D(_VegNoise); |
|||
SAMPLER2D(sampler_VegNoise); |
|||
|
|||
TEXTURE2D(_VegWindMask); |
|||
SAMPLER2D(sampler_VegWindMask); |
|||
|
|||
CBUFFER_START(_PerMaterial) |
|||
float4 _VegPivot; |
|||
float _VegStiffness; |
|||
float4 _VegAssistantDirectional; |
|||
float4 _VegWindDirection; |
|||
float _VegWindIntensity; |
|||
float _VegWindSpeed; |
|||
float _VegDetailVariation; |
|||
float _VegLeafShakeScale; |
|||
float _VegLeafShakeSpeed; |
|||
float _VegLeafShakePower; |
|||
float _VegPerLeafBendScale; |
|||
float _VegPerLeafBendSpeed; |
|||
float _VegPerLeafBendPower; |
|||
CBUFFER_END |
|||
|
|||
fileFormatVersion: 2 |
|||
guid: b9abd5b973633b846b6119a4ec8e8a54 |
|||
timeCreated: 1509484592 |
|||
licenseType: Pro |
|||
ShaderImporter: |
|||
externalObjects: {} |
|||
defaultTextures: [] |
|||
userData: |
|||
assetBundleName: |
|||
assetBundleVariant: |
|||
|
|||
#include "VegetationProperties.hlsl" |
|||
|
|||
void ApplyVegetationWind( inout float3 positionWS, |
|||
float3 positionOS, |
|||
float3 normalW, |
|||
float2 texcoord, |
|||
float4 weights, |
|||
float4 time) |
|||
{ |
|||
float3 normalWS = TransformObjectToWorldNormal(normalW); |
|||
float3 windDir = normalize(_VegWindDirection.xyz); |
|||
float windSpeedWS = _VegWindSpeed * time.y * 3.0; |
|||
|
|||
float vertexToPivotDist = distance(positionOS, float3(0.0, 0.0, 0.0)); |
|||
float distOffset = vertexToPivotDist / 128.0; |
|||
|
|||
float3 posToPivot = positionWS.xyz - _VegPivot.xyz; |
|||
float3 shiftPivot = _VegPivot.xyz + normalize(posToPivot) * vertexToPivotDist * (1.0 + weights.x); |
|||
float3 posToShiftPivot = positionWS.xyz - shiftPivot.xyz; |
|||
|
|||
float3 shiftPivotDistOffset = distance(positionOS, shiftPivot) / 64.0; |
|||
float3 axis = cross(posToShiftPivot, windDir); |
|||
|
|||
float4 noiseUV = time.yyyy * 0.05f; |
|||
//float4 noise = tex2Dlod(sampler_VegNoise, float4(noiseUV.x, 0.5, 0.0, 0.0)); |
|||
//#define SAMPLE_TEXTURE2D_LOD(textureName, samplerName, coord2, lod) textureName.SampleLevel(samplerName, coord2, lod) |
|||
float4 noise = SAMPLE_TEXTURE2D_LOD(_VegNoise, sampler_VegNoise, float2(noiseUV.x, 0.5), 0.0); |
|||
|
|||
half rad = radians(sin(windSpeedWS + (distOffset + shiftPivotDistOffset) / _VegStiffness) * distOffset * _VegWindIntensity * noise.x); |
|||
half radAssist = radians(sin(windSpeedWS) * distOffset * _VegWindIntensity * noise.x); |
|||
|
|||
float3x3 rP = float3x3(axis.x * axis.x * (1.0f - cos(rad)) + cos(rad), axis.x * axis.y * (1.0f - cos(rad)) + axis.z * sin(rad), axis.x * axis.z * (1.0f - cos(rad)) - axis.y * sin(rad), |
|||
axis.x * axis.y * (1.0f - cos(rad)) - axis.z * sin(rad), axis.y * axis.y * (1.0f - cos(rad)) + cos(rad), axis.y * axis.z * (1.0f - cos(rad)) + axis.x * sin(rad), |
|||
axis.x * axis.z * (1.0f - cos(rad)) + axis.y * sin(rad), axis.y * axis.z * (1.0f - cos(rad)) - axis.x * sin(rad), axis.z * axis.z * (1.0f - cos(rad)) + cos(rad)); |
|||
|
|||
float3x3 rPAssist = float3x3(_VegAssistantDirectional.x * _VegAssistantDirectional.x * (1.0f - cos(radAssist)) + cos(radAssist), _VegAssistantDirectional.x * _VegAssistantDirectional.y * (1.0f - cos(radAssist)) + _VegAssistantDirectional.z * sin(radAssist), _VegAssistantDirectional.x * _VegAssistantDirectional.z * (1.0f - cos(radAssist)) - _VegAssistantDirectional.y * sin(radAssist), |
|||
_VegAssistantDirectional.x * _VegAssistantDirectional.y * (1.0f - cos(radAssist)) - _VegAssistantDirectional.z * sin(radAssist), _VegAssistantDirectional.y * _VegAssistantDirectional.y * (1.0f - cos(radAssist)) + cos(radAssist), _VegAssistantDirectional.y * _VegAssistantDirectional.z * (1.0f - cos(radAssist)) + _VegAssistantDirectional.x * sin(radAssist), |
|||
_VegAssistantDirectional.x * _VegAssistantDirectional.z * (1.0f - cos(radAssist)) + _VegAssistantDirectional.y * sin(radAssist), _VegAssistantDirectional.y * _VegAssistantDirectional.z * (1.0f - cos(radAssist)) - _VegAssistantDirectional.x * sin(radAssist), _VegAssistantDirectional.z * _VegAssistantDirectional.z * (1.0f - cos(radAssist)) + cos(radAssist)); |
|||
|
|||
float detailVariation = weights.g * _VegDetailVariation; |
|||
|
|||
float3 leafShakeDeform = sin((positionWS / _VegLeafShakeScale + windSpeedWS * 5.0 * _VegLeafShakeSpeed) + detailVariation); |
|||
leafShakeDeform = clamp(leafShakeDeform, -1.0, 1.0); |
|||
leafShakeDeform *= _VegWindIntensity * noise * (1.0 + weights.g); |
|||
float4 perLeafMask = SAMPLE_TEXTURE2D_LOD(_VegWindMask, sampler_VegWindMask, float2(texcoord.x, texcoord.y), 0.0); |
|||
leafShakeDeform *= (normalWS * perLeafMask.r + (-normalWS) * perLeafMask.g) * _VegLeafShakePower; |
|||
|
|||
float3 perLeafBending = sin((positionWS / _VegPerLeafBendScale + windSpeedWS * 3.0 * _VegPerLeafBendSpeed) * (windDir+_VegAssistantDirectional) + detailVariation + shiftPivotDistOffset / 0.5); |
|||
perLeafBending *= _VegWindIntensity * noise; |
|||
perLeafBending = float3(0.0, perLeafBending.y, 0.0f); |
|||
perLeafBending *= weights.b * perLeafMask.b * (1.0 + weights.g) * _VegPerLeafBendPower; |
|||
|
|||
float3 rPAssistpos = mul(rPAssist, positionOS); |
|||
float3 pos = mul(rP, rPAssistpos) + perLeafBending + leafShakeDeform; |
|||
positionWS = mul(UNITY_MATRIX_M, float4(pos, 1.0)).xyz; |
|||
} |
|||
|
|||
fileFormatVersion: 2 |
|||
guid: fa32c39574d2ed444880dfb634c62aba |
|||
timeCreated: 1509485943 |
|||
licenseType: Pro |
|||
ShaderImporter: |
|||
externalObjects: {} |
|||
defaultTextures: [] |
|||
userData: |
|||
assetBundleName: |
|||
assetBundleVariant: |
|||
撰写
预览
正在加载...
取消
保存
Reference in new issue