Exemplo n.º 1
0
 public bool ApplyIfMatch(BlendModePreset preset, BlendMode src, BlendMode dst)
 {
     if (blendSrc == src && blendDst == dst)
     {
         blendModePreset = preset;
         UpdateAutoSettings();
         return(true);
     }
     return(false);
 }
Exemplo n.º 2
0
        public void ConformPresetToBlend()
        {
            bool matched = false;

            matched |= ApplyIfMatch(BlendModePreset.Opaque, BlendMode.One, BlendMode.Zero);
            matched |= ApplyIfMatch(BlendModePreset.Additive, BlendMode.One, BlendMode.One);
            matched |= ApplyIfMatch(BlendModePreset.Screen, BlendMode.OneMinusDstColor, BlendMode.One);
            matched |= ApplyIfMatch(BlendModePreset.Screen, BlendMode.One, BlendMode.OneMinusSrcColor);
            matched |= ApplyIfMatch(BlendModePreset.AlphaBlended, BlendMode.SrcAlpha, BlendMode.OneMinusSrcAlpha);
            matched |= ApplyIfMatch(BlendModePreset.AlphaBlendedPremultiplied, BlendMode.One, BlendMode.OneMinusSrcAlpha);
            matched |= ApplyIfMatch(BlendModePreset.Multiplicative, BlendMode.DstColor, BlendMode.Zero);
            matched |= ApplyIfMatch(BlendModePreset.Multiplicative, BlendMode.Zero, BlendMode.SrcColor);

            if (!matched)
            {
                blendModePreset = BlendModePreset.Custom;
            }
        }
Exemplo n.º 3
0
        public override float DrawInner(ref Rect r)
        {
            float prevYpos = r.y;

            r.y = 0;

            r.y    += 20;
            r.xMin += 20; // Indent

            BlendModePreset before = blendModePreset;

            GUI.enabled     = ps.catLighting.renderPath == SFPSC_Lighting.RenderPath.Forward;
            blendModePreset = (BlendModePreset)UndoableLabeledEnumPopupNamed(r, "混合模式", blendModePreset, strBlendModePreset, "blend mode");
            GUI.enabled     = true;
            if (blendModePreset != before)
            {
                ConformBlendsToPreset();
            }
            if (blendModePreset == BlendModePreset.Custom)
            {
                GUI.color = new Color(1f, 1f, 1f, 0.5f);
                GUI.Label(r.PadLeft(70).PadTop(-1), "自定义混合 点击选择预设", EditorStyles.miniLabel);
                GUI.color = Color.white;
            }

            r.y += 20;

            //if( blendModePreset != BlendModePreset.Opaque ) {
            //if( blendModePreset != BlendModePreset.Custom )
            //GUI.enabled = false;
            //EditorGUILayout.BeginHorizontal( GUILayout.Width( maxWidth ) );
            //{
            //Indent();

            string srcStr      = "来源 * ";
            string dstStr      = " + 目标 * ";
            int    srcStrWidth = SF_GUI.WidthOf(srcStr, EditorStyles.miniLabel);
            int    dstStrWidth = SF_GUI.WidthOf(dstStr, EditorStyles.miniLabel);
            int    fieldWidth  = Mathf.FloorToInt((r.width - srcStrWidth - dstStrWidth) / 2);

            Rect rSrcLb    = new Rect(r); rSrcLb.width = srcStrWidth;
            Rect rSrcField = new Rect(r); rSrcField.x = rSrcLb.xMax; rSrcField.width = fieldWidth;
            Rect rDstLb    = new Rect(r); rDstLb.x = rSrcField.xMax; rDstLb.width = dstStrWidth;
            Rect rDstField = new Rect(rSrcField); rDstField.x = rDstLb.xMax;

            EditorGUI.BeginChangeCheck();

            GUI.Label(rSrcLb, srcStr, EditorStyles.miniLabel);
            blendSrc = (BlendMode)UndoableEnumPopup(rSrcField, blendSrc, "blend source");
            GUI.Label(rDstLb, dstStr, EditorStyles.miniLabel);
            blendDst = (BlendMode)UndoableEnumPopup(rDstField, blendDst, "blend destination");

            if (EditorGUI.EndChangeCheck())
            {
                ConformPresetToBlend();
            }

            //if( blendModePreset != BlendModePreset.Custom )
            //GUI.enabled = true;

            r.y += 20;
            //}


            UndoableColorMask(r, "颜色遮罩", ref colorMask);
            r.y += 20;

            bool canEditDithering = editor.mainNode.alphaClip.IsConnectedAndEnabled();

            EditorGUI.BeginDisabledGroup(!canEditDithering);
            if (canEditDithering)
            {
                dithering = (Dithering)UndoableLabeledEnumPopupNamed(r, "抖动的 alpha 剪辑", dithering, strDithering, "dithered alpha clip");
            }
            else
            {
                UndoableLabeledEnumPopup(r, "抖动的 alpha 剪辑", Dithering.Off, "dithered alpha clip");
            }
            EditorGUI.EndDisabledGroup();
            r.y += 20;

            bool canEditAlphaToCoverage = editor.mainNode.alphaClip.IsConnectedAndEnabled() || editor.mainNode.alpha.IsConnectedAndEnabled();

            EditorGUI.BeginDisabledGroup(!canEditAlphaToCoverage);
            if (canEditAlphaToCoverage)
            {
                alphaToCoverage = UndoableToggle(r, alphaToCoverage, "Alpha 叠加(MSAA 一起发送)", "alpha to coverage");
            }
            else
            {
                GUI.Toggle(r, false, "Alpha 叠加(MSAA 一起发送)");
            }
            EditorGUI.EndDisabledGroup();
            r.y += 20;


            OffsetBlock(ref r);


            RefractionBlock(ref r);


            FogBlock(ref r);

            SortingBlock(ref r);



            StencilBlock(ref r);

            r.y += prevYpos;

            return((int)r.yMax);
        }
