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	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	DrawQuad (const glm::mat4 &transform, const glm::vec4 &color)
	Draws a colored quad with the given transform and color.

static void	DrawQuad (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	DrawQuad (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	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::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	DrawQuad (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	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	DrawQuad (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	DrawQuad (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	DrawRotatedQuad (const glm::mat4 &transform, const glm::vec4 &color)
	Draws a rotated colored quad with the given transform and color.

static void	DrawRotatedQuad (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	DrawRotatedQuad (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	DrawRotatedQuad (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	DrawRotatedQuad (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	DrawRotatedQuad (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	DrawRotatedQuad (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 void	DrawRotatedQuad (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	DrawRotatedQuad (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	EndScene ()
	Ends the current scene.

static void	Flush ()
	Flushes the current batch of rendering commands.

static Statistics	GetStats ()
	Retrieves the current rendering statistics.

static Ref< Texture2D >	GetWhiteTexture ()
	Returns a reference to the default white texture that allows for coloring.

static void	Init ()
	Initializes the 2D renderer.

static void	ResetStats ()
	Resets the rendering statistics.

static void	Shutdown ()
	Shuts down the 2D renderer.

Static Private Member Functions
static void	FlushAndReset ()

static void	StartBatch ()

Detailed Description

A 2D renderer for drawing quads and sprites.

Todo:: Change draw func names to be overloaded DrawQuad and remove the "WithTexture" suffix, as the presence of a texture parameter should be sufficient to determine the type of quad being drawn. The current naming convention is a holdover from when the renderer had separate functions for textured and non-textured quads.

Member Function Documentation

◆ BeginScene() [1/3]

void Muto::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.

Note: Currently the intended use of this function is for rendering from a scene with an attached camera component, but it can be used for any camera and transform. The other BeginScene overloads are intended for editor use and the latter will likely be removed once we have a proper scene system in place.

    {
        MU_PROFILE_FUNCTION();
 
        glm::mat4 viewProj = camera.GetProjection() * glm::inverse(transform);
        s_Data.TextureShader->Bind();
        s_Data.TextureShader->SetMat4("u_ViewProjection", viewProj);
        StartBatch();
    }

References Muto::s_Data, and StartBatch().

◆ BeginScene() [2/3]

void Muto::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.

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

References Muto::s_Data, and StartBatch().

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

◆ BeginScene() [3/3]

void Muto::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

    {
        MU_PROFILE_FUNCTION();
        s_Data.TextureShader->Bind();
        s_Data.TextureShader->SetMat4("u_ViewProjection", camera.GetViewProjectionMatrix());
        StartBatch();
    }

References Muto::s_Data, and StartBatch().

◆ DrawQuad() [1/9]

void Muto::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.

    {
        MU_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(), Muto::Renderer2DData::MaxIndices, Muto::Renderer2D::Statistics::QuadCount, Muto::Renderer2DData::QuadIndexCount, Muto::Renderer2DData::QuadVertexBufferPtr, Muto::s_Data, Muto::Renderer2DData::Stats, Muto::QuadVertex::TexIndex, and Muto::QuadVertex::TilingFactor.

◆ DrawQuad() [2/9]

void Muto::Renderer2D::DrawQuad	(	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.

    {
        MU_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(), Muto::Renderer2DData::MaxIndices, Muto::Renderer2DData::MaxTextureSlots, Muto::Renderer2D::Statistics::QuadCount, Muto::Renderer2DData::QuadIndexCount, Muto::Renderer2DData::QuadVertexBufferPtr, Muto::s_Data, Muto::Renderer2DData::Stats, Muto::QuadVertex::TexIndex, Muto::Renderer2DData::TextureSlotIndex, and Muto::QuadVertex::TilingFactor.

◆ DrawQuad() [3/9]

void Muto::Renderer2D::DrawQuad	(	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.

    {
        MU_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(), Muto::Renderer2DData::MaxIndices, Muto::Renderer2DData::MaxTextureSlots, Muto::Renderer2D::Statistics::QuadCount, Muto::Renderer2DData::QuadIndexCount, Muto::Renderer2DData::QuadVertexBufferPtr, Muto::s_Data, Muto::Renderer2DData::Stats, Muto::QuadVertex::TexIndex, Muto::Renderer2DData::TextureSlotIndex, and Muto::QuadVertex::TilingFactor.

◆ DrawQuad() [4/9]

void Muto::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() [5/9]

void Muto::Renderer2D::DrawQuad	(	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.

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

◆ DrawQuad() [6/9]

void Muto::Renderer2D::DrawQuad	(	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.

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

◆ DrawQuad() [7/9]

void Muto::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);
 
    }

◆ DrawQuad() [8/9]

void Muto::Renderer2D::DrawQuad	(	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.

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

◆ DrawQuad() [9/9]

void Muto::Renderer2D::DrawQuad	(	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.

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

◆ DrawRotatedQuad() [1/9]

void Muto::Renderer2D::DrawRotatedQuad	(	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.

    {
        MU_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(), Muto::Renderer2DData::MaxIndices, Muto::Renderer2D::Statistics::QuadCount, Muto::Renderer2DData::QuadIndexCount, Muto::Renderer2DData::QuadVertexBufferPtr, Muto::s_Data, Muto::Renderer2DData::Stats, Muto::QuadVertex::TexIndex, and Muto::QuadVertex::TilingFactor.

◆ DrawRotatedQuad() [2/9]

void Muto::Renderer2D::DrawRotatedQuad	(	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.

    {
        MU_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(), Muto::Renderer2DData::MaxIndices, Muto::Renderer2DData::MaxTextureSlots, Muto::Renderer2D::Statistics::QuadCount, Muto::Renderer2DData::QuadIndexCount, Muto::Renderer2DData::QuadVertexBufferPtr, Muto::s_Data, Muto::Renderer2DData::Stats, Muto::QuadVertex::TexIndex, Muto::Renderer2DData::TextureSlotIndex, and Muto::QuadVertex::TilingFactor.

◆ DrawRotatedQuad() [3/9]

void Muto::Renderer2D::DrawRotatedQuad	(	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.

    {
        MU_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(), Muto::Renderer2DData::MaxIndices, Muto::Renderer2DData::MaxTextureSlots, Muto::Renderer2D::Statistics::QuadCount, Muto::Renderer2DData::QuadIndexCount, Muto::Renderer2DData::QuadVertexBufferPtr, Muto::s_Data, Muto::Renderer2DData::Stats, Muto::QuadVertex::TexIndex, Muto::Renderer2DData::TextureSlotIndex, and Muto::QuadVertex::TilingFactor.

◆ DrawRotatedQuad() [4/9]

void Muto::Renderer2D::DrawRotatedQuad	(	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.

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

◆ DrawRotatedQuad() [5/9]

void Muto::Renderer2D::DrawRotatedQuad	(	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.

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

◆ DrawRotatedQuad() [6/9]

void Muto::Renderer2D::DrawRotatedQuad	(	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.

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

◆ DrawRotatedQuad() [7/9]

void Muto::Renderer2D::DrawRotatedQuad	(	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.

    {
        MU_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 });
 
        DrawRotatedQuad(transform, subtexture, tilingFactor, tintColor);
    }

◆ DrawRotatedQuad() [8/9]

void Muto::Renderer2D::DrawRotatedQuad	(	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 });
 
        DrawRotatedQuad(transform, texture, tilingFactor, tintColor);
    }

◆ DrawRotatedQuad() [9/9]

void Muto::Renderer2D::DrawRotatedQuad	(	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 });
        DrawRotatedQuad(transform, color);
    }

◆ EndScene()

void Muto::Renderer2D::EndScene ( )

static

Ends the current scene.

    {
        MU_PROFILE_FUNCTION();
 
        if (s_Data.QuadIndexCount == 0)
            return; // Nothing to draw
 
        uint32_t dataSize = (uint32_t)((uint8_t*)s_Data.QuadVertexBufferPtr - (uint8_t*)s_Data.QuadVertexBufferBase);
 
        {
#ifdef MU_ENABLE_ASSERTS
            uint32_t expectedVertices = (s_Data.QuadIndexCount / 6) * 4;
            uint32_t expectedBytes = expectedVertices * sizeof(QuadVertex);
            MU_CORE_ASSERT(dataSize == expectedBytes, "Renderer2D: vertex buffer size does not match index count (possible ghosting source). dataSize = {0}, expected = {1}", dataSize, expectedBytes);
#endif
        }
 
        s_Data.QuadVertexBuffer->SetData(s_Data.QuadVertexBufferBase, dataSize);
        Flush();
    }

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

Referenced by FlushAndReset(), Sandbox2D::OnUpdate(), Muto::Scene::OnUpdateEditor(), and Muto::Scene::OnUpdateRuntime().

◆ Flush()

void Muto::Renderer2D::Flush ( )

static

Flushes the current batch of rendering commands.

Resets the batch for a new set of draw calls.

Todo:: Remove the OpenGL-specific code from here

Todo:: Remove the OpenGL-specific code from here

    {
        MU_PROFILE_FUNCTION();
 
        // DIsable depth testing
        GLboolean depthEnabled = glIsEnabled(GL_DEPTH_TEST);
        GLboolean depthMask = 1;
        glGetBooleanv(GL_DEPTH_WRITEMASK, &depthMask);
 
        if (depthEnabled)
            glDisable(GL_DEPTH_TEST);
        glDepthMask(GL_FALSE);
 
        // 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++;
 
        // Restore depth state
        glDepthMask(depthMask);
        if (depthEnabled)
            glEnable(GL_DEPTH_TEST);
    }

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

Referenced by EndScene().

◆ FlushAndReset()

void Muto::Renderer2D::FlushAndReset ( )

staticprivate

    {
        EndScene();
        StartBatch();
    }

References EndScene(), and StartBatch().

Referenced by DrawQuad(), DrawQuad(), DrawQuad(), DrawRotatedQuad(), DrawRotatedQuad(), and DrawRotatedQuad().

◆ GetStats()

Renderer2D::Statistics Muto::Renderer2D::GetStats ( )

static

Retrieves the current rendering statistics.

    {
        return s_Data.Stats;
    }

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

Referenced by Muto::EditorLayer::OnImGuiRender(), and Sandbox2D::OnImGuiRender().

◆ GetWhiteTexture()

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

static

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

    {
        return s_Data.WhiteTexture;
    }

References Muto::s_Data.

◆ Init()

void Muto::Renderer2D::Init ( )

static

Initializes the 2D renderer.

    {
        MU_PROFILE_FUNCTION();
 
        s_Data.QuadVertexArray = (VertexArray::Create());
 
 
        s_Data.QuadVertexBuffer = VertexBuffer::Create(s_Data.MaxVertices * sizeof(QuadVertex));
 
        s_Data.QuadVertexBuffer->SetLayout({
            { ShaderDataType::SDT_Float3, "a_Position"  },
            { ShaderDataType::SDT_Float4, "a_Color"     },
            { ShaderDataType::SDT_Float2, "a_TexCoord"   },
            { ShaderDataType::SDT_Float,  "a_TexIndex"   },
            { ShaderDataType::SDT_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;
 
 
        std::string shaderPath = Muto::Application::Get().ResolvePath(Muto::JoinPaths("shaders", "Texture.glsl"), Muto::PathResolveMode::AssetsDirectory);
        MU_CORE_INFO("Attempting to load shader from: {0}", shaderPath);
 
        s_Data.TextureShader = Shader::Create(shaderPath);
        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 Muto::AssetsDirectory, Muto::Application::Get(), Muto::JoinPaths(), Muto::Renderer2DData::MaxIndices, Muto::Renderer2DData::MaxTextureSlots, Muto::Renderer2DData::MaxVertices, Muto::Renderer2DData::QuadVertexBufferBase, Muto::Application::ResolvePath(), Muto::s_Data, Muto::SDT_Float, Muto::SDT_Float2, Muto::SDT_Float3, and Muto::SDT_Float4.

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

◆ ResetStats()

void Muto::Renderer2D::ResetStats ( )

static

Resets the rendering statistics.

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

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

Referenced by Sandbox2D::OnUpdate(), and Muto::EditorLayer::OnUpdate().

◆ Shutdown()

void Muto::Renderer2D::Shutdown ( )

static

Shuts down the 2D renderer.

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

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

◆ StartBatch()

void Muto::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 Muto::Renderer2DData::QuadIndexCount, Muto::Renderer2DData::QuadVertexBufferBase, Muto::Renderer2DData::QuadVertexBufferPtr, Muto::s_Data, and Muto::Renderer2DData::TextureSlotIndex.

Referenced by BeginScene(), BeginScene(), BeginScene(), and FlushAndReset().

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

Muto/src/Renderer/Renderer2D.h
Muto/src/Renderer/Renderer2D.cpp

Classes

Static Public Member Functions

Static Private Member Functions

Detailed Description

Member Function Documentation

◆ BeginScene() [1/3]

◆ BeginScene() [2/3]

◆ BeginScene() [3/3]

◆ DrawQuad() [1/9]

◆ DrawQuad() [2/9]

◆ DrawQuad() [3/9]

◆ DrawQuad() [4/9]

◆ DrawQuad() [5/9]

◆ DrawQuad() [6/9]

◆ DrawQuad() [7/9]

◆ DrawQuad() [8/9]

◆ DrawQuad() [9/9]

◆ DrawRotatedQuad() [1/9]

◆ DrawRotatedQuad() [2/9]

◆ DrawRotatedQuad() [3/9]

◆ DrawRotatedQuad() [4/9]

◆ DrawRotatedQuad() [5/9]

◆ DrawRotatedQuad() [6/9]

◆ DrawRotatedQuad() [7/9]

◆ DrawRotatedQuad() [8/9]

◆ DrawRotatedQuad() [9/9]

◆ EndScene()

◆ Flush()

◆ FlushAndReset()

◆ GetStats()

◆ GetWhiteTexture()

◆ Init()

◆ ResetStats()

◆ Shutdown()

◆ StartBatch()