Scripting API

Scripting API

Scripting API

The public types of the engine and of its official packages, a page each, made from their code and its documentation.

Abyss.Core

TypeWhat it is
AbyssComponentAttributeClass: Marks a plain-data struct as a component the engine should be able to describe.
AbyssListAttributeClass: 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.
AbyssPackageAttributeClass: 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.
AbyssPluginAttributeClass: 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.
AbyssSystemAttributeClass: Marks a static method as a system, so its access can be derived from its signature instead of declared a second time by hand.
ActionNameRecord 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.
ActionStateEnum: How an action — a clip played from code — is getting on, or how it ended.
ActionTypeEnum: What an input action's value is.
AddOnRecord: 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.
AddOnDownloadClass: 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.
AddOnDownloadStateEnum: What a download of an add-on is doing.
AddOnListClass: 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.
AddOnSettingsClass: 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.
AddableComponentRecord 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.
AddressableSettingsClass: A game's groups of addressable assets, each built into a pack of its own: settings/addressables.json.
AffineRecord 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.
AlphaKindEnum: Which of Bevy's transparency rules a surface is drawn under.
AmbientLightingRecord struct: The light a camera sees everything by, from no way in particular: what keeps a shadow from being black.
AnimationActionRecord 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.
AnimationClipDocumentClass: What a clip file says, to read and change; see AnimationClipFiles.
AnimationClipFilesClass: 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.
AnimationEventAttributeClass: 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.
AnimationEventTypeRecord: An animation event's struct, described for an editor to place and fill in.
AnimatorStateRecord: What an animator plays: each clip, the one last played first.
ArchetypeRecord struct: A registered set of component types that entities can be created with, given, or stripped of.
ArgumentKindEnum: What kind of value a string's argument holds, which says how it is written.
AssetAccessStruct: What a running system can do with the world's assets: load, make, copy, change and let go of them.
AssetAddressClass: 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.
AssetCatalogClass: 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.
AssetDatabaseClass: What every file under the asset root is called, and what it is.
AssetGuidStruct: A file's identity, which outlives where the file happens to sit.
AssetKeyClass: 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.
AssetSetupRecord: Where a world's assets are read from.
AssetStateEnum: How far along an asset's load is.
AssetsClass: Values shared by every kind of asset id.
AudioAddressClass: A sound's key, which AssetAccess.LoadAudioClip takes.
AudioBusRecord: One bus of a game's mix, as settings/audio.json holds it.
AudioClipIdRecord struct: The id of a sound clip the engine loaded.
AudioCodecEnum: What a clip's file is encoded as, as the inspector names it.
AudioCompressionEnum: How a sound clip is encoded as it is imported: what its import settings call its Compression Format.
AudioEncodingRecord 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.
AudioImportRecord: 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.
AudioImporterClass: 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.
AudioLoadTypeEnum: How a clip is kept once it is loaded: what its import settings call its Load Type.
AudioMixClass: A game's mix: its buses, as the Audio tab lays them out — settings/audio.json beside the game's assets.
AudioPeaksRecord: A clip's waveform: what its file holds, and for each channel each column's lowest and highest sample, from −1 to 1.
AudioSettingsRecord struct: What a clip's import settings say of it as it is played.
AudioShapeRecord struct: What a clip's file holds: how many frames, at what rate, of how many channels, encoded how.
BakeLandedRecord: What baking a model made: its import, and what each baker made of it.
BakeWantedRecord: 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.
BakedByRecord: What one baker made of a model.
BakedModelClass: 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.
BakerInfoRecord: A baker, as the editor knows it; see Schedule.BakeInEditor.
BindClass: Bindings made in code: map.Add("Jump", ActionType.Button, Bind.Key(Key.Space), Bind.Button(GamepadButton.South)).
BindingSourceRecord struct: One thing on a device that a binding reads, named as settings/input.json names it.
BlendPointClass: One of a blend space's clips, and where it is placed.
BlendSpaceClass: The clips a state mixes by where one field or two fall among the places they are given.
BloomCompositeEnum: How a bloom's glow is put on the picture.
BoneMaskClass: The bones a layer moves, by their names, as ticked on a model's tree of them.
BuildOptimizationEnum: 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.
BuildSceneRecord: A scene in a build: the file, by its path under the assets and its identity, and whether it goes in.
BuildSettingsClass: 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.
BusEffectRecord: One effect on a bus of the mix: its kind, whether it is on, and its settings in its kind's order.
BusEffectFieldRecord: One setting of a kind of bus effect, as the engine describes it.
BusEffectKindEnum: A kind of effect a bus of the mix runs, by the engine's number for it.
BusEffectTypeRecord: A kind of bus effect, its names and its settings, as the engine describes it.
BusEffectValueEnum: A setting of a bus's effect, by the engine's number for it: what a game's code changes with WorldAudio.SetBusEffect.
BusEffectsClass: 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.
BusLevelRecord struct: How loud a bus of the mix has been since it was last asked: what the Audio tab's meters show.
CameraBloomRecord struct: A camera's bloom: what is bright spreads a glow round it, as light does in an eye or a lens.
CameraDepthOfFieldRecord 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.
CameraFogRecord 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.
CameraSkyRecord 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.
CatalogEntryRecord: One asset a catalog lists: where it is, who it is, and what it is loaded by if it is addressable.
ChildrenColumnStruct: A chunk's column of Children: each row's, as a ChildrenView.
ChildrenViewStruct: 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.
ChoiceVariantRecord: One variant of a ComponentChoice, and the value choosing it gives.
ChunkStruct: One contiguous block of entities, exposing each queried component as a span over Bevy's own storage.
ChunkCollectionStruct: The chunks a ChunkCollection.Query resolved to.
ChunkCollection.EnumeratorStruct: Allocation-free enumerator over ChunkCollection.
ClipAddressClass: A clip's key, a model's or a clip file's, which AssetAccess.LoadClip takes.
ClipCurveRecord: 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.
ClipEventRecord: One event on a clip, as its model's import settings wrote it.
ClipEventFieldsClass: 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.
ClipFrameRecord struct: One frame of a clip file: the image a sprite shows from a time on, and the slice of it.
ClipIdRecord struct: The id of a model's clip the engine loaded.
ClipMarkerRecord struct: One sync marker on a clip: a moment named for what happens there — LeftDown, where the left foot lands.
ClipSettingsRecord: 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.
ColorUsageAttributeClass: Shows a Vector4 or Vector3 field as a color: a swatch that opens the editor's picker, rather than its numbers.
CommandBufferClass: Records entity creation and removal for the engine to apply at the end of the frame.
CommandOutcomeRecord struct: What applying a command buffer did.
CompiledShaderRecord struct: What one variant of a shader compiled to.
CompiledVariantRecord: One compiled variant of a shader, as the world is given it.
ComponentBatchStruct: A pending change to entities that already exist, whose new component values are written through spans.
ComponentChoiceRecord: One enum a component holds, which no layout can describe: where it is, and what it can be.
ComponentFieldRecord struct: One field of a component, at the offset the engine reported rather than one C# assumed.
ComponentFieldSpecRecord struct: One field of a component C# declares, on its way to the engine.
ComponentGivenRecord: What a load would give one component by itself, as Given answers it.
ComponentIdRecord struct: An untyped component id, as the native core knows it.
ComponentLayoutClass: 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.
ComponentMoveClass: What moving a component's values onto another did; see World.MoveComponent.
ComponentTraitsEnum: 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.
CompositePartRecord struct: One part of a composite binding: up of four keys, negative of two.
ConditionFieldRecord struct: A field a condition can read.
ConditionMistakeRecord: A mistake in a condition, as the world finds it: what is wrong, and where, in characters into the text.
ControllerDocumentClass: What a controller file says, to read, change and write back.
ControllerFilesClass: 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.
ControllerLayerClass: One layer of a controller.
ControllerStateClass: One state of a layer.
CursorShapeEnum: The shapes the pointer can take over a window.
CurveKeyRecord 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.
DataAssetAttributeClass: 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.
DataAssetBinaryClass: 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.
DataAssetFileClass: 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.
DataAssetTypeRecord: A kind of data asset declared in code, described for an editor to make and show; see World.DataAssetTypes.
DateLengthEnum: How long a date is written: what FormatDate and a string's {day:date long} ask for.
DecibelsClass: 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.
DepthOfFieldModeEnum: How a depth of field blurs what is out of focus.
DisplayMonitorStruct: One display, in the desktop's physical pixels.
DrawnVariantRecord: One variant drawing asked a shader for.
DurationStyleEnum: 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.
EditorIconEnum: A picture beside a row of an editor window (EditorUi.Row), drawn as the editor's own.
EditorMenuItemRecord: 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.
EditorMenuPlaceEnum: Which of the editor's menus a plugin's item goes in; see ToolsMenu.
EditorOnlyAttributeClass: Marks a plugin that is the editor's alone: built and run by the editor, and never by the game on its own.
EditorSelectionClass: The entities the editor has picked, for a game's systems to draw more for; empty in a game on its own.
EditorUiClass: 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.
EditorWindowDrawDelegate: 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.
EditorWindowItemRecord: 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.
EngineAboutRecord: What the editor's Help ▸ About says of the engine a world runs; see World.About.
EngineSystemsClass: The systems the engine declares itself, by the name they are registered under.
EngineVersionClass: The engine's version: one number for its C# and its Rust.
EntityKindEnum: What sort of entity a EntityRow describes.
EntityRefRecord struct: An entity a component names: a joint's Connected Body, a door's switch, what a follower follows.
EntityRowStruct: One entity, as a list of them crosses from the engine.
EntityVisibilityEnum: Whether an entity is drawn, as Bevy's Visibility on it says; see World.SetVisibility.
ExecuteAlwaysAttributeClass: Marks a plugin that runs while its game is edited, as well as while it plays.
FadeCurveEnum: How a fade goes from one state to the next.
FadeRuleClass: A fade a layer gives one change of state rather than its own.
FieldAssetEnum: What kind of asset a reference field names; see FieldHint.Asset.
FieldChoiceRecord struct: One value of an enum a field holds: its name as the enum declares it, and its number.
FieldColorRecord 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.
FieldHintRecord: 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.
FieldKindEnum: What kind of value a component field holds.
FieldKindsClass: Sizes for FieldKind.
FieldRangeRecord struct: The two ends of a slider.
FieldValueStruct: 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.
FileDropRecord struct: A file dragged over a window or dropped on it, as World.ReadFileDrops reports it.
FileDropKindEnum: What a file dragged in from the desktop is doing.
FileKindAttributeClass: 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.
FileRefStruct: 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.
FiredClipEventRecord struct: One event a clip fired on an animator, before its struct is made of its fields.
FixedList128Class: 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.
FixedList16Class: 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.
FixedList32Class: 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.
FixedList64Class: 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.
FixedList8Class: 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.
FixedText128Struct: 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.
FixedText256Struct: 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.
FixedText32Struct: 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.
FixedText64Struct: 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.
FlowClass: 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.
FogFalloffEnum: How a camera's fog thickens with distance.
FontFilesClass: A font's file: .ttf or .otf, TrueType or OpenType, as bevy_text reads it.
FormerlySerializedAsAttributeClass: 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.
FullscreenModeEnum: How a built game's window fills the screen.
GameApplicationClass: 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.
GameCodeClass: 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.
GameCursorClass: 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.
GameDisplayClass: 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.
GameInputRecord struct: What of the devices a game has; see World.SetGameInput.
GameModeEnum: Which of a game's systems run on a world's frames.
GamePackagesClass: A game's packages, removed: what uses one, and taking it out of the game.
GamePictureAreaRecord 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.
GameRandomClass: 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.
GameStartClass: 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.
GameTimeClass: 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.
GameUiClass: 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.
GamepadAxisEnum: One direction of a gamepad's stick, negative one to one, up and right positive.
GamepadButtonEnum: A gamepad's button, by where it is on the pad rather than what it is labeled.
GamepadKindEnum: Whose gamepad it is, which is what its buttons are labeled: A, Cross or B for the one at the bottom.
GamepadStickEnum: Both directions of a gamepad's stick at once.
GizmoSegmentStruct: One line a game's gizmos drew, as the editor's Scene panel draws it.
GizmosClass: 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#.
GlobalTransformStruct: Where an entity is in world space — as an affine matrix, which is not the same shape as Transform.
HandlePlacementStruct: 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.
HeardInputRecord struct: What World.ListenForInput heard first: a key, mouse button, gamepad button or stick's direction.
HeardKindEnum: What HeardInput heard.
HideInInspectorAttributeClass: Leaves a field out of the inspector's normal view.
IPluginInterface: A part of a game: what it adds to a schedule when the game plays.
IPreferencesInterface: A class marked PreferencesAttribute with a name: kept as a file of its own.
IPreferencesDataInterface: What the source generator gives a class marked PreferencesAttribute: how its members are written and read.
IStaticGeometry2DInterface: 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.
IStaticGeometry3DInterface: 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.
ISystemTimingsInterface: 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.
ImageAddressClass: An image's key, which AssetAccess.LoadImage takes.
ImageColorEnum: What the numbers in an image made from pixels are.
ImageIdRecord struct: The id of an image the engine loaded or made.
ImagePixelsRecord: An image's pixels: its first level, four bytes a texel, row by row from the top left.
ImageRegionRecord struct: A rectangle of an image, in its pixels from its top-left: what UiElement.SetImage draws of it.
ImageSamplingRecord 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 }.
ImportAxesEnum: What to do about the axes a model file was authored in.
ImportColorEnum: What the numbers in an image file mean.
ImportCompressionEnum: Whether an imported texture is block-compressed, and how well.
ImportFilterEnum: How a texture is sampled when a pixel covers more or fewer than one texel.
ImportIndexFormatEnum: How big each number of an imported mesh's index buffer is: its Index Format.
ImportMipFilterEnum: How each mipmap is made from the one above it.
ImportMipmapsEnum: Whether an imported texture has a mipmap chain.
ImportNormalsEnum: Where an imported mesh's normals come from: its Normals.
ImportSettingsRecord struct: How one file should be read, as sixteen numbers.
ImportTangentsEnum: Where an imported mesh's tangents come from: its Tangents.
ImportTextureTypeEnum: What a texture is for, which decides how its numbers are read and what it is imported as.
ImportWrapEnum: What a texture does outside its own edges.
ImportedAudioRecord 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.
ImportedFormatEnum: What the GPU is given of an imported texture.
ImportedMeshRecord: One mesh of an imported model, as its file's tables describe it.
ImportedModelRecord struct: What an import of a model made: how many meshes, vertices and triangles, the bytes they take, and the textures it carries.
ImportedTextureRecord struct: What an import made: its size, its mipmaps, its format and what it takes on the GPU.
InputActionClass: One action of a game's: what its code asks about — whether Jump was pressed, which way Move points.
InputActionStateStruct: One action of one player's this frame, as the engine works it out from every device.
InputActionsClass: 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.
InputBindingRecord: One way of driving an action, and what is done to its value; see Bind for making one.
InputDeviceRecord struct: The device a player last used.
InputDeviceKindEnum: Which kind of device a player last used; see PlayerInput.LastDevice.
InputMapClass: A map of actions, which a player has on or off as a whole: a game's, a menu's.
InputNamesClass: 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.
InputStateStruct: Everything the engine knows about the keyboard and mouse this frame.
InstalledPackageRecord: A package a game has: its folder, and what its manifest says.
JSExceptionClass: What the page threw at a JSImportAttribute method's call, or why it could not be called, as the page said it.
JSExportAttributeClass: 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.
JSImportAttributeClass: 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).
JSStandInAttributeClass: 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.
KeyEnum: A key, as AbyssEngine names it.
KeyEaseEnum: How a clip's curve goes on from a key to the next.
KeyEasesClass: Names a KeyEase as a clip file writes it after a key's time and value.
KeyEventStruct: One key going down or coming up, as World.ReadKeys reports it.
LabelNameClass: 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.
LanguageRecord 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.
LayerBlendingEnum: How a layer above the first is laid over the layers under it.
LayerMaskRecord struct: Some of a project's 32 layers, a bit each: what a camera draws, and what physics and rays will meet.
LayerMatrixStruct: 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.
LayerRunRecord: One layer of an animator, as its controller runs it.
LayerSettingsClass: A project's 32 layers by name: settings/layers.json beside the game's assets, which Project Settings' Tags and Layers page lays out.
LeavingEnum: When a state may be left.
LengthUnitEnum: The unit a curve writing a length of Bevy's UI writes it in: pixels unless it says otherwise, named as CSS names them.
LengthUnitsClass: Names a LengthUnit as a clip file writes it.
LensRecord 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.
LightKindEnum: 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.
ListLayoutRecord: 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.
ListedPackageRecord: One package a game's list names: its id, the version the game has, and where it came from.
LocalizationClass: A game's languages and strings, and the language the player uses: world.Localization.
LocalizationSettingsClass: 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.
LocalizedArgumentStruct: 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.
LocalizedAssetClass: 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.
LocalizedFileRecord struct: A file a localized asset names: by its path, and by its identity, which finds it where it has moved.
LocalizedKindEnum: What a localized asset is: the kind of file its default and each language's file are.
LocalizedStringStruct: A string of the game's a component names: an entry of a string table, said in the player's language by Localization.Text.
LogClass: The engine's log: what Bevy, the libraries under it, the editor and a game have said.
LogEntryRecord: One thing that was said.
LogReaderClass: Walks the engine's log from a place of its own, reading what has been said since.
LogSeverityEnum: How serious a message is.
MapNameRecord struct: An input map as code names it: Actions.Maps.UI, which the build writes; its name; or the InputMap itself.
MarkerKindEnum: What a SceneMarker marks.
MarkerProjectionEnum: How a camera a SceneMarker marks projects.
MarkerShapeEnum: 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.
MaterialAddressClass: A material's key, which AssetAccess.LoadMaterial takes.
MaterialFieldRecord struct: One editable number in a MaterialSpec, at the offset the compiler chose.
MaterialFilesClass: 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.
MaterialIdRecord struct: The id of a material the engine created.
MaterialRemapClass: 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.
MaterialSlotNameRecord: 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.
MaterialSpecStruct: How a surface should look, in the part of PBR the engine can write down.
MeshAddressClass: 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.
MeshBakerDelegate: 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.
MeshDataStruct: The vertex data of a mesh, as spans over the caller's own memory.
MeshGeometryRecord: A mesh's corners and the triangles between them, as the engine holds the mesh: what a collider of it is made of.
MeshIdRecord struct: The id of a mesh the engine created, which is what a caller holds instead of a handle.
MeshPartNameRecord: 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.
MissingStringsEnum: What a string none of the languages it is looked for in has shows, and where it is looked for.
ModelImporterClass: 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.
MouseButtonsEnum: A mouse button.
MouseInputEnum: What of the mouse a binding reads.
NameColumnStruct: A chunk's column of Name: each row's, as a NameView.
NameViewStruct: 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.
NativeBodyRecord struct: A body of engine work written in Rust, which a Schedule can run as a system alongside C# ones.
NoiseRecord 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.
NoiseFractalEnum: How a Noise's layers are summed.
NoiseKindEnum: 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.
NumberDigitsEnum: Which digits a game writes its numbers in.
OutlineEdgeStruct: One edge of an outline, on the screen.
PackClass: 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.
PackAccessStruct: 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.
PackEntryKindEnum: What an entry of a pack holds.
PackIdRecord struct: A pack a game attached with PackAccess.Attach, by its whole path: what takes it away again.
PackStampRecord struct: Whose a pack is: the game a build made it for, and the pack's own identity, new each time it is built.
PackWriterClass: Writes a pack an entry at a time; nothing is a pack until PackWriter.Finish.
PackWrittenRecord: What writing a pack made.
PackageArchiveClass: 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.
PackageAuthorRecord: Who made a package.
PackageBumpEnum: Which part of a version PackageVersion.Next raises.
PackageChangesRecord: What a game's copy of a package has that its original has not, by path in the package, with forward slashes.
PackageFilesClass: A package's files, compared: what a game's copy of one has changed of its original.
PackageHeldExceptionClass: 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.
PackageIgnoreClass: 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.
PackageInArchiveRecord: What an archive of a package says it is: its manifest, and the hashes of the files it holds.
PackageListClass: The packages a game has, as settings/packages.json lists them: the version of each and where it came from.
PackageManifestClass: 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.
PackageNativeSourceRecord: What a package's native libraries are built from, as the notices beside a built game name it.
PackagePathClass: 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.
PackageRegistryClass: 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.
PackageSourceEnum: Where a game's package came from, as its list keeps it (PackageList).
PackageUpdateRecord: 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.
PackageUsersRecord: What in a game uses one of its packages, as removing it lists them.
PackageVersionRecord 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.
PaintBatchRecord struct: A run of indices drawn with one texture, clipped to one rectangle.
PaintVertexRecord struct: One vertex of a painted frame: where it is, what part of a texture it takes, and what color.
PaintingClass: Constants shared by everything that paints.
ParallelChunkBodyDelegate: What SystemContext.ForEachChunkParallel runs for each slice of the system's chunks: a part of one chunk, on whichever thread took it.
ParticleStruct: One particle as code reads it, in the world; see Read.
ParticleCastStruct: One particle's move this frame, in the world, as a provider of particle colliders is asked about it; see RegisterColliders.
ParticleColliderProviderRecord 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.
ParticleHitStruct: What a provider of particle colliders says a particle met first along its move; see RegisterColliders.
ParticlePreviewStateRecord struct: How what the editor plays while the game is edited was as of the last frame; see Preview.
ParticleStateRecord struct: How a Particle Emitter was as of the last frame.
ParticleSubEmitterRecord struct: A sub-emitter of an emitter's: the entity it is on, and what fires it; see WorldParticles.SubEmitters.
PlacedRecord struct: A transform to give an entity, as the editor's handles ask for one.
PlacedSpriteEnum: What a picked entity's sprite is, as the Rect tool stretches it.
PlacedTileRecord struct: A tile and the cell it goes in: how many tiles along X and up Y from its Tilemap's origin.
PlacementRecord struct: Where an entity is in the hierarchy: under which parent, and before which sibling.
PlayOptionsRecord 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.
PlayerClass: 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.
PlayerInputClass: One player's input actions, asked about each frame: context.Input.Pressed(Actions.Player.Jump), context.Input.Vector("Move").
PlayerSettingsClass: What a built game is, to a player and to the platform: Player in Project Settings — settings/player.json beside the game's assets.
PlayerStartRecord: Where a game plays from, and what its build says of it: what Plan works out.
PlayingClipRecord struct: One clip an animator plays, as World.AnimatorOf says it.
PluralCategoryEnum: The forms a string can have for a number, as Unicode CLDR names them; PluralCategory.Other is every language's.
PrefabAddressClass: A prefab's or a model's key, which AssetAccess.LoadPrefab takes.
PrefabIdRecord 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.
PrefabRefStruct: 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.
PreferencesClass: 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.
PreferencesAttributeClass: 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.
PreviewChannelEnum: Which of an imported texture's channels a preview shows.
ProfilePartEnum: Which of a profile's parts a name is asked of.
ProfileStagesStruct: How long each of a frame's main schedules took; see ProfiledFrame.StagesNs.
ProfiledFrameStruct: 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.
ProfiledRenderStruct: 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.
ProjectAgeEnum: How a project's stamp compares with the editor opening it.
ProjectSettingsAttributeClass: 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.
ProjectSettingsFileClass: 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": ...}.
ProjectStampRecord: 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.
QueryClass: A prepared query over a fixed set of components.
QueryFilterStruct: A presence constraint that narrows which entities a query matches, without producing a column.
QueryTermStruct: One component a query touches, and how.
RangeAttributeClass: Shows a number field as a slider between two values, and keeps what is typed into it between them.
Ray3DRecord struct: A ray in a 3D world: where it starts, and the way it goes, a unit long.
RayHitStruct: 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.
RebindOptionsRecord: What GameCode.Rebind listens for.
RebindResultRecord: What PlayerInput.Rebind did.
RebindingRecord struct: A player's own binding, in place of the game's: what PlayerInput.Rebind puts there.
RecordingQualityEnum: How good a recorded video's pictures are: how many bits a second they take.
RecordingStateEnum: Whether a video is being recorded.
RegisteredPackageRecord: A package the registry has, every version of it, oldest first.
RegisteredVersionRecord: A version of a package the registry has: its archive, and what its manifest says.
RelativeStyleEnum: How long a relative time is written: what FormatRelative and a string's {seen:relative} and {seen:relative-short} ask for.
RemappedMaterialRecord struct: A material file one of a model's own materials is drawn as instead.
RenderPartsStruct: How long each part of a drawing took; see ProfiledRender.PartsNs.
RenderSetupRecord: 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.
ResourceIdRecord struct: An untyped resource id, as the native core knows it.
ResourceTermStruct: One resource a system reads or writes.
ResourceType<T>Struct: A resource type registered with a World — singleton data with no entity attached.
RolloffEnum: How a 3D sound's volume falls with its distance from the listener.
RustCratesClass: 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.
SceneAccessStruct: The world's scenes, to load and unload while a system runs: SystemContext.Scenes.
SceneAddressClass: A scene's key, which SceneAccess.Load takes.
SceneBoneStruct: 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.
SceneDrawEnum: How the editor's Scene panel draws the scene.
SceneEditRecord struct: One thing a person did to a component's handles in the Scene view, for its plugin to make of it.
SceneEditHandlesClass: 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.
SceneEditKindEnum: What a person did to a component's handles in the Scene view.
SceneEditableRecord 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.
SceneIdRecord struct: A scene: the entity that stands for everything one load built, or one script made.
SceneLightRecord 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.
SceneMarkerStruct: One light or camera, as the editor's Scene panel marks it: where it is, which way it faces, and what it is.
SceneModeEnum: What a scene loaded while a game plays does to the scenes there are already.
ScenePaceEnum: 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.
SceneProjectionRecord 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).
SceneStateEnum: Where a scene is in being loaded and unloaded.
ScheduleClass: An ordered set of systems that the engine can run, sequentially or in parallel.
ScreenOrientationEnum: Which way a game on a phone or a tablet is held.
ScrollUnitEnum: How far one unit of scroll goes.
SerializeAllFieldsAttributeClass: Says that a scene writes every field of this component, even one that holds what a load would give it anyway.
ServicesClass: 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.
SettingsImageRecord: An image a setting names: by its path under the assets and by its identity, which finds it where it has been moved.
SettingsTypeRecord: A project's settings declared in code, described for an editor to show and a file to keep.
ShaderAddressClass: 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.
ShaderCompilerClass: 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.
ShaderFilesClass: 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.
ShaderIdRecord struct: The id of a shader read out of a game's shaders folder.
ShaderKindEnum: What a shader draws: a mesh's surface, or a UI element.
ShaderKindsClass: What a shader's text says it draws, read as the engine reads it.
ShaderLayoutRecord: What a shader takes: its values, and the names of its textures.
ShaderTargetEnum: What a game's shaders are compiled for.
ShaderValueRecord: One value a shader takes, as its WGSL declares it.
SharedTextRecord 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.
SheetDeclarationRecord: A declaration of a stylesheet's rule.
SheetRuleRecord: A rule of a stylesheet, as the Style Sheets panel lists it.
SheetRuleKindEnum: What a rule of a stylesheet is.
SimulatedGamepadClass: 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.
SnapshotRestoreRecord: What putting a WorldSnapshot back did.
SortAxisEnum: What decides between two sprites of one sorting layer and one order.
SortingLayerRecord: One sorting layer of a game's, as settings/sorting.json holds it.
SortingLayersClass: 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.
SoundRecord 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.
SoundStateEnum: How far along a sound is.
SourceKindEnum: Which device a BindingSource is on, and what of it.
SourcePictureRecord: A source image as it is, for the Sprite Editor to draw it and cut it in its own pixels.
SpawnBatchStruct: A pending batch of new entities, whose initial component values are written through spans.
SpriteModeEnum: 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.
SpriteSheetRecord: 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.
SpriteSliceRecord 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.
StateRunRecord struct: One state of an animator's layer, as it runs it.
StringEntryClass: 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.
StringKeyRecord 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.
StringTableClass: 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.
StructuralAccessStruct: What a system is allowed to change about the shape of the world.
StylePropertyRecord: A property a stylesheet's rule can set.
StylePropertyKindEnum: How a property a stylesheet's rule sets is edited: what its value is.
StyleSheetFilesClass: A stylesheet's file: .css, CSS as a web page's is, read by bevy_flair.
StyleSheetTextClass: 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.
StyleValueRecord: A property a stylesheet's rule sets, and what to.
SubEmitterTriggerEnum: What a parent's particle does that fires a sub-emitter.
SystemBodyDelegate: The body of a system.
SystemClipboardClass: 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.
SystemConflictClass: A pair of systems that cannot be in flight at the same time.
SystemContextStruct: What a system body receives when it runs.
SystemErrorHandlerDelegate: Called when a system fails.
SystemFailureClass: A system that threw while the schedule was running it.
SystemIdRecord struct: Identifies a system registered with a World.
SystemTimingRecord struct: A system's run, as a profiler is told it; see ISystemTimings.
TakenEntitiesRecord struct: What World.TakeEntities took: where the entity was, and how many went with it.
TakenReportRecord: What World.TakeEntities keeps under one token.
TextImportRecord: 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.
TextImportAsEnum: What a text file is imported as: nothing a game reads, or the license of what it is beside.
TextureImporterClass: 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.
TexturePreviewRecord: One mipmap of an imported texture, as a preview shows it: four bytes a pixel, opaque.
TileRecord 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.
TileCollisionEnum: 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.
TileOutlineRecord: 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.
TileShapeRecord: 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.
TileShapeKindEnum: What of its cell a tile of a slice fills: all of it, what of its art shows, or shapes drawn on it.
TimeSettingsClass: 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.
TooltipAttributeClass: What the inspector says about a field when the pointer rests on its name.
TransformStruct: An entity's position, rotation and scale relative to its parent.
TrashClass: The platform's trash: the Recycle Bin on Windows, the Trash elsewhere.
UiCanvasLaidRecord struct: How an element of a UI document open on its own is laid out on its canvas, in the document's own pixels.
UiDirectionEnum: A direction focus moves in between a document's elements.
UiDocumentCodeRecord: What the build writes of a UI document's class; see UiDocumentFiles.CodeOf.
UiDocumentDraftClass: 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.
UiDocumentFilesClass: 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.
UiElementClass: An element of a shown UI document: the entity its document's element became, found by the identity the document gave it.
UiElementClassesRecord: An element of a document and its classes, as its Inspector lists them.
UiElementNavigationRecord: An element of a document that can have focus, and how focus comes to it and goes from it, as its Inspector lists them.
UiEventKindEnum: What an element of a shown UI document did.
UiMatchRecord: A rule of a document's sheets applying to elements drawn on the canvas.
UiNamedRecord: What a selector can name an element by, as bevy_flair styles it.
UiRuleRecord: A field of an element a stylesheet's rule sets, and the rule.
UiSettingsClass: 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.
UiSheetReferenceRecord: A stylesheet a document names: by its path under the asset root, and its identity where it is known.
UiStatesEnum: 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.
UiTextHandlerStruct: 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.
UiViewClass: 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();.
UpdateDoneRecord: What changing a package to another version did.
UpdateFileRecord: One file a package's update would change, by its path in the package, with forward slashes.
UpdateKindEnum: What another version of a package does to one file of a game's copy of it.
WebPageEnum: The page a game built for the web plays on: one of the engine's, or its own.
WindowFlagsEnum: How a window beside the primary behaves.
WindowHandleKindEnum: Which platform's window handle World.WindowHandle returned.
WindowIdRecord struct: One of the engine's windows: the primary one, or one opened beside it.
WindowSetupRecord: The engine's window.
WindowStateStruct: A window's client area on the desktop, in physical pixels, and what it is doing.
WindowStateAttributeClass: 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.
WindowStateFlagsEnum: What a window is doing.
WindowsDetailsRecord: What a built game's Windows executable says of itself — in Explorer's Details tab and its Properties — as its version information holds it.
WindowsIconClass: A game's icon at the sizes an executable carries it, made by the engine.
WindowsResourcesClass: 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.
WorldClass: A Bevy ECS world that C# gameplay code can operate on directly.
WorldAudioStruct: 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.
WorldCamerasStruct: Cameras, as a game moves them from its code beyond what their components say: shaken for a hit or a boss's slam.
WorldLights2DStruct: 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.
WorldLinesStruct: 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.
WorldParticlesStruct: Particles, as a game plays them from its code: an entity's ParticleEmitter played, stopped and asked to emit, and asked how it is.
WorldSetupRecord: What a world has from the moment it is made: a window, assets, a renderer.
WorldSnapshotClass: What a world's entities held at one moment, to be put back onto the same entities.
WorldTilemapsStruct: 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.
WorldTrailsStruct: 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.
YoursKindEnum: What a game's copy has done to a file the version changes, where it has done anything.

