Beispiel #1
0
        public void Show(bool reload)
        {
            GUILayout.BeginVertical();
            try {
                GUILayout.BeginHorizontal();
                try {
                    var texIcon = expand ? MinusIcon : PlusIcon;
                    if (GUILayout.Button(texIcon, bStyleLeft, optUnitHeight, optIconWidth))
                    {
                        expand = !expand;
                    }

                    if (GUILayout.Button(edited.name, bStyleLeft, optUnitHeight))
                    {
                        expand = !expand;
                    }
                    if (!expand)
                    {
                        return;
                    }
                } finally {
                    GUILayout.EndHorizontal();
                }

                if (edited.type == ShaderType.UNKNOWN)
                {
                    GUILayout.Label("shader: " + edited.material.shader.name);
                    return;
                }

                GUILayout.BeginHorizontal();
                try {
                    // コピー
                    if (GUILayout.Button(CopyIcon, optUnitHeight, optButonWidthS))
                    {
                        clipHandler.SetClipboard(MateHandler.Instance.ToText(edited));
                        if (tipsCall != null)
                        {
                            tipsCall("マテリアル情報をクリップボードに\nコピーしました");
                        }
                    }

                    GUI.enabled &= clipHandler.isMateText;
                    var icons = PasteIcons;
                    if (GUILayout.Button(icons[0], optUnitHeight, optButonWidthS))
                    {
                        try {
                            MateHandler.Instance.Write(edited, clipHandler.mateText);
                            if (tipsCall != null)
                            {
                                tipsCall("マテリアル情報を貼付けました");
                            }
                        } catch (Exception e) {
                            LogUtil.Error("failed to import mateText", e);
                        }
                    }

                    includeOthers = GUILayout.Toggle(includeOthers, "CF", uiParams.tStyleSS);
                    includeShader = GUILayout.Toggle(includeShader, "S", uiParams.tStyleSS);
                    includeTex    = GUILayout.Toggle(includeTex, "T", uiParams.tStyleSS);
                    GUI.enabled  &= (includeTex | includeShader | includeOthers);
                    if (GUILayout.Button(icons[1], optUnitHeight, optButonWidth))
                    {
                        try {
                            var pasteFlag = 0;
                            if (includeTex)
                            {
                                pasteFlag |= MateHandler.MATE_TEX;
                            }
                            if (includeShader)
                            {
                                pasteFlag |= MateHandler.MATE_SHADER;
                            }
                            if (includeOthers)
                            {
                                pasteFlag |= MateHandler.MATE_COLOR | MateHandler.MATE_FLOAT;
                            }
                            LogUtil.DebugF("material pasting from cp... tex={0}, shader={1}, others={2}",
                                           includeTex, includeShader, includeOthers);
                            MateHandler.Instance.Write(edited, clipHandler.mateText, pasteFlag);
                        } catch (Exception e) {
                            LogUtil.Error("failed to import mateText", e);
                        }

                        if (tipsCall != null)
                        {
                            tipsCall("マテリアル情報を貼付けました");
                        }
                    }
                } finally {
                    GUI.enabled = true;
                    GUILayout.EndHorizontal();
                }

                var material = edited.material;
                var idx      = edited.type.idx;

                if (shaderCombo == null)
                {
                    var selected = (idx >= 0 && idx < ShaderNames.Length) ? ShaderNames[idx] : GUIContent.none;
                    shaderCombo = new ComboBoxLO(selected, ShaderNames, uiParams.bStyleSC, uiParams.boxStyle, uiParams.listStyle, false);
                }
                else
                {
                    shaderCombo.SelectedItemIndex = idx;
                }
                shaderCombo.Show(GUILayout.ExpandWidth(true)); //uiParams.optInsideWidth);

                var selectedIdx = shaderCombo.SelectedItemIndex;
                if (idx != selectedIdx && selectedIdx != -1)
                {
                    LogUtil.Debug("shader changed", idx, "=>", selectedIdx);

                    // シェーダ変更
                    var shaderName0 = ShaderNames[selectedIdx].text;
                    edited.ChangeShader(shaderName0, selectedIdx);
                }

                if (reload)
                {
                    edited.renderQueue.Set(material.renderQueue);
                }

                sliderHelper.SetupFloatSlider("RQ", edited.renderQueue,
                                              edited.renderQueue.range.editMin, edited.renderQueue.range.editMax,
                                              (rq) => {
                    material.SetFloat(ShaderPropType.RenderQueue.propId, rq);
                    material.renderQueue = (int)rq;
                },
                                              ShaderPropType.RenderQueue.opts,
                                              ShaderPropType.RenderQueue.presetVals,
                                              rqResolver.Resolve(slotIdx));


                var sdType = edited.type;
                for (var i = 0; i < sdType.colProps.Length; i++)
                {
                    var colProp   = sdType.colProps[i];
                    var editColor = edited.editColors[i];
                    var picker    = edited.pickers[i];
                    if (reload)
                    {
                        editColor.Set(material.GetColor(colProp.propId));
//                    } else {
//                        if (!editColor.val.HasValue) {
//                            editColor.Set(colProp.defaultVal);
//                            LogUtil.DebugF("value is empty. set white. color={0}, vals={1}, syncs={2}",
//                                editColor.val, editColor.editVals, editColor.isSyncs);
//                        }
                    }

                    if (sliderHelper.DrawColorSlider(colProp, ref editColor, picker))
                    {
                        material.SetColor(colProp.propId, editColor.val);
                    }
                }

                for (var i = 0; i < sdType.fProps.Length; i++)
                {
                    var prop = sdType.fProps[i];
                    if (reload)
                    {
                        edited.editVals[i].Set(material.GetFloat(prop.propId));
                    }

                    switch (prop.valType)
                    {
                    case ValType.Float:
                        // slider
                        var fprop = prop;
                        // fprop.SetValue(mat, val);
                        sliderHelper.SetupFloatSlider(fprop, edited.editVals[i], (val) => fprop.SetValue(material, val));
                        break;

                    case ValType.Bool:
                        cbHelper.ShowCheckBox(prop.name, edited.editVals[i],
                                              (val) => prop.SetValue(material, val));
                        break;

                    case ValType.Enum:
                        cbHelper.ShowComboBox(prop.name, edited.editVals[i],
                                              (val) => prop.SetValue(material, val));
                        break;
                    }
                }
            } finally {
                GUILayout.EndVertical();
            }
        }