Example #1
0
 public bool IsNumeric(PatternParameter param)
 {
     if (param == null)
     {
         return(false);
     }
     if (param.paramType == ParamType.FLOAT || param.paramType == ParamType.INT)
     {
         return(true);
     }
     return(false);
 }
Example #2
0
    public int GetRows(PatternParameter param)
    {
        //1 row for name + type
        //1 row for controllable
        //1 row for default
        int rowcount = 3;

        if (param != null && param.input)
        {
            rowcount++;
            if (IsNumeric(param))
            {
                //+1 row for "useRange"
                rowcount++;
                if (param.useRange)
                {
                    //+1 row for min/max
                    rowcount++;
                }
            }
        }
        return(rowcount);
    }
Example #3
0
    public override float GetPropertyHeight(SerializedProperty prop, GUIContent label)
    {
        PatternParameter param = PropToParam(prop);

        return(base.GetPropertyHeight(prop, label) + GetRows(param) * rowHeight);
    }
Example #4
0
    public override void OnGUI(Rect position, SerializedProperty property, GUIContent label)
    {
        PatternParameter param = PropToParam(property);
        int rowsFilled         = 0;
        var lineRect           = new Rect(position.x, position.y + 0.5f, position.width, 0.5f);

        EditorGUI.DrawRect(lineRect, Color.black);

        EditorGUI.BeginProperty(position, label, property);

        // Draw label
        //position = EditorGUI.PrefixLabel(position, GUIUtility.GetControlID(FocusType.Passive), new GUIContent("Name"));
        position = new Rect(position.x, position.y + 4.5f, position.width, position.height);
        float width = position.width;


        var nameRect = new Rect(position.x, YOffset(rowsFilled, position.y),
                                3 * width / 4, rowHeight);

        var typeRect = new Rect(position.x + 3 * width / 4, YOffset(rowsFilled, position.y),
                                width / 4, rowHeight);

        var nameProp = property.FindPropertyRelative("name");
        var typeProp = property.FindPropertyRelative("paramType");

        EditorGUI.PropertyField(nameRect, nameProp);
        EditorGUI.PropertyField(typeRect, typeProp, GUIContent.none);
        rowsFilled++;

        //var controllableRect = new Rect(position.x, YOffset(rowsFilled, position.y),
        //                                width, rowHeight);
        //var controllableProp = property.FindPropertyRelative("input");
        //EditorGUI.PropertyField(controllableRect, controllableProp);
        //rowsFilled++;
        var passToShaderRect = new Rect(position.x, YOffset(rowsFilled, position.y), width, rowHeight);
        var passToShaderProp = property.FindPropertyRelative("passToShader");

        EditorGUI.PropertyField(passToShaderRect, passToShaderProp);
        rowsFilled++;
        if (param != null && param.input)
        {
            if (IsNumeric(param))
            {
                var rangeRect = new Rect(position.x, YOffset(rowsFilled, position.y), width, rowHeight);
                var rangeProp = property.FindPropertyRelative("useRange");
                EditorGUI.PropertyField(rangeRect, rangeProp);
                rowsFilled++;
                if (param.useRange)
                {
                    var minRect = new Rect(position.x, YOffset(rowsFilled, position.y), width / 2, rowHeight);
                    var maxRect = new Rect(position.x + width / 2, YOffset(rowsFilled, position.y), width / 2, rowHeight);
                    SerializedProperty minProp;
                    SerializedProperty maxProp;
                    if (param.paramType == ParamType.FLOAT)
                    {
                        minProp = property.FindPropertyRelative("minFloat");
                        maxProp = property.FindPropertyRelative("maxFloat");
                    }
                    else
                    {
                        minProp = property.FindPropertyRelative("minInt");
                        maxProp = property.FindPropertyRelative("maxInt");
                    }
                    EditorGUI.PropertyField(minRect, minProp, new GUIContent("Min"));
                    EditorGUI.PropertyField(maxRect, maxProp, new GUIContent("Max"));
                    rowsFilled++;
                }

                var defaultRect = new Rect(position.x, YOffset(rowsFilled, position.y), position.width, rowHeight);
                SerializedProperty defaultProp;
                if (param != null)
                {
                    switch (param.paramType)
                    {
                    case (ParamType.BOOL):
                        defaultProp = property.FindPropertyRelative("defaultBool");
                        break;

                    case (ParamType.INT):
                        defaultProp = property.FindPropertyRelative("defaultInt");
                        break;

                    case (ParamType.FLOAT4):
                        defaultProp = property.FindPropertyRelative("defaultVector");
                        break;

                    case (ParamType.TEX):
                        defaultProp = property.FindPropertyRelative("defaultTexture");
                        break;

                    default:
                        defaultProp = property.FindPropertyRelative("defaultFloat");
                        break;
                    }
                    EditorGUI.PropertyField(defaultRect, defaultProp, new GUIContent("Default"));
                }
            }
        }
        EditorGUI.EndProperty();
    }
