Developer

Appearance

General ​

load ​

load(spaceId: string, [callback: Function])

Loads a space with the given space ID. This function is typically called internally during the initialization process, but can also be used to load a different space instance.

The spaceId is the unique identifier of the space to load.

js
api.load('123456789123456789', function() {
  console.log('Space loaded successfully');
});

start ​

start([callback: Function])

Starts the space viewer. The callback will be invoked with no parameters.

js
api.start(function() {
  console.log('Viewer started');
});

stop ​

stop([callback: Function])

Stops/pauses the viewer. A call to start will resume the viewer. The callback will be invoked with no parameters.

js
api.stop(function() {
  console.log('Viewer stopped');
});

startRender ​

startRender([callback: Function])

Starts the render loop for the viewer's engine.

js
api.startRender(function() {
  console.log('Render loop started');
});

stopRender ​

stopRender([callback: Function])

Stops the render loop for the viewer's engine.

js
api.stopRender(function() {
  console.log('Render loop stopped');
});

getScreenshot ​

getScreenshot(size: [width: number, height: number] | number, callback: Function, [fileType: string])

This function allows you to take a screenshot of the viewer. The width and height arguments specify the dimensions of the screenshot. The optional fileType parameter accepts "jpg", "png", or "webp" (defaults to "png"). The callback will be called with one parameter containing a base64-encoded image.

js
// Default PNG format
api.getScreenshot([1920, 1080], function(base64) {
  console.log(base64); // Result: 'data:image/png;base64,/9j/4AAQ...'
});

// Explicit JPG format
api.getScreenshot([1920, 1080], function(base64) {
  console.log(base64); // Result: 'data:image/jpeg;base64,/9j/4AAQ...'
}, 'jpg');

// PNG format with transparency support
api.getScreenshot([1920, 1080], function(base64) {
  console.log(base64); // Result: 'data:image/png;base64,iVBORw0KG...'
}, 'image/png');

// Single number size with File type
api.getScreenshot(1920, function(base64) {
  console.log(base64); // Result: 'data:image/png;base64,iVBORw0KG...'
}, 'image/png');

setCanvasFocus ​

setCanvasFocus([callback: Function])

This function allows you to set focus on the viewer's canvas.

js
api.setCanvasFocus(function () {
  console.log('Focus set');
});

pickColor ​

pickColor(position: [x: number, y: number], [callback: Function])

Returns the color in the 3D viewer for the given screen coordinates. The callback returns a hex-color string.

js
api.pickColor([200, 300], function (colorHex) {
  console.log(colorHex); // Result: #ffd700
});

getMinimapSize ​

getMinimapSize(callback: Function)

Gets current minimap size in screen pixels, if exists.

js
api.getMinimapSize(function (val) {
  console.log(val); // Result: [100, 100]
});

showMinimap ​

showMinimap([callback: Function])

Show the minimap

js
api.showMinimap(function (val) {
  console.log('Minimap visible');
});

hideMinimap ​

hideMinimap([callback: Function])

Hide the minimap

js
api.hideMinimap(function (val) {
  console.log('Minimap hidden');
});

setQuality ​

setQuality(level: string, [callback: Function])

Set the quality level from 3d scene and reload the viewer after that automatically.

js
api.setQuality('HD', function () {
  console.log('Level changed');
});

isAmbientSoundMuted ​

isAmbientSoundMuted([callback: Function])

Returns true if the ambient sound is muted, false otherwise.

js
api.isAmbientSoundMuted(function (isAmbientSoundMuted) {
  console.log('Is ambient sound muted:', isAmbientSoundMuted);
});

muteAmbientSound ​

muteAmbientSound([callback: Function])

Mute the ambient sound in the background.

js
api.muteAmbientSound(function () {
  console.log('Ambient sound muted');
});

unmuteAmbientSound ​

unmuteAmbientSound([callback: Function])

Unmute the ambient sound in the background.

js
api.unmuteAmbientSound(function () {
  console.log('Ambient sound unmuted');
});

muteAllSound ​

muteAllSound([callback: Function])

Mute all sounds in the scene.

js
api.muteAllSound(function () {
  console.log('All sounds muted');
});

areAllSoundsMuted ​

areAllSoundsMuted([callback: Function])

Returns true if all sounds are muted, false otherwise.

js
api.areAllSoundsMuted(function (areAllSoundsMuted) {
  console.log('Are all sounds muted:', areAllSoundsMuted);
});

unmuteAllSound ​

unmuteAllSound([callback: Function])

Unmute all sounds in the scene.

js
api.unmuteAllSound(function () {
  console.log('All sounds unmuted');
});

muteSpace ​

muteSpace([callback: Function])

Mute all sounds in the space including voice chat.

js
api.muteSpace(function () {
  console.log('Space is muted');
});

unmuteSpace ​

unmuteSpace([callback: Function])

Unmute space sound.

js
api.unmuteSpace(function () {
  console.log('Space is unmuted');
});

getIsSpaceMuted ​

getIsSpaceMuted(callback: Function)

Returns space's sound state.

js
api.getIsSpaceMuted(function (isMuted) {
  console.log(isMuted); // Result: true | false
});

getVideos ​

getVideos(callback: Function)

Returns list of videos.

js
api.getVideos(function (videoIds) {
  console.log(videoIds); // Result: ['1-video', '2-video']
});

playVideo ​

playVideo(videoId:string, [callback: Function])

Plays selected video. The videoId is the ID of the video, which can be found via getVideos.

js
api.playVideo('1-video', function () {
  console.log('Video is playing');
});

