您最多选择25个主题 主题必须以中文或者字母或数字开头,可以包含连字符 (-),并且长度不得超过35个字符
 
 
 
 

715 行
34 KiB

using System;
using System.Collections.Generic;
using System.Linq;
using UnityEngine;
namespace UnityEditor
{
internal class LightweightStandardParticlesShaderGUI : ShaderGUI
{
public enum BlendMode
{
Opaque,
Cutout,
Fade, // Old school alpha-blending mode, fresnel does not affect amount of transparency
Transparent, // Physically plausible transparency mode, implemented as alpha pre-multiply
Additive,
Subtractive,
Modulate
}
public enum FlipbookMode
{
Simple,
Blended
}
public enum ColorMode
{
Multiply,
Additive,
Subtractive,
Overlay,
Color,
Difference
}
private static class Styles
{
public static GUIContent albedoText = new GUIContent("Albedo", "Albedo (RGB) and Transparency (A).");
public static GUIContent alphaCutoffText = new GUIContent("Alpha Cutoff", "Threshold for alpha cutoff.");
public static GUIContent metallicMapText = new GUIContent("Metallic", "Metallic (R) and Smoothness (A).");
public static GUIContent smoothnessText = new GUIContent("Smoothness", "Smoothness value.");
public static GUIContent smoothnessScaleText = new GUIContent("Smoothness", "Smoothness scale factor.");
public static GUIContent normalMapText = new GUIContent("Normal Map", "Normal Map.");
public static GUIContent emissionText = new GUIContent("Color", "Emission (RGB).");
public static GUIContent renderingMode = new GUIContent("Rendering Mode", "Determines the transparency and blending method for drawing the object to the screen.");
public static GUIContent[] blendNames = Array.ConvertAll(Enum.GetNames(typeof(BlendMode)), item => new GUIContent(item));
public static GUIContent colorMode = new GUIContent("Color Mode", "Determines the blending mode between the particle color and the texture albedo.");
public static GUIContent[] colorNames = Array.ConvertAll(Enum.GetNames(typeof(ColorMode)), item => new GUIContent(item));
public static GUIContent flipbookMode = new GUIContent("Flip-Book Mode", "Determines the blending mode used for animated texture sheets.");
public static GUIContent[] flipbookNames = Array.ConvertAll(Enum.GetNames(typeof(FlipbookMode)), item => new GUIContent(item));
public static GUIContent twoSidedEnabled = new GUIContent("Two Sided", "Render both front and back faces of the particle geometry.");
public static GUIContent softParticlesEnabled = new GUIContent("Enable Soft Particles", "Fade out particle geometry when it gets close to the surface of objects written into the depth buffer.");
public static GUIContent softParticlesNearFadeDistanceText = new GUIContent("Near fade", "Soft Particles near fade distance.");
public static GUIContent softParticlesFarFadeDistanceText = new GUIContent("Far fade", "Soft Particles far fade distance.");
public static GUIContent cameraFadingEnabled = new GUIContent("Enable Camera Fading", "Fade out particle geometry when it gets close to the camera.");
public static GUIContent cameraNearFadeDistanceText = new GUIContent("Near fade", "Camera near fade distance.");
public static GUIContent cameraFarFadeDistanceText = new GUIContent("Far fade", "Camera far fade distance.");
public static GUIContent emissionEnabled = new GUIContent("Emission");
public static string blendingOptionsText = "Blending Options";
public static string mainOptionsText = "Main Options";
public static string mapsOptionsText = "Maps";
public static string advancedOptionsText = "Advanced Options";
public static string requiredVertexStreamsText = "Required Vertex Streams";
public static string streamPositionText = "Position (POSITION.xyz)";
public static string streamNormalText = "Normal (NORMAL.xyz)";
public static string streamColorText = "Color (COLOR.xyzw)";
public static string streamUVText = "UV (TEXCOORD0.xy)";
public static string streamUV2Text = "UV2 (TEXCOORD0.zw)";
public static string streamAnimBlendText = "AnimBlend (TEXCOORD1.x)";
public static string streamTangentText = "Tangent (TANGENT.xyzw)";
public static GUIContent streamApplyToAllSystemsText = new GUIContent("Apply to Systems", "Apply the vertex stream layout to all Particle Systems using this material");
}
MaterialProperty blendMode;
MaterialProperty colorMode;
MaterialProperty flipbookMode;
MaterialProperty cullMode;
MaterialProperty albedoMap;
MaterialProperty albedoColor;
MaterialProperty alphaCutoff;
MaterialProperty metallicMap;
MaterialProperty metallic;
MaterialProperty smoothness;
MaterialProperty bumpScale;
MaterialProperty bumpMap;
MaterialProperty emissionEnabled;
MaterialProperty emissionColorForRendering;
MaterialProperty emissionMap;
MaterialProperty softParticlesEnabled;
MaterialProperty cameraFadingEnabled;
MaterialProperty softParticlesNearFadeDistance;
MaterialProperty softParticlesFarFadeDistance;
MaterialProperty cameraNearFadeDistance;
MaterialProperty cameraFarFadeDistance;
MaterialEditor m_MaterialEditor;
List<ParticleSystemRenderer> m_RenderersUsingThisMaterial = new List<ParticleSystemRenderer>();
bool m_FirstTimeApply = true;
public void FindProperties(MaterialProperty[] props)
{
blendMode = FindProperty("_Mode", props);
colorMode = FindProperty("_ColorMode", props, false);
flipbookMode = FindProperty("_FlipbookMode", props);
cullMode = FindProperty("_Cull", props);
albedoMap = FindProperty("_MainTex", props);
albedoColor = FindProperty("_Color", props);
alphaCutoff = FindProperty("_Cutoff", props);
metallicMap = FindProperty("_MetallicGlossMap", props, false);
metallic = FindProperty("_Metallic", props, false);
smoothness = FindProperty("_Glossiness", props, false);
bumpScale = FindProperty("_BumpScale", props, false);
bumpMap = FindProperty("_BumpMap", props, false);
emissionEnabled = FindProperty("_EmissionEnabled", props);
emissionColorForRendering = FindProperty("_EmissionColor", props);
emissionMap = FindProperty("_EmissionMap", props);
softParticlesEnabled = FindProperty("_SoftParticlesEnabled", props);
cameraFadingEnabled = FindProperty("_CameraFadingEnabled", props);
softParticlesNearFadeDistance = FindProperty("_SoftParticlesNearFadeDistance", props);
softParticlesFarFadeDistance = FindProperty("_SoftParticlesFarFadeDistance", props);
cameraNearFadeDistance = FindProperty("_CameraNearFadeDistance", props);
cameraFarFadeDistance = FindProperty("_CameraFarFadeDistance", props);
}
public override void OnGUI(MaterialEditor materialEditor, MaterialProperty[] props)
{
FindProperties(props); // MaterialProperties can be animated so we do not cache them but fetch them every event to ensure animated values are updated correctly
m_MaterialEditor = materialEditor;
Material material = materialEditor.target as Material;
if (m_FirstTimeApply)
{
MaterialChanged(material);
CacheRenderersUsingThisMaterial(material);
m_FirstTimeApply = false;
}
ShaderPropertiesGUI(material);
}
public void ShaderPropertiesGUI(Material material)
{
// Use default labelWidth
EditorGUIUtility.labelWidth = 0f;
// Detect any changes to the material
EditorGUI.BeginChangeCheck();
{
GUILayout.Label(Styles.blendingOptionsText, EditorStyles.boldLabel);
BlendModePopup();
ColorModePopup();
EditorGUILayout.Space();
GUILayout.Label(Styles.mainOptionsText, EditorStyles.boldLabel);
FlipbookModePopup();
TwoSidedPopup(material);
FadingPopup(material);
EditorGUILayout.Space();
GUILayout.Label(Styles.mapsOptionsText, EditorStyles.boldLabel);
DoAlbedoArea(material);
DoSpecularMetallicArea(material);
DoNormalMapArea(material);
DoEmissionArea(material);
if (!flipbookMode.hasMixedValue && (FlipbookMode)flipbookMode.floatValue != FlipbookMode.Blended)
{
EditorGUI.BeginChangeCheck();
m_MaterialEditor.TextureScaleOffsetProperty(albedoMap);
if (EditorGUI.EndChangeCheck())
emissionMap.textureScaleAndOffset = albedoMap.textureScaleAndOffset; // Apply the main texture scale and offset to the emission texture as well, for Enlighten's sake
}
}
if (EditorGUI.EndChangeCheck())
{
foreach (var obj in blendMode.targets)
MaterialChanged((Material)obj);
}
EditorGUILayout.Space();
GUILayout.Label(Styles.requiredVertexStreamsText, EditorStyles.boldLabel);
DoVertexStreamsArea(material);
}
public override void AssignNewShaderToMaterial(Material material, Shader oldShader, Shader newShader)
{
// Sync the lighting flag for the unlit shader
if (newShader.name.Contains("Unlit"))
material.SetFloat("_LightingEnabled", 0.0f);
else
material.SetFloat("_LightingEnabled", 1.0f);
// _Emission property is lost after assigning Standard shader to the material
// thus transfer it before assigning the new shader
if (material.HasProperty("_Emission"))
{
material.SetColor("_EmissionColor", material.GetColor("_Emission"));
}
base.AssignNewShaderToMaterial(material, oldShader, newShader);
if (oldShader == null || !oldShader.name.Contains("Legacy Shaders/"))
{
SetupMaterialWithBlendMode(material, (BlendMode)material.GetFloat("_Mode"));
return;
}
BlendMode blendMode = BlendMode.Opaque;
if (oldShader.name.Contains("/Transparent/Cutout/"))
{
blendMode = BlendMode.Cutout;
}
else if (oldShader.name.Contains("/Transparent/"))
{
// NOTE: legacy shaders did not provide physically based transparency
// therefore Fade mode
blendMode = BlendMode.Fade;
}
material.SetFloat("_Mode", (float)blendMode);
MaterialChanged(material);
}
void BlendModePopup()
{
EditorGUI.showMixedValue = blendMode.hasMixedValue;
var mode = (BlendMode)blendMode.floatValue;
EditorGUI.BeginChangeCheck();
mode = (BlendMode)EditorGUILayout.Popup(Styles.renderingMode, (int)mode, Styles.blendNames);
if (EditorGUI.EndChangeCheck())
{
m_MaterialEditor.RegisterPropertyChangeUndo("Rendering Mode");
blendMode.floatValue = (float)mode;
}
EditorGUI.showMixedValue = false;
}
void ColorModePopup()
{
if (colorMode != null)
{
EditorGUI.showMixedValue = colorMode.hasMixedValue;
var mode = (ColorMode)colorMode.floatValue;
EditorGUI.BeginChangeCheck();
mode = (ColorMode)EditorGUILayout.Popup(Styles.colorMode, (int)mode, Styles.colorNames);
if (EditorGUI.EndChangeCheck())
{
m_MaterialEditor.RegisterPropertyChangeUndo("Color Mode");
colorMode.floatValue = (float)mode;
}
EditorGUI.showMixedValue = false;
}
}
void FlipbookModePopup()
{
EditorGUI.showMixedValue = flipbookMode.hasMixedValue;
var mode = (FlipbookMode)flipbookMode.floatValue;
EditorGUI.BeginChangeCheck();
mode = (FlipbookMode)EditorGUILayout.Popup(Styles.flipbookMode, (int)mode, Styles.flipbookNames);
if (EditorGUI.EndChangeCheck())
{
m_MaterialEditor.RegisterPropertyChangeUndo("Flip-Book Mode");
flipbookMode.floatValue = (float)mode;
}
EditorGUI.showMixedValue = false;
}
void TwoSidedPopup(Material material)
{
EditorGUI.showMixedValue = cullMode.hasMixedValue;
var enabled = (cullMode.floatValue == (float)UnityEngine.Rendering.CullMode.Off);
EditorGUI.BeginChangeCheck();
enabled = EditorGUILayout.Toggle(Styles.twoSidedEnabled, enabled);
if (EditorGUI.EndChangeCheck())
{
m_MaterialEditor.RegisterPropertyChangeUndo("Two Sided Enabled");
cullMode.floatValue = enabled ? (float)UnityEngine.Rendering.CullMode.Off : (float)UnityEngine.Rendering.CullMode.Back;
}
EditorGUI.showMixedValue = false;
}
void FadingPopup(Material material)
{
// Z write doesn't work with fading
bool hasZWrite = (material.GetInt("_ZWrite") != 0);
if (!hasZWrite)
{
// Soft Particles
{
EditorGUI.showMixedValue = softParticlesEnabled.hasMixedValue;
var enabled = softParticlesEnabled.floatValue;
EditorGUI.BeginChangeCheck();
enabled = EditorGUILayout.Toggle(Styles.softParticlesEnabled, enabled != 0.0f) ? 1.0f : 0.0f;
if (EditorGUI.EndChangeCheck())
{
m_MaterialEditor.RegisterPropertyChangeUndo("Soft Particles Enabled");
softParticlesEnabled.floatValue = enabled;
}
if (enabled != 0.0f)
{
int indentation = 2;
m_MaterialEditor.ShaderProperty(softParticlesNearFadeDistance, Styles.softParticlesNearFadeDistanceText, indentation);
m_MaterialEditor.ShaderProperty(softParticlesFarFadeDistance, Styles.softParticlesFarFadeDistanceText, indentation);
}
}
// Camera Fading
{
EditorGUI.showMixedValue = cameraFadingEnabled.hasMixedValue;
var enabled = cameraFadingEnabled.floatValue;
EditorGUI.BeginChangeCheck();
enabled = EditorGUILayout.Toggle(Styles.cameraFadingEnabled, enabled != 0.0f) ? 1.0f : 0.0f;
if (EditorGUI.EndChangeCheck())
{
m_MaterialEditor.RegisterPropertyChangeUndo("Camera Fading Enabled");
cameraFadingEnabled.floatValue = enabled;
}
if (enabled != 0.0f)
{
int indentation = 2;
m_MaterialEditor.ShaderProperty(cameraNearFadeDistance, Styles.cameraNearFadeDistanceText, indentation);
m_MaterialEditor.ShaderProperty(cameraFarFadeDistance, Styles.cameraFarFadeDistanceText, indentation);
}
}
EditorGUI.showMixedValue = false;
}
}
void DoAlbedoArea(Material material)
{
m_MaterialEditor.TexturePropertyWithHDRColor(Styles.albedoText, albedoMap, albedoColor, true);
if (((BlendMode)material.GetFloat("_Mode") == BlendMode.Cutout))
{
m_MaterialEditor.ShaderProperty(alphaCutoff, Styles.alphaCutoffText, MaterialEditor.kMiniTextureFieldLabelIndentLevel);
}
}
void DoEmissionArea(Material material)
{
// Emission
EditorGUI.showMixedValue = emissionEnabled.hasMixedValue;
var enabled = (emissionEnabled.floatValue != 0.0f);
EditorGUI.BeginChangeCheck();
enabled = EditorGUILayout.Toggle(Styles.emissionEnabled, enabled);
if (EditorGUI.EndChangeCheck())
{
m_MaterialEditor.RegisterPropertyChangeUndo("Emission Enabled");
emissionEnabled.floatValue = enabled ? 1.0f : 0.0f;
}
if (enabled)
{
bool hadEmissionTexture = emissionMap.textureValue != null;
// Texture and HDR color controls
m_MaterialEditor.TexturePropertyWithHDRColor(Styles.emissionText, emissionMap, emissionColorForRendering, false);
// If texture was assigned and color was black set color to white
float brightness = emissionColorForRendering.colorValue.maxColorComponent;
if (emissionMap.textureValue != null && !hadEmissionTexture && brightness <= 0f)
emissionColorForRendering.colorValue = Color.white;
}
}
void DoSpecularMetallicArea(Material material)
{
if (metallicMap == null)
return;
bool useLighting = (material.GetFloat("_LightingEnabled") > 0.0f);
if (useLighting)
{
bool hasGlossMap = metallicMap.textureValue != null;
m_MaterialEditor.TexturePropertySingleLine(Styles.metallicMapText, metallicMap, hasGlossMap ? null : metallic);
int indentation = 2; // align with labels of texture properties
bool showSmoothnessScale = hasGlossMap;
m_MaterialEditor.ShaderProperty(smoothness, showSmoothnessScale ? Styles.smoothnessScaleText : Styles.smoothnessText, indentation);
}
}
void DoNormalMapArea(Material material)
{
bool useLighting = (material.GetFloat("_LightingEnabled") > 0.0f);
if (useLighting)
{
m_MaterialEditor.TexturePropertySingleLine(Styles.normalMapText, bumpMap, bumpMap.textureValue != null ? bumpScale : null);
}
}
void DoVertexStreamsArea(Material material)
{
// Display list of streams required to make this shader work
bool useLighting = (material.GetFloat("_LightingEnabled") > 0.0f);
bool useFlipbookBlending = (material.GetFloat("_FlipbookMode") > 0.0f);
bool useTangents = material.GetTexture("_BumpMap") && useLighting;
GUILayout.Label(Styles.streamPositionText, EditorStyles.label);
if (useLighting)
GUILayout.Label(Styles.streamNormalText, EditorStyles.label);
GUILayout.Label(Styles.streamColorText, EditorStyles.label);
GUILayout.Label(Styles.streamUVText, EditorStyles.label);
if (useFlipbookBlending)
{
GUILayout.Label(Styles.streamUV2Text, EditorStyles.label);
GUILayout.Label(Styles.streamAnimBlendText, EditorStyles.label);
}
if (useTangents)
GUILayout.Label(Styles.streamTangentText, EditorStyles.label);
// Build the list of expected vertex streams
List<ParticleSystemVertexStream> streams = new List<ParticleSystemVertexStream>();
streams.Add(ParticleSystemVertexStream.Position);
if (useLighting)
streams.Add(ParticleSystemVertexStream.Normal);
streams.Add(ParticleSystemVertexStream.Color);
streams.Add(ParticleSystemVertexStream.UV);
if (useFlipbookBlending)
{
streams.Add(ParticleSystemVertexStream.UV2);
streams.Add(ParticleSystemVertexStream.AnimBlend);
}
if (useTangents)
streams.Add(ParticleSystemVertexStream.Tangent);
// Set the streams on all systems using this material
if (GUILayout.Button(Styles.streamApplyToAllSystemsText, EditorStyles.miniButton, GUILayout.ExpandWidth(false)))
{
foreach (ParticleSystemRenderer renderer in m_RenderersUsingThisMaterial)
{
renderer.SetActiveVertexStreams(streams);
}
}
// Display a warning if any renderers have incorrect vertex streams
string Warnings = "";
List<ParticleSystemVertexStream> rendererStreams = new List<ParticleSystemVertexStream>();
foreach (ParticleSystemRenderer renderer in m_RenderersUsingThisMaterial)
{
renderer.GetActiveVertexStreams(rendererStreams);
if (!rendererStreams.SequenceEqual(streams))
Warnings += " " + renderer.name + "\n";
}
if (Warnings != "")
{
EditorGUILayout.HelpBox("The following Particle System Renderers are using this material with incorrect Vertex Streams:\n" + Warnings + "Use the Apply to Systems button to fix this", MessageType.Warning, true);
}
EditorGUILayout.Space();
}
public static void SetupMaterialWithBlendMode(Material material, BlendMode blendMode)
{
switch (blendMode)
{
case BlendMode.Opaque:
material.SetOverrideTag("RenderType", "");
material.SetInt("_BlendOp", (int)UnityEngine.Rendering.BlendOp.Add);
material.SetInt("_SrcBlend", (int)UnityEngine.Rendering.BlendMode.One);
material.SetInt("_DstBlend", (int)UnityEngine.Rendering.BlendMode.Zero);
material.SetInt("_ZWrite", 1);
material.DisableKeyword("_ALPHATEST_ON");
material.DisableKeyword("_ALPHABLEND_ON");
material.DisableKeyword("_ALPHAPREMULTIPLY_ON");
material.DisableKeyword("_ALPHAMODULATE_ON");
material.renderQueue = -1;
break;
case BlendMode.Cutout:
material.SetOverrideTag("RenderType", "TransparentCutout");
material.SetInt("_BlendOp", (int)UnityEngine.Rendering.BlendOp.Add);
material.SetInt("_SrcBlend", (int)UnityEngine.Rendering.BlendMode.One);
material.SetInt("_DstBlend", (int)UnityEngine.Rendering.BlendMode.Zero);
material.SetInt("_ZWrite", 1);
material.EnableKeyword("_ALPHATEST_ON");
material.DisableKeyword("_ALPHABLEND_ON");
material.DisableKeyword("_ALPHAPREMULTIPLY_ON");
material.DisableKeyword("_ALPHAMODULATE_ON");
material.renderQueue = (int)UnityEngine.Rendering.RenderQueue.AlphaTest;
break;
case BlendMode.Fade:
material.SetOverrideTag("RenderType", "Transparent");
material.SetInt("_BlendOp", (int)UnityEngine.Rendering.BlendOp.Add);
material.SetInt("_SrcBlend", (int)UnityEngine.Rendering.BlendMode.SrcAlpha);
material.SetInt("_DstBlend", (int)UnityEngine.Rendering.BlendMode.OneMinusSrcAlpha);
material.SetInt("_ZWrite", 0);
material.DisableKeyword("_ALPHATEST_ON");
material.EnableKeyword("_ALPHABLEND_ON");
material.DisableKeyword("_ALPHAPREMULTIPLY_ON");
material.DisableKeyword("_ALPHAMODULATE_ON");
material.renderQueue = (int)UnityEngine.Rendering.RenderQueue.Transparent;
break;
case BlendMode.Transparent:
material.SetOverrideTag("RenderType", "Transparent");
material.SetInt("_BlendOp", (int)UnityEngine.Rendering.BlendOp.Add);
material.SetInt("_SrcBlend", (int)UnityEngine.Rendering.BlendMode.One);
material.SetInt("_DstBlend", (int)UnityEngine.Rendering.BlendMode.OneMinusSrcAlpha);
material.SetInt("_ZWrite", 0);
material.DisableKeyword("_ALPHATEST_ON");
material.DisableKeyword("_ALPHABLEND_ON");
material.EnableKeyword("_ALPHAPREMULTIPLY_ON");
material.DisableKeyword("_ALPHAMODULATE_ON");
material.renderQueue = (int)UnityEngine.Rendering.RenderQueue.Transparent;
break;
case BlendMode.Additive:
material.SetOverrideTag("RenderType", "Transparent");
material.SetInt("_BlendOp", (int)UnityEngine.Rendering.BlendOp.Add);
material.SetInt("_SrcBlend", (int)UnityEngine.Rendering.BlendMode.SrcAlpha);
material.SetInt("_DstBlend", (int)UnityEngine.Rendering.BlendMode.One);
material.SetInt("_ZWrite", 0);
material.DisableKeyword("_ALPHATEST_ON");
material.EnableKeyword("_ALPHABLEND_ON");
material.DisableKeyword("_ALPHAPREMULTIPLY_ON");
material.DisableKeyword("_ALPHAMODULATE_ON");
material.renderQueue = (int)UnityEngine.Rendering.RenderQueue.Transparent;
break;
case BlendMode.Subtractive:
material.SetOverrideTag("RenderType", "Transparent");
material.SetInt("_BlendOp", (int)UnityEngine.Rendering.BlendOp.ReverseSubtract);
material.SetInt("_SrcBlend", (int)UnityEngine.Rendering.BlendMode.SrcAlpha);
material.SetInt("_DstBlend", (int)UnityEngine.Rendering.BlendMode.One);
material.SetInt("_ZWrite", 0);
material.DisableKeyword("_ALPHATEST_ON");
material.EnableKeyword("_ALPHABLEND_ON");
material.DisableKeyword("_ALPHAPREMULTIPLY_ON");
material.DisableKeyword("_ALPHAMODULATE_ON");
material.renderQueue = (int)UnityEngine.Rendering.RenderQueue.Transparent;
break;
case BlendMode.Modulate:
material.SetOverrideTag("RenderType", "Transparent");
material.SetInt("_BlendOp", (int)UnityEngine.Rendering.BlendOp.Add);
material.SetInt("_SrcBlend", (int)UnityEngine.Rendering.BlendMode.DstColor);
material.SetInt("_DstBlend", (int)UnityEngine.Rendering.BlendMode.OneMinusSrcAlpha);
material.SetInt("_ZWrite", 0);
material.DisableKeyword("_ALPHATEST_ON");
material.DisableKeyword("_ALPHABLEND_ON");
material.DisableKeyword("_ALPHAPREMULTIPLY_ON");
material.EnableKeyword("_ALPHAMODULATE_ON");
material.renderQueue = (int)UnityEngine.Rendering.RenderQueue.Transparent;
break;
}
}
public static void SetupMaterialWithColorMode(Material material, ColorMode colorMode)
{
switch (colorMode)
{
case ColorMode.Multiply:
material.DisableKeyword("_COLOROVERLAY_ON");
material.DisableKeyword("_COLORCOLOR_ON");
material.DisableKeyword("_COLORADDSUBDIFF_ON");
break;
case ColorMode.Overlay:
material.DisableKeyword("_COLORCOLOR_ON");
material.DisableKeyword("_COLORADDSUBDIFF_ON");
material.EnableKeyword("_COLOROVERLAY_ON");
break;
case ColorMode.Color:
material.DisableKeyword("_COLOROVERLAY_ON");
material.DisableKeyword("_COLORADDSUBDIFF_ON");
material.EnableKeyword("_COLORCOLOR_ON");
break;
case ColorMode.Difference:
material.DisableKeyword("_COLOROVERLAY_ON");
material.DisableKeyword("_COLORCOLOR_ON");
material.EnableKeyword("_COLORADDSUBDIFF_ON");
material.SetVector("_ColorAddSubDiff", new Vector4(-1.0f, 1.0f, 0.0f, 0.0f));
break;
case ColorMode.Additive:
material.DisableKeyword("_COLOROVERLAY_ON");
material.DisableKeyword("_COLORCOLOR_ON");
material.EnableKeyword("_COLORADDSUBDIFF_ON");
material.SetVector("_ColorAddSubDiff", new Vector4(1.0f, 0.0f, 0.0f, 0.0f));
break;
case ColorMode.Subtractive:
material.DisableKeyword("_COLOROVERLAY_ON");
material.DisableKeyword("_COLORCOLOR_ON");
material.EnableKeyword("_COLORADDSUBDIFF_ON");
material.SetVector("_ColorAddSubDiff", new Vector4(-1.0f, 0.0f, 0.0f, 0.0f));
break;
}
}
void SetMaterialKeywords(Material material)
{
// Z write doesn't work with distortion/fading
bool hasZWrite = (material.GetInt("_ZWrite") != 0);
// Lit shader?
bool useLighting = (material.GetFloat("_LightingEnabled") > 0.0f);
// 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, "_NORMALMAP", material.GetTexture("_BumpMap") && useLighting);
SetKeyword(material, "_METALLICGLOSSMAP", (material.GetTexture("_MetallicGlossMap") != null) && useLighting);
material.globalIlluminationFlags = MaterialGlobalIlluminationFlags.None;
SetKeyword(material, "_EMISSION", material.GetFloat("_EmissionEnabled") > 0.0f);
// Set the define for flipbook blending
bool useFlipbookBlending = (material.GetFloat("_FlipbookMode") > 0.0f);
SetKeyword(material, "_REQUIRE_UV2", useFlipbookBlending);
// Clamp fade distances
bool useSoftParticles = (material.GetFloat("_SoftParticlesEnabled") > 0.0f);
bool useCameraFading = (material.GetFloat("_CameraFadingEnabled") > 0.0f);
float softParticlesNearFadeDistance = material.GetFloat("_SoftParticlesNearFadeDistance");
float softParticlesFarFadeDistance = material.GetFloat("_SoftParticlesFarFadeDistance");
float cameraNearFadeDistance = material.GetFloat("_CameraNearFadeDistance");
float cameraFarFadeDistance = material.GetFloat("_CameraFarFadeDistance");
if (softParticlesNearFadeDistance < 0.0f)
{
softParticlesNearFadeDistance = 0.0f;
material.SetFloat("_SoftParticlesNearFadeDistance", 0.0f);
}
if (softParticlesFarFadeDistance < 0.0f)
{
softParticlesFarFadeDistance = 0.0f;
material.SetFloat("_SoftParticlesFarFadeDistance", 0.0f);
}
if (cameraNearFadeDistance < 0.0f)
{
cameraNearFadeDistance = 0.0f;
material.SetFloat("_CameraNearFadeDistance", 0.0f);
}
if (cameraFarFadeDistance < 0.0f)
{
cameraFarFadeDistance = 0.0f;
material.SetFloat("_CameraFarFadeDistance", 0.0f);
}
// Set the define for fading
bool useFading = (useSoftParticles || useCameraFading) && !hasZWrite;
SetKeyword(material, "_FADING_ON", useFading);
if (useSoftParticles)
material.SetVector("_SoftParticleFadeParams", new Vector4(softParticlesNearFadeDistance, 1.0f / (softParticlesFarFadeDistance - softParticlesNearFadeDistance), 0.0f, 0.0f));
else
material.SetVector("_SoftParticleFadeParams", new Vector4(0.0f, 0.0f, 0.0f, 0.0f));
if (useCameraFading)
material.SetVector("_CameraFadeParams", new Vector4(cameraNearFadeDistance, 1.0f / (cameraFarFadeDistance - cameraNearFadeDistance), 0.0f, 0.0f));
else
material.SetVector("_CameraFadeParams", new Vector4(0.0f, Mathf.Infinity, 0.0f, 0.0f));
// Set the define for distortion + grabpass (Distortion not supported)
material.SetShaderPassEnabled("Always", false);
}
void MaterialChanged(Material material)
{
SetupMaterialWithBlendMode(material, (BlendMode)material.GetFloat("_Mode"));
if (colorMode != null)
SetupMaterialWithColorMode(material, (ColorMode)material.GetFloat("_ColorMode"));
SetMaterialKeywords(material);
}
void CacheRenderersUsingThisMaterial(Material material)
{
m_RenderersUsingThisMaterial.Clear();
ParticleSystemRenderer[] renderers = UnityEngine.Object.FindObjectsOfType(typeof(ParticleSystemRenderer)) as ParticleSystemRenderer[];
foreach (ParticleSystemRenderer renderer in renderers)
{
if (renderer.sharedMaterial == material)
m_RenderersUsingThisMaterial.Add(renderer);
}
}
static void SetKeyword(Material m, string keyword, bool state)
{
if (state)
m.EnableKeyword(keyword);
else
m.DisableKeyword(keyword);
}
}
} // namespace UnityEditor