riyyi
/
inferno
1
0
Vork 0
Code Kwesties Pull-aanvragen Publicaties Wiki Activiteit

Vergelijk commits

basis: riyyi:4dbac7ee3898a8a0357ec67c17821ce9734be51f
Branches Labels
riyyi:master
..
vergelijk: riyyi:cd36841039504725d03cf99242a44f0fba75e8cb
Branches Labels
riyyi:master

Geen overeenkomstige commits. '4dbac7ee3898a8a0357ec67c17821ce9734be51f' en 'cd36841039504725d03cf99242a44f0fba75e8cb' hebben totaal verschillende histories.
4dbac7ee38 ... cd36841039

8 gewijzigde bestanden met toevoegingen van 198 en 202 verwijderingen
Witregel
Toon alle wijzigingen Witruimte negeren bij het vergelijken van regels Negeer veranderingen in de hoeveelheid witruimte Negeren van wijzigingen in witruimte op EOL
Zij-aan-zij weergave
Diff opties
Statistieken weergeven
  1. 33
      src/inferno/application.cpp
  2. 5
      src/inferno/application.h
  3. 131
      src/inferno/render/buffer.cpp
  4. 14
      src/inferno/render/buffer.h
  5. 115
      src/inferno/render/framebuffer.cpp
  6. 89
      src/inferno/render/framebuffer.h
  7. 10
      src/inferno/render/render-command.cpp
  8. 3
      src/inferno/render/render-command.h

33
src/inferno/application.cpp
Unescape Bestand weergeven

@ -53,19 +53,10 @@ Application::Application()
Input::initialize();
RenderCommand::initialize();
m_framebuffer = Framebuffer::create({
.attachments = { Framebuffer::Type::Color, Framebuffer::Type::Depth },
.width = m_window->getWidth(),
.height = m_window->getHeight(),
.clearColor = { 0.2f, 0.3f, 0.3f, 1.0f },
.clearBit = GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT,
});
m_screenFramebuffer = Framebuffer::create({
.renderToScreen = true,
.clearColor = { 1.0f, 1.0f, 1.0f, 1.0f },
.clearBit = GL_COLOR_BUFFER_BIT,
});
m_framebuffer = std::make_unique<Framebuffer>(
Framebuffer::Properties { .type = Framebuffer::Type::Color | Framebuffer::Type::Depth | Framebuffer::Type::Stencil,
.width = m_window->getWidth(),
.height = m_window->getHeight() });
m_scene = std::make_shared<Scene>();
m_scene->initialize();
@ -184,11 +175,11 @@ int Application::run()
m_framebuffer->bind();
RenderCommand::clearColor(m_framebuffer->clearColor());
RenderCommand::clearBit(m_framebuffer->clearBit());
render();
RenderCommand::clearColor({ 0.2f, 0.3f, 0.3f, 1.0f });
RenderCommand::clearColorDepthBit();
std::pair<glm::mat4, glm::mat4> projectionView = m_scene->cameraProjectionView();
RendererCubemap::the().beginScene(projectionView.first, projectionView.second); // camera, lights, environment
Renderer3D::the().beginScene(projectionView.first, projectionView.second); // camera, lights, environment
@ -208,10 +199,8 @@ int Application::run()
// ---------------------------------
// Framebuffer
m_screenFramebuffer->bind();
RenderCommand::clearColor(m_screenFramebuffer->clearColor());
RenderCommand::clearBit(m_screenFramebuffer->clearBit());
RenderCommand::clearColor({ 1.0f, 1.0f, 1.0f, 1.0f });
RenderCommand::clearColorBit();
Renderer2D::the().setEnableDepthBuffer(false);
Renderer2D::the().beginScene(matIdentity, matIdentity);
@ -219,8 +208,6 @@ int Application::run()
Renderer2D::the().endScene();
Renderer2D::the().setEnableDepthBuffer(true);
m_screenFramebuffer->unbind();
m_window->render();
}
@ -255,7 +242,7 @@ bool Application::onWindowResize(WindowResizeEvent& e)
ruc::info("WindowResizeEvent {}x{}", e.getWidth(), e.getHeight());
RenderCommand::setViewport(0, 0, e.getWidth(), e.getHeight());
m_framebuffer->resize(e.getWidth(), e.getHeight());
m_framebuffer->setSize(e.getWidth(), e.getHeight());
return true;
}

