celisej567/Nuake-custom
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Rendering abstraction progress

Browse Source
This commit is contained in:
Antoine Pilote
2021-07-11 23:59:37 -04:00
parent 53564d4997
commit c2ce3c9cb9
14 changed files with 77 additions and 182 deletions
Download Patch File Download Diff File Expand all files Collapse all files

10
Nuake/src/Rendering/Buffers/VertexBuffer.cpp
View File

@@ -1,12 +1,12 @@
#include "VertexBuffer.h"
#include "src/Rendering/RenderCommand.h"
namespace Nuake {
VertexBuffer::VertexBuffer(const void* data, unsigned int size)
VertexBuffer::VertexBuffer(const void* data, unsigned int size, RendererEnum bufferType)
{
m_BufferType = bufferType;
RenderCommand::GenBuffer(m_RendererID);
Bind();
RenderCommand::SetBufferData(RendererEnum::ARRAY_BUFFER, data, size);
RenderCommand::SetBufferData(m_BufferType, data, size);
}
VertexBuffer::~VertexBuffer()
@@ -16,11 +16,11 @@ namespace Nuake {
void VertexBuffer::Bind() const
{
RenderCommand::BindBuffer(RendererEnum::ARRAY_BUFFER, m_RendererID);
RenderCommand::BindBuffer(m_BufferType, m_RendererID);
}
void VertexBuffer::Unbind() const
{
RenderCommand::BindBuffer(RendererEnum::ARRAY_BUFFER, 0);
RenderCommand::BindBuffer(m_BufferType, 0);
}
}

5
Nuake/src/Rendering/Buffers/VertexBuffer.h
View File

@@ -1,15 +1,18 @@
#pragma once
#include "src/Rendering/RenderCommand.h"
namespace Nuake {
class VertexBuffer
{
public:
VertexBuffer(const void* data, unsigned int size);
VertexBuffer() {}
VertexBuffer(const void* data, unsigned int size, RendererEnum bufferType = RendererEnum::ARRAY_BUFFER);
~VertexBuffer();
void Bind() const;
void Unbind() const;
private:
unsigned int m_RendererID = -1;
RendererEnum m_BufferType;
};
}

60
Nuake/src/Rendering/Mesh/Mesh.cpp
View File

@@ -19,61 +19,37 @@ namespace Nuake
void Mesh::setupMesh()
{
glGenVertexArrays(1, &VAO);
glGenBuffers(1, &VBO);
glGenBuffers(1, &EBO);
m_VertexArray = new VertexArray();
m_VertexArray->Bind();
m_VertexBuffer = new VertexBuffer(m_Vertices.data(), m_Vertices.size() * sizeof(Vertex));
m_ElementBuffer = new VertexBuffer(m_Indices.data(), m_Indices.size() * sizeof(unsigned int), RendererEnum::ELEMENT_ARRAY_BUFFER);
glBindVertexArray(VAO);
glBindBuffer(GL_ARRAY_BUFFER, VBO);
VertexBufferLayout bufferLayout = VertexBufferLayout();
bufferLayout.Push<float>(3); // Position
bufferLayout.Push<float>(2); // UV
bufferLayout.Push<float>(3); // Normal
bufferLayout.Push<float>(3); // Tangent
bufferLayout.Push<float>(3); // Bitangent
bufferLayout.Push<float>(1); // Texture
glBufferData(GL_ARRAY_BUFFER, m_Vertices.size() * sizeof(Vertex), &m_Vertices[0], GL_STATIC_DRAW);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, EBO);
glBufferData(GL_ELEMENT_ARRAY_BUFFER, m_Indices.size() * sizeof(unsigned int), &m_Indices[0], GL_STATIC_DRAW);
// vertex positions
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, sizeof(Vertex), (void*)0);
glEnableVertexAttribArray(0);
// UV
glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, sizeof(Vertex), (void*)(sizeof(GL_FLOAT) * 3));
glEnableVertexAttribArray(1);
// Normal
glVertexAttribPointer(2, 3, GL_FLOAT, GL_FALSE, sizeof(Vertex), (void*)(sizeof(GL_FLOAT) * 5));
glEnableVertexAttribArray(2);
// Tangent
glVertexAttribPointer(3, 3, GL_FLOAT, GL_FALSE, sizeof(Vertex), (void*)(sizeof(GL_FLOAT) * 8));
glEnableVertexAttribArray(3);
// Bi tangent
glVertexAttribPointer(4, 3, GL_FLOAT, GL_FALSE, sizeof(Vertex), (void*)(sizeof(GL_FLOAT) * 11));
glEnableVertexAttribArray(4);
// Texture
glVertexAttribPointer(5, 1, GL_FLOAT, GL_FALSE, sizeof(Vertex), (void*)(sizeof(GL_FLOAT) * 14));
glEnableVertexAttribArray(5);
glBindVertexArray(0);
m_VertexArray->AddBuffer(*m_VertexBuffer, bufferLayout);
m_VertexArray->Unbind();
}
void Mesh::Draw(bool drawMaterial)
{
if (drawMaterial)
m_Material->Bind();
// draw mesh
glBindVertexArray(VAO);
glDrawElements(GL_TRIANGLES, m_Indices.size(), GL_UNSIGNED_INT, 0);
//glBindVertexArray(0);
m_VertexArray->Bind();
RenderCommand::DrawElements(RendererEnum::TRIANGLES, m_Indices.size(), RendererEnum::UINT, 0);
}
void Mesh::DebugDraw()
{
Renderer::m_DebugShader->Bind();
Renderer::m_DebugShader->SetUniform4f("u_Color", 1.0f, 0.0f, 0.0f, 1.f);
glBindVertexArray(VAO);
glDrawElements(GL_TRIANGLES, m_Indices.size(), GL_UNSIGNED_INT, 0);
m_VertexArray->Bind();
RenderCommand::DrawElements(RendererEnum::TRIANGLES, m_Indices.size(), RendererEnum::UINT, 0);
}
}

