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)
SetKeyword(material, "_NORMALMAP", material.GetTexture("_BumpMap") || material.GetTexture("_DetailNormalMap"));
if (workflowMode == WorkflowMode.Specular)
{
SetKeyword(material, "_SPECGLOSSMAP", material.GetTexture("_SpecGlossMap"));
}
else if (workflowMode == WorkflowMode.Metallic)
{
SetKeyword(material, "_METALLICGLOSSMAP", material.GetTexture("_MetallicGlossMap"));
}
SetKeyword(material, "_PARALLAXMAP", material.GetTexture("_ParallaxMap"));
SetKeyword(material, "_DETAIL_MULX2", material.GetTexture("_DetailAlbedoMap") || material.GetTexture("_DetailNormalMap"));
bool shouldEmissionBeEnabled = ShouldEmissionBeEnabled(material.GetColor("_EmissionColor"));
SetKeyword(material, "_EMISSION", shouldEmissionBeEnabled);
// 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;
}
}
public void LightmapEmissionFlagsProperty(int indent, bool enabled, bool ignoreEmissionColor)
{
// Calculate isMixed
MaterialGlobalIlluminationFlags any_em = MaterialGlobalIlluminationFlags.AnyEmissive;
MaterialGlobalIlluminationFlags giFlags = shaderEditor.materials[0].globalIlluminationFlags & any_em;
bool isMixed = false;
for (int i = 1; i < shaderEditor.materials.Length; i++)
{
if ((shaderEditor.materials[i].globalIlluminationFlags & any_em) != giFlags)
{
isMixed = true;
break;
}
}
EditorGUI.BeginChangeCheck();
// Show popup
EditorGUI.showMixedValue = isMixed;
giFlags = (MaterialGlobalIlluminationFlags)EditorGUILayout.IntPopup(lightmapEmissiveLabel, (int)giFlags, lightmapEmissiveStrings, lightmapEmissiveValues);
EditorGUI.showMixedValue = false;
// Apply flags. But only the part that this tool modifies (RealtimeEmissive, BakedEmissive, None)
bool applyFlags = EditorGUI.EndChangeCheck();
foreach (Material mat in shaderEditor.materials)
{
mat.globalIlluminationFlags = applyFlags ? giFlags : mat.globalIlluminationFlags;
if (!ignoreEmissionColor)
{
FixupEmissiveFlag(mat);
}
}
}
private static void SetMaterialKeywords(Material material, StandardShaderGUI.WorkflowMode workflowMode)
{
StandardShaderGUI.SetKeyword(material, "_NORMALMAP", (bool)((UnityEngine.Object)material.GetTexture("_BumpMap")) || (bool)((UnityEngine.Object)material.GetTexture("_DetailNormalMap")));
if (workflowMode == StandardShaderGUI.WorkflowMode.Specular)
{
StandardShaderGUI.SetKeyword(material, "_SPECGLOSSMAP", (bool)((UnityEngine.Object)material.GetTexture("_SpecGlossMap")));
}
else if (workflowMode == StandardShaderGUI.WorkflowMode.Metallic)
{
StandardShaderGUI.SetKeyword(material, "_METALLICGLOSSMAP", (bool)((UnityEngine.Object)material.GetTexture("_MetallicGlossMap")));
}
StandardShaderGUI.SetKeyword(material, "_PARALLAXMAP", (bool)((UnityEngine.Object)material.GetTexture("_ParallaxMap")));
StandardShaderGUI.SetKeyword(material, "_DETAIL_MULX2", (bool)((UnityEngine.Object)material.GetTexture("_DetailAlbedoMap")) || (bool)((UnityEngine.Object)material.GetTexture("_DetailNormalMap")));
bool state = StandardShaderGUI.ShouldEmissionBeEnabled(material.GetColor("_EmissionColor"));
StandardShaderGUI.SetKeyword(material, "_EMISSION", state);
MaterialGlobalIlluminationFlags illuminationFlags1 = material.globalIlluminationFlags;
if ((illuminationFlags1 & (MaterialGlobalIlluminationFlags.RealtimeEmissive | MaterialGlobalIlluminationFlags.BakedEmissive)) == MaterialGlobalIlluminationFlags.None)
{
return;
}
MaterialGlobalIlluminationFlags illuminationFlags2 = illuminationFlags1 & ~MaterialGlobalIlluminationFlags.EmissiveIsBlack;
if (!state)
{
illuminationFlags2 |= MaterialGlobalIlluminationFlags.EmissiveIsBlack;
}
material.globalIlluminationFlags = illuminationFlags2;
}
private static void SetMaterialKeywords(Material material, StandardShaderGUI.WorkflowMode workflowMode)
{
StandardShaderGUI.SetKeyword(material, "_NORMALMAP", material.GetTexture("_BumpMap") || material.GetTexture("_DetailNormalMap"));
if (workflowMode == StandardShaderGUI.WorkflowMode.Specular)
{
StandardShaderGUI.SetKeyword(material, "_SPECGLOSSMAP", material.GetTexture("_SpecGlossMap"));
}
else if (workflowMode == StandardShaderGUI.WorkflowMode.Metallic)
{
StandardShaderGUI.SetKeyword(material, "_METALLICGLOSSMAP", material.GetTexture("_MetallicGlossMap"));
}
StandardShaderGUI.SetKeyword(material, "_PARALLAXMAP", material.GetTexture("_ParallaxMap"));
StandardShaderGUI.SetKeyword(material, "_DETAIL_MULX2", material.GetTexture("_DetailAlbedoMap") || material.GetTexture("_DetailNormalMap"));
bool flag = StandardShaderGUI.ShouldEmissionBeEnabled(material, material.GetColor("_EmissionColor"));
StandardShaderGUI.SetKeyword(material, "_EMISSION", flag);
if (material.HasProperty("_SmoothnessTextureChannel"))
{
StandardShaderGUI.SetKeyword(material, "_SMOOTHNESS_TEXTURE_ALBEDO_CHANNEL_A", StandardShaderGUI.GetSmoothnessMapChannel(material) == StandardShaderGUI.SmoothnessMapChannel.AlbedoAlpha);
}
MaterialGlobalIlluminationFlags materialGlobalIlluminationFlags = material.globalIlluminationFlags;
if ((materialGlobalIlluminationFlags & (MaterialGlobalIlluminationFlags.RealtimeEmissive | MaterialGlobalIlluminationFlags.BakedEmissive)) != MaterialGlobalIlluminationFlags.None)
{
materialGlobalIlluminationFlags &= ~MaterialGlobalIlluminationFlags.EmissiveIsBlack;
if (!flag)
{
materialGlobalIlluminationFlags |= MaterialGlobalIlluminationFlags.EmissiveIsBlack;
}
material.globalIlluminationFlags = materialGlobalIlluminationFlags;
}
}
private static void SetMaterialKeywords(Material material, WorkflowMode workflowMode)
{
SetKeyword(material, "_NORMALMAP", (material.GetTexture("_BumpMap") != null) || ((bool)material.GetTexture("_DetailNormalMap")));
if (workflowMode == WorkflowMode.Specular)
{
SetKeyword(material, "_SPECGLOSSMAP", (bool)material.GetTexture("_SpecGlossMap"));
}
else if (workflowMode == WorkflowMode.Metallic)
{
SetKeyword(material, "_METALLICGLOSSMAP", (bool)material.GetTexture("_MetallicGlossMap"));
}
SetKeyword(material, "_PARALLAXMAP", (bool)material.GetTexture("_ParallaxMap"));
SetKeyword(material, "_DETAIL_MULX2", (material.GetTexture("_DetailAlbedoMap") != null) || ((bool)material.GetTexture("_DetailNormalMap")));
bool state = ShouldEmissionBeEnabled(material.GetColor("_EmissionColor"));
SetKeyword(material, "_EMISSION", state);
MaterialGlobalIlluminationFlags globalIlluminationFlags = material.globalIlluminationFlags;
if ((globalIlluminationFlags & (MaterialGlobalIlluminationFlags.BakedEmissive | MaterialGlobalIlluminationFlags.RealtimeEmissive)) != MaterialGlobalIlluminationFlags.None)
{
globalIlluminationFlags &= ~MaterialGlobalIlluminationFlags.EmissiveIsBlack;
if (!state)
{
globalIlluminationFlags |= MaterialGlobalIlluminationFlags.EmissiveIsBlack;
}
material.globalIlluminationFlags = globalIlluminationFlags;
}
}
private static void SetMaterialKeywords(Material material, StandardShaderGUI.WorkflowMode workflowMode)
{
StandardShaderGUI.SetKeyword(material, "_NORMALMAP", material.GetTexture("_BumpMap") || material.GetTexture("_DetailNormalMap"));
if (workflowMode == StandardShaderGUI.WorkflowMode.Specular)
{
StandardShaderGUI.SetKeyword(material, "_SPECGLOSSMAP", material.GetTexture("_SpecGlossMap"));
}
else
{
if (workflowMode == StandardShaderGUI.WorkflowMode.Metallic)
{
StandardShaderGUI.SetKeyword(material, "_METALLICGLOSSMAP", material.GetTexture("_MetallicGlossMap"));
}
}
StandardShaderGUI.SetKeyword(material, "_PARALLAXMAP", material.GetTexture("_ParallaxMap"));
StandardShaderGUI.SetKeyword(material, "_DETAIL_MULX2", material.GetTexture("_DetailAlbedoMap") || material.GetTexture("_DetailNormalMap"));
bool flag = StandardShaderGUI.ShouldEmissionBeEnabled(material.GetColor("_EmissionColor"));
StandardShaderGUI.SetKeyword(material, "_EMISSION", flag);
MaterialGlobalIlluminationFlags materialGlobalIlluminationFlags = material.globalIlluminationFlags;
if ((materialGlobalIlluminationFlags & (MaterialGlobalIlluminationFlags.RealtimeEmissive | MaterialGlobalIlluminationFlags.BakedEmissive)) != MaterialGlobalIlluminationFlags.None)
{
materialGlobalIlluminationFlags &= ~MaterialGlobalIlluminationFlags.EmissiveIsBlack;
if (!flag)
{
materialGlobalIlluminationFlags |= MaterialGlobalIlluminationFlags.EmissiveIsBlack;
}
material.globalIlluminationFlags = materialGlobalIlluminationFlags;
}
}
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)
SetKeyword(material, "_NORMALMAP", material.GetTexture("_BumpMap") || material.GetTexture("_DetailNormalMap"));
if (workflowMode == WorkflowMode.Specular)
{
SetKeyword(material, "_SPECGLOSSMAP", material.GetTexture("_SpecGlossMap"));
}
else if (workflowMode == WorkflowMode.Metallic)
{
SetKeyword(material, "_METALLICGLOSSMAP", material.GetTexture("_MetallicGlossMap"));
}
bool shouldEmissionBeEnabled = ShouldEmissionBeEnabled(material, material.GetColor("_EmissionColor"));
SetKeyword(material, "_EMISSION", shouldEmissionBeEnabled);
// fun dream zone
SetKeyword(material, "_REFLECTIONMAP", material.GetTexture("_ReflectionMap"));
SetKeyword(material, "_RIMOFFSET", material.GetFloat("_RimOffset") > 0);
SetKeyword(material, "_REAL_FRESNEL", material.GetFloat("_Real_Fresnel") > 0 && (BlendMode)material.GetFloat("_Mode") == BlendMode.Fade ||
material.GetFloat("_Real_Fresnel") > 0 && (BlendMode)material.GetFloat("_Mode") == BlendMode.Transparent);
//layer system
SetKeyword(material, "_UV3_ON", material.GetFloat("_UV2") == 1);
SetKeyword(material, "_UV4_ON", material.GetFloat("_UV3") == 1);
SetKeyword(material, "_MASKTEX", material.GetTexture("_MaskTex"));
SetKeyword(material, "_LAYER_BASE_TEX", material.GetTexture("_LayerBaseTex"));
SetKeyword(material, "_LAYER_BASE_NORMAL", material.GetTexture("_LayerBaseNormal"));
SetKeyword(material, "_LayerBaseUVSet_0", material.GetFloat("_LayerBaseUVSet") == 0);
SetKeyword(material, "_LayerBaseUVSet_1", material.GetFloat("_LayerBaseUVSet") == 1);
SetKeyword(material, "_LayerBaseUVSet_2", material.GetFloat("_LayerBaseUVSet") == 2);
SetKeyword(material, "_LayerBaseUVSet_3", material.GetFloat("_LayerBaseUVSet") == 3);
// set key for layer Blend Mode
SetKeyword(material, "_LayerBase_Blend_Normal", material.GetFloat("_LayerBaseBlendMode") == 0);
SetKeyword(material, "_LayerBase_Blend_Multiply", material.GetFloat("_LayerBaseBlendMode") == 1);
//SetKeyword(material, "_LayerBase_Blend_Darken", material.GetFloat("_LayerBaseBlendMode") == 2);
// 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;
}
}
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)
SetKeyword(material, "_NORMALMAP", material.GetTexture("_BumpMap") || material.GetTexture("_DetailNormalMap"));
if (workflowMode == WorkflowMode.Specular)
{
SetKeyword(material, "_SPECGLOSSMAP", material.GetTexture("_SpecGlossMap"));
}
else if (workflowMode == WorkflowMode.Metallic)
{
SetKeyword(material, "_METALLICGLOSSMAP", material.GetTexture("_MetallicGlossMap"));
}
SetKeyword(material, "_PARALLAXMAP", material.GetTexture("_ParallaxMap"));
SetKeyword(material, "_DETAIL_MULX2", material.GetTexture("_DetailAlbedoMap") || material.GetTexture("_DetailNormalMap"));
bool shouldEmissionBeEnabled = ShouldEmissionBeEnabled(material, material.GetColor("_EmissionColor"));
SetKeyword(material, "_EMISSION", shouldEmissionBeEnabled);
if (material.HasProperty("_SmoothnessTextureChannel"))
{
SetKeyword(material, "_SMOOTHNESS_TEXTURE_ALBEDO_CHANNEL_A", GetSmoothnessMapChannel(material) == SmoothnessMapChannel.AlbedoAlpha);
}
// 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;
}
float intensity = material.GetFloat("_IntensityVC");
if (intensity <= 0f)
{
SetKeyword(material, "_VERTEXCOLOR_LERP", false);
SetKeyword(material, "_VERTEXCOLOR", false);
}
else if (intensity > 0f && intensity < 1f)
{
SetKeyword(material, "_VERTEXCOLOR_LERP", true);
SetKeyword(material, "_VERTEXCOLOR", false);
}
else
{
SetKeyword(material, "_VERTEXCOLOR_LERP", false);
SetKeyword(material, "_VERTEXCOLOR", true);
}
}
protected override void ReadFromImpl(object obj)
{
base.ReadFromImpl(obj);
Material uo = (Material)obj;
renderQueue = uo.renderQueue;
globalIlluminationFlags = uo.globalIlluminationFlags;
doubleSidedGI = uo.doubleSidedGI;
enableInstancing = uo.enableInstancing;
shaderKeywords = uo.shaderKeywords;
}
public static MaterialGlobalIlluminationFlags FixupEmissiveFlag(Color col, MaterialGlobalIlluminationFlags flags)
{
if ((flags & MaterialGlobalIlluminationFlags.BakedEmissive) != 0 && col.maxColorComponent == 0.0f) // flag black baked
{
flags |= MaterialGlobalIlluminationFlags.EmissiveIsBlack;
}
else if (flags != MaterialGlobalIlluminationFlags.EmissiveIsBlack) // clear baked flag on everything else, unless it's explicity disabled
{
flags &= MaterialGlobalIlluminationFlags.AnyEmissive;
}
return(flags);
}
public static MaterialGlobalIlluminationFlags FixupEmissiveFlag(Color col, MaterialGlobalIlluminationFlags flags)
{
if ((flags & MaterialGlobalIlluminationFlags.BakedEmissive) != MaterialGlobalIlluminationFlags.None && col.maxColorComponent == 0f)
{
flags |= MaterialGlobalIlluminationFlags.EmissiveIsBlack;
}
else if (flags != MaterialGlobalIlluminationFlags.EmissiveIsBlack)
{
flags &= MaterialGlobalIlluminationFlags.AnyEmissive;
}
return(flags);
}
public override void Deserialize(BinaryReader binaryReader)
{
base.Deserialize(binaryReader);
m_doubleSidedGI = binaryReader.ReadBoolean();
m_enableInstancing = binaryReader.ReadBoolean();
m_mainTexPropIdx = binaryReader.ReadInt32();
m_passCount = binaryReader.ReadInt32();
m_renderQueue = binaryReader.ReadInt32();
m_globalIlluminationFlags = (MaterialGlobalIlluminationFlags)binaryReader.ReadInt32();
m_shader = SerializerKun.DesirializeObject <ShaderKun>(binaryReader);
m_shaderKeywords = SerializerKun.DesirializeStrings(binaryReader);
m_propertys = SerializerKun.DesirializeObjects <Property>(binaryReader);
}
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;
}
}
public static void DrawLightmapFlagsOptions()
{
EditorGUILayout.BeginHorizontal();
GUILayout.FlexibleSpace();
EditorGUI.BeginChangeCheck();
MaterialGlobalIlluminationFlags value = (MaterialGlobalIlluminationFlags)EditorGUILayout.EnumPopup(ThryEditor.currentlyDrawing.materials[0].globalIlluminationFlags, GUILayout.ExpandWidth(false));
if (EditorGUI.EndChangeCheck())
{
foreach (Material m in ThryEditor.currentlyDrawing.materials)
{
m.globalIlluminationFlags = value;
}
}
EditorGUILayout.EndHorizontal();
}
static void SetEmissiveAndGI(Material material, ShaderType type, bool hasContour2)
{
bool emits;
if (type == ShaderType.Unlit)
{
emits = true;
}
else
{
emits =
Emits(GetColor(CP.EmissionColor, 0, material)) ||
hasContour2 && Emits(GetColor(CP.EmissionColor, 1, material));
if (emits)
{
bool emissionMaps =
GetTexture(CP.EmissionMap, 0, material) ||
(hasContour2 && GetTexture(CP.EmissionMap, 1, material));
SetKeyword(material, "_EMISSION", !emissionMaps);
SetKeyword(material, "_EMISSIONMAP", emissionMaps);
}
else
{
SetKeyword(material, "_EMISSION", false);
SetKeyword(material, "_EMISSIONMAP", false);
}
}
// Setup lightmap and emissive flags
MaterialGlobalIlluminationFlags flags = material.globalIlluminationFlags;
MaterialGlobalIlluminationFlags mask = MaterialGlobalIlluminationFlags.BakedEmissive |
MaterialGlobalIlluminationFlags.RealtimeEmissive;
if ((flags & mask) != 0)
{
if (emits)
{
flags &= ~MaterialGlobalIlluminationFlags.EmissiveIsBlack;
}
else
{
flags |= MaterialGlobalIlluminationFlags.EmissiveIsBlack;
}
material.globalIlluminationFlags = flags;
}
}
public override void Draw(AlloyFieldDrawerArgs args)
{
args.Editor.MatEditor.LightmapEmissionProperty();
foreach (var material in args.Materials)
{
// Setup lightmap emissive flags
MaterialGlobalIlluminationFlags flags = material.globalIlluminationFlags;
if ((flags & (MaterialGlobalIlluminationFlags.BakedEmissive | MaterialGlobalIlluminationFlags.RealtimeEmissive)) != 0)
{
flags &= ~MaterialGlobalIlluminationFlags.EmissiveIsBlack;
material.globalIlluminationFlags = flags;
}
}
}
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)
SetKeyword(material, "_NORMALMAP", material.GetTexture("_BumpMap"));
if (workflowMode == WorkflowMode.Specular)
{
SetKeyword(material, "_SPECGLOSSMAP", material.GetTexture("_SpecGlossMap"));
}
else if (workflowMode == WorkflowMode.Metallic)
{
SetKeyword(material, "_METALLICGLOSSMAP", material.GetTexture("_MetallicGlossMap"));
}
bool shouldEmissionBeEnabled = ShouldEmissionBeEnabled(material, material.GetColor("_EmissionColor"));
SetKeyword(material, "_EMISSION", shouldEmissionBeEnabled);
if (material.HasProperty("_SmoothnessTextureChannel"))
{
SetKeyword(material, "_SMOOTHNESS_TEXTURE_ALBEDO_CHANNEL_A", GetSmoothnessMapChannel(material) == SmoothnessMapChannel.AlbedoAlpha);
}
if (material.HasProperty("_UVSec"))
{
SetKeyword(material, "_SECOND_UV", material.GetFloat("_UVSec") > 0.5f);
}
SetKeyword(material, "_TEXTURE_MASK", material.GetTexture("_DFMask"));
// 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;
}
}
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)
SetKeyword(material, "_NORMALMAP", material.GetTexture("_BumpMap") || material.GetTexture("_DetailNormalMap"));
if (workflowMode == WorkflowMode.Specular)
{
SetKeyword(material, "_SPECGLOSSMAP", material.GetTexture("_SpecGlossMap"));
}
else if (workflowMode == WorkflowMode.Metallic)
{
SetKeyword(material, "_METALLICGLOSSMAP", material.GetTexture("_MetallicGlossMap"));
}
SetKeyword(material, "_PARALLAXMAP", material.GetTexture("_ParallaxMap"));
SetKeyword(material, "_DETAIL_MULX2", material.GetTexture("_DetailAlbedoMap") || material.GetTexture("_DetailNormalMap"));
bool shouldEmissionBeEnabled = ShouldEmissionBeEnabled(material, material.GetColor("_EmissionColor"));
SetKeyword(material, "_EMISSION", shouldEmissionBeEnabled);
if (material.HasProperty("_SmoothnessTextureChannel"))
{
SetKeyword(material, "_SMOOTHNESS_TEXTURE_ALBEDO_CHANNEL_A", GetSmoothnessMapChannel(material) == SmoothnessMapChannel.AlbedoAlpha);
}
// 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;
}
//if we want the primary section plane to appear in material preview:
//material.DisableKeyword("CLIP_PLANE");//if we want the primary section plane to appear in material preview
//Shader.SetGlobalVector("_SectionPlane", new Vector3(0.707f,0,-0.2f));
//Shader.SetGlobalVector("_SectionPoint", Vector3.zero);
}
protected virtual void SetupEmissionGIFlags(Material material)
{
// Setup lightmap emissive flags
MaterialGlobalIlluminationFlags flags = material.globalIlluminationFlags;
if ((flags & (MaterialGlobalIlluminationFlags.BakedEmissive | MaterialGlobalIlluminationFlags.RealtimeEmissive)) != 0)
{
if (ShouldEmissionBeEnabled(material))
{
flags &= ~MaterialGlobalIlluminationFlags.EmissiveIsBlack;
}
else
{
flags |= MaterialGlobalIlluminationFlags.EmissiveIsBlack;
}
material.globalIlluminationFlags = flags;
}
}
private static int get_globalIlluminationFlags(IntPtr L)
{
object obj = null;
int result;
try
{
obj = ToLua.ToObject(L, 1);
Material material = (Material)obj;
MaterialGlobalIlluminationFlags globalIlluminationFlags = material.globalIlluminationFlags;
ToLua.Push(L, globalIlluminationFlags);
result = 1;
}
catch (Exception ex)
{
result = LuaDLL.toluaL_exception(L, ex, (obj != null) ? ex.Message : "attempt to index globalIlluminationFlags on a nil value");
}
return(result);
}
private static int set_globalIlluminationFlags(IntPtr L)
{
object obj = null;
int result;
try
{
obj = ToLua.ToObject(L, 1);
Material material = (Material)obj;
MaterialGlobalIlluminationFlags globalIlluminationFlags = (int)ToLua.CheckObject(L, 2, typeof(MaterialGlobalIlluminationFlags));
material.set_globalIlluminationFlags(globalIlluminationFlags);
result = 0;
}
catch (Exception ex)
{
result = LuaDLL.toluaL_exception(L, ex, (obj != null) ? ex.get_Message() : "attempt to index globalIlluminationFlags on a nil value");
}
return(result);
}
public MaterialSerializable(Material material) : base(material)
{
shaderKeywords = material.shaderKeywords;
enableInstancing = material.enableInstancing;
doubleSidedGI = material.doubleSidedGI;
globalIlluminationFlags = material.globalIlluminationFlags;
renderQueue = material.renderQueue;
mainTextureScale = material.mainTextureScale;
mainTextureOffset = material.mainTextureOffset;
shader = material.shader != null ? new ShaderSerializable(material.shader) : null;
if (material.HasProperty("_Color"))
{
color = material.GetColor("_Color");
}
if (material.HasProperty("_MainTex"))
{
var tex = material.GetTexture("_MainTex");
mainTex = tex != null ? new TextureUnion(tex) : null;
}
}
public static void SetKeywords()
{
foreach (Material mat in materials)
{
if (Mathf.Approximately(material.GetFloat("_AASmooth"), 0f))
{
material.DisableKeyword("_AA_ON");
}
else
{
material.EnableKeyword("_AA_ON");
}
if (isProjector || isUnlit || isMobile)
{
continue;
}
var shouldEmissionBeEnabled = !Mathf.Approximately(material.GetFloat("_WEmission"), 0f) ||
!Mathf.Approximately(material.GetFloat("_GEmission"), 0f) ||
WFAShaderGUI.ShouldEmissionBeEnabled(material, material.GetColor("_EmissionColor"));
SetKeyword(material, "_EMISSION", shouldEmissionBeEnabled);
SetKeyword(mat, "_NORMALMAP", material.GetTexture("_BumpMap"));
SetKeyword(material, "_METALLICGLOSSMAP", material.GetTexture("_MetallicGlossMap"));
// 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;
}
}
}
//Setup GI emission
private void SetGIFlags()
{
foreach (Material obj in emissionColor.targets)
{
bool emissive = true;
if (obj.GetColor("_EmissionColor") == Color.black)
{
emissive = false;
}
MaterialGlobalIlluminationFlags flags = obj.globalIlluminationFlags;
if ((flags & (MaterialGlobalIlluminationFlags.BakedEmissive | MaterialGlobalIlluminationFlags.RealtimeEmissive)) != 0)
{
flags &= ~MaterialGlobalIlluminationFlags.EmissiveIsBlack;
if (!emissive)
{
flags |= MaterialGlobalIlluminationFlags.EmissiveIsBlack;
}
obj.globalIlluminationFlags = flags;
}
}
}
public static void SetMaterialKeywords(Material material, WorkflowMode workflowMode)
{
SetKeyword(material, "_NORMALMAP", material.GetTexture("_BumpMap") || material.GetTexture("_DetailNormalMap"));
if (workflowMode == WorkflowMode.Specular)
{
SetKeyword(material, "_SPECGLOSSMAP", material.GetTexture("_SpecGlossMap"));
}
else if (workflowMode == WorkflowMode.Metallic)
{
SetKeyword(material, "_METALLICGLOSSMAP", material.GetTexture("_MetallicGlossMap"));
}
SetKeyword(material, "_PARALLAXMAP", material.GetTexture("_ParallaxMap"));
SetKeyword(material, "_DETAIL_MULX2", material.GetTexture("_DetailAlbedoMap") || material.GetTexture("_DetailNormalMap"));
bool shouldEmissionBeEnabled = ShouldEmissionBeEnabled(material, material.GetColor("_EmissionColor"));
SetKeyword(material, "_EMISSION", shouldEmissionBeEnabled);
if (material.HasProperty("_SmoothnessTextureChannel"))
{
SetKeyword(material, "_SMOOTHNESS_TEXTURE_ALBEDO_CHANNEL_A", GetSmoothnessMapChannel(material) == SmoothnessMapChannel.AlbedoAlpha);
}
// 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;
}
}
// Non-static and direct property use breaks the comment below, but should be safe for our use cases.
/*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)
SetKeyword(material, "_NORMALMAP", material.GetTexture("_BumpMap") || material.GetTexture("_DetailNormalMap"));
SetKeyword(material, "ORTHONORMALIZE_TANGENT_BASE", orthoNormalize != null && orthoNormalize.floatValue > 0.5f);
bool specGlossMap = material.GetTexture("_SpecGlossMap");
SetKeyword(material, "SMOOTHNESS_IN_ALBEDO", smoothnessInAlbedo != null && smoothnessInAlbedo.floatValue > 0.5f && !specGlossMap);
if (workflowMode == WorkflowMode.Specular)
{
SetKeyword(material, "_SPECGLOSSMAP", specGlossMap);
}
else if (workflowMode == WorkflowMode.Metallic)
{
SetKeyword(material, "_METALLICGLOSSMAP", material.GetTexture("_MetallicGlossMap"));
}
SetKeyword(material, "_PARALLAXMAP", material.GetTexture("_ParallaxMap"));
SetKeyword(material, "_DETAIL_MULX2", material.GetTexture("_DetailAlbedoMap") || material.GetTexture("_DetailNormalMap"));
var enableEmission = ShouldEmissionBeEnabled(material.GetColor("_EmissionColor"));
SetKeyword(material, "_EMISSION", enableEmission);
// Setup lightmap emissive flags
MaterialGlobalIlluminationFlags flags = material.globalIlluminationFlags;
if ((flags & (MaterialGlobalIlluminationFlags.BakedEmissive | MaterialGlobalIlluminationFlags.RealtimeEmissive)) != 0)
{
flags &= ~MaterialGlobalIlluminationFlags.EmissiveIsBlack;
if (!enableEmission)
{
flags |= MaterialGlobalIlluminationFlags.EmissiveIsBlack;
}
material.globalIlluminationFlags = flags;
}
}
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)
SetKeyword(material, "_NORMALMAP", material.GetTexture("_BumpMap"));
SetKeyword(material, "ORTHONORMALIZE_TANGENT_BASE", material.HasProperty("__orthonormalize") && material.GetFloat("__orthonormalize") > 0.5f);
if (workflowMode == WorkflowMode.Specular)
{
SetKeyword(material, "_SPECGLOSSMAP", material.GetTexture("_SpecGlossMap"));
}
else if (workflowMode == WorkflowMode.Metallic)
{
SetKeyword(material, "_METALLICGLOSSMAP", material.GetTexture("_MetallicGlossMap"));
}
//SetKeyword(material, "_RIM", rimOn);
SetKeyword(material, "_RIM", material.GetFloat("_RimLevel") > 0 || material.GetColor("_RimColor").maxColorComponent > (0.1f / 255.0f));
bool shouldEmissionBeEnabled = ShouldEmissionBeEnabled(material.GetColor("_EmissionColor"));
SetKeyword(material, "_EMISSION", shouldEmissionBeEnabled);
// 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;
}
}
private static int GetGlobalIlluminationInt(MaterialGlobalIlluminationFlags flags)
{
int num = 0;
if ((flags & MaterialGlobalIlluminationFlags.RealtimeEmissive) != MaterialGlobalIlluminationFlags.None)
num = 1;
else if ((flags & MaterialGlobalIlluminationFlags.BakedEmissive) != MaterialGlobalIlluminationFlags.None)
num = 2;
return num;
}
public static SerializedPropertyTreeView.Column[] CreateEmissivesColumns(out string[] propNames)
{
SerializedPropertyTreeView.Column[] expr_07 = new SerializedPropertyTreeView.Column[4];
int arg_9B_1 = 0;
SerializedPropertyTreeView.Column column = new SerializedPropertyTreeView.Column();
column.headerContent = LightTableColumns.Styles.SelectObjects;
column.headerTextAlignment = TextAlignment.Left;
column.sortedAscending = true;
column.sortingArrowAlignment = TextAlignment.Center;
column.width = 20f;
column.minWidth = 20f;
column.maxWidth = 20f;
column.autoResize = false;
column.allowToggleVisibility = true;
column.propertyName = "m_LightmapFlags";
column.dependencyIndices = null;
column.compareDelegate = null;
column.drawDelegate = delegate(Rect r, SerializedProperty prop, SerializedProperty[] dep)
{
if (GUI.Button(r, LightTableColumns.Styles.SelectObjectsButton, "label"))
{
SearchableEditorWindow.SearchForReferencesToInstanceID(prop.serializedObject.targetObject.GetInstanceID());
}
};
expr_07[arg_9B_1] = column;
expr_07[1] = new SerializedPropertyTreeView.Column
{
headerContent = LightTableColumns.Styles.Name,
headerTextAlignment = TextAlignment.Left,
sortedAscending = true,
sortingArrowAlignment = TextAlignment.Center,
width = 200f,
minWidth = 100f,
autoResize = false,
allowToggleVisibility = true,
propertyName = null,
dependencyIndices = null,
compareDelegate = SerializedPropertyTreeView.DefaultDelegates.s_CompareName,
drawDelegate = SerializedPropertyTreeView.DefaultDelegates.s_DrawName,
filter = new SerializedPropertyFilters.Name()
};
int arg_1A6_1 = 2;
column = new SerializedPropertyTreeView.Column();
column.headerContent = LightTableColumns.Styles.GlobalIllumination;
column.headerTextAlignment = TextAlignment.Left;
column.sortedAscending = true;
column.sortingArrowAlignment = TextAlignment.Center;
column.width = 120f;
column.minWidth = 70f;
column.autoResize = false;
column.allowToggleVisibility = true;
column.propertyName = "m_LightmapFlags";
column.dependencyIndices = null;
column.compareDelegate = SerializedPropertyTreeView.DefaultDelegates.s_CompareInt;
column.drawDelegate = delegate(Rect r, SerializedProperty prop, SerializedProperty[] dep)
{
if (prop.serializedObject.targetObject.GetType().Equals(typeof(Material)))
{
using (new EditorGUI.DisabledScope(!LightTableColumns.IsEditable(prop.serializedObject.targetObject)))
{
MaterialGlobalIlluminationFlags materialGlobalIlluminationFlags = ((prop.intValue & 2) == 0) ? MaterialGlobalIlluminationFlags.RealtimeEmissive : MaterialGlobalIlluminationFlags.BakedEmissive;
int[] optionValues = new int[]
{
1,
2
};
EditorGUI.BeginChangeCheck();
materialGlobalIlluminationFlags = (MaterialGlobalIlluminationFlags)EditorGUI.IntPopup(r, (int)materialGlobalIlluminationFlags, LightTableColumns.Styles.LightmapEmissiveStrings, optionValues);
if (EditorGUI.EndChangeCheck())
{
Material material = (Material)prop.serializedObject.targetObject;
Undo.RecordObjects(new Material[]
{
material
}, "Modify GI Settings of " + material.name);
material.globalIlluminationFlags = materialGlobalIlluminationFlags;
prop.serializedObject.Update();
}
}
}
};
expr_07[arg_1A6_1] = column;
int arg_26F_1 = 3;
column = new SerializedPropertyTreeView.Column();
column.headerContent = LightTableColumns.Styles.Intensity;
column.headerTextAlignment = TextAlignment.Left;
column.sortedAscending = true;
column.sortingArrowAlignment = TextAlignment.Center;
column.width = 70f;
column.minWidth = 40f;
column.autoResize = false;
column.allowToggleVisibility = true;
column.propertyName = "m_Shader";
column.dependencyIndices = null;
column.compareDelegate = delegate(SerializedProperty lhs, SerializedProperty rhs)
{
float num;
float num2;
float num3;
Color.RGBToHSV(((Material)lhs.serializedObject.targetObject).GetColor("_EmissionColor"), out num, out num2, out num3);
float num4;
float num5;
float value;
Color.RGBToHSV(((Material)rhs.serializedObject.targetObject).GetColor("_EmissionColor"), out num4, out num5, out value);
return(num3.CompareTo(value));
};
column.drawDelegate = delegate(Rect r, SerializedProperty prop, SerializedProperty[] dep)
{
if (prop.serializedObject.targetObject.GetType().Equals(typeof(Material)))
{
using (new EditorGUI.DisabledScope(!LightTableColumns.IsEditable(prop.serializedObject.targetObject)))
{
Material material = (Material)prop.serializedObject.targetObject;
Color color = material.GetColor("_EmissionColor");
ColorPickerHDRConfig colorPickerHDRConfig = LightTableColumns.s_ColorPickerHDRConfig ?? ColorPicker.defaultHDRConfig;
EditorGUI.BeginChangeCheck();
Color value = EditorGUI.ColorBrightnessField(r, GUIContent.Temp(""), color, colorPickerHDRConfig.minBrightness, colorPickerHDRConfig.maxBrightness);
if (EditorGUI.EndChangeCheck())
{
Undo.RecordObjects(new Material[]
{
material
}, "Modify Color of " + material.name);
material.SetColor("_EmissionColor", value);
}
}
}
};
column.copyDelegate = delegate(SerializedProperty target, SerializedProperty source)
{
Material material = (Material)source.serializedObject.targetObject;
Color color = material.GetColor("_EmissionColor");
Material material2 = (Material)target.serializedObject.targetObject;
material2.SetColor("_EmissionColor", color);
};
expr_07[arg_26F_1] = column;
SerializedPropertyTreeView.Column[] columns = expr_07;
return(LightTableColumns.FinalizeColumns(columns, out propNames));
}
protected virtual LightingExplorerTableColumn[] GetEmissivesColumns()
{
return(new[]
{
new LightingExplorerTableColumn(LightingExplorerTableColumn.DataType.Custom, Styles.SelectObjects, "m_LightmapFlags", 20, (r, prop, dep) =>
{
if (GUI.Button(r, Styles.SelectObjectsButton, "label"))
{
SearchableEditorWindow.SearchForReferencesToInstanceID(prop.serializedObject.targetObject.GetInstanceID());
}
}), // 0: Icon
new LightingExplorerTableColumn(LightingExplorerTableColumn.DataType.Name, Styles.Name, null, 200), // 1: Name
new LightingExplorerTableColumn(LightingExplorerTableColumn.DataType.Int, Styles.GlobalIllumination, "m_LightmapFlags", 120, (r, prop, dep) =>
{
if (!prop.serializedObject.targetObject.GetType().Equals(typeof(Material)))
{
return;
}
using (new EditorGUI.DisabledScope(!IsEditable(prop.serializedObject.targetObject)))
{
MaterialGlobalIlluminationFlags giFlags = ((prop.intValue & (int)MaterialGlobalIlluminationFlags.BakedEmissive) != 0) ? MaterialGlobalIlluminationFlags.BakedEmissive : MaterialGlobalIlluminationFlags.RealtimeEmissive;
int[] lightmapEmissiveValues = { (int)MaterialGlobalIlluminationFlags.RealtimeEmissive, (int)MaterialGlobalIlluminationFlags.BakedEmissive };
EditorGUI.BeginProperty(r, GUIContent.none, prop);
EditorGUI.BeginChangeCheck();
giFlags = (MaterialGlobalIlluminationFlags)EditorGUI.IntPopup(r, (int)giFlags, Styles.LightmapEmissiveStrings, lightmapEmissiveValues);
if (EditorGUI.EndChangeCheck())
{
Material material = (Material)prop.serializedObject.targetObject;
material.globalIlluminationFlags = giFlags;
prop.serializedObject.Update();
}
EditorGUI.EndProperty();
}
}), // 2: GI
new LightingExplorerTableColumn(LightingExplorerTableColumn.DataType.Custom, Styles.Color, "m_Shader", 120, (r, prop, dep) =>
{
if (!prop.serializedObject.targetObject.GetType().Equals(typeof(Material)))
{
return;
}
using (new EditorGUI.DisabledScope(!IsEditable(prop.serializedObject.targetObject)))
{
Material material = (Material)prop.serializedObject.targetObject;
Color color = material.GetColor("_EmissionColor");
EditorGUI.BeginProperty(r, GUIContent.none, prop);
EditorGUI.BeginChangeCheck();
Color newValue = EditorGUI.ColorField(r, GUIContent.Temp(""), color, true, false, true);
if (EditorGUI.EndChangeCheck())
{
material.SetColor("_EmissionColor", newValue);
}
EditorGUI.EndProperty();
}
}, (lhs, rhs) =>
{
float lh, ls, lv, rh, rs, rv;
Color.RGBToHSV(((Material)lhs.serializedObject.targetObject).GetColor("_EmissionColor"), out lh, out ls, out lv);
Color.RGBToHSV(((Material)rhs.serializedObject.targetObject).GetColor("_EmissionColor"), out rh, out rs, out rv);
return lv.CompareTo(rv);
}, (target, source) =>
{
Material sourceMaterial = (Material)source.serializedObject.targetObject;
Color color = sourceMaterial.GetColor("_EmissionColor");
Material targetMaterial = (Material)target.serializedObject.targetObject;
targetMaterial.SetColor("_EmissionColor", color);
}) // 3: Color
});
}
public static SerializedPropertyTreeView.Column[] CreateEmissivesColumns(out string[] propNames)
{
var columns = new[]
{
new SerializedPropertyTreeView.Column // 0: Icon
{
headerContent = Styles.SelectObjects,
headerTextAlignment = TextAlignment.Left,
sortedAscending = true,
sortingArrowAlignment = TextAlignment.Center,
width = 20,
minWidth = 20,
maxWidth = 20,
autoResize = false,
allowToggleVisibility = true,
propertyName = "m_LightmapFlags",
dependencyIndices = null,
compareDelegate = null,
drawDelegate = (Rect r, SerializedProperty prop, SerializedProperty[] dep) =>
{
if (GUI.Button(r, Styles.SelectObjectsButton, "label"))
{
SearchableEditorWindow.SearchForReferencesToInstanceID(prop.serializedObject.targetObject.GetInstanceID());
}
}
},
new SerializedPropertyTreeView.Column // 1: Name
{
headerContent = Styles.Name,
headerTextAlignment = TextAlignment.Left,
sortedAscending = true,
sortingArrowAlignment = TextAlignment.Center,
width = 200,
minWidth = 100,
autoResize = false,
allowToggleVisibility = true,
propertyName = null,
dependencyIndices = null,
compareDelegate = SerializedPropertyTreeView.DefaultDelegates.s_CompareName,
drawDelegate = SerializedPropertyTreeView.DefaultDelegates.s_DrawName,
filter = new SerializedPropertyFilters.Name()
},
new SerializedPropertyTreeView.Column // 2: GI
{
headerContent = Styles.GlobalIllumination,
headerTextAlignment = TextAlignment.Left,
sortedAscending = true,
sortingArrowAlignment = TextAlignment.Center,
width = 120,
minWidth = 70,
autoResize = false,
allowToggleVisibility = true,
propertyName = "m_LightmapFlags",
dependencyIndices = null,
compareDelegate = SerializedPropertyTreeView.DefaultDelegates.s_CompareInt,
drawDelegate = (Rect r, SerializedProperty prop, SerializedProperty[] dep) =>
{
if (!prop.serializedObject.targetObject.GetType().Equals(typeof(Material)))
{
return;
}
using (new EditorGUI.DisabledScope(!IsEditable(prop.serializedObject.targetObject)))
{
MaterialGlobalIlluminationFlags giFlags = ((prop.intValue & (int)MaterialGlobalIlluminationFlags.BakedEmissive) != 0) ? MaterialGlobalIlluminationFlags.BakedEmissive : MaterialGlobalIlluminationFlags.RealtimeEmissive;
int[] lightmapEmissiveValues = { (int)MaterialGlobalIlluminationFlags.RealtimeEmissive, (int)MaterialGlobalIlluminationFlags.BakedEmissive };
EditorGUI.BeginChangeCheck();
giFlags = (MaterialGlobalIlluminationFlags)EditorGUI.IntPopup(r, (int)giFlags, Styles.LightmapEmissiveStrings, lightmapEmissiveValues);
if (EditorGUI.EndChangeCheck())
{
Material material = (Material)prop.serializedObject.targetObject;
Undo.RecordObjects(new Material[] { material }, "Modify GI Settings of " + material.name);
material.globalIlluminationFlags = giFlags;
prop.serializedObject.Update();
}
}
}
},
new SerializedPropertyTreeView.Column // 3: Color
{
headerContent = Styles.Color,
headerTextAlignment = TextAlignment.Left,
sortedAscending = true,
sortingArrowAlignment = TextAlignment.Center,
width = 70,
minWidth = 40,
autoResize = false,
allowToggleVisibility = true,
propertyName = "m_Shader",
dependencyIndices = null,
compareDelegate = (SerializedProperty lhs, SerializedProperty rhs) =>
{
float lh, ls, lv, rh, rs, rv;
Color.RGBToHSV(((Material)lhs.serializedObject.targetObject).GetColor("_EmissionColor"), out lh, out ls, out lv);
Color.RGBToHSV(((Material)rhs.serializedObject.targetObject).GetColor("_EmissionColor"), out rh, out rs, out rv);
return(lv.CompareTo(rv));
},
drawDelegate = (Rect r, SerializedProperty prop, SerializedProperty[] dep) =>
{
if (!prop.serializedObject.targetObject.GetType().Equals(typeof(Material)))
{
return;
}
using (new EditorGUI.DisabledScope(!IsEditable(prop.serializedObject.targetObject)))
{
Material material = (Material)prop.serializedObject.targetObject;
Color color = material.GetColor("_EmissionColor");
EditorGUI.BeginChangeCheck();
Color newValue = EditorGUI.ColorField(r, GUIContent.Temp(""), color, true, false, true);
if (EditorGUI.EndChangeCheck())
{
Undo.RecordObjects(new Material[] { material }, "Modify Emission Color of " + material.name);
material.SetColor("_EmissionColor", newValue);
}
}
},
copyDelegate = (SerializedProperty target, SerializedProperty source) =>
{
Material sourceMaterial = (Material)source.serializedObject.targetObject;
Color color = sourceMaterial.GetColor("_EmissionColor");
Material targetMaterial = (Material)target.serializedObject.targetObject;
targetMaterial.SetColor("_EmissionColor", color);
}
}
};
return(FinalizeColumns(columns, out propNames));
}
private static int GetGlobalIlluminationInt(MaterialGlobalIlluminationFlags flags)
{
int result = 0;
if ((flags & MaterialGlobalIlluminationFlags.RealtimeEmissive) != MaterialGlobalIlluminationFlags.None)
{
result = 1;
}
else
{
if ((flags & MaterialGlobalIlluminationFlags.BakedEmissive) != MaterialGlobalIlluminationFlags.None)
{
result = 2;
}
}
return result;
}
