public override void OnGUI(Rect position, SerializedProperty prop, GUIContent content)
{
var att = (ShaderPropertyPopupAttribute)attribute;
var directable = prop.serializedObject.targetObject as IDirectable;
if (directable != null)
{
var actor = directable.actor;
if (actor != null)
{
var renderer = actor.GetComponent <Renderer>();
if (renderer != null)
{
var material = renderer.sharedMaterial;
if (material != null)
{
var shader = material.shader;
var options = new List <string>();
for (var i = 0; i < ShaderUtil.GetPropertyCount(shader); i++)
{
if (ShaderUtil.IsShaderPropertyHidden(shader, i))
{
continue;
}
if (att.propertyType != null)
{
var type = ShaderUtil.GetPropertyType(shader, i);
if (att.propertyType == typeof(Color) && type != ShaderUtil.ShaderPropertyType.Color)
{
continue;
}
if (att.propertyType == typeof(Texture) && type != ShaderUtil.ShaderPropertyType.TexEnv)
{
continue;
}
if (att.propertyType == typeof(float) && type != ShaderUtil.ShaderPropertyType.Float && type != ShaderUtil.ShaderPropertyType.Range)
{
continue;
}
if ((att.propertyType == typeof(Vector2) || att.propertyType == typeof(Vector4)) && type != ShaderUtil.ShaderPropertyType.Vector)
{
continue;
}
}
options.Add(ShaderUtil.GetPropertyName(shader, i));
}
prop.stringValue = EditorTools.CleanPopup <string>(content.text, prop.stringValue, options);
return;
}
}
}
}
prop.stringValue = EditorGUILayout.TextField(content.text, prop.stringValue);
}
private static MaterialPropertyHandler GetShaderPropertyHandler(Shader shader, string name)
{
string[] attribs = ShaderUtil.GetShaderPropertyAttributes(shader, name);
if (attribs == null || attribs.Length == 0)
{
return(null);
}
var handler = new MaterialPropertyHandler();
foreach (var attr in attribs)
{
bool isDecorator;
MaterialPropertyDrawer drawer = GetShaderPropertyDrawer(attr, out isDecorator);
if (drawer != null)
{
if (isDecorator)
{
if (handler.m_DecoratorDrawers == null)
{
handler.m_DecoratorDrawers = new List <MaterialPropertyDrawer>();
}
handler.m_DecoratorDrawers.Add(drawer);
}
else
{
if (handler.m_PropertyDrawer != null)
{
Debug.LogWarning(string.Format("Shader property {0} already has a property drawer", name), shader);
}
handler.m_PropertyDrawer = drawer;
}
}
}
return(handler);
}
private static int GetMaterialPropertyPopupHash(UnityEngine.Object[] objects)
{
int num = 0;
for (int i = 0; i < objects.Length; i++)
{
VideoPlayer videoPlayer = (VideoPlayer)objects[i];
if (videoPlayer)
{
Renderer targetRenderer = VideoPlayerEditor.GetTargetRenderer(videoPlayer);
if (targetRenderer)
{
num ^= videoPlayer.targetMaterialProperty.GetHashCode();
Material[] sharedMaterials = targetRenderer.sharedMaterials;
for (int j = 0; j < sharedMaterials.Length; j++)
{
Material material = sharedMaterials[j];
if (material)
{
num ^= material.name.GetHashCode();
int k = 0;
int propertyCount = ShaderUtil.GetPropertyCount(material.shader);
while (k < propertyCount)
{
if (ShaderUtil.GetPropertyType(material.shader, k) == ShaderUtil.ShaderPropertyType.TexEnv)
{
num ^= ShaderUtil.GetPropertyName(material.shader, k).GetHashCode();
}
k++;
}
}
}
}
}
}
return(num);
}
private static MaterialPropertyHandler GetShaderPropertyHandler(Shader shader, string name)
{
string[] shaderPropertyAttributes = ShaderUtil.GetShaderPropertyAttributes(shader, name);
if (shaderPropertyAttributes == null || shaderPropertyAttributes.Length == 0)
{
return(null);
}
MaterialPropertyHandler materialPropertyHandler = new MaterialPropertyHandler();
string[] array = shaderPropertyAttributes;
for (int i = 0; i < array.Length; i++)
{
string attrib = array[i];
bool flag;
MaterialPropertyDrawer shaderPropertyDrawer = MaterialPropertyHandler.GetShaderPropertyDrawer(attrib, out flag);
if (shaderPropertyDrawer != null)
{
if (flag)
{
if (materialPropertyHandler.m_DecoratorDrawers == null)
{
materialPropertyHandler.m_DecoratorDrawers = new List <MaterialPropertyDrawer>();
}
materialPropertyHandler.m_DecoratorDrawers.Add(shaderPropertyDrawer);
}
else
{
if (materialPropertyHandler.m_PropertyDrawer != null)
{
Debug.LogWarning(string.Format("Shader property {0} already has a property drawer", name), shader);
}
materialPropertyHandler.m_PropertyDrawer = shaderPropertyDrawer;
}
}
}
return(materialPropertyHandler);
}
private void ShaderPreloadGUI()
{
EditorGUILayout.Space();
GUILayout.Label(GraphicsSettingsInspector.Styles.shaderPreloadSettings, EditorStyles.boldLabel, new GUILayoutOption[0]);
EditorGUILayout.PropertyField(this.m_PreloadedShaders, true, new GUILayoutOption[0]);
EditorGUILayout.Space();
GUILayout.Label(string.Format("Currently tracked: {0} shaders {1} total variants", (object)ShaderUtil.GetCurrentShaderVariantCollectionShaderCount(), (object)ShaderUtil.GetCurrentShaderVariantCollectionVariantCount()));
EditorGUILayout.BeginHorizontal();
GUILayout.FlexibleSpace();
if (GUILayout.Button(GraphicsSettingsInspector.Styles.shaderPreloadSave, EditorStyles.miniButton, new GUILayoutOption[0]))
{
string path = EditorUtility.SaveFilePanelInProject("Save Shader Variant Collection", "NewShaderVariants", "shadervariants", "Save shader variant collection", ProjectWindowUtil.GetActiveFolderPath());
if (!string.IsNullOrEmpty(path))
{
ShaderUtil.SaveCurrentShaderVariantCollection(path);
}
GUIUtility.ExitGUI();
}
if (GUILayout.Button(GraphicsSettingsInspector.Styles.shaderPreloadClear, EditorStyles.miniButton, new GUILayoutOption[0]))
{
ShaderUtil.ClearCurrentShaderVariantCollection();
}
EditorGUILayout.EndHorizontal();
}
public override void OnInspectorGUI()
{
base.serializedObject.Update();
bool flag = false;
bool flag2 = false;
GUILayout.Label(GraphicsSettingsInspector.Styles.builtinSettings, EditorStyles.boldLabel, new GUILayoutOption[0]);
this.m_Deferred.DoGUI();
EditorGUI.BeginChangeCheck();
this.m_DeferredReflections.DoGUI();
if (EditorGUI.EndChangeCheck())
{
ShaderUtil.ReloadAllShaders();
}
this.m_ScreenSpaceShadows.DoGUI();
this.m_LegacyDeferred.DoGUI();
this.m_DepthNormals.DoGUI();
this.m_MotionVectors.DoGUI();
this.m_LightHalo.DoGUI();
this.m_LensFlare.DoGUI();
EditorGUILayout.PropertyField(this.m_AlwaysIncludedShaders, true, new GUILayoutOption[0]);
EditorGUILayout.Space();
GUILayout.Label(GraphicsSettingsInspector.Styles.shaderStrippingSettings, EditorStyles.boldLabel, new GUILayoutOption[0]);
this.LightmapStrippingGUI(out flag);
this.FogStrippingGUI(out flag2);
this.ShaderPreloadGUI();
base.serializedObject.ApplyModifiedProperties();
if (flag)
{
ShaderUtil.CalculateLightmapStrippingFromCurrentScene();
}
if (flag2)
{
ShaderUtil.CalculateFogStrippingFromCurrentScene();
}
}
public override void OnInspectorGUI()
{
serializedObject.Update();
// Evaluate displayMaterialWarning before drawing properties to avoid mismatched layout group
bool displayMaterialWarning = false;
if (!m_Materials.hasMultipleDifferentValues)
{
MeshFilter mf = ((MeshRenderer)serializedObject.targetObject).GetComponent <MeshFilter>();
displayMaterialWarning = mf != null && mf.sharedMesh != null && m_Materials.arraySize > mf.sharedMesh.subMeshCount;
}
DrawMaterials();
if (!m_Materials.hasMultipleDifferentValues && displayMaterialWarning)
{
EditorGUILayout.HelpBox(Styles.materialWarning.text, MessageType.Warning, true);
}
if (ShaderUtil.MaterialsUseInstancingShader(m_Materials))
{
m_GameObjectsSerializedObject.Update();
if (!m_GameObjectStaticFlags.hasMultipleDifferentValues && ((StaticEditorFlags)m_GameObjectStaticFlags.intValue & StaticEditorFlags.BatchingStatic) != 0)
{
EditorGUILayout.HelpBox(Styles.staticBatchingWarning.text, MessageType.Warning, true);
}
}
LightingSettingsGUI(true);
RayTracingSettingsGUI();
OtherSettingsGUI(true, false, false);
serializedObject.ApplyModifiedProperties();
}
private void DisplayAddVariantsWindow(Shader shader, ShaderVariantCollection collection)
{
string[] strArray;
AddShaderVariantWindow.PopupData data = new AddShaderVariantWindow.PopupData {
shader = shader,
collection = collection
};
ShaderUtil.GetShaderVariantEntries(shader, collection, out data.types, out strArray);
if (strArray.Length == 0)
{
EditorApplication.Beep();
}
else
{
data.keywords = new string[strArray.Length][];
for (int i = 0; i < strArray.Length; i++)
{
char[] separator = new char[] { ' ' };
data.keywords[i] = strArray[i].Split(separator);
}
AddShaderVariantWindow.ShowAddVariantWindow(data);
GUIUtility.ExitGUI();
}
}
private static List <ComputeShaderInspector.KernelInfo> GetKernelDisplayInfo(ComputeShader cs)
{
List <ComputeShaderInspector.KernelInfo> list = new List <ComputeShaderInspector.KernelInfo>();
int computeShaderPlatformCount = ShaderUtil.GetComputeShaderPlatformCount(cs);
for (int i = 0; i < computeShaderPlatformCount; i++)
{
GraphicsDeviceType computeShaderPlatformType = ShaderUtil.GetComputeShaderPlatformType(cs, i);
int computeShaderPlatformKernelCount = ShaderUtil.GetComputeShaderPlatformKernelCount(cs, i);
for (int j = 0; j < computeShaderPlatformKernelCount; j++)
{
string computeShaderPlatformKernelName = ShaderUtil.GetComputeShaderPlatformKernelName(cs, i, j);
bool flag = false;
foreach (ComputeShaderInspector.KernelInfo current in list)
{
if (current.name == computeShaderPlatformKernelName)
{
ComputeShaderInspector.KernelInfo expr_6C = current;
expr_6C.platforms += ' ';
ComputeShaderInspector.KernelInfo expr_85 = current;
expr_85.platforms += computeShaderPlatformType.ToString();
flag = true;
}
}
if (!flag)
{
list.Add(new ComputeShaderInspector.KernelInfo
{
name = computeShaderPlatformKernelName,
platforms = computeShaderPlatformType.ToString()
});
}
}
}
return(list);
}
public override void OnInspectorGUI()
{
serializedObject.Update();
m_Deferred.DoGUI();
// deferred reflections being off affects forward vs deferred style probe rendering;
// need to reload shaders for new platform macro to live update
EditorGUI.BeginChangeCheck();
m_DeferredReflections.DoGUI();
if (EditorGUI.EndChangeCheck())
{
ShaderUtil.ReloadAllShaders();
}
m_LegacyDeferred.DoGUI();
m_ScreenSpaceShadows.DoGUI();
m_DepthNormals.DoGUI();
m_MotionVectors.DoGUI();
m_LightHalo.DoGUI();
m_LensFlare.DoGUI();
serializedObject.ApplyModifiedProperties();
}
internal static bool MaterialsUseInstancingShader(SerializedProperty materialsArray)
{
bool result;
if (materialsArray.hasMultipleDifferentValues)
{
result = false;
}
else
{
for (int i = 0; i < materialsArray.arraySize; i++)
{
Material material = materialsArray.GetArrayElementAtIndex(i).objectReferenceValue as Material;
if (material != null && material.enableInstancing && material.shader != null && ShaderUtil.HasInstancing(material.shader))
{
result = true;
return(result);
}
}
result = false;
}
return(result);
}
public void ReadFromMaterialPropertyBlock(MaterialPropertyBlock block)
{
ShaderUtil.ApplyMaterialPropertyBlockToMaterialProperty(block, this);
}
public void WriteToMaterialPropertyBlock(MaterialPropertyBlock materialblock, int changedPropertyMask)
{
ShaderUtil.ApplyMaterialPropertyToMaterialPropertyBlock(this, changedPropertyMask, materialblock);
}
public static Texture2D Render(GameObject prefab)
{
if (prefab == null)
{
return(null);
}
if (prefab.GetComponent <Renderer>() == null)
{
return(null);
}
Texture2D textured2 = new Texture2D(0x40, 0x40)
{
hideFlags = HideFlags.HideAndDontSave,
name = "Preview Texture"
};
RenderTexture temporary = RenderTexture.GetTemporary(textured2.width, textured2.height);
GameObject obj2 = new GameObject("Preview")
{
hideFlags = HideFlags.HideAndDontSave
};
Camera camera = obj2.AddComponent(typeof(Camera)) as Camera;
camera.cameraType = CameraType.Preview;
camera.clearFlags = CameraClearFlags.Color;
camera.backgroundColor = new Color(0.5f, 0.5f, 0.5f, 0f);
camera.cullingMask = 0;
camera.enabled = false;
camera.targetTexture = temporary;
Light light = obj2.AddComponent(typeof(Light)) as Light;
light.type = LightType.Directional;
Bounds bounds = CalculateVisibleBounds(prefab);
Vector3 vector = new Vector3(0.7f, 0.3f, 0.7f);
float num = bounds.extents.magnitude * 1.6f;
obj2.transform.position = bounds.center + ((Vector3)(vector.normalized * num));
obj2.transform.LookAt(bounds.center);
camera.nearClipPlane = num * 0.1f;
camera.farClipPlane = num * 2.2f;
Camera current = Camera.current;
camera.RenderDontRestore();
Light[] lights = new Light[] { light };
Graphics.SetupVertexLights(lights);
Component[] componentsInChildren = prefab.GetComponentsInChildren(typeof(Renderer));
foreach (Renderer renderer in componentsInChildren)
{
if (renderer.enabled)
{
Material[] sharedMaterials = renderer.sharedMaterials;
for (int i = 0; i < sharedMaterials.Length; i++)
{
if (sharedMaterials[i] != null)
{
Material original = sharedMaterials[i];
string dependency = ShaderUtil.GetDependency(original.shader, "BillboardShader");
if ((dependency != null) && (dependency != ""))
{
original = UnityEngine.Object.Instantiate <Material>(original);
original.shader = Shader.Find(dependency);
original.hideFlags = HideFlags.HideAndDontSave;
}
for (int j = 0; j < original.passCount; j++)
{
if (original.SetPass(j))
{
renderer.RenderNow(i);
}
}
if (original != sharedMaterials[i])
{
UnityEngine.Object.DestroyImmediate(original);
}
}
}
}
}
textured2.ReadPixels(new Rect(0f, 0f, (float)textured2.width, (float)textured2.height), 0, 0);
RenderTexture.ReleaseTemporary(temporary);
UnityEngine.Object.DestroyImmediate(obj2);
Camera.SetupCurrent(current);
return(textured2);
}
public override void OnInspectorGUI()
{
serializedObject.Update();
serializedObject.ApplyModifiedProperties();
EditorGUILayout.PropertyField(m_PreloadedShaders, true);
EditorGUILayout.Space();
GUILayout.Label(
string.Format("Currently tracked: {0} shaders {1} total variants",
ShaderUtil.GetCurrentShaderVariantCollectionShaderCount(), ShaderUtil.GetCurrentShaderVariantCollectionVariantCount()
)
);
EditorGUILayout.BeginHorizontal();
GUILayout.FlexibleSpace();
if (GUILayout.Button(Styles.shaderPreloadSave, EditorStyles.miniButton))
{
string message = "Save shader variant collection";
string assetPath = EditorUtility.SaveFilePanelInProject("Save Shader Variant Collection", "NewShaderVariants", "shadervariants", message, ProjectWindowUtil.GetActiveFolderPath());
if (!string.IsNullOrEmpty(assetPath))
{
ShaderUtil.SaveCurrentShaderVariantCollection(assetPath);
}
GUIUtility.ExitGUI();
}
if (GUILayout.Button(Styles.shaderPreloadClear, EditorStyles.miniButton))
{
ShaderUtil.ClearCurrentShaderVariantCollection();
}
EditorGUILayout.EndHorizontal();
serializedObject.ApplyModifiedProperties();
}
public virtual void OnEnable()
{
Shader target = this.target as Shader;
ShaderUtil.FetchCachedErrors(target);
}
// Compiled shader code button+dropdown
private void ShowCompiledCodeButton(Shader s)
{
EditorGUILayout.BeginHorizontal();
EditorGUILayout.PrefixLabel("Compiled code", EditorStyles.miniButton);
var hasCode = ShaderUtil.HasShaderSnippets(s) || ShaderUtil.HasSurfaceShaders(s) || ShaderUtil.HasFixedFunctionShaders(s);
if (hasCode)
{
// button with a drop-down part on the right
var modeContent = Styles.showCurrent;
var modeRect = GUILayoutUtility.GetRect(modeContent, EditorStyles.miniButton, GUILayout.ExpandWidth(false));
var modeDropRect = new Rect(modeRect.xMax - 16, modeRect.y, 16, modeRect.height);
if (EditorGUI.DropdownButton(modeDropRect, GUIContent.none, FocusType.Passive, GUIStyle.none))
{
Rect rect = GUILayoutUtility.topLevel.GetLast();
PopupWindow.Show(rect, new ShaderInspectorPlatformsPopup(s));
GUIUtility.ExitGUI();
}
if (GUI.Button(modeRect, modeContent, EditorStyles.miniButton))
{
ShaderUtil.OpenCompiledShader(s, ShaderInspectorPlatformsPopup.currentMode, ShaderInspectorPlatformsPopup.currentPlatformMask, ShaderInspectorPlatformsPopup.currentVariantStripping == 0);
GUIUtility.ExitGUI();
}
}
else
{
// Note: PrefixLabel is sometimes buggy if followed by a non-control (like Label).
// We just want to show a label here, but have to pretend it's a button so it is treated like
// a control.
GUILayout.Button("none (precompiled shader)", GUI.skin.label);
}
EditorGUILayout.EndHorizontal();
}
public override void OnInspectorGUI()
{
var s = target as Shader;
if (s == null)
{
return;
}
GUI.enabled = true;
EditorGUI.indentLevel = 0;
ShowShaderCodeArea(s);
if (s.isSupported)
{
EditorGUILayout.LabelField("Cast shadows", (ShaderUtil.HasShadowCasterPass(s)) ? "yes" : "no");
EditorGUILayout.LabelField("Render queue", ShaderUtil.GetRenderQueue(s).ToString(CultureInfo.InvariantCulture));
EditorGUILayout.LabelField("LOD", ShaderUtil.GetLOD(s).ToString(CultureInfo.InvariantCulture));
EditorGUILayout.LabelField("Ignore projector", ShaderUtil.DoesIgnoreProjector(s) ? "yes" : "no");
string disableBatchingString;
switch (s.disableBatching)
{
case DisableBatchingType.False:
disableBatchingString = "no";
break;
case DisableBatchingType.True:
disableBatchingString = "yes";
break;
case DisableBatchingType.WhenLODFading:
disableBatchingString = "when LOD fading is on";
break;
default:
disableBatchingString = "unknown";
break;
}
EditorGUILayout.LabelField("Disable batching", disableBatchingString);
ShowKeywords(s);
// If any SRP is active, then display the SRP Batcher compatibility status
if (RenderPipelineManager.currentPipeline != null)
{
// NOTE: Force the shader compilation to ensure GetSRPBatcherCompatibilityCode will be up to date
srpCompatibilityCheckMaterial.SetPass(0);
int subShader = ShaderUtil.GetShaderActiveSubshaderIndex(s);
int SRPErrCode = ShaderUtil.GetSRPBatcherCompatibilityCode(s, subShader);
string result = (0 == SRPErrCode) ? "compatible" : "not compatible";
EditorGUILayout.LabelField("SRP Batcher", result);
if (SRPErrCode != 0)
{
EditorGUILayout.HelpBox(ShaderUtil.GetSRPBatcherCompatibilityIssueReason(s, subShader, SRPErrCode), MessageType.Info);
}
}
ShowShaderProperties(s);
}
}
private static void TextureProperty(string propertyName, string label, ShaderUtil.ShaderPropertyTexDim desiredTexdim)
{
GUILayout.BeginHorizontal();
GUILayout.Label(label + " |TP " + propertyName, GUILayout.Width(_LABEL_WIDTH));
GUILayout.Space(3);
switch (propertyName)
{
case "_MainTex":
KP.Mtexture_a = ((Texture2D)EditorGUILayout.ObjectField(KP.Mtexture_a, typeof(Texture2D), true));
KP._sMaterial.SetTexture(propertyName, KP.Mtexture_a);
break;
case "_BumpMap":
case "_DecalTex":
case "_Detail":
case "_Illum":
KP.Mtexture_b = ((Texture2D)EditorGUILayout.ObjectField(KP.Mtexture_b, typeof(Texture2D), true));
KP._sMaterial.SetTexture(propertyName, KP.Mtexture_b);
break;
case "_ParallaxMap":
KP.Mtexture_c = ((Texture2D)EditorGUILayout.ObjectField(KP.Mtexture_c, typeof(Texture2D), true));
KP._sMaterial.SetTexture(propertyName, KP.Mtexture_c);
break;
}
GUILayout.EndHorizontal();
}
public static Texture2D Render(GameObject prefab)
{
if (prefab == null)
{
return(null);
}
if (prefab.GetComponent <Renderer>() == null)
{
return(null);
}
EditorUtility.SetTemporarilyAllowIndieRenderTexture(true);
Texture2D texture2D = new Texture2D(64, 64);
texture2D.hideFlags = HideFlags.HideAndDontSave;
texture2D.name = "Preview Texture";
RenderTexture temporary = RenderTexture.GetTemporary(texture2D.width, texture2D.height);
GameObject gameObject = new GameObject("Preview");
gameObject.hideFlags = HideFlags.HideAndDontSave;
Camera camera = gameObject.AddComponent(typeof(Camera)) as Camera;
camera.clearFlags = CameraClearFlags.Color;
camera.backgroundColor = new Color(0.5f, 0.5f, 0.5f, 0f);
camera.cullingMask = 0;
camera.enabled = false;
camera.targetTexture = temporary;
Light light = gameObject.AddComponent(typeof(Light)) as Light;
light.type = LightType.Directional;
Bounds bounds = RenderThumbnailUtility.CalculateVisibleBounds(prefab);
Vector3 vector = new Vector3(0.7f, 0.3f, 0.7f);
float num = bounds.extents.magnitude * 1.6f;
gameObject.transform.position = bounds.center + vector.normalized * num;
gameObject.transform.LookAt(bounds.center);
camera.nearClipPlane = num * 0.1f;
camera.farClipPlane = num * 2.2f;
Camera current = Camera.current;
camera.RenderDontRestore();
Light[] lights = new Light[]
{
light
};
Graphics.SetupVertexLights(lights);
Component[] componentsInChildren = prefab.GetComponentsInChildren(typeof(Renderer));
Component[] array = componentsInChildren;
for (int i = 0; i < array.Length; i++)
{
Renderer renderer = (Renderer)array[i];
if (renderer.enabled)
{
Material[] sharedMaterials = renderer.sharedMaterials;
for (int j = 0; j < sharedMaterials.Length; j++)
{
if (!(sharedMaterials[j] == null))
{
Material material = sharedMaterials[j];
string dependency = ShaderUtil.GetDependency(material.shader, "BillboardShader");
if (dependency != null && dependency != string.Empty)
{
material = UnityEngine.Object.Instantiate <Material>(material);
material.shader = Shader.Find(dependency);
material.hideFlags = HideFlags.HideAndDontSave;
}
for (int k = 0; k < material.passCount; k++)
{
if (material.SetPass(k))
{
renderer.RenderNow(j);
}
}
if (material != sharedMaterials[j])
{
UnityEngine.Object.DestroyImmediate(material);
}
}
}
}
}
texture2D.ReadPixels(new Rect(0f, 0f, (float)texture2D.width, (float)texture2D.height), 0, 0);
RenderTexture.ReleaseTemporary(temporary);
UnityEngine.Object.DestroyImmediate(gameObject);
Camera.SetupCurrent(current);
EditorUtility.SetTemporarilyAllowIndieRenderTexture(false);
return(texture2D);
}
public Texture TextureProperty(string propertyName, string label, ShaderUtil.ShaderPropertyTexDim texDim)
{
MaterialProperty materialProperty = MaterialEditor.GetMaterialProperty(base.targets, propertyName);
return this.TextureProperty(materialProperty, label);
}
public Texture TextureProperty(string propertyName, string label, ShaderUtil.ShaderPropertyTexDim texDim, bool scaleOffset)
{
return this.TextureProperty(MaterialEditor.GetMaterialProperty(this.targets, propertyName), label, scaleOffset);
}
private bool IsMaterialUsingFixedFunction()
{
Material sharedMaterial = (this.target as SpriteRenderer).sharedMaterial;
return(!(sharedMaterial == null) && ShaderUtil.DoesShaderContainFixedFunctionPasses(sharedMaterial.shader));
}
public virtual void OnEnable()
{
Shader s = base.target as Shader;
ShaderUtil.FetchCachedErrors(s);
}
internal static MaterialProperty GetMaterialProperty(UnityEngine.Object[] mats, int propertyIndex)
{
return(ShaderUtil.GetMaterialProperty_Index(mats, propertyIndex));
}
public override void OnInspectorGUI()
{
base.serializedObject.Update();
bool flag = false;
bool flag2 = false;
EditorGUILayout.PropertyField(this.m_LightmapStripping, GraphicsSettingsWindow.ShaderStrippingEditor.Styles.lightmapModes, new GUILayoutOption[0]);
if (this.m_LightmapStripping.intValue != 0)
{
EditorGUI.indentLevel++;
EditorGUILayout.PropertyField(this.m_LightmapKeepPlain, GraphicsSettingsWindow.ShaderStrippingEditor.Styles.lightmapPlain, new GUILayoutOption[0]);
EditorGUILayout.PropertyField(this.m_LightmapKeepDirCombined, GraphicsSettingsWindow.ShaderStrippingEditor.Styles.lightmapDirCombined, new GUILayoutOption[0]);
EditorGUILayout.PropertyField(this.m_LightmapKeepDynamicPlain, GraphicsSettingsWindow.ShaderStrippingEditor.Styles.lightmapDynamicPlain, new GUILayoutOption[0]);
EditorGUILayout.PropertyField(this.m_LightmapKeepDynamicDirCombined, GraphicsSettingsWindow.ShaderStrippingEditor.Styles.lightmapDynamicDirCombined, new GUILayoutOption[0]);
EditorGUILayout.PropertyField(this.m_LightmapKeepShadowMask, GraphicsSettingsWindow.ShaderStrippingEditor.Styles.lightmapKeepShadowMask, new GUILayoutOption[0]);
EditorGUILayout.PropertyField(this.m_LightmapKeepSubtractive, GraphicsSettingsWindow.ShaderStrippingEditor.Styles.lightmapKeepSubtractive, new GUILayoutOption[0]);
EditorGUILayout.Space();
EditorGUILayout.BeginHorizontal(new GUILayoutOption[0]);
EditorGUILayout.PrefixLabel(GUIContent.Temp(" "), EditorStyles.miniButton);
if (GUILayout.Button(GraphicsSettingsWindow.ShaderStrippingEditor.Styles.lightmapFromScene, EditorStyles.miniButton, new GUILayoutOption[]
{
GUILayout.ExpandWidth(false)
}))
{
flag = true;
}
EditorGUILayout.EndHorizontal();
EditorGUI.indentLevel--;
EditorGUILayout.Space();
}
EditorGUILayout.PropertyField(this.m_FogStripping, GraphicsSettingsWindow.ShaderStrippingEditor.Styles.fogModes, new GUILayoutOption[0]);
if (this.m_FogStripping.intValue != 0)
{
EditorGUI.indentLevel++;
EditorGUILayout.PropertyField(this.m_FogKeepLinear, GraphicsSettingsWindow.ShaderStrippingEditor.Styles.fogLinear, new GUILayoutOption[0]);
EditorGUILayout.PropertyField(this.m_FogKeepExp, GraphicsSettingsWindow.ShaderStrippingEditor.Styles.fogExp, new GUILayoutOption[0]);
EditorGUILayout.PropertyField(this.m_FogKeepExp2, GraphicsSettingsWindow.ShaderStrippingEditor.Styles.fogExp2, new GUILayoutOption[0]);
EditorGUILayout.Space();
EditorGUILayout.BeginHorizontal(new GUILayoutOption[0]);
EditorGUILayout.PrefixLabel(GUIContent.Temp(" "), EditorStyles.miniButton);
if (GUILayout.Button(GraphicsSettingsWindow.ShaderStrippingEditor.Styles.fogFromScene, EditorStyles.miniButton, new GUILayoutOption[]
{
GUILayout.ExpandWidth(false)
}))
{
flag2 = true;
}
EditorGUILayout.EndHorizontal();
EditorGUI.indentLevel--;
EditorGUILayout.Space();
}
EditorGUILayout.PropertyField(this.m_InstancingStripping, GraphicsSettingsWindow.ShaderStrippingEditor.Styles.instancingVariants, new GUILayoutOption[0]);
base.serializedObject.ApplyModifiedProperties();
if (flag)
{
ShaderUtil.CalculateLightmapStrippingFromCurrentScene();
}
if (flag2)
{
ShaderUtil.CalculateFogStrippingFromCurrentScene();
}
}
// shared by compute shader inspector too
internal static void ShaderErrorListUI(Object shader, ShaderMessage[] messages, ref Vector2 scrollPosition)
{
int n = messages.Length;
GUILayout.Space(kSpace);
GUILayout.Label(string.Format("Errors ({0}):", n), EditorStyles.boldLabel);
int errorListID = GUIUtility.GetControlID(kErrorViewHash, FocusType.Passive);
float height = Mathf.Min(n * 20f + 40f, 150f);
scrollPosition = GUILayout.BeginScrollView(scrollPosition, GUISkin.current.box, GUILayout.MinHeight(height));
EditorGUIUtility.SetIconSize(new Vector2(16.0f, 16.0f));
float lineHeight = Styles.messageStyle.CalcHeight(EditorGUIUtility.TempContent(Styles.errorIcon), 100);
Event e = Event.current;
for (int i = 0; i < n; ++i)
{
Rect r = EditorGUILayout.GetControlRect(false, lineHeight);
string err = messages[i].message;
string plat = messages[i].platform.ToString();
bool warn = messages[i].severity != ShaderCompilerMessageSeverity.Error;
string fileName = FileUtil.GetLastPathNameComponent(messages[i].file);
int line = messages[i].line;
// Double click opens shader file at error line
if (e.type == EventType.MouseDown && e.button == 0 && r.Contains(e.mousePosition))
{
GUIUtility.keyboardControl = errorListID;
if (e.clickCount == 2)
{
string filePath = messages[i].file;
Object asset = string.IsNullOrEmpty(filePath) ? null : AssetDatabase.LoadMainAssetAtPath(filePath);
// if we don't have an asset and the filePath is an absolute path, it's an error in a system
// cginc - open that instead
if (asset == null && System.IO.Path.IsPathRooted(filePath))
{
ShaderUtil.OpenSystemShaderIncludeError(filePath, line);
}
else
{
AssetDatabase.OpenAsset(asset ?? shader, line);
}
GUIUtility.ExitGUI();
}
e.Use();
}
// Context menu, "Copy"
if (e.type == EventType.ContextClick && r.Contains(e.mousePosition))
{
e.Use();
var menu = new GenericMenu();
// need to copy current value to be used in delegate
// (C# closures close over variables, not their values)
var errorIndex = i;
menu.AddItem(EditorGUIUtility.TrTextContent("Copy error text"), false, delegate {
string errMsg = messages[errorIndex].message;
if (!string.IsNullOrEmpty(messages[errorIndex].messageDetails))
{
errMsg += '\n';
errMsg += messages[errorIndex].messageDetails;
}
EditorGUIUtility.systemCopyBuffer = errMsg;
});
menu.ShowAsContext();
}
// background
if (e.type == EventType.Repaint)
{
if ((i & 1) == 0)
{
GUIStyle st = Styles.evenBackground;
st.Draw(r, false, false, false, false);
}
}
// error location on the right side
Rect locRect = r;
locRect.xMin = locRect.xMax;
if (line > 0)
{
GUIContent gc;
if (string.IsNullOrEmpty(fileName))
{
gc = EditorGUIUtility.TempContent(line.ToString(CultureInfo.InvariantCulture));
}
else
{
gc = EditorGUIUtility.TempContent(fileName + ":" + line.ToString(CultureInfo.InvariantCulture));
}
// calculate size so we can right-align it
Vector2 size = EditorStyles.miniLabel.CalcSize(gc);
locRect.xMin -= size.x;
GUI.Label(locRect, gc, EditorStyles.miniLabel);
locRect.xMin -= 2;
// ensure some minimum width so that platform field next will line up
if (locRect.width < 30)
{
locRect.xMin = locRect.xMax - 30;
}
}
// platform to the left of it
Rect platRect = locRect;
platRect.width = 0;
if (plat.Length > 0)
{
GUIContent gc = EditorGUIUtility.TempContent(plat);
// calculate size so we can right-align it
Vector2 size = EditorStyles.miniLabel.CalcSize(gc);
platRect.xMin -= size.x;
// draw platform in dimmer color; it's often not very important information
Color oldColor = GUI.contentColor;
GUI.contentColor = new Color(1, 1, 1, 0.5f);
GUI.Label(platRect, gc, EditorStyles.miniLabel);
GUI.contentColor = oldColor;
platRect.xMin -= 2;
}
// error message
Rect msgRect = r;
msgRect.xMax = platRect.xMin;
GUI.Label(msgRect, EditorGUIUtility.TempContent(err, warn ? Styles.warningIcon : Styles.errorIcon), Styles.messageStyle);
}
EditorGUIUtility.SetIconSize(Vector2.zero);
GUILayout.EndScrollView();
}
public VariantCompileInfo CompileVariant(ShaderType shaderType, string[] keywords,
ShaderCompilerPlatform shaderCompilerPlatform, BuildTarget buildTarget, BuiltinShaderDefine[] platformKeywords, GraphicsTier tier, bool forExternalTool)
{
return(ShaderUtil.CompileShaderVariant(SourceShader, SubshaderIndex, m_PassIndex, shaderType, platformKeywords, keywords, shaderCompilerPlatform, buildTarget, tier, forExternalTool));
}
public virtual void OnEnable()
{
var s = target as Shader;
ShaderUtil.FetchCachedMessages(s);
}
public PreprocessedVariant PreprocessVariant(ShaderType shaderType, string[] keywords,
ShaderCompilerPlatform shaderCompilerPlatform, BuildTarget buildTarget, BuiltinShaderDefine[] platformKeywords, GraphicsTier tier, bool stripLineDirectives)
{
return(ShaderUtil.PreprocessShaderVariant(SourceShader, SubshaderIndex, m_PassIndex, shaderType, platformKeywords, keywords, shaderCompilerPlatform, buildTarget, tier, stripLineDirectives));
}
public override void OnInspectorGUI()
{
serializedObject.Update();
bool calcLightmapStripping = false, calcFogStripping = false;
EditorGUILayout.PropertyField(m_LightmapStripping, Styles.lightmapModes);
if (m_LightmapStripping.intValue != 0)
{
EditorGUI.indentLevel++;
EditorGUILayout.PropertyField(m_LightmapKeepPlain, Styles.lightmapPlain);
EditorGUILayout.PropertyField(m_LightmapKeepDirCombined, Styles.lightmapDirCombined);
EditorGUILayout.PropertyField(m_LightmapKeepDynamicPlain, Styles.lightmapDynamicPlain);
EditorGUILayout.PropertyField(m_LightmapKeepDynamicDirCombined, Styles.lightmapDynamicDirCombined);
EditorGUILayout.PropertyField(m_LightmapKeepShadowMask, Styles.lightmapKeepShadowMask);
EditorGUILayout.PropertyField(m_LightmapKeepSubtractive, Styles.lightmapKeepSubtractive);
EditorGUILayout.Space();
EditorGUILayout.BeginHorizontal();
EditorGUILayout.PrefixLabel(GUIContent.Temp(" "), EditorStyles.miniButton);
if (GUILayout.Button(Styles.lightmapFromScene, EditorStyles.miniButton, GUILayout.ExpandWidth(false)))
{
calcLightmapStripping = true;
}
EditorGUILayout.EndHorizontal();
EditorGUI.indentLevel--;
EditorGUILayout.Space();
}
EditorGUILayout.PropertyField(m_FogStripping, Styles.fogModes);
if (m_FogStripping.intValue != 0)
{
EditorGUI.indentLevel++;
EditorGUILayout.PropertyField(m_FogKeepLinear, Styles.fogLinear);
EditorGUILayout.PropertyField(m_FogKeepExp, Styles.fogExp);
EditorGUILayout.PropertyField(m_FogKeepExp2, Styles.fogExp2);
EditorGUILayout.Space();
EditorGUILayout.BeginHorizontal();
EditorGUILayout.PrefixLabel(GUIContent.Temp(" "), EditorStyles.miniButton);
if (GUILayout.Button(Styles.fogFromScene, EditorStyles.miniButton, GUILayout.ExpandWidth(false)))
{
calcFogStripping = true;
}
EditorGUILayout.EndHorizontal();
EditorGUI.indentLevel--;
EditorGUILayout.Space();
}
EditorGUILayout.PropertyField(m_InstancingStripping, Styles.instancingVariants);
serializedObject.ApplyModifiedProperties();
// need to do these after ApplyModifiedProperties, since it changes their values from native code
if (calcLightmapStripping)
{
ShaderUtil.CalculateLightmapStrippingFromCurrentScene();
}
if (calcFogStripping)
{
ShaderUtil.CalculateFogStrippingFromCurrentScene();
}
}
public bool HasShaderStage(ShaderType shaderType)
{
return(ShaderUtil.PassHasShaderStage(SourceShader, SubshaderIndex, m_PassIndex, shaderType));
}
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 = useLighting && material.GetTexture("_BumpMap");
bool useGPUInstancing = ShaderUtil.HasProceduralInstancing(material.shader);
if (useGPUInstancing && m_RenderersUsingThisMaterial.Count > 0)
{
if (!m_RenderersUsingThisMaterial[0].enableGPUInstancing)
{
useGPUInstancing = false;
}
}
GUILayout.Label(Styles.streamPositionText, EditorStyles.label);
if (useLighting)
{
GUILayout.Label(Styles.streamNormalText, EditorStyles.label);
}
GUILayout.Label(useGPUInstancing ? Styles.streamColorInstancedText : Styles.streamColorText, EditorStyles.label);
GUILayout.Label(Styles.streamUVText, EditorStyles.label);
if (useTangents)
{
GUILayout.Label(Styles.streamTangentText, EditorStyles.label);
}
if (useGPUInstancing)
{
GUILayout.Label(Styles.streamAnimFrameText, EditorStyles.label);
}
else if (useFlipbookBlending && !useGPUInstancing)
{
GUILayout.Label(Styles.streamUV2Text, EditorStyles.label);
GUILayout.Label(Styles.streamAnimBlendText, 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 (useTangents)
{
streams.Add(ParticleSystemVertexStream.Tangent);
}
List <ParticleSystemVertexStream> instancedStreams = new List <ParticleSystemVertexStream>(streams);
if (useGPUInstancing)
{
instancedStreams.Add(ParticleSystemVertexStream.AnimFrame);
}
if (useFlipbookBlending)
{
streams.Add(ParticleSystemVertexStream.UV2);
streams.Add(ParticleSystemVertexStream.AnimBlend);
}
// Set the streams on all systems using this material
if (GUILayout.Button(Styles.streamApplyToAllSystemsText, EditorStyles.miniButton, GUILayout.ExpandWidth(false)))
{
Undo.RecordObjects(m_RenderersUsingThisMaterial.Where(r => r != null).ToArray(), Styles.undoApplyCustomVertexStreams);
foreach (ParticleSystemRenderer renderer in m_RenderersUsingThisMaterial)
{
if (renderer != null)
{
if (useGPUInstancing && renderer.renderMode == ParticleSystemRenderMode.Mesh && renderer.supportsMeshInstancing)
{
renderer.SetActiveVertexStreams(instancedStreams);
}
else
{
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)
{
if (renderer != null)
{
renderer.GetActiveVertexStreams(rendererStreams);
bool streamsValid;
if (useGPUInstancing && renderer.renderMode == ParticleSystemRenderMode.Mesh && renderer.supportsMeshInstancing)
{
streamsValid = rendererStreams.SequenceEqual(instancedStreams);
}
else
{
streamsValid = rendererStreams.SequenceEqual(streams);
}
if (!streamsValid)
{
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 Texture TextureProperty(string propertyName, string label, ShaderUtil.ShaderPropertyTexDim texDim, bool scaleOffset)
{
MaterialProperty materialProperty = GetMaterialProperty(base.targets, propertyName);
return this.TextureProperty(materialProperty, label, scaleOffset);
}
