s&box


public AnyOfType MyScatterer { get; set; }

Serialization stores the concrete type name alongside the property values

Application

class

AssetPathAttribute

attribute

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

AssetTypeAttribute

attribute

Should be applied to a class that inherits from Sandbox.GameResource. Makes the class able to be stored as an asset on disk.

AssetTypeFlags

enum

Flags for Sandbox.AssetTypeAttribute

AudioListener

class

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.

AudioSurface

enum

Defines acoustic properties of a surface, which defines how sound will bounce

AuthorityAttribute

obsoleteattribute

Marks a method as being an RPC specifically targeted to the owner of the Sandbox.GameObject, or the host if the Sandbox.GameObject doesn't have an owner.

The state of the object the RPC is called on will be up-to-date including its Sandbox.GameTransform and any properties with the Sandbox.SyncAttribute or Sandbox.HostSyncAttribute attributes by the time the method is called on remote clients. The only except is any synchronized properties marked with Sandbox.SyncAttribute.Query which will generally only be received every network tick.

AutoGenerateAttribute

attribute

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.

BallJoint

class

Fix two objects together but can rotate - like a shoulder.

BallJointBuilder

class

Provides ability to generate a ball joint for a Sandbox.Model at runtime.

A filesystem. Could be on disk, or in memory, or in the cloud. Could be writable or read only. Or it could be an aggregation of all those things, merged together and read only.

BasePostProcess

class

The base class for all post process effects.

BasePostProcess<T>

class

Like BasePostProcess but enables access to helper methods for accessing from multiple instances using GetWeighted.

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.

BitFlagsAttribute

attribute

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

Blend modes used by the UI system

BlitOverlay

class

Draw a material over the screen

BlobData

class

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.

Bloom

class

Applies a bloom effect to the camera

Blur

class

Applies a blur effect to the camera.

BoneCollection

class

A collection of bones. This could be from a model, or an entity

BoxCollider

class

Defines a box collider.

BroadcastAttribute

obsoleteattribute

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 Sandbox.GameTransform and any properties with the Sandbox.SyncAttribute or Sandbox.HostSyncAttribute attributes by the time the method is called on remote clients. The only except is any synchronized properties marked with Sandbox.SyncAttribute.Query which will generally only be received every network tick.

ButtonAttribute

attribute

When added to a method - the inspector will show a button for it.

ByteStream

struct

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

CableComponent

class

Non-destructive cable data + mesh generation.

Every scene should have at least one Camera.

CapsuleCollider

class

Defines a capsule collider.

CaseInsensitiveConcurrentDictionary<T>

class

CaseInsensitiveDictionary<T>

class

ChangeAttribute

attribute

This will invoke a method when the property changes. It can be used with any property but is especially useful when combined with [Sync] or [ConVar].

If no name is provided, we will try to call On[PropertyName]Changed. The callback should have 2 arguments - oldValue and newValue, both of the same type as the property itself.

CharacterController

class

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.

CharacterControllerHelper

struct

ChatMessageEvent

class

A chat message event. Handlers can set Sandbox.ChatMessageEvent.Suppress to true to prevent the message from being delivered, or set Sandbox.ChatMessageEvent.RecipientFilter to control per-connection visibility.

ChromaticAberration

class

Applies a chromatic aberration effect to the camera

ClearFlags

enum

Flags for clearing a RT before rendering a scene using a SceneCamera

ClientEditableAttribute

attribute

Indicates that this propery can be edited by the client, in a game like Sandbox Mode. In reality this is used however the game wants to implement it.

CloneConfig

struct

The low level input of a GameObject.Clone

Clothing

class

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

ClothingContainer

class

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

Cloud

class

For accessing assets from the cloud - from code

CodeArchive

class

CodeGeneratorAttribute

attribute

An attribute that can be added to a custom System.Attribute class for special code generation behavior. They'll then be applied to methods and properties when they are decorated with that attribute.

CodeGeneratorFlags

enum

Used to specify what type of code generation to perform.

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.

Applies color adjustments to the camera.

ColorGrading

class

Applies color grading to the camera

ColorUsageAttribute

attribute

When applied to a Color property, allows you to specify whether the color should have an alpha channel and/or be in HDR.

CompactTerrainMaterial

struct

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

Given a folder of .cs files, this will produce (and load) an assembly

A GameObject can have many components, which are the building blocks of the game.

ComponentDooExtensions

class

Backward-compatible extension methods telling users to switch from Run/Stop/IsRunning to RunDoo/StopDoo/IsRunningDoo. These are marked as obsolete and hidden from intellisense to encourage migration, and are extensions so you don't get member variable conflicts.

