UltimateZoneBuilder/Source/Plugins/3DFloorMode/BuilderPlug.cs

1135 lines
31 KiB
C#
Raw Normal View History


#region ================== Copyright (c) 2014 Boris Iwanski
/*
* Copyright (c) 2014 Boris Iwanski
* 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.Collections.Specialized;
using System.Collections.ObjectModel;
using System.Globalization;
using System.Text;
using System.Text.RegularExpressions;
using System.Windows.Forms;
using System.IO;
using System.Reflection;
using System.Linq;
using System.Diagnostics;
using CodeImp.DoomBuilder.Windows;
using CodeImp.DoomBuilder.IO;
using CodeImp.DoomBuilder.Map;
using CodeImp.DoomBuilder.Rendering;
using CodeImp.DoomBuilder.Geometry;
using System.Drawing;
using CodeImp.DoomBuilder.Editing;
using CodeImp.DoomBuilder.Plugins;
using CodeImp.DoomBuilder.Actions;
using CodeImp.DoomBuilder.Types;
using CodeImp.DoomBuilder.Config;
using CodeImp.DoomBuilder.Data;
using CodeImp.DoomBuilder.BuilderModes;
// using CodeImp.DoomBuilder.GZBuilder.Geometry;
using CodeImp.DoomBuilder.VisualModes;
#endregion
namespace CodeImp.DoomBuilder.ThreeDFloorMode
{
//
// MANDATORY: The plug!
// This is an important class to the Doom Builder core. Every plugin must
// have exactly 1 class that inherits from Plug. When the plugin is loaded,
// this class is instantiated and used to receive events from the core.
// Make sure the class is public, because only public classes can be seen
// by the core.
//
[Flags]
public enum PlaneType
{
Floor = 1,
Ceiling = 2,
Bottom = 4, // Floor of 3D floor control sector
Top = 8 // Ceiling of 3D floor control sector
}
public enum LabelDisplayOption
{
Always,
Never,
WhenHighlighted,
}
public class BuilderPlug : Plug
{
#region ================== Variables
private bool additiveselect;
private bool additivepaintselect;
private float highlightrange;
private bool autoclearselection;
private MenusForm menusform;
private bool usehighlight;
private ControlSectorArea controlsectorarea;
private float highlightsloperange;
private List<SlopeVertexGroup> slopevertexgroups;
private float stitchrange;
private Sector slopedatasector;
private bool updateafteraction;
private string updateafteractionname;
private LabelDisplayOption sectorlabeldisplayoption;
private LabelDisplayOption slopevertexlabeldisplayoption;
private PreferencesForm preferencesform;
private bool selectchangedafterundoredo;
// TMP
public List<Line3D> drawlines;
public List<Vector3D> drawpoints;
#endregion
#region ================== Properties
public bool AdditiveSelect { get { return additiveselect; } }
public bool AdditivePaintSelect { get { return additivepaintselect; } }
public float HighlightRange { get { return highlightrange; } }
public bool AutoClearSelection { get { return autoclearselection; } }
public MenusForm MenusForm { get { return menusform; } }
public bool UseHighlight
{
get
{
return usehighlight;
}
set
{
usehighlight = value;
General.Map.Renderer3D.ShowSelection = usehighlight;
General.Map.Renderer3D.ShowHighlight = usehighlight;
}
}
public ControlSectorArea ControlSectorArea { get { return controlsectorarea; } }
public float HighlightSlopeRange { get { return highlightsloperange; } }
public List<SlopeVertexGroup> SlopeVertexGroups { get { return slopevertexgroups; } set { slopevertexgroups = value; } }
public float StitchRange { get { return stitchrange; } }
public bool SelectChangedAfterUndoRedo { get { return selectchangedafterundoredo; } internal set { selectchangedafterundoredo = value; } }
public Sector SlopeDataSector { get { return slopedatasector; } set { slopedatasector = value; } }
public LabelDisplayOption SectorLabelDisplayOption { get { return sectorlabeldisplayoption; } set { sectorlabeldisplayoption = value; } }
public LabelDisplayOption SlopeVertexLabelDisplayOption { get { return slopevertexlabeldisplayoption; } set { slopevertexlabeldisplayoption = value; } }
#endregion
// Static instance. We can't use a real static class, because BuilderPlug must
// be instantiated by the core, so we keep a static reference. (this technique
// should be familiar to object-oriented programmers)
private static BuilderPlug me;
// Lines tagged to the selected sectors
private static ThreeDFloorEditorWindow tdfew = new ThreeDFloorEditorWindow();
public static ThreeDFloorEditorWindow TDFEW { get { return tdfew; } }
// Static property to access the BuilderPlug
public static BuilderPlug Me { get { return me; } }
// This plugin relies on some functionality that wasn't there in older versions
public override int MinimumRevision { get { return 1310; } }
// This event is called when the plugin is initialized
public override void OnInitialize()
{
base.OnInitialize();
usehighlight = true;
LoadSettings();
slopevertexgroups = new List<SlopeVertexGroup>();
//controlsectorarea = new ControlSectorArea(-512, 0, 512, 0, -128, -64, 128, 64, 64, 56);
// This binds the methods in this class that have the BeginAction
// and EndAction attributes with their actions. Without this, the
// attributes are useless. Note that in classes derived from EditMode
// this is not needed, because they are bound automatically when the
// editing mode is engaged.
General.Actions.BindMethods(this);
menusform = new MenusForm();
// TODO: Add DB2 version check so that old DB2 versions won't crash
// General.ErrorLogger.Add(ErrorType.Error, "zomg!");
// Keep a static reference
me = this;
// TMP
drawlines = new List<Line3D>();
drawpoints = new List<Vector3D>();
}
// This is called when the plugin is terminated
public override void Dispose()
{
base.Dispose();
// This must be called to remove bound methods for actions.
General.Actions.UnbindMethods(this);
}
public override void OnMapNewEnd()
{
base.OnMapNewEnd();
controlsectorarea = new ControlSectorArea(-512, 0, 512, 0, 64, 56);
BuilderPlug.Me.ControlSectorArea.LoadConfig();
slopevertexgroups.Clear();
slopedatasector = null;
}
public override void OnMapOpenEnd()
{
base.OnMapOpenEnd();
controlsectorarea = new ControlSectorArea(-512, 0, 512, 0, 64, 56);
BuilderPlug.Me.ControlSectorArea.LoadConfig();
// Try to find the slope data sector and store slope information in it
slopedatasector = GetSlopeDataSector();
if (slopedatasector != null)
LoadSlopeVertexGroupsFromSector();
}
public override void OnUndoEnd()
{
base.OnUndoEnd();
// Load slope vertex data from the dummy sector
LoadSlopeVertexGroupsFromSector();
}
public override void OnRedoEnd()
{
base.OnRedoEnd();
// Load slope vertex data from the dummy sector
LoadSlopeVertexGroupsFromSector();
}
public override void OnActionBegin(CodeImp.DoomBuilder.Actions.Action action)
{
base.OnActionBegin(action);
string[] monitoractions = {
"buildermodes_raisesector8", "buildermodes_lowersector8", "buildermodes_raisesector1",
"buildermodes_lowersector1", "builder_visualedit", "builder_classicedit"
};
if (General.Editing.Mode is SlopeMode)
return;
if (monitoractions.Contains(action.Name))
{
updateafteraction = true;
updateafteractionname = action.Name;
}
//else
// updateafteraction = false;
}
public override void OnActionEnd(CodeImp.DoomBuilder.Actions.Action action)
{
base.OnActionEnd(action);
if (!updateafteraction && action.Name != updateafteractionname)
return;
updateafteraction = false;
Dictionary<SlopeVertexGroup, int> updatesvgs = new Dictionary<SlopeVertexGroup, int>();
// Find SVGs that needs to be updated, and change the SV z positions
foreach (SlopeVertexGroup svg in slopevertexgroups)
{
bool update = false;
Dictionary<int, List<Sector>> newheights = new Dictionary<int, List<Sector>>();
foreach (Sector s in svg.Sectors)
{
if (s.Fields == null)
continue;
if ((svg.SectorPlanes[s] & PlaneType.Floor) == PlaneType.Floor)
{
if (s.Fields.ContainsKey("user_floorplane_id") && s.Fields.GetValue("user_floorplane_id", -1) == svg.Id)
{
if (svg.Height != s.FloorHeight)
{
int diff = s.FloorHeight - svg.Height;
if (!newheights.ContainsKey(diff))
newheights.Add(diff, new List<Sector>() { s });
else
newheights[diff].Add(s);
update = true;
//break;
}
}
}
if ((svg.SectorPlanes[s] & PlaneType.Ceiling) == PlaneType.Ceiling)
{
if (s.Fields.ContainsKey("user_ceilingplane_id") && s.Fields.GetValue("user_ceilingplane_id", -1) == svg.Id)
{
if (svg.Height != s.CeilHeight)
{
int diff = s.CeilHeight - svg.Height;
if (!newheights.ContainsKey(diff))
newheights.Add(diff, new List<Sector>() { s });
else
newheights[diff].Add(s);
update = true;
//break;
}
}
}
}
// Debug.WriteLine(String.Format("floordiff: {0} / ceilingdiff: {1} / height: {2}", floordiff, ceilingdiff, svg.Height));
if (update)
{
if (newheights.Count > 1)
Debug.WriteLine(String.Format("Slope: multiple new heights, doing nothing. Your map is fucked!"));
else if (!updatesvgs.ContainsKey(svg))
updatesvgs.Add(svg, newheights.First().Key);
}
}
// Update the slopes, and also update the view if in visual mode
foreach (SlopeVertexGroup svg in updatesvgs.Keys)
{
foreach (SlopeVertex sv in svg.Vertices)
sv.Z += updatesvgs[svg];
svg.ComputeHeight();
foreach (Sector s in svg.Sectors)
UpdateSlopes(s);
// Save the updated data in the sector
svg.StoreInSector(slopedatasector);
if (General.Editing.Mode is BaseVisualMode)
{
List<Sector> sectors = new List<Sector>();
List<VisualSector> visualsectors = new List<VisualSector>();
BaseVisualMode mode = ((BaseVisualMode)General.Editing.Mode);
foreach (Sector s in svg.Sectors)
{
sectors.Add(s);
// Get neighbouring sectors and add them to the list
foreach (Sidedef sd in s.Sidedefs)
{
if (sd.Other != null && !sectors.Contains(sd.Other.Sector))
sectors.Add(sd.Other.Sector);
}
}
foreach (Sector s in svg.TaggedSectors)
{
if(!sectors.Contains(s))
sectors.Add(s);
// Get neighbouring sectors and add them to the list
foreach (Sidedef sd in s.Sidedefs)
{
if (sd.Other != null && !sectors.Contains(sd.Other.Sector))
sectors.Add(sd.Other.Sector);
}
}
foreach (Sector s in sectors)
visualsectors.Add(mode.GetVisualSector(s));
foreach (VisualSector vs in visualsectors) vs.UpdateSectorGeometry(true);
foreach (VisualSector vs in visualsectors) vs.UpdateSectorData();
}
}
}
public override bool OnModeChange(EditMode oldmode, EditMode newmode)
{
if (newmode != null && oldmode != null)
{
if (newmode.GetType().Name == "DragSectorsMode")
{
foreach (SlopeVertexGroup svg in slopevertexgroups)
if (svg.Reposition)
svg.GetAnchor();
}
else if(oldmode.GetType().Name == "DragSectorsMode")
{
foreach (SlopeVertexGroup svg in slopevertexgroups)
if (svg.Reposition)
{
svg.RepositionByAnchor();
svg.StoreInSector(slopedatasector);
}
}
}
return base.OnModeChange(oldmode, newmode);
}
// When the Preferences dialog is shown
public override void OnShowPreferences(PreferencesController controller)
{
base.OnShowPreferences(controller);
// Load preferences
preferencesform = new PreferencesForm();
preferencesform.Setup(controller);
}
// When the Preferences dialog is closed
public override void OnClosePreferences(PreferencesController controller)
{
base.OnClosePreferences(controller);
// Apply settings that could have been changed
LoadSettings();
// Unload preferences
preferencesform.Dispose();
preferencesform = null;
}
#region ================== Actions
#endregion
#region ================== Methods
private Sector GetSlopeDataSector()
{
foreach (Sector s in General.Map.Map.Sectors)
{
if (s.Fields.GetValue("user_slopedatasector", false) == true)
return s;
}
return null;
}
public DialogResult ThreeDFloorEditor()
{
List<Sector> selectedSectors = new List<Sector>(General.Map.Map.GetSelectedSectors(true));
if (selectedSectors.Count <= 0 && General.Editing.Mode.HighlightedObject is Sector)
selectedSectors.Add((Sector)General.Editing.Mode.HighlightedObject);
if (tdfew == null)
tdfew = new ThreeDFloorEditorWindow();
tdfew.ThreeDFloors = GetThreeDFloors(selectedSectors);
DialogResult result = tdfew.ShowDialog((Form)General.Interface);
return result;
}
// Use the same settings as the BuilderModes plugin
private void LoadSettings()
{
additiveselect = General.Settings.ReadPluginSetting("BuilderModes", "additiveselect", false);
additivepaintselect = General.Settings.ReadPluginSetting("BuilderModes", "additivepaintselect", false);
highlightrange = General.Settings.ReadPluginSetting("BuilderModes", "highlightrange", 20);
autoclearselection = General.Settings.ReadPluginSetting("BuilderModes", "autoclearselection", false);
highlightsloperange = (float)General.Settings.ReadPluginSetting("BuilderModes", "highlightthingsrange", 10);
stitchrange = (float)General.Settings.ReadPluginSetting("BuilderModes", "stitchrange", 20);
slopevertexlabeldisplayoption = (LabelDisplayOption)General.Settings.ReadPluginSetting("slopevertexlabeldisplayoption", (int)LabelDisplayOption.Always);
sectorlabeldisplayoption = (LabelDisplayOption)General.Settings.ReadPluginSetting("sectorlabeldisplayoption", (int)LabelDisplayOption.Always);
selectchangedafterundoredo = General.Settings.ReadPluginSetting("BuilderModes", "selectchangedafterundoredo", false);
}
public void StoreSlopeVertexGroupsInSector()
{
if (slopedatasector != null && !slopedatasector.IsDisposed)
{
slopedatasector.Fields.BeforeFieldsChange();
if (!slopedatasector.Fields.ContainsKey("user_slopedatasector"))
{
slopedatasector.Fields.Add("user_slopedatasector", new UniValue(UniversalType.Boolean, true));
}
slopedatasector.Fields["comment"] = new UniValue(UniversalType.String, "[!]DO NOT EDIT OR DELETE! This sector is used by the slope mode for undo/redo operations.");
foreach (SlopeVertexGroup svg in slopevertexgroups)
svg.StoreInSector(slopedatasector);
}
}
public void LoadSlopeVertexGroupsFromSector()
{
Regex svgregex = new Regex(@"user_svg(\d+)_v0_x", RegexOptions.IgnoreCase);
slopevertexgroups.Clear();
if (slopedatasector == null || slopedatasector.IsDisposed)
return;
foreach (KeyValuePair<string, UniValue> kvp in slopedatasector.Fields)
{
Match svgmatch = svgregex.Match((string)kvp.Key);
if (svgmatch.Success)
{
int svgid = Convert.ToInt32(svgmatch.Groups[1].ToString());
slopevertexgroups.Add(new SlopeVertexGroup(svgid, slopedatasector));
}
}
General.Map.Map.Update();
}
public void UpdateSlopes()
{
// foreach (Sector s in General.Map.Map.Sectors)
// UpdateSlopes(s);
foreach (SlopeVertexGroup svg in slopevertexgroups)
{
foreach (Sector s in svg.Sectors)
{
if (s != null && !s.IsDisposed)
UpdateSlopes(s);
}
}
}
public Vector3D CRS(Vector3D p0, Vector3D p1, Vector3D p2, Vector3D p3, float t)
{
return 0.5f * ((2 * p1) +
(-p0 + p2) * t +
(2 * p0 - 5 * p1 + 4 * p2 - p3) * (t * t) +
(-p0 + 3 * p1 - 3 * p2 + p3) * (t * t * t)
);
}
public void UpdateSlopes(Sector s)
{
string[] fieldnames = new string[] { "user_floorplane_id", "user_ceilingplane_id" };
foreach (string fn in fieldnames)
{
int id = s.Fields.GetValue(fn, -1);
if (id == -1)
{
if (fn == "user_floorplane_id")
{
s.FloorSlope = new Vector3D();
s.FloorSlopeOffset = 0;
}
else
{
s.CeilSlope = new Vector3D();
s.CeilSlopeOffset = 0;
}
continue;
}
List<Vector3D> sp = new List<Vector3D>();
SlopeVertexGroup svg = GetSlopeVertexGroup(id);
// If the SVG does not exist unbind the SVG info from this sector
if (svg == null)
{
s.Fields.Remove(fn);
continue;
}
if (svg.Spline)
{
Vector2D center = new Vector2D(s.BBox.Width / 2 + s.BBox.X, s.BBox.Height / 2 + s.BBox.Y);
List<Line3D> splinelines = new List<Line3D>();
List<Vector3D> tangents = new List<Vector3D>();
sp.Add(new Vector3D(svg.Vertices[1].Pos.x, svg.Vertices[1].Pos.y, svg.Vertices[1].Z));
sp.Add(new Vector3D(svg.Vertices[0].Pos.x, svg.Vertices[0].Pos.y, svg.Vertices[0].Z));
sp.Add(new Vector3D(svg.Vertices[2].Pos.x, svg.Vertices[2].Pos.y, svg.Vertices[2].Z));
sp.Add(new Vector3D(sp[2].x-96, sp[2].y, sp[2].z-64));
sp.Insert(0, new Vector3D(sp[0].x+96, sp[0].y, sp[0].z-64));
//sp.Add(new Vector3D(sp[2] + (sp[2] - sp[1])));
//sp.Insert(0, new Vector3D(sp[0] + (sp[0] - sp[1])));
// Create tangents
tangents.Add(new Vector3D());
for (int i = 1; i <= 3; i++)
tangents.Add(new Vector3D((sp[i + 1] - sp[i - 1]) / 2.0f));
tangents.Add(new Vector3D());
Debug.Print("----- tangents -----");
for (int i = 0; i < tangents.Count; i++)
Debug.Print(tangents[i].ToString());
for(float u=0.0f; u < 1.0f; u += 0.1f)
{
splinelines.Add(new Line3D(
CRS(sp[0], sp[1], sp[2], sp[3], u),
CRS(sp[0], sp[1], sp[2], sp[3], u+0.1f)
));
/*
splinelines.Add(new Line3D(
Tools.HermiteSpline(sp[1], tangents[1], sp[2], tangents[2], u),
Tools.HermiteSpline(sp[1], tangents[1], sp[2], tangents[2], u+0.1f)
)
);
*/
}
for (float u = 0.0f; u < 1.0f; u += 0.1f)
{
splinelines.Add(new Line3D(
CRS(sp[1], sp[2], sp[3], sp[4], u),
CRS(sp[1], sp[2], sp[3], sp[4], u + 0.1f)
));
/*
splinelines.Add(new Line3D(
Tools.HermiteSpline(sp[2], tangents[2], sp[3], tangents[3], u),
Tools.HermiteSpline(sp[2], tangents[2], sp[3], tangents[3], u + 0.1f)
)
);
*/
}
drawlines.Clear();
drawlines.AddRange(splinelines);
drawpoints.Clear();
drawpoints.AddRange(sp);
Line2D sl1 = new Line2D(sp[1], sp[2]);
Line2D sl2 = new Line2D(sp[2], sp[3]);
List<Vector3D> points = new List<Vector3D>();
Debug.Print("----- spline lines -----");
foreach(Line3D l in splinelines)
Debug.Print(l.Start.ToString() + " / " + l.End.ToString());
foreach (Sidedef sd in s.Sidedefs)
{
2020-05-21 12:20:02 +00:00
double u = 0.0f;
Plane ldplane = new Plane(sd.Line.Start.Position, sd.Line.End.Position, new Vector3D(sd.Line.Start.Position.x, sd.Line.Start.Position.y, 128), true);
foreach(Line3D l in splinelines)
{
if(ldplane.GetIntersection(l.Start, l.End, ref u))
{
if (u < 0.0f || u > 1.0f)
continue;
Vector3D v = (l.End - l.Start) * u + l.Start;
points.Add(v);
}
}
/*
if(sd.Line.Line.GetIntersection(sl1, out u))
points.Add(Tools.HermiteSpline(sp[1], tangents[1], sp[2], tangents[2], u));
if (sd.Line.Line.GetIntersection(sl2, out u))
points.Add(Tools.HermiteSpline(sp[2], tangents[2], sp[3], tangents[3], u));
*/
}
if (fn == "user_floorplane_id")
{
/*
s.FloorSlope = new Vector3D(p.a, p.b, p.c);
s.FloorSlopeOffset = p.d;
*/
}
else
{
List<Vector3D> ps = new List<Vector3D>();
if (points.Count > 2)
points.RemoveAt(0);
Vector2D perp = new Line2D(points[0], points[1]).GetPerpendicular();
ps.Add(points[0]);
ps.Add(points[1]);
ps.Add(new Vector3D(points[0].x+perp.x, points[0].y+perp.y, points[0].z));
Debug.Print("----- points -----");
for (int i = 0; i < ps.Count; i++)
Debug.Print(ps[i].ToString());
/*
for(int i=0; i < ps.Count; i++)
{
ps[i] = new Vector3D(ps[i].x, ps[i].z, ps[i].y);
}
*/
Debug.Print("-----");
for (int i = 0; i < ps.Count; i++)
Debug.Print(ps[i].ToString());
Plane p = new Plane(ps[0], ps[1], ps[2], false);
s.CeilSlope = new Vector3D(p.a, p.b, p.c);
s.CeilSlopeOffset = p.d;
}
}
else // No spline
{
for (int i = 0; i < svg.Vertices.Count; i++)
{
sp.Add(new Vector3D(svg.Vertices[i].Pos.x, svg.Vertices[i].Pos.y, svg.Vertices[i].Z));
}
if (svg.Vertices.Count == 2)
{
2020-05-21 12:20:02 +00:00
double z = sp[0].z;
Line2D line = new Line2D(sp[0], sp[1]);
Vector3D perpendicular = line.GetPerpendicular();
Vector2D v = sp[0] + perpendicular;
sp.Add(new Vector3D(v.x, v.y, z));
}
if (fn == "user_floorplane_id")
{
Plane p = new Plane(sp[0], sp[1], sp[2], true);
s.FloorSlope = new Vector3D(p.a, p.b, p.c);
s.FloorSlopeOffset = p.d;
s.FloorHeight = svg.Height;
svg.Height = s.FloorHeight;
}
else
{
Plane p = new Plane(sp[0], sp[1], sp[2], false);
s.CeilSlope = new Vector3D(p.a, p.b, p.c);
s.CeilSlopeOffset = p.d;
s.CeilHeight = svg.Height;
svg.Height = s.CeilHeight;
}
}
}
}
public static List<ThreeDFloor> GetThreeDFloors(List<Sector> sectors)
{
List<ThreeDFloor> tdf = new List<ThreeDFloor>();
HashSet<Sector> tmpsectors = new HashSet<Sector>();
HashSet<Sector> potentialsectors = new HashSet<Sector>();
Dictionary<int, List<Sector>> tags = new Dictionary<int, List<Sector>>();
// Immediately return if the list is empty
if (sectors.Count == 0)
return tdf;
// Build a dictionary of tags used by 3D floor action and which control sector they belong to
foreach (Linedef ld in General.Map.Map.Linedefs)
{
// Make sure the front sector is managed by the 3D floor plugin
if (ld.Front == null || ld.Front.Sector == null || ld.Front.Sector.IsDisposed || (General.Map.UDMF && ld.Front.Sector.Fields.GetValue("user_managed_3d_floor", false) == false))
continue;
if (ld.Action == 160 && ld.Args[0] != 0)
{
if (!tags.ContainsKey(ld.Args[0]))
tags.Add(ld.Args[0], new List<Sector>() { ld.Front.Sector });
else
tags[ld.Args[0]].Add(ld.Front.Sector);
}
}
// Create a list of 3D floor control sectors that reference the given sectors
foreach (Sector s in sectors)
{
if (s == null || s.IsDisposed)
continue;
IEnumerable<int> intersecttags = tags.Keys.Intersect(s.Tags);
if (intersecttags.Count() == 0)
continue;
// This sector is tagged to contain a 3D floor. Using this will speed up creating the 3D floors later
potentialsectors.Add(s);
foreach(int it in intersecttags)
{
foreach (Sector its in tags[it])
tmpsectors.Add(its);
}
}
// Create 3D floors from the found sectors
foreach(Sector s in tmpsectors)
if(s != null)
tdf.Add(new ThreeDFloor(s, potentialsectors));
return tdf;
}
public static void ProcessThreeDFloors(List<ThreeDFloor> threedfloors)
{
ProcessThreeDFloors(threedfloors, null);
}
public static void ProcessThreeDFloors(List<ThreeDFloor> threedfloors, List<Sector> selectedSectors)
{
// List<Sector> selectedSectors = new List<Sector>(General.Map.Map.GetSelectedSectors(true));
var sectorsByTag = new Dictionary<int, List<Sector>>();
var sectorsToThreeDFloors = new Dictionary<Sector, List<ThreeDFloor>>();
var sectorGroups = new List<List<Sector>>();
List<int> tagblacklist = new List<int>();
int numnewcontrolsectors = 0;
if(selectedSectors == null)
selectedSectors = new List<Sector>(General.Map.Map.GetSelectedSectors(true));
var tmpSelectedSectors = new List<Sector>(selectedSectors);
foreach (ThreeDFloor tdf in GetThreeDFloors(selectedSectors))
{
bool add = true;
foreach (ThreeDFloor tdf2 in threedfloors)
{
if (tdf.Sector == tdf2.Sector)
{
add = false;
break;
}
}
if (add)
{
threedfloors.Add(tdf);
}
}
tmpSelectedSectors = new List<Sector>(selectedSectors);
General.Map.UndoRedo.CreateUndo("Modify 3D floors");
foreach (ThreeDFloor tdf in threedfloors)
{
// Create a list of all tags used by the control sectors. This is necessary so that
// tags that will be assigned to not yet existing geometry will not be used
foreach (int tag in tdf.Tags)
if (!tagblacklist.Contains(tag))
tagblacklist.Add(tag);
// Collect the number of control sectors that have to be created
if (tdf.IsNew)
numnewcontrolsectors++;
}
try
{
List<DrawnVertex> drawnvertices = new List<DrawnVertex>();
if (numnewcontrolsectors > 0)
drawnvertices = Me.ControlSectorArea.GetNewControlSectorVertices(numnewcontrolsectors);
foreach (ThreeDFloor tdf in threedfloors)
{
if (tdf.IsNew)
tdf.CreateGeometry(tagblacklist, drawnvertices);
tdf.UpdateGeometry();
}
}
catch (Exception e)
{
MessageBox.Show(e.Message + "\nPlease increase the size of the control sector area.", "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
General.Map.UndoRedo.WithdrawUndo();
return;
}
// Fill the sectorsToThreeDFloors dictionary, with a selected sector as key
// and a list of all 3D floors, that should be applied to to this sector, as value
foreach (Sector s in selectedSectors)
{
// Multiple tags is actually a UDMF field, so make sure it gets recorded for undo/redo
s.Fields.BeforeFieldsChange();
if (!sectorsToThreeDFloors.ContainsKey(s))
sectorsToThreeDFloors.Add(s, new List<ThreeDFloor>());
foreach (ThreeDFloor tdf in threedfloors)
{
if (tdf.TaggedSectors.Contains(s))
sectorsToThreeDFloors[s].Add(tdf);
}
}
// Group all selected sectors by their 3D floors. I.e. each element of sectorGroups
// is a list of sectors that have the same 3D floors
while (tmpSelectedSectors.Count > 0)
{
Sector s1 = tmpSelectedSectors.First();
var list = new List<Sector>();
var delsectors = new List<Sector>();
foreach (Sector s2 in tmpSelectedSectors)
{
if (sectorsToThreeDFloors[s1].ContainsAllElements(sectorsToThreeDFloors[s2]))
{
list.Add(s2);
delsectors.Add(s2);
}
}
foreach (Sector s in delsectors)
tmpSelectedSectors.Remove(s);
tmpSelectedSectors.Remove(s1);
sectorGroups.Add(list);
}
// Bind the 3D floors to the selected sectors
foreach (List<Sector> sectors in sectorGroups)
{
if (General.Map.UDMF == true)
{
foreach (Sector s in sectors)
{
// Remove all tags associated to 3D floors from the sector...
foreach (ThreeDFloor tdf in threedfloors)
{
if (s.Tags.Contains(tdf.UDMFTag))
s.Tags.Remove(tdf.UDMFTag);
}
// ... and re-add the ones that are still associated
foreach (ThreeDFloor tdf in sectorsToThreeDFloors[s])
{
if (!s.Tags.Contains(tdf.UDMFTag))
s.Tags.Add(tdf.UDMFTag);
}
// Remove tag 0 if there are other tags present, or add tag 0 if the sector has no tags
if (s.Tags.Count > 1 && s.Tags.Contains(0))
s.Tags.Remove(0);
if(s.Tags.Count == 0)
s.Tags.Add(0);
}
}
else
{
int newtag;
// Just use sectors.First(), all elements in sectors have the same 3D floors anyway
// If there are no 3D floors associated set the tag to 0
if (sectorsToThreeDFloors[sectors.First()].Count == 0)
newtag = 0;
else
try
{
newtag = BuilderPlug.Me.ControlSectorArea.GetNewSectorTag(tagblacklist);
tagblacklist.Add(newtag);
}
catch (Exception e)
{
MessageBox.Show(e.Message + "\nPlease increase the custom tag range.", "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
General.Map.UndoRedo.WithdrawUndo();
return;
}
foreach (Sector s in sectors)
s.Tag = newtag;
try
{
foreach (ThreeDFloor tdf in sectorsToThreeDFloors[sectors.First()])
tdf.BindTag(newtag, null);
}
catch (Exception e)
{
MessageBox.Show(e.Message, "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
General.Map.UndoRedo.WithdrawUndo();
return;
}
}
}
// Remove unused tags from the 3D floors
foreach (ThreeDFloor tdf in threedfloors)
tdf.Cleanup();
// Snap to map format accuracy
General.Map.Map.SnapAllToAccuracy();
// Update textures
General.Map.Data.UpdateUsedTextures();
// Update caches
General.Map.Map.Update();
General.Interface.RedrawDisplay();
General.Map.IsChanged = true;
}
public SlopeVertexGroup AddSlopeVertexGroup(List<SlopeVertex> vertices, out int id)
{
for (int i = 1; i < int.MaxValue; i++)
{
if (!slopevertexgroups.Exists(x => x.Id == i))
{
SlopeVertexGroup svg = new SlopeVertexGroup(i, (List<SlopeVertex>)vertices);
slopevertexgroups.Add(svg);
id = i;
return svg;
}
}
throw new Exception("No free slope vertex group ids");
}
public SlopeVertexGroup GetSlopeVertexGroup(SlopeVertex sv)
{
foreach (SlopeVertexGroup svg in slopevertexgroups)
{
if (svg.Vertices.Contains(sv))
return svg;
}
return null;
}
public SlopeVertexGroup GetSlopeVertexGroup(int id)
{
foreach (SlopeVertexGroup svg in slopevertexgroups)
{
if (svg.Id == id)
return svg;
}
return null;
}
public SlopeVertexGroup GetSlopeVertexGroup(Sector s)
{
foreach (SlopeVertexGroup svg in slopevertexgroups)
{
if (svg.Sectors.Contains(s))
return svg;
}
return null;
}
public static List<Sector> GetSectorsByTag(int tag)
{
return GetSectorsByTag(General.Map.Map.Sectors, tag);
}
public static List<Sector> GetSectorsByTag(IEnumerable sectors, int tag)
{
List<Sector> taggedsectors = new List<Sector>();
foreach (Sector s in sectors)
if (s.Tags.Contains(tag))
taggedsectors.Add(s);
return taggedsectors;
}
#endregion
}
public static class ThreeDFloorHelpers
{
public static bool ContainsAllElements<T>(this List<T> list1, List<T> list2)
{
if (list1.Count != list2.Count)
return false;
foreach (T i in list1)
if (!list2.Contains(i))
return false;
return true;
}
// Taken from http://stackoverflow.com/questions/10816803/finding-next-available-key-in-a-dictionary-or-related-collection
// Add item to sortedList (numeric key) to next available key item, and return key
public static int AddNext<T>(this SortedList<int, T> sortedList, T item)
{
int key = 1; // Make it 0 to start from Zero based index
int count = sortedList.Count;
int counter = 0;
do
{
if (count == 0) break;
int nextKeyInList = sortedList.Keys[counter++];
if (key != nextKeyInList) break;
key = nextKeyInList + 1;
if (count == 1 || counter == count) break;
if (key != sortedList.Keys[counter])
break;
} while (true);
sortedList.Add(key, item);
return key;
}
}
}