Vesper::Renderer2D Class Reference

A 2D renderer for drawing quads and sprites. More...

#include <Renderer2D.h>

Classes
struct	Statistics
	2D Renderer Statistics More...

Static Public Member Functions
static void	Init ()
	Initializes the 2D renderer.
static void	Shutdown ()
	Shuts down the 2D renderer.
static void	BeginScene (const Camera &camera, const glm::mat4 &transform)
	Begins a new scene with the given camera and transform.
static void	BeginScene (const EditorCamera &camera)
	Begins a new scene with the given editor camera.
static void	BeginScene (const OrthographicCamera &camera)
	Begins a new scene with the given orthographic camera.
static void	EndScene ()
	Ends the current scene.
static void	Flush ()
	Flushes the current batch of rendering commands.
static void	DrawQuad (const glm::mat4 &transform, const glm::vec4 &color)
	Draws a colored quad with the given transform and color.
static void	DrawQuad (const glm::vec2 &position, const glm::vec2 &size, const glm::vec4 &color)
	Draws a colored quad at the specified position and size.
static void	DrawQuad (const glm::vec3 &position, const glm::vec2 &size, const glm::vec4 &color)
	Draws a colored quad at the specified position and size.
static void	DrawQuadWithTexture (const glm::mat4 &transform, const Ref< Texture2D > &texture, float tilingFactor, const glm::vec4 tintColor)
	Draws a textured quad with the given transform, texture, tiling factor, and tint color.
static void	DrawQuadWithTexture (const glm::vec2 &position, const glm::vec2 &size, const Ref< Texture2D > &texture, float tilingFactor, const glm::vec4 tintColor)
	Draws a textured quad at the specified position and size.
static void	DrawQuadWithTexture (const glm::vec3 &position, const glm::vec2 &size, const Ref< Texture2D > &texture, float tilingFactor, const glm::vec4 tintColor)
	Draws a textured quad at the specified position and size.
static void	DrawQuadWithTexture (const glm::mat4 &transform, const Ref< SubTexture2D > &subtexture, float tilingFactor, const glm::vec4 tintColor)
	Draws a textured quad with the given transform, subtexture, tiling factor, and tint color.
static void	DrawQuadWithTexture (const glm::vec2 &position, const glm::vec2 &size, const Ref< SubTexture2D > &subtexture, float tilingFactor, const glm::vec4 tintColor)
	Draws a textured quad at the specified position and size.
static void	DrawQuadWithTexture (const glm::vec3 &position, const glm::vec2 &size, const Ref< SubTexture2D > &subtexture, float tilingFactor, const glm::vec4 tintColor)
	Draws a textured quad at the specified position and size.
static void	DrawQuadRotated (const glm::mat4 &transform, const glm::vec4 &color)
	Draws a rotated colored quad with the given transform and color.
static void	DrawQuadRotated (const glm::vec2 &position, const glm::vec2 &size, float rotationRads, const glm::vec4 &color)
	Draws a rotated colored quad at the specified position, size, and rotation.
static void	DrawQuadRotated (const glm::vec3 &position, const glm::vec2 &size, float rotationRads, const glm::vec4 &color)
	Draws a rotated colored quad at the specified position, size, and rotation.
static void	DrawQuadRotatedWithTexture (const glm::mat4 &transform, const Ref< Texture2D > &texture, float tilingFactor, const glm::vec4 tintColor)
	Draws a rotated textured quad with the given transform, texture, tiling factor, and tint color.
static void	DrawQuadRotatedWithTexture (const glm::vec2 &position, const glm::vec2 &size, const Ref< Texture2D > &texture, float rotationRads, float tilingFactor, const glm::vec4 tintColor)
	Draws a rotated textured quad at the specified position, size, and rotation.
static void	DrawQuadRotatedWithTexture (const glm::vec3 &position, const glm::vec2 &size, const Ref< Texture2D > &texture, float rotationRads, float tilingFactor, const glm::vec4 tintColor)
	Draws a rotated textured quad at the specified position, size, and rotation.
static void	DrawQuadRotatedWithTexture (const glm::mat4 &transform, const Ref< SubTexture2D > &subtexture, float tilingFactor, const glm::vec4 tintColor)
	Draws a rotated textured quad with the given transform, subtexture, tiling factor, and tint color.
static void	DrawQuadRotatedWithTexture (const glm::vec2 &position, const glm::vec2 &size, const Ref< SubTexture2D > &subtexture, float rotationRads, float tilingFactor, const glm::vec4 tintColor)
	Draws a rotated textured quad at the specified position, size, and rotation.
static void	DrawQuadRotatedWithTexture (const glm::vec3 &position, const glm::vec2 &size, const Ref< SubTexture2D > &subtexture, float rotationRads, float tilingFactor, const glm::vec4 tintColor)
	Draws a rotated textured quad at the specified position, size, and rotation.
static Ref< Texture2D >	GetWhiteTexture ()
	Returns a reference to the default white texture that allows for coloring.
