コード例 #1
0
        static void DrawOutlines(UIWindow window, GizmoType gizmoType)
        {
            var rectTransform = window.gameObject.GetComponent<RectTransform>();
            if (rectTransform != null)
            {
                if (EditorPrefs.HasKey("InventoryPro_UIWindowDebug") == false)
                    return;

                var color = new Color(Color.yellow.r, Color.yellow.g, Color.yellow.b, 0.6f);
                Gizmos.color = color;
                Handles.color = color;


                Vector3[] corners = new Vector3[4];
                rectTransform.GetWorldCorners(corners);


                // Draw window name
                //Handles.DrawBezier(Vector3.zero, Vector3.one * 1000, Vector3.up * 500, Vector3.up * 500, Color.yellow, null, 2.0f);
                //Handles.ArrowCap(0, Vector3.one * 1000, Quaternion.Euler(90.0f, 0.0f, 0.0f), 100.0f);
                DrawWindowName(corners[1] + Vector3.up * 20, window.windowName);


                // Draw the bounding box
                Gizmos.DrawLine(corners[0], corners[1]);
                Gizmos.DrawLine(corners[1], corners[2]);
                Gizmos.DrawLine(corners[2], corners[3]);
                Gizmos.DrawLine(corners[3], corners[0]);



                Gizmos.color = Color.white;
                Handles.color = Color.white;
            }
        }
コード例 #2
0
ファイル: MegaTracksEditor.cs プロジェクト: Morac/Orca6
	static void RenderGizmo(MegaTracks track, GizmoType gizmoType)
	{
		if ( (gizmoType & GizmoType.Active) != 0 && Selection.activeObject == track.gameObject )
		{
			if ( !track.displayspline )
				return;

			DrawGizmos(track, new Color(1.0f, 1.0f, 1.0f, 1.0f));
			Color col = Color.yellow;
			col.a = 0.5f;	//0.75f;
			Gizmos.color = col;	//Color.yellow;

			Matrix4x4 RingTM = Matrix4x4.identity;
			RingTM = track.transform.localToWorldMatrix * RingTM;

			float gsize = 0.1f;

			gsize *= 0.1f;

			if ( track.shape != null )
			{
				MegaSpline spl = track.shape.splines[track.curve];

				for ( int p = 0; p < spl.knots.Count; p++ )
				{
					Vector3 p1 = RingTM.MultiplyPoint(spl.knots[p].p);

					Gizmos.color = Color.green;
					Gizmos.DrawSphere(p1, gsize);
				}
			}
		}
	}
コード例 #3
0
	static void RenderGizmoSelected(MegaModifier mod, GizmoType gizmoType)
	{
		if ( GUI.changed )
		{
			Debug.Log("Editing " + mod.ModName());
		}
	}
コード例 #4
0
 static void RenderSpawnGizmo(SpawnPoint spawnPoint, GizmoType gizmoType)
 {
     // Draw the icon
     string iconName = spawnPoint.gizmoIcon;
     if (string.IsNullOrEmpty(iconName)) { iconName = "EnemySpawn"; }
     Gizmos.DrawIcon (spawnPoint.transform.position, iconName, true);
 }
コード例 #5
0
    //public virtual Mesh BuildMesh() {
    //    return new Mesh();
    //}
    public Mesh BuildMesh(GizmoMeshShape shape, GizmoType type) {  // SIMPLE CUBE!
        MeshBuilder meshBuilder = new MeshBuilder();

        if(shape == GizmoMeshShape.Cube) {
            meshBuilder = EditorGizmoMeshShapes.GetCubeMesh(meshBuilder);
            //BuildQuad(meshBuilder, new Vector3(-0.5f, -0.5f, -0.5f), Vector3.right, Vector3.up); // FRONT
            //BuildQuad(meshBuilder, new Vector3(-0.5f, -0.5f, 0.5f), Vector3.back, Vector3.up); // LEFT
            //BuildQuad(meshBuilder, new Vector3(-0.5f, 0.5f, 0.5f), Vector3.back, Vector3.right); // TOP
            //BuildQuad(meshBuilder, new Vector3(0.5f, -0.5f, 0.5f), Vector3.left, Vector3.up); // BACK
            //BuildQuad(meshBuilder, new Vector3(0.5f, -0.5f, -0.5f), Vector3.forward, Vector3.up); // RIGHT
            //BuildQuad(meshBuilder, new Vector3(-0.5f, -0.5f, 0.5f), Vector3.right, Vector3.back); // BOTTOM

            if(type != GizmoType.none) {
                collider = this.gameObject.AddComponent<BoxCollider>();
                collider.isTrigger = true;
            }
            
            if (gizmoMaterial == null) {
                gizmoMaterial = new Material(Shader.Find("Custom/CritterEditorGizmo"));
                //gizmoMaterial.renderQueue = 4000;
            }
            GetComponent<MeshRenderer>().material = gizmoMaterial;
        }
        else if(shape == GizmoMeshShape.Arrow) {
            EditorGizmoMeshShapes.GetArrowMesh(meshBuilder);

            if (type != GizmoType.none) {
                MeshCollider meshCollider = this.gameObject.AddComponent<MeshCollider>();
                meshCollider.sharedMesh = meshBuilder.CreateMesh();
                collider = meshCollider;
                //collider.isTrigger = true;
            }

            if (gizmoMaterial == null) {
                gizmoMaterial = new Material(Shader.Find("Custom/CritterEditorGizmo"));
                //gizmoMaterial.renderQueue = 4000;
            }
            GetComponent<MeshRenderer>().material = gizmoMaterial;
        }
        else if (shape == GizmoMeshShape.OmniArrow) {
            EditorGizmoMeshShapes.GetOmniArrowMesh(meshBuilder);

            if (type != GizmoType.none) {
                MeshCollider meshCollider = this.gameObject.AddComponent<MeshCollider>();
                meshCollider.sharedMesh = meshBuilder.CreateMesh();
                collider = meshCollider;
            }

            if (gizmoMaterial == null) {
                gizmoMaterial = new Material(Shader.Find("Custom/CritterEditorGizmo"));
                //gizmoMaterial.renderQueue = 4000;
            }
            GetComponent<MeshRenderer>().material = gizmoMaterial;
        }
        else {
            Debug.Log("No Gizmo Shape!!!");
        }

        return meshBuilder.CreateMesh();
    }
コード例 #6
0
    public static void DrawGraphGizmo(Graph graph, GizmoType type)
    {
        Color graphColor = GraphEditorWindow.GetGraphColor(graph);
        using (new GizmosColor(graphColor)) {
            foreach (GraphNode node in graph.Nodes) {
                GraphNodeEditor.DrawGraphNodeGizmo(node, GizmoType.NonSelected);
            }

            Color linkColor = Color.gray;
            if ((type & GizmoType.Selected) != 0) {
                linkColor = graphColor * 0.75f;
            }
            else if ((type & GizmoType.NonSelected) != 0) {
                linkColor = graphColor * 0.25f;
            }

            using (new GizmosColor(linkColor)) {
                foreach (var links in graph.Links) {
                    GraphNode nodeFrom = links.Key;
                    foreach (GraphNode nodeTo in links.Value) {
                        Vector3 pinShift = GraphEditorWindow.GetGraphNodePinShift(nodeTo);
                        Gizmos.DrawLine(nodeFrom.transform.position + pinShift, nodeTo.transform.position + pinShift);
                    }
                }
            }
        }
    }
コード例 #7
0
 static void OnDrawRootGizmo(GuiPanel panel, GizmoType gizmoType)
 {
     if (panel.enabled && panel.ClipType == GuiPanelClipType.Range) {
         Gizmos.color = (gizmoType & GizmoType.InSelectionHierarchy) != 0 ? Color.red : new Color (0.5f, 0f, 0f);
         Gizmos.DrawWireCube (panel.transform.position, new Vector3 (panel.ClipWidth, panel.ClipHeight, 0f));
     }
 }
