private WorldPos mapPos_From_LNDPos(XYZInt Pos)
{
var Result = new WorldPos();
Result.Horizontal.X = Pos.X + (int)(map.Terrain.TileSize.X * Constants.TerrainGridSpacing / 2.0D);
Result.Horizontal.Y = ((int)(map.Terrain.TileSize.Y * Constants.TerrainGridSpacing / 2.0D)) - Pos.Z;
Result.Altitude = (int)(map.GetTerrainHeight(Result.Horizontal));
return Result;
}
public bool ScreenXY_Get_TerrainPos(XYInt screenPos, ref WorldPos resultPos)
{
double dblTemp = 0;
var xYZ_dbl = default(XYZDouble);
var terrainViewVector = default(XYZDouble);
var x = 0;
var y = 0;
var limitA = default(XYDouble);
var limitB = default(XYDouble);
var min = new XYInt();
var max = new XYInt();
double triGradientX = 0;
double triGradientZ = 0;
double triHeightOffset = 0;
double dist = 0;
var bestPos = default(XYZDouble);
double bestDist = 0;
var dif = default(XYZDouble);
double inTileX = 0;
double inTileZ = 0;
var tilePos = default(XYDouble);
var terrainViewPos = default(XYZDouble);
try
{
terrainViewPos.X = ViewPos.X;
terrainViewPos.Y = ViewPos.Y;
terrainViewPos.Z = Convert.ToDouble(- ViewPos.Z);
//convert screen pos to vector of one pos unit
xYZ_dbl.X = (screenPos.X - MapViewControl.GLSize.X / 2.0D) * FOVMultiplier;
xYZ_dbl.Y = (MapViewControl.GLSize.Y / 2.0D - screenPos.Y) * FOVMultiplier;
xYZ_dbl.Z = 1.0D;
//rotate the vector so that it points forward and level
Matrix3DMath.VectorRotationByMatrix(ViewAngleMatrix, xYZ_dbl, ref terrainViewVector);
terrainViewVector.Y = Convert.ToDouble(- terrainViewVector.Y); //get the amount of looking down, not up
terrainViewVector.Z = Convert.ToDouble(- terrainViewVector.Z); //convert to terrain coordinates from view coordinates
//get range of possible tiles
dblTemp = (terrainViewPos.Y - 255 * Map.HeightMultiplier) / terrainViewVector.Y;
limitA.X = terrainViewPos.X + terrainViewVector.X * dblTemp;
limitA.Y = terrainViewPos.Z + terrainViewVector.Z * dblTemp;
dblTemp = terrainViewPos.Y / terrainViewVector.Y;
limitB.X = terrainViewPos.X + terrainViewVector.X * dblTemp;
limitB.Y = terrainViewPos.Z + terrainViewVector.Z * dblTemp;
min.X = Math.Max(Convert.ToInt32((Math.Min(limitA.X, limitB.X) / Constants.TerrainGridSpacing)), 0);
min.Y = Math.Max((int)((Math.Min(limitA.Y, limitB.Y) / Constants.TerrainGridSpacing)), 0);
max.X = Math.Min(Convert.ToInt32((Math.Max(limitA.X, limitB.X) / Constants.TerrainGridSpacing)), Map.Terrain.TileSize.X - 1);
max.Y = Math.Min(Convert.ToInt32((Math.Max(limitA.Y, limitB.Y) / Constants.TerrainGridSpacing)), Map.Terrain.TileSize.Y - 1);
//find the nearest valid tile to the view
bestDist = double.MaxValue;
bestPos.X = double.NaN;
bestPos.Y = double.NaN;
bestPos.Z = double.NaN;
for ( y = min.Y; y <= max.Y; y++ )
{
for ( x = min.X; x <= max.X; x++ )
{
tilePos.X = x * Constants.TerrainGridSpacing;
tilePos.Y = y * Constants.TerrainGridSpacing;
if ( Map.Terrain.Tiles[x, y].Tri )
{
triHeightOffset = Convert.ToDouble(Map.Terrain.Vertices[x, y].Height * Map.HeightMultiplier);
triGradientX = Convert.ToDouble(Map.Terrain.Vertices[x + 1, y].Height * Map.HeightMultiplier - triHeightOffset);
triGradientZ = Convert.ToDouble(Map.Terrain.Vertices[x, y + 1].Height * Map.HeightMultiplier - triHeightOffset);
xYZ_dbl.Y = (triHeightOffset +
(triGradientX * (terrainViewPos.X - tilePos.X) + triGradientZ * (terrainViewPos.Z - tilePos.Y) +
(triGradientX * terrainViewVector.X + triGradientZ * terrainViewVector.Z) * terrainViewPos.Y / terrainViewVector.Y) /
Constants.TerrainGridSpacing) /
(1.0D +
(triGradientX * terrainViewVector.X + triGradientZ * terrainViewVector.Z) / (terrainViewVector.Y * Constants.TerrainGridSpacing));
xYZ_dbl.X = terrainViewPos.X + terrainViewVector.X * (terrainViewPos.Y - xYZ_dbl.Y) / terrainViewVector.Y;
xYZ_dbl.Z = terrainViewPos.Z + terrainViewVector.Z * (terrainViewPos.Y - xYZ_dbl.Y) / terrainViewVector.Y;
inTileX = xYZ_dbl.X / Constants.TerrainGridSpacing - x;
inTileZ = xYZ_dbl.Z / Constants.TerrainGridSpacing - y;
if ( inTileZ <= 1.0D - inTileX & inTileX >= 0.0D & inTileZ >= 0.0D & inTileX <= 1.0D & inTileZ <= 1.0D )
{
dif = xYZ_dbl - terrainViewPos;
dist = dif.GetMagnitude();
if ( dist < bestDist )
{
bestDist = dist;
bestPos = xYZ_dbl;
}
}
triHeightOffset = Convert.ToDouble(Map.Terrain.Vertices[x + 1, y + 1].Height * Map.HeightMultiplier);
triGradientX = Convert.ToDouble(Map.Terrain.Vertices[x, y + 1].Height * Map.HeightMultiplier - triHeightOffset);
triGradientZ = Convert.ToDouble(Map.Terrain.Vertices[x + 1, y].Height * Map.HeightMultiplier - triHeightOffset);
xYZ_dbl.Y = (triHeightOffset + triGradientX + triGradientZ +
(triGradientX * (tilePos.X - terrainViewPos.X) + triGradientZ * (tilePos.Y - terrainViewPos.Z) -
(triGradientX * terrainViewVector.X + triGradientZ * terrainViewVector.Z) * terrainViewPos.Y / terrainViewVector.Y) /
Constants.TerrainGridSpacing) /
(1.0D -
(triGradientX * terrainViewVector.X + triGradientZ * terrainViewVector.Z) / (terrainViewVector.Y * Constants.TerrainGridSpacing));
xYZ_dbl.X = terrainViewPos.X + terrainViewVector.X * (terrainViewPos.Y - xYZ_dbl.Y) / terrainViewVector.Y;
xYZ_dbl.Z = terrainViewPos.Z + terrainViewVector.Z * (terrainViewPos.Y - xYZ_dbl.Y) / terrainViewVector.Y;
inTileX = xYZ_dbl.X / Constants.TerrainGridSpacing - x;
inTileZ = xYZ_dbl.Z / Constants.TerrainGridSpacing - y;
if ( inTileZ >= 1.0D - inTileX & inTileX >= 0.0D & inTileZ >= 0.0D & inTileX <= 1.0D & inTileZ <= 1.0D )
{
dif = xYZ_dbl - terrainViewPos;
dist = dif.GetMagnitude();
if ( dist < bestDist )
{
bestDist = dist;
bestPos = xYZ_dbl;
}
}
}
else
{
triHeightOffset = Convert.ToDouble(Map.Terrain.Vertices[x + 1, y].Height * Map.HeightMultiplier);
triGradientX = Convert.ToDouble(Map.Terrain.Vertices[x, y].Height * Map.HeightMultiplier - triHeightOffset);
triGradientZ = Convert.ToDouble(Map.Terrain.Vertices[x + 1, y + 1].Height * Map.HeightMultiplier - triHeightOffset);
xYZ_dbl.Y = (triHeightOffset + triGradientX +
(triGradientX * (tilePos.X - terrainViewPos.X) + triGradientZ * (terrainViewPos.Z - tilePos.Y) -
(triGradientX * terrainViewVector.X - triGradientZ * terrainViewVector.Z) * terrainViewPos.Y / terrainViewVector.Y) /
Constants.TerrainGridSpacing) /
(1.0D -
(triGradientX * terrainViewVector.X - triGradientZ * terrainViewVector.Z) / (terrainViewVector.Y * Constants.TerrainGridSpacing));
xYZ_dbl.X = terrainViewPos.X + terrainViewVector.X * (terrainViewPos.Y - xYZ_dbl.Y) / terrainViewVector.Y;
xYZ_dbl.Z = terrainViewPos.Z + terrainViewVector.Z * (terrainViewPos.Y - xYZ_dbl.Y) / terrainViewVector.Y;
inTileX = xYZ_dbl.X / Constants.TerrainGridSpacing - x;
inTileZ = xYZ_dbl.Z / Constants.TerrainGridSpacing - y;
if ( inTileZ <= inTileX & inTileX >= 0.0D & inTileZ >= 0.0D & inTileX <= 1.0D & inTileZ <= 1.0D )
{
dif = xYZ_dbl - terrainViewPos;
dist = dif.GetMagnitude();
if ( dist < bestDist )
{
bestDist = dist;
bestPos = xYZ_dbl;
}
}
triHeightOffset = Convert.ToDouble(Map.Terrain.Vertices[x, y + 1].Height * Map.HeightMultiplier);
triGradientX = Convert.ToDouble(Map.Terrain.Vertices[x + 1, y + 1].Height * Map.HeightMultiplier - triHeightOffset);
triGradientZ = Convert.ToDouble(Map.Terrain.Vertices[x, y].Height * Map.HeightMultiplier - triHeightOffset);
xYZ_dbl.Y = (triHeightOffset + triGradientZ +
(triGradientX * (terrainViewPos.X - tilePos.X) + triGradientZ * (tilePos.Y - terrainViewPos.Z) +
(triGradientX * terrainViewVector.X - triGradientZ * terrainViewVector.Z) * terrainViewPos.Y / terrainViewVector.Y) /
Constants.TerrainGridSpacing) /
(1.0D +
(triGradientX * terrainViewVector.X - triGradientZ * terrainViewVector.Z) / (terrainViewVector.Y * Constants.TerrainGridSpacing));
xYZ_dbl.X = terrainViewPos.X + terrainViewVector.X * (terrainViewPos.Y - xYZ_dbl.Y) / terrainViewVector.Y;
xYZ_dbl.Z = terrainViewPos.Z + terrainViewVector.Z * (terrainViewPos.Y - xYZ_dbl.Y) / terrainViewVector.Y;
inTileX = xYZ_dbl.X / Constants.TerrainGridSpacing - x;
inTileZ = xYZ_dbl.Z / Constants.TerrainGridSpacing - y;
if ( inTileZ >= inTileX & inTileX >= 0.0D & inTileZ >= 0.0D & inTileX <= 1.0D & inTileZ <= 1.0D )
{
dif = xYZ_dbl - terrainViewPos;
dist = dif.GetMagnitude();
if ( dist < bestDist )
{
bestDist = dist;
bestPos = xYZ_dbl;
}
}
}
}
}
if ( bestPos.X == double.NaN )
{
return false;
}
resultPos.Horizontal.X = (int)bestPos.X;
resultPos.Altitude = (int)bestPos.Y;
resultPos.Horizontal.Y = (int)bestPos.Z;
}
catch
{
return false;
}
return true;
}
public clsUnit PlaceUnit(UnitTypeBase TypeBase, WorldPos Pos, clsUnitGroup UnitGroup, int Rotation)
{
var TilePosA = new XYInt();
var TilePosB = new XYInt();
var X2 = 0;
var Y2 = 0;
var FinalTilePos = new XYInt();
var Footprint = new XYInt();
var NewUnitAdd = new clsUnitAdd();
NewUnitAdd.Map = Map;
NewUnitAdd.StoreChange = true;
var NewUnit = new clsUnit();
NewUnitAdd.NewUnit = NewUnit;
NewUnit.TypeBase = TypeBase;
NewUnit.UnitGroup = UnitGroup;
FinalTilePos.X = Pos.Horizontal.X / Constants.TerrainGridSpacing;
FinalTilePos.Y = Pos.Horizontal.Y / Constants.TerrainGridSpacing;
Footprint = TypeBase.get_GetFootprintSelected(Rotation);
NewUnit.Pos = Pos;
TilePosA.X = (int)(((double)NewUnit.Pos.Horizontal.X / Constants.TerrainGridSpacing - Footprint.X / 2.0D + 0.5D));
TilePosA.Y = (int)(((double)NewUnit.Pos.Horizontal.Y / Constants.TerrainGridSpacing - Footprint.Y / 2.0D + 0.5D));
TilePosB.X = (int)((double)NewUnit.Pos.Horizontal.X / Constants.TerrainGridSpacing + Footprint.X / 2.0D - 0.5D);
TilePosB.Y = (int)((double)NewUnit.Pos.Horizontal.Y / Constants.TerrainGridSpacing + Footprint.Y / 2.0D - 0.5D);
NewUnit.Rotation = Rotation;
NewUnitAdd.Perform();
for ( Y2 = Math.Max(TilePosA.Y, 0); Y2 <= Math.Min(TilePosB.Y, Map.Terrain.TileSize.Y - 1); Y2++ )
{
for ( X2 = Math.Max(TilePosA.X, 0); X2 <= Math.Min(TilePosB.X, Map.Terrain.TileSize.X - 1); X2++ )
{
TileNodeBlock(X2, Y2);
}
}
TilePathMap.FindCalc();
return NewUnit;
}
public WorldPos GetTileOffsetRotatedWorldPos(XYInt Tile, XYInt TileOffsetToRotate)
{
var Result = new WorldPos();
var RotatedOffset = new XYInt();
RotatedOffset = TileUtil.GetTileRotatedOffset(Terrain.Tiles[Tile.X, Tile.Y].Texture.Orientation, TileOffsetToRotate);
Result.Horizontal.X = Tile.X * Constants.TerrainGridSpacing + RotatedOffset.X;
Result.Horizontal.Y = Tile.Y * Constants.TerrainGridSpacing + RotatedOffset.Y;
Result.Altitude = (int)(GetTerrainHeight(Result.Horizontal));
return Result;
}
public void DrawTileOrientation(XYInt Tile)
{
var UnrotatedPos = new XYInt();
var Vertex0 = new WorldPos();
var Vertex1 = new WorldPos();
var Vertex2 = new WorldPos();
UnrotatedPos.X = 32;
UnrotatedPos.Y = 32;
Vertex0 = GetTileOffsetRotatedWorldPos(Tile, UnrotatedPos);
UnrotatedPos.X = 64;
UnrotatedPos.Y = 32;
Vertex1 = GetTileOffsetRotatedWorldPos(Tile, UnrotatedPos);
UnrotatedPos.X = 64;
UnrotatedPos.Y = 64;
Vertex2 = GetTileOffsetRotatedWorldPos(Tile, UnrotatedPos);
GL.Vertex3(Vertex0.Horizontal.X, Vertex0.Altitude, Vertex0.Horizontal.Y);
GL.Vertex3(Vertex1.Horizontal.X, Vertex1.Altitude, Vertex1.Horizontal.Y);
GL.Vertex3(Vertex2.Horizontal.X, Vertex2.Altitude, Vertex2.Horizontal.Y);
}
public WorldPos TileAlignedPosFromMapPos(XYInt Horizontal, XYInt Footprint)
{
var Result = new WorldPos();
Result.Horizontal.X =
(int)
((Math.Round(Convert.ToDouble((Horizontal.X - Footprint.X * Constants.TerrainGridSpacing / 2.0D) / Constants.TerrainGridSpacing)) +
Footprint.X / 2.0D) * Constants.TerrainGridSpacing);
Result.Horizontal.Y =
(int)
((Math.Round(Convert.ToDouble((Horizontal.Y - Footprint.Y * Constants.TerrainGridSpacing / 2.0D) / Constants.TerrainGridSpacing)) +
Footprint.Y / 2.0D) * Constants.TerrainGridSpacing);
Result.Altitude = (int)(GetTerrainHeight(Result.Horizontal));
return Result;
}
public WorldPos TileAlignedPos(XYInt TileNum, XYInt Footprint)
{
var Result = new WorldPos();
Result.Horizontal.X = (int)((TileNum.X + Footprint.X / 2.0D) * Constants.TerrainGridSpacing);
Result.Horizontal.Y = (int)((TileNum.Y + Footprint.Y / 2.0D) * Constants.TerrainGridSpacing);
Result.Altitude = (int)(GetTerrainHeight(Result.Horizontal));
return Result;
}
public void GLDraw()
{
var XYZ_dbl = default(XYZDouble);
var X = 0;
var Y = 0;
var X2 = 0;
var Y2 = 0;
var A = 0;
var B = 0;
var C = 0;
var D = 0;
var ColourA = new sRGBA_sng();
var ColourB = new sRGBA_sng();
var ShowMinimapViewPosBox = default(bool);
var ViewCorner0 = default(XYDouble);
var ViewCorner1 = default(XYDouble);
var ViewCorner2 = default(XYDouble);
var ViewCorner3 = default(XYDouble);
double dblTemp = 0;
var Vertex0 = default(XYZDouble);
var Vertex1 = default(XYZDouble);
var Vertex2 = default(XYZDouble);
var Vertex3 = default(XYZDouble);
var ScreenPos = new XYInt();
var XYZ_dbl2 = default(XYZDouble);
var WorldPos = new WorldPos();
var PosA = default(XYDouble);
var PosB = default(XYDouble);
var PosC = default(XYDouble);
var PosD = default(XYDouble);
var MinimapSizeXY = new XYInt();
var Unit = default(clsUnit);
var StartXY = new XYInt();
var FinishXY = new XYInt();
var DrawIt = default(bool);
var DrawCentreSector = new clsBrush.sPosNum();
var SelectionLabel = new clsTextLabel();
var light_position = new float[4];
var matrixB = new Matrix3DMath.Matrix3D();
var MapAction = default(clsAction);
float ZNearFar = 0;
var MapViewControl = ViewInfo.MapViewControl;
var GLSize = ViewInfo.MapViewControl.GLSize;
var DrawCentre = default(XYDouble);
double dblTemp2 = 0;
dblTemp = SettingsManager.Settings.MinimapSize;
ViewInfo.Tiles_Per_Minimap_Pixel = Math.Sqrt(Terrain.TileSize.X * Terrain.TileSize.X + Terrain.TileSize.Y * Terrain.TileSize.Y) /
(MathUtil.RootTwo * dblTemp);
if ( Minimap_Texture_Size > 0 & ViewInfo.Tiles_Per_Minimap_Pixel > 0.0D )
{
MinimapSizeXY.X = (int)(Terrain.TileSize.X / ViewInfo.Tiles_Per_Minimap_Pixel);
MinimapSizeXY.Y = (int)(Terrain.TileSize.Y / ViewInfo.Tiles_Per_Minimap_Pixel);
}
if ( !ViewInfo.ScreenXY_Get_ViewPlanePos(new XYInt((int)(GLSize.X / 2.0D), (int)(GLSize.Y / 2.0D)), dblTemp, ref DrawCentre) )
{
Matrix3DMath.VectorForwardsRotationByMatrix(ViewInfo.ViewAngleMatrix, ref XYZ_dbl);
dblTemp2 = App.VisionRadius * 2.0D / Math.Sqrt(XYZ_dbl.X * XYZ_dbl.X + XYZ_dbl.Z * XYZ_dbl.Z);
DrawCentre.X = ViewInfo.ViewPos.X + XYZ_dbl.X * dblTemp2;
DrawCentre.Y = ViewInfo.ViewPos.Z + XYZ_dbl.Z * dblTemp2;
}
DrawCentre.X = MathUtil.Clamp_dbl(DrawCentre.X, 0.0D, Terrain.TileSize.X * Constants.TerrainGridSpacing - 1.0D);
DrawCentre.Y = MathUtil.Clamp_dbl(Convert.ToDouble(- DrawCentre.Y), 0.0D, Terrain.TileSize.Y * Constants.TerrainGridSpacing - 1.0D);
DrawCentreSector.Normal = GetPosSectorNum(new XYInt((int)DrawCentre.X, (int)DrawCentre.Y));
DrawCentreSector.Alignment =
GetPosSectorNum(new XYInt((int)(DrawCentre.X - Constants.SectorTileSize * Constants.TerrainGridSpacing / 2.0D),
(int)(DrawCentre.Y - Constants.SectorTileSize * Constants.TerrainGridSpacing / 2.0D)));
var DrawObjects = new clsDrawSectorObjects();
DrawObjects.Map = this;
DrawObjects.UnitTextLabels = new clsTextLabels(64);
DrawObjects.Start();
XYZ_dbl.X = DrawCentre.X - ViewInfo.ViewPos.X;
XYZ_dbl.Y = 128 - ViewInfo.ViewPos.Y;
XYZ_dbl.Z = - DrawCentre.Y - ViewInfo.ViewPos.Z;
ZNearFar = (float)(XYZ_dbl.GetMagnitude());
GL.Enable(EnableCap.DepthTest);
GL.MatrixMode(MatrixMode.Projection);
var temp_mat = Matrix4.CreatePerspectiveFieldOfView(ViewInfo.FieldOfViewY, MapViewControl.OpenGLControl.AspectRatio, ZNearFar / 128.0F, ZNearFar * 128.0F);
GL.LoadMatrix(ref temp_mat);
GL.MatrixMode(MatrixMode.Modelview);
GL.LoadIdentity();
Matrix3DMath.MatrixRotationByMatrix(ViewInfo.ViewAngleMatrix_Inverted, App.SunAngleMatrix, matrixB);
Matrix3DMath.VectorForwardsRotationByMatrix(matrixB, ref XYZ_dbl);
light_position[0] = (float)XYZ_dbl.X;
light_position[1] = (float)XYZ_dbl.Y;
light_position[2] = Convert.ToSingle(- XYZ_dbl.Z);
light_position[3] = 0.0F;
GL.Light(LightName.Light0, LightParameter.Position, light_position);
GL.Light(LightName.Light1, LightParameter.Position, light_position);
GL.Disable(EnableCap.Light0);
GL.Disable(EnableCap.Light1);
if ( App.Draw_Lighting != enumDrawLighting.Off )
{
if ( App.Draw_Lighting == enumDrawLighting.Half )
{
GL.Enable(EnableCap.Light0);
}
else if ( App.Draw_Lighting == enumDrawLighting.Normal )
{
GL.Enable(EnableCap.Light1);
}
GL.Enable(EnableCap.Lighting);
}
else
{
GL.Disable(EnableCap.Lighting);
}
dblTemp = 127.5D * HeightMultiplier;
if ( ViewInfo.ScreenXY_Get_ViewPlanePos_ForwardDownOnly(0, 0, dblTemp, ref ViewCorner0)
&& ViewInfo.ScreenXY_Get_ViewPlanePos_ForwardDownOnly(GLSize.X, 0, dblTemp, ref ViewCorner1)
&& ViewInfo.ScreenXY_Get_ViewPlanePos_ForwardDownOnly(GLSize.X, GLSize.Y, dblTemp, ref ViewCorner2)
&& ViewInfo.ScreenXY_Get_ViewPlanePos_ForwardDownOnly(0, GLSize.Y, dblTemp, ref ViewCorner3) )
{
ShowMinimapViewPosBox = true;
}
else
{
ShowMinimapViewPosBox = false;
}
GL.Rotate((float)(ViewInfo.ViewAngleRPY.Roll / MathUtil.RadOf1Deg), 0.0F, 0.0F, -1.0F);
GL.Rotate((float)(ViewInfo.ViewAngleRPY.Pitch / MathUtil.RadOf1Deg), 1.0F, 0.0F, 0.0F);
GL.Rotate((float)(ViewInfo.ViewAngleRPY.Yaw / MathUtil.RadOf1Deg), 0.0F, 1.0F, 0.0F);
GL.Translate(Convert.ToDouble(- ViewInfo.ViewPos.X), Convert.ToDouble(- ViewInfo.ViewPos.Y), ViewInfo.ViewPos.Z);
GL.Enable(EnableCap.CullFace);
DebugGLError("Matrix modes");
if ( App.Draw_TileTextures )
{
GL.Color3(1.0F, 1.0F, 1.0F);
GL.Enable(EnableCap.Texture2D);
MapAction = new clsDrawCallTerrain();
MapAction.Map = this;
App.VisionSectors.PerformActionMapSectors(MapAction, DrawCentreSector);
GL.Disable(EnableCap.Texture2D);
DebugGLError("Tile textures");
}
GL.Disable(EnableCap.DepthTest);
GL.Disable(EnableCap.Lighting);
if ( App.Draw_TileWireframe )
{
GL.Color3(0.0F, 1.0F, 0.0F);
GL.LineWidth(1.0F);
var DrawCallTerrainWireframe = new clsDrawCallTerrainWireframe();
DrawCallTerrainWireframe.Map = this;
App.VisionSectors.PerformActionMapSectors(DrawCallTerrainWireframe, DrawCentreSector);
DebugGLError("Wireframe");
}
//draw tile orientation markers
if ( App.DisplayTileOrientation )
{
GL.Disable(EnableCap.CullFace);
GL.Begin(BeginMode.Triangles);
GL.Color3(1.0F, 1.0F, 0.0F);
MapAction = new clsDrawTileOrientation();
MapAction.Map = this;
App.VisionSectors.PerformActionMapSectors(MapAction, DrawCentreSector);
GL.End();
GL.Enable(EnableCap.CullFace);
DebugGLError("Tile orientation");
}
//draw painted texture terrain type markers
var RGB_sng = new sRGB_sng();
var MouseOverTerrain = ViewInfo.GetMouseOverTerrain();
if ( App.Draw_VertexTerrain )
{
GL.LineWidth(1.0F);
var DrawVertexTerran = new clsDrawVertexTerrain();
DrawVertexTerran.Map = this;
DrawVertexTerran.ViewAngleMatrix = ViewInfo.ViewAngleMatrix;
App.VisionSectors.PerformActionMapSectors(DrawVertexTerran, DrawCentreSector);
DebugGLError("Terrain type markers");
}
SelectionLabel.Text = "";
if ( Selected_Area_VertexA != null )
{
DrawIt = false;
if ( Selected_Area_VertexB != null )
{
//area is selected
MathUtil.ReorderXY(Selected_Area_VertexA, Selected_Area_VertexB, ref StartXY, ref FinishXY);
XYZ_dbl.X = Selected_Area_VertexB.X * Constants.TerrainGridSpacing - ViewInfo.ViewPos.X;
XYZ_dbl.Z = - Selected_Area_VertexB.Y * Constants.TerrainGridSpacing - ViewInfo.ViewPos.Z;
XYZ_dbl.Y = GetVertexAltitude(Selected_Area_VertexB) - ViewInfo.ViewPos.Y;
DrawIt = true;
}
else if ( modTools.Tool == modTools.Tools.TerrainSelect )
{
if ( MouseOverTerrain != null )
{
//selection is changing under pointer
MathUtil.ReorderXY(Selected_Area_VertexA, MouseOverTerrain.Vertex.Normal, ref StartXY, ref FinishXY);
XYZ_dbl.X = MouseOverTerrain.Vertex.Normal.X * Constants.TerrainGridSpacing - ViewInfo.ViewPos.X;
XYZ_dbl.Z = - MouseOverTerrain.Vertex.Normal.Y * Constants.TerrainGridSpacing - ViewInfo.ViewPos.Z;
XYZ_dbl.Y = GetVertexAltitude(MouseOverTerrain.Vertex.Normal) - ViewInfo.ViewPos.Y;
DrawIt = true;
}
}
if ( DrawIt )
{
Matrix3DMath.VectorRotationByMatrix(ViewInfo.ViewAngleMatrix_Inverted, XYZ_dbl, ref XYZ_dbl2);
if ( ViewInfo.Pos_Get_Screen_XY(XYZ_dbl2, ref ScreenPos) )
{
if ( ScreenPos.X >= 0 & ScreenPos.X <= GLSize.X & ScreenPos.Y >= 0 & ScreenPos.Y <= GLSize.Y )
{
SelectionLabel.Colour.Red = 1.0F;
SelectionLabel.Colour.Green = 1.0F;
SelectionLabel.Colour.Blue = 1.0F;
SelectionLabel.Colour.Alpha = 1.0F;
SelectionLabel.TextFont = App.UnitLabelFont;
SelectionLabel.SizeY = SettingsManager.Settings.FontSize;
SelectionLabel.Pos = ScreenPos;
SelectionLabel.Text = FinishXY.X - StartXY.X + "x" + Convert.ToString(FinishXY.Y - StartXY.Y);
}
}
GL.LineWidth(3.0F);
var DrawSelection = new clsDrawTileAreaOutline();
DrawSelection.Map = this;
DrawSelection.StartXY = StartXY;
DrawSelection.FinishXY = FinishXY;
DrawSelection.Colour = new sRGBA_sng(1.0F, 1.0F, 1.0F, 1.0F);
DrawSelection.ActionPerform();
}
DebugGLError("Terrain selection box");
}
if ( modTools.Tool == modTools.Tools.TerrainSelect )
{
if ( MouseOverTerrain != null )
{
//draw mouseover vertex
GL.LineWidth(3.0F);
Vertex0.X = MouseOverTerrain.Vertex.Normal.X * Constants.TerrainGridSpacing;
Vertex0.Y = Convert.ToDouble(Terrain.Vertices[MouseOverTerrain.Vertex.Normal.X, MouseOverTerrain.Vertex.Normal.Y].Height * HeightMultiplier);
Vertex0.Z = - MouseOverTerrain.Vertex.Normal.Y * Constants.TerrainGridSpacing;
GL.Begin(BeginMode.Lines);
GL.Color3(1.0F, 1.0F, 1.0F);
GL.Vertex3(Vertex0.X - 8.0D, Vertex0.Y, Convert.ToDouble(- Vertex0.Z));
GL.Vertex3(Vertex0.X + 8.0D, Vertex0.Y, Convert.ToDouble(- Vertex0.Z));
GL.Vertex3(Vertex0.X, Vertex0.Y, - Vertex0.Z - 8.0D);
GL.Vertex3(Vertex0.X, Vertex0.Y, - Vertex0.Z + 8.0D);
GL.End();
}
DebugGLError("Terrain selection vertex");
}
var Gateway = default(clsGateway);
if ( App.Draw_Gateways )
{
GL.LineWidth(2.0F);
foreach ( var tempLoopVar_Gateway in Gateways )
{
Gateway = tempLoopVar_Gateway;
if ( Gateway.PosA.X == Gateway.PosB.X )
{
if ( Gateway.PosA.Y <= Gateway.PosB.Y )
{
C = Gateway.PosA.Y;
D = Gateway.PosB.Y;
}
else
{
C = Gateway.PosB.Y;
D = Gateway.PosA.Y;
}
X2 = Gateway.PosA.X;
for ( Y2 = C; Y2 <= D; Y2++ )
{
Vertex0.X = X2 * Constants.TerrainGridSpacing;
Vertex0.Y = Convert.ToDouble(Terrain.Vertices[X2, Y2].Height * HeightMultiplier);
Vertex0.Z = - Y2 * Constants.TerrainGridSpacing;
Vertex1.X = (X2 + 1) * Constants.TerrainGridSpacing;
Vertex1.Y = Convert.ToDouble(Terrain.Vertices[X2 + 1, Y2].Height * HeightMultiplier);
Vertex1.Z = - Y2 * Constants.TerrainGridSpacing;
Vertex2.X = X2 * Constants.TerrainGridSpacing;
Vertex2.Y = Convert.ToDouble(Terrain.Vertices[X2, Y2 + 1].Height * HeightMultiplier);
Vertex2.Z = - (Y2 + 1) * Constants.TerrainGridSpacing;
Vertex3.X = (X2 + 1) * Constants.TerrainGridSpacing;
Vertex3.Y = Convert.ToDouble(Terrain.Vertices[X2 + 1, Y2 + 1].Height * HeightMultiplier);
Vertex3.Z = - (Y2 + 1) * Constants.TerrainGridSpacing;
GL.Begin(BeginMode.LineLoop);
GL.Color3(0.75F, 1.0F, 0.0F);
GL.Vertex3(Vertex0.X, Vertex0.Y, Convert.ToDouble(- Vertex0.Z));
GL.Vertex3(Vertex1.X, Vertex1.Y, Convert.ToDouble(- Vertex1.Z));
GL.Vertex3(Vertex3.X, Vertex3.Y, Convert.ToDouble(- Vertex3.Z));
GL.Vertex3(Vertex2.X, Vertex2.Y, Convert.ToDouble(- Vertex2.Z));
GL.End();
}
}
else if ( Gateway.PosA.Y == Gateway.PosB.Y )
{
if ( Gateway.PosA.X <= Gateway.PosB.X )
{
C = Gateway.PosA.X;
D = Gateway.PosB.X;
}
else
{
C = Gateway.PosB.X;
D = Gateway.PosA.X;
}
Y2 = Gateway.PosA.Y;
for ( X2 = C; X2 <= D; X2++ )
{
Vertex0.X = X2 * Constants.TerrainGridSpacing;
Vertex0.Y = Convert.ToDouble(Terrain.Vertices[X2, Y2].Height * HeightMultiplier);
Vertex0.Z = - Y2 * Constants.TerrainGridSpacing;
Vertex1.X = (X2 + 1) * Constants.TerrainGridSpacing;
Vertex1.Y = Convert.ToDouble(Terrain.Vertices[X2 + 1, Y2].Height * HeightMultiplier);
Vertex1.Z = - Y2 * Constants.TerrainGridSpacing;
Vertex2.X = X2 * Constants.TerrainGridSpacing;
Vertex2.Y = Convert.ToDouble(Terrain.Vertices[X2, Y2 + 1].Height * HeightMultiplier);
Vertex2.Z = - (Y2 + 1) * Constants.TerrainGridSpacing;
Vertex3.X = (X2 + 1) * Constants.TerrainGridSpacing;
Vertex3.Y = Convert.ToDouble(Terrain.Vertices[X2 + 1, Y2 + 1].Height * HeightMultiplier);
Vertex3.Z = - (Y2 + 1) * Constants.TerrainGridSpacing;
GL.Begin(BeginMode.LineLoop);
GL.Color3(0.75F, 1.0F, 0.0F);
GL.Vertex3(Vertex0.X, Vertex0.Y, Convert.ToDouble(- Vertex0.Z));
GL.Vertex3(Vertex1.X, Vertex1.Y, Convert.ToDouble(- Vertex1.Z));
GL.Vertex3(Vertex3.X, Vertex3.Y, Convert.ToDouble(- Vertex3.Z));
GL.Vertex3(Vertex2.X, Vertex2.Y, Convert.ToDouble(- Vertex2.Z));
GL.End();
}
}
else
{
//draw invalid gateways as red tile borders
X2 = Gateway.PosA.X;
Y2 = Gateway.PosA.Y;
Vertex0.X = X2 * Constants.TerrainGridSpacing;
Vertex0.Y = Convert.ToDouble(Terrain.Vertices[X2, Y2].Height * HeightMultiplier);
Vertex0.Z = - Y2 * Constants.TerrainGridSpacing;
Vertex1.X = (X2 + 1) * Constants.TerrainGridSpacing;
Vertex1.Y = Convert.ToDouble(Terrain.Vertices[X2 + 1, Y2].Height * HeightMultiplier);
Vertex1.Z = - Y2 * Constants.TerrainGridSpacing;
Vertex2.X = X2 * Constants.TerrainGridSpacing;
Vertex2.Y = Convert.ToDouble(Terrain.Vertices[X2, Y2 + 1].Height * HeightMultiplier);
Vertex2.Z = - (Y2 + 1) * Constants.TerrainGridSpacing;
Vertex3.X = (X2 + 1) * Constants.TerrainGridSpacing;
Vertex3.Y = Convert.ToDouble(Terrain.Vertices[X2 + 1, Y2 + 1].Height * HeightMultiplier);
Vertex3.Z = - (Y2 + 1) * Constants.TerrainGridSpacing;
GL.Begin(BeginMode.LineLoop);
GL.Color3(1.0F, 0.0F, 0.0F);
GL.Vertex3(Vertex0.X, Vertex0.Y, Convert.ToDouble(- Vertex0.Z));
GL.Vertex3(Vertex1.X, Vertex1.Y, Convert.ToDouble(- Vertex1.Z));
GL.Vertex3(Vertex3.X, Vertex3.Y, Convert.ToDouble(- Vertex3.Z));
GL.Vertex3(Vertex2.X, Vertex2.Y, Convert.ToDouble(- Vertex2.Z));
GL.End();
X2 = Gateway.PosB.X;
Y2 = Gateway.PosB.Y;
Vertex0.X = X2 * Constants.TerrainGridSpacing;
Vertex0.Y = Convert.ToDouble(Terrain.Vertices[X2, Y2].Height * HeightMultiplier);
Vertex0.Z = - Y2 * Constants.TerrainGridSpacing;
Vertex1.X = (X2 + 1) * Constants.TerrainGridSpacing;
Vertex1.Y = Convert.ToDouble(Terrain.Vertices[X2 + 1, Y2].Height * HeightMultiplier);
Vertex1.Z = - Y2 * Constants.TerrainGridSpacing;
Vertex2.X = X2 * Constants.TerrainGridSpacing;
Vertex2.Y = Convert.ToDouble(Terrain.Vertices[X2, Y2 + 1].Height * HeightMultiplier);
Vertex2.Z = - (Y2 + 1) * Constants.TerrainGridSpacing;
Vertex3.X = (X2 + 1) * Constants.TerrainGridSpacing;
Vertex3.Y = Convert.ToDouble(Terrain.Vertices[X2 + 1, Y2 + 1].Height * HeightMultiplier);
Vertex3.Z = - (Y2 + 1) * Constants.TerrainGridSpacing;
GL.Begin(BeginMode.LineLoop);
GL.Color3(1.0F, 0.0F, 0.0F);
GL.Vertex3(Vertex0.X, Vertex0.Y, Convert.ToDouble(- Vertex0.Z));
GL.Vertex3(Vertex1.X, Vertex1.Y, Convert.ToDouble(- Vertex1.Z));
GL.Vertex3(Vertex3.X, Vertex3.Y, Convert.ToDouble(- Vertex3.Z));
GL.Vertex3(Vertex2.X, Vertex2.Y, Convert.ToDouble(- Vertex2.Z));
GL.End();
}
}
DebugGLError("Gateways");
}
if ( MouseOverTerrain != null )
{
if ( modTools.Tool == modTools.Tools.ObjectSelect )
{
if ( Unit_Selected_Area_VertexA != null )
{
//selection is changing under pointer
MathUtil.ReorderXY(Unit_Selected_Area_VertexA, MouseOverTerrain.Vertex.Normal, ref StartXY, ref FinishXY);
GL.LineWidth(2.0F);
GL.Color3(0.0F, 1.0F, 1.0F);
for ( X = StartXY.X; X <= FinishXY.X - 1; X++ )
{
Vertex0.X = X * Constants.TerrainGridSpacing;
Vertex0.Y = Convert.ToDouble(Terrain.Vertices[X, StartXY.Y].Height * HeightMultiplier);
Vertex0.Z = - StartXY.Y * Constants.TerrainGridSpacing;
Vertex1.X = (X + 1) * Constants.TerrainGridSpacing;
Vertex1.Y = Convert.ToDouble(Terrain.Vertices[X + 1, StartXY.Y].Height * HeightMultiplier);
Vertex1.Z = - StartXY.Y * Constants.TerrainGridSpacing;
GL.Begin(BeginMode.Lines);
GL.Vertex3(Vertex0.X, Vertex0.Y, Convert.ToDouble(- Vertex0.Z));
GL.Vertex3(Vertex1.X, Vertex1.Y, Convert.ToDouble(- Vertex1.Z));
GL.End();
}
for ( X = StartXY.X; X <= FinishXY.X - 1; X++ )
{
Vertex0.X = X * Constants.TerrainGridSpacing;
Vertex0.Y = Convert.ToDouble(Terrain.Vertices[X, FinishXY.Y].Height * HeightMultiplier);
Vertex0.Z = - FinishXY.Y * Constants.TerrainGridSpacing;
Vertex1.X = (X + 1) * Constants.TerrainGridSpacing;
Vertex1.Y = Convert.ToDouble(Terrain.Vertices[X + 1, FinishXY.Y].Height * HeightMultiplier);
Vertex1.Z = - FinishXY.Y * Constants.TerrainGridSpacing;
GL.Begin(BeginMode.Lines);
GL.Vertex3(Vertex0.X, Vertex0.Y, Convert.ToDouble(- Vertex0.Z));
GL.Vertex3(Vertex1.X, Vertex1.Y, Convert.ToDouble(- Vertex1.Z));
GL.End();
}
for ( Y = StartXY.Y; Y <= FinishXY.Y - 1; Y++ )
{
Vertex0.X = StartXY.X * Constants.TerrainGridSpacing;
Vertex0.Y = Convert.ToDouble(Terrain.Vertices[StartXY.X, Y].Height * HeightMultiplier);
Vertex0.Z = - Y * Constants.TerrainGridSpacing;
Vertex1.X = StartXY.X * Constants.TerrainGridSpacing;
Vertex1.Y = Convert.ToDouble(Terrain.Vertices[StartXY.X, Y + 1].Height * HeightMultiplier);
Vertex1.Z = - (Y + 1) * Constants.TerrainGridSpacing;
GL.Begin(BeginMode.Lines);
GL.Vertex3(Vertex0.X, Vertex0.Y, Convert.ToDouble(- Vertex0.Z));
GL.Vertex3(Vertex1.X, Vertex1.Y, Convert.ToDouble(- Vertex1.Z));
GL.End();
}
for ( Y = StartXY.Y; Y <= FinishXY.Y - 1; Y++ )
{
Vertex0.X = FinishXY.X * Constants.TerrainGridSpacing;
Vertex0.Y = Convert.ToDouble(Terrain.Vertices[FinishXY.X, Y].Height * HeightMultiplier);
Vertex0.Z = - Y * Constants.TerrainGridSpacing;
Vertex1.X = FinishXY.X * Constants.TerrainGridSpacing;
Vertex1.Y = Convert.ToDouble(Terrain.Vertices[FinishXY.X, Y + 1].Height * HeightMultiplier);
Vertex1.Z = - (Y + 1) * Constants.TerrainGridSpacing;
GL.Begin(BeginMode.Lines);
GL.Vertex3(Vertex0.X, Vertex0.Y, Convert.ToDouble(- Vertex0.Z));
GL.Vertex3(Vertex1.X, Vertex1.Y, Convert.ToDouble(- Vertex1.Z));
GL.End();
}
DebugGLError("Object selection box");
}
else
{
GL.LineWidth(2.0F);
GL.Color3(0.0F, 1.0F, 1.0F);
GL.Begin(BeginMode.Lines);
GL.Vertex3(MouseOverTerrain.Pos.Horizontal.X - 16.0D, MouseOverTerrain.Pos.Altitude, MouseOverTerrain.Pos.Horizontal.Y - 16.0D);
GL.Vertex3(MouseOverTerrain.Pos.Horizontal.X + 16.0D, MouseOverTerrain.Pos.Altitude, MouseOverTerrain.Pos.Horizontal.Y + 16.0D);
GL.Vertex3(MouseOverTerrain.Pos.Horizontal.X + 16.0D, MouseOverTerrain.Pos.Altitude, MouseOverTerrain.Pos.Horizontal.Y - 16.0D);
GL.Vertex3(MouseOverTerrain.Pos.Horizontal.X - 16.0D, MouseOverTerrain.Pos.Altitude, MouseOverTerrain.Pos.Horizontal.Y + 16.0D);
GL.End();
DebugGLError("Mouse over position");
}
}
if ( modTools.Tool == modTools.Tools.RoadPlace )
{
GL.LineWidth(2.0F);
if ( MouseOverTerrain.Side_IsV )
{
Vertex0.X = MouseOverTerrain.Side_Num.X * Constants.TerrainGridSpacing;
Vertex0.Y = Convert.ToDouble(Terrain.Vertices[MouseOverTerrain.Side_Num.X, MouseOverTerrain.Side_Num.Y].Height * HeightMultiplier);
Vertex0.Z = - MouseOverTerrain.Side_Num.Y * Constants.TerrainGridSpacing;
Vertex1.X = MouseOverTerrain.Side_Num.X * Constants.TerrainGridSpacing;
Vertex1.Y = Convert.ToDouble(Terrain.Vertices[MouseOverTerrain.Side_Num.X, MouseOverTerrain.Side_Num.Y + 1].Height * HeightMultiplier);
Vertex1.Z = - (MouseOverTerrain.Side_Num.Y + 1) * Constants.TerrainGridSpacing;
}
else
{
Vertex0.X = MouseOverTerrain.Side_Num.X * Constants.TerrainGridSpacing;
Vertex0.Y = Convert.ToDouble(Terrain.Vertices[MouseOverTerrain.Side_Num.X, MouseOverTerrain.Side_Num.Y].Height * HeightMultiplier);
Vertex0.Z = - MouseOverTerrain.Side_Num.Y * Constants.TerrainGridSpacing;
Vertex1.X = (MouseOverTerrain.Side_Num.X + 1) * Constants.TerrainGridSpacing;
Vertex1.Y = Convert.ToDouble(Terrain.Vertices[MouseOverTerrain.Side_Num.X + 1, MouseOverTerrain.Side_Num.Y].Height * HeightMultiplier);
Vertex1.Z = - MouseOverTerrain.Side_Num.Y * Constants.TerrainGridSpacing;
}
GL.Begin(BeginMode.Lines);
GL.Color3(0.0F, 1.0F, 1.0F);
GL.Vertex3(Vertex0.X, Vertex0.Y, Convert.ToDouble(- Vertex0.Z));
GL.Vertex3(Vertex1.X, Vertex1.Y, Convert.ToDouble(- Vertex1.Z));
GL.End();
DebugGLError("Road place brush");
}
else if ( modTools.Tool == modTools.Tools.RoadLines || modTools.Tool == modTools.Tools.Gateways || modTools.Tool == modTools.Tools.ObjectLines )
{
GL.LineWidth(2.0F);
if ( Selected_Tile_A != null )
{
X2 = Selected_Tile_A.X;
Y2 = Selected_Tile_A.Y;
Vertex0.X = X2 * Constants.TerrainGridSpacing;
Vertex0.Y = Convert.ToDouble(Terrain.Vertices[X2, Y2].Height * HeightMultiplier);
Vertex0.Z = - Y2 * Constants.TerrainGridSpacing;
Vertex1.X = (X2 + 1) * Constants.TerrainGridSpacing;
Vertex1.Y = Convert.ToDouble(Terrain.Vertices[X2 + 1, Y2].Height * HeightMultiplier);
Vertex1.Z = - Y2 * Constants.TerrainGridSpacing;
Vertex2.X = X2 * Constants.TerrainGridSpacing;
Vertex2.Y = Convert.ToDouble(Terrain.Vertices[X2, Y2 + 1].Height * HeightMultiplier);
Vertex2.Z = - (Y2 + 1) * Constants.TerrainGridSpacing;
Vertex3.X = (X2 + 1) * Constants.TerrainGridSpacing;
Vertex3.Y = Convert.ToDouble(Terrain.Vertices[X2 + 1, Y2 + 1].Height * HeightMultiplier);
Vertex3.Z = - (Y2 + 1) * Constants.TerrainGridSpacing;
GL.Begin(BeginMode.LineLoop);
GL.Color3(0.0F, 1.0F, 1.0F);
GL.Vertex3(Vertex0.X, Vertex0.Y, Convert.ToDouble(- Vertex0.Z));
GL.Vertex3(Vertex1.X, Vertex1.Y, Convert.ToDouble(- Vertex1.Z));
GL.Vertex3(Vertex3.X, Vertex3.Y, Convert.ToDouble(- Vertex3.Z));
GL.Vertex3(Vertex2.X, Vertex2.Y, Convert.ToDouble(- Vertex2.Z));
GL.End();
if ( MouseOverTerrain.Tile.Normal.X == Selected_Tile_A.X )
{
if ( MouseOverTerrain.Tile.Normal.Y <= Selected_Tile_A.Y )
{
A = MouseOverTerrain.Tile.Normal.Y;
B = Selected_Tile_A.Y;
}
else
{
A = Selected_Tile_A.Y;
B = MouseOverTerrain.Tile.Normal.Y;
}
X2 = Selected_Tile_A.X;
for ( Y2 = A; Y2 <= B; Y2++ )
{
Vertex0.X = X2 * Constants.TerrainGridSpacing;
Vertex0.Y = Convert.ToDouble(Terrain.Vertices[X2, Y2].Height * HeightMultiplier);
Vertex0.Z = - Y2 * Constants.TerrainGridSpacing;
Vertex1.X = (X2 + 1) * Constants.TerrainGridSpacing;
Vertex1.Y = Convert.ToDouble(Terrain.Vertices[X2 + 1, Y2].Height * HeightMultiplier);
Vertex1.Z = - Y2 * Constants.TerrainGridSpacing;
Vertex2.X = X2 * Constants.TerrainGridSpacing;
Vertex2.Y = Convert.ToDouble(Terrain.Vertices[X2, Y2 + 1].Height * HeightMultiplier);
Vertex2.Z = - (Y2 + 1) * Constants.TerrainGridSpacing;
Vertex3.X = (X2 + 1) * Constants.TerrainGridSpacing;
Vertex3.Y = Convert.ToDouble(Terrain.Vertices[X2 + 1, Y2 + 1].Height * HeightMultiplier);
Vertex3.Z = - (Y2 + 1) * Constants.TerrainGridSpacing;
GL.Begin(BeginMode.LineLoop);
GL.Color3(0.0F, 1.0F, 1.0F);
GL.Vertex3(Vertex0.X, Vertex0.Y, Convert.ToDouble(- Vertex0.Z));
GL.Vertex3(Vertex1.X, Vertex1.Y, Convert.ToDouble(- Vertex1.Z));
GL.Vertex3(Vertex3.X, Vertex3.Y, Convert.ToDouble(- Vertex3.Z));
GL.Vertex3(Vertex2.X, Vertex2.Y, Convert.ToDouble(- Vertex2.Z));
GL.End();
}
}
else if ( MouseOverTerrain.Tile.Normal.Y == Selected_Tile_A.Y )
{
if ( MouseOverTerrain.Tile.Normal.X <= Selected_Tile_A.X )
{
A = MouseOverTerrain.Tile.Normal.X;
B = Selected_Tile_A.X;
}
else
{
A = Selected_Tile_A.X;
B = MouseOverTerrain.Tile.Normal.X;
}
Y2 = Selected_Tile_A.Y;
for ( X2 = A; X2 <= B; X2++ )
{
Vertex0.X = X2 * Constants.TerrainGridSpacing;
Vertex0.Y = Convert.ToDouble(Terrain.Vertices[X2, Y2].Height * HeightMultiplier);
Vertex0.Z = - Y2 * Constants.TerrainGridSpacing;
Vertex1.X = (X2 + 1) * Constants.TerrainGridSpacing;
Vertex1.Y = Convert.ToDouble(Terrain.Vertices[X2 + 1, Y2].Height * HeightMultiplier);
Vertex1.Z = - Y2 * Constants.TerrainGridSpacing;
Vertex2.X = X2 * Constants.TerrainGridSpacing;
Vertex2.Y = Convert.ToDouble(Terrain.Vertices[X2, Y2 + 1].Height * HeightMultiplier);
Vertex2.Z = - (Y2 + 1) * Constants.TerrainGridSpacing;
Vertex3.X = (X2 + 1) * Constants.TerrainGridSpacing;
Vertex3.Y = Convert.ToDouble(Terrain.Vertices[X2 + 1, Y2 + 1].Height * HeightMultiplier);
Vertex3.Z = - (Y2 + 1) * Constants.TerrainGridSpacing;
GL.Begin(BeginMode.LineLoop);
GL.Color3(0.0F, 1.0F, 1.0F);
GL.Vertex3(Vertex0.X, Vertex0.Y, Convert.ToDouble(- Vertex0.Z));
GL.Vertex3(Vertex1.X, Vertex1.Y, Convert.ToDouble(- Vertex1.Z));
GL.Vertex3(Vertex3.X, Vertex3.Y, Convert.ToDouble(- Vertex3.Z));
GL.Vertex3(Vertex2.X, Vertex2.Y, Convert.ToDouble(- Vertex2.Z));
GL.End();
}
}
}
else
{
X2 = MouseOverTerrain.Tile.Normal.X;
Y2 = MouseOverTerrain.Tile.Normal.Y;
Vertex0.X = X2 * Constants.TerrainGridSpacing;
Vertex0.Y = Convert.ToDouble(Terrain.Vertices[X2, Y2].Height * HeightMultiplier);
Vertex0.Z = - Y2 * Constants.TerrainGridSpacing;
Vertex1.X = (X2 + 1) * Constants.TerrainGridSpacing;
Vertex1.Y = Convert.ToDouble(Terrain.Vertices[X2 + 1, Y2].Height * HeightMultiplier);
Vertex1.Z = - Y2 * Constants.TerrainGridSpacing;
Vertex2.X = X2 * Constants.TerrainGridSpacing;
Vertex2.Y = Convert.ToDouble(Terrain.Vertices[X2, Y2 + 1].Height * HeightMultiplier);
Vertex2.Z = - (Y2 + 1) * Constants.TerrainGridSpacing;
Vertex3.X = (X2 + 1) * Constants.TerrainGridSpacing;
Vertex3.Y = Convert.ToDouble(Terrain.Vertices[X2 + 1, Y2 + 1].Height * HeightMultiplier);
Vertex3.Z = - (Y2 + 1) * Constants.TerrainGridSpacing;
GL.Begin(BeginMode.LineLoop);
GL.Color3(0.0F, 1.0F, 1.0F);
GL.Vertex3(Vertex0.X, Vertex0.Y, Convert.ToDouble(- Vertex0.Z));
GL.Vertex3(Vertex1.X, Vertex1.Y, Convert.ToDouble(- Vertex1.Z));
GL.Vertex3(Vertex3.X, Vertex3.Y, Convert.ToDouble(- Vertex3.Z));
GL.Vertex3(Vertex2.X, Vertex2.Y, Convert.ToDouble(- Vertex2.Z));
GL.End();
}
DebugGLError("Line brush");
}
//draw mouseover tiles
var ToolBrush = default(clsBrush);
if ( modTools.Tool == modTools.Tools.TextureBrush )
{
ToolBrush = App.TextureBrush;
}
else if ( modTools.Tool == modTools.Tools.CliffBrush )
{
ToolBrush = App.CliffBrush;
}
else if ( modTools.Tool == modTools.Tools.CliffRemove )
{
ToolBrush = App.CliffBrush;
}
else if ( modTools.Tool == modTools.Tools.RoadRemove )
{
ToolBrush = App.CliffBrush;
}
else
{
ToolBrush = null;
}
if ( ToolBrush != null )
{
GL.LineWidth(2.0F);
var DrawTileOutline = new clsDrawTileOutline();
DrawTileOutline.Map = this;
DrawTileOutline.Colour.Red = 0.0F;
DrawTileOutline.Colour.Green = 1.0F;
DrawTileOutline.Colour.Blue = 1.0F;
DrawTileOutline.Colour.Alpha = 1.0F;
ToolBrush.PerformActionMapTiles(DrawTileOutline, MouseOverTerrain.Tile);
DebugGLError("Brush tiles");
}
//draw mouseover vertex
if ( modTools.Tool == modTools.Tools.TerrainFill )
{
GL.LineWidth(2.0F);
Vertex0.X = MouseOverTerrain.Vertex.Normal.X * Constants.TerrainGridSpacing;
Vertex0.Y = Convert.ToDouble(Terrain.Vertices[MouseOverTerrain.Vertex.Normal.X, MouseOverTerrain.Vertex.Normal.Y].Height * HeightMultiplier);
Vertex0.Z = - MouseOverTerrain.Vertex.Normal.Y * Constants.TerrainGridSpacing;
GL.Begin(BeginMode.Lines);
GL.Color3(0.0F, 1.0F, 1.0F);
GL.Vertex3(Vertex0.X - 8.0D, Vertex0.Y, Convert.ToDouble(- Vertex0.Z));
GL.Vertex3(Vertex0.X + 8.0D, Vertex0.Y, Convert.ToDouble(- Vertex0.Z));
GL.Vertex3(Vertex0.X, Vertex0.Y, Convert.ToDouble(- Vertex0.Z - 8.0D));
GL.Vertex3(Vertex0.X, Vertex0.Y, - Vertex0.Z + 8.0D);
GL.End();
DebugGLError("Mouse over vertex");
}
if ( modTools.Tool == modTools.Tools.TerrainBrush )
{
ToolBrush = App.TerrainBrush;
}
else if ( modTools.Tool == modTools.Tools.HeightSetBrush )
{
ToolBrush = App.HeightBrush;
}
else if ( modTools.Tool == modTools.Tools.HeightChangeBrush )
{
ToolBrush = App.HeightBrush;
}
else if ( modTools.Tool == modTools.Tools.HeightSmoothBrush )
{
ToolBrush = App.HeightBrush;
}
else
{
ToolBrush = null;
}
if ( ToolBrush != null )
{
GL.LineWidth(2.0F);
var DrawVertexMarker = new clsDrawVertexMarker();
DrawVertexMarker.Map = this;
DrawVertexMarker.Colour.Red = 0.0F;
DrawVertexMarker.Colour.Green = 1.0F;
DrawVertexMarker.Colour.Blue = 1.0F;
DrawVertexMarker.Colour.Alpha = 1.0F;
ToolBrush.PerformActionMapVertices(DrawVertexMarker, MouseOverTerrain.Vertex);
DebugGLError("Brush vertices");
}
}
GL.Enable(EnableCap.DepthTest);
GL.Disable(EnableCap.CullFace);
GL.LoadIdentity();
GL.Rotate((float)(ViewInfo.ViewAngleRPY.Roll / MathUtil.RadOf1Deg), 0.0F, 0.0F, -1.0F);
GL.Rotate((float)(ViewInfo.ViewAngleRPY.Pitch / MathUtil.RadOf1Deg), 1.0F, 0.0F, 0.0F);
GL.Rotate((float)(ViewInfo.ViewAngleRPY.Yaw / MathUtil.RadOf1Deg), 0.0F, 1.0F, 0.0F);
GL.Enable(EnableCap.Blend);
GL.BlendFunc(BlendingFactorSrc.SrcAlpha, BlendingFactorDest.OneMinusSrcAlpha);
DebugGLError("Object matrix modes");
if ( App.Draw_Units )
{
GL.Color3(1.0F, 1.0F, 1.0F);
GL.Enable(EnableCap.Texture2D);
App.VisionSectors.PerformActionMapSectors(DrawObjects, DrawCentreSector);
GL.Disable(EnableCap.Texture2D);
DebugGLError("Objects");
}
if ( MouseOverTerrain != null )
{
GL.Enable(EnableCap.Texture2D);
if ( modTools.Tool == modTools.Tools.ObjectPlace )
{
var placeObject = Program.frmMainInstance.SingleSelectedObjectTypeBase;
if ( placeObject != null )
{
var Rotation = 0;
try
{
IOUtil.InvariantParse(Program.frmMainInstance.txtNewObjectRotation.Text, ref Rotation);
if ( Rotation < 0 | Rotation > 359 )
{
Rotation = 0;
}
}
catch
{
Rotation = 0;
}
WorldPos = TileAlignedPosFromMapPos(MouseOverTerrain.Pos.Horizontal, placeObject.get_GetFootprintSelected(Rotation));
GL.PushMatrix();
GL.Translate(WorldPos.Horizontal.X - ViewInfo.ViewPos.X, WorldPos.Altitude - ViewInfo.ViewPos.Y + 2.0D,
ViewInfo.ViewPos.Z + WorldPos.Horizontal.Y);
placeObject.GLDraw(Rotation);
GL.PopMatrix();
}
}
GL.Disable(EnableCap.Texture2D);
DebugGLError("Mouse over object");
}
GL.Disable(EnableCap.DepthTest);
var ScriptMarkerTextLabels = new clsTextLabels(256);
var TextLabel = default(clsTextLabel);
if ( App.Draw_ScriptMarkers )
{
var ScriptPosition = default(clsScriptPosition);
var ScriptArea = default(clsScriptArea);
GL.PushMatrix();
GL.Translate(Convert.ToDouble(- ViewInfo.ViewPos.X), Convert.ToDouble(- ViewInfo.ViewPos.Y), ViewInfo.ViewPos.Z);
foreach ( var tempLoopVar_ScriptPosition in ScriptPositions )
{
ScriptPosition = tempLoopVar_ScriptPosition;
ScriptPosition.GLDraw();
}
foreach ( var tempLoopVar_ScriptArea in ScriptAreas )
{
ScriptArea = tempLoopVar_ScriptArea;
ScriptArea.GLDraw();
}
foreach ( var tempLoopVar_ScriptPosition in ScriptPositions )
{
ScriptPosition = tempLoopVar_ScriptPosition;
if ( ScriptMarkerTextLabels.AtMaxCount() )
{
break;
}
XYZ_dbl.X = ScriptPosition.PosX - ViewInfo.ViewPos.X;
XYZ_dbl.Z = - ScriptPosition.PosY - ViewInfo.ViewPos.Z;
XYZ_dbl.Y = GetTerrainHeight(new XYInt(ScriptPosition.PosX, ScriptPosition.PosY)) - ViewInfo.ViewPos.Y;
Matrix3DMath.VectorRotationByMatrix(ViewInfo.ViewAngleMatrix_Inverted, XYZ_dbl, ref XYZ_dbl2);
if ( ViewInfo.Pos_Get_Screen_XY(XYZ_dbl2, ref ScreenPos) )
{
if ( ScreenPos.X >= 0 & ScreenPos.X <= GLSize.X & ScreenPos.Y >= 0 & ScreenPos.Y <= GLSize.Y )
{
TextLabel = new clsTextLabel();
TextLabel.Colour.Red = 1.0F;
TextLabel.Colour.Green = 1.0F;
TextLabel.Colour.Blue = 0.5F;
TextLabel.Colour.Alpha = 0.75F;
TextLabel.TextFont = App.UnitLabelFont;
TextLabel.SizeY = SettingsManager.Settings.FontSize;
TextLabel.Pos = ScreenPos;
TextLabel.Text = ScriptPosition.Label;
ScriptMarkerTextLabels.Add(TextLabel);
}
}
}
DebugGLError("Script positions");
foreach ( var tempLoopVar_ScriptArea in ScriptAreas )
{
ScriptArea = tempLoopVar_ScriptArea;
if ( ScriptMarkerTextLabels.AtMaxCount() )
{
break;
}
XYZ_dbl.X = ScriptArea.PosAX - ViewInfo.ViewPos.X;
XYZ_dbl.Z = - ScriptArea.PosAY - ViewInfo.ViewPos.Z;
XYZ_dbl.Y = GetTerrainHeight(new XYInt(ScriptArea.PosAX, ScriptArea.PosAY)) - ViewInfo.ViewPos.Y;
Matrix3DMath.VectorRotationByMatrix(ViewInfo.ViewAngleMatrix_Inverted, XYZ_dbl, ref XYZ_dbl2);
if ( ViewInfo.Pos_Get_Screen_XY(XYZ_dbl2, ref ScreenPos) )
{
if ( ScreenPos.X >= 0 & ScreenPos.X <= GLSize.X & ScreenPos.Y >= 0 & ScreenPos.Y <= GLSize.Y )
{
TextLabel = new clsTextLabel();
TextLabel.Colour.Red = 1.0F;
TextLabel.Colour.Green = 1.0F;
TextLabel.Colour.Blue = 0.5F;
TextLabel.Colour.Alpha = 0.75F;
TextLabel.TextFont = App.UnitLabelFont;
TextLabel.SizeY = SettingsManager.Settings.FontSize;
TextLabel.Pos = ScreenPos;
TextLabel.Text = ScriptArea.Label;
ScriptMarkerTextLabels.Add(TextLabel);
}
}
}
GL.PopMatrix();
DebugGLError("Script areas");
}
var MessageTextLabels = new clsTextLabels(24);
B = 0;
for ( A = Math.Max(Messages.Count - MessageTextLabels.MaxCount, 0); A <= Messages.Count - 1; A++ )
{
if ( !MessageTextLabels.AtMaxCount() )
{
TextLabel = new clsTextLabel();
TextLabel.Colour.Red = 0.875F;
TextLabel.Colour.Green = 0.875F;
TextLabel.Colour.Blue = 1.0F;
TextLabel.Colour.Alpha = 1.0F;
TextLabel.TextFont = App.UnitLabelFont;
TextLabel.SizeY = SettingsManager.Settings.FontSize;
TextLabel.Pos.X = 32 + MinimapSizeXY.X;
TextLabel.Pos.Y = 32 + (int)(Math.Ceiling((decimal)(B * TextLabel.SizeY)));
TextLabel.Text = Convert.ToString(Messages[A].Text);
MessageTextLabels.Add(TextLabel);
B++;
}
}
//draw unit selection
GL.Begin(BeginMode.Quads);
foreach ( var tempLoopVar_Unit in SelectedUnits )
{
Unit = tempLoopVar_Unit;
RGB_sng = GetUnitGroupColour(Unit.UnitGroup);
ColourA = new sRGBA_sng((1.0F + RGB_sng.Red) / 2.0F, (1.0F + RGB_sng.Green) / 2.0F, (1.0F + RGB_sng.Blue) / 2.0F, 0.75F);
ColourB = new sRGBA_sng(RGB_sng.Red, RGB_sng.Green, RGB_sng.Blue, 0.75F);
DrawUnitRectangle(Unit, 8, ColourA, ColourB);
}
if ( MouseOverTerrain != null )
{
foreach ( var tempLoopVar_Unit in MouseOverTerrain.Units )
{
Unit = tempLoopVar_Unit;
if ( Unit != null && modTools.Tool == modTools.Tools.ObjectSelect )
{
RGB_sng = GetUnitGroupColour(Unit.UnitGroup);
GL.Color4((0.5F + RGB_sng.Red) / 1.5F, (0.5F + RGB_sng.Green) / 1.5F, (0.5F + RGB_sng.Blue) / 1.5F, 0.75F);
ColourA = new sRGBA_sng((1.0F + RGB_sng.Red) / 2.0F, (1.0F + RGB_sng.Green) / 2.0F, (1.0F + RGB_sng.Blue) / 2.0F, 0.75F);
ColourB = new sRGBA_sng(RGB_sng.Red, RGB_sng.Green, RGB_sng.Blue, 0.875F);
DrawUnitRectangle(Unit, 16, ColourA, ColourB);
}
}
}
GL.End();
DebugGLError("Unit selection");
GL.MatrixMode(MatrixMode.Projection);
var temp_mat2 = Matrix4.CreateOrthographicOffCenter(0.0F, GLSize.X, GLSize.Y, 0.0F, -1.0F, 1.0F);
GL.LoadMatrix(ref temp_mat2);
GL.MatrixMode(MatrixMode.Modelview);
GL.LoadIdentity();
DebugGLError("Text label matrix modes");
GL.Enable(EnableCap.Texture2D);
ScriptMarkerTextLabels.Draw();
DrawObjects.UnitTextLabels.Draw();
SelectionLabel.Draw();
MessageTextLabels.Draw();
DebugGLError("Text labels");
GL.Disable(EnableCap.Texture2D);
GL.Disable(EnableCap.Blend);
//draw minimap
GL.MatrixMode(MatrixMode.Projection);
var temp_mat3 = Matrix4.CreateOrthographicOffCenter(0.0F, GLSize.X, 0.0F, GLSize.Y, -1.0F, 1.0F);
GL.LoadMatrix(ref temp_mat3);
GL.MatrixMode(MatrixMode.Modelview);
GL.LoadIdentity();
DebugGLError("Minimap matrix modes");
if ( Minimap_Texture_Size > 0 & ViewInfo.Tiles_Per_Minimap_Pixel > 0.0D )
{
GL.Translate(0.0F, GLSize.Y - MinimapSizeXY.Y, 0.0F);
XYZ_dbl.X = (double)Terrain.TileSize.X / Minimap_Texture_Size;
XYZ_dbl.Z = (double)Terrain.TileSize.Y / Minimap_Texture_Size;
if ( Minimap_GLTexture > 0 )
{
GL.Enable(EnableCap.Texture2D);
GL.BindTexture(TextureTarget.Texture2D, Minimap_GLTexture);
GL.TexEnv(TextureEnvTarget.TextureEnv, TextureEnvParameter.TextureEnvMode, (int)TextureEnvMode.Decal);
GL.Begin(BeginMode.Quads);
GL.TexCoord2(0.0F, 0.0F);
GL.Vertex2(0, MinimapSizeXY.Y);
GL.TexCoord2((float)XYZ_dbl.X, 0.0F);
GL.Vertex2(MinimapSizeXY.X, MinimapSizeXY.Y);
GL.TexCoord2((float)XYZ_dbl.X, (float)XYZ_dbl.Z);
GL.Vertex2(MinimapSizeXY.X, 0);
GL.TexCoord2(0.0F, (float)XYZ_dbl.Z);
GL.Vertex2(0, 0);
GL.End();
GL.Disable(EnableCap.Texture2D);
DebugGLError("Minimap");
}
//draw minimap border
GL.LineWidth(1.0F);
GL.Begin(BeginMode.Lines);
GL.Color3(0.75F, 0.75F, 0.75F);
GL.Vertex2(MinimapSizeXY.X, 0.0F);
GL.Vertex2(MinimapSizeXY.X, MinimapSizeXY.Y);
GL.Vertex2(0.0F, 0.0F);
GL.Vertex2(MinimapSizeXY.X, 0.0F);
GL.End();
DebugGLError("Minimap border");
//draw minimap view pos box
if ( ShowMinimapViewPosBox )
{
dblTemp = Constants.TerrainGridSpacing * ViewInfo.Tiles_Per_Minimap_Pixel;
PosA.X = ViewCorner0.X / dblTemp;
PosA.Y = MinimapSizeXY.Y + ViewCorner0.Y / dblTemp;
PosB.X = ViewCorner1.X / dblTemp;
PosB.Y = MinimapSizeXY.Y + ViewCorner1.Y / dblTemp;
PosC.X = ViewCorner2.X / dblTemp;
PosC.Y = MinimapSizeXY.Y + ViewCorner2.Y / dblTemp;
PosD.X = ViewCorner3.X / dblTemp;
PosD.Y = MinimapSizeXY.Y + ViewCorner3.Y / dblTemp;
GL.LineWidth(1.0F);
GL.Begin(BeginMode.LineLoop);
GL.Color3(1.0F, 1.0F, 1.0F);
GL.Vertex2(PosA.X, PosA.Y);
GL.Vertex2(PosB.X, PosB.Y);
GL.Vertex2(PosC.X, PosC.Y);
GL.Vertex2(PosD.X, PosD.Y);
GL.End();
DebugGLError("Minimap view position polygon");
}
if ( Selected_Area_VertexA != null )
{
DrawIt = false;
if ( Selected_Area_VertexB != null )
{
//area is selected
MathUtil.ReorderXY(Selected_Area_VertexA, Selected_Area_VertexB, ref StartXY, ref FinishXY);
DrawIt = true;
}
else if ( modTools.Tool == modTools.Tools.TerrainSelect )
{
if ( MouseOverTerrain != null )
{
//selection is changing under mouse
MathUtil.ReorderXY(Selected_Area_VertexA, MouseOverTerrain.Vertex.Normal, ref StartXY, ref FinishXY);
DrawIt = true;
}
}
if ( DrawIt )
{
GL.LineWidth(1.0F);
PosA.X = StartXY.X / ViewInfo.Tiles_Per_Minimap_Pixel;
PosA.Y = MinimapSizeXY.Y - StartXY.Y / ViewInfo.Tiles_Per_Minimap_Pixel;
PosB.X = FinishXY.X / ViewInfo.Tiles_Per_Minimap_Pixel;
PosB.Y = MinimapSizeXY.Y - StartXY.Y / ViewInfo.Tiles_Per_Minimap_Pixel;
PosC.X = FinishXY.X / ViewInfo.Tiles_Per_Minimap_Pixel;
PosC.Y = MinimapSizeXY.Y - FinishXY.Y / ViewInfo.Tiles_Per_Minimap_Pixel;
PosD.X = StartXY.X / ViewInfo.Tiles_Per_Minimap_Pixel;
PosD.Y = MinimapSizeXY.Y - FinishXY.Y / ViewInfo.Tiles_Per_Minimap_Pixel;
GL.Begin(BeginMode.LineLoop);
GL.Color3(1.0F, 1.0F, 1.0F);
GL.Vertex2(PosA.X, PosA.Y);
GL.Vertex2(PosB.X, PosB.Y);
GL.Vertex2(PosC.X, PosC.Y);
GL.Vertex2(PosD.X, PosD.Y);
GL.End();
DebugGLError("Minimap selection box");
}
}
}
}
