qc_clientcore

Adventure guide as the tree view shows it (decision E-924), without the GUI: which advancements a player sees, how far they are with each, and where each stands, one tree per root

Turns a pose into bone rotations for skeleton models and into the first-person hand motion

What worn armour looks like (decision E-235): for each piece its layer boxes, the boxes of the reference model (the humanoid) it covers made slightly larger and cut to the layer's heights, and its extra parts, as attachments on the bones

Inventory icon of a block state: its boxes drawn from above at an angle (top, east and south faces), textured from the atlas and shaded like the world, so stairs, slabs and fences look different from their base block

Boats and their drivers as the client draws them in a frame (decision E-920): a boat where the mirror shows it (interpolated, bobbing while it floats) and its paddles rowing while its driver paddles (the boat's QcMsg::Rowing bit), and every other player who sits on a boat's driver seat drawn there facing the boat's way, their hands on the paddles in the same stroke

Client session's part of the health line (decision E-834)

What the dials of held items show (decision E-769), as pure functions of the session's state

Which entities a frame builds (decision E-862): only those whose box may show in the camera's view

What players and items look like when drawn: shared by the world (QcEntityFrameBuilder) and the character preview, so the preview shows exactly what other players see

View-frustum culling of axis-aligned boxes (chunk sections) against the clip planes of a view-projection matrix

How the buttons of a family are drawn in hints and named in help texts (decision E-612), as plain shapes and letters, no logos: a shape (a disc with a letter, the four PlayStation shapes, a shoulder or trigger tab, a stick, the d-pad cross with one arm lit, a diamond of four dots with one lit for the face buttons of a generic pad), its text and a colour role

Names of buttons, axes and types in the control interface and in settings ("south", "leftX", "playstation"); the lookups return nullopt for an unknown name

What the renderer learned about the GPU, for code that prepares textures in other threads (decision E-300): the largest texture edge

Draws item frames and paintings (decisions E-790, E-791): a frame as a thin board in its item's texture with the held item in front, turned by its rotation (a block item as a small cube, any other item flat); a painting as one picture tile per block (QcPaintingMotif::tileTexture) on a board whose back and edges show its back texture

Index buffers of section meshes: two bytes per index whenever every vertex can be addressed with 16 bits, otherwise four (QcPackedMesh writes them)

Heights of a liquid's surface at the four top corners of its cell (decision E-885), so the surface slopes towards where the liquid flows, as in the reference game: each corner averages the surfaces of the up to four cells sharing it, sources and full cells weighing ten times as much as lower flows, open cells (air, torches, plants, thin snow; QcBlockRenderTable::Entry:: liquidMayEnter) counting as height 0 and closed cells (solid blocks, other liquids) not at all; a corner next to a full cell (liquid on top of it) is full

Next mip level of the material atlases (decision E-908): every 2 x 2 block of texels into one

Paints the material maps of one texture from its colour picture (decision E-908)

Turns relative mouse motion (in points, y down) into view yaw and pitch

5 x 7 pixel font of the text on signs (decision E-766), drawn by the game itself like its textures: printable ASCII, the German umlauts and ß, a few accented letters, € and °; any other character shows as '?'

Poses of the character preview: the animations to check a look with (standing with the idle sway, walking on the spot, mining) and the head following the mouse pointer

A procedural texture definition (content/*/textures/*.json or a texture pack's spec) turned into a picture: the fields are read into a QcTextureSpec and painted at 16 x 16; larger resolutions are enlarged with the pattern's detail (QcTextureDetail, decision E-299)

Camera-relative rendering (decision E-883)

How the enchanting screen writes an offer's clue (decision E-884): every letter is either readable or hidden behind a rune (QcRuneGlyphs), and the bookshelves around the table decide how many are readable: floor(letters x shelves / 15), all of them at 15

Pure parts of the sun shadows (decision E-903): which light casts them, how far each cascade reaches, the light's axes and a box per cascade whose texels stay on a fixed grid of the world (texel snapping), so shadow edges do not crawl while the camera moves

Sky as a function of the world time and the weather

How a creature that swims in pulses (the squid, QcMobDefinition::pulse, decision E-974) holds its body in one frame: tilted by the pitch the server sends (QcCreature::tilt) about the middle of its height, its tentacles (QcMobPart::tentacle) open as it slows below the speed of a push and pulled in right after one

Renders a procedural texture above 16 x 16 (decision E-299): the pattern's 16 x 16 picture is enlarged in steps of two with an edge-aware pixel-art filter (Scale2x on similar colours, so diagonals and round shapes get finer steps instead of blurring), then gains detail that only the higher resolution can show: a fine grain on the surface and a bevel along strong edges (lit at the top and left, shaded at the bottom and right, also towards transparent pixels). The outlines of the enlarged picture follow its coverage alone, so the pixel variation of a thin shape cannot notch or pinch it; tools and weapons take the outline of strokes between the pixels instead (QcTextureOutline, decision E-1000)

Smooth outline of an enlarged cut-out shape (decision E-1000)

Reads a texture pack folder (decision E-297) and checks everything in it at the system boundary (decision E-298): the manifest, file names (only textures/<namespace>/<name>.png|json, no links, no hidden files, so nothing outside the folder is read), the number and size of files, PNG signature, size and resolution, damaged images and a budget for decoded image memory

Where each texture of the atlas comes from (decision E-297): the active packs in priority order, then the content's own definition (the base 16 x 16 textures and those of mods)

A tidy layout of a tree read from left to right (decision E-924; the advancement tree): a node's column is its depth, children follow their parent in one column further right in the order of their indices, and every parent stands halfway between its first and its last child

Size of the HUD and the screens (decisions E-725, E-875): the player's choice (a step from 75 % to 200 %) times the window's factor, which grows the UI with large windows, and how far that may go in a window before the UI would no longer fit

Look of the water in the realistic mode (decision E-906): what does not need the GPU

An advancement in the tree: where it stands and how far the player is with it

Levels (0..1) of the four ambience loops, chosen from the surroundings with simple rules: wind under the open sky (stronger up high), a cave rumble under a thick rock ceiling, water when water blocks are near, rain while it rains where the listener is (muffled under a roof, faint in a cave)

Time of the animated block textures in game ticks (decision E-878), advanced every frame by the frame's seconds at the server's speed (QcMsg::WorldTime::speed): smooth between ticks, faster in a /tick sprint, and standing while the server stands (pause menu, an empty server, /tick freeze; speed 0)

Rotation of a bone around its pivot in degrees

One image of a macOS .iconset

Software mixer: plays sample buffers as voices with their own gain, stereo position and speed, grouped into buses with a volume each, under a master volume and a mute switch

One playing sound

One cell of a block that fills several (a bed's foot and head, decision E-885): its state's entry, drawn offset cells away from the first part

What changed since the last takeChanges(): new snapshots of sections whose levels differ, and the sections whose meshes read a changed cell (also neighbours of changed border cells)

Blocks of the loaded chunks as the client shows them (decision E-853): what the server's world messages say and, on top, the local player's predicted block changes

Whether the session shows the blocks of the local player's breaks and placements before the server confirms them, and the numbers of the predicted actions (decision E-853)

A pair of crossed planes (plants, saplings) spanning a box of the cell

Rectangle on a cell side in the two coordinates that span it (see QcBlockRenderTable::axes): a0..a1 along the first axis, b0..b1 along the second

How a paddle lies in its oarlock, in degrees: sweep turns its outer end towards the stern (negative towards the bow), lift tilts its outer end down towards the water

Where a driver sits as drawn this frame: the boat, the feet on its seat (bobbing with it), the boat's yaw and the paddles' stroke

Legs of a creature built from static boxes (decision E-888), found in its parts, so every walking creature of the content and of mods swings its legs without naming them: a leg stands on the lowest level of the model and is at least 1.5 times as tall as it is wide and deep; a model needs at least two

Legs of the box models drawn, found once per model instead of every frame

Smoke rising from the lit campfires near the player (decision E-772): a list of the campfires (blocks whose campfire cooks) within radius blocks, found again every rescanTicks by looking only into the chunk sections whose palette holds such a block, and a few puffs per campfire that rise, drift and shrink in a loop

Swing of a cape (decision E-240): a damped spring per axis pulls the cape towards an angle that follows from the movement: lifted backwards by walking and more by sprinting, upwards when falling, pressed to the back when rising or sneaking, held off the swinging legs when walking backwards, swaying gently when standing

A look saved under a name: a built-in preset or one the player saved

What the server sends about the loaded chunks besides their blocks: the labels floating in them (decision E-222), the creature kinds spinning in their monster spawners (decision E-520) and the items lying on their campfires (decision E-772)

Triangle mesh of one chunk section

Client's side of the admin channel (decision E-848), part of QcClientSession: what an operator asks the server for and what came back, for the "Manage server" screen (stage 77.2) and the control interface

Local player's progress in the adventure guide as the server told it (decision E-923, QcMsg::AdvancementProgress); the definitions come with the content (QcContentRegistry::advancements)

A screen the server opened at a block for the local player (the anvil, the enchanting table): whether it is open, where, and the way out to the server

Client's subscription to the server's debug data (QcMsg::DebugSubscribe, decision E-225) and what arrived of it

Client mirror of the entities the server reports, with their animation timers and the ones that play their death animation

Local player's game mode as the server reported it (decision E-282), with the world's adventure allow-lists in adventure mode (decision E-735), and what the client does with it: the wish to fly that goes with every input (decision E-284), the pace of instant breaking in creative mode, and the requests for catalogue items (E-283) and picked blocks (E-285)

Drawing a launcher on the client (a bow, decision E-425): the use button held with a launcher in the hand draws it, its release shoots

What the client proves itself with

Maps the server sent (decision E-802), part of the world mirror: per map id its picture (QcMapData), the markers of its last update and a revision that grows with every update, so a drawn image of the map can tell it is out of date

Minecart the local player rides (decision E-382)

Editor of a sign the server opened for the local player (decision E-766): the sign's position and lines (QcMsg::OpenSignEditor), and the lines the player writes (QcMsg::EditSign)

Stonecutter screen the server opened for the local player (decision E-785): its input slot and the stonecutting recipe chosen for it (decision E-784) as the server last sent them, and the choices the player makes

What the server last told the player about themselves (QcClientSession::vitals): health and whether they burn or are dead, food, experience (decision E-398) and air under water (decision E-955)

Client-side mirror of the chunks the server sent

A control request that completes on a later tick

Turns the player's view like a player moving the mouse

Control commands by name, each served by one of the command groups

Control commands about entities: listing them, attacking or using an item on a creature, collecting dropped items, and riding minecarts

Machine-readable control of a client session: newline-delimited JSON requests in, one JSON response line per request out

Control commands on machine and chest screens: opening, filling, emptying, closing and their state

JSON views of the session state that control responses report

Control commands for trading with villagers (decision E-414): opening a villager's screen, listing its offers, trading and closing

One end of a debug line: position in the world and colour (RGBA bytes)

What the debug display shows (decision E-225): its level, switched by the debug key, and the visualisations, each switched on its own in the debug options (like Factorio's F4)

Entities of the mirror by kind

Block under the crosshair

Debug display's text (decision E-225), translated: one line for the compact level, the general column (position, light, target, entities, chunks, memory, server) and the time column (client frame and server tick phases, mean and maximum, aligned for a fixed-width font) for the full level

Time of day the clock shows as hours and minutes, sunrise at 6:00

Lists of precipitation drops handed to the view in turn (decision E-397): the view keeps the latest, the renderer the one it last copied, so a third is always free to be filled again and a frame allocates nothing once the lists have grown

A cube of an effect cloud as the entity frame draws it at a moment (campfire smoke, ink clouds; decision E-975): its centre and its edge length

Floating book: the middle of its spine, the direction it faces (radians about +y, 0 facing +z) and how far it is open (0 closed, 1 wide open)

A table and the bookshelves that count for it

Light of an entity: sky light (scaled by daylight in the shader) and block light, both 0..1

An extra textured box worn on a bone of a skeleton model, in model space like the bone's own boxes: it turns with the bone and takes the figure's light and hurt tint

A sprite with thickness: size metres across, in the local space of a flat sprite (x across and centred, y up from 0 to size), one texel thick along z and centred on z = 0

Draws held items, in the first-person fist and in a figure's fist

What a dropped item looks like this frame: alpha interpolates between the last two ticks, seconds is the client clock driving the animation, light the light at the item

Where an item lies flat on a block (on a campfire, decision E-772): the middle of its underside, turned by yaw degrees, in light

How a creature of static boxes looks this frame (decision E-480): sitting (each part moves by its QcMobPart::sitOffset) and the colours its tinted parts take (the collar: QcTint::Collar)

Rotation around the Y axis by a yaw in degrees: the model faces -Z; yaw 90 faces +X

Vertex of creature, player, item and hand meshes: like QcBlockVertex plus a tint colour that the texture is multiplied with (outfit colours, the red flash of a hit)

What a puff looks like at a moment (lookAt())

Camera's height above the player's feet: it drops to QcPhysics::sneakEyeHeight while the player crouches and rises back when he stands up, at a steady speed over transitionSeconds, like the role model (decision E-961)

Two presses of the jump key in quick succession toggle flying in creative mode (decision E-284)

How the player moves this frame

Pictures of the maps in item frames (decision E-809), one texture for all of them: a grid of columns x columns tiles of QcMapData::size pixels, one per map id drawn this frame, so every framed map is drawn with the same texture and a wall of them costs one draw call

Player settings of the graphical game, stored as an INI file in the data directory

A gamepad steering the player (decision E-541): the left stick walks with stepless speed, the right stick looks, the triggers mine (right, also attacks) and use (left), the shoulders step through the hotbar, the stick clicks sprint (left) and toggle sneaking (right; held while flying, where it descends), south jumps and a double tap of it toggles creative flight

Default bindings (Auftrag point 40, decisions E-541 and E-580, after the console layout of the model): south jumps (double tap: creative flight), the left stick click sprints, the right stick click sneaks, the shoulders step through the hotbar; start pauses, north opens the inventory, east drops, west picks the block in view; the d-pad holds the radial menu (left), switches the camera (up), opens the chat (down) and the handbook (right); back holds the player list

Forward (positive) and strafe right (positive) from the shaped left stick (y positive down)

How one pad steers the player (decisions E-541, E-610, E-611): dead zones, outer zone and response curve of sticks and triggers (QcGamepadResponse), the turning speed of the right stick at full deflection, whether pushing it up looks down, how far a trigger is pulled before it acts, whether the pad vibrates and the buttons of the actions

Gamepad part of the settings (decisions E-541, E-610, E-611): the profile all pads use (standard, stored as gamepad/<key> as before), the pad models with a profile of their own (by SDL's GUID, stored as gamepadControllers/<n>/<key>, at most maxControllers) and whether the hotbar shows only the slot in the hand (radialOnly, decision E-614)

Gamepads the client sees, behind one interface (decision E-540): the SDL3 backend of the game (QcSdlGamepadSource in src/app/input, polled on a Qt timer) and the virtual pads of tests and the control interface (QcVirtualGamepadSource) look the same to the input mapping

What the local player's hand does: the block and the entity under the crosshair, mining the targeted block (survival progress and hit sounds, instant breaking in creative mode), using the held item on a block, an entity or itself, drawing and releasing a launcher (QcClientLauncher) and attacking

Turn of arm and item about the shoulder in degrees, in the camera's frame: pitch positive lifts the arm (its forward end up), negative strikes down; yaw positive turns it inwards towards the crosshair; roll positive turns it in the picture's plane, counter-clockwise as seen, so the head of a tool held in the lower right corner comes down and to the left, towards the lower middle of the screen

Progress of the own player's hand animations in one frame (QcClientSession::handTimers): switching the held item, landing and using; 0..1 while running, negative otherwise. aim is how far the hand has come to a drawn launcher (decision E-984)

How far the view tips: pitch up and roll clockwise (the head leaning to the right), in degrees

One puff of a cloud

Texts the UI shows for keys and actions, in the UI language

Picks the world labels to draw (decision E-222): those within reach of the camera (titles from further away), in front of it and not hidden behind an opaque full block, at most maxShown of the nearest

Sky and block light of the cells around one position, for the debug display (decision E-225): sky light shines with 15 into every cell above the highest cell of its column that stops light coming straight down (QcLightPassage) and spreads like block light, by the same rules as the mesher's light

What take() hands out

Sounds of the local player's own movement, made on the client without a server round trip: steps on the block underfoot, jumps, landings, swimming strokes and splashes into water

Surface of one procedural texture for its material maps (decision E-908), before it is painted per texel by QcMaterialSynthesizer

Colours of the definition that tell an inclusion (the ore) from its ground (the stone)

Immutable snapshot of everything needed to mesh one section: the chunk and its eight neighbours (for faces and ambient occlusion across chunk borders)

Blocks of the 3 x 3 chunks around a section as the chunk mesher reads them (QcMeshInput), by chunk-local coordinates

Keeps section meshes in sync with the client world

When the mouse is captured for looking around, as a small state machine without a window: the game asks it after every change of the screens and before acting on a mouse button

A light that moves with what carries it (decision E-902): a torch in a hand, a glowing item on the ground, a firefly

One note of a piece

Joins a network game (decisions E-251, E-252, E-872): connects over TLS to the address, checks the server's certificate against the pin in the known servers (pins it at the first connection), logs in with the credentials and hands over the session once the server welcomed the player

Lists of a section mesh (QcChunkMesh) packed for the GPU into one vertex and one index range (decision E-813), which the GPU mesh store places in a page shared with other sections (decision E-820)

Hotbar's radial menu with the mouse (decision E-614): while its key is held the mouse does not turn the view but moves a pointer from the centre, and the direction of the pointer picks the slot like the pad's right stick (QcHotbarRadial)

A voice that follows its source

Rain and snow around the camera (decision E-395): up to a budget of particles in a box around the eye, falling, each only where the sky is open above it

Prediction of the local player: the movement intent, the inputs the server has not acknowledged yet, the predicted motion one tick ago and now, and the reconciliation with the authoritative state (corrections, decision E-257)

View of the character preview: the figure stands at the origin and turns on the spot (dragging turns it), the camera looks at it from +Z along -Z and zooms from the whole body to the head

Frame pacing of the character preview: it draws only while it is visible and at most at its frame rate, so an open screen with a preview adds a small, bounded load and a hidden one none

What the preview shows of the player

Shading, sky light and block light given to all four vertices of a quad

Reports an action the game mode refused (adventure mode, decision E-735) at most once in reportTicks ticks, so that a held button does not flood the HUD with notices

Material maps of the realistic mode (decision E-908): relief from the normal maps, smoothness, metal and reflectance for the sun's highlight and the sky's reflection, light of its own (maps); with lightHighlights the moving lights also make highlights

Water of the realistic mode (decision E-906): wave octaves of the surface's normals, how far the refraction bends the picture behind it (0: straight through), the steps of the screen-space reflections (0: sky and sun only) and the strength of the caustics on the ground under shallow water (0: none)

One character of a clue as the screen draws it: a rune (its index), or the readable character (rune -1)

Picks the screen a scripted run opens its window on (–screen / QTCRAFT_SCREEN) and places the window fully inside it

A world label as drawn this frame: where on screen (pixels from the top left), how large and how opaque

What the client knows of the server's debug data (QcMsg::ServerDebug, decision E-225): the latest message and the durations of the latest ticks for the tick graph, each tick once (a message reports the ticks up to its own; those the graph already has are skipped)

The connection (after the messages sent before)

Forget the largest correction so far (QcPrediction::resetCorrections)

Player's wish to fly (QcClientGameMode::setFlightWanted)

Sends Hello and starts ticking (TickMode::Timer) or waits for tick() (TickMode::Manual)

What the session's tick core (QcSessionCore) tells the session, in one ordered stream (decision E-560): the server's messages as they arrived and, between them, the predicted ticks and the reconciliations of the local player

Prediction as the core holds it now, and how far the core is with the session's commands

Server's state of the player was applied to the prediction

Session's side of its tick core (decision E-560): owns the core and, when it ticks on a thread of its own, that thread

One cascade of the shadow map: a square box in the light's space around a sphere near the camera

Light that casts the shadows of a frame (decision E-903): the sun by day, the moon (weaker) by night, faded out near the horizon and under clouds so that the switch between them is never seen

Front of a sign's board: the middle of the text, the direction to the right of a reader, and the direction the front faces (up is +y)

Recent server snapshots of one entity's motion, by server time (decision E-271), and its pose at any moment between them: interpolated between the two around it, extrapolated along the last movement for at most extrapolationMs past the newest one, then held

Chooses the moment of server time at which the client shows other players and creatures (decision E-271)

A sound the client should play now: from a server SoundEvent or made by the client itself (the player's steps, jumps, mining strikes)

Where the listener's ears are and which way they look

A positional sound as the engine places it: where it sounds, how loud at the source (the definition's volume times the cue's) and how far it carries (the definition's range, longer for cues louder than 1, as the server sends them)

Whether the player sprints, from the keys, as in the model (decision E-280): a press of the sprint key while moving forward, or a double tap of the forward key, starts a sprint, which then lasts while the forward key stays held, also after the sprint key is released

A corner of the solid form: point in the local space of a sprite one unit across (x across and centred, y up from 0 to 1, z through it and centred on 0), texture in the unit square of the picture (x from the left, y from the top)

One side of an extruded sprite, a texel long: the opaque texel and the way its side faces

Statistics log (decision E-225): every interval one line "STATS {json}" in the log (category qtcraft.stats), with the debug data as QcDebugJson writes it, so scripts and agents read the same numbers as the debug display

One thread: from the middle of the parent's body to the middle of the child's, with the texture

All content textures in one image with its mip levels (decision E-300)

Limits and settings for building a QcTextureAtlas

A loaded texture pack (decision E-297): its manifest and the textures it brings, keyed by the content's texture name ("qtcraft:stone")

A stack as loaded, and the ids that could not be loaded

A checked PNG texture: the first frame at the pack's resolution and how many frames the file had, the frames after the first at the same size (a vertical strip animates, decision E-878)

Manifest texturepack.json of a texture pack (decision E-297): what the settings show and the resolution every image of the pack must have

One problem found while loading a texture pack: the file it concerns (relative to the pack, "" for the pack itself) and a message

Data description of a procedurally generated block/item texture

What one run() is asked to do

Generates deterministic pixel-art textures from a QcTextureSpec

Punctuality of the client session's ticks (decision E-560): how late each tick ran against its due time on the 50 ms grid, and how many due ticks never ran

Places of a tree and its size

Text and background roles of controlPalette() that controls draw together

Gamepads fed from outside (decision E-540): unit tests and the control interface (gamepadConnect, gamepadSet, ...) connect pads and set their buttons and axes; the input mapping cannot tell them from real ones

What one frame's water is drawn with

World as the server sends it (part of QcClientSession, decision E-717): the content, the blocks of the loaded chunks with the local player's predicted changes on top (QcBlockMirror, decision E-853; QcClientWorld, there from the content on), what the chunks carry besides their blocks (QcChunkExtras), the world time and the weather