internal override bool HasModified() { if (base.HasModified()) { return(true); } ShaderImporter shaderImporter = this.target as ShaderImporter; if (shaderImporter == null) { return(false); } Shader shader = shaderImporter.GetShader(); if (shader == null) { return(false); } int propertyCount = ShaderUtil.GetPropertyCount(shader); for (int i = 0; i < propertyCount; i++) { string propertyName = ShaderUtil.GetPropertyName(shader, i); for (int j = 0; j < this.propertyNames.Count; j++) { if (this.propertyNames[j] == propertyName && this.textures[j] != shaderImporter.GetDefaultTexture(propertyName)) { return(true); } } } return(false); }
private static int GetMaterialPropertyPopupHash(UnityEngine.Object[] objects) { int hash = 0; foreach (VideoPlayer vp in objects) { if (!vp) { continue; } Renderer renderer = GetTargetRenderer(vp); if (!renderer) { continue; } hash ^= vp.targetMaterialProperty.GetHashCode(); foreach (Material material in renderer.sharedMaterials) { if (!material) { continue; } hash ^= material.name.GetHashCode(); for (int i = 0, e = ShaderUtil.GetPropertyCount(material.shader); i < e; ++i) { if (ShaderUtil.GetPropertyType(material.shader, i) == ShaderUtil.ShaderPropertyType.TexEnv) { hash ^= ShaderUtil.GetPropertyName(material.shader, i).GetHashCode(); } } } } return(hash); }
internal override void ResetValues() { base.ResetValues(); this.propertyNames = new List <string>(); this.displayNames = new List <string>(); this.textures = new List <Texture>(); this.dimensions = new List <TextureDimension>(); ShaderImporter shaderImporter = this.target as ShaderImporter; if (shaderImporter == null) { return; } Shader shader = shaderImporter.GetShader(); if (shader == null) { return; } int propertyCount = ShaderUtil.GetPropertyCount(shader); for (int i = 0; i < propertyCount; i++) { if (ShaderUtil.GetPropertyType(shader, i) == ShaderUtil.ShaderPropertyType.TexEnv) { string propertyName = ShaderUtil.GetPropertyName(shader, i); string propertyDescription = ShaderUtil.GetPropertyDescription(shader, i); Texture defaultTexture = shaderImporter.GetDefaultTexture(propertyName); this.propertyNames.Add(propertyName); this.displayNames.Add(propertyDescription); this.textures.Add(defaultTexture); this.dimensions.Add(ShaderUtil.GetTexDim(shader, i)); } } }
internal override bool HasModified() { if (base.HasModified()) { return(true); } ShaderImporter target = this.target as ShaderImporter; if ((UnityEngine.Object)target == (UnityEngine.Object)null) { return(false); } Shader shader = target.GetShader(); if ((UnityEngine.Object)shader == (UnityEngine.Object)null) { return(false); } int propertyCount = ShaderUtil.GetPropertyCount(shader); for (int propertyIdx = 0; propertyIdx < propertyCount; ++propertyIdx) { string propertyName = ShaderUtil.GetPropertyName(shader, propertyIdx); for (int index = 0; index < this.propertyNames.Count; ++index) { if (this.propertyNames[index] == propertyName && (UnityEngine.Object) this.textures[index] != (UnityEngine.Object)target.GetDefaultTexture(propertyName)) { return(true); } } } return(false); }
internal override void ResetValues() { base.ResetValues(); this.propertyNames = new List <string>(); this.displayNames = new List <string>(); this.textures = new List <Texture>(); this.dimensions = new List <ShaderUtil.ShaderPropertyTexDim>(); ShaderImporter target = this.target as ShaderImporter; if ((UnityEngine.Object)target == (UnityEngine.Object)null) { return; } Shader shader = target.GetShader(); if ((UnityEngine.Object)shader == (UnityEngine.Object)null) { return; } int propertyCount = ShaderUtil.GetPropertyCount(shader); for (int propertyIdx = 0; propertyIdx < propertyCount; ++propertyIdx) { if (ShaderUtil.GetPropertyType(shader, propertyIdx) == ShaderUtil.ShaderPropertyType.TexEnv) { string propertyName = ShaderUtil.GetPropertyName(shader, propertyIdx); string propertyDescription = ShaderUtil.GetPropertyDescription(shader, propertyIdx); Texture defaultTexture = target.GetDefaultTexture(propertyName); this.propertyNames.Add(propertyName); this.displayNames.Add(propertyDescription); this.textures.Add(defaultTexture); this.dimensions.Add(ShaderUtil.GetTexDim(shader, propertyIdx)); } } }
private string GenerateMultiMaterialinformation() { if (targets.Count() > 1) { return(""); } VideoPlayer vp = target as VideoPlayer; if (!vp) { return(""); } Renderer renderer = GetTargetRenderer(vp); if (!renderer) { return(""); } var sharedMaterials = renderer.sharedMaterials; if (sharedMaterials == null || sharedMaterials.Count() <= 1) { return(""); } var targetMaterials = new List <string>(); foreach (Material material in sharedMaterials) { if (!material) { continue; } for (int i = 0, e = ShaderUtil.GetPropertyCount(material.shader); i < e; ++i) { if ((ShaderUtil.GetPropertyType(material.shader, i) == ShaderUtil.ShaderPropertyType.TexEnv) && (ShaderUtil.GetPropertyName(material.shader, i) == m_TargetMaterialProperty.stringValue)) { targetMaterials.Add(material.name); break; } } } if (targetMaterials.Count() == sharedMaterials.Count()) { return(s_Styles.texPropInAllMaterialsHelp); } return(string.Format( s_Styles.texPropInSomeMaterialsHelp, targetMaterials.Count(), sharedMaterials.Count()) + ": " + string.Join(", ", targetMaterials.ToArray())); }
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 List <string> GetMaterialPropertyNames(UnityEngine.Object obj, bool multiSelect, out int selection, out bool invalidSelection) { selection = -1; invalidSelection = true; List <string> list = new List <string>(); VideoPlayer videoPlayer = obj as VideoPlayer; List <string> result; if (!videoPlayer) { result = list; } else { Renderer targetRenderer = VideoPlayerEditor.GetTargetRenderer(videoPlayer); if (!targetRenderer) { result = list; } else { Material[] sharedMaterials = targetRenderer.sharedMaterials; for (int i = 0; i < sharedMaterials.Length; i++) { Material material = sharedMaterials[i]; if (material) { int j = 0; int propertyCount = ShaderUtil.GetPropertyCount(material.shader); while (j < propertyCount) { if (ShaderUtil.GetPropertyType(material.shader, j) == ShaderUtil.ShaderPropertyType.TexEnv) { string propertyName = ShaderUtil.GetPropertyName(material.shader, j); if (!list.Contains(propertyName)) { list.Add(propertyName); } } j++; } selection = list.IndexOf(videoPlayer.targetMaterialProperty); invalidSelection = (selection < 0 && list.Count <string>() > 0); if (invalidSelection && !multiSelect) { selection = list.Count <string>(); list.Add(videoPlayer.targetMaterialProperty); } } } result = list; } } return(result); }
protected override void ResetValues() { base.ResetValues(); m_Properties.Clear(); var importer = target as ShaderImporter; if (importer == null) { return; } var shader = importer.GetShader(); if (shader == null) { return; } var propertyCount = ShaderUtil.GetPropertyCount(shader); for (var i = 0; i < propertyCount; i++) { if (ShaderUtil.GetPropertyType(shader, i) != ShaderUtil.ShaderPropertyType.TexEnv) { continue; } var propertyName = ShaderUtil.GetPropertyName(shader, i); var displayName = ShaderUtil.GetPropertyDescription(shader, i); // might be empty var modifiable = !ShaderUtil.IsShaderPropertyNonModifiableTexureProperty(shader, i); Texture tex; if (!modifiable) { tex = importer.GetNonModifiableTexture(propertyName); } else { tex = importer.GetDefaultTexture(propertyName); } var temp = new TextureProp { propertyName = propertyName, texture = tex, dimension = ShaderUtil.GetTexDim(shader, i), displayName = displayName, modifiable = modifiable }; m_Properties.Add(temp); } }
protected override void InitializeExtraDataInstance(Object extraTarget, int targetIndex) { var data = (ShaderProperties)extraTarget; data.CleanUp(); var importer = targets[targetIndex] as ShaderImporter; if (importer == null) { return; } var shader = importer.GetShader(); if (shader == null) { return; } var propertyCount = ShaderUtil.GetPropertyCount(shader); for (var i = 0; i < propertyCount; i++) { if (ShaderUtil.GetPropertyType(shader, i) != ShaderUtil.ShaderPropertyType.TexEnv) { continue; } var propertyName = ShaderUtil.GetPropertyName(shader, i); var displayName = ShaderUtil.GetPropertyDescription(shader, i); // might be empty var modifiable = !ShaderUtil.IsShaderPropertyNonModifiableTexureProperty(shader, i); Texture tex; if (!modifiable) { tex = importer.GetNonModifiableTexture(propertyName); } else { tex = importer.GetDefaultTexture(propertyName); } var temp = new TextureProp { propertyName = propertyName, texture = tex, dimension = ShaderUtil.GetTexDim(shader, i), displayName = displayName, modifiable = modifiable }; data.m_Properties.Add(temp); } }
private static void ShowShaderProperties(Shader s) { GUILayout.Space(5f); GUILayout.Label("Properties:", EditorStyles.boldLabel, new GUILayoutOption[0]); int propertyCount = ShaderUtil.GetPropertyCount(s); for (int index = 0; index < propertyCount; ++index) { EditorGUILayout.LabelField(ShaderUtil.GetPropertyName(s, index), ShaderInspector.GetPropertyType(s, index) + ShaderUtil.GetPropertyDescription(s, index), new GUILayoutOption[0]); } }
private static void ShowShaderProperties(Shader s) { GUILayout.Space(kSpace); GUILayout.Label("Properties:", EditorStyles.boldLabel); int n = ShaderUtil.GetPropertyCount(s); for (int i = 0; i < n; ++i) { string pname = ShaderUtil.GetPropertyName(s, i); string pdesc = GetPropertyType(s, i) + ShaderUtil.GetPropertyDescription(s, i); EditorGUILayout.LabelField(pname, pdesc); } }
private void ShowShaderProperties(Shader s) { GUILayout.Space(5f); GUILayout.Label("Properties:", EditorStyles.boldLabel, new GUILayoutOption[0]); int propertyCount = ShaderUtil.GetPropertyCount(s); for (int i = 0; i < propertyCount; i++) { string propertyName = ShaderUtil.GetPropertyName(s, i); string label = GetPropertyType(s, i) + ShaderUtil.GetPropertyDescription(s, i); EditorGUILayout.LabelField(propertyName, label, new GUILayoutOption[0]); } }
void SynchronizeLayerProperties(int layerIndex) { Material material = m_MaterialEditor.target as Material; Material layerMaterial = m_MaterialLayers[layerIndex]; if (layerMaterial != null) { Shader layerShader = layerMaterial.shader; int propertyCount = ShaderUtil.GetPropertyCount(layerShader); for (int i = 0; i < propertyCount; ++i) { string propertyName = ShaderUtil.GetPropertyName(layerShader, i); string layerPropertyName = propertyName + layerIndex; if (material.HasProperty(layerPropertyName)) { ShaderUtil.ShaderPropertyType type = ShaderUtil.GetPropertyType(layerShader, i); switch (type) { case ShaderUtil.ShaderPropertyType.Color: { material.SetColor(layerPropertyName, layerMaterial.GetColor(propertyName)); break; } case ShaderUtil.ShaderPropertyType.Float: case ShaderUtil.ShaderPropertyType.Range: { material.SetFloat(layerPropertyName, layerMaterial.GetFloat(propertyName)); break; } case ShaderUtil.ShaderPropertyType.Vector: { material.SetVector(layerPropertyName, layerMaterial.GetVector(propertyName)); break; } case ShaderUtil.ShaderPropertyType.TexEnv: { material.SetTexture(layerPropertyName, layerMaterial.GetTexture(propertyName)); break; } } } } } }
public override bool HasModified() { bool result; if (base.HasModified()) { result = true; } else { ShaderImporter shaderImporter = base.target as ShaderImporter; if (shaderImporter == null) { result = false; } else { Shader shader = shaderImporter.GetShader(); if (shader == null) { result = false; } else { int propertyCount = ShaderUtil.GetPropertyCount(shader); for (int i = 0; i < propertyCount; i++) { string propertyName = ShaderUtil.GetPropertyName(shader, i); for (int j = 0; j < this.m_Properties.Count; j++) { if (this.m_Properties[j].propertyName == propertyName) { Texture y = (!this.m_Properties[j].modifiable) ? shaderImporter.GetNonModifiableTexture(propertyName) : shaderImporter.GetDefaultTexture(propertyName); if (this.m_Properties[j].texture != y) { result = true; return(result); } } } } result = false; } } } return(result); }
private static List <string> GetMaterialPropertyNames(UnityEngine.Object obj, bool multiSelect, out int selection, out bool invalidSelection) { selection = -1; invalidSelection = true; List <string> properties = new List <string>(); VideoPlayer vp = obj as VideoPlayer; if (!vp) { return(properties); } Renderer renderer = GetTargetRenderer(vp); if (!renderer) { return(properties); } foreach (Material material in renderer.sharedMaterials) { if (material) { for (int i = 0, e = ShaderUtil.GetPropertyCount(material.shader); i < e; ++i) { if (ShaderUtil.GetPropertyType(material.shader, i) == ShaderUtil.ShaderPropertyType.TexEnv) { string propertyName = ShaderUtil.GetPropertyName(material.shader, i); if (!properties.Contains(propertyName)) { properties.Add(propertyName); } } } selection = properties.IndexOf(vp.targetMaterialProperty); invalidSelection = selection < 0 && properties.Count() > 0; if (invalidSelection && !multiSelect) { selection = properties.Count(); properties.Add(vp.targetMaterialProperty); } } } return(properties); }
protected override void ResetValues() { base.ResetValues(); this.m_Properties.Clear(); ShaderImporter shaderImporter = base.target as ShaderImporter; if (!(shaderImporter == null)) { Shader shader = shaderImporter.GetShader(); if (!(shader == null)) { int propertyCount = ShaderUtil.GetPropertyCount(shader); for (int i = 0; i < propertyCount; i++) { if (ShaderUtil.GetPropertyType(shader, i) == ShaderUtil.ShaderPropertyType.TexEnv) { string propertyName = ShaderUtil.GetPropertyName(shader, i); string propertyDescription = ShaderUtil.GetPropertyDescription(shader, i); bool flag = !ShaderUtil.IsShaderPropertyNonModifiableTexureProperty(shader, i); Texture texture; if (!flag) { texture = shaderImporter.GetNonModifiableTexture(propertyName); } else { texture = shaderImporter.GetDefaultTexture(propertyName); } ShaderImporterInspector.TextureProp item = new ShaderImporterInspector.TextureProp { propertyName = propertyName, texture = texture, dimension = ShaderUtil.GetTexDim(shader, i), displayName = propertyDescription, modifiable = flag }; this.m_Properties.Add(item); } } } } }
public override bool HasModified() { if (base.HasModified()) { return(true); } var importer = target as ShaderImporter; if (importer == null) { return(false); } var shader = importer.GetShader(); if (shader == null) { return(false); } var propertyCount = ShaderUtil.GetPropertyCount(shader); for (var i = 0; i < propertyCount; i++) { var propertyName = ShaderUtil.GetPropertyName(shader, i); for (var k = 0; k < m_Properties.Count; k++) { if (m_Properties[k].propertyName == propertyName) { var tex = m_Properties[k].modifiable ? importer.GetDefaultTexture(propertyName) : importer.GetNonModifiableTexture(propertyName); if (m_Properties[k].texture != tex) { return(true); } } } } return(false); }
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 string GenerateMultiMaterialinformation() { string result; if (base.targets.Count <UnityEngine.Object>() > 1) { result = ""; } else { VideoPlayer videoPlayer = base.target as VideoPlayer; if (!videoPlayer) { result = ""; } else { Renderer targetRenderer = VideoPlayerEditor.GetTargetRenderer(videoPlayer); if (!targetRenderer) { result = ""; } else { Material[] sharedMaterials = targetRenderer.sharedMaterials; if (sharedMaterials == null || sharedMaterials.Count <Material>() <= 1) { result = ""; } else { List <string> list = new List <string>(); Material[] array = sharedMaterials; for (int i = 0; i < array.Length; i++) { Material material = array[i]; if (material) { int j = 0; int propertyCount = ShaderUtil.GetPropertyCount(material.shader); while (j < propertyCount) { if (ShaderUtil.GetPropertyType(material.shader, j) == ShaderUtil.ShaderPropertyType.TexEnv && ShaderUtil.GetPropertyName(material.shader, j) == this.m_TargetMaterialProperty.stringValue) { list.Add(material.name); break; } j++; } } } if (list.Count <string>() == sharedMaterials.Count <Material>()) { result = VideoPlayerEditor.s_Styles.texPropInAllMaterialsHelp; } else { result = string.Format(VideoPlayerEditor.s_Styles.texPropInSomeMaterialsHelp, list.Count <string>(), sharedMaterials.Count <Material>()) + ": " + string.Join(", ", list.ToArray()); } } } } } return(result); }