.gitattributes

@@ -1,8 +1,2 @@
 *.glb filter=lfs diff=lfs merge=lfs -text
 *.blend filter=lfs diff=lfs merge=lfs -text
-* !text !filter !merge !diff
-*.png filter=lfs diff=lfs merge=lfs -text
-*.obj filter=lfs diff=lfs merge=lfs -text
-*.fbx filter=lfs diff=lfs merge=lfs -text
-*.bin filter=lfs diff=lfs merge=lfs -text
-*.xcf filter=lfs diff=lfs merge=lfs -text

.lfsconfig

@@ -1,2 +0,0 @@
-[lfs]
-	url = https://git.onewaycoding.com/jay/fast-nuclear-sim.git/info/lfs

assets/shader/light.gsh

@@ -6,12 +6,13 @@ layout (triangle_strip, max_vertices=18) out;
 
 uniform mat4 shadow_mats[6];
 
-in flat int should_ignore[];
+in float emissive[];
+in float base_transparency[];
 out vec3 frag_pos;
 
 void main()
 {
-	if(should_ignore[0] != 0) return;
+	if(emissive[0] > 0 || base_transparency[0] > 0) return;
 
 	for(int i = 0; i < 6; i++)
 	{

assets/shader/light.vsh

@@ -4,16 +4,17 @@
 layout (location = 2) in vec4 aPos;
 layout (location = 4) in vec4 aColour;
 layout (location = 5) in vec3 aMaterial;
-layout (location = 6) in float aTransformIndex;
 
 uniform mat4 model;
 uniform mat4 camera;
 
-out flat int should_ignore;
+out float emissive;
+out float base_transparency;
 
 void main()
 {
 	gl_Position = camera * model * aPos;
-	should_ignore = int(aTransformIndex >= 0.f || aMaterial[2] > 0.f || aColour.a < 1.f);
+	base_transparency = 1.f - aColour.a;
+	emissive = aMaterial[2];
 }
 

assets/shader/main.fsh

@@ -18,12 +18,12 @@ struct Light
 	vec4 colour;
 };
 
-layout(std140, binding = 1) readonly buffer LightBuffer
+layout(std140, binding = 1) buffer ssbo_lights
 {
 	Light lights[];
 };
 
-layout(std430, binding = 2) readonly buffer ShadowMapBuffer
+layout(std430, binding = 2) buffer ssbo_shadow_maps
 {
 	samplerCube shadow_maps[];
 };
@@ -97,11 +97,10 @@ vec3 sRGB_To_LinRGB(vec3 c)
 
 void main()
 {
-	vec4 albedo = texture2D(frag_tex, vin.tex_pos);
+	vec4 albedo = texture2D(frag_tex, vin.tex_pos) * vin.colour;
 	if(albedo.a == 0.f) discard;
 
-	vec3 albedo_lin = sRGB_To_LinRGB(albedo.rgb) * vin.colour.rgb;
+	vec3 albedo_lin = sRGB_To_LinRGB(albedo.rgb);
-	albedo *= vin.colour;
 	
 	float roughness = vin.material[0];
 	float metalness = vin.material[1];
@@ -164,5 +163,6 @@ void main()
 
 	light = mix(light, albedo.rgb, luminance);
 	frag_colour = vec4(light, albedo.a);
+
 }
 

assets/shader/main.vsh

@@ -8,17 +8,11 @@ layout (location = 2) in vec4 aPos;
 layout (location = 3) in vec3 aNormal;
 layout (location = 4) in vec4 aColour;
 layout (location = 5) in vec3 aMaterial;
-layout (location = 6) in float aTransformIndex;
 
 uniform mat4 model;
 uniform mat4 camera;
 uniform mat4 projection;
 
-layout (binding = 3) readonly buffer TransformBuffer
-{
-	mat4 transforms[];
-};
-
 out VS_OUT {
 	vec3 normal;
 	vec4 colour;
@@ -31,12 +25,11 @@ out flat sampler2D frag_tex;
 
 void main()
 {
-	mat4 m = (aTransformIndex >= 0.f ? transforms[int(aTransformIndex)] : mat4(1.f)) * model;
+	mat4 mvp = camera * model;
-	mat4 mvp = camera * m;
 	vec4 pos = mvp * aPos;
 
-	vout.normal = mat3(m) * aNormal;
+	vout.normal = mat3(model) * aNormal;
-	vout.pos = (m * aPos).xyz;
+	vout.pos = (model * aPos).xyz;
 	vout.colour = aColour;
 	vout.tex_pos = aTexPos;
 	vout.material = aMaterial;

src/graphics/equipment/reactor.cpp

@@ -9,34 +9,16 @@
 
 using namespace Sim::Graphics::Equipment;
 
-Reactor::Reactor(const Model& model)
+Reactor::Reactor(const Model& model, Mesh& rmesh)
 {
 	g_control_rod = model.load("visual_control_rod");
 }
 
-void Reactor::remesh_static(Mesh& rmesh)
+void Reactor::update(double dt)
 {
-	Sim::System& sys = *Sim::System::active;
-
-	for(int i = 0; i < sys.reactor.size; i++)
-	{
-		Sim::Reactor::Rod* r = sys.reactor.rods[i].get();
-
-		if(!r->should_display())
-		{
-			continue;
 }
 
-		if(r->get_colour()[3] != 0)
+void Reactor::remesh_slow(Mesh& rmesh)
-		{
-			Mesh m = g_control_rod;
-			m.set_transform_id();
-			rmesh.add(m);
-		}
-	}
-}
-
-void Reactor::get_static_transforms(std::vector<glm::mat4>& transforms)
 {
 	Sim::System& sys = *Sim::System::active;
 
@@ -60,8 +42,17 @@ void Reactor::get_static_transforms(std::vector<glm::mat4>& transforms)
 
 		if(r->get_colour()[3] != 0)
 		{
-			transforms.push_back(glm::translate(glm::mat4(1), glm::vec3(ox, oy, (1 - r->get_colour().r) * sys.reactor.cell_height)));
+			rmesh.add(g_control_rod, glm::translate(glm::mat4(1), glm::vec3(ox, oy, (1 - r->get_colour().r) * sys.reactor.cell_height)));
 		}
 	}
 }
 
+void Reactor::remesh_fast(Mesh& rmesh)
+{
+}
+
+void Reactor::render()
+{
+}
+
+

src/graphics/equipment/reactor.hpp

@@ -12,9 +12,11 @@ class Reactor : public MeshGen
 
 public:
 
-	Reactor(const Model& model);
+	Reactor(const Model& model, Mesh& rmesh);
-	virtual void get_static_transforms(std::vector<glm::mat4>& transforms);
+	virtual void update(double dt);
-	virtual void remesh_static(Mesh& rmesh);
+	virtual void remesh_slow(Mesh& rmesh);
+	virtual void remesh_fast(Mesh& rmesh);
+	virtual void render();
 };
 
 };

