| PlaceholderAttribute |
Add placeholder text, typically displayed for string properties when the text entry field is empty.
This info can then be retrieved via DisplayInfo library.
|
| ClassNameAttribute |
Set the class name for this type or member.
This info can then be retrieved via DisplayInfo library.
|
| TitleAttribute |
Sets the title or a "nice name" of a type or a type member.
This info can then be retrieved via DisplayInfo library.
|
| DescriptionAttribute |
Sets the description of a type or a type member. This attribute is usually applied automatically by codegen based on the XML comment of the type or member.
This info can then be retrieved via DisplayInfo library.
|
| CategoryAttribute |
Sets the category or the group of a type or a type member.
This info can then be retrieved via DisplayInfo library.
|
| GroupAttribute |
Sets the category or the group of a type or a type member.
This info can then be retrieved via DisplayInfo library.
|
| ToggleGroupAttribute |
Very much like a GroupAttribute, except we're indicating that the group can be toggle on and off using the named property
|
| IconAttribute |
Sets the icon of a type or a type member. Colors are expected in HTML formats, like "rgb(255,255,255)" or "#FFFFFF".
This info can then be retrieved via DisplayInfo library.
|
| OrderAttribute |
Visual order of this member for UI purposes.
This info can then be retrieved via DisplayInfo library.
|
| TimeRangeAttribute |
For use with Curves, allows you to define a custom range for the time
|
| ValueRangeAttribute |
For use with Curves, allows you to define a custom range for the value
|
| TagAttribute |
Adds a single or multiple tags for this type or member. Tags can then be retrieved via DisplayInfo library.
|
| AliasAttribute |
Alternate class name(s) for this type to the one specified via LibraryAttribute. This info can then be retrieved via DisplayInfo library.
|
| EditorAttribute |
Tell the tools or gameui property editor which editor we should be using for this property or type.
|
| SpawnableAttribute |
This entity is expected to be spawnable in-game, like from Sandbox's spawnmenu.
|
| HideInEditorAttribute |
Hide this in tools/editors.
|
| MinMaxAttribute |
Mark property as having a minimum and maximum value.
|
| EditorModelAttribute |
Declare a model to represent this entity in editor. This is a common attribute so it's leaked out of the Editor namespace.
|
| DefaultValueAttribute |
Sometimes with CodeGen we want reflection to be able to get the original initial value
of a property (which is set with {get;set;} = initialvalue;). For this reason sometimes
we'll drop this attribute on that property.
You might want to use this manually for instances where codegen can't define the default
value. This will usually happen for structs like vector and color.. if the default value isn't
defined as a number or string.
|
| SandboxSystemExtensions |
|
| Color |
Represents a color using 4 floats (rgba), with 0-1 range.
|
| Color32 |
A 32bit color, commonly used by things like vertex buffers.
The functionality on this is purposely left minimal so we're encouraged to use the regular Color struct.
|
| ColorHsv |
A color in Hue-Saturation-Value/Brightness format.
|
| Angles |
Euler angles. Unlike a <see cref="T:Rotation">Rotation</see>, Euler angles can represent multiple revolutions (rotations) around an axis,
but suffer from issues like gimbal lock and lack of a defined "up" vector. Use <see cref="T:Rotation">Rotation</see> for most cases.
|
| BBox |
An Axis Aligned Bounding Box.
|
| Capsule |
A capsule object, defined by 2 points and a radius. A capsule is a cylinder with round ends (inset half spheres on each end).
|
| Line |
Represents a line in 3D space.
|
| Matrix |
Represents a 4x4 matrix.
|
| RangedFloat |
A float between two values, which can be randomized or fixed.
|
| Ray |
A struct describing an origin and direction
|
| Rotation |
Represents a Quaternion rotation. Can be interpreted as a direction unit vector (x,y,z) + rotation around the direction vector (w) which represents the up direction.
Unlike Angles, this cannot store multiple revolutions around an axis.
|
| Transform |
A struct containing a position, rotation and scale. This is commonly used in engine to describe
entity position, bone position and scene object position.
|
| Vector2 |
A 2-dimensional vector. Typically represents a position or size in 2D space.
|
| Vector2Int |
|
| Vector3 |
A point in 3D space.
|
| Vector3Int |
|
| Vector4 |
A 4-dimensional vector/point.
|
| Sandbox.PureAttribute |
|
| Sandbox.ImpureAttribute |
|
| Sandbox.HasImplementationAttribute |
In ActionGraph, this type parameter can only be satisfied by a type <c>TArg</c>, such
that there exists at least one non-abstract type that extends / implements both
<c>TArg</c> and Sandbox.HasImplementationAttribute.BaseType.
|
| Sandbox.ExpressionNodeAttribute |
|
| Sandbox.ActionNodeAttribute |
|
| Sandbox.SingleActionAttribute |
Force a delegate-type property to only have a single attached Action Graph.
|
| Sandbox.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].
<br /><br />
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.
|
| Sandbox.WideModeAttribute |
Expand the value editor to fill the next line in the inspector, leaving the title above it
|
| Sandbox.ReadOnlyAttribute |
Display this in the inspector - but don't let anyone edit it
|
| Sandbox.TextAreaAttribute |
When applied to a string property, show a multi-line text box instead of a single line.
|
| Sandbox.InputActionAttribute |
When applied to a string property, use an input action selector.
|
| Sandbox.TargetTypeAttribute |
When applied to a Type property, allows you to specify a Type that the property's value must derive from.
|
| Sandbox.FontNameAttribute |
When applied to a string property, uses a font name selector.
|
| Sandbox.IconNameAttribute |
When applied to a string property, uses a Material Icon selector.
|
| Sandbox.ColorUsageAttribute |
When applied to a Color property, allows you to specify whether the color should have an alpha channel and/or be in HDR.
|
| Sandbox.FeatureAttribute |
Sets the category or the group of a type or a type member.
This info can then be retrieved via DisplayInfo library.
|
| Sandbox.TintAttribute |
|
| Sandbox.EditorTint |
|
| Sandbox.FeatureEnabledAttribute |
Mark a boolean property as a feature toggle
|
| Sandbox.HeaderAttribute |
Add a header above this property
|
| Sandbox.SpaceAttribute |
Add a space above this property
|
| Sandbox.HelpUrlAttribute |
Add a link to some documentation for this component, or <see langword="property" /> |
| Sandbox.EventAttribute |
A generic event listener. You are probably looking for Sandbox.Event.* attributes.
|
| Sandbox.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.
|
| Sandbox.SuppressNullKeyWarningAttribute |
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.
|
| Sandbox.SupportsILHotloadAttribute |
|
| Sandbox.MethodBodyChangeAttribute |
|
| Sandbox.PropertyAccessor |
|
| Sandbox.PropertyAccessorBodyChangeAttribute |
|
| Sandbox.InputAttribute |
Makes this method available as a Map Logic Input, for use in the Hammer Editor. This is only applicable to entities.
|
| Sandbox.ButtonAttribute |
When added to a method - the inspector will show a button for it.
|
| Sandbox.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.
|
| Sandbox.JsonUpgraderAttribute |
An attribute that describes a version update for a JSON object.
|
| Sandbox.LibraryAttribute |
|
| Sandbox.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.
|
| Sandbox.PropertyAttribute |
|
| Sandbox.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.
|
| Sandbox.InlineEditorAttribute |
Tell the editor to try to display inline editing for this property, rather than hiding it behind a popup etc.
|
| Sandbox.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
|
| Sandbox.SelectionBaseAttribute |
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.
|
| Sandbox.StringLiteralOnlyAttribute |
Ask codegen to shit itself if the parameter isn't passed in as a string literal
|
| Sandbox.HideAttribute |
Hide this in tools/editors.
|
| Sandbox.CodeGeneratorAttribute |
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 <i>that</i> attribute.
|
| Sandbox.CodeGeneratorFlags |
Used to specify what type of code generation to perform.
|
| Sandbox.WrappedMethod |
Provides data about a wrapped method in a Sandbox.CodeGeneratorAttribute callback.
|
| Sandbox.WrappedMethod<T> |
Provides data about a wrapped method in a Sandbox.CodeGeneratorAttribute callback.
|
| Sandbox.WrappedPropertySet<T> |
Provides data about a wrapped property setter in a Sandbox.CodeGeneratorAttribute callback.
|
| Sandbox.WrappedPropertyGet<T> |
Provides data about a wrapped property getter in a Sandbox.CodeGeneratorAttribute callback.
|
| Sandbox.CaseInsensitiveDictionary<T> |
|
| Sandbox.CaseInsensitiveConcurrentDictionary<T> |
|
| Sandbox.ConCmdAttribute |
|
| Sandbox.ConVarAttribute |
Console variable
|
| Sandbox.ConVarFlags |
|
| Sandbox.SandboxSystemExtensions |
|
| Sandbox.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.
|
| Sandbox.LogLevel |
|
| Sandbox.LogEvent |
|
| Sandbox.Curve |
Describes a curve, which can have multiple key frames.
|
| Sandbox.CurveRange |
Two curves
|
| Sandbox.Frustum |
Represents a frustum.
|
| Sandbox.Gradient |
Describes a gradient between multiple colors
|
| Sandbox.Plane |
Represents a plane.
|
| Sandbox.Rect |
Represents a rectangle.
|
| Sandbox.RectInt |
Represents a rectangle but with whole numbers
|
| Sandbox.Sphere |
Represents a sphere.
|
| Sandbox.Spline |
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.
<br /><br />
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.
|
| Sandbox.Triangle |
|
| Sandbox.CustomEditorAttribute |
|
| Sandbox.MultiSerializedObject |
An object (or data) that can be accessed as an object
|
| Sandbox.SerializedCollection |
|
| Sandbox.SerializedObject |
An object (or data) that can be accessed as an object
|
| Sandbox.SerializedProperty |
|
| Sandbox.InspectorVisibilityAttribute |
Hide a property if a condition matches.
|
| Sandbox.RealTime |
Access to time.
|
| Sandbox.RealTimeSince |
A convenience struct to easily measure time since an event last happened, based on Sandbox.RealTime.GlobalNow.<br /><br />
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.:
<code>
RealTimeSince lastUsed = 0;
if ( lastUsed > 10 ) { /*Do something*/ }
</code> |
| Sandbox.RealTimeUntil |
A convenience struct to easily manage a time countdown, based on Sandbox.RealTime.GlobalNow.<br /><br />
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.:
<code>
RealTimeUntil nextAttack = 10;
if ( nextAttack ) { /*Do something*/ }
</code> |
| Sandbox.ByteStream |
A result of SpeedTest.MemoryAlloc - to make it easy to use this instead of AllocHGlobal
|
| Sandbox.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();`
|
| Sandbox.SelectionSystem |
|
| Sandbox.SteamId |
Represents a SteamId, in the hope to avoid the "should it be a long or ulong" debate.
|
| Sandbox.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.
|
| Sandbox.ThreadSafe |
MainThread related functions.
|
| Sandbox.Localization.Languages |
A list of supported languages and metadata surrounding them
|
| Sandbox.Localization.LanguageInformation |
|
| Sandbox.Localization.Phrase |
A translated string. ie "Hello World".
It might also have variables, ie "Hello {PlayerName}".
Todo support for conditionals and plurals
|
| Sandbox.Localization.PhraseCollection |
Holds a bunch of localized phrases
|
| Sandbox.UI.Length |
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.
|
| Sandbox.UI.LengthUnit |
Possible units for various CSS properties that require length, used by Sandbox.UI.Length struct.
|
| Sandbox.UI.LengthUnitExtension |
|
| Sandbox.UI.Margin |
Represents a <see cref="T:Sandbox.Rect">Rect</see> where each side is the thickness of an edge/padding/margin/border, rather than positions.
|
| Sandbox.UI.CascadingParameterAttribute |
A panel's property will be inherited from its parent.
|
| Sandbox.UI.PseudoClass |
List of CSS pseudo-classes used by the styling system for hover, active, etc.
This acts as a bit-flag.
|
| Sandbox.UI.RenderState |
Describes panel's position and size for rendering operations.
|
| Sandbox.UI.StyleSheetAttribute |
Will automatically apply the named stylesheet to the Panel.
|
| Sandbox.UI.PanelTransform |
|
| Sandbox.UI.Shadow |
Shadow style settings
|
| Sandbox.UI.ShadowList |
A list of shadows
|
| Sandbox.UI.OverflowMode |
Possible values for the "overflow" CSS rule, dictating what to do with content that is outside of a panels bounds.
|
| Sandbox.UI.Align |
Possible values for <c>align-items</c> CSS property.
|
| Sandbox.UI.PositionMode |
Possible values for <c>position</c> CSS property.
|
| Sandbox.UI.FlexDirection |
Possible values for <c>flex-direction</c> CSS property.
|
| Sandbox.UI.Justify |
Possible values for <c>justify-content</c> CSS property.
|
| Sandbox.UI.DisplayMode |
Possible values for <c>display</c> CSS property.
|
| Sandbox.UI.PointerEvents |
Possible values for <c>pointer-events</c> CSS property.
|
| Sandbox.UI.Wrap |
Possible values for <c>flex-wrap</c> CSS property.
|
| Sandbox.UI.TextAlign |
Possible values for <c>text-align</c> CSS property.
|
| Sandbox.UI.TextOverflow |
Possible values for <c>text-overflow</c> CSS property.
|
| Sandbox.UI.WordBreak |
Possible values for <c>word-break</c> CSS property.
|
| Sandbox.UI.TextTransform |
Possible values for <c>text-transform</c> CSS property.
|
| Sandbox.UI.TextSkipInk |
Possible values for <c>text-decoration-skip-ink</c> CSS property.
|
| Sandbox.UI.TextDecorationStyle |
Possible values for <c>text-decoration-style</c> CSS property.
|
| Sandbox.UI.TextDecoration |
Possible values for <c>text-decoration</c> CSS property.
|
| Sandbox.UI.WhiteSpace |
Possible values for <c>white-space</c> CSS property.
|
| Sandbox.UI.FontStyle |
Possible values for <c>font-style</c> CSS property.
|
| Sandbox.UI.ImageRendering |
Possible values for <c>image-rendering</c> CSS property.
|
| Sandbox.UI.BorderImageFill |
State of <c>fill</c> setting of <c>border-image-slice</c> (<c>border-image</c>) CSS property.
|
| Sandbox.UI.BorderImageRepeat |
Possible values for <c>border-image-repeat</c> (<c>border-image</c>) CSS property.
|
| Sandbox.UI.BackgroundRepeat |
Possible values for <c>background-repeat</c> CSS property.
|
| Sandbox.UI.MaskMode |
Possible values for <c>mask-mode</c> CSS property.
|
| Sandbox.UI.MaskScope |
Possible values for <c>mask-scope</c> CSS property.
|
| Sandbox.UI.FontSmooth |
Possible values for <c>font-smooth</c> CSS property.
|
| Sandbox.UI.ObjectFit |
|
| Sandbox.Utility.CircularBuffer<T> |
Circular buffer, push pop and index access is always O(1).
|
| Sandbox.Utility.Noise |
Provides access to coherent noise utilities.
All of these functions should return between 0 and 1.
|
| Sandbox.Utility.Crc32 |
Generate 32-bit Cyclic Redundancy Check (CRC32) checksums.
|
| Sandbox.Utility.Crc64 |
Generate 64-bit Cyclic Redundancy Check (CRC64) checksums.
|
| Sandbox.Utility.DataProgress |
For providing a callback to describe the progress of doing something with some kind of block of data
|
| Sandbox.Utility.DisposeAction |
Creates an IDisposable that will simply run an action when disposed
|
| Sandbox.Utility.Easing |
Easing functions used for transitions. See https://easings.net/ for examples.
|
| Sandbox.Internal.ClassFileLocationAttribute |
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.
|
| Sandbox.Internal.SourceLocationAttribute |
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.
|
| Sandbox.Internal.GlobalSystemNamespace |
|
| Sandbox.Diagnostics.Assert |
|
| Sandbox.Diagnostics.Logger |
|
| Sandbox.Diagnostics.FastTimer |
Like stopwatch, but more lightweight and straight to the point. Use FastTimer.StartNew()
|
| ConditionalVisibilityAttribute |
Hide a property if a condition matches.
|
| HideIfAttribute |
Hide this property if a given property within the same class has the given value. Used typically in the Editor Inspector.
|
| ShowIfAttribute |
Show this property if a given property within the same class has the given value. Used typically in the Editor Inspector.
|
| SandboxSystemExtensions |
|
| Editor.MetaDataAttribute |
Base attribute which allows adding FGD metadata to classes.
|
| Editor.FieldMetaDataAttribute |
Base attribute which allows adding metadata to properties.
|
| Editor.HidePropertyAttribute |
A way to hide properties from parent classes in tools.
|
| Editor.EnableColorAlphaAttribute |
If used on a Color or Color32 property, enables alpha modification in editors.
|
| NativeEngine.VfxCompileTarget_t |
|
| Sandbox.CachingHandler |
|
| Sandbox.Application |
|
| Sandbox.Achievement |
|
| Sandbox.AchievementCollection |
Holds achievements for a package
|
| Sandbox.Cloud |
For accessing assets from the cloud - from code
|
| Sandbox.ManifestSchema |
An addon's manifest, describing what files are available
|
| Sandbox.Package |
Represents an asset on Asset Party.
|
| Sandbox.Sound |
Single source for creating sounds
|
| Sandbox.SoundHandle |
A handle to a sound that is currently playing. You can use this to control the sound's position, volume, pitch etc.
|
| Sandbox.SoundStream |
|
| Sandbox.CookieContainer |
|
| Sandbox.VideoDisplayMode |
|
| Sandbox.BlendMode |
Blend modes used by the UI system
|
| Sandbox.SceneLayerType |
|
| Sandbox.Clothing |
A piece of player model customization.
|
| Sandbox.ClothingContainer |
Holds a collection of clothing items. Won't let you add items that aren't compatible.
|
| Sandbox.WorkshopItemMetaData |
Some metadata we'll pack into a workshop submission when publishing.
|
| Sandbox.Friend |
|
| Sandbox.LaunchArguments |
These are arguments that were set when launching the current game.
This is used to pre-configure the game from the menu
|
| Sandbox.LoadingScreen |
Holds metadata and raw data relating to a Saved Game.
|
| Sandbox.Map |
|
| Sandbox.MapLoader |
|
| Sandbox.SceneMapLoader |
|
| Sandbox.PartyRoom |
A Party. A Party with your friends.
|
| Sandbox.Preferences |
Holds information about the current user's preferences.
|
| Sandbox.CurrencyValue |
Describes money, in a certain currency
|
| Sandbox.Gizmo |
|
| Sandbox.ModelArchetype |
Default model archetypes.
These types are defined in "tools/model_archetypes.txt".
|
| Sandbox.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.
|
| Sandbox.FGDTypeAttribute |
Overrides the auto generated FGD type.
|
| Sandbox.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"
|
| Sandbox.BitFlagsAttribute |
This choices type is bitflags, so we should be able to choose more than one option at a time.
|
| Sandbox.AssetPathAttribute |
When added to a string property, will becomes a selector for AssetTypeExtension
|
| Sandbox.ImageAssetPathAttribute |
When added to a string property, will become an image string selector
|
| Sandbox.FilePathAttribute |
When added to a string property, will become a file picker for the given extension (or all by default)
|
| Sandbox.TextureImagePathAttribute |
When added to a string property, will allow selection of anything that a Texture can be
|
| Sandbox.MapAssetPathAttribute |
When added to a string property, will become a map string selector
|
| Sandbox.Input |
Allows querying of player button presses and other inputs.
|
| Sandbox.InputAnalog |
An analog input, when fetched, is between -1 and 1 (0 being default)
|
| Sandbox.InputMotionData |
Represents the current state of a device's motion sensor(s).
|
| Sandbox.ControlModeSettings |
|
| Sandbox.GamepadCode |
Game controller codes, driven from SDL.
|
| Sandbox.HapticEffect |
Contains a haptic effect, which consists of patterns for the controller and triggers.
|
| Sandbox.HapticPattern |
Contains a haptic pattern, which consists of frequency and amplitude values that can change over time.
|
| Sandbox.HapticTarget |
Places you can trigger haptics on
|
| Sandbox.InputGlyphSize |
|
| Sandbox.SandboxGameExtensions |
|
| Sandbox.GlyphStyle |
|
| Sandbox.InputAction |
An input action defined by a game project.
|
| Sandbox.KeyboardModifiers |
|
| Sandbox.MouseButtons |
State of mouse buttons being pressed or not.
|
| Sandbox.ImageFormat |
Format used when creating textures.
|
| Sandbox.JointMotion |
|
| Sandbox.PhysicsBodyType |
|
| Sandbox.PhysicsMotionType |
Represents <see cref="T:Sandbox.PhysicsBody">Physics body's</see> motion type.
|
| Sandbox.Networking |
Global manager to hold and tick the singleton instance of NetworkSystem.
|
| Sandbox.Connection |
A connection, usually to a server or a client.
|
| Sandbox.NetFlags |
|
| Sandbox.PhysicsBody |
Represents a physics object. An entity can have multiple physics objects. See <see cref="P:Sandbox.PhysicsBody.PhysicsGroup">PhysicsGroup</see>.
A physics objects consists of one or more <see cref="T:Sandbox.PhysicsShape">PhysicsShape</see>s.
|
| Sandbox.PhysicsLock |
|
| Sandbox.PhysicsGroup |
Represents a set of <see cref="T:Sandbox.PhysicsBody">PhysicsBody</see> objects. Think ragdoll.
|
| Sandbox.PhysicsShape |
Represents a basic, convex shape. A <see cref="T:Sandbox.PhysicsBody">PhysicsBody</see> consists of one or more of these.
|
| Sandbox.PhysicsTraceBuilder |
|
| Sandbox.PhysicsTraceResult |
|
| Sandbox.PhysicsSimulationMode |
Physics simulation mode. For use with Sandbox.PhysicsWorld.SimulationMode.
|
| Sandbox.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.
|
| Sandbox.PhysicsContact |
|
| Sandbox.PhysicsIntersection |
|
| Sandbox.PhysicsIntersectionEnd |
|
| Sandbox.ConfigData |
Project configuration data is derived from this class
|
| Sandbox.CursorSettings |
|
| Sandbox.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.
|
| Sandbox.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.
|
| Sandbox.ProjectSettings |
|
| Sandbox.Project |
Represents an on-disk project.
|
| Sandbox.AnimationSequence |
|
| Sandbox.AnimGraphDirectPlayback |
For communicating with a Direct Playback Anim Node, which allows code to tell it to play a given sequence
|
| Sandbox.ComputeBufferType |
|
| Sandbox.ComputeBuffer<T> |
|
| Sandbox.ComputeShader |
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.
|
| Sandbox.GpuBuffer |
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<T> and RWStructuredBuffer<T> in HLSL.
|
| Sandbox.GpuBuffer<T> |
A typed GpuBuffer
|
| Sandbox.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.
|
| Sandbox.MorphCollection |
Used to access and manipulate morphs.
|
| Sandbox.MusicPlayer |
Enables music playback. Use this for music, not for playing game sounds.
|
| Sandbox.VideoPlayer |
Enables video playback and access to the video texture and audio.
|
| Sandbox.VideoWriter |
Allows the creation of video content by encoding a sequence of frames.
|
| Sandbox.RenderAttributes |
|
| Sandbox.RenderTarget |
Essentially wraps a couple of textures that we're going to render to. The color texture and the depth texture.
|
| Sandbox.TextRendering |
|
| Sandbox.VertexLayout |
Allows for the definition of custom vertex layouts
|
| Sandbox.VolumetricFogParameters |
|
| Sandbox.AnimParam<T> |
Anim param values contain any value for a limited set of types
|
| Sandbox.AnimationGraph |
|
| Sandbox.DecalDefinition |
A decal which can be applied to objects and surfaces.
|
| Sandbox.GameResource |
Assets defined in C# and created through tools.
You can define your own Custom Asset Types.
|
| Sandbox.GameResourceAttribute |
Should be applied to a class that inherits from Sandbox.GameResource.
Makes the class able to be stored as an asset on disk.
|
| Sandbox.Material |
A material. Uses several Sandbox.Textures and a Sandbox.Material.Shader with specific settings for more interesting visual effects.
|
| Sandbox.MeshPrimitiveType |
Possible primitive types of a Sandbox.Mesh.
|
| Sandbox.Mesh |
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.
<para>A set of meshes can be used to create a Sandbox.Model via the Sandbox.ModelBuilder class.</para> |
| Sandbox.VertexAttributeType |
|
| Sandbox.VertexAttributeFormat |
|
| Sandbox.VertexAttribute |
|
| Sandbox.BoneCollection |
A collection of bones. This could be from a model, or an entity
|
| Sandbox.Model |
A model.
|
| Sandbox.AnimationBuilder |
Provides ability to generate animations for a Sandbox.Model at runtime.
See Sandbox.ModelBuilder.AddAnimation(System.String,System.Single) |
| Sandbox.ModelBuilder |
Provides ability to generate Sandbox.Models at runtime.
A static instance of this class is available at Sandbox.Model.Builder |
| Sandbox.ModelAttachments |
|
| Sandbox.HitboxSet |
|
| Sandbox.ModelMorphs |
Allows fast lookups of morph variables
|
| Sandbox.PhysicsGroupDescription |
|
| Sandbox.ParticleSnapshot |
A particle snapshot that can be created procedurally.
Contains a set of vertices that particle effects can address.
|
| Sandbox.ParticleSystem |
A particle effect system that allows for complex visual effects, such as
explosions, muzzle flashes, impact effects, etc.
|
| Sandbox.Resource |
A resource loaded in the engine, such as a Sandbox.Model or Sandbox.Material.
|
| Sandbox.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.
|
| Sandbox.ResourceExtension<T,TSelf> |
An extension of ResourceExtension[t], this gives special helper methods for retrieving resources targetting
specific assets.
|
| Sandbox.ResourceLibrary |
Keeps a library of all available Sandbox.Resource.
|
| Sandbox.PrefabFile |
|
| Sandbox.PrefabVariable |
A prefab variable definition
|
| Sandbox.SceneFile |
|
| Sandbox.Shader |
A shader is a specialized and complex computer program that use
world geometry, materials and textures to render graphics.
|
| Sandbox.ShaderProgramType |
|
| Sandbox.SimpleVertex |
|
| Sandbox.Soundscape |
A soundscape is used for environmental ambiance of a map by playing a set of random sounds at given intervals.
|
| Sandbox.SoundEvent |
A sound event. It can play a set of random sounds with optionally random settings such as volume and pitch.
|
| Sandbox.SoundFormat |
|
| Sandbox.SoundFile |
A sound resource.
|
| Sandbox.Surface |
A physics surface. This is applied to each <see cref="T:Sandbox.PhysicsShape">PhysicsShape</see> and controls its physical properties and physics related sounds.
|
| Sandbox.AudioSurface |
Defines acoustic properties of a surface, which defines how sound will bounce
|
| Sandbox.TerrainMaterial |
Description of a Terrain Material.
|
| Sandbox.TerrainStorage |
Stores heightmaps, control maps and materials.
|
| Sandbox.Bitmap |
|
| Sandbox.MultisampleAmount |
|
| Sandbox.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).
|
| Sandbox.Texture2DBuilder |
|
| Sandbox.Texture3DBuilder |
|
| Sandbox.TextureArrayBuilder |
|
| Sandbox.TextureBuilder |
|
| Sandbox.TextureCubeBuilder |
|
| Sandbox.Vertex |
|
| Sandbox.VertexBuffer |
|
| Sandbox.CubemapFogController |
|
| Sandbox.SceneDynamicObject |
|
| Sandbox.GradientFogController |
|
| Sandbox.SceneCamera |
Represents a camera and holds render hooks. This camera can be used to draw tool windows and scene panels.
|
| Sandbox.ClearFlags |
Flags for clearing a RT before rendering a scene using a SceneCamera
|
| Sandbox.SceneCameraDebugMode |
|
| Sandbox.SceneCubemap |
|
| Sandbox.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)
|
| Sandbox.SceneCustomObject |
A scene object that allows custom rendering within a scene world.
|
| Sandbox.SceneDirectionalLight |
A directional scene light that is used to mimic sun light in a Sandbox.SceneWorld. Direction is controlled by this objects' Rotation.
|
| Sandbox.SceneFogVolume |
Represents a volume of fog in a scene, contributing to volumetric fog effects set on Sandbox.SceneCamera.VolumetricFog.
|
| Sandbox.SceneLight |
Generic point light scene object for use with a Sandbox.SceneWorld.
|
| Sandbox.SceneLineObject |
A scene object which is used to draw lines
|
| Sandbox.SceneLoadOptions |
|
| Sandbox.SceneMap |
Map geometry that can be rendered within a Sandbox.SceneWorld.
|
| Sandbox.SceneModel |
A model scene object that supports animations and can be rendered within a Sandbox.SceneWorld.
|
| Sandbox.SceneObject |
A model scene object that can be rendered within a Sandbox.SceneWorld.
|
| Sandbox.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.
|
| Sandbox.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.
|
| Sandbox.SceneSkyBox |
Renders a skybox within a Sandbox.SceneWorld.
|
| Sandbox.SceneSpotLight |
A simple spot light scene object for use in a Sandbox.SceneWorld.
|
| Sandbox.TrailTextureConfig |
Defines how a trail is going to be textured. Used by TrailRenderer.
|
| Sandbox.SceneWorld |
A scene world that contains Sandbox.SceneObjects. See Utility.CreateSceneWorld.
<para>You may also want a Sandbox.SceneCamera to manually render the scene world.</para> |
| Sandbox.StereoTargetEye |
|
| Sandbox.EditorContext |
|
| Sandbox.Standalone |
|
| Sandbox.StandaloneManifest |
|
| Sandbox.StreamChannel |
|
| Sandbox.StreamChatMessage |
|
| Sandbox.StreamClip |
|
| Sandbox.Streamer |
|
| Sandbox.StreamPoll |
|
| Sandbox.StreamPrediction |
|
| Sandbox.StreamService |
Streamer integration services
|
| Sandbox.StreamUser |
|
| Sandbox.StreamUserFollow |
|
| Sandbox.MainThread |
Utility functions that revolve around the main thread
|
| Sandbox.ITagSet |
|
| Sandbox.Json |
A convenience JSON helper that handles Sandbox.Resource types for you.
|
| Sandbox.FloatSpan |
Allows easy SIMD/AVX2 fast math on a span of floats
|
| Sandbox.Metadata |
A simple class for storing and retrieving metadata values.
|
| Sandbox.Screen |
Access screen dimension etc.
|
| Sandbox.TagSet |
|
| Sandbox.Time |
|
| Sandbox.TimeSince |
A convenience struct to easily measure time since an event last happened, based on Sandbox.Time.Now.<br /><br />
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.:
<code>
TimeSince lastUsed = 0;
if ( lastUsed > 10 ) { /*Do something*/ }
</code> |
| Sandbox.TimeUntil |
A convenience struct to easily manage a time countdown, based on Sandbox.Time.Now.<br /><br />
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.:
<code>
TimeUntil nextAttack = 10;
if ( nextAttack ) { /*Do something*/ }
</code> |
| Sandbox.WebSurface |
Enables rendering and interacting with a webpage
|
| Sandbox.Http |
Lets your game make async HTTP requests.
|
| Sandbox.Utility.FloatBitmap |
|
| Sandbox.Utility.Parallel |
Wrappers of the parallel class.
|
| Sandbox.Utility.Steam |
|
| Sandbox.Utility.Svg.PathFillType |
How to determine which sections of the path are filled.
|
| Sandbox.Utility.Svg.PathArcSize |
Controls arc size in Sandbox.Utility.Svg.ArcToPathCommand.
|
| Sandbox.Utility.Svg.PathDirection |
Controls arc direction in Sandbox.Utility.Svg.ArcToPathCommand.
|
| Sandbox.Utility.Svg.PathCommand |
Base class for SVG path commands.
|
| Sandbox.Utility.Svg.AddCirclePathCommand |
See <see href="https://developer.mozilla.org/en-US/docs/Web/SVG/Element/circle" />.
|
| Sandbox.Utility.Svg.AddOvalPathCommand |
See <see href="https://developer.mozilla.org/en-US/docs/Web/SVG/Element/ellipse" />.
|
| Sandbox.Utility.Svg.AddPolyPathCommand |
See <see href="https://developer.mozilla.org/en-US/docs/Web/SVG/Element/polyline" />, <see href="https://developer.mozilla.org/en-US/docs/Web/SVG/Element/polygon" />.
|
| Sandbox.Utility.Svg.AddRectPathCommand |
See <see href="https://developer.mozilla.org/en-US/docs/Web/SVG/Element/rect" />.
|
| Sandbox.Utility.Svg.AddRoundRectPathCommand |
See <see href="https://developer.mozilla.org/en-US/docs/Web/SVG/Element/rect" />.
|
| Sandbox.Utility.Svg.ArcToPathCommand |
See <see href="https://developer.mozilla.org/en-US/docs/Web/SVG/Tutorial/Paths#arcs" />.
|
| Sandbox.Utility.Svg.ClosePathCommand |
See <see href="https://developer.mozilla.org/en-US/docs/Web/SVG/Tutorial/Paths#line_commands" />.
|
| Sandbox.Utility.Svg.CubicToPathCommand |
See <see href="https://developer.mozilla.org/en-US/docs/Web/SVG/Tutorial/Paths#b%C3%A9zier_curves" />.
|
| Sandbox.Utility.Svg.LineToPathCommand |
See <see href="https://developer.mozilla.org/en-US/docs/Web/SVG/Tutorial/Paths#line_commands" />.
|
| Sandbox.Utility.Svg.MoveToPathCommand |
See <see href="https://developer.mozilla.org/en-US/docs/Web/SVG/Tutorial/Paths#line_commands" />.
|
| Sandbox.Utility.Svg.QuadToPathCommand |
See <see href="https://developer.mozilla.org/en-US/docs/Web/SVG/Tutorial/Paths#b%C3%A9zier_curves" />.
|
| Sandbox.Utility.Svg.SvgPath |
A shape in a Sandbox.Utility.Svg.SvgDocument, described as a vector path.
|
| Sandbox.Utility.Svg.SvgDocument |
Helper class for reading Scalable Vector Graphics files.
|
| Sandbox.UI.PanelInputType |
|
| Sandbox.UI.TransitionDesc |
Describes transition of a single CSS property, a.k.a. the values of a <c>transition</c> CSS property.
<para>Utility to create a transition by comparing the
panel style before and after the scope.</para> |
| Sandbox.UI.TransitionList |
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.
|
| Sandbox.UI.BaseStyles |
Auto generated container class for majority of CSS properties available.
|
| Sandbox.UI.Clipboard |
|
| Sandbox.UI.Emoji |
Helper class for working with Unicode emoji.
|
| Sandbox.Tasks.SyncTask |
|
| Sandbox.Resources.EmbeddedResource |
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.
|
| Sandbox.Resources.ResourceCompileContext |
|
| Sandbox.Resources.ResourceCompiler |
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.
|
| Sandbox.Resources.ResourceGenerator |
Creates a resource from a json definition
|
| Sandbox.Resources.ResourceGenerator<T> |
A resource generator targetting a specific type
|
| Sandbox.Resources.TextureGenerator |
|
| Sandbox.Resources.ColorTextureGenerator |
Generate a texture which is just a single color
|
| Sandbox.Resources.ImageFileGenerator |
Load images from disk and convert them to textures
|
| Sandbox.Resources.LinearGradient |
|
| Sandbox.Resources.RadialGradient |
|
| Sandbox.Resources.RandomTextureGenerator |
|
| Sandbox.Resources.SvgSourceGenerator |
|
| Sandbox.Resources.TextTextureGenerator |
|
| Sandbox.Physics.BallSocketJoint |
A ballsocket constraint.
|
| Sandbox.Physics.FixedJoint |
A generic "rope" type constraint.
|
| Sandbox.Physics.HingeJoint |
A hinge-like constraint.
|
| Sandbox.Physics.PulleyJoint |
A pulley constraint. Consists of 2 ropes which share same length, and the ratio changes via physics interactions.
Typical setup looks like this:
<code>
@-----------------@
| |
| |
Object A Object B
</code> |
| Sandbox.Physics.SliderJoint |
A slider constraint, basically allows movement only on the arbitrary axis between the 2 constrained objects on creation.
|
| Sandbox.Physics.SpringJoint |
A rope-like constraint that is has springy/bouncy.
|
| Sandbox.Physics.PhysicsJoint |
A physics constraint.
|
| Sandbox.Physics.PhysicsPoint |
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.
|
| Sandbox.Physics.PhysicsSpring |
Spring related settings for joints such as Sandbox.Physics.FixedJoint.
|
| Sandbox.Physics.CollisionRules |
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.
|
| Sandbox.Physics.PhysicsSettings |
|
| Sandbox.Network.HostStats |
|
| Sandbox.Network.NetworkFile |
|
| Sandbox.Network.MountedVPKsResponse |
|
| Sandbox.Network.InitialSnapshotResponse |
|
| Sandbox.Network.SnapshotMsg |
|
| Sandbox.Network.ReconnectMsg |
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.
|
| Sandbox.Network.ConnectionStats |
|
| Sandbox.Network.GameNetworkSystem |
An instance of this is created by the NetworkSystem when a server is joined, or created.
You should not try to create this manually.
|
| Sandbox.Network.LobbyInformation |
|
| Sandbox.Network.LobbyConfig |
|
| Sandbox.Network.LobbyPrivacy |
|
| Sandbox.Network.NetworkSocket |
|
| Sandbox.Rendering.CommandList |
|
| Sandbox.Rendering.RenderTargetHandle |
A render target handle used with CommandLists
|
| Sandbox.Rendering.ViewSetup |
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.
|
| Sandbox.Rendering.HudPainter |
|
| Sandbox.Rendering.ResourceState |
Used to describe a GPU resources state for barrier transitions.
|
| Sandbox.Rendering.Stage |
|
| Sandbox.Modals.FriendsListModalOptions |
|
| Sandbox.Modals.ServerListConfig |
|
| Sandbox.Modals.CreateGameOptions |
Passed to IModalSystem.CreateGame
|
| Sandbox.Modals.CreateGameResults |
|
| Sandbox.VR.AnalogInput |
Represents a VR analog input action (e.g. trigger)
|
| Sandbox.VR.AnalogInput2D |
Represents a two-dimensional VR analog input action (e.g. joysticks)
|
| Sandbox.VR.DigitalInput |
Represents a VR digital input action (e.g. X button)
|
| Sandbox.VR.VRInput |
|
| Sandbox.VR.MotionRange |
|
| Sandbox.VR.TrackedObject |
Represents a physically tracked VR object with a transform
|
| Sandbox.VR.VRController |
Represents a VR controller, along with its transform, velocity, and inputs.
|
| Sandbox.VR.VRHandJoint |
|
| Sandbox.VR.VRHandJointData |
|
| Sandbox.VR.FingerValue |
Accessors for Sandbox.VR.VRController.GetFingerValue(Sandbox.VR.FingerValue) |
| Sandbox.VR.TrackedDeviceRole |
|
| Sandbox.VR.TrackedDeviceType |
|
| Sandbox.VR.VROverlay |
<para>VR overlays draw over the top of the 3D scene, they will not be affected by lighting,
post processing effects or anything else in the world.<br />
This makes them ideal for HUDs or menus, or anything else that should be local to the
HMD or tracked devices.</para><para>If you need something in the world, consider using WorldPanel
and WorldInput instead.</para> |
| Sandbox.ModelEditor.GameDataAttribute |
Indicates that this class/struct should be available as GenericGameData node in ModelDoc
|
| Sandbox.ModelEditor.AxisAttribute |
Draws 3 line axis visualization, which can set up to be manipulated via gizmos. You can have multiple of these.
|
| Sandbox.ModelEditor.BoxAttribute |
Draws a box, which can be manipulated via gizmos. You can have multiple of these.
|
| Sandbox.ModelEditor.SphereAttribute |
Draws a sphere, which can be manipulated via gizmos. You can have multiple of these.
|
| Sandbox.ModelEditor.CapsuleAttribute |
Draws a capsule, which can be manipulated via gizmos. You can have multiple of these.
|
| Sandbox.ModelEditor.CylinderAttribute |
Draws a cylinder, which can be manipulated via gizmos. You can have multiple of these.
|
| Sandbox.ModelEditor.HingeJointAttribute |
A helper that draws axis of rotation and angle limit of a hinge joint.
|
| Sandbox.ModelEditor.EditorWidgetAttribute |
Adds a custom editor widget to the game data node.
Currently only 1 option is available - "HandPosePairEditor"
|
| Sandbox.ModelEditor.HandPoseAttribute |
A helper used for VR hand purposes.
|
| Sandbox.ModelEditor.LineAttribute |
|
| Sandbox.ModelEditor.ScaleBoneRelativeAttribute |
Scales the vector with the "ScaleAndMirror" node, relative to associated bone.
|
| Sandbox.ModelEditor.ScaleWorldAttribute |
Scales the vector with the "ScaleAndMirror" node.
|
| Sandbox.ModelEditor.Nodes.ModelBreakPiece |
Defines a single breakable prop gib.
|
| Sandbox.ModelEditor.Nodes.ModelPropData |
Generic prop settings. Support for this depends on the entity.
|
| Sandbox.ModelEditor.Nodes.ModelExplosionBehavior |
Defines the model as explosive. Support for this depends on the entity.
|
| Sandbox.ModelEditor.Nodes.ModelEye |
Defines an eye on a character model.
|
| Sandbox.ModelEditor.Nodes.ModelNavData |
Carries navigation related data.
|
| Sandbox.ModelEditor.Nodes.ModelEyeOcclusion |
|
| Sandbox.ModelEditor.Nodes.ModelBodygroupDrivenMorph |
|
| Sandbox.ModelEditor.Nodes.ModelMaterialGroupDrivenMorph |
|
| Sandbox.ModelEditor.Internal.BaseModelDocAttribute |
|
| Sandbox.ModelEditor.Internal.BaseTransformAttribute |
|
| Sandbox.Services.AchievementOverview |
Activity Feed
|
| Sandbox.Services.Achievements |
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.
|
| Sandbox.Services.Auth |
|
| Sandbox.Services.BenchmarkSystem |
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.
|
| Sandbox.Services.Feed |
Activity Feed
|
| Sandbox.Services.Inventory |
Allows access to the Steam Inventory system
|
| Sandbox.Services.Leaderboards |
|
| Sandbox.Services.Messaging |
|
| Sandbox.Services.News |
News Posts
|
| Sandbox.Services.Notification |
Player notification
|
| Sandbox.Services.Review |
Package Reviews
|
| Sandbox.Services.ServerList |
|
| Sandbox.Services.Stats |
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.
|
| Sandbox.Services.Players.Overview |
An overview of a player. Only available if their profile isn't set to private.
|
| Sandbox.Services.Players.Profile |
Player profile
|
| Sandbox.Navigation.NavMesh |
Navigation Mesh - allowing AI to navigate a world
|
| Sandbox.Mounting.Directory |
|
| Sandbox.Mounting.MountInfo |
Information about a single mount
|
| Sandbox.DataModel.GameSetting |
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.
|
| Sandbox.DataModel.ProjectConfig |
Configuration of a Sandbox.Project.
|
| Sandbox.Menu.LoadingProgress |
|
| Sandbox.Diagnostics.Allocations |
Tools for diagnosing heap allocations
|
| Sandbox.Diagnostics.FrameStats |
Stats returned from the engine each frame describing what was rendered, and how much of it.
|
| Sandbox.Diagnostics.Performance |
|
| Sandbox.Diagnostics.PerformanceStats |
|
| Sandbox.Engine.GameLoadingFlags |
|
| Sandbox.Engine.BindCollection |
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.
|
| Sandbox.Engine.Protocol |
A centralized place to access the protocols
|
| Sandbox.Engine.SystemInfo |
|
| Sandbox.Engine.Utility.RayTrace.MeshTraceRequest |
|
| Sandbox.Engine.Shaders.ShaderCompile |
|
| Sandbox.Engine.Shaders.ShaderCompileOptions |
Options used when compiling a shader
|
| Sandbox.Engine.Settings.RenderSettings |
|
| Sandbox.Speech.SpeechRecognitionResult |
A result from speech recognition.
|
| Sandbox.Speech.Recognition |
|
| Sandbox.Speech.Synthesizer |
A speech synthesis stream. Lets you write text into speech and output it to a Sandbox.SoundHandle.
|
| Sandbox.Audio.AudioDistanceFloatAttribute |
|
| Sandbox.Audio.AudioMeter |
Allows the capture and monitor of an audio source
|
| Sandbox.Audio.MixBuffer |
Contains 512 samples of audio data, this is used when mixing a single channel
|
| Sandbox.Audio.MultiChannelBuffer |
Holds up to 8 mix buffers, which usually represent output speakers.
|
| Sandbox.Audio.DspPresetHandle |
A handle to a DspPreset
|
| Sandbox.Audio.DspProcessor |
|
| Sandbox.Audio.Mixer |
Takes a bunch of sound, changes its volumes, mixes it together, outputs it
|
| Sandbox.Audio.MixerSettings |
|
| Sandbox.Audio.MixerHandle |
A handle to a Mixer
|
| Sandbox.Audio.AudioProcessor |
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.
|
| Sandbox.Audio.AudioChannel |
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.
|
| Sandbox.Audio.PerChannel<T> |
Stores a variable per channel
|
| Sandbox.Audio.DelayProcessor |
|
| Sandbox.Audio.HighPassProcessor |
Just a test - don't count on this sticking around
|
| Sandbox.Audio.LowPassProcessor |
Just a test - don't count on this sticking around
|
| Sandbox.Audio.PitchProcessor |
|
| Sandbox.ActionGraphs.MapSourceLocation |
Source location for action graphs that belong to a Hammer map. This is used for stack
traces, and for knowing which map to save when editing a graph.
|
| Sandbox.ActionGraphs.GameResourceSourceLocation |
Source location for action graphs that belong to a Sandbox.GameResource.
These can include scenes and prefabs, or custom resources. This is used for stack
traces, and for knowing which asset to save when editing a graph.
|
| TemporaryEffect |
Destroys a GameObject after a number of seconds. If the GameObject or its children have any
components that implement ITemporaryEffect we will wait for those to be finished before destroying.
This is particularly useful if you want to delete a GameObject but want to wait for sounds or particles
to conclude.
|
| Microsoft.AspNetCore.Components.RenderFragment |
Represents a segment of UI content, implemented as a delegate that
writes the content to a Microsoft.AspNetCore.Components.Rendering.RenderTreeBuilder.
|
| Microsoft.AspNetCore.Components.RenderFragment<TValue> |
Represents a segment of UI content for an object of type <typeparamref name="TValue" />, implemented as
a function that returns a Microsoft.AspNetCore.Components.RenderFragment.
|
| Microsoft.AspNetCore.Components.ParameterAttribute |
Signifies a parameter attribute
|
| Microsoft.AspNetCore.Components.ComponentBase |
A base component
|
| Microsoft.AspNetCore.Components.EventHandlerAttribute |
|
| Microsoft.AspNetCore.Components.EventCallback |
|
| Microsoft.AspNetCore.Components.EventCallback<TValue> |
|
| Microsoft.AspNetCore.Components.EventCallbackFactory |
|
| Microsoft.AspNetCore.Components.EventHandlers |
|
| Microsoft.AspNetCore.Components.EditorRequiredAttribute |
Specifies that the component parameter is required to be provided by the user when authoring it in the editor.
<para>
If a value for this parameter is not provided, editors or build tools may provide warnings indicating the user to
specify a value. This attribute is only valid on properties marked with Microsoft.AspNetCore.Components.ParameterAttribute.
</para> |
| Microsoft.AspNetCore.Components.RouteAttribute |
|
| Microsoft.AspNetCore.Components.CompilerServices.RuntimeHelpers |
|
| Microsoft.AspNetCore.Components.Rendering.RenderHandle |
|
| Microsoft.AspNetCore.Components.Rendering.RenderTreeBuilder |
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.
|
| HalfEdgeMesh.VertexHandle |
|
| HalfEdgeMesh.FaceHandle |
|
| HalfEdgeMesh.HalfEdgeHandle |
|
| Sandbox.ConsoleSystem |
A library to interact with the Console System.
|
| Sandbox.SandboxGameExtensions |
|
| Sandbox.SoundHandleExtensions |
|
| Sandbox.FileSystem |
A filesystem that can be accessed by the game.
|
| Sandbox.Game |
|
| Sandbox.ColorGradient |
A color gradient for use as entity and asset properties
TODO: Gradient property editor
|
| Sandbox.FGDCurve |
A helper class to handle 'curve' FGD type.
TOOD: Get rid of in favor of new curve stuff.
|
| Sandbox.EditorHandleAttribute |
When applied to a component, the editor will draw a selectable handle sprite for the gameobject in scene
|
| Sandbox.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.
|
| Sandbox.BaseSoundComponent |
|
| Sandbox.DspVolume |
|
| Sandbox.LipSync |
Drive morphs with lipsync from sounds.
|
| Sandbox.SoundBoxComponent |
Plays a sound within a box.
|
| Sandbox.SoundPointComponent |
Plays a sound at a point in the world.
|
| Sandbox.SoundscapeTrigger |
Plays a soundscape when the listener enters the trigger area.
|
| Sandbox.Voice |
Records and transmits voice/microphone input to other players.
|
| Sandbox.CameraComponent |
Every scene should have at least one Camera.
|
| Sandbox.CubemapFog |
Applies a cubemap fog effect to the camera
|
| Sandbox.Tonemapping |
Applies a tonemapping effect to the camera.
|
| Sandbox.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.
|
| Sandbox.CharacterControllerHelper |
|
| Sandbox.BoxCollider |
Defines a box collider.
|
| Sandbox.CapsuleCollider |
Defines a capsule collider.
|
| Sandbox.Collider |
|
| Sandbox.HullCollider |
Defines a box, cone, or cylinder hull collider.
|
| Sandbox.ModelCollider |
Defines a collider based on a model.
|
| Sandbox.ModelPhysics |
Physics for a model. This is primarily used for ragdolls and other physics driven models, otherwise you should be using a Rigidbody.
|
| Sandbox.PlaneCollider |
Defines a plane collider.
|
| Sandbox.Rigidbody |
Adds physics properties to an object. Requires a collider to be attached to the same object.
|
| Sandbox.RigidbodyFlags |
|
| Sandbox.SphereCollider |
Defines a sphere collider.
|
| Sandbox.Component |
A GameObject can have many components, which are the building blocks of the game.
|
| Sandbox.MakeDirtyAttribute |
|
| Sandbox.ComponentFlags |
|
| Sandbox.LegacyParticleSystem |
Support's Source Engine's vpcf particles
|
| Sandbox.Dresser |
Allows easily dressing a citizen or human in clothing
|
| Sandbox.Gib |
A gib is a prop that is treated slightly different. It will fade out after a certain amount of time.
|
| Sandbox.Hitbox |
|
| Sandbox.ManualHitbox |
A hitbox that can be placed manually on a GameObject, instead of coming from a model
|
| Sandbox.ModelHitboxes |
Hitboxes from a model
|
| Sandbox.PlayerController |
|
| Sandbox.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.
|
| Sandbox.SpawnPoint |
Dictates where players will spawn when they join the game when using a NetworkHelper.
|
| Sandbox.BallJoint |
Fix two objects together but can rotate - like a shoulder.
|
| Sandbox.FixedJoint |
Weld two physics objects together
|
| Sandbox.HingeJoint |
Create a hinged connection between two physics objects. Like a door hinge or a wheel.
|
| Sandbox.Joint |
|
| Sandbox.SliderJoint |
Restrict an object to one axis, relative to another object. Like a drawer opening.
|
| Sandbox.SpringJoint |
Try to keep an object a set distance away from another object. Like a spring connecting two objects.
|
| Sandbox.AmbientLight |
Adds an ambient light to the scene, applied globally.
|
| Sandbox.DirectionalLight |
A directional light that casts shadows, like the sun.
|
| Sandbox.EnvmapProbe |
A cubemap probe that captures the environment around it.
|
| Sandbox.Light |
|
| Sandbox.PointLight |
Emits light in all directions from a point in space.
|
| Sandbox.SpotLight |
Emits light in a specific direction in a cone shape.
|
| Sandbox.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.
|
| Sandbox.MapCollider |
|
| Sandbox.MapInstance |
Allows you to load a map into the Scene. This can be either a vpk or a scene map.
|
| Sandbox.MapObjectComponent |
|
| Sandbox.MapSkybox3D |
|
| Sandbox.Collision |
|
| Sandbox.CollisionStop |
|
| Sandbox.CollisionSource |
|
| Sandbox.MeshComponent |
An editable polygon mesh with collision
|
| Sandbox.PolygonMesh |
An editable mesh made up of polygons, triangulated into a model
|
| Sandbox.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.
|
| Sandbox.NavMeshAgent |
An agent that can navigate the navmesh defined in the scene.
|
| Sandbox.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.
|
| Sandbox.NavMeshLink |
NavigationLinks connect navigation mesh polygons for pathfinding and enable shortcuts like ladders, jumps, or teleports.
|
| Sandbox.ParticleAttractor |
Attract particles to a GameObject in the scene
|
| Sandbox.ParticleController |
Particles can have extra controllers that can modify the particles every frame.
|
| Sandbox.ParticleBoxEmitter |
Emits particles within a box shape.
|
| Sandbox.ParticleConeEmitter |
Emits particles within/along a cone shape.
|
| Sandbox.ParticleEmitter |
Creates particles. Should be attached to a Sandbox.ParticleEffect.
|
| Sandbox.ParticleModelEmitter |
Emits particles in a model
|
| Sandbox.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.
|
| Sandbox.ParticleSphereEmitter |
Emits particles within a sphere shape.
|
| Sandbox.Particle |
|
| Sandbox.ParticleControlPoint |
|
| Sandbox.ParticleEffect |
Defines and holds particles. This is the core of the particle system.
|
| Sandbox.ParticleFloat |
|
| Sandbox.ParticleVector3 |
|
| Sandbox.ParticleGradient |
|
| Sandbox.ParticleLightRenderer |
Adds lighting to particles in your effect.
|
| Sandbox.ParticleModelRenderer |
Renders particles as models, using the particle's position, rotation, and size.
|
| Sandbox.ParticleRenderer |
Renders a set of particles. Should be attached to a Sandbox.ParticleRenderer.ParticleEffect.
|
| Sandbox.ParticleSpriteRenderer |
Renders particles as 2D sprites
|
| Sandbox.ParticleTextRenderer |
Renders particles as 2D sprites
|
| Sandbox.ParticleTrailRenderer |
Renders a trail for each particle in the effect.
|
| Sandbox.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.
|
| Sandbox.Bloom |
Applies a bloom effect to the camera
|
| Sandbox.Blur |
Applies a blur effect to the camera.
|
| Sandbox.ChromaticAberration |
Applies a chromatic aberration effect to the camera
|
| Sandbox.ColorAdjustments |
Applies color adjustments to the camera.
|
| Sandbox.ColorGrading |
Applies color grading to the camera
|
| Sandbox.DepthOfField |
Applies a depth of field effect to the camera
|
| Sandbox.FilmGrain |
Applies a film grain effect to the camera
|
| Sandbox.Highlight |
This should be added to a camera that you want to outline stuff
|
| Sandbox.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.
|
| Sandbox.MotionBlur |
Applies a motion blur effect to the camera
|
| Sandbox.Pixelate |
Applies a pixelate effect to the camera
|
| Sandbox.PostProcess |
Adds an effect to the camera
|
| Sandbox.ScreenSpaceReflections |
|
| Sandbox.Sharpen |
Applies a sharpen effect to the camera
|
| Sandbox.Vignette |
Applies a vignette to the camera
|
| Sandbox.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.
|
| Sandbox.DecalRenderer |
Component that creates a projected decal relative to its GameObject.
|
| Sandbox.GradientFog |
Adds a gradient fog to the world
|
| Sandbox.LineRenderer |
Renders a line between a list of points
|
| Sandbox.ModelRenderer |
Renders a model in the world
|
| Sandbox.Renderer |
|
| Sandbox.RenderOptions |
|
| Sandbox.SkinnedModelRenderer |
Renders a skinned model in the world. A skinned model is any model with bones/animations.
|
| Sandbox.SkyBox2D |
Adds a 2D skybox to the world
|
| Sandbox.SpriteRenderer |
Renders a sprite in the world
|
| Sandbox.TextRenderer |
Renders text in the world
|
| Sandbox.TrailRenderer |
Renders a trail behind the object, when it moves.
|
| Sandbox.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
|
| Sandbox.VolumetricFogVolume |
Adds a volumetric fog volume to the scene.
|
| Sandbox.Terrain |
Terrain renders heightmap based terrain.
|
| Sandbox.PanelComponent |
|
| Sandbox.ScreenPanel |
Renders any attached PanelComponents to the screen. Acts as the root for all your UI components.
|
| Sandbox.WorldInput |
A router for world input, the best place to put this is on your player's camera.
|
| Sandbox.WorldPanel |
Renders any attached PanelComponents to the world in 3D space.
|
| Sandbox.SceneInformation |
|
| Sandbox.VRWorldInput |
|
| Sandbox.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.
|
| Sandbox.DebugOverlaySystem |
|
| Sandbox.SceneAnimationSystem |
|
| Sandbox.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.
|
| Sandbox.GameObjectSystem<T> |
A syntax sugar wrapper around GameObjectSystem, which allows you to access your system using
SystemName.Current instead of Scene.GetSystem.
|
| Sandbox.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.
|
| Sandbox.ComponentList |
|
| Sandbox.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.
|
| Sandbox.CloneConfig |
The low level input of a GameObject.Clone
|
| Sandbox.GameObjectFlags |
|
| Sandbox.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.
|
| Sandbox.GameTransform |
|
| Sandbox.TransformProxy |
|
| Sandbox.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.
|
| Sandbox.NetDictionary<TKey,TValue> |
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.
<br /><para><b>Example usage:</b><code>
public class MyComponent : Component
{
[Sync] public NetDictionary<string,bool> MyBoolTable { get; set; } = new();
<br />
public void SetBoolState( string key, bool state )
{
if ( IsProxy ) return;
MyBoolTable[key] = state;
}
}
</code></para> |
| Sandbox.NetList<T> |
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.
<br /><para><b>Example usage:</b><code>
public class MyComponent : Component
{
[Sync] public NetList<int> MyIntegerList { get; set; } = new();
<br />
public void AddNumber( int number )
{
if ( IsProxy ) return;
MyIntegerList.Add( number );
}
}
</code></para> |
| Sandbox.HostSyncAttribute |
Automatically synchronize a property of a networked object from the host to other clients.
Obsolete: 11/12/2024
|
| Sandbox.NetworkMode |
Specifies how a Sandbox.GameObject should be networked.
|
| Sandbox.NetworkOrphaned |
Specifies what happens when the owner of a networked object disconnects.
|
| Sandbox.OwnerTransfer |
Specifies who can control ownership of a networked object.
|
| Sandbox.RpcAttribute |
Marks a method as being an RPC. This means that it can be called over the network.
|
| Sandbox.Rpc |
|
| Sandbox.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 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.
|
| Sandbox.AuthorityAttribute |
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.
<br /><br />
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.
|
| Sandbox.NetPermission |
Specifies who can invoke an action over the network.
|
| Sandbox.SceneNetworkSystem |
This is created and referenced by the network system, as a way to route.
|
| Sandbox.SyncAttribute |
Automatically synchronize a property of a networked object from the owner to other clients.
|
| Sandbox.SyncFlags |
Describes the behaviour of network synchronization.
|
| Sandbox.SceneUtility |
|
| Sandbox.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.
|
| Sandbox.PrefabScene |
|
| Sandbox.Scene |
|
| Sandbox.GameObjectUndoFlags |
|
| Sandbox.SceneTrace |
|
| Sandbox.SceneTraceResult |
|
| Sandbox.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.
|
| Sandbox.Language |
Allows access to translated phrases, allowing the translation of gamemodes etc
|
| Sandbox.Mouse |
Gives access to mouse position etc
|
| Sandbox.MouseVisibility |
The visibility state of the mouse cursor.
|
| Sandbox.GameTask |
A generic Sandbox.TaskSource.
|
| Sandbox.TaskSource |
Provides a way for us to cancel tasks after common async shit is executed.
|
| Sandbox.WebSocket |
A WebSocket client for connecting to external services.
|
| Sandbox.Utility.EditorTools |
Functions to interact with the tools system. Does nothing if tools aren't enabled.
|
| Sandbox.Razor.RenderTreeBuilderOld |
|
| Sandbox.UI.KeyFrames |
Represents a CSS <c>@keyframes</c> rule.
|
| Sandbox.UI.BasePopup |
A panel that gets deleted automatically when clicked away from
|
| Sandbox.UI.Image |
A generic box that displays a given texture within itself.
|
| Sandbox.UI.Label |
A generic text label. Can be made editable.
|
| Sandbox.UI.ScenePanel |
Allows to render a scene world onto a panel.
|
| Sandbox.UI.SvgPanel |
A generic panel that draws an SVG scaled to size
|
| Sandbox.UI.WebPanel |
A panel that displays an interactive web page.
|
| Sandbox.UI.LayoutCascade |
|
| Sandbox.UI.ButtonEvent |
Keyboard (and mouse) key press Sandbox.UI.PanelEvent.
|
| Sandbox.UI.InputFocus |
Handles input focus for Sandbox.UI.Panels.
|
| Sandbox.UI.WorldInput |
WorldInput can be used to simulate standard mouse inputs on WorldPanels.
|
| Sandbox.UI.PanelStyle |
|
| Sandbox.UI.CopyEvent |
|
| Sandbox.UI.CutEvent |
|
| Sandbox.UI.PasteEvent |
|
| Sandbox.UI.EscapeEvent |
|
| Sandbox.UI.DragEvent |
|
| Sandbox.UI.MousePanelEvent |
Mouse related Sandbox.UI.PanelEvent.
|
| Sandbox.UI.PanelEvent |
Base Sandbox.UI.Panel event.<br />
See Sandbox.UI.Panel.CreateEvent(Sandbox.UI.PanelEvent).
|
| Sandbox.UI.PanelEventAttribute |
Add an event listener to a Sandbox.UI.Panel event with the given name.<br />
See Sandbox.UI.Panel.CreateEvent(System.String,System.Object,System.Nullable{System.Single}).
|
| Sandbox.UI.SelectionEvent |
|
| Sandbox.UI.Panel |
A simple User Interface panel. Can be styled with CSS.
|
| Sandbox.UI.Box |
Represents position and size of a Sandbox.UI.Panel on the screen.
|
| Sandbox.UI.RootPanel |
A root panel. Serves as a container for other panels, handles things such as rendering.
|
| Sandbox.UI.StyleBlock |
A CSS rule - ie ".chin { width: 100%; height: 100%; }"
|
| Sandbox.UI.Styles |
Represents all supported CSS properties and their currently assigned values.
|
| Sandbox.UI.StyleSelector |
A CSS selector like "Panel.button.red:hover .text"
|
| Sandbox.UI.StyleSheet |
|
| Sandbox.UI.StyleSheetCollection |
A collection of Sandbox.UI.StyleSheet objects applied directly to a panel.
See Sandbox.UI.Panel.StyleSheet.
|
| Sandbox.UI.Transitions |
Handles the storage, progression and application of CSS transitions for a single Sandbox.UI.Panel.
|
| Sandbox.UI.WorldPanel |
An interactive 2D panel rendered in the 3D world.
|
| Sandbox.UI.Construct.ImageConstructor |
|
| Sandbox.UI.Construct.LabelConstructor |
|
| Sandbox.UI.Construct.SceneConstructor |
|
| Sandbox.UI.Construct.PanelCreator |
Used for Sandbox.UI.Panel.Add for quick panel creation with certain settings. Other panels types are added via extension methods.
|
| Sandbox.VR.VRAnchor |
Updates the the VR anchor based on a GameObject's transform.
|
| Sandbox.VR.VRHand |
Updates the parameters on an Sandbox.SkinnedModelRenderer on this GameObject based on the skeletal data from SteamVR.
Useful for quick hand posing based on controller input.
|
| Sandbox.VR.VRModelRenderer |
Renders a device-specific model for a VR device
|
| Sandbox.VR.VRTrackedObject |
Updates this GameObject's transform based on a given tracked object (e.g. left controller, HMD).
|
| Sandbox.VR.VROverlayPanel |
<para>A Sandbox.VR.VROverlay that draws and handles input of a Sandbox.UI.RootPanel.</para><para>VR overlays draw over the top of the 3D scene, they will not be affected by lighting,
post processing effects or anything else in the world.<br />
This makes them ideal for HUDs or menus, or anything else that should be local to the
HMD or tracked devices.</para><para>If you need something in the world, consider using WorldPanel
and Sandbox.UI.WorldInput instead.</para> |
| Sandbox.Volumes.SceneVolume |
A generic way to represent volumes in a scene. If we all end up using this instead of defining our own version
in everything, we can improve this and improve everything at the same time.
|
| Sandbox.Volumes.VolumeComponent |
|
| Sandbox.Volumes.VolumeSystem |
A base GameObjectSystem for handling of IVolume components. You can use this to find volume components
by position.
|
| Sandbox.Movement.MoveModeLadder |
The character is climbing up a ladder
|
| Sandbox.Movement.MoveMode |
A move mode for this character
|
| Sandbox.Movement.MoveModeSwim |
The character is swimming
|
| Sandbox.Movement.MoveModeWalk |
The character is walking
|
| Sandbox.Internal.GlobalGameNamespace |
|
| Sandbox.ActionGraphs.ActionGraphResource |
|
| Sandbox.ActionGraphs.ActionsInvoker |
A component which allows you to use action in all the usual functions.
|
| Sandbox.ActionGraphs.SimpleActionComponent |
These should not exist
|
| Sandbox.ActionGraphs.AwakeActionComponent |
|
| Sandbox.ActionGraphs.StartActionComponent |
|
| Sandbox.ActionGraphs.EnabledActionComponent |
|
| Sandbox.ActionGraphs.DisabledActionComponent |
|
| Sandbox.ActionGraphs.UpdateActionComponent |
|
| Sandbox.ActionGraphs.FixedUpdateActionComponent |
|
| Sandbox.ActionGraphs.DestroyActionComponent |
|
| Sandbox.ActionGraphs.CollisionActionComponent |
Reacts to collisions.
|
| Sandbox.ActionGraphs.TriggerActionComponent |
Reacts to collider triggers.
|
| Sandbox.ActionGraphs.ActionGraphDebugger |
|
| Sandbox.ActionGraphs.LinkDebugger |
|
| Sandbox.Bind.BindSystem |
Data bind system, bind properties to each other.
|
| Sandbox.Bind.Builder |
A helper to create binds between two properties (or whatever you want)
<para>
Example usage: set "BoolValue" from value of "StringValue"
<code>BindSystem.Build.Set( this, "BoolValue" ).From( this, "StringValue" );</code></para> |
| Sandbox.Bind.Link |
Joins two proxies together, so one can be updated from the other (or both from each other)
|
| Sandbox.Bind.Proxy |
Gets and Sets a value from somewhere.
|
| Sandbox.DisplayInfo |
Collects all the relevant info (such as description, name, icon, etc) from attributes and other sources about a type or type member.
|
| Sandbox.EnumDescription |
|
| Sandbox.FieldDescription |
Describes a field. We use this class to wrap and return <see cref="P:Sandbox.FieldDescription.FieldInfo">FieldInfo</see>'s that are safe to interact with.
Returned by Sandbox.Internal.TypeLibrary and Sandbox.TypeDescription.
|
| Sandbox.MemberDescription |
Wraps <see cref="F:Sandbox.MemberDescription.MemberInfo">MemberInfo</see> but with caching and sandboxing.
Returned by Sandbox.Internal.TypeLibrary and Sandbox.TypeDescription.
|
| Sandbox.MethodDescription |
Describes a method. We use this class to wrap and return <see cref="T:System.Reflection.MethodInfo">MethodInfo</see>'s that are safe to interact with.
Returned by Sandbox.Internal.TypeLibrary and Sandbox.TypeDescription.
|
| Sandbox.PropertyDescription |
Describes a property. We use this class to wrap and return <see cref="P:Sandbox.PropertyDescription.PropertyInfo">PropertyInfo</see>'s that are safe to interact with.
Returned by Sandbox.Internal.TypeLibrary and Sandbox.TypeDescription.
|
| Sandbox.TypeDescription |
Describes a type. We use this class to wrap and return <see cref="T:System.Type">System.Type</see>'s that are safe to interact with.
Returned by Sandbox.Internal.TypeLibrary.
|
| Sandbox.ActionGraphs.ActionGraphExtensions |
|
| Sandbox.Internal.TypeLibrary |
|
| Sandbox.SandboxToolExtensions |
|
| Sandbox.Global |
Utility info for tools usage.
|
| Sandbox.SceneExtensions |
|
| Sandbox.SceneReferenceHelper |
Editor helpers for scene.ref nodes.
|
| Sandbox.WorkshopUtils |
Utils for uploading assets to Steam. This is wholely for clothing right now.
|
| Sandbox.Helpers.UndoSystem |
A system that aims to wrap the main reusable functionality of an undo system
|
| Sandbox.Internal.GlobalToolsNamespace |
|
| Editor.Asset |
|
| Editor.EditorForAssetTypeAttribute |
Used in conjunction with IAssetEditor to declare a window that can edit an asset type
|
| Editor.AssetSystem |
The asset system, provides access to all the assets.
|
| Editor.AssetTagSystem |
Handles asset tags.
|
| Editor.AssetType |
|
| Editor.MetaData |
A class to CRUD json files. This should probably be a generic class since it seems
like we might want to do this with stuff other than meta files. But there's no need for
that right now, so lets leave it simple.
|
| Editor.TextureResourceCompiler |
|
| Editor.CodeEditor |
For opening source code files in whatever code editor the user has selected.
|
| Editor.ConsoleSystem |
|
| Editor.AnglesControlWidget |
|
| Editor.BBoxControlWidget |
|
| Editor.BoolControlWidget |
|
| Editor.ControlWidget |
A control widget is used to edit the value of a single SerializedProperty.
|
| Editor.EnumControlWidget |
|
| Editor.FloatControlWidget |
|
| Editor.FloatSlider |
|
| Editor.IntegerControlWidget |
|
| Editor.MarginControlWidget |
|
| Editor.RectControlWidget |
|
| Editor.RotationControlWidget |
|
| Editor.SphereControlWidget |
|
| Editor.StringControlWidget |
|
| Editor.TextAreaControlWidget |
|
| Editor.TransformControlWidget |
|
| Editor.VectorControlWidget |
|
| Editor.VectorIntControlWidget |
|
| Editor.TextureResidencyInfo |
Provides information about currently resident textures on the GPU
|
| Editor.EditorPreferences |
|
| Editor.EditorShortcuts |
|
| Editor.DockAttribute |
|
| Editor.EditorAppAttribute |
|
| Editor.EditorMainWindow |
|
| Editor.EngineOverlay |
|
| Editor.EngineView |
|
| Editor.GameScenePicker |
Opens an invisible popup above the game screen which allows you to left click once on the scene.
This is great for things like selecting something from the game scene.
|
| Editor.HeadBarEvent |
|
| Editor.LibrarySystem |
|
| Editor.LibraryProject |
|
| Editor.MenuAttribute |
|
| Editor.Progress |
|
| Editor.ShortcutAttribute |
|
| Editor.ShortcutType |
|
| Editor.StackLineHandlerAttribute |
Marks a method as a custom handler for stack trace lines matching a certain pattern.
The method must take in a System.Text.RegularExpressions.Match parameter, and return
a Editor.StackRow (or null).
|
| Editor.StackRow |
|
| Editor.EditorEvent |
|
| Editor.FileSystem |
A filesystem that can be accessed by the game.
|
| Editor.GameData |
Lets all native and managed tools know about any engine / game entities.
|
| Editor.InputOutputType |
|
| Editor.InputOutputBase |
Represents a variable
|
| Editor.Input |
|
| Editor.Output |
|
| Editor.MapClass |
Represents an entity class used by the map editor
|
| Editor.MapClassVariable |
Represents a variable.
|
| Editor.InputSystem |
|
| Editor.AssetPreviewAttribute |
|
| Editor.CanEditAttribute |
|
| Editor.ComponentEditorWidget |
A control widget is used to edit the value of a single SerializedProperty.
|
| Editor.InspectorAttribute |
|
| Editor.InspectorWidget |
|
| Editor.QStringList |
|
| Editor.QTextBlock |
|
| Editor.TextCursor |
|
| Editor.TraceResult |
|
| Editor.Trace |
Trace for tools, not to be confused with Sandbox.SceneTrace |
| Editor.ProjectList |
|
| Editor.Application |
|
| Editor.AutoComplete |
|
| Editor.BaseScrollWidget |
|
| Editor.Button |
A simple button widget.
|
| Editor.CheckState |
Check state of a Editor.Checkbox.
|
| Editor.Checkbox |
A generic checkbox widget.
|
| Editor.ComboBox |
|
| Editor.DockManager |
|
| Editor.DockWindow |
A window that is built from docking windows
|
| Editor.DragData |
Contains drag and drop data for tool widgets. See Editor.Widget.DragEvent.
|
| Editor.DragAssetData |
Represents an asset being dragged into an editor window. Assets will either
be sourced from a package (see Editor.DragAssetData.PackageIdent) or a local path (see Editor.DragAssetData.AssetPath).
Instances of this type are accessed through Editor.DragData.Assets.
|
| Editor.DropAction |
Used to tell the user what kind of action will happen during a drag and drop event on mouse release.
In Windows, these actions will also display text near cursor to let the user know what will happen if they release their mouse button.
|
| Editor.Drag |
|
| Editor.CursorShape |
TODO: Make this match whatever we do in game
|
| Editor.DockArea |
|
| Editor.KeyCode |
|
| Editor.Orientation |
|
| Editor.ShortcutContext |
Scope of the shortcut. Requires focus at this level for the shortcut to be active.
Defaults to Editor.ShortcutContext.WindowShortcut.
|
| Editor.SizeConstraint |
|
| Editor.SizeMode |
|
| Editor.ToolbarPosition |
|
| Editor.WindowFlags |
|
| Editor.MouseEvent |
Information about a Editor.Widgets mouse event.
|
| Editor.KeyEvent |
Information about a Editor.Widgets keyboard event.
|
| Editor.ContextMenuEvent |
Information about a Editor.Widgets context menu event.
|
| Editor.GraphicsMouseEvent |
Information about a Editor.GraphicsItems mouse click event.
|
| Editor.GraphicsHoverEvent |
Information about a Editor.GraphicsItems mouse hover event.
|
| Editor.WheelEvent |
Information about a mouse wheel scroll event of a Editor.Widget.
|
| Editor.FileDialog |
|
| Editor.Frame |
Like a widget - but is drawn
|
| Editor.ScrollbarMode |
|
| Editor.GraphicsView |
|
| Editor.GraphicsItem |
|
| Editor.GraphicsLine |
|
| Editor.PenStyle |
|
| Editor.RenderMode |
|
| Editor.Paint |
|
| Editor.Pixmap |
A pixel map, or just a simple image.
|
| Editor.GraphicsWidget |
|
| Editor.Label |
A simple text label.
|
| Editor.Layout |
|
| Editor.BoxLayout |
A widget layout. You can think of it as an invisible box of rows or columns, each one containing a widget, useful for automatic positioning and scaling.
|
| Editor.GridLayout |
A widget layout. You can think of it as an invisible box of rows or columns, each one containing a widget, useful for automatic positioning and scaling.
|
| Editor.LineEdit |
A single line text entry. See Editor.TextEdit for multi line version.
|
| Editor.LinkableSplitter |
Splitter that can be linked to move alongside others
|
| Editor.Menu |
|
| Editor.ContextMenu |
Identical to Menu except DeleteOnClose defaults to true
|
| Editor.MenuBar |
|
| Editor.NativeRenderingWidget |
Sets up the widget to render
|
| Editor.Option |
|
| Editor.PopupDialogWidget |
|
| Editor.QObject |
|
| Editor.SceneRenderingWidget |
Render a scene to a native widget. This replaces NativeRenderingWidget.
|
| Editor.ScrollArea |
A widget that can scroll its Editor.ScrollArea.Canvas.
|
| Editor.ScrollBar |
|
| Editor.Splitter |
Split frame, allows dragging to resize panels
|
| Editor.StatusBar |
|
| Editor.TabBar |
|
| Editor.TextEdit |
A multi-line text entry. See Editor.LineEdit for a single line version.
|
| Editor.ToolButtonStyle |
|
| Editor.ToolBar |
|
| Editor.TrayIcon |
Like a widget - but is drawn
|
| Editor.Widget |
A generic widget.
|
| Editor.WidgetSignal |
|
| Editor.FocusMode |
|
| Editor.SuspendUpdates |
Suspends updates in the widget for this using scope.
|
| Editor.FocusChangeReason |
Describes why a Editor.Widgets' keyboard focus has changed via Editor.Widget.OnFocus(Editor.FocusChangeReason) and Editor.Widget.OnBlur(Editor.FocusChangeReason) callbacks.
|
| Editor.Window |
|
| Editor.EditorScene |
|
| Editor.SceneEditor |
|
| Editor.SceneEditorSession |
Holds a current open scene and its edit state
|
| Editor.Theme |
|
| Editor.ToolRender |
Renders basic stuff for tool views
|
| Editor.EditorUtility |
|
| Editor.Animate |
|
| Editor.CloudAsset |
|
| Editor.ColorSampler |
|
| Editor.ExportConfig |
|
| Editor.HistoryList<T> |
A helper class to store a list of strings, which can then be navigated around, saved, restored
|
| Editor.ProjectPublisher |
|
| Editor.StandaloneExporter |
|
| Editor.BuildStepExtensions |
|
| Editor.BaseItemWidget |
|
| Editor.BaseWindow |
|
| Editor.Dialog |
A wrapper to more easily create dialog windows.
|
| Editor.FolderEdit |
An editable text box with a button to browse for an arbitrary folder using OS file browser dialog.
|
| Editor.IconButton |
|
| Editor.ListView |
|
| Editor.PopupWidget |
A popup widget that automatically deletes itself once it stops being visible
|
| Editor.SegmentedControl |
|
| Editor.Separator |
|
| Editor.VirtualWidget |
|
| Editor.Graphic.SimpleText |
|
| Editor.ModelEditor.ModelDoc |
|
| Editor.MeshEditor.PrimitiveBuilder |
Build primitives out of polygons.
|
| Editor.MapDoc.MapDocument |
Represents an open map document. A document has a tree of Editor.MapDoc.MapNode that represent the world.
|
| Editor.MapDoc.MapEntity |
MapEntity in Hammer is a type of Editor.MapDoc.MapNode that has a set of key/value pairs.
The keyvalues represent the authoritative state of the entity.
Entities may have helpers that enhance the presentation and sometimes modification of those keyvalues.
The helpers may come and go; it should always be possible to recreate the helpers from
the parent entity's keyvalues.
Entities may also have zero or more Editor.MapDoc.MapMesh children.
|
| Editor.MapDoc.MapGameObject |
|
| Editor.MapDoc.MapGroup |
A map node which has the sole purpose of grouping other map nodes together.
|
| Editor.MapDoc.MapInstance |
A map node which allows a target group and its children to be placed with a new position
and orientation in the world without creating a new copy.
Multiple MapInstance classes may reference the same target allowing it to be placed in
multiple locations, but allowing any edits to be applied to all instances.
|
| Editor.MapDoc.MapMesh |
MapMesh is the Hammer map node which represents editable mesh geometry in a Hammer map.
This is the map node that is created when using the hammer geometry editing tools.
|
| Editor.MapDoc.MapNode |
A common class used for all objects in the world object tree.
|
| Editor.MapDoc.MapPath |
Path containing a bunch of Editor.MapDoc.MapPathNode |
| Editor.MapDoc.MapPathNode |
Nodes along a Editor.MapDoc.MapPath |
| Editor.MapDoc.MapStaticOverlay |
An overlay which is rendered using a mesh generated by projecting faces onto
surrounding geometry. Baked during map compile so that there is no runtime component.
Also supports being limited to specific targets.
|
| Editor.MapDoc.MapWorld |
MapWorld is the root node of a Editor.MapDoc.MapDocument, however it can have multiple sub Editor.MapDoc.MapWorld of prefabs.
|
| Editor.MapEditor.CanDropAttribute |
|
| Editor.MapEditor.Hammer |
|
| Editor.MapEditor.HammerMainWindow |
This is our CQHammerMainWnd
|
| Editor.MapEditor.HammerManagedInspector |
|
| Editor.MapEditor.HammerSceneEditorSession |
|
| Editor.MapEditor.HammerSourceLocation |
Source location for graphs created in a Hammer editor session.
|
| Editor.MapEditor.HammerSession |
This is our CQHammerMainWnd
|
| Editor.MapEditor.History |
Undo/redo history for the current active mapdoc
|
| Editor.MapEditor.Selection |
Current selection set for the active map
|
| Editor.MapEditor.SelectMode |
|
| Editor.MapEditor.MapView |
MapViews are owned by the MapViewMgr. They display the MapViewMgr's mapdoc.
The MapView provides either a 2d or 3d view of the provided map doc. The rendering mode
may be swapped between various 2d and 3d modes dynamically. In addition to basic display
functionality the view also provides movement implementation for moving a camera within a 3d view
or panning a 2d view.
|
| Sandbox.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.
|
| Sandbox.FileWatch |
Watch folders, dispatch events on changed files
|
| Sandbox.CodeArchive |
|
| Sandbox.CompileGroup |
|
| Sandbox.Compiler |
Given a folder of .cs files, this will produce (and load) an assembly
|
| Sandbox.CompilerOutput |
|
| Sandbox.NetworkHelper |
Creates a networked game lobby and assigns player prefabs to connected clients.
|
| Sandbox.SandboxBaseExtensions |
Extensions for Model
|
| Sandbox.UI.Button |
A simple button Sandbox.UI.Panel.
|
| Sandbox.UI.ButtonGroup |
A group of side-by-side buttons one of which can be selected.
|
| Sandbox.UI.Checkbox |
A simple checkbox Sandbox.UI.Panel.
|
| Sandbox.UI.NavHostPanel |
A panel that acts like a website. A single page is always visible
but it will cache other views that you visit, and allow forward/backward navigation.
|
| Sandbox.UI.NavigationExtensions |
|
| Sandbox.UI.NavLinkPanel |
A panel that will navigate to an href but also have .active class if href is active
|
| Sandbox.UI.BaseControl |
|
| Sandbox.UI.DropDown |
A UI control which provides multiple options via a dropdown box.
|
| Sandbox.UI.Field |
A field in a form, usually contains a label and a control
|
| Sandbox.UI.FieldControl |
A field in a form, usually contains a label and a control
|
| Sandbox.UI.Form |
|
| Sandbox.UI.IconPanel |
A panel containing an icon, typically a material icon.
|
| Sandbox.UI.Option |
An option for a Sandbox.UI.DropDown or Sandbox.UI.ButtonGroup.
|
| Sandbox.UI.Popup |
|
| Sandbox.UI.PopupButton |
A button that opens a Sandbox.UI.PopupButton.Popup panel.
Useless on its own - you need to implement Open
|
| Sandbox.UI.SplitContainer |
A control that has two panes with a splitter in between. You can drag the splitter to change the size of the two panels.
|
| Sandbox.UI.TabContainer |
A container with tabs, allowing you to switch between different sheets.
You can position the tabs by adding the class tabs-bottom, tabs-left, tabs-right (default is tabs top)
|
| Sandbox.UI.TextEntry |
A Sandbox.UI.Panel that the user can enter text into.
|
| Sandbox.UI.LoaderFullScreen |
|
| Sandbox.UI.PackageCard |
|
| Sandbox.UI.PackageFilterFacet |
|
| Sandbox.UI.PackageFilterOrder |
|
| Sandbox.UI.PackageFilters |
|
| Sandbox.UI.PackageList |
|
| Sandbox.UI.SliderControl |
|
| Sandbox.UI.SwitchControl |
|
| Sandbox.UI.MenuPanel |
|
| Sandbox.UI.Tests.GridLayout |
|
| Sandbox.UI.Tests.VirtualScrollPanel |
Scroll panel that creates its contents as they become visible
TODO: we need to let panels know, or recreate them, when Data changes
|
| Sandbox.UI.Tests.BaseVirtualScrollPanel<T> |
|
| Sandbox.UI.Construct.ButtonConstructor |
|
| Sandbox.UI.Construct.IconPanelConstructor |
|
| Sandbox.UI.Construct.TextEntryConstructor |
|
| Sandbox.Citizen.CitizenAnimationHelper |
Used to control the Citizen animation state. You don't have to use this to animate your citizen avatar, but our
aim is to put everything you need in this class, so you can easily see what variables are available.
|
| ComponentListWidget |
|
| NavMeshLinkTool |
|
| Editor.CodeEditorControlWidget |
|
| Editor.CreateAsset |
|
| Editor.CurveControlWidget |
|
| Editor.CurveRangeControlWidget |
|
| Editor.CurveEditor |
A widget which contains an editable curve
|
| Editor.CurveEditorPopup |
|
| Editor.CurveExtensions |
|
| Editor.CurvePresets |
A widget which holds a list of user curve presets, saved in a cookie
|
| Editor.Allocations |
|
| Editor.PerformanceDock |
|
| Editor.AssetBrowser |
A list of assets with filtering options.
|
| Editor.AssetLocations |
|
| Editor.ChipsWidget |
|
| Editor.Chip |
|
| Editor.FolderMetadataDialog |
|
| Editor.HistoryStack<T> |
|
| Editor.DiskLocation |
|
| Editor.EverythingLocation |
|
| Editor.MountLocation |
|
| Editor.PackageLocation |
|
| Editor.RecentsLocation |
|
| Editor.MainAssetBrowser |
|
| Editor.PathWidget |
|
| Editor.SearchWidget |
|
| Editor.AssetContextMenu |
Information about selected asset(s) when opening a context menu in Editor.AssetList.
|
| Editor.FolderContextMenu |
Information about selected directory/folder when opening a context menu in Editor.AssetList or in Editor.AssetLocations.
|
| Editor.AssetList |
Displays a list of assets, set by Editor.BaseItemWidget.SetItems(System.Collections.Generic.IEnumerable{System.Object}). They should be either Editor.Asset or System.IO.DirectoryInfo.
|
| Editor.AssetListViewMode |
|
| Editor.AssetEntry |
|
| Editor.DirectoryEntry |
|
| Editor.PackageEntry |
|
| Editor.AssetPicker |
|
| Editor.AssetPickerAttribute |
|
| Editor.BaseResourceEditor<T> |
Implement this with your target type to create a special inspector for the resource type
|
| Editor.BatchMarkPublishedWidget |
|
| Editor.BatchPublisher |
|
| Editor.ClothingIconControlWidget |
|
| Editor.ClothingScene |
|
| Editor.CloudBrowser |
A list of cloud assets.
|
| Editor.FacetDropdown |
|
| Editor.CloudLocations |
|
| Editor.MainCloudBrowser |
|
| Editor.ControlSheet |
|
| Editor.ControlSheetFormatter |
|
| Editor.FeatureTabWidget |
The tab widget that sits at the top of the ControlSheet if you add [Features]
|
| Editor.FeatureTabOption |
|
| Editor.DebuggingMenus |
|
| Editor.ExpandGroup |
|
| Editor.FeatureBox |
|
| Editor.Group |
|
| Editor.EditorSubToolBarWidget |
|
| Editor.EditorToolBarWidget |
|
| Editor.HeaderBarStyle |
|
| Editor.NavMeshToolbarWidget |
|
| Editor.ToolbarGroup |
|
| Editor.Inspector |
|
| Editor.InspectorToolbar |
|
| Editor.PropertyRow |
|
| Editor.PropertyRowError |
|
| Editor.SettingsMenus |
|
| Editor.UndoDock |
|
| Editor.VRStats |
|
| Editor.PathExtensions |
|
| Editor.SceneEditorExtensions |
|
| Editor.DropShadow |
|
| Editor.NoticeManager |
Manages those annoying notices on the side of your screen. You get them when you're compiling.
This is what's making those errors keep appearing. It's not your bad code, it's this bad class,
blame this class - it's this classes fault you're getting annoyed.
|
| Editor.NoticeWidget |
|
| Editor.MorphCollectionControlWidget |
|
| Editor.ParametersControlWidget |
|
| Editor.ComponentTemplate |
|
| Editor.RazorComponentTemplate |
|
| Editor.SimpleComponentTemplate |
|
| Editor.ComponentControlWidget |
|
| Editor.ComponentViewMode |
|
| Editor.ComponentSheet |
The component sheet that is used to edit a component's properties in the GameObjectInspector
|
| Editor.ComponentSheetHeader |
|
| Editor.GameObjectControlWidget |
|
| Editor.InspectorHeader |
|
| Editor.MissingComponentSheet |
|
| Editor.TagSetControlWidget |
|
| Editor.EyeDropperTool |
|
| Editor.ObjectEditorTool |
Move, rotate and scale objects
|
| Editor.PhysicsEditorTool |
Simulate rigid bodies in editor
|
| Editor.PositionEditorTool |
Move selected Gameobjects.<br /><br /><b>Ctrl</b> - toggle snap to grid<br /><b>Shift</b> - duplicate selection
|
| Editor.RotationEditorTool |
Rotate selected GameObjects.<br /><br /><b>Ctrl</b> - toggle snap to grid
|
| Editor.ScaleEditorTool |
Scale selected GameObjects.<br /><br /><b>Ctrl</b> - toggle snap to grid<br /><b>Shift</b> - scale all 3 axis
|
| Editor.SceneEditorMenus |
|
| Editor.SceneTreeWidget |
|
| Editor.BaseDropObject |
|
| Editor.DropObjectAttribute |
|
| Editor.SceneDock |
The scene dock is the actual tab that is shown in the editor. Its main
job is to host the SceneViewWidget and to switch the active session when
the dock is hovered or focused. It also destroys the session when the dock
is closed.
|
| Editor.SceneOverlayWidget |
|
| Editor.SceneViewportWidget |
|
| Editor.SceneViewWidget |
|
| Editor.ViewportOptions |
|
| Editor.EditorTool<T> |
|
| Editor.BoxColliderTool |
|
| Editor.CameraEditorTool |
|
| Editor.CapsuleColliderTool |
|
| Editor.EnvmapProbeTool |
|
| Editor.HullColliderTool |
|
| Editor.ParticleEditorTool |
|
| Editor.EditorTool |
|
| Editor.EditorToolManager |
|
| Editor.EditorToolAttribute |
|
| Editor.WidgetWindow |
A widget that acts like a window. It can be dragged around its parent.
|
| Editor.ClipboardTools |
|
| Editor.LocalizationTools |
|
| Editor.WidgetGalleryAttribute |
When used on a static method, this method will be called to create an example of this panel for the "Widget Gallery" window.
This method should create and return a Editor.Widget that serves as an example usage of the Widget class the method is defined in.
You can use [Title], [Icon], etc on this method as well.
|
| Editor.WidgetGalleryWindow |
|
| Editor.ToolButton |
A button that shows as an icon and tries to keep itself square.
|
| Editor.ColorControlWidget |
|
| Editor.ColorSwatchWidget |
|
| Editor.ColorStringWidget |
|
| Editor.ColorVectorWidget |
|
| Editor.ColorPalette |
Used to store and manipulate a collection of colors.
|
| Editor.ColorPicker |
A color picker widget that makes it easy to select or edit colors
|
| Editor.AudioDistanceFloatControlWidget |
|
| Editor.BodyGroupsControlWidget |
|
| Editor.ButtonControlWidget |
|
| Editor.ControlObjectWidget |
A control widget that converts its property into a SerializedObject, so it can edit subproperties
|
| Editor.DictionaryControlWidget |
|
| Editor.DropdownControlWidget<T> |
Abstract class to enable easily creating ControlWidgets with dropdowns.
|
| Editor.DspPresetHandleControlWidget |
Dropdown selection for DspPresetHandle
|
| Editor.FilePathStringControlWidget |
File paths stored as strings
|
| Editor.FolderControlWidget |
|
| Editor.GamePackageControlWidget |
|
| Editor.GenericControlWidget |
This is a callback control widget, which is used to edit classes.
It shows key properties, and an edit button. On clicking the edit button
it'll show a propery sheet popup.
|
| Editor.ListControlWidget |
|
| Editor.MaterialGroupControlWidget |
|
| Editor.OrganizationControlWidget |
|
| Editor.ParticleFloatControlWidget |
|
| Editor.ParticleGradientControlWidget |
|
| Editor.ParticleVector3ControlWidget |
|
| Editor.PhysicsLockControlWidget |
|
| Editor.PopupEditor |
This is created using EditorUtility.OpenControlSheet
|
| Editor.RangedFloatControlWidget |
|
| Editor.ResourceControlWidget |
|
| Editor.ResourceStringControlWidget |
Resources stored as strings
|
| Editor.TextureImageControlWidget |
Resources stored as strings
|
| Editor.DateTimeControlWidget |
|
| Editor.DateTimeOffsetControlWidget |
|
| Editor.DateTimeEditorWidget |
|
| Editor.GradientControlWidget |
|
| Editor.GradientEditorWidget |
|
| Editor.GradientExtensions |
|
| Editor.GradientPresets |
A widget which holds a list of user gradient presets, saved in a cookie
|
| Editor.KeyBindControlWidget |
|
| Editor.KeyBind |
|
| Editor.NavigationView |
|
| Editor.PackageSelector |
|
| Editor.PopupWindow |
A simple popup window to quickly display a message, optionally with custom actions.
|
| Editor.SoundPlayer |
|
| Editor.TabWidget |
|
| Editor.TagsControlWidget |
|
| Editor.TagEdit |
A text entry that automatically breaks the input into tags
|
| Editor.TagPicker |
Offers a popup menu with a number of "tags" when you can then select
|
| Editor.TextureControlWidget |
|
| Editor.IconButtonWithDropper |
|
| Editor.TextureWidget |
Draw a texture as a widget. This will handle converting to a pixmap to the best of its ability.
|
| Editor.ToggleSwitch |
|
| Editor.TreeNode |
|
| Editor.TreeNode<T> |
A small wrapper that changes Value into the T type.
|
| Editor.TreeView |
|
| Editor.WarningBox |
|
| Editor.InformationBox |
|
| Editor.Widgets.GizmoSceneTest |
|
| Editor.Widgets.VideoGallery |
|
| Editor.Widgets.VideoWidget |
A widget that uses a pixmap to display a video.
|
| Editor.Widgets.WebWidget |
A widget that shows a web page.
|
| Editor.Widgets.Packages.PackagePopup |
|
| Editor.ShaderGraph.BaseNode |
|
| Editor.ShaderGraph.BasePlug |
|
| Editor.ShaderGraph.BasePlugIn |
|
| Editor.ShaderGraph.BasePlugOut |
|
| Editor.ShaderGraph.PlugInfo |
|
| Editor.ShaderGraph.TextureNodeType |
|
| Editor.ShaderGraph.ClassNodeType |
|
| Editor.ShaderGraph.SubgraphNodeType |
|
| Editor.ShaderGraph.GraphCompiler |
|
| Editor.ShaderGraph.NodeResultType |
|
| Editor.ShaderGraph.NodeResult |
|
| Editor.ShaderGraph.ShaderTemplate |
|
| Editor.ShaderGraph.DefaultEditor |
|
| Editor.ShaderGraph.FunctionResult |
Final result
|
| Editor.ShaderGraph.FunctionOutput |
|
| Editor.ShaderGraph.MissingNode |
|
| Editor.ShaderGraph.NodeInput |
|
| Editor.ShaderGraph.UIType |
|
| Editor.ShaderGraph.ParameterUI |
|
| Editor.ShaderGraph.ParameterNode<T> |
|
| Editor.ShaderGraph.Result |
Final result
|
| Editor.ShaderGraph.BaseResult |
|
| Editor.ShaderGraph.SamplerFilter |
|
| Editor.ShaderGraph.SamplerAddress |
|
| Editor.ShaderGraph.Sampler |
|
| Editor.ShaderGraph.BlendMode |
|
| Editor.ShaderGraph.ShadingModel |
|
| Editor.ShaderGraph.ShaderDomain |
|
| Editor.ShaderGraph.PreviewSettings |
|
| Editor.ShaderGraph.ShaderGraph |
|
| Editor.ShaderGraph.ShaderNode |
|
| Editor.ShaderGraph.SubgraphNode |
|
| Editor.ShaderGraph.TextureExtension |
|
| Editor.ShaderGraph.TextureProcessor |
|
| Editor.ShaderGraph.TextureColorSpace |
|
| Editor.ShaderGraph.TextureFormat |
|
| Editor.ShaderGraph.TextureType |
|
| Editor.ShaderGraph.UIGroup |
|
| Editor.ShaderGraph.TextureInput |
|
| Editor.TerrainEditor.BrushList |
Brushes you can use
|
| Editor.TerrainEditor.Brush |
|
| Editor.TerrainEditor.BrushSettings |
|
| Editor.TerrainEditor.BrushSettingsWidgetWindow |
|
| Editor.TerrainEditor.TerrainEditorTool |
Modify terrains
|
| Editor.TerrainEditor.TerrainMaterialList |
|
| Editor.TerrainEditor.SculptMode |
Our sculpt brush types, passed to the compute shader
|
| Editor.TerrainEditor.TerrainPaintParameters |
A collection of parameters we'll use for tools
|
| Editor.TerrainEditor.BaseBrushTool |
Base brush tool, handles common logic we'd reuse across brush modes.
|
| Editor.TerrainEditor.FlattenTool |
Flatten an area of terrain.
|
| Editor.TerrainEditor.HoleTool |
Puts a hole in the terrain.<br /><br /><b>Ctrl</b> - fill hole
|
| Editor.TerrainEditor.NoiseTool |
Adds a random noise to a terrain.
|
| Editor.TerrainEditor.PaintTextureTool |
|
| Editor.TerrainEditor.RaiseLowerTool |
Click and drag to raise terrain.<br /><br /><b>Ctrl</b> - lower terrain
|
| Editor.TerrainEditor.SmoothTool |
Smooth an area of terrain.
|
| Editor.Experimental.StyleWidget |
|
| Editor.Experimental.StyleLabel |
|
| Editor.Experimental.Button2 |
|
| Editor.NodeEditor.ColorEditor |
|
| Editor.NodeEditor.CommentColor |
|
| Editor.NodeEditor.CommentUI |
|
| Editor.NodeEditor.Connection |
|
| Editor.NodeEditor.DragDirection |
|
| Editor.NodeEditor.ConnectionPlug |
|
| Editor.NodeEditor.ConnectionHandleConfig |
|
| Editor.NodeEditor.ConnectionStyle |
Base class for graph editor connection line styles, e.g. curvy or angular.
|
| Editor.NodeEditor.ClassicConnectionStyle |
Original curvy cubic line style.
|
| Editor.NodeEditor.GridConnectionStyle |
|
| Editor.NodeEditor.MenuExtensions |
|
| Editor.NodeEditor.FloatEditor |
|
| Editor.NodeEditor.GraphView |
|
| Editor.NodeEditor.FilterModifier |
|
| Editor.NodeEditor.FilterPart |
|
| Editor.NodeEditor.NodeQuery |
|
| Editor.NodeEditor.NodeQueryExtensions |
|
| Editor.NodeEditor.RerouteUI |
|
| Editor.NodeEditor.NodeUI |
|
| Editor.NodeEditor.Plug |
|
| Editor.NodeEditor.HandleShape |
|
| Editor.NodeEditor.HandleConfig |
|
| Editor.NodeEditor.PlugIn |
|
| Editor.NodeEditor.PlugOut |
|
| Editor.NodeEditor.ResizableItem |
Example of a resizable item for when I need it
|
| Editor.NodeEditor.TypeNameFormatter |
|
| Editor.NodeEditor.ValueEditor |
|
| Editor.MeshEditor.BlockPrimitive |
|
| Editor.MeshEditor.QuadPrimitive |
|
| Editor.MeshEditor.StairsPrimitive |
|
| Editor.MeshEditor.MeshEdge |
References a edge handle and the mesh component it belongs to.
|
| Editor.MeshEditor.BevelEdges |
|
| Editor.MeshEditor.BevelEdgesInspector |
|
| Editor.MeshEditor.EdgeInspector |
|
| Editor.MeshEditor.MeshFace |
References a face handle and the mesh component it belongs to.
|
| Editor.MeshEditor.FaceInspector |
|
| Editor.MeshEditor.MeshVertex |
References a vertex handle and the mesh component it belongs to.
|
| Editor.MeshEditor.VertexInspector |
|
| Editor.MeshEditor.BaseMeshTool |
Base class for vertex, edge and face tools.
|
| Editor.MeshEditor.BaseMoveTool |
Base class for moving mesh elements (move, rotate, scale)
|
| Editor.MeshEditor.BlockTool |
Create new shapes by dragging out a block
|
| Editor.MeshEditor.BlockToolInspector |
|
| Editor.MeshEditor.EdgeTool |
Move, rotate and scale mesh edges
|
| Editor.MeshEditor.FaceTool |
Move, rotate and scale mesh faces
|
| Editor.MeshEditor.MeshComponentTool |
|
| Editor.MeshEditor.MeshComponentWidget |
|
| Editor.MeshEditor.PivotTool |
Set the location of the gizmo for the current selection.
|
| Editor.MeshEditor.PositionTool |
Move selected Mesh Elements.<br /><br /><b>Ctrl</b> - toggle snap to grid<br /><b>Shift</b> - extrude selection
|
| Editor.MeshEditor.RotateTool |
Rotate selected Mesh Elements.<br /><br /><b>Ctrl</b> - toggle snap to grid
<b>Shift</b> - extrude selection
|
| Editor.MeshEditor.ScaleTool |
Scale selected Mesh Elements.<br /><br /><b>Ctrl</b> - toggle snap to grid<br /><b>Shift</b> - extrude selection
|
| Editor.MeshEditor.VertexTool |
Move, rotate and scale mesh vertices
|
| Editor.LibraryManager.LibraryManagerDock |
|
| Editor.LibraryManager.InstalledLibrariesWidget |
|
| Editor.LibraryManager.AvailableLibrariesWidget |
|
| Editor.Inspectors.AssetInspector |
|
| Editor.Inspectors.AssetPreviewWidget |
|
| Editor.Inspectors.GameResourceEditor |
|
| Editor.Inspectors.ModelInspector |
|
| Editor.Inspectors.AnimationParameterList |
|
| Editor.Inspectors.StyleEditor |
|
| Editor.Inspectors.SoundFileCompileSettings |
|
| Editor.Inspectors.TextureCompileSettings |
|
| Editor.Inspectors.GameObjectInspector |
|
| Editor.Inspectors.SceneInspector |
|
| Editor.Inspectors.PrefabFileInspector |
|
| Editor.Inspectors.SceneFileInspector |
|
| Editor.Wizards.PublishConfig |
|
| Editor.VisemeEditor.MorphSlider |
|
| Editor.VisemeEditor.Morphs |
|
| Editor.VisemeEditor.Preview |
|
| Editor.VisemeEditor.Visemes |
|
| Editor.VisemeEditor.Window |
|
| Editor.TextureEditor.TextureRect |
|
| Editor.TextureEditor.Preview |
|
| Editor.TextureEditor.Properties |
|
| Editor.TextureEditor.GammaType |
|
| Editor.TextureEditor.ImageFormatType |
|
| Editor.TextureEditor.MipAlgorithm |
|
| Editor.TextureEditor.TextureSequence |
|
| Editor.TextureEditor.TextureFile |
|
| Editor.TextureEditor.Window |
|
| Editor.SoundEditor.Preview |
|
| Editor.SoundEditor.Properties |
|
| Editor.SoundEditor.PhonemeFrame |
|
| Editor.SoundEditor.Timeline |
|
| Editor.SoundEditor.TimelineView |
|
| Editor.SoundEditor.WaveForm |
|
| Editor.SoundEditor.TimeAxis |
|
| Editor.SoundEditor.Scrubber |
|
| Editor.SoundEditor.PhonemeItem |
|
| Editor.SoundEditor.Window |
|
| Editor.RectEditor.SelectionOperation |
|
| Editor.RectEditor.Document |
|
| Editor.RectEditor.MaterialReference |
|
| Editor.RectEditor.MaterialPicker |
|
| Editor.RectEditor.Properties |
|
| Editor.RectEditor.RectAssetData |
|
| Editor.RectEditor.DragState |
|
| Editor.RectEditor.RectView |
|
| Editor.RectEditor.Window |
|
| Editor.ProjectSettingPages.CollisionMatrixWidget |
|
| Editor.ProjectSettingPages.WildcardPathWidget |
|
| Editor.PanelInspector.PanelInspectorWidget |
|
| Editor.PanelInspector.PanelTreeNode |
|
| Editor.AssetPickers.GenericPicker |
An asset browser allowing the user to pick a single asset.
Supports limiting display to only certain asset types.
|
| Editor.AssetPickers.SimplePicker |
|
| Editor.GraphicsItems.EditableCurve |
Anatomy of an EditableCurve: https://files.facepunch.com/garry/72bd3a5f-c9e4-40fe-8748-05e782d3a230.png
|
| Editor.GraphicsItems.RangePolygon |
|
| Editor.GraphicsItems.ChartBackground |
A generic chart background. Has axis down left and along bottom.
|
| Editor.CodeEditors.Rider |
|
| Editor.CodeEditors.VisualStudio |
|
| Editor.CodeEditors.VisualStudioCode |
|
| Editor.Audio.AudioMeterWidget |
Shows left and right volume bars, with a peak indicator.
|
| Editor.Audio.MixerDetail |
|
| Editor.Audio.Helper |
|
| Editor.Audio.MixerDock |
|
| Editor.Audio.MixerTree |
|
| Editor.Audio.MixerTreeNode |
|
| Editor.Audio.MixerWidget |
|
| Editor.Audio.ProcessorListWidget |
|
| Editor.Audio.ProcessorWidget |
|
| Editor.Audio.VolumeSliderWidget |
|
| Editor.Audio.VolumeTicksWidget |
|
| Editor.Assets.AssetPreview |
|
| Editor.Assets.PixmapAssetPreview |
|
