Skip to main content

Assets

Assets are resources imported into Lens Studio. See also: Importing and Updating Resources Guide

AnimationAsset​

Asset that contains multiple animation layers. Animation assets themselves do not handle playing or orchestrating animations. This is left to the animation player component to handle.

Lens Studio v5.0.10+
Scripting Name: Asset.AnimationAsset
Inherits from Asset

AnimationCurveTrack​

An asset that contains one or more animation curves. When evaluating multiple values, the values are selected from left to right in order. For example, for a vec3 containing x,y,z , it will correspond to track index 0, 1, 2 from left to right.

Lens Studio v5.0.1+
Scripting Name: Asset.AnimationCurveTrack
Inherits from AnimationTrack

[DEPRECATED] AnimationLayer​

Configures an animation layer for a single SceneObject. Gives access to position, rotation, scale and blend shape animation tracks. See also: Playing 3D Animation Guide, AnimationMixer, Animation.

Lens Studio v1.0.0+
Scripting Name: Asset.AnimationLayer
Inherits from AnimationTrack

AnimationTrack​

The base class for animation tracks.

Lens Studio v1.0.0+
Scripting Name: Asset.AnimationTrack
Inherits from Asset

Asset​

Base class for all assets used in the engine.

Lens Studio v1.0.0+
Scripting Name: Asset
Inherits from SerializableWithUID

AudioEffectAsset​

Configures an audio effect for AudioEffectComponent.

Lens Studio v1.7.0+
Scripting Name: Asset.AudioEffectAsset
Inherits from Asset

AudioTrackAsset​

Represents an audio file asset. See also: AudioComponent.

Lens Studio v1.0.0+
Scripting Name: Asset.AudioTrackAsset
Inherits from Asset

BinAsset​

File based asset.

Lens Studio v1.7.0+
Scripting Name: Asset.BinAsset
Inherits from Asset

BitmojiModule​

Provides access to getting information about the current user's Bitmoji.

Lens Studio v4.22.0+
Scripting Name: Asset.BitmojiModule
Inherits from Asset

BodyTrackingAsset​

Asset used to configure Body Tracking for the ObjectTracking3D component.

Lens Studio v3.4+
Scripting Name: Asset.BodyTrackingAsset
Inherits from Object3DAsset

CloudStorageModule​

Provides access to Cloud Storage.

Lens Studio v4.19.0+
Scripting Name: Asset.CloudStorageModule
Inherits from Asset

CollisionMesh​

Lens Studio v4.53.0+
Scripting Name: Physics.CollisionMesh
Inherits from Asset

ConnectedLensModule​

Connected Lenses Module allows use of networked Lens communication capabilities (real-time communication, co-located session creation and joining, and shared persistent storage). It's recommended to only use one ConnectedLensModule per Lens.

Lens Studio v4.0+
Scripting Name: Asset.ConnectedLensModule
Inherits from Asset

DeformingCollisionMesh​

Lens Studio v4.53.0+
Scripting Name: Physics.DeformingCollisionMesh
Inherits from CollisionMesh

DeviceTrackingModule​

The module that provides DeviceTracking component.

Lens Studio v5.0.20+
Scripting Name: Asset.DeviceTrackingModule
Inherits from Asset

DialogModule​

Lens Studio v4.28.0+
Scripting Name: Asset.DialogModule
Inherits from Asset

FixedCollisionMesh​

Lens Studio v4.53.0+
Scripting Name: Physics.FixedCollisionMesh
Inherits from CollisionMesh

[DEPRECATED] FloatAnimationTrack​

The base class for animation tracks using float values.

Lens Studio v1.0.0+
Scripting Name: Asset.FloatAnimationTrack
Inherits from AnimationTrack

[DEPRECATED] FloatAnimationTrackKeyFramed​

Represents an animation track using float value keyframes.

Lens Studio v1.0.0+
Scripting Name: Asset.FloatAnimationTrackKeyFramed
Inherits from FloatAnimationTrack

[DEPRECATED] FloatBezierAnimationTrackKeyFramed​

Represents an animation track using vec3 value keyframes for a bezier curve.

Lens Studio v1.0.0+
Scripting Name: Asset.FloatBezierAnimationTrackKeyFramed
Inherits from FloatAnimationTrack

Font​

A font asset used for rendering text. Used by Text. For more information, see the Text guide.

Lens Studio v1.7.0+
Scripting Name: Asset.Font
Inherits from Asset

GaussianSplattingAsset​

Asset that contains Gaussian Splats. Used with GaussianSplattingVisual.

