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

ray renderer

Browse Source
This commit is contained in:
Ben Kyd
2023-08-06 23:38:39 +01:00
parent db42b0df82
commit 4012464bc5
4 changed files with 81 additions and 77 deletions
Download Patch File Download Diff File Expand all files Collapse all files

72
src/renderer/renderer.cpp
View File

@@ -15,15 +15,16 @@
#include <iostream>
using namespace inferno;
namespace inferno::graphics {
RayRenderer::RayRenderer(HHM* accelIface)
: mIface(accelIface)
std::unique_ptr<RayRenderer> rayr_create(glm::ivec2 viewport, HHM* accelIface)
{
mTarget = new glm::fvec4[mRenderTargetSize.x * mRenderTargetSize.y];
std::unique_ptr<RayRenderer> renderer = std::make_unique<RayRenderer>();
renderer->RenderTargetSize = viewport;
renderer->RenderData = new glm::fvec4[renderer->RenderTargetSize.x * renderer->RenderTargetSize.y];
glGenTextures(1, &mRenderTargetTexture);
glBindTexture(GL_TEXTURE_2D, mRenderTargetTexture);
glGenTextures(1, &renderer->RenderTargetTexture);
glBindTexture(GL_TEXTURE_2D, renderer->RenderTargetTexture);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
@@ -31,66 +32,72 @@ RayRenderer::RayRenderer(HHM* accelIface)
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
glPixelStorei(GL_UNPACK_ROW_LENGTH, 0);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, mRenderTargetSize.x, mRenderTargetSize.y, 0, GL_RGBA, GL_FLOAT, mTarget);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, renderer->RenderTargetSize.x, renderer->RenderTargetSize.y, 0, GL_RGBA, GL_FLOAT, renderer->RenderData);
glBindTexture(GL_TEXTURE_2D, 0);
return renderer;
}
RayRenderer::~RayRenderer()
void rayr_cleanup(std::unique_ptr<RayRenderer>& renderer)
{
delete[] mTarget;
delete[] renderer->RenderData;
}
void RayRenderer::setScene(Scene* scene)
void rayr_set_scene(std::unique_ptr<RayRenderer>& renderer, std::shared_ptr<scene::Scene> scene)
{
mCurrentScene = scene;
if (mRaySource != nullptr)
renderer->CurrentScene = scene;
if (renderer->RaySource != nullptr)
{
delete mRaySource;
delete renderer->RaySource;
}
mRaySource = new RaySource(scene->getCamera());
// renderer->RaySource = new RaySource(scene->getCamera());
// the scene will be sent to the module on prepare
// as it did update during initialisation
// mIface->newScene(scene);
}
void RayRenderer::setTargetSize(glm::ivec2 size)
void rayr_set_viewport(std::unique_ptr<RayRenderer> &renderer, glm::ivec2 size)
{
mRenderTargetSize = size;
renderer->RenderTargetSize = size;
}
glm::ivec2 RayRenderer::getTargetSize()
glm::ivec2 rayr_get_viewport(std::unique_ptr<RayRenderer> &renderer)
{
return mRenderTargetSize;
return renderer->RenderTargetSize;
}
GLuint RayRenderer::getRenderedTexture()
GLuint rayr_get_rendered_texture(std::unique_ptr<RayRenderer> &renderer)
{
std::lock_guard<std::mutex> lock(this->_RenderData);
std::lock_guard<std::mutex> lock(renderer->RenderDataMutex);
glBindFramebuffer(GL_FRAMEBUFFER, 0);
glBindTexture(GL_TEXTURE_2D, mRenderTargetTexture);
return mRenderTargetTexture;
glBindTexture(GL_TEXTURE_2D, renderer->RenderTargetTexture);
return renderer->RenderTargetTexture;
}
glm::fvec4* RayRenderer::getRenderData()
glm::fvec4* rayr_get_render_data(std::unique_ptr<RayRenderer> &renderer)
{
return mTarget;
std::lock_guard<std::mutex> lock(renderer->RenderDataMutex);
return renderer->RenderData;
}
void RayRenderer::prepare()
void rayr_prepare(std::unique_ptr<RayRenderer> &renderer)
{
assert(mCurrentScene != nullptr);
if (mCurrentScene->didUpdate())
assert(renderer->CurrentScene != nullptr);
// here, scene_did_update takes a unique_ptr, but we have a shared_ptr
// so we need to call unique() to get the unique_ptr but that will error
// with non-const ltype so we need to const_cast it
if (scene::scene_did_update(renderer->CurrentScene.unique()))
{
yolo::debug("New Scene!");
mIface->newScene(mCurrentScene);
// renderer->AccelerationInterface->newScene(renderer->CurrentScene);
}
}
void RayRenderer::draw()
void rayr_draw(std::unique_ptr<RayRenderer> &renderer)
{
mCurrentScene->newFrame();
scene::scene_frame_tick(renderer->CurrentScene.unique());
// TODO: Rays should definately be bump allocated if possible, this is KBs of
// ray data and nothing else being reallocated every frame for no reason
ReferencedRayField startRays = mRaySource->getInitialRays(true);
@@ -129,4 +136,9 @@ void RayRenderer::computeHit(HitInfo* info)
if (d > maxd) maxd = d;
float n = (d - mind) / (maxd - mind);
mTarget[pos.y * mRenderTargetSize.x + pos.x] = { n, n, n, 1.0f};
}
void mHaultWait();
std::unordered_map<uint32_t, glm::ivec2>* mCurrentRefTable;
}

