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

based wtf

Browse Source
This commit is contained in:
Benjamin Kyd
2023-05-17 12:40:50 +01:00
parent 2f022e9361
commit 97476996e8
7 changed files with 117 additions and 91 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
libhart/scene/camera.hpp
View File

@@ -10,7 +10,7 @@ namespace inferno::graphics {
struct _CameraImpl;
typedef struct Viewports {
typedef struct Viewport {
glm::ivec2 Raster;
glm::ivec2 Ray;
} Viewports;
@@ -20,7 +20,7 @@ typedef struct Camera {
glm::mat4 ProjectionMatrix;
glm::mat4 LookMatrix;
std::shared_ptr<Viewports> Viewports;
std::shared_ptr<Viewport> Views;
float MouseSensitivity = 0.4f;
float Speed = 0.1f;

2
src/hart_directory.hpp
View File

@@ -53,7 +53,7 @@ public:
void setActive(std::string moduleName);
void setActiveIndex(int index);
HARTModule* getActiveModule();
std::string getActive();
int getActiveIndex();

2
src/inferno.cpp
View File

@@ -1,4 +1,4 @@
#include "inferno.hpp"
#include "infergo.hpp"
#include <version.hpp>
// #include "gui/layout.hpp"

122
src/preview_renderer/renderer.cpp
View File

@@ -3,112 +3,134 @@
#include "shader.hpp"
#include <scene/camera.hpp>
#include <scene/scene.hpp>
#include <scene/material.hpp>
#include <scene/mesh.hpp>
#include <scene/scene.hpp>
#include <iostream>
using namespace inferno;
namespace inferno::graphics {
RasterizeRenderer::RasterizeRenderer()
std::unique_ptr<PreviewRenderer> preview_create()
{
glGenFramebuffers(1, &mRenderTarget);
glBindFramebuffer(GL_FRAMEBUFFER, mRenderTarget);
std::unique_ptr<PreviewRenderer> renderer = std::make_unique<PreviewRenderer>();
glGenFramebuffers(1, &renderer->RenderTarget);
glBindFramebuffer(GL_FRAMEBUFFER, renderer->RenderTarget);
glGenTextures(1, &mRenderTargetTexture);
glBindTexture(GL_TEXTURE_2D, mRenderTargetTexture);
glGenTextures(1, &renderer->RenderTargetTexture);
glBindTexture(GL_TEXTURE_2D, renderer->RenderTargetTexture);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, 800, 600, 0, GL_RGB, GL_UNSIGNED_BYTE, NULL);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glGenTextures(1, &mRenderTargetDepthTexture );
glBindTexture(GL_TEXTURE_2D, mRenderTargetDepthTexture );
glTexImage2D(GL_TEXTURE_2D, 0, GL_DEPTH24_STENCIL8, 800, 600, 0, GL_DEPTH_COMPONENT, GL_FLOAT, NULL);
glGenTextures(1, &renderer->RenderTargetDepthTexture);
glBindTexture(GL_TEXTURE_2D, renderer->RenderTargetDepthTexture);
glTexImage2D(GL_TEXTURE_2D, 0, GL_DEPTH24_STENCIL8, 800, 600, 0, GL_DEPTH_COMPONENT, GL_FLOAT, NULL);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
// Attach the texture to the framebuffer.
glFramebufferTexture2D( GL_DRAW_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_TEXTURE_2D, mRenderTargetDepthTexture, 0 );
glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, mRenderTargetTexture, 0);
// Attach the texture to the framebuffer.
glFramebufferTexture2D(GL_DRAW_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_TEXTURE_2D, renderer->RenderTargetDepthTexture, 0);
glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, renderer->RenderTargetTexture, 0);
assert(glCheckFramebufferStatus(GL_FRAMEBUFFER) == GL_FRAMEBUFFER_COMPLETE);
glBindFramebuffer(GL_FRAMEBUFFER, 0);
glBindFramebuffer(GL_FRAMEBUFFER, 0);
return renderer;
}
RasterizeRenderer::~RasterizeRenderer()
void preview_cleanup(std::unique_ptr<PreviewRenderer>& renderer)
{
}
void RasterizeRenderer::setScene(Scene* scene)
void preview_set_scene(std::unique_ptr<PreviewRenderer>& renderer, std::shared_ptr<Scene> scene)
{
mCurrentScene = scene;
renderer->CurrentScene = scene;
}
void RasterizeRenderer::setTargetSize(glm::ivec2 size)
void preview_set_viewport(std::unique_ptr<PreviewRenderer>& renderer, std::shared_ptr<const Viewport> viewport)
{
glBindFramebuffer(GL_FRAMEBUFFER, mRenderTarget);
renderer->RenderTargetSize = viewport;
glBindFramebuffer(GL_FRAMEBUFFER, renderer->RenderTarget);
glBindTexture(GL_TEXTURE_2D, mRenderTargetTexture);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, size.x, size.y, 0, GL_RGB, GL_UNSIGNED_BYTE, NULL);
glBindTexture(GL_TEXTURE_2D, renderer->RenderTargetTexture);
glTexImage2D(
GL_TEXTURE_2D,
0,
GL_RGB,
viewport->Raster.x,
viewport->Raster.y,
0,
GL_RGB,
GL_UNSIGNED_BYTE,
NULL);
glBindTexture(GL_TEXTURE_2D, mRenderTargetDepthTexture);
glTexImage2D( GL_TEXTURE_2D, 0, GL_DEPTH24_STENCIL8, size.x, size.y, 0, GL_DEPTH_COMPONENT, GL_FLOAT, NULL );
glBindTexture(GL_TEXTURE_2D, renderer->RenderTargetDepthTexture);
glTexImage2D(GL_TEXTURE_2D,
0,
GL_DEPTH24_STENCIL8,
viewport->Raster.x,
viewport->Raster.y,
0,
GL_DEPTH_COMPONENT,
GL_FLOAT,
NULL);
glBindFramebuffer(GL_FRAMEBUFFER, 0);
mRenderTargetSize = size;
}
GLuint RasterizeRenderer::getRenderedTexture()
const glm::ivec2& preview_get_viewport(std::unique_ptr<PreviewRenderer>& renderer)
{
glBindFramebuffer(GL_FRAMEBUFFER, mRenderTarget);
return mRenderTargetTexture;
return renderer->RenderTargetSize->Raster;
}
glm::ivec2 RasterizeRenderer::getTargetSize()
GLuint preview_get_rendered_texture(std::unique_ptr<PreviewRenderer>& renderer)
{
return mRenderTargetSize;
glBindFramebuffer(GL_FRAMEBUFFER, renderer->RenderTarget);
return renderer->RenderTargetTexture;
}
void RasterizeRenderer::prepare()
void preview_prepare(std::unique_ptr<PreviewRenderer>& renderer)
{
glBindFramebuffer(GL_FRAMEBUFFER, mRenderTarget);
glBindFramebuffer(GL_FRAMEBUFFER, renderer->RenderTarget);
glClearColor(0.1, 0.1, 0.1, 1.0);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glBindFramebuffer(GL_FRAMEBUFFER, 0);
}
void RasterizeRenderer::draw()
void preview_draw(std::unique_ptr<PreviewRenderer>& renderer)
{
glBindFramebuffer(GL_FRAMEBUFFER, mRenderTarget);
glViewport(0, 0, mRenderTargetSize.x, mRenderTargetSize.y);
glBindFramebuffer(GL_FRAMEBUFFER, renderer->RenderTarget);
glViewport(0,
0,
renderer->RenderTargetSize->Raster.x,
renderer->RenderTargetSize->Raster.y);
glEnable(GL_DEPTH_TEST);
for (Mesh* m : mCurrentScene->getRenderables())
{
//m->getMaterial()->getGlShader()->use();
//GLint uniTrans = glGetUniformLocation(m->getMaterial()->getGlShader()->getProgram(), "model");
//glUniformMatrix4fv(uniTrans, 1, GL_FALSE, glm::value_ptr(glm::mat4(1.0f)));
glEnable(GL_DEPTH_TEST);
//GLint uniView = glGetUniformLocation(m->getMaterial()->getGlShader()->getProgram(), "view");
//glUniformMatrix4fv(uniView, 1, GL_FALSE, glm::value_ptr(mCurrentScene->getCamera()->getViewMatrix()));
for (Mesh* m : renderer->CurrentScene->getRenderables()) {
// m->getMaterial()->getGlShader()->use();
// GLint uniTrans = glGetUniformLocation(m->getMaterial()->getGlShader()->getProgram(), "model");
// glUniformMatrix4fv(uniTrans, 1, GL_FALSE, glm::value_ptr(glm::mat4(1.0f)));
// GLint uniView = glGetUniformLocation(m->getMaterial()->getGlShader()->getProgram(), "view");
// glUniformMatrix4fv(uniView, 1, GL_FALSE, glm::value_ptr(renderer->CurrentScene->getCamera()->getViewMatrix()));
// GLint uniProj = glGetUniformLocation(m->getMaterial()->getGlShader()->getProgram(), "proj");
// glUniformMatrix4fv(uniProj, 1, GL_FALSE, glm::value_ptr(renderer->CurrentScene->getCamera()->getProjectionMatrix()));
//GLint uniProj = glGetUniformLocation(m->getMaterial()->getGlShader()->getProgram(), "proj");
//glUniformMatrix4fv(uniProj, 1, GL_FALSE, glm::value_ptr(mCurrentScene->getCamera()->getProjectionMatrix()));
glBindVertexArray(m->getVAO());
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, m->getEBO());
glDrawElements(GL_TRIANGLES, m->getIndexCount() * sizeof(uint32_t), GL_UNSIGNED_INT, 0);
}
glBindFramebuffer(GL_FRAMEBUFFER, 0);
}
}

