Class Scene

Classdesc

Scene class, used for building scenes

Example

const scene = new Scene({
     lighting: true,
     physics: true,
     physicsOptions: {
     gravity: {
         x: 0,
         y: 0
     }
}
});

Example

const scene = new Scene({
     lighting: true,
     physics: true,
     physicsOptions: {
         gravity: {
             x: 0,
             y: 0
         }
     },
     lightOptions: {
         fog: 1.3,
         ambient: 0.2
     } 
});

Example

const scene = new Scene({
     layers: [background, middle, foreground]
});

Constructors

constructor

Properties

FPS_BUFFER_SIZE GPUSettings ambient backgroundColor bounds boundsActive cameraAngle cameraBind canvas clearScene collisionMonitors ctx diffuseKernel dlights drawMode fog formattedDLights formattedLights fpsBuffer fpsMonitoringEnabled gpu height id isActiveScene isClient lastFrameStamp layers lighting lights lightsPreFormatted objects readyToDraw update width

Methods

activateBounds addLight addObject bindCamera cameraTo check clear configureLightingKernel diffuseLights disableBounds disableFPS draw drawFromPassedObjects enableCollisionsBetween enableFPS formatDLights formatLights moveCamera plainDraw ready removeObject setBoundaries setDrawingCapabilities treatAsPlayer unbindCamera updateAll updateLights

Constructors

constructor

Properties

FPS_BUFFER_SIZE

FPS_BUFFER_SIZE: number

Size of the fps buffer

GPUSettings

GPUSettings: Object

GPU.js settings

ambient

ambient: number

Ambient of the scene

backgroundColor

backgroundColor: string

Background color of the scene

bounds

bounds: Vec2

Bounds of the scene

boundsActive

boundsActive: boolean

Whether or not the bounds are active

cameraAngle

cameraAngle: Vec2

Position of the camera

cameraBind

cameraBind: null | GameObject

Object to bind the camera to

canvas

canvas: HTMLCanvasElement

Canvas of the scene

clearScene

clearScene: boolean

Whether or not to clear the scene

collisionMonitors

collisionMonitors: CollisionMonitor[]

Collision monitors in the scene

ctx

ctx: CanvasRenderingContext2D

Canvas rendering context of the scene

diffuseKernel

diffuseKernel: any

GPU.js kernel for diffuse lighting

dlights

dlights: DirectionalLight[]

Directional lights in the scene

drawMode

drawMode: "full" | "plain"

Draw mode of the scene. "full" is defualt and used when objects need to be updated as well. "plain" just draws objects (eg: when the scene is handled on the server)

fog

fog: number

Fog of the scene

formattedDLights

formattedDLights: number[]

Formatted directional lights for the diffuse kernel

formattedLights

formattedLights: number[]

Formatted lights for the diffuse kernel

fpsBuffer

fpsBuffer: number[]

Buffer that holds the last FPS_BUFFER_SIZE frames rendering times (in ms)

fpsMonitoringEnabled

fpsMonitoringEnabled: boolean

Whether or not to monitor the fps

gpu

gpu: any

GPU.js instance

height

height: number

Height of the scene

id

id: string

Unique ID of the scene

isActiveScene

isActiveScene: boolean

Whether or not the scene is the active scene

isClient

isClient: boolean

Whether or not the scene is running on the client

lastFrameStamp

lastFrameStamp: number

Last frame stamp

layers

layers: Layer[]

Layers of the scene

lighting

lighting: boolean

Whether or not lighting is enabled

lights

lights: Light[]

Lights in the scene

lightsPreFormatted

lightsPreFormatted: boolean

Whether or not the lights are pre-formatted

objects

objects: GameObject[]

Objects in the scene

readyToDraw

readyToDraw: boolean

Whether or not the scene is ready to draw

update

update: Function

Update function of the scene (called every frame)

width

width: number

Width of the scene

Methods

activateBounds

  • activateBounds(): void

  • Enables the boundaries of the scene

    Returns void

addLight

  • addLight(light): void

  • Used to add lights to the scene

    Parameters

    Returns void

addObject

  • addObject(object, layerID?): void

  • Adds the specified GameObject to the scene

    Parameters

    • object: GameObject

      GameObject to add to the scene

    • Optional layerID: string

    Returns void

bindCamera

  • bindCamera(object): void

  • Binds the scene's camera to a GameObject

    Parameters

    • object: GameObject

      GameObject to bind the scene's camera to

    Returns void

cameraTo

  • cameraTo(object): void

  • Moves the camera to a GameObject

    Parameters

    • object: GameObject

      GameObject to move the camera to

    Returns void

check

  • check(): void

  • Checks to see if the scene is configured to draw, if not, it configures it (eg: initializes lighting kernel, etc.)

    Returns void

