Full API List

• Base64
  • decode(_value: string): Uint8Array
  • encode(_data: Uint8Array): string
• BaseDescriptor
  • dependencies: Editor.InterfaceId[]
  • description: string
  • id: string
  • interfaces: Editor.InterfaceId[]
  • name: string
• Editor
  • IAuthorization: Editor.InterfaceId
  • IContextActionRegistry: Editor.InterfaceId
  • IEntityPicker: Editor.InterfaceId
  • IInstallableContentActions: Editor.InterfaceId
  • IInstallableContentRegistry: Editor.InterfaceId
  • createAnimationClip(_scene: Editor.Assets.Scene): Editor.AnimationClip
  • isNull(_object: any): boolean
• Editor
  • Ai
  • Ai
    • Storage
  • Alignment
    • Horizontal
      • Center: number
      • Left: number
      • Right: number
    • Vertical
      • Bottom: number
      • Center: number
      • Top: number
  • AnimationClip
    • animation: Editor.Assets.AnimationAsset
    • begin: number
    • blendMode: Editor.AnimationLayerBlendMode
    • disabled: boolean
    • end: number
    • name: string
    • playbackMode: Editor.PlaybackMode
    • playbackSpeed: number
    • reversed: boolean
    • scaleMode: Editor.AnimationLayerScaleMode
    • weight: number
  • AnimationLayerBlendMode
    • Additive: number
    • Default: number
  • AnimationLayerScaleMode
    • Additive: number
    • Multiply: number
  • Assets
    • AnimationAsset
      • duration: number
      • fps: number
      • frames: number
    • AntialiasingMode
      • Disabled: number
      • MSAA: number
      • TAA: number
    • AntialiasingQuality
      • Default: number
      • High: number
      • Low: number
      • Medium: number
      • Ultra: number
    • Asset
      • cacheFile: Editor.Path
      • fileMeta: Editor.Model.AssetImportMetadata
      • name: string
    • BlendMode
      • Add: number
      • AddLegacy: number
      • AlphaTest: number
      • AlphaToCoverage: number
      • Average: number
      • Bright: number
      • Color: number
      • ColorBurn: number
      • ColorDodge: number
      • ColoredGlass: number
      • Custom: number
      • Darken: number
      • Diff: number
      • Disabled: number
      • Division: number
      • Exclusion: number
      • Forgray: number
      • Glass: number
      • HardGlow: number
      • HardLight: number
      • HardMix: number
      • HardPhoenix: number
      • HardReflect: number
      • Hue: number
      • Intense: number
      • Lighten: number
      • LinearLight: number
      • Luminosity: number
      • Max: number
      • Min: number
      • Multiply: number
      • MultiplyLegacy: number
      • Negation: number
      • Normal: number
      • NotBright: number
      • Overlay: number
      • PinLight: number
      • PremultipliedAlpha: number
      • PremultipliedAlphaAuto: number
      • Realistic: number
      • Saturation: number
      • Screen: number
      • SoftLight: number
      • Subtract: number
      • VividLight: number
    • BodyTracking3DAsset
      • handTrackingEnabled: boolean
    • ClearColorOption
      • BackgroundTexture: number
      • CustomColor: number
      • CustomTexture: number
      • LegacyClearColorEnable: number
      • None: number
    • CullMode
      • Back: number
      • Front: number
      • FrontAndBack: number
    • DepthBufferStrategy
      • Auto: number
      • ForceOff: number
      • ForceOn: number
    • DepthFunction
      • Always: number
      • Equal: number
      • Greater: number
      • GreaterEqual: number
      • Less: number
      • LessEqual: number
      • Never: number
      • NotEqual: number
    • DeviceCameraTexture
    • FaceCropTexture
      • faceCenterMouthWeight: number
      • faceIndex: number
      • inputTexture: Editor.Assets.Texture
      • scale: vec2
    • FaceMesh
      • earGeometryEnabled: boolean
      • expressionMultiplier: number
      • externalMesh: Editor.Assets.FileMesh
      • externalMeshMapUV: Editor.Assets.VertexAttribute
      • externalScale: number
      • eyeCornerGeometryEnabled: boolean
      • eyeGeometryEnabled: boolean
      • faceGeometryEnabled: boolean
      • faceIndex: number
      • mouthGeometryEnabled: boolean
      • skullGeometryEnabled: boolean
    • FileMesh
    • FileTexture
      • fileInfo: Editor.Assets.FileTextureInfo
    • FileTexture2DArray
      • fileInfo: Editor.Assets.FileTextureInfo3D
    • FileTexture3D
      • fileInfo: Editor.Assets.FileTextureInfo3D
    • FileTextureCubemap
      • fileInfo: Editor.Assets.FileTextureInfo3D
    • FileTextureInfo
      • height: number
      • width: number
    • FileTextureInfo3D
      • depth: number
    • FilteringMode
      • Bilinear: number
      • Nearest: number
      • Trilinear: number
    • Font
    • FrustumCullMode
      • Auto: number
      • Extend: number
    • GaussianSplattingAsset
      • flipXY: boolean
      • recenter: boolean
      • scale: number
    • HairDataAsset
    • HandTracking3DAsset
      • handType: Editor.Assets.HandTracking3DHandType
    • HandTracking3DHandType
      • Left: number
      • Right: number
    • ImageMarker
      • texture: Editor.Assets.FileTexture
    • JavaScriptAsset
    • Location
      • displayName: string
      • locationId: string
      • locationType: Editor.Assets.LocationType
    • LocationMesh
      • location: Editor.Assets.Location
    • LocationType
      • Custom: number
      • NativeAR: number
      • Proxy: number
      • RelativeTile: number
      • Snap: number
      • Tile: number
      • World: number
    • MLAsset
    • MSAAStrategy
      • Default: number
      • OnlyWhenRequired: number
    • MarkerAsset
      • height: number
    • Material
      • passInfos: Editor.Assets.PassInfo[]
      • addPass(_pass: Editor.Assets.Pass): Editor.Assets.PassInfo
    • NativePackageDescriptor
      • componentId: Editor.Uuid
      • description: string
      • exportId: Editor.Uuid
      • icon: Editor.Icon
      • packageName: string
      • setupScript: Editor.Assets.SetupScript
      • version: Editor.Assets.Version
    • Object3DAsset
    • ObjectOwner
      • rootSceneObjects: Editor.Model.SceneObject[]
      • sceneObjects: Editor.Model.SceneObject[]
      • addSceneObject(_parent: Editor.Model.SceneObject): Editor.Model.SceneObject
      • createSceneObject(_name: string): Editor.Model.SceneObject
      • findComponents(_entityType: string): Editor.Components.Component[]
      • getRootObjectIndex(_object: Editor.Model.SceneObject): number
      • reparentSceneObject(_object: Editor.Model.SceneObject, _newParent: Editor.Model.SceneObject, _position: number): void
    • ObjectPrefab
      • lazyLoading: boolean
      • prefabInstances: Editor.Model.SceneObject[]
      • retainAssets: boolean
    • ObjectTrackingTexture
      • trackingType: Editor.Assets.ObjectTrackingTextureType
    • ObjectTrackingTextureType
      • Hand: number
      • Nails: number
    • Pass
    • PassInfo
      • blendMode: Editor.Assets.BlendMode
      • colorMask: any
      • cullMode: Editor.Assets.CullMode
      • defines: string[]
      • depthFunction: Editor.Assets.DepthFunction
      • depthTest: boolean
      • depthWrite: boolean
      • frustumCulling: Editor.Assets.FrustumCullMode
      • instanceCount: number
      • polygonOffset: vec2
      • twoSided: boolean
      • getPropertyNames(): string[]
    • Physics
      • Filter
        • includeDynamic: boolean
        • includeIntangible: boolean
        • includeStatic: boolean
        • onlyLayers: Editor.Model.LayerSet
        • skipLayers: Editor.Model.LayerSet
      • LevelsetColliderAsset
      • Matter
        • dynamicBounciness: number
        • friction: number
        • rollingFriction: number
        • spinningFriction: number
        • staticBounciness: number
      • WorldSettingsAsset
        • absoluteSpeedLimit: number
        • defaultFilter: Editor.Assets.Physics.Filter
        • defaultMatter: Editor.Assets.Physics.Matter
        • gravity: vec3
        • relativeSpeedLimit: number
        • simulationRate: number
        • slowDownStep: number
        • slowDownTime: number
        • getLayersCollidable(_{layerNumberA:} number, _{layerNumberB:} number): boolean
    • RemoteMLAsset
      • deviceDependentAssetId: string
    • RenderMesh
    • RenderTarget
      • antialiasingMode: Editor.Assets.AntialiasingMode
      • clearColor: vec4
      • clearColorOption: Editor.Assets.ClearColorOption
      • depthBuffer: Editor.Assets.DepthBufferStrategy
      • inputTexture: Editor.Assets.Texture
      • msaaStrategy: Editor.Assets.MSAAStrategy
      • resolution: Editor.Size
      • useScreenResolution: boolean
    • Sampler
      • filteringMode: Editor.Assets.FilteringMode
      • mipmapsEnabled: boolean
      • wrapModeU: Editor.Assets.WrapMode
      • wrapModeV: Editor.Assets.WrapMode
      • wrapModeW: Editor.Assets.WrapMode
    • Scene
      • layers: Editor.Model.Layers
      • mainCamera: Editor.Components.Camera
      • renderOutput: Editor.Assets.RenderTarget
      • renderOverlayOutput: Editor.Assets.RenderTarget
      • renderPreviewOutput: Editor.Assets.RenderTarget
      • instantiatePrefab(_prefab: Editor.Assets.ObjectPrefab, _parent: Editor.Model.SceneObject): Editor.Model.SceneObject
    • ScriptAsset
      • componentId: Editor.Uuid
      • description: string
      • exportId: Editor.Uuid
      • icon: Editor.Icon
      • version: Editor.Assets.Version
      • isScriptInputHidden(_inputName: string): boolean
      • setScriptInputHidden(_inputName: string, _hidden: boolean): void
    • ScriptTypes
      • Visibility
        • Editable: number
        • Locked: number
    • SegmentationTexture
      • feathering: number
      • invertMask: boolean
      • refineEdge: boolean
      • segmentationType: Editor.Assets.SegmentationType
    • SegmentationType
      • Body: number
      • Footwear: number
      • FullGarment: number
      • LowerGarment: number
      • PortraitFace: number
      • PortraitHair: number
      • PortraitHead: number
      • PortraitSegmentation: number
      • PortraitShoulder: number
      • PortraitSkin: number
      • Sky: number
      • UpperGarment: number
    • SetupScript
      • code: string
    • SnapcodeMarker
    • Texture
    • TextureParameter
      • id: Editor.Uuid
      • sampler: Editor.Assets.Sampler
    • Version
      • major: number
      • minor: number
      • patch: number
    • VertexAttribute
      • BoneData: number
      • Color: number
      • Normal: number
      • Position: number
      • Tangent: number
      • Texcoord0: number
      • Texcoord1: number
      • Texcoord2: number
      • Texcoord3: number
    • WrapMode
      • ClampToBorderColor: number
      • ClampToEdge: number
      • MirroredRepeat: number
      • Repeat: number
  • Axis
    • X: number
    • Y: number
    • Z: number
  • Buffer
    • toBytes(): Uint8Array
    • toString(): string
  • Components
    • AnimationPlayer
      • animationClips: Editor.AnimationClip[]
      • autoplay: boolean
      • clipRangeType: Editor.Components.ClipRangeType
    • BackgroundSettings
      • cornerRadius: number
      • enabled: boolean
      • fill: Editor.Components.TextFill
      • margins: Editor.Rect
    • BarycentricVertex
      • indices: number[]
      • weights: number[]
    • BaseMeshVisual
      • horizontalAlignment: Editor.Alignment.Horizontal
      • meshShadowMode: Editor.Components.MeshShadowMode
      • shadowColor: vec4
      • shadowDensity: number
      • stretchMode: Editor.Components.StretchMode
      • verticalAlignment: Editor.Alignment.Vertical
    • Camera
      • aspect: number
      • aspectPreset: Editor.Components.CameraAspectPreset
      • cameraType: Editor.Components.CameraType
      • clearColor: Editor.Components.CameraClearColor
      • clearDepth: Editor.Components.CameraClearDepth
      • depthMode: Editor.Components.CameraDepthBufferMode
      • deviceProperty: Editor.Components.CameraDeviceProperty
      • far: number
      • fov: number
      • inputTexture: Editor.Assets.Texture
      • maskTexture: Editor.Assets.Texture
      • mipmapLevel: number
      • near: number
      • oitLayers: Editor.Components.CameraOitLayers
      • orthographicSize: vec2
      • renderOrder: number
      • renderTarget: Editor.Assets.RenderTarget
      • size: number
    • CameraAspectPreset
      • Custom: number
      • Specific: number
    • CameraClearColor
      • color: vec4
      • input: Editor.Assets.Texture
      • mode: Editor.Components.CameraClearColor.Mode
    • CameraClearColor
      • Mode
        • Background: number
        • Color: number
        • None: number
        • Texture: number
    • CameraClearDepth
      • input: Editor.Assets.Texture
      • mode: Editor.Components.CameraClearDepth.Mode
      • value: number
    • CameraClearDepth
      • Mode
        • None: number
        • Texture: number
        • Value: number
    • CameraDepthBufferMode
      • Logarithmic: number
      • Regular: number
    • CameraDeviceProperty
      • All: number
      • Aspect: number
      • Fov: number
      • None: number
    • CameraOitLayers
      • Layers4: number
      • Layers4Plus1: number
      • Layers8: number
      • NoOit: number
    • CameraType
      • Orthographic: number
      • Perspective: number
    • Canvas
      • pivot: vec2
      • sortingType: Editor.Components.SortingType
      • unitType: Editor.Components.UnitType
      • worldSpaceRect: Editor.Rect
    • CapitalizationOverride
      • AllLower: number
      • AllUpper: number
      • None: number
    • ClipRangeType
      • Frames: number
      • Seconds: number
    • ClothVisual
      • bendMode: Editor.Components.ClothVisual.BendMode
      • bendStiffness: number
      • colliders: Editor.Components.Physics.ColliderComponent[]
      • collisionEnabled: boolean
      • collisionFriction: number
      • collisionOffset: number
      • collisionStiffness: number
      • debugModeEnabled: boolean
      • frameRate: number
      • friction: number
      • gravity: vec3
      • iterations: number
      • mass: number
      • maxAcceleration: number
      • mesh: Editor.Assets.RenderMesh
      • stretchStiffness: number
      • updateNormalsEnabled: boolean
      • vertexBindings: Editor.Components.ClothVisual.VertexBinding[]
    • ClothVisual
      • BendMode
        • Isometric: number
        • Linear: number
      • VertexBinding
        • color: vec4
        • colorMask: any
        • followObject: Editor.Model.SceneObject
    • Component
      • enabled: boolean
      • name: string
      • sceneObject: Editor.Model.SceneObject
    • DecayType
      • Linear: number
      • None: number
      • Quadratic: number
    • DeviceTracking
      • deviceTrackingMode: Editor.Components.DeviceTrackingMode
      • rotationOptions: Editor.Components.RotationOptions
      • surfaceOptions: Editor.Components.SurfaceOptions
    • DeviceTrackingMode
      • Rotation: number
      • Surface: number
      • World: number
    • DropshadowSettings
      • enabled: boolean
      • fill: Editor.Components.TextFill
      • offset: vec2
    • EnvmapFromCameraMode
      • Auto: number
      • Face: number
      • Surface: number
    • ExtrudeDirection
      • Backwards: number
      • Both: number
      • Forwards: number
    • EyeColorVisual
      • eyeToRender: Editor.Components.EyeToRender
      • faceIndex: number
      • rotationEnabled: boolean
    • EyeToRender
      • Both: number
      • Left: number
      • Right: number
    • FaceInsetRegion
      • Custom: number
      • Face: number
      • LeftEye: number
      • Mouth: number
      • Nose: number
      • RightEye: number
    • FaceInsetVisual
      • faceIndex: number
      • faceRegion: Editor.Components.FaceInsetRegion
      • flipX: boolean
      • flipY: boolean
      • innerBorderRadius: number
      • offset: vec2
      • outerBorderRadius: number
      • pivot: vec2
      • sourceScale: vec2
      • subDivisionCount: number
    • FaceMaskVisual
      • drawMouth: boolean
      • enabledLipsFix: boolean
      • enabledTeethFix: boolean
      • faceIndex: number
      • maskCoordinates: vec2[]
      • maskOnMouthClosed: Editor.Assets.Texture
      • originalFaceIndex: number
      • teethFixAlpha: number
      • textureCoordinates: vec2[]
      • useOriginalTexCoords: boolean
      • useTextureFacePosition: boolean
    • FaceStretchVisual
      • faceIndex: number
      • addFeature(_name: string): void
      • clearFeatures(): void
      • getFeatureNames(): string[]
      • getFeaturePoints(_name: string): Editor.Components.StretchPoint[]
      • getFeatureWeight(_name: string): number
      • removeFeature(_name: string): void
      • setFeatureWeight(_name: string, _weight: number): void
      • updateFeaturePoints(_name: string, _points: Editor.Components.StretchPoint[]): void
    • GaussianSplattingVisual
      • activeFrame: number
      • asset: Editor.Assets.GaussianSplattingAsset
    • HairVisual
      • bendStiffness: number
      • clumpDensity: number
      • clumpRadius: number
      • clumpTipScale: number
      • collapseStiffness: number
      • colliders: Editor.Components.Physics.ColliderComponent[]
      • collisionEnabled: boolean
      • collisionFriction: number
      • collisionOffset: number
      • collisionStiffness: number
      • damp: number
      • debugDrawLoadedStrands: boolean
      • debugDrawSimulatedStrands: boolean
      • debugModeEnabled: boolean
      • density: number
      • fallbackModeEnabled: boolean
      • frameRate: number
      • friction: number
      • gravity: vec3
      • hairData: Editor.Assets.HairDataAsset
      • hairMaterial: Editor.Assets.Material
      • hairResolution: number
      • noise: number
      • selfCollisionEnabled: boolean
      • selfCollisionFriction: number
      • selfCollisionOffset: number
      • selfCollisionStiffness: number
      • steppedCutEnabled: boolean
      • stiffness: number
      • strandCut: number
      • strandNeighborCosThreshold: number
      • strandNeighborLengthThreshold: number
      • strandNeighborRadius: number
      • strandTaper: number
      • strandWidth: number
      • stretchLimitEnabled: boolean
      • stretchStiffness: number
      • twistStiffness: number
      • windEnabled: boolean
      • windForce: vec3
    • Head
      • attachedBarycentricVertex: Editor.Components.BarycentricVertex
      • attachmentPoint: Editor.Components.HeadAttachmentPointType
      • faceIndex: number
    • HeadAttachmentPointType
      • CandideCenter: number
      • Chin: number
      • FaceMeshCenter: number
      • Forehead: number
      • HeadCenter: number
      • LeftCheek: number
      • LeftEyeballCenter: number
      • LeftForehead: number
      • MouthCenter: number
      • RightCheek: number
      • RightEyeballCenter: number
      • RightForehead: number
      • TriangleBarycentric: number
    • HorizontalOverflow
      • Ellipsis: number
      • EllipsisFront: number
      • Overflow: number
      • Shrink: number
      • Truncate: number
      • TruncateFront: number
      • Wrap: number
    • Image
      • flipX: boolean
      • flipY: boolean
      • pivot: vec2
      • rotationAngle: number
    • InteractionComponent
      • camera: Editor.Components.Camera
      • depthFilter: boolean
      • meshVisuals: Editor.Components.BaseMeshVisual[]
      • minimumTouchSize: number
    • LightSource
      • autoLightSourcePosition: boolean
      • autoShadowFrustumSize: boolean
      • autoShadowFrustumSizeExtend: number
      • castsShadows: boolean
      • color: vec4
      • decayLimit: boolean
      • decayRange: number
      • decayType: Editor.Components.DecayType
      • diffuseEnvmapTexture: Editor.Assets.Texture
      • dynamicEnvInputTexture: Editor.Assets.Texture
      • envmapExposure: number
      • envmapFromCameraMode: Editor.Components.EnvmapFromCameraMode
      • envmapRotation: number
      • estimationSharpness: number
      • innerConeAngle: number
      • intensity: number
      • lightType: Editor.Components.LightType
      • outerConeAngle: number
      • shadowBlurRadius: number
      • shadowColor: vec4
      • shadowDensity: number
      • shadowFrustumFarClipPlane: number
      • shadowFrustumNearClipPlane: number
      • shadowFrustumSize: number
      • shadowTextureSize: number
      • specularEnvmapTexture: Editor.Assets.Texture
      • useEnvmapFromCamera: boolean
    • LightType
      • Ambient: number
      • Directional: number
      • EnvMap: number
      • Estimation: number
      • Point: number
      • Spot: number
    • LiquifyVisual
      • intensity: number
      • radius: number
    • LocatedAtComponent
      • location: Editor.Assets.Location
      • position: vec3
    • LookAtComponent
      • aimVectors: Editor.Components.LookAtComponent.AimVectors
      • lookAtMode: Editor.Components.LookAtComponent.LookAtMode
      • offsetRotation: quat
      • target: Editor.Model.SceneObject
      • worldUpVector: Editor.Components.LookAtComponent.WorldUpVector
    • LookAtComponent
      • AimVectors
        • NegativeXAimNegativeYUp: number
        • NegativeXAimNegativeZUp: number
        • NegativeXAimYUp: number
        • NegativeXAimZUp: number
        • NegativeYAimNegativeXUp: number
        • NegativeYAimNegativeZUp: number
        • NegativeYAimXUp: number
        • NegativeYAimZUp: number
        • NegativeZAimNegativeXUp: number
        • NegativeZAimNegativeYUp: number
        • NegativeZAimXUp: number
        • NegativeZAimYUp: number
        • XAimNegativeYUp: number
        • XAimNegativeZUp: number
        • XAimYUp: number
        • XAimZUp: number
        • YAimNegativeXUp: number
        • YAimNegativeZUp: number
        • YAimXUp: number
        • YAimZUp: number
        • ZAimNegativeXUp: number
        • ZAimNegativeYUp: number
        • ZAimXUp: number
        • ZAimYUp: number
      • LookAtMode
        • LookAtDirection: number
        • LookAtPoint: number
      • WorldUpVector
        • ObjectX: number
        • ObjectY: number
        • ObjectZ: number
        • SceneX: number
        • SceneY: number
        • SceneZ: number
        • TargetX: number
        • TargetY: number
        • TargetZ: number
    • ManipulateComponent
      • drag: boolean
      • maxDistance: number
      • maxScale: number
      • minDistance: number
      • minScale: number
      • rotate: boolean
      • scale: boolean
    • MarkerTrackingComponent
      • marker: Editor.Assets.MarkerAsset
    • MaskingComponent
      • cornerRadius: number
    • MaterialMeshVisual
      • mainMaterial: Editor.Assets.Material
      • materials: Editor.Assets.Material[]
      • addMaterialAt(_value: Editor.Assets.Material, _pos: number): void
      • clearMaterials(): void
      • getMaterialAt(_pos: number): Editor.Assets.Material
      • getMaterialsCount(): number
      • indexOfMaterial(_value: Editor.Assets.Material): number
      • moveMaterial(_origin: number, _destination: number): void
      • removeMaterialAt(_pos: number): void
      • setMaterialAt(_pos: number, _value: Editor.Assets.Material): void
    • MeshShadowMode
      • Caster: number
      • None: number
      • Receiver: number
    • ObjectTracking
      • trackingType: Editor.Components.ObjectTrackingType
    • ObjectTracking3D
      • matchingRootObject: Editor.Model.SceneObject
      • objectIndex: number
      • trackPosition: boolean
      • trackingAsset: Editor.Assets.Object3DAsset
      • trackingMode: Editor.Components.ObjectTracking3D.TrackingMode
    • ObjectTracking3D
      • TrackingMode
        • Attachment: number
        • PoseOnly: number
        • ProportionsAndPose: number
    • ObjectTrackingType
      • Cat: number
      • Dog: number
      • FullBody: number
      • Hand: number
      • Nails: number
      • Pet: number
      • Shoulder: number
      • UpperBody: number
    • OutlineSettings
      • enabled: boolean
      • fill: Editor.Components.TextFill
      • size: number
    • Physics
      • BodySetting
        • Density: number
        • Mass: number
      • Constraint
        • Fixed: number
        • Hinge: number
        • Point: number
      • BodyComponent
        • angularDamping: number
        • bodySetting: Editor.Components.Physics.BodySetting
        • bodySettingValue: number
        • damping: number
        • dynamic: boolean
      • Box
        • size: vec3
      • Capsule
        • axis: Editor.Axis
        • length: number
        • radius: number
      • ColliderComponent
        • debugDrawEnabled: boolean
        • filter: Editor.Assets.Physics.Filter
        • fitVisual: boolean
        • forceCompound: boolean
        • intangible: boolean
        • matter: Editor.Assets.Physics.Matter
        • overlapFilter: Editor.Assets.Physics.Filter
        • rotateSmoothFactor: number
        • shape: Editor.Components.Physics.Shape
        • smooth: boolean
        • translateSmoothFactor: number
        • worldSettings: Editor.Assets.Physics.WorldSettingsAsset
      • Cone
        • axis: Editor.Axis
        • length: number
        • radius: number
      • ConstraintComponent
        • constraint: Editor.Components.Physics.Constraint
        • debugDrawEnabled: boolean
        • target: Editor.Components.Physics.ColliderComponent
      • Cylinder
        • axis: Editor.Axis
        • length: number
        • radius: number
      • LevelSet
        • asset: Editor.Assets.Physics.LevelsetColliderAsset
      • Mesh
        • convex: boolean
        • mesh: Editor.Assets.RenderMesh
        • skin: Editor.Components.Skin
      • Shape
      • Sphere
        • radius: number
      • WorldComponent
        • updateOrder: number
        • worldSettings: Editor.Assets.Physics.WorldSettingsAsset
    • PinToMesh
      • Orientation
        • OnlyPosition: number
        • PositionAndDirection: number
    • PinToMeshComponent
      • offsetPosition: vec3
      • offsetRotation: vec3
      • orientation: Editor.Components.PinToMesh.Orientation
      • pinUV: vec2
      • target: Editor.Components.BaseMeshVisual
      • useVertexNormal: boolean
    • PostEffectVisual
    • RectangleSetter
      • cropTexture: Editor.Assets.Texture
    • RenderLayerOwner
      • renderLayer: Editor.Model.LayerSet
    • RenderMeshVisual
      • blendNormals: boolean
      • blendShapesEnabled: boolean
      • mesh: Editor.Assets.RenderMesh
    • RetouchVisual
      • eyeWhiteningIntensity: number
      • faceIndex: number
      • sharpenEyeIntensity: number
      • softSkinIntensity: number
      • teethWhiteningIntensity: number
    • RotationOptions
      • invertRotation: boolean
    • ScreenRegionComponent
      • region: Editor.Components.ScreenRegionType
      • resizeWithKeyboard: boolean
    • ScreenRegionType
      • Capture: number
      • FullFrame: number
      • Preview: number
      • RoundButton: number
      • SafeRender: number
    • ScreenTransform
      • advanced: boolean
      • anchor: Editor.Rect
      • constraints: Editor.Components.ScreenTransformConstraints
      • offset: Editor.Rect
      • pivot: vec2
      • transform: Editor.Transform
    • ScreenTransformConstraints
      • fixedHeight: boolean
      • fixedWidth: boolean
      • pinToBottom: boolean
      • pinToLeft: boolean
      • pinToRight: boolean
      • pinToTop: boolean
    • ScriptComponent
      • scriptAsset: Editor.Assets.ScriptAsset
    • Skin
      • skinBones: object
    • SortingType
      • Depth: number
      • Hierarchy: number
    • StretchMode
      • Fill: number
      • FillAndCut: number
      • Fit: number
      • FitHeight: number
      • FitWidth: number
      • Stretch: number
    • StretchPoint
      • delta: vec3
      • index: number
      • weight: number
    • SurfaceOptions
      • enhanceWithNativeAR: boolean
    • Text
      • advancedLayout: Editor.Components.TextAdvancedLayout
      • backgroundSettings: Editor.Components.BackgroundSettings
      • capitalizationOverride: Editor.Components.CapitalizationOverride
      • depthTest: boolean
      • dropshadowSettings: Editor.Components.DropshadowSettings
      • editable: boolean
      • font: Editor.Assets.Font
      • horizontalOverflow: Editor.Components.HorizontalOverflow
      • letterSpacing: number
      • lineSpacing: number
      • outlineSettings: Editor.Components.OutlineSettings
      • showEditingPreview: boolean
      • size: number
      • sizeToFit: boolean
      • text: string
      • textFill: Editor.Components.TextFill
      • touchHandler: Editor.Components.InteractionComponent
      • twoSided: boolean
      • verticalOverflow: Editor.Components.VerticalOverflow
      • worldSpaceRect: Editor.Rect
    • Text3D
      • advancedLayout: Editor.Components.TextAdvancedLayout
      • capitalizationOverride: Editor.Components.CapitalizationOverride
      • editable: boolean
      • enableBatching: boolean
      • extrudeDirection: Editor.Components.ExtrudeDirection
      • extrusionDepth: number
      • font: Editor.Assets.Font
      • horizontalOverflow: Editor.Components.HorizontalOverflow
      • letterSpacing: number
      • lineSpacing: number
      • showEditingPreview: boolean
      • size: number
      • sizeToFit: boolean
      • text: string
      • touchHandler: Editor.Components.InteractionComponent
      • verticalOverflow: Editor.Components.VerticalOverflow
      • worldSpaceRect: Editor.Rect
    • TextAdvancedLayout
      • capitalizationOverride: Editor.Components.CapitalizationOverride
      • extentsTarget: Editor.Components.ScreenTransform
      • letterSpacing: number
      • lineSpacing: number
    • TextFill
      • color: vec4
      • mode: Editor.Components.TextFillMode
      • texture: Editor.Assets.Texture
      • textureStretch: Editor.Components.StretchMode
      • tileCount: number
      • tileZone: Editor.Components.TextFillTileZone
    • TextFillMode
      • Solid: number
      • Texture: number
    • TextFillTileZone
      • Character: number
      • Extents: number
      • Rect: number
      • Screen: number
    • UnitType
      • Pixels: number
      • Points: number
      • World: number
    • VerticalOverflow
      • Overflow: number
      • Shrink: number
      • Truncate: number
    • Visual
      • renderOrder: number
  • Compression
  • Compression
    • Zip
      • pack(_src: Editor.Path, _destFile: Editor.Path): void
      • unpack(_src: Editor.Path, _destDir: Editor.Path): void
  • ContextAction
    • apply: () => void
    • caption: string
    • description: string
    • group: string[]
    • id: string
  • Dock
  • Dock
    • IDockManager
      • panels: IPanelPlugin[]
      • activate(_panel: IPanelPlugin): void
      • add(_panel: IPanelPlugin): void
      • highlight(_panel: IPanelPlugin): void
      • read(_reader: "LensStudio:Serialization".IReader): void
      • remove(_panel: IPanelPlugin): void
      • write(_writer: "LensStudio:Serialization".IWriter): void
  • IContext
  • IGuard
    • dispose(): void
  • IInterface
  • IOverlayManager
    • requestShow(_overlayID: string): void
  • IPlugin
    • id: string
  • IPluginComponent
  • Icon
    • fromFile(_{absoluteFilePath:} Editor.Path): Editor.Icon
    • fromSvgData(_buffer: string): Editor.Icon
  • InterfaceId
  • Model
    • IEntityPrototypeRegistry: Editor.InterfaceId
    • IEntityRegistry: Editor.InterfaceId
    • IModel: Editor.InterfaceId
  • Model
    • AssetContext
      • selection: Editor.Model.AssetContext.Item[]
    • AssetContext
      • Item
        • asset: Editor.Assets.Asset
        • path: Editor.Path
    • AssetImportMetadata
      • assets: Editor.Assets.Asset[]
      • primaryAsset: Editor.Assets.Asset
      • sourcePath: Editor.Path
      • getNativePackageItems(_{iterateOption:} Editor.Model.AssetImportMetadata.PackageIterate): Editor.Model.AssetImportMetadata[]
      • setExtraDataItem(_key: string, _value: string): void
    • AssetImportMetadata
      • PackageIterate
        • Deep: number
        • Shallow: number
    • AssetManager
      • assets: Editor.Assets.Asset[]
      • assetsDirectory: Editor.Path
      • cacheDirectory: Editor.Path
      • createNativeAsset(_assetType: string, _baseName: string, _{relativeDestinationDir:} Editor.Path): Editor.Assets.Asset
      • createPackage(_{requestedAssets:} Editor.Model.AssetImportMetadata[], _{relativeDestinationDir:} Editor.Path, _packageName: string, _{packageOption:} Editor.Model.PackageOption): Editor.Model.AssetImportMetadata
      • exportAssets(_{requestedAssets:} Editor.Model.AssetImportMetadata[], _{absoluteDestination:} Editor.Path): Editor.Model.AssetImportMetadata[]
      • exportSceneObjects(_{topLevelSceneObjects:} Editor.Model.SceneObject[], _{absoluteDestination:} Editor.Path): Editor.Model.AssetImportMetadata[]
      • findImportedCopy(_{absoluteSourcePath:} Editor.Path): Editor.Model.AssetImportMetadata
      • getFileMeta(_{relativeFilePath:} Editor.Path): Editor.Model.AssetImportMetadata
      • importExternalFile(_{absoluteSourcePath:} Editor.Path, _{relativeDestinationDir:} Editor.Path, _resultType: Editor.Model.ResultType): Editor.Model.ImportResult
      • importExternalFileAsync(_{absoluteSourcePath:} Editor.Path, _{relativeDestinationDir:} Editor.Path, _resultType: Editor.Model.ResultType): Promise
      • move(_fileMeta: Editor.Model.AssetImportMetadata, _{relativeDestinationDir:} Editor.Path): void
      • remove(_{relativeFilePath:} Editor.Path): void
      • rename(_fileMeta: Editor.Model.AssetImportMetadata, _newName: string): void
      • saveAsPrefab(_sceneObject: Editor.Model.SceneObject, _{relativeDestinationDir:} Editor.Path): Editor.Assets.ObjectPrefab
    • BaseChangesStream
      • executeAsGroup(_name: string, _change: () => void): void
    • ChangesStream
    • DeviceType
      • Desktop: number
      • Mobile: number
      • Spectacles: number
      • Unknown: number
    • Entity
      • id: Editor.Uuid
      • type: string
      • getDirectlyReferencedEntities(): Editor.Model.Entity[]
      • getOwnedEntities(): Editor.Model.Entity[]
      • remapReferences(_{referenceMapping:} object): void
    • EntityBaseType
      • Asset: number
      • Component: number
    • EntityPrototypeData
      • baseEntityType: string
      • caption: string
      • creator: any
      • entityType: string
      • icon: Editor.Icon
      • section: string
    • EntityStructure
    • ImportResult
      • files: Editor.Model.AssetImportMetadata[]
      • path: Editor.Path
      • primary: Editor.Assets.Asset
    • Layer
      • id: Editor.Model.LayerId
      • name: string
    • LayerId
      • Default: Editor.Model.LayerId
      • MaxUser: Editor.Model.LayerId
      • MinUser: Editor.Model.LayerId
      • Ortho: Editor.Model.LayerId
      • forEach(_predicate: (arg1: Editor.Model.LayerId) => void): void
      • forEachUser(_predicate: (arg1: Editor.Model.LayerId) => void): void
    • LayerSet
      • PredefinedIds(): Editor.Model.LayerSet
      • contains(_other: Editor.Model.LayerSet): boolean
      • except(_other: Editor.Model.LayerSet): Editor.Model.LayerSet
      • fromBit(_bit: number): Editor.Model.LayerSet
      • fromId(_layerId: Editor.Model.LayerId): Editor.Model.LayerSet
      • fromMask(_mask: number): Editor.Model.LayerSet
      • intersect(_other: Editor.Model.LayerSet): Editor.Model.LayerSet
      • isEmpty(): boolean
      • toArray(): Editor.Model.LayerId[]
      • union(_other: Editor.Model.LayerSet): Editor.Model.LayerSet
    • Layers
      • canAdd: boolean
      • combinedIds: Editor.Model.LayerSet
      • add(_layerId: Editor.Model.LayerId): Editor.Model.Layer
      • contains(_layerId: Editor.Model.LayerId): boolean
      • find(_layerId: Editor.Model.LayerId): Editor.Model.Layer
      • remove(_layerId: Editor.Model.LayerId): void
    • LensActivationCamera
      • Front: number
      • Rear: number
    • LensApplicability
      • Back: number
      • Front: number
    • Meta
      • isAbstract: boolean
    • MetaInfo
      • activationCamera: Editor.Model.LensActivationCamera
      • iconPath: Editor.Path
      • isIconSet: boolean
      • lensApplicability: Editor.Model.LensApplicability[]
      • lensName: string
      • isLensNameValid(_lensName: string): boolean
      • setIcon(_{externalPath:} Editor.Path): void
    • ObjectContext
      • selection: Editor.Model.SceneObject[]
    • PackageOption
      • Packed: number
      • Unpacked: number
    • Prefabable
    • Project
      • assetManager: Editor.Model.AssetManager
      • assetsDirectory: Editor.Path
      • cacheDirectory: Editor.Path
      • history: Editor.Model.ChangesStream
      • metaInfo: Editor.Model.MetaInfo
      • projectDirectory: Editor.Path
      • projectFile: Editor.Path
      • scene: Editor.Assets.Scene
      • onEntityAdded(_typeName: string): signal1
      • onEntityAdding(_typeName: string): signal1
      • onEntityRemoved(_typeName: string): signal1
      • onEntityUpdated(_typeName: string): signal1
      • onEntityUpdating(_typeName: string): signal1
      • save(): void
      • saveTo(_{absoluteFilePath:} Editor.Path): void
    • ResultType
      • Auto: number
      • Packed: number
      • Unpacked: number
    • SceneObject
      • children: Editor.Model.SceneObject[]
      • components: Editor.Components.Component[]
      • enabled: boolean
      • hasVisuals: boolean
      • layer: Editor.Model.LayerId
      • layers: Editor.Model.LayerSet
      • localTransform: Editor.Transform
      • name: string
      • topOwner: Editor.Assets.ObjectOwner
      • worldTransform: Editor.Transform
      • addChildAt(_value: Editor.Model.SceneObject, _pos: number): void
      • addComponent(_entityType: string): Editor.Components.Component
      • addComponentAt(_value: Editor.Components.Component, _pos: number): void
      • clearChildren(): void
      • clearComponents(): void
      • commonParent(_{sceneObjects:} Editor.Model.SceneObject[]): Editor.Model.SceneObject
      • copy(): Editor.Model.SceneObject
      • destroy(): void
      • getChildAt(_pos: number): Editor.Model.SceneObject
      • getChildrenCount(): number
      • getComponent(_entityType: string): ComponentNameMap[K]
      • getComponentAt(_pos: number): Editor.Components.Component
      • getComponents(_entityType: string): ComponentNameMap[K][]
      • getComponentsCount(): number
      • getParent(): Editor.Model.SceneObject
      • indexOfChild(_value: Editor.Model.SceneObject): number
      • indexOfComponent(_value: Editor.Components.Component): number
      • moveChild(_child: Editor.Model.SceneObject, _destination: number): void
      • moveComponent(_origin: number, _destination: number): void
      • removeChild(_child: Editor.Model.SceneObject): void
      • removeChildAt(_pos: number): void
      • removeComponent(_entityType: string): boolean
      • removeComponentAt(_pos: number): void
      • setChildAt(_pos: number, _value: Editor.Model.SceneObject): void
      • setComponentAt(_pos: number, _value: Editor.Components.Component): void
      • setParent(_newParent: Editor.Model.SceneObject, _position: number): void
      • topLevel(_{sceneObjects:} Editor.Model.SceneObject[]): Editor.Model.SceneObject[]
  • Path
    • appended(_path: Editor.Path): Editor.Path
    • extension: string
    • fileName: Editor.Path
    • fileNameBase: string
    • hasExtension(_extension: string): boolean
    • isEmpty: boolean
    • isInside(_directory: Editor.Path): boolean
    • parent: Editor.Path
    • relative(_rootPath: Editor.Path): Editor.Path
    • replaceExtension(_{newExtension:} string): Editor.Path
    • replaceFileNameBase(_name: string): Editor.Path
    • toString(): string
  • PlaybackMode
    • Loop: number
    • PingPong: number
    • Single: number
  • PluginSystem
    • create(_descriptor: IPluginDescriptor): Editor.IPlugin
    • descriptors: IPluginDescriptor[]
    • findInterface(_id: Editor.InterfaceId): Editor.IInterface
    • loadDirectory(_directory: Editor.Path): void
    • unloadDirectory(_directory: Editor.Path): void
  • Point
    • x: number
    • y: number
  • Rect
    • bottom: number
    • create(_left: number, _right: number, _bottom: number, _top: number): Editor.Rect
    • fromMinMax(_min: vec2, _max: vec2): Editor.Rect
    • getCenter(): vec2
    • getSize(): vec2
    • left: number
    • leftBottom: vec2
    • right: number
    • rightTop: vec2
    • setCenter(_center: vec2): void
    • setSize(_size: vec2): void
    • toVec4(): vec4
    • top: number
  • ScopedConnection
    • disconnect(): boolean
    • isConnected: boolean
  • Shape
    • createBoxShape(_scene: Editor.Assets.Scene): Editor.Components.Physics.Box
    • createCapsuleShape(_scene: Editor.Assets.Scene): Editor.Components.Physics.Capsule
    • createConeShape(_scene: Editor.Assets.Scene): Editor.Components.Physics.Cone
    • createCylinderShape(_scene: Editor.Assets.Scene): Editor.Components.Physics.Cylinder
    • createLevelSetShape(_scene: Editor.Assets.Scene): Editor.Components.Physics.LevelSet
    • createMeshShape(_scene: Editor.Assets.Scene): Editor.Components.Physics.Mesh
    • createSphereShape(_scene: Editor.Assets.Scene): Editor.Components.Physics.Sphere
  • Size
    • equal(_value: Editor.Size): boolean
    • fromVec2(_value: vec2): Editor.Size
    • isEmpty(): boolean
    • toVec2(): vec2
    • x: number
    • y: number
  • Transform
    • position: vec3
    • rotation: vec3
    • scale: vec3
  • Uuid
    • isValid(): boolean
    • toString(): string