Example #5
0
    void OnWizardUpdate()
    {
        helpString = "Create new node";

        PatternParameter sigInput = null, sigOutput = null, texInput = null, texOutput = null;

        // Add pattern parameters for a given set of styles.
        if (template != oldTemplate)
        {
            oldTemplate = template;
            switch (template)
            {
            case NodeTemplate.SignalFilter:
                defaultSize = new Vector2(150, 100);
                inputs      = new PatternParameter[1];
                outputs     = new PatternParameter[1];
                sigInput    = new PatternParameter()
                {
                    name      = "inputSignal",
                    input     = true,
                    paramType = ParamType.FLOAT,
                    useRange  = true,
                    minFloat  = 0,
                    maxFloat  = 1,
                };
                sigOutput = new PatternParameter()
                {
                    name      = "outputSignal",
                    input     = false,
                    paramType = ParamType.FLOAT,
                    useRange  = false,
                };
                inputs[0]      = sigInput;
                outputs[0]     = sigOutput;
                generateShader = false;
                break;

            case NodeTemplate.SignalGenerator:
                defaultSize = new Vector2(150, 100);
                inputs      = new PatternParameter[0];
                outputs     = new PatternParameter[1];
                sigOutput   = new PatternParameter()
                {
                    name      = "outputSignal",
                    input     = true,
                    paramType = ParamType.FLOAT,
                    useRange  = true,
                    minFloat  = 0,
                    maxFloat  = 1,
                };
                outputs[0]     = sigOutput;
                generateShader = false;
                break;

            case NodeTemplate.TextureFilter:
                defaultSize = new Vector2(200, 200);
                inputs      = new PatternParameter[1];
                outputs     = new PatternParameter[1];
                texInput    = new PatternParameter()
                {
                    name         = "inputTex",
                    input        = true,
                    passToShader = true,
                    paramType    = ParamType.TEX,
                };
                texOutput = new PatternParameter()
                {
                    name         = "outputTex",
                    input        = false,
                    passToShader = true,
                    paramType    = ParamType.TEX,
                    useRange     = false,
                };
                inputs[0]      = texInput;
                outputs[0]     = texOutput;
                generateShader = true;
                break;

            case NodeTemplate.TextureGenerator:
                defaultSize = new Vector2(200, 200);
                inputs      = new PatternParameter[0];
                outputs     = new PatternParameter[1];
                texOutput   = new PatternParameter()
                {
                    name         = "outputTex",
                    input        = false,
                    passToShader = true,
                    paramType    = ParamType.TEX,
                    useRange     = false,
                };
                outputs[0]     = texOutput;
                generateShader = true;
                break;

            case NodeTemplate.Custom:
                break;
            }
        }
        if (inputs != null)
        {
            foreach (var param in inputs)
            {
                param.input = true;
            }
        }
        if (outputs != null)
        {
            foreach (var param in outputs)
            {
                param.input = false;
            }
        }
    }