Skip to content

General

start

start([callback: Function])

Start the space given by the user. Callback will be invoked with no parameter.

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

stop

stop([callback: Function])

Stops/pauses the viewer, a call to start will resume the viewer. Callback will be invoked with no parameter.

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

startRender

startRender([callback: Function])

Starts render loop for viewer's engine

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

stopRender

stopRender([callback: Function])

Stops render loop for viewer's engine

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

getScreenshot

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

This function lets you take a screenshot of the viewer. The width and height arguments are the width and the height of the screenshot. The callback will be called with one parameter and will be a base64 encoded image.

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

setCanvasFocus

setCanvasFocus([callback: Function])

This function lets you set focus on 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');
});

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');
});

unmuteAllSound

unmuteAllSound([callback: Function])

Unmute all sounds in the scene.

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

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');
});

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) }
  );