internal void Draw(WorldRenderer wr)
{
if (initializePalettes)
{
fogPalette = wr.Palette("fog");
shroudPalette = wr.Palette("shroud");
initializePalettes = false;
}
if (shroud != null && shroud.dirty)
{
shroud.dirty = false;
for (int i = map.Bounds.Left; i < map.Bounds.Right; i++)
for (int j = map.Bounds.Top; j < map.Bounds.Bottom; j++)
sprites[i, j] = ChooseShroud(i, j);
for (int i = map.Bounds.Left; i < map.Bounds.Right; i++)
for (int j = map.Bounds.Top; j < map.Bounds.Bottom; j++)
fogSprites[i, j] = ChooseFog(i, j);
}
var clipRect = Game.viewport.WorldBounds(wr.world);
DrawShroud(wr, clipRect, sprites, shroudPalette);
if (wr.world.WorldActor.HasTrait<Fog>())
DrawShroud(wr, clipRect, fogSprites, fogPalette);
}
public IEnumerable<IRenderable> Render(WorldRenderer wr)
{
if (building.Disposed || rb.Repairers.Count == 0 || wr.World.FogObscures(building))
return SpriteRenderable.None;
PaletteReference palette;
if (!string.IsNullOrEmpty(rb.Info.IndicatorPalette))
palette = wr.Palette(rb.Info.IndicatorPalette);
else
palette = wr.Palette(rb.Info.IndicatorPalettePrefix + rb.Repairers[shownPlayer % rb.Repairers.Count].InternalName);
return anim.Render(building.CenterPosition, palette);
}
public IEnumerable<IRenderable> Render(WorldRenderer wr)
{
if (a.Destroyed || wr.world.FogObscures(a))
return SpriteRenderable.None;
return anim.Render(a.CenterPosition, wr.Palette("chrome"));
}
public IEnumerable<IRenderable> Render(WorldRenderer wr)
{
if (a.Destroyed || wr.World.FogObscures(a))
return SpriteRenderable.None;
return anim.Render(a.CenterPosition, wr.Palette(canPowerDown.Info.IndicatorPalette));
}
public IEnumerable<IRenderable> Render(WorldRenderer wr)
{
if (!args.SourceActor.World.FogObscures(pos))
{
if (info.Shadow)
{
var shadowPos = pos - new WVec(0, 0, pos.Z);
foreach (var r in anim.Render(shadowPos, wr.Palette("shadow")))
yield return r;
}
var palette = wr.Palette(info.Palette);
foreach (var r in anim.Render(pos, palette))
yield return r;
}
}
public TerrainRenderer(World world, WorldRenderer wr)
{
this.world = world;
this.map = world.Map;
var tileSize = new Size( Game.CellSize, Game.CellSize );
var tileMapping = new Cache<TileReference<ushort,byte>, Sprite>(
x => Game.modData.SheetBuilder.Add(world.TileSet.GetBytes(x), tileSize));
var vertices = new Vertex[4 * map.Bounds.Height * map.Bounds.Width];
terrainSheet = tileMapping[map.MapTiles.Value[map.Bounds.Left, map.Bounds.Top]].sheet;
int nv = 0;
var terrainPalette = wr.Palette("terrain").Index;
for( int j = map.Bounds.Top; j < map.Bounds.Bottom; j++ )
for( int i = map.Bounds.Left; i < map.Bounds.Right; i++ )
{
var tile = tileMapping[map.MapTiles.Value[i, j]];
// TODO: move GetPaletteIndex out of the inner loop.
Util.FastCreateQuad(vertices, Game.CellSize * new float2(i, j), tile, terrainPalette, nv, tile.size);
nv += 4;
if (tileMapping[map.MapTiles.Value[i, j]].sheet != terrainSheet)
throw new InvalidOperationException("Terrain sprites span multiple sheets");
}
vertexBuffer = Game.Renderer.Device.CreateVertexBuffer( vertices.Length );
vertexBuffer.SetData( vertices, nv );
}
public IEnumerable<IRenderable> Render(WorldRenderer wr)
{
if (!a.IsInWorld || a.World.FogObscures(a.Location))
return SpriteRenderable.None;
return anim.Render(a.CenterPosition, wr.Palette(palette));
}
public IEnumerable<IRenderable> Render(WorldRenderer wr)
{
if (world.FogObscures(pos))
return SpriteRenderable.None;
return anim.Render(pos, wr.Palette(palette));
}
public void InitPalette( WorldRenderer wr )
{
var paletteName = "{0}{1}".F( info.BaseName, owner.InternalName );
var newpal = new Palette(wr.Palette(info.BasePalette).Palette,
new PlayerColorRemap(info.RemapIndex, owner.ColorRamp));
wr.AddPalette(paletteName, newpal, info.AllowModifiers);
}
public void WorldLoaded(World w, WorldRenderer wr)
{
if (w.Type != WorldType.Editor)
return;
palette = wr.Palette(info.Palette);
}
public IEnumerable<IRenderable> Render(WorldRenderer wr)
{
var rc = cargo.Render(wr);
// Don't render anything if the cargo is invisible (e.g. under fog)
if (!rc.Any())
yield break;
var parachuteShadowPalette = wr.Palette(parachutableInfo.ParachuteShadowPalette);
foreach (var c in rc)
{
if (!c.IsDecoration && shadow == null)
yield return c.WithPalette(parachuteShadowPalette).WithZOffset(c.ZOffset - 1).AsDecoration();
yield return c.OffsetBy(pos - c.Pos);
}
var shadowPalette = !string.IsNullOrEmpty(parachutableInfo.ShadowPalette) ? wr.Palette(parachutableInfo.ShadowPalette) : rc.First().Palette;
if (shadow != null)
foreach (var r in shadow.Render(pos - new WVec(0, 0, pos.Z), WVec.Zero, 1, shadowPalette, 1f))
yield return r;
var parachutePalette = !string.IsNullOrEmpty(parachutableInfo.ParachutePalette) ? wr.Palette(parachutableInfo.ParachutePalette) : rc.First().Palette;
if (parachute != null)
foreach (var r in parachute.Render(pos, parachuteOffset, 1, parachutePalette, 1f))
yield return r;
}
public IEnumerable<Renderable> Render(WorldRenderer wr)
{
if (a.IsInWorld)
yield return new Renderable(anim.Image,
a.CenterLocation.ToFloat2() - .5f * anim.Image.size + offset,
wr.Palette("effect"), (int)a.CenterLocation.Y);
}
public IEnumerable<IRenderable> Render(WorldRenderer wr)
{
if (!show || self.Destroyed)
return SpriteRenderable.None;
var palette = wr.Palette(info.IndicatorPalettePrefix + self.Owner.InternalName);
return anim.Render(self.CenterPosition, palette);
}
public IEnumerable<IRenderable> Render(WorldRenderer wr)
{
if (building.Destroyed || wr.world.FogObscures(building) || rb.Repairers.Count == 0)
return SpriteRenderable.None;
var palette = wr.Palette(palettePrefix + rb.Repairers[shownPlayer % rb.Repairers.Count].InternalName);
return anim.Render(building.CenterPosition, palette);
}
public IEnumerable<IRenderable> Render(WorldRenderer wr)
{
if (world.FogObscures(pos) && !visibleThroughFog)
return SpriteRenderable.None;
var zoom = scaleSizeWithZoom ? 1f / wr.Viewport.Zoom : 1f;
return anim.Render(pos, WVec.Zero, 0, wr.Palette(palette), zoom);
}
public IEnumerable<IRenderable> Render(WorldRenderer wr)
{
if (self.World.RenderPlayer == null || !dotStates[self.World.RenderPlayer].ShouldRender || self.Disposed)
return SpriteRenderable.None;
var palette = wr.Palette(info.IndicatorPalettePrefix + self.Owner.InternalName);
return anim.Render(self.CenterPosition, palette);
}
public IEnumerable<IRenderable> Render(WorldRenderer wr)
{
if (building.Destroyed || wr.world.FogObscures(building))
return SpriteRenderable.None;
return anim.Render(building.CenterPosition,
wr.Palette(palettePrefix+player.InternalName));
}
public IEnumerable<IRenderable> Render(WorldRenderer wr)
{
var world = args.SourceActor.World;
if (!world.FogObscures(pos))
{
if (info.Shadow)
{
var dat = world.Map.DistanceAboveTerrain(pos);
var shadowPos = pos - new WVec(0, 0, dat.Length);
foreach (var r in anim.Render(shadowPos, wr.Palette("shadow")))
yield return r;
}
var palette = wr.Palette(info.Palette);
foreach (var r in anim.Render(pos, palette))
yield return r;
}
}
public IEnumerable<Renderable> Render(WorldRenderer wr)
{
if (!target.IsInWorld)
yield break;
if (remainingTicks % 2 == 0)
foreach (var r in target.Render(wr))
yield return r.WithPalette(wr.Palette("highlight"));
}
public IEnumerable<IRenderable> Render(WorldRenderer wr)
{
if (a.Destroyed) // Tick will clean up
yield break;
foreach (var r in a.Render(wr))
if (!r.IsDecoration)
yield return r.WithPalette(wr.Palette("invuln"));
}
public IEnumerable<Renderable> Render(WorldRenderer wr)
{
if (!building.Destroyed)
{
yield return new Renderable(anim.Image,
building.CenterLocation.ToFloat2() - .5f * anim.Image.size,
wr.Palette(palettePrefix+player.InternalName), (int)building.CenterLocation.Y);
}
}
public void RenderAfterWorld(WorldRenderer wr)
{
if (self.Owner != self.World.LocalPlayer || minefield == null)
return;
var pal = wr.Palette("terrain");
foreach (var c in minefield)
new SpriteRenderable(tile, c.CenterPosition,
WVec.Zero, -511, pal, 1f, true).Render(wr);
}
public IEnumerable<Renderable> Render(WorldRenderer wr)
{
if (!show || self.Destroyed)
yield break;
var p = self.CenterLocation;
var palette = wr.Palette(info.IndicatorPalettePrefix+self.Owner.InternalName);
yield return new Renderable(anim.Image, p.ToFloat2() - 0.5f * anim.Image.size, palette, p.Y)
.WithScale(1.5f);
}
void DrawControlGroup(WorldRenderer wr, Actor self, float2 basePosition)
{
var group = self.World.Selection.GetControlGroupForActor(self);
if (group == null) return;
var pipImages = new Animation("pips");
pipImages.PlayFetchIndex("groups", () => (int)group);
pipImages.Tick();
pipImages.Image.DrawAt(basePosition + new float2(-8, 1), wr.Palette("chrome"));
}
public IEnumerable<IRenderable> RenderAfterWorld(WorldRenderer wr)
{
if (self.Owner != self.World.LocalPlayer || Minefield == null)
yield break;
var pal = wr.Palette("terrain");
foreach (var c in Minefield)
yield return new SpriteRenderable(tile, self.World.Map.CenterOfCell(c),
WVec.Zero, -511, pal, 1f, true);
}
public IEnumerable<Renderable> ModifyRender(Actor self, WorldRenderer wr, IEnumerable<Renderable> r)
{
var disabled = self.IsDisabled();
foreach (var a in r)
{
var ret = a.WithPos(a.Pos - Info.Origin);
yield return ret;
if (disabled)
yield return ret.WithPalette(wr.Palette("disabled")).WithZOffset(1);
}
}
internal void Draw(WorldRenderer wr, Shroud shroud)
{
if (initializePalettes)
{
if (shroudInfo.Fog)
fogPalette = wr.Palette("fog");
shroudPalette = wr.Palette("shroud");
initializePalettes = false;
}
GenerateSprites(shroud);
var clipRect = Game.viewport.WorldBounds(wr.world);
// We draw the shroud when disabled to hide the sharp map edges
DrawShroud(wr, clipRect, sprites, shroudPalette);
if (shroudInfo.Fog)
DrawShroud(wr, clipRect, fogSprites, fogPalette);
}
IEnumerable<IRenderable> IEffectAboveShroud.RenderAboveShroud(WorldRenderer r)
{
if (beacon == null)
return SpriteRenderable.None;
if (!owner.IsAlliedWith(owner.World.RenderPlayer))
return SpriteRenderable.None;
var palette = r.Palette(isPlayerPalette ? beaconPalette + owner.InternalName : beaconPalette);
return beacon.Render(position, palette);
}
public IEnumerable<IRenderable> ModifyRender(Actor self, WorldRenderer wr, IEnumerable<IRenderable> r)
{
// Contrails shouldn't cast shadows
var shadowSprites = r.Where(s => !s.IsDecoration)
.Select(a => a.WithPalette(wr.Palette(info.Palette))
.OffsetBy(new WVec(0, 0, -a.Pos.Z))
.WithZOffset(a.ZOffset + a.Pos.Z)
.AsDecoration());
return shadowSprites.Concat(r);
}
public IEnumerable<IRenderable> Render(WorldRenderer wr)
{
if (building.Owner != building.World.LocalPlayer)
return SpriteRenderable.None;
if (!building.IsInWorld || !building.World.Selection.Actors.Contains(building))
return SpriteRenderable.None;
var pos = cachedLocation.CenterPosition;
var palette = wr.Palette(palettePrefix+building.Owner.InternalName);
return circles.Render(pos, palette).Concat(flag.Render(pos, palette));
}
public TerrainRenderer(World world, WorldRenderer wr)
{
map = world.Map;
theater = wr.Theater;
foreach (var template in map.Rules.TileSet.Templates)
{
var palette = template.Value.Palette ?? TileSet.TerrainPaletteInternalName;
spriteLayers.GetOrAdd(palette, pal =>
new TerrainSpriteLayer(world, wr, theater.Sheet, BlendMode.Alpha, wr.Palette(palette), world.Type != WorldType.Editor));
}
foreach (var cell in map.AllCells)
{
UpdateCell(cell);
}
map.Tiles.CellEntryChanged += UpdateCell;
map.Height.CellEntryChanged += UpdateCell;
}
