Muto::Scene Class Reference

Represents a scene in the application and manages entities and their components. More...

#include <Scene.h>

Public Member Functions
Entity	CreateEntity (const std::string &name, const std::string &uuid)
Entity	CreateEntity (const std::string &name=std::string())
void	DestroyEntity (Entity entity)
Entity	GetPrimaryCameraEntity ()
void	OnUpdateEditor (Timestep ts, EditorCamera &camera)
void	OnUpdateRuntime (Timestep ts)
void	OnViewportResize (uint32_t width, uint32_t height)
	Scene ()
	Scene (const std::string &name)
	~Scene ()

Private Member Functions
const std::string &	GetName () const
template<>
void	OnComponentAdded (Entity entity, CameraComponent &component)
template<>
void	OnComponentAdded (Entity entity, CameraComponent &component)
template<>
void	OnComponentAdded (Entity entity, NameComponent &component)
template<>
void	OnComponentAdded (Entity entity, NameComponent &component)
template<>
void	OnComponentAdded (Entity entity, NativeScriptComponent &component)
template<>
void	OnComponentAdded (Entity entity, NativeScriptComponent &component)
template<>
void	OnComponentAdded (Entity entity, ParticleSystemComponent &component)
template<>
void	OnComponentAdded (Entity entity, ParticleSystemComponent &component)
template<>
void	OnComponentAdded (Entity entity, SpriteRendererComponent &component)
template<>
void	OnComponentAdded (Entity entity, SpriteRendererComponent &component)
template<>
void	OnComponentAdded (Entity entity, SubTextureComponent &component)
template<>
void	OnComponentAdded (Entity entity, SubTextureComponent &component)
template<typename T >
void	OnComponentAdded (Entity entity, T &component)
template<>
void	OnComponentAdded (Entity entity, TextureAnimationComponent &component)
template<>
void	OnComponentAdded (Entity entity, TextureAnimationComponent &component)
template<>
void	OnComponentAdded (Entity entity, TransformComponent &component)
template<>
void	OnComponentAdded (Entity entity, TransformComponent &component)
template<>
void	OnComponentAdded (Entity entity, UUIDComponent &component)
template<>
void	OnComponentAdded (Entity entity, UUIDComponent &component)
void	SetName (const std::string &name)

Private Attributes
std::string	m_Name
entt::registry	m_Registry
uint32_t	m_ViewportHeight = 90
uint32_t	m_ViewportWidth = 160

Friends
class	Entity
class	SceneCamera
class	SceneHierarchyPanel
class	SceneSerializer

Detailed Description

Represents a scene in the application and manages entities and their components.

Todo:

Create a friend class SceneRenderer;

Constructor & Destructor Documentation

Scene() [1/2]

Muto::Scene::Scene

(

)

        : m_Name("Untitled Scene")
    {
        MU_PROFILE_FUNCTION();
 
    }

References m_Name.

Scene() [2/2]

Muto::Scene::Scene

(

const std::string &

name

)

        : m_Name(name)
    {
    }

References m_Name.

~Scene()

Muto::Scene::~Scene

(

)

    {
    }

Member Function Documentation

CreateEntity() [1/2]

Entity Muto::Scene::CreateEntity	(	const std::string &	name,
		const std::string &	uuid
	)

    {
        Entity entity = { m_Registry.create(), this };
        entity.AddComponent<TransformComponent>();
        auto& nameTag = entity.AddComponent<NameComponent>();
        nameTag.Name = name.empty() ? "Entity" + std::to_string(static_cast<std::uint32_t>(entity)) : name;
        entity.AddComponent<UUIDComponent>(uuid);
        return entity;
 
    }

CreateEntity() [2/2]

Entity Muto::Scene::CreateEntity

(

const std::string &

name = std::string()

)

    {
        Entity entity = { m_Registry.create(), this };
        entity.AddComponent<TransformComponent>();
        auto& nameTag = entity.AddComponent<NameComponent>();
        nameTag.Name = name.empty() ? "Entity" + std::to_string(static_cast<std::uint32_t>(entity)) : name;
        entity.AddComponent<UUIDComponent>();
 
        return entity;
    }