• IPanelPlugin
• IPluginDescriptor
  • dependencies: Editor.InterfaceId[]
  • description: string
  • id: string
  • interfaces: Editor.InterfaceId[]
  • name: string
• LensStudio:Analytics
• LensStudio:App
  • env: object
  • version: string
• LensStudio:AssetInstantiator
  • AssetInstantiator
    • instantiate(_asset: Editor.Assets.Asset, _scene: Editor.Assets.Scene, _target: Editor.Model.SceneObject): Editor.Model.Prefabable[]
  • Descriptor
    • canInstantiate: (arg1: Editor.Assets.Asset) => any
  • IAssetInstantiator
• LensStudio:AssetLibrary
  • Asset
    • assetId: string
    • assetName: string
    • assetType: "LensStudio:AssetLibrary".AssetType
    • resources: "LensStudio:AssetLibrary".Resource[]
  • AssetFilter
    • categoryId: string
    • pagination: "LensStudio:AssetLibrary".Pagination
    • searchText: string
  • AssetListRequest
    • assetFilter: "LensStudio:AssetLibrary".AssetFilter
    • environmentSetting: "LensStudio:AssetLibrary".EnvironmentSetting
  • AssetListResponse
  • AssetListService
    • fetch(_request: "LensStudio:AssetLibrary".AssetListRequest, _onSuccess: (arg1: "LensStudio:AssetLibrary".AssetListSuccess) => void, _onFailure: (arg1: "LensStudio:AssetLibrary".ServiceError) => void): void
  • AssetListSuccess
    • assets: "LensStudio:AssetLibrary".Asset[]
  • AssetType
    • AnimatedTexture: number
    • Audio: number
    • CustomComponent: number
    • Guide: number
    • Invalid: number
    • MLModel: number
    • Material: number
    • Mesh3D: number
    • Music: number
    • ObjectPrefab: number
    • ObjectPreset: number
    • Plugin: number
    • ProjectTemplate: number
    • RemoteApi: number
    • Script: number
    • Texture: number
    • Video: number
  • Environment
    • Invalid: number
    • Production: number
    • Staging: number
  • EnvironmentSetting
    • environment: "LensStudio:AssetLibrary".Environment
    • space: "LensStudio:AssetLibrary".Space
  • IAssetLibraryProvider: Editor.InterfaceId
  • Pagination
    • limit: number
    • offset: number
    • singleBatch(_offset: number, _limit: number): "LensStudio:AssetLibrary".Pagination
  • Resource
    • name: string
    • uri: string
  • ServiceError
    • description: string
  • Space
    • Internal: number
    • Invalid: number
    • Public: number
