What Vixen offers

Guide

• Move sets

  A movement vocabulary as a flat table, and picking from it with a scored query instead of a graph.

• Pose constraints

  Telling a pose where to be — four goal kinds, resolvable frames, proxy shapes, and one authored contact that fits any body.

• The variation harness

  Playing one interaction across a range of bodies, props and ground, measuring it five ways, and failing a build when it regresses.

• Getting content into a running game

  What a build has to know, what it ships, and the two shapes a shipped chunk comes in.

• Components

  The data an entity has, and what makes a type one.

• Entity queries

  Iterating the entities that have a given set of components.

• Booleans and handoff

  Non-destructive union, subtract and intersect whose operands stay editable — and what turns a block-out into an asset.

• The editing pipeline

  One path every edit in the editor takes, so undo, multi-object editing and mixed values are answered once rather than per panel.

• Element selection

  Vertex, edge and face modes over one mesh — what a click takes, what a loop walks, and what survives an edit.

• Face materials

  Per-face materials, UV projection, smoothing groups and the block-out checker the viewport draws by default.

• Foliage mode

  The mode that requires nothing — six tools, a palette, surface filters, and instance selection through the transform gizmo.

• Icons

  Declaring what a type looks like with SVG path data, and the parser that made the attribute buildable.

• The editor shell

  The window the editor is made of, and the command registry every part of it is a view over.

• Editable meshes in a scene

  How an entity comes to carry an editable mesh, how it is saved, and how an edit is undone.

• Editor modes

  What the viewport's input means right now, and how a mode claims keys that already mean something else.

• Building to a number

  The work plane you build in, typing an exact distance mid-drag, the tape measure, and the scale references.

• Scene menus

  A pie menu under the cursor and a list beside it, both filled by one registration and filtered by the active mode.

• The shape tool

  Making block-out geometry — live parameters, the cube grid, the poly shape, and duplicate, mirror and array.

• Snapping

  What a transform lands on, which part of it lands there, and why that is one service rather than one per tool.

• Sub-object picking

  Which face, edge or vertex of one mesh the pointer is on, and why that is a different question from which entity.

• Sculpt and paint mode

  The viewport mode the terrain tools live in — two categories sharing the digits, one drag as one undo entry, and the panel as settings objects rather than dialog code.

• Writing an editor plugin

  What a plugin can contribute to the editor, how it registers, and how everything it added is taken back out when it unloads.

• Block-out shapes

  Boxes, stairs, arches and the rest, generated from a handful of numbers that stay live afterwards.

• Booting an application

  The three calls behind VixenApp.Run, and the two seams that decide which platform and which device you get.

• Character movement

  Turning a player's intent into a character that walks, jumps, crouches and slides along walls.

• Editable meshes

  Faces over shared positions, an edge table that reports rather than refuses, and face groups.

• Growing a forest

  The offline ecology — seeds sown, aged, spread, shaded out and displaced — regenerated wholesale from four sliders and a stated seed.

• Foliage instances

  Trees and rocks stored in a cell grid, the six rules that refuse a placement, and the activation radius that decides which of them are worth a physics body.

• Grass

  A field scattered from a rule and never saved — the density curve, the hash both halves share, and the ring of buffers that makes it cost a fixed amount of memory.

• Mesh booleans

  Union, difference and intersection over solids, classified exactly so that coplanar faces do not open cracks.

• Mesh operations

  Extrude, inset, bevel, loop cut, bridge, weld, dissolve — the modelling verbs, as functions over a mesh.

• Mesh surfaces

  Where a face's texels come from and which normals it shades with — world-space projection and smoothing groups.

• Networked players

  Giving a connection a body, predicting its movement, and proving the two ends agree.

• Players and possession

  A controller that outlives the body it drives, and the one component that carries a player's intent.

• Splines

  A cubic Hermite curve with an arc-length table, the authored asset over it, and its two consumers — roads that deform a terrain and camera dollies that follow a track.

• Terrain brushes

  One brush — a shape, a falloff, a radius in metres and a spacing — answering one question for three different tools.

• The terrain heightfield

  One grid of 16-bit heights over an authored range, a stack of non-destructive edit layers, the paint channels and the hole mask.

• Painting a terrain

  The four paint tools, the layer weights that sum to one, the reusable ground a layer names, and the undo record that has to hold all of them.

• Sculpting a heightfield

  The seven sculpt kernels plus holes and paint, the stroke record that makes a drag undoable, and the ray that turns a pointer into a sample.

• Saving and restoring a world

  Writing every entity in a world to bytes, and making the world again from them.

• Admission, health and the control plane

  The door a ticketed player comes through, the two-second sample a fleet is watched by, and the one place a realm ever calls an orchestrator.

• Durable state and the ledger

  Accounts, characters and the append-only double-entry journal every movement of value is written to — and the fence that makes one writer one writer.

• Placing players

  The megaserver as a function — the hard filters, the score, the explanation, and the hysteresis that decides when a map grows a shard.

• Placing realms

  Starting, watching and stopping realm processes — and the backend that makes a fleet an ordinary unit test.

• Shards, keys and specs

  What a shard is, what makes two of them interchangeable, and the one string a realm process boots from.

• The cluster

  The four grains the orchestrator is made of, the lease that makes item duplication unrepresentable, and why the client cannot reach any of it.

• The service plane

  The gate — sign in, characters, the catalog check, and the one call that turns "I want to play" into an endpoint and a signed ticket.

• Transfer tickets

  A player's signed, expiring permission to be admitted to a shard — and why the client can only carry it.

• Transferring players

  The overlap — a second session opened while the player is still playing on the first, and the lease epoch that makes the switch atomic.

• Upgrading a fleet

  Whether a content update can be applied to a running world — proven by the build rather than asserted by a human — and the rolling upgrade for when it cannot.

• Writing a realm

  A dedicated server that is a shard — the one-line entry point, the four hooks it seals, and the map it opens.

• Drawing foliage

  Cells culled as objects, instances culled within them, LOD decided per instance, and one indirect command per level.

• Drawing grass

  Cells scattered as they come into range and blades culled every frame — the CPU reference of a compute pass, and the seam test that holds the two together.

• Impostors

  A tree photographed from a hemi-octahedral grid of directions once, offline, and drawn as two triangles for ever after.

• Culling and streaming instances

  Per-instance culling and LOD binning inside a batch, per-instance parameters beside the transforms, and a grid that keeps pages resident around whoever is moving.

• Turning on dynamic global illumination

  The four compositor nodes that make a frame's indirect light a file rather than a program.

• Meshes and materials, type by type

  Neither word names a type — each names a chain of them, one per stage, plus four subsystems that borrowed the same word.

• Drawing particles

  Dropping a .vxvfx onto an entity — the component, the importer that compiles the graph, the bridge that runs it, and the feature that draws it.

• Lighting a scene in lux and lumens

  Colour temperature, photometric units, an analytic daylight sky, and the one exposure that brings them back to a display.

• Making a room look different

  A box a level designer places to say how the frame looks inside it, how two of them resolve where they overlap, and the one thing a volume cannot do.

• The post-processing node kinds

  Every screen-space effect a compositor document can name, what each one reads, and the order they have to run in.

• Making everything cast a shadow

  The caster stage, the atlas a shading pass reads it from, and the two joins that make one mesh drawable by two shaders.

• Drawing a terrain

  A quadtree with a vertex morph, one instanced grid patch, no vertex buffer, and one draw call however many patches it takes.