コード例 #8
0
    static void RenderBoundsGizmo(DrawBoundsGizmo boundsGizmo, GizmoType gizmoType) {
        Gizmos.color = boundsGizmo.color;

        // get renderer bonding box
        var bounds = new Bounds();
        var initBound = false;
        if (UnityUtility.GetBoundWithChildren(boundsGizmo.transform, ref bounds, ref initBound)) {
            if (boundsGizmo.drawCube) {
                Gizmos.DrawWireCube(bounds.center, bounds.size);
            }
            if (boundsGizmo.drawSphere) {
                Gizmos.DrawWireSphere(bounds.center, Mathf.Max(Mathf.Max(bounds.extents.x, bounds.extents.y), bounds.extents.z));
            }
        }

        if (boundsGizmo.showCenter) {
            Gizmos.DrawLine(new Vector3(bounds.min.x, bounds.center.y, bounds.center.z), new Vector3(bounds.max.x, bounds.center.y, bounds.center.z));
            Gizmos.DrawLine(new Vector3(bounds.center.x, bounds.min.y, bounds.center.z), new Vector3(bounds.center.x, bounds.max.y, bounds.center.z));
            Gizmos.DrawLine(new Vector3(bounds.center.x, bounds.center.y, bounds.min.z), new Vector3(bounds.center.x, bounds.center.y, bounds.max.z));
        }

        // UnityEditor code draws a label with the dimensions of the bounding box
        Handles.BeginGUI();
        var view = SceneView.currentDrawingSceneView;
        var pos = view.camera.WorldToScreenPoint(bounds.center);
        var size = GUI.skin.label.CalcSize(new GUIContent(bounds.ToString()));
        GUI.Label(new Rect(pos.x - (size.x / 2), -pos.y + view.position.height + 4, size.x, size.y), bounds.ToString());
        Handles.EndGUI();
    }
コード例 #9
0
ファイル: MapEditor.cs プロジェクト: jimmylarkin/River
 static void DrawRiverLines(MapController mapController, GizmoType gizmoType)
 {
     if (mapController == null)
     {
       return;
     }
     Map map = mapController.map;
     if (map == null)
     {
       return;
     }
     Gizmos.color = Color.red;
     for (int i = 1; i < map.RiverData.Count; i++)
     {
       Gizmos.DrawLine(new Vector3(map.RiverData[i - 1].JointChannelMiddleLine, map.WaterLevel, map.RiverData[i - 1].Z), new Vector3(map.RiverData[i].JointChannelMiddleLine, map.WaterLevel, map.RiverData[i].Z));
     }
     Gizmos.color = Color.yellow;
     for (int i = 1; i < map.RiverData.Count; i++)
     {
       Gizmos.DrawLine(new Vector3(map.RiverData[i - 1].LeftChannel.LeftEdge, map.WaterLevel, map.RiverData[i - 1].Z), new Vector3(map.RiverData[i].LeftChannel.LeftEdge, map.WaterLevel, map.RiverData[i].Z));
       Gizmos.DrawLine(new Vector3(map.RiverData[i - 1].LeftChannel.MiddleLine, map.WaterLevel, map.RiverData[i - 1].Z), new Vector3(map.RiverData[i].LeftChannel.MiddleLine, map.WaterLevel, map.RiverData[i].Z));
       Gizmos.DrawLine(new Vector3(map.RiverData[i - 1].LeftChannel.RightEdge, map.WaterLevel, map.RiverData[i - 1].Z), new Vector3(map.RiverData[i].LeftChannel.RightEdge, map.WaterLevel, map.RiverData[i].Z));
     }
     Gizmos.color = Color.cyan;
     for (int i = 1; i < map.RiverData.Count; i++)
     {
       Gizmos.DrawLine(new Vector3(map.RiverData[i - 1].RightChannel.LeftEdge, map.WaterLevel, map.RiverData[i - 1].Z), new Vector3(map.RiverData[i].RightChannel.LeftEdge, map.WaterLevel, map.RiverData[i].Z));
       Gizmos.DrawLine(new Vector3(map.RiverData[i - 1].RightChannel.MiddleLine, map.WaterLevel, map.RiverData[i - 1].Z), new Vector3(map.RiverData[i].RightChannel.MiddleLine, map.WaterLevel, map.RiverData[i].Z));
       Gizmos.DrawLine(new Vector3(map.RiverData[i - 1].RightChannel.RightEdge, map.WaterLevel, map.RiverData[i - 1].Z), new Vector3(map.RiverData[i].RightChannel.RightEdge, map.WaterLevel, map.RiverData[i].Z));
     }
 }
コード例 #10
0
 static void RenderLightGizmo(GameObject gameObject, GizmoType gizmoType)
 {
     if (gameObject.CompareTag("SpawnPoint")) {
         Gizmos.color = Color.red;
         Gizmos.DrawSphere(gameObject.transform.position, 0.5f);
     }
 }
コード例 #11
0
    static void DrawProjectileStatePoints(BouncingProjectile projectile , GizmoType gizmoType)
    {
        if (projectile == null)
            return;

        if (projectile.HasPackages() == false)
            return;

        List<Projectile2DState> points = projectile.GetAllPackages();

        DrawSegment(projectile.transform.position + Vector3.up * .99f, projectile.nextPosition + Vector3.up * .99f, Color.blue, visualizationTime);

        //Vector3 ballMoveDir = projectile.transform.position - projectile.previousPosition;

        for (int i = 0; i < points.Count; i++)
        {
            // draw little + for points
            DrawCross(points[i].Position3() + Vector3.up, .2f, Color.white, visualizationTime);

            // draw little -> for points
            Color targetColor = Color.yellow;
            if (points[i].ServerVerified == false)
                targetColor = Color.cyan;

            if (i != 0)
                DrawSegment(points[i].Position3() + Vector3.up * .9f, points[i - 1].Position3() + Vector3.up * .9f, Color.green, visualizationTime);

            DrawArrow(points[i].Position3() + Vector3.up, points[i].Direction3(), .5f, targetColor, visualizationTime);
        }

        

    }
コード例 #12
0
	static void RenderGizmo(MegaTrainFollow mod, GizmoType gizmoType)
	{
		if ( (gizmoType & GizmoType.Active) != 0 && Selection.activeObject == mod.gameObject )
		{
			if ( !mod.showrays )
				return;

			for ( int i = 0; i < mod.carriages.Count; i++ )
			{
				MegaCarriage car = mod.carriages[i];

				Handles.color = Color.white;
				Handles.DrawLine(car.b1, car.b2);
				//Gizmos.DrawSphere(car.b1, car.length * 0.025f);
				//Gizmos.DrawSphere(car.b2, car.length * 0.025f);
				Handles.SphereCap(0, car.cp, Quaternion.identity, car.length * 0.025f);
				Handles.SphereCap(0, car.b1, Quaternion.identity, car.length * 0.025f);
				Handles.SphereCap(0, car.b2, Quaternion.identity, car.length * 0.025f);
									//if ( showrays )
				Handles.color = Color.red;
				Handles.DrawLine(car.cp, car.bp1);
				Handles.SphereCap(0, car.bp1, Quaternion.identity, car.length * 0.025f);

				//Gizmos.color = Color.green;
				Handles.color = Color.green;
				//Gizmos.DrawLine(car.cp, car.bp2);
				Handles.DrawLine(car.cp, car.bp2);

				//Gizmos.DrawSphere(car.bp2, car.length * 0.025f);
				Handles.SphereCap(0, car.bp2, Quaternion.identity, car.length * 0.025f);
			}
		}
	}
コード例 #13
0
 static void DrawGizmoFor(LodeRunnerGraphBuilder target, GizmoType gizmoType)
 {
     //draw arrow map
     if (target.showArrowMap)
     {
         for (int x = 0; x < target.getWidth(); x++)
         {
             for (int y = target.getHeight() - 1; y >= 0; y--)
             {
                 byte arrow = target.getArrowMapValue(x, y);
                 if (arrow == (byte)Arrow.Dot)
                 {
                     Gizmos.DrawIcon(target.getTileCenterPositionInWorld(x, y), "arrow_dot.png", true);
                     continue;
                 }
                 if (arrow == (byte)Arrow.JumpPoint)
                 {
                     Gizmos.DrawIcon(target.getTileCenterPositionInWorld(x, y), "arrow_JP.png", true);
                     continue;
                 }
                 if (target.hasArrow(arrow, Arrow.Up))
                     Gizmos.DrawIcon(target.getTileCenterPositionInWorld(x, y), "arrow_up.png", true);
                 if (target.hasArrow(arrow, Arrow.Down))
                     Gizmos.DrawIcon(target.getTileCenterPositionInWorld(x, y), "arrow_down.png", true);
                 if (target.hasArrow(arrow, Arrow.Left))
                     Gizmos.DrawIcon(target.getTileCenterPositionInWorld(x, y), "arrow_left.png", true);
                 if (target.hasArrow(arrow, Arrow.Right))
                     Gizmos.DrawIcon(target.getTileCenterPositionInWorld(x, y), "arrow_right.png", true);
             }
         }
     }
 }