Abyss.Core.Scenes

TypeWhat it is
BuiltPrefabsClass: The prefabs a world's instances were built from, as they were then: what tells a prefab that has changed since from one that has not, and what an instance's changes are read against.
ClipBonesClass: Which bone of a skeleton each bone a clip moves lands on, as the engine fits a clip to the skeleton of the animator playing it: by its path where the skeleton has it, else the bone whose path is the clip's with nodes at its top added or taken away, else the one bone of its name where the clip, too, moves only one of that name.
IPrefabSourceInterface: Where a prefab reference gets the document it names.
MadePrefabRecord: An entity made a prefab: what the prefab's file says, and where the entity was.
ModelClipRecord: One clip of a model, as its import lists it.
ModelDescriptionRecord: What an import says of a model besides its meshes — its nodes, materials and textures — read from the description the engine writes beside them; see ModelImporter.DescriptionOf.
ModelImagesClass: Where the images a model names in files of their own are in the project: where the model says they are, or, where it names a folder the project does not have, the image of its name in the folder nearest the model.
ModelMaterialRecord: One material of a model, as Bevy's own surface says it, its textures by index.
ModelMeshRecord: One mesh of a model: a primitive or several, each drawn with a material of its own.
ModelNodeRecord: One node of a model: an entity of its prefab.
ModelPrefabClass: A model's prefab: what an import says of its nodes, materials and textures, made into the document a prefab is, which the editor keeps beside the import (ModelImporter.PrefabOf) and PrefabFolder reads when a scene instances the model.
ModelPrimitiveRecord: One primitive: a mesh of the import, and what it is drawn with.
ModelSkinRecord: One skin of a model, as its import lists it.
ModelTextureRecord: One texture of a model.
OverrideKindEnum: What an instance did of its prefab, as a line of its Overrides list says it.
PrefabAppliedRecord: What applying a change of an instance to a prefab wrote; see SceneFile.ApplyTo.
PrefabDifferencesRecord: What of an entity a prefab supplied differs from what the prefab says; see SceneFile.Differences.
PrefabExpansionClass: Replacing every prefab instance in a document with the entities it stands for.
PrefabFolderClass: Prefabs read out of the project folder, found by identity first and by path second.
PrefabInstanceStruct: The mark on an entity that came from a prefab, saying which one.
PrefabMakingClass: An entity and everything under it written as a prefab: what dragging one from the hierarchy onto a folder makes.
PrefabOverrideRecord: One thing an instance did of its prefab: a line of its Overrides list, and what Revert and Apply are asked of.
PrefabPartStruct: The mark on an entity a prefab supplied inside an instance, saying which prefab: what tells it from one the scene added there.
PrefabRefreshClass: Brings a scene's instances up to date with prefabs that changed since they were built, keeping what the scene changed in each.
PrefabRefreshedRecord: What bringing a scene's instances up to date with their prefabs did.
PrefabRevertedRecord: What taking back one change of an instance did; see SceneFile.Revert.
PrefabSourceClass: Prefab sources that are not a folder.
PrefabStageClass: A prefab opened to be edited on its own, or a model's to be looked at: built from its file into a scene of its own while the scene that was open is set aside as a draft, written back to its file from there, and closed, the scene given back.
PrefabUnpackClass: An instance of a prefab made the scene's own entities: unpacked, each instance it held is left an instance of its own prefab; unpacked completely, nothing under it is one.
SceneAssetClass: Something the scene's entities refer to, under a key that is local to the file.
SceneAssetKindEnum: What kind of thing a SceneAsset is.
SceneCaptureRecord: What came of writing a world down.
SceneComponentClass: One component on an entity, and the values of the fields the engine describes.
SceneDocumentClass: A scene as it exists in a file: entities, what each one carries, and what they are drawn with.
SceneEntityClass: One entity, and everything about it a file can hold.
SceneEntityIdStruct: The name a scene file gave this entity, carried in the world so a later save writes it again.
SceneExpansionRecord: What an expansion produced: a document with no instances left in it.
SceneFieldRecord: One field of one component, with as many values as the field holds.
SceneFileClass: Turns a world into a SceneDocument and a document back into a world.
SceneFormatExceptionClass: A scene file that cannot be read as one.
SceneImageClass: A scene as a built game reads it: each set of components its entities carry a column at a time, in the bytes the engine keeps them in, with what cannot be bytes beside them.
SceneImageWrittenRecord: What writing a scene's image did.
SceneJsonClass: Reads and writes a SceneDocument as JSON.
SceneLoadRecord: What came of building a scene in a world.
SceneLoaderClass: Loads scenes into a world and unloads them while a game plays, a slice at a time, so that no frame pays for a whole scene.
SceneLocalizedRecord: The string of the game's a field names: its table and its entry, and what it is called.
SceneMaterialRecord: A surface, in the part of PBR that is numbers.
SceneOverrideClass: One thing a scene changed, or added, below the root of a prefab instance.
SceneReferenceRecord: The file a field names: what kind of asset it is, where it was, and who it is.
SceneWritingRecord: How a scene is written: what a project says of every scene it saves.
UiTemplateStruct: The mark on the top element of a UI template placed in another document's file, saying which document it is an instance of: what has the game make that document's class for it as the document it is in is shown (GameUi).
UnpackedRecord: What unpacking an instance took from its entities and gave them: what packs it again.

