Sandbox.Engine

Prevent double initialization

Steam AppId of S&box.

True if we're running the engine as part of a unit test

True if running without a graphics window, such as in a terminal.

True if running in a terminal like console, instead of a game window or editor.

True if this is a dedicated server

True if running a benchmark

True if running with the tools or editor attached

True if running with -joinlocal. This is an instance that launches and joins an in process editor session.

A local instance Id assigned when the instance is spawned with -joinlocal. We can use this to create a deterministic fake SteamId for example.

The engine's version string

True if this is compiled and published on steam

The date of this version, as a UTC datetime.

Number of exceptions we've had. Resets on game exit.

True if the game is running in standalone mode

The language code for the current language

True if the game is running in VR mode

The currently loaded game package. May be null if no game loaded. Controlled by GameMenuDll.

The currently loaded map package

The currently loaded game package's ident - if applicable.

Returns true if the microphone is currently listening

Returns true if the microphone is currently listening and actually hearing/capturing sounds

Is the game window in focus?

Exits the application if we're running in standalone mode or we are a Dedicated Server.

Allows access to the RenderSettings singleton, which contains settings related to rendering in the game. You're only able to access this when in standalone mode. When accessing in the editor, or in sbox it will return null.

Gets the active scene. This could be in the menu system, or in the game. This is provided for internal engine, and should never be accessible to the user code.

Get the current editor if any. Will return null if we're not in the editor, or there is no active editor session.

The github SHA of the current build

Called before anything else. This should set up any low level stuff that might be relied on if static functions are called.

Let's native exit the C# app so AppDomain.ProcessExit gets called

Called on exceptions from a task (delayed, because it'll only get called when the exception gets collected) TODO: Move this somewhere else

Called to initialize the engine.

Should be called when startup has finished. If we have a client, this is when the menu is first entered.

Called when the "disconnect" command is ran.

Closes the current GameInstance immediately

Get the replicated var value from the host

Load the assemblies from this package into the current game instance

Set if we're loading a game as a result of joining a server

Set if we're the hosting as the result of starting our own server

Set if we want to reload the game, even if it's already loaded

Set if this is a developer session. It started from an editor session and as such we shouldn't load assemblies from the package, they should be loaded from the Network Tables instead.

Called when a game session starts. Destroys the menu scene to free resources.

Called when a game session ends. Recreates the menu scene.

The name of this context, for debugging purposes

What mouse cursor does this context want to show?

What kind of mouse interaction is this context interested in right now

Mouse is UI mode but wants to use the mouse capture/delta mode

What kind of keyboard interaction is this context interested in right now

When input type changes, we capture which buttons are down to block text input until they're released This fixes problems where you hold a key, open a UI, and the held key generates text input

Mouse moved in game mode

A button event to be sent to the game

Which system should we be sending our input to?

When true we've called StartTrapping and are waiting for the user to release keys

Start trapping keys. When the user releases all keys the callback will be called with a list of buttons that were pressed during the trap.

Called when a key is released if we're trapping keys.

Special handling for the escape button. Return false if we didn't use it.

This is called even if the context doesn't have focus. It's just a place to unpress buttons, if they're down.

Is this a reserved button? This means developers can not detect these keys as up or down.

Doesn't want it, pass down to next context

Interacting with UI

Interacting with the game

Registers exclusive Sandbox.Tools types

Load the startup project for the first time

Is the game view visible, or is it in a tab in the background?

A public interface to the active editor system

Called after the host network system is initialised, used to add additional package references etc. to dev servers

Get a thumbnail for the specified asset.Can return null if not immediately available.

Sandbox.GameInstance or Sandbox.Menu

The input context for this game instance, which contains the current input state and bindings.

The active scene for this game instance.

For the resource library

Holds a list of available classes and types in the game, used for serialization and reflection.

For actiongraph

All of the mounted assets

A persistent data folder for the current package.

Allows a common place for an org's data

Special options for serializing json

For running tasks in a kind of sandboxed way

Creates tokens that will be cancelled at the end of the game

The event system isn't used that much anymore, we should move away from it.

The UI system for the game, which manages the user interface elements and their interactions.

Holds cookies for the game, which can be used for storing session data or other small pieces of information that need to persist across requests.

Holds language data for the game.

Per-context lookup of loaded instances by their physics index. Kept here so Menu and Game contexts each maintain their own set, preventing game-session teardown from clearing surfaces owned by the persistent menu context.

The global context for the game, which holds references to various systems and libraries used throughout the game.

Should be called before using. This will re-initialize the task source stuff, ready to use.

Called once at process shutdown. Clears and nulls all held references without re-allocating — use for the between-game teardown.

We sometimes want to disable access to certain things, like when we're running static initializers. This prevents users from relying on behaviours that are not stable.

Should rarely have to get called, game scope is implicit. Will need to be called if we're in the menu scope, and have to call something in the game scope.

Should only be called at a really high level, when doing menu stuff

The context used for the menu system

The context used for the game. This is the default context.

The current active context

The global context for the game, which holds references to various systems and libraries used throughout the game.

Throws an exception when called from client or server.

Your own username

Your own user id

The service type (ie "Twitch")

Are we connected to a service

A centralized place to access the protocols

We cannot play packages with an Api version higher than this.

We cannot talk to servers or clients with a network protocol different to this.

Defines a navigation area resource for use in navigation meshes.

Debug color for this Area.

How much costlier it is to cross this Area. Will be clamped.

Gets or sets the priority level for the area definition. Higher values take precedence if multiple areas overlap.

Changing this value may trigger updates to the navigation mesh.

A wrapper to allow the unification of editing materials. This is usually a member on a Component which implements MaterialAccessor.ITarget.


             MaterialAccessor materialAccessor;
            
            	[Property]
            	public MaterialAccessor Materials => materialAccessor ??= new MaterialAccessor( this );

The target of a MaterialAccessor. This is the object that will be modified when setting or clearing material overrides.

Return true if this target is valid

The number of materials on this target

Get the original material, before overrides, matching this index

Set the override material for this index.

Wipe all overrides

Create a new material accessor for this object.

Total number of material slots

Get the original material for the specified index.

Does this index have an override material?

Get the override material for this slot. Or null if not set.

Set an override material for this slot. If the material is null, it will clear the override.

Apply to the object. You don't need to call this when setting overrides, as it will automatically apply them to the target when you set them. This is here as a convenience if this object holds data, and you need to apply it to another object that didn't exist when the overrides were originally set, or loaded.

A collection of action binds. BindCollection - Action: attack1 - Slot0: mouse1 - Action: selectall - Slot0: ctrl + a The bind collection can be saved and loaded from disk via the BindSaveConfig class. The bind collection can have a base collection which it will fall back to if it contains the same binds. This allows us to have a "common" collection which can be shared between all games, but can also let the games + users to override those binds if they choose.

The base collection. Game binds have this set to the common binds.

Will be either "common" or the ident of the current game.

The location of the config file to load from in EngineFileSystem.Config

The actual collection of binds.

Creates a collection and tries to load it from disk.

If we're the common collection and have no binds (because we haven't been able to load a customized config from disk) then we'll fill in the defaults based on Input.CommonInputs.

Get the bind, create if it doesn't exist

Set the bind value for this action. This will overwrite what's in this slot.

Get the bind value at this slot

Save the collection to disk

Reset the collection to the default values.

Enumerate all actions that contain this button

The action list has changed, we just got the config from the server. Here we'll clear the actions, add all of the defaults from the new config and then load the user config if it exists.

If this is set then we want to read the value from the base collection

A struct which is serialized/deserialized to save binds to a file (in a more readable format)

To allow us to cater for changes in schema

A list of strings that describe the binds "jump": "space;m", "run": "shift", "walk": "alt",

Load a serialized collection from disk

Save a serialized collection to disk

Find a bind collection by name. The name is generally the ident of the current game. We'll try to load the binds from /config/input/*.json - if we fail then we'll serve the default.

Temporary housing for common inputs Games that don't define any input actions will get a bunch of default actions given to them

This is where input is sent to from the engine. This is the first place input is routed to. From here it tries to route it to the menu, game menu and client - in that order. That should really be abstracted out though, so we can use this properly in Standalone.

True if the cursor is visible

The mouse cursor position. Or the last position if it's now invisible.

The mouse cursor delta

The panel we're keyboard focusing on

The position in which we entered capture/relative mode

True if an "exit game" button is pressed, escape on keyboard

The escape button was pressed this frame. The game is allowed to consume this. Then it will go to the menu. This is distinct from EscapeIsDown, because that is used to close the game when held down.

Time since escape was pressed

Buttons that are currently pressed

Controller buttons that are currently pressed

Returns the number of seconds escape has been held down

Return the input contexts of each context, in order of priority

An input context wants to set the cursor position

Return true if button is pressed

A console command from the engine.

Cursor is hidden and restricted to window (game mode) but the mouse has been moved

Cursor is visible and mouse is being moved

The escape, or start button has been pressed

Convert engine (IE_ShiftPressed etc) to our KeyboardModifiers enum

Get the current modifier key state by checking the actual button state directly.

A WebSocket client for connecting to external services.

Events handlers will be called on the synchronization context that was called on.

Event handler which processes text messages from the WebSocket service.

The message text that was received.

Event handler which processes binary messages from the WebSocket service.

The binary message data that was received.

Event handler which fires when the WebSocket disconnects from the server.

The close status code from the server, or 0 if there was none. See known values here: https://developer.mozilla.org/en-US/docs/Web/API/CloseEvent The reason string for closing the connection. This may not be populated, may be from the server, or may be a client exception message.

Returns true as long as a WebSocket connection is established.

Get the sub-protocol that was negotiated during the opening handshake.

Event which fires when a text message is received from the server.

Event which fires when a binary message is received from the server.

Event which fires when the connection to the WebSocket service is lost, for any reason.

Initialized a new WebSocket client.

The maximum message size to allow from the server, in bytes. Default 64 KiB.

Cleans up resources used by the WebSocket client. This will also immediately close the connection if it is currently open.

Add a sub-protocol to be negotiated during the WebSocket connection handshake.

Establishes a connection to an external WebSocket service.

The WebSocket URI to connect to. For example, "ws://hostname.local:1280/" for unencrypted WebSocket or "wss://hostname.local:1281/" for encrypted. A which allows the connection attempt to be aborted if necessary. A which completes when the connection is established, or throws if it failed to connect.

Sends a text message to the WebSocket server.

The message text to send. Must not be null. A which completes when the message was queued to be sent.

Sends a binary message to the WebSocket server.

The and overloads allow sending subsections of byte arrays. The message data to send. Must not be null. A which completes when the message was queued to be sent.

Sends a binary message to the WebSocket server.

The message data to send. Must not be null. A which completes when the message was queued to be sent.

Sends a binary message to the WebSocket server.

The message data to send. A which completes when the message was queued to be sent.

Controls the quality level of post processing effects such as: ambient occlusion, depth of field, motion blur and more

Render quality profiles adjust rendering features to a profile level

Set all the convars for a group based on the level

User graphics settings

We want benchmarks to have all similar settings. Set them here. The only fluctuations we should see are resolution and hardware.

The results of compiling a single combo

Compile a single program on this shader

The results of a shader compile

True if the shader was compiled successfully. False indicates an error occurred. You can dig deeper into why in Programs.

If true then this compile was skipped because nothing changed

If successful, this contains the actual resource-encoded bytes of the shader compile.

The results of an individual shader program compile (PS, VS etc)

The identifier for this program

How many combos had to be compiled for this program. This is Static * Dynamic.

The full pre-processed source for this shader

True if this was compiled successfully

Shader compile output, warnings and errors

Compile a shader from a filename ("/folder/file.shader")

Convert a shader to a resource file

Passed to shader compiles to provide a shared context between the compiles. This provides the source code to the compile, but it also gives an opportunity for the threaded, individual compiles, to share and cache information between them.

Options used when compiling a shader

Write to console. Used when running from the command line.

A source version of the shader. In the future we'll use this to pre-process the shader, work out what programs it contains, and pull out all of the meta data that we need.

Updates IsOutOfDate

Go through each line and find the programs that we have

Add a program to compile

Serialize to the correct format

Run the trace and return the result. The result will return the first hit.

Casts a ray from point A to point B.

Casts a ray from a given position and direction, up to a given distance.

Only return scene objects with this tag. Subsequent calls to this will add multiple requirements and they'll all have to be met (ie, the scene object will need all tags).

Only return scene objects with all of these tags

Only return scene objects with any of these tags

Only return scene objects without any of these tags

The distance between start and end positions.

The start position of the trace

The end or hit position of the trace

The hit position of the trace

A fraction [0..1] of where the trace hit between the start and the original end positions

The hit surface normal (direction vector)

The transform of the hit object (if it has one)

If we hit something associated with a sceneobject, this will be that object.

This is the Uv coordinate on the triangle hit. 'x' represents the distance between Vertex 0-1, 'y' represents the distance between Vertex 0-2.

Given the position on the triangle hit, this vector gives the influence of each vertex on that position. So for example, if the Vector is [1,0,0] that means that the hit point is right on vertex 0. If it's [0.33, 0.33, 0.33] then it's right in the middle of each vertex.

Human-readable product name of this system's processor.

The frequency of this system's processor in GHz.

The number of logical processors in this system.

Total physical memory available on this machine, in bytes.

Human-readable product name of the graphics card in this system.

The version number of the graphics card driver.

Total VRAM on this system's graphics card.

Indicates the amount of available free space on game drive in bytes

Gets the total size of storage space on game drive in bytes

Return as an object, for sending to backends

Tools for diagnosing heap allocations

A shared private class with the explicit purpose of recording how long it takes between a developer saving a .cs file, and the changes being available on the client. This is used to diagnose and monitor the code iteration time.

Stats returned from the engine each frame describing what was rendered, and how much of it.

Number of objects that passed all cull checks and were rendered.

Number of objects considered before culling.

Number of objects that were tested against cull checks.

Primitive draws for base (static) scene objects.

Primitive draws for animatable scene objects.

Number of render batch draw lists submitted.

Total number of triangles rendered.

Number of draw calls.

Number of non-shadow (colour pass) material changes.

Number of depth-only (shadow pass) material changes.

Number of initial material changes (first bind of a material this frame).

Number of unique materials seen this frame.

Number of display lists submitted to the GPU.

Number of scene views rendered.

Number of render target resolves.

Number of primary render contexts created.

Number of secondary render contexts created.

Number of objects culled by static visibility.

Number of objects culled by screen size.

Number of objects culled by distance fading.

Number of objects currently being distance-faded.

Number of lights in view that cast shadows.

Number of lights in view that don't cast shadows.

Number of shadow maps rendered this frame.

GPU timing data for a single render pass/group

GPU profiler stats collected from the scene system timestamp manager

Whether GPU profiling is enabled

Total GPU time for all tracked passes

Get the current GPU timing entries

Get a smoothed duration for a given name (for display purposes)

Get a decayed max duration for a given name (for display purposes)

Record a frame state section in PerformanceStats

This exists to allow the creation of performance scopes without

Get the time taken, in seconds, that were required to process the previous frame.

Latest available GPU frametime, in ms.

Frame number of the last reported .

The number of bytes that were allocated on the managed heap in the last frame. This may not include allocations from threads other than the game thread.

Number of generation 0 (fastest) garbage collections were done in the last frame.

Number of generation 1 (fast) garbage collections were done in the last frame.

Number of generation 2 (slow) garbage collections were done in the last frame.

How many ticks we paused in the last frame

Number of exceptions in the last frame.

Approximate working set of this process.

Performance statistics over the last period, which is dictated by "perf_time" console command.

Return a list of the main top tier timings we're interested in

Additional symbol path to use for resolving symbols

Pumps the input system

A console command has arrived, or a convar has changed

Called right at the end of a view being submitted, so everything CPU is done and it's handed off to the GPU. This is also called for any dependent views.

Queue something to be disposed of after the frame has ended and everything has finished rendering.

Drain all queued frame-end disposables immediately. Called during shutdown since no more frames will run to process them naturally.

Sometimes stuff is blocking that doesn't need to be. We want to keep running the main loop while the function is blocking. This usually happens with Qt stuff like the drag and drop. This should allow the main loop to still be pumped while waiting for that blocking function. - main game loop while ( true ) { mainloop(); BlockingLoopPumper.Run() { runBlockingFunction(); } } - somewhere else - usually Qt Timer BlockingLoopPumper.Pump(); { mainloop(); }

Used to call things outside of the main frame

Called outside the main game loop.

An action to call the main game loop

Should be called regularly, on the main thread. Generally this is called automatically by Qt in the timer (search OnQtHeartbeat). This should do total nothing if we're not actually in a blocking loop - because loopPump will be null.

This is how the engine communicates with the menu system

Called to initialize the menu system

Close down the menu, delete everything

Called every frame, to let the menu think

Show a popup

Show a question

Package closed. Add a toast asking if it was cool or not

True if we want to force the cursor to be visible and swallow input. This is used for the developer console and loading screens.

Used to talk to the menu's loading screen.

The Id of the element ( id="foo" )

If the panel created by razor, this is the file in which it was defined

If the panel was created by razor, this is the line in which it was defined

If true then this panel (or its ancestor) has pointer-events: all

Set the panel's absolute position. This wouldn't be needed if we could expose the styles. Which we should do.

Procedural classes such as :hover and :active

Get all style blocks active on this panel

Log information to console for debugging purposes.

Data storage that persists across sessions.

Allows access to all available types, reflection style.

Thrown when accessed during static constructors.

A readonly filesystem that has a list of files, and a list of redirects. When accessing a file, it'll access the redirect file invisibly.

Add a redirect path

Try to get all tags in the set.

The menu that is shown when escape is pressed while playing.

Show offline members

Show online (but not in-game) members

Passed to IModalSystem.CreateGame

Passed to IModalSystem.WorkshopPublish

The default title of this item. The user will be able to change it.

The description of this item. The user will be able to change it.

512x512 thumbnail image, no transparency

The filesystem containing the files to publish

Keyvalues to store on the item. You can search and filter by these later.

Tags to set on the item. You can search and filter by these later.

You can store metadata on the item, which is just a string. This can be read when querying items before downloading them - so it can be useful for storing extra info you want to store.

The visibility of the item

Can the client select the visibility for this item

Called when done. The ulong is the published item id. You can access it via url https://steamcommunity.com/sharedfiles/filedetails/?id=######

If set, update this existing workshop item instead of creating a new one.

Defined categories to show in the workshop publish modal

Adds a new category associated with the specified enum type to the collection. The user will be prompted to select one of the enum values when publishing. This will be set on the file as keyvalues[name] = enum.ToString()

Helper to wrap while keeping a reference to the original delegate, so it won't be garbage collected. must be called to remove the reference.

Gets the raw function pointer.

Removes the reference to the original delegate, and sets the function pointer to null.

A base interface that all handles should use

This struct exists to differentiate the constructor of a handle object from the regular constructors. This way we can prevent clients creating the object manually, but still be able to create them at runtime.

An index that can convert from a handle (int) to a class. This is usually a static on your Handle object called HandleIndex.

Convert a native utf pointer to a string

Get the length of a null-terminated UTF-8 string using AVX2 (fallback to scalar if unavailable)

Convert a native utf pointer to a string

Called by the binding system to log an exception when calling a binding

Converts a base library name to its platform-specific filename. e.g. "engine2" → "engine2.dll" (Windows), "libengine2.so" (Linux), "libengine2.dylib" (macOS)

used to pass a string back to native

This is called when native calls a managed function and it returns a string. In this case we can't free the string immediately, so we store it in a list and free it at the end of the frame. This has potential to crash, if we free the string before the thread uses it but this would be super rare and the other option is to never return strings like this.

Represents filtering modes for texture sampling in the rendering pipeline.

Uses the nearest texel without interpolation. Fastest but lowest visual quality.

Interpolates between the four nearest texels in the same mip level. Smoother than point sampling but does not blend between mip levels.

Bilinear sampling with smooth transitions between mipmap levels. Provides better visual quality across distances.

Enhances texture detail on steep viewing angles. Best visual quality, higher performance cost.

Specifies how texture coordinates outside the [0.0, 1.0] range are handled.

Wraps the texture coordinates. Values beyond 1.0 wrap around to the beginning. Produces a repeating tiling pattern.

Mirrors the texture coordinates when sampling outside the [0.0, 1.0] range. Creates a mirrored tiling effect.

Clamps the texture coordinates to the [0.0, 1.0] range. Texture edges are stretched when sampling outside the range.

Uses a constant border color when sampling outside the [0.0, 1.0] range. Requires a border color to be defined.

Mirrors the texture once, then clamps to the edge. Coordinates in [0.0, 1.0] sample normally, [-1.0, 0.0] mirror once, and everything else clamps.

This is a pointer but native pretends like it's a handle/struct using DECLARE_POINTER_HANDLE. We just treat it like a pointer.

Represents a sampler state used to control how textures are sampled in shaders. Example usage:


             SamplerState mySampler < Attribute("sampler"); >;

C# binding:


             var sampler = new SamplerState
             {
                 Filter = FilterMode.Trilinear,
                 AddressModeU = TextureAddressMode.Wrap,
                 AddressModeV = TextureAddressMode.Wrap,
                 AddressModeW = TextureAddressMode.Clamp,
                 MaxAnisotropy = 4
             };
            
             Graphics.Attributes.Set("sampler", sampler);

The texture filtering mode used for sampling (e.g., point, bilinear, trilinear).

The addressing mode used for the U (X) texture coordinate.

The addressing mode used for the V texture coordinate.

The addressing mode used for the W texture coordinate.

The bias applied to the calculated mip level during texture sampling. Positive values make textures appear blurrier; negative values sharpen.

The maximum anisotropy level used for anisotropic filtering. Higher values improve texture quality at oblique viewing angles.

Border color to use if is specified for AddressU, AddressV, or AddressW.

Gets or creates a bindless sampler index for this .

Set a special value

Set the color texture from this named render target to this attribute

Set the depth texture from this named render target to this attribute

Set the color texture from this named render target to this attribute

Set the size of this named render target to this float2 attribute

Takes a copy of the current viewport's color texture and stores it in targetName on renderAttributes.

Takes a copy of the current viewport's depth texture and stores it in targetName on renderAttributes.

Get the actual render target by name. Useful for externals that need to access the render target directly.

These are the attributes for the current view. Setting a variable here will let you pass it down to other places in the render pipeline.

Access to the local attributes. What these are depends on where the command list is being called. If we're calling from a renderable, these are the attributes for that renderable.

Holds the function and state data for a single command. We should FIGHT to keep this as small as possible. Every byte you add to this makes it WORSE.

An ordered list of entries that will execute on the render thread.

Access to simple 2D painting functions to draw shapes and text.

This lives for the lifetime of the command list and is used to store temporary render targets and other state.

Should be called at the end of usage

Sneaky way for externals to get render target

Takes a copy of the framebuffer and returns a handle to it

Generates mipmaps on the grabbed texture filtered with gaussian blur for each mip

Takes a copy of the depthbuffer and returns a handle to it

Run this CommandList here

Run this command list

Command buffer flags allow us to skip command buffers if the camera doesn't want a particular thing. Like post processing.

Draws a single model at the given Transform immediately.

The model to draw Transform to draw the model at Optional attributes to apply only for this draw call

Draws multiple instances of a model using GPU instancing, assuming standard implemented shaders. Use `GetTransformMatrix( int instance )` in shaders to access the instance transform. There is a limit of 1,048,576 transform slots per frame when using this method.

The model to draw Instance transform data to draw Optional attributes to apply only for this draw call

Draws multiple instances of a model using GPU instancing with the number of instances being provided by indirect draw arguments. Use `SV_InstanceID` semantic in shaders to access the rendered instance.

The model to draw The GPU buffer containing the DrawIndirectArguments Optional offset in the GPU buffer Optional attributes to apply only for this draw call

Draws multiple instances of a model using GPU instancing. This is similar to , except the count is provided from the CPU rather than via a GPU buffer. Use `SV_InstanceID` semantic in shaders to access the rendered instance.

The model to draw The number of instances to draw Optional attributes to apply only for this draw call

Draws geometry using a vertex buffer and material.

The vertex type used for vertex layout. The GPU buffer containing vertex data. The material to use for rendering. The starting vertex index for rendering. The number of vertices to render. If 0, uses all vertices in the buffer. Optional render attributes to apply only for this draw call. The type of primitives to render. Defaults to triangles.

Draws indexed geometry using vertex and index buffers.

The vertex type used for vertex layout. The GPU buffer containing vertex data. The GPU buffer containing index data. The material to use for rendering. The starting index for rendering. The number of indices to render. If 0, uses all indices in the buffer. Optional render attributes to apply only for this draw call. The type of primitives to render. Defaults to triangles.

Draws instanced geometry using a vertex buffer and indirect draw arguments stored in a GPU buffer.

The vertex type used for vertex layout. The GPU buffer containing vertex data. The material to use for rendering. The GPU buffer containing indirect draw arguments. Optional byte offset into the indirect buffer. Optional render attributes to apply only for this draw call. The type of primitives to render. Defaults to triangles.

Draws instanced geometry using a vertex buffer and indirect draw arguments stored in a GPU buffer.

Vertex data is accessed in shader through buffer attribute and SV_VertexID. The material to use for rendering. The GPU buffer containing indirect draw arguments. Optional byte offset into the indirect buffer. Optional render attributes to apply only for this draw call. The type of primitives to render. Defaults to triangles.

Draws instanced indexed geometry using indirect draw arguments stored in a GPU buffer.

The vertex type used for vertex layout. The GPU buffer containing vertex data. The GPU buffer containing index data. The material to use for rendering. The GPU buffer containing indirect draw arguments. Optional byte offset into the indirect buffer. Optional render attributes to apply only for this draw call. The type of primitives to render. Defaults to triangles.

Draws instanced indexed geometry using indirect draw arguments stored in a GPU buffer.

Vertex data is accessed in shader through buffer attribute and SV_VertexID. The GPU buffer containing index data. The material to use for rendering. The GPU buffer containing indirect draw arguments. Optional byte offset into the indirect buffer. Optional render attributes to apply only for this draw call. The type of primitives to render. Defaults to triangles.

Draws indexed geometry with instancing. Each instance shares the same index buffer.

Get a screen sized temporary render target. You should release the returned handle when you're done to return the textures to the pool.

The name of the render target handle. Divide the screen size by this factor. 2 would be half screen sized. 1 for full screen sized. The format for the color buffer. If set to default we'll use whatever the current pipeline is using. Number of mips you want in this texture. You probably don't want this unless you want to generate mips in a second pass. A RenderTarget that is ready to render to.

Get a screen sized temporary render target. You should release the returned handle when you're done to return the textures to the pool.

The name of the render target handle. Divide the screen size by this factor. 2 would be half screen sized. 1 for full screen sized. The format for the color buffer. If set to default we'll use whatever the current pipeline is using. The format for the depth buffer. The number of msaa samples you'd like. Msaa render textures are a pain in the ass so you're probably gonna regret trying to use this. Number of mips you want in this texture. You probably don't want this unless you want to generate mips in a second pass. A RenderTarget that is ready to render to.

Get a temporary render target. You should release the returned handle when you're done to return the textures to the pool.

The name of the render target handle. Width of the render target you want. Height of the render target you want. The format for the color buffer. If set to default we'll use whatever the current pipeline is using. The format for the depth buffer. The number of msaa samples you'd like. Msaa render textures are a pain in the ass so you're probably gonna regret trying to use this. Number of mips you want in this texture. You probably don't want this unless you want to generate mips in a second pass. A RenderTarget that is ready to render to.

We're no longer using this RT, return it to the pool

Set the current render target. Setting this will bind the render target and change the viewport to match it.

Set the color texture from this named render target to this attribute

A handle to the viewport size

A handle to the viewport size divided by a factor. Useful for dispatching at half or quarter resolution.

Dispatch a compute shader

Dispatch a ray tracing shader

Called during rendering, convert RenderTargetHandle.SizeHandle to a dimension

Clear the current drawing context to given color.

Color to clear to. Whether to clear the color buffer at all. Whether to clear the depth buffer. Whether to clear the stencil buffer.

Clears the given texture to a solid color.

The texture to clear. The color to clear to. Defaults to transparent black.

Clears the color texture of the given render target handle to a solid color.

The render target handle whose color texture to clear. The color to clear to. Defaults to transparent black.

Fills the given GPU buffer with a repeated uint32 value.

The buffer to clear. The uint32 value to fill with. Defaults to zero.

Executes a barrier transition for the given GPU Texture Resource. Transitions the texture resource to a new pipeline stage and access state.

The texture to transition. The new resource state for the texture. The mip level to transition (-1 for all mips).

Executes a barrier transition for the color texture of the given render target handle.

The render target color handle. The new resource state for the texture. The mip level to transition (-1 for all mips).

Executes a barrier transition for the depth texture of the given render target handle.

The render target depth handle. The new resource state for the texture. The mip level to transition (-1 for all mips).

Executes a barrier transition for the color texture of the given render target handle.

The render target handle. The new resource state for the texture. The mip level to transition (-1 for all mips).

Executes a barrier transition for the given GPU Buffer Resource. Transitions the buffer resource to a new pipeline stage and access state.

The GPU buffer to transition. The new resource state for the buffer.

Executes a barrier transition for the given GPU Buffer Resource. Transitions the buffer resource from a known source state to a specified destination state.

The GPU buffer to transition. The current resource state of the buffer. The desired resource state of the buffer after the transition.

Issues a UAV barrier for the given texture, ensuring writes from prior shader invocations are visible to subsequent ones without changing the resource layout.

The texture to barrier.

Issues a UAV barrier for the given GPU buffer, ensuring writes from prior shader invocations are visible to subsequent ones.

The buffer to barrier.

Sneaky way for extensions to add an action. This creates an allocation, so it should be used sparingly.

Sneaky way for externals to get render target

Generates a mip-map chain for the specified render target. This will generate mipmaps for the color texture of the render target.

Generates a mip-map chain for the specified texture. This will generate mipmaps for the color texture of the texture.

Draws text within a rectangle using a prepared .

The text rendering scope. The rectangle to draw the text in. Text alignment flags (optional).

Render a with the specified overrides.

Renders the view from a camera to the specified render target.

Render a planar reflection using the specified camera and the specified plane.

Render a planar refraction using the specified camera and the specified plane. This is for all intents and purposes a regular view with a plane clipping it. Usually used for rendering under water.

The color texure we're currently rendering to

The depth texture we're currently rendering to

Will set the named combo to 1 if MSAA is active, otherwise 0.

2D Drawing functions for a . HudPainter provides a set of methods for drawing shapes, textures, and text onto a command list, typically for HUD or UI rendering.

The underlying used for rendering.

Initializes a new instance of the struct for the specified .

The command list to draw to. Must not be null.

Sets the blend mode for subsequent drawing operations.

The blend mode to use.

Sets the transformation matrix for subsequent drawing operations.

The transformation matrix to apply.

Draws a filled circle at the specified position and size.

The center position of the circle. The size (diameter) of the circle. The color of the circle.

Draws a rectangle with optional corner radius and border.

The rectangle to draw. The fill color of the rectangle. The radius for each corner (optional). The width of the border for each edge (optional). The color of the border (optional).

Draws a texture in the specified rectangle with a white tint.

The texture to draw. The rectangle to draw the texture in.

Draws a texture in the specified rectangle with a tint color.

The texture to draw. The rectangle to draw the texture in. The tint color to apply to the texture.

Draws text at a 3D point with the specified size, color, and alignment flags.

The text to draw. The font size. The color of the text. The 3D point to draw the text at. Text alignment flags (optional).

Draws text within a rectangle with the specified size, color, and alignment flags.

The text to draw. The font size. The color of the text. The rectangle to draw the text in. Text alignment flags (optional).

Draws text at a 3D point using a prepared .

The text rendering scope. The 3D point to draw the text at. Text alignment flags (optional).

Draws text within a rectangle using a prepared .

The text rendering scope. The rectangle to draw the text in. Text alignment flags (optional).

Draws a line between two points with the specified width and color.

The start point of the line. The end point of the line. The width of the line. The color of the line. Optional corner flags for line end caps.

A render target handle used with CommandLists

Reference to the color texture of this target

Reference to the depth texture of this target

Reference to the index of the color texture of this target

Reference to the size of the texture

When manually rendering a camera this will let you override specific elements of that render. This means you can use most of the camera's properties, but override some without disturbing the camera itself.

Overrides the camera's position and rotation

Overrides the camera's field of view

Overrides the camera's znear

Overrides the camera's zfar

Overrides the camera's clear color

Overrides the camera's projection matrix

Allows overriding gradient fog for this view

If set then the regular scene's ambient light will be multiplied by this

If set then this will be added to the ambient light color

Clipspace is usually used for rendering posters, or center-offsetting the view. You're basically zooming into a subrect of the clipspace. So imagine you draw a smaller rect inside the first rect of the frustum.. that's what you're gonna render - that rect.

When rendering to a texture, this allows you to flip the view horizontally.

When rendering to a texture, this allows you to flip the view vertically.

Whether post processing should be enabled for this view. If null it will use the camera's setting.

If you're rendering a subview this will allow the renderer to find the same view again next frame

Setup for defining gradient fog in a view

Whether the fog is enabled.

Start distance of the fog.

End distance of the fog.

The starting height of the gradient fog.

The ending height of the gradient fog.

The maximum opacity of the gradient fog.

The color of the gradient fog.

The exponent controlling the distance-based falloff of the fog.

The exponent controlling the vertical falloff of the fog.

Lerp this GradientFogSetup to a another, allowing transition states.

Allows special setup for reflections, such as offsetting the reflection plane

Allows overriding everything you normally can

Offset the reflection plane's clip plane by this much

If true we'll render the reflection even if we're behind the plane

If we can't render the reflection and this is set, we'll clear the render target to this color

Allows special setup for refraction, such as offsetting the clip plane

Allows overriding everything you normally can

Offset the reflection plane's clip plane by this much

If true we'll render the reflection even if we're behind the plane

If we can't render the reflection and this is set, we'll clear the render target to this color

When manually rendering a Renderer this will let you override specific elements of that render. This means you can use most of the Renderer's properties, but override some without disturbing the Renderer itself.

Overrides the transform used for rendering

Overrides the color used for rendering

Overrides the material used for rendering

Managed clustered light culling layer. Builds clustered light, envmap, and decal lists for the frame.

This layer does not need to store the results of its color target rendering

This layer does not need to store the results of its depth/stencil rendering

Similar to FullSort, but instead of using depth (or custom sort key), use default sorting

Any layer marked IsDepthRenderingPass is subject to ShouldOverrideDepthMaterial. Setting this disables ShouldOverrideDepthMaterial for depth rendering.

Use pyramid geometry for light rendering instead of cone geo. Don't restrict to geometry

Configures the lightbinner to react to mat_fullbright and more

Captures frames for screenshots and video recording.

Draws a red rectangle border around the screen when recording.

ISceneLayer which is basically a render pass

Maybe we just call this RenderPass like every other engine.

Renders all matching scene objects with this shader mode if applicable

Scene objects must have these flags to be included in the layer

Scene objects with these flags will be excluded from the layer

Deferred render target attributes

Add to view

Passing viewport here might not be what we want

A render layer with a callback

Start moving the c++ render pipeline here It won't be the prettiest to start, but we can start simplifying afterwards

Called once a view has been submitted, which means the entire render pipeline has executed and we don't need the object anymore.

Layer configuration for the 3D skybox rendering pipeline.

Static entry point called from C++ when setting up the 3D skybox view.

Adds 3D skybox layers to the view.

Lightbinner layer for the 3D skybox.

Depth prepass layer for the 3D skybox.

Forward opaque layer for the 3D skybox.

Translucent forward layer for the 3D skybox.

Used to describe a GPU resources state for barrier transitions.

There are intended to be a high level generic of resource states that can be translated to any lower level graphics APIs. (VK/D3D12/Metal)

Not rendered in cubemaps

ShadowMapper It is owned by a CLightBinnerStandard in c++ which are pooled and reinitialized with CLightBinnerStandard::InitForView We then also get called by CLightBinnerStandard::UploadLightingToGPU

Lifetime counters for tracking texture allocation health. Created - Disposed should equal cache + pool + in-flight at any point. If in-flight grows indefinitely, textures are being orphaned.

Called as we submit display lists, upload our shadow map buffers.

How long a texture sits unused in the cache before being evicted and returned to the pool.

How long a texture sits unused in the pool before being disposed.

Evict shadow maps from lights that haven't been rendered recently, and dispose pooled textures that have sat idle for too long.

Called when a light is removed from the scene. Returns its shadow map to the pool.

Computes a per-light bias scale factor based on the shadow frustum's texel size. Wider cones and larger ranges produce bigger shadow map texels in world space, requiring proportionally more bias to prevent acne. Matches Unity URP's approach of scaling bias by frustumSize / resolution.

Find a cached shadow map or create a new one for the light and view. Returns an index to the shadow maps structured buffer

Calculates normalized [0,1] split distances for cascade shadow maps. Cascade 0 is fixed to firstCascadeSize world units from the near plane. Cascades 1+ use a logarithmic/uniform blend (PSSM) from firstCascadeSize to far.

FOV compensation for cascade shadow maps using sphere-frustum intersection. Places a unit sphere offset along the view axis based on FOV, then finds where the frustum diagonal ray intersects it. The intersection distance becomes the far plane scale factor, keeping cascade sizes stable across FOVs. Reference: Valient, "The Rendering Technology of Killzone 2", GDC 2009 https://www.guerrilla-games.com/media/News/Files/GDC09_Valient_Rendering_Technology_Of_Killzone_2_Extended_Presenter_Notes.pdf

Given a camera view frustum, computes cascade frustums into the provided span. Returns the number of cascades written.

Snaps a position to the nearest shadowmap texel to prevent view-dependent aliasing.

Find or create shadow maps for a directional light (CSM). Returns an index to the directional shadow buffer.

All projected shadows for this view

Finds a cached shadow map or creates a new one. This is for a single shadow map like a spot light

All cube projected shadows (special case)

Stupid class for native to call, instances a shadowmapper per lightbinner

Each pooled lightbinner gets a shadowmapper, use the lightbinner ptr as a handle.. probably fine There's only gonna be a handful of these

Gives global access to the texture streaming system.

Run a block of code with texture streaming disabled

This object renders every sprite registered to it in a single draw call. It takes care of sorting, sampling, and the whole pipeline regarding sprites. The SceneSpriteSystem is responsible for pushing sprites into this object depending on its properties.

Flags for sprite rendering, must match SpriteFlags in sprite_ps.shader

Create the initialize sprite mesh that will be instanced

Resizes GPU buffers to the nearest power of 2

Resizes GPU buffers to accommodate the specified allocation size

Copy host buffers onto GPU

Performs a GPU bitonic sort

Rendering logic of the sprites

Format used when creating textures.

Four 8-bit components representing RGBA.

Four 8-bit components representing ABGR.

Three 8-bit components representing RGB.

Three 8-bit components representing BGR.

Three components representing RGB. Red and blue are 5 bit components, green is 6 bit totalling 16 bits.

Single 8-bit component representing luminance.

Two 8-bit components representing luminance and alpha.

Single 8-bit component representing alpha.

Compressed texture format with no alpha.

Compressed texture format with alpha.

Compressed texture format with alpha, generally better than DXT3.

Four 16-bit float components representing RGBA.

Four 16-bit integer components representing RGBA.

Three 32-bit float components representing RGB.

Single 32-bit float component representing R.

Four 32-bit float components representing RGBA.

Represents Physics body's motion type.

Invalid type.

Physically simulated body.

Cannot move at all.

No physics simulation, but can be moved via setting position/rotation.

Extendable helper to create common gizmos

A front left up position movement widget. If widget was moved then will return true and out will return the new position.

Draw an arrow - return move delta if interacted with

Manipulate a 2d value by moving on 2 axis

Scope this before drawing a control to obey Settings.GizmoScale

A full 3d rotation gizmo. If rotated will return true and newValue will be the new rotation.

A single rotation axis

A front left up position movement widget. If widget was moved then will return true and out will return the new position.

A scalable sphere gizmo. Returns true if the gizmo was interacted with and outValue will return the new radius.

Holds fully realized controls to manipulate some value

Draw a shape using the gizmo library

Contains functions to add objects to the Gizmo Scene. This is an instantiable class so it's possible to add extensions.

The color to render the next object

Ignore depth when drawing, draw on top of everything

The thickness of line drawings

Don't draw backfaces when drawing solids

Draw a model

Draw particles. Control points will be set to the transform position.

Draw particles. Control point 0 will be set to the transform position.

Draw text

Draw text with a text rendering scope for more text rendering customization.

Draw text on screen at a 3d position

Draw text on screen at a 3d position with a text rendering scope for more text rendering customization.

Draw text at an angle

Draw a rect, on the screen

Draw a plane

Draw a line with an arrow on the end

Draws a grid

Draws a grid centered at a position

Adds a line to the current object, but also adds it as a potential hitbox

Draw a line from a to b

Draw a lines

Draw a bounding box

Draws a frustum.

Draw a sphere made out of lines

A cylinder

A triangle

Multiple triangles

Draw a solid cone shape

Draw a solid box shape

Draw a solid triangle shape

Multiple solid triangles

Draw a filled circle

Draw a filled ring

Draw a solid sphere shape

Draw a solid cylinder shape

Draw a solid capsule shape

Draws a half circle that tries its best to point towards the camera. This is used by the rotation widgets that bias towards the camera.

Draw a sprite.

Using pure primary colors is horrible. Lets make it easier to avoid.

Create a new scope - any changes to colors and transforms will be stored and reverted when exiting the scope.

Get the distance from a point on a plane

Get the mouse delta at this current position

Get the mouse drag distance at this current position, assuming we are pressed

Get the vector distance from a point on a plane

Get the distance from a point on a plane

Get the distance moved from (or towards) a position on a plane

The current cursor position, in screen space

The delta of cursor movement between this frame and last, in screen space

The delta of cursor movement between last press and now, in screen space. If left mouse isn't down, will return CursorMoveDelta

The current keyboard modifiers

Will snap this position, depending on the current snap settings and keys that are pressed. Will snap along if movement is detected along that axis. For example, if movement is 1,0,0 then we'll only snap on the x axis.

Snaps a rotation delta to angle increments.

The rotation delta to snap A snapped rotation that aligns to the angle grid

Applies snapping to a box being resized using delta tracking. Returns a properly snapped box.

The original box before resizing began The accumulated delta changes A new snapped box with proper minimum dimensions

Will give you a nudge vector along the most aligned left and up axis of the rotation based on left/right/up/down direction and camera angle

The cameras transform - in world space

The cameras transform - in local space

The input state, allows interaction with Gizmos

True if the scene is being hovered by the mouse. False if the cursor is being used somewhere else

Holds the backend state for a Gizmo scope. This allows us to have multiple different gizmo states (for multiple views, multiple windows, game and editor) and push them as the current active state whenever needed.

If true, we'll draw some debug information

If true we'll enable hitbox debugging

The SceneWorld this instance is writing to. This world exists only for this instance. You need to add this world to your camera for it to render (!)

Input state. Should be setup before push.

The previous input state

Last frame's objects that are available for reuse

This frame's created (or re-used) objects

When a new scope is pushed, we store the old one and copy it to this. When it's disposed we restore this to the old one. This is the currently active scope.

Holds the current hitbox line scope status

The current control mode. This is generally implementation specific. We tend to use "mouse" and "firstperson".

Some global settings accessible to the gizmos. Your implementation generally lets your users set up these things to their preference, and the gizmos should try to obey them.

Generic storage for whatever you want to do. You're responsible for not spamming into this and cleaning up after yourself.

Called when the scene changes and we don't want to inherit a bunch of values. We might want to just target some specific values here instead of clearing the log.

how long the previous loop took, in milliseconds

To handle multiple viewports, so we keep track of which viewport is being pressed.

Destroy this instance, clean up any created resources/scene objects, destroy the world.

Push this instance as the global Gizmo state. All Gizmo calls during this scope will use this instance.

Called at the start of a 'frame'

Called at the end of a 'frame'

Find a cached version of this sceneobject - if not found, create one

Set all of the state's cursor positions to this value. This stomps previous values which will effectively clear any deltas. This should be used prior to starting a loop.

Access to the currently pressed path information

The ray representing the cursor direction

True if the current gizmo scope is pressed

True if any object is currently pressed

The distance the cursor has travelled since press started

The cursor position at the start of the press

True if press is active. This generally means that the left mouse button is down

How do we want to edit this? Usually something like "position", "rotation", "scale" etc

Do we want to let the user select things in the current mode?

What is the current view mode? 3d, 2d, ui?

Are gizmos enabled?

How big to show the gizmos

Grid spacing

Snap positions to the grid

Snap angles

Grid spacing

Editing in local space

Should we show lines representing GameObject references in action graphs?

Which gizmos are disabled

Check if a gizmo type is enabled

Set the enabled state of a gizmo type

Clear all enabled gizmos

Whenever Gizmo.State is called, this is copied, stored and restored. This should hold whatever data is important to reset at the end of a scope. We should be really careful not to fill this with too much shit.

Allows creating a gizmo hitbox which will be interactable using the mouse (or vr deck2 super controller)

Contains functions to add objects to the immediate mode Scene. This is an instantiable class so it's possible to add extensions.

Whether or not drawn gizmos can be interacted with. Only affects gizmos in the current scope.

If this distance is closer than our previous best, this path will become the hovered path

A sphere hitbox

A bounding box hitbox

A 2d circle hitbox, on a plane

A model hitbox

A 2d sprite hitbox

Start a line scope. Any drawn lines should become a hitbox during this scope.

If we're in a hitbox linescope we'll distance this test vs the current ray. If not, we'll return immediately. This is automatically called when rendering lines

Draws anything

Debug grid overlay for visualizing probe positions.

Draws text in screenspace

this argument is short sighted and stupid, don't keep using it

Draws a vertex object. Lines or solids usually.

Default model archetypes. These types are defined in "tools/model_archetypes.txt".

A static model. It can still have collisions, but they do not have physics.

Animated model. Typically no physics.

A generic physics enabled model.

A ragdoll type model.

A physics model that can be broken into other physics models.

A generic actor/NPC model.

Internal, used to add multi level key-values.

Add generic key-values to the helper.

Internal name of the key that dictates which bone to use as parent for position/angles.

Internal name of the key that dictates which attachment to use as parent for position/angles.

Internal name of the key to store position in, if set, allows the helper to be moved.

Internal name of the key to store angles in, allows the helper to be rotated.

Indicates that this class/struct should be available as GenericGameData node in ModelDoc

Indicates that this type compiles as list, rather than a single entry in the model. This will also affect how you retrieve this data via Model.GetData().

Draws 3 line axis visualization, which can set up to be manipulated via gizmos. You can have multiple of these.

Internal name of a boolean key that dictates whether this helper should draw or not. If unset, will draw always.

If set to true, when the node is selected a line will be drawn from the helper to the parent attachment/bone.

Draws a box, which can be manipulated via gizmos. You can have multiple of these.

If set, the semi-transparent box "walls" will not be drawn.

If set, gizmos will be shown in transform mode to quickly move/scale the box. For "dimensions" box Origin/Angles must be set.

Store the box's dimensions in a single key, acting as (maxs-mins) which assumes the box's center is at the models origin. The box's center can be set up to be movable via "Origin" property and rotatable via "Angles" property.

Internal name of a key on the node that will store the dimensions of the box.

Store the box's dimensions in 2 keys as Mins and Maxs. This type cannot be rotated.

Internal name of a key on the node that will store the mins of the box. Internal name of a key on the node that will store the maxs of the box.

Draws a sphere, which can be manipulated via gizmos. You can have multiple of these.

If set, the semi-transparent sphere "wall"/surface will not be drawn.

Draws a capsule, which can be manipulated via gizmos. You can have multiple of these.

This variation has 1 radius for both points.

This variation has independent radius for each point.

Draws a cylinder, which can be manipulated via gizmos. You can have multiple of these.

This variation has 1 radius for both points.

This variation has independent radius for each point.

A helper that draws axis of rotation and angle limit of a hinge joint.

Key name that dictates whether the hinge limit is enabled or not.

Key name that stores the minimum angle value for the revolute joint.

Key name that stores the maximum angle value for the revolute joint.

Adds a custom editor widget to the game data node. Currently only 1 option is available - "HandPosePairEditor"

A helper used for VR hand purposes.

Internal name of the key to store position in.

Internal name of the key to store angles in.

Path to a model to use.

Whether this helper represents the right hand or not. This decides the names of the bones the helper will try to use.

Text label this helper will have when hovered/selected.

Internal name of the key that controls whether this helper is visible or not.

Internal name of the key to store position in. Internal name of the key to store angles in. Path to a model to use. Whether this helper represents the right hand or not. This decides the names of the bones the helper will try to use.

Internal name of the key that dictates which bone to use as parent for start position.

Internal name of the key that dictates which attachment to use as parent for start position.

Internal name of the key to read line start position from.

Internal name of the key that dictates which bone to use as parent for end position.

Internal name of the key that dictates which attachment to use as parent for end position.

Internal name of the key to read line end position from.

Internal name of the key that controls whether this helper is visible or not.

A string formatted color for this helper. Format is "255 255 255"

The width of the line helper

Scales the vector with the "ScaleAndMirror" node, relative to associated bone.

Scales the vector with the "ScaleAndMirror" node.

Defines a single breakable prop gib.

Generic prop settings. Support for this depends on the entity.

When this model is used as prop_static, it will bake lighting by default depending on this value.

When this model is used as prop_physics, it's health will be set to this value.

If true well treat this prop as flammable, meaning it can catch fire and burn.

If true we'll explode this prop when it's destroyed

Amount of damage to do at the center on the explosion. It will falloff over distance.

Range of explosion's damage.

Scale of the force applied to entities damaged by the explosion and the models break pieces.

Minimum impact damage speed to break this object.

The amount of damage this deals to other objects when it collides at high speed. If set to -1, this will be calculated from the mass of the rigidbody.

Defines an eye on a character model.

Carries navigation related data.

During map compile this model would mark its volume as an area that should be avoided by AI.

Indicates that this type should generate meta data. Tagging your asset with this will mean that the .asset file is automatically generated - which means you don't have to do that.

Overrides the auto generated FGD type.

The FGD type override. The name of a custom editor to use for this property. Arguments for given editor override. Format depends on each editor.

Allows you to specify a string property as a resource type. This will give the property a resource finder. Type should be the file extension, ie "vmdl"

This choices type is bitflags, so we should be able to choose more than one option at a time.

TODO: Once this is no longer used in assets it can be deleted. It should be derived from [System.Flags]

When added to a string property, will becomes a selector for AssetTypeExtension

When added to a string property, will become an image string selector

When added to a string property, will become a file picker for the given extension (or all by default)

The extension to filter by. If empty, all files are shown. Can be a comma separated list of extensions, or a single extension.

When added to a string property, will allow selection of anything that a Texture can be

When added to a string property, will become a map string selector

Utility class to make random outfits for the avatar. Uses a predefined set of groups and chances.

Describes an item of clothing and implicitly which other items it can be worn with

Model to replace the human skin with

Replace skin with this

Bodygroup on the model to choose

Allows adding tags for this skin, ie "female". This affects which alternative clothing models are used with it.

Name of the clothing to show in UI.

A subtitle for this clothing piece.

What kind of clothing this is?

A list of conditional models. (key) = tag(s), (value) = model

Tries to get the model for this current clothing. Takes into account any conditional model for other clothing.

This should be a single word to describe the subcategory, and should match any other items you want to categorize in the same bunch. The work will be tokenized so it can become localized.

The clothing to parent this too. It will be displayed as a variation of its parent

The model to bonemerge to the player when this clothing is equipped.

The model to bonemerge to the human player when this clothing is equipped.

Replace the skin with this material

Replace the eyes with this material

Which material group of the model to use.

Do we need to lift the heel up?

Which slots this clothing takes on "inner" layer.

Which slots this clothing takes on "outer" layer.

Which body parts of the player model should not show when this clothing is equipped.

The Steam Item Definition ID for this clothing item, if it's an inventory item

Can we wear this item?

Return true if this item of clothing can be worn with the target item, at the same time.

Icon for this clothing piece.

Dress this sceneobject with the passed clothes. Return the created clothing.

Is this just a SteamItemDefinitionId. Usually created in the avatar editing scenario.

Holds a collection of clothing items. Won't let you add items that aren't compatible.

A direct reference to the clothing item

If this is a Steam Inventory Item then this is the item definition id. This usually means we'll look up the clothing item from the workshop.

Used to select a tint for the item. The gradients are defined in the item.

If this item is manually placed, this is the bone we're attached to

If this item is manually placed, this is the offset relative to the bone

A user set name for this setup

The avatar's height. Default is 0.5f.

The avatar's age. Default is 0.0f. We'll pick a skin based on this.

For the citizen the skin color is dynamic, based on a gradient. This is 0-1.

If true, this avatar prefers to use a human model when possible

A list of clothing items the avatar is wearing

Restrict things like Height to their sensible limits

Add a clothing item if we don't already contain it, else remove it

Add clothing item

Add clothing items

Find a clothing entry matching this clothing item

Remove clothing item

Returns true if we have this clothing item

Return a list of bodygroups and what their value should be

Serialize to Json

Deserialize from Json

Used for serialization

The resource path of this item. This means it's on disk somewhere.

Legacy integer resource ID from before path-based serialization. Kept for backwards compatibility when reading old saved avatars.

The Steam Inventory Item Definition Id. This means we should look up the item from the workshop.

Tint variable used to evaluate the model tint color gradient

Create the container from json definitions

Create the container from the local user's setup

Create the container from a connection's avatar, filtered to only items they are verified to own.

Removes any clothing items that require Steam inventory ownership but the local user doesn't own.

Removes clothing items that the given connection is not verified to own.

Dresses a skinned model with an outfit. Will apply all the clothes it can immediately, then download any missing clothing.

Dress a skinned model renderer with an outfit. Doesn't download missing clothing.

Clear the outfit from this model, make it named

Some metadata we'll pack into a workshop submission when publishing.

Returns true if this friend is the local user

The friend's Steam Id

The friend's name

Returns true if your friend is online

Returns true if this user is your friend

Returns true if your friend is away

Returns true if this friend is marked as busy

Returns true if this friend is marked as snoozing

Returns a string that was possibly set by rich presence

Returns true if they're playing this game

Returns true if they're playing any game

Opens the Steam overlay web browser to their user profile.

Opens the Steam overlay with a popup that allows the local Steam user to confirm whether to add this user to their Steam friends list.

A value between 0 and 1, to show a progress bar

The current transfer rate in Megabits per second. 0 is none.

Delta multipled by 100

The total size of what we're trying to download

A that has been marked with This is stored as project metadata so we can set up a game without loading it.

Configuration of a .

The directory housing this addon (TODO)

The human readable title, for example "Sandbox", "Counter-Strike"

The type of addon. Current valid values are "game"

The ident of the org that owns this addon. For example "facepunch", "valve".

The ident of this addon. For example "sandbox", "cs" or "dm98"

Type of the package.

Returns a combination of Org and Ident - for example "facepunch.sandbox" or "valve.cs".

The version of the addon file. Allows us to upgrade internally.

If true then we'll include all the source files

A list of paths in which to look for extra assets to upload with the addon. Note that compiled asset files are automatically included.

A list of packages that this package depends on. These should be installed alongside this package.

A list of packages that this package uses but there is no need to install. For example, a map package might use a model package - but there is no need to download that model package because any usage will organically be included in the manifest. However, when loading this item in the editor, it'd make sense to install these 'cloud' packages.

A list of mounts that are required

Contains unique elements from , along with any implicit package references. An example implicit reference is the parent package of an addon.

Whether or not this project is standalone-only, and supports disabling the whitelist, compiling with /unsafe, etc.

Custom key-value storage for this project.

Serialize the entire config to a JSON string.

Try to get a value at given key in .

Type of the value. The key to retrieve the value of. The value, if it was present in the metadata storage. Whether the value was successfully retrieved.

Get the package's meta value. If it's missing or the wrong type then use the default value.

Store custom data at given key in the .

The key for the data. The data itself to store. Always true.

Provides global access to core game state, utilities, and operations for S&box. The class exposes static properties and methods to query and control the running game, such as checking if the game is running, getting your steamid, taking screenshots, and managing game sessions.


            // Check if the game is running in the editor
            if (Game.IsEditor)
            {
                // Perform editor-specific logic
            }


            // Take a screenshot
            Game.TakeScreenshot();

The input context for this context (menu, gamemenu, client)

Steam AppId of S&box.

Return true if we're in a game (ie, not in the main menu)

Returns true if the game is running with the editor enabled

Returns the current game's ident - ie facepunch.sandbox

Returns true if the main menu is visible. Note that this will work serverside too but will only return the state of the host.

True if we're currently recording a video (using the video command, or F6)

Set to true when the game is closing

Return true if we're running in VR

Return true if we're running on a handheld device (the deck). Will always be false serverside.

A shared random that is automatically seeded on tick

Set the seed for Game.Random

Your SteamId

Create a limited web surface

Disconnect from the current game session

Trace against the physics in the current scene

Trace against the physics and hitboxes in the current scene

Close the current game.

Load a game. You can configure the new game with LaunchArguments before calling this.

Capture a screenshot. Saves it in Steam.

Capture a high resolution screenshot using the active scene camera.

This has to be in Game.dll so the codegen will get generated for it

Provides access to the global for the current game context. The TypeLibrary is a runtime reflection system that describes types, their members, and relationships in the game and engine assemblies. It allows you to find and create types by name and id. It's basically a sandboxed version of the .net reflection system.

Allows access to the cookies for the current game. The cookies are used to store persistent data across game sessions, such as user preferences or session data. Internally the cookies are encoded to JSON and stored in a file on disk.

Lets you get translated phrases from the localization system

A library of node definitions for action graphs.

Returns true only when current code is running in the menu.

Provides static methods for displaying various modal overlays in the game UI. The class allows you to open modals for packages, maps, news, organizations, reviews, friends lists, server lists, settings, input bindings, and player profiles. It serves as a central point for invoking user interface overlays that interact with core game and community features.


             // Show a modal for a specific game package
             Game.Overlay.ShowGameModal("facepunch.sandbox");
            
             // Check if any overlay is currently open
             if (Game.Overlay.IsOpen)
             {
                 // Pause game logic or input
             }

Opens a modal for the specified game package

Opens a modal for the specified map package

Opens a modal for the specified package

Opens a modal for the specified package on the specified page

Opens a modal for the news item

Opens a modal for the specified organization. This is most likely called from a Package - so get the organization from there.

Opens a modal to review the specified package

Opens a modal for selecting a package

Opens a modal that shows the user's friends list

Opens a modal that shows a list of active servers

Opens a modal that lets you modify your settings Optionally, you can specify a page to open directly to: "keybinds", "video", "input", "audio", "game", "storage", "developer"

Opens a modal that lets you view and rebind game input actions.

Opens a modal to create a game with a bunch of settings. We use this in the menu when you click "Create Game" and the game has options.

View a selected user's profile

Open a modal that shows a list of players currently in the game

Open a modal that prompts the user to publish content to the workshop

Opens the pause menu overlay. This is the same menu that appears when pressing ESC.

Closes the top overlay if one exists

Close all open overlays

If , will skip any outros

Returns true if any overlay is open

Returns true if the pause menu overlay is open

Indicates whether the game is currently running and actively playing a scene.

Indicates whether the game is currently paused.

The current scene that is being played.

Change the active scene and optionally bring all connected clients to the new scene (broadcast the scene change.) If we're in a networking session, then only the host can change the scene.

The to use which also specifies which scene to load. Whether the scene was changed successfully.

Todo: make internal - the only thing using ir right now is the binds system

Called after all loading is done, right before we enter the game

True after the game is fully loaded

These are arguments that were set when launching the current game. This is used to pre-configure the game from the menu

The map to start with. It's really up to the game to use this

Preferred max players for multiplayer games. Used by games, but not enforced.

Default privacy for lobbies created on game start.

The game settings to apply on join. These are a list of convars.

The hostname for the server.

Should be called when leaving a game to set the properties back to default. We need to be aware and prevent these leaking between games.

Holds metadata and raw data relating to a Saved Game.

A title to show

A subtitle to show

A URL or filepath to show as the background image.

A list of tasks that are currently being awaited during loading.

Called by the scene system to tell us about the loading tasks

A class to orchestrate lobbies, globally.

A low level list of lobbies we're in

Note there's not a callback for this afaik, so we call this manually

The world physics objects

The world geometry;

Holds key values for the map object

Create an object from a serialized object entry

Load the assemblies and collect sources. That's all.

Get information about all the current mounts

Get a specific mount by name

Mount this game if we can. Returns null if it can't be mounted, or the mount object if it can. If we're already mounted, will just return the mount straight away.

Set mounted or not mounted. Called by user via editor.

If /mount/{x}/assets exists, add it to our filesystem

Information about a single mount

A short, lowercase string that will be used to uniquely identify this asset source

The display name of this

Is this source available, is this game installed? Can we mount it?

Is this active and mounted?

Find a ResourceLoader by its mount path.

Create a preview texture for the given resource loader.

A scoped builder for creating prefabs within a Mount. Typically used inside a implementation.

Set the name/resource path of the resulting prefab. The root name is derived from the filename portion if left unchanged.

Enter a temporary scene scope. GameObjects created inside will become part of this prefab.

Serialize the scene content into a registered . Call after you've created any objects and the has been disposed.

Unregister and destroy a created by . Call from when a mount is disabled.

Disposable scope that manages a temporary scene for .

Creates a from a DDS byte buffer.

Raw DDS file contents. A with mips.

Erodes the walkable area within the heightfield by the specified radius.

The radius of erosion in voxels The compact heightfield to erode True if the operation completed successfully

Applies a median filter to walkable area types (based on area id), removing noise.

The compact heightfield to filter True if the operation completed successfully

Clamps bounds to the heightfield grid, converting from world to grid coordinates

False if the bounds are completely outside the heightfield

Checks if a point is contained within a polygon

Marks areas in the heightfield that are within a convex polygon

Marks areas in the heightfield that are within an oriented box

Marks areas in the heightfield that are within a capsule

Marks areas in the heightfield that are within a sphere

The tiles x position in tile coordinates.

The tiles y position in tile coordinates.

The width/height size of tile's on the xy-plane. [Limit: >= 0] [Units: vx]

The size of the non-navigable border around the heightfield. [Limit: >=0] [Units: vx]

The xz-plane cell size to use for fields. [Limit: > 0] [Units: wu]

The y-axis cell size to use for fields. [Limit: > 0] [Units: wu]

The bounds of the field's AABB. [Units: wu]

The maximum slope that is considered walkable. [Limits: 0 <= value < 90] [Units: Degrees]

Minimum floor to 'ceiling' height that will still allow the floor area to be considered walkable. [Limit: >= 3] [Units: vx]

Maximum ledge height that is considered to still be traversable. [Limit: >=0] [Units: vx]

The distance to erode/shrink the walkable area of the heightfield away from obstructions. [Limit: >=0] [Units: vx]

The maximum allowed length for contour edges along the border of the mesh. [Limit: >=0] [Units: vx]

The maximum distance a simplified contour's border edges should deviate the original raw contour. [Limit: >=0] [Units: vx]

The minimum number of cells allowed to form isolated island areas. [Limit: >=0] [Units: vx]

Any regions with a span count smaller than this value will, if possible, be merged with larger regions. [Limit: >=0] [Units: vx]

The maximum number of vertices allowed for polygons generated during the contour to polygon conversion process. [Limit: >= 3]

A contour representing a simplified region boundary. Vertices are stored as packed int4 (x, y, z, flags). Instances are pooled by ContourBuilderContext for reuse.

Merge contour cb into ca at the specified vertex indices. Uses provided buffer list to avoid allocations.

Scratch buffer for MergeContours to avoid allocations.

Pool of Contour instances for reuse. Contours are rented via RentContour() and returned to pool when ClearContourSet() is called at the start of BuildContours.

Rent a contour from the pool, sized for the given vertex count.

Return all contours in ContourSet to the pool and clear the set. Called at the start of BuildContours to recycle previous contours.

@par The raw contours will match the region outlines exactly. The @p maxError and @p maxEdgeLen parameters control how closely the simplified contours will match the raw contours. Simplified contours are generated such that the vertices for portals between areas match up. (They are considered mandatory vertices.) Setting @p maxEdgeLength to zero will disabled the edge length feature. See the #rcConfig documentation for more information on the configuration parameters. @see rcAllocContourSet, CompactHeightfield, ContourSet, rcConfig

Flat span record stored per column (sorted by MinY).

Adds (and merges) a span into a column. Disallowed after compression.

Builds a compact heightfield from current spans. Auto-compresses if not already compressed.

Marks walkable triangles based on slope angle

The polygon vertices. [Size: 3 * #nverts]

The polygon indices. [Size: 2 * #npolys * nvp]

The area id assigned to each polygon. [Size: #npolys]

Edge hash map using parallel arrays with separate chaining. Enables O(1) lookup of polygon edges for merge candidate search.

Builds a polygon mesh from a contour set.

Finds the best pair of polygons to merge (longest shared edge that preserves convexity).

Checks if two polygons can be merged along a shared edge while preserving convexity.

Computes the squared length of an edge (used for merge priority).

Divides a convex polygon of max 12 vertices into two convex polygons across a separating axis

Rasterize a single triangle to the heightfield

Rasterizes triangles to the heightfield using vertex and index arrays

Reusable context for region building. Cache and reuse to avoid allocations.

Applies (in-order per span): 1. Low-hanging obstacle promotion 2. Low-ceiling (clearance) rejection 3. Ledge / steep slope rejection Single pass over the heightfield to improve cache locality.

Navigation Mesh - allowing AI to navigate a world

Core baking logic without editor dependencies. Used by BakeDataAsync and tests.

Bakes the navmesh tile data to a byte array. Returns null if there are no tiles to bake. Used internally by BakeData and for testing.

Loads navmesh tile data from a byte array. Used internally by LoadFromBake and for testing.

Waits for all in-progress heightfield builds to complete. This ensures we snapshot a consistent state before baking.

Determines wether the navigation mesh is enabled and should be generated

The navigation mesh is generating

The navigation mesh is dirty and needs a complete rebuild

Should the generator include static bodies

Should the generator include keyframed bodies

Don't include these bodies in the generation

If any, we'll only include bodies with this tag

Skip tile generation during scene load. Tiles can then be generated on demand via , , etc.

By Default , the navmesh will calculate bounds based on the world geometry, but if you want to override that, you can set custom bounds here.

The bounds to generate the navmesh within. Won't take effect until regenerated or reloaded.

Constantly update the navigation mesh in the editor

Draw the navigation mesh in the editor

Height of the agent

The radius of the agent. This will change how much gap is left on the edges of surfaces, so they don't clip into walls.

The maximum height an agent can climb (step)

The maximum slope an agent can walk up (in degrees)

The xz-plane cell size to use for fields. [Limit: > 0] [Units: wu]

The y-axis cell size to use for fields. [Limit: > 0] [Units: wu]

The width/height size of tile's on the xy-plane. [Limit: >= 0] [Units: vx]

Set the navgiation a dirty, so it will rebuild over the next few frames. If you need an immediate rebuild, call instead.

Implement this interface to receive navmesh editor events.

Called when an area definition has changed or loaded/created.

Generates or regenerates the navmesh tile at the given world position. This function is thread safe but can only be called from the main thread.

While most of the generation happens in parallel, this function also requires some time on the main thread. If you need to update many tiles, consider spreading the updates accross multiple frames.

Generates or regenerates the navmesh tiles overlapping with the given bounds. This function is thread safe but can only be called from the main thread.

While most of the generation happens in parallel, this function also requires some time on the main thread. If you need to update many tiles, consider spreading the updates accross multiple frames.

Removes the navmesh tile at the given world position.

Removes all navmesh tiles overlapping with the given bounds.

Queues the navmesh tile at the given world position for incremental generation over subsequent frames. Fire-and-forget alternative to .

Queues all navmesh tiles overlapping with the given bounds for incremental generation over subsequent frames. Fire-and-forget alternative to .

Computes a navigation path between the specified start and target positions on the navmesh. Uses the same pathfinding algorithm as , taking agent configuration into account if provided. The result is suitable for direct use with . If a complete path cannot be found, the result may indicate an incomplete or failed path.

Get a random point on the navmesh, within the bounding box. This will return null if it can't find a point on the navmesh in a few tries. Returning false doesn't mean it's impossible, our algorithm here isn't the best.

Get a random point on the navmesh, within the sphere. This will return null if it can't find a point on the navmesh in a few tries. Returning false doesn't mean it's impossible, our algorithm here isn't the best.

The relative path to the baked navdata file (without _c suffix)

Get the navdata filename for this scene

Data saved in a Scene file

Data loaded from a Scene file

Returns true if any tile has an in-progress heightfield or navmesh build. Used to wait for a stable state before baking.

Defines the input for a pathfinding request on the navmesh.

Start position of the path, should be close to the navmesh.

Target/End position of the path, should be close to the navmesh.

Optional agent whose configuration is used for path calculation.

Contains the result of a pathfinding operation.

The outcome of the path calculation.

True if a path was found.

Polygons traversed by the path. Internal for now as you cannot do anything with polygon ids yet.

Points along the path.

Start location was not found on the navmesh.

Target location was not found on the navmesh.

No path could be found.

Path found, but does not reach the target. The returned path will be to the closest location that can be reached.

Path found from start to target.

Represents a point in a navmesh path, including its position in 3D space. May be extended in the future to hold more information about the point.

True if the cached heightfield originates from baked data rather than live geometry.

A Party. A Party with your friends.

The unique identifier of this lobby

The server this party is playing on, if any. This is set by the owner of the party, and read by clients to know where to connect to.

The name of this lobby.

The maximum number of members allowed in this lobby.

The current number of members in this lobby.

Set the owner to someone else. You need to be the owner

Allow communication via voice when in the main menu.

Voice data has been recieved. Send it to everyone.

Determine our state to be sent to other party members

A list of members in this room

What package is this party's owner playing?

Called each frame that a client wants to broadcast their voice

Called when we join a party.

Called when we leave a party.

A lobby member has sent a chat message.

A lobby member has sent a voice packet.

A lobby member has joined.

A lobby member has left.

Kick a member from the lobby. Only the owner can kick members.

Used by party members to know when to preload the game package, and when to connect to the party leader's server.

The current join state of the owner of the party

Wait for the background preload to finish, then connect to the server.

Start downloading the game package in the background so it's ready by the time the host signals we can connect.

Holds information about the current user's preferences.

The user's preference for their field of view

The user's preferred Music volume, as set in the options, clamped between 0 and 1

The user's preferred VOIP volume, as set in the options, clamped between 0 and 1

The mouse sensitivity

Activity Feed

Allows access to stats for the current game. Stats are defined by the game's author and can be used to track anything from player actions to performance metrics. They are how you submit data to leaderboards.

Delay automatic achievement unlocks for this many seconds. Useful when loading etc.

Stats for the current map

Get an auth token, which can be passed to the backend

Get a Steam authentication ticket intended for a target with a particular Steam Id.

End an authentication session with a particular user.

Begin an authentication session with a particular user, using the ticket they provided you.

Cancel an authentication ticket from a handle obtained by .

Called to start a benchmark

Set a custom metric, like load time, shutdown time etc

Called to close a benchmark off

Should be called in update every frame

Finish this benchmark session and send it off to the backend

The value below which 5% of the samples fall (the 5th percentile).

The value below which 95% of the samples fall (the 95th percentile).

The value below which 99% of the samples fall (the 99th percentile).

The value below which 99.9% of the samples fall (the 99.9th percentile).

This is the sum of all samples that exceeded the stuttering threshold. May not be very useful for non time based samples.

Calculates the specified percentile value from the collected samples.

The percentile to compute (a value between 0 and 100). For example, passing 95 computes the 95th percentile. The value below which the given percentage of samples fall.

Calculates the sum of all samples that exceeded the stuttering threshold. A sample is considered stuttering if it exceeds the moving average multiplied by the stuttering factor.

The multiplier used to determine the stuttering threshold. A higher factor makes it less sensitive to spikes (default is typically 2.5).

Activity Feed

Allows access to the Steam Inventory system

All of the items the user has in their inventory

Get the user's inventory. This is called on startup - and shouldn't really need to be called again unless the user buys something. Returns a list of items added since the last refresh.

That last serialized inventory proof for the local user, sent as part of UserInfo during connection

Returns true if we have this item

All item definitions

Find a definition by id

Wait until the items have been delievered

Describes a type of item that can be in the inventory

If we're for sale, this is our price

If we're for sale but on sale, this is our regular price

The steamid to get information about. If unset then this defaults to the current player.

The maximum entries to respond with.

global, country, friends

The group name of this board. For example, "Global" for global, "Friends" for friends.

The display name of this board, which was set in the backend.

The description of this board, which was set in the backend.

The total number of chart entries for this board.

The unit type chosen for this board

The group of entries for this board. This is usually the entries that surround the TargetSteamId.

True if this entry is for the current player.

The rank in the board

The value in the board

The value, but formatted according to Unit

The steamid of the entry

The player's display name

Center the results on this steamid, show the surrounding results with this in the middle.

Center the results on you, show the surrounding results with you in the middle.

If they have any results, include these steamids in the results - regardless of their position.

The steamid to get information about. If unset then this defaults to the current player.

The maximum entries to respond with.

The offset to start at. If less than 0, we will start from the bottom.

The total number of chart entries for this board.

If you are restructing by time period, this is the name of the period

The group of entries for this board. This is usually the entries that surround the TargetSteamId.

The rank in the board

The value in the board

The steamid of the entry

The country which this entry is from

The player's display name

The time this entry was created.

Data associated with this entry

Store the messages from the other thread so we can process them on the main thread, at an appropriate time in the loop

News Posts

Player notification

An overview of a player. Only available if their profile isn't set to private.

A json string representing how their avatar is dressed

Player profile

Package Reviews

The player who made the review

The actual content (text only right now)

The score of the review

How many seconds this user played

Date this review was updated

Implements Steamscreenshots

Writes a screenshot to the user's Steam screenshot library

This is a cleaned up version of gameserveritem_t.

Data from c++ We skip the steamid because there's some class padding fuckery going on. We pass that in manually to make life easier.

Send any pending stats to the backend. Don't wait for confirmation of ingestiom, fire and forget.

Send any pending stats to the backend, will wait until they're available for query before finishing.

Static cache of all the global stats

Get the global stats for the calling package

Get the global stats for this package

True if we're currently fetching new stats

The UTC datetime when we last fetched new stats

Make a copy of this class. Allows you to store the stats from a point in time.

Get a stat by name. Will return an empty stat if not found

Get a stat by name, returns true if found

Refresh these global stats - grab the latest values

The programatic name for this stat. This should probably be called Ident

The title of this stat, as defined on the backend

The description of this stat, as defined on the backend

The unit of this stat as defined on the backend

The change in this stat in units per hour

The current stat value

The current value formatted using Unit

The amount of players that have this stat

The maximum value

The minimum value

The average value

The sum of all values

Stats for the current map

Get the stats for the local player

Get the global stats

Add a stat value for this package

Get a stat for the local player

Static cache of all the global stats

Get the global stats for the calling package

Get the global stats for this package

Get the stats for this package

True if we're currently fetching new stats

The UTC datetime when we last fetched new stats

Make a copy of this class. Allows you to store the stats from a point in time.

Get a stat by name. Will return an empty stat if not found

Get a stat by name, returns true if found

Refresh these global stats - grab the latest values

When the stat is queued for change on the backend, we can predict its change on the front end, for achievements etc.

The programatic name for this stat. This should probably be called Ident

The title of this stat, as defined on the backend

The description of this stat, as defined on the backend

The unit of this stat as defined on the backend

The current stat value

The current value formatted using Unit

The maximum value

The minimum value

The average value

The sum of all values

The time of the last value

The last value

The time of the first value

The last value

Implements SteamUgc, lets us edit/create workshop items

A class that can be used to update a workshop file. This is inaccessible in game. Instead, use the publisher modal.

Describes money, in a certain currency

The name of the currency

The value without decimals. This is in the smallest denomination of the currency.

If running in standalone, contains the properties of the standalone game

The date and time at which the current standalone game was built

Is the current standalone game running in development mode?

The date and time at which the current standalone game was built

Represents the current standalone game's version, specified by the developer

What is the game's name?

What ident are we running under?

Game's executable name (e.g. game.exe)

The Steam App ID of the game

Game's build date, automatically set when the game was exported.

Should we automatically launch this project in VR?

Your own username

Your own user id

The service type (ie "Twitch")

Are we connected to a service

Get user information. If no username is specified, the user returned is ourself

Get user following "Who is X following"

Get user followers "Who is following X"

Start a poll with choices, save the poll id so you can end it later on

End a poll using a saved poll id, you can optionally archive the poll or just terminate it

Create a prediction to bet with channel points

Lock a current prediction with prediction id

Cancel a current prediction with prediction id

Resolve a current prediction with prediction id and choose winning outcome to pay out channel points

Send a message to chat, optionally specify channel you want to send the message, otherwise it is sent to your own chat

Clear your own chat

Ban user from your chat by username, the user will no longer be able to chat. Optionally specify the duration, a duration of zero means perm ban (Note: You have to be in your chat for this to work)

Unban user from your chat by username (Note: You have to be in your chat for this to work)

Set the game you're playing by game id

Set the language of your stream

Set the title of your stream

Set the delay of your stream

Amount of concurrent viewer your stream has.

End this poll, you can optionally archive the poll, otherwise just terminate it

Lock this prediction

Cancel this prediction

Resolve this prediction and choose winning outcome to pay out channel points

Streamer integration services

Get following "Who is following us"

Get followers "Who are we following"

Ban user from your chat, the user will no longer be able to chat. Optionally specify the duration, a duration of zero means perm ban (Note: You have to be in your chat for this to work)

Unban user from your chat, this allows them to chat again (Note: You have to be in your chat for this to work)

Create a clip of our stream, if we're streaming

Start a poll on our channel with multiple choices, save the poll so you can end it later on

Create a prediction on our channel to bet with channel points

The channel the message was sent in

Message itself

Command parameters

The user whose message it is

Hostmask of the user

Raw Command

IRCv3 tags

Create an INCOMPLETE IrcMessage only carrying username

Create an IrcMessage

IRC Command Command params User IRCv3 tags

Parses a raw IRC message into a IRCMessage.

Accessors for

Represents the curling motion of the thumb.

Represents the curling motion of the index finger.

Represents the curling motion of the middle finger.

Represents the curling motion of the ring finger.

Represents the curling motion of the pinky finger.

Represents the splaying motion between the thumb and index finger.

Represents the splaying motion between the index and middle fingers.

Represents the splaying motion between the middle and ring fingers.

Represents the splaying motion between the ring and pinky fingers.

Describes a tracked VR device

This device's grip pose transform in absolute space (centered on palm/grip)

This device's aim pose transform in absolute space (pointing forward)

Velocity in tracker space in inch/s

Angular velocity in degrees/s

Where is this device (left hand, right hand, left ankle, chest, etc.)?

What type of device is this (HMD, controller, tracker, etc.)?

The input source for this device

Handle we should use internally for performance-sensitive calls

Is this tracked device currently active (connected)?

Index we can use when referring to poses retrieved through WaitGetPose and similar functions

Update this tracked device's position, velocity, etc.

Information about a tracked device - vendor info, serial number, battery data

Which tracking system does this use (e.g. "oculus")?
Represents the value given by Prop_TrackingSystemName_String.

Who manufactured this device (e.g. "Oculus")?
Represents the value given by Prop_ManufacturerName_String.

What is this device called (e.g. "Oculus Rift S (Left Controller)")?
Represents the value given by Prop_ModelNumber_String.

Which render model should this use (e.g. "oculus_rifts_controller_left")?
Represents the value given by Prop_RenderModelName_String.

What is the serial number for this device (e.g. "1WMGH---------_Controller_Left")?
Represents the value given by Prop_SerialNumber_String.

Battery percentage from 0 to 100

If this is a controller, then represents the value given by Prop_ControllerType_String, otherwise "unknown".

Unknown device role

Represents the left hand

Represents the right hand

Represents the head

Represents a gamepad

Represents a treadmill

Represents a stylus

Represents the left foot

Represents the right foot

Represents the left shoulder

Represents the right shoulder

Represents the left elbow

Represents the right elbow

Represents the left knee

Represents the right knee

Represents the left wrist

Represents the right wrist

Represents the left ankle

Represents the right ankle

Represents the waist

Represents the chest

Represents a camera - such as a base station

Represents a keyboard

The ID was not valid.

Head-mounted display (your headset)

Tracked controllers

Generic trackers

Camera and base stations that serve as tracking reference points

Accessories that aren't necessarily tracked themselves, but may redirect video output from other tracked devices

VR overlays draw over the top of the 3D scene, they will not be affected by lighting, post processing effects or anything else in the world.
This makes them ideal for HUDs or menus, or anything else that should be local to the HMD or tracked devices. If you need something in the world, consider using WorldPanel and WorldInput instead.

Destroys this overlay.

Shows or hides the VR overlay.

Sets the transform to absolute tracking origin

Sets the rendering sort order for the overlay.

The width of the overlay quad. By default overlays are rendered on a quad that is 1 meter across.

Use to draw overlay as a curved surface. Curvature is a percentage from (0..1] where 1 is a fully closed cylinder. For a specific radius, curvature can be computed as: overlay.width / (2 PI r).

Sets the color tint of the overlay quad. Use 0.0 to 1.0 per channel. Sets the alpha of the overlay quad. Use 1.0 for 100 percent opacity to 0.0 for 0 percent opacity.

Texture that is rendered on the overlay quad.

Sets the mouse scaling factor that is used for mouse events.

Triggers a haptic event on the laser mouse controller for this overlay

The grip pose - centered on the palm/grip of the controller

The aim pose - pointing forward, suitable for aiming/pointing

Per-finger constants for curl calculation. minDistance/maxDistance define the range of tip-to-palm distances.

Tell the compositor that we're starting a frame, and reset frame state

Tell the compositor that we're ending a frame

Updates the the VR anchor based on a GameObject's transform.

Update the VR anchor based on the GameObject's transform

Updates the parameters on an on this GameObject based on the skeletal data from SteamVR. Useful for quick hand posing based on controller input.

Which to use when updating this component

Represents a controller to use when fetching skeletal data (finger curl/splay values)

The left controller

The right controller

Which hand should we use to update the parameters?

What motion range should we use to update the parameters?

Renders a device-specific model for a VR device

Represents a controller to use when fetching the model (which device)

The left controller

The right controller

Which device should we use to fetch the model?

Which model renderer should we use as the target?

Updates this GameObject's transform based on a given tracked object (e.g. left controller, HMD).

Represents tracked devices to use when updating

Retrieve data from the head-mounted display

Retrieve data from the left controller

Retrieve data from the right controller

The type of pose to track from the controller

The grip pose - centered on the palm/grip of the controller. Best for representing where the hand is holding the controller.

The aim pose - pointing forward from the controller. Best for aiming, pointing, or ray casting.

Represents transform values to update

Don't update the position or the rotation

Update the rotation only

Update the position only

Update both the position and rotation

Which tracked object should we use to update the transform?

Which pose type to use (only applies to hand controllers, not the head). Grip is centered on the palm, Aim points forward for aiming/pointing.

Which parts of the transform should be updated? (eg. rotation, position)

If this is checked, then the transform used will be relative to the VR anchor (rather than an absolute world position).

Get the appropriate VR transform for the specified and

Set the GameObject's transform based on the and

Represents a VR analog input action (e.g. trigger)

The current value of this input, from 0 to 1.

How much has changed since the last update, from 0 to 1.

Whether or not this action is currently accessible (if false, then will always be 0 and will never change).

Implicitly returns as a .

Represents a two-dimensional VR analog input action (e.g. joysticks)

The current value of this input, with both axes ranging from 0 to 1.

How much has changed since the last update, with both axes ranging from 0 to 1.

Whether or not this action is currently accessible (if false, then will always be 0 and will never change).

Implicitly returns as a .

Represents a VR digital input action (e.g. X button)

The current value of this input - true if pressed, false if not pressed.

The previous value of this input - true if it was pressed, false if it was not pressed.

How much has changed since the last update.

Whether or not this action is currently accessible (if false, then will always be false and will never change).

Implicitly returns as a .

The current relevant instance.

Get or set the player's scale in the world. If you set it to 2 the player will be twice as big.

Gets or sets where the center of the VR play area is in world space.

Returns true if SteamVR is drawing the controllers

Returns true if the left hand is dominant

Position and rotation of the Head Mounted Display in local space coordinates.

Information about the left hand input.

Information about the right hand input.

A list of available trackers.

The default motion range. Provides hand poses that either estimate or fully represent the user's hand.

Provides hand poses that estimate how the user's hand wraps around a controller, if they're using one.

Represents a physically tracked VR object with a transform

Whether or not this object is currently accessible (if false, then the transform will not update).

Local velocity of this object.

Local angular velocity of this object (degrees/s)

The grip pose transform of this tracked object in world space (centered on palm/grip). This is the default transform used for hand positioning.

The aim pose transform of this tracked object in world space (pointing forward). Use this for aiming, pointing, or ray casting.

Which part of the body this tracked object represents - waist, left shoulder, etc.

What type of object this is - tracker, controller, etc.

Represents a VR controller, along with its transform, velocity, and inputs.

The grip pose transform in world space (centered on palm/grip).

The aim pose transform in world space (pointing forward).

Is this controller currently being represented using full hand tracking?

Retrieves or creates a cached model that can be used to render this controller.

Triggers a haptic vibration event on the controller for this hand.

If a haptic event is already running it will be interrupted immediately. How long the haptic action should last (in seconds - can be 0 to "pulse" it) How often the haptic motor should bounce (0 - 320 in hz. The lower end being more useful) How intense the haptic should be (0 - 1)

Stop all vibration events on this controller.

Trigger a vibration based on a predefined . All s are normalized (start at 0, peak at 1).

The pattern to use The amount to scale the pattern's length by. The amount to scale the pattern's frequency by. The amount to scale the pattern's amplitude by.

Stops all rumble and haptic events on this controller.

The trigger input on this controller

The grip input on this controller

The primary joystick input on this controller

The primary joystick press on this controller

The primary button on this controller (Usually A, can be X for Oculus Touch)

The secondary button on this controller (Usually B, can be Y for Oculus Touch)

Returns joint data for a specific motion range.

Whether the joints returned represent a raw hand pose, or one that represents the hand wrapping around the controller.

Get the skeletal value (from 0 to 1) of a specified - includes curl and splay.

Get the skeletal value (from 0 to 1) of a specified finger curl index.

Get the skeletal value (from 0 to 1) of a specified finger splay index.

Anim param values contain any value for a limited set of types

Whether the animation graph is invalid, or has not yet loaded.

Animation graph file name.

Private constructor, use

Number of parameters in this animgraph

Get value type of parameter at given index

Get value type of parameter with the given , or if not found.

Get name of parameter at given index

Try to get parameter index at given name

Get parameter at given name

Get parameter at given index

Load an animation graph from given file.

Try to make it so only one AnimationGraph class exists for each animation graph

A weighted collection of Prefabs and Models for random selection during clutter placement.

Tile size options for streaming mode.

List of weighted entries

Size of each tile in world units for infinite streaming mode.

Gets the tile size as a float value.

Number of tiles to generate around the camera in each direction. Higher values = more visible range but more memory usage.

Represents a single weighted entry in a . Contains either a Prefab or Model reference along with spawn parameters.

Prefab to spawn. If set, this takes priority over .

Model to spawn as a static prop. Only used if is null.

Relative weight for random selection. Higher values = more likely to be chosen.

Returns whether this entry has a valid asset to spawn.

Returns the primary asset reference as a string for debugging.

Custom scene object for rendering batched clutter models. Groups instances by model type for efficient GPU instanced rendering.

Batches by model

Adds a clutter instance to the appropriate batch.

Clears all batches.

Called when the batch is deleted. Cleans up resources.

Renders all batched instances using GPU instancing.

Clutter scattering component supporting both infinite and volumes.

Infinite/streaming clutter mode

Volume/baked clutter mode - generates once within bounds

Clutter generation mode.

The clutter containing objects to scatter and scatter settings.

Seed for deterministic generation. Change to get different variations.

Clutter generation mode - Volume or Infinite streaming.

Returns true if in infinite streaming mode.

Gets the current clutter settings for the grid system.

Clears all infinite mode tiles for this component.

Invalidates the tile at the given world position, causing it to regenerate.

Invalidates all tiles within the given bounds, causing them to regenerate.

Storage for volume model instances. Serialized with component.

Layer used for rendering volume model instances.

Tracks pending tile count for progressive volume generation.

Total tiles queued for current generation.

Cancels ongoing volume generation.

Rebuilds the visual layer from stored model instances. Called on scene load and when entering play mode.

Defines who owns the generated clutter instances.

Component owns instances. Models stored in component's Storage, prefabs saved with scene. Used for volume mode.

GridSystem owns instances. Prefabs are unsaved/hidden, tiles manage cleanup. Used for infinite streaming mode.

Unified job for clutter generation.

The clutter definition containing entries and scatterer.

Parent GameObject for spawned prefabs.

Bounds to scatter within.

Random seed for deterministic generation.

Who owns the generated instances.

Layer for batched model rendering.

Tile data for infinite mode (null for volume mode).

Storage for component-owned model instances

Optional callback when job completes (for volume mode progress tracking).

Execute the generation job.

Game object clutter will be placed under this parent

Model instances organized by tile coordinate.

Batches organized by model, containing all instances across all tiles in this layer.

batches need to be rebuilt

Called when a tile has been populated with instances. Marks batches as dirty so they'll be rebuilt.

Clears model instances for a specific tile coordinate.

Adds a model instance for a specific tile.

Rebuilds all batches from scratch using all populated tiles.

Invalidates the tile at the given world position, causing it to regenerate.

Invalidates all tiles that intersect the given bounds, causing them to regenerate.

Groups multiple instances of the same model for efficient batch rendering.

The model being rendered in this batch.

List of transforms for each instance.

Adds an instance to this batch.

Clears all instances from this batch.

Immutable settings for clutter generation. Used to detect changes and configure the grid system.

Validates that settings are ready for clutter generation.

Represents a single tile in the clutter spatial grid. Tracks spawned objects for cleanup when the tile is no longer needed.

Grid coordinates of this tile.

World-space bounds of this tile.

Random seed offset for deterministic generation.

Whether this tile has been populated with clutter instances.

GameObjects spawned from prefab entries.

Represents a single clutter instance to be spawned.

Base class to override if you want to create custom scatterer logic. Provides utility methods for entry selection and common operations.

Generates clutter instances for the given bounds. The Random property is initialized before this is called.

World-space bounds to scatter within The clutter containing objects to scatter Scene to use for tracing (null falls back to Game.ActiveScene) Collection of clutter instances to spawn

Public entry point for scattering. Creates Random from seed and calls Generate().

World-space bounds to scatter within The clutter containing objects to scatter Seed for deterministic random generation Scene to use for tracing (required in editor mode) Collection of clutter instances to spawn

Generates a hash from all serializable fields and properties using TypeLibrary. Override this if you need custom hash generation logic.

Selects a random entry from the clutter based on weights. Returns null if no valid entries exist.

Creates a rotation aligned to a surface normal with random yaw.

Helper to perform a ground trace at a position.

Generates a deterministic seed from tile coordinates and base seed. Use this to create unique seeds for different tiles.

Calculates the number of points to scatter based on density and area. Caps at maxPoints to prevent engine freezing.

Bounds to scatter in Points per square meter Maximum points to cap at (default 10000) Number of points to generate

Scale range for spawned objects.

Points per square meter. 0.05 = sparse trees, 0.5 = dense grass.

Maps an clutter entry to a slope angle range.

Minimum slope angle (degrees) for this entry.

Maximum slope angle (degrees) for this entry.

Which clutter entry to use for this slope range.

Scatterer that filters and selects assets based on the slope angle of the surface. Useful for placing different vegetation or rocks on flat vs steep terrain.

Scale range for spawned objects.

Points per square meter (density).

Offset from ground surface.

Align objects to surface normal.

Define which entries spawn at which slope angles.

Use random clutter entry if no slope mapping matches.

Finds an entry that matches the given slope angle based on mappings.

Maps a terrain material to a list of clutter entries that can spawn on it.

The terrain material to match.

Indices of clutter entries that can spawn on this material.

Scatterer that selects assets based on the terrain material at the hit position. Useful for placing different vegetation on different terrain textures (grass, dirt, rock, etc).

Scale range for spawned objects.

Points per square meter (density).

Offset from ground surface.

Align objects to surface normal.

Apply random rotation around vertical axis.

Define which entries spawn on which terrain materials.

Use random clutter entry if no material mapping matches or no terrain is present.

Cached terrain reference to avoid repeated GetComponent calls within same tile.

Gets the Terrain component from a trace result, with caching.

Finds an entry that matches the terrain material at the given position.

Game object system that manages clutter generation. Handles infinite streaming layers and executes generation jobs.

Mapping of clutter components to their respective layers

Storage for painted clutter model instances. Serialized with the scene - this is the source of truth for painted clutter.

Layer for rendering painted model instances from Storage. This is transient - rebuilt from Storage on scene load.

Check for new terrains, queue generation/cleanup jobs, and process pending jobs.

Queues a generation job for processing.

Removes a tile from pending set (called when tile is destroyed).

Clears all tiles for a specific component.

Invalidates the tile at the given world position for a component, causing it to regenerate.

Invalidates all tiles within the given bounds for a component, causing them to regenerate.

Invalidates all tiles within the given bounds for ALL infinite clutter components. Useful for terrain painting where you want to refresh all clutter layers.

Paint instance. Rebuilds on next frame update. Models are batched, Prefabs become GameObjects.

Erase instances. Rebuilds on next frame update. Erases both model batches and prefab GameObjects.

Clears all painted clutter (both model instances from storage and prefab GameObjects). Does not affect clutter owned by ClutterComponent volumes.

Flush painted changes and rebuild visual batches immediately.

Rebuild the painted clutter layer from stored instances in Storage.

Manages storage and serialization of painted clutter instances. Uses binary serialization via BlobData for efficient storage.

Gets the total number of instances across all models.

Gets all model paths that have instances.

Gets instances for a specific model path.

Gets all instances grouped by model path.

Adds a single instance for a model.

Adds multiple instances for a model.

Erases all instances within a radius of a position.

Clears all instances for a specific model.

Clears all instances.

Serialize to binary format.

Deserialize from binary format.

A JSON definition of an embedded resource. This is a resource that can be either standalone (in a .vtex file) or embedded in a GameResource's Json data. When it's detected in a GameResource we will create the named compiler and create the resource. When compiling the GameResource this can optionally create a compiled version of the resource on disk. When we compile a regular resource that contains this $compiler structure, it operates like any other compile, except it's totally managed by c# instead of resourcecompiler.

The name of the ResourceCompiler to use

The name of the ResourceGenerator that created this resource. This is basically a sub-compiler.

Sometimes we'll want to embed a child class of a resource

Data that is serialized/deserialized from the ResourceGenerator

If this resource has been compiled to disk then this is the path to that resource. This avoids the need to generate this resource again.

The absolute path to the resource on disk

The path relative to the assets folder

The resource version can be important

Add a reference. This means that the resource we're compiling depends on this resource.

Add a reference that is needed to compile this resource, but isn't actually needed once compiled.

Add a game file reference. This file will be included in packages but is not a native resource. Use this for arbitrary data files that are loaded by managed code (e.g. navdata files).

Get the streaming data to write to

Get the data to write to

Create a child resource

Load the json and scan it for paths or any embedded resources

Read the source, either from in memory, or from disk

Write a string with a null terminator

Takes the "source" of a resource and creates a compiled version. The compiled version can create a number of child resources and store binary data.

A collection of helper methods for making your own resource compiler.

Mark a ResourceCompiler. This is used to identify the compiler for a specific file extension, or compiler.

Writes resource to a JSON file, using the ResourceGenerator to create the resource.

Try to parse the source as an EmbeddedResource Returns false if the source is not valid JSON or doesn't contain a ResourceGenerator.

Create a deterministic path for a generated resource based on the embedded resource data.

Generic method to compile an embedded resource by creating a child context. This handles the common pattern of creating a generator, generating a path, creating a child context, and setting the compiled path.

Creates a resource from a json definition

True if we're compiling this resource to write to disk

Will be set to the compiler that is currently compiling this resource. Or null, if we're generating in another method.

If true then the generation will create a real resource and store it on disk. Use this if creating the resource takes a while, or you won't be shipping the generator with the game, or if it relies on data that won't be available in the shipped game.

Create a ResourceGenerator by name

Create a ResourceGenerator by name and deserialize it

Create a resource from an embedded resource with a given

Copy properties from obj to us

Returns a hash to be used when loading/saving. We use this to determine if the resource has changed. By default we serialize the generator to a json string and return the CRC64 of that value. You can override this in your generator if you need to make it faster, or ignore some stuff.

If we generated this before, then find the current cache'd value. If not, then generate a new one.

Find or create the resource (blocking)

A resource generator targetting a specific type

If true then the generation will avoid creating duplicate resources by checking hash codes of previously generated resources and re-using them if possible.

Find a previously created of this resource

Add this resource to the cache for our current hash

If we generated this before, then find the current cache'd value. If not, then generate a new one.

Create the resource blocking

Create the resource asyncronously

Find an existing texture for this

Create a texture. Will replace a placeholder texture, which will turn into the generated texture later, if it's not immediately available.

Create a texture. Will wait until the texture is fully loaded and return when done.

Generate a texture which is just a single color

Load images from disk and convert them to textures

The path to the image file, relative to any other assets in the project.

The maximum size of the image in pixels. If the imported image is larger than this (after cropping), it will be downscaled to fit.

When enabled, the output texture will be a normal map generated from the heightmap of the image.

The scale of the normal map when using . If negative, the normal map will be inverted.

How much to rotate the image by, in degrees. This is applied after cropping and padding.

Whether or not to flip the image vertically. This is done after everything else has been applied.

Whether or not to flip the image horizontally. This is done after everything else has been applied.

How many pixels from each edge to crop from the image. If negative values are used, the image will be expanded instead of cropped.

How many pixels of padding from each edge. After the image has been cropped, padding is added without affecting the size of the image (scaling the original image down to fit padded margins).

Whether or not to invert the colors of the image.

The color the image should be tinted. This effectively multiplies the color of each pixel by this color (including alpha).

The intensity of the blur effect. If 0, no blur is applied.

The intensity of the sharpen effect. If 0, no sharpening is applied.

The brightness of the image.

The contrast of the image.

The saturation of the image.

How much to adjust the hue of the image, in degrees. If 0, no hue adjustment is applied.

When enabled, every pixel in the image will be re-colored to the (interpolated by the alpha).

When is enabled, this is the target color that every pixel in the image will be re-colored to.

Provides a texture generator entry that returns the texture owned by a RenderTexture asset.

The render texture asset to reference.

Writes the Source 2 resource container format. File layout: - ResourceFileHeader_t (16 bytes) - ResourceBlockEntry_t[] (12 bytes each) - Block data (DATA block, etc.) - Streaming data (texture bits, etc.) All offsets in CResourcePointer/CResourceArray are relative to the field's own position.

Set the DATA block content (e.g., VTEX_Header_t for textures)

Set the streaming data (e.g., texture bits)

Write the complete resource file

Writes the VTEX data format (texture header and streaming data). The format consists of: 1. Header (width, height, depth, format, flags, etc.) 2. Extra data blocks (not currently used) 3. Streaming data (encoded texture pixels) - Ordered from smallest mip to largest - For cubemaps: each mip contains all 6 faces in order (face 0-5)

Given what we know, work out the best texture

A decal which can be applied to objects and surfaces.

The color map to use for the decal including transparency which masks the decal. This must be set for other textures to use the decal mask.

The normal texture map to use for the decal.

The Roughness/Metal/Ambient Occlusion texture map to use for the decal, stored in the respective RGB channels.

The emissive texture map to use for the decal.

Strength of the emission effect.

The height texture to use for parallax mapping.

Strength of the parallax effect.

Tints the color of the decal's albedo and can be used to adjust the overall opacity of the decal.

Controls the opacity of the decal's color texture without reducing the impact of the normal or rmo texture. Set to 0 to create a normal/rmo only decal masked by the color textures alpha.

Width of the decal.

Height of the decal.

How the texture gets filtered.

A serialized reference to a data file (like navdata) that needs to be tracked and packaged. These files have no dependencies themselves.

Assets defined in C# and created through tools. You can define your own Custom Asset Types.

Allows tools to post process the serialized json object

The last saved compiled hash for this file.

The last saved uncompiled hash for this file. We use this to detect external changes in the editor, it's never serialized.

Re-use ActionGraph instances when deserializing this resource.

True if this resource has changed but the changes aren't written to disk

Binary data to be written alongside the JSON file.

Should be called after the resource has been edited by the inspector

True if we're waiting for our load to complete

True if we're a promise, waiting to finalize the load

Get a list of packages that are needed to load this asset

Called when the asset is first loaded from disk.

Called when the asset is recompiled/reloaded from disk.

Creates an instance of this type that will get loaded into later. This allows us to have resources that reference other resources that aren't loaded yet (or are missing).

Makes sure all properties are derived properly from filename, and then registered to ResourceLibrary

Loads a game resource from given file.

Target type used for any action graphs contained in this resource. Defaults to this resource's type.

Target instance used for any action graphs contained in this resource. Defaults to this resource itself.

Pushes a context in which action graphs belonging to this resource can be serialized or deserialized.

Serialize the current state to a JsonObject

called to upgrade a bunch of json to the latest version

The version of the component. Used by .

Deserialize values from a JsonObject

Called after we serialize, allowing you to store any extra or modify the output.

Called when this resource is being unloaded. Clean up any resources owned by this instance here.

Should be applied to a class that inherits from . Makes the class able to be stored as an asset on disk.

This gets filled in by the TypeLibrary when the class is registered, it shouldn't be changed manually.

The title of this game resource.

File extension for this game resource.

Category of this game resource, for grouping in UI.

Flags for this asset type.

Find a resource type by its extension. The extension should have no period.

Flags for

If set then this resource cannot be embedded. This means that in the editor it can only really exist as an asset file on disk, not inside another asset.

Include thumbnails when publishing as part of another package

Icon to be used for this asset Can be an absolute path of a PNG Or a material icon for this game resource's thumbnail.

Background color for this resource's thumbnail.

Foreground color (icon color) for this resource's thumbnail.

Can this GameResource be an embedded resource? Allows the ability to edit a resource inline instead of saving it to a specific file.

Description of this game resource. This is obsolete, we'll use the xml summary description.

A material. Uses several s and a with specific settings for more interesting visual effects.

Name (or path) of the material.

Access to all of the attributes of this material.

Private constructor, use

Create a copy of this material

Set a feature flag on the material. This is usually used to enable/disable shader permutations. This is kind of a define, also known as a combo.

Get a feature flag on the material. This is usually used to enable/disable shader permutations.

Access flags on this material, which usually hint about the contents. These are generally added by the shader procedurally - but developers can add these in material editor too.

Load a material from disk. Has internal cache.

The filepath to load the material from. The loaded material, or null

Load a material from disk. Has internal cache.

The filepath to load the material from. The loaded material, or null

Try to make it so only one Material class exists for each material

Gets the underlying shader name for this material.

Get thje first texture assigned to this material, if any.

Gets the material's shader

Get texture parameter, by name

Get Vector4 parameter, by name

Get Color parameter, by name

Overrides/Sets an Vector4 within the material

Override/Sets texture parameter (Color, Normal, etc)

Overrides/Sets an color within the material as a color value within the material

Overrides/Sets an Vector3 within the material

Overrides/Sets an Vector2 within the material

Overrides/Sets an float within the material

Overrides/Sets an int within the material

Overrides/Sets an bool within the material

Create a new empty material at runtime.

Name of the new material. Shader that the new material will use. If false, material can be found by name. The new material.

Get an empty material based on the specified shader. This will cache the material so that subsequent calls will return the same material.

Dispose all cached shader materials created via and . Called during shutdown to release native strong handles before the resource system tears down.

Static materials for UI rendering purposes.

As basic 2D drawing material. Supports Texture and vertex color.

CSS Box rendering

Batched CSS Box rendering — reads per-box data from a StructuredBuffer

CSS Box Shadow rendering

CSS Text Rendering

For filter: border-wrap( ... );

For filter: drop-shadow( ... );

CSS Outline rendering

Possible primitive types of a .

A mesh is a basic version of a , containing a set of vertices and indices which make up faces that make up a shape. A set of meshes can be used to create a via the class.

Sets the primitive type for this mesh.

Sets material for this mesh.

Sets AABB bounds for this mesh.

Used to calculate texture size for texture streaming.

Set how many vertices this mesh draws (if there's no index buffer)

Set how many indices this mesh draws

Create vertex and index buffers.

Input vertex buffer. If it is indexed (), then index buffer will also be created. Whether to recalculate bounds from the vertex buffer.

Triangulate a polygon made up of points, returns triangle indices into the list of vertices.

Whether this mesh has an index buffer.

Number of indices this mesh has.

Create an empty index buffer, it can be resized later

Create a index buffer with a number of indices

Set data of this buffer

Resize the index buffer.

Lock all the memory in this buffer so you can write to it

Lock a specific amount of the memory in this buffer so you can write to it

Lock a region of memory in this buffer so you can write to it

Whether this mesh has a vertex buffer.

Number of vertices this mesh has.

Create a vertex buffer with a number of vertices

Create an empty vertex buffer, it can be resized later

Create a vertex buffer with a number of vertices

Set data of this buffer

Resize the vertex buffer

Lock all the memory in this buffer so you can write to it

Lock a specific amount of the memory in this buffer so you can write to it

Lock a region of memory in this buffer so you can write to it

Create an empty index buffer, it can be resized later

Create a index buffer with a number of indices

Set data of this buffer

Resize the index buffer.

Lock all the memory in this buffer so you can write to it

Lock a specific amount of the memory in this buffer so you can write to it

Lock a region of memory in this buffer so you can write to it

Resize the vertex buffer

Set data of this buffer

Lock all the memory in this buffer so you can write to it

Lock a specific amount of the memory in this buffer so you can write to it

Lock a region of memory in this buffer so you can write to it

Create an empty vertex buffer, it can be resized later

Create a vertex buffer with a number of vertices

Resize the vertex buffer

Set data of this buffer

Lock all the memory in this buffer so you can write to it

Lock a specific amount of the memory in this buffer so you can write to it

Lock a region of memory in this buffer so you can write to it

A collection of bones. This could be from a model, or an entity

Root bone of the model.

List of all bones of our object.

Whether the model or entity has a given bone by name.

Retrieve a bone by name.

A bone in a .

Numerical index of this bone.

Name of this bone.

The parent bone.

Transform on this bone, relative to the root bone.

Whether this bone has any child bones.

List of all bones that descend from this bone.

Whether this bone has given name or not.

A model.

Number of animations this model has.

Returns name of an animation at given animation index.

Animation index to get name of, starting at 0. Name of the animation. Thrown when given index exceeds range of [0,AnimationCount-1]

Get the animgraph this model uses.

Access to bones of this model.

Returns amount of attachment points this model has.

Retrieves attachment transform based on given attachment name.

Name of the attachment to retrieve transform of. The attachment transform, or null if attachment by given name is not found.

Retrieves attachment transform based on given attachment index.

>Index of the attachment to look up, starting at 0. The attachment transform. Thrown when given index exceeds range of [0,AttachmentCount-1]

Returns name of an attachment at given index.

Index of the attachment to look up, starting at 0. The name of the attachment at given index. Thrown when given index exceeds range of [0,AttachmentCount-1]

Access to body parts of this model.

Used to mark properties as a body group mask, so the correct editor can be used

Total bounds of all the meshes.

Total bounds of all the physics shapes.

Render view bounds.

Private constructor, use

Called when the resource is reloaded. We should clear any cached values.

Whether this model is an error model or invalid or not.

Name of the model, usually being its file path.

Whether this model is procedural, i.e. it was created at runtime via .

Total number of meshes this model is made out of.

Trace against the triangles in this mesh

Base model of this model if one was used.

If the prop is destructable this is its start health

Should this prop explode when destroyed? If so, this is the radius of the damage from it.

Should this prop explode when destroyed? If so, this is the physics push force from it.

Minimum impact damage speed to break this object.

The amount of damage this deals to other objects when it collides at high speed. If set to -1, this will be calculated from the mass of the rigidbody.

Tries to extract data from model based on the given type's ModelDoc.GameDataAttribute.

The extracted data, or default on failure. true if data was extracted successfully, false otherwise.

Tries to extract data from model based on the given type's ModelDoc.GameDataAttribute.

The extracted data, or default on failure. The class with ModelDoc.GameDataAttribute. true if data was extracted successfully, false otherwise.

Tests if this model has generic data based on given type's ModelDoc.GameDataAttribute. This will be faster than testing this via GetData]]>()

Extracts data from model based on the given type's ModelDoc.GameDataAttribute.

Internal function used to get a list of break commands the model has.

Access to default hitbox set of this model

Load a model by file path.

The file path to load as a model. The loaded model, or null

Load a model by file path.

The file path to load as a model. The loaded model, or null

Number of material groups this model has.

Returns name of a material group at given group index.

Group index to get name of, starting at 0. Name of the group. Thrown when given index exceeds range of [0,MaterialGroupCount-1]

Retrieves the index of a material group given its name.

The name of the material group. The index of the material group, or a negative value if the group does not exist.

Retrieves an enumerable collection of all Materials on the meshes. This is fast, and cached. The order of these items is the same order used in ModelRenderer.Materials etc

An ImmutableArray of Materials.

Retrieves an enumerable collection of Materials belonging to a specified group.

The index of the material group. Default value is 0. An IEnumerable of Materials in the specified group.

Retrieves an enumerable collection of Materials belonging to a specified group.

The name of the material group. An IEnumerable of Materials in the specified group. Thrown when the provided group name does not exist.

Used to mark a property as a material group, for the editor

Used to mark a property as a material material override dictionary, for the editor

Access to bones of this model.

Number of morph controllers this model has.

Returns name of a morph controller at given index.

Morph controller index to get name of, starting at 0. Name of the morph controller at given index. Thrown when given index exceeds range of [0,MorphCount-1]

Get morph weight for viseme.

List of sequence names this model has.

Access to bones of this model.

Number of bones this model has.

Returns name of a bone at given bone index.

Bone index to get name of, starting at 0. Name of the bone. Thrown when given index exceeds range of [0,BoneCount-1]

Returns the id of given bone's parent bone.

The bone to look up parent of. The id of the parent bone, or -1 if given bone has no parent. Thrown when given index exceeds range of [0,BoneCount-1]

Returns transform of given bone at bind position.

Thrown when given index exceeds range of [0,BoneCount-1]

Returns transform of given bone at bind position.

Creates a dictionary of bone names to game objects, where each game object is a bone object in the scene.

Recursively creates game objects for each bone in the hierarchy, starting from the given root bone.

Cached instance from native, or creates

Returns a static instance, allowing for runtime model creation.

A cube model

A sphere model

A plane model

An error model

Experimental!

Provides ability to generate animations for a at runtime. See

The name of the animation.

The frames per second of the animation.

This animation loops.

This animation "adds" to the base result.

This animation disables interpolation between frames.

The number of frames in the animation.

Sets the name of the animation.

Sets the frames per second of the animation.

Sets whether the animation loops.

Sets whether the animation adds to the base result.

Sets whether interpolation between frames is disabled.

Add bone transforms for a frame of animation.

Provides ability to generate s at runtime. A static instance of this class is available at

Adds an animation to this model and returns a builder to construct the animation.

The name of the animation. The frames per second of the animation. An instance to construct the animation.

Total mass of the physics body (Default is 1000)

Surface property to use for collision

LOD switch distance increment for each Level of Detail (LOD) level. (Default is 50)

Add box collision shape.

Add sphere collision shape.

Add capsule collision shape.

Add a CONVEX hull collision shape.

Add a CONCAVE mesh collision shape. (This shape can NOT be physically simulated)

Add trace vertices for tracing against mesh

Add a mesh.

Add a bunch of meshes.

Add a mesh to a Level of Detail (LOD) group.

Add a bunch of meshes to a Level of Detail (LOD) group.

Add a mesh to a body group choice.

Add a mesh to a Level of Detail (LOD) and a body group choice.

A bone definition for use with .

Name of the bone. Name of the parent bone. Position of the bone, relative to its parent. Rotation of the bone, relative to its parent.

A bone definition for use with .

Name of the bone. Name of the parent bone. Position of the bone, relative to its parent. Rotation of the bone, relative to its parent.

Name of the bone.

Name of the parent bone.

Position of the bone, relative to its parent.

Rotation of the bone, relative to its parent.

Add a bone to the skeleton via a struct.

Add multiple bones to the skeleton.

Add a bone to the skeleton.

Add an attachment to the skeleton.

Provide a name to identify the model by

Desired model name

Finish creation of the model.

Add a named material group builder.

Adds a new physics body to this object.

The mass of the body. Default is 0. The surface properties to apply. Default is default. Optional name of the bone this body is attached to. Leave empty for non-skeletal bodies. A new for configuring the body.

Adds a hinge joint between two bodies, allowing rotation around a single axis.

The index of the first body. The index of the second body. Optional joint frame in local space of body1. Optional joint frame in local space of body2. Whether the connected bodies can collide.

Adds a ball joint between two bodies, allowing free rotation within optional swing/twist limits.

The index of the first body. The index of the second body. Optional joint frame in local space of body1. Optional joint frame in local space of body2. Whether the connected bodies can collide.

Adds a fixed joint between two bodies, locking their relative position and orientation.

The index of the first body. The index of the second body. Optional joint frame in local space of body1. Optional joint frame in local space of body2. Whether the connected bodies can collide.

Adds a slider joint between two bodies, allowing motion along a single axis.

The index of the first body. The index of the second body. Optional joint frame in local space of body1. Optional joint frame in local space of body2. Whether the connected bodies can collide.

Bone transformed LocalTransform

All body parts in this model.

How many body parts there are in this model.

Default body groups mask for this model.

Get body part by name.

The associated with this object.

Called by the engine when the associated is reloaded. Implementing classes should clear or update any cached data that depends on the model.

A set of hitboxes on a model. Hitboxes can be boxes, spheres or capsules.

All hitboxes in this set

A single hitbox on the model. This can be a box, sphere or capsule.

Either a Sphere, Capsule or BBox

Get a random point inside this hitbox

Get a random point on the edge this hitbox

The name of the material group.

Add a material to the group.

Add a materials to the group.

Allows fast lookups of morph variables

Get the name of a morph by its index.

Get the index of a morph by its name

Clear it so it can't be used after disposed

Enumerate every in this

For debug rendering

Provides ability to generate a physics body for a at runtime. See

The mass of the body in kilograms. Set to 0 to calculate automatically from its shapes and density.

The surface properties applied to this body.

The bind pose transform used when attaching this body to a bone.

The name of the bone this body is attached to, or null if not attached.

Add a sphere shape.

Add a capsule shape.

The method used to simplify a hull.

Quadratic Error Metric � prioritizes preserving shape accuracy.

Iterative Vertex Removal � removes vertices gradually.

No simplification � use the exact points provided.

Iterative Face Removal � removes faces to reduce complexity.

Settings for simplifying a hull shape.

Maximum allowed angle change between faces, in degrees.

Maximum distance a vertex can be moved during simplification.

Maximum number of faces allowed after simplification.

Maximum number of edges allowed after simplification.

Maximum number of vertices allowed after simplification.

The simplification method to use.

Adds a convex hull shape to this body.

The points making up the hull. Optional local transform of the hull relative to the body. Optional settings to reduce the complexity of the hull. Thrown if less than 3 points are provided.

Adds a triangle mesh shape to this body.

The mesh vertex positions. The mesh indices, grouped in triples to form triangles. Must be a multiple of 3. Optional per-vertex material IDs. Length must match count or be empty. Thrown if the mesh has fewer than 3 vertices, if indices are not a multiple of 3, or if material count does not match vertex count. Thrown if any index refers to a vertex that does not exist.

Provides ability to generate a physics joint for a at runtime.

The index of the first body connected by the joint.

The index of the second body connected by the joint.

The joint frame in the local space of .

Whether the connected bodies can collide with each other.

The maximum linear force the joint can withstand before breaking.

The maximum angular force/torque the joint can withstand before breaking.

Provides ability to generate a hinge joint for a at runtime.

Whether the hinge enforces a twist angle limit.

The minimum and maximum allowed twist angles (degrees).

Whether the hinge's angular motor is enabled.

Target angular velocity for the motor.

Maximum torque the motor may apply.

Provides ability to generate a ball joint for a at runtime.

Whether the joint enforces a swing angle limit.

Whether the joint enforces a twist angle limit.

Maximum allowed swing angle in degrees.

Minimum and maximum allowed twist angles in degrees.

Provides ability to generate a fixed joint for a at runtime.

The frequency of the joint's linear spring in hertz. Higher values make the joint stiffer in translation.

The damping ratio for the joint's linear spring. Higher values reduce oscillation in translation.

The frequency of the joint's angular spring in hertz. Higher values make the joint stiffer in rotation.

The damping ratio for the joint's angular spring. Higher values reduce oscillation in rotation.

Provides ability to generate a slider joint for a at runtime.

Whether the joint enforces a translation limit along its axis.

The minimum and maximum allowed translation along the joint axis.

A particle snapshot that can be created procedurally. Contains a set of vertices that particle effects can address.

A vertex to update a particle snapshot with.

Create new empty procedural particle snapshot.

Update this snapshot with a list of vertices.

A particle effect system that allows for complex visual effects, such as explosions, muzzle flashes, impact effects, etc.

Whether the particle system is invalid, or has not yet loaded.

Particle system file name.

Static bounding box of the resource.

How many child particle systems do we have

Returns child particle at given index.

Index of child particle system, starting at 0. Particle system Thrown when given index exceeds range of [0,ChildCount-1]

Loads a particle system from given file.

Load a particle system by file path.

The file path to load as a particle system. The loaded particle system, or null

A resource loaded in the engine, such as a or .

Get the icon for this type of asset. This is an icon that is shown in the editor.

Create an icon for this type of asset. This is an icon that is shown in the editor.

Create a simple icon using an icon. This is used by default for asset types.

ID of this resource,

Internal use only — a stable 64-bit hash of ResourcePath, used for networking and resource lookup.

Path to this resource.

File name of the resource without the extension.

This is what loads the resource. While this is alive the resource will be loaded.

True if this resource has been changed but the changes aren't written to disk

Sets the ResourcePath, ResourceName and ResourceId from a resource path. Registers in the WeakIndex so the resource can be found by ResourceId for networking, without preventing garbage collection. This is intended for runtime/native resources only. Disk-based resources (GameResource) should use instead.

Accessor for loading native resources, not great, doesn't need to handle GameResource

Called by OnResourceReloaded when a resource has been reloaded

Should be called after the resource has been edited by the inspector

Embedded data for this resource

Read the resource from a JSON element. This is usually a string, describing the path to the resource

Write the resource reference to a json element. This is usually a string, describing the path to the resource

Load a resource from a path with improved deferred loading support

Load a resource reference from JSON data. Handles both string paths and embedded resource objects for all resource types.

Allows a resource type to override how it reference entry is written. This is generally just going to be a path to the on disk resource, but we can use this to store metadata too.

When publishing an asset we'll call into this method to allow the resource to configure how it wants to be published. This allows your resource to make bespoke decisions to configure publishing based on its content.

Render a thumbnail for this specific resource.

Created by the editor when publishing a resource, passed into Resource.ConfigurePublishing. This allows the resource to configure how it wants to be published.

Can be set to false using SetPublishingDisabled

If publishing is disabled this will be the message to display why.

Allows you to disable publishing for this resource, with a reason that'll be shown to the user.

A function to create a thumbnail for this resource. If not null, this will be called to create the thumbnail.

If true we'll include the addon's code with this

If true then we'll offer an option to upload source files with this asset. This will make it easier for people who want to download and add it to their project, but make their own changes.

Describes a resource extension at a base level

Find all resources that are targetting a specific resource

Find all extensions that target a specific type.

A GameResource type that adds extended properties to another resource type. You should prefer to use the type with to generic arguments, and define your own type as the second argument. That way you get access to the helper methods.

If true then this is returned when calling FindForResourceOrDefault if no other extension is found targetting a specific resource.

Extensions can target more than one resource.

An extension of ResourceExtension[t], this gives special helper methods for retrieving resources targetting specific assets.

Maps ResourceIdLong → path for all resources that exist on disk. Populated at startup without loading anything; used as on-demand load fallback during network deserialization when a resource hasn't been loaded on the client yet.

Prune dead entries from the WeakIndex to prevent unbounded growth. Only runs every 30 seconds.

Find all alive weak resources of a given type whose ResourcePath starts with the given prefix. Used for hotload scenarios like SVG textures with query parameters.

Get a cached resource by its hash.

Resource type to get. Resource hash to look up.

Get a cached resource by its file path.

Resource type to get. File path to the resource.

Try to get a cached resource by its file path.

Resource type to get. File path to the resource. The retrieved resource, if any. True if resource was retrieved successfully.

Get all cached resources of given type.

Resource type to get.

Get all cached resources of given type in a specific folder.

Resource type to get. The path of the folder to check. Whether or not to check folders within the specified folder.

Returns stats about the ResourceIndex and WeakIndex for debug overlays.

Read compiled resource as JSON from the provided buffer.

Read compiled resource as JSON from the provided file path.

Get the for a given extension.

garry: why the fuck does this exist garry: fuck me why the fuck does this exist

Loads a Gameresource from disk. Doesn't look at cache. Registers the resource if successful.

Installs all references for a GameResource

Keeps a library of all available .

Get a cached resource by its hash.

Resource type to get. Resource hash to look up.

Get a cached resource by its file path.

Resource type to get. File path to the resource.

Try to get a cached resource by its file path.

Resource type to get. File path to the resource. The retrieved resource, if any. True if resource was retrieved successfully.

Get all cached resources of given type.

Resource type to get.

Get all cached resources of given type in a specific folder.

Resource type to get. The path of the folder to check. Whether or not to check folders within the specified folder.

Load a resource by its file path.

Render a thumbnail for this resource

Called when a new resource has been registered

Called when a previously known resource has been unregistered

Called when a resource has been saved

Called when the source file of a known resource has been externally modified on disk

Called when the source file of a known resource has been externally modified on disk and after it has been fully loaded (after post load is called)

Registers resource paths into PathIndex without loading them, for any file whose extension is in . Called during LoadAllGameResource.

A GameObject which is saved to a file.

Load a prefab by file path. Also handles mount:// paths

Contains the original JSON read from File.

This is used as a reference

Get the actual scene scene

If true then we'll show this in the right click menu, so people can create it

If ShowInMenu is true, this is the path in the menu for this prefab

Icon to show to the left of the option in the menu

If true then the prefab will not be broken when created as a template

Read metadata saved using a ISceneMetadata based component, such as SceneInformation

If this instance is stored in , what's the key?

Add this instance to , indexed by Guid. If the Guid has changed, removes the old entry.

Remove this instance from .

We store each prefabfile in here indexed by their root object id, allowing us to discuss them over the network, because the net system will be able to look the GameObject up.

We can look up prefabfile by their object guid

Version 0 to 1 - "Id" changed to "__guid"

Version 1 to 2 - Add "Children" and "Components" array if they don't exist - Add Flags if they don't exist

A prefab variable definition

A unique id for this variable. This is what it will be referred to in code.

A user friendly title for this variable

A user friendly description for this variable

An optional group for this variable to belong to

Lower numbers appear first

Component variables that are being targetted

Add a target property

Targets a property in a component or gameobject.

The Id of the gameobject or component. The name of the parameter on the target.

Targets a property in a component or gameobject.

The Id of the gameobject or component. The name of the parameter on the target.

The Id of the gameobject or component.

The name of the parameter on the target.

A scene file contains a collection of GameObject with Components and their properties.

Version 0 to 1 - "Id" changed to "__guid"

Version 1 to 2 - Title and Description moved to SceneInformation metadata component

Version 2 to 3 - Add "Children" and "Components" array if they don't exist - Add Flags if they don't exist

A shader is a specialized and complex computer program that use world geometry, materials and textures to render graphics.

Loads from the compiled resource, unless it's out of date by comparing the md5 in which case it just returns false

Loads all shader programs from the shader source file, except those that are already loaded (from above, assumably)

Returns a schema representing the variables and combos in this shader. This is used by the material editor to show UI for editing shader parameters.

Try to make it so only one Shader class exists for each shader

Load a shader by file path.

The file path to load as a shader. The loaded shader, or null

A soundscape is used for environmental ambiance of a map by playing a set of random sounds at given intervals.

All sound volumes in this soundscape will be scaled by this value.

Sounds that are played constantly on a loop.

Sounds that are played at intervals.

The sound to play. It should have the looped flag set.

Sound volume.

If true then the sound will come from a random direction in the world

The sound event to play.

How many instances of this sting should exist.

How often should this sound be repeated.

How far away from the camera should the sound play.

Raw PCM sound data, kind of like a bitmap but for sounds

A sound event. It can play a set of random sounds with optionally random settings such as volume and pitch.

Is this sound 2D?

How loud the sound should be.

The base pitch of the sound.

How loud is this sound, affects how far away it can be heard

Selection strategy to use when picking from multiple sounds.

A random sound from the list will be selected to be played.

Allow this sound to be occluded by geometry

Allow this sound to trace reflections, allowing it to be heard indirectly

Allow this sound to be absorbed by air

Allow this sound to be transmitted through geometry

The radius of this sound's occlusion in inches.

Should the sound fade out over distance

How many units the sound can be heard from.

The falloff curve for the sound.

Default mixer to play this sound with if one isn't provided on play.

Used for selection mode

A sound resource.

Ran when the file is reloaded/recompiled, etc.

true if sound is loaded

Format of the audio file.

Bits per each sample of this sound file.

Number of channels this audio file has.

Bytes per each sample of this sound file.

Size of one sample, typically this would be "sample size * channel count", but can vary on audio format.

Sample rate of this sound file, per second.

Duration of the sound this sound file contains, in seconds.

Load a new sound from disk. Includes automatic caching.

The file path to load the sound from. The loaded sound file, or null if failed.

Load from PCM.

Create a sound from raw PCM data.

Sound name Raw interleaved PCM data Number of channels (1 = mono, 2 = stereo) Sample rate (e.g. 44100) Bits per sample (8, 16, 32) Whether the sound should loop

Load from WAV.

Load from MP3.

Request decompressed audio samples.

Represents a sprite resource that can be static or animated. Sprites are rendererd using the SpriteRenderer component.

The different loop modes for sprite animation.

The animation will play from start to finish and then stop.

The animation will play from start to finish and then loop back to the start.

The animation will play from start to finish and then backwards from finish to start before looping.

A custom string will be broadcast by invoking an Action on the SpriteRenderer

Plays a sound from the sprite's position

Spawns a prefab at the sprite's position

Describes a single animation frame

A message that is broadcast when a frame is displayed.

Contains one or multiple frames that can be played in sequence.

The name of the animation. Allows you to play specific animations by name.

The speed of the animation in frames per second.

The point at which the rendered sprite is anchored from. This means scaling/rotating a sprite will do so around the origin.

The loop mode of the animation. This determines what should happen when the animation reaches the final frame in playback.

A list of frames that make up the animation. Each frame is a texture that will be displayed in sequence.

True if we have more than one frame

Contains the state of a sprite instance's animation playback.

The current frame index in the animation.

Whether or not the animation is currently ping-ponging. This is only relevant for animations that have

The time since the last frame was advanced.

The speed at which the animation is playing back. A value of 1 means normal speed, 0.5 means half speed, and -1 means reverse playback.

Returns true if the animation finished, looped, or ping-ponged after calling

Reset the animation playback state to the beginning (first frame, no ping-pong, zero time-since).

Try to advance the frame of a given animation with a given delta time. Returns false if the frame did not advance.

A list of animations that can be played. Some animations can consist of multiple frames. If a sprite is static, it will only contain a single default animation.

Get the index of an animation by its name. Returns -1 if not found.

The name of the animation

Get an animation by its index. Returns null if out of bounds.

The index of the animation

Get an animation by its name. Returns null if not found.

The name of the animation

Returns a sprite with a single frame animation using the provided texture.

The texture to be used

Returns a sprite with a single animation using the provided textures as frames.

The textures to be used for the animation The frame rate of the animation

A physics surface. This is applied to each PhysicsShape and controls its physical properties and physics related sounds.

Per-context lookup of loaded surfaces by their physics index. Each GlobalContext (Menu, Game) owns its own dictionary so that game-session teardown never clears entries belonging to the menu.

Filepath of the base surface. Use SetBaseSurface and GetBaseSurface.

Defines the audio properties of this surface for Steam Audio

A concise description explaining what this surface property should be used for.

Friction of this surface material.

Controls bounciness.

Density of this surface material. This affects things like automatic mass calculation. Density is in kg/m^3.

Controls how easily rolling shapes (sphere, capsule) roll on surfaces.

Velocity threshold, below which objects will not bounce due to their elasticity.

Linear drag applied when submerged.

Angular drag applied when submerged.

Returns the base surface of this surface, or null if we are the default surface.

Sets the base surface by name.

Find a surface by its index in the array. This is the fastest way to lookup, so it's passed from things like Traces since the index is going to be the same. It's important to know that this index shouldn't be saved or networked because it could differ between loads or clients. Instead send the name hash and look up using that.

Returns a Surface from its name, or null

The name of a surface property to look up The surface with given name, or null if such surface property doesn't exist

Play a collision sound based on this shape's surface. Can return null if sound is invalid, or too quiet to play.

Spawn one of these particles on impact.

Spawn one of these particles when hit by a bullet.

Use one of these as the bullet impact decal.

Spawn one of these particles on impact.

Use one of these as a physics impact decal.

Spawn one of these particles on impact.

Use one of these as a physics impact decal.

Impact effects of this surface material.

Similar to friction but only affects whether a scrape is rough or smooth.

Surface roughness greater than this results in rough scrapes.

Spawn one of these particle effects during a smooth scrape.

Spawn one of these particle effects during a rough scrape.

Use one of these particles during a smooth scrape.

Use one of these particles during a rough scrape.

Scrape effects of this surface material.

Left footstep sound.

Right footstep sound.

Jump sound for this surface.

Landing sound for this surface.

Bullet impact sound for this surface.

Hard, high velocity impact sound.

Soft, low velocity impact sound.

Rough scraping sound when scraping against another surface.

Smooth scraping sound when scraping against another surface.

Sounds associated with this surface material.

Holds a dictionary of common prefabs associated with a surface

A prefab to spawn when this surface is hit by a bullet. The prefab should be spawned facing the same direction as the hit normal. It could include decals and particle effects. It should be parented to the surface that it hit.

A prefab to spawn when this surface is hit by something blunt. The prefab should be spawned facing the same direction as the hit normal. It could include decals and particle effects. It should be parented to the surface that it hit.

Common prefabs for this surface material

Holds a dictionary of common sounds associated with a surface. This allows you to pick and choose an appropriate sound.

Left footstep sound.

Right footstep sound.

Jump sound for this surface.

Landing sound for this surface.

Bullet impact sound for this surface.

Hard, high velocity impact sound.

Soft, low velocity impact sound.

Rough scraping sound when scraping against another surface.

Smooth scraping sound when scraping against another surface.

Sound to play when an object made of this breaks

Sounds for this surface material

Internal accessor for the surface's tags (stored as StringToken)

A list of tags as one string.

Do we have a tag?

Do we have all the tags on this hitbox?

True if all tags match, false if any tag does not match.

Do we have all the tags on this hitbox?

True if any tag matches, false if all tags do not match.

Defines acoustic properties of a surface, which defines how sound will bounce

Description of a Terrain Material.

Compact terrain material encoding with base/overlay texture blending. Packed format (32-bit uint)

Helper struct for cleaner bit field manipulation

Extract value from packed data

Insert value into packed data

Base texture ID (0-31)

Overlay texture ID (0-31)

Blend factor between base and overlay (0-255).

Whether this pixel is marked as a hole

Reserved bits for future use (13 bits)

Raw packed value

Stores heightmaps, control maps and materials.

Uniform world size of the width and length of the terrain.

World size of the maximum height of the terrain.

Contains terrain maps that get compressed

Asset that owns a GPU render target texture which can be shared across runtime systems.

Resolution of the render target in pixels.

Color format used when building the render target. Unsupported formats fall back to RGBA8888.

Multisample anti-aliasing level for the render target.

Optional clear colour applied when the texture is (re)created.

The width and height of the bitmap

Used internally for resizing operations

Clears the bitmap to the specified color.

The color to fill the bitmap with.

Retrieves the pixel data of the bitmap as an array of colors.

Retrieves the color of a specific pixel in the bitmap.

The x-coordinate of the pixel. The y-coordinate of the pixel. The color of the pixel at the specified coordinates.

Sets the color of a specific pixel in the bitmap.

The x-coordinate of the pixel. The y-coordinate of the pixel. The color to set the pixel to.

Low level, get a span of the bitmap data.

Super low level, get a pointer to the bitmap data.

Asserts that the specified region is within the bounds of the bitmap. Throws an exception if the bounds are out of range.

The x-coordinate of the starting point. The y-coordinate of the starting point. The width of the region to check. The height of the region to check.

Copy the bitmap to a new one without any changes.

Returns true if this bitmap is completely opaque (no alpha) This does a pixel by pixel search, so it's not the fastest.

Draws a rectangle using the current pen settings.

The rectangle to draw.

Draws a rectangle using the current pen settings.

The x-coordinate of the top-left corner. The y-coordinate of the top-left corner. The width of the rectangle. The height of the rectangle.

Draws a rectangle using the current pen settings.

Draws a circle using the current pen settings.

The center of the circle. The radius of the circle.

Draws a circle using the current pen settings.

The x-coordinate of the circle's center. The y-coordinate of the circle's center. The radius of the circle.

Draws a polygon using the current pen settings.

The points of the polygon.

Draws an arc using the current pen settings.

The bounding rectangle of the arc. The starting angle of the arc, in degrees. The sweep angle of the arc, in degrees.

Draws an arc using the current pen settings, with an option to connect to the center.

The bounding rectangle of the arc. The starting angle of the arc, in degrees. The sweep angle of the arc, in degrees. If true, connects the arc endpoints to the center point, forming a pie shape.

Draws another bitmap onto this bitmap.

The bitmap to draw. The destination rectangle for the drawn bitmap.

Draws a line using the current pen settings.

The starting point of the line. The ending point of the line.

Draws connected lines through a series of points using the current pen settings.

The points to connect with lines.

Applies a Gaussian blur effect to the current bitmap.

The radius of the blur, controlling its intensity. Must be non-negative. Determines the behavior at the edges of the bitmap: true to clamp the edges (default), or false to repeat the edges.

Applies a Gaussian blur effect to the current bitmap.

Adjusts brightness, contrast, and saturation in one pass.

Adjusts the hue of the bitmap.

The angle to rotate the hue, in degrees (0 to 360).

Color the bitmap using this color, respect alpha

Tint the bitmap using this color, respect alpha

Shrink the image by adding padding all around - without resizing the bitmap

Applies a posterize effect to the bitmap.

The number of color levels to reduce to (e.g., 2, 4, 8).

Converts a heightmap to a normal map using parallel processing.

The strength of the normal map effect (default is 1.0). The generated normal map as an SKBitmap.

Gets the height value from the pixel array, clamped to the edges.

Inverts the colors of the bitmap while preserving alpha.

Loads a bitmap from the specified byte array.

The byte array containing the image data. A new instance.

Return true if this data is a Ies file

Creates a Bitmap instance from PSD file data.

Byte array containing the PSD file data. A Bitmap instance if successful, or null if the data is not valid PSD.

Checks if the provided byte array is a valid PSD file.

Byte array to check. True if the data is a PSD file, otherwise false.

Create a bitmap from an SVG, with optional size

Return true if this data is a Tga file

Sets the pen for drawing with a solid color and stroke style.

Sets the pen to use a specific blend mode.

The blend mode to apply.

Sets the pen for drawing with a solid color and stroke style.

The color of the pen. The width of the pen in pixels.

Sets the pen for drawing dashed or dotted lines.

The color of the pen. The width of the pen in pixels. An array defining the dash pattern (e.g., [10, 5] for 10px dash, 5px gap).

Sets the pen for drawing filled shapes with a solid color.

The color to fill the shapes with.

Sets the pen for drawing with a linear gradient.

the gradient's start point. the gradient's end point. The color of the gradient.

Sets the pen for drawing with a radial gradient.

The gradient's center. The radius of the gradient. The color of the gradient.

Exports the bitmap as a JPEG byte array with the specified quality.

The quality of the JPEG, between 0 and 100. A byte array containing the JPEG image data.

Exports the bitmap as a PNG byte array.

A byte array containing the PNG image data.

Exports the bitmap as a BMP byte array.

A byte array containing the BMP image data.

Exports the bitmap as an HDR WebP byte array with the specified quality.

The quality of the WebP image, between 0 and 100. A byte array containing the WebP HDR image data.

Exports the bitmap to the specified image format with optional quality.

The image format (e.g., PNG, JPEG, BMP). The quality of the image, used for formats like JPEG. A byte array containing the image data.

Exports the bitmap to the specified engine format

Draws text onto this bitmap

Try to create a texture from this bitmap

Rotates the bitmap by the specified angle.

The angle in degrees to rotate the bitmap. A new instance with the rotated image.

Resizes the bitmap to the specified dimensions and returns a new bitmap.

The new width of the bitmap. The new height of the bitmap. Resample smoothly. If false this will be nearest neighbour. A new instance with the specified dimensions.

Flips the bitmap vertically.

A new instance with the flipped image.

Flips the bitmap horizontally.

A new instance with the flipped image.

Crops the bitmap to the specified rectangle.

The rectangle to crop to. A new instance with the cropped image.

A texture is an image used in rendering. Can be a static texture loaded from disk, or a dynamic texture rendered to by code. Can also be 2D, 3D (multiple slices), or a cube texture (6 slices).

Begins creation of a custom texture. Finish by calling .

Begins creation of a custom 3D texture. Finish by calling .

Begins creation of a custom cube texture. (A texture with 6 sides) Finish by calling .

Begins creation of a custom texture array. Finish by calling .

Begins creation of a render target. Finish by calling .

The texture builder to help build the render target.

A convenience function to quickly create a render target.

A meaningless debug name for your texture. The image format. The size of the texture. The newly created render target texture.

This will create a render target texture if is null or doesn't match what you've passed in. This is designed to be called regularly to resize your texture in response to other things changing (like the screen size, panel size etc).

A meaningless debug name for your texture. The image format. The size of the texture. A previously created texture. Will return a new texture, or the .

Create a texture from an SVG source

Allow the texture to keep a reference to its parent object (like a videoplayer).

Has the native handle changed?

Whether this texture is an error or invalid or not.

Flags providing hints about this texture

Private constructor, use

Texture index. Bit raw dog and needs a higher level abstraction.

Replace our strong handle with a copy of the strong handle of the passed texture Which means that this texture will invisibly become that texture. I suspect that there might be a decent way to do this in native using the resource system. In which case we should change all this code to use that way instead of doing this.

Width of the texture in pixels.

Height of the texture in pixels.

Depth of a 3D texture in pixels, or slice count for 2D texture arrays, or 6 for slices of cubemap.

Number of mip maps this texture has.

Returns a Vector2 representing the size of the texture (width, height)

Whether this texture has finished loading or not.

Image format of this texture.

Returns how many frames ago this texture was last used by the renderer

Gets if the texture has UAV access

Will release the handle for this texture. If the texture isn't referenced by anything else it'll be released properly. This will happen anyway because it's called in the destructor. By calling it manually you're just telling the engine you're done with this texture right now instead of waiting for the garbage collector.

If this texture is a sprite sheet, will return information about the sheet, which is generally used in the shader. You don't really need to think about the contents.

The count of sequences in this texture, if any. The rest of the sequence data is encoded into the texture itself.

Get the frame count for this sequence

Get the total length of this seqence

TODO: Fill this out, build a structure of Sequence[] for people to access Then make it so we can actually preview them

Tells texture streaming this texture is being used. This is usually automatic, but useful for bindless pipelines.

Mark this texture as loading, create a texture in a task, replace this texture with it, mark it as loaded. This is for situations where you create a placeholder texture then replace it with the real texture later.

Try to load a texture from given filesystem, by filename.

All the helpers should flow through this to actually load

Try to load a texture.

Load avatar image of a Steam user (with a certain size if supplied).

The SteamID of the user to load the avatar of. The size of the avatar (Can be 32, 64, or 128. Defaults to 64 and rounds input to nearest of the three). The avatar texture

Load a texture asynchronously. Will return when the texture is loaded and valid. This is useful when loading textures from the web.

Load a texture asynchronously. Will return when the texture is loaded and valid. This is useful when loading textures from the web, or without any big loading hitches.

Try to get an already loaded texture.

The filename of the texture. The already loaded texture, or null if it was not yet loaded.

Reads pixel colors from the texture at the specified mip level

Reads a 2D range of pixel values from the texture at the specified mip level, writing to . This reads one slice from a 2D texture array or 3D texture volume.

Pixel value type (e.g., , , or ) Pixel region to read. For 2D texture arrays or 3D texture volumes, which slice to read from. Mip level to read from. Array to write to, starting at index 0 for the first read pixel. Pixel format to use when writing to . We only support some common formats for now. Dimensions of destination pixel array. Matches by default.

Reads a 2D range of pixel values from the texture at the specified mip level, writing to . This reads one slice from a 2D texture array or 3D texture volume.

Reads a 3D range of pixel values from the texture at the specified mip level, writing to . This can be used with a 2D texture array, or a 3D volume texture.

Pixel value type (e.g., , , or ) Pixel region to read. Mip level to read from. Array to write to, starting at index 0 for the first read pixel. Pixel format to use when writing to . We only support some common formats for now. Dimensions of destination pixel array. Matches by default.

Reads a single pixel color.

Reads a single pixel color from a volume or array texture.

Asynchronously reads all pixel colors from the texture at the specified mip level.

Callback function that receives the pixel data when ready. Mip level to read from. This operation is asynchronous and won't block the calling thread while data is downloaded from the GPU. The data provided to the callback is only valid for the duration of the callback execution. Storing references to the Span beyond the callback's scope will result in undefined behavior.

Asynchronously reads a 2D range of pixel values from the texture at the specified mip level.

Pixel value type (e.g., , , or ) Callback function that receives the pixel data when ready. Pixel format to use when writing to the destination buffer. Pixel region to read. If omitted full texture will be read. For 2D texture arrays or 3D texture volumes, which slice to read from. Mip level to read from. This operation is asynchronous and won't block the calling thread while data is downloaded from the GPU. The data provided to the callback is only valid for the duration of the callback execution. Storing references to the Span beyond the callback's scope will result in undefined behavior.

Asynchronously reads a 3D range of pixel values from the texture at the specified mip level.

Pixel value type (e.g., , , or ) Callback function that receives the pixel data when ready. Pixel format to use when writing to the destination buffer. Pixel region to read. If omitted full texture will be read. Mip level to read from. This operation is asynchronous and won't block the calling thread while data is downloaded from the GPU. The data provided to the callback is only valid for the duration of the callback execution. Storing references to the Span beyond the callback's scope will result in undefined behavior.

Asynchronously reads the texture into a bitmap at the specified mip level.

Callback function that receives the bitmap when ready. Mip level to read from. This operation is asynchronous and won't block the calling thread while data is downloaded from the GPU. Unlike the other async methods, the Bitmap provided to the callback is valid beyond the callback's scope as it owns its memory.

Converts image data from one format to another and writes to an existing buffer.

Creates a VTEX file from this texture.

For cubemaps, this assumes the texture was rendered for use with inverted scale sampling (like EnvmapProbe's dynamic rendering). Face pairs are swapped and flipped to compensate so the saved texture can be sampled normally. Optional format override. If null, the format is automatically determined based on texture properties.

Gets a single face from a cubemap texture as a bitmap, applying the necessary flip transformation for cubemaps rendered with inverted scale sampling.

Asynchronously saves the current data to the VTEX platform and returns the resulting byte array.

Optional format override. If null, the format is automatically determined based on texture properties.

1x1 solid magenta colored texture.

1x1 solid white opaque texture.

1x1 solid black opaque texture.

1x1 fully transparent texture.

Clear this texture with a solid color

Update this texture with given raw data.

The raw data pixels, appropriate for this textures format. If updating a subsegment of the texture, this will be start coordinates on the target texture. (Top Left) If updating a subsegment of the texture, this will be start coordinates on the target texture. (Top Left) Width of the image contained in . Height of the image contained in .

Update this texture with given raw data.

Update this texture from the bitmap

Update this 3D texture with given raw data.

The raw data pixels, appropriate for this textures format. If updating a subsegment of the texture, this will be start coordinates on the target texture. (Top Left) If updating a subsegment of the texture, this will be start coordinates on the target texture. (Top Left) If updating a subsegment of the texture, this will be start coordinates on the target texture. Width of the image contained in . Height of the image contained in . Depth of the image contained in .

Write a coloured rectangle to the texture

Write a coloured pixel to the texture

Provide a name to identify the texture by

Desired texture name

Initialize texture with pre-existing texture data.

Texture data. How big our texture data is.

Initialize texture with pre-existing texture data.

Texture data type Texture data

Create a texture with data using an UNSAFE intptr

Pointer to the data Length of the data

Use Multi-Sample Anti Aliasing (MSAA) of given sample count.

Set whether the texture is an anonymous texture or not

Set if it's anonymous or not

Build and create the actual texture

Custom methods

Create texture with a predefined size.

Width in pixel. Height in pixels.

Create texture with a predefined size

Width and Height in pixels

Provide a name to identify the texture by

Desired texture name

Initialize texture with pre-existing texture data

Texture data

Initialize texture with pre-existing texture data

Texture data How big our texture data is

Create a texture with data using an UNSAFE intptr

Pointer to the data Length of the data

Define which how much multisampling the current texture should use

Multisampling amount

Set whether the texture is an anonymous texture or not

Set if it's anonymous or not

Build and create the actual texture

Custom methods

Create texture with a predefined size

Width in pixel Height in pixels Depth in pixels

Create texture with a predefined size

Width, Height and Depth in pixels

Provide a name to identify the texture by

Desired texture name

Initialize texture with pre-existing texture data

Texture data

Initialize texture with pre-existing texture data

Texture data How big our texture data is

Create a texture with data using an UNSAFE intptr

Pointer to the data Length of the data

Define which how much multisampling the current texture should use

Multisampling amount

Set whether the texture is an anonymous texture or not

Set if it's anonymous or not

Build and create the actual texture

Custom methods

Create texture with a predefined size

Width in pixel Height in pixels

Create texture array with this many textures

Once the texture is created it will be cleared to this color

Provides a hint to the GPU that this texture will not be modified.

Provides a hint to the GPU that this texture will only be updated sometimes.

Provides a hint to the GPU that this texture will be updated regularly. (almost every frame)

Specify the texture to ONLY be used on the GPU on not allow CPU access.

Sets the texture to use 2x multisampling.

Sets the texture to use 4x multisampling.

Sets the texture to use 6x multisampling.

Sets the texture to use 8x multisampling.

Sets the texture to use 16x multisampling.

Sets the texture to use the same multisampling as whatever the screen/framebuffer uses

The internal texture format to use.

Texture format

Sets the internal texture format to use the same format as the screen/frame buffer.

Uses the same depth format as what the screen/framebuffer uses.

Generate amount of mip levels.

How many mips should be generated for this texture

Support binding the texture as a Unordered Access View in a compute or pixel shader. This is required for binding a texture within a compute shader.

Finish creating the texture.

Name for the new texture. Whether this texture is anonymous. Raw color data in correct format for the texture. Length of the . The created texture. Thrown when the texture size is invalid, i.e. less then or equal to 0 on either axis.

Provide a name to identify the texture by

Desired texture name

Initialize texture with pre-existing texture data

Texture data

Initialize texture with pre-existing texture data

Texture data How big our texture data is

Create a texture with data using an UNSAFE intptr

Pointer to the data Length of the data

Define which how much multisampling the current texture should use

Multisampling amount

Set whether the texture is an anonymous texture or not

Set if it's anonymous or not

Build and create the actual texture

Custom methods

Create texture with a predefined size

Width in pixel Height in pixels

Create texture with a predefined size

Width and Height in pixels

Facilitates loading of Steam user avatars.

Caches raw avatar pixel data from Steam API responses to avoid repeat network requests.

Caches raw downloaded bytes on a sliding window, so repeated loads don't re-download while keeping VRAM free when textures aren't in use.

Loads a thumbnail of an entity or something

Flags providing hints about a texture

Hint that this texture has pre-multiplied alpha

List of all vertices in this buffer.

All indices associated with the vertices of this buffer

Whether this vertex buffer has any indexes. This is set by .

Clear all vertices and indices, and resets .

Clear the buffer and set whether it will have indices.

Whether this buffer will have indices. Affects .

Add a vertex

Add an index. This is relative to the top of the vertex buffer. So 0 is Vertex.Count., 1 is Vertex.Count -1

Thrown when is false.

Add a triangle by indices. This is relative to the top of the vertex buffer. So 0 is Vertex.Count.

Thrown when is false.

Add an index. This is NOT relative to the top of the vertex buffer.

Thrown when is false.

Draw this mesh using Material

When applied to a component, the editor will draw a selectable handle sprite for the gameobject in scene

If this exists and is enabled in a scene, then the client will hear from this point rather than from the cameras point of view.

If true, while the audio listener position will be used, the rotation element will come from the camera.

The mixer we want this sound to play through

Apply DSP to mixer when listener is inside a DspVolume

Drive morphs with lipsync from sounds.

Plays a sound within a box.

Plays a sound at a point in the world.

Return true if the sound is playing

Plays a soundscape when the listener enters the trigger area.

Can be heard from anywhere.

Can be heard within a radius.

Can be heard within the bounds of a box.

Determines when/where the soundscape can be heard.

The mixer that the soundscape will play on.

When true the soundscape will keep playing after exiting the area, and will only stop playing once another soundscape takes over.

The radius of the Soundscape when is set to .

The size of the Soundscape when is set to .

Return true if they should hear this soundscape when in this position

Load and start this soundscape..

True if this sound has finished, can be removed

Gets set when it's time to fade this out

We store the current volume so we can seamlessly fade in and out

Consider us dead if the soundscape system thinks we're finished and our volume is low

If we're using the same sound file as this incoming sound, and we're on our way out.. then let it replace us instead. This is much nicer.

Records and transmits voice/microphone input to other players.

How long has it been since this sound played?

Laughter score for the current audio frame, between 0 and 1

A list of 15 lipsync viseme weights. Requires to be enabled.

Returns true if the mic is listening. Even if it's listening, it might not be playing - because it will only record and transmit if it can hear sound.

Measure of audio loudness.

Exclude these connection from hearing our voice.

Whether we want to hear voice from a particular connection.

Every scene should have at least one Camera.

Enables and configures auto exposure on the camera. This is usually controlled by the Tonemapping component. But if you're not using that, it can be controlled manually here.

Add a command list to the render

Remove an entry

Remove all entries in this stage

Called during the render pipeline. Currently this is rendered on the main thread, but ideally, one day, this will all be threaded.

The clear flags for this camera.

The background color of this camera's view if there's no 2D Sky in the scene.

Returns true if this is the main game camera.

The axis to use for the field of view.

The field of view of this camera.

The camera's near clip plane distance. This is the closest distance this camera will be able to render. A good value for this is about 5. Below 5 and particularly below 1 you're going to start to see a lot of artifacts like z-fighting.

The camera's far clip plane distance. This is the furthest distance this camera will be able to render. This value totally depends on the game you're making. Shorter the better, sensible ranges would be between about 1000 and 30000, but if you want it to be further out you can balance that out by making ZNear larger.

The priority of this camera. Dictates which camera gets rendered on top of another. Higher means it'll be rendered on top.

Whether or not to use orthographic projection instead of perspective.

The orthographic size for this camera while is set to true.

The HMD eye that this camera is targeting. Use for the user's monitor (i.e. the companion window).

A list of tags that will be checked to include specific game objects when rendering this camera. If none are set, it will include everything.

A list of tags that will be checked to exclude specific game objects when rendering this camera.

The size of the camera represented on the screen. Normalized between 0 and 1.

If specified, this camera will render to this RenderTexture instead of the screen. This can then be used in other stuff like materials.

Since we are rendering to a texture, better to generate mipmaps for it.

The texture to draw this camera to. Requires

Render this camera using a different render mode

Render this camera using a wireframe view.

Accessor for getting this Camera Component's SceneCamera

Update a SceneCamera with the settings from this component

Update the SceneCamera UI with the settings from this component

Obsolete 09/06/2025

Obsolete 02/10/2025

This should only be called when creating render lists!!

The size of the viewport, in screen coordinates

Given a BBox in world space, will return the screen space rect that totally contains the box.

Convert from screen coords to world coords on the near frustum plane.

Returns the view frustum of the current screen rect.

Given a pixel rect return a frustum on the current camera.

Given a pixel rect return a frustum on the current camera. Pass in 1 to ScreenSize to use normalized screen coords.

Render scene to a texture from this camera's point of view

Allows specifying a custom projection matrix for this camera

Allows specifying a custom aspect ratio for this camera. By default (or when null) the camera size is screen size or render target size.

Get frustum projection matrix.

Calculates a projection matrix with an oblique clip-plane defined in world space.

Fits the view within the x-axis.

Fits the view within the y-axis.

Render this camera to the target bitmap.

Allows drawing on the camera. This is drawn before the post processing.

Used to draw to the screen. This is drawn on top of everything, so is good for debug overlays etc.

Enable or disable post processing for this camera.

If set then we'll trigger post process volumes from this position, instead of the camera's position.

Applies a cubemap fog effect to the camera

Allows collision constrained movement without the need for a rigidbody. This is not affected by forces and will only move when you call the Move() method.

When jumping into walls, should we bounce off or just stop dead?

If enabled, determine what to collide with using current project's collision rules for the of the containing .

Add acceleration to the current velocity. No need to scale by time delta - it will be done inside.

Apply an amount of friction to the current velocity. No need to scale by time delta - it will be done inside.

Trace the controller's current position to the specified delta

Disconnect from ground and punch our velocity. This is useful if you want the player to jump or something.

Move a character, with this velocity

Move from our current position to this target position, but using tracing an sliding. This is good for different control modes like ladders and stuff.

Trace this from one position to another

Try to move to the position. Will return the fraction of the desired velocity that we traveled. Position and Velocity will be what we recommend using.

Move our position by this delta using trace. If we hit something we'll stop, we won't slide across it nicely like TryMove does.

Like TryMove but will also try to step up if it hits a wall

Used to store a list of planes that an object is going to hit, and then remove velocity from them so the object can slide over the surface without going through any of the planes.

Maximum number of planes that can be hit

Number of planes we're currently holding

Try to add this plane and restrain velocity to it (and its brothers)

False if we ran out of room and should stop adding planes

Try to clip our velocity to all the planes, so we're not travelling into them Returns true if we clipped properly

Returns true if we're moving towards any of our planes (except for skip)

Start a new bump. Clears planes and resets BumpVelocity

Clip the velocity to the normal

Defines a box collider.

The size of the box, from corner to corner.

The center of the box relative to this GameObject

Defines a capsule collider.

Bottom point of the capsule

Top point of the capsule

Radius of the capsule

Return true if this collider is using dynamic physics. Returns false if this is a keyframe body, or a static physics body.

Allows overriding the friction for this collider. This value can exceed 1 to to give crazy grippy friction if you want it to, but the normal value is between 0 and 1.

Allows overriding the elasticity for this collider. Controls how bouncy this collider is.

Allows overriding the rolling resistance for this collider. Controls how easily rolling shapes (sphere, capsule) roll on surfaces.

Set the local velocity of the surface so things can slide along it, like a conveyor belt

Calculated local bounds of all physics shapes in this collider.

Overridable in derived component to create shapes

Called when a collider enters this trigger

Called when a collider exits this trigger

Called when a gameobject enters this trigger

Called when a gameobject exits this trigger

If we're a trigger, this will list all of the colliders that are touching us. If we're not a trigger, this will list all of the triggers that we are touching.

Apply any things that we an apply after they're created

Get the velocity of this collider at the specific point in world coordinates.

Returns the closest point to the given one between all convex shapes of this body.

Get the world bounds of this object

Flags that modify the behavior of this collider

If we're a keyframe collider, this is the set of joints attached to us. If we're not then this won't ever return anything.

Called right before physics simulation to move the keyframebody to its new transform.

If this collider is part of a Rigidbody then this will return the component that it's attached to. If this is null it's usually a good indication that this collider is either static, world geometry, or a keyframe.

Returns either the rigidbody's physics body or the keyframe's physics body.

Called when a Rigidbody is enabled. It calls this on all downstream colliders. On our part, we look at who out nearest parent rigidbody is and add ourselves to that.

An upstream rigidbody has been disabled or destroyed. We look for the nearest parent rigidbody and add ourselves to that. If one doesn't exist we become a kinematic collider.

Traces can never see this collider, no matter what happens

Collider has no mass, won't affect physics objects it collides with

Used to abstract the listening of collision events

Swap to a new physics body without reallocating delegates.

Defines a box, cone, or cylinder hull collider.

The type of primitive.

The center of the primitive relative to this GameObject.

The size of the box, from corner to corner.

Defines a collider based on a model.

Physics for a model. This is primarily used for ragdolls and other physics driven models, otherwise you should be using a Rigidbody.

Number of times the physics have been rebuilt. Debugging use only.

Number of times the physics have been destroyed. Debugging use only.

The model used to generate physics bodies, collision shapes, and joints.

The renderer that receives transform updates from physics bodies.

If true, the root physics body will not drive this component's transform.

Rigidbody flags applied to all bodies.

Rigidbody locking applied to all bodies.

All bodies will be put to sleep on start.

Enable to drive renderer from physics, disable to drive physics from renderer.

Returns the total mass of every

Returns the center of mass of every in world-space

Apply body transforms to renderer bones.

Smooth move bodies to animated bone transforms for bodies that have motion disabled.

Adjust joint points for body scaling.

Put all bodies to sleep.

Copy the bone positions and velocities from a different SkinnedModelRenderer

Represents a attached to a specific bone with a local transform.

Represents a between two bodies with local frames for each.

Networked list of bodies.

Networked list of joints.

Networked transforms.

Sync visual transforms to physics transforms.

Send body transforms.

Move proxy bodies to networked body transforms.

Create all the bodies, colliders and joints.

Destroy all the bodies, colliders and joints.

Defines a plane collider.

The size of the plane, from corner to corner.

The center of the plane relative to this GameObject.

The normal of the plane, determining its orientation.

Adds physics properties to an object. Requires a collider to be attached to the same object.

Applies buoyancy and drag to the rigidbody relative to a plane to simulate things floating in water.

Tell all the downstream colliders that we exist. This gives them a chance to re-configure themselves. This doesn't meant they'll become shapes on our body, it just means they have potential to. They really just look for their nearest parent that has a Rigidbody on it, and then that becomes their boss.

Tell all the colliders we're fucking off. Clear the list.

Called by a collider to tell the Rigidbody that it's part of it

Called by a collider to tell the Rigidbody that it's no longer part of it

Is gravity enabled or not.

Scale the gravity relative to . 2 is double the gravity, etc.

Override mass for this body, only when value is more than zero

Center of mass for this rigidbody in local space coordinates.

Whether this rigidbody can deal damage to damageable objects on high-speed impacts.

The minimum speed required for an impact to cause damage.

The amount of damage this rigidbody deals to other objects when it collides at high speed. If set to 0 or less, this will be calculated from the mass of the rigidbody.

The game object source for finding collision listeners.

Enable or disable touch events. If you disable the events then ICollisionListener won't get any touch events and you won't get things like collision sounds.

Like CollisionEventsEnabled but means the OnCollisionUpdate gets called when the collision persists

Gets or sets the inertia tensor for this body. By default, the inertia tensor is automatically calculated from the shapes attached to the body. Setting this property overrides the automatically calculated inertia tensor until is called.

Gets or sets the rotation applied to the inertia tensor. Like , this acts as an override to the automatically calculated inertia tensor rotation and remains in effect until is called.

Enable enhanced continuous collision detection (CCD) for this body. When enabled, the body performs CCD against dynamic bodies (but not against other bodies with enhanced CCD enabled). This is useful for fast-moving objects like bullets or rockets that need reliable collision detection.

Resets the inertia tensor and its rotation to the values automatically calculated from the attached colliders. This removes any custom overrides set via or .

Gets the effective impact damage value. If ImpactDamage is not set, calculates a default value based on the rigidbody's mass.

Called when this rigidbody starts colliding with another object. Handles velocity-based damage for high-speed impacts.

Used for transforming a selected rigidbody in editor, if useful for gameplay this could be made public.

Linear velocity before physics step. Internal until someone needs them.

Angular velocity before physics step. Internal until someone needs them.

Called whenever the local transform of this component changes. This is used to update the physics body with the new position and rotation.

Get the actual physics body that was created by this component. You should be careful, this can of course be null when the object is not enabled or the physics world is not available. It might also get deleted and re-created, so best use this to access, but don't store it.

Returns the closest point to the given one between all convex shapes of this body.

Returns the world space velocity of a point of the object. This is useful for objects rotating around their own axis/origin.

Applies force to this body at given position.

Applies linear force to this body

Applies angular velocity to this body.

Applies instant linear impulse (i.e. a bullet impact) to this body at given position

Applies instant linear impulse (i.e. a bullet impact) to this body

Clear accumulated linear forces ( and ) during this physics frame that were not yet applied to the physics body.

Move body to this position in a way that cooperates with the physics system. This is quite good for things like grabbing and moving objects.

Rotate the body to this position in a way that cooperates with the physics system.

Updates the physics body with the current properties of this component.

This is a list of all of the triggers that we are touching.

A list of joints that we're connected to, if any.

Get the world bounds of this object

Defines a sphere collider.

A GameObject can have many components, which are the building blocks of the game.

Runs after this clone has been created by a cloned GameObject.

The original component that was cloned. During the cloning process, we build a mapping from original objects to their clone, so we will need to add ourselves to it.

Runs after all objects of the original hierarchy have been cloned/created. Here we initialize the clones properties and fields with the values from the original object. A mapping of original objects to their clones, used for all reference types. A mapping of original GUIDs to cloned GUIDs, used for GameObject and Component references in JSON.

Invokes the callback for the given type. Called internally by to avoid delegate allocations.

The scene this Component is in. This is a shortcut for `GameObject.Scene`.

The transform of the GameObject this component belongs to. Components don't have their own transforms but they can access the transform of the GameObject they belong to. This is a shortcut for `GameObject.Transform`.

The GameObject this component belongs to.

Allow creating tasks that are automatically cancelled when the GameObject is destroyed.

Access components on this component's GameObject

Called to call Awake, once, at startup.

The enable state of this . This doesn't tell you whether the component is actually active because its parent might be disabled. This merely tells you what the component wants to be. You should use to determine whether the object is truly active in the scene.

True if this Component is enabled, and all of its ancestor GameObjects are enabled

Should this component execute? Should OnUpdate, OnEnabled get called?

Called once per component

Called after Awake or whenever the component switches to being enabled (because a gameobject hierarchy active change, or the component changed)

Called once, when the component or gameobject is destroyed

When enabled, called every frame, does not get called on a dedicated server

Replaces with , and adds / removes this component from the given , depending on whether the new action is null, and this type implements the given interface.

Destroy this component, if it isn't already destroyed. The component will be removed from its GameObject and will stop existing. You should avoid interating with the component after calling this.

Destroy the parent GameObject. This really only exists so when you're typing Destroy you realise that calling Destroy only destroys the Component - not the whole GameObject.

Called immediately after deserializing, and when a property is changed in the editor.

Called immediately after being refreshed from a network snapshot.

Called when something on the component has been edited

When tags have been updated

The parent has changed from one parent to another

Invoke a method in x seconds. Won't be invoked if the component is no longer active.

Allows drawing of temporary debug shapes and text in the scene

The parent object is being destroyed. This is a nice place to switch to a healthier parent.

Called when a property is set, which will run a callback

Called when the component has become dirty

A list of running doos

Starts executing the given Doo on this component. Optionally configure initial arguments via the callback.

Stop a specific Doo, if it's running

Stop all running Doos

Returns true if the given Doo is currently running on this component.

Add a component to this GameObject

Get a component on this GameObject

Get components on this GameObject

Get components on this GameObject and on descendant GameObjects

Get component on this GameObject or on descendant GameObjects

Get components on this GameObject and on ancestor GameObjects

Get component on this GameObject and on ancestor GameObjects

Called in the editor to draw things like bounding boxes etc

Should only be called by .

Allows overriding the ID of this object. This should be used sparingly, and only when necessary. This is generally used for network reasons, to make something deterministic.

The local transform of the game object.

The local position of the game object.

The local rotation of the game object.

The local scale of the game object.

True if this is a networked object and is owned by another client. This means that we're not controlling this object, so shouldn't try to move it or anything.

Get or create a new interpolated variable. This will set the current interpolated value to the provided one if it hasn't been created yet.

Check all of our properties for a [RequireComponent] attribute. If we find one, and the property is null, try to find one or create one. Runs in the editor as well as in game.

When is , properties absent from (e.g. omitted by ) are explicitly cleared to null/default rather than left at their existing value. Used for all network receive paths.

Deserialize this component as per but update and property references immediately instead of having them deferred.

Json Keys used for serialization and deserialization of Components. Kept here so they are easier to change, and we are less susceptible to typos.

Called once before the first Update - when enabled.

When enabled, called every frame

When enabled, called on a fixed interval that is determined by the Scene. This is also the fixed interval in which the physics are ticked. Time.Delta is that fixed interval.

The version of the component. Used by .

The world transform of the game object.

The world position of the game object.

The world rotation of the game object.

The world scale of the game object.

A component with this interface will not run on dedicated servers.

A component with this interface will run in the editor.

A with this interface can react to collisions.

Called when this collider/rigidbody starts touching another collider.

Called once per physics step for every collider being touched.

Called when this collider/rigidbody stops touching another collider.

When applied to a , the component will be able to provide the color to use for certain UI editor elements.

A component that can be damaged by something.

A component that has bounds

Returns bounds, in local space

A with this interface can react to network events.

Called on the host to decide whether to accept a . If any that implements this returns false, the connection will be denied.

The reason to display to the client.

Called when someone joins the server. This will only be called for the host.

Called when someone leaves the server. This will only be called for the host.

Called when someone is all loaded and entered the game. This will only be called for the host.

Called when the host of the game has left - and you are now the new host.

When implemented on a or it can read and write data to and from a network snapshot.

Read data from the snapshot.

Write data to the snapshot.

A with this interface can listen for when a GameObject in its ancestors has been network spawned.

Called when this object is spawned on the network.

A with this interface can determine whether a networked object should be visible for a specific .

Whether this networked object is visible for the specified .

A component that can be pressed. Like a button. This could be by a player USE'ing it, or by a player walking on it, or by an NPC. A call to Press should ALWAYS call release afterwards. Generally this is done by the player, where holding E presses the button, and releasing E stops pressing it. You need to handle edge cases where the player dies while holding etc.

Describes who pressed it.

A tooltip to show when looking at this pressable

A player has started looking at this

A player is still looking at this. Called every frame.

A player has stopped looking at this

Pressed. Returns true on success, else false. If it returns true then you should call Release when the press finishes. Not everything expects it, but some stuff will.

Still being pressed. Return true to allow the press to continue, false cancel the press

To be called when the press finishes. You should only call this after a successful press - ie when Press hass returned true.

Return true if the press is possible right now

Get a tooltip to show when looking at this pressable

Allows scene systems to react to render threads

Called on update start. This is the very first thing called.

Allows components to indicate their state in a generic way. This is useful if you have a temporary effect system in which you want to remove GameObjects when their effects have all finished.

Should return true if the effect is active in a visible way

Indicates to the target object that we want it to die. If it's looping then it should stop now and put itself in a state where it will eventually die.

Disable the any looping effects. This indicates to the target object that we want it to die soon.

A that lets you change its color.

A with this interface can react to interactions with triggers.

Called when a collider enters the trigger.

The collider that entered.

Called when a collider enters the trigger.

This trigger's collider. The collider that entered.

Called when a collider exits the trigger.

The collider that exited.

Called when a collider exits the trigger.

This trigger's collider. The collider that exited.

Called when a game object enters the trigger.

The game object that entered.

Called when a game object enters the trigger.

This trigger's collider. The game object that entered.

Called when a game object exits the trigger.

The game object that exited.

Called when a game object exits the trigger.

This trigger's collider. The game object that exited.

Provides helper methods for cloning objects and their members. We use a heuristic to determine if a type can be cloned by copy to speed up cloning. If we cannot copy something and we have to "clone" we do so by serializing to and deserializing from JSON. However, our goal is to copy as much as possible to avoid the serialization overhead.

We want GUIDS that reference something within the original hierarchy to reference the corresponding clone in the new hierarchy.

Caches pre-compiled expression-tree delegates that copy a single member's value directly from source to target without boxing. Only used for value types that are safe to clone by copy. Cleared via after hotload and game close.

Hide this component in component inspector

Don't save this component to disk

There's something wrong with this

Loading something

Is in the process of deserializing

Cannot be edited in the component inspector

Keep local - don't network this component as part of the scene snapshot

In the process of refreshing from the network

Don't serialize this component when cloning

Can edit advanced properties in the component inspector

A serialized reference to a that can be resolved at runtime. Components are referenced by their , their containing object's , and their if available.

Reference a given .

Converts a into a , referencing the object that contains the component.

Expected to be "component" for a component reference.

The of the referenced component.

The of the object containing the referenced component.

If available, the of the referenced component.

Attempt to resolve into a . Returns if not resolved.

Optional base type / interface that the resolved type must derive from / implement. Defaults to .

Attempt to resolve this reference in the current . Returns if the reference couldn't be resolved, and logs a warning.

Attempt to resolve this reference in the given . Returns if the reference couldn't be resolved.

Scene to attempt to resolve the reference in. Optional base type / interface that the resolved instance must derive from / implement. Defaults to . If true, log a warning to the console if the reference couldn't be resolved.

The BeamEffect component creates a visual beam effect in the scene, simulating a continuous line or laser-like effect. Unlike LineRenderer these beams can change over time, spawn multiple instances, and have various properties like color, texture, and lifetime. This is a useful component for creating things like laser beams, energy effects and tracers.

Thickness of the beam in world units. Controls how wide the beam appears.

World position the beam targets if no target object is set. Used as the endpoint for the beam.

GameObject to target with the beam. If assigned, overrides TargetPosition and uses the object's world position as the endpoint.

Random offset applied to the target position for visual variation. Adds randomness to the endpoint.

If true, the beam endpoints follow their source and target positions each frame, updating dynamically.

Number of beams spawned per second. Controls the spawn rate for continuous effects.

Maximum number of beams that can exist at once. Limits the total active beams.

Number of beams spawned immediately when the effect is enabled.

Lifetime of each beam in seconds. Determines how long a beam remains before being removed or respawned.

If true, beams respawn automatically when they expire, creating a looping effect.

Texture applied to the beam. Defines the visual appearance along the beam's length.

Material applied to the beam. Defines the visual appearance along the beam's length. The material should be based on the `line.shader`.

Offset of the texture along the beam. Shifts the texture start position.

Scale of the texture along the beam. Controls how many world units each texture tile covers.

Speed at which the texture scrolls along the beam. Positive values scroll in one direction, negative in the other.

This is pretty much the same as TextureOffset - but it's seperate so you can use offset for offset, and scroll to scroll.

Controls texture filtering on this beam effect.

Color gradient of the beam over its lifetime. Defines how the color changes from birth to death.

Alpha multiplier for the beam's color. Controls transparency over the beam's lifetime.

Brightness multiplier for the beam's color. Adjusts intensity over the beam's lifetime.

If true, the beam is rendered additively, making it appear to glow.

If true, the beam casts shadows in the scene.

If true, the beam is affected by scene lighting.

If true, the beam is rendered as opaque rather than transparent.

Amount of feathering applied to the beam's depth, softening its intersection with geometry.

If true, the beam visually travels from start to end, useful for tracer effects.

Controls the interpolation of the beam's travel effect over its lifetime.

Returns true if there are any active beams.

Disables automatic looping of beams, preventing them from respawning when expired.

Represents an individual beam instance within the effect.

Start position of the beam in world space.

End position of the beam in world space.

LineRenderer component used to render the beam visually.

Time when the beam was created (born).

Time when the beam will expire (die).

Returns the normalized lifetime of the beam, ranging from 0 (just born) to 1 (expired).

Random seed used to generate consistent random values for this beam instance.

Destroys the beam instance, cleaning up its resources.

Spawns a new beam and adds it to the effect.

Support's Source Engine's vpcf particles

A GameObject representing the seat position

The sitting pose to use when a player is seated

Height offset for sitting position, from -1 (lowest) to 1 (highest)

A GameObject representing the eye position

Pitch range for seated players

Yaw range for seated players

Chair is usable if the player can enter

Called when the player has pressed to use the chair. Only called if CanPress returned true.

Called on the host to enter the chair.

Called on the client to place the player in the chair.

Called on the host to request leaving the chair.

Return true if this player can leave the chair

Called on the client to eject the player from the chair.

Returns a position to place the player when they exit the chair. This searches through ExitPoints to find the best one, which is usually the one the player is most facing towards.

Return true if this player can enter the chair

Get the transform representing the eye position when seated

Returns true if the chair is currently occupied

Gets the player that is currently occupying the chair

Called to update the player's animator when seated

Clamps the eye angles of a seated player between the PitchRange and YawRange

Calculates the eye transform for a seated player

Draws the player model sitting in the chair if it's selected

The title of this chair's tooltip. Empty to disable.

The icon for this chair's tooltip. Either Material Icons or an Emoji.

A longer description for this chair's tooltip.

Allows easily dressing a citizen or human in clothing

Manually select the clothing to wear

Dress according to the local user's avatar

Dress according to the avatar of the network owner of this GameObject

Where to get the clothing from

When using , strip any clothing items that are not owned in their Steam Inventory. Disable only if your game handles ownership checks itself.

Who are we dressing? This should be the renderer of the body of a Citizen or Human

Should we change the height too?

If we're dressing in an async way - stop it.

True if we're dressing, in an async way

Make a random outfit

Called when Height, Age or Tint is changed

Applies Height, Age and Tint.

Applies fire damage to any IDamageable in our Root object. Damage is tagged "fire" and "burn"

How much damage to apply per second

A gib is a prop that is treated slightly different. It will fade out after a certain amount of time.

A hitbox that can be placed manually on a GameObject, instead of coming from a model

The target GameObject to report in trace hits. If this is unset we'll default to the gameobject on which this component is.

Tags have been updated

Hitboxes from a model

The target SkinnedModelRenderer that holds the model/skeleton you want to take the hitboxes from.

The target GameObject to report in trace hits. If this is unset we'll defaault to the gameobject on which this component is.

The gameobject tags have changed, update collision tags on the target objects

The character is climbing up a ladder

A list of tags we can climb up - when they're on triggers

The GameObject we're climbing. This will usually be a ladder trigger.

When climbing, this is the rotation of the wall/ladder you're climbing, where Forward is the direction to look at the ladder, and Up is the direction to climb.

A move mode for this character

Update the animator which is available at Controller.Renderer.

Sets animation parameters on based on the current and .

Sets animation parameters on describing the movement style, like swimming, falling, or ducking.

Set animation parameters on to look towards .

Updates the of .

Get the position of the player's eye

Called to update the camera each frame

Highest number becomes the new control mode

Called before the physics step is run

Called after the physics step is run

This mode has just started

This mode has stopped. We're swapping to another move mode.

If we're approaching a step, step up if possible

If we're on the ground, make sure we stay there by falling to the ground

Read inputs, return WishVelocity

The character is sitting

Score this move mode highly if we're parented to a chair

Update the animator while sitting in a chair

Entering the chair, disable body and collider

Leaving the chair, re-enable body and collider

Move is always zero while sitting

Get the eye transform from the chair we're sitting in

Player pressed "use" but failed to press it. So we'll interpret that as wanting to leave the chair.

A component that can be sat in by a player. If the player is parented to an object with this component, they will be sitting in it.

Here you can set any animator parameters needed for sitting in this chair

Get the transform representing the eye position when seated. This is the first person eye position, not the third person camera position.

Player wants to leave the chair

The character is swimming

We will update this based on how much you're in a "water" tagged trigger.

The character is walking

The body will usually be a child object with SkinnedModelRenderer

If true we'll show the "create body" button

How strongly to look in the eye direction with our eyes

How strongly to turn in the eye direction with our head

How strongly to turn in the eye direction with our body

Update the animation for this renderer. This will update the body rotation etc too.

This is used to keep a distance away from surfaces. For example, when grounding, we'll be a skin distance away from the ground.

We will apply extra friction when we're on the ground and our desired velocity is lower than our current velocity, so we will slow down.

How much friction to add when we're in the air. This will slow you down unless you have a wish velocity.

Not touching the ground, and not swimming or climbing

Our actual physical velocity minus our ground velocity

The velocity that the ground underneath us is moving

Set to true when entering a climbing .

Set to true when entering a swimming .

Adds velocity in a special way. First we subtract any opposite velocity (ie, falling) then we add the velocity, but we clamp it to that direction. This means that if you jump when you're running up a platform, you don't get extra jump power.

The direction we're looking in input space.

The player's eye position, in first person mode

The player's eye transform, in first person mode

True if this player is ducking

The distance from the top of the head to the closest ceiling.

Make sure the body and our components are created

Update the body dimensions, and change the physical properties based on the current state

Events from the PlayerController

Our eye angles are changing. Allows you to change the sensitivity, or stomp all together.

Called after we've set the camera up

The player has just jumped

The player has landed on the ground, after falling this distance.

Used by the Using system to find components we can interact with. By default we can only interact with IPressable components. Return a component if we can use it, or else return null.

We have started using something (use was pressed)

We have stopped using something

We pressed USE but it did nothing

We have a chance to do something before input is processed

Draw debug overlay on footsteps

Play a footstep sound at the given world position. Will only play if the player has a GroundSurface.

The object we're standing on. Null if we're standing on nothing.

The collider component we're standing on. Null if we're standing nothing

If we're stnding on a surface this is it

The friction property of the ground we're standing on.

Are we standing on a surface that is physically dynamic

Amount of time since this character was last on the ground

Amount of time since this character was last not on the ground

Prevent being grounded for a number of seconds

Lift player up and place a skin level above the ground

Amount of seconds it takes to get from your current speed to your requuested speed, if higher

Amount of seconds it takes to get from your current speed to your requuested speed, if lower

The button that the player will press to use to run

If true then the player will run by default, and holding AltMoveButton will switch to walk

Allows to player to interact with things by "use"ing them. Usually by pressing the "use" button.

The button that the player will press to use things

How far from the eye can the player reach to use things

When true we'll move the camera around using the mouse

Allows modifying the eye angle sensitivity. Note that player preference sensitivity is already automatically applied, this is just extra.

Gets the current character height from when standing, otherwise uses when ducking.

Called during FixedUpdate when UseInputControls is enabled. Will duck if requested. If not, and we're ducked, will unduck if there is room

The object we're currently looking at

The object we're currently using by holding down USE

The tooltip of the currently hovered Pressable object

Called in Update when Using is enabled

Called every frame to update our pressed object

Called every frame to update our hovered status, unless it's being pressed

Stop pressing. Pressed will become null.

Start pressing a target component. This is called automatically when Use is pressed.

Called every frame with the component we're looking at - even if it's null

Get the best component we're looking at. We don't just return any old component, by default we only return components that implement IPressable. Components can implement GetUsableComponent to search and provide better alternatives.

Enable debug overlays for this character

Try to step up. Will trace forward, then up, then across, then down.

If we stepped up on the previous step, we suck our position back to the previous position after the physics step to avoid adding double velocity. This is technically wrong but doesn't seem to cause any harm right now

Return an aabb representing the body

Trace the aabb body from one position to another and return the result

Create a ragdoll gameobject version of our render body.

A prop is defined by its model. The model can define its health and what happens when it breaks. This component is designed to be easy to use - since you only need to define the model. Although you can access the procedural (hidden) components, they aren't saved, so it's a waste of time.

If the prop is static - it won't have dynamic physics. This is usually used for things that you want to be breakable but don't move. Like fences and stuff.

Physics will be asleep until it's woken up.

True if this prop can be set on fire.

Create the gibs for this prop breaking, over the network. This causes clients to spawn the gibs too.

Create the gibs and return them.

Delete this component and split into the procedural components that this prop created.

Applies damage in a radius, with physics force, and optional occlusion

The radius of the damage area.

How much physics force should be applied on explosion?

If enabled we'll apply damage once as soon as enabled

Should the world shield victims from damage?

The amount of damage inflicted

Tags to apply to the damage

Who should we credit with this attack?

Apply the damage now

Dictates where players will spawn when they join the game when using a NetworkHelper.

Deals damage to objects inside

These tags will be applied to the emitted

How much damage to apply

The delay between applying the damage

If not empty, the target must have one of these tags

If not empty, the target must not have one of these tags

Verlet integration-based rope physics simulation component.

The GameObject the end of the rope attaches to.

The LineRenderer used to visualize the rope.

Additional slack, added to the rope length.

Number of segments in the rope. Higher values increase visual fidelity and collision accuracy but quickly reduce performance.

Radius of the rope for collision detection.

Controls the rope's length directly, will override the initial length and slack will not be applied. When set to 0, the rope's initial length between attachment points is used.

Rope stiffness factor. Higher values make the rope more rigid.

Dampens rope movement. Higher values make the rope settle faster.

Controls how easily the rope bends. Lower values allow more bending, higher values make it stiffer.

The rope length when it initialized.

The length the rope would like to have.

Set on Initialize based on distance between attachment points and slack.

Gets the actual gravity to use.

Number of iterations to solve constraints. Higher values increase rigidity but reduce performance.

Base velocity threshold used for scaling the rest detection

Base segment length used for calibrating various calculations.

Consecutive frames of no movement required to consider the rope at rest.

Factor after which we consider a rope to be stretched.

Ignore collisions when segment is stretched beyond this factor

Velocity threshold below which we consider the rope to be at rest. Scale the rest velocity threshold based on segment length.

We use an array because we can acces members by ref. Which is faster than using a list.

This method checks each segment of the rope for collisions and adjusts their positions accordingly. It skips collision checks for segments that are excessively stretched to prevent the rope from becoming unstable. If the rope is extremely stretched, all collision checks are bypassed to allow the rope to recover.

Maintains GPU data for all instances in a scene. Collects, sorts, and uploads volume parameters to the renderer.

Probe updater implementation using Cubermapper for probe radiance collection.

Volume texture storing probe irradiance data (color).

Volume texture storing probe distance/visibility data.

Whether to do a second pass on probes that are inside geometry so they have accurate bounces.

Copies depth texture values to a color texture array slice using a compute shader.

Dynamic Diffuse Global Illumination volume that provides indirect lighting using a 3D probe grid. Probes store irradiance and distance data in volume textures that can be sampled by shaders.

Probe relocation functionality for DDGI volumes. Moves probes out of geometry to unfuck artifacts.

Behavior when a probe is detected inside geometry. Relocation moves the probe out of geometry to reduce artifacts, while Deactivate simply disables the occluded probe, sealing leaks entirely.

Probe is deactivated and won't contribute to lighting.

Probe is relocated to escape the geometry.

Per-probe data including position offset and active state.

CPU-side probe data indexed by flattened probe index.

World-space bounding box that defines the volume coverage area.

Number of probes per 1024 world units. Higher values increase probe resolution.

Bias applied along surface normals to prevent self-occlusion artifacts.

Controls how much less energy to conserve during probe integration. Higher values give a harsher, more contrasty look.

Calculated probe count along each axis based on bounds and density.

Volume texture storing probe irradiance data (color).

Volume texture storing probe distance/visibility data.

Volume texture storing probe relocation offsets (XYZ = offset, W = active).

Cancellation source for the current bake operation.

Starts the probe baking process to capture lighting into the volume textures.

Automatically sizes the volume to encompass all scene geometry.

Saves texture to disk and reloads it.

Builds GPU-ready structure for shader consumption.

Calculates probe count along each axis based on volume size and density.

Calculates spacing between probes based on volume size and probe counts.

Gets the local-space position of a probe at the given grid index.

Gets the world-space position of a probe at the given grid index.

Gets the relocated world position of a probe.

Gets probe data at the given grid index.

Number of ray directions to cast per probe for relocation analysis.

Number of iterative refinement steps when computing relocation.

Threshold for backface hit ratio to consider probe inside geometry.

Minimum distance (as fraction of min spacing) a probe should maintain from frontface geometry.

Maximum offset as fraction of probe spacing (forms ellipsoid constraint).

How far to trace rays as a multiple of the minimum probe spacing.

How to handle probes detected inside geometry.

Volume texture storing probe relocation offsets (XYZ = offset, W = active).

Result of tracing a single ray for relocation purposes.

Aggregated statistics from tracing all rays for a single probe.

Computes probe relocation offsets for all probes in the volume. Uses iterative refinement with mesh tracing. All computations are relative to probe spacing for resolution-independent behavior.

Traces rays in all provided directions from a probe position. Uses mesh tracing with CullMode = 0 (no culling) to detect both front and back faces.

Traces a single ray using mesh tracing and determines if it hit a backface. Uses CullMode = 0 (no culling) to get all hits, then uses dot product with normal to detect backfaces.

Computes the new probe offset for relocation. Returns the new absolute offset (not delta) and whether the probe should be deactivated. All distances are computed relative to probe spacing.

Returns true if the offset lies within the ellipsoid defined by spacing and the max factor.

Clears all probe relocation offsets.

Generates evenly distributed directions on a sphere using spherical Fibonacci. This provides a quasi-uniform distribution with good coverage properties.

Loads probe data from an existing relocation texture. This restores the Probes array after a scene reload.

Creates or updates the relocation texture from CPU offset data.

Fix two objects together but can rotate - like a shoulder.

The motor is disabled and only friction is applied.

The motor drives the joint towards a target rotation using frequency and damping.

The motor drives the joint with a target angular velocity and maximum torque.

Motor mode

Enables or disables the swing limit.

The minimum and maximum swing angles allowed by the joint in degrees.

Enables or disables the twist limit.

The minimum and maximum twist angles allowed by the joint in degrees.

Joint friction.

Target angle of motor.

Frequency of motor.

Damping of motor.

Target angular velocity of the motor.

Maximum torque the motor can apply when in velocity mode.

The other body to ignore collisions with.

Weld two physics objects together

Create a hinged connection between two physics objects. Like a door hinge or a wheel.

Minimum angle it should be allowed to go

Maximum angle it should be allowed to go

Motor mode

Hinge friction

Target angle of motor

Frequency of motor

Damping of motor

Target velocity of motor

Max torque of motor

Local frames are calculated automatically using this component transform and connected body transform.

Local frames are set manually. See ,

Are local frames calculated automatically or set manually. See ,

Only used on joint creation. See

The body this joint is anchored to. If this is null then it will use the current GameObject as the anchor.

Game object to find the body to attach this joint to.

Enable or disable collision between the two bodies.

Is the joint broken on start.

Strength of the linear constraint. If it takes any more energy than this, it'll break.

Strength of the angular constraint. If it takes any more energy than this, it'll break.

Called when the joint breaks.

Current linear stress applied to the joint.

Current angular stress applied to the joint.

Is the joint currently broken and inactive.

The source physics body this joint is attached to.

The source GameObject we're connected to

The target physics body this joint is constraining.

The target GameObject we're connected to

A specific point this joint is attached at on

Joint type implementation.

Restrict an object to one axis, relative to another object. Like a drawer opening.

Maximum length it should be allowed to go

Minimum length it should be allowed to go

Slider friction

Try to keep an object a set distance away from another object. Like a spring connecting two objects.

The stiffness of the spring

The damping ratio of the spring, usually between 0 and 1

Minimum length it should be allowed to go

Maximum length it should be allowed to go

Length of the spring at rest.

Determines which way the spring applies force. Pull = only when stretched, Push = only when compressed, Both = acts in both directions.

Constrains a physics body to stay upright relative to another body or the world. Uses a spring to keep the Z-axes of both bodies parallel.

Spring stiffness in cycles per second (Hertz). Higher values make the joint stiffer and snap back faster.

Spring damping ratio (non-dimensional). A value of 1 is critically damped; values below 1 are springy, values above 1 are over-damped.

Maximum torque the joint can apply in newton-meters. Set to 0 for unlimited torque.

The wheel joint can be used to simulate wheels on vehicles. The wheel joint restricts body B to move along a local axis in body A. Body B is free to rotate. Supports a linear spring, linear limits, and a rotational motor. The assumption is that you will create this joint on the wheel body.This will enable suspension to be in the correct direction.

Adds an ambient light to the scene, applied globally.

Ambient light color outside of all light probes.

A directional light that casts shadows, like the sun.

Color of the ambient sky color This is kept for long term support, the recommended way to do this is with an Ambient Light component.

Number of cascades to split the view frustum into for the whole scene dynamic shadow. More cascades result in better shadow resolution, but adds significant rendering cost. User settings will set a maximum.

Controls how cascades 2+ are distributed between the first cascade boundary and the far clip. 0 is uniform, 1 is fully logarithmic.

A cubemap probe that captures the environment around it.

Bake this envmap now. This will stop it being dynamic if it was.

Update once, when the cubemap is enabled

Update every frame (slow, not recommended)

Update every x frames

Update on a time based interval

Gets or sets the priority level for the object.

If this is set, the EnvmapProbe will use a custom cubemap texture instead of rendering dynamically

The texture that was baked for this envmap probe

Resolution of the cubemap texture

Only update dynamically if we're this close to it

Minimum amount of reflection bounces to render when first enabled before settling, at cost of extra performance on load Often times you don't need this

Tags have been updated - lets update our tags

v1 - Changed RenderDynamically bool to Mode enum.

The main color of the light

Should this light cast shadows?

Tags have been updated - lets update our light's tags

Emits light in all directions from a point in space.

Emits light in a specific direction in a cone shape.

Sound to play when the button is pressed.

Sound to play when the button is released.

Called when the button is pressed. Receives the GameObject that pressed it.

Called when the button is released. Receives the GameObject that released it.

Called when the button turns on. Receives the GameObject that activated it.

Called when the button turns off.

The button's behavior mode.

Normal toggle button - click to turn on, click again to turn off.

Button is only on while being held down.

Button briefly turns on then immediately off when pressed.

Animation curve to use, X is the time between 0-1 and Y is how much the button is pressed from 0-1.

How long in seconds should it take to animate this button.

True if the button is currently on

True if the button is currently animating

Turns the button on. Does nothing if already on or animating.

Turns the button off. Does nothing if already off or animating.

Toggles the button between on and off states.

Added automatically by Hammer to GameObjects that have a map mesh tied to them. When a map is compiled the Model property is populated by the generated model.

Gets populated at compile time, will be valid when loading from compiled map

Set the local velocity of the surface so things can slide along it, like a conveyor belt

Called when a collider enters this trigger

Called when a collider exits this trigger

Allows you to load a map into the Scene. This can be either a vpk or a scene map.

True if the map is loaded

Called when the map has successfully loaded

Called when the map has been unloaded

Get the world bounds of the map

Unload the current map.

Make sure all cubemaps placed on scene are up-to-date when we load/unload a map instance.

Override this to add components to a map object. Only called for map objects that are not implemented.

Get the PVS of the loaded map

Loader for a 3D skybox which updates the values on the parent sceneworld

Non-destructive cable data + mesh generation.

An editable polygon mesh with collision

An editable mesh made up of polygons, triangulated into a model

Has there been changes to the mesh that need rebuilding?

Has there been changes to the vertex data?

Where is the mesh in worldspace.

Set transform without computing texture parameters from coordinates.

Called on serialize, goes through and cleans up any unused materials, and remaps material indices

All of the vertex handles being used

All of the face handles being used

All of the half edge handles being used

Add a vertex to the topology

Add multiple vertices to the topology

Connect these vertices to make a face

Calculate bounds of all vertices

Calculate bounds of all transformed vertices

Scale all vertices

Assign a material to a face

Get a material a face is using

Get the smoothing of this edge

Set the smoothing of this edge

Convert a triangle index to a face handle

Extrude multiple faces along an offset

Detatch multiple faces

Add a face filling in the open edge loop specified by the provided edge

Get the face connected to this half edge

Determine if the specified edge is open (only has one connected face)

Find all of the edges in the ring with the specified edge. An edge ring is the set of edges that are connected by a loop of faces.

Bridge two edges (create a face connecting them). The edges must both be open and belong to different faces.

Bridges two matching edge loops with interpolation.

Connect the specified edges by adding a vertex to their mid point of each edge and then connecting the vertices.

Get start and end points of an edge

Get the two vertices of this half edge

Set the position of a vertex

Get the position of a vertex

Get the positions of all vertices

Set the blend of a vertex

Set the color of a vertex

Get the color of a vertex

Get the blend of a vertex

Calculate the center point of a face

Get the start and end points of all edges

Transform all the vertices

Get all edge handles of a face

Get all vertex handles of a face

Get texture offset of a face

Set texture offset of a face

Get texture scale of a face

Set texture scale of a face

Align face texture properties to grid

Align face texture properties to face

Set face vertex texture coord

Get face vertex texture coord

Set face texture coords

Set face texture properties

Align all face texture properties to grid

Remove these faces

Remove these vertices

Remove these edges

Triangulate the polygons into a model

This is added when a component is missing. It will store the json data of the missing component, so we don't lose any data.

Get the Json data that was deserialized

An agent that can navigate the navmesh defined in the scene.

The maximum acceleration a agent can have. This is how fast the agent can change its velocity. If you want snappy movement this should be as high or higher than .

Set the Position of the GameObject to the agent position every frame. You can turn this off and handle it yourself by using the AgentPosition property.

This will simply face the direction it is moving. It is not configurable on purpose, so you should really turn this off and be doing this yourself if you need it to do anything specific.

What areas the agent is allowed to travel on. If empty, all areas are allowed.

What areas the agent is not allowed to travel on. If empty, no areas are forbidden.

Is the agent allowed to travel on the default area?

Should the agent automatically traverse links when it reaches them? Or do you want to implement your own link traversal logic?

Gets or sets the separation factor used to control how strongly agents avoid crowding each other.

Updated with the agent's position, even if UpdatePosition is false

Gets the current target position for the agent, if one is set.

The velocity the agent would like to move at, you can pass this into a PlayerController.

Returns true if the agent is currently navigating to a target.

Updated by

Rate Limiter for ground traces

If you want to move the agent from one position to another

Navigate to the position

Assigns a precalculated path for the agent to follow. The agent will attempt to follow the path, but may adjust its movement to avoid obstacles or other agents. If the path becomes invalid during navigation, it may be recalculated completely.

Returns the agent's current path as a NavMeshPath. This is not free, so avoid calling it every frame.

A NavMeshPath containing the agent's current path information.

Stop moving, or whatever we're doing

Finish link traversal, must be called after traversing a link if AutoTraverseLinks is false.

Emitted when the agent enters a link.

Emitted when the agent exits a link.

Returns true if the agent is currently traversing a link.

Holds information about the current link the agent is traversing.

The start position of the traversal. Depending on the direction traversing, this is either LinkComponent.WorldStartPositionOnNavMesh or LinkComponent.WorldEndPositionOnNavMesh.

The end position of the traversal. Where the agent should exit. Depending on the direction traversing, this is either LinkComponent.WorldStartPositionOnNavMesh or LinkComponent.WorldEndPositionOnNavMesh.

The position at which the agent entered the link.

The Link component that the agent is traversing. May be null if the agent is traversing a link created without a NavMeshLink component.

Information about the current link traversal.

Get a point on the current path, distance away from here. This is a simplified path so only includes the first few corners.

An area that influences the NavMesh generation. Areas can be used to block off parts of the NavMesh. Static areas have almost no performance overhead. Moving areas at runtime will have an impact on performance if done excessively.

Whether navmesh generation in this area will be completely disabled.

The NavMesh area definition to apply to this area.

The collider this area's shape is based on. In almost every case, you will want to use a trigger collider for this.

Legacy support: Convert the linked collider to a SceneVolume and clear the reference

Removes the current NavMeshArea

Called when the transform changes

NavigationLinks connect navigation mesh polygons for pathfinding and enable shortcuts like ladders, jumps, or teleports.

Start position relative to the game object's position.

End position relative to the game object's position.

Start position in world space snapped to the navmesh.

End position in world space snapped to the navmesh.

Whether this link can be traverse bi-directional or only start towards end.

Radius that will be searched at the start and end positions for a connection to the navmesh.

The NavMesh area definition to apply to this link.

Emitted when an agent enters the link.

Emitted when an agent exits the link.

Start position in world space.

End position in world space.

Called when an agent enters the link.

Called when an agent exits the link.

Attract particles to a GameObject in the scene

Particles can have extra controllers that can modify the particles every frame.

The particle we're controlling

Called before the particle step

Called after the particle step

Called for each particle during the particle step. This is super threaded so you better watch out.

Emits particles within a box shape.

Emits particles within/along a cone shape.

Randomize the direction of the initial velocity. 0 = no randomization, 1 = full randomization.

When distributing should we bias the center of the cone

Should particles near the center have more velocity

Multiply velocity by this

Creates particles. Should be attached to a .

Whether the emitter should restart after finishing

Whether to destroy the GameObject when the emitter finishes (only applies when Loop is false)

How long the emitter should run for, after the Delay

How many seconds to wait before the emitter starts

How many particles to emit, in a burst

How many particles to emit over time

How many particles to emit per 100 units moved

0-1, the life time of the emitter

True if we're doing a burst

0-1, a random number to be used for this loop of the emitter

Allows child emitters to override how many particles are in a burst

Allows child emitters to override how many particles are in a rate

Return true if we haven't finished emitting

Emits particles in a model

Emits particles in a ring. The ring can be flat or have a tube-like quality. Velocity can either be added from the center of the ring, or from the ring itself.

Emits particles within a sphere shape.

A range from 0 to 1 descriving how long this particle has been alive

The time that this particle is scheduled to die

A GameObject that is following us. Might be emitting other particles or something.

Get an arbituary data value

Set an arbituary data value

Allows creating a class that will exist for as long as a particle. The methods get called in the particle thread, which removes the need to run through the particle list again, but it has the danger and restrictions that come with threaded code.

The component that created this listener. May be null.

Called in a thread. The particle is in its first position.

Called in a thread, guarenteed to be called after OnEnabled

Called in a thread. OnUpdate won't be called again.

Add a listener.

Remove a listener

Remove all listeners with this component set as the source. This is most commonly called when the passed component is destroyed or disabled, to remove any effects created.

Defines and holds particles. This is the core of the particle system.

The maximum number of particles that can exist in this effect at once.

The lifetime of each particle, in seconds.

Scales the simulation time for this effect.

How many seconds to pre-warm this effect by when creating.

The delay before a particle starts after being emitted, in seconds.

Per-particle time scale multiplier. Allows each particle to have a unique simulation speed.

Use game simulation time (affected by game time scale).

Use real-world time (ignores game time scale).

How time is updated for this effect.

The initial velocity of the particle when it is created. This is applied before any forces are applied.

Apply an element of random velocity to the particle when it is created, in a random direction.

The damping factor applied to particle velocity over time. This reduces the velocity of particles, simulating resistance or drag.

Move this delta constantly. Ignores velocity, collisions and drag.

When 1 particles will be moved in local space relative to the emitter GameObject's transform. This allows particles to be emitted in a local space, like a fire effect that moves with the player, but the particles can slowly move to world space.

Enables or disables rotation for particles.

The pitch rotation of the particles.

The yaw rotation of the particles.

The roll rotation of the particles.

Enables or disables color application for particles.

Enables or disables alpha application for particles.

The tint color applied to particles.

The gradient used to color particles over their lifetime.

The brightness multiplier applied to particles.

The alpha transparency of particles.

Enables or disables shape application for particles.

The scale of particles.

The stretch factor of particles, affecting their aspect ratio.

Enables or disables the application of forces to particles.

The direction of the force applied to particles.

The scale of the force applied to each particle. This multiplier determines the intensity of the force applied to particles.

The orbital force applied to particles, causing them to rotate around a point.

The pull strength of the orbital force, drawing particles closer to the center.

The simulation space in which forces are applied. Forces can be applied in either local space (relative to the emitter) or world space.

Enables or disables collision behavior for particles.

The chance that a particle will die upon collision.

The radius used for collision detection.

The set of tags to ignore during collision detection.

The bounce factor applied to particles upon collision.

The friction factor applied to particles upon collision.

The bumpiness factor applied to particles upon collision.

The strength of the push force applied to particles upon collision.

Enables or disables the use of a sheet sequence for particles.

Which sequence to use.

Allows control of the sequence time, which spans from 0 to 1 for one loop.

Increment the sequence time by this much.

When enabled, snap to the nearest whole frame instead of blending between frames.

Enables or disables the use of prefabs for particles.

Will choose a random prefab to spawn from this list.

If 1 then we'll always spawn a prefab. If 0.5 then we'll spawn a prefab 50% of the time.

When true the prefab will be destroyed at the end of the particle's life.

Will choose a random prefab to spawn from this list.

When true the collision prefab will be aligned with the surface it collides with.

We will by default align to the particle's angle, but we can also randomize that.

If 1 then we'll always spawn a prefab. If 0.5 then we'll spawn a prefab 50% of the time.

Called any time a particle is destroyed.

Called any time a particle is created.

Active particles in the effect. Active particles are those currently being simulated and rendered.

Delayed particles in the effect. Delayed particles are those that have been emitted but are waiting to be activated based on their start delay.

The total number of particles in the effect, including both active and delayed particles.

Whether the particle effect has reached its maximum capacity. This is determined by comparing the total particle count to the property.

Whether the particle simulation is currently paused. When paused, particles will not update their positions, velocities, or other properties.

Called before the particles are stepped. This allows custom logic to be executed before the simulation advances.

Called after the particles are stepped. This allows custom logic to be executed after the simulation advances.

Called after each particle is stepped. This provides an opportunity to modify individual particles during the simulation.

The bounding box that encompasses all active particles. This is useful for determining the spatial extent of the particle effect.

The size of the largest particle in the effect. This is determined by the maximum scale of any particle along its x, y, or z axis.

Forces are applied in world space, independent of the emitter's position or rotation.

Forces are applied in local space, relative to the emitter's position and rotation.

Emit a particle at the given position.

The position in which to spawn the particle The time delta of the spawn. The first spawned particle is 0, the last spawned particle is 1. This is used to evaluate the spawn particles like lifetime and delay. A particle, will never be null. It's up to you to obey max particles.

Should return true if we have active particles

v1 - Added ApplyAlpha property if ApplyColor was true.

v2 - Changed Space from enum to LocalSpace ParticleFloat, where 1 is local, 0 is world space.

Should return the lifetime delta we're going to use to evaluate

Should return the seed we're using for randomness

Represents a floating-point value that can change over time with support for various evaluation modes.

A value that doesn't change over time.

The value is interpolated between two fixed floats.

A curve that defines how the value changes over time or based on an evaluation factor.

Two curves where the value is interpolated between them.

Evaluates the value based on the lifetime using its normalized age.

Evaluates the value based on the current frame, introducing randomness for dynamic effects.

Evaluates the value based on a random seed. This means that in most situations, it's random per context. Like if this is on a particle, the value will be random per particle.

Evaluates the value based on the given delta and random seed, optimized for performance.

Evaluates the value using a dynamic context and seed, optimized for clarity and functionality.

Checks if the value is nearly zero.

Reads a ParticleFloat instance from JSON, refactored for modularity.

Writes a ParticleFloat instance to JSON, refactored for modularity.

This is only here to remain "compatible" with RangedFloat

Ticks the physics in FrameStage.PhysicsStep

We process the particles in chunks, in parallel. We don't do one particle at a time because it'd spend more time doing all the admin of giving them to threads than it would actually take.

for that omits unused properties. Will serialize as just a string for .

Interface for batched particle renderers that can be processed by SceneSpriteSystem

Result of particle processing operation

Efficiently converts particle data directly into GPU-ready SpriteData format. This is the hot path for particle rendering - bypasses intermediate allocations by writing directly to the destination sprite buffer.

Adds lighting to particles in your effect.

If 1, then every particle will get a light. If 0, no particles will get a light. If 0.5, half will get a particle.

Renders particles as models, using the particle's position, rotation, and size.

Render options for advanced rendering.

Entry for a model, including its material group and body group settings.

The model associated with this entry.

Material group for the model.

Body group mask for the model.

Indicates whether the model has material groups.

Indicates whether the model has body groups.

Converts a to a .

The model to convert. A new instance.

List of models for rendering. This property is obsolete; use instead.

List of model entries available for rendering.

Material override for rendering.

If true, the models will rotate relative to the this GameObject

Scale factor for particle rendering.

Indicates whether particles cast shadows.

Called when a particle is created.

The particle being created.

Version of the component.

Upgrades the JSON representation of the particle model renderer to version 1.

The JSON object to upgrade.

Represents a particle model listener that updates the scene object based on particle properties.

Renderer associated with this particle model.

Initializes a new instance of the class.

The particle model renderer.

Called when the particle is enabled.

The particle being enabled.

Called when the particle is disabled.

The particle being disabled.

Updates the particle.

The particle being updated. The delta time since the last update.

Renders a set of particles. Should be attached to a .

Return the bounds of this renderer in local space.

Renders particles as 2D sprites - can be static or animated

The sprite resource to render. This can be completely static or contain animation(s).

The animation that this sprite should start playing when the scene starts.

The scale of the sprite when rendered.

Whether or not the sprite should be rendered additively.

Whether or not the sprite should cast shadows in the scene.

Whether or not the sprite should be lit by the scene lighting.

Indicates whether the sprite is opaque, optimizing rendering by skipping sorting.

The texture filtering mode used when rendering the sprite. For pixelated sprites use .

Alignment mode for the sprite's billboard behavior.

Sorting mode used for rendering particles.

Amount of feathering applied to the depth, softening its intersection with geometry.

The strength of the fog effect applied to the sprite. This determines how much the sprite blends with any fog in the scene.

Aligns the sprite to face its velocity direction.

Offset applied to the rotation when facing velocity.

Enables motion blur effects for the sprite.

Determines whether the motion blur effect includes a leading trail.

Amount of blur applied to the sprite during motion blur.

Spacing between blur samples in the motion blur effect.

Opacity of the blur effect applied to the sprite.

The animation that is currently being played. Returns null if no sprite is set or the sprite has no animations.

Whether or not the sprite is animated. This is true if the sprite has more than one animation or if the current animation has more than one frame.

Interface property to determine if particles should be sorted

The pivot point of the sprite, used for rotation and scaling. This is in normalized coordinates (0 to 1).

The texture being displayed from the sprite given the current frame/animation.

Provides texture for rendering - implementation for IBatchedParticleSpriteRenderer

Look directly at the camera, apply roll

Look at the camera but don't pitch up and down, up is always up, can roll

Use rotation provided by the particle, pitch yaw and roll

Align to game object rotation, apply pitch yaw and roll

Set the animation by index (the first animation is index 0).

Set the animation by name.

v2 - Use embedded Sprite resource instead of a single Texture

Renders particles as 2D sprites

Indicates whether the sprite is opaque, optimizing rendering by skipping sorting.

Aligns the sprite to face its velocity direction.

Offset applied to the rotation when facing velocity.

Enables motion blur effects for the sprite.

Determines whether the motion blur effect includes a leading trail.

Amount of blur applied to the sprite during motion blur.

Spacing between blur samples in the motion blur effect.

Opacity of the blur effect applied to the sprite.

Alignment mode for the sprite's billboard behavior.

Sorting mode used for rendering particles.

Interface property to determine if particles should be sorted

Provides texture for rendering the sprite

Renders a trail for each particle in the effect.

The base class for all post process effects.

The camera we're being applied to. This is only valid during the Render call.

The default attributes for this post process. This will be used by helper functions like Blit.

Override in your implementation to do your rendering

The material to use for the blit.

We'll use this instead of BasePostProcess.Attributes if set.

Where to place this in the render pipeline

The order within the stage. Lower numbers get rendered first.

If true, the backbuffer will be copied to a texture called "ColorBuffer" before the blit.

If both WantsBackbuffer and this is true the backbuffer will be mipped after being copied.

Shortcut to build a simple blit mode

Shortcut to build a blit mode that copies the backbuffer first

Helper to do a blit with the current camera's post process

Helper to add a command list to the current camera's post process

Like BasePostProcess but enables access to helper methods for accessing from multiple instances using GetWeighted.

Helper to get a weighted value from all active post process volumes

Adds an approximation of ambient occlusion using Screen Space Ambient Occlusion (SSAO). It darkens areas where ambient light is generally occluded from such as corners, crevices and surfaces that are close to each other.

The intensity of the darkening effect. Has no impact on performance.

Maximum distance of samples from pixel when determining its occlusion, in world units.

Gently reduce sample impact as it gets out of the effect's radius bounds

How we should denoise the effect

Run ambient occlusion at a reduced resolution to save GPU time. The AO texture is sampled with bilinear filtering when applied to the scene.

Slightly reduce impact of samples further back to counter the bias from depth-based (incomplete) input scene geometry data

Blue-noise texture used by GTAO sampling.

Applies same-frame multi-pass spatial denoising (dilated edge-aware blur). This smooths sampling noise without requiring previous frame history.

Applies temporal denoising to reduce noise by averaging pixel values over multiple frames. This method leverages the temporal coherence of consecutive frames to achieve a noise-free result.

9 samples

16 samples

25 samples

Draw a material over the screen

Applies a bloom effect to the camera

Applies a blur effect to the camera.

Applies a chromatic aberration effect to the camera

Strength of the chromatic aberration effect

The pixel offset for each color channel. These values should be very small as it's in UV space. (0.004 for example) X = Red Y = Green Z = Blue

Applies color adjustments to the camera.

Applies color grading to the camera

Represent our curves into shaders

Applies a depth of field effect to the camera

Quality scale factors: [Off, Low, Medium, High]

How blurry to make stuff that isn't in focus.

How far away from the camera to focus in world units.

This modulates how far is the blur to the image.

Should we blur what's ahead the focal point towards us?

Should we blur what's behind the focal point?

Applies a film grain effect to the camera

This should be added to a camera that you want to outline stuff

This component should be added to stuff you want to be outlined. You will also need to add the Highlight component to the camera you want to render the outlines.

If defined, the glow will use this material rather than a generated one.

The colour of the glow outline

The colour of the glow when the mesh is obscured by something closer.

Color of the inside of the glow

Color of the inside of the glow when the mesh is obscured by something closer.

The width of the line of the glow

Specify targets of the outline manually

Get a list of targets that we want to draw the outline around

Applies a motion blur effect to the camera

Applies a pixelate effect to the camera

Stop tracing rays after this roughness value. This is meant to be used to avoid tracing rays for very rough surfaces which are unlikely to have any reflections. This is a performance optimization.

Applies a sharpen effect to the camera

Applies a tonemapping effect to the camera.

Options to select a tonemapping algorithm to use for color grading.

John Hable's filmic tonemapping algorithm. Matches the default curve Source 2 uses based on Uncharted 2.

The most realistic tonemapper at handling bright light, desaturating light as it becomes brighter. This is slightly more expensive than other options.

Reinhard's tonemapper, which is a simple and fast tonemapper.

Linear tonemapper, only applies autoexposure.

Similar to ACES - very realistic, but handles lower and higher brightness ranges better. Uses the Punchy AgX look.

Which tonemapping algorithm to use for color grading.

Remove Exposure Bias this doesn't make much sense since it's tied to only HableFilmic and does the same thing as ExposureCompensation

Remap the old "Legacy" mode to HableFilmic

Applies a vignette to the camera

The color of the vignette or the "border"

How strong the vignette is. This is a value between 0 -> 1

How much fall off or how blurry the vignette is

How circular or round the vignette is

The center of the vignette in relation to UV space. This means a value of {0.5, 0.5} is the center of the screen

Adds an effect to the camera

The stage in the render pipeline that we'll get rendered in

Lower numbers get renderered first

You should implement this method and fill the CommandList with the actions that you want to do for this post process.

Holds a list of post processing layers for a camera

Add a new post process layer to a specific stage

Called for each stage during this camera's render. This is called on the render thread.

A layer is placed on a specific Render Stage is ordered relative to other layers on that stage

Render this layer

Manages post-processing effects for cameras and volumes within a scene, handling their application during rendering and editor preview stages.

This system coordinates the collection and application of post-process effects based on camera position and active post-process volumes. In editor mode, it supports previewing effects for selected volumes or cameras. Implements both scene stage and render thread interfaces to integrate with the rendering pipeline.

Called at the very end of the scene update, after all other components have been ticked. We use it to update our post processing effects for each camera.

Called in editor mode, when a volume is selected

Called whenever a camera is rendering a specific stage. This is called on the render thread.

A volume that defines a region in the scene where post processing effects will be applied.

Higher priority volumes override lower priority ones. The default priority is 0.

Allows fading in and out

Distance from the edge of the volume where blending starts. 0 means hard edge, higher values create softer transitions.

Preview the post processing when this object is selected in the editor, or when the editor camera is inside the volume.

Get weight based on position

The Decal component projects textures onto model's opaque or transparent surfaces. They inherit and modify the PBR properties of the surface they're projected on.

How long should this decal live for?

If true then the decal will repeat itself forever

If true then this decal will automatically get removed when maxdecals are exceeded. This is good for things like bullect impacts, where you want to keep them around for as long as possible but also don't want to have an unlimited amount of them hanging around. Note that while the component will be destroyed, you probably want a TemporaryEffect component on the GameObject to make sure it all gets fully deleted.

A 2D size of the decal in world units.

Scale the width and height by this value

Rotation angle of the decal in degrees

The depth of the decal in world units. This is how far the decal extends into the surface it is projected onto.

Parallax depth strength of the decal

Tints the color of the decal's albedo and can be used to adjust the overall opacity of the decal.

Controls the opacity of the decal's color texture without reducing the impact of the normal or rmo texture. Set to 0 to create a normal/rmo only decal masked by the color textures alpha.

Attenuation angle controls how much the decal fades at an angle. At 0 it does not fade at all. Up to 1 it fades the most.

Determines the order the decal gets rendered in, the higher the layer the more priority it has. Decals on the same layer get automatically sorted by their GameObject ID.

Which sequence to use

Get the world bounds of this decal

Tags have been updated - lets update our scene object tags

Component that creates a projected decal relative to its GameObject.

Adds a gradient fog to the world

Base interface for components that can be grouped for sprite rendering. Contains the 4 fields needed for render group classification.

Renders a line between a list of points

Calculates Rotation Minimizing Frame normals for a sequence of points in a single pass

Renders a model in the world

Get the GameObject of a specific attachment.

Force a level of detail.

Set body group value by name

Set body group value by name and choice

Set body group value by index

Get body group value by name

Get body group value by index

Tags have been updated - lets update our scene object tags

Copy everything from another renderer

Completely stop overriding materials

Set a material override for a material with a specific attribute set. For example, if you have a model with lots of different materials, but one of them has an attribute "skin" set to "1", then calling this with a material and "skin" will override only that material.

Apply any saved material overrides to the scene object.

Access to the materials

Copy everything from another renderer

Attributes that are applied to the renderer based on the current material and shader. If the renderer is disabled, the changes are deferred until it is enabled again. Attributes are not saved to disk, and are not cloned when copying the renderer.

A command list which is executed immediately before rendering this

A command list which is executed immediately after rendering this

Backup the specified RenderAttributes so we can restore them later with

Restore any attributes that were previously backed up with

Render the of this renderer with the specified overrides.

Regular game rendering layers

Rendered above everything else

Rendererd during bloom

Rendered after the UI is rendered

Apply these options to a SceneObject

Renders a skinned model in the world. A skinned model is any model with bones/animations.

Get the GameObject of a specific bone.

Find a bone's GameObject by bone name.

Try to get the final worldspace bone transform.

Try to get the worldspace bone transform after animation but before physics and procedural bones.

Allocate an array of bone transforms in either world space or parent space.

Allocate an array of bone velocities in world space

Retrieve the bone's velocities based on previous and current position

Usually used for turning off animation on ragdolls.

Override animgraph, otherwise uses animgraph of the model.

Allows playback of sequences directly, rather than using an animation graph. Requires disabled if the scene model has one.

Control playback rate of animgraph or current sequence.

Does our model have collision and joints.

If true then animations will play while in an editor scene.

For Procedural Bones, copy the current value to the animation bone

For non procedural bones, copy the "parent space" bone from to the GameObject transform. Will return true if any transforms have changed.

Called when a footstep event happens

Called when a generic animation event happens

Called when a sound event happens

Called when an anim tag event happens

Access to the morphs for this model

Sets a morph override value. Uses a default blend time to smoothly transition from the animation-driven morph to this override.

Sets a morph override value with blending. fadeTime controls how long it takes to blend between the animation-driven morph and this override.

Returns true if we have this value overridden (set). False means its value is likely being driven by animation etc.

Get this value

Clears the morph override and returns control to the animation. Uses the default blend time to smoothly transition back.

Clears the morph override and returns control to the animation. fadeTime controls how long it takes to blend back to the animation-driven morph.

If something sets parameters before the model is spawned, then we store them and apply them when it does spawn. This isn't ideal, but it is what it is.

Remove any stored parameters

Converts value to vector local to this entity's eyepos and passes it to SetAnimVector

Converts value to vector local to this entity's eyepos and passes it to SetAnimVector. This also sets {name}_weight to the weight value.

Sets an IK parameter. This sets 3 variables that should be set in the animgraph: 1. ik.{name}.enabled 2. ik.{name}.position 3. ik.{name}.rotation

This sets ik.{name}.enabled to false.

Access to the animgraph parameters for this model

Simulates bones using physics defined on the model.

Isolated physics world to simulate physics bones.

Control playback rate of sequence.

Adds a 2D skybox to the world

Tags have been updated

Renders a sprite in the world

The sprite resource to render. This can be completely static or contain animation(s).

The animation that this sprite should start playing when the scene starts.

The playback speed of the animation. 0 is paused, and negative values will play the animation in reverse.

The width and height of the sprite in world units.

The color of the sprite. This is multiplied with the texture color.

Whether or not the sprite should be rendered additively.

Whether or not the sprite should cast shadows.

Whether or not the sprite should be rendered opaque. If true, any semi-transparent pixels will be dithered.

Alpha threshold for discarding pixels. Pixels with alpha below this value will be discarded. Only used when Opaque is true. Range: 0.0 (transparent) to 1.0 (opaque). Default is 0.5.

Whether or not the sprite should be lit by the scene's lighting system. Otherwise it will be unlit/fullbright.

Amount of feathering applied to the depth, softening its intersection with geometry.

The strength of the fog effect applied to the sprite. This determines how much the sprite blends with any fog in the scene.

Whether or not the sprite should be flipped horizontally.

Whether or not the sprite should be flipped vertically.

The texture filtering mode used when rendering the sprite. For pixelated sprites, use .

Alignment mode for the sprite's billboard behavior.

Whether or not the sprite should be sorted by depth. If the sprite is opaque, this can be turned off for a performance boost if not needed.

This action is invoked when an animation starts playing. The string parameter is the name of the animation that started.

This action is invoked when an animation finishes playing or has looped. The string parameter is the name of the animation.

This action is invoked when advancing to a new frame that has broadcast messages. The string parameter is the message being broadcast.

The animation that is currently being played. Returns null if no sprite is set or the sprite has no animations.

The index of the current frame being displayed. This will change over time if the sprite is animated, and can be set to go to a specific frame even during playback.

Whether or not the sprite is animated. This is true if the sprite has more than one animation.

The texture of the current frame being displayed. Returns a transparent texture when no valid frame is available.

Play an animation by index (the first animation is index 0).

Play an animation by name.

v2 - Use embedded Sprite resource instead of a single Texture

Renders text in the world

Represents the horizontal alignment of the text.

Represents the vertical alignment of the text.

The text scope defines what text to render and it's visual properties (such as font, color, outline, etc.)

The size of the text in the world. This is different from the font size, which is defined in the TextScope and determines resolution of the rendered text.

The horizontal alignment of the text in the world.

The vertical alignment of the text in the world.

The blend mode of the text. This determines how the text is rendered over the world.

The strength of the fog effect applied to the text. This determines how much the text blends with any fog in the scene.

Tags have been updated - lets update our scene object tags

The color of the text from the TextScope.

The font size of the text from the TextScope. This is different from the Scale, which determines how large the text appears in the world.

Renders a trail behind the object, when it moves.

When enabled, new points are added to the trail.

Internal component for storing the baked fog texture We don't need to expose the volumetric fog controller like we did previously with entities, But we need to be fetch the baked fog texture from the map file

Adds a volumetric fog volume to the scene.

Terrain renders heightmap based terrain.

Call on enable or storage change

Given a world ray, finds out the LOCAL position it intersects with this terrain.

Called when the terrain has been modified (height, control, or holes)

Downloads dirty regions from the GPU texture maps onto the CPU, updating collider data and making changes saveable. This is used from the editor after modifying.

Updates the GPU texture maps with the CPU data

Information about terrain materials at a specific position

The base (primary) material index at this position

The overlay (secondary) material index at this position

Blend factor between base and overlay (0-1, where 0 = full base, 1 = full overlay)

Whether this position is marked as a hole

The base terrain material resource (if available)

The overlay terrain material resource (if available)

Gets the dominant material at this position based on blend factor

Gets the dominant material index at this position based on blend factor

Gets terrain material information at a world position. Returns null if the position is outside terrain bounds.

Override the terrain rendering with your own material shader. This needs to be explicitly set up to work with the Terrain Shader API.

Uniform world size of the width and length of the terrain.

World size of the maximum height of the terrain.

Create buffers needed for terrain rendering, set sane empties, always bound

Upload the Terrain buffer, this should be called when some base settings change.

Upload the Materials buffer, this should be called when materials are added, removed or modified.

Diamond-square implementation trying to reduce duplicate vertices.

The panel. Can be null if the panel doesn't exist yet.

Gets overridden by .razor file

Called when the razor ui has been built.

Called after the tree has been built. This can happen any time the contents change.

When this has changes, we will re-render this panel. This is usually implemented as a HashCode.Combine containing stuff that causes the panel's content to change.

Should be called when you want the component to be re-rendered.

A panel where we control the tree build.

Renders any attached PanelComponents to the screen. Acts as the root for all your UI components.

The height is scaled on the assumptiuon that we're always 1080p

We use the same scaling as the desktop

A router for world input, the best place to put this is on your player's camera. Uses cursor ray when mouse is active, otherwise the direction of this gameobject. You could also put this on a VR controller to interact with world panels.

Holds our input state in the UI system.

Which action is our left clicking button?

Which action is our right clicking button?

If using VR this will be the hand source for input.

The that is currently hovered by this input.

Renders any attached PanelComponents to the world in 3D space.

How far can we interact with this world panel?

Tags have been updated

A generic way to represent volumes in a scene. If we all end up using this instead of defining our own version in everything, we can improve this and improve everything at the same time.

A sphere. It's like the earth. Or an eyeball.

A box, like a cube.

A capsule, like a pill or a hotdog.

A global, infinite, boundless volume.

Draws an editable sphere/box gizmo, for adjusting the volume

Is this point within the volume

Is this point within the (local space) volume

Get the actual amount of volume in this shape. This is useful if you want to make a system where you prioritize by volume size. Don't forget to multiply by scale!

Calculates the shortest distance from the specified world position to the edge of this volume.

The world transform of the volume. The position in world space to measure from. The distance, in world units, from the position to the volume edge.

Returns the axis-aligned bounding box that encloses the current volume.

True if SceneVolume.Type == SceneVolume.VolumeTypes.Infinite

Calculates the shortest distance from the specified world position to the nearest edge of the scene volume.

A base GameObjectSystem for handling of IVolume components. You can use this to find volume components by position.

Find a volume of this type, at this point. Will return null if none.

Find all volumes of this type, at this point

Describes the damage that should be done to something. This is purposefully a class so it can be derived from, allowing games to create their own special types of damage, while not having to create a whole new system.

Usually a player or Npc

The weapon that did the damage, or a vehicle etc

The hitbox that we hit (if any)

Amount of damage this should do

The origin of the damage. For bullets this would be the shooter's eye position. For explosions, this would be the center of the exposion.

The location of the damage on the hit object.

The physics shape that we hit (if any)

Tags for this damage, allows you to enter and read different damage types etc

True if this is explosive damage

Allows listening to network events on a specific GameObject

Called before we are about to drop ownership of a network GameObject

Called when the owner of a network GameObject is changed

We have become the controller of this object, we are no longer a proxy

This object has become a proxy, controlled by someone else

Listen to all collision events that happen during a physics step.

Called when a collider/rigidbody starts touching another collider.

Called once per physics step for every collider being touched.

Called when a collider/rigidbody stops touching another collider.

Called when a collider/rigidbody hits another collider, including repeated hits on the same shape while they are already touching.

Allows listening to events related to scene loading

Called before the loading starts

Called during loading. The game will wait for your task to finish

Loading has finished

Allows events before and after the the physics step

Called before the physics step is run. This is called pretty much right after FixedUpdate.

Called after the physics step is run

Called when a rigidbody goes out of bounds.

Called when a rigidbody goes to sleep.

Allows listening to events related to scene startup. This should really only apply to GameObjectSystem's because components won't have been spawned/created when most of this is invoked.

Called before the scene is loaded. In game only, on host only.

Called after the scene is loaded. In game only, on the host only.

Called in game after the client has loaded the initial scene from the server, or after OnHostInitialize. This is not called on the dedicated server.

This system exists to collect pending collision sounds and filter them into a unique set, to avoid unnesssary sounds playing, when they're going to be making the same sound anyway.

Add a collision sound for this shape

Create the pending sounds

Draw a wireframe capsule, simple cylinder with 2 hemispheres.

Draw a wireframe cylinder, like a capsule without the hemispheres, showing all sides.

Draw a box

Draw a GameObject in the world

Draw a line

Draw model in the world

Draw a sphere

Draw text in the world

Draw a frustum

Add an entry manually

Draw text on the screen

Draw a texture on the screen

Draws the result of a physics trace, showing the start and end points, the hit location and normal (if any), and the traced shape (ray, sphere, box, capsule, cylinder) at both the start and end positions.

A list of decals that can be destroyed after a certain time.

Ticks the physics in FrameStage.PhysicsStep

Updates interpolation for any that needs it.

Add a to the interpolation list.

Remove a from the interpolation list.

Updates NavMeshAgent ground positions in parallel during PrePhysicsStep.

We are tracing in the following interval (scale not accurate) x | | We start a certain distance above the agents capsules center | | | ------- | | | | x | -- Trace Start (in lower third) | | | ------- | | ~~~~~~~ -- Potential ground | | | x We trace down the same distance In case of multiple hits we prefer the once closest to the agent's capsule center

How long stats have been accumulating since the last reset (or first tracked message).

Reset all accumulated RPC tracking stats.

Track a network message for diagnostic purposes.

Track a sync var property update for diagnostic purposes.

Record the size of a message by category to be added to the current tick sample. These can be shown on a network graph.

Ticks the physics in FrameStage.PhysicsStep

Implements logic for the SoundScape system

Carries the data needed to configure a new from the original component state.

Find the component's current render group - might be outdated if component has changed. Returns null if not present in any

Stores editor selection sets on the scene so they serialize into SceneProperties/GameObjectSystems.

Updates sound occlusion in parallel during StartFixedUpdate. This moves the expensive physics traces out of the main sound tick loop and parallelizes them across all sounds rather than per-sound.

Cached data for parallel occlusion updates. We cache listener positions on the main thread because Listener.Position has a main thread assertion and cannot be accessed from worker threads.

Compute how occluded a sound is. Returns 0 if fully occluded, 1 if not occluded.

Collect all handle/listener pairs that need occlusion updates this frame. Must be called on main thread to access Listener.Position.

Simulates VerletRope components in parallel during PrePhysicsStep

Allows creation of a system that always exists in every scene, is hooked into the scene's lifecycle, and is disposed when the scene is disposed.

Listen to a frame stage. Order is used to determine the order in which listeners are called, the default action always happens at 0, so if you want it to happen before you should go to -1, if you want it to happen after go to 1 etc.

A list of stages in the scene tick in which we can hook

At the very start of the scene update

Bones are worked out

Physics step, called in fixed update

When transforms are interpolated

At the very end of the scene update

Called at the start of fixed update

Called at the end of fixed update

Called after a scene has been loaded

When implementing an ITraceProvider, the most important thing to keep in mind is that the call to DoTrace should be thread safe. This might be called from multiple threads at once, so you better watch out.

Should only be called by .

Get or create a new interpolated variable. This will set the current interpolated value to the provided one if it hasn't been created yet.

Try to send a network update or do nothing if no update is required. This is most likely called after WriteDeltaSnapshot.

Write all pending data table changes.

Read the network table data.

A syntax sugar wrapper around GameObjectSystem, which allows you to access your system using SystemName.Current instead of Scene.GetSystem.

Configuration for GameObjectSystem properties at a project level. Specific scenes may override this as well - but will be serialized directly in the scene.

Stores GameObjectSystems to property names to property values

Quick utility method to get the type name from a TypeDescription

Get property value for a specific system type. Returns the configured value, or a default value for the type if not found.

Try to get property value for a specific system type. Returns true if the property was found in the config.

Set property value for a specific system type

Keeps a list of callbacks The intention of this is that in the future we'll have a nice window that will show the relative performance of each callback, and allow you to disable them to debug.

We want to execute callbacks in a predictable order. This happens naturally when spawning one GameObject, but when spawning a scene, or a prefab, we want to hold the calls to things like OnEnable and call them all after OnStart or whatever has been called on all the objects in the batch.

Stores either a direct dispatch target (no delegate allocation) or a fallback action for closures.

Pre-sorted CommonCallback values used in Execute() to avoid per-call LINQ OrderBy allocation.

Add callbacks to the previous batch (or create one). This allows for one single batch, the most outer one, and won't create a new batch for inner ones. This is used when doing things like deserializing a map, so all the OnEnable etc are executed at the same time, and in the right order.

Collect callbacks in this scope and execute them immediately at the end of this batch. This is used for things like gameobject Clones, where we're going to want access to the object straight after creating it.. and if we're inside a Batch then OnEnable etc won't have been called, so it will be confusing to everyone.

Adds a direct-dispatch callback, avoiding a delegate allocation.

Adds a closure-based fallback callback. Prefer the non-Action overloads to avoid delegate allocation.

A list of component methods that are deferred and batched into groups, and exected in group order. This is used to ensure that components are initialized in a predictable order. The order of this enum is critical.

The component is deserializing.

The component has been deserialized, or edited in the editor

An opportunity for the component to load any data they need to load

The component is awake. Called only once, on first enable.

Component has been enabled

The component has become dirty, usually due to a property changing

Component has been disabled

Component has been destroyed

GameObject actually deleted

Flags to search for Components. I've named this something generic because I think we can re-use it to search for GameObjects too.

Components that are enabled

Components that are disabled

Components in this object

Components in our parent

Components in all ancestors (parent, their parent, their parent, etc)

Components in our children

Components in all decendants (our children, their children, their children etc)

This is the hard list of components. This isn't a HashSet because we need the order to stay. Lazily initialized so GameObjects without components don't allocate.

Get all components, including disabled ones

Hotload has occurred

Add a component of this type

Get a component of this type

Get all components of this type

Get all components

Get a list of components on this game object, optionally recurse when deep is true

Try to get this component

Allows linq style queries

Amount of components - including disabled

Move the position of the component in the list by delta (-1 means up one, 1 means down one)

Move the component to a specific index in the list. If a component is already at that index, it will be swapped with the component being moved.

Find component on this gameobject

Find this component, if it doesn't exist - create it.

Find component on this gameobject's ancestors or on self

Find component on this gameobject's ancestors

Find component on this gameobject's decendants or on self

Find component on this gameobject's decendants

Find component on this gameobject's immediate children or on self

Find component on this gameobject's immediate children

Find component on this gameobject's parent or on self

Find component on this gameobject's parent

Find component on this gameobject with the specified id

Adds a special component that will keep information about a missing component. This component just holds the raw json of this component.

Interface for types that reference a , to provide convenience method for accessing that list.

An object in the scene. Functionality is added using Components. A GameObject has a transform, which explains its position, rotation and scale, relative to its parent. It also has a name, and can be enabled or disabled. When disabled, the GameObject is still in the scene, but the components don't tick and are all disabled.

Create a unique copy of the passed in GameObject

Runs after this clone has been created by a cloned GameObject.

A mapping of original objects to their clones, used for all reference types. A mapping of original GUIDs to cloned GUIDs, used for GameObject and Component references in JSON.

Clone a prefab from path

Create a unique copy of the GameObject

The scene that this GameObject is in.

Our position relative to our parent, or the scene if we don't have any parent.

The GameObject's name is usually used for debugging, and for finding it in the scene.

Returns true of this is a root object. Root objects are parented to the scene.

Return the root GameObject. The root is the object that is parented to the scene - which could very much be this object.

This token source is expired when leaving the game session, or when the GameObject is disabled/destroyed.

This token is cancelled when the GameObject ceases to exist, or is disabled

Access components on this GameObject

Is this gameobject enabled?

Create a new GameObject with the given name. Will be created enabled.

Create a new GameObject with the given enabled state and name.

Create a new GameObject with the given parent, enabled state and name.

Creates a new task source. Any Waits etc created by Task will be cancelled when the GameObject is disabled, or destroyed, or the game is exited.

Cancel this task source

Handles all internal common logic for setting the parent of this .

Can we update the transform to the target value. This takes network authority into account.

Do we have authority over this ? If it's networked, we have authority if we're the network root, and we're not a proxy.

Can we change our parent to the specified ?

The parent to become a child of.

Is this gameobject active. For it to be active, it needs to be enabled, all of its ancestors need to be enabled, and it needs to be in a scene.

Like the above, but faster, no allocations

Should be called whenever we change anything that we suspect might cause the active status to change on us, or our components. Don't call this directly. Only call it via SceneUtility.ActivateGameObject( this );

Returns true if the passed in object is a decendant of ours

Returns true if the passed in object is an ancestor

Set the parent of this GameObject from a remote change over the network.

The human readable ID is the number in parentheses at the end of the name. (If it exists) There is no guarantee that this is unique, or sequential.

This is slow, and somewhat innacurate. Don't call it every frame!

Get the GameObject after us,

Internal stuff only

Allows drawing of temporary debug shapes and text in the scene

Invokes the callback for the given type. Called internally by to avoid delegate allocations.

True if the GameObject is not destroyed

Actually destroy the object and its children. Turn off and destroy components.

Called on a child GameObject when its parent is being destroyed

Destroy the object and its children and destroy any components without invoking any callbacks.

The last thing ever called.

Destroy this object. Will actually be destroyed at the start of the next frame.

Return true if this object is destroyed. This will also return true if the object is marked to be destroyed soon.

Destroy this object immediately. Calling this might cause some problems if functions are expecting the object to still exist, so it's not always a good idea.

Remove all children

Destroy all components and child objects

True if this GameObject should survive a scene load

Destroy all components and child objects

Post event to a specific GameObject (and its descendants by default - you can specify a to control this)

True if this GameObject is being deserialized right now

Do we or our ancestor have this flag

Add a component to this GameObject

Get a component on this GameObject

Get components on this GameObject

Get components on this GameObject and on descendant GameObjects

Get component on this GameObject or on descendant GameObjects

Get components on this GameObject and on ancestor GameObjects

Get component on this GameObject and on ancestor GameObjects

Finds the first GameObject in the ancestor chain that we consider a selection base.

Should only be called by .

Allows overriding the ID of this object. This should be used sparingly, and only when necessary. This is generally used for network reasons, to make something deterministic.

The local transform of the game object.

The local position of the game object.

The local rotation of the game object.

The local scale of the game object.

True if this is a networked object and is owned by another client. This means that we're not controlling this object, so shouldn't try to move it or anything.

If true then this object is the root of a networked object.

OBSOLETE: Use NetworkMode instead.

How should this object be networked to other clients? By default, a will be networked as part of the snapshot.

A component that can control our network visibility to a specific .

If this object is networked, who can control ownership of it? This property will only be synchronized for a root network object.

Determines what happens when the owner disconnects. This property will only be synchronized for a root network object.

Network flags that describe the behavior of this as a .

Determines whether updates for this networked object are always transmitted to clients. Otherwise, they are only transmitted when the object is determined as visible to each client.

Whether our networked transform will be interpolated. This property will only be synchronized for a root network object. Obsolete: 09/12/2025

Detach the network connection for this networked object. This will turn it into a regular object for all clients, and it will no longer receive network updates.

Spawn on the network. If you have permission to spawn entities, this will spawn on everyone else's clients, and you will be the owner.

Spawn on the network with the specified options. If you have permission to spawn entities, this will spawn on everyone else's clients.

Spawn on the network. If you have permission to spawn entities, this will spawn on everyone else's clients and the owner will be the connection provided.

Initialize this object from the network

Always transmit has been changed by the owner. We can't use Sync Vars for this, because they don't get sent if they shouldn't be transmitted.

Make a request from the host to stop being the network owner of this game object.

Stop being the network owner of this game object, or clear ownership if you're the host.

Make a request from the host to become the network owner of this game object.

Set the parent of this networked object.

Become the network owner of this game object.

Make a request from the host to assign ownership of this game object to the specified connection .

Assign ownership of this game object to the specified connection .

The network root is the first networked GameObject above this. This gets set from the parent's NetworkSpawn and invalidated when the parent changes.

Update hierarchy from a network refresh.

Loop all of our children, and any with networking enabled, we should spawn them with the same creator + owner as this.

Access network information for this GameObject.

Is this object networked?

Get the GameObject that is the root of this network object

Are we the owner of this network object?

The Id of the owner of this object

Are we the creator of this network object

The Id of the creator of this object

Is this object a network proxy? A network proxy is a network object that is not being simulated on the local pc. This means it's either owned by no-one and is being simulated by the host or owned by another client.

Try to get the connection that owns this object. This can and will return null if we don't have information for this connection.

Who can control ownership of this networked object?

Determines what happens when the owner disconnects.

Current snapshot version. This usually changes when the owner changes.

Network flags which describe the behavior of this networked object. Can only be changed by the host after the networked object has been spawned.

Determines whether updates for this networked object are always transmitted to clients. Otherwise, they are only transmitted when the object is determined as visible to each client.

Whether the networked object's transform is interpolated.

Enable interpolation for the networked object's transform. Obsolete: 09/12/2025

Disable interpolation for the networked object's transform. Obsolete: 09/12/2025

Set what happens to this networked object when the owner disconnects.

Set who can control ownership of this networked object. Only the current owner can change this.

Send a complete refresh snapshot of this networked object to other clients. This is useful if you have made vast changes to components or children.

Send a refresh for a specific in the hierarchy of this networked object to other clients. This is useful if you've destroyed or added a new descendent and don't want to refresh the entire networked object.

Send a refresh for a specific in the hierarchy of this networked object to other clients. This is useful if you've destroyed or added a new and don't want to refresh the entire object.

Become the network owner of this object.

Note: whether you can take ownership of this object depends on the of this networked object.

Set the owner of this object to the specified .

Note: whether you can assign ownership of this object depends on the of this networked object.

cannot be null. To clear owner, use instead.

Assign ownership to the specific connection id. This should only be used internally when we want to force an ownership change, such as for a action.

Change the cull state of this GameObject on the network for the specified . This is for internal use only.

Stop being the owner of this object. Will clear the owner so the object becomes controlled by the server, and owned by no-one.

Note: whether you can drop ownership of this object depends on the of this networked object.

Before we drop ownership (or assign ownership to somebody else), there are a few things we want to do first. We want to let any listeners know so that they can react to it, we want to clear interpolation, and finally, we want to force a full delta snapshot of the object's state.

We are cloned from a prefab. Stop that.

Get the GameObject of a prefab from file path

This GameObject is part of a prefab instance.

This GameObject is the root of a prefab instance. Returns true for regular instance roots and nested prefab instance roots.

Get the root of the prefab instance this GameObject is part of.

Get the outermost prefab instance root of this GameObject. This is the root of the prefab instance this GameObject is part of, or the root of the prefab instance this GameObject is nested in.

This GameObject is the root of a prefab instance and is not nested inside another prefab instance.

This GameObject is the root of a nested prefab instance.

Is this PrefabRoot the root of a prefab cache scene?

The filename of the map this object is defined in.

Initializes the instance data.

Access point for all prefab instance related data. Can be accessed on both instance root and children contained within the instance. For outermost prefab instances this will contain a patch and guid mappings. For nested prefab instances this will just contain the prefab source.

Defines objects within a scene hierarchy we want to track for prefab diffing and patching.

Helper variable for editor refreshes during deserialization.

If we're serializing for network, we won't include any networked objects

We're cloning this object

We're going to send a single network object

Serialize the full hierarchy, prefab instances will be expanded to include all their children and components. All instances will be considered nested instances. The path to the prefab instance will be included in the JSON Implies

Serialize the prefab instance so it can be used to update the state of the prefab. Makes sure TopLevel nested prefabs are flagged, so they can get converted to a full prefab instance in the prefab.

Don't serialize gameObject children.

Don't serialize gameObject components.

Skip null member values during serialization to reduce output size. On the receive side, deserialize with set to so that missing keys are treated as an explicit null for reference/nullable types, clearing any stale value on the receiver. Value types are never skipped (they cannot be null) so they are always safe.

When true, updates the existing GameObject hierarchy instead of creating a new one from scratch. This preserves C# object references and identity, used for undo/redo operations, and prefab instance patching. During refreshing: - Existing GameObjects and Components are updated rather than recreated - Objects are matched by their GUIDs - Only missing objects are created - Existing objects not present in the JSON are removed - Component ordering is preserved as specified in the JSON

Should be used in Conjunction with . Makes sure child networked objects are not removed during refresh.

When true, component properties absent from the JSON (e.g. omitted by ) are explicitly cleared to null/default rather than left at their existing value.

Allows overriding the transform when deserializing. Will apply only to the root object.

Returns either a full JsonObject with all the GameObjects data, or if this GameObject is a prefab instance, it will return an object containing the patch/diff between instance and prefab.

Creates a JSON representation of this prefab instance including its overrides and GUID mappings.

Returns a JsonObject containing all the GameObject's data.

Serializing the transform depends on a bunch of stuff, so split it into this method for clarity.

Again - this can be complicated, so this is extracted

Only needed for legacy support, when cloning.

Push ActionGraph source location and cache if we're a prefab instance or map object.

Json Keys used for serialization and deserialization of GameObjects. Kept here so they are easier to change, and we are less susceptible to typos.

Play this sound on this GameObject. The sound will follow the position of the GameObject. You'll be able to use GameObject.StopAllSounds to stop all sounds that are following this GameObject.

Stop any sounds playing on this GameObject

Called by GameTags when the tags change

Converts Legacy Prefab Instance Data and variables to a patch. - Root level properties: Transform, Flags, Network... are converted to property overrides - Prefab Variables are converted to component property overrides - Prefab to instance guid lookup is created

Backwards combatibility for old prefab instances.

Converts NetworkInterpolation property to NetworkFlags.

The world transform of the game object.

The world position of the game object.

The world rotation of the game object.

The world scale of the game object.

The low level input of a GameObject.Clone

Hide this object in hierarchy/inspector

Don't save this object to disk, or when duplicating

Auto created - it's a bone, driven by animation

Auto created - it's an attachment

There's something wrong with this

Loading something

Is in the process of deserializing

When loading a new scene, keep this gameobject active

Keep local - don't network this object as part of the scene snapshot

In the process of refreshing from the network

Stops animation stomping the bone, will use the bone's local position

Only exists in the editor. Don't spawn it in game.

Ignore the parent transform. Basically, position: absolute for gameobjects.

The position of this object is controlled by by physics - usually via a RigidBody component

Stops this object being interpolated, either via the network system or the physics system

A serialized reference to a that can be resolved at runtime. Can either have a for objects in a scene, or a if we're referencing a prefab.

Reference a in a scene by its .

Reference a prefab by its .

Reference a given .

Expected to be "gameobject" for a game object reference.

If we're referencing an object in a scene, this is its .

If we're referencing a prefab, this is its .

Attempt to resolve this reference in the current . Returns if the reference couldn't be resolved, and logs a warning.

Attempt to resolve this reference in the given . Returns if the reference couldn't be resolved.

Scene to attempt to resolve the reference in. If true, log a warning to the console if the reference couldn't be resolved.

Entity Tags are strings you can set and check for on any entity. Internally these strings are tokenized and networked so they're also available clientside.

Returns all the tags this object has.

Returns true if this object (or its parents) has given tag.

Returns true if this object has given tag.

Returns true if this object has one or more tags from given tag list.

Try to add the tag to this object.

Adds multiple tags. Calls EntityTags.Add for each tag.

Try to remove the tag from this entity.

Remove all tags

Returns a list of ints, representing the tags. These are used internally by the engine.

Get all potential suggested tags that someone might want to add to this set.

Automatically interpolate the transform over multiple frames when changed within the context of a fixed update. This results in a smoother appearance for a moving .

Are we following our parent object?

Returns true if we're inside the transform changed callback.

Returns true if we're interpolating the transform, which means we're not inside a change callback and we're not in a fixed update scene.

The current interpolated local transform.

The current local transform.

Sets the local transform without firing a bunch of "transform changed" callbacks. The assumption is that you're changing a bunch of child transforms, and will then call transform changed on the root, which will then invoke all the callbacks just once. This is what the animation system does!

Sets the local transform with exact (bitwise) equality checks, bypassing Vector3's approximate AlmostEqual operator. Use during deserialization so that tiny floating-point values (e.g. -7.2e-05) are not silently swallowed by the 0.0001 tolerance.

The target world transform. For internal use only.

The world transform gets cached to avoid recalculating it every time. It is invalidated in TransformChanged, which is called recursively down children when the transform changes.

The current world transform.

Set from the provided in world-space.

The world-space transform.

The position in world coordinates.

The rotation in world coordinates.

The scale in world coordinates.

Position in local coordinates.

Rotation in local coordinates.

Scale in local coordinates.

Performs linear interpolation between this and the given transform.

The destination transform. Fraction, where 0 would return this, 0.5 would return a point between this and given transform, and 1 would return the given transform.

Disable the proxy temporarily

The desired local transform. If we are interpolating we'll use the last value in the interpolation buffer. This is useful for networking because we always want to send the "real" transform.

This will be true if the GameObject is enabled, we're in a Fixed Update context, and interpolation is not disabled for this GameObject.

The interpolated world transform. For internal use only.

Clear any interpolation and force us to reach our final destination immediately. If we own this object we'll tell other clients to clear interpolation too when they receive the next network update from us.

Like but will not clear interpolation across the network.

Temporarily disable Fixed Update Interpolation.

Called when the transform is changed

I need to know the root transform that actually changed

Our transform has changed, which means our children transforms changed too tell them all.

Help to implement a component that completely overrides the transform. This is useful for scenarios where you will want to keep the local transform of a GameObject, but want to offset based on that for some reason. Having multiple of these on one GameObject is not supported, and will result in weirdness.

Override to provide the local transform

Called when the local transform is being set

Override to provide the world transform. The default implementation will calculate it using GetLocalTransform() based on the parent.

Called when the world transform is being set

Tell our other components, and our children that our transform has changed. This will update things like Renderers to update their render positions.

Can be implemented on a type so that when used in conjunction with [Sync] you can write and read directly from delta snapshots.

Write to a .

The parent slot in the network table for this property The snapshot we're writing to

Read from a .

The parent slot in the network table for this property The snapshot we're reading from

Clean up any data about a removed networked object.

Clear this connection and clean up.

Tick the connection and clear any out-of-date data.

Remove a connection from the snapshot system.

Reset all connection data for the snapshot system. This might happen when a hotload occurs, or the host changes.

Locally clear any stored snapshot information about a networked object.

Create a new snapshot id for the provided .

Update the cached real time value that is used internally in the Delta Snapshot System.

Tick the snapshot system and clear any out-of-date data.

Send a delta snapshot for a set of networked objects to the specified connections.

Send a delta snapshot for a single networked object.

Clear all of removed slots from a .

Get a full serialized data update for a local snapshot state.

Unique identifier for this object.

Whether this object is a proxy (or we own it.)

Current snapshot version for this object.

Called when a snapshot is received by a .

Update the transmit state for the target connections. This method should return true if we should transmit to ANY of these connections.

Should this snapshot transmit to the target ?

Write delta snapshot data and return the object.

Called when another client has acknowledged a delta snapshot.

Try to send a network update or do nothing if no update is required. This is most likely called after WriteSnapshotState.

Represents the current local snapshot state for a networked object. This will contain entries that will be sent to other clients.

Hash the value with the unique of the parent.

Hash the value with the value of the network flags.

Hash the value with all other hashable values.

The unique of the networked object's parent.

Network flags which describe the behavior of this network object.

Call this every time you begin updating the snapshot state.

Remove a connection from stored state acknowledgements.

Clear all connections from stored state acknowledgements.

Remove an existing entry from the specified slot.

Compute a hash from the specified byte array.

Add a serialized byte array value to the specified slot with the specified hash.

Add a serialized byte array value to the specified slot. Can optionally choose to add the parent as a salt when hashing the value, if the value is related to the parent.

Add from a cache. Can optionally choose to add the parent as a salt when hashing the value.

Rent an object from the pool.

Return an object to the pool.

Represents the current snapshot state for an object based on delta snapshots received from another client.

How many seconds we'll allow to pass for a snapshot acknowledgement packet to be received from a client.

Whether the incoming snapshot id is newer than our last processed one. This automatically handles wrapping of the ushort.

Add a predicted entry to the snapshot from a .

Update the value in the stored snapshot from a .

Try to get the hash of the value from the specified slot without reading from the predicted data. It will only return true if the entry is from the same or older snapshot.

Try to get the hash of the value from the specified slot.

Remove an entry from the specified slot.

Try to get the serialized byte array value from the specified slot.

Create a new delta snapshot using the values of this snapshot state but only with the slots from the provided . This will return a pooled so you'll want to call when you're done with it.

Build a new from the specified .

Add to reference count for this object.

Release a reference for this object, and return it to the pool if nothing else is referencing it.

Get cached bytes from the specified value if they exist. If the value is different, then re-serialize and cache again.

Internal flag set while reading changes. Useful when you want to force something to be set when we otherwise wouldn't have permission to.

Whether the specified has control of this entry.

Whether we (our local ) have control of this entry.

Do we have any pending changes for entries we control?

Do we have any pending reliable changes for entries we control?

Unregister a variable assigned to a slot id.

Get a variable from a slot id.

Does a variable with the specified slot exist?

Do we have control over the value for a specific slot id?

Update the hash for a specific entry.

Update the hash for a specific slot id.

Set a variable from a slot id.

Write supported snapshot variables serialized to the specified dictionary.

Read and apply any variables from the provided snapshot.

Write all reliable variables to the provided .

Write all variables to the provided .

Write an entry to the specified .

Write any changes to the provided for entries that must be sent reliably. Calling this will clear the changes.

Write any changes to the provided . Calling this will clear the changes.

Read and apply any variables from the provided .

If any properties are "query" types, we'll copy the new values to ourselves and mark as changed, if changed.

If true then this host is being run from an editor, as such the assemblies are sent via network tables and loading assemblies from the package is not required.

A console command was run on a client but is being forwarded to the server. This is the message that contains the details of that command.

A UserInfo ConVar value was changed on a client. This message is intended for the host so that they can propagate this change to all clients.

A simple log message packet. This is used by when logging to another client's console.

Sent to the server to tell clients to reconnect. This is sent when the server is changing games, or maps, and wants the current players to follow them to the new game, or map. We send the Game and Map to the best of our knowledge, so the client can maybe preload them, while we are.

Get info for this connection

Information about a connection. The difference between this and the actual connections is that this can be networked between clients, so all clients have the same information about each other. This is going to be required in p2p games, where players need to take over hosting from each other. In a game like Rust, with a dedicated server, this won't need to be networked to other clients.

Key values that come straight from the user. Can't be trusted, they could send anything. Used for things like preferences, avatar clothing etc.

When a user isn't connected to a server, or hosting a server, the client info table doesn't exist. So we provide info here for the local connection.

Current ping for this connection.

How many packets per second we're sending to this connection.

How many bytes per second we're sending to this connection.

How many packets per second we're receiving from this connection.

How many bytes per second we're receiving from this connection.

Estimate rate that we believe we can send data to this connection.

From 0 to 1 how good is our connection to this?

An instance of this is created by the NetworkSystem when a server is joined, or created. You should not try to create this manually.

Called on the host to decide whether to accept a .

The reason to display to the client.

Called when the network system should handle initialization.

A client has connected to the server but hasn't fully finished joining yet.

Fully joined the server. Can be called when changing the map too. The game should usually create some object for the player to control here.

A client has disconnected from the server.

The host left the server and you are now in charge.

The current host has been changed.

Whether the host is busy right now. This can be used to determine if the host can be changed.

Allows to push some kind of scope when reading network messages. This is useful if you need to adjust Time.Now etc.

Called every frame

A heartbeat has been received from the host. We should make sure our times are in sync.

We've received a cull state change for a networked object.

A delta snapshot message has been received from another connection.

True if we can be considered the host of this session. Either we're not connected to a server, or we are and we are the host.

True if we're connected to a server and not the host.

True if we're currently connecting to the server

True if we're currently connected etc

Called after we've loaded a new scene.

True if this lobby is full (Members >= MaxMembers).

True if this lobby should be hidden from server lists.

Return true if this lobby contains a friend.

All metadata for this dedicated server.

The current name of the dedicated server.

The current map name of the dedicated server.

Log a warning if the tags string is too long.

Set data for this dedicated server. This data is used when querying or filtering servers. Uses game tags internally, which have a hardcoded character limit enforced by Steam.

Get data for this dedicated server. This data is used when querying or filtering servers.

A network system is a bunch of connections that people can send messages over. Right now it can be a dedicated server, a listen server, a pure client, or a p2p system.

A small message sent from the host to the client, and then returned to measure latency and keep everything in sync.

Is a struct packed using TypeLibrary

A delta-based tick sent by the client

Set the cull state of a networked object

Is a delta snapshot message

Is a delta snapshot cluster message

Is a delta snapshot acknowledgement

Is a delta snapshot cluster acknowledgement

A request, this is a guid, then another message

A response, this is a guid, then another message

Whether to automatically destroy this lobby when the host leaves. This is only applicable to P2P lobbies.

Whether to periodically switch to the best possible host candidate. This is only applicable to P2P lobbies.

Whether to hide this lobby from appearing in the server list. It will still be queryable programatically, so long as the mode allows it.

Determines who is able to connect to this lobby. This will be public by default.

The maximum amount of players this lobby can hold. By default, this will be the Max Players set in the current Game Package's project settings.

The name of this lobby. If this isn't set, a default lobby name will be chosen instead.

This lobby is open to everyone.

Nobody can join this lobby unless they are invited.

Only friends can join this lobby.

Whether this socket should be disposed automatically when the network system it belongs to is disconnected.

This is called on a worker thread and should handle any threaded processing of messages.

Called when everything has just been hooked up to the network system.

ConnectionInfo table has been updated

Called when a session has failed with a user. Steam Networking Messages will invoke this callback if an attempt to send a message to a user failed because of a broken session.

Set data about this socket. For example, this might be used to change whether a lobby should be visible for players depending on the game state.

Set the name of the server. This will be displayed to other players when they query servers.

Set the current map name. This will be displayed to other players when they query servers.

Called once a second

A network system is a bunch of connections that people can send messages over. Right now it can be a dedicated server, a listen server, a pure client, or a p2p system.

True if we're currently connecting to the server. We're not yet spawned etc.

If true then this host is sending assemblies and other files via network tables and as such, does not need to load assemblies from the package (if it even exists).

Get whether there are any connections still doing the handshake process.

Find a connection by its unique id.

Start the handshaking process with the specified client .

Restart the handshaking process. This could be used if the host changed while we're connecting.

Called from the host to add a connection to the ConnectionInfo table

We were disconnected from the server. This will almost always be when we're on a dedicated server and it has closed down.

Called any time we suspect the connection info might have changed, which lets us tell the sockets/connections to update any information they hold.

Are we the owner of this network system? True if we're hosting the server, or we're the current owner of a p2p system.

Has this network system been disconnected?

Are we currently disconnecting from networking?

Whether the host is busy right now. This can be used to determine if the host can be changed.

We have received a log message from another client.

We have received a UserInfo ConVar value update from a client.

We have received a console command from a client that should be run on the server.

We have received network / performance stats from the server.

We have received a changed server name.

We have received a changed map name.

We have received changed data from the server.

The server has told us to reconnect

We have received a message intended for a different connection.

Called to read and process incoming messages.

Server says hello to the client. It tells the client some basic information about itself. The client can determine here whether they still want to join or not.

Process any incoming or outgoing messages. This would usually be called on a worker thread unless threaded networking is disabled.

Send a message to all connections. You can optionally pass in a filter to determine who actually receives the message.

The message to send. The minumum state the connection must be to receive the message. If specified, the connection must pass this filter to receive the message. Network message flags that may dictate how the message is sent.

Broadcast a packed message to all connections.

Get a list of connections that meet a specific criteria.

The minumum state the connection must be to receive the message. If specified, the connection must pass this filter to receive the message.

String tables should all get installed at this point.

Install a network table. If we're the host then this table will be sent to all clients.. but only if they have the same named network table installed.

The maximum size of a snapshot entry in megabytes.

Called when a table entry is changed or added from the network

The table has been fully replaced. Anything or everything could have changed.

Called when a table entry is removed by the network

Called after a network update of the table is complete. Not called after snapshots!

Read an unmanaged struct from the data

An empty connection that can be used for testing and optimizing processing. Messages can not actually be sent to it, and it won't receive any either. Other clients will be unaware of it.

A mock channel. Allows passing this to RPCs when they're being called locally.

A mock channel. Allows passing this to RPCs when they're being called locally. Mock connections will also exist for other clients when connected to a dedicated server. If we try to send a message to one, we'll route that message through the server instead.

Override for pre-encoded payloads (e.g. from Broadcast's single-encode path). Decodes the wire bytes and routes through the host via .

A direct connection to a peer in a lobby.

A fake socket that wraps around a Steam lobby.

The time until we should try to find a new host.

The SteamId of the host of this lobby.

How many cunts are in this lobby.

Current owner of this lobby.

The underlying Steam lobby.

Current config of this lobby.

Enqueue a message to be sent to a user on a different thread.

Process any incoming messages from Steam networking and enqueue them to be handled by the main thread.

Send any queued outgoing messages via Steam Networking API.

Send any queued outgoing messages and process any incoming messages to be queued for handling on the main thread.

Make sure this steamid has this connection id

A connection to a SteamId. This can be a SteamId of an individual Steam user or an assigned SteamId for a game server.

A connection to an IP and port.

A connection from a listen socket.

Send any queued outgoing messages and process any incoming messages to be queued for handling on the main thread.

Process any incoming messages from Steam networking and enqueue them to be handled by the main thread.

This gets called by the SteamAPI, so only really need to call this in unit tests.

A socket that listens on a SteamId and virtual port.

A socket that listens on an IP address and port.

A listen socket, one socket to many. We should really use this just for dedicated servers.

Send any queued outgoing messages and process any incoming messages to be queued for handling on the main thread.

Process any incoming messages from Steam networking and enqueue them to be handled by the main thread.

A handle to a connection.

A handle to a listen socket

A handle to a poll group

A listen socket, one socket to many. We should really use this just dedicated servers imo.

Send the network data in a thread. This prevents the client from freezing up when running a client and server in the same process. In reality this only really happens in unit tests, but better safe than sorry.

A listen socket over TCP. For testing locally.

An interface for networked properties via .

Called when initializing with a network table at the specified slot.

Our slot index in the network table The object we belong to

An interface to implement to determine whether this object is a proxy.

Indicates that this type must be sent reliably and cannot be sent as part of a delta snapshot.

An interface for specifying how a custom type can be serialized and deserialized over the network with support for only sending changes.

Write any changes to the . This is only applicable if the type that implements this also implements .

Write all data to the .

Read data from a .

Whether we currently have changes (are we dirty?)

Describes a change to a which is passed to whenever its contents change.

A networkable dictionary for use with the and . Only changes will be networked instead of sending the whole dictionary every time, so it's more efficient.
Example usage:


            public class MyComponent : Component
            {
            	[Sync] public NetDictionary<string,bool> MyBoolTable { get; set; } = new();
            	

            	public void SetBoolState( string key, bool state )
            	{
            		if ( IsProxy ) return;
            		MyBoolTable[key] = state;
            	}
            }

Represents a change in the dictionary.

Get notified when the dictionary is changed.

Do we have any pending changes?

Write any changed items to a .

Read a network update from a .

Write all items to a .

Read all changes in the dictionary as if we're building it for the first time.

Read any changed items from a .

Describes a change to a which is passed to whenever its contents change.

A networkable list for use with the and . Only changes will be networked instead of sending the whole list every time, so it's more efficient.
Example usage:


            public class MyComponent : Component
            {
            	[Sync] public NetList<int> MyIntegerList { get; set; } = new();
            	

            	public void AddNumber( int number )
            	{
            		if ( IsProxy ) return;
            		MyIntegerList.Add( number );
            	}
            }

Represents a change in the list.

Get notified when the list has changed.

Do we have any pending changes?

Write any changed items to a .

Read a network update from a .

Write all items to a .

Read all changes in the list as if we're building it for the first time.

Read any changed items from a .

A network table that can be used with [Sync]. It will be serialized fully for clients when they first need it, and then it will be sent as delta snapshots when individual entries change.

Read-only access for all entries in the network table.

Clear the network table.

Set the value of an entry in the specified slot.

Get the value of an entry in the specified slot.

Called when initialized from a parent network table.

Called whenever a key is removed from the table.

Called whenever a value changes in a specific slot.

Called when the network table is cleared.

A containing Transforms but each component of the transform is added to a .

Automatically synchronize a property of a networked object from the host to other clients. Obsolete: 11/12/2024

Create a new interpolator for the type of the provided value.

Query the interpolated value at the provided time.

Contains a target value and the current interpolated value for the property it represents.

Query the value at the specified time.

Update the value with the latest value from the network.

Describes the behavior of network objects.

Disable network transform interpolation for this networked object.

Disable position synchronization for the transform of this networked object.

Disable rotation synchronization for the transform of this networked object.

Disable scale synchronization for the transform of this networked object.

Disable synchronization for the entire transform of this networked object.

Specifies how a should be networked.

Never network this .

Network this as a single network object. Objects networked in this way can have an owner, and synchronized properties with .

Network this to other clients as part of the snapshot.

The unique of the underlying .

The of the connection that created this.

If true, then this object is spawning on the host, on behalf of another client. While it's doing this, we're going to act like the host is the owner... so that anything called in OnAwake will think we're not a proxy - until we've fully handed it off.

The of the connection that owns this.

Are we the owner of this networked object?

Is this networked object unowned?

This is a proxy if we don't own this networked object.

Current snapshot version for this networked object.

Initialize and spawn this networked object with the specified owner .

Call INetworkSpawn hooks

Tell everyone that we exist, and spawn any child network objects with the same owner.

Initialize this networked object from a create message.

Send a detach message to all other clients. Only the host can detach a networked object.

Only cull this object if we've been invisible for this long.

Remove a connection id from any internal data structures.

Called when the host has changed.

Clear all connections associated with the local snapshot state.

Is this network object visible to the provided . We'll check if we have a culler component and use that, but we'll also use our bounds to determine if we're visible.

Whether the specified has control over this networked object. A connection has control if the object is unowned, and they are the host, or if they own it directly.

Get a deterministic property slot for use with a network table.

Write all reliable data table entries.

Write all pending data table changes.

Read the network table data.

Specifies what happens when the owner of a networked object disconnects.

Destroy the networked object.

Assign the host as the owner.

Randomly assign another connection as the owner.

Clear the owner of the networked object.

Configurable options when spawning a networked object.

The default network spawn options.

Should this networked object start enabled?

Who should be the owner of this networked object?

Specifies who can control ownership of a networked object.

Anyone can control ownership.

Only the host can change the ownership.

Anyone can request ownership changes from the host.

Marks a method as being an RPC. This means that it can be called over the network.

Marks a method as being an RPC. It will be called for everyone.

Marks a method as being an RPC. It will only be called on the host.

Marks a method as being an RPC. It will only be called on owner of this object.

The that is calling this method.

The id of the that is calling this method.

Whether we're currently being called from a remote .

Resume a method from an RPC. If the RPC caller is our local connection then we'll first disable any active filter and restore it afterwards.

Called right before calling an RPC function.

Filter the recipients of any Rpc called in this scope to only include the specified set.

Only send the RPC to these connections.

Filter the recipients of any Rpc called in this scope to only include a based on a predicate.

Only send the RPC to connections that meet the criteria of the predicate.

Filter the recipients of any Rpc called in this scope to only include the specified .

Only send the RPC to this connection.

Filter the recipients of any Rpc called in this scope to exclude a based on a predicate.

Exclude connections that don't meet the criteria of the predicate from receiving the RPC.

Filter the recipients of any Rpc called in this scope to exclude the specified set.

Exclude these connections from receiving the RPC.

Filter the recipients of any Rpc called in this scope to exclude the specified .

Exclude this connection from receiving the RPC.

An instance RPC call is incoming from the network. Look up the method and call it.

Does the current caller have permission to invoke the RPC?

Called when an instance RPC is called for a and .

Do the actual send of the instance RPC.

A static RPC call is incoming from the network. Look up the method and call it.

Called when a static RPC is called with a single argument of an array type.

Called when a static RPC is called with object parameters.

Does the current caller have permission to invoke the RPC?

Do the actual send of the static RPC.

Marks a method as being an RPC that when invoked will be called for all connected clients including the host. The state of the object the RPC is called on will be up-to-date including its and any properties with the or attributes by the time the method is called on remote clients. The only except is any synchronized properties marked with which will generally only be received every network tick.

Marks a method as being an RPC specifically targeted to the owner of the , or the host if the doesn't have an owner.

The state of the object the RPC is called on will be up-to-date including its and any properties with the or attributes by the time the method is called on remote clients. The only except is any synchronized properties marked with which will generally only be received every network tick.

Specifies who can invoke an action over the network.

Anyone can invoke this.

Only the host can invoke this.

Only the owner can invoke this. If the action is static, this works the same way as .

This is created and referenced by the network system, as a way to route.

Any GameObjects created within this scope will not send spawn messages to other clients.

Any GameObjects destroyed within this scope will not send destroy messages to other clients.

Load a scene for all other clients. This can only be called by the host.

Start a network spawn batch. Any networked objects created within this scope will be sent with one spawn message. This makes sure that any references are kept to child networked objects when the objects are spawned on the other side.

Broadcast the spawning of a networked object. This will add the networked object to the batch list if we're spawning as part of a batch and will ignore the spawn message entirely if we're supposed to be suppressing spawn messages.

Broadcast the detachment of a networked object.

Broadcast the destruction of a networked object. The message will be ignored if we're supposed to be suppressing destroy messages.

Called when the host has provided us with a snapshot for a newly loaded scene.

Called when a client has requested the snapshot for a newly loaded scene. This is usually once they've done any preloading that they need to do.

Called when the host has told us to load a new scene.

Called by clients to confirm they have finished loading the new scene.

A client has joined and wants to know what VPKs to preload.

Asynchronously load and mount any VPKs from the provided server response.

A client has joined and wants a snapshot of the world.

Write any snapshot data from for a .

We have received a snapshot of the world.

Read any snapshot data from for a .

Called on the host to decide whether to accept a . If any that implements this returns false, the connection will be denied.

The reason to display to the client.

A heartbeat has been received from the host. We should make sure our times are in sync.

We've received a cull state change for a networked object.

A delta snapshot message has been received from another connection.

When a client has sent an acknowledgement that they've received a refresh message for a networked object.

When a in the hierarchy of a networked object has been destroyed.

When a in the hierarchy of a networked object has been added or changed.

When a networked object has been refreshed. This is a full update message for that networked object. Any new GameObjects or Components in the hierarchy will be created and existing ones will be updated.

Automatically synchronize a property of a networked object from the owner to other clients.

Query this value for changes rather than counting on set being called. This is appropriate if the value returned by its getter can change without calling its setter. Obsoleted: 13/12/2024

Flags that describe how this property is synchronized.

Describes the behaviour of network synchronization.

The host has ownership over the value.

Query this value for changes rather than counting on set being called. This is appropriate if the value returned by its getter can change without calling its setter.

The value will be interpolated between ticks. This is currently only supported for , , , , , .

Find all "__guid" guids, and replace them with new guids. This is used to make GameObject serializations unique, so when you duplicate stuff, it copies over uniquely and keeps associations.

Find all "Id" guids, and replace them with new guids. This is used to make GameObject serializations unique, so when you duplicate stuff, it copies over uniquely and keeps associations.

Create a unique copy of the passed in GameObject

Get a (cached) scene from a PrefabFile

Render a GameObject to a bitmap. This is usually used for easily rendering "previews" of GameObjects, for things like saving thumbnails etc.

Render a Model to a bitmap. This is usually used for easily rendering "previews" of Models for thumbnails

Run an action inside a batch group. A batchgroup is used with GameObject and Components to make sure that their OnEnable/OnDisable and other callbacks are called in a deterministic order, and that they can find each other during creation.

New GameObjects and Components are registered with this class when they're created, and unregistered when they're removed. This gives us a single place to enforce Id uniqueness in the scene, and allows for fast lookups by Id.

Find a GameObjectSystem in the scene by Guid. This should be really really fast.

Find a Component in the scene by Guid. This should be really really fast.

Find a GameObject in the scene by Guid. This should be really really fast.

Find objects with this name. Not performant.

Allows components to add metadata to the scene/prefab file, which is accessible before loading it.

A prefab which is loaded and accessible via GameObject.GetPrefab( x )

Contains the the JSON for the prefab after loading it's cached scene and expanding all prefab instances. We cache this since we use this quite often to resolve nested prefab instance overrides.

Contains all the prefab files that are referenced by this prefab scene.

Don't try and do this. You can't destroy a PrefabCacheScene.

A list of variables and their targets for this prefab scene

A collection of variabnles that have been configured for this scene

Called for every enabled component

Get all components of type. This can include interfaces. This function can only find enabled/active components.

For scenes within a hammer MapWorld, for action graph stack traces, and so the editor knows the map must be saved when editing graphs from it.

If true we'll additive load the system scene when this scene is loaded. Defaults to true. You might want to disable this for specific scenes, like menu scenes etc.

Global render attributes accessible on any renderable in this Scene.

Returns true if this scene has not been destroyed

Destroy this scene. After this you should never use it again.

Create a GameObject on this scene. This doesn't require the scene to be the active scene.

Push this scene as the active scene, for a scope

Collects anything inside into a batch group. A batchgroup is used with GameObject and Components to make sure that their OnEnable/OnDisable and other callbacks are called in a deterministic order, and that they can find each other during creation. calls will also be batched.

Cache all enabled and disabled cameras in the scene. Registered/Deregistered in CameraComponent.OnAwake and OnDestroy.

Should be called before rendering. This allows things like reflections to render.

Allows quickly finding components that have a volume

Adds the "system" scene, which is defined in the project settings.

Find objects with all tags

Find objects with tag

Adds a GameObject to delete later

Delete any GameObjects waiting to be deleted

Allows access to the scene's editor session from the game. This will be null if there is no editor session active on this scene.

The scene for this session

True if this scene has unsaved changes

Selection system for this session

If we have any gameobjects selected, return the first one

You have changed the editor's selection, add a new undo entry

Focus the editor camera onto this box

Save this scene to disk

Tell undo about this property change

Add a new undo entry

Gets the current selection from the editor

Get the filesystem in which temporary files can be created. These files can be used (and shipped) by a package, but won't be stored in source control. This is usually used for files that are expected to be re-generated at runtime by the package itself.

Get the folder for this scene. This is a folder in which we can store assets that are referenced by this scene. Things like envmap textures, lightmaps, baked data, etc.

Run an event on all components. The find argument is unused when calling this on a scene.

Default scene sound listener, at the camera.

Multiple scene sound listeners, created by audio listener components.

Update default sound listener to camera.

Dispose any sound listeners we created.

Add a new sound listener and return it.

Remove and dispose a scene sound listener.

Find the closest sound listener at this point.

Return true if we're in an initial loading phase

Wait for scene loading to finish

Load from the provided . This will not load the scene for other clients in a multiplayer session, you should instead use if you want to bring other clients.

Load from the provided file name. This will not load the scene for other clients in a multiplayer session, you should instead use if you want to bring other clients.

Create a new SceneFile from this scene

Save the contents of this scene to the SceneFile

In editor this gets called every frame In game this gets called every fixed update

One divided by ProjectSettings.Networking.UpdateRate.

Send any pending network updates at our desired .

Do appropriate actions based on the mode for all networked objects owned by a specific connection.

Send all of our visibility origins to other clients. These are points we can observe from, which helps to determine the visibility of network objects and sends a user command.

A cache of all the MapInstances that gets updated every frame

Are these bounds visible to the specified ?

Is a position visible to the specified ?

Should only be called when destroying the scene. This here just to avoid unregistering all of the objects when we don't need to, because we're just quitting.

When hotload occurs, the interfaces etc could have changed. So first of all we want to go through and remove any null entries, then we want to go through and re-add everything.

Adds object instance, indexed by type, to the directory so that its values are accessible by GetAll

Get all objects of this type. This could be a component or a GameObjectSystem, or other stuff in the future.

Gets the first object found of this type. This could be a component or a GameObjectSystem, or other stuff in the future.

All active non-editor scenes.

Call dispose on all installed hooks

Find all types of SceneHook, create an instance of each one and install it.

Apply configuration values to a GameObjectSystem with priority: 1. Project-wide value (from ) 2. Default value (already set by property initializer) Scene-specific overrides are applied during deserialization via

Apply scene-specific GameObjectSystem property overrides. Called during scene deserialization.

Signal a hook stage

Get the hook container for this stage

Reset the listener metrics to 0, like before a benchmark or something

Get a JSON serializable list of metrics from the scene's listeners. (this is just internal object[] right now because I can't be fucked to exose it properly)

Call this method on this stage. This returns a disposable that will remove the hook when disposed.

Get a specific system by type.

Get a specific system by .

Get all systems belonging to this scene.

The update loop will turn certain settings on Here we turn them to their defaults.

Update the current time from the host

Run OnStart on all components that haven't had OnStart called yet

This is called in EditorTick and GameTick. It's only called in EditorTick if we're actually an editor scene.

Find game objects in a sphere using physics.

Find game objects in a box using physics.

Find game objects in a frustum using physics.

Allocation-free scope returned by . Use with using var to keep it stack-allocated; storing as IDisposable will box it.

A wrapper for scene event interfaces. Allows syntax sugar of something like `IPlayerEvents.Post( x => x.OnPlayerHurt( this, amount ) )` instead of using Scene.Run to call them manually.

Post an event to the entire scene, including GameObjectSystem's

Post event to a specific GameObject (and its descendants by default - you can specify a to control this)

The title of this loading task

True if the task has completed

The task itself

returns true if we need to do some managed side filtering

Casts a sphere from point A to point B.

Casts a sphere from a given position and direction, up to a given distance.

Casts a box from point A to point B.

Casts a box from a given position and direction, up to a given distance.

Casts a box from point A to point B.

Casts a box from a given position and direction, up to a given distance.

Casts a capsule

Casts a capsule from point A to point B.

Casts a capsule from a given position and direction, up to a given distance.

Casts a cylinder

Casts a cylinder from point A to point B.

Casts a cylinder from a given position and direction, up to a given distance.

Casts a ray from point A to point B.

Casts a ray from a given position and direction, up to a given distance.

Casts a .

Casts a PhysicsBody from its current position and rotation to desired end point.

Casts a PhysicsBody from a position and rotation to desired end point.

Sweeps each PhysicsShape of given PhysicsBody and returns the closest collision. Does not support Mesh PhysicsShapes. Basically 'hull traces' but with physics shapes. Same as tracing a body but allows rotation to change during the sweep.

Creates a Trace.Sweep using the PhysicsBody's position as the starting position.

Sets the start and end positions of the trace request

Sets the start transform and end position of the trace request

Makes this trace an axis aligned box of given size. Extracts mins and maxs from the Bounding Box.

Makes this trace an axis aligned box of given size. Calculates mins and maxs by assuming given size is (maxs-mins) and the center is in the middle.

Makes this trace an axis aligned box of given size.

Makes this a rotated trace, for tracing rotated boxes and capsules.

Makes this trace a sphere of given radius.

Should we compute hit position.

Should we hit hitboxes

Should we hit meshes too? This can be slow and only works for the editor.

Should we hit physics objects?

Only return entities with this tag. Subsequent calls to this will add multiple requirements and they'll all have to be met (ie, the entity will need all tags).

Only return entities with all of these tags

Only return entities with any of these tags

Only return entities without any of these tags

Use the collision rules of an object with the given tags.

Which tag this trace will adopt the collision rules of. If true, trace against triggers only. Otherwise, trace for collisions (default).

Use the collision rules for the given set of tags.

Which tags this trace will adopt the collision rules of. If true, trace against triggers only. Otherwise, trace for collisions (default).

Do not hit this object

Hit Triggers

Hit Only Triggers

Do not hit static objects

Do not hit dynamic objects

Do not hit keyframed objects

Run the trace and return the result. The result will return the first hit.

Run the trace and record everything we hit along the way. The result will be an array of hits.

Return true if we should hit this shape. We purposely keep this locked down, don't offer a user specified callback.

Return true if we should hit this sceneobject. We purposely keep this locked down, don't offer a user specified callback.

Whether the trace hit something or not

Whether the trace started in a solid

The start position of the trace

The end or hit position of the trace

The hit position of the trace. Requires .

The hit surface normal (direction vector)

A fraction [0..1] of where the trace hit between the start and the original end positions

The GameObject that was hit

The Component that was hit

The Collider that was hit

The physics object that was hit, if any

The physics shape that was hit, if any

The physical properties of the hit surface

The id of the hit bone (either from hitbox or physics shape)

The direction of the trace ray

The triangle index hit, if we hit a mesh physics shape

The tags that the hit shape had

The hitbox that we hit

The distance between start and end positions.

A list of services that we have linked

A list of organizations of which we're a member

A list of our favourited games

Current client hash (the login session cookie)

The current logged in user's steamid

The current logged in user's gamercore

The current logged in user's avatar, from the backend

Update Current

Helper - return true if Current.Favourites contains us

Returns true if a user is a member of this organization

Returns a URL in which users have the ability to upload files (but not the ability to list or download files). This is used so users can upload files to our blob storage, and give us the filename - rather than uploading big ass files to our api.

Get linked service credentials, ie "twitch". Under the hood, on our server, we will probably be renewing the token with the service (assume the token is only good for 2-3 hours).

Post a batch of analytic events. Analytic events are things like compile or load times to help us find, fix and track performance issues.

Add an event to the queue. You should not use this event again.

Force an immediate flush of all events

Post a batch of analytic events. Analytic events are things like compile or load times to help us find, fix and track performance issues.

Collect a statistic. This should usually be called ONCE per frame, per stat.

Convert statDict into an object that we can send to the backend.

Here we take the array of values and convert them into an object with a bunch of statistics about them. Basically trying to cover our bases as much as possible, in case we need to show this data later on.

This attempts to be a unique identifier for the launch of a game.

Flush the stats and wait until they have been ingested by the backend, at which point they should be available in stats and leaderboard queries.

Force an immediate flush of all events

Force an immediate flush of the stats and wait until it's done

Post a batch of analytic events. Analytic events are things like compile or load times to help us find, fix and track performance issues.

The package ident (lowercase [org.package])

The name of the stat (lowercase, no spaces)

When this stat was created

When this stat was updated

If this is an increment

If this represents multiple calls, this is the number of calls

If this represents multiple calls, this is the smallest

If this represents multiple calls, this is the largest

The actual value

Additional context. Map etc..

The current session (or null if #local)

The current time in session

Should be a dynamic object

Returns whether this achievement should be visible to the player

A float, representing the progression of this stat. 0 is 0%, 1 is 100%. Not clamped.

Given a stat return the fraction completed this achievement is. The assumption is that the stat you pass in matches the stat this achievement is looking for. The number returned is unclamped.

Holds achievements for a package

Get achievement by name, or null of it doesn't exist

Use the current stats to recount the progression on stats with progression. This is purely for UI, you can't force an achivement to unlock early by calling this.

Unlock this achievement. It must be a manual achievement.

Unlock this achievement. It can be anything.

Check each achievement to see if it can be unlocked.

For accessing assets from the cloud - from code

Returns the path of the asset referenced by this package

Loads a model from the cloud by its identifier. The asset is downloaded during code compilation, so it's treated like a local model since it's shipped along with your package.

If you wish to load a model at runtime, use instead.

The cloud ident/url of the model

Loads a material from the cloud by its identifier. The asset is downloaded during code compilation, so it's treated like a local material since it's shipped along with your package.

If you wish to load a material at runtime, use instead.

The cloud ident/url of the material

Loads a sound event from the cloud by its identifier. The asset is downloaded during code compilation, so it's treated like a local particle system since it's shipped along with your package.

If you wish to load a sound event at runtime, use instead.

The cloud ident/url of the particle system

Loads a shader from the cloud by its identifier. The asset is downloaded during code compilation, so it's treated like a local shader since it's shipped along with your package.

If you wish to load a shader at runtime, use instead.

The cloud ident/url of the shader

Loads a resource asynchronously from the cloud by its identifier, downloading the package if the client doesn't have it locally.

Checks if a cloud package is installed.

Loads a cloud package asynchronously from the cloud by its identifier

Automatically addeded to a type as a result of using Cloud.Model etc inside.

Tells codegen to generate a [assembly: Cloud.Asset] for this method

Resolve a primary asset to a loaded package

Given a json value, walk it and find paths, resolve them to packages

Given a json string, walk it and find paths, resolve them to packages

A mock package, this is a package wrapped around a

The path to this project's assets

The path to this project's code

The path to this project's localization files

True if this package is shipped with the game - so everyone should have it

A filesystem into which compiled assemblies are written

Retrieve meta directly from the project instead of the package

Return true if we need the "base" package including. There are a few situations: 1. We're the root gamemode

An addon's manifest, describing what files are available

For internal use

A list of files that should be mounted to use this asset

Represents an asset on Asset Party.

Get a list of achievements

Whether this is a remote or a locally installed package.

The owner of this package.

Full unique identity of this package.

Unique identity of this package within its organization..

A "nice" name of this package, which will be shown to players in UI.

A short summary of the package.

Full description of the package.

Link to the thumbnail image of this package.

Link to the thumbnail video of this package.

Engine version this package was uploaded with. This is useful for when the base game undergoes large API changes.

List of tags for this package.

List of packages that this package depends on. These will be downloaded and installed when installing this package.

List of packages that this package depended on during editing.

What kind of package it is.

Whether this package is public or hidden.

Whether this package is archived or not.

The total size of this package in MB. This only applies to packages from Asset Party, the total file size of local packages are not calculated.

Statistics for user interactions with this package

Unique Users

Total combined user-seconds

Total lifetime usage stats

Usage for the last 3 days

Usage for the last week

Usage for the last 24 hours

How many users are using it right now

The trend is a number that represents whether it's been popular recently. Higher means more popular.

Statistics for user interactions with this package

Number of players who added this package to their favourites.

Number of players who voted this package up.

Number of players who voted this package down.

Link to this package's sources, if set.

For game extension compatibility. Game targeting extensions are only compatible with that game if the API Versions match.

A list of screenshots

True if this is a loading screen rather than a regular screenshot

Return the URL of a thumbnail matching this exact size. For caching reasons it's going to be best if we can keep this to round number sizes (256, 512 etc) rather than trying to exact fit.

True if this asset is in our favourite list.

True if we're a member of this package's organization.

A link to this asset on our backend

When the entry was last updated. If these are different between packages then something updated on the backend.

When the package was originally created.

How many collections we're in (roughly)

How many packages we're referencing (roughly)

How many packages we're referenced by (roughly)

Stats for the reviews. Gives the number of reviews, and the fraction of the total score.

What fraction of users got errors from this package in the last day

The latest news post created by this package

Represents an organization on Asset Party. Organization owns packages.

Unique string that identifies this organization.

Full or "nice" name of this organization.

Link to Twitter of this organization, if set.

Link to the website of this organization, if set.

Description of this organization.

Link to the thumbnail image of this organization.

When the organization was created.

Unique index of this revision.

Number of files in this revision.

Total size of all the files in this revision, in bytes.

A summary of the changes in this revision.

When this revision was created.

Engine version of this revision. TODO: How exactly is this different from ?

Manifest of the revision, describing what files are available. For this to be available you should call DownloadManifestAsync first.

The manifest will not be immediately available until you've downloaded it.

Information about the current package revision/version.

Returns true if the org and ident of the passed in ident matches this package

Describes the authenticated user's interactions with this package. This is only available clientside for specific users in order to show things like play history state, favourite status and whether they have rated the item or not.

If this package is a game, it can provide media to show on the loading screen

The URL to an image or video to use as a loading screen. The extension should reveal its type.

Get a data value. These are usually set on the backend, and are package type specific. These are generally values that are used to configure behaviour in the menu system.

Don't blindly download every file in the manifest. We can filter them here.

Download a package to a temporary location and return a filesystem with its contents

Make sure this manifest file entry is what it says it is

Download an individual file

Download and mount this package. If withCode is true we'll try to load the assembly if it exists.

Describes a facet of a group of items, with a limited number of each facet with their total item counts

A facet entry consists of a name, display information and the number of items inside

A result from the call to FindAsync

The amount of time the query took

A list of packages retrieved

The total amount of packages

Facets particular to this search

A list of tags relevant to this search

A list of sort orders. There may be other sort orders, but we provide a list here that can be easily used to save rewriting the same code over and over.

Binary options

Represents a tag along with the count of items it contains

Describes a sort order which can be used with the package/find api

A binary category used to divide into two categories. For example, Work In Progress.

Represents the actual response from the api

The name of this group

The groups of packages

The title of this group

The icon of this group

The style of this group

Link to get a full list of this category

The packages in this group

Gets the name of the primary asset path stored in the package metadata. This could be null or empty.

Get metadata value from this package for given key. This will be specific to each .

Type of the metadata value. This should be something that can be serialized by JSON. The name of the key to look up. Default value to return when requested key was not present in the package's metadata.

but with cache.

Get the full ident with your choice of fidelity

Compiler name to use when building this package's code. Will be of the form "org.ident".

Assembly name to use when building this package's code. Will be of the form "package.org.ident".

Compiler name to use when building this package's editor code. Will be of the form "org.ident.editor".

Assembly name to use when building this package's editor code. Will be of the form "package.org.ident.editor".

Check if the package is installed and mounted

Remove a specific package from the cache

Parse a package ident into parts. There are a few different formats you can pass to this. - org/package - org.package - org.package#version - https://sbox.game/org/package - https://sbox.game/org/package#version If package version isn't specified version will be null

Produces a package ident of the form .[#|#].

Find package information

Mount a package by ident. This is the same as FetchAsync but it also mounts the package, which means it will be available for use right away. If you just want the package information, use FetchAsync.

Find package information

If we have this package information, try to get its name

These packages are created from local addons, and should be the only way 99% of systems interact with local addons.

Retrieve a list of packages

Retrieve a list of packages, organised into groups, for discovery

Sort the given list of packages so that referenced packages are ordered before the packages that reference them.

Unordered list of packages. A new enumerable, ordered to maintain references.

Sort the given list of items so that referenced packages are ordered before the packages that reference them.

Unordered list of items with a corresponding package. Delegate that maps each item to its corresponding package. A new enumerable, ordered to maintain references.

Get package version list

An assembly that has been loaded into a PackageLoader.

If not null, this is an assembly that was created by Fast Hotload

Handles the loading of package assemblies into a loadcontext.

In tools mode we don't register events unless they're from a tools project

Disables access control on all loaded local packages, but not remote packages.

Called on Game Loop Init

Make sure we should be able to load this dll

If successful, will change outgoing in place and return true

Return true if, between and , package references are added or removed, or a package reference changes version and wasn't fast-hotloaded itself. If either is the case, the incoming assembly can't be fast-hotloaded because the types it references have changed.

Trigger a switch event

Called by Enroller to get the assemblies associated with a package. If deep is true then this should return all assemblies needed by this package and its dependencies.

Holds a list of assemblies with the intention of enrolling them into services like TypeLibrary, Event. Handles deduplication and switching due to hotloading etc..

All of the assembles loaded into this enroller

Get all of the loaded assemblies. This is only to be used when sending assemblies to children.

Called by PackageLoader when the assembly has undergone a fast hotload

Called after hotload, to register a swapped assembly

Called internally on all the assemblies when a package is loaded. This then calls down to all of the listeners, to let them know.

General options that are usable whenever we load a package

Mounts assets from the package, but does not compile or load any code.

The ident of the package to load

A group tag for this package, so we can unload all packages using this tag

For cancelling the task

If true we will only download the code files (.bin) and not the assets.

If false, the resource system will not reload symlinked resident resources after mounting. Set to false when batch-installing packages and call NativeEngine.g_pResourceSystem.ReloadSymlinkedResidentResources() once manually afterwards.

Loading progress callbacks

Describes a package that is currently mounted. Mounted packages are shared between client, server and editor. We keep track of which host is using which package using Tags.

The project settings folder

The project's localization folder

Mounted on FileSystem, this is where the codearchive is mounted to

Set the filesystem up from this downloaded asset

Called to unmount and remove this package from being active

List all currently active packages

Install a package in the specific context

The package ident The context (ie, client, server)

Unmount all packages that use a specific tag. This is usually done on leaving a game for client and server

The library used to load assemblies

Called when a new package is installed

Install a package

Install all of the projects as packages

Retrieve a package by ident.

Retrieve a package by ident and minimum download mode.

The manifest might not be immediately available until you've downloaded it

Get a data value. These are usually set on the backend, and are package type specific. These are generally values that are used to configure behaviour in the menu system.

Some game logic implemented using visual scripting

A component which allows you to use action in all the usual functions.

A component that only provides actions to implement with an Action Graph.

These should not exist

ActionGraph to run when the relevant event occurs.

Reacts to collisions.

Reacts to collider triggers.

Returns a color with a random hue.

Saturation of the generated color, from 0 to 1. Lightness of the generated color, from 0 to 1.

A sound resource.

A sound event. It can play a set of random sounds with optionally random settings such as volume and pitch.

A model.

A material. Uses several Textures and a Shader with specific settings for more interesting visual effects.

A prefab.

An asset defined in C# and created through tools.

Optional target to post this event to. Only components within this target and its descendants will receive the event. If not provided, the whole will be used.

Plays a sound at the position of the target object.

True if we are the owner of the GameObject

A that provides .

Source location for action graphs that belong to a Hammer map. This is used for stack traces, and for knowing which map to save when editing a graph.

Gets a from a path name.

Project-relative map path ending with ".vmap" or ".vpk".

Source location for action graphs that belong to a . These can include scenes and prefabs, or custom resources. This is used for stack traces, and for knowing which asset to save when editing a graph.

Resource that contains action graphs.

A task that does nothing for a given amount of time in seconds. This will continue even if the object containing this graph is destroyed, you probably want → Time → Delay instead.

Time to wait in seconds. Token for cancelling the delay.

A task that does nothing for a given amount of time in seconds, and cancels automatically if the target is destroyed.

Cancel the delay if this object is destroyed. Time to wait in seconds. Token for cancelling the delay.

Tests if the given input is of the given type, otherwise returns null.

Input type. Type to test for. Input value to test the type of.

Tests if the given input is null or invalid.

Input value to test for null.

Tests if the given input is not null and not invalid.

Input value to test for null.

A mix frame size is 512 samples A second is made up of 44100 samples This means one frame is about 11.6ms So as long as mixing takes less than 10ms we're okay

How many output channels do we have? Generally 2, but if they have a 7.1 setup it can be more.

How many seconds one sample lasts

The engine's output sampling rate. This doesn't change.

The size of one

Called every frame.

Allows the capture and monitor of an audio source

The amount of individual voices playing

A wrapper around CAudioMixer, which is used in c++ to read from a wav etc. This has two parts. o Sample - reads the samples, advances the index o GetSamples - returns the samples. The reason it's coded like this is because each mix frame we read all samples, then the mixers can do whatever they want with them. So rather than have the mixers fight over reading and advancing, they can all get the samples if they want to.

Read samples to our internal buffer and advance the index. Pitch should be default 1.

Get the last read samples. This is called by the mixers.

Contains 512 samples of audio data, this is used when mixing a single channel

If true, this buffer pointer is managed by something else

This is locked from being disposed

Silence this buffer

Get direct access to the memory

Set this buffer to this value

Mix this buffer with another

Scale the buffer by volume

Holds up to 8 mix buffers, which usually represent output speakers.

How many channels do we have

Delete and release all resources. Cannot be used again.

Get MixBuffer number i

Silence all buffers

Set this buffer to this value

Copies from one buffer to the other. If the other has less channels, we'll upmix

Mix the target buffer into this buffer

Scale volume of this buffer

Send to device output

Mix each channel into the single buffer, using passed in volume

An instance of a DspPreset. The actual processor creates one of these from a DspPreset, and then uses it to process the audio buffers.

Defines a DSP preset. This is a collection of DSP processors that can be applied to a sound. These originate from Half-Life 1's DSP system, and give that iconic Source Engine Sound.

A handle to a DspPreset

Listens for sounds in a scene.

Currently active listeners.

Listener's that have been removed this frame.

Direct access to active listeners list. Use for iteration without allocation.

Direct access to removed listeners list. Use for iteration without allocation.

For the mixing thread to know which listeners have been removed.

Listener's world transform, where we are listening to sounds from.

Mixer thread safe transform.

Listener's world position, where we are listening to sounds from.

Weak reference to the scene, so we don't prevent GC of the scene when listeners are held in static lists.

Scene this listener belongs to. May return null if the scene has been collected.

Get active sound listener states.

Takes a bunch of sound, changes its volumes, mixes it together, outputs it

Allows monitoring of the output of the mixer

Unique identifier for this object, for lookup, deserialization etc

Final mixed output buffer containing audio from all listeners.

Per-listener audio buffers mixed into the final output buffer.

Tracks which listener buffers were used during the current frame.

We don't want to access sound listeners directly, because it might keep changing in the other thread. This is a local copy for us to use.

Id of listeners that have been removed so we can dispose of their buffers.

The current voices playing on this mixer

Reused working list to avoid per-frame LINQ allocations.

Final mixed output buffer containing audio from all listeners.

The display name for this mixer

Scale the volume of our output by this amount

The maximum amount of voices to play at one time on this mixer

If true then this mixer will use custom occlusion tags. If false we'll use what our parent uses.

The tags which occlude our physics

Get an array of occlusion tags our sounds want to hit. May return null if there are none defined!

When 0 the sound will come out of all speakers, when 1 it will be fully spacialized

Sounds get quieter as they go further away

How much these sounds can get occluded

How much the air absorbs energy from the sound

Should this be the only mixer that is heard?

Is this mixer muted?

The default mixer gets all sounds that don't have a mixer specifically assigned

Called at the start of the mixing frame

Mix the child mixes

Mix the incoming voices into the mix

Mixing is finished. Clean up and finalize

Mix a single voice

This will spatialize the voice based on its location

Stop all sound handles using this mixer

We might want to do a fast lookup at some point

Private, because we want to make this as thread safe as possible

Add a processor to the list

The amount of processors

Get the current processor list

Get the first processor of a specific type, or null if not found

Actually apply the processors to the output buffer

A handle to a Mixer

This is a real thread! We need to be very careful about what this accesses, and how.

Queue an AudioSampler for disposal between mix frames, so the native CAudioMixer is never freed while a mixing task still holds a reference to it.

Read one sample from each voice

Mark any finished voices as finished

Takes a bunch of samples and processes them. It's common for these to be chained together. It's also common for the processor to store state between calls.

Is this processor active?

Should we fade the influence of this processor in?

The listener's position in this frame.

Should process input into output

Will process the buffer, and copy it back to output

Called internally to process each channel in a buffer

For implementations that process each channel individually

One of these is created for every listener that uses an audio processor.

Called when audio processor or the listener is removed.

Optionally target a listener, this processor will only run for a specific listener.

Set current state for listener.

Remove any states associated with these listeners.

Represents an audio channel, between 0 and 7. This is used to index into buffers. This is used rather than an int to avoid unfortuate bugs.

Stores a variable per channel

Get the value in a channel

Set the value in a channel

Audio processor that allows per listener state.

Per listener states.

Current state for listener.

Set current state for listener.

Remove any states associated with these listeners.

Destroy and clear all states.

Just a test - don't count on this sticking around

Cutoff frequency of the high-pass filter (0 to 1, where 1 is Nyquist frequency).

Processes each channel individually using a simple one-pole high-pass filter.

Just a test - don't count on this sticking around

Cutoff frequency for the low-pass filter (normalized 0 to 1).

Processes a single audio channel with a low-pass filter.

Time tracking for occlusion updates, managed by SoundOcclusionSystem

Stop any lerping and jump straight to the target occlusion

Set the target occlusion value. Called by SoundOcclusionSystem after computing occlusion.

A source for the "direct" group of effects. This gets added to the SteamAudio scene and is simulated for things like occlusion.

Buffers should be mono in, mono out

Buffers should be mono in, stereo out

Called by the sound handle at the appropriate times to update the native source

Time tracking for occlusion updates, managed by SoundOcclusionSystem

Set the target occlusion value. Called by SoundOcclusionSystem after computing occlusion.

Single source for creating sounds

Sound listener of the active scene.

The user's preference for their master volume.

Precaches sound files associated with given sound event by name. This helps avoid stutters on first load of each sound file.

Get a list of available DSP names

Uncompress the voice data

The sample rate for voice data

Play a sound and set its position

Play a sound and set its mixer

A handle to a sound that is currently playing. You can use this to control the sound's position, volume, pitch etc.

RealTime that this sound was created

Sorts by creation time descending; static to avoid per-call allocations.

An empty, do nothing sound, that we can return to avoid NREs

Position of the sound.

The direction the sound is facing

This sound's transform

Volume of the sound.

A debug name to help identify the sound

How 3d the sound should be. 0 means no 3d, 1 means fully

How many units the sound can be heard from.

The falloff curve for the sound.

The fadeout curve for when the sound stops.

The fadein curve for when the sound starts.

Pitch of the sound.

Whether the sound is currently playing or not.

Whether the sound is currently paused or not.

Sound is done

Enable the sound reflecting off surfaces

Allow this sound to be occluded by geometry etc

The radius of this sound's occlusion, allow for partial occlusion

Should the sound fade out over distance

Should the sound get absorbed by air, so it sounds different at distance

Should the sound transmit through walls, doors etc

Which mixer do we want to write to

Marks this sound as voice/speech audio (e.g., from VoiceComponent). Voice sounds use cheaper HRTF interpolation since they don't benefit from bilinear filtering.

How many samples per second?

Keep playing silently for a second or two, to finish reverb effect

Keep playing until faded out

Time remaining until the fade-in completes

Have we started fading out?

Are we currently fading in?

True if the sound has been stopped

The current time of the playing sound in seconds. Note: for some formats seeking may be expensive, and some may not support it at all.

Place the listener at 0,0,0 facing 1,0,0.

If true, then this sound won't be played unless voice_loopback is 1. The assumption is that it's the local user's voice. Amplitude and visme data will still be available!

Measure of audio loudness.

Weak reference to the scene, so we don't prevent GC of the scene when sound handles are held in static queues.

Scene this sound belongs to. May return null if the scene has been collected.

Return true if this has no mixer specified, so will use the default mixer

Return true if we want to play on this mixer. Will return true if we have no mixer specified, and the provided mixer is the default.

Gets the effective mixer this sound will play on. Returns the TargetMixer if set, otherwise the default mixer.

Returns true if this sound is ready to be mixed (has sampler, not finished, valid). Used by both mixer and occlusion system to determine if sound should be processed.

This is called on the main thread for all active voices

Called to push changes to a sound immediately, rather than waiting for the next tick. You should call this if you make changes to a sound.

Before we're added to the active list, we need to get some stuff straight

Update our position every frame relative to our parent

If we're following a parent, our position will be this relative to them.

If set with a parent and is true, we will update our position to match the parent's world position. You can use to set an offset from the parent's position. Setting a parent also allows you to use GameObject.StopAllSounds on the parent to stop all sounds that are following it. This is set automatically when calling on a GameObject, but you can set it manually if you want to change the parent of an existing sound handle.

Clear our parent - stop following

Tell the SoundHandle to follow this GameObject's position

Access lipsync processing.

A list of 15 lipsync viseme weights. Requires to be true.

Count from start of recognition.

Frame delay in milliseconds.

Laughter score for the current audio frame.

Enables lipsync processing.

Number of samples per second, as set during its creation.

Number of audio channels, as set during its creation.

Close the stream: signals that no more data will be written. Once the internal buffer drains, will become false.

Play sound of the stream.

A result from speech recognition.

From 0-1 how confident are we that this is the correct result?

The text result from speech recognition.

Did we successfully find a match?

Called when we have a result from speech recognition.

Whether or not we are currently listening for speech.

Whether or not speech recognition is supported and a language is available.

Start listening for speech to recognize as text. When speech has been recognized the callback will be invoked, the callback will also be invoked if recognition fails.

A callback that will be invoked when recognition has finished. An array of possible choices. If specified, the closest match will be chosen and passed to the callback.

Stop any active listening for speech.

A speech synthesis stream. Lets you write text into speech and output it to a .

Called by SpeechSynthesizer to populate viseme data.

Gets a list of currently installed voices on the user's system.

Gets the current voice being used by .

Tries to set the voice to a matching voice name installed on the user's system.

Tries to set the voice matching gender and age criteria.

Adds some text to the speech.

Registers an action to fetch all viseme data.

Sets the playback rate of the synthesizer.

Adds a break to the speech.

Takes info from and creates a , outputting to a stream object. Using we then read all the PCM samples, and write it to a SoundStream. This means it'll work like any other sound.

A collection of helper methods to help read PCM samples. Taken mostly from https://github.com/Facepunch/sbox-arcade/

Saved into config file

If true then this cannot be interacted with via game code

If true then this command can only be run on the server

If true then this command can only be run by a server administrator

Server value is replicated to clients

Not visible in auto complete and find

Client values are sent to the server, accessible via Connection userinfo

Can't access unless sv_cheats is 1

If we have a command line version of the command then set it and return true

Todo: Add support for managed commands to return shit here Todo: We could maybe do this in a cool way, using parameters? So that for example, we could list players if it's a player etc

A library to interact with the Console System.

Try to set a console variable. You will only be able to set variables that you have permission to set.

Get a console variable's value as a string.

Invoke a method when a property with [Change] is changed.

When we update a ConVar in code, call the ConsoleSystem.

When we query a convar property

Run this command. This should be a single command.

Run this command, along with the arguments. We'll automatically convert them to strings and handle quoting.

Actually do the business of trying to run a command. Will return (not throw) an exception object if an exception is thrown of command isn't found.

Called when the ConVar is changed.

Add this assembly to the console library, which will scan it for console commands and make them available.

Remove this assembly and its console commands.

Add this command to the library. Any existing commands named the same will be over-written.

Add this ConVar to the library. Any existing commands named the same will be over-written.

Get a ConVar value as a string.

Get a ConVar value as an integer. If the ConVar value is a boolean, this will return the value in its integer form.

Get a ConVar value as a float.

Try to set a ConVar. You will only be able to set variables that you have permission to set.

Save all the convars.

Run a single command. [command] [args]

Run a potential string of commands, separated by newlines or ;

Split a command string on ';' and '\n', but respect quoted sections.

Should be called any time a ConVar is changed. This should be called from two places, the managed side and the native side. Managed side comes from when the property value actually changes. The native side comes from a on change callback. CAVEAT: This will only get called for ConVars that use CODEGEN!

Called from native as a result of calling RefreshNativeVariables

If set to non 0, this key will be deleted at/after given time. This is useful in case you didn't open your game for more than 30 days (which is the default expiry time), and then you lose all your cookies because they all are expired and get deleted on launch. This way you have a 24 hour grace period.

Not public, not IDisposable. Don't want people to be able to do this from game.

Set a cookie to be stored between sessions. The cookie will expire one month from when it was set.

Get a stored session cookie.

Load JSON encodable data from cookies

Set JSON encodable object to data

Removes a cookie from the cache entirely

A visual scripting task composed of executable blocks.

Marks a static method as callable from within a Doo script.

The fully qualified method path (e.g. "Log.Info").

The category portion of the path, derived from the text before the first dot.

Creates a new with the given method path.

Specify a hint on a Doo explaining that we're going to be passing in an expected argument when calling it.

The argument name shown in the editor.

A help string describing what this argument is for.

The expected type of this argument.

Specify a hint on a Doo explaining that we're going to be passing in an expected argument when calling it.

Creates a new with the given name and type hint.

Base class for all executable blocks within a Doo.

Optional list of child blocks nested inside this block.

Returns a human-readable string describing this block for display in the editor.

Returns true if this can have child nodes

Reset this block to some sensible defaults. This is called when the block is first added, so this is a good opportunity to set up default values for properties.

Recursively collects all variable names referenced by this block and its children.

Wait for a number of seconds

The number of seconds to wait before continuing.

Run a block of code a certain number of times, with a loop variable.

The name of the loop counter variable.

The initial value of the loop counter.

The upper bound of the loop (exclusive).

The amount to increment the loop counter each iteration.

Call a global method or a method on a component.

Whether this invokes a static global method or a component member.

The component instance to invoke the method on when using .

The fully qualified method path to invoke (e.g. "Log.Info").

The list of argument expressions to pass to the method.

Variable name to set to the returned value. Leave empty to ignore the return value.

Stops execution of the current Doo immediately.

Set a variable to a value.

The name of the variable to assign to.

The expression whose result will be stored in the variable.

Provides configuration for a Doo run, such as setting initial argument values.

Sets a local variable for this Doo run.

The top-level list of blocks that make up this task.

Determines how an invoke block resolves its target method.

Returns a short display label describing this Doo's contents.

Returns true if this Doo has no blocks.

Find and delete this block from the Doo tree.

Remove a block from a list, searching recursively.

Insert a block before the target block.

Insert a block after the target block.

Insert relative to target (offset 0 = before, offset 1 = after).

Add a block as a child of the target block's body.

Base class for all value expressions used as arguments and assignments within blocks.

Evaluates this expression and returns its value.

Returns a human-readable string representation of this expression for the editor.

Collects all variable names referenced by this expression.

An expression that evaluates to a constant literal value.

The constant value this expression evaluates to.

An expression that evaluates to the current value of a named variable.

The name of the variable to read.

Utility methods for the Doo scripting system.

Finds a method by its fully qualified path (e.g. "TypeName.MethodName"). Returns null if the type or method cannot be found.

Deserializes a Doo from JSON.

Serializes a Doo to JSON.

Built-in static methods available to Doo scripts.

Logs an informational message.

Logs a warning message.

Logs an error message.

Destroys the given GameObject.

Clones a GameObject, optionally spawning it on the network.

Clones a GameObject with an explicit position, rotation, and scale.

Abstracts a link to a component - which can be * An actual component * A GameObject and a component type * A Variable (GameObject or Component) and a component type

Resolves the component

The Component we want to target directly.

The GameObject that contains the target component.

The type of Component we want to access. This allows us to select members that exist on this type.

The name of the variable we're going to use. This can be a GameObject or a Component.

Collects all variable names referenced by this expression.

System that manages the execution of Doo scripts within a scene.

Creates a new DooEngine for the given scene.

Sets a global variable that is accessible to all Doo scripts in this scene.

Downloadeded assets go in the ".source2/assets" folder, where they are symlinked on demand for use by the engine.

We have downloaded an asset file. Store it for reuse in the future

Try to mount the downloaded file with this path and crc. If it doesn't exist, return false

Makes sure the directory exists, and returns the relative path to this file

Generate the absolute path for this, whether it exists or not

Is a file an legal download or not (filter out executables etc)

Given a file with a crc, create a unique cache filename for it

Content from libraries. This only exists in editor.

For tools, maintain a list of mounted addon content paths

A place to write files temporarily. This is stored in memory so cleaning up after yourself is a good idea (!)

The .source2/temp folder

The folder holding the project's settings files

Don't try to use the filesystem until you've called this!

Setup Config parameter

Setup Addons parameter (there's no reason for this to exist now?)

Setup Download folder

Setup Addons parameter (there's no reason for this to exist now?)

Should only be called at the very death

A filesystem that can be accessed by the game.

Normalizes given file path so the game's filesystem can understand it. Fixes slashes and lowercases the file path.

The file path to normalize The normalized file path

All mounted content.

A subset of for custom gamemode data.

A filesystem for custom data, per gamemode's organization.

A cached keystore that can be used for anything. This is stored in a global cache folder, and may be deleted at any time.

Create a filesystem that exists only in memory

Allows storing files by hashed keys, rather than by actual filename. This is sometimes useful.

Creates a keystore which is in a global cache position. The folder can be deleted at any time, and it's all fine and no-one cares.

Store a bunch of bytes

Get stored bytes, or return null

Get stored bytes, or return false

Check if a key exists

Remove a key

A filesystem that redirects a package's local paths to the actual files in a download cache

Create a new storage entry of the given type.

A name to categorize this type as. For example "dupe" or "save" A new Entry

Create a storage entry from an existing filesystem. This is used when downloading workshop entries.

This is what is saved to the .meta file

This matches ERemoteStoragePublishedFileVisibility in native

A folder of content stored on disk

The identity of this content

The type of content, eg "save", "dupe"

Metadata about this content. This gets saved to disk automatically.

When this content was created

This is where you save and load your files to

Creates a new storage entry with the specified type

The content type (letters only, 1-16 characters)

Set a meta value

Get a meta value

Gets the thumbnail texture for this storage entry, if one exists

Sets the thumbnail for this storage entry

The bitmap to use as the thumbnail

Deletes this storage entry and all its files from disk

Publishes this storage entry to the workshop

The title for the workshop item Additional tags to apply to the workshop item Additional key-value pairs for the workshop item

Publishes this storage entry to the workshop

Install a workshop file, return a LocalFileSystem to it

The data returned by CUgcInstall

Query the Steam Workshop for items

Specific workshop file IDs to query. When set, other filters are ignored and the query returns details for these specific items.

Tags that the item must have all of to be included in results.

Tags that the item must not have any of to be included in results.

KeyValues that the item must match to be included in results.

Search Text

Max Cache Age in seconds

Sort Order

Filter results to items published by this Steam ID. When set, uses a user-specific query instead of a global one.

Number of days to consider for rank trend calculations

Run the query

The results of a Steam Workshop query

Returns true if there are more results to be fetched

Get the next set of results from the query. Returns null if none.

Details about a UGC item returned from a Steam Workshop query

Install this item. This can return null if it's not of the right format.

Assert if any one type takes more than this duration to process, AND more than of the total time.

Assert if any one type takes more than this fraction of the total time to process, AND more than .

Does the actual hotload

Lets the hotload system know that something has changed. If we detect that we are replacing a dll (instead of just adding one) we'll queue up a swap. We should still call this even if or is null, since that will tell the hotload system to start / stop watching static members of the assembly.

Gets a sensor reading from the device's gyroscope (if it has one)

Gets a sensor reading from the device's accelerometer (if it has one)

Sets the color of the gamepad if supported

What type of controller is this?

Which glyph vendor are we using for this controller? - default "The default vendor type, which uses Xbox glyphs" - playstation - switch

Rumbles the controller.

The speed of the left motor, between 0 and 0xFFFF The speed of the right motor, between 0 and 0xFFFF The duration of the vibration in ms

Rumbles the controller's triggers (if supported)

The speed of the left trigger motor, between 0 and 0xFFFF The speed of the right trigger motor, between 0 and 0xFFFF The duration of the vibration in ms

Stops all rumble and haptic events on this controller.

Stop all vibration events on this controller.

Trigger a vibration based on a predefined . All s are normalized (start at 0, peak at 1).

The pattern to use The amount to scale the pattern's length by. The amount to scale the pattern's frequency by. The amount to scale the pattern's amplitude by.

A list of all of the controllers, active and inactive.

Get the first controller that's connected (shortcut)

The input context for this controller.

SDL reports values between this range

Get an axis

An axis

Allows querying of player button presses and other inputs.

What's our current player index (for input scoping)? -1 is the default behavior, where it'll accept keyboard AND gamepad inputs. Anything above that, is targeting a specific controller.

How many controllers are active right now?

Whether or not the Virtual Cursor should show when using a controller. Disable this to control the cursor manually.

Tries to find the current controller to use.

An analog input, when fetched, is between -1 and 1 (0 being default)

Processes controller inputs based on a player index (for input scoping). This can be called many times a frame.

Push a specific player scope to be active

Was the last button pressed a game controller button?

Missing action names that we've warned about already. This gets cleared when actions are initialized again.

We pack actions bit-by-bit in CUserCmd, using the index (which is shared between realms) to map it to an action. This is an accessor to grab that index easily from its action.

True if escape was pressed

Action is currently pressed down

Action wasn't pressed but now it is

Action was pressed but now it isn't

Remove this action, so it's no longer being pressed.

Clears the current input actions, so that none of them are active.

Clears the current input actions, so that none of them are active. Unlike ClearActions this will unpress the buttons, so they won't be active again until they're pressed again.

Releases the action, and it won't be active again until it's pressed again.

Activates / Deactivates an action when building input.

Called when a compatible button is pressed.

Copies all input actions to be used publicly

Names of all actions from the current game's input settings.

Finds the of the given action.

Action name to find the group name of.

Read the config from this source

The current input context, pushed using Context.Push

Get all of the contexts

If the input is suppressed then everything will act like there is no input

Allows tracking states of button changes and input deltas in a custom period (such as a tick) rather than in a per frame manner. This allows frame and tick to have legit data.

Copy accumulated values. Flip previous actions to current actions etc.

Make this the current active context. You can optionally use the returned IDisposable to restore back to the previous context when you're done.

Virtual Reality specific input data.

Movement delta from the mouse.

The state of the mouse wheel.

True if the mouse cursor is visible (using UI etc)

Analog look value from the default input device. This is scaled by Preferences.Sensitivity - so you don't need to scale it afterwards.

Analog move value from the default input device.

Called multiple times between ticks.

Current state of the current input device's motion sensor(s) if supported. This is only supported on: Dualshock 4+, Switch Controllers, Steam Controller, Steam Deck.

This will return if no button was set in the action.

Returns the name of a key bound to this InputAction For example: Input.GetButtonOrigin( "Undo" ) could return SPACE if using keyboard or A Button when using a controller.

Convert a button code to its user-facing keyname (our best guess at what's painted on the physical key cap)

Tries to load a glyph texture, will seek the current vendor controller (Xbox, PlayStation, Nintendo) and fall back to Xbox if not found.

Some keys can't be parsed by files because they're symbols, so we change them into something readable

Get a glyph texture from the controller bound to the action. If no binding is found will return an 'UNBOUND' glyph.

You should update your UI with this every frame, it's very cheap to call and context can change.

Get a glyph texture from an analog input on a controller.

Returns the name of the analog axis bound to this . For example: Input.GetButtonOrigin( InputAnalog.Move ) could return Left Joystick

Keyboard related glyph methods.

Get a glyph texture from a specific key name.

Keyboard key is held down

Keyboard key wasn't pressed but now it is

Keyboard key was pressed but now it isn't

Trigger a haptic event on supported controllers including Xbox trigger impulse rumble.

SDL will translate these commands into haptic pulses that should work on all controller types. The speed of the left motor, between 0.0 and 1.0. The speed of the right motor, between 0.0 and 1.0. (Xbox One controller only) The speed of the left trigger motor, between 0.0 and 1.0. (Xbox One controller only) The speed of the right trigger motor, between 0.0 and 1.0. How long (in milliseconds) should we apply this for?

Trigger haptics based on a predefined . All s are normalized (start at 0, peak at 1).

The pattern to use The amount to scale the pattern's length by. The amount to scale the pattern's frequency by. The amount to scale the pattern's amplitude by.

Trigger haptics based on a predefined . All s are normalized (start at 0, peak at 1).

The pattern to use The amount to scale the pattern's frequency by. The amount to scale the pattern's amplitude by.

Stop all vibration events on the current controller.

An analog input, when fetched, is between -1 and 1 (0 being default)

Represents the current state of a device's motion sensor(s).

The raw value from the input device's gyroscope.

The raw value from the input device's accelerometer.

Game controller codes, driven from SDL.

Normally the small button on the left side of a gamepad

The big button in the middle of a gamepad, usually with the logo on it

This is automatically used as the escape key in all games

The button when you press down on the stick

Also known as the left bumper, or LB, or L1

Also known as the right bumper, or RB, or R1

This is a button that doesn't have a specific name, like the share button on some controllers

Extra button on the back of some gamepads, like the Xbox Elite

Also known as LT, or L2

Also known as RT, or R2

Contains a haptic effect, which consists of patterns for the controller and triggers.

A haptic pattern that represents a light, soft impact.

A haptic pattern that represents a hard, sudden impact.

Applies a simple rumble to the controller.

Applies a simple rumble to the left trigger.

Applies a simple rumble to the right trigger.

A haptic effect that feels like a heartbeat.

Contains a haptic pattern, which consists of frequency and amplitude values that can change over time.

A haptic pattern that represents a light, soft impact.

A haptic pattern that represents a hard, sudden impact.

A haptic pattern that represents a constant low-frequency rumble.

A haptic pattern that feels like a heartbeat.

Places you can trigger haptics on

Controller

Left impulse trigger (Xbox)

Right impulse trigger (Xbox)

Small 32x32 ( Keyboard glyphs can be wider for long key names )

Medium 128x128 ( Keyboard glyphs can be wider for long key names )

Large 256x256 ( Keyboard glyphs can be wider for long key names )

Translates this enum to pixel size.

Face buttons will have colored labels/outlines on a knocked out background Rest of inputs will have white detail/borders on a knocked out background

Black detail/borders on a white background

White detail/borders on a black background

ABXY Buttons will match the base style color instead of their normal associated color

ABXY Buttons will have a solid fill

Internal bit flags for glyph styles, matches Steam Input ones.

An input action defined by a game project.

The name of the input action. Used by Input.Down|Pressed|Released.

A group name for this input when showing in a binding system

A friendly name for this input action when showing in a binding system

The key or key combo we'll be watching for.

What gamepad button should this action map to?

State of mouse buttons being pressed or not.

No buttons are being pressed.

Left mouse button is being pressed.

Right mouse button is being pressed.

Middle mouse button (mouse wheel) is being pressed in.

The "back" mouse button (mouse4) being pressed in.

The "forward" mouse button (mouse5) being pressed in.

A container for the current language, allowing access to translated phrases and language information.

The abbreviation for the language the user wants. This is set by the user in the options menu.

Information about the current selected language. Will default to English if the current language isn't found.

FileSystem used for localization.

Called when file(s) have changed and we should reload next tick

Look up a phrase

The token used to identify the phrase Key values of data used by the string. Example: {Variable} -> { "Variable", someVar } If found will return the phrase, else will return the token itself

Allows access to translated phrases, allowing the translation of gamemodes etc

The abbreviation for the language the user wants. This is set by the user in the options menu.

Information about the current selected language. Will default to English if the current language isn't found.

Look up a phrase

The token used to identify the phrase Key values of data used by the string. Example: {Variable} -> { "Variable", someVar } If found will return the phrase, else will return the token itself

Controls which s from a scene are controlled by which from a . Can be serialized to save which tracks are bound to which targets.

Creates any missing s or s for the given to target.

Creates any missing s or s for the given set of to target.

Destroy any instances created by .

Create any missing s or s for the given track and its children to target.

We've created from a prefab, but we only want child objects / s that we have tracks for. Remove the rest here.

We've created during , bind it to the track reference it was created for and keep track of it for removal during .

Controls which s from a scene are controlled by which from a . Can be serialized to save which tracks are bound to which targets.

The scene this binder is targeting.

Gets or creates a target that maps to the given . The target might not be bound to anything in the scene yet, use to check.

Get all reference targets for tracks in the given .

Reference type, for example or a type. Movie clip to find track bindings for.

Get all property targets for tracks in the given .

Property value type. Movie clip to find track bindings for.

Get all bound component references for tracks in the given .

Component type. Movie clip to find track bindings for.

Gets the default binder for the active scene.

Map track IDs to s and s.

Map s and s to the track IDs they are bound to.

Finds track IDs currently explicitly bound to the given .

Returns true if there's an existing mapping for the given , and outputs that mapping as . Note that is a valid binding, to force a track to map to nothing.

Target that references a in a scene.

If our parent object is bound, try to bind to a child object with a matching name. If we have no parent, look up by referenceId, or default to a root object with the right name.

Target that references a in a scene.

If our parent object is bound, try to bind to a component with a matching type.

Reads / writes an anim graph parameter on a .

Any property in a is an anim graph parameter, but we can only determine the type if it actually exists.

Helper methods for working with .

Can we make a or of the given ? Returns true if is either , or derived from .

If is a constructed , gets the wrapped type. Otherwise, returns .

Used by movie property tracks with or value types to reference other tracks. This value will be resolved to whatever the referenced track is bound to during playback. Needed for properties like .

Either , or a type. Track to look up the binding of during playback.

Used by movie property tracks with or value types to reference other tracks. This value will be resolved to whatever the referenced track is bound to during playback. Needed for properties like .

Either , or a type. Track to look up the binding of during playback.

Track to look up the binding of during playback.

Resolve this binding reference by looking up the current binding for .

Binder to look up the current binding in.

Procedural property inside , that makes the object look at a world position.

Pseudo-property on a that has a sub-property for each bone. Stores movie-driven transforms for each bone during playback, and applies them when performs .

Renderer this accessor was created for.

Helper to see if the renderer's model has a bone with the given .

Gets the current movie-driven parent-space transform of the given bone. If the bone isn't controlled by a movie, just returns the current parent-space transform.

Sets the current movie-driven parent-space transform of the given bone.

Clears any movie-driven bone transforms for this renderer.

Applies any movie-driven bone transforms. Called during .

Reads / writes a bone transform on a .

Any property inside a is a bone.

Coordinates playing bone animations from s. Holds a for s in the scene, which store any movie-controlled bone transforms.

Applies any active movie-driven bone transformations.

Clears all movie-driven bone transformations for the given .

Gets the current movie-driven parent-space transform for the given bone. If this bone isn't currently being controlled by a movie, returns its current transform.

Sets the current movie-driven parent-space transform for the given bone.

Procedural property inside , that makes the object look at a world position.

Movie property that references a field or property contained in another . For example, a property in a .

Value type stored in the property.

Movie property that references a field or property contained in another . For example, a property in a .

Value type stored in the property.

True if still exists. Can become false after a hotload that removed the member.

Default behaviour is to check if the parent is active.

Reads / writes a morph parameter on a .

Any property inside a is a morph.

Used by to create instances that allow s to modify values in a scene.

Used to sort the order that factories are considered when trying to create a property.

Lists all available property names provided by this factory from a given .

Decides if this factory can create a property given a target and . Returns any non- type if this factory can create such a property, after which will be called using that type.

When listing properties to add, what category should we use for the given property provided by this factory?

Create a property with the given , , and property value type . The target type was previously returned by , or read from a deserialized track.

An that only creates properties nested inside a particular target type.

Parent target type that this factory's properties are always nested inside.

An that only creates properties nested inside a particular target type, and that always have the same property value type .

Parent target type that this factory's properties are always nested inside. Property value type for properties created by this factory.

Returns true if this factory can create a property with the given and .

Creates a property with the given and .

Special handling for .

Fallback property that can never be bound.

Dummy type for to return if it matches a track, but doesn't know what target type it maps to.

Something in the scene that is being controlled by an . This could be a or reference, or a property contained within another . These targets are created using . If is true, this target is connected to a live instance of something in the scene, so accessing it will affect that connected instance.

The binder that created this target.

Name of this target, for debugging and editing.

Value type of this target.

If true, this target is connected to a real object in the scene, so can be accessed.

If true, the target is bound and active in the scene hierarchy.

If bound, the current value of this target in the scene.

Component / game object / property that contains this target, if from a nested track.

Target value type.

A target referencing a or in the scene.

The of the reference track this target was created from.

Optional game object target that contains this one, if from a nested track.

Explicitly bind this reference to a particular object in the scene, or null to force it to stay unbound.

Clear any explicit binding, so this reference will auto-bind based on its name, type, and parent.

Reference value type.

A target referencing a member property or field of another target.

Target that this member belongs to.

False if this member is write-only.

False if this member is read-only.

If bound, gets or sets the current value of this member.

If bound and writable, update this property's value from the given at the given .

Property value type.

A collection of s describing properties changing over time and actions being invoked.

All tracks within the clip.

How long this clip takes to fully play.

Attempts to get a reference track with the given .

The matching track, or if not found.

Get tracks that are active at the given .

Maps to a in a scene, and describes how it changes over time.

Property or object name, used when auto-binding this track in a scene.

What type of object or property is this track targeting.

Tracks can be nested, which means child tracks can auto-bind to targets in the scene if their parent is bound.

Additional information used when editing or animating reference tracks.

ID of the or this track was created to target. For tracks, the prefab path that the original target object was instantiated from.

Additional information used when editing or animating reference tracks.

ID of the or this track was created to target. For tracks, the prefab path that the original target object was instantiated from.

ID of the or this track was created to target.

For tracks, the prefab path that the original target object was instantiated from.

Maps to an in a scene, which binds to a or .

Identifier for this track. Must be unique in the containing , but different clips can share tracks as long as they have identical names, types, and parent tracks.

Additional information used when editing or animating this track.

Reference value type, must match .

Unused, will describe running actions in the scene.

Controls an in the scene. Defines what value that property should have at each moment of time.

For a given , does this track want to control its mapped property. If so, also outputs the desired property value.

Property value type.

For a given , does this track want to control its mapped property. If so, also outputs the desired property value.

A time region where something happens in a movie track.

Start and end time of this block.

Describes a value that changes over time.

What type of value does this signal describe?

What value does this signal have at the given time?

A with a defined start and end time.

A that can change dynamically, usually for previewing edits / live recordings.

Helper methods for working with and .

How deeply are we nested? Root tracks have depth 0.

Searches for a track with the given , starting from the root level of the clip.

Searches for a property track with the given , starting from the root level of the clip.

Property value type.

For each track in the given that we have a mapped property for, set the property value to whatever value is stored in that track at the given .

If we have a mapped property for , set the property value to whatever value is stored in the track at the given .

A block of time where something happens in an .

Move this block by the given time .

Trim this block down to the given .

Time range to clamp to.

Unused, will describe starting / stopping an action in the scene.

Start and end time of this block.

Unused, will describe starting / stopping an action in the scene.

Start and end time of this block.

Interface for blocks describing a property changing value over time.

Interface for blocks describing a property changing value over time. Typed version of .

This block has a single constant value for the whole duration. Useful for value types that can't be interpolated, and change infrequently.

Json-serialized constant value.

This block has a single constant value for the whole duration. Useful for value types that can't be interpolated, and change infrequently.

Property value type. Start and end time of this block. Json-serialized constant value.

This block has a single constant value for the whole duration. Useful for value types that can't be interpolated, and change infrequently.

Property value type. Start and end time of this block. Json-serialized constant value.

Start and end time of this block.

This block contains an array of values sampled at uniform intervals.

Time offset of the first sample.

How many samples per second.

Raw sample values.

This block contains an array of values sampled at uniform intervals.

Property value type. Start and end time of this block. Time offset of the first sample. How many samples per second. Raw sample values.

This block contains an array of values sampled at uniform intervals.

Property value type. Start and end time of this block. Time offset of the first sample. How many samples per second. Raw sample values.

Start and end time of this block.

Time offset of the first sample.

How many samples per second.

Returns a property block with only sample data within . Returns the current instance if it represents an irreducible block. If only one sample is needed, will return a .

An immutable compiled designed to be serialized.

A clip with no tracks.

Create a root that targets a with the given . To create a nested track, use .

Create a root that targets a with the type . To create a nested track, use .

Helper methods for working with , , or .

Create a nested that targets a with the given .

Create a nested that targets a with the type .

Create a nested that targets a property with the given in the parent track.

Create a nested that targets an item with the given in the parent collection property track.

Helper for creating a compiled child track with the given and value . Some special cases if the parent track is a reference track: is Returns a game object reference track extends Returns a component reference track By default, returns a property track.

Returns a clone of with an appended with the given and .

Returns a clone of with an appended with the given , , and list of sample .

Interpreting as an array of samples taken at a given , read a sample from the array at the given offset from the first sample. Optionally uses to interpolate between samples.

Plays a in a to animate properties over time.

Maps s to game objects, components, and property s in the scene.

Contains a to play. Can be a or .

If true, creates any missing s and s for the current movie to target.

Play the current movie from the start.

Play the specified movie from the start.

Movie resource to play.

Play the specified clip from the start.

Movie clip to play.

Forces the creation of any missing s or s for the current to target.

Apply the movie clip to the scene at the current time position.

Set the of all bound renderers.

A container for a , including optional .

Compiled movie clip.

Editor-only data used to generate .

Mark this resource as modified, with changes coming from the given .

An editor-only movie project that can be compiled into a .

Compile this project into a playable .

A movie clip created with the MoviePlayer component.

An embedded in a property.

When added to a , handles how to capture the properties of a particular component type.

Returns true if this recorder can handle the given .

Handle capturing the properties of the given instance. Find properties to capture using , then call on them.

Generic helper implementation of .

Component type this capturer supports. Will match on derived component types too.

Records properties in a scene to tracks ready for use in a . You can use this for in-game demo recording of a whole scene, or only specific properties, configured using . You can manually call to move the recording time along, then to write all recorded properties to tracks. Alternatively, call to automatically advance and capture every fixed update, and to finish recording. Convert the recording to a by calling . This clip can then be played back immediately, or serialized to later use.

Start or stop movie recording.

Optional ring buffer duration.

Saves the current recording without stopping it.

Configuration deciding which properties are captured, and at what sample rate.

Maps tracks to objects and properties in the scene.

Scene we're recording. Will match .

Recorded time range, spanning from the first capture to the current value of .

Which s recorded anything during the last call to .

Current recording time, increased by calling .

Create a new , recording the given with the given .

Scene to record. Optional configuration, defaults to .

Create a new with the given and .

Binder to map tracks to objects in a scene. Optional configuration, defaults to .

Gets a for the given , creating one if it doesn't exist. If reject this game object, returns null instead.

Object in the scene to record.

Gets a for the given , creating one if it doesn't exist. If reject the component's game object, returns null instead. Calling on the returned recorder will use s to decide which properties to capture. These handlers are configured using .

Component in the scene to record.

Gets a for the given , creating one if it doesn't exist. If reject whatever game object the track is bound to, returns null instead.

Track to record.

Starts recording the scene. Stop recording by calling , or disposing the returned object. Recording will automatically stop when the recorded scene is being destroyed.

Stop recording the scene. Does nothing if you haven't called .

Moves recording ahead by the given . This will happen automatically if you've called .

Runs all actions in . This will happen automatically if you've called .

Convert the current recording to a that can be serialized or played back.

Convert the current recording to a that can be saved as a .movie asset.

Ticks all s for the current scene.

If true, only the host or editor sessions can use the movie command.

Returns if the passed shouldn't be recorded. Called once per object.

Called each time is invoked.

Call this static method when building . The method must have exactly one parameter, of type , and must return a .

Configures a , deciding how often it captures and which properties should be recorded.

How often to capture the value of recorded properties. Keep only the most recent samples in memory, with this duration. If , samples won't be discarded and the recording will keep growing in size until stopped.

Configures a , deciding how often it captures and which properties should be recorded.

How often to capture the value of recorded properties.

Keep only the most recent samples in memory, with this duration. If , samples won't be discarded and the recording will keep growing in size until stopped.

Default value for .

Default options, using and .

Decide which objects are allowed to be recorded. Called the first time a is passed to , which will return if any delegate in this list returns .

Delegates called each time is invoked, to control which objects should be recorded. These actions will call on one or more track recorders.

When is called on a component track, any instances in this list that match the component type will be used to decide which properties on that component should be recorded.

Watches some object or property in the scene, capturing its state whenever is called.

Describes the track this recorder is recording to.

Currently recorded data for this track.

Gets or creates a recorder for the named sub-property.

Property name.

Write the current state of the recorded object or property to the owning .

Compiles captured values for this property and all sub-properties into tracks.

Binder targeting the prefab source of this object (if it's a prefab instance), so we can find the default values of each track.

Compiles the samples written by this writer to a block, clamped to the given .

Interpolates between two values of the same type.

Value type to interpolate.

Interpolate between two values.

Value to return when is 0. Value to return when is 1. Fraction between 0 and 1 (inclusive).

Helper for accessing implementations, for interpolating between two values of the same type

Attempts to find a default interpolator for type , returning if not found.

Value type to interpolate.

Attempts to find a default interpolator for the given , returning if not found.

Interpolator for common types.

Represents a duration of time in a movie. Uses fixed point so precision is consistent at any absolute time. Defaults to .

How many per second. This value should nicely divide into common frame rates.

Frame rates <= 120 that can be perfectly represented by , in ascending order. Venturing outside these rates will lead to some frames being slightly different durations than others.

Given a , how many frames have passed before reaching this time.

Given a , how many frames have passed before reaching this time, and how far into the current frame are we.

Given a , how many frames would need to be allocated to represent every moment of time up until now. This is always at least 1, and will be 1 more than unless this time is exactly on a frame boundary.

Represents a segment of time, given by and times.

Minimum time in the range. Maximum time in the range.

Represents a segment of time, given by and times.

Minimum time in the range. Maximum time in the range.

Minimum time in the range.

Maximum time in the range.

Global manager to hold and tick the singleton instance of NetworkSystem.

Set data about the current server or lobby. Other players can query this when searching for a game. Note: for now, try to keep the key and value as short as possible, Steam enforce a character limit on server tags, so it could be possible to reach that limit when running a Dedicated Server. In the future we'll store this stuff on our backend, so that won't be a problem.

Get data about the current server or lobby. This data can be used for filtering when querying lobbies.

The name of the server you are currently connected to.

The name of the map being used on the server you're connected to.

The maximum number of players allowed on the server you're connected to.

The last connection string used to connect to a server.

Get the latest host stats such as bandwidth used and the current frame rate.

True if we can be considered the host of this session. Either we're not connected to a server, or we are host of a server.

True if we're currently connected to a server, and we are not the host

True if we're currently connecting to the server

True if we're currently disconnecting from the server

The connection of the current network host.

Whether the host is busy right now. This can be used to determine if the host can be changed.

A list of connections that are currently on this server. If you're not on a server this will return only one connection (Connection.Local). Some games restrict the connection list - in which case you will get an empty list.

Internally update the server name without propagating to sockets.

Get the status of our connection to the Steam Datagram Relay service.

Reset any static members to their defaults or clear them.

Aggregate wire stats across all active non-local connections, expose them via , and feed them into the performance telemetry pipeline so they appear in activity updates alongside frametime and render stats.

Try to join the best lobby. Return true on success.

When creating a lobby from the editor, we'll use this override for the lobby privacy.

Will create a new lobby with the specified to customize the lobby further.

Will create a new lobby.

Disconnect from current multiplayer session.

Will try to determine the right method for connection, and then try to connect.

The client has been told to reconnect to the server. Pause while the server restarts, then attempt to reconnect.

Get all lobbies for the current game.

Get all lobbies for a specific game.

Get all lobbies for a specific game and map.

Get all lobbies that match the specified filters.

Add an empty connection for debugging purposes. This connection cannot receive or send data and it won't be visible to other clients.

Build info for the local user, which will then get sent to the server and possibly shared between all clients

A connection, usually to a server or a client.

Called when we receive from this .

Our outgoing data. Whether or not we want to continue to connect.

Called when we receive from this .

Whether or not we want to allow this connection

Get whether this connection has a specific permission.

This connection's unique identifier.

A unique identifier that is set when the connection starts handshaking. This identifier will be passed into all handshake messages, so that if a new handshaking process starts while one is already active, old handshake messages will be ignored.

The this connection belongs to.

An array of Pvs sources from this connection.

Calculate the closest distance (squared) to a position based on the Pvs sources from this .

Calculate the closest distance to a position based on the Pvs sources from this .

Can this connection spawn networked objects?

Can this connection refresh networked objects that they own?

Can this connection destroy networked objects they own?

True if this channel is still currently connecting.

True if this channel is fully connnected and fully logged on.

How many messages have been sent to this connection?

How many messages have been received from this connection?

Kick this from the server. Only the host can kick clients.

The reason to display to this client.

Log a message to the console for this connection.

Get stats about this connection such as bandwidth usage and how many packets are being sent and received.

Send a message to this connection.

Virtual override point — exists so can intercept the raw for routing through the host before encoding happens. All other code should prefer calling with already-encoded bytes.

Send an already wire-encoded payload. Chunks it into packets if the payload exceeds the threshold and the message is reliable.

This is called on a worker thread and should handle any threaded processing of messages.

Current internal progression of this connection.

Generate an ID for this connection. This is called by the server to allocate the connection an identifier. We're avoiding sequential, allocated ids because who needs to deal with that bullshit.

Update this channel's info. Usually called from the host.

Called once a second.

The ping of this connection (in milliseconds.)

The server has worked out the round trip time on a connection using the heartbeat. We want to keep a sliding window of this timing and use it to predict the latency.

The connection info before connection is added

The Id of the party that this user is a part of. This can be used to compare to other users to group them into parties.

Check if this connection has a specific inventory item in their Steam Inventory

New, updated UserInfo data arrived. Replace our old data with this.

Set or update an individual UserInfo data key.

Only include the connections in the filter when sending a message.

Exclude the connections in the filter when sending a message.

Is the specified a valid recipient?

Build the for this .

Clear pending pressed and released actions for all connections in the Update context.

Clear pending pressed and released actions for all connections in the Fixed Update context.

Clear the state of this input context.

Action is currently pressed down for this .

Action was pressed for this within the current update context.

Action was released for this within the current update context.

Entry point for all incoming transport packets. Handles chunk reassembly transparently; fully assembled (or non-chunked) payloads are decoded and dispatched to .

Send a message to this connection, wait for a response

Send a response message to this connection.

A response to a message has arrived, route it to the correct async function

This is a "fake" connection for the local player. It is passed to RPCs when calling them locally etc.

The connection of the current network host.

Find a for a Connection Id.

Reset any static members to their defaults or clear them.

Upper bound on decompressed payload size. Any packet claiming a larger original length is treated as corrupt/malicious and rejected.

Encode a into a wire-ready packet, applying LZ4 when beneficial. Wire format: [FlagRaw][data] or [FlagCompressed][origLen:4][lz4data]. Returns a heap-allocated [] that transports may store beyond the call.

Decode a wire payload ( or ). packets must be fully reassembled by before reaching this method. Returns a span into either the source data (raw) or the static (compressed). The span is only valid until the next call to .

Build a transport-level chunk packet: [FlagChunk:1][index:4][total:4][data:N]. Chunks carry raw slices of an already-encoded (possibly compressed) payload. Chunk header is 9 bytes vs the old 14-byte envelope.

Message will be sent unreliably. It may not arrive and it may be received out of order. But chances are that it will arrive on time and everything will be fine. This is good for sending position updates, or spawning effects. This is the fastest way to send a message. It is also the cheapest.

Message will be sent reliably. Multiple attempts will be made until the recipient has received it. Use this for things like chat messages, or important events. This is the slowest way to send a message. It is also the most expensive.

Message will not be grouped up with other messages, and will be sent immediately. This is most useful for things like streaming voice data, where packets need to stream in real-time, rather than arriving with a bunch of other packets.

Message will be dropped if it can't be sent quickly. Only applicable to unreliable messages.

Only the host may call this action

Only the owner may call this action

Message will be sent unreliably, not grouped up with other messages and will be dropped if it can't be sent quickly.

Specifies who can invoke an action over the network.

Send to everyone

Send to the owner of this

Only send to the host.

Convert these flags to an integer usable with the Steam Networking API.

Reset the string table.

Add all files from the network.

Add a file to be networked.

Remove a networked file.

Manages the network string table "ServerPackages", which contains a list of packages that the client should have installed. During join the client will install these packages before loading in.

Reset the string table.

Add all files from the network.

Add a file to be networked.

Remove a networked file.

A User Command that will be sent to the current host every tick.

The command number of this .

Which actions are currently being held down.

Serialize this to the specified .

Deserialize this from specified .

Reset the next available command number back to zero.

Create a new with the next available command number.

A static class that handles user permissions.

Represents a user in the user permissions config.

Get whether or not the specified has this permission.

Save user permissions to disk.

Load user permissions from disk. The file location should be "config/users.json".

A ballsocket constraint.

Constraint friction.

Maximum angle it should be allowed to swing to

The control joint is designed to control the movement of a body while remaining responsive to collisions. A spring can be used to control position and rotation, while a velocity motor can control velocity and simulate friction in top-down games. Both methods can be combined — for example, a spring with friction. Position and velocity control each have configurable force and torque limits.

The desired relative linear velocity.

The desired relative angular velocity in radians per second.

The joint maximum force.

The joint maximum torque.

The spring linear hertz stiffness and damping ratio.

The spring angular hertz stiffness and damping ratio.

A generic "rope" type constraint.

TODO: How is this different from ? Should they be merged?

How springy and tight the joint will be in its movement.

How springy and tight the joint will be in its rotation.

A hinge-like constraint.

Maximum angle it should be allowed to go

Minimum angle it should be allowed to go

Hinge friction.

A pulley constraint. Consists of 2 ropes which share same length, and the ratio changes via physics interactions. Typical setup looks like this:


                @-----------------@
                |                 |
                |                 |
             Object A          Object B

A slider constraint, basically allows movement only on the arbitrary axis between the 2 constrained objects on creation.

Maximum length it should be allowed to go

Minimum length it should be allowed to go

Slider friction.

A rope-like constraint that is has springy/bouncy.

How springy and tight the joint will be

Maximum length it should be allowed to go

Minimum length it should be allowed to go. At which point it acts a bit like a rod.

Maximum force it should be allowed to go. Set to zero to only allow stretching.

Minimum force it should be allowed to go.

A parallel joint that constrains the Z-axes of two bodies to be parallel using a spring. Useful for keeping a physics body upright relative to another body or a static anchor.

The spring stiffness in cycles per second (Hertz). Higher values make the constraint stiffer.

The spring damping ratio (non-dimensional). A value of 1 is critically damped; values below 1 are under-damped (springy).

The maximum torque the joint can apply.

Enable or disable the wheel joint spring.

Gets or sets the wheel joint suspension stiffness in Hertz.

Gets or sets the wheel joint suspension damping ratio (non-dimensional).

Enable or disable the wheel joint suspension limit.

Gets or sets the wheel joint suspension limits.

Enable or disable the wheel joint spin motor.

Gets or sets the wheel joint spin motor speed in degrees per second.

Gets or sets the wheel joint maximum spin motor torque, usually in newton-meters.

Enable or disable wheel steering. Steering allows the wheel to rotate about the suspension axis.

Gets or sets the wheel joint steering stiffness in Hertz.

Gets or sets the wheel joint steering damping ratio (non-dimensional).

Gets or sets the wheel joint maximum steering torque in N·m.

Enable or disable the wheel joint steering limit.

Gets or sets the wheel joint steering limits in degrees.

Gets or sets the wheel joint target steering angle in degrees.

Gets the current wheel spin speed in degrees per second.

Gets the current wheel spin torque in newton-meters.

Gets the current wheel steering angle in degrees.

Gets the current wheel steering torque in newton-meters.

A physics constraint.

Removes this joint.

Called when the joint breaks.

The this joint belongs to.

The source physics body this joint is attached to.

The target physics body this joint is constraining.

A specific point this joint is attached at on

Enables or disables collisions between the 2 constrained physics bodies.

Strength of the linear constraint. If it takes any more energy than this, it'll break.

Strength of the angular constraint. If it takes any more energy than this, it'll break.

Creates an almost solid constraint between two physics bodies.

Creates a constraint like a rope, where it has no minimum length but its max length is restrained.

Creates a constraint that will try to stay the same length, like a spring, or a rod.

Creates a slider constraint between two physics bodies via s.

Creates a ball socket constraint.

The source physics body. The target physics body to constrain to. The origin of the hinge in world coordinates. The 2 bodies will rotate around this point. The created ball socket joint.

Creates a ball socket constraint.

The source physics body. The target physics body to constrain to. The created ball socket joint.

Used to describe a point on a physics body. This is used for things like joints where you want to pass in just a body, or sometimes you want to pass in a body with a specific location and rotation to attach to.

The physics body this point is attached to.

Position offset from the body's position.

Rotation offset from the body's position.

A transform relative to , containing and with scale of 1.

Transform of this point in world space.

Describe an attachment using a position/rotation local to the body

Describe an attachment using a position/rotation from the world

Spring related settings for joints such as .

The stiffness of the spring

The damping ratio of the spring, usually between 0 and 1

For weld joints only, maximum force. Not for breaking.

This is a JSON serializable description of the physics's collision rules. This allows us to send it to the engine - and store it in a string table (which is networked to the client). You shouldn't really ever have to mess with this, it's just used internally.

Result of a collision between two objects.

Fallback to default behavior.

Collide.

Do not collide, but trigger touch callbacks.

Do not collide.

A pair of case- and order-insensitive tags, used as a key to look up a .

Initializes from a pair of tags.

First of the two tags.

Second of the two tags.

Initializes from a pair of tags.

Returns true if either or matches the given tag.

If no pair matching is found, this is what we'll use

What happens when a pair collides

All tags with either an entry in or .

All known tags as values. Built during validation.

Gets or sets in its serialized form for JSON.

Selects the result with the highest precedence (least colliding).

Gets the specific collision rule for a pair of tags.

Gets the collision rule for a pair of values.

Remove duplicates etc

If false, then instead of operating physics, and UpdateFixed in a fixed update frequency they will be called the same as Update - every frame, with a variable time delta.

If you're seeing objects go through other objects or you have a low tickrate, you might want to increase the number of physics substeps. This breaks physics steps down into this many substeps. The default is 1 and works pretty good. Be aware that the number of physics ticks per second is going to be tickrate * substeps. So if you're ticking at 90 and you have SubSteps set to 1000 then you're going to do 90,000 steps per second. So be careful here.

How many times a second FixedUpdate runs

If the frame took longer than a FixedUpdate step, we need to run multiple steps for that frame, to catch up. How many are allowed? Too few, and the simluation will run slower than the game. If you allow an unlimited amount then the frame time could snowball to infinity and never catch up.

Represents a physics object. An entity can have multiple physics objects. See PhysicsGroup. A physics objects consists of one or more PhysicsShapes.

The GameObject that created this body

The component that created this body

The Hitbox that this physics body represents

Position of this body in world coordinates.

The physics world this body belongs to.

Rotation of the physics body in world space.

Linear velocity of this body in world space.

Angular velocity of this body in world space.

Center of mass for this physics body in world space coordinates.

Center of mass for this physics body relative to its origin.

Is this physics body mass calculated or set directly.

Mass of this physics body.

Whether gravity is enabled for this body or not.

Whether to play collision sounds

Scale the gravity relative to . 2 is double the gravity, etc.

If true we'll create a controller for this physics body. This is useful for keyframed physics objects that need to push things. The controller will sweep as the entity moves, rather than teleporting the object.. which works better when pushing dynamic objects etc.

Enables Touch callbacks on all PhysicsShapes of this body. Returns true if ANY of the physics shapes have touch events enabled.

Sets on all shapes of this body.

Returns true if ANY of the physics shapes have persistent touch events enabled.

Sets on all shapes of this body.

Returns true if ANY of the physics shapes have solid collisions enabled.

Movement type of physics body, either Static, Keyframed, Dynamic Note: If this body is networked and dynamic, it will return Keyframed on the client

The bodytype may change between edit and game time. For navmesh generation we always need to know the bodytype at game time. This override can be set to inform the navmesh generation of the correct game time bodytype.

Whether this body is allowed to automatically go into "sleep" after a certain amount of time of inactivity. for more info on the sleep mechanic.

Transform of this physics body.

Move to a new position. Unlike Transform, if you have `UseController` enabled, this will sweep the shadow to the new position, rather than teleporting there.

How many shapes belong to this body.

All shapes that belong to this body.

Add a sphere shape to this body.

Center of the sphere, relative to of this body. Radius of the sphere. Whether the mass should be recalculated after adding the shape. The newly created shape, if any.

Add a sphere shape to this body.

Add a capsule shape to this body.

Point A of the capsule, relative to of this body. Point B of the capsule, relative to of this body. Radius of the capsule end caps. Whether the mass should be recalculated after adding the shape. The newly created shape, or null on failure.

Add a box shape to this body.

Center of the box, relative to of this body. Rotation of the box, relative to of this body. The extents of the box. The box will extend from its center by this much in both negative and positive directions of each axis. Whether the mass should be recalculated after adding the shape. The newly created shape, or null on failure.

Add a box shape to this body.

Add a convex hull shape to this body.

Center of the hull, relative to of this body. Rotation of the hull, relative to of this body. Points for the hull. They will be used to generate a convex shape. Whether the mass should be recalculated after adding the shape. The newly created shape, or null on failure.

Add a cylinder shape to this body.

Add a cone shape to this body.

Adds a mesh type shape to this physics body. Mesh shapes cannot be physically simulated!

Vertices of the mesh. Indices of the mesh. The created shape, or null on failure.

Remove all physics shapes, but not the physics body itself.

Called from Shape.Remove()

Meant to be only used on dynamic bodies, rebuilds mass from all shapes of this body based on their volume and physics properties, for cases where they may have changed.

Completely removes this physics body.

Applies instant linear impulse (i.e. a bullet impact) to this body at its center of mass. For continuous force (i.e. a moving car), use

Applies instant linear impulse (i.e. a bullet impact) to this body at given position. For continuous force (i.e. a moving car), use

Applies instant angular impulse (i.e. a bullet impact) to this body. For continuous force (i.e. a moving car), use

Applies force to this body at the center of mass. This force will only be applied on the next physics frame and is scaled with physics timestep.

Applies force to this body at given position. This force will only be applied on the next physics frame and is scaled with physics timestep.

Applies angular velocity to this body. This force will only be applied on the next physics frame and is scaled with physics timestep.

Clear accumulated linear forces ( and ) during this physics frame that were not yet applied to the physics body.

Clear accumulated torque (angular force, ) during this physics frame that were not yet applied to the physics body.

Returns the world space velocity of a point of the object. This is useful for objects rotating around their own axis/origin.

The point to test, in world coordinates. Velocity at the given point.

Whether this body is enabled or not. Disables collisions, physics simulation, touch events, trace queries, etc.

Controls physics simulation on this body.

Physics bodies automatically go to sleep after a certain amount of time of inactivity to save on performance. You can use this to wake the body up, or prematurely send it to sleep.

If enabled, this physics body will move slightly ahead each frame based on its velocities.

The physics body we are attached to, if any

A convenience property, returns Parent, or if there is no parent, returns itself.

The physics group we belong to.

Returns the closest point to the given one between all shapes of this body.

Input position. The closest possible position on the surface of the physics body to the given position.

Generic linear damping, i.e. how much the physics body will slow down on its own.

Generic angular damping, i.e. how much the physics body will slow down on its own.

The diagonal elements of the local inertia tensor matrix.

The orientation of the principal axes of local inertia tensor matrix.

Sets the inertia tensor using the given moments and rotation.

Principal moments (Ixx, Iyy, Izz). Rotation of the principal axes.

Resets the inertia tensor to its calculated values.

Returns Axis-Aligned Bounding Box (AABB) of this physics body.

Returns average of densities for all physics shapes of this body. This is based on of each shape.

Time since last water splash effect. Used internally.

Sets on all child PhysicsShapes.

The most commonly occurring surface name between all PhysicsShapes of this PhysicsBody.

Convenience function that returns a from a position relative to this body.

Convenience function that returns a for this body from a world space position.

Returns a at the center of mass of this body.

What is this body called in the group?

Return the index of this body in its PhysicsGroup

Checks if another body overlaps us, ignoring all collision rules

Checks if another body overlaps us at a given transform, ignoring all collision rules

Checks if there's any contact points with another body

Checks if there's any contact points with another shape

Add a shape from a physics hull

Add a shape from a mesh hull

Transform, on previous step

Transform on current step

Called on each active body after a "step"

When the physics world is run at a fixed timestep, getting the positions of bodies will not be smooth. You can use this function to get the lerped position between steps, to make things super awesome.

Move body to this position in a way that cooperates with the physics system. This is quite good for things like grabbing and moving objects.

Rotate the body to this position in a way that cooperates with the physics system.

Called when anything significant changed about this physics object. Like its position, or its enabled status.

Represents a set of PhysicsBody objects. Think ragdoll.

The world in which this group belongs

Returns position of the first physics body of this group, or zero vector if it has none.

TODO: How useful is this in its current form? Should it be removed, or at least renamed to Position?

Returns the center of mass for this group of physics bodies.

Adds given amount of velocity () to all physics bodies in this group.

How much linear force to add?

Adds given amount of angular velocity to all physics bodies in this group.

How much angular force to add?

Adds given amount of linear impulse () to all physics bodies in this group.

Velocity to apply. Whether to multiply the velocity by mass of the on a per-body basis.

Adds given amount of angular linear impulse () to all physics bodies in this group.

Angular velocity to apply. Whether to multiply the velocity by mass of the on a per-body basis.

Sets on all bodies of this group.

Physics bodies automatically go to sleep after a certain amount of time of inactivity to save on performance. You can use this to wake the body up, or prematurely send it to sleep.

Calls on all bodies of this group.

The total mass of all the dynamic PhysicsBodies in this group. When setting the total mass, it will be set on each body proportionally to each of their old masses, i.e. if a body had 25% of previous total mass, it will have 25% of new total mass.

Sets on all bodies in this group.

Returns all physics bodies that belong to this physics group.

Returns amount of physics bodies that belong to this physics group.

Gets a at given index within this physics group. See .

Index for the body to look up, in range from 0 to .

Returns a by its within this group.

Name of the physics body to look up. The physics body, or null if body with given name is not found.

Any and all joints that are attached to any body in this group.

Sets the physical properties of each PhysicsShape of this group.

Delete this group, and all of its bodies

Represents a basic, convex shape. A PhysicsBody consists of one or more of these.

The physics body we belong to.

The bone index that this physics shape represents

The collider object that created / owns this shape

This is a trigger (!)

Set the local velocity of the surface so things can slide along it, like a conveyor belt

Enable contact, trace and touch

Disable contact, trace and touch

Controls whether this shape has solid collisions.

Controls whether this shape can fire touch events for its owning entity. (Entity.StartTouch, Touch and EndTouch)

Controls whether this shape can fire continuous touch events for its owning entity (i.e. calling Entity.Touch every frame)

Is this a MeshShape

Is this a HullShape

Is this a SphereShape

Is this a CapsuleShape

Is this a HeightfieldShape

Get sphere properties if we're a sphere type

Get capsule properties if we're a capsule type

Recreate the collision mesh (Only if this physics shape is type Capsule)

Recreate the collision mesh (Only if this physics shape is type Hull)

Recreate the collision mesh (Only if this physics shape is type Mesh)

Recreate the mesh of the shape (Only if this physics shape is type Mesh)

Recreate the hull of the shape (Only if this physics shape is type Hull)

Controls physical properties of this shape.

Multiple surfaces referenced by mesh or heightfield collision.

Remove this shape. After calling this the shape should be considered released and not used again.

Triangulate this shape.

The friction value

Called when anything significant changed about this physics object. Like its position, or its enabled status.

Does this shape have a specific tag?

Add a tag to this shape.

Remove a tag from this shape.

Clear all tags from this shape.

Do not expose! We want to force this whole thing into as tight of a box as possible!

Casts a sphere from point A to point B.

Casts a sphere from a given position and direction, up to a given distance.

Casts a box from point A to point B.

Casts a box from a given position and direction, up to a given distance.

Casts a box from point A to point B.

Casts a box from a given position and direction, up to a given distance.

Casts a capsule

Casts a capsule from point A to point B.

Casts a capsule from a given position and direction, up to a given distance.

Casts a cylinder

Casts a cylinder from point A to point B.

Casts a cylinder from a given position and direction, up to a given distance.

Casts a ray from point A to point B.

Casts a ray from a given position and direction, up to a given distance.

Casts a PhysicsBody from its current position and rotation to desired end point.

Casts a PhysicsBody from a position and rotation to desired end point.

Creates a Trace.Sweep using the PhysicsBody's position as the starting position.

Sets the start and end positions of the trace request

Sets the start transform and end position of the trace request

Sets the start rotation of the trace request

Include triggers in the trace

Only hit triggers

Ignore static objects in the trace

Ignore dynamic objects in the trace

Ignore keyframed objects in the trace

Compute hit position.

Makes this trace an axis aligned box of given size. Extracts mins and maxs from the Bounding Box.

Makes this trace an axis aligned box of given size. Calculates mins and maxs by assuming given size is (maxs-mins) and the center is in the middle.

Makes this trace an axis aligned box of given size.

Makes this trace a sphere of given radius.

Run the trace and return the result. The result will return the first hit.

Run the trace and return all hits as a result.

Traces only against the given capsule at the specified transform.

The capsule to test against. Transform applied to the capsule. The trace result.

Traces only against the given sphere at the specified transform.

The sphere to test against. Transform applied to the sphere. The trace result.

Traces only against the given bounding box at the specified transform.

The bounding box to test against. Transform applied to the box. The trace result.

Only return entities with this tag. Subsequent calls to this will add multiple requirements and they'll all have to be met (ie, the entity will need all tags).

Only return with all of these tags

Only return entities with any of these tags

Only return entities with any of these tags (using ints)

Only return with any of these tags

Only return without this tag

Only return without any of these tags

Use the collision rules of the given tag.

Which tag this trace will adopt the collision rules of. If true, trace against triggers only. Otherwise, trace for collisions (default).

Use the collision rules for the given set of tags.

Which tags this trace will adopt the collision rules of. If true, trace against triggers only. Otherwise, trace for collisions (default).

Whether the trace hit something or not

Whether the trace started in a solid

The start position of the trace

The end or hit position of the trace

The hit position of the trace

The hit surface normal (direction vector)

A fraction [0..1] of where the trace hit between the start and the original end positions

The physics object that was hit, if any

The physics shape that was hit, if any

The physical properties of the hit surface

The id of the hit bone (either from hitbox or physics shape)

The direction of the trace ray

The triangle index hit, if we hit a mesh physics shape

The tags that the hit shape had

The distance between start and end positions.

Physics simulation mode. For use with .

Discrete collision detection. In this mode physics bodies can fly through thin walls when moving very quickly, but it is has better performance.

Continuous collision detection. This is the default mode.

A world in which physics objects exist. You can create your own world but you really don't need to. A world for the map is created clientside and serverside automatically.

All bodies in the world

Set or retrieve the collision rules for this .

Create a new physics world. You should only do this if you want to simulate an extra world for some reason.

Temp function for creating model physics until entity system handles it

Delete this world and all objects inside. Will throw an exception if you try to delete a world that you didn't manually create.

Step simulation of this physics world. You can only do this on physics worlds that you manually create.

Access the world's current gravity.

Air density of this physics world, for things like air drag.

The body of this physics world.

The physics group of this physics world. A physics world will contain only 1 body.

If true then bodies will be able to sleep after a period of inactivity

Physics simulation mode. See for explanation of each mode.

Used internally to set collision rules from gamemode's project settings. You shouldn't need to call this yourself.

Gets the specific collision rule for a pair of tags.

Raytrace against this world

Like calling PhysicsTraceBuilder.Run, except will re-target this world if it's not already the target

Like calling PhysicsTraceBuilder.RunAll, except will re-target this world if it's not already the target

A SceneWorld where debug SceneObjects exist.

Updates all the SceneObjects in the , call once per tick or frame.

Project configuration data is derived from this class

Called after deserialization, and before serialization. A place to error check and make sure everything is fine.

A class that holds all configured input settings for a game. This is serialized as a config and shared from the server to the client.

A list of actions used by the game.

A class that holds all configured networking settings for a game. This is serialized as a config and shared from the server to the client.

Whether to disband the game lobby when the host leaves.

Whether to periodically switch to the best host candidate. Candidates are scored based on their average ping and connection quality to all other peers.

By default, can clients create objects. This can be changed per connection after join.

By default, can clients refresh objects. This can be changed per connection after join.

By default, can clients destroy objects. This can be changed per connection after join.

The frequency at which the network system will send updates to clients. Higher is better but you probably want to stay in the 10-60 range.

Get the from the active project settings.

Reset any stored references to Project Settings.

Gets or creates a default version of this config data. You can safely call this multiple times and it will return the same object. The cache is cleared automatically when the project changes, or when it's hotloaded.

Represents an on-disk project.

Whether the project's code has a compiler assigned.

These package types should reference package.base

If required, create the editor compiler

Find a project from a compiler

Loads precompiled assemblies that might exist (menu) as long as we're not in editor or headless or anything

If this is a single asset project, this will be the asset object

Absolute path to the .addon file

Root directory of this project

True if this project is active

True if this project is pinned, we'll prioritise it when sorting

When did the user last open this project?

True if this project failed to load properly for some reason

Returns true if this project has previously been published. This is kind of a guess though because all it does is look to see if we have a published package cached with the same ident.

The URL to the package's page for editing

The URL to the package's page for viewing/linking

Configuration of the project.

If true this project isn't a 'real' project. It's likely a temporary project created with the intention to configure and publish a single asset.

Called when the project is about to save

A filesystem into which compiled assemblies are written

Absolute path to the location of the .sbproj file of the project.

Gets the .sbproj file for this project

Absolute path to the Code folder of the project.

Returns true if the Code path exists

Absolute path to the Editor folder of the project.

Returns true if the Editor path exists

Absolute path to the Assets folder of the project, or if not set.

Absolute path to the Localization folder of the project, or if not set.

Returns true if the Assets path exists

The package for this project. This is a mock up of the actual package.

Return true if this project type uploads all the source files when it's published

Current open project.

Remove all local packages. Used by unit tests to reset state.

Check whether the group needs recompiling, and recompiles

Initializes all the base projects

Takes all of the active projects and makes sure we're in sync with the package manager. Creates mock packages that act like real ones. Removes packages that are no longer active. If nothing changed then this should do nothing.

(Re)generate the active project's solution file.

Writes a .vscode workspace configuration

Like AddFromFile but the project is marked as "built in" - which means it's always automatically loaded and can't be unloaded.

Resolve an assemblt to a compiler using the assembly name

Add references to non-package assemblies needed by tools / editor packages.

Add references to package assemblies needed by editor packages. Includes toolbase and tools like shadergraph.

Add Microsoft.AspNetCore.Components and Microsoft.AspNetCore.Components.Rendering as global using statements.

Add Sandbox.Internal.GlobalToolsNamespace as a global static statement.

Add Sandbox.Internal.GlobalGameNamespace as a global static statement.

The duration of the currently playing sequence (seconds)

Get whether the current animation sequence has finished

The name of the currently playing animation sequence

The normalized (between 0 and 1) elapsed time of the currently playing animation sequence

The elapsed time of the currently playing animation sequence (seconds)

Get or set whether the current animation sequence is looping

Get or set whether animations blend smoothly when transitioning between sequences.

The list of sequences that can be used

For communicating with a Direct Playback Anim Node, which allows code to tell it to play a given sequence

Set the time at which the currently playing sequence should have had a cycle of zero. This will adjust the current cycle of the sequence to match.

Get the cycle of the currently playing sequence. Will return 0 if no sequence is playing.

The duration of the currently playing sequence (seconds)

The elapsed time of the currently playing animation sequence (seconds)

Returns the currently playing sequence.

Get the number of animations that can be used.

Get the list of animations that can be used.

Get the list of sequences that can be used.

Play the given sequence until it ends, then blend back. Calling this function with a new sequence while another one is playing will immediately start blending from the old one to the new one.

Same as the other Play function, but also sets a target position and heading for the sequence. Over interpTime seconds, the entity's root motion will be augmented to move it to target and rotate it to heading.

Stop playing the override sequence.

Provides methods for reading GPU data asynchronously without blocking the render thread.

Handles the management of callbacks and memory for reading textures and buffers from GPU memory. Data retrieved through these methods is only valid during the callback execution.

Reads texture data from GPU memory, data is kept valid until after the callback task is finished. If srcRect is not specified, the entire texture will be read.

Called by native to dispatch the managed callback for texture read operations.

Called by native to dispatch the managed callback for buffer read operations.

Blend modes used by the UI system

Camera setup for rendering a View.

Structured Buffer (HLSL RWStructuredBuffer)

Byte Address Buffer (HLSL RWByteAddressBuffer)

Append Structured Buffer (HLSL AppendStructuredBuffer)

Indirect argument buffer for indirect draws

A compute shader is a program that runs on the GPU, often with data provided to/from the CPU by means of a or a .

Attributes that are passed to the compute shader on dispatch.

Create a compute shader from the specified path.

Dispatch this compute shader using explicit thread counts.

The specified thread counts will be automatically divided by the thread group size defined in the shader to compute the final dispatch group count. When called outside a graphics context, the dispatch runs immediately. When called inside a graphics context, the dispatch runs async. The number of threads to dispatch in the X dimension. The number of threads to dispatch in the Y dimension. The number of threads to dispatch in the Z dimension.

Dispatch this compute shader by reading thread group counts (x, y, z) from an indirect buffer of type .

must be created with and have an element size of 12 bytes. is an element index into , not a byte offset. When called outside a graphics context, the dispatch runs immediately. When called inside a graphics context, the dispatch runs async. The GPU buffer containing one or more dispatch argument entries. The index of the dispatch arguments element to use (each element = 12 bytes).

Provides functionality for rendering and filtering cubemap textures. Used for environment mapping and image-based lighting in PBR rendering.

Specifies the quality level for GGX filtering of environment maps.

Faster filtering with lower sample count.

Higher quality filtering with more samples.

Renders a cubemap from a scene at the specified transform position and applies filtering.

The scene world to render. The texture to render the cubemap to. The position and rotation of the cubemap camera. The near plane distance for the camera. The far plane distance for the camera. The quality level for GGX filtering.

Applies filtering to a cubemap texture, generating both downsample and GGX filtering.

The cubemap texture to filter. The quality level for GGX filtering. Thrown when the cubemap texture doesn't meet requirements.

Downsamples a cubemap texture to generate its mip chain.

The cubemap texture to downsample.

Applies GGX filtering to a cubemap texture for image-based lighting. This generates the pre-filtered environment map used in PBR workflows.

The cubemap texture to filter. The quality level for GGX filtering.

Calculates the sum of squares of powers of two up to n. Formula: 1² + 2² + 4² + 8² + ... + (2^k)² where 2^k ≤ n Used for determining compute shader dispatch dimensions.

The upper limit for powers of two. The sum of squares of powers of two up to n.

A GPU data buffer intended for use with a . You can read and write arbitrary data to and from the CPU and GPU. This allows for efficient parallel data processing on the GPU. Different GPU buffer types can be used depending on the provided . Using the default type buffers map to StructuredBuffer<T> and RWStructuredBuffer<T> in HLSL.

This example shows how to use the GpuBuffer class to send data to a compute shader:


             struct MyData
             {
                 public float Value;
             }
             
             // Allocate the GPU buffer
             using (var buffer = new GpuBuffer<MyData>( 2 ))
             {
            		// Upload data to the GPU buffer
            		var data = new MyData[] { new MyData { Value = 1.0f }, new MyData { Value = 2.0f } };
            		buffer.SetData( data );
             
                 // Pass the buffer to a compute shader
                 ComputeShader.Attributes.Set( "myData", buffer );
                 
                 // Dispatch the shader
                 ComputeShader.Dispatch();
             }

This example shows how to retrieve data from a GPU using the GpuBuffer class:


             struct MyData
             {
                 public float Value;
             }
             
             using (var buffer = new GpuBuffer<MyData>( 8 ))
             {
                 // Pass the buffer to a compute shader
                 ComputeShader.Attributes.Set( "myData", buffer );
                 
                 // Dispatch the shader
                 ComputeShader.Dispatch();
                 
            		// Retrieve the data from the GPU
            		var data = new MyData[ 8 ];
            		buffer.GetData( data, 0, 8 );
             }

Number of elements in the buffer.

Size of a single element in the buffer.

What sort of buffer this is

Creates a new GPU buffer with a specified number of elements and a specific buffer type.

The total number of elements that the GpuBuffer can hold. This represents the buffer's size in terms of elements, not bytes. The total number of elements that the GpuBuffer can hold. This represents the buffer's size in terms of elements, not bytes. Defines the usage pattern of the GPU buffer. This can affect performance depending on how the buffer is utilized. Test

Destroys the GPU buffer, don't use it no more

Retrieves the GPU buffer and copies them into a provided Span.

This operation is synchronous and will block until the data has been fully downloaded from the GPU. A Span of type T which the GPU buffer's contents will be copied into.

Retrieves a number of elements from the GPU buffer and copies them into a provided Span.

This operation is synchronous and will block until the specified range of data has been fully downloaded from the GPU. A Span of type T which the GPU buffer's contents will be copied into. The starting index from which to begin retrieving data. This index is in terms of elements, not bytes. The number of elements to retrieve from the GPU buffer. This count is also in terms of elements, not bytes.

Asynchronously retrieves data from the GPU buffer and provides it to the callback.

Asynchronously retrieves a number of elements from the GPU buffer and provides it to the callback.

This operation is asynchronous and won't block the calling thread while data is downloaded from the GPU. The data span is only valid during the callback execution. The type of data to retrieve. Callback that receives the data when the read operation completes. The starting index from which to begin retrieving data. This index is in terms of elements, not bytes. The number of elements to retrieve from the GPU buffer. This count is also in terms of elements, not bytes.

Synchronously uploads data from a Span to the GPU, replacing the existing data in this GpuBuffer.

This operation is synchronous; it will block until the data has been fully uploaded to the GPU. The Span of data to upload. It should contain items of type T, which is a struct. The offset in terms of elements (not bytes) at which to start uploading data (default is 0).

Synchronously uploads data from a List to the GPU, replacing the existing data in this GpuBuffer.

This operation is synchronous; it will block until the data has been fully uploaded to the GPU. The List of data to upload. It should contain items of type T, which is a struct. The offset in terms of elements (not bytes) at which to start uploading data (default is 0).

For buffers there is a hidden uint 32-bit atomic counter in the buffer that contains the number of writes to the buffer after invocation of the compute shader. In order to get the value of the counter, the data needs to be copied to another GPU buffer that can be used.

Fills the entire buffer with a repeated uint32 value. Uses the native GPU fill command (vkCmdFillBuffer) — no CPU-side allocation needed.

The uint32 value to fill with. Defaults to zero.

Sets the counter value for or structured buffers.

You can combine these e.g UsageFlags.Index | UsageFlags.ByteAddress for a buffer that can be used as an index buffer and in a compute shader.

Can be used as a vertex buffer.

Can be used as an index buffer.

Byte Address Buffer (HLSL RWByteAddressBuffer)

Structured Buffer (HLSL RWStructuredBuffer)

Append Structured Buffer (HLSL AppendStructuredBuffer)

Indirect argument buffer for indirect draws

Number of vertices to draw per instance.

Number of instances to draw.

Index of the first vertex to draw.

Instance ID of the first instance.

Number of indices to draw per instance.

Number of instances to draw.

Index of the first index to draw.

Value added to each index before indexing into the vertex buffer.

Instance ID of the first instance.

A typed GpuBuffer

The type of data that the GpuBuffer will store. Must be a blittable value type.

Used to render to the screen using your Graphics Card, or whatever you kids are using in your crazy future computers. Whatever it is I'm sure it isn't fungible and everyone has free money and no-one has to ever work.

If true then we're currently rendering and you are safe to use the contents of this class

The current layer type. This is useful to tell whether you're meant to be drawing opaque, transparent or shadow. You mainly don't need to think about this, but when you do, it's here.

When Frame grabbing, we store the result in this pooled render target. It stays checked out until the end of this render scope.

In pixel size, where are we rendering to?

Access to the current render context's attributes. These will be used to set attributes in materials/shaders. This is cleared at the end of the render block.

Access to the current frame's attributes. These will live until the end of the frame.

The camera transform of the currently rendering view

The camera position of the currently rendering view

The camera rotation of the currently rendering view

The field of view of the currently rendering camera view, in degrees.

The frustum of the currently rendering camera view.

Creates a scope where Graphics is safe to use.

Setup the lighting attributes for this current object. Place them in the targetAttributes

Grabs the current viewport's color texture and stores it in targetName on renderAttributes.

Grabs the current depth texture and stores it in targetName on renderAttributes.

Get or set the current render target. Setting this will bind the render target and change the viewport to match it.

Clear the current drawing context to given color.

Color to clear to. Whether to clear the color buffer at all. Whether to clear the depth buffer. Whether to clear the stencil buffer.

Clear the current drawing context to given color.

Whether to clear the color buffer to transparent color. Whether to clear the depth buffer.

Render this camera to the specified texture target

Copies pixel data from one texture to another on the GPU. This does not automatically resize or scale the texture, format and size should be equal.

Copies pixel data from one texture to another on the GPU. This does not automatically resize or scale the texture, format and size should be equal. This one lets you copy to/from arrays / specific mips.

Forces the GPU to flush all pending commands and wait for completion. Useful when you need to ensure GPU work is finished before proceeding. Can be called outside of a render block.

Draws geometry using a vertex buffer and material.

Draws indexed geometry using vertex and index buffers.

This is our entry point into the engine for all draws

Draw a bunch of vertices

Draw a bunch of vertices TODO: make this public TODO: Is this safe to be public TODO: Is VertexLayoutManager.Get Safe

Draw a bunch of vertices

Draw a bunch of vertices TODO: make this public TODO: Is this safe to be public TODO: Is VertexLayoutManager.Get Safe

Draw a bunch of vertices

Draw a screen space quad using the passed material. Your material should be using a screenspace shader so it will actually render to the screen and not in worldspace at 0,0,0

Render a SceneObject

Draw a quad in screenspace

Draw a rotated quad in screenspace

Draws a text quad in screenspace using the Material.UI.Text material.

Draws a rotated text quad in screenspace using the Material.UI.Text material.

Draws a text quad in screenspace using the Material.UI.Text material.

Measure how big some text will be, without having to render it

Calls DrawText with "Material Icons" font. You can get a list of icons here https://fonts.google.com/icons?selected=Material+Icons

Draw a rounded rectangle, with optional border, in Material.UI.Box

Draws a single model at the given Transform immediately.

The model to draw Transform to draw the model at Optional attributes to apply only for this draw call

The model to draw Instance transform data to draw Optional attributes to apply only for this draw call

The model to draw The GPU buffer containing the DrawIndirectArguments Optional offset in the GPU buffer Optional attributes to apply only for this draw call

The model to draw The number of instances to draw Optional attributes to apply only for this draw call

Called by the engine during pipeline. This could be rendering the scene from any camera. That means you can't assume this is the game view. This might be a tools view, or another view

Which method to use when downsampling a texture

Uses a box filter to downsample the texture

Uses a gaussian filter to downsample the texture

Uses a gaussian filter to downsample the texture, applies border to not oversample edges

Downsamples the texture using a max operator filter ( brightest pixel )

Downsamples the texture using a min operator filter ( darkest pixel )

Downsamples the texture in red and green channels using a Min/Max filter ( darkest and brightest pixel )

Generate the mip maps for this texture. Obviously the texture needs to support mip maps.

Executes a barrier transition for the given GPU Texture Resource. Transitions the texture resource to a new pipeline stage and access state.

The texture to transition. The new resource state for the texture. The mip level to transition (-1 for all mips).

Executes a barrier transition for the given GPU Buffer Resource. Transitions the buffer resource to a new pipeline stage and access state.

The unmanaged type of the buffer elements. The GPU buffer to transition. The new resource state for the buffer.

Executes a barrier transition for the given GPU Buffer Resource. Transitions the buffer resource to a new pipeline stage and access state.

The GPU buffer to transition. The new resource state for the buffer.

Executes a barrier transition for the given GPU Buffer Resource. Transitions the buffer resource from a known source state to a specified destination state.

The unmanaged type of the buffer elements. The GPU buffer to transition. The current resource state of the buffer. The desired resource state of the buffer after the transition.

Executes a barrier transition for the given GPU Buffer Resource. Transitions the buffer resource from a known source state to a specified destination state.

The GPU buffer to transition. The current resource state of the buffer. The desired resource state of the buffer after the transition.

Issues a UAV barrier for the given texture, ensuring writes from prior shader invocations are visible to subsequent ones without changing the resource layout.

The texture to barrier.

Issues a UAV barrier for the given GPU buffer, ensuring writes from prior shader invocations are visible to subsequent ones.

The buffer to barrier.

Figure out what flags Vulkan needs for the given ResourceState

Used to access and manipulate morphs.

Reset all morphs to their default values.

Reset morph number i to its default value.

Reset named morph to its default value.

Set indexed morph to this value.

Set named morph to this value.

Set indexed morph to this value.

Set named morph to this value.

Get indexed morph value (Note: Currently, this only gets the override morph value)

Get named morph value (Note: Currently, this only gets the override morph value)

Retrieve name of a morph at given index.

Amount of morphs.

Enables music playback. Use this for music, not for playing game sounds.

We only use the audio component of the video player.

Sample rate of the audio being played.

Number of channels of the audio being played.

Gets the total duration of the video in seconds.

Gets the current playback time in seconds.

Invoked when the audio has finished playing.

Invoked when the audio has repeated.

Place the listener at 0,0,0 facing 1,0,0.

Position of the sound.

Pause playback of audio.

Audio will repeat when reaching the end.

Change the volume of this music.

Enables lipsync processing.

Which mixer do we want to write to

A list of 15 lipsync viseme weights. Requires to be enabled.

Get title of the track.

512 FFT magnitudes used for audio visualization.

Approximate measure of audio loudness.

Plays a music stream from a URL.

Plays a music file from a relative path.

Stops audio playback.

Sets the playback position to a specified time in the audio, given in seconds.

Get meta data string.

Utility methods for screen recording and screenshot functionality

Generates a suitable screenshot filename with timestamp

Records the screen to a video file.

Gets whether a recording is currently in progress.

Starts recording to the specified file.

True if recording started successfully

Stops the current recording.

Captures a video frame from the provided render context and view.

Captures an audio frame from the provided audio buffers.

Provides functionality to capture and save screenshots in various formats.

Captures the screen and saves it as a PNG file.

Captures the current render target and saves it to the specified file.

Enables video playback and access to the video texture and audio.

Video successfully loaded.

Event that is invoked when the audio stream is created and ready to use.

Video finished playing.

Video started playing again after looping.

If this event is set, texture data will be provided instead of rendering to the texture.

Sets whether the video should loop when it reaches the end.

Gets the total duration of the video in seconds.

Gets the current playback time in seconds.

Audio sample rate.

Number of audio channels.

Does the loaded video have audio?

Has the video been paused?

Texture of the video frame.

Width of the video.

Height of the video.

Access audio properties for this video playback.

Place the listener at 0,0,0 facing 1,0,0.

Position of the sound.

Which mixer do we want to write to

Volume of the sound.

Enables lipsync processing.

A list of 15 lipsync viseme weights. Requires to be enabled.

Get meta data string.

Plays a video file from a URL. If there's already a video playing, it will stop.

Plays a video file from a relative path. If there's already a video playing, it will stop.

Resumes video playback.

Stops video playback.

Pauses video playback.

Toggle video playback

Sets the playback position to a specified time in the video, given in seconds.

Present a video frame.

The video is muted

Allows the creation of video content by encoding a sequence of frames.

Can this container support the codec.

Obsolete: H.264 is no longer supported, if used will map to AV1 instead.

Obsolete: H.265 is no longer supported, if used will map to AV1 instead.

Obsolete: VP8 is no longer supported, if used will map to VP9 instead.

VP9 codec (supports transparency)

WebP codec (supports transparency)

AV1 codec — excellent compression, slower encoding.

Controls the speed/quality tradeoff of video encoding.

Optimized for speed. Suitable for real-time recording.

Balanced speed and quality.

Optimized for quality. Suitable for offline export.

Audio codec to use for encoding.

Opus — high quality, open codec.

MP4 container (does not support transparency)

WebM container (supports transparency)

WebP container (supports transparency)

Dispose this recorder, the encoder will be flushed and video finalized.

Finish creating this video. The encoder will be flushed and video finalized.

Add a frame of data to be encoded. Timestamp is in microseconds. If a timestamp is not specified, it will use an incremented frame count as the timestamp.

The frame data to be encoded. The timestamp for the frame in microseconds. If not specified, an incremented frame count will be used.

Add a frame of data to be encoded. Timestamp is in microseconds. If a timestamp is not specified, it will use an incremented frame count as the timestamp.

The frame data to be encoded. The timestamp for the frame in microseconds. If not specified, an incremented frame count will be used.

Internal for now as I have no idea, how to expose audio recording in a good way yet.

Represents a ray tracing acceleration structure that contains geometry for efficient ray intersection testing. This is used to organize scene geometry in a hierarchical structure optimized for ray tracing performance.

Gets whether this acceleration structure is valid and can be used for ray tracing.

Create a ray tracing acceleration structure from native engine data.

Create a ray tracing acceleration structure from scene geometry.

The geometry data to build the acceleration structure from. A new acceleration structure, or null if creation failed.

Updates the acceleration structure with new geometry data. This is more efficient than rebuilding from scratch for dynamic geometry.

The updated geometry data.

Releases the native resources associated with this acceleration structure.

A ray tracing shader, enabling advanced rendering techniques like real-time ray tracing for reflections, global illumination, and shadows.

Attributes that are passed to the ray tracing shader on dispatch.

Create a ray tracing shader from the specified path.

Dispatches the ray tracing shader using explicit thread counts.

The specified thread counts represent the dispatch dimensions for the ray generation shader. When called outside a graphics context, the dispatch runs immediately. When called inside a graphics context, the dispatch runs async. Render attributes to use for this dispatch. The number of threads to dispatch in the X dimension. The number of threads to dispatch in the Y dimension. The number of threads to dispatch in the Z dimension.

Dispatches the ray tracing shader using the default attributes.

Dispatches the ray tracing shader by reading dispatch arguments from an indirect buffer.

must be created with and have an element size of 12 bytes (3 uint32 values for X, Y, Z dimensions). is an element index into , not a byte offset. When called outside a graphics context, the dispatch runs immediately. When called inside a graphics context, the dispatch runs async. The GPU buffer containing one or more dispatch argument entries. The index of the dispatch arguments element to use (each element = 12 bytes).

A thread-safe pool for reusing instances. Returning to the pool clears the instance but does not free its memory, allowing for efficient reuse. Uses ConcurrentQueue instead of ConcurrentBag to avoid ThreadLocal strong handle roots that survive even after Clear/null.

Get a pooled instance. Make sure you return it to the pool after use with .

Returns a instance to the pool for reuse. Make sure you're done with it because it will be cleared.

Dequeues all pooled instances and clears them, releasing native handles.

RenderAttributes are a set of values that are passed to the renderer. They can be a variety of primitive types, textures, samplers or buffers. You can access attributes in the shader by binding them to a variable:


            float4 CornerRadius < Attribute( "BorderRadius" ); >;
            Texture2D g_tColor 	< Attribute( "Texture" ); SrgbRead( false ); >;

Internal for a reason - don't expose!

Set a constant buffer to a specific value

Get a bool value - else defaultValue if missing

Get a vector3 value - else defaultValue if missing

Get a vector4 value - else defaultValue if missing

Get a float value - else defaultValue if missing

Get a int value - else defaultValue if missing

Get a matrix value - else defaultValue if missing

Get a texture value - else defaultValue if missing

Clear used textures, destroying any strong handles we've created. These handles are mainly used for storage RenderAttributes like SceneObject.Attributes

Essentially wraps a couple of textures that we're going to render to. The color texture and the depth texture.

Get a temporary render target. You should dispose the returned handle when you're done to return the textures to the pool.

Width of the render target you want. Height of the render target you want. The format for the color buffer. If set to default we'll use whatever the current pipeline is using. The format for the depth buffer. The number of msaa samples you'd like. Msaa render textures are a pain in the ass so you're probably gonna regret trying to use this. Number of mips you want in this texture. You probably don't want this unless you want to generate mips in a second pass. The optional name of the render target A RenderTarget that is ready to render to.

Get a temporary render target. You should dispose the returned handle when you're done to return the textures to the pool.

Divide the screen size by this factor. 2 would be half screen sized. 1 for full screen sized. The format for the color buffer. If null we'll choose the most appropriate for where you are in the pipeline. The format for the depth buffer. The number of msaa samples you'd like. Msaa render textures are a pain in the ass so you're probably gonna regret trying to use this. Number of mips you want in this texture. You probably don't want this unless you want to generate mips in a second pass. The optional name of the render target A RenderTarget that is ready to render to.

Called at the end of the frame. At this point none of the render targets that were loaned out should be being used, so we can put them all back in the pool.

Flush all the render targets out. Useful to do when screen size changes.

Destroy all cached render targets immediately. Called during shutdown to release native texture handles before the resource system tears down.

Is this currently loaned out (Active)

The amount of time since this texture was last used

The hash of the parameters used to create this

Width of the render target

Height of the render target

The target colour texture

The target depth texture

Stop using this texture, return it to the pool

Destroy this buffer. It shouldn't be used anymore after this.

Create a render target from these textures

Translucent pass. We're rendering translucent objects in depth sorted order, from back to front.

Rendering dynamic shadows

Translucent effects on the 1/4 texture

Opaque effects on the 1/4 texture

Depth prepass to reduce overdraw

Tries to get the best matching font for the given style. Will return a matching font family with the closest font weight and optionally slant.

Create a texture from the scope. The texture will either be a cached version or will be rendered immediately

Resolves or creates a fully initialized for the given scope. Safe to call from any thread. MakeReady() must still be called on the render thread before drawing.

Free old, unused textblocks (and their textures)

Defines a scope of text, all using the same style.

Measures the rendered size of the text in this using its current style settings. This is non trivial but the underlying style is cached, so if you end up drawing it, it'll re-use the cached data anyway.

A representing the width and height, in pixels, of the rendered text.

We'll expose this at some point, but will probably be as Sandbox.TextBlock - and then need to think about ownership and caching

Allows for the definition of custom vertex layouts

Should probably be calling this on hotload, when types are changed?

Indicates whether the fog system is enabled.

Level of anisotropy.

Scattering value.

Draw distance.

Start distance where fading begins.

End distance where fading concludes.

Strength of indirect illumination.

Provides indirect lighting from a baked volume texture. This gets compiled with your map and is provided by an env_volumetric_controller.

You shouldn't expect to be able to add new runtime fog volumes if using this.

Adjust how quickly the cubemap blurs out at closer distances. A value of 0.0 always uses the lowest resolution MIP over the entire range, while a value of 1.0 uses the highest.

The distance from the player at which the fog will start to fade in.

The distance from the player at which the fog will be at full strength.

Exponent for distance falloff. For example, 2.0 is proportional to square of distance.

The distance between the start of the height fog and where it is fully opaque. Setting this to 0 will disable height based blending.

The absolute height in the map at which the height fog will start to fade in.

Exponent for height falloff. For example, 2.0 is proportional to square of distance.

Is this cubemap fog active?

Cubemap texture to use for the fog.

Location of the fog.

Tint of the fog.

A decal. Use the Component.

Used for c++ to make callbacks to a camera and be able to find it by id

Called when entering a specific pipeline stage

Allocate a camera id for this camera. This is used to find the camera in the c++ code.

Find a camera by its id. This is used to find the camera by the calling c++ code. This is called in the render thread, so it's important to be thread-safe.

keep the directory clean by trimming all the old ones

A directional scene light that is used to mimic sun light in a . Direction is controlled by this object's .

Ambient light color outside of all light probes.

Control number of shadow cascades

Set the max distance of the shadow cascade

Base class for light scene objects for use with a .

Color and brightness of the light

Radius of the light in units

The light attenuation constant term

The light attenuation linear term

The light attenuation quadratic term

Get or set the resolution of the shadow map. If this is zero the engine will decide what it should use.

Enable or disable shadow rendering

Access the LightCookie - which is a texture that gets drawn over the light

Stupid fucking shit

A point light scene object for use in a .

A simple spot light scene object for use in a .

The inner cone of the spotlight, in half angle degrees.

The outer cone of the spotlight, in half angle degrees

Represents a camera and holds render hooks. This camera can be used to draw tool windows and scene panels.

Access tonemapping properties of camera

Enable or disable exposure.

This is a c++ object with a ton of useful shit. Don't access it directly because it might be dirty.

The name of this camera.. for debugging purposes.

Scene objects with any of these tags won't be rendered by this camera.

Only scene objects with one of these tags will be rendered by this camera.

Keep hidden! CommandBuffers only!!

Called when rendering the post process pass

Called when rendering the transparent pass

The size of the screen. Allows us to work out aspect ratio. For now will get updated automatically on render.

Control volumetric fog parameters, expect this to take 1-2ms of your GPU frame time.

Control fog based on an image.

Define the rotations for each of the 6 cube faces (right, left, up, down, front, back)

The world we're going to render.

Your camera can render multiple worlds.

The position of the scene's camera.

The rotation of the scene's camera.

The horizontal field of view of the Camera in degrees.

The camera's zFar distance. This is the furthest distance this camera will be able to render. This value totally depends on the game you're making. Shorter the better, sensible ranges would be between about 1000 and 30000, but if you want it to be further out you can balance that out by making znear larger.

The camera's zNear distance. This is the closest distance this camera will be able to render. A good value for this is about 5. Below 5 and particularly below 1 you're going to start to see a lot of artifacts like z-fighting.

Whether to use orthographic projection.

Height of the ortho when is enabled.

Render this camera using a different render mode

Render this camera using a wireframe view.

What kind of clearing should we do before we begin?

The rect of the screen to render to. This is normalized, between 0 and 1.

Color the scene camera clears the render target to.

The color of the ambient light. Set it to black for no ambient light, alpha is used for lerping between IBL and constant color.

Enable or disable anti-aliasing for this render.

Toggle all post processing effects for this camera. The default is on.

Should this camera render engine overlays, you'd only want this on the main camera.

When true, rendering from this camera won't request higher mip levels from the texture streaming system. Used by cubemap rendering to prevent envmap probes from pulling in full-resolution textures across the entire map.

The camera currently used for video/screenshot recording.

The HMD eye that this camera is targeting. Use for the user's monitor (i.e. the companion window).

Set this to false if you don't want the stereo renderer to submit this camera's texture to the compositor. This option isn't considered if is .

Enable or disable direct lighting

Enable or disable indirect lighting

Should be called before a render

Configure the view immediately before rendering. This will set the camera position etc on the local camera renderer. This should be called immediately before adding the views etc.

Given a pixel rect return a frustum on the current camera.

Given a pixel rect return a frustum on the current camera. Pass in 1 to ScreenSize to use normalized screen coords.

Given a cursor position get a scene aiming ray.

Convert from world coords to screen coords. The results for x and y will be from 0 to .

Convert from world coords to normal screen corrds. The results will be between 0 and 1

Convert from world coords to screen coords but the Z component stores whether this vector is behind the screen (<0) or in front of it (>0). The X and Y components are normalized from 0 to 1.

Convert from screen coords to world coords on the near frustum plane.

Renders the scene from the camera position to a cube texture, capturing all 6 directions.

Allows specifying a custom projection matrix for this camera

Access tonemapping properties of camera

Flags for clearing a RT before rendering a scene using a SceneCamera

Enable or disable exposure.

The rate of change for exposure.

Set the speed at which exposure fades downwards (diminishes) in response to light changes.

Minimum auto exposure scale

Maximum auto exposure scale

Number of stops to adjust auto-exposure by

Set a custom brightness target to go along with 'Target Bright Pixel Percentage'. (-1 for default engine behavior)

Set a target for percentage of pixels above a certain brightness. (-1 for default engine behavior)

Set the minimum average luminance. This ensures that certain regions aren't too dim after tonemapping

Marks the cubemap as dirty, to be re-rendered on the next render.

A box which can be used to explicitly control scene visibility. There are two modes: 1. Cull inside, hide any objects fully inside the box (excluder) 2. Cull outside, hide any objects not intersecting any cull boxes marked cull outside (includer)

Cull mode, either inside or outside

Hide any objects fully inside the box

Hide any objects not intersecting any boxes

Is this culling box valid, exists inside a scene world.

The scene world this culling box belongs to.

Position and rotation of this box, scale will scale the box size

Size of this box, transform scale will scale this size

Cull mode, either inside or outside

Create a scene culling box. Each scene world can have a list of boxes which can be used to explicitly cull objects inside or outside the boxes.

Delete this culling box. You shouldn't access it anymore.

A scene object that allows custom rendering within a scene world.

Called by default version of .

Called when this scene object needs to be rendered. Invokes by default. See the library for a starting point.

Represents a volume of fog in a scene, contributing to volumetric fog effects set on .

The position and rotation of the fog volume in the scene.

Defines the spatial boundaries of the fog volume.

The intensity of the fog. Higher values indicate denser fog.

Controls how quickly the fog fades at the edges of the volume. Higher values give sharper transitions.

Delete this fog volume. You shouldn't access it anymore.

Keep this internal for now

A scene object which is used to draw lines

Number of tessellation subdivisions across the width of each line segment. 1 = no tessellation (just left and right), 2 = one subdivision in the middle, etc. Higher values create smoother curves and more detailed geometry but use more vertices.

Calculate the number of vertices needed for a specific cap type

Calculate the number of indices needed for a specific cap type

Internal property to mark this scene as being a system scene. It should only be set in .

If true, on load we'll even delete objects that are marked as DontDelete

Map geometry that can be rendered within a .

The scene world this map belongs to.

Is the map valid.

Bounds of the map.

cs_assault

maps/davej/cs_assault

Create a scene map within a scene world.

Invoked when a map file is updated (re-compiled in Hammer.)

Create scene map asynchronously for when large maps take time to load.

Delete this scene map. You shouldn't access it anymore.

A model scene object that supports animations and can be rendered within a .

Manually override the final bone transform.

Local coordinates based on the SceneModel's transform

Clears all bone transform overrides.

Whether any bone transforms have been overridden.

Calculates the velocity from the previous and current bone transforms.

Override the anim graph this scene model uses

Sets the world space bone transform of a bone by its index.

Bone index to set transform of.

Returns the world space transform of a bone by its index.

Index of the bone to calculate transform of. The world space transform, or an identity transform on failure.

Returns the world space transform of a bone by its name.

Name of the bone to calculate transform of. The world space transform, or an identity transform on failure.

Returns the local space transform of a bone by its index.

Index of the bone to calculate transform of. The local space transform, or an identity transform on failure.

Returns the local space transform of a bone by its name.

Name of the bone to calculate transform of. The local space transform, or an identity transform on failure.

Set material group to replace materials of the model as set up in ModelDoc.

Set which body group to use.

Get attachment transform by name.

Name of the attachment to calculate transform of. Whether the transform should be in world space (relative to the scene world), or local space (relative to the scene object)

Allows the scene model to not use the anim graph so it can play sequences directly

Get the calculated motion from animgraph since last frame

Allows playback of sequences directly, rather than using an animation graph. Requires disabled if the scene model has one.

Access this sceneobject's morph collection. Morphs are generally used in the model to control the face, for things like emotions and lip sync.

Access this sceneobject's direct playback. Direct playback is used to control the direct playback node in an animgraph to play sequences directly in code

Called when a footstep event happens

Called when a generic event happens

Called when a sound event happens

Called when a anim tag event happens

Enumeration that describes how the AnimGraph tag state changed. Used in .

Tag was activated and deactivated on the same frame

The tag has become active

The tag has become inactive

Sets a boolean animation graph parameter by name.

Sets a float animation graph parameter by name.

Sets a vector animation graph parameter by name.

Sets a integer animation graph parameter by name.

Sets a rotation animation graph parameter by name.

Reset all animgraph parameters to their default values.

Get an animated parameter

Update this animation. Delta is the time you want to advance, usually RealTime.Delta

Update all of the bones to the bind pose

Updates attachments, ao proxies etc Should be called any time the world transform change

Update our bones to match the target's bones. This is a manual bone merge.

Returns the parent space transform of a bone by its index.

Index of the bone to calculate transform of. The parent space transform, or an identity transform on failure.

A model scene object that can be rendered within a .

The scene world this object belongs to.

Delete this scene object. You shouldn't access it anymore.

Transform of this scene object, relative to its , or if parent is not set.

Rotation of this scene object, relative to its , or if parent is not set.

Position of this scene object, relative to its , or if parent is not set.

Set or get the axis aligned bounding box for this object.

Set the axis aligned bounding box by transforming by this objects transform.

Whether this scene object should render or not.

Color tint of this scene object.

Clipping plane for this scene object. Requires to be true.

Whether or not to use the clipping plane defined in .

Movement parent of this scene object, if any.

Add a named child scene object to this one. The child scene object will have its parent set.

The name can be used to look up children by name, but it is not bound. (SceneObject_FindChild)

Unlink given scene object as a child from this one. The child scene object will have its parent set to null. It will not be deleted.

The model this scene object will render.

State of all bodygroups of this object's model. You might be looking for .

Override current LOD level, -1 to disable.

Override all materials on this object's .

Clear all material replacements.

Replaces all materials of the model that have the given User Material Attribute set to "1", with given material. The system checks both the models' default material group materials and the materials of the active material group.

Material to replace with. Name of the User Material Attribute to test on each material of the model. They are set in the Material Editor's Attributes tab. Value of the attribute to test for.

Set material group to replace materials of the model as set up in ModelDoc.

This object is not batchable by material for some reason ( example: has dynamic attributes that affect rendering )

For storing and retrieving the GameObject this SceneObject belongs to

The component that created this object

Updates flags like transparent/opaque based on object's material, this is usually called automatically. But some procedural workflows (mesh editor) may want to call this manually.

Access to various advanced scene object flags.

Whether this scene object should cast shadows.

Don't render in the opaque/translucent game passes. This is useful when you want to only render in the Bloom layer, rather than additionally to it.

True if this object needs cubemap information

Automatically sets the "FrameBufferCopyTexture" attribute within the material. This does the same thing as Render.CopyFrameBuffer(); except automatically if the pass allows for it.

Draw this in cubemaps

For a layer to draw this object, the target layer must match (or be unset) and the flags must match

List of tags for this scene object.

SceneObjects can be rendered on layers other than the main game layer. This is useful if, for example, you want to render on top of everything without applying post processing.

Draw wherever makes sense based on the flags, default behaviour

Layer drawn on top of everything else - with altered depth

Overlay - after post processing - but still with the scene's depth

Overlay - after post processing - without depth (draw over)

Internally we don't pass these enums, they're just string tokens. No need to expose the actual string tokens to people unless we expose the render pipeline fully to them.

A SceneObject used to render particles. We need to be careful with what we do here, because this object is created for in-engine particles as well as custom scene object particles. With custom particles there's no automatic Simulate, or deletion.. You're completely on your own. This is perhaps a good thing though, it's maybe what you want to happen. To be completely isolated and completely in control. But at the same time maybe it's not and it's something we need to sort out.

Create scene particles.

The scene world to create the particles in. Path to the particle system file.

Create scene particles.

The scene world to create the particles in. Particle system resource.

Whether to render the particles or not.

Stop (or start) the particle system emission.

Particle collisions use this physics world to perform traces.

Whether given control point has any data set.

The control point index. Range is 0-63.

Returns the position set on a given control point.

The control point index. Range is 0-63.

Set position on given control point.

The control point index. Range is 0-63. The position to set.

Set rotation on given control point.

The control point index. Range is 0-63. The rotation to set.

Set transform on given control point.

The control point index. Range is 0-63. The transform to set.

Set snapshot on given control point.

The control point index. Range is 0-63. The snapshot to set.

Set model on given control point.

The control point index. Range is 0-63. The model to set.

Set vector on given named value.

The name of the key. The value to set.

Simulate the particles for given amount of time.

Amount of time has passed since last simulation.

The amount of particles

The amount of particles including child systems

The total allowed particle count

Manually emit a bunch of particles

True if particle system has reached the end

Get or set the simulation time

Renders a skybox within a .

The skybox material. Typically it should use the "Sky" shader.

Skybox color tint.

Controls the skybox specific fog.

Delete this fog volume. You shouldn't access it anymore.

I don't want to expose SceneObjects to people anymore. They should be using the scene system. It's better if we can keep things internal so we don't have the burden of supporting api layout.

Total maximum points we're allowing

Wait until we're this far away before adding a new point

Texture details, in a nice stuct to hide the bs

How long the trail lasts - or 0 for infinite

Try to add a position to this trail. Returns true on success.

Advance the time for this trail. Will fade out points and scoll the texture.

Build the vertices for this object. TODO: We can move this to build automatically in a thread

Defines how a trail is going to be textured. Used by TrailRenderer.

If true the texture will be clamped instead of repeating

A scene world that contains s. See Utility.CreateSceneWorld. You may also want a to manually render the scene world.

List of scene objects belonging to this scene world.

Controls gradient fog settings.

Sets the ambient lighting color

Sets the clear color, if nothing else is drawn, this is the color you will see

If a world is transient, it means it was created by game code, and should be deleted at the end of the game session. If they're non transient then they were created in the menu, or by the engine code and will be released properly by that code.

Delete this scene world. You shouldn't access it anymore.

Deleted objects are actually deleted at the end of each frame. Call this to actually delete pending deletes right now instead of waiting.

Flush all system-wide queued scene object and world deletes. Normally processed at end-of-frame by FinishRenderingViews, but during shutdown no frame runs so we must flush manually.

This finishes any loads and actually spawns the world sceneobjects

Add a scenemap to this world

Trace against all scene objects in this scene world

Don't render in stereo

Only render the left eye

Only render the right eye

Render both eyes in stereo

When true, any continuations that attempt to run on this instance will log an exception, unless whitelisted by .

If true, warn when tasks don't yield after .

Logs a warning if any actions posted to this sync context take too long before returning.

Returns true if is false, or if represents a task method that is allowed to persist after context expiry. Logs an error otherwise.

Current sync context for the main thread. This will be null until has been called for the first time.

Current sync context for worker threads. This will be null until has been called for the first time.

Sets both and to be a new instance of . Only has an effect the first time it's called.

Invalidates and , and replaces them with a new instance. Any tasks that try to continue on the old instances will log an error, unless they are whitelisted with .

Run an async task in a synchronous blocking manner.

Run an async task in a synchronous blocking manner and returns the result.

Create a scope that sets the current synchronization context to the provided context.

Starts a bunch of long-running tasks in the worker thread pool that keep calling on .

Thrown if tasks are already running.

Forces the tasks created by to cancel, to be restarted later. This doesn't cancel tasks created with Sandbox.TaskSource.RunInThreadAsync, they just get suspended until is called again.

Log an error if any tasks take longer than this to return.

Utility functions that revolve around the main thread

Wait to execute on the main thread

Run a function on the main thread and wait for the result.

When running in another thread you can queue a method to run in the main thread. If you are on the main thread we will execute the method immediately and return.

Run queued actions on the main thread

A generic .

Provides a way for us to cancel tasks after common async shit is executed.

Create a token source, which will also be cancelled when sessions end

Marks this task source as invalid. All associated running tasks will be canceled ASAP.

A task that does nothing for given amount of time in milliseconds.

Time to wait in milliseconds.

A task that does nothing for given amount of time in milliseconds.

Time to wait in milliseconds. Token to cancel the delay early.

Measured actual granularity of on this platform/OS configuration. Anything with more time remaining than this gets a single bulk ; the sub-granularity tail is polled per frame.

A task that does nothing for given amount of time in seconds.

>Time to wait in seconds.

A task that does nothing for given amount of time in seconds.

>Time to wait in seconds. Token to cancel the delay early.

Continues on the main thread.

Continues on a worker thread.

Wait until the start of the next frame

Wait until the end of the frame

Wait until the next fixed update

Represents a CSS @keyframes rule.

Name of the @keyframes rule.

A keyframe within the animation.

The position of the keyframe within the overall animation. 0 to 1, where 0 is the start, and 1 is the end of the animation.

The styles that should be applied at this position in the animation.

List of keyframes with in the @keyframes rule.

A panel that gets deleted automatically when clicked away from

Stay open, even when CloseAll popups is called

A generic box that displays a given texture within itself.

The texture being displayed by this panel.

Set from a file path. URLs supported.

Create an image with given texture and CSS classname.

Create a simple text label with given text and CSS classname.

Used for for quick panel creation with certain settings. Other panels types are added via extension methods.

The panel to add children to.

Add a new blank panel as a child.

The crated panel.

Add a new blank panel with given CSS classes as a child.

The crated panel.

A generic text label. Can be made editable.

Information about the on a per-element scale. It handles multi-character Unicode units (graphemes) correctly.

Can be selected

If true and the text starts with #, it will be treated as a language token.

The color used for text selection highlight

Text to display on the label.

Set to true if this is rich text. This means it can support some inline html elements.

Position of the text cursor/caret within the text, at which newly typed characters are inserted.

Amount of characters in the text of the text entry. Not bytes.

Ensure the text caret and selection are in sane positions, that is, not outside of the text bounds.

Returns the selected text.

When the language changes, if we're token based we need to update to the new phrase.

Enables multi-line support for editing purposes.

Replace the currently selected text with given text.

Sets the text selection.

Set the text caret position to the given index.

Where to move the text caret to within the text. Whether to also add the characters we passed by to the selection.

Put the caret within the visible region.

Move the text caret to the closest word start or end to the left of current position.
This simulates holding Control key while pressing left arrow key.

Whether to also add the characters we passed by to the selection.

Move the text caret to the closest word start or end to the right of current position.
This simulates holding Control key while pressing right arrow key.

Whether to also add the characters we passed by to the selection.

Move the text caret by given amount.

How many characters to the right to move. Negative values move left. Whether to also add the characters we passed by to the selection.

Insert given text at given position.

Text to insert. Position to insert the text at. If set, the end position in the current , which will be used to replace portion of the existing text with the given .

Remove given amount of characters from the label at given position.

Move the text caret to the start of the current line.

Whether to also add the characters we passed by to the selection.

Move the text caret to the end of the current line.

Whether to also add the characters we passed by to the selection.

Move the text caret to next or previous line.

How many lines to offset. Negative values move up. Whether to also add the characters we passed by to the selection.

Select a work at given word position.

Returns a list of positions in the text of each side of each word within the .
This is used for Control + Arrow Key navigation.

Returns true if the input string is a 1 or 2 (\r\n) character newline symbol.

Allows to render a scene world onto a panel.

Shortcut to Camera.World

The camera we're going to be using to render

If enabled, the scene will only render once. That isn't totally accurate though, because we'll also re-render the scene when the size of the panel changes.

The texture that the panel is rendering to internally. This will change to a different texture if the panel changes size, so I wouldn't hold onto this object.

The Scene this panel renders.

Creates and loads a Scene from a file to render to this panel.

Render the panel again next frame. This is meant to be used with RenderOnce, where you might want to render on demand or only once.

A generic panel that draws an SVG scaled to size

Content path to the SVG file

Optional color to draw the SVG with

A panel that displays an interactive web page.

Access to the HTML surface to change URL, etc.

The texture has changed

Some properties cascade from their parent onto children if the children don't set them. Things like font size, color, cursor.

Build a text descriptor into the target RenderLayer.

Called on layout. We should decide here if we actually need to rebuild

Actually recreate the texture

Left Mouse Button

Muddle Mouse Button

Right Mouse Button

Back Button

Forward Button

Keyboard (and mouse) key press .

The button that triggered the event.

Whether the button was pressed in, or release.

The keyboard modifier keys that were held down at the moment the event triggered.

Whether Shift key was being held down at the time of the event.

Whether Control key was being held down at the time of the event.

Whether Alt key was being held down at the time of the event.

Set to to prevent the event from propagating to the parent panel.

Queue input events on here to be processed by the UISystem.

Handles input focus for s.

The panel that currently has input focus.

The panel that will have the input focus next.

Set the focus to this panel (or its nearest ancestor with AcceptsFocus). Note that won't change until the next frame.

Clear focus away from this panel.

Clear keyboard focus

Panel we're currently hovered over

Panel we're currently pressing down

During a drag, the panel currently under the cursor (potential drop target)

Called from input when mouse wheel changes

The cursor should change. Name could be null, meaning default.

Then panel that is potentially being dragged

The point where we first pressed on the Active element

Simulates PanelInput for world space panels using a ray and inputs.

Regular expected behaviour.

Redirect to the game's Input system

This could be a local variable if we wanted to create a new class every time

Store the last active rules so we can compare them when they change and trigger sounds etc on new styles

Cache of the active rules that are applied, that way we can trigger stuff only if they actually changed

Should be called when a stylesheet in our bundle has changed. This can happen as a result of editing it in the style editor.

All these styles could possibly apply to us. To get this list we get the stylesheets from ourself and our anscestors and then filter them by the broadphase. The broadphase is a check against classes, element names and ids, things that don't change in a recursive way.

A hash of the things that are checked in the broadphase.

This style has a ::before element available. This is signalling to the panel system that if we apply this style, we should also create a ::before element.

This style has a ::after element available. This is signalling to the panel system that if we apply this style, we should also create a ::after element.

Called when a stylesheet has been added or removed from ourselves or one of our ancestor panels - because under that condition we need to rebuild our broadphase.

Called from the root panel in a thread. We replace activeRules with all of the rules that we want applied and return true if the rules changed.

Returns true if we have the style

For ondrag event - the delta of the mouse movement

The position on the Target panel where the drag started

The position relative to the screen where the drag started

The current mouse position relative to target

The current position relative to the screen

Mouse related .

Position of the cursor relative to the panel's top left corner at the time the event was triggered.

Which button triggered the event, in string form.

Which button triggered the event, as a enum.

Base event.
See .

The panel on which the event is being called. For example, if you have a button with a label.. when the button gets clicked the actual click event might come from the label. When the event is called on the label, This will be the label. When the event propagates up to the button This will be the button - but Target will be the label. This is mainly of use with Razor callbacks, where you want to get the actual panel that created the event.

Add an event listener to a event with the given name.
See .

Name of the event to listen to.

A simple User Interface panel. Can be styled with CSS.

if we have a ::before element, this is it.

if we have a ::after element, this is it.

Called during tick to create or destroy the ::before and ::after elements.

Called to update the state of a before or after element. Either destroying it or creating it.

Quickly add common panels with certain values as children.

List of panels that are attached/parented directly to this one.

Whether this panel has any child panels at all.

The panel we are directly attached to. This panel will be positioned relative to the given parent, and therefore move with it, typically also be hidden by the parents bounds.

Called internally when a child is removed, to remove from our Children list

A child panel has been removed from this panel.

Deletes all child panels via .

Add given panel as a child to this panel.

Called internally when a child is added, to add to our children list.

A child panel has been added to this panel.

Sort the children using given comparison function.

Can be overridden by children to determine whether the panel is empty, and the :empty pseudo-class should be applied.

Should be called if overriding IsEmpty to notify the panel that its empty state has changed.

The index of this panel in its parent's child list.

Creates a panel of given type and makes it our child.

The panel to create. Optional CSS class names to apply to the newly created panel. The created panel.

Creates a panel of given type and makes it our child, returning it as an out argument.

The panel to create. The created panel. Optional CSS class names to apply to the newly created panel. Always returns .

Returns this panel and all its ancestors, i.e. the Parent, parent of its parent, etc.

Returns all ancestors, i.e. the parent, parent of our parent, etc.

List of all panels that are attached to this panel, recursively, i.e. all children of this panel, children of those children, etc.

Is the given panel a parent, grandparent, etc.

Returns the we are ultimately attached to, if any.

Returns the first ancestor panel that has no parent.

Returns the scene that this panel belongs to

Returns the GameObject that this panel belongs to

Returns the index at which the given panel is parented to this panel, or -1 if it is not.

Return a child at given index.

Index at which to look. Whether to loop indices when out of bounds, i.e. -1 becomes last child, 11 becomes second child in a list of 10, etc. Returns the requested child, or if it was not found.

Amount of panels directly parented to this panel.

Returns a list of child panels of given type.

The type of panels to retrieve.

A list of CSS classes applied to this panel.

All CSS classes applied to this panel, separated with spaces.

Adds CSS class(es) separated by spaces to this panel.

Sets a specific CSS class active or not.

Add a class for a set amount of seconds. If called multiple times, we will stomp the earlier call.

Add a class if we don't have it, remove a class if we do have it

Add multiple CSS classes separated by spaces to this panel.

Removes given CSS class from this panel.

Whether we have the given CSS class or not.

Whether if we have all of these CSS classes.

Dirty the styles on this panel

Dirty the styles of this class and its children recursively.

Switch the class on or off depending on the value of the bool.

The element name. If you've created this Panel via a template this will be whatever the element name is on there. If not then it'll be the name of the class (ie Panel, Button)

Works the same as the html id="" attribute. If you set Id to "poop", it'll match any styles that define #poop in their selector.

If this was created by razor, this is the file in which it was created

If this was created by razor, this is the line number in the file

Quick access to timing events, for async/await.

A collection of stylesheets applied to this panel directly.

Special flags used by the styling system for hover, active etc..

Whether this panel has the :focus pseudo class active.

Whether this panel has the :active pseudo class active.

Whether this panel has the :hover pseudo class active.

Whether this panel has the :intro pseudo class active.

Whether this panel has the :outro pseudo class active.

Called when a hotload happened. (Not necessarily on this panel)

List of all s applied to this panel and all its ancestors.

Switch a pseudo class on or off.

Return true if this panel isn't hidden by opacity or displaymode.

Called every frame. This is your "Think" function.

Called after the parent of this panel has changed.

Returns true if this panel would like the mouse cursor to be visible.

Convert a point from the screen to a point representing a delta on this panel where the top left is [0,0] and the bottom right is [1,1]

Convert a point from the screen to a position relative to the top left of this panel

Convert a point from local space to screen space

Find and return any children of this panel (including self) within the given rect.

The area to look for panels in, in screen-space coordinates. Whether we want only the panels that are completely within the given bounds.

Allow selecting child text

Called when the player moves the mouse after "press and holding" (or dragging) the panel.

If AllowChildSelection is enabled, we'll try to select all children text

Clear any selection in children

Called when the current language has changed. This allows you to rebuild anything that might need rebuilding. Tokenized text labels should automatically update.

Invoke a method after a delay. If the panel is deleted before this delay the method will not be called.

Invoke a method after a delay. If the panel is deleted before this delay the method will not be called. If the invoke is called while the old one is waiting, the old one will be cancelled.

Cancel a named invocation

Set via "value" property from HTML.

Call this when the value has changed due to user input etc. This updates any bindings, backwards. Also triggers $"{name}.changed" event, with value being the Value on the event.

Whether was called on this panel.

Deletes the panel.

If , will skip any outros. (:outro CSS pseudo class)

Called when the panel is about to be deleted.

Called on delete.

Return true if this panel wants to be dragged

Set this to false if you want to opt out of drag scrolling

Find a panel in our heirachy that wants to be dragged

Distribute the drag events to specific virtual functions

Return true if this panel is scrollable on the X axis

Return true if this panel is scrollable on the Y axis

Called when a panel is being dragged over this panel. Fires continuously as the cursor moves.

Called when a panel being dragged leaves this panel's bounds.

Called when a dragged panel is released over this panel.

To be used inside to add custom shapes, textures and text to a panel. These draw calls will be batched together with the panel's CSS-styled content for efficient rendering.


            public override void OnDraw()
            {
                Draw.Rect( new Rect( 0, 0, 100, 100 ), Color.Red, cornerRadius: 8 );
                Draw.Text( "Hello", new Rect( 10, 10, 80, 20 ), 14, Color.White );
            }

Draws a filled rectangle.

The rectangle to draw, in panel-local coordinates. Fill color. Uniform corner radius for rounded rectangles. Use the overload for per-corner control.

Draws a filled rectangle with per-corner radius control.

The rectangle to draw, in panel-local coordinates. Fill color. Corner radii as (bottom-right, top-right, bottom-left, top-left).

Draws a filled circle.

Center position in panel-local coordinates. Circle radius in pixels. Fill color.

Draws a texture within the given rectangle.

The texture to draw. Destination rectangle in panel-local coordinates. Optional color tint applied to the texture. Defaults to (no tint).

Draws a text string within the given rectangle.

The text to render. Bounding rectangle for text layout, in panel-local coordinates. Font size in pixels. Text color. Text alignment and layout flags. Defaults to .

Draws a box shadow (drop shadow or inset shadow).

The rectangle to cast the shadow from, in panel-local coordinates. Shadow color. Blur radius in pixels. Higher values produce softer shadows. Spread distance in pixels. Positive values expand the shadow, negative values shrink it. Shadow offset from the rectangle position. Corner radius to match rounded rectangles. If true, draws an inner shadow instead of a drop shadow.

Draws an outline (stroke) around a rectangle.

The rectangle to outline, in panel-local coordinates. Outline color. Outline thickness in pixels. Corner radius to match rounded rectangles. Outline offset. Positive values push the outline outward, negative values pull it inward.

Draws a texture using this panel's CSS box styling (border radius, border image, background position/size, tint, blend mode, filter mode, etc.) and adds the resulting descriptor to . This is intended for controls like , , and that render a texture as their primary content while respecting the panel's CSS properties. For simple texture drawing without CSS styling, use instead.

The texture to draw. If null or invalid, draws the styled box without a texture. Controls how the texture is sized within the panel (e.g. , , ).

Called on creation and hotload to delete and re-initialize event listeners.

Runs given callback when the given event is triggered.

Runs given callback when the given event is triggered, without access to the .

Create a new event and pass it to the panels event queue.

Event name. Event value. Time, in seconds, to wait before firing the event.
All subsequent calls to with the same event name will update the original event instead of creating a new event, until it finally triggers.

Pass given event to the event queue.

Called when various s happen. Handles event listeners and many standard events by default.

Called when the player releases their left mouse button (Mouse 1) while hovering this panel.

Called when the player releases their middle mouse button (Mouse 3) while hovering this panel.

Called when the player releases their right mouse button (Mouse 2) while hovering this panel.

Called when the player presses down the left or right mouse buttons while hovering this panel.

Called when the player releases left or right mouse button.

Called when the player double clicks the panel with the left mouse button.

Called when the cursor moves while hovering this panel.

Called when the cursor enters this panel.

Called when the cursor leaves this panel.

Called when the player presses the "Back" button while hovering this panel, which is typically "mouse 5", aka one of the mouse buttons on its side.

Called when the player presses the "Forward" button while hovering this panel, which is typically "mouse 4", aka one of the mouse buttons on its side.

Called when the escape key is pressed

Called when this panel receives input focus.

Called when this panel loses input focus.

Current mouse position local to this panels top left corner.

Called by to transform the current mouse position using the panel's LocalMatrix (by default). This can be overriden for special cases.

Whether given screen position is within this panel. This will accurately handle border radius as well.

The position to test, in screen coordinates.

Whether the given rect is inside this panels bounds. ()

The rect to test, which should have screen-space coordinates. to test if the given rect is completely inside the panel. to test for an intersection.

False by default, can this element accept keyboard focus. If an element accepts focus it'll be able to receive keyboard input.

Describe what to do with keyboard input. The default is InputMode.UI which means that when focused, this panel will receive Keys Typed and Button Events. If you set this to InputMode.Game, this panel will redirect its inputs to the game, which means for example that if you're focused on this panel and press space, it'll send the jump button to the game.

False by default. Anything that is capable of accepting IME input should return true. Which is probably just a TextEntry.

Give input focus to this panel.

Remove input focus from this panel.

Called when any button, mouse (except for mouse4/5) and keyboard, are pressed or depressed while hovering this panel.

Called when a printable character has been typed (pressed) while this panel has input focus. ()

Called when any keyboard button has been typed (pressed) while this panel has input focus. ()

Called when the user presses CTRL+V while this panel has input focus.

If we have a value that can be copied to the clipboard, return it here.

Called when the player scrolls their mouse wheel while hovering this panel.

The scroll wheel delta. Positive values are scrolling down, negative - up.

Called from to try to scroll.

The scroll wheel delta. Positive values are scrolling down, negative - up. Return true to NOT propagate the event to the .

Scroll to the bottom, if the panel has scrolling enabled.

Whether we scrolled to the bottom or not.

Captures the mouse cursor while active. The cursor will be hidden and will be stuck in place. You will want to use in while to read mouse movements. You can call this from for mouse clicks.

Whether to enable or disable the capture.

Whether this panel is capturing the mouse cursor. See .

Transform a ray in 3D space to a position on the panel. This is used for world panel input.

The ray in 3D world space to test against this panel. Position on the panel where the intersection happened, local to the panel's top left corner. Distance from the ray's origin to the intersection in 3D space. Return true if a hit/intersection was detected.

If the tooltip text changed, we'll update it here. I haven't exposed this to game code yet because I doubt the usefulness to people that are manually creating tooltip panels.

Called before rendering this panel

Called during Gather phase — push RT on the global command list.

Build commands for post-children layer drawing (filters, masks, etc.) Called during Build phase after children are processed. LayerStack is maintained during Build so PopLayer can set correct state.

Draws shadows for the current layer into the specified command list.

Draws borders for the current layer into the specified command list.

Returns true if this panel has a layer that needs post-children rendering.

Access to various bounding boxes of this panel.

If true, calls .

The velocity of the current scroll

Offset of the panel's children position for scrolling purposes.

Scale of the panel on the screen.

Inverse scale of .

If this panel has transforms, they'll be reflected here

If this panel or its parents have transforms, they'll be compounded here.

The matrix that is applied as a result of transform: styles

The computed style has a non-default backdrop filter property

The computed style has a non-default filter property

The computed style has a renderable background

Called when the visibility of the current panel changes. This could be because our own style changed, or a parent style. You can check visibility using and .

The currently calculated opacity. This is set by multiplying our current style opacity with our parent's opacity.

This panel has just been laid out. You can modify its position now and it will affect its children. This is a useful place to restrict shit to the screen etc.

Takes a and returns an outer rect

If true, we'll try to stay scrolled to the bottom when the panel changes size

Whether the scrolling is currently pinned to the bottom of the panel as dictated by .

The size of the scrollable area within this panel.

Is this panel currently being scrolled by dragging?

Layout the children of this panel.

The parent's position.

Constrain scrolling to the given size.

Play a sound from this panel.

Move this panel to be after the given sibling.

Move given child panel to be given index, where 0 is the first child.

True when a bind has changed and OnParametersSet call is pending a call

Same as , but first tries to set the property on the panel object, then process any special properties such as class.

Set a property on the panel, such as special properties (class, id, style and value, etc.) and properties of the panel's C# class.

name of the property to modify. Value to assign to the property.

Used in templates, gets an attribute that was set in the template.

Used in templates, try to get the attribute that was set in creation.

Called after all templated panel binds have been set.

Called by the templating system when an element has content between its tags.

true when the tree should be re-rendered next frame.

For razor panels, call when the state of the render tree has changed such that it would be a good idea to re-render the tree. You would usually not need to call this manually.

Overridden/implemented by Razor templating, contains render tree checksum to determine when the render tree content has changed.

Overridden/implemented by Razor templating to build a render tree.

By overriding this you can return a hash of variables used by the Razor layout, which will cause a rebuild when changed. This is useful when your layout uses a global variable because by adding it to a HashCode.Combine here you can easily trigger a build when it changes.

A RenderFragment has been set on us, so our tree has potential changes now. Lets update and see.

Allows building render tree from outside of the class.

Called after the razor tree has been created/rendered.

Delete all children generated by the Razor render tree.

Override this to draw custom graphics for this panel using the API.


            public override void OnDraw()
            {
                var r = Box.RectInner;
                Draw.Rect( r, Color.Blue.WithAlpha( 0.2f ), cornerRadius: 4 );
                Draw.Text( "Score: 100", r, 16, Color.White, TextFlag.Center );
            }

Build descriptors for all children. Called during tick phase.

This is the style that we computed last. If you're looking to see which styles are set on this panel then this is what you're looking for.

A importance sorted list of style blocks that are active on this panel

Allows you to set styles specifically on this panel. Setting the style will only affect this panel and no others and will override any other styles.

Try to find @keyframes CSS rule with given name in .

The name to search for. The keyframes, if any are found, or . if @keyframes with given name were found.

Should be called when something happens that means that this panel's stylesheets need to be re-evaluated. Like becoming hovered or classes changed. You don't call this when changing styles directly on the panel, just on anything that will change which stylesheets should get selected.

Also re-evaluate all ancestor panels. (for :has()) Also re-evaluate all child panels. (for parent selectors) Root panel cache so we don't need to keep looking it up.

Loads a stylesheet from one specified within a [StyleSheet] attribute.

True if the attribute exists and we loaded from it, otherwise false

Loads a stylesheet from one based on the class name.

True if the attribute exists and we loaded from it, otherwise false

Loads a stylesheet from the specified path.

True if the stylesheet was loaded successfully, otherwise false

TODO: Obsolete this and instead maybe we have something like [PanelSlot( "slotname" )] that is applied on properties. Then when we find a slot="slotname" we chase up the heirachy and set the property.

A string to show when hovering over this panel.

The created tooltip element will have this class, if set.

You should override and return true if you're overriding . Otherwise this will return true if is not empty.

Pushes the global context to whatever is suitable for this panel. This should never really have to be called, when panels tick render etc. they'll already be in the right context. This is for when the UI system is used outside of the standard contexts, like tooltips.

Create a tooltip panel. You can override this to create a custom tooltip panel.
If you're overriding this and not setting , then you must override and return true in .

Handles the storage, progression and application of CSS transitions.

Returns true if this panel has any active CSS transitions.

Any transitions running, or about to run, will jump straight to the end.

Can be used to store random data without sub-classing the panel.

Get a token that is cancelled when the panel is deleted

Represents position and size of a on the screen.

Position and size of the element on the screen, including both - its padding AND margin.

Position and size of only the element's inner content on the screen, without padding OR margin.

The size of padding.

The size of border.

Position and size of the element on the screen, including its padding, but not margin.

minus the border sizes. Used internally to "clip" (hide) everything outside of these bounds, if the panels is not set to .

Position of the left edge in screen coordinates.

Position of the right edge in screen coordinates.

Position of the top edge in screen coordinates.

Position of the bottom edge in screen coordinates.

Represents a parsed @mixin definition that can be included elsewhere.

The name of the mixin (e.g., "button" from "@mixin button")

Parameter definitions in order, with optional default values. Key = parameter name (without $), Value = default value (null if required)

Whether this mixin has a variadic parameter (last param ends with ...)

The raw content of the mixin body, to be expanded when included. This includes nested rules which will be parsed during expansion.

Source file for error messages

Source line for error messages

Expand this mixin with the given arguments, returning the CSS content with all parameters substituted.

Replace @content directives, handling both standalone and with trailing semicolons

Pattern:
@content\\s*;
Options:
RegexOptions.IgnoreCase
Explanation:


            ○ Match '@'.

            ○ Match a character in the set [Cc].

            ○ Match a character in the set [Oo].

            ○ Match a character in the set [Nn].

            ○ Match a character in the set [Tt].

            ○ Match a character in the set [Ee].

            ○ Match a character in the set [Nn].

            ○ Match a character in the set [Tt].

            ○ Match a whitespace character atomically any number of times.

            ○ Match ';'.

Pattern:
@content(?!\\w)
Options:
RegexOptions.IgnoreCase
Explanation:


            ○ Match '@'.

            ○ Match a character in the set [Cc].

            ○ Match a character in the set [Oo].

            ○ Match a character in the set [Nn].

            ○ Match a character in the set [Tt].

            ○ Match a character in the set [Ee].

            ○ Match a character in the set [Nn].

            ○ Match a character in the set [Tt].

            ○ Zero-width negative lookahead.

                ○ Match a word character.

A single parameter in a mixin definition.

Parameter name without the $ prefix (and without ... for variadic)

Default value, or null if the parameter is required

Whether this is a variadic parameter (collects remaining arguments)

Get the appropriate property name from a potential alias (color -> font-color). This means we can define all our aliases in one place without any code re-use.

Parse the styles as you would if they were passed in an style="width: 100px" attribute

Parse a @mixin definition and add it to the . Returns true if we found and parsed a mixin, false otherwise.

Parse mixin parameter list like "$color, $padding: 8px, $args..."

Parse @include directive arguments like "button(#3498db, 16px)" or "button($radius: 8px)".

Parse include arguments, handling positional, named, and variadic arguments.

Split the parameter / argument list by commas, respecting nested parentheses.

Check if content starts with @include and expand it if so. Returns false if not an include directive.

Overload for backward compatibility - no content block

Here we divide the selectors into groups .fucker, .cocks, .hairy

Parse a single rule, which as "panel.closed.error:hover"

Handle @include at the top level (outside any selector block). This expands the mixin content and parses any resulting style blocks.

Process expanded mixin content, handling both properties and nested rules. The currentNode parameter is the StyleBlock where the @include appears - used for selector resolution.

Determines if the current position in the parse is a nested selector rather than a CSS property.

Read content within braces, handling nested braces correctly. Advances p past the closing brace.

This is a tree renderer for panels. If we ever use razor on other ui we'll want to make a copy of this class and do the specific things to that.

Reset to an unseen, unlooped state

Allows caching a block so you can avoid repeating unnecessary steps. Calling this will return true if it's already cached, false if it's not. If it's not it'll add to the cache so that next time it will return true.

For loops, how many times has this been seen

Called once before building the tree

Called once after building the tree

Add the current source location. Used to record in which file the element was created.

Start working on this element

Handles "style" and "class" attributes..

Styles from a style block

]]>

Finish working on this element

Handles text content within an element

Delete all of the elements created by this render tree

Implements @ref

Handles @onclick=@( () => DoSomething( "boobies" ) )

Handles @onclick=@( () => await DoSomethingAsync( "boobies" ) )

Handles @onclick=@( ( PanelEvent e ) => DoSomething( e.This, "boobies" ) )

Add markup to the current element

Create a panel of type T

Called to set attributes on a panel directly

Update bound variables and return true if any of them changed

Per-box data uploaded to a StructuredBuffer for the batched UI box shader. Must match BoxInstanceData in ui_cssbox_batched.shader.

Per-scissor data uploaded to a StructuredBuffer for per-instance clipping. Must match ScissorData in ui_cssbox_batched.shader.

Per-transform data uploaded to a StructuredBuffer for per-instance transforms. Must match TransformData in ui_cssbox_batched.shader.

Software scissor, panels outside of this should not be rendered

Accumulated clip rect from ancestors. Any panel whose bounds extend outside this rect will be skipped entirely. Null when no clip-whole ancestor is active.

Accumulated clip rect from and ancestors. Any panel whose bounds lie completely outside this rect will be skipped entirely (early cull). Uses an overlap test so partially-visible panels still render. Null when no scroll/hidden ancestor is active.

Scissor passed to gpu shader to be transformed

Scope that updates the renderer's scissor state for child panels to inherit. Does NOT modify any command lists - those are set up separately in BuildCommandList.

Create a clip scope for a panel's children. This updates the renderer's scissor state so child panels will inherit the correct scissor when their command lists are built.

Creates a box descriptor for a texture and adds it to the target RenderLayer. Used by Image, SvgPanel, ScenePanel etc.

Rebuild all descriptors for a panel. Called during build phase when panel is dirty.

Calculate and store the transform matrix for a panel during build phase. The transform is cached on the panel and applied to the global CL during gather.

Sorts deferred instances, flushes draw calls at transitions.

All descriptor types build into this This is higher than the GPUBoxInstance because of the texture refs but I want the texture refs so we can refresh bindless indices at render time But this should be refactored down into the descriptor itself somehow, since we want to support custom ones..

Collects all draw instances for a panel's cached render data. Rebuilt when dirty, drawn during the gather phase.

Clear all instances from this layer.

Thread-local buffer for collecting UI draw descriptors during panel.OnDraw(). Descriptors are routed directly to the active RenderLayer.

The target layer for draw calls. Set by the renderer before OnDraw().

Renders descriptors that can't go through the instanced batch path. Backdrops need framebuffer grabs.

A root panel. Serves as a container for other panels, handles things such as rendering.

Bounds of the panel, i.e. its size and position on the screen.

If any of our panels are visible and want mouse input (pointer-events != none) then this will be set to true.

The scale of this panel and its children.

If set to true this panel won't be rendered to the screen like a normal panel. This is true when the panel is drawn via other means (like as a world panel).

True if this is a world panel, so should be skipped when determining cursor visibility etc

If this panel belongs to a VR overlay

If this panel should be rendered with ~4K resolution.

Current global mouse position, projected onto plane for world panels.

Single flat command list used by the flat rendering path. All panels record into this one list instead of per-panel lists.

This is called from tests to emulate the regular root panel simulate loop

Called before layout to lock the bounds of this root panel to the screen size (which is passed). Internally this sets PanelBounds to rect and calls UpdateScale.

Work out scaling here. Default is to scale relative to the screen being 1920 wide. ie - scale = screensize.Width / 1920.0f;

Build descriptors for this panel and all children. Called during the tick phase, before gathering.

Render this panel manually. This gives more flexibility to where UI is rendered, to texture for example. must be set to true.

A list of panels that are waiting to have their styles re-evaluated

Add this panel to a list to have their styles re-evaluated. This should be done any time the panel changes in a way that could affect its style selector.. like if its child index changed, or classes added or removed, or became hovered etc.

Run through all panels that are pending a re-check on their style rules. Only properly invalidate them if their rules actually change.

Describes transition of a single CSS property, a.k.a. the values of a transition CSS property. Utility to create a transition by comparing the panel style before and after the scope.

The CSS property to transition.

Duration of the transition between old value and new value.

If set, delay before starting the transition after the property was changed.

The timing or "easing" function. transition-timing-function CSS property. Example values would be ease, ease-in, ease-out and ease-in-out.

A list of CSS properties that should transition when changed. Utility to create a transition by comparing the panel style before and after the scope.

The actual list of CSS properties that should be transitioned.

Clear the list of CSS transitions.

Auto generated container class for majority of CSS properties available.

Called when any CSS properties are changed.

Represents the overflow CSS property.

Copy over only the styles that are set.

Copy all styles from given style set.

Set Left, Right, Width and Height based on this rect. Scale can be used to scale the rect (maybe you want to use Panel.ScaleFromScreen etc)

Represents the content CSS property.

Represents the width CSS property.

Represents the min-width CSS property.

Represents the max-width CSS property.

Represents the height CSS property.

Represents the min-height CSS property.

Represents the max-height CSS property.

Represents the left CSS property.

Represents the top CSS property.

Represents the right CSS property.

Represents the bottom CSS property.

Represents the opacity CSS property.

Represents the background-color CSS property.

Represents the padding-left CSS property.

Represents the padding-top CSS property.

Represents the padding-right CSS property.

Represents the padding-bottom CSS property.

Represents the margin-left CSS property.

Represents the margin-top CSS property.

Represents the margin-right CSS property.

Represents the margin-bottom CSS property.

Represents the border-top-left-radius CSS property.

Represents the border-top-right-radius CSS property.

Represents the border-bottom-right-radius CSS property.

Represents the border-bottom-left-radius CSS property.

Represents the border-left-width CSS property.

Represents the border-top-width CSS property.

Represents the border-right-width CSS property.

Represents the border-bottom-width CSS property.

Represents the border-left-color CSS property.

Represents the border-top-color CSS property.

Represents the border-right-color CSS property.

Represents the border-bottom-color CSS property.

Represents the font-size CSS property.

Represents the font-color CSS property.

Represents the font-weight CSS property.

Represents the font-family CSS property.

Represents the caret-color CSS property.

Represents the cursor CSS property.

Represents the pointer-events CSS property.

Represents the mix-blend-mode CSS property.

Represents the position CSS property.

Represents the overflow-x CSS property.

Represents the overflow-y CSS property.

Represents the flex-direction CSS property.

Represents the justify-content CSS property.

Represents the display CSS property.

Represents the flex-wrap CSS property.

Represents the align-content CSS property.

Represents the align-self CSS property.

Represents the align-items CSS property.

Represents the flex-basis CSS property.

Represents the flex-grow CSS property.

Represents the flex-shrink CSS property.

Represents the row-gap CSS property.

Represents the column-gap CSS property.

Represents the aspect-ratio CSS property.

Represents the text-align CSS property.

Represents the text-overflow CSS property.

Represents the text-filter CSS property.

Represents the word-break CSS property.

Represents the text-decoration-line CSS property.

Represents the text-decoration-color CSS property.

Represents the text-decoration-thickness CSS property.

Represents the text-decoration-skip-ink CSS property.

Represents the text-decoration-style CSS property.

Represents the text-underline-offset CSS property.

Represents the text-overline-offset CSS property.

Represents the text-line-through-offset CSS property.

Represents the font-style CSS property.

Represents the font-variant-numeric CSS property.

Represents the transform CSS property.

Represents the text-transform CSS property.

Represents the transform-origin-x CSS property.

Represents the transform-origin-y CSS property.

Represents the letter-spacing CSS property.

Represents the line-height CSS property.

Represents the word-spacing CSS property.

Represents the white-space CSS property.

Represents the z-index CSS property.

Represents the order CSS property.

Represents the sound-in CSS property.

Represents the sound-out CSS property.

Represents the backdrop-filter-blur CSS property.

Represents the backdrop-filter-brightness CSS property.

Represents the backdrop-filter-contrast CSS property.

Represents the backdrop-filter-saturate CSS property.

Represents the backdrop-filter-sepia CSS property.

Represents the backdrop-filter-invert CSS property.

Represents the backdrop-filter-hue-rotate CSS property.

Represents the filter-blur CSS property.

Represents the filter-saturate CSS property.

Represents the filter-sepia CSS property.

Represents the filter-brightness CSS property.

Represents the filter-hue-rotate CSS property.

Represents the filter-invert CSS property.

Represents the filter-contrast CSS property.

Represents the filter-tint CSS property.

Represents the filter-border-width CSS property.

Represents the filter-border-color CSS property.

Represents the mask-mode CSS property.

Represents the mask-repeat CSS property.

Represents the mask-size-x CSS property.

Represents the mask-size-y CSS property.

Represents the mask-position-x CSS property.

Represents the mask-position-y CSS property.

Represents the mask-angle CSS property.

Represents the mask-scope CSS property.

Represents the background-size-x CSS property.

Represents the background-size-y CSS property.

Represents the background-position-x CSS property.

Represents the background-position-y CSS property.

Represents the background-repeat CSS property.

Represents the border-image-width-left CSS property.

Represents the border-image-width-right CSS property.

Represents the border-image-width-top CSS property.

Represents the border-image-width-bottom CSS property.

Represents the border-image-fill CSS property.

Represents the border-image-repeat CSS property.

Represents the border-image-tint CSS property.

Represents the background-blend-mode CSS property.

Represents the background-tint CSS property.

Represents the background-angle CSS property.

Represents the text-background-angle CSS property.

Represents the perspective-origin-x CSS property.

Represents the perspective-origin-y CSS property.

Represents the text-stroke-color CSS property.

Represents the text-stroke-width CSS property.

Represents the image-rendering CSS property.

Represents the animation-delay CSS property.

Represents the animation-direction CSS property.

Represents the animation-duration CSS property.

Represents the animation-fill-mode CSS property.

Represents the animation-iteration-count CSS property.

Represents the animation-name CSS property.

Represents the animation-play-state CSS property.

Represents the animation-timing-function CSS property.

Represents the font-smooth CSS property.

Represents the object-fit CSS property.

Represents the outline-width CSS property.

Represents the outline-color CSS property.

Represents the outline-offset CSS property.

Copy over only the styles that are set.

Copy all styles from given style set.

Set a CSS property via its string name.

Lerp every property in this stylesheet

Lerp a specific property by name

Perform a deep copy of this stylesheet

Controls whether the background video is paused. Mirrors animation-play-state. Maps to the CSS property background-playback-state: paused | running.

Whether there is an active CSS animation.

A CSS rule - ie ".chin { width: 100%; height: 100%; }"

A list of appropriate selectors for this block (ie ".button")

A list of selectors for this block

Get the list of raw style values

Update a raw style value

The filename of the file containing this style block (or null if none)

The absolute on disk filename for this style block (or null if not on disk)

The line in the file containing this style block

The styles that are defined in this block

Test whether target passes our selector tests. We use forceFlag to do alternate tests for flags like ::before and ::after. It's basically added to the target's pseudo class list for the test.

Tests a few broadphase conditions to build a list of feasible styleblocks tailored for a panel.

Represents all supported CSS properties and their currently assigned values.

Stops the animation. If we have animation vars we'll start again.

Stop any previous animations and start this one. Make it last this long.

Whether this style sheet has any transitions that would need to be run.

List of transitions this style sheet has.

Creates a matrix based on this style's "transform" and other related properties

Try to find all panels using this style and mark them dirty so they'll redraw with the style. This should be called when the style is changed. Which is only technically when done via the editor.

Optional Optional Optional Optional

A CSS selector like "Panel.button.red:hover .text"

The Id selector - minus the # https://developer.mozilla.org/en-US/docs/Web/CSS/ID_selectors

Descendant combinator A B Child combinator A > B Adjacent sibling combinator A + B General sibling combinator A ~B

True if this has a universal selector (*)

For + combinator

For ~ combinator

Test whether target passes our selector test. We use forceFlag to do alternate tests for flags like ::before and ::after. It's basically added to the target's pseudo class list for the test.

Between sessions we clear the stylesheets, so one gamemode can't accidentally use cached values from another.

Releases the filesystem watcher so we won't get file changed events.

Try to get a mixin by name.

Get a mixin by name or null if not found.

A collection of objects applied directly to a panel. See .

Add a stylesheet directly

Load the stylesheet from a file.

Load the stylesheet from a string.

Remove a specific from the collection.

Remove all stylesheets whose filename matches this wildcard glob.

Returns all CSS variables from the owning panel and its ancestors.

Handles the storage, progression and application of CSS transitions for a single .

Active CSS transitions.

Whether there are any active CSS transitions.

Clear all transitions. This will immediately remove transitions, leaving styles wherever they are.

Immediately snaps all transitions to the end point, at which point they're removed.

Sets the clipboard text

Helper class for working with Unicode emoji.

Find a Unicode emoji from a :emoji_name: format.

Input emoji text in :emoji_name: format. The emoji or .

We share a lot of code between mask-image and background-image - so this handles all image rect calculations.

Base class for virtualized, scrollable panels that only create item panels when visible.

When setting the items from a List we keep a reference to it here for change detection.

When true, forces a layout rebuild on the next .

Template used to render an item into a cell panel.

Called when a cell is created. Allows you to fill the cell in

Called when the last cell has been viewed. This allows you to view more.

Initializes the base virtual panel with default styles.

Replaces the current items. Only triggers a rebuild if the sequence is actually different. When set to an IList (like List<T>), changes to the source list will be automatically detected.

Adds a single item and marks the panel for rebuild.

The item to append.

Adds multiple items and marks the panel for rebuild.

Items to append.

Removes the first occurrence of a specific item and marks the panel for rebuild.

The item to remove. True if item was found and removed; otherwise false.

Removes the item at the specified index and marks the panel for rebuild.

The zero-based index of the item to remove.

Inserts an item at the specified index and marks the panel for rebuild.

The zero-based index at which item should be inserted. The item to insert.

Clears all items and destroys created panels.

Checks the source list for changes and updates the internal items if needed.

Per-frame update: adjusts spacing from CSS, updates layout, creates/destroys visible panels.

Final layout pass for child panels and scroll bounds.

Layout offset.

Returns true if is a valid item index.

Item index. True if within bounds; otherwise false.

Gets the number of items in the panel.

Convenience helper that sets .

New items sequence.

Updates the layout spacing based on CSS gaps.

The spacing vector from CSS.

Updates the layout and returns true if the layout changed.

True if layout was updated; otherwise false.

Gets the range of visible item indices.

First visible index (inclusive). Past-the-end index (exclusive).

Positions a panel at the specified index.

Item index. Panel to position.

Gets the total height needed to display the specified number of items.

Number of items. Total height in layout units.

Layout objects in a grid

Fixed item width (≥ 1). Values set below 1 are clamped to 1.

Fixed item height (≥ 1). Values set below 1 are clamped to 1.

Gaps between cells. X = column gap, Y = row gap.

If true, stretches cell width to be flush on the right edge and preserves aspect ratio by scaling height accordingly.

Update layout state from the given box, scale, scroll, and justification. Returns true when internal state changed (i.e., layout is dirty).

Compute the visible index range [firstIndex, lastIndex). Uses the outer viewport height and compensates for inner top offset so top padding does not cull early rows.

Get the rectangle for the cell at the given index.

Apply the cell rectangle for to .

Calculate total content height for the given item count.

Layout items in a vertical list

Fixed item height (≥ 1). Values set below 1 are clamped to 1.

Gaps between items. X is ignored; Y is row gap.

Update layout state from the given box, scale, and scroll. Returns true when internal state changed.

Compute the visible index range [firstIndex, lastIndex). Compensates for inner top offset so top padding does not cull early items.

Get the rectangle for the item at the given index.

Apply the item rectangle for to .

Calculate total content height for the given item count.

A virtualized, scrollable grid panel that only creates item panels when visible.

Grid layout used to position/measure items. (Swappable later if needed.)

Fixed width of each item. If < 0, layout may stretch to fill width.

A virtualized, scrollable list panel that only creates item panels when visible.

Vertical list layout used to position/measure items. (Swappable later if needed.)

Fixed height of each item.

An interactive 2D panel rendered in the 3D world.

Scene object that renders the panel.

Transform of the world panel in 3D space.

Tags that are applied to the underlying SceneObject

Position of the world panel in 3D space.

Rotation of the world panel in 3D space.

Scale of the world panel in 3D space.

Maximum distance at which a player can interact with this world panel.

Update the bounds for this panel. We purposely do nothing here because on world panels you can change the bounds by setting .

We override this to prevent the scale automatically being set based on screen size changing.. because that's obviously not needed here.

Holds onto a list of root panels to tick, input and draw

This panel should get deleted at some point

Delete all panels that were deferred and are no longer playing outro transitions

Renders a panel in a scene world. You are probably looking for WorldPanel.

Global scale for panel rendering within a scene world.

The panel that will be rendered.

Base class for properties that should be serialized to binary format instead of JSON. Used for large data structures that would be inefficient as JSON.

The version of this binary data format. Used for upgrade paths.

Serialize this object to binary format.

Deserialize this object from binary format.

Optional upgrade path for old data versions. Called if the data version is older than current Version.

Context for writing binary blob data. Wraps ByteStream for allocation-free serialization.

The underlying byte stream.

Context for reading binary blob data. Wraps ByteStream for allocation-free deserialization.

The underlying byte stream.

The version of the data being read.

Manages binary blobs during JSON serialization with support for nested contexts.

Indicates whether a blob context is currently active.

Registers a instance for serialization in the current blob context. Returns a that can be used to reference the blob in JSON. If no blob context is active, returns . Called automatically by BinaryBlobJsonConverter during JSON serialization.

Create a blob serialization context for capturing blobs.

Load blob data from memory if available, otherwise from file path.

Create a blob deserialization context from in-memory data.

Create a blob deserialization context from a file.

A disposable context for blob serialization/deserialization.

Add a reference to the "base" package.

Add a reference to the "toolbase" package.

Add a reference to the given compiler.

Add a reference to the given package's assembly.

Add a reference to the given package's editor assembly.

Encode and decode LZ4 compressed data.

Encode data as an LZ4 block.

Input buffer Compression level to use Compressed LZ4 block data

Decode raw LZ4 block data.

Input buffer, compressed LZ4 block data Output buffer, uncompressed Number of bytes written

Encode data as an LZ4 frame (standard LZ4 frame format, compatible with lz4 CLI).

Input buffer Compression level to use Compressed LZ4 frame data

Decode an LZ4 frame (standard LZ4 frame format, compatible with lz4 CLI).

Input buffer, compressed LZ4 frame data Uncompressed data

Functions to interact with the tools system. Does nothing if tools aren't enabled.

Set the object to be inspected by the inspector in the editor

Wrappers of the parallel class.

Return what type os SteamId this is

The current user's SteamId

The current user's persona name (Steam name)

Return true if this is a friend

Return true if this person is online

Filters text for game content using Steam's text filter.

Filters chat messages using Steam's text filter.

Filters player names using Steam's text filter.

Download a file to a target filename (todo - progress)

Download a file to a byte array

Download a url to a string

Download a file to a target filename (todo - progress)

How to determine which sections of the path are filled.

Clockwise paths are filled, counter-clockwise are empty.

Regions that are enclosed by an odd number of paths are filled, other regions are empty.

Controls arc size in .

Controls arc direction in .

Base class for SVG path commands.

See .

See , .

See .

A shape in a , described as a vector path.

How to determine which sections of the path are filled.

Description of how the path is constructed out of basic elements.

If true, this path has no commands.

Enclosing bounding box for this path.

Optional outline color for this path.

Optional fill color for this path.

Helper class for reading Scalable Vector Graphics files.

Reads an SVG document from the given string, returning a list of path elements describing the shapes in the image.

SVG document contents.

List of all shapes in the document.

Convert to a FloatSpan, which allows easy SIMD/AVX2 instructions

The event system.

Register an assembly. If old assembly is valid, we try to remove all of the old event hooks from this assembly, while retaining a list of objects.

Unregister an object, stop reviving events

Run an event.

Run an event with an argument of arbitrary type.

Arbitrary type for the argument. Name of the event to run. Argument to pass down to event handlers.

Run an event with 2 arguments of arbitrary type.

Arbitrary type for the first argument. Arbitrary type for the second argument. Name of the event to run. First argument to pass down to event handlers. Second argument to pass down to event handlers.

Run an event with 3 arguments of arbitrary type.

Arbitrary type for the first argument. Arbitrary type for the second argument. Arbitrary type for the third argument. Name of the event to run. First argument to pass down to event handlers. Second argument to pass down to event handlers. Third argument to pass down to event handlers.

Stream API related events. See Sandbox.Streamer.

Event called when joined a chat

Event called when left a chat

Event called when chat message comes in

How many times a second FixedUpdate runs.

Accumulate frame time up until a maximum amount (maxSteps). While this value is above the time we will invoke a fixed update.

Remove all tags from the set.

Does this set have the specified tag?

Add a tag to the set.

Remove a tag from the set.

Add or remove this tag, based on state

Try to get all tags in the set.

Get all default tags for this set.

Set the tags to match this other tag set

Add the tags from another set, to this set

If this tag is already here, remove it, else add it.

Does this set have any of the specified tag?

Does this set have all of the specified tags?

JSON converter that handles BinaryBlob serialization

Allows writing JsonConverter in a more compact way, without having to pre-register them.

Converts a Unix timestamp (seconds since epoch) to a DateTimeOffset.

A simple type value wrapper that indicates what type the value is.

A convenience JSON helper that handles types for you.

Should be called on startup and when hotloading. The reason for doing on hotloading is to clear all the types in JsonSerializableFactory

Try to deserialize given source to given type.

Deserialize from a Utf8JsonReader to given type, using our engine specific options.

Try to deserialize given source to given type. Return true if it was a success

Serialize an object.

Serialize to a Utf8JsonWriter using our engine specific options.

Parse some Json to a JsonObject

Parse some Json to a JsonNode

Deserialize to this existing object

Serialize a single object to a JsonNode

Serialize a single object to a JsonNode with the given expected type

Deserialize a single object to a type

Serialize this object property by property - even if JsonConvert has other plans

Deep walk though an entire Json tree, optionally changing values of nodes.

Uniquely identifies a tracked object by its type and identifier value.

Represents a property change to apply during patching.

The object whose property should be modified

The name of the property to modify

The new value to assign to the property

Represents an object that needs to be added during patching.

The identifier for the new object

The parent object that will contain this object

The previous sibling when adding to an array (null if first or not in array)

The property name in the parent that will contain this object

Whether this object is being added to an array (true) or as a direct property (false)

The data for the new object

Represents an object that should be removed during patching.

The identifier of the object to remove

Represents an object that should be moved to a new location during patching.

The identifier of the object to move

The new parent object

The property name in the new parent that will contain this object

Whether the object is being moved to an array (true) or as a direct property (false)

The previous sibling in the new location (null if first or not in array)

Defines characteristics of an object type that should be tracked within a JSON tree structure. These definitions are used to identify, track, and manage specific types of objects during JSON diffing and patching operations.

A unique identifier for this object type. This is used to categorize objects.

Determines whether a JSON object should be considered an instance of this tracked object type.

The function returns a float value indicating how well the JSON object matches this definition. A return value of 0 indicates no match, while higher values indicate stronger matches. This allows for heuristic-based matching when exact matches aren't possible.

Maps a JSON object to a unique identifier string.

The identifier could be derived from a specific property, a combination of properties, or a computed hash. It's critical that this function: 1. Produces a truly unique value for each distinct object of this type 2. Never maps two different objects to the same ID 3. Is deterministic - always returns the same ID when applied to the same object If you can just use a UUID or other guaranteed unique identifier.

Specifies the required type of the parent object. If null, AllowedAsRoot must be true.

This enforces type hierarchy constraints within the JSON structure.

If true, objects of this type can be the root of the object tree.

Root objects don't require a parent, and they don't need an ID since there can only be one root. If AllowedAsRoot is false, ParentType must be specified.

When true, treats this object as an atomic unit during tracking operations.

Objects with AtomicTracking enabled: 1. Have their children excluded from individual tracking 2. Skip property-level diffing (changes are handled as whole object replacements) 3. Are treated as "black boxes" where internal structure is ignored This is useful for: - Objects containing data that shouldn't be tracked independently (like patches) - Preventing recursive tracking of complex nested structures

Creates a TrackedObjectDefinition that identifies objects based on the presence of specific fields.

Represents a tracked object in a JSON tree with metadata for diffing and patching operations.

The unique identifier for this object

The defintion taht was used to track this object.

The object's JSON data without its children

Reference to this object's parent (null for root objects)

The property name in parent that contains this object

Whether this object is contained in an array (true) or as a direct property (false)

The previous sibling element when contained in an array (null if first or not in array)

Hash of the path to this object in the JSON structure

Child objects belonging to this object

Reference to this object's node in parent's Children list (for O(1) removal)

Reconstructs a complete JSON tree from this object and all its children.

Represents a complete set of changes to be applied to a JSON structure.

A patch contains all the operations needed to transform one JSON structure into another while preserving object identity and relationships.

Objects that need to be added to the target structure.

Objects that need to be removed from the target structure.

Property values that need to be changed on existing objects.

Objects that need to be moved to a different location in the structure.

Compares two JSON object trees and calculates the differences between them.

The original JSON object tree The updated JSON object tree Set of definitions for tracked object types in the JSON structure A Patch object containing all changes needed to transform oldRoot into newRoot

Applies a patch to transform a JSON object tree, with support for partial patch application when the source tree has been modified after the patch was created.

The JSON object tree to modify The patch containing all changes to apply Set of definitions for tracked object types A new JSON object tree with all applicable changes applied Partial patch application semantics: Object Removal: - Skipped if object doesn't exist in source - Proceeds if object exists even if parent has changed Object Addition: - Only added if parent exists in source - Skipped if parent is missing Object Moves: - Requires both object and target parent to exist - Object is removed if target parent doesn't exist Property Overrides: - Only applied if target object exists Array Ordering: - Best effort based on neighbourhood information (previous element) - Objects without previous elements are placed at start Operations are processed in this order: removals, additions, moves, reordering, and finally property overrides.

Combine a parent path hash with a property name segment using XxHash3. Produces a deterministic 64-bit hash without allocating any strings.

Combine a parent path hash with an array index segment.

Represents a JSON Pointer as defined in RFC 6901.

The reference tokens that make up the JSON Pointer.

A static instance representing the root JSON Pointer (i.e., "/").

Initializes a new instance of the class with the specified string.

The string value of the JSON Pointer.

Initializes a new instance of the class with the specified tokens.

The tokens that make up the JSON Pointer.

Appends a token to the JSON Pointer and returns a new .

The token to append. A new with the appended token.

Appends an integer index as a token to the JSON Pointer and returns a new .

The integer index to append. A new with the appended index.

Returns a new representing the parent of the current pointer.

A new for the parent path.

Custom JSON converter for the Pointer class that serializes a Pointer as a string and deserializes a string back into a Pointer using the Parse method.

Try to do any reflection / code gen immediately, so we don't do anything too slow during gameplay.

Objects that need to be deserialized into can implement this interface which allows them to be populated from a JSON object.

Runs through all upgraders that match its class where our version is lower than the specified version.

The current version that's serialized in the json object

Provides vectorized operations over a span of floats.

A simple class for storing and retrieving metadata values.

Deserialize metadata from a JSON string.

Serialize the metadata to a JSON string.

Set a value with the specified key.

Try to get a value of the specified type.

Get the a value. If it's missing or the wrong type then use the default value.

Gives access to mouse position etc

Called once per frame

Access to local clients' cursor position, relative to game windows' top left corner.

Change in local clients' cursor position since last frame.

Sets the cursor type until another panel stomps this value. Doesn't affect main menu.

Whether the local clients' cursor is active or not, meaning it can interact with UI elements, etc.

DEPRECATED. Use Mouse.Visibility instead.

The visibility state of the mouse cursor. Auto will only show the mouse when clickable UI elements are visible.

The visibility state of the mouse cursor.

The mouse is visible and can interact with UI elements.

The mouse is only visible when UI elements with `pointer-events: auto` are on-screen.

The mouse is locked to the game and cannot interact with UI elements.

We cache results for some expensive reflection queries. This results in large performance improvements during various operations (Cloning, NetworkSpawn, Serialization...)

Clears the type cache, called after HotLoad and after a game ended. Called from and .

Returns true if this type's ICloneable.Clone() is safe to call during cloning, meaning the type declares its own Clone() rather than inheriting a shallow-copy implementation from a BCL base type (Delegate, Array, etc.). Result is cached since GetMethod is expensive.

Returns all properties and fields that should be (de)serialized. Also sorts the members for historic reasons.

Returns all properties that have a [RequireComponent] attribute.

Returns all properties that have a [Sync] attribute.

Determines if a type can be cloned by a simple copy. This recursively walks through all properties and fields of the type to determine if they are cloneable by copy. Since this is fairly expensive, we cache the results for each type.

Access screen dimension etc.

The total size of the game screen

The width of the game screen. Equal to Screen.x

The height of the game screen. Equal to Screen.y

The aspect ratio of the screen. Equal to Width/Height

The desktop's dpi scale on the current monitor.

Converts a vertical field of view to a horizontal field of view based on the screen aspect ratio.

Converts a vertical field of view to a horizontal field of view based on the given aspect ratio.

Returns a list of ints, representing the tags. These are used internally by the engine.

The time since the game startup.

The delta between the last frame and the current (for all intents and purposes).

The time since the game startup as a double.

A convenience struct to easily measure time since an event last happened, based on .

Typical usage would see you assigning 0 to a variable of this type to reset the timer. Then the struct would return time since the last reset. i.e.:


            TimeSince lastUsed = 0;
            if ( lastUsed > 10 ) { /*Do something*/ }

Time at which the timer reset happened, based on .

Time passed since last reset, in seconds.

A convenience struct to easily manage a time countdown, based on .

Typical usage would see you assigning to a variable of this type a necessary amount of seconds. Then the struct would return the time countdown, or can be used as a bool i.e.:


            TimeUntil nextAttack = 10;
            if ( nextAttack ) { /*Do something*/ }

Time to which we are counting down to, based on .

The actual countdown, in seconds.

Amount of seconds passed since the countdown started.

The countdown, but as a fraction, i.e. a value from 0 (start of countdown) to 1 (end of countdown)

Try to get all tags in the set.

A Variant is a type that can hold any value, and also keeps track of the type of the value it holds. It's useful for cases where you want to store a value of an unknown type, or when you want to serialize/deserialize values of various types in a generic way.

The type of the value currently stored in the Variant. This is automatically set when you assign a value to the Variant.

Gets or sets the value associated with this instance.

Uncompress a voice buffer and call ondata with the result

A WebSocket client for connecting to external services.

Events handlers will be called on the synchronization context that Connect was called on.

Event handler which processes text messages from the WebSocket service.

The message text that was received.

Event handler which processes binary messages from the WebSocket service.

The binary message data that was received.

Event handler which fires when the WebSocket disconnects from the server.

Returns true as long as a WebSocket connection is established.

Get the sub-protocol that was negotiated during the opening handshake.

Event which fires when a text message is received from the server.

Event which fires when a binary message is received from the server.

Event which fires when the connection to the WebSocket service is lost, for any reason.

Enable or disable compression for the websocket. If the server supports it, compression will be enabled for all messages. Note: compression is disabled by default, and can be dangerous if you are sending secrets across the network.

Initialized a new WebSocket client.

The maximum message size to allow from the server, in bytes. Default 64 KiB.

Cleans up resources used by the WebSocket client. This will also immediately close the connection if it is currently open.

Add a sub-protocol to be negotiated during the WebSocket connection handshake.

Establishes a connection to an external WebSocket service.

The WebSocket URI to connect to. For example, "ws://hostname.local:1280/" for unencrypted WebSocket or "wss://hostname.local:1281/" for encrypted. Headers to send with the connection request. A which allows the connection attempt to be aborted if necessary. A which completes when the connection is established, or throws if it failed to connect.

Sends a text message to the WebSocket server.

The message text to send. Must not be null. A which completes when the message was queued to be sent.

Sends a binary message to the WebSocket server.

The and overloads allow sending subsections of byte arrays. The message data to send. Must not be null. A which completes when the message was queued to be sent.

Sends a binary message to the WebSocket server.

The message data to send. Must not be null. A which completes when the message was queued to be sent.

Sends a binary message to the WebSocket server.

The message data to send. A which completes when the message was queued to be sent.

Enables rendering and interacting with a webpage

Called when the texture has changed and should be updated

The current Url

Is this URL allowed

The size of the browser

Invoked when the browser needs to be repainted

A navigation has happened, allow or deny it

Invoked when the browser is navigating to a new url

Tell the browser the mouse has moved

Tell the browser the mouse wheel has moved

Tell the browser a mouse button has been pressed

Tell the browser a unicode key has been pressed

Tell the browser a key has been pressed or released

Tell the html control if it has key focus currently, controls showing the I-beam cursor in text controls amongst other things

DPI Scaling factor

Enable/disable low-resource background mode, where javascript and repaint timers are throttled, resources are more aggressively purged from memory, and audio/video elements are paused. When background mode is enabled, all HTML5 video and audio objects will execute ".pause()" and gain the property "._steam_background_paused = 1". When background mode is disabled, any video or audio objects with that property will resume with ".play()".

Lets your game make async HTTP requests.

We shouldn't blindly let users opt into local http. But it's okay for editor, dedicated servers and standalone.

Check if the given Uri matches the following requirements: 1. Scheme is https/http or wss/ws 2. If it's localhost, only allow ports 80/443/8080/8443 3. Not an ip address

The Uri to check. True if the Uri can be accessed, false if the Uri will be blocked.

Checks if a given header is allowed to be set.

The header name to check. True if the header is allowed to be set.

Send a HTTP request to the specified URI and return the response body as a string in an asynchronous operation.

The URI to request. The HTTP verb for the request (eg. GET, POST, etc.). The content to include within the request, or null if none should be sent. Headers to add to the request, or null if none should be added. An optional cancellation token for canceling this request. An asynchronous task which resolves to the response body as a string. The request responded with a non-2xx HTTP status code. The request was not allowed, either an unallowed URI or header.

Send a HTTP request to the specified URI and return the response body as a byte array in an asynchronous operation.

The URI to request. The HTTP verb for the request (eg. GET, POST, etc.). The content to include within the request, or null if none should be sent. Headers to add to the request, or null if none should be added. An optional cancellation token for canceling this request. An asynchronous task which resolves to the response body as a byte array. The request responded with a non-2xx HTTP status code. The request was not allowed, either an unallowed URI or header.

Send a HTTP request to the specified URI and return the response body as a stream in an asynchronous operation.

The URI to request. The HTTP verb for the request (eg. GET, POST, etc.). The content to include within the request, or null if none should be sent. Headers to add to the request, or null if none should be added. An optional cancellation token for canceling this request. An asynchronous task which resolves to the response body as a . The request responded with a non-2xx HTTP status code. The request was not allowed, either an unallowed URI or header.

Sends a HTTP request to the specified URI and return the response body as a JSON deserialized object in an asynchronous operation.

The URI to request. The HTTP verb for the request (eg. GET, POST, etc.). The content to include within the request, or null if none should be sent. Headers to add to the request, or null if none should be added. An optional cancellation token for canceling this request. An asynchronous task which resolves to the response body deserialized from JSON. The request responded with a non-2xx HTTP status code. The request was not allowed, either an unallowed URI or header.

Sends a HTTP request to the specified URI and returns the response in an asynchronous operation.

The URI to request. The HTTP verb for the request (eg. GET, POST, etc.). The content to include within the request, or null if none should be sent. Headers to add to the request, or null if none should be added. An optional cancellation token for canceling this request. An asynchronous task which resolves to a containing the response for the request. The request responded with a non-2xx HTTP status code. The request was not allowed, either an unallowed URI or header.

Creates a new instance containing the specified object serialized to JSON.

Mutates in-place for the redirect, matching dotnet/runtime RedirectHandler: - Always clears Authorization (credentials must not follow redirects) - Coerces method to GET and clears Content for 301/302/303 POST requests - 307/308 preserve method and content

Mimmicks the engine internal CreateInterface system, allowing us to get the interfaces without asking native.

True if this is as a result of a button being pressed

We let some button presses skip the UI completely. These can then be used as key binds that can always run. We mainly do this with the F keys.

For objects that can't be considered to be "owned" by the world they are in because they are owned by a manager. All this flag does is cause a warning when such an object is still in the world at world deletion time (a leak). if this flag is set, then the object will not be deleted when deleting the world, and will not be queued for delete. It's assumed that this object is going to be deleted inside of the destructor of another sceneobject We have a mixture of alpha-blended and non-alpha blended draws A unique batch flag that allows objects to draw in a separate batch from their original group

This is a pointer but native pretends like it's a handle/struct using DECLARE_POINTER_HANDLE. We just treat it like a pointer.

Triangulate a polygon made up of points, returns triangle indices into the list of vertices.

Get a version of this config with some fixes applied, to reduce the chance of runtime errors.

from FloatBitmap

Interop will try to load dlls from this path, e.g bin/win64/

From here we'll open the native dlls and inject our function pointers into them, and retrieve function pointers from them.

The scene we're currently editing

Run a process on multiple items, show progress bar

Start a progress section

The main editor camera

Base attribute which allows adding FGD metadata to classes.

Base attribute which allows adding metadata to properties.

A way to hide properties from parent classes in tools.

The internal/fgd name to skip. Usually all lowercase and with underscores (_) instead of spaces.

If used on a Color or Color32 property, enables alpha modification in editors.

This is an entity that can be placed in Hammer.

This is a brush based entity class. It can only be a mesh tied to an entity.

This is a point class entity, but does support being a brush entity (a mesh tied to an entity).

Marks this entity as a physics constraint. This disables pre-settle for all PhysicsSimulated entities this entity's keyvalues reference in Hammer.

This is a path class, used with Hammer's Path Tool.

Class name of the node entity. If set to true, will actually create node entities. If set to false, node data will be serialized to a JSON key-value.

This is a path node class. May not necessarily be an entity.

Apply this material to the mesh when tying one to this class. Typically used for triggers.

This makes it so the model, skin and bodygroups can be set and changed in Hammer.

The default model to be set to.

The default body group to be set to.

The default material group to be set to.

Marks this entity as a representative of a certain model archetype. This makes this entity class appear in ModelDoc under given archetype(s), which will be used to decide which entity class to use when dragging models from Hammer's Asset browser.

Declare a sprite to represent this entity in Hammer.

[EditorSprite( "editor/ai_goal_follow.vmat" )]

Tells Hammer that this entity has a particle effect keyvalue that needs to be visualized.

Indicate to the map builder that any meshes associated with the entity should have a mesh physics type.

Indicate if the entity is simulated in game and should participate in the pre-settle simulation during map compile. Adds a pre-settle keyvalue to this entity class.

Helper to render skybox in hammer

Used to tell Hammer which automatic Visibility Groups an entity should belong to. See VisGroupAttribute.

Entities that are primarily lights and that sort of thing.

The purpose of these entities is to emit light and not much else.

Pure logic entities, typically not shown in-game.

Any sort of trigger volume, these usually don't show up in-game.

Entities that are related to nav meshes.

The main reason these exist is to create particle systems.

Physics enabled entities.

Entities that do not move via physics but are still intractable with or otherwise non static.

Makes the entity show up under given automatic visibility group in Hammer.

Draws the movement direction in Hammer.

[DrawAngles( "movedir", "movedir_islocal" )]

Draws the door movement and the final open position in Hammer.

Adds the render color and other related options to the entity class in Hammer.

[RenderFields]

Draws a frustum that doesn't contribute to bounds calculations.

Displays a sphere in Hammer with a radius tied to given property and with given color. The sphere's radius can be manipulated in Hammer's 2D views. You can have multiple of these.

If set to true, the sphere will appear as 3 circles in 3D view, rather than a wireframe sphere.

Name of the variable to use as sphere radius. Color as an unsigned integer. For example 0xFF99CC, where 0xBBGGRR. If this helper should show up when only 1 object is selected in Hammer. Name of the variable to use as sphere radius. Color as an unsigned integer. For example 0xFF99CC, where 0xBBGGRR. If this helper should show up when only 1 object is selected in Hammer. Name of the variable to use as sphere radius. Red component of the sphere's color. Green component of the sphere's color. Blue component of the sphere's color. If this helper should show up when only 1 object is selected in Hammer. Range of the sphere to show. Red component of the sphere's color. Green component of the sphere's color. Blue component of the sphere's color. If this helper should show up when only 1 object is selected in Hammer.

Displays text in Hammer on the entity.

The text to display. The name of the property that will act as the position of the text. Whether the position from the variable should be interpreted in world space (true) or in local space (false).

Draws a line in Hammer. You can have multiple of this attribute.

Draws lines between this entity and all entities which have a key named 'startKey' and its value matches the value of our 'startKeyValue'.

Name of the key to search on other entities. This typically will be 'targetname'. Name of our key whose value will be used to match other entities. Only draw the line when the entity is selected.

Draws lines between all entities, starting from each entity that has a key named 'startKey' and its value matches the value of our 'startKeyValue' and going to each entity that has a key named endKey with a value of 'endKeyValue's value.

Name of the key to search on other entities. This typically will be 'targetname'. Name of our key whose value will be used to match other entities. Name of the key to search on other entities. Name of our key whose value will be used to match other entities. Only draw the line when the entity is selected.

Draws a line in Hammer from the entity's origin to a point that can be moved with a gizmo and is stored in this property.

Write local to entity coordinates to the provided key. Default is to write in world space.

For point entities without visualization (model/sprite), sets the size of the box the entity will appear as in Hammer.

Creates a resizable box helper in Hammer which outputs the size of the bounding box defined by the level designer into given keys/properties. You can have multiple of this attribute.

Key (classname) of the entity to store the "Mins" of the bounding box.

Key (classname) of the entity to store the "Maxs" of the bounding box.

Key (classname) of the entity to store the bounding box as an "extents". This replaces and and assumes the entity is in the middle of the bounds. The output value will be the total size of the bounds on each axis.

Always move the entity to the center of the bounds.

Make the bounds AABB (true), not OBB (false). Basically ignores rotation.

Creates a box helper that outputs the size of the bounding box defined by the level designer as mins and maxs

The internal key name to output "mins" size to. The internal key name to output "maxs" size to. If set to true, editing this box in Hammer will automatically move the entity to the center of the box. If set, the helper box will ignore entity rotation.

Creates a box helper that outputs the size of the bounding box defined by the level designer as extents (maxs - mins). This assumes the entity is in the center of the box.

The internal key name to output "extents" size to. This is the result of (maxs - mins). If set, the helper box will ignore entity rotation.

Creates a resizable box helper that represents an orthographic projection from the entity's origin in Hammer. The size of the bounding box as defined by the level designer is put into given keys/properties.

Adds a property in Hammer that dictates whether the entity will be spawned on server or client.

Makes value of this property appear in the Source File column of the Entity Report dialog in Hammer. There can be only one of such properties.

Internally marks this class in Hammer as a post processing entity for preview purposes.

Internally marks this class in Hammer as a tonemap entity for preview purposes.

Internally marks this class in Hammer as a light.

The light_spot visualizer.

Marks this entity as global, there should only be one entity with this global name in the map. Used internally for Preview purposes.

Adds a simple parameterless helper to the entity class.

Used by light_environment entity internally.

Allows hammer to bake resources, mostly used for cubemaps and light probes

Write a file to the path relative to the scene folder, return the path relative to the root.

Hide a property if a condition matches.

The test condition.

The class instance of the property this attribute is attached to. Description of the 's type. Return true if the property should be visible.

Hide this property if a given property within the same class has the given value. Used typically in the Editor Inspector.

Property name to test.

Property value to test against.

Show this property if a given property within the same class has the given value. Used typically in the Editor Inspector.

Validates a property using a method.

Specifies a method in the same class to use for validation.

Name of the validation method in the current class Message to display when validation fails severity level to use when validation fails


            [Validate(nameof(IsLineMaterial), "Material should derive from 'line.shader'.", LogLevel.Warn)]
            public Material Material { get; set; }
            
            private bool IsLineMaterial(Material material)
            {
                return material != null && material.Shader.Name.Contains("line.shader");
            }

Specifies a static method in another class to use for validation.

The type containing the static validation method Name of the static validation method Message to display when validation fails severity level to use when validation fails


            [Validate(typeof(MaterialValidators), nameof(MaterialValidators.IsLineMaterial), "Material should derive from 'line.shader'.", LogLevel.Warn)]
            public Material Material { get; set; }
            
            // In MaterialValidators.cs
            public static class MaterialValidators
            {
                public static bool IsLineMaterial(Material material)
                {
                    return material != null && material.Shader.Name.Contains("line.shader");
                }
            }

Validates a property value using the specified method.

@defgroup crowd Crowd Members in this module implement local steering and dynamic avoidance features. The crowd is the big beast of the navigation features. It not only handles a lot of the path management for you, but also local steering and dynamic avoidance between members of the crowd. I.e. It can keep your agents from running into each other. Main class: #dtCrowd The #dtNavMeshQuery and #dtPathCorridor classes provide perfectly good, easy to use path planning features. But in the end they only give you points that your navigation client should be moving toward. When it comes to deciding things like agent velocity and steering to avoid other agents, that is up to you to implement. Unless, of course, you decide to use #dtCrowd. Basically, you add an agent to the crowd, providing various configuration settings such as maximum speed and acceleration. You also provide a local target to more toward. The crowd manager then provides, with every update, the new agent position and velocity for the frame. The movement will be constrained to the navigation mesh, and steering will be applied to ensure agents managed by the crowd do not collide with each other. This is very powerful feature set. But it comes with limitations. The biggest limitation is that you must give control of the agent's position completely over to the crowd manager. You can update things like maximum speed and acceleration. But in order for the crowd manager to do its thing, it can't allow you to constantly be giving it overrides to position and velocity. So you give up direct control of the agent's movement. It belongs to the crowd. The second biggest limitation revolves around the fact that the crowd manager deals with local planning. So the agent's target should never be more than 256 polygons aways from its current position. If it is, you risk your agent failing to reach its target. So you may still need to do long distance planning and provide the crowd manager with intermediate targets. Other significant limitations: - All agents using the crowd manager will use the same #dtQueryFilter. - Crowd management is relatively expensive. The maximum agents under crowd management at any one time is between 20 and 30. A good place to start is a maximum of 25 agents for 0.5ms per frame. @note This is a summary list of members. Use the index or search feature to find minor members. @struct dtCrowdAgentParams @see dtCrowdAgent, dtCrowd::addAgent(), dtCrowd::updateAgentParameters() @var dtCrowdAgentParams::obstacleAvoidanceType @par #dtCrowd permits agents to use different avoidance configurations. This value is the index of the #dtObstacleAvoidanceParams within the crowd. @see dtObstacleAvoidanceParams, dtCrowd::setObstacleAvoidanceParams(), dtCrowd::getObstacleAvoidanceParams() @var dtCrowdAgentParams::collisionQueryRange @par Collision elements include other agents and navigation mesh boundaries. This value is often based on the agent radius and/or maximum speed. E.g. radius * 8 @var dtCrowdAgentParams::separationWeight @par A higher value will result in agents trying to stay farther away from each other at the cost of more difficult steering in tight spaces. Provides local steering behaviors for a group of agents. @ingroup crowd Sets the shared avoidance configuration for the specified index. @param[in] idx The index. [Limits: 0 <= value < #DT_CROWD_MAX_OBSTAVOIDANCE_PARAMS] @param[in] option The new configuration. Gets the shared avoidance configuration for the specified index. @param[in] idx The index of the configuration to retreive. [Limits: 0 <= value < #DT_CROWD_MAX_OBSTAVOIDANCE_PARAMS] @return The requested configuration. Updates the specified agent's configuration. @param[in] idx The agent index. [Limits: 0 <= value < #GetAgentCount()] @param[in] params The new agent configuration. @par The agent's position will be constrained to the surface of the navigation mesh. Adds a new agent to the crowd. @param[in] pos The requested position of the agent. [(x, y, z)] @param[in] params The configuration of the agent. @return The index of the agent in the agent pool. Or -1 if the agent could not be added. Submits a new move request for the specified agent. @param[in] idx The agent index. [Limits: 0 <= value < #GetAgentCount()] @param[in] ref The position's polygon reference. @param[in] pos The position within the polygon. [(x, y, z)] @return True if the request was successfully submitted. This method is used when a new target is set. The position will be constrained to the surface of the navigation mesh. The request will be processed during the next #Update(). Submits a new move request for the specified agent. @param[in] idx The agent index. [Limits: 0 <= value < #GetAgentCount()] @param[in] vel The movement velocity. [(x, y, z)] @return True if the request was successfully submitted. Resets any request for the specified agent. @param[in] idx The agent index. [Limits: 0 <= value < #GetAgentCount()] @return True if the request was successfully reseted. Gets the active agents int the agent pool. @return List of active agents Represents an agent managed by a #dtCrowd object. @ingroup crowd The type of mesh polygon the agent is traversing. (See: #CrowdAgentState) True if the agent has valid path (targetState == DT_CROWDAGENT_TARGET_VALID) and the path does not lead to the requested position, else false. The path corridor the agent is using. The local boundary data for the agent. Time since the agent's path corridor was optimized. The known neighbors of the agent. The number of neighbors. The desired speed. The agent's configuration parameters. The local path corridor corners for the agent. The number of corners. Configuration parameters for a crowd agent. @ingroup crowd Defines how close a collision element must be before it is considered for steering behaviors. [Limits: > 0] How aggresive the agent manager should be at avoiding collisions with this agent. [Limit: >= 0] the agent path. Flags that impact steering behavior. (See: #UpdateFlags) The index of the avoidance configuration to use for the agent. [Limits: 0 <= value < #DT_CROWD_MAX_OBSTAVOIDANCE_PARAMS] User defined data attached to the agent. The type of navigation mesh polygon the agent is currently traversing. @ingroup crowd Crowd agent update flags. @ingroup crowd @see dtCrowdAgentParams::updateFlags The maximum number of neighbors that a crowd agent can take into account for steering decisions. @ingroup crowd The maximum number of corners a crowd agent will look ahead in the path. This value is used for sizing the crowd agent corner buffers. Due to the behavior of the crowd manager, the actual number of useful corners will be one less than this number. @ingroup crowd The maximum number of crowd avoidance configurations supported by the crowd manager. @ingroup crowd @see dtObstacleAvoidanceParams, dtCrowd::SetObstacleAvoidanceParams(), dtCrowd::GetObstacleAvoidanceParams(), dtCrowdAgentParams::obstacleAvoidanceType The maximum number of query filter types supported by the crowd manager. @ingroup crowd @see dtQueryFilter, dtCrowd::GetFilter() dtCrowd::GetEditableFilter(), dtCrowdAgentParams::queryFilterType Provides neighbor data for agents managed by the crowd. @ingroup crowd @see dtCrowdAgent::neis, dtCrowd

Bias applied to favor the desired velocity directly; remaining portion defines exploration radius. Range [0,1]. Higher values stick closer to desired velocity before avoidance.

Weight applied to deviation from desired velocity (steering objective). Higher values prioritize matching the desired velocity.

Weight applied to deviation from current velocity (inertia preservation). Higher values reduce abrupt changes in movement.

Weight applied to the side bias heuristic (preference for passing direction). Helps pick routes that reduce future collisions.

Weight applied to time-of-impact (earlier collisions => higher penalty). Drives strong avoidance of imminent collisions.

Time horizon (seconds) considered when predicting collisions. Longer horizons lead to more conservative velocity choices.

Resolution of the uniform grid sampler (number of cells per axis). Larger values increase sampling density and cost.

Number of angular divisions for adaptive sampling rings (pattern density).

Number of concentric rings used in adaptive sampling.

Number of refinement iterations performed during adaptive sampling.

Calculate the collision penalty for a given velocity vector @param vcand sampled velocity @param dvel desired velocity @param minPenalty threshold penalty for early out < Max number of adaptive rings. Position of the obstacle Velocity of the obstacle Velocity of the obstacle Radius of the obstacle Use for side selection during sampling. Use for side selection during sampling. End points of the obstacle segment End points of the obstacle segment Represents a dynamic polygon corridor used to plan agent movement. @ingroup crowd, detour @class dtPathCorridor @par The corridor is loaded with a path, usually obtained from a #dtNavMeshQuery::findPath() query. The corridor is then used to plan local movement, with the corridor automatically updating as needed to deal with inaccurate agent locomotion. Example of a common use case: -# Construct the corridor object and call #init() to allocate its path buffer. -# Obtain a path from a #dtNavMeshQuery object. -# Use #reset() to set the agent's current position. (At the beginning of the path.) -# Use #setCorridor() to load the path and target. -# Use #findCorners() to plan movement. (This handles dynamic path straightening.) -# Use #movePosition() to feed agent movement back into the corridor. (The corridor will automatically adjust as needed.) -# If the target is moving, use #moveTargetPosition() to update the end of the corridor. (The corridor will automatically adjust as needed.) -# Repeat the previous 3 steps to continue to move the agent. The corridor position and target are always constrained to the navigation mesh. One of the difficulties in maintaining a path is that floating point errors, locomotion inaccuracies, and/or local steering can result in the agent crossing the boundary of the path corridor, temporarily invalidating the path. This class uses local mesh queries to detect and update the corridor as needed to handle these types of issues. The fact that local mesh queries are used to move the position and target locations results in two beahviors that need to be considered: Every time a move function is used there is a chance that the path will become non-optimial. Basically, the further the target is moved from its original location, and the further the position is moved outside the original corridor, the more likely the path will become non-optimal. This issue can be addressed by periodically running the #optimizePathTopology() methods. All local mesh queries have distance limitations. (Review the #dtNavMeshQuery methods for details.) So the most accurate use case is to move the position and target in small increments. If a large increment is used, then the corridor may not be able to accurately find the new location. Because of this limiation, if a position is moved in a large increment, then compare the desired and resulting polygon references. If the two do not match, then path replanning may be needed. E.g. If you move the target, check #getLastPoly() to see if it is the expected polygon. @par @warning Cannot be called more than once. Allocates the corridor's path buffer. @param[in] maxPath The maximum path size the corridor can handle. @return True if the initialization succeeded. @par Essentially, the corridor is set of one polygon in size with the target equal to the position. Resets the path corridor to the specified position. @param[in] ref The polygon reference containing the position. @param[in] pos The new position in the corridor. [(x, y, z)] @par This is the function used to plan local movement within the corridor. One or more corners can be detected in order to plan movement. It performs essentially the same function as #dtNavMeshQuery::findStraightPath. Due to internal optimizations, the maximum number of corners returned will be (@p maxCorners - 1) For example: If the buffers are sized to hold 10 corners, the function will never return more than 9 corners. So if 10 corners are needed, the buffers should be sized for 11 corners. If the target is within range, it will be the last corner and have a polygon reference id of zero. Finds the corners in the corridor from the position toward the target. (The straightened path.) @param[out] cornerVerts The corner vertices. [(x, y, z) * cornerCount] [Size: <= maxCorners] @param[out] cornerFlags The flag for each corner. [(flag) * cornerCount] [Size: <= maxCorners] @param[out] cornerPolys The polygon reference for each corner. [(polyRef) * cornerCount] [Size: <= @p maxCorners] @param[in] maxCorners The maximum number of corners the buffers can hold. @param[in] navquery The query object used to build the corridor. @param[in] filter The filter to apply to the operation. @return The number of corners returned in the corner buffers. [0 <= value <= @p maxCorners] @par Inaccurate locomotion or dynamic obstacle avoidance can force the agent position significantly outside the original corridor. Over time this can result in the formation of a non-optimal corridor. This function will use a local area path search to try to re-optimize the corridor. The more inaccurate the agent movement, the more beneficial this function becomes. Simply adjust the frequency of the call to match the needs to the agent. Attempts to optimize the path using a local area search. (Partial replanning.) @param[in] navquery The query object used to build the corridor. @param[in] filter The filter to apply to the operation. @par Behavior: - The movement is constrained to the surface of the navigation mesh. - The corridor is automatically adjusted (shorted or lengthened) in order to remain valid. - The new position will be located in the adjusted corridor's first polygon. The expected use case is that the desired position will be 'near' the current corridor. What is considered 'near' depends on local polygon density, query search half extents, etc. The resulting position will differ from the desired position if the desired position is not on the navigation mesh, or it can't be reached using a local search. Moves the position from the current location to the desired location, adjusting the corridor as needed to reflect the change. @param[in] npos The desired new position. [(x, y, z)] @param[in] navquery The query object used to build the corridor. @param[in] filter The filter to apply to the operation. @return Returns true if move succeeded. @par Behavior: - The movement is constrained to the surface of the navigation mesh. - The corridor is automatically adjusted (shorted or lengthened) in order to remain valid. - The new target will be located in the adjusted corridor's last polygon. The expected use case is that the desired target will be 'near' the current corridor. What is considered 'near' depends on local polygon density, query search half extents, etc. The resulting target will differ from the desired target if the desired target is not on the navigation mesh, or it can't be reached using a local search. Moves the target from the curent location to the desired location, adjusting the corridor as needed to reflect the change. @param[in] npos The desired new target position. [(x, y, z)] @param[in] navquery The query object used to build the corridor. @param[in] filter The filter to apply to the operation. @return Returns true if move succeeded. @par The current corridor position is expected to be within the first polygon in the path. The target is expected to be in the last polygon. @warning The size of the path must not exceed the size of corridor's path buffer set during #init(). Loads a new path and target into the corridor. @param[in] target The target location within the last polygon of the path. [(x, y, z)] @param[in] path The path corridor. [(polyRef) * @p npolys] @param[in] npath The number of polygons in the path. @par The path can be invalidated if there are structural changes to the underlying navigation mesh, or the state of a polygon within the path changes resulting in it being filtered out. (E.g. An exclusion or inclusion flag changes.) Checks the current corridor path to see if its polygon references remain valid. @param[in] maxLookAhead The number of polygons from the beginning of the corridor to search. @param[in] navquery The query object used to build the corridor. @param[in] filter The filter to apply to the operation. Gets the current position within the corridor. (In the first polygon.) @return The current position within the corridor. Gets the current target within the corridor. (In the last polygon.) @return The current target within the corridor. The polygon reference id of the first polygon in the corridor, the polygon containing the position. @return The polygon reference id of the first polygon in the corridor. (Or zero if there is no path.) The polygon reference id of the last polygon in the corridor, the polygon containing the target. @return The polygon reference id of the last polygon in the corridor. (Or zero if there is no path.) The corridor's path. @return The corridor's path. [(polyRef) * #getPathCount()] The number of polygons in the current corridor path. @return The number of polygons in the current corridor path. Path find start and end location. Segment start/end Distance for pruning. Bounding volume node. @note This structure is rarely if ever used by the end user. @see dtMeshTile The maximum number of vertices per navigation polygon. @ingroup detour A magic number used to detect compatibility of navigation tile data. A version number used to detect compatibility of navigation tile data. A magic number used to detect the compatibility of navigation tile states. A version number used to detect compatibility of navigation tile states. A flag that indicates that an entity links to an external entity. (E.g. A polygon edge is a portal that links to another polygon.) A value that indicates the entity does not link to anything. The maximum number of user defined area ids. Limit raycasting during any angle pahfinding The limit is given as a multiple of the character radius @{ @name Encoding and Decoding These functions are generally meant for internal use only. Derives a standard polygon reference. @note This function is generally meant for internal use only. @param[in] salt The tile's salt value. @param[in] it The index of the tile. @param[in] ip The index of the polygon within the tile. Decodes a standard polygon reference. @note This function is generally meant for internal use only. @param[in] ref The polygon reference to decode. @param[out] salt The tile's salt value. @param[out] it The index of the tile. @param[out] ip The index of the polygon within the tile. @see #encodePolyId Extracts a tile's salt value from the specified polygon reference. @note This function is generally meant for internal use only. @param[in] ref The polygon reference. @see #encodePolyId Extracts the tile's index from the specified polygon reference. @note This function is generally meant for internal use only. @param[in] ref The polygon reference. @see #encodePolyId Extracts the polygon's index (within its tile) from the specified polygon reference. @note This function is generally meant for internal use only. @param[in] ref The polygon reference. @see #encodePolyId Get flags for edge in detail triangle. @param[in] triFlags The flags for the triangle (last component of detail vertices above). @param[in] edgeIndex The index of the first vertex of the edge. For instance, if 0, returns flags for edge AB. Options for dtNavMeshQuery::initSlicedFindPath and updateSlicedFindPath Defines a link between polygons. @note This structure is rarely if ever used by the end user. @see dtMeshTile The tile bounding volume nodes. [Size: dtMeshHeader::bvNodeCount] (Will be null if bounding volumes are disabled.) Provides high level information related to a dtMeshTile object. Tile magic number. (Used to identify the data format.) Tile data format version number. The x-position of the tile within the dtNavMesh tile grid. (x, y, layer) The y-position of the tile within the dtNavMesh tile grid. (x, y, layer) The layer of the tile within the dtNavMesh tile grid. (x, y, layer) The user defined id of the tile. The number of polygons in the tile. The number of vertices in the tile. The number of allocated links. The number of bounding volume nodes. (Zero if bounding volumes are disabled.) The number of off-mesh connections. The index of the first polygon which is an off-mesh connection. The height of the agents using the tile. The radius of the agents using the tile. The maximum climb height of the agents using the tile. The minimum bounds of the tile's AABB. [(x, y, z)] The maximum bounds of the tile's AABB. [(x, y, z)] The bounding volume quantization factor. Defines a navigation mesh tile. @ingroup detour A navigation mesh based on tiles of convex polygons. @ingroup detour The maximum number of vertices per navigation polygon. The maximum number of tiles supported by the navigation mesh. @return The maximum number of tiles supported by the navigation mesh. Returns pointer to tile in the tile array. Gets the polygon reference for the tile's base polygon. @param[in] tile The tile. @return The polygon reference for the base polygon in the specified tile. Calculates the tile grid location for the specified world position. @param[in] pos The world position for the query. [(x, y, z)] @param[out] tx The tile's x-location. (x, y) @param[out] ty The tile's y-location. (x, y) Gets the tile and polygon for the specified polygon reference. @param[in] ref The reference for the a polygon. @param[out] tile The tile containing the polygon. @param[out] poly The polygon. @return The status flags for the operation. @par @warning Only use this function if it is known that the provided polygon reference is valid. This function is faster than #getTileAndPolyByRef, but it does not validate the reference. Returns the tile and polygon for the specified polygon reference. @param[in] ref A known valid reference for a polygon. @param[out] tile The tile containing the polygon. @param[out] poly The polygon. Checks the validity of a polygon reference. @param[in] ref The polygon reference to check. @return True if polygon reference is valid for the navigation mesh. Queries polygons within a tile. @par The add operation will fail if the data is in the wrong format, the allocated tile space is full, or there is a tile already at the specified reference. The lastRef parameter is used to restore a tile with the same tile reference it had previously used. In this case the #dtPolyRef's for the tile will be restored to the same values they were before the tile was removed. The nav mesh assumes exclusive access to the data passed and will make changes to the dynamic portion of the data. For that reason the data should not be reused in other nav meshes until the tile has been successfully removed from this nav mesh. @see dtCreateNavMeshData, #removeTile Adds a tile to the navigation mesh. @param[in] data Data for the new tile mesh. (See: #dtCreateNavMeshData) @param[in] dataSize Data size of the new tile mesh. @param[in] flags Tile flags. (See: #dtTileFlags) @param[in] lastRef The desired reference for the tile. (When reloading a tile.) [opt] [Default: 0] @param[out] result The tile reference. (If the tile was succesfully added.) [opt] @return The status flags for the operation. Removes the specified tile from the navigation mesh. @param[in] ref The reference of the tile to remove. @param[out] data Data associated with deleted tile. @param[out] dataSize Size of the data associated with deleted tile. This function returns the data for the tile so that, if desired, it can be added back to the navigation mesh at a later point. @see #addTile Builds internal polygons links for a tile. Removes external links at specified side. Builds external polygon links for a tile. Builds external polygon links for a tile. Returns all polygons in neighbour tile based on portal defined by the segment. Builds internal polygons links for a tile. Returns closest point on polygon. @param ref @param pos @return Find nearest polygon within a tile. Returns neighbour tile based on side. Returns neighbour tile based on side. Gets the endpoints for an off-mesh connection, ordered by "direction of travel". @param[in] prevRef The reference of the polygon before the connection. @param[in] polyRef The reference of the off-mesh connection polygon. @param[out] startPos The start position of the off-mesh connection. [(x, y, z)] @param[out] endPos The end position of the off-mesh connection. [(x, y, z)] @return The status flags for the operation. @par Off-mesh connections are stored in the navigation mesh as special 2-vertex polygons with a single edge. At least one of the vertices is expected to be inside a normal polygon. So an off-mesh connection is "entered" from a normal polygon at one of its endpoints. This is the polygon identified by the prevRef parameter. Sets the user defined area for the specified polygon. @param[in] ref The polygon reference. @param[in] area The new area id for the polygon. [Limit: DT_MAX_AREAS] @return The status flags for the operation. Gets the user defined area for the specified polygon. @param[in] ref The polygon reference. @param[out] resultArea The area id for the polygon. @return The status flags for the operation. @par The output data array is allocated using the detour allocator (dtAlloc()). The method used to free the memory will be determined by how the tile is added to the navigation mesh. @see dtNavMesh, dtNavMesh::addTile() Represents the source data used to build an navigation mesh tile. @ingroup detour @} @name Off-Mesh Connections Attributes (Optional) Used to define a custom point-to-point edge within the navigation graph, an off-mesh connection is a user defined traversable connection made up to two vertices, at least one of which resides within a navigation mesh polygon. @{ Off-mesh connection vertices. [(ax, ay, az, bx, by, bz) * #offMeshConCount] [Unit: wu] Off-mesh connection radii. [Size: #offMeshConCount] [Unit: wu] User defined area ids assigned to the off-mesh connections. [Size: #offMeshConCount] The permitted travel direction of the off-mesh connections. [Size: #offMeshConCount] The user defined ids of the off-mesh connection. [Size: #offMeshConCount] The number of off-mesh connections. [Limit: >= 0] @} @name Tile Attributes @note The tile grid/layer data can be left at zero if the destination is a single tile mesh. @{ @} @name General Configuration Attributes @{ True if a bounding volume tree should be built for the tile. @note The BVTree is not normally needed for layered navigation meshes. Configuration parameters used to define multi-tile navigation meshes. The values are used to allocate space during the initialization of a navigation mesh. @see dtNavMesh::init() @ingroup detour Provides the ability to perform pathfinding related queries against a navigation mesh. @ingroup detour @class dtNavMeshQuery For methods that support undersized buffers, if the buffer is too small to hold the entire result set the return status of the method will include the #DT_BUFFER_TOO_SMALL flag. Constant member functions can be used by multiple clients without side effects. (E.g. No change to the closed list. No impact on an in-progress sliced path query. Etc.) Walls and portals: A @e wall is a polygon segment that is considered impassable. A @e portal is a passable segment between polygons. A portal may be treated as a wall based on the dtQueryFilter used for a query. @see dtNavMesh, dtQueryFilter, #dtAllocNavMeshQuery(), #dtAllocNavMeshQuery() Returns random location on navmesh. Polygons are chosen weighted by area. The search runs in linear related to number of polygon. @param[in] filter The polygon filter to apply to the query. @param[in] frand Function returning a random number [0..1). @param[out] randomRef The reference id of the random location. @param[out] randomPt The random location. @returns The status flags for the query. Returns random location on navmesh within the reach of specified location. Polygons are chosen weighted by area. The search runs in linear related to number of polygon. The location is not exactly constrained by the circle, but it limits the visited polygons. @param[in] startRef The reference id of the polygon where the search starts. @param[in] centerPos The center of the search circle. [(x, y, z)] @param[in] maxRadius The radius of the search circle. [Units: wu] @param[in] filter The polygon filter to apply to the query. @param[in] frand Function returning a random number [0..1). @param[out] randomRef The reference id of the random location. @param[out] randomPt The random location. [(x, y, z)] @returns The status flags for the query. Returns random location on navmesh within the reach of specified location. Polygons are chosen weighted by area. The search runs in linear related to number of polygon. The location is strictly constrained by the circle. @param startRef The reference id of the polygon where the search starts. @param centerPos The center of the search circle. [(x, y, z)] @param maxRadius @param filter The polygon filter to apply to the query. @param frand Function returning a random number [0..1). @return Random location Returns random location on navmesh within the reach of specified location. Polygons are chosen weighted by area. The search runs in linear related to number of polygon. The location is not exactly constrained by the circle, but it limits the visited polygons. @param[in] startRef The reference id of the polygon where the search starts. @param[in] centerPos The center of the search circle. [(x, y, z)] @param[in] maxRadius The radius of the search circle. [Units: wu] @param[in] filter The polygon filter to apply to the query. @param[in] frand Function returning a random number [0..1). @param[in] constraint @param[out] randomRef The reference id of the random location. @param[out] randomPt The random location. [(x, y, z)] @returns The status flags for the query. @par Uses the detail polygons to find the surface height. (Most accurate.) @p pos does not have to be within the bounds of the polygon or navigation mesh. See closestPointOnPolyBoundary() for a limited but faster option. Finds the closest point on the specified polygon. @param[in] ref The reference id of the polygon. @param[in] pos The position to check. [(x, y, z)] @param[out] closest The closest point on the polygon. [(x, y, z)] @param[out] posOverPoly True of the position is over the polygon. @returns The status flags for the query. @par Much faster than ClosestPointOnPoly(). If the provided position lies within the polygon's xz-bounds (above or below), then @p pos and @p closest will be equal. The height of @p closest will be the polygon boundary. The height detail is not used. @p pos does not have to be within the bounds of the polybon or the navigation mesh. Returns a point on the boundary closest to the source point if the source point is outside the polygon's xz-bounds. @param[in] ref The reference id to the polygon. @param[in] pos The position to check. [(x, y, z)] @param[out] closest The closest point. [(x, y, z)] @returns The status flags for the query. @par Will return #DT_FAILURE if the provided position is outside the xz-bounds of the polygon. Gets the height of the polygon at the provided position using the height detail. (Most accurate.) @param[in] ref The reference id of the polygon. @param[in] pos A position within the xz-bounds of the polygon. [(x, y, z)] @param[out] height The height at the surface of the polygon. @returns The status flags for the query. Finds the polygon nearest to the specified center point. [opt] means the specified parameter can be a null pointer, in that case the output parameter will not be set. @param[in] center The center of the search box. [(x, y, z)] @param[in] halfExtents The search distance along each axis. [(x, y, z)] @param[in] filter The polygon filter to apply to the query. @param[out] nearestRef The reference id of the nearest polygon. Will be set to 0 if no polygon is found. @param[out] nearestPt The nearest point on the polygon. Unchanged if no polygon is found. [opt] [(x, y, z)] @param[out] isOverPoly Set to true if the point's X/Z coordinate lies inside the polygon, false otherwise. Unchanged if no polygon is found. [opt] @returns The status flags for the query. Queries polygons within a tile. @par If no polygons are found, the function will return #DT_SUCCESS with a @p polyCount of zero. If @p polys is too small to hold the entire result set, then the array will be filled to capacity. The method of choosing which polygons from the full set are included in the partial result set is undefined. Finds polygons that overlap the search box. @param[in] center The center of the search box. [(x, y, z)] @param[in] halfExtents The search distance along each axis. [(x, y, z)] @param[in] filter The polygon filter to apply to the query. @param[out] polys The reference ids of the polygons that overlap the query box. @param[out] polyCount The number of polygons in the search result. @param[in] maxPolys The maximum number of polygons the search result can hold. @returns The status flags for the query. @par The query will be invoked with batches of polygons. Polygons passed to the query have bounding boxes that overlap with the center and halfExtents passed to this function. The dtPolyQuery::process function is invoked multiple times until all overlapping polygons have been processed. Finds polygons that overlap the search box. @param[in] center The center of the search box. [(x, y, z)] @param[in] halfExtents The search distance along each axis. [(x, y, z)] @param[in] filter The polygon filter to apply to the query. @param[in] query The query. Polygons found will be batched together and passed to this query. @par If the end polygon cannot be reached through the navigation graph, the last polygon in the path will be the nearest the end polygon. If the path array is to small to hold the full result, it will be filled as far as possible from the start polygon toward the end polygon. The start and end positions are used to calculate traversal costs. (The y-values impact the result.) @name Standard Pathfinding Functions @{ Finds a path from the start polygon to the end polygon. @param[in] startRef The reference id of the start polygon. @param[in] endRef The reference id of the end polygon. @param[in] startPos A position within the start polygon. [(x, y, z)] @param[in] endPos A position within the end polygon. [(x, y, z)] @param[in] filter The polygon filter to apply to the query. @param[out] path An ordered list of polygon references representing the path. (Start to end.) [(polyRef) * @p pathCount] @param[out] pathCount The number of polygons returned in the @p path array. @param[in] maxPath The maximum number of polygons the @p path array can hold. [Limit: >= 1] @} @name Sliced Pathfinding Functions Common use case: -# Call initSlicedFindPath() to initialize the sliced path query. -# Call updateSlicedFindPath() until it returns complete. -# Call finalizeSlicedFindPath() to get the path. @{ Initializes a sliced path query. @param[in] startRef The reference id of the start polygon. @param[in] endRef The reference id of the end polygon. @param[in] startPos A position within the start polygon. [(x, y, z)] @param[in] endPos A position within the end polygon. [(x, y, z)] @param[in] filter The polygon filter to apply to the query. @param[in] options query options (see: #dtFindPathOptions) @returns The status flags for the query. Updates an in-progress sliced path query. @param[in] maxIter The maximum number of iterations to perform. @param[out] doneIters The actual number of iterations completed. [opt] @returns The status flags for the query. Finalizes and returns the results of a sliced path query. @param[out] path An ordered list of polygon references representing the path. (Start to end.) [(polyRef) * @p pathCount] @param[out] pathCount The number of polygons returned in the @p path array. @param[in] maxPath The max number of polygons the path array can hold. [Limit: >= 1] @returns The status flags for the query. Finalizes and returns the results of an incomplete sliced path query, returning the path to the furthest polygon on the existing path that was visited during the search. @param[in] existing An array of polygon references for the existing path. @param[in] existingSize The number of polygon in the @p existing array. @param[out] path An ordered list of polygon references representing the path. (Start to end.) [(polyRef) * @p pathCount] @param[out] pathCount The number of polygons returned in the @p path array. @param[in] maxPath The max number of polygons the @p path array can hold. [Limit: >= 1] @returns The status flags for the query. @par This method peforms what is often called 'string pulling'. The start position is clamped to the first polygon in the path, and the end position is clamped to the last. So the start and end positions should normally be within or very near the first and last polygons respectively. The returned polygon references represent the reference id of the polygon that is entered at the associated path position. The reference id associated with the end point will always be zero. This allows, for example, matching off-mesh link points to their representative polygons. If the provided result buffers are too small for the entire result set, they will be filled as far as possible from the start toward the end position. Finds the straight path from the start to the end position within the polygon corridor. @param[in] startPos Path start position. [(x, y, z)] @param[in] endPos Path end position. [(x, y, z)] @param[in] path An array of polygon references that represent the path corridor. @param[in] pathSize The number of polygons in the @p path array. @param[out] straightPath Points describing the straight path. [(x, y, z) * @p straightPathCount]. @param[in] maxStraightPath The maximum number of points the straight path arrays can hold. [Limit: > 0] @param[in] options Query options. (see: #dtStraightPathOptions) @returns The status flags for the query. @par This method is optimized for small delta movement and a small number of polygons. If used for too great a distance, the result set will form an incomplete path. @p resultPos will equal the @p endPos if the end is reached. Otherwise the closest reachable position will be returned. @p resultPos is not projected onto the surface of the navigation mesh. Use #getPolyHeight if this is needed. This method treats the end position in the same manner as the #raycast method. (As a 2D point.) See that method's documentation for details. If the @p visited array is too small to hold the entire result set, it will be filled as far as possible from the start position toward the end position. Moves from the start to the end position constrained to the navigation mesh. @param[in] startRef The reference id of the start polygon. @param[in] startPos A position of the mover within the start polygon. [(x, y, x)] @param[in] endPos The desired end position of the mover. [(x, y, z)] @param[in] filter The polygon filter to apply to the query. @param[out] resultPos The result position of the mover. [(x, y, z)] @param[out] visited The reference ids of the polygons visited during the move. @param[out] visitedCount The number of polygons visited during the move. @param[in] maxVisitedSize The maximum number of polygons the @p visited array can hold. @returns The status flags for the query. @par This method is meant to be used for quick, short distance checks. If the path array is too small to hold the result, it will be filled as far as possible from the start postion toward the end position. Using the Hit Parameter t of RaycastHit If the hit parameter is a very high value (FLT_MAX), then the ray has hit the end position. In this case the path represents a valid corridor to the end position and the value of @p hitNormal is undefined. If the hit parameter is zero, then the start position is on the wall that was hit and the value of @p hitNormal is undefined. If 0 < t < 1.0 then the following applies: @code distanceToHitBorder = distanceToEndPosition * t hitPoint = startPos + (endPos - startPos) * t @endcode Use Case Restriction The raycast ignores the y-value of the end position. (2D check.) This places significant limits on how it can be used. For example: Consider a scene where there is a main floor with a second floor balcony that hangs over the main floor. So the first floor mesh extends below the balcony mesh. The start position is somewhere on the first floor. The end position is on the balcony. The raycast will search toward the end position along the first floor mesh. If it reaches the end position's xz-coordinates it will indicate FLT_MAX (no wall hit), meaning it reached the end position. This is one example of why this method is meant for short distance checks. Casts a 'walkability' ray along the surface of the navigation mesh from the start position toward the end position. @param[in] startRef The reference id of the start polygon. @param[in] startPos A position within the start polygon representing the start of the ray. [(x, y, z)] @param[in] endPos The position to cast the ray toward. [(x, y, z)] @param[in] filter The polygon filter to apply to the query. @param[in] options govern how the raycast behaves. See dtRaycastOptions @param[out] hit Pointer to a raycast hit structure which will be filled by the results. @param[in] prevRef parent of start ref. Used during for cost calculation [opt] @returns The status flags for the query. @par At least one result array must be provided. The order of the result set is from least to highest cost to reach the polygon. A common use case for this method is to perform Dijkstra searches. Candidate polygons are found by searching the graph beginning at the start polygon. If a polygon is not found via the graph search, even if it intersects the search circle, it will not be included in the result set. For example: polyA is the start polygon. polyB shares an edge with polyA. (Is adjacent.) polyC shares an edge with polyB, but not with polyA Even if the search circle overlaps polyC, it will not be included in the result set unless polyB is also in the set. The value of the center point is used as the start position for cost calculations. It is not projected onto the surface of the mesh, so its y-value will effect the costs. Intersection tests occur in 2D. All polygons and the search circle are projected onto the xz-plane. So the y-value of the center point does not effect intersection tests. If the result arrays are to small to hold the entire result set, they will be filled to capacity. @} @name Dijkstra Search Functions @{ Finds the polygons along the navigation graph that touch the specified circle. @param[in] startRef The reference id of the polygon where the search starts. @param[in] centerPos The center of the search circle. [(x, y, z)] @param[in] radius The radius of the search circle. @param[in] filter The polygon filter to apply to the query. @param[out] resultRef The reference ids of the polygons touched by the circle. [opt] @param[out] resultParent The reference ids of the parent polygons for each result. Zero if a result polygon has no parent. [opt] @param[out] resultCost The search cost from @p centerPos to the polygon. [opt] @param[out] resultCount The number of polygons found. [opt] @param[in] maxResult The maximum number of polygons the result arrays can hold. @returns The status flags for the query. @par The order of the result set is from least to highest cost. At least one result array must be provided. A common use case for this method is to perform Dijkstra searches. Candidate polygons are found by searching the graph beginning at the start polygon. The same intersection test restrictions that apply to findPolysAroundCircle() method apply to this method. The 3D centroid of the search polygon is used as the start position for cost calculations. Intersection tests occur in 2D. All polygons are projected onto the xz-plane. So the y-values of the vertices do not effect intersection tests. If the result arrays are is too small to hold the entire result set, they will be filled to capacity. Finds the polygons along the naviation graph that touch the specified convex polygon. @param[in] startRef The reference id of the polygon where the search starts. @param[in] verts The vertices describing the convex polygon. (CCW) [(x, y, z) * @p nverts] @param[in] nverts The number of vertices in the polygon. @param[in] filter The polygon filter to apply to the query. @param[out] resultRef The reference ids of the polygons touched by the search polygon. [opt] @param[out] resultParent The reference ids of the parent polygons for each result. Zero if a result polygon has no parent. [opt] @param[out] resultCost The search cost from the centroid point to the polygon. [opt] @param[out] resultCount The number of polygons found. @param[in] maxResult The maximum number of polygons the result arrays can hold. @returns The status flags for the query. @par This method is optimized for a small search radius and small number of result polygons. Candidate polygons are found by searching the navigation graph beginning at the start polygon. The same intersection test restrictions that apply to the findPolysAroundCircle mehtod applies to this method. The value of the center point is used as the start point for cost calculations. It is not projected onto the surface of the mesh, so its y-value will effect the costs. Intersection tests occur in 2D. All polygons and the search circle are projected onto the xz-plane. So the y-value of the center point does not effect intersection tests. If the result arrays are is too small to hold the entire result set, they will be filled to capacity. Finds the non-overlapping navigation polygons in the local neighbourhood around the center position. @param[in] startRef The reference id of the polygon where the search starts. @param[in] centerPos The center of the query circle. [(x, y, z)] @param[in] radius The radius of the query circle. @param[in] filter The polygon filter to apply to the query. @param[out] resultRef The reference ids of the polygons touched by the circle. @param[out] resultParent The reference ids of the parent polygons for each result. @returns The status flags for the query. @par If the @p segmentRefs parameter is provided, then all polygon segments will be returned. Otherwise only the wall segments are returned. A segment that is normally a portal will be included in the result set as a wall if the @p filter results in the neighbor polygon becoomming impassable. The @p segmentVerts and @p segmentRefs buffers should normally be sized for the maximum segments per polygon of the source navigation mesh. Returns the segments for the specified polygon, optionally including portals. @param[in] ref The reference id of the polygon. @param[in] filter The polygon filter to apply to the query. @param[out] segmentVerts The segments. [(ax, ay, az, bx, by, bz) * segmentCount] @param[out] segmentRefs The reference ids of each segment's neighbor polygon. Or zero if the segment is a wall. [opt] [(parentRef) * @p segmentCount] @param[out] segmentCount The number of segments returned. @param[in] maxSegments The maximum number of segments the result arrays can hold. @returns The status flags for the query. @par @p hitPos is not adjusted using the height detail data. @p hitDist will equal the search radius if there is no wall within the radius. In this case the values of @p hitPos and @p hitNormal are undefined. The normal will become unpredicable if @p hitDist is a very small number. Finds the distance from the specified position to the nearest polygon wall. @param[in] startRef The reference id of the polygon containing @p centerPos. @param[in] centerPos The center of the search circle. [(x, y, z)] @param[in] maxRadius The radius of the search circle. @param[in] filter The polygon filter to apply to the query. @param[out] hitDist The distance to the nearest wall from @p centerPos. @param[out] hitPos The nearest position on the wall that was hit. [(x, y, z)] @param[out] hitNormal The normalized ray formed from the wall point to the source point. [(x, y, z)] @returns The status flags for the query. Returns true if the polygon reference is valid and passes the filter restrictions. @param[in] ref The polygon reference to check. @param[in] filter The filter to apply. Gets the navigation mesh the query object is using. @return The navigation mesh the query object is using. Gets a path from the explored nodes in the previous search. @param[in] endRef The reference id of the end polygon. @param[out] path An ordered list of polygon references representing the path. (Start to end.) [(polyRef) * @p pathCount] @param[out] pathCount The number of polygons returned in the @p path array. @param[in] maxPath The maximum number of polygons the @p path array can hold. [Limit: >= 0] @returns The status flags. Returns DT_FAILURE | DT_INVALID_PARAM if any parameter is wrong, or if @p endRef was not explored in the previous search. Returns DT_SUCCESS | DT_BUFFER_TOO_SMALL if @p path cannot contain the entire path. In this case it is filled to capacity with a partial path. Otherwise returns DT_SUCCESS. @remarks The result of this function depends on the state of the query object. For that reason it should only be used immediately after one of the two Dijkstra searches, findPolysAroundCircle or findPolysAroundShape. @par The closed list is the list of polygons that were fully evaluated during the last navigation graph search. (A* or Dijkstra) Defines an navigation mesh off-mesh connection within a dtMeshTile object. An off-mesh connection is a user defined traversable connection made up to two vertices. The radius of the endpoints. [Limit: >= 0] The polygon reference of the connection within the tile. End point side. The id of the offmesh connection. (User assigned when the navigation mesh is built.) Defines a polygon within a dtMeshTile object. @ingroup detour Index to first link in linked list. (Or #DT_NULL_LINK if there is no link.) The indices of the polygon's vertices. The actual vertices are located in dtMeshTile::verts. Packed data representing neighbor polygons references and flags for each edge. The number of vertices in the polygon. The area id Polygon type (see: #dtPolyTypes). Defines the location of detail sub-mesh data within a dtMeshTile. Flags representing the type of a navigation mesh polygon. The Default Implementation At construction: All area costs default to 1.0. All flags are included and none are excluded. If a polygon has both an include and an exclude flag, it will be excluded. The way filtering works, a navigation mesh polygon must have at least one flag set to ever be considered by a query. So a polygon with no flags will never be considered. Setting the include flags to 0 will result in all polygons being excluded. Custom Implementations Implement a custom query filter by overriding the virtual PassFilter() and GetCost() functions. If this is done, both functions should be as fast as possible. Use cached local copies of data rather than accessing your own objects where possible. Custom implementations do not need to adhere to the flags or cost logic used by the default implementation. In order for A* searches to work properly, the cost should be proportional to the travel distance. Implementing a cost modifier less than 1.0 is likely to lead to problems during pathfinding. @see NavMeshQuery Provides information about raycast hit filled by dtNavMeshQuery::raycast @ingroup detour The hit parameter. (FLT_MAX if no wall hit.) hitNormal The normal of the nearest wall hit. [(x, y, z)] The index of the edge on the final polygon where the wall was hit. Pointer to an array of reference ids of the visited polygons. [opt] The cost of the path until hit. Options for dtNavMeshQuery::raycast Vertex flags returned by dtNavMeshQuery::findStraightPath. The local path corridor corners for the agent. (Staight path.) [(x, y, z) * #ncorners] The local path corridor corner flags. (See: #dtStraightPathFlags) [(flags) * #ncorners] The reference id of the polygon being entered at the corner. [(polyRef) * #ncorners] Options for dtNavMeshQuery::findStraightPath. Determines if two axis-aligned bounding boxes overlap. @param[in] amin Minimum bounds of box A. [(x, y, z)] @param[in] amax Maximum bounds of box A. [(x, y, z)] @param[in] bmin Minimum bounds of box B. [(x, y, z)] @param[in] bmax Maximum bounds of box B. [(x, y, z)] @return True if the two AABB's overlap. @see dtOverlapBounds Determines if two axis-aligned bounding boxes overlap. @param[in] amin Minimum bounds of box A. [(x, y, z)] @param[in] amax Maximum bounds of box A. [(x, y, z)] @param[in] bmin Minimum bounds of box B. [(x, y, z)] @param[in] bmax Maximum bounds of box B. [(x, y, z)] @return True if the two AABB's overlap. @see dtOverlapQuantBounds @par All vertices are projected onto the xz-plane, so the y-values are ignored. @} @name Computational geometry helper functions. @{ Derives the signed xz-plane area of the triangle ABC, or the relationship of line AB to point C. @param[in] a Vertex A. [(x, y, z)] @param[in] b Vertex B. [(x, y, z)] @param[in] c Vertex C. [(x, y, z)] @return The signed xz-plane area of the triangle. @par All points are projected onto the xz-plane, so the y-values are ignored. Derives the xz-plane 2D perp product of the two vectors. (uz*vx - ux*vz) @param[in] u The LHV vector [(x, y, z)] @param[in] v The RHV vector [(x, y, z)] @return The dot product on the xz-plane. The vectors are projected onto the xz-plane, so the y-values are ignored. TODO should be called DOT2D Provides custom polygon query behavior. Used by dtNavMeshQuery::queryPolygons. @ingroup detour Called for each batch of unique polygons touched by the search area in dtNavMeshQuery::queryPolygons. This can be called multiple times for a single query.

This is a pointer but native pretends like it's a handle/struct using DECLARE_POINTER_HANDLE. We just treat it like a pointer.

Sandbox.AsyncGPUReadback.DispatchManagedReadTextureCallback( ... )

Sandbox.AsyncGPUReadback.DispatchManagedReadBufferCallback( ... )

Sandbox.Audio.MixingThread.MixOneBuffer( ... )

Sandbox.ConVarSystem.RegisterNativeVar( ... )

Sandbox.ConVarSystem.RegisterNativeCommand( ... )

Sandbox.ConVarSystem.OnConVarChanged( ... )

Sandbox.Diagnostics.Logging.RegisterEngineLogger( ... )

Sandbox.Engine.Bootstrap.EnvironmentExit( ... )

Sandbox.Engine.InputRouter.OnMouseMotion( ... )

Sandbox.Engine.InputRouter.OnMousePositionChange( ... )

Sandbox.Engine.InputRouter.OnMouseButton( ... )

Sandbox.Engine.InputRouter.OnKey( ... )

Sandbox.Engine.InputRouter.OnText( ... )

Sandbox.Engine.InputRouter.OnWindowActive( ... )

Sandbox.Engine.InputRouter.OnMouseWheel( ... )

Sandbox.Engine.InputRouter.OnImeStart( ... )

Sandbox.Engine.InputRouter.OnImeComposition( ... )

Sandbox.Engine.InputRouter.OnImeEnd( ... )

Sandbox.Engine.InputRouter.OnGameControllerButton( ... )

Sandbox.Engine.InputRouter.OnGameControllerAxis( ... )

Sandbox.Engine.InputRouter.OnGameControllerConnected( ... )

Sandbox.Engine.InputRouter.OnGameControllerDisconnected( ... )

Sandbox.Engine.InputRouter.OnConsoleCommand( ... )

Sandbox.Engine.InputRouter.CloseApplication( ... )

Sandbox.Engine.SystemInfo.Set( ... )

Sandbox.Engine.SystemInfo.SetGpu( ... )

Sandbox.EngineLoop.Print( ... )

Sandbox.EngineLoop.DispatchConsoleCommand( ... )

Sandbox.EngineLoop.OnClientOutput( ... )

Sandbox.EngineLoop.OnSceneViewSubmitted( ... )

Sandbox.Graphics.OnLayer( ... )

Sandbox.HandleIndex.RegisterHandle( ... )

Sandbox.HandleIndex.FreeHandle( ... )

Sandbox.LobbyManager.OnLobbyInvite( ... )

Sandbox.LobbyManager.OnMemberEntered( ... )

Sandbox.LobbyManager.OnMemberLeave( ... )

Sandbox.LobbyManager.OnEntered( ... )

Sandbox.LobbyManager.OnCreated( ... )

Sandbox.LobbyManager.OnDataUpdate( ... )

Sandbox.LobbyManager.OnChatMessage( ... )

Sandbox.Network.SteamNetwork.OnSocketConnection( ... )

Sandbox.Network.SteamNetwork.OnSocketDisconnection( ... )

Sandbox.Network.SteamNetwork.ShouldAcceptConnection( ... )

Sandbox.Network.SteamNetwork.OnDisconnection( ... )

Sandbox.Network.SteamNetwork.OnSessionEstablished( ... )

Sandbox.Network.SteamNetwork.OnSessionFailed( ... )

Sandbox.Physics.PhysicsEngine.OnPhysicsJointBreak( ... )

Sandbox.Physics.PhysicsEngine.OnActive( ... )

Sandbox.RealTime.Update( ... )

Sandbox.Rendering.RenderPipeline.InternalAddLayersToView( ... )

Sandbox.Rendering.RenderPipeline.InternalPipelineEnd( ... )

Sandbox.Rendering.ShadowMapperCallbacks.InitForView( ... )

Sandbox.Rendering.ShadowMapperCallbacks.SetShaderAttributes( ... )

Sandbox.Rendering.ShadowMapperCallbacks.UploadToGPU( ... )

Sandbox.Rendering.ShadowMapperCallbacks.DoDirectionalLight( ... )

Sandbox.Rendering.ShadowMapperCallbacks.FindOrCreateShadowMaps( ... )

Sandbox.Rendering.Skybox3DPipeline.InternalAddLayersToView( ... )

Sandbox.RenderTarget.Flush( ... )

Sandbox.Resource.OnResourceReloaded( ... )

Sandbox.SceneCustomObjectRender.RenderObject( ... )

Sandbox.SceneSystem.OnBeforeRender( ... )

Sandbox.SceneSystem.OnAfterRender( ... )

Sandbox.Services.Inventory.OnDefinitionUpdate( ... )

Sandbox.Services.Inventory.OnPricesUpdate( ... )

Sandbox.Services.Inventory.OnPurchaseResult( ... )

Sandbox.Services.ServerList.OnStarted( ... )

Sandbox.Services.ServerList.OnServerResponded( ... )

Sandbox.Services.ServerList.OnFinished( ... )

Sandbox.VideoPlayer.OnTextureCreatedInternal( ... )

Sandbox.VideoPlayer.OnInitAudioInternal( ... )

Sandbox.VideoPlayer.OnFreeAudioInternal( ... )

Sandbox.VideoPlayer.OnTextureDataInternal( ... )

Sandbox.VideoPlayer.OnLoadedInternal( ... )

Sandbox.VideoPlayer.WantsTextureData( ... )

Sandbox.VideoPlayer.OnFinishedInternal( ... )

Sandbox.VideoPlayer.OnRepeatedInternal( ... )

Sandbox.VR.VRSystem.InternalIsActive( ... )

Sandbox.VR.VRSystem.BeginFrame( ... )

Sandbox.VR.VRSystem.EndFrame( ... )

Sandbox.VR.VRSystem.Submit( ... )

Sandbox.VR.VRSystem.GetVulkanInstanceExtensionsRequired( ... )

Sandbox.VR.VRSystem.GetVulkanDeviceExtensionsRequired( ... )

Steamworks.Dispatch.OnClientCallback( ... )

An awaitable version of a SteamAPICall_t.

This gets called if IsComplete returned false on the first call. The Action "continues" the async call. We pass it to the Dispatch to be called when the callback returns.

Gets the result. This is called internally by the async shit.

Return true if complete or failed

This is what makes this struct awaitable

Gives us a generic way to get the CallbackId of structs

Responsible for all callback/call result handling. This manually pumps Steam's message queue and dispatches those events to any waiting callbacks/call results.

Called if an exception happens during a callback/call result. This is needed because the exception isn't always accessible when running async.. and can fail silently. With this hooked you won't be stuck wondering what happened.

To be safe we don't call the continuation functions while iterating the Callback list. This is maybe overly safe because the only way this could be an issue is if the callback list is modified in the continuation which would only happen if starting or shutting down in the callback.

A callback is a general global message.

Given a callback, try to turn it into a string

A result is a reply to a specific command

Watch for a Steam API call.

Install a global callback. The passed function will get called if it's all good.

Try to join this room. Will return RoomEnter.Success on success, and anything else is a failure

Leave a lobby; this will take effect immediately on the client side other users in the lobby will be notified by a LobbyChatUpdate_t callback

Invite another user to the lobby will return true if the invite is successfully sent, whether or not the target responds returns false if the local user is not connected to the Steam servers

Invite another user to the lobby

Get current lobby's member count

Returns current members. Need to be in the lobby to see the users.

Get data associated with this lobby

Removes a metadata key from the lobby

Get all data for this lobby

Gets per-user metadata for someone in this lobby

Sets per-user metadata (for the local user implicitly)

Make the request to refresh this lobby data, and hang on till we get a result. Will timeout after 5s and return false.

Max members able to join this lobby. Cannot be over 250. Can only be set by the owner

You must be the lobby owner to set the owner

Check if the specified SteamId owns the lobby

only lobbies in the same immediate region will be returned

Filter by specified key/value pair; string parameters

Numerical filter where value is less than the value provided

Numerical filter where value is greater than the value provided

Numerical filter where value must be equal to the value provided

Numerical filter where value must not equal the value provided

Test key, initialize numerical filter list if necessary, then add new numerical filter

Order filtered results according to key/values nearest the provided key/value pair. Can specify multiple near value filters; each successive filter is lower priority than the previous.

returns only lobbies with the specified number of slots available

sets how many results to return, the lower the count the faster it is to download the lobby results

Run the query, get the matching lobbies

Initialize the steam client.

Check if Steam is loaded and accessible.

Gets the Steam ID of the account currently logged into the Steam client. This is commonly called the 'current user', or 'local user'. A Steam ID is a unique identifier for a Steam accounts, Steam groups, Lobbies and Chat rooms, and used to differentiate users in all parts of the Steamworks API.

returns the local players name - guaranteed to not be NULL. this is the same name as on the users community profile page

returns the appID of the current process

Functions for clients to access data about Steam friends

Called when a friends' status changes

Called when the user tries to join a game from their friends list rich presence will have been set with the "connect" key which is set here

Callback indicating updated data about friends rich presence information

Called when the user tries to join a game from their friends list in a lobby

"steamid" - Opens the overlay web browser to the specified user or groups profile. "chat" - Opens a chat window to the specified user, or joins the group chat. "jointrade" - Opens a window to a Steam Trading session that was started with the ISteamEconomy/StartTrade Web API. "stats" - Opens the overlay web browser to the specified user's stats. "achievements" - Opens the overlay web browser to the specified user's achievements. "friendadd" - Opens the overlay in minimal mode prompting the user to add the target user as a friend. "friendremove" - Opens the overlay in minimal mode prompting the user to remove the target friend. "friendrequestaccept" - Opens the overlay in minimal mode prompting the user to accept an incoming friend invite. "friendrequestignore" - Opens the overlay in minimal mode prompting the user to ignore an incoming friend invite.

Activates the Steam Overlay to open the invite dialog. Invitations sent from this dialog will be for the provided lobby.

Requests the persona name and optionally the avatar of a specified user. NOTE: It's a lot slower to download avatars and churns the local cache, so if you don't need avatars, don't request them. returns true if we're fetching the data, false if we already have it

Functions for clients to access matchmaking services, favorites, and to operate on game lobbies

Maximum number of characters a lobby metadata key can be

Creates a new invisible lobby. Call lobby.SetPublic to take it online.

Attempts to directly join the specified lobby

Interface which provides access to a range of miscellaneous utility functions

returns true if the image exists, and the buffer was successfully filled out results are returned in RGBA format the destination buffer size should be 4 * height * width * sizeof(char)

returns the image in RGBA format

returns true if Steam itself is running on the Steam Deck

Returns true if this is the local user

Return true if this is a friend

Returns true if you have this user blocked

Return true if this user is playing the game we're running

Return true if this user is playing another game

Returns true if this friend is online

Sometimes we don't know the user's name. This will wait until we have downloaded the information on this user.

Returns true if this friend is marked as away

Returns true if this friend is marked as busy

Returns true if this friend is marked as snoozing

Invite this friend to the game that we are playing

Activates the Steam Overlay to a specific dialog

Sends a message to a Steam friend. Returns true if success

Returns a buffer. This will get returned and reused later on. We shouldn't really be using this anymore.

Returns false if model has no valid render meshes, or is null.

We only want 1 instance of a Resource class in C# and we want that to have 1 strong handle to native. So we need a WeakReference lookup everytime we get a Resource from native to match that class. This way GC can work for us and free anything we're no longer using anywhere, fantastic! However sometimes GC is very good at it's job and will free Resources we don't keep a strong reference to in generation 0 or 1 immediately after usage. This can cause the resource to need to be loaded every frame. Or worse be finalized at unpredictable times. So we keep a sliding memory cache of the Resources - realistically these only need to live for an extra frame. But it's probably nice to keep around for longer if they're going to be used on and off.

We still want a WeakReference cache because we might have a strong reference somewhere to a resource that has been expired from the cache. And we absolutely only want 1 instance of the resource.

When is enabled, stores the callstack captured at the time each resource was added to the cache. This prevents WeakTable pruning so every allocation remains visible at shutdown.

When enabled, disables WeakTable entry pruning and captures allocation callstacks so that resource leaks can be diagnosed at shutdown with full context.

Remove a key from both caches. Used when a resource is explicitly disposed so that a new instance can be created for the same native pointer.

Ticks the underlying MemoryCache to clear expired entries

Returns stats about the NativeResourceCache for debug overlays.

Clear the cache when games are closed etc. ready for a

Destroys a GameObject after a number of seconds. If the GameObject or its children have any components that implement ITemporaryEffect we will wait for those to be finished before destroying. This is particularly useful if you want to delete a GameObject but want to wait for sounds or particles to conclude.

Number of seconds to wait before destroying

If true we will wait for any ITemporaryEffect's to finish before destroying

If the parent GameObject is destroyed we should become orphaned instead of being destroyed ourselves. Once orphaned we'll stop all looping effects and wait to die.

Look at the children in this GameObject and orphan any temporary effects

Gets the cached patch representing differences between this instance and its source prefab. No guarantee this is up to date, except when in editor, calculating a patch is fairly expensive so we only do it when serializing or editing.

Translate from this instances guids to prefab guids

Translate from prefab guids to this instances guids

A prefab instance that is nested only contains the prefab source and lookup data, no patch.

The filename of the prefab this object is defined in.

Initialize lookups for this prefab instance.

Mapping from prefab GUIDs to instance GUIDs

Initialize patch data for this prefab instance.

Existing patch to use

Updates the cached patch that represents differences between this instance and its source prefab.

Clear Patch for this instance, can be used to revert back to the original state.

Returns true if this GameObject has been added to a prefab instance.

Returns true if this Component has been added to a prefab instance.

Returns true if the property of the owner was overridden by the prefab instance.

Returns true if the prefab instance was modified. 1. If any property was changed on any descendant 2. If any GameObject/Component was added 3. If any GameObject/Component was moved 4. If any GameObject/Component was removed

Some properties are always overridden by a prefab instance, we may want to ignore them so they don't show as modified in the UI.

Determines if a basic GameObject override should be ignored.

Returns true if: 1. Any property of the GameObject or descendant has been modified 2. If any GameObject/Component was added/removed to the GameObject

Returns true if any property of the component was changed on the instance.

Reverts the properties value back to the prefab's value.

Helper function used when Discarding/Reverting.

Reverts all the components properties back to the prefab's value.

Helper function used when Discarding/Reverting.

Reverts all the changes made to the GameObject and descendants (Additions, Removals, PropertyOverrides) back to the prefab's value.

Applies the changes made to the property back to the prefab.

Applies the changes made to the component back to the prefab.

Prepares instance JSON data for application to a prefab by updating GUID mappings and translating instance GUIDs to their prefab equivalents.

Applies the changes made to the GameObject and descendants back to the prefab.

Adds an added GameObject or PrefabInstance from the instance to the prefab.

Overrides the prefab definition with the current instance state, making the instance match the prefab exactly.

Creates the bidirectional GUID lookups from the provided mapping.

We don't serialize the GameTransform, we always serialize Position, Rotation and Scale. So we always need to use those keys, when handling GameTransform properties.

Remap all guids in the json to the new guids in the remap table.

Node that will be modified. The table to use for guid translation. If true, will also remap objects that have their own mapping (added prefab instances).

Ensures the prefab-to-instance GUID mapping is valid by adding missing entries and removing obsolete ones.

The existing GUID mapping to validate The source path of the prefab file A validated mapping containing only relevant GUIDs with appropriate instance IDs

Gets all required GUIDs from a prefab scene.

Adds new GUID mappings to the instance lookup in-place for any GUIDs not already present.

Gets all GUIDs contained inside a go hierarchy

Add to reference count for this object.

Release a reference for this object, and return it to the pool if nothing else is referencing it.

Add a serialized byte array value to the specified slot.

Try to get a deserialized value from the specified slot.

Copy the data from a .

Build a from the specified dictionary of type and value. This will return a pooled so you'll want to call when you're done with it.

Add to reference count for this object.

Release a reference for this object, and return it to the pool if nothing else is referencing it.

The maximum size (in bytes) of a single snapshot cluster. Since clusters are generally sent unreliably, the maximum size should really be under the typical MTU size of 1500 bytes.

Add a to the cluster. It will be ignored if the snapshot is empty.

Hidden class. addon code should only ever access AnimationSequence.

Hidden class. addon code should only ever access DirectPlayback.

Hidden class. addon code should only ever access MorphCollection.

The full url of this route (ie "/home/section/page")

The url split into parts (ie "home" "section" "page" )

Given a URL, check out TypeLibrary and find a valid target

True if this matches the passed in url. Queries are trimmed and ignored ( ?query=fff ) Variables are tested (but not type matched or anything)

Given a Url, check for {properties} and convert them to key values

Custom -derived type for the ReplaceContentSemicolonRegex method.

Cached, thread-safe singleton instance.

Initializes the instance.

Provides a factory for creating instances to be used by methods on .

Creates an instance of a used by methods on .

Provides the runner that contains the custom logic implementing the specified regular expression.

Scan the starting from base.runtextstart for the next match.

The text being scanned by the regular expression.

Search starting from base.runtextpos for the next location a match could possibly start.

The text being scanned by the regular expression. true if a possible match was found; false if no more matches are possible.

Determine whether at base.runtextpos is a match for the regular expression.

The text being scanned by the regular expression. true if the regular expression matches at the current position; otherwise, false.

Custom -derived type for the ReplaceContentRegex method.

Cached, thread-safe singleton instance.

Initializes the instance.

Provides a factory for creating instances to be used by methods on .

Creates an instance of a used by methods on .

Provides the runner that contains the custom logic implementing the specified regular expression.

Scan the starting from base.runtextstart for the next match.

The text being scanned by the regular expression.

Search starting from base.runtextpos for the next location a match could possibly start.

The text being scanned by the regular expression. true if a possible match was found; false if no more matches are possible.

Determine whether at base.runtextpos is a match for the regular expression.

The text being scanned by the regular expression. true if the regular expression matches at the current position; otherwise, false.

Helper methods used by generated -derived implementations.

Default timeout value set in , or if none was set.

Whether is non-infinite.

Determines whether the character is part of the [\w] set.

Provides a mask of Unicode categories that combine to form [\w].

Gets a bitmap for whether each character 0 through 127 is in [\w]

Supports searching for the string "@content".