Reference
Find the right API
Look up which package and export covers the job you have, then read its types in the source for the full options.
On this page
Search the API
623 exports in 14 packages
- addFoliageBackLightfunctioncoreAdds subsurfaceColor times the far-face irradiance to a Two Sided Foliage leaf's emissive node.
import { addFoliageBackLight } from "@threenative/core" - addInSlicesfunctioncoreAttach hundreds of built objects to the scene in slices with an 8 ms default budget, presenting a frame between each.
import { addInSlices } from "@threenative/core" - addSpanfunctioncoreAttribute the render phase to 100% with a nested span tree, off unless TN_FRAME_SPANS asks.
import { addSpan } from "@threenative/core" - aerodynamicCoefficientsfunctioncoreFly a fixed-wing aircraft with a real force balance instead of a steered velocity.
import { aerodynamicCoefficients } from "@threenative/core" - afterPhysicsfunctioncoreRegister work that reads a body or camera after physics has moved it and before this frame draws.
import { afterPhysics } from "@threenative/core" - aircraftMassfunctioncoreFly a fixed-wing aircraft with a real force balance instead of a steered velocity.
import { aircraftMass } from "@threenative/core" - airDensityfunctioncoreFly a fixed-wing aircraft with a real force balance instead of a steered velocity.
import { airDensity } from "@threenative/core" - alwaysRenderfunctioncoreKeep an object drawn even when the render camera cannot resolve it.
import { alwaysRender } from "@threenative/core" - AnimationComposerclasscoreCompose game-authored locomotion and masked actions on one Three.js mixer.
import { AnimationComposer } from "@threenative/core" - AnimationPlayerclasscorePlay a skinned or sprite animation from game code.
import { AnimationPlayer } from "@threenative/core" - AtmosphereclasscoreOwn the compute lifetime and expose only parameter-driven atmosphere nodes.
import { Atmosphere } from "@threenative/core" - AtmosphereLutsclasscoreOwn the transmittance, multi-scattering, and sky-view compute lookup textures.
import { AtmosphereLuts } from "@threenative/core" - attachToBonefunctioncoreAttach a game-owned object to a named skeleton bone.
import { attachToBone } from "@threenative/core" - attitudeAxesfunctioncoreFly a fixed-wing aircraft with a real force balance instead of a steered velocity.
import { attitudeAxes } from "@threenative/core" - AudioBusclasscoreRoute effects through a named audio bus.
import { AudioBus } from "@threenative/core" - AutoExposureNodeclasscoreAuto exposure with Unreal 5.8.3's metering: a 64-bin histogram of log2 luminance (the darkest and brightest 10% ignored), key 0.18 x 2, -10 to +20 EV100, 3 stops/s brighter and 1 stop/s darker.
import { AutoExposureNode } from "@threenative/core" - baseGeometryOffunctioncoreThe full-detail geometry of a mesh the loader gave an automatic LOD chain.
import { baseGeometryOf } from "@threenative/core" - beginSpanfunctioncoreAttribute the render phase to 100% with a nested span tree, off unless TN_FRAME_SPANS asks.
import { beginSpan } from "@threenative/core" - Billboard3DclasscoreFace a game-owned object toward a perspective or orthographic camera.
import { Billboard3D } from "@threenative/core" - BlendSpace1DclasscoreSelect finite, normalized locomotion weights from sorted thresholds or a fixed triangulation.
import { BlendSpace1D } from "@threenative/core" - BlendSpace2DclasscoreSelect finite, normalized locomotion weights from sorted thresholds or a fixed triangulation.
import { BlendSpace2D } from "@threenative/core" - boneContactfunctioncoreMeasure whether a named bone reaches the object it is supposed to be touching, in metres.
import { boneContact } from "@threenative/core" - boneLengthDeviationsfunctioncoreCompare a rig's bone distances now against a captured snapshot and name every bone that moved.
import { boneLengthDeviations } from "@threenative/core" - boneLengthsfunctioncoreMeasure a rig's parent→child bone distances, in world space, as it stands right now.
import { boneLengths } from "@threenative/core" - BudgetLadderclasscoreA cost ladder for one render stage: the whole GPU frame against the frame period moves it, by Unreal's DynamicRenderScaling rule.
import { BudgetLadder } from "@threenative/core" - bvhIntersectFirstHitfunctioncorePack a selected static scene into TSL storage nodes for an upstream BVH ray query.
import { bvhIntersectFirstHit } from "@threenative/core" - CameraShakeclasscoreProduce a game-authored camera shake offset for a template-owned camera rig.
import { CameraShake } from "@threenative/core" - CanvasLayerclasscoreManage a camera or screen-facing canvas layer.
import { CanvasLayer } from "@threenative/core" - captureMousefunctioncoreLock the pointer to the game's surface: the capture every first-person mouse look needs.
import { captureMouse } from "@threenative/core" - clipBoneCoveragefunctioncoreReport which bones of a character a clip does not drive.
import { clipBoneCoverage } from "@threenative/core" - clipPoseErrorfunctioncoreScore a retargeted clip against the source it came from, per bone, in degrees.
import { clipPoseError } from "@threenative/core" - clipTrackBindingsfunctioncoreReport which of a clip's tracks bind to nothing on a character.
import { clipTrackBindings } from "@threenative/core" - ClusteredBatchclasscoreDraw many copies of one over-detailed body, each at the detail its own distance earns.
import { ClusteredBatch } from "@threenative/core" - ClusteredMeshclasscoreDraw a model too detailed for the screen to resolve, without submitting the part it cannot.
import { ClusteredMesh } from "@threenative/core" - ComputeDrivenRegistryclasscoreRegister game-owned IComputeDriven objects with the shared compute lifetime.
import { ComputeDrivenRegistry } from "@threenative/core" - counterDeviceOffunctioncoreCount the frame's host-boundary crossings and the bytes it writes into GPU buffers, off unless TN_FRAME_SPANS asks for them.
import { counterDeviceOf } from "@threenative/core" - createAssetLoaderfunctioncoreCreate the portable asset loader a scene also receives as ctx.assets.
import { createAssetLoader } from "@threenative/core" - createPipelineCensusfunctioncoreRead the renderer's bounded, versioned pipeline capture in a diagnostic or playtest tool.
import { createPipelineCensus } from "@threenative/core" - createRandomfunctioncoreCreate a deterministic random source for portable gameplay.
import { createRandom } from "@threenative/core" - createReplayDriverfunctioncoreRecord or replay deterministic game input and state.
import { createReplayDriver } from "@threenative/core" - DaylightclasscoreAn outdoor daylight rig: physical sky, one sun with open-world shadows that follow the eye, hemisphere fill, sky-coloured haze and the AgX tone curve.
import { Daylight } from "@threenative/core" - debugFlagfunctioncoreRead a debug switch from the URL, or from TN_DEBUG_ in the environment on a native launch.
import { debugFlag } from "@threenative/core" - debugValuefunctioncoreRead the text a debug switch was given by the launch, on the same rule as debugFlag.
import { debugValue } from "@threenative/core" - defineGamefunctioncoreDefine the portable game entry shared by web and native.
import { defineGame } from "@threenative/core" - describeSceneShapefunctioncoreWarn the agent that built the scene before a human plays it: a frame whose GPU is idle while its JS render phase is longer than the display's own period is a scene-shape problem, and the engine already has the shape.
import { describeSceneShape } from "@threenative/core" - describeSceneWarningfunctioncoreWarn the agent that built the scene before a human plays it: a frame whose GPU is idle while its JS render phase is longer than the display's own period is a scene-shape problem, and the engine already has the shape.
import { describeSceneWarning } from "@threenative/core" - devGlobalfunctioncoreThe one name every dev surface publishes under, and the reader/writer for it.
import { devGlobal } from "@threenative/core" - directionalTransmittancefunctioncoreApproximate direct transmittance for a ray leaving the game surface.
import { directionalTransmittance } from "@threenative/core" - directionFromSolarPositionfunctioncoreConvert solar elevation and azimuth degrees into a normalized Three.js direction.
import { directionFromSolarPosition } from "@threenative/core" - displayPeriodMsfunctioncoreWarn the agent that built the scene before a human plays it: a frame whose GPU is idle while its JS render phase is longer than the display's own period is a scene-shape problem, and the engine already has the shape.
import { displayPeriodMs } from "@threenative/core" - endSpanfunctioncoreAttribute the render phase to 100% with a nested span tree, off unless TN_FRAME_SPANS asks.
import { endSpan } from "@threenative/core" - ensureVelocityOutputfunctioncoreProvision screen-space motion data for temporal nodes and keep per-instance history at the frame boundary.
import { ensureVelocityOutput } from "@threenative/core" - ev100FromCamerafunctioncorePhotometric exposure units: EV100 to the renderer multiplier and back, a physical camera's EV100, and a meter reading.
import { ev100FromCamera } from "@threenative/core" - ev100FromExposurefunctioncorePhotometric exposure units: EV100 to the renderer multiplier and back, a physical camera's EV100, and a meter reading.
import { ev100FromExposure } from "@threenative/core" - ev100FromLuminancefunctioncorePhotometric exposure units: EV100 to the renderer multiplier and back, a physical camera's EV100, and a meter reading.
import { ev100FromLuminance } from "@threenative/core" - exposeDebugfunctioncorePublish one game object under __THREENATIVE__.debug for a capture script or the console.
import { exposeDebug } from "@threenative/core" - exposureFromEv100functioncorePhotometric exposure units: EV100 to the renderer multiplier and back, a physical camera's EV100, and a meter reading.
import { exposureFromEv100 } from "@threenative/core" - fetchAssetfunctioncoreFetch a data file the asset loader serves: each url assets.resolve(path) names, in order, until one answers ok.
import { fetchAsset } from "@threenative/core" - FlightModelclasscoreFly a fixed-wing aircraft with a real force balance instead of a steered velocity.
import { FlightModel } from "@threenative/core" - FluidField2DclasscoreSimulate a deterministic 2D velocity-and-dye field on the GPU while exposing its data to game-owned rendering.
import { FluidField2D } from "@threenative/core" - FluidParticles3DclasscoreSimulate liquid as GPU particles (pour, splash, dam break, waterfall) and expose positions, a density volume and a surface height while the game owns every look.
import { FluidParticles3D } from "@threenative/core" - formatSceneWarningfunctioncoreWarn the agent that built the scene before a human plays it: a frame whose GPU is idle while its JS render phase is longer than the display's own period is a scene-shape problem, and the engine already has the shape.
import { formatSceneWarning } from "@threenative/core" - formatSpansWindowfunctioncoreAttribute the render phase to 100% with a nested span tree, off unless TN_FRAME_SPANS asks.
import { formatSpansWindow } from "@threenative/core" - formatUnlitFoliageWarningfunctioncoreTell the agent that built the scene that its imported foliage is drawing with no image-based light: an alpha-cutout MeshStandardMaterial (or its Node twin) with scene.environment unset and no envMap of its own gets a hemisphere fill and one flat dark value, which is cardboard.
import { formatUnlitFoliageWarning } from "@threenative/core" - formatValidationReportfunctioncoreProve that nothing a cache skipped changed the picture: TN_RENDERLIST_VALIDATE=1 recomputes every world matrix the long way, every frame, and throws on the first element that disagrees with what the frame is about to draw.
import { formatValidationReport } from "@threenative/core" - FrameBudgetclasscoreRead where the frame's milliseconds went, per presented frame, on any platform; each TN_FRAME_BUDGET window also carries the GPU time per resolved frame and the draw calls and triangles each render pass submitted.
import { FrameBudget } from "@threenative/core" - FrameCountersclasscoreCount the frame's host-boundary crossings and the bytes it writes into GPU buffers, off unless TN_FRAME_SPANS asks for them.
import { FrameCounters } from "@threenative/core" - gearClearancefunctioncoreFly a fixed-wing aircraft with a real force balance instead of a steered velocity.
import { gearClearance } from "@threenative/core" - getPlatformfunctioncoreRead the host platform without reaching for browser globals.
import { getPlatform } from "@threenative/core" - GIBudgetclasscoreReports what a game's global illumination costs against the frame period: the GI share of the GPU frame and whether the frame fits its period less 10% headroom.
import { GIBudget } from "@threenative/core" - GIVisualizeclasscoreShows the indirect diffuse light of a frame by itself, the counterpart of Unreal's Lumen Visualize IndirectDiffuse mode, so a lighting gap against a reference can be told apart from a scene gap.
import { GIVisualize } from "@threenative/core" - GPUParticles3DclasscoreDispatch a game-owned particle surface and process function through a pooled system.
import { GPUParticles3D } from "@threenative/core" - GPUReadbackclasscoreCopy a GPU buffer back to the CPU on a throttle, and report how old each sample is.
import { GPUReadback } from "@threenative/core" - GPUSceneBVHclasscorePack a selected static scene into TSL storage nodes for an upstream BVH ray query.
import { GPUSceneBVH } from "@threenative/core" - GrassField3DclasscoreStream instanced grass in chunks around the camera; the game owns the blade and its TSL material.
import { GrassField3D } from "@threenative/core" - GroundSnapclasscoreKeep a rendered model's feet on a surface while preserving an auditable override.
import { GroundSnap } from "@threenative/core" - InputMapclasscoreThe map a game reads input through: named actions, 2D vectors and scalar axes resolved from keyboard, gamepad, mouse, wheel, pinch and touch.
import { InputMap } from "@threenative/core" - installFilmicToneMappingfunctioncoreUnreal 5.8.3's tone curve, the default tone mapping of createRenderer and Game: a filmic curve in ACEScg (slope 0.88, toe 0.55, shoulder 0.26) after the gamut expansion and blue correction of Unreal's colour LUT.
import { installFilmicToneMapping } from "@threenative/core" - installSpanProbesfunctioncoreAttach the span probes to a renderer: three's render, _projectObject, the render list's sort, the per-draw submission, and the scene-graph walk.
import { installSpanProbes } from "@threenative/core" - InstancedBatchclasscoreCollapse many copies of one game-authored shape into a single draw, without counting them first.
import { InstancedBatch } from "@threenative/core" - InstancedModelclasscoreInstance an entire multi-mesh, multi-material static model across many placements in spatial cells, keeping every child transform, baked AutoLOD chain and loader asset provenance intact.
import { InstancedModel } from "@threenative/core" - invalidateStaticfunctioncoreStop recomposing the transforms of a subtree nobody moves.
import { invalidateStatic } from "@threenative/core" - isConsolefunctioncoreRead the host platform without reaching for browser globals.
import { isConsole } from "@threenative/core" - isMobilefunctioncoreRead the host platform without reaching for browser globals.
import { isMobile } from "@threenative/core" - isNativefunctioncoreRead the host platform without reaching for browser globals.
import { isNative } from "@threenative/core" - isPs4functioncoreRead the host platform without reaching for browser globals.
import { isPs4 } from "@threenative/core" - isStaticfunctioncoreStop recomposing the transforms of a subtree nobody moves.
import { isStatic } from "@threenative/core" - isStreamedGeometryfunctioncoreTrue while a geometry is the coarse companion a streamed model draws first (PRD-860), before its full file replaces it in place.
import { isStreamedGeometry } from "@threenative/core" - isTouchscreenAvailablefunctioncoreRead the host platform without reaching for browser globals.
import { isTouchscreenAvailable } from "@threenative/core" - isWebfunctioncoreRead the host platform without reaching for browser globals.
import { isWeb } from "@threenative/core" - lampPenumbraTangentfunctioncoreA lamp's penumbra radius in tangent units at a receiver, from the lamp's source radius and the blocker and receiver distances.
import { lampPenumbraTangent } from "@threenative/core" - lampShadowMarkerfunctioncoreThe TN_LAMP_SHADOW line for the renderer's last frame, or undefined on a renderer that keeps no lamp counters (three's own).
import { lampShadowMarker } from "@threenative/core" - loadAllfunctioncoreLoad a list with bounded concurrency, returning results in the input's order.
import { loadAll } from "@threenative/core" - lodChainOffunctioncoreThe cooked automatic LOD chain (TN_discrete_lod) a loaded geometry carries, or undefined.
import { lodChainOf } from "@threenative/core" - lodPixelScalefunctioncoreThe screen pixels one world unit covers at depth for this camera and viewport.
import { lodPixelScale } from "@threenative/core" - markStaticfunctioncoreFreeze a subtree nobody moves: markStatic(root) composes its transforms once and stops the per-frame recompose.
import { markStatic } from "@threenative/core" - MatrixWorldPassclasscoreWalk the scene graph's world matrices each frame without recursing into a hidden subtree.
import { MatrixWorldPass } from "@threenative/core" - measureThreePosefunctioncoreMeasure a Three.js pose for grounded or attachment-aware checks.
import { measureThreePose } from "@threenative/core" - mergeByMaterialfunctioncoreBake a hierarchy's static meshes into one mesh per material, with their transforms baked in.
import { mergeByMaterial } from "@threenative/core" - mergePartsfunctioncoreMerge pieces a game authored out of primitives into one buffer, keeping each piece's own look.
import { mergeParts } from "@threenative/core" - normaliseToMetresfunctioncoreScale an asset to a real-world measurement and return the applied factor.
import { normaliseToMetres } from "@threenative/core" - onLaunchFailurefunctioncoreCalled for every launch failure the engine notices, with the message to show the player.
import { onLaunchFailure } from "@threenative/core" - parseReplayRecordingfunctioncoreValidate and parse a replay recording file.
import { parseReplayRecording } from "@threenative/core" - PathFollow3DclasscoreMove an object along a Three.js curve with Godot-style path following.
import { PathFollow3D } from "@threenative/core" - penumbraUvfunctioncoreConvert world-space caster gap to a shadow UV radius, floored at one texel.
import { penumbraUv } from "@threenative/core" - PipelineCensusclasscoreRead the renderer's bounded, versioned pipeline capture in a diagnostic or playtest tool.
import { PipelineCensus } from "@threenative/core" - PointerEvents3DclasscoreDispatch portable pointer events from the game surface to registered Three.js objects.
import { PointerEvents3D } from "@threenative/core" - posedBoundsfunctioncoreMeasure a Three.js pose for grounded or attachment-aware checks.
import { posedBounds } from "@threenative/core" - prewarmfunctioncoreKeep transient render surfaces in the renderer's pipeline cache before first use.
import { prewarm } from "@threenative/core" - ProbeVolumeclasscoreBake static diffuse irradiance that reaches surfaces from outside the camera view.
import { ProbeVolume } from "@threenative/core" - publishDevGlobalfunctioncoreThe one name every dev surface publishes under, and the reader/writer for it.
import { publishDevGlobal } from "@threenative/core" - qualityPresetfunctioncoreThe quality tiers of the Unreal 5.8.3 look: what high (a desktop, Unreal's Epic), medium and low (a phone) turn on, how a GPU family picks its start tier, and the global illumination and shadow filter settings per tier named after Unreal's scalability levels.
import { qualityPreset } from "@threenative/core" - RadianceCacheclasscoreA probe field of diffuse irradiance that refreshes by tracing the packed scene, with no scene draw: the radiance cache of a dynamic global-illumination pass.
import { RadianceCache } from "@threenative/core" - readGIMarkerfunctioncoreParse a TN_GI console line back into its report, or undefined.
import { readGIMarker } from "@threenative/core" - readLampShadowMarkerfunctioncoreParse a TN_LAMP_SHADOW line back into its stats, or undefined.
import { readLampShadowMarker } from "@threenative/core" - readProbeVolumeObservationfunctioncoreRead the most recent observation from a probe volume.
import { readProbeVolumeObservation } from "@threenative/core" - readRenderChainObservationfunctioncoreCompose game-provided render nodes in a measured, fail-closed chain.
import { readRenderChainObservation } from "@threenative/core" - readRenderChainReportfunctioncoreCompose game-provided render nodes in a measured, fail-closed chain.
import { readRenderChainReport } from "@threenative/core" - readShadowTierMarkerfunctioncoreParse a TN_SHADOW_TIER console line back into its report, or undefined.
import { readShadowTierMarker } from "@threenative/core" - readVelocityPreviousBoneMatricesfunctioncoreProvision screen-space motion data for temporal nodes and keep per-instance history at the frame boundary.
import { readVelocityPreviousBoneMatrices } from "@threenative/core" - readVelocityPreviousMatricesfunctioncoreProvision screen-space motion data for temporal nodes and keep per-instance history at the frame boundary.
import { readVelocityPreviousMatrices } from "@threenative/core" - readVelocityPreviousWorldMatrixfunctioncoreProvision screen-space motion data for temporal nodes and keep per-instance history at the frame boundary.
import { readVelocityPreviousWorldMatrix } from "@threenative/core" - readVirtualShadowMarkerfunctioncoreParse a TN_VIRTUAL_SHADOW console line back into its complete stats, or undefined.
import { readVirtualShadowMarker } from "@threenative/core" - reconcileMirroredClipsfunctioncoreRepair an exported rig whose animation clips are z-mirrored against its own bind pose.
import { reconcileMirroredClips } from "@threenative/core" - refreshStaticTransformsfunctioncoreStop recomposing the transforms of a subtree nobody moves.
import { refreshStaticTransforms } from "@threenative/core" - RenderChainclasscoreCompose game-provided render nodes in a measured, fail-closed chain.
import { RenderChain } from "@threenative/core" - renderListValidationRequestedfunctioncoreProve that nothing a cache skipped changed the picture: TN_RENDERLIST_VALIDATE=1 recomputes every world matrix the long way, every frame, and throws on the first element that disagrees with what the frame is about to draw.
import { renderListValidationRequested } from "@threenative/core" - RenderListValidatorclasscoreProve that nothing a cache skipped changed the picture: TN_RENDERLIST_VALIDATE=1 recomputes every world matrix the long way, every frame, and throws on the first element that disagrees with what the frame is about to draw.
import { RenderListValidator } from "@threenative/core" - renderTrapAuditfunctioncoreCatch scene state that silently loses environment fill or ignores authored opacity.
import { renderTrapAudit } from "@threenative/core" - replayfunctioncoreRecord or replay deterministic game input and state.
import { replay } from "@threenative/core" - resetAudioCueLedgerfunctioncoreForgets every recorded cue.
import { resetAudioCueLedger } from "@threenative/core" - resetStaticTransformsfunctioncoreStop recomposing the transforms of a subtree nobody moves.
import { resetStaticTransforms } from "@threenative/core" - resolveAtmosphereLutResolutionsfunctioncoreResolve the three LUT dimensions, allowing a game to trade startup cost for resolution.
import { resolveAtmosphereLutResolutions } from "@threenative/core" - resolveAtmosphereParametersfunctioncoreValidate and clone game-owned atmosphere coefficients.
import { resolveAtmosphereParameters } from "@threenative/core" - resolveTargetFpsfunctioncoreRead what frame rate a game gets when its config does not say, and why.
import { resolveTargetFps } from "@threenative/core" - RippleFieldclasscorePropagate a disturbance across a patch of water surface and let it fade.
import { RippleField } from "@threenative/core" - ScatterField3DclasscoreStream instanced copies of any baked mesh around a follow point, with distance thinning and levels of detail, from the game's own placement rule.
import { ScatterField3D } from "@threenative/core" - SceneclasscoreImplement a portable Godot-shaped game scene lifecycle.
import { Scene } from "@threenative/core" - ScenePickerclasscoreRaycast the game scene using the framework's picker.
import { ScenePicker } from "@threenative/core" - sceneWarningfunctioncoreWarn the agent that built the scene before a human plays it: a frame whose GPU is idle while its JS render phase is longer than the display's own period is a scene-shape problem, and the engine already has the shape.
import { sceneWarning } from "@threenative/core" - SchedulerclasscoreSchedule delayed and repeating callbacks or tween numeric properties with game-owned cleanup.
import { Scheduler } from "@threenative/core" - ScreenProbeGatherclasscoreLumen's Screen Probe Gather: one probe per 16 x 16 pixels traces an 8 x 8 octahedron of rays, the probes are filtered into an irradiance octahedron each, and a pixel blends the four nearest probes it can see, instead of every pixel tracing its own rays.
import { ScreenProbeGather } from "@threenative/core" - setAttitudefunctioncoreFly a fixed-wing aircraft with a real force balance instead of a steered velocity.
import { setAttitude } from "@threenative/core" - setSpanRecorderfunctioncoreAttribute the render phase to 100% with a nested span tree, off unless TN_FRAME_SPANS asks.
import { setSpanRecorder } from "@threenative/core" - ShadowFilterBudgetclasscoreSteps a game's soft-shadow tier down (low, medium, high) when the whole GPU frame stays over the frame period, and back up when the frame has room, by the settings of Unreal's virtual shadow map budget (a linear model, 5% headroom).
import { ShadowFilterBudget } from "@threenative/core" - ShortRangeAOclasscoreUnreal's Short Range AO: a horizon search of 2 sweeps around the view normal, 3 samples each at the squared fraction of a 32 px screen reach, at full resolution, with a bent normal at Epic.
import { ShortRangeAO } from "@threenative/core" - SkeletalMesh3DclasscoreShared preparation for an imported rigged character.
import { SkeletalMesh3D } from "@threenative/core" - skeletonBonesfunctioncoreList the names of every bone in a character hierarchy.
import { skeletonBones } from "@threenative/core" - SkyCaptureclasscoreCapture game-owned sky radiance into a sun-triggered, frame-budgeted environment map.
import { SkyCapture } from "@threenative/core" - SkyCaptureScheduleclasscoreCapture game-owned sky radiance into a sun-triggered, frame-budgeted environment map.
import { SkyCaptureSchedule } from "@threenative/core" - snapRefreshRatefunctioncoreRead what frame rate a game gets when its config does not say, and why.
import { snapRefreshRate } from "@threenative/core" - SoftBody3DclasscoreSimulate an ordinary game-authored triangle mesh as cloth on the existing fixed-step GPU lane.
import { SoftBody3D } from "@threenative/core" - softCircleDataTexturefunctioncoreBuild a soft round sprite as pixel data instead of painting a canvas.
import { softCircleDataTexture } from "@threenative/core" - solarPositionfunctioncoreCalculate solar elevation and azimuth from time, latitude, and longitude.
import { solarPosition } from "@threenative/core" - solarPositionAtfunctioncoreCalculate solar elevation and azimuth for one UTC date.
import { solarPositionAt } from "@threenative/core" - sourceAngleShadowFilterfunctioncoreSource-angle blocker search and variable-radius PCF on three's shadow map.
import { sourceAngleShadowFilter } from "@threenative/core" - sourceRadiusShadowFilterfunctioncoreSource-radius blocker search and variable-radius PCF on a spot or point light's shadow map.
import { sourceRadiusShadowFilter } from "@threenative/core" - spanNowfunctioncoreAttribute the render phase to 100% with a nested span tree, off unless TN_FRAME_SPANS asks.
import { spanNow } from "@threenative/core" - spanRecorderfunctioncoreAttribute the render phase to 100% with a nested span tree, off unless TN_FRAME_SPANS asks.
import { spanRecorder } from "@threenative/core" - SpanRecorderclasscoreAttribute the render phase to 100% with a nested span tree, off unless TN_FRAME_SPANS asks.
import { SpanRecorder } from "@threenative/core" - spansRequestedfunctioncoreAttribute the render phase to 100% with a nested span tree, off unless TN_FRAME_SPANS asks.
import { spansRequested } from "@threenative/core" - SpectralOceanclasscoreSimulate a spectral ocean — cascaded wave spectra inverse-transformed on the GPU each frame.
import { SpectralOcean } from "@threenative/core" - SpriteAnimator3DclasscoreAdvance a game-owned non-uniform sprite atlas on the fixed step.
import { SpriteAnimator3D } from "@threenative/core" - stageGpuReadingfunctioncoreRead the GPU milliseconds of each named render pass of the newest resolved frame, such as SSGI or AO, with the whole frame's total.
import { stageGpuReading } from "@threenative/core" - staticTransformCensusfunctioncoreStop recomposing the transforms of a subtree nobody moves.
import { staticTransformCensus } from "@threenative/core" - SurfaceCacheclasscoreThe Surface Cache: what a traced global-illumination ray reads where it hits a surface.
import { SurfaceCache } from "@threenative/core" - SurfaceLightsclasscoreThe local lamps at the hit of a traced ray: the point and spot lights whose range reaches it, the brightest eight, one shadow ray each.
import { SurfaceLights } from "@threenative/core" - thinCardsfunctioncoreA far level for a card mesh (needle or leaf quads): keep a share of its cards and grow each kept card about its own centre, so the crown holds its total surface area, as Unreal's Nanite "Preserve Area" foliage does.
import { thinCards } from "@threenative/core" - TracedReflectionsclasscoreReflection rays against the scene's triangles, in TSL.
import { TracedReflections } from "@threenative/core" - TracerPool3DclasscorePool travelling bullet-streak meshes for hitscan shots.
import { TracerPool3D } from "@threenative/core" - unlitFoliageWarningfunctioncoreTell the agent that built the scene that its imported foliage is drawing with no image-based light: an alpha-cutout MeshStandardMaterial (or its Node twin) with scene.environment unset and no envMap of its own gets a hemisphere fill and one flat dark value, which is cardboard.
import { unlitFoliageWarning } from "@threenative/core" - unmarkStaticfunctioncoreStop recomposing the transforms of a subtree nobody moves.
import { unmarkStatic } from "@threenative/core" - updateAtmosphereParametersfunctioncoreApply a partial game-owned atmosphere change while preserving validation.
import { updateAtmosphereParameters } from "@threenative/core" - updateClusteredMeshesfunctioncoreTake every clustered mesh under a root through this frame's cut, before the render.
import { updateClusteredMeshes } from "@threenative/core" - updateModelLodsfunctioncoreDraw a model at the detail its projected geometric error earns, from a chain the asset cook baked.
import { updateModelLods } from "@threenative/core" - useRoughDiffusefunctioncoreUnreal's Substrate rough diffuse (EON) on standard and physical materials, so direct sun and lamp light meets a rough surface the way Unreal shades it.
import { useRoughDiffuse } from "@threenative/core" - validateWorldMatricesfunctioncoreProve that nothing a cache skipped changed the picture: TN_RENDERLIST_VALIDATE=1 recomputes every world matrix the long way, every frame, and throws on the first element that disagrees with what the frame is about to draw.
import { validateWorldMatrices } from "@threenative/core" - velocityTexturefunctioncoreProvision screen-space motion data for temporal nodes and keep per-instance history at the frame boundary.
import { velocityTexture } from "@threenative/core" - VelocityTrackerclasscoreProvision screen-space motion data for temporal nodes and keep per-instance history at the frame boundary.
import { VelocityTracker } from "@threenative/core" - VirtualShadowNodeclasscoreOne directional shadow for a whole open world: camera-centred clip levels, each snapped to its own texel grid and re-rendered only when its window moves.
import { VirtualShadowNode } from "@threenative/core" - warmUpScenefunctioncoreWarms up scene for camera, in slices, presenting a frame between each.
import { warmUpScene } from "@threenative/core" - WaterSurface3DclasscoreGive a horizontal water surface the world mirrored in it, the world beneath it, and the metres of water between them.
import { WaterSurface3D } from "@threenative/core" - WaveFieldclasscoreEvaluate analytic waves on CPU and displace game-owned vertices with the matching TSL graph.
import { WaveField } from "@threenative/core" - withVelocityContextfunctioncoreProvision screen-space motion data for temporal nodes and keep per-instance history at the frame boundary.
import { withVelocityContext } from "@threenative/core" - WorldEnvironmentclasscoreThe node that says which lighting effects a scene runs and how strong they are, with a fresh Unreal 5.8.3 project's defaults: the filmic tone curve, Unreal-metered auto exposure, screen-space GI and ambient occlusion, SMAA, Unreal's bloom and local exposure.
import { WorldEnvironment } from "@threenative/core" - zenithTransmittancefunctioncoreReturn direct vertical transmittance for the supplied atmosphere.
import { zenithTransmittance } from "@threenative/core" - acceptHotUpdatefunctioncoreRegister hot-reload state preservation for a game.
import { acceptHotUpdate } from "@threenative/core/hot" - assertPortableStatefunctioncoreValidate that hot-reload state can cross the Vite boundary.
import { assertPortableState } from "@threenative/core/hot" - connectfunctioncoreOpen a bounded, authenticated WebTransport message channel shared by browser and native games.
import { connect } from "@threenative/core/net" - playtestfunctioncoreInstall the playtest bridge into a portable game.
import { playtest } from "@threenative/core/playtest" - createCssUiRootfunctioncoreMount React into a native CSS engine.
import { createCssUiRoot } from "@threenative/core/react-css" - createReactOverlayfunctioncore@threenative/core/react — React that renders on a phone, with no DOM and no WebView.
import { createReactOverlay } from "@threenative/core/react" - measureTextfunctioncoreWidth in pixels of a glyph run at a given cell height.
import { measureText } from "@threenative/core/react" - supportedGlyphsfunctioncoreEvery character this glyph set can draw, for error messages and for the templates' AGENTS.md.
import { supportedGlyphs } from "@threenative/core/react" - supportedStyleKeysfunctioncoreEvery style key the overlay implements, for the templates' AGENTS.md and for error messages.
import { supportedStyleKeys } from "@threenative/core/react" - TextfunctioncoreA run of bitmap glyphs, drawn as one instanced quad per lit pixel.
import { Text } from "@threenative/core/react" - ViewfunctioncoreA rectangle.
import { View } from "@threenative/core/react" - cachedEnvironmentSamplefunctioncoreThe sample this renderer took of scene's environment, if it is still current.
import { cachedEnvironmentSample } from "@threenative/core/render/environment" - cacheEnvironmentSamplefunctioncoreRemembers sample as this renderer's reading of scene's environment.
import { cacheEnvironmentSample } from "@threenative/core/render/environment" - captureEnvironmentSnapshotfunctioncoreThe provenance of a scene's environment: which texture, at which intensity, in which colour space.
import { captureEnvironmentSnapshot } from "@threenative/core/render/environment" - environmentSnapshotCurrentfunctioncoreWhether the scene's environment still matches the snapshot a sample was taken from.
import { environmentSnapshotCurrent } from "@threenative/core/render/environment" - isWebGLFallbackRendererfunctioncoreWhether a WebGPURenderer wrapper is running three's WebGL backend behind it.
import { isWebGLFallbackRenderer } from "@threenative/core/render/environment" - materialLightingEnabledfunctioncoreWhether tier may run the material-lighting lane in environment.
import { materialLightingEnabled } from "@threenative/core/render/environment" - measureEnvironmentfunctioncoreThe environment measure-and-sample mechanism every kit repeats: what the scene's environment actually contributes, a bounded GPU sample of it with a cache and a readback deadline, the provenance a stale readback is rejected by, and the gate that decides which renderer may run the material lane.
import { measureEnvironment } from "@threenative/core/render/environment" - reportEnvironmentContributionfunctioncoreThe environment measure-and-sample mechanism every kit repeats: what the scene's environment actually contributes, a bounded GPU sample of it with a cache and a readback deadline, the provenance a stale readback is rejected by, and the gate that decides which renderer may run the material lane.
import { reportEnvironmentContribution } from "@threenative/core/render/environment" - sampledRadiancefunctioncoreThe mean radiance and colour of a bounded linear sample, or unknown with the reason.
import { sampledRadiance } from "@threenative/core/render/environment" - sampleEnvironmentfunctioncoreMeasures and samples the scene's real environment on the GPU, bounded by a readback deadline.
import { sampleEnvironment } from "@threenative/core/render/environment" - samplingSourceSupportedfunctioncoreWhether an environment texture's mapping and colour space are qualified for the bounded GPU sample.
import { samplingSourceSupported } from "@threenative/core/render/environment" - CastPoolclasscoreStep a spell's timeline: charge, release, travel, impact, linger, done.
import { CastPool } from "@threenative/core/spells" - createAegisfunctioncoreA ward around the caster: it forms, holds, and breaks outward when it expires.
import { createAegis } from "@threenative/core/spells" - createArcaneBarragefunctioncoreA volley of arcane missiles: fast, precise, and each one pops on arrival.
import { createArcaneBarrage } from "@threenative/core/spells" - createFireballfunctioncoreA ball of fire that charges, crosses the room and leaves the floor burning.
import { createFireball } from "@threenative/core/spells" - createGlacialSpikefunctioncoreA shard of ice that flies flat and fast, and freezes the ground it breaks on.
import { createGlacialSpike } from "@threenative/core/spells" - createInfernofunctioncoreA pillar of fire that erupts where it lands and keeps burning.
import { createInferno } from "@threenative/core/spells" - createSpellfunctioncoreBuild a spell from a recipe: four beats, a tint, and the numbers between them.
import { createSpell } from "@threenative/core/spells" - createThunderstrikefunctioncoreA bolt out of the sky: it charges, strikes the point instantly, and the ground remembers it.
import { createThunderstrike } from "@threenative/core/spells" - ParticleKindTableclasscoreTune what a particle kind does, as data rather than a shader.
import { ParticleKindTable } from "@threenative/core/spells" - ReactionFieldclasscoreThe marks a spell leaves on the floor: heat, char, wet, frost, crack and glow.
import { ReactionField } from "@threenative/core/spells" - SpellLightsclasscoreA fixed pool of spell lights, created once at zero intensity.
import { SpellLights } from "@threenative/core/spells" - SpellWorldclasscoreEverything a spell may touch: the scene, the floor, the light pool, the surface field, one shake and one flash limiter.
import { SpellWorld } from "@threenative/core/spells" - bakeNoisefunctioncoreCPU bake of the Ultra Elements 3D noise, curl and blackbody textures that every spell volume samples.
import { bakeNoise } from "@threenative/core/spells/ultra" - createFxfunctioncoreThe shared Ultra Elements spell world: casts, volumes, spell lights and the per-frame CPU tick.
import { createFx } from "@threenative/core/spells/ultra" - groundShadefunctioncoreThe Ultra Elements arena floor's response to the ground field and spell impacts (scorch, char, wet, glowing hot ground) as nodes for a game's own floor material: color, roughness, metalness, emissive from the floor's own surface at a world position.
import { groundShade } from "@threenative/core/spells/ultra" - ParticlesclasscoreThe Ultra Elements GPU particle system behind fx.particles: a spell's kinds, emitters and field emitters.
import { Particles } from "@threenative/core/spells/ultra" - connectUiBridgefunctioncoreOpen the message channel between a game and its UI, whatever host is underneath.
import { connectUiBridge } from "@threenative/core/ui-layer" - onUiIntentfunctioncoreHandle the actions a UI sends back to the game.
import { onUiIntent } from "@threenative/core/ui-layer" - publishHitRegionsfunctioncoreTell the native input host where a UI's touchable controls are.
import { publishHitRegions } from "@threenative/core/ui-layer" - publishUiStatefunctioncorePublish the game's state so a UI in another process can mirror it.
import { publishUiState } from "@threenative/core/ui-layer" - sendUiIntentfunctioncoreSend a player action from the UI back to the game.
import { sendUiIntent } from "@threenative/core/ui-layer" - subscribeUiStatefunctioncoreMirror the game's published state on the UI side.
import { subscribeUiState } from "@threenative/core/ui-layer" - serveWorkerGamefunctioncoreRuns inside the worker: wire the page's messages to the unchanged portable game.
import { serveWorkerGame } from "@threenative/core/worker" - startWorkerGamefunctioncoreRuns on the page: own the canvas and the DOM, and feed the worker game.
import { startWorkerGame } from "@threenative/core/worker" - AdmissionBudgetclasscoreOne frame's admission allowance, shared by every path that puts streamed content on screen.
import { AdmissionBudget } from "@threenative/core/world" - applyTerrainSurfacefunctioncoreApply a cooked GLB's package-authored layered surface to its marked terrain meshes.
import { applyTerrainSurface } from "@threenative/core/world" - bakedFractalNoisefunctioncoreDrop-in for mx_fractal_noise_float(p, octaves, lacunarity, diminish, amplitude): one read an octave.
import { bakedFractalNoise } from "@threenative/core/world" - bakedNoisefunctioncoreDrop-in for mx_noise_float(p, amplitude, pivot) on a vec3 p: one filtered read of the baked volume instead of the per-pixel Perlin.
import { bakedNoise } from "@threenative/core/world" - baseRingGapfunctioncoreThe highest gap between a wide model's rim and the ground, one sample per angular sector: in each sector, the lowest vertex beyond rim of that sector's reach.
import { baseRingGap } from "@threenative/core/world" - cellPlacementsfunctioncoreBorrow the run's placement records as a live view over the placement buffer.
import { cellPlacements } from "@threenative/core/world" - footprintGapfunctioncoreHow far the flat underside of a static geometry rises above the ground at its highest point.
import { footprintGap } from "@threenative/core/world" - getWorldCapabilitiesfunctioncoreResolve the active world-generation path from host capability facts.
import { getWorldCapabilities } from "@threenative/core/world" - HeightfieldclasscoreOne height buffer shared by world queries, rendered geometry, and a physics heightfield.
import { Heightfield } from "@threenative/core/world" - HeightfieldCollarclasscoreA heightfield's far ring: rings square rings past its playable square, one vertex per boundary sample, and the index grid that draws them.
import { HeightfieldCollar } from "@threenative/core/world" - heightSamplerFromHeightmapfunctioncoreBuild a game-usable sampleHeight from a raw v1 heightmap.
import { heightSamplerFromHeightmap } from "@threenative/core/world" - instanceRandomfunctioncoreA random in [0, 1) that stays with its instance, as UE 5.8.3's PerInstanceRandom: hashed from the instance's world origin, never from its draw slot.
import { instanceRandom } from "@threenative/core/world" - lakeReachfunctioncoreHow far a lake's water reaches: the waterline its basin measures, margin times out, capped.
import { lakeReach } from "@threenative/core/world" - lakeSurfaceGeometryfunctioncoreA lake's water surface: a level disc out to lakeReach, the footprint WaterBodies floods, with a metres attribute (water depth over the ground).
import { lakeSurfaceGeometry } from "@threenative/core/world" - loadTerrainSplatfunctioncoreThe splat terrain surface a world package describes, for WorldCells.load({ surface }).
import { loadTerrainSplat } from "@threenative/core/world" - loadWorldHeightmapfunctioncoreFetch a raw little-endian uint16 heightmap and expose it as samples.
import { loadWorldHeightmap } from "@threenative/core/world" - meshSectionsfunctioncoreA mesh's material sections: one per geometry group for a material array, else the whole mesh.
import { meshSections } from "@threenative/core/world" - noiseVolumefunctioncoreThe one volume every material shares: baked on first use, 1 MiB of RGBA8 (it stays in L2).
import { noiseVolume } from "@threenative/core/world" - repairZeroNormalsfunctioncoreRecompute the normals of a geometry whose normals are missing, zero or not finite, and leave authored normals alone.
import { repairZeroNormals } from "@threenative/core/world" - riverRibbonGeometryfunctioncoreThe water surface of every river, as one geometry with one group per river.
import { riverRibbonGeometry } from "@threenative/core/world" - sectionGeometryfunctioncoreOne section's geometry in model space, standing on y = 0.
import { sectionGeometry } from "@threenative/core/world" - shoreFieldfunctioncoreDistance to the shore and open-sea exposure for every node of a square height grid, measured once from the bake.
import { shoreField } from "@threenative/core/world" - snowDiscFootprintfunctioncoreA circular contact footprint, sized from a radius the caller measures.
import { snowDiscFootprint } from "@threenative/core/world" - SnowFieldclasscorePersistent snow deformation over one canonical heightfield.
import { SnowField } from "@threenative/core/world" - staticLowestYfunctioncoreExact lowest world Y of a static geometry under matrix, the precise measurement GroundSnap audits against, cheap enough for a load that poses hundreds of thousands of props.
import { staticLowestY } from "@threenative/core/world" - surfaceSamplerfunctioncoreHeightfield.surfaceAt under the transform the game draws the field's mesh with, so a prop or a player stands on the triangles the eye sees rather than on the bilinear field between them.
import { surfaceSampler } from "@threenative/core/world" - TerrainTilesclasscoreStream a bounded square of game-authored heightfields and keep their render and physics units together.
import { TerrainTiles } from "@threenative/core/world" - terrainValidationRequestedfunctioncoreWhether TN_TERRAIN_VALIDATE asks for terrain validation on this launch.
import { terrainValidationRequested } from "@threenative/core/world" - validateWorldPackagefunctioncoreValidate a world.json manifest against the v1 contract.
import { validateWorldPackage } from "@threenative/core/world" - warmUnculledfunctioncoreDraw root with frustum culling off until it has drawn draws times, then cull it again and resolve.
import { warmUnculled } from "@threenative/core/world" - WaterBodiesclasscoreOne world's water, queried: surface height, current and footprint from the baked arrays.
import { WaterBodies } from "@threenative/core/world" - waterlineRadiusfunctioncoreThe furthest a lake's basin reaches on a bearing: where the drawn ground crosses its level.
import { waterlineRadius } from "@threenative/core/world" - WorldCellsclasscoreStream a Blender-authored world package by cell and keep it resident around a followed point.
import { WorldCells } from "@threenative/core/world" - ctx.assets.memofunctioncoreReturns what build returned the last time this build of the game ran, read back from disk, and calls build only when nothing is stored.
src/assets.ts - renderer.matrixWorldfunctioncoreThe per-frame world-matrix walk, on by default as "visible": a hidden subtree — a full-detail body behind a merged stand-in, a hidden LOD level, a parked or hangared model — is not recursed into, so nothing that cannot draw pays a world-matrix multiply.
src/game.ts - renderer.minimumProjectedPixelsfunctioncoreDo not submit what the render camera cannot resolve.
src/game.ts - renderer.projectionfunctioncoreThe engine's scene-render projection — an internal mirror that collapses repeated draws, including animated skinned rigs that share a geometry and material into one palette draw per pass — on by default.
src/game.ts - ctx.afterfunctioncoreRuns callback once, delay seconds of game time later, and returns a handle that cancels it.
src/scene.ts - ctx.beforeRenderfunctioncoreRegisters work that runs once per actual world render, after the frame's last fixed update and before the projection reconciles and the renderer draws.
src/scene.ts - ctx.startup.progressfunctioncoreHow much of the start scene has loaded and presented, 0 to 1, for a loading cover's bar.
src/scene.ts - assertJsonSafefunctionplaytestValidate JSON-safe bridge messages and protocol sizes.
import { assertJsonSafe } from "@threenative/playtest" - DeviceMetricsErrorclassplaytestMeasure and judge device thermal, power and battery state around a device playtest run.
import { DeviceMetricsError } from "@threenative/playtest" - DeviceMetricsRecorderclassplaytestMeasure and judge device thermal, power and battery state around a device playtest run.
import { DeviceMetricsRecorder } from "@threenative/playtest" - evaluateRichPlaytestAssertionsfunctionplaytestEvaluate rich semantic assertions against captured observations.
import { evaluateRichPlaytestAssertions } from "@threenative/playtest" - invalidScenariofunctionplaytestConstruct a named invalid-scenario error without loading or executing a scenario.
import { invalidScenario } from "@threenative/playtest" - jsonByteLengthfunctionplaytestValidate JSON-safe bridge messages and protocol sizes.
import { jsonByteLength } from "@threenative/playtest" - loadPlaytestScenariofunctionplaytestLoad and validate a scenario and its referenced evidence before running it.
import { loadPlaytestScenario } from "@threenative/playtest" - missingPlaytestCapabilitiesfunctionplaytestValidate and inspect playtest capability declarations.
import { missingPlaytestCapabilities } from "@threenative/playtest" - parseDeviceBatteryfunctionplaytestMeasure and judge device thermal, power and battery state around a device playtest run.
import { parseDeviceBattery } from "@threenative/playtest" - parseDeviceCurrentfunctionplaytestMeasure and judge device thermal, power and battery state around a device playtest run.
import { parseDeviceCurrent } from "@threenative/playtest" - parseDevicePowerRailsfunctionplaytestMeasure and judge device thermal, power and battery state around a device playtest run.
import { parseDevicePowerRails } from "@threenative/playtest" - parseDeviceThermalfunctionplaytestMeasure and judge device thermal, power and battery state around a device playtest run.
import { parseDeviceThermal } from "@threenative/playtest" - playtestDiagnosticfunctionplaytestCreate a structured playtest diagnostic.
import { playtestDiagnostic } from "@threenative/playtest" - PlaytestScenarioErrorclassplaytestCarry a structured scenario validation diagnostic as an error.
import { PlaytestScenarioError } from "@threenative/playtest" - playtestStepHoldTicksfunctionplaytestRead a validated step's input-hold duration in simulation ticks.
import { playtestStepHoldTicks } from "@threenative/playtest" - playtestStepWaitTicksfunctionplaytestRead a validated step's no-input duration in simulation ticks.
import { playtestStepWaitTicks } from "@threenative/playtest" - rejectUnknownKeysfunctionplaytestReject object keys outside the explicitly allowed scenario fields.
import { rejectUnknownKeys } from "@threenative/playtest" - requiredPlaytestCapabilitiesfunctionplaytestEvaluate rich semantic assertions against captured observations.
import { requiredPlaytestCapabilities } from "@threenative/playtest" - resolveDiagnosticsPolicyfunctionplaytestResolve the effective diagnostics policy for a run, with fail-closed defaults applied.
import { resolveDiagnosticsPolicy } from "@threenative/playtest" - summarizeDeviceMetricsfunctionplaytestMeasure and judge device thermal, power and battery state around a device playtest run.
import { summarizeDeviceMetrics } from "@threenative/playtest" - unknownPlaytestCapabilitiesfunctionplaytestValidate and inspect playtest capability declarations.
import { unknownPlaytestCapabilities } from "@threenative/playtest" - assertCaptureNotBlankfunctionplaytestFail closed when a screenshot is blank or uniform.
import { assertCaptureNotBlank } from "@threenative/playtest/capture" - assertDesktopCaptureNotBlankfunctionplaytestFail closed when a desktop-host frame shows no rendered content.
import { assertDesktopCaptureNotBlank } from "@threenative/playtest/capture" - assertFrameShowsSomethingfunctionplaytestFail closed when a screenshot is blank or uniform.
import { assertFrameShowsSomething } from "@threenative/playtest/capture" - CaptureGuardErrorclassplaytestExplain why a captured frame failed the non-blank guard.
import { CaptureGuardError } from "@threenative/playtest/capture" - collectRegionalTonefunctionplaytestCollect opt-in regional tone observations from the same acquired PNG.
import { collectRegionalTone } from "@threenative/playtest/capture" - inspectFramefunctionplaytestInspect a PNG frame for visible pixels and luminance variation.
import { inspectFrame } from "@threenative/playtest/capture" - assertJsonSafefunctionplaytestReject any value that would not survive JSON serialization.
import { assertJsonSafe } from "@threenative/playtest/protocol" - jsonByteLengthfunctionplaytestMeasure a payload's wire size in bytes.
import { jsonByteLength } from "@threenative/playtest/protocol" - requestedPlaytestClockModefunctionplaytestThe clock the host asked for, or undefined for the default deterministic run.
import { requestedPlaytestClockMode } from "@threenative/playtest/protocol" - absolutesVerdictfunctionplaytestThe host-load reading and the rule that decides whether absolute milliseconds are trustworthy: absolutes are invalid once the one-minute load passes half the cores.
import { absolutesVerdict } from "@threenative/playtest/runner" - AdbAndroidDriverclassplaytestDrive and inspect Android playtest transport.
import { AdbAndroidDriver } from "@threenative/playtest/runner" - advanceFixedStepfunctionplaytestExecute scenario steps, assertions, and evidence capture.
import { advanceFixedStep } from "@threenative/playtest/runner" - advanceTimeoutMsfunctionplaytestConnect a Playwright page to a playtest bridge.
import { advanceTimeoutMs } from "@threenative/playtest/runner" - androidMailboxPathsfunctionplaytestResolve a native device transport and its mailbox paths.
import { androidMailboxPaths } from "@threenative/playtest/runner" - androidTouchBatchesfunctionplaytestDrive and inspect Android playtest transport.
import { androidTouchBatches } from "@threenative/playtest/runner" - batchArtifactDirectoryfunctionplaytestExecute scenario steps, assertions, and evidence capture.
import { batchArtifactDirectory } from "@threenative/playtest/runner" - boundedTeardownStepfunctionplaytestExecute scenario steps, assertions, and evidence capture.
import { boundedTeardownStep } from "@threenative/playtest/runner" - bridgeWaitTimeoutMsfunctionplaytestConnect a Playwright page to a playtest bridge.
import { bridgeWaitTimeoutMs } from "@threenative/playtest/runner" - buildReportfunctionplaytestExecute scenario steps, assertions, and evidence capture.
import { buildReport } from "@threenative/playtest/runner" - captureVisualSurfacefunctionplaytestExecute scenario steps, assertions, and evidence capture.
import { captureVisualSurface } from "@threenative/playtest/runner" - connectPlaytestBridgefunctionplaytestConnect a Playwright page to a playtest bridge.
import { connectPlaytestBridge } from "@threenative/playtest/runner" - connectPlaytestBridgeTransportfunctionplaytestConnect a Playwright page to a playtest bridge.
import { connectPlaytestBridgeTransport } from "@threenative/playtest/runner" - decideDisplayStrategyfunctionplaytestDecide which display a pixel-producing run paints on, the same decision the runner makes.
import { decideDisplayStrategy } from "@threenative/playtest/runner" - desktopConsoleTypefunctionplaytestDrive a local desktop playtest mailbox.
import { desktopConsoleType } from "@threenative/playtest/runner" - DesktopPlaytestDriverclassplaytestDrive a local desktop playtest mailbox.
import { DesktopPlaytestDriver } from "@threenative/playtest/runner" - DeviceBridgeTransportclassplaytestResolve a native device transport and its mailbox paths.
import { DeviceBridgeTransport } from "@threenative/playtest/runner" - deviceMailboxPathsfunctionplaytestResolve a native device transport and its mailbox paths.
import { deviceMailboxPaths } from "@threenative/playtest/runner" - DeviceMailboxTransportclassplaytestResolve a native device transport and its mailbox paths.
import { DeviceMailboxTransport } from "@threenative/playtest/runner" - deviceTimeoutDiagnosticfunctionplaytestResolve a native device transport and its mailbox paths.
import { deviceTimeoutDiagnostic } from "@threenative/playtest/runner" - discoverAdbfunctionplaytestDrive and inspect Android playtest transport.
import { discoverAdb } from "@threenative/playtest/runner" - failedDiagnosticsAssertionfunctionplaytestExecute scenario steps, assertions, and evidence capture.
import { failedDiagnosticsAssertion } from "@threenative/playtest/runner" - formatPipelineSummaryfunctionplaytestParse and explain bounded shader-compilation captures.
import { formatPipelineSummary } from "@threenative/playtest/runner" - formatUsagefunctionplaytestParse standalone playtest runner configuration.
import { formatUsage } from "@threenative/playtest/runner" - handlePlaytestSignalfunctionplaytestExecute scenario steps, assertions, and evidence capture.
import { handlePlaytestSignal } from "@threenative/playtest/runner" - initStandalonePlaytestfunctionplaytestInitialize the standalone playtest files for a project.
import { initStandalonePlaytest } from "@threenative/playtest/runner" - isRuntimeReadoutfunctionplaytestExecute scenario steps, assertions, and evidence capture.
import { isRuntimeReadout } from "@threenative/playtest/runner" - keyboardIsShownfunctionplaytestDrive and inspect Android playtest transport.
import { keyboardIsShown } from "@threenative/playtest/runner" - LocalDeviceMailboxclassplaytestDrive a local desktop playtest mailbox.
import { LocalDeviceMailbox } from "@threenative/playtest/runner" - ManagedServerErrorclassplaytestExecute scenario steps, assertions, and evidence capture.
import { ManagedServerError } from "@threenative/playtest/runner" - openPageAndConnectBridgefunctionplaytestExecute scenario steps, assertions, and evidence capture.
import { openPageAndConnectBridge } from "@threenative/playtest/runner" - pageLifecycleDiagnosticfunctionplaytestExecute scenario steps, assertions, and evidence capture.
import { pageLifecycleDiagnostic } from "@threenative/playtest/runner" - parseAndroidConsolefunctionplaytestDrive and inspect Android playtest transport.
import { parseAndroidConsole } from "@threenative/playtest/runner" - parseAndroidTouchViewportfunctionplaytestDrive and inspect Android playtest transport.
import { parseAndroidTouchViewport } from "@threenative/playtest/runner" - parseLaunchedPidfunctionplaytestDrive and inspect iOS simulator playtest transport.
import { parseLaunchedPid } from "@threenative/playtest/runner" - parsePipelineCapturefunctionplaytestParse and explain bounded shader-compilation captures.
import { parsePipelineCapture } from "@threenative/playtest/runner" - parsePipelineEventMarkersfunctionplaytestParse and explain bounded shader-compilation captures.
import { parsePipelineEventMarkers } from "@threenative/playtest/runner" - parseStandalonePlaytestArgsfunctionplaytestParse standalone playtest runner configuration.
import { parseStandalonePlaytestArgs } from "@threenative/playtest/runner" - PlaytestBridgeErrorclassplaytestConnect a Playwright page to a playtest bridge.
import { PlaytestBridgeError } from "@threenative/playtest/runner" - PlaytestCliUsageErrorclassplaytestParse standalone playtest runner configuration.
import { PlaytestCliUsageError } from "@threenative/playtest/runner" - playtestStepDrivesMovementfunctionplaytestExecute scenario steps, assertions, and evidence capture.
import { playtestStepDrivesMovement } from "@threenative/playtest/runner" - PlaywrightTransportclassplaytestConnect a Playwright page to a playtest bridge.
import { PlaywrightTransport } from "@threenative/playtest/runner" - preflightDisplayfunctionplaytestExecute scenario steps, assertions, and evidence capture.
import { preflightDisplay } from "@threenative/playtest/runner" - readHostLoadfunctionplaytestThe host-load reading and the rule that decides whether absolute milliseconds are trustworthy: absolutes are invalid once the one-minute load passes half the cores.
import { readHostLoad } from "@threenative/playtest/runner" - reconcileBrowserPointersfunctionplaytestCompare pointer snapshots and produce down, move, and up transitions.
import { reconcileBrowserPointers } from "@threenative/playtest/runner" - recordToScenariofunctionplaytestConvert captured runner observations into a replay scenario.
import { recordToScenario } from "@threenative/playtest/runner" - requireAssertionsfunctionplaytestConvert captured runner observations into a replay scenario.
import { requireAssertions } from "@threenative/playtest/runner" - resolveBrowserArgumentsfunctionplaytestCopy the selected Chromium arguments without silently enabling a rendering recipe.
import { resolveBrowserArguments } from "@threenative/playtest/runner" - resolveDesktopExecutablefunctionplaytestRun a desktop playtest and collect its report.
import { resolveDesktopExecutable } from "@threenative/playtest/runner" - resolveDesktopLaunchfunctionplaytestRun a desktop playtest and collect its report.
import { resolveDesktopLaunch } from "@threenative/playtest/runner" - resolveManagedServerCommandfunctionplaytestExecute scenario steps, assertions, and evidence capture.
import { resolveManagedServerCommand } from "@threenative/playtest/runner" - resolveManagedServerConfigfunctionplaytestExecute scenario steps, assertions, and evidence capture.
import { resolveManagedServerConfig } from "@threenative/playtest/runner" - rotatedTouchPositionfunctionplaytestDrive and inspect Android playtest transport.
import { rotatedTouchPosition } from "@threenative/playtest/runner" - runAndroidPlaytestfunctionplaytestRun a playtest on Android through the configured device transport.
import { runAndroidPlaytest } from "@threenative/playtest/runner" - runDesktopPlaytestfunctionplaytestRun a desktop playtest and collect its report.
import { runDesktopPlaytest } from "@threenative/playtest/runner" - runDevicePlaytestfunctionplaytestRun a playtest on any device lane (Android, desktop or iOS) through its driver and transport.
import { runDevicePlaytest } from "@threenative/playtest/runner" - runIosPlaytestfunctionplaytestRun a playtest on the iOS simulator or device transport.
import { runIosPlaytest } from "@threenative/playtest/runner" - runStandalonePlaytestfunctionplaytestExecute scenario steps, assertions, and evidence capture.
import { runStandalonePlaytest } from "@threenative/playtest/runner" - runStandalonePlaytestsfunctionplaytestExecute scenario steps, assertions, and evidence capture.
import { runStandalonePlaytests } from "@threenative/playtest/runner" - softwareAdapterNamefunctionplaytestIdentify a software renderer in the fields reported by adapter.info.
import { softwareAdapterName } from "@threenative/playtest/runner" - substituteManagedPortfunctionplaytestExecute scenario steps, assertions, and evidence capture.
import { substituteManagedPort } from "@threenative/playtest/runner" - summarizePipelineCapturefunctionplaytestParse and explain bounded shader-compilation captures.
import { summarizePipelineCapture } from "@threenative/playtest/runner" - tapCommandfunctionplaytestDrive and inspect Android playtest transport.
import { tapCommand } from "@threenative/playtest/runner" - touchPositionForViewportfunctionplaytestDrive and inspect Android playtest transport.
import { touchPositionForViewport } from "@threenative/playtest/runner" - touchRotationFromWindowDumpfunctionplaytestDrive and inspect Android playtest transport.
import { touchRotationFromWindowDump } from "@threenative/playtest/runner" - validateDeviceEndpointfunctionplaytestResolve a native device transport and its mailbox paths.
import { validateDeviceEndpoint } from "@threenative/playtest/runner" - viewportPresentationCommandsfunctionplaytestDrive and inspect Android playtest transport.
import { viewportPresentationCommands } from "@threenative/playtest/runner" - viewportPresentationObservedfunctionplaytestDrive and inspect Android playtest transport.
import { viewportPresentationObserved } from "@threenative/playtest/runner" - viewportRestoreCommandsfunctionplaytestDrive and inspect Android playtest transport.
import { viewportRestoreCommands } from "@threenative/playtest/runner" - withBrowserCapturefunctionplaytestCapture a ready ThreeNative game with the runner's display, lock, server and browser ownership.
import { withBrowserCapture } from "@threenative/playtest/runner" - withScenarioClockfunctionplaytestParse standalone playtest runner configuration.
import { withScenarioClock } from "@threenative/playtest/runner" - writeCaptureProvenancefunctionplaytestExecute scenario steps, assertions, and evidence capture.
import { writeCaptureProvenance } from "@threenative/playtest/runner" - writeObservationArtifactsfunctionplaytestExecute scenario steps, assertions, and evidence capture.
import { writeObservationArtifacts } from "@threenative/playtest/runner" - XcrunIosDriverclassplaytestDrive and inspect iOS simulator playtest transport.
import { XcrunIosDriver } from "@threenative/playtest/runner" - adviseThreeRenderWorkloadfunctionplaytestExplain which render workloads should be collapsed or retained.
import { adviseThreeRenderWorkload } from "@threenative/playtest/three" - connectDevicePlaytestBridgefunctionplaytestConnect a device-hosted game to the playtest bridge.
import { connectDevicePlaytestBridge } from "@threenative/playtest/three" - installThreePlaytestBridgefunctionplaytestInstall the playtest observation bridge for a plain Three.js game.
import { installThreePlaytestBridge } from "@threenative/playtest/three" - observeSceneResourcesfunctionplaytestObserve the room a game is played in — lights, materials, fog, background and camera framing.
import { observeSceneResources } from "@threenative/playtest/three" - readPlaytestEndpointfunctionplaytestConnect a device-hosted game to the playtest bridge.
import { readPlaytestEndpoint } from "@threenative/playtest/three" - ThreePlaytestPhysicsRecorderclassplaytestRecord Three.js physics bodies for playtest observations.
import { ThreePlaytestPhysicsRecorder } from "@threenative/playtest/three" - applyPlacementOverridesfunctionterrainAttach manual transforms to raw evaluated candidates and report orphan keys.
import { applyPlacementOverrides } from "@threenative/terrain" - bakeBiomefunctionterrainBake one biome: the recipe's evaluated state and the world package it streams.
import { bakeBiome } from "@threenative/terrain" - bakeMeshfunctionterrainBakes the recovered indexed top surface and optional vertical skirts into caller-owned arrays.
import { bakeMesh } from "@threenative/terrain" - bakeTerrainfunctionterrainBakes finite LOD chunks, the same collision samples and resolved placements.
import { bakeTerrain } from "@threenative/terrain" - bakeWorldPackagefunctionterrainBake an evaluated terrain into the engine's world package: a world.json manifest, a uint16 heightmap, a splat mask array, a placement buffer of eight float32 per instance, a placement ID sidecar and the square cells that stream them.
import { bakeWorldPackage } from "@threenative/terrain" - collarSamplerfunctionterrainThe collar's height at any (x, z), and a way to raise one of its per-vertex attributes at a placement: both read the collar's own quad grid, so a lane that reshapes the collar moves the trees with it.
import { collarSampler } from "@threenative/terrain" - compilePropBucketsfunctionterrainGroup placements into their streamed worlds and write each world's cells and records.
import { compilePropBuckets } from "@threenative/terrain" - createSegmentIndexfunctionterrainBuild the index once per world; ask nearby per scatter candidate or heightfield vertex.
import { createSegmentIndex } from "@threenative/terrain" - decodeHeightPNGfunctionterrainCRC-checked bounded non-interlaced grayscale PNG height decoder.
import { decodeHeightPNG } from "@threenative/terrain" - decodePropBucketfunctionterrainThe records of one compiled prop bucket, read back in record order: the inverse of compilePropBuckets, so a loader that fetched a bake's files gets each record's ID, model, pose and reach without re-deriving the container layout.
import { decodePropBucket } from "@threenative/terrain" - decodeRAW16functionterrainValidates dimensions and range before decoding numerical height samples.
import { decodeRAW16 } from "@threenative/terrain" - encodeGLBfunctionterrainLegacy terrain-only GLB encoding with embedded mesh arrays and no chosen material.
import { encodeGLB } from "@threenative/terrain" - encodeHeightPNGfunctionterrainEncodes numerical grayscale PNG16 with embedded elevation range.
import { encodeHeightPNG } from "@threenative/terrain" - encodeRAW16functionterrainEncodes finite metre elevations as an explicit-range RAW16 buffer.
import { encodeRAW16 } from "@threenative/terrain" - encodeSplatPNGsfunctionterrainEncodes the eight linear material-weight channels as two RGBA images.
import { encodeSplatPNGs } from "@threenative/terrain" - encodeZIPfunctionterrainDeterministic store-method ZIP with safe unique relative filenames.
import { encodeZIP } from "@threenative/terrain" - farForestPlacementsfunctionterrainFar-field placements on the collar; also paints the collar's canopy attribute under each crown.
import { farForestPlacements } from "@threenative/terrain" - fieldWeightfunctionterrainA field's weight at (x, z), clamped to 0..1.
import { fieldWeight } from "@threenative/terrain" - gradientAtfunctionterrainWorld-space height gradient from the canonical samples.
import { gradientAt } from "@threenative/terrain" - grassFieldFromBiomefunctionterrainTurns a terrain biome's grass rows and its ground into GrassField3D placement options, so a generated or cooked world grows streamed grass with one call.
import { grassFieldFromBiome } from "@threenative/terrain" - landformfunctionterrainOne call, one landscape: a calibrated layer recipe for a kind of environment.
import { landform } from "@threenative/terrain" - landformBackdropfunctionterrainDistant mountains around a playable area: a landform window with a valley floor at its centre.
import { landformBackdrop } from "@threenative/terrain" - liftMassiffunctionterrainA tile's mountain above its own foot: the heights minus a smooth surface through its border, so its edge is exactly zero and stands on any ground with no wall or ramp.
import { liftMassif } from "@threenative/terrain" - makeExportfunctionterrainRecovered numerical/project exports; GLB/runtime outputs contain terrain only.
import { makeExport } from "@threenative/terrain" - measureBandsfunctionterrainResolve a biome's fraction bands against this world's own height samples.
import { measureBands } from "@threenative/terrain" - orderedScatterRulesfunctionterrainA biome's rows as the ordered generators read them.
import { orderedScatterRules } from "@threenative/terrain" - paintCanopyCoverfunctionterrainPaint each placed tree's crown into a per-vertex canopy grid, so the ground under a stand reads as forest floor rather than open turf.
import { paintCanopyCover } from "@threenative/terrain" - placeMassiffunctionterrainStands one surveyed mountain behind a world, chosen and posed by a seed: the tile from a list, a point on a bearing and distance, a turn that faces its steepest wall to the centre within 20 degrees, a mirror and a summit height.
import { placeMassif } from "@threenative/terrain" - propAssetOffunctionterrainThe asset a package run names.
import { propAssetOf } from "@threenative/terrain" - propPackageFilefunctionterrainA path under world/ that no bucket name can break: local:true becomes local-true.
import { propPackageFile } from "@threenative/terrain" - propPackageFilesfunctionterrainWrite a compiled package as the manifest the game fetches and one set of files per bucket.
import { propPackageFiles } from "@threenative/terrain" - sampleHeightfunctionterrainBilinear query of canonical height samples; triangle sampling is a separate contract.
import { sampleHeight } from "@threenative/terrain" - scatterPropsfunctionterrainEvery placement, for one world, from one seed: the game's own rule set, in its own draw order.
import { scatterProps } from "@threenative/terrain" - skyVisibilityfunctionterrainThe share of the sky each heightfield vertex sees past the terrain around it: 1 on open ground, lower on a valley floor, at a cliff foot or in a crater.
import { skyVisibility } from "@threenative/terrain" - slopeAtIndexfunctionterrainSlope in degrees at a heightfield sample.
import { slopeAtIndex } from "@threenative/terrain" - slopeQuantilefunctionterrainA slope, in degrees, that the given share of this terrain's interior vertices lie at or below.
import { slopeQuantile } from "@threenative/terrain" - splinePointsfunctionterrainRecovered horizontal Catmull–Rom and vertically linear profile sampler.
import { splinePoints } from "@threenative/terrain" - TerrainclassterrainOrdered, stable-ID terrain authoring with synchronous atomic transactions.
import { Terrain } from "@threenative/terrain" - TerrainEvaluatorclassterrainRecovered prefix-caching authoring evaluator.
import { TerrainEvaluator } from "@threenative/terrain" - terrainStatsfunctionterrainLandform statistics used to calibrate generators against real DEMs.
import { terrainStats } from "@threenative/terrain" - validateBiomefunctionterrainOne biome file, checked field by field.
import { validateBiome } from "@threenative/terrain" - validateDocumentfunctionterrainValidates the recovered recipe schema, operation allow-lists and numeric bounds.
import { validateDocument } from "@threenative/terrain" - validatePlacementOverridesfunctionterrainValidate and clone stable-key placement transforms before saving or previewing them.
import { validatePlacementOverrides } from "@threenative/terrain" - checkEnvironmentAssetsfunctionterrainCheck that the images an environment names are registered environment or image assets.
import { checkEnvironmentAssets } from "@threenative/terrain/editor" - createEditorSelectionfunctionterrainGesture and transaction mechanics; the caller owns the controls, proxy and all rendering.
import { createEditorSelection } from "@threenative/terrain/editor" - createTweakBoxfunctionterrainA box of range bars and colour pickers over the running game, for tuning numbers by eye.
import { createTweakBox } from "@threenative/terrain/editor" - editorPlacementCenterfunctionterrainTransform the caller's measured geometry centre into the evaluated placement's world space.
import { editorPlacementCenter } from "@threenative/terrain/editor" - editorPointToClientfunctionterrainProject an injected world point to client pixels in the caller's viewport.
import { editorPointToClient } from "@threenative/terrain/editor" - editorSurfaceHeightfunctionterrainQuery the rendered heightfield, including its triangulation rather than an interpolated bake.
import { editorSurfaceHeight } from "@threenative/terrain/editor" - focusCamerafunctionterrainFrame a point, prop, landmark or region for the live viewport and projection.
import { focusCamera } from "@threenative/terrain/editor" - inspectImagefunctionterrainValidate a PNG, JPEG, WebP, Radiance HDR or OpenEXR container and read its pixel size.
import { inspectImage } from "@threenative/terrain/editor" - inspectSpatialfunctionterrainRead-only spatial inspection of one evaluated terrain revision.
import { inspectSpatial } from "@threenative/terrain/editor" - landformPosefunctionterrainRecipe footprints are heights over X/Z, never independently transformed solids.
import { landformPose } from "@threenative/terrain/editor" - mountTerrainEditorfunctionterrainMount recovered terrain controls around the project-owned ThreeNative view.
import { mountTerrainEditor } from "@threenative/terrain/editor" - pickEditorPlacementfunctionterrainA foreground terrain hit occludes placements; matching uses the evaluated world position.
import { pickEditorPlacement } from "@threenative/terrain/editor" - pickEditorSurfacefunctionterrainConvert viewport client coordinates once; the installed picker owns ray intersection.
import { pickEditorSurface } from "@threenative/terrain/editor" - probeTerrainfunctionterrainProbe the evaluated surface at one world point, separating bilinear from triangle values.
import { probeTerrain } from "@threenative/terrain/editor" - runCameraOperationfunctionterrainRun one create / get / list / update / delete / activate operation over saved cameras.
import { runCameraOperation } from "@threenative/terrain/editor" - runEnvironmentOperationfunctionterrainApply one get / patch / reset against the saved environment overrides; the caller commits it.
import { runEnvironmentOperation } from "@threenative/terrain/editor" - snifffunctionterrainThe kind and format a file's own bytes declare, whatever its name says.
import { sniff } from "@threenative/terrain/editor" - surfaceSpacefunctionterrainThe colour space an input's pixels are read in, from the channel its name ends with.
import { surfaceSpace } from "@threenative/terrain/editor" - TerrainEditorControllerclassterrainHTTP controller for the project-local terrain editor.
import { TerrainEditorController } from "@threenative/terrain/editor" - transformedLandformfunctionterrainConvert a terrain-editor gizmo pose into a heightfield landform footprint.
import { transformedLandform } from "@threenative/terrain/editor" - validateAssetfunctionterrainValidate one saved asset registration exactly as a document commit stores it.
import { validateAsset } from "@threenative/terrain/editor" - validateAssetsfunctionterrainValidate the whole asset list of an authoring document.
import { validateAssets } from "@threenative/terrain/editor" - validateCamerafunctionterrainNormalise and validate one saved camera, exactly as a document commit would store it.
import { validateCamera } from "@threenative/terrain/editor" - validateCamerasfunctionterrainValidate a document's saved camera list, keeping ids unique across it.
import { validateCameras } from "@threenative/terrain/editor" - validateEnvironmentfunctionterrainValidate a complete overrides object exactly as a document commit stores it.
import { validateEnvironment } from "@threenative/terrain/editor" - validateSpatialReferencefunctionterrainNormalise and validate one saved reference, exactly as a document commit would store it.
import { validateSpatialReference } from "@threenative/terrain/editor" - validateSurfacesfunctionterrainValidate surface mappings against the registered images they name.
import { validateSurfaces } from "@threenative/terrain/editor" - terrainEditorfunctionterrainMount the optional terrain document API on an existing loopback Vite server.
import { terrainEditor } from "@threenative/terrain/editor/server" - TerrainEditorDocumentclassterrainProject-local terrain document authority; no renderer or game dependency.
import { TerrainEditorDocument } from "@threenative/terrain/editor/server" - prepareWorldGLTFfunctionterrainPrepare the game's validated, frozen portable scene; the server cook owns GLB encoding.
import { prepareWorldGLTF } from "@threenative/terrain/export" - bakeKitfunctionterrainBake a copied kit, optionally using the caller's installed world cook.
import { bakeKit } from "@threenative/terrain/kit" - starterAssetsDirfunctionterrainResolve shared starter assets locally, or download the package's pinned archive on demand.
import { starterAssetsDir } from "@threenative/terrain/kit" - addStarterWorldfunctionterrainLoad caller-authored starter data with one scene lifetime; all appearance comes from spec.
import { addStarterWorld } from "@threenative/terrain/starter" - addStreamedGroundfunctionterrainPRD-790: the ground past the playable square, streamed around the player by TerrainTiles out to the collar's reach.
import { addStreamedGround } from "@threenative/terrain/starter" - authoredQuaternionfunctionterrainThe quaternion a placement's own scatter numbers describe: the normal tilt, then the yaw.
import { authoredQuaternion } from "@threenative/terrain/starter" - beginScenefunctionterrainStart a scene's view accounting: the player view it opens in, and nothing measured yet.
import { beginScene } from "@threenative/terrain/starter" - collarArithmeticHeightfunctionterrainThe collar triangle under (x, z) found by arithmetic alone, as the tile shader finds it: the ring from the ring spacing, the perimeter step from the face the point projects onto, and the triangle from the point's place in the quad.
import { collarArithmeticHeight } from "@threenative/terrain/starter" - collarDrawnHeightfunctionterrainThe collar's drawn height under (x, z); null where there is no collar.
import { collarDrawnHeight } from "@threenative/terrain/starter" - collarMorphfunctionterrainPRD-790 box 2: the streamed tiles' vertex shift.
import { collarMorph } from "@threenative/terrain/starter" - collarSeamGapfunctionterrainPRD-790: where streamed tiles meet the collar.
import { collarSeamGap } from "@threenative/terrain/starter" - createDiagnosticsStatefunctionterrainThe state one world's measurements are reported through, with its own name in it.
import { createDiagnosticsState } from "@threenative/terrain/starter" - createMeasurefunctionterrainThe per-world measurement: contacts, travel, edge overshoot, water and the frame facts a run reports.
import { createMeasure } from "@threenative/terrain/starter" - createMorphedHeightfunctionterrainThe height a tile vertex stands at once collarMorph moved it: the survey inside the band, the collar's arithmetic height at the drawn square's edge.
import { createMorphedHeight } from "@threenative/terrain/starter" - createPlayerRigfunctionterrainThe player: the capsule the solver moves, the mannequin that rides it, and the third-person camera that follows with the terrain as its walls.
import { createPlayerRig } from "@threenative/terrain/starter" - createRevealProbefunctionterrainWhat the loading reveal showed once the curtain lifts: drawn batches, pipelines and impostor readiness, measured against the reveal's own baseline.
import { createRevealProbe } from "@threenative/terrain/starter" - createSpawnGatefunctionterrainThe spawn gate: one deadline, one settlement, one failure report.
import { createSpawnGate } from "@threenative/terrain/starter" - editWorldPlacementsfunctionterrainApply deterministic startup edits to the decoded placement data before a world is loaded.
import { editWorldPlacements } from "@threenative/terrain/starter" - enterViewfunctionterrainThe camera cycle moved to another view: a keyed group for it, and a fresh measurement.
import { enterView } from "@threenative/terrain/starter" - invalidatePropShadowsfunctionterrainKeep WorldCells' changed caster bounds when forwarding to the existing shadow renderer.
import { invalidatePropShadows } from "@threenative/terrain/starter" - leaveScenefunctionterrainThe scene is gone: nothing is on screen, so no window can belong to a view.
import { leaveScene } from "@threenative/terrain/starter" - loadCanopyfunctionterrainThe canopy weight the ground shader reads, painted from the placements the bake drew.
import { loadCanopy } from "@threenative/terrain/starter" - loadPropPackagefunctionterrainThe baked prop package of one world, fetched as the bake wrote it.
import { loadPropPackage } from "@threenative/terrain/starter" - loadSkyfunctionterrainThe share of the sky each terrain vertex sees past the relief, as skyVisibility baked it.
import { loadSky } from "@threenative/terrain/starter" - observeFramefunctionterrainOne world frame was drawn: count it, and open a fresh GPU sample window if the view or the readiness changed.
import { observeFrame } from "@threenative/terrain/starter" - observeWindowfunctionterrainThe frame-budget window closed: latch it, and update the numbers the run reports.
import { observeWindow } from "@threenative/terrain/starter" - preparePosefunctionterrainThe pose a prop draws at, grounded on the game's own height field.
import { preparePose } from "@threenative/terrain/starter" - preparePropTransformfunctionterrainThe pose and the transform an editor edited, prepared together so one write reports both.
import { preparePropTransform } from "@threenative/terrain/starter" - PropCollidersclassterrainStream caller-specified fixed collision shapes around a moving follow object.
import { PropColliders } from "@threenative/terrain/starter" - propCountsfunctionterrainRecords per asset across the package's buckets: what the run report calls the scatter's counts.
import { propCounts } from "@threenative/terrain/starter" - propKeyfunctionterrainThe model a record draws: its asset, its variant, and the shape a non-uniform edit gave it.
import { propKey } from "@threenative/terrain/starter" - propRatiofunctionterrainThe shape propKey wrote, so the loader scales the model the record's one scale cannot carry.
import { propRatio } from "@threenative/terrain/starter" - publishfunctionterrainPublish the measurements and the scene's own facts into state, twice per second.
import { publish } from "@threenative/terrain/starter" - readPropTransformfunctionterrainThe transform an instance's current pose describes.
import { readPropTransform } from "@threenative/terrain/starter" - streamPropsfunctionterrainLoad the prop worlds, pose every record on the ground, and hand each bucket to WorldCells.
import { streamProps } from "@threenative/terrain/starter" - withAuthoredPosefunctionterrainA placement as a package record stores it: the authored pose becomes its transform, at one scale.
import { withAuthoredPose } from "@threenative/terrain/starter" - writePropTransformfunctionterrainWrites a prepared pose onto the instance, reporting the transform only when the pose changed.
import { writePropTransform } from "@threenative/terrain/starter" - toGeometryfunctionterrainConverts baked arrays to ordinary geometry using the consumer's installed Three.js.
import { toGeometry } from "@threenative/terrain/three" - atlasManifestfunctionassetsPack texture sources into deterministic atlas pages and answer each source's UV transform, so a build can stop giving every material a private texture.
import { atlasManifest } from "@threenative/assets" - audioPassfunctionassetsConditions a game's audio and proves the conditioning did not destroy it.
import { audioPass } from "@threenative/assets" - censusDocumentfunctionassetsCensus one glTF document, or a directory of them: the merge buckets a scene has now, and the buckets it would have once its atlasable textures shared pages.
import { censusDocument } from "@threenative/assets" - compileAssetsfunctionassetsCompiles a project's source assets into content-addressed runtime files and a manifest.
import { compileAssets } from "@threenative/assets" - cookTerrainWorldfunctionassetsBake evaluated terrain and static species into an instanced GLB and streaming world package.
import { cookTerrainWorld } from "@threenative/assets" - dedupeMaterialsfunctionassetsCollapse materials that became identical once their textures shared an atlas page, and count the buckets a merge would find — before and after — so the promise can be checked rather than made.
import { dedupeMaterials } from "@threenative/assets" - formatAudioSizesfunctionassetsFormats audio conditioning measurements for a build report.
import { formatAudioSizes } from "@threenative/assets" - formatHealthReportfunctionassetsFormats asset health findings and their summary for human-readable output.
import { formatHealthReport } from "@threenative/assets" - formatModelSizesfunctionassetsFormats model byte, geometry, and embedded-texture measurements for a build report.
import { formatModelSizes } from "@threenative/assets" - formatPassCostsfunctionassetsFormats per-pass wall-clock costs for a build report.
import { formatPassCosts } from "@threenative/assets" - formatTextureSizesfunctionassetsFormats standalone texture byte measurements for a build report.
import { formatTextureSizes } from "@threenative/assets" - lightmapPassfunctionassetsGenerates lightmap UVs and bakes a static GLB's lightmap atlas.
import { lightmapPass } from "@threenative/assets" - materialSignaturefunctionassetsCollapse materials that became identical once their textures shared an atlas page, and count the buckets a merge would find — before and after — so the promise can be checked rather than made.
import { materialSignature } from "@threenative/assets" - materialStateOffunctionassetsCensus one glTF document, or a directory of them: the merge buckets a scene has now, and the buckets it would have once its atlasable textures shared pages.
import { materialStateOf } from "@threenative/assets" - modelPassfunctionassetsOptimizes self-contained GLB models through the configured geometry and embedded-texture passes.
import { modelPass } from "@threenative/assets" - packAtlasfunctionassetsPack texture sources into deterministic atlas pages and answer each source's UV transform, so a build can stop giving every material a private texture.
import { packAtlas } from "@threenative/assets" - parseAudioConfigfunctionassetsValidates a game's declared assets.audio block, the one place its keys and ranges are checked.
import { parseAudioConfig } from "@threenative/assets" - parsePngfunctionassetsReads dimensions and alpha metadata from a PNG signature and IHDR header.
import { parsePng } from "@threenative/assets" - resolveBasisTranscoderfunctionassetsFinds Three.js's Basis Universal transcoder files for the runtime KTX2 loader.
import { resolveBasisTranscoder } from "@threenative/assets" - resolveSourceTexelfunctionassetsMove a mesh's UVs onto its atlas page, and decide from the geometry which meshes may not go.
import { resolveSourceTexel } from "@threenative/assets" - rewriteUvsfunctionassetsMove a mesh's UVs onto its atlas page, and decide from the geometry which meshes may not go.
import { rewriteUvs } from "@threenative/assets" - runHealthReportfunctionassetsMeasures compiled assets and grades them against declared project targets.
import { runHealthReport } from "@threenative/assets" - texturePassfunctionassetsEncodes standalone textures as mipmapped KTX2/Basis assets for GPU storage.
import { texturePass } from "@threenative/assets" - thinFoliageCardsfunctionassetsBuild a standalone card-thinned foliage mesh, preserving opaque parts and vertex attributes.
import { thinFoliageCards } from "@threenative/assets" - totalCensusfunctionassetsCensus one glTF document, or a directory of them: the merge buckets a scene has now, and the buckets it would have once its atlasable textures shared pages.
import { totalCensus } from "@threenative/assets" - uvsTilefunctionassetsMove a mesh's UVs onto its atlas page, and decide from the geometry which meshes may not go.
import { uvsTile } from "@threenative/assets" - watchAssetsfunctionassetsWatches an asset source directory and recompiles settled changes during development.
import { watchAssets } from "@threenative/assets" - withAtlasTexturesfunctionassetsCollapse materials that became identical once their textures shared an atlas page, and count the buckets a merge would find — before and after — so the promise can be checked rather than made.
import { withAtlasTextures } from "@threenative/assets" - wrapTilesfunctionassetsMove a mesh's UVs onto its atlas page, and decide from the geometry which meshes may not go.
import { wrapTiles } from "@threenative/assets" - createThreeGeometryfunctionraw-unrealConverts a decoded .uasset static mesh into a THREE.BufferGeometry, with one draw group per material section.
import { createThreeGeometry } from "@threenative/raw-unreal" - createThreeObjectfunctionraw-unrealConverts a decoded .uasset static mesh into a renderable THREE.Mesh with provenance in userData.unreal and material selection left to the game's materialFactory.
import { createThreeObject } from "@threenative/raw-unreal" - decompressBulkDatafunctionraw-unrealReads the FByteBulkData headers an editor package serializes into its export data, and resolves each payload — inline, at the end of the package, or in a sibling .ubulk/.uptnl file whose bytes the caller supplies — decompressing FArchive::SerializeCompressed blocks.
import { decompressBulkData } from "@threenative/raw-unreal" - decompressCompressedBufferfunctionraw-unrealParses one UE5 FCompressedBuffer and decompresses it block-by-block with the codecs the caller injected — uncompressed payloads are handled natively.
import { decompressCompressedBuffer } from "@threenative/raw-unreal" - findBulkDataHeadersfunctionraw-unrealReads the FByteBulkData headers an editor package serializes into its export data, and resolves each payload — inline, at the end of the package, or in a sibling .ubulk/.uptnl file whose bytes the caller supplies — decompressing FArchive::SerializeCompressed blocks.
import { findBulkDataHeaders } from "@threenative/raw-unreal" - findCompressedBufferOffsetsfunctionraw-unrealParses one UE5 FCompressedBuffer and decompresses it block-by-block with the codecs the caller injected — uncompressed payloads are handled natively.
import { findCompressedBufferOffsets } from "@threenative/raw-unreal" - findMeshDescriptionOffsetsfunctionraw-unrealParses a serialized FMeshDescription — element containers, allocation bit arrays, and attribute sets — into validated typed arrays, exactly consuming its byte range.
import { findMeshDescriptionOffsets } from "@threenative/raw-unreal" - findRawMeshBlobsfunctionraw-unrealParses one FRawMesh blob — the UE4.18-era source-model layout — validating that the fixed eighteen-array walk consumes the blob exactly and every count agrees with the wedge totals.
import { findRawMeshBlobs } from "@threenative/raw-unreal" - looksLikeMeshDescriptionfunctionraw-unrealParses a serialized FMeshDescription — element containers, allocation bit arrays, and attribute sets — into validated typed arrays, exactly consuming its byte range.
import { looksLikeMeshDescription } from "@threenative/raw-unreal" - looksLikeMeshDescriptionUe4functionraw-unrealParses the UE4.2x serialization of FMeshDescription — fixed-order element containers, and a triangle container that trails the attribute sets rather than sitting with its siblings.
import { looksLikeMeshDescriptionUe4 } from "@threenative/raw-unreal" - parseBulkDataHeaderfunctionraw-unrealReads the FByteBulkData headers an editor package serializes into its export data, and resolves each payload — inline, at the end of the package, or in a sibling .ubulk/.uptnl file whose bytes the caller supplies — decompressing FArchive::SerializeCompressed blocks.
import { parseBulkDataHeader } from "@threenative/raw-unreal" - parseCompressedBufferfunctionraw-unrealParses one UE5 FCompressedBuffer and decompresses it block-by-block with the codecs the caller injected — uncompressed payloads are handled natively.
import { parseCompressedBuffer } from "@threenative/raw-unreal" - parseMeshDescriptionfunctionraw-unrealParses a serialized FMeshDescription — element containers, allocation bit arrays, and attribute sets — into validated typed arrays, exactly consuming its byte range.
import { parseMeshDescription } from "@threenative/raw-unreal" - parseMeshDescriptionUe4functionraw-unrealParses the UE4.2x serialization of FMeshDescription — fixed-order element containers, and a triangle container that trails the attribute sets rather than sitting with its siblings.
import { parseMeshDescriptionUe4 } from "@threenative/raw-unreal" - parseRawMeshfunctionraw-unrealParses one FRawMesh blob — the UE4.18-era source-model layout — validating that the fixed eighteen-array walk consumes the blob exactly and every count agrees with the wedge totals.
import { parseRawMesh } from "@threenative/raw-unreal" - parseUAssetStaticMeshfunctionraw-unrealParses a raw Unreal editor .uasset static mesh into validated, plain typed arrays — UE5 FMeshDescription payloads (including the Oodle-compressed package-trailer form) and the UE4.18-era FRawMesh source-model layout, with no interchange conversion at any step.
import { parseUAssetStaticMesh } from "@threenative/raw-unreal" - readPackageLayoutfunctionraw-unrealWalks the whole FPackageFileSummary for the offsets bulk data is addressed against — TotalHeaderSize and BulkDataStartOffset — and returns undefined when the walk cannot be trusted.
import { readPackageLayout } from "@threenative/raw-unreal" - readPackageSummaryfunctionraw-unrealReads the fixed prefix of FPackageFileSummary — the legacy tag, engine versions, and the custom-version list — without walking the name map, export map, or dependency graph.
import { readPackageSummary } from "@threenative/raw-unreal" - resolveBulkDataPayloadfunctionraw-unrealReads the FByteBulkData headers an editor package serializes into its export data, and resolves each payload — inline, at the end of the package, or in a sibling .ubulk/.uptnl file whose bytes the caller supplies — decompressing FArchive::SerializeCompressed blocks.
import { resolveBulkDataPayload } from "@threenative/raw-unreal" - UAssetErrorclassraw-unrealThe error thrown for every malformed, truncated, or unsupported .uasset input, carrying a stable code and structured details instead of invented fallback geometry.
import { UAssetError } from "@threenative/raw-unreal" - UAssetLoaderclassraw-unrealLoads a raw Unreal .uasset static mesh as a three.js loader — load(url) for the browser, parse(data) for bytes you already hold — with parse and adapter options passed through.
import { UAssetLoader } from "@threenative/raw-unreal" - Area3DclassphysicsDetect overlaps without turning the body into a moving collider.
import { Area3D } from "@threenative/physics" - attachSnowPhysicsfunctionphysicsDrive a SnowField from real solved contacts.
import { attachSnowPhysics } from "@threenative/physics" - boxFootprintfunctionphysicsA rectangular contact: the face a box rests on, in the contact's own frame.
import { boxFootprint } from "@threenative/physics" - buildStaticCollidersfunctionphysicsBuild fixed trimesh bodies from the meshes a game authored in a scene root.
import { buildStaticColliders } from "@threenative/physics" - Buoyancy3DclassphysicsFloat a rigid body on a game-owned height source with fixed-step force ordering.
import { Buoyancy3D } from "@threenative/physics" - capsuleFootprintfunctionphysicsA stadium contact: a rectangle of half-length halfHeight and half-width radius, capped by two half-discs of radius.
import { capsuleFootprint } from "@threenative/physics" - CharacterBody3DclassphysicsMove a character body with collision-aware sliding.
import { CharacterBody3D } from "@threenative/physics" - CollisionShape3DclassphysicsGive a physics body a Three.js collision shape.
import { CollisionShape3D } from "@threenative/physics" - interactionGroupsfunctionphysicsEncode collision layers and masks for Rapier groups.
import { interactionGroups } from "@threenative/physics" - Joint3DclassphysicsConnect two physics bodies with a Godot-style joint.
import { Joint3D } from "@threenative/physics" - PhysicsDirectSpaceState3DclassphysicsQuery the physics world without creating a body.
import { PhysicsDirectSpaceState3D } from "@threenative/physics" - rapierfunctionphysicsInstall the Rapier physics plugin and simulation backend.
import { rapier } from "@threenative/physics" - RigidBody3DclassphysicsSimulate a dynamic or static rigid body.
import { RigidBody3D } from "@threenative/physics" - ScatterCollidersclassphysicsMake scattered props solid: fixed bodies for rocks and trunks near a followed point, streamed with it.
import { ScatterColliders } from "@threenative/physics" - softBodyCollisionfunctionphysicsFeed existing rigid-body boxes into SoftBody3D without inventing a second collider API.
import { softBodyCollision } from "@threenative/physics" - VehicleBody3DclassphysicsDrive a car on ray-cast suspension instead of faking speed and heading.
import { VehicleBody3D } from "@threenative/physics" - NavigationAgent3DclassphysicsMove an agent along a baked navmesh toward a target.
import { NavigationAgent3D } from "@threenative/physics/navigation" - NavigationObstacle3DclassphysicsAdd a non-moving crowd obstacle to a navmesh.
import { NavigationObstacle3D } from "@threenative/physics/navigation" - NavigationRegion3DclassphysicsBake walkable Three.js geometry into a navigation region.
import { NavigationRegion3D } from "@threenative/physics/navigation" - recastfunctionphysicsInstall navmesh pathfinding and crowd avoidance.
import { recast } from "@threenative/physics/navigation" - bakeCityfunctionprocedural-environmentBake an Apex City Kit module to one GLB: a road tile, a building, a street prop, a vehicle, a race kit piece, a block or lot, a sidewalk, transit, a public space, a utility or a decal.
import { bakeCity } from "@threenative/procedural-environment" - bakeRockfunctionprocedural-environmentBake a procedural rock (Outcrop) to GLBs, one per level of detail: a boulder, slab, spire, hoodoo, sea stack, mesa, arch, tileable cliff module or a mountain, weathered and coloured for its biome (moss in a forest, snow in the tundra, sand in the desert, algae below the tide line).
import { bakeRock } from "@threenative/procedural-environment" - bakeVegetationfunctionprocedural-environmentBake a procedural tree (Arbor) to GLBs, one per level of detail, ready for ctx.assets.model.
import { bakeVegetation } from "@threenative/procedural-environment" - environmentBiomesfunctionprocedural-environmentEvery biome: its id, name, the request words that mean it, the rock surface its rocks wear and the element ids that belong there.
import { environmentBiomes } from "@threenative/procedural-environment" - environmentElementsfunctionprocedural-environmentFind the nature elements to bake, by biome, kind or words: trees, ground cover, forest-floor debris and rock forms (boulders, cliffs, sea stacks, mesas, arches, mountains), each with the exact bake call.
import { environmentElements } from "@threenative/procedural-environment" - vegetationPresetsfunctionprocedural-environmentList every preset a bake can grow: id, name, latin name and kind.
import { vegetationPresets } from "@threenative/procedural-environment" - createStylizedAssetfunctionprocedural-environmentGenerate a Stylized Biome Kit or Dungeon piece or scene with its Three.js materials.
import { createStylizedAsset } from "@threenative/procedural-environment/stylized" - scatterfunctionprocedural-environmentMake instanced batches of a Stylized Biome Kit piece at explicit positions.
import { scatter } from "@threenative/procedural-environment/stylized" - skyfunctionprocedural-environmentBuild a gradient sky dome with the Stylized Biome Kit's WebGL shader.
import { sky } from "@threenative/procedural-environment/stylized" - stylizedAssetsfunctionprocedural-environmentList the Stylized Biome Kit pieces and scenes, including available variants.
import { stylizedAssets } from "@threenative/procedural-environment/stylized" - terrainfunctionprocedural-environmentBuild stylized heightfield geometry with a color callback and a second-color mask for path edges.
import { terrain } from "@threenative/procedural-environment/stylized" - createAnimalActorfunctionprocedural-animalsOwn one actor's pose/lifetime, accepting the completed physics state as its only root writer.
import { createAnimalActor } from "@threenative/procedural-animals" - createAnimalGeometryfunctionprocedural-animalsValidates all bytes before constructing geometry with the bake's skin and rig attributes.
import { createAnimalGeometry } from "@threenative/procedural-animals" - loadAnimalBakefunctionprocedural-animalsResolves and loads a prebuilt wolf through the game's ordinary asset resolver.
import { loadAnimalBake } from "@threenative/procedural-animals" - parseAnimalBakefunctionprocedural-animalsValidates a pinned wolf PANM bake before constructing any renderer resource.
import { parseAnimalBake } from "@threenative/procedural-animals" - animalBakePassfunctionprocedural-animalsValidate staged PANM sources inside the existing asset compiler; it owns the hashed manifest.
import { animalBakePass } from "@threenative/procedural-animals/build" - bakeWolffunctionprocedural-animalsBake the pinned wolf on the build machine, never on the portable runtime path.
import { bakeWolf } from "@threenative/procedural-animals/build" - bakeWolfToFilefunctionprocedural-animalsStage a validated source bake with a same-directory atomic rename, then use compileAssets.
import { bakeWolfToFile } from "@threenative/procedural-animals/build" - DebugOverlayfunctionuiShow framework diagnostics while developing a game.
import { DebugOverlay } from "@threenative/ui" - GameCanvasfunctionuiMount a ThreeNative game in a React canvas.
import { GameCanvas } from "@threenative/ui" - UiLayerfunctionuiRender a game's UI so the same source runs on web and on every native target.
import { UiLayer } from "@threenative/ui" - useGameStatefunctionuiRead the game's coalesced frame snapshot from React.
import { useGameState } from "@threenative/ui" - useUiIntentfunctionuiSend a player action from the UI back to the game.
import { useUiIntent } from "@threenative/ui" - useUiStatefunctionuiRead the game's published state from a UI that may be in another process.
import { useUiState } from "@threenative/ui" - useUiStateDuringStartupfunctionuiRead the game's published state while the loading cover is still up, for a UI that draws its own loading screen.
import { useUiStateDuringStartup } from "@threenative/ui" - createThreeGeometryfunctionueformatConverts one parsed Unreal mesh LOD into a THREE.BufferGeometry — coordinates, scale, winding, normals, tangents, UVs, vertex colours, morphs, skin weights, and material groups.
import { createThreeGeometry } from "@threenative/ueformat" - createThreeObjectfunctionueformatBuilds a renderable Three.js object — a Group for single-LOD models, a THREE.LOD for multi-LOD ones — from parsed .uemodel data, with collision geometry on userData.
import { createThreeObject } from "@threenative/ueformat" - parseUEModelfunctionueformatParses a UEFormat v10 .uemodel body — the interchange format CUE4Parse and FModel export from Unreal packages — into validated, plain mesh data without building any Three.js objects.
import { parseUEModel } from "@threenative/ueformat" - summarizeUEModelfunctionueformatSummarizes a parsed .uemodel — LOD, material, skeleton, collision, and unknown-attribute counts — without dumping vertex arrays, for logs, validation, and build reports.
import { summarizeUEModel } from "@threenative/ueformat" - UEFormatErrorclassueformatThe error thrown for every malformed, truncated, or unsupported .uemodel input, carrying a stable code and the byte offset where validation stopped.
import { UEFormatError } from "@threenative/ueformat" - UEFormatLoaderclassueformatLoads a .uemodel file as a Three.js loader — load(url) for the browser, parse(data) for bytes you already hold — with the parser and three-adapter options passed straight through.
import { UEFormatLoader } from "@threenative/ueformat" - assertAssetPathfunctionmetahumanKeeps a caller-supplied asset path inside the asset directory.
import { assertAssetPath } from "@threenative/metahuman" - loadMetaHumanfunctionmetahumanLoad a prepared MetaHuman head and drive its expression from the browser's WASM evaluator: declared faceboard controls in, joint deltas and morph weights out, applied to an ordinary Three.js object graph.
import { loadMetaHuman } from "@threenative/metahuman" - MetaHumanAssetErrorclassmetahumanThe rejection every check in this package raises, carrying a stable machine-readable code.
import { MetaHumanAssetError } from "@threenative/metahuman" - RigEvaluatorclassmetahumanOne MetaHuman head rig over the checksum-verified browser WASM build of the shared OpenRigLogic ABI: faceboard GUI controls in, joint deltas, blend shape weights and animated map weights out.
import { RigEvaluator } from "@threenative/metahuman" - validateMetaHumanAssetsfunctionmetahumanChecks one prepared specimen — bindings sidecar, DNA and GLB — against the rig it claims to drive, and returns the bindings only when every name, index, domain and hash holds up.
import { validateMetaHumanAssets } from "@threenative/metahuman" - bloomfunctionthreeGlow around bright pixels.
import { bloom } from "three/addons/tsl/display/BloomNode.js" - denoisefunctionthreeThreeNative equivalent for realism-effects denoise.
import { denoise } from "three/addons/tsl/display/DenoiseNode.js" - godraysfunctionthreeRaymarched shafts of light.
import { godrays } from "three/addons/tsl/display/GodraysNode.js" - aofunctionthreeGround-truth ambient occlusion.
import { ao } from "three/addons/tsl/display/GTAONode.js" - motionBlurfunctionthreeThreeNative equivalent for realism-effects motionBlur.
import { motionBlur } from "three/addons/tsl/display/MotionBlur.js" - recurrentDenoisefunctionthreeThreeNative equivalent for realism-effects recurrentDenoise.
import { recurrentDenoise } from "three/addons/tsl/display/RecurrentDenoiseNode.js" - sharpenfunctionthreeThreeNative equivalent for realism-effects sharpen.
import { sharpen } from "three/addons/tsl/display/SharpenNode.js" - ssaaPassfunctionthreeThreeNative equivalent for realism-effects ssaaPass.
import { ssaaPass } from "three/addons/tsl/display/SSAAPassNode.js" - ssgifunctionthreeThreeNative equivalent for realism-effects ssgi.
import { ssgi } from "three/addons/tsl/display/SSGINode.js" - ssrfunctionthreeThreeNative equivalent for realism-effects ssr.
import { ssr } from "three/addons/tsl/display/SSRNode.js" - temporalReprojectfunctionthreeThreeNative equivalent for realism-effects temporalReproject.
import { temporalReproject } from "three/addons/tsl/display/TemporalReprojectNode.js" - traafunctionthreeThreeNative equivalent for realism-effects traa.
import { traa } from "three/addons/tsl/display/TRAANode.js" - depthfunctionthreeThreeNative equivalent for realism-effects depth.
import { depth } from "three/tsl" - mrtfunctionthreeThreeNative equivalent for realism-effects mrt.
import { mrt } from "three/tsl" - normalViewfunctionthreeThreeNative equivalent for realism-effects normalView.
import { normalView } from "three/tsl" - velocityfunctionthreeThreeNative equivalent for realism-effects velocity.
import { velocity } from "three/tsl" - VelocityNodeclassthreeThreeNative equivalent for realism-effects VelocityNode.
import { VelocityNode } from "three/webgpu" - createStormAudiofunctiontemplate:rainThe storm's sound as generated source, mixed through the engine's own AudioBus: a rain hiss, a wind bed, and thunder queued strike by strike and delayed and filtered by how far away it was struck.
src/audio/storm.ts - createStormLightningfunctiontemplate:rainA branching lightning bolt as generated Rain source: makeBolt(end, random) walks a 30-segment channel down from the cloud deck with side branches, and one additive camera-facing ribbon draw (gaussian core inside a wide halo) shows it while the caller's flash envelope is above zero.
src/render/lightning.ts - createNoiseVolumefunctiontemplate:rainThe 64³ RGBA cloud noise volume as generated Rain source: { data: Uint8Array, texture: Data3DTexture }.
src/render/noise-volume.ts - createStormRainfunctiontemplate:rainCamera-anchored falling rain as generated Rain source: one instanced draw whose vertex stage hashes each drop from its index, wraps it in a 66 × 30 × 66 m cell that follows the camera in 12 m steps, and projects a quad stretched along its own fall — no particle simulation, no texture.
src/render/rain.ts - createWeatherWorldfunctiontemplate:rainThe raymarched coastal storm as generated source: one screen quad whose TSL shader draws the sky, the sea, the coast, the road, the forest and the lamps, and whose wet ground reflects them, written from the uniforms the game feeds it each frame.
src/render/world.ts - gradualBackgroundfunctiontemplate:starterThreeNative equivalent for realism-effects gradualBackground.
import { gradualBackground } from "@threenative/template/starter/src/render/effects/gradualBackground" - lensDistortionfunctiontemplate:starterThreeNative equivalent for realism-effects lensDistortion.
import { lensDistortion } from "@threenative/template/starter/src/render/effects/lensDistortion" - sparklefunctiontemplate:starterThreeNative equivalent for realism-effects sparkle.
import { sparkle } from "@threenative/template/starter/src/render/effects/sparkle"
Packages
A generated project installs a matching set for its template. Add others as your game needs them.
| Package | Provides | Used from |
|---|---|---|
create-threenative |
Project templates and setup | pnpm create threenative |
@threenative/core |
Scenes, game loop, input, loading, rendering helpers | Game code |
@threenative/physics |
Rapier bodies, triggers and character movement | The rapier() plugin |
@threenative/assets |
Asset conversion and compression | The build |
@threenative/ui |
React components and UI hooks | The UI entry |
@threenative/playtest |
Scripted input and gameplay checks | Tests against a running build |
@threenative/runtime-native |
Native host and packaging | Desktop and Android builds |
The scene context
A scene's enter(ctx) receives ICtx, which holds the scene's runtime tools. It can return a
per-frame function:
import { type ICtx, Scene, type SceneFrame } from "@threenative/core";
import { BoxGeometry, Mesh, MeshStandardMaterial } from "three";
export class Play extends Scene<GameState> {
override enter(ctx: ICtx<GameState>): SceneFrame<GameState> {
const box = ctx.add(new Mesh(new BoxGeometry(), new MeshStandardMaterial()));
return (frame, dt) => {
box.rotation.y += dt;
};
}
}| Fields | Use them to |
|---|---|
scene, camera, add |
Place Three.js objects and frame the view. add returns the object with its type. |
renderer, viewport |
Reach render controls and screen size. renderer.raw is the underlying renderer. |
input, pointer, raycast, raycastAll |
Read actions and pick objects. Use physics queries for collision shapes. |
assets, startup |
Load files and track startup. startup.hold() keeps the loading screen up. |
state |
Hold game values that a separate UI reads. |
after, every, tween |
Schedule work and animate values. |
afterPhysics, beforeRender |
Follow solved bodies and adjust visuals before drawing. |
entities, goto, random |
Register entities, switch scenes and make seeded random choices. |
Use the same seed for random to repeat choices in a playtest.
Reusable features
All of these export from @threenative/core.
| Job | Exports | Notes |
|---|---|---|
| Animated characters | AnimationPlayer, SkeletalMesh3D |
SkeletalMesh3D clones the skeleton, so each character poses on its own. |
| Many copies of one mesh | InstancedBatch |
add or place each copy, then build() the InstancedMesh. |
| Merged static geometry | mergeParts |
Keeps each part's colour. preserve keeps authored normals and UVs. |
| Dense static models | ClusteredMesh, ClusteredBatch |
Use cluster data from the asset build. The cut is taken for the render camera only: a mesh drawn through a second camera (a mirror, a portal) sets viewCull = false, and viewCullReport says what it did. |
| Distance detail | updateModelLods, baseGeometryOf |
Picks asset-built LODs. baseGeometryOf returns LOD0 for collision. |
| Visibility | alwaysRender, MatrixWorldPass |
alwaysRender keeps a small object drawn at range. |
| Camera-facing objects | Billboard3D |
Turns an object to face the camera when you call update(). |
| Camera shake | CameraShake |
update() returns an offset. Apply it after your camera rig. |
| Sky | Atmosphere, solarPosition |
The minimal template uses it on WebGPU only. |
| Sound | AudioBus |
Loads and plays sounds and manages volume. Unlocks on first input. |
| GPU ray queries | GPUSceneBVH |
Call rebuild() after the scene geometry changes. |
| Frame timing | FrameBudget, SpanRecorder |
GPU timings appear when the platform provides timestamps. |
Physics nodes (RigidBody3D, Area3D, CharacterBody3D, CollisionShape3D) export from
@threenative/physics. See Physics.
Search the engine before you write
An agent works from this repository's MCP servers, which are wired into every generated project's
.mcp.json. threenative-engine is the one that answers "does the engine already do this?".
| Tool | Takes | Answers |
|---|---|---|
engine_search_capabilities |
situation (required), scope ("request" or "mechanic", default "mechanic") |
Up to 15 deduplicated capabilities for a complete cross-system request, up to 5 for one mechanic |
engine_capability_detail |
symbol (required), importPath when two packages export that symbol |
One capability's import, signature, example, constraints and overrides |
Search the mechanically explicit request with scope: "request", then search each implied mechanic
with scope: "mechanic". A request that names a game or genre a starter kit covers (like mario) leads with a starterKits
entry and its npx create-threenative <dir> --template <name> command: scaffold it, then search the
mechanics it does not cover. Every result carries the
matchedSituation it matched and a score, so a weak match is visible rather than silent, and
engine_capability_detail is authoritative on platform support: it never states a limitation it does
not actually have.
A reply with verdict: "none" is an answer, not a failed search. Follow its guidance and write the
behavior in your own src/. Only results at or above the relevance floor of 0.27 are returned.
The server fails closed on the JSON-RPC layer, so a broken call is legible:
| Code | Meaning |
|---|---|
-32700 |
The line was not valid JSON |
-32601 |
Unknown method |
-32000 |
A tool rejected its arguments, with the message as written |
The blender server answers the same way, and never fails on a machine without Blender: blender_status
returns available: false with a cause (blender-missing, blender-too-old, blender-unreadable)
and an install command per platform. Every other blender tool returns one structured result with the
same guidance, so a missing Blender reads as a fixable instruction rather than a dead server.
The asset and sculpt servers are separate servers with their own tools and their own argument shapes. The recipes cover them: Finding assets and Sculpt from a reference.
Read an API in the source
Start at a package's src/index.ts and follow the export to its file. The doc comment above each
export lists its options, constraints and an example. Your editor's completion shows the APIs in the
version you installed.