Exemplo n.º 4
0
        public override void Deserialize(string key, string value)
        {
            switch (key)
            {
            case "blpr":     // This is no longer saved, but in old shaders, we have to read it with old enum indices

                //	0 "Opaque",
                //	1 "Alpha Blended",
                //	- "Alpha Blended (Premultiplied)",
                //	2 "Additive",
                //	3 "Screen",
                //	4 "Multiplicative",

                int iVal = int.Parse(value);
                if (iVal > 1)     // Offset due to adding premul
                {
                    iVal++;
                }
                blendModePreset = (BlendModePreset)iVal;
                ConformBlendsToPreset();

                lockSrcDstRead = true;
                break;

            case "bsrc":
                if (lockSrcDstRead)
                {
                    break;
                }
                blendSrc = (BlendMode)int.Parse(value);
                break;

            case "bdst":
                if (lockSrcDstRead)
                {
                    lockSrcDstRead = false;
                    break;
                }
                blendDst = (BlendMode)int.Parse(value);
                ConformPresetToBlend();
                break;

            case "dpts":
                depthTest = (DepthTest)int.Parse(value);
                break;

            case "wrdp":
                writeDepth = bool.Parse(value);
                break;

            case "dith":
                dithering = (Dithering)int.Parse(value);
                break;

            case "atcv":
                alphaToCoverage = bool.Parse(value);
                break;

            case "rfrpo":
                perObjectRefraction = bool.Parse(value);
                break;

            case "rfrpn":
                refractionPassName = value;
                break;

            case "coma":
                colorMask = int.Parse(value);
                break;

            case "ufog":
                useFog = bool.Parse(value);
                break;

            case "aust":
                autoSort = bool.Parse(value);
                break;

            case "igpj":
                ignoreProjector = bool.Parse(value);
                break;

            case "qofs":
                queueOffset = int.Parse(value);
                break;

            case "qpre":
                queuePreset = (Queue)int.Parse(value);
                break;

            case "rntp":
                renderType = (RenderType)int.Parse(value);
                break;

            // Fog booleans
            case "fgom":
                fogOverrideMode = bool.Parse(value);
                break;

            case "fgoc":
                fogOverrideColor = bool.Parse(value);
                break;

            case "fgod":
                fogOverrideDensity = bool.Parse(value);
                break;

            case "fgor":
                fogOverrideRange = bool.Parse(value);
                break;

            // Fog values
            case "fgmd":
                fogMode = (ShaderFogMode)int.Parse(value);
                break;

            case "fgcr":
                fogColor.r = float.Parse(value);
                break;

            case "fgcg":
                fogColor.g = float.Parse(value);
                break;

            case "fgcb":
                fogColor.b = float.Parse(value);
                break;

            case "fgca":
                fogColor.a = float.Parse(value);
                break;

            case "fgde":
                fogDensity = float.Parse(value);
                break;

            case "fgrn":
                fogRange.x = float.Parse(value);
                break;

            case "fgrf":
                fogRange.y = float.Parse(value);
                break;

            // Stencil buffer:
            case "stcl":
                useStencilBuffer = bool.Parse(value);
                break;

            case "atwp":
                allowStencilWriteThroughProperties = bool.Parse(value);
                break;

            case "stva":
                stencilValue = byte.Parse(value);
                break;

            case "stmr":
                stencilMaskRead = byte.Parse(value);
                break;

            case "stmw":
                stencilMaskWrite = byte.Parse(value);
                break;

            case "stcp":
                stencilComparison = (DepthTestStencil)int.Parse(value);
                break;

            case "stps":
                stencilPass = (StencilOp)int.Parse(value);
                break;

            case "stfa":
                stencilFail = (StencilOp)int.Parse(value);
                break;

            case "stfz":
                stencilFailZ = (StencilOp)int.Parse(value);
                break;

            // Offset
            case "ofsf":
                offsetFactor = int.Parse(value);
                break;

            case "ofsu":
                offsetUnits = int.Parse(value);
                break;
            }
        }