Elevate::Renderer Class Reference

#include <Renderer.h>

Static Public Member Functions
static RendererAPI::GraphicAPI	GetAPI ()
static void	BeginFrame (const ScenePtr scene, const Camera &cam)
static bool	BindShader (const std::shared_ptr< Shader > &shader)
static void	ApplySystemUniforms (const std::shared_ptr< Shader > &shader)
static void	SetClearColor (const glm::vec4 &color)
static void	Clear ()
static void	FlushBuffers ()
static void	SetViewport (int x, int y, int width, int height)
static void	DrawArray (const VertexArray *vao, DrawPrimitiveType primitive=DrawPrimitiveType::Triangles)
static void	DrawArray (const std::shared_ptr< VertexArray > &vao, DrawPrimitiveType primitive=DrawPrimitiveType::Triangles)
static void	DrawStack ()
static void	PushRenderState (const RenderState &newState)
static void	Dispatch (const RenderCommand &command)
	Immediatly process a RenderCommand. Do not use directly unless you know what you are donig.
static void	Submit (RenderBucket::Type type, const RenderCommand &command)
static void	SubmitMesh (const std::shared_ptr< VertexArray > &vao, const std::shared_ptr< Material > &material, const glm::mat4 &transform, RenderBucket::Type bucketType=RenderBucket::Opaque)
static void	BindTexture (const std::shared_ptr< Texture > &texture, uint8_t slot=0)
static void	InvalidateStateCache ()

Detailed Description

Definition at line 21 of file Renderer.h.

Member Function Documentation

ApplySystemUniforms()

void Elevate::Renderer::ApplySystemUniforms ( const std::shared_ptr< Shader > &  shader )

static

Definition at line 42 of file Renderer.cpp.

    {
        // If the binded shader changed
        if (BindShader(shader))
        {
            shader->SetProjectionViewMatrix(s_data.ViewProj);
            shader->SetCameraPosition(s_data.CameraPosition);
        }
    }

BeginFrame()

void Elevate::Renderer::BeginFrame ( const ScenePtr  scene, const Camera &  cam  )

static

Definition at line 21 of file Renderer.cpp.

    {
        s_API->ClearTextureBindings();
        s_currentShaderID = 0;
        s_data.CameraPosition = cam.gameObject->GetPosition();
        s_data.ViewProj = cam.GenViewProjectionMatrix();
        s_data.ActiveLighting = scene->GetSceneLighting();
    }

BindShader()

bool Elevate::Renderer::BindShader ( const std::shared_ptr< Shader > &  shader )

static

Definition at line 30 of file Renderer.cpp.

    {
        uint32_t id = shader->GetID();
        if (s_currentShaderID != id)
        {
            shader->Bind();
            s_currentShaderID = id;
            return true;
        }
        return false;
    }

BindTexture()

void Elevate::Renderer::BindTexture ( const std::shared_ptr< Texture > &  texture, uint8_t  slot = 0  )

static

Definition at line 160 of file Renderer.cpp.

    {
        // todo optimize and make sure EVERY texture uses this
        uintptr_t textureID = texture ? reinterpret_cast<uintptr_t>(texture->GetNativeHandle()) : 0;
        if (s_textures[slot] != textureID)
        {
            if (texture)
            {
                texture->Bind(slot);
            }
            s_textures[slot] = textureID;
        }
    }

Clear()

void Elevate::Renderer::Clear ( )

static

Definition at line 58 of file Renderer.cpp.

    {
        s_API->Clear();
    }

Dispatch()

void Elevate::Renderer::Dispatch ( const RenderCommand &  command )

static

Immediatly process a RenderCommand. Do not use directly unless you know what you are donig.

Parameters

command

The RenderCommand to process at this exact instant.

Definition at line 112 of file Renderer.cpp.

    {
        // Update the renderer state if necessary
        PushRenderState(command.m_State);
 
        // Setup the Material and Shader
        uint32_t prevshader = s_currentShaderID;
        if (command.m_MaterialInstance)
        {
            auto shader = command.m_MaterialInstance->GetShader();
            if (shader)
            {
                ApplySystemUniforms(shader);
                shader->SetModelMatrix(command.Transform);
                s_data.ActiveLighting->UploadToShader(shader);
                command.m_MaterialInstance->Apply();
            }
        }
        // Actually render the vertex array
        Renderer::DrawArray(command.m_VertexArray);
    }

