Euler angles. Unlike a Rotation, Euler angles can represent multiple revolutions (rotations) around an axis, but suffer from issues like gimbal lock and lack of a defined "up" vector. Use Rotation for most cases.

An Axis Aligned Bounding Box.

A capsule object, defined by 2 points and a radius. A capsule is a cylinder with round ends (inset half spheres on each end).

Represents a color using 4 floats (rgba), with 0-1 range.

A 32bit color, commonly used by things like vertex buffers. The functionality on this is purposely left minimal so we're encouraged to use the regular Color struct.

A color in Hue-Saturation-Value/Brightness format.

A tapered shape between two points with a radius at each end. Supports cones and cylinders, with flat ends.

Represents a line in 3D space.

Represents a 4x4 matrix.

A float between two values, which can be randomized or fixed.

A struct describing an origin and direction

Represents a Quaternion rotation. Can be interpreted as a direction unit vector (x,y,z) + rotation around the direction vector (w) which represents the up direction. Unlike Angles, this cannot store multiple revolutions around an axis.

A struct containing a position, rotation and scale. This is commonly used in engine to describe entity position, bone position and scene object position.

A 2-dimensional vector. Typically represents a position, size, or direction in 2D space.

A 3-dimentional vector. Typically represents a position, size, or direction in 3D space.

A 4-dimensional vector/point.

Information about a Editor.Widgets context menu event.

Information about a Editor.GraphicsItems mouse hover event.

Information about a Editor.GraphicsItems mouse click event.

Information about a Editor.Widgets keyboard event.

Information about a Editor.Widgets mouse event.

Provides information about currently resident textures on the GPU

Trace for tools, not to be confused with Sandbox.SceneTrace

Information about a mouse wheel scroll event of a Editor.Widget.

Represents a collection of tags for an asset. This is only necessary so we can save tags as soon as they are added.

Passed parameters for the AssetPicker going from engine to addon code

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

A wrapper that holds an instance of any concrete type assignable to . Use this as a property type when you want the inspector to let you pick from all non-abstract implementations of an abstract class or interface. public AnyOfType MyScatterer { get; set; } Serialization stores the concrete type name alongside the property values

Write and read bytes to a stream. This aims to be as allocation free as possible while also being as fast as possible.

The low level input of a GameObject.Clone

Compact terrain material encoding with base/overlay texture blending. Packed format (32-bit uint)

Describes money, in a certain currency

Describes a curve, which can have multiple key frames.

Two curves

Collects all the relevant info (such as description, name, icon, etc) from attributes and other sources about a type or type member.

Provides vectorized operations over a span of floats.

Represents a frustum.

Describes a gradient between multiple colors

Represents the current state of a device's motion sensor(s).

Describes a per-vertex delta for a morph target (blend shape).

Describes a change to a Sandbox.NetDictionary`2 which is passed to Sandbox.NetDictionary`2.OnChanged whenever its contents change.

Describes a change to a Sandbox.NetListChangeEvent`1 which is passed to Sandbox.NetList`1.OnChanged whenever its contents change.

Configurable options when spawning a networked object.

Represents a floating-point value that can change over time with support for various evaluation modes.

Represents a plane.

A convenience struct to easily measure time since an event last happened, based on Sandbox.RealTime.GlobalNow.

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.: RealTimeSince lastUsed = 0; if ( lastUsed > 10 ) { /*Do something*/ }

A convenience struct to easily manage a time countdown, based on Sandbox.RealTime.GlobalNow.

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.: RealTimeUntil nextAttack = 10; if ( nextAttack ) { /*Do something*/ }

Represents a rectangle.

Represents a rectangle but with whole numbers

Represents a sphere.

Represents a Steam ID (64-bit unique identifier for Steam accounts). Provides type-safe storage and conversion between long/ulong representations.

Strings are commonly converted to tokens in engine, to save space and speed up things like comparisons. We wrap this functionality up in the StringToken struct, because we can apply a bunch of compile time optimizations to speed up the conversion.

Provides a way for us to cancel tasks after common async shit is executed.

A convenience struct to easily measure time since an event last happened, based on Sandbox.Time.Now.

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*/ }

A convenience struct to easily manage a time countdown, based on Sandbox.Time.Now.

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*/ }

Defines how a trail is going to be textured. Used by TrailRenderer.

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.

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

Provides data about a wrapped method in a Sandbox.CodeGeneratorAttribute callback.

Provides data about a wrapped method in a Sandbox.CodeGeneratorAttribute callback.

Provides data about a wrapped property getter in a Sandbox.CodeGeneratorAttribute callback.

Provides data about a wrapped property setter in a Sandbox.CodeGeneratorAttribute callback.

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.

A handle to a DspPreset

A handle to a Mixer

Stores a variable per channel

A helper to create binds between two properties (or whatever you want) Example usage: set "BoolValue" from value of "StringValue" BindSystem.Build.Set( this, "BoolValue" ).From( this, "StringValue" );

