public void DrawCursor(Texture2D Texture, vec2 Size, float Angle = 0)
{
vec2 WorldCord = ScreenToWorldCoord(Input.CurMousePos);
DrawTextureSmooth.Using(camvec, CameraAspect, Texture);
RectangleQuad.Draw(GameClass.Graphics, WorldCord, Size, Angle);
}
RectangleQuad SetUnitQuad(vec2 pos, vec2 size, float type, int player, int frame, float dir, RectangleQuad quad = null)
{
if (IsBuilding(type))
{
return(SetBuildingQuad(pos, size, type, player, quad));
}
vec2 uv_size = UnitSpriteSheet.SpriteSize;
vec2 uv_offset;
uv_offset.x = frame;
uv_offset.y = (Float(dir) - 1) + 4 * (player - 1) + 4 * 4 * Float(UnitType.UnitIndex(type));
uv_offset *= UnitSpriteSheet.SpriteSize;
if (quad == null)
{
quad = new RectangleQuad();
}
quad.SetupVertices(pos, pos + 2 * new vec2(size.x, -size.y), new vec2(0, uv_size.y) + uv_offset, new vec2(uv_size.x, 0.005f * uv_size.y) + uv_offset);
quad.Texture = Assets.UnitTexture_1;
return(quad);
}
public void DrawMinimap(vec2 pos, vec2 size, bool ShowCameraBox = true, bool SolidColor = false)
{
//vec2 center = pos + vec(-CameraAspect, -1) + new vec2(size.x, size.y) * vec(1.1f, 1.15f);
vec2 center = pos * vec(2 * CameraAspect, -2) - vec(CameraAspect, -1);
MinimapQuad.SetupVertices(center - size, center + size, vec(0, 0), vec(1, 1));
vec2 _size = size * vec(1, 254f / 245f) * 1.12f;
vec2 _center = center + _size * vec(.03f, -.06f);
DrawTextureSmooth.Using(vec(0, 0, 1, 1), CameraAspect, Assets.Minimap);
RectangleQuad.Draw(GameClass.Graphics, _center, _size);
if (SolidColor)
{
DrawSolid.Using(vec(0, 0, 1, 1), CameraAspect, rgb(0x222222));
MinimapQuad.Draw(GameClass.Graphics);
}
else
{
DrawTextureSmooth.Using(vec(0, 0, 1, 1), CameraAspect, Minimap);
MinimapQuad.Draw(GameClass.Graphics);
}
if (ShowCameraBox)
{
vec2 cam = CameraPos * size;
vec2 bl = center + cam - vec(CameraAspect, 1) * size / CameraZoom;
vec2 tr = center + cam + vec(CameraAspect, 1) * size / CameraZoom;
bl = max(bl, center - size);
tr = min(tr, center + size);
DrawSolid.Using(vec(0, 0, 1, 1), CameraAspect, new color(.6f, .6f, .6f, .5f));
DrawBox(bl, tr, 2f / GameClass.Screen.x);
}
}
private void DrawLine(vec2 p1, vec2 p2, float width)
{
var q = new RectangleQuad();
vec2 thick = vec(width, width);
q.SetupVertices(min(p1 - thick, p2 - thick), max(p1 + thick, p2 + thick), vec2.Zero, vec2.Ones);
q.Draw(GameClass.Graphics);
}
public void DrawArrowCursor()
{
vec2 WorldCord = ScreenToWorldCoord(Input.CurMousePos);
DrawTextureSmooth.Using(camvec, CameraAspect, Assets.Cursor);
vec2 size = .02f * Assets.Cursor.UnitSize() / CameraZoom;
RectangleQuad.Draw(GameClass.Graphics, WorldCord + new vec2(size.x, -size.y), size);
}
public static void DrawFullScreen(Texture2D texture)
{
float a = 1920f / 1080f;
var q = new RectangleQuad();
q.SetupVertices(new vec2(-a, -1), new vec2(a, 1), vec2.Zero, vec2.Ones);
q.SetColor(new color(1f, 1f, 1f, 1f));
DrawTextureSmooth.Using(new vec4(0, 0, 1, 1), ScreenAspect, texture);
q.Draw(GameClass.Graphics);
}
public void Add(string name, RectangleQuad e)
{
e.Texture = Assets.White;
Elements.Add(name, e);
if (!name.Contains("[Text]"))
{
Order.Add(e);
}
}
private void BlackOverlay(float s)
{
float a = 1920f / 1080f;
var q = new RectangleQuad();
q.SetupVertices(new vec2(-a, -1), new vec2(a, 1), vec2.Zero, vec2.Ones);
q.SetColor(new color(1f, 1f, 1f, 1f));
DrawSolid.Using(new vec4(0, 0, 1, 1), ScreenAspect, new color(0f, 0f, 0f, s));
q.Draw(GameClass.Graphics);
Render.UnsetDevice();
}
public void DrawGridCell()
{
vec2 GridCoord = ScreenToGridCoord(Input.CurMousePos);
color clr = CanPlaceItem ? DrawTerritoryPlayer.Available : DrawTerritoryPlayer.Unavailable;
DrawSolid.Using(camvec, CameraAspect, clr);
vec2 gWorldCord = GridToWorldCood(floor(GridCoord));
vec2 size = 1 / DataGroup.GridSize;
RectangleQuad.Draw(GameClass.Graphics, gWorldCord + new vec2(size.x, -size.y), size);
}
public static void Element(string name)
{
if (Ui.ActiveUi.Elements.ContainsKey(name))
{
Ui.e = Ui.ActiveUi.Elements[name];
return;
}
var e = new RectangleQuad(vec2.Zero, vec2.Zero, vec2.Zero, vec2.Ones);
Ui.ActiveUi.Add(name, e);
Ui.e = e;
}
public void SelectInAreaViaRasterize(vec2 pos, vec2 size, bool Deselect, bool Selecting, float Player, bool EffectSelection, bool Fake = false)
{
DataDrawMouse.Using(Assets.SelectCircle_Data, Player, Output: SelectField, Clear: Color.Transparent);
if (Selecting)
{
RectangleQuad.Draw(GraphicsDevice, pos, size);
}
if (EffectSelection)
{
SelectUnits(Player, Deselect, Fake);
}
}
public void DrawCircleCursor(bool AfterUi)
{
if (AfterUi)
{
return;
}
vec2 WorldCord = ScreenToWorldCoord(Input.CurMousePos);
DrawTextureSmooth.Using(camvec, CameraAspect, Assets.SelectCircle);
RectangleQuad.Draw(GameClass.Graphics, WorldCord, SelectSize);
DrawTextureSmooth.Using(camvec, CameraAspect, Assets.SelectDot);
RectangleQuad.Draw(GameClass.Graphics, WorldCord, .0075f * vec2.Ones / CameraZoom);
}
public void DrawVisibleGrid(float scale = 1)
{
vec2 center = CameraPos, size = vec(CameraAspect, 1) * scale;
vec2 uv_center = WorldToGridCood(CameraPos) / GridSize;
vec2 uv_size = abs((WorldToGridCood(vec(CameraAspect, 1) / CameraZoom) - WorldToGridCood(vec(0, 0))) / GridSize);
vec2
uv_bl = uv_center - uv_size,
uv_tr = uv_center + uv_size,
bl = CameraPos - vec(CameraAspect, 1) / CameraZoom,
tr = CameraPos + vec(CameraAspect, 1) / CameraZoom;
RectangleQuad q = new RectangleQuad(bl, tr, uv_bl, uv_tr);
q.Draw(GameClass.Graphics);
}
public Marker(World world, vec2 pos, vec2 size, Texture2D texture, float alpha_fade = -1, int frames = 1, float frame_length = .1f, DrawOrder DrawOrder = DrawOrder.AfterTiles, float alpha = 1, vec2 dsize_dt = default(vec2))
{
this.world = world;
this.alpha = alpha;
this.dalpha_dt = alpha_fade;
this.pos = pos;
this.size = size;
this.dsize_dt = dsize_dt;
this.frames = frames;
this.frame_length = frame_length;
quad = new RectangleQuad(pos - size / 2, pos + size / 2, vec2.Zero, vec(1.0f / frames, 1));
this.texture = texture;
this.MyDrawOrder = DrawOrder;
}
RectangleQuad SetBuildingQuad(vec2 pos, vec2 size, float type, int player, RectangleQuad quad = null)
{
vec2 uv_size = BuildingSpriteSheet.BuildingSize;
vec2 uv_offset;
uv_offset.x = player * BuildingSpriteSheet.BuildingDimX;
uv_offset.y = BuildingSpriteSheet.SubsheetDimY * Float(UnitType.BuildingIndex(type));
uv_offset *= BuildingSpriteSheet.SpriteSize;
if (quad == null)
{
quad = new RectangleQuad();
}
quad.SetupVertices(pos, pos + 2 * new vec2(size.x, -size.y), new vec2(0, uv_size.y) + uv_offset, new vec2(uv_size.x, 0) + uv_offset);
quad.Texture = Assets.BuildingTexture_1;
return(quad);
}
public void SelectAlongLine(vec2 p1, vec2 p2, vec2 size, bool Deselect, bool Selecting, float Player, bool EffectSelection, bool Fake = false)
{
DataDrawMouse.Using(Assets.SelectCircle_Data, Player, Output: SelectField, Clear: Color.Transparent);
if (Selecting)
{
vec2 shift = CellSpacing.FlipY();
for (int i = 0; i <= 10; i++)
{
float t = i / 10.0f;
var pos = t * p2 + (1 - t) * p1;
RectangleQuad.Draw(GraphicsDevice, pos - shift, size);
}
}
if (EffectSelection)
{
SelectUnits(Player, Deselect, Fake);
}
}
void DrawAvailabilityGrid()
{
vec2 GridCoord = ScreenToGridCoord(Input.CurMousePos) - new vec2(1, 1);
int _w = 3, _h = 3;
color clr = color.TransparentBlack;
CanPlaceItem = true;
for (int i = 0; i < _w; i++)
{
for (int j = 0; j < _h; j++)
{
clr = CanPlace[i + j * _h] ? DrawTerritoryPlayer.Available : DrawTerritoryPlayer.Unavailable;
DrawSolid.Using(camvec, CameraAspect, clr);
vec2 gWorldCord = GridToWorldCood(new vec2((float)Math.Floor(GridCoord.x + i), (float)Math.Floor(GridCoord.y + j)));
vec2 size = 1 / DataGroup.GridSize;
RectangleQuad.Draw(GameClass.Graphics, gWorldCord + new vec2(size.x, -size.y), size);
}
}
}
static void DrawElement(RectangleQuad e)
{
DrawTextureSmooth.Using(vec(0, 0, 1, 1), GameClass.ScreenAspect, e.Texture);
e.Draw(GameClass.Graphics);
}
void DrawDragonLordMarker(int player, bool After = false)
{
if (!TrackDragonLord)
{
return;
}
vec2 cur = CurDragonLordPos[player];
vec2 prev = PrevDragonLordPos[player];
if (cur.x < 1 && cur.y < 1)
{
return;
}
var q = new RectangleQuad();
var p = cur * PercentSimStepComplete + prev * (1 - PercentSimStepComplete);
p = GridToWorldCood(p);
var s = vec(.01f, .01f) + .0001f * vec2.Ones * (float)Math.Cos(GameClass.Game.DrawCount * .08f);
float alpha = 1;
bool selected = DataGroup.UnitSummary[Int(UnitType.DragonLord) - 1];
if (!After)
{
alpha = selected ? .11f : .05f;
color clr = selected ? new color(1f, 1f, 1f, alpha) : new color(.8f, .8f, .8f, alpha);
q.SetupVertices(p - s * 3, p + s * 3, vec(0, 0), vec(1, 1));
q.SetColor(clr);
DrawTexture.Using(camvec, CameraAspect, Assets.DragonLord_Marker);
q.Draw(GameClass.Game.GraphicsDevice);
q.SetupVertices(p - s * .5f, p + s * .5f, vec(0, 0), vec(1, 1));
q.SetColor(clr);
DrawTexture.Using(camvec, CameraAspect, Assets.DragonLord_Marker);
q.Draw(GameClass.Game.GraphicsDevice);
}
if (After)
{
float z = 14;
if (CameraZoom <= z / 4f)
{
s *= 7;
alpha = CoreMath.LerpRestrict(z / 4, 0, z / 8, 1, CameraZoom);
}
else
{
return;
}
q.SetupVertices(p - s, p + s, vec(0, 0), vec(1, 1));
q.SetColor(new color(.8f, .8f, .8f, 1f * alpha));
var texture = Assets.AoE_DragonLord[player];
if (player == MyPlayerNumber && selected)
{
texture = Assets.AoE_DragonLord_Selected;
}
DrawTexture.Using(camvec, CameraAspect, texture);
q.Draw(GameClass.Game.GraphicsDevice);
}
}
public static bool Contains(this RectangleQuad quad, vec2 pos)
{
return(pos > quad.Bl && pos < quad.Tr);
}
//Build the mesh for the base
private static Mesh CreateBoardBaseMesh(int width, int height, float unitSize, List <int>[] allPorts)
{
//Create the mesh
Mesh mesh = new Mesh();
List <Vector3> vertices = new List <Vector3>();
List <int> triangles = new List <int>();
//Create base
var h = height * unitSize;
var w = width * unitSize;
var quad = new RectangleQuad(0, 0, w, h);
quad.Build(vertices, triangles);
#region Create Borders
float offset = 0.0f;
//horizontal
var topStrip = new Strip();
var bottomStrip = new Strip();
var topPorts = allPorts[1];
var bottomPorts = allPorts[3];
var edgei = new Edge(0, h, 0, h + BordersWidth);
topStrip.AddEdge(edgei);
edgei = new Edge(0, -BordersWidth, 0, 0);
bottomStrip.AddEdge(edgei);
for (var i = 0; i < width; i++)
{
//top
offset = (topPorts.Exists(u => u == i))? BordersOffset : 0.0f;
var edge0 = new Edge(unitSize * i + 0.1f, h, unitSize * i + 0.1f, h + BordersWidth + offset);
var edge1 = new Edge(unitSize * i + 1.9f, h, unitSize * i + 1.9f, h + BordersWidth + offset);
topStrip.AddEdge(edge0);
topStrip.AddEdge(edge1);
//bottom
offset = (bottomPorts.Exists(u => u == i))? BordersOffset : 0.0f;
edge0 = new Edge(unitSize * i + 0.1f, -BordersWidth - offset, unitSize * i + 0.1f, 0);
edge1 = new Edge(unitSize * i + 1.9f, -BordersWidth - offset, unitSize * i + 1.9f, 0);
bottomStrip.AddEdge(edge0);
bottomStrip.AddEdge(edge1);
}
edgei = new Edge(unitSize * width, h, unitSize * width, h + BordersWidth);
topStrip.AddEdge(edgei);
edgei = new Edge(unitSize * width, -BordersWidth, unitSize * width, 0);
bottomStrip.AddEdge(edgei);
var top = topStrip.Build(vertices, triangles);
var bottom = bottomStrip.Build(vertices, triangles);
//vertical
var leftStrip = new Strip();
var rightStrip = new Strip();
var leftPorts = allPorts[0];
var rightPorts = allPorts[2];
edgei = new Edge(0, 0, -BordersWidth, 0);
leftStrip.AddEdge(edgei);
edgei = new Edge(w + BordersWidth, 0, w, 0);
rightStrip.AddEdge(edgei);
for (var i = 0; i < height; i++)
{
//left
offset = (leftPorts.Exists(u => u == i)) ? BordersOffset : 0.0f;
var edge0 = new Edge(0, unitSize * i + 0.1f, -BordersWidth - offset, unitSize * i + 0.1f);
var edge1 = new Edge(0, unitSize * i + 1.9f, -BordersWidth - offset, unitSize * i + 1.9f);
leftStrip.AddEdge(edge0);
leftStrip.AddEdge(edge1);
//right
offset = (rightPorts.Exists(u => u == i)) ? BordersOffset : 0.0f;
edge0 = new Edge(w + BordersWidth + offset, unitSize * i + 0.1f, w, unitSize * i + 0.1f);
edge1 = new Edge(w + BordersWidth + offset, unitSize * i + 1.9f, w, unitSize * i + 1.9f);
rightStrip.AddEdge(edge0);
rightStrip.AddEdge(edge1);
}
edgei = new Edge(0, unitSize * height, -BordersWidth, unitSize * height);
leftStrip.AddEdge(edgei);
edgei = new Edge(w + BordersWidth, unitSize * height, w, unitSize * height);
rightStrip.AddEdge(edgei);
var left = leftStrip.Build(vertices, triangles);
var right = rightStrip.Build(vertices, triangles);
#endregion
#region Create Corners
//left-top corner
var v1 = left[1] - 1;
var v2 = left[1];
var v3 = top[0] + 1;
triangles.Add(v1);
triangles.Add(v2);
triangles.Add(v3);
//top-right corner
v1 = top[1] - 1;
v2 = top[1];
v3 = right[1] - 1;
triangles.Add(v1);
triangles.Add(v2);
triangles.Add(v3);
//right-bottom corner
v1 = right[0];
v2 = bottom[1] - 1;
v3 = right[0] + 1;
triangles.Add(v1);
triangles.Add(v2);
triangles.Add(v3);
//bottom-left corner
v1 = bottom[0];
v2 = left[0] + 1;
v3 = bottom[0] + 1;
triangles.Add(v1);
triangles.Add(v2);
triangles.Add(v3);
#endregion
#region Extrude
//find outer edges
var outerEdges = new List <Vector2Int>();
//left
for (var i = left[1]; i >= left[0]; i--)
{
if (i % 2 == 0)
{
continue;
}
if (i - 2 < left[0])
{
break;
}
outerEdges.Add(new Vector2Int(i, i - 2));
}
//top
for (var i = top[1]; i >= top[0]; i--)
{
if (i % 2 == 0)
{
continue;
}
if (i - 2 < top[0])
{
break;
}
outerEdges.Add(new Vector2Int(i, i - 2));
}
//right
for (var i = right[0]; i <= right[1]; i++)
{
if (i % 2 != 0)
{
continue;
}
if (i + 2 > right[1])
{
break;
}
outerEdges.Add(new Vector2Int(i, i + 2));
}
//bottom
for (var i = bottom[0]; i <= bottom[1]; i++)
{
if (i % 2 != 0)
{
continue;
}
if (i + 2 > bottom[1])
{
break;
}
outerEdges.Add(new Vector2Int(i, i + 2));
}
//corners
outerEdges.Add(new Vector2Int(top[0] + 1, left[1]));
outerEdges.Add(new Vector2Int(right[1] - 1, top[1]));
outerEdges.Add(new Vector2Int(bottom[1] - 1, right[0]));
outerEdges.Add(new Vector2Int(left[0] + 1, bottom[0]));
//extrude
for (var i = 0; i < outerEdges.Count; i++)
{
var n = vertices.Count;
var edge = outerEdges[i];
var a0 = edge.x;
var a1 = edge.y;
//duplicate edge
var v = vertices[edge.x];
v.y -= BoardThickness;
vertices.Add(v);
var a2 = n;
v = vertices[edge.y];
v.y -= BoardThickness;
vertices.Add(v);
var a3 = n + 1;
triangles.Add(a0);
triangles.Add(a1);
triangles.Add(a2);
triangles.Add(a2);
triangles.Add(a1);
triangles.Add(a3);
}
#endregion
//set mesh properties
mesh.vertices = vertices.ToArray();
mesh.triangles = triangles.ToArray();
mesh.RecalculateNormals();
return(mesh);
}
