renderer.cpp

#include <Phoenix/renderer/renderer.h>
#include <Phoenix/renderer/renderer_command.h>
#include <Phoenix/core/base.h>
#include <algorithm>
#include <array>
#include <cmath>
#include <string>

namespace Phoenix{
    Scope<Renderer::SceneData> Renderer::s_SceneData = CreateScope<Renderer::SceneData>();
    Scope<RenderLightCube> Renderer::s_RenderLightCube = CreateScope<RenderLightCube>();
    Scope<RenderCameraGizmo> Renderer::s_CameraGizmo = CreateScope<RenderCameraGizmo>();
    Scope<RenderDirLightGizmo> Renderer::s_DirLightGizmo = CreateScope<RenderDirLightGizmo>();
    Ref<Shader> Renderer::s_OutlineShader;
    Ref<Shader> Renderer::s_WaterShader;

    uint32_t Renderer::s_ShadowFBO = 0;
    uint32_t Renderer::s_ShadowAtlasTex = 0;
    Ref<Shader> Renderer::s_ShadowShader;
    glm::mat4 Renderer::s_LightSpaceMatrix[Renderer::MAX_DIR_LIGHTS] = { glm::mat4(1.0f) };
    int Renderer::s_NumShadows = 0;
    bool Renderer::s_ShadowsEnabled = false;
    int Renderer::s_PrevFBO = 0;
    int Renderer::s_PrevViewport[4] = { 0, 0, 0, 0 };
    bool Renderer::s_LinearLighting = false;

    glm::vec3 Renderer::ToLinear(const glm::vec3& c){
        if (!s_LinearLighting) { return c; }
        // sRGB EOTF; the power segment also extends sensibly to HDR values above 1.
        auto channel = [](float v){
            v = std::max(v, 0.0f);
            return v <= 0.04045f ? v / 12.92f : std::pow((v + 0.055f) / 1.055f, 2.4f);
        };
        return { channel(c.r), channel(c.g), channel(c.b) };
    }

    // Shadow atlas: a SHADOW_COLS x SHADOW_ROWS grid of SHADOW_TILE-sized tiles, one per
    // directional light. COLS*ROWS must be >= MAX_DIR_LIGHTS and the grid must match the
    // SHADOW_COLS/SHADOW_ROWS #defines in lighting.glsl.
    static const uint32_t SHADOW_TILE = 1024;
    static const int      SHADOW_COLS = 4;
    static const int      SHADOW_ROWS = 2; // 4x2 = 8 tiles = MAX_DIR_LIGHTS
    static const uint32_t SHADOW_ATLAS_W = SHADOW_TILE * SHADOW_COLS;
    static const uint32_t SHADOW_ATLAS_H = SHADOW_TILE * SHADOW_ROWS;