• LensStudio:AssetUtils.js
  • ShaderGraphType
    • ShaderGraphGltf: undefined
    • ShaderGraphImage: undefined
    • ShaderGraphOccluder: undefined
    • ShaderGraphUberPbr: undefined
    • ShaderGraphUnlit: undefined
  • addDefine(_passInfo: Editor.Assets.PassInfo, _define: string): void
  • addGraphToMaterial(_material: Editor.Assets.Material, _pass: Editor.Assets.Pass, _{addDefineStrings:} string[]): Editor.Assets.PassInfo
  • createMaterialFromGraph(_{assetManager:} Editor.Model.AssetManager, _graphType: "LensStudio:AssetUtils.js".ShaderGraphType, _materialDir: string, _{materialName:} string, _{shaderGraphDir:} string): Promise
  • findAsset(_{assetManager:} Editor.Model.AssetManager, _assetType: string, _assetName: string, _parentDir: Editor.Path): Editor.Assets.Asset[]
  • findOrCreateNativeAsset(_{nativeAssetTypeName:} string, _{assetManager:} Editor.Model.AssetManager, _basename: string, _{destinationDir:} Editor.Path): Editor.Assets.Asset
  • findOrCreateNonNativeAsset(_{assetManager:} Editor.Model.AssetManager, _{assetAbsPath:} Editor.Path, _{destDirInProject:} Editor.Path): Promise
  • findOrCreateObjectTrackingTexture(_{assetManager:} Editor.Model.AssetManager, _destination: Editor.Path, _type: Editor.Assets.ObjectTrackingTextureType): Editor.Assets.Asset
  • findOrCreateScreenTexture(_{assetManager:} Editor.Model.AssetManager, _destination: Editor.Path): Editor.Assets.Asset
  • getResourceFile(_assetType: "LensStudio:AssetUtils.js".ShaderGraphType): Editor.Path
  • importImageAsTexture(_{assetManager:} Editor.Model.AssetManager, _{imageFileAbsolutePath:} string, _wrapMode: Editor.Assets.WrapMode, _{imageImportDestinationDir:} string): Promise
  • setupSamplerWrapMode(_sampler: Editor.Assets.Sampler, _wrapModeU: Editor.Assets.WrapMode, _wrapModeV: Editor.Assets.WrapMode, _wrapModeW: Editor.Assets.WrapMode): Editor.Assets.Sampler
