API index#

This table lists every export of @sparkjsdev/radix, sorted by name. Everything is exported from @sparkjsdev/radix; the core/ exports (marked core) also come from @sparkjsdev/radix/core, which has no three.js and runs in workers and Node. Kinds: class, function, value, or type.

NameKindLayerWhat it is
AnyGpuSplatReadertypegpuany of the three splat readers (Splats)
AnySplatGeneratortypegpua generator of any data (Generators and modifiers)
AnySplatObjecttyperendera splat object of any data (Rendering)
ArrayBundletypecoreone bundle of a table: def, channels, meta (ArrayData)
ArrayBundlestypecorea table's bundles by name
ArrayChanneltypecoreone channel: { format, data }
ArrayDataclasscorethe table: rows of elements, channels of typed arrays, named bundles (ArrayData)
ArrayFormattypecorea channel format: "uint32x4", "float16x2", ... (ArrayData)
ArrayFormatsclasscoreinfo(format) and make(scalar, components)
ArrayOftypecorethe typed array of a format
ArrayWritertypegpuwhat GpuArrays.write runs: a fragment or compute writer (GPU arrays)
AutoSorttyperender{ distance, angle }: when autoSort re-sorts (Views and CPU orders)
Axesclasscorecoordinate systems: SYSTEMS, matrix, converter, convert (Splat files)
AxesConvertertypecoreconverts values from one system to another in place: vec, quat, scales, cov, splat, sh
BundleChannelstypecorechannel names to formats
BundleDeftypecorea bundle definition: channels, packing, serialize (ArrayData)
BundleLiketypecoreanything with named channels of formats
ByteReaderclasscorebytes taken in order from bytes or a stream (Splat files)
BytesInputtypecorebytes, an ArrayBuffer, or a stream
CallOptionstypeworker{ onProgress? } of a worker call (Workers)
CameraControlsclasscontrolsorbit and fly controls for pointer, touch, keys, gamepads, and XR (Camera controls)
CameraControlsInertiatypecontrolsinertia per input, in seconds
CameraControlsModetypecontrols"fly" | "orbit"
CameraControlsSettingstypecontrolsall the controls' settings (Camera controls)
CompressedPlyFileclasscoreSuperSplat compressed PLY write (and read, as PlyFile.read) (Splat files)
Compressionclasscoregzip, gunzip, byte-transposed gzip, and reading bytes (Splat files)
ComputeIdstypewgpua kernel body's built-in ids (WebGPU compute)
CoordinateSystemtypecore"RUB", "RDF", "RFU", ...: where +x, +y, and +z point (Splat files)
CopySpantypecoreone rectangle of a texture copy
Covtypecorea symmetric 3x3 matrix: { xx, yy, zz, xy, xz, yz }
CovSplattypecorea covariance-form splat record (Splats)
CovSplatModifiertypegpua TSL function of a covariance splat (Generators and modifiers)
CovSplatNodetypegputhe covariance splat struct in TSL (Shaders)
CovSplatstypecorea typed covSplats bundle
createRendererfunctiongpuan initialized WebGPURenderer with the device baselines (The renderer)
CreateRendererOptionstypegpuits options
decodeShScalefunctioncorepacked SH's scale byte to a band's largest value (Spherical harmonics)
defineBundlefunctioncorea bundle definition (ArrayData)
DispatchSizetypewgputhreads, workgroups, or an indirect buffer
encodeShScalefunctioncorea band's largest value to packed SH's scale byte, rounded up (Spherical harmonics)
Encodingclasscorethe scalar and vector codecs of the splat layouts (Encodings)
ExtSplattypecorea splat record with PBR fields
ExtSplatstypecorea typed extSplats bundle
FormatInfotypecorewhat ArrayFormats.info returns
FoundShtypecorewhat Sh.find returns: { name, codec, degree } (Spherical harmonics)
FoundSplatstypecore{ name, layout, bundle } from Splats.find / get
getGpuCapsfunctiongputhe renderer's backend and limits (The renderer)
GpuArrayReaderclassgpuTSL reads of one bundle (GPU arrays)
GpuArraysclassgpua table in textures (GPU arrays)
GpuArrayWriterclassgpuwrites bundles from TSL as a fragment pass (GPU arrays)
GpuBackendtypegpu"webgpu" | "webgpu-gl"
GpuBundletypegpuone bundle of a GpuArrays
GpuBundlestypegpuits bundles by name
GpuCapstypegpuwhat getGpuCaps returns
GpuChanneltypegpuone channel's texture and formats
GpuCovSplatReaderclassgputhe covSplats reader
GpuEncodingclassgputhe TSL twin of Encoding (Encodings)
GpuExtSplatReaderclassgputhe extSplats reader
GpuPackedSplatReaderclassgputhe packedSplats reader
GpuProfiletypegpuGPU and CPU ms per phase
GpuProfilerclassgpuGPU and CPU time per named phase (The renderer)
GpuShclassgpuspherical harmonics in TSL: evaluate, maxDegree, codec (Spherical harmonics)
GpuShCodectypegpua built-in SH codec's TSL decoder: decodeBand (Spherical harmonics)
GpuShPaletteclassgpuSH palettes on the GPU: upload, create (Spherical harmonics)
GpuShReaderclassgpureads and evaluates stored SH in any generator: bind, color, apply (Spherical harmonics)
GpuSortKeysclassgputhe TSL twin of SortKeys (Shaders)
GpuSplatMathclassgputhe TSL twin of SplatMath
GpuSplatReaderclassgpusplat reads in TSL: for(layout), from(arrays) (Splats)
GpuSplatsclassgputhe splat structs and TSL codecs (Splats)
Hdrclassgputhe HDR canvas and headroom tone mapping (The renderer)
HdrToneMappingtypegputhe tone mapping's controls
LimitRequesttypegpua WebGPU limit to request: a number or "adapter"
LoadedSplatstypecorewhat loadSplatFile and the readers return: { splats, shPalette? } (Splat files)
loadSplatFilefunctionworkera splat file into { splats, shPalette? }, a palette kept, on a worker (Splat files)
loadSplatsfunctionworkera splat file into its table, a palette expanded per splat, on a worker (Splat files)
LoadSplatsOptionstypeworkerthe options of loadSplats and loadSplatFile (Splat files)
MappedObjecttyperender{ object, offset }: an object in a collection, with its offset
ModifierSpacetyperender"view" | "world" | "object" or a Matrix4 (Generators and modifiers)
PackedEncodingtypecorethe ranges of packed splats' 8-bit codes (Splats)
PackedSplatstypecorea typed packedSplats bundle
Pbrtypecorenormal, roughness, and metallic
PbrNodetypegputhe PBR struct in TSL
PlyFileclasscorePLY read (standard or compressed) and write (Splat files)
Progresstypecore(fraction, stage) => void
ProgressStagetypecore"downloading" | "decoding" | "encoding" | "compressing"
ProjectionMethodtyperender"ewa" | "3dgut" | "htgs" | "raygs" (Projection)
Quattypecore{ x, y, z, w }
RadFileclasscoreRAD read and write, clustered SH included
RadixKeysPerThreadtypewgpu8 or 16
RdxFileclasscoreRDX files: whole, chunked, over HTTP range requests (RDX files)
RdxHeadertypecorean RDX header
RdxReadertypecoreheader and readChunk(chunk, into)
Rgbtypecore{ r, g, b }
ScalarTypetypecorethe scalar part of a format
ScanTiertypewgpu"portable" | "subgroup"
Schematypecorebundle names to definitions
Shclasscorespherical harmonics on the CPU: codecs, bundles, find, encoders, convert, evaluate (Spherical harmonics)
ShCodectypecorea built-in SH codec (Sh.codec(name)): name, words, channels, encode, decode (Spherical harmonics)
ShCodecNametypecorethe SH codecs: "ext" | "packed" (Spherical harmonics)
ShDegreetypecore1 | 2 | 3 | 4: the highest SH band (Spherical harmonics)
ShPaletteclasscorea table of SH entries that splats pick by label (Spherical harmonics)
ShTargettypecorewhat file readers do with SH: "ext", "packed", or false (Spherical harmonics)
SortedSplatstypeworker{ ordering, visible, keys } from sortSplatKeys
SortKeyBitstypecore16 | 24 | 32
SortKeysclasscoresort keys: compute, invalid, sort, KEYS (Sorting)
sortSplatKeysfunctionworkersorts sort keys on a worker or on the current thread (Workers)
Splattypecorea splat record: center, scales, quaternion, rgb, opacity (Splats)
SplatBindContexttypegputhe generator context as three.js values, for bind (Generators and modifiers)
SplatBundletypecoreany typed splat bundle
SplatBundlestypecorelayout names to typed bundles
SplatCollectionclassrenderan immutable, ordered list of splat objects (Rendering)
SplatDatatypecorea table with a layout's splat bundle
SplatFilesclasscoresplat files on the current thread (Splat files)
SplatFormattypecore"ply" | "compressed-ply" | "spz" | "rad" | "rdx"
SplatGeneratorvalue and typegpumakes splat i in TSL; fromSplats, forArrays, indices, context (Generators and modifiers)
SplatGeneratorContexttypegpuwhat a generator or modifier knows of the object and the view: viewOrigin, ... (Generators and modifiers)
SplatLayouttypecore"extSplats" | "covSplats" | "packedSplats"
SplatLoadOptionstypecoreSplatFiles.decode's options
SplatMathclasscorequaternion and covariance math (Encodings)
SplatModifiertypegpua TSL function of a splat (Generators and modifiers)
SplatNodetypegputhe splat struct in TSL (Shaders)
SplatObjecttyperenderone thing to draw: generator, data, count, matrixWorld, params, release (Rendering)
SplatObjectParamstyperenderthe params each object projects with (Params)
SplatOrdertyperenderone CPU sort's result (Views and CPU orders)
SplatProjectorclassrenderthe program cache: programs, dispose(generator) (Generators and modifiers)
SplatReadOptionstypecorea target layout plus progress, sh, and coordinateSystem
SplatRendererclassrenderthe mesh that draws a collection (Rendering)
SplatRequestInittypecorefetch options for a splat file's URL, loadSplats' request (Splat files)
SplatRendererOptionstyperenderits options
Splatsclasscorethe splat layouts on the CPU (Splats)
SplatShOptionstypegpu{ codec, degree, palette? }: the SH a fromSplats generator adds (Generators and modifiers)
SplatSourcetypeworkera URL, a Blob or File, or bytes
SplatTargettypecore{ layout?, encoding? }
SplatViewclassrenderone viewpoint of a renderer (Views and CPU orders)
SplatViewOptionstyperenderwhat viewFor sets
SplatViewParamstyperenderthe params every splat of a render shares (Params)
SplatWriteOptionstypecorethe writers' options (Splat files)
SpzExtensiontypecorean SPZ extension record: { type, data }
SpzFileclasscoreSPZ read, write, and unpack (Splat files)
SpzUnpackedtypecorean SPZ file's header and byte columns
SpzWriteOptionstypecorethe SPZ writer's options
StoredSplatstypegpu{ splats, indices?, shPalette? }: the data of a fromSplats object
StructNodetypegpua typed TSL struct node
TexelSpantypecoreone rectangle of texels
TextureLayoutclasscoreelements to texels of a 2D array texture (ArrayData)
TransferableArrayDatatypecorea table as a plain object, for postMessage
TSLvaluegputhree/tsl with loosened node types (Shaders)
TslNodetypegpuany TSL node
TypedArraytypecoreany typed array a channel can hold
TypedArrayConstructortypecoreits constructor
Vec3typecore{ x, y, z }
WgpuArrayStoreclasswgpuwrites elements at any index from compute (WebGPU compute)
WgpuArrayWriterclasswgputhe compute writer (WebGPU compute)
WgpuBufferclasswgpua typed storage buffer (WebGPU compute)
WgpuCompactclasswgpustream compaction (WebGPU compute)
WgpuComputeclasswgpua compute kernel (WebGPU compute)
WgpuComputeBatchclasswgpudispatches in one compute pass
WgpuRadixSortclasswgpua stable GPU radix sort (WebGPU compute)
WgpuSplatSorterclasswgpucompaction, sort, and draw arguments for projected splats (WebGPU compute)
WorkerArgstypeworkera handler's arguments
WorkerCalltypeworkerthe handler names
WorkerChoicetypeworkerwhere a file call runs: boolean, a pool, or a lease (Splat files)
WorkerLeaseclassworkerone worker of a pool, held until release() (Workers)
WorkerPoolclassworkerup to size workers, made on demand (Workers)
WorkerResulttypeworkera handler's result
WriteItemtypegpua write range plus its writer
WriteRangetypegpu{ at?, count, first? }
WriterFortypegputhe writers that arrays with a given storage setting accept
WriterOutputtypegpuone output channel of a writer
WriterOutputstypegpua writer body's out argument
writeSplatsfunctionworkera table to a splat file, on a worker (Splat files)
XrInputtypecontrolsthe part of renderer.xr the controls read
Zstdclasscorezstd compress and decompress (Splat files)

Internal (not exported; the tests import them by path): SplatCamera, SplatParams, SplatProjection, projectCollection, programOf, readSortKeys, and the transforms in splatTransform.tsl.ts (Projection).

Source: docs/api.md