mirror of
https://git.do.srb2.org/STJr/UltimateZoneBuilder.git
synced 2024-11-30 15:41:30 +00:00
504 lines
13 KiB
C#
504 lines
13 KiB
C#
|
|
#region ================== Copyright (c) 2007 Pascal vd Heiden
|
|
|
|
/*
|
|
* Copyright (c) 2007 Pascal vd Heiden, www.codeimp.com
|
|
* This program is released under GNU General Public License
|
|
*
|
|
* This program is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*
|
|
*/
|
|
|
|
#endregion
|
|
|
|
#region ================== Namespaces
|
|
|
|
using System;
|
|
using System.Collections;
|
|
using System.Collections.Generic;
|
|
using System.Globalization;
|
|
using System.Text;
|
|
using System.Windows.Forms;
|
|
using System.IO;
|
|
using System.Reflection;
|
|
using CodeImp.DoomBuilder.Windows;
|
|
using CodeImp.DoomBuilder.IO;
|
|
using CodeImp.DoomBuilder.Map;
|
|
using CodeImp.DoomBuilder.Rendering;
|
|
using CodeImp.DoomBuilder.Actions;
|
|
using CodeImp.DoomBuilder.Geometry;
|
|
using System.Drawing;
|
|
using SlimDX;
|
|
using CodeImp.DoomBuilder.Editing;
|
|
|
|
#endregion
|
|
|
|
namespace CodeImp.DoomBuilder.VisualModes
|
|
{
|
|
/// <summary>
|
|
/// Provides specialized functionality for a visual (3D) Doom Builder editing mode.
|
|
/// </summary>
|
|
public abstract class VisualMode : EditMode
|
|
{
|
|
#region ================== Constants
|
|
|
|
private const float ANGLE_FROM_MOUSE = 0.0001f;
|
|
private const float MAX_ANGLEZ_LOW = 100f / Angle2D.PIDEG;
|
|
private const float MAX_ANGLEZ_HIGH = (360f - 100f) / Angle2D.PIDEG;
|
|
private const float CAMERA_SPEED = 6f;
|
|
private const double SECTOR_UPDATE_INTERVAL = 100d;
|
|
|
|
#endregion
|
|
|
|
#region ================== Variables
|
|
|
|
// 3D Mode thing
|
|
protected Thing modething;
|
|
|
|
// Graphics
|
|
protected IRenderer3D renderer;
|
|
private Renderer3D renderer3d;
|
|
|
|
// Camera
|
|
private Vector3D campos;
|
|
private Vector3D camtarget;
|
|
private float camanglexy, camanglez;
|
|
|
|
// Processing
|
|
private double lastsectorupdatetime;
|
|
private Sector viewstartsector;
|
|
|
|
// Input
|
|
private bool keyforward;
|
|
private bool keybackward;
|
|
private bool keyleft;
|
|
private bool keyright;
|
|
|
|
// Map
|
|
protected VisualBlockMap blockmap;
|
|
protected Dictionary<Sector, VisualSector> allsectors;
|
|
protected Dictionary<Sector, VisualSector> visiblesectors;
|
|
|
|
#endregion
|
|
|
|
#region ================== Properties
|
|
|
|
public Vector3D CameraPosition { get { return campos; } set { campos = value; } }
|
|
public Vector3D CameraTarget { get { return camtarget; } }
|
|
|
|
#endregion
|
|
|
|
#region ================== Constructor / Disposer
|
|
|
|
/// <summary>
|
|
/// Provides specialized functionality for a visual (3D) Doom Builder editing mode.
|
|
/// </summary>
|
|
public VisualMode()
|
|
{
|
|
// Initialize
|
|
this.renderer = General.Map.Renderer3D;
|
|
this.renderer3d = (Renderer3D)General.Map.Renderer3D;
|
|
this.campos = new Vector3D(0.0f, 0.0f, 96.0f);
|
|
this.camanglez = Angle2D.PI;
|
|
this.blockmap = new VisualBlockMap();
|
|
this.allsectors = new Dictionary<Sector, VisualSector>(General.Map.Map.Sectors.Count);
|
|
this.visiblesectors = new Dictionary<Sector, VisualSector>(50);
|
|
}
|
|
|
|
// Disposer
|
|
public override void Dispose()
|
|
{
|
|
// Not already disposed?
|
|
if(!isdisposed)
|
|
{
|
|
// Clean up
|
|
foreach(KeyValuePair<Sector, VisualSector> s in allsectors) s.Value.Dispose();
|
|
blockmap.Dispose();
|
|
visiblesectors = null;
|
|
allsectors = null;
|
|
blockmap = null;
|
|
|
|
// Done
|
|
base.Dispose();
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region ================== Start / Stop
|
|
|
|
// Mode is engaged
|
|
public override void OnEngage()
|
|
{
|
|
base.OnEngage();
|
|
|
|
// Update the used textures
|
|
General.Map.Data.UpdateUsedTextures();
|
|
|
|
// Fill the blockmap
|
|
FillBlockMap();
|
|
|
|
// Find a 3D Mode thing
|
|
foreach(Thing t in General.Map.Map.Things)
|
|
if(t.Type == General.Map.Config.Start3DModeThingType) modething = t;
|
|
|
|
// Found one?
|
|
if(modething != null)
|
|
{
|
|
// Position camera here
|
|
modething.DetermineSector();
|
|
campos = modething.Position + new Vector3D(0.0f, 0.0f, 96.0f);
|
|
camanglexy = modething.Angle + Angle2D.PI;
|
|
camanglez = Angle2D.PI;
|
|
}
|
|
|
|
// Start special input mode
|
|
General.Interface.SetProcessorState(true);
|
|
General.Interface.StartExclusiveMouseInput();
|
|
}
|
|
|
|
// Mode is disengaged
|
|
public override void OnDisengage()
|
|
{
|
|
base.OnDisengage();
|
|
|
|
// Do we have a 3D Mode thing?
|
|
if(modething != null)
|
|
{
|
|
// Position the thing to match camera
|
|
modething.Move((int)campos.x, (int)campos.y, 0);
|
|
modething.Rotate(camanglexy - Angle2D.PI);
|
|
}
|
|
|
|
// Stop special input mode
|
|
General.Interface.SetProcessorState(false);
|
|
General.Interface.StopExclusiveMouseInput();
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region ================== Events
|
|
|
|
public override void OnUndoEnd()
|
|
{
|
|
base.OnUndoEnd();
|
|
|
|
// Make new blockmap
|
|
if(blockmap != null)
|
|
{
|
|
blockmap.Dispose();
|
|
blockmap = new VisualBlockMap();
|
|
FillBlockMap();
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region ================== Input
|
|
|
|
// Mouse input
|
|
public override void OnMouseInput(Vector2D delta)
|
|
{
|
|
base.OnMouseInput(delta);
|
|
|
|
// Change camera angles with the mouse changes
|
|
camanglexy -= delta.x * ANGLE_FROM_MOUSE;
|
|
camanglez += delta.y * ANGLE_FROM_MOUSE;
|
|
|
|
// Normalize angles
|
|
camanglexy = Angle2D.Normalized(camanglexy);
|
|
camanglez = Angle2D.Normalized(camanglez);
|
|
|
|
// Limit vertical angle
|
|
if(camanglez < MAX_ANGLEZ_LOW) camanglez = MAX_ANGLEZ_LOW;
|
|
if(camanglez > MAX_ANGLEZ_HIGH) camanglez = MAX_ANGLEZ_HIGH;
|
|
|
|
General.MainWindow.UpdateCoordinates(new Vector2D(camanglexy, camanglez));
|
|
}
|
|
|
|
[BeginAction("moveforward", BaseAction = true)]
|
|
public virtual void BeginMoveForward()
|
|
{
|
|
keyforward = true;
|
|
}
|
|
|
|
[EndAction("moveforward", BaseAction = true)]
|
|
public virtual void EndMoveForward()
|
|
{
|
|
keyforward = false;
|
|
}
|
|
|
|
[BeginAction("movebackward", BaseAction = true)]
|
|
public virtual void BeginMoveBackward()
|
|
{
|
|
keybackward = true;
|
|
}
|
|
|
|
[EndAction("movebackward", BaseAction = true)]
|
|
public virtual void EndMoveBackward()
|
|
{
|
|
keybackward = false;
|
|
}
|
|
|
|
[BeginAction("moveleft", BaseAction = true)]
|
|
public virtual void BeginMoveLeft()
|
|
{
|
|
keyleft = true;
|
|
}
|
|
|
|
[EndAction("moveleft", BaseAction = true)]
|
|
public virtual void EndMoveLeft()
|
|
{
|
|
keyleft = false;
|
|
}
|
|
|
|
[BeginAction("moveright", BaseAction = true)]
|
|
public virtual void BeginMoveRight()
|
|
{
|
|
keyright = true;
|
|
}
|
|
|
|
[EndAction("moveright", BaseAction = true)]
|
|
public virtual void EndMoveRight()
|
|
{
|
|
keyright = false;
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region ================== Visibility Culling
|
|
|
|
// This preforms visibility culling
|
|
private void DoCulling()
|
|
{
|
|
Vector2D campos2d = (Vector2D)campos;
|
|
float viewdist = General.Settings.ViewDistance;
|
|
|
|
// Get the blocks within view range and make a collection of all nearby linedefs
|
|
RectangleF viewrect = new RectangleF(campos.x - viewdist, campos.y - viewdist, viewdist * 2, viewdist * 2);
|
|
List<VisualBlockEntry> blocks = blockmap.GetSquareRange(viewrect);
|
|
List<Linedef> nearbylines = new List<Linedef>(blocks.Count);
|
|
foreach(VisualBlockEntry b in blocks) nearbylines.AddRange(b.Lines);
|
|
|
|
// Find the sector to begin with
|
|
if(General.Clock.CurrentTime > (lastsectorupdatetime + SECTOR_UPDATE_INTERVAL))
|
|
{
|
|
lastsectorupdatetime = General.Clock.CurrentTime;
|
|
viewstartsector = FindStartSector((Vector2D)campos, nearbylines);
|
|
}
|
|
|
|
// Find visible sectors
|
|
visiblesectors = new Dictionary<Sector, VisualSector>(visiblesectors.Count);
|
|
if(viewstartsector != null) ProcessVisibleSectors(viewstartsector, (Vector2D)campos);
|
|
}
|
|
|
|
// This finds and adds visible sectors
|
|
private void ProcessVisibleSectors(Sector start, Vector2D campos)
|
|
{
|
|
Stack<Sector> todo = new Stack<Sector>(50);
|
|
Dictionary<Sector, Sector> stackedsectors = new Dictionary<Sector, Sector>(50);
|
|
Clipper clipper = new Clipper(campos);
|
|
float viewdist2 = General.Settings.ViewDistance * General.Settings.ViewDistance;
|
|
|
|
// TODO: Use sector markings instead of the stackedsectors dictionary?
|
|
|
|
// This algorithm uses a breadth-first search for visible sectors
|
|
|
|
// Continue until no more sectors to process
|
|
todo.Push(start);
|
|
stackedsectors.Add(start, start);
|
|
while(todo.Count > 0)
|
|
{
|
|
Sector s = todo.Pop();
|
|
VisualSector vs;
|
|
|
|
// Find the basesector and make it if needed
|
|
if(allsectors.ContainsKey(s))
|
|
{
|
|
// Take existing visualsector
|
|
vs = allsectors[s];
|
|
}
|
|
else
|
|
{
|
|
// Make new visualsector
|
|
vs = CreateVisualSector(s);
|
|
allsectors.Add(s, vs);
|
|
}
|
|
|
|
// Add sector to visibility list
|
|
visiblesectors.Add(s, vs);
|
|
|
|
// Go for all sidedefs in the sector
|
|
foreach(Sidedef sd in s.Sidedefs)
|
|
{
|
|
// Camera on the front of this side?
|
|
float side = sd.Line.SideOfLine(campos);
|
|
if(((side > 0) && sd.IsFront) ||
|
|
((side < 0) && !sd.IsFront))
|
|
{
|
|
// Sidedef blocking the view?
|
|
if((sd.Other == null) ||
|
|
(sd.Other.Sector.FloorHeight >= (sd.Sector.CeilHeight - 0.0001f)) ||
|
|
(sd.Other.Sector.CeilHeight <= (sd.Sector.FloorHeight + 0.0001f)) ||
|
|
(sd.Other.Sector.FloorHeight >= (sd.Other.Sector.CeilHeight - 0.0001f)))
|
|
{
|
|
// This blocks the view
|
|
clipper.InsertRange(sd.Line.Start.Position, sd.Line.End.Position);
|
|
}
|
|
}
|
|
}
|
|
|
|
// Go for all sidedefs in the sector
|
|
foreach(Sidedef sd in s.Sidedefs)
|
|
{
|
|
// Doublesided and not referring to same sector?
|
|
if((sd.Other != null) && (sd.Other.Sector != sd.Sector))
|
|
{
|
|
// Get the other sector
|
|
Sector os = sd.Other.Sector;
|
|
|
|
// Sector not added yet?
|
|
if(!stackedsectors.ContainsKey(os))
|
|
{
|
|
// Within view range?
|
|
if(sd.Line.DistanceToSq(campos, true) < viewdist2)
|
|
{
|
|
Vector2D p = sd.Line.Start.Position;
|
|
if((p.x > s.BBox.Left + Linedef.SIDE_POINT_DISTANCE) &&
|
|
(p.x < s.BBox.Right - Linedef.SIDE_POINT_DISTANCE) &&
|
|
(p.y > s.BBox.Top + Linedef.SIDE_POINT_DISTANCE) &&
|
|
(p.y < s.BBox.Bottom - Linedef.SIDE_POINT_DISTANCE))
|
|
{
|
|
// Sidedef is inside source sector, other sector always visible!
|
|
todo.Push(os);
|
|
stackedsectors.Add(os, os);
|
|
}
|
|
// Can we see this sector?
|
|
else if(clipper.TestRange(sd.Line.Start.Position, sd.Line.End.Position))
|
|
{
|
|
// Process this sector as well
|
|
todo.Push(os);
|
|
stackedsectors.Add(os, os);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// Done
|
|
clipper.Dispose();
|
|
}
|
|
|
|
// This finds the nearest sector to the camera
|
|
private Sector FindStartSector(Vector2D campos, List<Linedef> lines)
|
|
{
|
|
float side;
|
|
Linedef l;
|
|
|
|
// Get nearest linedef
|
|
l = MapSet.NearestLinedef(lines, campos);
|
|
if(l != null)
|
|
{
|
|
// Check if we are on front or back side
|
|
side = l.SideOfLine(campos);
|
|
if(side > 0)
|
|
{
|
|
// Is there a sidedef here?
|
|
if(l.Back != null)
|
|
return l.Back.Sector;
|
|
else if(l.Front != null)
|
|
return l.Front.Sector;
|
|
else
|
|
return null;
|
|
}
|
|
else
|
|
{
|
|
// Is there a sidedef here?
|
|
if(l.Front != null)
|
|
return l.Front.Sector;
|
|
else if(l.Back != null)
|
|
return l.Back.Sector;
|
|
else
|
|
return null;
|
|
}
|
|
}
|
|
else
|
|
return null;
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region ================== Processing
|
|
|
|
// This creates a visual sector
|
|
protected abstract VisualSector CreateVisualSector(Sector s);
|
|
|
|
// This fills the blockmap
|
|
protected virtual void FillBlockMap()
|
|
{
|
|
blockmap.AddLinedefsSet(General.Map.Map.Linedefs);
|
|
}
|
|
|
|
// Processing
|
|
public override void OnProcess(double deltatime)
|
|
{
|
|
Vector3D camvec;
|
|
Vector3D camvecstrafe;
|
|
|
|
base.OnProcess(deltatime);
|
|
|
|
// Calculate camera direction vectors
|
|
camvec = Vector3D.FromAngleXYZ(camanglexy, camanglez);
|
|
camvecstrafe = Vector3D.FromAngleXY(camanglexy + Angle2D.PIHALF);
|
|
|
|
// Move the camera
|
|
if(keyforward) campos += camvec * CAMERA_SPEED;
|
|
if(keybackward) campos -= camvec * CAMERA_SPEED;
|
|
if(keyleft) campos -= camvecstrafe * CAMERA_SPEED;
|
|
if(keyright) campos += camvecstrafe * CAMERA_SPEED;
|
|
|
|
// Target the camera
|
|
camtarget = campos + camvec;
|
|
|
|
// Apply new camera matrices
|
|
renderer.PositionAndLookAt(campos, camtarget);
|
|
|
|
// Visibility culling
|
|
DoCulling();
|
|
|
|
// Now redraw
|
|
General.Interface.RedrawDisplay();
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region ================== Rendering
|
|
|
|
// Call this to simply render all visible sectors
|
|
public override void OnRedrawDisplay()
|
|
{
|
|
// Render all visible sectors
|
|
foreach(KeyValuePair<Sector, VisualSector> vs in visiblesectors)
|
|
renderer.RenderGeometry(vs.Value);
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region ================== Actions
|
|
|
|
[EndAction("reloadresources", BaseAction = true)]
|
|
public virtual void ReloadResources()
|
|
{
|
|
// Trash all visual sectors, because they are no longer valid
|
|
foreach(KeyValuePair<Sector, VisualSector> s in allsectors) s.Value.Dispose();
|
|
allsectors.Clear();
|
|
visiblesectors.Clear();
|
|
}
|
|
|
|
#endregion
|
|
}
|
|
}
|