示例#1
0
    //public GameObject meshRenderer;

    public override void OnInspectorGUI(NavGraph target)
    {
        NavMeshGraph graph = target as NavMeshGraph;

/*
 #if UNITY_3_3
 *              graph.sourceMesh = EditorGUILayout.ObjectField ("Source Mesh",graph.sourceMesh,typeof(Mesh)) as Mesh;
 #else
 *              graph.sourceMesh = EditorGUILayout.ObjectField ("Source Mesh",graph.sourceMesh,typeof(Mesh), true) as Mesh;
 #endif
 */
        graph.sourceMesh = ObjectField("Source Mesh", graph.sourceMesh, typeof(Mesh), false) as Mesh;

        EditorGUIUtility.LookLikeControls();
        EditorGUILayoutx.BeginIndent();
        graph.offset = EditorGUILayout.Vector3Field("Offset", graph.offset);
        EditorGUILayoutx.EndIndent();

        EditorGUILayoutx.BeginIndent();
        graph.rotation = EditorGUILayout.Vector3Field("Rotation", graph.rotation);
        EditorGUILayoutx.EndIndent();

        EditorGUIUtility.LookLikeInspector();

        graph.scale = EditorGUILayout.FloatField(new GUIContent("Scale", "Scale of the mesh"), graph.scale);
        graph.scale = (graph.scale <0.01F && graph.scale> -0.01F) ? (graph.scale >= 0 ? 0.01F : -0.01F) : graph.scale;

        graph.accurateNearestNode = EditorGUILayout.Toggle(new GUIContent("Accurate Nearest Node Queries", "More accurate nearest node queries. See docs for more info"), graph.accurateNearestNode);
    }
示例#2
0
    public override void OnInspectorGUI(NavGraph target)
    {
        PointGraph graph = target as PointGraph;

/*
 #if UNITY_3_3
 *              graph.root = (Transform)EditorGUILayout.ObjectField (new GUIContent ("Root","All childs of this object will be used as nodes, if it is not set, a tag search will be used instead (see below)"),graph.root,typeof(Transform));
 #else
 *              graph.root = (Transform)EditorGUILayout.ObjectField (new GUIContent ("Root","All childs of this object will be used as nodes, if it is not set, a tag search will be used instead (see below)"),graph.root,typeof(Transform),true);
 #endif
 */
        //Debug.Log (EditorGUI.indentLevel);

        graph.root = ObjectField(new GUIContent("Root", "All childs of this object will be used as nodes, if it is not set, a tag search will be used instead (see below)"), graph.root, typeof(Transform), true) as Transform;

        graph.recursive = EditorGUILayout.Toggle(new GUIContent("Recursive", "Should childs of the childs in the root GameObject be searched"), graph.recursive);
        graph.searchTag = EditorGUILayout.TagField(new GUIContent("Tag", "If root is not set, all objects with this tag will be used as nodes"), graph.searchTag);

        if (graph.root != null)
        {
            GUILayout.Label("All childs " + (graph.recursive ? "and sub-childs ":"") + "of 'root' will be used as nodes\nSet root to null to use a tag search instead", AstarPathEditor.helpBox);
        }
        else
        {
            GUILayout.Label("All object with the tag '" + graph.searchTag + "' will be used as nodes" + (graph.searchTag == "Untagged" ? "\nNote: the tag 'Untagged' cannot be used" : ""), AstarPathEditor.helpBox);
        }

        graph.maxDistance = EditorGUILayout.FloatField(new GUIContent("Max Distance", "The max distance in world space for a connection to be valid. A zero counts as infinity"), graph.maxDistance);

        EditorGUIUtility.LookLikeControls();
#if UNITY_4
        graph.limits = EditorGUILayout.Vector3Field("Max Distance (axis aligned)", graph.limits);
#else
        EditorGUILayoutx.BeginIndent();
        graph.limits = EditorGUILayout.Vector3Field("Max Distance (axis aligned)", graph.limits);
        EditorGUILayoutx.EndIndent();
#endif
        EditorGUIUtility.LookLikeInspector();

        graph.raycast = EditorGUILayout.Toggle(new GUIContent("Raycast", "Use raycasting to check if connections are valid between each pair of nodes"), graph.raycast);

        editor.GUILayoutx.BeginFadeArea(graph.raycast, "raycast");

        EditorGUI.indentLevel++;

        graph.thickRaycast = EditorGUILayout.Toggle(new GUIContent("Thick Raycast", "A thick raycast checks along a thick line with radius instead of just along a line"), graph.thickRaycast);

        editor.GUILayoutx.BeginFadeArea(graph.thickRaycast, "thickRaycast");

        graph.thickRaycastRadius = EditorGUILayout.FloatField(new GUIContent("Raycast Radius", "The radius in world units for the thick raycast"), graph.thickRaycastRadius);

        editor.GUILayoutx.EndFadeArea();

        //graph.mask = 1 << EditorGUILayout.LayerField ("Mask",(int)Mathf.Log (graph.mask,2));
        graph.mask = EditorGUILayoutx.LayerMaskField(/*new GUIContent (*/ "Mask" /*,"Used to mask which layers should be checked")*/, graph.mask);
        EditorGUI.indentLevel--;

        editor.GUILayoutx.EndFadeArea();
    }