DestroyEntity()

void Muto::Scene::DestroyEntity

(

Entity

entity

)

    {
        m_Registry.destroy(entity);
    }

GetName()

const std::string & Muto::Scene::GetName ( ) const

inlineprivate

{ return m_Name; }

References m_Name.

GetPrimaryCameraEntity()

Entity Muto::Scene::GetPrimaryCameraEntity

(

)

    {
        auto view = m_Registry.view<CameraComponent>();
        for (auto entity : view) {
 
            const auto& camera = view.get<CameraComponent>(entity);
            if (camera.Primary)
                return Entity{ entity, this };
        }
        return {};
    }

OnComponentAdded() [1/19]

template<>

void Muto::Scene::OnComponentAdded ( Entity  entity, CameraComponent &  component  )

private

                                                                                           {
        component.Camera.SetViewportSize(m_ViewportWidth, m_ViewportHeight);
    }

OnComponentAdded() [2/19]

template<>

void Muto::Scene::OnComponentAdded ( Entity  entity, CameraComponent &  component  )

private

                                                                                           {
        component.Camera.SetViewportSize(m_ViewportWidth, m_ViewportHeight);
    }

References m_ViewportHeight, and m_ViewportWidth.

OnComponentAdded() [3/19]

template<>

void Muto::Scene::OnComponentAdded ( Entity  entity, NameComponent &  component  )

private

                                                                                       {
    }

OnComponentAdded() [4/19]

template<>

void Muto::Scene::OnComponentAdded ( Entity  entity, NameComponent &  component  )

private

                                                                                       {
    }

OnComponentAdded() [5/19]

template<>

void Muto::Scene::OnComponentAdded ( Entity  entity, NativeScriptComponent &  component  )

private

                                                                                                       {
    }

OnComponentAdded() [6/19]

template<>

void Muto::Scene::OnComponentAdded ( Entity  entity, NativeScriptComponent &  component  )

private

                                                                                                       {
    }

OnComponentAdded() [7/19]

template<>

void Muto::Scene::OnComponentAdded ( Entity  entity, ParticleSystemComponent &  component  )

private

                                                                                                           {
    }

OnComponentAdded() [8/19]

template<>

void Muto::Scene::OnComponentAdded ( Entity  entity, ParticleSystemComponent &  component  )

private

                                                                                                           {
    }

OnComponentAdded() [9/19]

template<>

void Muto::Scene::OnComponentAdded ( Entity  entity, SpriteRendererComponent &  component  )

private

                                                                                                           {
    }

OnComponentAdded() [10/19]

template<>

void Muto::Scene::OnComponentAdded ( Entity  entity, SpriteRendererComponent &  component  )

private

                                                                                                           {
    }

OnComponentAdded() [11/19]

template<>

void Muto::Scene::OnComponentAdded ( Entity  entity, SubTextureComponent &  component  )

private

                                                                                                   {
        auto& src = entity.GetOrAddComponent<SpriteRendererComponent>();
        if (!src.TextureEnabled) src.TextureEnabled = true;
        component.SetTexture(src.Texture ? src.Texture : Renderer2D::GetWhiteTexture());
    }

OnComponentAdded() [12/19]

template<>

void Muto::Scene::OnComponentAdded ( Entity  entity, SubTextureComponent &  component  )

private

                                                                                                   {
        auto& src = entity.GetOrAddComponent<SpriteRendererComponent>();
        if (!src.TextureEnabled) src.TextureEnabled = true;
        component.SetTexture(src.Texture ? src.Texture : Renderer2D::GetWhiteTexture());
    }

OnComponentAdded() [13/19]

template<typename T >

void Muto::Scene::OnComponentAdded ( Entity  entity, T &  component  )

private

                                                            {
        static_assert(false);
    }

OnComponentAdded() [14/19]

template<>

void Muto::Scene::OnComponentAdded ( Entity  entity, TextureAnimationComponent &  component  )

