Blunkall-Technologies/Archimedes
2
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

sandbox

Browse Source
This commit is contained in:
Nathan
2026-02-13 08:24:03 -06:00
parent ec8a9c9f4f
commit f9f311c82b
12 changed files with 569 additions and 56 deletions
Download Patch File Download Diff File Expand all files Collapse all files

50
ExampleModules.nix
View File

@@ -215,6 +215,56 @@
'';
};
Sandbox = pkgs.stdenvNoCC.mkDerivation {
name = "Sandbox";
src = ./.;
imgui = inputs.imgui;
nativeBuildInputs = with pkgs; [
clang
];
buildInputs = with pkgs; [
glfw
glew
glm
curl
nlohmann_json
];
buildPhase = ''
clang++ \
modules/Archimedes-Modules/Sandbox/*.cpp \
modules/WindowModule/*.cpp \
modules/ImguiModule/*.cpp \
$imgui/backends/imgui_impl_glfw.cpp \
$imgui/backends/imgui_impl_opengl3.cpp \
$imgui/misc/cpp/*.cpp \
$imgui/*.cpp \
-DRENDERER_OPENGL=1 \
-DWINDOW_GLFW=1 \
-DSANDBOX_DYNAMIC \
-fpic -shared \
-I include -I $imgui -I . \
-lEGL -lglfw -lGLEW \
$(curl-config --cflags) \
$(curl-config --libs) \
-Wall \
-o $name -DIMGUI_IMPL_GLFW_DISABLE_X11
'';
installPhase = ''
mkdir -p $out/bin
cp $name $out/bin
'';
};
TestImgui = pkgs.stdenvNoCC.mkDerivation {
name = "TestImgui";

4
include/extratools.h
View File

@@ -2,6 +2,10 @@
#define EXTRATOOLS_H
#include <glm/glm.hpp>
#include <glm/gtc/matrix_transform.hpp>
#include <glm/gtc/type_ptr.hpp>
#include <nlohmann/json.hpp>
#include <curl/curl.h>

1
include/utils/Objects/Object.h
View File

@@ -15,6 +15,7 @@ namespace Archimedes {
private:
glm::mat4 worldTransform = glm::mat4(1.0f);
};
}

27
include/utils/Renderer/RenderTarget.h
View File

@@ -44,6 +44,8 @@ namespace Archimedes {
VertexBuffer(const void* data, size_t size) : data(data), size(size) {
}
VertexBuffer() {}
~VertexBuffer() {}
const void* getData() const { return data; }
@@ -74,6 +76,8 @@ namespace Archimedes {
IndexArray(const unsigned int* indices, size_t count) : indices(indices), count(count) {
}
IndexArray() {}
~IndexArray() {}
const void* getIndicies() const { return indices; }
@@ -95,7 +99,15 @@ namespace Archimedes {
FromFileBin
};
Shader(const std::string& vs, const std::string& fs, LoadType loadType) : loadType(loadType) {
Shader() {}
Shader(const std::string& vs, const std::string& fs, LoadType loadType) {
init(vs, fs, loadType);
}
~Shader() {}
void init(const std::string& vs, const std::string& fs, LoadType loadType) {
switch(loadType) {
case LoadType::FromSource:
this->vs = vs;
@@ -114,16 +126,11 @@ namespace Archimedes {
}
}
~Shader() {}
std::string getVSource() const { return vs; }
std::string getFSource() const { return fs; }
unsigned int id;
private:
LoadType loadType;
std::string vs;
std::string fs;
@@ -165,6 +172,8 @@ namespace Archimedes {
}
RenderTarget() {}
~RenderTarget() {}
//private:
@@ -173,11 +182,13 @@ namespace Archimedes {
VertexArray vertexArray;
VertexLayout layout;
IndexArray indexArray;
VertexLayout layout;
Shader shader;
glm::mat4 transform = glm::mat4(1.0f);
};
}

18
include/utils/Renderer/Renderer.h
View File

@@ -26,18 +26,18 @@ namespace Archimedes {
virtual Shader createShader(const std::string& vs, const std::string& fs, const Shader::LoadType& lt) = 0;
virtual RenderTarget* createRenderTarget(
const void* data,
size_t size,
unsigned int* indices,
size_t count,
virtual void useShader(Shader& shader) = 0;
virtual RenderTarget createRenderTarget(
VertexBuffer vb,
IndexArray ia,
VertexLayout layout,
const std::string& vs,
const std::string& fs,
const Shader::LoadType& lt
Shader& s
) = 0;
virtual void draw(const RenderTarget*) = 0;
virtual void useRenderTarget(RenderTarget& rt) = 0;
virtual void draw(const RenderTarget&) = 0;
virtual Renderer* getRendererImpl() = 0;

126
include/utils/Renderer/RendererImpl/RendererOpenGL/RendererOpenGL.h
View File

@@ -22,14 +22,20 @@ namespace Archimedes {
~RendererOpenGL() {};
bool init() override {
return glewInit() == GLEW_OK;
bool ok = glewInit() == GLEW_OK;
if(ok) {
glEnable(GL_DEPTH_TEST);
}
return ok;
};
void render() override {
glViewport(0, 0, w, h);
glClearColor(clearColor.r, clearColor.g, clearColor.b, clearColor.a);
glClear(GL_COLOR_BUFFER_BIT);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
}
@@ -86,30 +92,73 @@ namespace Archimedes {
return shader;
}
RenderTarget* createRenderTarget(const void* data, size_t size, unsigned int* indices, size_t count, VertexLayout layout, const std::string& vs, const std::string& fs, const Shader::LoadType& lt) override {
void useShader(Shader& shader) override {
VertexBuffer vb(data, size);
std::string vss = shader.getVSource();
std::string fss = shader.getFSource();
IndexArray ia(indices, count);
const char* vsc = vss.c_str();
const char* fsc = fss.c_str();
Shader s = createShader(vs, fs, lt);
unsigned int vertexShader = glCreateShader(GL_VERTEX_SHADER);
glShaderSource(vertexShader, 1, &vsc, NULL);
glCompileShader(vertexShader);
// check for shader compile errors
int success;
char infoLog[512];
glGetShaderiv(vertexShader, GL_COMPILE_STATUS, &success);
if (!success)
{
glGetShaderInfoLog(vertexShader, 512, NULL, infoLog);
std::cout << "ERROR::SHADER::VERTEX::COMPILATION_FAILED\n" << infoLog << std::endl;
}
// fragment shader
unsigned int fragmentShader = glCreateShader(GL_FRAGMENT_SHADER);
glShaderSource(fragmentShader, 1, &fsc, NULL);
glCompileShader(fragmentShader);
// check for shader compile errors
glGetShaderiv(fragmentShader, GL_COMPILE_STATUS, &success);
if (!success)
{
glGetShaderInfoLog(fragmentShader, 512, NULL, infoLog);
std::cout << "ERROR::SHADER::FRAGMENT::COMPILATION_FAILED\n" << infoLog << std::endl;
}
// link shaders
unsigned int shaderProgram = glCreateProgram();
glAttachShader(shaderProgram, vertexShader);
glAttachShader(shaderProgram, fragmentShader);
glLinkProgram(shaderProgram);
// check for linking errors
glGetProgramiv(shaderProgram, GL_LINK_STATUS, &success);
if (!success) {
glGetProgramInfoLog(shaderProgram, 512, NULL, infoLog);
std::cout << "ERROR::SHADER::PROGRAM::LINKING_FAILED\n" << infoLog << std::endl;
}
glDeleteShader(vertexShader);
glDeleteShader(fragmentShader);
auto rt = new RenderTarget(vb, ia, layout, s);
shader.id = shaderProgram;
glGenVertexArrays(1, &rt->vertexArray.id);
}
glGenBuffers(1, &rt->vertexBuffer.id);
RenderTarget createRenderTarget(VertexBuffer vb, IndexArray ia, VertexLayout layout, Shader& s) override {
glBindVertexArray(rt->vertexArray.id);
auto rt = RenderTarget(vb, ia, layout, s);
glBindBuffer(GL_ARRAY_BUFFER, rt->vertexBuffer.id);
glBufferData(GL_ARRAY_BUFFER, sizeof(float) * 6, data, GL_STATIC_DRAW);
glGenVertexArrays(1, &rt.vertexArray.id);
glGenBuffers(1, &rt.vertexBuffer.id);
glBindVertexArray(rt.vertexArray.id);
glBindBuffer(GL_ARRAY_BUFFER, rt.vertexBuffer.id);
glBufferData(GL_ARRAY_BUFFER, vb.getSize(), vb.getData(), GL_STATIC_DRAW);
glGenBuffers(1, &rt->indexArray.id);
glGenBuffers(1, &rt.indexArray.id);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, rt->indexArray.id);
glBufferData(GL_ELEMENT_ARRAY_BUFFER, count * sizeof(unsigned int), indices, GL_STATIC_DRAW);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, rt.indexArray.id);
glBufferData(GL_ELEMENT_ARRAY_BUFFER, rt.indexArray.getCount() * sizeof(unsigned int), rt.indexArray.getIndicies(), GL_STATIC_DRAW);
glUseProgram(s.id);
@@ -124,13 +173,52 @@ namespace Archimedes {
return rt;
};
void draw(const RenderTarget* rt) override {
void useRenderTarget(RenderTarget& rt) override {
glUseProgram(rt->shader.id);
glGenVertexArrays(1, &rt.vertexArray.id);
glBindVertexArray(rt->vertexArray.id);
glGenBuffers(1, &rt.vertexBuffer.id);
glDrawElements(GL_TRIANGLES, rt->indexArray.getCount(), GL_UNSIGNED_INT, nullptr);
glBindVertexArray(rt.vertexArray.id);
glBindBuffer(GL_ARRAY_BUFFER, rt.vertexBuffer.id);
glBufferData(GL_ARRAY_BUFFER, rt.vertexBuffer.getSize(), rt.vertexBuffer.getData(), GL_STATIC_DRAW);
glGenBuffers(1, &rt.indexArray.id);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, rt.indexArray.id);
glBufferData(GL_ELEMENT_ARRAY_BUFFER, rt.indexArray.getCount() * sizeof(unsigned int), rt.indexArray.getIndicies(), GL_STATIC_DRAW);
glUseProgram(rt.shader.id);
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 3 * sizeof(float), (void*)0);
glEnableVertexAttribArray(0);
glBindVertexArray(0);
glBindBuffer(GL_ARRAY_BUFFER, 0);
};
void draw(const RenderTarget& rt) override {
glUseProgram(rt.shader.id);
unsigned int transformLoc = glGetUniformLocation(rt.shader.id, "model");
glUniformMatrix4fv(transformLoc, 1, GL_FALSE, glm::value_ptr(rt.transform));
unsigned int resLoc = glGetUniformLocation(rt.shader.id, "res");
glUniform2ui(resLoc, w, h);
unsigned int ccLoc = glGetUniformLocation(rt.shader.id, "clearColor");
glUniform4f(ccLoc, clearColor.r, clearColor.g, clearColor.b, clearColor.a);
glBindVertexArray(rt.vertexArray.id);
glDrawElements(GL_TRIANGLES, rt.indexArray.getCount(), GL_UNSIGNED_INT, nullptr);
glBindVertexArray(0);
}

11
include/utils/Window/Window.h
View File

@@ -39,8 +39,17 @@ namespace Archimedes {
h = this->h;
}
virtual void setSize(const int& w, const int& h) {
this->w = w;
this->h = h;
}
Renderer* getRenderer() { return renderer; }
void setRenderer(Renderer* r) { renderer = r; }
void setRenderer(Renderer* r) {
renderer = r;
renderer->w = w;
renderer->h = h;
}
virtual Window* getWindowImpl() = 0;

7
include/utils/Window/WindowImpl/WindowGLFW/WindowGLFW.h
View File

@@ -116,6 +116,13 @@ namespace Archimedes {
return glfwWindowShouldClose(window);
}
void setSize(const int& w, const int& h) override {
this->w = w;
this->h = h;
glfwSetWindowSize(window, w, h);
}
void restoreContext() override { glfwMakeContextCurrent(window); }
void getSize(int& w, int& h) override {

9
include/utils/Window/WindowImpl/WindowSDL3/WindowSDL3.h
View File

@@ -141,15 +141,6 @@ namespace Archimedes {
#ifdef RENDERER_OPENGL
void restoreContext() override { SDL_GL_MakeCurrent(window, gl_context); }
#endif
void getSize(int& w, int& h) override {
w = this->w;
h = this->h;
}
void setSize(int& w, int& h) {
this->w = w;
this->h = h;
}
SDL_Window* getWindow() { return window; }
#ifdef RENDERER_OPENGL

191
modules/Archimedes-Modules/Sandbox/Sandbox.cpp Normal file
View File

@@ -0,0 +1,191 @@
// This only works with opengl!!!!
#include "Sandbox.h"
Sandbox::Sandbox(Archimedes::App* a, void* h) : Archimedes::Module(a, h) {
name = "Sandbox";
WindowModule* wm = new WindowModule(a, h);
deps[*wm] = wm;
ImguiModule* im = new ImguiModule(a, h);
deps[*im] = im;
}
Sandbox::~Sandbox() {
if(app) {
WindowModule* wm; { wm = (WindowModule*) moduleInstances[WindowModule()]; }
ImguiModule* im; { im = (ImguiModule*) moduleInstances[ImguiModule()]; }
im->releaseContext(ImGui::GetCurrentContext());
wm->releaseWindow(window);
}
}
void Sandbox::onLoad() {
// get window
WindowModule* wm; { wm = (WindowModule*) moduleInstances[WindowModule()]; }
ImguiModule* im; { im = (ImguiModule*) moduleInstances[ImguiModule()]; }
if(!wm) {
std::cout << "No WindowModule for Sandbox!\n";
std::abort();
}
if(!im) {
std::cout << "No ImguiModule for Sandbox!\n";
std::abort();
}
window = wm->aquireWindow();
ImGui::SetCurrentContext(im->aquireContext());
window->getRenderer()->clearColor = { 0.2, 0.2, 0.4, 0.7 };
gridShader = Archimedes::Shader(cubeVS, gridFS, Archimedes::Shader::LoadType::FromSource);
window->getRenderer()->useShader(gridShader);
grid = Archimedes::RenderTarget(
Archimedes::VertexBuffer(gridVertices, 12 * sizeof(float)),
Archimedes::IndexArray(gridIndices, 6),
Archimedes::VertexLayout(),
gridShader
);
window->getRenderer()->useRenderTarget(grid);
cubeShader = Archimedes::Shader(cubeVS, cubeFS, Archimedes::Shader::LoadType::FromSource);
window->getRenderer()->useShader(cubeShader);
cube = Archimedes::RenderTarget(
Archimedes::VertexBuffer(vertices, 24 * sizeof(float)),
Archimedes::IndexArray(indices, 36),
Archimedes::VertexLayout(),
cubeShader
);
window->getRenderer()->useRenderTarget(cube);
int w, h;
window->getSize(w, h);
app->emitEvent(new Archimedes::ResizeWindowEvent(w, h));
}
void Sandbox::run() {
static float scale = 100.0f;
static glm::vec3 pos(0), rot(0);
static glm::vec3 camPos(0.0f, 0.0f, 3.0f), camRot(0.0f, 0.0f, 0.0f);
static glm::mat4 orthoCamera, perspCamera, cameraTransform;
cameraTransform = glm::mat4(1.0f);
cameraTransform = glm::translate(cameraTransform, camPos);
cameraTransform = glm::rotate(cameraTransform, camRot.x, glm::vec3(1.0f, 0.0f, 0.0f));
cameraTransform = glm::rotate(cameraTransform, camRot.y, glm::vec3(0.0f, 1.0f, 0.0f));
cameraTransform = glm::rotate(cameraTransform, camRot.z, glm::vec3(0.0f, 0.0f, 1.0f));
int w, h;
window->getSize(w, h);
orthoCamera = glm::ortho(-(float)w / 2.0f, (float)w / 2.0f, -(float)h / 2.0f, (float)h / 2.0f, 0.1f, 100.0f)
* cameraTransform;
perspCamera = glm::perspective(glm::radians(45.0f), (float)w/(float)h, 0.1f, 100.0f)
* cameraTransform;
glm::mat4& cubeTransform = cube.transform;
//glm::mat4& gridTransform = grid.transform;
cubeTransform = glm::mat4(1.0f);
cubeTransform = glm::translate(cubeTransform, pos);
cubeTransform = glm::rotate(cubeTransform, rot.x, glm::vec3(1.0f, 0.0f, 0.0f));
cubeTransform = glm::rotate(cubeTransform, rot.y, glm::vec3(0.0f, 1.0f, 0.0f));
cubeTransform = glm::rotate(cubeTransform, rot.z, glm::vec3(0.0f, 0.0f, 1.0f));
cubeTransform = glm::scale(cubeTransform, glm::vec3(scale));
//gridTransform = glm::mat4(1.0f);
//gridTransform = glm::scale(gridTransform, glm::vec3(800.0f));
cubeTransform = orthoCamera * cubeTransform;
//gridTransform = orthoCamera * gridTransform;
/*
cubeTransform = glm::perspective(glm::radians(45.0f), (float)w/(float)h, 0.1f, 100.0f)
* glm::lookAt(glm::vec3(0.0f, 0.0f, 3.0f), glm::vec3(0.0f, 0.0f, 0.0f), glm::vec3(0.0f, 1.0f, 0.0f))
* cubeTransform;
*/
//window->getRenderer()->draw(grid);
window->getRenderer()->draw(cube);
{
ImGuiIO& io = ImGui::GetIO();
static glm::vec4& clearColor = window->getRenderer()->clearColor;
ImGui::Begin("Sandbox Module");
ImGui::Text("Pick a clear color!");
ImGui::SliderFloat("r", &clearColor.r, 0.0f, 1.0f);
ImGui::SliderFloat("g", &clearColor.g, 0.0f, 1.0f);
ImGui::SliderFloat("b", &clearColor.b, 0.0f, 1.0f);
ImGui::SliderFloat("a", &clearColor.a, 0.0f, 1.0f);
ImGui::Text("Properties");
ImGui::SliderFloat("pitch", &rot.x, -3.14159265359f, 3.14159265359f);
ImGui::SliderFloat("yaw", &rot.y, -3.14159265359f, 3.14159265359f);
ImGui::SliderFloat("roll", &rot.z, -3.14159265359f, 3.14159265359f);
ImGui::SliderFloat("scale", &scale, 0.1f, 1000.0f);
ImGui::SliderFloat("x", &pos.x, -100.0f, 100.0f);
ImGui::SliderFloat("y", &pos.y, -100.0f, 100.0f);
ImGui::SliderFloat("z", &pos.z, -100.0f, 100.0f);
ImGui::Text("Camera Properties");
ImGui::SliderFloat("c_pitch", &camRot.x, -3.14159265359f, 3.14159265359f);
ImGui::SliderFloat("c_yaw", &camRot.y, -3.14159265359f, 3.14159265359f);
ImGui::SliderFloat("c_roll", &camRot.z, -3.14159265359f, 3.14159265359f);
ImGui::SliderFloat("c_x", &camPos.x, -100.0f, 100.0f);
ImGui::SliderFloat("c_y", &camPos.y, -100.0f, 100.0f);
ImGui::SliderFloat("c_z", &camPos.z, -100.0f, 100.0f);
if(ImGui::Button("Reset Window Size")) {
app->emitEvent(new Archimedes::ResizeWindowEvent(500, 500));
}
ImGui::Text("Application average %.3f ms/frame (%.1f FPS)", 1000.0f / io.Framerate, io.Framerate);
ImGui::End();
}
}
bool Sandbox::onEvent(const Archimedes::Event& e) {
return false;
}