17
Nuake/src/Rendering/Mesh/Mesh.h
View File

@@ -1,10 +1,13 @@
#pragma once
#include <vector>
#include "src/Rendering/Textures/Texture.h"
#include "src/Rendering/Vertex.h"
#include <glm\ext\matrix_float4x4.hpp>
#include "src/Rendering/Textures/Material.h"
#include "src/Core/Core.h"
#include "src/Core/Maths.h"
#include "src/Rendering/Textures/Material.h"
#include "src/Rendering/Vertex.h"
#include "src/Rendering/Buffers/VertexBuffer.h"
#include "src/Rendering/Buffers/VertexArray.h"
#include "src/Rendering/Buffers/VertexBufferLayout.h"
namespace Nuake
{
@@ -21,6 +24,10 @@ namespace Nuake
void DebugDraw();
private:
VertexBuffer* m_VertexBuffer;
VertexArray* m_VertexArray;
VertexBuffer* m_ElementBuffer;
unsigned int VAO, VBO, EBO;
void setupMesh();
};

10
Nuake/src/Rendering/Platforms/OGLRendererAPI.cpp
View File

@@ -54,7 +54,13 @@ namespace Nuake {
void OGLRendererAPI::VertexAttribPointer(const unsigned int index, const int size, const RendererEnum type, bool normalized, int stride, const void* pointer)
{
glVertexAttribPointer(index, size, GetType(type), normalized, stride, pointer);
GLenum glType = GetType(type);
glVertexAttribPointer(index, size, glType, normalized, stride, pointer);
}
void OGLRendererAPI::DrawElements(const RendererEnum mode, const int count, const RendererEnum type, const void* indices)
{
glDrawElements(GetType(mode), count, GetType(type), indices);
}
void OGLRendererAPI::DrawArrays(int from, int count)
@@ -67,12 +73,14 @@ namespace Nuake {
switch (bufferType)
{
case RendererEnum::ARRAY_BUFFER: return GL_ARRAY_BUFFER;
case RendererEnum::ELEMENT_ARRAY_BUFFER: return GL_ELEMENT_ARRAY_BUFFER;
case RendererEnum::FLOAT: return GL_FLOAT;
case RendererEnum::UFLOAT: return GL_BYTE;
case RendererEnum::BYTE: return GL_BYTE;
case RendererEnum::UBYTE: return GL_UNSIGNED_BYTE;
case RendererEnum::INT: return GL_INT;
case RendererEnum::UINT: return GL_UNSIGNED_INT;
case RendererEnum::TRIANGLES: return GL_TRIANGLES;
}
return 0;

1
Nuake/src/Rendering/Platforms/OGLRendererAPI.h
View File

@@ -22,6 +22,7 @@ namespace Nuake {
void EnableVertexAttribArray(unsigned int& index) override;
void VertexAttribPointer(const unsigned int index, const int size, const RendererEnum type, bool normalized, int stride, const void* pointer) override;
void DrawElements(const RendererEnum mode, const int count, const RendererEnum type, const void* indices) override;
void DrawArrays(int from, int count) override;
private:
GLenum GetType(const RendererEnum& bufferType);

5
Nuake/src/Rendering/Platforms/RendererAPI.h
View File

@@ -5,7 +5,9 @@ namespace Nuake {
enum class RendererEnum {
INT, UINT, BYTE, UBYTE,
FLOAT, UFLOAT,
ARRAY_BUFFER
ARRAY_BUFFER,
ELEMENT_ARRAY_BUFFER,
TRIANGLES
};
class RendererAPI
@@ -25,6 +27,7 @@ namespace Nuake {
virtual void EnableVertexAttribArray(unsigned int& index) = 0;
virtual void VertexAttribPointer(const unsigned int index, const int size, const RendererEnum type, bool normalized, int stride, const void* pointer) = 0;
virtual void DrawElements(const RendererEnum mode, const int count, const RendererEnum type, const void* indices) = 0;
virtual void DrawArrays(int from, int count) = 0;
};
}

5
Nuake/src/Rendering/RenderCommand.cpp
View File

@@ -64,6 +64,11 @@ namespace Nuake {
sRendererAPI->VertexAttribPointer(index, size, type, normalized, stride, pointer);
}
void RenderCommand::DrawElements(const RendererEnum mode, const int count, const RendererEnum type, const void* indices)
{
sRendererAPI->DrawElements(mode, count, type, indices);
}
void RenderCommand::DrawArrays(int first, int count)
{
sRendererAPI->DrawArrays(first, count);

1
Nuake/src/Rendering/RenderCommand.h
View File

@@ -27,6 +27,7 @@ namespace Nuake {
static void BindVertexArray(const unsigned int& rendererID);
static void VertexAttribPointer(const unsigned int index, const int size, const RendererEnum type, bool normalized, int stride, const void* pointer);
static void DrawElements(const RendererEnum mode, const int count, const RendererEnum type, const void* indices);
static void DrawArrays(int first, int count);
private:
static RendererAPI* sRendererAPI;

36
Nuake/src/Rendering/Renderer.cpp
View File

@@ -29,6 +29,7 @@ namespace Nuake
Ref<Shader> Renderer::m_ShadowmapShader;
VertexArray* Renderer::QuadVertexArray;
VertexBuffer* Renderer::QuadVertexBuffer;
unsigned int CubeVAO;
unsigned int CubeVBO;
@@ -85,43 +86,29 @@ namespace Nuake
QuadVertexArray = new VertexArray();
QuadVertexArray->Bind();
VertexBuffer quadVertexBuffer(QuadVertices, sizeof(QuadVertices));
QuadVertexBuffer = new VertexBuffer(QuadVertices, sizeof(QuadVertices));
VertexBufferLayout vblayout = VertexBufferLayout();
vblayout.Push<float>(3);
vblayout.Push<float>(2);
QuadVertexArray->AddBuffer(quadVertexBuffer, vblayout);
//glGenVertexArrays(1, &QuadVAO);`
//glBindVertexArray(QuadVAO);
//
//glGenBuffers(1, &QuadVBO);
//glBindBuffer(GL_ARRAY_BUFFER, QuadVBO);
//glBufferData(GL_ARRAY_BUFFER, sizeof(QuadVertices), QuadVertices, GL_STATIC_DRAW);
//
//glEnableVertexAttribArray(0);
//glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 5 * sizeof(float), (void*)0);
//glEnableVertexAttribArray(1);
//glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, 5 * sizeof(float), (void*)(3 * sizeof(float)));
QuadVertexArray->AddBuffer(*QuadVertexBuffer, vblayout);
}
void Renderer::LoadShaders()
{
m_ShadowmapShader = ShaderManager::GetShader("resources/Shaders/shadowMap.shader");
m_SkyboxShader = ShaderManager::GetShader("resources/Shaders/skybox.shader");
m_BRDShader = ShaderManager::GetShader("resources/Shaders/BRD.shader");
m_GBufferShader = ShaderManager::GetShader("resources/Shaders/gbuffer.shader");
m_DeferredShader = ShaderManager::GetShader("resources/Shaders/deferred.shader");
m_ShadowmapShader = ShaderManager::GetShader("resources/Shaders/shadowMap.shader");
m_SkyboxShader = ShaderManager::GetShader("resources/Shaders/skybox.shader");
m_BRDShader = ShaderManager::GetShader("resources/Shaders/BRD.shader");
m_GBufferShader = ShaderManager::GetShader("resources/Shaders/gbuffer.shader");
m_DeferredShader = ShaderManager::GetShader("resources/Shaders/deferred.shader");
m_ProceduralSkyShader = ShaderManager::GetShader("resources/Shaders/atmospheric_sky.shader");
m_DebugShader = ShaderManager::GetShader("resources/Shaders/debug.shader");
m_Shader = ShaderManager::GetShader("resources/Shaders/basic.shader");
m_DebugShader = ShaderManager::GetShader("resources/Shaders/debug.shader");
m_Shader = ShaderManager::GetShader("resources/Shaders/basic.shader");
}
void Renderer::BeginDraw(Ref<Camera> camera)
{
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
RenderCommand::Clear();
m_Shader->Bind();
m_Shader->SetUniformMat4f("u_Projection", camera->GetPerspective());
@@ -141,6 +128,7 @@ namespace Nuake
{
if (m_Lights.size() == 20)
return;
m_Lights.push_back({ transform , light });
// What light idx is this?

2
Nuake/src/Rendering/Renderer.h
View File

@@ -16,6 +16,8 @@ namespace Nuake
{
public:
static VertexArray* Renderer::QuadVertexArray;
static VertexBuffer* Renderer::QuadVertexBuffer;
static Ref<Shader> m_Shader;
static Ref<Shader> m_ShadowmapShader;
static Ref<Shader> m_SkyboxShader;

4
Nuake/src/Scene/Components/LightComponent.cpp
View File

@@ -1,10 +1,10 @@
#pragma once
//#include <imgui\imgui.h>
#include "LightComponent.h"
#include "../../../Rendering/Renderer.h"
#include "src/Rendering/Renderer.h"
#include <GL\glew.h>
#include "../Core/Core.h"
#include "src/Core/Core.h"
#include <src/Scene/Entities/ImGuiHelper.h>
namespace Nuake {

101
Nuake/src/Scene/Components/MeshComponent.cpp
View File

@@ -62,107 +62,10 @@ namespace Nuake {
//
//ProcessNode(scene->mRootNode, scene);
}
unsigned int sphereVAO = 0;
unsigned int indexCount;
void MeshComponent::RenderSphere() {
if (sphereVAO == 0)
{
glGenVertexArrays(1, &sphereVAO);
unsigned int vbo, ebo;
glGenBuffers(1, &vbo);
glGenBuffers(1, &ebo);
std::vector<glm::vec3> positions;
std::vector<glm::vec2> uv;
std::vector<glm::vec3> normals;
std::vector<unsigned int> indices;
const unsigned int X_SEGMENTS = 64;
const unsigned int Y_SEGMENTS = 64;
const float PI = 3.14159265359;
for (unsigned int y = 0; y <= Y_SEGMENTS; ++y)
{
for (unsigned int x = 0; x <= X_SEGMENTS; ++x)
{
float xSegment = (float)x / (float)X_SEGMENTS;
float ySegment = (float)y / (float)Y_SEGMENTS;
float xPos = std::cos(xSegment * 2.0f * PI) * std::sin(ySegment * PI);
float yPos = std::cos(ySegment * PI);
float zPos = std::sin(xSegment * 2.0f * PI) * std::sin(ySegment * PI);
positions.push_back(glm::vec3(xPos, yPos, zPos));
uv.push_back(glm::vec2(xSegment, ySegment));
normals.push_back(glm::vec3(xPos, yPos, zPos));
}
}
bool oddRow = false;
for (unsigned int y = 0; y < Y_SEGMENTS; ++y)
{
if (!oddRow) // even rows: y == 0, y == 2; and so on
{
for (unsigned int x = 0; x <= X_SEGMENTS; ++x)
{
indices.push_back(y * (X_SEGMENTS + 1) + x);
indices.push_back((y + 1) * (X_SEGMENTS + 1) + x);
}
}
else
{
for (int x = X_SEGMENTS; x >= 0; --x)
{
indices.push_back((y + 1) * (X_SEGMENTS + 1) + x);
indices.push_back(y * (X_SEGMENTS + 1) + x);
}
}
oddRow = !oddRow;
}
indexCount = indices.size();
std::vector<float> data;
for (std::size_t i = 0; i < positions.size(); ++i)
{
data.push_back(positions[i].x);
data.push_back(positions[i].y);
data.push_back(positions[i].z);
if (uv.size() > 0)
{
data.push_back(uv[i].x);
data.push_back(uv[i].y);
}
if (normals.size() > 0)
{
data.push_back(normals[i].x);
data.push_back(normals[i].y);
data.push_back(normals[i].z);
}
}
glBindVertexArray(sphereVAO);
glBindBuffer(GL_ARRAY_BUFFER, vbo);
glBufferData(GL_ARRAY_BUFFER, data.size() * sizeof(float), &data[0], GL_STATIC_DRAW);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, ebo);
glBufferData(GL_ELEMENT_ARRAY_BUFFER, indices.size() * sizeof(unsigned int), &indices[0], GL_STATIC_DRAW);
float stride = (3 + 2 + 3) * sizeof(float);
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, sizeof(Vertex), (void*)0);
glEnableVertexAttribArray(0);
glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, sizeof(Vertex), (void*)(sizeof(GL_FLOAT) * 3));
glEnableVertexAttribArray(1);
glVertexAttribPointer(2, 3, GL_FLOAT, GL_FALSE, sizeof(Vertex), (void*)(sizeof(GL_FLOAT) * 5));
glEnableVertexAttribArray(2);
glVertexAttribPointer(3, 1, GL_FLOAT, GL_FALSE, sizeof(Vertex), (void*)(sizeof(GL_FLOAT) * 8));
glEnableVertexAttribArray(3);
}
glBindVertexArray(sphereVAO);
glDrawElements(GL_TRIANGLE_STRIP, indexCount, GL_UNSIGNED_INT, 0);
}
//void MeshComponent::ProcessNode(aiNode * node, const aiScene* scene)
//{

2
Nuake/src/Scene/Components/MeshComponent.h
View File

@@ -20,7 +20,5 @@ namespace Nuake {
void SetMaterial(const std::string materialName);
void Draw(glm::mat4 projection, glm::mat4 view, glm::mat4 transform);
void DrawEditor();
void RenderSphere();
};
}