A tree node for use with Editor.AdvancedDropdownWidget. Items with children are categories; items without children are selectable leaves.

A popup wrapper around Editor.AdvancedDropdownWidget.

A generic sliding hierarchical selector widget. Build a tree of Editor.AdvancedDropdownItem and hand it to this widget.

The asset system, provides access to all the assets.

Handles asset tags.

A widget layout. You can think of it as an invisible box of rows or columns, each one containing a widget, useful for automatic positioning and scaling.

A simple button widget.

A generic checkbox widget.

Check state of a Editor.Checkbox.

For opening source code files in whatever code editor the user has selected.

A control widget is used to edit the value of a single SerializedProperty.

Identical to Menu except DeleteOnClose defaults to true. Can optionally be made searchable by setting Editor.ContextMenu.Searchable to true before opening.

Information about a Editor.Widgets context menu event.

A control widget is used to edit the value of a single SerializedProperty.

A popup dialog for creating models from mesh files (.fbx, .obj, .dmx). Lets you configure collision type and output path.

Popup dialog for combining multiple mesh files into a single .vmdl. Mesh files are grouped by their suffix: _lod/_hull/_col

TODO: Make this match whatever we do in game

Dev tools (devtools, F11) in an editor dock. In the editor they live here rather than in a window of their own: the dock draws the same panels on a Editor.PanelSurfaceWidget, and opening dev tools opens this dock. They count as open while the dock is on screen, so the data behind them is only collected while someone can see it.

A wrapper to more easily create dialog windows.

Marks a widget as a creatable dock on a DockWindow. Common targets include: Editor, Hammer

Container for docked widgets

A window that is built from docking windows.

Represents an asset being dragged into an editor window. Assets will either be sourced from a package (see Editor.DragAssetData.PackageIdent) or a local path (see Editor.DragAssetData.AssetPath). Instances of this type are accessed through Editor.DragData.Assets.

Contains drag and drop data for tool widgets. See Editor.Widget.DragEvent.

Used to tell the user what kind of action will happen during a drag and drop event on mouse release. In Windows, these actions will also display text near cursor to let the user know what will happen if they release their mouse button.

Base class for dropdown control widgets with multi-select support.

Used in conjunction with IAssetEditor to declare a window that can edit an asset type

A filesystem that can be accessed by the game.

Describes why a Editor.Widgets' keyboard focus has changed via Editor.Widget.OnFocus(Editor.FocusChangeReason) and Editor.Widget.OnBlur(Editor.FocusChangeReason) callbacks.

An editable text box with a button to browse for an arbitrary folder using OS file browser dialog.

A text entry with a browse button that opens the OS folder picker. Editor only - games don't get to poke around the filesystem.

Like a widget - but is drawn

Lets all native and managed tools know about any engine / game entities.

Registers a widget with the input system to use SDL and manages inputs and focus as it relates to the editor's game widget.

Opens an invisible popup above the game screen which allows you to left click once on the scene. This is great for things like selecting something from the game scene.

Information about a Editor.GraphicsItems mouse hover event.

Information about a Editor.GraphicsItems mouse click event.

A widget layout. You can think of it as an invisible box of rows or columns, each one containing a widget, useful for automatic positioning and scaling.

A helper class to store a list of strings, which can then be navigated around, saved, restored

Editor for hold type strings (e.g. Sandbox.BaseCombatWeapon.HoldType) - a combo pre-filled with the hold types the citizen animgraph understands, editable so graphs with their own options can use anything.

A material icon label

Represents a variable

When using Editor.InspectorAttribute with a type that inherits from InspectorWidget, when you inspect an object of that class, it will create an instance of the widget and display it in the inspector.

Information about a Editor.Widgets keyboard event.

A simple text label.

A single line text entry. See Editor.TextEdit for multi line version.

Splitter that can be linked to move alongside others

Generates face lipsync visemes from audio.

Represents an entity class used by the map editor

Represents a variable.

A class to CRUD json files. This should probably be a generic class since it seems like we might want to do this with stuff other than meta files. But there's no need for that right now, so lets leave it simple.

Shows the selected deformation's name above its icon buttons without an extra inspector row.

Edits the deformer's existing shape fields with room for sphere radius and center on separate rows. Other users of SceneVolume retain their usual inspector layout.

Information about a Editor.Widgets mouse event.

Drags dock panels between desktop windows with panel-drawn chrome.

An OS window whose entire contents are panel UI. It owns the window, its swap chain and the UI inside it. Its input comes straight from SDL and never touches the engine's input system - there's no widget toolkit involved anywhere. A popup is one that hangs off another, the way a menu does - see Editor.PanelWindow.Popup(Editor.PanelWindow,Vector2,System.Boolean). Editor only. A game has one window and draws its UI into that. The window itself is the engine's internal SurfaceWindow; this is the public face of it for tools, and lives in Sandbox.Tools so game code can't open windows.

A pixel map, or just a simple image.

A popup widget that automatically deletes itself once it stops being visible

Editor access to a project's compilers. These are internal on Sandbox.Project so game code never sees them - editor code reaches them through these extensions.

Elapsed time for one stage of a scene compile, including editor yields.

Measurements from a successful scene compile, excluding unchanged referenced assets.

A SceneEditorSession holds a Scene that is open in the editor. It creates a widget, has a selection and undo system.