161
modules/Archimedes-Modules/Sandbox/Sandbox.h Normal file
View File

@@ -0,0 +1,161 @@
// This only works with opengl!!!!
#include "Archimedes.h"
#include "modules/WindowModule/WindowModule.h"
#include "modules/ImguiModule/ImguiModule.h"
class Sandbox : public Archimedes::Module {
public:
Sandbox(Archimedes::App*, void*);
Sandbox() { name = "Sandbox"; }
~Sandbox();
void onLoad() override;
void run() override;
bool onEvent(const Archimedes::Event& e) override;
private:
Archimedes::Window* window;
std::string cubeVS = "#version 330 core\n"
"layout (location = 0) in vec3 aPos;\n"
"uniform mat4 model;\n"
"uniform uvec2 res;\n"
"uniform vec4 clearColor;\n"
"void main()\n"
"{\n"
" gl_Position = model * vec4(aPos.x, aPos.y, aPos.z, 1.0);\n"
"}\0";
std::string cubeFS = "#version 330 core\n"
"out vec4 FragColor;\n"
"uniform mat4 model;\n"
"uniform uvec2 res;\n"
"uniform vec4 clearColor;\n"
"void main()\n"
"{\n"
" FragColor = vec4(0.6f, 0.1f, 0.1f, 1.0f);\n"
"}\n\0";
std::string gridFS = "#version 330 core\n"
"out vec4 FragColor;\n"
"uniform mat4 model;\n"
"uniform uvec2 res;\n"
"uniform vec4 clearColor;\n"
"vec2 pos = gl_FragCoord.xy - res / 2.0f;\n"
"int gridSpacing = 50;"
"void main()\n"
"{\n"
" switch((int(pos.x)) * (int(pos.y))) {\n"
" case 0:\n"
" FragColor = vec4(1.0f);\n"
" break;\n"
" default:\n"
" switch((int(pos.x) % gridSpacing) * (int(pos.y) % gridSpacing)) {\n"
" case 0:\n"
" FragColor = vec4(0.7f, 0.7f, 0.7f, 1.0f);\n"
" break;\n"
" default:\n"
" discard;\n"
" break;\n"
" }\n"
" break;\n"
" }\n"
"}\n\0";
Archimedes::Shader cubeShader, gridShader;
Archimedes::RenderTarget cube, grid;
float gridVertices[24] = {
-1.0f, 0.0f, 1.0f,
1.0f, 0.0f, 1.0f,
1.0f, 0.0f, -1.0f,
-1.0f, 0.0f, -1.0f,
};
unsigned int gridIndices[6] = {
0,
1,
2,
2,
3,
0
};
float vertices[24] = {
-0.5f, -0.5f, 0.5f,
0.5f, -0.5f, 0.5f,
0.5f, 0.5f, 0.5f,
-0.5f, 0.5f, 0.5f,
-0.5f, -0.5f, -0.5f,
0.5f, -0.5f, -0.5f,
0.5f, 0.5f, -0.5f,
-0.5f, 0.5f, -0.5f,
};
unsigned int indices[36] = {
0,
1,
2,
2,
3,
0,
4,
5,
6,
6,
7,
4,
0,
1,
5,
5,
4,
0,
3,
2,
6,
6,
7,
3,
0,
3,
7,
7,
4,
0,
1,
2,
6,
6,
5,
1,
};
};
#ifdef SANDBOX_DYNAMIC
typedef Sandbox mtype;
#include "endModule.h"
#endif

6
modules/WindowModule/WindowModule.cpp
View File

@@ -57,9 +57,9 @@ bool WindowModule::onEvent(const Archimedes::Event& e) {
Archimedes::ResizeWindowEvent& event = (Archimedes::ResizeWindowEvent&) e;
renderer->w = event.width;
renderer->h = event.height;
#if WINDOW == 2
window->getWindowImpl().setSize(event.width, event.height);
#endif
window->setSize(event.width, event.height);
return true;
} else if(type == app->getEventType(Archimedes::CloseWindowEvent())) {
app->emitEvent(new Archimedes::DoUnloadModuleEvent(name));