コード例 #1
0
    public override MegaLoftLayerBase Copy(GameObject go)
    {
        MegaLoftLayerMultiMat layer = go.AddComponent <MegaLoftLayerMultiMat>();

        //meshsections = new List<MegaMeshSection>();	//null;	//.Clear();

        Copy(this, layer);

        layer.meshsections = new List <MegaMeshSection>();              //.Clear();
        loftverts          = null;
        loftverts1         = null;
        loftuvs            = null;
        loftcols           = null;
        capStartVerts      = null;
        capStartUVS        = null;
        capStartCols       = null;
        capEndVerts        = null;
        capEndUVS          = null;
        capEndCols         = null;
        capStartTris       = null;
        capEndTris         = null;
        lofttris           = null;

        return(null);
    }
コード例 #2
0
    public override void OnInspectorGUI()
    {
        MegaLoftLayerMultiMat layer = (MegaLoftLayerMultiMat)target;
        MegaShapeLoft         loft  = layer.GetComponent <MegaShapeLoft>();

        if (loft && loft.undo)
        {
            undoManager.CheckUndo();
        }

        DisplayGUI();
        CommonGUI();

        if (GUI.changed)
        {
            if (loft)
            {
                loft.rebuild = true;
                EditorUtility.SetDirty(loft);
            }

            if (layer)
            {
                EditorUtility.SetDirty(layer);
            }
        }
        if (loft && loft.undo)
        {
            undoManager.CheckDirty();
        }
    }
コード例 #3
0
    void DisplayMaterialSections(MegaLoftLayerMultiMat layer)
    {
        if (GUILayout.Button("Add Material"))
        {
            MegaMaterialSection ms = new MegaMaterialSection();
            layer.sections.Add(ms);
            EditorUtility.SetDirty(target);
        }

        for (int i = 0; i < layer.sections.Count; i++)
        {
            MegaMaterialSection ms = layer.sections[i];


            string name = "Mat " + ms.id;
            if (ms.mat)
            {
                name += " " + ms.mat.name;
            }

            EditorGUILayout.BeginVertical("box");
            ms.show = EditorGUILayout.Foldout(ms.show, name);
            if (ms.show)
            {
                ms.Enabled      = EditorGUILayout.BeginToggleGroup("Enabled", ms.Enabled);
                ms.id           = EditorGUILayout.IntField("ID", ms.id);
                ms.mat          = (Material)EditorGUILayout.ObjectField("Material", ms.mat, typeof(Material), true);
                ms.cdist        = EditorGUILayout.Slider(MegaToolTip.CrossDist, ms.cdist, cdl, cdh);            //0.025f, 1.0f);
                ms.includeknots = EditorGUILayout.Toggle("Include Knots", ms.includeknots);

                //ms.vertscale = EditorGUILayout.FloatField("Vert Scale", ms.vertscale);
                ms.UVOffset = EditorGUILayout.Vector2Field("UV Offset", ms.UVOffset);
                ms.UVScale  = EditorGUILayout.Vector2Field("UV Scale", ms.UVScale);
                ms.swapuv   = EditorGUILayout.Toggle(MegaToolTip.SwapUV, ms.swapuv);
                ms.physuv   = EditorGUILayout.Toggle(MegaToolTip.PhysicalUV, ms.physuv);
                ms.uvcalcy  = EditorGUILayout.Toggle("Calc Y", ms.uvcalcy);

                ms.colmode   = (MegaLoftColMode)EditorGUILayout.EnumPopup("Color Mode", ms.colmode);
                ms.coloffset = EditorGUILayout.FloatField("Offset", ms.coloffset);
                ms.color     = EditorGUILayout.ColorField("Color", ms.color);
                ms.colR      = EditorGUILayout.CurveField("Red", ms.colR);
                ms.colG      = EditorGUILayout.CurveField("Green", ms.colG);
                ms.colB      = EditorGUILayout.CurveField("Blue", ms.colB);
                ms.colA      = EditorGUILayout.CurveField("Alpha", ms.colA);

                EditorGUILayout.EndToggleGroup();

                if (i > 0)
                {
                    if (GUILayout.Button("Delete"))
                    {
                        layer.sections.RemoveAt(i);
                        EditorUtility.SetDirty(target);
                    }
                }
            }
            EditorGUILayout.EndVertical();
        }
    }
