Class ThreeDDice

constructor

• new ThreeDDice(canvas?, apiKey?, config?): ThreeDDice

• Construct and initialize the object

  Parameters

  • Optional canvas: HTMLCanvasElement

    Canvas element

  • Optional apiKey: string

    Required if connecting to the dddice API

  • Optional config: Partial<IEngineConfig>

    Optional configuration to change the look and feel of the renderer

  Returns ThreeDDice

Static DefaultConfig

Optional api

Optional apiKey

Optional canvas

controlsEnabled

• get controlsEnabled(): boolean

• Get mouse/pointer controls enabled

  Returns boolean
• set controlsEnabled(enabled): void

• Set mouse/pointer controls enabled

  Parameters

  • enabled: boolean

  Returns void

height

• get height(): number

• Canvas Height

  Returns number

isDiceThrowing

• get isDiceThrowing(): boolean

• Get if a roll is currently animating

  Returns boolean

diceCount

• get diceCount(): number

• Get the number of dice currently being rendered

  Returns number

version

• get version(): string

• Get the current version of dddice

  Returns string

width

• get width(): number

• Canvas width

  Returns number

Static isWebGLAvailable

• isWebGLAvailable(): boolean

• Check if WebGL is available

  Returns boolean

addCallback

• addCallback(eventName, callback): void

• Add document/canvas event callback

  Parameters

  • eventName: string

  • callback: ((...params) => void)

    • • (...params): void

      • Parameters

        • Rest ...params: any[]

        Returns void

  Returns void

clear

• clear(): void

• Clear all dice from canvas

  Returns void

connect

• connect(roomSlug, roomPasscode?, userUuid?): ThreeDDice

• Connect to the live server and begin listening to room events.

  Note: Your user must be a participant in a room in order to listen to events, otherwise an error is thrown.

  Parameters

  • roomSlug: string

    Room slug to listen on

  • Optional roomPasscode: string

    Private passcode to access room

  • Optional userUuid: string

    Personal User UUID to listen to whispers

  Returns ThreeDDice

disconnect

• disconnect(): ThreeDDice

• Connect to the live server and begin listening to room events.

  Note: Your user must be a participant in a room in order to listen to events, otherwise an error is thrown.

  Returns ThreeDDice

dispatch

• dispatch(event, ...params): ThreeDDice

• Manually trigger an event

  Parameters

  • event: DiceEvent | RoomUpdated | ThreeDDiceRollEvent | AddDie

    The event to dispatch

  • Rest ...params: any[]

  Returns ThreeDDice

getTheme

• getTheme(themeId): ITheme

• Return a loaded theme

  Parameters

  • themeId: string

  Returns ITheme

getThemes

• getThemes(): ITheme[]

• Return all loaded themes

  Returns ITheme[]

initialize

• initialize(canvas?, apiKey?, config?, appName?): ThreeDDice

• Initialize object if the default constructor had been called

  Parameters

  • Optional canvas: HTMLCanvasElement

    Canvas element

  • Optional apiKey: string

    Required if connecting to the dddice API

  • Optional config: Partial<IEngineConfig>

    Optional configuration to change the look and feel of the renderer

  • Optional appName: string

    Optional name to identify which application is connecting to dddice

  Returns ThreeDDice

filter

• filter(participantIds): ThreeDDice

• Limit which participant events are executed This is useful for filtering dice rolls to a select group of players per instance (i.e. creating dice trays)

  Parameters

  • participantIds: number[]

    The participant IDs of the room

  Returns ThreeDDice

loadTheme

• loadTheme(theme, overwriteTheme?, fetchPreviews?): ThreeDDice

• Load a theme, including shaders, into the engine

  Parameters

  • theme: ITheme

  • overwriteTheme: boolean = false

  • fetchPreviews: boolean = true

  Returns ThreeDDice

off

• off(event): ThreeDDice

• Remove callback from event

  Parameters

  • event: RoomUpdated | ThreeDDiceRollEvent

    The event to stop listening to

  Returns ThreeDDice

on

• on(event, callback): ThreeDDice

• Listen for an event and execute a callback.

  Parameters

  • event: DiceEvent

    The event to listen on

  • callback: DiceEventCallback

    The function to execute when the event is fired

  Returns ThreeDDice
• on(event, callback): ThreeDDice

• Parameters

  • event: RoomUpdated

  • callback: RoomEventCallback

  Returns ThreeDDice

• on(event, callback): ThreeDDice

• Parameters

  • event: ThreeDDiceRollEvent

  • callback: RollEventCallback

  Returns ThreeDDice

pause

• pause(): void

• Pause camera controls

  Returns void

pickUpRollsForUser

• pickUpRollsForUser(uuid): Promise<void>

• Pick up dice belonging to a particular user

  This clears all dice rolled by the specified from the board and uses the API to notify clear those dice from the board's of all connected users

  Parameters

  • uuid: string

    uuid of the user whose dice to clear

  Returns Promise<void>

  void

  Throws

  APIError if connect not called previously

pickUpRoll

• pickUpRoll(roll, uuids?): Promise<IApiResponse<"roll[]", IRoll[]>>

• Pick up dice

  This clears certain dice from the board and updates the API

  Parameters

  • roll: Partial<IRoll> | Partial<IRoll>[]

    single roll or array of rolls

  • uuids: string[] = []

    Optional array of dice uuids

  Returns Promise<IApiResponse<"roll[]", IRoll[]>>

  void

  Throws

  APIError if connect not called previously

loadThemeResources

• loadThemeResources(id, processQueue?): string[]

• Load assets for a loaded theme

  This loads all meshes, textures, and sounds for a dice theme. Calling this multiple times will debounce the loading processing for 50ms

  Returns a list of items to be queued

  Parameters

  • id: string

  • processQueue: boolean = true

  Returns string[]

resetCamera

• resetCamera(): void

• Reset camera frame

  After disabling camera controls, this can be used to reset the camera view to a top-down angle

  Returns void

resize

• resize(width, height): ThreeDDice

• Resize canvas

  Parameters

  • width: number

    Width of canvas in pixels

  • height: number

    Height of canvas in pixels

  Returns ThreeDDice

resume

• resume(): void

• Resume camera controls

  Returns void

roll

• roll(dice, options?): Promise<IApiResponse<"roll", IRoll>>

• Roll dice using the dddice API. This method submits the roll to the server to be distributed to all room participants.

  Parameters

  • dice: IDiceRoll[]

  • Optional options: IDiceRollOptions

  Returns Promise<IApiResponse<"roll", IRoll>>

  Throws

  APIError if connect not called previously

screenshot

• screenshot(mimeType): undefined | string

• Screenshot the canvas

  Parameters

  • mimeType: string

    image format mime type of the generated screenshot.

  Returns undefined | string

  screenshot as a DataURI

setConfig

• setConfig(config): void

• Set configuration

  Parameters

  • config: Partial<IEngineConfig>

  Returns void

start

• start(): ThreeDDice

• Start the renderer

  Returns ThreeDDice

stop

• stop(): ThreeDDice

• Stop the renderer

  Returns ThreeDDice

unhideRoll

• unhideRoll(roll, uuids?): Promise<IApiResponse<"roll", IRoll>>

• Change the hidden state of a roll

  Optionally pass the uuids of specific dice to only unhide those dice, otherwise all dice in the roll will be revealed.

  Parameters

  • roll: IRoll

    IRoll Roll to unhide

  • uuids: string[] = []

    Optional array of dice uuids

  Returns Promise<IApiResponse<"roll", IRoll>>

  void

  Throws

  APIError if connect not called previously