コード例 #14
0
ファイル: PathScriptGizmoDrawer.cs プロジェクト: Clavus/Tank
    public static void DrawGizmo(PathScript scr, GizmoType gizmoType)
    {
        Vector3[] nodes = scr.GetPath();

        if (nodes.Length > 1)
            iTween.DrawPathGizmos(nodes);

        for (int i = 0; i < nodes.Length; i++)
        {
            if (scr.loops && i == nodes.Length - 1 && nodes.Length > 1)
                break;

            if (nodes.Length > 1 && scr.loops)
                Gizmos.color = Color.Lerp(Color.red, Color.blue, (float)i / (nodes.Length - 2));
            else if (nodes.Length > 1)
                Gizmos.color = Color.Lerp(Color.red, Color.blue, (float)i / (nodes.Length - 1));
            else
                Gizmos.color = Color.red;

            if ((gizmoType & GizmoType.NonSelected) > 0)
                Gizmos.DrawWireSphere(nodes[i], 0.25f);
            else
                Gizmos.DrawSphere(nodes[i], 0.5f);

            Vector3 screenPoint = Camera.current.WorldToScreenPoint(nodes[i]);
            GUI.TextField(new Rect(screenPoint.x, screenPoint.y, 20, 20), i.ToString());

        }
    }
コード例 #15
0
	static void RenderGizmo (LegController legC, GizmoType gizmoType) {
		if (Application.isPlaying || AnimationUtility.InAnimationMode())
			return;
		
		Vector3 up = legC.transform.up;
		Vector3 forward = legC.transform.forward;
		Vector3 right = legC.transform.right;
		
		// Draw cross signifying the Ground Plane Height
		Vector3 groundCenter = (
			legC.transform.position
				+ legC.groundPlaneHeight * up * legC.transform.lossyScale.y
		);
		Gizmos.color = (Color.green+Color.white)/2;
		Gizmos.DrawLine(groundCenter-forward, groundCenter+forward);
		Gizmos.DrawLine(groundCenter-right, groundCenter+right);
		
		// Draw rect showing foot boundaries
		if (legC.groundedPose==null) return;
		float scale = legC.transform.lossyScale.z;
		for (int leg=0; leg<legC.legs.Length; leg++) {
			if (legC.legs[leg].ankle==null) continue;
			if (legC.legs[leg].toe==null) continue;
			if (legC.legs[leg].footLength+legC.legs[leg].footWidth==0) continue;
			legC.InitFootData(leg);
			Vector3 heel = legC.legs[leg].ankle.TransformPoint(legC.legs[leg].ankleHeelVector);
			Vector3 toetip = legC.legs[leg].toe.TransformPoint(legC.legs[leg].toeToetipVector);
			Vector3 side = (Quaternion.AngleAxis(90,up) * (toetip-heel)).normalized * legC.legs[leg].footWidth * scale;
			Gizmos.DrawLine(heel+side/2, toetip+side/2);
			Gizmos.DrawLine(heel-side/2, toetip-side/2);
			Gizmos.DrawLine(heel-side/2, heel+side/2);
			Gizmos.DrawLine(toetip-side/2, toetip+side/2);
		}
	}
コード例 #16
0
    public static void DrawGraphNodeGizmo(GraphNode node, GizmoType type)
    {
        using (new GizmosColor(GraphEditorWindow.GetGraphColor(node.graph))) {
            if (node.graph == null) {
                Vector3 nodePinPosition = node.transform.position + GraphEditorWindow.GetGraphNodePinShift(node);
                Gizmos.DrawLine(node.transform.position, nodePinPosition);
                Gizmos.DrawWireSphere(nodePinPosition, GraphEditorWindow.GraphNodePinRadius * 1.1f);

                return;
            }

            if ((type & GizmoType.Selected) != 0) {
                GraphEditor.DrawGraphGizmo(node.graph, GizmoType.NonSelected);

                Vector3 pinShift = GraphEditorWindow.GetGraphNodePinShift(node);
                Vector3 nodePinPosition = node.transform.position + pinShift;
                Gizmos.DrawLine(node.transform.position, nodePinPosition);
                Gizmos.DrawWireSphere(nodePinPosition, GraphEditorWindow.GraphNodePinRadius * 1.1f);

                foreach (GraphNode linkedNode in node.EnumLinkedNodes()) {
                    Gizmos.DrawLine(nodePinPosition, linkedNode.transform.position + pinShift);
                }
            }
            else if (type == GizmoType.NonSelected) {
                Vector3 pinShift = GraphEditorWindow.GetGraphNodePinShift(node);
                Vector3 nodePinPosition = node.transform.position + pinShift;
                Gizmos.DrawLine(node.transform.position, nodePinPosition);
                Gizmos.DrawSphere(nodePinPosition, GraphEditorWindow.GraphNodePinRadius);
            }
        }
    }
コード例 #17
0
ファイル: SceneScripts.cs プロジェクト: NachyoChez/BookWork
    private static void Draw(GameObject gObj, GizmoType gizmoType)
    {
        GUIStyle style = new GUIStyle();

                style.alignment = TextAnchor.MiddleCenter;
                style.fontStyle = FontStyle.Bold;
                if (gObj.GetComponent<Zone> () != null) {
                        //if (!gObj.GetComponent<Zone> ().UseSlots) {
                                style.normal.textColor = Color.yellow;
                                Handles.Label(gObj.GetComponent<Collider>().bounds.center, gObj.name, style);
                                Bounds bounds = gObj.GetComponent<Collider>().bounds;

                                Gizmos.color = Color.yellow;

                                Gizmos.DrawWireCube (bounds.center, bounds.size);

                        //}

                } else if (gObj.GetComponent<Slot> () != null) {
                        if (gObj.transform.parent != null)
                        if (gObj.transform.parent.GetComponent<Zone> () != null)
                        //if (gObj.transform.parent.GetComponent<Zone> ().UseSlots) {
                                style.normal.textColor = Color.cyan;
                                Handles.Label(gObj.GetComponent<Collider>().bounds.center, gObj.name, style);
                                Bounds bounds = gObj.GetComponent<Collider>().bounds;

                                Gizmos.color = Color.cyan;

                                Gizmos.DrawWireCube (bounds.center, bounds.size);
                        //}
                }
    }
コード例 #18
0
ファイル: CharacterEditor.cs プロジェクト: yenv672/thesis
    private static void GizmoTest(Transform aTarget, GizmoType aGizmoType)
    {
        #if UNITY_EDITOR
        if (Application.isPlaying)
        {
            ThirdPersonMotor motor = (ThirdPersonMotor)aTarget.GetComponent<ThirdPersonMotor>();
            if (!motor) return;

            // debug auto crouch
            Vector3 posHead = motor.transform.position + Vector3.up * ((motor.colliderHeight * 0.5f) - motor.colliderRadius);
            Ray ray1 = new Ray(posHead, Vector3.up);
            Gizmos.DrawWireSphere(ray1.GetPoint((motor.headDetect - (motor.colliderRadius * 0.1f))), motor.colliderRadius * 0.9f);
            Handles.Label(ray1.GetPoint((motor.headDetect + (motor.colliderRadius))), "Head Detection");
            // debug check trigger action
            Vector3 yOffSet = new Vector3(0f, -0.5f, 0f);
            Ray ray2 = new Ray(motor.transform.position - yOffSet, motor.transform.forward);
            Debug.DrawRay(ray2.origin, ray2.direction * 0.45f, Color.white);
            Handles.Label(ray2.GetPoint(0.45f), "Check for Trigger Actions");
            // debug stopmove
            Ray ray3 = new Ray(motor.transform.position + new Vector3(0, motor.colliderHeight / 3, 0), motor.transform.forward);
            Debug.DrawRay(ray3.origin, ray3.direction * motor.stopMoveDistance, Color.blue);
            Handles.Label(ray3.GetPoint(motor.stopMoveDistance), "Check for StopMove");
            // debug stopmove
            Ray ray4 = new Ray(motor.transform.position + new Vector3(0, motor.colliderHeight / 3.5f, 0), motor.transform.forward);
            Debug.DrawRay(ray4.origin, ray4.direction * 1f, Color.cyan);
            Handles.Label(ray4.GetPoint(1f), "Check for SlopeLimit");
            // debug stepOffset
        //            Ray ray5 = new Ray((motor.transform.position + new Vector3(0, motor.stepOffsetEnd, 0) + motor.transform.forward * ((motor.capsuleCollider).radius + motor.stepOffsetFwd)), Vector3.down);
        //            Debug.DrawRay(ray5.origin, ray5.direction * (motor.stepOffsetEnd - motor.stepOffsetStart), Color.yellow);
        //            Handles.Label(ray5.origin, "Step OffSet");
        }
        #endif
    }