static void	ResetStats ()
	Resets the rendering statistics.
static Statistics	GetStats ()
	Retrieves the current rendering statistics.

Static Private Member Functions
static void	FlushAndReset ()
static void	StartBatch ()

Detailed Description

A 2D renderer for drawing quads and sprites.

Member Function Documentation

BeginScene() [1/3]

void Vesper::Renderer2D::BeginScene ( const Camera & camera, const glm::mat4 & transform )

static

Begins a new scene with the given camera and transform.

Parameters

camera	The camera to use for the scene.
transform	The transform matrix for the camera.

    {
        VZ_PROFILE_FUNCTION();
 
        glm::mat4 viewProj = camera.GetProjection() * glm::inverse(transform);
 
        s_Data.TextureShader->Bind();
        s_Data.TextureShader->SetMat4("u_ViewProjection", viewProj);
 
        s_Data.QuadIndexCount = 0;
        s_Data.QuadVertexBufferPtr = s_Data.QuadVertexBufferBase;
 
        s_Data.TextureSlotIndex = 1;
    }

References Vesper::Renderer2DData::QuadIndexCount, Vesper::Renderer2DData::QuadVertexBufferBase, Vesper::Renderer2DData::QuadVertexBufferPtr, Vesper::s_Data, and Vesper::Renderer2DData::TextureSlotIndex.

BeginScene() [2/3]

void Vesper::Renderer2D::BeginScene ( const EditorCamera & camera )

static

Begins a new scene with the given editor camera.

Parameters

camera

The editor camera to use for the scene.

    {
        VZ_PROFILE_FUNCTION();
 
        glm::mat4 viewProj = camera.GetViewProjection();
        s_Data.TextureShader->Bind();
        s_Data.TextureShader->SetMat4("u_ViewProjection", viewProj);
        StartBatch();
    }

References Vesper::s_Data, and StartBatch().

Referenced by Vesper::Scene::OnUpdateEditor().

BeginScene() [3/3]

void Vesper::Renderer2D::BeginScene ( const OrthographicCamera & camera )

static

Begins a new scene with the given orthographic camera.

Parameters

camera

The orthographic camera to use for the scene.

Todo

Remove once we have a proper scene system

    {
        VZ_PROFILE_FUNCTION();
        s_Data.TextureShader->Bind();
        s_Data.TextureShader->SetMat4("u_ViewProjection", camera.GetViewProjectionMatrix());
 
        s_Data.QuadIndexCount = 0;
        s_Data.QuadVertexBufferPtr = s_Data.QuadVertexBufferBase;
 
        s_Data.TextureSlotIndex = 1;
    }

References Vesper::Renderer2DData::QuadIndexCount, Vesper::Renderer2DData::QuadVertexBufferBase, Vesper::Renderer2DData::QuadVertexBufferPtr, Vesper::s_Data, and Vesper::Renderer2DData::TextureSlotIndex.

DrawQuad() [1/3]

void Vesper::Renderer2D::DrawQuad ( const glm::mat4 & transform, const glm::vec4 & color )

static

Draws a colored quad with the given transform and color.

Parameters

transform	The transform matrix for the quad.
color	The color of the quad.

    {
        VZ_PROFILE_FUNCTION();
        constexpr size_t quadVertexCount = 4;
        constexpr glm::vec2 texCoords[quadVertexCount] = {
            { 0.0f, 0.0f },
            { 1.0f, 0.0f },
            { 1.0f, 1.0f },
            { 0.0f, 1.0f }
        };
        if (s_Data.QuadIndexCount >= s_Data.MaxIndices)
            FlushAndReset();
        const float texIndex = 0.0f; // White Texture
        const float tilingFactor = 1.0f;
        for (size_t i = 0; i < quadVertexCount; i++)
        {
            s_Data.QuadVertexBufferPtr->Position = transform * s_Data.QuadVertexPositions[i];
            s_Data.QuadVertexBufferPtr->Color = color;
            s_Data.QuadVertexBufferPtr->TexCoord = texCoords[i];
            s_Data.QuadVertexBufferPtr->TexIndex = texIndex;
            s_Data.QuadVertexBufferPtr->TilingFactor = tilingFactor;
            s_Data.QuadVertexBufferPtr++;
        }
        s_Data.QuadIndexCount += 6;
        s_Data.Stats.QuadCount++;
 
    }

References FlushAndReset(), Vesper::Renderer2DData::MaxIndices, Vesper::Renderer2D::Statistics::QuadCount, Vesper::Renderer2DData::QuadIndexCount, Vesper::Renderer2DData::QuadVertexBufferPtr, Vesper::s_Data, Vesper::Renderer2DData::Stats, Vesper::QuadVertex::TexIndex, and Vesper::QuadVertex::TilingFactor.

DrawQuad() [2/3]

void Vesper::Renderer2D::DrawQuad ( const glm::vec2 & position, const glm::vec2 & size, const glm::vec4 & color )

static

Draws a colored quad at the specified position and size.

Parameters

