SafeArchive.Extract stages into <folder>.building-<8 hex> and SafePaths.ReplaceDirectory sets the previous
folder aside as <folder>.trash-<8 hex>, both named by SafePaths.Sibling (they added a whole 32-digit GUID). Their
files must fit the 259 characters Unity can use on Windows (SafePaths.MaxPathLength; Unity is not long-path aware,
whatever the system setting): MCB downloads failed with “Could not find a part of the path” in ordinary project
folders.SafeArchive.RequireRoom and SafePaths.RequireLength: an archive whose files would not fit is refused before
anything is written, with a message saying how many characters shorter the project’s folder path must be. Callers
that know the files can check before downloading (MCB does).OrbitersMenuIcons: Orbiters’ default VRChat menu icons, written once as 64 × 64 PNGs into
Assets/Orbiters/Menu Icons/ (a white dot for toggles, a gauge for sliders, a folder for folders, an arrow for
Next pages). The toggles VrcFuryWriter makes, and the held props’ toggles, buttons, sliders and folders
(HeldPropRig: drawing pen, hand screen), get them.AvatarParameterBudget: BuildRemovedParameters is also asked about the avatar’s own expression parameters (with its
VRCAvatarDescriptor; a Full Controller’s global parameters left out there are left out too), and
BuildRemovedToggles tells which VRCFury Toggles a build leaves out. My Avatar uses both for items left out of the
upload. VrcFury.IsGlobalParameter reads a Full Controller’s global parameter rules.AnimatorControllerCopy.Tree: a new blend tree with another’s settings and children. Unity asserts when a blend tree
holding other trees is instantiated; the controller copy and My Avatar’s face tracking build copy trees this way.ClothingCoverage) counts underwear, swimwear and one-piece garments as body clothing by name
(jockstrap, briefs, boxers, thong, bra, speedo, trunks, lingerie, bikini, swimsuit, leotard, bodysuit, onesie,
jumpsuit): underwear is fitted first, as the innermost layer, and one-pieces with shirts and trousers.OrbitCamera and OffscreenPreview: the 3D previews’ camera (turn, move and zoom with the pointer, values gliding to
their targets, view presets with LookFrom) and their render into UI Toolkit textures, which always restores the
editor’s lighting after PreviewRenderUtility.Render. MCB’s version comparison and ReFit’s stage use them.HandScreenInstaller.CreatePrefab): the video the world is playing (its _Udon_VideoTex global
texture, shared by ProTV 3 and other players), letterboxed on a 16:9 screen with a handle on each side. One hand
carries it, both hands stretch it: each handle follows its own wrist and constraints work the screen’s corners out
from the two handles (no animator maths). Let go, it stays in the world. Only its owner moves it; 4 bits of
parameters; needs VRCFury. Without a video in the world it shows a quiet play sign, as on its back. The prefab
carries its own shader and no Orbiters script (Toolkit releases ship without .meta files, so their GUIDs differ in
every project): a gallery copy works wherever it is installed, and Toolkit finds it by its left handle’s grab.UnityPackageReader: the one .unitypackage reader of every Orbiters tool. It streams the archive once, checking its
structure as UnityPackageIndex did (tar checksums, record names, sizes, the expanded size and entry count, metadata
GUIDs, one GUID per path), and hands each record to the caller. UnityPackageIndex, UnityPackageFiles.AssetHashes
and CopyEntries (which now check the archive too, and copy long-name records as stored), MCB’s source FBX extraction
and the Unity Package Manager all read through it. Options.FirstLinePathname (and UnityPackageIndex.Read’s
firstLinePathname) reads a pathname’s first line, as Unity’s importer does, for tools that only read a package.
UnityPackageIndex.ExpandedBytes gives the archive’s decompressed size: a package nested in a ZIP is checked in one
pass instead of being decompressed twice.OrbitersAccountElement takes confirmLogout to ask before signing out of every tool (MCB’s account row uses it).127.0.0.1:4100, the address the tools use.HeldPropRig: the drawing pen’s grab rig (PhysBone pickup, wrist hold measured where it was grabbed, world-fixed
drop) and controller pieces, shared by the pen and the hand screen.OrbitersDrawingPen marker stays only so older pens load
without a missing script): a gallery pen is found by its grab and fitted in any project, where it used to arrive with
a missing script and never follow the hands (Toolkit’s script GUIDs differ in every project). DrawingPenInstaller.Bind
takes the pen’s transform; Find is replaced by the internal FindAll.AttachmentHooks.Register(hook, claims) and AttachmentHooks.Fits: a package of a prop a hook fits declares the
Toolkit version it needs (My Avatar 0.9.7’s gallery packager), even when it refers to none of Toolkit’s files.AvatarParameterBudget counts a face tracking template apart: objects an AvatarParameterBudget.FaceTrackingOwners hook claims (My Avatar’s) have their parameters in ParameterBudget.FaceTrackingBits, taken out of AvatarBits and, when the custom base also owns them, out of CustomBaseBits. BudgetCount gets a FaceTracking share.AnimatorControllerCopy: a deep copy of an animator controller in memory (layers, state machines, states,
transitions, behaviours, blend trees and clips, with an optional clip rewrite), freed with Destroy().BlendShapeLinkEngine also applies links to in-memory controllers on the descriptor (build previews such as My
Avatar’s face tracking test), and only saves assets when an asset controller changed.OrbitersVectorLogo draws relative SVG path commands and H, V and S, reads the viewBox (also one not starting at 0)
and fills each path with its own fill colour (white, or Fill, without one).VrcAvatarCard and VrcCardStage: VRChat’s in-game avatar card (badges, two-line name, author) in its menu
backdrop, moved here from My Avatar so other tools show the same card (Unit Git’s upload releases). The host sets the
platforms, the performance warning and the author; VrcCardStage.SetAmbient lights the backdrop with the thumbnail’s
colours. VrcLinks.AvatarPage gives an avatar’s page on vrchat.com.RefitRecords.Discard takes a refit back for every tool: it removes the record and tells the custom base provider
(ICustomBaseFits, implemented by MCB) to forget the fit it saved for the version. RefitRunner.IsRunning / Hold
tell whether a refit is at work on an avatar. The temporary original-base import is shared by reference count.orbiters_editor_window (MCP) captures everything in the background: inactive docked tabs, windows that are not open
(open_if_missing) and long windows (width, height, scroll_to) are rendered in a hidden copy outside every
display, and inspect captures any object’s Inspector without selecting it. Unity is never brought forward; the
focus option is gone.MaterialSides: whether a material shows the back of its faces and whether the mesh part it covers needs that (open
surfaces such as fur cards and feathers). MaterialSurfaceMaps.OriginalShader, StrippedTexture and EnableEmission
for locked (optimized) materials and emission maps.CustomBaseFootprint, e.g. MCB’s logic).BoneFrameRetarget: animations written for a skeleton whose bones rest in other orientations (a model re-exported with
other bone rolls) turn each bone the same way from its rest pose on the current skeleton; clips already made for it
stay. AttachmentAnimationBuild.IsBuildData tells build copies (in memory, the build cache, VRCFury’s temporary
builds) from source assets.OrbitersAboutWindow: the About window of the Orbiters tools (logo, version, license, then each third-party project
with its license, read from the tool’s notices file). MCB and My Avatar use it. It recognises the SIL Open Font License (OFL) and keeps
a notice’s list items on their own lines.PhotoshootPanel.SetLead, e.g. My Avatar’s card).PhotoshootOptions.TextFonts) gets a line of text on the thumbnail
(PhotoshootState.Text), edited on its previews (PhotoshootTextLayer: move, resize, write in place, while the rest
of the preview still frames the avatar) and in a Text tab, and drawn into captured thumbnails by the same renderer
that draws the preview (PhotoshootTextRenderer: glyphs from the font, then outline, shadow or glow).PhotoshootLibrary).AvatarParameterBudget.BuildRemovedParameters: a build step that leaves parameters of a VRCFury component out (My
Avatar’s face tracking features others don’t see) makes every budget count them as uploaded.Assets/Animations/Imported, or a folder you choose), and save their animations as standalone .anim clips you can use
anywhere: pick the clips and their names, keep or force Loop Time, and replace earlier extractions in place so
controllers using them keep working (or keep both, or skip). Humanoid curves, events and clip settings come along.outline-width property on every import.OrbitSphere, also for other tools). The avatar turns around whichever of its hips, chest and head is nearest the middle of the view, and the camera is framed on the unturned avatar, so turning no longer slides it around or changes the zoom. Eyes are the humanoid eye bones, else the ones set in the VRChat Avatar Descriptor’s eye look (PhotoshootLook.EyeFallback).AvatarBudget: an avatar’s parameters, bones, PhysBones and contacts against VRChat’s PC limits, read from the SDK’s performance levels, split between the avatar and its custom base. Custom base providers describe what they add and what their build changes with CustomBaseFootprint. XRay Gizmos shows it over the Scene view.AttachmentAnimationBuild.Keep makes objects created during a build assets until it is released; Moved keeps the animations of bones a tool moved before the build.BlendShapePruning: the blendshapes a built avatar uses on a renderer (its controllers’ animations, visemes, jaw flap, eyelids, standard MMD morphs on Body), and a copy of the mesh without the others, baked at their weight..unitypackage hashing, copying and import previews, content trust prompts, and resumable transfers checked against their SHA-256.DrawingPenInstaller.CreatePrefab) that fits itself to the avatar it is attached to; AttachmentHooks lets props adapt when a tool attaches them.Unity 2022.3 editor utilities for mirror posing and optional AI integration. Mirror posing works without MCP. The screenshot adapter compiles separately when MCP for Unity 9.7.1 or newer is installed; this package does not install the server.
From 0.2.1, MCB and My Avatar share account storage and Magic Sync through
AuthenticationService, environment/API URL handling through
OrbitersEnvironment, and authenticated requests through OrbitersApi.
The per-environment account in the Unity preferences folder is the common store, readable by the signed-in OS user only
(DPAPI on Windows, a chmod 600 file elsewhere); disconnecting in either tool disconnects the shared account. A browser
login saves only if it is still the newest, uncancelled one and the tools are still on the server it started on.
OrbitersAccountView, OrbitersSignInElement and OrbitersAccountElement provide
common account controls. OrbitersGlow and OrbitersGlowSurfaceElement render
the animated background; OrbitersVectorLogo draws SVG paths (M, L, H, V, C, S, Z, absolute or relative) in their own fill colours.
These editor-guarded services live in Orbiters.Toolkit, allowing components with
editor-only helpers to reference them. Player builds contain none of this editor
logic. Orbiters.Toolkit.Editor continues to own posing and screenshot utilities.
The package also depends on Unity’s Newtonsoft JSON package.
Orbiters.Toolkit.Editor.Meshes compares versions of a model without importing them: FbxReader reads a binary FBX
(meshes placed in the file root’s space with Unity’s axes and scale, blendshape signatures, bones, material names; with
FbxReadOptions.Render UV-split vertices and one submesh per material slot, with FbxReadOptions.ShapeOffsets each
blendshape’s offsets). MeshComparison measures how far each vertex moved, index by index or to the other version’s
surface when the topology changed, and describes parts as moved, reshaped, re-materialed, added or removed. Unit Git’s 3D
view and MCB’s version differences use it.
Tools register opt-in features with OrbitersFeatures.Register (key, product, label,
description, FeatureStage, default; stored per user in EditorPrefs). Orbiters settings
lists them by product with a StageBadge (beta, alpha, experimental) and a switch.
Orbiters.Toolkit.Editor.Vpm (compiled when the VRChat Package Resolver is present) reads a
package’s VPM dependencies from its package.json: vpmDependencies plus an "orbiters" block
with repositories, dependencyDisplayNames and optionalVpmDependencies (displayName,
version, reason). VpmDependencies.For("<package>") reports status and installs, adding
missing repositories first; DependencyPrompt shows “this feature needs X” with an Install
button and hides once X is installed.
In XRay Gizmos, select an avatar or one of its bones and enable Mirror in the Scene-view toolbar or the XRay Gizmos window. Rotate or move one paired bone in the Scene view or Inspector; Toolkit mirrors the edited channels to its partner across the avatar root’s local X plane. The mirror remains scoped to that rig when selection changes. Toggle it off and on with another avatar selected to switch. The window reports the active rig, pair count and selected partner.
Humanoid bone mappings take priority. Generic rigs use matching hierarchy paths
whose names differ only by a side word (Left/Right in any case, or a separate
L/R: upper_arm.L, J_Bip_L_Hand, LeftArm, mixamorig:LeftHand), see
BoneNames.Mirror. Ambiguous paths, unpaired bones and center bones are skipped.
The mesh bind pose supplies the reference frames, accounting for different local bone axes. Pairs missing complete bind-pose data use the pose at enable time as a relative reference, shown in the status. Enabling Mirror never changes the pose. Editing one side subsequently replaces the opposite side’s edited channels. If both partners are edited in the same operation, both explicit edits are kept. Mirrored changes join the source Undo operation and record prefab overrides.
Mirror is an edit-mode tool, pauses during animation preview/recording, and turns off on play-mode changes, script reload or changes to the captured bone hierarchy. It does not mirror scale, solve IK, bake animation or continuously drive bones. Bone and ancestor scales must be positive and uniform. Turn Mirror off before changing reference scale or rig structure, then enable it again.
Other editor tools can call Orbiters.Toolkit.Editor.Posing.MirrorPoseService
(Enable(root, renderer), Disable(), GetPartner(bone), Changed).
Its assembly is Orbiters.Toolkit.Editor; it has no XRayGizmos or MCP dependency.
Orbiters.Toolkit.Armature (runtime assembly Orbiters.Toolkit) matches clothing and accessory armatures onto an
avatar. BoneNames reads bone names as words: Normalize, Side, Mirror, IsArmatureContainer, IsEnd and
TryInferHumanoid, which knows Unity/VRChat, Mixamo, Blender/Rigify, VRoid, Rexouium, Biped and Unreal names,
including fingers, eyes and jaw, and leaves props (ArmBand.L, Chest Pin), Blender copies (Hips.001) and _end
leaves alone. AvatarBoneIndex.Build indexes an avatar’s bones by name and humanoid role; BoneMatcher.MatchHierarchy
matches parents first by exact name, name without the clothing’s affix (DetectAffixes: Hips_Shirt), humanoid role,
then contained name, and reports ambiguous matches with their alternatives. ArmatureRest gives bind-pose rest frames.
Orbiters.Toolkit.Meshes.BlendShapeEvaluation.Add applies a blendshape to mesh data the way Unity’s skinning does
(checked against BakeMesh), clamped or not as the project’s “Clamp BlendShapes” Player Setting (ClampWeights) says, so
X-Ray and ReFit measure the shape the user sees.
Orbiters.Toolkit.Editor.VRChat.Attachments attaches a clothing or accessory object placed under an avatar root, with
Undo and without changing the avatar. AttachmentPlanner.Analyze(accessory, avatarRoot) returns an AttachmentPlan:
AttachmentPlan.Ambiguous keeps it with its candidates (named in a note) for AI or the user.Empty parent, position and rotation constraints (Unity or VRChat) named after avatar bones (Head, Left wrist) get
that bone as source, keeping where the object stands. Unity ones become VRChat constraints, except those an animation of
the avatar drives: the SDK could only rebind those animations by editing the clip assets in place, so they stay working
Unity constraints. On an object the tool did not create (AttachmentOptions.Created = false) the user’s Unity constraints
stay in the scene and are converted on the build copy only (claimed through the SDK’s IsUnityConstraintAutoConverted, so
its build panel does not flag them). Empty aim, look-at and scale constraints, object names that give instructions ((open me),
Put me in armature), unknown scripts, missing scripts and bones no avatar bone explains become SetupNotes.
AttachmentInstaller.Install(plan, options) adds OrbitersAttachment (runtime assembly Orbiters.Toolkit.VRChat,
IEditorOnly) to the accessory root, the VRCFury Armature Link when exact, a saved VRCFury toggle under
Accessories/<name> when the accessory has no toggle or controller of its own, and copies the body’s blendshape
weights to same-named shapes. Retarget, Link (AI answers), Remove and Installed complete it. Remove deletes an
object the tool created; from one it did not create, it removes what it added and puts back what it changed (wired
constraints, the place it was moved to, blendshape weights copied from the body), recorded on the attachment, where
the user did not change it since. VRCFury components
are created through VRCFury’s public API by the optional Orbiters.Toolkit.Editor.VRCFury assembly; VrcFury reads
VRCFury components (including links saved by older VRCFury versions) without referencing it.
At build (AttachmentBuild, VRChat preprocess callbacks): at -10100, just before VRCFury, linked bones are placed at
their rest offset from their avatar bone (from both meshes’ bind poses, so the scene pose does not matter) and parented
props stay where they are. Both are then moved under their bone, without adding constraints. When VRCFury builds the
avatar (it has a VRCFury component), VRCFury keeps the accessory’s animations working with the paths it recorded
earlier. Otherwise (AttachmentAnimationBuild) each one goes under an offset frame on its bone, the build copy’s
animator controllers are copied and their paths remapped (with proxy frames keeping animated former parents’ motion and
visibility), and the copies live in Assets/OrbitersToolkitBuildCache until the build ends; data left by an
interrupted build is deleted on the next script reload. At -8900
animations of body blendshapes also drive the same-named accessory shapes (BlendShapeSync, including meshes that moved
out with their bone; shapes a refit already links are left to it), and the components are removed. The scene is never
changed by a build.
AttachmentFollow.Links(avatarRoot) lists, for every accessory, which transform follows which avatar bone and at which
offset: My Avatar attachments, VRCFury Armature Links, and the bone matcher for clothing nothing links. The build and
the posing preview share it. Armature Links follow VRCFury’s own rules: the first target that resolves on the avatar
(humanoid bone, object or avatar root, then its offset path), and position, rotation and scale aligned independently.
OrbitersSurfaceFollow (runtime assembly Orbiters.Toolkit.VRChat, IEditorOnly, menu Orbiters › Follow Body
Blendshapes (beta)) keeps rigid accessories on the skin when body blendshapes change: a piercing on a chest that grows
with “Muscles” moves and tilts with it. On an object it covers that object’s meshes; on the avatar root in Small
Accessories mode, every small rigid accessory close to the skin (size and gap are settings). Rigid means a plain mesh
or a mesh on one or two bones; clothing skinned to more bones bends with the body on its own and is left alone.
SurfaceFollow (editor VRChat assembly) anchors each accessory to the closest triangle of the body at its current pose
and weights. For every body blendshape, the movement and tilt of that triangle (offsets through the same bone blend as
skinning, so exact at the scene pose) become a blendshape of the accessory with the same name; shapes that move the skin
there by less than 0.2 mm and 0.3° are left out. At build, after VRCFury and MCB’s links (-8950), plain meshes become
single-bone skinned meshes (except renderers an animation drives, which stay as they are), the accessory’s rest shape is
set so it stays where it is at the body’s current weights, and BlendShapeSync copies the body’s weights and animations
to the new shapes. The scene is not changed. The component’s inspector has Check, a dry run listing what will follow
and which blendshapes move it. ReFit (Keep rigid pieces on the body) and MCB (Keep Small Accessories On The Body)
add it for you.
Clothing made for an avatar’s original base does not follow the blendshapes a custom base adds (MCB versions: muscles,
flexing…). The Orbiters tools share one refit layer for it; ReFit (orbiters.refit) computes the geometry.
Orbiters.Toolkit.Editor.Refit): RefitEngine.Current is the installed engine (IRefitEngine); ReFit
registers itself when its editor code loads, so a tool never references it and only needs it once the user asks for a
refit. A RefitJob is one mesh: Fit fits it from the original base body to this body and adds the body’s shapes,
Shapes only adds the shapes to a mesh that already fits. RefitPreferences.Tightness (0 loose … 1 tight, saved in
ProjectSettings/OrbitersRefit.json) is shared by MCB’s ReFit panel and My Avatar.CustomBases.Describe(avatarRoot) asks the registered ICustomBaseProviders (MCB registers one) for
the avatar’s custom base: its body, its blendshapes (the declared ones on the body, then every body shape containing
“flex”) and, when the provider can, the original base to fit from (ResolveOriginal, disposable: it may be a temporary
import). CustomBaseFingerprint recognises a custom base without a provider: the SHA-256 of the body’s model file is
looked up on the Orbiters server (POST mcb/custom-bases/identify), cached in Library/Orbiters. It cannot fit from
the original. CustomBaseDetection.DetectAsync(avatarRoot) does both once per avatar in the background, then measures
where each custom shape moves the body (BodyShapeMap, read a few shapes per editor update); it starts over when a
provider calls CustomBases.NotifyChanged (a version applied) or the body mesh changes.FitCheck.CheckAsync(item, state) says whether an item needs anything: only its skinned meshes lying
within 5 cm of skin a custom shape moves count (RefitRelevance, on a worker thread), so rigid pieces and far away
items are left alone. Shapes a mesh already has, under the same or a normalized name, are its creator’s and are never
replaced. FitAdvice: AddShapes (it fits, or its creator adapted part of it), AskFit (unknown: ask), Refit
(OrbitersFitInfo says it was made for the original base). An item’s creator adds Orbiters › Fit Info
(OrbitersFitInfo) to say which base and custom base it was made for, and which body shapes it must never get.RefitRunner.Run/RunAsync(RefitBatch) refits meshes and records each on its renderer
(OrbitersRefit, runtime Orbiters.Toolkit.VRChat, IEditorOnly): the renderer’s state before (mesh, bones, pose,
weights), the generated mesh and the body shape each generated shape follows. Refitting a refitted mesh starts again
from its original instead of stacking; adding shapes to it keeps its fit; a failed refit keeps the previous one. The
same inputs (mesh, pose, body and its weights, the original body’s pose and weights when fitting from it, shapes,
tightness) reuse an earlier result from Assets/Orbiters/ReFit/Cache, with its warnings (a rough fit stays rough). RefitRecords restores (Remove, RemoveAll), lists and syncs them; the record’s
inspector shows what follows the body and restores the original mesh.RefitBuild takes the applied records from the build copy at -10110, before attachments and VRCFury move
or merge meshes, and at -8960 (after VRCFury and MCB’s correctives, before Follow Body Blendshapes and attachments)
makes every animation of a body shape also drive its generated shapes, whatever animates it (exact curve copies,
BlendShapeSync). A generated shape removed during the build while its body shape is animated fails the build.
Without VRCFury, the controllers are copied as for attachments. Attachments leave the shapes a refit links alone.RefitGhost.Show(original, originalBody, avatarBody) shows the original base see-through over the body, to line
clothing up with it before a Fit; RefitCandidates lists the meshes a refit can adapt (never editor helpers such as
X-Ray gizmos).Orbiters.Toolkit.Editor.VRChat.Posing.AccessoryPoseSync (Enable(avatarRoot), Disable(), Sync(), Find,
Accessories, Changed) keeps accessories in the avatar’s pose as they will be attached once built, including props on
one bone. It is a preview: accessories go back where they were when it is switched off, before their scene is saved, on
script reload and on entering Play Mode. Bones driven by constraints are left to them; accessories Modular Avatar
attaches are shown by name match.
Open Tools > Orbiters > Toolkit, select Codex and/or Claude Code, and click Install / update AI integration. This adds the bundled screenshot skill to this Unity project:
.agents/skills/orbiters-toolkit/SKILL.md.claude/skills/orbiters-toolkit/SKILL.mdThe window reports installation status for each client. It does not configure MCP connections or personal settings. Start a new chat or reload skills if the client has not discovered the new instructions. Updates replace only toolkit-installed, unedited copies; custom edits are preserved and reported. A small ownership receipt is stored beside each installed skill. Existing identical skills need no rewrite.
Repository: https://github.com/Orbiters-cc/Toolkit
Build Release uses the same workflow as ReFit. It packages the editor tools and
bundled AI skill, validates the archive, and publishes the ZIP and package.json.
The repository variable PACKAGE_NAME is Toolkit. Push a new unused
package.json version to master for an automatic release, or run the workflow
manually. The first release is 0.1.0.
Call execute_custom_tool with tool_name: "orbiters_editor_window".
List open windows:
{ "action": "list" }Capture the existing ReFit window:
{
"action": "capture",
"window_type": "Orbiters.ReFit.Editor.ReFitWizard",
"max_resolution": 0
}Use window_id from the list instead of window_type to distinguish multiple
instances. Everything happens in the background: Unity is never brought forward and
the user’s layout, tabs, scroll positions, selection and focus are left alone. The
tool does not click any controls, change the scene, or capture pixels from the desktop.
"open_if_missing": true with an
exact window_type), or a capture with width, height (points, up to 8000) or
scroll_to is rendered in a hidden copy: shown without focus outside every display,
with the original window’s serialized state, and closed after the capture
(captureMode: "hidden_copy_framebuffer"). Opening a window type uses only its
CreateInstance; windows that need a menu setup routine may show their empty state.scroll_to scrolls the hidden copy so the first element whose name, USS class or
text matches is at the top.delay_ms (0..8000) waits that much longer before the capture: an animation settled,
or a state reached a moment after the window opens."inspect": "<instance ID | Root/Child | Scene:Root/Child | Assets/... path>"
captures a hidden Inspector locked on that object, without selecting it:{ "action": "capture", "inspect": "Rexouium1.6 Default Setup", "height": 1400, "scroll_to": "Face tracking" }The server polls pending captures automatically. Clients without polling support
can call { "action": "status", "job_id": "<returned job_id>" }. Jobs are
in-memory and expire on domain reload; request a new capture after a reload.
Only one capture runs at a time; up to 16 recent results are retained.
The completed response includes fullPath, output/source dimensions, scale,
window identity, Unity version and project path. Open fullPath with the client’s
image viewer to inspect the PNG. Files use unique names under
Library/OrbitersToolkit/Screenshots/; they are not imported as Unity assets and
are removed if the project’s Library is cleared. max_resolution accepts 0 for
native pixels or 64–8192 for a downscaled image.
The capture is the window’s rendered content, not its operating-system title bar
or other popup windows. It uses Unity’s internal GUIView.GrabPixels API and
fails explicitly if that API is unavailable. A visible graphical editor is
required; headless, minimized and hidden-window rendering are not guaranteed.
Capture failure, closed windows and inactive docked tabs produce errors. Inspect the
returned image before treating a successful pixel read as visual verification.
After importing this package, allow compilation and MCP tool discovery to finish. If the tool list is stale, rescan tools in MCP for Unity or reconnect the MCP client.
orbiters.toolkit
Undefined
0.3.21
2022.3 or later
No dependencies
No legacy packages
Undefined