• LensStudio:ChatAssistant
• LensStudio:CoreService
  • CoreService
    • pluginSystem: Editor.PluginSystem
    • start(): void
    • stop(): void
  • Descriptor
• LensStudio:DialogPlugin
  • Descriptor
    • menuActionHierarchy: string[]
    • toolbarConfig: "LensStudio:Ui".ToolbarConfig
  • DialogPlugin
    • pluginSystem: Editor.PluginSystem
    • show(_parent: "LensStudio:Ui".Widget): "LensStudio:Ui".Dialog
• LensStudio:EditorPlugin
  • Descriptor
    • canEdit: (arg1: Editor.Model.Entity) => any
    • toolbarConfig: "LensStudio:Ui".ToolbarConfig
  • EditorPlugin
    • createWidget(_parent: "LensStudio:Ui".Widget): "LensStudio:Ui".Widget
    • edit(_entities: Editor.Model.Entity[]): boolean
    • pluginSystem: Editor.PluginSystem
• LensStudio:FileSystem
  • CopyDirOptions
    • force: boolean
    • recursive: boolean
  • CreateDirOptions
    • recursive: boolean
  • ReadDirOptions
    • recursive: boolean
  • TempDir
    • create(): "LensStudio:FileSystem".TempDir
    • path: Editor.Path
  • Watcher
    • create(_path: Editor.Path): "LensStudio:FileSystem".Watcher
    • isWatching: boolean
    • onAdded: signal1
    • onModified: signal1
    • onMoved: signal2
    • onRemoved: signal1
    • path: Editor.Path
    • start(): void
    • stop(): void
  • copyDir(_src: Editor.Path, _dest: Editor.Path, _options: "LensStudio:FileSystem".CopyDirOptions): void
  • copyFile(_src: Editor.Path, _dest: Editor.Path): void
  • createDir(_path: Editor.Path, _options: "LensStudio:FileSystem".CreateDirOptions): void
  • exists(_path: Editor.Path): boolean
  • isDirectory(_path: Editor.Path): boolean
  • isFile(_path: Editor.Path): boolean
  • readBytes(_path: Editor.Path): Uint8Array
  • readDir(_path: Editor.Path, _options: "LensStudio:FileSystem".ReadDirOptions): Editor.Path[]
  • readFile(_path: Editor.Path): string
  • realPath(_path: Editor.Path): Editor.Path
  • remove(_path: Editor.Path): void
  • rename(_oldPath: Editor.Path, _newPath: Editor.Path): void
  • size(_path: Editor.Path): number
  • writeFile(_path: Editor.Path, _data: string|Uint8Array): void