position	The position of the quad in 2D space.
size	The size of the quad.
color	The color of the quad.

    {
        DrawQuad({ position.x, position.y, 0.0f }, size, color);
    }

DrawQuad() [3/3]

void Vesper::Renderer2D::DrawQuad ( const glm::vec3 & position, const glm::vec2 & size, const glm::vec4 & color )

static

Draws a colored quad at the specified position and size.

Parameters

position	The position of the quad in 3D space.
size	The size of the quad.
color	The color of the quad.

    {
        glm::mat4 transform = glm::translate(glm::mat4(1.0f), position) * glm::scale(glm::mat4(1.0f), { size.x, size.y, 1.0f });
        DrawQuad(transform, color);
 
    }

DrawQuadRotated() [1/3]

void Vesper::Renderer2D::DrawQuadRotated ( const glm::mat4 & transform, const glm::vec4 & color )

static

Draws a rotated colored quad with the given transform and color.

Parameters

transform	The transform matrix for the quad.
color	The color of the quad.

    {
        VZ_PROFILE_FUNCTION();
        constexpr size_t quadVertexCount = 4;
        constexpr glm::vec2 texCoords[quadVertexCount] = {
            { 0.0f, 0.0f },
            { 1.0f, 0.0f },
            { 1.0f, 1.0f },
            { 0.0f, 1.0f }
        };
        if (s_Data.QuadIndexCount >= s_Data.MaxIndices)
            FlushAndReset();
        const float texIndex = 0.0f; // White Texture
        const float tilingFactor = 1.0f;
        for (size_t i = 0; i < quadVertexCount; i++)
        {
            s_Data.QuadVertexBufferPtr->Position = transform * s_Data.QuadVertexPositions[i];
            s_Data.QuadVertexBufferPtr->Color = color;
            s_Data.QuadVertexBufferPtr->TexCoord = texCoords[i];
            s_Data.QuadVertexBufferPtr->TexIndex = texIndex;
            s_Data.QuadVertexBufferPtr->TilingFactor = tilingFactor;
            s_Data.QuadVertexBufferPtr++;
        }
        s_Data.QuadIndexCount += 6;
        s_Data.Stats.QuadCount++;
    }

References FlushAndReset(), Vesper::Renderer2DData::MaxIndices, Vesper::Renderer2D::Statistics::QuadCount, Vesper::Renderer2DData::QuadIndexCount, Vesper::Renderer2DData::QuadVertexBufferPtr, Vesper::s_Data, Vesper::Renderer2DData::Stats, Vesper::QuadVertex::TexIndex, and Vesper::QuadVertex::TilingFactor.

DrawQuadRotated() [2/3]

void Vesper::Renderer2D::DrawQuadRotated ( const glm::vec2 & position, const glm::vec2 & size, float rotationRads, const glm::vec4 & color )

static

Draws a rotated colored quad at the specified position, size, and rotation.

Parameters

position	The position of the quad in 2D space.
size	The size of the quad.
rotationRads	The rotation of the quad in radians.
color	The color of the quad.

    {
        DrawQuadRotated({ position.x, position.y, 0.0f }, size, rotationRads, color);
    }

DrawQuadRotated() [3/3]

void Vesper::Renderer2D::DrawQuadRotated ( const glm::vec3 & position, const glm::vec2 & size, float rotationRads, const glm::vec4 & color )

static

Draws a rotated colored quad at the specified position, size, and rotation.

Parameters

position	The position of the quad in 3D space.
size	The size of the quad.
rotationRads	The rotation of the quad in radians.
color	The color of the quad.

    {
        glm::mat4 transform = glm::translate(glm::mat4(1.0f), position)
            * glm::rotate(glm::mat4(1.0f), rotationRads, { 0.0f, 0.0f, 1.0f })
            * glm::scale(glm::mat4(1.0f), { size.x, size.y, 1.0f });
        DrawQuadRotated(transform, color);
    }

DrawQuadRotatedWithTexture() [1/6]

void Vesper::Renderer2D::DrawQuadRotatedWithTexture ( const glm::mat4 & transform, const Ref< SubTexture2D > & subtexture, float tilingFactor, const glm::vec4 tintColor )

static

Draws a rotated textured quad with the given transform, subtexture, tiling factor, and tint color.

Parameters

