public override void OnInspectorGUI()
        {
            base.serializedObject.Update();
            SerializedProperty property = base.serializedObject.FindProperty("m_Shader");

            if ((base.isVisible && !property.hasMultipleDifferentValues) && (property.objectReferenceValue != null))
            {
                List <MaterialProperty> list = new List <MaterialProperty>(MaterialEditor.GetMaterialProperties(base.targets));
                base.SetDefaultGUIWidths();
                SpeedTreeGeometryType[] source = new SpeedTreeGeometryType[base.targets.Length];
                for (int i = 0; i < base.targets.Length; i++)
                {
                    source[i] = SpeedTreeGeometryType.Branch;
                    for (int j = 0; j < this.speedTreeGeometryTypeString.Length; j++)
                    {
                        if (((Material)base.targets[i]).shaderKeywords.Contains <string>(this.speedTreeGeometryTypeString[j]))
                        {
                            source[i] = (SpeedTreeGeometryType)j;
                            break;
                        }
                    }
                }
                EditorGUI.showMixedValue = source.Distinct <SpeedTreeGeometryType>().Count <SpeedTreeGeometryType>() > 1;
                EditorGUI.BeginChangeCheck();
                SpeedTreeGeometryType geomType = (SpeedTreeGeometryType)EditorGUILayout.EnumPopup("Geometry Type", source[0], new GUILayoutOption[0]);
                if (EditorGUI.EndChangeCheck())
                {
                    bool     flag = this.ShouldEnableAlphaTest(geomType);
                    CullMode mode = !flag ? CullMode.Back : CullMode.Off;
                    IEnumerator <Material> enumerator = base.targets.Cast <Material>().GetEnumerator();
                    try
                    {
                        while (enumerator.MoveNext())
                        {
                            Material current = enumerator.Current;
                            for (int k = 0; k < this.speedTreeGeometryTypeString.Length; k++)
                            {
                                current.DisableKeyword(this.speedTreeGeometryTypeString[k]);
                            }
                            current.EnableKeyword(this.speedTreeGeometryTypeString[(int)geomType]);
                            current.renderQueue = !flag ? 0x7d0 : 0x992;
                            current.SetInt("_Cull", (int)mode);
                        }
                    }
                    finally
                    {
                        if (enumerator == null)
                        {
                        }
                        enumerator.Dispose();
                    }
                }
                EditorGUI.showMixedValue = false;
                if (< > f__am$cache1 == null)
                {
 public override void OnInspectorGUI()
 {
     base.serializedObject.Update();
     SerializedProperty property = base.serializedObject.FindProperty("m_Shader");
     if ((base.isVisible && !property.hasMultipleDifferentValues) && (property.objectReferenceValue != null))
     {
         List<MaterialProperty> list = new List<MaterialProperty>(MaterialEditor.GetMaterialProperties(base.targets));
         base.SetDefaultGUIWidths();
         SpeedTreeGeometryType[] source = new SpeedTreeGeometryType[base.targets.Length];
         for (int i = 0; i < base.targets.Length; i++)
         {
             source[i] = SpeedTreeGeometryType.Branch;
             for (int j = 0; j < this.speedTreeGeometryTypeString.Length; j++)
             {
                 if (((Material) base.targets[i]).shaderKeywords.Contains<string>(this.speedTreeGeometryTypeString[j]))
                 {
                     source[i] = (SpeedTreeGeometryType) j;
                     break;
                 }
             }
         }
         EditorGUI.showMixedValue = source.Distinct<SpeedTreeGeometryType>().Count<SpeedTreeGeometryType>() > 1;
         EditorGUI.BeginChangeCheck();
         SpeedTreeGeometryType geomType = (SpeedTreeGeometryType) EditorGUILayout.EnumPopup("Geometry Type", source[0], new GUILayoutOption[0]);
         if (EditorGUI.EndChangeCheck())
         {
             bool flag = this.ShouldEnableAlphaTest(geomType);
             CullMode mode = !flag ? CullMode.Back : CullMode.Off;
             IEnumerator<Material> enumerator = base.targets.Cast<Material>().GetEnumerator();
             try
             {
                 while (enumerator.MoveNext())
                 {
                     Material current = enumerator.Current;
                     for (int k = 0; k < this.speedTreeGeometryTypeString.Length; k++)
                     {
                         current.DisableKeyword(this.speedTreeGeometryTypeString[k]);
                     }
                     current.EnableKeyword(this.speedTreeGeometryTypeString[(int) geomType]);
                     current.renderQueue = !flag ? 0x7d0 : 0x992;
                     current.SetInt("_Cull", (int) mode);
                 }
             }
             finally
             {
                 if (enumerator == null)
                 {
                 }
                 enumerator.Dispose();
             }
         }
         EditorGUI.showMixedValue = false;
         if (<>f__am$cache1 == null)
         {
Beispiel #3
0
    protected override bool OnSetOption(int newOption, AlloyFieldDrawerArgs args)
    {
        base.OnSetOption(newOption, args);
        SpeedTreeGeometryType newMode = (SpeedTreeGeometryType)newOption;
        bool setVal = true;

        if (!string.IsNullOrEmpty(RenderQueueOrderField))
        {
            SerializedProperty custom = args.Editor.GetProperty(MaterialProperty.PropType.Float, RenderQueueOrderField);

            if (custom.floatValue > 0.5f)
            {
                setVal = false;
            }
        }

        for (int i = 0; i < args.Materials.Length; i++)
        {
            var material = args.Materials[i];

            for (int j = 0; j < s_speedTreeKeywordSettings.Length; j++)
            {
                SpeedTreeKeywordSetting setting = s_speedTreeKeywordSettings[j];
                string keyword = setting.Keyword;

                if (newMode != setting.GeometryType)
                {
                    material.DisableKeyword(keyword);
                }
                else
                {
                    material.EnableKeyword(keyword);

                    if (setVal)
                    {
                        material.renderQueue = setting.RenderQueue;
                    }
                }
            }

            material.SetInt("_GeometryType", (int)newMode);
            EditorUtility.SetDirty(material);
        }

        Undo.RecordObjects(args.Materials, "Set geometry type");
        return(true);
    }
 public override void OnInspectorGUI()
 {
     base.serializedObject.Update();
     SerializedProperty property = base.serializedObject.FindProperty("m_Shader");
     if ((base.isVisible && !property.hasMultipleDifferentValues) && (property.objectReferenceValue != null))
     {
         List<MaterialProperty> list = new List<MaterialProperty>(MaterialEditor.GetMaterialProperties(base.targets));
         base.SetDefaultGUIWidths();
         SpeedTreeGeometryType[] source = new SpeedTreeGeometryType[base.targets.Length];
         for (int i = 0; i < base.targets.Length; i++)
         {
             source[i] = SpeedTreeGeometryType.Branch;
             for (int j = 0; j < this.speedTreeGeometryTypeString.Length; j++)
             {
                 if (Enumerable.Contains<string>(((Material) base.targets[i]).shaderKeywords, this.speedTreeGeometryTypeString[j]))
                 {
                     source[i] = (SpeedTreeGeometryType) j;
                     break;
                 }
             }
         }
         EditorGUI.showMixedValue = Enumerable.Count<SpeedTreeGeometryType>(Enumerable.Distinct<SpeedTreeGeometryType>(source)) > 1;
         EditorGUI.BeginChangeCheck();
         SpeedTreeGeometryType geomType = (SpeedTreeGeometryType) EditorGUILayout.EnumPopup("Geometry Type", source[0], new GUILayoutOption[0]);
         if (EditorGUI.EndChangeCheck())
         {
             bool flag = this.ShouldEnableAlphaTest(geomType);
             CullMode mode = !flag ? CullMode.Back : CullMode.Off;
             foreach (Material material in Enumerable.Cast<Material>(base.targets))
             {
                 if (flag)
                 {
                     material.SetOverrideTag("RenderType", "treeTransparentCutout");
                 }
                 for (int k = 0; k < this.speedTreeGeometryTypeString.Length; k++)
                 {
                     material.DisableKeyword(this.speedTreeGeometryTypeString[k]);
                 }
                 material.EnableKeyword(this.speedTreeGeometryTypeString[(int) geomType]);
                 material.renderQueue = !flag ? 0x7d0 : 0x992;
                 material.SetInt("_Cull", (int) mode);
             }
         }
         EditorGUI.showMixedValue = false;
         if (<>f__am$cache0 == null)
         {
        public override void OnInspectorGUI()
        {
            serializedObject.Update();
            var theShader = serializedObject.FindProperty("m_Shader");

            // if we are not visible... return
            if (!isVisible || theShader.hasMultipleDifferentValues || theShader.objectReferenceValue == null)
            {
                return;
            }

            List <MaterialProperty> props = new List <MaterialProperty>(GetMaterialProperties(targets));

            SetDefaultGUIWidths();

            // Geometry type choice
            //---------------------------------------------------------------
            var geomTypes = new SpeedTreeGeometryType[targets.Length];

            for (int i = 0; i < targets.Length; ++i)
            {
                geomTypes[i] = SpeedTreeGeometryType.Branch;
                for (int j = 0; j < speedTreeGeometryTypeString.Length; ++j)
                {
                    if (((Material)targets[i]).shaderKeywords.Contains(speedTreeGeometryTypeString[j]))
                    {
                        geomTypes[i] = (SpeedTreeGeometryType)j;
                        break;
                    }
                }
            }
            EditorGUI.showMixedValue = geomTypes.Distinct().Count() > 1;
            EditorGUI.BeginChangeCheck();
            var setGeomType = (SpeedTreeGeometryType)EditorGUILayout.EnumPopup("Geometry Type", geomTypes[0]);

            if (EditorGUI.EndChangeCheck())
            {
                bool shouldEnableAlphaTest = ShouldEnableAlphaTest(setGeomType);
                UnityEngine.Rendering.CullMode cullMode = shouldEnableAlphaTest ? UnityEngine.Rendering.CullMode.Off : UnityEngine.Rendering.CullMode.Back;

                foreach (var m in targets.Cast <Material>())
                {
                    if (shouldEnableAlphaTest)
                    {
                        m.SetOverrideTag("RenderType", "treeTransparentCutout");
                    }
                    for (int i = 0; i < speedTreeGeometryTypeString.Length; ++i)
                    {
                        m.DisableKeyword(speedTreeGeometryTypeString[i]);
                    }
                    m.EnableKeyword(speedTreeGeometryTypeString[(int)setGeomType]);
                    m.renderQueue = shouldEnableAlphaTest ? (int)UnityEngine.Rendering.RenderQueue.AlphaTest : (int)UnityEngine.Rendering.RenderQueue.Geometry;
                    m.SetInt("_Cull", (int)cullMode);
                }
            }
            EditorGUI.showMixedValue = false;

            //---------------------------------------------------------------
            var mainTex = props.Find(prop => prop.name == "_MainTex");

            if (mainTex != null)
            {
                props.Remove(mainTex);
                ShaderProperty(mainTex, mainTex.displayName);
            }

            //---------------------------------------------------------------
            var bumpMap = props.Find(prop => prop.name == "_BumpMap");

            if (bumpMap != null)
            {
                props.Remove(bumpMap);

                var  enableBump = targets.Select(t => ((Material)t).shaderKeywords.Contains("EFFECT_BUMP"));
                bool?enable     = ToggleShaderProperty(bumpMap, enableBump.First(), enableBump.Distinct().Count() > 1);
                if (enable != null)
                {
                    foreach (var m in targets.Cast <Material>())
                    {
                        if (enable.Value)
                        {
                            m.EnableKeyword("EFFECT_BUMP");
                        }
                        else
                        {
                            m.DisableKeyword("EFFECT_BUMP");
                        }
                    }
                }
            }

            //---------------------------------------------------------------
            var detailTex = props.Find(prop => prop.name == "_DetailTex");

            if (detailTex != null)
            {
                props.Remove(detailTex);
                if (geomTypes.Contains(SpeedTreeGeometryType.BranchDetail))
                {
                    ShaderProperty(detailTex, detailTex.displayName);
                }
            }

            //---------------------------------------------------------------
            var enableHueVariation = targets.Select(t => ((Material)t).shaderKeywords.Contains("EFFECT_HUE_VARIATION"));
            var hueVariation       = props.Find(prop => prop.name == "_HueVariation");

            if (enableHueVariation != null && hueVariation != null)
            {
                props.Remove(hueVariation);
                bool?enable = ToggleShaderProperty(hueVariation, enableHueVariation.First(), enableHueVariation.Distinct().Count() > 1);
                if (enable != null)
                {
                    foreach (var m in targets.Cast <Material>())
                    {
                        if (enable.Value)
                        {
                            m.EnableKeyword("EFFECT_HUE_VARIATION");
                        }
                        else
                        {
                            m.DisableKeyword("EFFECT_HUE_VARIATION");
                        }
                    }
                }
            }

            //---------------------------------------------------------------
            var alphaCutoff = props.Find(prop => prop.name == "_Cutoff");

            if (alphaCutoff != null)
            {
                props.Remove(alphaCutoff);
                if (geomTypes.Any(t => ShouldEnableAlphaTest(t)))
                {
                    ShaderProperty(alphaCutoff, alphaCutoff.displayName);
                }
            }

            //---------------------------------------------------------------
            foreach (var prop in props)
            {
                if ((prop.flags & MaterialProperty.PropFlags.HideInInspector) != 0)
                {
                    continue;
                }
                ShaderProperty(prop, prop.displayName);
            }

            EditorGUILayout.Space();
            EditorGUILayout.Space();

            RenderQueueField();
            EnableInstancingField();
            DoubleSidedGIField();
        }
 private bool ShouldEnableAlphaTest(SpeedTreeGeometryType geomType)
 {
     return(geomType == SpeedTreeGeometryType.Frond ||
            geomType == SpeedTreeGeometryType.Leaf);
 }