コード例 #19
0
ファイル: MegaWarpEditor.cs プロジェクト: mobeid/NP_SIMULATOR
	static void RenderGizmo(MegaWarp warp, GizmoType gizmoType)
	{
		if ( MegaModifiers.GlobalDisplay && warp.DisplayGizmo )
		{
			Color col = Color.white;

#if UNITY_5_1 || UNITY_5_2
			if ( (gizmoType & GizmoType.NotInSelectionHierarchy) != 0 )
#else
			if ( (gizmoType & GizmoType.NotInSelectionHierarchy) != 0 )
#endif
			{
				col.a = 0.5f;
			}
			else
			{
				if ( (gizmoType & GizmoType.Active) != 0 )
				{
					if ( warp.Enabled )
						col.a = 1.0f;
					else
						col.a = 0.75f;
				}
				else
				{
					if ( warp.Enabled )
						col.a = 0.5f;
					else
						col.a = 0.25f;
				}
			}
			warp.DrawGizmo(col);
			Gizmos.DrawIcon(warp.transform.position, warp.GetIcon(), false);
		}
	}
コード例 #20
0
    static void DrawSomething(Transform objectTransform, GizmoType gizmoType)
    {
        Label3D l3d = objectTransform.GetComponent<Label3D>();

        if(null == l3d) return;

        Handles.Label(((l3d.target)?l3d.target.position:objectTransform.position) + l3d.offset, l3d.text, "Button");
    }
コード例 #21
0
ファイル: GizmoHandle.cs プロジェクト: azanium/PopBloop-Unity
    public void setType(GizmoType gizmoType)
    {
        this.gizmoType = gizmoType;

        positionEnd.SetActive(gizmoType == GizmoType.Position);
        rotationEnd.SetActive(gizmoType == GizmoType.Rotation);
        scaleEnd.SetActive(gizmoType == GizmoType.Scale);
    }
コード例 #22
0
	static void RenderGizmo(MegaLoftLayerMultiMatComplex layer, GizmoType gizmoType)
	{
		if ( (gizmoType & GizmoType.Active) != 0 && Selection.activeObject == layer.gameObject )
		{
			if ( layer.showsections )
				DrawPath(layer);
		}
	}
コード例 #23
0
		static void RenderCustomGizmo(Transform objectTransform, GizmoType gizmoType)
		{
			View view = objectTransform.gameObject.GetComponent<View>();
			if (view != null)
			{
				DrawView(view, false);
			}
		}
コード例 #24
0
	static void RenderGizmo(MegaTankWheels track, GizmoType gizmoType)
	{
		if ( (gizmoType & GizmoType.Active) != 0 && Selection.activeObject == track.gameObject )
		{
			Gizmos.matrix = track.transform.localToWorldMatrix;
			Gizmos.DrawWireSphere(Vector3.zero, track.radius);
		}
	}
コード例 #25
0
        static void DrawGizmoForObiWorld(ObiWorld world, GizmoType gizmoType)
        {
            if ((gizmoType & GizmoType.Selected) != 0) {

                Gizmos.color = new Color(0,0,1,0.05f);
                DrawDBVH(world, world.dynamicBVH.Root);

            }
        }
コード例 #26
0
 static void RenderLightGizmo(GameObject gameObject, GizmoType gizmoType)
 {
     if (gameObject.CompareTag("StationSpawn") && string.IsNullOrEmpty(AssetDatabase.GetAssetPath(gameObject))) {
         Gizmos.color = Color.yellow;
         var prefab = (GameObject)GameObject.FindObjectsOfTypeIncludingAssets(typeof(GameObject)).First(g => ((GameObject)g).name == "Work Station");
         var modelTransform = prefab.transform.FindChild("Cube");
         Gizmos.DrawCube(gameObject.transform.position, modelTransform.localScale);
     }
 }
コード例 #27
0
	static void ColliderGizmoDraw(GameObject go,GizmoType gt) {
		if (!debugViewEnabled) {
			return;
		}

		if (go.tag == "Player") {
			// Scaler
			for (int x = -10;x < 10;x ++) {
				Vector3 vecA = go.transform.position + Vector3.left * x;
				Vector3 vecB = vecA + Vector3.up;
				Gizmos.color = (Mathf.Abs(x) < 5) ? Color.red : Color.white;
				Gizmos.DrawLine (vecA,vecB);
			}
			for (int x = -10;x < 10;x ++) {
				Vector3 vecA = go.transform.position + Vector3.up * x;
				Vector3 vecB = vecA + Vector3.left;
				Gizmos.color = (Mathf.Abs(x) < 5) ? Color.red : Color.white;
				Gizmos.DrawLine (vecA,vecB);
			}
		} else
		if (go.tag == "Enemy") {
			// AI Status
			Gizmos.color = Color.red;
			Gizmos.DrawCube (go.transform.position, new Vector3 (0.1f, 0.1f, 0.1f));
			GUIStyle style = new GUIStyle();
			style.active.textColor 	= Color.red;
			style.normal.textColor 	= Color.red;
			style.hover.textColor 	= Color.red;
			style.focused.textColor	= Color.red;

			EnemyMain em = go.GetComponent<EnemyMain>();
			if (em == null) {
				return;
			}

			if (em.cameraEnabled) {
				Handles.Label (go.transform.position,
				               string.Format("{0} {1} {2}",
				              em.aiState,
				              em.GetComponent<EnemyController>().grounded,
				              em.GetDistanePlayer()) );
			}

			// Dog Pile
			Gizmos.color = Color.red;
			StageObject_DogPile[] dogPileList = GameObject.FindObjectsOfType<StageObject_DogPile>();
			foreach(StageObject_DogPile dogPile in dogPileList) {
				foreach(GameObject enemy in dogPile.enemyList) {
					if (go == enemy) {
						Gizmos.DrawLine (go.transform.position, dogPile.transform.position);
						return;
					}
				}
			}
			
		}
	}
コード例 #28
0
    static void RenderGizmo(MegaTankWheels track, GizmoType gizmoType)
    {
        if ( (gizmoType & GizmoType.Active) != 0 )
        {

            Gizmos.matrix = track.transform.localToWorldMatrix;
            //Gizmos.DrawWireCube(Vector3.zero, new Vector3(track.radius * 0.5f, track.radius * 0.5f, track.radius));
            Gizmos.DrawWireSphere(Vector3.zero, track.radius);
        }
    }
コード例 #29
0
ファイル: DrawGizmos.cs プロジェクト: exdev/urban-survivors
 // [DrawGizmo (GizmoType.NotSelected | GizmoType.Pickable)]
 static void Draw ( Spawner_base _c, GizmoType _gizmoType ) {
     if ( _c.showSpawns ) {
         foreach ( Object obj in _c.existObjects ) {
             if ( obj == null )
                 continue;
             Vector3 position = _c.transform.position;
             Gizmos.color = new Color( 0.0f, 0.0f, 1.0f, 1.0f );
             Gizmos.DrawLine (position, (obj as GameObject).transform.position);
         }
     }
 }
コード例 #30
0
    /// <summary>
    /// Draws the standard gizmo for <see cref="NMGenAreaMarker"/> components.
    /// </summary>
    /// <param name="marker">The marker to draw.</param>
    /// <param name="type">The gizmo type.</param>
    protected static void DrawStandardGizmo(NMGenAreaMarker marker, GizmoType type)
    {
        if (!NMGenAreaMarker.debugEnabled && (type & GizmoType.SelectedOrChild) == 0)
            return;

        Gizmos.color = ColorUtil.IntToColor(marker.Area, 0.6f);

        Vector3 pos = marker.transform.position;

        Gizmos.DrawCube(pos, markerSize);
    }
コード例 #31
0
 static void DrawGizmoNonSelected(Map map, GizmoType type)
 {
     DisplayGizmos(map);
 }
コード例 #32
0
 static void DrawGizmos(CinemachinePath path, GizmoType selectionType)
 {
     DrawPathGizmo(path,
                   (Selection.activeGameObject == path.gameObject)
         ? path.m_Appearance.pathColor : path.m_Appearance.inactivePathColor);
 }