transform	The transform matrix for the quad.
subtexture	The subtexture to apply to the quad.
tilingFactor	The tiling factor for the texture.
tintColor	The tint color to apply to the texture.

    {
        VZ_PROFILE_FUNCTION();
        constexpr size_t quadVertexCount = 4;
        const glm::vec2* texCoords = subtexture->GetTexCoords();
        const Ref<Texture2D> texture = subtexture->GetTexture();
        if (s_Data.QuadIndexCount >= s_Data.MaxIndices)
            FlushAndReset();
        float textureIndex = 0.0f;
        for (uint32_t i = 1; i < s_Data.TextureSlotIndex; i++)
        {
            if (*s_Data.TextureSlots[i].get() == *texture.get())
            {
                textureIndex = (float)i;
                break;
            }
        }
        if (textureIndex == 0.0f)
        {
            if (s_Data.TextureSlotIndex >= s_Data.MaxTextureSlots)
                FlushAndReset();
            textureIndex = (float)s_Data.TextureSlotIndex;
            s_Data.TextureSlots[s_Data.TextureSlotIndex] = texture;
            s_Data.TextureSlotIndex++;
        }
        for (size_t i = 0; i < quadVertexCount; i++)
        {
            s_Data.QuadVertexBufferPtr->Position = transform * s_Data.QuadVertexPositions[i];
            s_Data.QuadVertexBufferPtr->Color = tintColor;
            s_Data.QuadVertexBufferPtr->TexCoord = texCoords[i];
            s_Data.QuadVertexBufferPtr->TexIndex = textureIndex;
            s_Data.QuadVertexBufferPtr->TilingFactor = tilingFactor;
            s_Data.QuadVertexBufferPtr++;
        }
        s_Data.QuadIndexCount += 6;
        s_Data.Stats.QuadCount++;
 
    }

References FlushAndReset(), Vesper::Renderer2DData::MaxIndices, Vesper::Renderer2DData::MaxTextureSlots, Vesper::Renderer2D::Statistics::QuadCount, Vesper::Renderer2DData::QuadIndexCount, Vesper::Renderer2DData::QuadVertexBufferPtr, Vesper::s_Data, Vesper::Renderer2DData::Stats, Vesper::QuadVertex::TexIndex, Vesper::Renderer2DData::TextureSlotIndex, and Vesper::QuadVertex::TilingFactor.

DrawQuadRotatedWithTexture() [2/6]

void Vesper::Renderer2D::DrawQuadRotatedWithTexture ( const glm::mat4 & transform, const Ref< Texture2D > & texture, float tilingFactor, const glm::vec4 tintColor )

static

Draws a rotated textured quad with the given transform, texture, tiling factor, and tint color.

Parameters

transform	The transform matrix for the quad.
texture	The texture to apply to the quad.
tilingFactor	The tiling factor for the texture.
tintColor	The tint color to apply to the texture.

    {
        VZ_PROFILE_FUNCTION();
        constexpr size_t quadVertexCount = 4;
        constexpr glm::vec2 texCoords[quadVertexCount] = {
            { 0.0f, 0.0f },
            { 1.0f, 0.0f },
            { 1.0f, 1.0f },
            { 0.0f, 1.0f }
        };
        if (s_Data.QuadIndexCount >= s_Data.MaxIndices)
            FlushAndReset();
        float textureIndex = 0.0f;
        for (uint32_t i = 1; i < s_Data.TextureSlotIndex; i++)
        {
            if (*s_Data.TextureSlots[i].get() == *texture.get())
            {
                textureIndex = (float)i;
                break;
            }
        }
        if (textureIndex == 0.0f)
        {
            if (s_Data.TextureSlotIndex >= s_Data.MaxTextureSlots)
                FlushAndReset();
            textureIndex = (float)s_Data.TextureSlotIndex;
            s_Data.TextureSlots[s_Data.TextureSlotIndex] = texture;
            s_Data.TextureSlotIndex++;
        }
        for (size_t i = 0; i < quadVertexCount; i++)
        {
            s_Data.QuadVertexBufferPtr->Position = transform * s_Data.QuadVertexPositions[i];
            s_Data.QuadVertexBufferPtr->Color = tintColor;
            s_Data.QuadVertexBufferPtr->TexCoord = texCoords[i];
            s_Data.QuadVertexBufferPtr->TexIndex = textureIndex;
            s_Data.QuadVertexBufferPtr->TilingFactor = tilingFactor;
            s_Data.QuadVertexBufferPtr++;
        }
        s_Data.QuadIndexCount += 6;
        s_Data.Stats.QuadCount++;
    }

References FlushAndReset(), Vesper::Renderer2DData::MaxIndices, Vesper::Renderer2DData::MaxTextureSlots, Vesper::Renderer2D::Statistics::QuadCount, Vesper::Renderer2DData::QuadIndexCount, Vesper::Renderer2DData::QuadVertexBufferPtr, Vesper::s_Data, Vesper::Renderer2DData::Stats, Vesper::QuadVertex::TexIndex, Vesper::Renderer2DData::TextureSlotIndex, and Vesper::QuadVertex::TilingFactor.

DrawQuadRotatedWithTexture() [3/6]

void Vesper::Renderer2D::DrawQuadRotatedWithTexture ( const glm::vec2 & position, const glm::vec2 & size, const Ref< SubTexture2D > & subtexture, float rotationRads, float tilingFactor, const glm::vec4 tintColor )

static

Draws a rotated textured quad at the specified position, size, and rotation.

Parameters

