本文整理汇总了C#中Canvas.FillCircle方法的典型用法代码示例。如果您正苦于以下问题:C# Canvas.FillCircle方法的具体用法?C# Canvas.FillCircle怎么用?C# Canvas.FillCircle使用的例子?那么恭喜您, 这里精选的方法代码示例或许可以为您提供帮助。您也可以进一步了解该方法所在类Canvas
的用法示例。
在下文中一共展示了Canvas.FillCircle方法的15个代码示例,这些例子默认根据受欢迎程度排序。您可以为喜欢或者感觉有用的代码点赞,您的评价将有助于系统推荐出更棒的C#代码示例。
示例1: Canvas
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);
}
}
示例2: Canvas
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);
}
}
示例3: Draw
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);
}
示例4: DrawTestImageRow
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();
}
示例5: DrawWorldAnchor
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);
}
示例6: DrawLocalFrictionMarker
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);
}
示例7: OnCollectStateOverlayDrawcalls
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();
}
示例8: Draw
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);
}
示例9: DrawTileHighlights
//.........这里部分代码省略.........
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();
}
示例10: Canvas
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);
}
示例11: Draw
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);
}
示例12: OnCollectWorldOverlayDrawcalls
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
//.........这里部分代码省略.........
示例13: OnCollectStateOverlayDrawcalls
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);
}
}
示例14: Canvas
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);
}
}
}
示例15: OnCollectStateWorldOverlayDrawcalls
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();
}