void Update()
{
int _Frame = Mathf.FloorToInt(Time.time * 5.5f);
if (_Frame != CurrentFrame)
{
int _ScreenWidth = Screen.width - GameScreenScaler.VIEWPORT_PADDING_LEFT - GameScreenScaler.VIEWPORT_PADDING_RIGHT;
int _ScreenHeight = Screen.height - GameScreenScaler.VIEWPORT_PADDING_TOP - GameScreenScaler.VIEWPORT_PADDING_BOTTOM;
Vector2Int _MinBounds = new Vector2Int((int)m_Camera.transform.position.x - Mathf.CeilToInt(_ScreenWidth / 64), (int)m_Camera.transform.position.y - Mathf.CeilToInt(_ScreenHeight / 64) - 3);
Vector2Int _MaxBounds = new Vector2Int((int)m_Camera.transform.position.x + Mathf.CeilToInt(_ScreenWidth / 64) + 3, (int)m_Camera.transform.position.y + Mathf.CeilToInt(_ScreenHeight / 64) + 1);
CurrentFrame = _Frame;
for (int i = 0; i < s_Renderers.Count; i++)
{
MapObjectRenderer _Animation = s_Renderers[i];
Vector3 _Position = _Animation.transform.position;
if (_Position.x >= _MinBounds.x &&
_Position.y >= _MinBounds.y &&
_Position.x <= _MaxBounds.x &&
_Position.y <= _MaxBounds.y)
{
_Animation.Animate(_Frame);
}
}
}
}
public override void Render(ViewportBase viewport)
{
// Render
if (_base != null)
{/*
* var faces = _drawing.GetBoxFaces().Select(x =>
* {
* var f = new Face(0) { Plane = new Plane(x[0], x[1], x[2])};
* f.Vertices.AddRange(x.Select(v => new Vertex(v + f.Plane.Normal * 0.1m, f)));
* return f;
* });*
*/
var vp3 = viewport as Viewport3D;
if (vp3 == null)
{
return;
}
GL.Disable(EnableCap.CullFace);
var faces = GetSides().OrderByDescending(x => (vp3.Camera.LookAt.ToCoordinate() - x.BoundingBox.Center).LengthSquared()).ToList();
MapObjectRenderer.DrawFilled(faces, Color.FromArgb(64, Color.DodgerBlue), false, false);
GL.Enable(EnableCap.CullFace);
}
else if (_cloneFace != null)
{
MapObjectRenderer.DrawFilled(new[] { _cloneFace }, Color.FromArgb(64, Color.Orange), false, false);
}
}
protected override void Render2D(Viewport2D viewport)
{
base.Render2D(viewport);
if (ShouldDrawBox(viewport) && _preview != null)
{
GL.Color3(GetRenderColour());
Graphics.Helpers.Matrix.Push();
var matrix = viewport.GetModelViewMatrix();
GL.MultMatrix(ref matrix);
MapObjectRenderer.DrawWireframe(_preview, true, false);
Graphics.Helpers.Matrix.Pop();
}
}
protected override void Render3D(Viewport3D viewport)
{
base.Render3D(viewport);
if (ShouldDraw3DBox() && _preview != null)
{
GL.Disable(EnableCap.CullFace);
TextureHelper.Unbind();
if (viewport.Type != Viewport3D.ViewType.Flat)
{
MapObjectRenderer.EnableLighting();
}
MapObjectRenderer.DrawFilled(_preview, GetRenderColour(), false);
MapObjectRenderer.DisableLighting();
GL.Color4(Color.GreenYellow);
MapObjectRenderer.DrawWireframe(_preview, true, false);
}
}
public GameRenderer(RenderingDevice renderingDevice, IGameViewport viewport)
{
_device = renderingDevice;
_viewport = viewport;
_mapObjectRenderer = new MapObjectRenderer(renderingDevice, Tig.MdfFactory, GameSystems.AAS.Renderer);
_sectorDebugRenderer = new SectorDebugRenderer();
_sectorVisibilityRenderer = new SectorVisibilityRenderer();
MapFogDebugRenderer = new MapFogDebugRenderer(GameSystems.MapFogging, renderingDevice);
_particleSysRenderer = new ParticleSystemsRenderer(
renderingDevice,
Tig.ShapeRenderer2d,
GameSystems.AAS.ModelFactory,
GameSystems.AAS.Renderer,
GameSystems.ParticleSys
);
}
protected override void Render2D(Viewport2D vp)
{
base.Render2D(vp);
if (_currentTool != null)
{
_currentTool.Render2D(vp);
}
// Render out the solid previews
GL.Color3(Color.Pink);
Matrix.Push();
var matrix = vp.GetModelViewMatrix();
GL.MultMatrix(ref matrix);
MapObjectRenderer.DrawWireframe(_copies.Keys.SelectMany(x => x.Faces), true, false);
Matrix.Pop();
// Draw in order by the unused coordinate (the up axis for this viewport)
var ordered = (from point in Points
where (point.IsMidPoint && _showPoints != ShowPoints.Vertices) || (!point.IsMidPoint && _showPoints != ShowPoints.Midpoints)
let unused = vp.GetUnusedCoordinate(point.Coordinate)
orderby point.IsSelected, unused.X + unused.Y + unused.Z
select point).ToList();
// Render out the point handles
var z = (double)vp.Zoom;
GL.Begin(BeginMode.Quads);
foreach (var point in ordered)
{
var c = vp.Flatten(point.Coordinate);
GL.Color3(Color.Black);
GLX.Square(new Vector2d(c.DX, c.DY), 4, z, true);
GL.Color3(point.GetColour());
GLX.Square(new Vector2d(c.DX, c.DY), 3, z, true);
}
GL.End();
}
public static void RemoveObject(MapObjectRenderer a_Renderer)
{
s_Renderers.Remove(a_Renderer);
}
public static void AddObject(MapObjectRenderer a_Renderer)
{
s_Renderers.Add(a_Renderer);
}
protected override void Render3D(Viewport3D vp)
{
base.Render3D(vp);
if (_currentTool != null)
{
_currentTool.Render3D(vp);
}
TextureHelper.Unbind();
if (_currentTool == null || _currentTool.DrawVertices())
{
// Get us into 2D rendering
Matrix.Set(MatrixMode.Projection);
Matrix.Identity();
Graphics.Helpers.Viewport.Orthographic(0, 0, vp.Width, vp.Height);
Matrix.Set(MatrixMode.Modelview);
Matrix.Identity();
var half = new Coordinate(vp.Width, vp.Height, 0) / 2;
// Render out the point handles
GL.Begin(PrimitiveType.Quads);
foreach (var point in Points)
{
if (point.IsMidPoint && _showPoints == ShowPoints.Vertices)
{
continue;
}
if (!point.IsMidPoint && _showPoints == ShowPoints.Midpoints)
{
continue;
}
var c = vp.WorldToScreen(point.Coordinate);
if (c == null || c.Z > 1)
{
continue;
}
c -= half;
GL.Color3(Color.Black);
GL.Vertex2(c.DX - 4, c.DY - 4);
GL.Vertex2(c.DX - 4, c.DY + 4);
GL.Vertex2(c.DX + 4, c.DY + 4);
GL.Vertex2(c.DX + 4, c.DY - 4);
GL.Color3(point.GetColour());
GL.Vertex2(c.DX - 3, c.DY - 3);
GL.Vertex2(c.DX - 3, c.DY + 3);
GL.Vertex2(c.DX + 3, c.DY + 3);
GL.Vertex2(c.DX + 3, c.DY - 3);
}
GL.End();
// Get back into 3D rendering
Matrix.Set(MatrixMode.Projection);
Matrix.Identity();
Graphics.Helpers.Viewport.Perspective(0, 0, vp.Width, vp.Height, View.CameraFOV);
Matrix.Set(MatrixMode.Modelview);
Matrix.Identity();
vp.Camera.Position();
}
var type = vp.Type;
bool shaded = type == Viewport3D.ViewType.Shaded || type == Viewport3D.ViewType.Textured,
textured = type == Viewport3D.ViewType.Textured,
wireframe = type == Viewport3D.ViewType.Wireframe;
// Render out the solid previews
GL.Color3(Color.White);
var faces = _copies.Keys.SelectMany(x => x.Faces).ToList();
if (!wireframe)
{
if (shaded)
{
MapObjectRenderer.EnableLighting();
}
GL.Enable(EnableCap.Texture2D);
MapObjectRenderer.DrawFilled(faces.Where(x => !x.IsSelected), Color.FromArgb(255, 64, 192, 64), textured);
MapObjectRenderer.DrawFilled(faces.Where(x => x.IsSelected), Color.FromArgb(255, 255, 128, 128), textured);
GL.Disable(EnableCap.Texture2D);
MapObjectRenderer.DisableLighting();
GL.Color3(Color.Pink);
MapObjectRenderer.DrawWireframe(faces, true, false);
}
else
{
GL.Color4(Color.FromArgb(255, 64, 192, 64));
MapObjectRenderer.DrawWireframe(faces.Where(x => !x.IsSelected), true, false);
GL.Color4(Color.FromArgb(255, 255, 128, 128));
MapObjectRenderer.DrawWireframe(faces.Where(x => x.IsSelected), true, false);
}
}
private void UpdateCache()
{
if (!_update)
{
return;
}
UpdateModels();
var all = GetAllVisible(Document.Map.WorldSpawn);
var cache = CollectFaces(all);
var unselected = cache.Where(x => !x.IsSelected && (x.Parent == null || !x.Parent.IsSelected) && x.Opacity > 0.1).ToList();
var selected = cache.Where(x => (x.IsSelected || (x.Parent != null && x.Parent.IsSelected)) && x.Opacity > 0.1).ToList();
var decals = GetDecals(Document.Map.WorldSpawn).ToList();
GL.NewList(_listUntransformed2D, ListMode.Compile);
// Draw unselected stuff
MapObjectRenderer.DrawWireframe(unselected.Where(x => x.Parent == null || !x.Parent.IsRenderHidden2D), false, true);
MapObjectRenderer.DrawWireframe(decals.Where(x => !x.IsSelected && !x.IsRenderHidden2D).SelectMany(x => x.GetDecalGeometry()), false, true);
MapObjectRenderer.DrawWireframe(_models.Where(x => !x.Item1.IsSelected && !x.Item1.IsRenderHidden2D).SelectMany(x => x.Item1.GetBoxFaces()), false, true);
// Draw selection (untransformed)
GL.Color4(Color.FromArgb(128, 0, 0));
MapObjectRenderer.DrawWireframe(selected.Where(x => x.Parent == null || !x.Parent.IsRenderHidden2D), true, true);
MapObjectRenderer.DrawWireframe(decals.Where(x => x.IsSelected && !x.IsRenderHidden2D).SelectMany(x => x.GetDecalGeometry()), true, true);
MapObjectRenderer.DrawWireframe(_models.Where(x => x.Item1.IsSelected && !x.Item1.IsRenderHidden2D).SelectMany(x => x.Item1.GetBoxFaces()), true, true);
GL.EndList();
GL.NewList(_listTransformed2D, ListMode.Compile);
// Draw selection (transformed)
GL.Color4(Color.Red);
MapObjectRenderer.DrawWireframe(selected.Where(x => x.Parent == null || !x.Parent.IsRenderHidden2D), true, true);
MapObjectRenderer.DrawWireframe(decals.Where(x => x.IsSelected && !x.IsRenderHidden2D).SelectMany(x => x.GetDecalGeometry()), true, true);
MapObjectRenderer.DrawWireframe(_models.Where(x => x.Item1.IsSelected && !x.Item1.IsRenderHidden2D).SelectMany(x => x.Item1.GetBoxFaces()), true, true);
GL.EndList();
_transparentFaces.Clear();
_transparentFaces.AddRange(selected.Where(x => x.Opacity < 0.9 || (x.Texture.Texture != null && x.Texture.Texture.HasTransparency)));
_transparentFaces.AddRange(unselected.Where(x => x.Opacity < 0.9 || (x.Texture.Texture != null && x.Texture.Texture.HasTransparency)));
_transparentFaces.AddRange(decals.SelectMany(x => x.GetDecalGeometry()));
selected.RemoveAll(_transparentFaces.Contains);
unselected.RemoveAll(_transparentFaces.Contains);
var sel3D = selected.Where(x => x.Parent == null || !x.Parent.IsRenderHidden3D).ToList();
// Draw unselected
GL.NewList(_listUntransformed3DTextured, ListMode.Compile);
MapObjectRenderer.DrawFilled(unselected.Where(x => x.Parent == null || !x.Parent.IsRenderHidden3D), Color.Empty, true);
GL.EndList();
GL.NewList(_listUntransformed3DFlat, ListMode.Compile);
MapObjectRenderer.DrawFilled(unselected.Where(x => x.Parent == null || !x.Parent.IsRenderHidden3D), Color.Empty, false);
GL.EndList();
GL.NewList(_listUntransformed3D, ListMode.Compile);
// Draw selected (wireframe; untransformed)
GL.Color4(Color.Yellow);
MapObjectRenderer.DrawWireframe(sel3D, true, false);
MapObjectRenderer.DrawWireframe(_models.Where(x => x.Item1.IsSelected && !x.Item1.IsRenderHidden3D).SelectMany(x => x.Item1.GetBoxFaces()), true, false);
GL.EndList();
GL.NewList(_listTransformed3DTextured, ListMode.Compile);
MapObjectRenderer.DrawFilled(sel3D, Color.Empty, true);
if (!Document.Map.HideFaceMask || !Document.Selection.InFaceSelection)
{
MapObjectRenderer.DrawFilled(sel3D, Color.FromArgb(255, 255, 128, 128), true);
}
GL.EndList();
GL.NewList(_listTransformed3DFlat, ListMode.Compile);
MapObjectRenderer.DrawFilled(sel3D, Color.Empty, false);
if (!Document.Map.HideFaceMask || !Document.Selection.InFaceSelection)
{
MapObjectRenderer.DrawFilled(sel3D, Color.FromArgb(255, 255, 128, 128), false);
}
GL.EndList();
_update = false;
}
public void Draw3D(ViewportBase context, Matrix4 viewport, Matrix4 camera, Matrix4 modelView)
{
var type = ((Viewport3D)context).Type;
var cam = ((Viewport3D)context).Camera.Location;
var location = new Coordinate((decimal)cam.X, (decimal)cam.Y, (decimal)cam.Z);
UpdateCache();
Matrix4 current;
GL.GetFloat(GetPName.ModelviewMatrix, out current);
GL.MatrixMode(MatrixMode.Modelview);
bool shaded = type == Viewport3D.ViewType.Shaded || type == Viewport3D.ViewType.Textured,
textured = type == Viewport3D.ViewType.Textured,
wireframe = type == Viewport3D.ViewType.Wireframe;
if (shaded)
{
MapObjectRenderer.EnableLighting();
}
if (!textured)
{
GL.Disable(EnableCap.Texture2D);
}
else
{
GL.Enable(EnableCap.Texture2D);
}
if (!wireframe)
{
GL.CallList(textured ? _listUntransformed3DTextured : _listUntransformed3DFlat);
GL.CallList(_listUntransformed3D);
// Render models
if (!View.DisableModelRendering)
{
foreach (var tuple in _models)
{
var arr = _modelLists[tuple.Item2];
var origin = tuple.Item1.Origin;
if (tuple.Item1.HideDistance() <= (location - origin).VectorMagnitude())
{
MapObjectRenderer.DrawFilled(tuple.Item1.GetBoxFaces(), Color.Empty, textured);
}
else
{
var angles = tuple.Item1.EntityData.GetPropertyCoordinate("angles", Coordinate.Zero);
angles = new Coordinate(DMath.DegreesToRadians(angles.Z), DMath.DegreesToRadians(angles.X), DMath.DegreesToRadians(angles.Y));
if (tuple.Item1.IsSelected)
{
origin *= _selectionTransformMat;
}
var tform = Matrix.Rotation(Quaternion.EulerAngles(angles)).Translate(origin).ToOpenTKMatrix4();
GL.MultMatrix(ref tform);
GL.CallList(arr);
GL.LoadMatrix(ref current);
}
}
}
}
else
{
GL.CallList(_listUntransformed2D);
}
GL.MultMatrix(ref _selectionTransform);
if (!wireframe)
{
GL.CallList(textured ? _listTransformed3DTextured : _listTransformed3DFlat);
}
else
{
GL.CallList(_listTransformed2D);
}
GL.LoadMatrix(ref current);
if (!wireframe)
{
foreach (var face in _transparentFaces.OrderByDescending(x => (location - x.BoundingBox.Center).LengthSquared()))
{
var sel = (!Document.Map.HideFaceMask || !Document.Selection.InFaceSelection) && (face.IsSelected || (face.Parent != null && face.Parent.IsSelected));
if (sel)
{
GL.MultMatrix(ref _selectionTransform);
}
MapObjectRenderer.DrawFilled(new[] { face }, sel ? Color.FromArgb(255, 255, 128, 128) : Color.Empty, true);
GL.LoadMatrix(ref current);
}
}
else
{
if (Document.Map.HideFaceMask && Document.Selection.InFaceSelection)
{
MapObjectRenderer.DrawWireframe(_transparentFaces, false, true);
}
else
{
MapObjectRenderer.DrawWireframe(_transparentFaces.Where(x => !x.IsSelected && (x.Parent == null || !x.Parent.IsSelected)), false, true);
GL.Color4(Color.Red);
MapObjectRenderer.DrawWireframe(_transparentFaces.Where(x => x.IsSelected || (x.Parent != null && x.Parent.IsSelected)), true, true);
}
}
MapObjectRenderer.DisableLighting();
}