position	The position of the quad in 2D space.
size	The size of the quad.
rotationRads	The rotation of the quad in radians.
subtexture	The subtexture to apply to the quad.
tilingFactor	The tiling factor for the texture.
tintColor	The tint color to apply to the texture.

    {
        DrawQuadRotatedWithTexture({ position.x, position.y, 0.0f }, size, subtexture, rotationRads, tilingFactor, tintColor);
    }

DrawQuadRotatedWithTexture() [4/6]

void Vesper::Renderer2D::DrawQuadRotatedWithTexture ( const glm::vec2 & position, const glm::vec2 & size, const Ref< Texture2D > & texture, float rotationRads, float tilingFactor, const glm::vec4 tintColor )

static

Draws a rotated textured quad at the specified position, size, and rotation.

Parameters

position	The position of the quad in 2D space.
size	The size of the quad.
rotationRads	The rotation of the quad in radians.
texture	The texture to apply to the quad.
tilingFactor	The tiling factor for the texture.
tintColor	The tint color to apply to the texture.

    {
        DrawQuadRotatedWithTexture({ position.x, position.y, 0.0f }, size, texture, rotationRads, tilingFactor, tintColor);
    }

DrawQuadRotatedWithTexture() [5/6]

void Vesper::Renderer2D::DrawQuadRotatedWithTexture ( const glm::vec3 & position, const glm::vec2 & size, const Ref< SubTexture2D > & subtexture, float rotationRads, float tilingFactor, const glm::vec4 tintColor )

static

Draws a rotated textured quad at the specified position, size, and rotation.

Parameters

position	The position of the quad in 3D space.
size	The size of the quad.
rotationRads	The rotation of the quad in radians.
subtexture	The subtexture to apply to the quad.
tilingFactor	The tiling factor for the texture.
tintColor	The tint color to apply to the texture.

    {
        VZ_PROFILE_FUNCTION();
 
        glm::mat4 transform = glm::translate(glm::mat4(1.0f), position)
            * glm::rotate(glm::mat4(1.0f), rotationRads, { 0.0f, 0.0f, 1.0f })
            * glm::scale(glm::mat4(1.0f), { size.x, size.y, 1.0f });
 
        DrawQuadRotatedWithTexture(transform, subtexture, tilingFactor, tintColor);
    }

DrawQuadRotatedWithTexture() [6/6]

void Vesper::Renderer2D::DrawQuadRotatedWithTexture ( const glm::vec3 & position, const glm::vec2 & size, const Ref< Texture2D > & texture, float rotationRads, float tilingFactor, const glm::vec4 tintColor )

static

Draws a rotated textured quad at the specified position, size, and rotation.

Parameters

position	The position of the quad in 3D space.
size	The size of the quad.
rotationRads	The rotation of the quad in radians.
texture	The texture to apply to the quad.
tilingFactor	The tiling factor for the texture.
tintColor	The tint color to apply to the texture.

    {
        glm::mat4 transform = glm::translate(glm::mat4(1.0f), position)
            * glm::rotate(glm::mat4(1.0f), rotationRads, { 0.0f, 0.0f, 1.0f })
            * glm::scale(glm::mat4(1.0f), { size.x, size.y, 1.0f });
 
        DrawQuadRotatedWithTexture(transform, texture, tilingFactor, tintColor);
    }

DrawQuadWithTexture() [1/6]

void Vesper::Renderer2D::DrawQuadWithTexture ( const glm::mat4 & transform, const Ref< SubTexture2D > & subtexture, float tilingFactor, const glm::vec4 tintColor )

static

Draws a textured quad with the given transform, subtexture, tiling factor, and tint color.

Parameters

transform	The transform matrix for the quad.
subtexture	The subtexture to apply to the quad.
tilingFactor	The tiling factor for the texture.
tintColor	The tint color to apply to the texture.

    {
        VZ_PROFILE_FUNCTION();
 
        constexpr size_t quadVertexCount = 4;
        const glm::vec2* texCoords = subtexture->GetTexCoords();
        const Ref<Texture2D> texture = subtexture->GetTexture();
 
        if (s_Data.QuadIndexCount >= s_Data.MaxIndices)
            FlushAndReset();
 
        float textureIndex = 0.0f;
        for (uint32_t i = 1; i < s_Data.TextureSlotIndex; i++)
        {
            if (*s_Data.TextureSlots[i].get() == *texture.get())
            {
                textureIndex = (float)i;
                break;
            }
        }
 
        if (textureIndex == 0.0f)
        {
            if (s_Data.TextureSlotIndex >= s_Data.MaxTextureSlots)
                FlushAndReset();
 
            textureIndex = (float)s_Data.TextureSlotIndex;
            s_Data.TextureSlots[s_Data.TextureSlotIndex] = texture;
            s_Data.TextureSlotIndex++;
        }
 
        for (size_t i = 0; i < quadVertexCount; i++)
        {
            s_Data.QuadVertexBufferPtr->Position = transform * s_Data.QuadVertexPositions[i];
            s_Data.QuadVertexBufferPtr->Color = tintColor;
            s_Data.QuadVertexBufferPtr->TexCoord = texCoords[i];
            s_Data.QuadVertexBufferPtr->TexIndex = textureIndex;
            s_Data.QuadVertexBufferPtr->TilingFactor = tilingFactor;
            s_Data.QuadVertexBufferPtr++;
        }
 
        s_Data.QuadIndexCount += 6;
        s_Data.Stats.QuadCount++;
    }