Render a scene to a native widget. This replaces NativeRenderingWidget.

A widget that can scroll its Editor.ScrollArea.Canvas.

Scope of the shortcut. Requires focus at this level for the shortcut to be active. Defaults to Editor.ShortcutContext.WindowShortcut.

Shared dimensions and painting for single-value and interval sliders.

Sounds are compiled by the native sound compiler, but we get first look at the compile here. We read the lipsync visemes and subtitles authored in the sound editor from the sound's .meta and inject them into the compiled resource as custom blocks, then return false so the native compiler runs as usual - our blocks ride along into the final file. The engine reads them back out via Sandbox.SoundFile.Visemes and Sandbox.SoundFile.Subtitles.

Split frame, allows dragging to resize panels

Marks a method as a custom handler for stack trace lines matching a certain pattern. The method must take in a System.Text.RegularExpressions.Match parameter, and return a Editor.StackRow (or null).

Lays a transcript out over a sound as timed Sandbox.SubtitleTrack.Words. The sound editor uses this to bootstrap a subtitle track - the user types what's being said, we spread the words over the speech we know about (the viseme track if there is one, the whole clip otherwise), and they fine-tune the timing on the timeline.

Suspends updates in the widget for this using scope.

Recent projects for the Windows taskbar jump list - the menu you get right clicking the taskbar icon, like Visual Studio's recent solutions.

A multi-line text entry. See Editor.LineEdit for a single line version.

Provides information about currently resident textures on the GPU

A list of title bar buttons, at the top right of a window.

A button that shows as an icon and tries to keep itself square.

Renders basic stuff for tool views

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

Like a widget - but is drawn

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

A generic widget.

A single sliding panel with header, scroll area, and item list.

A category entry widget with a forward arrow.

A leaf item entry widget.

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

This is data that is saved in an asset's meta file under "publish" to configure its project for uploading.

Should target a static method like `public static Pixmap RenderThumbnail( Asset thumbnail )` where the method returns a thumbnail for that asset type. This kind of sucks I don't like it.

Passed parameters for the AssetPicker going from engine to addon code

A visually distinct button.

Import options, remembered between uses. Add a property here to add a setting to the dialog.

Description of a registered dock type.

Called every frame for tools

Events that happen within the map editor.

Event args for Editor.EditorEvent.ISceneView.ShowContextMenu(Editor.EditorEvent.ShowContextMenuEvent) events.

Called when the map view is right clicked, Editor.Menu is passed.

Called when the user selects / deselects any object in the map and is changed.

Public, token-free info about a third-party service account (eg Twitch) linked to the player. This is the menu-facing proxy for the backend's service link data.

Represents an open map document. A document has a tree of Editor.MapDoc.MapNode that represent the world.

MapEntity in Hammer is a type of Editor.MapDoc.MapNode that has a set of key/value pairs. The keyvalues represent the authoritative state of the entity. Entities may have helpers that enhance the presentation and sometimes modification of those keyvalues. The helpers may come and go; it should always be possible to recreate the helpers from the parent entity's keyvalues. Entities may also have zero or more Editor.MapDoc.MapMesh children.

A map node which has the sole purpose of grouping other map nodes together.

A map node which allows a target group and its children to be placed with a new position and orientation in the world without creating a new copy. Multiple MapInstance classes may reference the same target allowing it to be placed in multiple locations, but allowing any edits to be applied to all instances.

MapMesh is the Hammer map node which represents editable mesh geometry in a Hammer map. This is the map node that is created when using the hammer geometry editing tools.

One polygon of a Editor.MapDoc.MapMesh, in world space.

A common class used for all objects in the world object tree.

Path containing a bunch of Editor.MapDoc.MapPathNode

Nodes along a Editor.MapDoc.MapPath

An overlay which is rendered using a mesh generated by projecting faces onto surrounding geometry. Baked during map compile so that there is no runtime component. Also supports being limited to specific targets.

MapWorld is the root node of a Editor.MapDoc.MapDocument, however it can have multiple sub Editor.MapDoc.MapWorld of prefabs.

This is our CQHammerMainWnd

This is our CQHammerMainWnd

Source location for graphs created in a Hammer editor session.

Undo/redo history for the current active mapdoc

The Build Map dialog's presets. Matches BuildPresetList_t.

MapViews are owned by the MapViewMgr. They display the MapViewMgr's mapdoc. The MapView provides either a 2d or 3d view of the provided map doc. The rendering mode may be swapped between various 2d and 3d modes dynamically. In addition to basic display functionality the view also provides movement implementation for moving a camera within a 3d view or panning a 2d view.

Current selection set for the active map

Build primitives out of polygons.

A list of vertices and faces.

A list of indices indexing into the Editor.MeshEditor.PrimitiveBuilder.PolygonMesh.Vertices list.

A single file in the project revision manifest

A workshop item the files could go in

What a workshop item is, for checking it's the right one before publishing to it

Unique transitive assets, including ones already published. Selected roots are not counted.

Additional uncompressed bytes, estimated from existing compiler metadata.

Snapshot of publishing settings, including unsaved edits used by the settings preview.

Information about a widget drag and drop event.

Utility info for tools usage.

A system that aims to wrap the main reusable functionality of an Sandbox.Helpers.IUndoSystem.

Describes the path to a Sandbox.SerializedProperty from either a Sandbox.GameObject or Sandbox.Component.