Lens Studio v5.0.14+
Scripting Name: Asset.GaussianSplattingAsset
Inherits from Asset

GltfAsset​

Represents a GLTF 3D Model.

Lens Studio v4.22.0+
Scripting Name: Asset.GltfAsset
Inherits from Asset

HairDataAsset​

Hair asset converted from an FBX containing splines to be used with Hair Visual.

Lens Studio v4.0+
Scripting Name: Asset.HairDataAsset
Inherits from Asset

HandTracking3DAsset​

Lens Studio v4.7+
Scripting Name: Asset.HandTracking3DAsset
Inherits from Object3DAsset

[DEPRECATED] IntAnimationTrack​

The base class for animation tracks using integer values.

Lens Studio v1.0.0+
Scripting Name: Asset.IntAnimationTrack
Inherits from AnimationTrack

[DEPRECATED] IntStepAnimationTrackKeyFramed​

Represents an animation track using stepped integer value keyframes.

Lens Studio v1.0.0+
Scripting Name: Asset.IntStepAnimationTrackKeyFramed
Inherits from IntAnimationTrack

[DEPRECATED] IntStepNoLerpAnimationTrackKeyFramed​

Represents an animation track using stepped integer value keyframes.

Lens Studio v2.0.0+
Scripting Name: Asset.IntStepNoLerpAnimationTrackKeyFramed
Inherits from IntAnimationTrack

LeaderboardModule​

A module which provides the Leaderboard api.

Lens Studio v5.0.20+
Scripting Name: Asset.LeaderboardModule
Inherits from Asset

LevelsetColliderAsset​

Collider asset generated from a mesh to be used with the Hair Visual as part of the hair simulation.

Lens Studio v4.1+
Scripting Name: Asset.LevelsetColliderAsset
Inherits from BinAsset

LocalizationsAsset​

Asset used with the Localizations system to support custom localization strings.

Lens Studio v4.1+
Scripting Name: Asset.LocalizationsAsset
Inherits from Asset

LocationAsset​

Provides a frame of reference in which to localize objects to the real world. Use with LocatedAtComponent.

Lens Studio v2.0.0+
Scripting Name: Asset.LocationAsset
Inherits from Asset

LocationCloudStorageModule​

Provides access to location cloud storage depending upon the LocationCloudStorageOptions.

Lens Studio v4.28.0+
Scripting Name: Asset.LocationCloudStorageModule
Inherits from Asset

MLAsset​

Binary ML model supplied by the user.

Lens Studio v3.0+
Scripting Name: Asset.MLAsset
Inherits from BinAsset

MapModule​

Module for providing Map utils.

Lens Studio v4.43.0+
Scripting Name: Asset.MapModule
Inherits from Asset

MarkerAsset​

Defines a marker to use for Marker Tracking with MarkerTrackingComponent. For more information, see the Marker Tracking guide.

Lens Studio v1.7.0+
Scripting Name: Asset.MarkerAsset
Inherits from Asset

Material​

An asset that describes how visual objects should appear. Each Material is a collection of Passes which define the actual rendering passes. Materials are used by MeshVisuals for drawing meshes in the scene.

Lens Studio v1.0.0+
Scripting Name: Asset.Material
Inherits from Asset

Matter​

Settings for the physical substance, such as friction and bounciness, of a collider. If unset, uses the default matter from the world settings.

Lens Studio v4.13.0+
Scripting Name: Physics.Matter
Inherits from Asset

Object3DAsset​

Base class for configuring object tracking in the ObjectTracking3D component.

Lens Studio v3.4+
Scripting Name: Asset.Object3DAsset
Inherits from Asset

ObjectPrefab​

A reusable object hierarchy stored as a resource. Can be instantiated through script or brought into the scene through Lens Studio. For more information, see the Prefabs guide.

Lens Studio v1.7.0+
Scripting Name: Asset.ObjectPrefab
Inherits from Asset

Physics.WorldSettingsAsset​

Stores reusable settings uniform for a world (such as gravity magnitude and direction). See also: WorldComponent.worldSettings.

Lens Studio v4.31.0+
Scripting Name: Physics.WorldSettingsAsset
Inherits from Asset
Outer Classes: Physics

ProcessedLocationModule​

Lens Studio v5.0.20+
Scripting Name: Asset.ProcessedLocationModule
Inherits from Asset

[DEPRECATED] QuaternionAnimationTrack​

The base class for animation tracks using quaternion values.

Lens Studio v1.0.0+
Scripting Name: Asset.QuaternionAnimationTrack
Inherits from AnimationTrack

[DEPRECATED] QuaternionAnimationTrackKeyFramed​

