mitiru::scene

Scene graph: nodes, transforms, hierarchies, and traversal helpers.

Name	Kind	Items
ComponentPersistenceEntry	struct	4
EntityPersistence	class	6
LightType	enum	5
MeshComponent	struct	1
AudioSourceComponent	struct	1
ComponentStore	class	6
GameWorld	class	10
IScene	class	6
MitiruScene	class	9
MitiruSceneManager	class	10
TraversalOrder	enum	2
NodeId	struct	7
SceneNode	struct	4
SceneGraph	class	10
SceneRouter	class	14
SceneData	struct	6
ComponentSerializerEntry	struct	3
SceneSerializer2	class	7
TransitionType	enum	6
TransitionPhase	enum	6
TransitionConfig	struct	3
SceneTransitionManager	class	17
ISystem	class	3
SystemProfile	struct	1
SystemRunner	class	7
TransitionKind	enum	5
SlideDirection	enum	4
TransitionFrame	struct	7
Transition	class	15

struct ComponentPersistenceEntry 4

std::string typeName

std::function<std::string(const sgc::ecs::World&, sgc::ecs::Entity)> serialize

std::function<void(sgc::ecs::World&, sgc::ecs::Entity, const std::string&)> deserialize

std::function<bool(const sgc::ecs::World&, sgc::ecs::Entity)> hasComponent

class EntityPersistence 6

template <typename T> void registerComponent( const std::string& typeName, std::function<std::string(const T&)> serialize, std::function<T(const std::string&)> deserialize)

template <typename T> [[nodiscard]] bool isRegistered() const

[[nodiscard]] std::size_t registeredCount() const noexcept

[[nodiscard]] std::vector<std::string> registeredTypeNames() const

[[nodiscard]] std::string saveWorld(const ecs::MitiruWorld& world) const

void loadWorld(ecs::MitiruWorld& world, const std::string& json) const

enum LightType 5

Directional

Point

Spot

using EntityId = uint32_t;

inline constexpr EntityId INVALID_ENTITY = 0

struct MeshComponent 1

std::string meshId

struct AudioSourceComponent 1

std::string soundId

class ComponentStore 6

template <typename T> void add(EntityId entityId, T component)

template <typename T> [[nodiscard]] T* get(EntityId entityId) noexcept

template <typename T> [[nodiscard]] const T* get(EntityId entityId) const noexcept

template <typename T> [[nodiscard]] bool has(EntityId entityId) const noexcept

void removeAll(EntityId entityId)

template <typename T> void forEach(const std::function<void(EntityId, T&)>& callback)

class GameWorld 10

[[nodiscard]] EntityId createEntity(const std::string& name = "")

void removeEntity(EntityId entityId)

[[nodiscard]] bool isValid(EntityId entityId) const noexcept

[[nodiscard]] size_t entityCount() const noexcept

[[nodiscard]] std::string entityName(EntityId entityId) const

template <typename T> void addComponent(EntityId entityId, T component)

template <typename T> [[nodiscard]] T* getComponent(EntityId entityId) noexcept

template <typename T> [[nodiscard]] const T* getComponent(EntityId entityId) const noexcept

template <typename T> [[nodiscard]] bool hasComponent(EntityId entityId) const noexcept

template <typename T> void forEach(const std::function<void(EntityId, T&)>& callback)

class IScene 6

virtual ~IScene() = default

virtual void onEnter()

virtual void onUpdate(float dt) = 0

virtual void onExit()

virtual void onPause()

virtual void onResume()

class MitiruScene 9

virtual ~MitiruScene() = default

virtual void onEnter()

virtual void onExit()

virtual void onUpdate(float dt) = 0

virtual void onDraw(Screen& screen) = 0

[[nodiscard]] virtual std::string name() const = 0

void addLabel(const std::string& label)

[[nodiscard]] bool hasLabel(const std::string& label) const

[[nodiscard]] const std::vector<std::string>& labels() const noexcept

class MitiruSceneManager 10

void pushScene(std::unique_ptr<MitiruScene> scene)

void popScene()

void replaceScene(std::unique_ptr<MitiruScene> scene)

void clear()

[[nodiscard]] MitiruScene* currentScene() noexcept

[[nodiscard]] const MitiruScene* currentScene() const noexcept

[[nodiscard]] std::vector<MitiruScene*> sceneStack() const

[[nodiscard]] std::size_t depth() const noexcept

[[nodiscard]] bool empty() const noexcept

[[nodiscard]] std::string toJson() const

enum TraversalOrder 2

DepthFirst

BreadthFirst

struct NodeId 7

[[nodiscard]] uint16_t index() const noexcept

[[nodiscard]] uint16_t generation() const noexcept

[[nodiscard]] bool isValid() const noexcept

bool operator==(const NodeId& other) const noexcept

bool operator!=(const NodeId& other) const noexcept

[[nodiscard]] static NodeId make(uint16_t idx, uint16_t gen) noexcept

[[nodiscard]] static NodeId invalid() noexcept

struct SceneNode 4

std::string name

std::vector<NodeId> children

sgc::Mat4f localTransform = sgc::Mat4f::identity()

NodeId parent = NodeId::invalid()

class SceneGraph 10

[[nodiscard]] NodeId createNode(const std::string& name = "")

void destroyNode(NodeId id)

[[nodiscard]] bool isValid(NodeId id) const noexcept

[[nodiscard]] size_t nodeCount() const noexcept

[[nodiscard]] SceneNode* getNode(NodeId id) noexcept

[[nodiscard]] const SceneNode* getNode(NodeId id) const noexcept

void reparent(NodeId child, NodeId newParent)

[[nodiscard]] sgc::Mat4f getWorldTransform(NodeId id) const