• LensStudio:GeneralUtils.js
  • promisify(_fn: (callback: (err: Error, result: T) => void) => void): Promise
• LensStudio:GuiService
  • Descriptor
  • GuiService
    • pluginSystem: Editor.PluginSystem
    • start(): void
    • stop(): void
  • IGuiService
• LensStudio:HierarchyUtils.js
  • CreateOptions
    • componentType: string|string[]
    • name: string
    • parent: Editor.Model.SceneObject
    • scene: Editor.Assets.Scene
  • SearchOptions
    • createIfNotFound: boolean
    • createOptions: "LensStudio:HierarchyUtils.js".CreateOptions
    • findAll: boolean
    • maxDepth: number
  • createOrthoCameraOnObject(_scene: Editor.Assets.Scene, _sceneObject: Editor.Model.SceneObject, _unitType: Editor.Components.UnitType, _renderLayer: Editor.Model.LayerId): Editor.Model.SceneObject
  • createPerspectiveCameraOnObject(_scene: Editor.Assets.Scene, _sceneObject: Editor.Model.SceneObject, _renderLayer: Editor.Model.LayerId): Editor.Model.SceneObject
  • findInAncestorsByName(_base: Editor.Model.SceneObject, _name: string, _options: "LensStudio:HierarchyUtils.js".SearchOptions): Editor.Model.SceneObject[]
  • findInAncestorsByType(_base: Editor.Model.SceneObject, _{componentType:} string, _options: "LensStudio:HierarchyUtils.js".SearchOptions): Editor.Model.SceneObject[]
  • findInDescendantsByName(_base: Editor.Assets.Scene|Editor.Model.SceneObject, _name: string, _options: "LensStudio:HierarchyUtils.js".SearchOptions): Editor.Model.SceneObject[]
  • findInDescendantsByType(_base: Editor.Assets.Scene|Editor.Model.SceneObject, _{componentType:} string, _options: "LensStudio:HierarchyUtils.js".SearchOptions): Editor.Model.SceneObject[]
  • findInRootObjectsByName(_scene: Editor.Assets.Scene, _name: string, _options: "LensStudio:HierarchyUtils.js".SearchOptions): Editor.Model.SceneObject[]
  • findInRootObjectsByType(_scene: Editor.Assets.Scene, _{componentType:} string, _options: "LensStudio:HierarchyUtils.js".SearchOptions): Editor.Model.SceneObject[]
  • findNearestCameraInAncestors(_{baseSceneObject:} Editor.Model.SceneObject, _cameraType: Editor.Components.CameraType, _maxDepth: number): Editor.Model.SceneObject
  • findOrCreateCameraObject(_scene: Editor.Assets.Scene, _cameraType: Editor.Components.CameraType, _{bearerSceneObject:} Editor.Model.SceneObject): Editor.Model.SceneObject
  • findOrCreateChildWithName(_rootObject: Editor.Model.SceneObject, _name: string, _scene: Editor.Assets.Scene): Editor.Model.SceneObject
  • findOrCreateOrthoCameraForObject(_scene: Editor.Assets.Scene, _sceneObject: Editor.Model.SceneObject, _{canvasUnitType:} Editor.Components.UnitType):
  • getFirstCameraInScene(_scene: Editor.Assets.Scene, _cameraType: Editor.Components.CameraType): Editor.Model.SceneObject
  • getNearestOrFirstCamera(_sceneObject: Editor.Model.SceneObject, _scene: Editor.Assets.Scene, _cameraType: Editor.Components.CameraType): Editor.Model.SceneObject
  • getOrCreateCanvas(_{cameraObject:} Editor.Model.SceneObject, _unitType: Editor.Components.UnitType): Editor.Components.Canvas
  • getOrCreateScreenRegion(_{cameraObject:} Editor.Model.SceneObject, _scene: Editor.Assets.Scene): Editor.Components.ScreenRegionComponent
• LensStudio:LcaUtils.js
  • attachLCAHeader(_request: "LensStudio:Network".HttpRequest, _issuer: string): void
• LensStudio:LensBasedEditorView
• LensStudio:ModelUi
  • EntityReferencePickerLine
    • create(_{assetManager:} Editor.Model.AssetManager, _{entityPrototypeRegistry:} IEntityPrototypeRegistry, _entityType: string, _widget: "LensStudio:Ui".Widget): "LensStudio:ModelUi".EntityReferencePickerLine
    • onAssetHighlight: signal0
    • onEntityClear: signal0
    • onEntityDrop: signal1
    • onEntitySelect: signal0
