TexturePropertyMiniThumbnail() public method

public TexturePropertyMiniThumbnail ( Rect position, MaterialProperty prop, string label, string tooltip ) : Texture
position UnityEngine.Rect
prop MaterialProperty
label string
tooltip string
return UnityEngine.Texture
Exemplo n.º 1
0
        // Helper to show texture and color properties
        public static Rect TextureColorProps(MaterialEditor materialEditor, GUIContent label, MaterialProperty textureProp, MaterialProperty colorProp, bool hdr = false)
        {
            Rect rect = EditorGUILayout.GetControlRect();

            EditorGUI.showMixedValue = textureProp.hasMixedValue;
            materialEditor.TexturePropertyMiniThumbnail(rect, textureProp, label.text, label.tooltip);
            EditorGUI.showMixedValue = false;

            if (colorProp != null)
            {
                EditorGUI.BeginChangeCheck();
                EditorGUI.showMixedValue = colorProp.hasMixedValue;
                int indentLevel = EditorGUI.indentLevel;
                EditorGUI.indentLevel = 0;
                Rect rectAfterLabel = new Rect(rect.x + EditorGUIUtility.labelWidth, rect.y,
                                               EditorGUIUtility.fieldWidth, EditorGUIUtility.singleLineHeight);
                var col = EditorGUI.ColorField(rectAfterLabel, GUIContent.none, colorProp.colorValue, true,
                                               false, hdr);
                EditorGUI.indentLevel = indentLevel;
                if (EditorGUI.EndChangeCheck())
                {
                    materialEditor.RegisterPropertyChangeUndo(colorProp.displayName);
                    colorProp.colorValue = col;
                }
                EditorGUI.showMixedValue = false;
            }

            return(rect);
        }
    override public void OnGUI(Rect position, MaterialProperty prop, string label, MaterialEditor editor) {
        //Debug.Log("OnGUI: " + label + " RTP_MaterialProp");

        if (!parsed)
        {
            parsed = true;
            parsedLabel = RTP_MatPropStringParser.Parse(label);
        }
        label = parsedLabel;

        if (editor is RTP_CustomShaderGUI)
        {
            RTP_CustomShaderGUI customEditor = editor as RTP_CustomShaderGUI;

            if (customEditor.showFlag && (show_for_active_layer == -1 || customEditor.active_layer == show_for_active_layer) && prop.name!= "dummy_end") {

                EditorGUI.BeginDisabledGroup(customEditor.inactiveFlag);

                switch (prop.type)
                {
                    //case MaterialProperty.PropType.Range: // float ranges
                    //    {
                    //        editor.RangeProperty(position, prop, label);
                    //        break;
                    //    }
                    //case MaterialProperty.PropType.Float: // floats
                    //    {
                    //        editor.FloatProperty(position, prop, label);
                    //        break;
                    //    }
                    case MaterialProperty.PropType.Color: // colors
                        {
                            EditorGUIUtility.labelWidth -= 30;
                            if (noAlphaFlag)
                            {
                                EditorGUI.ColorField(position, new GUIContent(label, ""), prop.colorValue, true, false, false, null);
                            }
                            else
                            {
                                editor.ColorProperty(position, prop, label);
                            }
                            break;
                        }
                    case MaterialProperty.PropType.Texture: // textures
                        {
                            EditorGUI.BeginChangeCheck();
                            if (miniThumbFlag)
                            {
                                editor.TexturePropertyMiniThumbnail(position, prop, label,"");
                            } else
                            {
                                editor.TextureProperty(position, prop, label, !noTileOffsetFlag);
                            }
                            if (EditorGUI.EndChangeCheck() && prop.textureValue!=null && sharedTextures!=null)
                            {
                                for(int j=0; j<sharedTextures.Length; j++)
                                {
                                    foreach(Material mat in editor.targets)
                                    {
                                        if (mat.HasProperty(sharedTextures[j]))
                                        {
                                            mat.SetTexture(sharedTextures[j], prop.textureValue);
                                        }
                                    }
                                }
                            }
                            break;
                        }
                    case MaterialProperty.PropType.Vector: // vectors
                        {
                            if (byLayerFlag)
                            {
                                //
                                // affect single vector component depending on active layer
                                //
                                int layerNum = customEditor.active_layer;
                                float pval = prop.vectorValue[layerNum];
                                float nval;
                                if (minVal == maxVal)
                                {
                                    // float
                                    EditorGUIUtility.labelWidth -= 23;
                                    nval = EditorGUI.FloatField(position, label, pval);
                                }
                                else
                                {
                                    // slider
                                    EditorGUIUtility.labelWidth = 160;
                                    nval = EditorGUI.Slider(position, label, pval, minVal, maxVal);
                                }
                                if (pval!=nval)
                                {
                                    for(int i=0; i< prop.targets.Length; i++)
                                    {
                                        Material mat = (prop.targets[i] as Material);
                                        Vector4 vec = mat.GetVector(prop.name);
                                        vec[layerNum] = nval;
                                        mat.SetVector(prop.name, vec);
                                    }
                                }
                            }
                            else
                            {
                                position.x += 12;
                                position.width -= 12;
                                editor.VectorProperty(position, prop, label);
                            }
                            break;
                        }
                    default:
                        {
                            if (customEditor.nextLabelWidth>0)
                            {
                                EditorGUIUtility.labelWidth = customEditor.nextLabelWidth;
                                customEditor.nextLabelWidth = 0;
                            } else
                            {
                                EditorGUIUtility.labelWidth -= 30;
                            }
                            editor.DefaultShaderProperty(position, prop, label);
                            break;
                        }
                }

			    EditorGUI.EndDisabledGroup();
		    }
        }

    }