renderer.hpp

Go to the documentation of this file.

#pragma once
 
#include <vertexarray.hpp>
#include <vertexbuffer.hpp>
#include <indexbuffer.hpp>
#include <framebuffer.hpp>
#include <shader.hpp>
#include <global.hpp>
#include <texture.hpp>
#ifdef EDITOR
    #include <editor.hpp>
#endif
 
class Camera;
 
struct RendererData{
    VertexBuffer VBO;
    VertexArray VAO;
    VertexBufferLayout VBL;
    Shader S;
    unsigned int NumVertices;
 
    RendererData(const char *vertex_path,const char *fragment_path,unsigned int vertex_size);
};
 
enum class TonemapType{
    None=0,
    Reinhard=1,
    Filmic=2,
    Uncharted2=3,
    ACES=4,
    Exponential=5,
    Logarithmic=6,
    Mantiuk=7
};
 
std::string TonemapTypeToString(TonemapType type);
TonemapType StringToTonemapType(const std::string &type);
 
class Renderer{
public:
    Renderer();
    ~Renderer();
 
    void StartScene();
    void DrawScene();
    #ifdef EDITOR
        friend class Editor;
        friend class SceneSerializer;
 
        void StartEditorScene(Editor *editor); 
        void DrawEditorScene(Framebuffer *framebuffer);
    #endif
 
    #ifdef APPLICATION
        friend class SceneSerializer;
    #endif
 
    void Clear(bool ambient_light=false) const;
    void Clear(Vec4 color) const;
 
    void DrawTexture(Vec2 pos,Vec2 size,int layer,float texID);
    void DrawTexture(Vec2 pos,Vec2 size,Vec2 texture_pos,Vec2 texture_size,Vec2 texture_total_size,int layer,float texID);
    void DrawTexture(Vec2 pos,Vec2 size,bool reverse_x,bool reverse_y,int layer,Texture &texture);
    void DrawSpriteSheet(Vec2 pos,Vec2 size,float row,float col,int layer,SpriteSheet &s);
    void DrawAnimatedTexture(Vec2 pos,Vec2 size,int layer,SpriteSheet &s,bool &play_animation,bool loop_animation,float animation_delay,float &last_animation_time,int &animation_index);
    void DrawTriangle(Vec2 pos1,Vec2 pos2,Vec2 pos3,Vec4 color,int layer);
    void DrawSolidQuad(Vec2 pos,Vec2 size,Vec4 color,int layer);
    void DrawPoint(Vec2 pos,Vec4 color,int layer);
    void DrawCircle(Vec2 pos,Vec4 color,float border,int layer);
    void DrawLine(Vec2 pos1,Vec2 pos2,Vec4 color,int layer);
    void DrawLight(Vec2 pos,Vec4 color,LightType light_type,float radius=0.0f,float blurAmount=0.0f);
 
    void Render(bool post_processing=false);
    void RenderTextures(bool post_processing,float max_layer);
    void RenderTriangles(float max_layer);
    void RenderLines(float max_layer);
    void RenderPoints(float max_layer);
    void SetPostProcessing(const char *uniform_name);
    void PostProcessing();
 
    void SetLineWidth(float new_size);
    void UpdateLineWidth();
    void SetPointSize(float new_size);
    float GetPointSize();
    float GetLineWidth();
    void SetAmbientLight(Vec3 color);
    void SetClearColor(Vec3 color);
 
    void AddSegment(Vec2 start_point,Vec2 end_point);
    void UpdateScreenSegments();
    void ClearSegments();
    std::vector<std::pair<Vec2,Vec2>> &GetSegments();
    void ApplyLight();
    void ApplyLight(Framebuffer *framebuffer);
    void KeepCircle(Vec2 pos,float radius,float blurAmount);
    std::pair<Vec2,float> GetIntersection(const std::pair<Vec2,Vec2>&ray,const std::pair<Vec2,Vec2>&seg);
 
    inline RendererData* GetLightsData(){ return &m_Lights; }
    inline unsigned int GetFramebufferID(){ return m_Framebuffer->GetColorbufferID(); }
 
    void SetTonemapType(TonemapType type);
    void SetGamma(float gamma);
    void SetExposure(float exposure);
    
    TonemapType GetTonemapType();
    float GetGamma();
    float GetExposure();
 
    void CreateShaders();
    void ReloadShaders();
    inline void SetProjMat(glm::mat4 proj){
        m_Proj=proj;
    }
    inline void SetViewMat(glm::mat4 view){
        m_View=view;
    }
    inline void SetViewProjMat(glm::mat4 view_proj){
        m_ViewProj=view_proj;
    }
 
    static void ImGui_Init();
    static void ImGui_Theme();
    static void ImGui_Start_Frame();
    static void ImGui_Content();
    static void ImGui_End_Frame();
    static void ImGui_Close();
 
private:
    friend class Camera;
 
    RendererData m_Textures;
    RendererData m_Points;
    RendererData m_Lines;
    RendererData m_Triangles;
    RendererData m_Lights;
 
    unsigned int m_TextureIndex,m_PointIndex,m_LineIndex,m_TriangleIndex;
 
    IndexBuffer IB;
 
    Vertex *m_BufferT;
    PointVertex *m_BufferP;
    LineVertex *m_BufferL;
    TriangleVertex *m_BufferTR;
    
    Framebuffer *m_Framebuffer;
    Framebuffer *m_LightingFramebuffer;
    Framebuffer *m_TempFramebuffer;
 
    Shader m_SHdr;
    Shader m_SPostProcessing;
    unsigned int m_PostProcessingIndex;
 
    Vec3 m_AmbientLight;
    Vec3 m_ClearColor;
    
    int m_Slots[32];
    int m_MaxTextureSlots;
 
    float m_PointSize;
    float m_LineWidth;
    float m_Zoom;
 
    float m_Gamma;
    float m_Exposure;
    TonemapType m_TonemapType=TonemapType::Reinhard;
 
    //matrices set in the camera (copied here so reloading the shaders doesn't involve the camera)
    glm::mat4 m_Proj;
    glm::mat4 m_View;
    glm::mat4 m_ViewProj;
 
    std::vector<std::pair<Vec2,Vec2>>segments; //used for lighting
 
    static bool cmp1(const Vertex &v1,const Vertex &v2){
        if(v1.layer==v2.layer)
            return v1.texID<v2.texID;
        return v1.layer<v2.layer; 
    }
 
    template<typename T>
    static bool cmpgeneral(const T &v1,const T &v2){
        return v1.layer<v2.layer; 
    }
 
    inline int GetTexturesMinLayer(){ return m_Textures.NumVertices>0?m_BufferT[m_TextureIndex].layer:std::numeric_limits<int>::max(); }
    inline int GetPointsMinLayer(){ return m_Points.NumVertices>0?m_BufferP[m_PointIndex].layer:std::numeric_limits<int>::max(); }
    inline int GetLinesMinLayer(){ return m_Lines.NumVertices>0?m_BufferL[m_LineIndex].layer:std::numeric_limits<int>::max(); }
    inline int GetTrianglesMinLayer(){ return m_Triangles.NumVertices>0?m_BufferTR[m_TriangleIndex].layer:std::numeric_limits<int>::max(); }
 
    inline void AddLayout(VertexBufferLayout &VBL,unsigned int type,unsigned int count,bool normalized){
        VBL.Push(type,count,normalized);
    }
};