• LensStudio:MultimediaWidgets
• LensStudio:Network
  • Address
    • address: string
    • port: number
  • BaseServer
    • address: string
    • close(): void
    • listen(_address: "LensStudio:Network".Address): boolean
    • onConnect: signal1
    • onError: signal1
    • port: number
  • BaseSocket
    • close(): void
    • destroy(): void
    • localAddress: "LensStudio:Network".Address
    • onData: signal1
    • onEnd: signal0
    • onError: signal1
    • remoteAddress: "LensStudio:Network".Address
  • FormData
    • append(_body: string|Uint8Array, _headers: object): void
  • HttpReply
    • onData: signal1
    • onEnd: signal1
    • onError: signal1
  • HttpRequest
    • authorization: IAuthorization
    • body: string|Uint8Array|"LensStudio:Network".FormData
    • contentType: string
    • headers: object
    • method: "LensStudio:Network".HttpRequest.Method
    • url: string
  • HttpRequest
    • Method
      • Delete: number
      • Get: number
      • Post: number
      • Put: number
  • HttpResponse
    • body: Editor.Buffer
    • contentType: string
    • error: string
    • headers: object
    • statusCode: number
  • TcpServer
    • create(): "LensStudio:Network".TcpServer
  • TcpSocket
    • write(_data: string|Uint8Array): number
  • performAuthorizedHttpRequest(_request: "LensStudio:Network".HttpRequest, _callback: (arg1: "LensStudio:Network".HttpResponse) => void): void
  • performHttpRequest(_request: "LensStudio:Network".HttpRequest, _callback: (arg1: "LensStudio:Network".HttpResponse) => void): void
  • performHttpRequestWithReply(_request: "LensStudio:Network".HttpRequest): "LensStudio:Network".HttpReply
• LensStudio:OverlayPlugin
  • Descriptor
  • OverlayPlugin
    • createWidget(_parent: "LensStudio:Ui".Widget): "LensStudio:Ui".Widget
    • pluginSystem: Editor.PluginSystem
    • requestHide(): void
    • requestShow(): void
• LensStudio:PanelPlugin
  • Descriptor
    • defaultDockState: "LensStudio:Ui".DockState
    • defaultSize: "LensStudio:Ui".Size
    • isUnique: boolean
    • menuActionHierarchy: string[]
    • minimumSize: "LensStudio:Ui".Size
    • toolbarConfig: "LensStudio:Ui".ToolbarConfig
  • PanelPlugin
    • createWidget(_parent: "LensStudio:Ui".Widget): "LensStudio:Ui".Widget
    • pluginSystem: Editor.PluginSystem
• LensStudio:PluginVerifier
  • Descriptor
    • canVerify: (arg1: IPluginDescriptor) => any
  • PluginVerifier
    • pluginSystem: Editor.PluginSystem
    • verify(_{pluginDescriptor:} IPluginDescriptor, _outputDir: Editor.Path): any
• LensStudio:Preset
  • Descriptor
    • entityType: string
    • icon: Editor.Icon
    • section: string
  • Preset
    • create(_destination: Editor.Path|Editor.Model.SceneObject): Editor.Model.Entity
    • createAsync(_destination: Editor.Path|Editor.Model.SceneObject): Promise
    • pluginSystem: Editor.PluginSystem
• LensStudio:ProjectSettingsPlugin
  • Descriptor
    • icon: Editor.Icon
    • section: string
    • title: string
  • ProjectSettingsPlugin
    • createWidget(_parent: "LensStudio:Ui".Widget): "LensStudio:Ui".Widget
    • pluginSystem: Editor.PluginSystem
    • setIssues(_issues: "LensStudio:Ui".ProjectSettings.Error|"LensStudio:Ui".ProjectSettings.Warning|"LensStudio:Ui".ProjectSettings.NoIssue[]): void
• LensStudio:RemoteServiceModule
  • RemoteApiRequest
    • body: string|Uint8Array
    • create(): "LensStudio:RemoteServiceModule".RemoteApiRequest
    • endpoint: string
    • parameters: object
    • specId: string
  • RemoteApiResponse
    • body: Editor.Buffer
    • linkedResources: "LensStudio:RemoteServiceModule".RemoteApiResponse.LinkedResource[]
    • statusCode: number
  • RemoteApiResponse
    • LinkedResource
      • url: string
  • performApiRequest(_request: "LensStudio:RemoteServiceModule".RemoteApiRequest, _callback: (arg1: "LensStudio:RemoteServiceModule".RemoteApiResponse) => void): void
• LensStudio:Serialization
  • IReader
  • IWriter
    • getString(): string
  • Yaml
    • createReader(_data: string): "LensStudio:Serialization".IReader
    • createWriter(): "LensStudio:Serialization".IWriter
• LensStudio:Shell
  • openUrl(_baseUrl: string, _queryData: object): boolean
  • showItemInFolder(_path: Editor.Path): void
• LensStudio:Subprocess
  • ExitStatus
    • CrashExit: number
    • NormalExit: number
  • ProcessError
    • Crashed: number
    • FailedToStart: number
    • ReadError: number
    • Timedout: number
    • UnknownError: number
    • WriteError: number
  • ProcessState
    • Idle: number
    • Running: number
    • Starting: number
  • SpawnOptions
    • cwd: Editor.Path
    • env: object
    • timeout: number
  • SpawnSyncResult
    • exitCode: number
    • stderr: Editor.Buffer
    • stdout: Editor.Buffer
  • Subprocess
    • command: string
    • create(_command: string, _args: string[], _options: "LensStudio:Subprocess".SpawnOptions): "LensStudio:Subprocess".Subprocess
    • kill(): void
    • onError: signal1
    • onExit: signal2
    • onStart: signal0
    • onStateChange: signal1
    • start(): void
    • stderr: signal1
    • stdin: "LensStudio:Subprocess".Writable
    • stdout: signal1
  • Writable
    • write(_data: string|Uint8Array): number
  • spawn(_command: string, _args: string[], _options: "LensStudio:Subprocess".SpawnOptions): "LensStudio:Subprocess".Subprocess
  • spawnSync(_command: string, _args: string[], _options: "LensStudio:Subprocess".SpawnOptions): "LensStudio:Subprocess".SpawnSyncResult
• LensStudio:SysInfo
  • productType: string