DrawArray() [1/2]

void Elevate::Renderer::DrawArray ( const std::shared_ptr< VertexArray > &  vao, DrawPrimitiveType  primitive = DrawPrimitiveType::Triangles  )

static

Definition at line 81 of file Renderer.cpp.

    {
        DrawArray(vao.get(), primitive);
    }

DrawArray() [2/2]

void Elevate::Renderer::DrawArray ( const VertexArray *  vao, DrawPrimitiveType  primitive = DrawPrimitiveType::Triangles  )

static

Definition at line 73 of file Renderer.cpp.

    {
        if (vao)
        {
            s_API->DrawArray(vao, primitive);
        }
    }

DrawStack()

void Elevate::Renderer::DrawStack ( )

static

Definition at line 86 of file Renderer.cpp.

    {
        s_commands.FlushAll();
    }

FlushBuffers()

void Elevate::Renderer::FlushBuffers ( )

static

Definition at line 63 of file Renderer.cpp.

    {
        s_API->FlushBuffers();
    }

GetAPI()

static RendererAPI::GraphicAPI Elevate::Renderer::GetAPI ( )

inlinestatic

Definition at line 24 of file Renderer.h.

{ return RendererAPI::GetAPI(); }

InvalidateStateCache()

void Elevate::Renderer::InvalidateStateCache ( )

static

Definition at line 174 of file Renderer.cpp.

    {
        // Make each texture ptr to an impossible value to make sure we bind each frame.
        for (int i = 0; i < std::size(s_textures); i++) {
            s_textures[i] = (uintptr_t)-1;
        }
    }

PushRenderState()

void Elevate::Renderer::PushRenderState ( const RenderState &  newState )

static

Definition at line 91 of file Renderer.cpp.

    {
        // todo make a first invalid call to make sure the GPU is synced with this cache before the user does anything
        if (newState.Cullface != s_currentState.Cullface)
        {
            s_API->SetCullingState(newState.Cullface);
        }
 
        if (newState.DepthWrite != s_currentState.DepthWrite)
        {
            s_API->SetDepthWrittingState(newState.DepthWrite);
        }
 
        if (newState.DepthTest != s_currentState.DepthTest)
        {
            s_API->SetDepthTestingState(newState.DepthTest);
        }
 
        s_currentState = newState;
    }

SetClearColor()

void Elevate::Renderer::SetClearColor ( const glm::vec4 &  color )

static

Definition at line 53 of file Renderer.cpp.

    {
        s_API->SetClearColor(color);
    }

SetViewport()

void Elevate::Renderer::SetViewport ( int  x, int  y, int  width, int  height  )

static

Definition at line 68 of file Renderer.cpp.

    {
        s_API->SetViewport(x, y, width, height);
    }

Submit()

void Elevate::Renderer::Submit ( RenderBucket::Type  type, const RenderCommand &  command  )

static

Definition at line 134 of file Renderer.cpp.

    {
        s_commands.Submit(type, command);
    }

SubmitMesh()

void Elevate::Renderer::SubmitMesh ( const std::shared_ptr< VertexArray > &  vao, const std::shared_ptr< Material > &  material, const glm::mat4 &  transform, RenderBucket::Type  bucketType = RenderBucket::Opaque  )

static

Definition at line 139 of file Renderer.cpp.

    {
        RenderCommand command;
        command.m_VertexArray = vao.get();
        command.m_MaterialInstance = material.get();
        command.Transform = transform;
 
        if (bucketType == RenderBucket::Transparent)
        {
            command.m_State.BlendEnable = true;
            command.m_State.DepthWrite = false; // Transparents usually don't write to depth
        }
        else
        {
            command.m_State.BlendEnable = false;
            command.m_State.DepthWrite = true;
        }
 
        Submit(bucketType, command);
    }

---

The documentation for this class was generated from the following files:

• ElevateEngine/src/ElevateEngine/Renderer/Renderer.h
• ElevateEngine/src/ElevateEngine/Renderer/Renderer.cpp