コード例 #33
0
 private static void DrawGizmo(SquarePyramidGuide shape, GizmoType gizmo)
 {
     DrawGuide(shape, Palette.Translucent);
 }
コード例 #34
0
 static void DrawLowResPath(PathBase Path, GizmoType type)
 {
     DrawPath(Path, 20);
 }
コード例 #35
0
ファイル: RectangleGuide.cs プロジェクト: mikendu/DroneMayhem
 private static void DrawGizmo(RectangleGuide shape, GizmoType gizmo)
 {
     DrawSquare(shape, Palette.Translucent);
 }
コード例 #36
0
 private static void DrawGizmosWhenSelected(
     WakeTrigger wakeTrigger, GizmoType gizmoType)
 {
     DrawWakeUpTargets(wakeTrigger);
 }
コード例 #37
0
 static void DrawGizmosSelected(RotationRedirector rotator, GizmoType gizmoType)
 {
     Gizmos.DrawIcon(rotator.transform.TransformPoint(rotator.RotationPoint), "SpaceExtenderTool/rotationIcon",
                     true);
 }
コード例 #38
0
        internal static void DrawGizmos(HDProbe d, GizmoType gizmoType)
        {
            HDProbeUI s;

            if (!HDProbeEditor.TryGetUIStateFor(d, out s))
            {
                return;
            }

            var mat = Matrix4x4.TRS(d.transform.position, d.transform.rotation, Vector3.one);

            switch (EditMode.editMode)
            {
            case EditBaseShape:
                if (d is PlanarReflectionProbe && (InfluenceShape)d.influenceVolume.shape == InfluenceShape.Box)
                {
                    //Planar need to update its transform position.
                    //Let PlanarReflectionProbeUI.Handle do this work.
                    break;
                }
                InfluenceVolumeUI.DrawGizmos(
                    s.influenceVolume, d.influenceVolume, mat,
                    InfluenceVolumeUI.HandleType.Base,
                    InfluenceVolumeUI.HandleType.All);
                break;

            case EditInfluenceShape:
                InfluenceVolumeUI.DrawGizmos(
                    s.influenceVolume,
                    d.influenceVolume,
                    mat,
                    InfluenceVolumeUI.HandleType.Influence,
                    InfluenceVolumeUI.HandleType.All);
                break;

            case EditInfluenceNormalShape:
                InfluenceVolumeUI.DrawGizmos(
                    s.influenceVolume,
                    d.influenceVolume,
                    mat,
                    InfluenceVolumeUI.HandleType.InfluenceNormal,
                    InfluenceVolumeUI.HandleType.All);
                break;

            default:
            {
                var showedHandles = s.influenceVolume.showInfluenceHandles
                        ? InfluenceVolumeUI.HandleType.All
                        : InfluenceVolumeUI.HandleType.Base | InfluenceVolumeUI.HandleType.Influence;
                InfluenceVolumeUI.DrawGizmos(
                    s.influenceVolume,
                    d.influenceVolume,
                    mat,
                    InfluenceVolumeUI.HandleType.None,
                    showedHandles);
                break;
            }
            }

            if (d.proxyVolume != null)
            {
                ReflectionProxyVolumeComponentUI.DrawGizmos_EditNone(d.proxyVolume);
            }
        }
コード例 #39
0
        private static void DrawGroupComposerGizmos(CinemachineFramingTransposer target, GizmoType selectionType)
        {
            // Show the group bounding box, as viewed from the camera position
            var group = target.TargetGroup;

            if (group != null)
            {
                var m = Gizmos.matrix;
                var b = target.m_LastBounds;
                Gizmos.matrix = target.m_lastBoundsMatrix;
                Gizmos.color  = Color.yellow;
                Gizmos.DrawWireCube(b.center, b.size);
                Gizmos.matrix = m;
            }
        }
コード例 #40
0
    static void RenderTileNodeGizmo(TileNode node, GizmoType gizmoType)
    {
        if (node.parent == null)
        {
            return;
        }
        Vector3 position = node.transform.position;

        // draw cube(s) for node
        if (node.parent.gizmoDrawNodes || ((gizmoType & GizmoType.Selected) != 0))
        {
            if ((gizmoType & GizmoType.Selected) != 0)
            {
                Gizmos.color = Color.red;
                Gizmos.DrawCube(position, TileNode.GizmoSize);
            }

            else if (node.parent.gizmoColorCoding)
            {
                bool    drawn = false;
                Vector3 offs  = Vector3.zero;
                for (int i = 0; i < TileNode.GizmoColourCoding.Length; i++)
                {
                    int t = (int)Mathf.Pow(2, i);
                    if (((int)node.tileTypeMask & t) == t)
                    {
                        Gizmos.color = TileNode.GizmoColourCoding[i];
                        Gizmos.DrawCube(position + offs, TileNode.GizmoSize);
                        offs.y += TileNode.GizmoSize.y;
                        drawn   = true;
                    }
                }

                if (!drawn)
                {
                    Gizmos.color = Color.black;
                    Gizmos.DrawCube(position, TileNode.GizmoSize);
                }
            }

            else
            {
                Gizmos.color = Color.black;
                Gizmos.DrawCube(position, TileNode.GizmoSize);
            }
        }

        // draw the node links
        if (node.nodeLinks != null && (node.parent.gizmoDrawLinks || (gizmoType & GizmoType.Selected) != 0))
        {
            TNELinksOnOffSwitch linkSwitch = node.gameObject.GetComponent <TNELinksOnOffSwitch>();
            foreach (TileNode n in node.nodeLinks)
            {
                if (n != null)
                {
                    Gizmos.color = Color.blue;

                    if (linkSwitch != null)
                    {                           // check if lik is on with neighbour
                        if (linkSwitch.LinkIsOn(n) == 0)
                        {
                            Gizmos.color = Color.red;
                        }
                    }

                    TNELinksOnOffSwitch nls = n.gameObject.GetComponent <TNELinksOnOffSwitch>();
                    if (nls != null)
                    {                           // check if neighbour's link with me is on
                        if (nls.LinkIsOn(node) == 0)
                        {
                            Gizmos.color = Color.red;
                        }
                    }

                    Gizmos.DrawLine(position, n.transform.position);
                }
            }
        }
    }
コード例 #41
0
 public DrawGizmo(GizmoType gizmo)
 {
     drawOptions = gizmo;
 }
コード例 #42
0
ファイル: BGCurveEditor.cs プロジェクト: ivarsbergs/escape
 public static bool Comply(GizmoType gizmoType, GizmoType toCompare)
 {
     return((gizmoType & toCompare) != 0);
 }
コード例 #43
0
        private static void DrawGizmos(AreaClock2D clock, GizmoType gizmoType)
        {
            // Draw icon...

            Gizmos.color = Color.white;

            Vector3 position;

            if (clock.mode == AreaClockMode.PointToEdge)
            {
                position = clock.transform.TransformPoint(clock.center);
            }
            else
            {
                position = clock.transform.position;
            }

            Gizmos.DrawIcon(position, "AreaClock");

            // Draw inset approximations for padding...

            if (clock.mode == AreaClockMode.DistanceFromEntry)
            {
                Handles.color = clock.padding > 0 ? Color.cyan : Color.red;

                Vector2 inset = -(2 * clock.padding * Vector2.one);

                CircleCollider2D circleCollider = clock.GetComponent <CircleCollider2D>();

                if (circleCollider != null)
                {
                    Vector2 scale      = clock.transform.lossyScale;
                    float   maxScale   = Mathf.Max(scale.x, scale.y);
                    Vector2 insetScale = (maxScale * (2 * circleCollider.radius) * Vector2.one) + inset;

                    if (IsVectorNegative(insetScale))
                    {
                        Handles.color = Color.red;
                    }
                    Handles.matrix = Matrix4x4.TRS(clock.transform.position, clock.transform.rotation, insetScale);
                    Handles.DrawWireDisc(Vector3.zero, Vector3.forward, 0.5f);

                    return;
                }

                BoxCollider2D boxCollider = clock.GetComponent <BoxCollider2D>();

                if (boxCollider != null)
                {
                    Vector2 insetScale = Vector2.Scale(boxCollider.size, clock.transform.lossyScale) + inset;

                    if (IsVectorNegative(insetScale))
                    {
                        Handles.color = Color.red;
                    }
                    Handles.matrix = Matrix4x4.TRS(clock.transform.position, clock.transform.rotation, insetScale);
                    Handles.DrawPolyLine
                    (
                        new Vector3(-1, -1, 0) / 2,
                        new Vector3(-1, +1, 0) / 2,
                        new Vector3(+1, +1, 0) / 2,
                        new Vector3(+1, -1, 0) / 2,
                        new Vector3(-1, -1, 0) / 2
                    );

                    return;
                }

                PolygonCollider2D polyCollider = clock.GetComponent <PolygonCollider2D>();

                if (polyCollider != null)
                {
                    Vector3 bounds           = polyCollider.bounds.size;
                    float   smallestBound    = Mathf.Min(bounds.x, bounds.y);
                    Vector2 normalizedBounds = smallestBound * new Vector2(1 / bounds.x, 1 / bounds.y);
                    Vector2 insetScale       = (Vector2)clock.transform.lossyScale + Vector2.Scale(normalizedBounds, inset);

                    if (IsVectorNegative(insetScale))
                    {
                        Handles.color = Color.red;
                    }
                    Handles.matrix = Matrix4x4.TRS(clock.transform.position, clock.transform.rotation, insetScale);
                    Vector3[] points = polyCollider.points.Select(v2 => (Vector3)v2).ToArray();
                    Handles.DrawPolyLine(points);

                    return;
                }
            }
        }