clear

  • clear(): void

  • Clears the canvas that the scene is being drawn on

    Returns void

configureLightingKernel

  • configureLightingKernel(): void

  • Configures the lighting kernel (if lighting is enabled and the scene is on the client side)

    Returns void

diffuseLights

  • diffuseLights(ambient?, fog?): void

  • Renders lights onto the scene. Automatically calculates if lights are in the camera view and removes them from the render if they are not.

    Parameters

    • ambient: number = 0.2

      The ambient lighting in the scene

    • fog: number = 1.3

      The fog constant in the scene

    Returns void

disableBounds

  • disableBounds(): void

  • Disables the boundaries of the scene

    Returns void

disableFPS

  • disableFPS(): void

  • Disables FPS monitoring

    Returns void

draw

  • draw(): void

  • Draws all of the objects, lights, and directional lights in the scene. Also updates each physics object and checks for collisions. It also recalculates the FPS if enabled.

    Returns void

drawFromPassedObjects

  • drawFromPassedObjects(objects): void

  • Reloads scene objects from the passed list, used for multiplayer when objects are handled on the server

    Parameters

    Returns void

enableCollisionsBetween

  • enableCollisionsBetween(o1, o2, fo, ff, options?): void

  • Enables collisions between the specified objects Adds a CollisionMonitor to the scene

    Parameters

    • o1: GameObject

      First object to check for collisions

    • o2: GameObject

      Second object to check for collisions

    • fo: Function

      Function that runs when the objects collide (called once)

    • ff: Function

      Function that runs when the objects separate (called once)

    • Optional options: CollisionMonitorOptions

      Options for the collision monitor

    Returns void

enableFPS

  • enableFPS(): void

  • Enables FPS monitoring

    Returns void

formatDLights

  • formatDLights(lights, cameraAngle?): number[]

  • Formats the directional lights into a format that the diffuseKernel can understand Updates the formattedDLights property

    Parameters

    Returns number[]

formatLights

  • formatLights(lights, cameraAngle?): number[]

  • Formats the lights into a format that the diffuseKernel can understand Updates the formattedLights array property

    Parameters

    • lights: Light[]

      List of lights in the scene

    • Optional cameraAngle: Vec2

    Returns number[]

moveCamera

  • moveCamera(vector): void

  • Moves the scene's camera

    Parameters

    • vector: Vec2

      Vector to move the scene's camera by

    Returns void

plainDraw

  • plainDraw(): void

  • Draws the scene without updating any of the objects

    Returns void

ready

  • ready(): void

  • Initializes the scene, specifically the light rendering kernel

    Returns void

removeObject

  • removeObject(object): void

  • Removes a GameObject from the scene

    Parameters

    • object: GameObject

      GameObject to remove from the scene

    Returns void

setBoundaries

  • setBoundaries(rightBound, bottomBound, activate?): void

  • Sets the boundaries of the scene (eg: where object can move)

    Parameters

    • rightBound: number

      How far right (in pixel) can objects in the scene move. If object are initialized outside the bounds, they will not be able to move, unless physics is enabled, in which case they will not be able to enter the scene.

    • bottomBound: number

      How far down (in pixel) can objects in the scene move. If object are initialized outside the bounds, they will not be able to move, unless physics is enabled, in which case they will not be able to enter the scene.

    • activate: boolean = true

      Boolean, if true, bounds will be active by defualt, if false, bounds will be inactive by default

    Returns void

setDrawingCapabilities

  • setDrawingCapabilities(canvas, ctx, width, height, drawMode?): void

  • Configures the scene to draw on the provided canvas

    Parameters

    • canvas: HTMLCanvasElement

      Canvas that the scene will draw on

    • ctx: CanvasRenderingContext2D

      The canvas rendering context of the scene

    • width: number

      The width of the scene

    • height: number

      The height of the scene

    • drawMode: string = "full"

    Returns void

treatAsPlayer

  • treatAsPlayer(object, movementSpeed?): void

  • Used to quickly set up an object as the player. Binds the camera to the object and sets up WASD movement (the object will move movementSpeed pixels every 10ms) (Only for sigle-player games)

    Parameters

    • object: GameObject

      GameObject to configure as player

    • movementSpeed: number = 2

      How quickly the player should move

    Returns void

unbindCamera

  • unbindCamera(): void

  • Unbinds the scene's camera from a GameObject

    Returns void

updateAll

  • updateAll(): void

  • Updates all of the objects, lights, physics, and collision monitors in the scene

    Returns void

updateLights

  • updateLights(): void

  • Updates all lights in the scene

    Returns void

Settings

Member Visibility

Theme

On This Page

Generated using TypeDoc