src/graphics/mesh/arrays.cpp

@@ -36,8 +36,5 @@ void Arrays::vertex_attrib_pointers()
 
 	glVertexAttribPointer(5, 3, GL_FLOAT, false, sizeof(v), ptr_diff(&v.material, &v));
 	glEnableVertexAttribArray(5);
-
-	glVertexAttribPointer(6, 1, GL_FLOAT, false, sizeof(v), ptr_diff(&v.transform_id, &v));
-	glEnableVertexAttribArray(6);
 }
 

src/graphics/mesh/arrays.hpp

@@ -14,7 +14,6 @@ struct Vertex
 	glm::vec3 normal = {0, 0, 0};
 	glm::vec4 colour = {1, 1, 1, 1};
 	glm::vec3 material = {0, 0, 0};
-	float transform_id = -1;
 
 	constexpr bool operator==(const Vertex&) const = default;
 

src/graphics/mesh/mesh.cpp

@@ -15,22 +15,11 @@ Mesh::Mesh()
 
 }
 
-void Mesh::set_transform_id()
-{
-	for(unsigned int i = 0; i < vertices.size(); i++)
-	{
-		vertices[i].transform_id = 0;
-	}
-
-	max_transform_id = 0;
-}
-
 void Mesh::add(const Mesh& o, glm::mat4 mat)
 {
 	unsigned int off = vertices.size();
-	float t_off = max_transform_id + 1;
-
 	glm::mat3 mat3(mat);
+
 	vertices.reserve(vertices.size() + o.vertices.size());
 	indices.reserve(indices.size() + o.indices.size());
 
@@ -39,13 +28,6 @@ void Mesh::add(const Mesh& o, glm::mat4 mat)
 		Arrays::Vertex v = o.vertices[i];
 		v.normal = mat3 * v.normal;
 		v.pos = mat * v.pos;
-
-		if(v.transform_id >= 0)
-		{
-			v.transform_id += t_off;
-			max_transform_id = std::max(max_transform_id, v.transform_id);
-		}
-
 		vertices.push_back(v);
 	}
 
@@ -210,11 +192,7 @@ vec3 Mesh::calc_intersect(vec3 pos, vec3 path) const
 	}
 
 	vec3 path_n = path / l;
-	bool changing = true;
+	unsigned int i_found = 0;
-
-	while(changing)
-	{
-		changing = false;
 
 	for(unsigned int i = 0; i < indices.size(); i += 3)
 	{
@@ -226,7 +204,7 @@ vec3 Mesh::calc_intersect(vec3 pos, vec3 path) const
 		
 		if(calc_intercept_vert(v, pos, path, path_n, l))
 		{
-				changing = true;
+			i_found = i;
 		}
 
 		if(l == 0)
@@ -234,6 +212,21 @@ vec3 Mesh::calc_intersect(vec3 pos, vec3 path) const
 			return path;
 		}
 	}
+
+	for(unsigned int i = 0; i < i_found; i += 3)
+	{
+		vec3 v[3] = {
+			vec3(this->vertices[indices[i]].pos),
+			vec3(this->vertices[indices[i + 1]].pos),
+			vec3(this->vertices[indices[i + 2]].pos)
+		};
+		
+		calc_intercept_vert(v, pos, path, path_n, l);
+
+		if(l == 0)
+		{
+			return path;
+		}
 	}
 
 	return path;