コード例 #44
0
 public DrawGizmo(GizmoType gizmo, Type drawnGizmoType)
 {
     drawnType   = drawnGizmoType;
     drawOptions = gizmo;
 }
コード例 #45
0
 static void DrawGizmo(Map map, GizmoType type)
 {
     DisplayGizmos(map);
 }
コード例 #46
0
        static void DrawMovingPlatformGizmo(MovingPlatform movingPlatform, GizmoType gizmoType)
        {
            if (movingPlatform.Waypoints == null)
            {
                return;
            }

            Mesh mesh       = null;
            var  meshFilter = movingPlatform.GetComponent <MeshFilter>();

            if (meshFilter != null)
            {
                mesh = meshFilter.sharedMesh;
            }
            for (int i = 0; i < movingPlatform.Waypoints.Length; ++i)
            {
                if (movingPlatform.Waypoints[i].Transform == null)
                {
                    continue;
                }

                Gizmos.color = movingPlatform.GizmoColor;
                // Draw the mesh if it exists.
                if (mesh != null)
                {
                    Gizmos.DrawMesh(mesh, movingPlatform.Waypoints[i].Transform.position, movingPlatform.Waypoints[i].Transform.rotation, movingPlatform.transform.localScale);
                }
                Gizmos.DrawWireSphere(movingPlatform.Waypoints[i].Transform.position, 0.5f);

                if (movingPlatform.DrawDebugLabels)
                {
                    if (s_DebugLabelStyle == null)
                    {
                        s_DebugLabelStyle                  = new GUIStyle(EditorStyles.label);
                        s_DebugLabelStyle.fontSize         = 16;
                        s_DebugLabelStyle.normal.textColor = InspectorUtility.GetContrastColor(movingPlatform.GizmoColor);
                    }
                    // Draw the delay in the center of the platform.
                    Handles.Label(movingPlatform.Waypoints[i].Transform.position, movingPlatform.Waypoints[i].Delay.ToString(), s_DebugLabelStyle);
                }

                // Draw a line connecting the platforms.
                if (i > 0 && movingPlatform.Waypoints[i - 1].Transform != null && movingPlatform.MovementType != MovingPlatform.PathMovementType.Target)
                {
                    Gizmos.color = InspectorUtility.GetContrastColor(movingPlatform.GizmoColor);
                    Gizmos.DrawLine(movingPlatform.Waypoints[i - 1].Transform.position, movingPlatform.Waypoints[i].Transform.position);

                    if (movingPlatform.DrawDebugLabels)
                    {
                        // Draw a distance in the center of the line.
                        var distance = decimal.Round((decimal)Vector3.Distance(movingPlatform.Waypoints[i - 1].Transform.position, movingPlatform.Waypoints[i].Transform.position), 3);
                        Handles.Label((movingPlatform.Waypoints[i - 1].Transform.position + movingPlatform.Waypoints[i].Transform.position) / 2, distance.ToString(), s_DebugLabelStyle);
                    }
                }
            }

            // Complete the path drawing.
            if (movingPlatform.MovementType == MovingPlatform.PathMovementType.Loop && movingPlatform.Waypoints.Length > 0 && movingPlatform.Waypoints[0].Transform != null &&
                movingPlatform.Waypoints[movingPlatform.Waypoints.Length - 1].Transform != null)
            {
                Gizmos.color = InspectorUtility.GetContrastColor(movingPlatform.GizmoColor);
                Gizmos.DrawLine(movingPlatform.Waypoints[0].Transform.position, movingPlatform.Waypoints[movingPlatform.Waypoints.Length - 1].Transform.position);

                if (movingPlatform.DrawDebugLabels)
                {
                    // Draw a distance in the center of the line.
                    var distance = decimal.Round((decimal)Vector3.Distance(movingPlatform.Waypoints[0].Transform.position, movingPlatform.Waypoints[movingPlatform.Waypoints.Length - 1].Transform.position), 3);
                    Handles.Label((movingPlatform.Waypoints[0].Transform.position + movingPlatform.Waypoints[movingPlatform.Waypoints.Length - 1].Transform.position) / 2, distance.ToString(), s_DebugLabelStyle);
                }
            }
            else if (movingPlatform.MovementType == MovingPlatform.PathMovementType.Target && movingPlatform.TargetWaypoint < movingPlatform.Waypoints.Length && movingPlatform.Waypoints[movingPlatform.TargetWaypoint].Transform != null)
            {
                Gizmos.color = InspectorUtility.GetContrastColor(movingPlatform.GizmoColor);
                Gizmos.DrawLine(movingPlatform.transform.position, movingPlatform.Waypoints[movingPlatform.TargetWaypoint].Transform.position);
            }

            // Draw the current waypoint the platform is moving towards.
            if (Application.isPlaying && movingPlatform.enabled && movingPlatform.Waypoints.Length > 0)
            {
                Gizmos.color = Color.green;
                Gizmos.DrawLine(movingPlatform.transform.position, movingPlatform.Waypoints[movingPlatform.NextWaypoint].Transform.position);
            }
        }
コード例 #47
0
 static void DrawGizmos(StickFromMouseSceneView stick, GizmoType selectionType)
 {
     StickUpdater.SetReference(stick);
 }
コード例 #48
0
        private static void DrawStartLocationGizmo(AbilityStartLocation startLocation, GizmoType gizmoType)
        {
            var transform = startLocation.transform;

            Handles.matrix = Gizmos.matrix = Matrix4x4.TRS(transform.position, transform.rotation, transform.lossyScale);

            // Wire lines will indicate the valid starting positions.
            Gizmos.color = new Color(1, 0.6f, 0, 0.7f);
            Gizmos.DrawWireCube(startLocation.Offset, startLocation.Size);

            // Draw an arc indicating the direction that the character can face.
            Handles.matrix = Gizmos.matrix = Matrix4x4.TRS(transform.TransformPoint(startLocation.Offset), transform.rotation * Quaternion.Euler(0, startLocation.YawOffset, 0), transform.lossyScale);
            Handles.color  = new Color(0, 1, 0, 0.7f);
            var radius = Mathf.Min(0.5f, Mathf.Max(Mathf.Abs(startLocation.Offset.z), 0.2f));

            Handles.DrawWireDisc(Vector3.zero, Vector3.up, radius);
            Handles.color = new Color(0, 1, 0, 0.2f);
            Handles.DrawSolidArc(Vector3.zero, Vector3.up, Quaternion.AngleAxis(startLocation.Angle / 2 - startLocation.Angle, Vector3.up) * Vector3.forward,
                                 startLocation.Angle, radius);

            // Draw arrows pointing in the direction that the character can face.
            radius       /= 2;
            Handles.color = new Color(0, 1, 0, 0.7f);
            Handles.DrawLine(Vector3.zero, (Vector3.forward * 2f) * radius);
            Handles.DrawLine((Vector3.forward * 2) * radius, ((Vector3.forward * 1.5f * radius) + (Vector3.left * 0.5f) * radius));
            Handles.DrawLine((Vector3.forward * 2) * radius, ((Vector3.forward * 1.5f * radius) + (Vector3.right * 0.5f) * radius));
            if (startLocation.Angle >= 180)
            {
                Handles.DrawLine((Vector3.left * 2) * radius, (Vector3.right * 2) * radius);
                Handles.DrawLine((Vector3.left * 2) * radius, ((Vector3.left * 1.5f * radius) + (Vector3.forward * 0.5f) * radius));
                Handles.DrawLine((Vector3.left * 2) * radius, ((Vector3.left * 1.5f * radius) + (Vector3.back * 0.5f) * radius));
                Handles.DrawLine((Vector3.right * 2) * radius, ((Vector3.right * 1.5f * radius) + (Vector3.forward * 0.5f) * radius));
                Handles.DrawLine((Vector3.right * 2) * radius, ((Vector3.right * 1.5f * radius) + (Vector3.back * 0.5f) * radius));
                if (startLocation.Angle == 360)
                {
                    Handles.DrawLine(Vector3.zero, (Vector3.back * 2f) * radius);
                    Handles.DrawLine((Vector3.back * 2) * radius, ((Vector3.back * 1.5f * radius) + (Vector3.left * 0.5f) * radius));
                    Handles.DrawLine((Vector3.back * 2) * radius, ((Vector3.back * 1.5f * radius) + (Vector3.right * 0.5f) * radius));
                }
            }
        }