Abyss.Navigation

TypeWhat it is
NavAgentType3DStruct: A kind of agent a navmesh is baked for: how wide, how tall, the tallest step it walks up and the steepest slope it walks — what decides where it can go.
NavArea3DStruct: A kind of floor of the project's own, beside Walkable and Not Walkable: water, mud, a road.
NavMesh3DClass: A navmesh: the floors an agent walks, baked from a scene's triangles (Bake) and loaded from what the bake made (Load), asked for a path between two points, the closest point of it to one, or how far a straight walk gets.
NavMeshAgent2DStruct: Something that walks a navmesh in 2D while the game plays: sent to NavMeshAgent2D.Destination, or after NavMeshAgent2D.Target, it walks there around walls, obstacles and other agents at its NavMeshAgent2D.Speed, moving its entity along X and Y.
NavMeshAgent3DStruct: Something that walks the navmesh of its agent type to where it is sent — NavMeshAgent3D.Destination, or NavMeshAgent3D.Target's entity wherever that goes — along a path around what is in its way, steering around the other agents and the obstacles that move.
NavMeshAvoidance2DEnum: How well a NavMeshAgent2D steers around other agents and moving obstacles: better costs more.
NavMeshAvoidance3DEnum: How well a NavMeshAgent3D steers around the others as it walks.
NavMeshBake3DStruct: How a navmesh is baked: the agent it is for — how wide, how tall, the step it climbs and the slope it walks — and how finely the scene is sampled, which is worked out from the agent where it is not said.
NavMeshBakeLink3DRecord struct: A way across that a navmesh is baked with, a link: from Start to End, in world space, a gap to jump or a ledge to drop off, which a path crosses as it would a floor of its Area.
NavMeshBakeVolume3DRecord struct: A box a navmesh is baked with that makes the floor within it an area: Size across, about Center, turned by Rotation, in world space.
NavMeshCollect2DEnum: Which entities a NavMeshSurface2D is baked from.
NavMeshCollect3DEnum: Which entities a NavMeshSurface3D is baked from.
NavMeshFileClass: A baked navmesh as its file keeps it, .abynav: what a NavMeshSurface3D's NavMeshSurface3D.Baked names, which a game reads as the surface appears.
NavMeshGeometry3DEnum: What a NavMeshSurface3D is baked from.
NavMeshLink2DStruct: A way across what the navmesh cannot walk, in 2D: a gap to jump, a hole to climb through, a door the game opens.
NavMeshLink3DStruct: A way across what the navmesh cannot walk: a gap to jump, a ledge to drop off, a ladder.
NavMeshModifier3DStruct: Changes how a navmesh is baked from its entity's meshes and colliders, and from those under it: gives their floor an NavMeshModifier3D.Area — a road, a pond — or leaves them out of the bake, neither floor nor wall.
NavMeshModifierVolume3DStruct: A box that makes the floor within it an area as a navmesh is baked: a pond painted on one big terrain's mesh, a strip of mud, a spot no agent goes.
NavMeshObstacle2DStruct: Something NavMeshAgent2Ds go around while the game plays, in 2D: a cart pushed into a doorway, a gate that closes.
NavMeshObstacle3DStruct: Something agents go around while the game plays: a crate pushed into a doorway, a door that closes, a car that parks.
NavMeshObstacleShape2DEnum: The shape of a NavMeshObstacle2D.
NavMeshObstacleShape3DEnum: The shape of a NavMeshObstacle3D.
NavMeshSurface2DStruct: Where agents of one type walk in a game seen from above, in 2D: a navmesh baked from the Tilemaps under it, or of its whole scene, for the agent type it names; the bake kept in a file beside its scene (NavMeshSurface2D.Baked), which the game loads as the surface appears.
NavMeshSurface3DStruct: Where agents of one type walk: a navmesh baked from the entities under it, or its whole scene — their meshes, their colliders or both — for the agent type it names; the bake kept in a file beside its scene (NavMeshSurface3D.Baked), which the game loads as the surface appears.
NavPath2DRecord: A path along a navmesh in 2D: the corners to walk, the start first and the end last.
NavPath3DRecord: A path along a navmesh: the corners to walk, the start first and the end last.
Navigation2DClass: The navmeshes a world's surfaces in 2D were baked as, loaded as each NavMeshSurface2D appears and let go of as it goes, and asked for a path, the closest point or a straight walk on the one of an agent type: world.Navigation2D().FindPath(from, to).
Navigation3DClass: The navmeshes a world's surfaces were baked as, loaded as each NavMeshSurface3D appears and let go of as it goes, and asked for a path, the closest point or a straight walk on the one of an agent type: world.Navigation3D().FindPath(from, to).
NavigationAgentsPluginClass: Walks a world's agents and stands its obstacles while the game plays (NavMeshAgent3D, NavMeshObstacle3D, and their 2D twins), never while it is edited; and lets go of them as the game stops, the navmeshes read again as they were baked, so what obstacles cut into them goes with them.
NavigationEditingClass: Navigation in the editor: a NavMeshSurface3D baked by Bake on its menu in the Inspector, or with every other by Window ▸ Navigation ▸ Navigation, which lists them; its Agent Type chosen by name, as Project Settings ▸ Navigation names them; and its navmesh drawn in the Scene, see-through blue with its edges, while it is picked or the window is open.
NavigationPluginClass: Keeps a world's navmeshes (Navigation3D, Navigation2D) as its surfaces are, while the game is edited and as it plays: a surface's bake loaded as it appears, and let go of as it goes.
NavigationSettingsStruct: The project's navigation, Project Settings ▸ Navigation: the kinds of agent its navmeshes are baked for, Humanoid first, and the kinds of floor, the project's own after Walkable and Not Walkable.
NavigationViewStruct: What the Navigation window keeps for whoever edits the game.
NavigationWorldClass: A world's navmeshes; see NavigationWorld.Navigation3D and NavigationWorld.Navigation2D.