References FlushAndReset(), Vesper::Renderer2DData::MaxIndices, Vesper::Renderer2DData::MaxTextureSlots, Vesper::Renderer2D::Statistics::QuadCount, Vesper::Renderer2DData::QuadIndexCount, Vesper::Renderer2DData::QuadVertexBufferPtr, Vesper::s_Data, Vesper::Renderer2DData::Stats, Vesper::QuadVertex::TexIndex, Vesper::Renderer2DData::TextureSlotIndex, and Vesper::QuadVertex::TilingFactor.

DrawQuadWithTexture() [2/6]

void Vesper::Renderer2D::DrawQuadWithTexture ( const glm::mat4 & transform, const Ref< Texture2D > & texture, float tilingFactor, const glm::vec4 tintColor )

static

Draws a textured quad with the given transform, texture, tiling factor, and tint color.

Parameters

transform	The transform matrix for the quad.
texture	The texture to apply to the quad.
tilingFactor	The tiling factor for the texture.
tintColor	The tint color to apply to the texture.

    {
        VZ_PROFILE_FUNCTION();
        constexpr size_t quadVertexCount = 4;
        constexpr glm::vec4 color = { 1.0f, 1.0f, 1.0f, 1.0f };
        constexpr glm::vec2 texCoords[quadVertexCount] = {
            { 0.0f, 0.0f },
            { 1.0f, 0.0f },
            { 1.0f, 1.0f },
            { 0.0f, 1.0f }
        };
        if (s_Data.QuadIndexCount >= s_Data.MaxIndices)
            FlushAndReset();
        float textureIndex = 0.0f;
        for (uint32_t i = 1; i < s_Data.TextureSlotIndex; i++)
        {
            if (*s_Data.TextureSlots[i].get() == *texture.get())
            {
                textureIndex = (float)i;
                break;
            }
        }
        if (textureIndex == 0.0f)
        {
            if (s_Data.TextureSlotIndex >= s_Data.MaxTextureSlots)
                FlushAndReset();
            textureIndex = (float)s_Data.TextureSlotIndex;
            s_Data.TextureSlots[s_Data.TextureSlotIndex] = texture;
            s_Data.TextureSlotIndex++;
        }
        for (size_t i = 0; i < quadVertexCount; i++)
        {
            s_Data.QuadVertexBufferPtr->Position = transform * s_Data.QuadVertexPositions[i];
            s_Data.QuadVertexBufferPtr->Color = tintColor;
            s_Data.QuadVertexBufferPtr->TexCoord = texCoords[i];
            s_Data.QuadVertexBufferPtr->TexIndex = textureIndex;
            s_Data.QuadVertexBufferPtr->TilingFactor = tilingFactor;
            s_Data.QuadVertexBufferPtr++;
        }
 
        s_Data.QuadIndexCount += 6;
        s_Data.Stats.QuadCount++;
 
    }

References FlushAndReset(), Vesper::Renderer2DData::MaxIndices, Vesper::Renderer2DData::MaxTextureSlots, Vesper::Renderer2D::Statistics::QuadCount, Vesper::Renderer2DData::QuadIndexCount, Vesper::Renderer2DData::QuadVertexBufferPtr, Vesper::s_Data, Vesper::Renderer2DData::Stats, Vesper::QuadVertex::TexIndex, Vesper::Renderer2DData::TextureSlotIndex, and Vesper::QuadVertex::TilingFactor.

DrawQuadWithTexture() [3/6]

void Vesper::Renderer2D::DrawQuadWithTexture ( const glm::vec2 & position, const glm::vec2 & size, const Ref< SubTexture2D > & subtexture, float tilingFactor, const glm::vec4 tintColor )

static

Draws a textured quad at the specified position and size.

Parameters

position	The position of the quad in 2D space.
size	The size of the quad.
subtexture	The subtexture to apply to the quad.
tilingFactor	The tiling factor for the texture.
tintColor	The tint color to apply to the texture.

    {
        DrawQuadWithTexture({ position.x, position.y, 0.0f }, size, subtexture, tilingFactor, tintColor);
    }

DrawQuadWithTexture() [4/6]

void Vesper::Renderer2D::DrawQuadWithTexture ( const glm::vec2 & position, const glm::vec2 & size, const Ref< Texture2D > & texture, float tilingFactor, const glm::vec4 tintColor )

static

Draws a textured quad at the specified position and size.

Parameters

position	The position of the quad in 2D space.
size	The size of the quad.
texture	The texture to apply to the quad.
tilingFactor	The tiling factor for the texture.
tintColor	The tint color to apply to the texture.

    {
        DrawQuadWithTexture({ position.x, position.y, 0.0f }, size, texture, tilingFactor, tintColor);
    }