private

                                                                                                               {
        auto& src = entity.GetOrAddComponent<SpriteRendererComponent>();
        if (!src.TextureEnabled) src.TextureEnabled = true;
        auto& stc = entity.GetOrAddComponent<SubTextureComponent>();
        stc.SetTexture(src.Texture ? src.Texture : Renderer2D::GetWhiteTexture());
        component.SubTextures.clear();
        component.SubTextures.push_back(SubTexture2D::CreateFromCoords(stc.SubTexture->GetTexture(), {1, 1}, {1, 1}));
    }

OnComponentAdded() [15/19]

template<>

void Muto::Scene::OnComponentAdded ( Entity  entity, TextureAnimationComponent &  component  )

private

                                                                                                               {
        auto& src = entity.GetOrAddComponent<SpriteRendererComponent>();
        if (!src.TextureEnabled) src.TextureEnabled = true;
        auto& stc = entity.GetOrAddComponent<SubTextureComponent>();
        stc.SetTexture(src.Texture ? src.Texture : Renderer2D::GetWhiteTexture());
        component.SubTextures.clear();
        component.SubTextures.push_back(SubTexture2D::CreateFromCoords(stc.SubTexture->GetTexture(), {1, 1}, {1, 1}));
    }

OnComponentAdded() [16/19]

template<>

void Muto::Scene::OnComponentAdded ( Entity  entity, TransformComponent &  component  )

private

                                                                                                 {
    }

OnComponentAdded() [17/19]

template<>

void Muto::Scene::OnComponentAdded ( Entity  entity, TransformComponent &  component  )

private

                                                                                                 {
    }

OnComponentAdded() [18/19]

template<>

void Muto::Scene::OnComponentAdded ( Entity  entity, UUIDComponent &  component  )

private

                                                                                       {
        // TODO: search registry to ensure unique UUID
    }

OnComponentAdded() [19/19]

template<>

void Muto::Scene::OnComponentAdded ( Entity  entity, UUIDComponent &  component  )

private

                                                                                       {
        // TODO: search registry to ensure unique UUID
    }

OnUpdateEditor()

void Muto::Scene::OnUpdateEditor	(	Timestep	ts,
		EditorCamera &	camera
	)

    {
        MU_PROFILE_FUNCTION();
        Renderer2D::BeginScene(camera);
        auto view = m_Registry.group<SpriteRendererComponent>();
        for (auto entity : view)
        {
            auto& transform = m_Registry.get<TransformComponent>(entity);
            auto& sprite = m_Registry.get<SpriteRendererComponent>(entity);
            // Do not render subtextures here
            auto stc = m_Registry.try_get<SubTextureComponent>(entity);
            if (stc) {
                continue;
            }
            // Do not render texture animations here
            auto texAnim = m_Registry.try_get<TextureAnimationComponent>(entity);
            if (texAnim) {
                continue;
            }
 
            if (sprite.TextureEnabled && !sprite.Texture)
                Renderer2D::DrawQuad(transform.GetTransform(), MU_DEFAULT_TEXTURE, sprite.TilingFactor, sprite.Color);
            else if (sprite.TextureEnabled && sprite.Texture)
                Renderer2D::DrawQuad(transform.GetTransform(), sprite.Texture, sprite.TilingFactor, sprite.Color);
            else
                Renderer2D::DrawQuad(transform.GetTransform(), sprite.Color);
        }
 
        auto subTextureView = m_Registry.group<SubTextureComponent>();
        for (auto entity : subTextureView) {
            auto& transform = m_Registry.get<TransformComponent>(entity);
            auto& sprite = m_Registry.get<SpriteRendererComponent>(entity);
            auto& subTexture = m_Registry.get<SubTextureComponent>(entity);
 
            // Do not render texture animations here
            auto texAnim = m_Registry.try_get<TextureAnimationComponent>(entity);
            if (texAnim) {
                continue;
            }
 
            if (!sprite.TextureEnabled) sprite.TextureEnabled = true;
            if (subTexture.SubTexture == nullptr)
            {
                subTexture.SetTexture(MU_DEFAULT_TEXTURE);
            }
            else {
                // TODO: find way to avoid this check every frame
                // Ensure the subtexture's texture matches the sprite's texture
                if (sprite.Texture && subTexture.SubTexture->GetTexture() != sprite.Texture) {
                    subTexture.SetTexture(sprite.Texture);
                }
            }
            Renderer2D::DrawQuad(transform.GetTransform(), subTexture.GetSubTexture(), sprite.TilingFactor, sprite.Color);
        }
 
        auto TextureAnimationView = m_Registry.group<TextureAnimationComponent>();
        for (auto entity : TextureAnimationView)
        {
            auto& transform = m_Registry.get<TransformComponent>(entity);
            auto& texAnim = m_Registry.get<TextureAnimationComponent>(entity);
            auto& sprite = m_Registry.get<SpriteRendererComponent>(entity);
            if (texAnim.IsLooping) {
                texAnim.Update(ts.GetSeconds());
            }
            Renderer2D::DrawQuad(transform.GetTransform(), texAnim.SubTextures[texAnim.CurrentFrame], 1.0f, sprite.Color);
        }
 
        {
            MU_PROFILE_SCOPE("Particle System(s) Update");
 
            auto particleSystemView = m_Registry.group<ParticleSystemComponent>();
            for (auto entity : particleSystemView) {
                auto& transform = m_Registry.get<TransformComponent>(entity);
                auto& particleSystem = m_Registry.get<ParticleSystemComponent>(entity);
                auto& ps = particleSystem.System;
                auto& props = ps.m_Props;
                props.Position = transform.Translation;
                ps.OnUpdate(ts);
                if (ps.m_IsEmitting) {
                    for (int i = 0; i < ps.m_EmitRate; i++) {
                        ps.Emit(ps.m_Props);
                    }
                    ps.m_IsEmitting = false;
                }
 
                ps.OnRender();
            }
        }
 
        Renderer2D::EndScene();
    }

