benkyd/inferno-hart
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

well that broke a lot - sounds like a tomorrow problem

Browse Source
This commit is contained in:
Ben Kyd
2023-10-03 23:09:36 +01:00
parent a21880ff63
commit 98e0adc416
13 changed files with 104 additions and 104 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
src/inferno.cpp
View File

@@ -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>();
app->Input = std::make_unique<InfernoInput>();
std::unique_ptr<InfernoApp> app = new InfernoApp;
app->Input = new InfernoInput;
// Create window
graphics::window_create("Inferno v" INFERNO_VERSION, 1280, 720);

20
src/inferno.hpp
View File

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

2
src/preview_renderer/renderer.cpp
View File

@@ -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);

8
src/preview_renderer/renderer.hpp
View File

@@ -20,11 +20,11 @@ typedef struct PreviewRenderer {
GLuint RenderTargetDepthTexture = 0;
} PreviewRenderer;
std::unique_ptr<PreviewRenderer> preview_create();
void preview_cleanup(std::unique_ptr<PreviewRenderer>& renderer);
PreviewRenderer* preview_create();
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

24
src/preview_renderer/shader.cpp
View File

@@ -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);
}

20
src/preview_renderer/shader.hpp
View File

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

20
src/renderer/renderer.cpp
View File

@@ -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

14
src/renderer/renderer.hpp
View File

@@ -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);
void rayr_cleanup(std::unique_ptr<RayRenderer>& renderer);
RayRenderer* rayr_create(glm::ivec2 viewport, HHM* accelIface);
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);
glm::fvec4* rayr_get_render_data(std::unique_ptr<RayRenderer>& renderer);
GLuint rayr_get_rendered_texture(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);

38
src/scene/camera.cpp
View File

@@ -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->_impl = std::make_unique<_CameraImpl>();
Camera* camera = new Camera;
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);

10
src/scene/object.cpp
View File

@@ -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;
}

8
src/scene/object.hpp
View File

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

20
src/scene/scene.cpp
View File

@@ -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->Camera = std::make_unique<graphics::Camera>();
Scene* scene = new Scene;
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

20
src/scene/scene.hpp
View File

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