A compute shader is a program that runs on the GPU, often with data provided to/from the CPU by means of a Sandbox.GpuBuffer`1 or a Sandbox.Texture.

Project configuration data is derived from this class

Connection

class

A connection, usually to a server or a client.

ConsoleSystem

class

A library to interact with the Console System.

Applies a cubemap fog effect to the camera

Describes money, in a certain currency

Describes a curve, which can have multiple key frames.

CurveRange

struct

Two curves

CustomEditorAttribute

attribute

CustomEmbeddedEditorAttribute

attribute

DamageInfo

class

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.

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.

DecalDefinition

class

A decal which can be applied to objects and surfaces.

Component that creates a projected decal relative to its GameObject.

DepthOfField

class

Applies a depth of field effect to the camera

DirectionalLight

class

A directional light that casts shadows, like the sun.

DisplayInfo

struct

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

Doo

class

A visual scripting task composed of executable blocks.

DooEngine

class

System that manages the execution of Doo scripts within a scene.

Dresser

class

Allows easily dressing a citizen or human in clothing

DspVolume

class

EditorHandleAttribute

attribute

When applied to a component, the editor will draw a selectable handle sprite for the gameobject in scene

EditorTint

enum

EnumButtonGroupAttribute

attribute

Forces an enum property to be shown as a group of buttons.

EnumDescription

class

EnumDropdownAttribute

attribute

Forces an enum property to be shown as a dropdown list.

EnvmapProbe

class

A cubemap probe that captures the environment around it.

EventAttribute

attribute

A generic event listener. You are probably looking for Sandbox.Event.* attributes.

ExpressionNodeAttribute

obsoleteattribute

FeatureAttribute

attribute

Sets the category or the group of a type or a type member. This info can then be retrieved via DisplayInfo library.

FeatureEnabledAttribute

attribute

Mark a boolean property as a feature toggle

FGDTypeAttribute

attribute

Overrides the auto generated FGD type.

FieldDescription

class

Describes a field. We use this class to wrap and return FieldInfo's that are safe to interact with. Returned by Sandbox.Internal.TypeLibrary and Sandbox.TypeDescription.

FilePathAttribute

attribute

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

FileSystem

class

A filesystem that can be accessed by the game.

FileWatch

class

Watch folders, dispatch events on changed files

FilmGrain

class

Applies a film grain effect to the camera

FindMode

enum

Flags to search for Components. I've named this something generic because I think we can re-use it to search for GameObjects too.

FireDamage

class

Applies fire damage to any IDamageable in our Root object. Damage is tagged "fire" and "burn"

FixedJoint

class

Weld two physics objects together

FixedJointBuilder

class

Provides ability to generate a fixed joint for a Sandbox.Model at runtime.

FloatSpan

struct

Provides vectorized operations over a span of floats.

FontNameAttribute

attribute

When applied to a string property, uses a font name selector.

Represents a frustum.

Game

class

Provides global access to core game state, utilities, and operations for S&box. The Sandbox.Game 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.

GameObject

class

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.

GameObjectDirectory

class

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.

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.

GameObjectSystem<T>

class

A syntax sugar wrapper around GameObjectSystem, which allows you to access your system using SystemName.Current instead of Scene.GetSystem.

GamepadCode

enum

Game controller codes, driven from SDL.

GameResource

class

Assets defined in C# and created through tools. You can define your own Custom Asset Types.

GameResourceAttribute

obsoleteattribute

GameTags

class

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.

GameTask

class

A generic Sandbox.TaskSource.

A gib is a prop that is treated slightly different. It will fade out after a certain amount of time.

A GPU data buffer intended for use with a Sandbox.ComputeShader. 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 Sandbox.GpuBuffer.UsageFlags. Using the default Sandbox.GpuBuffer.UsageFlags.Structured type buffers map to StructuredBuffer and RWStructuredBuffer in HLSL.

Describes a gradient between multiple colors

GradientFog

class

Adds a gradient fog to the world

Graphics

class

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.

HammerMesh

class

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.

HapticEffect

class

Contains a haptic effect, which consists of patterns for the controller and triggers.

HapticPattern

class

Contains a haptic pattern, which consists of frequency and amplitude values that can change over time.

HapticTarget

enum

Places you can trigger haptics on

HasImplementationAttribute

attribute

In ActionGraph, this type parameter can only be satisfied by a type TArg, such that there exists at least one non-abstract type that extends / implements both TArg and Sandbox.HasImplementationAttribute.BaseType.

HeaderAttribute

attribute

Add a header above this property

HelpUrlAttribute

attribute

Add a link to some documentation for this component, or

HideAttribute

attribute

Hide this in tools/editors.

Highlight

class

This should be added to a camera that you want to outline stuff

HighlightOutline

class

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.

HingeJoint

class

Create a hinged connection between two physics objects. Like a door hinge or a wheel.

HingeJointBuilder

class

Provides ability to generate a hinge joint for a Sandbox.Model at runtime.

A set of hitboxes on a model. Hitboxes can be boxes, spheres or capsules.

HostSyncAttribute

obsoleteattribute

Automatically synchronize a property of a networked object from the host to other clients. Obsolete: 11/12/2024

Http

class

Lets your game make async HTTP requests.

HullCollider

class

Defines a box, cone, or cylinder hull collider.

IconNameAttribute

attribute

When applied to a string property, uses a Material Icon selector.

ImageAssetPathAttribute

attribute

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

ImageFormat

enum

Format used when creating textures.

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.

InfoBoxAttribute

attribute

Draw a box with information above this property

InlineEditorAttribute

attribute

Tell the editor to try to display inline editing for this property, rather than hiding it behind a popup etc.

Input

class

Allows querying of player button presses and other inputs.

InputAction

class

An input action defined by a game project.

InputActionAttribute

attribute

When applied to a string property, use an input action selector.

InputAnalog

enum

An analog input, when fetched, is between -1 and 1 (0 being default)

InputAttribute

attribute

Makes this method available as a Map Logic Input, for use in the Hammer Editor. This is only applicable to entities.

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

InputSettings

class

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.

InspectorVisibilityAttribute

attribute

Hide a property if a condition matches.

A convenience JSON helper that handles Sandbox.Resource types for you.

JsonUpgraderAttribute

attribute

An attribute that describes a version update for a JSON object.

Mark this property as the key property - which means that it can represent the whole object in a single line, while usually offering an advanced mode to view the entire object.

KeyStore

class

Allows storing files by hashed keys, rather than by actual filename. This is sometimes useful.

Language

class

Allows access to translated phrases, allowing the translation of gamemodes etc

LanguageContainer

class

A container for the current language, allowing access to translated phrases and language information.

LaunchArguments

class

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

LegacyParticleSystem

obsoleteclass

Support's Source Engine's vpcf particles

Renders a line between a list of points

LipSync

class

Drive morphs with lipsync from sounds.

Holds metadata and raw data relating to a Saved Game.

Utility functions that revolve around the main thread

An addon's manifest, describing what files are available

ManualHitbox

class

A hitbox that can be placed manually on a GameObject, instead of coming from a model

Map

class

MapAssetPathAttribute

attribute

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

Allows you to load a map into the Scene. This can be either a vpk or a scene map.

A material. Uses several Sandbox.Textures and a Sandbox.Material.Shader with specific settings for more interesting visual effects.

A class to add functionality to the math library that System.Math and System.MathF don't provide. A lot of these methods are also extensions, so you can use for example `int i = 1.0f.FloorToInt();`

MemberDescription

class

Wraps MemberInfo but with caching and sandboxing. Returned by Sandbox.Internal.TypeLibrary and Sandbox.TypeDescription.

Mesh

class

A mesh is a basic version of a Sandbox.Model, 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 Sandbox.Model via the Sandbox.ModelBuilder class.

MeshComponent

class

An editable polygon mesh with collision

MeshPrimitiveType

enum

Possible primitive types of a Sandbox.Mesh.

Metadata

class

A simple class for storing and retrieving metadata values.

MethodArgumentsAttribute

attribute

Specify the types of arguments a method should have. Typically used with event attributes to throw an exception if an event attribute is added to a method with incorrect arguments.

MethodBodyChangeAttribute

attribute

MethodDescription

class

Describes a method. We use this class to wrap and return MethodInfo's that are safe to interact with. Returned by Sandbox.Internal.TypeLibrary and Sandbox.TypeDescription.

MissingComponent

class

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.

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

Provides ability to generate Sandbox.Models at runtime. A static instance of this class is available at Sandbox.Model.Builder

ModelCollider

class

Defines a collider based on a model.

ModelHitboxes

class

Hitboxes from a model

ModelMorphs

class

Allows fast lookups of morph variables

Physics for a model. This is primarily used for ragdolls and other physics driven models, otherwise you should be using a Rigidbody.

ModelRenderer

class

Renders a model in the world

MorphCollection

class

Used to access and manipulate morphs.

MorphDelta

struct

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

MotionBlur

class

Applies a motion blur effect to the camera

Mouse

class

Gives access to mouse position etc

MouseButtons

enum

State of mouse buttons being pressed or not.

MouseVisibility

enum

The visibility state of the mouse cursor.

MultisampleAmount

enum

MultiSerializedObject

class

An object (or data) that can be accessed as an object

MusicPlayer

class

Enables music playback. Use this for music, not for playing game sounds.

NavMeshAgent

class

An agent that can navigate the navmesh defined in the scene.

NavMeshArea

class

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.

NavMeshLink

class

NavigationLinks connect navigation mesh polygons for pathfinding and enable shortcuts like ladders, jumps, or teleports.

NetDictionary<TKey,TValue>

class

A networkable dictionary for use with the Sandbox.SyncAttribute and Sandbox.HostSyncAttribute. 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 MyBoolTable { get; set; } = new();
	

	public void SetBoolState( string key, bool state )
	{
		if ( IsProxy ) return;
		MyBoolTable[key] = state;
	}
}

NetDictionaryChangeEvent<TKey,TValue>

struct

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

A networkable list for use with the Sandbox.SyncAttribute and Sandbox.HostSyncAttribute. 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 MyIntegerList { get; set; } = new();
	

	public void AddNumber( int number )
	{
		if ( IsProxy ) return;
		MyIntegerList.Add( number );
	}
}

NetListChangeEvent<T>

struct

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

NetPermission

obsoleteenum

Specifies who can invoke an action over the network.

NetworkFlags

enum

Describes the behavior of network objects.

Global manager to hold and tick the singleton instance of NetworkSystem.

NetworkingSettings

class

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.

NetworkMode

enum

Specifies how a Sandbox.GameObject should be networked.

NetworkOrphaned

enum

Specifies what happens when the owner of a networked object disconnects.

NetworkSpawnOptions

struct

Configurable options when spawning a networked object.

NormalAttribute

attribute

When applied to a Vector property, provides normal selection tools.

OwnerTransfer

enum

Specifies who can control ownership of a networked object.

Package

class

Represents an asset on Asset Party.

Attract particles to a GameObject in the scene

ParticleBoxEmitter

class

Emits particles within a box shape.

ParticleConeEmitter

class

Emits particles within/along a cone shape.

ParticleController

class

Particles can have extra controllers that can modify the particles every frame.

Defines and holds particles. This is the core of the particle system.

ParticleEmitter

class

Creates particles. Should be attached to a Sandbox.ParticleEffect.

ParticleFloat

struct

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

ParticleGradient

struct

ParticleLightRenderer

class

Adds lighting to particles in your effect.

ParticleModelEmitter

class

Emits particles in a model

ParticleModelRenderer

class

Renders particles as models, using the particle's position, rotation, and size.

ParticleRenderer

class

Renders a set of particles. Should be attached to a Sandbox.ParticleRenderer.ParticleEffect.

ParticleRingEmitter

class

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.

ParticleSnapshot

obsoleteclass

A particle snapshot that can be created procedurally. Contains a set of vertices that particle effects can address.

ParticleSphereEmitter

class

Emits particles within a sphere shape.

ParticleSpriteRenderer

class

Renders particles as 2D sprites - can be static or animated

ParticleSystem

obsoleteclass

A particle effect system that allows for complex visual effects, such as explosions, muzzle flashes, impact effects, etc.

ParticleTextRenderer

class

Renders particles as 2D sprites

ParticleTrailRenderer

class

Renders a trail for each particle in the effect.

A Party. A Party with your friends.

PhysicsBody

class

Represents a physics object. An entity can have multiple physics objects. See PhysicsGroup. A physics objects consists of one or more PhysicsShapes.

PhysicsBodyBuilder

class

Provides ability to generate a physics body for a Sandbox.Model at runtime. See Sandbox.ModelBuilder.AddBody(System.Single,Sandbox.Surface,System.String)

Represents a set of PhysicsBody objects. Think ragdoll.

PhysicsGroupDescription

class

Describes the physics shapes of a model or standalone vphys resource. Wraps native CPhysicsData the same way Sandbox.Model wraps IModel.

PhysicsIntersection

struct

PhysicsIntersectionEnd

struct

PhysicsJointBuilder

class

Provides ability to generate a physics joint for a Sandbox.Model at runtime.

PhysicsJointBuilderExtensions

Represents Physics body's motion type.

PhysicsShape

class

Represents a basic, convex shape. A PhysicsBody consists of one or more of these.

PhysicsSimulationMode

enum

Physics simulation mode. For use with Sandbox.PhysicsWorld.SimulationMode.

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.

Pixelate

class

Applies a pixelate effect to the camera

Defines a plane collider.

PlatformSettings

class

Platform-level settings for a game project. These control engine-provided features like text chat that exist outside of any specific scene.

Emits light in all directions from a point in space.

PolygonMesh

class

An editable mesh made up of polygons, triangulated into a model

PostProcess

obsoleteclass

Adds an effect to the camera

PostProcessSystem

class

Manages post-processing effects for cameras and volumes within a scene, handling their application during rendering and editor preview stages.

PostProcessVolume

class

A volume that defines a region in the scene where post processing effects will be applied.

PrefabFile

class

A GameObject which is saved to a file.

A prefab variable definition

Preferences

class

Holds information about the current user's preferences.

Project

class

Represents an on-disk project.

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.

PropertyAccessor

enum

PropertyAccessorBodyChangeAttribute

Describes a property. We use this class to wrap and return PropertyInfo's that are safe to interact with. Returned by Sandbox.Internal.TypeLibrary and Sandbox.TypeDescription.

Applies damage in a radius, with physics force, and optional occlusion

RangeAttribute

attribute

Mark this property as a ranged float/int. In inspector we'll be able to create a slider instead of a text entry.

RayTracingAccelerationStructure

class

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.

ReadOnlyAttribute

attribute

Display this in the inspector - but don't let anyone edit it

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

RealTimeUntil

struct

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

Rect

struct

Represents a rectangle.

RectInt

struct

Represents a rectangle but with whole numbers

RenderAttributes

class

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

Essentially wraps a couple of textures that we're going to render to. The color texture and the depth texture.

RenderTextureAsset

class

Asset that owns a GPU render target texture which can be shared across runtime systems.

RequireComponentAttribute

attribute

When added to a property on a Component, we'll try to make that component value non null. We will first look on the GameObject for the component type. If it's not found, we'll create one.

Resource

class

A resource loaded in the engine, such as a Sandbox.Model or Sandbox.Material.

ResourceExtension<T,TSelf>

class

An extension of ResourceExtension[t], this gives special helper methods for retrieving resources targetting specific assets.

ResourceExtension<T>

class

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.

ResourceLibrary

class

Keeps a library of all available Sandbox.Resource.

ResourcePublishContext

class

Created by the editor when publishing a resource, passed into Resource.ConfigurePublishing. This allows the resource to configure how it wants to be published.

ResourceSystem

class

ResourceTypeAttribute

attribute

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"

Rigidbody

class

Adds physics properties to an object. Requires a collider to be attached to the same object.

Marks a method as being an RPC. This means that it can be called over the network.

SandboxBaseExtensions

class

SandboxGameExtensions

class

SandboxSystemExtensions

Represents a camera and holds render hooks. This camera can be used to draw tool windows and scene panels.

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)

SceneCustomObject

class

A scene object that allows custom rendering within a scene world.

SceneDirectionalLight

class

A directional scene light that is used to mimic sun light in a Sandbox.SceneWorld. Direction is controlled by this object's Rotation.

A scene file contains a collection of GameObject with Components and their properties.

SceneFogVolume

class

Represents a volume of fog in a scene, contributing to volumetric fog effects set on Sandbox.SceneCamera.VolumetricFog.

Base class for light scene objects for use with a Sandbox.SceneWorld.

SceneLineObject

class

A scene object which is used to draw lines

Map geometry that can be rendered within a Sandbox.SceneWorld.

A model scene object that supports animations and can be rendered within a Sandbox.SceneWorld.

SceneNetworkSystem

class

This is created and referenced by the network system, as a way to route.

SceneObject

class

A model scene object that can be rendered within a Sandbox.SceneWorld.

SceneParticles

obsoleteclass

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.

ScenePointLight

class

A point light scene object for use in a Sandbox.SceneWorld.

SceneRenderLayer

enum

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.

SceneSkyBox

class

Renders a skybox within a Sandbox.SceneWorld.

SceneSpotLight

class

A simple spot light scene object for use in a Sandbox.SceneWorld.

A scene world that contains Sandbox.SceneObjects. See Utility.CreateSceneWorld. You may also want a Sandbox.SceneCamera to manually render the scene world.

Screen

class

Access screen dimension etc.

ScreenPanel

class

Renders any attached PanelComponents to the screen. Acts as the root for all your UI components.

ScreenSpaceReflections

class

SelectionBaseAttribute

attribute

Apply this attribute to a component class to mark its GameObject as a selection base for Scene View picking. For example, if you click on a child object within a Prefab, the root of the Prefab is selected by default. With the SelectionBase attribute, you can designate a specific component (and its GameObject) to be treated as a selection base, ensuring it is picked when clicking in the Scene View.

SelectionSetsSystem

class

Stores editor selection sets on the scene so they serialize into SceneProperties/GameObjectSystems.

SelectionSystem

class

An ordered collection of unique objects with add/remove callbacks. Maintains insertion order and provides change notifications.

An object (or data) that can be accessed as an object

A shader is a specialized and complex computer program that use world geometry, materials and textures to render graphics.

Sharpen

class

Applies a sharpen effect to the camera

SimpleVertex

struct

SingleActionAttribute

attribute

Force a delegate-type property to only have a single attached Action Graph.

SkinnedModelRenderer

class

Renders a skinned model in the world. A skinned model is any model with bones/animations.

SkipHotloadAttribute

attribute

Skip processing a specific field, or any fields in a type marked by this attribute. Field processing will still occur if a type marked by this attribute was defined in a swapped assembly.

SkyBox2D

class

Adds a 2D skybox to the world

SliderJoint

class

Restrict an object to one axis, relative to another object. Like a drawer opening.

SliderJointBuilder

class

Provides ability to generate a slider joint for a Sandbox.Model at runtime.

Sound

class

Single source for creating sounds

SoundBoxComponent

class

Plays a sound within a box.

SoundEvent

class

A sound event. It can play a set of random sounds with optionally random settings such as volume and pitch.

A handle to a sound that is currently playing. You can use this to control the sound's position, volume, pitch etc.

SoundPointComponent

class

Plays a sound at a point in the world.

Soundscape

class

A soundscape is used for environmental ambiance of a map by playing a set of random sounds at given intervals.

SoundscapeTrigger

class

Plays a soundscape when the listener enters the trigger area.

Add a space above this property

SpawnPoint

class

Dictates where players will spawn when they join the game when using a NetworkHelper.

Defines a sphere collider.

Spline

class

Collection of curves in 3D space. Shape and behavior of the curves are controled through points Sandbox.Spline.Point, each with customizable handles, roll, scale, and up vectors. Two consecutive points define a segment/curve of the spline.

By adjusting the handles both smooth and sharp corners can be created. The spline can also be turned into a loop, combined with linear tangents this can be used to create polygons. Splines can also be used used for animations, camera movements, marking areas, or procedural geometry generation.

SpotLight

class

Emits light in a specific direction in a cone shape.

SpringJoint

class

Try to keep an object a set distance away from another object. Like a spring connecting two objects.

Sprite

class

Represents a sprite resource that can be static or animated. Sprites are rendererd using the SpriteRenderer component.

SpriteRenderer

class

Renders a sprite in the world

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

StepAttribute

attribute

Mark this property as a stepped value, where the value can only be set to multiples of the step value.

Streamer integration services

StringLiteralOnlyAttribute

attribute

Ask codegen to shit itself if the parameter isn't passed in as a string literal

StringToken

struct

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.

SupportsILHotloadAttribute

attribute

SuppressNullKeyWarningAttribute

attribute

When applied to a member with System.Collections.Generic.Dictionary`2 or System.Collections.Generic.HashSet`1 type, don't warn if the key of an item becomes null during a hotload because a type is removed. You should only use this attribute if you're sure that it's safe to quietly remove entries.

Surface

class

A physics surface. This is applied to each PhysicsShape and controls its physical properties and physics related sounds.

SyncAttribute

attribute

Automatically synchronize a property of a networked object from the owner to other clients.

SyncFlags

enum

Describes the behaviour of network synchronization.

SystemsConfig

class

Configuration for GameObjectSystem properties at a project level. Specific scenes may override this as well - but will be serialized directly in the scene.

When applied to a Type property, allows you to specify a Type that the property's value must derive from.

TaskSource

struct

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

Terrain

class

Terrain renders heightmap based terrain.

Description of a Terrain Material.

TerrainStorage

class

Stores heightmaps, control maps and materials.

TextAreaAttribute

attribute

When applied to a string property, show a multi-line text box instead of a single line.

TextFlag

enum

Flags dictating position of text (and other elements). Default alignment on each axis is Top, Left. Values for each axis can be combined into a single value, conflicting values have undefined behavior.

TextRenderer

class

Renders text in the world

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

Flags providing hints about a texture

TextureImagePathAttribute

attribute

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

ThreadSafe

class

Provides utilities for working with threads, particularly for identifying and asserting code is running on the main thread.

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

TimeUntil

struct

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

Applies a tonemapping effect to the camera.

TrailRenderer

class

Renders a trail behind the object, when it moves.

TrailTextureConfig

struct

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

TransformProxy

class

TransformProxyComponent

class

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.

Deals damage to objects inside

TypeDescription

class

Describes a type. We use this class to wrap and return System.Type's that are safe to interact with. Returned by Sandbox.Internal.TypeLibrary.

UprightJoint

class

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.

Variant

struct

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.

VerletRope

class

Verlet integration-based rope physics simulation component.

VertexAttributeFormat

Allows for the definition of custom vertex layouts

VideoPlayer

class

Enables video playback and access to the video texture and audio.

VideoWriter

class

Allows the creation of video content by encoding a sequence of frames.

Vignette

class

Applies a vignette to the camera

Voice

class

Records and transmits voice/microphone input to other players.

VoiceMode

enum

Voice chat activation mode preference.

VolumetricFogController

class

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

VolumetricFogParameters

class

VolumetricFogVolume

class

Adds a volumetric fog volume to the scene.

WebSocket

class

A WebSocket client for connecting to external services.

WebSurface

class

Enables rendering and interacting with a webpage

WheelJoint

class

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.

WideModeAttribute

attribute

Expand the value editor to fill the next line in the inspector, leaving the title above it

WorkshopItemMetaData

struct

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

WorldInput

class

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.

WorldPanel

class

Renders any attached PanelComponents to the world in 3D space.

WrappedMethod

struct

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

WrappedMethod<T>

struct

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

WrappedPropertyGet<T>

struct

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

WrappedPropertySet<T>

struct

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

list Sandbox.AmbientOcclusion 2

folder Sandbox.Audio 17

AudioChannel

struct

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.

AudioDistanceFloatAttribute

attribute

AudioMeter

class

Allows the capture and monitor of an audio source

AudioProcessor

class

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.

AudioProcessor<T>

class

Audio processor that allows per listener state.

A handle to a DspPreset

Just a test - don't count on this sticking around

LowPassProcessor

class

Just a test - don't count on this sticking around

MixBuffer

class

Contains 512 samples of audio data, this is used when mixing a single channel

Mixer

class

Takes a bunch of sound, changes its volumes, mixes it together, outputs it

Holds up to 8 mix buffers, which usually represent output speakers.

PerChannel<T>

struct

Stores a variable per channel

PitchProcessor

class

deployed_code Sandbox.Audio.AudioMeter 1

Frame

struct

folder Sandbox.Audio.AudioProcessor 1

ListenerState

class

One of these is created for every listener that uses an audio processor.

folder Sandbox.Audio.DelayProcessor 1

State

class

folder Sandbox.Audio.DspProcessor 1

State

class

folder Sandbox.Audio.HighPassProcessor 1

State

class

folder Sandbox.Audio.LowPassProcessor 1

State

class

folder Sandbox.Audio.PitchProcessor 1

State

class

list Sandbox.BallJoint 1

MotorMode

enum

list Sandbox.BaseChair 1

AnimatorSitPose

enum

deployed_code Sandbox.BasePostProcess 1

BlitMode

struct

folder Sandbox.BeamEffect 1

BeamInstance

class

Represents an individual beam instance within the effect.

folder Sandbox.Bind 4

BindSystem

class

Data bind system, bind properties to each other.

Builder

struct

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

Link

class

Joins two proxies together, so one can be updated from the other (or both from each other)

Proxy

class

Gets and Sets a value from somewhere.

deployed_code Sandbox.BlobData 2

Reader

struct

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

Writer

struct

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

list Sandbox.Bloom 1

FilterMode

enum

folder Sandbox.BoneCollection 1

Bone

class

A bone in a Sandbox.BoneCollection.

list Sandbox.CableComponent 1

CableTextureOrientation

enum

folder Sandbox.CameraComponent 2

folder Sandbox.Citizen 1

CitizenAnimationHelper

class

list Sandbox.Citizen.CitizenAnimationHelper 5

folder Sandbox.Clothing 4

list Sandbox.Clothing.IconSetup 1

IconModes

enum

folder Sandbox.ClothingContainer 1

ClothingEntry

class

label Sandbox.Cloud 1

AssetAttribute

attribute

Automatically addeded to a type as a result of using Cloud.Model etc inside.

folder Sandbox.Clutter 11

ClutterComponent

class

Clutter scattering component supporting both infinite and volumes.

ClutterDefinition

class

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

ClutterEntry

class

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

ClutterGridSystem

class

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

ClutterInstance

struct

Represents a single clutter instance to be spawned.

Scatterer

class

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

Maps an clutter entry to a slope angle range.

SlopeScatterer

class

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.

TerrainMaterialMapping

class

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

TerrainMaterialScatterer

class

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

list Sandbox.Clutter.ClutterComponent 1

ClutterMode

enum

Clutter generation mode.

list Sandbox.Clutter.ClutterDefinition 1

TileSizeOption

enum

Tile size options for streaming mode.

folder Sandbox.Clutter.ClutterGridSystem 1

ClutterStorage

class

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

deployed_code Sandbox.Clutter.ClutterGridSystem.ClutterStorage 1

Instance

struct

folder Sandbox.CodeArchive 1

AdditionalFile

class

Represents a file to send to the compiler along with all the code. This is usually something that the generator turns into code, such as a Razor file.

list Sandbox.ColorGrading 2

deployed_code Sandbox.CompileGroup 1

Results

struct

folder Sandbox.Compiler 2

deployed_code Sandbox.Component.IPressable 2

Event

struct

Describes who pressed it.

Tooltip

struct

A tooltip to show when looking at this pressable

folder Sandbox.Compression 1

LZ4

class

Encode and decode LZ4 compressed data.

deployed_code Sandbox.ConCmdAttribute 1

AutoCompleteResult

struct

deployed_code Sandbox.Connection 1

Filter

struct

list Sandbox.Connection.Filter 1

FilterType

enum

deployed_code Sandbox.CursorSettings 1

Cursor

struct

folder Sandbox.Curve 2

Frame

struct

Keyframes times and values should range between 0 and 1

HandleMode

enum

Describes how the line should behave when entering/leaving a frame

folder Sandbox.DataModel 2

GameSetting

struct

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.

ProjectConfig

class

Configuration of a Sandbox.Project.

deployed_code Sandbox.DataModel.GameSetting 1

Option

struct

folder Sandbox.Debug 1

Networking

class

folder Sandbox.DecalDefinition 1

DecalEntry

obsoleteclass

folder Sandbox.Diagnostics 9

Allocations

class

Tools for diagnosing heap allocations

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

FrameStats

struct

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

GpuProfilerStats

class

GPU profiler stats collected from the scene system timestamp manager

GpuTimingEntry

struct

GPU timing data for a single render pass/group

folder Sandbox.Diagnostics.Allocations 2

deployed_code Sandbox.Diagnostics.Performance 1

ScopeSection

struct

This exists to allow the creation of performance scopes without

folder Sandbox.Diagnostics.PerformanceStats 3

deployed_code Sandbox.Diagnostics.PerformanceStats.Timings 1

Frame

struct

folder Sandbox.DirectionalLight 1

CascadeVisualizer

class

folder Sandbox.Doo 17

ArgumentHintAttribute

attribute

Specify a hint on a Doo explaining that we're going to be passing in an expected argument when calling it.

ArgumentHintAttribute<T>

attribute

Specify a hint on a Doo explaining that we're going to be passing in an expected argument when calling it.

Block

class

Base class for all executable blocks within a Doo.

Configure

struct

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

DelayBlock

class

Wait for a number of seconds

Expression

class

Base class for all value expressions used as arguments and assignments within blocks.

ForBlock

class

Run a block of code a certain number of times, with a loop variable.

Helpers

class

Utility methods for the Doo scripting system.

InvokeBlock

class

Call a global method or a method on a component.

InvokeType

enum

Determines how an invoke block resolves its target method.

LiteralExpression

class

An expression that evaluates to a constant literal value.

MethodAttribute

attribute

Marks a static method as callable from within a Doo script.

Methods

class

Built-in static methods available to Doo scripts.

ReturnBlock

class

Stops execution of the current Doo immediately.

SetBlock

class

Set a variable to a value.

TargetComponent

class

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

VariableExpression

class

An expression that evaluates to the current value of a named variable.

list Sandbox.Doo.TargetComponent 1

TargetType

enum

list Sandbox.Dresser 1

ClothingSource

enum

folder Sandbox.Engine 5

BindCollection

class

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.

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

Protocol

class

A centralized place to access the protocols

SystemInfo

class

folder Sandbox.Engine.BindCollection 2

folder Sandbox.Engine.Resources 1

NavMeshAreaDefinition

class

Defines a navigation area resource for use in navigation meshes.

folder Sandbox.Engine.Settings 7

Fsr3UpscalerQuality

enum

Controls the upscaler quality preset which determines the internal render resolution. Higher quality = higher resolution = better image but lower performance.

PostProcessQuality

enum

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

RenderSettings

class

User graphics settings

Selects which upscaler is used to take a lower-resolution scene render and upscale it back to display resolution. Mirrors the r_upscaling ConVar.

VolumetricFogQuality

enum

deployed_code Sandbox.Engine.Settings.RenderSettings 1

VideoDisplayMode

struct

folder Sandbox.Engine.Shaders 2

Options used when compiling a shader

folder Sandbox.Engine.Shaders.ShaderCompile 1

Results

class

The results of a shader compile

folder Sandbox.Engine.Shaders.ShaderCompile.Results 1

Program

class

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

deployed_code Sandbox.Engine.Utility.RayTrace 1

MeshTraceRequest

struct

deployed_code Sandbox.Engine.Utility.RayTrace.MeshTraceRequest 1

Result

struct

deployed_code Sandbox.Engine.Utility.RayTrace.MeshTraceRequest.Result 1

VertexDetail

struct

deployed_code Sandbox.EnumDescription 1

Entry

struct

list Sandbox.EnvmapProbe 3

folder Sandbox.Game 1

Overlay

class

Provides static methods for displaying various modal overlays in the game UI. The Sandbox.Game.Overlay 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.

folder Sandbox.GameObject 3

list Sandbox.GameObjectSystem 1

Stage

enum

A list of stages in the scene tick in which we can hook

folder Sandbox.Gizmo 9

Colors

class

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

GizmoControls

class

Extendable helper to create common gizmos

GizmoDraw

class

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

GizmoHitbox

class

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

The input state, allows interaction with Gizmos

Instance

class

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.

Pressed

class

Access to the currently pressed path information

SceneSettings

class

folder Sandbox.GpuBuffer 4

IndirectDispatchArguments

struct

IndirectDrawArguments

struct

IndirectDrawIndexedArguments

struct

UsageFlags

enum

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.

folder Sandbox.Gradient 3

AlphaFrame

struct

Keyframes times and values should range between 0 and 1

BlendMode

enum

Describes how the line should behave when entering/leaving a frame

ColorFrame

struct

Keyframes times and values should range between 0 and 1

list Sandbox.Graphics 2

DownsampleMethod

enum

Which method to use when downsampling a texture

PrimitiveType

enum

list Sandbox.HingeJoint 1

MotorMode

enum

folder Sandbox.HitboxSet 1

Box

class

A single hitbox on the model. This can be a box, sphere or capsule.

list Sandbox.HullCollider 1

PrimitiveType

enum

deployed_code Sandbox.IByteParsable 1

ByteParseOptions

struct

folder Sandbox.IndirectLightVolume 2

InsideGeometryBehavior

enum

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

class

Per-probe data including position offset and active state.

folder Sandbox.Input 1

Keyboard

class

Keyboard related glyph methods.

folder Sandbox.Internal 7

ClassFileLocationAttribute

attribute

Automatically added to codegenerated classes to let them determine their location This helps when looking for resources relative to them, like style sheets. Replaced in Sept 2023 by SourceLocationAttribute, which is added to classes and members.

GlobalGameNamespace

class

GlobalSystemNamespace

class

PublicArrayPool<T>

class

Calls to ArrayPool.Shared{T} will map to this class. You can use it directly but you probably shouldn't

SafeStringBuilder

class

Calls to new StringBuilder() in addon code will map to this class. You can use it directly but you probably shouldn't.

SourceLocationAttribute

attribute

Automatically added to classes and their members to let them determine their location This helps when looking for resources relative to them, like style sheets.

TypeLibrary

class

folder Sandbox.Internal.IControlSheet 2

Feature

class

A feature is usually displayed as a tab, to break things up in the inspector. They can sometimes be turned on and off.

Group

class

A group is a collection of properties that are related to each other, and can be displayed together in the inspector, usually with a title.

list Sandbox.Joint 1

AttachmentMode

enum

folder Sandbox.Json 9

AddedObject

struct

Represents an object that needs to be added during patching.

MovedObject

struct

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

ObjectIdentifier

struct

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

Patch

class

Represents a complete set of changes to be applied to a JSON structure.

Pointer

class

Represents a JSON Pointer as defined in RFC 6901.

PointerJsonConverter

class

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.

PropertyOverride

struct

Represents a property change to apply during patching.

RemovedObject

struct

Represents an object that should be removed during patching.

TrackedObjectDefinition

class

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.

list Sandbox.Light 1

FogInfluence

enum

folder Sandbox.Localization 4

A list of supported languages and metadata surrounding them

Phrase

class

A translated string. ie "Hello World". It might also have variables, ie "Hello {PlayerName}". Todo support for conditionals and plurals

PhraseCollection

class

Holds a bunch of localized phrases

deployed_code Sandbox.ManifestSchema 1

File

struct

list Sandbox.ManualHitbox 1

HitboxShape

enum

deployed_code Sandbox.MapLoader 1

ObjectEntry

struct

Holds key values for the map object

folder Sandbox.Mapping 2

list Sandbox.Mapping.Button 1

ButtonMode

enum

The button's behavior mode.

list Sandbox.Mapping.Door 2

folder Sandbox.Material 2

Static materials for UI rendering purposes.

deployed_code Sandbox.Menu 1

LoadingProgress

struct

folder Sandbox.Mesh 2

IndexBufferLockHandler

class

VertexBufferLockHandler<T>

class

list Sandbox.MeshComponent 1

CollisionType

enum

deployed_code Sandbox.Modals 5

CreateGameOptions

struct

Passed to IModalSystem.CreateGame

CreateGameResults

struct

FriendsListModalOptions

struct

ServerListConfig

struct

WorkshopPublishOptions

struct

Passed to IModalSystem.WorkshopPublish

folder Sandbox.Model 5

BodyGroupMaskAttribute

attribute

Used to mark properties as a body group mask, so the correct editor can be used

MaterialGroupAttribute

attribute

Used to mark a property as a material group, for the editor

MaterialOverrideAttribute

attribute

Used to mark a property as a material material override dictionary, for the editor

folder Sandbox.Model.BodyPart 1

Choice

class

folder Sandbox.ModelAttachments 1

Attachment

class

deployed_code Sandbox.ModelBuilder 1

Bone

struct

A bone definition for use with Sandbox.ModelBuilder.

label Sandbox.ModelEditor 12

AxisAttribute

attribute

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

BoxAttribute

attribute

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

CapsuleAttribute

attribute

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

CylinderAttribute

attribute

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

EditorWidgetAttribute

attribute

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

GameDataAttribute

attribute

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

HandPoseAttribute

attribute

A helper used for VR hand purposes.

HingeJointAttribute

attribute

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

LineAttribute

attribute

ScaleBoneRelativeAttribute

attribute

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

ScaleWorldAttribute

attribute

Scales the vector with the "ScaleAndMirror" node.

SphereAttribute

attribute

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

label Sandbox.ModelEditor.Internal 2

BaseModelDocAttribute

attribute

BaseTransformAttribute

attribute

folder Sandbox.ModelEditor.Nodes 7

ModelBodygroupDrivenMorph

class

ModelBreakPiece

struct

Defines a single breakable prop gib.

ModelEye

class

Defines an eye on a character model.

ModelEyeOcclusion

class

ModelMaterialGroupDrivenMorph

class

ModelNavData

class

Carries navigation related data.

ModelPropData

class

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

deployed_code Sandbox.ModelPhysics 2

Body

struct

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

Joint

struct

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

list Sandbox.ModelRenderer 1

ShadowRenderType

enum

folder Sandbox.Mounting 6

folder Sandbox.Movement 5

MoveMode

class

A move mode for this character

MoveModeLadder

class

The character is climbing up a ladder

MoveModeSwim

class

The character is swimming

MoveModeWalk

class

The character is walking

SitMoveMode

class

The character is sitting

folder Sandbox.MovieMaker 15

ClipExtensions

class

Helper methods for working with Sandbox.MovieMaker.IMovieClip and Sandbox.MovieMaker.ITrack.

ComponentCapturer<T>

class

Generic helper implementation of Sandbox.MovieMaker.IComponentCapturer.

DefaultMovieRecorderOptionsAttribute

attribute

Call this static method when building Sandbox.MovieMaker.MovieRecorderOptions.Default. The method must have exactly one parameter, of type Sandbox.MovieMaker.MovieRecorderOptions, and must return a Sandbox.MovieMaker.MovieRecorderOptions.

EmbeddedMovieResource

class

An Sandbox.MovieMaker.IMovieClip embedded in a property.

Interpolator

class

Helper for accessing Sandbox.MovieMaker.IInterpolator`1 implementations, for interpolating between two values of the same type