References Muto::Renderer2D::BeginScene(), and Muto::Renderer2D::EndScene().

OnUpdateRuntime()

void Muto::Scene::OnUpdateRuntime

(

Timestep

ts

)

TODO: Move to Scene::OnScenePlay()

TODO: Move to Scene::OnScenePlay()

    {
        MU_PROFILE_FUNCTION();
 
        // Update scripts
        {
            m_Registry.view<NativeScriptComponent>().each([=](auto entity, NativeScriptComponent& nsc)
                {
                    if (!nsc.Instance)
                    {
                        nsc.Instance = nsc.InstantiateScript();
                        nsc.Instance->m_Entity = Entity{ entity, this };
                        nsc.Instance->OnCreate();
                    }
                    nsc.Instance->OnUpdate(ts);
                });
        }
 
        Camera* mainCamera = nullptr;
        glm::mat4 camTransform;
        {
            auto view = m_Registry.view<TransformComponent, CameraComponent>();
            for (auto entity : view)
            {
                auto [transform, camera] = view.get<TransformComponent, CameraComponent>(entity);
                if (camera.Primary) {
                    mainCamera = &camera.Camera;
                    camTransform = transform.GetTransform();
                    break;
                }
            }
        }
        if (!mainCamera)
            return;
 
        Renderer2D::BeginScene(mainCamera->GetProjection(), camTransform);
 
 
        auto view = m_Registry.group<SpriteRendererComponent>();
        for (auto entity : view)
        {
            auto& transform = m_Registry.get<TransformComponent>(entity);
            auto& sprite = m_Registry.get<SpriteRendererComponent>(entity);
 
            // Do not render subtextures here
            auto stc = m_Registry.try_get<SubTextureComponent>(entity);
            if (stc) {
                continue;
            }
 
            // Do not render texture animations here
            auto texAnim = m_Registry.try_get<TextureAnimationComponent>(entity);
            if (texAnim) {
                continue;
            }
 
            if (sprite.TextureEnabled && !sprite.Texture)
                Renderer2D::DrawQuad(transform.GetTransform(), MU_DEFAULT_TEXTURE, sprite.TilingFactor, sprite.Color);
            else if (sprite.TextureEnabled && sprite.Texture)
                Renderer2D::DrawQuad(transform.GetTransform(), sprite.Texture, sprite.TilingFactor, sprite.Color);
            else
                Renderer2D::DrawQuad(transform.GetTransform(), sprite.Color);
        }
 
        auto subTextureView = m_Registry.group<SubTextureComponent>();
        for (auto entity : subTextureView) {
            auto& transform = m_Registry.get<TransformComponent>(entity);
            auto& sprite = m_Registry.get<SpriteRendererComponent>(entity);
            auto& subTexture = m_Registry.get<SubTextureComponent>(entity);
 
            // Do not render texture animations here
            auto texAnim = m_Registry.try_get<TextureAnimationComponent>(entity);
            if (texAnim) {
                continue;
            }
 
            if (!sprite.TextureEnabled) sprite.TextureEnabled = true;
            if (subTexture.SubTexture == nullptr)
            {
                subTexture.SetTexture(MU_DEFAULT_TEXTURE);
            }
            else {
                // Ensure the subtexture's texture matches the sprite's texture
                if (sprite.Texture && subTexture.SubTexture->GetTexture() != sprite.Texture) {
                    subTexture.SetTexture(sprite.Texture);
                }
            }
 
            Renderer2D::DrawQuad(transform.GetTransform(), subTexture.GetSubTexture(), sprite.TilingFactor, sprite.Color);
        }
 
        auto TextureAnimationView = m_Registry.group<TextureAnimationComponent>();
        for (auto entity : TextureAnimationView)
        {
            auto& transform = m_Registry.get<TransformComponent>(entity);
            auto& texAnim = m_Registry.get<TextureAnimationComponent>(entity);
            auto& sprite = m_Registry.get<SpriteRendererComponent>(entity);
            texAnim.Update(ts.GetSeconds());
            Renderer2D::DrawQuad(transform.GetTransform(), texAnim.SubTextures[texAnim.CurrentFrame], 1.0f, sprite.Color);
        }
 
 
        {
            MU_PROFILE_SCOPE("Particle System(s) Update");
 
            auto particleSystemView = m_Registry.group<ParticleSystemComponent>();
            for (auto entity : particleSystemView) {
                auto& transform = m_Registry.get<TransformComponent>(entity);
                auto& particleSystem = m_Registry.get<ParticleSystemComponent>(entity);
                auto& ps = particleSystem.System;
                auto& props = ps.m_Props;
                props.Position = transform.Translation;
                ps.OnUpdate(ts);
 
                if (ps.m_IsEmitting) {
                    for (int i = 0; i < ps.m_EmitRate; i++) {
                        ps.Emit(ps.m_Props);
                    }
                    ps.m_IsEmitting = false;
                }
 
                ps.OnRender();
            }
        }
 
        Renderer2D::EndScene();
 
    }

