mirror of
https://git.do.srb2.org/STJr/UltimateZoneBuilder.git
synced 2024-11-23 12:22:35 +00:00
914 lines
24 KiB
C#
Executable file
914 lines
24 KiB
C#
Executable file
using System;
|
|
using System.Drawing;
|
|
using System.Windows.Forms;
|
|
using CodeImp.DoomBuilder.Windows;
|
|
|
|
namespace CodeImp.DoomBuilder.StairSectorBuilderMode
|
|
{
|
|
public partial class StairSectorBuilderForm : DelayedForm
|
|
{
|
|
private bool fullyloaded;
|
|
private bool loadingprefab;
|
|
private int stepmultiplier = 1;
|
|
private int originalfloorbase;
|
|
private int originalceilingbase;
|
|
|
|
|
|
#region ================== Properties
|
|
|
|
public int OriginalFloorBase
|
|
{
|
|
set { originalfloorbase = value; }
|
|
get { return originalfloorbase; }
|
|
}
|
|
|
|
public int OriginalCeilingBase
|
|
{
|
|
set { originalceilingbase = value; }
|
|
get { return originalceilingbase; }
|
|
}
|
|
|
|
public int StepMultiplier
|
|
{
|
|
set { stepmultiplier = value; }
|
|
}
|
|
|
|
public int StairType
|
|
{
|
|
get { return tabcontrol.SelectedIndex; }
|
|
}
|
|
|
|
public uint NumberOfSectors
|
|
{
|
|
// get { return (uint)System.Convert.ToUInt32(numberofsectors.Text); }
|
|
get { return (uint)numberofsectors.GetResult(1); }
|
|
set { numberofsectors.Text = value.ToString(); }
|
|
}
|
|
|
|
public uint SectorDepth
|
|
{
|
|
// get { return (uint)System.Convert.ToUInt32(sectordepth.Text); }
|
|
get { return (uint)sectordepth.GetResult(32); }
|
|
set { sectordepth.Text = value.ToString(); }
|
|
}
|
|
|
|
public int Spacing
|
|
{
|
|
get { return spacing.GetResult(0); }
|
|
set { spacing.Text = value.ToString(); }
|
|
}
|
|
|
|
public int InnerVertexMultiplier
|
|
{
|
|
get { return autocurveinnervertexmultiplier.GetResult(1); }
|
|
set { autocurveinnervertexmultiplier.Text = value.ToString(); }
|
|
}
|
|
|
|
public int OuterVertexMultiplier
|
|
{
|
|
get { return autocurveoutervertexmultiplier.GetResult(1); }
|
|
set { autocurveoutervertexmultiplier.Text = value.ToString(); }
|
|
}
|
|
|
|
public bool SideFront
|
|
{
|
|
get { return sidefront.Checked; }
|
|
set { sidefront.Checked = value; }
|
|
}
|
|
|
|
public CheckBox DistinctBaseHeights
|
|
{
|
|
get { return distinctbaseheights; }
|
|
set { distinctbaseheights = value; }
|
|
}
|
|
|
|
public CheckBox SingleSteps
|
|
{
|
|
get { return singlesteps; }
|
|
set { singlesteps = value; }
|
|
}
|
|
|
|
public CheckBox DistinctSectors
|
|
{
|
|
get { return distinctsectors; }
|
|
set { distinctsectors = value; }
|
|
}
|
|
|
|
public CheckBox SingleDirection
|
|
{
|
|
get { return singledirection; }
|
|
set { singledirection = value; }
|
|
}
|
|
|
|
public TabControl Tabs
|
|
{
|
|
get { return tabcontrol; }
|
|
}
|
|
|
|
public int NumControlPoints
|
|
{
|
|
get { return numberofcontrolpoints.GetResult(1) + 2; }
|
|
set { numberofcontrolpoints.Text = value.ToString(); }
|
|
}
|
|
|
|
public bool FloorHeight
|
|
{
|
|
get { return floorheightmodification.Checked; }
|
|
set { floorheightmodification.Checked = value; }
|
|
}
|
|
|
|
public bool CeilingHeight
|
|
{
|
|
get { return ceilingheightmodification.Checked; }
|
|
set { ceilingheightmodification.Checked = value; }
|
|
}
|
|
|
|
|
|
public int FloorHeightModification
|
|
{
|
|
get { return floorheightmod.GetResult(0); }
|
|
set { floorheightmod.Text = value.ToString(); }
|
|
}
|
|
|
|
public int CeilingHeightModification
|
|
{
|
|
get { return ceilingheightmod.GetResult(0); }
|
|
set { ceilingheightmod.Text = value.ToString(); }
|
|
}
|
|
|
|
public bool FloorFlat
|
|
{
|
|
get { return floorflat.Checked; }
|
|
set { floorflat.Checked = value; }
|
|
}
|
|
|
|
public string FloorFlatTexture
|
|
{
|
|
get { return floorflattexture.TextureName; }
|
|
set { floorflattexture.TextureName = value; }
|
|
}
|
|
|
|
public bool CeilingFlat
|
|
{
|
|
get { return ceilingflat.Checked; }
|
|
set { ceilingflat.Checked = value; }
|
|
}
|
|
|
|
public string CeilingFlatTexture
|
|
{
|
|
get { return ceilingflattexture.TextureName; }
|
|
set { ceilingflattexture.TextureName = value; }
|
|
}
|
|
|
|
public bool UpperTexture
|
|
{
|
|
get { return uppertexture.Checked; }
|
|
set { uppertexture.Checked = value; }
|
|
}
|
|
|
|
public bool MiddleTexture
|
|
{
|
|
get { return middletexture.Checked; }
|
|
set { middletexture.Checked = value; }
|
|
}
|
|
|
|
public bool LowerTexture
|
|
{
|
|
get { return lowertexture.Checked; }
|
|
set { lowertexture.Checked = value; }
|
|
}
|
|
|
|
public string UpperTextureTexture
|
|
{
|
|
get { return uppertexturetexture.TextureName; }
|
|
set { uppertexturetexture.TextureName = value; }
|
|
}
|
|
|
|
public string MiddleTextureTexture
|
|
{
|
|
get { return middletexturetexture.TextureName; }
|
|
set { middletexturetexture.TextureName = value; }
|
|
}
|
|
|
|
public string LowerTextureTexture
|
|
{
|
|
get { return lowertexturetexture.TextureName; }
|
|
set { lowertexturetexture.TextureName = value; }
|
|
}
|
|
|
|
public int FloorBase
|
|
{
|
|
set { floorbase.Text = value.ToString(); }
|
|
get { return floorbase.GetResult(0); }
|
|
}
|
|
|
|
public int CeilingBase
|
|
{
|
|
set { ceilingbase.Text = value.ToString(); }
|
|
get { return ceilingbase.GetResult(0); }
|
|
}
|
|
|
|
public bool FullyLoaded
|
|
{
|
|
get { return fullyloaded; }
|
|
}
|
|
|
|
public int Flipping
|
|
{
|
|
get { return autocurveflipping.SelectedIndex; }
|
|
set { autocurveflipping.SelectedIndex = value; }
|
|
}
|
|
|
|
public bool UpperUnpegged
|
|
{
|
|
get { return upperunpegged.Checked; }
|
|
set { upperunpegged.Checked = value; }
|
|
}
|
|
|
|
public bool LowerUnpegged
|
|
{
|
|
get { return lowerunpegged.Checked; }
|
|
set { lowerunpegged.Checked = value; }
|
|
}
|
|
|
|
#endregion
|
|
|
|
public StairSectorBuilderForm()
|
|
{
|
|
InitializeComponent();
|
|
|
|
foreach(BuilderPlug.Prefab p in BuilderPlug.Me.Prefabs)
|
|
{
|
|
ListViewItem lvi = new ListViewItem();
|
|
ListViewItem.ListViewSubItem lvisi = new ListViewItem.ListViewSubItem();
|
|
|
|
lvi.Text = p.name;
|
|
lvisi.Text = tabcontrol.TabPages[p.stairtype].Text;
|
|
|
|
lvi.SubItems.Add(lvisi);
|
|
prefabs.Items.Add(lvi);
|
|
}
|
|
}
|
|
|
|
// This shows the window
|
|
public void Show(Form owner)
|
|
{
|
|
// Position at left-top of owner
|
|
this.Location = new Point(owner.Location.X + 20, owner.Location.Y + 90);
|
|
|
|
// Set the default name for the prefab
|
|
for(int i = 1; i < int.MaxValue; i++)
|
|
{
|
|
string defname = "Prefab #" + i;
|
|
bool validname = true;
|
|
|
|
foreach(BuilderPlug.Prefab p in BuilderPlug.Me.Prefabs)
|
|
{
|
|
if(p.name == defname)
|
|
{
|
|
validname = false;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if(validname)
|
|
{
|
|
prefabname.Text = defname;
|
|
break;
|
|
}
|
|
}
|
|
|
|
// Show window
|
|
base.Show(owner);
|
|
}
|
|
|
|
private void ComputeHeights()
|
|
{
|
|
if(!fullyloaded) return;
|
|
|
|
if(floorbase.Enabled == false)
|
|
{
|
|
floorfirst.Text = "--";
|
|
floorlast.Text = "--";
|
|
}
|
|
else
|
|
{
|
|
floorfirst.Text = (Int32.Parse(floorbase.Text) + Int32.Parse(floorheightmod.Text)).ToString();
|
|
floorlast.Text = (Int32.Parse(floorbase.Text) + Int32.Parse(floorheightmod.Text) * (Int32.Parse(numberofsectors.Text) * stepmultiplier)).ToString();
|
|
}
|
|
|
|
if(ceilingbase.Enabled == false)
|
|
{
|
|
ceilingfirst.Text = "--";
|
|
ceilinglast.Text = "--";
|
|
}
|
|
else
|
|
{
|
|
ceilingfirst.Text = (Int32.Parse(ceilingbase.Text) + Int32.Parse(ceilingheightmod.Text)).ToString();
|
|
ceilinglast.Text = (Int32.Parse(ceilingbase.Text) + Int32.Parse(ceilingheightmod.Text) * (Int32.Parse(numberofsectors.Text) * stepmultiplier)).ToString();
|
|
}
|
|
}
|
|
|
|
// Wrap redrawing display so that it will not get called multiple
|
|
// times while loading a prefab
|
|
private void DoRedrawDisplay()
|
|
{
|
|
if(loadingprefab == false) General.Interface.RedrawDisplay();
|
|
}
|
|
|
|
private void btnOK_Click(object sender, EventArgs e)
|
|
{
|
|
SavePrefab("[Previous]", true, 0);
|
|
|
|
General.Editing.AcceptMode();
|
|
}
|
|
|
|
private void btnCancel_Click(object sender, EventArgs e)
|
|
{
|
|
General.Editing.CancelMode();
|
|
}
|
|
|
|
private void tbSectorDepth_TextChanged(object sender, EventArgs e)
|
|
{
|
|
DoRedrawDisplay();
|
|
}
|
|
|
|
private void rdbFront_CheckedChanged(object sender, EventArgs e)
|
|
{
|
|
DoRedrawDisplay();
|
|
}
|
|
|
|
private void rdbBack_CheckedChanged(object sender, EventArgs e)
|
|
{
|
|
DoRedrawDisplay();
|
|
}
|
|
|
|
private void tabcontrol_SelectedIndexChanged(object sender, EventArgs e)
|
|
{
|
|
if(General.Map.Map.GetSelectedLinedefs(true).Count == 1)
|
|
{
|
|
tabcontrol.SelectedTab = tabPage1;
|
|
}
|
|
|
|
if(tabcontrol.SelectedTab != tabPage1)
|
|
{
|
|
floorbase.Enabled = true;
|
|
ceilingbase.Enabled = true;
|
|
}
|
|
else
|
|
{
|
|
if(distinctbaseheights.Checked)
|
|
{
|
|
floorbase.Enabled = false;
|
|
ceilingbase.Enabled = false;
|
|
}
|
|
else
|
|
{
|
|
floorbase.Enabled = true;
|
|
ceilingbase.Enabled = true;
|
|
}
|
|
}
|
|
|
|
DoRedrawDisplay();
|
|
ComputeHeights();
|
|
}
|
|
|
|
/*private void tbAutoNumSectors_TextChanged(object sender, EventArgs e)
|
|
{
|
|
DoRedrawDisplay();
|
|
}*/
|
|
|
|
private void numberofsectors_WhenTextChanged(object sender, EventArgs e)
|
|
{
|
|
if(numberofsectors.Text == "" || numberofsectors.GetResult(1) == 0) numberofsectors.Text = "1";
|
|
ComputeHeights();
|
|
DoRedrawDisplay();
|
|
}
|
|
|
|
private void sectordepth_WhenTextChanged(object sender, EventArgs e)
|
|
{
|
|
if(sectordepth.GetResult(32) == 0) sectordepth.Text = "1";
|
|
DoRedrawDisplay();
|
|
}
|
|
|
|
private void StairSectorBuilderForm_Load(object sender, EventArgs e)
|
|
{
|
|
sectordepth.Text = "32";
|
|
spacing.Text = "0";
|
|
numberofsectors.Text = "1";
|
|
autocurveinnervertexmultiplier.Text = "1";
|
|
autocurveoutervertexmultiplier.Text = "1";
|
|
splineinnervertexmultiplier.Text = "1";
|
|
splineoutervertexmultiplier.Text = "1";
|
|
numberofcontrolpoints.Text = "1";
|
|
floorheightmod.Text = "0";
|
|
ceilingheightmod.Text = "0";
|
|
floorbase.Text = "0";
|
|
ceilingbase.Text = "0";
|
|
autocurveflipping.SelectedIndex = 0;
|
|
MiddleTextureTexture = "-";
|
|
|
|
fullyloaded = true;
|
|
|
|
ComputeHeights();
|
|
}
|
|
|
|
private void autocurveinnervertexmultiplier_WhenTextChanged(object sender, EventArgs e)
|
|
{
|
|
if(autocurveinnervertexmultiplier.GetResult(1) == 0) autocurveinnervertexmultiplier.Text = "1";
|
|
|
|
if(splineinnervertexmultiplier.Text != autocurveinnervertexmultiplier.Text)
|
|
splineinnervertexmultiplier.Text = autocurveinnervertexmultiplier.Text;
|
|
|
|
DoRedrawDisplay();
|
|
}
|
|
|
|
private void autocurveoutervertexmultiplier_WhenTextChanged(object sender, EventArgs e)
|
|
{
|
|
if(autocurveoutervertexmultiplier.GetResult(1) == 0) autocurveoutervertexmultiplier.Text = "1";
|
|
|
|
if(splineoutervertexmultiplier.Text != autocurveoutervertexmultiplier.Text)
|
|
splineoutervertexmultiplier.Text = autocurveoutervertexmultiplier.Text;
|
|
|
|
DoRedrawDisplay();
|
|
|
|
}
|
|
|
|
private void splineinnervertexmultiplier_WhenTextChanged(object sender, EventArgs e)
|
|
{
|
|
if(splineinnervertexmultiplier.GetResult(1) == 0) splineinnervertexmultiplier.Text = "1";
|
|
|
|
if(autocurveinnervertexmultiplier.Text != splineinnervertexmultiplier.Text)
|
|
autocurveinnervertexmultiplier.Text = splineinnervertexmultiplier.Text;
|
|
|
|
DoRedrawDisplay();
|
|
}
|
|
|
|
private void splineoutervertexmultiplier_WhenTextChanged(object sender, EventArgs e)
|
|
{
|
|
if(splineoutervertexmultiplier.GetResult(1) == 0) splineoutervertexmultiplier.Text = "1";
|
|
|
|
if(splineoutervertexmultiplier.Text != autocurveoutervertexmultiplier.Text)
|
|
autocurveoutervertexmultiplier.Text = splineoutervertexmultiplier.Text;
|
|
|
|
DoRedrawDisplay();
|
|
}
|
|
|
|
private void onecontrolpoint_CheckedChanged(object sender, EventArgs e)
|
|
{
|
|
DoRedrawDisplay();
|
|
}
|
|
|
|
private void StairSectorBuilderForm_Shown(object sender, EventArgs e)
|
|
{
|
|
if(General.Map.Map.GetSelectedLinedefs(true).Count == 1 || General.Map.Map.SelectedSectorsCount > 0)
|
|
{
|
|
tabcontrol.TabPages.Remove(tabPage2);
|
|
tabcontrol.TabPages.Remove(tabPage3);
|
|
}
|
|
|
|
if(General.Map.Map.SelectedSectorsCount > 0)
|
|
{
|
|
singledirection.Checked = false;
|
|
singledirection.Enabled = false;
|
|
|
|
singlesteps.Checked = true;
|
|
singlesteps.Enabled = false;
|
|
}
|
|
}
|
|
|
|
private void singleseteps_CheckedChanged(object sender, EventArgs e)
|
|
{
|
|
if (singlesteps.Checked)
|
|
{
|
|
singledirection.Enabled = true;
|
|
distinctsectors.Enabled = true;
|
|
}
|
|
else
|
|
{
|
|
singledirection.Enabled = false;
|
|
distinctsectors.Enabled = false;
|
|
}
|
|
|
|
DoRedrawDisplay();
|
|
}
|
|
|
|
private void numberofcontrolpoints_WhenTextChanged(object sender, EventArgs e)
|
|
{
|
|
if(numberofcontrolpoints.GetResult(1) == 0) numberofcontrolpoints.Text = "1";
|
|
DoRedrawDisplay();
|
|
}
|
|
|
|
private void sidefront_CheckedChanged(object sender, EventArgs e)
|
|
{
|
|
DoRedrawDisplay();
|
|
}
|
|
|
|
private void sideback_CheckedChanged(object sender, EventArgs e)
|
|
{
|
|
DoRedrawDisplay();
|
|
}
|
|
|
|
private void singledirection_CheckedChanged(object sender, EventArgs e)
|
|
{
|
|
DoRedrawDisplay();
|
|
}
|
|
|
|
private void floorheightmod_WhenTextChanged(object sender, EventArgs e)
|
|
{
|
|
if(floorheightmod.GetResult(0) == 0) floorheightmod.Text = "0";
|
|
ComputeHeights();
|
|
}
|
|
|
|
private void ceilingheightmod_WhenTextChanged(object sender, EventArgs e)
|
|
{
|
|
if(ceilingheightmod.GetResult(0) == 0) ceilingheightmod.Text = "0";
|
|
ComputeHeights();
|
|
}
|
|
|
|
private void floorflat_CheckedChanged(object sender, EventArgs e)
|
|
{
|
|
if(floorflat.Checked)
|
|
floorflattexture.Enabled = true;
|
|
else
|
|
floorflattexture.Enabled = false;
|
|
}
|
|
|
|
private void ceilingflat_CheckedChanged(object sender, EventArgs e)
|
|
{
|
|
if(ceilingflat.Checked)
|
|
ceilingflattexture.Enabled = true;
|
|
else
|
|
ceilingflattexture.Enabled = false;
|
|
}
|
|
|
|
private void spacing_WhenTextChanged(object sender, EventArgs e)
|
|
{
|
|
if(spacing.GetResult(0) == 0) spacing.Text = "0";
|
|
DoRedrawDisplay();
|
|
}
|
|
|
|
private void uppertexture_CheckedChanged(object sender, EventArgs e)
|
|
{
|
|
if(uppertexture.Checked)
|
|
{
|
|
uppertexturetexture.Enabled = true;
|
|
upperunpegged.Enabled = true;
|
|
}
|
|
else
|
|
{
|
|
uppertexturetexture.Enabled = false;
|
|
upperunpegged.Enabled = false;
|
|
}
|
|
}
|
|
|
|
private void middletexture_CheckedChanged(object sender, EventArgs e)
|
|
{
|
|
if(middletexture.Checked)
|
|
middletexturetexture.Enabled = true;
|
|
else
|
|
middletexturetexture.Enabled = false;
|
|
}
|
|
|
|
private void lowertexture_CheckedChanged(object sender, EventArgs e)
|
|
{
|
|
if(lowertexture.Checked)
|
|
{
|
|
lowertexturetexture.Enabled = true;
|
|
lowerunpegged.Enabled = true;
|
|
}
|
|
else
|
|
{
|
|
lowertexturetexture.Enabled = false;
|
|
lowerunpegged.Enabled = false;
|
|
}
|
|
}
|
|
|
|
private void firstisback_CheckedChanged(object sender, EventArgs e)
|
|
{
|
|
DoRedrawDisplay();
|
|
}
|
|
|
|
private void StairSectorBuilderForm_FormClosing(object sender, FormClosingEventArgs e)
|
|
{
|
|
// User closing the window?
|
|
if(e.CloseReason == CloseReason.UserClosing)
|
|
{
|
|
// Just cancel
|
|
General.Editing.CancelMode();
|
|
e.Cancel = true;
|
|
}
|
|
}
|
|
|
|
private void lastisback_CheckedChanged(object sender, EventArgs e)
|
|
{
|
|
DoRedrawDisplay();
|
|
}
|
|
|
|
private void acflipping1_CheckedChanged(object sender, EventArgs e)
|
|
{
|
|
DoRedrawDisplay();
|
|
}
|
|
|
|
private void acflipping2_CheckedChanged(object sender, EventArgs e)
|
|
{
|
|
DoRedrawDisplay();
|
|
}
|
|
|
|
private void acflipping3_CheckedChanged(object sender, EventArgs e)
|
|
{
|
|
DoRedrawDisplay();
|
|
}
|
|
|
|
private void floorbase_WhenTextChanged(object sender, EventArgs e)
|
|
{
|
|
if(floorbase.GetResult(0) == 0) floorbase.Text = "0";
|
|
ComputeHeights();
|
|
}
|
|
|
|
private void ceilingbase_WhenTextChanged(object sender, EventArgs e)
|
|
{
|
|
if(ceilingbase.GetResult(0) == 0) ceilingbase.Text = "0";
|
|
ComputeHeights();
|
|
}
|
|
|
|
private void prefabsave_Click(object sender, EventArgs e)
|
|
{
|
|
string name = prefabname.Text.Trim();
|
|
|
|
if(name == "[Previous]")
|
|
MessageBox.Show(Owner, "The prefab name \"[Previous]\" is reserved and can not be overwritten.", "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
|
|
else
|
|
SavePrefab(prefabname.Text.Trim(), false, -1);
|
|
}
|
|
|
|
private void SavePrefab(string name, bool forceoverwrite, int position)
|
|
{
|
|
int overwrite = -1;
|
|
|
|
// Prefab name may not be empty
|
|
if(name == "")
|
|
{
|
|
MessageBox.Show(this.Owner, "Please enter a name for the prefab", "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
|
|
return;
|
|
}
|
|
|
|
// Check if there's already a prefab with the given name
|
|
for(int i = 0; i < BuilderPlug.Me.Prefabs.Count; i++)
|
|
{
|
|
BuilderPlug.Prefab p = BuilderPlug.Me.Prefabs[i];
|
|
|
|
if(p.name == name)
|
|
{
|
|
if(forceoverwrite == false && MessageBox.Show(this.Owner, "A prefab with that name already exists. Overwrite?", "", MessageBoxButtons.YesNo, MessageBoxIcon.Question) == DialogResult.No)
|
|
return;
|
|
else
|
|
overwrite = i;
|
|
}
|
|
}
|
|
|
|
ListViewItem lvi = new ListViewItem();
|
|
ListViewItem.ListViewSubItem lvisi = new ListViewItem.ListViewSubItem();
|
|
|
|
lvi.Text = name;
|
|
lvisi.Text = tabcontrol.TabPages[tabcontrol.SelectedIndex].Text;
|
|
|
|
lvi.SubItems.Add(lvisi);
|
|
|
|
BuilderPlug.Prefab pf = new BuilderPlug.Prefab();
|
|
|
|
pf.name = name;
|
|
|
|
pf.numberofsectors = (int)NumberOfSectors;
|
|
pf.outervertexmultiplier = OuterVertexMultiplier;
|
|
pf.innervertexmultiplier = InnerVertexMultiplier;
|
|
|
|
pf.stairtype = tabcontrol.SelectedIndex;
|
|
|
|
// Straight stairs
|
|
pf.sectordepth = (int)SectorDepth;
|
|
pf.spacing = Spacing;
|
|
pf.frontside = SideFront;
|
|
pf.singlesteps = SingleSteps.Checked;
|
|
pf.distinctsectors = distinctsectors.Checked;
|
|
pf.singledirection = SingleDirection.Checked;
|
|
pf.distinctbaseheights = DistinctBaseHeights.Checked;
|
|
|
|
// Auto curve
|
|
pf.flipping = Flipping;
|
|
|
|
// Catmull Rom spline
|
|
pf.numberofcontrolpoints = NumControlPoints - 2;
|
|
|
|
// Height info
|
|
pf.applyfloormod = FloorHeight;
|
|
pf.floormod = FloorHeightModification;
|
|
//pf.floorbase = FloorBase;
|
|
pf.applyceilingmod = CeilingHeight;
|
|
pf.ceilingmod = CeilingHeightModification;
|
|
//pf.ceilingbase = CeilingBase;
|
|
|
|
// Textures
|
|
pf.applyfloortexture = FloorFlat;
|
|
pf.floortexture = FloorFlatTexture;
|
|
|
|
pf.applyceilingtexture = CeilingFlat;
|
|
pf.ceilingtexture = CeilingFlatTexture;
|
|
|
|
pf.applyuppertexture = UpperTexture;
|
|
pf.uppertexture = UpperTextureTexture;
|
|
pf.upperunpegged = UpperUnpegged;
|
|
|
|
pf.applymiddletexture = MiddleTexture;
|
|
pf.middletexture = MiddleTextureTexture;
|
|
|
|
pf.applylowertexture = LowerTexture;
|
|
pf.lowertexture = LowerTextureTexture;
|
|
pf.lowerunpegged = LowerUnpegged;
|
|
|
|
if(overwrite == -1)
|
|
{
|
|
if(position == -1)
|
|
{
|
|
BuilderPlug.Me.Prefabs.Add(pf);
|
|
prefabs.Items.Add(lvi);
|
|
}
|
|
else
|
|
{
|
|
BuilderPlug.Me.Prefabs.Insert(position, pf);
|
|
prefabs.Items.Insert(position, lvi);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
BuilderPlug.Me.Prefabs.RemoveAt(overwrite);
|
|
BuilderPlug.Me.Prefabs.Insert(overwrite, pf);
|
|
|
|
prefabs.Items.RemoveAt(overwrite);
|
|
prefabs.Items.Insert(overwrite, lvi);
|
|
}
|
|
}
|
|
|
|
private void LoadPrefab(int position)
|
|
{
|
|
loadingprefab = true;
|
|
|
|
BuilderPlug.Prefab p = BuilderPlug.Me.Prefabs[position];
|
|
|
|
prefabname.Text = p.name;
|
|
|
|
NumberOfSectors = (uint)p.numberofsectors;
|
|
OuterVertexMultiplier = p.outervertexmultiplier;
|
|
InnerVertexMultiplier = p.innervertexmultiplier;
|
|
|
|
tabcontrol.SelectedIndex = p.stairtype;
|
|
|
|
// Straight stairs
|
|
SectorDepth = (uint)p.sectordepth;
|
|
Spacing = p.spacing;
|
|
SideFront = p.frontside;
|
|
SingleSteps.Checked = p.singlesteps;
|
|
distinctsectors.Checked = p.distinctsectors;
|
|
SingleDirection.Checked = p.singledirection;
|
|
DistinctBaseHeights.Checked = p.distinctbaseheights;
|
|
|
|
// Auto curve TODO
|
|
Flipping = p.flipping;
|
|
|
|
// Catmull Rom spline
|
|
NumControlPoints = p.numberofcontrolpoints;
|
|
|
|
// Height info
|
|
FloorHeight = p.applyfloormod;
|
|
FloorHeightModification = p.floormod;
|
|
//FloorBase = p.floorbase;
|
|
CeilingHeight = p.applyceilingmod;
|
|
CeilingHeightModification = p.ceilingmod;
|
|
//CeilingBase = p.ceilingbase;
|
|
|
|
// Textures
|
|
FloorFlat = p.applyfloortexture;
|
|
FloorFlatTexture = p.floortexture;
|
|
CeilingFlat = p.applyceilingtexture;
|
|
CeilingFlatTexture = p.ceilingtexture;
|
|
|
|
UpperTexture = p.applyuppertexture;
|
|
UpperTextureTexture = p.uppertexture;
|
|
UpperUnpegged = p.upperunpegged;
|
|
|
|
MiddleTexture = p.applymiddletexture;
|
|
MiddleTextureTexture = p.middletexture;
|
|
|
|
LowerTexture = p.applylowertexture;
|
|
LowerTextureTexture = p.lowertexture;
|
|
LowerUnpegged = p.lowerunpegged;
|
|
|
|
loadingprefab = false;
|
|
}
|
|
|
|
private void prefabload_Click(object sender, EventArgs e)
|
|
{
|
|
if(prefabs.SelectedIndices.Count == 0) return;
|
|
|
|
LoadPrefab(prefabs.SelectedIndices[0]);
|
|
|
|
DoRedrawDisplay();
|
|
}
|
|
|
|
private void prefabdelete_Click(object sender, EventArgs e)
|
|
{
|
|
if(prefabs.SelectedIndices.Count == 0) return;
|
|
|
|
BuilderPlug.Me.Prefabs.RemoveAt(prefabs.SelectedIndices[0]);
|
|
prefabs.Items.RemoveAt(prefabs.SelectedIndices[0]);
|
|
}
|
|
|
|
private void distinctbaseheights_CheckedChanged(object sender, EventArgs e)
|
|
{
|
|
if(distinctbaseheights.Checked)
|
|
{
|
|
floorbase.Enabled = false;
|
|
ceilingbase.Enabled = false;
|
|
}
|
|
else
|
|
{
|
|
if(floorheightmodification.Checked) floorbase.Enabled = true;
|
|
if(ceilingheightmodification.Checked) ceilingbase.Enabled = true;
|
|
}
|
|
|
|
ComputeHeights();
|
|
}
|
|
|
|
private void autocurveflipping_SelectedIndexChanged(object sender, EventArgs e)
|
|
{
|
|
if(autocurveflipping.SelectedIndex != splineflipping.SelectedIndex)
|
|
splineflipping.SelectedIndex = autocurveflipping.SelectedIndex;
|
|
|
|
DoRedrawDisplay();
|
|
}
|
|
|
|
private void splineflipping_SelectedIndexChanged(object sender, EventArgs e)
|
|
{
|
|
if(splineflipping.SelectedIndex != autocurveflipping.SelectedIndex)
|
|
autocurveflipping.SelectedIndex = splineflipping.SelectedIndex;
|
|
|
|
DoRedrawDisplay();
|
|
}
|
|
|
|
private void floorheightmodification_CheckedChanged(object sender, EventArgs e)
|
|
{
|
|
if(floorheightmodification.Checked)
|
|
{
|
|
floorheightmod.Enabled = true;
|
|
|
|
if(StairType != 0 || distinctbaseheights.Checked == false) floorbase.Enabled = true;
|
|
}
|
|
else
|
|
{
|
|
floorheightmod.Enabled = false;
|
|
|
|
if(StairType != 0 || distinctbaseheights.Checked == false) floorbase.Enabled = false;
|
|
}
|
|
}
|
|
|
|
private void ceilingheightmodification_CheckedChanged(object sender, EventArgs e)
|
|
{
|
|
if(ceilingheightmodification.Checked)
|
|
{
|
|
ceilingheightmod.Enabled = true;
|
|
|
|
if(StairType != 0 || distinctbaseheights.Checked == false) ceilingbase.Enabled = true;
|
|
}
|
|
else
|
|
{
|
|
ceilingheightmod.Enabled = false;
|
|
|
|
if(StairType != 0 || distinctbaseheights.Checked == false) ceilingbase.Enabled = false;
|
|
}
|
|
}
|
|
|
|
private void floorbasegetter_LinkClicked(object sender, LinkLabelLinkClickedEventArgs e)
|
|
{
|
|
floorbase.Text = originalfloorbase.ToString();
|
|
}
|
|
|
|
private void ceilingbasegetter_LinkClicked(object sender, LinkLabelLinkClickedEventArgs e)
|
|
{
|
|
ceilingbase.Text = originalceilingbase.ToString();
|
|
}
|
|
|
|
private void prefabs_DoubleClick(object sender, EventArgs e)
|
|
{
|
|
if (prefabs.SelectedIndices.Count == 0) return;
|
|
|
|
LoadPrefab(prefabs.SelectedIndices[0]);
|
|
|
|
DoRedrawDisplay();
|
|
}
|
|
|
|
private void distinctsectors_CheckedChanged(object sender, EventArgs e)
|
|
{
|
|
DoRedrawDisplay();
|
|
}
|
|
}
|
|
}
|