MoviePlayer

class

Plays a Sandbox.MovieMaker.IMovieClip in a Sandbox.Scene to animate properties over time.

MovieRecorder

class

Records properties in a scene to tracks ready for use in a Sandbox.MovieMaker.MoviePlayer. You can use this for in-game demo recording of a whole scene, or only specific properties, configured using Sandbox.MovieMaker.MovieRecorderOptions. You can manually call Sandbox.MovieMaker.MovieRecorder.Advance(Sandbox.MovieMaker.MovieTime) to move the recording time along, then Sandbox.MovieMaker.MovieRecorder.Capture to write all recorded properties to tracks. Alternatively, call Sandbox.MovieMaker.MovieRecorder.Start to automatically advance and capture every fixed update, and Sandbox.MovieMaker.MovieRecorder.Stop to finish recording. Convert the recording to a Sandbox.MovieMaker.Compiled.MovieClip by calling Sandbox.MovieMaker.MovieRecorder.ToClip. This clip can then be played back immediately, or serialized to later use.

MovieRecorderAction

class

Called each time Sandbox.MovieMaker.MovieRecorder.Capture is invoked.

MovieRecorderFilter

class

Returns if the passed shouldn't be recorded. Called once per object.

MovieRecorderOptions

class

Configures a Sandbox.MovieMaker.MovieRecorder, deciding how often it captures and which properties should be recorded.

