Texture beta

A GPU texture created and managed at runtime. Construct one from an image or video source (Texture.image(...), Texture.video(...)), the live camera feed (Texture.cameraFeed()), or a compute kernel that writes its pixels (Texture.compute(...)).

For a compute-written texture the kernel writes the pixels and materials sample the same texture through the same handle, so updates show up in the next rendered frame without an explicit copy. Feed .read / .write tokens into a kernel's inputTextures / outputTextures maps.

Properties

depth

• Type: number
• Depth (slices) for 3D textures, layer count for arrays. 1 for flat 2D / cubemap-face textures.

height

• Type: number

id

• Type: string
• Texture id – matches dynamicTexture.id. Stable for the lifetime of the texture; surfaces in material TextureReference.dynamic references.

pixelFormat

• Type: string
• Engine-agnostic pixel format name (e.g. "rgba32Float").

read

• Type: TextureBinding
• Token tagged as "read into kernel" – pass to a kernel's inputTextures map.

textureType

• Type: string
• Texture dimensionality: "2d", "3d", "cube", "2dArray", "cubeArray".

width

• Type: number

write

• Type: TextureBinding
• Token tagged as "write from kernel" – pass to a kernel's outputTextures map.

Static Methods

cameraFeed()

Texture.cameraFeed(options?: Object): Promise<Texture>

Live camera feed as a sampleable texture. Binds the device's camera capture as a regular texture handle – typical uses are first-person portal effects, augmented-reality color grading on detected planes, or piping the feed into a compute kernel for a real-time filter.

Available on iOS / iPadOS only – Mac Catalyst and visionOS don't expose the AR camera capture. Always gate with environment.features.has('cameraFeed').

Example:

if (!environment.features.has('cameraFeed')) return;
const camTex = await Texture.cameraFeed();
await entity.representation.setMaterial(Material.unlit({ map: camTex }));

Parameters:

• options (Object) (optional)
• options.semantic (string) (optional)

Returns: Promise<Texture>

compute()

Texture.compute(options: Object): Promise<Texture>

Allocate a GPU-only texture written by a compute kernel. Supports 2D, 3D, cube, and array textures with optional mipmap chains.

Async because the dynamic-texture asset-provider funnel allocates the underlying GPU resource and registers it in the runtime's manager cache (so material binding finds the same instance later). Authors await once at allocation; subsequent kernel dispatches are sync.

Example:

// 2D height map for a wave-grid kernel
const heightMap = await Texture.compute({
    pixelFormat: 'rgba32Float',
    width: 256,
    height: 256
});

// 3D scalar field for volumetric / marching-cubes work
const field = await Texture.compute({
    textureType: '3d',
    pixelFormat: 'r32Float',
    width: 64, height: 64, depth: 64
});

// Compute-driven normal map sampled by a PBR material
const normalMap = await Texture.compute({
    pixelFormat: 'rgba8Unorm',
    width: 512, height: 512,
    semantic: 'normal'
});

Parameters:

• options (Object)
• options.pixelFormat (string) - e.g. 'rgba32Float', 'rgba16Float', 'r32Float'.
• options.textureType (string) (optional) - '2d' | '3d' | 'cube' | '2dArray' | 'cubeArray'.
• options.width (number)
• options.height (number)
• options.depth (number) (optional) - Slice count for 3D textures.
• options.arrayLength (number) (optional) - Layer count for arrays.
• options.mipmapLevelCount (number) (optional) - Set > 1 + call texture.generateMipmaps() to populate.
• options.semantic (string) (optional) - 'color' | 'normal' | 'scalar' | 'hdrColor' | 'raw'. Tells material binding how to sample (sRGB vs linear, etc.).
• options.usage (Array<string>) (optional)

Returns: Promise<Texture>

image()

Texture.image(urlOrId: string, options?: Object): Promise<Texture>

Static image-asset texture. Reads an image asset (PNG / JPG / etc.) from the experience's asset library or an absolute URL and binds it as a sampleable texture – typical use is a hand-painted normal map or albedo map fed to Material.pbr({ normalMap: tex }).

Example:

const normalMap = await Texture.image('rocks-normal.png', { semantic: 'normal' });
await entity.representation.setMaterial(Material.pbr({
    map: 'rocks-color.png',
    normalMap: normalMap
}));

Parameters:

• urlOrId (string) - HTTPS URL or asset id from the project library.
• options (Object) (optional)
• options.semantic (string) (optional) - 'color' | 'normal' | 'scalar' | 'hdrColor' | 'raw'. Tells material binding how to sample (sRGB vs linear).

Returns: Promise<Texture>

video()

Texture.video(urlOrId: string, options?: Object): Promise<Texture>

Video-asset texture. Plays a video file (mp4 / mov) as a sampleable texture and binds it to a material – typical use is a looping background, an animated diorama, or a UI-overlay video sticker.

The video starts playing automatically by default. Pass { autoplays: false } and call videoTexture.play() later when the entity becomes visible.

Example:

const intro = await Texture.video('intro-loop.mp4', { loops: true, volume: 0.3 });
await entity.representation.setMaterial(Material.unlit({ map: intro }));

Parameters:

• urlOrId (string) - HTTPS URL or asset id from the project library.
• options (Object) (optional)
• options.semantic (string) (optional) - 'color' | 'normal' | 'scalar' | 'hdrColor' | 'raw'.
• options.loops (boolean) (optional) - Restart from frame 0 on end.
• options.autoplays (boolean) (optional) - Start playback as soon as the asset is ready.
• options.volume (number) (optional) - Linear gain (0..1). Unset = system default.
• options.streamContent (boolean) (optional) - HTTP streaming vs. download-then-play.
• options.isShared (boolean) (optional) - SharePlay sync – when true, playback time syncs across session participants.

Returns: Promise<Texture>

Methods

destroy()

destroy(): void

Release the texture's GPU memory immediately.

Textures clean up automatically when the proxy goes out of scope. Call destroy() only for early termination in hot allocation / teardown loops where JSC's GC delay matters. Subsequent kernel dispatches binding this texture warn + skip the binding.

Returns: void

generateMipmaps()

generateMipmaps(): void

Generate the mipmap chain. Runs a synchronous GPU mipmap-generation pass against the texture's command queue. Requires the texture was allocated with mipmapLevelCount > 1. No-op on textures without a mip chain.

Returns: void