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

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.

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 Editor.PopupWindow is one that hangs off another, the way a menu does. Editor only. A game has one window and draws its UI into that.

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.

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.

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.

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

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

The result of an MCP tool call - one or more content blocks the agent reads. Tools can return plain values and get shaped into a single block automatically, but returning one of these gives full control, like pairing a screenshot with a caption.

A Model Context Protocol server embedded in the editor process, letting AI agents like Claude Code drive the editor. Speaks the streamable HTTP transport (plain JSON responses, no server initiated streams). Binds loopback only and dies with the editor - it must never be reachable from beyond this machine.

Shorthand variants of Editor.Mcp.McpToolAttribute with hints baked in.

Expose a static method as an MCP tool, callable by AI agents connected to the editor's MCP server. The method name (converted to snake_case) becomes the tool name unless one is given here, and the XML summary becomes the tool description the agent reads. Parameters become the tool's input schema - describe them with [Description]. Tools are invoked on the main thread and can return a Task to be async. Return values get serialized to json for the agent - return a Sandbox.Bitmap to send an image, or an Editor.Mcp.McpResult to compose text and images yourself. Agents find tools through search_tools and run them through call_tool - so the name and description are what make a tool discoverable.

Behaviour hints for Editor.Mcp.McpToolAttribute tools.

Groups a class of Editor.Mcp.McpToolAttribute tools into a named toolset, which agents browse with list_toolsets and describe_toolset. Without this a class's tools still group under a name derived from the class name - the attribute exists to pick that name deliberately and describe what the group is for.

An MCP tool that only reads - never changes project, scene or editor state. Clients can run these without asking the user's permission.

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

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.