Components

ECS components used by the engine's built-in systems.

Transform

Header: Core/include/Core/Components.h

struct Transform {
  glm::vec3 position{0.0f};
  glm::vec3 rotation{0.0f};  // Euler angles in degrees
  glm::vec3 scale{1.0f};
};

Controls an entity's position, rotation, and scale in world space. Rotation is applied around the model's bounding box center (not the origin), so models rotate visually in place.

Field	Type	Default	Description
`position`	`glm::vec3`	`{0.0f}`	World position
`rotation`	`glm::vec3`	`{0.0f}`	Rotation in degrees (applied as X, Y, Z)
`scale`	`glm::vec3`	`{1.0f}`	Scale factor per axis

ModelRenderer

Header: Core/include/Core/Components.h

struct ModelRenderer {
  std::shared_ptr<Model> model;
  std::string modelPath;
};

Attaches a loaded Model to an entity. The engine's RenderSystem queries all entities with both Transform and ModelRenderer, computes a model matrix, and draws the model.

Field	Type	Description
`model`	`std::shared_ptr<Model>`	Pointer to a loaded Model instance
`modelPath`	`std::string`	Path used to load the model (used for serialization)

For procedural primitives, modelPath uses the primitive:<type> convention (e.g. "primitive:box", "primitive:sphere").

Camera

Header: Core/include/Core/Components.h

enum class ProjectionType { Perspective, Orthographic };

struct Camera {
  float fov = 45.0f;
  float nearPlane = 0.1f;
  float farPlane = 1000.0f;
  ProjectionType projectionType = ProjectionType::Perspective;
  float orthoSize = 10.0f;
  bool isMain = false;
};

Defines a camera viewpoint. During play mode, the entity with isMain == true drives the rendering view.

Field	Type	Default	Description
`fov`	`float`	`45.0`	Field of view in degrees
`nearPlane`	`float`	`0.1`	Near clipping distance
`farPlane`	`float`	`1000.0`	Far clipping distance
`projectionType`	`ProjectionType`	`Perspective`	Projection mode
`orthoSize`	`float`	`10.0`	Orthographic view height
`isMain`	`bool`	`false`	Active camera during play mode

Animator

Header: Core/include/Core/Components.h

struct Animator {
  int clipIndex = 0;
  float time = 0.0f;
  float speed = 1.0f;
  bool playing = true;
  bool loop = true;
  std::vector<glm::mat4> boneMatrices;
};

Controls skeletal animation playback for entities with a skinned Model.

Field	Type	Default	Description
`clipIndex`	`int`	`0`	Index into the model's animation clips
`time`	`float`	`0.0`	Current playback time in seconds
`speed`	`float`	`1.0`	Playback speed multiplier
`playing`	`bool`	`true`	Whether the animation is playing
`loop`	`bool`	`true`	Whether to loop at the end of the clip
`boneMatrices`	`std::vector<glm::mat4>`	empty	Output bone matrices (set by the system)

NativeScript

Header: Core/include/Core/Behavior.h

struct NativeScript {
  std::string behaviorName;
  std::unordered_map<std::string, std::string> properties;
  std::shared_ptr<Behavior> instance;  // runtime-only
  bool started = false;                // runtime-only
};

Attaches a behavior to an entity. The behaviorName is used to look up the factory in BehaviorRegistry. The properties map stores configurable parameters editable in the Inspector.

Field	Type	Serialized	Description
`behaviorName`	`std::string`	Yes	Name of the registered behavior
`properties`	`map<string, string>`	Yes	User-configurable key-value pairs
`instance`	`shared_ptr<Behavior>`	No	Runtime behavior instance
`started`	`bool`	No	Whether OnStart has been called

RigidBody

Header: Core/include/Core/PhysicsComponents.h

struct RigidBody {
  enum Type { Static = 0, Dynamic = 1, Kinematic = 2 };
  Type type = Dynamic;
  float mass = 1.0f;
  float linearDamping = 0.05f;
  float angularDamping = 0.05f;
  float restitution = 0.3f;
  float friction = 0.5f;
  float gravityFactor = 1.0f;
  bool freezePositionX = false, freezePositionY = false, freezePositionZ = false;
  bool freezeRotationX = false, freezeRotationY = false, freezeRotationZ = false;
};

Field	Type	Default	Description
`type`	`Type`	Dynamic	Static, Dynamic, or Kinematic
`mass`	`float`	`1.0`	Mass in kg
`linearDamping`	`float`	`0.05`	Linear velocity damping
`angularDamping`	`float`	`0.05`	Angular velocity damping
`restitution`	`float`	`0.3`	Bounciness (0-1)
`friction`	`float`	`0.5`	Surface friction
`gravityFactor`	`float`	`1.0`	Gravity multiplier (0 = no gravity)
`freezePosition*`	`bool`	`false`	Lock position on specific axes
`freezeRotation*`	`bool`	`false`	Lock rotation on specific axes