Represents an animation track using quaternion value keyframes.

Lens Studio v1.0.0+
Scripting Name: Asset.QuaternionAnimationTrackKeyFramed

[DEPRECATED] QuaternionAnimationTrackXYZEuler​

Represents a rotation animation track using euler angles.

Lens Studio v1.0.0+
Scripting Name: Asset.QuaternionAnimationTrackXYZEuler

RawLocationModule​

Lens Studio v5.0.20+
Scripting Name: Asset.RawLocationModule
Inherits from Asset

RemoteMediaModule​

Provides access to a remote media.

Lens Studio v4.22.0+
Scripting Name: Asset.RemoteMediaModule
Inherits from Asset

RemoteReferenceAsset​

Provides a reference to a remote asset (i.e. assets outside of the Lens size limit) that can be downloaded at runtime using script.

Lens Studio v4.31.0+
Scripting Name: Asset.RemoteReferenceAsset
Inherits from Asset

RemoteServiceModule​

Provides access to the remote services. For Spectacles, this module process access to the open internet.

Lens Studio v4.0+
Scripting Name: Asset.RemoteServiceModule
Inherits from Asset

RenderMesh​

Represents a mesh asset. See also: RenderMeshVisual.

Lens Studio v1.0.0+
Scripting Name: Asset.RenderMesh
Inherits from Asset

[Exposes User Data] ScanModule​

Asset for detecting an object through the Scan system.

Lens Studio v3.4+
Scripting Name: Asset.ScanModule
Inherits from Asset
Inner Classes: ScanModule.Contexts

ScriptAsset​

Represents a JavaScript script which can be used to add logic in your Lens.

Lens Studio v4.22.0+
Scripting Name: Asset.ScriptAsset
Inherits from Asset

SegmentationModel​

Segmentation model used for SegmentationTextureProvider.

Lens Studio v1.7.0+
Scripting Name: Asset.SegmentationModel
Inherits from BinAsset

TextInputModule​

Lens Studio v5.0.20+
Scripting Name: Asset.TextInputModule
Inherits from Asset

TextToSpeechModule​

Allows generation of speech from a given text. You can use only one TextToSpeechModule in a Lens. However, its methods can be called multiple times in parallel if needed.

Lens Studio v4.4+
Scripting Name: Asset.TextToSpeechModule
Inherits from Asset

Texture​

Represents a texture file asset.

Lens Studio v1.0.0+
Scripting Name: Asset.Texture
Inherits from Asset

UpperBodyTrackingAsset​

An asset containing the upper body tracker. It is optimized to track with the face and in selfie use cases.

Lens Studio v5.2.0+
Scripting Name: Asset.UpperBodyTrackingAsset
Inherits from Object3DAsset

VFXAsset​

Defines a VFX to use with VFX Component. For more information, see the VFX Guide.

Lens Studio v4.0+
Scripting Name: Asset.VFXAsset
Inherits from Asset

[DEPRECATED] Vec2AnimationTrack​

Represents an animation track using vec2 value keyframes.

Lens Studio v1.0.0+
Scripting Name: Asset.Vec2AnimationTrack
Inherits from AnimationTrack

[DEPRECATED] Vec2AnimationTrackKeyFramed​

Represents an animation track using vec2 value keyframes.

Lens Studio v1.0.0+
Scripting Name: Asset.Vec2AnimationTrackKeyFramed
Inherits from Vec2AnimationTrack

[DEPRECATED] Vec3AnimationTrack​

Represents an animation track using vec3 value keyframes.

Lens Studio v1.0.0+
Scripting Name: Asset.Vec3AnimationTrack
Inherits from AnimationTrack

[DEPRECATED] Vec3AnimationTrackKeyFramed​

Represents an animation track using vec3 value keyframes.

Lens Studio v1.0.0+
Scripting Name: Asset.Vec3AnimationTrackKeyFramed
Inherits from Vec3AnimationTrack

[DEPRECATED] Vec3AnimationTrackXYZ​

Represents an animation track using vec3 animation tracks.

Lens Studio v1.0.0+
Scripting Name: Asset.Vec3AnimationTrackXYZ
Inherits from Vec3AnimationTrack

[DEPRECATED] Vec4AnimationTrack​

Represents an animation track using vec4 value keyframes.

Lens Studio v1.0.0+
Scripting Name: Asset.Vec4AnimationTrack
Inherits from AnimationTrack

[DEPRECATED] Vec4AnimationTrackKeyFramed​

Represents an animation track using vec4 value keyframes.