MovieResource

class

A movie clip created with the MoviePlayer component.

MovieTime

struct

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.

MovieTimeRange

struct

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

TrackBinder

class

Controls which Sandbox.MovieMaker.ITrackTargets from a scene are controlled by which Sandbox.MovieMaker.ITrack from a Sandbox.MovieMaker.IMovieClip. Can be serialized to save which tracks are bound to which targets.

TrackMetadata

class

Additional information used when editing or animating reference tracks.

folder Sandbox.MovieMaker.Compiled 8

CompiledActionBlock

class

Unused, will describe starting / stopping an action in the scene.

CompiledActionTrack

class

CompiledClipExtensions

class

Helper methods for working with Sandbox.MovieMaker.Compiled.MovieClip, Sandbox.MovieMaker.Compiled.ICompiledTrack, or Sandbox.MovieMaker.Compiled.ICompiledBlock.

CompiledConstantBlock<T>

class

This block has a single constant value for the whole duration. Useful for value types that can't be interpolated, and change infrequently.

CompiledPropertyTrack<T>

class

CompiledReferenceTrack<T>

class

CompiledSampleBlock<T>

class

This block contains an array of values sampled at uniform intervals.

MovieClip

class

An immutable compiled Sandbox.MovieMaker.IMovieClip designed to be serialized.

