type shit

This commit is contained in:
niko
2026-06-29 21:52:59 +02:00
parent 8d2eed9892
commit f93f5bfc3d
204 changed files with 16437 additions and 0 deletions
@@ -0,0 +1,620 @@
using System;
using UnityEngine;
namespace UnityEditor
{
internal class UVFreePBRShaderTopBottomGUI : ShaderGUI
{
private enum WorkflowMode
{
Specular,
Metallic,
Dielectric
}
private static class Styles
{
public static GUIStyle optionsButton = "PaneOptions";
public static string emptyTootip = "";
public static GUIContent triplanarSpace = new GUIContent("Triplanar Space", "Whether the triplanar projection should be in local or global space");
public static GUIContent texturePowerText = new GUIContent("Texture Power", "How strong textures on different axes are differentiated. 1 for smooth blending, 10+ for sharper contrasts");
public static GUIContent topMultiplierText = new GUIContent("Top Strength", "How much of the mesh should be considered the top. Set to 0 to disable.");
public static GUIContent bottomMultiplierText = new GUIContent("Bottom Strength", "How much of the mesh should be considered the bottom. Set to 0 to disable.");
public static GUIContent vertexColorStrengthText = new GUIContent("Vertex Color Strength", "0 for no vertex color (off), 1 for full vertex color tinting");
public static GUIContent albedoLabel = new GUIContent("Albedo", "Albedo (RGB) and Transparency (A)");
public static GUIContent albedoText = new GUIContent("Main", "Albedo (RGB) and Transparency (A)");
public static GUIContent albedoTextTop = new GUIContent("Top (+Y)", "Albedo (RGB) and Transparency (A)");
public static GUIContent albedoTextBottom = new GUIContent("Bottom (-Y)", "Albedo (RGB) and Transparency (A)");
public static GUIContent specularLabel = new GUIContent("Specular", "Specular (RGB) and Smoothness (A)");
public static GUIContent specularMapText = new GUIContent("Main", "Specular (RGB) and Smoothness (A)");
public static GUIContent specularMapTextTop = new GUIContent("Top (+Y)", "Specular (RGB) and Smoothness (A)");
public static GUIContent specularMapTextBottom = new GUIContent("Bottom (-Y)", "Specular (RGB) and Smoothness (A)");
public static GUIContent metallicLabel = new GUIContent("Metallic", "Metallic (R) and Smoothness (A)");
public static GUIContent metallicMapText = new GUIContent("Main", "Metallic (R) and Smoothness (A)");
public static GUIContent metallicMapTextTop = new GUIContent("Top (+Y)", "Metallic (R) and Smoothness (A)");
public static GUIContent metallicMapTextBottom = new GUIContent("Bottom (-Y)", "Metallic (R) and Smoothness (A)");
public static GUIContent smoothnessText = new GUIContent("Smoothness", "");
public static GUIContent smoothnessTextTop = new GUIContent("Smoothness", "");
public static GUIContent smoothnessTextBottom = new GUIContent("Smoothness", "");
public static GUIContent normalLabel = new GUIContent("Normal", "Normal Map");
public static GUIContent normalMapText = new GUIContent("Main", "Normal Map");
public static GUIContent normalMapTextTop = new GUIContent("Top (+Y)", "Normal Map");
public static GUIContent normalMapTextBottom = new GUIContent("Bottom (-Y)", "Normal Map");
public static GUIContent emissionLabel = new GUIContent("Emission", "Emission (RGB)");
public static GUIContent emissionText = new GUIContent("Main", "Emission (RGB)");
public static GUIContent emissionTextTop = new GUIContent("Top (+Y)", "Emission (RGB)");
public static GUIContent emissionTextBottom = new GUIContent("Bottom (-Y)", "Emission (RGB)");
public static string textureScaleOffset = "Main Texture Scale/Offset";
public static string textureScaleOffsetTop = "Top (+Y) Texture Scale/Offset";
public static string textureScaleOffsetBottom = "Bottom (-Y) Texture Scale/Offset";
public static string whiteSpaceString = " ";
public static GUIContent emissiveWarning = new GUIContent ("Emissive value is animated but the material has not been configured to support emissive. Please make sure the material itself has some amount of emissive.");
public static GUIContent emissiveColorWarning = new GUIContent ("Ensure emissive color is non-black for emission to have effect.");
public static readonly string[] spaceNames = Enum.GetNames (typeof(Space));
public static string advancedText = "Advanced Options";
}
private const float MIN_VALUE = 0.0f;
// FRONT
MaterialProperty vertexColorStrength = null;
MaterialProperty albedoMap = null;
MaterialProperty albedoColor = null;
MaterialProperty specularMap = null;
MaterialProperty specularColor = null;
MaterialProperty metallicMap = null;
MaterialProperty metallic = null;
MaterialProperty smoothness = null;
MaterialProperty bumpScale = null;
MaterialProperty bumpMap = null;
MaterialProperty emissionScaleUI = null;
MaterialProperty emissionColorUI = null;
MaterialProperty emissionColorForRendering = null;
MaterialProperty emissionMap = null;
// TOP
MaterialProperty albedoMapTop = null;
MaterialProperty albedoColorTop = null;
MaterialProperty specularMapTop = null;
MaterialProperty specularColorTop = null;
MaterialProperty metallicMapTop = null;
MaterialProperty metallicTop = null;
MaterialProperty smoothnessTop = null;
MaterialProperty bumpScaleTop = null;
MaterialProperty bumpMapTop = null;
MaterialProperty emissionScaleUITop = null;
MaterialProperty emissionColorUITop = null;
MaterialProperty emissionMapTop = null;
// BOTTOM
MaterialProperty albedoMapBottom = null;
MaterialProperty albedoColorBottom = null;
MaterialProperty specularMapBottom = null;
MaterialProperty specularColorBottom = null;
MaterialProperty metallicMapBottom = null;
MaterialProperty metallicBottom = null;
MaterialProperty smoothnessBottom = null;
MaterialProperty bumpScaleBottom = null;
MaterialProperty bumpMapBottom = null;
MaterialProperty emissionScaleUIBottom = null;
MaterialProperty emissionColorUIBottom = null;
MaterialProperty emissionMapBottom = null;
MaterialProperty texturePower = null;
MaterialProperty triplanarSpace = null;
MaterialProperty topMultiplier = null;
MaterialProperty bottomMultiplier = null;
MaterialEditor m_MaterialEditor;
WorkflowMode m_WorkflowMode = WorkflowMode.Specular;
bool m_FirstTimeApply = true;
public void FindProperties (MaterialProperty[] props)
{
triplanarSpace = FindProperty("_TriplanarSpace", props, false);
texturePower = FindProperty("_TexPower", props, false);
topMultiplier = FindProperty("_TopMultiplier", props, false);
bottomMultiplier = FindProperty("_BottomMultiplier", props, false);
vertexColorStrength = FindProperty("_VertexColorStrength", props, false);
albedoMap = FindProperty ("_MainTex", props);
albedoColor = FindProperty ("_Color", props);
specularMap = FindProperty ("_SpecGlossMap", props, false);
specularColor = FindProperty ("_SpecColor", props, false);
metallicMap = FindProperty ("_MetallicGlossMap", props, false);
metallic = FindProperty ("_Metallic", props, false);
if (specularMap != null && specularColor != null)
{
m_WorkflowMode = WorkflowMode.Specular;
}
else if (metallicMap != null && metallic != null)
{
m_WorkflowMode = WorkflowMode.Metallic;
}
else
{
m_WorkflowMode = WorkflowMode.Dielectric;
}
smoothness = FindProperty ("_Glossiness", props);
bumpScale = FindProperty ("_BumpScale", props);
bumpMap = FindProperty ("_BumpMap", props);
emissionMap = FindProperty("_EmissionMap", props);
emissionScaleUI = FindProperty ("_EmissionScaleUI", props);
emissionColorUI = FindProperty ("_EmissionColorUI", props);
emissionColorForRendering = FindProperty ("_EmissionColor", props);
// TOP
albedoMapTop = FindProperty ("_TopMainTex", props, false);
albedoColorTop = FindProperty ("_TopColor", props, false);
specularMapTop = FindProperty ("_TopSpecGlossMap", props, false);
specularColorTop = FindProperty ("_TopSpecColor", props, false);
metallicMapTop = FindProperty ("_TopMetallicGlossMap", props, false);
metallicTop = FindProperty ("_TopMetallic", props, false);
smoothnessTop = FindProperty ("_TopGlossiness", props, false);
bumpScaleTop = FindProperty ("_TopBumpScale", props, false);
bumpMapTop = FindProperty ("_TopBumpMap", props, false);
emissionMapTop = FindProperty("_TopEmissionMap", props);
emissionScaleUITop = FindProperty ("_TopEmissionScaleUI", props);
emissionColorUITop = FindProperty ("_TopEmissionColorUI", props);
// BOTTOM
albedoMapBottom = FindProperty ("_BottomMainTex", props, false);
albedoColorBottom = FindProperty ("_BottomColor", props, false);
specularMapBottom = FindProperty ("_BottomSpecGlossMap", props, false);
specularColorBottom = FindProperty ("_BottomSpecColor", props, false);
metallicMapBottom = FindProperty ("_BottomMetallicGlossMap", props, false);
metallicBottom = FindProperty ("_BottomMetallic", props, false);
smoothnessBottom = FindProperty ("_BottomGlossiness", props, false);
bumpScaleBottom = FindProperty ("_BottomBumpScale", props, false);
bumpMapBottom = FindProperty ("_BottomBumpMap", props, false);
emissionMapBottom = FindProperty("_BottomEmissionMap", props, false);
emissionScaleUIBottom = FindProperty ("_BottomEmissionScaleUI", props, false);
emissionColorUIBottom = FindProperty ("_BottomEmissionColorUI", props, false);
}
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;
ShaderPropertiesGUI (material);
// Make sure that needed keywords are set up if we're switching some existing
// material to a standard shader.
if (m_FirstTimeApply)
{
SetMaterialKeywords (material, m_WorkflowMode);
m_FirstTimeApply = false;
}
}
public void ShaderPropertiesGUI (Material material)
{
// Use default labelWidth
EditorGUIUtility.labelWidth = 0f;
// Detect any changes to the material
EditorGUI.BeginChangeCheck();
{
TriplanarSpacePopup();
m_MaterialEditor.RangeProperty (texturePower, "Texture Power");
m_MaterialEditor.RangeProperty (topMultiplier, "Top Multiplier");
m_MaterialEditor.RangeProperty (bottomMultiplier, "Bottom Multiplier");
if (vertexColorStrength != null)
{
m_MaterialEditor.RangeProperty (vertexColorStrength, Styles.vertexColorStrengthText.text);
}
DoAlbedoArea(material);
DoSpecularMetallicArea(material);
// bump
GUILayout.Label(Styles.normalLabel, EditorStyles.boldLabel);
m_MaterialEditor.TexturePropertySingleLine(Styles.normalMapText, bumpMap, bumpMap.textureValue != null ? bumpScale : null);
if (topMultiplier.floatValue > MIN_VALUE)
{
m_MaterialEditor.TexturePropertySingleLine(Styles.normalMapTextTop, bumpMapTop, bumpMapTop.textureValue != null ? bumpScaleTop : null);
}
if (bottomMultiplier.floatValue > MIN_VALUE)
{
m_MaterialEditor.TexturePropertySingleLine(Styles.normalMapTextBottom, bumpMapBottom, bumpMapBottom.textureValue != null ? bumpScaleBottom : null);
}
DoEmissionArea(material);
// MAIN
EditorGUILayout.Space();
GUILayout.Label(Styles.textureScaleOffset, EditorStyles.boldLabel);
m_MaterialEditor.TextureScaleOffsetProperty(albedoMap);
// TOP
if (topMultiplier.floatValue > MIN_VALUE)
{
EditorGUILayout.Space();
GUILayout.Label(Styles.textureScaleOffsetTop, EditorStyles.boldLabel);
m_MaterialEditor.TextureScaleOffsetProperty(albedoMapTop);
}
// BOTTOM
if (bottomMultiplier.floatValue > MIN_VALUE)
{
EditorGUILayout.Space();
GUILayout.Label(Styles.textureScaleOffsetBottom, EditorStyles.boldLabel);
m_MaterialEditor.TextureScaleOffsetProperty(albedoMapBottom);
}
}
if (EditorGUI.EndChangeCheck())
{
MaterialChanged(material, m_WorkflowMode);
}
EditorGUILayout.Space();
GUILayout.Label(Styles.advancedText, EditorStyles.boldLabel);
m_MaterialEditor.RenderQueueField();
m_MaterialEditor.EnableInstancingField();
m_MaterialEditor.DoubleSidedGIField();
}
//internal
void DetermineWorkflow(MaterialProperty[] props)
{
if (FindProperty("_SpecGlossMap", props, false) != null && FindProperty("_SpecColor", props, false) != null)
m_WorkflowMode = WorkflowMode.Specular;
else if (FindProperty("_MetallicGlossMap", props, false) != null && FindProperty("_Metallic", props, false) != null)
m_WorkflowMode = WorkflowMode.Metallic;
else
m_WorkflowMode = WorkflowMode.Dielectric;
}
public override void AssignNewShaderToMaterial (Material material, Shader oldShader, Shader newShader)
{
base.AssignNewShaderToMaterial(material, oldShader, newShader);
}
void TriplanarSpacePopup()
{
EditorGUI.showMixedValue = triplanarSpace.hasMixedValue;
var space = (Space)triplanarSpace.floatValue;
EditorGUI.BeginChangeCheck();
space = (Space)EditorGUILayout.Popup(Styles.triplanarSpace.text, (int)space, Styles.spaceNames);
if (EditorGUI.EndChangeCheck())
{
m_MaterialEditor.RegisterPropertyChangeUndo("Triplanar Space");
triplanarSpace.floatValue = (float)space;
}
EditorGUI.showMixedValue = false;
}
void DoAlbedoArea(Material material)
{
GUILayout.Label(Styles.albedoLabel, EditorStyles.boldLabel);
m_MaterialEditor.TexturePropertySingleLine(Styles.albedoText, albedoMap, albedoColor);
if (material.GetFloat ("_TopMultiplier") > MIN_VALUE)
{
m_MaterialEditor.TexturePropertySingleLine(Styles.albedoTextTop, albedoMapTop, albedoColorTop);
}
if (material.GetFloat ("_BottomMultiplier") > MIN_VALUE)
{
m_MaterialEditor.TexturePropertySingleLine(Styles.albedoTextBottom, albedoMapBottom, albedoColorBottom);
}
}
void DoEmissionArea(Material material)
{
GUILayout.Label(Styles.emissionLabel, EditorStyles.boldLabel);
bool showEmissionColorAndGIControls = emissionScaleUI.floatValue > 0f;
bool showEmissionColorAndGIControlsTop = emissionScaleUITop.floatValue > 0f;
bool showEmissionColorAndGIControlsBottom = emissionScaleUIBottom.floatValue > 0f;
// Do controls
m_MaterialEditor.TexturePropertySingleLine(Styles.emissionText, emissionMap, showEmissionColorAndGIControls ? emissionColorUI : null, emissionScaleUI);
if (material.GetFloat ("_TopMultiplier") > MIN_VALUE)
{
m_MaterialEditor.TexturePropertySingleLine(Styles.emissionTextTop, emissionMapTop, showEmissionColorAndGIControlsTop ? emissionColorUITop : null, emissionScaleUITop);
}
if (material.GetFloat("_BottomMultiplier") > MIN_VALUE)
{
m_MaterialEditor.TexturePropertySingleLine(Styles.emissionTextBottom, emissionMapBottom, showEmissionColorAndGIControlsBottom ? emissionColorUIBottom : null, emissionScaleUIBottom);
}
// Dynamic Lightmapping mode
if (showEmissionColorAndGIControls)
{
bool shouldEmissionBeEnabled = ShouldEmissionBeEnabled(EvalFinalEmissionColor(material));
EditorGUI.BeginDisabledGroup(!shouldEmissionBeEnabled);
m_MaterialEditor.LightmapEmissionProperty (MaterialEditor.kMiniTextureFieldLabelIndentLevel + 1);
EditorGUI.EndDisabledGroup();
}
}
void DoSpecularMetallicArea(Material material)
{
if (m_WorkflowMode == WorkflowMode.Specular)
{
GUILayout.Label(Styles.specularLabel, EditorStyles.boldLabel);
// MAIN
if (specularMap.textureValue == null)
{
m_MaterialEditor.TexturePropertyTwoLines(Styles.specularMapText, specularMap, specularColor, Styles.smoothnessText, smoothness);
}
else
{
m_MaterialEditor.TexturePropertySingleLine(Styles.specularMapText, specularMap);
}
// TOP
if (topMultiplier.floatValue > MIN_VALUE)
{
if (specularMapTop.textureValue == null)
{
m_MaterialEditor.TexturePropertyTwoLines(Styles.specularMapTextTop, specularMapTop, specularColorTop, Styles.smoothnessTextTop, smoothnessTop);
}
else
{
m_MaterialEditor.TexturePropertySingleLine(Styles.specularMapTextTop, specularMapTop);
}
}
// BOTTOM
if (bottomMultiplier.floatValue > MIN_VALUE)
{
if (specularMapBottom.textureValue == null)
{
m_MaterialEditor.TexturePropertyTwoLines(Styles.specularMapTextBottom, specularMapBottom, specularColorBottom, Styles.smoothnessTextBottom, smoothnessBottom);
}
else
{
m_MaterialEditor.TexturePropertySingleLine(Styles.specularMapTextBottom, specularMapBottom);
}
}
}
else if (m_WorkflowMode == WorkflowMode.Metallic)
{
GUILayout.Label(Styles.metallicLabel, EditorStyles.boldLabel);
// MAIN
if (metallicMap.textureValue == null)
{
m_MaterialEditor.TexturePropertyTwoLines(Styles.metallicMapText, metallicMap, metallic, Styles.smoothnessText, smoothness);
}
else
{
m_MaterialEditor.TexturePropertySingleLine(Styles.metallicMapText, metallicMap);
}
// TOP
if (topMultiplier.floatValue > MIN_VALUE)
{
if (metallicMapTop.textureValue == null)
{
m_MaterialEditor.TexturePropertyTwoLines(Styles.metallicMapTextTop, metallicMapTop, metallicTop, Styles.smoothnessTextTop, smoothnessTop);
}
else
{
m_MaterialEditor.TexturePropertySingleLine(Styles.metallicMapTextTop, metallicMapTop);
}
}
// BOTTOM
if (bottomMultiplier.floatValue > MIN_VALUE)
{
if (metallicMapBottom.textureValue == null)
{
m_MaterialEditor.TexturePropertyTwoLines(Styles.metallicMapTextBottom, metallicMapBottom, metallicBottom, Styles.smoothnessTextBottom, smoothnessBottom);
}
else
{
m_MaterialEditor.TexturePropertySingleLine(Styles.metallicMapTextBottom, metallicMapBottom);
}
}
}
}
// Calculate final HDR _EmissionColor (gamma space) from _EmissionColorUI (LDR, gamma) & _EmissionScaleUI (gamma)
static Color EvalFinalEmissionColor(Material material)
{
return material.GetColor("_EmissionColorUI") * material.GetFloat("_EmissionScaleUI");
}
static Color EvalFinalEmissionColorTop(Material material)
{
return material.GetColor("_TopEmissionColorUI") * material.GetFloat("_TopEmissionScaleUI");
}
static Color EvalFinalEmissionColorBottom(Material material)
{
return material.GetColor("_BottomEmissionColorUI") * material.GetFloat("_BottomEmissionScaleUI");
}
static bool ShouldEmissionBeEnabled (Color color)
{
return color.grayscale > (0.1f / 255.0f);
}
static void SetMaterialKeywords(Material material, WorkflowMode workflowMode)
{
// 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)
if (workflowMode == WorkflowMode.Specular)
{
SetKeyword (material, "_SPECGLOSSMAP",
material.GetTexture ("_SpecGlossMap") ||
material.GetTexture ("_TopSpecGlossMap") ||
material.GetTexture ("_BottomSpecGlossMap")
);
}
else if (workflowMode == WorkflowMode.Metallic)
{
SetKeyword (material, "_METALLICGLOSSMAP",
material.GetTexture ("_MetallicGlossMap") ||
material.GetTexture ("_TopMetallicGlossMap") ||
material.GetTexture ("_BottomMetallicGlossMap")
);
}
bool shouldEmissionBeEnabled =
ShouldEmissionBeEnabled (material.GetColor("_EmissionColor"))
|| (material.HasProperty ("_TopMultiplier") && material.GetFloat ("_TopMultiplier") > MIN_VALUE && ShouldEmissionBeEnabled (material.GetColor("_TopEmissionColor")))
|| (material.HasProperty ("_BottomMultiplier") && material.GetFloat ("_BottomMultiplier") > MIN_VALUE && ShouldEmissionBeEnabled (material.GetColor("_BottomEmissionColor")));
SetKeyword (material, "_EMISSION", shouldEmissionBeEnabled);
// Triplanar texture space
SetKeyword(material, "_UVFREE_LOCAL", material.GetFloat ("_TriplanarSpace") == (float) Space.Self);
// whether the bottom is enabled
SetKeyword(material, "_UVFREE_BOTTOM", material.GetFloat ("_BottomMultiplier") > (0.1f / 255.0f));
// Setup lightmap emissive flags
MaterialGlobalIlluminationFlags flags = material.globalIlluminationFlags;
if ((flags & (MaterialGlobalIlluminationFlags.BakedEmissive | MaterialGlobalIlluminationFlags.RealtimeEmissive)) != 0)
{
flags &= ~MaterialGlobalIlluminationFlags.EmissiveIsBlack;
if (!shouldEmissionBeEnabled)
flags |= MaterialGlobalIlluminationFlags.EmissiveIsBlack;
material.globalIlluminationFlags = flags;
}
}
bool HasValidEmissiveKeyword (Material material)
{
// Material animation might be out of sync with the material keyword.
// So if the emission support is disabled on the material, but the property blocks have a value that requires it, then we need to show a warning.
// (note: (Renderer MaterialPropertyBlock applies its values to emissionColorForRendering))
bool hasEmissionKeyword = material.IsKeywordEnabled ("_EMISSION");
if (!hasEmissionKeyword && ShouldEmissionBeEnabled (emissionColorForRendering.colorValue))
return false;
else
return true;
}
static void MaterialChanged(Material material, WorkflowMode workflowMode)
{
// clamp texture power
float tTexPower = material.GetFloat("_TexPower");
if (tTexPower < 0.0f || tTexPower > 20.0f)
{
material.SetFloat ("_TexPower", Mathf.Clamp (tTexPower, 0.0f, 20.0f));
}
// clamp top multiplier
float tTopMultiplier = material.GetFloat ("_TopMultiplier");
if (tTopMultiplier < 0.0f || tTopMultiplier > 8.0f)
{
material.SetFloat ("_TopMultiplier", Mathf.Clamp (tTopMultiplier, 0.0f, 8.0f));
}
// clamp bottom multiplier
float tBottomMultiplier = material.GetFloat ("_BottomMultiplier");
if (tBottomMultiplier < 0.0f || tBottomMultiplier > 8.0f)
{
material.SetFloat ("_BottomMultiplier", Mathf.Clamp (tBottomMultiplier, 0.0f, 8.0f));
}
// Clamp EmissionScale to always positive
if (material.GetFloat("_EmissionScaleUI") < 0.0f)
material.SetFloat("_EmissionScaleUI", 0.0f);
// Apply combined emission value
Color emissionColorOut = EvalFinalEmissionColor (material);
material.SetColor("_EmissionColor", emissionColorOut);
// TOP
if (material.GetFloat("_TopEmissionScaleUI") < 0.0f)
material.SetFloat("_TopEmissionScaleUI", 0.0f);
Color emissionColorOutTop = EvalFinalEmissionColorTop (material);
material.SetColor("_TopEmissionColor", emissionColorOutTop);
// BOTTOM
if (material.GetFloat("_BottomEmissionScaleUI") < 0.0f)
material.SetFloat("_BottomEmissionScaleUI", 0.0f);
Color emissionColorOutBottom = EvalFinalEmissionColorBottom (material);
material.SetColor("_BottomEmissionColor", emissionColorOutBottom);
if (workflowMode == WorkflowMode.Metallic)
{
material.SetFloat ("_UsingMetallicGlossMap", (material.GetTexture ("_MetallicGlossMap") == null) ? 0.0f : 1.0f);
material.SetFloat ("_TopUsingMetallicGlossMap", (material.GetTexture ("_TopMetallicGlossMap") == null) ? 0.0f : 1.0f);
material.SetFloat ("_BottomUsingMetallicGlossMap", (material.GetTexture ("_BottomMetallicGlossMap") == null) ? 0.0f : 1.0f);
}
else if (workflowMode == WorkflowMode.Specular)
{
material.SetFloat ("_UsingSpecGlossMap", (material.GetTexture ("_SpecGlossMap") == null) ? 0.0f : 1.0f);
material.SetFloat ("_TopUsingSpecGlossMap", (material.GetTexture ("_TopSpecGlossMap") == null) ? 0.0f : 1.0f);
material.SetFloat ("_BottomUsingSpecGlossMap", (material.GetTexture ("_BottomSpecGlossMap") == null) ? 0.0f : 1.0f);
}
SetMaterialKeywords(material, workflowMode);
}
static void SetKeyword(Material m, string keyword, bool state)
{
//Debug.Log(keyword + ": " + state);
if (state)
m.EnableKeyword (keyword);
else
m.DisableKeyword (keyword);
}
}
} // namespace UnityEditor