pauseVideo ​

pauseVideo(videoId:string, [callback: Function])

Pauses selected video. The videoId is the ID of the video, which can be found via getVideos.

js
api.pauseVideo('1-video', function () {
  console.log('Video is paused');
});

setVideoTime ​

setVideoTime(videoId:string, time: number, [callback: Function])

Set current time for selected video. The videoId is the ID of the video, which can be found via getVideos. The time is new current time in seconds.

js
api.setVideoTime('1-video', 10, function () {
  console.log('Video current time is set to 10 sec');
});

muteVideo ​

muteVideo(videoId: string, [callback: Function])

Mutes a specific video. The videoId is the ID of the video, which can be found via getVideos.

js
api.muteVideo('1-video', function () {
  console.log('Video is muted');
});

unmuteVideo ​

unmuteVideo(videoId: string, [callback: Function])

Unmutes a specific video. The videoId is the ID of the video, which can be found via getVideos.

js
api.unmuteVideo('1-video', function () {
  console.log('Video is unmuted');
});

getVideoProgressionEvents ​

getVideoProgressionEvents(videoId:string, [callback: Function])

Turns on progress events for the specified video. The videoId is the ID of the video, which can be found via getVideos. The progress event can then be listened to via the video.progress event.

js
api.getVideoProgressionEvents('1-video', function () {
  console.log('Video progression events turned on');
});

stopVideoProgressionEvents ​

stopVideoProgressionEvents(videoId:string, [callback: Function])

Turns off progress events for the specified video. The videoId is the ID of the video, which can be found via getVideos.

js
api.stopVideoProgressionEvents('1-video', function () {
  console.log('Video progression events turned off');
});

getWorldToScreenCoordinates ​

getWorldToScreenCoordinates(coords: [x: number, y: number, z: number], [callback: Function])

Returns the screen coordinates for the given world coordinates.

js
api.getWorldToScreenCoordinates([1, 1, 1], function (coords) {
  console.log(coords); // Result: [100, 100]
});

getScreenToWorldCoordinates ​

getScreenToWorldCoordinates(coords: [x: number, y: number], [callback: Function])

Returns the world coordinates for the given screen coordinates. The first hit point in the scene.

js
api.getScreenToWorldCoordinates([100, 100], function (coords) {
  console.log(coords); // Result: [1, 1, 1]
});

importMesh ​

importMesh(url: string, filename: string, [options: Record<string, any>], [callback: Function])

Load gltf|glb file into scene. supports animation.

arguments:

  • url: url where the file is located
  • filename: name of gltf|glb file
  • options: key:value object with more options
    • transform: transform coordinates for the imported mesh
    • skeletonsEnabled: boolean gets or sets a boolean indicating if skeletons are enabled on this scene
    • playAnimation: string play named animation if existing
  • callback: function with arry of nodeIds as arguments
js
api.importMesh(
  'https://www.example.com/path/to/file/',
  'example-file.glb',
  {
      transform: {
          position: [Math.random(), 0, Math.random()],
          rotation: [0, Math.random() * 2 * Math.PI, 0],
          scale: [1, 1, 1],
      },
      skeletonsEnabled: true,
      playAnimation: true,
  },
  function (result) { console.log(result) }
  );

loadAssetContainer ​

loadAssetContainer(url: string, filename: string, [options: Record<string, any>], [callback: Function])

Load gltf|glb file as asset container and optionally creates instances of them.

arguments:

  • url: url where the file is located
  • filename: name of gltf|glb file
  • options: key:value object with more options
    • instanceTransforms: array of transform coordinates for the created instances
    • transform: transform coordinates for the root node
    • skeletonsEnabled: boolean gets or sets a boolean indicating if skeletons are enabled on this scene
    • cloneMaterials: boolean defines an optional boolean that defines if materials must be cloned as well (false by default)
    • doNotInstantiate: boolean defines if the model must be instantiated or just cloned
    • playAnimation: string play named animation if existing
  • callback: function with arry of nodeIds as arguments
js
api.loadAssetContainer(
  'https://www.example.com/path/to/file/',
  'example-file.glb',
  {
      instanceTransforms: [
          {
              position: [Math.random(), 0, Math.random()],
              rotation: [0, Math.random() * 2 * Math.PI, 0],
              scale: [1, 1, 1],
          },
          {
              position: [Math.random(), 0, Math.random()],
              rotation: [0, Math.random() * 6, 0],
              scale: [1, 1, 1],
          },
      ],
      transform: {
        position: [Math.random(), 0, Math.random()],
        rotation: [0, Math.random() * 2 * Math.PI, 0],
        scale: [2, 2, 2],
      },
      skeletonsEnabled: true,
      cloneMaterials: false,
      doNotInstantiate: false,
      playAnimation: true,
  },
  function (result) { console.log(result) }
  );

closeModal ​

closeModal(modalName:string, [callback: Function])

Closes an opened modal with the given modal name. The modalName can be a known name of an opened modal or a string received with the modal.open event when a modal is opened.

js
api.closeModal('Confirmation-dialog', function () {
  console.log('Confirmation-dialog modal is closed');
});

openTextChat ​

openTextChat([callback: Function])

Opens the text chat box.

js
api.openTextChat(function () {
  console.log('Text chat box is opened.');
});

closeTextChat ​

closeTextChat([callback: Function])

Closes the text chat box.

js
api.closeTextChat(function () {
  console.log('Text chat box is closed.');
});

Built with ❤️ by rooom AG

Copyright © 2025 rooom AG. All rights reserved.