folder Sandbox.MovieMaker.Properties 6

BindingReference

class

Helper methods for working with Sandbox.MovieMaker.Properties.BindingReference`1.

BindingReference<T>

struct

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.

BoneAccessor

class

Pseudo-property on a Sandbox.SkinnedModelRenderer that has a sub-property for each bone. Stores movie-driven transforms for each bone during playback, and applies them when Sandbox.MovieMaker.Properties.MovieBoneAnimatorSystem performs Sandbox.GameObjectSystem.Stage.UpdateBones.

MovieBoneAnimatorSystem

class

Coordinates playing bone animations from Sandbox.MovieMaker.MoviePlayers. Holds a Sandbox.MovieMaker.Properties.BoneAccessor for Sandbox.SkinnedModelRenderers in the scene, which store any movie-controlled bone transforms.

Dummy type for Sandbox.MovieMaker.Properties.ITrackPropertyFactory`1 to return if it matches a track, but doesn't know what target type it maps to.

folder Sandbox.Navigation 5

CalculatePathRequest

struct

Defines the input for a pathfinding request on the navmesh.

NavMesh

class

Navigation Mesh - allowing AI to navigate a world

NavMeshPath

struct

Contains the result of a pathfinding operation.

NavMeshPathPoint

struct

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.

NavMeshPathStatus

