Thomas Hourdel
8 年前
当前提交
4acdd75e
共有 33 个文件被更改，包括 3029 次插入 和 86 次删除
-
6Assets/ScriptableRenderPipeline/HDRenderPipeline/Editor/HDRenderPipelineInspector.cs
-
54Assets/ScriptableRenderPipeline/HDRenderPipeline/HDRenderPipeline.cs
-
7Assets/ScriptableRenderPipeline/HDRenderPipeline/Lighting/Deferred.shader
-
11Assets/ScriptableRenderPipeline/HDRenderPipeline/Material/Lit/Editor/LitUI.cs
-
2Assets/ScriptableRenderPipeline/HDRenderPipeline/Material/Lit/LitDataInternal.hlsl
-
60Assets/ScriptableRenderPipeline/HDRenderPipeline/Material/Lit/Resources/CombineSubsurfaceScattering.shader
-
2Assets/ScriptableRenderPipeline/LightweightPipeline/Shaders/LightweightPipeline.shader
-
33Assets/ScriptableRenderPipeline/LightweightPipeline/Shaders/LightweightPipelineCore.cginc
-
2Assets/ScriptableRenderPipeline/ShaderLibrary/Common.hlsl
-
36Assets/ScriptableRenderPipeline/ShaderLibrary/CommonLighting.hlsl
-
4Assets/ScriptableRenderPipeline/ShaderLibrary/Shadow/ShadowSampling.hlsl
-
9Assets/LegacyLayered.meta
-
9Assets/LegacyLayered/Editor.meta
-
736Assets/LegacyLayered/Editor/LayeredPhotogrammetryUI.cs
-
12Assets/LegacyLayered/Editor/LayeredPhotogrammetryUI.cs.meta
-
603Assets/LegacyLayered/LayeredPhotogrammetry.shader
-
9Assets/LegacyLayered/LayeredPhotogrammetry.shader.meta
-
140Assets/LegacyLayered/LayeredPhotogrammetryDataInternal.cginc
-
9Assets/LegacyLayered/LayeredPhotogrammetryDataInternal.cginc.meta
-
91Assets/LegacyLayered/LayeredPhotogrammetrySampleUVMapping.cginc
-
9Assets/LegacyLayered/LayeredPhotogrammetrySampleUVMapping.cginc.meta
-
48Assets/LegacyLayered/LayeredPhotogrammetrySampleUVMappingInternal.cginc
-
9Assets/LegacyLayered/LayeredPhotogrammetrySampleUVMappingInternal.cginc.meta
-
1001Assets/LegacyLayered/UnityLayeredPhotogrammetryCore.cginc
-
9Assets/LegacyLayered/UnityLayeredPhotogrammetryCore.cginc.meta
-
20Assets/LegacyLayered/UnityLayeredPhotogrammetryCoreForward.cginc
-
9Assets/LegacyLayered/UnityLayeredPhotogrammetryCoreForward.cginc.meta
-
75Assets/LegacyLayered/UnityLayeredPhotogrammetryInput.cginc
-
9Assets/LegacyLayered/UnityLayeredPhotogrammetryInput.cginc.meta
-
82Assets/LegacyLayered/UnityLayeredPhotogrammetryMeta.cginc
-
9Assets/LegacyLayered/UnityLayeredPhotogrammetryMeta.cginc.meta
|
|||
fileFormatVersion: 2 |
|||
guid: 78d15b13b40de7a4891eb491afc04d28 |
|||
folderAsset: yes |
|||
timeCreated: 1497255974 |
|||
licenseType: Pro |
|||
DefaultImporter: |
|||
userData: |
|||
assetBundleName: |
|||
assetBundleVariant: |
|||
|
|||
fileFormatVersion: 2 |
|||
guid: 5676a938b6eb98341a6a6c5b52ca30e1 |
|||
folderAsset: yes |
|||
timeCreated: 1497279200 |
|||
licenseType: Pro |
|||
DefaultImporter: |
|||
userData: |
|||
assetBundleName: |
|||
assetBundleVariant: |
|||
|
|||
using System; |
|||
using UnityEngine; |
|||
using UnityEngine.Rendering; |
|||
using UnityEditor; |
|||
|
|||
using System.Linq; |
|||
|
|||
//namespace UnityEditor.Experimental.Rendering.HDPipeline
|
|||
//{
|
|||
internal class LayeredPhotogrammetryGUI : ShaderGUI//LitGUI
|
|||
{ |
|||
|
|||
protected const string kUVBase = "_UVBase"; |
|||
protected const string kTexWorldScale = "_TexWorldScale"; |
|||
protected const string kUVMappingMask = "_UVMappingMask"; |
|||
|
|||
protected const string kBaseColor = "_BaseColor"; |
|||
protected const string kBaseColorMap = "_BaseColorMap"; |
|||
protected const string kMetallic = "_Metallic"; |
|||
protected const string kSmoothness = "_Smoothness"; |
|||
protected const string kMaskMap = "_MaskMap"; |
|||
protected const string kNormalMap = "_NormalMap"; |
|||
protected const string kNormalScale = "_NormalScale"; |
|||
protected const string kHeightMap = "_HeightMap"; |
|||
protected const string kHeightAmplitude = "_LayerHeightAmplitude"; |
|||
protected const string kHeightCenter = "_LayerHeightCenter"; |
|||
|
|||
protected const string kUVDetail = "_UVDetail"; |
|||
protected const string kUVDetailsMappingMask = "_UVDetailsMappingMask"; |
|||
protected const string kDetailMap = "_DetailMap"; |
|||
protected const string kDetailMask = "_DetailMask"; |
|||
protected const string kDetailAlbedoScale = "_DetailAlbedoScale"; |
|||
protected const string kDetailNormalScale = "_DetailNormalScale"; |
|||
protected const string kDetailSmoothnessScale = "_DetailSmoothnessScale"; |
|||
|
|||
protected MaterialProperty alphaCutoffEnable = null; |
|||
protected const string kAlphaCutoffEnabled = "_AlphaCutoffEnable"; |
|||
protected MaterialProperty alphaCutoff = null; |
|||
protected const string kAlphaCutoff = "_AlphaCutoff"; |
|||
|
|||
protected MaterialEditor m_MaterialEditor; |
|||
|
|||
public enum LayerUVBaseMapping |
|||
{ |
|||
UV0, |
|||
UV1, |
|||
UV2, |
|||
UV3, |
|||
Planar, |
|||
} |
|||
|
|||
public enum VertexColorMode |
|||
{ |
|||
None, |
|||
Multiply, |
|||
Add |
|||
} |
|||
|
|||
public enum UVBaseMapping |
|||
{ |
|||
UV0, |
|||
Planar, |
|||
} |
|||
|
|||
public enum HeightmapMode |
|||
{ |
|||
Parallax, |
|||
Displacement, |
|||
} |
|||
|
|||
public enum UVDetailMapping |
|||
{ |
|||
UV0, |
|||
UV1, |
|||
UV2, |
|||
UV3 |
|||
} |
|||
|
|||
public enum EmissiveColorMode |
|||
{ |
|||
UseEmissiveColor, |
|||
UseEmissiveMask, |
|||
} |
|||
|
|||
private class StylesLayer |
|||
{ |
|||
public readonly GUIContent[] layerLabels = |
|||
{ |
|||
new GUIContent("Main layer"), |
|||
new GUIContent("Layer 1"), |
|||
new GUIContent("Layer 2"), |
|||
new GUIContent("Layer 3"), |
|||
}; |
|||
|
|||
public readonly GUIStyle[] layerLabelColors = |
|||
{ |
|||
new GUIStyle(EditorStyles.label), |
|||
new GUIStyle(EditorStyles.label), |
|||
new GUIStyle(EditorStyles.label), |
|||
new GUIStyle(EditorStyles.label) |
|||
}; |
|||
|
|||
public readonly GUIContent layersText = new GUIContent("Inputs"); |
|||
public readonly GUIContent emissiveText = new GUIContent("Emissive"); |
|||
public readonly GUIContent layerMapMaskText = new GUIContent("Layer Mask", "Layer mask"); |
|||
public readonly GUIContent vertexColorModeText = new GUIContent("Vertex Color Mode", "Mode multiply: vertex color is multiply with the mask. Mode additive: vertex color values are remapped between -1 and 1 and added to the mask (neutral at 0.5 vertex color)."); |
|||
public readonly GUIContent layerCountText = new GUIContent("Layer Count", "Number of layers."); |
|||
public readonly GUIContent layerTilingBlendMaskText = new GUIContent("Tiling", "Tiling for the blend mask."); |
|||
public readonly GUIContent objectScaleAffectTileText = new GUIContent("Tiling 0123 follow object Scale", "Tiling will be affected by the object scale."); |
|||
public readonly GUIContent objectScaleAffectTileText2 = new GUIContent("Tiling 123 follow object Scale", "Tiling will be affected by the object scale."); |
|||
|
|||
public readonly GUIContent layerBaseColor = new GUIContent("Base Color"); |
|||
public readonly GUIContent layerMetallic = new GUIContent("Metallic"); |
|||
public readonly GUIContent layerMask = new GUIContent("Mask Map - M(R), AO(G), S(A)", "Mask map"); |
|||
public readonly GUIContent layerSmoothness = new GUIContent("Smoothness"); |
|||
public readonly GUIContent layerNormalMap = new GUIContent("Normal Map"); |
|||
public readonly GUIContent layerHeightMapText = new GUIContent("Height Map (R)", "Height Map"); |
|||
public readonly GUIContent layerHeightMapAmplitudeText = new GUIContent("Height Map Amplitude", "Height Map amplitude in world units."); |
|||
public readonly GUIContent layerHeightMapCenterText = new GUIContent("Height Map Center", "Center of the heightmap in the texture (between 0 and 1)"); |
|||
public readonly GUIContent layerTilingText = new GUIContent("Tiling", "Tiling factor applied to UVSet."); |
|||
public readonly GUIContent layerTexWorldScaleText = new GUIContent("World Scale", "Tiling factor applied to Planar/Trilinear mapping"); |
|||
public readonly GUIContent UVBaseText = new GUIContent("Base UV Mapping", "Base UV Mapping mode of the layer."); |
|||
public readonly GUIContent UVBlendMaskText = new GUIContent("BlendMask UV Mapping", "Base UV Mapping mode of the layer."); |
|||
public readonly GUIContent UVDetailText = new GUIContent("Detail UV Mapping", "Detail UV Mapping mode of the layer."); |
|||
public readonly GUIContent mainLayerInfluenceText = new GUIContent("Main layer influence", "Main layer influence."); |
|||
public readonly GUIContent densityOpacityInfluenceText = new GUIContent("Density / Opacity", "Density / Opacity"); |
|||
public readonly GUIContent useHeightBasedBlendText = new GUIContent("Use Height Based Blend", "Layer will be blended with the underlying layer based on the height."); |
|||
public readonly GUIContent useDensityModeModeText = new GUIContent("Use Density Mode", "Enable density mode"); |
|||
public readonly GUIContent useMainLayerInfluenceModeText = new GUIContent("Main Layer Influence", "Switch between regular layers mode and base/layers mode"); |
|||
public readonly GUIContent heightControlText = new GUIContent("Height control"); |
|||
public readonly GUIContent layerDetailMapNormalText = new GUIContent("Detail Map A(R) Ny(G) S(B) Nx(A)", "Detail Map"); |
|||
public readonly GUIContent layerDetailMaskText = new GUIContent("Detail Mask (G)", "Mask for detailMap"); |
|||
public readonly GUIContent layerDetailAlbedoScaleText = new GUIContent("Detail AlbedoScale", "Detail Albedo Scale factor"); |
|||
public readonly GUIContent layerDetailNormalScaleText = new GUIContent("Detail NormalScale", "Normal Scale factor"); |
|||
public readonly GUIContent layerDetailSmoothnessScaleText = new GUIContent("Detail SmoothnessScale", "Smoothness Scale factor"); |
|||
|
|||
public readonly GUIContent blendUsingHeight = new GUIContent("Blend Using Height", "Blend Layers using height."); |
|||
public readonly GUIContent inheritBaseColorThresholdText = new GUIContent("Threshold", "Inherit the base color from the base layer."); |
|||
public readonly GUIContent minimumOpacityText = new GUIContent("Minimum Opacity", "Minimum Opacity."); |
|||
public readonly GUIContent opacityAsDensityText = new GUIContent("Use Opacity as Density", "Use Opacity as Density."); |
|||
public readonly GUIContent inheritBaseNormalText = new GUIContent("Normal influence", "Inherit the normal from the base layer."); |
|||
public readonly GUIContent inheritBaseHeightText = new GUIContent("Heightmap influence", "Inherit the height from the base layer."); |
|||
public readonly GUIContent inheritBaseColorText = new GUIContent("BaseColor influence", "Inherit the base color from the base layer."); |
|||
|
|||
public static GUIContent alphaCutoffEnableText = new GUIContent("Alpha Cutoff Enable", "Threshold for alpha cutoff"); |
|||
public static GUIContent alphaCutoffText = new GUIContent("Alpha Cutoff", "Threshold for alpha cutoff"); |
|||
|
|||
public static string advancedText = "Advanced Options"; |
|||
|
|||
public StylesLayer() |
|||
{ |
|||
layerLabelColors[0].normal.textColor = Color.white; |
|||
layerLabelColors[1].normal.textColor = Color.red; |
|||
layerLabelColors[2].normal.textColor = Color.green; |
|||
layerLabelColors[3].normal.textColor = Color.blue; |
|||
} |
|||
} |
|||
|
|||
static StylesLayer s_Styles = null; |
|||
private static StylesLayer styles { get { if (s_Styles == null) s_Styles = new StylesLayer(); return s_Styles; } } |
|||
|
|||
// Needed for json serialization to work
|
|||
[Serializable] |
|||
internal struct SerializeableGUIDs |
|||
{ |
|||
public string[] GUIDArray; |
|||
} |
|||
|
|||
const int kMaxLayerCount = 4; |
|||
|
|||
// Layer options
|
|||
MaterialProperty layerCount = null; |
|||
const string kLayerCount = "_LayerCount"; |
|||
MaterialProperty layerMaskMap = null; |
|||
const string kLayerMaskMap = "_LayerMaskMap"; |
|||
MaterialProperty vertexColorMode = null; |
|||
const string kVertexColorMode = "_VertexColorMode"; |
|||
MaterialProperty objectScaleAffectTile = null; |
|||
const string kObjectScaleAffectTile = "_ObjectScaleAffectTile"; |
|||
MaterialProperty UVBlendMask = null; |
|||
const string kUVBlendMask = "_UVBlendMask"; |
|||
MaterialProperty layerTilingBlendMask = null; |
|||
const string kLayerTilingBlendMask = "_LayerTilingBlendMask"; |
|||
MaterialProperty texWorldScaleBlendMask = null; |
|||
const string kTexWorldScaleBlendMask = "_TexWorldScaleBlendMask"; |
|||
MaterialProperty useMainLayerInfluence = null; |
|||
const string kkUseMainLayerInfluence = "_UseMainLayerInfluence"; |
|||
MaterialProperty useHeightBasedBlend = null; |
|||
const string kUseHeightBasedBlend = "_UseHeightBasedBlend"; |
|||
|
|||
// Lit properties
|
|||
MaterialProperty[] layerBaseColor = new MaterialProperty[kMaxLayerCount]; |
|||
MaterialProperty[] layerBaseColorMap = new MaterialProperty[kMaxLayerCount]; |
|||
MaterialProperty[] layerSmoothness = new MaterialProperty[kMaxLayerCount]; |
|||
MaterialProperty[] layerMetallic = new MaterialProperty[kMaxLayerCount]; |
|||
MaterialProperty[] layerNormalMap = new MaterialProperty[kMaxLayerCount]; |
|||
MaterialProperty[] layerNormalScale = new MaterialProperty[kMaxLayerCount]; |
|||
MaterialProperty[] layerMask = new MaterialProperty[kMaxLayerCount]; |
|||
MaterialProperty[] layerHeightMap = new MaterialProperty[kMaxLayerCount]; |
|||
MaterialProperty[] layerHeightAmplitude = new MaterialProperty[kMaxLayerCount]; |
|||
MaterialProperty[] layerHeightCenter = new MaterialProperty[kMaxLayerCount]; |
|||
MaterialProperty[] layerDetailMask = new MaterialProperty[kMaxLayerCount]; |
|||
MaterialProperty[] layerDetailMap = new MaterialProperty[kMaxLayerCount]; |
|||
MaterialProperty[] layerDetailAlbedoScale = new MaterialProperty[kMaxLayerCount]; |
|||
MaterialProperty[] layerDetailNormalScale = new MaterialProperty[kMaxLayerCount]; |
|||
MaterialProperty[] layerDetailSmoothnessScale = new MaterialProperty[kMaxLayerCount]; |
|||
|
|||
// Properties for multiple layers inherit from referenced lit materials
|
|||
MaterialProperty[] layerTexWorldScale = new MaterialProperty[kMaxLayerCount]; |
|||
MaterialProperty[] layerUVBase = new MaterialProperty[kMaxLayerCount]; |
|||
MaterialProperty[] layerUVMappingMask = new MaterialProperty[kMaxLayerCount]; |
|||
MaterialProperty[] layerUVDetail = new MaterialProperty[kMaxLayerCount]; |
|||
MaterialProperty[] layerUVDetailsMappingMask = new MaterialProperty[kMaxLayerCount]; |
|||
// This one is specific to layer lit
|
|||
MaterialProperty[] layerTiling = new MaterialProperty[kMaxLayerCount]; |
|||
const string kLayerTiling = "_LayerTiling"; |
|||
|
|||
// Density/opacity mode
|
|||
MaterialProperty useDensityMode = null; |
|||
const string kUseDensityMode = "_UseDensityMode"; |
|||
MaterialProperty[] opacityAsDensity = new MaterialProperty[kMaxLayerCount]; |
|||
const string kOpacityAsDensity = "_OpacityAsDensity"; |
|||
MaterialProperty[] minimumOpacity = new MaterialProperty[kMaxLayerCount]; |
|||
const string kMinimumOpacity = "_MinimumOpacity"; |
|||
|
|||
// HeightmapMode control
|
|||
MaterialProperty[] blendUsingHeight = new MaterialProperty[kMaxLayerCount - 1]; // Only in case of influence mode
|
|||
const string kBlendUsingHeight = "_BlendUsingHeight"; |
|||
|
|||
// Influence
|
|||
MaterialProperty[] inheritBaseNormal = new MaterialProperty[kMaxLayerCount - 1]; |
|||
const string kInheritBaseNormal = "_InheritBaseNormal"; |
|||
MaterialProperty[] inheritBaseHeight = new MaterialProperty[kMaxLayerCount - 1]; |
|||
const string kInheritBaseHeight = "_InheritBaseHeight"; |
|||
MaterialProperty[] inheritBaseColor = new MaterialProperty[kMaxLayerCount - 1]; |
|||
const string kInheritBaseColor = "_InheritBaseColor"; |
|||
MaterialProperty[] inheritBaseColorThreshold = new MaterialProperty[kMaxLayerCount - 1]; |
|||
const string kInheritBaseColorThreshold = "_InheritBaseColorThreshold"; |
|||
|
|||
protected void FindMaterialProperties(MaterialProperty[] props) |
|||
{ |
|||
// Inherit from LitUI
|
|||
layerCount = FindProperty(kLayerCount, props); |
|||
layerMaskMap = FindProperty(kLayerMaskMap, props); |
|||
vertexColorMode = FindProperty(kVertexColorMode, props); |
|||
objectScaleAffectTile = FindProperty(kObjectScaleAffectTile, props); |
|||
UVBlendMask = FindProperty(kUVBlendMask, props); |
|||
layerTilingBlendMask = FindProperty(kLayerTilingBlendMask, props); |
|||
texWorldScaleBlendMask = FindProperty(kTexWorldScaleBlendMask, props); |
|||
|
|||
useMainLayerInfluence = FindProperty(kkUseMainLayerInfluence, props); |
|||
useHeightBasedBlend = FindProperty(kUseHeightBasedBlend, props); |
|||
|
|||
useDensityMode = FindProperty(kUseDensityMode, props); |
|||
|
|||
for (int i = 0; i < kMaxLayerCount; ++i) |
|||
{ |
|||
layerBaseColor[i] = FindProperty(string.Format("{0}{1}", kBaseColor, i), props); |
|||
layerBaseColorMap[i] = FindProperty(string.Format("{0}{1}", kBaseColorMap, i), props); |
|||
layerSmoothness[i] = FindProperty(string.Format("{0}{1}", kSmoothness, i), props); |
|||
layerMetallic[i] = FindProperty(string.Format("{0}{1}", kMetallic, i), props); |
|||
layerNormalMap[i] = FindProperty(string.Format("{0}{1}", kNormalMap, i), props); |
|||
layerNormalScale[i] = FindProperty(string.Format("{0}{1}", kNormalScale, i), props); |
|||
layerMask[i] = FindProperty(string.Format("{0}{1}", kMaskMap, i), props); |
|||
layerHeightMap[i] = FindProperty(string.Format("{0}{1}", kHeightMap, i), props); |
|||
layerTexWorldScale[i] = FindProperty(string.Format("{0}{1}", kTexWorldScale, i), props); |
|||
layerUVBase[i] = FindProperty(string.Format("{0}{1}", kUVBase, i), props); |
|||
layerUVMappingMask[i] = FindProperty(string.Format("{0}{1}", kUVMappingMask, i), props); |
|||
layerUVDetail[i] = FindProperty(string.Format("{0}{1}", kUVDetail, i), props); |
|||
layerUVDetailsMappingMask[i] = FindProperty(string.Format("{0}{1}", kUVDetailsMappingMask, i), props); |
|||
layerTiling[i] = FindProperty(string.Format("{0}{1}", kLayerTiling, i), props); |
|||
layerDetailMap[i] = FindProperty(string.Format("{0}{1}", kDetailMap, i), props); |
|||
layerDetailMask[i] = FindProperty(string.Format("{0}{1}", kDetailMask, i), props); |
|||
layerDetailAlbedoScale[i] = FindProperty(string.Format("{0}{1}", kDetailAlbedoScale, i), props); |
|||
layerDetailNormalScale[i] = FindProperty(string.Format("{0}{1}", kDetailNormalScale, i), props); |
|||
layerDetailSmoothnessScale[i] = FindProperty(string.Format("{0}{1}", kDetailSmoothnessScale, i), props); |
|||
|
|||
// Density/opacity mode
|
|||
opacityAsDensity[i] = FindProperty(string.Format("{0}{1}", kOpacityAsDensity, i), props); |
|||
minimumOpacity[i] = FindProperty(string.Format("{0}{1}", kMinimumOpacity, i), props); |
|||
|
|||
layerHeightAmplitude[i] = FindProperty(string.Format("{0}{1}", kHeightAmplitude, i), props); |
|||
layerHeightCenter[i] = FindProperty(string.Format("{0}{1}", kHeightCenter, i), props); |
|||
|
|||
if (i != 0) |
|||
{ |
|||
blendUsingHeight[i - 1] = FindProperty(string.Format("{0}{1}", kBlendUsingHeight, i), props); |
|||
// Influence
|
|||
inheritBaseNormal[i - 1] = FindProperty(string.Format("{0}{1}", kInheritBaseNormal, i), props); |
|||
inheritBaseHeight[i - 1] = FindProperty(string.Format("{0}{1}", kInheritBaseHeight, i), props); |
|||
inheritBaseColor[i - 1] = FindProperty(string.Format("{0}{1}", kInheritBaseColor, i), props); |
|||
inheritBaseColorThreshold[i - 1] = FindProperty(string.Format("{0}{1}", kInheritBaseColorThreshold, i), props); |
|||
} |
|||
} |
|||
|
|||
// Reuse property from LitUI.cs
|
|||
//emissiveColor = FindProperty(kEmissiveColor, props);
|
|||
//emissiveColorMap = FindProperty(kEmissiveColorMap, props);
|
|||
//emissiveIntensity = FindProperty(kEmissiveIntensity, props);
|
|||
} |
|||
|
|||
int numLayer |
|||
{ |
|||
set { layerCount.floatValue = (float)value; } |
|||
get { return (int)layerCount.floatValue; } |
|||
} |
|||
|
|||
bool DoLayerGUI(AssetImporter materialImporter, int layerIndex) |
|||
{ |
|||
bool result = false; |
|||
|
|||
Material material = m_MaterialEditor.target as Material; |
|||
|
|||
bool mainLayerInfluenceEnable = useMainLayerInfluence.floatValue > 0.0f; |
|||
|
|||
EditorGUILayout.LabelField(styles.layerLabels[layerIndex], styles.layerLabelColors[layerIndex]); |
|||
|
|||
m_MaterialEditor.TexturePropertySingleLine(styles.layerBaseColor, layerBaseColorMap[layerIndex], layerBaseColor[layerIndex]); |
|||
m_MaterialEditor.ShaderProperty(layerMetallic[layerIndex], styles.layerMetallic); |
|||
m_MaterialEditor.ShaderProperty(layerSmoothness[layerIndex], styles.layerSmoothness); |
|||
|
|||
m_MaterialEditor.TexturePropertySingleLine(styles.layerMask, layerMask[layerIndex]); |
|||
m_MaterialEditor.TexturePropertySingleLine(styles.layerNormalMap, layerNormalMap[layerIndex], layerNormalScale[layerIndex]); |
|||
|
|||
m_MaterialEditor.TexturePropertySingleLine(styles.layerHeightMapText, layerHeightMap[layerIndex]); |
|||
if (!layerHeightMap[layerIndex].hasMixedValue && layerHeightMap[layerIndex].textureValue != null) |
|||
{ |
|||
EditorGUI.indentLevel++; |
|||
m_MaterialEditor.ShaderProperty(layerHeightAmplitude[layerIndex], styles.layerHeightMapAmplitudeText); |
|||
m_MaterialEditor.ShaderProperty(layerHeightCenter[layerIndex], styles.layerHeightMapCenterText); |
|||
EditorGUI.showMixedValue = false; |
|||
EditorGUI.indentLevel--; |
|||
} |
|||
|
|||
EditorGUI.BeginChangeCheck(); |
|||
m_MaterialEditor.ShaderProperty(layerUVBase[layerIndex], styles.UVBaseText); |
|||
if (EditorGUI.EndChangeCheck()) |
|||
{ |
|||
result = true; |
|||
} |
|||
if (((LayerUVBaseMapping)layerUVBase[layerIndex].floatValue == LayerUVBaseMapping.Planar)) |
|||
{ |
|||
EditorGUI.indentLevel++; |
|||
m_MaterialEditor.ShaderProperty(layerTexWorldScale[layerIndex], styles.layerTexWorldScaleText); |
|||
EditorGUI.indentLevel--; |
|||
} |
|||
else |
|||
{ |
|||
EditorGUI.indentLevel++; |
|||
m_MaterialEditor.ShaderProperty(layerTiling[layerIndex], styles.layerTilingText); |
|||
EditorGUI.indentLevel--; |
|||
} |
|||
m_MaterialEditor.TextureScaleOffsetProperty(layerBaseColorMap[layerIndex]); |
|||
|
|||
m_MaterialEditor.TexturePropertySingleLine(styles.layerDetailMaskText, layerDetailMask[layerIndex]); |
|||
m_MaterialEditor.TexturePropertySingleLine(styles.layerDetailMapNormalText, layerDetailMap[layerIndex]); |
|||
|
|||
if (((LayerUVBaseMapping)layerUVBase[layerIndex].floatValue == LayerUVBaseMapping.Planar)) |
|||
{ |
|||
GUILayout.Label(" " + styles.UVDetailText.text + ": Planar"); |
|||
} |
|||
else |
|||
{ |
|||
EditorGUI.BeginChangeCheck(); |
|||
m_MaterialEditor.ShaderProperty(layerUVDetail[layerIndex], styles.UVDetailText); |
|||
if (EditorGUI.EndChangeCheck()) |
|||
{ |
|||
result = true; |
|||
} |
|||
} |
|||
m_MaterialEditor.TextureScaleOffsetProperty(layerDetailMap[layerIndex]); |
|||
m_MaterialEditor.ShaderProperty(layerDetailAlbedoScale[layerIndex], styles.layerDetailAlbedoScaleText); |
|||
m_MaterialEditor.ShaderProperty(layerDetailNormalScale[layerIndex], styles.layerDetailNormalScaleText); |
|||
m_MaterialEditor.ShaderProperty(layerDetailSmoothnessScale[layerIndex], styles.layerDetailSmoothnessScaleText); |
|||
|
|||
// We setup the masking map based on the enum for each layer.
|
|||
// using mapping mask allow to reduce the number of generated combination for a very small increase in ALU
|
|||
LayerUVBaseMapping layerUVBaseMapping = (LayerUVBaseMapping)layerUVBase[layerIndex].floatValue; |
|||
|
|||
float X, Y, Z, W; |
|||
X = (layerUVBaseMapping == LayerUVBaseMapping.UV0) ? 1.0f : 0.0f; |
|||
Y = (layerUVBaseMapping == LayerUVBaseMapping.UV1) ? 1.0f : 0.0f; |
|||
Z = (layerUVBaseMapping == LayerUVBaseMapping.UV2) ? 1.0f : 0.0f; |
|||
W = (layerUVBaseMapping == LayerUVBaseMapping.UV3) ? 1.0f : 0.0f; |
|||
layerUVMappingMask[layerIndex].colorValue = (layerIndex == 0) ? new Color(1.0f, 0.0f, 0.0f, 0.0f) : new Color(X, Y, Z, W); // Special case for Main Layer and Blend Mask, only UV0. As Layer0 is share by both here, need to force X to 1.0 in all case
|
|||
|
|||
UVDetailMapping layerUVDetailMapping = (UVDetailMapping)layerUVDetail[layerIndex].floatValue; |
|||
X = (layerUVDetailMapping == UVDetailMapping.UV0) ? 1.0f : 0.0f; |
|||
Y = (layerUVDetailMapping == UVDetailMapping.UV1) ? 1.0f : 0.0f; |
|||
Z = (layerUVDetailMapping == UVDetailMapping.UV2) ? 1.0f : 0.0f; |
|||
W = (layerUVDetailMapping == UVDetailMapping.UV3) ? 1.0f : 0.0f; |
|||
layerUVDetailsMappingMask[layerIndex].colorValue = new Color(X, Y, Z, W); |
|||
|
|||
bool useDensityModeEnable = useDensityMode.floatValue != 0.0f; |
|||
if (useDensityModeEnable) |
|||
{ |
|||
EditorGUILayout.LabelField(styles.densityOpacityInfluenceText, EditorStyles.boldLabel); |
|||
|
|||
EditorGUI.indentLevel++; |
|||
m_MaterialEditor.ShaderProperty(opacityAsDensity[layerIndex], styles.opacityAsDensityText); |
|||
m_MaterialEditor.ShaderProperty(minimumOpacity[layerIndex], styles.minimumOpacityText); |
|||
EditorGUI.indentLevel--; |
|||
} |
|||
|
|||
// Display height control if they have a meaning
|
|||
//if ((tessellationMode != null && ((TessellationMode)tessellationMode.floatValue == TessellationMode.Displacement || (TessellationMode)tessellationMode.floatValue == TessellationMode.DisplacementPhong))
|
|||
// || (enablePerPixelDisplacement.floatValue > 0.0f)
|
|||
// || (useHeightBasedBlend.floatValue > 0.0f)
|
|||
// )
|
|||
//if (useHeightBasedBlend.floatValue > 0.0f)
|
|||
//{
|
|||
// EditorGUILayout.LabelField(styles.heightControlText, EditorStyles.boldLabel);
|
|||
|
|||
// EditorGUI.indentLevel++;
|
|||
// m_MaterialEditor.ShaderProperty(heightFactor[layerIndex], styles.heightFactorText);
|
|||
// layerHeightAmplitude[layerIndex].floatValue = material.GetFloat(kHeightAmplitude + layerIndex) * heightFactor[layerIndex].floatValue;
|
|||
// m_MaterialEditor.ShaderProperty(heightCenterOffset[layerIndex], styles.heightCenterOffsetText);
|
|||
// layerCenterOffset[layerIndex].floatValue = material.GetFloat(kHeightCenter + layerIndex) + heightCenterOffset[layerIndex].floatValue;
|
|||
// EditorGUI.indentLevel--;
|
|||
//}
|
|||
|
|||
|
|||
// influence
|
|||
if (layerIndex > 0) |
|||
{ |
|||
int paramIndex = layerIndex - 1; |
|||
|
|||
bool heightBasedBlendEnable = useHeightBasedBlend.floatValue > 0.0f; |
|||
if (heightBasedBlendEnable) |
|||
{ |
|||
EditorGUI.indentLevel++; |
|||
m_MaterialEditor.ShaderProperty(blendUsingHeight[paramIndex], styles.blendUsingHeight); |
|||
EditorGUI.indentLevel--; |
|||
} |
|||
|
|||
if (mainLayerInfluenceEnable) |
|||
{ |
|||
EditorGUILayout.LabelField(styles.mainLayerInfluenceText, EditorStyles.boldLabel); |
|||
|
|||
EditorGUI.indentLevel++; |
|||
|
|||
m_MaterialEditor.ShaderProperty(inheritBaseColor[paramIndex], styles.inheritBaseColorText); |
|||
EditorGUI.indentLevel++; |
|||
m_MaterialEditor.ShaderProperty(inheritBaseColorThreshold[paramIndex], styles.inheritBaseColorThresholdText); |
|||
EditorGUI.indentLevel--; |
|||
m_MaterialEditor.ShaderProperty(inheritBaseNormal[paramIndex], styles.inheritBaseNormalText); |
|||
// Main height influence is only available if the shader use the heightmap for displacement (per vertex or per level)
|
|||
// We always display it as it can be tricky to know when per pixel displacement is enabled or not
|
|||
m_MaterialEditor.ShaderProperty(inheritBaseHeight[paramIndex], styles.inheritBaseHeightText); |
|||
|
|||
EditorGUI.indentLevel--; |
|||
} |
|||
} |
|||
|
|||
if (layerIndex == 0) |
|||
EditorGUILayout.Space(); |
|||
|
|||
return result; |
|||
} |
|||
|
|||
bool DoLayersGUI(AssetImporter materialImporter) |
|||
{ |
|||
Material material = m_MaterialEditor.target as Material; |
|||
|
|||
bool layerChanged = false; |
|||
|
|||
GUI.changed = false; |
|||
|
|||
GUILayout.Label(styles.layersText, EditorStyles.boldLabel); |
|||
|
|||
EditorGUI.showMixedValue = layerCount.hasMixedValue; |
|||
EditorGUI.BeginChangeCheck(); |
|||
int newLayerCount = EditorGUILayout.IntSlider(styles.layerCountText, (int)layerCount.floatValue, 2, 4); |
|||
if (EditorGUI.EndChangeCheck()) |
|||
{ |
|||
Undo.RecordObject(material, "Change layer count"); |
|||
layerCount.floatValue = (float)newLayerCount; |
|||
layerChanged = true; |
|||
} |
|||
|
|||
m_MaterialEditor.TexturePropertySingleLine(styles.layerMapMaskText, layerMaskMap); |
|||
|
|||
m_MaterialEditor.ShaderProperty(UVBlendMask, styles.UVBlendMaskText); |
|||
|
|||
if (((LayerUVBaseMapping)UVBlendMask.floatValue == LayerUVBaseMapping.Planar)) |
|||
{ |
|||
m_MaterialEditor.ShaderProperty(texWorldScaleBlendMask, styles.layerTexWorldScaleText); |
|||
} |
|||
else |
|||
{ |
|||
m_MaterialEditor.ShaderProperty(layerTilingBlendMask, styles.layerTilingBlendMaskText); |
|||
} |
|||
|
|||
m_MaterialEditor.ShaderProperty(vertexColorMode, styles.vertexColorModeText); |
|||
|
|||
EditorGUI.BeginChangeCheck(); |
|||
EditorGUI.showMixedValue = useMainLayerInfluence.hasMixedValue; |
|||
bool mainLayerModeInfluenceEnable = EditorGUILayout.Toggle(styles.useMainLayerInfluenceModeText, useMainLayerInfluence.floatValue > 0.0f); |
|||
if (EditorGUI.EndChangeCheck()) |
|||
{ |
|||
useMainLayerInfluence.floatValue = mainLayerModeInfluenceEnable ? 1.0f : 0.0f; |
|||
} |
|||
|
|||
EditorGUI.BeginChangeCheck(); |
|||
EditorGUI.showMixedValue = useDensityMode.hasMixedValue; |
|||
bool useDensityModeEnable = EditorGUILayout.Toggle(styles.useDensityModeModeText, useDensityMode.floatValue > 0.0f); |
|||
if (EditorGUI.EndChangeCheck()) |
|||
{ |
|||
useDensityMode.floatValue = useDensityModeEnable ? 1.0f : 0.0f; |
|||
} |
|||
|
|||
EditorGUI.BeginChangeCheck(); |
|||
EditorGUI.showMixedValue = useHeightBasedBlend.hasMixedValue; |
|||
bool enabled = EditorGUILayout.Toggle(styles.useHeightBasedBlendText, useHeightBasedBlend.floatValue > 0.0f); |
|||
if (EditorGUI.EndChangeCheck()) |
|||
{ |
|||
useHeightBasedBlend.floatValue = enabled ? 1.0f : 0.0f; |
|||
} |
|||
|
|||
m_MaterialEditor.ShaderProperty(objectScaleAffectTile, mainLayerModeInfluenceEnable ? styles.objectScaleAffectTileText2 : styles.objectScaleAffectTileText); |
|||
|
|||
EditorGUILayout.Space(); |
|||
|
|||
for (int i = 0; i < numLayer; i++) |
|||
{ |
|||
layerChanged |= DoLayerGUI(materialImporter, i); |
|||
} |
|||
|
|||
layerChanged |= GUI.changed; |
|||
GUI.changed = false; |
|||
|
|||
return layerChanged; |
|||
} |
|||
|
|||
|
|||
protected void SetupMaterialKeywordsAndPassInternal(Material material) |
|||
{ |
|||
SetupMaterialKeywordsAndPass(material); |
|||
} |
|||
|
|||
static public void SetKeyword(Material m, string keyword, bool state) |
|||
{ |
|||
if (state) |
|||
m.EnableKeyword(keyword); |
|||
else |
|||
m.DisableKeyword(keyword); |
|||
} |
|||
|
|||
static public void SetupLayersMappingKeywords(Material material) |
|||
{ |
|||
// object scale affect tile
|
|||
SetKeyword(material, "_LAYER_TILING_COUPLED_WITH_UNIFORM_OBJECT_SCALE", material.GetFloat(kObjectScaleAffectTile) > 0.0f); |
|||
|
|||
// Blend mask
|
|||
LayerUVBaseMapping UVBlendMaskMapping = (LayerUVBaseMapping)material.GetFloat(kUVBlendMask); |
|||
SetKeyword(material, "_LAYER_MAPPING_PLANAR_BLENDMASK", UVBlendMaskMapping == LayerUVBaseMapping.Planar); |
|||
|
|||
int numLayer = (int)material.GetFloat(kLayerCount); |
|||
|
|||
// Layer
|
|||
if (numLayer == 4) |
|||
{ |
|||
SetKeyword(material, "_LAYEREDLIT_4_LAYERS", true); |
|||
SetKeyword(material, "_LAYEREDLIT_3_LAYERS", false); |
|||
} |
|||
else if (numLayer == 3) |
|||
{ |
|||
SetKeyword(material, "_LAYEREDLIT_4_LAYERS", false); |
|||
SetKeyword(material, "_LAYEREDLIT_3_LAYERS", true); |
|||
} |
|||
else |
|||
{ |
|||
SetKeyword(material, "_LAYEREDLIT_4_LAYERS", false); |
|||
SetKeyword(material, "_LAYEREDLIT_3_LAYERS", false); |
|||
} |
|||
|
|||
const string kLayerMappingPlanar = "_LAYER_MAPPING_PLANAR"; |
|||
|
|||
// We have to check for each layer if the UV2 or UV3 is needed.
|
|||
bool needUV3 = false; |
|||
bool needUV2 = false; |
|||
|
|||
for (int i = 0; i < numLayer; ++i) |
|||
{ |
|||
string layerUVBaseParam = string.Format("{0}{1}", kUVBase, i); |
|||
LayerUVBaseMapping layerUVBaseMapping = (LayerUVBaseMapping)material.GetFloat(layerUVBaseParam); |
|||
string currentLayerMappingPlanar = string.Format("{0}{1}", kLayerMappingPlanar, i); |
|||
SetKeyword(material, currentLayerMappingPlanar, layerUVBaseMapping == LayerUVBaseMapping.Planar); |
|||
|
|||
string uvBase = string.Format("{0}{1}", kUVBase, i); |
|||
string uvDetail = string.Format("{0}{1}", kUVDetail, i); |
|||
|
|||
if (((UVDetailMapping)material.GetFloat(uvDetail) == UVDetailMapping.UV2) || |
|||
((LayerUVBaseMapping)material.GetFloat(uvBase) == LayerUVBaseMapping.UV2)) |
|||
{ |
|||
needUV2 = true; |
|||
} |
|||
|
|||
if (((UVDetailMapping)material.GetFloat(uvDetail) == UVDetailMapping.UV3) || |
|||
((LayerUVBaseMapping)material.GetFloat(uvBase) == LayerUVBaseMapping.UV3)) |
|||
{ |
|||
needUV3 = true; |
|||
break; // If we find it UV3 let's early out
|
|||
} |
|||
} |
|||
|
|||
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"); |
|||
} |
|||
} |
|||
|
|||
static public void SetupBaseUnlitKeywords(Material material) |
|||
{ |
|||
bool alphaTestEnable = material.GetFloat(kAlphaCutoffEnabled) > 0.0f; |
|||
|
|||
material.SetOverrideTag("RenderType", alphaTestEnable ? "TransparentCutout" : ""); |
|||
material.SetInt("_SrcBlend", (int)UnityEngine.Rendering.BlendMode.One); |
|||
material.SetInt("_DstBlend", (int)UnityEngine.Rendering.BlendMode.Zero); |
|||
material.SetInt("_ZWrite", 1); |
|||
material.renderQueue = alphaTestEnable ? (int)UnityEngine.Rendering.RenderQueue.AlphaTest : -1; |
|||
material.SetInt("_CullMode", (int)UnityEngine.Rendering.CullMode.Back); |
|||
|
|||
SetKeyword(material, "_ALPHATEST_ON", alphaTestEnable); |
|||
} |
|||
|
|||
// 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) |
|||
{ |
|||
SetupBaseUnlitKeywords(material); |
|||
SetupLayersMappingKeywords(material); |
|||
|
|||
for (int i = 0; i < kMaxLayerCount; ++i) |
|||
{ |
|||
SetKeyword(material, "_NORMALMAP" + i, material.GetTexture(kNormalMap + i) || material.GetTexture(kDetailMap + i)); |
|||
|
|||
SetKeyword(material, "_MASKMAP" + i, material.GetTexture(kMaskMap + i)); |
|||
|
|||
SetKeyword(material, "_DETAIL_MAP" + i, material.GetTexture(kDetailMap + i)); |
|||
|
|||
SetKeyword(material, "_HEIGHTMAP" + i, material.GetTexture(kHeightMap + i)); |
|||
} |
|||
|
|||
SetKeyword(material, "_MAIN_LAYER_INFLUENCE_MODE", material.GetFloat(kkUseMainLayerInfluence) != 0.0f); |
|||
|
|||
VertexColorMode VCMode = (VertexColorMode)material.GetFloat(kVertexColorMode); |
|||
if (VCMode == VertexColorMode.Multiply) |
|||
{ |
|||
SetKeyword(material, "_LAYER_MASK_VERTEX_COLOR_MUL", true); |
|||
SetKeyword(material, "_LAYER_MASK_VERTEX_COLOR_ADD", false); |
|||
} |
|||
else if (VCMode == VertexColorMode.Add) |
|||
{ |
|||
SetKeyword(material, "_LAYER_MASK_VERTEX_COLOR_MUL", false); |
|||
SetKeyword(material, "_LAYER_MASK_VERTEX_COLOR_ADD", true); |
|||
} |
|||
else |
|||
{ |
|||
SetKeyword(material, "_LAYER_MASK_VERTEX_COLOR_MUL", false); |
|||
SetKeyword(material, "_LAYER_MASK_VERTEX_COLOR_ADD", false); |
|||
} |
|||
|
|||
bool useHeightBasedBlend = material.GetFloat(kUseHeightBasedBlend) != 0.0f; |
|||
SetKeyword(material, "_HEIGHT_BASED_BLEND", useHeightBasedBlend); |
|||
|
|||
bool useDensityModeEnable = material.GetFloat(kUseDensityMode) != 0.0f; |
|||
SetKeyword(material, "_DENSITY_MODE", useDensityModeEnable); |
|||
} |
|||
protected void FindBaseMaterialProperties(MaterialProperty[] props) |
|||
{ |
|||
alphaCutoffEnable = FindProperty(kAlphaCutoffEnabled, props); |
|||
alphaCutoff = FindProperty(kAlphaCutoff, props); |
|||
} |
|||
|
|||
protected void BaseMaterialPropertiesGUI() |
|||
{ |
|||
EditorGUI.indentLevel++; |
|||
m_MaterialEditor.ShaderProperty(alphaCutoffEnable, StylesLayer.alphaCutoffEnableText); |
|||
if (alphaCutoffEnable.floatValue == 1.0f) |
|||
{ |
|||
m_MaterialEditor.ShaderProperty(alphaCutoff, StylesLayer.alphaCutoffText); |
|||
} |
|||
} |
|||
|
|||
public override void OnGUI(MaterialEditor materialEditor, MaterialProperty[] props) |
|||
{ |
|||
FindBaseMaterialProperties(props); |
|||
FindMaterialProperties(props); |
|||
|
|||
m_MaterialEditor = materialEditor; |
|||
// We should always do this call at the beginning
|
|||
m_MaterialEditor.serializedObject.Update(); |
|||
|
|||
Material material = m_MaterialEditor.target as Material; |
|||
AssetImporter materialImporter = AssetImporter.GetAtPath(AssetDatabase.GetAssetPath(material.GetInstanceID())); |
|||
|
|||
bool optionsChanged = false; |
|||
EditorGUI.BeginChangeCheck(); |
|||
{ |
|||
BaseMaterialPropertiesGUI(); |
|||
EditorGUILayout.Space(); |
|||
} |
|||
if (EditorGUI.EndChangeCheck()) |
|||
{ |
|||
optionsChanged = true; |
|||
} |
|||
|
|||
bool layerChanged = DoLayersGUI(materialImporter); |
|||
|
|||
EditorGUI.indentLevel--; |
|||
m_MaterialEditor.EnableInstancingField(); |
|||
|
|||
if (layerChanged || optionsChanged) |
|||
{ |
|||
foreach (var obj in m_MaterialEditor.targets) |
|||
{ |
|||
SetupMaterialKeywordsAndPassInternal((Material)obj); |
|||
} |
|||
} |
|||
|
|||
// We should always do this call at the end
|
|||
m_MaterialEditor.serializedObject.ApplyModifiedProperties(); |
|||
} |
|||
} |
|||
//} // namespace UnityEditor
|
|||
|
|||
fileFormatVersion: 2 |
|||
guid: a3bb4d5be7ed5bc4fa8e72c75b21ef1b |
|||
timeCreated: 1497279201 |
|||
licenseType: Pro |
|||
MonoImporter: |
|||
serializedVersion: 2 |
|||
defaultReferences: [] |
|||
executionOrder: 0 |
|||
icon: {instanceID: 0} |
|||
userData: |
|||
assetBundleName: |
|||
assetBundleVariant: |
|||
|
|||
Shader "LayeredPhotogrammetry" |
|||
{ |
|||
Properties |
|||
{ |
|||
_BaseColor0("BaseColor0", Color) = (1, 1, 1, 1) |
|||
_BaseColor1("BaseColor1", Color) = (1, 1, 1, 1) |
|||
_BaseColor2("BaseColor2", Color) = (1, 1, 1, 1) |
|||
_BaseColor3("BaseColor3", Color) = (1, 1, 1, 1) |
|||
|
|||
_BaseColorMap0("BaseColorMap0", 2D) = "white" {} |
|||
_BaseColorMap1("BaseColorMap1", 2D) = "white" {} |
|||
_BaseColorMap2("BaseColorMap2", 2D) = "white" {} |
|||
_BaseColorMap3("BaseColorMap3", 2D) = "white" {} |
|||
|
|||
_Metallic0("Metallic0", Range(0.0, 1.0)) = 0 |
|||
_Metallic1("Metallic1", Range(0.0, 1.0)) = 0 |
|||
_Metallic2("Metallic2", Range(0.0, 1.0)) = 0 |
|||
_Metallic3("Metallic3", Range(0.0, 1.0)) = 0 |
|||
|
|||
_Smoothness0("Smoothness0", Range(0.0, 1.0)) = 1.0 |
|||
_Smoothness1("Smoothness1", Range(0.0, 1.0)) = 1.0 |
|||
_Smoothness2("Smoothness2", Range(0.0, 1.0)) = 1.0 |
|||
_Smoothness3("Smoothness3", Range(0.0, 1.0)) = 1.0 |
|||
|
|||
_MaskMap0("MaskMap0", 2D) = "white" {} |
|||
_MaskMap1("MaskMap1", 2D) = "white" {} |
|||
_MaskMap2("MaskMap2", 2D) = "white" {} |
|||
_MaskMap3("MaskMap3", 2D) = "white" {} |
|||
|
|||
_NormalMap0("NormalMap0", 2D) = "bump" {} |
|||
_NormalMap1("NormalMap1", 2D) = "bump" {} |
|||
_NormalMap2("NormalMap2", 2D) = "bump" {} |
|||
_NormalMap3("NormalMap3", 2D) = "bump" {} |
|||
|
|||
_NormalScale0("_NormalScale0", Range(0.0, 2.0)) = 1 |
|||
_NormalScale1("_NormalScale1", Range(0.0, 2.0)) = 1 |
|||
_NormalScale2("_NormalScale2", Range(0.0, 2.0)) = 1 |
|||
_NormalScale3("_NormalScale3", Range(0.0, 2.0)) = 1 |
|||
|
|||
_HeightMap0("HeightMap0", 2D) = "black" {} |
|||
_HeightMap1("HeightMap1", 2D) = "black" {} |
|||
_HeightMap2("HeightMap2", 2D) = "black" {} |
|||
_HeightMap3("HeightMap3", 2D) = "black" {} |
|||
|
|||
_DetailMap0("DetailMap0", 2D) = "black" {} |
|||
_DetailMap1("DetailMap1", 2D) = "black" {} |
|||
_DetailMap2("DetailMap2", 2D) = "black" {} |
|||
_DetailMap3("DetailMap3", 2D) = "black" {} |
|||
|
|||
_DetailMask0("DetailMask0", 2D) = "white" {} |
|||
_DetailMask1("DetailMask1", 2D) = "white" {} |
|||
_DetailMask2("DetailMask2", 2D) = "white" {} |
|||
_DetailMask3("DetailMask3", 2D) = "white" {} |
|||
|
|||
_DetailAlbedoScale0("_DetailAlbedoScale0", Range(-2.0, 2.0)) = 1 |
|||
_DetailAlbedoScale1("_DetailAlbedoScale1", Range(-2.0, 2.0)) = 1 |
|||
_DetailAlbedoScale2("_DetailAlbedoScale2", Range(-2.0, 2.0)) = 1 |
|||
_DetailAlbedoScale3("_DetailAlbedoScale3", Range(-2.0, 2.0)) = 1 |
|||
|
|||
_DetailNormalScale0("_DetailNormalScale0", Range(0.0, 2.0)) = 1 |
|||
_DetailNormalScale1("_DetailNormalScale1", Range(0.0, 2.0)) = 1 |
|||
_DetailNormalScale2("_DetailNormalScale2", Range(0.0, 2.0)) = 1 |
|||
_DetailNormalScale3("_DetailNormalScale3", Range(0.0, 2.0)) = 1 |
|||
|
|||
_DetailSmoothnessScale0("_DetailSmoothnessScale0", Range(-2.0, 2.0)) = 1 |
|||
_DetailSmoothnessScale1("_DetailSmoothnessScale1", Range(-2.0, 2.0)) = 1 |
|||
_DetailSmoothnessScale2("_DetailSmoothnessScale2", Range(-2.0, 2.0)) = 1 |
|||
_DetailSmoothnessScale3("_DetailSmoothnessScale3", Range(-2.0, 2.0)) = 1 |
|||
|
|||
// Layer blending options |
|||
_LayerMaskMap("LayerMaskMap", 2D) = "white" {} |
|||
[ToggleOff] _UseHeightBasedBlend("UseHeightBasedBlend", Float) = 0.0 |
|||
[ToggleOff] _UseHeightBasedBlend("UseHeightBasedBlend", Float) = 0.0 |
|||
// Layer blending options V2 |
|||
[ToggleOff] _UseDensityMode("Use Density mode", Float) = 0.0 |
|||
[ToggleOff] _UseMainLayerInfluence("UseMainLayerInfluence", Float) = 0.0 |
|||
|
|||
// Store result of combination of _HeightFactor and _HeightAmplitude0 |
|||
_LayerHeightAmplitude0("_LayerHeightAmplitude0", Float) = 1 |
|||
_LayerHeightAmplitude1("_LayerHeightAmplitude1", Float) = 1 |
|||
_LayerHeightAmplitude2("_LayerHeightAmplitude2", Float) = 1 |
|||
_LayerHeightAmplitude3("_LayerHeightAmplitude3", Float) = 1 |
|||
|
|||
// Store result of combination of _HeightCenterOffset0 and _HeightCenter0 |
|||
_LayerHeightCenter0("_LayerOffset0", Float) = 0.0 |
|||
_LayerHeightCenter1("_LayerOffset1", Float) = 0.0 |
|||
_LayerHeightCenter2("_LayerOffset2", Float) = 0.0 |
|||
_LayerHeightCenter3("_LayerOffset3", Float) = 0.0 |
|||
|
|||
_BlendUsingHeight1("_BlendUsingHeight1", Float) = 0.0 |
|||
_BlendUsingHeight2("_BlendUsingHeight2", Float) = 0.0 |
|||
_BlendUsingHeight3("_BlendUsingHeight3", Float) = 0.0 |
|||
|
|||
_InheritBaseNormal1("_InheritBaseNormal1", Range(0, 1.0)) = 0.0 |
|||
_InheritBaseNormal2("_InheritBaseNormal2", Range(0, 1.0)) = 0.0 |
|||
_InheritBaseNormal3("_InheritBaseNormal3", Range(0, 1.0)) = 0.0 |
|||
|
|||
_InheritBaseHeight1("_InheritBaseHeight1", Range(0, 1.0)) = 0.0 |
|||
_InheritBaseHeight2("_InheritBaseHeight2", Range(0, 1.0)) = 0.0 |
|||
_InheritBaseHeight3("_InheritBaseHeight3", Range(0, 1.0)) = 0.0 |
|||
|
|||
_InheritBaseColor1("_InheritBaseColor1", Range(0, 1.0)) = 0.0 |
|||
_InheritBaseColor2("_InheritBaseColor2", Range(0, 1.0)) = 0.0 |
|||
_InheritBaseColor3("_InheritBaseColor3", Range(0, 1.0)) = 0.0 |
|||
|
|||
_InheritBaseColorThreshold1("_InheritBaseColorThreshold1", Range(0, 1.0)) = 1.0 |
|||
_InheritBaseColorThreshold2("_InheritBaseColorThreshold2", Range(0, 1.0)) = 1.0 |
|||
_InheritBaseColorThreshold3("_InheritBaseColorThreshold3", Range(0, 1.0)) = 1.0 |
|||
|
|||
_MinimumOpacity0("_MinimumOpacity0", Range(0, 1.0)) = 1.0 |
|||
_MinimumOpacity1("_MinimumOpacity1", Range(0, 1.0)) = 1.0 |
|||
_MinimumOpacity2("_MinimumOpacity2", Range(0, 1.0)) = 1.0 |
|||
_MinimumOpacity3("_MinimumOpacity3", Range(0, 1.0)) = 1.0 |
|||
|
|||
_OpacityAsDensity0("_OpacityAsDensity0", Range(0, 1.0)) = 0.0 |
|||
_OpacityAsDensity1("_OpacityAsDensity1", Range(0, 1.0)) = 0.0 |
|||
_OpacityAsDensity2("_OpacityAsDensity2", Range(0, 1.0)) = 0.0 |
|||
_OpacityAsDensity3("_OpacityAsDensity3", Range(0, 1.0)) = 0.0 |
|||
|
|||
_LayerTilingBlendMask("_LayerTilingBlendMask", Float) = 1 |
|||
_LayerTiling0("_LayerTiling0", Float) = 1 |
|||
_LayerTiling1("_LayerTiling1", Float) = 1 |
|||
_LayerTiling2("_LayerTiling2", Float) = 1 |
|||
_LayerTiling3("_LayerTiling3", Float) = 1 |
|||
|
|||
[HideInInspector] _LayerCount("_LayerCount", Float) = 2.0 |
|||
|
|||
[Enum(None, 0, Multiply, 1, Add, 2)] _VertexColorMode("Vertex color mode", Float) = 0 |
|||
|
|||
[ToggleOff] _ObjectScaleAffectTile("_ObjectScaleAffectTile", Float) = 0.0 |
|||
[Enum(UV0, 0, Planar, 4)] _UVBlendMask("UV Set for blendMask", Float) = 0 |
|||
_TexWorldScaleBlendMask("Tiling", Float) = 1.0 |
|||
|
|||
[ToggleOff] _AlphaCutoffEnable("Alpha Cutoff Enable", Float) = 0.0 |
|||
_AlphaCutoff("Alpha Cutoff", Range(0.0, 1.0)) = 0.5 |
|||
|
|||
_TexWorldScale0("Tiling", Float) = 1.0 |
|||
_TexWorldScale1("Tiling", Float) = 1.0 |
|||
_TexWorldScale2("Tiling", Float) = 1.0 |
|||
_TexWorldScale3("Tiling", Float) = 1.0 |
|||
|
|||
[Enum(UV0, 0, Planar, 4)] _UVBase0("UV Set for base0", Float) = 0 // no UV1/2/3 for main layer |
|||
[Enum(UV0, 0, UV1, 1, UV2, 2, UV3, 3, Planar, 4)] _UVBase1("UV Set for base1", Float) = 0 |
|||
[Enum(UV0, 0, UV1, 1, UV2, 2, UV3, 3, Planar, 4)] _UVBase2("UV Set for base2", Float) = 0 |
|||
[Enum(UV0, 0, UV1, 1, UV2, 2, UV3, 3, Planar, 4)] _UVBase3("UV Set for base3", Float) = 0 |
|||
|
|||
[HideInInspector] _UVMappingMask0("_UVMappingMask0", Color) = (1, 0, 0, 0) |
|||
[HideInInspector] _UVMappingMask1("_UVMappingMask1", Color) = (1, 0, 0, 0) |
|||
[HideInInspector] _UVMappingMask2("_UVMappingMask2", Color) = (1, 0, 0, 0) |
|||
[HideInInspector] _UVMappingMask3("_UVMappingMask3", Color) = (1, 0, 0, 0) |
|||
|
|||
[Enum(UV0, 0, UV1, 1, UV2, 2, UV3, 3)] _UVDetail0("UV Set for detail0", Float) = 0 |
|||
[Enum(UV0, 0, UV1, 1, UV2, 2, UV3, 3)] _UVDetail1("UV Set for detail1", Float) = 0 |
|||
[Enum(UV0, 0, UV1, 1, UV2, 2, UV3, 3)] _UVDetail2("UV Set for detail2", Float) = 0 |
|||
[Enum(UV0, 0, UV1, 1, UV2, 2, UV3, 3)] _UVDetail3("UV Set for detail3", Float) = 0 |
|||
|
|||
[HideInInspector] _UVDetailsMappingMask0("_UVDetailsMappingMask0", Color) = (1, 0, 0, 0) |
|||
[HideInInspector] _UVDetailsMappingMask1("_UVDetailsMappingMask1", Color) = (1, 0, 0, 0) |
|||
[HideInInspector] _UVDetailsMappingMask2("_UVDetailsMappingMask2", Color) = (1, 0, 0, 0) |
|||
[HideInInspector] _UVDetailsMappingMask3("_UVDetailsMappingMask3", Color) = (1, 0, 0, 0) |
|||
} |
|||
|
|||
CGINCLUDE |
|||
|
|||
// Define feature |
|||
#pragma shader_feature _ALPHATEST_ON |
|||
|
|||
|
|||
#pragma shader_feature _LAYER_TILING_COUPLED_WITH_UNIFORM_OBJECT_SCALE |
|||
#pragma shader_feature _ _LAYER_MAPPING_PLANAR_BLENDMASK |
|||
|
|||
#pragma shader_feature _ _LAYER_MAPPING_PLANAR0 |
|||
|
|||
#pragma shader_feature _ _LAYER_MAPPING_PLANAR1 |
|||
|
|||
#pragma shader_feature _ _LAYER_MAPPING_PLANAR2 |
|||
#pragma shader_feature _ _LAYER_MAPPING_PLANAR3 |
|||
#pragma shader_feature _ _REQUIRE_UV2 _REQUIRE_UV3 |
|||
|
|||
#pragma shader_feature _NORMALMAP0 |
|||
#pragma shader_feature _NORMALMAP1 |
|||
#pragma shader_feature _NORMALMAP2 |
|||
#pragma shader_feature _NORMALMAP3 |
|||
|
|||
#pragma shader_feature _MASKMAP0 |
|||
#pragma shader_feature _MASKMAP1 |
|||
#pragma shader_feature _MASKMAP2 |
|||
#pragma shader_feature _MASKMAP3 |
|||
|
|||
#pragma shader_feature _HEIGHTMAP0 |
|||
#pragma shader_feature _HEIGHTMAP1 |
|||
#pragma shader_feature _HEIGHTMAP2 |
|||
#pragma shader_feature _HEIGHTMAP3 |
|||
#pragma shader_feature _DETAIL_MAP0 |
|||
#pragma shader_feature _DETAIL_MAP1 |
|||
#pragma shader_feature _DETAIL_MAP2 |
|||
#pragma shader_feature _DETAIL_MAP3 |
|||
#pragma shader_feature _ _LAYER_MASK_VERTEX_COLOR_MUL _LAYER_MASK_VERTEX_COLOR_ADD |
|||
#pragma shader_feature _MAIN_LAYER_INFLUENCE_MODE |
|||
#pragma shader_feature _DENSITY_MODE |
|||
#pragma shader_feature _HEIGHT_BASED_BLEND |
|||
#pragma shader_feature _ _LAYEREDLIT_3_LAYERS _LAYEREDLIT_4_LAYERS |
|||
|
|||
|
|||
#pragma multi_compile LIGHTMAP_OFF LIGHTMAP_ON |
|||
#pragma multi_compile DIRLIGHTMAP_OFF DIRLIGHTMAP_COMBINED |
|||
#pragma multi_compile DYNAMICLIGHTMAP_OFF DYNAMICLIGHTMAP_ON |
|||
|
|||
#define _MAX_LAYER 4 |
|||
|
|||
#if defined(_LAYEREDLIT_4_LAYERS) |
|||
# define _LAYER_COUNT 4 |
|||
#elif defined(_LAYEREDLIT_3_LAYERS) |
|||
# define _LAYER_COUNT 3 |
|||
#else |
|||
# define _LAYER_COUNT 2 |
|||
#endif |
|||
|
|||
#define MERGE_NAME(X, Y) X##Y |
|||
#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)\ |
|||
UNITY_DECLARE_TEX2D(MERGE_NAME(name, 0)); \ |
|||
UNITY_DECLARE_TEX2D(MERGE_NAME(name, 1)); \ |
|||
UNITY_DECLARE_TEX2D(MERGE_NAME(name, 2)); \ |
|||
UNITY_DECLARE_TEX2D(MERGE_NAME(name, 3)) |
|||
|
|||
float _AlphaCutoff; |
|||
|
|||
// 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, _Metallic); |
|||
PROP_DECL(float, _Smoothness); |
|||
PROP_DECL_TEX2D(_MaskMap); |
|||
|
|||
PROP_DECL_TEX2D(_NormalMap); |
|||
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, _DetailAlbedoScale); |
|||
PROP_DECL(float, _DetailNormalScale); |
|||
PROP_DECL(float, _DetailSmoothnessScale); |
|||
|
|||
PROP_DECL(float, _LayerHeightAmplitude); |
|||
PROP_DECL(float, _LayerHeightCenter); |
|||
PROP_DECL(float, _MinimumOpacity); |
|||
|
|||
UNITY_DECLARE_TEX2D(_LayerMaskMap); |
|||
|
|||
float _BlendUsingHeight1; |
|||
float _BlendUsingHeight2; |
|||
float _BlendUsingHeight3; |
|||
|
|||
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); |
|||
|
|||
#if defined(_REQUIRE_UV2) || defined(_REQUIRE_UV3) || defined(DYNAMICLIGHTMAP_ON) |
|||
#define ATTRIBUTES_NEED_TEXCOORD2 |
|||
#endif |
|||
#if defined(_REQUIRE_UV3) |
|||
#define ATTRIBUTES_NEED_TEXCOORD3 |
|||
#endif |
|||
|
|||
|
|||
ENDCG |
|||
|
|||
SubShader |
|||
{ |
|||
Tags { "RenderType"="Opaque" "PerformanceChecks"="False" } |
|||
LOD 300 |
|||
|
|||
|
|||
// ------------------------------------------------------------------ |
|||
// Base forward pass (directional light, emission, lightmaps, ...) |
|||
Pass |
|||
{ |
|||
Name "FORWARD" |
|||
Tags { "LightMode" = "ForwardBase" } |
|||
|
|||
Blend One Zero |
|||
|
|||
ZWrite On |
|||
|
|||
CGPROGRAM |
|||
#pragma target 3.0 |
|||
|
|||
// ------------------------------------- |
|||
|
|||
//#pragma shader_feature _NORMALMAP |
|||
//#pragma shader_feature _ _ALPHATEST_ON _ALPHABLEND_ON _ALPHAPREMULTIPLY_ON |
|||
//#pragma shader_feature _EMISSION |
|||
//#pragma shader_feature _METALLICGLOSSMAP |
|||
//#pragma shader_feature ___ _DETAIL_MULX2 |
|||
//#pragma shader_feature _ _SMOOTHNESS_TEXTURE_ALBEDO_CHANNEL_A |
|||
//#pragma shader_feature _ _SPECULARHIGHLIGHTS_OFF |
|||
//#pragma shader_feature _ _GLOSSYREFLECTIONS_OFF |
|||
//#pragma shader_feature _PARALLAXMAP |
|||
|
|||
#pragma multi_compile_fwdbase |
|||
#pragma multi_compile_fog |
|||
#pragma multi_compile_instancing |
|||
// Uncomment the following line to enable dithering LOD crossfade. Note: there are more in the file to uncomment for other passes. |
|||
//#pragma multi_compile _ LOD_FADE_CROSSFADE |
|||
|
|||
#pragma vertex vertBase |
|||
#pragma fragment fragBase |
|||
#include "UnityLayeredPhotogrammetryCoreForward.cginc" |
|||
|
|||
ENDCG |
|||
} |
|||
// ------------------------------------------------------------------ |
|||
// Additive forward pass (one light per pass) |
|||
Pass |
|||
{ |
|||
Name "FORWARD_DELTA" |
|||
Tags { "LightMode" = "ForwardAdd" } |
|||
Blend One One |
|||
Fog { Color (0,0,0,0) } // in additive pass fog should be black |
|||
ZWrite Off |
|||
ZTest LEqual |
|||
|
|||
CGPROGRAM |
|||
#pragma target 3.0 |
|||
|
|||
// ------------------------------------- |
|||
|
|||
|
|||
//#pragma shader_feature _NORMALMAP |
|||
//#pragma shader_feature _ _ALPHATEST_ON _ALPHABLEND_ON _ALPHAPREMULTIPLY_ON |
|||
//#pragma shader_feature _METALLICGLOSSMAP |
|||
//#pragma shader_feature _ _SMOOTHNESS_TEXTURE_ALBEDO_CHANNEL_A |
|||
//#pragma shader_feature _ _SPECULARHIGHLIGHTS_OFF |
|||
//#pragma shader_feature ___ _DETAIL_MULX2 |
|||
//#pragma shader_feature _PARALLAXMAP |
|||
|
|||
#pragma multi_compile_fwdadd_fullshadows |
|||
#pragma multi_compile_fog |
|||
// Uncomment the following line to enable dithering LOD crossfade. Note: there are more in the file to uncomment for other passes. |
|||
//#pragma multi_compile _ LOD_FADE_CROSSFADE |
|||
|
|||
#pragma vertex vertAdd |
|||
#pragma fragment fragAdd |
|||
#include "UnityLayeredPhotogrammetryCoreForward.cginc" |
|||
|
|||
ENDCG |
|||
} |
|||
// ------------------------------------------------------------------ |
|||
// Shadow rendering pass |
|||
Pass { |
|||
Name "ShadowCaster" |
|||
Tags { "LightMode" = "ShadowCaster" } |
|||
|
|||
ZWrite On ZTest LEqual |
|||
|
|||
CGPROGRAM |
|||
#pragma target 3.0 |
|||
|
|||
// ------------------------------------- |
|||
|
|||
|
|||
#pragma shader_feature _ _ALPHATEST_ON _ALPHABLEND_ON _ALPHAPREMULTIPLY_ON |
|||
#pragma shader_feature _METALLICGLOSSMAP |
|||
#pragma shader_feature _PARALLAXMAP |
|||
#pragma multi_compile_shadowcaster |
|||
#pragma multi_compile_instancing |
|||
// Uncomment the following line to enable dithering LOD crossfade. Note: there are more in the file to uncomment for other passes. |
|||
//#pragma multi_compile _ LOD_FADE_CROSSFADE |
|||
|
|||
#pragma vertex vertShadowCaster |
|||
#pragma fragment fragShadowCaster |
|||
|
|||
#include "UnityStandardShadow.cginc" |
|||
|
|||
ENDCG |
|||
} |
|||
// ------------------------------------------------------------------ |
|||
// Deferred pass |
|||
Pass |
|||
{ |
|||
Name "DEFERRED" |
|||
Tags { "LightMode" = "Deferred" } |
|||
|
|||
CGPROGRAM |
|||
#pragma target 3.0 |
|||
#pragma exclude_renderers nomrt |
|||
|
|||
|
|||
// ------------------------------------- |
|||
|
|||
//#pragma shader_feature _NORMALMAP |
|||
//#pragma shader_feature _ _ALPHATEST_ON _ALPHABLEND_ON _ALPHAPREMULTIPLY_ON |
|||
//#pragma shader_feature _EMISSION |
|||
//#pragma shader_feature _METALLICGLOSSMAP |
|||
//#pragma shader_feature _ _SMOOTHNESS_TEXTURE_ALBEDO_CHANNEL_A |
|||
//#pragma shader_feature _ _SPECULARHIGHLIGHTS_OFF |
|||
//#pragma shader_feature ___ _DETAIL_MULX2 |
|||
//#pragma shader_feature _PARALLAXMAP |
|||
|
|||
#pragma multi_compile_prepassfinal |
|||
#pragma multi_compile_instancing |
|||
// Uncomment the following line to enable dithering LOD crossfade. Note: there are more in the file to uncomment for other passes. |
|||
//#pragma multi_compile _ LOD_FADE_CROSSFADE |
|||
|
|||
#pragma vertex vertDeferred |
|||
#pragma fragment fragDeferred |
|||
|
|||
#include "UnityLayeredPhotogrammetryCore.cginc" |
|||
|
|||
ENDCG |
|||
} |
|||
|
|||
// ------------------------------------------------------------------ |
|||
// Extracts information for lightmapping, GI (emission, albedo, ...) |
|||
// This pass it not used during regular rendering. |
|||
Pass |
|||
{ |
|||
Name "META" |
|||
Tags { "LightMode"="Meta" } |
|||
|
|||
Cull Off |
|||
|
|||
CGPROGRAM |
|||
#pragma vertex vert_meta |
|||
#pragma fragment frag_meta |
|||
|
|||
//#pragma shader_feature _EMISSION |
|||
//#pragma shader_feature _METALLICGLOSSMAP |
|||
//#pragma shader_feature _ _SMOOTHNESS_TEXTURE_ALBEDO_CHANNEL_A |
|||
//#pragma shader_feature ___ _DETAIL_MULX2 |
|||
//#pragma shader_feature EDITOR_VISUALIZATION |
|||
|
|||
#include "UnityLayeredPhotogrammetryMeta.cginc" |
|||
ENDCG |
|||
} |
|||
} |
|||
|
|||
SubShader |
|||
{ |
|||
Tags { "RenderType"="Opaque" "PerformanceChecks"="False" } |
|||
LOD 150 |
|||
|
|||
// ------------------------------------------------------------------ |
|||
// Base forward pass (directional light, emission, lightmaps, ...) |
|||
Pass |
|||
{ |
|||
Name "FORWARD" |
|||
Tags { "LightMode" = "ForwardBase" } |
|||
|
|||
Blend One Zero |
|||
ZWrite On |
|||
|
|||
CGPROGRAM |
|||
#pragma target 2.0 |
|||
|
|||
//#pragma shader_feature _NORMALMAP |
|||
//#pragma shader_feature _ _ALPHATEST_ON _ALPHABLEND_ON _ALPHAPREMULTIPLY_ON |
|||
//#pragma shader_feature _EMISSION |
|||
//#pragma shader_feature _METALLICGLOSSMAP |
|||
//#pragma shader_feature _ _SMOOTHNESS_TEXTURE_ALBEDO_CHANNEL_A |
|||
//#pragma shader_feature _ _SPECULARHIGHLIGHTS_OFF |
|||
//#pragma shader_feature _ _GLOSSYREFLECTIONS_OFF |
|||
// SM2.0: NOT SUPPORTED shader_feature ___ _DETAIL_MULX2 |
|||
// SM2.0: NOT SUPPORTED shader_feature _PARALLAXMAP |
|||
|
|||
#pragma skip_variants SHADOWS_SOFT DIRLIGHTMAP_COMBINED |
|||
|
|||
#pragma multi_compile_fwdbase |
|||
#pragma multi_compile_fog |
|||
|
|||
#pragma vertex vertBase |
|||
#pragma fragment fragBase |
|||
#include "UnityLayeredPhotogrammetryCoreForward.cginc" |
|||
|
|||
ENDCG |
|||
} |
|||
// ------------------------------------------------------------------ |
|||
// Additive forward pass (one light per pass) |
|||
Pass |
|||
{ |
|||
Name "FORWARD_DELTA" |
|||
Tags { "LightMode" = "ForwardAdd" } |
|||
Blend One One |
|||
Fog { Color (0,0,0,0) } // in additive pass fog should be black |
|||
ZWrite Off |
|||
ZTest LEqual |
|||
|
|||
CGPROGRAM |
|||
#pragma target 2.0 |
|||
|
|||
//#pragma shader_feature _NORMALMAP |
|||
//#pragma shader_feature _ _ALPHATEST_ON _ALPHABLEND_ON _ALPHAPREMULTIPLY_ON |
|||
//#pragma shader_feature _METALLICGLOSSMAP |
|||
//#pragma shader_feature _ _SMOOTHNESS_TEXTURE_ALBEDO_CHANNEL_A |
|||
//#pragma shader_feature _ _SPECULARHIGHLIGHTS_OFF |
|||
//#pragma shader_feature ___ _DETAIL_MULX2 |
|||
// SM2.0: NOT SUPPORTED shader_feature _PARALLAXMAP |
|||
#pragma skip_variants SHADOWS_SOFT |
|||
|
|||
#pragma multi_compile_fwdadd_fullshadows |
|||
#pragma multi_compile_fog |
|||
|
|||
#pragma vertex vertAdd |
|||
#pragma fragment fragAdd |
|||
#include "UnityLayeredPhotogrammetryCoreForward.cginc" |
|||
|
|||
ENDCG |
|||
} |
|||
// ------------------------------------------------------------------ |
|||
// Shadow rendering pass |
|||
Pass { |
|||
Name "ShadowCaster" |
|||
Tags { "LightMode" = "ShadowCaster" } |
|||
|
|||
ZWrite On ZTest LEqual |
|||
|
|||
CGPROGRAM |
|||
#pragma target 2.0 |
|||
|
|||
//#pragma shader_feature _ _ALPHATEST_ON _ALPHABLEND_ON _ALPHAPREMULTIPLY_ON |
|||
//#pragma shader_feature _METALLICGLOSSMAP |
|||
//#pragma skip_variants SHADOWS_SOFT |
|||
#pragma multi_compile_shadowcaster |
|||
|
|||
#pragma vertex vertShadowCaster |
|||
#pragma fragment fragShadowCaster |
|||
|
|||
#include "UnityStandardShadow.cginc" |
|||
|
|||
ENDCG |
|||
} |
|||
|
|||
// ------------------------------------------------------------------ |
|||
// Extracts information for lightmapping, GI (emission, albedo, ...) |
|||
// This pass it not used during regular rendering. |
|||
Pass |
|||
{ |
|||
Name "META" |
|||
Tags { "LightMode"="Meta" } |
|||
|
|||
Cull Off |
|||
|
|||
CGPROGRAM |
|||
#pragma vertex vert_meta |
|||
#pragma fragment frag_meta |
|||
|
|||
//#pragma shader_feature _EMISSION |
|||
//#pragma shader_feature _METALLICGLOSSMAP |
|||
//#pragma shader_feature _ _SMOOTHNESS_TEXTURE_ALBEDO_CHANNEL_A |
|||
//#pragma shader_feature ___ _DETAIL_MULX2 |
|||
//#pragma shader_feature EDITOR_VISUALIZATION |
|||
|
|||
#include "UnityLayeredPhotogrammetryMeta.cginc" |
|||
ENDCG |
|||
} |
|||
} |
|||
|
|||
|
|||
FallBack "VertexLit" |
|||
CustomEditor "LayeredPhotogrammetryGUI" |
|||
} |
|||
|
|||
fileFormatVersion: 2 |
|||
guid: f90795f547a374942a9e5c53acbe0784 |
|||
timeCreated: 1497256144 |
|||
licenseType: Pro |
|||
ShaderImporter: |
|||
defaultTextures: [] |
|||
userData: |
|||
assetBundleName: |
|||
assetBundleVariant: |
|||
|
|||
void ADD_IDX(ComputeLayerTexCoord)( float2 texCoord0, float2 texCoord1, float2 texCoord2, float2 texCoord3, |
|||
float3 positionWS, int mappingType, float worldScale, inout LayerTexCoord layerTexCoord, float additionalTiling = 1.0) |
|||
{ |
|||
// Handle uv0, uv1, uv2, uv3 based on _UVMappingMask weight (exclusif 0..1) |
|||
float2 uvBase = ADD_IDX(_UVMappingMask).x * texCoord0 + |
|||
ADD_IDX(_UVMappingMask).y * texCoord1 + |
|||
ADD_IDX(_UVMappingMask).z * texCoord2 + |
|||
ADD_IDX(_UVMappingMask).w * texCoord3; |
|||
|
|||
// Only used with layered, allow to have additional tiling |
|||
uvBase *= additionalTiling.xx; |
|||
|
|||
|
|||
float2 uvDetails = ADD_IDX(_UVDetailsMappingMask).x * texCoord0 + |
|||
ADD_IDX(_UVDetailsMappingMask).y * texCoord1 + |
|||
ADD_IDX(_UVDetailsMappingMask).z * texCoord2 + |
|||
ADD_IDX(_UVDetailsMappingMask).w * texCoord3; |
|||
|
|||
uvDetails *= additionalTiling.xx; |
|||
|
|||
// If base is planar/triplanar then detail map is forced to be planar/triplanar |
|||
ADD_IDX(layerTexCoord.details).mappingType = ADD_IDX(layerTexCoord.base).mappingType = mappingType; |
|||
ADD_IDX(layerTexCoord.details).normalWS = ADD_IDX(layerTexCoord.base).normalWS = layerTexCoord.vertexNormalWS; |
|||
|
|||
// planar/triplanar |
|||
float2 uvXZ; |
|||
float2 uvXY; |
|||
float2 uvZY; |
|||
GetTriplanarCoordinate(positionWS * worldScale, uvXZ, uvXY, uvZY); |
|||
|
|||
// Planar is just XZ of triplanar |
|||
if (mappingType == UV_MAPPING_PLANAR) |
|||
{ |
|||
uvBase = uvDetails = uvXZ; |
|||
} |
|||
|
|||
// Apply tiling options |
|||
ADD_IDX(layerTexCoord.base).uv = TRANSFORM_TEX(uvBase, ADD_IDX(_BaseColorMap)); |
|||
ADD_IDX(layerTexCoord.details).uv = TRANSFORM_TEX(uvDetails, ADD_IDX(_DetailMap)); |
|||
} |
|||
|
|||
float3 ADD_IDX(GetNormalTS)(FragInputs input, LayerTexCoord layerTexCoord, float3 detailNormalTS, float detailMask, bool useBias, float bias) |
|||
{ |
|||
float3 normalTS; |
|||
|
|||
#ifdef _NORMALMAP_IDX |
|||
if (useBias) |
|||
{ |
|||
normalTS = SAMPLE_UVMAPPING_NORMALMAP_BIAS(ADD_IDX(_NormalMap), SAMPLER_NORMALMAP_IDX, ADD_IDX(layerTexCoord.base), ADD_IDX(_NormalScale), bias); |
|||
} |
|||
else |
|||
{ |
|||
normalTS = SAMPLE_UVMAPPING_NORMALMAP(ADD_IDX(_NormalMap), SAMPLER_NORMALMAP_IDX, ADD_IDX(layerTexCoord.base), ADD_IDX(_NormalScale)); |
|||
} |
|||
|
|||
#ifdef _DETAIL_MAP_IDX |
|||
normalTS = lerp(normalTS, BlendNormalRNM(normalTS, detailNormalTS), detailMask); |
|||
#endif |
|||
#else |
|||
normalTS = float3(0.0, 0.0, 1.0); |
|||
#endif |
|||
|
|||
return normalTS; |
|||
} |
|||
|
|||
// Return opacity |
|||
float ADD_IDX(GetSurfaceData)(FragInputs input, LayerTexCoord layerTexCoord, out SurfaceData surfaceData, out float3 normalTS) |
|||
{ |
|||
float alpha = SAMPLE_UVMAPPING_TEXTURE2D(ADD_IDX(_BaseColorMap), ADD_ZERO_IDX(sampler_BaseColorMap), ADD_IDX(layerTexCoord.base)).a * ADD_IDX(_BaseColor).a; |
|||
|
|||
// Perform alha test very early to save performance (a killed pixel will not sample textures) |
|||
#if defined(_ALPHATEST_ON) && !defined(LAYERED_LIT_SHADER) |
|||
clip(alpha - _AlphaCutoff); |
|||
#endif |
|||
|
|||
float3 detailNormalTS = float3(0.0, 0.0, 0.0); |
|||
float detailMask = 0.0; |
|||
#ifdef _DETAIL_MAP_IDX |
|||
detailMask = SAMPLE_UVMAPPING_TEXTURE2D(ADD_IDX(_DetailMask), SAMPLER_DETAILMASK_IDX, ADD_IDX(layerTexCoord.base)).g; |
|||
float2 detailAlbedoAndSmoothness = SAMPLE_UVMAPPING_TEXTURE2D(ADD_IDX(_DetailMap), SAMPLER_DETAILMAP_IDX, ADD_IDX(layerTexCoord.details)).rb; |
|||
float detailAlbedo = detailAlbedoAndSmoothness.r; |
|||
float detailSmoothness = detailAlbedoAndSmoothness.g; |
|||
// Resample the detail map but this time for the normal map. This call should be optimize by the compiler |
|||
// We split both call due to trilinear mapping |
|||
detailNormalTS = SAMPLE_UVMAPPING_NORMALMAP_AG(ADD_IDX(_DetailMap), SAMPLER_DETAILMAP_IDX, ADD_IDX(layerTexCoord.details), ADD_IDX(_DetailNormalScale)); |
|||
#endif |
|||
|
|||
surfaceData.baseColor = SAMPLE_UVMAPPING_TEXTURE2D(ADD_IDX(_BaseColorMap), ADD_ZERO_IDX(sampler_BaseColorMap), ADD_IDX(layerTexCoord.base)).rgb * ADD_IDX(_BaseColor).rgb; |
|||
#ifdef _DETAIL_MAP_IDX |
|||
surfaceData.baseColor *= LerpWhiteTo(2.0 * saturate(detailAlbedo * ADD_IDX(_DetailAlbedoScale)), detailMask); |
|||
#endif |
|||
|
|||
#ifdef _SPECULAROCCLUSIONMAP_IDX |
|||
// TODO: Do something. For now just take alpha channel |
|||
surfaceData.specularOcclusion = SAMPLE_UVMAPPING_TEXTURE2D(ADD_IDX(_SpecularOcclusionMap), SAMPLER_SPECULAROCCLUSIONMAP_IDX, ADD_IDX(layerTexCoord.base)).a; |
|||
#else |
|||
// The specular occlusion will be perform outside the internal loop |
|||
surfaceData.specularOcclusion = 1.0; |
|||
#endif |
|||
surfaceData.normalWS = float3(0.0, 0.0, 0.0); // Need to init this to keep quiet the compiler, but this is overriden later (0, 0, 0) so if we forget to override the compiler may comply. |
|||
|
|||
normalTS = ADD_IDX(GetNormalTS)(input, layerTexCoord, detailNormalTS, detailMask, false, 0.0); |
|||
|
|||
#if defined(_MASKMAP_IDX) |
|||
surfaceData.perceptualSmoothness = SAMPLE_UVMAPPING_TEXTURE2D(ADD_IDX(_MaskMap), SAMPLER_MASKMAP_IDX, ADD_IDX(layerTexCoord.base)).a; |
|||
#else |
|||
surfaceData.perceptualSmoothness = 1.0; |
|||
#endif |
|||
surfaceData.perceptualSmoothness *= ADD_IDX(_Smoothness); |
|||
#ifdef _DETAIL_MAP_IDX |
|||
surfaceData.perceptualSmoothness *= LerpWhiteTo(2.0 * saturate(detailSmoothness * ADD_IDX(_DetailSmoothnessScale)), detailMask); |
|||
#endif |
|||
|
|||
// MaskMap is RGBA: Metallic, Ambient Occlusion (Optional), emissive Mask (Optional), Smoothness |
|||
#ifdef _MASKMAP_IDX |
|||
surfaceData.metallic = SAMPLE_UVMAPPING_TEXTURE2D(ADD_IDX(_MaskMap), SAMPLER_MASKMAP_IDX, ADD_IDX(layerTexCoord.base)).r; |
|||
surfaceData.ambientOcclusion = SAMPLE_UVMAPPING_TEXTURE2D(ADD_IDX(_MaskMap), SAMPLER_MASKMAP_IDX, ADD_IDX(layerTexCoord.base)).g; |
|||
#else |
|||
surfaceData.metallic = 1.0; |
|||
surfaceData.ambientOcclusion = 1.0; |
|||
#endif |
|||
surfaceData.metallic *= ADD_IDX(_Metallic); |
|||
// Mandatory to setup value to keep compiler quiet |
|||
|
|||
// Layered shader only supports the standard material |
|||
surfaceData.materialId = 1; // MaterialId.LitStandard |
|||
|
|||
// All these parameters are ignore as they are re-setup outside of the layers function |
|||
surfaceData.tangentWS = float3(0.0, 0.0, 0.0); |
|||
surfaceData.anisotropy = 0.0; |
|||
surfaceData.specular = 0.0; |
|||
|
|||
surfaceData.subsurfaceRadius = 0.0; |
|||
surfaceData.thickness = 0.0; |
|||
surfaceData.subsurfaceProfile = 0; |
|||
|
|||
surfaceData.specularColor = float3(0.0, 0.0, 0.0); |
|||
|
|||
return alpha; |
|||
} |
|||
|
|||
fileFormatVersion: 2 |
|||
guid: 7fa7bc071bd7d1b4ba005beb70f1dd93 |
|||
timeCreated: 1497270844 |
|||
licenseType: Pro |
|||
ShaderImporter: |
|||
defaultTextures: [] |
|||
userData: |
|||
assetBundleName: |
|||
assetBundleVariant: |
|||
|
|||
// This structure abstract uv mapping inside one struct. |
|||
// It represent a mapping of any uv (with its associated tangent space for derivative if SurfaceGradient mode) - UVSet0 to 4, planar, triplanar |
|||
|
|||
#define UV_MAPPING_UVSET 0 |
|||
#define UV_MAPPING_PLANAR 1 |
|||
|
|||
// Planar/Triplanar convention for Unity in world space |
|||
void GetTriplanarCoordinate(float3 position, out float2 uvXZ, out float2 uvXY, out float2 uvZY) |
|||
{ |
|||
// Caution: This must follow the same rule as what is use for SurfaceGradient triplanar |
|||
// TODO: Currently the normal mapping looks wrong without SURFACE_GRADIENT option because we don't handle corretly the tangent space |
|||
uvXZ = float2(position.z, position.x); |
|||
uvXY = float2(position.x, position.y); |
|||
uvZY = float2(position.z, position.y); |
|||
} |
|||
|
|||
struct UVMapping |
|||
{ |
|||
int mappingType; |
|||
float2 uv; // Current uv or planar uv |
|||
|
|||
float3 normalWS; // vertex normal |
|||
}; |
|||
|
|||
#define TEXTURE2D_ARGS(textureName, samplerName) Texture2D textureName, SamplerState samplerName |
|||
#define TEXTURE2D_PARAM(textureName, samplerName) textureName, samplerName |
|||
#define UNITY_SAMPLE_TEX2D_SAMPLER(tex,samplertex,coord) tex.Sample (samplertex,coord) |
|||
#define UNITY_SAMPLE_TEX2D_LOD_SAMPLER(tex,samplertex,coord, lod) tex.SampleLevel (samplertex,coord, lod) |
|||
#define UNITY_SAMPLE_TEX2D_BIAS_SAMPLER(tex,samplertex,coord, bias) tex.SampleBias (samplertex,coord, bias) |
|||
|
|||
float3 UnpackNormalRGB(float4 packedNormal, float scale = 1.0) |
|||
{ |
|||
float3 normal; |
|||
normal.xyz = packedNormal.rgb * 2.0 - 1.0; |
|||
normal.xy *= scale; |
|||
return normalize(normal); |
|||
} |
|||
|
|||
float3 UnpackNormalAG(float4 packedNormal, float scale = 1.0) |
|||
{ |
|||
float3 normal; |
|||
normal.xy = packedNormal.wy * 2.0 - 1.0; |
|||
normal.xy *= scale; |
|||
normal.z = sqrt(1.0 - saturate(dot(normal.xy, normal.xy))); |
|||
return normal; |
|||
} |
|||
|
|||
float3 UnpackNormalmapRGorAG(float4 packedNormal, float scale = 1.0) |
|||
{ |
|||
// This do the trick |
|||
packedNormal.w *= packedNormal.x; |
|||
return UnpackNormalAG(packedNormal, scale); |
|||
} |
|||
|
|||
// Regular sampling functions |
|||
#define ADD_FUNC_SUFFIX(Name) Name |
|||
#define SAMPLE_TEXTURE_FUNC(textureName, samplerName, uvMapping, unused) UNITY_SAMPLE_TEX2D_SAMPLER(textureName, samplerName, uvMapping) |
|||
#include "LayeredPhotogrammetrySampleUVMappingInternal.cginc" |
|||
#undef ADD_FUNC_SUFFIX |
|||
#undef SAMPLE_TEXTURE_FUNC |
|||
|
|||
// Lod sampling functions |
|||
#define ADD_FUNC_SUFFIX(Name) Name##Lod |
|||
#define SAMPLE_TEXTURE_FUNC(textureName, samplerName, uvMapping, lod) UNITY_SAMPLE_TEX2D_LOD_SAMPLER(textureName, samplerName, uvMapping, lod) |
|||
#include "LayeredPhotogrammetrySampleUVMappingInternal.cginc" |
|||
#undef ADD_FUNC_SUFFIX |
|||
#undef SAMPLE_TEXTURE_FUNC |
|||
|
|||
// Bias sampling functions |
|||
#define ADD_FUNC_SUFFIX(Name) Name##Bias |
|||
#define SAMPLE_TEXTURE_FUNC(textureName, samplerName, uvMapping, bias) UNITY_SAMPLE_TEX2D_BIAS_SAMPLER(textureName, samplerName, uvMapping, bias) |
|||
#include "LayeredPhotogrammetrySampleUVMappingInternal.cginc" |
|||
#undef ADD_FUNC_SUFFIX |
|||
#undef SAMPLE_TEXTURE_FUNC |
|||
|
|||
// Macro to improve readibility of surface data |
|||
#define SAMPLE_UVMAPPING_TEXTURE2D(textureName, samplerName, uvMapping) SampleUVMapping(TEXTURE2D_PARAM(textureName, samplerName), uvMapping, 0.0) // Last 0.0 is unused |
|||
#define SAMPLE_UVMAPPING_TEXTURE2D_LOD(textureName, samplerName, uvMapping, lod) SampleUVMappingLod(TEXTURE2D_PARAM(textureName, samplerName), uvMapping, lod) |
|||
#define SAMPLE_UVMAPPING_TEXTURE2D_BIAS(textureName, samplerName, uvMapping, bias) SampleUVMappingBias(TEXTURE2D_PARAM(textureName, samplerName), uvMapping, bias) |
|||
|
|||
#define SAMPLE_UVMAPPING_NORMALMAP(textureName, samplerName, uvMapping, scale) SampleUVMappingNormal(TEXTURE2D_PARAM(textureName, samplerName), uvMapping, scale, 0.0) |
|||
#define SAMPLE_UVMAPPING_NORMALMAP_LOD(textureName, samplerName, uvMapping, scale, lod) SampleUVMappingNormalLod(TEXTURE2D_PARAM(textureName, samplerName), uvMapping, scale, lod) |
|||
#define SAMPLE_UVMAPPING_NORMALMAP_BIAS(textureName, samplerName, uvMapping, scale, bias) SampleUVMappingNormalBias(TEXTURE2D_PARAM(textureName, samplerName), uvMapping, scale, bias) |
|||
|
|||
#define SAMPLE_UVMAPPING_NORMALMAP_AG(textureName, samplerName, uvMapping, scale) SampleUVMappingNormalAG(TEXTURE2D_PARAM(textureName, samplerName), uvMapping, scale, 0.0) |
|||
#define SAMPLE_UVMAPPING_NORMALMAP_AG_LOD(textureName, samplerName, uvMapping, scale, lod) SampleUVMappingNormalAGLod(TEXTURE2D_PARAM(textureName, samplerName), uvMapping, scale, lod) |
|||
#define SAMPLE_UVMAPPING_NORMALMAP_AG_BIAS(textureName, samplerName, uvMapping, scale, bias) SampleUVMappingNormalAGBias(TEXTURE2D_PARAM(textureName, samplerName), uvMapping, scale, bias) |
|||
|
|||
#define SAMPLE_UVMAPPING_NORMALMAP_RGB(textureName, samplerName, uvMapping, scale) SampleUVMappingNormalRGB(TEXTURE2D_PARAM(textureName, samplerName), uvMapping, scale, 0.0) |
|||
#define SAMPLE_UVMAPPING_NORMALMAP_RGB_LOD(textureName, samplerName, uvMapping, scale, lod) SampleUVMappingNormalRGBLod(TEXTURE2D_PARAM(textureName, samplerName), uvMapping, scale, lod) |
|||
#define SAMPLE_UVMAPPING_NORMALMAP_RGB_BIAS(textureName, samplerName, uvMapping, scale, bias) SampleUVMappingNormalRGBBias(TEXTURE2D_PARAM(textureName, samplerName), uvMapping, scale, bias) |
|||
|
|||
fileFormatVersion: 2 |
|||
guid: 821dcc02e404ef641a35f02b724b3eac |
|||
timeCreated: 1497271217 |
|||
licenseType: Pro |
|||
ShaderImporter: |
|||
defaultTextures: [] |
|||
userData: |
|||
assetBundleName: |
|||
assetBundleVariant: |
|||
|
|||
|
|||
// These functions are use to hide the handling of triplanar mapping |
|||
// Normal need a specific treatment as they use special encoding for both base and detail map |
|||
// Also we use multiple inclusion to handle the various variation for lod and bias |
|||
|
|||
// param can be unused, lod or bias |
|||
float4 ADD_FUNC_SUFFIX(SampleUVMapping)(TEXTURE2D_ARGS(textureName, samplerName), UVMapping uvMapping, float param) |
|||
{ |
|||
{ |
|||
return SAMPLE_TEXTURE_FUNC(textureName, samplerName, uvMapping.uv, param); |
|||
} |
|||
} |
|||
|
|||
// Nested multiple includes of the file to handle all variations of normal map (AG, RG or RGB) |
|||
|
|||
// This version is use for the base normal map (BC5 or DXT5nm) |
|||
#define ADD_NORMAL_FUNC_SUFFIX(Name) Name |
|||
#if defined(UNITY_NO_DXT5nm) |
|||
#define UNPACK_NORMAL_FUNC UnpackNormalRGB |
|||
#else |
|||
#define UNPACK_NORMAL_FUNC UnpackNormalmapRGorAG |
|||
#endif |
|||
float3 ADD_FUNC_SUFFIX(ADD_NORMAL_FUNC_SUFFIX(SampleUVMappingNormal))(TEXTURE2D_ARGS(textureName, samplerName), UVMapping uvMapping, float scale, float param) |
|||
{ |
|||
return UNPACK_NORMAL_FUNC(SAMPLE_TEXTURE_FUNC(textureName, samplerName, uvMapping.uv, param), scale); |
|||
} |
|||
#undef ADD_NORMAL_FUNC_SUFFIX |
|||
#undef UNPACK_NORMAL_FUNC |
|||
|
|||
// This version is for normalmap with AG encoding only. Use with details map encoded with others properties (like smoothness). |
|||
#define ADD_NORMAL_FUNC_SUFFIX(Name) Name##AG |
|||
#define UNPACK_NORMAL_FUNC UnpackNormalAG |
|||
float3 ADD_FUNC_SUFFIX(ADD_NORMAL_FUNC_SUFFIX(SampleUVMappingNormal))(TEXTURE2D_ARGS(textureName, samplerName), UVMapping uvMapping, float scale, float param) |
|||
{ |
|||
return UNPACK_NORMAL_FUNC(SAMPLE_TEXTURE_FUNC(textureName, samplerName, uvMapping.uv, param), scale); |
|||
} |
|||
#undef ADD_NORMAL_FUNC_SUFFIX |
|||
#undef UNPACK_NORMAL_FUNC |
|||
|
|||
// This version is for normalmap with RGB encoding only, i.e uncompress or BC7. |
|||
#define ADD_NORMAL_FUNC_SUFFIX(Name) Name##RGB |
|||
#define UNPACK_NORMAL_FUNC UnpackNormalRGB |
|||
float3 ADD_FUNC_SUFFIX(ADD_NORMAL_FUNC_SUFFIX(SampleUVMappingNormal))(TEXTURE2D_ARGS(textureName, samplerName), UVMapping uvMapping, float scale, float param) |
|||
{ |
|||
return UNPACK_NORMAL_FUNC(SAMPLE_TEXTURE_FUNC(textureName, samplerName, uvMapping.uv, param), scale); |
|||
} |
|||
#undef ADD_NORMAL_FUNC_SUFFIX |
|||
#undef UNPACK_NORMAL_FUNC |
|||
|
|||
fileFormatVersion: 2 |
|||
guid: fbb4ef2b52866d84186e0d38ddae61e6 |
|||
timeCreated: 1497271217 |
|||
licenseType: Pro |
|||
ShaderImporter: |
|||
defaultTextures: [] |
|||
userData: |
|||
assetBundleName: |
|||
assetBundleVariant: |
|||
1001
Assets/LegacyLayered/UnityLayeredPhotogrammetryCore.cginc
文件差异内容过多而无法显示
查看文件
文件差异内容过多而无法显示
查看文件
|
|||
fileFormatVersion: 2 |
|||
guid: dac69be6f6996b14e824a03121d9e8c6 |
|||
timeCreated: 1497256143 |
|||
licenseType: Pro |
|||
ShaderImporter: |
|||
defaultTextures: [] |
|||
userData: |
|||
assetBundleName: |
|||
assetBundleVariant: |
|||
|
|||
#ifndef UNITY_STANDARD_CORE_FORWARD_INCLUDED |
|||
#define UNITY_STANDARD_CORE_FORWARD_INCLUDED |
|||
|
|||
#if defined(UNITY_NO_FULL_STANDARD_SHADER) |
|||
# define UNITY_STANDARD_SIMPLE 1 |
|||
#endif |
|||
|
|||
#include "UnityStandardConfig.cginc" |
|||
|
|||
#if UNITY_STANDARD_SIMPLE |
|||
# error |
|||
#else |
|||
#include "UnityLayeredPhotogrammetryCore.cginc" |
|||
VertexOutputForwardBase vertBase (VertexInput v) { return vertForwardBase(v); } |
|||
VertexOutputForwardAdd vertAdd (VertexInput v) { return vertForwardAdd(v); } |
|||
half4 fragBase (VertexOutputForwardBase i) : SV_Target { return fragForwardBaseInternal(i); } |
|||
half4 fragAdd (VertexOutputForwardAdd i) : SV_Target { return fragForwardAddInternal(i); } |
|||
#endif |
|||
|
|||
#endif // UNITY_STANDARD_CORE_FORWARD_INCLUDED |
|||
|
|||
fileFormatVersion: 2 |
|||
guid: 3509fad5b0da8fe409cca366ceb504c5 |
|||
timeCreated: 1497256457 |
|||
licenseType: Pro |
|||
ShaderImporter: |
|||
defaultTextures: [] |
|||
userData: |
|||
assetBundleName: |
|||
assetBundleVariant: |
|||
|
|||
#ifndef UNITY_STANDARD_INPUT_INCLUDED |
|||
#define UNITY_STANDARD_INPUT_INCLUDED |
|||
|
|||
#include "UnityCG.cginc" |
|||
#include "UnityStandardConfig.cginc" |
|||
#include "UnityPBSLighting.cginc" // TBD: remove |
|||
#include "UnityStandardUtils.cginc" |
|||
|
|||
//--------------------------------------- |
|||
// Directional lightmaps & Parallax require tangent space too |
|||
#if (_NORMALMAP || DIRLIGHTMAP_COMBINED || _PARALLAXMAP) |
|||
#define _TANGENT_TO_WORLD 1 |
|||
#endif |
|||
|
|||
#if defined(_NORMALMAP0) || defined(_NORMALMAP1) || defined(_NORMALMAP2) || defined(_NORMALMAP3) |
|||
#define _TANGENT_TO_WORLD 1 |
|||
#endif |
|||
|
|||
#if (_DETAIL_MULX2 || _DETAIL_MUL || _DETAIL_ADD || _DETAIL_LERP) |
|||
#define _DETAIL 1 |
|||
#endif |
|||
|
|||
|
|||
// ref http://blog.selfshadow.com/publications/blending-in-detail/ |
|||
// ref https://gist.github.com/selfshadow/8048308 |
|||
// Reoriented Normal Mapping |
|||
// Blending when n1 and n2 are already 'unpacked' and normalised |
|||
// assume compositing in tangent space |
|||
float3 BlendNormalRNM(float3 n1, float3 n2) |
|||
{ |
|||
float3 t = n1.xyz + float3(0.0, 0.0, 1.0); |
|||
float3 u = n2.xyz * float3(-1.0, -1.0, 1.0); |
|||
float3 r = (t / t.z) * dot(t, u) - u; |
|||
return r; |
|||
} |
|||
|
|||
//------------------------------------------------------------------------------------- |
|||
// Input functions |
|||
|
|||
struct VertexInput |
|||
{ |
|||
float4 vertex : POSITION; |
|||
half3 normal : NORMAL; |
|||
float2 uv0 : TEXCOORD0; |
|||
float2 uv1 : TEXCOORD1; |
|||
#if defined(DYNAMICLIGHTMAP_ON) || defined(UNITY_PASS_META) |
|||
float2 uv2 : TEXCOORD2; |
|||
#endif |
|||
|
|||
// BEGIN LAYERED_PHOTOGRAMMETRY |
|||
half4 color : COLOR; |
|||
float2 uv3 : TEXCOORD3; |
|||
// END LAYERED_PHOTOGRAMMETRY |
|||
|
|||
#ifdef _TANGENT_TO_WORLD |
|||
half4 tangent : TANGENT; |
|||
#endif |
|||
UNITY_VERTEX_INPUT_INSTANCE_ID |
|||
}; |
|||
|
|||
float4 TexCoords(VertexInput v) |
|||
{ |
|||
//float4 texcoord; |
|||
//texcoord.xy = TRANSFORM_TEX(v.uv0, _MainTex); // Always source from uv0 |
|||
//texcoord.zw = TRANSFORM_TEX(((_UVSec == 0) ? v.uv0 : v.uv1), _DetailAlbedoMap); |
|||
//return texcoord; |
|||
|
|||
float4 texcoord; |
|||
texcoord.xy = v.uv0; |
|||
texcoord.zw = v.uv1; |
|||
return texcoord; |
|||
} |
|||
|
|||
|
|||
#endif // UNITY_STANDARD_INPUT_INCLUDED |
|||
|
|||
fileFormatVersion: 2 |
|||
guid: 36a92757d8b2b4c4880665c56d4b0dec |
|||
timeCreated: 1497258005 |
|||
licenseType: Pro |
|||
ShaderImporter: |
|||
defaultTextures: [] |
|||
userData: |
|||
assetBundleName: |
|||
assetBundleVariant: |
|||
|
|||
#ifndef UNITY_STANDARD_META_INCLUDED |
|||
#define UNITY_STANDARD_META_INCLUDED |
|||
|
|||
// Functionality for Standard shader "meta" pass |
|||
// (extracts albedo/emission for lightmapper etc.) |
|||
|
|||
// define meta pass before including other files; they have conditions |
|||
// on that in some places |
|||
#define UNITY_PASS_META 1 |
|||
|
|||
#include "UnityCG.cginc" |
|||
#include "UnityMetaPass.cginc" |
|||
|
|||
#include "UnityLayeredPhotogrammetryCore.cginc" |
|||
#include "UnityLayeredPhotogrammetryInput.cginc" |
|||
|
|||
struct v2f_meta |
|||
{ |
|||
float4 uv : TEXCOORD0; |
|||
float4 uv2 : TEXCOORD1; |
|||
half4 tangentToWorldAndPackedData[3] : TEXCOORD2; // [3x3:tangentToWorld | 1x3:viewDirForParallax or worldPos] |
|||
float4 pos : SV_POSITION; |
|||
float4 color : COLOR; |
|||
|
|||
#if UNITY_REQUIRE_FRAG_WORLDPOS && !UNITY_PACK_WORLDPOS_WITH_TANGENT |
|||
float3 posWorld : TEXCOORD8; |
|||
#endif |
|||
}; |
|||
|
|||
v2f_meta vert_meta (VertexInput v) |
|||
{ |
|||
v2f_meta o; |
|||
o.pos = UnityMetaVertexPosition(v.vertex, v.uv1.xy, v.uv2.xy, unity_LightmapST, unity_DynamicLightmapST); |
|||
o.uv = TexCoords(v); |
|||
o.uv2 = float4(v.uv2, v.uv3); // JIG CHECK UV SCALE |
|||
o.color = v.color; |
|||
|
|||
float4 posWorld = mul(unity_ObjectToWorld, v.vertex); |
|||
#if UNITY_REQUIRE_FRAG_WORLDPOS |
|||
#if UNITY_PACK_WORLDPOS_WITH_TANGENT |
|||
o.tangentToWorldAndPackedData[0].w = posWorld.x; |
|||
o.tangentToWorldAndPackedData[1].w = posWorld.y; |
|||
o.tangentToWorldAndPackedData[2].w = posWorld.z; |
|||
#else |
|||
o.posWorld = posWorld.xyz; |
|||
#endif |
|||
#endif |
|||
return o; |
|||
} |
|||
|
|||
// Albedo 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. |
|||
half3 UnityLightmappingAlbedo (half3 diffuse, half3 specular, half smoothness) |
|||
{ |
|||
half roughness = SmoothnessToRoughness(smoothness); |
|||
half3 res = diffuse; |
|||
res += specular * roughness * 0.5; |
|||
return res; |
|||
} |
|||
|
|||
float4 frag_meta (v2f_meta i) : SV_Target |
|||
{ |
|||
// we're interested in diffuse & specular colors, |
|||
// and surface roughness to produce final albedo. |
|||
FragmentCommonData data = FragmentSetupLayeredPhotogrammetry(i.pos, i.uv, i.uv2, i.color, float3(0.0, 0.0, 0.0), i.tangentToWorldAndPackedData, IN_WORLDPOS(i)); |
|||
|
|||
UnityMetaInput o; |
|||
UNITY_INITIALIZE_OUTPUT(UnityMetaInput, o); |
|||
|
|||
#if defined(EDITOR_VISUALIZATION) |
|||
o.Albedo = data.diffColor; |
|||
#else |
|||
o.Albedo = UnityLightmappingAlbedo (data.diffColor, data.specColor, data.smoothness); |
|||
#endif |
|||
o.SpecularColor = data.specColor; |
|||
o.Emission = float3(0.0, 0.0, 0.0);// Emission(i.uv.xy); |
|||
|
|||
return UnityMetaFragment(o); |
|||
} |
|||
|
|||
#endif // UNITY_STANDARD_META_INCLUDED |
|||
|
|||
fileFormatVersion: 2 |
|||
guid: b84d19b0baf3bcb4bbbb3cc8204bcade |
|||
timeCreated: 1497258005 |
|||
licenseType: Pro |
|||
ShaderImporter: |
|||
defaultTextures: [] |
|||
userData: |
|||
assetBundleName: |
|||
assetBundleVariant: |
|||
撰写
预览
正在加载...
取消
保存
Reference in new issue