コード例 #4
0
    void OnGUI()
    {
        if (Selection.activeGameObject == null)
        {
            return;
        }

        MegaShapeLoft loft = Selection.activeGameObject.GetComponent <MegaShapeLoft>();

        if (loft == null)
        {
            return;
        }

        lofttype  = (MegaLoftType)EditorGUILayout.EnumPopup("Type", lofttype);
        LayerName = EditorGUILayout.TextField("Name", LayerName);
        start     = EditorGUILayout.FloatField("Start", start);
        length    = EditorGUILayout.FloatField("Length", length);
        paramCol  = EditorGUILayout.ColorField("Param Col", paramCol);

        EditorStyles.textField.wordWrap = true;

        switch (lofttype)
        {
        case MegaLoftType.Simple:
            EditorGUILayout.TextArea("Basic Loft layer that uses a single spline for the path and another spline for the cross section", GUILayout.Height(50.0f));
            path     = (MegaShape)EditorGUILayout.ObjectField("Path", path, typeof(MegaShape), true);
            section  = (MegaShape)EditorGUILayout.ObjectField("Section", section, typeof(MegaShape), true);
            material = (Material)EditorGUILayout.ObjectField("Material", material, typeof(Material), true);
            break;

        //case MegaLoftType.Collider:
        //	colliderwidth = EditorGUILayout.FloatField("Collider Width", colliderwidth);
        //	break;

        case MegaLoftType.CloneSimple:
            EditorGUILayout.TextArea("Clone a mesh onto a surface with options for start, end and main meshes", GUILayout.Height(50.0f));
            startObjMesh = (Mesh)EditorGUILayout.ObjectField("Start Obj", startObjMesh, typeof(Mesh), true);
            mainObjMesh  = (Mesh)EditorGUILayout.ObjectField("Main Obj", mainObjMesh, typeof(Mesh), true);
            endObjMesh   = (Mesh)EditorGUILayout.ObjectField("End Obj", endObjMesh, typeof(Mesh), true);
            surfaceLoft  = (MegaShapeLoft)EditorGUILayout.ObjectField("Surface", surfaceLoft, typeof(MegaShapeLoft), true);
            surfaceLayer = EditorGUILayout.Popup("Layer", surfaceLayer + 1, MegaShapeUtils.GetLayers(surfaceLoft)) - 1;
            material     = (Material)EditorGUILayout.ObjectField("Material", material, typeof(Material), true);
            break;

        case MegaLoftType.ScatterSimple:
            EditorGUILayout.TextArea("Scatters a choosen mesh and material over a surface", GUILayout.Height(50.0f));
            mainObjMesh  = (Mesh)EditorGUILayout.ObjectField("Obj", mainObjMesh, typeof(Mesh), true);
            surfaceLoft  = (MegaShapeLoft)EditorGUILayout.ObjectField("Surface", surfaceLoft, typeof(MegaShapeLoft), true);
            surfaceLayer = EditorGUILayout.Popup("Layer", surfaceLayer + 1, MegaShapeUtils.GetLayers(surfaceLoft)) - 1;
            material     = (Material)EditorGUILayout.ObjectField("Material", material, typeof(Material), true);
            break;

        case MegaLoftType.Scatter:
            EditorGUILayout.TextArea("Builds a mesh layer by scattering a choosen object over a surface", GUILayout.Height(50.0f));
            mainObj      = (GameObject)EditorGUILayout.ObjectField("Obj", mainObj, typeof(Mesh), true);
            mainObj      = MegaMeshCheck.ValidateObj(mainObj);
            surfaceLoft  = (MegaShapeLoft)EditorGUILayout.ObjectField("Surface", surfaceLoft, typeof(MegaShapeLoft), true);
            surfaceLayer = EditorGUILayout.Popup("Layer", surfaceLayer + 1, MegaShapeUtils.GetLayers(surfaceLoft)) - 1;
            break;

        case MegaLoftType.ScatterSpline:
            EditorGUILayout.TextArea("Build a mesh by scattering a choosen mesh and material along a spline", GUILayout.Height(50.0f));
            path        = (MegaShape)EditorGUILayout.ObjectField("Path", path, typeof(MegaShape), true);
            mainObjMesh = (Mesh)EditorGUILayout.ObjectField("Obj", mainObjMesh, typeof(Mesh), true);
            material    = (Material)EditorGUILayout.ObjectField("Material", material, typeof(Material), true);
            break;

        case MegaLoftType.Complex:
            EditorGUILayout.TextArea("Advanced lofter that uses a spline for the path and any number of cross section splines to define the loft", GUILayout.Height(50.0f));
            path     = (MegaShape)EditorGUILayout.ObjectField("Path", path, typeof(MegaShape), true);
            section  = (MegaShape)EditorGUILayout.ObjectField("Section", section, typeof(MegaShape), true);
            material = (Material)EditorGUILayout.ObjectField("Material", material, typeof(Material), true);
            break;

        case MegaLoftType.CloneSplineSimple:
            EditorGUILayout.TextArea("Clone a mesh along a spline with options for start, end and main meshes", GUILayout.Height(50.0f));
            path         = (MegaShape)EditorGUILayout.ObjectField("Path", path, typeof(MegaShape), true);
            startObjMesh = (Mesh)EditorGUILayout.ObjectField("Start Obj", startObjMesh, typeof(Mesh), true);
            //startObj = MegaMeshCheck.ValidateObj(startObj);
            mainObjMesh = (Mesh)EditorGUILayout.ObjectField("Main Obj", mainObjMesh, typeof(Mesh), true);
            //mainObj = MegaMeshCheck.ValidateObj(mainObj);
            endObjMesh = (Mesh)EditorGUILayout.ObjectField("End Obj", endObjMesh, typeof(Mesh), true);
            //endObj = MegaMeshCheck.ValidateObj(endObj);
            material = (Material)EditorGUILayout.ObjectField("Material", material, typeof(Material), true);
            break;

        case MegaLoftType.Clone:
            EditorGUILayout.TextArea("Clone a mesh onto a surface with options for start, end and main meshes", GUILayout.Height(50.0f));
            startObj     = (GameObject)EditorGUILayout.ObjectField("Start Obj", startObj, typeof(GameObject), true);
            startObj     = MegaMeshCheck.ValidateObj(startObj);
            mainObj      = (GameObject)EditorGUILayout.ObjectField("Main Obj", mainObj, typeof(GameObject), true);
            mainObj      = MegaMeshCheck.ValidateObj(mainObj);
            endObj       = (GameObject)EditorGUILayout.ObjectField("End Obj", endObj, typeof(GameObject), true);
            endObj       = MegaMeshCheck.ValidateObj(endObj);
            surfaceLoft  = (MegaShapeLoft)EditorGUILayout.ObjectField("Surface", surfaceLoft, typeof(MegaShapeLoft), true);
            surfaceLayer = EditorGUILayout.Popup("Layer", surfaceLayer + 1, MegaShapeUtils.GetLayers(surfaceLoft)) - 1;
            material     = (Material)EditorGUILayout.ObjectField("Material", material, typeof(Material), true);

            break;

        case MegaLoftType.CloneSpline:
            EditorGUILayout.TextArea("Build a mesh layer by cloning objects along a spline with options for start, end and main objects", GUILayout.Height(50.0f));
            path     = (MegaShape)EditorGUILayout.ObjectField("Path", path, typeof(MegaShape), true);
            startObj = (GameObject)EditorGUILayout.ObjectField("Start Obj", startObj, typeof(GameObject), true);
            startObj = MegaMeshCheck.ValidateObj(startObj);
            mainObj  = (GameObject)EditorGUILayout.ObjectField("Main Obj", mainObj, typeof(GameObject), true);
            mainObj  = MegaMeshCheck.ValidateObj(mainObj);
            endObj   = (GameObject)EditorGUILayout.ObjectField("End Obj", endObj, typeof(GameObject), true);
            endObj   = MegaMeshCheck.ValidateObj(endObj);
            break;

        case MegaLoftType.CloneRules:
            EditorGUILayout.TextArea("Rule based clone onto a surface", GUILayout.Height(50.0f));
            //path = (MegaShape)EditorGUILayout.ObjectField("Path", path, typeof(MegaShape), true);
            surfaceLoft  = (MegaShapeLoft)EditorGUILayout.ObjectField("Surface", surfaceLoft, typeof(MegaShapeLoft), true);
            surfaceLayer = EditorGUILayout.Popup("Layer", surfaceLayer + 1, MegaShapeUtils.GetLayers(surfaceLoft)) - 1;
            break;

        case MegaLoftType.CloneSplineRules:
            EditorGUILayout.TextArea("Rule based clone along a spline", GUILayout.Height(50.0f));
            path         = (MegaShape)EditorGUILayout.ObjectField("Path", path, typeof(MegaShape), true);
            surfaceLoft  = (MegaShapeLoft)EditorGUILayout.ObjectField("Surface", surfaceLoft, typeof(MegaShapeLoft), true);
            surfaceLayer = EditorGUILayout.Popup("Layer", surfaceLayer + 1, MegaShapeUtils.GetLayers(surfaceLoft)) - 1;
            break;

#if true
        case MegaLoftType.MultiMaterial:
            EditorGUILayout.TextArea("Will create a loft using multiple materials based on material ids in the spline knots. It uses a single spline for the path and another spline for the cross section", GUILayout.Height(50.0f));
            path     = (MegaShape)EditorGUILayout.ObjectField("Path", path, typeof(MegaShape), true);
            section  = (MegaShape)EditorGUILayout.ObjectField("Section", section, typeof(MegaShape), true);
            material = (Material)EditorGUILayout.ObjectField("Material", material, typeof(Material), true);
            break;

        case MegaLoftType.MultiMaterialComplex:
            EditorGUILayout.TextArea("Will create a complex loft using multiple materials based on material ids in the spline knots. It uses a single spline for the path and another spline for the cross section", GUILayout.Height(50.0f));
            path     = (MegaShape)EditorGUILayout.ObjectField("Path", path, typeof(MegaShape), true);
            section  = (MegaShape)EditorGUILayout.ObjectField("Section", section, typeof(MegaShape), true);
            material = (Material)EditorGUILayout.ObjectField("Material", material, typeof(Material), true);
            break;
#endif
        }

        EditorStyles.textField.wordWrap = false;

        EditorGUILayout.BeginHorizontal();
        if (GUILayout.Button("Create"))
        {
            MegaLoftLayerBase laybase = null;

            switch (lofttype)
            {
            case MegaLoftType.Simple:
            {
                MegaLoftLayerSimple layer = Selection.activeGameObject.AddComponent <MegaLoftLayerSimple>();
                layer.pathStart    = start;
                layer.pathLength   = length;
                layer.layerPath    = path;
                layer.layerSection = section;
                laybase            = layer;
            }
            break;

            case MegaLoftType.CloneSimple:
            {
                MegaLoftLayerCloneSimple layer = Selection.activeGameObject.AddComponent <MegaLoftLayerCloneSimple>();
                layer.startObj     = startObjMesh;
                layer.mainObj      = mainObjMesh;
                layer.endObj       = endObjMesh;
                layer.surfaceLoft  = surfaceLoft;
                layer.surfaceLayer = surfaceLayer;
                laybase            = layer;
            }
            break;

            case MegaLoftType.ScatterSimple:
            {
                MegaLoftLayerScatterSimple layer = Selection.activeGameObject.AddComponent <MegaLoftLayerScatterSimple>();
                layer.scatterMesh  = mainObjMesh;
                layer.surfaceLoft  = surfaceLoft;
                layer.surfaceLayer = surfaceLayer;
                laybase            = layer;
            }
            break;

            case MegaLoftType.Scatter:
            {
                MegaLoftLayerScatter layer = Selection.activeGameObject.AddComponent <MegaLoftLayerScatter>();
                layer.mainObj      = mainObj;
                layer.surfaceLoft  = surfaceLoft;
                layer.surfaceLayer = surfaceLayer;
                laybase            = layer;
            }
            break;

            case MegaLoftType.ScatterSpline:
            {
                MegaLoftLayerScatterSpline layer = Selection.activeGameObject.AddComponent <MegaLoftLayerScatterSpline>();
                layer.scatterMesh = mainObjMesh;
                layer.layerPath   = path;
                laybase           = layer;
            }
            break;

            case MegaLoftType.Complex:
            {
                MegaLoftLayerComplex layer = Selection.activeGameObject.AddComponent <MegaLoftLayerComplex>();
                layer.layerPath    = path;
                layer.layerSection = section;
                laybase            = layer;
            }
            break;

            case MegaLoftType.CloneSplineSimple:
            {
                MegaLoftLayerCloneSplineSimple layer = Selection.activeGameObject.AddComponent <MegaLoftLayerCloneSplineSimple>();
                layer.layerPath = path;
                layer.startObj  = startObjMesh;
                layer.mainObj   = mainObjMesh;
                layer.endObj    = endObjMesh;
                laybase         = layer;
            }
            break;

            case MegaLoftType.CloneSpline:
            {
                MegaLoftLayerCloneSpline layer = Selection.activeGameObject.AddComponent <MegaLoftLayerCloneSpline>();
                layer.layerPath = path;
                layer.startObj  = startObj;
                layer.mainObj   = mainObj;
                layer.endObj    = endObj;
                laybase         = layer;
            }
            break;

            case MegaLoftType.Clone:
            {
                MegaLoftLayerClone layer = Selection.activeGameObject.AddComponent <MegaLoftLayerClone>();
                layer.surfaceLoft  = surfaceLoft;
                layer.surfaceLayer = surfaceLayer;
                layer.startObj     = startObj;
                layer.mainObj      = mainObj;
                layer.endObj       = endObj;
                laybase            = layer;
            }
            break;

            case MegaLoftType.CloneRules:
            {
                MegaLoftLayerCloneRules layer = Selection.activeGameObject.AddComponent <MegaLoftLayerCloneRules>();
                layer.surfaceLoft  = surfaceLoft;
                layer.surfaceLayer = surfaceLayer;
                //layer.layerPath = path;
                //layer.layerSection = section;
                laybase = layer;
            }
            break;

            case MegaLoftType.CloneSplineRules:
            {
                MegaLoftLayerCloneSplineRules layer = Selection.activeGameObject.AddComponent <MegaLoftLayerCloneSplineRules>();
                layer.layerPath = path;
                laybase         = layer;
            }
            break;

#if true
            case MegaLoftType.MultiMaterial:
            {
                MegaLoftLayerMultiMat layer = Selection.activeGameObject.AddComponent <MegaLoftLayerMultiMat>();
                layer.pathStart    = start;
                layer.pathLength   = length;
                layer.layerPath    = path;
                layer.layerSection = section;
                MegaMaterialSection ms = new MegaMaterialSection();
                ms.mat = material;
                layer.sections.Add(ms);
                laybase = layer;
            }
            break;

            // We should add two loft sections
            // if cross has multiple splines add them all equally spaced?
            case MegaLoftType.MultiMaterialComplex:
            {
                MegaLoftLayerMultiMatComplex layer = Selection.activeGameObject.AddComponent <MegaLoftLayerMultiMatComplex>();
                layer.pathStart    = start;
                layer.pathLength   = length;
                layer.layerPath    = path;
                layer.layerSection = section;
                MegaMaterialSection ms = new MegaMaterialSection();
                ms.mat = material;
                layer.sections.Add(ms);
                laybase = layer;
            }
            break;
#endif
            default:
                EditorUtility.DisplayDialog("Layer Not Supported", "Currently this layer type is not not supported", "OK");
                break;
            }

            // Common params
            if (laybase)
            {
                laybase.paramcol  = paramCol;
                laybase.LayerName = LayerName;
                laybase.LayerName = LayerName;
                laybase.material  = material;
            }
            this.Close();
        }

        if (GUILayout.Button("Cancel"))
        {
            this.Close();
        }
        EditorGUILayout.EndHorizontal();
    }