src/graphics/mesh/mesh.hpp

@@ -19,11 +19,9 @@ struct Mesh
 {
 	std::vector<Arrays::Vertex> vertices;
 	std::vector<unsigned int> indices;
-	float max_transform_id = -1;
 
 	Mesh();
 
-	void set_transform_id();
 	void set_vertices(const Arrays::Vertex* data, size_t size);
 	void set_indices(const unsigned int* data, size_t size);
 	void load_text(const char* text, double size);

src/graphics/mesh/meshgen.hpp

@@ -10,10 +10,10 @@ class MeshGen
 {
 public:
 	virtual ~MeshGen() {}
-	virtual void update(double dt) {};
+	virtual void update(double dt) = 0;
-	virtual void get_static_transforms(std::vector<glm::mat4>& transforms) {};
+	virtual void remesh_slow(Mesh& rmesh) = 0;
-	virtual void remesh_static(Mesh& rmesh) {};
+	virtual void remesh_fast(Mesh& rmesh) = 0;
-	virtual void remesh_slow(Mesh& rmesh) {};
+	virtual void render() = 0;
 };
 
 };

src/graphics/monitor/core.cpp

@@ -116,9 +116,14 @@ struct CoreJoystick : public Focus::FocusType
 	}
 };
 
-Core::Core(const Model& model)
+Core::Core(const Model& model, Mesh& rmesh)
 {
+	Mesh mesh = model.load("translation_monitor_3");
 	mat = Locations::monitors[2];
+
+	mesh.load_text("Reactor Core", 0.04);
+	rmesh.add(mesh, mat);
+
 	m_buttons[0] = model.load("click_numpad_1");
 	m_buttons[1] = model.load("click_numpad_2");
 	m_buttons[2] = model.load("click_numpad_3");
@@ -133,13 +138,6 @@ Core::Core(const Model& model)
 	m_scram = model.load("click_scram");
 }
 
-void Core::remesh_static(Mesh& rmesh)
-{
-	Mesh mesh;
-	mesh.load_text("Reactor Core", 0.04);
-	rmesh.add(mesh, mat);
-}
-
 static Mesh add_dot(glm::mat4 model_mat, glm::vec4 colour)
 {
 	unsigned int indices[] = {0, 1, 3, 0, 3, 2};
@@ -185,6 +183,16 @@ void Core::update(double dt)
 }
 
 void Core::remesh_slow(Mesh& rmesh)
+{
+	remesh(rmesh, false);
+}
+
+void Core::remesh_fast(Mesh& rmesh)
+{
+	remesh(rmesh, true);
+}
+
+void Core::remesh(Mesh& rmesh, bool fast)
 {
 	Sim::System& sys = *System::active;
 	Sim::Graphics::Mesh mesh;
@@ -213,6 +221,9 @@ void Core::remesh_slow(Mesh& rmesh)
 		}
 
 		glm::mat4 mat = glm::translate(glm::mat4(1), glm::vec3(ox, oy, 0)) * mat_scale;
+
+		if(!fast)
+		{
 			glm::vec4 colour_heat = r->get_heat_colour() * glm::vec4(glm::vec3(1), 1);
 			glm::vec4 colour_spec = r->get_colour();
 
@@ -227,7 +238,10 @@ void Core::remesh_slow(Mesh& rmesh)
 			{
 				mesh.add(add_dot(mat * mat_spec, colour_spec));
 			}
+		}
 
+		else
+		{
 			if(sys.reactor.cursor == i)
 			{
 				mesh.add(add_dot(mat * mat_cursor, {1, 0, 0, 1}));
@@ -238,7 +252,12 @@ void Core::remesh_slow(Mesh& rmesh)
 				mesh.add(add_dot(mat * mat_select, {1, 1, 0, 1}));
 			}
 		}
+	}
 	
 	rmesh.add(mesh, mat);
 }
 
+void Core::render()
+{
+}
+

src/graphics/monitor/core.hpp

@@ -18,10 +18,12 @@ class Core : public MeshGen
 	
 public:
 
-	Core(const Model& model);
+	Core(const Model& model, Mesh& rmesh);
+	void remesh(Mesh& rmesh, bool fast);
 	virtual void update(double dt);
-	virtual void remesh_static(Mesh& rmesh);
 	virtual void remesh_slow(Mesh& rmesh);
+	virtual void remesh_fast(Mesh& rmesh);
+	virtual void render();
 };
 
 };

src/graphics/monitor/primary_loop.cpp

@@ -49,29 +49,12 @@ struct ValveJoystick : public Focus::FocusType
 	}
 };
 