DrawQuadWithTexture() [5/6]

void Vesper::Renderer2D::DrawQuadWithTexture ( const glm::vec3 & position, const glm::vec2 & size, const Ref< SubTexture2D > & subtexture, float tilingFactor, const glm::vec4 tintColor )

static

Draws a textured quad at the specified position and size.

Parameters

position	The position of the quad in 3D space.
size	The size of the quad.
subtexture	The subtexture to apply to the quad.
tilingFactor	The tiling factor for the texture.
tintColor	The tint color to apply to the texture.

    {
        VZ_PROFILE_FUNCTION();
 
        glm::mat4 transform = glm::translate(glm::mat4(1.0f), position) * glm::scale(glm::mat4(1.0f), { size.x, size.y, 1.0f });
        DrawQuadWithTexture(transform, subtexture, tilingFactor, tintColor);
    }

DrawQuadWithTexture() [6/6]

void Vesper::Renderer2D::DrawQuadWithTexture ( const glm::vec3 & position, const glm::vec2 & size, const Ref< Texture2D > & texture, float tilingFactor, const glm::vec4 tintColor )

static

Draws a textured quad at the specified position and size.

Parameters

position	The position of the quad in 3D space.
size	The size of the quad.
texture	The texture to apply to the quad.
tilingFactor	The tiling factor for the texture.
tintColor	The tint color to apply to the texture.

    {
        VZ_PROFILE_FUNCTION();
 
        glm::mat4 transform = glm::translate(glm::mat4(1.0f), position) * glm::scale(glm::mat4(1.0f), { size.x, size.y, 1.0f });
        DrawQuadWithTexture(transform, texture, tilingFactor, tintColor);
    }

EndScene()

void Vesper::Renderer2D::EndScene ( )

static

Ends the current scene.

    {
        VZ_PROFILE_FUNCTION();
        uint32_t dataSize = (uint32_t)((uint8_t*)s_Data.QuadVertexBufferPtr - (uint8_t*)s_Data.QuadVertexBufferBase);
 
        s_Data.QuadVertexBuffer->SetData(s_Data.QuadVertexBufferBase, dataSize);
        Flush();
    }

References Flush(), Vesper::Renderer2DData::QuadVertexBufferBase, Vesper::Renderer2DData::QuadVertexBufferPtr, and Vesper::s_Data.

Referenced by FlushAndReset(), Vesper::EditorLayer::OnUpdate(), Vesper::Scene::OnUpdateEditor(), and Vesper::Scene::OnUpdateRuntime().

Flush()

void Vesper::Renderer2D::Flush ( )

static

Flushes the current batch of rendering commands.

    {
        VZ_PROFILE_FUNCTION();
        // Bind textures
        for (uint32_t i = 0; i < s_Data.TextureSlotIndex; i++)
            s_Data.TextureSlots[i]->Bind(i);
 
        RenderCommand::DrawIndexed(s_Data.QuadVertexArray, s_Data.QuadIndexCount);
        s_Data.Stats.DrawCalls++;
    }

References Vesper::Renderer2D::Statistics::DrawCalls, Vesper::Renderer2DData::QuadIndexCount, Vesper::s_Data, Vesper::Renderer2DData::Stats, and Vesper::Renderer2DData::TextureSlotIndex.

Referenced by EndScene().

FlushAndReset()

void Vesper::Renderer2D::FlushAndReset ( )

staticprivate

    {
        EndScene();
        s_Data.QuadIndexCount = 0;
        s_Data.QuadVertexBufferPtr = s_Data.QuadVertexBufferBase;
        s_Data.TextureSlotIndex = 1;
    }

References EndScene(), Vesper::Renderer2DData::QuadIndexCount, Vesper::Renderer2DData::QuadVertexBufferBase, Vesper::Renderer2DData::QuadVertexBufferPtr, Vesper::s_Data, and Vesper::Renderer2DData::TextureSlotIndex.

Referenced by DrawQuad(), DrawQuadRotated(), DrawQuadRotatedWithTexture(), DrawQuadRotatedWithTexture(), DrawQuadWithTexture(), and DrawQuadWithTexture().

GetStats()

Renderer2D::Statistics Vesper::Renderer2D::GetStats ( )

static

Retrieves the current rendering statistics.

    {
        return s_Data.Stats;
    }

References Vesper::s_Data, and Vesper::Renderer2DData::Stats.

Referenced by Vesper::EditorLayer::OnImGuiRender().

GetWhiteTexture()

Ref< Texture2D > Vesper::Renderer2D::GetWhiteTexture ( )

static

Returns a reference to the default white texture that allows for coloring.

    {
        return s_Data.WhiteTexture;
    }

References Vesper::s_Data.

Init()

void Vesper::Renderer2D::Init ( )

static

