public override bool OnInteract()
{
Ring.Floor floor = Ring.GetFloor(Radius);
if (floor == null)
{
return(false);
}
Ring.Floor.Wing wing = floor.GetWing(Radians);
if (wing != null)
{
return(false);
}
float position =
(floor.RadiansToMeters(Radians) / Ring.UnitWingWidth).RoundDown() *
Ring.UnitWingWidth;
float radian_position = floor.MetersToRadians(position);
if (InputUtility.WasMouseLeftReleased)
{
floor.Wings.Add(new Ring.Floor.Wing(floor, position, 1));
}
else
{
Overlay.StartRadians = radian_position;
Overlay.EndRadians = radian_position +
floor.MetersToRadians(Ring.UnitWingWidth);
Overlay.StartRadius = floor.Radius -
floor.CeilingHeight;
Overlay.EndRadius = floor.Radius;
}
return(true);
}
public override bool OnInteract()
{
Ring.Floor floor = Ring.GetFloor(Radius);
if (floor == null)
{
return(false);
}
Ring.Floor.Wing wing = floor.GetWing(Radians);
if (wing != null)
{
if (InputUtility.WasMouseLeftReleased)
{
floor.Wings.Remove(wing);
}
else
{
Overlay.StartRadians = wing.StartRadians;
Overlay.EndRadians = wing.EndRadians;
Overlay.StartRadius = floor.Radius - floor.CeilingHeight;
Overlay.EndRadius = floor.Radius;
}
}
else
{
int floor_index = Ring.Floors.IndexOf(floor);
bool is_in_bottom_half = floor_index < Ring.Floors.Count / 2;
if (InputUtility.WasMouseLeftReleased)
{
if (is_in_bottom_half)
{
Ring.Floors.RemoveRange(0, floor_index + 1);
}
else
{
Ring.Floors.RemoveRange(floor_index, Ring.Floors.Count - floor_index);
}
}
else
{
Overlay.StartRadians = 0;
Overlay.EndRadians = 2 * Mathf.PI;
if (is_in_bottom_half)
{
Overlay.StartRadius = floor.Radius - floor.CeilingHeight;
Overlay.EndRadius = Ring.GroundFloorRadius;
}
else
{
Overlay.StartRadius = Ring.RoofRadius;
Overlay.EndRadius = floor.Radius;
}
}
}
return(true);
}
void Update()
{
if (Ring.Floors.Count() == 0)
{
Ring.GenerateSampleStructure(223, 5);
}
//Animation
if (Application.isPlaying)
{
//Spin
if (Linearity == 0)
{
in_linear_transition = false;
transform.rotation = Quaternion.Euler(0, 0,
transform.rotation.eulerAngles.z +
Ring.RPM * 360 / 60.0f * Time.deltaTime);
}
else
{
if (!in_linear_transition)
{
start_degrees = transform.rotation.eulerAngles.z;
in_linear_transition = true;
}
transform.rotation = Quaternion.Euler(0, 0,
Mathf.Lerp(start_degrees, 0, Linearity));
}
}
//Input
if (IsSelected)
{
Ray ray = The.StationViewer.GetRayFromCursorPosition();
Vector2 polar_coordinates = PolarCoordinatesFromRay(ray);
Ring.Floor.Wing wing_pointed_at =
Ring.GetWing(polar_coordinates.x, polar_coordinates.y);
foreach (WingVisualization wing in WingVisualizations)
{
if (wing.Wing == wing_pointed_at)
{
wing.Color = Color.yellow;
}
else
{
wing.Color = Color.green;
}
}
}
//Shader
if (material == null)
{
material = new MaterialPropertyBlock();
MeshRenderer.GetPropertyBlock(material);
}
bool regenerate = false;
if (outer_radius_displayed != Ring.GroundFloorRadius)
{
regenerate = true;
}
if (wings_displayed_per_floor.Count != Ring.Floors.Count)
{
regenerate = true;
}
else
{
for (int i = 0; i < Ring.Floors.Count; i++)
{
if (Ring.Floors[i].Wings.Count != wings_displayed_per_floor[i])
{
regenerate = true;
}
}
}
if (regenerate && Application.isPlaying)
{
//Floor data buffers
float[] floor_indices = new float[FloorResolution];
float[] floor_radii = new float[MaxFloorCount];
float[] ceiling_heights = new float[MaxFloorCount];
//Wing data buffers
int max_wing_count = MaxWingCountPerFloor * MaxFloorCount;
float[] wing_indices = new float[max_wing_count];
for (int i = 0; i < max_wing_count; i++)
{
wing_indices[i] = -1;
}
float[] wing_positions = new float[max_wing_count];
float[] wing_widths = new float[max_wing_count];
//Wing data textures
Texture2D wing_indices_texture = new Texture2D(MaxWingCountPerFloor / 4,
MaxFloorCount,
TextureFormat.RGBAFloat, false);
wing_indices_texture.filterMode = FilterMode.Point;
wing_indices_texture.wrapMode = TextureWrapMode.Clamp;
Texture2D wing_positions_texture = GameObject.Instantiate(wing_indices_texture);
Texture2D wing_widths_texture = GameObject.Instantiate(wing_indices_texture);
//Clear WingVisualizations
foreach (WingVisualization wing in WingVisualizations)
{
GameObject.DestroyImmediate(wing.gameObject);
}
//Generate data
foreach (WingVisualization wing in WingVisualizations)
{
GameObject.DestroyImmediate(wing.gameObject);
}
int floor_slot_index = 0;
int wing_index = 0;
foreach (Ring.Floor floor in Ring.Floors)
{
int floor_index = Ring.Floors.IndexOf(floor);
float ceiling_height = floor.CeilingHeight;
float floor_radius = Ring.GroundFloorRadius - floor_slot_index * Ring.Floor.UnitCeilingHeight;
int floor_slot_count = (ceiling_height / Ring.Floor.UnitCeilingHeight).Round();
for (int i = 0; i < floor_slot_count; i++)
{
floor_indices[floor_slot_index++] = floor_index;
}
ceiling_heights[floor_index] = ceiling_height;
floor_radii[floor_index] = floor_radius;
foreach (Ring.Floor.Wing wing in floor.Wings)
{
float wing_width = wing.Width;
Color wing_color = Color;
int wing_slot_count = (wing_width / Ring.UnitWingWidth).Round();
int wing_slot_start_index = (wing.Position / Ring.UnitWingWidth).Round();
for (int i = 0; i < wing_slot_count; i++)
{
wing_indices[floor_index * MaxWingCountPerFloor +
wing_slot_start_index + i] = wing_index;
}
wing_widths[wing_index] = wing_width;
wing_positions[wing_index] = wing.Position;
wing_index++;
WingVisualization wing_visualization =
GameObject.Instantiate(WingVisualizationPrefab);
wing_visualization.Wing = wing;
wing_visualization.transform.SetParent(WingVisualizationsContainer);
wing_visualization.Color = Color;
}
}
material.SetFloatArray("FloorIndices", floor_indices);
material.SetFloatArray("FloorRadii", floor_radii);
material.SetFloatArray("FloorHeights", ceiling_heights);
wing_indices_texture.SetPixelData(wing_indices, 0);
wing_indices_texture.Apply();
material.SetTexture("WingIndices", wing_indices_texture);
wing_positions_texture.SetPixelData(wing_positions, 0);
wing_positions_texture.Apply();
material.SetTexture("WingPositions", wing_positions_texture);
wing_widths_texture.SetPixelData(wing_widths, 0);
wing_widths_texture.Apply();
material.SetTexture("WingWidths", wing_widths_texture);
outer_radius_displayed = Ring.GroundFloorRadius;
wings_displayed_per_floor.Clear();
foreach (Ring.Floor floor in Ring.Floors)
{
wings_displayed_per_floor.Add(floor.Wings.Count());
}
}
UpdateWingColors();
material.SetFloat("FloorDivisor", Ring.Floor.UnitCeilingHeight);
material.SetFloat("InterstitialSpaceThickness",
Ring.Floor.InterstitialSpaceThickness * Linearity * 2);
material.SetFloat("OuterRadius", Ring.GroundFloorRadius);
material.SetFloat("InnerRadius", Ring.RoofRadius);
material.SetFloat("WingDivisor", Ring.UnitWingWidth);
material.SetFloat("WingDepth", Ring.UnitWingDepth);
material.SetFloat("RingDepth", Ring.Depth);
material.SetFloat("Linearity", Linearity);
material.SetFloat("ApplyWidthCorrection", 1);
material.SetFloat("WingVisibility", WingVisibility);
material.SetFloat("WireframeVisibility", WireframeVisibility);
material.SetColor("WireFrameColor", Color);
material.SetFloat("WallThickness",
Ring.Floor.Wing.WallThickness * Linearity * 2);
MeshRenderer.SetPropertyBlock(material);
}
