| 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. |
| HideInEditorAttributeobsolete |
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. |
| Color.Rgba16 |
|
| 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. |
| RangedFloat.RangeType |
Range type of RangedFloat. |
| 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. |
| Vector3.SmoothDamped |
Everything you need to smooth damp a Vector3. Just call Update every frame. |
| Vector3.SpringDamped |
Everything you need to create a springy Vector3 |
| 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.ExpressionNodeAttributeobsolete |
|
| Sandbox.ActionNodeAttributeobsolete |
|
| 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.ConCmdAttribute.AutoCompleteResult |
|
| 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.Curve.Frame |
Keyframes times and values should range between 0 and 1 |
| Sandbox.Curve.HandleMode |
Describes how the line should behave when entering/leaving a frame |
| Sandbox.CurveRange |
Two curves |
| Sandbox.Frustum |
Represents a frustum. |
| Sandbox.Gradient |
Describes a gradient between multiple colors |
| Sandbox.Gradient.ColorFrame |
Keyframes times and values should range between 0 and 1 |
| Sandbox.Gradient.AlphaFrame |
Keyframes times and values should range between 0 and 1 |
| Sandbox.Gradient.BlendMode |
Describes how the line should behave when entering/leaving a frame |
| 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.Spline.Point |
Point that defines part of the spline.
Two consecutive points define a segment of the spline.
The Sandbox.Spline.Point.Position, Sandbox.Spline.Point.In/Sandbox.Spline.Point.Out Handles and <see cref="F:Sandbox.Spline.Point.Mode"></see> / properties are used to define the shape of the spline.
<code>
P1 (Position)
P1 (In) ▼ P1 (Out)
o──────═══X═══──────o
───/ \───
──/ \──
-/ \-
/ \
| |
P0 X X P2
</code> |
| Sandbox.Spline.HandleMode |
Describes how the spline should behave when entering/leaving a point. |
| Sandbox.Spline.Sample |
Information about the spline at a specific distance. |
| 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.SerializedObject.PropertyChangedDelegate |
|
| Sandbox.SerializedObject.PropertyPreChangeDelegate |
|
| Sandbox.SerializedObject.PropertyStartEditDelegate |
|
| Sandbox.SerializedObject.PropertyFinishEditDelegate |
|
| Sandbox.SerializedProperty |
|
| Sandbox.SerializedProperty.AsAccessor |
|
| Sandbox.SerializedProperty.Proxy |
Allows easily creating SerializedProperty classes that wrap other properties. |
| 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.IByteParsable.ByteParseOptions |
|
| 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.SteamId.AccountTypes |
|
| 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.StringToken.ConvertAttribute |
To allow redirecting in the case where a class has both a string and StringToken version of a method.
We should be able to remove this when we're compiling on demand instead of keeping the string versions around for compatibility. |
| 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.IStyleBlock.StyleProperty |
|
| 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.PanelTransform.Entry |
|
| Sandbox.UI.PanelTransform.EntryType |
|
| 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.Noise.Parameters |
Parameters for constructing a noise field. Use Sandbox.Utility.Noise.FractalParameters if you
want a noise field made from multiple octaves. |
| Sandbox.Utility.Noise.FractalParameters |
Parameters for constructing a fractal
noise field, which layers multiple octaves of a noise function with increasing frequency
and reducing amplitudes. |
| 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.DataProgress.Callback |
|
| 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.Utility.Easing.Function |
An easing function that transforms the linear input into non linear output. |
| 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 |
|
| 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 |
|
| 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.Application |
|
| 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.Gizmo |
|
| Sandbox.Gizmo.GizmoControls |
Extendable helper to create common gizmos |
| Sandbox.Gizmo.GizmoDraw |
Contains functions to add objects to the Gizmo Scene. This
is an instantiable class so it's possible to add extensions. |
| Sandbox.Gizmo.Colors |
Using pure primary colors is horrible. Lets make it easier to avoid. |
| Sandbox.Gizmo.Inputs |
The input state, allows interaction with Gizmos |
| Sandbox.Gizmo.Instance |
Holds the backend state for a Gizmo scope. This allows us to have multiple different gizmo
states (for multiple views, multiple windows, game and editor) and push them as the current
active state whenever needed. |
| Sandbox.Gizmo.Pressed |
Access to the currently pressed path information |
| Sandbox.Gizmo.GridAxis |
|
| Sandbox.Gizmo.SceneSettings |
|
| Sandbox.Gizmo.GizmoHitbox |
Contains functions to add objects to the immediate mode Scene. This
is an instantiable class so it's possible to add extensions. |
| 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.Clothing |
A piece of player model customization. |
| Sandbox.Clothing.ClothingCategory |
|
| Sandbox.Clothing.Slots |
|
| Sandbox.Clothing.BodyGroups |
|
| Sandbox.Clothing.IconSetup |
|
| Sandbox.Clothing.IconSetup.IconModes |
|
| Sandbox.ClothingContainer |
Holds a collection of clothing items. Won't let you add items that aren't compatible. |
| Sandbox.ClothingContainer.ClothingEntry |
|
| Sandbox.ClothingContainer.Entry |
Used for serialization |
| Sandbox.WorkshopItemMetaData |
Some metadata we'll pack into a workshop submission when publishing. |
| Sandbox.Friend |
|
| Sandbox.Game |
Provides global access to core game state, utilities, and operations for S&box.
<para>
The Sandbox.Game class exposes static properties and methods to query and control the running game,
such as checking if the game is running, getting your steamid, taking screenshots, and managing game sessions.
</para> |
| Sandbox.Game.Overlay |
Provides static methods for displaying various modal overlays in the game UI.
<para>
The Sandbox.Game.Overlay class allows you to open modals for packages, maps, news, organizations, reviews, friends lists, server lists, settings, input bindings, and player profiles.
It serves as a central point for invoking user interface overlays that interact with core game and community features.
</para> |
| 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.MapLoader.ObjectEntry |
Holds key values for the map object |
| Sandbox.SceneMapLoader |
|
| Sandbox.SceneMapLoader.TextSceneObject |
|
| Sandbox.PartyRoom |
A Party. A Party with your friends. |
| Sandbox.PartyRoom.Entry |
|
| Sandbox.Preferences |
Holds information about the current user's preferences. |
| Sandbox.CurrencyValue |
Describes money, in a certain currency |
| Sandbox.Standalone |
|
| Sandbox.StandaloneManifest |
|
| Sandbox.StreamChannel |
|
| Sandbox.StreamChatMessage |
|
| Sandbox.StreamClip |
|
| Sandbox.Streamer |
|
| Sandbox.StreamPoll |
|
| Sandbox.StreamPoll.Choice |
|
| Sandbox.StreamPrediction |
|
| Sandbox.StreamPrediction.Outcome |
|
| Sandbox.StreamService |
Streamer integration services |
| Sandbox.StreamUser |
|
| Sandbox.StreamUserFollow |
|
| 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.DecalDefinition.DecalEntry |
|
| 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.Material.FlagsAccessor |
|
| Sandbox.Material.UI |
Static materials for UI rendering purposes. |
| 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.Mesh.IndexBufferLockHandler |
|
| Sandbox.Mesh.VertexBufferLockHandler<T> |
|
| Sandbox.VertexAttributeType |
|
| Sandbox.VertexAttributeFormat |
|
| Sandbox.VertexAttribute |
|
| Sandbox.BoneCollection |
A collection of bones. This could be from a model, or an entity |
| Sandbox.BoneCollection.Bone |
A bone in a Sandbox.BoneCollection. |
| Sandbox.Model |
A model. |
| Sandbox.Model.BodyPart |
|
| Sandbox.Model.BodyPart.Choice |
|
| Sandbox.Model.BodyGroupMaskAttribute |
Used to mark properties as a body group mask, so the correct editor can be used |
| Sandbox.Model.MaterialGroupAttribute |
Used to mark a property as a material group, for the editor |
| Sandbox.Model.MaterialOverrideAttribute |
Used to mark a property as a material material override dictionary, for the editor |
| 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.ModelBuilder.Bone |
A bone definition for use with Sandbox.ModelBuilder. |
| Sandbox.ModelAttachments |
|
| Sandbox.ModelAttachments.Attachment |
|
| Sandbox.HitboxSet |
|
| Sandbox.HitboxSet.Box |
|
| Sandbox.ModelMorphs |
Allows fast lookups of morph variables |
| Sandbox.PhysicsGroupDescription |
|
| Sandbox.PhysicsGroupDescription.JointType |
|
| Sandbox.PhysicsGroupDescription.Joint |
|
| Sandbox.PhysicsGroupDescription.BodyPart |
|
| Sandbox.PhysicsGroupDescription.BodyPart.Part |
|
| Sandbox.PhysicsGroupDescription.BodyPart.SpherePart |
|
| Sandbox.PhysicsGroupDescription.BodyPart.CapsulePart |
|
| Sandbox.PhysicsGroupDescription.BodyPart.HullPart |
|
| Sandbox.PhysicsGroupDescription.BodyPart.MeshPart |
|
| Sandbox.ParticleSnapshotobsolete |
A particle snapshot that can be created procedurally.
Contains a set of vertices that particle effects can address. |
| Sandbox.ParticleSnapshot.Vertex |
A vertex to update a particle snapshot with. |
| Sandbox.ParticleSystemobsolete |
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.ResourceSystem |
|
| Sandbox.ResourceLibrary |
Keeps a library of all available Sandbox.Resource. |
| Sandbox.PrefabFile |
|
| Sandbox.PrefabVariableobsolete |
A prefab variable definition |
| Sandbox.PrefabVariable.PrefabVariableTarget |
Targets a property in a component or gameobject. |
| 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.Soundscape.LoopedSound |
|
| Sandbox.Soundscape.StingSound |
|
| Sandbox.SoundEvent |
A sound event. It can play a set of random sounds with optionally random settings such as volume and pitch. |
| Sandbox.SoundEvent.SoundSelectionMode |
|
| 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.Surface.ImpactEffectDataobsolete |
|
| Sandbox.Surface.ScrapeEffectDataobsolete |
|
| Sandbox.Surface.OldSoundDataobsolete |
|
| Sandbox.Surface.SurfacePrefabCollection |
Holds a dictionary of common prefabs associated with a surface |
| Sandbox.Surface.SurfaceSoundCollection |
Holds a dictionary of common sounds associated with a surface. This allows you to pick and choose an appropriate sound. |
| 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.TerrainStorage.TerrainMaterialSettings |
|
| 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.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.SoundscapeTrigger.TriggerType |
|
| Sandbox.Voice |
Records and transmits voice/microphone input to other players. |
| Sandbox.Voice.ActivateMode |
|
| Sandbox.CameraComponent |
Every scene should have at least one Camera. |
| Sandbox.CameraComponent.Axis |
|
| Sandbox.CubemapFog |
Applies a cubemap fog effect to the camera |
| Sandbox.Tonemapping |
Applies a tonemapping effect to the camera. |
| Sandbox.Tonemapping.TonemappingMode |
Options to select a tonemapping algorithm to use for color grading. |
| Sandbox.Tonemapping.ExposureColorSpaceEnum |
|
| 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.HullCollider.PrimitiveType |
|
| 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.Component.IPressable.Event |
Describes who pressed it. |
| Sandbox.MakeDirtyAttribute |
|
| Sandbox.ComponentFlags |
|
| Sandbox.LegacyParticleSystemobsolete |
Support's Source Engine's vpcf particles |
| Sandbox.Dresser |
Allows easily dressing a citizen or human in clothing |
| Sandbox.Dresser.ClothingSource |
|
| 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.ManualHitbox.HitboxShape |
|
| 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.HingeJoint.MotorMode |
|
| Sandbox.Joint |
|
| Sandbox.Joint.AttachmentMode |
|
| 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.EnvmapProbe.CubemapResolution |
|
| Sandbox.EnvmapProbe.CubemapDynamicUpdate |
|
| Sandbox.Light |
|
| Sandbox.Light.FogInfluence |
|
| 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.MeshComponent.CollisionType |
|
| Sandbox.PolygonMesh |
An editable mesh made up of polygons, triangulated into a model |
| Sandbox.PolygonMesh.BevelEdgesMode |
|
| Sandbox.PolygonMesh.EdgeSmoothMode |
|
| Sandbox.PolygonMesh.DissolveRemoveVertexCondition |
|
| Sandbox.PolygonMesh.ExtentType |
|
| Sandbox.PolygonMesh.FaceExtents |
|
| Sandbox.PolygonMesh.TextureJustification |
|
| 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.NavMeshAgent.LinkTraversalData |
Holds information about the current link the agent is traversing. |
| 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.Particle.BaseListener |
Allows creating a class that will exist for as long as a particle.
The methods get called in the particle thread, which removes the need to run through
the particle list again, but it has the danger and restrictions that come with threaded code. |
| Sandbox.ParticleControlPointobsolete |
|
| Sandbox.ParticleControlPoint.ControlPointValueInputobsolete |
|
| Sandbox.ParticleEffect |
Defines and holds particles. This is the core of the particle system. |
| Sandbox.ParticleEffect.TimingMode |
|
| Sandbox.ParticleEffect.SimulationSpace |
|
| Sandbox.ParticleFloat |
|
| Sandbox.ParticleFloat.ValueType |
|
| Sandbox.ParticleFloat.EvaluationType |
|
| Sandbox.ParticleVector3 |
|
| Sandbox.ParticleGradient |
|
| Sandbox.ParticleGradient.ValueType |
|
| Sandbox.ParticleGradient.EvaluationType |
|
| Sandbox.ParticleLightRenderer |
Adds lighting to particles in your effect. |
| Sandbox.ParticleModelRenderer |
Renders particles as models, using the particle's position, rotation, and size. |
| Sandbox.ParticleModelRenderer.ModelEntry |
|
| Sandbox.ParticleRenderer |
Renders a set of particles. Should be attached to a Sandbox.ParticleRenderer.ParticleEffect. |
| Sandbox.ParticleSpriteRenderer |
Renders particles as 2D sprites |
| Sandbox.ParticleSpriteRenderer.BillboardAlignment |
|
| Sandbox.ParticleSpriteRenderer.ParticleSortMode |
|
| Sandbox.ParticleTextRenderer |
Renders particles as 2D sprites |
| Sandbox.ParticleTextRenderer.BillboardAlignment |
|
| Sandbox.ParticleTextRenderer.ParticleSortMode |
|
| 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.AmbientOcclusion.SampleQuality |
|
| Sandbox.AmbientOcclusion.DenoiseModes |
|
| 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.ColorGrading.GradingType |
|
| Sandbox.ColorGrading.ColorSpaceEnum |
|
| Sandbox.DepthOfField |
Applies a depth of field effect to the camera |
| Sandbox.DepthOfField.Quality |
|
| 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.DecalRendererobsolete |
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.ModelRenderer.ShadowRenderType |
|
| Sandbox.Renderer |
|
| Sandbox.RenderOptions |
|
| Sandbox.SkinnedModelRenderer |
Renders a skinned model in the world. A skinned model is any model with bones/animations. |
| Sandbox.SkinnedModelRenderer.BoneVelocity |
|
| Sandbox.SkinnedModelRenderer.MorphAccessor |
|
| Sandbox.SkinnedModelRenderer.ParameterAccessor |
|
| Sandbox.SkinnedModelRenderer.SequenceAccessor |
|
| 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.TextRenderer.TextAlign |
|
| 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.Terrain.SyncFlags |
|
| Sandbox.PanelComponent |
|
| Sandbox.ScreenPanel |
Renders any attached PanelComponents to the screen. Acts as the root for all your UI components. |
| Sandbox.ScreenPanel.AutoScale |
|
| 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.WorldPanel.HAlignment |
|
| Sandbox.WorldPanel.VAlignment |
|
| Sandbox.SceneInformation |
|
| 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.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.Stage |
A list of stages in the scene tick in which we can hook |
| 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.GameObject.NetworkAccessor |
|
| Sandbox.GameObject.SerializeOptions |
|
| Sandbox.GameObject.DeserializeOptions |
|
| 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.HostSyncAttributeobsolete |
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.Rpc.BroadcastAttribute |
Marks a method as being an RPC. It will be called for everyone. |
| Sandbox.Rpc.HostAttribute |
Marks a method as being an RPC. It will only be called on the host. |
| Sandbox.Rpc.OwnerAttribute |
Marks a method as being an RPC. It will only be called on owner of this object. |
| Sandbox.BroadcastAttributeobsolete |
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.AuthorityAttributeobsolete |
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.NetPermissionobsolete |
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.PrefabScene.VariableCollectionobsolete |
A collection of variabnles that have been configured for this scene |
| Sandbox.Scene |
|
| Sandbox.GameObjectUndoFlags |
|
| Sandbox.SceneTrace |
|
| Sandbox.SceneTraceResult |
|
| Sandbox.CachingHandler |
|
| Sandbox.Achievement |
|
| Sandbox.AchievementCollection |
Holds achievements for a package |
| Sandbox.Cloud |
For accessing assets from the cloud - from code |
| Sandbox.Cloud.AssetAttribute |
Automatically addeded to a type as a result of using Cloud.Model etc inside. |
| Sandbox.ManifestSchema |
An addon's manifest, describing what files are available |
| Sandbox.ManifestSchema.File |
|
| Sandbox.Package |
Represents an asset on Asset Party. |
| Sandbox.Package.PackageUsageStats |
Statistics for user interactions with this package |
| Sandbox.Package.PackageUsageStats.Group |
|
| Sandbox.Package.Screenshot |
|
| Sandbox.Package.ReviewStats |
|
| Sandbox.Package.Organization |
Represents an organization on Asset Party. Organization owns packages. |
| Sandbox.Package.Type |
|
| Sandbox.Package.PackageInteraction |
|
| Sandbox.Package.LoadingScreenSetup |
|
| Sandbox.Package.Facet |
Describes a facet of a group of items, with a limited
number of each facet with their total item counts |
| Sandbox.Package.Facet.Entry |
A facet entry consists of a name, display information and the number of items inside |
| Sandbox.Package.FindResult |
A result from the call to FindAsync |
| Sandbox.Package.TagEntry |
Represents a tag along with the count of items it contains |
| Sandbox.Package.SortOrder |
Describes a sort order which can be used with the package/find api |
| Sandbox.Package.PackageProperty |
A binary category used to divide into two categories. For example, Work In Progress. |
| Sandbox.Package.ListResult |
Represents the actual response from the api |
| Sandbox.Package.ListResult.Grouping |
|
| 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.SoundHandle.LipSyncAccessor |
|
| Sandbox.SoundStream |
|
| Sandbox.ConsoleSystem |
A library to interact with the Console System. |
| Sandbox.CookieContainer |
|
| Sandbox.FileSystem |
A filesystem that can be accessed by the game. |
| Sandbox.Input |
Allows querying of player button presses and other inputs. |
| Sandbox.Input.Keyboard |
|
| 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.LanguageContainer |
A container for the current language, allowing access to translated phrases and language information. |
| Sandbox.Language |
Allows access to translated phrases, allowing the translation of gamemodes etc |
| 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.Connection.Filter |
|
| Sandbox.Connection.Filter.FilterType |
|
| 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.PhysicsContact.Target |
|
| Sandbox.PhysicsIntersection |
|
| Sandbox.PhysicsIntersectionEnd |
|
| Sandbox.ConfigData |
Project configuration data is derived from this class |
| Sandbox.CursorSettings |
|
| Sandbox.CursorSettings.Cursor |
|
| 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.BlendMode |
Blend modes used by the UI system |
| Sandbox.ComputeBufferTypeobsolete |
|
| Sandbox.ComputeBuffer<T>obsolete |
|
| 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.UsageFlags |
You can combine these e.g UsageFlags.Index | UsageFlags.ByteAddress for a buffer that can be used as an index buffer and in a compute shader. |
| Sandbox.GpuBuffer.IndirectDrawArguments |
|
| Sandbox.GpuBuffer.IndirectDrawIndexedArguments |
|
| Sandbox.GpuBuffer.IndirectDispatchArguments |
|
| 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.Graphics.PrimitiveType |
|
| Sandbox.Graphics.DownsampleMethod |
Which method to use when downsampling a texture |
| 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.VideoPlayer.TextureChangedDelegate |
|
| Sandbox.VideoPlayer.AudioAccessor |
|
| Sandbox.VideoWriter |
Allows the creation of video content by encoding a sequence of frames. |
| Sandbox.VideoWriter.Config |
|
| Sandbox.VideoWriter.Codec |
|
| Sandbox.VideoWriter.Container |
|
| 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.SceneLayerType |
|
| Sandbox.TextRendering |
|
| Sandbox.TextRendering.Scope |
Defines a scope of text, all using the same style. |
| Sandbox.TextRendering.Outline |
|
| Sandbox.TextRendering.Shadow |
|
| Sandbox.VertexLayout |
Allows for the definition of custom vertex layouts |
| Sandbox.VertexLayout.BaseAttribute |
|
| Sandbox.VertexLayout.Position |
|
| Sandbox.VertexLayout.Normal |
|
| Sandbox.VertexLayout.Color |
|
| Sandbox.VertexLayout.TexCoord |
|
| Sandbox.VertexLayout.Tangent |
|
| Sandbox.VertexLayout.BlendWeight |
|
| Sandbox.VertexLayout.BlendIndices |
|
| Sandbox.VolumetricFogParameters |
|
| Sandbox.CubemapFogController |
|
| Sandbox.SceneDynamicObject |
|
| Sandbox.SceneCamera |
Represents a camera and holds render hooks. This camera can be used to draw tool windows and scene panels. |
| Sandbox.SceneCamera.BloomAccessor |
|
| Sandbox.SceneCamera.BloomAccessor.BloomMode |
|
| Sandbox.SceneCamera.TonemapAccessor |
|
| Sandbox.ClearFlags |
Flags for clearing a RT before rendering a scene using a SceneCamera |
| Sandbox.SceneCameraDebugMode |
|
| Sandbox.SceneCubemap |
|
| Sandbox.SceneCubemap.ProjectionMode |
|
| 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.SceneCullingBox.CullMode |
Cull mode, either inside or outside |
| 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.SceneLight.FogLightingMode |
|
| Sandbox.SceneLight.LightShape |
|
| Sandbox.SceneLineObject |
A scene object which is used to draw lines |
| Sandbox.SceneLineObject.CapStyle |
|
| Sandbox.SceneLineObject.FaceMode |
|
| 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.SceneModel.FootstepEvent |
|
| Sandbox.SceneModel.GenericEvent |
|
| Sandbox.SceneModel.SoundEvent |
|
| Sandbox.SceneModel.AnimTagEvent |
|
| Sandbox.SceneModel.AnimTagStatus |
Enumeration that describes how the AnimGraph tag state changed. Used in Sandbox.SceneModel.AnimTagEvent. |
| Sandbox.SceneObject |
A model scene object that can be rendered within a Sandbox.SceneWorld. |
| Sandbox.SceneObject.SceneObjectFlagAccessor |
|
| 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.SceneParticlesobsolete |
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.SceneSkyBox.FogType |
|
| Sandbox.SceneSkyBox.FogParamInfo |
|
| Sandbox.SceneSkyBox.SkyLightInfo |
|
| 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.MainThread |
Utility functions that revolve around the main thread |
| Sandbox.GameTask |
A generic Sandbox.TaskSource. |
| Sandbox.TaskSource |
Provides a way for us to cancel tasks after common async shit is executed. |
| Sandbox.ITagSet |
|
| Sandbox.Json |
A convenience JSON helper that handles Sandbox.Resource types for you. |
| Sandbox.Json.Pointer |
Represents a JSON Pointer as defined in RFC 6901. |
| Sandbox.Json.PointerJsonConverter |
Custom JSON converter for the Pointer class that serializes a Pointer as a string
and deserializes a string back into a Pointer using the Parse method. |
| 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.Mouse |
Gives access to mouse position etc |
| Sandbox.MouseVisibility |
The visibility state of the mouse cursor. |
| Sandbox.Screen |
Access screen dimension etc. |
| Sandbox.TagSet |
|
| Sandbox.TagSet.JsonConvert |
|
| 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.WebSocket |
A WebSocket client for connecting to external services. |
| Sandbox.WebSocket.MessageReceivedHandler |
Event handler which processes text messages from the WebSocket service. |
| Sandbox.WebSocket.DataReceivedHandler |
Event handler which processes binary messages from the WebSocket service. |
| Sandbox.WebSocket.DisconnectedHandler |
Event handler which fires when the WebSocket disconnects from the server. |
| Sandbox.WebSurface |
Enables rendering and interacting with a webpage |
| Sandbox.WebSurface.TextureChangedDelegate |
|
| Sandbox.Http |
Lets your game make async HTTP requests. |
| Sandbox.Utility.EditorTools |
Functions to interact with the tools system. Does nothing if tools aren't enabled. |
| 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.Razor.RenderTreeBuilderOldobsolete |
|
| Sandbox.UI.KeyFrames |
Represents a CSS <c>@keyframes</c> rule. |
| Sandbox.UI.KeyFrames.Block |
A keyframe within the animation. |
| 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.PanelInputType |
|
| 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.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.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.Styles.GradientColorOffset |
|
| Sandbox.UI.Styles.GradientGenerator |
|
| 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.Transitions.TransitionFunction |
|
| Sandbox.UI.Transitions.Entry |
|
| Sandbox.UI.Clipboard |
|
| Sandbox.UI.Emoji |
Helper class for working with Unicode emoji. |
| 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.Tasks.SyncTask |
|
| 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.CollisionRules.Result |
Result of a collision between <see cref="T:Sandbox.Physics.CollisionRules.Pair">two objects</see>. |
| Sandbox.Physics.CollisionRules.Pair |
A pair of case- and order-insensitive tags, used as a key to look up a Sandbox.Physics.CollisionRules.Result. |
| Sandbox.Physics.PhysicsSettings |
|
| Sandbox.Network.HostStats |
|
| Sandbox.Network.NetworkFile |
|
| Sandbox.Network.MountedVPKsResponse |
|
| Sandbox.Network.InitialSnapshotResponse |
|
| Sandbox.Network.SnapshotMsg |
|
| Sandbox.Network.SnapshotMsg.GameObjectSystemData |
|
| 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.Speech.SpeechRecognitionResult |
A result from speech recognition. |
| Sandbox.Speech.Recognition |
|
| Sandbox.Speech.Recognition.OnSpeechResult |
Called when we have a result from speech recognition. |
| Sandbox.Speech.Synthesizer |
A speech synthesis stream. Lets you write text into speech and output it to a Sandbox.SoundHandle. |
| Sandbox.Speech.Synthesizer.InstalledVoice |
|
| Sandbox.Audio.AudioDistanceFloatAttribute |
|
| Sandbox.Audio.AudioMeter |
Allows the capture and monitor of an audio source |
| Sandbox.Audio.AudioMeter.Frame |
|
| 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.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.SceneVolume.VolumeTypes |
|
| 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.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.ResourceCompileContext.Child |
|
| Sandbox.Resources.ResourceCompileContext.DataStream |
|
| 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.ResourceCompiler.ResourceIdentityAttribute |
Mark a ResourceCompiler. This is used to identify the compiler for a specific file extension, or compiler. |
| Sandbox.Resources.ResourceGenerator |
Creates a resource from a json definition |
| Sandbox.Resources.ResourceGenerator.Options |
|
| 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.VR.FingerValue |
Accessors for Sandbox.VR.VRController.GetFingerValue(Sandbox.VR.FingerValue) |
| Sandbox.VR.TrackedDeviceRole |
|
| Sandbox.VR.TrackedDeviceType |
|
| Sandbox.VR.VROverlayobsolete |
<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.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.VRHand.HandSources |
Represents a controller to use when fetching skeletal data (finger curl/splay values) |
| Sandbox.VR.VRModelRenderer |
Renders a device-specific model for a VR device |
| Sandbox.VR.VRModelRenderer.ModelSources |
Represents a controller to use when fetching the model (which device) |
| Sandbox.VR.VRTrackedObject |
Updates this GameObject's transform based on a given tracked object (e.g. left controller, HMD). |
| Sandbox.VR.VRTrackedObject.PoseSources |
Represents tracked devices to use when updating |
| Sandbox.VR.VRTrackedObject.TrackingTypes |
Represents transform values to update |
| 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.Rendering.CommandList |
|
| Sandbox.Rendering.CommandList.AttributeAccess |
|
| Sandbox.Rendering.CommandList.Flag |
Command buffer flags allow us to skip command buffers if the camera
doesn't want a particular thing. Like post processing. |
| Sandbox.Rendering.HudPainter |
2D Drawing functions for a Sandbox.Rendering.CommandList.
<para><c>HudPainter</c> provides a set of methods for drawing shapes, textures, and text onto a command list, typically for HUD or UI rendering.
</para> |
| Sandbox.Rendering.RenderTargetHandle |
A render target handle used with CommandLists |
| Sandbox.Rendering.RenderTargetHandle.ColorTextureRef |
|
| Sandbox.Rendering.RenderTargetHandle.ColorIndexRef |
|
| Sandbox.Rendering.RenderTargetHandle.SizeHandle |
|
| 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.GradientFogSetup |
Setup for defining gradient fog in a view |
| Sandbox.Rendering.ReflectionSetup |
Allows special setup for reflections, such as offsetting the reflection plane |
| Sandbox.Rendering.RefractionSetup |
Allows special setup for refraction, such as offsetting the clip plane |
| Sandbox.Rendering.RendererSetup |
When manually rendering a Renderer this will let you override specific
elements of that render. This means you can use most of the Renderer's
properties, but override some without disturbing the Renderer itself. |
| Sandbox.Rendering.ResourceState |
Used to describe a GPU resources state for barrier transitions. |
| Sandbox.Rendering.Stage |
|
| 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.Achievements.Map |
Stats for the current map |
| 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.Inventory.Item |
Describes a type of item that can be in the inventory |
| Sandbox.Services.Inventory.ItemDefinition |
Describes a type of item that can be in the inventory |
| Sandbox.Services.Leaderboards |
|
| Sandbox.Services.Leaderboards.Board |
|
| Sandbox.Services.Leaderboards.Entry |
|
| Sandbox.Services.Leaderboards.Board2 |
|
| Sandbox.Services.Leaderboards.Board2.Entry |
|
| Sandbox.Services.Messaging |
|
| Sandbox.Services.News |
News Posts |
| Sandbox.Services.Notification |
Player notification |
| Sandbox.Services.Review |
Package Reviews |
| Sandbox.Services.Review.ReviewScore |
|
| Sandbox.Services.ServerList |
|
| Sandbox.Services.ServerList.Entry |
This is a cleaned up version of gameserveritem_t. |
| 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.Stats.GlobalStats |
|
| Sandbox.Services.Stats.GlobalStat |
|
| Sandbox.Services.Stats.Map |
Stats for the current map |
| Sandbox.Services.Stats.PlayerStats |
|
| Sandbox.Services.Stats.PlayerStat |
|
| 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.GameSetting.Option |
|
| Sandbox.DataModel.ProjectConfig |
Configuration of a Sandbox.Project. |
| Sandbox.Menu.LoadingProgress |
|
| 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.Modals.FriendsListModalOptions |
|
| Sandbox.Modals.ServerListConfig |
|
| Sandbox.Modals.CreateGameOptions |
Passed to IModalSystem.CreateGame |
| Sandbox.Modals.CreateGameResults |
|
| Sandbox.Internal.GlobalGameNamespace |
|
| Sandbox.Diagnostics.Allocations |
Tools for diagnosing heap allocations |
| Sandbox.Diagnostics.Allocations.Entry |
|
| Sandbox.Diagnostics.Allocations.Scope |
|
| Sandbox.Diagnostics.FrameStats |
Stats returned from the engine each frame describing what was rendered, and how much of it. |
| Sandbox.Diagnostics.Performance |
|
| Sandbox.Diagnostics.Performance.ScopeSection |
This exists to allow the creation of performance scopes without |
| Sandbox.Diagnostics.PerformanceStats |
|
| Sandbox.Diagnostics.PerformanceStats.Block |
|
| Sandbox.Diagnostics.PerformanceStats.PeriodMetric |
|
| Sandbox.Diagnostics.PerformanceStats.Timings |
|
| Sandbox.Diagnostics.PerformanceStats.Timings.Frame |
|
| Sandbox.Diagnostics.PerformanceStats.VRStats |
|
| Sandbox.Engine.GameLoadingFlags |
|
| Sandbox.Engine.Protocol |
A centralized place to access the protocols |
| Sandbox.Engine.MaterialAccessor |
A wrapper to allow the unification of editing materials. This is usually a member on a Component which implements MaterialAccessor.ITarget. |
| 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.BindCollection.ActionBind |
|
| Sandbox.Engine.BindCollection.BindEntry |
|
| Sandbox.Engine.SystemInfo |
|
| Sandbox.Engine.Utility.RayTrace.MeshTraceRequest |
|
| Sandbox.Engine.Utility.RayTrace.MeshTraceRequest.Result |
|
| Sandbox.Engine.Utility.RayTrace.MeshTraceRequest.Result.VertexDetail |
|
| Sandbox.Engine.Shaders.ShaderCompile |
|
| Sandbox.Engine.Shaders.ShaderCompile.Results |
The results of a shader compile |
| Sandbox.Engine.Shaders.ShaderCompile.Results.Program |
The results of an individual shader program compile (PS, VS etc) |
| Sandbox.Engine.Shaders.ShaderCompileOptions |
Options used when compiling a shader |
| Sandbox.Engine.Settings.RenderSettings |
|
| Sandbox.Engine.Settings.RenderSettings.VideoDisplayMode |
|
| 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.EnumDescription.Entry |
|
| 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.Internal.TypeLibrary |
|
| 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.CodeArchive.AdditionalFile |
Represents a file to send to the compiler along with all the code. This is usually
something that the generator turns into code, such as a Razor file. |
| Sandbox.CompileGroup |
|
| Sandbox.CompileGroup.Results |
|
| Sandbox.Compiler |
Given a folder of .cs files, this will produce (and load) an assembly |
| Sandbox.Compiler.ReleaseMode |
|
| Sandbox.Compiler.Configuration |
|
| 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.Popup.PositionMode |
Dictates where a Sandbox.UI.Popup is positioned. |
| 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.TabContainer.Tab |
Holds a Tab button and a Page for each sheet on the TabControl. |
| Sandbox.UI.TextEntry |
A Sandbox.UI.Panel that the user can enter text into. |
| Sandbox.UI.TextEntry.AutocompleteEntry |
|
| 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. |
| Sandbox.Citizen.CitizenAnimationHelper.HoldTypes |
|
| Sandbox.Citizen.CitizenAnimationHelper.Hand |
|
| Sandbox.Citizen.CitizenAnimationHelper.MoveStyles |
|
| Sandbox.Citizen.CitizenAnimationHelper.SpecialMoveStyle |
|
| Sandbox.Citizen.CitizenAnimationHelper.SittingStyle |
|
| ComponentListWidget |
|
| NavMeshLinkTool |
|
| Editor.CodeEditorControlWidget |
|
| Editor.CreateAsset |
|
| Editor.CreateAsset.Entry |
|
| 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.AssetBrowser.LocationType |
|
| Editor.AssetBrowser.Location |
|
| 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.AssetPicker.PickerOptions |
|
| 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.MaterialAccessorControlWidget |
|
| 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.SceneViewportWidget.ViewMode |
|
| Editor.SceneViewportWidget.ViewportState |
|
| Editor.SceneViewWidget |
|
| Editor.SceneViewWidget.ViewportLayoutMode |
|
| 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.WidgetGalleryWindow.ColouredLabel |
|
| 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.DropdownControlWidget<T>.Entry |
|
| 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.GradientPresets.GradientPreset |
|
| Editor.KeyBindControlWidget |
|
| Editor.KeyBind |
|
| Editor.NavigationView |
|
| Editor.NavigationView.Option |
|
| Editor.PackageSelector |
|
| Editor.PopupWindow |
A simple popup window to quickly display a message, optionally with custom actions. |
| Editor.SoundPlayer |
|
| Editor.SoundPlayer.TimelineView |
|
| Editor.SoundPlayer.Scrubber |
|
| Editor.SoundPlayer.TimeAxis |
|
| Editor.SoundPlayer.WaveForm |
|
| Editor.TabWidget |
|
| Editor.TagsControlWidget |
|
| Editor.TagEdit |
A text entry that automatically breaks the input into tags |
| Editor.TagEdit.TagDetail |
Returned by Editor.TagEdit.Convertors on successfully parsing a tag |
| Editor.TagPicker |
Offers a popup menu with a number of "tags" when you can then select |
| Editor.TagPicker.Option |
|
| Editor.TagPicker.TagEntry |
|
| Editor.TagPicker.TagOption |
|
| 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.Header |
|
| Editor.TreeNode.SmallHeader |
|
| Editor.TreeNode.Section |
|
| Editor.TreeNode.Spacer |
A node that serves only to create a space |
| 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.BaseNode.InputAttribute |
|
| Editor.ShaderGraph.BaseNode.InputDefaultAttribute |
|
| Editor.ShaderGraph.BaseNode.OutputAttribute |
|
| Editor.ShaderGraph.BaseNode.EditorAttribute |
|
| Editor.ShaderGraph.BaseNode.RangeAttribute |
|
| 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.GraphCompiler.Error |
|
| Editor.ShaderGraph.GraphCompiler.ShaderStage |
|
| Editor.ShaderGraph.NodeResultType |
|
| Editor.ShaderGraph.NodeResult |
|
| Editor.ShaderGraph.NodeResult.Func |
|
| Editor.ShaderGraph.ShaderTemplate |
|
| Editor.ShaderGraph.DefaultEditor |
|
| Editor.ShaderGraph.FunctionResult |
Final result |
| Editor.ShaderGraph.FunctionOutput |
|
| Editor.ShaderGraph.FunctionOutput.PreviewType |
|
| 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.GraphView.SelectionBox |
|
| Editor.NodeEditor.FilterModifier |
|
| Editor.NodeEditor.FilterPart |
|
| Editor.NodeEditor.NodeQuery |
|
| Editor.NodeEditor.NodeQueryExtensions |
|
| Editor.NodeEditor.RerouteUI |
|
| Editor.NodeEditor.RerouteUI.Comment |
|
| 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.VertexInspector.MergeRange |
|
| 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.SoundFileCompileSettings.Settings |
|
| Editor.Inspectors.SoundFileCompileSettings.Settings.SamplingRate |
|
| Editor.Inspectors.TextureCompileSettings |
|
| Editor.Inspectors.TextureCompileSettings.Settings |
|
| 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.PhonemeItem.PhonemeDesc |
|
| Editor.SoundEditor.PhonemeItem.PhonemeCategory |
|
| Editor.SoundEditor.Window |
|
| Editor.RectEditor.SelectionOperation |
|
| Editor.RectEditor.Document |
|
| Editor.RectEditor.Document.Rectangle |
|
| Editor.RectEditor.MaterialReference |
|
| Editor.RectEditor.MaterialPicker |
|
| Editor.RectEditor.Properties |
|
| Editor.RectEditor.RectAssetData |
|
| Editor.RectEditor.RectAssetData.Properties |
|
| Editor.RectEditor.RectAssetData.Subrect |
|
| Editor.RectEditor.RectAssetData.SubrectSet |
|
| Editor.RectEditor.DragState |
|
| Editor.RectEditor.RectView |
|
| Editor.RectEditor.Window |
|
| Editor.ProjectSettingPages.CollisionMatrixWidget |
|
| Editor.ProjectSettingPages.CollisionMatrixWidget.LayerName |
|
| Editor.ProjectSettingPages.CollisionMatrixWidget.MatrixButton |
|
| 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.EditableCurve.Handle |
|
| Editor.GraphicsItems.EditableCurve.HandlePopup |
This would be a lot simpler if we just passed the handle to it, and let it fuck with it directly!! |
| Editor.GraphicsItems.EditableCurve.Tangent |
Represents entry/exit angle of the curve handle |
| Editor.GraphicsItems.RangePolygon |
|
| Editor.GraphicsItems.ChartBackground |
A generic chart background. Has axis down left and along bottom. |
| Editor.GraphicsItems.ChartBackground.AxisConfig |
|
| 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 |
|