コード例 #5
0
 private void OnEnable()
 {
     src         = target as MegaLoftLayerMultiMat;
     undoManager = new MegaUndo(src, "Multi Mat Layer Param");
 }
コード例 #6
0
    public void DisplayGUI()
    {
        MegaLoftLayerMultiMat layer = (MegaLoftLayerMultiMat)target;

        SetLimits(layer.gameObject);

        MegaShapeLoftEditor.PushCols();

        GUI.color           = Color.white;
        GUI.backgroundColor = layer.paramcol;
        GUI.contentColor    = Color.white;

        EditorGUILayout.BeginVertical("TextArea");

        if (GUILayout.Button("Reset All Curves"))
        {
            layer.InitCurves();
            GUI.changed = true;
            EditorUtility.SetDirty(target);
        }

        layer.LayerName    = EditorGUILayout.TextField(MegaToolTip.LayerName, layer.LayerName);
        layer.LayerEnabled = EditorGUILayout.Toggle(MegaToolTip.Enabled, layer.LayerEnabled);
        layer.paramcol     = EditorGUILayout.ColorField(MegaToolTip.ParamCol, layer.paramcol);

        if (layer.LayerEnabled)
        {
            layer.Lock = EditorGUILayout.Toggle(MegaToolTip.Lock, layer.Lock);

            if (!layer.Lock)
            {
                layer.material  = (Material)EditorGUILayout.ObjectField(MegaToolTip.Material, layer.material, typeof(Material), true);
                layer.layerPath = (MegaShape)EditorGUILayout.ObjectField(MegaToolTip.Path, layer.layerPath, typeof(MegaShape), true);

                if (layer.layerPath && layer.layerPath.splines != null)
                {
                    if (layer.layerPath.splines.Count > 1)
                    {
                        layer.curve = EditorGUILayout.IntSlider(MegaToolTip.Curve, layer.curve, 0, layer.layerPath.splines.Count - 1);
                    }
                    if (layer.curve < 0)
                    {
                        layer.curve = 0;
                    }
                    if (layer.curve > layer.layerPath.splines.Count - 1)
                    {
                        layer.curve = layer.layerPath.splines.Count - 1;
                    }
                }

                layer.pathStart  = EditorGUILayout.Slider(MegaToolTip.Start, layer.pathStart, sl, sh);
                layer.pathLength = EditorGUILayout.Slider(MegaToolTip.Length, layer.pathLength, ll, lh);
                layer.pathDist   = EditorGUILayout.Slider(MegaToolTip.Dist, layer.pathDist, dl, dh);

                EditorGUILayout.BeginVertical("Box");
                layer.offset = EditorGUILayout.Vector3Field("Offset", layer.offset);

                layer.useOffsetX = EditorGUILayout.BeginToggleGroup(MegaToolTip.UseOffsetX, layer.useOffsetX);
                layer.offsetCrvX = EditorGUILayout.CurveField(MegaToolTip.OffsetCrvX, layer.offsetCrvX);
                EditorGUILayout.EndToggleGroup();

                layer.useOffsetY = EditorGUILayout.BeginToggleGroup(MegaToolTip.UseOffsetY, layer.useOffsetY);
                layer.offsetCrvY = EditorGUILayout.CurveField(MegaToolTip.OffsetCrvY, layer.offsetCrvY);
                EditorGUILayout.EndToggleGroup();

                layer.useOffsetZ = EditorGUILayout.BeginToggleGroup(MegaToolTip.UseOffsetZ, layer.useOffsetZ);
                layer.offsetCrvZ = EditorGUILayout.CurveField(MegaToolTip.OffsetCrvZ, layer.offsetCrvZ);
                EditorGUILayout.EndToggleGroup();

                layer.frameMethod = (MegaFrameMethod)EditorGUILayout.EnumPopup("Frame Method", layer.frameMethod);
                layer.useTwistCrv = EditorGUILayout.BeginToggleGroup(MegaToolTip.UseTwist, layer.useTwistCrv);
                layer.twistAmt    = EditorGUILayout.FloatField(MegaToolTip.Twist, layer.twistAmt);
                layer.twistCrv    = EditorGUILayout.CurveField(MegaToolTip.TwistCrv, layer.twistCrv);
                EditorGUILayout.EndToggleGroup();

                //layer.color = EditorGUILayout.ColorField("Color", layer.color);
                //layer.colR = EditorGUILayout.CurveField("Red", layer.colR);
                //layer.colG = EditorGUILayout.CurveField("Green", layer.colG);
                //layer.colB = EditorGUILayout.CurveField("Blue", layer.colB);
                //layer.colA = EditorGUILayout.CurveField("Alpha", layer.colA);

                EditorGUILayout.EndVertical();

                DisplayMaterialSections(layer);

                //layer.showcrossparams = EditorGUILayout.Foldout(layer.showcrossparams, MegaToolTip.CrossParams);	//"Cross Params");
                layer.showcrossparams = MegaFoldOut.Start("Cross Params", layer.showcrossparams, new Color(0.5f, 1.0f, 0.5f));

                if (layer.showcrossparams)
                {
                    //EditorGUILayout.BeginVertical("Box");
                    layer.layerSection = (MegaShape)EditorGUILayout.ObjectField(MegaToolTip.Section, layer.layerSection, typeof(MegaShape), true);

                    if (layer.layerSection && layer.layerSection.splines != null)
                    {
                        if (layer.layerSection.splines.Count > 1)
                        {
                            layer.crosscurve = EditorGUILayout.IntSlider(MegaToolTip.Curve, layer.crosscurve, 0, layer.layerSection.splines.Count - 1);
                            layer.snap       = EditorGUILayout.Toggle(MegaToolTip.Snap, layer.snap);
                        }
                        if (layer.crosscurve < 0)
                        {
                            layer.crosscurve = 0;
                        }
                        if (layer.crosscurve > layer.layerSection.splines.Count - 1)
                        {
                            layer.crosscurve = layer.layerSection.splines.Count - 1;
                        }
                    }

                    //layer.alignCross = EditorGUILayout.Toggle("Align Cross", layer.alignCross);
                    layer.alignCross = EditorGUILayout.Slider("Align Cross", layer.alignCross, 0.0f, 1.0f);
                    layer.crossStart = EditorGUILayout.Slider(MegaToolTip.CrossStart, layer.crossStart, csl, csh);
                    layer.crossEnd   = EditorGUILayout.Slider(MegaToolTip.CrossLength, layer.crossEnd, cll, clh);
                    //layer.crossDist = EditorGUILayout.Slider(MegaToolTip.CrossDist, layer.crossDist, cdl, cdh);	//0.025f, 1.0f);

                    layer.crossRot   = EditorGUILayout.Vector3Field("Cross Rotate", layer.crossRot);
                    layer.crossScale = EditorGUILayout.Vector3Field("Cross Scale", layer.crossScale);
                    layer.pivot      = EditorGUILayout.Vector3Field("Pivot", layer.pivot);
                    //layer.includeknots = EditorGUILayout.Toggle(MegaToolTip.IncludeKnots, layer.includeknots);
                    layer.useCrossScaleCrv = EditorGUILayout.BeginToggleGroup(MegaToolTip.UseCrossScale, layer.useCrossScaleCrv);
                    layer.crossScaleCrv    = EditorGUILayout.CurveField(MegaToolTip.CrossScaleCrv, layer.crossScaleCrv);
                    layer.scaleoff         = EditorGUILayout.Slider(MegaToolTip.CrossOff, layer.scaleoff, -1.0f, 1.0f);
                    layer.sepscale         = EditorGUILayout.Toggle(MegaToolTip.SeperateScale, layer.sepscale);
                    EditorGUILayout.EndToggleGroup();

                    if (layer.sepscale)
                    {
                        layer.useCrossScaleCrvY = EditorGUILayout.BeginToggleGroup(MegaToolTip.UseCrossScaleY, layer.useCrossScaleCrvY);
                        layer.crossScaleCrvY    = EditorGUILayout.CurveField(MegaToolTip.CrossScaleCrvY, layer.crossScaleCrvY);
                        layer.scaleoffY         = EditorGUILayout.Slider(MegaToolTip.CrossOffY, layer.scaleoffY, -1.0f, 1.0f);
                        EditorGUILayout.EndToggleGroup();
                    }

                    //EditorGUILayout.EndVertical();
                }
                MegaFoldOut.End(layer.showcrossparams);

#if false
                //layer.showadvancedparams = EditorGUILayout.Foldout(layer.showadvancedparams, MegaToolTip.AdvancedParams);
                layer.showadvancedparams = MegaFoldOut.Start("Advanced Params", layer.showadvancedparams, new Color(0.5f, 0.5f, 1.0f));

                if (layer.showadvancedparams)
                {
                    //layer.optimize = EditorGUILayout.Toggle("Optimize", layer.optimize);
                    //layer.maxdeviation = EditorGUILayout.Slider("Max Deviation", layer.maxdeviation, 0.0f, 90.0f);
                    layer.flip    = EditorGUILayout.Toggle(MegaToolTip.Flip, layer.flip);
                    layer.snapTop = EditorGUILayout.BeginToggleGroup(MegaToolTip.SnapTop, layer.snapTop);
                    layer.Top     = EditorGUILayout.FloatField(MegaToolTip.Top, layer.Top);
                    EditorGUILayout.EndToggleGroup();

                    layer.snapBottom = EditorGUILayout.BeginToggleGroup(MegaToolTip.SnapBottom, layer.snapBottom);
                    layer.Bottom     = EditorGUILayout.FloatField(MegaToolTip.Bottom, layer.Bottom);
                    EditorGUILayout.EndToggleGroup();


                    layer.clipTop    = EditorGUILayout.BeginToggleGroup(MegaToolTip.ClipTop, layer.clipTop);
                    layer.clipTopVal = EditorGUILayout.FloatField(MegaToolTip.ClipTopVal, layer.clipTopVal);
                    EditorGUILayout.EndToggleGroup();

                    layer.clipBottom    = EditorGUILayout.BeginToggleGroup(MegaToolTip.ClipBottom, layer.clipBottom);
                    layer.clipBottomVal = EditorGUILayout.FloatField(MegaToolTip.ClipBottomVal, layer.clipBottomVal);
                    EditorGUILayout.EndToggleGroup();
                }
                MegaFoldOut.End(layer.showadvancedparams);
#endif

#if false
                //layer.showuvparams = EditorGUILayout.Foldout(layer.showuvparams, MegaToolTip.UVParams);
                layer.showuvparams = MegaFoldOut.Start("UV Params", layer.showuvparams, new Color(1.0f, 0.5f, 0.5f));

                if (layer.showuvparams)
                {
                    //EditorGUILayout.BeginVertical("Box");
                    MegaShapeLoftEditor.PushCols();
                    GUI.color = Color.white;

                    layer.UVOffset = EditorGUILayout.Vector2Field("UV Offset", layer.UVOffset);
                    layer.UVScale  = EditorGUILayout.Vector2Field("UV Scale", layer.UVScale);
                    layer.swapuv   = EditorGUILayout.Toggle(MegaToolTip.SwapUV, layer.swapuv);
                    layer.physuv   = EditorGUILayout.Toggle(MegaToolTip.PhysicalUV, layer.physuv);
                    layer.uvcalcy  = EditorGUILayout.Toggle("Calc Y", layer.uvcalcy);
                    layer.UVOrigin = (MegaLoftUVOrigin)EditorGUILayout.EnumPopup("UV origin", layer.UVOrigin);

                    layer.planarMapping = EditorGUILayout.BeginToggleGroup("Planar", layer.planarMapping);
                    layer.planarAxis    = (MegaAxis)EditorGUILayout.EnumPopup("Axis", layer.planarAxis);
                    //layer.planarWorld = EditorGUILayout.Toggle("World", layer.planarWorld);
                    layer.planarMode = (MegaPlanarMode)EditorGUILayout.EnumPopup("Mode", layer.planarMode);
                    bool lockWorld = EditorGUILayout.Toggle("Lock World", layer.lockWorld);
                    if (lockWorld != layer.lockWorld)
                    {
                        layer.lockWorld = lockWorld;
                        if (lockWorld)
                        {
                            layer.lockedTM = layer.transform.localToWorldMatrix;
                        }
                    }

                    EditorGUILayout.EndToggleGroup();

                    layer.sideViewUV   = EditorGUILayout.BeginToggleGroup("Side View", layer.sideViewUV);
                    layer.sideViewAxis = (MegaAxis)EditorGUILayout.EnumPopup("Side Axis", layer.sideViewAxis);
                    EditorGUILayout.EndToggleGroup();
                    MegaShapeLoftEditor.PopCols();
                    //EditorGUILayout.EndVertical();
                }
                MegaFoldOut.End(layer.showuvparams);
#endif

#if false
                //layer.showCapParams = EditorGUILayout.Foldout(layer.showCapParams, MegaToolTip.CapParams);
                layer.showCapParams = MegaFoldOut.Start("Cap Params", layer.showCapParams, new Color(1.0f, 1.0f, 0.5f));

                if (layer.showCapParams)
                {
                    layer.capflip          = EditorGUILayout.Toggle("Flip Caps", layer.capflip);
                    layer.capStart         = EditorGUILayout.BeginToggleGroup(MegaToolTip.CapStart, layer.capStart);
                    layer.capStartMat      = (Material)EditorGUILayout.ObjectField(MegaToolTip.CapStartMat, layer.capStartMat, typeof(Material), true);
                    layer.capStartUVOffset = EditorGUILayout.Vector2Field("UV Offset", layer.capStartUVOffset);
                    layer.capStartUVScale  = EditorGUILayout.Vector2Field("UV Scale", layer.capStartUVScale);
                    layer.capStartUVRot    = EditorGUILayout.FloatField(MegaToolTip.CapStartRot, layer.capStartUVRot);

                    EditorGUILayout.EndToggleGroup();

                    layer.capEnd         = EditorGUILayout.BeginToggleGroup(MegaToolTip.CapEnd, layer.capEnd);
                    layer.capEndMat      = (Material)EditorGUILayout.ObjectField(MegaToolTip.CapEndMat, layer.capEndMat, typeof(Material), true);
                    layer.capEndUVOffset = EditorGUILayout.Vector2Field("UV Offset", layer.capEndUVOffset);
                    layer.capEndUVScale  = EditorGUILayout.Vector2Field("UV Scale", layer.capEndUVScale);
                    layer.capEndUVRot    = EditorGUILayout.FloatField(MegaToolTip.CapEndRot, layer.capEndUVRot);
                    EditorGUILayout.EndToggleGroup();
                }
                MegaFoldOut.End(layer.showCapParams);
#endif
                layer.showConformParams = MegaFoldOut.Start("Conform Params", layer.showConformParams, new Color(1.0f, 1.0f, 0.5f));

                if (layer.showConformParams)
                {
                    layer.conform = EditorGUILayout.BeginToggleGroup("Conform", layer.conform);
                    GameObject contarget = (GameObject)EditorGUILayout.ObjectField("Target", layer.target, typeof(GameObject), true);

                    if (contarget != layer.target)
                    {
                        layer.SetTarget(contarget);
                    }
                    layer.conformAmount = EditorGUILayout.Slider("Amount", layer.conformAmount, 0.0f, 1.0f);
                    layer.raystartoff   = EditorGUILayout.FloatField("Ray Start Off", layer.raystartoff);
                    layer.conformOffset = EditorGUILayout.FloatField("Conform Offset", layer.conformOffset);
                    layer.raydist       = EditorGUILayout.FloatField("Ray Dist", layer.raydist);
                    EditorGUILayout.EndToggleGroup();
                }

                MegaFoldOut.End(layer.showConformParams);
            }
        }

        EditorGUILayout.EndVertical();
        MegaShapeLoftEditor.PopCols();
    }