Context for reading binary blob data. Wraps ByteStream for allocation-free deserialization.

Context for writing binary blob data. Wraps ByteStream for allocation-free serialization.

Represents a single clutter instance to be spawned.

Describes who pressed it.

A tooltip to show when looking at this pressable

Keyframes times and values should range between 0 and 1

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

A lightweight, high-resolution timer for performance measurement. More efficient than System.Diagnostics.Stopwatch with a simpler API.

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

GPU timing data for a single render pass/group

This exists to allow the creation of performance scopes without

Provides configuration for a Doo run, such as setting initial argument values.

Options used when compiling a shader

The input state, allows interaction with Gizmos

Keyframes times and values should range between 0 and 1

Keyframes times and values should range between 0 and 1

Represents an object that needs to be added during patching.

Represents an object that should be moved to a new location during patching.

Uniquely identifies a tracked object by its type and identifier value.

Represents a property change to apply during patching.

Represents an object that should be removed during patching.

Holds key values for the map object

Passed to IModalSystem.CreateGame

Passed to IModalSystem.WorkshopPublish

A bone definition for use with Sandbox.ModelBuilder.

Defines a single breakable prop gib.

Represents a Sandbox.Rigidbody attached to a specific bone with a local transform.

Represents a Sandbox.Joint between two bodies with local frames for each.

Information about a single mount

Disposable scope that manages a temporary scene for Sandbox.Mounting.PrefabBuilder.

Represents a duration of time in a movie. Uses fixed point so precision is consistent at any absolute time. Defaults to Sandbox.MovieMaker.MovieTime.Zero.

Represents a segment of time, given by Sandbox.MovieMaker.MovieTimeRange.Start and Sandbox.MovieMaker.MovieTimeRange.End times.

Used by movie property tracks with Sandbox.GameObject or Sandbox.Component 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 Sandbox.SkinnedModelRenderer.BoneMergeTarget.

Defines the input for a pathfinding request on the navmesh.

Contains the result of a pathfinding operation.

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.

Holds information about the current link the agent is traversing.

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.

A binary category used to divide into two categories. For example, Work In Progress.

Statistics for user interactions with this package

Describes a sort order which can be used with the package/find api

Represents a tag along with the count of items it contains

A vertex to update a particle snapshot with.

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.

Spring related settings for joints such as Sandbox.Physics.FixedJoint.

A pair of case- and order-insensitive tags, used as a key to look up a Sandbox.Physics.CollisionRules.Result.

Settings for simplifying a hull shape.

Targets a property in a component or gameobject.

Setup for defining gradient fog in a view

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

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

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

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.

A render target handle used with CommandLists

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);

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.

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.

This is a cleaned up version of gameserveritem_t.

Options for creating a sound from WAV or MP3 data via Sandbox.SoundFile.FromWav(System.String,System.Span{System.Byte},Sandbox.SoundFile.LoadOptions) or Sandbox.SoundFile.FromMp3(System.String,System.Span{System.Byte},Sandbox.SoundFile.LoadOptions).

Options for creating a sound from raw PCM data via Sandbox.SoundFile.FromPcm(System.String,System.Span{System.Byte},Sandbox.SoundFile.PcmOptions).

A result from speech recognition.

Point that defines part of the spline. Two consecutive points define a segment of the spline. The Sandbox.Spline.Point.Position, Sandbox.Spline.Point.In/Sandbox.Spline.Point.Out Handles and / properties are used to define the shape of the spline. P1 (Position) P1 (In) ▼ P1 (Out) o──────═══X═══──────o ───/ \─── ──/ \── -/ \- / \ | | P0 X X P2

Information about the spline at a specific distance.

Holds a dictionary of common prefabs associated with a surface

Holds a dictionary of common sounds associated with a surface. This allows you to pick and choose an appropriate sound.

Information about terrain materials at a specific position

Defines a scope of text, all using the same style.

A variable unit based length. ie, could be a percentage or a pixel length. This is commonly used to express the size of things in UI space, usually coming from style sheets.

Represents a Rect where each side is the thickness of an edge/padding/margin/border, rather than positions.

A single parameter in a mixin definition.

Describes panel's position and size for rendering operations.

Shadow style settings

A collection of Sandbox.UI.StyleSheet objects applied directly to a panel. See Sandbox.UI.Panel.StyleSheet.

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.

Used for Sandbox.UI.Panel.Add for quick panel creation with certain settings. Other panels types are added via extension methods.

Provides progress information for operations that process blocks of data, such as file uploads, downloads, or large data transfers.

A simple IDisposable that invokes an action when disposed. Useful for creating using-blocks with cleanup logic.

Zero-allocation enumerator for Sandbox.Utility.CircularBuffer`1. Returned as a value type so never allocates.

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.

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

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

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

Everything you need to smooth damp a Vector3. Just call Update every frame.

Everything you need to create a springy Vector3