namespace Sandbox

in global

This namespace contains:

namespace ActionGraphs
namespace Audio
namespace DataModel
namespace Diagnostics
namespace Engine
namespace Html
namespace Internal
namespace Localization
namespace Menu
namespace Modals
namespace ModelEditor
namespace Mounting
namespace Movement
namespace Navigation
namespace Network
namespace Physics
namespace Razor
namespace Rendering
namespace Resources
namespace Services
namespace Speech
namespace Tasks
namespace UI
namespace Utility
namespace Volumes
namespace VR
class Achievement
class AchievementCollection Holds achievements for a package
class ActionGraphExposeWhenCachedAttribute Don't cache instances of this type when serializing action graph references, force them to be always serialized separately. We need this for component / game object references so we can update IDs when duplicating objects / instantiating prefabs.
class ActionGraphIgnoreAttribute
class ActionGraphIncludeAttribute
class ActionGraphNodeAttribute No summary.
class ActionGraphOperatorAttribute Display this node as an operator, with no header or socket labels, and a big icon in the middle.
class ActionGraphPropertyAttribute In ActionGraph, this parameter should only be configurable in the inspector as a property and not have a dedicated input.
class ActionGraphTargetAttribute No summary.
class ActionNodeAttribute
class AmbientLight Adds an ambient light to the scene, applied globally.
class AmbientOcclusion Adds an approximation of ambient occlusion using Screen Space Ambient Occlusion (SSAO). It darkens areas where ambient light is generally occluded from such as corners, crevices and surfaces that are close to each other.
struct AmbientOcclusion.DenoiseModes
struct AmbientOcclusion.SampleQuality
class AnimationBuilder Provides ability to generate animations for a at runtime. See
class AnimationGraph
class AnimationSequence
class AnimGraphDirectPlayback For communicating with a Direct Playback Anim Node, which allows code to tell it to play a given sequence
struct AnimParam<T> Anim param values contain any value for a limited set of types
class Application
class AssetPathAttribute When added to a string property, will becomes a selector for AssetTypeExtension
class AudioListener 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.
struct AudioSurface Defines acoustic properties of a surface, which defines how sound will bounce
class AuthorityAttribute Marks a method as being an RPC specifically targeted to the owner of the , or the host if the doesn't have an owner. The state of the object the RPC is called on will be up-to-date including its and any properties with the or attributes by the time the method is called on remote clients. The only except is any synchronized properties marked with which will generally only be received every network tick.
class AutoGenerateAttribute 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.
class BallJoint Fix two objects together but can rotate - like a shoulder.
class BaseFileSystem 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.
class BaseSoundComponent
class BitFlagsAttribute This choices type is bitflags, so we should be able to choose more than one option at a time.
class Bitmap
struct BlendMode Blend modes used by the UI system
class Bloom Applies a bloom effect to the camera
class Blur Applies a blur effect to the camera.
class BoneCollection A collection of bones. This could be from a model, or an entity
class BoneCollection.Bone A bone in a .
class BoxCollider Defines a box collider.
class BroadcastAttribute Marks a method as being an RPC that when invoked will be called for all connected clients including the host. The state of the object the RPC is called on will be up-to-date including its and any properties with the or attributes by the time the method is called on remote clients. The only except is any synchronized properties marked with which will generally only be received every network tick.
class ButtonAttribute When added to a method - the inspector will show a button for it.
struct ByteStream A result of SpeedTest.MemoryAlloc - to make it easy to use this instead of AllocHGlobal
class CachingHandler
class CameraComponent Every scene should have at least one Camera.
struct CameraComponent.Axis
interface CameraComponent.ISceneCameraSetup
class CapsuleCollider Defines a capsule collider.
class CaseInsensitiveConcurrentDictionary<T>
class CaseInsensitiveDictionary<T>
class ChangeAttribute 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.
class CharacterController Allows collision contrained movement without the need for a rigidbody. This is not affected by forces and will only move when you call the Move() method.
struct CharacterControllerHelper
class ChromaticAberration Applies a chromatic aberration effect to the camera
struct ClearFlags Flags for clearing a RT before rendering a scene using a SceneCamera
struct CloneConfig The low level input of a GameObject.Clone
class Clothing A piece of player model customization.
struct Clothing.BodyGroups
struct Clothing.ClothingCategory
struct Clothing.IconSetup
struct Clothing.IconSetup.IconModes
struct Clothing.Slots
class ClothingContainer Holds a collection of clothing items. Won't let you add items that aren't compatible.
class ClothingContainer.ClothingEntry
class ClothingContainer.Entry Used for serialization
class Cloud For accessing assets from the cloud - from code
class Cloud.AssetAttribute Automatically addeded to a type as a result of using Cloud.Model etc inside.
class CodeGeneratorAttribute An attribute that can be added to a custom class for special code generation behavior. They'll then be applied to methods and properties when they are decorated with that attribute.
struct CodeGeneratorFlags Used to specify what type of code generation to perform.
class Collider
struct Collision
class CollisionSoundSystem 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.
struct CollisionSource
struct CollisionStop
class ColorAdjustments Applies color adjustments to the camera.
class ColorGradient A color gradient for use as entity and asset properties TODO: Gradient property editor
class ColorGrading Applies color grading to the camera
struct ColorGrading.ColorSpaceEnum
struct ColorGrading.GradingType
class ColorUsageAttribute When applied to a Color property, allows you to specify whether the color should have an alpha channel and/or be in HDR.
class Component A GameObject can have many components, which are the building blocks of the game.
interface Component.ExecuteInEditor A component with this interface will run in the editor.
interface Component.ICollisionListener A with this interface can react to collisions.
interface Component.IColorProvider When applied to a , the component will be able to provide the color to use for certain UI editor elements.
interface Component.IDamageable A component that can be damaged by something.
interface Component.IHasBounds A component that has bounds
interface Component.IMaterialSetter
interface Component.INetworkListener A with this interface can react to network events.
interface Component.INetworkSnapshot When implemented on a it can read and write data to and from a network snapshot.
interface Component.INetworkSpawn A with this interface can listen for when a GameObject in its ancestors has been network spawned.
interface Component.IPressable A component that can be pressed. Like a button. This could be by a player USE'ing it, or by a player walking on it, or by an NPC. A call to Press should ALWAYS call release afterwards. Generally this is done by the player, where holding E presses the button, and releasing E stops pressing it. You need to handle edge cases where the player dies while holding etc.
struct Component.IPressable.Event Describes who pressed it.
interface Component.ISceneStage Called on update start. This is the very first thing called.
interface Component.ITemporaryEffect Allows components to indicate their state in a generic way. This is useful if you have a temporary effect system in which you want to remove GameObjects when their effects have all finished.
interface Component.ITintable A that lets you change its color.
interface Component.ITriggerListener A with this interface can react to interactions with triggers.
struct ComponentFlags
class ComponentList
class ComputeBuffer<T>
struct ComputeBufferType
class ComputeShader A compute shader is a program that runs on the GPU, often with data provided to/from the CPU by means of a or a .
class ConCmdAttribute
struct ConCmdAttribute.AutoCompleteResult
class ConfigData Project configuration data is derived from this class
class Connection A connection, usually to a server or a client.
struct Connection.Filter
struct Connection.Filter.FilterType
class ConsoleSystem A library to interact with the Console System.
class ControlModeSettings
class ConVarAttribute Console variable
struct ConVarFlags
class CookieContainer
class CubemapFog Applies a cubemap fog effect to the camera
class CubemapFogController
struct CurrencyValue Describes money, in a certain currency
class CursorSettings
struct CursorSettings.Cursor
struct Curve Describes a curve, which can have multiple key frames.
struct Curve.Frame Keyframes times and values should range between 0 and 1
struct Curve.HandleMode Describes how the line should behave when entering/leaving a frame
struct CurveRange Two curves
class CustomEditorAttribute
class DamageInfo 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.
class DebugOverlaySystem
class Decal 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.
class DecalDefinition A decal which can be applied to objects and surfaces.
class DecalDefinition.DecalEntry
class DecalRenderer Component that creates a projected decal relative to its GameObject.
class DepthOfField Applies a depth of field effect to the camera
struct DepthOfField.Quality
class DirectionalLight A directional light that casts shadows, like the sun.
struct DisplayInfo Collects all the relevant info (such as description, name, icon, etc) from attributes and other sources about a type or type member.
class DspVolume
class EditorContext
class EditorContext.EntityObject
class EditorHandleAttribute When applied to a component, the editor will draw a selectable handle sprite for the gameobject in scene
struct EditorTint
class EnumDescription
struct EnumDescription.Entry
class EnvmapProbe A cubemap probe that captures the environment around it.
struct EnvmapProbe.CubemapDynamicUpdate
struct EnvmapProbe.CubemapResolution
class EventAttribute A generic event listener. You are probably looking for Sandbox.Event.* attributes.
class ExpressionNodeAttribute
class FeatureAttribute Sets the category or the group of a type or a type member. This info can then be retrieved via DisplayInfo library.
class FeatureEnabledAttribute Mark a boolean property as a feature toggle
class FGDCurve A helper class to handle 'curve' FGD type. TOOD: Get rid of in favor of new curve stuff.
class FGDTypeAttribute Overrides the auto generated FGD type.
class FieldDescription Describes a field. We use this class to wrap and return FieldInfo's that are safe to interact with. Returned by and .
class FileSystem A filesystem that can be accessed by the game.
class FileWatch Watch folders, dispatch events on changed files
class FilmGrain Applies a film grain effect to the camera
struct FindMode Flags to search for Components. I've named this something generic because I think we can re-use it to search for GameObjects too.
class FixedJoint Weld two physics objects together
struct FloatSpan Allows easy SIMD/AVX2 fast math on a span of floats
class FontNameAttribute When applied to a string property, uses a font name selector.
struct Friend
struct Frustum Represents a frustum.
class Game
class Game.Overlay
class GameObject 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.
struct GameObject.DeserializeOptions
class GameObject.NetworkAccessor
class GameObject.SerializeOptions
class GameObjectDirectory 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.
struct GameObjectFlags
class GameObjectSystem 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.
interface GameObjectSystem.ITraceProvider When implementing an ITraceProvider, the most importannt thing to keep in mind is that the call to DoTrace should be thread safe. This might be called from multiple threads at once, so you better watch out.
struct GameObjectSystem.Stage A list of stages in the scene tick in which we can hook
class GameObjectSystem<T> A syntax sugar wrapper around GameObjectSystem, which allows you to access your system using SystemName.Current instead of Scene.GetSystem.
struct GameObjectUndoFlags
struct GamepadCode Game controller codes, driven from SDL.
class GameResource Assets defined in C# and created through tools. You can define your own Custom Asset Types.
class GameResourceAttribute Should be applied to a class that inherits from . Makes the class able to be stored as an asset on disk.
class GameTags 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.
class GameTask A generic .
class GameTransform
class Gib A gib is a prop that is treated slightly different. It will fade out after a certain amount of time.
class Gizmo
class Gizmo.Colors Using pure primary colors is horrible. Lets make it easier to avoid.
class Gizmo.GizmoControls Extendable helper to create common gizmos
class Gizmo.GizmoDraw Contains functions to add objects to the Gizmo Scene. This is an instantiable class so it's possible to add extensions.
class Gizmo.GizmoHitbox Contains functions to add objects to the immediate mode Scene. This is an instantiable class so it's possible to add extensions.
struct Gizmo.GridAxis
struct Gizmo.Inputs The input state, allows interaction with Gizmos
class Gizmo.Instance 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.
class Gizmo.Pressed Access to the currently pressed path information
class Gizmo.SceneSettings
struct GlyphStyle
class GpuBuffer A GPU data buffer intended for use with a . You can read and write arbitrary data to and from the CPU and GPU. This allows for efficient parallel data processing on the GPU. Different GPU buffer types can be used depending on the provided . Using the default type buffers map to StructuredBuffer<T> and RWStructuredBuffer<T> in HLSL.
struct GpuBuffer.IndirectDispatchArguments
struct GpuBuffer.IndirectDrawArguments
struct GpuBuffer.IndirectDrawIndexedArguments
struct GpuBuffer.UsageFlags 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.
class GpuBuffer<T> A typed GpuBuffer
struct Gradient Describes a gradient between multiple colors
struct Gradient.AlphaFrame Keyframes times and values should range between 0 and 1
struct Gradient.BlendMode Describes how the line should behave when entering/leaving a frame
struct Gradient.ColorFrame Keyframes times and values should range between 0 and 1
class GradientFog Adds a gradient fog to the world
struct GradientFogController
class Graphics 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.
struct Graphics.DownsampleMethod Which method to use when downsampling a texture
struct Graphics.PrimitiveType
class HammerMesh 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.
class HapticEffect Contains a haptic effect, which consists of patterns for the controller and triggers.
class HapticPattern Contains a haptic pattern, which consists of frequency and amplitude values that can change over time.
struct HapticTarget Places you can trigger haptics on
class HasImplementationAttribute 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 .
class HeaderAttribute Add a header above this property
class HelpUrlAttribute Add a link to some documentation for this component, or
class HideAttribute Hide this in tools/editors.
class Highlight This should be added to a camera that you want to outline stuff
class HighlightOutline 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.
class HingeJoint Create a hinged connection between two physics objects. Like a door hinge or a wheel.
struct HingeJoint.MotorMode
class Hitbox
class HitboxSet
class HitboxSet.Box
class HostSyncAttribute Automatically synchronize a property of a networked object from the host to other clients. Obsolete: 11/12/2024
class Http Lets your game make async HTTP requests.
class HullCollider Defines a box, cone, or cylinder hull collider.
struct HullCollider.PrimitiveType
interface IByteParsable
struct IByteParsable.ByteParseOptions
interface IByteParsable<T>
interface IComponentLister Interface for types that reference a , to provide convenience method for accessing that list.
class IconNameAttribute When applied to a string property, uses a Material Icon selector.
interface IGameInstance Todo: make internal - the only thing using ir right now is the binds system
interface IGameObjectNetworkEvents Allows listening to network events on a specific GameObject
interface IHotloadManaged During hotloads, instances of types implementing this interface will be notified when they get replaced.
interface IJsonConvert Allows writing JsonConverter in a more compact way, without having to pre-register them.
interface IJsonPopulator Objects that need to be deserialized into can implement this interface which allows them to be populated from a JSON object.
class ImageAssetPathAttribute When added to a string property, will become an image string selector
struct ImageFormat
interface IMemberAttribute When applied to an attribute, which is them applied to a member.. This will make set on the attribute upon load. This provides a convenient way to know which member the attribute was attached to.
class ImpureAttribute No summary.
class InlineEditorAttribute Tell the editor to try to display inline editing for this property, rather than hiding it behind a popup etc.
class Input Allows querying of player button presses and other inputs.
class Input.Keyboard
class InputAction An input action defined by a game project.
class InputActionAttribute When applied to a string property, use an input action selector.
struct InputAnalog An analog input, when fetched, is between -1 and 1 (0 being default)
class InputAttribute Makes this method available as a Map Logic Input, for use in the Hammer Editor. This is only applicable to entities.
struct InputGlyphSize
struct InputMotionData Represents the current state of a device's motion sensor(s).
class InputSettings 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.
class InspectorVisibilityAttribute Hide a property if a condition matches.
interface ISceneCollisionEvents Listen to all collision events that happen during a physics step.
interface ISceneEvent<T> A wrapper for scene event interfaces. Allows syntax sugar of something like `IPlayerEvents.Post( x => x.OnPlayerHurt( this, amount ) )` instead of using Scene.Run to call them manually.
interface ISceneLoadingEvents Allows listening to events related to scene loading
interface ISceneMetadata Allows components to add metadata to the scene/prefab file, which is accessible before loading it.
interface IScenePhysicsEvents Allows events before and after the the physics step
interface ISceneStartup Allows listening to events related to scene startup. This should really only apply to GameObjectSystem's because components won't have been spawned/created when most of this is invoked.
interface ISceneUndoScope
class ITagSet
interface ITypeAttribute When applied to an attribute, which is then applied to a type.. This will make set on the attribute upon load. This provides a convenient way to know which type the attribute was attached to.
interface IValid This object can become invalid
class Joint
struct Joint.AttachmentMode
struct JointMotion
class Json A convenience JSON helper that handles types for you.
class Json.Pointer Represents a JSON Pointer as defined in RFC 6901.
class Json.PointerJsonConverter 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.
class JsonUpgraderAttribute An attribute that describes a version update for a JSON object.
struct KeyboardModifiers
class KeyPropertyAttribute 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.
class Language Allows access to translated phrases, allowing the translation of gamemodes etc
class LaunchArguments These are arguments that were set when launching the current game. This is used to pre-configure the game from the menu
class LegacyParticleSystem Support's Source Engine's vpcf particles
class LibraryAttribute
class Light
struct Light.FogInfluence
class LineRenderer Renders a line between a list of points
class LipSync Drive morphs with lipsync from sounds.
class LoadingScreen Holds metadata and raw data relating to a Saved Game.
struct LoadSceneBeginMsg
struct LogEvent
struct LogLevel
class MainThread Utility functions that revolve around the main thread
class MakeDirtyAttribute
class ManifestSchema An addon's manifest, describing what files are available
struct ManifestSchema.File
class ManualHitbox A hitbox that can be placed manually on a GameObject, instead of coming from a model
struct ManualHitbox.HitboxShape
class Map
class MapAssetPathAttribute When added to a string property, will become a map string selector
class MapCollider
class MapInstance Allows you to load a map into the Scene. This can be either a vpk or a scene map.
class MapLoader
struct MapLoader.ObjectEntry Holds key values for the map object
class MapObjectComponent
class MapSkybox3D
class Material A material. Uses several s and a with specific settings for more interesting visual effects.
struct Material.FlagsAccessor
class Material.UI Static materials for UI rendering purposes.
class MathX 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();`
class MemberDescription Wraps MemberInfo but with caching and sandboxing. Returned by and .
class Mesh A mesh is a basic version of a , containing a set of vertices and indices which make up faces that make up a shape. A set of meshes can be used to create a via the class.
class Mesh.IndexBufferLockHandler
class Mesh.VertexBufferLockHandler<T>
class MeshComponent An editable polygon mesh with collision
struct MeshComponent.CollisionType
struct MeshPrimitiveType Possible primitive types of a .
class Metadata A simple class for storing and retrieving metadata values.
class MethodArgumentsAttribute 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.
class MethodBodyChangeAttribute
class MethodDescription Describes a method. We use this class to wrap and return MethodInfo's that are safe to interact with. Returned by and .
class MissingComponent 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.
class Model A model.
class Model.BodyGroupMaskAttribute Used to mark properties as a body group mask, so the correct editor can be used
class Model.BodyPart
class Model.BodyPart.Choice
class Model.MaterialGroupAttribute Used to mark a property as a material group, for the editor
class Model.MaterialOverrideAttribute Used to mark a property as a material material override dictionary, for the editor
struct ModelArchetype Default model archetypes. These types are defined in "tools/model_archetypes.txt".
class ModelAttachments
class ModelAttachments.Attachment
class ModelBuilder Provides ability to generate s at runtime. A static instance of this class is available at
struct ModelBuilder.Bone A bone definition for use with .
class ModelCollider Defines a collider based on a model.
class ModelHitboxes Hitboxes from a model
class ModelMorphs Allows fast lookups of morph variables
class ModelPhysics Physics for a model. This is primarily used for ragdolls and other physics driven models, otherwise you should be using a Rigidbody.
class ModelRenderer Renders a model in the world
struct ModelRenderer.ShadowRenderType
class MorphCollection Used to access and manipulate morphs.
class MotionBlur Applies a motion blur effect to the camera
class Mouse Gives access to mouse position etc
struct MouseButtons State of mouse buttons being pressed or not.
struct MouseVisibility The visibility state of the mouse cursor.
struct MultisampleAmount
class MultiSerializedObject An object (or data) that can be accessed as an object
class MusicPlayer Enables music playback. Use this for music, not for playing game sounds.
class NavMeshAgent An agent that can navigate the navmesh defined in the scene.
struct NavMeshAgent.LinkTraversalData Holds information about the current link the agent is traversing.
class NavMeshArea 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.
class NavMeshLink NavigationLinks connect navigation mesh polygons for pathfinding and enable shortcuts like ladders, jumps, or teleports.
class NetDictionary<TKey,TValue> A networkable dictionary for use with the and . Only changes will be networked instead of sending the whole dictionary every time, so it's more efficient. Example usage: public class MyComponent : Component { [Sync] public NetDictionary<string,bool> MyBoolTable { get; set; } = new(); public void SetBoolState( string key, bool state ) { if ( IsProxy ) return; MyBoolTable[key] = state; } }
struct NetFlags
class NetList<T> A networkable list for use with the and . Only changes will be networked instead of sending the whole list every time, so it's more efficient. Example usage: public class MyComponent : Component { [Sync] public NetList<int> MyIntegerList { get; set; } = new(); public void AddNumber( int number ) { if ( IsProxy ) return; MyIntegerList.Add( number ); } }
struct NetPermission Specifies who can invoke an action over the network.
class Networking Global manager to hold and tick the singleton instance of NetworkSystem.
class NetworkingSettings 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.
struct NetworkMode Specifies how a should be networked.
struct NetworkOrphaned Specifies what happens when the owner of a networked object disconnects.
struct ObjectCreateBatchMsg
struct ObjectCreateMsg
struct ObjectDestroyMsg
struct ObjectNetworkTableMsg
struct ObjectRefreshMsg
struct ObjectRefreshMsgAck
struct ObjectRpcMsg
struct OwnerTransfer Specifies who can control ownership of a networked object.
class Package Represents an asset on Asset Party.
class Package.Facet Describes a facet of a group of items, with a limited number of each facet with their total item counts
class Package.Facet.Entry A facet entry consists of a name, display information and the number of items inside
class Package.FindResult A result from the call to FindAsync
interface Package.IRevision
class Package.ListResult Represents the actual response from the api
class Package.ListResult.Grouping
struct Package.LoadingScreenSetup
class Package.Organization Represents an organization on Asset Party. Organization owns packages.
struct Package.PackageInteraction
struct Package.PackageProperty A binary category used to divide into two categories. For example, Work In Progress.
struct Package.PackageUsageStats Statistics for user interactions with this package
struct Package.PackageUsageStats.Group
struct Package.ReviewStats
class Package.Screenshot
struct Package.SortOrder Describes a sort order which can be used with the package/find api
struct Package.TagEntry Represents a tag along with the count of items it contains
struct Package.Type
class PanelComponent
class Particle
class Particle.BaseListener 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.
class ParticleAttractor Attract particles to a GameObject in the scene
class ParticleBoxEmitter Emits particles within a box shape.
class ParticleConeEmitter Emits particles within/along a cone shape.
class ParticleController Particles can have extra controllers that can modify the particles every frame.
struct ParticleControlPoint
struct ParticleControlPoint.ControlPointValueInput
class ParticleEffect Defines and holds particles. This is the core of the particle system.
struct ParticleEffect.SimulationSpace
class ParticleEmitter Creates particles. Should be attached to a .
struct ParticleFloat
struct ParticleFloat.EvaluationType
struct ParticleFloat.ValueType
struct ParticleGradient
struct ParticleGradient.EvaluationType
struct ParticleGradient.ValueType
class ParticleLightRenderer Adds lighting to particles in your effect.
class ParticleModelEmitter Emits particles in a model
class ParticleModelRenderer Renders particles as models, using the particle's position, rotation, and size.
class ParticleModelRenderer.ModelEntry
class ParticleRenderer Renders a set of particles. Should be attached to a .
class ParticleRingEmitter 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.
class ParticleSnapshot A particle snapshot that can be created procedurally. Contains a set of vertices that particle effects can address.
struct ParticleSnapshot.Vertex A vertex to update a particle snapshot with.
class ParticleSphereEmitter Emits particles within a sphere shape.
class ParticleSpriteRenderer Renders particles as 2D sprites
struct ParticleSpriteRenderer.BillboardAlignment
struct ParticleSpriteRenderer.ParticleSortMode
class ParticleSystem A particle effect system that allows for complex visual effects, such as explosions, muzzle flashes, impact effects, etc.
class ParticleTextRenderer Renders particles as 2D sprites
struct ParticleTextRenderer.BillboardAlignment
struct ParticleTextRenderer.ParticleSortMode
class ParticleTrailRenderer Renders a trail for each particle in the effect.
struct ParticleVector3
class PartyRoom A Party. A Party with your friends.
struct PartyRoom.Entry
class PhysicsBody Represents a physics object. An entity can have multiple physics objects. See PhysicsGroup. A physics objects consists of one or more PhysicsShapes.
struct PhysicsBodyType
struct PhysicsContact
struct PhysicsContact.Target
class PhysicsGroup Represents a set of PhysicsBody objects. Think ragdoll.
class PhysicsGroupDescription
class PhysicsGroupDescription.BodyPart
class PhysicsGroupDescription.BodyPart.CapsulePart
class PhysicsGroupDescription.BodyPart.HullPart
class PhysicsGroupDescription.BodyPart.MeshPart
class PhysicsGroupDescription.BodyPart.Part
class PhysicsGroupDescription.BodyPart.SpherePart
class PhysicsGroupDescription.Joint
struct PhysicsGroupDescription.JointType
struct PhysicsIntersection
struct PhysicsIntersectionEnd
struct PhysicsLock
struct PhysicsMotionType Represents Physics body's motion type.
class PhysicsShape Represents a basic, convex shape. A PhysicsBody consists of one or more of these.
struct PhysicsSimulationMode Physics simulation mode. For use with .
struct PhysicsTraceBuilder
struct PhysicsTraceResult
class PhysicsWorld 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.
class Pixelate Applies a pixelate effect to the camera
struct Plane Represents a plane.
class PlaneCollider Defines a plane collider.
class PlayerController
interface PlayerController.IEvents Events from the PlayerController
class PointLight Emits light in all directions from a point in space.
class PolygonMesh An editable mesh made up of polygons, triangulated into a model
struct PolygonMesh.BevelEdgesMode
struct PolygonMesh.DissolveRemoveVertexCondition
struct PolygonMesh.EdgeSmoothMode
struct PolygonMesh.ExtentType
class PolygonMesh.FaceExtents
struct PolygonMesh.TextureJustification
class PostProcess Adds an effect to the camera
class PrefabFile
class PrefabScene
class PrefabScene.VariableCollection A collection of variabnles that have been configured for this scene
class PrefabVariable A prefab variable definition
struct PrefabVariable.PrefabVariableTarget Targets a property in a component or gameobject.
class Preferences Holds information about the current user's preferences.
class Project Represents an on-disk project.
class ProjectSettings
class Prop 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.
struct PropertyAccessor
class PropertyAccessorBodyChangeAttribute
class PropertyAttribute
class PropertyDescription Describes a property. We use this class to wrap and return PropertyInfo's that are safe to interact with. Returned by and .
class PureAttribute No summary.
class RangeAttribute Mark this property as a ranged float/int. In inspector we'll be able to create a slider instead of a text entry. TODO: Replace this with the System.ComponentModel.DataAnnotations.Range one - move step and clamped to their own attributes
class ReadOnlyAttribute Display this in the inspector - but don't let anyone edit it
class RealTime Access to time.
struct RealTimeSince A convenience struct to easily measure time since an event last happened, based on . Typical usage would see you assigning 0 to a variable of this type to reset the timer. Then the struct would return time since the last reset. i.e.: RealTimeSince lastUsed = 0; if ( lastUsed > 10 ) { /*Do something*/ }
struct RealTimeUntil A convenience struct to easily manage a time countdown, based on . Typical usage would see you assigning to a variable of this type a necessary amount of seconds. Then the struct would return the time countdown, or can be used as a bool i.e.: RealTimeUntil nextAttack = 10; if ( nextAttack ) { /*Do something*/ }
struct Rect Represents a rectangle.
struct RectInt Represents a rectangle but with whole numbers
class RenderAttributes
class Renderer
class RenderOptions
class RenderTarget Essentially wraps a couple of textures that we're going to render to. The color texture and the depth texture.
class RequireComponentAttribute 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.
class Resource A resource loaded in the engine, such as a or .
class ResourceExtension<T,TSelf> An extension of ResourceExtension[t], this gives special helper methods for retrieving resources targetting specific assets.
class ResourceExtension<T> 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.
class ResourceLibrary Keeps a library of all available .
interface ResourceLibrary.IEventListener
class ResourceTypeAttribute 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"
class Rigidbody Adds physics properties to an object. Requires a collider to be attached to the same object.
struct RigidbodyFlags
class Rpc
class Rpc.BroadcastAttribute Marks a method as being an RPC. It will be called for everyone.
class Rpc.HostAttribute Marks a method as being an RPC. It will only be called on the host.
class Rpc.OwnerAttribute Marks a method as being an RPC. It will only be called on owner of this object.
class RpcAttribute Marks a method as being an RPC. This means that it can be called over the network.
class SandboxGameExtensions
class SandboxGameExtensions
class SandboxSystemExtensions
class Scene
interface Scene.ISceneEditorSession
class SceneAnimationSystem
class SceneCamera Represents a camera and holds render hooks. This camera can be used to draw tool windows and scene panels.
class SceneCamera.BloomAccessor
struct SceneCamera.BloomAccessor.BloomMode
class SceneCamera.TonemapAccessor
struct SceneCameraDebugMode
class SceneCubemap
struct SceneCubemap.ProjectionMode
class SceneCullingBox 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)
struct SceneCullingBox.CullMode Cull mode, either inside or outside
class SceneCustomObject A scene object that allows custom rendering within a scene world.
class SceneDirectionalLight A directional scene light that is used to mimic sun light in a . Direction is controlled by this objects' .
class SceneDynamicObject
class SceneFile
class SceneFogVolume Represents a volume of fog in a scene, contributing to volumetric fog effects set on .
class SceneInformation
struct SceneLayerType
class SceneLight Generic point light scene object for use with a .
struct SceneLight.FogLightingMode
struct SceneLight.LightShape
class SceneLineObject A scene object which is used to draw lines
struct SceneLineObject.CapStyle
struct SceneLineObject.FaceMode
struct SceneLoadedMsg
class SceneLoadOptions
class SceneMap Map geometry that can be rendered within a .
class SceneMapLoader
class SceneMapLoader.TextSceneObject
class SceneModel A model scene object that supports animations and can be rendered within a .
struct SceneModel.AnimTagEvent
struct SceneModel.AnimTagStatus Enumeration that describes how the AnimGraph tag state changed. Used in .
struct SceneModel.FootstepEvent
struct SceneModel.GenericEvent
struct SceneModel.SoundEvent
class SceneNetworkSystem This is created and referenced by the network system, as a way to route.
struct SceneNetworkTableMsg
class SceneObject A model scene object that can be rendered within a .
class SceneObject.SceneObjectFlagAccessor
class SceneParticles 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.
struct SceneRenderLayer 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.
struct SceneRpcMsg
class SceneSkyBox Renders a skybox within a .
struct SceneSkyBox.FogParamInfo
struct SceneSkyBox.FogType
struct SceneSkyBox.SkyLightInfo
class SceneSpotLight A simple spot light scene object for use in a .
struct SceneTrace
struct SceneTraceResult
class SceneUtility
class SceneWorld A scene world that contains s. See Utility.CreateSceneWorld. You may also want a to manually render the scene world.
class Screen Access screen dimension etc.
class ScreenPanel Renders any attached PanelComponents to the screen. Acts as the root for all your UI components.
struct ScreenPanel.AutoScale
class SelectionSystem
class SerializedCollection
class SerializedObject An object (or data) that can be accessed as an object
class SerializedObject.PropertyChangedDelegate
class SerializedObject.PropertyFinishEditDelegate
class SerializedObject.PropertyPreChangeDelegate
class SerializedObject.PropertyStartEditDelegate
class SerializedProperty
struct SerializedProperty.AsAccessor
class SerializedProperty.Proxy Allows easily creating SerializedProperty classes that wrap other properties.
class Shader A shader is a specialized and complex computer program that use world geometry, materials and textures to render graphics.
struct ShaderProgramType
class Sharpen Applies a sharpen effect to the camera
struct SimpleVertex
class SingleActionAttribute Force a delegate-type property to only have a single attached Action Graph.
class SkinnedModelRenderer Renders a skinned model in the world. A skinned model is any model with bones/animations.
struct SkinnedModelRenderer.BoneVelocity
class SkinnedModelRenderer.MorphAccessor
class SkinnedModelRenderer.ParameterAccessor
class SkinnedModelRenderer.SequenceAccessor
class SkipHotloadAttribute 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.
class SkyBox2D Adds a 2D skybox to the world
class SliderJoint Restrict an object to one axis, relative to another object. Like a drawer opening.
class Sound Single source for creating sounds
class SoundBoxComponent Plays a sound within a box.
class SoundEvent A sound event. It can play a set of random sounds with optionally random settings such as volume and pitch.
struct SoundEvent.SoundSelectionMode
class SoundFile A sound resource.
struct SoundFormat
class SoundHandle A handle to a sound that is currently playing. You can use this to control the sound's position, volume, pitch etc.
class SoundHandle.LipSyncAccessor
class SoundHandleExtensions
class SoundPointComponent Plays a sound at a point in the world.
class Soundscape A soundscape is used for environmental ambiance of a map by playing a set of random sounds at given intervals.
class Soundscape.LoopedSound
class Soundscape.StingSound
class SoundscapeTrigger Plays a soundscape when the listener enters the trigger area.
struct SoundscapeTrigger.TriggerType
class SoundStream
class SpaceAttribute Add a space above this property
class SpawnPoint Dictates where players will spawn when they join the game when using a NetworkHelper.
struct Sphere Represents a sphere.
class SphereCollider Defines a sphere collider.
class Spline Collection of curves in 3D space. Shape and behavior of the curves are controled through points , 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.
struct Spline.HandleMode Describes how the spline should behave when entering/leaving a point.
struct Spline.Point Point that defines part of the spline. Two consecutive points define a segment of the spline. The , / 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
struct Spline.Sample Information about the spline at a specific distance.
class SpotLight Emits light in a specific direction in a cone shape.
class SpringJoint Try to keep an object a set distance away from another object. Like a spring connecting two objects.
class SpriteRenderer Renders a sprite in the world
class Standalone
class StandaloneManifest
struct StaticRpcMsg
struct SteamId Represents a SteamId, in the hope to avoid the "should it be a long or ulong" debate.
struct SteamId.AccountTypes
struct StereoTargetEye
struct StreamChannel
struct StreamChatMessage
struct StreamClip
class Streamer
struct StreamPoll
struct StreamPoll.Choice
struct StreamPrediction
struct StreamPrediction.Outcome
struct StreamService Streamer integration services
struct StreamUser
struct StreamUserFollow
class StringLiteralOnlyAttribute Ask codegen to shit itself if the parameter isn't passed in as a string literal
struct StringToken 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.
class StringToken.ConvertAttribute 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.
class SupportsILHotloadAttribute
class SuppressNullKeyWarningAttribute When applied to a member with or 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.
class Surface A physics surface. This is applied to each PhysicsShape and controls its physical properties and physics related sounds.
struct Surface.BreakablesInfo
struct Surface.ImpactEffectData
struct Surface.ScrapeEffectData
struct Surface.SoundData
class SyncAttribute Automatically synchronize a property of a networked object from the owner to other clients.
struct SyncFlags Describes the behaviour of network synchronization.
class TagSet
class TagSet.JsonConvert
class TargetTypeAttribute When applied to a Type property, allows you to specify a Type that the property's value must derive from.
struct TaskSource Provides a way for us to cancel tasks after common async shit is executed.
class Terrain Terrain renders heightmap based terrain.
struct Terrain.SyncFlags
class TerrainMaterial Description of a Terrain Material.
class TerrainStorage Stores heightmaps, control maps and materials.
class TerrainStorage.TerrainMaterialSettings
class TextAreaAttribute When applied to a string property, show a multi-line text box instead of a single line.
struct TextFlag 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.
class TextRenderer Renders text in the world
struct TextRenderer.TextAlign
class TextRendering
struct TextRendering.Outline
struct TextRendering.Scope Defines a scope of text, all using the same style.
struct TextRendering.Shadow
class Texture 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).
struct Texture2DBuilder
struct Texture3DBuilder
struct TextureArrayBuilder
struct TextureBuilder
struct TextureCubeBuilder
class TextureImagePathAttribute When added to a string property, will allow selection of anything that a Texture can be
class ThreadSafe MainThread related functions.
class Time
struct TimeSince A convenience struct to easily measure time since an event last happened, based on . Typical usage would see you assigning 0 to a variable of this type to reset the timer. Then the struct would return time since the last reset. i.e.: TimeSince lastUsed = 0; if ( lastUsed > 10 ) { /*Do something*/ }
struct TimeUntil A convenience struct to easily manage a time countdown, based on . Typical usage would see you assigning to a variable of this type a necessary amount of seconds. Then the struct would return the time countdown, or can be used as a bool i.e.: TimeUntil nextAttack = 10; if ( nextAttack ) { /*Do something*/ }
class TintAttribute
class Tonemapping Applies a tonemapping effect to the camera.
struct Tonemapping.ExposureColorSpaceEnum
struct Tonemapping.TonemappingMode Options to select a tonemapping algorithm to use for color grading.
class TrailRenderer Renders a trail behind the object, when it moves.
struct TrailTextureConfig Defines how a trail is going to be textured. Used by TrailRenderer.
class TransformProxy
class TransformProxyComponent 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.
struct Triangle
class TypeDescription Describes a type. We use this class to wrap and return System.Type's that are safe to interact with. Returned by .
struct Vertex
struct VertexAttribute
struct VertexAttributeFormat
struct VertexAttributeType
class VertexBuffer
class VertexLayout Allows for the definition of custom vertex layouts
class VertexLayout.BaseAttribute
class VertexLayout.BlendIndices
class VertexLayout.BlendWeight
class VertexLayout.Color
class VertexLayout.Normal
class VertexLayout.Position
class VertexLayout.Tangent
class VertexLayout.TexCoord
struct VideoDisplayMode
class VideoPlayer Enables video playback and access to the video texture and audio.
class VideoPlayer.AudioAccessor
class VideoPlayer.TextureChangedDelegate
class VideoWriter Allows the creation of video content by encoding a sequence of frames.
struct VideoWriter.Codec
struct VideoWriter.Config
struct VideoWriter.Container
class Vignette Applies a vignette to the camera
class Voice Records and transmits voice/microphone input to other players.
struct Voice.ActivateMode
class VolumetricFogController 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
class VolumetricFogParameters
class VolumetricFogVolume Adds a volumetric fog volume to the scene.
class VRWorldInput
struct VRWorldInput.HandSources Represents a controller to use
class WebSocket A WebSocket client for connecting to external services.
class WebSocket.DataReceivedHandler Event handler which processes binary messages from the WebSocket service.
class WebSocket.DisconnectedHandler Event handler which fires when the WebSocket disconnects from the server.
class WebSocket.MessageReceivedHandler Event handler which processes text messages from the WebSocket service.
class WebSurface Enables rendering and interacting with a webpage
class WebSurface.TextureChangedDelegate
class WideModeAttribute Expand the value editor to fill the next line in the inspector, leaving the title above it
struct WorkshopItemMetaData Some metadata we'll pack into a workshop submission when publishing.
class WorldInput A router for world input, the best place to put this is on your player's camera.
class WorldPanel Renders any attached PanelComponents to the world in 3D space.
struct WorldPanel.HAlignment
struct WorldPanel.VAlignment
struct WrappedMethod Provides data about a wrapped method in a callback.
struct WrappedMethod<T> Provides data about a wrapped method in a callback.
struct WrappedPropertyGet<T> Provides data about a wrapped property getter in a callback.
struct WrappedPropertySet<T> Provides data about a wrapped property setter in a callback.