enum

deployed_code Sandbox.NavMeshAgent 1

LinkTraversalData

struct

Holds information about the current link the agent is traversing.

folder Sandbox.Network 12

An instance of this is created by the NetworkSystem when a server is joined, or created. You should not try to create this manually.

HostStats

struct

InitialSnapshotResponse

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.

SnapshotMsg

struct

deployed_code Sandbox.Network.SnapshotMsg 1

GameObjectSystemData

struct

folder Sandbox.Package 13

Facet

class

Describes a facet of a group of items, with a limited number of each facet with their total item counts

FindResult

class

A result from the call to FindAsync

ListResult

class

Represents the actual response from the api

Represents an organization on Asset Party. Organization owns packages.

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

PackageUsageStats

struct

Statistics for user interactions with this package

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

TagEntry

struct

Represents a tag along with the count of items it contains

Type

enum

folder Sandbox.Package.Facet 1

Entry

class

A facet entry consists of a name, display information and the number of items inside

folder Sandbox.Package.ListResult 1

Grouping

class

deployed_code Sandbox.Package.PackageUsageStats 1

Group

struct

folder Sandbox.Particle 1

BaseListener

class

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.

list Sandbox.ParticleControlPoint 1

ControlPointValueInput

obsoleteenum

list Sandbox.ParticleEffect 2

