public void RenderAfterWorld(WorldRenderer wr, Actor self) { foreach (var i in impacts) { var alpha = 255.0f * i.Time / info.DisplayDuration; var rangeStep = alpha / i.Range.Length; RangeCircleRenderable.DrawRangeCircle(wr, i.CenterPosition, i.OuterRange, 1, Color.FromArgb((int)alpha, i.Color), 0, i.Color); foreach (var r in i.Range) { var tl = wr.ScreenPosition(i.CenterPosition - new WVec(r.Length, r.Length, 0)); var br = wr.ScreenPosition(i.CenterPosition + new WVec(r.Length, r.Length, 0)); var rect = RectangleF.FromLTRB(tl.X, tl.Y, br.X, br.Y); Game.Renderer.WorldRgbaColorRenderer.FillEllipse(rect, Color.FromArgb((int)alpha, i.Color)); alpha -= rangeStep; } if (!wr.World.Paused) i.Time--; } impacts.RemoveAll(i => i.Time == 0); }
public void Render(WorldRenderer wr) { // Need at least 4 points to smooth the contrail over if (length - skip < 4) return; var wlr = Game.Renderer.WorldLineRenderer; var oldWidth = wlr.LineWidth; wlr.LineWidth = wr.Viewport.Zoom; // Start of the first line segment is the tail of the list - don't smooth it. var curPos = trail[Index(next - skip - 1)]; var curColor = color; for (var i = 0; i < length - skip - 4; i++) { var j = next - skip - i - 2; var nextPos = Average(trail[Index(j)], trail[Index(j - 1)], trail[Index(j - 2)], trail[Index(j - 3)]); var nextColor = Exts.ColorLerp(i * 1f / (length - 4), color, Color.Transparent); if (!world.FogObscures(curPos) && !world.FogObscures(nextPos)) wlr.DrawLine(wr.ScreenPosition(curPos), wr.ScreenPosition(nextPos), curColor, nextColor); curPos = nextPos; curColor = nextColor; } wlr.LineWidth = oldWidth; }
public void RenderAfterWorld(WorldRenderer wr, Actor self) { if (devMode == null || !devMode.ShowMuzzles) return; if (health.Value != null) wr.DrawRangeCircle(Color.Red, wr.ScreenPxPosition(self.CenterPosition), health.Value.Info.Radius / Game.CellSize); var wlr = Game.Renderer.WorldLineRenderer; var c = Color.White; foreach (var a in armaments.Value) { foreach (var b in a.Barrels) { var muzzle = self.CenterPosition + a.MuzzleOffset(self, b); var dirOffset = new WVec(0, -224, 0).Rotate(a.MuzzleOrientation(self, b)); var sm = wr.ScreenPosition(muzzle); var sd = wr.ScreenPosition(muzzle + dirOffset); wlr.DrawLine(sm, sd, c, c); wr.DrawTargetMarker(c, sm); } } }
public void Render(WorldRenderer wr) { var wlr = Game.Renderer.WorldLineRenderer; var src = wr.ScreenPosition(pos); var dest = wr.ScreenPosition(pos + length); var oldWidth = wlr.LineWidth; wlr.LineWidth = wr.Viewport.Zoom * width; wlr.DrawLine(src, dest, color); wlr.LineWidth = oldWidth; }
public void RenderAfterWorld(WorldRenderer wr, Actor self) { if (devMode == null || !devMode.ShowCombatGeometry) return; if (health.Value != null) wr.DrawRangeCircle(self.CenterPosition, health.Value.Info.Radius, Color.Red); // No armaments to draw if (attack.Value == null) return; var wlr = Game.Renderer.WorldLineRenderer; var c = Color.White; // Fire ports on garrisonable structures var garrison = attack.Value as AttackGarrisoned; if (garrison != null) { var bodyOrientation = coords.Value.QuantizeOrientation(self, self.Orientation); foreach (var p in garrison.Ports) { var pos = self.CenterPosition + coords.Value.LocalToWorld(p.Offset.Rotate(bodyOrientation)); var da = coords.Value.LocalToWorld(new WVec(224, 0, 0).Rotate(WRot.FromYaw(p.Yaw + p.Cone)).Rotate(bodyOrientation)); var db = coords.Value.LocalToWorld(new WVec(224, 0, 0).Rotate(WRot.FromYaw(p.Yaw - p.Cone)).Rotate(bodyOrientation)); var o = wr.ScreenPosition(pos); var a = wr.ScreenPosition(pos + da * 224 / da.Length); var b = wr.ScreenPosition(pos + db * 224 / db.Length); wlr.DrawLine(o, a, c, c); wlr.DrawLine(o, b, c, c); } return; } foreach (var a in attack.Value.Armaments) { foreach (var b in a.Barrels) { var muzzle = self.CenterPosition + a.MuzzleOffset(self, b); var dirOffset = new WVec(0, -224, 0).Rotate(a.MuzzleOrientation(self, b)); var sm = wr.ScreenPosition(muzzle); var sd = wr.ScreenPosition(muzzle + dirOffset); wlr.DrawLine(sm, sd, c, c); wr.DrawTargetMarker(c, sm); } } }
public IEnumerable<IRenderable> GenerateRenderables(WorldRenderer wr) { var bright = wr.world.Map.SequenceProvider.GetSequence(image, "bright"); var dim = wr.world.Map.SequenceProvider.GetSequence(image, "dim"); var source = wr.ScreenPosition(pos); var target = wr.ScreenPosition(pos + length); for (var n = 0; n < dimZaps; n++) foreach (var z in DrawZapWandering(wr, source, target, dim, palette)) yield return z; for (var n = 0; n < brightZaps; n++) foreach (var z in DrawZapWandering(wr, source, target, bright, palette)) yield return z; }
public static void DrawRangeCircle(WorldRenderer wr, WPos centerPosition, WDist radius, float width, Color color, float contrastWidth, Color contrastColor) { var wcr = Game.Renderer.WorldRgbaColorRenderer; var offset = new WVec(radius.Length, 0, 0); for (var i = 0; i < RangeCircleSegments; i++) { var a = wr.ScreenPosition(centerPosition + offset.Rotate(RangeCircleStartRotations[i])); var b = wr.ScreenPosition(centerPosition + offset.Rotate(RangeCircleEndRotations[i])); if (contrastWidth > 0) wcr.DrawLine(a, b, contrastWidth / wr.Viewport.Zoom, contrastColor); if (width > 0) wcr.DrawLine(a, b, width / wr.Viewport.Zoom, color); } }
public void RenderAfterWorld(WorldRenderer wr, Actor self) { if (devMode == null || !devMode.ShowMuzzles) return; var wlr = Game.Renderer.WorldLineRenderer; var c = Color.White; foreach (var a in armaments.Value) foreach (var b in a.Barrels) { var muzzle = self.CenterPosition + a.MuzzleOffset(self, b); var dirOffset = new WVec(0,-224,0).Rotate(a.MuzzleOrientation(self, b)); var sm = wr.ScreenPosition(muzzle); var sd = wr.ScreenPosition(muzzle + dirOffset); wlr.DrawLine(sm, sd, c, c); wlr.DrawLine(sm + new float2(-1, -1), sm + new float2(-1, 1), c, c); wlr.DrawLine(sm + new float2(-1, 1), sm + new float2(1, 1), c, c); wlr.DrawLine(sm + new float2(1, 1), sm + new float2(1, -1), c, c); wlr.DrawLine(sm + new float2(1, -1), sm + new float2(-1, -1), c, c); } }
public TerrainRenderer(World world, WorldRenderer wr) { this.world = world; this.map = world.Map; var terrainPalette = wr.Palette("terrain").Index; var vertices = new Vertex[4 * map.Bounds.Height * map.Bounds.Width]; var nv = 0; foreach (var cell in map.Cells) { var tile = wr.Theater.TileSprite(map.MapTiles.Value[cell]); var pos = wr.ScreenPosition(map.CenterOfCell(cell)) - 0.5f * tile.size; Util.FastCreateQuad(vertices, pos, tile, terrainPalette, nv, tile.size); nv += 4; } vertexBuffer = Game.Renderer.Device.CreateVertexBuffer(vertices.Length); vertexBuffer.SetData(vertices, nv); }
public TerrainRenderer(World world, WorldRenderer wr) { this.world = world; this.map = world.Map; var terrainPalette = wr.Palette("terrain").Index; var vertices = new Vertex[4 * map.Bounds.Height * map.Bounds.Width]; int nv = 0; for (var j = map.Bounds.Top; j < map.Bounds.Bottom; j++) { for (var i = map.Bounds.Left; i < map.Bounds.Right; i++) { var tile = wr.Theater.TileSprite(map.MapTiles.Value[i, j]); var pos = wr.ScreenPosition(new CPos(i, j).CenterPosition) - 0.5f * tile.size; Util.FastCreateQuad(vertices, pos, tile, terrainPalette, nv, tile.size); nv += 4; } } vertexBuffer = Game.Renderer.Device.CreateVertexBuffer(vertices.Length); vertexBuffer.SetData(vertices, nv); }
public void RenderDebugGeometry(WorldRenderer wr) { var pxOrigin = wr.ScreenPosition(pos); var groundZ = 0.5f * (pxOrigin.Y - wr.ScreenZPosition(pos, 0)); var shadowOrigin = pxOrigin - groundZ * (new float2(renderProxy.ShadowDirection, 1)); // Draw sprite rect var offset = pxOrigin + renderProxy.Sprite.offset - 0.5f * renderProxy.Sprite.size; Game.Renderer.WorldLineRenderer.DrawRect(offset, offset + renderProxy.Sprite.size, Color.Red); // Draw transformed shadow sprite rect var c = Color.Purple; var psb = renderProxy.ProjectedShadowBounds; Game.Renderer.WorldLineRenderer.DrawLine(shadowOrigin + psb[1], shadowOrigin + psb[3], c, c); Game.Renderer.WorldLineRenderer.DrawLine(shadowOrigin + psb[3], shadowOrigin + psb[0], c, c); Game.Renderer.WorldLineRenderer.DrawLine(shadowOrigin + psb[0], shadowOrigin + psb[2], c, c); Game.Renderer.WorldLineRenderer.DrawLine(shadowOrigin + psb[2], shadowOrigin + psb[1], c, c); // Draw voxel bounding box var draw = voxels.Where(v => v.DisableFunc == null || !v.DisableFunc()); var scaleTransform = Util.ScaleMatrix(scale, scale, scale); var cameraTransform = Util.MakeFloatMatrix(camera.AsMatrix()); foreach (var v in draw) { var bounds = v.Voxel.Bounds(v.FrameFunc()); var worldTransform = v.RotationFunc().Reverse().Aggregate(scaleTransform, (x, y) => Util.MatrixMultiply(x, Util.MakeFloatMatrix(y.AsMatrix()))); var pxOffset = wr.ScreenVector(v.OffsetFunc()); var pxPos = pxOrigin + new float2(pxOffset[0], pxOffset[1]); var screenTransform = Util.MatrixMultiply(cameraTransform, worldTransform); DrawBoundsBox(pxPos, screenTransform, bounds, Color.Yellow); } }
public void WorldLoaded(World w, WorldRenderer wr) { // Cache the tile positions to avoid unnecessary calculations for (var i = bounds.Left; i < bounds.Right; i++) { for (var j = bounds.Top; j < bounds.Bottom; j++) { var k = j * tileStride + i; tiles[k].Position = new CPos(i, j); tiles[k].ScreenPosition = wr.ScreenPosition(tiles[k].Position.CenterPosition); } } fogPalette = wr.Palette("fog"); shroudPalette = wr.Palette("shroud"); }
public void RenderAfterWorld(WorldRenderer wr, Actor self) { if (devMode == null || !devMode.ShowCombatGeometry) return; var wcr = Game.Renderer.WorldRgbaColorRenderer; var iz = 1 / wr.Viewport.Zoom; if (healthInfo != null) healthInfo.Shape.DrawCombatOverlay(wr, wcr, self); var blockers = allBlockers.Where(Exts.IsTraitEnabled).ToList(); if (blockers.Count > 0) { var hc = Color.Orange; var height = new WVec(0, 0, blockers.Max(b => b.BlockingHeight.Length)); var ha = wr.ScreenPosition(self.CenterPosition); var hb = wr.ScreenPosition(self.CenterPosition + height); wcr.DrawLine(ha, hb, iz, hc); TargetLineRenderable.DrawTargetMarker(wr, hc, ha); TargetLineRenderable.DrawTargetMarker(wr, hc, hb); } foreach (var attack in self.TraitsImplementing<AttackBase>().Where(x => !x.IsTraitDisabled)) DrawArmaments(self, attack, wr, wcr, iz); }
public void WorldLoaded(World w, WorldRenderer wr) { // Initialize tile cache // This includes the region outside the visible area to cover any sprites peeking outside the map foreach (var uv in w.Map.AllCells.MapCoords) { var pos = w.Map.CenterOfCell(uv.ToCPos(map)); var screen = wr.ScreenPosition(pos - new WVec(0, 0, pos.Z)); var variant = (byte)Game.CosmeticRandom.Next(info.ShroudVariants.Length); tileInfos[uv] = new TileInfo(screen, variant); } // Dirty the whole projected space DirtyCells(map.AllCells.MapCoords.Select(uv => (PPos)uv)); // All tiles are visible in the editor if (w.Type == WorldType.Editor) visibleUnderShroud = _ => true; else visibleUnderShroud = puv => map.Contains(puv); visibleUnderFog = puv => map.Contains(puv); var shroudSheet = shroudSprites[0].Sheet; if (shroudSprites.Any(s => s.Sheet != shroudSheet)) throw new InvalidDataException("Shroud sprites span multiple sheets. Try loading their sequences earlier."); var shroudBlend = shroudSprites[0].BlendMode; if (shroudSprites.Any(s => s.BlendMode != shroudBlend)) throw new InvalidDataException("Shroud sprites must all use the same blend mode."); var fogSheet = fogSprites[0].Sheet; if (fogSprites.Any(s => s.Sheet != fogSheet)) throw new InvalidDataException("Fog sprites span multiple sheets. Try loading their sequences earlier."); var fogBlend = fogSprites[0].BlendMode; if (fogSprites.Any(s => s.BlendMode != fogBlend)) throw new InvalidDataException("Fog sprites must all use the same blend mode."); shroudLayer = new TerrainSpriteLayer(w, wr, shroudSheet, shroudBlend, wr.Palette(info.ShroudPalette), false); fogLayer = new TerrainSpriteLayer(w, wr, fogSheet, fogBlend, wr.Palette(info.FogPalette), false); }
public void Render(WorldRenderer wr) { var pxOrigin = wr.ScreenPosition(pos); var groundZ = 0.5f*(pxOrigin.Y - wr.ScreenZPosition(pos, 0)); var shadowOrigin = pxOrigin - groundZ*(new float2(renderProxy.ShadowDirection, 1)); var psb = renderProxy.ProjectedShadowBounds; var sa = shadowOrigin + psb[0]; var sb = shadowOrigin + psb[2]; var sc = shadowOrigin + psb[1]; var sd = shadowOrigin + psb[3]; Game.Renderer.WorldRgbaSpriteRenderer.DrawSprite(renderProxy.ShadowSprite, sa, sb, sc, sd); Game.Renderer.WorldRgbaSpriteRenderer.DrawSprite(renderProxy.Sprite, pxOrigin - 0.5f*renderProxy.Sprite.size); }
void DrawArmaments(Actor self, AttackBase attack, WorldRenderer wr, RgbaColorRenderer wcr, float iz) { var c = Color.White; // Fire ports on garrisonable structures var garrison = attack as AttackGarrisoned; if (garrison != null) { var bodyOrientation = coords.Value.QuantizeOrientation(self, self.Orientation); foreach (var p in garrison.Info.Ports) { var pos = self.CenterPosition + coords.Value.LocalToWorld(p.Offset.Rotate(bodyOrientation)); var da = coords.Value.LocalToWorld(new WVec(224, 0, 0).Rotate(WRot.FromYaw(p.Yaw + p.Cone)).Rotate(bodyOrientation)); var db = coords.Value.LocalToWorld(new WVec(224, 0, 0).Rotate(WRot.FromYaw(p.Yaw - p.Cone)).Rotate(bodyOrientation)); var o = wr.ScreenPosition(pos); var a = wr.ScreenPosition(pos + da * 224 / da.Length); var b = wr.ScreenPosition(pos + db * 224 / db.Length); wcr.DrawLine(o, a, iz, c); wcr.DrawLine(o, b, iz, c); } return; } foreach (var a in attack.Armaments) { foreach (var b in a.Barrels) { var muzzle = self.CenterPosition + a.MuzzleOffset(self, b); var dirOffset = new WVec(0, -224, 0).Rotate(a.MuzzleOrientation(self, b)); var sm = wr.ScreenPosition(muzzle); var sd = wr.ScreenPosition(muzzle + dirOffset); wcr.DrawLine(sm, sd, iz, c); TargetLineRenderable.DrawTargetMarker(wr, c, sm); } } }
public void Render(WorldRenderer wr) { var screenPos = wr.Viewport.Zoom*(wr.ScreenPosition(pos) - wr.Viewport.TopLeft.ToFloat2()) - 0.5f*font.Measure(text).ToFloat2(); var screenPxPos = new float2((float)Math.Round(screenPos.X), (float)Math.Round(screenPos.Y)); font.DrawTextWithContrast(text, screenPxPos, color, Color.Black, 1); }
public void DrawCombatOverlay(WorldRenderer wr, RgbaColorRenderer wcr, Actor actor) { var a = actor.CenterPosition + new WVec(PointA.X, PointA.Y, 0).Rotate(actor.Orientation); var b = actor.CenterPosition + new WVec(PointB.X, PointB.Y, 0).Rotate(actor.Orientation); var offset = new WVec(a.Y - b.Y, b.X - a.X, 0); offset = offset * Radius.Length / offset.Length; var c = Color.Yellow; RangeCircleRenderable.DrawRangeCircle(wr, a, Radius, 1, c, 0, c); RangeCircleRenderable.DrawRangeCircle(wr, b, Radius, 1, c, 0, c); wcr.DrawLine(new[] { wr.ScreenPosition(a - offset), wr.ScreenPosition(b - offset) }, 1, c); wcr.DrawLine(new[] { wr.ScreenPosition(a + offset), wr.ScreenPosition(b + offset) }, 1, c); }
public void WorldLoaded(World w, WorldRenderer wr) { // Initialize tile cache // Adds a 1-cell border around the border to cover any sprites peeking outside the map foreach (var cell in CellRegion.Expand(w.Map.Cells, 1)) { var screen = wr.ScreenPosition(w.Map.CenterOfCell(cell)); var variant = Game.CosmeticRandom.Next(info.ShroudVariants.Length); tiles[cell] = new ShroudTile(cell, screen, variant); // Set the cells outside the border so they don't need to be touched again if (!map.Contains(cell)) { var index = info.UseExtendedIndex ? 240 : 15; tiles[cell].Shroud = shroudSprites[variant * variantStride + spriteMap[index]]; } } fogPalette = wr.Palette(info.FogPalette); shroudPalette = wr.Palette(info.ShroudPalette); }
public void RenderDebugGeometry(WorldRenderer wr) { var groundPos = voxel.pos - new WVec(0, 0, wr.World.Map.DistanceAboveTerrain(voxel.pos).Length); var groundZ = wr.World.Map.Grid.TileSize.Height * (groundPos.Z - voxel.pos.Z) / 1024f; var pxOrigin = wr.ScreenPosition(voxel.pos); var shadowOrigin = pxOrigin - groundZ * (new float2(renderProxy.ShadowDirection, 1)); var iz = 1 / wr.Viewport.Zoom; // Draw sprite rect var offset = pxOrigin + renderProxy.Sprite.Offset - 0.5f * renderProxy.Sprite.Size; Game.Renderer.WorldRgbaColorRenderer.DrawRect(offset, offset + renderProxy.Sprite.Size, iz, Color.Red); // Draw transformed shadow sprite rect var c = Color.Purple; var psb = renderProxy.ProjectedShadowBounds; Game.Renderer.WorldRgbaColorRenderer.DrawPolygon(new[] { shadowOrigin + psb[1], shadowOrigin + psb[3], shadowOrigin + psb[0], shadowOrigin + psb[2] }, iz, c); // Draw voxel bounding box var draw = voxel.voxels.Where(v => v.DisableFunc == null || !v.DisableFunc()); var scaleTransform = OpenRA.Graphics.Util.ScaleMatrix(voxel.scale, voxel.scale, voxel.scale); var cameraTransform = OpenRA.Graphics.Util.MakeFloatMatrix(voxel.camera.AsMatrix()); foreach (var v in draw) { var bounds = v.Voxel.Bounds(v.FrameFunc()); var worldTransform = v.RotationFunc().Reverse().Aggregate(scaleTransform, (x, y) => OpenRA.Graphics.Util.MatrixMultiply(x, OpenRA.Graphics.Util.MakeFloatMatrix(y.AsMatrix()))); float sx, sy, sz; wr.ScreenVectorComponents(v.OffsetFunc(), out sx, out sy, out sz); var pxPos = pxOrigin + new float2(sx, sy); var screenTransform = OpenRA.Graphics.Util.MatrixMultiply(cameraTransform, worldTransform); DrawBoundsBox(pxPos, screenTransform, bounds, iz, Color.Yellow); } }
public Rectangle ScreenBounds(WorldRenderer wr) { var pxOrigin = wr.ScreenPosition(voxel.pos); var draw = voxel.voxels.Where(v => v.DisableFunc == null || !v.DisableFunc()); var scaleTransform = Util.ScaleMatrix(voxel.scale, voxel.scale, voxel.scale); var cameraTransform = Util.MakeFloatMatrix(voxel.camera.AsMatrix()); var minX = float.MaxValue; var minY = float.MaxValue; var maxX = float.MinValue; var maxY = float.MinValue; foreach (var v in draw) { var bounds = v.Voxel.Bounds(v.FrameFunc()); var worldTransform = v.RotationFunc().Reverse().Aggregate(scaleTransform, (x, y) => Util.MatrixMultiply(x, Util.MakeFloatMatrix(y.AsMatrix()))); float sx, sy, sz; wr.ScreenVectorComponents(v.OffsetFunc(), out sx, out sy, out sz); var pxPos = pxOrigin + new float2(sx, sy); var screenTransform = Util.MatrixMultiply(cameraTransform, worldTransform); for (var i = 0; i < 8; i++) { var vec = new float[] { bounds[CornerXIndex[i]], bounds[CornerYIndex[i]], bounds[CornerZIndex[i]], 1 }; var screen = Util.MatrixVectorMultiply(screenTransform, vec); minX = Math.Min(minX, pxPos.X + screen[0]); minY = Math.Min(minY, pxPos.Y + screen[1]); maxX = Math.Max(maxX, pxPos.X + screen[0]); maxY = Math.Max(maxY, pxPos.Y + screen[1]); } } return Rectangle.FromLTRB((int)minX, (int)minY, (int)maxX, (int)maxY); }
public void Render(WorldRenderer wr) { var groundPos = voxel.pos - new WVec(0, 0, wr.World.Map.DistanceAboveTerrain(voxel.pos).Length); var groundZ = wr.World.Map.Grid.TileSize.Height * (groundPos.Z - voxel.pos.Z) / 1024f; var pxOrigin = wr.ScreenPosition(voxel.pos); var shadowOrigin = pxOrigin - groundZ * (new float2(renderProxy.ShadowDirection, 1)); var psb = renderProxy.ProjectedShadowBounds; var sa = shadowOrigin + psb[0]; var sb = shadowOrigin + psb[2]; var sc = shadowOrigin + psb[1]; var sd = shadowOrigin + psb[3]; Game.Renderer.WorldRgbaSpriteRenderer.DrawSprite(renderProxy.ShadowSprite, sa, sb, sc, sd); Game.Renderer.WorldRgbaSpriteRenderer.DrawSprite(renderProxy.Sprite, pxOrigin - 0.5f * renderProxy.Sprite.Size); }
public void Render(WorldRenderer wr) { // Need at least 4 points to smooth the contrail over if (length - skip < 4) return; var screenWidth = wr.ScreenVector(new WVec(width, WDist.Zero, WDist.Zero))[0]; var wcr = Game.Renderer.WorldRgbaColorRenderer; // Start of the first line segment is the tail of the list - don't smooth it. var curPos = trail[Index(next - skip - 1)]; var curColor = color; for (var i = 0; i < length - skip - 4; i++) { var j = next - skip - i - 2; var nextPos = Average(trail[Index(j)], trail[Index(j - 1)], trail[Index(j - 2)], trail[Index(j - 3)]); var nextColor = Exts.ColorLerp(i * 1f / (length - 4), color, Color.Transparent); if (!world.FogObscures(curPos) && !world.FogObscures(nextPos)) wcr.DrawLine(wr.ScreenPosition(curPos), wr.ScreenPosition(nextPos), screenWidth, curColor, nextColor); curPos = nextPos; curColor = nextColor; } }
public void DrawCombatOverlay(WorldRenderer wr, RgbaColorRenderer wcr, Actor actor) { var verts = combatOverlayVerts.Select(v => wr.ScreenPosition(actor.CenterPosition + v.Rotate(actor.Orientation))); wcr.DrawPolygon(verts.ToArray(), 1, Color.Yellow); }
public void WorldLoaded(World w, WorldRenderer wr) { // Initialize tile cache // Adds a 1-cell border around the border to cover any sprites peeking outside the map foreach (var uv in CellRegion.Expand(w.Map.Cells, 1).MapCoords) { var screen = wr.ScreenPosition(w.Map.CenterOfCell(uv.ToCPos(map))); var variant = (byte)Game.CosmeticRandom.Next(info.ShroudVariants.Length); tileInfos[uv] = new TileInfo(screen, variant); } fogPalette = wr.Palette(info.FogPalette); shroudPalette = wr.Palette(info.ShroudPalette); wr.PaletteInvalidated += () => { mapBorderShroudIsCached = false; MarkCellsDirty(CellRegion.Expand(map.Cells, 1)); }; }
public void Render(WorldRenderer wr) { var vecLength = length.Length; if (vecLength == 0) return; if (shape == BeamRenderableShape.Flat) { var delta = length * width.Length / (2 * vecLength); var corner = new WVec(-delta.Y, delta.X, delta.Z); var a = wr.ScreenPosition(pos - corner); var b = wr.ScreenPosition(pos + corner); var c = wr.ScreenPosition(pos + corner + length); var d = wr.ScreenPosition(pos - corner + length); Game.Renderer.WorldRgbaColorRenderer.FillRect(a, b, c, d, color); } else { var start = wr.ScreenPosition(pos); var end = wr.ScreenPosition(pos + length); var screenWidth = wr.ScreenVector(new WVec(width, WDist.Zero, WDist.Zero))[0]; Game.Renderer.WorldRgbaColorRenderer.DrawLine(start, end, screenWidth, color); } }
public void Render(WorldRenderer wr) { var wcr = Game.Renderer.WorldRgbaColorRenderer; var center = wr.ScreenPosition(centerPosition); for (var i = 0; i < trailCount; i++) { var angle = trailAngle - new WAngle(i * (trailSeparation.Angle <= 512 ? 1 : -1)); var length = radius.Length * new WVec(angle.Cos(), angle.Sin(), 0) / 1024; var end = wr.ScreenPosition(centerPosition + length); var alpha = color.A - i * color.A / trailCount; wcr.DrawLine(center, end, 3, Color.FromArgb(alpha, contrastColor)); wcr.DrawLine(center, end, 1, Color.FromArgb(alpha, color)); } RangeCircleRenderable.DrawRangeCircle(wr, centerPosition, radius, 1, color, 3, contrastColor); }
public void RenderDebugGeometry(WorldRenderer wr) { var pxOrigin = wr.ScreenPosition(voxel.pos); var groundZ = 0.5f * (pxOrigin.Y - wr.ScreenZPosition(voxel.pos, 0)); var shadowOrigin = pxOrigin - groundZ * (new float2(renderProxy.ShadowDirection, 1)); // Draw sprite rect var offset = pxOrigin + renderProxy.Sprite.Offset - 0.5f * renderProxy.Sprite.Size; Game.Renderer.WorldLineRenderer.DrawRect(offset, offset + renderProxy.Sprite.Size, Color.Red); // Draw transformed shadow sprite rect var c = Color.Purple; var psb = renderProxy.ProjectedShadowBounds; Game.Renderer.WorldLineRenderer.DrawLine(shadowOrigin + psb[1], shadowOrigin + psb[3], c); Game.Renderer.WorldLineRenderer.DrawLine(shadowOrigin + psb[3], shadowOrigin + psb[0], c); Game.Renderer.WorldLineRenderer.DrawLine(shadowOrigin + psb[0], shadowOrigin + psb[2], c); Game.Renderer.WorldLineRenderer.DrawLine(shadowOrigin + psb[2], shadowOrigin + psb[1], c); // Draw voxel bounding box var draw = voxel.voxels.Where(v => v.DisableFunc == null || !v.DisableFunc()); var scaleTransform = Util.ScaleMatrix(voxel.scale, voxel.scale, voxel.scale); var cameraTransform = Util.MakeFloatMatrix(voxel.camera.AsMatrix()); foreach (var v in draw) { var bounds = v.Voxel.Bounds(v.FrameFunc()); var worldTransform = v.RotationFunc().Reverse().Aggregate(scaleTransform, (x, y) => Util.MatrixMultiply(x, Util.MakeFloatMatrix(y.AsMatrix()))); float sx, sy, sz; wr.ScreenVectorComponents(v.OffsetFunc(), out sx, out sy, out sz); var pxPos = pxOrigin + new float2(sx, sy); var screenTransform = Util.MatrixMultiply(cameraTransform, worldTransform); DrawBoundsBox(pxPos, screenTransform, bounds, Color.Yellow); } }
public void Render(WorldRenderer wr) { // TODO: This is a temporary workaround until we have a proper ramp-aware height calculation var groundPos = wr.World.Map.CenterOfCell(wr.World.Map.CellContaining(voxel.pos)); var ts = Game.ModData.Manifest.TileSize; var groundZ = ts.Height * (groundPos.Z - voxel.pos.Z) / 1024f; var pxOrigin = wr.ScreenPosition(voxel.pos); var shadowOrigin = pxOrigin - groundZ * (new float2(renderProxy.ShadowDirection, 1)); var psb = renderProxy.ProjectedShadowBounds; var sa = shadowOrigin + psb[0]; var sb = shadowOrigin + psb[2]; var sc = shadowOrigin + psb[1]; var sd = shadowOrigin + psb[3]; Game.Renderer.WorldRgbaSpriteRenderer.DrawSprite(renderProxy.ShadowSprite, sa, sb, sc, sd); Game.Renderer.WorldRgbaSpriteRenderer.DrawSprite(renderProxy.Sprite, pxOrigin - 0.5f * renderProxy.Sprite.Size); }
public void Render(WorldRenderer wr) { var wlr = Game.Renderer.WorldLineRenderer; var src = wr.ScreenPosition(pos); var dest = wr.ScreenPosition(pos + length); var lineWidth = wlr.LineWidth; if (lineWidth != width) { wlr.Flush(); wlr.LineWidth = width; } wlr.DrawLine(src, dest, color, color); if (lineWidth != width) { wlr.Flush(); wlr.LineWidth = lineWidth; } }
public void WorldLoaded(World w, WorldRenderer wr) { // Initialize tile cache // Adds a 1-cell border around the border to cover any sprites peeking outside the map foreach (var cell in CellRegion.Expand(w.Map.Cells, 1)) { var screen = wr.ScreenPosition(w.Map.CenterOfCell(cell)); var variant = (byte)Game.CosmeticRandom.Next(info.ShroudVariants.Length); tiles[cell] = new ShroudTile(screen, variant); // Set the cells outside the border so they don't need to be touched again if (!map.Contains(cell)) { var shroudTile = tiles[cell]; shroudTile.Shroud = GetTile(shroudSprites, notVisibleEdges, variant); tiles[cell] = shroudTile; } } fogPalette = wr.Palette(info.FogPalette); shroudPalette = wr.Palette(info.ShroudPalette); }