Initializes the 2D renderer.

    {
        VZ_PROFILE_FUNCTION();
 
        s_Data.QuadVertexArray = (VertexArray::Create());
 
 
        s_Data.QuadVertexBuffer = VertexBuffer::Create(s_Data.MaxVertices * sizeof(QuadVertex));
 
        s_Data.QuadVertexBuffer->SetLayout({
            { ShaderDataType::Float3, "a_Position"  },
            { ShaderDataType::Float4, "a_Color"     },
            { ShaderDataType::Float2, "a_TexCoord"   },
            { ShaderDataType::Float,  "a_TexIndex"   },
            { ShaderDataType::Float,  "a_TilingFactor"}
            });
        s_Data.QuadVertexArray->AddVertexBuffer(s_Data.QuadVertexBuffer);
 
        s_Data.QuadVertexBufferBase = new QuadVertex[s_Data.MaxVertices];
 
        uint32_t* quadIndices = new uint32_t[s_Data.MaxIndices];
        uint32_t offset = 0;
 
        for (uint32_t i = 0; i < s_Data.MaxIndices; i += 6) {
            quadIndices[i + 0] = offset + 0;
            quadIndices[i + 1] = offset + 1;
            quadIndices[i + 2] = offset + 2;
            quadIndices[i + 3] = offset + 2;
            quadIndices[i + 4] = offset + 3;
            quadIndices[i + 5] = offset + 0;
 
            offset += 4;
        }
 
        Ref<IndexBuffer> quadIB;
        quadIB = (IndexBuffer::Create(quadIndices, s_Data.MaxIndices));
        s_Data.QuadVertexArray->SetIndexBuffer(quadIB);
        delete[] quadIndices;
 
        s_Data.WhiteTexture = Texture2D::Create(1, 1);
        uint32_t whiteTextureData = 0xffffffff;
        s_Data.WhiteTexture->SetData(&whiteTextureData, sizeof(uint32_t));
 
        int32_t samplers[s_Data.MaxTextureSlots];
        for (uint32_t i = 0; i < s_Data.MaxTextureSlots; i++)
            samplers[i] = i;
 
 
        s_Data.TextureShader = Shader::Create("../../Vesper-Editor/assets/shaders/Texture.glsl");
        s_Data.TextureShader->Bind();
        s_Data.TextureShader->SetIntArray("u_Textures", samplers, s_Data.MaxTextureSlots);
 
        s_Data.TextureSlots[0] = s_Data.WhiteTexture;
 
        s_Data.QuadVertexPositions[0] = { -0.5f, -0.5f, 0.0f, 1.0f };
        s_Data.QuadVertexPositions[1] = { 0.5f, -0.5f, 0.0f, 1.0f };
        s_Data.QuadVertexPositions[2] = { 0.5f,  0.5f, 0.0f, 1.0f };
        s_Data.QuadVertexPositions[3] = { -0.5f,  0.5f, 0.0f, 1.0f };
 
    }

References Vesper::Float, Vesper::Float2, Vesper::Float3, Vesper::Float4, Vesper::Renderer2DData::MaxIndices, Vesper::Renderer2DData::MaxTextureSlots, Vesper::Renderer2DData::MaxVertices, Vesper::Renderer2DData::QuadVertexBufferBase, and Vesper::s_Data.

Referenced by Vesper::Renderer::Init().

ResetStats()

void Vesper::Renderer2D::ResetStats ( )

static

Resets the rendering statistics.

    {
        memset(&s_Data.Stats, 0, sizeof(Statistics));
    }

References Vesper::s_Data, and Vesper::Renderer2DData::Stats.

Referenced by Vesper::EditorLayer::OnUpdate().

Shutdown()

void Vesper::Renderer2D::Shutdown ( )

static

Shuts down the 2D renderer.

    {
        VZ_PROFILE_FUNCTION();
 
        delete[] s_Data.QuadVertexBufferBase;
    }

References Vesper::Renderer2DData::QuadVertexBufferBase, and Vesper::s_Data.

StartBatch()

void Vesper::Renderer2D::StartBatch ( )

staticprivate

    {
 
        s_Data.QuadIndexCount = 0;
        s_Data.QuadVertexBufferPtr = s_Data.QuadVertexBufferBase;
 
        //s_Data.CircleIndexCount = 0;
        //s_Data.CircleVertexBufferPtr = s_Data.CircleVertexBufferBase;
 
        //s_Data.LineVertexCount = 0;
        //s_Data.LineVertexBufferPtr = s_Data.LineVertexBufferBase;
 
        //s_Data.TextIndexCount = 0;
        //s_Data.TextVertexBufferPtr = s_Data.TextVertexBufferBase;
 
        s_Data.TextureSlotIndex = 1;
 
    }

References Vesper::Renderer2DData::QuadIndexCount, Vesper::Renderer2DData::QuadVertexBufferBase, Vesper::Renderer2DData::QuadVertexBufferPtr, Vesper::s_Data, and Vesper::Renderer2DData::TextureSlotIndex.

Referenced by BeginScene().

---

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

• Vesper/src/Vesper/Renderer/Renderer2D.h
• Vesper/src/Vesper/Renderer/Renderer2D.cpp