372 lines
14 KiB
C++
372 lines
14 KiB
C++
#include "Debug.h"
|
|
#include "RenderSystem.h"
|
|
#include "common.h"
|
|
#include "VBO.h"
|
|
#include "VAO.h"
|
|
#include "EBO.h"
|
|
#include "FBO.h"
|
|
#include "shaderClass.h"
|
|
#include "Object.h"
|
|
#include "Camera.h"
|
|
#include "Cubemap.h"
|
|
#include "QuadVertices.h"
|
|
#include "Lighting.h"
|
|
#include "Animator.h"
|
|
|
|
// ============================================================================
|
|
// Initialize
|
|
// ============================================================================
|
|
void RenderSystem::Initialize()
|
|
{
|
|
glEnable(GL_DEPTH_TEST);
|
|
glViewport(0, 0, window->width, window->height);
|
|
glEnable(GL_MULTISAMPLE);
|
|
glEnable(GL_BLEND);
|
|
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
|
|
glEnable(GL_CULL_FACE);
|
|
glCullFace(GL_BACK);
|
|
glFrontFace(GL_CCW);
|
|
|
|
// Screen quad
|
|
screenfbo = new FBO();
|
|
skyboxVAO = new VAO();
|
|
skyboxVBO = new VBO();
|
|
quadVAO = new VAO();
|
|
quadVBO = new VBO();
|
|
|
|
skyboxVAO->GenerateID();
|
|
skyboxVBO->GenerateID();
|
|
skyboxVAO->Bind();
|
|
skyboxVBO->Bind();
|
|
glBufferData(GL_ARRAY_BUFFER, sizeof(skyboxVertices), &skyboxVertices, GL_STATIC_DRAW);
|
|
glEnableVertexAttribArray(0);
|
|
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 3 * sizeof(float), (void*)0);
|
|
|
|
quadVAO->GenerateID();
|
|
quadVBO->GenerateID();
|
|
quadVAO->Bind();
|
|
quadVBO->Bind();
|
|
quadVBO->BufferData(quadVertices, sizeof(quadVertices));
|
|
quadVAO->LinkVBO(*quadVBO, 0, 2, GL_FLOAT, 4 * sizeof(float), (void*)0);
|
|
quadVAO->LinkVBO(*quadVBO, 1, 2, GL_FLOAT, 4 * sizeof(float), (void*)(2 * sizeof(float)));
|
|
|
|
std::vector<std::string> faces = {
|
|
"assets/miramar_ft.tga", "assets/miramar_bk.tga",
|
|
"assets/miramar_up.tga", "assets/miramar_dn.tga",
|
|
"assets/miramar_rt.tga", "assets/miramar_lf.tga"
|
|
};
|
|
Cubemap* skyboxcm = new Cubemap();
|
|
skyboxcm->FillCubemap(faces);
|
|
skybox = skyboxcm;
|
|
|
|
// Screen framebuffer
|
|
screenfbo->Bind();
|
|
glGenTextures(1, &textureColorbuffer);
|
|
glBindTexture(GL_TEXTURE_2D, textureColorbuffer);
|
|
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, window->width, window->height, 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL);
|
|
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
|
|
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
|
|
glBindTexture(GL_TEXTURE_2D, 0);
|
|
glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, textureColorbuffer, 0);
|
|
|
|
glGenRenderbuffers(1, &rbo);
|
|
glBindRenderbuffer(GL_RENDERBUFFER, rbo);
|
|
glRenderbufferStorage(GL_RENDERBUFFER, GL_DEPTH24_STENCIL8, window->width, window->height);
|
|
glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_STENCIL_ATTACHMENT, GL_RENDERBUFFER, rbo);
|
|
|
|
if (glCheckFramebufferStatus(GL_FRAMEBUFFER) != GL_FRAMEBUFFER_COMPLETE)
|
|
std::cout << "ERROR::FRAMEBUFFER:: Framebuffer is not complete!\n";
|
|
screenfbo->Unbind();
|
|
|
|
// Shadow framebuffer
|
|
shadowdepthmapfbo = new FBO();
|
|
SHADOW_RESOLUTION = 4096;
|
|
glGenTextures(1, &depthMaptexture);
|
|
glBindTexture(GL_TEXTURE_2D, depthMaptexture);
|
|
glTexImage2D(GL_TEXTURE_2D, 0, GL_DEPTH_COMPONENT,
|
|
SHADOW_RESOLUTION, SHADOW_RESOLUTION, 0, GL_DEPTH_COMPONENT, GL_FLOAT, 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_WRAP_S, GL_CLAMP_TO_BORDER);
|
|
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_BORDER);
|
|
float borderColor[] = { 1.0f, 1.0f, 1.0f, 1.0f };
|
|
glTexParameterfv(GL_TEXTURE_2D, GL_TEXTURE_BORDER_COLOR, borderColor);
|
|
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_COMPARE_MODE, GL_COMPARE_REF_TO_TEXTURE);
|
|
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_COMPARE_FUNC, GL_LEQUAL);
|
|
|
|
shadowdepthmapfbo->Bind();
|
|
glFramebufferTexture2D(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_TEXTURE_2D, depthMaptexture, 0);
|
|
glDrawBuffer(GL_NONE);
|
|
glReadBuffer(GL_NONE);
|
|
glBindFramebuffer(GL_FRAMEBUFFER, 0);
|
|
|
|
lighting = new Lighting();
|
|
}
|
|
|
|
// ============================================================================
|
|
// RenderTranslucent
|
|
// Collects all non-opaque 3D renderables (mesh + particle), sorts back-to-front,
|
|
// then renders each with the correct shader. Blending stays on throughout.
|
|
// ============================================================================
|
|
void RenderSystem::RenderTranslucent(Camera& camera, const glm::mat4& lightSpaceMatrix,
|
|
const glm::vec3& camPos)
|
|
{
|
|
// Collect translucent 3D renderables
|
|
std::vector<std::pair<float, Renderable*>> sorted;
|
|
for (Renderable* r : renderables) {
|
|
if (r->opaque) continue;
|
|
if (r->shadertype != Renderable::MeshShader &&
|
|
r->shadertype != Renderable::ParticleShader &&
|
|
r->shadertype != Renderable::RigShader) continue;
|
|
|
|
glm::vec3 pos = r->GetWorldPosition();
|
|
float dist = glm::length(pos - camPos);
|
|
sorted.push_back({ dist, r });
|
|
}
|
|
|
|
// Sort back-to-front
|
|
std::sort(sorted.begin(), sorted.end(),
|
|
[](const auto& a, const auto& b) { return a.first > b.first; });
|
|
|
|
glEnable(GL_BLEND);
|
|
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
|
|
glDepthMask(GL_FALSE); // write to color but not depth — prevents z-fighting between translucents
|
|
|
|
Renderable::ShaderType lastShader = Renderable::ShaderType::MeshShader;
|
|
bool shaderSet = false;
|
|
|
|
for (auto& [dist, r] : sorted) {
|
|
// Only re-bind shader when it changes
|
|
if (!shaderSet || r->shadertype != lastShader) {
|
|
if (r->shadertype == Renderable::MeshShader) {
|
|
PrepareMeshShader(camera);
|
|
MeshShader->SetMat4("lightSpaceMatrix", lightSpaceMatrix);
|
|
glActiveTexture(GL_TEXTURE0);
|
|
glBindTexture(GL_TEXTURE_2D, depthMaptexture);
|
|
MeshShader->Set3F("dirLight.ambient", glm::vec3(0.3f));
|
|
MeshShader->Set3F("dirLight.diffuse", glm::vec3(0.4f));
|
|
MeshShader->Set3F("dirLight.specular", glm::vec3(0.3f));
|
|
MeshShader->Set3F("dirLight.direction", lighting->dirlighting.GetFrontVector());
|
|
}
|
|
else if (r->shadertype == Renderable::ParticleShader) {
|
|
PrepareParticleShader(camera);
|
|
}
|
|
else if (r->shadertype == Renderable::RigShader) {
|
|
PrepareRigShader(camera);
|
|
RigShader->SetMat4("lightSpaceMatrix", lightSpaceMatrix);
|
|
glActiveTexture(GL_TEXTURE0);
|
|
glBindTexture(GL_TEXTURE_2D, depthMaptexture);
|
|
RigShader->Set3F("dirLight.ambient", glm::vec3(0.3f));
|
|
RigShader->Set3F("dirLight.diffuse", glm::vec3(0.4f));
|
|
RigShader->Set3F("dirLight.specular", glm::vec3(0.3f));
|
|
RigShader->Set3F("dirLight.direction", lighting->dirlighting.GetFrontVector());
|
|
}
|
|
lastShader = r->shadertype;
|
|
shaderSet = true;
|
|
}
|
|
|
|
Shader* sh = (r->shadertype == Renderable::MeshShader) ? MeshShader
|
|
: (r->shadertype == Renderable::ParticleShader) ? ParticleShader
|
|
: RigShader;
|
|
r->Render(*sh);
|
|
}
|
|
|
|
glDepthMask(GL_TRUE); // restore depth writing for subsequent passes
|
|
}
|
|
|
|
// ============================================================================
|
|
// Render
|
|
// ============================================================================
|
|
void RenderSystem::Render(Camera& camera)
|
|
{
|
|
lighting->dirlighting.RotateByEulerAngles({ glm::radians(0.05f), 0.0f, 0.0f });
|
|
|
|
const glm::mat4 proj = camera.GetProjectionMatrix(0.05f, 2000.0f);
|
|
const glm::mat4 view = camera.GetViewMatrix();
|
|
const glm::vec3 camPos = camera.t.GetTranslation();
|
|
|
|
const float near_plane = 0.1f, far_plane = 100.0f;
|
|
const glm::mat4 lightSpaceMatrix =
|
|
glm::ortho(-32.0f, 32.0f, -32.0f, 32.0f, near_plane, far_plane)
|
|
* glm::lookAt(camPos - lighting->dirlighting.GetFrontVector() * 10.0f,
|
|
camPos, camera.t.GetUpVector());
|
|
|
|
// ---- Shadow pass ----
|
|
glCullFace(GL_FRONT);
|
|
glEnable(GL_DEPTH_TEST);
|
|
glViewport(0, 0, SHADOW_RESOLUTION, SHADOW_RESOLUTION);
|
|
shadowdepthmapfbo->Bind();
|
|
glClear(GL_DEPTH_BUFFER_BIT);
|
|
|
|
MeshShadowShader->Activate();
|
|
MeshShadowShader->SetMat4("lightSpaceMatrix", lightSpaceMatrix);
|
|
for (Renderable* r : renderables) {
|
|
if (!r->castshadow || r->shadertype != Renderable::MeshShader) continue;
|
|
r->Render(*MeshShadowShader);
|
|
}
|
|
|
|
RigShadowShader->Activate();
|
|
RigShadowShader->SetMat4("lightSpaceMatrix", lightSpaceMatrix);
|
|
for (Renderable* r : renderables) {
|
|
if (!r->castshadow || r->shadertype != Renderable::RigShader) continue;
|
|
r->Render(*RigShadowShader);
|
|
}
|
|
|
|
glCullFace(GL_BACK);
|
|
|
|
// ---- Main scene ----
|
|
screenfbo->Bind();
|
|
glViewport(0, 0, window->width, window->height);
|
|
glEnable(GL_DEPTH_TEST);
|
|
glClearColor(212.f / 255.f, 223.f / 255.f, 232.f / 255.f, 1.0f);
|
|
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
|
|
|
|
// Skybox
|
|
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
|
|
glDisable(GL_DEPTH_TEST);
|
|
SkyboxShader->Activate();
|
|
SkyboxShader->SetMat4("proj", proj);
|
|
SkyboxShader->SetMat4("view", glm::mat4(glm::mat3(view)));
|
|
skyboxVAO->Bind();
|
|
glActiveTexture(GL_TEXTURE0);
|
|
skybox->Bind();
|
|
glDrawArrays(GL_TRIANGLES, 0, 36);
|
|
glBindVertexArray(0);
|
|
glEnable(GL_DEPTH_TEST);
|
|
|
|
// ---- Opaque meshes ----
|
|
PrepareMeshShader(camera);
|
|
MeshShader->SetMat4("lightSpaceMatrix", lightSpaceMatrix);
|
|
glActiveTexture(GL_TEXTURE0);
|
|
glBindTexture(GL_TEXTURE_2D, depthMaptexture);
|
|
MeshShader->Set3F("dirLight.ambient", glm::vec3(0.3f));
|
|
MeshShader->Set3F("dirLight.diffuse", glm::vec3(0.4f));
|
|
MeshShader->Set3F("dirLight.specular", glm::vec3(0.3f));
|
|
MeshShader->Set3F("dirLight.direction", lighting->dirlighting.GetFrontVector());
|
|
for (Renderable* r : renderables) {
|
|
if (r->shadertype == Renderable::MeshShader && r->opaque)
|
|
r->Render(*MeshShader);
|
|
}
|
|
|
|
// ---- Opaque rigs ----
|
|
PrepareRigShader(camera);
|
|
RigShader->SetMat4("lightSpaceMatrix", lightSpaceMatrix);
|
|
glActiveTexture(GL_TEXTURE0);
|
|
glBindTexture(GL_TEXTURE_2D, depthMaptexture);
|
|
RigShader->Set3F("dirLight.ambient", glm::vec3(0.3f));
|
|
RigShader->Set3F("dirLight.diffuse", glm::vec3(0.4f));
|
|
RigShader->Set3F("dirLight.specular", glm::vec3(0.3f));
|
|
RigShader->Set3F("dirLight.direction", lighting->dirlighting.GetFrontVector());
|
|
for (Renderable* r : renderables) {
|
|
if (r->shadertype == Renderable::RigShader && r->opaque)
|
|
r->Render(*RigShader);
|
|
}
|
|
|
|
// ---- Translucent pass (meshes + particles + rigs, sorted back-to-front) ----
|
|
// Disable face culling so thin translucent quads render both sides
|
|
glDisable(GL_CULL_FACE);
|
|
RenderTranslucent(camera, lightSpaceMatrix, camPos);
|
|
glEnable(GL_CULL_FACE);
|
|
|
|
// ---- Framebuffer blit to screen ----
|
|
screenfbo->Unbind();
|
|
glDisable(GL_DEPTH_TEST);
|
|
glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
|
|
glClear(GL_COLOR_BUFFER_BIT);
|
|
ScreenShader->Activate();
|
|
quadVAO->Bind();
|
|
glActiveTexture(GL_TEXTURE0);
|
|
glBindTexture(GL_TEXTURE_2D, textureColorbuffer);
|
|
glDrawArrays(GL_TRIANGLES, 0, 6);
|
|
|
|
// ---- GUI (always on top, no depth) ----
|
|
PrepareBoxShader(camera);
|
|
for (Renderable* r : renderables) {
|
|
if (r->shadertype == Renderable::BoxShader)
|
|
r->Render(*BoxShader);
|
|
}
|
|
|
|
PrepareImageBoxShader(camera);
|
|
for (Renderable* r : renderables) {
|
|
if (r->shadertype == Renderable::ImageBoxShader)
|
|
r->Render(*ImageBoxShader);
|
|
}
|
|
|
|
PrepareTextShader(camera);
|
|
for (Renderable* r : renderables) {
|
|
if (r->shadertype == Renderable::TextShader)
|
|
r->Render(*Text2DShader);
|
|
}
|
|
|
|
glActiveTexture(GL_TEXTURE0);
|
|
glBindTexture(GL_TEXTURE_2D, 0);
|
|
glfwSwapBuffers(window->handle);
|
|
}
|
|
|
|
// ============================================================================
|
|
// Shader preparation helpers
|
|
// ============================================================================
|
|
void RenderSystem::RenderRenderable(Renderable* renderable, Camera& camera)
|
|
{
|
|
Shader* shader = (renderable->shadertype == Renderable::MeshShader) ? MeshShader
|
|
: (renderable->shadertype == Renderable::ParticleShader) ? ParticleShader
|
|
: RigShader;
|
|
shader->Activate();
|
|
renderable->Render(*shader);
|
|
}
|
|
|
|
void RenderSystem::PrepareMeshShader(Camera& camera)
|
|
{
|
|
MeshShader->Activate();
|
|
MeshShader->SetMat4("proj", camera.GetProjectionMatrix(0.05f, 2000.0f));
|
|
MeshShader->SetMat4("view", camera.GetViewMatrix());
|
|
MeshShader->Set3F("viewPos", camera.t.GetTranslation());
|
|
}
|
|
|
|
void RenderSystem::PrepareRigShader(Camera& camera)
|
|
{
|
|
RigShader->Activate();
|
|
RigShader->SetMat4("proj", camera.GetProjectionMatrix(0.05f, 2000.0f));
|
|
RigShader->SetMat4("view", camera.GetViewMatrix());
|
|
RigShader->Set3F("viewPos", camera.t.GetTranslation());
|
|
}
|
|
|
|
void RenderSystem::PrepareParticleShader(Camera& camera)
|
|
{
|
|
ParticleShader->Activate();
|
|
ParticleShader->SetMat4("proj", camera.GetProjectionMatrix(0.05f, 2000.0f));
|
|
ParticleShader->SetMat4("view", camera.GetViewMatrix());
|
|
}
|
|
|
|
void RenderSystem::PrepareBoxShader(Camera& camera)
|
|
{
|
|
BoxShader->Activate();
|
|
BoxShader->Set2F("screenSize", { (float)window->width, (float)window->height });
|
|
}
|
|
|
|
void RenderSystem::PrepareImageBoxShader(Camera& camera)
|
|
{
|
|
ImageBoxShader->Activate();
|
|
ImageBoxShader->Set2F("screenSize", { (float)window->width, (float)window->height });
|
|
}
|
|
|
|
void RenderSystem::PrepareTextShader(Camera& camera)
|
|
{
|
|
Text2DShader->Activate();
|
|
Text2DShader->Set2F("screenSize", { (float)window->width, (float)window->height });
|
|
}
|
|
|
|
// ============================================================================
|
|
// Renderable base
|
|
// ============================================================================
|
|
Renderable::Renderable() {}
|
|
|
|
Renderable::~Renderable()
|
|
{
|
|
engine->rendersystem->RemoveRenderable(this);
|
|
}
|
|
|
|
void Renderable::BindToRenderSystem()
|
|
{
|
|
engine->rendersystem->AddRenderable(this);
|
|
} |