list Sandbox.ParticleFloat 2

list Sandbox.ParticleGradient 2

folder Sandbox.ParticleModelRenderer 1

ModelEntry

class

Entry for a model, including its material group and body group settings.

deployed_code Sandbox.ParticleSnapshot 1

Vertex

struct

A vertex to update a particle snapshot with.

list Sandbox.ParticleSpriteRenderer 2

list Sandbox.ParticleTextRenderer 1

ParticleSortMode

enum

folder Sandbox.PartyRoom 2

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

folder Sandbox.Physics 13

BallSocketJoint

class

A ballsocket constraint.

CollisionRules

class

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.

ControlJoint

class

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.

FixedJoint

class

A generic "rope" type constraint.

HingeJoint

class

A hinge-like constraint.

PhysicsJoint

class

A physics constraint.

PhysicsPoint

struct

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.

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

SliderJoint

class

A slider constraint, basically allows movement only on the arbitrary axis between the 2 constrained objects on creation.

SpringJoint

class

A rope-like constraint that is has springy/bouncy.

UprightJoint

class

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.

folder Sandbox.Physics.CollisionRules 2

Pair

struct

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

Result

enum

Result of a collision between two objects.

folder Sandbox.PhysicsBodyBuilder 2

HullSimplify

struct

Settings for simplifying a hull shape.

SimplifyMethod

enum

The method used to simplify a hull.

deployed_code Sandbox.PhysicsContact 1

Target

struct

folder Sandbox.PhysicsGroupDescription 3

folder Sandbox.PhysicsGroupDescription.BodyPart 5

folder Sandbox.Platform 1

Chat

class

Platform-level text chat system. Provides an API for sending and receiving chat messages to users.

folder Sandbox.PolygonMesh 9

BridgeInterpolationParameters

struct

BridgeUVMode

enum

DissolveRemoveVertexCondition

folder Sandbox.PrefabScene 1

VariableCollection

obsoleteclass

A collection of variabnles that have been configured for this scene

deployed_code Sandbox.PrefabVariable 1

PrefabVariableTarget

struct

Targets a property in a component or gameobject.

folder Sandbox.Project 1

VSCodeExtensions

class

folder Sandbox.Razor 1

RenderTreeBuilderOld

obsoleteclass

folder Sandbox.Rendering 15

Represents filtering modes for texture sampling in the rendering pipeline.

GradientFogSetup

struct

Setup for defining gradient fog in a view

HudPainter

struct

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.

ReflectionSetup

struct

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

RefractionSetup

struct

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

RendererSetup

struct

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.

RenderTargetHandle

struct

A render target handle used with CommandLists

Used to describe a GPU resources state for barrier transitions.

SamplerState

struct

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

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

TextureStreaming

class

Gives global access to the texture streaming system.

ViewSetup

struct

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.

folder Sandbox.Rendering.CommandList 2

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

deployed_code Sandbox.Rendering.RenderTargetHandle 4

deployed_code Sandbox.Resource 1

ThumbnailOptions

struct

folder Sandbox.Resources 14

ColorTextureGenerator

class

Generate a texture which is just a single color

EmbeddedResource

struct

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.

ImageFileGenerator

class

Load images from disk and convert them to textures

RandomTextureGenerator

class

RenderTextureAssetGenerator

class

Provides a texture generator entry that returns the texture owned by a RenderTexture asset.

ResourceCompileContext

class

ResourceCompiler

class

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.

ResourceGenerator

class

Creates a resource from a json definition

ResourceGenerator<T>

class

A resource generator targetting a specific type

list Sandbox.Resources.RandomTextureGenerator 1

NoiseType

enum

folder Sandbox.Resources.ResourceCompileContext 2

label Sandbox.Resources.ResourceCompiler 1

ResourceIdentityAttribute

attribute

Mark a ResourceCompiler. This is used to identify the compiler for a specific file extension, or compiler.

deployed_code Sandbox.Resources.ResourceGenerator 1

Options

struct

label Sandbox.Rpc 3

BroadcastAttribute

attribute

Marks a method as being an RPC. It will be called for everyone.

HostAttribute

attribute

Marks a method as being an RPC. It will only be called on the host.

OwnerAttribute

attribute

Marks a method as being an RPC. It will only be called on owner of this object.

folder Sandbox.SceneCamera 1

BloomAccessor

class

list Sandbox.SceneCamera.BloomAccessor 1

BloomMode

enum

list Sandbox.SceneCubemap 1

ProjectionMode

enum

list Sandbox.SceneCullingBox 1

CullMode

enum

Cull mode, either inside or outside

list Sandbox.SceneLight 2

list Sandbox.SceneLineObject 2

folder Sandbox.SceneMapLoader 1

TextSceneObject

class

folder Sandbox.SceneModel 5

Enumeration that describes how the AnimGraph tag state changed. Used in Sandbox.SceneModel.AnimTagEvent.

folder Sandbox.SceneObject 1

SceneObjectFlagAccessor

class

folder Sandbox.SceneSkyBox 3

list Sandbox.ScreenPanel 1

AutoScale

enum

folder Sandbox.SelectionSetsSystem 2

folder Sandbox.SerializedObject 4

PropertyChangedDelegate

class

PropertyFinishEditDelegate

class

PropertyPreChangeDelegate

class

PropertyStartEditDelegate

class

folder Sandbox.SerializedProperty 3

AsAccessor

struct

CustomizableSerializedProperty

class

A proxy around a SerializedProperty that allows overriding any property for UI customization. Unset values fall through to the underlying property.

Proxy

class

Allows easily creating SerializedProperty classes that wrap other properties.

folder Sandbox.Services 15

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.

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.

Allows access to the Steam Inventory system

Implements Steamscreenshots

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.

folder Sandbox.Services.Achievements 1

Map

class

Stats for the current map

folder Sandbox.Services.Inventory 2

Item

class

Describes a type of item that can be in the inventory

ItemDefinition

class

Describes a type of item that can be in the inventory

folder Sandbox.Services.Leaderboards 3

deployed_code Sandbox.Services.Leaderboards.Board2 1

Entry

struct

folder Sandbox.Services.Players 2

Overview

class

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

Profile

class

Player profile

list Sandbox.Services.Reports 1

Reason

enum

folder Sandbox.Services.Review 4

deployed_code Sandbox.Services.ServerList 1

Entry

struct

This is a cleaned up version of gameserveritem_t.

folder Sandbox.Services.Stats 5