5
src/inferno/application.h
Unescape Bestand weergeven

@ -1,5 +1,5 @@
/*
* Copyright (C) 2022,2024 Riyyi
* Copyright (C) 2022 Riyyi
*
* SPDX-License-Identifier: MIT
*/
@ -51,9 +51,8 @@ private:
float m_lastFrameTime { 0.0f };
std::unique_ptr<Window> m_window;
std::shared_ptr<Framebuffer> m_framebuffer;
std::shared_ptr<Framebuffer> m_screenFramebuffer;
std::shared_ptr<Scene> m_scene;
std::unique_ptr<Framebuffer> m_framebuffer;
//
std::shared_ptr<Font> m_font;

131
src/inferno/render/buffer.cpp
Unescape Bestand weergeven

@ -5,9 +5,10 @@
*/
#include "glad/glad.h"
#include "ruc/meta/assert.h"
#include "inferno/core.h"
#include "inferno/render/buffer.h"
#include "ruc/meta/assert.h"
namespace Inferno {
@ -42,38 +43,57 @@ uint32_t BufferElement::getTypeSize(const BufferElementType type)
case BufferElementType::None:
return 0;
case BufferElementType::Bool:
return sizeof(bool);
case BufferElementType::Bool2:
return sizeof(bool) * 2;
case BufferElementType::Bool3:
return sizeof(bool) * 3;
case BufferElementType::Bool4:
return sizeof(bool) * getTypeCount(type);
return sizeof(bool) * 4;
case BufferElementType::Int:
return sizeof(int32_t);
case BufferElementType::Int2:
return sizeof(int32_t) * 2;
case BufferElementType::Int3:
return sizeof(int32_t) * 3;
case BufferElementType::Int4:
return sizeof(int32_t) * getTypeCount(type);
return sizeof(int32_t) * 4;
case BufferElementType::Uint:
return sizeof(uint32_t);
case BufferElementType::Uint2:
return sizeof(uint32_t) * 2;
case BufferElementType::Uint3:
return sizeof(uint32_t) * 3;
case BufferElementType::Uint4:
return sizeof(uint32_t) * getTypeCount(type);
return sizeof(uint32_t) * 4;
case BufferElementType::Float:
return sizeof(float);
case BufferElementType::Vec2:
return sizeof(float) * 2;
case BufferElementType::Vec3:
return sizeof(float) * 3;
case BufferElementType::Vec4:
return sizeof(float) * getTypeCount(type);
case BufferElementType::VecDouble:
case BufferElementType::VecDouble2:
case BufferElementType::VecDouble3:
case BufferElementType::VecDouble4:
return sizeof(double) * getTypeCount(type);
return sizeof(float) * 4;
case BufferElementType::Double:
return sizeof(double);
case BufferElementType::Double2:
return sizeof(double);
case BufferElementType::Double3:
return sizeof(double);
case BufferElementType::Double4:
return sizeof(double);
case BufferElementType::Mat2:
return sizeof(float) * 2 * 2;
case BufferElementType::Mat3:
return sizeof(float) * 3 * 3;
case BufferElementType::Mat4:
return sizeof(float) * getTypeCount(type);
case BufferElementType::MatDouble2:
case BufferElementType::MatDouble3:
case BufferElementType::MatDouble4:
return sizeof(double) * getTypeCount(type);
return sizeof(float) * 4 * 4;
case BufferElementType::DoubleMat2:
return sizeof(double) * 2 * 2;
case BufferElementType::DoubleMat3:
return sizeof(double) * 3 * 3;
case BufferElementType::DoubleMat4:
return sizeof(double) * 4 * 4;
};
VERIFY(false, "BufferElement unknown BufferElementType size!");
@ -86,28 +106,44 @@ uint32_t BufferElement::getTypeCount(const BufferElementType type)
case BufferElementType::None:
return 0;
case BufferElementType::Bool:
case BufferElementType::Int:
case BufferElementType::Uint:
case BufferElementType::Float:
case BufferElementType::VecDouble:
return 1;
case BufferElementType::Bool2:
case BufferElementType::Int2:
case BufferElementType::Uint2:
case BufferElementType::Vec2:
case BufferElementType::VecDouble2:
return 2;
case BufferElementType::Bool3:
case BufferElementType::Int3:
case BufferElementType::Uint3:
case BufferElementType::Vec3:
case BufferElementType::VecDouble3:
return 3;
case BufferElementType::Bool4:
return 4;
case BufferElementType::Int:
return 1;
case BufferElementType::Int2:
return 2;
case BufferElementType::Int3:
return 3;
case BufferElementType::Int4:
return 4;
case BufferElementType::Uint:
return 1;
case BufferElementType::Uint2:
return 2;
case BufferElementType::Uint3:
return 3;
case BufferElementType::Uint4:
return 4;
case BufferElementType::Float:
return 1;
case BufferElementType::Vec2:
return 2;
case BufferElementType::Vec3:
return 3;
case BufferElementType::Vec4:
case BufferElementType::VecDouble4:
return 4;
case BufferElementType::Double:
return 1;
case BufferElementType::Double2:
return 2;
case BufferElementType::Double3:
return 3;
case BufferElementType::Double4:
return 4;
case BufferElementType::Mat2:
return 2 * 2;
@ -115,11 +151,11 @@ uint32_t BufferElement::getTypeCount(const BufferElementType type)
return 3 * 3;
case BufferElementType::Mat4:
return 4 * 4;
case BufferElementType::MatDouble2:
case BufferElementType::DoubleMat2:
return 2 * 2;
case BufferElementType::MatDouble3:
case BufferElementType::DoubleMat3:
return 3 * 3;
case BufferElementType::MatDouble4:
case BufferElementType::DoubleMat4:
return 4 * 4;
};
@ -133,37 +169,56 @@ uint32_t BufferElement::getTypeGL(const BufferElementType type)
case BufferElementType::None:
return GL_NONE;
case BufferElementType::Bool:
return GL_BOOL;
case BufferElementType::Bool2:
return GL_BOOL;
case BufferElementType::Bool3:
return GL_BOOL;
case BufferElementType::Bool4:
return GL_BOOL;
case BufferElementType::Int:
return GL_INT;
case BufferElementType::Int2:
return GL_INT;
case BufferElementType::Int3:
return GL_INT;
case BufferElementType::Int4:
return GL_INT;
case BufferElementType::Uint:
return GL_UNSIGNED_INT;
case BufferElementType::Uint2:
return GL_UNSIGNED_INT;
case BufferElementType::Uint3:
return GL_UNSIGNED_INT;
case BufferElementType::Uint4:
return GL_UNSIGNED_INT;
case BufferElementType::Float:
return GL_FLOAT;
case BufferElementType::Vec2:
return GL_FLOAT;
case BufferElementType::Vec3:
return GL_FLOAT;
case BufferElementType::Vec4:
return GL_FLOAT;
case BufferElementType::VecDouble:
case BufferElementType::VecDouble2:
case BufferElementType::VecDouble3:
case BufferElementType::VecDouble4:
case BufferElementType::Double:
return GL_DOUBLE;
case BufferElementType::Double2:
return GL_DOUBLE;
case BufferElementType::Double3:
return GL_DOUBLE;
case BufferElementType::Double4:
return GL_DOUBLE;
case BufferElementType::Mat2:
return GL_FLOAT;
case BufferElementType::Mat3:
return GL_FLOAT;
case BufferElementType::Mat4:
return GL_FLOAT;
case BufferElementType::MatDouble2:
case BufferElementType::MatDouble3:
case BufferElementType::MatDouble4:
case BufferElementType::DoubleMat2:
return GL_DOUBLE;
case BufferElementType::DoubleMat3:
return GL_DOUBLE;
case BufferElementType::DoubleMat4:
return GL_DOUBLE;
};