[[nodiscard]] std::optional<NodeId> findByName(const std::string& name) const

void traverse(NodeId root, TraversalOrder order, const std::function<void(const SceneNode&)>& visitor) const

class SceneRouter 14

SceneRouter() = default

SceneRouter(const SceneRouter&) = delete

SceneRouter& operator=(const SceneRouter&) = delete

SceneRouter(SceneRouter&&) = default

SceneRouter& operator=(SceneRouter&&) = default

~SceneRouter() = default

void push(std::unique_ptr<IScene> scene)

void pop()

void replace(std::unique_ptr<IScene> scene)

void update(float dt)

[[nodiscard]] IScene* current() const noexcept

[[nodiscard]] std::size_t depth() const noexcept

[[nodiscard]] bool empty() const noexcept

class [[deprecated("Use SceneSerializer2 for new code — supports component registration and SceneGraph")]] SceneSerializer

struct SceneData 6

std::string sceneName

std::string entitiesJson

std::string metadata

[[nodiscard]] std::string toJson() const

using SerializeFn = std::function<std::optional<std::string>(const GameWorld&, EntityId)>;

using DeserializeFn = std::function<bool(const std::string&, GameWorld&, EntityId)>;

struct ComponentSerializerEntry 3

std::string name

SerializeFn serialize

DeserializeFn deserialize

class SceneSerializer2 7

void registerComponentSerializer( const std::string& name, SerializeFn serializeFn, DeserializeFn deserializeFn)

void registerBuiltins()

[[nodiscard]] std::string serializeWorld(const GameWorld& world) const

bool deserializeWorld(const std::string& json, GameWorld& world) const

[[nodiscard]] std::string serializeEntity(const GameWorld& world, EntityId entityId) const

[[nodiscard]] std::string serializeSceneGraph(const SceneGraph& graph) const

bool deserializeSceneGraph(const std::string& json, SceneGraph& graph) const

enum TransitionType : uint8_t 6

None = 0

Fade

Slide

Zoom

Dissolve

Custom

enum TransitionPhase : uint8_t 6

Idle = 0

FadeOut

Load

FadeIn

using TransitionEasing = std::function<float(float t)>;

using LoadingProgressCallback = std::function<void(float progress)>;

struct TransitionConfig 3

TransitionType type = TransitionType::Fade

float duration = 0.5f

std::string customName

class SceneTransitionManager 17

SceneTransitionManager() = default

void transitionTo( std::unique_ptr<MitiruScene> scene, TransitionType type = TransitionType::Fade, float duration = 0.5f)

void transitionTo( const std::string& sceneName, TransitionType type = TransitionType::Fade, float duration = 0.5f)

void pushWithTransition( std::unique_ptr<MitiruScene> scene, TransitionType type = TransitionType::Fade, float duration = 0.5f)

void popWithTransition( TransitionType type = TransitionType::Fade, float duration = 0.5f)

void update(float dt)

[[nodiscard]] float getRenderAlpha() const noexcept

[[nodiscard]] bool isTransitioning() const noexcept

[[nodiscard]] TransitionPhase phase() const noexcept

void pushScene(std::unique_ptr<MitiruScene> scene)

[[nodiscard]] MitiruScene* currentScene() noexcept

[[nodiscard]] const MitiruScene* currentScene() const noexcept

[[nodiscard]] std::size_t depth() const noexcept

void registerTransition(const std::string& name, TransitionEasing easing)

void transitionToCustom( std::unique_ptr<MitiruScene> scene, const std::string& customName, float duration = 0.5f)

void registerScene(const std::string& name, std::function<std::unique_ptr<MitiruScene>()> factory)

void setLoadingCallback(LoadingProgressCallback callback)

class ISystem 3

virtual ~ISystem() = default

[[nodiscard]] virtual std::string name() const = 0

virtual void update(GameWorld& world, float dt) = 0

struct SystemProfile 1

std::string name

class SystemRunner 7

void addSystem(std::unique_ptr<ISystem> system, int32_t priority = 0)

bool removeSystem(const std::string& name)

void updateAll(GameWorld& world, float dt)

bool setEnabled(const std::string& name, bool enabled)

[[nodiscard]] bool isEnabled(const std::string& name) const noexcept

[[nodiscard]] std::vector<SystemProfile> profiles() const

[[nodiscard]] size_t systemCount() const noexcept

enum TransitionKind 5

Fade

Dissolve

Slide

Zoom

Custom

enum SlideDirection 4

Left

Right

Up

Down

struct TransitionFrame 7

TransitionKind kind = TransitionKind::Fade

float progress = 0.0f

SlideDirection slideDir = SlideDirection::Left

float customResult = 0.0f

[[nodiscard]] float alpha() const noexcept

[[nodiscard]] float slideOffset() const noexcept

[[nodiscard]] float zoomScale() const noexcept

class Transition 15

using EasingFn = std::function<float(float t)>;

using DrawFn = std::function<void(const TransitionFrame&)>;

Transition() = default

void setDrawCallback(DrawFn fn)

void setCustomEasing(EasingFn fn)

void setSlideDirection(SlideDirection dir) noexcept

void start(TransitionKind kind, float durationSec, sgc::Colorf color = sgc::Colorf{0, 0, 0, 1})

void update(float dt)

void draw() const

[[nodiscard]] bool isDone() const noexcept

[[nodiscard]] float progress() const noexcept

[[nodiscard]] float alpha() const noexcept

[[nodiscard]] TransitionKind kind() const noexcept

[[nodiscard]] sgc::Colorf color() const noexcept

[[nodiscard]] TransitionFrame buildFrame() const

---

Sourced from docs/API_CATALOG.md, auto-generated by tools/generate_api_catalog.py.