Stats for the current map

folder Sandbox.Shader 3

folder Sandbox.SkinnedModelRenderer 4

list Sandbox.SoundEvent 1

SoundSelectionMode

enum

deployed_code Sandbox.SoundFile 2

LoadOptions

struct

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

PcmOptions

struct

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

folder Sandbox.SoundHandle 1

LipSyncAccessor

class

folder Sandbox.Soundscape 2

list Sandbox.SoundscapeTrigger 1

TriggerType

enum

folder Sandbox.Speech 3

Recognition

class

SpeechRecognitionResult

struct

A result from speech recognition.

Synthesizer

class

A speech synthesis stream. Lets you write text into speech and output it to a Sandbox.SoundHandle.

folder Sandbox.Speech.Recognition 1

OnSpeechResult

class

Called when we have a result from speech recognition.

deployed_code Sandbox.Speech.Synthesizer 1

InstalledVoice

struct

folder Sandbox.Spline 3

HandleMode

enum

Describes how the spline should behave when entering/leaving a point.

Point

struct

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

Sample

struct

Information about the spline at a specific distance.

list Sandbox.SpringJoint 1

SpringForceMode

enum

folder Sandbox.Sprite 6

Animation

class

Contains one or multiple frames that can be played in sequence.

AnimationState

class

Contains the state of a sprite instance's animation playback.

BroadcastEvent

class

A message that is broadcast when a frame is displayed.

Describes a single animation frame

LoopMode

enum

The different loop modes for sprite animation.

list Sandbox.SpriteRenderer 1

BillboardMode

enum

list Sandbox.SteamId 1

AccountTypes

enum

The different types of Steam accounts.

folder Sandbox.Storage 6

Entry

class

A folder of content stored on disk

Query

class

Query the Steam Workshop for items

QueryItem

class

Details about a UGC item returned from a Steam Workshop query

QueryResult

class

The results of a Steam Workshop query

This matches ERemoteStoragePublishedFileVisibility in native

deployed_code Sandbox.StreamPoll 1

Choice

struct

deployed_code Sandbox.StreamPrediction 1

Outcome

struct

label Sandbox.StringToken 1

ConvertAttribute

attribute

To allow redirecting in the case where a class has both a string and StringToken version of a method. We should be able to remove this when we're compiling on demand instead of keeping the string versions around for compatibility.

deployed_code Sandbox.Surface 5

SurfacePrefabCollection

struct

Holds a dictionary of common prefabs associated with a surface

SurfaceSoundCollection

struct

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

folder Sandbox.TagSet 1

JsonConvert

class

deployed_code Sandbox.Tasks 1

SyncTask

struct

folder Sandbox.Terrain 2

Information about terrain materials at a specific position

folder Sandbox.TerrainStorage 1

TerrainMaterialSettings

class

list Sandbox.TextRenderer 2

HAlignment

enum

Represents the horizontal alignment of the text.

VAlignment

enum

Represents the vertical alignment of the text.

deployed_code Sandbox.TextRendering 3

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

Shadow

struct

list Sandbox.Tonemapping 2

ExposureColorSpaceEnum

enum

TonemappingMode

enum

Options to select a tonemapping algorithm to use for color grading.

folder Sandbox.UI 119

Align

enum

Possible values for align-items CSS property.

BackdropDrawDescriptor

struct

BackgroundRepeat

enum

Possible values for background-repeat CSS property.

A panel that gets deleted automatically when clicked away from

BaseStyles

class

Auto generated container class for majority of CSS properties available.

BaseVirtualPanel

class

Base class for virtualized, scrollable panels that only create item panels when visible.

BorderImageFill

enum

State of fill setting of border-image-slice (border-image) CSS property.

BorderImageRepeat

enum

Possible values for border-image-repeat (border-image) CSS property.

Box

class

Represents position and size of a Sandbox.UI.Panel on the screen.

Keyboard (and mouse) key press Sandbox.UI.PanelEvent.

ButtonGroup

class

CascadingParameterAttribute

attribute

A panel's property will be inherited from its parent.

ColorSaturationValueControl

ControlSheetGroupHeader

Possible values for display CSS property.

Helper class for working with Unicode emoji.

Possible values for flex-direction CSS property.

FontSmooth

enum

Possible values for font-smooth CSS property.

FontStyle

enum

Possible values for font-style CSS property.

FontVariantNumeric

enum

Possible values for font-variant-numeric CSS property.

A generic box that displays a given texture within itself.

ImageRendering

enum

Possible values for image-rendering CSS property.

InputFocus

class

Handles input focus for Sandbox.UI.Panels.

Justify

enum

Possible values for justify-content CSS property.

KeyFrames

class

Represents a CSS @keyframes rule.

Label

class

A generic text label. Can be made editable.

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.

LengthUnit

enum

Possible units for various CSS properties that require length, used by Sandbox.UI.Length struct.

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

MaskMode

enum

Possible values for mask-mode CSS property.

MaskScope

enum

Possible values for mask-scope CSS property.

Represents a parsed @mixin definition that can be included elsewhere.

MixinParameter

struct

A single parameter in a mixin definition.

MousePanelEvent

class

Mouse related Sandbox.UI.PanelEvent.

OutlineDrawDescriptor

struct

OverflowMode

enum

Possible values for the "overflow" CSS rule, dictating what to do with content that is outside of a panels bounds.

A simple User Interface panel. Can be styled with CSS.

PanelEvent

class

Base Sandbox.UI.Panel event.
See Sandbox.UI.Panel.CreateEvent(Sandbox.UI.PanelEvent).

PanelEventAttribute

attribute

Add an event listener to a Sandbox.UI.Panel event with the given name.
See Sandbox.UI.Panel.CreateEvent(System.String,System.Object,System.Nullable{System.Single}).

PanelInputType

enum

PanelRenderTreeBuilder

class

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.

Possible values for pointer-events CSS property.

Possible values for position CSS property.

PseudoClass

enum

List of CSS pseudo-classes used by the styling system for hover, active, etc. This acts as a bit-flag.

RenderState

struct

Describes panel's position and size for rendering operations.

RootPanel

class

A root panel. Serves as a container for other panels, handles things such as rendering.

ScenePanel

class

Allows to render a scene world onto a panel.

Shadow style settings

A CSS rule - ie ".chin { width: 100%; height: 100%; }"

Styles

class

Represents all supported CSS properties and their currently assigned values.

StyleSelector

class

A CSS selector like "Panel.button.red:hover .text"

Will automatically apply the named stylesheet to the Panel.

StyleSheetCollection

struct

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

SvgPanel

class

A generic panel that draws an SVG scaled to size

Possible values for text-align CSS property.

TextDecoration

enum

Possible values for text-decoration CSS property.

TextDecorationStyle

enum

Possible values for text-decoration-style CSS property.

Possible values for text-overflow CSS property.

TextSkipInk

enum

Possible values for text-decoration-skip-ink CSS property.

TextTransform

enum

Possible values for text-transform CSS property.

TransitionDesc

struct

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.

TransitionList

class

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.

Transitions

class

Handles the storage, progression and application of CSS transitions for a single Sandbox.UI.Panel.

A virtualized, scrollable grid panel that only creates item panels when visible.

VirtualList

class

A virtualized, scrollable list panel that only creates item panels when visible.

WebPanel

class

A panel that displays an interactive web page.

WhiteSpace

enum

Possible values for white-space CSS property.

WordBreak

enum

Possible values for word-break CSS property.

An interactive 2D panel rendered in the 3D world.

Wrap

enum

Possible values for flex-wrap CSS property.

folder Sandbox.UI.Construct 5

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

SceneConstructor

class

deployed_code Sandbox.UI.IStyleBlock 1

StyleProperty

struct

folder Sandbox.UI.KeyFrames 1

Block

class

A keyframe within the animation.

folder Sandbox.UI.Navigation 3

list Sandbox.UI.PackageCard 1

SizeType

enum

folder Sandbox.UI.Panel 1

Draw

class

To be used inside Sandbox.UI.Panel.OnDraw 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 );
}