• LensStudio:Ui
  • AbstractButton
    • checked: boolean
    • setIcon(_icon: Editor.Icon): void
    • setIconSize(_w: number, _h: number): void
    • text: string
  • Action
    • blockSignals(_blocked: boolean): void
    • checkable: boolean
    • checked: boolean
    • create(_caption: "LensStudio:Ui".Widget): "LensStudio:Ui".Action
    • icon: Editor.Icon
    • iconVisibleInMenu: boolean
    • onToggle: signal1
    • onTrigger: signal1
    • text: string
    • toolTip: string
  • Alignment
    • AlignAbsolute: number
    • AlignBaseline: number
    • AlignBottom: number
    • AlignCenter: number
    • AlignHCenter: number
    • AlignHorizontal_Mask: number
    • AlignJustify: number
    • AlignLeading: number
    • AlignLeft: number
    • AlignRight: number
    • AlignTop: number
    • AlignTrailing: number
    • AlignVCenter: number
    • AlignVertical_Mask: number
    • Default: number
  • ArrowPosition
    • Bottom: number
    • Top: number
  • AspectRatioMode
    • IgnoreAspectRatio: number
    • KeepAspectRatio: number
    • KeepAspectRatioByExpanding: number
  • BackgroundRole
    • ButtonBackground: number
    • ComponentBackground: number
    • CtaBackground: number
    • InputBackground: number
    • PanelBackground: number
    • PopupBackground: number
    • WindowBackground: number
  • BoxLayout
    • addLayout(_layout: "LensStudio:Ui".Layout): void
    • addStretch(_stretch: number): void
    • addWidgetWithStretch(_widget: "LensStudio:Ui".Widget, _stretch: number, _alignment: "LensStudio:Ui".Alignment): void
    • create(): "LensStudio:Ui".BoxLayout
    • setDirection(_direction: "LensStudio:Ui".Direction): void
  • CalloutFrame
    • create(_widget: "LensStudio:Ui".Widget): "LensStudio:Ui".CalloutFrame
  • CheckBox
    • checkState: "LensStudio:Ui".CheckState
    • create(_widget: "LensStudio:Ui".Widget): "LensStudio:Ui".CheckBox
    • onToggle: signal1
  • CheckState
    • Checked: number
    • PartiallyChecked: number
    • Unchecked: number
  • ClearLayoutBehavior
    • DeleteClearedWidgets: number
    • KeepClearedWidgets: number
  • ClickableLabel
    • create(_widget: "LensStudio:Ui".Widget): "LensStudio:Ui".ClickableLabel
    • onClick: signal0
  • CollapsiblePanel
    • clearContent(): void
    • create(_icon: Editor.Icon, _text: string, _widget: "LensStudio:Ui".Widget): "LensStudio:Ui".CollapsiblePanel
    • customBackgroundRole: "LensStudio:Ui".BackgroundRole
    • expand(_value: boolean): void
    • expandable: boolean
    • onExpand: signal1
    • overrideBackgroundRole: boolean
    • setContentWidget(_widget: "LensStudio:Ui".Widget): void
  • Color
    • alpha: number
    • blue: number
    • green: number
    • red: number
  • ColorButton
    • alphaEnabled: boolean
    • colorAccepted: signal1
    • colorRejected: signal1
    • colorValueChanged: signal1
    • create(_widget: "LensStudio:Ui".Widget): "LensStudio:Ui".ColorButton
    • currentColor: "LensStudio:Ui".Color
    • dialogClosed: signal0
    • dialogCreated: signal1
    • isDialogActive: boolean
    • lastAcceptedColor: "LensStudio:Ui".Color
    • setAutoUpdateToolTip(_{autoUpdateToolTip:} boolean): void
  • ColorRole
    • AlternateBase: number
    • Base: number
    • BrightText: number
    • Button: number
    • ButtonText: number
    • Dark: number
    • Highlight: number
    • HighlightedText: number
    • Light: number
    • Link: number
    • LinkVisited: number
    • Mid: number
    • Midlight: number
    • NoRole: number
    • PlaceholderText: number
    • Shadow: number
    • Text: number
    • ToolTipBase: number
    • ToolTipText: number
    • Window: number
    • WindowText: number
  • ComboBox
    • addIconItem(_icon: Editor.Icon, _text: string): void
    • addItem(_text: string): void
    • create(_widget: "LensStudio:Ui".Widget): "LensStudio:Ui".ComboBox
    • currentText: string
    • onCurrentTextChange: signal1
    • setItemIcon(_index: number, _icon: Editor.Icon): void
  • ContextMenuPolicy
    • ActionsContextMenu: number
    • CustomContextMenu: number
    • DefaultContextMenu: number
    • NoContextMenu: number
    • PreventContextMenu: number
  • Dialog
    • close(): void
    • create(_widget: "LensStudio:Ui".Widget): "LensStudio:Ui".Dialog
    • onClose: signal0
    • show(): void
  • Dialogs
    • Options
      • DirectoriesOnly: number
      • Usual: number
    • Params
      • caption: string
      • filter: string
      • options: "LensStudio:Ui".Dialogs.Options
  • Direction
    • BottomToTop: number
    • LeftToRight: number
    • RightToLeft: number
    • TopToBottom: number
  • DockState
    • Attached: number
    • Detached: number
  • DoubleSpinBox
    • create(_widget: "LensStudio:Ui".Widget): "LensStudio:Ui".DoubleSpinBox
    • onValueChange: signal1
    • setRange(_min: number, _max: number): void
    • singleStep: number
    • value: number
  • FontRole
    • Default: number
    • DefaultBold: number
    • DefaultItalic: number
    • DefaultUnderlined: number
    • First: number
    • LargeTitle: number
    • LargeTitleBold: number
    • MediumTitle: number
    • MediumTitleBold: number
    • Monospace: number
    • Small: number
    • SmallTitle: number
    • Title: number
    • TitleBold: number
  • GridLayout
    • addLayout(_layout: "LensStudio:Ui".Layout, _row: number, _column: number, _alignment: "LensStudio:Ui".Alignment): void
    • addWidgetAt(_widget: "LensStudio:Ui".Widget, _row: number, _column: number, _alignment: "LensStudio:Ui".Alignment): void
    • addWidgetWithSpan(_widget: "LensStudio:Ui".Widget, _fromRow: number, _fromColumn: number, _rowSpan: number, _columnSpan: number, _alignment: "LensStudio:Ui".Alignment): void
    • create(): "LensStudio:Ui".GridLayout
    • getColumnMinimumWidth(_column: number): number
    • getColumnStretch(_column: number): number
    • getRowMinimumHeight(_row: number): number
    • getRowStretch(_row: number): number
    • setColumnMinimumWidth(_column: number, _minSize: number): void
    • setColumnStretch(_column: number, _stretch: number): void
    • setRowMinimumHeight(_row: number, _minSize: number): void
    • setRowStretch(_row: number, _stretch: number): void
  • Gui
  • IDialogs
    • selectFileToOpen(_params: "LensStudio:Ui".Dialogs.Params, _defaultPath: Editor.Path): Editor.Path
    • selectFileToSave(_params: "LensStudio:Ui".Dialogs.Params, _defaultPath: Editor.Path): Editor.Path
    • selectFilesToOpen(_params: "LensStudio:Ui".Dialogs.Params, _defaultPath: Editor.Path): Editor.Path[]
    • selectFolderToOpen(_params: "LensStudio:Ui".Dialogs.Params, _defaultPath: Editor.Path): Editor.Path
    • selectFolderToSave(_params: "LensStudio:Ui".Dialogs.Params, _defaultPath: Editor.Path): Editor.Path
  • IGui: Editor.InterfaceId
  • IWorkspaceManager
    • all: "LensStudio:Ui".Workspaces.Workspace[]
    • create(_descriptor: "LensStudio:Ui".Workspaces.Descriptor): "LensStudio:Ui".Workspaces.Workspace
    • onAboutToBeActivated: signal1
    • onAboutToBeAdded: signal1
    • onAboutToBeDeactivated: signal1
    • onAboutToBeRemoved: signal1
    • onActivated: signal1
    • onAdded: signal1
    • onDeactivated: signal1
    • onRemoved: signal1
    • readDescriptor(_{presetDirPath:} Editor.Path): "LensStudio:Ui".Workspaces.Descriptor
    • register(_descriptor: "LensStudio:Ui".Workspaces.Descriptor): "LensStudio:Ui".Workspaces.PresetHandle
    • unregister(_handle: "LensStudio:Ui".Workspaces.PresetHandle): void
  • IconMode
    • MonoChrome: number
    • Regular: number
  • ImageView
    • create(_widget: "LensStudio:Ui".Widget): "LensStudio:Ui".ImageView
    • onClick: signal0
    • onHover: signal1
    • pixmap: "LensStudio:Ui".Pixmap
    • radius: number
    • responseHover: boolean
    • scaledContents: boolean
  • Label
    • create(_widget: "LensStudio:Ui".Widget): "LensStudio:Ui".Label
    • onLinkActivate: signal1
    • openExternalLinks: boolean
    • text: string
    • wordWrap: boolean
  • Layout
    • addWidget(_widget: "LensStudio:Ui".Widget): void
    • clear(_behavior: "LensStudio:Ui".ClearLayoutBehavior): void
    • deleteLater(): void
    • enabled: boolean
    • isNull: boolean
    • setContentsMargins(_left: number, _top: number, _right: number, _bottom: number): void
    • setLayoutAlignment(_layout: "LensStudio:Ui".Layout, _alignment: "LensStudio:Ui".Alignment): boolean
    • setWidgetAlignment(_widget: "LensStudio:Ui".Widget, _alignment: "LensStudio:Ui".Alignment): boolean
    • spacing: number
  • LineEdit
    • create(_widget: "LensStudio:Ui".Widget): "LensStudio:Ui".LineEdit
    • icon: Editor.Icon
    • onTextChange: signal1
    • placeholderText: string
    • text: string
  • Menu
    • addAction(_action: "LensStudio:Ui".Action): void
    • addMenu(_caption: string): "LensStudio:Ui".Menu
    • addSeparator(): void
    • create(_parent: "LensStudio:Ui".Widget): "LensStudio:Ui".Menu
    • popup(_target: "LensStudio:Ui".Widget): void
  • Movie
    • create(_filename: Editor.Path): "LensStudio:Ui".Movie
    • height: number
    • resize(_width: number, _height: number): void
    • speed: number
    • width: number
  • MovieView
    • animated: boolean
    • create(_widget: "LensStudio:Ui".Widget): "LensStudio:Ui".MovieView
    • movie: "LensStudio:Ui".Movie
    • onClick: signal0
    • onHover: signal1
    • responseHover: boolean
    • scaledContents: boolean
  • Orientation
    • Horizontal: number
    • Vertical: number
  • OverflowToolBar
    • addStretch(_section: "LensStudio:Ui".Section, _stretch: number): void
    • addWidget(_widget: "LensStudio:Ui".Widget, _section: "LensStudio:Ui".Section, _action: "LensStudio:Ui".Action): void
    • create(_widget: "LensStudio:Ui".Widget): "LensStudio:Ui".OverflowToolBar
  • Pixmap
    • aspectRatioMode: "LensStudio:Ui".AspectRatioMode
    • create(_filename: Editor.Path): "LensStudio:Ui".Pixmap
    • crop(_rect: "LensStudio:Ui".Rect): void
    • height: number
    • load(_filename: Editor.Path): void
    • resize(_width: number, _height: number): void
    • save(_filename: Editor.Path): void
    • transformationMode: "LensStudio:Ui".TransformationMode
    • width: number
  • PopupWithArrow
    • close(): void
    • create(_widget: "LensStudio:Ui".Widget, _{arrowPosition:} "LensStudio:Ui".ArrowPosition): "LensStudio:Ui".PopupWithArrow
    • popup(_target: "LensStudio:Ui".Widget): void
    • setMainWidget(_widget: "LensStudio:Ui".Widget): void
  • ProgressBar
    • create(_widget: "LensStudio:Ui".Widget): "LensStudio:Ui".ProgressBar
    • maximum: number
    • minimum: number
    • setRange(_minimum: number, _maximum: number): void
    • value: number
  • ProgressIndicator
    • create(_widget: "LensStudio:Ui".Widget): "LensStudio:Ui".ProgressIndicator
    • start(): void
    • stop(): void
  • ProjectSettings
    • Error
      • description: string
    • NoIssue
    • Warning
      • description: string
  • PushButton
    • create(_widget: "LensStudio:Ui".Widget): "LensStudio:Ui".PushButton
    • onClick: signal0
    • primary: boolean
    • setIconMode(_iconMode: "LensStudio:Ui".IconMode): void
    • setIconWithMode(_icon: Editor.Icon, _iconMode: "LensStudio:Ui".IconMode): void
  • RadioButton
    • create(_widget: "LensStudio:Ui".Widget): "LensStudio:Ui".RadioButton
    • onClick: signal0
  • RadioButtonGroup
    • addButton(_button: "LensStudio:Ui".AbstractButton, _id: number): void
    • clearSelection(): void
    • create(_widget: "LensStudio:Ui".Widget): "LensStudio:Ui".RadioButtonGroup
    • currentIndex: number
    • currentItem: "LensStudio:Ui".AbstractButton
    • spacing: number
  • Rect
  • SearchLineEdit
    • create(_widget: "LensStudio:Ui".Widget): "LensStudio:Ui".SearchLineEdit
  • Section
    • Center: number
    • Left: number
    • Right: number
  • Separator
    • create(_orientation: "LensStudio:Ui".Orientation, _shadow: "LensStudio:Ui".Shadow, _widget: "LensStudio:Ui".Widget): "LensStudio:Ui".Separator
  • Shadow
    • Plain: number
    • Raised: number
    • Sunken: number
  • Size
    • height: number
    • width: number
  • SizePolicy
    • Policy
      • Expanding: number
      • Fixed: number
      • Ignored: number
      • Maximum: number
      • Minimum: number
      • MinimumExpanding: number
      • Preferred: number
  • Sizes
    • ButtonDelegateSide: number
    • ButtonHeight: number
    • ButtonRadius: number
    • CheckBoxDrawedDiameter: number
    • CheckBoxOutlineWidth: number
    • CheckboxFocusPadding: number
    • CheckboxPadding: number
    • CheckboxRadius: number
    • DialogContentMargin: number
    • DoublePadding: number
    • DragIconSizeHeight: number
    • DragIconSizeWidth: number
    • ExtentIconSide: number
    • HalfPadding: number
    • IconSide: number
    • InputHeight: number
    • InputRadius: number
    • MenuItemHeight: number
    • MessageBoxIconSide: number
    • Padding: number
    • PaddingLarge: number
    • ProgressBarHeight: number
    • RoundedPixmapRadius: number
    • SeparatorContentsMargin: number
    • SeparatorLineWidth: number
    • SizeGripSizeHeight: number
    • SizeGripSizeWidth: number
    • Spacing: number
    • SpinboxButtonHeight: number
    • SpinboxButtonWidth: number
    • SpinboxDefaultWidth: number
    • SplitterHandleWidth: number
    • TextEditHeight: number
    • ToolButtonPadding: number
    • ViewElidingGradientWidth: number
    • ViewIndentation: number
    • ViewSectionHeight: number
  • Slider
    • create(_widget: "LensStudio:Ui".Widget): "LensStudio:Ui".Slider
    • onValueChange: signal1
    • setRange(_min: number, _max: number): void
    • singleStep: number
    • value: number
  • SpinBox
    • create(_widget: "LensStudio:Ui".Widget): "LensStudio:Ui".SpinBox
    • onValueChange: signal1
    • setRange(_min: number, _max: number): void
    • step: number
    • value: number
  • StackedLayout
    • addWidgetAt(_widget: "LensStudio:Ui".Widget, _index: number): number
    • create(): "LensStudio:Ui".StackedLayout
    • currentIndex: number
    • onCurrentChanged: signal1
    • stackingMode: "LensStudio:Ui".StackingMode
  • StackedWidget
    • addWidget(_widget: "LensStudio:Ui".Widget): number
    • create(_widget: "LensStudio:Ui".Widget): "LensStudio:Ui".StackedWidget
    • currentIndex: number
    • currentWidget: "LensStudio:Ui".Widget
  • StackingMode
    • StackAll: number
    • StackOne: number
  • StatusIndicator
    • create(_text: string, _widget: "LensStudio:Ui".Widget): "LensStudio:Ui".StatusIndicator
    • start(): void
    • stop(): void
    • text: string
  • TabBar
    • addTab(_text: string): void
    • create(_widget: "LensStudio:Ui".Widget): "LensStudio:Ui".TabBar
    • currentIndex: number
    • onCurrentChange: signal1
    • setTabIcon(_index: number, _icon: Editor.Icon): void
  • TextEdit
    • acceptRichText: boolean
    • create(_widget: "LensStudio:Ui".Widget): "LensStudio:Ui".TextEdit
    • onTextChange: signal0
    • placeholderText: string
    • plainText: string
  • ToolButton
    • checkable: boolean
    • create(_parent: "LensStudio:Ui".Widget): "LensStudio:Ui".ToolButton
    • onClick: signal0
    • setDefaultAction(_action: "LensStudio:Ui".Action): void
  • ToolbarConfig
    • caption: string
    • icon: Editor.Icon
    • settings: "LensStudio:Ui".ToolbarSettings
  • ToolbarPosition
    • Left: number
    • Right: number
  • ToolbarSettings
    • position: "LensStudio:Ui".ToolbarPosition
    • primary: boolean
    • priority: number
    • showText: boolean
  • TransformationMode
    • FastTransformation: number
    • SmoothTransformation: number
  • VerticalScrollArea
    • create(_widget: "LensStudio:Ui".Widget): "LensStudio:Ui".VerticalScrollArea
    • maximum: number
    • minimum: number
    • onValueChange: signal1
    • setWidget(_widget: "LensStudio:Ui".Widget): void
    • value: number
  • WebEngineView
    • create(_parent: "LensStudio:Ui".Widget): "LensStudio:Ui".WebEngineView
    • load(_url: string): void
    • onLoadFinished: signal1
    • onLoadStarted: signal0
  • Widget
    • activateWindow(): void
    • adjustSize(): void
    • autoFillBackground: boolean
    • backgroundRole: "LensStudio:Ui".ColorRole
    • blockSignals(_blocked: boolean): void
    • contextMenuPolicy: "LensStudio:Ui".ContextMenuPolicy
    • create(_widget: "LensStudio:Ui".Widget): "LensStudio:Ui".Widget
    • deleteLater(): void
    • devicePixelRatio: number
    • enabled: boolean
    • fontRole: "LensStudio:Ui".FontRole
    • foregroundRole: "LensStudio:Ui".ColorRole
    • grab(): "LensStudio:Ui".Pixmap
    • height: number
    • hidden: boolean
    • isNull: boolean
    • layout: "LensStudio:Ui".Layout
    • move(_ax: number, _ay: number): void
    • onHide: signal0
    • onResize: signal2
    • onShow: signal0
    • raise(): void
    • resize(_width: number, _height: number): void
    • setContentsMargins(_left: number, _top: number, _right: number, _bottom: number): void
    • setFixedHeight(_height: number): void
    • setFixedWidth(_width: number): void
    • setMaximumHeight(_height: number): void
    • setMaximumWidth(_width: number): void
    • setMinimumHeight(_height: number): void
    • setMinimumWidth(_width: number): void
    • setSizePolicy(_horizontal: "LensStudio:Ui".SizePolicy.Policy, _vertical: "LensStudio:Ui".SizePolicy.Policy): void
    • toolTip: string
    • visible: boolean
    • width: number
    • windowTitle: string
  • Workspaces
    • Descriptor
      • layoutReader: "LensStudio:Serialization".IReader
      • metadata: "LensStudio:Ui".Workspaces.Metadata
    • Metadata
      • icon: Editor.Icon
      • name: string
    • PresetHandle
    • Workspace
      • dockManager: Editor.Dock.IDockManager
      • metadata: "LensStudio:Ui".Workspaces.Metadata
  • getUrlString(_displayText: string, _url: string): string