コード例 #7
0
 private void OnEnable()
 {
     src = target as MegaLoftLayerMultiMat;
     undoManager = new MegaUndo(src, "Multi Mat Layer Param");
 }
コード例 #8
0
    void DisplayMaterialSections(MegaLoftLayerMultiMat layer)
    {
        if ( GUILayout.Button("Add Material") )
        {
            MegaMaterialSection ms = new MegaMaterialSection();
            layer.sections.Add(ms);
            EditorUtility.SetDirty(target);
        }

        for ( int i = 0; i < layer.sections.Count; i++ )
        {
            MegaMaterialSection ms = layer.sections[i];

            string name = "Mat " + ms.id;
            if ( ms.mat )
            {
                name += " " + ms.mat.name;
            }

            EditorGUILayout.BeginVertical("box");
            ms.show = EditorGUILayout.Foldout(ms.show, name);
            if ( ms.show )
            {
                ms.Enabled = EditorGUILayout.BeginToggleGroup("Enabled", ms.Enabled);
                ms.id = EditorGUILayout.IntField("ID", ms.id);
                ms.mat = (Material)EditorGUILayout.ObjectField("Material", ms.mat, typeof(Material), true);
                ms.cdist = EditorGUILayout.Slider(MegaToolTip.CrossDist, ms.cdist, cdl, cdh);	//0.025f, 1.0f);
                ms.includeknots = EditorGUILayout.Toggle("Include Knots", ms.includeknots);

                //ms.vertscale = EditorGUILayout.FloatField("Vert Scale", ms.vertscale);
                ms.UVOffset = EditorGUILayout.Vector2Field("UV Offset", ms.UVOffset);
                ms.UVScale = EditorGUILayout.Vector2Field("UV Scale", ms.UVScale);
                ms.swapuv = EditorGUILayout.Toggle(MegaToolTip.SwapUV, ms.swapuv);
                ms.physuv = EditorGUILayout.Toggle(MegaToolTip.PhysicalUV, ms.physuv);
                ms.uvcalcy = EditorGUILayout.Toggle("Calc Y", ms.uvcalcy);

                ms.colmode = (MegaLoftColMode)EditorGUILayout.EnumPopup("Color Mode", ms.colmode);
                ms.coloffset = EditorGUILayout.FloatField("Offset", ms.coloffset);
                ms.color = EditorGUILayout.ColorField("Color", ms.color);
                ms.colR = EditorGUILayout.CurveField("Red", ms.colR);
                ms.colG = EditorGUILayout.CurveField("Green", ms.colG);
                ms.colB = EditorGUILayout.CurveField("Blue", ms.colB);
                ms.colA = EditorGUILayout.CurveField("Alpha", ms.colA);

                EditorGUILayout.EndToggleGroup();

                if ( i > 0 )
                {
                    if ( GUILayout.Button("Delete") )
                    {
                        layer.sections.RemoveAt(i);
                        EditorUtility.SetDirty(target);
                    }
                }
            }
            EditorGUILayout.EndVertical();
        }
    }