示例#3
0
    /** Draws an integer field */
    public int IntField(GUIContent label, int value, int offset, int adjust, out Rect r, out bool selected)
    {
        GUIStyle intStyle = EditorStyles.numberField;

        EditorGUILayoutx.BeginIndent();
        Rect r1 = GUILayoutUtility.GetRect(label, intStyle);

        Rect r2 = GUILayoutUtility.GetRect(new GUIContent(value.ToString()), intStyle);

        EditorGUILayoutx.EndIndent();


        r2.width += (r2.x - r1.x);
        r2.x      = r1.x + offset;
        r2.width -= offset + offset + adjust;

        r        = new Rect();
        r.x      = r2.x + r2.width;
        r.y      = r1.y;
        r.width  = offset;
        r.height = r1.height;

        GUI.SetNextControlName("IntField_" + label.text);
        value = EditorGUI.IntField(r2, "", value);

        bool on = GUI.GetNameOfFocusedControl() == "IntField_" + label.text;

        selected = on;

        if (Event.current.type == EventType.Repaint)
        {
            intStyle.Draw(r1, label, false, false, false, on);
        }

        return(value);
    }
示例#4
0
    public override void OnInspectorGUI(NavGraph target)
    {
        GridGraph graph = target as GridGraph;

        //GUILayout.BeginHorizontal ();
        //GUILayout.BeginVertical ();
        Rect lockRect;
        Rect tmpLockRect;

        GUIStyle lockStyle = AstarPathEditor.astarSkin.FindStyle("GridSizeLock");

        if (lockStyle == null)
        {
            lockStyle = new GUIStyle();
        }

        bool sizeSelected1 = false;
        bool sizeSelected2 = false;

#if UNITY_4
        int newWidth = IntField(new GUIContent("Width (nodes)", "Width of the graph in nodes"), graph.width, 100, 0, out lockRect, out sizeSelected1);
        int newDepth = IntField(new GUIContent("Depth (nodes)", "Depth (or height you might also call it) of the graph in nodes"), graph.depth, 100, 0, out tmpLockRect, out sizeSelected2);
#else
        int newWidth = IntField(new GUIContent("Width (nodes)", "Width of the graph in nodes"), graph.width, 50, 0, out lockRect, out sizeSelected1);
        int newDepth = IntField(new GUIContent("Depth (nodes)", "Depth (or height you might also call it) of the graph in nodes"), graph.depth, 50, 0, out tmpLockRect, out sizeSelected2);
#endif

        //Rect r = GUILayoutUtility.GetRect (0,0,lockStyle);

        lockRect.width  = lockStyle.fixedWidth;
        lockRect.height = lockStyle.fixedHeight;
        lockRect.x     += lockStyle.margin.left;
        lockRect.y     += lockStyle.margin.top;

        locked = GUI.Toggle(lockRect, locked, new GUIContent("", "If the width and depth values are locked, changing the node size will scale the grid which keeping the number of nodes consistent instead of keeping the size the same and changing the number of nodes in the graph"), lockStyle);

        //GUILayout.EndHorizontal ();

        if (newWidth != graph.width || newDepth != graph.depth)
        {
            SnapSizeToNodes(newWidth, newDepth, graph);
        }

        GUI.SetNextControlName("NodeSize");
        newNodeSize = EditorGUILayout.FloatField(new GUIContent("Node size", "The size of a single node. The size is the side of the node square in world units"), graph.nodeSize);

        newNodeSize = newNodeSize <= 0.01F ? 0.01F : newNodeSize;

        float prevRatio = graph.aspectRatio;
        graph.aspectRatio = EditorGUILayout.FloatField(new GUIContent("Aspect Ratio", "Scaling of the nodes width/depth ratio. Good for isometric games"), graph.aspectRatio);


        //if ((GUI.GetNameOfFocusedControl () != "NodeSize" && Event.current.type == EventType.Repaint) || Event.current.keyCode == KeyCode.Return) {

        //Debug.Log ("Node Size Not Selected " + Event.current.type);

        if (graph.nodeSize != newNodeSize || prevRatio != graph.aspectRatio)
        {
            if (!locked)
            {
                graph.nodeSize = newNodeSize;
                Matrix4x4 oldMatrix = graph.matrix;
                graph.GenerateMatrix();
                if (graph.matrix != oldMatrix)
                {
                    //Rescann the graphs
                    //AstarPath.active.AutoScan ();
                    GUI.changed = true;
                }
            }
            else
            {
                float delta = newNodeSize / graph.nodeSize;
                graph.nodeSize      = newNodeSize;
                graph.unclampedSize = new Vector2(newWidth * graph.nodeSize, newDepth * graph.nodeSize);
                Vector3 newCenter = graph.matrix.MultiplyPoint3x4(new Vector3((newWidth / 2F) * delta, 0, (newDepth / 2F) * delta));
                graph.center = newCenter;
                graph.GenerateMatrix();

                //Make sure the width & depths stay the same
                graph.width = newWidth;
                graph.depth = newDepth;
                AstarPath.active.AutoScan();
            }
        }
        //}

        Vector3 pivotPoint;
        Vector3 diff;

        EditorGUIUtility.LookLikeControls();
#if !UNITY_4
        EditorGUILayoutx.BeginIndent();
#else
        GUILayout.BeginHorizontal();
#endif

        switch (pivot)
        {
        case GridPivot.Center:
            graph.center = EditorGUILayout.Vector3Field("Center", graph.center);
            break;

        case GridPivot.TopLeft:
            pivotPoint   = graph.matrix.MultiplyPoint3x4(new Vector3(0, 0, graph.depth));
            diff         = pivotPoint - graph.center;
            pivotPoint   = EditorGUILayout.Vector3Field("Top-Left", pivotPoint);
            graph.center = pivotPoint - diff;
            break;

        case GridPivot.TopRight:
            pivotPoint   = graph.matrix.MultiplyPoint3x4(new Vector3(graph.width, 0, graph.depth));
            diff         = pivotPoint - graph.center;
            pivotPoint   = EditorGUILayout.Vector3Field("Top-Right", pivotPoint);
            graph.center = pivotPoint - diff;
            break;

        case GridPivot.BottomLeft:
            pivotPoint   = graph.matrix.MultiplyPoint3x4(new Vector3(0, 0, 0));
            diff         = pivotPoint - graph.center;
            pivotPoint   = EditorGUILayout.Vector3Field("Bottom-Left", pivotPoint);
            graph.center = pivotPoint - diff;
            break;

        case GridPivot.BottomRight:
            pivotPoint   = graph.matrix.MultiplyPoint3x4(new Vector3(graph.width, 0, 0));
            diff         = pivotPoint - graph.center;
            pivotPoint   = EditorGUILayout.Vector3Field("Bottom-Right", pivotPoint);
            graph.center = pivotPoint - diff;
            break;
        }

        graph.GenerateMatrix();

        pivot = PivotPointSelector(pivot);

#if !UNITY_4
        EditorGUILayoutx.EndIndent();

        EditorGUILayoutx.BeginIndent();
#else
        GUILayout.EndHorizontal();
#endif

        graph.rotation = EditorGUILayout.Vector3Field("Rotation", graph.rotation);
        //Add some space to make the Rotation and postion fields be better aligned (instead of the pivot point selector)
        GUILayout.Space(19 + 7);
        //GUILayout.EndHorizontal ();

#if !UNITY_4
        EditorGUILayoutx.EndIndent();
#endif
        EditorGUIUtility.LookLikeInspector();

        if (GUILayout.Button(new GUIContent("Snap Size", "Snap the size to exactly fit nodes"), GUILayout.MaxWidth(100), GUILayout.MaxHeight(16)))
        {
            SnapSizeToNodes(newWidth, newDepth, graph);
        }

        Separator();

        graph.cutCorners = EditorGUILayout.Toggle(new GUIContent("Cut Corners", "Enables or disables cutting corners. See docs for image example"), graph.cutCorners);
        graph.neighbours = (NumNeighbours)EditorGUILayout.EnumPopup(new GUIContent("Connections", "Sets how many connections a node should have to it's neighbour nodes."), graph.neighbours);

        //GUILayout.BeginHorizontal ();
        //EditorGUILayout.PrefixLabel ("Max Climb");
        graph.maxClimb = EditorGUILayout.FloatField(new GUIContent("Max Climb", "How high, relative to the graph, should a climbable level be. A zero (0) indicates infinity"), graph.maxClimb);
        EditorGUI.indentLevel++;
        graph.maxClimbAxis = EditorGUILayout.IntPopup(new GUIContent("Climb Axis", "Determines which axis the above setting should test on"), graph.maxClimbAxis, new GUIContent[3] {
            new GUIContent("X"), new GUIContent("Y"), new GUIContent("Z")
        }, new int[3] {
            0, 1, 2
        });

        EditorGUI.indentLevel--;
        //GUILayout.EndHorizontal ();

        graph.maxSlope = EditorGUILayout.Slider(new GUIContent("Max Slope", "Sets the max slope in degrees for a point to be walkable. Only enabled if Height Testing is enabled."), graph.maxSlope, 0, 90F);

        graph.erodeIterations = EditorGUILayout.IntField(new GUIContent("Erode iterations", "Sets how many times the graph should be eroded. This adds extra margin to objects. This will not work when using Graph Updates, so if you can, use the Diameter setting in collision settings instead"), graph.erodeIterations);
        graph.erodeIterations = graph.erodeIterations > 16 ? 16 : graph.erodeIterations;         //Clamp iterations to 16

        graph.erosionUseTags = EditorGUILayout.Toggle(new GUIContent("Erosion Uses Tags", "Instead of making nodes unwalkable, " +
                                                                     "nodes will have their tag set to a value corresponding to their erosion level, " +
                                                                     "which is a quite good measurement of their distance to the closest wall."),
                                                      graph.erosionUseTags);
        if (graph.erosionUseTags)
        {
            EditorGUI.indentLevel++;
            graph.erosionFirstTag = EditorGUILayoutx.SingleTagField("First Tag", graph.erosionFirstTag);
            EditorGUI.indentLevel--;
        }

        DrawCollisionEditor(graph.collision);

        Separator();

        showExtra = EditorGUILayout.Foldout(showExtra, "Extra");

        if (showExtra)
        {
            EditorGUI.indentLevel += 2;

            graph.penaltyAngle = ToggleGroup(new GUIContent("Angle Penalty", "Adds a penalty based on the slope of the node"), graph.penaltyAngle);
            //bool preGUI = GUI.enabled;
            //GUI.enabled = graph.penaltyAngle && GUI.enabled;
            if (graph.penaltyAngle)
            {
                EditorGUI.indentLevel++;
                graph.penaltyAngleFactor = EditorGUILayout.FloatField(new GUIContent("Factor", "Scale of the penalty. A negative value should not be used"), graph.penaltyAngleFactor);
                //GUI.enabled = preGUI;
                HelpBox("Applies penalty to nodes based on the angle of the hit surface during the Height Testing");

                EditorGUI.indentLevel--;
            }

            graph.penaltyPosition = ToggleGroup("Position Penalty", graph.penaltyPosition);
            //EditorGUILayout.Toggle ("Position Penalty",graph.penaltyPosition);
            //preGUI = GUI.enabled;
            //GUI.enabled = graph.penaltyPosition && GUI.enabled;
            if (graph.penaltyPosition)
            {
                EditorGUI.indentLevel++;
                graph.penaltyPositionOffset = EditorGUILayout.FloatField("Offset", graph.penaltyPositionOffset);
                graph.penaltyPositionFactor = EditorGUILayout.FloatField("Factor", graph.penaltyPositionFactor);
                HelpBox("Applies penalty to nodes based on their Y coordinate\nSampled in Int3 space, i.e it is multiplied with Int3.Precision first (" + Int3.Precision + ")\n" +
                        "Be very careful when using negative values since a negative penalty will underflow and instead get really high");
                //GUI.enabled = preGUI;
                EditorGUI.indentLevel--;
            }

            if (textureVisible)
            {
                DrawTextureData(graph.textureData, graph);
            }
            EditorGUI.indentLevel -= 2;
        }
    }