Collider

Header: Core/include/Core/PhysicsComponents.h

enum class ColliderShape { Box = 0, Sphere = 1, Capsule = 2 };

struct Collider {
  ColliderShape shape = ColliderShape::Box;
  float halfExtentX = 0.5f, halfExtentY = 0.5f, halfExtentZ = 0.5f;
  float radius = 0.5f;
  float halfHeight = 0.5f;
  float offsetX = 0.0f, offsetY = 0.0f, offsetZ = 0.0f;
  bool showOutline = false;
};

Field	Type	Default	Description
`shape`	`ColliderShape`	`Box`	Box, Sphere, or Capsule
`halfExtent*`	`float`	`0.5`	Half-size per axis (Box only)
`radius`	`float`	`0.5`	Radius (Sphere/Capsule)
`halfHeight`	`float`	`0.5`	Half height (Capsule only)
`offset*`	`float`	`0.0`	Offset from entity center
`showOutline`	`bool`	`false`	Debug wireframe visualization

PointLight

Header: Core/include/Core/Components.h

struct PointLight {
  float r = 1.0f, g = 1.0f, b = 1.0f;
  float intensity = 1.0f;
  float constant = 1.0f, linear = 0.09f, quadratic = 0.032f;
};

A point light source with distance attenuation. Up to 8 point lights are supported.

DirectionalLight

Header: Core/include/Core/Components.h

struct DirectionalLight {
  float r = 1.0f, g = 1.0f, b = 1.0f;
  float intensity = 1.0f;
};

A directional light (like sunlight). Direction is derived from the entity's Transform rotation. Up to 4 directional lights are supported.

SpotLight

Header: Core/include/Core/Components.h

struct SpotLight {
  float r = 1.0f, g = 1.0f, b = 1.0f;
  float intensity = 1.0f;
  float innerCutoff = 12.5f;
  float outerCutoff = 17.5f;
};

A spot light with inner and outer cone angles in degrees. Up to 4 spot lights are supported.

ParticleEmitter

Header: Core/include/Core/ParticleSystem.h

struct ParticleEmitter {
  float emitRate = 10.0f;
  float lifetime = 2.0f;
  float speed = 3.0f;
  float speedVariance = 1.0f;
  float size = 0.1f;
  float sizeEnd = 0.0f;
  glm::vec3 colorStart{1, 1, 1};
  glm::vec3 colorEnd{1, 1, 1};
  float gravity = -9.81f;
  int maxParticles = 256;
  bool enabled = true;
};

Field	Type	Default	Description
`emitRate`	`float`	`10.0`	Particles emitted per second
`lifetime`	`float`	`2.0`	Particle lifetime in seconds
`speed`	`float`	`3.0`	Initial speed
`speedVariance`	`float`	`1.0`	Speed randomization
`size`	`float`	`0.1`	Start size
`sizeEnd`	`float`	`0.0`	End size (lerps over lifetime)
`colorStart`	`glm::vec3`	`{1, 1, 1}`	Start color (RGB 0-1)
`colorEnd`	`glm::vec3`	`{1, 1, 1}`	End color (RGB 0-1)
`gravity`	`float`	`-9.81`	Gravity acceleration
`maxParticles`	`int`	`256`	Maximum particle pool size
`enabled`	`bool`	`true`	Whether emitter is active

AudioSource

Header: Core/include/Core/AudioComponents.h

struct AudioSource {
  std::string clipPath;
  float volume = 1.0f;
  float pitch = 1.0f;
  bool loop = false;
  bool spatial = true;
  bool playOnAwake = false;
};

Field	Type	Default	Description
`clipPath`	`std::string`	`""`	Path to audio file
`volume`	`float`	`1.0`	Volume (0-1)
`pitch`	`float`	`1.0`	Pitch modifier
`loop`	`bool`	`false`	Loop playback
`spatial`	`bool`	`true`	3D spatial audio
`playOnAwake`	`bool`	`false`	Auto-play on start

AudioListener

Header: Core/include/Core/AudioComponents.h

struct AudioListener {};

Tag component -- attach to the entity that should "hear" 3D audio (typically the main camera).

#Components

#Transform

#ModelRenderer

#Camera

#Animator

#NativeScript

#RigidBody

#Collider

#PointLight

#DirectionalLight

#SpotLight

#ParticleEmitter

#AudioSource

#AudioListener

Components

Transform

ModelRenderer

Camera

Animator

NativeScript

RigidBody

Collider

PointLight

DirectionalLight

SpotLight

ParticleEmitter

AudioSource

AudioListener