well that broke a lot - sounds like a tomorrow problem

src/inferno.cpp

@@ -27,8 +27,8 @@ std::unique_ptr<InfernoApp> inferno_create()
     // MOTD
     yolo::info("INFERNO HART v" INFERNO_VERSION);
 
-    std::unique_ptr<InfernoApp> app = std::make_unique<InfernoApp>();
+    std::unique_ptr<InfernoApp> app = new InfernoApp;
-    app->Input = std::make_unique<InfernoInput>();
+    app->Input = new InfernoInput;
 
     // Create window
     graphics::window_create("Inferno v" INFERNO_VERSION, 1280, 720);

src/inferno.hpp

@@ -24,17 +24,17 @@ typedef struct InfernoInput {
 } InfernoInput;
 
 typedef struct InfernoApp {
-    std::unique_ptr<InfernoInput> Input;
+    InfernoInput* Input;
-    std::unique_ptr<scene::Scene> Scene;
+    scene::Scene* Scene;
-    std::unique_ptr<graphics::PreviewRenderer> PreviewRenderer;
+    graphics::PreviewRenderer* PreviewRenderer;
-    // std::unique_ptr<graphics::RayRenderer> RayRenderer;
+    // graphics::RayRenderer* RayRenderer;
 } InfernoApp;
 
-std::unique_ptr<InfernoApp> inferno_create();
+InfernoApp* inferno_create();
-void inferno_cleanup(std::unique_ptr<InfernoApp>& app);
+void inferno_cleanup(InfernoApp* app);
-void inferno_preset_gui(std::unique_ptr<InfernoApp>& app);
+void inferno_preset_gui(InfernoApp* app);
-void inferno_move_input(std::unique_ptr<InfernoApp>& app);
+void inferno_move_input(InfernoApp* app);
-void inferno_stop_move_input(std::unique_ptr<InfernoApp>& app);
+void inferno_stop_move_input(InfernoApp* app);
-int inferno_run(std::unique_ptr<InfernoApp>& app);
+int inferno_run(InfernoApp* app);
 
 } // namespace inferno

src/preview_renderer/renderer.cpp

@@ -16,7 +16,7 @@ namespace inferno::graphics {
 
 std::unique_ptr<PreviewRenderer> preview_create()
 {
-    std::unique_ptr<PreviewRenderer> renderer = std::make_unique<PreviewRenderer>();
+    std::unique_ptr<PreviewRenderer> renderer = new PreviewRenderer;
 
     glGenFramebuffers(1, &renderer->RenderTarget);
     glBindFramebuffer(GL_FRAMEBUFFER, renderer->RenderTarget);

src/preview_renderer/renderer.hpp

@@ -20,11 +20,11 @@ typedef struct PreviewRenderer {
     GLuint RenderTargetDepthTexture = 0;
 } PreviewRenderer;
 
-std::unique_ptr<PreviewRenderer> preview_create();
+PreviewRenderer* preview_create();
-void preview_cleanup(std::unique_ptr<PreviewRenderer>& renderer);
+void preview_cleanup(PreviewRenderer* renderer);
 
-GLuint preview_get_rendered_texture(std::unique_ptr<PreviewRenderer>& renderer);
+GLuint preview_get_rendered_texture(PreviewRenderer* renderer);
 
-void preview_draw(std::unique_ptr<PreviewRenderer>& renderer, std::unique_ptr<scene::Scene>& scene);
+void preview_draw(PreviewRenderer* renderer, scene::Scene* scene);
 
 } // namespace inferno::graphics

src/preview_renderer/shader.cpp

@@ -25,7 +25,7 @@ std::string textFromFile(const std::filesystem::path& path)
         std::istreambuf_iterator<char>());
 }
 
-std::vector<const ShaderPreprocessorDefinition*> getKeys(std::unique_ptr<Shader>& shader, std::string key)
+std::vector<const ShaderPreprocessorDefinition*> getKeys(Shader* shader, std::string key)
 {
     std::vector<const ShaderPreprocessorDefinition*> ret;
     for (const auto& p : shader->PreprocessorDefinitions)
@@ -56,9 +56,9 @@ bool checkShader(GLuint uid)
     return true;
 }
 
