// Add a pc.CameraComponent to an entity
var entity = new pc.Entity();
entity.addComponent('camera', {
    nearClip: 1,
    farClip: 100,
    fov: 55
});

// Get the pc.CameraComponent on an entity
var cameraComponent = entity.camera;

// Update a property on a camera component
entity.camera.nearClip = 2;

CameraComponent(system, entity) 

Create a new Camera Component.

// Add a pc.CameraComponent to an entity
var entity = new pc.Entity();
entity.addComponent('camera', {
    nearClip: 1,
    farClip: 100,
    fov: 55
});

// Get the pc.CameraComponent on an entity
var cameraComponent = entity.camera;

// Update a property on a camera component
entity.camera.nearClip = 2;

Parameters

system	pc.CameraComponentSystem	The ComponentSystem that created this Component.
entity	pc.Entity	The Entity that this Component is attached to.

numberaspectRatio 

The aspect ratio (width divided by height) of the camera. If aspectRatioMode is ASPECT_AUTO, then this value will be automatically calculated every frame, and you can only read it. If it's ASPECT_MANUAL, you can set the value.

numberaspectRatioMode 

The aspect ratio mode of the camera. Can be pc.ASPECT_AUTO (default) or pc.ASPECT_MANUAL. ASPECT_AUTO will always be current render target's width divided by height. ASPECT_MANUAL will use the aspectRatio value instead.

pc.callbacks.CalculateMatrixcalculateProjection 

Custom function you can provide to calculate the camera projection matrix manually. Can be used for complex effects like doing oblique projection. Function is called using component's scope. Arguments:

• {pc.Mat4} transformMatrix: output of the function
• {number} view: Type of view. Can be pc.VIEW_CENTER, pc.VIEW_LEFT or pc.VIEW_RIGHT. Left and right are only used in stereo rendering.

pc.callbacks.CalculateMatrixcalculateTransform 

Custom function you can provide to calculate the camera transformation matrix manually. Can be used for complex effects like reflections. Function is called using component's scope. Arguments:

• {pc.Mat4} transformMatrix: output of the function.
• {number} view: Type of view. Can be pc.VIEW_CENTER, pc.VIEW_LEFT or pc.VIEW_RIGHT. Left and right are only used in stereo rendering.

pc.ColorclearColor 

The color used to clear the canvas to before the camera starts to render.

booleanclearColorBuffer 

If true the camera will clear the color buffer to the color set in clearColor.

booleanclearDepthBuffer 

If true the camera will clear the depth buffer.

booleanclearStencilBuffer 

If true the camera will clear the stencil buffer.

booleancullFaces 

If true the camera will take material.cull into account. Otherwise both front and back faces will be rendered.

numberfarClip 

The distance from the camera after which no rendering will take place.

booleanflipFaces 

If true the camera will invert front and back faces. Can be useful for reflection rendering.

numberfov 

The field of view of the camera in degrees. Usually this is the Y-axis field of view, see pc.CameraComponent#horizontalFov. Used for pc.PROJECTION_PERSPECTIVE cameras only. Defaults to 45.

pc.Frustumfrustum 

Queries the camera's frustum shape.

[read only]

booleanfrustumCulling 

Controls the culling of mesh instances against the camera frustum, i.e. if objects outside of camera should be omitted from rendering. If true, culling is enabled. If false, all mesh instances in the scene are rendered by the camera, regardless of visibility. Defaults to false.

booleanhorizontalFov 

Set which axis to use for the Field of View calculation. Defaults to false (use Y-axis).

number[]layers 