-PrimaryLoop::PrimaryLoop(const Model& model)
+PrimaryLoop::PrimaryLoop(const Model& model, Mesh& rmesh)
 {
 	mat = Locations::monitors[3];
 	
-	g_switch_pump = model.load("visual_pump_switch_1");
-	g_switch_bypass = model.load("visual_bypass_switch");
-	g_switch_inlet = model.load("visual_inlet_switch");
-
-	m_joystick_turbine_bypass = model.load("click_bypass_joystick");
-	m_joystick_turbine_inlet = model.load("click_inlet_joystick");
-	m_switch_pump = model.load("click_pump_switch_1");
-	m_switch_bypass = model.load("click_bypass_switch");
-	m_switch_inlet = model.load("click_inlet_switch");
-
-	g_switch_pump.set_transform_id();
-	g_switch_bypass.set_transform_id();
-	g_switch_inlet.set_transform_id();
-}
-
-void PrimaryLoop::remesh_static(Mesh& rmesh)
-{
 	std::stringstream ss;
-	Mesh mesh;
+	Sim::Graphics::Mesh mesh;
 
 	ss << "Turbine Bypass Valve\n\n";
 	ss << "Opened\nFlow\nSetpoint\n\n";
@@ -88,9 +71,15 @@ void PrimaryLoop::remesh_static(Mesh& rmesh)
 	mesh.load_text(ss.str().c_str(), 0.04);
 	rmesh.add(mesh, mat);
 
-	rmesh.add(g_switch_pump);
+	g_switch_pump = model.load("visual_pump_switch_1");
-	rmesh.add(g_switch_bypass);
+	g_switch_bypass = model.load("visual_bypass_switch");
-	rmesh.add(g_switch_inlet);
+	g_switch_inlet = model.load("visual_inlet_switch");
+
+	m_joystick_turbine_bypass = model.load("click_bypass_joystick");
+	m_joystick_turbine_inlet = model.load("click_inlet_joystick");
+	m_switch_pump = model.load("click_pump_switch_1");
+	m_switch_bypass = model.load("click_bypass_switch");
+	m_switch_inlet = model.load("click_inlet_switch");
 }
 
 void PrimaryLoop::update(double dt)
@@ -157,7 +146,7 @@ void PrimaryLoop::remesh_slow(Mesh& rmesh)
 	rmesh.add(mesh, glm::translate(mat, glm::vec3(0.5, 0, 0)));
 }
 
-void PrimaryLoop::get_static_transforms(std::vector<glm::mat4>& transforms)
+void PrimaryLoop::remesh_fast(Mesh& rmesh)
 {
 	System& sys = *System::active;
 
@@ -165,8 +154,12 @@ void PrimaryLoop::get_static_transforms(std::vector<glm::mat4>& transforms)
 	float off2 = sys.loop.turbine_bypass_valve.get_auto() ? 0.07 : 0;
 	float off3 = sys.loop.turbine_inlet_valve.get_auto() ? 0.07 : 0;
 
-	transforms.push_back(glm::translate(glm::mat4(1), glm::vec3(0, off1, 0)));
+	rmesh.add(g_switch_pump, glm::translate(glm::mat4(1), glm::vec3(0, off1, 0)));
-	transforms.push_back(glm::translate(glm::mat4(1), glm::vec3(0, off2, 0)));
+	rmesh.add(g_switch_bypass, glm::translate(glm::mat4(1), glm::vec3(0, off2, 0)));
-	transforms.push_back(glm::translate(glm::mat4(1), glm::vec3(0, off3, 0)));
+	rmesh.add(g_switch_inlet, glm::translate(glm::mat4(1), glm::vec3(0, off3, 0)));
+}
+
+void PrimaryLoop::render()
+{
 }
 

src/graphics/monitor/primary_loop.hpp

@@ -24,11 +24,11 @@ class PrimaryLoop : public MeshGen
 	
 public:
 
-	PrimaryLoop(const Model& model);
+	PrimaryLoop(const Model& model, Mesh& rmesh);
 	virtual void update(double dt);
-	virtual void get_static_transforms(std::vector<glm::mat4>& transforms);
-	virtual void remesh_static(Mesh& rmesh);
 	virtual void remesh_slow(Mesh& rmesh);
+	virtual void remesh_fast(Mesh& rmesh);
+	virtual void render();
 };
 
 };

src/graphics/monitor/secondary_loop.cpp

@@ -17,36 +17,12 @@ using namespace Sim::Graphics::Monitor;
 using namespace Sim::Util::Streams;
 
 