55
src/preview_renderer/renderer.hpp
View File

@@ -2,32 +2,33 @@
#include <graphics.hpp>
namespace inferno {
class Scene;
class RasterizeRenderer
{
public:
RasterizeRenderer();
~RasterizeRenderer();
void setScene(Scene* scene);
void setTargetSize(glm::ivec2 size);
glm::ivec2 getTargetSize();
GLuint getRenderedTexture();
void prepare();
void draw();
private:
GLuint mRenderTarget = 0;
GLuint mRenderTargetTexture = 0;
GLuint mRenderTargetDepthTexture = 0;
glm::ivec2 mRenderTargetSize = {1920, 1080};
Scene* mCurrentScene;
};
#include <memory>
namespace inferno::scene {
struct Scene;
}
namespace inferno::graphics {
struct Viewport;
typedef struct PreviewRenderer {
GLuint RenderTarget = 0;
GLuint RenderTargetTexture = 0;
GLuint RenderTargetDepthTexture = 0;
std::shared_ptr<scene::Scene> CurrentScene;
std::shared_ptr<const Viewport> RenderTargetSize;
} PreviewRenderer;
std::unique_ptr<PreviewRenderer> preview_create();
void preview_cleanup(std::unique_ptr<PreviewRenderer>& renderer);
void preview_set_scene(std::unique_ptr<PreviewRenderer>& renderer, std::shared_ptr<scene::Scene> scene);
void preview_set_viewport(std::unique_ptr<PreviewRenderer>& renderer, std::shared_ptr<const Viewport> viewports);
const glm::ivec2& preview_get_viewport(std::unique_ptr<PreviewRenderer>& renderer);
GLuint preview_get_rendered_texture(std::unique_ptr<PreviewRenderer>& renderer);
void preview_prepare(std::unique_ptr<PreviewRenderer>& renderer);
void preview_draw(std::unique_ptr<PreviewRenderer>& renderer);
} // namespace inferno::graphics

16
src/scene/camera.cpp
View File

@@ -12,9 +12,9 @@ std::unique_ptr<Camera> camera_create()
{
std::unique_ptr<Camera> camera = std::make_unique<Camera>();
camera->_impl = std::make_unique<_CameraImpl>();
camera->Viewports = std::make_shared<Viewports>();
camera->Viewports->Raster = glm::ivec2(800, 600);
camera->Viewports->Ray = glm::ivec2(800, 600);
camera->Views = std::make_shared<Viewports>();
camera->Views->Raster = glm::ivec2(800, 600);
camera->Views->Ray = glm::ivec2(800, 600);
camera->ProjectionMatrix = glm::perspective(
glm::radians(camera->FOV),
@@ -61,7 +61,7 @@ void camera_update(std::unique_ptr<Camera>& camera)
camera->ViewMatrix = rotate * translate;
camera->ProjectionMatrix = glm::perspective(
glm::radians(camera->FOV),
static_cast<float>(camera->Viewports->Raster.x) / static_cast<float>(camera->Viewports->Raster.y),
static_cast<float>(camera->Views->Raster.x) / static_cast<float>(camera->Views->Raster.y),
0.1f,
1000.0f);
@@ -108,7 +108,7 @@ glm::mat4 camera_get_look(std::unique_ptr<Camera>& camera)
void raster_set_viewport(std::unique_ptr<Camera>& camera, glm::ivec2 viewport)
{
std::lock_guard<std::mutex> lock(camera->_impl->CamMutex);
camera->Viewports->Raster = viewport;
camera->Views->Raster = viewport;
camera->ProjectionMatrix = glm::perspective(
glm::radians(camera->FOV),
static_cast<float>(viewport.x) / static_cast<float>(viewport.y),
@@ -119,19 +119,19 @@ void raster_set_viewport(std::unique_ptr<Camera>& camera, glm::ivec2 viewport)
glm::ivec2 raster_get_viewport(std::unique_ptr<Camera>& camera)
{
std::lock_guard<std::mutex> lock(camera->_impl->CamMutex);
return camera->Viewports->Raster;
return camera->Views->Raster;
}
void ray_set_viewport(std::unique_ptr<Camera>& camera, glm::ivec2 viewport)
{
std::lock_guard<std::mutex> lock(camera->_impl->CamMutex);
camera->Viewports->Ray = viewport;
camera->Views->Ray = viewport;
}
glm::ivec2 ray_get_viewport(std::unique_ptr<Camera>& camera)
{
std::lock_guard<std::mutex> lock(camera->_impl->CamMutex);
return camera->Viewports->Ray;
return camera->Views->Ray;
}
void camera_move(std::unique_ptr<Camera>& camera, uint8_t movement_delta)

7
src/scene/scene.hpp
View File

@@ -2,14 +2,17 @@
#include <vector>
namespace inferno {
namespace inferno::scene {
class SceneObject;
class Camera;
class Mesh;
class Sky;
class Scene
typedef struct Scene {
} Scene;
{
public:
Scene();