	void Renderer::Init(){
		RenderCommand::Init();
        s_RenderLightCube->Init();
        s_CameraGizmo->Init();
        s_DirLightGizmo->Init();
        s_OutlineShader = Shader::Create("assets/shaders/outline.glsl");
        s_WaterShader = Shader::Create("assets/shaders/water.glsl");
        s_ShadowShader = Shader::Create("assets/shaders/shadow_depth.glsl");

        // One big depth-texture atlas; each light renders into its own tile (set by the
        // viewport in BeginShadowPass). LINEAR + compare mode = hardware PCF. Sampled as a
        // plain sampler2DShadow with per-tile UV math (portable; no array samplers).
        glGenTextures(1, &s_ShadowAtlasTex);
        glBindTexture(GL_TEXTURE_2D, s_ShadowAtlasTex);
        glTexImage2D(GL_TEXTURE_2D, 0, GL_DEPTH_COMPONENT24, SHADOW_ATLAS_W, SHADOW_ATLAS_H, 0, GL_DEPTH_COMPONENT, GL_FLOAT, nullptr);
        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_COMPARE_MODE, GL_COMPARE_REF_TO_TEXTURE);
        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_COMPARE_FUNC, GL_LEQUAL);
        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 border[] = { 1.0f, 1.0f, 1.0f, 1.0f }; // outside the map = max depth = lit
        glTexParameterfv(GL_TEXTURE_2D, GL_TEXTURE_BORDER_COLOR, border);

        glGenFramebuffers(1, &s_ShadowFBO);
        glBindFramebuffer(GL_FRAMEBUFFER, s_ShadowFBO);
        glFramebufferTexture2D(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_TEXTURE_2D, s_ShadowAtlasTex, 0);
        glDrawBuffer(GL_NONE);
        glReadBuffer(GL_NONE);
        glBindFramebuffer(GL_FRAMEBUFFER, 0);
	}

    void Renderer::BeginShadowPass(int index, const glm::mat4& lightSpaceMatrix){
        if (index < 0 || index >= MAX_DIR_LIGHTS) { return; }
        glGetIntegerv(GL_FRAMEBUFFER_BINDING, &s_PrevFBO);
        glGetIntegerv(GL_VIEWPORT, s_PrevViewport);

        s_LightSpaceMatrix[index] = lightSpaceMatrix;
        s_ShadowsEnabled = true;
        if (index + 1 > s_NumShadows) { s_NumShadows = index + 1; }

        glBindFramebuffer(GL_FRAMEBUFFER, s_ShadowFBO);
        // Clear the WHOLE atlas once (on the first light) -> empty tiles read as "lit".
        if (index == 0){
            glViewport(0, 0, SHADOW_ATLAS_W, SHADOW_ATLAS_H);
            glClear(GL_DEPTH_BUFFER_BIT);
        }
        // Restrict rasterization to this light's tile.
        int col = index % SHADOW_COLS;
        int row = index / SHADOW_COLS;
        glViewport(col * SHADOW_TILE, row * SHADOW_TILE, SHADOW_TILE, SHADOW_TILE);

        s_ShadowShader->Bind();
        s_ShadowShader->SetMat4("u_LightSpaceMatrix", lightSpaceMatrix);
    }

    void Renderer::SubmitShadow(const Ref<VertexArray>& vertexArray, const glm::mat4& transform){
        s_ShadowShader->SetMat4("model", transform);
        s_ShadowShader->SetInt("u_Animated", 0);
        vertexArray->Bind();
        RenderCommand::DrawIndexed(vertexArray);
    }

    void Renderer::SubmitShadowAnimated(const Ref<VertexArray>& vertexArray, const glm::mat4& transform,
            const std::vector<glm::mat4>& boneMatrices){
        s_ShadowShader->SetMat4("model", transform);
        s_ShadowShader->SetInt("u_Animated", 1);
        if (!boneMatrices.empty())
            s_ShadowShader->SetMat4Array("u_BoneMatrices", boneMatrices.data(), (uint32_t)boneMatrices.size());
        vertexArray->Bind();
        RenderCommand::DrawIndexed(vertexArray);
        s_ShadowShader->SetInt("u_Animated", 0);
    }

    void Renderer::SubmitShadowCube(const glm::mat4& transform){
        SubmitShadow(s_RenderLightCube->m_Vertex_array, transform);
    }

    void Renderer::EndShadowPass(){
        s_ShadowShader->Unbind();
        glBindFramebuffer(GL_FRAMEBUFFER, (uint32_t)s_PrevFBO);
        glViewport(s_PrevViewport[0], s_PrevViewport[1], s_PrevViewport[2], s_PrevViewport[3]);
    }

	void Renderer::Shutdown(){
	}

	void Renderer::OnWindowResize(uint32_t width, uint32_t height){
		RenderCommand::SetViewport(0, 0, width, height);
	}

    void Renderer::BeginScene(const glm::mat4& projection, const glm::mat4& view, const glm::vec3& cameraPos){
        s_SceneData->ProjectionMatrix = projection;
        s_SceneData->ViewMatrix = view;
        s_SceneData->CameraPos = cameraPos;

        auto& shader = s_RenderLightCube->m_Shader;
        shader->Bind();
        shader->SetMat4("view", view);
        shader->SetMat4("projection", projection);
        shader->SetFloat3("cameraPos", cameraPos);

        // Shadow atlas on texture unit 1 (diffuse=0, normal map=2). The light matrices are
        // a plain uniform array (dynamic indexing of non-samplers IS allowed).
        shader->SetInt("u_ShadowsEnabled", s_ShadowsEnabled ? 1 : 0);
        shader->SetInt("u_NumShadows", s_NumShadows);
        shader->SetInt("u_ShadowMap", 1);
        glBindTextureUnit(1, s_ShadowAtlasTex);
        shader->SetMat4Array("u_LightSpaceMatrices", s_LightSpaceMatrix, MAX_DIR_LIGHTS);
        shader->SetInt("u_LinearLighting", s_LinearLighting ? 1 : 0);
    }

    // Uniform names for the light arrays, built once rather than every frame.
    static const int NUM_POINT_LIGHTS = 4; // NR_POINT_LIGHTS in lighting.glsl

    struct DirLightUniformNames { std::string ambient, diffuse, specular, direction; };
    struct PointLightUniformNames { std::string constant, linear, quadratic, ambient, diffuse, specular, position; };

    static const DirLightUniformNames& DirLightNames(int i){
        static const auto names = []{
            std::array<DirLightUniformNames, Renderer::MAX_DIR_LIGHTS> n;
            for (int j = 0; j < Renderer::MAX_DIR_LIGHTS; j++){
                std::string base = "dirLights[" + std::to_string(j) + "].";
                n[j] = { base + "ambient", base + "diffuse", base + "specular", base + "direction" };
            }
            return n;
        }();
        return names[i];
    }

    static const PointLightUniformNames& PointLightNames(int i){
        static const auto names = []{
            std::array<PointLightUniformNames, NUM_POINT_LIGHTS> n;
            for (int j = 0; j < NUM_POINT_LIGHTS; j++){
                std::string base = "pointLights[" + std::to_string(j) + "].";
                n[j] = { base + "constant", base + "linear", base + "quadratic", base + "ambient",
                         base + "diffuse", base + "specular", base + "position" };
            }
            return n;
        }();
        return names[i];
    }

    void Renderer::SetLights(
            const glm::vec3& ambient,
            const DirLightComponent dirLights[],
            const glm::vec3 dirLightDirs[],
            int numDirLights,
            PointLightComponent pointLight[],
            const glm::vec3 pointLightPos[],
            int numOfPointLight ){

        auto& shader = s_RenderLightCube->m_Shader;

        shader->SetFloat3("u_Ambient", ToLinear(ambient));

        if (numDirLights > MAX_DIR_LIGHTS) { numDirLights = MAX_DIR_LIGHTS; }
        shader->SetInt("u_NumDirLights", numDirLights);
        for (int i = 0; i < MAX_DIR_LIGHTS; i++){
            const DirLightUniformNames& u = DirLightNames(i);
            if (i < numDirLights){
                shader->SetFloat3(u.ambient, ToLinear(dirLights[i].ambient));
                shader->SetFloat3(u.diffuse, ToLinear(dirLights[i].diffuse));
                shader->SetFloat3(u.specular, ToLinear(dirLights[i].specular));
                shader->SetFloat3(u.direction, dirLightDirs[i]);
            }
            else{
                shader->SetFloat3(u.ambient, glm::vec3(0.0f));
                shader->SetFloat3(u.diffuse, glm::vec3(0.0f));
                shader->SetFloat3(u.specular, glm::vec3(0.0f));
                shader->SetFloat3(u.direction, glm::vec3(0.0f, -1.0f, 0.0f));
            }
        }

        shader->SetInt("u_NumPointLights", std::min(std::max(numOfPointLight, 0), NUM_POINT_LIGHTS));
        for (int i = 0 ; i < NUM_POINT_LIGHTS ; i ++)
        {
            const PointLightUniformNames& u = PointLightNames(i);
            if (i < numOfPointLight)
            {
                shader->SetFloat(u.constant, pointLight[i].constant);
                shader->SetFloat(u.linear, pointLight[i].linear);
                shader->SetFloat(u.quadratic, pointLight[i].quadratic);
                shader->SetFloat3(u.ambient, ToLinear(pointLight[i].ambient));
                shader->SetFloat3(u.diffuse, ToLinear(pointLight[i].diffuse));
                shader->SetFloat3(u.specular, ToLinear(pointLight[i].specular));
                shader->SetFloat3(u.position, pointLightPos[i]);
            }
            else{
                shader->SetFloat(u.constant, 1.0f);
                shader->SetFloat(u.linear, 0.03f);
                shader->SetFloat(u.quadratic, 0.099f);
                shader->SetFloat3(u.ambient, glm::vec3(0.0, 0.0, 0.0));
                shader->SetFloat3(u.diffuse, glm::vec3(0.0, 0.0, 0.0));
                shader->SetFloat3(u.specular, glm::vec3(0.0, 0.0, 0.0));
                shader->SetFloat3(u.position, glm::vec3(0.0, 0.0, 0.0));
            }
        }
    }

    // Texture units: 0 = diffuse, 1 = shadow map array, 2 = normal map.
    static const uint32_t NORMAL_MAP_UNIT = 2;

    // Upload material params + bind its textures. The material's own diffuse path (set via
    // the Textures panel) overrides the mesh-embedded `diffuseMap`; the normal path adds
    // tangent-space detail. Both are resolved from path through Texture2D's path cache.
    static void BindMaterial(const Ref<Shader>& shader, const Material& material, const Ref<Texture2D>& diffuseMap){
        shader->SetFloat3("material.ambient", Renderer::ToLinear(material.ambient));
        shader->SetFloat3("material.diffuse", Renderer::ToLinear(material.diffuse));
        shader->SetFloat3("material.specular", Renderer::ToLinear(material.specular));
        shader->SetFloat("material.shininess", material.shininess);
        shader->SetFloat3("u_Emissive", Renderer::ToLinear(material.emissive) * material.emissiveStrength);
        shader->SetFloat("u_Reflectivity", material.reflectivity);

        Ref<Texture2D> diffuse = !material.diffusePath.empty() ? Texture2D::Create(material.diffusePath) : diffuseMap;
        if (diffuse){
            diffuse->Bind(0, Renderer::IsLinearLighting()); // colour data: sRGB-decoded when linear
            shader->SetInt("u_DiffuseMap", 0);
            shader->SetInt("u_HasDiffuseMap", 1);
        }
        else{
            shader->SetInt("u_HasDiffuseMap", 0);
        }

        if (!material.normalPath.empty()){
            Ref<Texture2D> normal = Texture2D::Create(material.normalPath);
            if (normal){
                normal->Bind(NORMAL_MAP_UNIT);
                shader->SetInt("u_NormalMap", (int)NORMAL_MAP_UNIT);
                shader->SetInt("u_HasNormalMap", 1);
            }
            else{
                shader->SetInt("u_HasNormalMap", 0);
            }
        }
        else{
            shader->SetInt("u_HasNormalMap", 0);
        }
    }

    void Renderer::Submit(const Ref<VertexArray>& vertexArray, const Material& material, const glm::mat4& transform, const Ref<Texture2D>& diffuseMap){
        auto& shader = s_RenderLightCube->m_Shader;
        BindMaterial(shader, material, diffuseMap);
        shader->SetMat4("model", transform);
        shader->UploadUniformMat3("u_NormalMatrix", glm::transpose(glm::inverse(glm::mat3(transform))));
        shader->SetInt("u_Animated", 0);

        vertexArray->Bind();
        RenderCommand::DrawIndexed(vertexArray);
    }

    void Renderer::SubmitAnimated(const Ref<VertexArray>& vertexArray, const Material& material, const glm::mat4& transform,
            const std::vector<glm::mat4>& boneMatrices, const Ref<Texture2D>& diffuseMap){
        auto& shader = s_RenderLightCube->m_Shader;
        BindMaterial(shader, material, diffuseMap);
        shader->SetMat4("model", transform);
        shader->UploadUniformMat3("u_NormalMatrix", glm::transpose(glm::inverse(glm::mat3(transform))));
        shader->SetInt("u_Animated", 1);
        if (!boneMatrices.empty())
            shader->SetMat4Array("u_BoneMatrices", boneMatrices.data(), (uint32_t)boneMatrices.size());

        vertexArray->Bind();
        RenderCommand::DrawIndexed(vertexArray);

        shader->SetInt("u_Animated", 0); // reset so following draws aren't skinned
    }

    void Renderer::SubmitCube(const Material& material, const glm::mat4& transform){
        Submit(s_RenderLightCube->m_Vertex_array, material, transform);
    }

    void Renderer::SetWireframe(bool enabled){
        glPolygonMode(GL_FRONT_AND_BACK, enabled ? GL_LINE : GL_FILL);
    }

    void Renderer::DrawOutline(const std::vector<Ref<VertexArray>>& vertexArrays, const glm::mat4& transform, const glm::vec3& color,
            const std::vector<glm::mat4>* boneMatrices){
        if (vertexArrays.empty()) { return; }

        s_OutlineShader->Bind();
        s_OutlineShader->SetMat4("view", s_SceneData->ViewMatrix);
        s_OutlineShader->SetMat4("projection", s_SceneData->ProjectionMatrix);
        s_OutlineShader->SetFloat3("u_Color", ToLinear(color));

        // Skin the silhouette for animated meshes so it tracks the posed geometry.
        if (boneMatrices && !boneMatrices->empty()){
            s_OutlineShader->SetInt("u_Animated", 1);
            s_OutlineShader->SetMat4Array("u_BoneMatrices", boneMatrices->data(), (uint32_t)boneMatrices->size());
        }
        else{
            s_OutlineShader->SetInt("u_Animated", 0);
        }

        glEnable(GL_STENCIL_TEST);
        glClear(GL_STENCIL_BUFFER_BIT);
        glDisable(GL_DEPTH_TEST); // keep the outline visible even when occluded

        // Pass 1: mark the silhouette (stencil = 1), writing neither colour nor depth.
        glStencilFunc(GL_ALWAYS, 1, 0xFF);
        glStencilOp(GL_KEEP, GL_KEEP, GL_REPLACE);
        glStencilMask(0xFF);
        glColorMask(GL_FALSE, GL_FALSE, GL_FALSE, GL_FALSE);
        s_OutlineShader->SetMat4("model", transform);
        for (const auto& va : vertexArrays){ va->Bind(); RenderCommand::DrawIndexed(va); }
        glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);

        // Pass 2: draw the enlarged object only OUTSIDE the silhouette -> a thin border.
        glStencilFunc(GL_NOTEQUAL, 1, 0xFF);
        glStencilMask(0x00);
        s_OutlineShader->SetMat4("model", transform * glm::scale(glm::mat4(1.0f), glm::vec3(1.03f)));
        for (const auto& va : vertexArrays){ va->Bind(); RenderCommand::DrawIndexed(va); }

        // Restore state.
        glStencilMask(0xFF);
        glStencilFunc(GL_ALWAYS, 0, 0xFF);
        glDisable(GL_STENCIL_TEST);
        glEnable(GL_DEPTH_TEST);
        s_OutlineShader->Unbind();
    }

    void Renderer::DrawOutlineCube(const glm::mat4& transform, const glm::vec3& color){
        DrawOutline({ s_RenderLightCube->m_Vertex_array }, transform, color);
    }

    void Renderer::DrawCameraGizmo(const glm::mat4& transform, float verticalFov, float aspect, const glm::vec3& color){
        // Shape the unit frustum (base half-size 1 at z=-1) to the camera's FOV/aspect.
        const float length = 1.5f;
        float halfHeight = length * std::tan(verticalFov * 0.5f);
        float halfWidth = halfHeight * aspect;
        glm::mat4 model = transform * glm::scale(glm::mat4(1.0f), glm::vec3(halfWidth, halfHeight, length));

        s_OutlineShader->Bind();
        s_OutlineShader->SetMat4("view", s_SceneData->ViewMatrix);
        s_OutlineShader->SetMat4("projection", s_SceneData->ProjectionMatrix);
        s_OutlineShader->SetMat4("model", model);
        s_OutlineShader->SetFloat3("u_Color", ToLinear(color));
        s_OutlineShader->SetInt("u_Animated", 0); // DrawOutline may have left skinning on

        s_CameraGizmo->m_Vertex_array->Bind();
        glLineWidth(2.0f);
        glDrawElements(GL_LINES, 16, GL_UNSIGNED_INT, 0);

        s_OutlineShader->Unbind();
    }

    void Renderer::DrawDirLightGizmo(const glm::mat4& transform, const glm::vec3& color){
        // Use rotation+translation only (drop scale) so the arrow keeps a fixed size.
        glm::vec3 pos = glm::vec3(transform[3]);
        glm::mat3 rotation = glm::mat3(transform);
        rotation[0] = glm::normalize(rotation[0]);
        rotation[1] = glm::normalize(rotation[1]);
        rotation[2] = glm::normalize(rotation[2]);
        glm::mat4 model = glm::translate(glm::mat4(1.0f), pos) * glm::mat4(rotation);

        s_OutlineShader->Bind();
        s_OutlineShader->SetMat4("view", s_SceneData->ViewMatrix);
        s_OutlineShader->SetMat4("projection", s_SceneData->ProjectionMatrix);
        s_OutlineShader->SetMat4("model", model);
        s_OutlineShader->SetFloat3("u_Color", ToLinear(color));
        s_OutlineShader->SetInt("u_Animated", 0); // DrawOutline may have left skinning on

        s_DirLightGizmo->m_Vertex_array->Bind();
        glLineWidth(2.0f);
        glDrawElements(GL_LINES, 10, GL_UNSIGNED_INT, 0);

        s_OutlineShader->Unbind();
    }

    void Renderer::SubmitWater(const Ref<VertexArray>& vertexArray, const glm::mat4& transform,
            const WaterParams& params){
        glEnable(GL_BLEND);
        glDepthMask(GL_FALSE); // transparent: test against depth but don't write it

        s_WaterShader->Bind();
        s_WaterShader->SetMat4("view", s_SceneData->ViewMatrix);
        s_WaterShader->SetMat4("projection", s_SceneData->ProjectionMatrix);
        s_WaterShader->SetMat4("model", transform);
        s_WaterShader->SetFloat3("u_CameraPos", s_SceneData->CameraPos);
        s_WaterShader->SetFloat3("u_Color", ToLinear(params.color));
        s_WaterShader->SetInt("u_LinearLighting", s_LinearLighting ? 1 : 0);
        s_WaterShader->SetFloat("u_Alpha", params.alpha);
        s_WaterShader->SetFloat3("u_LightDir", params.lightDir);
        s_WaterShader->SetFloat("u_Time", params.time);
        s_WaterShader->SetFloat("u_Amplitude", params.amplitude);
        s_WaterShader->SetFloat("u_WaveScale", params.waveScale);
        s_WaterShader->SetFloat("u_Speed", params.speed);
        s_WaterShader->SetFloat("u_Choppiness", params.choppiness);
        s_WaterShader->SetFloat("u_Foam", params.foam);
        s_WaterShader->SetFloat("u_WaterSize", params.size);

        // Dynamic ripple heightfield on unit 3 (0 diffuse, 1 shadow atlas, 2 normal map).
        s_WaterShader->SetInt("u_HasRipples", params.rippleTexture ? 1 : 0);
        if (params.rippleTexture){
            glActiveTexture(GL_TEXTURE3);
            glBindTexture(GL_TEXTURE_2D, params.rippleTexture);
            s_WaterShader->SetInt("u_RippleTex", 3);
            glActiveTexture(GL_TEXTURE0);
        }

        vertexArray->Bind();
        RenderCommand::DrawIndexed(vertexArray);

        s_WaterShader->Unbind();
        glDepthMask(GL_TRUE);
    }

	void Renderer::EndScene(){
        s_RenderLightCube->m_Shader->Unbind();
        // Reset for next frame; if no shadow pass runs, shadows stay disabled.
        s_ShadowsEnabled = false;
        s_NumShadows = 0;
	}

}