-SecondaryLoop::SecondaryLoop(const Model& model)
+SecondaryLoop::SecondaryLoop(const Model& model, Mesh& rmesh)
 {
 	mat = Locations::monitors[5];
 
-	g_switch_2 = model.load("visual_pump_switch_2");
-	g_switch_3 = model.load("visual_pump_switch_3");
-
-	m_joystick_turbine_bypass = model.load("click_bypass_joystick");
-	m_joystick_turbine_inlet = model.load("click_inlet_joystick");
-	m_switch_2 = model.load("click_pump_switch_2");
-	m_switch_3 = model.load("click_pump_switch_3");
-
-	g_switch_2.set_transform_id();
-	g_switch_3.set_transform_id();
-}
-
-void SecondaryLoop::update(double dt)
-{
-	System& sys = *System::active;
-
-	if(m_switch_2.check_focus())
-		sys.loop.secondary_pump.powered = !sys.loop.secondary_pump.powered;
-	if(m_switch_3.check_focus())
-		sys.freight_pump.powered = !sys.freight_pump.powered;
-}
-
-void SecondaryLoop::remesh_static(Mesh& rmesh)
-{
 	std::stringstream ss;
-	Mesh mesh;
+	Sim::Graphics::Mesh mesh;
 
 	ss << "Cooling Tower\n\n";
 	ss << "Heat\nSteam\nPressure\nLevel\n\n";
@@ -57,8 +33,24 @@ void SecondaryLoop::remesh_static(Mesh& rmesh)
 
 	mesh.load_text(ss.str().c_str(), 0.04);
 	rmesh.add(mesh, mat);
-	rmesh.add(g_switch_2);
+
-	rmesh.add(g_switch_3);
+	g_switch_2 = model.load("visual_pump_switch_2");
+	g_switch_3 = model.load("visual_pump_switch_3");
+
+	m_joystick_turbine_bypass = model.load("click_bypass_joystick");
+	m_joystick_turbine_inlet = model.load("click_inlet_joystick");
+	m_switch_2 = model.load("click_pump_switch_2");
+	m_switch_3 = model.load("click_pump_switch_3");
+}
+
+void SecondaryLoop::update(double dt)
+{
+	System& sys = *System::active;
+
+	if(m_switch_2.check_focus())
+		sys.loop.secondary_pump.powered = !sys.loop.secondary_pump.powered;
+	if(m_switch_3.check_focus())
+		sys.freight_pump.powered = !sys.freight_pump.powered;
 }
 
 void SecondaryLoop::remesh_slow(Mesh& rmesh)
@@ -85,14 +77,19 @@ void SecondaryLoop::remesh_slow(Mesh& rmesh)
 	rmesh.add(mesh, glm::translate(mat, glm::vec3(0.5, 0, 0)));
 }
 
-void SecondaryLoop::get_static_transforms(std::vector<glm::mat4>& transforms)
+void SecondaryLoop::remesh_fast(Mesh& rmesh)
 {
 	System& sys = *System::active;
 
 	float off2 = sys.loop.secondary_pump.powered ? 0.07 : 0;
 	float off3 = sys.freight_pump.powered ? 0.07 : 0;
 
-	transforms.push_back(glm::translate(glm::mat4(1), glm::vec3(0, off2, 0)));
+	rmesh.add(g_switch_2, glm::translate(glm::mat4(1), glm::vec3(0, off2, 0)));
-	transforms.push_back(glm::translate(glm::mat4(1), glm::vec3(0, off3, 0)));
+	rmesh.add(g_switch_3, glm::translate(glm::mat4(1), glm::vec3(0, off3, 0)));
 }
 
+void SecondaryLoop::render()
+{
+}
+
+

src/graphics/monitor/secondary_loop.hpp

@@ -21,11 +21,11 @@ class SecondaryLoop : public MeshGen
 	
 public:
 
-	SecondaryLoop(const Model& model);
+	SecondaryLoop(const Model& model, Mesh& rmesh);
 	virtual void update(double dt);
-	virtual void get_static_transforms(std::vector<glm::mat4>& transforms);
-	virtual void remesh_static(Mesh& rmesh);
 	virtual void remesh_slow(Mesh& rmesh);
+	virtual void remesh_fast(Mesh& rmesh);
+	virtual void render();
 };
 
 };

src/graphics/monitor/turbine.cpp

@@ -16,47 +16,10 @@ using namespace Sim::Graphics;
 using namespace Sim::Graphics::Monitor;
 using namespace Sim::Util::Streams;
 