14
src/inferno/render/buffer.h
Unescape Bestand weergeven

@ -18,13 +18,13 @@ namespace Inferno {
// https://www.khronos.org/opengl/wiki/Data_Type_(GLSL)
enum class BufferElementType {
None = 0,
Bool, Bool2, Bool3, Bool4, // bvec
Int, Int2, Int3, Int4, // ivec
Uint, Uint2, Uint3, Uint4, // uvec
Float, Vec2, Vec3, Vec4, // vec
VecDouble, VecDouble2, VecDouble3, VecDouble4, // dvec
Mat2, Mat3, Mat4, // mat
MatDouble2, MatDouble3, MatDouble4, // dmat
Bool, Bool2, Bool3, Bool4, // bvec
Int, Int2, Int3, Int4, // ivec
Uint, Uint2, Uint3, Uint4, // uvec
Float, Vec2, Vec3, Vec4, // vec
Double, Double2, Double3, Double4, // dvec
Mat2, Mat3, Mat4, // mat
DoubleMat2, DoubleMat3, DoubleMat4, // dmat
};
// clang-format on

115
src/inferno/render/framebuffer.cpp
Unescape Bestand weergeven

@ -4,8 +4,7 @@
* SPDX-License-Identifier: MIT
*/
#include <cstddef> // size_t
#include <cstdint> // uint8_t, uint32_t
#include <cstdint> // int8_t
#include "glad/glad.h"
#include "ruc/meta/assert.h"
@ -15,34 +14,34 @@
namespace Inferno {
std::shared_ptr<Framebuffer> Framebuffer::create(const Properties& properties)
Framebuffer::Framebuffer(const Properties& init)
: m_type(init.type)
, m_width(init.width)
, m_height(init.height)
{
VERIFY((properties.attachments.size() > 0 && !properties.renderToScreen) || properties.renderToScreen,
"cant have attachments on the default framebuffer");
VERIFY(static_cast<int8_t>(init.type) != 0,
"malformed framebuffer type: {}", init.type);
auto result = std::shared_ptr<Framebuffer>(new Framebuffer(properties));
if (!properties.renderToScreen) {
result->m_id = UINT_MAX;
glGenFramebuffers(1, &result->m_id);
}
result->createTextures();
m_id = UINT_MAX;
glGenFramebuffers(1, &m_id);
return result;
createTextures();
}
Framebuffer::~Framebuffer()
{
if (m_renderToScreen) {
return;
}
glDeleteFramebuffers(1, &m_id);
}
// -----------------------------------------
bool Framebuffer::check() const
{
VERIFY(glCheckFramebufferStatus(GL_FRAMEBUFFER) == GL_FRAMEBUFFER_COMPLETE,
"malformed framebuffer: {:#x}", glCheckFramebufferStatus(GL_FRAMEBUFFER));
return true;
}
void Framebuffer::bind() const
{
glBindFramebuffer(GL_FRAMEBUFFER, m_id);
@ -53,14 +52,7 @@ void Framebuffer::unbind() const
glBindFramebuffer(GL_FRAMEBUFFER, 0);
}
bool Framebuffer::check() const
{
VERIFY(glCheckFramebufferStatus(GL_FRAMEBUFFER) == GL_FRAMEBUFFER_COMPLETE,
"malformed framebuffer: {:#x}", glCheckFramebufferStatus(GL_FRAMEBUFFER));
return true;
}
void Framebuffer::resize(uint32_t width, uint32_t height)
void Framebuffer::setSize(uint32_t width, uint32_t height)
{
if (m_width == width && m_height == height) {
return;
@ -76,55 +68,40 @@ void Framebuffer::resize(uint32_t width, uint32_t height)
void Framebuffer::createTextures()
{
if (m_renderToScreen) {
return;
}
bind();
if (m_id) {
glDeleteFramebuffers(1, &m_id);
m_textures.clear();
m_textures[0] = AssetManager::the().remove(FRAMEBUFFER_TEXTURE_COLOR);
m_textures[1] = AssetManager::the().remove(FRAMEBUFFER_TEXTURE_DEPTH);
m_textures[2] = AssetManager::the().remove(FRAMEBUFFER_TEXTURE_STENCIL);
m_textures[3] = AssetManager::the().remove(FRAMEBUFFER_TEXTURE_DEPTH_STENCIL);
if (m_type & Type::Color) {
// Set color attachment 0 out of 32
m_textures[0] = AssetManager::the().load<TextureFramebuffer>(
FRAMEBUFFER_TEXTURE_COLOR, m_width, m_height, GL_RGB, GL_RGB);
m_textures[0]->bind(0);
glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, m_textures[0]->id(), 0);
m_textures[0]->unbind();
}
m_id = UINT_MAX;
glGenFramebuffers(1, &m_id);
bind();
auto it = m_attachments.begin();
uint8_t color_attachment = 0;
size_t size = m_attachments.size();
m_textures.resize(size);
for (size_t i = 0; i < size; ++i) {
TypeProperties type = *(it + i);
if (type.type == Type::Color) {
// Set color attachment 0 out of 32
m_textures[i] = (TextureFramebuffer::create(
"", m_width, m_height, GL_RGB, GL_RGB));
glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0 + color_attachment, GL_TEXTURE_2D, m_textures[i]->id(), 0);
}
// This combined texture is required for older GPUs
if (type.type == Type::Depth24Stencil8) {
m_textures[i] = (TextureFramebuffer::create(
"", m_width, m_height, GL_DEPTH24_STENCIL8, GL_DEPTH_STENCIL, GL_UNSIGNED_INT_24_8));
glFramebufferTexture2D(GL_FRAMEBUFFER, GL_DEPTH_STENCIL_ATTACHMENT, GL_TEXTURE_2D, m_textures[i]->id(), 0);
continue;
}
if (type.type == Type::Depth32F) {
// FIXME: This isnt a 32-bit float texture
m_textures[i] = (TextureFramebuffer::create(
"", m_width, m_height, GL_DEPTH_COMPONENT, GL_DEPTH_COMPONENT));
glFramebufferTexture2D(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_TEXTURE_2D, m_textures[i]->id(), 0);
continue;
}
// This combined texture is required for older GPUs
if (m_type & Type::Depth && m_type & Stencil) {
m_textures[3] = AssetManager::the().load<TextureFramebuffer>(
FRAMEBUFFER_TEXTURE_DEPTH_STENCIL, m_width, m_height, GL_DEPTH24_STENCIL8, GL_DEPTH_STENCIL, GL_UNSIGNED_INT_24_8);
glFramebufferTexture2D(GL_FRAMEBUFFER, GL_DEPTH_STENCIL_ATTACHMENT, GL_TEXTURE_2D, m_textures[3]->id(), 0);
}
else if (m_type & Type::Depth) {
m_textures[1] = AssetManager::the().load<TextureFramebuffer>(
FRAMEBUFFER_TEXTURE_DEPTH, m_width, m_height, GL_DEPTH_COMPONENT, GL_DEPTH_COMPONENT);
glFramebufferTexture2D(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_TEXTURE_2D, m_textures[1]->id(), 0);
}
else if (m_type & Type::Stencil) {
m_textures[2] = AssetManager::the().load<TextureFramebuffer>(
FRAMEBUFFER_TEXTURE_STENCIL, m_width, m_height, GL_STENCIL_INDEX, GL_STENCIL_INDEX);
glFramebufferTexture2D(GL_FRAMEBUFFER, GL_STENCIL_ATTACHMENT, GL_TEXTURE_2D, m_textures[2]->id(), 0);
}
VERIFY(color_attachment <= 32, "maximum color attachments was exceeded: {}/32", color_attachment);
check();
unbind();
}

89
src/inferno/render/framebuffer.h
Unescape Bestand weergeven

@ -6,94 +6,67 @@
#pragma once
#include <cstddef> // size_t
#include <cstdint> // uint8_t
#include <initializer_list>
#include <memory> // std::shared_ptr
#include <vector>
#include "glm/ext/vector_float4.hpp" // glm::vec4
#include <cstdint> // int8_t
#include <memory> // std::shared_ptr
#include "inferno/asset/texture.h"
#include "ruc/meta/core.h"
// AssetManager paths to the global framebuffer textures
#define FRAMEBUFFER_TEXTURE_COLOR "@framebuffer-color"
#define FRAMEBUFFER_TEXTURE_DEPTH "@framebuffer-depth"
#define FRAMEBUFFER_TEXTURE_STENCIL "@framebuffer-stencil"
#define FRAMEBUFFER_TEXTURE_DEPTH_STENCIL "@framebuffer-depth-stencil"
namespace Inferno {
class Framebuffer final { // Frame Buffer Object, FBO
public:
enum Type : uint8_t {
enum Type : int8_t {
None = 0,
// Color
RGBA8 = 1,
// Depth/stencil
Depth32F = 2,
Depth24Stencil8 = 3,
// Defaults
Color = RGBA8,
Depth = Depth24Stencil8,
};
struct TypeProperties {
TypeProperties() = default;
TypeProperties(Type type)
: type(type)
{
}
Type type;
Color = BIT(0),
Depth = BIT(1),
Stencil = BIT(2),
};
struct Properties {
std::initializer_list<TypeProperties> attachments {};
bool renderToScreen { false }; // (dummy framebuffer)
Type type { None };
uint32_t width { 1280 };
uint32_t height { 720 };
glm::vec4 clearColor { 1.0f, 0.0f, 1.0f, 1.0f }; // magenta
uint32_t clearBit { 0 };
};
Framebuffer(const Properties& init);
~Framebuffer();
// Factory function
static std::shared_ptr<Framebuffer> create(const Properties& properties);
bool check() const;
void bind() const;
void unbind() const;
bool check() const;
void resize(uint32_t width, uint32_t height);
uint32_t id() const { return m_id; }
void setSize(uint32_t width, uint32_t height);
Type type() const { return m_type; }
uint32_t width() const { return m_width; }
uint32_t height() const { return m_height; }
uint32_t clearBit() const { return m_clearBit; }
glm::vec4 clearColor() const { return m_clearColor; }
const std::vector<TypeProperties>& attachments() const { return m_attachments; }
std::shared_ptr<TextureFramebuffer> texture(size_t index) const { return m_textures[index]; }
uint32_t id() const { return m_id; }
std::shared_ptr<TextureFramebuffer> texture(uint8_t index) const { return m_textures[index]; }
private:
Framebuffer(const Properties& properties)
: m_renderToScreen(properties.renderToScreen)
, m_width(properties.width)
, m_height(properties.height)
, m_clearBit(properties.clearBit)
, m_clearColor(properties.clearColor)
, m_attachments(properties.attachments)
{
}
void createTextures();
private:
bool m_renderToScreen { false };
uint32_t m_id { 0 };
Type m_type { None };
uint32_t m_width { 0 };
uint32_t m_height { 0 };
uint32_t m_clearBit { 0 };
glm::vec4 m_clearColor;
std::vector<TypeProperties> m_attachments;
std::vector<std::shared_ptr<TextureFramebuffer>> m_textures;
uint32_t m_id { 0 };
std::shared_ptr<TextureFramebuffer> m_textures[4] { nullptr, nullptr, nullptr, nullptr };
};
// Make bitwise OR '|' return the enum type instead of int
inline Framebuffer::Type operator|(Framebuffer::Type lhs, Framebuffer::Type rhs)
{
return static_cast<Framebuffer::Type>(
static_cast<int8_t>(lhs) | static_cast<int8_t>(rhs));
}
} // namespace Inferno

10
src/inferno/render/render-command.cpp
Unescape Bestand weergeven

@ -29,10 +29,14 @@ void RenderCommand::destroy()
{
}
void RenderCommand::clearBit(uint32_t bits)
void RenderCommand::clearColorDepthBit()
{
// GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT
glClear(bits);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
}
void RenderCommand::clearColorBit()
{
glClear(GL_COLOR_BUFFER_BIT);
}
void RenderCommand::clearColor(const glm::vec4& color)

3
src/inferno/render/render-command.h
Unescape Bestand weergeven

@ -19,7 +19,8 @@ public:
static void initialize();
static void destroy();
static void clearBit(uint32_t bits);
static void clearColorDepthBit();
static void clearColorBit();
static void clearColor(const glm::vec4& color);
static void drawIndexed(std::shared_ptr<VertexArray> vertexArray, uint32_t indexCount = 0);

Schrijf Voorbeeld
Laden…
Annuleren
Opslaan