jay
/
fast-nuclear-sim
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

fix refactor

This commit is contained in:
Jay Robson 2024-02-16 18:36:27 +11:00
parent 0df855ad8c
commit 91c0101fc4
37 changed files with 108 additions and 108 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
src/graphics/input/focus.cpp
View File

@ -19,8 +19,8 @@ using namespace Sim::Graphics;
static glm::vec<3, double> trigger_near; static glm::vec<3, double> trigger_near;
static glm::vec<3, double> trigger_far; static glm::vec<3, double> trigger_far;
static std::vector<std::unique_ptr<Focus::Focus>> stack; static std::vector<std::unique_ptr<Focus::FocusType>> stack;
static std::unique_ptr<Focus::Focus> state = nullptr; static std::unique_ptr<Focus::FocusType> state = nullptr;
static bool mouse_visible = false; static bool mouse_visible = false;
static bool mouse_locked = false; static bool mouse_locked = false;
static bool triggered = false; static bool triggered = false;
@ -179,7 +179,7 @@ void Focus::clear_mouse_locked()
clear_focus(); clear_focus();
} }
void Focus::set(std::unique_ptr<Focus> f) void Focus::set(std::unique_ptr<FocusType> f)
{ {
if(state != nullptr) if(state != nullptr)
{ {

6
src/graphics/input/focus.hpp
View File

@ -8,9 +8,9 @@
namespace Sim::Graphics::Focus namespace Sim::Graphics::Focus
{ {
struct Focus struct FocusType
{ {
virtual ~Focus() { } virtual ~FocusType() { }
virtual bool cursor_is_visible() { return true; } virtual bool cursor_is_visible() { return true; }
virtual void on_keypress(int key, int sc, int action, int mods) { } virtual void on_keypress(int key, int sc, int action, int mods) { }
virtual void on_mouse_button(int button, int action, int mods) { } virtual void on_mouse_button(int button, int action, int mods) { }
@ -28,7 +28,7 @@ bool is_mouse_locked();
void clear_mouse_locked(); void clear_mouse_locked();
glm::vec<3, double> get_trigger_near(); glm::vec<3, double> get_trigger_near();
glm::vec<3, double> get_trigger_far(); glm::vec<3, double> get_trigger_far();
void set(std::unique_ptr<Focus> f); void set(std::unique_ptr<FocusType> f);
void on_keypress(int key, int sc, int action, int mods); void on_keypress(int key, int sc, int action, int mods);
void on_mouse_button(int button, int action, int mods); void on_mouse_button(int button, int action, int mods);
void on_cursor_pos(double x, double y); void on_cursor_pos(double x, double y);

2
src/graphics/mesh/arrays.cpp
View File

@ -19,7 +19,7 @@ static void* ptr_diff(void* a, void* b)
void Arrays::vertex_attrib_pointers() void Arrays::vertex_attrib_pointers()
{ {
vertex v; Vertex v;
glVertexAttribLPointer(0, 1, GL_UNSIGNED_INT64_ARB, sizeof(v), ptr_diff(&v.texid, &v)); glVertexAttribLPointer(0, 1, GL_UNSIGNED_INT64_ARB, sizeof(v), ptr_diff(&v.texid, &v));
glEnableVertexAttribArray(0); glEnableVertexAttribArray(0);

2
src/graphics/mesh/arrays.hpp
View File

@ -6,7 +6,7 @@
namespace Sim::Graphics::Arrays namespace Sim::Graphics::Arrays
{ {
struct vertex struct Vertex
{ {
unsigned long texid = 0; unsigned long texid = 0;
glm::vec2 texpos = {0, 0}; glm::vec2 texpos = {0, 0};

18
src/graphics/mesh/font.cpp
View File

@ -15,7 +15,7 @@
using namespace Sim::Graphics; using namespace Sim::Graphics;
struct character struct Character
{ {
unsigned long handle; unsigned long handle;
float advance; float advance;
@ -23,7 +23,7 @@ struct character
glm::vec2 bearing; glm::vec2 bearing;
}; };
static character chars[128]; static Character chars[128];
void Font::init() void Font::init()
{ {
@ -63,7 +63,7 @@ void Font::init()
int offx = face->glyph->bitmap_left; int offx = face->glyph->bitmap_left;
int offy = face->glyph->bitmap_top; int offy = face->glyph->bitmap_top;
character& c = chars[i]; Character& c = chars[i];
c.advance = face->glyph->advance.x * m / 64.0; c.advance = face->glyph->advance.x * m / 64.0;
c.size = {width * m, height * m}; c.size = {width * m, height * m};
c.bearing = {offx * m, offy * m}; c.bearing = {offx * m, offy * m};
@ -95,7 +95,7 @@ void Font::init()
void Mesh::load_text(const char* text, double size) void Mesh::load_text(const char* text, double size)
{ {
std::vector<Arrays::vertex> vertices; std::vector<Arrays::Vertex> vertices;
std::vector<unsigned int> indices; std::vector<unsigned int> indices;
float x = 0, y = size; float x = 0, y = size;
@ -111,7 +111,7 @@ void Mesh::load_text(const char* text, double size)
for(unsigned int i = 0; text[i] != '\0'; i++) for(unsigned int i = 0; text[i] != '\0'; i++)
{ {
char c = text[i]; char c = text[i];
character ch = chars[c]; Character ch = chars[c];
if(c == '\n') if(c == '\n')
{ {
@ -136,10 +136,10 @@ void Mesh::load_text(const char* text, double size)
float ex = sx + ch.size.x * size; float ex = sx + ch.size.x * size;
float ey = sy + ch.size.y * size; float ey = sy + ch.size.y * size;
vertices.push_back(Arrays::vertex(ch.handle, {0, 0}, {sx, sy, 0, 1}, {0, 0, -1})); vertices.push_back(Arrays::Vertex(ch.handle, {0, 0}, {sx, sy, 0, 1}, {0, 0, -1}));
vertices.push_back(Arrays::vertex(ch.handle, {0, 1}, {sx, ey, 0, 1}, {0, 0, -1})); vertices.push_back(Arrays::Vertex(ch.handle, {0, 1}, {sx, ey, 0, 1}, {0, 0, -1}));
vertices.push_back(Arrays::vertex(ch.handle, {1, 0}, {ex, sy, 0, 1}, {0, 0, -1})); vertices.push_back(Arrays::Vertex(ch.handle, {1, 0}, {ex, sy, 0, 1}, {0, 0, -1}));
vertices.push_back(Arrays::vertex(ch.handle, {1, 1}, {ex, ey, 0, 1}, {0, 0, -1})); vertices.push_back(Arrays::Vertex(ch.handle, {1, 1}, {ex, ey, 0, 1}, {0, 0, -1}));
indices.insert(indices.end(), &index[0], &index[6]); indices.insert(indices.end(), &index[0], &index[6]);
at += 4; at += 4;

4
src/graphics/mesh/mesh.cpp
View File

@ -20,7 +20,7 @@ void Mesh::add(const Mesh& o, glm::mat4 mat)
for(unsigned int i = 0; i < o.vertices.size(); i++) for(unsigned int i = 0; i < o.vertices.size(); i++)
{ {
Arrays::vertex v = o.vertices[i]; Arrays::Vertex v = o.vertices[i];
v.normal = mat3 * v.normal; v.normal = mat3 * v.normal;
v.pos = mat * v.pos; v.pos = mat * v.pos;
vertices.push_back(v); vertices.push_back(v);
@ -32,7 +32,7 @@ void Mesh::add(const Mesh& o, glm::mat4 mat)
} }
} }
void Mesh::set_vertices(const Arrays::vertex* data, size_t size) void Mesh::set_vertices(const Arrays::Vertex* data, size_t size)
{ {
vertices.clear(); vertices.clear();
vertices.reserve(size); vertices.reserve(size);

4
src/graphics/mesh/mesh.hpp
View File

@ -15,12 +15,12 @@ namespace Sim::Graphics
struct Mesh struct Mesh
{ {
std::vector<Arrays::vertex> vertices; std::vector<Arrays::Vertex> vertices;
std::vector<unsigned int> indices; std::vector<unsigned int> indices;
constexpr Mesh() { } constexpr Mesh() { }
void set_vertices(const Arrays::vertex* data, size_t size); void set_vertices(const Arrays::Vertex* data, size_t size);
void set_indices(const unsigned int* data, size_t size); void set_indices(const unsigned int* data, size_t size);
void load_model(std::string base, std::string path); void load_model(std::string base, std::string path);
void load_model(std::string path) { load_model(".", path); } void load_model(std::string path) { load_model(".", path); }

14
src/graphics/mesh/model.cpp
View File

@ -17,17 +17,17 @@
using namespace Sim::Graphics; using namespace Sim::Graphics;
struct proc_state struct ProcState
{ {
unsigned int offset = 0; unsigned int offset = 0;
std::string base; std::string base;
std::vector<Arrays::vertex> vertices; std::vector<Arrays::Vertex> vertices;
std::vector<unsigned int> indices; std::vector<unsigned int> indices;
std::unordered_map<const aiTexture*, unsigned int> handles; std::unordered_map<const aiTexture*, unsigned int> handles;
}; };
static unsigned int proc_texture(const proc_state& state, aiMaterial* mat, const aiScene* scene) static unsigned int proc_texture(const ProcState& state, aiMaterial* mat, const aiScene* scene)
{ {
for(int i = 0; i < 0x0d; i++) for(int i = 0; i < 0x0d; i++)
{ {
@ -59,7 +59,7 @@ static unsigned int proc_texture(const proc_state& state, aiMaterial* mat, const
return Texture::handle_white; return Texture::handle_white;
} }
static void proc_mesh(proc_state& state, glm::mat4 mat, aiMesh* mesh, const aiScene* scene) static void proc_mesh(ProcState& state, glm::mat4 mat, aiMesh* mesh, const aiScene* scene)
{ {
aiMaterial* material = scene->mMaterials[mesh->mMaterialIndex]; aiMaterial* material = scene->mMaterials[mesh->mMaterialIndex];
unsigned int handle = proc_texture(state, material, scene); unsigned int handle = proc_texture(state, material, scene);
@ -68,7 +68,7 @@ static void proc_mesh(proc_state& state, glm::mat4 mat, aiMesh* mesh, const aiSc
for(unsigned int i = 0; i < mesh->mNumVertices; i++) for(unsigned int i = 0; i < mesh->mNumVertices; i++)
{ {
Arrays::vertex vertex; Arrays::Vertex vertex;
auto [x, y, z] = mesh->mVertices[i]; auto [x, y, z] = mesh->mVertices[i];
vertex.pos = glm::vec4(x, y, z, 1) * mat; vertex.pos = glm::vec4(x, y, z, 1) * mat;
@ -102,7 +102,7 @@ static void proc_mesh(proc_state& state, glm::mat4 mat, aiMesh* mesh, const aiSc
state.offset += mesh->mNumVertices; state.offset += mesh->mNumVertices;
} }
static void proc_node(proc_state& state, glm::mat4 mat, aiNode* node, const aiScene* scene) static void proc_node(ProcState& state, glm::mat4 mat, aiNode* node, const aiScene* scene)
{ {
auto m = node->mTransformation; auto m = node->mTransformation;
mat = glm::mat4( mat = glm::mat4(
@ -145,7 +145,7 @@ static unsigned int proc_embedded_texture(aiTexture* tex)
void Mesh::load_model(std::string base, std::string filename) void Mesh::load_model(std::string base, std::string filename)
{ {
proc_state state {.base = base}; ProcState state {.base = base};
std::string path = base + "/" + filename; std::string path = base + "/" + filename;
Assimp::Importer importer; Assimp::Importer importer;

12
src/graphics/monitor/core.cpp
View File

@ -31,7 +31,7 @@ static void set_all(bool state)
} }
} }
struct core_monitor : public Focus::Focus struct CoreMonitor : public Focus::FocusType
{ {
virtual void on_keypress(int key, int sc, int action, int mods) virtual void on_keypress(int key, int sc, int action, int mods)
{ {
@ -72,14 +72,14 @@ struct core_monitor : public Focus::Focus
} }
}; };
struct core_joystick : public Focus::Focus struct CoreJoystick : public Focus::FocusType
{ {
virtual void on_cursor_pos(double x, double y) virtual void on_cursor_pos(double x, double y)
{ {
Sim::System::active.reactor->add_rod_speed(y * 1e-6); Sim::System::active.reactor->add_rod_speed(y * 1e-6);
} }
virtual ~core_joystick() virtual ~CoreJoystick()
{ {
Sim::System::active.reactor->reset_rod_speed(); Sim::System::active.reactor->reset_rod_speed();
} }
@ -114,7 +114,7 @@ void Core::init()
mesh1.set(rmesh, GL_STATIC_DRAW); mesh1.set(rmesh, GL_STATIC_DRAW);
unsigned int indices[] = {0, 1, 3, 0, 3, 2}; unsigned int indices[] = {0, 1, 3, 0, 3, 2};
Arrays::vertex vertices[] = { Arrays::Vertex vertices[] = {
{Texture::handle_white, {0, 0}, {-0.75, -0.75, 0, 1}, {0, 0, -1}}, {Texture::handle_white, {0, 0}, {-0.75, -0.75, 0, 1}, {0, 0, -1}},
{Texture::handle_white, {0, 1}, {-0.75, 0.75, 0, 1}, {0, 0, -1}}, {Texture::handle_white, {0, 1}, {-0.75, 0.75, 0, 1}, {0, 0, -1}},
{Texture::handle_white, {1, 0}, { 0.75, -0.75, 0, 1}, {0, 0, -1}}, {Texture::handle_white, {1, 0}, { 0.75, -0.75, 0, 1}, {0, 0, -1}},
@ -145,9 +145,9 @@ void Core::update(double dt)
Sim::System& sys = Sim::System::active; Sim::System& sys = Sim::System::active;
if(m_monitor.check_focus()) if(m_monitor.check_focus())
Focus::set(std::make_unique<core_monitor>()); Focus::set(std::make_unique<CoreMonitor>());
if(m_joystick.check_focus()) if(m_joystick.check_focus())
Focus::set(std::make_unique<core_joystick>()); Focus::set(std::make_unique<CoreJoystick>());
if(m_scram.check_focus()) if(m_scram.check_focus())
sys.reactor->scram(); sys.reactor->scram();
if(m_buttons[0].check_focus()) if(m_buttons[0].check_focus())

2
src/graphics/monitor/core.hpp
View File

@ -3,7 +3,7 @@
#include "../mesh/glmesh.hpp" #include "../mesh/glmesh.hpp"
namespace Sim::Graphics::monitor namespace Sim::Graphics::Monitor
{ {
class Core class Core

10
src/graphics/monitor/primary_loop.cpp
View File

@ -15,16 +15,16 @@
using namespace Sim::Graphics; using namespace Sim::Graphics;
using namespace Sim::Graphics::Monitor; using namespace Sim::Graphics::Monitor;
struct valve_joystick : public Focus::Focus struct ValveJoystick : public Focus::FocusType
{ {
Sim::Coolant::Valve* active; Sim::Coolant::Valve* active;
valve_joystick(Sim::Coolant::Valve* v) : active(v) ValveJoystick(Sim::Coolant::Valve* v) : active(v)
{ {
} }
virtual ~valve_joystick() virtual ~ValveJoystick()
{ {
active->clear_open_speed(); active->clear_open_speed();
} }
@ -159,9 +159,9 @@ void PrimaryLoop::update(double dt)
} }
if(m_joystick_turbine_bypass.check_focus()) if(m_joystick_turbine_bypass.check_focus())
Focus::set(std::make_unique<valve_joystick>(sys.turbine_bypass_valve.get())); Focus::set(std::make_unique<ValveJoystick>(sys.turbine_bypass_valve.get()));
if(m_joystick_turbine_inlet.check_focus()) if(m_joystick_turbine_inlet.check_focus())
Focus::set(std::make_unique<valve_joystick>(sys.turbine_inlet_valve.get())); Focus::set(std::make_unique<ValveJoystick>(sys.turbine_inlet_valve.get()));
if(m_switch_pump.check_focus()) if(m_switch_pump.check_focus())
sys.primary_pump->powered = !sys.primary_pump->powered; sys.primary_pump->powered = !sys.primary_pump->powered;
if(m_switch_inlet.check_focus()) if(m_switch_inlet.check_focus())

2
src/graphics/monitor/primary_loop.hpp
View File

@ -3,7 +3,7 @@
#include "../mesh/glmesh.hpp" #include "../mesh/glmesh.hpp"
namespace Sim::Graphics::monitor namespace Sim::Graphics::Monitor
{ {
class PrimaryLoop class PrimaryLoop

2
src/graphics/monitor/secondary_loop.hpp
View File

@ -3,7 +3,7 @@
#include "../mesh/glmesh.hpp" #include "../mesh/glmesh.hpp"
namespace Sim::Graphics::monitor namespace Sim::Graphics::Monitor
{ {
class SecondaryLoop class SecondaryLoop

2
src/graphics/monitor/turbine.hpp
View File

@ -3,7 +3,7 @@
#include "../mesh/glmesh.hpp" #include "../mesh/glmesh.hpp"
namespace Sim::Graphics::monitor namespace Sim::Graphics::Monitor
{ {
class Turbine class Turbine

2
src/graphics/monitor/vessel.cpp
View File

@ -78,7 +78,7 @@ void Vessel::update(double dt)
continue; continue;
} }
auto br = (Sim::Reactor::control::BoronRod*)r; auto br = (Sim::Reactor::Control::BoronRod*)r;
double v = br->get_inserted(); double v = br->get_inserted();
if(v > crod_max) if(v > crod_max)

2
src/graphics/monitor/vessel.hpp
View File

@ -3,7 +3,7 @@
#include "../mesh/glmesh.hpp" #include "../mesh/glmesh.hpp"
namespace Sim::Graphics::monitor namespace Sim::Graphics::Monitor
{ {
class Vessel class Vessel

30
src/graphics/ui.cpp
View File

@ -18,8 +18,8 @@
using namespace Sim::Graphics; using namespace Sim::Graphics;
static GLMesh StaticMeshData; static GLMesh s_mesh;
static widget::Clock WidgetClock; static Widget::Clock w_clock;
void UI::init() void UI::init()
{ {
@ -27,24 +27,24 @@ void UI::init()
unsigned int handle = Texture::handle_white; unsigned int handle = Texture::handle_white;
const unsigned int indices[] = {0, 1, 3, 0, 3, 2}; const unsigned int indices[] = {0, 1, 3, 0, 3, 2};
const Arrays::vertex vertices[] = { const Arrays::Vertex vertices[] = {
Arrays::vertex(handle, {0, 0}, {-1, -1, 0, 1}, {0, 0, -1}), Arrays::Vertex(handle, {0, 0}, {-1, -1, 0, 1}, {0, 0, -1}),
Arrays::vertex(handle, {0, 1}, {-1, 1, 0, 1}, {0, 0, -1}), Arrays::Vertex(handle, {0, 1}, {-1, 1, 0, 1}, {0, 0, -1}),
Arrays::vertex(handle, {1, 0}, { 1, -1, 0, 1}, {0, 0, -1}), Arrays::Vertex(handle, {1, 0}, { 1, -1, 0, 1}, {0, 0, -1}),
Arrays::vertex(handle, {1, 1}, { 1, 1, 0, 1}, {0, 0, -1}), Arrays::Vertex(handle, {1, 1}, { 1, 1, 0, 1}, {0, 0, -1}),
}; };
m.set_indices(indices, 6); m.set_indices(indices, 6);
m.set_vertices(vertices, 4); m.set_vertices(vertices, 4);
StaticMeshData.bind(); s_mesh.bind();
StaticMeshData.set(m, GL_STATIC_DRAW); s_mesh.set(m, GL_STATIC_DRAW);
StaticMeshData.colour_matrix = glm::scale(glm::mat4(1), glm::vec3(1) * 0.75f); s_mesh.colour_matrix = glm::scale(glm::mat4(1), glm::vec3(1) * 0.75f);
} }
void UI::update(double dt) void UI::update(double dt)
{ {
WidgetClock.update(dt); w_clock.update(dt);
} }
void UI::render() void UI::render()
@ -58,10 +58,10 @@ void UI::render()
glUniformMatrix4fv(Shader::gl_projection, 1, false, &mat_projection[0][0]); glUniformMatrix4fv(Shader::gl_projection, 1, false, &mat_projection[0][0]);
glUniformMatrix4fv(Shader::gl_camera, 1, false, &mat_camera[0][0]); glUniformMatrix4fv(Shader::gl_camera, 1, false, &mat_camera[0][0]);
StaticMeshData.bind(); s_mesh.bind();
StaticMeshData.uniform(); s_mesh.uniform();
StaticMeshData.render(); s_mesh.render();
WidgetClock.render(); w_clock.render();
} }

2
src/graphics/widget/clock.hpp
View File

@ -3,7 +3,7 @@
#include "../mesh/glmesh.hpp" #include "../mesh/glmesh.hpp"
namespace Sim::Graphics::widget namespace Sim::Graphics::Widget
{ {
struct Clock struct Clock

10
src/graphics/window.cpp
View File

@ -33,11 +33,11 @@ static GLFWwindow* win;
static bool win_should_close = false; static bool win_should_close = false;
static GLMesh mesh_scene; static GLMesh mesh_scene;
static monitor::Vessel monitor_vessel; static Monitor::Vessel monitor_vessel;
static monitor::Core monitor_core; static Monitor::Core monitor_core;
static monitor::PrimaryLoop monitor_primary_loop; static Monitor::PrimaryLoop monitor_primary_loop;
static monitor::SecondaryLoop monitor_secondary_loop; static Monitor::SecondaryLoop monitor_secondary_loop;
static monitor::Turbine monitor_turbine; static Monitor::Turbine monitor_turbine;
glm::mat4 Window::projection_matrix; glm::mat4 Window::projection_matrix;

24
src/reactor/builder.cpp
View File

@ -11,7 +11,7 @@
using namespace Sim::Reactor; using namespace Sim::Reactor;
Sim::Reactor::Reactor Sim::Reactor::Builder(const int W, const int H, const double CW, const double CH, fuel::FuelRod fr, coolant::Vessel* v, const char** lines) Sim::Reactor::Reactor Sim::Reactor::Builder(const int W, const int H, const double CW, const double CH, Fuel::FuelRod fr, Coolant::Vessel* v, const char** lines)
{ {
std::vector<std::unique_ptr<Rod>> arr(W * H); std::vector<std::unique_ptr<Rod>> arr(W * H);
@ -24,19 +24,19 @@ Sim::Reactor::Reactor Sim::Reactor::Builder(const int W, const int H, const doub
switch(c) switch(c)
{ {
case 'F': case 'F':
r = std::make_unique<fuel::FuelRod>(fr); r = std::make_unique<Fuel::FuelRod>(fr);
break; break;
case 'C': case 'C':
r = std::make_unique<control::BoronRod>(v); r = std::make_unique<Control::BoronRod>(v);
break; break;
case 'G': case 'G':
r = std::make_unique<control::GraphiteRod>(); r = std::make_unique<Control::GraphiteRod>();
break; break;
case 'H': case 'H':
r = std::make_unique<coolant::Heater>(); r = std::make_unique<Coolant::Heater>();
break; break;
case 'P': case 'P':
r = std::make_unique<coolant::Pipe>(v); r = std::make_unique<Coolant::Pipe>(v);
break; break;
default: default:
r = std::make_unique<Rod>(); r = std::make_unique<Rod>();
@ -49,22 +49,22 @@ Sim::Reactor::Reactor Sim::Reactor::Builder(const int W, const int H, const doub
return Reactor(&arr[0], W, H, CW, CH); return Reactor(&arr[0], W, H, CW, CH);
} }
std::unique_ptr<Rod> Sim::Reactor::load_rod(const Json::Value& node, coolant::Vessel* v) std::unique_ptr<Rod> Sim::Reactor::load_rod(const Json::Value& node, Coolant::Vessel* v)
{ {
int id = node["id"].asInt(); int id = node["id"].asInt();
switch(id) switch(id)
{ {
case 1: case 1:
return std::make_unique<fuel::FuelRod>(node); return std::make_unique<Fuel::FuelRod>(node);
case 2: case 2:
return std::make_unique<coolant::Pipe>(node, v); return std::make_unique<Coolant::Pipe>(node, v);
case 3: case 3:
return std::make_unique<coolant::Heater>(node); return std::make_unique<Coolant::Heater>(node);
case 4: case 4:
return std::make_unique<control::GraphiteRod>(node); return std::make_unique<Control::GraphiteRod>(node);
case 5: case 5:
return std::make_unique<control::BoronRod>(node, v); return std::make_unique<Control::BoronRod>(node, v);
} }
return std::make_unique<Rod>(); return std::make_unique<Rod>();

4
src/reactor/builder.hpp
View File

@ -11,8 +11,8 @@
namespace Sim::Reactor namespace Sim::Reactor
{ {
Reactor Builder(const int W, const int H, const double CW, const double CH, fuel::FuelRod fr, coolant::Vessel* v, const char** lines); Reactor Builder(const int W, const int H, const double CW, const double CH, Fuel::FuelRod fr, Coolant::Vessel* v, const char** lines);
std::unique_ptr<Rod> load_rod(const Json::Value& node, coolant::Vessel* v); std::unique_ptr<Rod> load_rod(const Json::Value& node, Coolant::Vessel* v);
}; };

6
src/reactor/control/boron_rod.cpp
View File

@ -9,7 +9,7 @@ constexpr double boron_density = 2340000; // g/m^3
constexpr double boron_molar_mass = 10; // g/mol constexpr double boron_molar_mass = 10; // g/mol
constexpr double boron_molar_density = boron_density / boron_molar_mass; // mol/m^3 constexpr double boron_molar_density = boron_density / boron_molar_mass; // mol/m^3
BoronRod::BoronRod(const Json::Value& node, coolant::Vessel* v) : coolant::Pipe(node, v) BoronRod::BoronRod(const Json::Value& node, Coolant::Vessel* v) : Coolant::Pipe(node, v)
{ {
inserted = node["inserted"].asDouble(); inserted = node["inserted"].asDouble();
absorbed = node["absorbed"].asDouble(); absorbed = node["absorbed"].asDouble();
@ -17,13 +17,13 @@ BoronRod::BoronRod(const Json::Value& node, coolant::Vessel* v) : coolant::Pipe(
Json::Value BoronRod::serialize() const Json::Value BoronRod::serialize() const
{ {
Json::Value node(coolant::Pipe::serialize()); Json::Value node(Coolant::Pipe::serialize());
node["inserted"] = inserted; node["inserted"] = inserted;
node["absorbed"] = absorbed; node["absorbed"] = absorbed;
return node; return node;
} }
BoronRod::BoronRod(coolant::Vessel* v) : coolant::Pipe(v) BoronRod::BoronRod(Coolant::Vessel* v) : Coolant::Pipe(v)
{ {
} }

8
src/reactor/control/boron_rod.hpp
View File

@ -3,10 +3,10 @@
#include "../coolant/pipe.hpp" #include "../coolant/pipe.hpp"
namespace Sim::Reactor::control namespace Sim::Reactor::Control
{ {
class BoronRod : public coolant::Pipe class BoronRod : public Coolant::Pipe
{ {
double inserted = 1; double inserted = 1;
double absorbed = 0; double absorbed = 0;
@ -18,8 +18,8 @@ class BoronRod : public coolant::Pipe
public: public:
BoronRod(coolant::Vessel* v); BoronRod(Coolant::Vessel* v);
BoronRod(const Json::Value& node, coolant::Vessel* v); BoronRod(const Json::Value& node, Coolant::Vessel* v);
virtual Json::Value serialize() const; virtual Json::Value serialize() const;
virtual void update(double secs); virtual void update(double secs);

2
src/reactor/control/graphite_rod.hpp
View File

@ -3,7 +3,7 @@
#include "../rod.hpp" #include "../rod.hpp"
namespace Sim::Reactor::control namespace Sim::Reactor::Control
{ {
class GraphiteRod : public Sim::Reactor::Rod class GraphiteRod : public Sim::Reactor::Rod

2
src/reactor/coolant/heater.hpp
View File

@ -3,7 +3,7 @@
#include "../rod.hpp" #include "../rod.hpp"
namespace Sim::Reactor::coolant namespace Sim::Reactor::Coolant
{ {
class Heater : public Sim::Reactor::Rod class Heater : public Sim::Reactor::Rod

4
src/reactor/coolant/pipe.cpp
View File

@ -4,13 +4,13 @@
using namespace Sim::Reactor::Coolant; using namespace Sim::Reactor::Coolant;
Pipe::Pipe(coolant::Vessel* v) Pipe::Pipe(Coolant::Vessel* v)
{ {
this->vessel = v; this->vessel = v;
this->steam = 0; this->steam = 0;
} }
Pipe::Pipe(const Json::Value& node, coolant::Vessel* v) : vessel(v) Pipe::Pipe(const Json::Value& node, Coolant::Vessel* v) : vessel(v)
{ {
steam = node["steam"].asDouble(); steam = node["steam"].asDouble();
} }

8
src/reactor/coolant/pipe.hpp
View File

@ -4,14 +4,14 @@
#include "vessel.hpp" #include "vessel.hpp"
#include "../rod.hpp" #include "../rod.hpp"
namespace Sim::Reactor::coolant namespace Sim::Reactor::Coolant
{ {
class Pipe : public Sim::Reactor::Rod class Pipe : public Sim::Reactor::Rod
{ {
protected: protected:
coolant::Vessel* vessel; Coolant::Vessel* vessel;
double steam; double steam;
virtual double get_k(Sim::Reactor::Rod::val_t type) const; virtual double get_k(Sim::Reactor::Rod::val_t type) const;
@ -22,8 +22,8 @@ protected:
public: public:
Pipe(coolant::Vessel* v); Pipe(Coolant::Vessel* v);
Pipe(const Json::Value& node, coolant::Vessel* v); Pipe(const Json::Value& node, Coolant::Vessel* v);
virtual Json::Value serialize() const; virtual Json::Value serialize() const;
virtual std::unique_ptr<Rod> clone() const { return std::make_unique<Pipe>(*this); } virtual std::unique_ptr<Rod> clone() const { return std::make_unique<Pipe>(*this); }

2
src/reactor/coolant/vessel.cpp
View File

@ -67,7 +67,7 @@ void Vessel::update(double secs)
steam_last = steam; steam_last = steam;
steam_suspended += diff; steam_suspended += diff;
steam_suspended *= Reactor::fuel::half_life::get(secs, bubble_hl); steam_suspended *= Reactor::Fuel::half_life::get(secs, bubble_hl);
if(steam_suspended < 0) if(steam_suspended < 0)
{ {

2
src/reactor/coolant/vessel.hpp
View File

@ -5,7 +5,7 @@
#include "../../coolant/fluid_holder.hpp" #include "../../coolant/fluid_holder.hpp"
namespace Sim::Reactor::coolant namespace Sim::Reactor::Coolant
{ {
class Vessel : public Sim::Coolant::FluidHolder class Vessel : public Sim::Coolant::FluidHolder

2
src/reactor/fuel/fuel_rod.hpp
View File

@ -4,7 +4,7 @@
#include "sample.hpp" #include "sample.hpp"
#include "../rod.hpp" #include "../rod.hpp"
namespace Sim::Reactor::fuel namespace Sim::Reactor::Fuel
{ {
class FuelRod : public Sim::Reactor::Rod class FuelRod : public Sim::Reactor::Rod

2
src/reactor/fuel/half_life.hpp
View File

@ -3,7 +3,7 @@
#include <cmath> #include <cmath>
namespace Sim::Reactor::fuel::half_life namespace Sim::Reactor::Fuel::half_life
{ {
const double Te_135 = 19; const double Te_135 = 19;

4
src/reactor/fuel/sample.hpp
View File

@ -5,14 +5,14 @@
#include <ostream> #include <ostream>
namespace Sim::Reactor::fuel namespace Sim::Reactor::Fuel
{ {
class Sample class Sample
{ {
constexpr static const double Xe_135_M = 1e6; constexpr static const double Xe_135_M = 1e6;
Sim::Reactor::fuel::Waste waste; Sim::Reactor::Fuel::Waste waste;
// mol // mol
double fuel = 0; double fuel = 0;

2
src/reactor/fuel/waste.hpp
View File

@ -3,7 +3,7 @@
#include <json/json.h> #include <json/json.h>
namespace Sim::Reactor::fuel namespace Sim::Reactor::Fuel
{ {
class Waste class Waste

2
src/reactor/reactor.cpp
View File

@ -246,7 +246,7 @@ void Reactor::get_stats(Rod::val_t type, double& min, double& max)
} }
} }
Reactor::Reactor(const Json::Value& node, coolant::Vessel* v) : Reactor::Reactor(const Json::Value& node, Coolant::Vessel* v) :
cell_width(node["cell_width"].asDouble()), cell_width(node["cell_width"].asDouble()),
cell_height(node["cell_height"].asDouble()), cell_height(node["cell_height"].asDouble()),
width(node["width"].asInt()), width(node["width"].asInt()),

2
src/reactor/reactor.hpp
View File

@ -27,7 +27,7 @@ struct Reactor
int cursor; int cursor;
Reactor(std::unique_ptr<Rod>* rods, int width, int height, double cell_width, double cell_height); Reactor(std::unique_ptr<Rod>* rods, int width, int height, double cell_width, double cell_height);
Reactor(const Json::Value& node, coolant::Vessel* v); Reactor(const Json::Value& node, Coolant::Vessel* v);
Reactor(const Reactor& r); Reactor(const Reactor& r);
Reactor(Reactor&& r); Reactor(Reactor&& r);

6
src/system.cpp
View File

@ -38,8 +38,8 @@ System::System()
" C C C C " " C C C C "
}; };
vessel = std::make_unique<Reactor::coolant::Vessel>(Sim::Coolant::WATER, 8, 10, 6e6, 5e5, 10); vessel = std::make_unique<Reactor::Coolant::Vessel>(Sim::Coolant::WATER, 8, 10, 6e6, 5e5, 10);
reactor = std::make_unique<Reactor::Reactor>(Sim::Reactor::Builder(19, 19, 1.0 / 4.0, 4, Reactor::fuel::FuelRod(0.2), vessel.get(), layout)); reactor = std::make_unique<Reactor::Reactor>(Sim::Reactor::Builder(19, 19, 1.0 / 4.0, 4, Reactor::Fuel::FuelRod(0.2), vessel.get(), layout));
condenser = std::make_unique<Coolant::Condenser>(Sim::Coolant::WATER, 6, 4, 3e6, 30000); condenser = std::make_unique<Coolant::Condenser>(Sim::Coolant::WATER, 6, 4, 3e6, 30000);
turbine = std::make_unique<Electric::Turbine>(Sim::Coolant::WATER, condenser.get(), 6, 3, 2e6); turbine = std::make_unique<Electric::Turbine>(Sim::Coolant::WATER, condenser.get(), 6, 3, 2e6);
@ -59,7 +59,7 @@ System::System(const Json::Value& node)
{ {
clock = node["clock"].asDouble(); clock = node["clock"].asDouble();
vessel = std::make_unique<Reactor::coolant::Vessel>(node["vessel"]); vessel = std::make_unique<Reactor::Coolant::Vessel>(node["vessel"]);
reactor = std::make_unique<Reactor::Reactor>(node["reactor"], vessel.get()); reactor = std::make_unique<Reactor::Reactor>(node["reactor"], vessel.get());
condenser = std::make_unique<Coolant::Condenser>(node["condenser"]); condenser = std::make_unique<Coolant::Condenser>(node["condenser"]);
turbine = std::make_unique<Electric::Turbine>(node["turbine"], condenser.get()); turbine = std::make_unique<Electric::Turbine>(node["turbine"], condenser.get());

2
src/system.hpp
View File

@ -22,7 +22,7 @@ struct System
static System active; static System active;
std::unique_ptr<Sim::Reactor::Reactor> reactor; std::unique_ptr<Sim::Reactor::Reactor> reactor;
std::unique_ptr<Sim::Reactor::coolant::Vessel> vessel; std::unique_ptr<Sim::Reactor::Coolant::Vessel> vessel;
std::unique_ptr<Sim::Coolant::Sink> sink; std::unique_ptr<Sim::Coolant::Sink> sink;
std::unique_ptr<Sim::Coolant::Condenser> condenser; std::unique_ptr<Sim::Coolant::Condenser> condenser;