-Turbine::Turbine(const Model& model)
+Turbine::Turbine(const Model& model, Mesh& rmesh)
 {
 	mat = Locations::monitors[4];
 	
-	g_synchroscope_dial = model.load("visual_synchroscope_dial");
-	g_switch_breaker = model.load("visual_breaker_switch");
-	m_switch_breaker = model.load("click_breaker_switch");
-	
-	g_synchroscope_dial.set_transform_id();
-	g_switch_breaker.set_transform_id();
-}
-
-void Turbine::update(double dt)
-{
-	System& sys = *System::active;
-
-	if(m_switch_breaker.check_focus())
-		sys.loop.generator.breaker_closed = !sys.loop.generator.breaker_closed;
-}
-
-void Turbine::get_static_transforms(std::vector<glm::mat4>& transforms)
-{
-	System& sys = *System::active;
-	double rpm = sys.loop.generator.get_rpm();
-	glm::mat4 mat(1);
-
-	if(rpm > 3570 && rpm < 3630)
-	{
-		mat = glm::translate(mat, glm::vec3(6.35, 3.949, 1.35));
-		mat = glm::rotate(mat, float(sys.loop.generator.get_phase_diff()), glm::vec3(0, 1, 0));
-		mat = glm::translate(mat, glm::vec3(-6.35, -3.949, -1.35));
-	}
-	
-	float off1 = sys.loop.generator.breaker_closed ? 0.07 : 0;
-
-	transforms.push_back(mat);
-	transforms.push_back(glm::translate(glm::mat4(1), glm::vec3(0, off1, 0)));
-}
-
-void Turbine::remesh_static(Mesh& rmesh)
-{
 	std::stringstream ss;
 	Sim::Graphics::Mesh mesh;
 
@@ -66,8 +29,33 @@ void Turbine::remesh_static(Mesh& rmesh)
 	mesh.load_text(ss.str().c_str(), 0.04);
 	rmesh.add(mesh, mat);
 
-	rmesh.add(g_synchroscope_dial);
+	mesh.load_text("Synchroscope", 0.04);
-	rmesh.add(g_switch_breaker);
+	rmesh.add(mesh, glm::translate(mat, glm::vec3(0, 0.6, 0)));
+	
+	mesh = model.load("visual_synchroscope_dial");
+	gm_synchroscope_dial.bind();
+	gm_synchroscope_dial.set(mesh, GL_STATIC_DRAW);
+
+	g_switch_breaker = model.load("visual_breaker_switch");
+	m_switch_breaker = model.load("click_breaker_switch");
+}
+
+void Turbine::update(double dt)
+{
+	System& sys = *System::active;
+	double rpm = sys.loop.generator.get_rpm();
+
+	if(rpm > 3570 && rpm < 3630)
+	{
+		glm::mat4 mat = glm::mat4(1);
+		mat = glm::translate(mat, glm::vec3(6.35, 3.949, 1.35));
+		mat = glm::rotate(mat, float(sys.loop.generator.get_phase_diff()), glm::vec3(0, 1, 0));
+		mat = glm::translate(mat, glm::vec3(-6.35, -3.949, -1.35));
+		gm_synchroscope_dial.model_matrix = mat;
+	}
+
+	if(m_switch_breaker.check_focus())
+		sys.loop.generator.breaker_closed = !sys.loop.generator.breaker_closed;
 }
 
 void Turbine::remesh_slow(Mesh& rmesh)
@@ -91,7 +79,7 @@ void Turbine::remesh_slow(Mesh& rmesh)
 	Util::Streams::show_units( ss, sys.loop.generator.get_energy_generated() ) << "W\n";
 
 	mesh.load_text(ss.str().c_str(), 0.04);
-	rmesh.add(mesh, glm::translate(mat, glm::vec3(0.4, 0.75, 0)));
+	rmesh.add(mesh, glm::translate(mat, glm::vec3(0.4, 0.7, 0)));
 
 	ss = std::stringstream();
 
@@ -99,6 +87,25 @@ void Turbine::remesh_slow(Mesh& rmesh)
 	ss << show( sys.grid.frequency ) << " Hz\n";
 
 	mesh.load_text(ss.str().c_str(), 0.04);
-	rmesh.add(mesh, glm::translate(mat, glm::vec3(0.7, 0.75, 0)));
+	rmesh.add(mesh, glm::translate(mat, glm::vec3(0.7, 0.7, 0)));
+}
+
+void Turbine::remesh_fast(Mesh& rmesh)
+{
+	System& sys = *System::active;
+	float off1 = sys.loop.generator.breaker_closed ? 0.07 : 0;
+	rmesh.add(g_switch_breaker, glm::translate(glm::mat4(1), glm::vec3(0, off1, 0)));
+}
+
+void Turbine::render()
+{
+	double rpm = System::active->loop.generator.get_rpm();
+
+	if(rpm > 3570 && rpm < 3630)
+	{
+		gm_synchroscope_dial.bind();
+		gm_synchroscope_dial.uniform();
+		gm_synchroscope_dial.render();
+	}
 }
 

src/graphics/monitor/turbine.hpp

@@ -12,17 +12,17 @@ class Turbine : public MeshGen
 {
 	glm::mat4 mat;
 
-	Mesh g_synchroscope_dial;
+	GLMesh gm_synchroscope_dial;
 	Mesh g_switch_breaker;
 	Mesh m_switch_breaker;
 
 public:
 
-	Turbine(const Model& model);
+	Turbine(const Model& model, Mesh& rmesh);
 	virtual void update(double dt);
-	virtual void get_static_transforms(std::vector<glm::mat4>& transforms);
-	virtual void remesh_static(Mesh& rmesh);
 	virtual void remesh_slow(Mesh& rmesh);
+	virtual void remesh_fast(Mesh& rmesh);
+	virtual void render();
 };
 
 };

src/graphics/monitor/vessel.cpp

@@ -15,13 +15,10 @@
 using namespace Sim::Graphics::Monitor;
 using namespace Sim::Util::Streams;
 
-Vessel::Vessel(const Model& model)
+Vessel::Vessel(const Model& model, Mesh& rmesh)
 {
 	mat = Locations::monitors[1];
-}
 
-void Vessel::remesh_static(Mesh& rmesh)
-{
 	std::stringstream ss;
 	Sim::Graphics::Mesh mesh;
 
@@ -41,6 +38,10 @@ void Vessel::remesh_static(Mesh& rmesh)
 	rmesh.add(mesh, mat);
 }
 