コード例 #49
0
        static void DrawSpawnPointGizmo(SpawnPoint spawnPoint, GizmoType gizmoType)
        {
            var transform = spawnPoint.transform;

            Gizmos.matrix = Matrix4x4.TRS(transform.position, transform.rotation, transform.lossyScale);

            Gizmos.color = spawnPoint.GizmoColor;
            var position = Vector3.zero;

            if (spawnPoint.Shape == SpawnPoint.SpawnShape.Point || spawnPoint.Shape == SpawnPoint.SpawnShape.Sphere)
            {
                var size = spawnPoint.Shape == SpawnPoint.SpawnShape.Sphere ? spawnPoint.Size : 0.2f;
                Gizmos.DrawSphere(position, size);

                // Draw the outline when the component is selected.
                if (MathUtility.InLayerMask((int)GizmoType.Selected, (int)gizmoType))
                {
                    Gizmos.color = InspectorUtility.GetContrastColor(spawnPoint.GizmoColor);
                    Gizmos.DrawWireSphere(position, size);
                }
            }
            else if (spawnPoint.Shape == SpawnPoint.SpawnShape.Box)
            {
                var size = Vector3.zero;
                size.x    = size.z = spawnPoint.Size;
                size.y    = spawnPoint.GroundSnapHeight;
                position += spawnPoint.transform.up * size.y / 2;
                Gizmos.DrawCube(position, size);

                // Draw the outline when the component is selected.
                if (MathUtility.InLayerMask((int)GizmoType.Selected, (int)gizmoType))
                {
                    Gizmos.color = InspectorUtility.GetContrastColor(spawnPoint.GizmoColor);
                    Gizmos.DrawWireCube(position, size);
                }
            }

            if (MathUtility.InLayerMask((int)GizmoType.Selected, (int)gizmoType))
            {
                // The Gizmo class cannot draw a wire disk.
                Handles.color = InspectorUtility.GetContrastColor(spawnPoint.GizmoColor);
                Handles.DrawWireDisc(spawnPoint.transform.position, spawnPoint.transform.up, 1);

                // Draw directional arrows when selected.
                var rad = spawnPoint.Size > 0 ? spawnPoint.Size : 1;
                if (spawnPoint.RandomDirection)
                {
                    // Draw four big arrows, relative to the spawnpoint and perpendicular to each other.
                    Gizmos.DrawLine((Vector3.back * 2) * rad, (Vector3.forward * 2) * rad);
                    Gizmos.DrawLine((Vector3.left * 2) * rad, (Vector3.right * 2) * rad);
                    Gizmos.DrawLine((Vector3.forward * 2) * rad, (Vector3.forward * 1.5f * rad) + (Vector3.left * 0.5f) * rad);
                    Gizmos.DrawLine((Vector3.forward * 2) * rad, (Vector3.forward * 1.5f * rad) + (Vector3.right * 0.5f) * rad);
                    Gizmos.DrawLine((Vector3.back * 2) * rad, (Vector3.back * 1.5f * rad) + (Vector3.left * 0.5f) * rad);
                    Gizmos.DrawLine((Vector3.back * 2) * rad, (Vector3.back * 1.5f * rad) + (Vector3.right * 0.5f) * rad);
                    Gizmos.DrawLine((Vector3.left * 2) * rad, (Vector3.left * 1.5f * rad) + (Vector3.forward * 0.5f) * rad);
                    Gizmos.DrawLine((Vector3.left * 2) * rad, (Vector3.left * 1.5f * rad) + (Vector3.back * 0.5f) * rad);
                    Gizmos.DrawLine((Vector3.right * 2) * rad, (Vector3.right * 1.5f * rad) + (Vector3.forward * 0.5f) * rad);
                    Gizmos.DrawLine((Vector3.right * 2) * rad, (Vector3.right * 1.5f * rad) + (Vector3.back * 0.5f) * rad);
                }
                else
                {
                    // Draw a single big arrow pointing in the spawnpoint's forward direction.
                    Gizmos.DrawLine(Vector3.zero, (Vector3.forward * 2) * rad);
                    Gizmos.DrawLine((Vector3.forward * 2) * rad, (Vector3.forward * 1.5f * rad) + (Vector3.left * 0.5f) * rad);
                    Gizmos.DrawLine((Vector3.forward * 2) * rad, (Vector3.forward * 1.5f * rad) + (Vector3.right * 0.5f) * rad);
                }
            }
        }
        public static void DrawGizmos(PlanarReflectionProbe d, GizmoType gizmoType)
        {
            PlanarReflectionProbeUI s;

            if (!PlanarReflectionProbeEditor.TryGetUIStateFor(d, out s))
            {
                return;
            }

            var mat = d.transform.localToWorldMatrix;

            switch (EditMode.editMode)
            {
            case EditBaseShape:
                InfluenceVolumeUI.DrawGizmos(
                    s.influenceVolume,
                    d.influenceVolume,
                    mat,
                    InfluenceVolumeUI.HandleType.Base,
                    InfluenceVolumeUI.HandleType.All);
                break;

            case EditInfluenceShape:
                InfluenceVolumeUI.DrawGizmos(
                    s.influenceVolume,
                    d.influenceVolume,
                    mat,
                    InfluenceVolumeUI.HandleType.Influence,
                    InfluenceVolumeUI.HandleType.All);
                break;

            case EditInfluenceNormalShape:
                InfluenceVolumeUI.DrawGizmos(
                    s.influenceVolume,
                    d.influenceVolume,
                    mat,
                    InfluenceVolumeUI.HandleType.InfluenceNormal,
                    InfluenceVolumeUI.HandleType.All);
                break;

            default:
            {
                var showedHandles = s.influenceVolume.showInfluenceHandles
                            ? InfluenceVolumeUI.HandleType.All
                            : InfluenceVolumeUI.HandleType.Base;
                InfluenceVolumeUI.DrawGizmos(
                    s.influenceVolume,
                    d.influenceVolume,
                    mat,
                    InfluenceVolumeUI.HandleType.None,
                    showedHandles);
                break;
            }
            }

            if (d.proxyVolumeReference != null)
            {
                ReflectionProxyVolumeComponentUI.DrawGizmos_EditNone(s.reflectionProxyVolume, d.proxyVolumeReference);
            }

            var showFrustrum = s.showCaptureHandles ||
                               EditMode.editMode == EditCenter;
            var showCaptureMirror = (s.showCaptureHandles && d.useMirrorPlane) ||
                                    EditMode.editMode == EditMirrorPosition ||
                                    EditMode.editMode == EditMirrorRotation;

            if (showFrustrum)
            {
                DrawGizmos_CaptureFrustrum(s, d);
            }

            if (showCaptureMirror)
            {
                DrawGizmos_CaptureMirror(s, d);
            }
        }
コード例 #51
0
 static void RenderBoxGizmoSelected(NavMeshSurface navSurface, GizmoType gizmoType)
 {
     RenderBoxGizmo(navSurface, gizmoType, true);
 }
コード例 #52
0
 static void DrawGizmosSelected(Projectile projectile, GizmoType gizmoType)
 {
     Gizmos.DrawWireSphere(projectile.transform.position, projectile.damageRadius);
 }