-std::unique_ptr<Shader> shader_create()
+Shader* shader_create()
 {
-    std::unique_ptr<Shader> shader = std::make_unique<Shader>();
+    Shader* shader = new Shader;
 
     shader->Program = 0;
     shader->Shaders[0] = GL_NONE;
@@ -68,7 +68,7 @@ std::unique_ptr<Shader> shader_create()
     return shader;
 }
 
-void shader_cleanup(std::unique_ptr<Shader>& shader)
+void shader_cleanup(Shader* shader)
 {
     for (int i = 0; i < 3; i++) {
         if (shader->Shaders[i] == GL_NONE)
@@ -79,7 +79,7 @@ void shader_cleanup(std::unique_ptr<Shader>& shader)
     glDeleteProgram(shader->Program);
 }
 
-void shader_load(std::unique_ptr<Shader>& shader, std::filesystem::path path)
+void shader_load(Shader* shader, std::filesystem::path path)
 {
 
     assert(std::filesystem::exists(path));
@@ -132,7 +132,7 @@ void shader_load(std::unique_ptr<Shader>& shader, std::filesystem::path path)
     }
 }
 
-void shader_link(std::unique_ptr<Shader>& shader)
+void shader_link(Shader* shader)
 {
     shader->Program = glCreateProgram();
 
@@ -150,32 +150,32 @@ void shader_link(std::unique_ptr<Shader>& shader)
     glLinkProgram(shader->Program);
 }
 
-void shader_add_attribute(std::unique_ptr<Shader>& shader, const std::string& attribute)
+void shader_add_attribute(Shader* shader, const std::string& attribute)
 {
     shader->Attributes[attribute] = glGetAttribLocation(shader->Program, attribute.c_str());
 }
 
-void shader_add_uniform(std::unique_ptr<Shader>& shader, const std::string& uniform)
+void shader_add_uniform(Shader* shader, const std::string& uniform)
 {
     shader->Uniforms[uniform] = glGetUniformLocation(shader->Program, uniform.c_str());
 }
 
-GLuint shader_get_attribute(std::unique_ptr<Shader>& shader, const std::string& attribute)
+GLuint shader_get_attribute(Shader* shader, const std::string& attribute)
 {
     return shader->Attributes[attribute];
 }
 
-GLuint shader_get_uniform(std::unique_ptr<Shader>& shader, const std::string& uniform)
+GLuint shader_get_uniform(Shader* shader, const std::string& uniform)
 {
     return shader->Uniforms[uniform];
 }
 
-void shader_use(std::unique_ptr<Shader>& shader)
+void shader_use(Shader* shader)
 {
     glUseProgram(shader->Program);
 }
 
-void shader_unuse(std::unique_ptr<Shader>& shader)
+void shader_unuse(Shader* shader)
 {
     glUseProgram(0);
 }

src/preview_renderer/shader.hpp

@@ -24,18 +24,18 @@ typedef struct Shader {
     std::vector<ShaderPreprocessorDefinition> PreprocessorDefinitions;
 } Shader;
 
-std::unique_ptr<Shader> shader_create();
+Shader* shader_create();
-void shader_cleanup(std::unique_ptr<Shader>& shader);
+void shader_cleanup(Shader* shader);
 
-void shader_load(std::unique_ptr<Shader>& shader, std::filesystem::path path);
+void shader_load(Shader* shader, std::filesystem::path path);
-void shader_link(std::unique_ptr<Shader>& shader);
+void shader_link(Shader* shader);
 // TODO: Implement shader_reload
-void shader_add_attribute(std::unique_ptr<Shader>& shader, const std::string& attribute);
+void shader_add_attribute(Shader* shader, const std::string& attribute);
-void shader_add_uniform(std::unique_ptr<Shader>& shader, const std::string& uniform);
+void shader_add_uniform(Shader* shader, const std::string& uniform);
-GLuint shader_get_attribute(std::unique_ptr<Shader>& shader, const std::string& attribute);
+GLuint shader_get_attribute(Shader* shader, const std::string& attribute);
-GLuint shader_get_uniform(std::unique_ptr<Shader>& shader, const std::string& uniform);
+GLuint shader_get_uniform(Shader* shader, const std::string& uniform);
 