• LensStudio:UriHandlerPlugin
  • Descriptor
    • canHandle: (arg1: string) => any
  • UriHandlerPlugin
    • handle(_uri: string): boolean
    • pluginSystem: Editor.PluginSystem
• LensStudio:WebSocket
  • WebSocket
    • send(_data: string|Uint8Array): number
  • WebSocketServer
    • create(): "LensStudio:WebSocket".WebSocketServer
• ScriptObject
  • getTypeName(): string
  • isOfType(_type: string): boolean
  • isSame(_other: ScriptObject): boolean
• SecureLocalStorage
  • clear(): void
  • getItem(_keyName: string): string
  • length(): number
  • removeItem(_keyName: string): void
  • setItem(_keyName: string, _keyValue: string): void
• Task
• TextEncoder
  • encode(_value: string): Uint8Array
  • encodeInto(_value: string, _result: Uint8Array): void
  • encoding: string
• Timeout
• bvec4
• clearInterval(_timeout: Timeout): void
• clearTimeout(_timeout: Timeout): void
• console
  • debug(_data: any[]): void
  • error(_data: any[]): void
  • info(_data: any[]): void
  • log(_data: any[]): void
  • trace(_data: any[]): void
  • warn(_data: any[]): void
• global
  • secureLocalStorage: SecureLocalStorage
• mat3
  • add(_mat: mat3): mat3
  • column0: vec3
  • column1: vec3
  • column2: vec3
  • description: string
  • determinant(): number
  • div(_mat: mat3): mat3
  • equal(_mat: mat3): boolean
  • inverse(): mat3
  • mult(_mat: mat3): mat3
  • multiplyScalar(_scalar: number): mat3
  • sub(_mat: mat3): mat3
  • toString(): string
  • transpose(): mat3
• mat3
  • identity(): mat3
  • makeFromRotation(_arg1: quat): mat3
  • zero(): mat3
• quat
  • dot(_quat: quat): number
  • equal(_b: quat): boolean
  • getAngle(): number
  • getAxis(): vec3
  • invert(): quat
  • multiply(_b: quat): quat
  • multiplyVec3(_vec3: vec3): vec3
  • normalize(): void
  • toEulerAngles(): vec3
  • toString(): string
  • w: number
  • x: number
  • y: number
  • z: number
• quat
  • angleAxis(_angle: number, _axis: vec3): quat
  • angleBetween(_a: quat, _b: quat): number
  • fromEulerAngles(_x: number, _y: number, _z: number): quat
  • fromEulerVec(_eulerVec: vec3): quat
  • fromRotationMat(_rotationMat: mat3): quat
  • lerp(_a: quat, _b: quat, _t: number): quat
  • lookAt(_forward: vec3, _up: vec3): quat
  • quatIdentity(): quat
  • rotationFromTo(_from: vec3, _to: vec3): quat
  • slerp(_a: quat, _b: quat, _t: number): quat
• setInterval(_callback: () => void, _delayMs: number): Timeout
• setTimeout(_callback: () => void, _delayMs: number): Timeout
• signal0
  • connect(_callback: () => R): Editor.ScopedConnection
• signal1
  • connect(_callback: (arg0: T0) => R): Editor.ScopedConnection
• signal2
  • connect(_callback: (arg0: T0, arg1: T1) => R): Editor.ScopedConnection
• signal3
  • connect(_callback: (arg0: T0, arg1: T1, arg2: T2) => R): Editor.ScopedConnection
• signal4
  • connect(_callback: (arg0: T0, arg1: T1, arg2: T2, arg3: T3) => R): Editor.ScopedConnection
• signal5
  • connect(_callback: (arg0: T0, arg1: T1, arg2: T2, arg3: T3, arg4: T4) => R): Editor.ScopedConnection
• vec2
  • add(_vec: vec2): vec2
  • angleTo(_vec: vec2): number
  • clampLength(_length: number): vec2
  • distance(_vec: vec2): number
  • distanceSquared(_vec: vec2): number
  • div(_vec: vec2): vec2
  • dot(_vec: vec2): number
  • equal(_vec: vec2): boolean
  • g: number
  • length: number
  • lengthSquared: number
  • moveTowards(_point: vec2, _magnitude: number): vec2
  • mult(_vec: vec2): vec2
  • normalize(): vec2
  • project(_vec: vec2): vec2
  • projectOnPlane(_normal: vec2): vec2
  • r: number
  • reflect(_vec: vec2): vec2
  • scale(_vec: vec2): vec2
  • sub(_vec: vec2): vec2
  • toString(): string
  • uniformScale(_scale: number): vec2
  • x: number
  • y: number
• vec2
  • down(): vec2
  • left(): vec2
  • lerp(_vecA: vec2, _vecB: vec2, _t: number): vec2
  • max(_vecA: vec2, _vecB: vec2): vec2
  • min(_vecA: vec2, _vecB: vec2): vec2
  • one(): vec2
  • randomDirection(): vec2
  • right(): vec2
  • up(): vec2
  • zero(): vec2
• vec3
  • add(_vec: vec3): vec3
  • angleTo(_vec: vec3): number
  • b: number
  • clampLength(_length: number): vec3
  • cross(_vec: vec3): vec3
  • distance(_vec: vec3): number
  • distanceSquared(_vec: vec3): number
  • div(_vec: vec3): vec3
  • dot(_vec: vec3): number
  • equal(_vec: vec3): boolean
  • g: number
  • length: number
  • lengthSquared: number
  • moveTowards(_point: vec3, _magnitude: number): vec3
  • mult(_vec: vec3): vec3
  • normalize(): vec3
  • project(_vec: vec3): vec3
  • projectOnPlane(_normal: vec3): vec3
  • r: number
  • reflect(_vec: vec3): vec3
  • rotateTowards(_target: vec3, _step: number): vec3
  • scale(_vec: vec3): vec3
  • sub(_vec: vec3): vec3
  • toString(): string
  • uniformScale(_scale: number): vec3
  • x: number
  • y: number
  • z: number
• vec3
  • back(): vec3
  • down(): vec3
  • forward(): vec3
  • left(): vec3
  • lerp(_vecA: vec3, _vecB: vec3, _t: number): vec3
  • max(_vecA: vec3, _vecB: vec3): vec3
  • min(_vecA: vec3, _vecB: vec3): vec3
  • one(): vec3
  • orthonormalize(_vecA: vec3, _vecB: vec3): void
  • randomDirection(): vec3
  • right(): vec3
  • slerp(_vecA: vec3, _vecB: vec3, _t: number): vec3
  • up(): vec3
  • zero(): vec3
• vec4
  • a: number
  • add(_vec: vec4): vec4
  • angleTo(_vec: vec4): number
  • b: number
  • clampLength(_length: number): vec4
  • distance(_vec: vec4): number
  • distanceSquared(_vec: vec4): number
  • div(_vec: vec4): vec4
  • dot(_vec: vec4): number
  • equal(_vec: vec4): boolean
  • g: number
  • length: number
  • lengthSquared: number
  • moveTowards(_point: vec4, _magnitude: number): vec4
  • mult(_vec: vec4): vec4
  • normalize(): vec4
  • project(_vec: vec4): vec4
  • projectOnPlane(_normal: vec4): vec4
  • r: number
  • reflect(_vec: vec4): vec4
  • scale(_vec: vec4): vec4
  • sub(_vec: vec4): vec4
  • toString(): string
  • uniformScale(_scale: number): vec4
  • w: number
  • x: number
  • y: number
  • z: number
• vec4
  • lerp(_vecA: vec4, _vecB: vec4, _t: number): vec4
  • max(_vecA: vec4, _vecB: vec4): vec4
  • min(_vecA: vec4, _vecB: vec4): vec4
  • one(): vec4
  • zero(): vec4