krenderer.h

Go to the documentation of this file.

 
#ifndef KRENDERER_H
#define KRENDERER_H
 
#include "kexport.h"
#include "kdriver.h"
 
#include "kwindow.h"
#include "kdatatype.h"
 
#include <string>
#include <vector>
#include <set>
#include <assert.h>
#include <algorithm>
#include <cmath>
 
#include <glm/glm.hpp>
#include <glm/gtc/matrix_transform.hpp>
 
#include "kmesh.h"
#include "kcamera.h"
#include "kshader.h"
#include "klight.h"
#include "kworld.h"
#include "kscene.h"
#include "kobject.h"
#include "koctree.h"
 
#include <unordered_set>
#include <memory>
 
#include <glm/gtx/string_cast.hpp>
 
namespace kemena
{
    class KEMENA3D_API kRenderer
    {
    public:
        kRenderer();

        bool init(kWindow *window = nullptr, kRendererType type = kRendererType::RENDERER_GL);

        void destroy();

        void setEngineInfo(const kString name, uint32_t version);

        kWindow *getWindow();

        kDriver *getDriver();

        void clear();

        void render(kWorld *world, kScene *scene, int x, int y, int width, int height,
                    float deltaTime = 0.0f, bool autoClearSwapWindow = true);

        kVec4 getClearColor();

        void setClearColor(kVec4 newColor);

        void setEnableScreenBuffer(bool newEnable, bool useDefaultShader = true);

        bool getEnableScreenBuffer();

        void setScreenShader(kShader *newShader);

        kShader *getScreenShader();

        void setEnableShadow(bool newEnable, bool useDefaultShader = true);

        bool getEnableShadow();

        void setShadowShader(kShader *newShader);

        kShader *getShadowShader();

        void setShadowCascadeCount(int count);
        int  getShadowCascadeCount() const { return shadowCascadeCount; }

        void setShadowResolution(int resolution);
        int  getShadowResolution() const { return shadowResolution; }

        void  setShadowSplitLambda(float lambda) { shadowSplitLambda = lambda; }
        float getShadowSplitLambda() const { return shadowSplitLambda; }

        void setShadowDebug(bool enable) { shadowDebug = enable; }
        bool getShadowDebug() const { return shadowDebug; }

        void  setShadowBias(float bias) { shadowBias = bias; }
        float getShadowBias() const { return shadowBias; }

        void  setShadowNormalBias(float bias) { shadowNormalBias = bias; }
        float getShadowNormalBias() const { return shadowNormalBias; }

        void  setShadowSoftness(float softness) { shadowSoftness = softness; }
        float getShadowSoftness() const { return shadowSoftness; }

        void setEnableAutoExposure(bool newEnable);

        bool getEnableAutoExposure();

        void resizeFbo(int newWidth, int newHeight);

        uint32_t getFboTexture();

        int getFboWidth();

        int getFboHeight();

        float srgbToLinear(float c);

        kVec3 idToRgb(unsigned int i);

        unsigned int rgbToId(unsigned int r, unsigned int g, unsigned int b);
 
        // --- Color ID object picking -----------------------------------------

        void setEnableObjectPicking(bool enable, bool useDefaultShader = true);

        bool getEnableObjectPicking();

        void setOctreeCullingEnabled(bool enable) { octreeCullingEnabled = enable; }

        void setOctreeDirty() { octreeDirty = true; }

        bool getOctreeCullingEnabled() const { return octreeCullingEnabled; }

        void setCullingCamera(kCamera *camera) { cullingCamera = camera; }

        kCamera *getCullingCamera() const { return cullingCamera; }

        const kOctree &getOctree() const { return *sceneOctree; }

        kObject *pickObject(kWorld *world, kScene *scene,
                            int mouseX, int mouseY,
                            int viewWidth, int viewHeight);

        void renderPickingPass(kWorld *world, kScene *scene, int viewWidth, int viewHeight);

        void setRenderMode(kRenderMode mode);

        kRenderMode getRenderMode();

        void renderOutline(kWorld *world, kScene *scene,
                           const std::vector<kString> &selectedUuids,
                           kVec4 color     = kVec4(1.0f, 0.6f, 0.0f, 1.0f),
                           float thickness = 3.0f);

        void renderDebugShapes(kWorld *world, kScene *scene,
                               const std::vector<kString> &selectedUuids);

        void setOctreeDebugEnabled(bool enable) { octreeDebugEnabled = enable; }

