C# Canvas.FillCircle方法代码示例

		void ICmpRenderer.Draw(IDrawDevice device)
		{
			Canvas canvas = new Canvas(device);

			// Draw the mouse cursor when available
			if (DualityApp.Mouse.IsAvailable)
			{
				canvas.State.ColorTint = ColorRgba.White;
				canvas.FillCircle(
					DualityApp.Mouse.X, 
					DualityApp.Mouse.Y, 
					2);
			}
		}

		void ICmpRenderer.Draw(IDrawDevice device)
		{
			Canvas canvas = new Canvas(device);
			
			// Update input stats texts for drawing
			this.WriteInputStats(ref this.mouseStatsText, DualityApp.Mouse);
			this.WriteInputStats(ref this.keyboardStatsText, DualityApp.Keyboard);
			this.WriteInputStats(ref this.joystickStatsText, DualityApp.Joysticks);
			this.WriteInputStats(ref this.gamepadStatsText, DualityApp.Gamepads);

			// Draw input stats texts
			{
				int y = 10;

				canvas.DrawText(this.mouseStatsText, 10, y, 0, null, Alignment.TopLeft, true);
				y += 20 + (int)this.mouseStatsText.TextMetrics.Size.Y;

				canvas.DrawText(this.keyboardStatsText, 10, y, 0, null, Alignment.TopLeft, true);
				y += 20 + (int)this.keyboardStatsText.TextMetrics.Size.Y;

				canvas.DrawText(this.joystickStatsText, 10, y, 0, null, Alignment.TopLeft, true);
				y += 20 + (int)this.joystickStatsText.TextMetrics.Size.Y;

				canvas.DrawText(this.gamepadStatsText, 10, y, 0, null, Alignment.TopLeft, true);
				y += 20 + (int)this.gamepadStatsText.TextMetrics.Size.Y;
			}

			// Draw the mouse cursor's movement trail
			if (DualityApp.Mouse.IsAvailable)
			{
				canvas.State.ColorTint = new ColorRgba(128, 192, 255, 128);
				canvas.FillThickLine(
					DualityApp.Mouse.X - DualityApp.Mouse.XSpeed, 
					DualityApp.Mouse.Y - DualityApp.Mouse.YSpeed, 
					DualityApp.Mouse.X, 
					DualityApp.Mouse.Y, 
					2);
				// Draw the mouse cursor at its local window coordiates
				canvas.State.ColorTint = ColorRgba.White;
				canvas.FillCircle(
					DualityApp.Mouse.X, 
					DualityApp.Mouse.Y, 
					2);
			}
		}

		public override void Draw(Canvas target, Vector3 basePos, float baseRotation, float baseScale)
		{
			float circleRadius = 5.0f;
			float borderRadius = DefaultOutlineWidth;

			// Scale anti-proportional to perspective scale in order to keep a constant size 
			// in screen space even when actually drawing in world space.
			{
				float scale = 1.0f;
				Vector3 posTemp = this.pos + basePos;
				target.DrawDevice.PreprocessCoords(ref posTemp, ref scale);
				circleRadius /= scale;
				borderRadius /= scale;
			}

			// Determine circle position
			Vector3 circlePos = this.pos;
			MathF.TransformCoord(ref circlePos.X, ref circlePos.Y, baseRotation, baseScale);
			circlePos += basePos;

			// Draw circle
			target.State.ColorTint *= this.Color;
			target.FillCircle(
				circlePos.X, 
				circlePos.Y, 
				circlePos.Z, 
				circleRadius - borderRadius * 0.5f);

			// Draw circle outline
			if (target.DrawDevice.DepthWrite) target.State.ZOffset -= 1;
			target.State.ColorTint *= ColorRgba.Black;
			target.FillCircleSegment(
				circlePos.X, 
				circlePos.Y, 
				circlePos.Z, 
				circleRadius, 
				0.0f, 
				MathF.RadAngle360, 
				borderRadius);
		}

		private void DrawTestImageRow(Canvas c, int baseX, int baseY)
		{
			Vector2[] polygon = new Vector2[]
			{ 
				new Vector2(0.0f, 0.0f), 
				new Vector2(50.0f, 0.0f), 
				new Vector2(50.0f, 45.0f), 
				new Vector2(5.0f, 50.0f), 
			};

			int x = baseX;
			int y = baseY;

			// Outline Shapes
			c.PushState();
			{
				c.DrawCircle(x, y, 25);
				x += 100;

				c.DrawCircleSegment(x, y, 25, 0.0f, MathF.RadAngle30 * 4, true);
				x += 100;

				c.DrawLine(x, y , x + 50, y + 25);
				c.DrawDashLine(x, y + 25, x + 50, y + 50);
				c.DrawThickLine(x, y + 50, x + 50, y + 75, 3);
				x += 100;

				c.DrawOval(x, y, 50, 50);
				x += 100;

				c.DrawOvalSegment(x, y, 50, 50, 0.0f, MathF.RadAngle30 * 4, true);
				x += 100;

				c.DrawPolygon(polygon, x, y);
				x += 100;

				c.DrawRect(x, y, 50, 50);
				x += 100;

				c.DrawText("Hello World", x, y, drawBackground: true);
				x = baseX;
				y += 100;
			}
			c.PopState();

			// Filled Shapes
			c.PushState();
			{
				c.FillCircle(x, y, 25);
				x += 100;

				c.FillCircleSegment(x, y, 0, 25, MathF.RadAngle30 * 0, MathF.RadAngle30 * 4);
				c.FillCircleSegment(x, y, 0, 25, MathF.RadAngle30 * 5, MathF.RadAngle30 * 9, 10);
				x += 100;

				c.FillThickLine(x, y + 25, x + 50, y + 50, 3);
				x += 100;

				c.FillOval(x, y, 50, 50);
				x += 100;

				c.FillOvalSegment(x, y, 0, 50, 50, MathF.RadAngle30 * 0, MathF.RadAngle30 * 4);
				c.FillOvalSegment(x, y, 0, 50, 50, MathF.RadAngle30 * 5, MathF.RadAngle30 * 9, 10);
				x += 100;

				c.FillPolygon(polygon, x, y);
				x += 100;

				c.FillRect(x, y, 50, 50);
				x = baseX;
				y += 100;
			}
			c.PopState();
		}

        private void DrawWorldAnchor(Canvas canvas, RigidBody body, Vector2 anchor)
        {
            Vector3 colliderPos = body.GameObj.Transform.Pos;
            float markerCircleRad = body.BoundRadius * 0.02f;
            ColorRgba clr = this.JointColor;

            canvas.State.SetMaterial(new BatchInfo(DrawTechnique.Alpha, clr));
            canvas.FillCircle(
                anchor.X,
                anchor.Y,
                colliderPos.Z,
                markerCircleRad);
        }

        private void DrawLocalFrictionMarker(Canvas canvas, RigidBody body, Vector2 anchor)
        {
            Vector3 colliderPos = body.GameObj.Transform.Pos;

            ColorRgba clr = this.JointColor;
            float markerCircleRad = body.BoundRadius * 0.02f;
            Vector2 anchorToWorld = body.GameObj.Transform.GetWorldVector(anchor);

            canvas.State.SetMaterial(new BatchInfo(DrawTechnique.Alpha, clr));
            canvas.FillCircle(
                colliderPos.X + anchorToWorld.X,
                colliderPos.Y + anchorToWorld.Y,
                colliderPos.Z,
                markerCircleRad * 0.5f);
            canvas.DrawCircle(
                colliderPos.X + anchorToWorld.X,
                colliderPos.Y + anchorToWorld.Y,
                colliderPos.Z,
                markerCircleRad);
            canvas.DrawCircle(
                colliderPos.X + anchorToWorld.X,
                colliderPos.Y + anchorToWorld.Y,
                colliderPos.Z,
                markerCircleRad * 1.5f);
        }

		protected virtual void OnCollectStateOverlayDrawcalls(Canvas canvas)
		{
			// Gather general data
			Point cursorPos = this.PointToClient(Cursor.Position);

			// Update action text from hovered / selection / action object
			Vector2 actionTextPos = new Vector2(cursorPos.X + 30, cursorPos.Y + 10);
			this.actionText.SourceText = this.UpdateActionText(ref actionTextPos);

			// Collect the views overlay layer drawcalls
			this.CollectLayerOverlayDrawcalls(canvas);

			// Collect the states overlay drawcalls
			canvas.PushState();
			{
				// Draw camera movement indicators
				if (this.camAction != CameraAction.None)
				{
					canvas.PushState();
					canvas.State.ColorTint = ColorRgba.White.WithAlpha(0.5f);
					if (this.camAction == CameraAction.DragScene)
					{
						// Don't draw anything.
					}
					else if (this.camAction == CameraAction.RotateScene)
					{
						canvas.FillCircle(this.camActionBeginLoc.X, this.camActionBeginLoc.Y, 3);
						canvas.DrawLine(this.camActionBeginLoc.X, this.camActionBeginLoc.Y, cursorPos.X, this.camActionBeginLoc.Y);
					}
					else if (this.camAction == CameraAction.Move)
					{
						canvas.FillCircle(this.camActionBeginLoc.X, this.camActionBeginLoc.Y, 3);
						canvas.DrawLine(this.camActionBeginLoc.X, this.camActionBeginLoc.Y, cursorPos.X, cursorPos.Y);
					}
					else if (this.camAction == CameraAction.Rotate)
					{
						canvas.FillCircle(this.camActionBeginLoc.X, this.camActionBeginLoc.Y, 3);
						canvas.DrawLine(this.camActionBeginLoc.X, this.camActionBeginLoc.Y, cursorPos.X, this.camActionBeginLoc.Y);
					}
					canvas.PopState();
				}
				
				// Normalize action text position
				if (this.actionText.Fonts != null && this.actionText.Fonts.Any(r => r.IsAvailable && r.Res.IsPixelGridAligned))
				{
					actionTextPos.X = MathF.Round(actionTextPos.X);
					actionTextPos.Y = MathF.Round(actionTextPos.Y);
				}

				// Draw current action text
				if (!this.actionText.IsEmpty)
				{
					canvas.DrawText(this.actionText, actionTextPos.X, actionTextPos.Y, drawBackground: true);
				}

				// Update / Draw current status text
				{
					this.statusText.SourceText = this.UpdateStatusText();
					if (!this.statusText.IsEmpty)
					{
						Vector2 statusTextSize = this.statusText.Size;
						canvas.DrawText(this.statusText, 10, this.ClientSize.Height - statusTextSize.Y - 10, drawBackground: true);
					}
				}
			}
			canvas.PopState();

			// Draw a focus indicator at the view border
			canvas.PushState();
			{
				ColorRgba focusColor = ColorRgba.Lerp(this.FgColor, this.BgColor, 0.25f).WithAlpha(255);
				ColorRgba noFocusColor = ColorRgba.Lerp(this.FgColor, this.BgColor, 0.75f).WithAlpha(255);
				canvas.State.SetMaterial(new BatchInfo(DrawTechnique.Mask, this.Focused ? focusColor : noFocusColor));
				canvas.DrawRect(0, 0, this.ClientSize.Width, this.ClientSize.Height);
			}
			canvas.PopState();
		}

        public override void Draw(Canvas target, Vector3 basePos, float baseRotation, float baseScale)
        {
            float originRadius = 5.0f;
            float vectorThickness = 4.0f;
            float borderRadius = DefaultOutlineWidth;

            // Scale anti-proportional to perspective scale in order to keep a constant size
            // in screen space even when actually drawing in world space.
            {
                float scale = 1.0f;
                Vector3 posTemp = this.posA + basePos;
                target.DrawDevice.PreprocessCoords(ref posTemp, ref scale);
                originRadius /= scale;
                borderRadius /= scale;
                vectorThickness /= scale;
            }

            // Determine base and target positions
            Vector3 originPos = this.posA;
            Vector3 targetPos = this.posB;
            MathF.TransformCoord(ref originPos.X, ref originPos.Y, baseRotation, baseScale);
            MathF.TransformCoord(ref targetPos.X, ref targetPos.Y, baseRotation, baseScale);
            originPos += basePos;
            targetPos += basePos;

            // Create connection polygon
            float vectorLen = (targetPos.Xy - originPos.Xy).Length;
            Vector2 dirForward = (targetPos.Xy - originPos.Xy).Normalized;
            Vector2 dirLeft = dirForward.PerpendicularLeft;
            Vector2 dirRight = -dirLeft;
            Vector2[] connection = new Vector2[4];
            connection[0] = dirLeft * vectorThickness * 0.5f;
            connection[1] = dirLeft * vectorThickness * 0.5f + dirForward * vectorLen;
            connection[2] = dirRight * vectorThickness * 0.5f + dirForward * vectorLen;
            connection[3] = dirRight * vectorThickness * 0.5f;

            // Draw vector and outline
            ColorRgba areaColor = target.State.ColorTint * this.Color;
            ColorRgba outlineColor = areaColor * ColorRgba.Black;
            target.State.ColorTint = areaColor;
            target.FillPolygon(
                connection,
                originPos.X,
                originPos.Y,
                originPos.Z);
            if (target.DrawDevice.DepthWrite) target.State.ZOffset -= 0.1f;
            target.State.ColorTint = outlineColor;
            target.FillPolygonOutline(
                connection,
                borderRadius,
                originPos.X,
                originPos.Y,
                originPos.Z);

            // Draw connection points and outline
            if (target.DrawDevice.DepthWrite) target.State.ZOffset -= 0.1f;
            target.State.ColorTint = areaColor;
            target.FillCircle(
                originPos.X,
                originPos.Y,
                originPos.Z,
                originRadius - borderRadius * 0.5f);
            target.FillCircle(
                targetPos.X,
                targetPos.Y,
                targetPos.Z,
                originRadius - borderRadius * 0.5f);
            if (target.DrawDevice.DepthWrite) target.State.ZOffset -= 0.1f;
            target.State.ColorTint = outlineColor;
            target.FillCircleSegment(
                originPos.X,
                originPos.Y,
                originPos.Z,
                originRadius,
                0.0f,
                MathF.RadAngle360,
                borderRadius);
            target.FillCircleSegment(
                targetPos.X,
                targetPos.Y,
                targetPos.Z,
                originRadius,
                0.0f,
                MathF.RadAngle360,
                borderRadius);
        }

