Optional initial property values. Omit to construct with defaults (near 0.1, far 1000, aspect 16/9, perspective) and set fields afterward, or use Camera.createPerspective / Camera.createOrthographic.
Stable identity for this component, unique within a session. Auto-generated for runtime-created components; the editor overwrites it with a persistent id when projecting a saved document so references survive save / load / undo.
Whether this component participates in simulation and rendering. When false,
the GameObject skips its update/updateRender and the scene's
render collectors (mesh renderers, camera, lights, …) ignore it — the
component stays attached and keeps its state, like Unity's Behaviour.enabled
/ Renderer.enabled. Defaults to true.
The owning GameObject; assigned by addComponent before onAttach runs.
True between onAttach and onDetach — i.e. while this component sits on a GameObject that is part of a live Scene. Managed by GameObject. Internal — do not set directly.
Projection type of the camera.
Vertical field of view in radians.
Orthographic size (height) for orthographic projection.
Near clip plane distance.
Far clip plane distance.
Width / height aspect ratio.
Clear flags for the camera.
Clear color for the camera.
Clear depth value for the camera.
Clear stencil value for the camera.
Viewport rectangle in normalized [0-1] coordinates.
The simulation clock of the scene this component belongs to. Read inside
update (or any time after the GameObject is added to a scene) for
absolute time, frame count, FPS, and timeScale-aware delta — e.g.
this.time.elapsed, this.time.delta, this.time.frameCount.
this.time.delta equals the dt argument passed to update, so
components can ignore that argument entirely and pull everything from here.
Connect to a Signal with automatic disconnect when this component is removed from its GameObject — the safe default for cross-object listening, so a destroyed component never leaks into (or gets called by) a signal it once observed. Typically called from onAttach:
onAttach(): void {
const health = this.gameObject.getComponent(Health)!;
this.listen(health.died, () => this.playDeathEffect());
}
The signal to connect to.
Listener, forwarded to Signal.connect.
Optionalopts: SignalConnectOptionsSee SignalConnectOptions.
The unsubscribe function, for listeners that also want to disconnect early; calling it is optional and idempotent.
Disconnect every signal connection made through listen. Called by GameObject.removeComponent after onDetach (so it runs even when a subclass overrides onDetach without calling super). Internal — do not call directly.
Called when the component joins a live scene — from addComponent when the
GameObject is already in a scene, otherwise when the GameObject is added to
one. this.gameObject.scene (and scene.engine) is always set here.
Override to acquire references to siblings/children or initialize resources.
Called when the component leaves the scene — removed via GameObject.removeComponent, or its GameObject removed from the scene. Override to release resources or unsubscribe from events.
Called every frame by the GameObject's update traversal.
Frame delta time in seconds.
Called when this component's GameObject begins touching another body, with the GameObject it collided with. Dispatched by the physics system after each world step (only while playing), so handlers may freely mutate the scene. Requires a physics body (RigidBody / CharacterBody) on the object.
The other GameObject involved in the contact.
StaticcreateStaticcreateRefreshes the cached view / projection / viewProj / invViewProj / position
from the current intrinsics and the owning GameObject's world transform,
and synchronizes aspect to the canvas size on ctx. Called once
per frame by the GameObject / Scene render traversal after simulation
and input have finalized the transform.
The viewMatrix / projectionMatrix / viewProjectionMatrix /
inverseViewProjectionMatrix / position getters return the
values cached here; they assume updateRender has run this frame.
Overrides the cached matrices with an externally-supplied view and
projection — used by the WebXR path, where the headset runtime, not this
component's GameObject transform, dictates each eye's pose and projection.
Called once per eye per frame (before features read the camera). Unlike
updateRender it does not touch the previous-frame VP snapshot
(temporal effects are disabled in XR), and it derives position from the
inverse view matrix so lighting / specular use the true eye origin.
Records a sub-pixel jittered view-projection for this frame. Typically called from TAAPass.update(); geometry-fill passes then read the result via jitteredViewProjectionMatrix.
NDC x offset (typically ±1/width).
NDC y offset (typically ±1/height).
Tells the camera that the world's floating origin shifted this frame by shift
(the world-space translation applied to all content, i.e. the camera's pre-shift
world position when the origin is re-anchored under the camera). The shift is folded
into the previous-frame VP on the next updateRender so temporal reprojection
(TAA, motion blur) doesn't read the origin jump as camera motion. Call it right after
re-anchoring, before the frame renders. No-op for renderers that never shift origin.
Cached projection matrix, populated by updateRender.
Falls back to fresh computation when called before any updateRender
(e.g. from unit tests with no render context). Render-pass-heavy callers
should always call updateRender first to avoid the cold-path work.
Cached world-to-view matrix (see projectionMatrix re: cold path).
Cached projection × view matrix (see projectionMatrix re: cold path).
Cached inverse of viewProjectionMatrix (see projectionMatrix re: cold path).
Cached inverse projection matrix (camera-space ↔ NDC).
Returns the TAA-jittered viewProj if applyJitter ran this frame, otherwise falls back to the un-jittered viewProjectionMatrix. Geometry-fill passes use this for vertex transforms so TAA has sub-pixel motion to converge.
Previous frame's un-jittered view-projection, as snapshotted by the most recent updateRender. Used by TAA / SSGI to reproject the prior frame into the current one. Falls back to viewProjectionMatrix on the very first frame so reprojection sees no apparent motion (no ghosting).
Cached world-space camera origin (see projectionMatrix re: cold path).
Returns the 8 corners of the view frustum in world space.
Computed fresh each call (does not read the cached viewProj) because cascade
fitting temporarily mutates near/far and expects the result to reflect
those mutations, not the per-frame cached values.
Camera component. Drives view/projection matrices used by every render pass that needs the main view (geometry, shadows, post).
The camera's world transform comes from its owning GameObject; this component only stores intrinsics (FOV, near/far, aspect) and exposes derived matrices.