        bool getOctreeDebugEnabled() const { return octreeDebugEnabled; }

        void renderOctreeDebug(kWorld *world, kScene *scene);

        void renderDebugLines(kWorld *world, const std::vector<kVec3> &segments, kVec3 color);
 
    protected:
    private:
        kString engineName;           
        uint32_t engineVersion = 0;  
 
        // Octree frustum culling
        std::unique_ptr<kOctree> sceneOctree = std::make_unique<kOctree>(); 
        bool octreeCullingEnabled = true; 
        bool octreeDirty = true;         
        bool octreeDebugEnabled = false; 
        kCamera *cullingCamera = nullptr; 
        std::unordered_set<kMesh*> visibleMeshSet; 
        kFrustum currentFrustum; 
        bool currentFrustumValid = false; 
        kWindow *appWindow = nullptr; 
 
        kRendererType renderType; 
        kDriver *driver = nullptr; 
 
        kVec4 clearColor = kVec4(0.0f, 0.0f, 0.0f, 1.0f); 

        int frameId = 0;

        void renderSceneGraph(kWorld *world, kScene *scene, kObject *rootNode,
                              bool transparent = false, float deltaTime = 0.0f);

        void renderSceneGraphShadow(kWorld *world, kScene *scene, kObject *rootNode,
                                    const kMat4 &lightSpaceMatrix,
                                    float deltaTime = 0.0f);

        void renderSceneGraphPicking(kWorld *world, kScene *scene, kObject *rootNode);
 
        // Screen FBO
        bool enableScreenBuffer = false; 
        kShader *screenShader = nullptr; 
        uint32_t quadVao = 0, quadVbo = 0, quadEbo = 0; 
        uint32_t fbo = 0, fboTexColor = 0, rboDepth = 0; 
        uint32_t fboMsaa = 0, fboTexColorMsaa = 0, rboDepthMsaa = 0; 
 
        int fboWidth = 0, fboHeight = 0; 
 
        // Cascaded shadow maps — one depth-texture-array layer per cascade.
        static constexpr int kMaxShadowCascades = 4;
        bool     enableShadow       = false;
        kShader *shadowShader       = nullptr;
        int      shadowResolution   = 2048;   
        int      shadowCascadeCount = 3;      
        float    shadowSplitLambda  = 0.85f;  
        bool     shadowDebug        = false;  
        float    shadowBias         = 0.0008f;
        float    shadowNormalBias   = 0.003f; 
        float    shadowSoftness     = 1.5f;   
        uint32_t shadowFbo          = 0;      
        uint32_t shadowTexArray     = 0;      
        kMat4    lightSpaceMatrices[kMaxShadowCascades]; 
        float    cascadeSplits[kMaxShadowCascades] = {}; 
 
        // Picking FBO
        bool enablePicking = false; 
        kShader *pickingShader = nullptr; 
        kShader *pickingIconShader = nullptr; 
        uint32_t pickingIconVAO = 0, pickingIconVBO = 0; 
        uint32_t pickFbo = 0, pickFboTex = 0, pickRboDepth = 0; 
        int pickFboWidth = 0, pickFboHeight = 0; 
 
        // Outline shader (compiled on first renderOutline call)
        kShader *outlineShader = nullptr; 
 
        // Passthrough shader for Object IDs display mode
        kShader *debugPickShader = nullptr; 
 
        // Debug / render-mode shaders (compiled on first use)
        kShader *debugAlbedoShader  = nullptr; 
        kShader *debugNormalsShader = nullptr; 
        kShader *debugWireShader    = nullptr; 
        kShader *debugDepthShader   = nullptr; 
 
        // Debug shape line rendering
        kShader  *debugLineShader = nullptr; 
        uint32_t  debugLineVao    = 0;       
        uint32_t  debugLineVbo    = 0;       
 
        kRenderMode renderMode = kRenderMode::RENDER_MODE_FULL; 

        void renderSceneGraphDebug(kWorld *world, kScene *scene, kObject *rootNode,
                                   kShader *shader, bool wireframe);
 
        // Auto exposure
        bool enableAutoExposure = false; 
        float averageLuminance = 0.0f; 
        float averageLuminanceColor[4] = {}; 
        float exposureKey = 0.18f; 
        float exposureAdaptationRate = 2.0f; 
        float exposure = 1.0f; 
    };
}
 
#endif // KRENDERER_H