| AbyssComponentAttribute | Class: Marks a plain-data struct as a component the engine should be able to describe. |
| AbyssListAttribute | Class: Marks a plain-data struct as the item of a list component: an entity carrying it holds a list of them, as many as it needs, which grows and shrinks. |
| AbyssPackageAttribute | Class: Says an assembly is a package's, and what registers it: what the engine's source generator writes into a package's code, beside its AbyssPackage, and reads off each package a game references, to call every package's registration from the game's own. |
| AbyssPluginAttribute | Class: A plugin an assembly names as its game's; see AbyssPluginAttribute<T>. |
| AbyssPluginAttribute<T> | Class: Names a plugin the game plays with, as abyss_ffi::plugin! names a Rust one. |
| AbyssSystemAttribute | Class: Marks a static method as a system, so its access can be derived from its signature instead of declared a second time by hand. |
| ActionName | Record struct: An input action as code names it: Actions.Player.Jump, which the build writes from settings/input.json; its path, "Player/Jump" or "Jump" where one map alone has an action so called; or the InputAction itself. |
| ActionState | Enum: How an action — a clip played from code — is getting on, or how it ended. |
| ActionType | Enum: What an input action's value is. |
| AddOn | Record: A pack that does not ship with its game — an Addressables group built as an add-on, or one language's strings of the string tables in such a group — as the game's build lists it: its file, the length and SHA-256 a file downloaded or given is checked against before it is attached, and what it holds. |
| AddOnDownload | Class: A download of an add-on from the game's content address into the player's folder (PackAccess.Download): how far it has got, read each frame, and awaited, which ends once it is attached, has failed or was cancelled. |
| AddOnDownloadState | Enum: What a download of an add-on is doing. |
| AddOnList | Class: The add-ons a game's build made: catalog.json, or catalog_1.23.1.json, in the folder the build writes them into, uploaded with them, and the same list in the game's main pack, which a game reads as it starts. |
| AddOnSettings | Class: Where a game downloads its add-ons from: settings/addons.json, which Project Settings' Add-ons page lays out — the content address, and whether the game reads the list there as it starts. |
| AddableComponent | Record struct: A component that could be added to an entity, as the Add Component list shows it. |
| AddedInEditor<T> | Delegate: Fills a T the editor has just put on entity, from what the entity is: a collider made the size of the sprite it is put on. |
| AddressableSettings | Class: A game's groups of addressable assets, each built into a pack of its own: settings/addressables.json. |
| Affine | Record struct: Where something is in the world, as Bevy's GlobalTransform holds it: three axes, scaled and turned as it is, and where its origin is. |
| AlphaKind | Enum: Which of Bevy's transparency rules a surface is drawn under. |
| AmbientLighting | Record struct: The light a camera sees everything by, from no way in particular: what keeps a shadow from being black. |
| AnimationAction | Record struct: A clip played from code on an animator, as World.Play gives it: what World.StateOf says how it is getting on by, and GameCode.Ended waits for the end of. |
| AnimationClipDocument | Class: What a clip file says, to read and change; see AnimationClipFiles. |
| AnimationClipFiles | Class: A clip as a file of its own: an .anim in a game's assets, which holds one clip — a sprite's frames, and the events, curves and sync markers a model's clip has. |
| AnimationEventAttribute | Class: Marks a plain-data struct as an event a clip can fire: placed on a clip's timeline in its model's inspector, its fields filled in there, and read by a game's systems as the clip passes it. |
| AnimationEventType | Record: An animation event's struct, described for an editor to place and fill in. |
| AnimatorState | Record: What an animator plays: each clip, the one last played first. |
| Archetype | Record struct: A registered set of component types that entities can be created with, given, or stripped of. |
| ArgumentKind | Enum: What kind of value a string's argument holds, which says how it is written. |
| AssetAccess | Struct: What a running system can do with the world's assets: load, make, copy, change and let go of them. |
| AssetAddress | Class: What an addressable file is loaded by: its address, which a game names it by wherever the file is, and the labels it is found by among others. |
| AssetCatalog | Class: What a pack says of the assets it holds beside their bytes: each one's path and identity, and the address and labels of each addressable one. |
| AssetDatabase | Class: What every file under the asset root is called, and what it is. |
| AssetGuid | Struct: A file's identity, which outlives where the file happens to sit. |
| AssetKey | Class: An addressable asset as the build names it in a game's code — Addresses.Scenes.Moons — its address and its identity: of one kind of asset each, so a clip given where a prefab goes is a build error, and a key whose asset went is one where it is used. |
| AssetRef<T> | Struct: A reference to a data asset of T, by its identity: a slot in the Inspector that takes only those, read with World.Data. |
| AssetSetup | Record: Where a world's assets are read from. |
| AssetState | Enum: How far along an asset's load is. |
| Assets | Class: Values shared by every kind of asset id. |
| AudioAddress | Class: A sound's key, which AssetAccess.LoadAudioClip takes. |
| AudioBus | Record: One bus of a game's mix, as settings/audio.json holds it. |
| AudioClipId | Record struct: The id of a sound clip the engine loaded. |
| AudioCodec | Enum: What a clip's file is encoded as, as the inspector names it. |
| AudioCompression | Enum: How a sound clip is encoded as it is imported: what its import settings call its Compression Format. |
| AudioEncoding | Record struct: How a sound clip is encoded as the editor imports it: its Compression Format, Vorbis's Quality, a lower Sample Rate and Force To Mono. |
| AudioImport | Record: How a sound clip is kept, as its import settings say: what its inspector's settings set, and what the editor tells the world it plays a project in, and the pack it is built into. |
| AudioImporter | Class: The engine's importer of sound clips: a clip's file read whole, mixed to mono and its sample rate lowered if asked, and written again as Ogg Vorbis, IMA ADPCM or 16-bit PCM; see abyss_core::audio::import. |
| AudioLoadType | Enum: How a clip is kept once it is loaded: what its import settings call its Load Type. |
| AudioMix | Class: A game's mix: its buses, as the Audio tab lays them out — settings/audio.json beside the game's assets. |
| AudioPeaks | Record: A clip's waveform: what its file holds, and for each channel each column's lowest and highest sample, from −1 to 1. |
| AudioSettings | Record struct: What a clip's import settings say of it as it is played. |
| AudioShape | Record struct: What a clip's file holds: how many frames, at what rate, of how many channels, encoded how. |
| BakeLanded | Record: What baking a model made: its import, and what each baker made of it. |
| BakeWanted | Record: A model a plugin asked to be baked as the editor added something made of it: the model's path and the baker's name. |
| BakedBy | Record: What one baker made of a model. |
| BakedModel | Class: What a baker made of a model's meshes, as a file of the cache and an entry of a pack keep it: each mesh's bytes by its label, as the baker gave them. |
| BakerInfo | Record: A baker, as the editor knows it; see Schedule.BakeInEditor. |
| Bind | Class: Bindings made in code: map.Add("Jump", ActionType.Button, Bind.Key(Key.Space), Bind.Button(GamepadButton.South)). |
| BindingSource | Record struct: One thing on a device that a binding reads, named as settings/input.json names it. |
| BlendPoint | Class: One of a blend space's clips, and where it is placed. |
| BlendSpace | Class: The clips a state mixes by where one field or two fall among the places they are given. |
| BloomComposite | Enum: How a bloom's glow is put on the picture. |
| BoneMask | Class: The bones a layer moves, by their names, as ticked on a model's tree of them. |
| BuildOptimization | Enum: What a built game's executable is compiled for: the engine's Rust, which most of it is; the game's C# is compiled as it is either way. |
| BuildScene | Record: A scene in a build: the file, by its path under the assets and its identity, and whether it goes in. |
| BuildSettings | Class: What a build makes of a game: what it is called, the window it opens, and the scenes in it, the first of which it opens — settings/build.json in the game's folder, beside its assets. |
| BusEffect | Record: One effect on a bus of the mix: its kind, whether it is on, and its settings in its kind's order. |
| BusEffectField | Record: One setting of a kind of bus effect, as the engine describes it. |
| BusEffectKind | Enum: A kind of effect a bus of the mix runs, by the engine's number for it. |
| BusEffectType | Record: A kind of bus effect, its names and its settings, as the engine describes it. |
| BusEffectValue | Enum: A setting of a bus's effect, by the engine's number for it: what a game's code changes with WorldAudio.SetBusEffect. |
| BusEffects | Class: The kinds of effect a bus runs and their settings: the engine's own table (abyss_core::audio::effect), read once, so the editor shows and checks what the engine plays. |
| BusLevel | Record struct: How loud a bus of the mix has been since it was last asked: what the Audio tab's meters show. |
| CameraBloom | Record struct: A camera's bloom: what is bright spreads a glow round it, as light does in an eye or a lens. |
| CameraDepthOfField | Record struct: A camera's depth of field: what is CameraDepthOfField.FocalDistance away is sharp, and nearer and farther blurs, as through a lens — the more, the lower its CameraDepthOfField.ApertureFStops. |
| CameraFog | Record struct: How far a camera sees through the air: what it fogs to, how fast, and the glow it takes toward the sun — CameraFog.Linear(sky, 96f, 128f) hides the edge of a world drawn to 128 meters in the sky's color. |
| CameraSky | Record struct: A sky drawn behind everything a camera sees, where its clear color would show: a color straight up, one at the horizon and one straight down, blended by how high the camera looks, and a glow toward each directional light. |
| CatalogEntry | Record: One asset a catalog lists: where it is, who it is, and what it is loaded by if it is addressable. |
| ChildrenColumn | Struct: A chunk's column of Children: each row's, as a ChildrenView. |
| ChildrenView | Struct: The entities under one entity, in the order the hierarchy lists them: a view of Bevy's Children where Bevy keeps it, which a system is given a row at a time. |
| ChoiceVariant | Record: One variant of a ComponentChoice, and the value choosing it gives. |
| Chunk | Struct: One contiguous block of entities, exposing each queried component as a span over Bevy's own storage. |
| ChunkCollection | Struct: The chunks a ChunkCollection.Query resolved to. |
| ChunkCollection.Enumerator | Struct: Allocation-free enumerator over ChunkCollection. |
| ClipAddress | Class: A clip's key, a model's or a clip file's, which AssetAccess.LoadClip takes. |
| ClipCurve | Record: One curve on a clip: a field of a component on the animator — Footing.Plant — or on what is under it that its ClipCurve.Path names — a UI element's BackgroundColor.a — that the engine writes with the curve's value at the clip's time at every frame the clip plays, and, while clips fade, with their curves for it weighed by how much of each is drawn. |
| ClipEvent | Record: One event on a clip, as its model's import settings wrote it. |
| ClipEventFields | Class: An event's fields, as a model's import settings keep them: a JSON object of the struct's fields by their dotted names, each a number, or a list of numbers for an array, as a scene keeps a component's. |
| ClipFrame | Record struct: One frame of a clip file: the image a sprite shows from a time on, and the slice of it. |
| ClipId | Record struct: The id of a model's clip the engine loaded. |
| ClipMarker | Record struct: One sync marker on a clip: a moment named for what happens there — LeftDown, where the left foot lands. |
| ClipSettings | Record: How a model's clips are imported, beside how its meshes are: whether they are at all, which of them loop, and the events, curves and sync markers on each. |
| ColorUsageAttribute | Class: Shows a Vector4 or Vector3 field as a color: a swatch that opens the editor's picker, rather than its numbers. |
| CommandBuffer | Class: Records entity creation and removal for the engine to apply at the end of the frame. |
| CommandOutcome | Record struct: What applying a command buffer did. |
| CompiledShader | Record struct: What one variant of a shader compiled to. |
| CompiledVariant | Record: One compiled variant of a shader, as the world is given it. |
| ComponentBatch | Struct: A pending change to entities that already exist, whose new component values are written through spans. |
| ComponentChoice | Record: One enum a component holds, which no layout can describe: where it is, and what it can be. |
| ComponentField | Record struct: One field of a component, at the offset the engine reported rather than one C# assumed. |
| ComponentFieldSpec | Record struct: One field of a component C# declares, on its way to the engine. |
| ComponentGiven | Record: What a load would give one component by itself, as Given answers it. |
| ComponentId | Record struct: An untyped component id, as the native core knows it. |
| ComponentLayout | Class: Where every field of a component actually sits. |
| ComponentMenuAction<T> | Delegate: What a component's item in the Inspector does to it: changed through component, written back after. |
| ComponentMove | Class: What moving a component's values onto another did; see World.MoveComponent. |
| ComponentTraits | Enum: What a component is, in the three respects a caller has to know before touching it. |
| ComponentType<T> | Struct: A component type registered with a World, carrying the CLR type it maps to. |
| CompositePart | Record struct: One part of a composite binding: up of four keys, negative of two. |
| ConditionField | Record struct: A field a condition can read. |
| ConditionMistake | Record: A mistake in a condition, as the world finds it: what is wrong, and where, in characters into the text. |
| ControllerDocument | Class: What a controller file says, to read, change and write back. |
| ControllerFiles | Class: An animator controller as a file of its own: a .controller in a game's assets, which says what an animator plays and when, as layers of states in order. |
| ControllerLayer | Class: One layer of a controller. |
| ControllerState | Class: One state of a layer. |
| CursorShape | Enum: The shapes the pointer can take over a window. |
| CurveKey | Record struct: One key of a clip's curve: a time on the clip, in seconds, the field's value there, and how the curve goes on to the next. |
| DataAssetAttribute | Class: Marks a struct as a kind of data asset, declared in a game's or a package's code: files of it, name.asset, made from the Project panel's Create menu under DataAssetAttribute.Menu, edited in the Inspector with its fields' rows, named by an AssetRef<T> field of a component, of settings or of another data asset, packed with the game and read with World.Data. |
| DataAssetBinary | Class: A data asset as a built game's pack carries it: its struct's bytes and the field table they were written by — ABDA, a version, the kind's name, each field's name, offset, kind and count, and the bytes — so a game reads it without parsing text, and one whose struct has changed since maps each field it still has by name. |
| DataAssetFile | Class: A data asset as its file keeps it, name.asset: {"abyssAsset": 1, "type": "Abyss.Physics2D.PhysicsMaterial2D", "fields": {...}}, its fields as a settings file keeps them. |
| DataAssetType | Record: A kind of data asset declared in code, described for an editor to make and show; see World.DataAssetTypes. |
| DateLength | Enum: How long a date is written: what FormatDate and a string's {day:date long} ask for. |
| Decibels | Class: A volume as a share of the whole and as decibels, turned into each other: a bus's fader is in decibels, a sound's volume and a meter's level a share from zero to one. |
| DepthOfFieldMode | Enum: How a depth of field blurs what is out of focus. |
| DisplayMonitor | Struct: One display, in the desktop's physical pixels. |
| DrawnVariant | Record: One variant drawing asked a shader for. |
| DurationStyle | Enum: How a length of time is written: what FormatDuration and a string's {left:duration} and {left:timer} ask for. |
| DynamicList<T> | Struct: One entity's list, read and written where the engine keeps it: a view, which code holds while it works on the list and cannot keep. |
| EditorIcon | Enum: A picture beside a row of an editor window (EditorUi.Row), drawn as the editor's own. |
| EditorMenuItem | Record: An item a plugin put in one of the editor's menus: where, by the path it gave — folders and its name, between slashes — the plugin that put it there, and what it does. |
| EditorMenuPlace | Enum: Which of the editor's menus a plugin's item goes in; see ToolsMenu. |
| EditorOnlyAttribute | Class: Marks a plugin that is the editor's alone: built and run by the editor, and never by the game on its own. |
| EditorSelection | Class: The entities the editor has picked, for a game's systems to draw more for; empty in a game on its own. |
| EditorUi | Class: What a plugin's editor window is drawn with (Schedule.EditorWindow): the editor's own rows, buttons, headings and lists, each a line under the last, in the editor's look whatever draws it. |
| EditorWindowDraw | Delegate: What an editor window draws, once a frame while it shows; see Schedule.EditorWindow. |
| EditorWindowDraw<T> | Delegate: What an editor window with a state draws, once a frame while it shows; see Schedule.EditorWindow. |
| EditorWindowItem | Record: A window a plugin gave the editor: in the Window menu at its path — under the plugin's package's name, the game's own first — opened in a window of its own and drawn as it says; see Schedule.EditorWindow. |
| EngineAbout | Record: What the editor's Help ▸ About says of the engine a world runs; see World.About. |
| EngineSystems | Class: The systems the engine declares itself, by the name they are registered under. |
| EngineVersion | Class: The engine's version: one number for its C# and its Rust. |
| EntityKind | Enum: What sort of entity a EntityRow describes. |
| EntityRef | Record struct: An entity a component names: a joint's Connected Body, a door's switch, what a follower follows. |
| EntityRow | Struct: One entity, as a list of them crosses from the engine. |
| EntityVisibility | Enum: Whether an entity is drawn, as Bevy's Visibility on it says; see World.SetVisibility. |
| ExecuteAlwaysAttribute | Class: Marks a plugin that runs while its game is edited, as well as while it plays. |
| FadeCurve | Enum: How a fade goes from one state to the next. |
| FadeRule | Class: A fade a layer gives one change of state rather than its own. |
| FieldAsset | Enum: What kind of asset a reference field names; see FieldHint.Asset. |
| FieldChoice | Record struct: One value of an enum a field holds: its name as the enum declares it, and its number. |
| FieldColor | Record struct: How a color is shown: ColorUsage(showAlpha, hdr), which a Rust field says as #[reflect(@ColorUsage(true, true))] on a field holding Bevy's Color. |
| FieldHint | Record: What a component's author said about one of its fields: how it is shown — [Range], [Tooltip] and [HideInInspector], on their way to an inspector — and what it was called before, [FormerlySerializedAs], on their way to a reload and a scene. |
| FieldKind | Enum: What kind of value a component field holds. |
| FieldKinds | Class: Sizes for FieldKind. |
| FieldRange | Record struct: The two ends of a slider. |
| FieldValue | Struct: One value of a component's field: a number, or a whole number held exactly in 64 bits. |
| FieldView<T> | Struct: One field of every row in a chunk, reached at the offset the engine reported. |
| FileDrop | Record struct: A file dragged over a window or dropped on it, as World.ReadFileDrops reports it. |
| FileDropKind | Enum: What a file dragged in from the desktop is doing. |
| FileKindAttribute | Class: Says which files a FileRef field's slot takes: those ending in FileKindAttribute.Extension, which a package's own kind of file is known by — .abynav. |
| FileRef | Struct: A file a component names that the engine has no kind of its own for — what a package bakes and reads back itself, a navmesh — kept by its identity, which the inspector's slot is given by dragging the file onto it from the Project panel, or by the code that made the file. |
| Fired<T> | Record struct: One event of type T a clip fired on an animator as it passed it: what a system reads with SystemContext.Events, and a flow awaits with GameCode.AnimationEvent. |
| FiredClipEvent | Record struct: One event a clip fired on an animator, before its struct is made of its fields. |
| FixedList128 | Class: Makes a FixedList128<T> from a collection expression. |
| FixedList128<T> | Struct: A list of up to 128 T a component holds in itself: plain data, as a component has to be, its room fixed when it is written and its items as many as it holds. |
| FixedList16 | Class: Makes a FixedList16<T> from a collection expression. |
| FixedList16<T> | Struct: A list of up to 16 T a component holds in itself: plain data, as a component has to be, its room fixed when it is written and its items as many as it holds. |
| FixedList32 | Class: Makes a FixedList32<T> from a collection expression. |
| FixedList32<T> | Struct: A list of up to 32 T a component holds in itself: plain data, as a component has to be, its room fixed when it is written and its items as many as it holds. |
| FixedList64 | Class: Makes a FixedList64<T> from a collection expression. |
| FixedList64<T> | Struct: A list of up to 64 T a component holds in itself: plain data, as a component has to be, its room fixed when it is written and its items as many as it holds. |
| FixedList8 | Class: Makes a FixedList8<T> from a collection expression. |
| FixedList8<T> | Struct: A list of up to 8 T a component holds in itself: plain data, as a component has to be, its room fixed when it is written and its items as many as it holds. |
| FixedText128 | Struct: Text of up to 128 bytes that a struct holds in itself — an item's name in a data asset, a label in a component — plain data, as a component and settings have to be: its UTF-8 and zeros after. |
| FixedText256 | Struct: Text of up to 256 bytes that a struct holds in itself — an item's name in a data asset, a label in a component — plain data, as a component and settings have to be: its UTF-8 and zeros after. |
| FixedText32 | Struct: Text of up to 32 bytes that a struct holds in itself — an item's name in a data asset, a label in a component — plain data, as a component and settings have to be: its UTF-8 and zeros after. |
| FixedText64 | Struct: Text of up to 64 bytes that a struct holds in itself — an item's name in a data asset, a label in a component — plain data, as a component and settings have to be: its UTF-8 and zeros after. |
| Flow | Class: A sequence of a game's that goes on over frames — waves of enemies, a level coming in, a door opening — written as one async method: what AddFlow runs once the game has started. |
| FogFalloff | Enum: How a camera's fog thickens with distance. |
| FontFiles | Class: A font's file: .ttf or .otf, TrueType or OpenType, as bevy_text reads it. |
| FormerlySerializedAsAttribute | Class: Says what a field was called before, so what was kept under that name is found again: a field is renamed without losing its saved value. |
| FullscreenMode | Enum: How a built game's window fills the screen. |
| GameApplication | Class: The game as an application: what it is called, who makes it and its version, as its Player settings say; whether it is played in the editor; its end, asked for from its code — a main menu's Exit — and whether there is one; and a web page opened from it, an About screen's link. |
| GameCode | Class: Code of a game's that runs between frames on the engine thread — a flow, a plugin's start — and what it can wait for there: the next frame, seconds of the game's time, a load. |
| GameCursor | Class: The cursor as a game asks for it: GameCursor.Lock holds it still for a camera turned by the mouse — whose motion still arrives — and GameCursor.Hide hides it. |
| GameDisplay | Class: How the game is shown as it plays, as a settings screen offers it: its window framed or across the screen (GameDisplay.Mode), waiting for the display to refresh before it shows a frame (GameDisplay.VSync), and no more frames a second than GameDisplay.FrameRateCap, among the rates the display refreshes at (GameDisplay.RefreshRates); and how many it is drawing (GameDisplay.FrameRate), as a debug screen shows. |
| GameInput | Record struct: What of the devices a game has; see World.SetGameInput. |
| GameMode | Enum: Which of a game's systems run on a world's frames. |
| GamePackages | Class: A game's packages, removed: what uses one, and taking it out of the game. |
| GamePictureArea | Record struct: Where a game's picture is: a rectangle of one of the engine's windows, in its logical pixels; and the size of the game it shows, which a cursor over it is measured in, where the game is drawn at a size of its own and scaled to fit, as an editor's Game view set to a resolution draws it. |
| GameRandom | Class: Random numbers for a game: a stream of them from a seed, the same stream for the same seed on every system — new GameRandom(seed).Range(0, 6) — and, without one, GameRandom.Shared. |
| GameStart | Class: The game starting: what a plugin's IPlugin.BeforeFirstScene is given, before any scene is read — to read a save, sign in, fetch what the game is set up with, and choose the scene it opens. |
| GameTime | Class: The game's clock, as World.Time gives it: how much of the game's time this frame took, how much has passed since the game started, how often its fixed systems run, and how fast its time runs. |
| GameUi | Class: A game's interface as it plays: the documents its UI Documents show, made from their files, each given the class the build made of it, and what their elements do, heard; see World.Ui. |
| GamepadAxis | Enum: One direction of a gamepad's stick, negative one to one, up and right positive. |
| GamepadButton | Enum: A gamepad's button, by where it is on the pad rather than what it is labeled. |
| GamepadKind | Enum: Whose gamepad it is, which is what its buttons are labeled: A, Cross or B for the one at the bottom. |
| GamepadStick | Enum: Both directions of a gamepad's stick at once. |
| GizmoSegment | Struct: One line a game's gizmos drew, as the editor's Scene panel draws it. |
| Gizmos | Class: What a system draws lines with for the editor's Scene panel: the lines, loops, cubes, circles and spheres of Bevy's Gizmos, under the same names, for a game's C#. |
| GlobalTransform | Struct: Where an entity is in world space — as an affine matrix, which is not the same shape as Transform. |
| HandlePlacement | Struct: One picked entity, as the editor's move, rotate, scale and rect handles move it: its own transform, where it is in the world and where its parent is, the box round what it and what is under it draw, and the box round what it draws itself, with what its sprite is. |
| HeardInput | Record struct: What World.ListenForInput heard first: a key, mouse button, gamepad button or stick's direction. |
| HeardKind | Enum: What HeardInput heard. |
| HideInInspectorAttribute | Class: Leaves a field out of the inspector's normal view. |
| IPlugin | Interface: A part of a game: what it adds to a schedule when the game plays. |
| IPreferences | Interface: A class marked PreferencesAttribute with a name: kept as a file of its own. |
| IPreferencesData | Interface: What the source generator gives a class marked PreferencesAttribute: how its members are written and read. |
| IStaticGeometry2D | Interface: What stands still in a world in 2D — its static colliders, as a physics package has them — for what is worked out of a scene by code that has no physics of its own: a navmesh in 2D, its floor less what the colliders cover. |
| IStaticGeometry3D | Interface: The triangles of what stands still in a world in 3D — its static colliders, as a physics package has them — for what is worked out of a scene by code that has no physics of its own: a navmesh baked from colliders rather than from what is drawn. |
| ISystemTimings | Interface: What a profiler is told of each system's run while it is a schedule's Schedule.Timings: told after every run, on the thread that ran the system — a schedule run in parallel calls it from several at once. |
| ImageAddress | Class: An image's key, which AssetAccess.LoadImage takes. |
| ImageColor | Enum: What the numbers in an image made from pixels are. |
| ImageId | Record struct: The id of an image the engine loaded or made. |
| ImagePixels | Record: An image's pixels: its first level, four bytes a texel, row by row from the top left. |
| ImageRegion | Record struct: A rectangle of an image, in its pixels from its top-left: what UiElement.SetImage draws of it. |
| ImageSampling | Record struct: How an image made from pixels is drawn, which a file's import settings say for it: its filter, its wrap and how many mipmaps it has, made of its pixels — what an atlas of pixel art needs, new ImageSampling { Filter = ImportFilter.Point, MipLevels = 5 }. |
| ImportAxes | Enum: What to do about the axes a model file was authored in. |
| ImportColor | Enum: What the numbers in an image file mean. |
| ImportCompression | Enum: Whether an imported texture is block-compressed, and how well. |
| ImportFilter | Enum: How a texture is sampled when a pixel covers more or fewer than one texel. |
| ImportIndexFormat | Enum: How big each number of an imported mesh's index buffer is: its Index Format. |
| ImportMipFilter | Enum: How each mipmap is made from the one above it. |
| ImportMipmaps | Enum: Whether an imported texture has a mipmap chain. |
| ImportNormals | Enum: Where an imported mesh's normals come from: its Normals. |
| ImportSettings | Record struct: How one file should be read, as sixteen numbers. |
| ImportTangents | Enum: Where an imported mesh's tangents come from: its Tangents. |
| ImportTextureType | Enum: What a texture is for, which decides how its numbers are read and what it is imported as. |
| ImportWrap | Enum: What a texture does outside its own edges. |
| ImportedAudio | Record struct: What an import of a sound clip made: how long it is, how much of it there is, and what it was made from. |
| ImportedFormat | Enum: What the GPU is given of an imported texture. |
| ImportedMesh | Record: One mesh of an imported model, as its file's tables describe it. |
| ImportedModel | Record struct: What an import of a model made: how many meshes, vertices and triangles, the bytes they take, and the textures it carries. |
| ImportedTexture | Record struct: What an import made: its size, its mipmaps, its format and what it takes on the GPU. |
| InputAction | Class: One action of a game's: what its code asks about — whether Jump was pressed, which way Move points. |
| InputActionState | Struct: One action of one player's this frame, as the engine works it out from every device. |
| InputActions | Class: A game's input actions in their maps: settings/input.json beside the game's assets, which a game's code reads through World.Input. |
| InputBinding | Record: One way of driving an action, and what is done to its value; see Bind for making one. |
| InputDevice | Record struct: The device a player last used. |
| InputDeviceKind | Enum: Which kind of device a player last used; see PlayerInput.LastDevice. |
| InputMap | Class: A map of actions, which a player has on or off as a whole: a game's, a menu's. |
| InputNames | Class: What keys and buttons are called where a player reads them: Space, Up Arrow, Left Shift; a gamepad's by its maker — A, Cross or B for the one at the bottom. |
| InputState | Struct: Everything the engine knows about the keyboard and mouse this frame. |
| InstalledPackage | Record: A package a game has: its folder, and what its manifest says. |
| JSException | Class: What the page threw at a JSImportAttribute method's call, or why it could not be called, as the page said it. |
| JSExportAttribute | Class: Marks a static method the page calls: the build's game.js gives it to the game's scripts as its class's, camel-cased — Game.Pause as Game.pause() — a promise of what it gives, since it runs at the start of the game's next frame, on the engine thread, where the world is the game's to change. |
| JSImportAttribute | Class: Marks a static partial method whose body the engine writes: in a game playing in a browser it calls the function of the same name, camel-cased, that the game's web/<Class>.js exports — Ads.ShowRewarded calls showRewarded in web/Ads.js — and in the editor and a desktop build the same method of its class's stand-in (JSStandInAttribute). |
| JSStandInAttribute | Class: Marks a class whose static methods answer the JSImportAttribute methods of JSStandInAttribute.Of in the editor and in a desktop build, where there is no page: each the method of the same name, parameters and result. |
| Key | Enum: A key, as AbyssEngine names it. |
| KeyEase | Enum: How a clip's curve goes on from a key to the next. |
| KeyEases | Class: Names a KeyEase as a clip file writes it after a key's time and value. |
| KeyEvent | Struct: One key going down or coming up, as World.ReadKeys reports it. |
| LabelName | Class: A label addressable assets carry, as the build names it in a game's code — Labels.Animals — which AssetAccess.LoadPrefabs takes: a label no asset carries any more is a build error where it is used. |
| Language | Record struct: A language a game can be shown in: its code as BCP 47 writes it (ru, pt-BR, zh-Hans), its name in English, and its name in itself, which a language menu shows. |
| LayerBlending | Enum: How a layer above the first is laid over the layers under it. |
| LayerMask | Record struct: Some of a project's 32 layers, a bit each: what a camera draws, and what physics and rays will meet. |
| LayerMatrix | Struct: Which of a project's 32 layers meet which: a tick for each pair, the same both ways — Default and Player meet, or neither meets the other. |
| LayerRun | Record: One layer of an animator, as its controller runs it. |
| LayerSettings | Class: A project's 32 layers by name: settings/layers.json beside the game's assets, which Project Settings' Tags and Layers page lays out. |
| Leaving | Enum: When a state may be left. |
| LengthUnit | Enum: The unit a curve writing a length of Bevy's UI writes it in: pixels unless it says otherwise, named as CSS names them. |
| LengthUnits | Class: Names a LengthUnit as a clip file writes it. |
| Lens | Record struct: How a camera sees: where it is, which way it is turned, how wide it sees and how near, and how big the view it draws into is; for an orthographic camera, how tall a piece of the world it sees in place of how wide an angle. |
| LightKind | Enum: Which kind of light a SceneLight is. |
| ListColumn<T> | Struct: The lists of a chunk's rows, one for each, in the order of its entities. |
| ListLayout | Record: What one item of a list component is: how big, and where its fields are. |
| ListType<T> | Struct: A list component registered with a World: each entity carrying it holds a list of T, as many as it needs. |
| ListedPackage | Record: One package a game's list names: its id, the version the game has, and where it came from. |
| Localization | Class: A game's languages and strings, and the language the player uses: world.Localization. |
| LocalizationSettings | Class: A game's languages: settings/localization.json beside the game's assets, which Project Settings' Localization page lays out — whether the game is localized, its languages, the one it is written in, which it starts in, and what a missing string shows. |
| LocalizedArgument | Struct: An argument a string is filled in with: {count} in it gives way to the argument named count, written as the language writes its kind of value, and {price:0.00} in a style of its kind. |
| LocalizedAsset | Class: A localized asset: an image, a sound or a font that is a file for each of a game's languages, as its .localized file names them, its default and a file for each language that has one of its own. |
| LocalizedFile | Record struct: A file a localized asset names: by its path, and by its identity, which finds it where it has moved. |
| LocalizedKind | Enum: What a localized asset is: the kind of file its default and each language's file are. |
| LocalizedString | Struct: A string of the game's a component names: an entry of a string table, said in the player's language by Localization.Text. |
| Log | Class: The engine's log: what Bevy, the libraries under it, the editor and a game have said. |
| LogEntry | Record: One thing that was said. |
| LogReader | Class: Walks the engine's log from a place of its own, reading what has been said since. |
| LogSeverity | Enum: How serious a message is. |
| MapName | Record struct: An input map as code names it: Actions.Maps.UI, which the build writes; its name; or the InputMap itself. |
| MarkerKind | Enum: What a SceneMarker marks. |
| MarkerProjection | Enum: How a camera a SceneMarker marks projects. |
| MarkerShape | Enum: The shape a Particle Emitter a SceneMarker marks sends its particles out from, each with its numbers in SceneMarker.Area in the order given here. |
| MaterialAddress | Class: A material's key, which AssetAccess.LoadMaterial takes. |
| MaterialField | Record struct: One editable number in a MaterialSpec, at the offset the compiler chose. |
| MaterialFiles | Class: A material as a file of its own: a .mat in a game's assets, which says what shader the material runs and what its values are. |
| MaterialId | Record struct: The id of a material the engine created. |
| MaterialRemap | Class: The material files a model's own materials are drawn as, instead of as its import describes them: each by the name the material has in the file, or by its label — Material0 — for one it names nothing. |
| MaterialSlotName | Record: One of a model's materials, as the model's sidecar keeps it for the key the build writes of it: Addresses.Models.Door.Materials.Stone. |
| MaterialSpec | Struct: How a surface should look, in the part of PBR the engine can write down. |
| MeshAddress | Class: The key of a part of a model's mesh — what is drawn with one of its materials — on the model's key, Addresses.Models.Door.Meshes.Frame, which AssetAccess.LoadMesh takes. |
| MeshBaker | Delegate: What a package works out of one mesh of a model as the editor imports it — the shapes a Mesh Collider 3D is made of — kept beside the import and packed with the model, so a game has it rather than working it out as it starts. |
| MeshData | Struct: The vertex data of a mesh, as spans over the caller's own memory. |
| MeshGeometry | Record: A mesh's corners and the triangles between them, as the engine holds the mesh: what a collider of it is made of. |
| MeshId | Record struct: The id of a mesh the engine created, which is what a caller holds instead of a handle. |
| MeshPartName | Record: A part of a model's mesh — what is drawn with one of its materials — as the model's sidecar keeps it for the key the build writes of it: Addresses.Models.Door.Meshes.Frame. |
| MissingStrings | Enum: What a string none of the languages it is looked for in has shows, and where it is looked for. |
| ModelImporter | Class: The engine's model importer: a model's file — glTF, FBX or OBJ — and its settings in, an .abymesh file of its meshes out, each as Bevy keeps it, its normals and tangents made once; and what such a file holds. |
| MouseButtons | Enum: A mouse button. |
| MouseInput | Enum: What of the mouse a binding reads. |
| NameColumn | Struct: A chunk's column of Name: each row's, as a NameView. |
| NameView | Struct: What one entity is called: a view of Bevy's Name where Bevy keeps it, which a system is given a row at a time, to compare without making a string. |
| NativeBody | Record struct: A body of engine work written in Rust, which a Schedule can run as a system alongside C# ones. |
| Noise | Record struct: Smooth randomness: a number from -1 to 1 for each place, changing gently from place to place, and the same for the same place and Noise.Seed every time it is asked and on every system — the stuff terrain, caves, clouds and wobbles are made of. |
| NoiseFractal | Enum: How a Noise's layers are summed. |
| NoiseKind | Enum: The pattern one layer of a Noise makes. |
| NotedInEditor<T> | Delegate: What the Inspector says under a T on entity, from what the entity is now: a mesh collider saying a dynamic body meets its mesh as its hull. |
| NumberDigits | Enum: Which digits a game writes its numbers in. |
| OutlineEdge | Struct: One edge of an outline, on the screen. |
| Pack | Class: A game's assets as a built game reads them: game.abypack, every asset in the engine's own forms, each entry compressed with LZ4 where that makes it smaller, found by its path. |
| PackAccess | Struct: A game's packs as its own code reaches them: an add-on its build made apart, a pack it was given after it shipped, attached over the others and taken away again. |
| PackEntryKind | Enum: What an entry of a pack holds. |
| PackId | Record struct: A pack a game attached with PackAccess.Attach, by its whole path: what takes it away again. |
| PackStamp | Record struct: Whose a pack is: the game a build made it for, and the pack's own identity, new each time it is built. |
| PackWriter | Class: Writes a pack an entry at a time; nothing is a pack until PackWriter.Finish. |
| PackWritten | Record: What writing a pack made. |
| PackageArchive | Class: A package as one file, acme.physics-1.2.0.abypackage: a zip of what it carries (PackageFiles) and PackageFiles.FileName, every file's hash, which is what Export writes, the registry keeps and a store will send. |
| PackageAuthor | Record: Who made a package. |
| PackageBump | Enum: Which part of a version PackageVersion.Next raises. |
| PackageChanges | Record: What a game's copy of a package has that its original has not, by path in the package, with forward slashes. |
| PackageFiles | Class: A package's files, compared: what a game's copy of one has changed of its original. |
| PackageHeldException | Class: A file or folder of a package that would not be let go of — another program has it open — so the package was not removed: it is as it was. |
| PackageIgnore | Class: A game's packages/.gitignore, which the editor writes whole: each engine package as it was installed is left out of git, since settings/packages.json lists it and every build puts it back from the registry; one with a file changed is kept in git, as is every package that is not the engine's, which a registry may not have when the game is built elsewhere. |
| PackageInArchive | Record: What an archive of a package says it is: its manifest, and the hashes of the files it holds. |
| PackageList | Class: The packages a game has, as settings/packages.json lists them: the version of each and where it came from. |
| PackageManifest | Class: What a package says of itself, in the package.json at its folder's top: its id and version, who made it and on what terms, what engine it is for and what other packages it needs. |
| PackageNativeSource | Record: What a package's native libraries are built from, as the notices beside a built game name it. |
| PackagePath | Class: How a path names a file of a package's: its id, ://, and its path under the package's own assets — acme.physics://models/rock.glb — or, for a shader, under its own shaders. |
| PackageRegistry | Class: The registry: a folder of packages as their authors made them, every version an archive, acme.physics/1.2.0.abypackage, which a game installs from, Export writes into, and a file sent or downloaded is added to; never changed by a game's edits to its copy. |
| PackageSource | Enum: Where a game's package came from, as its list keeps it (PackageList). |
| PackageUpdate | Record: What changing a game's copy of a package to another version the registry has would do: each file it would change, what the copy has done to it, the files of the person's it leaves alone, and why it cannot be done or what it would break. |
| PackageUsers | Record: What in a game uses one of its packages, as removing it lists them. |
| PackageVersion | Record struct: A package's version, major.minor.patch with a pre-release after - if it is one, as its manifest gives it (PackageManifest.IsVersion), compared as semantic versions are, and the ranges a package's dependencies are given in: ^1.2.0, ~1.2.0, 1.2.0. |
| PaintBatch | Record struct: A run of indices drawn with one texture, clipped to one rectangle. |
| PaintVertex | Record struct: One vertex of a painted frame: where it is, what part of a texture it takes, and what color. |
| Painting | Class: Constants shared by everything that paints. |
| ParallelChunkBody | Delegate: What SystemContext.ForEachChunkParallel runs for each slice of the system's chunks: a part of one chunk, on whichever thread took it. |
| Particle | Struct: One particle as code reads it, in the world; see Read. |
| ParticleCast | Struct: One particle's move this frame, in the world, as a provider of particle colliders is asked about it; see RegisterColliders. |
| ParticleColliderProvider | Record struct: A physics package registered as a provider of particle colliders: its id, its package's, the name it is shown by, and whether it is 2D. |
| ParticleHit | Struct: What a provider of particle colliders says a particle met first along its move; see RegisterColliders. |
| ParticlePreviewState | Record struct: How what the editor plays while the game is edited was as of the last frame; see Preview. |
| ParticleState | Record struct: How a Particle Emitter was as of the last frame. |
| ParticleSubEmitter | Record struct: A sub-emitter of an emitter's: the entity it is on, and what fires it; see WorldParticles.SubEmitters. |
| Placed | Record struct: A transform to give an entity, as the editor's handles ask for one. |
| PlacedSprite | Enum: What a picked entity's sprite is, as the Rect tool stretches it. |
| PlacedTile | Record struct: A tile and the cell it goes in: how many tiles along X and up Y from its Tilemap's origin. |
| Placement | Record struct: Where an entity is in the hierarchy: under which parent, and before which sibling. |
| PlayOptions | Record struct: How a sound is played: how loud and how high, whether it loops and fades in, and, played in the world, how it falls off with its distance from the listener. |
| Player | Class: The engine's start for a game: the window, the game's pack, its components and plugins, and the first scene of its build — what a built game runs, and what dotnet run runs from a game's folders. |
| PlayerInput | Class: One player's input actions, asked about each frame: context.Input.Pressed(Actions.Player.Jump), context.Input.Vector("Move"). |
| PlayerSettings | Class: What a built game is, to a player and to the platform: Player in Project Settings — settings/player.json beside the game's assets. |
| PlayerStart | Record: Where a game plays from, and what its build says of it: what Plan works out. |
| PlayingClip | Record struct: One clip an animator plays, as World.AnimatorOf says it. |
| PluralCategory | Enum: The forms a string can have for a number, as Unicode CLDR names them; PluralCategory.Other is every language's. |
| PrefabAddress | Class: A prefab's or a model's key, which AssetAccess.LoadPrefab takes. |
| PrefabId | Record struct: A prefab a game loaded to make instances of: a hand-made .prefab or a model's, by the path it was loaded by. |
| PrefabRef | Struct: A prefab a component names: a hand-made .prefab or a model, kept by its identity, which the inspector's slot is given by dragging the file onto it from the Project panel. |
| Preferences | Class: A player's own data — the settings a game keeps for whoever plays it, the keys they rebound, later their saves — in a folder of theirs: World.Preferences. |
| PreferencesAttribute | Class: Marks a partial class as a player's preferences: what Preferences.Save keeps and Preferences.Load reads back, as name.json in the player's folder. |
| PreviewChannel | Enum: Which of an imported texture's channels a preview shows. |
| ProfilePart | Enum: Which of a profile's parts a name is asked of. |
| ProfileStages | Struct: How long each of a frame's main schedules took; see ProfiledFrame.StagesNs. |
| ProfiledFrame | Struct: A frame of the main thread's as the engine timed it, for the editor's Profiler: its number, when it started and how long it took — to the next one's start — and of that how long each of Bevy's main schedules took, and how long the host's frame and its fixed steps took within them. |
| ProfiledRender | Struct: The render thread's drawing of a frame, as the engine timed it: the frame it draws, when it started and how long it took, and how long each of its parts took — up to the window's next image, the wait for it, the frame's draws worked out, drawn and presented, and what is put away after. |
| ProjectAge | Enum: How a project's stamp compares with the editor opening it. |
| ProjectSettingsAttribute | Class: Marks a struct as a project's settings, declared in a game's or a package's code: a resource every world has from the start, which its systems read with Res<T>; a page of Project Settings by ProjectSettingsAttribute.Title, its fields edited with the Inspector's rows; and settings/<file>.json, which a built game's pack carries. |
| ProjectSettingsFile | Class: A project's settings as their file keeps them: {"abyssSettings": 1, "fields": {"Gravity": [0, -9.81]}}, every field by its dotted name, each a number, or a list of numbers for one of several, as a scene keeps a component's; a fixed text as its text, and a reference to an asset as {"guid": ..., "path": ...}. |
| ProjectStamp | Record: The engine a project was last opened with, and the game's identity: settings/project.json, which the editor reads as it opens the project, asks about when it is another engine than its own, and then writes its own into, giving a game with no identity one. |
| Query | Class: A prepared query over a fixed set of components. |
| QueryFilter | Struct: A presence constraint that narrows which entities a query matches, without producing a column. |
| QueryTerm | Struct: One component a query touches, and how. |
| RangeAttribute | Class: Shows a number field as a slider between two values, and keeps what is typed into it between them. |
| Ray3D | Record struct: A ray in a 3D world: where it starts, and the way it goes, a unit long. |
| RayHit | Struct: One entity a ray passed through: how far along the ray, and where. |
| ReadOnlyDynamicList<T> | Struct: One entity's list, to read: a view, as DynamicList<T> is. |
| ReadOnlyListColumn<T> | Struct: The lists of a chunk's rows, to read. |
| RebindOptions | Record: What GameCode.Rebind listens for. |
| RebindResult | Record: What PlayerInput.Rebind did. |
| Rebinding | Record struct: A player's own binding, in place of the game's: what PlayerInput.Rebind puts there. |
| RecordingQuality | Enum: How good a recorded video's pictures are: how many bits a second they take. |
| RecordingState | Enum: Whether a video is being recorded. |
| RegisteredPackage | Record: A package the registry has, every version of it, oldest first. |
| RegisteredVersion | Record: A version of a package the registry has: its archive, and what its manifest says. |
| RelativeStyle | Enum: How long a relative time is written: what FormatRelative and a string's {seen:relative} and {seen:relative-short} ask for. |
| RemappedMaterial | Record struct: A material file one of a model's own materials is drawn as instead. |
| RenderParts | Struct: How long each part of a drawing took; see ProfiledRender.PartsNs. |
| RenderSetup | Record: The renderer. |
| Res<T> | Struct: Read-only access to a resource's value, pointing at the native storage. |
| ResMut<T> | Struct: Read/write access to a resource's value, pointing at the native storage. |
| ResourceBorrow<T> | Struct: An exclusive borrow of a resource, held for as long as the borrow is alive. |
| ResourceId | Record struct: An untyped resource id, as the native core knows it. |
| ResourceTerm | Struct: One resource a system reads or writes. |
| ResourceType<T> | Struct: A resource type registered with a World — singleton data with no entity attached. |
| Rolloff | Enum: How a 3D sound's volume falls with its distance from the listener. |
| RustCrates | Class: What the engine reads of a crate's manifest, the Cargo.toml in a game's or a package's rust folder: its package's name, and whether it names another crate as one it needs. |
| SceneAccess | Struct: The world's scenes, to load and unload while a system runs: SystemContext.Scenes. |
| SceneAddress | Class: A scene's key, which SceneAccess.Load takes. |
| SceneBone | Struct: One joint of a skin, as the editor's Scene panel draws a skin's bones: where it is, how it is turned, and the joint its bone starts from. |
| SceneDraw | Enum: How the editor's Scene panel draws the scene. |
| SceneEdit | Record struct: One thing a person did to a component's handles in the Scene view, for its plugin to make of it. |
| SceneEditHandles | Class: A component's handles in the editor's Scene view while it is edited there, as an editor-only plugin says they are (Schedule.EditInScene): the dots a person drags, the lines a dot can be added on, and whether a dot can be deleted, each in the entity's own units on its XY plane, where its Transform puts it; and the points a person moves anywhere, in its own units, by the Move tool's arrows and squares. |
| SceneEditKind | Enum: What a person did to a component's handles in the Scene view. |
| SceneEditable | Record struct: What a component is edited by in the Scene view: one the editor offers to edit there; see World.EditableInScene. |
| SceneEdited<T> | Delegate: Changes component as edit says: a box collider's side moved to where its dot is dragged. |
| SceneHandlesOf<T> | Delegate: Says the handles of component, on entity, into handles, in the entity's own units: a box collider's dot in the middle of each side. |
| SceneId | Record struct: A scene: the entity that stands for everything one load built, or one script made. |
| SceneLight | Record struct: A light's color and strength, as World.LightOf reads them: a sun of 2,000 lux is a bright day, 100 lux moonlight. |
| SceneMarker | Struct: One light or camera, as the editor's Scene panel marks it: where it is, which way it faces, and what it is. |
| SceneMode | Enum: What a scene loaded while a game plays does to the scenes there are already. |
| ScenePace | Enum: How a scene comes in once all of it is built, and how it goes when it is unloaded: in one frame, or over several. |
| SceneProjection | Record struct: How a camera projects: the editor's Scene panel's, and a game's own through World.SetProjection — SceneProjection.Perspective(70f, 0.05f, 600f). |
| SceneState | Enum: Where a scene is in being loaded and unloaded. |
| Schedule | Class: An ordered set of systems that the engine can run, sequentially or in parallel. |
| ScreenOrientation | Enum: Which way a game on a phone or a tablet is held. |
| ScrollUnit | Enum: How far one unit of scroll goes. |
| SerializeAllFieldsAttribute | Class: Says that a scene writes every field of this component, even one that holds what a load would give it anyway. |
| Services | Class: The objects a game keeps that are no data of the ECS's — a web client, a save system, a store's SDK — one of each type, found by the type: World.Services. |
| SettingsImage | Record: An image a setting names: by its path under the assets and by its identity, which finds it where it has been moved. |
| SettingsType | Record: A project's settings declared in code, described for an editor to show and a file to keep. |
| ShaderAddress | Class: A shader's key — every one of a game's shaders, and of its packages', has one, as each is packed — which AssetAccess.LoadShader takes: Shaders.Glow, by its path in the shaders folder, a package's after its id. |
| ShaderCompiler | Class: A game's shaders and Bevy's shader library as they were when it was made, ready to compile variants of the game's shaders to SPIR-V from. |
| ShaderFiles | Class: A game's shader file, by its extension: .wesl, WESL as Bevy 0.20's own shaders are written and as a new one is made, or .wgsl, which the engine composes as WESL too, WGSL being WESL with no imports or switches. |
| ShaderId | Record struct: The id of a shader read out of a game's shaders folder. |
| ShaderKind | Enum: What a shader draws: a mesh's surface, or a UI element. |
| ShaderKinds | Class: What a shader's text says it draws, read as the engine reads it. |
| ShaderLayout | Record: What a shader takes: its values, and the names of its textures. |
| ShaderTarget | Enum: What a game's shaders are compiled for. |
| ShaderValue | Record: One value a shader takes, as its WGSL declares it. |
| SharedText | Record struct: A text a component holds: a handle to a string the engine keeps, which never changes, so copies of it share it safely, as copies of a C# string do. |
| SheetDeclaration | Record: A declaration of a stylesheet's rule. |
| SheetRule | Record: A rule of a stylesheet, as the Style Sheets panel lists it. |
| SheetRuleKind | Enum: What a rule of a stylesheet is. |
| SimulatedGamepad | Class: A gamepad that is not there, for a test of a game's input: what it is written as pressing is read on the next frame. |
| SnapshotRestore | Record: What putting a WorldSnapshot back did. |
| SortAxis | Enum: What decides between two sprites of one sorting layer and one order. |
| SortingLayer | Record: One sorting layer of a game's, as settings/sorting.json holds it. |
| SortingLayers | Class: A game's sorting layers, in the order they are drawn, and what decides between two sprites of one layer and one order: settings/sorting.json beside the game's assets, which Project Settings' Sorting Layers lays out. |
| Sound | Record struct: A sound a game asked for, by the number it was given: what it is asked to stop, pause, resume or change, and asked whether it still plays. |
| SoundState | Enum: How far along a sound is. |
| SourceKind | Enum: Which device a BindingSource is on, and what of it. |
| SourcePicture | Record: A source image as it is, for the Sprite Editor to draw it and cut it in its own pixels. |
| SpawnBatch | Struct: A pending batch of new entities, whose initial component values are written through spans. |
| SpriteMode | Enum: How an image of the Sprite type is drawn: whole, or cut into slices — its Sprite Mode. |
| SpriteResizedInEditor<T> | Delegate: Changes a T on entity, whose sprite the editor has just resized from from to to, in the entity's own units: a collider kept fitted to the sprite as the Rect tool stretches it. |
| SpriteSheet | Record: An image's Sprite Mode and its slices, as its sidecar keeps them: what the Sprite Editor cuts it into, what the editor tells the world (World.UseSpriteSheet), and what a build packs beside the image. |
| SpriteSlice | Record struct: One slice of an image cut into sprites: what finds it, what it is called, its rectangle of the image in pixels from its top left corner, its pivot and its border. |
| StateRun | Record struct: One state of an animator's layer, as it runs it. |
| StringEntry | Class: One entry of a string table: its name, its identity, and what it says in each language, a text, or for a string with a count, a text for each plural form of the language. |
| StringKey | Record struct: One of a game's strings, as code names it: its table's identity, its entry's, and its name, Menu.Play, which shows where no language has it. |
| StringTable | Class: A string table: a .strings file of a game's assets, its entries' strings in every language the game has, each entry with an identity it keeps. |
| StructuralAccess | Struct: What a system is allowed to change about the shape of the world. |
| StyleProperty | Record: A property a stylesheet's rule can set. |
| StylePropertyKind | Enum: How a property a stylesheet's rule sets is edited: what its value is. |
| StyleSheetFiles | Class: A stylesheet's file: .css, CSS as a web page's is, read by bevy_flair. |
| StyleSheetText | Class: A stylesheet's text read into its rules, and the edits the Style Sheets panel makes to it, as abyss_core::ui::sheet reads and writes them: the least text changed, what a person wrote kept as they wrote it. |
| StyleValue | Record: A property a stylesheet's rule sets, and what to. |
| SubEmitterTrigger | Enum: What a parent's particle does that fires a sub-emitter. |
| SystemBody | Delegate: The body of a system. |
| SystemClipboard | Class: The platform's clipboard, as text: what the editor or a game copies goes there, where any other program can paste it, and what another program copied comes from there. |
| SystemConflict | Class: A pair of systems that cannot be in flight at the same time. |
| SystemContext | Struct: What a system body receives when it runs. |
| SystemErrorHandler | Delegate: Called when a system fails. |
| SystemFailure | Class: A system that threw while the schedule was running it. |
| SystemId | Record struct: Identifies a system registered with a World. |
| SystemTiming | Record struct: A system's run, as a profiler is told it; see ISystemTimings. |
| TakenEntities | Record struct: What World.TakeEntities took: where the entity was, and how many went with it. |
| TakenReport | Record: What World.TakeEntities keeps under one token. |
| TextImport | Record: How a text file — a .txt or a .md — is imported, as its inspector's Import As says: as nothing, which every one is until somebody says otherwise, or as a license, whose text every build of the game writes into the third-party notices beside it, under what it covers. |
| TextImportAs | Enum: What a text file is imported as: nothing a game reads, or the license of what it is beside. |
| TextureImporter | Class: The engine's texture importer: an image file and its settings in, a KTX2 file out, with its mipmaps and no larger than its Max Size; and a preview of what it made. |
| TexturePreview | Record: One mipmap of an imported texture, as a preview shows it: four bytes a pixel, opaque. |
| Tile | Record struct: What a cell of a Tilemap holds: a slice of its tile set, by the slice's identity, flipped across or up; Tile.None for nothing. |
| TileCollision | Enum: How Physics 2D's Tilemap Collider 2D meets a tile of a slice: as solid ground, not at all, or as a one-way platform met from above alone. |
| TileOutline | Record: One line of the outline Physics 2D meets a Tilemap's tiles by, in the Tilemap's own units: a loop round a region of solid tiles, the solid on the left of each piece, or the top of a row of one-way tiles. |
| TileShape | Record: What of its cell a tile of a slice fills, as Physics 2D's Tilemap Collider 2D meets it and a Shadow Caster 2D casts from it: the whole cell, what of the slice's art shows — its stair steps straightened up to TileShape.Smoothing pixels — or shapes drawn on it, their corners in the slice's pixels from its top left corner down. |
| TileShapeKind | Enum: What of its cell a tile of a slice fills: all of it, what of its art shows, or shapes drawn on it. |
| TimeSettings | Class: A game's clock: settings/time.json beside the game's assets, which Project Settings' Time page lays out — how often its fixed systems run, how far one frame may move the game's time on, and how fast that time runs. |
| TooltipAttribute | Class: What the inspector says about a field when the pointer rests on its name. |
| Transform | Struct: An entity's position, rotation and scale relative to its parent. |
| Trash | Class: The platform's trash: the Recycle Bin on Windows, the Trash elsewhere. |
| UiCanvasLaid | Record struct: How an element of a UI document open on its own is laid out on its canvas, in the document's own pixels. |
| UiDirection | Enum: A direction focus moves in between a document's elements. |
| UiDocumentCode | Record: What the build writes of a UI document's class; see UiDocumentFiles.CodeOf. |
| UiDocumentDraft | Class: A UI document opened to be edited: built from its file into a draft scene, which an editor lists and edits as it does a scene's entities, and written back to its file from there. |
| UiDocumentFiles | Class: A UI document's file: .ui, in the format scenes and prefabs are written in, its elements the entities in it and their components Bevy's own UI's — Node, Text, Button — and, beside them, the name of the class the build makes of it. |
| UiElement | Class: An element of a shown UI document: the entity its document's element became, found by the identity the document gave it. |
| UiElementClasses | Record: An element of a document and its classes, as its Inspector lists them. |
| UiElementNavigation | Record: An element of a document that can have focus, and how focus comes to it and goes from it, as its Inspector lists them. |
| UiEventKind | Enum: What an element of a shown UI document did. |
| UiMatch | Record: A rule of a document's sheets applying to elements drawn on the canvas. |
| UiNamed | Record: What a selector can name an element by, as bevy_flair styles it. |
| UiRule | Record: A field of an element a stylesheet's rule sets, and the rule. |
| UiSettings | Class: A game's interface as a whole: settings/ui.json beside the game's assets, which Project Settings' UI page lays out — the theme every document is styled by, and the screen its documents are laid out for. |
| UiSheetReference | Record: A stylesheet a document names: by its path under the asset root, and its identity where it is known. |
| UiStates | Enum: The states an element of a UI document can be held in on its canvas, as a browser's tools hold one, so what its sheets say for each is seen: a bit each, as the engine numbers them. |
| UiTextHandler | Struct: What UiElement.SetText is given in place of a string: an interpolated string's pieces, written into a buffer it borrows as the compiler hands them over. |
| UiView | Class: A UI document's class, which the build writes half of from the document: its elements by name, and a partial void for each thing each can do that the game's half fills in where it wants to hear it — partial void OnNewGameClicked() => StartGame();. |
| UpdateDone | Record: What changing a package to another version did. |
| UpdateFile | Record: One file a package's update would change, by its path in the package, with forward slashes. |
| UpdateKind | Enum: What another version of a package does to one file of a game's copy of it. |
| WebPage | Enum: The page a game built for the web plays on: one of the engine's, or its own. |
| WindowFlags | Enum: How a window beside the primary behaves. |
| WindowHandleKind | Enum: Which platform's window handle World.WindowHandle returned. |
| WindowId | Record struct: One of the engine's windows: the primary one, or one opened beside it. |
| WindowSetup | Record: The engine's window. |
| WindowState | Struct: A window's client area on the desktop, in physical pixels, and what it is doing. |
| WindowStateAttribute | Class: Marks a struct as an editor window's state (Schedule.EditorWindow): its fields drawn with the Inspector's rows by EditorUi.Fields, and kept by the editor for each person, in the project's cache, from one start to the next. |
| WindowStateFlags | Enum: What a window is doing. |
| WindowsDetails | Record: What a built game's Windows executable says of itself — in Explorer's Details tab and its Properties — as its version information holds it. |
| WindowsIcon | Class: A game's icon at the sizes an executable carries it, made by the engine. |
| WindowsResources | Class: The resources a built game's Windows executable carries — its version information and its icon — as a compiled resource file, .res, which the linker takes as it takes an object. |
| World | Class: A Bevy ECS world that C# gameplay code can operate on directly. |
| WorldAudio | Struct: Sound, as a game plays it from its code: a clip played as a 2D sound, at a place in the world, or on an entity, and each sound asked to stop, pause, resume or change. |
| WorldCameras | Struct: Cameras, as a game moves them from its code beyond what their components say: shaken for a hit or a boss's slam. |
| WorldLights2D | Struct: 2D lights, as a game asks them: how lit a point is by its Global Light 2Ds and the Point Light 2Ds that reach it, through the shadows they are drawn with — what hides a character in darkness and shows it in light. |
| WorldLines | Struct: Lines, as a game drives them from its code: an entity's Line given its points, all at once or one by its place, and read. |
| WorldParticles | Struct: Particles, as a game plays them from its code: an entity's ParticleEmitter played, stopped and asked to emit, and asked how it is. |
| WorldSetup | Record: What a world has from the moment it is made: a window, assets, a renderer. |
| WorldSnapshot | Class: What a world's entities held at one moment, to be put back onto the same entities. |
| WorldTilemaps | Struct: Tilemaps, as a game drives them from its code: an entity's Tilemap given its tiles by where they are, one or many at once, read, cleared, and given its tile set. |
| WorldTrails | Struct: Trails, as a game drives them from its code: an entity's Trail turned on and off, what it has left cleared, points added to it, and read. |
| YoursKind | Enum: What a game's copy has done to a file the version changes, where it has done anything. |