An array of layer IDs (pc.Layer#id) to which this camera should belong. Don't push/pop/splice or modify this array, if you want to change it - set a new one instead.

numbernearClip 

The distance from the camera before which no rendering will take place.

pc.GraphNodenode 

Queries the camera's GraphNode. Can be used to get position and rotation.

[read only]

numberorthoHeight 

The half-height of the orthographic view window (in the Y-axis). Used for pc.PROJECTION_ORTHOGRAPHIC cameras only. Defaults to 10.

pc.PostEffectQueuepostEffects 

The post effects queue for this camera. Use this to add or remove post effects from the camera.

numberpriority 

Controls the order in which cameras are rendered. Cameras with smaller values for priority are rendered first.

numberprojection 

The type of projection used to render the camera. Can be:

• pc.PROJECTION_PERSPECTIVE: A perspective projection. The camera frustum resembles a truncated pyramid.
• pc.PROJECTION_ORTHOGRAPHIC: An orthographic projection. The camera frustum is a cuboid.

Defaults to pc.PROJECTION_PERSPECTIVE.

pc.Mat4projectionMatrix 

Queries the camera's projection matrix.

[read only]

pc.Vec4rect 

Controls where on the screen the camera will be rendered in normalized screen coordinates.

pc.Vec4scissorRect 

Clips all pixels which are not in the rectangle. The order of the values is [x, y, width, height].

pc.Mat4viewMatrix 

Queries the camera's view matrix.

[read only]

calculateAspectRatio([rt]) 

Calculates aspect ratio value for a given render target.

Parameters

rt

pc.RenderTarget

Optional render target. If unspecified, the backbuffer is assumed.

Returns

number

The aspect ratio of the render target (or backbuffer).

endXr([callback]) 

Attempt to end XR session of this camera

// On an entity with a camera component
this.entity.camera.endXr(function (err) {
    // not anymore in XR
});

Parameters

callback

pc.callbacks.XrError

Optional callback function called once session is ended. The callback has one argument Error - it is null if successfully ended XR session.

screenToWorld(screenx, screeny, cameraz, [worldCoord]) 

Convert a point from 2D screen space to 3D world space.

// Get the start and end points of a 3D ray fired from a screen click position
var start = entity.camera.screenToWorld(clickX, clickY, entity.camera.nearClip);
var end = entity.camera.screenToWorld(clickX, clickY, entity.camera.farClip);

// Use the ray coordinates to perform a raycast
app.systems.rigidbody.raycastFirst(start, end, function (result) {
    console.log("Entity " + result.entity.name + " was selected");
});

Parameters

screenx	number	X coordinate on PlayCanvas' canvas element.
screeny	number	Y coordinate on PlayCanvas' canvas element.
cameraz	number	The distance from the camera in world space to create the new point.
worldCoord	pc.Vec3	3D vector to receive world coordinate result.

Returns

pc.Vec3

The world space coordinate.

startXr(type, spaceType, [callback]) 

Attempt to start XR session with this camera

// On an entity with a camera component
this.entity.camera.startXr(pc.XRTYPE_VR, pc.XRSPACE_LOCAL, function (err) {
    if (err) {
        // failed to start XR session
    } else {
        // in XR
    }
});

Parameters

type	string	The type of session. Can be one of the following: pc.XRTYPE_INLINE: Inline - always available type of session. It has limited feature availability and is rendered into HTML element. pc.XRTYPE_VR: Immersive VR - session that provides exclusive access to the VR device with the best available tracking features. pc.XRTYPE_AR: Immersive AR - session that provides exclusive access to the VR/AR device that is intended to be blended with the real-world environment.
spaceType	string	reference space type. Can be one of the following: pc.XRSPACE_VIEWER: Viewer - always supported space with some basic tracking capabilities. pc.XRSPACE_LOCAL: Local - represents a tracking space with a native origin near the viewer at the time of creation. It is meant for seated or basic local XR sessions. pc.XRSPACE_LOCALFLOOR: Local Floor - represents a tracking space with a native origin at the floor in a safe position for the user to stand. The y axis equals 0 at floor level. Floor level value might be estimated by the underlying platform. It is meant for seated or basic local XR sessions. pc.XRSPACE_BOUNDEDFLOOR: Bounded Floor - represents a tracking space with its native origin at the floor, where the user is expected to move within a pre-established boundary. pc.XRSPACE_UNBOUNDED: Unbounded - represents a tracking space where the user is expected to move freely around their environment, potentially long distances from their starting point.
callback	pc.callbacks.XrError	Optional callback function called once the session is started. The callback has one argument Error - it is null if the XR session started successfully.

worldToScreen(worldCoord, [screenCoord]) 

Convert a point from 3D world space to 2D screen space.

Parameters

worldCoord	pc.Vec3	The world space coordinate.
screenCoord	pc.Vec3	3D vector to receive screen coordinate result.

Returns

pc.Vec3

The screen space coordinate.

pc.ComponentSystemsystem 

The ComponentSystem used to create this Component.

pc.Entityentity 

The Entity that this Component is attached to.

booleanenabled 

Enables or disables the component.

fire(name, [arg1], [arg2], [arg3], [arg4], [arg5], [arg6], [arg7], [arg8]) 

Fire an event, all additional arguments are passed on to the event listener.

obj.fire('test', 'This is the message');

Parameters

name	object	Name of event to fire.
arg1	*	First argument that is passed to the event handler.
arg2	*	Second argument that is passed to the event handler.
arg3	*	Third argument that is passed to the event handler.
arg4	*	Fourth argument that is passed to the event handler.
arg5	*	Fifth argument that is passed to the event handler.
arg6	*	Sixth argument that is passed to the event handler.
arg7	*	Seventh argument that is passed to the event handler.
arg8	*	Eighth argument that is passed to the event handler.

Returns

pc.EventHandler

Self for chaining.

hasEvent(name) 

Test if there are any handlers bound to an event name.

obj.on('test', function () { }); // bind an event to 'test'
obj.hasEvent('test'); // returns true
obj.hasEvent('hello'); // returns false

Parameters

name

string

The name of the event to test.

Returns

boolean

True if the object has handlers bound to the specified event name.

off([name], [callback], [scope]) 

Detach an event handler from an event. If callback is not provided then all callbacks are unbound from the event, if scope is not provided then all events with the callback will be unbound.

var handler = function () {
};
obj.on('test', handler);

obj.off(); // Removes all events
obj.off('test'); // Removes all events called 'test'
obj.off('test', handler); // Removes all handler functions, called 'test'
obj.off('test', handler, this); // Removes all hander functions, called 'test' with scope this

Parameters

name	string	Name of the event to unbind.
callback	pc.callbacks.HandleEvent	Function to be unbound.
scope	object	Scope that was used as the this when the event is fired.

Returns

pc.EventHandler

Self for chaining.

on(name, callback, [scope]) 

Attach an event handler to an event.

obj.on('test', function (a, b) {
    console.log(a + b);
});
obj.fire('test', 1, 2); // prints 3 to the console

Parameters

name	string	Name of the event to bind the callback to.
callback	pc.callbacks.HandleEvent	Function that is called when event is fired. Note the callback is limited to 8 arguments.
scope	object	Object to use as 'this' when the event is fired, defaults to current this.

Returns

pc.EventHandler

Self for chaining.

once(name, callback, [scope]) 

Attach an event handler to an event. This handler will be removed after being fired once.

obj.once('test', function (a, b) {
    console.log(a + b);
});
obj.fire('test', 1, 2); // prints 3 to the console
obj.fire('test', 1, 2); // not going to get handled

Parameters

name	string	Name of the event to bind the callback to.
callback	pc.callbacks.HandleEvent	Function that is called when event is fired. Note the callback is limited to 8 arguments.
scope	object	Object to use as 'this' when the event is fired, defaults to current this.

Returns

pc.EventHandler

Self for chaining.