+void Vessel::update(double dt)
+{
+}
+
 void Vessel::remesh_slow(Mesh& rmesh)
 {
 	std::stringstream ss;
@@ -96,3 +97,11 @@ void Vessel::remesh_slow(Mesh& rmesh)
 	rmesh.add(mesh, glm::translate(mat, glm::vec3(0.5, 0, 0)));
 }
 
+void Vessel::remesh_fast(Mesh& rmesh)
+{
+}
+
+void Vessel::render()
+{
+}
+

src/graphics/monitor/vessel.hpp

@@ -13,9 +13,11 @@ class Vessel : public MeshGen
 	
 public:
 
-	Vessel(const Model& model);
+	Vessel(const Model& model, Mesh& rmesh);
-	virtual void remesh_static(Mesh& rmesh);
+	virtual void update(double dt);
 	virtual void remesh_slow(Mesh& rmesh);
+	virtual void remesh_fast(Mesh& rmesh);
+	virtual void render();
 };
 
 };

src/graphics/shader.cpp

@@ -121,11 +121,6 @@ void Shader::use()
 	ACTIVE = this;
 }
 
-void Shader::block_binding(const char* name, unsigned int binding)
-{
-	glUniformBlockBinding(prog_id, get_block_index(name), binding);
-}
-
 unsigned int Shader::operator [](const char* pos)
 {
 	auto it = uniform_locations.find(pos);
@@ -138,18 +133,6 @@ unsigned int Shader::operator [](const char* pos)
 	return uniform_locations[pos] = glGetUniformLocation(prog_id, pos);
 }
 
-unsigned int Shader::get_block_index(const char* pos)
-{
-	auto it = uniform_block_indices.find(pos);
-
-	if(it != uniform_block_indices.end())
-	{
-		return it->second;
-	}
-
-	return uniform_block_indices[pos] = glGetUniformBlockIndex(prog_id, pos);
-}
-
 unsigned int Shader::get(const char* pos)
 {
 	return operator[](pos);

src/graphics/shader.hpp

@@ -11,7 +11,6 @@ class Shader
 	unsigned int prog_id = 0;
 
 	std::unordered_map<const char*, unsigned int> uniform_locations;
-	std::unordered_map<const char*, unsigned int> uniform_block_indices;
 	
 public:
 	
@@ -28,11 +27,9 @@ public:
 
 	void load(const char* path, const char* file_vsh, const char* file_gsh, const char* file_fsh);
 	void load(const char* path, const char* file_vsh, const char* file_fsh);
-	void block_binding(const char* name, unsigned int index);
 	void use();
 
 	unsigned int operator[](const char* pos);
-	unsigned int get_block_index(const char* pos);
 	unsigned int get(const char* pos);
 };
 

src/graphics/widget/clock.cpp

@@ -34,7 +34,7 @@ void Clock::remesh_slow(Mesh& rmesh)
 	int t_m = std::fmod(at / 60, 60);
 	int t_h = std::fmod(at / 3600, 24);
 
-	ss << "FPS: " << (1.0 / dt) << "\n";
+//	ss << "FPS: " << (1.0 / dt) << "\n";
 	ss << "Time: " << std::setfill('0') << std::setw(2) << t_h << ":";
    	ss << std::setfill('0') << std::setw(2) << t_m << ":";
 	ss << std::setfill('0') << std::setw(2) << t_s << "\n";

src/graphics/window.cpp

@@ -37,22 +37,20 @@
 
 using namespace Sim::Graphics;
 
-constexpr int SSBO_TRANSFORMS_LEN = 2;
-
 static GLFWwindow* win;
 static bool win_should_close = false;
 static unsigned int ssbo_lights;
 static unsigned int ssbo_shadow_maps;
-static unsigned int ssbo_transforms[SSBO_TRANSFORMS_LEN];
 static double secs_wait_at = 0;
 static double secs_wait_now = 0;
 
 static int gm_dynamic_slow_at = 0;
-static int ssbo_transforms_at = 0;
 
 static GLMesh gm_scene;
 static GLMesh gm_transparent;
 static GLMesh gm_dynamic_slow[2];
+static GLMesh gm_dynamic_fast;
+static Mesh m_dynamic_fast;
 
 static std::vector<GLLight> lights;
 static std::vector<std::unique_ptr<MeshGen>> monitors;
@@ -151,22 +149,13 @@ void Window::create()
 
 	glUniform1i(Shader::MAIN["lights_count"], model.lights.size());
 
-	monitors.push_back(std::make_unique<Monitor::Core>(model));
+	monitors.push_back(std::make_unique<Monitor::Core>(model, m_scene));
-	monitors.push_back(std::make_unique<Monitor::Vessel>(model));
+	monitors.push_back(std::make_unique<Monitor::Vessel>(model, m_scene));
-	monitors.push_back(std::make_unique<Monitor::PrimaryLoop>(model));
+	monitors.push_back(std::make_unique<Monitor::PrimaryLoop>(model, m_scene));
-	monitors.push_back(std::make_unique<Monitor::SecondaryLoop>(model));
+	monitors.push_back(std::make_unique<Monitor::SecondaryLoop>(model, m_scene));
-	monitors.push_back(std::make_unique<Monitor::Turbine>(model));
+	monitors.push_back(std::make_unique<Monitor::Turbine>(model, m_scene));
-	equipment.push_back(std::make_unique<Equipment::Reactor>(model));
 