//.........这里部分代码省略.........
                        Vector2 renderStartPos = worldOriginPos + tileGridPos.X * tileSize.X * worldAxisX + tileGridPos.Y * tileSize.Y * worldAxisY;;
                        Vector2 renderPos = renderStartPos;
                        Vector2 tileXStep = worldAxisX * tileSize.X;
                        Vector2 tileYStep = worldAxisY * tileSize.Y;
                        int lineMergeCount = 0;
                        int totalRects = 0;
                        for (int tileIndex = 0; tileIndex < renderedTileCount; tileIndex++)
                        {
                            bool current = highlight[tileGridPos.X, tileGridPos.Y];
                            if (current)
                            {
                                // Try to merge consecutive rects in the same line to reduce drawcalls / CPU load
                                bool hasNext = (tileGridPos.X + 1 < highlight.Width) && ((tileGridPos.X + 1 - cullingOut.VisibleTileStart.X) < cullingOut.VisibleTileCount.X);
                                bool next = hasNext ? highlight[tileGridPos.X + 1, tileGridPos.Y] : false;
                                if (next)
                                {
                                    lineMergeCount++;
                                }
                                else
                                {
                                    totalRects++;
                                    canvas.FillRect(
                                        transform.Pos.X + renderPos.X - lineMergeCount * tileXStep.X,
                                        transform.Pos.Y + renderPos.Y - lineMergeCount * tileXStep.Y,
                                        transform.Pos.Z,
                                        tileSize.X * (1 + lineMergeCount),
                                        tileSize.Y);
                                    lineMergeCount = 0;
                                }
                            }

                            tileGridPos.X++;
                            renderPos += tileXStep;
                            if ((tileGridPos.X - cullingOut.VisibleTileStart.X) >= cullingOut.VisibleTileCount.X)
                            {
                                tileGridPos.X = cullingOut.VisibleTileStart.X;
                                tileGridPos.Y++;
                                renderPos = renderStartPos;
                                renderPos += tileYStep * (tileGridPos.Y - cullingOut.VisibleTileStart.Y);
                            }
                        }
                    }
                }

                // Draw highlight area outlines, unless flagged as uncertain
                if (!uncertain)
                {
                    // Determine the outlines of individual highlighted tile patches
                    if (outlineCache == null) outlineCache = new List<Vector2[]>();
                    if (outlineCache.Count == 0)
                    {
                        GetTileAreaOutlines(highlight, tileSize, ref outlineCache);
                    }

                    // Draw outlines around all highlighted tile patches
                    canvas.State.SetMaterial(selection ? strippleMaterial : defaultMaterial);
                    canvas.State.ColorTint = outlineTint;
                    foreach (Vector2[] outline in outlineCache)
                    {
                        // For strippled-line display, determine total length of outline
                        if (selection)
                        {
                            float totalLength = 0.0f;
                            for (int i = 1; i < outline.Length; i++)
                            {
                                totalLength += (outline[i - 1] - outline[i]).Length;
                            }
                            canvas.State.TextureCoordinateRect = new Rect(totalLength / strippledLineTex.PixelWidth, 1.0f);
                        }

                        // Draw the outline
                        canvas.DrawPolygon(
                            outline,
                            transform.Pos.X + worldOriginPos.X,
                            transform.Pos.Y + worldOriginPos.Y,
                            transform.Pos.Z);
                    }
                }

                // If this is an uncertain highlight, i.e. not actually reflecting the represented action,
                // draw a gizmo to indicate this for the user.
                if (uncertain)
                {
                    Vector2 highlightSize = new Vector2(highlight.Width * tileSize.X, highlight.Height * tileSize.Y);
                    Vector2 highlightCenter = highlightSize * 0.5f;

                    Vector3 circlePos = transform.Pos + new Vector3(worldOriginPos + worldAxisX * highlightCenter + worldAxisY * highlightCenter);
                    float circleRadius = MathF.Min(tileSize.X, tileSize.Y) * 0.2f;

                    canvas.State.SetMaterial(defaultMaterial);
                    canvas.State.ColorTint = outlineTint;
                    canvas.FillCircle(
                        circlePos.X,
                        circlePos.Y,
                        circlePos.Z,
                        circleRadius);
                }
            }
            canvas.PopState();
        }

		void ICmpRenderer.Draw(IDrawDevice device)
		{
			Canvas canvas = new Canvas(device);
			
			Vector2 screenSize = device.TargetSize;
			ICameraController activeController = this.mainCameraObj.GetComponent<ICameraController>();
			Transform camTransform = this.mainCameraObj.Transform;
			Transform targetTransform = this.targetObj.Transform;

			float camDist = (camTransform.Pos.Xy - targetTransform.Pos.Xy).Length;
			string activeControllerName = activeController != null ? activeController.GetType().Name : "None";
			activeControllerName = activeControllerName.Replace("CameraController", "");

			// Draw the screen center, so we know what exactly our camera controller is pointing at
			canvas.State.ColorTint = ColorRgba.Green.WithAlpha(0.5f);
			canvas.FillCircle(screenSize.X * 0.5f, screenSize.Y * 0.5f, 8.0f);

			// Draw the camera distance around the screen center
			canvas.State.ColorTint = ColorRgba.Green.WithAlpha(0.25f);
			canvas.DrawCircle(screenSize.X * 0.5f, screenSize.Y * 0.5f, camDist);

			// Draw the camera velocity (movement per second) around the screen center
			canvas.State.ColorTint = ColorRgba.Green.WithAlpha(0.5f);
			canvas.DrawLine(
				screenSize.X * 0.5f, 
				screenSize.Y * 0.5f, 
				screenSize.X * 0.5f + camTransform.Vel.X / Time.SPFMult, 
				screenSize.Y * 0.5f + camTransform.Vel.Y / Time.SPFMult);

			// Draw some info text
			if (this.infoText == null)
			{
				this.infoText = new FormattedText();
				this.infoText.MaxWidth = 350;
			}
			this.infoText.SourceText = string.Format(
				"Camera Controller Sample/n/n" +
				"Use /c44AAFFFFarrow keys/cFFFFFFFF // /c44AAFFFFleft thumbstick/cFFFFFFFF to move./n" + 
				"Use /c44AAFFFFnumber keys 1, 2/cFFFFFFFF // /c44AAFFFFbuttons A, B/cFFFFFFFF to select a Camera Controller./n" + 
				"Use the /c44AAFFFFM key/cFFFFFFFF // /c44AAFFFFbutton X/cFFFFFFFF to toggle movement history./n/n" + 
				"Active Camera Controller:/n/cFF8800FF{0}/cFFFFFFFF",
				activeControllerName);

			canvas.State.ColorTint = ColorRgba.White;
			canvas.DrawText(this.infoText, 10, 10, 0.0f, null, Alignment.TopLeft, true);

			// Draw state information on the current camera controller
			if (this.stateText == null) this.stateText = new FormattedText();
			this.stateText.SourceText = string.Format(
				"Camera Distance: {0:F}/n" +
				"Camera Velocity: {1:F}, {2:F}",
				camDist,
				camTransform.Vel.X,
				camTransform.Vel.Y);

			canvas.State.ColorTint = ColorRgba.White;
			canvas.DrawText(this.stateText, 10, screenSize.Y - 10, 0.0f, null, Alignment.BottomLeft, true);
		}

		public override void Draw(Canvas target, Vector3 basePos, float baseRotation, float baseScale)
		{
			float originRadius = 5.0f;
			float vectorThickness = 4.0f;
			float borderRadius = DefaultOutlineWidth;
			float vectorLengthFactor = 1.0f;

			// Scale anti-proportional to perspective scale in order to keep a constant size 
			// in screen space even when actually drawing in world space.
			{
				float scale = 1.0f;
				Vector3 posTemp = this.origin + basePos;
				target.DrawDevice.PreprocessCoords(ref posTemp, ref scale);
				originRadius /= scale;
				borderRadius /= scale;
				vectorThickness /= scale;
				if (this.invariantScale) vectorLengthFactor /= scale;
			}


			// Determine base and target positions
			Vector3 originPos = this.origin;
			Vector3 targetPos = this.origin + new Vector3(this.vec * vectorLengthFactor);
			MathF.TransformCoord(ref originPos.X, ref originPos.Y, baseRotation, baseScale);
			MathF.TransformCoord(ref targetPos.X, ref targetPos.Y, baseRotation, baseScale);
			originPos += basePos;
			targetPos += basePos;

			// Downscale vector arrow, if too small for display otherwise
			float vectorLen = (targetPos.Xy - originPos.Xy).Length;
			float vectorLenScale = MathF.Clamp(vectorLen / (vectorThickness * 7.0f), 0.0f, 1.0f);
			vectorThickness *= vectorLenScale;

			// Create arrow polygon
			Vector2 dirForward = (targetPos.Xy - originPos.Xy).Normalized;
			Vector2 dirLeft = dirForward.PerpendicularLeft;
			Vector2 dirRight = -dirLeft;
			Vector2[] arrow = new Vector2[7];
			arrow[0] = dirLeft * vectorThickness * 0.5f;
			arrow[1] = dirLeft * vectorThickness * 0.5f + dirForward * (vectorLen - vectorThickness * 2);
			arrow[2] = dirLeft * vectorThickness * 1.25f + dirForward * (vectorLen - vectorThickness * 2);
			arrow[3] = dirForward * vectorLen;
			arrow[4] = dirRight * vectorThickness * 1.25f + dirForward * (vectorLen - vectorThickness * 2);
			arrow[5] = dirRight * vectorThickness * 0.5f + dirForward * (vectorLen - vectorThickness * 2);
			arrow[6] = dirRight * vectorThickness * 0.5f;
			Vector2[] arrowHead = new Vector2[3];
			arrowHead[0] = arrow[2];
			arrowHead[1] = arrow[3];
			arrowHead[2] = arrow[4];
			Vector2[] arrowLine = new Vector2[4];
			arrowLine[0] = arrow[0];
			arrowLine[1] = arrow[1];
			arrowLine[2] = arrow[5];
			arrowLine[3] = arrow[6];

			// Draw vector and outline
			ColorRgba areaColor = target.State.ColorTint * this.Color;
			ColorRgba outlineColor = areaColor * ColorRgba.Black;
			target.State.ColorTint = areaColor;
			target.FillPolygon(
				arrowLine, 
				originPos.X, 
				originPos.Y, 
				originPos.Z);
			target.FillPolygon(
				arrowHead, 
				originPos.X, 
				originPos.Y, 
				originPos.Z);
			if (target.DrawDevice.DepthWrite) target.State.ZOffset -= 0.1f;
			target.State.ColorTint = outlineColor;
			target.FillPolygonOutline(
				arrow, 
				borderRadius,
				originPos.X, 
				originPos.Y, 
				originPos.Z);

			// Draw origin and outline
			if (target.DrawDevice.DepthWrite) target.State.ZOffset -= 0.1f;
			target.State.ColorTint = areaColor;
			target.FillCircle(
				originPos.X, 
				originPos.Y, 
				originPos.Z, 
				originRadius - borderRadius * 0.5f);
			if (target.DrawDevice.DepthWrite) target.State.ZOffset -= 0.1f;
			target.State.ColorTint = outlineColor;
			target.FillCircleSegment(
				originPos.X, 
				originPos.Y, 
				originPos.Z, 
				originRadius, 
				0.0f, 
				MathF.RadAngle360, 
				borderRadius);
		}

        protected internal override void OnCollectWorldOverlayDrawcalls(Canvas canvas)
        {
            base.OnCollectWorldOverlayDrawcalls(canvas);
            List<RigidBody> visibleColliders = this.QueryVisibleColliders().ToList();

            RigidBody selectedBody = this.QuerySelectedCollider();

            canvas.State.TextFont = Font.GenericMonospace10;
            canvas.State.TextInvariantScale = true;
            canvas.State.ZOffset = -0.5f;
            Font textFont = canvas.State.TextFont.Res;

            // Draw Shape layer
            foreach (RigidBody body in visibleColliders)
            {
                if (!body.Shapes.Any()) continue;
                float colliderAlpha = body == selectedBody ? 1.0f : (selectedBody != null ? 0.25f : 0.5f);
                float maxDensity = body.Shapes.Max(s => s.Density);
                float minDensity = body.Shapes.Min(s => s.Density);
                float avgDensity = (maxDensity + minDensity) * 0.5f;
                Vector3 objPos = body.GameObj.Transform.Pos;
                float objAngle = body.GameObj.Transform.Angle;
                float objScale = body.GameObj.Transform.Scale;
                int index = 0;
                foreach (ShapeInfo shape in body.Shapes)
                {
                    CircleShapeInfo circle = shape as CircleShapeInfo;
                    PolyShapeInfo poly = shape as PolyShapeInfo;
                    ChainShapeInfo chain = shape as ChainShapeInfo;
                    LoopShapeInfo loop = shape as LoopShapeInfo;

                    ObjectEditorCamViewState editorState = this.View.ActiveState as ObjectEditorCamViewState;
                    float shapeAlpha = colliderAlpha * (selectedBody == null || editorState == null || editorState.SelectedObjects.Any(sel => sel.ActualObject == shape) ? 1.0f : 0.5f);
                    float densityRelative = MathF.Abs(maxDensity - minDensity) < 0.01f ? 1.0f : shape.Density / avgDensity;
                    ColorRgba clr = shape.IsSensor ? this.ShapeSensorColor : this.ShapeColor;
                    ColorRgba fontClr = this.FgColor;
                    Vector2 center = Vector2.Zero;

                    if (!body.IsAwake) clr = clr.ToHsva().WithSaturation(0.0f).ToRgba();
                    if (!shape.IsValid) clr = this.ShapeErrorColor;

                    bool fillShape = (poly != null || circle != null);
                    Vector2[] shapeVertices = null;
                    if      (poly  != null) shapeVertices = poly .Vertices;
                    else if (loop  != null) shapeVertices = loop .Vertices;
                    else if (chain != null) shapeVertices = chain.Vertices;

                    if (circle != null)
                    {
                        Vector2 circlePos = circle.Position * objScale;
                        MathF.TransformCoord(ref circlePos.X, ref circlePos.Y, objAngle);

                        if (fillShape)
                        {
                            canvas.State.SetMaterial(new BatchInfo(DrawTechnique.Alpha, clr.WithAlpha((0.25f + densityRelative * 0.25f) * shapeAlpha)));
                            canvas.FillCircle(
                                objPos.X + circlePos.X,
                                objPos.Y + circlePos.Y,
                                objPos.Z,
                                circle.Radius * objScale);
                        }
                        canvas.State.SetMaterial(new BatchInfo(DrawTechnique.Alpha, clr.WithAlpha(shapeAlpha)));
                        canvas.DrawCircle(
                            objPos.X + circlePos.X,
                            objPos.Y + circlePos.Y,
                            objPos.Z,
                            circle.Radius * objScale);

                        center = circlePos;
                    }
                    else if (shapeVertices != null)
                    {
                        ColorRgba vertexFillColor = canvas.State.ColorTint * clr.WithAlpha((0.25f + densityRelative * 0.25f) * shapeAlpha);
                        ColorRgba vertexOutlineColor = canvas.State.ColorTint * clr;

                        // Prepare vertices to submit. We can't use higher-level canvas functionality
                        // here, because we want direct control over the vertex mode.
                        float viewSpaceScale = objScale;
                        Vector3 viewSpacePos = objPos;
                        canvas.DrawDevice.PreprocessCoords(ref viewSpacePos, ref viewSpaceScale);
                        VertexC1P3T2[] drawVertices = new VertexC1P3T2[shapeVertices.Length];
                        for (int i = 0; i < drawVertices.Length; i++)
                        {
                            drawVertices[i].Pos.X = shapeVertices[i].X * viewSpaceScale + viewSpacePos.X;
                            drawVertices[i].Pos.Y = shapeVertices[i].Y * viewSpaceScale + viewSpacePos.Y;
                            drawVertices[i].Pos.Z = viewSpacePos.Z;
                            drawVertices[i].Color = vertexOutlineColor;
                            MathF.TransformCoord(ref drawVertices[i].Pos.X, ref drawVertices[i].Pos.Y, objAngle);
                        }

                        // Calculate the center coordinate
                        for (int i = 0; i < drawVertices.Length; i++)
                            center += shapeVertices[i];
                        center /= shapeVertices.Length;
                        MathF.TransformCoord(ref center.X, ref center.Y, objAngle, objScale);

                        // Make sure to render using an alpha material
                        canvas.State.SetMaterial(new BatchInfo(DrawTechnique.Alpha, ColorRgba.White));

                        // Fill the shape
//.........这里部分代码省略.........

		protected override void OnCollectStateOverlayDrawcalls(Canvas canvas)
		{
			base.OnCollectStateOverlayDrawcalls(canvas);
			if (this.SelObjAction == ObjectAction.None && this.DragMustWait && !this.dragLastLoc.IsEmpty)
			{
				canvas.CurrentState.ColorTint = ColorRgba.White.WithAlpha(this.DragMustWaitProgress);
				canvas.FillCircle(
					this.dragLastLoc.X, 
					this.dragLastLoc.Y, 
					15.0f);
				canvas.CurrentState.ColorTint = ColorRgba.White;
				canvas.DrawCircle(
					this.dragLastLoc.X, 
					this.dragLastLoc.Y, 
					15.0f);
			}
		}

		void ICmpRenderer.Draw(IDrawDevice device)
		{
			// Create a buffer to cache and re-use vertices. Not required, but will boost performance.
			if (this.buffer == null) this.buffer = new CanvasBuffer();

			// Create a Canvas to auto-generate vertices from high-level drawing commands.
			Canvas canvas = new Canvas(device, this.buffer);
			canvas.State.SetMaterial(new BatchInfo(DrawTechnique.Alpha, ColorRgba.White));
			canvas.State.TextFont = this.font;

			// Retrieve players
			if (this.playerOne == null)
				this.playerOne = Scene.Current.FindComponents<Player>().Where(p => p.Id == PlayerId.PlayerOne).FirstOrDefault();
			if (this.playerTwo == null)
				this.playerTwo = Scene.Current.FindComponents<Player>().Where(p => p.Id == PlayerId.PlayerTwo).FirstOrDefault();

			// Is someone playing using mouse / keyboard? Display a mouse cursor then
			if (Player.AlivePlayers.Any(p => p.InputMethod == InputMethod.MouseAndKeyboard))
			{
				canvas.FillCircle(DualityApp.Mouse.X, DualityApp.Mouse.Y, 2.0f);
			}

			// Is any player alive? Keep that value in mind, won't change here anyway.
			bool isAnyPlayerAlive = Player.IsAnyPlayerAlive;

			// Draw health and info of player one
			if (this.IsPlayerActive(this.playerOne))
			{
				Ship playerShip = this.playerOne.ControlObject;

				if (playerShip.Active)
				{
					// Draw a health bar when alive
					float health = playerShip.Hitpoints;

					canvas.State.ColorTint = ColorRgba.Black.WithAlpha(0.5f);
					canvas.FillRect(12 - 1, device.TargetSize.Y - 10 - 198 - 1, 16 + 2, 196 + 2);

					canvas.State.ColorTint = this.playerOne.Color;
					canvas.DrawRect(10, device.TargetSize.Y - 10 - 200, 20, 200);
					canvas.FillRect(12, device.TargetSize.Y - 10 - health * 198.0f, 16, health * 196.0f);
				}
				else if (isAnyPlayerAlive && !this.playerOne.HasReachedGoal)
				{
					// Draw a respawn timer when dead
					float respawnPercentage = this.playerOne.RespawnTime / Player.RespawnDelay;
					string respawnText = string.Format("Respawn in {0:F1}", (Player.RespawnDelay - this.playerOne.RespawnTime) / 1000.0f);
					Vector2 textSize = canvas.MeasureText(string.Format("Respawn in {0:F1}", 0.0f));

					canvas.State.ColorTint = ColorRgba.Black.WithAlpha(0.5f);
					canvas.FillRect(10 - 1, device.TargetSize.Y - 10 - textSize.Y - 2, textSize.X + 5, textSize.Y + 8);

					canvas.State.ColorTint = this.playerOne.Color;
					canvas.DrawText(respawnText, 10, device.TargetSize.Y - 10, 0.0f, Alignment.BottomLeft);
					canvas.FillRect(10, device.TargetSize.Y - 10 - textSize.Y, textSize.X * respawnPercentage, 3);
					canvas.FillRect(10, device.TargetSize.Y - 10, textSize.X * respawnPercentage, 3);
				}
			}

			// Draw health and info of player two
			if (this.IsPlayerActive(this.playerTwo))
			{
				Ship playerShip = this.playerTwo.ControlObject;

				if (playerShip.Active)
				{
					// Draw a health bar when alive
					float health = playerShip.Hitpoints;

					canvas.State.ColorTint = ColorRgba.Black.WithAlpha(0.5f);
					canvas.FillRect(device.TargetSize.X - 12 - 16 - 1, device.TargetSize.Y - 10 - 198 - 1, 16 + 2, 196 + 2);

					canvas.State.ColorTint = this.playerTwo.Color;
					canvas.DrawRect(device.TargetSize.X - 10 - 20, device.TargetSize.Y - 10 - 200, 20, 200);
					canvas.FillRect(device.TargetSize.X - 12 - 16, device.TargetSize.Y - 10 - health * 198.0f, 16, health * 196.0f);
				}
				else if (isAnyPlayerAlive && !this.playerTwo.HasReachedGoal)
				{
					// Draw a respawn timer when dead
					float respawnPercentage = this.playerTwo.RespawnTime / Player.RespawnDelay;
					string respawnText = string.Format("{0:F1} to Respawn", (Player.RespawnDelay - this.playerTwo.RespawnTime) / 1000.0f);
					Vector2 textSize = canvas.MeasureText(string.Format("{0:F1} to Respawn", 0.0f));

					canvas.State.ColorTint = ColorRgba.Black.WithAlpha(0.5f);
					canvas.FillRect(device.TargetSize.X - 10 - textSize.X - 3, device.TargetSize.Y - 10 - textSize.Y - 2, textSize.X + 2, textSize.Y + 10);

					canvas.State.ColorTint = this.playerTwo.Color;
					canvas.DrawText(respawnText, device.TargetSize.X - 10, device.TargetSize.Y - 10, 0.0f, Alignment.BottomRight);
					canvas.FillRect(device.TargetSize.X - 10 - textSize.X * respawnPercentage, device.TargetSize.Y - 10 - textSize.Y, textSize.X * respawnPercentage, 3);
					canvas.FillRect(device.TargetSize.X - 10 - textSize.X * respawnPercentage, device.TargetSize.Y - 10, textSize.X * respawnPercentage, 3);
				}
			}
		}

        protected override void OnCollectStateWorldOverlayDrawcalls(Canvas canvas)
        {
            base.OnCollectStateWorldOverlayDrawcalls(canvas);

            // Assure we know how to display the current selection
            this.ValidateSelectionStats();

            List<ObjectEditorSelObj> transformObjSel = this.allObjSel.Where(s => s.HasTransform).ToList();
            Point cursorPos = this.PointToClient(Cursor.Position);
            canvas.PushState();
            canvas.State.ZOffset = -1.0f;

            // Draw indirectly selected object overlay
            canvas.State.SetMaterial(new BatchInfo(DrawTechnique.Solid, ColorRgba.Lerp(this.FgColor, this.BgColor, 0.75f)));
            this.DrawSelectionMarkers(canvas, this.indirectObjSel);
            if (this.mouseoverObject != null && (this.mouseoverAction == ObjectEditorAction.RectSelect || this.mouseoverSelect) && !transformObjSel.Contains(this.mouseoverObject))
                this.DrawSelectionMarkers(canvas, new [] { this.mouseoverObject });

            // Draw selected object overlay
            canvas.State.SetMaterial(new BatchInfo(DrawTechnique.Solid, this.FgColor));
            this.DrawSelectionMarkers(canvas, transformObjSel);

            // Draw overall selection boundary
            if (transformObjSel.Count > 1)
            {
                float midZ = transformObjSel.Average(t => t.Pos.Z);
                float maxZDiff = transformObjSel.Max(t => MathF.Abs(t.Pos.Z - midZ));
                if (maxZDiff > 0.001f)
                {
                    canvas.State.SetMaterial(new BatchInfo(DrawTechnique.Solid, ColorRgba.Lerp(this.FgColor, this.BgColor, 0.5f)));
                    canvas.DrawSphere(
                        this.selectionCenter.X,
                        this.selectionCenter.Y,
                        this.selectionCenter.Z,
                        this.selectionRadius);
                }
                else
                {
                    canvas.State.SetMaterial(new BatchInfo(DrawTechnique.Solid, ColorRgba.Lerp(this.FgColor, this.BgColor, 0.5f)));
                    canvas.DrawCircle(
                        this.selectionCenter.X,
                        this.selectionCenter.Y,
                        this.selectionCenter.Z,
                        this.selectionRadius);
                }
            }

            // Draw scale action dots
            bool canMove = this.actionObjSel.Any(s => s.IsActionAvailable(ObjectEditorAction.Move));
            bool canScale = (canMove && this.actionObjSel.Count > 1) || this.actionObjSel.Any(s => s.IsActionAvailable(ObjectEditorAction.Scale));
            if (canScale)
            {
                float dotR = 3.0f / this.GetScaleAtZ(this.selectionCenter.Z);
                canvas.State.ZOffset -= 0.1f;
                canvas.State.SetMaterial(new BatchInfo(DrawTechnique.Solid, this.FgColor));
                canvas.FillCircle(
                    this.selectionCenter.X + this.selectionRadius,
                    this.selectionCenter.Y,
                    this.selectionCenter.Z,
                    dotR);
                canvas.FillCircle(
                    this.selectionCenter.X - this.selectionRadius,
                    this.selectionCenter.Y,
                    this.selectionCenter.Z,
                    dotR);
                canvas.FillCircle(
                    this.selectionCenter.X,
                    this.selectionCenter.Y + this.selectionRadius,
                    this.selectionCenter.Z,
                    dotR);
                canvas.FillCircle(
                    this.selectionCenter.X,
                    this.selectionCenter.Y - this.selectionRadius,
                    this.selectionCenter.Z,
                    dotR);
                canvas.State.ZOffset += 0.1f;
            }

            if (this.action != ObjectEditorAction.None)
            {
                // Draw action lock axes
                this.DrawLockedAxes(canvas, this.selectionCenter.X, this.selectionCenter.Y, this.selectionCenter.Z, this.selectionRadius * 4);
            }

            canvas.PopState();
        }