Abyss.Physics2D

TypeWhat it is
BodyType2DEnum: How a body moves: Rigidbody2D.Type.
BoxCollider2DStruct: A box an entity meets things with: on its Rigidbody2D, or the nearest one above it, or ground where there is none.
CapsuleCollider2DStruct: A capsule an entity meets things with: a box with round ends, a character's.
CapsuleDirection2DEnum: Which way a capsule stands: CapsuleCollider2D.Direction.
CharacterController2DStruct: A character, moved as it is told rather than pushed about as a body is: the Rigidbody 2D on its entity, moved as a Kinematic one whatever its Type, and its Capsule Collider 2D the shape it moves as.
Characters2DEditingClass: A Character Controller 2D put on an entity in the editor brings what it moves with: a Rigidbody 2D, Kinematic and never turned, and a Capsule Collider 2D fitted to what the entity draws, each where the entity has none, all in the one step of the undo that put the controller on.
CircleCollider2DStruct: A circle an entity meets things with, scaled by the larger of the entity's X and Y.
Colliders2DEditingClass: Every 2D collider edited in the Scene view with Edit Collider: a box's and a capsule's dot in the middle of each side, which moves that side, the far one staying, a circle's four on its edge, which set its radius, and a polygon's and an edge's at each point, dragged, added on a line between two and deleted with Ctrl — a polygon three to 64, an edge two to 32.
Colliders2DFittingClass: A collider put on an entity in the editor fits what the entity draws — its sprite's rectangle, or its mesh's box across X and Y — as it is added: a box its size, a circle round it, a capsule along its longer side, a polygon at its corners.
Colliders2DGeometryClass: The colliders that stand still in 2D, as convex outlines, for what is worked out of a scene in the editor by code with no physics of its own: a navmesh in 2D, its floor less what they cover.
Collision2DRecord struct: Two bodies whose colliders began or stopped touching: Physics2D.CollisionsEntered and Physics2D.CollisionsExited.
CollisionDetection2DEnum: How a body is kept from passing through what it meets: Rigidbody2D.CollisionDetection.
DistanceJoint2DStruct: Two bodies kept DistanceJoint2D.Distance apart, as a rod between them, or with DistanceJoint2D.MaxDistanceOnly no further, as a rope: the body this is on and DistanceJoint2D.ConnectedBody, or a point in the world where that is none.
EdgeCollider2DStruct: A line of edges an entity meets things with, one way or the other: ground's outline, a slope, a ledge.
FixedJoint2DStruct: Two bodies held together as they were as it was made, as if welded: the body this is on and FixedJoint2D.ConnectedBody, or the world where that is none; stiff, or with a FixedJoint2D.Frequency giving like a spring.
HingeJoint2DStruct: Two bodies held turning about one point, as a door on its hinge or a wheel on its axle: the body this is on — the nearest Rigidbody 2D at or above its entity — and HingeJoint2D.ConnectedBody, or a point in the world where that is none.
Interpolation2DEnum: Whether a body is drawn between fixed steps: Rigidbody2D.Interpolate.
Joint2DKindEnum: Which joint broke: JointBroken2D.Joint.
JointBroken2DRecord struct: A joint that broke, held harder than its Break Force or Break Torque in a step, and taken off its entity: see Physics2D.JointsBroken.
Joints2DEditingClass: Joints in the editor: put on an entity, a joint brings a Rigidbody 2D where there is none on the entity or above it; Edit Joint drags its anchors in the Scene view; and the joints of what is picked are drawn there — where each holds its own body and the other, the line between, and which way a slider and a wheel's suspension move.
Particles2DEditingClass: While the game is edited, a Box2D world of the editor's own kept in step with the entities — bodies and ground made, moved and taken away as they are, never stepped and nothing written back — so particles meet the scene's 2D colliders in the Scene panel as they will as the game plays.
Physics2DClass: Physics 2D, as a game's code reaches it: context.Services.Get<Physics2D>().
Physics2DGizmosClass: The outlines of the colliders of what is picked, in the Scene view, as the editor draws them while editing and while playing: a box's, a circle's, a capsule's, a polygon's corners, an edge's line and a Tilemap's outline, in collider green, where the entity's GlobalTransform puts them.
Physics2DPluginClass: Physics 2D, as a plugin: a Box2D world for the game playing, stepped on the engine's fixed clock and kept in step with the entities — each Rigidbody 2D made a body and moved, with the colliders on its entity and under it that are on no body nearer, and ground made of each collider with no Rigidbody 2D at or above it, where its GlobalTransform puts it — and drawn between steps where a body asks.
Physics2DSettingsStruct: Physics 2D's settings, a page of Project Settings: the pull on every body, how many times Box2D works each step out, what queries find, and which layers' bodies meet which.
PhysicsMaterial2DStruct: What a 2D collider is made of: how it slides along what it touches and how it bounces off it.
PlatformEffector2DStruct: A one-way platform: the colliders on its entity met only from along its up — what lands on it from above rests on it, and what comes up from below or in from the side passes through — by bodies and characters alike.
PolygonCollider2DStruct: A shape of up to 64 corners an entity meets things with, in order round it, concave or convex: cut into the convex pieces of eight corners at most Box2D's polygons are, its hollows left out.
RaycastHit2DRecord struct: What a ray or a swept shape hit first: see Physics2D.Raycast.
Rigidbody2DStruct: A body Physics 2D moves: by gravity, by what it meets and by what code does to it, its colliders — a BoxCollider2D and the others on the same entity, and those on the entities under it that have no Rigidbody 2D nearer — what it meets with.
SliderJoint2DStruct: Two bodies held sliding along a line, as a drawer or a lift: the body this is on and SliderJoint2D.ConnectedBody, or the world where that is none, kept at the angle they were made at.
SpringJoint2DStruct: Two bodies pulled toward SpringJoint2D.Distance apart by a spring of SpringJoint2D.Frequency and SpringJoint2D.DampingRatio: the body this is on and SpringJoint2D.ConnectedBody, or a point in the world where that is none.
TilemapCollider2DStruct: The outline of the Tilemap on its entity, which it meets things with: a loop round each region of solid tiles joined by their sides, each straight run of it one edge — no seam between two tiles for what slides along it to catch on — and the top of each row of one-way tiles, met from above alone.
Trigger2DRecord struct: A body that went into or came out of a trigger: Physics2D.TriggersEntered and Physics2D.TriggersExited.
WheelJoint2DStruct: A wheel on a body: WheelJoint2D.ConnectedBody, the wheel, turning freely about WheelJoint2D.ConnectedAnchor and held to the body this is on — the car — by a suspension along a line, a spring of WheelJoint2D.SuspensionFrequency and WheelJoint2D.SuspensionDampingRatio.