-	for(auto& monitor : monitors)
+	equipment.push_back(std::make_unique<Equipment::Reactor>(model, m_scene));
-	{
-		monitor->remesh_static(m_scene);
-	}
-
-	for(auto& equipment : equipment)
-	{
-		equipment->remesh_static(m_scene);
-	}
 
 	gm_scene.bind();
 	gm_scene.set(m_scene, GL_STATIC_DRAW);
@@ -201,28 +190,6 @@ void Window::create()
 	glBindBuffer(GL_SHADER_STORAGE_BUFFER, ssbo_shadow_maps);
 	glBufferData(GL_SHADER_STORAGE_BUFFER, light_handles.size() * sizeof(light_handles[0]), &light_handles[0], GL_STATIC_DRAW);
 	glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 2, ssbo_shadow_maps);
-
-	// setup the transforms ssbos and their initial values
-	
-	std::vector<glm::mat4> transforms;
-
-	for(auto& monitor : monitors)
-	{
-		monitor->get_static_transforms(transforms);
-	}
-
-	for(auto& equipment : equipment)
-	{
-		equipment->get_static_transforms(transforms);
-	}
-
-	glGenBuffers(SSBO_TRANSFORMS_LEN, ssbo_transforms);
-
-	for(int i = 0; i < SSBO_TRANSFORMS_LEN; i++)
-	{
-		glBindBuffer(GL_SHADER_STORAGE_BUFFER, ssbo_transforms[i]);
-		glBufferData(GL_SHADER_STORAGE_BUFFER, transforms.size() * sizeof(transforms[0]), &transforms[0], GL_DYNAMIC_DRAW);
-	}
 }
 
 void update_slow()
@@ -249,28 +216,37 @@ void update_slow()
 void Window::update(double dt)
 {
 	Mesh mesh;
-	std::vector<glm::mat4> transforms;
 
 	glfwPollEvents();
 
 	for(auto& monitor : monitors)
 	{
 		monitor->update(dt);
-		monitor->get_static_transforms(transforms);
 	}
 
 	for(auto& equipment : equipment)
 	{
 		equipment->update(dt);
-		equipment->get_static_transforms(transforms);
 	}
 	
 	UI::update(dt);
 
-	glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 3, ssbo_transforms[ssbo_transforms_at]);
+	for(auto& monitor : monitors)
-	ssbo_transforms_at = (ssbo_transforms_at + 1) % SSBO_TRANSFORMS_LEN;
+	{
-	glBindBuffer(GL_SHADER_STORAGE_BUFFER, ssbo_transforms[ssbo_transforms_at]);
+		monitor->remesh_fast(mesh);
-	glBufferData(GL_SHADER_STORAGE_BUFFER, transforms.size() * sizeof(transforms[0]), &transforms[0], GL_DYNAMIC_DRAW);
+	}
+
+	for(auto& equipment : equipment)
+	{
+		equipment->remesh_fast(mesh);
+	}
+	
+	if(mesh != m_dynamic_fast)
+	{
+		gm_dynamic_fast.bind();
+		gm_dynamic_fast.set(mesh, GL_DYNAMIC_DRAW);
+		m_dynamic_fast = std::move(mesh);
+	}
 
 	secs_wait_now += dt;
 	if(secs_wait_now > secs_wait_at + 1.0/30.0)
@@ -290,6 +266,20 @@ void Window::render_scene()
 	gm_dynamic_slow[gm_dynamic_slow_at].uniform();
 	gm_dynamic_slow[gm_dynamic_slow_at].render();
 
+	gm_dynamic_fast.bind();
+	gm_dynamic_fast.uniform();
+	gm_dynamic_fast.render();
+
+	for(auto& monitor : monitors)
+	{
+		monitor->render();
+	}
+
+	for(auto& equipment : equipment)
+	{
+		equipment->render();
+	}
+	
 	gm_transparent.bind();
 	gm_transparent.uniform();
 	gm_transparent.render();
@@ -313,7 +303,6 @@ void Window::render()
 	glUniformMatrix4fv(Shader::MAIN["camera"], 1, false, &mat_camera[0][0]);
 	glUniform3fv(Shader::MAIN["camera_pos"], 1, &camera_pos[0]);
 	glUniform3fv(Shader::MAIN["brightness"], 1, &brightness[0]);
-	projection_matrix = mat_projection;
 
 	glFrontFace(GL_CCW);
 	glClearColor(0, 0, 0, 1.0f);

src/graphics/window.hpp

@@ -13,7 +13,6 @@ extern glm::mat4 projection_matrix;
 
 bool should_close();
 void create();
-void remesh();
 void update(double dt);
 void render();
 void render_scene();