docs(model): document the scene clock and scene timers

feat(model): the scene clock, GetSceneTime and scene timers
A ModelScene's M2 scene already keeps a clock: uint32 milliseconds at scene +0x0C, which SetTime (0x00707490) stores and M2SceneAdvance (0x007074B0) moves forward. The Model frame's update (slot 14, 0x0076D7F0) advances it by the truncated milliseconds of each frame. SetPaused already skips that advance, and a hidden frame does not update, so this is the clock every actor animates by, and it stands still exactly when they do. - scene:GetSceneTime() returns the seconds that clock has run since the frame was made. OnFrameUpdate reads +0x0C before and after the base update and adds the uint32 difference, so the sum starts at 0 and never wraps. OFF_M2SCENE_TIME added to Offsets.h. - scene:After / NewTimer / NewTicker are C_Timer's contract on that clock. They share C_Timer's queue, cancel handles and registry callbacks: each entry now has an owner (null for C_Timer). The scene fires its own entries from OnFrameUpdate right after the clock moves, before the actors update. Its destructor drops them (CancelOwned). C_Timer's WorldTick fires only owner-null entries, and its next- deadline early-out now covers only those. The argument checks of the three C_Timer functions moved into the shared Time::Timer::Script. - SetPaused's descriptor is unchanged; GetSceneTime and the three timer methods have descriptors marked as ClassicAPI extensions.
2026-11-10 20:07:37 +00:00 · 2026-11-10 13:55:11 -06:00 · 2026-11-10 13:53:40 -06:00 · 2026-11-10 12:37:21 -06:00 · 2026-11-10 12:37:20 -06:00 · 2026-11-10 12:27:43 -06:00
120 changed files with 21425 additions and 1001 deletions
@@ -22,6 +22,7 @@ reference is in **[docs/API.md](docs/API.md)**.
 | Inline textures | Draws inline texture markup (`\|T…\|t`) and atlas markup (`\|A…\|a`) as icons in FontStrings, chat, and tooltips. This covers item and spell icons, raid-target markers, and the coin icons in money strings. `GetStringWidth` and `GetStringHeight` count the icons, so measured width and text wrapping stay correct. Done in pure C++ by hooking the engine's text pipeline — no addon. |
 | [Soft targeting](docs/API.md#soft-interact-softinteract--anyinteract) | The Interact Key and soft targets. Bind **Interact With Target** to a key to interact with the nearest NPC, corpse, mailbox, chest or gathering node in front of you. The [`softenemy` and `softfriend`](docs/API.md#soft-enemy-and-soft-friend-softenemy--softfriend--anyenemy--anyfriend) tokens point at the nearest enemy and friendly unit without a change of target. With no target, harmful spells go to `softenemy` and helpful spells go to `softfriend`. `PLAYER_SOFT_*_CHANGED` events fire when the units change. |
 | [Animations](docs/API.md#animation) | Animation groups on frames, textures and font strings, made in Lua or XML: `CreateAnimationGroup`, looping, smoothing, scripts and templates, with `Alpha`, `Translation`, `Scale`, `Rotation` and `Path` applied. |
+| [Model scenes](docs/API.md#modelscene) | The `ModelScene` frame type shows many models in one 3D scene, with its own camera, light and fog. Each model is an actor that you place, turn, scale and animate. An actor shows a creature display, a model file or a copy of a unit. It can also seat a rider, show spell visual kits and pause on one frame. A scene can show a WMO, for example a dungeon, around the actors, with its props and their sounds. An actor can move on the WMO as a character moves in the world: it runs, jumps, falls, swims and walks to a point. You hear the sounds of a scene from its camera, or from an actor. A follow camera follows an actor as the camera of the world follows your character, and stops in front of walls. |
 | Tooltip line cap | Removes `GameTooltip`'s 30-line limit for every `GameTooltipTemplate` frame (`GameTooltip`, `ShoppingTooltip1/2`, `ItemRefTooltip`, AtlasLoot, …). A tooltip adds a new line pair when it needs one, so long tooltips and comparison blocks (for example, pfUI's eqcompare) keep all their lines. |
 | [XML attributes](docs/API.md#parentkey-in-xml) | More XML attributes work: `parentKey="Name"` makes `parent.Name` point to a frame, texture or font string, `<OnLoad function="Name"/>` uses a global function as a script handler, `<OnLoad method="Name"/>` uses the frame's own function, `mixin="A, B"` copies mixins onto the object, `<KeyValues>` sets fields on the object, a button's `<NormalFont style="..."/>` sets its font, and `inherits="A, B"` applies more than one template. `parentArray="Name"` adds the object to a list on its parent. An `<Anchor>` takes `x` and `y` offsets and `relativeKey="$parent.Key"`. `<OnEnter inherit="prepend">` runs the template's handler and then its own, and `inherit="append"` runs them in the other order. A frame with `intrinsic="true"` makes a new frame type. Frames take `scale`, `registerForDrag`, `clipChildren`, `useParentLevel`, `dontSavePosition`, `propagateKeyboardInput`, `propagateMouseInput`, `enableMouseClicks`, `enableMouseMotion` and `motionScriptsWhileDisabled`, and buttons take `registerForClicks`. Textures take `alpha`, `atlas`, `useAtlasSize`, `mask`, `desaturated`, `rotation`, `horizTile`, `vertTile`, `hWrapMode` and `vWrapMode`. Font strings take `alpha`, `wordwrap`, `indented`, `degrees` and `radians`. Status bars take `reverseFill`, `rotatesTexture` and `fillStyle`, and edit boxes take `countInvisibleLetters`. |
 | [Macro conditions](docs/API.md#more-commands-with-conditions) | `[conditions]` and `@unit` work on 38 slash commands, from `/cast` and `/use` to `/target`, `/follow`, `/cancelaura` and the `/pet` family. With `/cast [@mouseover,harm][] Fireball`, the spell goes to the mouseover unit. With no mouseover unit, it goes to your target. `@cursor` places a ground-target spell or item under the mouse and `@player` places it at your feet. A character name works where a unit token does (`[target=Feral]`). Addons read the same rules through `SecureCmdOptionParse`. |
@@ -88,6 +89,8 @@ In the Frame rows, a name that starts with `:` is a method of the widget that th
 | [Frame: StatusBar](docs/API.md#statusbarsetreversefillisreversefill--statusbargetreversefill) | `:SetReverseFill` / `:GetReverseFill`, `:SetRotatesTexture` / `:GetRotatesTexture`, `:SetFillStyle` / `:GetFillStyle`, `:SetColorFill`, `:SetStatusBarDesaturated` / `:IsStatusBarDesaturated`, `:SetStatusBarDesaturation` / `:GetStatusBarDesaturation`, `:SetTimerDuration` / `:GetTimerDuration`, `:SetValue` / `:SetMinMaxValues` with `interpolation`, `:GetInterpolatedValue`, `:IsInterpolating`, `:SetToTargetValue` |
 | [Frame: Slider](docs/API.md#sliderenable--sliderdisable--sliderisenabled) | `:Enable` / `:Disable` / `:IsEnabled` |
 | [Frame: Cooldown](docs/API.md#createframecooldown--name-parent-template) | `CreateFrame("Cooldown")`, `:SetCooldown`, `:SetCooldownDuration`, `:SetCooldownFromExpirationTime`, `:Clear`, `:GetCooldownTimes`, `:GetCooldownDuration`, `:GetCooldownDisplayDuration`, `:Pause` / `:Resume`, `:SetPaused` / `:IsPaused`, `:SetReverse` / `:GetReverse`, `:SetDrawEdge` / `:GetDrawEdge`, `:SetDrawSwipe` / `:GetDrawSwipe`, `:SetDrawBling` / `:GetDrawBling`, `:SetSwipeColor`, `:SetEdgeColor`, `:SetSwipeTexture`, `:SetEdgeTexture`, `:SetBlingTexture`, `:SetRotation` / `:GetRotation`, `:SetHideCountdownNumbers` / `:GetHideCountdownNumbers`, `:GetCountdownFontString`, `:SetCountdownAbbrevThreshold` / `:GetCountdownAbbrevThreshold`, `:SetCountdownMillisecondsThreshold` / `:GetCountdownMillisecondsThreshold`, `:SetMinimumCountdownDuration` / `:GetMinimumCountdownDuration`, `OnCooldownDone`, `CooldownFrame_Set`, `CooldownFrame_Clear`, `CooldownFrame_SetDisplayAsPercentage` |
+| [Frame: ModelScene](docs/API.md#modelscene) | `CreateFrame("ModelScene")`, `<ModelScene>` (`drawLayer`, `fogNear`, `fogFar`, `<FogColor>`, `<ViewInsets>`), `:CreateActor`, `:GetNumActors`, `:GetActorAtIndex`, `:SetCameraPosition` / `:GetCameraPosition`, `:SetCameraOrientationByYawPitchRoll`, `:SetCameraOrientationByAxisVectors`, `:GetCameraForward`, `:GetCameraRight`, `:GetCameraUp`, `:SetCameraFieldOfView` / `:GetCameraFieldOfView`, `:SetCameraNearClip` / `:GetCameraNearClip`, `:SetCameraFarClip` / `:GetCameraFarClip`, `:SetViewInsets` / `:GetViewInsets`, `:SetViewTranslation` / `:GetViewTranslation`, `:Project3DPointTo2D`, `"FollowCamera"` (`:SetFollowActor` / `:GetFollowActor`), `:SetLightType` / `:GetLightType`, `:SetLightVisible` / `:IsLightVisible`, `:SetLightDirection` / `:GetLightDirection`, `:SetLightPosition` / `:GetLightPosition`, `:SetLightAmbientColor` / `:GetLightAmbientColor`, `:SetLightDiffuseColor` / `:GetLightDiffuseColor`, `:SetFogColor` / `:GetFogColor`, `:SetFogNear` / `:GetFogNear`, `:SetFogFar` / `:GetFogFar`, `:ClearFog`, `:SetDrawLayer` / `:GetDrawLayer`, `:SetPaused`, `:GetSceneTime`, `:After`, `:NewTimer`, `:NewTicker`, `:SetAllowOverlappedModels` / `:GetAllowOverlappedModels`, `:SetGroundTerrain` / `:GetGroundTerrain`, `:SetWorldModel`, `:SetWorldModelByMapID`, `:ClearWorldModel`, `:SetPlayWorldModelSounds` / `:GetPlayWorldModelSounds`, `:TraceSegment`, `:GetLiquidAtPoint`, `:SweepCollider`, `:SetSoundListenerActor` / `:GetSoundListenerActor`, `:GetActorAtCursor`, `:GetCursorRay`, `:GetActorsInRadius`, `OnActorEnter` / `OnActorLeave` |
+| [Frame: ModelSceneActor](docs/API.md#actorsetmodelbycreaturedisplayiddisplayid--useactiveplayercustomizations) | `:SetModelByCreatureDisplayID`, `:SetModelByPath`, `:SetModelByUnit`, `:SetModelByUnitCreatureDisplayID`, `:GetModelUnitGUID`, `:Dress`, `:Undress`, `:UndressSlot`, `:TryOn`, `:DressPlayerSlot`, `:IsSlotAllowed` / `:IsSlotVisible`, `:GetItemTransmogInfo`, `:GetItemTransmogInfoList`, `:SetItemTransmogInfo`, `:SetSheathed` / `:GetSheathed`, `:SetSheathedCategory`, `:UseUnitSheatheCategory`, `:SetAutoDress` / `:GetAutoDress`, `:IsGeoReady`, `:ClearModel`, `:IsLoaded`, `:GetModelPath`, `:SetPosition` / `:GetPosition`, `:SetYaw` / `:GetYaw`, `:SetPitch` / `:GetPitch`, `:SetRoll` / `:GetRoll`, `:SetScale` / `:GetScale`, `:SetUseCenterForOrigin` / `:IsUsingCenterForOrigin`, `:GetActiveBoundingBox`, `:GetMaxBoundingBox`, `:Show` / `:Hide` / `:SetShown` / `:IsShown` / `:IsVisible`, `:SetAlpha` / `:GetAlpha`, `:SetAnimation` / `:GetAnimation`, `:GetAnimationVariation`, `:SetAnimationBlendOperation` / `:GetAnimationBlendOperation`, `:SetPaused` / `:GetPaused`, `:SetSpellVisualKit` / `:GetSpellVisualKit`, `:ApplySpellVisualKit`, `:PlayAnimationKit` / `:StopAnimationKit`, `:AttachToMount`, `:DetachFromMount`, `:CalculateMountScale`, `:GetAttachmentPosition`, `:AttachToActor`, `:DetachFromActor`, `:PlaySpellVisual`, `:StopSpellVisual`, `:PlaySound`, `:SetPlayAnimationSounds` / `:GetPlayAnimationSounds`, `:SetShadowShown` / `:IsShadowShown`, `:SetMovementEnabled` / `:IsMovementEnabled`, `:StartMovingForward`, `:StartMovingBackward`, `:StopMoving`, `:StartStrafingLeft`, `:StartStrafingRight`, `:StopStrafing`, `:StartTurningLeft`, `:StartTurningRight`, `:StopTurning`, `:Jump`, `:StartPitchingUp`, `:StartPitchingDown`, `:StopPitching`, `:IsFalling`, `:IsSwimming`, `:MoveTo`, `:SetWalking` / `:IsWalking`, `:GetCameraPivotHeight`, `OnLoad`, `OnUpdate`, `OnModelLoading`, `OnModelLoaded`, `OnModelCleared`, `OnAnimFinished`, `OnSpellVisualImpact`, `OnMoveFinished`, `<Actor>` templates |
 | [Frame: ScrollingMessageFrame](docs/API.md#smfsethyperlinksenabledenabled--smfgethyperlinksenabled) | `:SetHyperlinksEnabled` / `:GetHyperlinksEnabled`, `:GetMessageInfo` (with the extra `:AddMessage` values), `:BackFillMessage` (adds a message as the oldest), `:RemoveMessagesByPredicate`, `:SetScrollOffset` / `:GetScrollOffset`, `:GetMaxScrollRange`, `:ScrollByAmount`, `:SetInsertMode` / `:GetInsertMode`, `:AddOnDisplayRefreshedCallback` |
 | [Frame: scripts](docs/API.md#onenable-and-ondisable-scripts) | `OnEnable`, `OnDisable`, `OnMinMaxChanged`, `OnAttributeChanged`, `OnCharComposition`, `OnTextChanged` (`userInput`), `PreClick`, `PostClick`, `SetModernScriptArgs` / `GetModernScriptArgs` |
 | [FriendList](docs/API.md#friendlist) | `AddOrRemoveFriend`, `C_FriendList.GetFriendInfo`, `C_FriendList.GetFriendInfoByIndex`, `C_FriendList.GetNumFriends`, `C_FriendList.GetNumOnlineFriends`, `C_FriendList.GetNumWhoResults`, `C_FriendList.GetWhoInfo`, `C_FriendList.IsFriend`, `C_FriendList.IsIgnored`, `C_FriendList.IsIgnoredByGuid`, `C_FriendList.IsWhoQueryPending`, `C_FriendList.SendWhoQueryByName`, `C_FriendList.SetFriendNotes`, `C_FriendList.SetFriendNotesByIndex` |
@@ -96,7 +99,7 @@ In the Frame rows, a name that starts with `:` is a method of the widget that th
 | [GameTooltip](docs/API.md#gametooltip) | `GameTooltip:AddSpellByID`, `GameTooltip:AddTexture`, `GameTooltip:GetGameObject`, `GameTooltip:GetItem`, `GameTooltip:GetMinimumWidth`, `GameTooltip:GetOwner`, `GameTooltip:GetPadding`, `GameTooltip:GetSpell`, `GameTooltip:GetUnit`, `GameTooltip:GetUnitGUID`, `GameTooltip:HasGameObject`, `GameTooltip:HasItem`, `GameTooltip:HasSpell`, `GameTooltip:HasUnit`, `GameTooltip:IsEquippedItem`, `GameTooltip:IsUnit`, `GameTooltip:SetAnchorType`, `GameTooltip:SetEquipmentSet`, `GameTooltip:SetFrameStack`, `GameTooltip:SetHyperlink` (full links, `spell:`, `quest:`), `GameTooltip:SetHyperlinkCompareItem`, `GameTooltip:SetInventoryItemByID`, `GameTooltip:SetItemByGUID`, `GameTooltip:SetItemByID`, `GameTooltip:SetSpellByID`, `GameTooltip:SetTalentByID`, `GameTooltip:SetTotem`, `GameTooltip:SetUnitAura`, `OnTooltipSetItem`, `OnTooltipSetSpell`, `OnTooltipSetUnit`, `OnTooltipSetGameObject`, `OnTooltipSetFrameStack` (scripts) |
 | [Gossip](docs/API.md#gossip) | `C_GossipInfo.CloseGossip`, `C_GossipInfo.GetActiveQuests`, `C_GossipInfo.GetAvailableQuests`, `C_GossipInfo.GetNumActiveQuests`, `C_GossipInfo.GetNumAvailableQuests`, `C_GossipInfo.GetNumOptions`, `C_GossipInfo.GetOptions`, `C_GossipInfo.GetPoiForUiMapID`, `C_GossipInfo.GetPoiInfo`, `C_GossipInfo.GetText`, `C_GossipInfo.SelectActiveQuest`, `C_GossipInfo.SelectAvailableQuest`, `C_GossipInfo.SelectOption`, `C_GossipInfo.SelectOptionByIndex`, `GetNumGossipActiveQuests`, `GetNumGossipAvailableQuests`, `GetNumGossipOptions` |
 | [Hooks](docs/API.md#hooks) | `hooksecurefunc` |
-| [Input](docs/API.md#input) | `GetMouseButtonClicked`, `GetMouseButtonName`, `IsLeftAltKeyDown`, `IsLeftControlKeyDown`, `IsLeftShiftKeyDown`, `IsModifierKeyDown`, `IsMouseButtonDown`, `IsRightAltKeyDown`, `IsRightControlKeyDown`, `IsRightShiftKeyDown` |
+| [Input](docs/API.md#input) | `GetCursorDelta`, `GetMouseButtonClicked`, `GetMouseButtonName`, `IsLeftAltKeyDown`, `IsLeftControlKeyDown`, `IsLeftShiftKeyDown`, `IsModifierKeyDown`, `IsMouseButtonDown`, `IsRightAltKeyDown`, `IsRightControlKeyDown`, `IsRightShiftKeyDown` |
 | [Instance](docs/API.md#instance) | `GetInstanceInfo`, `IsActiveBattlefieldArena` |
 | [Item: C_Item](docs/API.md#item) | `C_Item.DoesItemExist` / `C_Item.DoesItemExistByID`, `C_Item.EquipItemByName`, `C_Item.GetCurrentItemLevel`, `C_Item.GetDetailedItemLevelInfo`, `C_Item.GetEnchantInfo`, `C_Item.GetItemClassInfo`, `C_Item.GetItemCount`, `C_Item.GetItemData` / `C_Item.GetItemDataByID`, `C_Item.GetItemFamily`, `C_Item.GetItemGUID`, `C_Item.GetItemIcon` / `C_Item.GetItemIconByID`, `C_Item.GetItemID`, `C_Item.GetItemInfo`, `C_Item.GetItemInfoInstant`, `C_Item.GetItemInventorySlotInfo`, `C_Item.GetItemInventorySlotKey`, `C_Item.GetItemInventoryType` / `C_Item.GetItemInventoryTypeByID`, `C_Item.GetItemLink`, `C_Item.GetItemLocation`, `C_Item.GetItemMaxStackSize` / `C_Item.GetItemMaxStackSizeByID`, `C_Item.GetItemName` / `C_Item.GetItemNameByID`, `C_Item.GetItemQuality` / `C_Item.GetItemQualityByID`, `C_Item.GetItemSellPrice` / `C_Item.GetItemSellPriceByID`, `C_Item.GetItemSetID` / `C_Item.GetItemSetIDByID`, `C_Item.GetItemSetInfo`, `C_Item.GetItemSpell`, `C_Item.GetItemStatDelta`, `C_Item.GetItemStats`, `C_Item.GetItemSubClassInfo`, `C_Item.GetItemTempEnchantInfo`, `C_Item.GetItemUniqueness` / `C_Item.GetItemUniquenessByID`, `C_Item.GetStackCount`, `C_Item.GetWeaponEnchantInfo`, `C_Item.IsBound`, `C_Item.IsConsumableItem`, `C_Item.IsEquippableItem`, `C_Item.IsEquippedItem`, `C_Item.IsItemDataCached` / `C_Item.IsItemDataCachedByID`, `C_Item.IsItemGUIDInInventory`, `C_Item.IsItemInRange`, `C_Item.IsItemOpenable`, `C_Item.IsLocked`, `C_Item.IsUsableItem`, `C_Item.ItemHasRange`, `C_Item.LockItem`, `C_Item.LockItemByGUID`, `C_Item.UnlockItem`, `C_Item.UnlockAllItems`, `C_Item.PickupItem`, `C_Item.RequestLoadItemData` / `C_Item.RequestLoadItemDataByID`, `C_Item.UseAtCursor`, `C_Item.UseAtUnit`, `C_Item.UseItemByName` |
 | [Item: info](docs/API.md#getitemclassinfoclassid) | `GetItemClassInfo`, `GetItemSubClassInfo`, `GetItemIcon`, `IsConsumableItem`, `IsCurrentItem`, `IsDressableItem`, `IsEquippedItemType`, `IsHarmfulItem`, `IsHelpfulItem`, `IsUsableItem` |
@@ -112,7 +115,9 @@ In the Frame rows, a name that starts with `:` is a method of the widget that th
 | [Map](docs/API.md#map) | `C_Map.CanSetUserWaypointOnMap`, `C_Map.ClearUserWaypoint`, `C_Map.GetAreaInfo`, `C_Map.GetAreas`, `C_Map.GetAreaTriggerInfo`, `C_Map.GetAreaTriggers`, `C_Map.GetBestMapForUnit`, `C_Map.GetFallbackWorldMapID`, `C_Map.GetMapAreaIDs`, `C_Map.GetMapArtLayers`, `C_Map.GetMapArtLayerTextures`, `C_Map.GetMapChildrenInfo`, `C_Map.GetMapInfo`, `C_Map.GetMapInfoAtPosition`, `C_Map.GetMapOverlays`, `C_Map.GetMapPosFromWorldPos`, `C_Map.GetMapRectOnMap`, `C_Map.GetMapWorldSize`, `C_Map.GetPlayerMapPosition`, `C_Map.GetUserWaypoint`, `C_Map.GetUserWaypointFromHyperlink`, `C_Map.GetUserWaypointHyperlink`, `C_Map.GetUserWaypointPositionForMap`, `C_Map.GetWorldPosFromMapPos`, `C_Map.HasUserWaypoint`, `C_Map.MapHasArt`, `C_Map.SetUserWaypoint` |
 | [MapExplorationInfo](docs/API.md#mapexplorationinfo) | `C_MapExplorationInfo.GetExploredAreaIDsAtPosition`, `C_MapExplorationInfo.GetExploredMapTextures`, `C_MapExplorationInfo.GetUnexploredMapTextures` |
 | [MerchantFrame](docs/API.md#merchantframe) | `C_MerchantFrame.GetBuybackItemID`, `C_MerchantFrame.GetItemInfo`, `C_MerchantFrame.GetNumJunkItems`, `C_MerchantFrame.IsMerchantItemRefundable`, `C_MerchantFrame.IsSellAllJunkEnabled`, `C_MerchantFrame.SellAllJunkItems`, `GetBuybackItemLink` |
-| [Model](docs/API.md#model) | `DressUpModel:TryOn` (links, recipes, names, hand, enchant glow, result), `DressUpModel:UndressSlot`, `DressUpModel:IsGeoReady`, `DressUpModel:SetSheathed` / `GetSheathed`, `DressUpModel:SetAutoDress` / `GetAutoDress`, `Model:SetGlow`, `PlayerModel:RefreshCamera`, `PlayerModel:SetCamDistanceScale`, `PlayerModel:SetCreature` (`displayID`), `PlayerModel:SetDisplayInfo`, `PlayerModel:SetItem`, `PlayerModel:SetPortraitZoom`, `PlayerModel:SetRotation` (`animate`), `PlayerModel:SetUnit` (result), `PlayerModel:CanSetUnit`, `PlayerModel:GetDisplayInfo`, `PlayerModel:SetAnimation`, `PlayerModel:FreezeAnimation`, `PlayerModel:HasAnimation`, `PlayerModel:SetDoBlend` / `GetDoBlend`, `PlayerModel:SetKeepModelOnHide` / `GetKeepModelOnHide`, `PlayerModel:ApplySpellVisualKit` |
+| [Model](docs/API.md#model) | `DressUpModel:TryOn` (links, recipes, names, hand, enchant glow, result), `DressUpModel:UndressSlot`, `DressUpModel:IsGeoReady`, `DressUpModel:SetSheathed` / `GetSheathed`, `DressUpModel:SetAutoDress` / `GetAutoDress`, `DressUpModel:GetItemTransmogInfo` / `GetItemTransmogInfoList` / `SetItemTransmogInfo`, `DressUpModel:IsSlotAllowed` / `IsSlotVisible`, `Model:SetGlow`, `PlayerModel:RefreshCamera`, `PlayerModel:SetCamDistanceScale`, `PlayerModel:SetCreature` (`displayID`), `PlayerModel:SetDisplayInfo`, `PlayerModel:SetItem`, `PlayerModel:SetPortraitZoom`, `PlayerModel:SetRotation` (`animate`), `PlayerModel:SetUnit` (result), `PlayerModel:CanSetUnit`, `PlayerModel:GetDisplayInfo`, `PlayerModel:SetAnimation`, `PlayerModel:FreezeAnimation`, `PlayerModel:HasAnimation`, `PlayerModel:SetDoBlend` / `GetDoBlend`, `PlayerModel:SetKeepModelOnHide` / `GetKeepModelOnHide`, `PlayerModel:ApplySpellVisualKit` |
+| [ModelInfo](docs/API.md#c_modelinfogetmodelsceneinfobyidmodelsceneid) | `C_ModelInfo.GetModelSceneInfoByID`, `C_ModelInfo.GetModelSceneCameraInfoByID`, `C_ModelInfo.GetModelSceneActorInfoByID`, `C_ModelInfo.GetModelSceneActorDisplayInfoByID` |
+| [Mount](docs/API.md#mount) | `C_MountJournal.GetMountFromItem`, `C_MountJournal.GetMountFromSpell`, `C_MountJournal.GetMountInfoExtraByID` |
 | [NamePlate](docs/API.md#nameplate) | `C_NamePlate.GetNamePlateForGUID`, `C_NamePlate.GetNamePlateForUnit`, `C_NamePlate.GetNamePlateGUIDs`, `C_NamePlate.GetNamePlates` |
 | [NameCache](docs/API.md#namecache) | `C_PlayerCache.GetPlayerInfoByName`, `C_PlayerCache.IsEnabled`, `C_PlayerCache.RememberPlayer`, `C_PlayerCache.SetEnabled`, `GetPlayerInfoByGUID`, `UnitNameFromGUID` |
 | [NewItems](docs/API.md#newitems) | `C_NewItems.ClearAll`, `C_NewItems.IsNewItem`, `C_NewItems.RemoveNewItem` |
@@ -161,6 +166,7 @@ the glue state because GlueXML had no way to reach them otherwise.
 | [CharacterList](docs/API.md#characterlist) | `GetSavedCharacterOrder`, `SetSavedCharacterOrder` (persist to `WTF\Account\...\ClassicAPI.txt`) |
 | CVar | `GetCVar`, `SetCVar`, `RegisterCVar`, `GetCVarDefault`, `C_CVar.GetCVarBool`, `C_CVar.SetTempCVar`, `C_CVar.RemoveTempCVar` (storage is process-global — writes from glue are visible in-world and vice versa) |
 | [Glue](docs/API.md#glue) | `C_Glue.IsFirstLoadThisSession`, `C_Glue.IsOnGlueScreen` |
+| [Input](docs/API.md#getcursordelta) | `GetCursorDelta` |
 | Script | `RunScript` (compile and run a Lua chunk in the glue state's globals — useful for slash-command-style helpers in GlueXML) |
 | State | `IsLoggedIn` |

@@ -398,6 +404,7 @@ when launching with `-console`), not as Lua functions. See the
 | Screen location type | `Enum.ScreenLocationType.{Center,Left,Right,Top,Bottom,TopLeft,TopRight,LeftOutside,RightOutside,LeftRight,TopBottom,LeftRightOutside}` (0–11) |
 | Self-resurrect option type | `Enum.SelfResurrectOptionType.{Spell,Item}` (0–1) |
 | Autocomplete entry flag | `Enum.AutoCompleteEntryFlag.{InGroup,InGuild,Friend,Bnet,InteractedWith,Online,InAOI,AccountCharacter,RecentPlayer}` (bits 1–256) |
+| Model blend operation | `Enum.ModelBlendOperation.{None,Anim}` (0–1) |
 | Autocomplete priority | `Enum.AutoCompletePriority.{Other,Interacted,InGroup,Guild,Friend,AccountCharacter,AccountCharacterSameRealm}` (0–6) |

 </details>
@@ -30,15 +30,23 @@ float PixelToInternal(float px) {
    const float div = Read<float>(Offsets::VAR_COORD_ASPECT_COMPENSATION);
    if (div == 0.0f)
        return 0.0f;
-    return px * mul / (div * static_cast<float>(Offsets::UI_COORD_SCALE_UNIT));
+    return px * mul / (div * Read<float>(Offsets::FLOAT_SCRIPT_COORD_SCALE));
 }

 double InternalToPixel(float internal) {
-    const float mul = Read<float>(Offsets::VAR_COORD_DDC_WIDTH_SCALE);
-    const float div = Read<float>(Offsets::VAR_COORD_ASPECT_COMPENSATION);
-    if (mul == 0.0f)
+    using GetScaledScreenAspect_t = float(__cdecl *)();
+    // Declared double so the quotient is read from ST0, as the engine's
+    // pushes store it with `fstp qword`, not narrowed to float.
+    using DivideByScreenScaleX_t = double(__stdcall *)(float);
+    if (Read<float>(Offsets::VAR_COORD_DDC_WIDTH_SCALE) == 0.0f)
        return 0.0;
-    return static_cast<double>(internal) * div * Offsets::UI_COORD_SCALE_UNIT / mul;
+    // `aspect * 1024` is exact, so the float product rounds once, as the
+    // engine's `fstp dword` does.
+    const float aspect =
+        reinterpret_cast<GetScaledScreenAspect_t>(Offsets::FUN_COORD_GET_SCALED_SCREEN_ASPECT)();
+    const float scaled = aspect * Read<float>(Offsets::FLOAT_SCRIPT_COORD_SCALE) * internal;
+    return reinterpret_cast<DivideByScreenScaleX_t>(Offsets::FUN_COORD_DIVIDE_BY_SCREEN_SCALE_X)(
+        scaled);
 }

 bool StringToFlag(const char *text) {
@@ -58,6 +58,18 @@ inline T &Ref(uintptr_t address) {
    return *reinterpret_cast<T *>(address);
 }

+// An engine constant at a fixed VA, read each time it is used, so the value is
+// the one the engine's own code reads: a runtime patch shows, and so does a
+// global the engine's static initializers fill after this DLL loads. Converts
+// to T, so it stands in a float expression as a float would.
+//
+//   const Game::Live<float> kSkin{Offsets::VAR_MOVER_SKIN};
+template <typename T>
+struct Live {
+    uintptr_t address;
+    operator T() const { return Read<T>(address); }
+};
+
 // Calls `fn(object)` for each object of one of a frame's intrusive lists,
 // OFF_FRAME_REGION_LIST or OFF_FRAME_CHILD_LIST: node+4 next, node+8 object,
 // a NULL or low-bit-1 link ends it - the walk the engine's own frame code
@@ -89,8 +101,10 @@ void *ResolveUnitToken(const char *token);

 // UI pixels <-> internal layout (anchor) units. Script_SetPoint converts its
 // pixel offsets with `px * [VAR_COORD_DDC_WIDTH_SCALE] / ([VAR_COORD_ASPECT_COMPENSATION]
-// * UI_COORD_SCALE_UNIT)`; Script_GetLeft and Script_GetStringWidth push the
-// inverse. A region's LOCAL pixels must be multiplied by its effective scale
+// * [FLOAT_SCRIPT_COORD_SCALE])`; every script coordinate push (GetLeft,
+// GetStringWidth, GetFont's height, GetCursorPosition, OnCursorChanged) is the
+// inverse, `DivideByScreenScaleX(GetScaledScreenAspect() * 1024 * value)`,
+// which InternalToPixel calls in that order. A region's LOCAL pixels must be multiplied by its effective scale
 // (OFF_REGION_EFFECTIVE_SCALE) first. Both return 0 while the scale globals
 // are unset, so an early caller gets a zero offset rather than a wild one.
 float PixelToInternal(float px);
@@ -77,6 +77,7 @@
 #include "addons/TocRewrite.h"
 #include "bindings/Inject.h"
 #include "embed/Resource.h"
+#include "storm/Memory.h"

 #include <cstdint>
 #include <cstdio>
@@ -153,8 +154,6 @@ Embed::Bytes LookupEmbedded(const char *relPath) {
 // by the caller's standard SMemFree in turn.
 using AddOns::EngineIO::FileExistsFn;
 using AddOns::EngineIO::FileReadFn;
-using AddOns::EngineIO::SMemAllocFn;
-using AddOns::EngineIO::SMemFreeFn;

 // The trampolines to the original FUN_FILE_READ / FUN_FILE_EXISTS (installed
 // by the co-hooks below).
@@ -277,8 +276,7 @@ void DecideSource(int addon) {
    // Free the disk buffer we just borrowed — we only needed it for
    // the version-line scrape. The actual content for the engine's
    // TOC read comes through the regular hook path below.
-    auto SMemFree = reinterpret_cast<SMemFreeFn>(Offsets::FUN_STORM_SMEM_FREE);
-    SMemFree(diskBuf, __FILE__, __LINE__, 0);
+    Storm::Free(diskBuf, __FILE__, __LINE__);

    // Missing or unparseable disk version → assume it's older than
    // anything we ship, embedded wins.
@@ -320,10 +318,8 @@ int ReadAddonFile(int addon, const char *relPath, int unused, const char *path,
                          flag1, flag2);
    }

-    auto SMemAlloc = reinterpret_cast<SMemAllocFn>(
-        Offsets::FUN_STORM_SMEM_ALLOC);
    const size_t totalSize = entry.size + extraBytes;
-    void *buf = SMemAlloc(totalSize, __FILE__, __LINE__, 0);
+    void *buf = Storm::Alloc(totalSize, __FILE__, __LINE__);
    if (buf == nullptr) return 0;
    std::memcpy(buf, entry.data, entry.size);
    if (extraBytes > 0) {
@@ -32,10 +32,6 @@ using FileReadFn = int(__stdcall *)(int unused, const char *path, void **outBuf,
 // FUN_FILE_EXISTS (0x00648A30) — __stdcall, RET 8.
 using FileExistsFn = int(__stdcall *)(const char *path, int mode);

-// FUN_STORM_SMEM_ALLOC / FUN_STORM_SMEM_FREE — __stdcall, RET 0x10. Buffers
-// FUN_FILE_READ hands out are freed with SMemFreeFn; a buffer we allocate with
-// SMemAllocFn is freed cleanly by the engine's own SMemFree in turn.
-using SMemAllocFn = void *(__stdcall *)(size_t size, const char *file, int line, int flags);
-using SMemFreeFn = void(__stdcall *)(void *buf, const char *file, int line, int flags);
+// Buffers FUN_FILE_READ hands out are freed with Storm::Free (storm/Memory.h).

 } // namespace AddOns::EngineIO
@@ -34,6 +34,7 @@
 #include "addons/EngineIO.h"
 #include "addons/Toc.h"
 #include "luasyntax/AddonNamespace.h"
+#include "storm/Memory.h"

 #include <cstddef>
 #include <cstdint>
@@ -51,7 +52,6 @@ using IsLoadedFn_t = uint8_t(__fastcall *)(const char *name);
 // FUN_FILE_READ address routes through Embedded's file-read hook, which forwards
 // every non-`!!!ClassicAPI` path to the original untouched — what we want here.
 using AddOns::EngineIO::FileReadFn;
-using AddOns::EngineIO::SMemFreeFn;

 // True iff the addon's `.toc` has a line `## AllowAddOnTableAccess: <nonzero>`.
 // The value is read as a TOC boolean flag: parse the leading integer, true iff
@@ -87,8 +87,7 @@ bool TocAllowsTableAccess(const char *name) {
        allowed = anyDigit && value != 0;
    }

-    auto smemFree = reinterpret_cast<SMemFreeFn>(Offsets::FUN_STORM_SMEM_FREE);
-    smemFree(buf, __FILE__, __LINE__, 0);
+    Storm::Free(buf, __FILE__, __LINE__);
    return allowed;
 }

@@ -86,6 +86,7 @@
 #include "addons/Embedded.h"
 #include "addons/EngineIO.h"
 #include "addons/Registry.h"
+#include "storm/Memory.h"

 #include <algorithm>
 #include <cstdint>
@@ -235,9 +236,7 @@ bool TryHashToc(const char *name, uint32_t *outHash) {
    if (!ReadToc(name, &buf, &size))
        return false;
    *outHash = HashTocMetadata(static_cast<const char *>(buf), size);
-    reinterpret_cast<AddOns::EngineIO::SMemFreeFn>(
-        static_cast<uintptr_t>(Offsets::FUN_STORM_SMEM_FREE))(
-        buf, __FILE__, __LINE__, 0);
+    Storm::Free(buf, __FILE__, __LINE__);
    return true;
 }

@@ -48,6 +48,7 @@
 #include "addons/EngineIO.h"
 #include "addons/Toc.h"
 #include "script/LoadFile.h"
+#include "storm/Memory.h"

 #include <cstddef>
 #include <cstdint>
@@ -66,7 +67,6 @@ constexpr size_t NPOS = static_cast<size_t>(-1);
 // FlavorToc applies), the exists-check, and the Storm free. See addons/EngineIO.h.
 using AddOns::EngineIO::FileExistsFn;
 using AddOns::EngineIO::FileReadFn;
-using AddOns::EngineIO::SMemFreeFn;
 using LoadTocFilesFn = uint32_t(__fastcall *)(char *tocPath, int *a2, int *a3);
 using NameFn = const char *(*)(); // no-arg readers (return in EAX)

@@ -160,8 +160,7 @@ SvFlags ReadSvFlags(const char *tocPath) {
    f.perChar =
        AddOns::Toc::FindValue(b, size, "SavedVariablesPerCharacter", &v, &n) && n > 0;

-    reinterpret_cast<SMemFreeFn>(static_cast<uintptr_t>(Offsets::FUN_STORM_SMEM_FREE))(
-        buf, __FILE__, __LINE__, 0);
+    Storm::Free(buf, __FILE__, __LINE__);
    return f;
 }

@@ -17,6 +17,7 @@
 #include "localization/Locale.h"

 #include "Offsets.h"
+#include "storm/Memory.h"
 #include "turtle/Detect.h"

 #include <cstddef>
@@ -28,8 +29,6 @@ namespace AddOns::TocRewrite {

 namespace {

-using AddOns::EngineIO::SMemAllocFn;
-using AddOns::EngineIO::SMemFreeFn;
 using AddOns::Toc::EqCI;
 using AddOns::Toc::Lower;

@@ -288,15 +287,13 @@ void Transform(const char *path, void **outBuf, size_t *outSize) {
        std::memcmp(rebuilt.data(), content, size) == 0)
        return; // brackets/commas were only in unaffected lines — nothing changed

-    auto SMemAlloc = reinterpret_cast<SMemAllocFn>(Offsets::FUN_STORM_SMEM_ALLOC);
-    auto SMemFree = reinterpret_cast<SMemFreeFn>(Offsets::FUN_STORM_SMEM_FREE);
    const size_t newLen = rebuilt.size();
-    void *buf = SMemAlloc(newLen + 1, __FILE__, __LINE__, 0); // +1 NUL (extraBytes=1)
+    void *buf = Storm::Alloc(newLen + 1, __FILE__, __LINE__); // +1 NUL (extraBytes=1)
    if (buf == nullptr) return;                               // OOM — keep the original
    std::memcpy(buf, rebuilt.data(), newLen);
    static_cast<char *>(buf)[newLen] = '\0';

-    SMemFree(*outBuf, __FILE__, __LINE__, 0);
+    Storm::Free(*outBuf, __FILE__, __LINE__);
    *outBuf = buf;
    if (outSize != nullptr) *outSize = newLen;
 }
@@ -61,6 +61,7 @@

 #include "Game.h"
 #include "Offsets.h"
+#include "frame/Layout.h"
 #include "frame/Alpha.h"
 #include "frame/Destruction.h"
 #include "texture/Transform.h"
@@ -115,7 +116,6 @@ using SetColor_t = void(__fastcall *)(void *region, void *edx, const uint32_t *b
 using StoreCorners_t = void(__fastcall *)(void *region, void *edx, float *rect);
 using Crop_t = void(__fastcall *)(void *region, void *edx, float *rect);
 using SetStringPos_t = void(__fastcall *)(void *block, const float *position);
-using NdcToDdc_t = void(__fastcall *)(float *outX, float *outY, float x, float y);
 using SizeChanged_t = void(__fastcall *)(void *layout, void *edx, const float *oldRect);
 using InvalidateNode_t = void(__fastcall *)(void *node);

@@ -216,7 +216,7 @@ bool GetStringPos(void *block, float out[3]) {
    if (node == nullptr)
        return false;
    const float *position = Game::Ptr<const float>(node, Offsets::OFF_TEXT_NODE_POSITION);
-    reinterpret_cast<NdcToDdc_t>(Offsets::FUN_COORD_NDC_TO_DDC)(&out[0], &out[1], position[0], position[1]);
+    Frame::Layout::NdcToDdc(&out[0], &out[1], position[0], position[1]);
    out[2] = position[2];
    return true;
 }
@@ -59,6 +59,8 @@ bool FloatAttr(const void *node, const char *name, float &out) {
    return true;
 }

+} // namespace
+
 // object[parentKey] = child, as 4.3.4's LoadXML does for both.
 void BindParentKey(void *object, Object *child, const char *key) {
    if (key == nullptr || *key == '\0')
@@ -145,6 +147,8 @@ void LoadKeyValues(Object *object, const void *node, void *status) {
    Game::Lua::SetTop(L, top);
 }

+namespace {
+
 // LoadXML_AnimOrigin: <Origin point="..."><Offset x= y=/></Origin>.
 void LoadOrigin(Anim *anim, const void *node) {
    const void *origin = FindChild(node, "Origin");
@@ -21,6 +21,7 @@
 // (RegisterXMLTemplate), whatever its tag, so `inherits` resolves through
 // Xml::Template as 4.3.4's XMLHashNodeRef does.
 namespace Animation {
+class Object;
 class Group;
 class Anim;
 class ControlPoint;
@@ -39,4 +40,13 @@ void LoadControlPoint(ControlPoint *point, const void *node, void *status);
 // The template node `name` resolves to, or nullptr.
 const void *Template(const char *name);

+// What every script object's element shares (Model::Scene's actors too):
+// object[key] = child for parentKey, an append to object[key] for
+// parentArray, the <Scripts> (a body, a `function` global or a `method`
+// field) and the <KeyValues>.
+void BindParentKey(void *object, Object *child, const char *key);
+void BindParentArray(void *object, Object *child, const char *key);
+void LoadScripts(Object *object, const void *node);
+void LoadKeyValues(Object *object, const void *node, void *status);
+
 } // namespace Animation::Xml
@@ -49,6 +49,7 @@
 #include "Inject.h"
 #include "Common.h"
 #include "Offsets.h"
+#include "storm/Memory.h"

 #include "embed/Resource.h"
 #include "embedded_resources.h"
@@ -213,8 +214,6 @@ const char *FindSplicePosition(const char *content, size_t size,
    return FindOutsideComment(content, end, "</Bindings>");
 }

-using SMemAlloc_t = void *(__stdcall *)(size_t size, const char *file, int line, int flags);
-using SMemFree_t = void(__stdcall *)(void *buf, const char *file, int line, int flags);

 } // namespace

@@ -257,10 +256,8 @@ bool TryHandle(int unused, const char *path, void **outBuf, size_t *outSize,
    const size_t splicePos = static_cast<size_t>(splice - content);
    const size_t newSize = origSize + config.innerSize;

-    auto SMemAlloc = reinterpret_cast<SMemAlloc_t>(Offsets::FUN_STORM_SMEM_ALLOC);
-    auto SMemFree = reinterpret_cast<SMemFree_t>(Offsets::FUN_STORM_SMEM_FREE);

-    void *newBuf = SMemAlloc(newSize + extraBytes, __FILE__, __LINE__, 0);
+    void *newBuf = Storm::Alloc(newSize + extraBytes, __FILE__, __LINE__);
    if (newBuf == nullptr) {
        // Allocation failed — fall back to the original buffer so the
        // engine still loads its own bindings.
@@ -277,7 +274,7 @@ bool TryHandle(int unused, const char *path, void **outBuf, size_t *outSize,
    if (extraBytes > 0)
        std::memset(dest + newSize, 0, extraBytes);

-    SMemFree(origBuf, __FILE__, __LINE__, 0);
+    Storm::Free(origBuf, __FILE__, __LINE__);

    if (outBuf != nullptr) *outBuf = newBuf;
    if (outSize != nullptr) *outSize = newSize;
@@ -46,6 +46,7 @@
 #include "baselib/Ascii.h"
 #include "frame/ClickEvents.h"
 #include "input/Modifier.h"
+#include "storm/Memory.h"
 #include "xml/FrameLoad.h"

 #include <cstdint>
@@ -219,8 +220,7 @@ void LoadModifiedClicks(const char *path, void *status) {
        return;
    void *tree = reinterpret_cast<TreeLoad_t>(Offsets::FUN_XML_TREE_LOAD)(
        static_cast<const char *>(data), static_cast<uint32_t>(size));
-    reinterpret_cast<AddOns::EngineIO::SMemFreeFn>(Offsets::FUN_STORM_SMEM_FREE)(data, __FILE__,
-                                                                                 __LINE__, 0);
+    Storm::Free(data, __FILE__, __LINE__);
    if (tree == nullptr)
        return; // the engine loader reports the parse error
    const void *root = Game::Read<const void *>(tree, 0);
@@ -45,6 +45,7 @@

 #include "Game.h"
 #include "Offsets.h"
+#include "frame/Layout.h"
 #include "text/InlineTexture.h"

 #include <cstdint>
@@ -59,21 +60,17 @@ using IndexAtPoint_t = void(__fastcall *)(void *editBox, void *edx, float x, flo
 using FontHeight_t = float(__fastcall *)(void *fs, void *edx, int mode);
 using MeasureRun_t = float(__fastcall *)(void *fs, void *edx, const uint8_t *text, int len);
 using PixelAlignY_t = float(__stdcall *)(float length);
-using GetRect_t = int(__fastcall *)(void *anchor, void *edx, float *out);
 using ClearAllPoints_t = void(__fastcall *)(void *anchor);
 using SetPoint_t = void(__thiscall *)(void *anchor, int point, void *relAnchor, int relPoint, float x, float y,
                                      int flag);
-using Resize_t = void(__fastcall *)(void *anchor, void *edx, int force);
 using Extent_t = float(__fastcall *)(void *anchor, void *edx);
-using ScreenAspect_t = float(__cdecl *)();
-using DivideByScreenScaleX_t = float(__stdcall *)(float value);
 using FireVariadic_t = void(__cdecl *)(void *frame, uint32_t *slotPtr, const char *fmt, ...);

 PlaceCaret_t g_origPlaceCaret = nullptr;
 PlaceSelectionPiece_t g_origPlaceSelectionPiece = nullptr;
 IndexAtPoint_t g_origIndexAtPoint = nullptr;

-void *AnchorOf(void *region) { return static_cast<uint8_t *>(region) + Offsets::OFF_REGION_ANCHOR; }
+using Frame::Layout::Of;

 // A multi-line box's rows: its label, the buffer the line table indexes (the
 // '*' copy of a password box) and the table — each line's first byte, the
@@ -179,9 +176,9 @@ bool AnchorX(const Rows &rows, int line, uint32_t pos, float &x, int &relPoint)

 // Anchors `region` as the placer did, at `y`.
 void Anchor(const Rows &rows, void *region, int relPoint, float x, float y, int flag) {
-    void *anchor = AnchorOf(region);
+    void *anchor = Of(region);
    reinterpret_cast<ClearAllPoints_t>(Offsets::FUN_LAYOUT_CLEAR_ALL_POINTS)(anchor);
-    reinterpret_cast<SetPoint_t>(Offsets::FUN_REGION_SET_POINT)(anchor, Offsets::FRAMEPOINT_TOPLEFT, AnchorOf(rows.fs),
+    reinterpret_cast<SetPoint_t>(Offsets::FUN_REGION_SET_POINT)(anchor, Offsets::FRAMEPOINT_TOPLEFT, Of(rows.fs),
                                                                relPoint, x, y, flag);
 }

@@ -192,7 +189,7 @@ void __fastcall IndexAtPoint_h(void *editBox, void *edx, float x, float y, int *
    if (!MultiLineRows(editBox, rows))
        return g_origIndexAtPoint(editBox, edx, x, y, index);
    float rect[4] = {0.0f, 0.0f, 0.0f, 0.0f}; // bottom, left, top, right
-    if (reinterpret_cast<GetRect_t>(Offsets::FUN_REGION_GET_RECT)(AnchorOf(rows.fs), nullptr, rect) == 0)
+    if (!Frame::Layout::GetRect(rows.fs, rect))
        return g_origIndexAtPoint(editBox, edx, x, y, index);
    // The engine walks rows down from the label's top while the click is
    // below the row (strictly), stopping at the last line. Walk the rows as
@@ -240,7 +237,7 @@ void __fastcall PlaceSelectionPiece_h(void *editBox, void *edx, void *piece, int
        return;
    const float y = -(RowHeight(rows) / rows.scale) * static_cast<float>(line) - shift;
    Anchor(rows, piece, relPoint, x, y, 0);
-    reinterpret_cast<Resize_t>(Offsets::FUN_LAYOUT_RESIZE)(AnchorOf(piece), nullptr, 1);
+    Frame::Layout::Resize(piece, true);
 }

 // --- the caret ----------------------------------------------------------------
@@ -276,15 +273,12 @@ void __fastcall PlaceCaret_h(void *editBox) {
        return;
    // OnCursorChanged(x, y, width, height) as the engine fires it: each
    // value by the anchor→script factor, pushed as a double.
-    void *anchor = AnchorOf(caret);
+    void *anchor = Of(caret);
    void **vtable = *static_cast<void ***>(anchor);
    const float width = reinterpret_cast<Extent_t>(vtable[7])(anchor, nullptr);  // +0x1C GetWidth
    const float height = reinterpret_cast<Extent_t>(vtable[8])(anchor, nullptr); // +0x20 GetHeight
-    const auto aspect = reinterpret_cast<ScreenAspect_t>(Offsets::FUN_COORD_GET_SCALED_SCREEN_ASPECT);
-    const auto divide = reinterpret_cast<DivideByScreenScaleX_t>(Offsets::FUN_COORD_DIVIDE_BY_SCREEN_SCALE_X);
-    const float factor = Game::Read<float>(Offsets::FLOAT_SCRIPT_COORD_SCALE);
-    const auto push = [&](float value) { return static_cast<double>(divide(aspect() * factor * value)); };
-    const double args[4] = {push(x), push(y), push(width), push(height)};
+    const double args[4] = {Game::InternalToPixel(x), Game::InternalToPixel(y), Game::InternalToPixel(width),
+                            Game::InternalToPixel(height)};
    void *L = Game::Lua::State();
    const int savedTop = (L != nullptr) ? Game::Lua::GetTop(L) : 0;
    reinterpret_cast<FireVariadic_t>(Offsets::FUN_FRAME_RUN_SCRIPT_VARIADIC)(
@@ -144,6 +144,17 @@ FrameXML\ColorSwatch.lua
 FrameXML\ColorSwatch.xml
 FrameXML\ScriptErrorsFrame.lua
 FrameXML\ScriptErrorsFrame.xml
+FrameXML\ModelScene\CameraRegistry.lua
+FrameXML\ModelScene\CameraBaseMixin.lua
+FrameXML\ModelScene\OrbitCameraMixin.lua
+FrameXML\ModelScene\FollowCameraMixin.lua
+FrameXML\ModelScene\ModelSceneMixin.lua
+FrameXML\ModelScene\ModelSceneMixin.xml
+FrameXML\ModelScene\ModelSceneActorMixin.lua
+FrameXML\ModelScene\ModelSceneActorMixin.xml
+FrameXML\ModelScene\ModelSceneControlFrame.lua
+FrameXML\ModelScene\ModelSceneControlFrame.xml
+FrameXML\DressUpFrame.xml
 FrameXML\DressUpFrame.lua

 Menu\MenuConstants.lua
@@ -24,3 +24,22 @@ end
 function C_AutoComplete.GetAutoCompleteRealms()
    return {}
 end
+
+-- C_ModelInfo's getters come from the DLL. Retail's active-scene bookkeeping
+-- "does nothing in public clients" (its own documentation).
+function C_ModelInfo.AddActiveModelScene(modelSceneFrame, modelSceneID)
+end
+
+function C_ModelInfo.AddActiveModelSceneActor(modelSceneFrameActor, modelSceneActorID)
+end
+
+function C_ModelInfo.ClearActiveModelScene(modelSceneFrame)
+end
+
+function C_ModelInfo.ClearActiveModelSceneActor(modelSceneFrameActor)
+end
+
+-- This client has no alternate player forms.
+function C_PlayerInfo.GetAlternateFormInfo()
+    return false, false
+end
@@ -10,10 +10,203 @@
 --   - An uncached item skips the IsDressableItem test, which reads only the
 --     cache. 1.12.1 opens no tooltip before a chat link's Control-click, so
 --     the test would drop most chat links; TryOn loads the item instead.
+--   - An item the model cannot wear goes on to DressUpMountLink, retail's
+--     next step in DressUpLink: 1.12.1's FrameXML (ItemRef, bags, loot, the
+--     auction house) calls DressUpItemLink alone.
+--   - It returns true when it showed the item or its mount, and false for a
+--     link of another type, as retail's does.

-function DressUpItemLink(link)
-	if ( not link or (C_Item.IsItemDataCachedByID(link) and not IsDressableItem(link)) ) then
-		return;
+-- A link DressUpItemLink takes: an item link, or anything that is not a
+-- link (an item ID or name).
+local function IsItemLink(link)
+	local linkType = type(link) == "string" and LinkUtil.ExtractLink(link);
+	return not linkType or linkType == "item";
+end
+
+-- 4.3.4's DressUpItemLink body: the item, when the model can wear it.
+local function DressUpWearable(link)
+	if ( C_Item.IsItemDataCachedByID(link) and not IsDressableItem(link) ) then
+		return false;
 	end
 	DressUpItem(link);
+	return true;
+end
+
+function DressUpItemLink(link)
+	if ( not link or not IsItemLink(link) ) then
+		return false;
+	end
+	return DressUpWearable(link) or DressUpMountLink(link);
+end
+
+-- Retail's DressUpLink (Mainline/DressUpFrames.lua), without battle pets.
+function DressUpLink(link, forcedFrame)
+	return link and ((IsItemLink(link) and DressUpWearable(link)) or DressUpMountLink(link, forcedFrame));
+end
+
+-- Retail's mount preview (Mainline/DressUpFrames.lua DressUpMountLink and
+-- DressUpMount, Blizzard_SharedXMLGame/DressUpModelFrameMixin.lua's mode and
+-- last link) on 1.12.1's dressing room. Mount mode shows DressUpFrameModelScene
+-- in place of DressUpModel and hides the Reset button, as retail's SetMode
+-- hides it outside player mode; DressUpItem goes back to player mode.
+--
+-- Differences from the retail source:
+--   - DressUpFrame keeps its own background (retail switches to the warrior
+--     one) and has no view insets to set (retail sets them to 0, the default).
+--   - There are no mount links, so a link never sets the model itself, and
+--     shouldSetModelFromHyperlink changes nothing.
+--   - A mount whose creature is not cached yet returns false, as retail does
+--     with no display, and opens when CREATURE_DATA_LOAD_RESULT reports the
+--     creature: retail has every display on disk, this client asks the server.
+
+DressUpFrame.ModelScene = DressUpFrameModelScene;
+DressUpFrame.ModelScene.ControlFrame:SetModelScene(DressUpFrame.ModelScene);
+
+function DressUpFrame:GetLastLink()
+	return self.lastLink;
+end
+
+function DressUpFrame:SetLastLink(link)
+	self.lastLink = link;
+end
+
+function DressUpFrame:GetMode()
+	return self.mode;
+end
+
+function DressUpFrame:SetMode(mode)
+	self.mode = mode;
+	local inPlayerMode = mode ~= "mount";
+	DressUpModel:SetShown(inPlayerMode);
+	DressUpFrameResetButton:SetShown(inPlayerMode);
+	self.ModelScene:SetShown(not inPlayerMode);
+end
+
+DressUpFrame.ModelScene:SetResetCallback(function()
+	local link = DressUpFrame:GetLastLink();
+	if link then
+		DressUpLink(link, DressUpFrame);
+	end
+end);
+
+-- The stock DressUpItem sets the unit only when it opens the window, and the
+-- model was hidden while a mount showed.
+local originalDressUpItem = DressUpItem;
+function DressUpItem(item)
+	if ( DressUpFrame:GetMode() == "mount" ) then
+		DressUpFrame:SetMode("player");
+		DressUpFrame:SetLastLink(nil);
+		if ( DressUpFrame:IsVisible() ) then
+			DressUpModel:SetUnit("player");
+		end
+	end
+	return originalDressUpItem(item);
+end
+
+function DressUpMountLink(link, forcedFrame)
+	if( link ) then
+		local mountID = 0;
+
+		local linkType, linkOptions = LinkUtil.ExtractLink(link);
+		if linkType == "item" then
+			local linkID = LinkUtil.SplitLinkOptions(linkOptions);
+			mountID = C_MountJournal.GetMountFromItem(tonumber(linkID));
+		elseif linkType == "spell" then
+			local linkID = LinkUtil.SplitLinkOptions(linkOptions);
+			mountID = C_MountJournal.GetMountFromSpell(tonumber(linkID));
+		end
+
+		if ( mountID ) then
+			return DressUpMount(mountID, forcedFrame, false, link);
+		end
+	end
+	return false
+end
+
+local pendingMount;
+
+-- The creature GetMountInfoExtraByID loads for a mount: a mount ID is its
+-- spell ID, and the mount aura's misc value is the creature.
+local SPELL_AURA_MOUNTED = 78;
+local function MountCreatureID(mountID)
+	local effects = C_Spell.GetSpellEffectInfo(mountID);
+	if ( effects ) then
+		for _, effect in ipairs(effects) do
+			if ( effect.auraName == SPELL_AURA_MOUNTED ) then
+				return effect.miscValue;
+			end
+		end
+	end
+end
+
+function DressUpMount(mountID, forcedFrame, shouldSetModelFromHyperlink, link)
+	if ( not mountID or mountID == 0 ) then
+		return false;
+	end
+
+	local creatureDisplayID, _, _, isSelfMount, _, modelSceneID, animID, spellVisualKitID, disablePlayerMountPreview = C_MountJournal.GetMountInfoExtraByID(mountID);
+	if ( not creatureDisplayID ) then
+		pendingMount = { mountID = mountID, creatureID = MountCreatureID(mountID), forcedFrame = forcedFrame, link = link };
+		return false;
+	end
+	pendingMount = nil;
+
+	local frame = forcedFrame or DressUpFrame;
+
+	--Show the frame
+	if ( not frame:IsShown() or frame:GetMode() ~= "mount" ) then
+		frame:SetMode("mount");
+		ShowUIPanel(frame);
+	end
+	frame:SetLastLink(link);
+	frame.ModelScene:ClearScene();
+	local forceEvenIfSame = true;
+	frame.ModelScene:TransitionToModelSceneID(modelSceneID, CAMERA_TRANSITION_TYPE_IMMEDIATE, CAMERA_MODIFICATION_TYPE_DISCARD, forceEvenIfSame);
+
+	local mountActor = frame.ModelScene:GetActorByTag("unwrapped");
+	if mountActor then
+		mountActor:SetModelByCreatureDisplayID(creatureDisplayID);
+
+		-- mount self idle animation
+		if (isSelfMount) then
+			mountActor:SetAnimationBlendOperation(Enum.ModelBlendOperation.None);
+			mountActor:SetAnimation(618); -- MountSelfIdle
+		else
+			mountActor:SetAnimationBlendOperation(Enum.ModelBlendOperation.Anim);
+			mountActor:SetAnimation(0);
+		end
+		frame.ModelScene:AttachPlayerToMount(mountActor, animID, isSelfMount, disablePlayerMountPreview);
+	end
+	return true;
+end
+
+local creatureLoadFrame = CreateFrame("Frame");
+creatureLoadFrame:RegisterEvent("CREATURE_DATA_LOAD_RESULT");
+creatureLoadFrame:SetScript("OnEvent", function(self, event, creatureID, success)
+	local pending = pendingMount;
+	if ( not pending or creatureID ~= pending.creatureID ) then
+		return;
+	end
+	pendingMount = nil;
+	if ( success ) then
+		DressUpMount(pending.mountID, pending.forcedFrame, false, pending.link);
+	end
+end);
+
+-- Control-click on a mount in the spellbook previews it. Retail has no such
+-- click (its mounts are in the mount journal); this client keeps mounts in
+-- the spellbook, where stock 1.12.1 casts on a Control-click. A mount spell
+-- never casts here, even while its creature loads; any other spell does.
+local originalSpellButtonOnClick = SpellButton_OnClick;
+function SpellButton_OnClick(drag)
+	if ( not drag and IsControlKeyDown() and SpellBookFrame.bookType ~= BOOKTYPE_PET ) then
+		local id = SpellBook_GetSpellID(this:GetID());
+		local link = id <= MAX_SPELLS and GetSpellLink(id, SpellBookFrame.bookType);
+		if ( link and C_MountJournal.GetMountFromSpell(link) ) then
+			this:SetChecked("false");
+			DressUpMountLink(link);
+			return;
+		end
+	end
+	return originalSpellButtonOnClick(drag);
 end
@@ -0,0 +1,27 @@
+<Ui xmlns="http://www.blizzard.com/wow/ui/" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://www.blizzard.com/wow/ui/
+..\FrameXML\UI.xsd">
+	<!-- The dressing room's mount mode (DressUpFrame.lua): a scene shown in
+	     place of DressUpModel, with retail's control frame. Like retail's, it
+	     fills the backdrop above the buttons: the four DressUpBackground
+	     textures, cut off at the top of the Reset / Close row (centred 422
+	     below the frame top, 22 tall, so 48 above the backdrop's bottom).
+	     DressUpModel's own rect is no guide: it is a scale 2 frame that
+	     reaches past the backdrop and over the buttons. -->
+	<ModelScene name="DressUpFrameModelScene" parent="DressUpFrame" inherits="ModelSceneMixinTemplate" hidden="true">
+		<Anchors>
+			<Anchor point="TOPLEFT" relativeTo="DressUpBackgroundTopLeft"/>
+			<Anchor point="BOTTOMRIGHT" relativeTo="DressUpBackgroundBotRight">
+				<Offset>
+					<AbsDimension x="0" y="48"/>
+				</Offset>
+			</Anchor>
+		</Anchors>
+		<Frames>
+			<Frame parentKey="ControlFrame" inherits="ModelSceneControlFrameTemplate">
+				<Anchors>
+					<Anchor point="TOP" x="0" y="-10"/>
+				</Anchors>
+			</Frame>
+		</Frames>
+	</ModelScene>
+</Ui>
@@ -0,0 +1,103 @@
+-- Verbatim backport of retail's Blizzard_SharedXML/Shared/ModelSceneCameras/CameraBaseMixin.lua.
+
+
+CameraBaseMixin = {};
+
+function CameraBaseMixin:SetOwningScene(owningScene)
+	if self.owningScene ~= owningScene then
+		if self.owningScene then
+			self:OnRemoved();
+		end
+
+		self.owningScene = owningScene;
+
+		if self.owningScene then
+			self:OnAdded();
+		end
+	end
+end
+
+function CameraBaseMixin:GetOwningScene()
+	return self.owningScene;
+end
+
+CAMERA_TRANSITION_TYPE_IMMEDIATE = 1; -- Switch to the camera view instantly
+CAMERA_TRANSITION_TYPE_INTERPOLATION = 2;  -- Switch to the camera view by interpolating from the current view
+
+CAMERA_MODIFICATION_TYPE_DISCARD = 1; -- Discard any modifications performed to the view by script
+CAMERA_MODIFICATION_TYPE_MAINTAIN = 2;  -- Retain any modifications performed to the view by script
+
+-- Override this to handle transitions to a modelSceneCamera data set
+function CameraBaseMixin:ApplyFromModelSceneCameraInfo(modelSceneCameraInfo, transitionType, modificationType)
+
+end
+
+-- Common accessors from the owning scene
+function CameraBaseMixin:IsLeftMouseButtonDown()
+	return self:GetOwningScene():IsLeftMouseButtonDown();
+end
+
+function CameraBaseMixin:IsRightMouseButtonDown()
+	return self:GetOwningScene():IsRightMouseButtonDown();
+end
+
+function CameraBaseMixin:SetPosition(x, y, z)
+	self:GetOwningScene():SetCameraPosition(x, y, z);
+end
+
+function CameraBaseMixin:GetPosition()
+	return self:GetOwningScene():GetCameraPosition();
+end
+
+function CameraBaseMixin:GetForwardVector()
+	return self:GetOwningScene():GetCameraForward();
+end
+
+function CameraBaseMixin:GetRightVector()
+	return self:GetOwningScene():GetCameraRight();
+end
+
+function CameraBaseMixin:GetUpVector()
+	return self:GetOwningScene():GetCameraUp();
+end
+
+-- Override this with a uniquely identifying name for the camera type
+function CameraBaseMixin:GetCameraType()
+	return "UnknownCamera";
+end
+
+-- Override this to perform any per-frame updates
+function CameraBaseMixin:OnUpdate(elapsed)
+end
+
+-- Override this with code to synchronize the camera state with the model scene API, may be called by the ModelScene to synchronize deferred camera state in case it needs to be queried
+function CameraBaseMixin:SynchronizeCamera()
+end
+
+-- Override this to be notified when the mouse is down on the model scene
+function CameraBaseMixin:OnMouseDown(button)
+end
+
+-- Override this to be notified when the mouse is up on the model scene
+function CameraBaseMixin:OnMouseUp(button)
+end
+
+-- Override this to be notified when the mouse wheel is changed on the model scene
+function CameraBaseMixin:OnMouseWheel(delta)
+end
+
+-- Override this to be notified when the camera is added to a scene
+function CameraBaseMixin:OnAdded()
+end
+
+-- Override this to be notified when the camera is remove from a scene
+function CameraBaseMixin:OnRemoved()
+end
+
+-- Override this to be notified when the camera becomes activated
+function CameraBaseMixin:OnActivated()
+end
+
+-- Override this to be notified when the camera becomes deactivated
+function CameraBaseMixin:OnDeactivated()
+end
@@ -0,0 +1,18 @@
+-- Verbatim backport of retail's Blizzard_SharedXML/Shared/ModelSceneCameras/CameraRegistry.lua.
+
+
+CameraRegistry = { cameraTypeToFactoryFunction = {}, };
+
+function CameraRegistry:AddCameraFactory(cameraTypeName, factoryFunction)
+	self.cameraTypeToFactoryFunction[cameraTypeName] = factoryFunction;
+end
+
+function CameraRegistry:AddCameraFactoryFromMixin(cameraTypeName, mixin)
+	self:AddCameraFactory(cameraTypeName, function() return CreateFromMixins(mixin); end);
+end
+
+function CameraRegistry:CreateCameraByType(cameraTypeName)
+	if self.cameraTypeToFactoryFunction[cameraTypeName] then
+		return self.cameraTypeToFactoryFunction[cameraTypeName]();
+	end
+end
@@ -0,0 +1,133 @@
+-- ClassicAPI extension: an orbit camera that follows an actor and stops in
+-- front of the WMO between the actor and the eye.
+
+--[[
+	FollowCameraMixin - An OrbitCamera whose target is an actor's pivot: its position, raised by the pivot height.
+
+	The pivot height is the one the world's follow camera eases to for a unit (actor:GetCameraPivotHeight), and
+	it eases the same way: the camera's first height is taken at once (BeginHeightTransition 0x00512790), and
+	each new one is armed (ArmHeight 0x005126B0) for |change| / cameraHeightSmoothSpeed seconds and eased with
+	the camera's cosine curve (0x0050F160). Until the actor's model has loaded, the camera waits, as the world's
+	does (0x0050E900).
+
+	The eye is placed the way the world's follow camera places it (the boom sweep of its solver 0x0050E570):
+	a trace of the camera's faces from the pivot to the eye (0x0050E816) shortens the distance, which then
+	backs off 1/9 yard (0x0050E871 to 0x0050E8A4). With no actor to follow, it is a plain OrbitCamera.
+
+	Create it beside the scene's own camera and give it that camera's settings:
+		local _, cameraIDs = C_ModelInfo.GetModelSceneInfoByID(modelSceneID);
+		local camera = scene:AddCamera(CameraRegistry:CreateCameraByType("FollowCamera"));
+		camera:ApplyFromModelSceneCameraInfo(C_ModelInfo.GetModelSceneCameraInfoByID(cameraIDs[1]), CAMERA_TRANSITION_TYPE_IMMEDIATE, CAMERA_MODIFICATION_TYPE_DISCARD);
+		camera:SetFollowActor(actor);
+		scene:SetActiveCamera(camera);
+]]
+
+FollowCameraMixin = CreateFromMixins(OrbitCameraMixin);
+
+local CAMERA_NAME = "FollowCamera";
+CameraRegistry:AddCameraFactoryFromMixin(CAMERA_NAME, FollowCameraMixin);
+
+-- The solver skips the sweep when the distance is not past the near clip by
+-- more than this (0x008026BC, 2^-20).
+local SWEEP_MIN_DISTANCE = 9.5367431640625e-07;
+-- A distance shortened by more than this (0x008029D4, 2^-22) backs off by
+-- BOOM_BACKOFF (0x00808A00, 1/9 yard), to no less than 0.
+local SHORTENED_EPSILON = 2.384185791015625e-07;
+local BOOM_BACKOFF = 1 / 9;
+-- A height within this of the armed or the live one arms nothing (0x00801360).
+local ARM_EPSILON = 0.001;
+-- The ease runs while the live height is this far or more from its target
+-- (0x008029D4, 2^-22).
+local EASE_EPSILON = 2.384185791015625e-07;
+
+-- "public" functions
+function FollowCameraMixin:GetCameraType() -- override
+	return CAMERA_NAME;
+end
+
+-- The target becomes the actor's pivot. Nil stops following.
+function FollowCameraMixin:SetFollowActor(actor)
+	self.followActor = actor;
+end
+
+function FollowCameraMixin:GetFollowActor()
+	return self.followActor;
+end
+
+-- "private" functions
+
+-- ArmHeight (0x005126B0) with no delay and a factor of 1, and its inner
+-- BeginHeightTransition (0x00512790).
+function FollowCameraMixin:ArmPivotHeight(height, now)
+	local live = self.pivotHeight or 0;
+	if self.pivotEasing and math.abs(self.pivotTarget - height) < ARM_EPSILON then
+		return;
+	end
+	if math.abs(live - height) < ARM_EPSILON then
+		return;
+	end
+	self.pivotTarget = height;
+	if not self.pivotSnapped then
+		self.pivotSnapped = true;
+		self.pivotHeight = height;
+		self.pivotEasing = false;
+		return;
+	end
+	self.pivotFrom = live;
+	self.pivotStart = now;
+	self.pivotDuration = math.abs(height - live) / tonumber(GetCVar("cameraHeightSmoothSpeed"));
+	self.pivotEasing = true;
+end
+
+-- The height channel of the camera's ease (0x0050F160).
+function FollowCameraMixin:EasePivotHeight(now)
+	if math.abs(self.pivotTarget - self.pivotHeight) < EASE_EPSILON then
+		self.pivotEasing = false;
+		return;
+	end
+	if not self.pivotEasing or self.pivotStart > now then
+		return;
+	end
+	local t = (now - self.pivotStart) / self.pivotDuration;
+	if t >= 1 then
+		self.pivotHeight = self.pivotTarget;
+	else
+		self.pivotHeight = self.pivotFrom + (self.pivotTarget - self.pivotFrom) * (1 - math.cos(math.pi * t)) * 0.5;
+	end
+end
+
+function FollowCameraMixin:OnUpdate(elapsed) -- override
+	local actor = self.followActor;
+	if actor then
+		local height = actor:GetCameraPivotHeight(self:GetZoomDistance());
+		if not height then
+			return;
+		end
+		local now = GetTime();
+		self:ArmPivotHeight(height, now);
+		self:EasePivotHeight(now);
+		local x, y, z = actor:GetPosition();
+		self:SetTarget(x, y, z + self.pivotHeight);
+	end
+	OrbitCameraMixin.OnUpdate(self, elapsed);
+end
+
+function FollowCameraMixin:CalculatePositionByDistanceFromTarget(targetX, targetY, targetZ, zoomDistance, axisAngleX, axisAngleY, axisAngleZ) -- override
+	if not self.followActor then
+		return OrbitCameraMixin.CalculatePositionByDistanceFromTarget(self, targetX, targetY, targetZ, zoomDistance, axisAngleX, axisAngleY, axisAngleZ);
+	end
+
+	local scene = self:GetOwningScene();
+	local distance = zoomDistance;
+	if distance - scene:GetCameraNearClip() > SWEEP_MIN_DISTANCE then
+		local eyeX, eyeY, eyeZ = OrbitCameraMixin.CalculatePositionByDistanceFromTarget(self, targetX, targetY, targetZ, distance, axisAngleX, axisAngleY, axisAngleZ);
+		local _, _, _, _, _, _, fraction = scene:TraceSegment(targetX, targetY, targetZ, eyeX, eyeY, eyeZ, true);
+		if fraction then
+			distance = distance * fraction;
+		end
+		if math.abs(zoomDistance - distance) > SHORTENED_EPSILON then
+			distance = math.max(distance - BOOM_BACKOFF, 0);
+		end
+	end
+	return OrbitCameraMixin.CalculatePositionByDistanceFromTarget(self, targetX, targetY, targetZ, distance, axisAngleX, axisAngleY, axisAngleZ);
+end
@@ -0,0 +1,144 @@
+-- Verbatim backport of retail's Blizzard_SharedXML/ModelSceneActorMixin.lua.
+
+
+ModelSceneActorMixin = {};
+
+-- "public" methods
+function ModelSceneActorMixin:ApplyFromModelSceneActorInfo(actorInfo)
+	self:SetUseCenterForOrigin(actorInfo.useCenterForOriginX, actorInfo.useCenterForOriginY, actorInfo.useCenterForOriginZ);
+
+	self:SetPosition(actorInfo.position:GetXYZ());
+	self:SetYaw(actorInfo.yaw);
+	self:SetPitch(actorInfo.pitch);
+	self:SetRoll(actorInfo.roll);
+
+	self.requestedScale = nil;
+
+	local actorDisplayInfo = actorInfo.modelActorDisplayID and C_ModelInfo.GetModelSceneActorDisplayInfoByID(actorInfo.modelActorDisplayID);
+	if actorDisplayInfo then
+		if actorDisplayInfo.animationKitID then
+			self:PlayAnimationKit(actorDisplayInfo.animationKitID);
+		else
+			self:SetAnimation(actorDisplayInfo.animation, actorDisplayInfo.animationVariation, actorDisplayInfo.animSpeed);
+		end
+
+		self:SetSpellVisualKit(actorDisplayInfo.spellVisualKitID);
+		
+		self:SetAlpha(actorDisplayInfo.alpha);
+		self:SetRequestedScale(actorDisplayInfo.scale);
+	else
+		self:StopAnimationKit();
+		self:SetSpellVisualKit(nil);
+		self:SetAnimation(0, 0, 1.0);
+		self:SetAlpha(1.0);
+		self:SetRequestedScale(1.0);
+	end
+
+	self:SetNormalizedScaleAggressiveness(actorInfo.normalizeScaleAggressiveness or 0.0);
+
+	self:MarkScaleDirty();
+	self:UpdateScale();
+
+	C_ModelInfo.AddActiveModelSceneActor(self, actorInfo.modelActorID);
+end
+
+function ModelSceneActorMixin:OnModelCleared()
+	C_ModelInfo.ClearActiveModelSceneActor(self);
+end
+
+function ModelSceneActorMixin:SetOnSizeChangedCallback(onSizeChangedCallback)
+	self.onSizeChangedCallback = onSizeChangedCallback;
+end
+
+function ModelSceneActorMixin:GetOnSizeChangedCallback()
+	return self.onSizeChangedCallback;
+end
+
+function ModelSceneActorMixin:SetOnModelLoadedCallback(onModelLoadedCallback)
+	self.onModelLoadedCallback = onModelLoadedCallback;
+end
+
+function ModelSceneActorMixin:GetOnModelLoadedCallback()
+	return self.onModelLoadedCallback;
+end
+
+function ModelSceneActorMixin:SetNormalizedScaleAggressiveness(normalizedScaleAggressiveness)
+	if self.normalizedScaleAggressiveness ~= normalizedScaleAggressiveness then
+		self.normalizedScaleAggressiveness = normalizedScaleAggressiveness;
+		self:MarkScaleDirty();
+	end
+end
+
+function ModelSceneActorMixin:GetNormalizedScaleAggressiveness()
+	return self.normalizedScaleAggressiveness or 0;
+end
+
+function ModelSceneActorMixin:SetRequestedScale(requestedScale)
+	if self.requestedScale ~= requestedScale then
+		self.requestedScale = requestedScale;
+		self:MarkScaleDirty();
+	end
+end
+
+function ModelSceneActorMixin:GetRequestedScale()
+	return self.requestedScale or self:GetScale();
+end
+
+MODEL_SCENE_ACTOR_DIMENSIONS_FOR_NORMALIZATION = { width = .9984, depth = 1.121, height = 2.118 }; -- Roughly the dimensions of a human male model (but why male models?)
+function ModelSceneActorMixin:CalculateNormalizedScale(normalizedScaleAggressiveness)
+	if self:IsLoaded() and normalizedScaleAggressiveness > 0.0 then
+		local bottomX, bottomY, bottomZ, topX, topY, topZ = self:GetActiveBoundingBox(); -- Could be nil for invisible models
+		if bottomX and bottomY and bottomZ and topX and topY and topZ then
+			local width = topX - bottomX;
+			local depth = topY - bottomY;
+			local height = topZ - bottomZ;
+
+			local widthScale = width / MODEL_SCENE_ACTOR_DIMENSIONS_FOR_NORMALIZATION.width;
+			local depthScale = depth / MODEL_SCENE_ACTOR_DIMENSIONS_FOR_NORMALIZATION.depth;
+			local heightScale = height / MODEL_SCENE_ACTOR_DIMENSIONS_FOR_NORMALIZATION.height;
+
+			local maxScale = math.max(widthScale, math.max(depthScale, heightScale));
+			if maxScale == 0 then
+				return 1.0;
+			end
+
+			return 1 / Lerp(1.0, maxScale, normalizedScaleAggressiveness);
+		end
+	end
+
+	return 1.0;
+end
+
+-- "private" methods
+function ModelSceneActorMixin:OnReleased()
+	self:SetOnSizeChangedCallback(nil);
+	self:SetOnModelLoadedCallback(nil);
+end
+
+function ModelSceneActorMixin:OnUpdate()
+	self:UpdateScale();
+end
+
+function ModelSceneActorMixin:OnModelLoaded()
+	self:MarkScaleDirty();
+
+	if self.onModelLoadedCallback then
+		self.onModelLoadedCallback(self);
+	end
+end
+
+function ModelSceneActorMixin:UpdateScale()
+	if self.scaleDirty and self:IsLoaded() then
+		self.scaleDirty = nil;
+		local effectiveScale = self:GetRequestedScale() * self:CalculateNormalizedScale(self:GetNormalizedScaleAggressiveness());
+		self:SetScale(effectiveScale);
+
+		if self.onSizeChangedCallback then
+			self.onSizeChangedCallback(self);
+		end
+	end
+end
+
+function ModelSceneActorMixin:MarkScaleDirty()
+	self.scaleDirty = true;
+end
@@ -0,0 +1,10 @@
+<Ui xmlns="http://www.blizzard.com/wow/ui/" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://www.blizzard.com/wow/ui/
+UI.xsd">
+	<Actor name="ModelSceneActorTemplate" mixin="ModelSceneActorMixin" virtual="true">
+		<Scripts>
+			<OnModelCleared method="OnModelCleared" />
+			<OnModelLoaded method="OnModelLoaded" />
+			<OnUpdate method="OnUpdate" />
+		</Scripts>
+	</Actor>
+</Ui>
@@ -0,0 +1,282 @@
+-- Verbatim backport of retail's Blizzard_SharedXML/ModelSceneControlFrame.lua.
+
+
+local DEFAULT_ZOOM_INCREMENT = 1;
+local DEFAULT_ROTATE_INCREMENT = 0.05;
+
+--------------------------------------------------
+-- MODEL SCENE CONTROL FRAME MIXIN
+ModelSceneControlFrameMixin = {};
+function ModelSceneControlFrameMixin:OnLoad()
+	if self.enableZoom then
+		local increment = self:GetZoomIncrement();
+		self.zoomInButton:SetZoomAmount(increment);
+		self.zoomInButton:Init();
+
+		self.zoomOutButton:SetZoomAmount(-increment);
+		self.zoomOutButton:Init();
+	end
+	self.zoomInButton:SetShown(self.enableZoom);
+	self.zoomOutButton:SetShown(self.enableZoom);
+
+	if self.enableRotate then
+		local increment = self:GetRotateIncrement();
+		self.rotateLeftButton:SetRotation("left");
+		self.rotateLeftButton:SetRotationIncrement(increment);
+		self.rotateLeftButton:Init();
+
+		self.rotateRightButton:SetRotation("right");
+		self.rotateRightButton:SetRotationIncrement(increment);
+		self.rotateRightButton:Init();
+	end
+	self.rotateLeftButton:SetShown(self.enableRotate);
+	self.rotateRightButton:SetShown(self.enableRotate);
+
+	if self.enableReset then
+		self.resetButton:Init();
+	end
+	self.resetButton:SetShown(self.enableReset);
+end
+
+function ModelSceneControlFrameMixin:OnShow()
+	self:UpdateLayout();
+end
+
+function ModelSceneControlFrameMixin:OnEnter()
+	self:SetAlpha(1);
+end
+
+function ModelSceneControlFrameMixin:OnLeave()
+	self:SetAlpha(0.5);
+end
+
+function ModelSceneControlFrameMixin:SetZoomIncrement(increment)
+	self.zoomIncrement = increment or DEFAULT_ZOOM_INCREMENT;
+end
+
+function ModelSceneControlFrameMixin:GetZoomIncrement()
+	return self.zoomIncrement or DEFAULT_ZOOM_INCREMENT;
+end
+
+function ModelSceneControlFrameMixin:SetRotateIncrement(increment)
+	self.rotationIncrement = increment or DEFAULT_ROTATE_INCREMENT;
+end
+
+function ModelSceneControlFrameMixin:GetRotateIncrement()
+	return self.rotationIncrement or DEFAULT_ROTATE_INCREMENT;
+end
+
+function ModelSceneControlFrameMixin:SetModelScene(modelScene)
+	self.modelScene = modelScene;
+
+	self.zoomInButton:SetModelScene(modelScene);
+	self.zoomOutButton:SetModelScene(modelScene);
+	self.rotateLeftButton:SetModelScene(modelScene);
+	self.rotateRightButton:SetModelScene(modelScene);
+	self.resetButton:SetModelScene(modelScene);
+end
+
+function ModelSceneControlFrameMixin:UpdateLayout()
+	local lastButton;
+	local hPadding = self.buttonHorizontalPadding or 0;
+	local vPadding = 0;
+	local buttonSize = 32;
+	local totalHeight = buttonSize;
+	local totalWidth = 2; -- Initial non-zero total width to prevent flickering from negataive padding
+
+	local function LayoutButton(button)
+		button:ClearAllPoints();
+		if lastButton then
+			button:SetPoint("LEFT", lastButton, "RIGHT", hPadding, vPadding);
+		else
+			button:SetPoint("LEFT", 0, vPadding);
+		end
+		totalWidth = totalWidth + buttonSize + hPadding;
+		lastButton = button;
+	end
+
+	if self.enableZoom then
+		-- Make sure that zoom is supported on the model scene.
+		if self.modelScene then
+			local camera = self.modelScene:GetActiveCamera();
+			self.canZoom = camera ~= nil and camera:GetZoomAvailable();
+			self.zoomInButton:SetShown(self.canZoom);
+			self.zoomOutButton:SetShown(self.canZoom);
+		end
+
+		if self.canZoom then
+			LayoutButton(self.zoomInButton);
+			LayoutButton(self.zoomOutButton);
+		end
+	end
+
+	if self.enableRotate then
+		LayoutButton(self.rotateLeftButton);
+		LayoutButton(self.rotateRightButton);
+	end
+
+	if self.enableReset then
+		LayoutButton(self.resetButton);
+	end
+	self:SetSize(totalWidth, totalHeight);
+end
+
+--------------------------------------------------
+-- MODEL SCENE CONTROL BUTTON MIXIN
+ModelSceneControlButtonMixin = {};
+function ModelSceneControlButtonMixin:Init(clickTypes, atlas, tooltip, tooltipText)
+	self:RegisterForClicks(clickTypes);
+	if atlas then
+		self.Icon:SetAtlas(atlas);
+	end
+	self.tooltip = tooltip;
+	self.tooltipText = tooltipText;
+end
+
+function ModelSceneControlButtonMixin:SetModelScene(modelScene)
+	self.modelScene = modelScene;
+end
+
+function ModelSceneControlButtonMixin:OnMouseDown()
+	self.Icon:AdjustPointsOffset(1, -1);
+	self:GetParent().buttonDown = self;
+end
+
+function ModelSceneControlButtonMixin:OnMouseUp()
+	self.Icon:AdjustPointsOffset(-1, 1);
+	self:GetParent().buttonDown = nil;
+end
+
+function ModelSceneControlButtonMixin:OnClick()
+	--override for your mouse click 
+end
+
+function ModelSceneControlButtonMixin:OnEnter()
+	self:GetParent():SetAlpha(1);
+	if ( GetCVar("UberTooltips") == "1" ) then
+		local tooltip = GetAppropriateTooltip();
+		local topLevelParent = GetAppropriateTopLevelParent();
+		GameTooltip_SetDefaultAnchor(tooltip, topLevelParent);
+		GameTooltip_SetTitle(tooltip, self.tooltip);
+		if ( self.tooltipText ) then
+			GameTooltip_AddBodyLine(tooltip, self.tooltipText);
+		end
+		tooltip:Show();
+	end
+end
+
+function ModelSceneControlButtonMixin:OnLeave()
+	self:GetParent():SetAlpha(0.5);
+
+	local tooltip = GetAppropriateTooltip();
+	tooltip:Hide();
+end
+
+--------------------------------------------------
+-- MODEL ZOOM BUTTON MIXIN
+ModelSceneZoomButtonMixin = CreateFromMixins(ModelSceneControlButtonMixin);
+function ModelSceneZoomButtonMixin:OnLoad()
+	self.zoomAmount = 0;
+end
+
+function ModelSceneZoomButtonMixin:Init()
+	if self.zoomAmount < 0 then
+		ModelSceneControlButtonMixin.Init(self, "AnyUp", "common-icon-zoomout", ZOOM_OUT, KEY_MOUSEWHEELDOWN);
+	else
+		ModelSceneControlButtonMixin.Init(self, "AnyUp", "common-icon-zoomin", ZOOM_IN, KEY_MOUSEWHEELUP);
+	end
+end
+
+function ModelSceneZoomButtonMixin:SetZoomAmount(amountToZoom)
+	self.zoomAmount = amountToZoom;
+end
+
+function ModelSceneZoomButtonMixin:OnClick()
+	if self.modelScene then
+		self.modelScene:OnMouseWheel(self.zoomAmount);
+	else
+		assertsafe(fale, "Model Scene not specified");
+	end
+	PlaySound(SOUNDKIT.IG_INVENTORY_ROTATE_CHARACTER);
+end
+
+--------------------------------------------------
+-- MODEL SCENE ROTATE BUTTON MIXIN
+ModelScenelRotateButtonMixin = CreateFromMixins(ModelSceneControlButtonMixin);
+function ModelScenelRotateButtonMixin:OnLoad()
+	ModelSceneControlButtonMixin.OnLoad(self);
+	self.rotateDirection = "none";
+end
+
+function ModelScenelRotateButtonMixin:Init()
+	if (self.rotateDirection == "left") then
+		ModelSceneControlButtonMixin.Init(self, "AnyUp", "common-icon-rotateleft", ROTATE_LEFT, ROTATE_TOOLTIP);
+	elseif (self.rotateDirection == "right") then
+		ModelSceneControlButtonMixin.Init(self, "AnyUp", "common-icon-rotateright", ROTATE_RIGHT, ROTATE_TOOLTIP);
+	else
+		assertsafe(false, "Invalid rotation specified: "..tostring(self.rotateDirection));
+	end
+end
+
+function ModelScenelRotateButtonMixin:SetRotation(rotation)
+	self.rotateDirection = rotation;
+end
+
+function ModelScenelRotateButtonMixin:SetRotationIncrement(increment)
+	self.rotationIncrement = increment or 0.05;
+end
+
+function ModelScenelRotateButtonMixin:OnMouseDown()
+	ModelSceneControlButtonMixin.OnMouseDown(self);
+	if self.modelScene then
+		self.modelScene:AdjustCameraYaw(self.rotateDirection, self.rotationIncrement);
+	else
+		assertsafe(false, "Model Scene not specified");
+	end
+	PlaySound(SOUNDKIT.IG_INVENTORY_ROTATE_CHARACTER);
+end
+
+function ModelScenelRotateButtonMixin:OnMouseUp()
+	ModelSceneControlButtonMixin.OnMouseUp(self);
+	if self.modelScene then
+		self.modelScene:StopCameraYaw();
+	end
+end
+
+function ModelScenelRotateButtonMixin:OnSmartNavClick()
+	self:RotateStep();
+end
+
+function ModelScenelRotateButtonMixin:RotateStep()
+	local camera = self.modelScene and self.modelScene:GetActiveCamera();
+	if not camera then
+		return;
+	end
+
+	if self.rotateDirection == "left" then
+		camera:AdjustYaw(-1, -1, 0.25);
+	else
+		camera:AdjustYaw(1, 1, 0.25);
+	end
+end
+
+--------------------------------------------------
+-- MODEL SCENE RESET BUTTON MIXIN
+ModelSceneResetButtonMixin = CreateFromMixins(ModelSceneControlButtonMixin);
+function ModelSceneResetButtonMixin:OnLoad()
+	ModelSceneControlButtonMixin.OnLoad(self);
+end
+
+function ModelSceneResetButtonMixin:Init()
+	local tooltipText = nil;
+	ModelSceneControlButtonMixin.Init(self, "AnyUp", "common-icon-undo", RESET_POSITION, tooltipText);
+end
+
+function ModelSceneResetButtonMixin:OnClick()
+	if self.modelScene then
+		self.modelScene:Reset();
+	else
+		assertsafe(false, "Model Scene not specified");
+	end
+	PlaySound(SOUNDKIT.IG_INVENTORY_ROTATE_CHARACTER);
+end
@@ -0,0 +1,67 @@
+<Ui xmlns="http://www.blizzard.com/wow/ui/" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://www.blizzard.com/wow/ui/
+UI.xsd">
+	<!-- Retail's Blizzard_SharedXML/ModelSceneControlFrame.xml. The one change:
+	     HitRectInsets takes this client's <AbsInset> child. The atlases are
+	     built in (src/texture/AtlasData.h, EMBEDDED ART). -->
+	<Button name="ModelSceneControlButtonTemplate" mixin="ModelSceneControlButtonMixin" virtual="true">
+		<Size x="32" y="32"/>
+		<HitRectInsets>
+			<AbsInset left="4" right="4" top="4" bottom="4"/>
+		</HitRectInsets>
+		<Layers>
+			<Layer level="OVERLAY">
+				<Texture parentKey="Icon" >
+					<Size x="16" y="16"/>
+					<Anchors>
+						<Anchor point="CENTER"/>
+					</Anchors>
+				</Texture>
+				<!--<Texture parentKey="Icon" setAllPoints="true" />-->
+			</Layer>
+		</Layers>
+		<Scripts>
+			<OnMouseDown method="OnMouseDown" />
+			<OnMouseUp method="OnMouseUp" />
+			<OnClick method="OnClick" />
+			<OnEnter method="OnEnter" />
+			<OnLeave method="OnLeave" />
+		</Scripts>
+		<NormalTexture parentKey="NormalTexture" atlas="common-button-square-gray-up"/>
+		<HighlightTexture parentKey="HighlightTexture" alphaMode="ADD" alpha="0.4">
+			<Anchors>
+				<Anchor point="TOPLEFT" relativeKey="$parent.Icon" relativePoint="TOPLEFT"/>
+				<Anchor point="BOTTOMRIGHT" relativeKey="$parent.Icon" relativePoint="BOTTOMRIGHT"/>
+			</Anchors>
+		</HighlightTexture>
+		<PushedTexture parentKey="PushedTexture" atlas="common-button-square-gray-down">
+			<Anchors>
+				<Anchor point="TOPLEFT" x="1" y="-1"/>
+				<Anchor point="BOTTOMRIGHT" x="1" y="-1"/>
+			</Anchors>
+		</PushedTexture>
+	</Button>
+	<Frame name="ModelSceneControlFrameTemplate" virtual="true" mixin="ModelSceneControlFrameMixin" alpha="0.5" hidden="true">
+		<Size x="32" y="32"/>
+		<KeyValues>
+			<KeyValue key="enableZoom" value="true" type="boolean" />
+			<KeyValue key="enableRotate" value="true" type="boolean" />
+			<KeyValue key="enableReset" value="true" type="boolean" />
+			<KeyValue key="rotationIncrement" value="0.05" type="number" />
+			<KeyValue key="zoomIncrement" value="1" type="number" />
+			<KeyValue key="buttonHorizontalPadding" value="-6" type="number" />
+		</KeyValues>
+		<Frames>
+			<Button parentKey="zoomInButton" hidden="true" mixin="ModelSceneZoomButtonMixin" inherits="ModelSceneControlButtonTemplate"/>
+			<Button parentKey="zoomOutButton" hidden="true" mixin="ModelSceneZoomButtonMixin" inherits="ModelSceneControlButtonTemplate"/>
+			<Button parentKey="rotateLeftButton" hidden="true" mixin="ModelScenelRotateButtonMixin" inherits="ModelSceneControlButtonTemplate"/>
+			<Button parentKey="rotateRightButton" hidden="true" mixin="ModelScenelRotateButtonMixin" inherits="ModelSceneControlButtonTemplate"/>
+			<Button parentKey="resetButton" hidden="true" mixin="ModelSceneResetButtonMixin" inherits="ModelSceneControlButtonTemplate"/>
+		</Frames>
+		<Scripts>
+			<OnLoad method="OnLoad" />
+			<OnShow method="OnShow" />
+			<OnEnter method="OnEnter" />
+			<OnLeave method="OnLeave" />
+		</Scripts>
+	</Frame>
+</Ui>
@@ -0,0 +1,571 @@
+-- Backport of retail's Blizzard_SharedXML/ModelSceneMixin.lua, verbatim except where
+-- marked "ClassicAPI:".
+
+
+ModelSceneMixin = {}
+
+-- "public" functions
+function ModelSceneMixin:OnLoad()
+	self.cameras = {};
+	self.actorTemplate = "ModelSceneActorTemplate";
+	self.tagToActor = {};
+	self.tagToCamera = {};
+
+	if self.allowOverlappedModels then
+		self:SetAllowOverlappedModels(true);
+	end
+end
+
+function ModelSceneMixin:ClearScene()
+	self.modelSceneID = nil;
+
+	self:ReleaseAllActors();
+	self:ReleaseAllCameras();
+
+	C_ModelInfo.ClearActiveModelScene(self);
+end
+
+function ModelSceneMixin:GetModelSceneID()
+	return self.modelSceneID; 
+end
+
+-- Adjusts this scene to mirror a model scene from static data without transition
+function ModelSceneMixin:SetFromModelSceneID(modelSceneID, forceEvenIfSame, noAutoCreateActors)
+	local modelSceneType, cameraIDs, actorIDs = C_ModelInfo.GetModelSceneInfoByID(modelSceneID);
+	if not modelSceneType then
+		return;
+	end
+
+	if self.modelSceneID ~= modelSceneID or forceEvenIfSame then
+		self.modelSceneID = modelSceneID;
+		self:ReleaseAllActors();
+		self:ReleaseAllCameras();
+
+		if not noAutoCreateActors then
+			for actorIndex, actorID in ipairs(actorIDs) do
+				self:CreateActorFromScene(actorID);
+			end
+		end
+
+		for cameraIndex, cameraID in ipairs(cameraIDs) do
+			self:CreateCameraFromScene(cameraID);
+		end
+	end
+
+	C_ModelInfo.AddActiveModelScene(self, self.modelSceneID);
+	EventRegistry:TriggerEvent("ModelScene.SetFromModelSceneID", self, self.modelSceneID);
+end
+
+function ModelSceneMixin:SetResetCallback(callback)
+	self.resetCallback = callback;
+end
+
+function ModelSceneMixin:Reset()
+	if self.modelSceneID then
+		self:TransitionToModelSceneID(self.modelSceneID, self.cameraTransitionType, self.cameraModificationType, self.forceEvenIfSame);
+		if self.resetCallback then
+			self.resetCallback(self);
+		end
+	end
+end
+
+-- Adjusts this scene to mirror a model scene from static data but with transition effects
+-- Only actors/cameras with script tags will be transitioned
+function ModelSceneMixin:TransitionToModelSceneID(modelSceneID, cameraTransitionType, cameraModificationType, forceEvenIfSame)
+	local modelSceneType, cameraIDs, actorIDs = C_ModelInfo.GetModelSceneInfoByID(modelSceneID);
+	if not modelSceneType or #cameraIDs == 0 or #actorIDs == 0 then
+		return;
+	end
+
+	if self.modelSceneID ~= modelSceneID or forceEvenIfSame then
+		self.modelSceneID = modelSceneID;
+		self.cameraTransitionType = cameraTransitionType;
+		self.cameraModificationType = cameraModificationType;
+		self.forceEvenIfSame = forceEvenIfSame;
+
+		local actorsToRelease = {};
+		for actor in self:EnumerateActiveActors() do
+			actorsToRelease[actor] = true;
+		end
+
+		local oldTagToActor = self.tagToActor;
+		self.tagToActor = {};
+
+		for actorIndex, actorID in ipairs(actorIDs) do
+			local actor = self:CreateOrTransitionActorFromScene(oldTagToActor, actorID);
+			if actor then
+				actorsToRelease[actor] = nil;
+			end
+		end
+
+		for actor in pairs(actorsToRelease) do
+			self.actorPool:Release(actor);
+		end
+
+		local oldTagToCamera = self.tagToCamera;
+		self.tagToCamera = {};
+
+		self.cameras = {};
+
+		local needsNewCamera = true;
+		for cameraIndex, cameraID in ipairs(cameraIDs) do
+			local camera = self:CreateOrTransitionCameraFromScene(oldTagToCamera, cameraTransitionType, cameraModificationType, cameraID);
+			if camera == self.activeCamera then
+				needsNewCamera = false;
+			end
+		end
+
+		if needsNewCamera then
+			self:SetActiveCamera(self.cameras[1]);
+		end
+	end
+
+	C_ModelInfo.AddActiveModelScene(self, self.modelSceneID);
+	EventRegistry:TriggerEvent("ModelScene.TransitionToModelSceneID", self, self.modelSceneID);
+end
+
+-- There may be inactive (pooled) actors maintained by this scene, these function only returns the active actors
+function ModelSceneMixin:GetNumActiveActors()
+	return self.actorPool and self.actorPool:GetNumActive() or 0;
+end
+
+function ModelSceneMixin:EnumerateActiveActors()
+	if self.actorPool then
+		return self.actorPool:EnumerateActive();
+	end
+	return nop;
+end
+
+function ModelSceneMixin:GetActorByTag(tag)
+	return self.tagToActor[tag];
+end
+
+function ModelSceneMixin:AttachPlayerToMount(mountActor, animID, isSelfMount, disablePlayerMountPreview, spellVisualKitID, usePlayerNativeForm, optionalPlayerRiderTag)
+	local playerRiderTag = optionalPlayerRiderTag or "player-rider";
+	local playerActor = self:GetPlayerActor(playerRiderTag);
+	if (playerActor) then
+		if disablePlayerMountPreview or isSelfMount then
+			playerActor:ClearModel();
+		else
+			local sheatheWeapons = true;
+			local autoDress = true;
+			local hideWeapons = true;
+
+			if C_Glue.IsOnGlueScreen() then
+				local characterIndex = nil;  -- defaults to selected character.
+				playerActor:SetPlayerModelFromGlues(characterIndex, sheatheWeapons, autoDress, hideWeapons, usePlayerNativeForm);
+			else
+				playerActor:SetModelByUnit("player", sheatheWeapons, autoDress, hideWeapons, usePlayerNativeForm);
+			end
+			local calcMountScale = mountActor:CalculateMountScale(playerActor);
+			local inverseScale = 1 / calcMountScale; 
+			playerActor:SetRequestedScale( inverseScale );
+			mountActor:AttachToMount(playerActor, animID, spellVisualKitID);
+		end
+	end
+end
+
+function GetPlayerActorLabelTag(forceAlternateForm, overrideRaceFilename, overrideGender)
+	local playerRaceName = overrideRaceFilename;
+	local playerGender = overrideGender;
+	local playerRaceNameActorTag = nil;
+	local hasAlternateForm, inAlternateForm = false, false;
+	if not overrideRaceFilename or not overrideGender then
+	if C_Glue.IsOnGlueScreen() then
+		local characterGuid = GetCharacterGUID(GetCharacterSelection());
+		if characterGuid then
+			local basicCharacterInfo = GetBasicCharacterInfo(characterGuid);
+				playerRaceName = overrideRaceFilename or basicCharacterInfo.raceFilename;
+				playerGender = overrideGender or basicCharacterInfo.genderEnum;
+		end
+	else
+		hasAlternateForm, inAlternateForm = C_PlayerInfo.GetAlternateFormInfo();
+		local _, raceFilename = UnitRace("player");
+			playerRaceName = overrideRaceFilename or raceFilename;
+			playerGender = overrideGender or UnitSex("player");
+		end
+	end
+	if not playerRaceName or not playerGender then
+		return playerRaceName, playerRaceNameActorTag;
+	end
+	playerRaceName = playerRaceName:lower();
+	if hasAlternateForm and (inAlternateForm or forceAlternateForm) then
+		playerRaceName = playerRaceName.."-alt";
+	end
+	playerGender = (playerGender == 2) and "male" or "female";
+	playerRaceNameActorTag = playerRaceName.."-"..playerGender;
+	return playerRaceName, playerRaceNameActorTag;
+end
+
+function ModelSceneMixin:GetPlayerActor(overrideActorName, forceAlternateForm, overrideRaceFilename, overrideGender)
+	local actor;
+	if overrideActorName then
+		actor = self:GetActorByTag(overrideActorName);
+	else
+		local playerRaceName, playerRaceNameActorTag = GetPlayerActorLabelTag(forceAlternateForm, overrideRaceFilename, overrideGender);
+		actor = self:GetActorByTag(playerRaceNameActorTag);
+		if not actor then		
+			actor = self:GetActorByTag(playerRaceName);
+			if not actor then
+				actor = self:GetActorByTag("player");
+				if not actor then
+					actor = self:GetActorByTag("player-rider");
+				end
+			end
+		end
+	end
+	return actor;
+end
+
+function ModelSceneMixin:ReleaseAllActors()
+	if self.actorPool then
+		self.actorPool:ReleaseAll();
+
+		if self.dropShadowPool then
+			self.dropShadowPool:ReleaseAll();
+		end
+
+		self.tagToActor = {};
+	end
+end
+
+local function OnReleased(actorPool, actor)
+	actor:OnReleased();
+	ActorPool_HideAndClearModel(actorPool, actor);
+end
+
+function ModelSceneMixin:AcquireActor()
+	if not self.actorPool then
+		self.actorPool = CreateActorPool(self, self.actorTemplate, OnReleased);
+	end
+	return self.actorPool:Acquire();
+end
+
+function ModelSceneMixin:ReleaseActor(actor)
+	if not actor or not self.actorPool then
+		return;
+	end
+
+	for tag, taggedActor in pairs(self.tagToActor) do
+		if actor == taggedActor then
+			self.tagToActor[tag] = nil;
+			break;
+		end
+	end
+
+	if actor.dropShadowTexture then
+		self.dropShadowPool:Release(actor.dropShadowTexture);
+	end
+
+	return self.actorPool:Release(actor);
+end
+
+function ModelSceneMixin:AcquireAndInitializeActor(actorInfo)
+	local actor = self:AcquireActor();
+	self:InitializeActor(actor, actorInfo);
+	return actor;
+end
+
+function ModelSceneMixin:ReleaseAllCameras()
+	self:SetActiveCamera(nil);
+	for i = #self.cameras, 1, -1 do
+		self.cameras[i]:SetOwningScene(nil);
+		self.cameras[i] = nil;
+	end
+	self.tagToCamera = {};
+end
+
+function ModelSceneMixin:GetCameraByTag(tag)
+	return self.tagToCamera[tag];
+end
+
+function ModelSceneMixin:AddCamera(camera)
+	table.insert(self.cameras, camera);
+
+	camera:SetOwningScene(self);
+
+	if not self:HasActiveCamera() then
+		self:SetActiveCamera(camera);
+	end
+
+	return camera;
+end
+
+function ModelSceneMixin:HasActiveCamera()
+	return self.activeCamera ~= nil;
+end
+
+function ModelSceneMixin:GetActiveCamera()
+	return self.activeCamera;
+end
+
+function ModelSceneMixin:SetActiveCamera(camera)
+	if camera ~= self.activeCamera then
+		if self.activeCamera then
+			self.activeCamera:OnDeactivated();
+		end
+
+		self.activeCamera = camera;
+
+		if self.activeCamera then
+			self.activeCamera:OnActivated();
+		end
+	end
+end
+
+function ModelSceneMixin:IsLeftMouseButtonDown()
+	return self.isLeftButtonDown;
+end
+
+function ModelSceneMixin:IsRightMouseButtonDown()
+	return self.isRightButtonDown;
+end
+
+function ModelSceneMixin:Transform3DPointTo2D(x, y, z)
+	self:SynchronizeActiveCamera();
+	return self:Project3DPointTo2D(x, y, z);
+end
+
+-- "private" functions
+function ModelSceneMixin:OnUpdate(elapsed)
+	if self.activeCamera then
+		local yawDirection = self.yawDirection;
+		-- ClassicAPI: retail turns by the increment every frame, which spins
+		-- several times faster at this client's uncapped frame rates. The
+		-- increment counts per 1/60 s here: 0.05 is 3 rad/s, the speed of
+		-- 1.12's own rotate buttons (ROTATIONS_PER_SECOND, pi rad/s).
+		local increment = self.increment and self.increment * elapsed * 60;
+		if yawDirection == "left" then
+			self.activeCamera:AdjustYaw(-1, -1, increment);
+		elseif yawDirection == "right" then
+			self.activeCamera:AdjustYaw(1, 1, increment);
+		end
+
+		self.activeCamera:OnUpdate(elapsed);
+	end
+end
+
+function ModelSceneMixin:SynchronizeActiveCamera()
+	if self.activeCamera then
+		self.activeCamera:SynchronizeCamera();
+	end
+end
+
+function ModelSceneMixin:OnEnter(button)
+	if self.ControlFrame then
+		self.ControlFrame:Show();
+	end
+end
+
+function ModelSceneMixin:OnLeave(button)
+	if self.ControlFrame then
+		if not self.ControlFrame:IsMouseOver()then
+			self.ControlFrame:Hide();
+		end
+	end
+end
+
+function ModelSceneMixin:OnMouseDown(button)
+	if button == "LeftButton" then
+		self.isLeftButtonDown = true;
+	elseif button == "RightButton" then
+		self.isRightButtonDown = true;
+	end
+
+	if self.activeCamera then
+		self.activeCamera:OnMouseDown(button);
+	end
+end
+
+function ModelSceneMixin:OnMouseUp(button)
+	if button == "LeftButton" then
+		self.isLeftButtonDown = false;
+	elseif button == "RightButton" then
+		self.isRightButtonDown = false;
+	end
+
+	if self.activeCamera then
+		self.activeCamera:OnMouseUp(button);
+	end
+end
+
+function ModelSceneMixin:OnMouseWheel(delta)
+	if self.activeCamera then
+		self.activeCamera:OnMouseWheel(delta);
+	end
+end
+
+function ModelSceneMixin:AdjustCameraYaw(direction, increment)
+	if self.activeCamera then
+		self.yawDirection = direction;
+		self.increment = increment;
+	end
+end
+
+function ModelSceneMixin:StopCameraYaw()
+	self.yawDirection = nil;
+	self.increment = nil;
+end
+
+function ModelSceneMixin:InitializeActor(actor, actorInfo)
+	if actorInfo.scriptTag then
+		self.tagToActor[actorInfo.scriptTag] = actor;
+	end
+
+	actor:ApplyFromModelSceneActorInfo(actorInfo);
+
+	actor:Show();
+end
+
+function ModelSceneMixin:CreateActorFromScene(actorID)
+	local actorInfo = C_ModelInfo.GetModelSceneActorInfoByID(actorID);
+	return self:AcquireAndInitializeActor(actorInfo);
+end
+
+function ModelSceneMixin:CreateOrTransitionActorFromScene(oldTagToActor, actorID)
+	local actorInfo = C_ModelInfo.GetModelSceneActorInfoByID(actorID);
+	local existingActor = oldTagToActor[actorInfo.scriptTag];
+	if existingActor then
+		self:InitializeActor(existingActor, actorInfo);
+		return existingActor;
+	end
+
+	return self:AcquireAndInitializeActor(actorInfo);
+end
+
+function ModelSceneMixin:CreateCameraFromScene(modelSceneCameraID)
+	local modelSceneCameraInfo = C_ModelInfo.GetModelSceneCameraInfoByID(modelSceneCameraID);
+	if modelSceneCameraInfo then
+		local camera = CameraRegistry:CreateCameraByType(modelSceneCameraInfo.cameraType);
+		if camera then
+			if modelSceneCameraInfo.scriptTag then
+				self.tagToCamera[modelSceneCameraInfo.scriptTag] = camera;
+			end
+			self:AddCamera(camera);
+			camera:ApplyFromModelSceneCameraInfo(modelSceneCameraInfo, CAMERA_TRANSITION_TYPE_IMMEDIATE, CAMERA_MODIFICATION_TYPE_DISCARD);
+			return camera;
+		end
+	end
+end
+
+function ModelSceneMixin:CreateOrTransitionCameraFromScene(oldTagToCamera, cameraTransitionType, cameraModificationType, modelSceneCameraID)
+	local modelSceneCameraInfo = C_ModelInfo.GetModelSceneCameraInfoByID(modelSceneCameraID);
+	if modelSceneCameraInfo then
+		local existingCamera = oldTagToCamera[modelSceneCameraInfo.scriptTag];
+		if existingCamera and existingCamera:GetCameraType() == modelSceneCameraInfo.cameraType then
+			self.tagToCamera[modelSceneCameraInfo.scriptTag] = existingCamera;
+
+			self:AddCamera(existingCamera);
+			existingCamera:ApplyFromModelSceneCameraInfo(modelSceneCameraInfo, cameraTransitionType, cameraModificationType);
+			return existingCamera;
+		end
+
+		return self:CreateCameraFromScene(modelSceneCameraID);
+	end
+end
+
+-- actorSettings = {
+--	"actorTag" = { startDelay = 0, duration = 0, speed = 1 } -- duration 0 means no automatic stoppage
+-- }
+function ModelSceneMixin:ShowAndAnimateActors(actorSettings, onFinishedCallback)
+	self:Show();
+	local totalTime = 0;
+	for actorTag, actorInfo in pairs(actorSettings) do
+		local actor = self:GetActorByTag(actorTag);
+		if actor then
+			local runningTime = actorInfo.startDelay + actorInfo.duration;
+			if actorInfo.startDelay > 0 then
+				actor:SetAnimation(0, 0, 0, 0);
+				C_Timer.After(actorInfo.startDelay,
+					function()
+						actor:SetAnimation(0, 0, actorInfo.speed, 0);
+					end
+				);
+			else
+				actor:SetAnimation(0, 0, actorInfo.speed, 0);
+			end
+			if actorInfo.duration > 0 then
+				C_Timer.After(runningTime,
+					function()
+						actor:SetAnimation(0, 0, 0, 0);
+					end
+				);
+			end
+			if runningTime > totalTime then
+				totalTime = runningTime;
+			end
+		end
+	end
+
+	if onFinishedCallback and totalTime > 0 then
+		C_Timer.After(totalTime, onFinishedCallback);
+	end
+end
+
+function ModelSceneMixin:GetOrAcquireDropShadow(actor)
+	if actor.dropShadowTexture then
+		return actor.dropShadowTexture;
+	end
+
+	if not self.dropShadowPool then
+		self.dropShadowPool = CreateTexturePool(self, "BORDER", 1, "ModelSceneDropShadowTemplate");
+	end
+
+	actor.dropShadowTexture = self.dropShadowPool:Acquire();
+	return actor.dropShadowTexture;
+end
+
+function ModelSceneMixin:AddOrUpdateDropShadow(actor, baseShadowScale)
+	baseShadowScale = baseShadowScale or 1.0;
+
+	local dropShadowTexture = self:GetOrAcquireDropShadow(actor);
+	local positionVector = CreateVector3D(actor:GetPosition());
+	positionVector:ScaleBy(actor:GetScale());
+	local x, y, depthScale = self:Transform3DPointTo2D(positionVector:GetXYZ());
+
+	if not x or not y or not depthScale then
+		dropShadowTexture:Hide();
+		return;
+	end
+
+	dropShadowTexture:ClearAllPoints();
+	depthScale = baseShadowScale * Lerp(.05, 1, ClampedPercentageBetween(depthScale, .8, 1))
+	-- Scales down the texture depending on it's depthScale.
+	dropShadowTexture:SetScale(depthScale);
+
+	-- Need to apply the effective scale to account for UI Scaling.
+	local inverseScale = self:GetEffectiveScale() * depthScale;
+	-- The position of the character can be found by the offset on the screen.
+	dropShadowTexture:SetPoint("CENTER", self, "BOTTOMLEFT", (x / inverseScale) + 2, (y / inverseScale) - 4);
+	dropShadowTexture:Show();
+end
+
+
+PanningModelSceneMixin = CreateFromMixins(ModelSceneMixin);
+function PanningModelSceneMixin:TransitionToModelSceneID(modelSceneID, cameraTransitionType, cameraModificationType, forceEvenIfSame)
+	ModelSceneMixin.TransitionToModelSceneID(self, modelSceneID, cameraTransitionType, cameraModificationType, forceEvenIfSame);
+
+	local camera = self:GetActiveCamera();
+	if camera then
+		camera:SetRightMouseButtonXMode(ORBIT_CAMERA_MOUSE_PAN_HORIZONTAL, true);
+		camera:SetRightMouseButtonYMode(ORBIT_CAMERA_MOUSE_PAN_VERTICAL, true);
+	end
+end
+
+
+NoCameraControlModelSceneMixin = CreateFromMixins(ModelSceneMixin);
+function NoCameraControlModelSceneMixin:OnMouseDown(button)
+	self.isLeftButtonDown = false;
+	self.isRightButtonDown = false;
+end
+
+function NoCameraControlModelSceneMixin:OnMouseUp(button)
+	self.isLeftButtonDown = false;
+	self.isRightButtonDown = false;
+end
+
+function NoCameraControlModelSceneMixin:OnMouseWheel(delta)	
+end
+NoZoomModelSceneMixin = CreateFromMixins(ModelSceneMixin);
+function NoZoomModelSceneMixin:OnMouseWheel(delta)	
+end
@@ -0,0 +1,28 @@
+<Ui xmlns="http://www.blizzard.com/wow/ui/" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://www.blizzard.com/wow/ui/
+UI.xsd">
+	<ModelScene name="NonInteractableModelSceneMixinTemplate" mixin="ModelSceneMixin" virtual="true">
+		<Scripts>
+			<OnLoad method="OnLoad" />
+			<OnUpdate method="OnUpdate" />
+		</Scripts>
+	</ModelScene>
+	<ModelScene name="ModelSceneMixinTemplate" inherits="NonInteractableModelSceneMixinTemplate" virtual="true">
+		<Scripts>
+			<OnEnter method="OnEnter"/>
+			<OnLeave method="OnLeave"/>
+			<OnMouseUp method="OnMouseUp"/>
+			<OnMouseDown method="OnMouseDown"/>
+			<OnMouseWheel method="OnMouseWheel" />
+		</Scripts>
+	</ModelScene>
+	<ModelScene name="StoreModelSceneMixinTemplate" inherits="ModelSceneMixinTemplate" virtual="true">
+		<KeyValues>
+			<!-- CLASS-44103: Automatically allow overlapped models for shop scenes -->
+			<KeyValue key="allowOverlappedModels" value="true" type="boolean"/>
+		</KeyValues>
+	</ModelScene>
+	<ModelScene name="NoZoomModelSceneMixinTemplate" inherits="ModelSceneMixinTemplate" mixin="NoZoomModelSceneMixin" virtual="true"/>
+	<ModelScene name="PanningModelSceneMixinTemplate" inherits="ModelSceneMixinTemplate" mixin="PanningModelSceneMixin" virtual="true" />
+	<ModelScene name="NoCameraControlModelSceneMixinTemplate" inherits="ModelSceneMixinTemplate" mixin="NoCameraControlModelSceneMixin" virtual="true" />
+	<Texture name="ModelSceneDropShadowTemplate" atlas="scoreboard-charactermodels-shadow" useAtlasSize="true" virtual="true"/>
+</Ui>
@@ -0,0 +1,640 @@
+-- Verbatim backport of retail's Blizzard_SharedXML/Shared/ModelSceneCameras/OrbitCameraMixin.lua.
+
+--[[
+	OrbitCameraMixin - A simple camera that can orbit a target point at a fixed distance.
+
+	The orbit is represented using a distance from a target point in world space and yaw, pitch and roll.
+	The yaw, pitch and roll represent the camera's orientation, or inversely the direction of the camera from the target point.
+
+	Optionally, the target, orientation and zoom can have splines that are added to the respective axes. The splines are fed the zoom percentage to calculate the point on the spline.
+	This is ideal for changing view points based on zoom distance from the target. For example, target model's face on zoom in and center on the model on zoom out.
+]]
+
+OrbitCameraMixin = CreateFromMixins(CameraBaseMixin);
+
+local CAMERA_NAME = "OrbitCamera";
+CameraRegistry:AddCameraFactoryFromMixin(CAMERA_NAME, OrbitCameraMixin);
+
+-- "public" functions
+function OrbitCameraMixin:GetCameraType() -- override
+	return CAMERA_NAME;
+end
+
+local function TryCreateZoomSpline(x, y, z, existingSpline)
+	if x and y and z and (x ~= 0 or y ~= 0 or z ~= 0) then
+		local spline = existingSpline or CreateCatmullRomSpline(3);
+		spline:ClearPoints();
+		spline:AddPoint(0, 0, 0);
+		spline:AddPoint(x, y, z);
+
+		return spline;
+	end
+	return nil;
+end
+
+function OrbitCameraMixin:ApplyFromModelSceneCameraInfo(modelSceneCameraInfo, transitionType, modificationType) -- override
+	self.panningXOffset = 0;
+	self.panningYOffset = 0;
+
+	local transitionalCameraInfo = self:CalculateTransitionalValues(self.modelSceneCameraInfo, modelSceneCameraInfo, modificationType);
+
+	self.modelSceneCameraInfo = modelSceneCameraInfo;
+
+	self:SetTarget(transitionalCameraInfo.target:GetXYZ());
+	self:SetTargetSpline(TryCreateZoomSpline(transitionalCameraInfo.zoomedTargetOffset:GetXYZ()), self:GetTargetSpline());
+	self:SetOrientationSpline(TryCreateZoomSpline(transitionalCameraInfo.zoomedYawOffset, transitionalCameraInfo.zoomedPitchOffset, transitionalCameraInfo.zoomedRollOffset), self:GetOrientationSpline());
+
+	self:SetMinZoomDistance(transitionalCameraInfo.minZoomDistance);
+	self:SetMaxZoomDistance(transitionalCameraInfo.maxZoomDistance);
+
+	self:SetZoomDistance(transitionalCameraInfo.zoomDistance);
+
+	self:SetYaw(transitionalCameraInfo.yaw);
+	self:SetPitch(transitionalCameraInfo.pitch);
+	self:SetRoll(transitionalCameraInfo.roll);
+
+	if transitionType == CAMERA_TRANSITION_TYPE_IMMEDIATE then
+		self:SnapAllInterpolatedValues();
+	end
+	self:UpdateCameraOrientationAndPosition();
+end
+
+function OrbitCameraMixin:SetTarget(x, y, z)
+	self.targetX, self.targetY, self.targetZ = x, y, z;
+end
+
+function OrbitCameraMixin:GetTarget(x, y, z)
+	return self.targetX, self.targetY, self.targetZ;
+end
+
+function OrbitCameraMixin:SetYaw(yaw)
+	self.yaw = yaw;
+end
+
+function OrbitCameraMixin:GetYaw()
+	return self.yaw;
+end
+
+function OrbitCameraMixin:SetPitch(pitch)
+	self.pitch = pitch;
+end
+
+function OrbitCameraMixin:GetPitch()
+	return self.pitch;
+end
+
+function OrbitCameraMixin:SetRoll(roll)
+	self.roll = roll;
+end
+
+function OrbitCameraMixin:GetRoll()
+	return self.roll;
+end
+
+-- where 100% is fully zoomed out
+function OrbitCameraMixin:GetZoomPercent()
+	return self.zoomPercent;
+end
+
+function OrbitCameraMixin:SetZoomPercent(zoomPercent)
+	self.zoomPercent = Saturate(zoomPercent);
+end
+
+function OrbitCameraMixin:ZoomByPercent(percent)
+	self:SetZoomPercent(self:GetZoomPercent() - percent);
+end
+
+function OrbitCameraMixin:SetMaxZoomDistance(distance)
+	self.maxZoomDistance = distance;
+	if self:GetZoomPercent() then
+		self:SetZoomDistance(self:GetZoomDistance());
+	end
+end
+
+function OrbitCameraMixin:GetMaxZoomDistance()
+	return self.maxZoomDistance;
+end
+
+function OrbitCameraMixin:SetMinZoomDistance(distance)
+	self.minZoomDistance = distance;
+	if self:GetZoomPercent() then
+		self:SetZoomDistance(self:GetZoomDistance());
+	end
+end
+
+function OrbitCameraMixin:GetMinZoomDistance()
+	return self.minZoomDistance;
+end
+
+function OrbitCameraMixin:SetZoomDistance(distance)
+	self:SetZoomPercent(self:CalculateZoomPercentFromDistance(distance));
+end
+
+function OrbitCameraMixin:CalculateZoomPercentFromDistance(distance)
+	if self:GetMinZoomDistance() and self:GetMaxZoomDistance() then
+		return PercentageBetween(distance, self:GetMinZoomDistance(), self:GetMaxZoomDistance());
+	end
+	return 0.0;
+end
+
+function OrbitCameraMixin:CalculateZoomDistanceFromPercent(percent)
+	if self:GetMinZoomDistance() and self:GetMaxZoomDistance() then
+		return Lerp(self:GetMinZoomDistance(), self:GetMaxZoomDistance(), percent);
+	end
+	return 0.0;
+end
+
+function OrbitCameraMixin:GetZoomDistance()
+	return self:CalculateZoomDistanceFromPercent(self:GetZoomPercent());
+end
+
+-- If min and max values are the same, zoom cannot really happen.
+function OrbitCameraMixin:GetZoomAvailable()
+	if self:GetMinZoomDistance() and self:GetMaxZoomDistance() then
+		return self:GetMinZoomDistance() ~= self:GetMaxZoomDistance();
+	end
+	return false;
+end
+
+function OrbitCameraMixin:ZoomBy(distance)
+	self:SetZoomDistance(self:GetZoomDistance() - distance);
+end
+
+-- Expects a three dimensional spline where a point of the curve represents a target position
+function OrbitCameraMixin:SetTargetSpline(targetSpline)
+	self.targetSpline = targetSpline;
+end
+
+function OrbitCameraMixin:GetTargetSpline()
+	return self.targetSpline;
+end
+
+-- Expects a three dimensional spline where a point of the curve represents the camera yaw, pitch, roll
+function OrbitCameraMixin:SetOrientationSpline(orientationSpline)
+	self.orientationSpline = orientationSpline;
+end
+
+function OrbitCameraMixin:GetOrientationSpline()
+	return self.orientationSpline;
+end
+
+-- Expects an one dimensional spline where a point of the curve represents the camera's distance from the target
+function OrbitCameraMixin:SetZoomSpline(zoomSpline)
+	self.zoomSpline = zoomSpline;
+end
+
+function OrbitCameraMixin:GetZoomSpline()
+	return self.zoomSpline;
+end
+
+--[[ These return the simple + spline values ]]--
+function OrbitCameraMixin:GetDerivedTarget()
+	local targetX, targetY, targetZ = self:GetTarget();
+
+	local targetSpline = self:GetTargetSpline();
+	if targetSpline then
+		return Vector3D_Add(targetX, targetY, targetZ, targetSpline:CalculatePointOnGlobalCurve(1.0 - self:GetZoomPercent()));
+	end
+
+	return targetX, targetY, targetZ;
+end
+
+function OrbitCameraMixin:GetDerivedOrientation()
+	local yaw, pitch, roll = self:GetYaw(), self:GetPitch(), self:GetRoll();
+
+	local orientationSpline = self:GetOrientationSpline();
+	if orientationSpline then
+		return Vector3D_Add(yaw, pitch, roll, orientationSpline:CalculatePointOnGlobalCurve(1.0 - self:GetZoomPercent()));
+	end
+
+	return yaw, pitch, roll;
+end
+
+function OrbitCameraMixin:GetDerivedZoomDistance()
+	local zoomDistance = self:GetZoomDistance();
+
+	local zoomSpline = self:GetZoomSpline();
+	if zoomSpline then
+		return zoomDistance + zoomSpline:CalculatePointOnGlobalCurve(1.0 - self:GetZoomPercent());
+	end
+
+	return zoomDistance;
+end
+
+function OrbitCameraMixin:SetAlignLightToOrbitDelta(alignLightToOrbitDelta)
+	if alignLightToOrbitDelta then
+		self.modelSceneCameraInfo.flags = bit.bor(self.modelSceneCameraInfo.flags, Enum.ModelSceneSetting.AlignLightToOrbitDelta);
+	else
+		self.modelSceneCameraInfo.flags = bit.band(self.modelSceneCameraInfo.flags, bit.bnot(Enum.ModelSceneSetting.AlignLightToOrbitDelta));
+	end
+end
+
+function OrbitCameraMixin:ShouldAlignLightToOrbitDelta()
+	return bit.band(self.modelSceneCameraInfo.flags, Enum.ModelSceneSetting.AlignLightToOrbitDelta) == Enum.ModelSceneSetting.AlignLightToOrbitDelta;
+end
+
+--[[
+	Interpolation API
+	For each API, "amount" is the percentage to approach in an "ideal" frame (60 fps), such that setting the value to >= 1 would snap to the desired target and <= 0 would freeze the interpolation.
+	Setting to nil will disable the interpolation.
+]]
+
+function OrbitCameraMixin:SetYawInterpolationAmount(yawInterpolationAmount)
+	self.yawInterpolationAmount = yawInterpolationAmount;
+end
+
+function OrbitCameraMixin:GetYawInterpolationAmount()
+	return self.yawInterpolationAmount;
+end
+
+function OrbitCameraMixin:SetPitchInterpolationAmount(pitchInterpolationAmount)
+	self.pitchInterpolationAmount = pitchInterpolationAmount;
+end
+
+function OrbitCameraMixin:GetPitchInterpolationAmount()
+	return self.pitchInterpolationAmount;
+end
+
+function OrbitCameraMixin:SetRollInterpolationAmount(rollInterpolationAmount)
+	self.rollInterpolationAmount = rollInterpolationAmount;
+end
+
+function OrbitCameraMixin:GetRollInterpolationAmount()
+	return self.rollInterpolationAmount;
+end
+
+function OrbitCameraMixin:SetTargetInterpolationAmount(targetInterpolationAmount)
+	self.targetInterpolationAmount = targetInterpolationAmount;
+end
+
+function OrbitCameraMixin:GetTargetInterpolationAmount()
+	return self.targetInterpolationAmount;
+end
+
+function OrbitCameraMixin:SetZoomInterpolationAmount(zoomInterpolationAmount)
+	self.zoomInterpolationAmount = zoomInterpolationAmount;
+end
+
+function OrbitCameraMixin:GetZoomInterpolationAmount()
+	return self.zoomInterpolationAmount;
+end
+
+function OrbitCameraMixin:GetInterpolatedTarget()
+	if self.interpolatedTargetX then
+		return self.interpolatedTargetX, self.interpolatedTargetY, self.interpolatedTargetZ;
+	end
+	return self:GetDerivedTarget();
+end
+
+function OrbitCameraMixin:GetInterpolatedOrientation()
+	if self.interpolatedYaw then
+		return self.interpolatedYaw, self.interpolatedPitch, self.interpolatedRoll;
+	end
+	return self:GetDerivedOrientation();
+end
+
+function OrbitCameraMixin:GetInterpolatedZoomDistance()
+	if self.interpolatedZoomDistance then
+		return self.interpolatedZoomDistance;
+	end
+	return self:GetDerivedZoomDistance();
+end
+
+function OrbitCameraMixin:SnapToTargetInterpolationYaw()
+	self.interpolatedYaw = nil;
+end
+
+function OrbitCameraMixin:SnapToTargetInterpolationPitch()
+	self.interpolatedPitch = nil;
+end
+
+function OrbitCameraMixin:SnapToTargetInterpolationRoll()
+	self.interpolatedRoll = nil;
+end
+
+function OrbitCameraMixin:SnapToTargetInterpolationZoom()
+	self.interpolatedZoomDistance = nil;
+end
+
+function OrbitCameraMixin:SnapToTargetInterpolationTarget()
+	self.interpolatedTargetX = nil;
+	self.interpolatedTargetY = nil;
+	self.interpolatedTargetZ = nil;
+end
+
+function OrbitCameraMixin:SnapAllInterpolatedValues()
+	self:SnapToTargetInterpolationYaw();
+	self:SnapToTargetInterpolationPitch();
+	self:SnapToTargetInterpolationRoll();
+
+	self:SnapToTargetInterpolationZoom();
+
+	self:SnapToTargetInterpolationTarget();
+end
+
+ORBIT_CAMERA_MOUSE_MODE_NOTHING = 0;
+ORBIT_CAMERA_MOUSE_MODE_YAW_ROTATION = 1;
+ORBIT_CAMERA_MOUSE_MODE_PITCH_ROTATION = 2;
+ORBIT_CAMERA_MOUSE_MODE_ROLL_ROTATION = 3;
+ORBIT_CAMERA_MOUSE_MODE_TARGET_HORIZONTAL = 4;
+ORBIT_CAMERA_MOUSE_MODE_TARGET_VERTICAL = 5;
+ORBIT_CAMERA_MOUSE_MODE_ZOOM = 6;
+ORBIT_CAMERA_MOUSE_PAN_HORIZONTAL = 7;
+ORBIT_CAMERA_MOUSE_PAN_VERTICAL = 8;
+
+function OrbitCameraMixin:SetLeftMouseButtonXMode(mouseMode, snap)
+	self.buttonModes.leftX = mouseMode;
+	self.buttonModes.leftXinterpolate = not snap;
+end
+
+function OrbitCameraMixin:GetLeftMouseButtonXMode()
+	return self.buttonModes.leftX, not self.buttonModes.leftXinterpolate;
+end
+
+function OrbitCameraMixin:SetLeftMouseButtonYMode(mouseMode, snap)
+	self.buttonModes.leftY = mouseMode;
+	self.buttonModes.leftYinterpolate = not snap;
+end
+
+function OrbitCameraMixin:GetLeftYMouseButtonYMode()
+	return self.buttonModes.leftY, not self.buttonModes.leftYinterpolate;
+end
+
+function OrbitCameraMixin:SetRightMouseButtonXMode(mouseMode, snap)
+	self.buttonModes.rightX = mouseMode;
+	self.buttonModes.rightXinterpolate = not snap;
+end
+
+function OrbitCameraMixin:GetRightMouseButtonXMode()
+	return self.buttonModes.rightX, not self.buttonModes.rightXinterpolate;
+end
+
+function OrbitCameraMixin:SetRightMouseButtonYMode(mouseMode, snap)
+	self.buttonModes.rightY = mouseMode;
+	self.buttonModes.rightYinterpolate = not snap;
+end
+
+function OrbitCameraMixin:GetRightMouseButtonYMode()
+	return self.buttonModes.rightY, not self.buttonModes.rightYinterpolate;
+end
+
+function OrbitCameraMixin:SetMouseWheelMode(mouseMode, snap)
+	self.buttonModes.wheel = mouseMode;
+	self.buttonModes.wheelInterpolate = not snap;
+end
+
+function OrbitCameraMixin:GetMouseWheelMode()
+	return self.buttonModes.wheel, not self.buttonModes.wheelInterpolate;
+end
+
+function OrbitCameraMixin:HandleMouseMovement(mode, delta, snapToValue)
+	if mode == ORBIT_CAMERA_MOUSE_MODE_YAW_ROTATION then
+		self:SetYaw(self:GetYaw() - delta);
+		if snapToValue then
+			self:SnapToTargetInterpolationYaw();
+		end
+	elseif mode == ORBIT_CAMERA_MOUSE_MODE_PITCH_ROTATION then
+		self:SetPitch(self:GetPitch() - delta);
+		if snapToValue then
+			self:SnapToTargetInterpolationPitch();
+		end
+	elseif mode == ORBIT_CAMERA_MOUSE_MODE_ROLL_ROTATION then
+		self:SetRoll(self:GetRoll() - delta);
+		if snapToValue then
+			self:SnapToTargetInterpolationRoll();
+		end
+	elseif mode == ORBIT_CAMERA_MOUSE_MODE_ZOOM then
+		self:ZoomByPercent(delta);
+		if snapToValue then
+			self:SnapToTargetInterpolationZoom();
+		end
+	elseif mode == ORBIT_CAMERA_MOUSE_MODE_TARGET_HORIZONTAL then
+		local rightX, rightY, rightZ = Vector3D_ScaleBy(delta, self:GetRightVector());
+		self:SetTarget(Vector3D_Add(rightX, rightY, rightZ, self:GetTarget()));
+
+		if snapToValue then
+			self:SnapToTargetInterpolationTarget();
+		end
+	elseif mode == ORBIT_CAMERA_MOUSE_MODE_TARGET_VERTICAL then
+		local upX, upY, upZ = Vector3D_ScaleBy(delta, self:GetUpVector());
+		self:SetTarget(Vector3D_Add(upX, upY, upZ, self:GetTarget()));
+
+		if snapToValue then
+			self:SnapToTargetInterpolationTarget();
+		end
+	elseif mode == ORBIT_CAMERA_MOUSE_PAN_HORIZONTAL then
+		self.panningXOffset = self.panningXOffset + delta;
+	elseif mode == ORBIT_CAMERA_MOUSE_PAN_VERTICAL then
+		self.panningYOffset = self.panningYOffset + delta;
+	end
+end
+
+function OrbitCameraMixin:ResetDefaultInputModes()
+	self:SetLeftMouseButtonXMode(ORBIT_CAMERA_MOUSE_MODE_YAW_ROTATION, true);
+	self:SetLeftMouseButtonYMode(ORBIT_CAMERA_MOUSE_MODE_NOTHING);
+	self:SetRightMouseButtonXMode(ORBIT_CAMERA_MOUSE_MODE_NOTHING);
+	self:SetRightMouseButtonYMode(ORBIT_CAMERA_MOUSE_MODE_NOTHING);
+	self:SetMouseWheelMode(ORBIT_CAMERA_MOUSE_MODE_ZOOM, false);
+end
+
+-- "private" function
+function OrbitCameraMixin:OnAdded() -- override
+	self.buttonModes = {};
+
+	self:SetTarget(0, 0, 0);
+
+	local targetSpline = CreateCatmullRomSpline(3);
+	targetSpline:AddPoint(0, 0, 0);
+	targetSpline:AddPoint(0, 0, .5);
+
+	self:SetTargetSpline(targetSpline);
+
+	self:SetMinZoomDistance(6);
+	self:SetMaxZoomDistance(10);
+
+	self:SetZoomDistance(8);
+
+	self:SetYaw(math.pi);
+	self:SetPitch(0);
+	self:SetRoll(0);
+
+	self:SetZoomInterpolationAmount(.15);
+	self:SetYawInterpolationAmount(.15);
+	self:SetPitchInterpolationAmount(.15);
+	self:SetRollInterpolationAmount(.15);
+	self:SetTargetInterpolationAmount(.15);
+
+	self:ResetDefaultInputModes();
+end
+
+function OrbitCameraMixin:GetDeltaModifierForCameraMode(mode)
+	if mode == ORBIT_CAMERA_MOUSE_MODE_YAW_ROTATION then
+		return .008;
+	elseif mode == ORBIT_CAMERA_MOUSE_MODE_PITCH_ROTATION then
+		return .008;
+	elseif mode == ORBIT_CAMERA_MOUSE_MODE_ROLL_ROTATION then
+		return .008;
+	elseif mode == ORBIT_CAMERA_MOUSE_MODE_ZOOM then
+		return .1;
+	elseif mode == ORBIT_CAMERA_MOUSE_MODE_TARGET_HORIZONTAL then
+		return .05;
+	elseif mode == ORBIT_CAMERA_MOUSE_MODE_TARGET_VERTICAL then
+		return .05;
+	elseif mode == ORBIT_CAMERA_MOUSE_PAN_HORIZONTAL then
+		return 0.93;
+	elseif mode == ORBIT_CAMERA_MOUSE_PAN_VERTICAL then
+		return 0.93;
+	end
+	return 0.0;
+end
+
+function OrbitCameraMixin:OnUpdate(elapsed) -- override
+	if self:IsLeftMouseButtonDown() then
+		local deltaX, deltaY = InputUtil.GetCursorDelta(GetAppropriateTopLevelParent());
+		self:HandleMouseMovement(self.buttonModes.leftX, deltaX * self:GetDeltaModifierForCameraMode(self.buttonModes.leftX), not self.buttonModes.leftXinterpolate);
+		self:HandleMouseMovement(self.buttonModes.leftY, -deltaY * self:GetDeltaModifierForCameraMode(self.buttonModes.leftY), not self.buttonModes.leftYinterpolate);
+	end
+
+	if self:IsRightMouseButtonDown() then
+		local deltaX, deltaY = InputUtil.GetCursorDelta(GetAppropriateTopLevelParent());
+		self:HandleMouseMovement(self.buttonModes.rightX, deltaX * self:GetDeltaModifierForCameraMode(self.buttonModes.rightX), not self.buttonModes.rightXinterpolate);
+		self:HandleMouseMovement(self.buttonModes.rightY, -deltaY * self:GetDeltaModifierForCameraMode(self.buttonModes.rightY), not self.buttonModes.rightYinterpolate);
+	end
+
+	self:UpdateInterpolationTargets(elapsed);
+	self:SynchronizeCamera();
+end
+
+function OrbitCameraMixin:SynchronizeCamera() -- override
+	self:UpdateCameraOrientationAndPosition();
+	self:UpdateLight();
+end
+
+local function InterpolateDimension(lastValue, targetValue, amount, elapsed)
+	return lastValue and amount and DeltaLerp(lastValue, targetValue, amount, elapsed) or targetValue;
+end
+
+function OrbitCameraMixin:UpdateInterpolationTargets(elapsed)
+	local yaw, pitch, roll = self:GetDerivedOrientation();
+	local targetX, targetY, targetZ = self:GetDerivedTarget();
+	local zoomDistance = self:GetDerivedZoomDistance();
+
+	self.interpolatedYaw = InterpolateDimension(self.interpolatedYaw, yaw, self.yawInterpolationAmount, elapsed);
+	self.interpolatedPitch = InterpolateDimension(self.interpolatedPitch, pitch, self.pitchInterpolationAmount, elapsed);
+	self.interpolatedRoll = InterpolateDimension(self.interpolatedRoll, roll, self.rollInterpolationAmount, elapsed);
+
+	self.interpolatedZoomDistance = InterpolateDimension(self.interpolatedZoomDistance, zoomDistance, self.zoomInterpolationAmount, elapsed);
+
+	self.interpolatedTargetX = InterpolateDimension(self.interpolatedTargetX, targetX, self.targetInterpolationAmount, elapsed);
+	self.interpolatedTargetY = InterpolateDimension(self.interpolatedTargetY, targetY, self.targetInterpolationAmount, elapsed);
+	self.interpolatedTargetZ = InterpolateDimension(self.interpolatedTargetZ, targetZ, self.targetInterpolationAmount, elapsed);
+end
+
+function OrbitCameraMixin:UpdateCameraOrientationAndPosition()
+	local yaw, pitch, roll = self:GetInterpolatedOrientation();
+	local axisAngleX, axisAngleY, axisAngleZ = Vector3D_CalculateNormalFromYawPitch(yaw, pitch);
+
+	local targetX, targetY, targetZ = self:GetInterpolatedTarget();
+
+	local zoomDistance = self:GetInterpolatedZoomDistance();
+
+	-- Panning start --
+	-- We want the model to move 1-to-1 with the mouse.
+	-- Panning formula: dx / hypotenuse * (zoomDistance - 1 / zoomDistance^3)
+	-- It was experimentally determined that adding the additional fudge factor 1/z^3 resulted in better tracking.
+
+	local width = self:GetOwningScene():GetWidth();
+	local height = self:GetOwningScene():GetHeight();
+	local scaleFactor = (width ~= 0 and height ~= 0) and math.sqrt(width * width + height * height) or 1;
+	local zoomFactor = 1;
+	if zoomDistance > 1 then
+		zoomFactor = zoomDistance - (1 / (zoomDistance * zoomDistance * zoomDistance));
+		if zoomFactor < 1 then
+			zoomFactor = 1;
+		end
+	end
+
+	local rightX, rightY, rightZ = Vector3D_ScaleBy((self.panningXOffset / scaleFactor) * zoomFactor, self:GetRightVector());
+	local upX, upY, upZ = Vector3D_ScaleBy((self.panningYOffset / scaleFactor) * zoomFactor, self:GetUpVector());
+
+	-- Panning end --
+
+	targetX, targetY, targetZ = Vector3D_Add(targetX, targetY, targetZ, rightX, rightY, rightZ);
+	targetX, targetY, targetZ = Vector3D_Add(targetX, targetY, targetZ, upX, upY, upZ);
+
+	self:SetPosition(self:CalculatePositionByDistanceFromTarget(targetX, targetY, targetZ, zoomDistance, axisAngleX, axisAngleY, axisAngleZ));
+	self:GetOwningScene():SetCameraOrientationByYawPitchRoll(yaw, pitch, roll);
+end
+
+function OrbitCameraMixin:UpdateLight()
+	if self:ShouldAlignLightToOrbitDelta() then
+		local owningScene = self:GetOwningScene();
+		owningScene:SetLightDirection(self:GetForwardVector());
+	end
+end
+
+function OrbitCameraMixin:CalculatePositionByDistanceFromTarget(targetX, targetY, targetZ, zoomDistance, axisAngleX, axisAngleY, axisAngleZ)
+	local towardsPosX, towardsPosY, towardsPosZ = Vector3D_ScaleBy(-zoomDistance, axisAngleX, axisAngleY, axisAngleZ);
+	return Vector3D_Add(towardsPosX, towardsPosY, towardsPosZ, targetX, targetY, targetZ);
+end
+
+function OrbitCameraMixin:CalculateTransitionalValues(fromModelSceneCameraInfo, toModelSceneCameraInfo, modificationType)
+	if fromModelSceneCameraInfo and modificationType == CAMERA_MODIFICATION_TYPE_MAINTAIN then
+		local zoomedTargetOffsetX, zoomedTargetOffsetY, zoomedTargetOffsetZ = 0, 0, 0;
+
+		local targetSpline = self:GetTargetSpline();
+		if targetSpline and targetSpline:GetNumPoints() > 0 then
+			zoomedTargetOffsetX, zoomedTargetOffsetY, zoomedTargetOffsetZ = targetSpline:GetPoint(targetSpline:GetNumPoints());
+		end
+
+		local zoomedYawOffset, zoomedPitchOffset, zoomedRollOffset = 0, 0, 0;
+		local orientationSpline = self:GetOrientationSpline();
+		if orientationSpline and orientationSpline:GetNumPoints() > 0 then
+			zoomedYawOffset, zoomedPitchOffset, zoomedRollOffset = orientationSpline:GetPoint(orientationSpline:GetNumPoints());
+		end
+
+		local fromZoomDistancePercent = PercentageBetween(fromModelSceneCameraInfo.zoomDistance, fromModelSceneCameraInfo.minZoomDistance, fromModelSceneCameraInfo.maxZoomDistance);
+		local toZoomDistancePercent = PercentageBetween(toModelSceneCameraInfo.zoomDistance, toModelSceneCameraInfo.minZoomDistance, toModelSceneCameraInfo.maxZoomDistance);
+		-- Maintain any modifications made by applying the scene delta
+		return {
+			   target = CreateVector3D(
+			   		(self.targetX - fromModelSceneCameraInfo.target.x) + toModelSceneCameraInfo.target.x,
+					(self.targetY - fromModelSceneCameraInfo.target.y) + toModelSceneCameraInfo.target.y,
+					(self.targetZ - fromModelSceneCameraInfo.target.z) + toModelSceneCameraInfo.target.z
+			   ),
+
+			   yaw = (self.yaw - fromModelSceneCameraInfo.yaw) + toModelSceneCameraInfo.yaw,
+			   pitch = (self.pitch - fromModelSceneCameraInfo.pitch) + toModelSceneCameraInfo.pitch,
+			   roll = (self.roll - fromModelSceneCameraInfo.roll) + toModelSceneCameraInfo.roll,
+
+			   zoomDistance = Lerp(toModelSceneCameraInfo.minZoomDistance, toModelSceneCameraInfo.maxZoomDistance, (self.zoomPercent - fromZoomDistancePercent) + toZoomDistancePercent),
+			   minZoomDistance = (self.minZoomDistance - fromModelSceneCameraInfo.minZoomDistance) + toModelSceneCameraInfo.minZoomDistance,
+			   maxZoomDistance = (self.maxZoomDistance - fromModelSceneCameraInfo.maxZoomDistance) + toModelSceneCameraInfo.maxZoomDistance,
+
+			   zoomedTargetOffset = CreateVector3D(
+					(zoomedTargetOffsetX - fromModelSceneCameraInfo.zoomedTargetOffset.x) + toModelSceneCameraInfo.zoomedTargetOffset.x,
+					(zoomedTargetOffsetY - fromModelSceneCameraInfo.zoomedTargetOffset.y) + toModelSceneCameraInfo.zoomedTargetOffset.y,
+					(zoomedTargetOffsetZ - fromModelSceneCameraInfo.zoomedTargetOffset.z) + toModelSceneCameraInfo.zoomedTargetOffset.z
+			   ),
+
+			   zoomedYawOffset = (zoomedYawOffset - fromModelSceneCameraInfo.zoomedYawOffset) + toModelSceneCameraInfo.zoomedYawOffset,
+			   zoomedPitchOffset = (zoomedPitchOffset - fromModelSceneCameraInfo.zoomedPitchOffset) + toModelSceneCameraInfo.zoomedPitchOffset,
+			   zoomedRollOffset = (zoomedRollOffset - fromModelSceneCameraInfo.zoomedRollOffset) + toModelSceneCameraInfo.zoomedRollOffset;
+		};
+	end
+
+	-- Nothing to transition from, just go directly to the values
+	return toModelSceneCameraInfo;
+end
+
+function OrbitCameraMixin:OnMouseWheel(delta) -- override
+	self:HandleMouseMovement(self.buttonModes.wheel, delta * self:GetDeltaModifierForCameraMode(self.buttonModes.wheel), not self.buttonModes.wheelInterpolate);
+end
+
+function OrbitCameraMixin:AdjustYaw(deltaX, deltaY, rotationScalar)
+	local xRotation = rotationScalar or self:GetDeltaModifierForCameraMode(self.buttonModes.leftX);
+	self:HandleMouseMovement(self.buttonModes.leftX, deltaX * xRotation, not self.buttonModes.leftXinterpolate);
+
+	local yRotatation  = rotationScalar or self:GetDeltaModifierForCameraMode(self.buttonModes.leftY);
+	self:HandleMouseMovement(self.buttonModes.leftY, -deltaY * yRotatation, not self.buttonModes.leftYinterpolate);
+end
@@ -107,6 +107,12 @@ function GameTooltip_AddNormalLine(tooltip, text, wrap, leftOffset)
 	GameTooltip_AddColoredLine(tooltip, text, NORMAL_FONT_COLOR, wrap, leftOffset);
 end

+-- Retail's takes `...` and passes it on; named parameters keep Lua 5.0 from
+-- building an `arg` table per call.
+function GameTooltip_AddBodyLine(tooltip, text, wrap, leftOffset)
+	GameTooltip_AddNormalLine(tooltip, text, wrap, leftOffset);
+end
+
 function GameTooltip_AddHighlightLine(tooltip, text, wrap, leftOffset)
 	GameTooltip_AddColoredLine(tooltip, text, HIGHLIGHT_FONT_COLOR, wrap, leftOffset);
 end
@@ -8,6 +8,12 @@ function InputUtil.GetCursorPosition(parent)
 	return x / scale, y / scale;
 end

+function InputUtil.GetCursorDelta(parent)
+	local x, y = GetCursorDelta();
+	local scale = parent:GetEffectiveScale();
+	return x / scale, y / scale;
+end
+
 function InputUtil.AnchorRegionToCursor(region, point)
 	local parent = GetAppropriateTopLevelParent();
 	local x, y = InputUtil.GetCursorPosition(parent);
@@ -6,8 +6,9 @@
 --     (scrapping, runeforging, soulbinds, keystones, item upgrades,
 --     recrafting, bank tabs), and the stock bag and character frames never
 --     ask for it.
--   - No ItemUtil.CreateItemTransmogInfo or ItemTransmogInfoMixin: there is
--     no transmogrification.
+--   - ItemTransmogInfoMixin's appearanceID is an item ID and its illusionID a
+--     SpellItemEnchantment ID, as the ModelSceneActor ItemTransmogInfo
+--     methods read and write them.
 --   - ItemUtil.GetItemDetails has no currency path: there are no currencies.
 --   - No ItemUtil.GetCraftingReagentCount: it picks between the reagent bank
 --     and the account bank, and neither exists.
@@ -95,6 +96,10 @@ function ItemUtil.FilterOwnedItems(itemIDs)
 	return filtered;
 end

+function ItemUtil.CreateItemTransmogInfo(appearanceID, secondaryAppearanceID, illusionID)
+	return CreateAndInitFromMixin(ItemTransmogInfoMixin, appearanceID, secondaryAppearanceID, illusionID);
+end
+
 function ItemUtil.TransformItemIDsToItems(itemIDs)
 	local items = {};
 	for index, itemID in ipairs(itemIDs) do
@@ -194,3 +199,42 @@ function ItemUtil.GetEquipSlotTexture(equipSlot)

 	return nil;
 end
+
+ItemTransmogInfoMixin = {};
+
+function ItemTransmogInfoMixin:Init(appearanceID, secondaryAppearanceID, illusionID)
+	self.appearanceID = appearanceID;
+	self.secondaryAppearanceID = secondaryAppearanceID or Constants.Transmog.NoTransmogID;
+	self.illusionID = illusionID or Constants.Transmog.NoTransmogID;
+end
+
+function ItemTransmogInfoMixin:IsEqual(itemTransmogInfo)
+	if not itemTransmogInfo then
+		return false;
+	end
+	return self.appearanceID == itemTransmogInfo.appearanceID and self.secondaryAppearanceID == itemTransmogInfo.secondaryAppearanceID and self.illusionID == itemTransmogInfo.illusionID;
+end
+
+function ItemTransmogInfoMixin:Clear()
+	self.appearanceID = Constants.Transmog.NoTransmogID;
+	self.secondaryAppearanceID = Constants.Transmog.NoTransmogID;
+	self.illusionID = Constants.Transmog.NoTransmogID;
+end
+
+-- There is no slot info in ItemTransmogInfo so the following 3 MainHand functions must be used with correct itemTransmogInfo at call site
+function ItemTransmogInfoMixin:ConfigureSecondaryForMainHand(isLegionArtifact)
+	if isLegionArtifact then
+		self.secondaryAppearanceID = Constants.Transmog.MainHandTransmogIsPairedWeapon;
+	else
+		self.secondaryAppearanceID = Constants.Transmog.MainHandTransmogIsIndividualWeapon;
+	end
+end
+
+function ItemTransmogInfoMixin:IsMainHandIndividualWeapon()
+	return self.secondaryAppearanceID == Constants.Transmog.MainHandTransmogIsIndividualWeapon;
+end
+
+function ItemTransmogInfoMixin:IsMainHandPairedWeapon()
+	-- paired weapon can be value Constants.Transmog.MainHandTransmogIsPairedWeapon or greater
+	return not self:IsMainHandIndividualWeapon();
+end
@@ -224,6 +224,9 @@ end
 -- extended `GameTooltip:SetHyperlink` (src/tooltip/Hyperlink.cpp), which
 -- builds the same tooltip `GameTooltip:SetSpellByID` builds, so the handler
 -- passes the payload through instead of rebuilding the tooltip itself.
+-- Control-click is retail's dress-up click: DressUpLink previews a mount
+-- spell, and nothing else happens, as retail's modified click shows no
+-- tooltip.
 ------------------------------------------------------------------------------
 LinkUtil.RegisterLinkHandler(LinkTypes.Spell, function(link, text, linkData, contextData)
 	local spellID = tonumber(string.match(link, "^spell:(%d+)"));
@@ -234,6 +237,10 @@ LinkUtil.RegisterLinkHandler(LinkTypes.Spell, function(link, text, linkData, con
 		ChatFrameEditBox:Insert(text);
 		return LinkProcessorResponse.Handled;
 	end
+	if IsControlKeyDown() then
+		DressUpLink(text);
+		return LinkProcessorResponse.Handled;
+	end
 	local tooltip = ItemRefTooltip or GameTooltip;
 	tooltip:SetOwner(UIParent, "ANCHOR_PRESERVE");
 	tooltip:SetHyperlink(link);
@@ -250,13 +257,14 @@ end);
 -- links. Route spell links Turtle would drop back through SetItemRef so the
 -- Spell handler above shows them; Turtle-shaped links
 -- (`spell:<id>:<bookType>:<player>`) pass through to Turtle's handler
-- untouched. On a stock client the original already forwards everything to
-- SetItemRef, so both branches behave the same there.
+-- untouched, except a Control-click, which previews the mount here. On a
+-- stock client the original already forwards everything to SetItemRef, so
+-- both branches behave the same there.
 ------------------------------------------------------------------------------
 local originalChatFrameOnHyperlinkShow = ChatFrame_OnHyperlinkShow;
 function ChatFrame_OnHyperlinkShow(link, text, button)
 	if type(link) == "string" and strsub(link, 1, 6) == "spell:" and
-		not string.find(link, "^spell:(%d+):(%w+):(%w+)") then
+		(IsControlKeyDown() or not string.find(link, "^spell:(%d+):(%w+):(%w+)")) then
 		SetItemRef(link, text, button);
 		return;
 	end
@@ -74,6 +74,10 @@ OPTION_TOOLTIP_INTERACT_ICONS = "Legt fest, welche Symbole über NSCs und Gegens
 OPTION_TOOLTIP_STOP_AUTO_ATTACK = "Automatischen Angriff stoppen, sobald das Ziel gewechselt wird.";
 KEY_BINDING_NAME_AND_KEY = "%s (%s)";
 KEY_BINDING_TOOLTIP = "<Zum Löschen der Belegung rechtsklicken>";
+RESET_POSITION = "Zurücksetzen";
+ROTATE_LEFT = "Linksdrehung";
+ROTATE_RIGHT = "Rechtsdrehung";
+ROTATE_TOOLTIP = "Linksklicken und ziehen, um den Charakter zu drehen.";
 SETTINGS_BIND_KEY_TO_COMMAND_OR_CANCEL = "Tastaturbelegung für \"%s\" zuweisen oder mit %s abbrechen";
 SET_FOCUS = "Fokus setzen";
 FOCUSTARGET = "Ziel als Fokus festlegen";
@@ -164,6 +164,10 @@ OPTION_TOOLTIP_INTERACT_ICONS = "Controls which icons appear above NPCs and obje
 OPTION_TOOLTIP_STOP_AUTO_ATTACK = "Stop auto attacking when you switch targets.";
 KEY_BINDING_NAME_AND_KEY = "%s (%s)";
 KEY_BINDING_TOOLTIP = "<Right click to unbind>";
+RESET_POSITION = "Reset Position";
+ROTATE_LEFT = "Rotate Left";
+ROTATE_RIGHT = "Rotate Right";
+ROTATE_TOOLTIP = "Left-click on character and drag to rotate.";
 SETTINGS_BIND_KEY_TO_COMMAND_OR_CANCEL = "Assign Binding for \"%s\" or Press %s to Cancel";
 SET_FOCUS = "Set Focus";
 FOCUS_TOKEN_NOT_FOUND = "<no focus>";
@@ -74,6 +74,10 @@ OPTION_TOOLTIP_INTERACT_ICONS = "Controla los iconos que aparecen sobre los PNJ
 OPTION_TOOLTIP_STOP_AUTO_ATTACK = "Detiene el ataque automático al cambiar de objetivo.";
 KEY_BINDING_NAME_AND_KEY = "%s (%s)";
 KEY_BINDING_TOOLTIP = "<Haz clic derecho para quitar la asignación>";
+RESET_POSITION = "Restablecer posición";
+ROTATE_LEFT = "Rotar a la izquierda";
+ROTATE_RIGHT = "Rotar a la derecha";
+ROTATE_TOOLTIP = "Haz clic izquierdo en el personaje y arrastra para rotar.";
 SETTINGS_BIND_KEY_TO_COMMAND_OR_CANCEL = "Asignar atajo para \"%s\" o pulsar %s para cancelar";
 SET_FOCUS = "Establecer foco";
 FOCUSTARGET = "Establecer objetivo";
@@ -74,6 +74,10 @@ OPTION_TOOLTIP_INTERACT_ICONS = "Contrôle les icônes qui s’affichent au-dess
 OPTION_TOOLTIP_STOP_AUTO_ATTACK = "Interrompt l'attaque automatique lorsque vous changez de cible.";
 KEY_BINDING_NAME_AND_KEY = "%s (%s)";
 KEY_BINDING_TOOLTIP = "<Clic droit pour retirer>";
+RESET_POSITION = "Position par défaut";
+ROTATE_LEFT = "Pivoter à gauche";
+ROTATE_RIGHT = "Pivoter à droite";
+ROTATE_TOOLTIP = "Cliquez sur le personnage et faites glisser la souris pour le faire pivoter.";
 SETTINGS_BIND_KEY_TO_COMMAND_OR_CANCEL = "Assigner un raccourci pour « %s » ou appuyer sur %s pour annuler";
 SET_FOCUS = "Définir la focalisation";
 FOCUSTARGET = "Définir la cible de focalisation";
@@ -5,6 +5,10 @@ DECIMAL_SEPERATOR = ".";
 FIRST_NUMBER = "천";
 FIRST_NUMBER_CAP = "만";
 FIRST_NUMBER_CAP_NO_SPACE = "만";
+RESET_POSITION = "위치 초기화";
+ROTATE_LEFT = "왼쪽으로 회전";
+ROTATE_RIGHT = "오른쪽으로 회전";
+ROTATE_TOOLTIP = "마우스 왼쪽 버튼으로 클릭 후 끌어 옮기면 캐릭터를 회전할 수 있습니다.";
 SECOND_NUMBER = "만";
 SECOND_NUMBER_CAP = "억";
 SECOND_NUMBER_CAP_NO_SPACE = "억";
@@ -166,6 +166,10 @@ OPTION_TOOLTIP_INTERACT_ICONS = "Определяет, какие значки
 OPTION_TOOLTIP_STOP_AUTO_ATTACK = "Прекращать автоатаку при смене цели.";
 KEY_BINDING_NAME_AND_KEY = "%s (%s)";
 KEY_BINDING_TOOLTIP = "<ПКМ, чтобы снять привязку>";
+RESET_POSITION = "Сброс позиции";
+ROTATE_LEFT = "Вращение влево";
+ROTATE_RIGHT = "Вращение вправо";
+ROTATE_TOOLTIP = "Зажмите ЛКМ и тащите курсор, чтобы вращать изображение.";
 SETTINGS_BIND_KEY_TO_COMMAND_OR_CANCEL = "Назначьте клавишу для \"%s\" или нажмите %s для отмены";
 SET_FOCUS = "Запомнить цель";
 FOCUS_TOKEN_NOT_FOUND = "<фокус отсутствует>";
@@ -163,6 +163,10 @@ OPTION_TOOLTIP_INTERACT_ICONS = "控制交互按键启用后NPC和物体上方
 OPTION_TOOLTIP_STOP_AUTO_ATTACK = "当你切换目标时停止自动攻击。";
 KEY_BINDING_NAME_AND_KEY = "%s（%s）";
 KEY_BINDING_TOOLTIP = "<右键解除键位>";
+RESET_POSITION = "重置位置";
+ROTATE_LEFT = "左转";
+ROTATE_RIGHT = "右转";
+ROTATE_TOOLTIP = "左键点击并拖曳以旋转角色";
 SETTINGS_BIND_KEY_TO_COMMAND_OR_CANCEL = "设置 \"%s\"的快捷键，或者按 %s 取消";
 SET_FOCUS = "设置焦点";
 FOCUSTARGET = "设定焦点目标";
@@ -74,6 +74,10 @@ OPTION_TOOLTIP_INTERACT_ICONS = "在啟用互動鍵功能後，控制出現在NP
 OPTION_TOOLTIP_STOP_AUTO_ATTACK = "當你切換目標時停止自動攻擊。";
 KEY_BINDING_NAME_AND_KEY = "%s(%s)";
 KEY_BINDING_TOOLTIP = "<右鍵點擊以解除綁定>";
+RESET_POSITION = "重置位置";
+ROTATE_LEFT = "向左旋轉";
+ROTATE_RIGHT = "向右旋轉";
+ROTATE_TOOLTIP = "滑鼠左鍵點擊角色並拖曳以旋轉角度。";
 SETTINGS_BIND_KEY_TO_COMMAND_OR_CANCEL = "為\"%s\"指配綁定或是按下%s以取消";
 SET_FOCUS = "設定專注目標";
 FOCUSTARGET = "設定鎖定目標";
@@ -19,6 +19,7 @@
 #include "frame/ScriptArgs.h"
 #include "frame/UnitEvent.h"
 #include "profile/ScriptTime.h"
+#include "storm/Memory.h"

 #include <cstdint>
 #include <cstring>
@@ -94,23 +95,6 @@ char *SStrDup(const char *s) {
    return fn(s, __FILE__, __LINE__);
 }

-// Storm allocator/free — the same pair the engine uses for the event-table
-// buffer (see RebuildEventTable), so its reload teardown `SMemFree`s our
-// grown buffer exactly as its own. Both `__stdcall`, 4 args (`ret 0x10`).
-// SMemAlloc flag bit 8 zero-fills (matching SetEventCount's fresh entries).
-void *SMemAlloc(unsigned size) {
-    using SMemAlloc_t = void *(__stdcall *)(unsigned size, const char *file,
-                                            int line, int flags);
-    auto fn = reinterpret_cast<SMemAlloc_t>(Offsets::FUN_STORM_SMEM_ALLOC);
-    return fn(size, __FILE__, __LINE__, 8 /* zero-fill */);
-}
-void SMemFree(void *ptr) {
-    using SMemFree_t = int(__stdcall *)(void *ptr, const char *file, int line,
-                                        int flags);
-    auto fn = reinterpret_cast<SMemFree_t>(Offsets::FUN_STORM_SMEM_FREE);
-    fn(ptr, __FILE__, __LINE__, 0);
-}
-
 // True when slot `id` of the live table can take one of our names: its name
 // is NULL (no one owns it) AND the engine never signals it by number. A NULL
 // name alone is not enough — the glue band (ids below GLUE_EVENT_COUNT) and
@@ -294,8 +278,12 @@ void Grow() {
    constexpr int kMargin = 16;
    const int deficit = (nulls < demand) ? (demand - nulls) : 0;
    const int newCount = count + deficit + kMargin;
+    // Storm's heap, like the engine's own table buffer (see RebuildEventTable),
+    // so its reload teardown SMemFrees ours the same way; zero-filled, like
+    // SetEventCount's fresh entries.
    auto *newBuf = static_cast<uint8_t *>(
-        SMemAlloc(static_cast<unsigned>(newCount) * Offsets::EVENT_ENTRY_STRIDE));
+        Storm::Alloc(static_cast<size_t>(newCount) * Offsets::EVENT_ENTRY_STRIDE, __FILE__,
+                     __LINE__, true));
    if (newBuf == nullptr)
        return; // alloc failed — keep the old table; claiming still works

@@ -323,7 +311,7 @@ void Grow() {
    Game::Ref<uint8_t *>(Offsets::VAR_EVENT_TABLE_BASE_PTR) = newBuf;
    Game::Ref<int>(Offsets::VAR_EVENT_TABLE_CAP) = newCount;
    Game::Ref<int>(Offsets::VAR_EVENT_TABLE_COUNT) = newCount;
-    SMemFree(base);
+    Storm::Free(base, __FILE__, __LINE__);

    Debug::Log::Printf("[event] grew table %d -> %d (%d NULL, %d reserved%s)",
                       count, newCount, nulls, demand,
@@ -39,19 +39,8 @@ namespace {

 // FUN_FONTSTRING_FONT_HEIGHT — __thiscall(fs, scaled-on-stack); dummy-EDX form.
 using FsFontHeight_t = float(__fastcall *)(void *fs, void *edx, int scaled);
-using GetScaledScreenAspect_t = float(__cdecl *)();
-// Declared double so the quotient is read from ST0 with `fstp qword`, as
-// GetFont stores it, not narrowed to float.
-using DivideByScreenScaleX_t = double(__stdcall *)(float);
-
-// GetFont's push (0x0079D4A5..0x0079D4C4). `aspect * 1024` is exact, so the
-// float product rounds once, as GetFont's `fstp dword` does.
-double ToUiHeight(float internal) {
-    const float aspect =
-        reinterpret_cast<GetScaledScreenAspect_t>(Offsets::FUN_COORD_GET_SCALED_SCREEN_ASPECT)();
-    const float scaled = aspect * static_cast<float>(Offsets::UI_COORD_SCALE_UNIT) * internal;
-    return reinterpret_cast<DivideByScreenScaleX_t>(Offsets::FUN_COORD_DIVIDE_BY_SCREEN_SCALE_X)(scaled);
-}
+// GetFont's push (0x0079D4A5..0x0079D4C4).
+double ToUiHeight(float internal) { return Game::InternalToPixel(internal); }

 void *FontStringSelf(void *L) { return Game::Lua::ResolveFontString(L); }
 void *FontSelf(void *L) { return Game::Lua::ResolveTypedObject(L, 1, Offsets::VAR_FONT_LUA_TYPE_ID); }
@@ -15,6 +15,7 @@

 #include "Game.h"
 #include "Offsets.h"
+#include "frame/Layout.h"

 #include <cstdint>

@@ -24,9 +25,6 @@ namespace {

 // FUN_HANDLE_RELEASE — DecRef a ref-counted handle. __fastcall(handle).
 using HandleRelease_t = void(__fastcall *)(void *handle);
-// FUN_LAYOUT_RESIZE — region layout resize (0 = invalidate). __thiscall(region,
-// int); dummy-EDX form.
-using LayoutInvalidate_t = void(__fastcall *)(void *region, void *edx, int arg);

 } // namespace

@@ -39,8 +37,7 @@ void Invalidate(void *fs) {
        Game::Ref<void *>(fs, Offsets::OFF_FONTSTRING_TEXT_BLOCK) = nullptr;
    }
    Game::Ref<uint32_t>(fs, Offsets::OFF_FONTSTRING_DIRTY_FLAGS) &= ~1u;
-    void *region = reinterpret_cast<void *>(reinterpret_cast<uintptr_t>(fs) + 0x24);
-    reinterpret_cast<LayoutInvalidate_t>(Offsets::FUN_LAYOUT_RESIZE)(region, nullptr, 0);
+    Frame::Layout::Resize(fs, false);
 }

 } // namespace FontString::Layout
@@ -54,6 +54,8 @@
 #include "Offsets.h"
 #include "frame/ClipChildren.h"
 #include "frame/Destruction.h"
+#include "frame/Layout.h"
+#include "gx/Device.h"
 #include "texture/Load.h"

 #include <cstdint>
@@ -63,19 +65,8 @@ namespace Frame::AlphaGradient {

 namespace {

-using Matrix_t = void(__fastcall *)(float *m);
 using SetProjection_t = void(__fastcall *)(const float *m);
-using GetViewport_t = void(__fastcall *)(float *minX, float *maxX, float *minY, float *maxY, float *minZ,
-                                         float *maxZ);
 using SetViewport_t = void(__stdcall *)(float minX, float maxX, float minY, float maxY, float minZ, float maxZ);
-using Convert_t = void(__fastcall *)(float *outX, float *outY, float x, float y);
-using GetRect_t = int(__fastcall *)(void *layout, void *edx, float *out);
-using GetRenderable_t = void *(__fastcall *)(void *hTex, int force, void *);
-using RsSet_t = void(__fastcall *)(int selector, int value);
-using RsSetPtr_t = void(__fastcall *)(int selector, const void *value);
-using StateOp_t = void(__fastcall *)();
-using TexMtxLoad_t = void(__fastcall *)(int unit, const float *m);
-using TexMtxOp_t = void(__fastcall *)(int unit);
 using SetFrameFlag_t = void(__fastcall *)(void *frame, void *edx, uint32_t mask, int on);

 // A rect: {bottom, left, top, right}.
@@ -135,7 +126,7 @@ void *RampTexture() {
    if (g_ramp == nullptr)
        g_ramp = Texture::CreateFromPixels("ClassicAPI\\AlphaGradient", 2, 2, kRampTexels, Texture::DefaultFlags());
    return g_ramp != nullptr
-               ? reinterpret_cast<GetRenderable_t>(Offsets::FUN_TEXTURE_GET_RENDERABLE)(g_ramp, 1, nullptr)
+               ? Texture::DeviceTexture(g_ramp)
               : nullptr;
 }

@@ -155,13 +146,12 @@ void RampColumn(const Stage &s, int axis, float vMin, float vMax, float col[4])
 }

 void Load(const Stage &s) {
-    float p[16] = {1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1};
-    reinterpret_cast<Matrix_t>(Offsets::FUN_GX_GET_PROJECTION)(p);
-    float minX, maxX, minY, maxY, minZ, maxZ;
-    reinterpret_cast<GetViewport_t>(Offsets::FUN_GX_GET_VIEWPORT)(&minX, &maxX, &minY, &maxY, &minZ, &maxZ);
+    Gx::Matrix p;
+    Gx::GetProjection(p);
+    const Gx::Viewport vp = Gx::GetViewport();
    float u[4], v[4];
-    RampColumn(s, 0, minX, maxX, u);
-    RampColumn(s, 1, minY, maxY, v);
+    RampColumn(s, 0, vp.minX, vp.maxX, u);
+    RampColumn(s, 1, vp.minY, vp.maxY, v);
    float m[16];
    for (int r = 0; r < 4; ++r) {
        const float *row = p + r * 4;
@@ -170,7 +160,7 @@ void Load(const Stage &s) {
        m[r * 4 + 2] = row[3];
        m[r * 4 + 3] = 0.0f;
    }
-    reinterpret_cast<TexMtxLoad_t>(Offsets::FUN_GX_TEXMTX_LOAD)(s.unit, m);
+    Gx::SetTransform(s.unit, m);
 }

 // Appends the stages of `frame`'s gradient at g_stages[g_count + n]. Returns
@@ -180,11 +170,9 @@ int AddStages(const void *frame, int n, int lastUnit) {
    if (it == g_gradients.end())
        return n;
    float rect[4];
-    void *layout = const_cast<uint8_t *>(static_cast<const uint8_t *>(frame) + Offsets::OFF_REGION_ANCHOR);
-    if (reinterpret_cast<GetRect_t>(Offsets::FUN_REGION_GET_RECT)(layout, nullptr, rect) == 0)
+    if (!Frame::Layout::GetRect(frame, rect))
        return n;
    const float scale = Game::Read<float>(frame, Offsets::OFF_REGION_EFFECTIVE_SCALE);
-    const auto toNdc = reinterpret_cast<Convert_t>(Offsets::FUN_COORD_DDC_TO_NDC);
    for (int index = 0; index < 2; ++index) {
        const float lx = it->second.x[index], ly = it->second.y[index];
        if (!(lx > 0.0f) && !(ly > 0.0f))
@@ -198,8 +186,8 @@ int AddStages(const void *frame, int n, int lastUnit) {
        const float dy = Game::PixelToInternal(ly * scale) * (index == 0 ? -1.0f : 1.0f);
        Stage &s = g_stages[g_count + n];
        s.unit = 1 + g_count + n;
-        toNdc(&s.p0[0], &s.p0[1], ex, ey);
-        toNdc(&s.p1[0], &s.p1[1], ex + dx, ey + dy);
+        Frame::Layout::DdcToNdc(&s.p0[0], &s.p0[1], ex, ey);
+        Frame::Layout::DdcToNdc(&s.p1[0], &s.p1[1], ex + dx, ey + dy);
        s.on[0] = lx > 0.0f && s.p1[0] != s.p0[0];
        s.on[1] = ly > 0.0f && s.p1[1] != s.p0[1];
        if (s.on[0] || s.on[1])
@@ -355,16 +343,14 @@ int Begin(const void *frame, bool ancestors) {
    void *ramp = RampTexture();
    if (ramp == nullptr)
        return 0;
-    const auto rs = reinterpret_cast<RsSet_t>(Offsets::FUN_GX_RS_SET);
-    const auto rsPtr = reinterpret_cast<RsSetPtr_t>(Offsets::FUN_GX_RS_SET_PTR);
-    reinterpret_cast<StateOp_t>(Offsets::FUN_GX_STATE_PUSH)();
+    Gx::PushStates();
    for (int i = g_count; i < g_count + n; ++i) {
        const int unit = g_stages[i].unit;
-        rsPtr(Offsets::GXRS_TEXTURE0 + unit, ramp);
-        rs(Offsets::GXRS_COMBINER0 + unit, Offsets::GXRS_COMBINE_MODULATE);
-        rs(Offsets::GXRS_TEXGEN0 + unit, Offsets::GXRS_TEXGEN_CAMERA_POS);
-        rs(Offsets::GXRS_TEXXFORM0 + unit, Offsets::GXRS_TEXXFORM_PROJECTED);
-        reinterpret_cast<TexMtxOp_t>(Offsets::FUN_GX_TEXMTX_PUSH)(unit);
+        Gx::SetState(Offsets::GXRS_TEXTURE0 + unit, ramp);
+        Gx::SetState(Offsets::GXRS_COMBINER0 + unit, Offsets::GXRS_COMBINE_MODULATE);
+        Gx::SetState(Offsets::GXRS_TEXGEN0 + unit, Offsets::GXRS_TEXGEN_CAMERA_POS);
+        Gx::SetState(Offsets::GXRS_TEXXFORM0 + unit, Offsets::GXRS_TEXXFORM_PROJECTED);
+        Gx::PushTransform(unit);
        Load(g_stages[i]);
    }
    g_count += n;
@@ -375,9 +361,9 @@ void End(int stages) {
    if (stages == 0)
        return;
    for (int i = g_count - 1; i >= g_count - stages; --i)
-        reinterpret_cast<TexMtxOp_t>(Offsets::FUN_GX_TEXMTX_POP)(g_stages[i].unit);
+        Gx::PopTransform(g_stages[i].unit);
    g_count -= stages;
-    reinterpret_cast<StateOp_t>(Offsets::FUN_GX_STATE_POP)();
+    Gx::PopStates();
 }

 int StagesInUse() { return g_count; }
@@ -30,6 +30,7 @@

 #include "Game.h"
 #include "Offsets.h"
+#include "frame/Layout.h"

 #include <cfloat>
 #include <cstdint>
@@ -43,20 +44,12 @@ struct Rect {
    float bottom, left, top, right;
 };

-using GetRect_t = int(__fastcall *)(void *layout, void *edx, Rect *out);
-using LayoutDirty_t = int(__fastcall *)(void *layout);
-using Resize_t = void(__fastcall *)(void *layout, void *edx, int force);
-
-void *LayoutOf(void *region) { return static_cast<uint8_t *>(region) + Offsets::OFF_REGION_ANCHOR; }
-
 // Grows `rect` by a region's own rect, resolving a pending layout first.
 void AddRegionRect(void *region, Rect &rect) {
-    void *layout = LayoutOf(region);
-    if (reinterpret_cast<LayoutDirty_t>(Offsets::FUN_REGION_LAYOUT_DIRTY)(layout) != 0)
-        reinterpret_cast<Resize_t>(Offsets::FUN_LAYOUT_RESIZE)(layout, nullptr, 1);
-    Rect own{};
-    if (reinterpret_cast<GetRect_t>(Offsets::FUN_REGION_GET_RECT)(layout, nullptr, &own) == 0)
+    float r[4];
+    if (!Frame::Layout::GetResolvedRect(region, r))
        return;
+    const Rect own{r[0], r[1], r[2], r[3]};
    rect.left = own.left < rect.left ? own.left : rect.left;
    rect.right = own.right > rect.right ? own.right : rect.right;
    rect.bottom = own.bottom < rect.bottom ? own.bottom : rect.bottom;
@@ -34,6 +34,7 @@

 #include "Game.h"
 #include "Offsets.h"
+#include "frame/Layout.h"

 #include <cstdint>
 #include <unordered_map>
@@ -54,10 +55,7 @@ std::unordered_map<void *, Insets> g_insets;
 using CalcRect_t = int(__thiscall *)(void *layout, float *rect);
 CalcRect_t g_origCalcRect = nullptr;

-using Invalidate_t = void(__thiscall *)(void *layout, int arg);

-void *LayoutOf(void *frame) { return static_cast<uint8_t *>(frame) + Offsets::OFF_REGION_ANCHOR; }
-void *FrameOf(void *layout) { return static_cast<uint8_t *>(layout) - Offsets::OFF_REGION_ANCHOR; }

 // A length in the frame's own units (what GetLeft returns) in layout units:
 // the inverse of Script GetLeft's conversion.
@@ -70,7 +68,7 @@ int __fastcall CalcRect_h(void *layout, void * /*edx*/, float *rect) {
    const uint32_t flags = Game::Read<uint32_t>(layout, Offsets::OFF_LAYOUT_FLAGS);
    if ((flags & Offsets::LAYOUT_FLAG_CLAMPED) == 0 || g_insets.empty())
        return g_origCalcRect(layout, rect);
-    void *frame = FrameOf(layout);
+    void *frame = Frame::Layout::OwnerOf(layout);
    const auto it = g_insets.find(frame);
    if (it == g_insets.end())
        return g_origCalcRect(layout, rect);
@@ -144,7 +142,7 @@ int __fastcall Script_SetClampRectInsets(void *L) {
    else
        g_insets[frame] = in;
    // Re-lay the frame out, as SetClampedToScreen does after changing the clamp.
-    reinterpret_cast<Invalidate_t>(Offsets::FUN_LAYOUT_RESIZE)(LayoutOf(frame), 0);
+    Frame::Layout::Resize(frame, false);
    return 0;
 }

@@ -66,10 +66,13 @@
 #include "Common.h"
 #include "Game.h"
 #include "Offsets.h"
+#include "frame/Layout.h"
 #include "frame/AlphaGradient.h"
 #include "frame/ClipChildren.h"
 #include "frame/Destruction.h"
+#include "frame/LayerChange.h"
 #include "frame/ParentChange.h"
+#include "gx/Device.h"
 #include "xml/FrameLoad.h"

 #include <cstdint>
@@ -85,14 +88,8 @@ using BatchOp_t = void(__fastcall *)(void *batch);
 using Callback_t = void(__fastcall *)(void *arg);
 using AddCallback_t = void(__fastcall *)(void *batch, void *edx, Callback_t fn, void *arg);
 using SetFrameFlag_t = void(__fastcall *)(void *frame, void *edx, uint32_t mask, int on);
-using NotifyLayerChanged_t = void(__fastcall *)(void *frame, void *edx, int layer);
 using HitTest_t = int(__fastcall *)(void *frame, void *edx, const float *point);
-using Matrix_t = void(__fastcall *)(float *m);
-using GetViewport_t = void(__fastcall *)(float *minX, float *maxX, float *minY, float *maxY, float *minZ,
-                                         float *maxZ);
-using SetViewport_t = void(__stdcall *)(float minX, float maxX, float minY, float maxY, float minZ, float maxZ);
 using SetupOrtho_t = void(__fastcall *)(const float *rect, const float *point, int unused);
-using Convert_t = void(__fastcall *)(float *outX, float *outY, float x, float y);

 // A hit rect: {bottom, left, top, right}.
 enum { BOTTOM, LEFT, TOP, RIGHT };
@@ -218,18 +215,11 @@ bool ClipRect(const void *root, float rect[4]) {
 // The ScrollFrame's draw (0x00787220) with `rect` in place of its hit rect
 // and `draw(arg)` in place of its scroll child's.
 void DrawInside(float rect[4], Callback_t draw, void *arg) {
-    float projection[16] = {1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1};
-    float view[16] = {1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1};
-    reinterpret_cast<Matrix_t>(Offsets::FUN_GX_GET_PROJECTION)(projection);
-    reinterpret_cast<Matrix_t>(Offsets::FUN_GX_GET_VIEW)(view);
-    float vpMinX, vpMaxX, vpMinY, vpMaxY, vpMinZ, vpMaxZ;
-    reinterpret_cast<GetViewport_t>(Offsets::FUN_GX_GET_VIEWPORT)(&vpMinX, &vpMaxX, &vpMinY, &vpMaxY, &vpMinZ,
-                                                                 &vpMaxZ);
-
-    const auto toDdc = reinterpret_cast<Convert_t>(Offsets::FUN_COORD_NDC_TO_DDC);
+    const Gx::SavedTransforms saved;
+    const Gx::Viewport &vp = saved.SavedViewport();
    float minX = 0, minY = 0, maxX = 0, maxY = 0;
-    toDdc(&minX, &minY, vpMinX, vpMinY);
-    toDdc(&maxX, &maxY, vpMaxX, vpMaxY);
+    Frame::Layout::NdcToDdc(&minX, &minY, vp.minX, vp.minY);
+    Frame::Layout::NdcToDdc(&maxX, &maxY, vp.maxX, vp.maxY);
    if (minX > rect[LEFT])
        rect[LEFT] = minX;
    if (maxX < rect[RIGHT])
@@ -241,9 +231,8 @@ void DrawInside(float rect[4], Callback_t draw, void *arg) {

    const float point[2] = {0, 0};
    reinterpret_cast<SetupOrtho_t>(Offsets::FUN_SETUP_ORTHO_TRANSFORMS)(rect, point, 0);
-    const auto toNdc = reinterpret_cast<Convert_t>(Offsets::FUN_COORD_DDC_TO_NDC);
-    toNdc(&rect[LEFT], &rect[BOTTOM], rect[LEFT], rect[BOTTOM]);
-    toNdc(&rect[RIGHT], &rect[TOP], rect[RIGHT], rect[TOP]);
+    Frame::Layout::DdcToNdc(&rect[LEFT], &rect[BOTTOM], rect[LEFT], rect[BOTTOM]);
+    Frame::Layout::DdcToNdc(&rect[RIGHT], &rect[TOP], rect[RIGHT], rect[TOP]);
    if (rect[LEFT] < 0.0f) {
        rect[RIGHT] -= rect[LEFT];
        rect[LEFT] = 0.0f;
@@ -261,14 +250,9 @@ void DrawInside(float rect[4], Callback_t draw, void *arg) {
        rect[TOP] = 1.0f;
    }
    if (rect[LEFT] < rect[RIGHT] && rect[BOTTOM] < rect[TOP]) {
-        reinterpret_cast<SetViewport_t>(Offsets::FUN_GX_SET_VIEWPORT)(rect[LEFT], rect[RIGHT], rect[BOTTOM],
-                                                                      rect[TOP], 0.0f, 1.0f);
+        Gx::SetViewport({rect[LEFT], rect[RIGHT], rect[BOTTOM], rect[TOP], 0.0f, 1.0f});
        draw(arg);
    }
-
-    reinterpret_cast<Matrix_t>(Offsets::FUN_GX_SET_PROJECTION)(projection);
-    reinterpret_cast<Matrix_t>(Offsets::FUN_GX_SET_VIEW)(view);
-    reinterpret_cast<SetViewport_t>(Offsets::FUN_GX_SET_VIEWPORT)(vpMinX, vpMaxX, vpMinY, vpMaxY, vpMinZ, vpMaxZ);
 }

 void __fastcall DrawClipped(void *arg) {
@@ -345,7 +329,7 @@ const Game::HookAutoRegister _hitTestHook{Offsets::FUN_FRAME_HIT_TEST, reinterpr

 void MarkLayers(void *frame) {
    for (int layer = 0; layer < Offsets::FRAME_LAYER_COUNT; ++layer)
-        reinterpret_cast<NotifyLayerChanged_t>(Offsets::FUN_FRAME_NOTIFY_LAYER_CHANGED)(frame, nullptr, layer);
+        Frame::LayerChange::NotifyFrame(frame, layer);
 }

 // Marks every layer of each frame under `frame` changed.
@@ -83,9 +83,12 @@
 #include "api/Documentation.h"
 #include "cvar/Factory.h"
 #include "frame/ExtraScripts.h"
+#include "frame/LayerChange.h"
+#include "frame/Layout.h"
 #include "frame/Region.h"
 #include "frame/RenderBatch.h"
 #include "frame/ScriptArgs.h"
+#include "frame/Subclass.h"
 #include "text/NumericFormatter.h"
 #include "texture/Load.h"
 #include "time/Clock.h"
@@ -185,9 +188,7 @@ struct Rect {
 };
 const Rect &RectOf(void *frame) { return *Game::Ptr<Rect>(frame, Offsets::OFF_REGION_RECT); }

-void *FrameOfLayout(void *layout) {
-    return static_cast<uint8_t *>(layout) - Offsets::OFF_FRAME_LAYOUT_SUBOBJECT;
-}
+using Frame::Layout::OwnerOf;

 // The alpha the frame draws with — 4.3.4's m_alpha * m_parentAlpha / 255.
 // 1.12's alpha setter copies one byte down the tree instead of multiplying.
@@ -224,28 +225,29 @@ uint32_t ColorByte(double c) {
    return static_cast<uint32_t>(c * 255.0 + 0.5);
 }

-// ---- vtables ----------------------------------------------------------------
+// ---- the class ----------------------------------------------------------------

-// An MSVC vtable with its RTTI locator in front, as the engine's are laid out.
-template <size_t N>
-struct VTable {
-    const void *locator;
-    const void *slots[N];
-};
-
-VTable<Offsets::VTBL_SIMPLEFRAME_SLOTS> g_vtable;
-VTable<Offsets::VTBL_SIMPLEFRAME_LAYOUT_SLOTS> g_layoutVtable;
-
-// CSimpleFrame's own slot, for the base call of an override.
-template <typename Fn>
-Fn Base(uintptr_t slot) {
-    return Game::Read<Fn>(reinterpret_cast<const void *>(Offsets::VTBL_SIMPLEFRAME), slot);
-}
-template <typename Fn>
-Fn LayoutBase(uintptr_t slot) {
-    return Game::Read<Fn>(reinterpret_cast<const void *>(Offsets::VTBL_SIMPLEFRAME_LAYOUT), slot);
+// CGCooldown::~CGCooldown, before CSimpleFrame's deleting destructor.
+void Destroy(void *frame) {
+    Fields &f = F(frame);
+    for (Slot &s : f.slots) {
+        Texture::ReleaseHandle(s.texture);
+        s.texture = nullptr;
+    }
+    Text::NumericFormatter::Release(f.countdownFormatter);
+    f.countdownFormatter = nullptr;
+    delete f.countdownText;
+    f.countdownText = nullptr;
 }

+Frame::Subclass::Class<Offsets::VTBL_SIMPLEFRAME_SLOTS, Offsets::VTBL_SIMPLEFRAME_LAYOUT_SLOTS>
+    g_class{"Cooldown",
+            Offsets::VTBL_SIMPLEFRAME,
+            Offsets::VTBL_SIMPLEFRAME_LAYOUT,
+            Offsets::FUN_SIMPLEFRAME_CONSTRUCTOR,
+            kObjectSize,
+            &Destroy};
+
 // 1.12's CSimpleFrame::Show / Hide, as Script Show / Hide make them.
 void Show(void *frame) {
    using Slot_t = void(__fastcall *)(void *self, void *edx);
@@ -259,10 +261,7 @@ void Hide(void *frame) {
    Game::Read<Slot_t>(Game::Read<void *>(frame, 0), Offsets::VTBL_FRAME_HIDE)(frame, nullptr);
 }

-void NotifyLayerChanged(void *frame, int layer) {
-    using Fn_t = void(__fastcall *)(void *self, void *edx, int layer);
-    reinterpret_cast<Fn_t>(Offsets::FUN_FRAME_NOTIFY_LAYER_CHANGED)(frame, nullptr, layer);
-}
+using Frame::LayerChange::NotifyFrame;

 // ---- textures ---------------------------------------------------------------

@@ -371,8 +370,6 @@ void MapStarTexCoords(Fields &f, const Rect &r) {
 void AnimateVerts(void *frame) {
    Fields &f = F(frame);
    const Rect &r = RectOf(frame);
-    const float cx = (r.minX + r.maxX) * 0.5f;
-    const float cy = (r.minY + r.maxY) * 0.5f;

    if (!f.flashing) {
        const float elapsed = static_cast<float>(f.elapsed);
@@ -482,7 +479,7 @@ void SetSlotTexture(void *frame, TextureSlot slot, const char *file, const uint3
    if (base != nullptr)
        s.base = *base;
    f.texturesSet |= 1u << slot;
-    NotifyLayerChanged(frame, kSlotLayer[slot]);
+    NotifyFrame(frame, kSlotLayer[slot]);
    UpdateColors(frame);
 }

@@ -633,25 +630,12 @@ void UpdateCountdown(void *frame) {

 // ---- the overrides ------------------------------------------------------------

-using DeletingDestructor_t = void *(__fastcall *)(void *self, void *edx, uint32_t flags);
-using GetScriptMethod_t = int(__fastcall *)(void *self, void *edx, void *L, const char *name);
-using IsA_t = bool(__fastcall *)(void *self, void *edx, int typeId);
-using IsObjectType_t = bool(__fastcall *)(void *self, void *edx, const char *name);
-using SetFrameAlpha_t = void(__fastcall *)(void *self, void *edx, uint8_t alpha);
-using OnFrameUpdate_t = void(__fastcall *)(void *self, void *edx, float elapsedSec);
-using EmitLayer_t = void(__fastcall *)(void *self, void *edx, void *batch, int layer);
+using Frame::Subclass::EmitLayer_t;
+using Frame::Subclass::LoadXML_t;
+using Frame::Subclass::OnFrameUpdate_t;
+using Frame::Subclass::SetFrameAlpha_t;
 using OnFrameSizeChanged_t = void(__fastcall *)(void *layout, void *edx, const float *oldRect);
-using LoadXML_t = uintptr_t(__fastcall *)(void *layout, void *edx, const void *node,
-                                          void *status);
-using PushMethod_t = int(__fastcall *)(void *L, const char *name, void *hash);
-
-// The class's method hash and type id (Offsets.h "Per-class method hashes").
-uint32_t g_hash[Offsets::METHOD_HASH_SIZE / 4];
-int g_typeId = 0;
-
-uintptr_t TypeIdVar() { return reinterpret_cast<uintptr_t>(&g_typeId); }
-
-const Frame::ExtraScripts::Script g_onCooldownDone{"oncooldowndone", TypeIdVar()};
+const Frame::ExtraScripts::Script g_onCooldownDone{"oncooldowndone", g_class.TypeIdVar()};

 // From the update walk, where the engine runs OnUpdate.
 void RunOnCooldownDone(void *frame) {
@@ -664,52 +648,15 @@ void RunOnCooldownDone(void *frame) {
    Frame::ScriptArgs::RunSlotWithValues(L, slot, frame, Game::Lua::GetTop(L) + 1, 0);
 }

-// CGCooldown::~CGCooldown, then CSimpleFrame's deleting destructor.
-void *__fastcall DeletingDestructor(void *self, void *, uint32_t flags) {
-    Fields &f = F(self);
-    for (Slot &s : f.slots) {
-        Texture::ReleaseHandle(s.texture);
-        s.texture = nullptr;
-    }
-    Text::NumericFormatter::Release(f.countdownFormatter);
-    f.countdownFormatter = nullptr;
-    delete f.countdownText;
-    f.countdownText = nullptr;
-    return Base<DeletingDestructor_t>(Offsets::VTBL_FRAME_DELETING_DESTRUCTOR)(self, nullptr,
-                                                                               flags);
-}
-
-void *__fastcall LayoutDeletingDestructor(void *layout, void *, uint32_t flags) {
-    return DeletingDestructor(FrameOfLayout(layout), nullptr, flags);
-}
-
-int __fastcall GetScriptMethod(void *self, void *, void *L, const char *name) {
-    if (reinterpret_cast<PushMethod_t>(Offsets::FUN_FRAMESCRIPT_PUSH_METHOD)(L, name, g_hash))
-        return 1;
-    return Base<GetScriptMethod_t>(Offsets::VTBL_FRAME_GET_SCRIPT_METHOD)(self, nullptr, L, name);
-}
-
-bool __fastcall IsA(void *self, void *, int typeId) {
-    return (g_typeId != 0 && typeId == g_typeId) ||
-           Base<IsA_t>(Offsets::VTBL_FRAME_IS_A)(self, nullptr, typeId);
-}
-
-bool __fastcall IsObjectType(void *self, void *, const char *name) {
-    return (name != nullptr && _stricmp(name, "Cooldown") == 0) ||
-           Base<IsObjectType_t>(Offsets::VTBL_FRAME_IS_OBJECT_TYPE)(self, nullptr, name);
-}
-
-const char *__fastcall GetObjectType(void *, void *) { return "Cooldown"; }
-
 // OFFSET (4.3.4): 0x009FF570 (UpdateAlpha)
 void __fastcall SetFrameAlpha(void *self, void *, uint8_t alpha) {
-    Base<SetFrameAlpha_t>(Offsets::VTBL_FRAME_SET_FRAME_ALPHA)(self, nullptr, alpha);
+    g_class.Base<SetFrameAlpha_t>(Offsets::VTBL_FRAME_SET_FRAME_ALPHA)(self, nullptr, alpha);
    UpdateColors(self);
 }

 // OFFSET (4.3.4): 0x009FF5A0 (OnLayerUpdate)
 void __fastcall OnFrameUpdate(void *self, void *, float elapsedSec) {
-    Base<OnFrameUpdate_t>(Offsets::VTBL_FRAME_ON_FRAME_UPDATE)(self, nullptr, elapsedSec);
+    g_class.Base<OnFrameUpdate_t>(Offsets::VTBL_FRAME_ON_FRAME_UPDATE)(self, nullptr, elapsedSec);
    Fields &f = F(self);
    // 4.3.4: `now <= start ? 0 : now - start`, compared wrap-safe. A paused
    // frame reads the time it was paused at.
@@ -757,7 +704,7 @@ void __fastcall OnFrameUpdate(void *self, void *, float elapsedSec) {

 // OFFSET (4.3.4): 0x009FE830 (OnFrameRender)
 void __fastcall EmitLayer(void *self, void *, void *batch, int layer) {
-    Base<EmitLayer_t>(Offsets::VTBL_FRAME_EMIT_LAYER)(self, nullptr, batch, layer);
+    g_class.Base<EmitLayer_t>(Offsets::VTBL_FRAME_EMIT_LAYER)(self, nullptr, batch, layer);
    Fields &f = F(self);
    using RenderBatch::QueueStrip;
    void *swipe = f.slots[SLOT_SWIPE].texture;
@@ -777,9 +724,9 @@ void __fastcall EmitLayer(void *self, void *, void *batch, int layer) {

 // OFFSET (4.3.4): 0x009FF580
 void __fastcall OnFrameSizeChanged(void *layout, void *, const float *oldRect) {
-    LayoutBase<OnFrameSizeChanged_t>(Offsets::VTBL_LAYOUT_ON_FRAME_SIZE_CHANGED)(layout, nullptr,
+    g_class.LayoutBase<OnFrameSizeChanged_t>(Offsets::VTBL_LAYOUT_ON_FRAME_SIZE_CHANGED)(layout, nullptr,
                                                                                 oldRect);
-    ResetVerts(FrameOfLayout(layout));
+    ResetVerts(OwnerOf(layout));
 }

 // The stock CooldownFrameTemplate: a Model template (Cooldown.xml, 1.12).
@@ -800,16 +747,15 @@ void LoadModernTemplate(void *layout) {
                                                                                         nullptr);
    reinterpret_cast<SetAllPoints_t>(Offsets::FUN_LAYOUT_SET_ALL_POINTS)(layout, nullptr, parent,
                                                                         1);
-    Hide(FrameOfLayout(layout));
+    Hide(OwnerOf(layout));
 }

 // A texture element's <Color> child into `color`, read as CSimpleTexture::
 // LoadXML reads one (it passes its load status too); false when it has none.
 bool XmlTextureColor(const void *node, void *status, uint32_t &color) {
-    using ReadColor_t = int(__fastcall *)(const void *node, uint32_t *bgra, void *status);
    for (const void *c = Xml::FirstChild(node); c != nullptr; c = Xml::NextSibling(c)) {
        if (Xml::TagIs(c, "Color")) {
-            reinterpret_cast<ReadColor_t>(Offsets::FUN_XML_READ_COLOR)(c, &color, status);
+            Xml::ReadColor(c, color, status);
            return true;
        }
    }
@@ -826,10 +772,10 @@ uintptr_t __fastcall LoadXML(void *layout, void *, const void *node, void *statu
        return 0;
    }
    const uintptr_t result =
-        LayoutBase<LoadXML_t>(Offsets::VTBL_XML_NODE_LOADER)(layout, nullptr, node, status);
+        g_class.LayoutBase<LoadXML_t>(Offsets::VTBL_XML_NODE_LOADER)(layout, nullptr, node, status);
    if (node == nullptr)
        return result;
-    Fields &f = F(FrameOfLayout(layout));
+    Fields &f = F(OwnerOf(layout));
    if (const char *reverse = Xml::Attr(node, "reverse"))
        f.reverse = Game::StringToFlag(reverse);
    if (const char *drawEdge = Xml::Attr(node, "drawEdge"))
@@ -853,7 +799,7 @@ uintptr_t __fastcall LoadXML(void *layout, void *, const void *node, void *statu
            if (!Xml::TagIs(c, kSlotTag[slot]))
                continue;
            uint32_t color = 0;
-            SetSlotTexture(FrameOfLayout(layout), static_cast<TextureSlot>(slot),
+            SetSlotTexture(OwnerOf(layout), static_cast<TextureSlot>(slot),
                           Xml::Attr(c, "file"),
                           XmlTextureColor(c, status, color) ? &color : nullptr);
        }
@@ -862,44 +808,23 @@ uintptr_t __fastcall LoadXML(void *layout, void *, const void *node, void *statu
 }

 void BuildVTables() {
-    if (g_vtable.slots[0] != nullptr)
+    if (!Frame::Subclass::BuildVTables<g_class>())
        return;
-    std::memcpy(&g_vtable, reinterpret_cast<const void *>(Offsets::VTBL_SIMPLEFRAME - 4),
-                sizeof(g_vtable));
-    std::memcpy(&g_layoutVtable,
-                reinterpret_cast<const void *>(Offsets::VTBL_SIMPLEFRAME_LAYOUT - 4),
-                sizeof(g_layoutVtable));
-    auto set = [](const void **slots, uintptr_t slot, const void *fn) { slots[slot / 4] = fn; };
-    const void **v = g_vtable.slots;
-    set(v, Offsets::VTBL_FRAME_DELETING_DESTRUCTOR, reinterpret_cast<const void *>(&DeletingDestructor));
-    set(v, Offsets::VTBL_FRAME_GET_SCRIPT_METHOD, reinterpret_cast<const void *>(&GetScriptMethod));
-    set(v, Offsets::VTBL_FRAME_IS_A, reinterpret_cast<const void *>(&IsA));
-    set(v, Offsets::VTBL_FRAME_IS_OBJECT_TYPE, reinterpret_cast<const void *>(&IsObjectType));
-    set(v, Offsets::VTBL_FRAME_GET_OBJECT_TYPE, reinterpret_cast<const void *>(&GetObjectType));
-    set(v, Offsets::VTBL_FRAME_SET_FRAME_ALPHA, reinterpret_cast<const void *>(&SetFrameAlpha));
-    set(v, Offsets::VTBL_FRAME_ON_FRAME_UPDATE, reinterpret_cast<const void *>(&OnFrameUpdate));
-    set(v, Offsets::VTBL_FRAME_EMIT_LAYER, reinterpret_cast<const void *>(&EmitLayer));
-    const void **l = g_layoutVtable.slots;
-    set(l, Offsets::VTBL_LAYOUT_ON_FRAME_SIZE_CHANGED,
-        reinterpret_cast<const void *>(&OnFrameSizeChanged));
-    set(l, Offsets::VTBL_LAYOUT_DELETING_DESTRUCTOR,
-        reinterpret_cast<const void *>(&LayoutDeletingDestructor));
-    set(l, Offsets::VTBL_XML_NODE_LOADER, reinterpret_cast<const void *>(&LoadXML));
+    auto fn = [](auto f) { return reinterpret_cast<const void *>(f); };
+    g_class.vtable.Set(Offsets::VTBL_FRAME_SET_FRAME_ALPHA, fn(&SetFrameAlpha));
+    g_class.vtable.Set(Offsets::VTBL_FRAME_ON_FRAME_UPDATE, fn(&OnFrameUpdate));
+    g_class.vtable.Set(Offsets::VTBL_FRAME_EMIT_LAYER, fn(&EmitLayer));
+    g_class.layoutVtable.Set(Offsets::VTBL_LAYOUT_ON_FRAME_SIZE_CHANGED, fn(&OnFrameSizeChanged));
+    g_class.layoutVtable.Set(Offsets::VTBL_XML_NODE_LOADER, fn(&LoadXML));
 }

 // OFFSET (4.3.4): 0x008C6390 (CGCooldown::Create) — the "Cooldown" factory.
 void *__fastcall CreateCooldown(void *parent) {
-    using SMemAlloc_t = void *(__stdcall *)(size_t size, const char *file, int line, int flags);
-    using Constructor_t = void(__fastcall *)(void *self, void *edx, void *parent);
    BuildVTables();
    // Zero-filled: 4.3.4's constructor zeroes every CGCooldown field.
-    void *frame = reinterpret_cast<SMemAlloc_t>(Offsets::FUN_STORM_SMEM_ALLOC)(
-        kObjectSize, __FILE__, __LINE__, 0x08);
+    void *frame = Frame::Subclass::New<g_class>(parent);
    if (frame == nullptr)
        return nullptr;
-    reinterpret_cast<Constructor_t>(Offsets::FUN_SIMPLEFRAME_CONSTRUCTOR)(frame, nullptr, parent);
-    Game::Ref<const void *>(frame, 0) = g_vtable.slots;
-    Game::Ref<const void *>(frame, Offsets::OFF_FRAME_LAYOUT_SUBOBJECT) = g_layoutVtable.slots;
    Fields &f = F(frame);
    f.modRate = 1.0f;
    f.drawSwipe = 1;
@@ -917,7 +842,7 @@ void *__fastcall CreateCooldown(void *parent) {

 // ---- the methods (CGCooldown_Scripts.cpp, then the later clients') -------------------

-void *ResolveCooldown(void *L) { return Game::Lua::ResolveTypedObject(L, 1, TypeIdVar()); }
+void *ResolveCooldown(void *L) { return Game::Lua::ResolveTypedObject(L, 1, g_class.TypeIdVar()); }

 // Seconds to ms on the GetTime() epoch, wrapping like the tick does.
 uint32_t Ms(double seconds) { return static_cast<uint32_t>(static_cast<int64_t>(seconds * 1000.0)); }
@@ -1046,7 +971,7 @@ int __fastcall Script_SetDrawSwipe(void *L) {
    const uint32_t drawSwipe = Game::Lua::ToFlag(L, 2, true);
    if (drawSwipe != f.drawSwipe) {
        f.drawSwipe = drawSwipe;
-        NotifyLayerChanged(frame, kSlotLayer[SLOT_SWIPE]);
+        NotifyFrame(frame, kSlotLayer[SLOT_SWIPE]);
    }
    return 0;
 }
@@ -1308,7 +1233,7 @@ int __fastcall Script_SetDrawEdge(void *L) {
    const uint32_t drawEdge = Game::Lua::ToFlag(L, 2, true);
    if (drawEdge != f.drawEdge) {
        f.drawEdge = drawEdge;
-        NotifyLayerChanged(frame, kSlotLayer[SLOT_EDGE]);
+        NotifyFrame(frame, kSlotLayer[SLOT_EDGE]);
    }
    return 0;
 }
@@ -1561,55 +1486,21 @@ const Game::Doc::Method g_methodDocs[] = {
    {"GetCountdownFormatter", &kGetCountdownFormatter},
 };

-// The engine's static initializer for a class hash (Model's 0x0076F5F0).
-void InitMethodHash() {
-    if (g_hash[0] != 0)
-        return;
-    g_hash[0] = Offsets::VTBL_METHOD_HASH_ALLOCATOR;
-    g_hash[1] = 0xC; // node link offset
-    g_hash[2] = reinterpret_cast<uintptr_t>(&g_hash[2]);
-    g_hash[3] = reinterpret_cast<uintptr_t>(&g_hash[2]) | 1;
-    g_hash[9] = 0xFFFFFFFF; // no buckets yet
-}
-
 void RegisterLuaFunctions() {
-    using RegisterFactory_t = int(__fastcall *)(const char *type, void *(__fastcall *)(void *),
-                                                int unique);
-    // The engine's frame-type table outlives the Lua state, so on a /reload
-    // the name is already there and the registrar keeps the first one. This
-    // pass runs before FrameXML loads (CGGameUI::Initialize calls
+    // This pass runs before FrameXML loads (CGGameUI::Initialize calls
    // LoadScriptFunctions first), like the engine's own game-UI list
    // FUN_00495940, where 4.3.4 registers "Cooldown".
-    InitMethodHash();
    g_countdownForCooldowns = CVar::Factory::Register(
        "countdownForCooldowns",
        "Whether to use number countdown instead of radial swipe for action button cooldowns or not.",
        Offsets::CVAR_CATEGORY_GAME, "0");
-    reinterpret_cast<RegisterFactory_t>(Offsets::FUN_FRAMEXML_REGISTER_FACTORY)(
-        "Cooldown", &CreateCooldown, 0);
-    Api::Documentation::NameWidgetSystem(g_hash, "FrameAPICooldown");
-    Game::Lua::RegisterFrameMethods(g_hash, g_methods, g_methodDocs);
+    Frame::Subclass::RegisterFactory(g_class.name, &CreateCooldown);
+    Api::Documentation::NameWidgetSystem(g_class.hash.Registry(), "FrameAPICooldown");
+    Game::Lua::RegisterFrameMethods(g_class.hash.Registry(), g_methods, g_methodDocs);
 }

 const Game::ModuleAutoRegister _autoreg{&RegisterLuaFunctions};

-// The hash's functions are references into the game Lua state, so they are
-// released with the engine's own class hashes, at the end of the game UI's
-// unregister pass while that state is still open.
-using UnregisterScriptFunctions_t = void(__cdecl *)();
-using UnregisterMethods_t = void(__fastcall *)(void *hash);
-UnregisterScriptFunctions_t UnregisterScriptFunctions_o = nullptr;
-
-void __cdecl UnregisterScriptFunctions_h() {
-    UnregisterScriptFunctions_o();
-    reinterpret_cast<UnregisterMethods_t>(Offsets::FUN_FRAMESCRIPT_UNREGISTER_METHODS)(g_hash);
-}
-
-const Game::HookAutoRegister _unregisterHook{
-    Offsets::FUN_GAMEUI_UNREGISTER_SCRIPT_FUNCTIONS,
-    reinterpret_cast<void *>(&UnregisterScriptFunctions_h),
-    reinterpret_cast<void **>(&UnregisterScriptFunctions_o)};
-
 } // namespace

 } // namespace Frame::Cooldown
@@ -0,0 +1,37 @@
+// This file is part of ClassicAPI.
+//
+// ClassicAPI is free software: you can redistribute it and/or modify it under the terms
+// of the GNU General Public License as published by the Free Software Foundation, either
+// version 3 of the License, or (at your option) any later version.
+//
+// ClassicAPI is distributed in the hope that it will be useful, but WITHOUT ANY
+// WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
+// PURPOSE. See the GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License along with
+// ClassicAPI. If not, see <https://www.gnu.org/licenses/>.
+
+#pragma once
+
+// The engine's two draw-layer invalidates: what to call after a change to
+// what a frame or a region draws, so the next batch rebuild picks it up.
+
+#include "Offsets.h"
+
+namespace Frame::LayerChange {
+
+// CSimpleFrame::NotifyLayerChanged (FUN_FRAME_NOTIFY_LAYER_CHANGED): one of
+// the frame's own draw layers.
+inline void NotifyFrame(void *frame, int layer) {
+    using Fn_t = void(__fastcall *)(void *frame, void *edx, int layer);
+    reinterpret_cast<Fn_t>(Offsets::FUN_FRAME_NOTIFY_LAYER_CHANGED)(frame, nullptr, layer);
+}
+
+// CScriptRegion::NotifyLayerChanged (FUN_REGION_NOTIFY_LAYER_CHANGED): the
+// layer the region draws in.
+inline void NotifyRegion(void *region) {
+    using Fn_t = void(__fastcall *)(void *region);
+    reinterpret_cast<Fn_t>(Offsets::FUN_REGION_NOTIFY_LAYER_CHANGED)(region);
+}
+
+} // namespace Frame::LayerChange
@@ -0,0 +1,82 @@
+// This file is part of ClassicAPI.
+//
+// ClassicAPI is free software: you can redistribute it and/or modify it under the terms
+// of the GNU General Public License as published by the Free Software Foundation, either
+// version 3 of the License, or (at your option) any later version.
+//
+// ClassicAPI is distributed in the hope that it will be useful, but WITHOUT ANY
+// WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
+// PURPOSE. See the GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License along with
+// ClassicAPI. If not, see <https://www.gnu.org/licenses/>.
+
+#pragma once
+
+// The layout sub-object every region and frame has (4.3.4's CLayoutFrame, at
+// OFF_REGION_ANCHOR, which is OFF_FRAME_LAYOUT_SUBOBJECT for a frame) and the
+// engine calls on it. Each call here takes the region or frame itself.
+
+#include "Offsets.h"
+
+#include <cstdint>
+
+namespace Frame::Layout {
+
+static_assert(Offsets::OFF_REGION_ANCHOR == Offsets::OFF_FRAME_LAYOUT_SUBOBJECT,
+              "a frame's layout sub-object is where a region's is");
+
+// The layout sub-object: `this` for SetPoint and the calls below.
+inline void *Of(const void *object) {
+    return const_cast<uint8_t *>(static_cast<const uint8_t *>(object) + Offsets::OFF_REGION_ANCHOR);
+}
+
+// Layout units (DDC, the space rects are stored in) to the device's 0..1
+// (NDC) and back: each axis scaled by the screen's (VAR_COORD_DDC_*_SCALE).
+// Either out pointer may be null, and may alias its input.
+inline void DdcToNdc(float *outX, float *outY, float x, float y) {
+    using Fn = void(__fastcall *)(float *, float *, float, float);
+    reinterpret_cast<Fn>(Offsets::FUN_COORD_DDC_TO_NDC)(outX, outY, x, y);
+}
+inline void NdcToDdc(float *outX, float *outY, float x, float y) {
+    using Fn = void(__fastcall *)(float *, float *, float, float);
+    reinterpret_cast<Fn>(Offsets::FUN_COORD_NDC_TO_DDC)(outX, outY, x, y);
+}
+
+// The region or frame a layout sub-object belongs to, for the layout
+// vtable's overrides and hooks.
+inline void *OwnerOf(void *layout) {
+    return static_cast<uint8_t *>(layout) - Offsets::OFF_REGION_ANCHOR;
+}
+
+// CLayoutFrame::GetRect (FUN_REGION_GET_RECT): {bottom, left, top, right} in
+// layout units. False while the object has no valid rect.
+inline bool GetRect(const void *object, float (&rect)[4]) {
+    using Fn = int(__thiscall *)(void *, float *);
+    return reinterpret_cast<Fn>(Offsets::FUN_REGION_GET_RECT)(Of(object), rect) != 0;
+}
+
+// IsResizePending (FUN_REGION_LAYOUT_DIRTY): a layout change waits for the
+// layout pass.
+inline bool IsResizePending(const void *object) {
+    using Fn = int(__thiscall *)(void *);
+    return reinterpret_cast<Fn>(Offsets::FUN_REGION_LAYOUT_DIRTY)(Of(object)) != 0;
+}
+
+// CLayoutFrame::Resize (FUN_LAYOUT_RESIZE): `now` lays the object out at
+// once; otherwise it is marked to be laid out later, the path SetPoint takes.
+inline void Resize(void *object, bool now) {
+    using Fn = void(__thiscall *)(void *, int);
+    reinterpret_cast<Fn>(Offsets::FUN_LAYOUT_RESIZE)(Of(object), now ? 1 : 0);
+}
+
+// The edge getters' read (Script GetLeft 0x007A1A19): a pending resize run
+// now, then the rect. A hidden object, which the layout pass skips, gets a
+// rect this way.
+inline bool GetResolvedRect(void *object, float (&rect)[4]) {
+    if (IsResizePending(object))
+        Resize(object, true);
+    return GetRect(object, rect);
+}
+
+} // namespace Frame::Layout
@@ -72,6 +72,7 @@
 #include "Game.h"
 #include "HookSecureFunc.h"
 #include "Offsets.h"
+#include "frame/Layout.h"
 #include "frame/ScriptBindings.h"

 #include <cstdint>
@@ -104,13 +105,10 @@ int __fastcall Script_SetSize(void *L) {
 }

 using LayoutExtent_t = float(__thiscall *)(void *layout);
-using LayoutDirty_t = int(__fastcall *)(void *layout);
-using LayoutResize_t = void(__fastcall *)(void *layout, void *edx, int force);
-using LayoutGetRect_t = int(__fastcall *)(void *layout, void *edx, float *out);

 // The explicit size of `self` in layout `slot`; 0 when none is set.
 float ExplicitExtent(void *self, int slot) {
-    void *layout = static_cast<uint8_t *>(self) + Offsets::OFF_REGION_ANCHOR;
+    void *layout = Frame::Layout::Of(self);
    auto *vtable = Game::Read<uintptr_t *>(layout, 0);
    return reinterpret_cast<LayoutExtent_t>(vtable[slot / sizeof(uintptr_t)])(layout);
 }
@@ -145,13 +143,10 @@ void PushUnscaledExtent(void *L, bool ignoreRect, int slot, bool vertical) {
    void *self = Game::Lua::ResolveRegion(L);
    if (self == nullptr)
        return;
-    void *layout = static_cast<uint8_t *>(self) + Offsets::OFF_REGION_ANCHOR;
    float extent = ExplicitExtent(self, slot);
    if (extent == 0.0f && !ignoreRect) {
-        if (reinterpret_cast<LayoutDirty_t>(Offsets::FUN_REGION_LAYOUT_DIRTY)(layout) != 0)
-            reinterpret_cast<LayoutResize_t>(Offsets::FUN_LAYOUT_RESIZE)(layout, nullptr, 1);
        float rect[4] = {0.0f, 0.0f, 0.0f, 0.0f}; // {bottom, left, top, right}
-        if (reinterpret_cast<LayoutGetRect_t>(Offsets::FUN_REGION_GET_RECT)(layout, nullptr, rect) != 0)
+        if (Frame::Layout::GetResolvedRect(self, rect))
            extent = (vertical ? rect[2] - rect[0] : rect[3] - rect[1]) /
                     Game::Read<float>(self, Offsets::OFF_REGION_EFFECTIVE_SCALE);
    }
@@ -44,6 +44,7 @@
 #include "Common.h"
 #include "Game.h"
 #include "Offsets.h"
+#include "frame/Layout.h"
 #include "baselib/Ascii.h"
 #include "frame/Destruction.h"
 #include "frame/MotionFocus.h"
@@ -63,7 +64,6 @@ using EnableEvent_t = void(__thiscall *)(void *frame, int kind, int priority);
 using DisableEvent_t = void(__thiscall *)(void *frame, int kind);
 using Button_t = void(__thiscall *)(void *frame, const void *event);
 using HitTest_t = int(__thiscall *)(void *frame, const float *point);
-using NDCToDDC_t = void(__fastcall *)(float *outX, float *outY, float x, float y);

 // Frames with their mouse bit on and that half off.
 std::unordered_set<void *> g_clickOff;
@@ -119,7 +119,7 @@ void ClickTargets(uint8_t *ctx, std::vector<void *> &out) {
    void *const primary = Game::Read<void *>(ctx, Offsets::OFF_UI_CONTEXT_MOUSE_FOCUS);
    const float *mouse = Game::Ptr<float>(ctx, Offsets::OFF_UI_CONTEXT_MOUSE_POSITION);
    float point[2] = {0.0f, 0.0f};
-    reinterpret_cast<NDCToDDC_t>(Offsets::FUN_COORD_NDC_TO_DDC)(&point[0], &point[1], mouse[0], mouse[1]);
+    Frame::Layout::NdcToDdc(&point[0], &point[1], mouse[0], mouse[1]);
    const auto hitTest = reinterpret_cast<HitTest_t>(Offsets::FUN_FRAME_HIT_TEST);

    bool pastPrimary = primary == nullptr;
@@ -44,6 +44,7 @@
 #include "Game.h"
 #include "Offsets.h"
 #include "frame/GetPointGuard.h"
+#include "frame/Layout.h"

 #include <cstdint>

@@ -55,9 +56,6 @@ using StringToPoint_t = int(__fastcall *)(const char *name, int *point);
 using RemoveDependent_t = void(__fastcall *)(void *relative, void *edx, void *layout, int mask);
 using GetRelative_t = void *(__thiscall *)(void *node);
 using DeleteNode_t = void(__thiscall *)(void *node, int flags);
-using LayoutDirty_t = int(__fastcall *)(void *layout);
-using Resize_t = void(__fastcall *)(void *layout, void *edx, int force);
-using GetRect_t = int(__fastcall *)(void *layout, void *edx, float *out);
 using SetPoint_t = void(__thiscall *)(void *anchor, int point, void *relAnchor, int relPoint,
                                      float x, float y, int flag);

@@ -154,12 +152,8 @@ int __fastcall Script_IsRectValid(void *L) {
    void *region = Game::Lua::ResolveRegion(L);
    if (region == nullptr)
        return 0;
-    void *layout = static_cast<uint8_t *>(region) + Offsets::OFF_REGION_ANCHOR;
-    if (reinterpret_cast<LayoutDirty_t>(Offsets::FUN_REGION_LAYOUT_DIRTY)(layout) != 0)
-        reinterpret_cast<Resize_t>(Offsets::FUN_LAYOUT_RESIZE)(layout, nullptr, 1);
    float rect[4];
-    Game::Lua::PushBoolean(
-        L, reinterpret_cast<GetRect_t>(Offsets::FUN_REGION_GET_RECT)(layout, nullptr, rect) != 0);
+    Game::Lua::PushBoolean(L, Frame::Layout::GetResolvedRect(region, rect));
    return 1;
 }

@@ -15,12 +15,12 @@

 #include "Game.h"
 #include "Offsets.h"
+#include "texture/Load.h"

 namespace Frame::RenderBatch {

 namespace {

-using GetRenderable_t = void *(__fastcall *)(void *texture, int load, void *callback);
 using ReserveQuads_t = void(__thiscall *)(void *array, uint32_t extra, int round);

 struct QuadRecord {
@@ -40,8 +40,7 @@ void QueueStrip(void *batch, void *texture, Blend blend, const C3Vector *positio
                const C2Vector *texCoords, const uint32_t *color) {
    // Loading on demand, as the texture emit does: a texture still streaming
    // is finished here, so the first rebuild already draws it.
-    void *device = reinterpret_cast<GetRenderable_t>(Offsets::FUN_TEXTURE_GET_RENDERABLE)(
-        texture, 1, nullptr);
+    void *device = Texture::DeviceTexture(texture);
    if (device == nullptr)
        return;
    reinterpret_cast<ReserveQuads_t>(Offsets::FUN_RENDERBATCH_RESERVE_QUADS)(
@@ -0,0 +1,66 @@
+// This file is part of ClassicAPI.
+//
+// ClassicAPI is free software: you can redistribute it and/or modify it under the terms
+// of the GNU General Public License as published by the Free Software Foundation, either
+// version 3 of the License, or (at your option) any later version.
+//
+// ClassicAPI is distributed in the hope that it will be useful, but WITHOUT ANY
+// WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
+// PURPOSE. See the GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License along with
+// ClassicAPI. If not, see <https://www.gnu.org/licenses/>.
+
+#include "frame/Subclass.h"
+
+namespace Frame::Subclass {
+
+namespace {
+
+// Constant-initialized, so every MethodHash's constructor can link in during
+// static initialization whatever the order of the translation units.
+MethodHash *g_hashes = nullptr;
+
+using RegisterFactory_t = int(__fastcall *)(const char *type, Factory_t factory, int unique);
+using PushMethod_t = int(__fastcall *)(void *L, const char *name, void *hash);
+using UnregisterMethods_t = void(__fastcall *)(void *hash);
+using UnregisterScriptFunctions_t = void(__cdecl *)();
+UnregisterScriptFunctions_t UnregisterScriptFunctions_o = nullptr;
+
+// The hashes' functions are references into the game Lua state.
+void __cdecl UnregisterScriptFunctions_h() {
+    UnregisterScriptFunctions_o();
+    MethodHash::ReleaseAll();
+}
+
+const Game::HookAutoRegister _unregisterHook{
+    Offsets::FUN_GAMEUI_UNREGISTER_SCRIPT_FUNCTIONS,
+    reinterpret_cast<void *>(&UnregisterScriptFunctions_h),
+    reinterpret_cast<void **>(&UnregisterScriptFunctions_o)};
+
+} // namespace
+
+void RegisterFactory(const char *type, Factory_t factory) {
+    reinterpret_cast<RegisterFactory_t>(Offsets::FUN_FRAMEXML_REGISTER_FACTORY)(type, factory, 0);
+}
+
+MethodHash::MethodHash() : words_{}, next_(g_hashes) {
+    words_[0] = Offsets::VTBL_METHOD_HASH_ALLOCATOR;
+    words_[1] = 0xC; // node link offset
+    words_[2] = reinterpret_cast<uintptr_t>(&words_[2]);
+    words_[3] = reinterpret_cast<uintptr_t>(&words_[2]) | 1;
+    words_[9] = 0xFFFFFFFF; // no buckets yet
+    g_hashes = this;
+}
+
+bool MethodHash::PushMethod(void *L, const char *name) {
+    return reinterpret_cast<PushMethod_t>(Offsets::FUN_FRAMESCRIPT_PUSH_METHOD)(L, name, words_) !=
+           0;
+}
+
+void MethodHash::ReleaseAll() {
+    for (MethodHash *h = g_hashes; h != nullptr; h = h->next_)
+        reinterpret_cast<UnregisterMethods_t>(Offsets::FUN_FRAMESCRIPT_UNREGISTER_METHODS)(h->words_);
+}
+
+} // namespace Frame::Subclass
@@ -0,0 +1,214 @@
+// This file is part of ClassicAPI.
+//
+// ClassicAPI is free software: you can redistribute it and/or modify it under the terms
+// of the GNU General Public License as published by the Free Software Foundation, either
+// version 3 of the License, or (at your option) any later version.
+//
+// ClassicAPI is distributed in the hope that it will be useful, but WITHOUT ANY
+// WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
+// PURPOSE. See the GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License along with
+// ClassicAPI. If not, see <https://www.gnu.org/licenses/>.
+
+#pragma once
+
+// The parts every frame class this DLL adds shares: copied engine vtables with
+// overrides in place, a method hash of the class's own, its type id and
+// type-name overrides, and the factory (Offsets.h "Subclassing CSimpleFrame",
+// "Per-class method hashes"). Frame::Cooldown and Model::Scene are built on it.
+
+#include "Game.h"
+#include "Offsets.h"
+#include "frame/Layout.h"
+#include "storm/Memory.h"
+
+#include <cstddef>
+#include <cstdint>
+#include <cstring>
+
+namespace Frame::Subclass {
+
+// An MSVC vtable with its RTTI locator in front, as the engine's are laid out.
+template <size_t N>
+struct VTable {
+    const void *locator;
+    const void *slots[N];
+
+    bool Built() const { return slots[0] != nullptr; }
+    // A copy of the engine vtable at `address` (its first slot).
+    void CopyFrom(uintptr_t address) {
+        std::memcpy(this, reinterpret_cast<const void *>(address - 4), sizeof(*this));
+    }
+    // `slot` is a byte offset (Offsets::VTBL_*).
+    void Set(uintptr_t slot, const void *fn) { slots[slot / 4] = fn; }
+};
+
+// The function in byte offset `slot` of the engine vtable at `address`, for
+// an override's base call.
+template <typename Fn>
+Fn Slot(uintptr_t address, uintptr_t slot) {
+    return Game::Read<Fn>(reinterpret_cast<const void *>(address), slot);
+}
+
+// A frame class's method hash, built the way the engine's static initializer
+// builds one (Model's 0x0076F5F0). Every hash is released where the engine
+// releases its own class hashes, at the end of CGGameUI::UnregisterScriptFunctions,
+// while the game Lua state is still open. Declare one at file scope.
+class MethodHash {
+  public:
+    MethodHash();
+    MethodHash(const MethodHash &) = delete;
+    MethodHash &operator=(const MethodHash &) = delete;
+
+    // What Game::Lua::RegisterFrameMethods and the documentation take.
+    void *Registry() { return words_; }
+    // FrameScriptPushMethod: pushes the method and answers true when the
+    // hash has it.
+    bool PushMethod(void *L, const char *name);
+
+    static void ReleaseAll();
+
+  private:
+    uint32_t words_[Offsets::METHOD_HASH_SIZE / 4];
+    MethodHash *next_;
+};
+
+// CSimpleFrame's own slot, for the base call of an override that answers as
+// a Frame whatever engine class the frame extends.
+template <typename Fn>
+Fn FrameBase(uintptr_t slot) {
+    return Slot<Fn>(Offsets::VTBL_SIMPLEFRAME, slot);
+}
+
+// A frame class this DLL adds: what it is and what it extends, then the
+// state the engine and the shared overrides below keep for it. Declare one
+// at file scope; the overrides take it as their template argument.
+template <size_t Slots, size_t LayoutSlots>
+struct Class {
+    const char *name;            // what GetObjectType gives and IsObjectType takes
+    uintptr_t engineVtable;      // the engine class it extends: its vtable,
+    uintptr_t engineLayoutVtable; // its layout vtable,
+    uintptr_t constructor;       // and its constructor, __thiscall (frame, parent)
+    size_t size;                 // the whole object, the engine class's part and ours
+    void (*destroy)(void *frame); // releases our part, before the engine's destructor
+
+    int typeId = 0; // the engine's type id for the class, once it names one
+    MethodHash hash;
+    VTable<Slots> vtable;
+    VTable<LayoutSlots> layoutVtable;
+
+    // What Game::Lua::ResolveTypedObject and Frame::ExtraScripts take.
+    uintptr_t TypeIdVar() { return reinterpret_cast<uintptr_t>(&typeId); }
+    // The engine class's own slot, for the base call of an override.
+    template <typename Fn>
+    Fn Base(uintptr_t slot) const {
+        return Slot<Fn>(engineVtable, slot);
+    }
+    template <typename Fn>
+    Fn LayoutBase(uintptr_t slot) const {
+        return Slot<Fn>(engineLayoutVtable, slot);
+    }
+};
+
+// ---- the overrides every class has --------------------------------------------
+
+using DeletingDestructor_t = void *(__fastcall *)(void *self, void *edx, uint32_t flags);
+using GetScriptMethod_t = int(__fastcall *)(void *self, void *edx, void *L, const char *name);
+using IsA_t = bool(__fastcall *)(void *self, void *edx, int typeId);
+using IsObjectType_t = bool(__fastcall *)(void *self, void *edx, const char *name);
+
+// The slots a class overrides for itself, for their base calls.
+using SetFrameAlpha_t = void(__fastcall *)(void *self, void *edx, uint8_t alpha);
+using OnFrameUpdate_t = void(__fastcall *)(void *self, void *edx, float elapsedSec);
+using EmitLayer_t = void(__fastcall *)(void *self, void *edx, void *batch, int layer);
+// The layout vtable's node loader (Offsets::VTBL_XML_NODE_LOADER).
+using LoadXML_t = uintptr_t(__fastcall *)(void *layout, void *edx, const void *node, void *status);
+
+// Our part released, then the engine class's deleting destructor.
+template <auto &C>
+void *__fastcall DeletingDestructor(void *self, void *, uint32_t flags) {
+    C.destroy(self);
+    return C.template Base<DeletingDestructor_t>(Offsets::VTBL_FRAME_DELETING_DESTRUCTOR)(
+        self, nullptr, flags);
+}
+
+template <auto &C>
+void *__fastcall LayoutDeletingDestructor(void *layout, void *, uint32_t flags) {
+    return DeletingDestructor<C>(Layout::OwnerOf(layout), nullptr, flags);
+}
+
+// The class's methods, then a Frame's: none of the engine class's own
+// (ModelScene has no Model methods).
+template <auto &C>
+int __fastcall GetScriptMethod(void *self, void *, void *L, const char *name) {
+    if (C.hash.PushMethod(L, name))
+        return 1;
+    return FrameBase<GetScriptMethod_t>(Offsets::VTBL_FRAME_GET_SCRIPT_METHOD)(self, nullptr, L,
+                                                                               name);
+}
+
+// The class, then what a Frame is (retail's ModelScene is not a Model).
+template <auto &C>
+bool __fastcall IsA(void *self, void *, int typeId) {
+    return (C.typeId != 0 && typeId == C.typeId) ||
+           FrameBase<IsA_t>(Offsets::VTBL_FRAME_IS_A)(self, nullptr, typeId);
+}
+
+template <auto &C>
+bool __fastcall IsObjectType(void *self, void *, const char *name) {
+    return (name != nullptr && Game::StrCmpI(name, C.name) == 0) ||
+           FrameBase<IsObjectType_t>(Offsets::VTBL_FRAME_IS_OBJECT_TYPE)(self, nullptr, name);
+}
+
+template <auto &C>
+const char *__fastcall GetObjectType(void *, void *) {
+    return C.name;
+}
+
+// Copies the engine class's two vtables and puts in the overrides above, with
+// CSimpleFrame's script names (+0x0C) to match its methods. False when they
+// are built already; on true the caller puts in its own overrides.
+template <auto &C>
+bool BuildVTables() {
+    if (C.vtable.Built())
+        return false;
+    C.vtable.CopyFrom(C.engineVtable);
+    C.layoutVtable.CopyFrom(C.engineLayoutVtable);
+    auto fn = [](auto f) { return reinterpret_cast<const void *>(f); };
+    C.vtable.Set(Offsets::VTBL_FRAME_DELETING_DESTRUCTOR, fn(&DeletingDestructor<C>));
+    C.vtable.Set(Offsets::VTBL_FRAME_GET_SCRIPT_METHOD, fn(&GetScriptMethod<C>));
+    C.vtable.Set(Offsets::VTBL_FRAME_SCRIPT_RESOLVER,
+                 FrameBase<const void *>(Offsets::VTBL_FRAME_SCRIPT_RESOLVER));
+    C.vtable.Set(Offsets::VTBL_FRAME_IS_A, fn(&IsA<C>));
+    C.vtable.Set(Offsets::VTBL_FRAME_IS_OBJECT_TYPE, fn(&IsObjectType<C>));
+    C.vtable.Set(Offsets::VTBL_FRAME_GET_OBJECT_TYPE, fn(&GetObjectType<C>));
+    C.layoutVtable.Set(Offsets::VTBL_LAYOUT_DELETING_DESTRUCTOR,
+                       fn(&LayoutDeletingDestructor<C>));
+    return true;
+}
+
+// A new frame of the class, shaped like the engine's factories (the "Frame"
+// one, 0x006EEC10): a Storm block for the whole object, zero-filled, the
+// engine class's constructor, then our vtables, which BuildVTables must have
+// built. Null when the allocation fails.
+template <auto &C>
+void *New(void *parent) {
+    using Constructor_t = void(__fastcall *)(void *self, void *edx, void *parent);
+    void *frame = Storm::Alloc(C.size, __FILE__, __LINE__, true);
+    if (frame == nullptr)
+        return nullptr;
+    reinterpret_cast<Constructor_t>(C.constructor)(frame, nullptr, parent);
+    Game::Ref<const void *>(frame, 0) = C.vtable.slots;
+    Game::Ref<const void *>(frame, Offsets::OFF_FRAME_LAYOUT_SUBOBJECT) = C.layoutVtable.slots;
+    return frame;
+}
+
+using Factory_t = void *(__fastcall *)(void *parent);
+
+// Adds the frame type to CreateFrame and XML (FUN_FRAMEXML_REGISTER_FACTORY).
+// The engine's type table outlives the Lua state, so on a /reload the name
+// is there already and the engine keeps the first factory.
+void RegisterFactory(const char *type, Factory_t factory);
+
+} // namespace Frame::Subclass
@@ -0,0 +1,157 @@
+// This file is part of ClassicAPI.
+//
+// ClassicAPI is free software: you can redistribute it and/or modify it under the terms
+// of the GNU General Public License as published by the Free Software Foundation, either
+// version 3 of the License, or (at your option) any later version.
+//
+// ClassicAPI is distributed in the hope that it will be useful, but WITHOUT ANY
+// WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
+// PURPOSE. See the GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License along with
+// ClassicAPI. If not, see <https://www.gnu.org/licenses/>.
+
+#pragma once
+
+// The graphics device's transforms: its projection and view matrices and its
+// viewport (Offsets.h, at FUN_GX_GET_PROJECTION). The engine's own draws that
+// leave the UI pass's transforms (SimpleModelDraw 0x0076D240, the ScrollFrame
+// draw 0x00787220, the portrait bake) save all three first and restore them
+// after; SavedTransforms does that for a scope.
+
+#include "Offsets.h"
+#include "gx/Matrix.h"
+
+#include <cstdint>
+
+namespace Gx {
+
+inline void GetProjection(Matrix &m) {
+    reinterpret_cast<void(__fastcall *)(float *)>(Offsets::FUN_GX_GET_PROJECTION)(m);
+}
+inline void SetProjection(const Matrix &m) {
+    reinterpret_cast<void(__fastcall *)(const float *)>(Offsets::FUN_GX_SET_PROJECTION)(m);
+}
+inline void GetView(Matrix &m) {
+    reinterpret_cast<void(__fastcall *)(float *)>(Offsets::FUN_GX_GET_VIEW)(m);
+}
+inline void SetView(const Matrix &m) {
+    reinterpret_cast<void(__fastcall *)(const float *)>(Offsets::FUN_GX_SET_VIEW)(m);
+}
+
+// In NDC, 0 to 1.
+struct Viewport {
+    float minX, maxX, minY, maxY, minZ, maxZ;
+};
+
+inline Viewport GetViewport() {
+    using Fn = void(__fastcall *)(float *, float *, float *, float *, float *, float *);
+    Viewport v{};
+    reinterpret_cast<Fn>(Offsets::FUN_GX_GET_VIEWPORT)(&v.minX, &v.maxX, &v.minY, &v.maxY, &v.minZ,
+                                                      &v.maxZ);
+    return v;
+}
+inline void SetViewport(const Viewport &v) {
+    using Fn = void(__stdcall *)(float, float, float, float, float, float);
+    reinterpret_cast<Fn>(Offsets::FUN_GX_SET_VIEWPORT)(v.minX, v.maxX, v.minY, v.maxY, v.minZ,
+                                                      v.maxZ);
+}
+
+// ---- render states (GXRS_*) -----------------------------------------------------
+// The device journals each state written after a push; the pop puts every one
+// back. The engine brackets each region-layer draw in a pair.
+
+inline void PushStates() { reinterpret_cast<void(__fastcall *)()>(Offsets::FUN_GX_STATE_PUSH)(); }
+inline void PopStates() { reinterpret_cast<void(__fastcall *)()>(Offsets::FUN_GX_STATE_POP)(); }
+
+// The render states written in a scope, put back when it ends.
+class SavedStates {
+  public:
+    SavedStates() { PushStates(); }
+    ~SavedStates() { PopStates(); }
+    SavedStates(const SavedStates &) = delete;
+    SavedStates &operator=(const SavedStates &) = delete;
+};
+
+inline void SetState(int state, int value) {
+    reinterpret_cast<void(__fastcall *)(int, int)>(Offsets::FUN_GX_RS_SET)(state, value);
+}
+// A pointer state: a texture bind.
+inline void SetState(int state, const void *value) {
+    reinterpret_cast<void(__fastcall *)(int, const void *)>(Offsets::FUN_GX_RS_SET_PTR)(state, value);
+}
+// A colour state (fog colour, material).
+inline void SetStateWord(int state, uint32_t value) {
+    reinterpret_cast<void(__fastcall *)(int, int, uint32_t)>(Offsets::FUN_GX_RS_SET_WORD)(state, 0, value);
+}
+inline void SetStateFloat(int state, float value) {
+    reinterpret_cast<void(__fastcall *)(int, int, float)>(Offsets::FUN_GX_RS_SET_FLOAT)(state, 0, value);
+}
+inline int GetState(int state) {
+    int value = 0;
+    reinterpret_cast<void(__fastcall *)(int, int *)>(Offsets::FUN_GX_RS_GET_INT)(state, &value);
+    return value;
+}
+
+// ---- transform stacks -----------------------------------------------------------
+// Each texture unit has a matrix stack, and stack 8 is the world transform.
+
+inline void PushTransform(int unit) {
+    reinterpret_cast<void(__fastcall *)(int)>(Offsets::FUN_GX_TEXMTX_PUSH)(unit);
+}
+inline void PushTransform(int unit, const float *m) {
+    reinterpret_cast<void(__fastcall *)(int, const float *)>(Offsets::FUN_GX_TEXMTX_PUSH_LOAD)(unit, m);
+}
+inline void PopTransform(int unit) {
+    reinterpret_cast<void(__fastcall *)(int)>(Offsets::FUN_GX_TEXMTX_POP)(unit);
+}
+// Over the top of the unit's stack.
+inline void SetTransform(int unit, const float *m) {
+    reinterpret_cast<void(__fastcall *)(int, const float *)>(Offsets::FUN_GX_TEXMTX_LOAD)(unit, m);
+}
+
+// ---- clear ----------------------------------------------------------------------
+
+inline uint32_t GetClearColor() {
+    uint32_t argb = 0;
+    reinterpret_cast<uint32_t *(__fastcall *)(uint32_t *)>(Offsets::FUN_GX_GET_CLEAR_COLOR)(&argb);
+    return argb;
+}
+inline void SetClearColor(uint32_t argb) {
+    reinterpret_cast<void(__stdcall *)(uint32_t)>(Offsets::FUN_GX_SET_CLEAR_COLOR)(argb);
+}
+// `mask` 1 the colour, 2 the depth.
+inline void Clear(uint32_t mask) { reinterpret_cast<void(__fastcall *)(uint32_t)>(Offsets::FUN_GX_CLEAR)(mask); }
+
+// The near and far plane points at the viewport fractions `a` (across) and
+// `b` (up), through the device view and projection: relative to the eye when
+// the view leaves it out, as a camera's does.
+inline void UnprojectScreenPoint(float (&nearPoint)[3], float (&farPoint)[3], float a, float b) {
+    using Fn = void(__fastcall *)(float *, float *, float, float);
+    reinterpret_cast<Fn>(Offsets::FUN_UNPROJECT_SCREEN_POINT)(nearPoint, farPoint, a, b);
+}
+
+// The projection, view and viewport, put back when the scope ends.
+class SavedTransforms {
+  public:
+    SavedTransforms() : viewport_(GetViewport()) {
+        GetProjection(projection_);
+        GetView(view_);
+    }
+    ~SavedTransforms() {
+        SetProjection(projection_);
+        SetView(view_);
+        SetViewport(viewport_);
+    }
+    SavedTransforms(const SavedTransforms &) = delete;
+    SavedTransforms &operator=(const SavedTransforms &) = delete;
+
+    const Viewport &SavedViewport() const { return viewport_; }
+
+  private:
+    Matrix projection_;
+    Matrix view_;
+    Viewport viewport_;
+};
+
+} // namespace Gx
@@ -0,0 +1,86 @@
+// This file is part of ClassicAPI.
+//
+// ClassicAPI is free software: you can redistribute it and/or modify it under the terms
+// of the GNU General Public License as published by the Free Software Foundation, either
+// version 3 of the License, or (at your option) any later version.
+//
+// ClassicAPI is distributed in the hope that it will be useful, but WITHOUT ANY
+// WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
+// PURPOSE. See the GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License along with
+// ClassicAPI. If not, see <https://www.gnu.org/licenses/>.
+
+#pragma once
+
+// The engine's 4x4 matrix helpers (Offsets.h FUN_MATRIX_*, FUN_TRANSFORM_*).
+// Matrices are row-vector: a point is a row times the matrix, rows 0..2 are
+// the scaled axes and row 3 the translation. Each transform below
+// pre-multiplies, so the one called last applies to a point first.
+
+#include "Offsets.h"
+
+#include <cstring>
+
+namespace Gx {
+
+using Matrix = float[16];
+
+inline void Identity(float *m) {
+    std::memset(m, 0, sizeof(Matrix));
+    m[0] = m[5] = m[10] = m[15] = 1.0f;
+}
+
+// TranslateMatrix: row 3 += t · rows 0..2.
+inline void Translate(float *m, const float (&t)[3]) {
+    reinterpret_cast<void(__thiscall *)(float *, const float *)>(Offsets::FUN_MATRIX_TRANSLATE)(m, t);
+}
+
+// RotateMatrix: by `angle` radians about the unit `axis`.
+inline void Rotate(float *m, float angle, const float (&axis)[3]) {
+    reinterpret_cast<void(__thiscall *)(float *, float, const float *, int)>(Offsets::FUN_MATRIX_ROTATE)(
+        m, angle, axis, 1);
+}
+
+// By the quaternion {x, y, z, w}.
+inline void RotateQuaternion(float *m, const float *q) {
+    reinterpret_cast<void(__thiscall *)(float *, const float *)>(Offsets::FUN_MATRIX_ROTATE_QUATERNION)(m, q);
+}
+
+inline void Scale(float *m, float s) {
+    reinterpret_cast<void(__thiscall *)(float *, float)>(Offsets::FUN_MATRIX_SCALE)(m, s);
+}
+
+// MultiplyMatrix4: out = a × b.
+inline void Multiply(float *out, const float *a, const float *b) {
+    reinterpret_cast<float *(__fastcall *)(float *, const float *, const float *)>(Offsets::FUN_MATRIX_MULTIPLY)(
+        out, a, b);
+}
+
+// m = m × b.
+inline void MultiplyInPlace(float *m, const float *b) {
+    reinterpret_cast<float *(__thiscall *)(float *, const float *)>(Offsets::FUN_MATRIX_MULTIPLY_IN_PLACE)(m, b);
+}
+
+// InvertAffineMatrix: the inverse of a rotation, uniform `scale` and
+// translation.
+inline void InvertAffine(const float *m, float *out, float scale) {
+    reinterpret_cast<void(__thiscall *)(const float *, float *, float)>(Offsets::FUN_MATRIX_INVERT_AFFINE)(
+        m, out, scale);
+}
+
+// The point through the matrix (`in` and `out` may be the same).
+inline void TransformPoint(const float (&in)[3], const float *m, float (&out)[3]) {
+    float v[3] = {in[0], in[1], in[2]};
+    reinterpret_cast<float *(__fastcall *)(float *, float *, const float *)>(Offsets::FUN_TRANSFORM_POINT_IN_PLACE)(
+        out, v, m);
+}
+
+// The box {min xyz, max xyz} through the matrix, as the box around its
+// transformed corners.
+inline void TransformBox(const float *m, const float (&box)[6], float (&out)[6]) {
+    reinterpret_cast<void(__fastcall *)(const float *, const float *, float *)>(Offsets::FUN_TRANSFORM_BOX)(m, box,
+                                                                                                           out);
+}
+
+} // namespace Gx
@@ -0,0 +1,97 @@
+// This file is part of ClassicAPI.
+//
+// ClassicAPI is free software: you can redistribute it and/or modify it under the terms
+// of the GNU General Public License as published by the Free Software Foundation, either
+// version 3 of the License, or (at your option) any later version.
+//
+// ClassicAPI is distributed in the hope that it will be useful, but WITHOUT ANY
+// WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
+// PURPOSE. See the GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License along with
+// ClassicAPI. If not, see <https://www.gnu.org/licenses/>.
+
+// `GetCursorDelta()` -> deltaX, deltaY
+//
+// Retail's: how far the cursor moved since the last frame, zero when it did
+// not, in GetCursorPosition's units (independent of the UI scale; InputUtil.
+// GetCursorDelta divides by a frame's effective scale). The orbit camera of
+// a ModelScene drags with it.
+//
+// The cursor is sampled once a frame, at the head of the UI render callback,
+// before any OnUpdate runs, the way the in-game GetCursorPosition (0x0048B820)
+// reads it: the top's NDC position (OFF_UI_CONTEXT_MOUSE_POSITION) through
+// NDCToDDC, then the engine's script push (Game::InternalToPixel). The delta is
+// this frame's sample less the last frame's, so every OnUpdate of a frame sees
+// the same value.
+
+#include "Game.h"
+#include "Offsets.h"
+#include "frame/Layout.h"
+#include "tick/FrameTick.h"
+
+namespace Input::CursorDelta {
+
+namespace {
+
+struct Position {
+    double x = 0.0;
+    double y = 0.0;
+};
+
+Position g_previous;
+Position g_current;
+bool g_sampled = false;
+
+// What GetCursorPosition pushes now, or false before the UI top exists.
+bool ReadCursor(Position &out) {
+    const void *top = Game::Read<const void *>(Offsets::VAR_UI_CONTEXT_PTR);
+    if (top == nullptr)
+        return false;
+    const float ndcX = Game::Read<float>(top, Offsets::OFF_UI_CONTEXT_MOUSE_POSITION);
+    const float ndcY = Game::Read<float>(top, Offsets::OFF_UI_CONTEXT_MOUSE_POSITION + 4);
+    float ddcX = 0.0f;
+    float ddcY = 0.0f;
+    Frame::Layout::NdcToDdc(&ddcX, &ddcY, ndcX, ndcY);
+    out = {Game::InternalToPixel(ddcX), Game::InternalToPixel(ddcY)};
+    return true;
+}
+
+void Sample() {
+    Position now;
+    if (!ReadCursor(now))
+        return;
+    g_previous = g_sampled ? g_current : now;
+    g_current = now;
+    g_sampled = true;
+}
+
+const Tick::FrameTick::AutoSubscribeBefore _tick{&Sample};
+
+int __fastcall Script_GetCursorDelta(void *L) {
+    Game::Lua::PushNumber(L, g_current.x - g_previous.x);
+    Game::Lua::PushNumber(L, g_current.y - g_previous.y);
+    return 2;
+}
+
+const Game::Doc::Field kRets[] = {
+    Game::Doc::Req("deltaX", "number"),
+    Game::Doc::Req("deltaY", "number"),
+};
+const Game::Doc::Function kDoc{"Returns how far the cursor moved since the last frame.", {},
+                               kRets, "Input"};
+
+void RegisterInGame() {
+    Game::Lua::RegisterGlobalFunction("GetCursorDelta", &Script_GetCursorDelta, &kDoc);
+}
+
+void RegisterGlue() {
+    Game::Lua::RegisterGlueFunction("GetCursorDelta", &Script_GetCursorDelta, &kDoc);
+}
+
+const Game::ModuleAutoRegister _autoreg{&RegisterInGame};
+const Game::GlueModuleAutoRegister _autoregGlue{&RegisterGlue};
+
+} // namespace
+
+} // namespace Input::CursorDelta
@@ -93,6 +93,7 @@
 #include "Game.h"
 #include "Offsets.h"
 #include "debug/Log.h"
+#include "storm/Memory.h"

 #include <windows.h>

@@ -114,7 +115,6 @@ namespace {
 using FileRead_t = int(__stdcall *)(int unused, const char *path, void **outBuf,
                                    unsigned int *outSize, unsigned int extraBytes,
                                    int flag1, int flag2);
-using SMemFree_t = void(__stdcall *)(void *ptr, const char *file, int line, int flags);

 // MPQ enumerator (see Offsets::FUN_MPQ_ENUM_FILES). The callback
 // receives each listfile entry's full path in ecx; returning 0 STOPS
@@ -301,7 +301,6 @@ void ScanPathGetters(Collector &c) {
 int WriteFiles(const std::vector<std::string> &files, size_t prefixLen,
               const char *dstRoot, int *skipped) {
    auto FileRead = reinterpret_cast<FileRead_t>(Offsets::FUN_FILE_READ);
-    auto SMemFree = reinterpret_cast<SMemFree_t>(Offsets::FUN_STORM_SMEM_FREE);

    int written = 0;
    int missed = 0;
@@ -327,7 +326,7 @@ int WriteFiles(const std::vector<std::string> &files, size_t prefixLen,
                               static_cast<unsigned long>(GetLastError()), dst.c_str());
        }

-        SMemFree(buf, __FILE__, __LINE__, 0);
+        Storm::Free(buf, __FILE__, __LINE__);
    }
    if (skipped != nullptr)
        *skipped = missed;
@@ -84,8 +84,6 @@ Vec3 GetVector(void *camera, uint32_t id) {
    return v;
 }

-namespace {
-
 void SetVector(void *camera, uint32_t id, const Vec3 &v) {
    reinterpret_cast<SetVector_t>(Offsets::FUN_CAMERA_SET_VECTOR)(camera, id, &v.x, 0);
 }
@@ -98,6 +96,13 @@ void SetScalar(void *camera, uint32_t id, float value) {
    reinterpret_cast<SetScalar_t>(Offsets::FUN_CAMERA_SET_SCALAR)(camera, id, value);
 }

+void SetDeviceTransforms(void *camera, const float (&rect)[4]) {
+    using Fn = void(__fastcall *)(void *camera, const float *rect, uint32_t unused);
+    reinterpret_cast<Fn>(Offsets::FUN_CAMERA_SET_DEVICE_TRANSFORMS)(camera, rect, 0);
+}
+
+namespace {
+
 // ConfigureCamera's own evaluation pass: facing 0, rebuild the root
 // transform, animate the scene, restore the facing.
 void AnimateUnrotated(void *pane, void *model) {
@@ -21,7 +21,16 @@ struct Vec3 {
 // The M2 model's camera with id `id` (0 = portrait), or null when it has none.
 void *CameraById(void *model, uint32_t id);

-// A camera's vector property (Offsets::CAMERA_PROP_EYE / _TARGET).
+// A camera's properties (Offsets::CAMERA_PROP_*): vectors (eye, target) and
+// scalars (clips, field of view, roll, yaw).
 Vec3 GetVector(void *camera, uint32_t id);
+void SetVector(void *camera, uint32_t id, const Vec3 &v);
+float GetScalar(void *camera, uint32_t id);
+void SetScalar(void *camera, uint32_t id, float value);
+
+// CameraSetDeviceTransforms (FUN_CAMERA_SET_DEVICE_TRANSFORMS): the device's
+// projection and view from the camera, framed over `rect` {bottom, left,
+// top, right}.
+void SetDeviceTransforms(void *camera, const float (&rect)[4]);

 } // namespace Model::Camera
@@ -96,8 +96,8 @@ constexpr uint32_t kGeosetGroupDefaults[16] = {1,   101,  201,  301,  401,  501,
 using CharCompCreate_t = void *(__cdecl *)();
 using CharCompDestroy_t = void(__fastcall *)(void *builder);
 using CharCompSetInfo_t = char(__thiscall *)(void *builder, const CharCompInfo *info);
-using CharCompSetItem_t = void(__thiscall *)(void *builder, int slot, int itemDisplayID);
-using CharCompPump_t = char(__thiscall *)(void *builder, int *unused);
+using CharCompSetItem_t = void(__thiscall *)(void *builder, uint32_t slot, uint32_t itemDisplayID);
+using CharCompPump_t = char(__thiscall *)(void *builder, int force);

 // A pending / finished dress for one Model frame. The model loads async, and
 // the engine only dresses a LOADED model (its poll gate FUN_00607da0 checks
@@ -301,10 +301,32 @@ const uint8_t *DressRecord(uint32_t displayID) {
    return bake != nullptr && bake[0] != '\0' ? extraRec : nullptr;
 }

+void *CreateDisplayModel(void *scene, uint32_t displayID, const char **path) {
+    using ApplyDisplay_t = void(__fastcall *)(void *model, const uint8_t *display,
+                                              const uint8_t *modelData);
+    const uint8_t *display = DBC::Record(Offsets::VAR_CREATUREDISPLAYINFO_RECORDS,
+                                         Offsets::VAR_CREATUREDISPLAYINFO_COUNT, displayID);
+    if (display == nullptr)
+        return nullptr;
+    const uint8_t *modelData = DBC::Record(
+        Offsets::VAR_CREATUREMODELDATA_RECORDS, Offsets::VAR_CREATUREMODELDATA_COUNT,
+        Game::Read<uint32_t>(display, Offsets::OFF_CREATUREDISPLAYINFO_MODEL_ID));
+    if (modelData == nullptr)
+        return nullptr;
+    const char *file = Game::Read<const char *>(modelData, Offsets::OFF_CREATUREMODELDATA_MODEL_PATH);
+    if (path != nullptr)
+        *path = file;
+    void *model = M2::CreateModel(scene, file);
+    if (model != nullptr)
+        reinterpret_cast<ApplyDisplay_t>(Offsets::FUN_APPLY_CREATURE_DISPLAY)(model, display,
+                                                                              modelData);
+    return model;
+}
+
 // Configure + feed equipment, the engine's order: SetInfo, then the 10 Extra
 // equipment slots. Field-for-field mirror of FUN_005fb200's NPC branch.
 void *CreateDresser(void *instance, const uint8_t *extraRec) {
-    void *builder = reinterpret_cast<CharCompCreate_t>(Offsets::FUN_CHARCOMP_CREATE)();
+    void *builder = NewDresser();
    if (builder == nullptr)
        return nullptr;

@@ -333,12 +355,10 @@ void *CreateDresser(void *instance, const uint8_t *extraRec) {
        DestroyDresser(builder); // releases the model ref already copied in
        return nullptr;
    }
-    auto setItem = reinterpret_cast<CharCompSetItem_t>(Offsets::FUN_CHARCOMP_SET_ITEM);
-    for (int slot = 0; slot < 10; ++slot) {
-        const auto displayID =
-            static_cast<int>(field(Offsets::OFF_CREATUREDISPLAYINFOEXTRA_EQUIP + slot * 4));
+    for (uint32_t slot = 0; slot < 10; ++slot) {
+        const uint32_t displayID = field(Offsets::OFF_CREATUREDISPLAYINFOEXTRA_EQUIP + slot * 4);
        if (displayID != 0)
-            setItem(builder, slot, displayID);
+            SetDresserItem(builder, slot, displayID);
    }
    return builder;
 }
@@ -348,16 +368,20 @@ void *CreateDresser(void *instance, const uint8_t *extraRec) {
 // black. Each child gets the frame's own light/fog callback; it reads the
 // frame's live light struct, so later SetLight calls reach them too.
 void LightChildren(void *frame, void *instance) {
-    const void *lightFogCb =
-        reinterpret_cast<const void *>(Offsets::FUN_SIMPLEMODELFFX_LIGHT_FOG_CB);
+    const void *callback = Game::Read<const void *>(instance, Offsets::OFF_MODEL_INSTANCE_RENDER_CB);
+    void *user = Game::Read<void *>(instance, Offsets::OFF_MODEL_INSTANCE_RENDER_CB_USER);
+    if (callback == nullptr) {
+        callback = reinterpret_cast<const void *>(Offsets::FUN_SIMPLEMODELFFX_LIGHT_FOG_CB);
+        user = frame;
+    }
    for (auto *child = Game::Read<uint8_t *>(instance, Offsets::OFF_MODEL_INSTANCE_CHILD_HEAD);
         child != nullptr;
         child = Game::Read<uint8_t *>(child, Offsets::OFF_MODEL_INSTANCE_CHILD_NEXT))
-        M2::SetRenderCallback(child, lightFogCb, frame);
+        M2::SetRenderCallback(child, callback, user);
 }

-bool PumpDresser(void *dresser) {
-    return reinterpret_cast<CharCompPump_t>(Offsets::FUN_CHARCOMP_PUMP)(dresser, nullptr) != 0;
+bool PumpDresser(void *dresser, bool force) {
+    return reinterpret_cast<CharCompPump_t>(Offsets::FUN_CHARCOMP_PUMP)(dresser, force ? 1 : 0) != 0;
 }

 void DestroyDresser(void *dresser) {
@@ -365,4 +389,20 @@ void DestroyDresser(void *dresser) {
        reinterpret_cast<CharCompDestroy_t>(Offsets::FUN_CHARCOMP_DESTROY)(dresser);
 }

+void *NewDresser() { return reinterpret_cast<CharCompCreate_t>(Offsets::FUN_CHARCOMP_CREATE)(); }
+
+void CloneDresser(void *dresser, void *model, void *source) {
+    using Clone_t = bool(__thiscall *)(void *dresser, void *model, void *source);
+    reinterpret_cast<Clone_t>(Offsets::FUN_CHARCOMP_CLONE)(dresser, model, source);
+}
+
+void UnequipDresserSlot(void *dresser, uint32_t slot) {
+    using Unequip_t = void(__thiscall *)(void *dresser, uint32_t slot);
+    reinterpret_cast<Unequip_t>(Offsets::FUN_CHARCOMP_UNEQUIP_SLOT)(dresser, slot);
+}
+
+void SetDresserItem(void *dresser, uint32_t slot, uint32_t displayID) {
+    reinterpret_cast<CharCompSetItem_t>(Offsets::FUN_CHARCOMP_SET_ITEM)(dresser, slot, displayID);
+}
+
 } // namespace Model::DisplayInfo
@@ -18,17 +18,37 @@ namespace Model::DisplayInfo {
 // null when the display gets no character customization.
 const uint8_t *DressRecord(uint32_t displayID);

+// A new model of the display in `scene`, skinned as AttachDisplayModel skins
+// one (CreateModelFromPath on the CreatureModelData path, then
+// ApplyCreatureDisplay), that the caller owns one reference on. Null for a
+// display with no CreatureDisplayInfo or CreatureModelData row. Undressed: a
+// DressRecord display still needs CreateDresser once it has loaded. `path`,
+// when given, receives the model's file path (DBC memory).
+void *CreateDisplayModel(void *scene, uint32_t displayID, const char **path = nullptr);
+
 // The engine character compositor, configured to dress the LOADED model
 // `instance` from `extraRec` (a DressRecord) and fed its equipment, or null
 // when the engine pool is empty or rejects the info. It holds a reference on
 // the model. Pump it with PumpDresser until that returns true; DestroyDresser
-// releases it (null is a no-op).
+// releases it (null is a no-op). `force` loads every texture at once,
+// ignoring the engine's per-frame load budget.
 void *CreateDresser(void *instance, const uint8_t *extraRec);
-bool PumpDresser(void *dresser);
+bool PumpDresser(void *dresser, bool force = false);
 void DestroyDresser(void *dresser);

-// Gives every model attached to `instance` the light and fog callback that
-// `frame` gives its own model, so the children are lit like it.
+// The compositor's own calls, for a dresser built another way. A new one
+// (FUN_CHARCOMP_CREATE), null when the pool is empty.
+void *NewDresser();
+// FUN_CHARCOMP_CLONE: `dresser` dresses `model` as `source` dresses its own;
+// the caller gives the dresser its reference on `model` first.
+void CloneDresser(void *dresser, void *model, void *source);
+// One component slot cleared, or set to an ItemDisplayInfo ID.
+void UnequipDresserSlot(void *dresser, uint32_t slot);
+void SetDresserItem(void *dresser, uint32_t slot, uint32_t displayID);
+
+// Gives every model attached to `instance` the light and fog callback of
+// `instance` itself, else the one `frame` gives its own model, so the
+// children are lit like it.
 void LightChildren(void *frame, void *instance);

 } // namespace Model::DisplayInfo
@@ -13,25 +13,23 @@

 // `DressUpModel:UndressSlot(slot)`, the 4.3.4 `DressUpModel:TryOn(item)`
 // (DressUpModelFrame_Scripts.cpp), and retail's TryOn result, IsGeoReady,
-// SetSheathed / GetSheathed and SetAutoDress / GetAutoDress.
+// SetSheathed / GetSheathed, SetAutoDress / GetAutoDress, IsSlotAllowed /
+// IsSlotVisible and the ItemTransmogInfo methods.
 //
 // UndressSlot is one step of vanilla's own Undress (DressUpModel::ClearModel
 // 0x00504490), which 4.3.4 split per slot: a component slot is cleared with
 // UnequipCharacterSlot, a held lane is detached with DetachHeldItemSlot and
 // zeroed. The slot map is 4.3.4's, from inventory slot to component slot.
+// That step, the lanes and the weapon hanging below are Model::Outfit's,
+// which the ModelScene actor shares.
 //
 // TryOn keeps vanilla's worker (TryOnItem, FUN_DRESSUPMODEL_TRY_ON_ITEM) and
-// takes 4.3.4's argument forms in front of it: an item ID, an item link or
-// `item:` string, a trade-skill `enchant:` link (the item its recipe makes),
-// or the name of an item the player carries. Anything else shows
+// takes the arguments Model::TryOn reads in front of it. No item shows
 // ERR_NOT_EQUIPPABLE, as 4.3.4 does.
 //
-// Retail's hand argument is an inventory slot name, matched the way
-// GetInventorySlotInfo matches it (SStrCmpI over the PaperDollItemFrame
-// rows): MainHandSlot or SecondaryHandSlot. The worker picks a hand at one
-// site (SITE_TRY_ON_HAND_CHOICE); a named hand sends a held item down that
-// hand's path, so the worker's own eviction of an incompatible other lane
-// runs, as 4.3.4's does for a forced hand.
+// The worker picks a hand at one site (SITE_TRY_ON_HAND_CHOICE); a named hand
+// sends a held item down that hand's path, so the worker's own eviction of an
+// incompatible other lane runs, as 4.3.4's does for a forced hand.
 //
 // The enchant glow is the player's AttachEnchantVisual step on the item the
 // worker hangs: FindChild at the attachment AttachItemModel used, then
@@ -41,11 +39,10 @@
 // the link's enchant field, as 4.3.4 passes it. The worker's cache callback
 // re-runs with neither hand nor enchant, as 4.3.4's does.
 //
-// 4.3.4's worker (`TryOnWithVisual`, 0x00A05010) tries on what a recipe makes:
-// an item with no inventory type whose spell teaches a CREATE_ITEM spell is
-// swapped for the made item. Vanilla's worker shows ERR_NOT_EQUIPPABLE
-// instead. `TryOnItem` adds the swap in front of the worker, for our TryOn
-// and for the worker's cache-load callback, so an uncached pattern works too.
+// Vanilla's worker shows ERR_NOT_EQUIPPABLE for a recipe, where 4.3.4's
+// tries on what it makes. `TryOnItem` adds that swap (Model::TryOn::WornItem)
+// in front of the worker, for our TryOn and for the worker's cache-load
+// callback, so an uncached pattern works too.
 //
 // TryOn's result (retail's ItemTryOnReason) is read from the same gates the
 // worker passes: an uncached record is DataPending (the worker has queued the
@@ -63,30 +60,34 @@
 //
 // Auto-dress off undresses the pane with ClearModel right after
 // SetModelInstance clones the unit, unless Dress() is the one rebuilding it.
+//
+// The ItemTransmogInfo methods are the ModelScene actor's (Outfit::Worn, the
+// item ID as the appearance, the glowing enchant as the illusion) on what the
+// pane wears: the unit's visible items when SetModelInstance builds it, then
+// each slot the worker fills (an armor arm's component slot, or the lane
+// TryOnAttach hangs) and each lane it evicts. A read first drops every slot
+// the pane no longer shows (Outfit::TrimWorn), which covers the engine's own
+// Undress. SetItemTransmogInfo is TryOn without the worker's
+// ERR_NOT_EQUIPPABLE: the worker shows it only in its default arm, once the
+// record is cached, so a quiet try-on of such an item skips the worker, then
+// or when its cache callback runs.

 #include "Game.h"
 #include "Offsets.h"
-#include "dbc/Lookup.h"
 #include "Common.h"
-#include "item/Arg.h"
-#include "item/Dressable.h"
-#include "item/ID.h"
-#include "item/Location.h"
 #include "item/Record.h"
-#include "model/ItemDisplay.h"
 #include "model/M2.h"
+#include "model/Outfit.h"
+#include "model/TryOn.h"
 #include "object/Resolve.h"

 #include <cstdint>
-#include <cstdio>
-#include <cstdlib>
-#include <cstring>
 #include <unordered_map>
+#include <unordered_set>

 namespace Model::DressUp {
 namespace {

-using UnequipSlot_t = void(__thiscall *)(void *component, uint32_t slot);
 using DetachHeldItem_t = void(__fastcall *)(void *model, uint32_t bodySlot, uint32_t sheatheType,
                                            bool shield);
 using AttachItemModel_t = int(__fastcall *)(void *model, const void *record, uint32_t bodySlot,
@@ -95,116 +96,38 @@ using AttachItemModel_t = int(__fastcall *)(void *model, const void *record, uin
 using TryOnItem_t = void(__thiscall *)(void *pane, uint32_t itemID);
 using SetModelInstance_t = void(__thiscall *)(void *pane, void *model);
 using ClearModel_t = void(__thiscall *)(void *pane);
-using GetHeldItemDisplay_t = const void *(__thiscall *)(void *unit, uint32_t hand);
-using FindChild_t = void *(__thiscall *)(void *model, int attachId);
-using GetVisibleItem_t = const void *(__thiscall *)(void *player, uint32_t slot);
-using GetDescVisual_t = int(__thiscall *)(const void *visibleItem);
-using DisplayError_t = void(__cdecl *)(uint32_t id, ...);

-// Body slots of the two held lanes.
-constexpr uint32_t kBodySlotMainHand = 0xF;
-constexpr uint32_t kBodySlotOffHand = 0x10;
-
-// Retail's Enum.ItemTryOnReason.
-constexpr int kTryOnSuccess = 0;
-constexpr int kTryOnWrongRace = 1;
-constexpr int kTryOnNotEquippable = 2;
-constexpr int kTryOnDataPending = 3;
-
-// A held lane (OFF_DRESSUPMODEL_*_HAND_LANE).
-struct HeldLane {
-    uint8_t itemClass; // 0 = empty
-    uint8_t unknown1[2];
-    uint8_t inventoryType;
-    uint8_t sheatheType;
-    uint8_t unknown5[3];
-};
-static_assert(sizeof(HeldLane) == 8, "ClearModel zeroes 8 bytes per lane");
-
-struct Lane {
-    uintptr_t offset;
-    uint32_t bodySlot;
-};
-constexpr Lane kLanes[2] = {
-    {Offsets::OFF_DRESSUPMODEL_MAIN_HAND_LANE, kBodySlotMainHand},
-    {Offsets::OFF_DRESSUPMODEL_OFF_HAND_LANE, kBodySlotOffHand},
-};
+static_assert(Offsets::OFF_DRESSUPMODEL_OFF_HAND_LANE ==
+                  Offsets::OFF_DRESSUPMODEL_MAIN_HAND_LANE + sizeof(Outfit::HeldLane),
+              "the pane's two lanes are one Outfit::Lanes");

 struct PaneState {
    bool autoDress = true;
    bool sheathSet = false; // SetSheathed was called; weapons follow the two below
    bool sheathed = false;
    bool hideWeapons = false;
-    const void *laneDisplay[2] = {}; // ItemDisplayInfo row on each lane, or null
-    uint32_t laneVisual[2] = {};     // enchant ItemVisuals row on each lane, or 0
+    Outfit::Weapons weapons;
+    Outfit::Worn worn = {};
+    std::unordered_set<uint32_t> quietPending; // quiet try-ons waiting for their record
 };
 std::unordered_map<void *, PaneState> g_panes;

 void *g_tryOnPane = nullptr;  // the pane whose TryOnItem worker is running
 uint32_t g_tryOnBodySlot = 0; // the hand TryOn named (kBodySlot*), or 0
 uint32_t g_tryOnEnchant = 0;  // the SpellItemEnchantment TryOn gave, or 0
+bool g_tryOnQuiet = false;    // the try-on shows no ERR_NOT_EQUIPPABLE
+uint32_t g_tryOnItem = 0;     // the item the worker is putting on
 bool g_dressing = false;      // Dress() is rebuilding the pane

 uintptr_t g_mainHandPath = Offsets::TRY_ON_MAIN_HAND_PATH;
 uintptr_t g_offHandPath = Offsets::TRY_ON_OFF_HAND_PATH;

-HeldLane &LaneOf(void *pane, int i) {
-    return Game::Ref<HeldLane>(pane, kLanes[i].offset);
+Outfit::Lanes &LanesOf(void *pane) {
+    return Game::Ref<Outfit::Lanes>(pane, Offsets::OFF_DRESSUPMODEL_MAIN_HAND_LANE);
 }

-int LaneIndex(uint32_t bodySlot) {
-    return bodySlot == kBodySlotOffHand ? 1 : 0;
-}
-
-// The glow `enchantID` gives an item shown with `display`: none when the
-// display has its own.
-uint32_t EnchantVisual(const void *display, uint32_t enchantID) {
-    if (display == nullptr ||
-        Model::ItemDisplay::OwnVisual(static_cast<const uint8_t *>(display)) != 0)
-        return 0;
-    const uint8_t *enchant = DBC::Record(Offsets::VAR_SPELLITEMENCHANT_RECORDS,
-                                         Offsets::VAR_SPELLITEMENCHANT_COUNT, enchantID);
-    return enchant != nullptr
-               ? Game::Read<uint32_t>(enchant, Offsets::OFF_SPELLITEMENCHANT_ITEM_VISUAL)
-               : 0;
-}
-
-// AttachEnchantVisual's step (0x005EED50): the glow on the item hung at
-// `attachId`.
-void HangVisual(void *model, int attachId, uint32_t visual) {
-    if (visual == 0 || attachId < 0)
-        return;
-    if (void *item = reinterpret_cast<FindChild_t>(Offsets::FUN_M2MODEL_FIND_CHILD)(model,
-                                                                                   attachId))
-        M2::AttachItemVisuals(item, visual);
-}
-
-// DetachHeldItemSlot on lane `i`'s item.
-void DetachLane(void *model, int i, const HeldLane &lane) {
-    reinterpret_cast<DetachHeldItem_t>(Offsets::FUN_DETACH_HELD_ITEM_SLOT)(
-        model, kLanes[i].bodySlot, lane.sheatheType,
-        lane.inventoryType == Offsets::INVTYPE_SHIELD);
-}
-
-// The unit's AttachHandItem step on each occupied lane: detach it, then hang
-// it in the hand or the sheath, or leave it off.
 void ApplyWeapons(void *pane, const PaneState &s) {
-    void *model = Pane::Model(pane);
-    if (model == nullptr)
-        return;
-    for (int i = 0; i < 2; ++i) {
-        const HeldLane &lane = LaneOf(pane, i);
-        if (lane.itemClass == 0 || s.laneDisplay[i] == nullptr)
-            continue;
-        DetachLane(model, i, lane);
-        if (s.hideWeapons)
-            continue;
-        const int attachId = reinterpret_cast<AttachItemModel_t>(Offsets::FUN_ATTACH_ITEM_MODEL)(
-            model, s.laneDisplay[i], kLanes[i].bodySlot, lane.sheatheType, s.sheathed,
-            lane.inventoryType == Offsets::INVTYPE_SHIELD,
-            lane.inventoryType == Offsets::INVTYPE_RANGEDRIGHT);
-        HangVisual(model, attachId, s.laneVisual[i]);
-    }
+    Outfit::HangWeapons(Pane::Model(pane), LanesOf(pane), s.weapons, s.sheathed, s.hideWeapons);
 }

 // Slot 36, after the original has cloned the unit and copied its lanes.
@@ -214,30 +137,11 @@ void __fastcall SetModelInstance(void *pane, void * /*edx*/, void *model) {
    if (model == nullptr)
        return;
    PaneState &s = g_panes[pane];
-    s.laneDisplay[0] = s.laneDisplay[1] = nullptr;
-    s.laneVisual[0] = s.laneVisual[1] = 0;
    // The original filled the lanes from this unit, resolved the same way.
-    const uint64_t guid = Game::Read<uint64_t>(pane, Offsets::OFF_PLAYERMODEL_UNIT_GUID);
-    if (void *unit = Object::ByGuid(Offsets::TYPEMASK_UNIT, guid)) {
-        const auto get = Game::Read<GetHeldItemDisplay_t>(
-            Game::Read<const void *>(unit, 0), Offsets::VTBL_UNIT_GET_HELD_ITEM_DISPLAY);
-        s.laneDisplay[0] = get(unit, 0);
-        s.laneDisplay[1] = get(unit, 1);
-    }
-    // AttachHandEnchant's glow (0x005EED00), for players only: the visible
-    // item in the lane's slot (0xF / 0x10, the same numbers as the body
-    // slots), and its visual unless the display hangs its own (-1).
-    if (void *player = Object::ByGuid(Offsets::TYPEMASK_PLAYER, guid)) {
-        for (int i = 0; i < 2; ++i) {
-            const void *item = reinterpret_cast<GetVisibleItem_t>(
-                Offsets::FUN_UNIT_GET_VISIBLE_ITEM)(player, kLanes[i].bodySlot);
-            if (item == nullptr || Game::Read<uint32_t>(item, Offsets::OFF_VISIBLE_ITEM_ITEM_ID) == 0)
-                continue;
-            const int visual =
-                reinterpret_cast<GetDescVisual_t>(Offsets::FUN_VISIBLE_ITEM_GET_DESC_VISUAL)(item);
-            s.laneVisual[i] = visual > 0 ? static_cast<uint32_t>(visual) : 0;
-        }
-    }
+    const auto guid = Game::Read<uint64_t>(pane, Offsets::OFF_PLAYERMODEL_UNIT_GUID);
+    Outfit::ReadWeapons(guid, s.weapons);
+    Outfit::ReadWorn(guid != 0 ? ::Object::ByGuid(Offsets::TYPEMASK_UNIT, guid) : nullptr, guid,
+                     s.weapons, s.worn);
    if (!s.autoDress && !g_dressing) {
        reinterpret_cast<ClearModel_t>(Offsets::FUN_DRESSUPMODEL_CLEAR_MODEL)(pane);
        return;
@@ -246,24 +150,26 @@ void __fastcall SetModelInstance(void *pane, void * /*edx*/, void *model) {
        ApplyWeapons(pane, s);
 }

-// TryOnItem's install: record the lane's row and glow, honor SetSheathed,
-// then hang the glow.
+// TryOnItem's install: record the lane's row, glow and item, honor
+// SetSheathed, then hang the glow.
 int __fastcall TryOnAttach(void *model, const void *record, uint32_t bodySlot,
                           uint32_t sheatheType, bool sheathed, bool shield, bool ranged) {
    const auto attach = reinterpret_cast<AttachItemModel_t>(Offsets::FUN_ATTACH_ITEM_MODEL);
    if (g_tryOnPane == nullptr)
        return attach(model, record, bodySlot, sheatheType, sheathed, shield, ranged);
    PaneState &s = g_panes[g_tryOnPane];
-    const int lane = LaneIndex(bodySlot);
-    s.laneDisplay[lane] = record;
-    s.laneVisual[lane] = EnchantVisual(record, g_tryOnEnchant);
+    const int lane = Outfit::LaneIndex(bodySlot);
+    s.weapons.display[lane] = record;
+    s.weapons.visual[lane] = Outfit::EnchantVisual(record, g_tryOnEnchant);
+    s.worn[(lane == 1 ? Offsets::INVSLOT_OFFHAND : Offsets::INVSLOT_MAINHAND) - 1] = {
+        g_tryOnItem, s.weapons.visual[lane] != 0 ? g_tryOnEnchant : 0};
    if (s.sheathSet) {
        if (s.hideWeapons)
            return -1;
        sheathed = s.sheathed;
    }
    const int attachId = attach(model, record, bodySlot, sheatheType, sheathed, shield, ranged);
-    HangVisual(model, attachId, s.laneVisual[lane]);
+    Outfit::HangVisual(model, attachId, s.weapons.visual[lane]);
    return attachId;
 }

@@ -273,9 +179,10 @@ int __fastcall TryOnAttach(void *model, const void *record, uint32_t bodySlot,
 void __fastcall TryOnEvict(void *model, uint32_t bodySlot, uint32_t sheatheType, bool shield) {
    if (g_tryOnPane != nullptr) {
        PaneState &s = g_panes[g_tryOnPane];
-        const int lane = LaneIndex(bodySlot);
-        s.laneDisplay[lane] = nullptr;
-        s.laneVisual[lane] = 0;
+        const int lane = Outfit::LaneIndex(bodySlot);
+        s.weapons.display[lane] = nullptr;
+        s.weapons.visual[lane] = 0;
+        s.worn[(lane == 1 ? Offsets::INVSLOT_OFFHAND : Offsets::INVSLOT_MAINHAND) - 1] = {};
    }
    reinterpret_cast<DetachHeldItem_t>(Offsets::FUN_DETACH_HELD_ITEM_SLOT)(model, bodySlot,
                                                                         sheatheType, shield);
@@ -302,33 +209,6 @@ __declspec(naked) void HandChoiceThunk() {
    }
 }

-// ClearModel's lane step: detach the held item and zero the lane.
-void ClearLane(void *pane, int i) {
-    HeldLane &lane = LaneOf(pane, i);
-    if (lane.itemClass == 0)
-        return;
-    DetachLane(Pane::Model(pane), i, lane);
-    lane = HeldLane{};
-}
-
-// Component slot for a 0-based inventory slot, or -1 (4.3.4 UndressSlot).
-int ComponentSlot(int slot0) {
-    switch (slot0) {
-    case 0: return 0;  // head
-    case 2: return 1;  // shoulder
-    case 3: return 2;  // shirt
-    case 4: return 3;  // chest
-    case 5: return 4;  // waist
-    case 6: return 5;  // legs
-    case 7: return 6;  // feet
-    case 8: return 7;  // wrist
-    case 9: return 8;  // hands
-    case 14: return 10; // back
-    case 18: return 9;  // tabard
-    default: return -1;
-    }
-}
-
 int __fastcall Script_UndressSlot(void *L) {
    void *pane = Game::Lua::ResolveDressUpModel(L);
    if (pane == nullptr)
@@ -337,166 +217,87 @@ int __fastcall Script_UndressSlot(void *L) {
        Game::Lua::Error(L, "Usage: %s:UndressSlot(slotIndex)", Game::Lua::ObjectDisplayName(pane));
        return 0;
    }
-    const int slot0 = static_cast<int>(Game::Lua::ToNumber(L, 2)) - 1;
-    void *component = Game::Read<void *>(pane, Offsets::OFF_DRESSUPMODEL_COMPONENT);
-    if (Pane::Model(pane) == nullptr || component == nullptr)
-        return 0;
-    if (slot0 + 1 == Offsets::INVSLOT_MAINHAND) {
-        ClearLane(pane, 0);
-    } else if (slot0 + 1 == Offsets::INVSLOT_OFFHAND) {
-        ClearLane(pane, 1);
-    } else {
-        const int compSlot = ComponentSlot(slot0);
-        if (compSlot >= 0)
-            reinterpret_cast<UnequipSlot_t>(Offsets::FUN_CHARCOMP_UNEQUIP_SLOT)(
-                component, static_cast<uint32_t>(compSlot));
-    }
+    Outfit::UndressSlot(Pane::Model(pane),
+                        Game::Read<void *>(pane, Offsets::OFF_DRESSUPMODEL_COMPONENT),
+                        LanesOf(pane), static_cast<int>(Game::Lua::ToNumber(L, 2)));
    return 0;
 }

-// The item a trade-skill recipe makes, from an `enchant:<spellID>` link: a
-// TRADESPELL whose first effect makes an item (4.3.4's test).
-uint32_t RecipeItem(const char *link) {
-    const char *enchant = std::strstr(link, "enchant:");
-    if (enchant == nullptr)
-        return 0;
-    const long spellID = std::strtol(enchant + 8, nullptr, 10);
-    if (spellID <= 0)
-        return 0;
-    const uint8_t *spell = DBC::Record(Offsets::VAR_SPELL_RECORDS, Offsets::VAR_SPELL_RECORD_COUNT,
-                                       static_cast<uint32_t>(spellID));
-    if (spell == nullptr ||
-        (Game::Read<uint32_t>(spell, Offsets::OFF_SPELL_RECORD_ATTRIBUTES) &
-         Offsets::SPELL_ATTR_TRADESPELL) == 0)
-        return 0;
-    return Game::Read<uint32_t>(spell, Offsets::OFF_SPELL_RECORD_EFFECT_ITEM_TYPE);
-}
-
-// The item the worker is given: a cached recipe item becomes what it makes.
-uint32_t WornItem(uint32_t itemID) {
-    const uint8_t *record = Item::PeekRecord(itemID);
-    if (record != nullptr &&
-        Game::Read<uint32_t>(record, Offsets::OFF_ITEMSTATS_INVENTORY_TYPE) == 0) {
-        const uint32_t made = Item::Dressable::RecipeItem(record);
-        if (made != 0)
-            return made;
-    }
-    return itemID;
-}
-
-// `__thiscall(pane, itemID)` as `__fastcall` with the EDX slot unused, so it
-// can stand at the worker's call sites.
-void __fastcall TryOnItem(void *pane, void *, uint32_t itemID) {
-    g_tryOnPane = pane;
-    reinterpret_cast<TryOnItem_t>(Offsets::FUN_DRESSUPMODEL_TRY_ON_ITEM)(pane, WornItem(itemID));
-    g_tryOnPane = nullptr;
-}
-
-// The lane a hand name picks: the PaperDollItemFrame row it names
-// (GetInventorySlotInfo's match), if that row is a held slot; else 0.
-uint32_t NamedHand(const char *name) {
-    const auto *records = Game::Read<const uint8_t *>(Offsets::VAR_PAPERDOLLITEMFRAME_RECORDS);
-    const int count = Game::Read<int>(Offsets::VAR_PAPERDOLLITEMFRAME_COUNT);
-    if (records == nullptr)
-        return 0;
-    for (int i = 0; i < count; ++i) {
-        const uint8_t *row = records + i * Offsets::OFF_PAPERDOLLITEMFRAME_RECORD_STRIDE;
-        if (Game::StrCmpI(Game::Read<const char *>(row, Offsets::OFF_PAPERDOLLITEMFRAME_SLOT_NAME),
-                          name) != 0)
-            continue;
-        switch (Game::Read<int>(row, Offsets::OFF_PAPERDOLLITEMFRAME_SLOT_NUMBER)) {
-        case Offsets::INVSLOT_MAINHAND: return kBodySlotMainHand;
-        case Offsets::INVSLOT_OFFHAND: return kBodySlotOffHand;
-        default: return 0;
-        }
-    }
-    return 0;
+// The worker's armor gate: the component and the ready byte.
+bool ArmorReady(void *pane) {
+    return Game::Read<void *>(pane, Offsets::OFF_DRESSUPMODEL_COMPONENT) != nullptr &&
+           Game::Read<uint8_t>(pane, Offsets::OFF_DRESSUPMODEL_READY) != 0;
 }

 // What the worker did with `itemID`, from the gates it passes (0x00504540).
 int TryOnResult(void *pane, uint32_t itemID) {
    const uint8_t *record = Item::PeekRecord(itemID);
    if (record == nullptr)
-        return kTryOnDataPending;
+        return TryOn::kDataPending;
    if (Game::Read<uint32_t>(record, Offsets::OFF_ITEMSTATS_DISPLAY_INFO_ID) == 0 ||
        Pane::Model(pane) == nullptr)
-        return kTryOnNotEquippable;
-    switch (Game::Read<uint32_t>(record, Offsets::OFF_ITEMSTATS_INVENTORY_TYPE)) {
-    case Offsets::INVTYPE_HEAD:
-    case Offsets::INVTYPE_SHOULDER:
-    case Offsets::INVTYPE_BODY:
-    case Offsets::INVTYPE_CHEST:
-    case Offsets::INVTYPE_WAIST:
-    case Offsets::INVTYPE_LEGS:
-    case Offsets::INVTYPE_FEET:
-    case Offsets::INVTYPE_WRIST:
-    case Offsets::INVTYPE_HAND:
-    case Offsets::INVTYPE_CLOAK:
-    case Offsets::INVTYPE_TABARD:
-    case Offsets::INVTYPE_ROBE:
-        // The armor arms: the component and the ready byte.
-        return Game::Read<void *>(pane, Offsets::OFF_DRESSUPMODEL_COMPONENT) != nullptr &&
-                       Game::Read<uint8_t>(pane, Offsets::OFF_DRESSUPMODEL_READY) != 0
-                   ? kTryOnSuccess
-                   : kTryOnNotEquippable;
-    case Offsets::INVTYPE_WEAPON:
-    case Offsets::INVTYPE_SHIELD:
-    case Offsets::INVTYPE_RANGED:
-    case Offsets::INVTYPE_2HWEAPON:
-    case Offsets::INVTYPE_WEAPONMAINHAND:
-    case Offsets::INVTYPE_WEAPONOFFHAND:
-    case Offsets::INVTYPE_HOLDABLE:
-    case Offsets::INVTYPE_THROWN:
-    case Offsets::INVTYPE_RANGEDRIGHT:
-        return kTryOnSuccess; // the held arm
+        return TryOn::kNotEquippable;
+    switch (Outfit::ArmOf(Game::Read<uint32_t>(record, Offsets::OFF_ITEMSTATS_INVENTORY_TYPE))) {
+    case Outfit::Arm::Armor:
+        return ArmorReady(pane) ? TryOn::kSuccess : TryOn::kNotEquippable;
+    case Outfit::Arm::Held:
+        return TryOn::kSuccess;
    default:
-        return kTryOnNotEquippable;
+        return TryOn::kNotEquippable;
    }
 }

+// `__thiscall(pane, itemID)` as `__fastcall` with the EDX slot unused, so it
+// can stand at the worker's call sites. An armor arm the worker took wears
+// the item in its slot.
+void __fastcall TryOnItem(void *pane, void *, uint32_t itemID) {
+    PaneState &s = g_panes[pane];
+    const bool quiet = g_tryOnQuiet || s.quietPending.erase(itemID) != 0;
+    const uint32_t item = TryOn::WornItem(itemID);
+    const uint8_t *record = Item::PeekRecord(item);
+    uint32_t componentSlot = 0;
+    const Outfit::Arm arm =
+        record != nullptr
+            ? Outfit::ArmOf(Game::Read<uint32_t>(record, Offsets::OFF_ITEMSTATS_INVENTORY_TYPE),
+                            &componentSlot)
+            : Outfit::Arm::Nothing;
+    if (record == nullptr) {
+        if (quiet)
+            s.quietPending.insert(item);
+    } else if (quiet && arm == Outfit::Arm::NotEquippable) {
+        return;
+    }
+    g_tryOnPane = pane;
+    g_tryOnItem = item;
+    reinterpret_cast<TryOnItem_t>(Offsets::FUN_DRESSUPMODEL_TRY_ON_ITEM)(pane, item);
+    g_tryOnPane = nullptr;
+    g_tryOnItem = 0;
+    if (arm == Outfit::Arm::Armor && TryOnResult(pane, item) == TryOn::kSuccess)
+        s.worn[Outfit::InvSlotOfComponent(componentSlot) - 1] = {item, 0};
+}
+
+// TryOn's step: the worker with the request's hand, enchant and quiet.
+int TryOnRequest(void *pane, const TryOn::Request &request) {
+    g_tryOnBodySlot = request.bodySlot;
+    g_tryOnEnchant = request.enchant;
+    g_tryOnQuiet = request.quiet;
+    TryOnItem(pane, nullptr, request.itemID);
+    g_tryOnBodySlot = g_tryOnEnchant = 0;
+    g_tryOnQuiet = false;
+    return TryOnResult(pane, TryOn::WornItem(request.itemID));
+}
+
 int __fastcall Script_TryOn(void *L) {
    void *pane = Game::Lua::ResolveDressUpModel(L);
    if (pane == nullptr)
        return 0;
-    // Read before the name search below, which stomps the Lua stack.
-    const uint32_t bodySlot = Game::Lua::Type(L, 3) == Game::Lua::TYPE_STRING
-                                  ? NamedHand(Game::Lua::ToString(L, 3))
-                                  : 0;
-    const bool enchantGiven = Game::Lua::IsNumber(L, 4) != 0;
-    uint32_t enchant = enchantGiven ? static_cast<uint32_t>(Game::Lua::ToNumber(L, 4)) : 0;
-    uint32_t itemID = 0;
-    if (Game::Lua::Type(L, 2) == Game::Lua::TYPE_NUMBER) {
-        itemID = static_cast<uint32_t>(Game::Lua::ToNumber(L, 2));
-    } else if (Game::Lua::Type(L, 2) == Game::Lua::TYPE_STRING) {
-        // Copied: the name search below stomps the Lua stack.
-        char s[256];
-        std::snprintf(s, sizeof(s), "%s", Game::Lua::ToString(L, 2));
-        if (std::strstr(s, "enchant:") != nullptr) {
-            itemID = RecipeItem(s);
-        } else {
-            // An item link, `item:` string or numeric string resolves to an ID;
-            // any other string is the name of an item the player carries.
-            const Item::Arg::Resolved arg = Item::Arg::ResolveString(s);
-            Item::Location::ByGUIDResult found{};
-            if (arg.itemID != 0) {
-                itemID = static_cast<uint32_t>(arg.itemID);
-                if (!enchantGiven)
-                    enchant = static_cast<uint32_t>(arg.enchant);
-            } else if (arg.name != nullptr && Item::Location::FindByArg(L, arg, &found))
-                itemID = static_cast<uint32_t>(Item::ID::FromCGItem(found.item));
-        }
-    }
-    if (itemID == 0) {
-        reinterpret_cast<DisplayError_t>(Offsets::FUN_GAMEUI_DISPLAY_ERROR)(
-            Offsets::GAME_ERROR_NOT_EQUIPPABLE);
-        Game::Lua::PushNumber(L, kTryOnNotEquippable);
+    const TryOn::Request request = TryOn::ReadArgs(L);
+    if (request.itemID == 0) {
+        TryOn::ShowNotEquippable();
+        Game::Lua::PushNumber(L, TryOn::kNotEquippable);
        return 1;
    }
-    g_tryOnBodySlot = bodySlot;
-    g_tryOnEnchant = enchant;
-    TryOnItem(pane, nullptr, itemID);
-    g_tryOnBodySlot = g_tryOnEnchant = 0;
-    Game::Lua::PushNumber(L, TryOnResult(pane, WornItem(itemID)));
+    Game::Lua::PushNumber(L, TryOnRequest(pane, request));
    return 1;
 }

@@ -552,6 +353,81 @@ int __fastcall Script_GetAutoDress(void *L) {
    return 1;
 }

+// What the pane wears now: nothing without a model, and no slot it no
+// longer shows.
+const Outfit::Worn &WornOf(void *pane) {
+    PaneState &s = g_panes[pane];
+    if (Pane::Model(pane) == nullptr) {
+        for (Outfit::Appearance &slot : s.worn)
+            slot = {};
+    }
+    Outfit::TrimWorn(Game::Read<void *>(pane, Offsets::OFF_DRESSUPMODEL_COMPONENT), LanesOf(pane),
+                     s.worn);
+    return s.worn;
+}
+
+int __fastcall Script_GetItemTransmogInfo(void *L) {
+    void *pane = Game::Lua::ResolveDressUpModel(L);
+    if (pane == nullptr)
+        return 0;
+    if (!Game::Lua::IsNumber(L, 2)) {
+        Game::Lua::Error(L, "Usage: %s:GetItemTransmogInfo(inventorySlot)",
+                         Game::Lua::ObjectDisplayName(pane));
+        return 0;
+    }
+    const int invSlot = static_cast<int>(Game::Lua::ToNumber(L, 2));
+    if (Pane::Model(pane) == nullptr || invSlot < 1 || invSlot > Outfit::kInventorySlots)
+        return 0;
+    TryOn::PushTransmogInfo(L, WornOf(pane)[invSlot - 1]);
+    return 1;
+}
+
+int __fastcall Script_GetItemTransmogInfoList(void *L) {
+    void *pane = Game::Lua::ResolveDressUpModel(L);
+    if (pane == nullptr)
+        return 0;
+    TryOn::PushTransmogInfoList(L, WornOf(pane));
+    return 1;
+}
+
+// TryOn with the info's item and enchant, quiet. No appearance changes
+// nothing.
+int __fastcall Script_SetItemTransmogInfo(void *L) {
+    void *pane = Game::Lua::ResolveDressUpModel(L);
+    if (pane == nullptr)
+        return 0;
+    TryOn::Request request;
+    if (!TryOn::ReadTransmogInfo(L, Game::Lua::ObjectDisplayName(pane), request))
+        return 0;
+    Game::Lua::PushNumber(L, request.itemID == 0 ? TryOn::kNotEquippable
+                                                 : TryOnRequest(pane, request));
+    return 1;
+}
+
+// The slots the worker's arms put an item in. No 1.12 model hides a slot it
+// takes, so IsSlotVisible gives the same.
+int SlotQuery(void *L, const char *usage) {
+    void *pane = Game::Lua::ResolveDressUpModel(L);
+    if (pane == nullptr)
+        return 0;
+    if (!Game::Lua::IsNumber(L, 2)) {
+        Game::Lua::Error(L, usage, Game::Lua::ObjectDisplayName(pane));
+        return 0;
+    }
+    Game::Lua::PushBool(L, Pane::Model(pane) != nullptr &&
+                               Outfit::SlotAllowed(static_cast<int>(Game::Lua::ToNumber(L, 2)),
+                                                   ArmorReady(pane)));
+    return 1;
+}
+
+int __fastcall Script_IsSlotAllowed(void *L) {
+    return SlotQuery(L, "Usage: %s:IsSlotAllowed(slot)");
+}
+
+int __fastcall Script_IsSlotVisible(void *L) {
+    return SlotQuery(L, "Usage: %s:IsSlotVisible(slot)");
+}
+
 const Game::Lua::FrameMethodEntry g_methods[] = {
    {"UndressSlot", &Script_UndressSlot},
    {"TryOn", &Script_TryOn},
@@ -561,6 +437,11 @@ const Game::Lua::FrameMethodEntry g_methods[] = {
    {"GetSheathed", &Script_GetSheathed},
    {"SetAutoDress", &Script_SetAutoDress},
    {"GetAutoDress", &Script_GetAutoDress},
+    {"GetItemTransmogInfo", &Script_GetItemTransmogInfo},
+    {"GetItemTransmogInfoList", &Script_GetItemTransmogInfoList},
+    {"SetItemTransmogInfo", &Script_SetItemTransmogInfo},
+    {"IsSlotAllowed", &Script_IsSlotAllowed},
+    {"IsSlotVisible", &Script_IsSlotVisible},
 };

 const Game::Doc::Field kUndressArgs[] = {
@@ -609,18 +490,58 @@ const Game::Doc::Field kEnabledRets[] = {
 const Game::Doc::Function kGetAutoDress{
    "Returns whether the model wears its unit's equipment when the unit is set.", {},
    kEnabledRets};
+const Game::Doc::Field kTransmogInfoRets[] = {
+    Game::Doc::Req("itemTransmogInfo", "ItemTransmogInfo",
+                   "What the slot wears: appearanceID is the item ID, illusionID the enchant whose "
+                   "glow a weapon shows. Nil when the model shows nothing."),
+};
+const Game::Doc::Function kGetItemTransmogInfo{
+    "Returns what the model wears in one inventory slot.", kUndressArgs, kTransmogInfoRets};
+const Game::Doc::Field kTransmogInfoListRets[] = {
+    Game::Doc::Req("infoList", "table", "An ItemTransmogInfo for each inventory slot 1 to 19."),
+};
+const Game::Doc::Function kGetItemTransmogInfoList{
+    "Returns what the model wears in each inventory slot.", {}, kTransmogInfoListRets};
+const Game::Doc::Field kSetTransmogInfoArgs[] = {
+    Game::Doc::Req("transmogInfo", "ItemTransmogInfo",
+                   "appearanceID is an item ID, illusionID a SpellItemEnchantment ID."),
+    Game::Doc::Opt("inventorySlots", "number", nullptr, "16 or 17: the hand that holds a weapon."),
+    Game::Doc::Opt("ignoreChildItems", "bool", "false", "Has no effect."),
+};
+const Game::Doc::Function kSetItemTransmogInfo{
+    "Puts an item on the model, as TryOn does. Shows no error. An appearanceID of 0 changes "
+    "nothing.",
+    kSetTransmogInfoArgs, kTryOnRets};
+const Game::Doc::Field kSlotAllowedRets[] = {
+    Game::Doc::Req("allowed", "bool"),
+};
+const Game::Doc::Function kIsSlotAllowed{
+    "Returns whether TryOn can put an item in an inventory slot of the model. The hands are "
+    "always allowed. An armor slot is allowed when TryOn can put armor on the model.",
+    kUndressArgs, kSlotAllowedRets};
+const Game::Doc::Field kSlotVisibleRets[] = {
+    Game::Doc::Req("visible", "bool"),
+};
+const Game::Doc::Function kIsSlotVisible{
+    "Returns whether an item in an inventory slot shows on the model. Same as IsSlotAllowed.",
+    kUndressArgs, kSlotVisibleRets};
 const Game::Doc::Method g_methodDocs[] = {
    {"UndressSlot", &kUndressSlot},   {"TryOn", &kTryOn},
    {"Dress", &kDress},               {"IsGeoReady", &kIsGeoReady},
    {"SetSheathed", &kSetSheathed},   {"GetSheathed", &kGetSheathed},
    {"SetAutoDress", &kSetAutoDress}, {"GetAutoDress", &kGetAutoDress},
+    {"GetItemTransmogInfo", &kGetItemTransmogInfo},
+    {"GetItemTransmogInfoList", &kGetItemTransmogInfoList},
+    {"SetItemTransmogInfo", &kSetItemTransmogInfo},
+    {"IsSlotAllowed", &kIsSlotAllowed},
+    {"IsSlotVisible", &kIsSlotVisible},
 };

 const Game::Lua::EnumIntegerEntry kItemTryOnReason[] = {
-    {"Success", kTryOnSuccess},
-    {"WrongRace", kTryOnWrongRace},
-    {"NotEquippable", kTryOnNotEquippable},
-    {"DataPending", kTryOnDataPending},
+    {"Success", TryOn::kSuccess},
+    {"WrongRace", TryOn::kWrongRace},
+    {"NotEquippable", TryOn::kNotEquippable},
+    {"DataPending", TryOn::kDataPending},
 };

 void RegisterLuaFunctions() {
@@ -19,6 +19,7 @@
 #include "Game.h"
 #include "Offsets.h"

+#include <cstddef>
 #include <cstdint>

 namespace Model::M2 {
@@ -50,6 +51,19 @@ inline void *CreateModel(void *scene, const char *path) {
    return reinterpret_cast<Fn>(Offsets::FUN_M2SCENE_CREATE_MODEL)(scene, path, 0);
 }

+// A new instance of `source`'s model in `scene` without its item attachments
+// (helm, shoulders, held items), the way the portrait bake copies a unit:
+// CreateModelFromModel (FUN_M2SCENE_COPY_MODEL), then DetachAllItemModels
+// (FUN_DETACH_ALL_ITEM_MODELS). The caller owns one reference, or null.
+inline void *CopyWithoutItems(void *scene, void *source) {
+    using Copy_t = void *(__thiscall *)(void *, void *, uint32_t);
+    using DetachAll_t = void(__fastcall *)(void *);
+    void *copy = reinterpret_cast<Copy_t>(Offsets::FUN_M2SCENE_COPY_MODEL)(scene, source, 0);
+    if (copy != nullptr)
+        reinterpret_cast<DetachAll_t>(Offsets::FUN_DETACH_ALL_ITEM_MODELS)(copy);
+    return copy;
+}
+
 inline void PlayAnimation(void *model, int keyBone, uint32_t id, int variation, int offset,
                          float speed, int blend, int primary) {
    using Fn = void(__thiscall *)(void *, int, uint32_t, int, int, float, int, int);
@@ -57,6 +71,45 @@ inline void PlayAnimation(void *model, int keyBone, uint32_t id, int variation,
                                                              offset, speed, blend, primary);
 }

+// The key bone's sequence as it plays (FUN_M2MODEL_GET_KEY_BONE_ANIM_STATE).
+struct AnimState {
+    uint32_t id;
+    uint32_t variation;
+    uint32_t position; // ms into the sequence
+    float speed;
+    uint32_t lo;
+    uint32_t hi;
+    uint32_t latch;
+};
+static_assert(sizeof(AnimState) == Offsets::M2_KEY_BONE_ANIM_STATE_SIZE);
+static_assert(offsetof(AnimState, id) == Offsets::OFF_M2_KEY_BONE_ANIM_STATE_ID);
+static_assert(offsetof(AnimState, variation) == Offsets::OFF_M2_KEY_BONE_ANIM_STATE_VARIATION);
+static_assert(offsetof(AnimState, position) == Offsets::OFF_M2_KEY_BONE_ANIM_STATE_POSITION);
+static_assert(offsetof(AnimState, speed) == Offsets::OFF_M2_KEY_BONE_ANIM_STATE_SPEED);
+static_assert(offsetof(AnimState, lo) == Offsets::OFF_M2_KEY_BONE_ANIM_STATE_LO);
+static_assert(offsetof(AnimState, hi) == Offsets::OFF_M2_KEY_BONE_ANIM_STATE_HI);
+static_assert(offsetof(AnimState, latch) == Offsets::OFF_M2_KEY_BONE_ANIM_STATE_LATCH);
+
+// Waits for an unloaded instance.
+inline AnimState GetAnimState(void *model, int keyBone) {
+    using Fn = void(__thiscall *)(void *, int, AnimState *);
+    AnimState state;
+    reinterpret_cast<Fn>(Offsets::FUN_M2MODEL_GET_KEY_BONE_ANIM_STATE)(model, keyBone, &state);
+    return state;
+}
+
+// Where the key bone's animation stands, in ms into its sequence. Waits for
+// an unloaded instance.
+inline int GetAnimPosition(void *model, int keyBone) {
+    return static_cast<int>(GetAnimState(model, keyBone).position);
+}
+
+// Moves the key bone's animation to `ms` into its sequence, keeping its speed.
+inline void SetAnimPosition(void *model, int keyBone, int ms) {
+    using Fn = void(__thiscall *)(void *, int, int);
+    reinterpret_cast<Fn>(Offsets::FUN_M2MODEL_SET_KEY_BONE_ANIM_TIME)(model, keyBone, ms);
+}
+
 inline void SetAnimDoneCallback(void *model, const void *callback, uint32_t userLow,
                                uint32_t userHigh) {
    using Fn = void(__thiscall *)(void *, const void *, uint32_t, uint32_t);
@@ -69,6 +122,220 @@ inline void SetVisible(void *model, bool visible) {
    reinterpret_cast<Fn>(Offsets::FUN_M2MODEL_SET_VISIBLE)(model, visible ? 1 : 0);
 }

+inline void SetAlpha(void *model, float alpha) {
+    using Fn = void(__thiscall *)(void *, float);
+    reinterpret_cast<Fn>(Offsets::FUN_M2MODEL_SET_ALPHA)(model, alpha);
+}
+
+// The tint the model is drawn with, {r, g, b}; white is none.
+inline void SetDiffuse(void *model, const float (&rgb)[3]) {
+    using Fn = void(__thiscall *)(void *, const float *);
+    reinterpret_cast<Fn>(Offsets::FUN_M2MODEL_SET_DIFFUSE_COLOR)(model, rgb);
+}
+
+// CM2Model::FindChild: the model hung at attachment `attachId`, or null.
+inline void *FindChild(void *model, int attachId) {
+    using Fn = void *(__thiscall *)(void *, int);
+    return reinterpret_cast<Fn>(Offsets::FUN_M2MODEL_FIND_CHILD)(model, attachId);
+}
+
+// The model this one is attached to, or null.
+inline void *Parent(const void *model) {
+    return Game::Read<void *>(model, Offsets::OFF_M2MODEL_PARENT);
+}
+
+// CM2Model::Attach: `child` on the parent's attachment `id`. The child leaves
+// the animate list (the parent animates it) and the parent takes a reference
+// on it.
+inline void Attach(void *child, void *parent, uint32_t id) {
+    using Fn = void(__thiscall *)(void *, void *, uint32_t);
+    reinterpret_cast<Fn>(Offsets::FUN_M2MODEL_ATTACH)(child, parent, id);
+}
+
+// Whether `child` may hang on `parent`: two models, and the parent is not the
+// child or hung (at any depth) from it. Animate recurses through the parent
+// chain (EnsureAnimated, 0x00714000), so a cycle never ends.
+inline bool CanAttach(const void *child, const void *parent) {
+    if (child == nullptr || parent == nullptr)
+        return false;
+    for (const void *m = parent; m != nullptr; m = Parent(m))
+        if (m == child)
+            return false;
+    return true;
+}
+
+// CM2Model::HasAttachment. Waits for an unloaded model file.
+inline bool HasAttachment(void *model, uint32_t id) {
+    using Fn = int(__thiscall *)(void *, uint32_t);
+    return reinterpret_cast<Fn>(Offsets::FUN_M2MODEL_HAS_ATTACHMENT)(model, id) != 0;
+}
+
+// CM2Model::GetAttachmentPosition: the attachment's point in the space the
+// root model's base matrix places it in (a scene's actor coordinates). The
+// model must have the attachment (HasAttachment).
+inline void GetAttachmentPosition(void *model, uint32_t id, float (&out)[3]) {
+    using Fn = float *(__thiscall *)(void *, float *, uint32_t);
+    reinterpret_cast<Fn>(Offsets::FUN_M2MODEL_GET_ATTACHMENT_POSITION)(model, out, id);
+}
+
+// CM2Model::GetAttachmentOffset: the attachment's position in model space,
+// not posed by any animation. The model must have the attachment
+// (HasAttachment). Waits for an unloaded model file.
+inline void GetAttachmentOffset(void *model, uint32_t id, float (&out)[3]) {
+    using Fn = void(__thiscall *)(void *, float *, uint32_t);
+    reinterpret_cast<Fn>(Offsets::FUN_M2MODEL_GET_ATTACHMENT_OFFSET)(model, out, id);
+}
+
+// The animation-event callback (Offsets::FUN_M2MODEL_SET_EVENT_CALLBACK).
+inline void SetEventCallback(void *model, const void *callback, uint32_t userLow,
+                             uint32_t userHigh) {
+    using Fn = void(__thiscall *)(void *, const void *, uint32_t, uint32_t);
+    reinterpret_cast<Fn>(Offsets::FUN_M2MODEL_SET_EVENT_CALLBACK)(model, callback, userLow,
+                                                                  userHigh);
+}
+
+// CM2Model::HasEvent. Waits for an unloaded model file.
+inline bool HasEvent(void *model, uint32_t tag) {
+    using Fn = int(__thiscall *)(void *, uint32_t);
+    return reinterpret_cast<Fn>(Offsets::FUN_M2MODEL_HAS_EVENT)(model, tag) != 0;
+}
+
+// CM2Model::GetEventPosition: the event's point in the scene, as
+// GetAttachmentPosition's. Waits for an unloaded model file.
+inline void GetEventPosition(void *model, uint32_t tag, float (&out)[3]) {
+    using Fn = float *(__thiscall *)(void *, float *, uint32_t);
+    reinterpret_cast<Fn>(Offsets::FUN_M2MODEL_GET_EVENT_POSITION)(model, out, tag);
+}
+
+inline bool HasLiveParticles(void *model) {
+    using Fn = int(__thiscall *)(void *);
+    return reinterpret_cast<Fn>(Offsets::FUN_M2MODEL_HAS_LIVE_PARTICLES)(model) != 0;
+}
+
+// CM2Model::Detach, when the model is attached: off its parent, which drops
+// its reference on it. Detach itself drops that reference unconditionally,
+// so the world's Dismount (0x00607CE0) tests the parent first, as this does.
+inline void Detach(void *model) {
+    using Fn = void(__fastcall *)(void *);
+    if (Parent(model) != nullptr)
+        reinterpret_cast<Fn>(Offsets::FUN_M2MODEL_DETACH)(model);
+}
+
+// The model's overall bounds {min xyz, max xyz}. Waits for an unloaded file.
+inline void GetBoundingBox(void *model, float (&box)[6]) {
+    using Fn = void(__thiscall *)(void *, float *);
+    reinterpret_cast<Fn>(Offsets::FUN_M2MODEL_GET_BOUNDING_BOX)(model, box);
+}
+
+// The model's collision box {min xyz, max xyz}. Waits for an unloaded file.
+inline void GetCollisionBox(void *model, float (&box)[6]) {
+    using Fn = void(__thiscall *)(void *, float *);
+    reinterpret_cast<Fn>(Offsets::FUN_M2MODEL_GET_COLLISION_BOX)(model, box);
+}
+
+// The model's bounding sphere {centre xyz, radius}. Waits for an unloaded file.
+inline void GetBoundingSphere(void *model, float (&sphere)[4]) {
+    using Fn = void(__thiscall *)(void *, float *);
+    reinterpret_cast<Fn>(Offsets::FUN_M2MODEL_GET_BOUNDING_SPHERE)(model, sphere);
+}
+
+// CM2Model::HasAnimation: whether the model has a sequence for the
+// animation. Waits for an unloaded file.
+inline bool HasAnimation(void *model, uint32_t animation) {
+    using Fn = bool(__thiscall *)(void *, uint32_t);
+    return reinterpret_cast<Fn>(Offsets::FUN_M2MODEL_HAS_ANIMATION)(model, animation);
+}
+
+// An animation's sequence record (FUN_M2MODEL_GET_SEQUENCE_INFO), all zero
+// when the model has no sequence for it.
+struct SequenceInfo {
+    uint32_t flags;
+    uint32_t length; // ms
+    float speed;     // the move speed times the model's scale
+    float bounds[6]; // {min xyz, max xyz}
+    uint8_t rest[Offsets::M2_SEQUENCE_INFO_SIZE - 0x24];
+};
+static_assert(sizeof(SequenceInfo) == Offsets::M2_SEQUENCE_INFO_SIZE);
+static_assert(offsetof(SequenceInfo, length) == Offsets::OFF_M2_SEQUENCE_INFO_LENGTH);
+static_assert(offsetof(SequenceInfo, speed) == Offsets::OFF_M2_SEQUENCE_INFO_SPEED);
+static_assert(offsetof(SequenceInfo, bounds) == Offsets::OFF_M2_SEQUENCE_INFO_BOUNDS);
+
+// Waits for an unloaded file.
+inline SequenceInfo GetSequenceInfo(void *model, uint32_t animation, uint32_t variation) {
+    using Fn = void(__thiscall *)(void *, uint32_t, uint32_t, SequenceInfo *);
+    SequenceInfo info{};
+    reinterpret_cast<Fn>(Offsets::FUN_M2MODEL_GET_SEQUENCE_INFO)(model, animation, variation, &info);
+    return info;
+}
+
+// The bounds of the animation's sequence, all zero when the model has none.
+// Waits for an unloaded file.
+inline void GetSequenceBounds(void *model, uint32_t animation, uint32_t variation,
+                              float (&box)[6]) {
+    const SequenceInfo info = GetSequenceInfo(model, animation, variation);
+    for (int i = 0; i < 6; ++i)
+        box[i] = info.bounds[i];
+}
+
+// The world pick's steps (Offsets::FUN_M2SCENE_RAY_HIT): ray hits on, the
+// candidates on the scene's hit list, then the ray.
+inline void EnableRayHits(void *scene) {
+    using Fn = void(__fastcall *)(void *);
+    reinterpret_cast<Fn>(Offsets::FUN_M2SCENE_ENABLE_RAY_HITS)(scene);
+}
+
+// Puts the model on its scene's hit list (skinned triangles), with `value`
+// for RayHit to return.
+inline void SetHitTest(void *model, uintptr_t value) {
+    using Fn = void(__thiscall *)(void *, int, int, uintptr_t);
+    reinterpret_cast<Fn>(Offsets::FUN_M2MODEL_SET_HIT_TEST_MODE)(model, Offsets::M2_HIT_TEST_SKINNED,
+                                                                 0, value);
+}
+
+// The hit value of the nearest triangle on p0..p1 (view space), else 0.
+// Empties the hit list.
+inline uintptr_t RayHit(void *scene, const float (&p0)[3], const float (&p1)[3]) {
+    using Fn = uintptr_t(__thiscall *)(void *, const float *, const float *, float *, int);
+    float fraction = 1.0f;
+    return reinterpret_cast<Fn>(Offsets::FUN_M2SCENE_RAY_HIT)(scene, p0, p1, &fraction, 1);
+}
+
+// The base matrix (row vectors: rows 0..2 the scaled axes, row 3 the
+// translation).
+inline void GetBaseTransform(void *model, float (&m)[16]) {
+    using Fn = void(__thiscall *)(void *, float *);
+    reinterpret_cast<Fn>(Offsets::FUN_M2MODEL_GET_BASE_TRANSFORM)(model, m);
+}
+
+// CM2Model::SetBaseTransform: the base matrix as given.
+inline void SetBaseTransform(void *model, const float (&m)[16]) {
+    using Fn = void(__thiscall *)(void *, const float *);
+    reinterpret_cast<Fn>(Offsets::FUN_M2MODEL_SET_BASE_TRANSFORM)(model, m);
+}
+
+// CM2Model::SetBaseTransformTRS: identity, translated to `position`, rotated
+// by `angle` about `axis`, then each row scaled.
+inline void SetBaseTRS(void *model, const float (&position)[3], float angle, const float (&axis)[3],
+                       const float (&scale)[3]) {
+    using Fn = void(__thiscall *)(void *, const float *, float, const float *, const float *);
+    reinterpret_cast<Fn>(Offsets::FUN_M2MODEL_SET_BASE_TRS)(model, position, angle, axis, scale);
+}
+
+// The base matrix in place, for the engine's matrix calls after SetBaseTRS.
+inline float *BaseMatrix(void *model) { return Game::Ptr<float>(model, Offsets::OFF_M2MODEL_BASE_MATRIX); }
+
+inline float GetAlpha(void *model) {
+    using Fn = float(__thiscall *)(void *);
+    return reinterpret_cast<Fn>(Offsets::FUN_M2MODEL_GET_ALPHA)(model);
+}
+
+inline void *FirstChild(const void *model) {
+    return Game::Read<void *>(model, Offsets::OFF_MODEL_INSTANCE_CHILD_HEAD);
+}
+inline void *NextSibling(const void *model) {
+    return Game::Read<void *>(model, Offsets::OFF_MODEL_INSTANCE_CHILD_NEXT);
+}
+
 inline void SetAnimated(void *model, bool animated) {
    using Fn = void(__thiscall *)(void *, int);
    reinterpret_cast<Fn>(Offsets::FUN_M2MODEL_SET_ANIMATED)(model, animated ? 1 : 0);
@@ -79,11 +346,24 @@ inline void AnimateScene(void *scene, const float *cameraPos) {
    reinterpret_cast<Fn>(Offsets::FUN_M2SCENE_ANIMATE)(scene, cameraPos);
 }

+// M2SceneDraw: pass 0 the opaque models, 1 the translucent ones.
+inline void DrawScene(void *scene, uint32_t pass) {
+    using Fn = void(__thiscall *)(void *, uint32_t);
+    reinterpret_cast<Fn>(Offsets::FUN_M2SCENE_DRAW)(scene, pass);
+}
+
 inline void AttachItemVisuals(void *model, uint32_t visualID) {
    using Fn = void(__fastcall *)(void *, uint32_t);
    reinterpret_cast<Fn>(Offsets::FUN_ATTACH_ITEM_VISUALS)(model, visualID);
 }

+// CM2Model::SetDrawCallback: a callback the model's draw runs as one of its
+// elements, in list 0 when `listZero`; a null callback removes it.
+inline void SetDrawCallback(void *model, const void *callback, void *userData, bool listZero) {
+    using Fn = void(__thiscall *)(void *, const void *, void *, int);
+    reinterpret_cast<Fn>(Offsets::FUN_M2MODEL_SET_DRAW_CALLBACK)(model, callback, userData, listZero ? 1 : 0);
+}
+
 inline void SetRenderCallback(void *model, const void *callback, void *userData) {
    using Fn = void(__thiscall *)(void *, const void *, void *);
    reinterpret_cast<Fn>(Offsets::FUN_MODEL_INSTANCE_SET_RENDER_CB)(model, callback, userData);
@@ -102,6 +382,44 @@ inline uint16_t LookupIndex(void *model, uintptr_t tableOffset, uint32_t id) {
    return reinterpret_cast<Fn>(Offsets::FUN_M2_LOOKUP_INDEX)(id, Data(model) + tableOffset);
 }

+// ---- a model light (M2LIGHT_SIZE bytes) -----------------------------------------
+
+inline void InitLight(void *light) {
+    reinterpret_cast<void(__fastcall *)(void *)>(Offsets::FUN_M2LIGHT_INITIALIZE)(light);
+}
+// 0 directional, 1 point.
+inline void SetLightType(void *light, int type) {
+    reinterpret_cast<void(__thiscall *)(void *, int)>(Offsets::FUN_M2LIGHT_SET_TYPE)(light, type);
+}
+inline void SetLightEnabled(void *light, bool enabled) {
+    reinterpret_cast<void(__thiscall *)(void *, int)>(Offsets::FUN_M2LIGHT_SET_ENABLED)(light, enabled ? 1 : 0);
+}
+inline void SetLightDirection(void *light, const float *v) {
+    reinterpret_cast<void(__thiscall *)(void *, const float *)>(Offsets::FUN_M2LIGHT_SET_DIRECTION)(light, v);
+}
+inline void SetLightPosition(void *light, const float *v) {
+    reinterpret_cast<void(__thiscall *)(void *, const float *)>(Offsets::FUN_M2LIGHT_SET_POSITION)(light, v);
+}
+
+// ---- animation classes (Offsets::FUN_IS_*_ANIMATION) -----------------------------
+// The unit's tests of an AnimationData ID. The death test is __stdcall, the
+// others __fastcall.
+
+inline bool IsDeathAnimation(int anim) {
+    return reinterpret_cast<int(__stdcall *)(int)>(Offsets::FUN_IS_DEATH_ANIMATION)(anim) != 0;
+}
+
+namespace Detail {
+inline bool AnimTest(uintptr_t fn, int anim) { return reinterpret_cast<int(__fastcall *)(int)>(fn)(anim) != 0; }
+} // namespace Detail
+
+inline bool IsBowAnimation(int anim) { return Detail::AnimTest(Offsets::FUN_IS_BOW_ANIMATION, anim); }
+inline bool IsRifleAnimation(int anim) { return Detail::AnimTest(Offsets::FUN_IS_RIFLE_ANIMATION, anim); }
+inline bool IsThrownAnimation(int anim) { return Detail::AnimTest(Offsets::FUN_IS_THROWN_ANIMATION, anim); }
+inline bool IsEmoteAnimation(int anim) { return Detail::AnimTest(Offsets::FUN_IS_EMOTE_ANIMATION, anim); }
+inline bool IsSpellCastAnimation(int anim) { return Detail::AnimTest(Offsets::FUN_IS_SPELL_CAST_ANIMATION, anim); }
+inline bool IsMoveAnimation(int anim) { return Detail::AnimTest(Offsets::FUN_IS_MOVE_ANIMATION, anim); }
+
 } // namespace Model::M2

 namespace Model::Pane {
@@ -0,0 +1,265 @@
+// This file is part of ClassicAPI.
+//
+// ClassicAPI is free software: you can redistribute it and/or modify it under the terms
+// of the GNU General Public License as published by the Free Software Foundation, either
+// version 3 of the License, or (at your option) any later version.
+//
+// ClassicAPI is distributed in the hope that it will be useful, but WITHOUT ANY
+// WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
+// PURPOSE. See the GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License along with
+// ClassicAPI. If not, see <https://www.gnu.org/licenses/>.
+
+// `C_ModelInfo.GetModelSceneInfoByID(modelSceneID)` -> modelSceneType,
+//     modelCameraIDs, modelActorsIDs, flags
+// `C_ModelInfo.GetModelSceneCameraInfoByID(modelSceneCameraID)` -> UIModelSceneCameraInfo
+// `C_ModelInfo.GetModelSceneActorInfoByID(modelActorID)` -> UIModelSceneActorInfo
+// `C_ModelInfo.GetModelSceneActorDisplayInfoByID(modelActorDisplayID)` -> UIModelSceneActorDisplayInfo
+//
+// Retail's getters read its UiModelScene DB2s; these read the rows embedded
+// in model/SceneData.h, shaped as retail returns them. An unknown ID returns
+// nothing, as retail's do (MayReturnNothing). The vector3 fields are
+// Vector3DMixin objects (CreateVector3D, Util/Vector3D.lua). From a retail
+// probe (docs/notes/model-scene.md § Data): the actor flags split into the
+// three useCenterForOrigin booleans, and a NormalizedScale of 0 is a nil
+// normalizeScaleAggressiveness; a display ID of 0 is likewise nil. Retail's
+// active-scene bookkeeping (Add/ClearActiveModelScene[Actor]) does nothing in
+// public clients and is the embedded addon's (Compat.lua).
+
+#include "Game.h"
+#include "model/SceneData.h"
+
+#include <cstdint>
+
+namespace Model::ModelInfo {
+
+namespace {
+
+using namespace Model::SceneData;
+
+// Enum.UIModelSceneActorFlag.
+constexpr uint32_t kUseCenterForOriginX = 0x2;
+constexpr uint32_t kUseCenterForOriginY = 0x4;
+constexpr uint32_t kUseCenterForOriginZ = 0x8;
+
+template <typename Row, size_t N>
+const Row *Find(const Row (&rows)[N], uint32_t id) {
+    for (const Row &row : rows)
+        if (row.id == id)
+            return &row;
+    return nullptr;
+}
+
+bool IdArg(void *L, uint32_t &id) {
+    if (!Game::Lua::IsNumber(L, 1))
+        return false;
+    id = static_cast<uint32_t>(Game::Lua::ToNumber(L, 1));
+    return true;
+}
+
+// `t[key] = CreateVector3D(v)` on the table at the top of the stack.
+void SetFieldVector3D(void *L, const char *key, const Vec3 &v) {
+    Game::Lua::PushString(L, key);
+    Game::Lua::PushString(L, "CreateVector3D");
+    Game::Lua::GetTable(L, Game::Lua::GLOBALS_INDEX);
+    Game::Lua::PushNumber(L, v.x);
+    Game::Lua::PushNumber(L, v.y);
+    Game::Lua::PushNumber(L, v.z);
+    Game::Lua::Call(L, 3, 1);
+    Game::Lua::SetTable(L, -3);
+}
+
+// An array of the IDs of every row of `rows` in `sceneID`, in ID order.
+template <typename Row, size_t N>
+void PushSceneIDs(void *L, const Row (&rows)[N], uint32_t sceneID) {
+    Game::Lua::NewTable(L);
+    int n = 0;
+    for (const Row &row : rows) {
+        if (row.sceneID != sceneID)
+            continue;
+        Game::Lua::PushNumber(L, row.id);
+        Game::Lua::RawSetI(L, -2, ++n);
+    }
+}
+
+int __fastcall Script_GetModelSceneInfoByID(void *L) {
+    uint32_t id = 0;
+    const SceneRow *scene = IdArg(L, id) ? Find(kScenes, id) : nullptr;
+    if (scene == nullptr)
+        return 0;
+    Game::Lua::PushNumber(L, scene->uiSystemType);
+    PushSceneIDs(L, kCameras, id);
+    PushSceneIDs(L, kActors, id);
+    Game::Lua::PushNumber(L, scene->flags);
+    return 4;
+}
+
+int __fastcall Script_GetModelSceneCameraInfoByID(void *L) {
+    uint32_t id = 0;
+    const CameraRow *camera = IdArg(L, id) ? Find(kCameras, id) : nullptr;
+    if (camera == nullptr)
+        return 0;
+    Game::Lua::NewTable(L);
+    Game::Lua::SetFieldNumber(L, "modelSceneCameraID", camera->id);
+    Game::Lua::SetFieldString(L, "scriptTag", camera->scriptTag);
+    Game::Lua::SetFieldString(L, "cameraType", "OrbitCamera");
+    SetFieldVector3D(L, "target", camera->target);
+    Game::Lua::SetFieldNumber(L, "yaw", camera->yaw);
+    Game::Lua::SetFieldNumber(L, "pitch", camera->pitch);
+    Game::Lua::SetFieldNumber(L, "roll", camera->roll);
+    Game::Lua::SetFieldNumber(L, "zoomDistance", camera->zoomDistance);
+    Game::Lua::SetFieldNumber(L, "minZoomDistance", camera->minZoomDistance);
+    Game::Lua::SetFieldNumber(L, "maxZoomDistance", camera->maxZoomDistance);
+    SetFieldVector3D(L, "zoomedTargetOffset", camera->zoomedTargetOffset);
+    Game::Lua::SetFieldNumber(L, "zoomedYawOffset", camera->zoomedYawOffset);
+    Game::Lua::SetFieldNumber(L, "zoomedPitchOffset", camera->zoomedPitchOffset);
+    Game::Lua::SetFieldNumber(L, "zoomedRollOffset", camera->zoomedRollOffset);
+    Game::Lua::SetFieldNumber(L, "flags", camera->flags);
+    return 1;
+}
+
+int __fastcall Script_GetModelSceneActorInfoByID(void *L) {
+    uint32_t id = 0;
+    const ActorRow *actor = IdArg(L, id) ? Find(kActors, id) : nullptr;
+    if (actor == nullptr)
+        return 0;
+    Game::Lua::NewTable(L);
+    Game::Lua::SetFieldNumber(L, "modelActorID", actor->id);
+    Game::Lua::SetFieldString(L, "scriptTag", actor->scriptTag);
+    SetFieldVector3D(L, "position", actor->position);
+    Game::Lua::SetFieldNumber(L, "yaw", actor->yaw);
+    Game::Lua::SetFieldNumber(L, "pitch", actor->pitch);
+    Game::Lua::SetFieldNumber(L, "roll", actor->roll);
+    if (actor->normalizedScale != 0.0f)
+        Game::Lua::SetFieldNumber(L, "normalizeScaleAggressiveness", actor->normalizedScale);
+    Game::Lua::SetFieldBool(L, "useCenterForOriginX", (actor->flags & kUseCenterForOriginX) != 0);
+    Game::Lua::SetFieldBool(L, "useCenterForOriginY", (actor->flags & kUseCenterForOriginY) != 0);
+    Game::Lua::SetFieldBool(L, "useCenterForOriginZ", (actor->flags & kUseCenterForOriginZ) != 0);
+    if (actor->displayID != 0)
+        Game::Lua::SetFieldNumber(L, "modelActorDisplayID", actor->displayID);
+    return 1;
+}
+
+int __fastcall Script_GetModelSceneActorDisplayInfoByID(void *L) {
+    uint32_t id = 0;
+    const ActorDisplayRow *display = IdArg(L, id) ? Find(kActorDisplays, id) : nullptr;
+    if (display == nullptr)
+        return 0;
+    Game::Lua::NewTable(L);
+    Game::Lua::SetFieldNumber(L, "animation", display->animation);
+    Game::Lua::SetFieldNumber(L, "animationVariation", display->animationVariation);
+    Game::Lua::SetFieldNumber(L, "animSpeed", display->animSpeed);
+    if (display->animKitID != 0)
+        Game::Lua::SetFieldNumber(L, "animationKitID", display->animKitID);
+    if (display->spellVisualKitID != 0)
+        Game::Lua::SetFieldNumber(L, "spellVisualKitID", display->spellVisualKitID);
+    Game::Lua::SetFieldNumber(L, "alpha", display->alpha);
+    Game::Lua::SetFieldNumber(L, "scale", display->scale);
+    return 1;
+}
+
+// --- Documentation ----------------------------------------------------------
+
+const Game::Doc::Field kActorDisplayInfoFields[] = {
+    Game::Doc::Req("animation", "number"),
+    Game::Doc::Req("animationVariation", "number"),
+    Game::Doc::Req("animSpeed", "number"),
+    Game::Doc::Opt("animationKitID", "number"),
+    Game::Doc::Opt("spellVisualKitID", "number"),
+    Game::Doc::Req("alpha", "number"),
+    Game::Doc::Req("scale", "number"),
+};
+const Game::Doc::Structure kActorDisplayInfo{"UIModelSceneActorDisplayInfo", "ModelInfo",
+                                             kActorDisplayInfoFields};
+
+const Game::Doc::Field kActorInfoFields[] = {
+    Game::Doc::Req("modelActorID", "number"),
+    Game::Doc::Req("scriptTag", "cstring"),
+    Game::Doc::Req("position", "vector3"),
+    Game::Doc::Req("yaw", "number"),
+    Game::Doc::Req("pitch", "number"),
+    Game::Doc::Req("roll", "number"),
+    Game::Doc::Opt("normalizeScaleAggressiveness", "number"),
+    Game::Doc::Req("useCenterForOriginX", "bool"),
+    Game::Doc::Req("useCenterForOriginY", "bool"),
+    Game::Doc::Req("useCenterForOriginZ", "bool"),
+    Game::Doc::Opt("modelActorDisplayID", "number"),
+};
+const Game::Doc::Structure kActorInfo{"UIModelSceneActorInfo", "ModelInfo", kActorInfoFields};
+
+const Game::Doc::Field kCameraInfoFields[] = {
+    Game::Doc::Req("modelSceneCameraID", "number"),
+    Game::Doc::Req("scriptTag", "cstring"),
+    Game::Doc::Req("cameraType", "cstring"),
+    Game::Doc::Req("target", "vector3"),
+    Game::Doc::Req("yaw", "number"),
+    Game::Doc::Req("pitch", "number"),
+    Game::Doc::Req("roll", "number"),
+    Game::Doc::Req("zoomDistance", "number"),
+    Game::Doc::Req("minZoomDistance", "number"),
+    Game::Doc::Req("maxZoomDistance", "number"),
+    Game::Doc::Req("zoomedTargetOffset", "vector3"),
+    Game::Doc::Req("zoomedYawOffset", "number"),
+    Game::Doc::Req("zoomedPitchOffset", "number"),
+    Game::Doc::Req("zoomedRollOffset", "number"),
+    Game::Doc::Req("flags", "ModelSceneSetting"),
+};
+const Game::Doc::Structure kCameraInfo{"UIModelSceneCameraInfo", "ModelInfo", kCameraInfoFields};
+
+const Game::Doc::Field kSceneIDArg[] = {Game::Doc::Req("modelSceneID", "number")};
+const Game::Doc::Field kSceneInfoRets[] = {
+    Game::Doc::Req("modelSceneType", "ModelSceneType"),
+    Game::Doc::Req("modelCameraIDs", "table"),
+    Game::Doc::Req("modelActorsIDs", "table"),
+    Game::Doc::Req("flags", "number"),
+};
+const Game::Doc::Function kGetModelSceneInfoByID{
+    "Returns a model scene's type and the IDs of its cameras and actors.", kSceneIDArg,
+    kSceneInfoRets};
+
+const Game::Doc::Field kCameraIDArg[] = {Game::Doc::Req("modelSceneCameraID", "number")};
+const Game::Doc::Field kCameraInfoRet[] = {
+    Game::Doc::Req("modelSceneCameraInfo", "UIModelSceneCameraInfo")};
+const Game::Doc::Function kGetModelSceneCameraInfoByID{"Returns a model scene camera's settings.",
+                                                       kCameraIDArg, kCameraInfoRet};
+
+const Game::Doc::Field kActorIDArg[] = {Game::Doc::Req("modelActorID", "number")};
+const Game::Doc::Field kActorInfoRet[] = {Game::Doc::Req("actorInfo", "UIModelSceneActorInfo")};
+const Game::Doc::Function kGetModelSceneActorInfoByID{
+    "Returns where a model scene actor stands and how it is scaled.", kActorIDArg,
+    kActorInfoRet};
+
+const Game::Doc::Field kActorDisplayIDArg[] = {Game::Doc::Req("modelActorDisplayID", "number")};
+const Game::Doc::Field kActorDisplayInfoRet[] = {
+    Game::Doc::Req("actorDisplayInfo", "UIModelSceneActorDisplayInfo")};
+const Game::Doc::Function kGetModelSceneActorDisplayInfoByID{
+    "Returns the animation, alpha and scale a model scene actor starts with.",
+    kActorDisplayIDArg, kActorDisplayInfoRet};
+
+// Enum.ModelSceneSetting: the camera rows' flags, which OrbitCameraMixin
+// tests on every update (ShouldAlignLightToOrbitDelta).
+const Game::Lua::EnumIntegerEntry kModelSceneSetting[] = {
+    {"AlignLightToOrbitDelta", 1},
+};
+
+void RegisterLuaFunctions() {
+    Game::Lua::RegisterIntegerEnum("Enum", "ModelSceneSetting", kModelSceneSetting, "UIModelInfo");
+    Game::Lua::RegisterTableFunction("C_ModelInfo", "GetModelSceneInfoByID",
+                                     &Script_GetModelSceneInfoByID, &kGetModelSceneInfoByID);
+    Game::Lua::RegisterTableFunction("C_ModelInfo", "GetModelSceneCameraInfoByID",
+                                     &Script_GetModelSceneCameraInfoByID,
+                                     &kGetModelSceneCameraInfoByID);
+    Game::Lua::RegisterTableFunction("C_ModelInfo", "GetModelSceneActorInfoByID",
+                                     &Script_GetModelSceneActorInfoByID,
+                                     &kGetModelSceneActorInfoByID);
+    Game::Lua::RegisterTableFunction("C_ModelInfo", "GetModelSceneActorDisplayInfoByID",
+                                     &Script_GetModelSceneActorDisplayInfoByID,
+                                     &kGetModelSceneActorDisplayInfoByID);
+}
+
+const Game::ModuleAutoRegister _autoreg{&RegisterLuaFunctions};
+
+} // namespace
+
+} // namespace Model::ModelInfo
@@ -0,0 +1,488 @@
+// This file is part of ClassicAPI.
+//
+// ClassicAPI is free software: you can redistribute it and/or modify it under the terms
+// of the GNU General Public License as published by the Free Software Foundation, either
+// version 3 of the License, or (at your option) any later version.
+//
+// ClassicAPI is distributed in the hope that it will be useful, but WITHOUT ANY
+// WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
+// PURPOSE. See the GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License along with
+// ClassicAPI. If not, see <https://www.gnu.org/licenses/>.
+
+// The outfit calls of a character model copy: DressUpModel's own steps
+// (SetModelInstance 0x00504350, ClearModel 0x00504490, 4.3.4's per-slot
+// UndressSlot) and the unit's AttachHandItem step, on whatever holds the
+// component and the lanes. benilla ui/dressup and charactermodel/equipment.
+//
+// The slot map is 4.3.4's UndressSlot map, from inventory slot to component
+// slot.
+//
+// What a slot wears (Worn) is read from the unit's visible items, the item
+// IDs the engine keeps per equipment slot for every player, and kept only
+// while the model shows it: an armor slot while the component holds a record
+// for it (so a hidden helm or cloak wears nothing), a hand while its lane
+// holds an item. A weapon's enchant is the one behind the glow the engine
+// shows, picked as GetItemDescVisual (0x0062EC70) picks it.
+//
+// TryOn is DressUpModel::TryOnItem's arms (0x00504540, benilla ui/dressup)
+// for a holder that is not a pane, the ModelScene actor: the pane runs the
+// engine's worker itself (model/DressUp.cpp). Two differences:
+//   - An evicted lane is zeroed, as Undress zeroes one. The worker leaves its
+//     record, which only makes a later try-on detach it again.
+//   - A tabard keeps no guild emblem. The worker's emblem step reads the
+//     pane's player.
+
+#include "model/Outfit.h"
+
+#include "Game.h"
+#include "Offsets.h"
+#include "dbc/Lookup.h"
+#include "model/DisplayInfo.h"
+#include "model/ItemDisplay.h"
+#include "model/M2.h"
+#include "object/Resolve.h"
+#include "unit/Identity.h"
+
+#include <iterator>
+
+namespace Model::Outfit {
+namespace {
+
+using DetachHeldItem_t = void(__fastcall *)(void *model, uint32_t bodySlot, uint32_t sheatheType,
+                                            bool shield);
+using AttachItemModel_t = int(__fastcall *)(void *model, const void *record, uint32_t bodySlot,
+                                            uint32_t sheatheType, bool sheathed, bool shield,
+                                            bool ranged);
+using GetHeldItemDisplay_t = const void *(__thiscall *)(void *unit, uint32_t hand);
+using GetHeldItemLane_t = const HeldLane *(__thiscall *)(void *unit, uint32_t hand, int one);
+using GetVisibleItem_t = const void *(__thiscall *)(void *player, uint32_t slot);
+using GetDescVisual_t = int(__thiscall *)(const void *visibleItem);
+using CanHoldBoth_t = bool(__fastcall *)(uint32_t mainType, uint32_t offType, bool dualWield);
+
+constexpr uint32_t kBodySlots[2] = {kBodySlotMainHand, kBodySlotOffHand};
+
+// The component slots ClearModel clears (0..11).
+constexpr uint32_t kComponentSlots = 12;
+
+// The inventory slot of each component slot 0..10 (4.3.4's UndressSlot map,
+// inverted); slot 11 has no inventory slot.
+constexpr int kInvSlotOfComponent[] = {1, 3, 4, 5, 6, 7, 8, 9, 10, 19, 15};
+
+// The ItemDisplayInfo record the component shows in `slot`, or null.
+const void *ComponentRecord(void *component, uint32_t slot) {
+    return Game::Read<const void *>(component, Offsets::OFF_CHARCOMP_ITEM_RECORDS + slot * 4);
+}
+
+template <typename Fn>
+Fn VirtualOf(void *object, uintptr_t slot) {
+    return Game::Read<Fn>(Game::Read<const void *>(object, 0), slot);
+}
+
+// DetachHeldItemSlot on lane `i`'s item.
+void DetachLane(void *model, int i, const HeldLane &lane) {
+    reinterpret_cast<DetachHeldItem_t>(Offsets::FUN_DETACH_HELD_ITEM_SLOT)(
+        model, kBodySlots[i], lane.sheatheType, lane.inventoryType == Offsets::INVTYPE_SHIELD);
+}
+
+// ClearModel's lane step: detach the held item and zero the lane.
+void ClearLane(void *model, Lanes &lanes, int i) {
+    if (lanes[i].itemClass == 0)
+        return;
+    DetachLane(model, i, lanes[i]);
+    lanes[i] = HeldLane{};
+}
+
+// TryOnItem's hand for a held type: the named one, else a second one-hander
+// in the off hand of a dual wielder, and each type's own hand.
+int HandFor(uint32_t type, const Lanes &lanes, const HeldTryOn &held) {
+    if (held.bodySlot != 0)
+        return LaneIndex(held.bodySlot);
+    switch (type) {
+    case Offsets::INVTYPE_WEAPON:
+        return lanes[0].itemClass != 0 &&
+                       (lanes[0].inventoryType == Offsets::INVTYPE_WEAPON ||
+                        lanes[0].inventoryType == Offsets::INVTYPE_WEAPONMAINHAND) &&
+                       held.dualWield
+                   ? 1
+                   : 0;
+    case Offsets::INVTYPE_SHIELD:
+    case Offsets::INVTYPE_RANGED:
+    case Offsets::INVTYPE_WEAPONOFFHAND:
+    case Offsets::INVTYPE_HOLDABLE:
+        return 1;
+    default: // two-hand, main-hand, thrown and right-hand ranged
+        return 0;
+    }
+}
+
+// The unit's AttachHandItem step on lane `i`: detach it, then hang it in the
+// hand or the sheath, or leave it off.
+void HangLane(void *model, int i, const HeldLane &lane, const Weapons &weapons, bool sheathed,
+              bool hide) {
+    if (lane.itemClass == 0 || weapons.display[i] == nullptr)
+        return;
+    DetachLane(model, i, lane);
+    if (hide)
+        return;
+    const int attachId = reinterpret_cast<AttachItemModel_t>(Offsets::FUN_ATTACH_ITEM_MODEL)(
+        model, weapons.display[i], kBodySlots[i], lane.sheatheType, sheathed,
+        lane.inventoryType == Offsets::INVTYPE_SHIELD,
+        lane.inventoryType == Offsets::INVTYPE_RANGEDRIGHT);
+    HangVisual(model, attachId, weapons.visual[i]);
+}
+
+} // namespace
+
+int ComponentSlotOf(int invSlot) {
+    for (int slot = 0; slot < static_cast<int>(std::size(kInvSlotOfComponent)); ++slot) {
+        if (kInvSlotOfComponent[slot] == invSlot)
+            return slot;
+    }
+    return -1;
+}
+
+int InvSlotOfComponent(uint32_t componentSlot) {
+    return componentSlot < std::size(kInvSlotOfComponent) ? kInvSlotOfComponent[componentSlot] : 0;
+}
+
+bool SlotAllowed(int invSlot, bool armorReady) {
+    if (invSlot == Offsets::INVSLOT_MAINHAND || invSlot == Offsets::INVSLOT_OFFHAND)
+        return true;
+    return ComponentSlotOf(invSlot) >= 0 && armorReady;
+}
+
+void ReadLanes(void *unit, Lanes &lanes) {
+    const auto get = VirtualOf<GetHeldItemLane_t>(unit, Offsets::VTBL_UNIT_GET_HELD_ITEM_LANE);
+    for (uint32_t hand = 0; hand < 2; ++hand) {
+        const HeldLane *lane = get(unit, hand, 1);
+        lanes[hand] = lane != nullptr ? *lane : HeldLane{};
+    }
+}
+
+void ReadWeapons(uint64_t guid, Weapons &weapons) {
+    weapons = Weapons{};
+    if (void *unit = Object::ByGuid(Offsets::TYPEMASK_UNIT, guid)) {
+        const auto get =
+            VirtualOf<GetHeldItemDisplay_t>(unit, Offsets::VTBL_UNIT_GET_HELD_ITEM_DISPLAY);
+        weapons.display[0] = get(unit, 0);
+        weapons.display[1] = get(unit, 1);
+    }
+    // AttachHandEnchant's glow (0x005EED00), for players only: the visible
+    // item in the lane's slot (0xF / 0x10, the same numbers as the body
+    // slots), and its visual unless the display hangs its own (-1).
+    void *player = Object::ByGuid(Offsets::TYPEMASK_PLAYER, guid);
+    if (player == nullptr)
+        return;
+    for (int i = 0; i < 2; ++i) {
+        const void *item =
+            reinterpret_cast<GetVisibleItem_t>(Offsets::FUN_UNIT_GET_VISIBLE_ITEM)(player,
+                                                                                kBodySlots[i]);
+        if (item == nullptr || Game::Read<uint32_t>(item, Offsets::OFF_VISIBLE_ITEM_ITEM_ID) == 0)
+            continue;
+        const int visual =
+            reinterpret_cast<GetDescVisual_t>(Offsets::FUN_VISIBLE_ITEM_GET_DESC_VISUAL)(item);
+        weapons.visual[i] = visual > 0 ? static_cast<uint32_t>(visual) : 0;
+    }
+}
+
+void *CloneComponent(void *model, void *unit) {
+    void *source = Game::Read<void *>(unit, Offsets::OFF_CGUNIT_CHARACTER_COMPONENT);
+    if (source == nullptr)
+        return nullptr;
+    void *component = DisplayInfo::NewDresser();
+    if (component == nullptr)
+        return nullptr;
+    M2::AddRef(model); // the component's reference
+    DisplayInfo::CloneDresser(component, model, source);
+    return component;
+}
+
+void HangVisual(void *model, int attachId, uint32_t visual) {
+    if (visual == 0 || attachId < 0)
+        return;
+    if (void *item = M2::FindChild(model, attachId))
+        M2::AttachItemVisuals(item, visual);
+}
+
+void HangWeapons(void *model, const Lanes &lanes, const Weapons &weapons, bool sheathed,
+                 bool hide) {
+    if (model == nullptr)
+        return;
+    for (int i = 0; i < 2; ++i)
+        HangLane(model, i, lanes[i], weapons, sheathed, hide);
+}
+
+void SetSheatheType(void *model, Lanes &lanes, int i, const Weapons &weapons,
+                    uint8_t sheatheType, bool sheathed, bool hide) {
+    if (model == nullptr || lanes[i].itemClass == 0)
+        return;
+    DetachLane(model, i, lanes[i]);
+    lanes[i].sheatheType = sheatheType;
+    HangLane(model, i, lanes[i], weapons, sheathed, hide);
+}
+
+uint8_t SheatheTypeFor(uint8_t own, uint32_t category) {
+    switch (category) {
+    case kSheatheBack:
+        if (own == Offsets::ITEM_SHEATH_HIP)
+            return static_cast<uint8_t>(Offsets::ITEM_SHEATH_BACK);
+        return own;
+    case kSheatheSide:
+        if (own == Offsets::ITEM_SHEATH_BACK || own == Offsets::ITEM_SHEATH_LARGE_BACK)
+            return static_cast<uint8_t>(Offsets::ITEM_SHEATH_HIP);
+        return own;
+    case kSheatheHide:
+        return static_cast<uint8_t>(Offsets::ITEM_SHEATH_NONE);
+    default:
+        return own;
+    }
+}
+
+uint32_t EnchantVisual(const void *display, uint32_t enchantID) {
+    if (display == nullptr ||
+        Model::ItemDisplay::OwnVisual(static_cast<const uint8_t *>(display)) != 0)
+        return 0;
+    const uint8_t *enchant = DBC::Record(Offsets::VAR_SPELLITEMENCHANT_RECORDS,
+                                         Offsets::VAR_SPELLITEMENCHANT_COUNT, enchantID);
+    return enchant != nullptr
+               ? Game::Read<uint32_t>(enchant, Offsets::OFF_SPELLITEMENCHANT_ITEM_VISUAL)
+               : 0;
+}
+
+Arm ArmOf(uint32_t inventoryType, uint32_t *componentSlot) {
+    uint32_t slot = 0;
+    switch (inventoryType) {
+    case Offsets::INVTYPE_HEAD: slot = 0; break;
+    case Offsets::INVTYPE_SHOULDER: slot = 1; break;
+    case Offsets::INVTYPE_BODY: slot = 2; break;
+    case Offsets::INVTYPE_CHEST:
+    case Offsets::INVTYPE_ROBE: slot = 3; break;
+    case Offsets::INVTYPE_WAIST: slot = 4; break;
+    case Offsets::INVTYPE_LEGS: slot = 5; break;
+    case Offsets::INVTYPE_FEET: slot = 6; break;
+    case Offsets::INVTYPE_WRIST: slot = 7; break;
+    case Offsets::INVTYPE_HAND: slot = 8; break;
+    case Offsets::INVTYPE_TABARD: slot = 9; break;
+    case Offsets::INVTYPE_CLOAK: slot = 10; break;
+    case Offsets::INVTYPE_WEAPON:
+    case Offsets::INVTYPE_SHIELD:
+    case Offsets::INVTYPE_RANGED:
+    case Offsets::INVTYPE_2HWEAPON:
+    case Offsets::INVTYPE_WEAPONMAINHAND:
+    case Offsets::INVTYPE_WEAPONOFFHAND:
+    case Offsets::INVTYPE_HOLDABLE:
+    case Offsets::INVTYPE_THROWN:
+    case Offsets::INVTYPE_RANGEDRIGHT:
+        return Arm::Held;
+    case Offsets::INVTYPE_NECK:
+    case Offsets::INVTYPE_FINGER:
+    case Offsets::INVTYPE_TRINKET:
+    case Offsets::INVTYPE_RELIC:
+        return Arm::Nothing;
+    default:
+        return Arm::NotEquippable;
+    }
+    if (componentSlot != nullptr)
+        *componentSlot = slot;
+    return Arm::Armor;
+}
+
+bool CanDualWield(uint64_t guid) {
+    return guid != 0 && guid == Unit::Identity::PlayerGuid() &&
+           reinterpret_cast<int(__cdecl *)()>(Offsets::FUN_PLAYER_CAN_DUAL_WIELD)() != 0;
+}
+
+int TryOn(void *model, void *component, bool armorReady, Lanes &lanes, Weapons &weapons,
+          const uint8_t *record, const HeldTryOn &held) {
+    const auto displayID = Game::Read<uint32_t>(record, Offsets::OFF_ITEMSTATS_DISPLAY_INFO_ID);
+    if (model == nullptr || displayID == 0)
+        return 0;
+    const auto type = Game::Read<uint32_t>(record, Offsets::OFF_ITEMSTATS_INVENTORY_TYPE);
+    uint32_t componentSlot = 0;
+    switch (ArmOf(type, &componentSlot)) {
+    case Arm::Armor:
+        if (component == nullptr || !armorReady)
+            return 0;
+        DisplayInfo::UnequipDresserSlot(component, componentSlot);
+        DisplayInfo::SetDresserItem(component, componentSlot, displayID);
+        return kInvSlotOfComponent[componentSlot];
+    case Arm::Held:
+        break;
+    default:
+        return 0;
+    }
+    const int lane = HandFor(type, lanes, held);
+    const int other = 1 - lane;
+    if (lanes[other].itemClass != 0) {
+        const uint32_t mainType = lane == 0 ? type : lanes[0].inventoryType;
+        const uint32_t offType = lane == 0 ? lanes[1].inventoryType : type;
+        if (!reinterpret_cast<CanHoldBoth_t>(Offsets::FUN_DRESSUPMODEL_CAN_HOLD_BOTH)(
+                mainType, offType, held.dualWield)) {
+            ClearLane(model, lanes, other);
+            weapons.display[other] = nullptr;
+            weapons.visual[other] = 0;
+        }
+    }
+    ClearLane(model, lanes, lane);
+    HeldLane &target = lanes[lane];
+    target = LaneOf(record);
+    const uint8_t *display = DBC::Record(Offsets::VAR_ITEMDISPLAYINFO_RECORDS,
+                                         Offsets::VAR_ITEMDISPLAYINFO_COUNT, displayID);
+    weapons.display[lane] = display;
+    weapons.visual[lane] = EnchantVisual(display, held.enchant);
+    const int invSlot = lane == 0 ? Offsets::INVSLOT_MAINHAND : Offsets::INVSLOT_OFFHAND;
+    if (display == nullptr || held.hide)
+        return invSlot;
+    const int attachId = reinterpret_cast<AttachItemModel_t>(Offsets::FUN_ATTACH_ITEM_MODEL)(
+        model, display, kBodySlots[lane], target.sheatheType, held.sheathed,
+        type == Offsets::INVTYPE_SHIELD, type == Offsets::INVTYPE_RANGEDRIGHT);
+    HangVisual(model, attachId, weapons.visual[lane]);
+    return invSlot;
+}
+
+void UndressSlot(void *model, void *component, Lanes &lanes, int invSlot) {
+    if (model == nullptr || component == nullptr)
+        return;
+    if (invSlot == Offsets::INVSLOT_MAINHAND) {
+        ClearLane(model, lanes, 0);
+    } else if (invSlot == Offsets::INVSLOT_OFFHAND) {
+        ClearLane(model, lanes, 1);
+    } else {
+        const int compSlot = ComponentSlotOf(invSlot);
+        if (compSlot >= 0)
+            DisplayInfo::UnequipDresserSlot(component, static_cast<uint32_t>(compSlot));
+    }
+}
+
+void DressSlot(void *model, void *component, bool armorReady, Lanes &lanes, Weapons &weapons,
+               void *unit, uint64_t guid, int invSlot, bool sheathed, bool hide) {
+    if (model == nullptr || unit == nullptr)
+        return;
+    if (invSlot == Offsets::INVSLOT_MAINHAND || invSlot == Offsets::INVSLOT_OFFHAND) {
+        const int i = invSlot == Offsets::INVSLOT_OFFHAND ? 1 : 0;
+        Lanes worn;
+        Weapons wornWeapons;
+        ReadLanes(unit, worn);
+        ReadWeapons(guid, wornWeapons);
+        ClearLane(model, lanes, i);
+        lanes[i] = worn[i];
+        weapons.display[i] = wornWeapons.display[i];
+        weapons.visual[i] = wornWeapons.visual[i];
+        HangLane(model, i, lanes[i], weapons, sheathed, hide);
+        return;
+    }
+    const int compSlot = ComponentSlotOf(invSlot);
+    void *source = Game::Read<void *>(unit, Offsets::OFF_CGUNIT_CHARACTER_COMPONENT);
+    if (compSlot < 0 || component == nullptr || source == nullptr || !armorReady)
+        return;
+    const auto slot = static_cast<uint32_t>(compSlot);
+    const void *record = ComponentRecord(source, slot);
+    DisplayInfo::UnequipDresserSlot(component, slot);
+    if (record != nullptr)
+        DisplayInfo::SetDresserItem(component, slot, Game::Read<uint32_t>(record, 0));
+}
+
+void ReadWorn(void *unit, uint64_t guid, const Weapons &weapons, Worn &worn) {
+    for (Appearance &slot : worn)
+        slot = Appearance{};
+    // Only a player has visible items: a creature's table is not initialized
+    // (FUN_UNIT_GET_VISIBLE_ITEM's hazard).
+    void *player = Object::ByGuid(Offsets::TYPEMASK_PLAYER, guid);
+    if (unit == nullptr || player == nullptr)
+        return;
+    const auto visibleItem = reinterpret_cast<GetVisibleItem_t>(Offsets::FUN_UNIT_GET_VISIBLE_ITEM);
+    const auto itemOf = [&](int invSlot) -> const uint8_t * {
+        const void *item = visibleItem(player, static_cast<uint32_t>(invSlot - 1));
+        return static_cast<const uint8_t *>(item);
+    };
+    void *component = Game::Read<void *>(unit, Offsets::OFF_CGUNIT_CHARACTER_COMPONENT);
+    if (component != nullptr) {
+        for (uint32_t slot = 0; slot < std::size(kInvSlotOfComponent); ++slot) {
+            const int invSlot = kInvSlotOfComponent[slot];
+            const uint8_t *item = itemOf(invSlot);
+            if (item != nullptr && ComponentRecord(component, slot) != nullptr)
+                worn[invSlot - 1].item = Game::Read<uint32_t>(item, Offsets::OFF_VISIBLE_ITEM_ITEM_ID);
+        }
+    }
+    for (int i = 0; i < 2; ++i) {
+        const int invSlot = i == 0 ? Offsets::INVSLOT_MAINHAND : Offsets::INVSLOT_OFFHAND;
+        const uint8_t *item = itemOf(invSlot);
+        if (item == nullptr || weapons.display[i] == nullptr)
+            continue;
+        Appearance &held = worn[invSlot - 1];
+        held.item = Game::Read<uint32_t>(item, Offsets::OFF_VISIBLE_ITEM_ITEM_ID);
+        if (weapons.visual[i] == 0)
+            continue;
+        // GetItemDescVisual's walk: the first enchant with an ItemVisual.
+        for (uint32_t e = 0; e < Offsets::VISIBLE_ITEM_ENCHANT_COUNT; ++e) {
+            const auto id = Game::Read<uint32_t>(item, Offsets::OFF_VISIBLE_ITEM_ENCHANTS + e * 4);
+            const uint8_t *enchant = DBC::Record(Offsets::VAR_SPELLITEMENCHANT_RECORDS,
+                                                 Offsets::VAR_SPELLITEMENCHANT_COUNT, id);
+            if (enchant != nullptr &&
+                Game::Read<uint32_t>(enchant, Offsets::OFF_SPELLITEMENCHANT_ITEM_VISUAL) != 0) {
+                held.enchant = id;
+                break;
+            }
+        }
+    }
+}
+
+void TrimWorn(void *component, const Lanes &lanes, Worn &worn) {
+    for (uint32_t slot = 0; slot < std::size(kInvSlotOfComponent); ++slot) {
+        if (component == nullptr || ComponentRecord(component, slot) == nullptr)
+            worn[kInvSlotOfComponent[slot] - 1] = Appearance{};
+    }
+    if (lanes[0].itemClass == 0)
+        worn[Offsets::INVSLOT_MAINHAND - 1] = Appearance{};
+    if (lanes[1].itemClass == 0)
+        worn[Offsets::INVSLOT_OFFHAND - 1] = Appearance{};
+}
+
+HeldLane LaneOf(const uint8_t *record) {
+    HeldLane lane{};
+    lane.itemClass = static_cast<uint8_t>(Game::Read<uint32_t>(record, Offsets::OFF_ITEMSTATS_CLASS));
+    lane.subclass = static_cast<uint8_t>(Game::Read<uint32_t>(record, Offsets::OFF_ITEMSTATS_SUBCLASS));
+    lane.inventoryType = static_cast<uint8_t>(Game::Read<uint32_t>(record, Offsets::OFF_ITEMSTATS_INVENTORY_TYPE));
+    lane.sheatheType = static_cast<uint8_t>(Game::Read<uint32_t>(record, Offsets::OFF_ITEMSTATS_SHEATH));
+    return lane;
+}
+
+void ReadRanged(void *unit, uint64_t guid, HeldLane &lane, const void *&display, Appearance &worn) {
+    lane = HeldLane{};
+    display = nullptr;
+    worn = Appearance{};
+    if (unit == nullptr)
+        return;
+    const HeldLane *held = VirtualOf<GetHeldItemLane_t>(unit, Offsets::VTBL_UNIT_GET_HELD_ITEM_LANE)(
+        unit, Offsets::UNIT_HAND_RANGED, 0);
+    const void *row = VirtualOf<GetHeldItemDisplay_t>(unit, Offsets::VTBL_UNIT_GET_HELD_ITEM_DISPLAY)(
+        unit, Offsets::UNIT_HAND_RANGED);
+    if (held == nullptr || held->itemClass == 0 || row == nullptr)
+        return;
+    lane = *held;
+    display = row;
+    // Only a player has visible items (ReadWorn's hazard).
+    void *player = Object::ByGuid(Offsets::TYPEMASK_PLAYER, guid);
+    if (player == nullptr)
+        return;
+    if (const void *item = reinterpret_cast<GetVisibleItem_t>(Offsets::FUN_UNIT_GET_VISIBLE_ITEM)(
+            player, static_cast<uint32_t>(Offsets::INVSLOT_RANGED - 1)))
+        worn.item = Game::Read<uint32_t>(item, Offsets::OFF_VISIBLE_ITEM_ITEM_ID);
+}
+
+void Undress(void *model, void *component, Lanes &lanes, bool weapons) {
+    if (model == nullptr)
+        return;
+    if (component != nullptr) {
+        for (uint32_t slot = 0; slot < kComponentSlots; ++slot)
+            DisplayInfo::UnequipDresserSlot(component, slot);
+    }
+    if (weapons) {
+        ClearLane(model, lanes, 0);
+        ClearLane(model, lanes, 1);
+    }
+}
+
+} // namespace Model::Outfit
@@ -0,0 +1,191 @@
+// This file is part of ClassicAPI.
+//
+// ClassicAPI is free software: you can redistribute it and/or modify it under the terms
+// of the GNU General Public License as published by the Free Software Foundation, either
+// version 3 of the License, or (at your option) any later version.
+//
+// ClassicAPI is distributed in the hope that it will be useful, but WITHOUT ANY
+// WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
+// PURPOSE. See the GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License along with
+// ClassicAPI. If not, see <https://www.gnu.org/licenses/>.
+
+#pragma once
+
+#include <cstdint>
+
+// What a copy of a unit's character model wears, apart from its own model:
+// the character component that composites its armor, and the two held-item
+// lanes. 1.12's DressUpModel keeps these in the pane (benilla ui/dressup);
+// the ModelScene actor keeps its own. Both change them with the calls here.
+namespace Model::Outfit {
+
+// Body slots of the two held lanes.
+constexpr uint32_t kBodySlotMainHand = 0xF;
+constexpr uint32_t kBodySlotOffHand = 0x10;
+
+// A held lane, as the unit's VTBL_UNIT_GET_HELD_ITEM_LANE returns it and the
+// pane stores it (OFF_DRESSUPMODEL_*_HAND_LANE).
+struct HeldLane {
+    uint8_t itemClass; // 0 = empty
+    uint8_t subclass; // the item subclass (UNIT_VIRTUAL_ITEM_INFO byte 1)
+    uint8_t unknown2;
+    uint8_t inventoryType;
+    uint8_t sheatheType;
+    uint8_t unknown5[3];
+};
+static_assert(sizeof(HeldLane) == 8, "ClearModel zeroes 8 bytes per lane");
+using Lanes = HeldLane[2]; // main hand, off hand
+
+// Retail's Enum.TransmogOutfitSlotOptionSheatheCategory: where a held item
+// hangs while sheathed.
+enum SheatheCategory : uint32_t {
+    kSheatheDefault = 0, // the item's own sheath point
+    kSheatheBack = 1,
+    kSheatheSide = 2,
+    kSheatheHide = 3, // no sheath point: nothing shows while sheathed
+};
+
+// The sheathe type an item whose own type is `own` (OFF_ITEMSTATS_SHEATH)
+// hangs with in `category`: Back moves a hip weapon to the back pair, Side
+// moves a back weapon to the hip, Hide leaves no sheath point. Every other
+// item keeps its own (a shield, an item with no sheath point).
+uint8_t SheatheTypeFor(uint8_t own, uint32_t category);
+
+// The row and glow each lane's item is hung with. The lanes keep no display
+// row, so whoever re-hangs a weapon keeps these beside them.
+struct Weapons {
+    const void *display[2] = {}; // ItemDisplayInfo row on each lane, or null
+    uint32_t visual[2] = {};     // enchant ItemVisuals row on each lane, or 0
+};
+
+// The lane (0 or 1) of a held body slot.
+inline int LaneIndex(uint32_t bodySlot) { return bodySlot == kBodySlotOffHand ? 1 : 0; }
+
+// DressUpModel SetModelInstance's lane copy (0x00504350): the unit's two
+// held-item lanes, zero where a hand is empty.
+void ReadLanes(void *unit, Lanes &lanes);
+
+// The rows the unit `guid` hangs its held items with (AttachHandItem's
+// source), and, for a player, each one's enchant glow (AttachHandEnchant).
+void ReadWeapons(uint64_t guid, Weapons &weapons);
+
+// A new character component for `model`, cloned from the unit's, as
+// DressUpModel SetModelInstance clones it; null when the unit has none.
+// It is pumped and released like a dresser (Model::DisplayInfo::PumpDresser,
+// DestroyDresser): both are the engine's character component.
+void *CloneComponent(void *model, void *unit);
+
+// AttachEnchantVisual's step (0x005EED50): the glow on the item hung at
+// `attachId`.
+void HangVisual(void *model, int attachId, uint32_t visual);
+
+// The unit's AttachHandItem step on each occupied lane: detach it, then hang
+// it in the hand or the sheath, or leave it off.
+void HangWeapons(void *model, const Lanes &lanes, const Weapons &weapons, bool sheathed,
+                 bool hide);
+
+// Lane `i` hung again with `sheatheType`: detached at the type it hangs with
+// now (DetachHeldItemSlot finds the sheath point from it), then hung in the
+// hand or the sheath, or left off. The lane keeps the new type, so every
+// later detach finds the new sheath point.
+void SetSheatheType(void *model, Lanes &lanes, int i, const Weapons &weapons,
+                    uint8_t sheatheType, bool sheathed, bool hide);
+
+// The glow `enchantID` gives an item shown with `display` (an ItemDisplayInfo
+// row): none when the display hangs its own (GetItemDescVisual's rule).
+uint32_t EnchantVisual(const void *display, uint32_t enchantID);
+
+// TryOnItem's dispatch (0x00504540) on an item's inventory type.
+enum class Arm {
+    Armor,         // a component slot
+    Held,          // a held-item lane
+    Nothing,       // neck, finger, trinket, relic: nothing, and no error
+    NotEquippable, // anything else: the worker shows ERR_NOT_EQUIPPABLE
+};
+
+// The arm for `inventoryType`; `componentSlot` receives an armor arm's slot.
+Arm ArmOf(uint32_t inventoryType, uint32_t *componentSlot = nullptr);
+
+// DressUpModel's dual-wield test: the model shows the active player, and the
+// player can dual wield.
+bool CanDualWield(uint64_t guid);
+
+// How a held try-on is hung.
+struct HeldTryOn {
+    uint32_t bodySlot = 0; // the hand named (kBodySlot*), or 0 for the worker's choice
+    bool dualWield = false;
+    bool sheathed = false;
+    bool hide = false;
+    uint32_t enchant = 0; // its glow's SpellItemEnchantment, or 0
+};
+
+// TryOnItem's arms on whatever holds the component and the lanes: an armor
+// slot is cleared and set on the component, which `armorReady` (the pane's
+// ready byte) must allow; a held item evicts an other-lane item it cannot be
+// held with, then takes its lane and hangs. The inventory slot (1-based) the
+// item went on, or 0.
+int TryOn(void *model, void *component, bool armorReady, Lanes &lanes, Weapons &weapons,
+          const uint8_t *record, const HeldTryOn &held);
+
+// UndressSlot: the item in one inventory slot (1-based) off the model. A
+// held lane is detached and zeroed, an armor slot cleared on the component.
+// Without a component it does nothing, held lanes included (4.3.4's
+// CGDressUpModelFrame::UndressSlot returns first).
+void UndressSlot(void *model, void *component, Lanes &lanes, int invSlot);
+
+// The component slot of an inventory slot (1-based), or -1 for a slot the
+// component has no record for (the neck, fingers, trinkets, hands held and
+// ranged).
+int ComponentSlotOf(int invSlot);
+
+// The inventory slot (1-based) of a component slot ArmOf gives, or 0.
+int InvSlotOfComponent(uint32_t componentSlot);
+
+// Whether TryOnItem's arms put anything in an inventory slot (1-based): a
+// hand takes any held item, an armor slot needs `armorReady` (a component the
+// model's ready gate allows).
+bool SlotAllowed(int invSlot, bool armorReady);
+
+// What `unit` wears in one inventory slot (1-based), back on the model: an
+// armor slot takes the unit's component record (empty when the unit hides
+// its helm or cloak), a held lane the unit's lane, row and glow. Armor needs
+// a component and `armorReady`.
+void DressSlot(void *model, void *component, bool armorReady, Lanes &lanes, Weapons &weapons,
+               void *unit, uint64_t guid, int invSlot, bool sheathed, bool hide);
+
+// DressUpModel ClearModel (0x00504490): component slots 0..11 cleared, and,
+// with `weapons`, both lanes detached and zeroed.
+void Undress(void *model, void *component, Lanes &lanes, bool weapons);
+
+// What one inventory slot wears, as retail's ItemTransmogInfo names it: the
+// item (1.12's appearance) and, on a hand, the SpellItemEnchantment whose
+// glow it shows. Zero for nothing.
+struct Appearance {
+    uint32_t item = 0;
+    uint32_t enchant = 0;
+};
+constexpr int kInventorySlots = 19;
+using Worn = Appearance[kInventorySlots]; // inventory slot n at [n - 1]
+
+// What the unit `guid` wears where its model shows it: each armor slot its
+// component shows and each hand `weapons` (ReadWeapons) holds. Nothing for a
+// unit that is not a player, which has no visible items.
+void ReadWorn(void *unit, uint64_t guid, const Weapons &weapons, Worn &worn);
+
+// Zeroes each slot of `worn` the model no longer shows: an armor slot the
+// component holds no record for (every one without a component), an empty
+// lane.
+void TrimWorn(void *component, const Lanes &lanes, Worn &worn);
+
+// The held lane an item record gives, as TryOnItem copies it: class,
+// subclass, inventory type and sheathe type.
+HeldLane LaneOf(const uint8_t *record);
+
+// RefreshRangedWeaponModel's source (0x00611E10): the unit's ranged lane and
+// display row (hand 2), and, for a player, the item its ranged slot wears.
+// All empty when the unit holds no ranged weapon.
+void ReadRanged(void *unit, uint64_t guid, HeldLane &lane, const void *&display, Appearance &worn);
+
+} // namespace Model::Outfit
@@ -51,7 +51,8 @@

 #include "Game.h"
 #include "Offsets.h"
-#include "dbc/Lookup.h"
+#include "frame/Layout.h"
+#include "gx/Device.h"
 #include "model/Camera.h"
 #include "model/DisplayInfo.h"
 #include "model/M2.h"
@@ -72,25 +73,11 @@ constexpr uint32_t kTexels = kSize * kSize;

 using CreateScene_t = void *(__cdecl *)();
 using ReleaseScene_t = void(__thiscall *)(void *scene);
-using CopyModel_t = void *(__thiscall *)(void *scene, void *source, uint32_t flags);
-using ApplyDisplay_t = void(__fastcall *)(void *model, const uint8_t *display,
-                                          const uint8_t *modelData);
-using DetachAll_t = void(__fastcall *)(void *model);
-using DrawScene_t = void(__thiscall *)(void *scene, uint32_t pass);
-using SetTransforms_t = void(__fastcall *)(void *camera, const float *rect, uint32_t unused);
-using GetMatrix_t = void(__fastcall *)(float *m);
-using SetMatrix_t = void(__fastcall *)(const float *m);
-using GetViewport_t = void(__fastcall *)(float *, float *, float *, float *, float *, float *);
-using SetViewport_t = void(__stdcall *)(float, float, float, float, float, float);
 using ScreenSize_t = void(__fastcall *)(float *rect);
-using DdcToNdc_t = void(__fastcall *)(float *x, float *y, float inX, float inY);
 using DeviceGate_t = int(__cdecl *)();
 using MasterGet_t = bool(__fastcall *)(uint32_t cap);
 using MasterSet_t = void(__fastcall *)(uint32_t cap, uint32_t on);
-using SetClearColor_t = void(__stdcall *)(uint32_t argb);
-using Clear_t = void(__fastcall *)(uint32_t mask);
 using AlphaMask_t = const uint8_t *(__fastcall *)(uint32_t size);
-using GetDeviceTexture_t = void *(__fastcall *)(void *texture, uint32_t wait, void *callback);
 using MarkDirty_t = void(__fastcall *)(void *gxTex, const int32_t *rect, uint32_t immediate);
 using SetImage_t = void(__thiscall *)(void *region, void *texture);

@@ -152,77 +139,62 @@ bool Bake(Portrait &p) {
    void *scene = reinterpret_cast<CreateScene_t>(Offsets::FUN_M2_CREATE_SCENE)();
    if (scene == nullptr)
        return false;
-    void *copy = reinterpret_cast<CopyModel_t>(Offsets::FUN_M2SCENE_COPY_MODEL)(scene, source, 0);
+    void *copy = M2::CopyWithoutItems(scene, source);
    if (copy == nullptr) {
        reinterpret_cast<ReleaseScene_t>(Offsets::FUN_M2SCENE_RELEASE)(scene);
        return false;
    }
-    reinterpret_cast<DetachAll_t>(Offsets::FUN_DETACH_ALL_ITEM_MODELS)(copy);
    void *camera = Model::Camera::CameraById(copy, 0);
    M2::PlayAnimation(copy, -1, 0, 0, 0, 1.0f, 0, 1);

-    float projection[16];
-    float view[16];
-    float viewport[6];
-    reinterpret_cast<GetMatrix_t>(Offsets::FUN_GX_GET_PROJECTION)(projection);
-    reinterpret_cast<GetMatrix_t>(Offsets::FUN_GX_GET_VIEW)(view);
-    reinterpret_cast<GetViewport_t>(Offsets::FUN_GX_GET_VIEWPORT)(
-        &viewport[0], &viewport[1], &viewport[2], &viewport[3], &viewport[4], &viewport[5]);
    const bool fog = reinterpret_cast<MasterGet_t>(Offsets::FUN_GX_MASTER_ENABLE_GET)(
        Offsets::GX_MASTER_FOG);
    auto setMaster = reinterpret_cast<MasterSet_t>(Offsets::FUN_GX_MASTER_ENABLE_SET);
    setMaster(Offsets::GX_MASTER_FOG, 0);
+    {
+        const Gx::SavedTransforms saved;
+        const float aspect = static_cast<float>((static_cast<double>(x1) - x0) /
+                                                (static_cast<double>(y1) - y0));
+        Frame::Layout::DdcToNdc(&x0, &y0, x0, y0);
+        Frame::Layout::DdcToNdc(&x1, &y1, x1, y1);

-    const float aspect = static_cast<float>((static_cast<double>(x1) - x0) /
-                                            (static_cast<double>(y1) - y0));
-    auto toNdc = reinterpret_cast<DdcToNdc_t>(Offsets::FUN_COORD_DDC_TO_NDC);
-    toNdc(&x0, &y0, x0, y0);
-    toNdc(&x1, &y1, x1, y1);
+        // First collection: evaluate the portrait camera.
+        M2::IsLoaded(copy, 1, 1);
+        M2::SetAnimated(copy, true);
+        const float origin[3] = {0.0f, 0.0f, 0.0f};
+        M2::AnimateScene(scene, origin);
+        const Model::Camera::Vec3 eye = Model::Camera::GetVector(camera, Offsets::CAMERA_PROP_EYE);
+        Model::Camera::GetVector(camera, Offsets::CAMERA_PROP_TARGET); // the bake reads it too
+        const float rect[4] = {0.0f, 0.0f, 1.0f, aspect};
+        Model::Camera::SetDeviceTransforms(camera, rect);
+        Gx::SetViewport({x0, x1, y0, y1, 0.0f, 1.0f});
+        Gx::SetClearColor(0);
+        Gx::Clear(3);

-    // First collection: evaluate the portrait camera.
-    M2::IsLoaded(copy, 1, 1);
-    M2::SetAnimated(copy, true);
-    const float origin[3] = {0.0f, 0.0f, 0.0f};
-    M2::AnimateScene(scene, origin);
-    const Model::Camera::Vec3 eye = Model::Camera::GetVector(camera, Offsets::CAMERA_PROP_EYE);
-    Model::Camera::GetVector(camera, Offsets::CAMERA_PROP_TARGET); // the bake reads it too
-    const float rect[4] = {0.0f, 0.0f, 1.0f, aspect};
-    reinterpret_cast<SetTransforms_t>(Offsets::FUN_CAMERA_SET_DEVICE_TRANSFORMS)(camera, rect, 0);
-    reinterpret_cast<SetViewport_t>(Offsets::FUN_GX_SET_VIEWPORT)(x0, x1, y0, y1, 0.0f, 1.0f);
-    reinterpret_cast<SetClearColor_t>(Offsets::FUN_GX_SET_CLEAR_COLOR)(0);
-    auto clear = reinterpret_cast<Clear_t>(Offsets::FUN_GX_CLEAR);
-    clear(3);
+        // Second collection from the portrait eye, then both passes.
+        M2::IsReady(copy, 1, 1);
+        M2::SetAnimated(copy, true);
+        M2::SetVisible(copy, true);
+        M2::SetRenderCallback(copy, reinterpret_cast<const void *>(Offsets::FUN_PORTRAIT_LIGHTING),
+                              nullptr);
+        M2::AnimateScene(scene, &eye.x);
+        M2::DrawScene(scene, 0);
+        M2::DrawScene(scene, 1);

-    // Second collection from the portrait eye, then both passes.
-    M2::IsReady(copy, 1, 1);
-    M2::SetAnimated(copy, true);
-    M2::SetVisible(copy, true);
-    M2::SetRenderCallback(copy, reinterpret_cast<const void *>(Offsets::FUN_PORTRAIT_LIGHTING),
-                          nullptr);
-    M2::AnimateScene(scene, &eye.x);
-    auto draw = reinterpret_cast<DrawScene_t>(Offsets::FUN_M2SCENE_DRAW);
-    draw(scene, 0);
-    draw(scene, 1);
-
-    const int32_t box[4] = {0, 0, static_cast<int32_t>(kSize), static_cast<int32_t>(kSize)};
-    TexelArray out{kTexels, kTexels, p.texels.data(), kTexels};
-    reinterpret_cast<void(__fastcall *)(const int32_t *, TexelArray *)>(
-        Offsets::FUN_GX_READ_PIXELS)(box, &out);
-    clear(3);
-    const auto *mask = reinterpret_cast<const AlphaMask *>(
-        reinterpret_cast<AlphaMask_t>(Offsets::FUN_PORTRAIT_ALPHA_MASK)(kSize));
-    if (out.data == p.texels.data()) {
-        for (uint32_t i = 0; i < kTexels; ++i)
-            p.texels[i] = (p.texels[i] & 0x00FFFFFFu) | static_cast<uint32_t>(mask->alpha[i]) << 24;
-        void *gxTex = reinterpret_cast<GetDeviceTexture_t>(Offsets::FUN_TEXTURE_GET_RENDERABLE)(
-            p.texture, 1, nullptr);
-        reinterpret_cast<MarkDirty_t>(Offsets::FUN_GX_TEX_MARK_RECT_DIRTY)(gxTex, box, 1);
+        const int32_t box[4] = {0, 0, static_cast<int32_t>(kSize), static_cast<int32_t>(kSize)};
+        TexelArray out{kTexels, kTexels, p.texels.data(), kTexels};
+        reinterpret_cast<void(__fastcall *)(const int32_t *, TexelArray *)>(
+            Offsets::FUN_GX_READ_PIXELS)(box, &out);
+        Gx::Clear(3);
+        const auto *mask = reinterpret_cast<const AlphaMask *>(
+            reinterpret_cast<AlphaMask_t>(Offsets::FUN_PORTRAIT_ALPHA_MASK)(kSize));
+        if (out.data == p.texels.data()) {
+            for (uint32_t i = 0; i < kTexels; ++i)
+                p.texels[i] = (p.texels[i] & 0x00FFFFFFu) | static_cast<uint32_t>(mask->alpha[i]) << 24;
+            void *gxTex = Texture::DeviceTexture(p.texture);
+            reinterpret_cast<MarkDirty_t>(Offsets::FUN_GX_TEX_MARK_RECT_DIRTY)(gxTex, box, 1);
+        }
    }
-
-    reinterpret_cast<SetMatrix_t>(Offsets::FUN_GX_SET_PROJECTION)(projection);
-    reinterpret_cast<SetMatrix_t>(Offsets::FUN_GX_SET_VIEW)(view);
-    reinterpret_cast<SetViewport_t>(Offsets::FUN_GX_SET_VIEWPORT)(
-        viewport[0], viewport[1], viewport[2], viewport[3], viewport[4], viewport[5]);
    setMaster(Offsets::GX_MASTER_FOG, fog ? 1 : 0);
    M2::Release(copy);
    reinterpret_cast<ReleaseScene_t>(Offsets::FUN_M2SCENE_RELEASE)(scene);
@@ -270,27 +242,14 @@ Portrait *Acquire(uint32_t displayID) {
    auto found = g_portraits.find(displayID);
    if (found != g_portraits.end())
        return found->second.get();
-    const uint8_t *display = DBC::Record(Offsets::VAR_CREATUREDISPLAYINFO_RECORDS,
-                                         Offsets::VAR_CREATUREDISPLAYINFO_COUNT, displayID);
-    if (display == nullptr)
-        return nullptr;
-    const uint8_t *modelData = DBC::Record(
-        Offsets::VAR_CREATUREMODELDATA_RECORDS, Offsets::VAR_CREATUREMODELDATA_COUNT,
-        Game::Read<uint32_t>(display, Offsets::OFF_CREATUREDISPLAYINFO_MODEL_ID));
-    if (modelData == nullptr)
-        return nullptr;
-
    void *scene = reinterpret_cast<CreateScene_t>(Offsets::FUN_M2_CREATE_SCENE)();
    if (scene == nullptr)
        return nullptr;
-    void *model = M2::CreateModel(
-        scene, Game::Read<const char *>(modelData, Offsets::OFF_CREATUREMODELDATA_MODEL_PATH));
+    void *model = Model::DisplayInfo::CreateDisplayModel(scene, displayID);
    if (model == nullptr) {
        reinterpret_cast<ReleaseScene_t>(Offsets::FUN_M2SCENE_RELEASE)(scene);
        return nullptr;
    }
-    reinterpret_cast<ApplyDisplay_t>(Offsets::FUN_APPLY_CREATURE_DISPLAY)(model, display,
-                                                                          modelData);

    // The bake's own texture: 64x64, one mip, ARGB8888, flags (1, 0, 0, 0, 0,
    // 0, 1, 0), "Portrait1" (0x005257D3).
@@ -0,0 +1,493 @@
+// This file is part of ClassicAPI.
+//
+// ClassicAPI is free software: you can redistribute it and/or modify it under the terms
+// of the GNU General Public License as published by the Free Software Foundation, either
+// version 3 of the License, or (at your option) any later version.
+//
+// ClassicAPI is distributed in the hope that it will be useful, but WITHOUT ANY
+// WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
+// PURPOSE. See the GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License along with
+// ClassicAPI. If not, see <https://www.gnu.org/licenses/>.
+
+#pragma once
+
+#include "Offsets.h"
+#include "animation/Object.h"
+#include "model/Outfit.h"
+#include "model/SceneContact.h"
+#include "model/TryOn.h"
+
+#include <cstdint>
+#include <memory>
+#include <string>
+#include <utility>
+#include <vector>
+
+// The ModelScene frame (model/Scene.cpp) and its actors (model/SceneActor.cpp).
+// docs/notes/model-scene.md has the plan, the retail contract and the probes.
+namespace Model::Scene {
+
+class Actor;
+namespace World {
+struct Ambience;
+}
+namespace Mover {
+struct Body;
+}
+
+// The light of a spell's model in flight or left behind, as the world gives
+// a missile or an effect a light node of its own: an entity standing on the
+// WMO under it (World::Settle / ActorLight), else the frame's light.
+struct EntityLight {
+    explicit EntityLight(void *frame);
+    ~EntityLight();
+    EntityLight(const EntityLight &) = delete;
+    EntityLight &operator=(const EntityLight &) = delete;
+    void *frame;
+    World::Ambience *ambience;
+};
+
+// One PlaySpellVisual on its caster (model/SceneSpell.cpp): the precast, the
+// cast, then the missile in flight.
+struct SpellCast {
+    enum class Phase { Precast, Cast, Flight };
+    uint32_t id = 0; // PlaySpellVisual's cast ID
+    uint32_t spellID = 0;
+    // The visual the caster shows (UnitGetSpellVisual's 64 bytes: the
+    // spell's record, a ranged spell's gaps filled from its weapon's).
+    uint8_t visual[Offsets::SPELL_VISUAL_SIZE] = {};
+    // The ammo the shot carries (SMSG_SPELL_GO's): an ItemDisplayInfo id and
+    // inventory type, 0 for a spell that is not ranged.
+    uint32_t ammoDisplay = 0;
+    uint32_t ammoType = 0;
+    Actor *target = nullptr;         // the caster for a cast on itself
+    Phase phase = Phase::Precast;
+    float precastLeftSec = 0.0f;
+    std::vector<void *> precastEffects; // one reference each
+    bool precastTinted = false;         // the precast kit set a tint or alpha
+    void *missile = nullptr;            // one reference, from the cast on
+    void *missileSound = nullptr;
+    float queuedSec = 0.0f; // since the missile was made, until its release
+    float speed = 0.0f;
+    float position[3] = {};
+    float destination[3] = {};
+    int attachment = -1; // the target attachment the launch settled, or -1
+    bool sticks = false; // shot from a bow, crossbow or thrown weapon
+    std::unique_ptr<EntityLight> light; // the missile's
+};
+
+// A cast that reached its target this frame, for the caster's
+// OnSpellVisualImpact.
+struct SpellImpact {
+    uint32_t castID = 0;
+    uint32_t spellID = 0;
+    Actor *target = nullptr;
+};
+
+// A missile stuck in its target, until its time is up.
+struct StuckMissile {
+    void *model = nullptr; // one reference
+    float leftSec = 0.0f;
+};
+
+// An impact model left at a missile's arrival, until its particles are gone.
+struct ImpactModel {
+    void *model = nullptr; // one reference
+    int framesShown = 0;
+    std::unique_ptr<EntityLight> light;
+};
+
+// A ModelSceneActor: one model in its scene frame's M2 scene, placed by the
+// scene's paint. A script object (Animation::Object) whose parent is the scene
+// frame, which owns it.
+class Actor : public Animation::Object {
+  public:
+    static Animation::Class s_class;
+
+    Actor(void *scene, const char *name);
+    ~Actor();
+
+    void *SceneFrame() const { return parent; }
+
+    // From the scene frame's update, before the scene clock advances: puts a
+    // ready model on the scene's animate list.
+    void Link();
+    // From the scene frame's update walk: load and dress state, scripts.
+    void Update(float elapsedSec);
+    // From the scene's paint, before the scene animates: the model's
+    // placement matrix.
+    void Place();
+    // The scene frame's alpha changed.
+    void ApplyAlpha();
+
+    // Shows `model` (one reference, which the actor takes over), or nothing.
+    void SetModel(void *model, const char *path, const uint8_t *dressRecord);
+    // Shows a copy of the unit's model, dressed and armed per autoDress,
+    // sheathed and hideWeapons; false (and no model) when it has none.
+    bool SetUnitModel(uint64_t guid);
+    // Hangs the hand lanes per MeleeSheathed and hideWeapons, and the ranged
+    // weapon in hand while it is drawn.
+    void ApplyWeapons();
+    // A ranged spell's start (the unit's sheathe state 2): the melee items
+    // on their sheath points, the ranged weapon in hand, until SetSheathed or
+    // a new model.
+    void DrawRanged();
+    // Leaves sheathe state 2: the ranged weapon leaves the hand.
+    void SheatheRanged();
+    // Whether the hand lanes hang at their sheath points: sheathed, or the
+    // ranged weapon drawn.
+    bool MeleeSheathed() const { return sheathed || rangedDrawn; }
+    // Puts the item on the model (Outfit::TryOn), once the model has loaded
+    // and the item's record is cached; returns the ItemTryOnReason.
+    int TryOnItem(const Model::TryOn::Request &request);
+    void ClearModel();
+    void PlayAnimation();
+    // Shows the kit (0 for none) on the model, replacing the one shown.
+    void SetSpellVisualKit(uint32_t kitID, bool oneShot);
+    // Loads the actor's XML element (an <Actor> template), then runs OnLoad.
+    void LoadXml(const void *node, void *status);
+
+    void *model = nullptr;
+    std::string modelPath;
+    const uint8_t *dressRecord = nullptr; // CreatureDisplayInfoExtra, until dressed
+    float displayScale = 1.0f; // a creature display's CreatureModelScale, else 1
+    // The CreatureDisplayInfo the model shows (a creature display's, or the
+    // unit's UNIT_FIELD_DISPLAYID), for its sound data; 0 for a model file.
+    uint32_t displayID = 0;
+    bool playAnimationSounds = false; // SetPlayAnimationSounds
+    bool shadowShown = false;         // SetShadowShown: a blob shadow under the model
+    World::Ambience *ambience;        // its light in the scene's WMO (owned)
+    // The character component dressing the model: a display's dress, or the
+    // clone of a unit's.
+    void *dresser = nullptr;
+    // A unit's model (SetModelByUnit): the unit and what the copy holds.
+    uint64_t unitGuid = 0;
+    Outfit::Lanes lanes = {};
+    Outfit::Weapons weapons;
+    Outfit::Worn worn = {}; // what each inventory slot wears (GetItemTransmogInfoList)
+    bool autoDress = true;
+    bool sheathed = false;
+    bool hideWeapons = false;
+    bool rangedDrawn = false; // the unit's sheathe state 2
+    // The ranged slot (a ClassicAPI extension): a unit's third held lane,
+    // inventory slot 18, which every bow, gun, crossbow, wand and thrown
+    // weapon takes. Its ItemDisplayInfo row, and its model (a unit's +0xD24,
+    // one reference) while hung: in hand while drawn, else only at a sheath
+    // point its type has.
+    Outfit::HeldLane ranged = {};
+    const void *rangedDisplay = nullptr;
+    void *rangedModel = nullptr;
+    // Per lane: the SetSheathedCategory category (Outfit::SheatheCategory),
+    // and the sheathe type the lane's item has of its own. The lane itself
+    // holds the type it hangs with.
+    uint32_t sheatheCategory[2] = {};
+    uint8_t ownSheathe[2] = {};
+    bool useUnitSheatheCategory = false; // UseUnitSheatheCategory
+    // The ammo tried on (an INVTYPE_AMMO item, as a player equips it): its
+    // ItemDisplayInfo id, 0 for none.
+    uint32_t ammoDisplay = 0;
+    // Lane `i` (on `onModel`, the actor's model or the copy being built) was
+    // just filled with its item's own type: hang it per its category.
+    void TookLane(void *onModel, int i);
+    // Hangs lane `i` per its category.
+    void ApplySheatheCategory(void *onModel, int i);
+    // DressUpModel's ready byte: the model may take armor (not a shapeshifted
+    // unit's).
+    bool armorReady = true;
+    std::vector<Model::TryOn::Request> pendingTryOns; // waiting for the model or the record
+    bool loaded = false; // OnModelLoaded has run for the model
+    bool animFinished = false;
+
+    // The client's mover (SetMovementEnabled, a ClassicAPI extension): while
+    // set, it moves `position` and turns `yaw` through the scene's WMO.
+    std::unique_ptr<Mover::Body> mover;
+    // A unit's facings while the mover is on (CGUnit_C +0xC98, +0xC94): the
+    // display facing the body turns toward, the body facing the model is
+    // drawn at, the time the display last stood still (+0xCB0), and the body
+    // pass's bits (+0xD58): 0x1 turning, 0x80 and 0x100 the model's twist
+    // bones, marked for `bonesOf` once it has loaded. `shuffle` is the pass's
+    // 0x800 (1) or 0x1000 (-1): the body caught up turning left or right on
+    // the spot this frame.
+    struct Facings {
+        float display = 0.0f;
+        float body = 0.0f;
+        uint32_t stamp = 0;
+        uint32_t bits = 0;
+        int shuffle = 0;
+        const void *bonesOf = nullptr;
+    } facings;
+    // The yaw the model is drawn at: the body facing while the mover is on.
+    float ShownYaw() const { return mover != nullptr ? facings.body : yaw; }
+
+    float position[3] = {0.0f, 0.0f, 0.0f};
+    float yaw = 0.0f, pitch = 0.0f, roll = 0.0f;
+    float scale = 1.0f;
+    float alpha = 1.0f;
+    bool shown = true;
+    bool useCenterForOrigin[3] = {false, false, false};
+    uint32_t animation = 0;
+    int variation = -1;
+    float animSpeed = 1.0f;
+    float animOffsetSec = 0.0f;
+    uint32_t blendOperation = 1; // Enum.ModelBlendOperation: 0 None, 1 Anim
+    bool paused = false;
+    bool globalPaused = false;
+    int heldPositionMs = -1; // the paused frame; -1 until read from a loaded model
+    uint32_t spellVisualKit = 0;
+    bool spellVisualKitOneShot = false;
+    std::vector<void *> kitEffects; // the kit's effect models, one reference each
+    // ApplySpellVisualKit calls made before the model loaded: {kit, oneShot}.
+    std::vector<std::pair<uint32_t, bool>> pendingKits;
+
+    // A spell kit's animation, shown in place of `animation` (-1 none): a
+    // precast's loops, a cast's or an impact's plays once.
+    int kitAnimation = -1;
+    bool kitAnimationLoops = false;
+    // The precast's looping animation (-1 none), which a once-only kit
+    // animation (a wound) gives back when it ends, as a unit's replays its
+    // spell's looping kit animation.
+    int kitLoopAnimation = -1;
+    bool kitAnimationEnded = false; // a once-only kit animation ended this frame
+    void PlayKitAnimation(int anim, bool loops);
+    // The animation the body plays: a spell kit's, else the script's.
+    int CurrentAnimation() const { return kitAnimation >= 0 ? kitAnimation : static_cast<int>(animation); }
+    // A release event of the model this frame ($CSL / $CSR / $CST, or $BWR
+    // from the bow or rifle release point), and its point.
+    bool releaseEvent = false;
+    float releasePoint[3] = {};
+    // The ranged pose, as a unit keeps it: the ammo in hand (one reference,
+    // nocked at attachment 35 while the bow is drawn), its display, and the
+    // drawn bit.
+    void *heldAmmo = nullptr;
+    uint32_t heldAmmoDisplay = 0;
+    bool bowDrawn = false;
+    // The unit fields DrawBowstring reads (the model and the drawn bit), the
+    // user data of a hung bow's string; each update, before the draw.
+    alignas(4) uint8_t stringUnit[Offsets::OFF_CGUNIT_STATE_FLAGS + 4] = {};
+    std::vector<SpellCast> spellCasts;
+    // The casts that reached their target, in order, until the update runs
+    // OnSpellVisualImpact for them: outside the casts' step, which a script
+    // that casts or stops a spell would change under it.
+    std::vector<SpellImpact> spellImpacts;
+    // The moves (MoveTo) the mover reported done, until the update runs
+    // OnMoveFinished for them.
+    uint32_t movesFinished = 0;
+    std::vector<ImpactModel> impactModels;
+    std::vector<StuckMissile> stuckMissiles; // the missiles stuck in this actor
+};
+
+// The spell visuals an actor casts (model/SceneSpell.cpp).
+namespace Casts {
+// Starts the cast and returns its ID (from 1); 0 when the spell, its visual
+// or the caster's model is missing. `castTimeMs` < 0 takes the spell's cast
+// time.
+uint32_t Play(Actor &caster, uint32_t spellID, Actor *target, int castTimeMs);
+// Interrupts the casts still preparing; casts already made go on.
+void Stop(Actor &caster);
+// The model's $BWP: the bow draws and the ammo is nocked, while a ranged
+// spell is cast.
+void BowPull(Actor &caster);
+// The model's $BWR: the weapon plays its release before the missiles go.
+void BowRelease(Actor &caster);
+// The animation a ranged load or hold goes on to when it ends, or -1 for
+// none (the ranged shot cycle).
+int RangedAnimationAfter(const Actor &caster, int ended);
+// EndRangedPose (0x0060F530): the bow is no longer drawn, the ammo leaves the
+// hand, and the weapon stands again unless it plays its release.
+void EndRangedPose(Actor &actor);
+// From the actor's update, after the scene advance: the casts move on.
+void Update(Actor &caster, float elapsedSec);
+// From the actor's Link: the released missiles and the impact models go on
+// the scene's animate list.
+void Link(Actor &caster);
+// From the actor's Place: the missiles' placement.
+void Place(Actor &caster);
+// Drops every cast, missile and impact model of the caster.
+void Drop(Actor &caster);
+// Stops the missiles' loop sounds (the scene hid; its update stops).
+void Silence(Actor &caster);
+} // namespace Casts
+
+// The unit's movement animations (model/SceneLocomotion.cpp): an actor with
+// the mover on picks and plays them as the client's unit does from its own
+// mover. Each is a no-op for an actor without the mover, without a loaded
+// model, or dead (its own animation a death animation).
+namespace Locomotion {
+// The movement messages a unit animates (AnimateMoveOpcode 0x0060E480), by
+// their 1.12 opcodes.
+enum class Move : uint32_t {
+    StartForward = 0xB5,
+    StartBackward = 0xB6,
+    Stop = 0xB7,
+    StartStrafeLeft = 0xB8,
+    StartStrafeRight = 0xB9,
+    StopStrafe = 0xBA,
+    Jump = 0xBB,
+    StartTurnLeft = 0xBC,
+    StartTurnRight = 0xBD,
+    StopTurn = 0xBE,
+    RunMode = 0xC2,
+    WalkMode = 0xC3,
+    TeleportAck = 0xC7,
+    StartSwim = 0xCA,
+    StopSwim = 0xCB,
+};
+// A movement message for a command the mover took, or a change the actor
+// made (ProcessLocalMoveEvent 0x0060E0A0 -> AnimateMoveOpcode).
+void OnMove(Actor &actor, Move move);
+// The mover's substep hook (Mover::Body::stepped), context the actor: an
+// arrival at a spline's end, a landing, a fall or a swim's end.
+void OnStep(void *actor, uint32_t oldFlags, bool jumped, bool arrived);
+// The body pass's shuffle (the tail of CGUnit_C::Update 0x00607ED0), `turn`
+// the turn the body made this frame.
+void OnBodyTurn(Actor &actor, float turn);
+// The actor's own animation ended: plays what follows it
+// (PlayFollowOnAnimation 0x005FC3F0) and returns true; false when the chain
+// does not run, and the caller replays it.
+bool FollowOn(Actor &actor);
+// Picks again (UpdateBaseAnimation 0x005FD9E0).
+void Repick(Actor &actor);
+} // namespace Locomotion
+
+// The actor model's animation events (model/SceneEvents.cpp).
+namespace Events {
+// The model event callback (Offsets::FUN_M2MODEL_SET_EVENT_CALLBACK), user
+// data the actor: missile releases for Casts, and the event sounds.
+void __stdcall OnModelEvent(uint32_t tag, uint32_t data, const float *point, uint32_t unknown,
+                            uint32_t userLow, uint32_t userHigh);
+} // namespace Events
+
+// The scene's WMO (SetWorldModel; model/SceneWorld.cpp).
+namespace World {
+struct Backdrop;
+// Whether `path` names a WMO (ends in ".wmo"), which only the scene shows.
+bool IsWmoPath(const char *path);
+// Null when the engine cannot read `path` safely: it is not a WMO, a file
+// does not open, the root's chunks are not in the engine's order or it has
+// more groups than the engine holds.
+// `mapID` is the map whose light the outdoor water takes (Light.dbc at the
+// scene's camera), or kNoMap for the world's light where the player is.
+constexpr uint32_t kNoMap = 0xFFFFFFFFu;
+Backdrop *Load(const char *path, const float (&placement)[16], uint32_t doodadSet, uint32_t mapID);
+// The single WMO of a WMO-only map at the map's own placement; null for any
+// other map.
+Backdrop *LoadMap(uint32_t mapID);
+// SetWorldModel's placement: at `position`, turned by `yaw` about z.
+void Placement(const float (&position)[3], float yaw, float (&out)[16]);
+void Free(Backdrop *backdrop);
+// From the scene's update, before the scene advances: makes the doodads of
+// each group parsed since, puts the ready ones on the animate list and
+// moves their sounds with the camera, and moves the camera's WMO fog (the
+// MFOG records near the camera, faded in and out as the world fades them).
+// `sounds` is SetPlayWorldModelSounds.
+void Update(Backdrop &backdrop, void *frame, bool sounds, float elapsed);
+// Drops the doodads' loop sounds (the scene hid).
+void Silence(Backdrop &backdrop);
+// From the paint, in place of its depth clear: the world's frame clear and,
+// with the camera outside the WMO's interior groups and dry, the world's sky
+// (the dome, the sun and moons, the stars, the clouds and the skyboxes) in
+// the device's view, lit by the backdrop map's light at the camera.
+void ClearAndDrawSky(const Backdrop &backdrop, void *frame, const float (&eye)[3]);
+// From the paint, after the animate pass: the WMO in the device's view.
+void Draw(Backdrop &backdrop, void *frame, const float (&eye)[3]);
+// From the paint, between the scene's opaque and translucent lists: the
+// liquids of the WMO's groups (the world draws them between its model lists).
+void DrawLiquids(Backdrop &backdrop, void *frame, const float (&eye)[3]);
+// Whether the camera is in one of the WMO's liquids: the world then draws the
+// liquids after the translucent models.
+bool CameraWet(const Backdrop &backdrop);
+// How the world lights a unit that stands in a WMO, kept per actor: the
+// colour of the face under it, or the sun, and the WMO's lights near it.
+struct Ambience;
+Ambience *NewAmbience();
+void FreeAmbience(Ambience *ambience);
+// From the scene's update: places the model in the WMO again when it moved,
+// or when more of the WMO has loaded since.
+void Settle(const Backdrop &backdrop, Ambience &ambience, void *frame, void *model, float elapsed);
+// The actor's lighting slots: the frame's light and fog without a WMO, or
+// before the model is placed in this one.
+void ActorLight(const Backdrop *backdrop, const Ambience &ambience, void *frame, void *record);
+// The TerrainType id of the WMO face under the actor, or -1 (no face, no
+// WMO, or not placed in this one).
+int Ground(const Backdrop *backdrop, const Ambience &ambience);
+// The nearest face of the loaded groups that the segment from `start` to
+// `end` (scene space) crosses, of the faces the world's line of sight tests,
+// or with `camera` the faces its camera collides with: its fraction along the
+// segment and its unit normal, turned to face `start`. False on a miss or
+// before the WMO has loaded.
+bool Trace(const Backdrop &backdrop, const float (&start)[3], const float (&end)[3], bool camera,
+           float &fraction, float (&normal)[3]);
+// The liquid a point (scene space) is in: the type (0 water, 1 ocean, 2
+// magma, 3 slime) and the surface's z, FLT_MAX for a group that is liquid
+// throughout. False when the point is not under a liquid surface of the
+// group below it, or before the WMO has loaded.
+bool LiquidAt(const Backdrop &backdrop, const float (&point)[3], uint32_t &type, float &surface);
+// The world query (0x006721B0) a scene body's sweeps make, for
+// Contact::Facets: the WMO's collision faces in a box (scene space), then
+// its doodads' collision meshes. False without a WMO, before it has loaded,
+// or while a group or doodad in the box is still loading, so a body there
+// does not move.
+bool QueryFacets(void *backdrop, const float (&box)[6], std::vector<Contact::Facet> &out);
+// The same query with a swimmer's class (0x30000), for Contact::Facets: the
+// water and ocean surfaces of the WMO's liquid groups in a box (scene space),
+// as their tiles' triangles. False without a WMO or before it has loaded.
+bool QueryLiquidFacets(void *backdrop, const float (&box)[6], std::vector<Contact::Facet> &out);
+// Sweeps a body by `move` to its first contact with the WMO's collision
+// faces, as the client's mover sweeps a unit's volume (CMovement::SweepVolume
+// 0x00632BA0, SceneContact.h): a box `radius` from `feet` on each side and
+// `height` tall over a downward point at `feet`. `end` is where the feet
+// stop; true when a face was met, `normal` the facet's plane normal (scene
+// space). The feet stay put before the WMO has loaded.
+bool Sweep(const Backdrop &backdrop, const float (&feet)[3], float radius, float height, const float (&move)[3],
+           float (&end)[3], float (&normal)[3]);
+// From the paint, after Draw: a texture laid over the WMO's faces in `box`
+// (scene space), as the world lays a decal on its ground.
+void DrawDecal(const Backdrop &backdrop, const float (&box)[6], uint32_t argb, const float (&m)[16], float fade,
+               uint32_t mask, const float (&eye)[3]);
+} // namespace World
+
+// The scene's WMO, or null.
+World::Backdrop *WorldOf(void *sceneFrame);
+
+// The actor the scene's sounds are heard at (SetSoundListenerActor), or null.
+Actor *SoundListener(void *sceneFrame);
+
+// The scene's sounds (model/SceneSound.cpp), heard from the scene camera:
+// each plays where its scene point lies from the camera, turned into the
+// sound listener's frame, so the engine's cutoff, falloff and panning apply
+// as they would to a unit at that distance.
+namespace Sounds {
+// A scene point as a point of the listener's (the engine's axes), heard at
+// the scene's listener actor while SoundListenerAtCharacter is on, else at
+// the scene camera.
+void Heard(void *sceneFrame, const float (&point)[3], float (&out)[3]);
+// Sound::Play::PlayKitIDAt, PlayKitLoopedAt and Move at a scene point.
+void *Play(void *sceneFrame, int soundKitID, const float (&point)[3]);
+void *Loop(void *sceneFrame, int soundKitID, const float (&point)[3]);
+void Move(void *sceneFrame, void *sound, const float (&point)[3]);
+} // namespace Sounds
+
+// The scene camera (model/Scene.cpp).
+struct View {
+    float eye[3];
+    float forward[3];
+    float up[3];
+    float farClip;
+};
+View CameraView(void *sceneFrame);
+
+// The scene's ground terrain (SetGroundTerrain): a TerrainType id, or -1.
+int GroundTerrain(void *sceneFrame);
+
+// Registers the actor class in the current Lua state.
+void RegisterActorClass();
+
+// The methods' argument checks, for the frame and its actors. True when the
+// `count` arguments from `first` are numbers; else the engine's usage error,
+// "Usage: <owner>:<usage>".
+bool NumberArgs(void *L, int first, int count, const char *owner, const char *usage);
+float FloatArg(void *L, int index);
+
+} // namespace Model::Scene
@@ -0,0 +1,432 @@
+// This file is part of ClassicAPI.
+//
+// ClassicAPI is free software: you can redistribute it and/or modify it under the terms
+// of the GNU General Public License as published by the Free Software Foundation, either
+// version 3 of the License, or (at your option) any later version.
+//
+// ClassicAPI is distributed in the hope that it will be useful, but WITHOUT ANY
+// WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
+// PURPOSE. See the GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License along with
+// ClassicAPI. If not, see <https://www.gnu.org/licenses/>.
+
+// The client mover's contact sweep, function by function (see SceneContact.h).
+//
+// Precision: the client runs these on the x87 at 53 bits and stores floats,
+// so each sum here is a double and each store a float cast, in the operand
+// order of the disassembly (benilla-re systems/collision/contact.md has the
+// instruction-level notes; its crates/collision/src/resolve_clip.rs is the
+// difftested transcription this follows). Where that transcription and the
+// binary differ, the binary wins: 0x00632BA0 starts the best distance and
+// each face's cap at the length asked for, not at the 1/36 floor
+// (0x00632BC3, 0x00632E10); the degenerate-edge test of the prisms returns
+// only below 2^-20 (0x006325B5, 0x006330C6 `jnp`); 0x006329E0 divides at the
+// parallel bound; and the quad prism tests its side against the vertex
+// before the edge with the sum (z, x, y) (0x006330EA, 0x00633126).
+
+#include "model/SceneContact.h"
+
+#include "Game.h"
+#include "Offsets.h"
+#include "model/ScenePrecision.h"
+
+#include <algorithm>
+#include <cfloat>
+#include <cstddef>
+#include <cmath>
+#include <cstring>
+#include <xmmintrin.h>
+
+namespace Model::Scene::Contact {
+
+namespace {
+
+using Game::Live;
+using Precision::Bits;
+using Precision::D;
+
+const Live<float> kSkin{Offsets::VAR_MOVER_SKIN};                      // 1/720
+const Live<float> kAllBehind{Offsets::VAR_MOVER_ALL_BEHIND};           // -2^-20
+const Live<float> kDegenerate{Offsets::VAR_TWO_POW_MINUS_20};
+const Live<float> kThirtySixth{Offsets::VAR_ONE_THIRTY_SIXTH};
+const Live<float> kNegThirtySixth{Offsets::VAR_MINUS_ONE_THIRTY_SIXTH};
+const Live<float> kFacing{Offsets::VAR_MOVER_MINUS_FACING_EPSILON};    // -1e-5
+const float kGrowth = Bits(0x3E2AAAAB);                                // 1/6, the gather's growth
+const Live<float> kBevelOut{Offsets::VAR_MOVER_BEVEL_OUT};             // sin 61.6°
+const Live<float> kBevelDown{Offsets::VAR_MOVER_BEVEL_DOWN};           // cos 61.6°
+const Live<float> kWaist{Offsets::VAR_MOVER_WAIST};                    // tan 61.6°
+constexpr float kFltMax = FLT_MAX;
+const float kTwelfth = Bits(0x3DAAAAAB);                               // 1/12, the point-over-facet margin
+const Live<float> kThreeQuarters{Offsets::VAR_THREE_QUARTERS};         // the swimmer's height
+
+// The volume's faces as vertex indices (0x00631BE0's store block): the five
+// box faces as quads, in plane order, then the four bevels as triangles.
+constexpr uint8_t kFaces[32] = {1, 2, 6, 5, 3, 4, 8, 7, 2, 3, 7, 6, 4, 1, 5, 8,
+                                5, 6, 7, 8, 0, 1, 2, 0, 3, 4, 0, 2, 3, 0, 4, 1};
+
+// A clip polygon (0xF4 bytes): up to 15 vertices, the plane each one came
+// from, and the count.
+struct Polygon {
+    float v[15][3];
+    int32_t tag[15];
+    uint32_t count;
+};
+static_assert(sizeof(Polygon) == 0xF4 && offsetof(Polygon, tag) == 0xB4 && offsetof(Polygon, count) == 0xF0,
+              "the client's clip polygon");
+static_assert(sizeof(Plane) == 0x10, "the client's plane");
+
+struct Volume {
+    Plane planes[9];
+    float v[9][3];
+};
+
+// ClipPolygonByPlane: keeps the inside of a plane, with a 1/720 band,
+// tagging the vertices it adds.
+void ClipByPlane(Polygon &poly, const Plane &pl, int32_t tag) {
+    using Fn = void(__fastcall *)(const Plane *, Polygon *, int32_t);
+    reinterpret_cast<Fn>(Offsets::FUN_CLIP_POLYGON_BY_PLANE)(&pl, &poly, tag);
+}
+
+// ClipPolygonByPlanes: by each plane in turn, false once empty.
+bool ClipByPlanes(Polygon &poly, const Plane *planes, int count) {
+    using Fn = int(__fastcall *)(const Plane *, uint32_t, Polygon *);
+    return reinterpret_cast<Fn>(Offsets::FUN_CLIP_POLYGON_BY_PLANES)(planes, static_cast<uint32_t>(count), &poly) != 0;
+}
+
+// ClipPolygonByPlanesExcept: by every volume plane but one.
+bool ClipByPlanesExcept(Polygon &poly, const Plane (&planes)[9], int skip) {
+    using Fn = int(__fastcall *)(const Plane *, uint32_t, uint32_t, Polygon *);
+    return reinterpret_cast<Fn>(Offsets::FUN_CLIP_POLYGON_BY_PLANES_EXCEPT)(planes, 9, static_cast<uint32_t>(skip),
+                                                                           &poly) != 0;
+}
+
+// PlaneFromTriangle: the normalized plane through three points, normal
+// (p1 - p0) × (p2 - p0).
+Plane PlaneFromPoints(const float (&p0)[3], const float (&p1)[3], const float (&p2)[3]) {
+    using Fn = void(__fastcall *)(Plane *, int, const float *, const float *, const float *);
+    Plane pl;
+    reinterpret_cast<Fn>(Offsets::FUN_PLANE_FROM_TRIANGLE)(&pl, 0, p0, p1, p2);
+    return pl;
+}
+
+// One edge plane of a face swept along `s` (0x00632460 / 0x00632F80): the
+// plane through the edge a→b and a + s, turned so that `other`, a face
+// vertex off the edge, is not on its positive side. False for an edge too
+// short or parallel to `s`.
+bool EdgePlane(const float (&a)[3], const float (&b)[3], const float (&other)[3], const float (&s)[3], bool quad,
+               Plane &out) {
+    float moved[3], u[3], w[3];
+    for (int k = 0; k < 3; ++k)
+        moved[k] = static_cast<float>(D(a[k]) + s[k]);
+    for (int k = 0; k < 3; ++k) {
+        u[k] = static_cast<float>(D(moved[k]) - a[k]);
+        w[k] = static_cast<float>(D(b[k]) - a[k]);
+    }
+    // w × u (0x0063256F: three `fsubp st(1),st`).
+    const float cz = static_cast<float>(D(u[1]) * w[0] - D(w[1]) * u[0]);
+    const float cy = static_cast<float>(D(w[2]) * u[0] - D(u[2]) * w[0]);
+    const float cx = static_cast<float>(D(u[2]) * w[1] - D(u[1]) * w[2]);
+    if (std::fabs((D(cy) * cy + D(cz) * cz) + D(cx) * cx) < kDegenerate)
+        return false;
+    out = PlaneFromPoints(a, b, moved);
+    float t[3];
+    for (int k = 0; k < 3; ++k)
+        t[k] = static_cast<float>(D(other[k]) - a[k]);
+    const double side = quad ? (D(t[2]) * out.n[2] + D(t[0]) * out.n[0]) + D(t[1]) * out.n[1]
+                             : (D(t[2]) * out.n[2] + D(t[1]) * out.n[1]) + D(t[0]) * out.n[0];
+    if (side > 0.0) {
+        for (float &c : out.n)
+            c = -c;
+        out.d = -out.d;
+    }
+    return true;
+}
+
+// BuildTrianglePrism (0x00632460): the edge planes of a bevel swept along s.
+bool TrianglePrism(const Volume &volume, const uint8_t *index, const float (&s)[3], Plane (&out)[4]) {
+    for (int i = 0; i < 3; ++i)
+        if (!EdgePlane(volume.v[index[i]], volume.v[index[(i + 1) % 3]], volume.v[index[(i + 2) % 3]], s, false,
+                       out[i]))
+            return false;
+    return true;
+}
+
+// BuildQuadPrism (0x00632F80): the edge planes of a box face swept along s.
+bool QuadPrism(const Volume &volume, const uint8_t *index, const float (&s)[3], Plane (&out)[4]) {
+    for (int i = 0; i < 4; ++i)
+        if (!EdgePlane(volume.v[index[i]], volume.v[index[(i + 1) & 3]], volume.v[index[(i + 3) & 3]], s, true,
+                       out[i]))
+            return false;
+    return true;
+}
+
+// BuildVolumePlanes (0x00631440) and CMovement::BuildVolume (0x00631BE0):
+// the nine planes and nine vertices of the volume at p.
+Volume BuildVolume(const float (&p)[3], float radius, float height) {
+    const double x = p[0], y = p[1], z = p[2], r = radius, h = height;
+    const double a = kBevelOut, b = kBevelDown, zero = 0.0;
+    Volume v{};
+    const auto set = [&](int i, float nx, float ny, float nz, double d) {
+        v.planes[i] = Plane{{nx, ny, nz}, static_cast<float>(d)};
+    };
+    set(0, -1.0f, 0.0f, 0.0f, x - r);
+    set(1, 1.0f, 0.0f, 0.0f, -x - r);
+    set(2, 0.0f, 1.0f, 0.0f, -y - r);
+    set(3, 0.0f, -1.0f, 0.0f, y - r);
+    set(4, 0.0f, 0.0f, 1.0f, -z - h);
+    set(5, -kBevelOut, 0.0f, -kBevelDown, (x * a + z * b) + y * zero);
+    set(6, kBevelOut, 0.0f, -kBevelDown, (z * b - x * a) + y * zero);
+    set(7, 0.0f, kBevelOut, -kBevelDown, (x * zero + z * b) - y * a);
+    set(8, 0.0f, -kBevelOut, -kBevelDown, (x * zero + z * b) + y * a);
+
+    const float waist = static_cast<float>(z + r * kWaist);
+    const float top = static_cast<float>(z + h);
+    const float lowX = static_cast<float>(x - r), highX = static_cast<float>(x + r);
+    const float lowY = static_cast<float>(y - r), highY = static_cast<float>(y + r);
+    const float corners[4][2] = {{lowX, lowY}, {lowX, highY}, {highX, highY}, {highX, lowY}};
+    std::memcpy(v.v[0], p, sizeof v.v[0]);
+    for (int i = 0; i < 4; ++i) {
+        v.v[1 + i][0] = v.v[5 + i][0] = corners[i][0];
+        v.v[1 + i][1] = v.v[5 + i][1] = corners[i][1];
+        v.v[1 + i][2] = waist;
+        v.v[5 + i][2] = top;
+    }
+    return v;
+}
+
+// PlaneDistanceAlongRay: how far a plane moves along `dir` before it
+// reaches q; n·q + d undivided when it runs parallel.
+double DistanceAlongRay(const float (&q)[3], const Plane &pl, const float (&dir)[3]) {
+    using Fn = double(__fastcall *)(const float *, const Plane *, const float *);
+    return reinterpret_cast<Fn>(Offsets::FUN_PLANE_DISTANCE_ALONG_RAY)(q, &pl, dir);
+}
+
+// PolygonContactDistance (0x00632830): the travel until volume face k
+// reaches the polygon, 0 when it already touches; nothing when the polygon
+// lies wholly behind the face, past 1/36 of the volume's inside.
+bool ContactDistance(Polygon &poly, const float (&dir)[3], const Plane (&planes)[9], int k, float &best) {
+    float m = best;
+    bool behind = true;
+    for (uint32_t i = 0; i < poly.count; ++i) {
+        const double t = DistanceAlongRay(poly.v[i], planes[k], dir);
+        if (t < m)
+            m = t > 0.0 ? static_cast<float>(t) : 0.0f;
+        if (t > kAllBehind)
+            behind = false;
+    }
+    if (behind) {
+        if (!ClipByPlanesExcept(poly, planes, k))
+            return false;
+        for (uint32_t i = 0; i < poly.count; ++i)
+            if (DistanceAlongRay(poly.v[i], planes[k], dir) > kNegThirtySixth)
+                behind = false;
+        if (behind)
+            return false;
+    }
+    if (!(m >= best)) {
+        best = m;
+        return true;
+    }
+    return false;
+}
+
+// FindNearestFacet (0x00632700): of the facets facing against the move, the
+// one volume face k reaches first inside its swept prism.
+bool NearestFacet(const std::vector<Facet> &list, const float (&dir)[3], const Plane *prism, int prismCount,
+                  const Plane (&planes)[9], int k, float &best, uint32_t &hit) {
+    bool found = false;
+    for (uint32_t i = 0; i < list.size(); ++i) {
+        const Facet &f = list[i];
+        const double facing = (D(f.plane.n[2]) * dir[2] + D(f.plane.n[1]) * dir[1]) + D(f.plane.n[0]) * dir[0];
+        if (facing > kFacing)
+            continue;
+        Polygon poly;
+        std::memcpy(poly.v, f.v, sizeof f.v);
+        poly.tag[0] = poly.tag[1] = poly.tag[2] = -1;
+        poly.count = 3;
+        if (!ClipByPlanes(poly, prism, prismCount))
+            continue;
+        float t = kFltMax;
+        if (!ContactDistance(poly, dir, planes, k, t))
+            continue;
+        if (t <= best) {
+            best = t;
+            hit = i;
+            found = true;
+        }
+    }
+    return found;
+}
+
+// The band rule of 0x00632280 and 0x00632BA0: a face nearer by more than
+// 1/720 replaces the list, one within 1/720 joins it, and the nearest leads.
+void Band(const Plane &face, float t, Contact &out, float &best) {
+    if (D(best) - kSkin > t) {
+        out.faces[0] = face;
+        out.count = 1;
+    } else if (D(best) + kSkin > t && out.count < 9) {
+        out.faces[out.count++] = face;
+    }
+    if (t < best) {
+        best = t;
+        if (out.count > 1)
+            std::swap(out.faces[out.count - 1], out.faces[0]);
+    }
+}
+
+// A leading face: its normal along the sweep, or NaN.
+bool Leading(double dot) { return dot > 0.0 || std::isnan(dot); }
+
+// CMovement::FindBevelContacts (0x00632280): the four bevels.
+void Bevels(const std::vector<Facet> &list, const float (&dir)[3], float length, const float (&s)[3],
+            const Volume &volume, Contact &out, float &best) {
+    for (int b = 0; b < 4; ++b) {
+        const Plane &face = volume.planes[5 + b];
+        if (!Leading((D(face.n[2]) * s[2] + D(face.n[0]) * s[0]) + D(face.n[1]) * s[1]))
+            continue;
+        Plane prism[4];
+        if (!TrianglePrism(volume, kFaces + 20 + 3 * b, s, prism))
+            continue;
+        float t = length;
+        if (!NearestFacet(list, dir, prism, 3, volume.planes, 5 + b, t, out.hit))
+            continue;
+        Band(face, t, out, best);
+    }
+}
+
+bool InBox(const float (&box)[6], const float (&p)[3]) {
+    for (int i = 0; i < 3; ++i)
+        if (box[i] > p[i] || p[i] > box[i + 3])
+            return false;
+    return true;
+}
+
+// CMovement::GatherSweepFacets (0x00631E70): the facets around the volume
+// moved by s, unless the cached box already holds it; a swimmer's liquid too.
+// The box is the body's full height whichever list the sweep reads.
+bool Gather(Facets &facets, bool swimmer, const float (&p)[3], float radius, float height, const float (&s)[3]) {
+    float e[3];
+    for (int k = 0; k < 3; ++k)
+        e[k] = static_cast<float>(D(p[k]) + s[k]);
+    float low[3] = {static_cast<float>(D(e[0]) - radius), static_cast<float>(D(e[1]) - radius), e[2]};
+    float high[3] = {static_cast<float>(D(e[0]) + radius), static_cast<float>(D(e[1]) + radius),
+                     static_cast<float>(D(e[2]) + height)};
+    if (InBox(facets.box, low) && InBox(facets.box, high))
+        return true;
+    float query[6];
+    for (int k = 0; k < 3; ++k) {
+        const float grownLow = static_cast<float>(D(low[k]) - kGrowth);
+        const float grownHigh = static_cast<float>(D(high[k]) + kGrowth);
+        // UnionBoxes (0x006373B0): the cached box on ties and NaN.
+        query[k] = grownLow > facets.box[k] ? facets.box[k] : grownLow;
+        query[k + 3] = facets.box[k + 3] > grownHigh ? facets.box[k + 3] : grownHigh;
+    }
+    if (!facets.query(facets.context, query, facets.solid))
+        return false;
+    if (swimmer)
+        QueryLiquid(facets, query);
+    std::memcpy(facets.box, query, sizeof query);
+    return true;
+}
+
+} // namespace
+
+void QueryLiquid(Facets &facets, const float (&box)[6]) {
+    facets.liquidQuery(facets.context, box, facets.liquid);
+    for (Facet &f : facets.liquid) {
+        for (float &c : f.plane.n)
+            c = -c;
+        f.plane.d = -f.plane.d;
+    }
+}
+
+Facet MakeFacet(const float (&v0)[3], const float (&v1)[3], const float (&v2)[3]) {
+    // FlushTriangleBatchFacets (0x00671CC0), its SSE path: the client sets
+    // s_useSse from the CPU's SSE bit (CMap::Initialize, 0x006920A7), so
+    // every machine that runs it today scales by rsqrtss, a 12-bit estimate.
+    Facet f;
+    std::memcpy(f.v[0], v0, sizeof f.v[0]);
+    std::memcpy(f.v[1], v1, sizeof f.v[1]);
+    std::memcpy(f.v[2], v2, sizeof f.v[2]);
+    const double ax = D(v2[0]) - v0[0], ay = D(v2[1]) - v0[1], az = D(v2[2]) - v0[2];
+    const float bx = static_cast<float>(D(v1[0]) - v0[0]);
+    const float by = static_cast<float>(D(v1[1]) - v0[1]);
+    const double bz = D(v1[2]) - v0[2];
+    const float nx = static_cast<float>(D(by) * az - bz * ay);
+    const float ny = static_cast<float>(bz * ax - az * bx);
+    const float nz = static_cast<float>(ay * bx - D(by) * ax);
+    const float length2 = static_cast<float>((D(nx) * nx + D(ny) * ny) + D(nz) * nz);
+    const float k = _mm_cvtss_f32(_mm_rsqrt_ss(_mm_set_ss(length2)));
+    const double x = D(k) * nx, y = D(k) * ny, z = D(k) * nz;
+    f.plane.n[0] = static_cast<float>(x);
+    f.plane.n[1] = static_cast<float>(y);
+    f.plane.n[2] = static_cast<float>(z);
+    f.plane.d = static_cast<float>(-((z * v0[2] + y * v0[1]) + x * v0[0]));
+    return f;
+}
+
+bool PointOverFacet(const Facet &facet, const float (&p)[3]) {
+    // 0x0063364A: the facet's prism along (0, 0, 1), its planes starting
+    // as (0, 0, 1, 0); 0x00633671 sums (x, z, y) and fails above 1/12.
+    const float up[3] = {0.0f, 0.0f, 1.0f};
+    Plane planes[3] = {{{0.0f, 0.0f, 1.0f}, 0.0f}, {{0.0f, 0.0f, 1.0f}, 0.0f}, {{0.0f, 0.0f, 1.0f}, 0.0f}};
+    for (int i = 0; i < 3; ++i)
+        if (!EdgePlane(facet.v[i], facet.v[(i + 1) % 3], facet.v[(i + 2) % 3], up, false, planes[i]))
+            break;
+    for (const Plane &pl : planes)
+        if (((D(pl.n[0]) * p[0] + D(pl.n[2]) * p[2]) + D(pl.n[1]) * p[1]) + pl.d > kTwelfth)
+            return false;
+    return true;
+}
+
+void BaseBox(const float (&p)[3], float radius, float height, float (&box)[6]) {
+    box[0] = static_cast<float>(D(p[0]) - radius);
+    box[1] = static_cast<float>(D(p[1]) - radius);
+    box[2] = p[2];
+    box[3] = static_cast<float>(D(p[0]) + radius);
+    box[4] = static_cast<float>(D(p[1]) + radius);
+    box[5] = static_cast<float>(D(p[2]) + height);
+}
+
+bool Sweep(Facets &facets, bool liquid, bool swimmer, const float (&p)[3], float radius, float height,
+           const float (&dir)[3], float length, Contact &out) {
+    const std::vector<Facet> &list = liquid ? facets.liquid : facets.solid;
+    out.count = 0;
+    if (std::fabs(length) < kDegenerate) {
+        out.distance = 0.0f;
+        out.hit = static_cast<uint32_t>(list.size());
+        return true;
+    }
+    // A swimmer meets the liquid with the lower three quarters of its body
+    // (0x00632C64), so it rests with its head above the surface.
+    const float volumeHeight = swimmer && liquid ? static_cast<float>(D(height) * kThreeQuarters) : height;
+    // At least 1/36 of sweep, but every distance is capped at the length.
+    const float d = length > kThirtySixth ? length : kThirtySixth;
+    const float s[3] = {static_cast<float>(D(d) * dir[0]), static_cast<float>(D(d) * dir[1]),
+                        static_cast<float>(D(d) * dir[2])};
+    const Volume volume = BuildVolume(p, radius, volumeHeight);
+    if (!Gather(facets, swimmer, p, radius, height, s)) {
+        out.distance = 0.0f;
+        return false;
+    }
+    out.hit = static_cast<uint32_t>(list.size());
+    float best = length;
+    Bevels(list, dir, length, s, volume, out, best);
+    for (int a = 0; a < 5; ++a) {
+        const Plane &face = volume.planes[a];
+        if (!Leading((D(s[2]) * face.n[2] + D(s[1]) * face.n[1]) + D(s[0]) * face.n[0]))
+            continue;
+        Plane prism[4];
+        if (!QuadPrism(volume, kFaces + 4 * a, s, prism))
+            continue;
+        float t = length;
+        if (!NearestFacet(list, dir, prism, 4, volume.planes, a, t, out.hit))
+            continue;
+        Band(face, t, out, best);
+    }
+    out.distance = best < kSkin ? 0.0f : best;
+    return true;
+}
+
+} // namespace Model::Scene::Contact
@@ -0,0 +1,99 @@
+// This file is part of ClassicAPI.
+//
+// ClassicAPI is free software: you can redistribute it and/or modify it under the terms
+// of the GNU General Public License as published by the Free Software Foundation, either
+// version 3 of the License, or (at your option) any later version.
+//
+// ClassicAPI is distributed in the hope that it will be useful, but WITHOUT ANY
+// WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
+// PURPOSE. See the GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License along with
+// ClassicAPI. If not, see <https://www.gnu.org/licenses/>.
+
+#pragma once
+
+// The client mover's contact geometry, transcribed for the scene's own
+// bodies: the volume a unit occupies, the facets of the world around a move,
+// and the first contact of the moving volume with them (0x00631440 through
+// 0x00632F80). Each function is one client function, with its arithmetic in
+// the client's order and precision (53-bit sums, float stores), so a body
+// meets a face where the client's mover would. The client's pure geometry
+// helpers (the polygon clips, the plane builder, the ray distance) are called,
+// not copied; the functions that read the client's mover state (CMovement,
+// the lists at 0x00C4E52C) are transcribed over the body's own, which come in
+// through Facets::query.
+
+#include <cstdint>
+#include <vector>
+
+namespace Model::Scene::Contact {
+
+// A plane: a point q is inside when n·q + d <= 0.
+struct Plane {
+    float n[3];
+    float d;
+};
+
+// A world facet, the 52-byte record of the facet emitter (0x00671CC0): its
+// plane, then its three vertices.
+struct Facet {
+    Plane plane;
+    float v[3][3];
+};
+static_assert(sizeof(Facet) == 0x34, "the client's facet record");
+
+// The facet the emitter writes for three vertices: normal (v1 - v0) × (v2 -
+// v0) normalized, d = -n·v0.
+Facet MakeFacet(const float (&v0)[3], const float (&v1)[3], const float (&v2)[3]);
+
+// IsPointOverListedTriangle (0x006335D0): whether p lies at most 1/12
+// outside each edge of the facet, the edges extruded straight up, so above
+// or below the facet in plan.
+bool PointOverFacet(const Facet &facet, const float (&p)[3]);
+
+// The facet lists a sweep reads and the box they cover: the solid list
+// (0x00C4E52C), the liquid list a swimmer adds (0x00C4E564), and their cached
+// box (0x00C4E5A0, min then max). `query` is the world query (0x006721B0)
+// with the mover's class: it empties `solid` and fills it with the facets in
+// a box, false when the query fails. `liquidQuery` is the same query with
+// the swimmer's class 0x30000, water and ocean surfaces, into `liquid`.
+struct Facets {
+    std::vector<Facet> solid;
+    std::vector<Facet> liquid;
+    float box[6];
+    bool (*query)(void *context, const float (&box)[6], std::vector<Facet> &out);
+    bool (*liquidQuery)(void *context, const float (&box)[6], std::vector<Facet> &out);
+    void *context;
+};
+
+// The swimmer's liquid query (0x00633E90, 0x006320E0): `liquidQuery` over the
+// box, its return not read, then every liquid plane reversed (0x00637330
+// and FCHS), so a surface faces down and meets a rising swimmer as a ceiling.
+void QueryLiquid(Facets &facets, const float (&box)[6]);
+
+// The volume's base box, as the substep's query frame (0x00633840) starts
+// it: (p.x - r, p.y - r, p.z) to (p.x + r, p.y + r, p.z + H).
+void BaseBox(const float (&p)[3], float radius, float height, float (&box)[6]);
+
+// What a sweep met: the travel to the first contact, the facet found (an
+// index into the list swept, its size when none), and the leading faces of
+// the volume that touch within 1/720 of it.
+struct Contact {
+    float distance;
+    uint32_t hit;
+    uint32_t count;
+    Plane faces[9];
+};
+
+// CMovement::SweepVolume (0x00632BA0): the volume of a body (a box of
+// half-width `radius` up to `height`, over a square pyramid whose apex is
+// `p`) swept along the unit vector `dir` for `length`, against the solid
+// list or with `liquid` the liquid list. A `swimmer` (flag 0x200000) gathers
+// the liquid list too, and its volume against that list is three quarters of
+// `height` tall. The hover's branch is not taken: the scene's bodies do not
+// hover. False when the facet query fails.
+bool Sweep(Facets &facets, bool liquid, bool swimmer, const float (&p)[3], float radius, float height,
+           const float (&dir)[3], float length, Contact &out);
+
+} // namespace Model::Scene::Contact
@@ -0,0 +1,147 @@
+// This file is part of ClassicAPI.
+//
+// ClassicAPI is free software: you can redistribute it and/or modify it under the terms
+// of the GNU General Public License as published by the Free Software Foundation, either
+// version 3 of the License, or (at your option) any later version.
+//
+// ClassicAPI is distributed in the hope that it will be useful, but WITHOUT ANY
+// WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
+// PURPOSE. See the GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License along with
+// ClassicAPI. If not, see <https://www.gnu.org/licenses/>.
+
+#pragma once
+
+#include "model/Camera.h"
+
+#include <cstdint>
+
+// The UiModelScene rows behind C_ModelInfo. Retail keeps them in four DB2s
+// that 1.12 has no counterpart for; only the scenes a ClassicAPI UI shows are
+// embedded: 4 (the default mount scene), 44 (the Qiraji battle tanks) and 596
+// (the dressing room). Grow the list scene by scene, never the whole tables.
+// Column meanings are retail's (docs/notes/model-scene.md § Data):
+//   - an actor's flags are Enum.UIModelSceneActorFlag (2/4/8 use the centre
+//     of the model for the X/Y/Z origin, 1 is deprecated);
+//   - a camera's type 0 is "OrbitCamera", the only type any row uses, and its
+//     flags are Enum.ModelSceneSetting;
+//   - a scene's system type is what GetModelSceneInfoByID returns as
+//     modelSceneType.
+namespace Model::SceneData {
+
+using Model::Camera::Vec3;
+
+struct SceneRow {
+    uint32_t id;
+    uint32_t uiSystemType;
+    uint32_t flags;
+};
+
+struct CameraRow {
+    uint32_t id;
+    uint32_t sceneID;
+    const char *scriptTag;
+    Vec3 target;
+    float yaw, pitch, roll;
+    float zoomDistance, minZoomDistance, maxZoomDistance;
+    Vec3 zoomedTargetOffset;
+    float zoomedYawOffset, zoomedPitchOffset, zoomedRollOffset;
+    uint32_t flags;
+};
+
+struct ActorRow {
+    uint32_t id;
+    uint32_t sceneID;
+    const char *scriptTag;
+    Vec3 position;
+    float yaw, pitch, roll;
+    float normalizedScale;
+    uint32_t flags;
+    uint32_t displayID; // a kActorDisplays row, 0 for none
+};
+
+struct ActorDisplayRow {
+    uint32_t id;
+    uint32_t animation;
+    uint32_t animationVariation;
+    float animSpeed;
+    uint32_t animKitID;       // 0 for none
+    uint32_t spellVisualKitID; // 0 for none
+    float alpha;
+    float scale;
+};
+
+// Generated from the retail 12.1.7.70740 UiModelScene, UiModelSceneCamera,
+// UiModelSceneActor and UiModelSceneActorDisplay exports (wago.tools CSV),
+// keeping only the scenes ClassicAPI uses: 4, 44, 596.
+
+// clang-format off
+const SceneRow kScenes[] = {
+    {4, 0, 0},
+    {44, 0, 0},
+    {596, 12, 0},
+};
+
+const CameraRow kCameras[] = {
+    {1, 4, "primary", {0.0f, 0.0f, 2.20000004768f}, 2.61999988556f, 0.0f, 0.0f, 14.0f, 8.0f, 18.0f, {0.0f, 0.0f, -1.5f}, 0.17453292012f, 0.0f, 0.0f, 0},
+    {48, 44, "primary", {0.0f, 0.0f, 2.20000004768f}, 2.61799383163f, 0.0f, 0.0f, 14.0f, 8.0f, 18.0f, {0.0f, 0.0f, -1.5f}, 0.17453292012f, 0.0f, 0.0f, 1},
+    {582, 596, "primary", {0.0f, 0.0f, 1.01999998093f}, 1.83000004292f, 0.0f, 0.0f, 3.90000009537f, 2.0f, 3.90000009537f, {0.0f, 0.0f, 0.0f}, 0.0f, 0.0f, 0.0f, 1},
+};
+
+const ActorRow kActors[] = {
+    {1, 4, "unwrapped", {0.0f, 0.0f, 0.0f}, 0.0f, 0.0f, 0.0f, 0.25f, 8, 6},
+    {2, 4, "wrapped", {0.0f, 0.0f, -0.5f}, 0.0f, 0.0f, 0.0f, 0.0f, 0, 1},
+    {60, 44, "unwrapped", {0.0f, 0.0f, 0.0f}, 0.0f, 0.0f, 0.0f, 0.40000000596f, 9, 6},
+    {61, 44, "wrapped", {0.0f, 0.0f, -0.5f}, 0.0f, 0.0f, 0.0f, 0.0f, 0, 1},
+    {400, 4, "player-rider", {0.0f, 0.0f, 0.0f}, 0.0f, 0.0f, 0.0f, 0.0f, 0, 170},
+    {408, 44, "player-rider", {0.0f, 0.0f, 0.0f}, 0.0f, 0.0f, 0.0f, 0.0f, 0, 170},
+    {1620, 596, "player", {0.0f, 0.0f, 0.0f}, -0.95999997854f, 0.0f, 0.0f, 1.0f, 2, 170},
+    {1621, 596, "tauren-male", {0.0f, 0.0f, 0.10000000149f}, -0.95999997854f, 0.0f, 0.0f, 0.28999999166f, 2, 170},
+    {1622, 596, "gnome", {0.0f, 0.0f, 0.02999999933f}, -0.95999997854f, 0.0f, 0.0f, 2.04999995232f, 2, 170},
+    {1623, 596, "dwarf-male", {0.0f, 0.0f, 0.03999999911f}, -0.95999997854f, 0.0f, 0.0f, 4.80000019073f, 2, 174},
+    {1624, 596, "scourge-male", {0.0f, 0.0f, 0.0f}, -0.95999997854f, 0.0f, 0.0f, 19.0f, 2, 174},
+    {1625, 596, "pandaren", {0.0f, 0.0f, 0.0700000003f}, -0.95999997854f, 0.0f, 0.0f, 0.37000000477f, 2, 170},
+    {1626, 596, "worgen-male", {0.0f, 0.0f, -0.03999999911f}, -0.95999997854f, 0.0f, 0.0f, 0.20000000298f, 2, 170},
+    {1627, 596, "draenei-male", {0.0f, 0.0f, 0.1400000006f}, -0.95999997854f, 0.0f, 0.0f, 0.49000000954f, 0, 170},
+    {1628, 596, "goblin-male", {0.0f, 0.0f, 0.01999999955f}, -0.95999997854f, 0.0f, 0.0f, 6.30000019073f, 2, 170},
+    {1629, 596, "goblin-female", {0.0f, 0.0f, 0.03999999911f}, -0.95999997854f, 0.0f, 0.0f, 4.0f, 2, 170},
+    {1630, 596, "orc", {0.0f, 0.0f, 0.05999999866f}, -0.95999997854f, 0.0f, 0.0f, 0.33000001311f, 2, 170},
+    {1631, 596, "tauren-female", {0.0f, 0.0f, 0.10000000149f}, -0.95999997854f, 0.0f, 0.0f, 0.41999998689f, 2, 170},
+    {1632, 596, "troll-male", {0.0f, 0.0f, -0.05999999866f}, -0.95999997854f, 0.0f, 0.0f, 0.07999999821f, 2, 170},
+    {1633, 596, "troll-female", {0.0f, 0.0f, 0.0f}, -0.95999997854f, 0.0f, 0.0f, 0.64999997616f, 2, 170},
+    {1634, 596, "scourge-female", {0.0f, 0.0f, -0.00999999978f}, -0.95999997854f, 0.0f, 0.0f, 3.29999995232f, 2, 170},
+    {1635, 596, "lightforgeddraenei-male", {0.0f, 0.0f, 0.12999999523f}, -0.95999997854f, 0.0f, 0.0f, 0.49000000954f, 0, 170},
+    {1636, 596, "lightforgeddraenei-female", {0.0f, 0.0f, 0.03999999911f}, -0.95999997854f, 0.0f, 0.0f, 0.80000001192f, 2, 170},
+    {1637, 596, "highmountaintauren-male", {0.0f, 0.0f, 0.10000000149f}, -0.95999997854f, 0.0f, 0.0f, 0.28999999166f, 2, 170},
+    {1638, 596, "highmountaintauren-female", {0.0f, 0.0f, 0.10000000149f}, -0.95999997854f, 0.0f, 0.0f, 0.41999998689f, 2, 170},
+    {1639, 596, "zandalaritroll", {0.0f, 0.0f, 0.05000000075f}, -0.95999997854f, 0.0f, 0.0f, 0.86000001431f, 2, 170},
+    {1640, 596, "kultiran-male", {0.0f, 0.0f, 0.01999999955f}, -0.95999997854f, 0.0f, 0.0f, 0.49000000954f, 2, 170},
+    {1641, 596, "magharorc-male", {0.0f, 0.0f, 0.1099999994f}, -0.95999997854f, 0.0f, 0.0f, 0.33000001311f, 2, 170},
+    {1642, 596, "kultiran-female", {0.0f, 0.0f, 0.0f}, -0.95999997854f, 0.0f, 0.0f, 1.12000000477f, 2, 170},
+    {1643, 596, "magharorc-female", {0.0f, 0.0f, 0.05000000075f}, -0.95999997854f, 0.0f, 0.0f, 0.18000000715f, 2, 170},
+    {1644, 596, "darkirondwarf-male", {0.0f, 0.0f, 0.0700000003f}, -0.95999997854f, 0.0f, 0.0f, 4.94999980927f, 2, 174},
+    {1645, 596, "worgen-female", {0.0f, 0.0f, 0.0f}, -0.95999997854f, 0.0f, 0.0f, 1.20000004768f, 2, 170},
+    {1646, 596, "draenei-female", {0.0f, 0.0f, 0.05000000075f}, -0.95999997854f, 0.0f, 0.0f, 1.00999999046f, 2, 170},
+    {1647, 596, "vulpera-female", {-0.12999999523f, 0.20000000298f, 0.03999999911f}, -0.95999997854f, 0.0f, 0.0f, 8.0f, 2, 174},
+    {1648, 596, "vulpera-male", {-0.12999999523f, 0.20000000298f, 0.03999999911f}, -0.95999997854f, 0.0f, 0.0f, 5.0f, 2, 174},
+    {1649, 596, "mechagnome-male", {0.0f, 0.0f, 0.07999999821f}, -0.95999997854f, 0.0f, 0.0f, 1.39999997616f, 2, 170},
+    {1650, 596, "mechagnome-female", {0.0f, 0.0f, 0.07999999821f}, -0.95999997854f, 0.0f, 0.0f, 1.20000004768f, 2, 170},
+    {1651, 596, "druid-bear-form", {0.10000000149f, 0.0f, 0.25f}, -0.95999997854f, 0.0f, 0.0f, 0.44999998808f, 0, 170},
+    {1652, 596, "druid-cat-form", {1.0f, 0.0f, 0.5f}, -0.95999997854f, 0.0f, 0.0f, 0.28999999166f, 0, 170},
+    {1653, 596, "dracthyr", {-0.5f, 0.80000001192f, -0.10000000149f}, -0.95999997854f, 0.0f, 0.0f, 0.12999999523f, 2, 170},
+    {1654, 596, "dracthyr-alt", {0.0f, 0.0f, 0.0f}, -0.95999997854f, 0.0f, 0.0f, 1.0f, 2, 170},
+    {2152, 596, "earthendwarf-male", {0.0f, 0.0f, 0.03999999911f}, -0.95999997854f, 0.0f, 0.0f, 2.70000004768f, 2, 174},
+    {3606, 596, "harronir", {0.0f, 0.0f, 0.0f}, -1.08210408688f, 0.0f, 0.0f, 1.0f, 0, 0},
+    {3619, 596, "harronir-female", {0.0f, 0.0f, 0.0f}, -1.08210408688f, 0.0f, 0.0f, 1.29999995232f, 0, 0},
+};
+
+const ActorDisplayRow kActorDisplays[] = {
+    {1, 0, 0, 1.0f, 0, 0, 1.0f, 4.0f},
+    {6, 0, 0, 1.0f, 0, 0, 1.0f, 3.5f},
+    {170, 0, 0, 1.0f, 0, 0, 1.0f, 1.0f},
+    {174, 0, 0, 1.0f, 0, 0, 1.0f, 2.0f},
+};
+// clang-format on
+
+} // namespace Model::SceneData
@@ -0,0 +1,273 @@
+// This file is part of ClassicAPI.
+//
+// ClassicAPI is free software: you can redistribute it and/or modify it under the terms
+// of the GNU General Public License as published by the Free Software Foundation, either
+// version 3 of the License, or (at your option) any later version.
+//
+// ClassicAPI is distributed in the hope that it will be useful, but WITHOUT ANY
+// WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
+// PURPOSE. See the GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License along with
+// ClassicAPI. If not, see <https://www.gnu.org/licenses/>.
+
+// An actor model's animation events. Each actor model gets the engine's event
+// callback, as a unit's model does (CGUnit_C::SetModelCallbacks, 0x00607800),
+// and the events reach this file the way a unit's reach its dispatcher
+// (CGUnit_C::OnModelEvent, 0x005FFBD0, keyed by the four-character tag):
+//
+// - $CSL / $CSR / $CST release a PlaySpellVisual missile (model/SceneSpell.cpp),
+//   always; so does $BWR, from the bow or rifle point, after the weapon's
+//   release animation. $BWP draws the bow and nocks the ammo while a ranged
+//   spell is cast.
+// - With SetPlayAnimationSounds (a ClassicAPI extension, off by default so
+//   the stock scenes stay as quiet as before), the sounds a unit plays from
+//   its own data, here from the CreatureSoundData of the display the actor
+//   shows (GetSoundData 0x0060AFB0: the display's row, else its model
+//   data's):
+//     $FD1..$FD4  the fidget sounds, +0x38 (0x006232C0; $FD5..$FD9 play none)
+//     $FDX        the stand vocal, +0x20: 41 in 101, at most once in 10 s
+//                 for all units, never for the active player (0x006236B0,
+//                 0x00623490)
+//     $FSD        the footstep: +0x24 by the ground's terrain through the
+//                 engine's GetFootstepSound, with FootstepSounds on
+//                 (0x00623390); the ground is the scene's SetGroundTerrain,
+//                 else the terrain type of the WMO face under the actor
+//     $DTH        the death thud by the size class and the ground, from the
+//                 engine's own table (0x006236E0)
+//     $WNG, $WGG  the wing flap +0x2C and glide +0x30 (vocal kinds 7 and 10,
+//                 which have no chance or rate limit)
+//     $CSD        the event's payload as a SoundEntries id, with EmoteSounds
+//                 on (0x00623C10)
+//     $TRD        the precast sound (visual +0x38) of the spell being
+//                 prepared (0x0062FAA0)
+//   The world plays these at the unit's position in 3D; a frame plays them
+//   at the actor, heard from the scene camera. An actor with neither ground
+//   has no footsteps and no death thud, as nothing tells it what it stands on.
+//
+// Not played: the combat tags $CSS, $CAH and $AH0..$AH3 present a pending
+// swing (0x006247D0) and play nothing without one, and an actor never swings
+// at anything; footprints, splashes and camera shakes are world effects.
+
+#include "model/Scene.h"
+
+#include "Game.h"
+#include "Offsets.h"
+#include "cvar/Factory.h"
+#include "dbc/Lookup.h"
+#include "model/M2.h"
+#include "sound/Play.h"
+#include "time/Clock.h"
+#include "unit/Identity.h"
+
+#include <cmath>
+#include <cstdint>
+#include <cstdlib>
+
+namespace Model::Scene::Events {
+
+namespace {
+
+// The tags, as the engine compares them: four characters in a dword.
+constexpr uint32_t Tag(char a, char b, char c, char d) {
+    return static_cast<uint32_t>(static_cast<uint8_t>(a)) |
+           static_cast<uint32_t>(static_cast<uint8_t>(b)) << 8 |
+           static_cast<uint32_t>(static_cast<uint8_t>(c)) << 16 |
+           static_cast<uint32_t>(static_cast<uint8_t>(d)) << 24;
+}
+constexpr uint32_t kCSL = Tag('$', 'C', 'S', 'L');
+constexpr uint32_t kCSR = Tag('$', 'C', 'S', 'R');
+constexpr uint32_t kCST = Tag('$', 'C', 'S', 'T');
+constexpr uint32_t kBWR = Tag('$', 'B', 'W', 'R');
+constexpr uint32_t kBWP = Tag('$', 'B', 'W', 'P');
+constexpr uint32_t kFD1 = Tag('$', 'F', 'D', '1');
+constexpr uint32_t kFD4 = Tag('$', 'F', 'D', '4');
+constexpr uint32_t kFDX = Tag('$', 'F', 'D', 'X');
+constexpr uint32_t kFSD = Tag('$', 'F', 'S', 'D');
+constexpr uint32_t kDTH = Tag('$', 'D', 'T', 'H');
+constexpr uint32_t kWNG = Tag('$', 'W', 'N', 'G');
+constexpr uint32_t kWGG = Tag('$', 'W', 'G', 'G');
+constexpr uint32_t kCSD = Tag('$', 'C', 'S', 'D');
+constexpr uint32_t kTRD = Tag('$', 'T', 'R', 'D');
+static_assert(kCSR == 0x52534324 && kWNG == 0x474E5724, "tags compare as the engine's dwords");
+
+constexpr int kStandChance = 40;            // 0x008626D4[5]: pass at <= 40 of 0..100
+constexpr uint32_t kStandIntervalMs = 10000; // 0x00623290
+uint32_t g_lastStandMs = 0;
+bool g_standPlayed = false;
+
+// The display's sound data row, else its model data's.
+const uint8_t *SoundData(uint32_t displayID) {
+    const uint8_t *display = DBC::Record(Offsets::VAR_CREATUREDISPLAYINFO_RECORDS,
+                                         Offsets::VAR_CREATUREDISPLAYINFO_COUNT, displayID);
+    if (display == nullptr)
+        return nullptr;
+    auto row = [](uint32_t id) {
+        return DBC::Record(Offsets::VAR_CREATURESOUNDDATA_RECORDS,
+                           Offsets::VAR_CREATURESOUNDDATA_COUNT, id);
+    };
+    if (const uint8_t *own = row(Game::Read<uint32_t>(display, Offsets::OFF_CREATUREDISPLAYINFO_SOUND_ID)))
+        return own;
+    const uint8_t *modelData =
+        DBC::Record(Offsets::VAR_CREATUREMODELDATA_RECORDS, Offsets::VAR_CREATUREMODELDATA_COUNT,
+                    Game::Read<uint32_t>(display, Offsets::OFF_CREATUREDISPLAYINFO_MODEL_ID));
+    return modelData != nullptr
+               ? row(Game::Read<uint32_t>(modelData, Offsets::OFF_CREATUREMODELDATA_SOUND_ID))
+               : nullptr;
+}
+
+// GetUnitSoundSize: the display's size class unless -1, else its model
+// data's; -1 when neither is known.
+int SizeClass(uint32_t displayID) {
+    const uint8_t *display = DBC::Record(Offsets::VAR_CREATUREDISPLAYINFO_RECORDS,
+                                         Offsets::VAR_CREATUREDISPLAYINFO_COUNT, displayID);
+    if (display == nullptr)
+        return -1;
+    const auto size = Game::Read<int32_t>(display, Offsets::OFF_CREATUREDISPLAYINFO_SIZE_CLASS);
+    if (size != -1)
+        return size;
+    const uint8_t *modelData =
+        DBC::Record(Offsets::VAR_CREATUREMODELDATA_RECORDS, Offsets::VAR_CREATUREMODELDATA_COUNT,
+                    Game::Read<uint32_t>(display, Offsets::OFF_CREATUREDISPLAYINFO_MODEL_ID));
+    return modelData != nullptr
+               ? Game::Read<int32_t>(modelData, Offsets::OFF_CREATUREMODELDATA_SIZE_CLASS)
+               : -1;
+}
+
+bool CVarOn(const char *name) { return CVar::Factory::GetInt(CVar::Factory::Find(name), 0) != 0; }
+
+// A unit's animation sounds play at the unit (heard from the scene camera).
+void Play(const Actor &actor, int32_t soundID) {
+    if (soundID > 0)
+        Sounds::Play(actor.SceneFrame(), soundID, actor.position);
+}
+
+void PlayStand(const Actor &actor, const uint8_t *soundData) {
+    if (actor.unitGuid != 0 && actor.unitGuid == Unit::Identity::PlayerGuid())
+        return;
+    if (std::rand() % 101 > kStandChance)
+        return;
+    const uint32_t now = Time::Clock::NowMs();
+    if (g_standPlayed && Time::Clock::Elapsed(g_lastStandMs, now) < kStandIntervalMs)
+        return;
+    g_standPlayed = true;
+    g_lastStandMs = now;
+    Play(actor, Game::Read<int32_t>(soundData, Offsets::OFF_CREATURESOUNDDATA_STAND));
+}
+
+// The ground the actor stands on: the scene's SetGroundTerrain, else the
+// terrain type of the WMO face under it (the unit's +0xC60).
+int Ground(const Actor &actor) {
+    void *frame = actor.SceneFrame();
+    const int set = GroundTerrain(frame);
+    return set >= 0 ? set : World::Ground(WorldOf(frame), *actor.ambience);
+}
+
+void PlayFootstep(const Actor &actor, const uint8_t *soundData) {
+    using GetFootstepSound_t = int(__fastcall *)(int footstepID, int terrainTypeID, int wet);
+    const int terrain = Ground(actor);
+    if (terrain < 0 || !CVarOn("FootstepSounds"))
+        return;
+    Play(actor, reinterpret_cast<GetFootstepSound_t>(Offsets::FUN_GET_FOOTSTEP_SOUND)(
+        Game::Read<int32_t>(soundData, Offsets::OFF_CREATURESOUNDDATA_FOOTSTEP), terrain, 0));
+}
+
+// PlayDeathThud's dry thud: the engine's table by size class and the
+// terrain's TerrainTypeSounds id, bounded as it bounds it.
+void PlayDeathThud(const Actor &actor) {
+    const int terrain = Ground(actor);
+    const int size = SizeClass(actor.displayID);
+    if (terrain < 0 || size < 0 || size >= Offsets::DEATH_THUD_SIZE_CLASSES)
+        return;
+    const uint8_t *terrainRow = DBC::Record(Offsets::VAR_TERRAINTYPE_RECORDS,
+                                            Offsets::VAR_TERRAINTYPE_COUNT,
+                                            static_cast<uint32_t>(terrain));
+    if (terrainRow == nullptr)
+        return;
+    const auto soundIndex = Game::Read<int32_t>(terrainRow, Offsets::OFF_TERRAINTYPE_SOUND_ID);
+    const uintptr_t table = static_cast<uintptr_t>(Offsets::VAR_DEATH_THUD_SOUNDS) +
+                            static_cast<uintptr_t>(size) * Offsets::DEATH_THUD_STRIDE;
+    if (soundIndex < 0 || soundIndex >= Game::Read<int32_t>(table + Offsets::OFF_DEATH_THUD_COUNT))
+        return;
+    const auto *pairs = Game::Read<const int32_t *>(table + Offsets::OFF_DEATH_THUD_PAIRS);
+    Play(actor, pairs[soundIndex * 2]);
+}
+
+void PlayPrecast(const Actor &actor) {
+    for (const SpellCast &cast : actor.spellCasts)
+        if (cast.phase == SpellCast::Phase::Precast) {
+            Play(actor, Game::Read<int32_t>(cast.visual, Offsets::OFF_SPELLVISUAL_PRECAST_SOUND));
+            return;
+        }
+}
+
+void PlaySound(Actor &actor, uint32_t tag, uint32_t data) {
+    if (tag == kCSD) {
+        if (CVarOn("EmoteSounds"))
+            Play(actor, static_cast<int32_t>(data));
+        return;
+    }
+    if (tag == kTRD) {
+        PlayPrecast(actor);
+        return;
+    }
+    if (tag == kDTH) {
+        PlayDeathThud(actor);
+        return;
+    }
+    const uint8_t *soundData = SoundData(actor.displayID);
+    if (soundData == nullptr)
+        return;
+    if (tag >= kFD1 && tag <= kFD4 && (tag & 0x00FFFFFF) == (kFD1 & 0x00FFFFFF))
+        Play(actor, Game::Read<int32_t>(soundData,
+                                 Offsets::OFF_CREATURESOUNDDATA_FIDGET + ((tag >> 24) - '1') * 4));
+    else if (tag == kFDX)
+        PlayStand(actor, soundData);
+    else if (tag == kFSD)
+        PlayFootstep(actor, soundData);
+    else if (tag == kWNG)
+        Play(actor, Game::Read<int32_t>(soundData, Offsets::OFF_CREATURESOUNDDATA_WING_FLAP));
+    else if (tag == kWGG)
+        Play(actor, Game::Read<int32_t>(soundData, Offsets::OFF_CREATURESOUNDDATA_WING_GLIDE));
+}
+
+// $BWR's point (0x00600159): a bow animation releases from the body's
+// attachment 35, a rifle animation from 36, any other from the event's point.
+void BowReleasePoint(const Actor &actor, float (&point)[3]) {
+    const int anim = actor.CurrentAnimation();
+    uint32_t attachment = 0;
+    if (M2::IsBowAnimation(anim))
+        attachment = Offsets::ATTACH_BOW_RELEASE;
+    else if (M2::IsRifleAnimation(anim))
+        attachment = Offsets::ATTACH_RIFLE_RELEASE;
+    if (attachment != 0 && actor.model != nullptr && M2::HasAttachment(actor.model, attachment))
+        M2::GetAttachmentPosition(actor.model, attachment, point);
+}
+
+} // namespace
+
+void __stdcall OnModelEvent(uint32_t tag, uint32_t data, const float *point, uint32_t /*unknown*/,
+                            uint32_t userLow, uint32_t /*userHigh*/) {
+    auto *actor = reinterpret_cast<Actor *>(static_cast<uintptr_t>(userLow));
+    if (tag == kCSL || tag == kCSR || tag == kCST || tag == kBWR) {
+        // The unit's callback drops a point that is not a number (0x00607840).
+        if (point == nullptr || std::isnan(point[0]) || std::isnan(point[1]) || std::isnan(point[2]))
+            return;
+        actor->releaseEvent = true;
+        for (int i = 0; i < 3; ++i)
+            actor->releasePoint[i] = point[i];
+        if (tag == kBWR) {
+            BowReleasePoint(*actor, actor->releasePoint);
+            Casts::BowRelease(*actor);
+        }
+        return;
+    }
+    if (tag == kBWP) {
+        Casts::BowPull(*actor);
+        return;
+    }
+    if (actor->playAnimationSounds)
+        PlaySound(*actor, tag, data);
+}
+
+} // namespace Model::Scene::Events
@@ -0,0 +1,288 @@
+// This file is part of ClassicAPI.
+//
+// ClassicAPI is free software: you can redistribute it and/or modify it under the terms
+// of the GNU General Public License as published by the Free Software Foundation, either
+// version 3 of the License, or (at your option) any later version.
+//
+// ClassicAPI is distributed in the hope that it will be useful, but WITHOUT ANY
+// WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
+// PURPOSE. See the GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License along with
+// ClassicAPI. If not, see <https://www.gnu.org/licenses/>.
+
+// An actor with the mover on (SetMovementEnabled) animates as the client's
+// unit does from its own mover. The unit's chain lives on CGUnit_C, which an
+// actor is not, so this is that chain on the actor, step for step:
+//
+//   1. The pick (SelectBaseAnimation 0x005FD8B0 with mask -1): the resolvers
+//      a scene body can claim, in their order, and the airborne hold
+//      between the first two and the rest.
+//   2. The play (CGUnit_C::PlayAnimation 0x005FE2F0, PlayTrack 0x005FDBA0):
+//      a move animation's rate and phase; nothing when the body already
+//      plays the animation.
+//   3. When it picks again: a movement command the mover took
+//      (ProcessLocalMoveEvent 0x0060E0A0 -> AnimateMoveOpcode 0x0060E480);
+//      a substep that arrives at a spline's end, lands, starts a fall or
+//      ends a swim (BroadcastStateChange 0x0061A820 -> OnLand 0x00602D00,
+//      UpdateLandingAnimation 0x00602C60, PlayFallAnimation 0x00602C40); a
+//      body that catches up turning on the spot (the tail of CGUnit_C::Update
+//      0x00607ED0); and a sequence that ends (OnAnimationDone 0x005FC920 ->
+//      PlayFollowOnAnimation 0x005FC3F0).
+//
+// What the unit has and an actor does not: the death, special stand, loot,
+// cast, ready, ranged, stand state and emote resolvers (an actor has no unit
+// state; its script plays those), stealth and flying. An actor whose own
+// animation is a death animation is dead, as Actor::PlayAnimation treats
+// it: the chain leaves it to its script. A spell kit's animation (Casts) stays on top: a pick sets
+// the actor's own animation under it, which the kit gives back when it ends.
+
+#include "model/Scene.h"
+
+#include "Game.h"
+#include "Offsets.h"
+#include "model/M2.h"
+#include "model/SceneMover.h"
+
+#include <cmath>
+#include <cstdint>
+
+namespace Model::Scene::Locomotion {
+
+namespace {
+
+constexpr uint32_t kNone = 208;               // AnimationData's row count: no animation
+const Game::Live<float> kSprintSpeed{Offsets::VAR_MOVER_SPRINT_SPEED};
+const Game::Live<float> kTurnEpsilon{Offsets::VAR_MOVER_FACING_EPSILON};
+const Game::Live<float> kTurnEpsilonNegative{Offsets::VAR_MOVER_MINUS_FACING_EPSILON};
+
+// The chain runs for an actor with the mover and a loaded model that is not
+// dead.
+bool Active(const Actor &actor) {
+    return actor.mover != nullptr && actor.model != nullptr && actor.loaded &&
+           !M2::IsDeathAnimation(static_cast<int>(actor.animation));
+}
+
+// A fall the pick holds through (0x005FD8EE to 0x005FD919): falling far, or
+// a fall with a start speed that is not exactly 0 or NaN.
+bool Airborne(const Mover::Body &b) {
+    if ((b.flags & Mover::FLAG_FALLING) && (b.flags & Mover::FLAG_FALLING_FAR))
+        return true;
+    return (b.flags & Mover::FLAG_FALLING) && (b.fallSpeed < 0.0f || b.fallSpeed > 0.0f);
+}
+
+// ResolveMoveAnimation (0x005FD100) for a body with a direction bit.
+uint32_t MoveAnimation(const Mover::Body &b) {
+    const uint32_t f = b.flags;
+    if (f & Mover::FLAG_SWIMMING) {
+        if ((f & 0x3C) == 0)
+            return (f & Mover::FLAG_BACKWARD) ? Offsets::ANIM_SWIM_BACKWARDS : Offsets::ANIM_SWIM;
+        if (f & 0x30)
+            return Offsets::ANIM_SWIM_IDLE;
+        return (f & Mover::FLAG_STRAFE_LEFT) ? Offsets::ANIM_SWIM_LEFT : Offsets::ANIM_SWIM_RIGHT;
+    }
+    if (f & Mover::FLAG_BACKWARD)
+        return Offsets::ANIM_WALK_BACKWARDS;
+    const float speed = Mover::CurrentSpeed(b);
+    if (kSprintSpeed <= speed)
+        return Offsets::ANIM_SPRINT;
+    if (b.walkSpeed + b.walkSpeed < speed)
+        return Offsets::ANIM_RUN;
+    return Offsets::ANIM_WALK;
+}
+
+// CanShuffle (0x005FCE30): turning, or the body catching up, and not in a
+// swim or an emote, cast or ranged animation, or JumpEnd.
+bool CanShuffle(const Actor &actor, bool jumpEndLock) {
+    const Mover::Body &b = *actor.mover;
+    if (!(b.flags & 0x30) && actor.facings.shuffle == 0)
+        return false;
+    if (b.flags & 0x40200800)
+        return false;
+    const int anim = actor.CurrentAnimation();
+    if (M2::IsEmoteAnimation(anim) || M2::IsSpellCastAnimation(anim) || M2::IsThrownAnimation(anim) ||
+        M2::IsBowAnimation(anim) || M2::IsRifleAnimation(anim))
+        return false;
+    return !jumpEndLock;
+}
+
+// SelectBaseAnimation (0x005FD8B0), mask -1. JumpEnd's lock (+0xD58 bit
+// 0x4) holds while it plays, and its follow-on clears it before it picks.
+uint32_t Select(const Actor &actor, bool jumpEndLock) {
+    const Mover::Body &b = *actor.mover;
+    if (Airborne(b))
+        return kNone;
+    if (b.flags & 0xF)
+        return MoveAnimation(b);
+    if (CanShuffle(actor, jumpEndLock))
+        return (!(b.flags & Mover::FLAG_TURN_LEFT) && actor.facings.shuffle <= 0) ? Offsets::ANIM_SHUFFLE_RIGHT
+                                                                                 : Offsets::ANIM_SHUFFLE_LEFT;
+    if (jumpEndLock)
+        return kNone; // ResolveIdleAnimation (0x005FD830) writes nothing
+    return (b.flags & Mover::FLAG_SWIMMING) ? Offsets::ANIM_SWIM_IDLE : Offsets::ANIM_STAND;
+}
+
+bool JumpEndLock(const Actor &actor) { return actor.animation == Offsets::ANIM_JUMP_END; }
+
+// CGUnit_C::PlayAnimation (0x005FE2F0) of `anim` on the body's track, as a
+// body with no mount, swing, weapon or effect plays it: a move animation at
+// the mover's speed over the sequence's (0x005FE50A to 0x005FE54D), starting
+// at the phase of the move animation it replaces, and nothing when the track
+// already plays it (PlayTrack 0x005FDBA0), unless that sequence just ended.
+void Play(Actor &actor, uint32_t anim, bool ended) {
+    if (!ended && actor.animation == anim)
+        return;
+    float rate = 1.0f;
+    uint32_t offsetMs = 0;
+    const M2::SequenceInfo info = M2::GetSequenceInfo(actor.model, anim, 0);
+    if (0.0f < info.speed && M2::IsMoveAnimation(static_cast<int>(anim))) {
+        rate = Mover::CurrentSpeed(*actor.mover) / info.speed;
+        if (info.length != 0) {
+            const M2::AnimState state = M2::GetAnimState(actor.model, -1);
+            const M2::SequenceInfo was = M2::GetSequenceInfo(actor.model, state.id, state.variation);
+            // 32-bit, as the client's imul and two divs (0x005FE606): the
+            // product wraps.
+            if (0.0f < was.speed && was.length != 0)
+                offsetMs = state.position * info.length / was.length % info.length;
+        }
+    }
+    actor.animation = anim;
+    actor.variation = -1;
+    actor.animSpeed = rate;
+    actor.animOffsetSec = static_cast<float>(offsetMs) / 1000.0f;
+    if (actor.kitAnimation < 0)
+        actor.PlayAnimation();
+}
+
+// UpdateBaseAnimation (0x005FD9E0), mask -1.
+void Pick(Actor &actor, bool jumpEndLock, bool ended) {
+    const uint32_t anim = Select(actor, jumpEndLock);
+    if (anim != kNone)
+        Play(actor, anim, ended);
+}
+
+} // namespace
+
+void Repick(Actor &actor) {
+    if (Active(actor))
+        Pick(actor, JumpEndLock(actor), false);
+}
+
+void OnMove(Actor &actor, Move move) {
+    if (!Active(actor))
+        return;
+    switch (move) {
+    case Move::StartForward:
+    case Move::StartBackward:
+    case Move::StartStrafeLeft:
+    case Move::StartStrafeRight:
+    case Move::StartSwim:
+        Casts::EndRangedPose(actor);
+        Pick(actor, JumpEndLock(actor), false);
+        return;
+    case Move::Jump:
+        Play(actor, Offsets::ANIM_JUMP_START, false);
+        return;
+    case Move::RunMode:
+    case Move::WalkMode:
+        if (actor.mover->flags & 0xF)
+            Pick(actor, JumpEndLock(actor), false);
+        return;
+    case Move::Stop:
+    case Move::StopStrafe:
+    case Move::StartTurnLeft:
+    case Move::StartTurnRight:
+    case Move::StopTurn:
+    case Move::TeleportAck:
+    case Move::StopSwim:
+        Pick(actor, JumpEndLock(actor), false);
+        return;
+    }
+}
+
+void OnStep(void *context, uint32_t oldFlags, bool jumped, bool arrived) {
+    Actor &actor = *static_cast<Actor *>(context);
+    // The arrival's MSG_MOVE_STOP, after the spline's done report.
+    if (arrived) {
+        actor.movesFinished += 1;
+        OnMove(actor, Move::Stop);
+    }
+    if (!Active(actor))
+        return;
+    const uint32_t flags = actor.mover->flags;
+    // A landing (OnLand 0x00602D00 -> UpdateLandingAnimation 0x00602C60):
+    // after a jump or a far fall, JumpEnd standing, JumpLandRun ahead or
+    // aside; else, and in the water or backing up, a pick, which a soft
+    // landing makes only when the direction changed in the air.
+    if (!(flags & Mover::FLAG_FALLING) && (oldFlags & Mover::FLAG_FALLING)) {
+        if (!jumped && !(oldFlags & Mover::FLAG_FALLING_FAR)) {
+            if ((flags ^ oldFlags) & 0xF)
+                Pick(actor, JumpEndLock(actor), false);
+        } else if (!(flags & Mover::FLAG_SWIMMING) && (flags & 0xF) == 0) {
+            Play(actor, Offsets::ANIM_JUMP_END, false);
+        } else if (!(flags & Mover::FLAG_SWIMMING) && !(flags & (Mover::FLAG_BACKWARD | 0x100))) {
+            Play(actor, Offsets::ANIM_JUMP_LAND_RUN, false);
+        } else {
+            Pick(actor, JumpEndLock(actor), false);
+        }
+    }
+    // A fall begins, or turns far (PlayFallAnimation 0x00602C40).
+    if (((flags & Mover::FLAG_FALLING) && !(oldFlags & Mover::FLAG_FALLING)) ||
+        ((flags & Mover::FLAG_FALLING_FAR) && !(oldFlags & Mover::FLAG_FALLING_FAR))) {
+        if (flags & Mover::FLAG_FALLING_FAR)
+            Play(actor, Offsets::ANIM_FALL, false);
+    }
+    // A swim ends: MSG_MOVE_STOP_SWIM, not sent along a spline.
+    if (!(flags & Mover::FLAG_SWIMMING) && (oldFlags & Mover::FLAG_SWIMMING) && !Mover::OnSpline(*actor.mover))
+        OnMove(actor, Move::StopSwim);
+}
+
+void OnBodyTurn(Actor &actor, float turn) {
+    Actor::Facings &f = actor.facings;
+    f.shuffle = 0;
+    if (!Active(actor))
+        return;
+    const uint32_t flags = actor.mover->flags;
+    if ((flags & 0xF) || (flags & Mover::FLAG_FALLING) || (flags & Mover::FLAG_SWIMMING))
+        return;
+    if (kTurnEpsilon < turn)
+        f.shuffle = 1;
+    else if (turn < kTurnEpsilonNegative)
+        f.shuffle = -1;
+    const int current = actor.CurrentAnimation();
+    int want;
+    if ((flags & Mover::FLAG_TURN_LEFT) || f.shuffle > 0)
+        want = Offsets::ANIM_SHUFFLE_LEFT;
+    else if ((flags & Mover::FLAG_TURN_RIGHT) || f.shuffle < 0)
+        want = Offsets::ANIM_SHUFFLE_RIGHT;
+    else if (current == Offsets::ANIM_SHUFFLE_LEFT || current == Offsets::ANIM_SHUFFLE_RIGHT)
+        want = Offsets::ANIM_STAND;
+    else
+        return;
+    if (current != want && CanShuffle(actor, JumpEndLock(actor)))
+        Pick(actor, JumpEndLock(actor), false);
+}
+
+bool FollowOn(Actor &actor) {
+    if (!Active(actor))
+        return false;
+    switch (actor.animation) {
+    case Offsets::ANIM_JUMP_START:
+    case Offsets::ANIM_JUMP:
+        Play(actor, Offsets::ANIM_JUMP, true);
+        return true;
+    case Offsets::ANIM_FALL:
+        Play(actor, Offsets::ANIM_FALL, true);
+        return true;
+    default: {
+        // The rest pick again; JumpEnd's own follow-on clears its lock
+        // first, so no pick here sees it. A pick that holds (the body in the
+        // air) leaves the ended sequence to repeat, as the model repeats it.
+        const uint32_t anim = Select(actor, false);
+        Play(actor, anim == kNone ? actor.animation : anim, true);
+        return true;
+    }
+    }
+}
+
+} // namespace Model::Scene::Locomotion
@@ -0,0 +1,172 @@
+// This file is part of ClassicAPI.
+//
+// ClassicAPI is free software: you can redistribute it and/or modify it under the terms
+// of the GNU General Public License as published by the Free Software Foundation, either
+// version 3 of the License, or (at your option) any later version.
+//
+// ClassicAPI is distributed in the hope that it will be useful, but WITHOUT ANY
+// WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
+// PURPOSE. See the GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License along with
+// ClassicAPI. If not, see <https://www.gnu.org/licenses/>.
+
+#pragma once
+
+// The client's mover, transcribed for a scene actor: CMovement's fields and
+// the functions that move a unit on the ground, through the air and in the
+// water, from the movement commands down to the contact sweep
+// (SceneContact.h). Each function is one client function, in its order and
+// precision. A Body is the scene's own; the client's movers, their manager
+// and its lists are never touched.
+//
+// A body is the client's active mover (the unit the player controls), so a
+// spline it finishes is reported and freed (CompleteSpline 0x00619DE0).
+//
+// Left out, as the scene has none of them: transports, flying splines
+// (spline flag 0x200), the event queue and every packet, hover (0x40000000),
+// water walking, fixed height (0x800) and the swim pitch setter
+// (0x007C6F70), which the client drives from the camera.
+
+#include "model/SceneContact.h"
+
+#include <array>
+#include <cstdint>
+#include <optional>
+#include <vector>
+
+namespace Model::Scene::Mover {
+
+// The spline record (0x00630C40, 0x70 bytes at CMovement +0xA4), the
+// fields a ground move uses, and its Catmull-Rom curve (+0x2C, vtable
+// 0x007FFD84) in mode 0: straight chords between the control points.
+struct Spline {
+    float facingAngle;              // +0x14, the facing at the end (flag 0x40000)
+    uint32_t flags;                 // +0x18
+    uint32_t start;                 // +0x1C, the tick it started at
+    int32_t elapsed;                // +0x20, ms
+    uint32_t duration;              // +0x24, ms
+    float length;                   // +0x30, the curve's total length (curve +0x04)
+    std::vector<std::array<float, 3>> points; // +0x3C, the curve's control points (curve +0x10)
+    std::vector<float> segments;    // +0x4C, the curve's segment lengths (curve +0x20)
+    float end[3];                   // +0x58, the last point
+};
+
+// CMovement, the fields a scene body uses (offsets from 0x00616FA0).
+struct Body {
+    float position[3];     // +0x10
+    float facing;          // +0x1C
+    float pitch;           // +0x20
+    uint32_t flags;        // +0x40
+    float anchor[3];       // +0x44, the position at the anchors
+    float anchorFacing;    // +0x50
+    float anchorPitch;     // +0x54
+    uint32_t elapsed;      // +0x58, ms since the anchors
+    float direction[3];    // +0x5C
+    float heading[2];      // +0x68
+    float pitchBasis[2];   // +0x70, cos and sin of the anchor pitch
+    uint32_t fallTime;     // +0x78, ms into the fall
+    float fallStartZ;      // +0x7C
+    float stepFloor;       // +0x80, the z a step began at
+    float speed;           // +0x84
+    float walkSpeed;       // +0x88
+    float runSpeed;        // +0x8C
+    float runBackSpeed;    // +0x90
+    float swimSpeed;       // +0x94
+    float swimBackSpeed;   // +0x98
+    float turnRate;        // +0x9C
+    float fallSpeed;       // +0xA0, down positive
+    std::optional<Spline> spline; // +0xA4, null when absent
+    float radius;          // +0xB0
+    float height;          // +0xB4
+    float stepRatio;       // +0xB8
+    uint32_t clock;        // the movement manager's +0x128: the tick moved to
+    Contact::Facets facets; // the world query's list (0x00C4E52C)
+    // The unit's side of each substep (BroadcastStateChange 0x0061A820,
+    // from the substep loop at 0x00634260): `oldFlags` the flags before the
+    // substep, `jumped` whether its fall had a start speed, `arrived` whether
+    // the body reached its spline's end and stopped (MSG_MOVE_STOP, after the
+    // spline's done report). Null for none.
+    void (*stepped)(void *context, uint32_t oldFlags, bool jumped, bool arrived) = nullptr;
+    void *steppedContext = nullptr;
+};
+
+// The client's flag bits (+0x40) a scene body takes.
+enum : uint32_t {
+    FLAG_FORWARD = 0x1,
+    FLAG_BACKWARD = 0x2,
+    FLAG_STRAFE_LEFT = 0x4,
+    FLAG_STRAFE_RIGHT = 0x8,
+    FLAG_TURN_LEFT = 0x10,
+    FLAG_TURN_RIGHT = 0x20,
+    FLAG_WALK = 0x100,
+    FLAG_PITCH_UP = 0x40,
+    FLAG_PITCH_DOWN = 0x80,
+    FLAG_FALLING = 0x2000,
+    FLAG_FALLING_FAR = 0x4000,
+    FLAG_SWIMMING = 0x200000,
+    FLAG_ON_STEP = 0x4000000,
+};
+
+// The constructor (0x00616FA0, 0x007C4850) at `p` facing `facing`, at the
+// tick `now`, with the speeds a server's create block gives a character.
+void Init(Body &body, const float (&p)[3], float facing, uint32_t now);
+// CMovement::SetCollisionSize (0x006174B0): a model's collision width and
+// height at `scale`, `displayScale` the display's CreatureModelScale.
+void SetCollisionSize(Body &body, float width, float height, float scale, float displayScale);
+// The movement manager's tick (0x00616800, 0x00616620) up to `now`. True
+// when time passed, where the client then runs the unit's step
+// (CGUnit_C::OnMoverStepped 0x005FAC70): the swim decision below.
+bool Tick(Body &body, uint32_t now);
+// The position reset (0x007C69A0): put down at `p` facing `facing`, at rest.
+void Reset(Body &body, const float (&p)[3], float facing);
+// SetFacing (0x007C6F30).
+void SetFacing(Body &body, float facing);
+// The fall gate (0x007C61C0): starts a fall from rest unless already in
+// the air, swimming or rooted.
+bool FallGate(Body &body);
+
+// The movement commands. Each takes effect at the body's tick: Tick first.
+bool StartMove(Body &body, bool forward);    // 0x007C6AE0
+bool StopMove(Body &body);                   // 0x007C6BA0
+bool StartStrafe(Body &body, bool left);     // 0x007C6C50
+bool StopStrafe(Body &body);                 // 0x007C6D30
+void StartTurn(Body &body, bool left);       // 0x007C6D90
+bool StopTurn(Body &body);                   // 0x007C6DD0
+void StartPitch(Body &body, bool up);        // 0x007C6DF0, only while swimming
+bool StopPitch(Body &body);                  // 0x007C6E30
+bool Jump(Body &body);                       // 0x007C6230 with check 1
+void SetRunMode(Body &body, bool run);       // 0x007C71C0
+// ClearSpline (0x007C6310): what the client does first with a move event
+// that is not the player's own (UpdatePlayerMovement 0x00615C30).
+void ClearSpline(Body &body);
+
+// A server's move of the body to `to` along the ground, as the client reads
+// and starts it (CGUnit_C::OnMonsterMove 0x006018F0, mover side): a path
+// from where the body stands, at its own speed (swim, walk or run), ending
+// at `facing` when given. True when the body set off; false when it stopped
+// where it stands, which the client reports as the spline done at once.
+bool MoveTo(Body &body, const float (&to)[3], const float *facing);
+// Whether the body follows a spline (+0xA4 set, its flag 0x4 clear).
+bool OnSpline(const Body &body);
+
+// The unit's swim decision (CGUnit_C::UpdateSwimState 0x006030C0) for a
+// player-controlled unit, after a tick: `depth` is the liquid's surface less
+// the feet's z, 0 out of liquid. A body starts swimming deeper than three
+// quarters of its height, unless it is still rising from a jump, and stops
+// out of the liquid or 1/36 yard shallower than that.
+void UpdateSwimState(Body &body, bool inLiquid, float depth);
+
+// GetCurrentFallSpeed (0x007C5D70): the vertical speed now, down positive.
+float FallSpeed(const Body &body);
+// GetCurrentSpeed (0x007C4C90, walk 0): the speed the flags pick, 0 with no
+// direction.
+float CurrentSpeed(const Body &body);
+
+// The pitch the client poses a unit's model with (the unit's pose 0x00608560,
+// 0x0060A110): a swimmer moving forward or back is turned by 2π less its
+// pitch about its own y axis (the euler builder 0x007BF4B0; nose up for a
+// rising swimmer), any other body not at all.
+float ModelPitch(const Body &body);
+
+} // namespace Model::Scene::Mover
@@ -0,0 +1,38 @@
+// This file is part of ClassicAPI.
+//
+// ClassicAPI is free software: you can redistribute it and/or modify it under the terms
+// of the GNU General Public License as published by the Free Software Foundation, either
+// version 3 of the License, or (at your option) any later version.
+//
+// ClassicAPI is distributed in the hope that it will be useful, but WITHOUT ANY
+// WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
+// PURPOSE. See the GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License along with
+// ClassicAPI. If not, see <https://www.gnu.org/licenses/>.
+
+#pragma once
+
+// The two helpers the transcribed client mover (SceneContact.cpp,
+// SceneMover.cpp) writes its arithmetic with. The client runs it on the x87
+// at 53 bits and stores floats, so a sum is taken in doubles (D) and each
+// store is a float cast. A constant the client reads from memory is a
+// Game::Live over its Offsets.h address; Bits is for the few that are code
+// immediates or have no address.
+
+#include <cstdint>
+#include <cstring>
+
+namespace Model::Scene::Precision {
+
+// The float with these bits.
+inline float Bits(uint32_t bits) {
+    float f;
+    std::memcpy(&f, &bits, sizeof f);
+    return f;
+}
+
+// A float widened to the 53-bit sum the x87 keeps.
+inline double D(float x) { return x; }
+
+} // namespace Model::Scene::Precision
@@ -0,0 +1,152 @@
+// This file is part of ClassicAPI.
+//
+// ClassicAPI is free software: you can redistribute it and/or modify it under the terms
+// of the GNU General Public License as published by the Free Software Foundation, either
+// version 3 of the License, or (at your option) any later version.
+//
+// ClassicAPI is distributed in the hope that it will be useful, but WITHOUT ANY
+// WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
+// PURPOSE. See the GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License along with
+// ClassicAPI. If not, see <https://www.gnu.org/licenses/>.
+
+// The scene's sounds, heard from the scene camera, or from the scene's
+// listener actor as the world hears from the player's unit (Ear). The engine has one
+// listener, which the world camera places; a scene is a second camera that
+// the sound engine knows nothing of. So a scene point is played at the spot
+// that lies from the listener as the point lies from the scene camera: its
+// offset along the camera's forward, up and side becomes the same offset
+// along the listener's. The engine then applies the row's cutoff, minimum
+// distance, falloff and panning exactly as it does for a unit that far away.
+//
+// The listener is read back from FMOD (FSOUND_3D_Listener_GetAttributes), in
+// the engine's axes (FMOD's (-y, z, x), Sound::SetListener 0x007A5EB0). A
+// point is mapped when it plays; a loop is mapped again each time it moves.
+
+#include "model/Scene.h"
+
+#include "Offsets.h"
+#include "cvar/Factory.h"
+#include "model/M2.h"
+#include "sound/Play.h"
+
+#include <cmath>
+#include <cstring>
+
+namespace Model::Scene::Sounds {
+
+namespace {
+
+// Three orthonormal axes at a point: the scene camera's, or the listener's.
+struct Frame3 {
+    float origin[3];
+    float axes[3][3]; // forward, up, side
+};
+
+void Normalize(float (&v)[3]) {
+    const float n = std::sqrt(v[0] * v[0] + v[1] * v[1] + v[2] * v[2]);
+    if (n > 0.0f)
+        for (float &c : v)
+            c /= n;
+}
+
+void Cross(const float (&a)[3], const float (&b)[3], float (&out)[3]) {
+    out[0] = a[1] * b[2] - a[2] * b[1];
+    out[1] = a[2] * b[0] - a[0] * b[2];
+    out[2] = a[0] * b[1] - a[1] * b[0];
+}
+
+float Dot(const float (&a)[3], const float (&b)[3]) { return a[0] * b[0] + a[1] * b[1] + a[2] * b[2]; }
+
+// Forward, up and side from a forward and an up that need not be square.
+Frame3 MakeFrame(const float (&origin)[3], const float (&forward)[3], const float (&up)[3]) {
+    Frame3 f{};
+    std::memcpy(f.origin, origin, sizeof f.origin);
+    std::memcpy(f.axes[0], forward, sizeof f.axes[0]);
+    Normalize(f.axes[0]);
+    Cross(f.axes[0], up, f.axes[2]);
+    Normalize(f.axes[2]);
+    Cross(f.axes[2], f.axes[0], f.axes[1]);
+    return f;
+}
+
+Frame3 ListenerFrame() {
+    using Get_t = void(__stdcall *)(float *pos, float *vel, float *fx, float *fy, float *fz, float *tx, float *ty,
+                                    float *tz);
+    float pos[3], vel[3], fwd[3], top[3];
+    reinterpret_cast<Get_t>(Offsets::FUN_FSOUND_LISTENER_GET_ATTRIBUTES)(pos, vel, &fwd[0], &fwd[1], &fwd[2],
+                                                                         &top[0], &top[1], &top[2]);
+    const auto engine = [](const float (&v)[3], float (&out)[3]) {
+        out[0] = v[2];
+        out[1] = -v[0];
+        out[2] = v[1];
+    };
+    float p[3], f[3], u[3];
+    engine(pos, p);
+    engine(fwd, f);
+    engine(top, u);
+    return MakeFrame(p, f, u);
+}
+
+// Where the scene hears from. The world's listener (0x00482EA0) stands at the
+// unit the player drives while SoundListenerAtCharacter is on: its position
+// raised by its scale times its box height (+0x90 * +0xBC, the model box's
+// max z less min z), facing the unit's facing with z 0, up (0, 0, 1). The
+// scene's listener actor stands in for that unit; without one, or with the
+// variable off, the camera hears, as the world's camera branch does.
+Frame3 Ear(void *sceneFrame) {
+    const Actor *actor = SoundListener(sceneFrame);
+    if (actor != nullptr &&
+        CVar::Factory::GetInt(CVar::Factory::Find("SoundListenerAtCharacter"), 0) != 0) {
+        float height = 0.0f;
+        if (actor->model != nullptr && M2::IsLoaded(actor->model, 0, 0)) {
+            float box[6];
+            M2::GetBoundingBox(actor->model, box);
+            height = (box[5] - box[2]) * actor->scale;
+        }
+        const float origin[3] = {actor->position[0], actor->position[1], actor->position[2] + height};
+        const float forward[3] = {std::cos(actor->yaw), std::sin(actor->yaw), 0.0f};
+        const float up[3] = {0.0f, 0.0f, 1.0f};
+        return MakeFrame(origin, forward, up);
+    }
+    const View view = CameraView(sceneFrame);
+    return MakeFrame(view.eye, view.forward, view.up);
+}
+
+} // namespace
+
+void Heard(void *sceneFrame, const float (&point)[3], float (&out)[3]) {
+    const Frame3 ear = Ear(sceneFrame);
+    const Frame3 listener = ListenerFrame();
+    const float offset[3] = {point[0] - ear.origin[0], point[1] - ear.origin[1], point[2] - ear.origin[2]};
+    for (int i = 0; i < 3; ++i)
+        out[i] = listener.origin[i];
+    for (int axis = 0; axis < 3; ++axis) {
+        const float along = Dot(offset, ear.axes[axis]);
+        for (int i = 0; i < 3; ++i)
+            out[i] += along * listener.axes[axis][i];
+    }
+}
+
+void *Play(void *sceneFrame, int soundKitID, const float (&point)[3]) {
+    float heard[3];
+    Heard(sceneFrame, point, heard);
+    return Sound::Play::PlayKitIDAt(soundKitID, heard);
+}
+
+void *Loop(void *sceneFrame, int soundKitID, const float (&point)[3]) {
+    float heard[3];
+    Heard(sceneFrame, point, heard);
+    return Sound::Play::PlayKitLoopedAt(soundKitID, heard);
+}
+
+void Move(void *sceneFrame, void *sound, const float (&point)[3]) {
+    if (sound == nullptr)
+        return;
+    float heard[3];
+    Heard(sceneFrame, point, heard);
+    Sound::Play::Move(sound, heard);
+}
+
+} // namespace Model::Scene::Sounds
@@ -0,0 +1,875 @@
+// This file is part of ClassicAPI.
+//
+// ClassicAPI is free software: you can redistribute it and/or modify it under the terms
+// of the GNU General Public License as published by the Free Software Foundation, either
+// version 3 of the License, or (at your option) any later version.
+//
+// ClassicAPI is distributed in the hope that it will be useful, but WITHOUT ANY
+// WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
+// PURPOSE. See the GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License along with
+// ClassicAPI. If not, see <https://www.gnu.org/licenses/>.
+
+// `actor:PlaySpellVisual(spellID, target [, castTimeMs])`, a ClassicAPI
+// extension: a spell's visual played between two actors the way the world
+// plays it between two units. The world's chain lives on units, missile
+// objects and world objects, none of which an actor has, so this is that
+// chain on actor models, step for step:
+//
+//   1. Precast (SPELL_START, 0x006EC220): the visual's +0x04 kit on the
+//      caster, its effects and its animation looping, its sound once, for the
+//      cast time (the engine's own FUN_GET_CAST_TIME unless one is given).
+//   2. Cast (SPELL_GO, benilla spell/go): the precast's effects and tint
+//      drop; the +0x08 kit plays once. A visual with a missile (+0x18, a
+//      speed above 0, a target that is not the caster) makes the missile
+//      model (+0x1C's SpellVisualEffectName file, else Spells\ErrorCube.mdx,
+//      as the launcher 0x0060A3D0), held until its release. Without one the
+//      impact plays at once (0x006E8BF0).
+//   3. Release (CGUnit_C::ReleaseMissiles, 0x0060C940): at the caster
+//      model's $CSL / $CSR / $CST event, from the event's point (the unit's
+//      event callback, 0x005FFBD0). Without the event it is
+//      ReleaseMissilesFromHand (0x0060C9B0): the first of those events the
+//      model has, at its current point, else the caster's position. The
+//      world calls that when the cast kit has no animation (0x006E8293),
+//      when the cast animation ends (0x005FC920) and 2000 ms after the queue
+//      (0x0060A814). A missile whose model has not loaded waits.
+//   4. Flight (CMissile::Launch 0x0061CEB0, 0x0061E2A0): the speed is fitted
+//      so the flight ends when the server would have it end, `t = d/speed -
+//      queued`, `speed = min(d/t, 100)` (100 for t <= 0); the model plays
+//      144 InFlight (0 Stand for t = 0) and loops, faces its travel, and
+//      re-aims each frame at the target's attachment: the visual's +0x24
+//      through s_spellVisualAttachments, else 15, else 19, else the target's
+//      position raised by 0.75 of its height (0x0061CF13, 0x0061D230). Its
+//      flight sound (+0x28) loops until arrival, then fades over 0.15 s (the
+//      missile's free, 0x0061CD70). It arrives when a frame's step passes
+//      the remaining distance (0x0061E3E8).
+//   5. Arrival (0x0061DC50): the target plays its wound animation, then the
+//      +0x0C impact kit once. A +0x30 impact model stays at the arrival
+//      point until it holds no live particle (the impact list, 0x0061E930).
+//
+// What the world does and this does not: the leading of a moving target
+// (actors move by script, not by a mover's velocity), misses, resists and
+// reflections (no combat), and arrows stuck in the target. The sounds play
+// where they would for units, heard from the scene camera (model/SceneSound.cpp):
+// the kits' at the actor, the missile's loop moving with the missile.
+//
+// A paused caster (SetPaused) holds its casts and missiles where they are.
+
+#include "model/Scene.h"
+
+#include "Game.h"
+#include "Offsets.h"
+#include "dbc/Lookup.h"
+#include "gx/Matrix.h"
+#include "model/DisplayInfo.h"
+#include "model/M2.h"
+#include "model/VisualKit.h"
+#include "sound/Play.h"
+
+#include <cmath>
+#include <cstdint>
+#include <cstring>
+#include <memory>
+#include <utility>
+#include <vector>
+
+namespace Model::Scene {
+
+EntityLight::EntityLight(void *frame) : frame(frame), ambience(World::NewAmbience()) {}
+
+EntityLight::~EntityLight() { World::FreeAmbience(ambience); }
+
+} // namespace Model::Scene
+
+namespace Model::Scene::Casts {
+
+namespace {
+
+// The model's lighting callback, `__fastcall(instance, record, user)`.
+void __fastcall OnEntityLighting(void * /*instance*/, void *record, EntityLight *light) {
+    World::ActorLight(WorldOf(light->frame), *light->ambience, light->frame, record);
+}
+
+void LightAsEntity(void *model, std::unique_ptr<EntityLight> &light, void *frame) {
+    light = std::make_unique<EntityLight>(frame);
+    M2::SetRenderCallback(model, reinterpret_cast<const void *>(&OnEntityLighting), light.get());
+}
+
+// The model drops its callback to the frame's before the light goes.
+void ReleaseLit(void *model, std::unique_ptr<EntityLight> &light) {
+    if (light != nullptr)
+        M2::SetRenderCallback(model, reinterpret_cast<const void *>(Offsets::FUN_SIMPLEMODELFFX_LIGHT_FOG_CB),
+                              light->frame);
+    light.reset();
+    M2::SetVisible(model, false);
+    M2::Release(model);
+}
+
+// The node's re-placement when it moved and its light's ease, each tick.
+void SettleLight(void *model, EntityLight *light, float elapsed) {
+    if (model == nullptr || light == nullptr || !M2::IsLoaded(model, 0, 0))
+        return;
+    if (World::Backdrop *world = WorldOf(light->frame))
+        World::Settle(*world, *light->ambience, light->frame, model, elapsed);
+}
+
+} // namespace
+
+namespace {
+
+// The release events, '$CSL', '$CSR', '$CST'.
+constexpr uint32_t kReleaseEvents[] = {0x4C534324, 0x52534324, 0x54534324};
+constexpr int kAnimStand = 0;
+constexpr int kAnimCombatWound = 9;
+constexpr int kAnimInFlight = 144;
+constexpr float kReleaseTimeoutSec = 2.0f; // 0x0060A814
+constexpr float kMaxSpeed = 100.0f;        // 0x0080C854
+constexpr float kSoundFadeSec = 0.15f;     // the missile's free, 0x0061CD70
+const Game::Live<float> kAimHeight{Offsets::VAR_THREE_QUARTERS};
+constexpr uint32_t kFallbackAttachments[] = {15, 19};
+constexpr char kErrorCube[] = "Spells\\ErrorCube.mdx";
+
+const uint8_t *Kit(const uint8_t *visual, uintptr_t column) {
+    return Model::VisualKit::Record(Game::Read<uint32_t>(visual, column));
+}
+
+int KitAnimation(const uint8_t *kit) {
+    return kit != nullptr ? Game::Read<int32_t>(kit, Offsets::OFF_SPELLVISUALKIT_ANIMATION) : -1;
+}
+
+const char *EffectFile(uint32_t effectID) {
+    const uint8_t *effect = DBC::Record(Offsets::VAR_SPELLVISUALEFFECTNAME_RECORDS,
+                                        Offsets::VAR_SPELLVISUALEFFECTNAME_COUNT, effectID);
+    const char *file =
+        effect != nullptr ? Game::Read<const char *>(effect, Offsets::OFF_SPELLVISUALEFFECTNAME_FILE)
+                          : nullptr;
+    return file != nullptr && *file != '\0' ? file : nullptr;
+}
+
+// A model and every parent loaded: what the position reads need, since they
+// wait for files and animate the parents first.
+bool ChainLoaded(void *model) {
+    if (model == nullptr)
+        return false;
+    for (void *m = model; m != nullptr; m = M2::Parent(m))
+        if (!M2::IsLoaded(m, 0, 0))
+            return false;
+    return true;
+}
+
+// The world's kit player on a unit, for a model: the effects (looping into
+// `effects`, or once and owned by the model), the animation and the sound.
+void PlayKit(Actor &actor, const uint8_t *kit, bool loops, std::vector<void *> *effects) {
+    if (kit == nullptr || actor.model == nullptr)
+        return;
+    Model::VisualKit::Apply(actor.SceneFrame(), actor.model, kit, !loops, effects);
+    const int anim = KitAnimation(kit);
+    if (anim >= 0)
+        actor.PlayKitAnimation(anim, loops);
+    Sounds::Play(actor.SceneFrame(), Game::Read<int32_t>(kit, Offsets::OFF_SPELLVISUALKIT_SOUND), actor.position);
+}
+
+bool HasTintProcedure(const uint8_t *kit) {
+    constexpr int32_t kTint = 1, kAlpha = 14;
+    for (int i = 0; i < 4; ++i) {
+        const auto kind = Game::Read<int32_t>(kit, Offsets::OFF_SPELLVISUALKIT_PROC_KIND + i * 4);
+        if (kind == kTint || kind == kAlpha)
+            return true;
+    }
+    return false;
+}
+
+bool IsRanged(const uint8_t *spell) {
+    return (Game::Read<uint32_t>(spell, Offsets::OFF_SPELL_RECORD_ATTRIBUTES) & Offsets::SPELL_ATTR_RANGED) != 0;
+}
+
+// UnitGetSpellVisual (0x0060D450) for the actor: the spell's visual, and for
+// a ranged spell the empty fields filled from its ranged weapon's visual.
+// False when neither exists.
+bool BuildVisual(const Actor &caster, const uint8_t *spell, uint8_t (&out)[Offsets::SPELL_VISUAL_SIZE]) {
+    using GetVisual_t = const uint8_t *(__fastcall *)(const uint8_t *spell);
+    const uint8_t *own = reinterpret_cast<GetVisual_t>(Offsets::FUN_GET_SPELL_VISUAL)(spell);
+    const uint8_t *weapon = nullptr;
+    if (IsRanged(spell) && caster.rangedDisplay != nullptr)
+        weapon = DBC::Record(Offsets::VAR_SPELLVISUAL_RECORDS, Offsets::VAR_SPELLVISUAL_COUNT,
+                             Game::Read<uint32_t>(caster.rangedDisplay, Offsets::OFF_ITEMDISPLAYINFO_SPELL_VISUAL));
+    if (own == nullptr && weapon == nullptr)
+        return false;
+    if (own != nullptr)
+        std::memcpy(out, own, sizeof out);
+    else
+        std::memset(out, 0, sizeof out);
+    if (weapon == nullptr)
+        return true;
+    const auto field = [&out](uintptr_t at) -> uint32_t & { return *reinterpret_cast<uint32_t *>(out + at); };
+    const auto fill = [&](uintptr_t at) {
+        if (field(at) == 0)
+            field(at) = Game::Read<uint32_t>(weapon, at);
+    };
+    fill(Offsets::OFF_SPELLVISUAL_PRECAST_KIT);
+    fill(Offsets::OFF_SPELLVISUAL_CAST_KIT);
+    fill(Offsets::OFF_SPELLVISUAL_IMPACT_KIT);
+    if (field(Offsets::OFF_SPELLVISUAL_HAS_MISSILE) == 0 &&
+        Game::Read<uint32_t>(weapon, Offsets::OFF_SPELLVISUAL_HAS_MISSILE) != 0) {
+        field(Offsets::OFF_SPELLVISUAL_HAS_MISSILE) = 1;
+        field(Offsets::OFF_SPELLVISUAL_MISSILE_MODEL) =
+            Game::Read<uint32_t>(weapon, Offsets::OFF_SPELLVISUAL_MISSILE_MODEL);
+    }
+    fill(Offsets::OFF_SPELLVISUAL_MISSILE_PATH);
+    fill(Offsets::OFF_SPELLVISUAL_MISSILE_ATTACHMENT);
+    fill(Offsets::OFF_SPELLVISUAL_MISSILE_SOUND);
+    fill(Offsets::OFF_SPELLVISUAL_PRECAST_SOUND);
+    return true;
+}
+
+// The ammo a ranged spell's packets carry (the server's WriteAmmoToPacket):
+// a thrown weapon is its own ammo; a bow, crossbow or gun shoots the ammo
+// tried on, else what the server gives an NPC (Rough Arrow, Light Shot).
+void ShotAmmo(const Actor &caster, const uint8_t *spell, uint32_t &display, uint32_t &type) {
+    display = type = 0;
+    if (!IsRanged(spell) || caster.rangedDisplay == nullptr)
+        return;
+    const Outfit::HeldLane &held = caster.ranged;
+    if (held.inventoryType == Offsets::INVTYPE_THROWN) {
+        display = Game::Read<uint32_t>(caster.rangedDisplay, 0);
+        type = Offsets::INVTYPE_THROWN;
+        return;
+    }
+    if (caster.ammoDisplay != 0)
+        display = caster.ammoDisplay;
+    else if (held.subclass == Offsets::ITEM_SUBCLASS_WEAPON_BOW ||
+             held.subclass == Offsets::ITEM_SUBCLASS_WEAPON_CROSSBOW)
+        display = Offsets::NPC_ARROW_DISPLAY;
+    else if (held.subclass == Offsets::ITEM_SUBCLASS_WEAPON_GUN)
+        display = Offsets::NPC_BULLET_DISPLAY;
+    if (display != 0)
+        type = Offsets::INVTYPE_AMMO;
+}
+
+// ---- the ranged pose ------------------------------------------------------------
+
+bool IsGunOrCrossbow(const Outfit::HeldLane &held) {
+    return held.itemClass == Offsets::ITEM_CLASS_WEAPON && (held.subclass == Offsets::ITEM_SUBCLASS_WEAPON_GUN ||
+                                                            held.subclass == Offsets::ITEM_SUBCLASS_WEAPON_CROSSBOW);
+}
+
+// Whether the ammo stays off the string: a gun or crossbow is the ranged item.
+bool KeepsAmmoOff(const Actor &actor) { return IsGunOrCrossbow(actor.ranged); }
+
+// The ranged weapon's model (a unit's +0xD24), or null (none hung).
+void *RangedModel(const Actor &actor) { return actor.rangedModel; }
+
+void Nock(Actor &actor) {
+    M2::Attach(actor.heldAmmo, actor.model, Offsets::ATTACH_BOW_RELEASE);
+    Model::DisplayInfo::LightChildren(actor.SceneFrame(), actor.model);
+}
+
+// CreateLooseItemModel: an item display's model for `body`, of `kind`
+// (LOOSE_ITEM_*), that the caller owns one reference on, or null.
+void *LooseItemModel(void *body, uint32_t display, uint32_t kind) {
+    using LooseItem_t = void *(__fastcall *)(void *model, const void *record, uint32_t kind);
+    return reinterpret_cast<LooseItem_t>(Offsets::FUN_CREATE_LOOSE_ITEM_MODEL)(
+        body, DBC::Record(Offsets::VAR_ITEMDISPLAYINFO_RECORDS, Offsets::VAR_ITEMDISPLAYINFO_COUNT, display), kind);
+}
+
+// SetAmmoDisplay (0x0060BA30): the ammo in hand for `display`, made again
+// when it changes; nocked at once while the bow is drawn.
+void HoldAmmo(Actor &actor, uint32_t display) {
+    if (actor.heldAmmoDisplay == display && actor.heldAmmo != nullptr)
+        return;
+    if (actor.heldAmmo != nullptr) {
+        if (M2::Parent(actor.heldAmmo) != nullptr)
+            M2::Detach(actor.heldAmmo);
+        M2::Release(actor.heldAmmo);
+        actor.heldAmmo = nullptr;
+    }
+    actor.heldAmmoDisplay = display;
+    if (display == 0 || actor.model == nullptr)
+        return;
+    const uint32_t kind = actor.ranged.inventoryType == Offsets::INVTYPE_THROWN ? Offsets::LOOSE_ITEM_WEAPON
+                                                                                : Offsets::LOOSE_ITEM_AMMO;
+    actor.heldAmmo = LooseItemModel(actor.model, display, kind);
+    if (actor.heldAmmo != nullptr && !KeepsAmmoOff(actor) && actor.bowDrawn && kind == Offsets::LOOSE_ITEM_AMMO)
+        Nock(actor);
+}
+
+} // namespace
+
+void EndRangedPose(Actor &actor) {
+    actor.bowDrawn = false;
+    if (actor.heldAmmo != nullptr && M2::Parent(actor.heldAmmo) != nullptr)
+        M2::Detach(actor.heldAmmo);
+    if (void *ranged = RangedModel(actor)) {
+        if (M2::GetAnimState(ranged, -1).id != Offsets::ANIM_BOW_RELEASE)
+            M2::PlayAnimation(ranged, -1, Offsets::ANIM_STAND, -1, 0, 1.0f, 1, 1);
+    }
+}
+
+namespace {
+
+// PlayBowPull (0x00624CC0): the weapon's BowPull, fitted to end with the
+// body's animation. A unit whose +0xD5C is 4 asks key bone 4 first; an actor
+// has no such state and asks the whole model.
+void PlayBowPull(Actor &actor) {
+    void *ranged = RangedModel(actor);
+    if (ranged == nullptr || !M2::IsLoaded(ranged, 0, 0) ||
+        !M2::HasAnimation(ranged, Offsets::ANIM_BOW_PULL) ||
+        actor.model == nullptr || !M2::IsLoaded(actor.model, 0, 0))
+        return;
+    const M2::AnimState state = M2::GetAnimState(actor.model, -1);
+    if (state.latch != 0)
+        return;
+    const auto played = static_cast<int>(static_cast<double>(state.position) / state.speed);
+    const int left = static_cast<int32_t>(state.hi) - played - static_cast<int32_t>(state.lo);
+    if (left <= 0)
+        return;
+    const M2::SequenceInfo info = M2::GetSequenceInfo(ranged, Offsets::ANIM_BOW_PULL, 0);
+    const float speed = static_cast<float>(info.length) / static_cast<float>(left);
+    M2::PlayAnimation(ranged, -1, Offsets::ANIM_BOW_PULL, 0, 0, speed, 1, 1);
+}
+
+// The unit's current spell is ranged: here a cast still preparing or waiting
+// for its release.
+bool CastsRanged(const Actor &actor) {
+    for (const SpellCast &cast : actor.spellCasts) {
+        if (cast.phase == SpellCast::Phase::Flight)
+            continue;
+        const uint8_t *spell =
+            DBC::Record(Offsets::VAR_SPELL_RECORDS, Offsets::VAR_SPELL_RECORD_COUNT, cast.spellID);
+        if (spell != nullptr && IsRanged(spell))
+            return true;
+    }
+    return false;
+}
+
+bool MissileQueued(const Actor &actor) {
+    for (const SpellCast &cast : actor.spellCasts)
+        if (cast.phase == SpellCast::Phase::Cast && cast.missile != nullptr)
+            return true;
+    return false;
+}
+
+bool IsBowCrossbowOrThrown(const Outfit::HeldLane &held) {
+    return held.itemClass == Offsets::ITEM_CLASS_WEAPON &&
+           (held.subclass == Offsets::ITEM_SUBCLASS_WEAPON_BOW || held.subclass == Offsets::ITEM_SUBCLASS_WEAPON_CROSSBOW ||
+            held.subclass == Offsets::ITEM_SUBCLASS_WEAPON_THROWN);
+}
+
+void FreeStuck(StuckMissile &stuck) {
+    if (M2::Parent(stuck.model) != nullptr)
+        M2::Detach(stuck.model);
+    M2::SetVisible(stuck.model, false);
+    M2::Release(stuck.model);
+    stuck.model = nullptr;
+}
+
+void EndPrecast(Actor &caster, SpellCast &cast) {
+    for (void *effect : cast.precastEffects) {
+        M2::Detach(effect);
+        M2::Release(effect);
+    }
+    cast.precastEffects.clear();
+    if (cast.precastTinted && caster.model != nullptr) {
+        const float white[3] = {1.0f, 1.0f, 1.0f};
+        M2::SetDiffuse(caster.model, white);
+        caster.ApplyAlpha();
+        cast.precastTinted = false;
+    }
+    // The loop goes; a once-only animation over it (a wound) plays on.
+    caster.kitLoopAnimation = -1;
+    if (caster.kitAnimationLoops) {
+        caster.kitAnimation = -1;
+        caster.kitAnimationLoops = false;
+        caster.PlayAnimation();
+    }
+}
+
+void StopMissileSound(SpellCast &cast) {
+    if (cast.missileSound != nullptr) {
+        Sound::Play::Stop(cast.missileSound, kSoundFadeSec);
+        cast.missileSound = nullptr;
+    }
+}
+
+void ReleaseMissile(SpellCast &cast) {
+    StopMissileSound(cast);
+    if (cast.missile != nullptr) {
+        M2::SetAnimDoneCallback(cast.missile, nullptr, 0, 0);
+        ReleaseLit(cast.missile, cast.light);
+        cast.missile = nullptr;
+    }
+}
+
+// The target's attachment point, or its position raised by 0.75 of its
+// height. Unchanged while the target's model has not loaded.
+// The attachment Launch settles (0x0061CEB0): the visual's, else 15, else
+// 19, else none (-1).
+int TargetAttachment(const SpellCast &cast) {
+    const Actor *target = cast.target;
+    if (target == nullptr || target->model == nullptr)
+        return -1;
+    const auto index = Game::Read<uint32_t>(cast.visual, Offsets::OFF_SPELLVISUAL_MISSILE_ATTACHMENT);
+    const uint32_t wanted =
+        index < Offsets::SPELL_VISUAL_ATTACHMENT_COUNT
+            ? Game::Read<uint32_t>(static_cast<uintptr_t>(Offsets::VAR_SPELL_VISUAL_ATTACHMENTS) +
+                                   index * 4)
+            : kFallbackAttachments[0];
+    const uint32_t tries[] = {wanted, kFallbackAttachments[0], kFallbackAttachments[1]};
+    for (uint32_t id : tries) {
+        if (M2::HasAttachment(target->model, id))
+            return static_cast<int>(id);
+    }
+    return -1;
+}
+
+void Aim(SpellCast &cast) {
+    Actor *target = cast.target;
+    if (target == nullptr || !ChainLoaded(target->model))
+        return;
+    if (const int id = TargetAttachment(cast); id >= 0) {
+        M2::GetAttachmentPosition(target->model, static_cast<uint32_t>(id), cast.destination);
+        return;
+    }
+    float box[6];
+    M2::GetBoundingBox(target->model, box);
+    cast.destination[0] = target->position[0];
+    cast.destination[1] = target->position[1];
+    cast.destination[2] = target->position[2] + box[5] * target->scale * kAimHeight;
+}
+
+// The spell reaches its target: the caster's OnSpellVisualImpact (queued),
+// the wound animation, then the impact kit once.
+void Impact(Actor &caster, SpellCast &cast, bool missileHit) {
+    caster.spellImpacts.push_back({cast.id, cast.spellID, cast.target});
+    Actor *target = cast.target;
+    if (target == nullptr || target->model == nullptr)
+        return;
+    if (missileHit)
+        target->PlayKitAnimation(kAnimCombatWound, false);
+    PlayKit(*target, Kit(cast.visual, Offsets::OFF_SPELLVISUAL_IMPACT_KIT), false, nullptr);
+}
+
+// StickInUnit (0x0061E7C0), from ArriveHit (0x0061DC50): a missile shot from
+// a bow, crossbow or thrown weapon stays in the target at the attachment it
+// flew at, as it struck, playing Impact, for 5 s. The missile is snapped to
+// the destination first (Arrive 0x0061E1D0), keeping the turn of its flight.
+bool Stick(SpellCast &cast) {
+    using Matrix_t = void(__thiscall *)(void *model, float *out, uint32_t id);
+    Actor *target = cast.target;
+    if (!cast.sticks || cast.attachment < 0 || cast.missile == nullptr || target == nullptr ||
+        target->model == nullptr || !M2::HasAttachment(target->model, static_cast<uint32_t>(cast.attachment)))
+        return false;
+    void *missile = cast.missile;
+    float *base = M2::BaseMatrix(missile);
+    for (int i = 0; i < 3; ++i)
+        base[12 + i] = cast.destination[i];
+    M2::SetAnimDoneCallback(missile, nullptr, 0, 0);
+    M2::PlayAnimation(missile, -1, Offsets::ANIM_IMPACT, -1, 0, 1.0f, 1, 1);
+    M2::Attach(missile, target->model, static_cast<uint32_t>(cast.attachment));
+    float attachment[16], inverse[16], world[16], local[16];
+    reinterpret_cast<Matrix_t>(Offsets::FUN_M2MODEL_GET_ATTACHMENT_MATRIX)(target->model, attachment,
+                                                                          static_cast<uint32_t>(cast.attachment));
+    Gx::InvertAffine(attachment, inverse, target->scale);
+    M2::GetBaseTransform(missile, world);
+    Gx::Multiply(local, world, inverse);
+    M2::SetBaseTransform(missile, local);
+    // The world object goes (0x0061E859); the missile is lit as the target's
+    // child.
+    Model::DisplayInfo::LightChildren(target->SceneFrame(), target->model);
+    cast.light.reset();
+    target->stuckMissiles.push_back({missile, static_cast<float>(Offsets::MISSILE_STICK_MS) * 0.001f});
+    cast.missile = nullptr;
+    return true;
+}
+
+void LeaveImpactModel(Actor &caster, const SpellCast &cast) {
+    const char *file = EffectFile(Game::Read<uint32_t>(cast.visual, Offsets::OFF_SPELLVISUAL_IMPACT_MODEL));
+    if (file == nullptr)
+        return;
+    void *model = M2::CreateModel(Model::Pane::Scene(caster.SceneFrame()), file);
+    if (model == nullptr)
+        return;
+    std::unique_ptr<EntityLight> light;
+    LightAsEntity(model, light, caster.SceneFrame());
+    const float axisZ[3] = {0.0f, 0.0f, 1.0f};
+    const float scales[3] = {1.0f, 1.0f, 1.0f};
+    M2::SetBaseTRS(model, cast.destination, 0.0f, axisZ, scales);
+    caster.impactModels.push_back({model, 0, std::move(light)});
+}
+
+// ReleaseMissilesFromHand's point: the first release event the model has,
+// else the caster's position.
+void HandPoint(Actor &caster, float (&point)[3]) {
+    if (ChainLoaded(caster.model)) {
+        for (uint32_t tag : kReleaseEvents) {
+            if (M2::HasEvent(caster.model, tag)) {
+                M2::GetEventPosition(caster.model, tag, point);
+                return;
+            }
+        }
+    }
+    for (int i = 0; i < 3; ++i)
+        point[i] = caster.position[i];
+}
+
+// CMissile::Launch: aims, fits the speed to the time spent queued, plays
+// InFlight and starts the flight sound. False while the model loads.
+bool Launch(Actor &caster, SpellCast &cast, const float (&from)[3]) {
+    if (!M2::IsLoaded(cast.missile, 0, 0))
+        return false;
+    for (int i = 0; i < 3; ++i)
+        cast.position[i] = from[i];
+    cast.attachment = ChainLoaded(cast.target->model) ? TargetAttachment(cast) : -1;
+    Aim(cast);
+    const float dx = cast.destination[0] - from[0];
+    const float dy = cast.destination[1] - from[1];
+    const float dz = cast.destination[2] - from[2];
+    const float distance = std::sqrt(dz * dz + dy * dy + dx * dx);
+    const float flightSec = distance / cast.speed - cast.queuedSec;
+    cast.speed = flightSec > 0.0f ? (std::fmin)(distance / flightSec, kMaxSpeed) : kMaxSpeed;
+    M2::SetAnimDoneCallback(cast.missile, Model::VisualKit::LoopCallback(), 0, 0);
+    M2::PlayAnimation(cast.missile, -1, flightSec > 0.0f ? kAnimInFlight : kAnimStand, 0, 0, 1.0f, 1,
+                      1);
+    cast.missileSound = Sounds::Loop(caster.SceneFrame(),
+                                     Game::Read<int32_t>(cast.visual, Offsets::OFF_SPELLVISUAL_MISSILE_SOUND),
+                                     cast.position);
+    cast.phase = SpellCast::Phase::Flight;
+    return true;
+}
+
+// The launcher's model (0x0060A3D0): the visual's missile model, else the
+// ammo's, else the error cube. A shot made during a rifle animation is drawn
+// at alpha 0 (the bullet is not seen).
+void *MakeMissile(Actor &caster, const SpellCast &cast) {
+    void *scene = Model::Pane::Scene(caster.SceneFrame());
+    void *model = nullptr;
+    const auto effect = Game::Read<int32_t>(cast.visual, Offsets::OFF_SPELLVISUAL_MISSILE_MODEL);
+    if (effect < 1) {
+        if (cast.ammoDisplay != 0)
+            model = LooseItemModel(caster.model, cast.ammoDisplay,
+                                   cast.ammoType == Offsets::INVTYPE_THROWN ? Offsets::LOOSE_ITEM_WEAPON
+                                                                            : Offsets::LOOSE_ITEM_AMMO);
+    } else if (const char *file = EffectFile(static_cast<uint32_t>(effect))) {
+        model = M2::CreateModel(scene, file);
+    }
+    if (model == nullptr)
+        model = M2::CreateModel(scene, kErrorCube);
+    if (model != nullptr && M2::IsRifleAnimation(caster.CurrentAnimation()))
+        M2::SetAlpha(model, 0.0f);
+    return model;
+}
+
+void StartCast(Actor &caster, SpellCast &cast) {
+    EndPrecast(caster, cast);
+    cast.phase = SpellCast::Phase::Cast;
+    PlayKit(caster, Kit(cast.visual, Offsets::OFF_SPELLVISUAL_CAST_KIT), false, nullptr);
+    const auto *spell = DBC::Record(Offsets::VAR_SPELL_RECORDS, Offsets::VAR_SPELL_RECORD_COUNT,
+                                    cast.spellID);
+    cast.speed = spell != nullptr ? Game::Read<float>(spell, Offsets::OFF_SPELL_RECORD_SPEED) : 0.0f;
+    const bool missile = (Game::Read<uint32_t>(cast.visual, Offsets::OFF_SPELLVISUAL_HAS_MISSILE) != 0 ||
+                          cast.ammoDisplay != 0) &&
+                         cast.speed > 0.0f && cast.target != &caster;
+    if (missile) {
+        cast.missile = MakeMissile(caster, cast);
+        cast.sticks = spell != nullptr && IsRanged(spell) && IsBowCrossbowOrThrown(caster.ranged);
+    }
+    if (cast.missile != nullptr) {
+        LightAsEntity(cast.missile, cast.light, caster.SceneFrame());
+        Aim(cast);
+        return;
+    }
+    Impact(caster, cast, false);
+}
+
+// Moves the cast on; true once it is over.
+bool Step(Actor &caster, SpellCast &cast, float elapsedSec) {
+    switch (cast.phase) {
+    case SpellCast::Phase::Precast:
+        cast.precastLeftSec -= elapsedSec;
+        if (cast.precastLeftSec > 0.0f)
+            return false;
+        StartCast(caster, cast);
+        return cast.missile == nullptr;
+    case SpellCast::Phase::Cast: {
+        cast.queuedSec += elapsedSec;
+        float from[3];
+        if (caster.releaseEvent) {
+            for (int i = 0; i < 3; ++i)
+                from[i] = caster.releasePoint[i];
+        } else if (KitAnimation(Kit(cast.visual, Offsets::OFF_SPELLVISUAL_CAST_KIT)) <= 0 ||
+                   caster.kitAnimationEnded || cast.queuedSec >= kReleaseTimeoutSec) {
+            HandPoint(caster, from);
+        } else {
+            return false;
+        }
+        // ReleaseMissiles ends the ranged pose (0x0060C951).
+        if (Launch(caster, cast, from))
+            EndRangedPose(caster);
+        return false;
+    }
+    case SpellCast::Phase::Flight: {
+        Aim(cast);
+        float d[3];
+        float lengthSq = 0.0f;
+        for (int i = 0; i < 3; ++i) {
+            d[i] = cast.destination[i] - cast.position[i];
+            lengthSq += d[i] * d[i];
+        }
+        const float step = elapsedSec * cast.speed;
+        if (step * step > lengthSq) {
+            for (int i = 0; i < 3; ++i)
+                cast.position[i] = cast.destination[i];
+            StopMissileSound(cast);
+            LeaveImpactModel(caster, cast);
+            Impact(caster, cast, true);
+            if (!Stick(cast))
+                ReleaseMissile(cast);
+            return true;
+        }
+        const float scale = step / std::sqrt(lengthSq);
+        for (int i = 0; i < 3; ++i)
+            cast.position[i] += d[i] * scale;
+        return false;
+    }
+    }
+    return true;
+}
+
+// A cast past its precast already ended it: the caster's looping animation
+// now belongs to a newer cast's precast, which a missile landing does not end.
+void DropCast(Actor &caster, SpellCast &cast) {
+    if (cast.phase == SpellCast::Phase::Precast)
+        EndPrecast(caster, cast);
+    ReleaseMissile(cast);
+}
+
+} // namespace
+
+// An interrupt ends a spell still preparing (0x0060D1C0 stops its kits: the
+// effects, the tint and the looping animation; the failed spell's EndPrecast
+// 0x0060FC50 ends the ranged pose); a spell already cast goes on, its missile
+// included.
+void Stop(Actor &caster) {
+    bool stopped = false;
+    for (size_t i = 0; i < caster.spellCasts.size();) {
+        if (caster.spellCasts[i].phase != SpellCast::Phase::Precast) {
+            ++i;
+            continue;
+        }
+        DropCast(caster, caster.spellCasts[i]);
+        caster.spellCasts.erase(caster.spellCasts.begin() + static_cast<ptrdiff_t>(i));
+        stopped = true;
+    }
+    if (stopped)
+        EndRangedPose(caster);
+}
+
+// $BWP (OnCombatModelEvent 0x006247D0): with a ranged spell under way, the
+// weapon draws and the ammo goes on the string unless a gun or crossbow
+// shoots it.
+void BowPull(Actor &caster) {
+    if (!CastsRanged(caster))
+        return;
+    PlayBowPull(caster);
+    if (!KeepsAmmoOff(caster) && caster.heldAmmo != nullptr && M2::Parent(caster.heldAmmo) == nullptr)
+        Nock(caster);
+    caster.bowDrawn = true;
+}
+
+// $BWR (0x00600159): the bow is no longer drawn; with a missile waiting, a
+// bow animation plays the weapon's stand and a rifle animation its release;
+// the ammo leaves the string.
+void BowRelease(Actor &caster) {
+    caster.bowDrawn = false;
+    if (MissileQueued(caster) && caster.model != nullptr) {
+        const int anim = caster.CurrentAnimation();
+        void *ranged = RangedModel(caster);
+        if (M2::IsBowAnimation(anim) &&
+            M2::HasAttachment(caster.model, Offsets::ATTACH_BOW_RELEASE)) {
+            if (ranged != nullptr)
+                M2::PlayAnimation(ranged, -1, Offsets::ANIM_STAND, -1, 0, 1.0f, 1, 1);
+        } else if (M2::IsRifleAnimation(anim) &&
+                   M2::HasAttachment(caster.model, Offsets::ATTACH_RIFLE_RELEASE)) {
+            if (ranged != nullptr)
+                M2::PlayAnimation(ranged, -1, Offsets::ANIM_BOW_RELEASE, -1, 0, 1.0f, 1, 1);
+        }
+    }
+    if (caster.heldAmmo != nullptr && M2::Parent(caster.heldAmmo) != nullptr)
+        M2::Detach(caster.heldAmmo);
+}
+
+// The sequence-end handler's ranged cases (0x005FC3F0): a load goes on to
+// its hold; a hold plays again while the weapon is held and the spell still
+// prepares.
+int RangedAnimationAfter(const Actor &caster, int ended) {
+    switch (ended) {
+    case Offsets::ANIM_LOAD_BOW:
+        return Offsets::ANIM_HOLD_BOW;
+    case Offsets::ANIM_LOAD_RIFLE:
+        return Offsets::ANIM_HOLD_RIFLE;
+    case Offsets::ANIM_HOLD_BOW:
+    case Offsets::ANIM_HOLD_RIFLE:
+    case Offsets::ANIM_HOLD_THROWN:
+    case Offsets::ANIM_LOAD_THROWN:
+        break;
+    default:
+        return -1;
+    }
+    bool preparing = false;
+    for (const SpellCast &cast : caster.spellCasts)
+        preparing = preparing || cast.phase == SpellCast::Phase::Precast;
+    if (RangedModel(caster) == nullptr || !preparing)
+        return -1;
+    return ended == Offsets::ANIM_LOAD_THROWN ? static_cast<int>(Offsets::ANIM_HOLD_THROWN) : ended;
+}
+
+uint32_t Play(Actor &caster, uint32_t spellID, Actor *target, int castTimeMs) {
+    using GetCastTime_t = int(__fastcall *)(int spellID, int pet, int allowNegative);
+    static uint32_t s_lastCastID = 0;
+    const uint8_t *spell =
+        DBC::Record(Offsets::VAR_SPELL_RECORDS, Offsets::VAR_SPELL_RECORD_COUNT, spellID);
+    if (spell == nullptr || caster.model == nullptr)
+        return 0;
+    uint8_t visual[Offsets::SPELL_VISUAL_SIZE];
+    if (!BuildVisual(caster, spell, visual))
+        return 0;
+    // A new cast ends the precast of one still preparing.
+    Stop(caster);
+    if (castTimeMs < 0)
+        castTimeMs = reinterpret_cast<GetCastTime_t>(Offsets::FUN_GET_CAST_TIME)(
+            static_cast<int>(spellID), 0, 0);
+    SpellCast cast;
+    if (++s_lastCastID == 0) // the IDs start again from 1 after 2^32 casts
+        s_lastCastID = 1;
+    cast.id = s_lastCastID;
+    cast.spellID = spellID;
+    std::memcpy(cast.visual, visual, sizeof visual);
+    ShotAmmo(caster, spell, cast.ammoDisplay, cast.ammoType);
+    // HandleSpellStart (0x006E78A1): a ranged or auto-repeat spell sets the
+    // ammo in hand.
+    if (IsRanged(spell) || (Game::Read<uint32_t>(spell, Offsets::OFF_SPELL_RECORD_ATTRIBUTES_EX2) &
+                            Offsets::SPELL_ATTR_EX2_AUTOREPEAT_FLAG) != 0) {
+        HoldAmmo(caster, cast.ammoDisplay);
+        caster.DrawRanged();
+    }
+    cast.target = target != nullptr ? target : &caster;
+    caster.spellCasts.push_back(std::move(cast));
+    SpellCast &added = caster.spellCasts.back();
+    const uint8_t *precast = Kit(visual, Offsets::OFF_SPELLVISUAL_PRECAST_KIT);
+    if (castTimeMs > 0 && precast != nullptr) {
+        added.phase = SpellCast::Phase::Precast;
+        added.precastLeftSec = static_cast<float>(castTimeMs) * 0.001f;
+        added.precastTinted = HasTintProcedure(precast);
+        PlayKit(caster, precast, true, &added.precastEffects);
+        return added.id;
+    }
+    StartCast(caster, added);
+    const uint32_t id = added.id;
+    if (added.missile == nullptr)
+        caster.spellCasts.pop_back();
+    return id;
+}
+
+void Update(Actor &caster, float elapsedSec) {
+    if (caster.paused || caster.globalPaused)
+        elapsedSec = 0.0f;
+    // By index: a step may start a cast's impact on this caster, which plays
+    // its kit, not another cast.
+    for (size_t i = 0; i < caster.spellCasts.size();) {
+        if (!Step(caster, caster.spellCasts[i], elapsedSec)) {
+            ++i;
+            continue;
+        }
+        DropCast(caster, caster.spellCasts[i]);
+        caster.spellCasts.erase(caster.spellCasts.begin() + static_cast<ptrdiff_t>(i));
+    }
+    caster.releaseEvent = false;
+    caster.kitAnimationEnded = false;
+    for (SpellCast &cast : caster.spellCasts)
+        if (cast.phase == SpellCast::Phase::Flight)
+            SettleLight(cast.missile, cast.light.get(), elapsedSec);
+    for (ImpactModel &impact : caster.impactModels)
+        SettleLight(impact.model, impact.light.get(), elapsedSec);
+    for (size_t i = 0; i < caster.stuckMissiles.size();) {
+        StuckMissile &stuck = caster.stuckMissiles[i];
+        stuck.leftSec -= elapsedSec;
+        if (stuck.leftSec > 0.0f) {
+            ++i;
+            continue;
+        }
+        FreeStuck(stuck);
+        caster.stuckMissiles.erase(caster.stuckMissiles.begin() + static_cast<ptrdiff_t>(i));
+    }
+    for (size_t i = 0; i < caster.impactModels.size();) {
+        ImpactModel &impact = caster.impactModels[i];
+        const bool gone = impact.framesShown >= 2 && !M2::HasLiveParticles(impact.model);
+        if (!gone) {
+            ++i;
+            continue;
+        }
+        ReleaseLit(impact.model, impact.light);
+        caster.impactModels.erase(caster.impactModels.begin() + static_cast<ptrdiff_t>(i));
+    }
+}
+
+void Link(Actor &caster) {
+    for (SpellCast &cast : caster.spellCasts) {
+        if (cast.phase != SpellCast::Phase::Flight || !M2::IsReady(cast.missile, 0, 1))
+            continue;
+        M2::SetAnimated(cast.missile, true);
+        M2::SetVisible(cast.missile, true);
+    }
+    for (ImpactModel &impact : caster.impactModels) {
+        if (!M2::IsReady(impact.model, 0, 1))
+            continue;
+        M2::SetAnimated(impact.model, true);
+        M2::SetVisible(impact.model, true);
+        ++impact.framesShown;
+    }
+}
+
+// The missile faces its travel: yaw about the up axis, then pitch, as an
+// actor's placement turns.
+void Place(Actor &caster) {
+    const float axisY[3] = {0.0f, 1.0f, 0.0f};
+    const float axisZ[3] = {0.0f, 0.0f, 1.0f};
+    const float scales[3] = {1.0f, 1.0f, 1.0f};
+    for (SpellCast &cast : caster.spellCasts) {
+        if (cast.phase != SpellCast::Phase::Flight)
+            continue;
+        const float dx = cast.destination[0] - cast.position[0];
+        const float dy = cast.destination[1] - cast.position[1];
+        const float dz = cast.destination[2] - cast.position[2];
+        const float yaw = std::atan2(dy, dx);
+        const float pitch = -std::atan2(dz, std::sqrt(dx * dx + dy * dy));
+        M2::SetBaseTRS(cast.missile, cast.position, yaw, axisZ, scales);
+        Gx::Rotate(M2::BaseMatrix(cast.missile), pitch, axisY);
+        Sounds::Move(caster.SceneFrame(), cast.missileSound, cast.position);
+    }
+}
+
+void Silence(Actor &caster) {
+    for (SpellCast &cast : caster.spellCasts)
+        if (cast.missileSound != nullptr) {
+            Sound::Play::Stop(cast.missileSound, 0.0f);
+            cast.missileSound = nullptr;
+        }
+}
+
+void Drop(Actor &caster) {
+    for (SpellCast &cast : caster.spellCasts)
+        DropCast(caster, cast);
+    caster.spellCasts.clear();
+    for (ImpactModel &impact : caster.impactModels)
+        ReleaseLit(impact.model, impact.light);
+    caster.impactModels.clear();
+    for (StuckMissile &stuck : caster.stuckMissiles)
+        FreeStuck(stuck);
+    caster.stuckMissiles.clear();
+    caster.releaseEvent = false;
+    HoldAmmo(caster, 0);
+    caster.bowDrawn = false;
+}
+
+} // namespace Model::Scene::Casts
@@ -0,0 +1,37 @@
+// This file is part of ClassicAPI.
+//
+// ClassicAPI is free software: you can redistribute it and/or modify it under the terms
+// of the GNU General Public License as published by the Free Software Foundation, either
+// version 3 of the License, or (at your option) any later version.
+//
+// ClassicAPI is distributed in the hope that it will be useful, but WITHOUT ANY
+// WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
+// PURPOSE. See the GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License along with
+// ClassicAPI. If not, see <https://www.gnu.org/licenses/>.
+
+// `Constants.Transmog`, retail's TransmogConstants system
+// (Blizzard_APIDocumentationGenerated/TransmogConstantsDocumentation.lua):
+// the values ItemTransmogInfoMixin (Util/ItemUtil.lua) and the
+// ModelSceneActor ItemTransmogInfo methods use for "no appearance".
+
+#include "Game.h"
+
+namespace Model::TransmogConstants {
+
+namespace {
+
+const Game::Lua::EnumIntegerEntry kTransmog[] = {
+    {"NoTransmogID", 0},
+    {"MainHandTransmogIsIndividualWeapon", -1},
+    {"MainHandTransmogIsPairedWeapon", 0},
+};
+
+void RegisterLuaFunctions() { Game::Lua::RegisterConstants("Transmog", kTransmog, "TransmogConstants"); }
+
+const Game::ModuleAutoRegister _autoreg{&RegisterLuaFunctions};
+
+} // namespace
+
+} // namespace Model::TransmogConstants
@@ -0,0 +1,186 @@
+// This file is part of ClassicAPI.
+//
+// ClassicAPI is free software: you can redistribute it and/or modify it under the terms
+// of the GNU General Public License as published by the Free Software Foundation, either
+// version 3 of the License, or (at your option) any later version.
+//
+// ClassicAPI is distributed in the hope that it will be useful, but WITHOUT ANY
+// WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
+// PURPOSE. See the GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License along with
+// ClassicAPI. If not, see <https://www.gnu.org/licenses/>.
+
+// TryOn's arguments. Retail's hand argument is an inventory slot name,
+// matched the way GetInventorySlotInfo matches it (SStrCmpI over the
+// PaperDollItemFrame rows): MainHandSlot or SecondaryHandSlot. Any other
+// string names no hand.
+//
+// A recipe tries on what it makes, as 4.3.4's worker (`TryOnWithVisual`,
+// 0x00A05010) does: an item with no inventory type whose spell teaches a
+// CREATE_ITEM spell is swapped for the made item, and a trade-skill
+// `enchant:` link names the item its TRADESPELL's first effect makes.
+
+#include "model/TryOn.h"
+
+#include "Game.h"
+#include "Offsets.h"
+#include "dbc/Lookup.h"
+#include "item/Arg.h"
+#include "item/Dressable.h"
+#include "item/ID.h"
+#include "item/Location.h"
+#include "item/Record.h"
+#include "model/Outfit.h"
+
+#include <cstdio>
+#include <cstdlib>
+#include <cstring>
+
+namespace Model::TryOn {
+namespace {
+
+// The lane a hand name picks: the PaperDollItemFrame row it names
+// (GetInventorySlotInfo's match), if that row is a held slot; else 0.
+uint32_t NamedHand(const char *name) {
+    const auto *records = Game::Read<const uint8_t *>(Offsets::VAR_PAPERDOLLITEMFRAME_RECORDS);
+    const int count = Game::Read<int>(Offsets::VAR_PAPERDOLLITEMFRAME_COUNT);
+    if (records == nullptr)
+        return 0;
+    for (int i = 0; i < count; ++i) {
+        const uint8_t *row = records + i * Offsets::OFF_PAPERDOLLITEMFRAME_RECORD_STRIDE;
+        if (Game::StrCmpI(Game::Read<const char *>(row, Offsets::OFF_PAPERDOLLITEMFRAME_SLOT_NAME),
+                          name) != 0)
+            continue;
+        switch (Game::Read<int>(row, Offsets::OFF_PAPERDOLLITEMFRAME_SLOT_NUMBER)) {
+        case Offsets::INVSLOT_MAINHAND: return Outfit::kBodySlotMainHand;
+        case Offsets::INVSLOT_OFFHAND: return Outfit::kBodySlotOffHand;
+        default: return 0;
+        }
+    }
+    return 0;
+}
+
+// The item a trade-skill recipe makes, from an `enchant:<spellID>` link: a
+// TRADESPELL whose first effect makes an item (4.3.4's test).
+uint32_t RecipeItem(const char *link) {
+    const char *enchant = std::strstr(link, "enchant:");
+    if (enchant == nullptr)
+        return 0;
+    const long spellID = std::strtol(enchant + 8, nullptr, 10);
+    if (spellID <= 0)
+        return 0;
+    const uint8_t *spell = DBC::Record(Offsets::VAR_SPELL_RECORDS, Offsets::VAR_SPELL_RECORD_COUNT,
+                                       static_cast<uint32_t>(spellID));
+    if (spell == nullptr ||
+        (Game::Read<uint32_t>(spell, Offsets::OFF_SPELL_RECORD_ATTRIBUTES) &
+         Offsets::SPELL_ATTR_TRADESPELL) == 0)
+        return 0;
+    return Game::Read<uint32_t>(spell, Offsets::OFF_SPELL_RECORD_EFFECT_ITEM_TYPE);
+}
+
+} // namespace
+
+Request ReadArgs(void *L) {
+    Request request;
+    // Read before the name search below, which stomps the Lua stack.
+    if (Game::Lua::Type(L, 3) == Game::Lua::TYPE_STRING)
+        request.bodySlot = NamedHand(Game::Lua::ToString(L, 3));
+    const bool enchantGiven = Game::Lua::IsNumber(L, 4) != 0;
+    if (enchantGiven)
+        request.enchant = static_cast<uint32_t>(Game::Lua::ToNumber(L, 4));
+    if (Game::Lua::Type(L, 2) == Game::Lua::TYPE_NUMBER) {
+        request.itemID = static_cast<uint32_t>(Game::Lua::ToNumber(L, 2));
+    } else if (Game::Lua::Type(L, 2) == Game::Lua::TYPE_STRING) {
+        // Copied: the name search below stomps the Lua stack.
+        char s[256];
+        std::snprintf(s, sizeof(s), "%s", Game::Lua::ToString(L, 2));
+        if (std::strstr(s, "enchant:") != nullptr) {
+            request.itemID = RecipeItem(s);
+        } else {
+            // An item link, `item:` string or numeric string resolves to an ID;
+            // any other string is the name of an item the player carries.
+            const Item::Arg::Resolved arg = Item::Arg::ResolveString(s);
+            Item::Location::ByGUIDResult found{};
+            if (arg.itemID != 0) {
+                request.itemID = static_cast<uint32_t>(arg.itemID);
+                if (!enchantGiven)
+                    request.enchant = static_cast<uint32_t>(arg.enchant);
+            } else if (arg.name != nullptr && Item::Location::FindByArg(L, arg, &found))
+                request.itemID = static_cast<uint32_t>(Item::ID::FromCGItem(found.item));
+        }
+    }
+    return request;
+}
+
+uint32_t WornItem(uint32_t itemID) {
+    const uint8_t *record = Item::PeekRecord(itemID);
+    if (record != nullptr &&
+        Game::Read<uint32_t>(record, Offsets::OFF_ITEMSTATS_INVENTORY_TYPE) == 0) {
+        const uint32_t made = Item::Dressable::RecipeItem(record);
+        if (made != 0)
+            return made;
+    }
+    return itemID;
+}
+
+void ShowNotEquippable() {
+    using DisplayError_t = void(__cdecl *)(uint32_t id, ...);
+    reinterpret_cast<DisplayError_t>(Offsets::FUN_GAMEUI_DISPLAY_ERROR)(
+        Offsets::GAME_ERROR_NOT_EQUIPPABLE);
+}
+
+namespace {
+
+// A number field of the table at `index`, or 0.
+uint32_t FieldNumber(void *L, int index, const char *key) {
+    Game::Lua::PushString(L, key);
+    Game::Lua::GetTable(L, index);
+    const double value = Game::Lua::IsNumber(L, -1) ? Game::Lua::ToNumber(L, -1) : 0.0;
+    Game::Lua::SetTop(L, -2);
+    return value > 0.0 ? static_cast<uint32_t>(value) : 0;
+}
+
+} // namespace
+
+bool ReadTransmogInfo(void *L, const char *name, Request &request) {
+    if (Game::Lua::Type(L, 2) != Game::Lua::TYPE_TABLE) {
+        Game::Lua::Error(L,
+                         "Usage: %s:SetItemTransmogInfo(transmogInfo [, inventorySlots, ignoreChildItems])",
+                         name);
+        return false;
+    }
+    request.itemID = FieldNumber(L, 2, "appearanceID");
+    request.enchant = FieldNumber(L, 2, "illusionID");
+    request.quiet = true;
+    if (Game::Lua::IsNumber(L, 3)) {
+        const int invSlot = static_cast<int>(Game::Lua::ToNumber(L, 3));
+        if (invSlot == Offsets::INVSLOT_MAINHAND)
+            request.bodySlot = Outfit::kBodySlotMainHand;
+        else if (invSlot == Offsets::INVSLOT_OFFHAND)
+            request.bodySlot = Outfit::kBodySlotOffHand;
+    }
+    return true;
+}
+
+void PushTransmogInfo(void *L, const Outfit::Appearance &slot) {
+    Game::Lua::PushString(L, "ItemUtil");
+    Game::Lua::GetTable(L, Game::Lua::GLOBALS_INDEX);
+    Game::Lua::PushString(L, "CreateItemTransmogInfo");
+    Game::Lua::GetTable(L, -2);
+    Game::Lua::Remove(L, -2);
+    Game::Lua::PushNumber(L, slot.item);
+    Game::Lua::PushNumber(L, 0);
+    Game::Lua::PushNumber(L, slot.enchant);
+    Game::Lua::Call(L, 3, 1);
+}
+
+void PushTransmogInfoList(void *L, const Outfit::Worn &worn) {
+    Game::Lua::NewTable(L);
+    for (int i = 0; i < Outfit::kInventorySlots; ++i) {
+        PushTransmogInfo(L, worn[i]);
+        Game::Lua::RawSetI(L, -2, i + 1);
+    }
+}
+
+} // namespace Model::TryOn
@@ -0,0 +1,66 @@
+// This file is part of ClassicAPI.
+//
+// ClassicAPI is free software: you can redistribute it and/or modify it under the terms
+// of the GNU General Public License as published by the Free Software Foundation, either
+// version 3 of the License, or (at your option) any later version.
+//
+// ClassicAPI is distributed in the hope that it will be useful, but WITHOUT ANY
+// WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
+// PURPOSE. See the GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License along with
+// ClassicAPI. If not, see <https://www.gnu.org/licenses/>.
+
+#pragma once
+
+#include "model/Outfit.h"
+
+#include <cstdint>
+
+// What every `TryOn(item [, handSlotName, spellEnchantID])` takes in front of
+// the step that dresses the model: DressUpModel's (model/DressUp.cpp, the
+// engine's TryOnItem worker) and the ModelScene actor's (Outfit::TryOn).
+namespace Model::TryOn {
+
+// Retail's Enum.ItemTryOnReason.
+enum Reason : int {
+    kSuccess = 0,
+    kWrongRace = 1,
+    kNotEquippable = 2,
+    kDataPending = 3,
+};
+
+struct Request {
+    uint32_t itemID = 0;   // 0: nothing to try on
+    uint32_t bodySlot = 0; // the hand the arguments name (Outfit::kBodySlot*), or 0
+    uint32_t enchant = 0;  // the SpellItemEnchantment whose glow a weapon shows, or 0
+    bool quiet = false;    // no ERR_NOT_EQUIPPABLE: the caller shows its own (SetItemTransmogInfo)
+};
+
+// The arguments from stack index 2: 4.3.4's item forms (an item ID, an item
+// link or `item:` string, a trade-skill `enchant:` link for the item its
+// recipe makes, or the name of an item the player carries), retail's hand
+// slot name and enchant. The enchant defaults to the link's.
+Request ReadArgs(void *L);
+
+// The item the model wears for `itemID`: a cached recipe is what it makes
+// (4.3.4's TryOnWithVisual swap).
+uint32_t WornItem(uint32_t itemID);
+
+// The worker's answer to an item it cannot put on: ERR_NOT_EQUIPPABLE.
+void ShowNotEquippable();
+
+// SetItemTransmogInfo's arguments from stack index 2: the info's item
+// (appearanceID) and enchant (illusionID), and the hand an inventory slot of
+// 16 or 17 names. Quiet: retail's callers show the error. False, after a Lua
+// usage error naming the frame `name`, when index 2 is not a table.
+bool ReadTransmogInfo(void *L, const char *name, Request &request);
+
+// One slot as retail's ItemTransmogInfo: ItemUtil.CreateItemTransmogInfo(item,
+// NoTransmogID, enchant), built by the mixin's own constructor.
+void PushTransmogInfo(void *L, const Outfit::Appearance &slot);
+
+// Every slot 1..19 as a list of ItemTransmogInfo.
+void PushTransmogInfoList(void *L, const Outfit::Worn &worn);
+
+} // namespace Model::TryOn
@@ -52,6 +52,7 @@
 #include "model/DisplayInfo.h"
 #include "model/M2.h"
 #include "model/Teardown.h"
+#include "model/VisualKit.h"
 #include "tick/FrameTick.h"

 #include <cstdint>
@@ -60,13 +61,6 @@
 namespace Model::VisualKit {
 namespace {

-using ModelFn_t = void(__fastcall *)(void *model);
-using HasAttachment_t = int(__thiscall *)(void *model, uint32_t id);
-using Attach_t = void(__thiscall *)(void *child, void *parent, uint32_t id);
-using SetAlpha_t = void(__thiscall *)(void *model, float alpha);
-using SetDiffuse_t = void(__thiscall *)(void *model, const float *rgb);
-using HasLiveParticles_t = int(__thiscall *)(void *model);
-
 // The attachment of each effect column, in the ghost kit's order.
 constexpr uint32_t kAttachments[] = {20, 34, 19, 21, 22, 17, 23, 24, 25};
 constexpr int kProcedures = 4;
@@ -108,8 +102,7 @@ void __fastcall OnEffectLoop(void *model, uint32_t /*keyBone*/, uint32_t animID,
 // Detaches a stopped effect that is still on its model, then drops our
 // reference.
 void Discard(void *model) {
-    if (Game::Read<void *>(model, Offsets::OFF_M2MODEL_PARENT) != nullptr)
-        reinterpret_cast<ModelFn_t>(Offsets::FUN_M2MODEL_DETACH)(model);
+    M2::Detach(model);
    M2::Release(model);
 }

@@ -132,8 +125,7 @@ void DiscardWhere(Pred done) {
 void Drain() {
    DiscardWhere([](const Stopped &e) {
        return Game::Read<void *>(e.model, Offsets::OFF_M2MODEL_PARENT) == nullptr ||
-               !reinterpret_cast<HasLiveParticles_t>(Offsets::FUN_M2MODEL_HAS_LIVE_PARTICLES)(
-                   e.model);
+               !M2::HasLiveParticles(e.model);
    });
 }

@@ -156,26 +148,33 @@ void ApplyProcedures(void *model, const uint8_t *kit) {
            const float rgb[3] = {static_cast<float>((color >> 16) & 0xFF) * kByteScale,
                                  static_cast<float>((color >> 8) & 0xFF) * kByteScale,
                                  static_cast<float>(color & 0xFF) * kByteScale};
-            reinterpret_cast<SetDiffuse_t>(Offsets::FUN_M2MODEL_SET_DIFFUSE_COLOR)(model, rgb);
+            M2::SetDiffuse(model, rgb);
        } else if (kind == kProcAlpha) {
            const float alpha = value < 0.0f ? 0.0f : value > 1.0f ? 1.0f : value;
-            reinterpret_cast<SetAlpha_t>(Offsets::FUN_M2MODEL_SET_ALPHA)(model, alpha);
+            M2::SetAlpha(model, alpha);
        }
    }
 }

-void Apply(void *pane, const uint8_t *kit, bool oneShot) {
-    void *model = Pane::Model(pane);
+} // namespace
+
+const void *LoopCallback() { return reinterpret_cast<const void *>(&OnEffectLoop); }
+
+const uint8_t *Record(uint32_t kitID) {
+    return DBC::Record(Offsets::VAR_SPELLVISUALKIT_RECORDS, Offsets::VAR_SPELLVISUALKIT_COUNT,
+                       kitID);
+}
+
+void Apply(void *frame, void *model, const uint8_t *kit, bool oneShot,
+           std::vector<void *> *effects) {
    if (model == nullptr)
        return;
-    void *scene = Pane::Scene(pane);
+    void *scene = Pane::Scene(frame);
    for (int i = 0; i < static_cast<int>(sizeof(kAttachments) / sizeof(kAttachments[0])); ++i) {
        const uint8_t *effect = DBC::Record(
            Offsets::VAR_SPELLVISUALEFFECTNAME_RECORDS, Offsets::VAR_SPELLVISUALEFFECTNAME_COUNT,
            Game::Read<uint32_t>(kit, Offsets::OFF_SPELLVISUALKIT_EFFECTS + i * 4));
-        if (effect == nullptr ||
-            !reinterpret_cast<HasAttachment_t>(Offsets::FUN_M2MODEL_HAS_ATTACHMENT)(
-                model, kAttachments[i]))
+        if (effect == nullptr || !M2::HasAttachment(model, kAttachments[i]))
            continue;
        void *child = M2::CreateModel(
            scene, Game::Read<const char *>(effect, Offsets::OFF_SPELLVISUALEFFECTNAME_FILE));
@@ -183,16 +182,21 @@ void Apply(void *pane, const uint8_t *kit, bool oneShot) {
            continue;
        if (oneShot)
            M2::SetAnimDoneCallback(child, reinterpret_cast<const void *>(&OnEffectDone),
-                                    static_cast<uint32_t>(reinterpret_cast<uintptr_t>(pane)), 0);
+                                    static_cast<uint32_t>(reinterpret_cast<uintptr_t>(frame)), 0);
        else
            M2::SetAnimDoneCallback(child, reinterpret_cast<const void *>(&OnEffectLoop), 0, 0);
-        reinterpret_cast<Attach_t>(Offsets::FUN_M2MODEL_ATTACH)(child, model, kAttachments[i]);
-        M2::Release(child);
+        M2::Attach(child, model, kAttachments[i]);
+        if (effects != nullptr)
+            effects->push_back(child); // our reference, handed over
+        else
+            M2::Release(child);
    }
-    Model::DisplayInfo::LightChildren(pane, model);
+    Model::DisplayInfo::LightChildren(frame, model);
    ApplyProcedures(model, kit);
 }

+namespace {
+
 int __fastcall Script_ApplySpellVisualKit(void *L) {
    void *pane = Game::Lua::ResolvePlayerModel(L);
    if (pane == nullptr)
@@ -201,11 +205,8 @@ int __fastcall Script_ApplySpellVisualKit(void *L) {
        Game::Lua::Error(L, "Usage: ApplySpellVisualKit(spellVisualKitID [, oneShot])");
        return 0;
    }
-    const uint8_t *kit =
-        DBC::Record(Offsets::VAR_SPELLVISUALKIT_RECORDS, Offsets::VAR_SPELLVISUALKIT_COUNT,
-                    static_cast<uint32_t>(Game::Lua::ToNumber(L, 2)));
-    if (kit != nullptr)
-        Apply(pane, kit, Game::Lua::ToBoolean(L, 3) != 0);
+    if (const uint8_t *kit = Record(static_cast<uint32_t>(Game::Lua::ToNumber(L, 2))))
+        Apply(pane, Pane::Model(pane), kit, Game::Lua::ToBoolean(L, 3) != 0);
    return 0;
 }

@@ -0,0 +1,37 @@
+// This file is part of ClassicAPI.
+//
+// ClassicAPI is free software: you can redistribute it and/or modify it under the terms
+// of the GNU General Public License as published by the Free Software Foundation, either
+// version 3 of the License, or (at your option) any later version.
+//
+// ClassicAPI is distributed in the hope that it will be useful, but WITHOUT ANY
+// WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
+// PURPOSE. See the GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License along with
+// ClassicAPI. If not, see <https://www.gnu.org/licenses/>.
+
+#pragma once
+
+#include <cstdint>
+#include <vector>
+
+// A spell visual kit on a model in a Model frame's scene (model/VisualKit.cpp).
+namespace Model::VisualKit {
+
+// The SpellVisualKit record, or null.
+const uint8_t *Record(uint32_t kitID);
+
+// Hangs the kit's effect models on `model`, a model in `frame`'s scene, lit
+// by the frame's light, and applies its tint and alpha procedures. A oneShot
+// effect stops when its sequence ends; the others loop. When `effects` is
+// given, each attached effect model is appended to it with one reference the
+// caller then owns; otherwise the effects live as long as `model` holds them.
+void Apply(void *frame, void *model, const uint8_t *kit, bool oneShot,
+           std::vector<void *> *effects = nullptr);
+
+// The world's KitEffectLoopCallback (0x0060ED00) as a done callback: a
+// sequence that ended cleanly plays again.
+const void *LoopCallback();
+
+} // namespace Model::VisualKit
@@ -12,6 +12,7 @@
 // ClassicAPI. If not, see <https://www.gnu.org/licenses/>.

 // `C_MountJournal.GetMountFromSpell(spellID)` -> mountID | nil
+// `C_MountJournal.GetMountFromItem(itemID)` -> mountID | nil
 // `C_MountJournal.GetMountInfoExtraByID(mountID)` -> creatureDisplayInfoID,
 //     description, source, isSelfMount, mountTypeID, uiModelSceneID, animID,
 //     spellVisualKitID, disablePlayerMountPreview
@@ -26,7 +27,9 @@
 // On Turtle a mount ITEM does not carry its mount spell: every one carries
 // 46499 "Add Mount to Collection", which teaches a spell from a server-only
 // item table. So only the mount spell (spellbook, spell link) resolves; 46499
-// is not a mount. See docs/notes/model-scene.md.
+// is not a mount. See docs/notes/model-scene.md. On a stock server an item
+// is a mount when its use spell is one (retail's GetMountFromItem hop); an
+// uncached item returns nil and starts the item cache load.
 //
 // creatureDisplayInfoID is the display the server mounts the caster on: the
 // aura's misc value is a creature entry, and the server takes a display from
@@ -49,6 +52,10 @@
 #include "Game.h"
 #include "Offsets.h"
 #include "creature/Info.h"
+#include "item/Arg.h"
+#include "item/Data.h"
+#include "item/Record.h"
+#include "item/Spell.h"
 #include "spell/Arg.h"
 #include "spell/Description.h"
 #include "spell/Lookup.h"
@@ -112,6 +119,22 @@ int __fastcall Script_GetMountFromSpell(void *L) {
    return 1;
 }

+int __fastcall Script_GetMountFromItem(void *L) {
+    const int itemID = Item::Arg::ResolveItemID(L, 1);
+    if (itemID <= 0)
+        return 0;
+    const uint8_t *item = Item::PeekRecord(static_cast<uint32_t>(itemID));
+    if (item == nullptr) {
+        Item::Data::WarmCache(static_cast<uint32_t>(itemID));
+        return 0;
+    }
+    const int spellID = Item::Spell::FindOnUseSpellIDInRecord(item);
+    if (MountRecord(spellID) == nullptr)
+        return 0;
+    Game::Lua::PushNumber(L, static_cast<double>(spellID));
+    return 1;
+}
+
 int __fastcall Script_GetMountInfoExtraByID(void *L) {
    if (!Game::Lua::IsNumber(L, 1))
        return 0;
@@ -160,6 +183,18 @@ const Game::Doc::Function kGetMountFromSpell{
    "The mount a spell summons. A mount's ID is the ID of the spell that summons it.",
    kGetMountFromSpellArgs, kGetMountFromSpellRets};

+const Game::Doc::Field kGetMountFromItemArgs[] = {
+    Game::Doc::Req("itemID", "number", "An item ID or item link."),
+};
+const Game::Doc::Field kGetMountFromItemRets[] = {
+    Game::Doc::Opt("mountID", "number", nullptr,
+                   "The mount the item's use spell summons, which is that spell's ID. Nil "
+                   "when the item does not summon a mount, or while the item is not cached; "
+                   "the call starts loading it."),
+};
+const Game::Doc::Function kGetMountFromItem{
+    "The mount an item summons when used.", kGetMountFromItemArgs, kGetMountFromItemRets};
+
 const Game::Doc::Field kGetMountInfoExtraByIDArgs[] = {
    Game::Doc::Req("mountID", "number", "A mount ID, which is the mount's spell ID."),
 };
@@ -184,6 +219,8 @@ const Game::Doc::Function kGetMountInfoExtraByID{
 void RegisterLuaFunctions() {
    Game::Lua::RegisterTableFunction("C_MountJournal", "GetMountFromSpell",
                                     &Script_GetMountFromSpell, &kGetMountFromSpell);
+    Game::Lua::RegisterTableFunction("C_MountJournal", "GetMountFromItem",
+                                     &Script_GetMountFromItem, &kGetMountFromItem);
    Game::Lua::RegisterTableFunction("C_MountJournal", "GetMountInfoExtraByID",
                                     &Script_GetMountInfoExtraByID, &kGetMountInfoExtraByID);
 }
@@ -38,6 +38,7 @@
 #include "Game.h"
 #include "Offsets.h"
 #include "frame/Destruction.h"
+#include "frame/Layout.h"
 #include "scrollingmessageframe/DisplayRefreshed.h"
 #include "scrollingmessageframe/InsertMode.h"

@@ -55,7 +56,6 @@ constexpr int kInsertModeBottom = 2;
 using SetPoint_t = void(__thiscall *)(void *anchor, int point, void *relAnchor, int relPoint, float x, float y,
                                      int flag);
 using ClearAllPoints_t = void(__fastcall *)(void *anchor);
-using Resize_t = void(__fastcall *)(void *anchor, void *edx, int force);
 using PixelAlignY_t = float(__stdcall *)(float length);

 // The frames in TOP mode. Every frame is rebuilt on /reload, so the set is
@@ -64,7 +64,7 @@ std::unordered_set<void *> g_topFrames;

 bool IsTop(void *smf) { return g_topFrames.count(smf) != 0; }

-void *AnchorOf(void *region) { return static_cast<uint8_t *>(region) + Offsets::OFF_REGION_ANCHOR; }
+using Frame::Layout::Of;

 // Sets a line's anchor as the layout gives it - (BOTTOMLEFT, the frame,
 // BOTTOMLEFT, x, y) for the first line, (BOTTOMLEFT, the line before, TOPLEFT,
@@ -88,7 +88,7 @@ void SetLinePoint(void *smf, void *anchor, int point, void *relative, int relati
 // the frame.
 void __fastcall AnchorNewLine(void *anchor, void *, int point, void *relative, int relativePoint, float x, float y,
                              int flag) {
-    void *line = static_cast<uint8_t *>(anchor) - Offsets::OFF_REGION_ANCHOR;
+    void *line = Frame::Layout::OwnerOf(anchor);
    SetLinePoint(Game::Read<void *>(line, Offsets::OFF_REGION_PARENT), anchor, point, relative, relativePoint, x, y,
                 flag);
 }
@@ -104,7 +104,7 @@ void AnchorLines(void *smf) {
    const int count = Game::Read<int>(smf, Offsets::OFF_SMF_LINE_COUNT);
    for (int i = 0; i < count; ++i) {
        AnchorLine(smf, i);
-        reinterpret_cast<Resize_t>(Offsets::FUN_LAYOUT_RESIZE)(AnchorOf(LineOf(smf, i)), nullptr, 1);
+        Frame::Layout::Resize(LineOf(smf, i), true);
    }
 }

@@ -185,14 +185,14 @@ const Frame::Destruction::AutoSubscribe _destructionSub{&OnFrameDestroyed};

 void AnchorLine(void *smf, int index) {
    void *line = LineOf(smf, index);
-    void *anchor = AnchorOf(line);
+    void *anchor = Of(line);
    reinterpret_cast<ClearAllPoints_t>(Offsets::FUN_LAYOUT_CLEAR_ALL_POINTS)(anchor);
    if (index == 0)
-        SetLinePoint(smf, anchor, Offsets::FRAMEPOINT_BOTTOMLEFT, AnchorOf(smf), Offsets::FRAMEPOINT_BOTTOMLEFT,
+        SetLinePoint(smf, anchor, Offsets::FRAMEPOINT_BOTTOMLEFT, Of(smf), Offsets::FRAMEPOINT_BOTTOMLEFT,
                     Game::Read<float>(smf, Offsets::OFF_SCROLLINGMESSAGEFRAME_INSET_LEFT),
                     Game::Read<float>(smf, Offsets::OFF_SCROLLINGMESSAGEFRAME_INSET_BOTTOM), 1);
    else
-        SetLinePoint(smf, anchor, Offsets::FRAMEPOINT_BOTTOMLEFT, AnchorOf(LineOf(smf, index - 1)),
+        SetLinePoint(smf, anchor, Offsets::FRAMEPOINT_BOTTOMLEFT, Of(LineOf(smf, index - 1)),
                     Offsets::FRAMEPOINT_TOPLEFT, 0.0f,
                     reinterpret_cast<PixelAlignY_t>(Offsets::FUN_PIXEL_ALIGN_Y)(
                         Game::Read<float>(line, Offsets::OFF_FONTSTRING_SPACING)),
@@ -56,6 +56,7 @@
 #include "Game.h"
 #include "Offsets.h"
 #include "scrollingmessageframe/DisplayRefreshed.h"
+#include "storm/Memory.h"

 #include <algorithm>
 #include <cstdint>
@@ -265,8 +266,6 @@ uint32_t MessageColor(void *L, void *frame) {
 // out as before (a hidden frame's layout places nothing).
 int __fastcall Script_BackFillMessage(void *L) {
    using namespace Game::Lua;
-    using StormAlloc_t = void *(__stdcall *)(size_t size, const char *file, int line, int flags);
-    using StormFree_t = int(__stdcall *)(void *ptr, const char *file, int line, int flags);
    using Layout_t = void(__fastcall *)(void *smf, void *edx, int newestRecord);
    static const char kStormFile[] = "ClassicAPI ScrollingMessageFrame:BackFillMessage";

@@ -284,7 +283,7 @@ int __fastcall Script_BackFillMessage(void *L) {
    const uint32_t color = MessageColor(L, frame);
    const size_t bytes = std::strlen(text) + 1;
    char *copy = static_cast<char *>(
-        reinterpret_cast<StormAlloc_t>(Offsets::FUN_STORM_SMEM_ALLOC)(bytes, kStormFile, __LINE__, 0));
+        Storm::Alloc(bytes, kStormFile, __LINE__));
    if (copy == nullptr)
        return 0;
    std::memcpy(copy, text, bytes);
@@ -298,7 +297,7 @@ int __fastcall Script_BackFillMessage(void *L) {
    uint8_t *record = Game::Read<uint8_t *>(frame, Offsets::OFF_SCROLLINGMESSAGEFRAME_MESSAGES);
    char *&stored = *reinterpret_cast<char **>(record + Offsets::OFF_SCROLLINGMESSAGEFRAME_MESSAGE_TEXT);
    if (stored != nullptr)
-        reinterpret_cast<StormFree_t>(Offsets::FUN_STORM_SMEM_FREE)(stored, kStormFile, __LINE__, 0);
+        Storm::Free(stored, kStormFile, __LINE__);
    stored = copy;
    *reinterpret_cast<uint32_t *>(record + Offsets::OFF_SCROLLINGMESSAGEFRAME_MESSAGE_COLOR) = color;
    *reinterpret_cast<int *>(record + Offsets::OFF_SCROLLINGMESSAGEFRAME_MESSAGE_SHOWN) = 1;
@@ -399,7 +398,6 @@ int __fastcall Script_RemoveMessagesByPredicate(void *L) {
    using Layout_t = void(__fastcall *)(void *smf, void *edx, int newestRecord);
    using Smf_t = void(__fastcall *)(void *smf);
    using ScrollOffset_t = int(__fastcall *)(void *smf);
-    using StormFree_t = int(__stdcall *)(void *ptr, const char *file, int line, int flags);
    static const char kStormFile[] = "ClassicAPI ScrollingMessageFrame:RemoveMessagesByPredicate";

    void *frame = ResolveTypedObject(L, 1, Offsets::VAR_SCROLLINGMESSAGEFRAME_LUA_TYPE_ID);
@@ -460,7 +458,7 @@ int __fastcall Script_RemoveMessagesByPredicate(void *L) {
                uint8_t *from = records + src * Offsets::SCROLLINGMESSAGEFRAME_MESSAGE_STRIDE;
                char *&landedOn = *reinterpret_cast<char **>(to + Offsets::OFF_SCROLLINGMESSAGEFRAME_MESSAGE_TEXT);
                if (landedOn != nullptr)
-                    reinterpret_cast<StormFree_t>(Offsets::FUN_STORM_SMEM_FREE)(landedOn, kStormFile, __LINE__, 0);
+                    Storm::Free(landedOn, kStormFile, __LINE__);
                std::memcpy(to, from, Offsets::SCROLLINGMESSAGEFRAME_MESSAGE_STRIDE);
                *reinterpret_cast<char **>(from + Offsets::OFF_SCROLLINGMESSAGEFRAME_MESSAGE_TEXT) = nullptr;
                if (extras) {
@@ -45,6 +45,8 @@
 // plays on the Sound slider; a FILE on "Ambience" is exact, because
 // Play2D takes the flags whole.

+#include "sound/Play.h"
+
 #include "Game.h"
 #include "Offsets.h"
 #include "event/Custom.h"
@@ -366,13 +368,7 @@ int __fastcall Script_StopSound(void *L) {
    const auto handle = static_cast<uintptr_t>(Game::Lua::ToNumber(L, 1));
    const double fadeMs =
        Game::Lua::Type(L, 2) == Game::Lua::TYPE_NUMBER ? Game::Lua::ToNumber(L, 2) : 0.0;
-    for (const Owned &o : g_owned) {
-        if (o.handle != handle || !StillPlaying(o))
-            continue;
-        reinterpret_cast<Stop_t>(Offsets::FUN_SOUND_STOP)(
-            reinterpret_cast<void *>(handle), static_cast<float>(fadeMs * 0.001));
-        break;
-    }
+    Stop(reinterpret_cast<void *>(handle), static_cast<float>(fadeMs * 0.001));
    return 0;
 }

@@ -427,4 +423,69 @@ const Game::ModuleAutoRegister _autoreg{&RegisterLuaFunctions};

 } // namespace

+void *PlayKitID(int soundKitID) { return PlayKit(soundKitID, PlayOptions{}); }
+
+// The world's 2D loop by row (FUN_SOUND_PLAY_ENTRY_LOOPED), on the Sound
+// slider, under PlayKit's suppression rule.
+void *PlayKitLooped(int soundKitID) {
+    using PlayLooped_t = void *(__fastcall *)(int soundEntryID, char ambience, char noCategory);
+    if (soundKitID <= 0 ||
+        Game::Read<int>(static_cast<uintptr_t>(Offsets::VAR_INTERFACE_SOUND_SUPPRESS)) > 0)
+        return nullptr;
+    void *sound = reinterpret_cast<PlayLooped_t>(Offsets::FUN_SOUND_PLAY_ENTRY_LOOPED)(
+        soundKitID, 0, 0);
+    if (sound != nullptr)
+        Own(sound, false);
+    return sound;
+}
+
+static bool Quiet() { return Game::Read<int>(static_cast<uintptr_t>(Offsets::VAR_INTERFACE_SOUND_SUPPRESS)) > 0; }
+
+// The world's 3D player by row (FUN_SOUND_PLAY_ENTRY_AT), on the Sound
+// slider, under PlayKit's suppression rule.
+void *PlayKitIDAt(int soundKitID, const float (&position)[3]) {
+    using PlayAt_t = void *(__fastcall *)(bool *culled, char keep, char noCategory, int bus, int soundEntryID,
+                                          const float *pos, int variantIndex, float volumeScale);
+    if (soundKitID <= 0 || Quiet())
+        return nullptr;
+    bool culled = false;
+    void *sound = reinterpret_cast<PlayAt_t>(Offsets::FUN_SOUND_PLAY_ENTRY_AT)(&culled, 0, 0, 0, soundKitID,
+                                                                                position, kVariantRandom, 1.0f);
+    if (sound != nullptr)
+        Own(sound, false);
+    return sound;
+}
+
+// The world's 3D loop by row (FUN_SOUND_PLAY_ENTRY_LOOPED_AT).
+void *PlayKitLoopedAt(int soundKitID, const float (&position)[3]) {
+    using PlayLoopedAt_t = void *(__fastcall *)(int soundEntryID, const float *pos);
+    if (soundKitID <= 0 || Quiet())
+        return nullptr;
+    void *sound = reinterpret_cast<PlayLoopedAt_t>(Offsets::FUN_SOUND_PLAY_ENTRY_LOOPED_AT)(soundKitID, position);
+    if (sound != nullptr)
+        Own(sound, false);
+    return sound;
+}
+
+void Move(void *sound, const float (&position)[3]) {
+    using SetPosition_t = void(__thiscall *)(void *sound, const float *pos, const float *velocity);
+    const auto handle = reinterpret_cast<uintptr_t>(sound);
+    for (const Owned &o : g_owned) {
+        if (o.handle != handle || !StillPlaying(o))
+            continue;
+        reinterpret_cast<SetPosition_t>(Offsets::FUN_SOUND_SET_POSITION)(sound, position, nullptr);
+        break;
+    }
+}
+
+void Stop(void *sound, float fadeSeconds) {
+    const auto handle = reinterpret_cast<uintptr_t>(sound);
+    for (const Owned &o : g_owned) {
+        if (o.handle != handle || !StillPlaying(o))
+            continue;
+        reinterpret_cast<Stop_t>(Offsets::FUN_SOUND_STOP)(sound, fadeSeconds);
+        break;
+    }
+}
+
 } // namespace Sound::Play
@@ -0,0 +1,39 @@
+// This file is part of ClassicAPI.
+//
+// ClassicAPI is free software: you can redistribute it and/or modify it under the terms
+// of the GNU General Public License as published by the Free Software Foundation, either
+// version 3 of the License, or (at your option) any later version.
+//
+// ClassicAPI is distributed in the hope that it will be useful, but WITHOUT ANY
+// WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
+// PURPOSE. See the GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License along with
+// ClassicAPI. If not, see <https://www.gnu.org/licenses/>.
+
+#pragma once
+
+// Sounds other modules start (sound/Play.cpp). Each returns the Sound record,
+// or null when nothing played (no row, or sounds held off while the UI loads
+// or the world is entered or left). A record is only a handle: pass it to
+// Stop, never read it.
+namespace Sound::Play {
+
+// The row once, as PlaySound(soundKitID) plays it.
+void *PlayKitID(int soundKitID);
+// The row as a loop until Stop.
+void *PlayKitLooped(int soundKitID);
+// The row once at `position` (the engine's axes, as the listener's), with
+// the row's cutoff and minimum distance; null too when the position is past
+// the cutoff.
+void *PlayKitIDAt(int soundKitID, const float (&position)[3]);
+// The row as a loop at `position` until Stop.
+void *PlayKitLoopedAt(int soundKitID, const float (&position)[3]);
+// Moves a sound from PlayKitIDAt or PlayKitLoopedAt. A sound that has ended
+// is left alone.
+void Move(void *sound, const float (&position)[3]);
+// Fades a sound from PlayKitID or PlayKitLooped out over `fadeSeconds` (at
+// once below 0.1 s). A sound that has ended is left alone.
+void Stop(void *sound, float fadeSeconds);
+
+} // namespace Sound::Play
@@ -63,7 +63,7 @@ bool EngineHasRange(void *caster, int spellID) {
    float maxRange;
    EngineMinMax(caster, spellID, nullptr, minRange, maxRange);
    const float epsilon = Game::Read<float>(
-        static_cast<uintptr_t>(Offsets::VAR_HAS_RANGE_EPSILON));
+        static_cast<uintptr_t>(Offsets::VAR_TWO_POW_MINUS_22));
    return !(std::fabs(minRange) < epsilon) ||
           !(std::fabs(maxRange) < epsilon);
 }
@@ -0,0 +1,41 @@
+// This file is part of ClassicAPI.
+//
+// ClassicAPI is free software: you can redistribute it and/or modify it under the terms
+// of the GNU General Public License as published by the Free Software Foundation, either
+// version 3 of the License, or (at your option) any later version.
+//
+// ClassicAPI is distributed in the hope that it will be useful, but WITHOUT ANY
+// WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
+// PURPOSE. See the GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License along with
+// ClassicAPI. If not, see <https://www.gnu.org/licenses/>.
+
+#pragma once
+
+// Storm's heap (Offsets.h, at FUN_STORM_SMEM_ALLOC): the blocks the engine
+// allocates and frees itself. A block the engine will free must come from
+// Alloc, and a block the engine hands over is freed with Free; SMemFree
+// rejects any other pointer (ERROR #124). `file` and `line` label the block
+// in Storm's bookkeeping.
+
+#include "Offsets.h"
+
+#include <cstddef>
+
+namespace Storm {
+
+// SMemAlloc: null when out of memory.
+inline void *Alloc(size_t size, const char *file, int line, bool zeroFill = false) {
+    using Fn = void *(__stdcall *)(size_t, const char *, int, int);
+    return reinterpret_cast<Fn>(Offsets::FUN_STORM_SMEM_ALLOC)(
+        size, file, line, zeroFill ? Offsets::STORM_SMEM_FLAG_ZERO_FILL : 0);
+}
+
+// SMemFree.
+inline void Free(void *ptr, const char *file, int line) {
+    using Fn = int(__stdcall *)(void *, const char *, int, int);
+    reinterpret_cast<Fn>(Offsets::FUN_STORM_SMEM_FREE)(ptr, file, line, 0);
+}
+
+} // namespace Storm
--- a/Show More
+++ b/Show More