koffscreenrenderer.h

Go to the documentation of this file.

 
#ifndef KOFFSCREENRENDERER_H
#define KOFFSCREENRENDERER_H
 
#include "kexport.h"
#include "kdatatype.h"
#include "kcamera.h"
 
#include <string>
 
namespace kemena
{
    class kMesh;
    class kScene;
    class kWorld;
    class kObject;
    class kShader;
    class kDriver;

    class KEMENA3D_API kOffscreenRenderer
    {
    public:
        kOffscreenRenderer(int width = 256, int height = 256);

        ~kOffscreenRenderer();

        void resize(int newWidth, int newHeight);

        void setBackgroundColor(kVec4 color) { bgColor = color; }

        kVec4 getBackgroundColor() const     { return bgColor; }

        void render(kWorld *world, kScene *scene, kCamera *camera);

        void renderMesh(kMesh *mesh, kCamera *camera = nullptr);

        void renderMeshWithMaterial(kMesh *mesh, kCamera *camera = nullptr);

        uint32_t getTexture() const { return colorTex; }

        int getWidth()  const { return width;  }

        int getHeight() const { return height; }

        bool saveToFile(const kString &filePath) const;
 
    private:
        kDriver *driver  = nullptr;
        uint32_t fbo      = 0;
        uint32_t colorTex = 0;
        uint32_t depthRbo = 0;
 
        int width;
        int height;
        int ssaaScale = 2; // render at Nx resolution, box-filter downsample on save
        kVec4 bgColor = kVec4(0.15f, 0.15f, 0.15f, 1.0f);
 
        kShader *builtinShader = nullptr; 
 
        // Cascaded-shadow-map resources for the offscreen pass. Lazily allocated
        // on the first render() call so headless thumbnail use cases that never
        // render a scene don't pay the VRAM cost.
        static constexpr int kMaxShadowCascades = 4;
        kShader *shadowShader        = nullptr;
        uint32_t shadowFbo           = 0;
        uint32_t shadowTexArray      = 0;
        int      shadowResolution    = 1024; // smaller than main renderer to save VRAM
        int      shadowCascadeCount  = 3;
        float    shadowSplitLambda   = 0.85f;
        kMat4    lightSpaceMatrices[kMaxShadowCascades];
        float    cascadeSplits[kMaxShadowCascades] = {};
 
        void createFBO();
        void destroyFBO();
        void ensureBuiltinShader();
 
        void ensureShadowResources();
        void applyShadowResolution(int resolution);
        void renderShadowPass(kWorld *world, kScene *scene, kCamera *camera);
        void renderShadowNode(kObject *node, const kMat4 &lightSpace, kShader *shader);
 
        void renderNodeFull(kObject *node, kScene *scene, kCamera *camera);
        void drawMeshWithMaterial(kMesh *mesh, kScene *scene, kCamera *camera,
                                  int sunCount, int pointCount, int spotCount);
        void drawMeshBuiltin(kMesh *mesh, kCamera *camera);
        void drawMeshHierarchy(kMesh *mesh, kCamera *camera);
 
        void setupLightsFromScene(kShader *shader, kScene *scene,
                                  int &outSun, int &outPoint, int &outSpot);
        void setupSingleSunLight(kShader *shader,
                                 kVec3 direction, kVec3 diffuse, float power);
        void bindMaterialTextures(kMesh *mesh, kShader *shader);
        void unbindMaterialTextures(kMesh *mesh);
    };
}
 
#endif // KOFFSCREENRENDERER_H