References Muto::Renderer2D::EndScene().

OnViewportResize()

void Muto::Scene::OnViewportResize	(	uint32_t	width,
		uint32_t	height
	)

    {
        m_ViewportWidth = width;
        m_ViewportHeight = height;
 
        // resize non fixed aspect ratio cameras
        auto view = m_Registry.view<CameraComponent>();
        for (auto entity : view)
        {
            auto& cameraComponent = view.get<CameraComponent>(entity);
            if (!cameraComponent.FixedAspectRatio)
                cameraComponent.Camera.SetViewportSize(width, height);
        }
    }

References m_ViewportHeight, and m_ViewportWidth.

SetName()

void Muto::Scene::SetName ( const std::string &  name )

inlineprivate

{ m_Name = name; }

References m_Name.

Friends And Related Symbol Documentation

Entity

friend class Entity

friend

SceneCamera

friend class SceneCamera

friend

SceneHierarchyPanel

friend class SceneHierarchyPanel

friend

SceneSerializer

friend class SceneSerializer

friend

Member Data Documentation

m_Name

std::string Muto::Scene::m_Name

private

Referenced by GetName(), Scene(), Scene(), and SetName().

m_Registry

entt::registry Muto::Scene::m_Registry

private

m_ViewportHeight

uint32_t Muto::Scene::m_ViewportHeight = 90

private

Referenced by OnComponentAdded(), and OnViewportResize().

m_ViewportWidth

uint32_t Muto::Scene::m_ViewportWidth = 160

private

Referenced by OnComponentAdded(), and OnViewportResize().

---

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

• Muto/src/Scene/Scene.h
• Muto/src/Scene/Scene.cpp