Developer

Appearance

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

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

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