68
src/renderer/renderer.hpp
View File

@@ -2,58 +2,50 @@
#include <graphics.hpp>
#include <condition_variable>
#include <mutex>
#include <unordered_map>
#include <condition_variable>
namespace inferno {
namespace inferno::scene {
struct Scene;
}
namespace inferno::graphics {
class HHM;
class Scene;
class HitInfo;
class RaySource;
class RenderDispatcher;
class RayRenderer
{
public:
RayRenderer(HHM* accelIface);
~RayRenderer();
typedef struct RayRenderer {
glm::fvec4* RenderData = nullptr;
GLuint RenderTargetTexture = 0;
void setScene(Scene* scene);
// TODO: Put this inside an internal struct
std::mutex RenderDataMutex;
std::condition_variable RenderPause;
// TODO: End
void setTargetSize(glm::ivec2 size);
glm::ivec2 getTargetSize();
GLuint getRenderedTexture();
glm::fvec4* getRenderData();
std::shared_ptr<scene::Scene> CurrentScene;
// std::shared_ptr<const Viewport> RenderTargetSize;
glm::ivec2 RenderTargetSize;
void prepare();
void draw();
HHM* AccelerationInterface = nullptr;
RenderDispatcher* Dispatcher = nullptr;
RaySource* RaySource = nullptr;
} RayRenderer;
public:
void computeHit(HitInfo* info);
std::unique_ptr<RayRenderer> rayr_create(glm::ivec2 viewport, HHM* accelIface);
void rayr_cleanup(std::unique_ptr<RayRenderer>& renderer);
void rayr_set_scene(std::unique_ptr<RayRenderer>& renderer, std::shared_ptr<scene::Scene> scene);
void rayr_set_viewport(std::unique_ptr<RayRenderer>& renderer, glm::ivec2 size);
glm::ivec2 rayr_get_viewport(std::unique_ptr<RayRenderer>& renderer);
GLuint rayr_get_rendered_texture(std::unique_ptr<RayRenderer>& renderer);
glm::fvec4* rayr_get_render_data(std::unique_ptr<RayRenderer>& renderer);
void rayr_prepare(std::unique_ptr<RayRenderer>& renderer);
void rayr_draw(std::unique_ptr<RayRenderer>& renderer);
private:
void mHaultWait();
std::unordered_map<uint32_t, glm::ivec2>* mCurrentRefTable;
private:
GLuint mRenderTargetTexture = 0;
glm::fvec4* mTarget;
std::mutex _RenderData;
std::condition_variable _RenderPause;
glm::ivec2 mRenderTargetSize = {200, 200};
Scene* mCurrentScene = nullptr;
RaySource* mRaySource = nullptr;
friend class RenderDispatcher;
private:
HHM* mIface;
};
void raryr_compute_hit(HitInfo* info);
}

8
src/scene/scene.cpp
View File

@@ -29,22 +29,22 @@ void scene_add_object(std::unique_ptr<Scene>& scene, std::unique_ptr<SceneObject
scene->DidUpdate = true;
}
std::vector<std::unique_ptr<SceneObject>>& get_renderables(std::unique_ptr<Scene>& scene)
std::vector<std::unique_ptr<SceneObject>>& scene_get_renderables(std::unique_ptr<Scene>& scene)
{
return scene->Objects;
}
bool did_update(std::unique_ptr<Scene>& scene)
bool scene_did_update(std::unique_ptr<Scene>& scene)
{
return scene->DidUpdate;
}
void frame_tick(std::unique_ptr<Scene>& scene)
void scene_frame_tick(std::unique_ptr<Scene>& scene)
{
scene->DidUpdate = false;
}
void tick(std::unique_ptr<Scene>& scene)
void scene_tick(std::unique_ptr<Scene>& scene)
{
for (auto& object : scene->Objects) {
// object->tick();

10
src/scene/scene.hpp
View File

@@ -22,10 +22,10 @@ std::unique_ptr<Scene> scene_create();
void scene_cleanup(std::unique_ptr<Scene>& scene);
void scene_set_camera(std::unique_ptr<Scene>& scene, std::shared_ptr<graphics::Camera> camera);
void scene_add_object(std::unique_ptr<Scene>& scene, std::unique_ptr<SceneObject> object);
std::unique_ptr<graphics::Camera>& get_camera(std::unique_ptr<Scene>& scene);
std::vector<std::unique_ptr<SceneObject>>& get_renderables(std::unique_ptr<Scene>& scene);
bool did_update(std::unique_ptr<Scene>& scene);
void frame_tick(std::unique_ptr<Scene>& scene);
void tick(std::unique_ptr<Scene>& scene);
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);
bool scene_did_update(std::unique_ptr<Scene>& scene);
void scene_frame_tick(std::unique_ptr<Scene>& scene);
void scene_tick(std::unique_ptr<Scene>& scene);
}