Class: FarTerrain
Coarse terrain past the loaded chunks: a quadtree of stepped-column tiles
the server samples from its generator, finer near the viewer and on tall
relief, painted from the textures of the blocks each surface is made of
and lit and fogged as the chunks are, hidden wherever a chunk draws real
terrain, with a flat water plane at sea level. Tiles are meshed off the
main thread and dissolve in and out as the detail changes. The World
owns one, feeds it the server's descriptor from the INIT options, drives
update once a frame, hands it method replies and sends the requests it
queues.
Hierarchy
-
Group↳
FarTerrain
Constructors
constructor
• new FarTerrain(shared, options?): FarTerrain
Parameters
| Name | Type |
|---|---|
shared | FarTerrainSharedUniforms |
options | Partial<FarTerrainOptions> |
Returns
Overrides
Group.constructor
Properties
batch
• Readonly batch: FarBatch
Every tile's land and floating-land meshes, drawn as one.
descriptor
• descriptor: FarTerrainDescriptor = null
options
• options: FarTerrainOptions
stats
• stats: FarTerrainStats
Accessors
distance
• get distance(): number
The reach in blocks; 0 switches the layer off and frees its tiles.
Returns
number
• set distance(distance): void
Parameters
| Name | Type |
|---|---|
distance | number |
Returns
void
isActive
• get isActive(): boolean
Returns
boolean
reach
• get reach(): number
The far reach when the layer is drawing, else 0 (for the fog range).
Returns
number
Methods
clearTiles
▸ clearTiles(): void
Drop every tile and forget what was asked for.
Returns
void
configure
▸ configure(descriptor): void
The server's description of its far terrain, or null for none.
Parameters
| Name | Type |
|---|---|
descriptor | FarTerrainDescriptor |
Returns
void
dispose
▸ dispose(): void
Returns
void
Overrides
Group.dispose
drawsColumn
▸ drawsColumn(cx, cz): boolean
Whether the layer draws the whole of a chunk column, as it does over a column still on its way outside the guard radius. A chunk landing there replaces terrain already on screen, so a host can land it as itself rather than reveal it out of the fog, which would flash over that terrain.
Parameters
| Name | Type |
|---|---|
cx | number |
cz | number |
Returns
boolean
hidesChunk
▸ hidesChunk(cx, cz, isPending): boolean
Whether the world hides a loaded chunk this frame, asked once per chunk
ahead of update, which then holds exactly the chunks hidden here: a
chunk still owing meshes (isPending, asked only when it matters)
that landed where the layer draws its column hides until it has
meshed whole. Deciding both in one place is what keeps a column from
being drawn twice: a chunk shown the frame it landed, before the next
update held it, flashed through the stand-in, and one that finished
without a mesh landing (its grace out, a stranded job swept) drew over
the stand-in until the mask's next recheck.
Parameters
| Name | Type |
|---|---|
cx | number |
cz | number |
isPending | () => boolean |
Returns
boolean
isHeld
▸ isHeld(cx, cz): boolean
Whether a loaded chunk is still being held back for the far layer:
landed where the far layer draws and not every section meshed yet, as
of the last update.
Parameters
| Name | Type |
|---|---|
cx | number |
cz | number |
Returns
boolean
onMethodReply
▸ onMethodReply(name, payload): void
A method reply to hand over; ignored unless it is a far-terrain tile.
Parameters
| Name | Type |
|---|---|
name | string |
payload | unknown |
Returns
void
resetPeaks
▸ resetPeaks(): void
Reset the peak and the running mean so a measurement window starts clean.
Returns
void
setPalette
▸ setPalette(palette): void
Replaces the colour of every class (linear RGB, flattened) for a server whose descriptor names no materials; tiles built from here on use it. A source whose classes are discovered as tiles arrive (block ids, say) grows its palette before handing each tile in.
Parameters
| Name | Type |
|---|---|
palette | ArrayLike<number> |
Returns
void
takePackets
▸ takePackets(): MessageProtocol[]
Requests queued since the last call, for the world to send.
Returns
MessageProtocol[]
tileSlots
▸ tileSlots(): FarBatchSlot[]
The batch slots the resident tiles hold, land and floating land.
Returns
FarBatchSlot[]
update
▸ update(position, world): void
One frame: plan which tiles to draw, ask for the missing ones, ease the detail changes, drop what is no longer wanted, refresh the chunk-coverage mask when chunks changed, and hand new tiles to the mesher.
isChunkPending says whether a chunk column inside the render radius
still owes its terrain (not loaded, or loaded with its mesh still being
built at some level; a loaded, meshed chunk with nothing to draw is not
pending): the mask covers those within pendingGuardRadius of the
viewer, so a coarse tile never shows through the walls around it.
Further out, a drawn tile over such a column keeps drawing until the
chunk lands instead of opening a hole of sky. A chunk that has landed
there is held for exactly as long as the world hides it, which it
asks hidesChunk before this runs each frame.
Parameters
| Name | Type |
|---|---|
position | Vector3 |
world | Object |
world.chunkSize | number |
world.forEachMeshedChunk | (callback: (cx: number, cz: number) => void) => void |
world.isChunkPending | (cx: number, cz: number) => boolean |
world.loadedGeneration | number |
world.renderRadius | number |
Returns
void
warmLooks
▸ warmLooks(): Promise<void>
Read every face the descriptor's materials name now, a slice at a time,
for a load phase to await once the block textures are painted: each
atlas read waits on the GPU, a stall that belongs behind a loading
screen, not in the frame a player switches the layer on. Settles once
the materials are ready (a face that never becomes readable is greyed
after faceLookTimeoutMs), at once for a world without materials.
Returns
Promise<void>