Lens Studio v1.0.0+
Scripting Name: Asset.Vec4AnimationTrackKeyFramed
Inherits from Vec4AnimationTrack

VoiceMLModule​

VoiceML Module allows voice input and commands. It enables transciption of the speech, detecting keywords within the transcription, intents as well as system commands (such as "Take a Snap"). You can use one VoiceML Module per Lens.

Lens Studio v4.4+
Scripting Name: Asset.VoiceMLModule
Inherits from Asset

Methods​

enableSystemCommands() :

void

​

Allows the user to provide voice commands for the VoiceML to execute on behalf of the users. Current supported commands: "Take a Snap", "Start Recording", "Stop Recording". In case a command was detected, it will be automtically executed by the system and returned as part of the NlpCommandResponse in the onListeningUpdate callback. You can retrieve the command that was executed using the following snippet:

var onUpdateListeningEventHandler = function(eventArgs) {
    var commandResponses = eventArgs.getCommandResponses();
    var nlpResponseText = "";

    for (var i = 0; i < commandResponses.length; i++) {
        var commandResponse = commandResponses[i];
        nlpResponseText += "Command Response: " + commandResponse.modelName + "\n command: " + commandResponse.command;     
    }
}

startListening(

VoiceML.ListeningOptions options

) :

void

 (Exposes User Data)​

Starts transcribing the user audio, the NLP model is connected and sends back results using an event, optionally could request for transcription and interim results. Notice, you can only startListening, after microphone permissions have been granted. It is recommended to use startListening method only after onListeningEnabled callback was called.

stopListening() :

void

​

Stops voice commands.

Properties​

onListeningDisabled :

()

 (readonly)​

Registers a callback which will be called when microphone permissions are taken from the lens. stopListening() is implicitly called in such case.

onListeningEnabled :

()

 (readonly)​

Registers a callback which will be called when microphone permissions are granted to the Lens, the microphone is initialized, and is actively listening. The expected design pattern is to start the listening session once those permissions have been granted:

//@input Asset.VoiceMLModule vmlModule
var onListeningEnabledHandler = function(){
    script.vmlModule.startListening(options);  
}
script.vmlModule.onListeningEnabled.add(onListeningEnabledHandler);

onListeningError :

(VoiceML.ListeningErrorEventArgs args)

 (readonly)​

Registers a callback, which will be called in case the VoiceML module can't process the inputs. Most errors are due to network connectivity, or misconfigured NLP inputs.

onListeningUpdate :

(VoiceML.ListeningUpdateEventArgs args)

 (readonly)​

Registers a callback, which will be called with interim transcription or related NLP models.

Inherited Methods​

getTypeName() :

String

​

Returns the name of this object's type.

isOfType(

String type

) :

Boolean

​

Returns true if the object matches or derives from the passed in type.

isSame(

ScriptObject other

) :

Boolean

​

Returns true if this object is the same as other. Useful for checking if two references point to the same thing.

Inherited Properties​

name :

String

​

The name of the Asset in Lens Studio.

uniqueIdentifier :

String

 (readonly)​

Examples​

//@input Asset.VoiceMLModule vmlModule {"label": "Voice ML Module"}
//@input Asset.AudioTrackAsset audioTrack

var options = VoiceML.ListeningOptions.create();
options.speechRecognizer = VoiceMLModule.SpeechRecognizer.Default;

//General Option
options.shouldReturnAsrTranscription = true;
options.shouldReturnInterimAsrTranscription = true;

//Speech Context
var phrasesOne = ["carrot", "tomato"];
var boostValueOne = 5;
options.addSpeechContext(phrasesOne,boostValueOne);

var phrasesTwo = ["orange", "apple"];
var boostValueTwo = 6;
options.addSpeechContext(phrasesTwo,boostValueTwo);


//NLPKeywordModel
var nlpKeywordModel = VoiceML.NlpKeywordModelOptions.create(); 
nlpKeywordModel.addKeywordGroup("Vegetable", ["carrot", "tomato"]);
nlpKeywordModel.addKeywordGroup("Fruit", ["orange", "apple"]);

//Command
var nlpIntentModel = VoiceML.NlpIntentsModelOptions.create("VOICE_ENABLED_UI");       
nlpIntentModel.possibleIntents =  ["next", "back", "left", "right", "up", "down", "first", "second", "third", "fourth", "fifth", "sixth", "seventh", "eighth", "ninth", "tenth"];
options.nlpModels =[nlpKeywordModel, nlpIntentModel];

var onListeningEnabledHandler = function() {
    script.vmlModule.startListening(options);
};
var onListeningDisabledHandler = function() {
    script.vmlModule.stopListening();
};