コード例 #53
0
        private static void DrawTransposerGizmos(CinemachineOrbitalTransposer target, GizmoType selectionType)
        {
            if (target.IsValid)
            {
                var originalGizmoColour = Gizmos.color;
                Gizmos.color = CinemachineCore.Instance.IsLive(target.VirtualCamera)
                    ? CinemachineSettings.CinemachineCoreSettings.ActiveGizmoColour
                    : CinemachineSettings.CinemachineCoreSettings.InactiveGizmoColour;

                var up    = Vector3.up;
                var brain = CinemachineCore.Instance.FindPotentialTargetBrain(target.VirtualCamera);
                if (brain != null)
                {
                    up = brain.DefaultWorldUp;
                }
                var pos = target.FollowTarget.position;

                var orient = target.GetReferenceOrientation(up);
                up = orient * Vector3.up;
                DrawCircleAtPointWithRadius
                    (pos + up * target.m_FollowOffset.y, orient, target.m_FollowOffset.z);

                Gizmos.color = originalGizmoColour;
            }
        }
コード例 #54
0
    static void ColliderGizmoDraw(GameObject go, GizmoType gt)
    {
        if (!debugViewEnabled)
        {
            return;
        }

        if (go.tag == "Player")
        {
            // Scaler
            for (int x = -10; x < 10; x++)
            {
                Vector3 vecA = go.transform.position + Vector3.left * x;
                Vector3 vecB = vecA + Vector3.up;
                Gizmos.color = (Mathf.Abs(x) < 5) ? Color.red : Color.white;
                Gizmos.DrawLine(vecA, vecB);
            }
            for (int x = -10; x < 10; x++)
            {
                Vector3 vecA = go.transform.position + Vector3.up * x;
                Vector3 vecB = vecA + Vector3.left;
                Gizmos.color = (Mathf.Abs(x) < 5) ? Color.red : Color.white;
                Gizmos.DrawLine(vecA, vecB);
            }
        }
        else
        if (go.tag == "Enemy")
        {
            // AI Status
            Gizmos.color = Color.red;
            Gizmos.DrawCube(go.transform.position, new Vector3(0.1f, 0.1f, 0.1f));
            GUIStyle style = new GUIStyle();
            style.active.textColor  = Color.red;
            style.normal.textColor  = Color.red;
            style.hover.textColor   = Color.red;
            style.focused.textColor = Color.red;

            EnemyMain em = go.GetComponent <EnemyMain>();
            if (em == null)
            {
                return;
            }

            if (em.cameraEnabled)
            {
                Handles.Label(go.transform.position,
                              string.Format("{0} {1} {2}",
                                            em.aiState,
                                            em.GetComponent <EnemyController>().grounded,
                                            em.GetDistanePlayer()));
            }

            // Dog Pile
            Gizmos.color = Color.red;
            StageObject_DogPile[] dogPileList = GameObject.FindObjectsOfType <StageObject_DogPile>();
            foreach (StageObject_DogPile dogPile in dogPileList)
            {
                foreach (GameObject enemy in dogPile.enemyList)
                {
                    if (go == enemy)
                    {
                        Gizmos.DrawLine(go.transform.position, dogPile.transform.position);
                        return;
                    }
                }
            }
        }
    }
コード例 #55
0
 static void DrawGizmos(UniventComponent uevh, GizmoType gizmoType)
 {
     Gizmos.DrawIcon(uevh.transform.position, "Univent/univenticon.png", false);
     DrawLines(uevh, 0.5f);
 }
コード例 #56
0
        internal static void DrawVirtualCameraBaseGizmos(CinemachineVirtualCameraBase vcam, GizmoType selectionType)
        {
            // Don't draw gizmos on hidden stuff
            if ((vcam.VirtualCameraGameObject.hideFlags & (HideFlags.HideInHierarchy | HideFlags.HideInInspector)) != 0)
            {
                return;
            }

            if (vcam.ParentCamera != null && (selectionType & GizmoType.Active) == 0)
            {
                return;
            }

            CameraState state = vcam.State;

            Gizmos.DrawIcon(state.FinalPosition, "Cinemachine/cm_logo_lg.png", true);

            CinemachineBrainEditor.DrawCameraFrustumGizmo(
                CinemachineCore.Instance.FindPotentialTargetBrain(vcam),
                state.Lens,
                Matrix4x4.TRS(
                    state.FinalPosition,
                    UnityQuaternionExtensions.Normalized(state.FinalOrientation), Vector3.one),
                CinemachineCore.Instance.IsLive(vcam)
                    ? CinemachineSettings.CinemachineCoreSettings.ActiveGizmoColour
                    : CinemachineSettings.CinemachineCoreSettings.InactiveGizmoColour);
        }
コード例 #57
0
    static void ColliderGizmoDraw(GameObject cv2, GizmoType gt)
    {
        if (!colliderViewEnabled)
        {
            return;
        }

        Gizmos.color = Color.blue;
        Gizmos.DrawCube(cv2.transform.position, new Vector3(0.1f, 0.1f, 0.1f));

        Handles.Label(cv2.transform.position, "[Collider] ON");

        BoxCollider2D[] bcs = cv2.GetComponents <BoxCollider2D> ();
        foreach (BoxCollider2D bc in bcs)
        {
            Vector3 pos = new Vector3(bc.center.x, bc.center.y, 0.0f);

            Vector3 p1 = cv2.transform.position + pos + new Vector3(-bc.size.x / 2.0f, -bc.size.y / 2.0f, 0.0f);
            Vector3 p2 = cv2.transform.position + pos + new Vector3(+bc.size.x / 2.0f, -bc.size.y / 2.0f, 0.0f);
            Vector3 p3 = cv2.transform.position + pos + new Vector3(+bc.size.x / 2.0f, +bc.size.y / 2.0f, 0.0f);
            Vector3 p4 = cv2.transform.position + pos + new Vector3(-bc.size.x / 2.0f, +bc.size.y / 2.0f, 0.0f);

            Gizmos.color = Color.red;
            Gizmos.DrawLine(p1, p2);
            Gizmos.DrawLine(p2, p3);
            Gizmos.DrawLine(p3, p4);
            Gizmos.DrawLine(p4, p1);
        }

        CircleCollider2D[] bcs2 = cv2.GetComponents <CircleCollider2D> ();
        foreach (CircleCollider2D bc in bcs2)
        {
            Vector3 pos = new Vector3(bc.center.x, bc.center.y, 0.0f);

            //Gizmos.color = Color.red;
            //Gizmos.DrawWireSphere (transform.position + pos, bc.radius);

            Gizmos.color = Color.red;
            int cmax = 16;
            for (int i = 0; i < cmax; i++)
            {
                Vector3 p1 = cv2.transform.position + pos + Quaternion.Euler(0.0f, 0.0f, 360.0f / cmax * (i + 0)) * new Vector3(bc.radius, 0.0f, 0.0f);
                Vector3 p2 = cv2.transform.position + pos + Quaternion.Euler(0.0f, 0.0f, 360.0f / cmax * (i + 1)) * new Vector3(bc.radius, 0.0f, 0.0f);
                Gizmos.DrawLine(p1, p2);
            }
        }

        EdgeCollider2D[] bcs3 = cv2.GetComponents <EdgeCollider2D> ();
        foreach (EdgeCollider2D bc in bcs3)
        {
            for (int i = 0; i < bc.pointCount - 1; i++)
            {
                Vector3 p1 = cv2.transform.position + new Vector3(bc.points[i + 0].x, bc.points[i + 0].y);
                Vector3 p2 = cv2.transform.position + new Vector3(bc.points[i + 1].x, bc.points[i + 1].y);
                Gizmos.DrawLine(p1, p2);
            }
        }

        PolygonCollider2D[] bcs4 = cv2.GetComponents <PolygonCollider2D> ();
        foreach (PolygonCollider2D bc in bcs4)
        {
            for (int i = 0; i < bc.pathCount - 1; i++)
            {
                Vector3 p1 = cv2.transform.position + new Vector3(bc.points[i + 0].x, bc.points[i + 0].y);
                Vector3 p2 = cv2.transform.position + new Vector3(bc.points[i + 1].x, bc.points[i + 1].y);
                Gizmos.DrawLine(p1, p2);
            }
        }
    }
コード例 #58
0
 static void RenderGizmo(MegaModifier mod, GizmoType gizmoType)
 {
 }
コード例 #59
0
 public static void OnDrawGizmos(GrendelObjectData grendelObject, GizmoType gizmoType)
 {
 }
コード例 #60
0
 static void DrawGizmo(PathInterpolatorBounds pathInterpolatorBounds, GizmoType gizmoType)
 {
     pathInterpolatorBounds.DrawGizmo(Color.white);
 }