Example #1
0
        protected static List <Action <ConvertContext> > CreateConverterList()
        {
            return(new List <Action <ConvertContext> >()
            {
                ctx => {
                    bool cnv = false;
                    var shader = ctx.target.shader;
                    while (WFCommonUtility.IsSupportedShader(shader) && !WFCommonUtility.IsMobileSupportedShader(shader))
                    {
                        // シェーダ切り替え
                        var fallback = WFCommonUtility.GetShaderFallBackTarget(shader) ?? "Hidden/UnlitWF/WF_UnToon_Hidden";
                        WFCommonUtility.ChangeShader(fallback, ctx.target);

                        // シェーダ切り替え後に RenderQueue をコピー
                        ctx.target.renderQueue = ctx.oldMaterial.renderQueue;

                        shader = ctx.target.shader;
                        cnv = true;
                    }
                    if (cnv)
                    {
                        WFCommonUtility.SetupShaderKeyword(ctx.target);
                        EditorUtility.SetDirty(ctx.target);
                    }
                },
                ctx => {
                    if (IsMatchShaderName(ctx.oldMaterial.shader, "Transparent3Pass") && !IsMatchShaderName(ctx.target.shader, "Transparent3Pass"))
                    {
                        // Transparent3Pass からそうではないシェーダの切り替えでは、_AL_ZWrite を ON に変更する
                        ctx.target.SetInt("_AL_ZWrite", 1);
                    }
                },
            });
        }
Example #2
0
        public static void copyProperties(CopyPropParameter param, bool undo)
        {
            if (param.materialSource == null)
            {
                return;
            }
            var src_props = new List <ShaderMaterialProperty>();

            // Label経由とPrefix経由をどちらもPrefixにする
            var copy_target = new List <string>(WFShaderFunction.LabelToPrefix(param.labels.ToList()));

            copy_target.AddRange(param.prefixs);

            foreach (var src_prop in ShaderMaterialProperty.AsList(param.materialSource))
            {
                string prefix = WFCommonUtility.GetPrefixFromPropName(src_prop.Name);
                if (prefix == null)
                {
                    continue;
                }
                // Prefixの一致判定
                if (copy_target.Any(prefix.Contains))
                {
                    if (!param.withoutTextures || src_prop.Type != ShaderUtil.ShaderPropertyType.TexEnv)
                    {
                        src_props.Add(src_prop);
                    }
                }
            }
            if (src_props.Count == 0)
            {
                return;
            }

            if (undo)
            {
                Undo.RecordObjects(param.materialDestination, "WF copy materials");
            }

            for (int i = 0; i < param.materialDestination.Length; i++)
            {
                var dst = param.materialDestination[i];
                if (dst == null || dst == param.materialSource)
                { // コピー先とコピー元が同じ時もコピーしない
                    continue;
                }
                var dst_props = ShaderMaterialProperty.AsDict(dst);

                // コピー
                if (CopyProperties(src_props, dst_props, param.onlyOverrideBuiltinTextures))
                {
                    // キーワードを整理する
                    WFCommonUtility.SetupShaderKeyword(dst);
                    // ダーティフラグを付ける
                    EditorUtility.SetDirty(dst);
                }
            }
            AssetDatabase.SaveAssets();
        }
Example #3
0
        public static void CleanUpProperties(CleanUpParameter param)
        {
            Undo.RecordObjects(param.materials, "WF cleanup materials");

            foreach (Material material in param.materials)
            {
                if (material == null)
                {
                    continue;
                }
                var props = ShaderSerializedProperty.AsList(material);

                // 無効になってる機能のプレフィックスを集める
                var delPrefix = new List <string>();
                foreach (var p in props)
                {
                    string label, name;
                    WFCommonUtility.FormatPropName(p.name, out label, out name);
                    if (label != null && name.ToLower() == "enable" && p.FloatValue == 0)
                    {
                        delPrefix.Add(label);
                    }
                }

                var del_props = new HashSet <ShaderSerializedProperty>();

                // プレフィックスに合致する設定値を消去
                Predicate <ShaderSerializedProperty> predPrefix = p =>
                {
                    string label = WFCommonUtility.GetPrefixFromPropName(p.name);
                    return(label != null && delPrefix.Contains(label));
                };
                props.FindAll(predPrefix)
                // ただしEnableToggle自体は初期化しない
                .Where(p => !WFCommonUtility.IsEnableToggleFromPropName(p.name)).ToList().ForEach(p => del_props.Add(p));
                // 未使用の値を削除
                Predicate <ShaderSerializedProperty> predUnused = p => param.resetUnused && !p.HasPropertyInShader;
                props.FindAll(predUnused).ForEach(p => del_props.Add(p));
                // 削除実行
                DeleteProperties(del_props);

                // キーワードクリア
                if (param.resetKeywords)
                {
                    foreach (var so in ShaderSerializedProperty.GetUniqueSerialObject(props))
                    {
                        DeleteShaderKeyword(so);
                    }
                }

                // キーワードを整理する
                WFCommonUtility.SetupShaderKeyword(material);
                // 反映
                EditorUtility.SetDirty(material);
            }
        }
Example #4
0
        public static void MigrationMaterialWithoutUndo(params Material[] mats)
        {
            mats = mats.Where(m => !m.shader.name.Contains("MatcapShadows")).ToArray();
            // プロパティ名を変更
            var oldPropList = CreateRelacePropertyList(mats);

            RenamePropNameWithoutUndo(mats, oldPropList);
            // シェーダキーワードを整理
            WFCommonUtility.SetupShaderKeyword(mats);
        }
Example #5
0
        public static void ResetPropertiesWithoutUndo(ResetParameter param)
        {
            foreach (Material material in param.materials)
            {
                if (material == null)
                {
                    continue;
                }

                var props     = ShaderSerializedProperty.AsList(material);
                var del_props = new HashSet <ShaderSerializedProperty>();

                // ColorのAlphaチャンネルのみ変更
                foreach (var p in props)
                {
                    if (p.HasPropertyInShader && p.Type == ShaderUtil.ShaderPropertyType.Color)
                    {
                        var c = p.ColorValue;
                        c.a          = 1;
                        p.ColorValue = c;
                    }
                }
                ShaderSerializedProperty.AllApplyPropertyChange(props);

                // 条件に合致するプロパティを削除
                foreach (var p in props)
                {
                    if (param.resetColor && p.Type == ShaderUtil.ShaderPropertyType.Color)
                    {
                        del_props.Add(p);
                    }
                    else if (param.resetFloat && p.Type == ShaderUtil.ShaderPropertyType.Float)
                    {
                        del_props.Add(p);
                    }
                    else if (param.resetTexture && p.Type == ShaderUtil.ShaderPropertyType.TexEnv)
                    {
                        del_props.Add(p);
                    }
                    else if (param.resetUnused && !p.HasPropertyInShader)
                    {
                        del_props.Add(p);
                    }
                    else if (param.resetLit && p.name.StartsWith("_GL_"))
                    {
                        del_props.Add(p);
                    }
                    else if (param.resetPrefixs.Contains(WFCommonUtility.GetPrefixFromPropName(p.name)))
                    {
                        del_props.Add(p);
                    }
                }
                // 削除実行
                DeleteProperties(del_props);

                // キーワードクリア
                if (param.resetKeywords)
                {
                    foreach (var so in ShaderSerializedProperty.GetUniqueSerialObject(props))
                    {
                        DeleteShaderKeyword(so);
                    }
                }

                // キーワードを整理する
                WFCommonUtility.SetupShaderKeyword(material);
                // 反映
                EditorUtility.SetDirty(material);
            }
        }