-void shader_use(std::unique_ptr<Shader>& shader);
+void shader_use(Shader* shader);
-void shader_unuse(std::unique_ptr<Shader>& shader);
+void shader_unuse(Shader* shader);
 
 }

src/renderer/renderer.cpp

@@ -16,9 +16,9 @@
 //
 // namespace inferno::graphics {
 //
-// std::unique_ptr<RayRenderer> rayr_create(glm::ivec2 viewport, HHM* accelIface)
+// RayRenderer* rayr_create(glm::ivec2 viewport, HHM* accelIface)
 // {
-//     std::unique_ptr<RayRenderer> renderer = std::make_unique<RayRenderer>();
+//     RayRenderer* renderer = new RayRenderer;
 //     renderer->RenderTargetSize = viewport;
 //     renderer->RenderData = new glm::fvec4[renderer->RenderTargetSize.x * renderer->RenderTargetSize.y];
 //
@@ -38,12 +38,12 @@
 //     return renderer;
 // }
 //
-// void rayr_cleanup(std::unique_ptr<RayRenderer>& renderer)
+// void rayr_cleanup(RayRenderer* renderer)
 // {
 //     delete[] renderer->RenderData;
 // }
 //
-// void rayr_set_scene(std::unique_ptr<RayRenderer>& renderer, std::shared_ptr<scene::Scene> scene)
+// void rayr_set_scene(RayRenderer* renderer, std::shared_ptr<scene::Scene> scene)
 // {
 //     renderer->CurrentScene = scene;
 //     if (renderer->RaySource != nullptr)
@@ -57,17 +57,17 @@
 //     // mIface->newScene(scene);
 // }
 //
-// void rayr_set_viewport(std::unique_ptr<RayRenderer> &renderer, glm::ivec2 size)
+// void rayr_set_viewport(RayRenderer* &renderer, glm::ivec2 size)
 // {
 //     renderer->RenderTargetSize = size;
 // }
 //
-// glm::ivec2 rayr_get_viewport(std::unique_ptr<RayRenderer> &renderer)
+// glm::ivec2 rayr_get_viewport(RayRenderer* &renderer)
 // {
 //     return renderer->RenderTargetSize;
 // }
 //
-// GLuint rayr_get_rendered_texture(std::unique_ptr<RayRenderer> &renderer)
+// GLuint rayr_get_rendered_texture(RayRenderer* &renderer)
 // {
 //     std::lock_guard<std::mutex> lock(renderer->RenderDataMutex);
 //     glBindFramebuffer(GL_FRAMEBUFFER, 0);
@@ -75,13 +75,13 @@
 //     return renderer->RenderTargetTexture;
 // }
 //
-// glm::fvec4* rayr_get_render_data(std::unique_ptr<RayRenderer> &renderer)
+// glm::fvec4* rayr_get_render_data(RayRenderer* &renderer)
 // {
 //     std::lock_guard<std::mutex> lock(renderer->RenderDataMutex);
 //     return renderer->RenderData;
 // }
 //
-// void rayr_prepare(std::unique_ptr<RayRenderer> &renderer)
+// void rayr_prepare(RayRenderer* &renderer)
 // {
 //     assert(renderer->CurrentScene != nullptr);
 //     // here, scene_did_update takes a unique_ptr, but we have a shared_ptr
@@ -94,7 +94,7 @@
 //     }
 // }
 //
-// void rayr_draw(std::unique_ptr<RayRenderer> &renderer)
+// void rayr_draw(RayRenderer* &renderer)
 // {
 //     scene::scene_frame_tick(renderer->CurrentScene);
 //     // TODO: Rays should definately be bump allocated if possible, this is KBs of

src/renderer/renderer.hpp