var getErrorMessage = function(response) {
    var errorMessage = "";
    switch (response) {
        case "#SNAP_ERROR_INDECISIVE":
            errorMessage = "indecisive";
            break;
        case "#SNAP_ERROR_INCONCLUSIVE":
            errorMessage = "inconclusive";
            break;
        case "#SNAP_ERROR_NONVERBAL":
            errorMessage = "non verbal";
            break;
        case "#SNAP_ERROR_SILENCE":
            errorMessage = "too long silence";
            break;          
        default:
        if (response.includes("#SNAP_ERROR")) {
            errorMessage = "general error";  
        } else {
            errorMessage = "unknown error";
        }
    }
    return errorMessage;
};

var parseKeywordResponses = function(keywordResponses) {
    var keywords = [];
    var code = "";
    for (var kIterator = 0; kIterator < keywordResponses.length; kIterator++) {
        var keywordResponse = keywordResponses[kIterator];
        
        switch (keywordResponse.status.code) {
            case VoiceMLModule.NlpResponsesStatusCodes.OK:
                code= "OK";
                for (var keywordsIterator = 0; keywordsIterator < keywordResponse.keywords.length; keywordsIterator++) {
                    var keyword = keywordResponse.keywords[keywordsIterator];
                    if (keyword.includes("#SNAP_ERROR")) {
                        var errorMessage = getErrorMessage(keyword);
                        print("Keyword Error: " + errorMessage);
                        break;
                    }
                    keywords.push(keyword);                  
                }
                break;
            case VoiceMLModule.NlpResponsesStatusCodes.ERROR:
                code = "ERROR";
                print("Status Code: "+code+ " Description: " + keywordResponse.status.code.description);
                break;
            default:
                print("Status Code: No Status Code");
        }
    }
    return keywords;
};

var parseCommandResponses = function(commandResponses) {
    var commands = [];
    var code = "";
    for (var iIterator = 0; iIterator < commandResponses.length; iIterator++) {
        var commandResponse = commandResponses[iIterator];
        switch (commandResponse.status.code) {
            case VoiceMLModule.NlpResponsesStatusCodes.OK:
                code= "OK";
                var command = commandResponse.intent;
                if (command.includes("#SNAP_ERROR")) {
                    var errorMessage = getErrorMessage(command);
                    print("Command Error: " + errorMessage);
                    break;
                }
                commands.push(commandResponse.intent);
                break;
            case VoiceMLModule.NlpResponsesStatusCodes.ERROR:
                code = "ERROR";
                print("Status Code: "+code+ " Description: " + commandResponse.status.code.description);
                break;
            default:
                print("Status Code: No Status Code");
        } 
    }
    return commands;
};

var onUpdateListeningEventHandler = function(eventArgs) { 
    if (eventArgs.transcription.trim() == "") {
        return;
    }  
    print("Transcription: " + eventArgs.transcription);
    
    if (!eventArgs.isFinalTranscription) {
        return;
    }  
    print("Final Transcription: " + eventArgs.transcription); 
    
    //Keyword Results 
    var keywordResponses = eventArgs.getKeywordResponses();  
    var keywords = parseKeywordResponses(keywordResponses);
    if (keywords.length > 0) {
        var keywordResponseText = "";
        for (var kIterator=0;kIterator<keywords.length;kIterator++) {
            keywordResponseText += keywords[kIterator] +"\n";                                   
        }
        print("Keywords:" + keywordResponseText);
    }
    
    //Command Results  
    var commandResponses = eventArgs.getIntentResponses();    
    var commands = parseCommandResponses(commandResponses);
    
    if (commands.length > 0) {
        var commandResponseText = ""; 
        for (var iIterator=0;iIterator<commands.length;iIterator++) {
            commandResponseText += commands[iIterator]+"\n";
        }   
        print("Commands: " + commandResponseText);
    }
    
};

var onListeningErrorHandler = function(eventErrorArgs) {
    print("Error: " + eventErrorArgs.error + " desc: "+ eventErrorArgs.description);
};

//VoiceML Callbacks
script.vmlModule.onListeningUpdate.add(onUpdateListeningEventHandler);
script.vmlModule.onListeningError.add(onListeningErrorHandler); 
script.vmlModule.onListeningEnabled.add(onListeningEnabledHandler);
script.vmlModule.onListeningDisabled.add(onListeningDisabledHandler);

WorldUnderstandingModule​

Lens Studio v5.0.20+
Scripting Name: Asset.WorldUnderstandingModule
Inherits from Asset
Was this page helpful?
Yes
No