Abyss.Physics3D

TypeWhat it is
BallJoint3DStruct: Two bodies held at one point and turning about it every way, as a ball in its socket or a lamp on its chain: the body this is on and BallJoint3D.ConnectedBody, or a point in the world where that is none.
BodyType3DEnum: How a body moves: Rigidbody3D.Type.
BoxCollider3DStruct: A box an entity meets things with: on its Rigidbody3D, or the nearest one above it, or ground where there is none.
CapsuleCollider3DStruct: A capsule an entity meets things with: a cylinder with a half ball at each end, a character's.
CapsuleDirection3DEnum: Which of the entity's own axes a capsule lies along: CapsuleCollider3D.Direction.
CharacterController3DStruct: A character, moved as it is told rather than pushed about as a body is: the Rigidbody 3D on its entity, moved as a Kinematic one whatever its Type, and its Capsule Collider 3D the shape it moves as, standing up — or its Box Collider 3D, square to the world, flat underneath: a box stands on an edge as long as any of it is over it and meets a wall flat, where a capsule rolls off an edge and, within its step, up one, which a block game does not want.
Characters3DEditingClass: A Character Controller 3D added in the editor brings what it moves as: a Rigidbody 3D, Kinematic, and a Capsule Collider 3D fitted to what the entity draws, in the same step of the undo; and the Inspector says under one with no capsule that it does not move as a character, and under one whose capsule lies along X or Z that it stands up.
Colliders3DEditingClass: The 3D colliders with a size edited in the Scene view with Edit Collider: a box's dot in the middle of each face, which moves that face, the far one staying; a sphere's at each end of its three axes, which set its radius; and a capsule's four round its middle, which set its radius, and one at each end, which set its height.
Colliders3DFittingClass: A collider put on an entity in the editor fits what the entity draws — its mesh's box, or its sprite's rectangle — as it is added: a box its size, a sphere round it, a capsule along its longest side.
Colliders3DGeometryClass: The colliders that stand still, as triangles, for what is worked out of a scene in the editor by code with no physics of its own: a navmesh baked from colliders.
Colliders3DNotesClass: What the Inspector says under a mesh collider that will not meet things as its fields alone say: one that is its mesh's hull, on a Dynamic body or as a trigger, and one whose entity carries no mesh.
Collision3DRecord struct: Two bodies whose colliders began, stopped or go on touching: Physics3D.CollisionsEntered, Physics3D.CollisionsExited and Physics3D.CollisionsStaying.
CollisionDetection3DEnum: How a body is kept from passing through what it meets: Rigidbody3D.CollisionDetection.
DistanceJoint3DStruct: Two bodies kept DistanceJoint3D.Distance apart, as a rod between them, or with DistanceJoint3D.MaxDistanceOnly no further, as a rope: the body this is on and DistanceJoint3D.ConnectedBody, or a point in the world where that is none.
FixedJoint3DStruct: Two bodies held together as they were as it was made, as if welded: the body this is on — the nearest Rigidbody 3D at or above its entity — and FixedJoint3D.ConnectedBody, or the world where that is none.
Freeze3DEnum: Which ways a body never moves or turns, along and about the world's axes: Rigidbody3D.Freeze.
HingeJoint3DStruct: Two bodies held turning about one line, as a door on its hinges or a wheel on its axle: the body this is on and HingeJoint3D.ConnectedBody, or the world where that is none.
Interpolation3DEnum: Whether a body is drawn between fixed steps: Rigidbody3D.Interpolate.
Joint3DKindEnum: Which joint broke: JointBroken3D.Joint.
JointBroken3DRecord struct: A joint that broke, held harder than its Break Force or Break Torque in a step, and taken off its entity: see Physics3D.JointsBroken.
JointMotor3DEnum: What a hinge's or a slider's motor does.
Joints3DEditingClass: Joints in the editor: put on an entity, a joint brings a Rigidbody 3D where there is none on the entity or above it; Edit Joint moves its anchors in the Scene view by handles of the Move tool's; and the joints of what is picked are drawn there — where each holds its own body and the other, the line between, a hinge's axis and how far it may turn, a slider's line and how far it may slide, and a ragdoll joint's cone and its twist.
MeshCollider3DStruct: The entity's own mesh, as what it meets things with: its triangles, where it is ground or on a body that moves only as it is moved, or its hull — the smallest convex shape round it, what Convex makes it — on a Dynamic body and as a trigger, triangles having no inside to weigh or to be in, which the Inspector says.
MeshColliders3DBakingClass: The shapes a Mesh Collider 3D is made of, baked as the editor imports a model ticked for Physics 3D — each mesh's triangles and its hull, saved as Jolt saves them — so a game restores them rather than working them out as it starts; and a model ticked as a Mesh Collider 3D of one of its meshes is added.
MeshShape3DClass: A Mesh Collider 3D's shape of a mesh's data, worked out ahead — on whatever thread a game's generation runs on — and handed to Physics 3D with the mesh in one call (Physics3D.CreateMesh, Physics3D.UpdateMesh), so the physics step makes nothing of it: a block world's chunk built whole, mesh and collider, away from the game.
Particles3DEditingClass: While the game is edited, a Jolt world of the editor's own kept in step with the entities — bodies and ground made, moved and taken away as they are, never stepped and nothing written back — so particles meet the scene's 3D colliders in the Scene panel as they will as the game plays.
Physics3DClass: Physics 3D, as a game's code reaches it: context.Services.Get<Physics3D>().
Physics3DGizmosClass: The wireframes of the colliders of what is picked, in the Scene view, as the editor draws them while editing and while playing: a box's edges, a sphere's three circles, a capsule's end circles and outlines, a mesh's triangles or its hull's edges as physics will meet it, in collider green, where the entity's GlobalTransform puts them.
Physics3DPluginClass: Physics 3D, as a plugin: a Jolt world for the game playing, stepped on the engine's fixed clock and kept in step with the entities — each Rigidbody 3D made a body and moved, with the colliders on its entity and under it that are on no body nearer, and ground made of each collider with no Rigidbody 3D at or above it, where its GlobalTransform puts it — and drawn between steps where a body asks.
Physics3DSettingsStruct: Physics 3D's settings, a page of Project Settings: the pull on every body, how many times Jolt works each step out, what queries find, and which layers' bodies meet which.
PhysicsMaterial3DStruct: What a 3D collider is made of: how it slides along what it touches and how it bounces off it.
RagdollJoint3DStruct: A limb held to what it hangs from, as a shoulder or a knee is: the body this is on and RagdollJoint3D.ConnectedBody, or a point in the world where that is none, held at one point, its RagdollJoint3D.Axis swinging no further from where it was than a cone and twisting about itself within a range.
RaycastHit3DRecord struct: What a ray or a swept shape hit first: see Physics3D.Raycast.
Rigidbody3DStruct: A body Physics 3D moves: by gravity, by what it meets and by what code does to it, its colliders — a BoxCollider3D and the others on the same entity, and those on the entities under it that have no Rigidbody 3D nearer — what it meets with.
SliderJoint3DStruct: Two bodies held sliding along one line, as a drawer or a lift, kept at the turn they were made at: the body this is on and SliderJoint3D.ConnectedBody, or the world where that is none.
SphereCollider3DStruct: A ball an entity meets things with, scaled by the largest of the entity's scales.
SpringJoint3DStruct: Two bodies pulled toward SpringJoint3D.Distance apart by a spring of SpringJoint3D.Frequency and SpringJoint3D.DampingRatio: the body this is on and SpringJoint3D.ConnectedBody, or a point in the world where that is none.
Trigger3DRecord struct: A body that went into, came out of or is inside a trigger: Physics3D.TriggersEntered, Physics3D.TriggersExited and Physics3D.TriggersStaying.