@@ -20,7 +20,7 @@ class RaySource;
 class RenderDispatcher;
 
 typedef struct RayRenderer {
-    std::unique_ptr<glm::ivec2> Viewport;
+    glm::ivec2* Viewport;
 
     // TODO: Can this be direct 2 GPU?
     glm::fvec4* RenderData = nullptr;
@@ -30,15 +30,15 @@ typedef struct RayRenderer {
     RaySource* RaySource = nullptr;
 } RayRenderer;
 
-std::unique_ptr<RayRenderer> rayr_create(glm::ivec2 viewport, HHM* accelIface);
+RayRenderer* rayr_create(glm::ivec2 viewport, HHM* accelIface);
-void rayr_cleanup(std::unique_ptr<RayRenderer>& renderer);
+void rayr_cleanup(RayRenderer* renderer);
 
-void rayr_set_viewport(std::unique_ptr<RayRenderer>& renderer, glm::ivec2 size);
+void rayr_set_viewport(RayRenderer* renderer, glm::ivec2 size);
 
-GLuint rayr_get_rendered_texture(std::unique_ptr<RayRenderer>& renderer);
+GLuint rayr_get_rendered_texture(RayRenderer* renderer);
-glm::fvec4* rayr_get_render_data(std::unique_ptr<RayRenderer>& renderer);
+glm::fvec4* rayr_get_render_data(RayRenderer* renderer);
 
-void rayr_draw(std::unique_ptr<RayRenderer>& renderer, std::unique_ptr<scene::Scene> scene);
+void rayr_draw(RayRenderer* renderer, scene::Scene* scene);
 
 void raryr_compute_hit(HitInfo* info);
 

src/scene/camera.cpp

@@ -2,10 +2,10 @@
 
 namespace inferno::graphics {
 
-std::unique_ptr<Camera> camera_create()
+Camera* camera_create()
 {
-    std::unique_ptr<Camera> camera = std::make_unique<Camera>();
+    Camera* camera = new Camera;
-    camera->_impl = std::make_unique<_CameraImpl>();
+    camera->_impl = new _CameraImpl;
 
     camera->Views = Viewports();
     camera->Views.Raster = glm::ivec2(800, 600);
@@ -29,13 +29,13 @@ std::unique_ptr<Camera> camera_create()
     return camera;
 }
 
-void camera_cleanup(std::unique_ptr<Camera>& camera)
+void camera_cleanup(Camera* camera)
 {
     camera->_impl.reset();
     camera.reset();
 }
 
-void camera_update(std::unique_ptr<Camera>& camera)
+void camera_update(Camera* camera)
 {
     glm::mat4 matRoll = glm::mat4(1.0f);
     glm::mat4 matPitch = glm::mat4(1.0f);
@@ -70,37 +70,37 @@ void camera_update(std::unique_ptr<Camera>& camera)
     camera->_impl->DidUpdate = true;
 }
 
-bool camera_did_update(std::unique_ptr<Camera>& camera)
+bool camera_did_update(Camera* camera)
 {
     std::lock_guard<std::mutex> lock(camera->_impl->CamMutex);
     return camera->_impl->DidUpdate;
 }
 
-void camera_new_frame(std::unique_ptr<Camera>& camera)
+void camera_new_frame(Camera* camera)
 {
     std::lock_guard<std::mutex> lock(camera->_impl->CamMutex);
     camera->_impl->DidUpdate = false;
 }
 
-glm::mat4 camera_get_view(std::unique_ptr<Camera>& camera)
+glm::mat4 camera_get_view(Camera* camera)
 {
     std::lock_guard<std::mutex> lock(camera->_impl->CamMutex);
     return camera->ViewMatrix;
 }
 
-glm::mat4 camera_get_projection(std::unique_ptr<Camera>& camera)
+glm::mat4 camera_get_projection(Camera* camera)
 {
     std::lock_guard<std::mutex> lock(camera->_impl->CamMutex);
     return camera->ProjectionMatrix;
 }
 
-glm::mat4 camera_get_look(std::unique_ptr<Camera>& camera)
+glm::mat4 camera_get_look(Camera* camera)
 {
     std::lock_guard<std::mutex> lock(camera->_impl->CamMutex);
     return camera->LookMatrix;
 }
 
-void raster_set_viewport(std::unique_ptr<Camera>& camera, glm::ivec2 viewport)
+void raster_set_viewport(Camera* camera, glm::ivec2 viewport)
 {
     std::lock_guard<std::mutex> lock(camera->_impl->CamMutex);
     camera->Views.Raster = viewport;
@@ -111,25 +111,25 @@ void raster_set_viewport(std::unique_ptr<Camera>& camera, glm::ivec2 viewport)
         1000.0f);
 }
 
-glm::ivec2 raster_get_viewport(std::unique_ptr<Camera>& camera)
+glm::ivec2 raster_get_viewport(Camera* camera)
 {
     std::lock_guard<std::mutex> lock(camera->_impl->CamMutex);
     return camera->Views.Raster;
 }
 
-void ray_set_viewport(std::unique_ptr<Camera>& camera, glm::ivec2 viewport)
+void ray_set_viewport(Camera* camera, glm::ivec2 viewport)
 {
     std::lock_guard<std::mutex> lock(camera->_impl->CamMutex);
     camera->Views.Ray = viewport;
 }
 
-glm::ivec2 ray_get_viewport(std::unique_ptr<Camera>& camera)
+glm::ivec2 ray_get_viewport(Camera* camera)
 {
     std::lock_guard<std::mutex> lock(camera->_impl->CamMutex);
     return camera->Views.Ray;
 }
 
-void camera_move(std::unique_ptr<Camera>& camera, uint8_t movement_delta)
+void camera_move(Camera* camera, uint8_t movement_delta)
 {
     if (movement_delta == 0)
         return;
@@ -181,7 +181,7 @@ void camera_move(std::unique_ptr<Camera>& camera, uint8_t movement_delta)
     camera_update(camera);
 }
 
-void camera_mouse_move(std::unique_ptr<Camera>& camera, glm::vec2 mouse_delta)
+void camera_mouse_move(Camera* camera, glm::vec2 mouse_delta)
 {
     if (glm::length(mouse_delta) == 0)
         return;
@@ -194,13 +194,13 @@ void camera_mouse_move(std::unique_ptr<Camera>& camera, glm::vec2 mouse_delta)
     camera_update(camera);
 }
 
-void camera_set_position(std::unique_ptr<Camera>& camera, glm::vec3 position)
+void camera_set_position(Camera* camera, glm::vec3 position)
 {
     camera->Position = position;
     camera_update(camera);
 }
 
-void camera_set_euler_look(std::unique_ptr<Camera>& camera, float roll, float pitch, float yaw)
+void camera_set_euler_look(Camera* camera, float roll, float pitch, float yaw)
 {
     camera->Roll = roll;
     camera->Pitch = pitch;
@@ -212,7 +212,7 @@ void camera_set_euler_look(std::unique_ptr<Camera>& camera, float roll, float pi
     camera_update(camera);
 }
 
-void camera_set_look(std::unique_ptr<Camera>& camera, glm::vec3 look_direction)
+void camera_set_look(Camera* camera, glm::vec3 look_direction)
 {
     camera->LookDirection = look_direction;
     camera->Pitch = asin(-look_direction.y);

src/scene/object.cpp

@@ -4,23 +4,23 @@
 
 namespace inferno::scene {
 
-std::unique_ptr<SceneObject> scene_object_create()
+SceneObject* scene_object_create()
 {
-    std::unique_ptr<SceneObject> object = std::make_unique<SceneObject>();
+    SceneObject* object = new SceneObject;
     return object;
 }
 
-void scene_object_cleanup(std::unique_ptr<SceneObject>& object)
+void scene_object_cleanup(SceneObject* object)
 {
 
 }
 
-void scene_object_add_mesh(std::unique_ptr<SceneObject>& object, Mesh* mesh)
+void scene_object_add_mesh(SceneObject* object, Mesh* mesh)
 {
     object->Meshs.push_back(mesh);
 }
 
-std::vector<Mesh*>& scene_object_get_meshs(std::unique_ptr<SceneObject>& object)
+std::vector<Mesh*>& scene_object_get_meshs(SceneObject* object)
 {
     return object->Meshs;
 }

src/scene/object.hpp

@@ -11,10 +11,10 @@ typedef struct SceneObject {
     std::vector<Mesh*> Meshs;
 } SceneObject;
 
-std::unique_ptr<SceneObject> scene_object_create();
+SceneObject* scene_object_create();
-void scene_object_cleanup(std::unique_ptr<SceneObject>& object);
+void scene_object_cleanup(SceneObject* object);
 
-void scene_object_add_mesh(std::unique_ptr<SceneObject>& object, Mesh* mesh);
+void scene_object_add_mesh(SceneObject* object, Mesh* mesh);
-std::vector<Mesh*>& scene_object_get_meshs(std::unique_ptr<SceneObject>& object);
+std::vector<Mesh*>& scene_object_get_meshs(SceneObject* object);
 
 } // namespace inferno::scene

src/scene/scene.cpp

@@ -7,44 +7,44 @@
 
 namespace inferno::scene {
 
-std::unique_ptr<Scene> scene_create()
+Scene* scene_create()
 {
-    std::unique_ptr<Scene> scene = std::make_unique<Scene>();
+    Scene* scene = new Scene;
-    scene->Camera = std::make_unique<graphics::Camera>();
+    scene->Camera = new graphics::Camera;
     return scene;
 }
 
-void scene_cleanup(std::unique_ptr<Scene>& scene)
+void scene_cleanup(Scene* scene)
 {
 }
 
-void scene_add_object(std::unique_ptr<Scene>& scene, std::unique_ptr<SceneObject>& object)
+void scene_add_object(Scene* scene, SceneObject* object)
 {
     scene->Objects.emplace_back(std::move(object));
     scene->DidUpdate = true;
 }
 
-std::unique_ptr<graphics::Camera>& scene_get_camera(std::unique_ptr<Scene>& scene)
+graphics::Camera* scene_get_camera(Scene* scene)
 {
     return scene->Camera;
 }
 
-std::vector<std::unique_ptr<SceneObject>>& scene_get_renderables(std::unique_ptr<Scene>& scene)
+std::vector<SceneObject*>& scene_get_renderables(Scene* scene)
 {
     return scene->Objects;
 }
 
-bool scene_did_update(std::unique_ptr<Scene>& scene)
+bool scene_did_update(Scene* scene)
 {
     return scene->DidUpdate;
 }
 
-void scene_frame_tick(std::unique_ptr<Scene>& scene)
+void scene_frame_tick(Scene* scene)
 {
     scene->DidUpdate = false;
 }
 
-void scene_tick(std::unique_ptr<Scene>& scene)
+void scene_tick(Scene* scene)
 {
     for (auto& object : scene->Objects) {
         // Shit here like animation idk

src/scene/scene.hpp

@@ -15,22 +15,22 @@ class SceneObject;
 class Mesh;
 
 typedef struct Scene {
-    std::unique_ptr<graphics::Camera> Camera;
+    std::vector<SceneObject*> Objects;
-    std::vector<std::unique_ptr<SceneObject>> Objects;
+    graphics::Camera* Camera;
     bool DidUpdate = false;
 } Scene;
 
-std::unique_ptr<Scene> scene_create();
+Scene* scene_create();
-void scene_cleanup(std::unique_ptr<Scene>& scene);
+void scene_cleanup(Scene* scene);
 
-void scene_add_object(std::unique_ptr<Scene>& scene, std::unique_ptr<SceneObject>& object);
+void scene_add_object(Scene* scene, SceneObject* object);
 
-std::unique_ptr<graphics::Camera>& scene_get_camera(std::unique_ptr<Scene>& scene);
+graphics::Camera* scene_get_camera(Scene* scene);
-std::vector<std::unique_ptr<SceneObject>>& scene_get_renderables(std::unique_ptr<Scene>& scene);
+std::vector<SceneObject*>& scene_get_renderables(Scene* scene);
 
-bool scene_did_update(std::unique_ptr<Scene>& scene);
+bool scene_did_update(Scene* scene);
 
-void scene_frame_tick(std::unique_ptr<Scene>& scene);
+void scene_frame_tick(Scene* scene);
-void scene_tick(std::unique_ptr<Scene>& scene);
+void scene_tick(Scene* scene);
 
 } // namespace inferno::scene