Example #1
0
            public void Draw(ShaderFieldDrawer parent, int mask)
            {
                if ((mask & Keyword.Mask) == 0)
                {
                    return;
                }

                Material targetMat   = (Material)parent.materialEditor.target;
                string   keyword     = Keyword.Keyword;
                string   displayName = Keyword.ReflectiveField.Name;

                bool isEnabled = targetMat.IsKeywordEnabled(keyword);

                if (parent.isDrawUI)
                {
                    bool newValue = EditorGUILayout.Toggle(displayName, isEnabled);
                    parent.IsKeywordChanged |= isEnabled != newValue;
                    isEnabled = newValue;
                }

                if (isEnabled)
                {
                    parent.keywords?.Add(keyword);
                    parent.Mask |= Keyword.Mask;
                }
            }
Example #2
0
            public void Draw(ShaderFieldDrawer parent, int mask)
            {
                if (parent.keywords == null)
                {
                    return;
                }
                if ((mask & Keyword.Mask) == 0)
                {
                    return;
                }

                var    targetMat    = (Material)parent.materialEditor.target;
                string keyword      = null;
                int    selecteIndex = -1;
                int    emptyIndex   = -1;

                for (int i = 0; i < Keyword.KeywordsAndMask.Length; i += 2)
                {
                    keyword = Keyword.GetKeyword(i);
                    if (keyword == null)
                    {
                        emptyIndex = i / 2;
                    }
                    else if (targetMat.IsKeywordEnabled(keyword))
                    {
                        selecteIndex = i / 2;
                        break;
                    }
                }

                if (selecteIndex < 0 && emptyIndex >= 0)
                {
                    selecteIndex = emptyIndex;
                }

                if (parent.isDrawUI)
                {
                    string displayName     = Keyword.ReflectiveField.Name;
                    int    newSelecteIndex = EditorGUILayout.Popup(displayName, selecteIndex, Keyword.SortNames);
                    parent.IsKeywordChanged |= selecteIndex != newSelecteIndex;
                    selecteIndex             = newSelecteIndex;
                }

                int index = selecteIndex * 2;

                keyword = Keyword.GetKeyword(index);

                if (keyword != null)
                {
                    parent.keywords?.Add(keyword);
                    int itemMask = Keyword.GetMask(index);
                    parent.Mask |= itemMask;
                }
            }
Example #3
0
            public void Draw(ShaderFieldDrawer parent, int mask)
            {
                if ((mask & Field.Mask) == 0)
                {
                    return;
                }

                if (parent.isDrawUI)
                {
                    string displayName = Field.ReflectiveField.Name;
                    parent.materialEditor.ShaderProperty(MaterialProperty, displayName);
                }
            }
Example #4
0
            public void Draw(ShaderFieldDrawer parent, int mask)
            {
                if (parent.keywords == null)
                {
                    return;
                }
                if ((mask & Keyword.Mask) == 0)
                {
                    return;
                }

                var targetMat   = (Material)parent.materialEditor.target;
                int selecteMask = 0;

                for (int i = 0; i < Keyword.KeywordsAndMask.Length; i += 2)
                {
                    string keyword = Keyword.GetKeyword(i);
                    if (keyword != null && targetMat.IsKeywordEnabled(keyword))
                    {
                        int currentMask = 1 << i / 2;
                        selecteMask |= currentMask;
                    }
                }

                if (parent.isDrawUI)
                {
                    string displayName    = Keyword.ReflectiveField.Name;
                    int    newSelecteMask = EditorGUILayout.MaskField(displayName, selecteMask, Keyword.SortNames);
                    parent.IsKeywordChanged |= selecteMask != newSelecteMask;
                    selecteMask              = newSelecteMask;
                }

                for (int i = 0; i < Keyword.KeywordsAndMask.Length; i += 2)
                {
                    int currentMask = 1 << i / 2;
                    if ((selecteMask & currentMask) != 0)
                    {
                        string keyword  = Keyword.GetKeyword(i);
                        int    itemMask = Keyword.GetMask(i);
                        if (keyword != null)
                        {
                            parent.keywords.Add(keyword);
                            parent.Mask |= itemMask;
                        }
                    }
                }
            }
Example #5
0
 public void FindDrawers(List <ISerializedPropertyDrawer> drawers, IShaderFieldGroup group, SerializedProperty property)
 {
     foreach (var child in group.Children)
     {
         if (child is ShaderField)
         {
             var field  = (ShaderField)child;
             var target = property.FindPropertyRelative(field.ReflectiveField.Name);
             if (target != null)
             {
                 var drawer = new ShaderFieldDrawer(target, field);
                 drawers.Add(drawer);
             }
         }
         else if (child is ShaderKeyword)
         {
             var field  = (ShaderKeyword)child;
             var target = property.FindPropertyRelative(field.ReflectiveField.Name);
             if (target != null)
             {
                 var drawer = new KeywordDrawer(target, field);
                 drawers.Add(drawer);
             }
         }
         else if (child is ShaderEnumKeyword)
         {
             var field  = (ShaderEnumKeyword)child;
             var target = property.FindPropertyRelative(field.ReflectiveField.Name);
             if (target != null)
             {
                 var drawer = new EnumKeywordDrawer(target, field);
                 drawers.Add(drawer);
             }
         }
         else if (child is ShaderFieldMark)
         {
             var field  = (ShaderFieldMark)child;
             var target = property.FindPropertyRelative(field.ReflectiveField.Name);
             if (target != null)
             {
                 var drawer = new Drawer(target);
                 drawers.Add(drawer);
             }
         }
         else if (child is ShaderCustomField)
         {
             var field  = (ShaderCustomField)child;
             var target = property.FindPropertyRelative(field.ReflectiveField.Name);
             if (target != null)
             {
                 var drawer = new Drawer(target);
                 drawers.Add(drawer);
             }
         }
         else if (child is ShaderFieldGroup)
         {
             var field  = (ShaderFieldGroup)child;
             var target = property.FindPropertyRelative(field.ReflectiveField.Name);
             if (target != null)
             {
                 var drawer = new GroupDrawer(target, field);
                 drawers.Add(drawer);
                 FindDrawers(drawer.Drawers, field, target);
             }
         }
         else
         {
             throw new NotImplementedException();
         }
     }
 }