Class CameraService

The Camera is used to determine /how much/ of a world to render, and /which part/. The Camera can have a minimum X and Y coordinate, and a maximum X and Y coordinate. It also has a zoom factor, and a current center point.

The zoom factor and center point give a rectangular region. The min and max coordinates give another rectangular region. If the first region is not fully within the second, we shift it so that it is within, and then we only show those things that are within it.

Note that the camera center can be changed dynamically, in response to changes in the world to which the camera is attached.

Constructors

constructor

Methods

addEntity adjustCamera getLeft getScale getTop inBounds metersToScreen render screenToMeters setBounds setCameraFocus setCenter setScale

Constructors

constructor

  • new CameraService(ratio): CameraService

  • Create a Camera by setting its bounds and its current pixel/meter ratio

    Parameters

    • ratio: number

      The initial pixel/meter ratio

    Returns CameraService

Methods

addEntity

  • addEntity(actor): void

  • Add an actor to the level, putting it into the appropriate z plane

    Parameters

    • actor: Actor

      The actor to add

    Returns void

adjustCamera

  • adjustCamera(): void

  • If the world's camera is supposed to follow an Actor, this code will figure out the point on which the camera should center, and will request that the camera center on that point.

    NB: The camera may decide not to center on that point, depending on zoom and camera bounds.

    Returns void

getLeft

  • getLeft(): number

  • Return the X coordinate of the left of the camera viewport

    Returns number

getScale

  • getScale(): number

  • Get the pixel/meter ratio of the camera. Increasing the ratio would equate to zooming in. Decreasing the ratio would equate to zooming out.

    Returns number

getTop

  • getTop(): number

  • Return the Y coordinate of the top of the camera viewport

    Returns number

inBounds

  • inBounds(x, y, r): boolean

  • Determine whether a sprite is within the region being shown by the camera, so that we can reduce the overhead on the renderer.

    Parameters

    • x: number

      The X coordinate of the top left corner of the sprite, in meters

    • y: number

      The Y coordinate of the top left corner of the sprite, in meters

    • r: number

      The radius of the circumscribing circle

    Returns boolean

metersToScreen

  • metersToScreen(worldX, worldY): {
        x: number;
        y: number;
    }

  • Convert meter coordinates to screen coordinates

    Parameters

    • worldX: number

      The X coordinate, in meters

    • worldY: number

      The Y coordinate, in meters

    Returns {
        x: number;
        y: number;
    }

    • x: number
    • y: number

render

  • render(elapsedMs, location): void

  • Render the actors associated with this camera

    Parameters

    Returns void

screenToMeters

  • screenToMeters(screenX, screenY): {
        x: number;
        y: number;
    }

  • Given screen coordinates, convert them to meter coordinates in the world

    Parameters

    • screenX: number

      The X coordinate, in pixels

    • screenY: number

      The Y coordinate, in pixels

    Returns {
        x: number;
        y: number;
    }

    • x: number
    • y: number

setBounds

  • setBounds(minX, minY, maxX, maxY): void

  • Update a camera's bounds by providing a new maximum (X, Y) coordinate

    Parameters

    • minX: undefined | number

      The new minimum X value (in meters)

    • minY: undefined | number

      The new minimum Y value (in meters)

    • maxX: undefined | number

      The new maximum X value (in meters)

    • maxY: undefined | number

      The new maximum Y value (in meters)

    Returns void

setCameraFocus

  • setCameraFocus(actor, x?, y?): void

  • Make the camera follow an Actor. Optionally add x,y to the actor's center, and center the camera on that point instead.

    Parameters

    • actor: undefined | Actor

      The actor to follow

    • x: number = 0

      Amount of x distance to add to actor center

    • y: number = 0

      Amount of y distance to add to actor center

    Returns void

setCenter

  • setCenter(centerX, centerY): void

  • Set the center point on which the camera should focus

    NB: this is called (indirectly) by the render loop in order to make sure we don't go out of bounds.

    Parameters

    • centerX: number

      The X coordinate of the center point (in meters)

    • centerY: number

      The Y coordinate of the center point (in meters)

    Returns void

setScale

  • setScale(ratio): void

  • Set the pixel/meter ratio of the camera. Bigger numbers mean zooming in, and smaller ones mean zooming out. The base value to consider is whatever you have set in your game's configuration.

    Parameters

    • ratio: number

      The new pixel/meter ratio

    Returns void

Settings

Member Visibility

Theme

On This Page