Merge campaign-cc6a: CC6a preview foundation + CC6b-PRE animation half, review-closed
CC6a (index->ObjDesc factory + static-pose offscreen renderer) and CC6b-PRE (idle loop, rotation, zoom, alternate-setup plumbing) both closed through dual-lens review -> fix round -> narrow re-review. The branch carries its own cross-branch renumbering (TS-84, ISSUES #403) so this merge is number-clean against the CC4 rows. Notable review outcomes carried in: the barber refutation (chargen has NO alternate-setup checkbox — all five write sites are gmBarberUI), the idle-by-default finding with its corrected InitializePage evidence, and the 180-degree initial heading owed to the mount half. Co-Authored-By: Claude Fable 5 <noreply@anthropic.com> # Conflicts: # docs/ISSUES.md # docs/architecture/retail-divergence-register.md
This commit is contained in:
Erik
commit
11374484dc
27 changed files with 4294 additions and 28 deletions
157
src/AcDream.App/Rendering/ChargenPreviewAnimator.cs
Normal file
157
src/AcDream.App/Rendering/ChargenPreviewAnimator.cs
Normal file
|
|
@ -0,0 +1,157 @@
|
|||
using System.Collections.Generic;
|
||||
using System.Numerics;
|
||||
using AcDream.Core.Physics;
|
||||
using AcDream.Core.World;
|
||||
|
||||
namespace AcDream.App.Rendering;
|
||||
|
||||
/// <summary>
|
||||
/// Owns the chargen preview's per-frame idle-loop ↔ rest-pose playback,
|
||||
/// mirroring <c>gmCG3DView::StartAnimation</c>/<c>StopAnimation</c>'s swap
|
||||
/// (<c>0x004EE600</c>/<c>0x004EE640</c>) and
|
||||
/// <c>gmCGAppearancePage::ZoomIn</c>/<c>ZoomOut</c>'s immediate call into it
|
||||
/// (<c>0x0047D024</c>/<c>0x0047D160</c> — the swap happens the instant the
|
||||
/// button is pressed, NOT once the camera's own 0.6s tween finishes).
|
||||
///
|
||||
/// <para>
|
||||
/// <b>Retail default is idle-PLAYING, not frozen</b> — see
|
||||
/// <see cref="ChargenPreviewEntityBuilder"/>'s class doc for the decomp
|
||||
/// citations. This class's own default (<see cref="IsZoomedIn"/> starts
|
||||
/// <c>false</c>) reproduces that: its constructor immediately plays the
|
||||
/// idle animation's frame 0 when one resolved, matching
|
||||
/// <c>gmCGAppearancePage::Update</c>'s own trailing
|
||||
/// <c>if (m_bZoomedIn == 0) StartAnimation()</c> gate
|
||||
/// (~0x0047EF01-0x0047EF12), which re-fires on every heritage/gender/
|
||||
/// appearance change too — <see cref="SetZoomedIn"/> restarts the idle loop
|
||||
/// at frame 0 on every transition INTO the playing state for the same
|
||||
/// reason: <c>set_sequence_animation</c>'s <c>arg3=1</c> clears the sequence
|
||||
/// before appending, so every <c>StartAnimation</c> call restarts the clip.
|
||||
/// The DEFAULT-false claim itself rests on <c>gmCGAppearancePage::InitializePage
|
||||
/// @ 0x0047FDD0</c>'s explicit <c>this->m_bZoomedIn = 0;</c> at
|
||||
/// <c>0x004802C3</c> — written immediately after that same function sets the
|
||||
/// camera to the zoomed-IN per-heritage eye (<c>0x00480286-0x0048029E</c>),
|
||||
/// not from the ctor simply never touching the field (heap <c>operator new</c>
|
||||
/// memory is indeterminate, not zero — that argument doesn't hold on its
|
||||
/// own). One retail quirk this implies: the character starts framed close-up
|
||||
/// AND not-zoomed-in at the same time, so the FIRST Zoom In click (once
|
||||
/// mounted) tweens close-eye→close-eye — visually null — while still
|
||||
/// freezing the animation; the port reproduces this faithfully rather than
|
||||
/// treating it as a bug.
|
||||
/// </para>
|
||||
///
|
||||
/// <para>
|
||||
/// The page-mount half (CC6b, after CC4 merges) wires the Zoom In/Out
|
||||
/// buttons to <see cref="SetZoomedIn"/> and the render loop to
|
||||
/// <see cref="Tick"/>; nothing in this repository calls either yet.
|
||||
/// </para>
|
||||
/// </summary>
|
||||
internal sealed class ChargenPreviewAnimator
|
||||
{
|
||||
/// <summary>
|
||||
/// <c>gmCG3DView::StartAnimation</c>'s literal framerate argument
|
||||
/// (<c>set_sequence_animation(this->m_pPlayerObject,
|
||||
/// this->m_didAnimation.id, 1, 0, 30f)</c>, pseudo-C ~0x004ee61b).
|
||||
/// </summary>
|
||||
public const float IdleFramerate = 30f;
|
||||
|
||||
private readonly ChargenPreviewAnimatedBuild _build;
|
||||
private float _currFrame;
|
||||
private bool _zoomedIn;
|
||||
|
||||
// Double-buffered so a 30fps Tick doesn't allocate a fresh List<MeshRef>
|
||||
// every frame: one buffer is whatever Entity.MeshRefs currently points
|
||||
// at (potentially still being read by the renderer's own Render() call
|
||||
// for this frame), the other is safe to Clear()+refill for the NEXT
|
||||
// tick and only gets published once fully populated.
|
||||
private readonly List<MeshRef> _meshRefsBufferA = [];
|
||||
private readonly List<MeshRef> _meshRefsBufferB = [];
|
||||
private bool _nextBufferIsA = true;
|
||||
|
||||
public ChargenPreviewAnimator(ChargenPreviewAnimatedBuild build)
|
||||
{
|
||||
_build = build ?? throw new ArgumentNullException(nameof(build));
|
||||
_currFrame = build.IdleLowFrame;
|
||||
if (build.IdleAnimation is not null)
|
||||
ApplyIdleFrame(); // retail's true default: idle playing, frame 0.
|
||||
// Else: Entity.MeshRefs already holds RestMeshRefs (set by
|
||||
// TryBuildAnimated) as the best available fallback.
|
||||
}
|
||||
|
||||
/// <summary>The live preview entity — mutated in place by <see cref="Tick"/>
|
||||
/// and <see cref="SetZoomedIn"/>; the renderer never needs to re-call
|
||||
/// <c>SetPreview</c> after the first assignment (<c>WorldEntity.MeshRefs</c>
|
||||
/// is read fresh every draw — see its own doc comment).</summary>
|
||||
public WorldEntity Entity => _build.Entity;
|
||||
|
||||
public bool IsZoomedIn => _zoomedIn;
|
||||
|
||||
/// <summary>
|
||||
/// <c>gmCGAppearancePage::ZoomIn</c>/<c>ZoomOut</c>'s
|
||||
/// <c>StopAnimation</c>/<c>StartAnimation</c> call, applied immediately
|
||||
/// (retail does not wait for the camera tween to finish before swapping
|
||||
/// animation state — see this class's own doc comment). No-op if
|
||||
/// already in the requested state, matching retail's own early-return
|
||||
/// guards (<c>ZoomIn</c>'s <c>if (m_bZoomedIn != 0) return</c>,
|
||||
/// <c>ZoomOut</c>'s mirror).
|
||||
/// </summary>
|
||||
public void SetZoomedIn(bool zoomedIn)
|
||||
{
|
||||
if (_zoomedIn == zoomedIn)
|
||||
return;
|
||||
_zoomedIn = zoomedIn;
|
||||
if (zoomedIn)
|
||||
{
|
||||
_build.Entity.MeshRefs = _build.RestMeshRefs;
|
||||
}
|
||||
else
|
||||
{
|
||||
_currFrame = _build.IdleLowFrame;
|
||||
if (_build.IdleAnimation is not null)
|
||||
ApplyIdleFrame();
|
||||
}
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Advances the idle loop by <paramref name="elapsedSeconds"/>. No-op
|
||||
/// while zoomed in (the rest pose is frozen — retail's framerate-0
|
||||
/// <c>set_sequence_animation</c> call never advances) or when no idle
|
||||
/// Animation resolved (heritage/DID gap; the entity keeps whatever pose
|
||||
/// the constructor seeded).
|
||||
/// </summary>
|
||||
public void Tick(float elapsedSeconds)
|
||||
{
|
||||
if (_zoomedIn || _build.IdleAnimation is null || elapsedSeconds <= 0f)
|
||||
return;
|
||||
|
||||
_currFrame = RetailAnimationCyclePlayback.Advance(
|
||||
_currFrame, _build.IdleLowFrame, _build.IdleHighFrame, IdleFramerate, elapsedSeconds);
|
||||
ApplyIdleFrame();
|
||||
}
|
||||
|
||||
private void ApplyIdleFrame()
|
||||
{
|
||||
DatReaderWriter.DBObjs.Animation animation = _build.IdleAnimation!;
|
||||
IReadOnlyList<ChargenPreviewDrawablePart> parts = _build.DrawableParts;
|
||||
List<MeshRef> meshRefs = _nextBufferIsA ? _meshRefsBufferA : _meshRefsBufferB;
|
||||
_nextBufferIsA = !_nextBufferIsA;
|
||||
meshRefs.Clear();
|
||||
foreach (ChargenPreviewDrawablePart part in parts)
|
||||
{
|
||||
bool resolved = RetailAnimationCyclePlayback.TryInterpolatePart(
|
||||
animation, _currFrame, _build.IdleLowFrame, _build.IdleHighFrame,
|
||||
part.SetupPartIndex, out Vector3 origin, out Quaternion orientation);
|
||||
// Same defensive default as ApplyHeldPoseTransforms: a part
|
||||
// index the bracketing frame doesn't cover (a Setup/Animation
|
||||
// part-count mismatch, never expected in practice) keeps
|
||||
// identity rather than a degenerate zero quaternion.
|
||||
if (!resolved)
|
||||
{
|
||||
origin = Vector3.Zero;
|
||||
orientation = Quaternion.Identity;
|
||||
}
|
||||
Matrix4x4 transform = RetailHeldPose.ComposePartTransform(part.DefaultScale, origin, orientation);
|
||||
meshRefs.Add(new MeshRef(part.GfxObjId, transform) { SurfaceOverrides = part.SurfaceOverrides });
|
||||
}
|
||||
_build.Entity.MeshRefs = meshRefs;
|
||||
}
|
||||
}
|
||||
185
src/AcDream.App/Rendering/ChargenPreviewCamera.cs
Normal file
185
src/AcDream.App/Rendering/ChargenPreviewCamera.cs
Normal file
|
|
@ -0,0 +1,185 @@
|
|||
using System;
|
||||
using System.Numerics;
|
||||
using AcDream.Core.CharGen;
|
||||
|
||||
namespace AcDream.App.Rendering;
|
||||
|
||||
/// <summary>
|
||||
/// Heritage-parameterized camera for the chargen 3D preview
|
||||
/// (<c>gmCG3DView</c>, Appearance page viewport <c>0x100003bb</c> / Summary
|
||||
/// <c>0x10000406</c>). Retail-exact eye positions, ported from
|
||||
/// <c>gmCGAppearancePage::Update @ 0x0047E8F0</c> (pseudo-C ~139037-139114,
|
||||
/// which sets <c>m_vectTargPosition</c>/<c>m_vectCurPosition</c> per
|
||||
/// heritage and snaps them together with no tween — CC6a's static preview
|
||||
/// renders that snapped default, the "zoomed-in" framing) and cross-checked
|
||||
/// against the IDENTICAL literals in <c>gmCGAppearancePage::ZoomIn @
|
||||
/// 0x0047CF00</c> (pseudo-C ~137618-137638). Direction is always
|
||||
/// <c>(0,0,0)</c> ⇒ <c>CreatureMode::SetCameraDirection</c> resets the view
|
||||
/// frame to IDENTITY — the SAME zero-yaw/zero-pitch convention
|
||||
/// <see cref="DollCamera"/> already established for the paperdoll (look
|
||||
/// straight down +Y, +Z up); every camera position below is used AS the
|
||||
/// world-space eye directly, matching that camera's approach.
|
||||
///
|
||||
/// <para>
|
||||
/// <b>Rotation is NOT a camera property.</b> Retail's continuous-rotation
|
||||
/// button (<c>gmCGAppearancePage::DoRotation @ 0x0047CA80</c>) advances a
|
||||
/// HEADING applied to the preview CHARACTER (<c>CPhysicsObj::set_heading</c>
|
||||
/// inside <c>gmCG3DView::Update</c>, pseudo-C ~242088) — the camera's own
|
||||
/// position/direction never change during a rotation. The heading itself
|
||||
/// lives on <see cref="ChargenPreviewRotationController"/> (CC6b: the
|
||||
/// <c>DoRotation</c>/<c>Rotate</c> port) and is applied to the entity via
|
||||
/// <c>ChargenPreviewEntityBuilder.TryBuild</c>/<c>TryBuildAnimated</c>'s
|
||||
/// <c>heading</c> parameter, not here; this class stays a fixed-per-heritage
|
||||
/// eye, exactly like retail's own camera. <see cref="ChargenPreviewZoomController"/>
|
||||
/// (CC6b: the <c>ZoomIn</c>/<c>ZoomOut</c>/<c>DoZoomAnimation</c> port) DOES
|
||||
/// mutate this class's <see cref="Eye"/> — zoom is a camera concern, unlike
|
||||
/// rotation.
|
||||
/// </para>
|
||||
/// </summary>
|
||||
public sealed class ChargenPreviewCamera : ICamera
|
||||
{
|
||||
private static readonly Vector3 Up = Vector3.UnitZ; // AC up-axis = +Z, same as DollCamera/ChaseCamera.
|
||||
|
||||
private Vector3 _eye;
|
||||
|
||||
public ChargenPreviewCamera(uint heritageId = 0u)
|
||||
{
|
||||
_eye = ResolveDefaultEye(heritageId);
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// The camera's current world-space eye. Settable so CC6b can react to a
|
||||
/// heritage change without reconstructing the camera.
|
||||
/// </summary>
|
||||
public Vector3 Eye
|
||||
{
|
||||
get => _eye;
|
||||
set => _eye = value;
|
||||
}
|
||||
|
||||
/// <summary>Re-derives <see cref="Eye"/> for the given heritage id (retail's <c>mHeritageGroup</c>).</summary>
|
||||
public void SetHeritage(uint heritageId) => _eye = ResolveDefaultEye(heritageId);
|
||||
|
||||
/// <summary>
|
||||
/// Retail default (zoomed-in) camera eye per heritage. All four profiles
|
||||
/// share <c>X=0</c>; only <c>(Y, Z)</c> — the AC world-space forward
|
||||
/// offset and height — vary. FOUR distinct profiles across the 13
|
||||
/// heritages, not five: standard heritages (Aluvian, Gharu'ndim, Sho,
|
||||
/// Viamontian, Shadowbound, Gearknight, Lugian, Empyrean, Penumbraen,
|
||||
/// Undead — everything except Tumerok/Olthoi/OlthoiAcid) share the SAME
|
||||
/// numeric offset as Gearknight's own dedicated branch in the decomp.
|
||||
/// </summary>
|
||||
public static Vector3 ResolveDefaultEye(uint heritageId) => heritageId switch
|
||||
{
|
||||
(uint)ChargenHeritageGroup.Olthoi => new Vector3(0f, -1.85000002f, 1.85000002f),
|
||||
(uint)ChargenHeritageGroup.OlthoiAcid => new Vector3(0f, -3.04999995f, 2.75f),
|
||||
(uint)ChargenHeritageGroup.Tumerok => new Vector3(0f, -0.850000024f, 1.64999998f),
|
||||
_ => new Vector3(0f, -0.550000012f, 1.64999998f),
|
||||
};
|
||||
|
||||
/// <summary>
|
||||
/// Retail zoomed-OUT camera eye per heritage
|
||||
/// (<c>gmCGAppearancePage::ZoomOut @ 0x0047D050</c>, pseudo-C
|
||||
/// ~137671-137687). CC6a does not implement the zoom button (CC6b) —
|
||||
/// recorded here as the verified target CC6b's tween will animate
|
||||
/// toward. Olthoi/OlthoiAcid each keep their own dedicated profile;
|
||||
/// every other heritage — INCLUDING Tumerok, whose zoomed-IN profile is
|
||||
/// special-cased but whose zoomed-OUT is not — shares one value.
|
||||
/// </summary>
|
||||
public static Vector3 ResolveZoomedOutEye(uint heritageId) => heritageId switch
|
||||
{
|
||||
(uint)ChargenHeritageGroup.Olthoi => new Vector3(0f, -3.79999995f, 1.14999998f),
|
||||
(uint)ChargenHeritageGroup.OlthoiAcid => new Vector3(0f, -5.69999981f, 1.64999998f),
|
||||
_ => new Vector3(0f, -2.5f, 0.95f),
|
||||
};
|
||||
|
||||
/// <summary>
|
||||
/// Seconds per 360° revolution for the continuous-rotation button
|
||||
/// (<c>gmCGAppearancePage::m_dRotationPerSec</c>, ctor pseudo-C
|
||||
/// ~137523-137524 / ~226652-226653: raw double bits low32=0x00000000,
|
||||
/// high32=0x40080000 → exactly 3.0 — the decompiler shows this cleanly,
|
||||
/// no reconstruction needed). Retail's own per-tick formula
|
||||
/// (<c>gmCGAppearancePage::DoRotation @ 0x0047CA80</c>, pseudo-C
|
||||
/// ~0x0047CAC7): <c>deltaDegrees = ((now - lastRotateTime) /
|
||||
/// RotationSecondsPerRevolution) * 360</c> — CC6b's rotation controller
|
||||
/// consumes this constant in exactly that shape, not as a
|
||||
/// degrees-per-second rate. NOT applied here; see this class's own doc
|
||||
/// comment on why rotation is not a camera concern.
|
||||
/// </summary>
|
||||
public const float RotationSecondsPerRevolution = 3.0f;
|
||||
|
||||
/// <summary>
|
||||
/// Zoom tween duration in seconds
|
||||
/// (<c>gmCGAppearancePage::DoZoomAnimation @ 0x0047C960</c>'s
|
||||
/// reset-if-invalid default, cross-confirmed by <c>ZoomIn</c>/<c>ZoomOut</c>'s
|
||||
/// own <c>-0.1</c> sentinel write, which deliberately invalidates
|
||||
/// <c>m_dAnimDuration</c> so the very next <c>DoZoomAnimation</c> tick
|
||||
/// resets it to this same value). The campaign plan flagged this
|
||||
/// constant as decompiler-garbled (both sites split the raw double
|
||||
/// across two 32-bit stores, and the decompiler mis-renders the LOW
|
||||
/// dword's store as a bogus float literal instead of raw bits) — it is
|
||||
/// NOT unrecoverable: reinterpreting each garbled float literal as its
|
||||
/// own raw 32-bit pattern and pairing it with the store's (clean) high
|
||||
/// dword reconstructs an exact IEEE-754 double both times.
|
||||
/// <c>DoZoomAnimation</c>'s own reset path: low32 from
|
||||
/// <c>4.17232506e-08f</c> reinterpreted = <c>0x33333333</c>, high32 =
|
||||
/// <c>0x3fe33333</c> (clean) → exactly <b>0.6</b>. Cross-check via
|
||||
/// <c>ZoomIn</c>/<c>ZoomOut</c>'s sentinel: low32 from
|
||||
/// <c>-1.58818684e-23f</c> reinterpreted = <c>0x9999999A</c>, high32 =
|
||||
/// <c>0xbfb99999</c> (clean) → exactly <b>-0.1</b>, the well-known
|
||||
/// IEEE-754 bit pattern for -0.1 (<c>0xBFB999999999999A</c>) — confirming
|
||||
/// the reconstruction technique itself, not just this one value.
|
||||
/// </summary>
|
||||
public const float ZoomTweenDurationSeconds = 0.6f;
|
||||
|
||||
public float FovRadians { get; set; } = MathF.PI / 4f; // retail CreatureMode default, same as DollCamera.
|
||||
public float Near { get; set; } = 0.1f;
|
||||
public float Far { get; set; } = 50f;
|
||||
public float Aspect { get; set; } = 1f;
|
||||
|
||||
public Matrix4x4 View =>
|
||||
Matrix4x4.CreateLookAt(_eye, _eye + Vector3.UnitY, Up);
|
||||
|
||||
public Matrix4x4 Projection =>
|
||||
Matrix4x4.CreatePerspectiveFieldOfView(FovRadians, Aspect <= 0f ? 1f : Aspect, Near, Far);
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Internal private-viewport adapter, mirroring <c>DollViewportCamera</c>'s
|
||||
/// role for <see cref="ChargenPreviewCamera"/>.
|
||||
/// </summary>
|
||||
internal sealed class ChargenPreviewViewportCamera : IPrivateEntityViewportCamera
|
||||
{
|
||||
private readonly ChargenPreviewCamera _camera;
|
||||
|
||||
public ChargenPreviewViewportCamera(uint heritageId = 0u)
|
||||
{
|
||||
_camera = new ChargenPreviewCamera(heritageId);
|
||||
}
|
||||
|
||||
public void SetHeritage(uint heritageId) => _camera.SetHeritage(heritageId);
|
||||
|
||||
public Vector3 Eye => _camera.Eye;
|
||||
public float FovRadians
|
||||
{
|
||||
get => _camera.FovRadians;
|
||||
set => _camera.FovRadians = value;
|
||||
}
|
||||
public float Near
|
||||
{
|
||||
get => _camera.Near;
|
||||
set => _camera.Near = value;
|
||||
}
|
||||
public float Far
|
||||
{
|
||||
get => _camera.Far;
|
||||
set => _camera.Far = value;
|
||||
}
|
||||
public float Aspect
|
||||
{
|
||||
get => _camera.Aspect;
|
||||
set => _camera.Aspect = value;
|
||||
}
|
||||
public Matrix4x4 View => _camera.View;
|
||||
public Matrix4x4 Projection => _camera.Projection;
|
||||
}
|
||||
431
src/AcDream.App/Rendering/ChargenPreviewEntityBuilder.cs
Normal file
431
src/AcDream.App/Rendering/ChargenPreviewEntityBuilder.cs
Normal file
|
|
@ -0,0 +1,431 @@
|
|||
using System.Collections.Generic;
|
||||
using System.Numerics;
|
||||
using AcDream.Content;
|
||||
using AcDream.Core.CharGen;
|
||||
using AcDream.Core.Meshing;
|
||||
using AcDream.Core.Physics;
|
||||
using AcDream.Core.World;
|
||||
using DatReaderWriter.DBObjs;
|
||||
|
||||
namespace AcDream.App.Rendering;
|
||||
|
||||
/// <summary>
|
||||
/// One resolved drawable part of the chargen preview body — a Setup part
|
||||
/// index (needed to sample <c>Animation.PartFrames[frame].Frames[index]</c>
|
||||
/// and <c>Setup.DefaultScale[index]</c>) paired with its resolved GfxObj id,
|
||||
/// default scale (captured once at build time — scale never changes across
|
||||
/// an idle cycle), and surface overrides. <see cref="ChargenPreviewAnimator"/>
|
||||
/// walks this list every tick without touching the dat source again.
|
||||
/// </summary>
|
||||
internal readonly record struct ChargenPreviewDrawablePart(
|
||||
int SetupPartIndex,
|
||||
uint GfxObjId,
|
||||
Vector3 DefaultScale,
|
||||
IReadOnlyDictionary<uint, uint>? SurfaceOverrides);
|
||||
|
||||
/// <summary>
|
||||
/// The richer sibling of <see cref="ChargenPreviewEntityBuilder.TryBuild"/>'s
|
||||
/// result: the built <see cref="WorldEntity"/> (seeded with retail's true
|
||||
/// default pose — see <see cref="ChargenPreviewAnimator"/>) plus everything
|
||||
/// needed to drive it frame-by-frame without re-touching the dat source —
|
||||
/// the resolved drawable parts, the precomputed frozen rest pose, and the
|
||||
/// resolved idle Animation + its frame range.
|
||||
/// </summary>
|
||||
internal sealed class ChargenPreviewAnimatedBuild
|
||||
{
|
||||
public required WorldEntity Entity { get; init; }
|
||||
public required IReadOnlyList<ChargenPreviewDrawablePart> DrawableParts { get; init; }
|
||||
|
||||
/// <summary>
|
||||
/// The held final-frame rest pose, precomputed once (retail:
|
||||
/// <c>gmCG3DView::StopAnimation</c>'s framerate-0
|
||||
/// <c>set_sequence_animation</c> call never advances, so there is
|
||||
/// nothing to recompute per tick while zoomed in). Falls back to each
|
||||
/// part's raw Setup-default transform (no-op) when the rest DID doesn't
|
||||
/// resolve, matching the pre-CC6b <c>ApplyHeldPose</c> no-op behavior.
|
||||
/// </summary>
|
||||
public required IReadOnlyList<MeshRef> RestMeshRefs { get; init; }
|
||||
|
||||
/// <summary>Retail's live idle DID (<c>m_didAnimation</c>), or null if unresolved.</summary>
|
||||
public Animation? IdleAnimation { get; init; }
|
||||
public int IdleLowFrame { get; init; }
|
||||
public int IdleHighFrame { get; init; }
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Builds the chargen preview <see cref="WorldEntity"/> from a
|
||||
/// <see cref="ChargenAppearanceResult"/> — the App-layer counterpart to
|
||||
/// <see cref="DollEntityBuilder"/>, except this one resolves its OWN
|
||||
/// MeshRefs from a Setup + the composed ObjDesc rather than receiving
|
||||
/// already-resolved refs from a live entity (there is no live entity yet;
|
||||
/// character creation hasn't happened). DAT-touching, unlike
|
||||
/// <see cref="DollEntityBuilder"/>'s pure index-agnostic builder — the
|
||||
/// closest existing precedent for the actual mesh-flatten/apply-changes/
|
||||
/// resolve-surface-overrides steps is
|
||||
/// <c>DatLiveEntityProjectionMaterializer.TryMaterialize</c>, trimmed to
|
||||
/// what a private, non-collision preview scene needs.
|
||||
///
|
||||
/// <para>
|
||||
/// <b>CC6b:</b> retail's chargen preview does NOT default to a frozen pose —
|
||||
/// <c>gmCGAppearancePage::Update</c>'s own trailing gate
|
||||
/// (~0x0047EF01-0x0047EF12) calls <c>gmCG3DView::StartAnimation</c> (idle
|
||||
/// loop playing) whenever <c>m_bZoomedIn == 0</c>, and that default is
|
||||
/// DIRECTLY ASSIGNED, not inherited:
|
||||
/// <c>gmCGAppearancePage::InitializePage @0x0047FDD0</c> writes an
|
||||
/// explicit <c>m_bZoomedIn = 0</c> at <c>0x004802C3</c> (right after
|
||||
/// setting the camera to the zoomed-IN per-heritage eye at
|
||||
/// <c>0x00480286-0x0048029E</c> — the null-tween quirk the zoom
|
||||
/// controller's doc records). The earlier elided-ctor-byte argument was
|
||||
/// unsound (heap-new members are indeterminate, not zero) and was
|
||||
/// replaced by this citation at the CC6b-PRE re-review. So retail's
|
||||
/// chargen preview plays its idle loop (<c>m_didAnimation</c>, 30fps) from
|
||||
/// the very first frame; the REST pose (<c>m_didAnimationRest</c>, held
|
||||
/// final frame, this class's pre-CC6b-only behavior) only appears once the
|
||||
/// user presses Zoom In (<c>gmCGAppearancePage::ZoomIn</c> calls
|
||||
/// <c>gmCG3DView::StopAnimation</c> immediately, before its camera tween
|
||||
/// even starts). <see cref="TryBuild"/> keeps its ORIGINAL (rest-only)
|
||||
/// behavior unchanged for its existing callers; <see cref="TryBuildAnimated"/>
|
||||
/// plus <see cref="ChargenPreviewAnimator"/> are the new, retail-accurate
|
||||
/// entry point a live preview (idle-playing by default, freezing on zoom-in)
|
||||
/// should use.
|
||||
/// </para>
|
||||
/// </summary>
|
||||
internal static class ChargenPreviewEntityBuilder
|
||||
{
|
||||
/// <summary>Reserved synthetic guid for the chargen preview clone —
|
||||
/// same reserved family as <see cref="DollEntityBuilder.DollServerGuid"/>
|
||||
/// (0xDA11D0xx) and <c>CreatureAppraisalEntityBuilder</c> (0xDA11D02x).</summary>
|
||||
public const uint PreviewServerGuid = 0xDA11_D031u;
|
||||
|
||||
/// <summary>Reserved render-local entity id — passed in
|
||||
/// <c>animatedEntityIds</c> by the renderer so a re-dress (a new
|
||||
/// selection) bypasses <c>WbDrawDispatcher</c>'s Tier-1 classification
|
||||
/// cache, mirroring <see cref="DollEntityBuilder.DollRenderId"/>'s own
|
||||
/// doc comment.</summary>
|
||||
public const uint PreviewRenderId = 0xDA11_D032u;
|
||||
|
||||
/// <summary>
|
||||
/// Retail's held-pose (REST) animation DID enum key, resolved through
|
||||
/// master map slot 7 exactly like <c>RetailPaperdollPoseApplicator.ResolvePoseDid</c>
|
||||
/// — 0x10000005 for every standard heritage (the SAME enum id the
|
||||
/// paperdoll's own held pose reads), matching
|
||||
/// <c>gmCG3DView</c>'s ctor / <c>::Update</c> per-heritage
|
||||
/// <c>m_didAnimationRest</c> assignment (pseudo-C ~0x004EE948,
|
||||
/// ~0x004EEC43). Olthoi and OlthoiAcid each get their OWN distinct rest
|
||||
/// DID — the one divergence from the paperdoll, which never needs an
|
||||
/// Olthoi branch because a live player can't be one.
|
||||
/// </summary>
|
||||
private static uint ResolveRestPoseEnum(uint heritageId) => heritageId switch
|
||||
{
|
||||
(uint)ChargenHeritageGroup.Olthoi => 0x10000011u,
|
||||
(uint)ChargenHeritageGroup.OlthoiAcid => 0x10000013u,
|
||||
_ => 0x10000005u,
|
||||
};
|
||||
|
||||
/// <summary>
|
||||
/// Retail's LIVE idle-loop animation DID enum key (<c>m_didAnimation</c>,
|
||||
/// the one <c>gmCG3DView::StartAnimation</c> plays at 30fps) — 0x10000006
|
||||
/// for every standard heritage, matching <c>gmCG3DView</c>'s ctor /
|
||||
/// <c>::Update</c> per-heritage assignment (pseudo-C ~0x004ee6cc,
|
||||
/// ~0x004eec2d). <b>Olthoi and OlthoiAcid use the SAME did for BOTH idle
|
||||
/// and rest</b> (0x10000011 / 0x10000013 respectively, pseudo-C
|
||||
/// ~0x004ee7e9/0x004ee7ff and ~0x004ee892/0x004ee8a8) — a genuine retail
|
||||
/// quirk, not a porting shortcut: those two heritages show no visible
|
||||
/// difference between "idle playing" and "zoomed in and frozen" in the
|
||||
/// chargen preview.
|
||||
/// </summary>
|
||||
private static uint ResolveIdleAnimEnum(uint heritageId) => heritageId switch
|
||||
{
|
||||
(uint)ChargenHeritageGroup.Olthoi => 0x10000011u,
|
||||
(uint)ChargenHeritageGroup.OlthoiAcid => 0x10000013u,
|
||||
_ => 0x10000006u,
|
||||
};
|
||||
|
||||
/// <summary>
|
||||
/// Builds the STATIC (held rest-pose) preview entity, or null when the
|
||||
/// resolved body Setup isn't in the dat source (a corrupted/incomplete
|
||||
/// install — the same failure shape
|
||||
/// <see cref="DatLiveEntityProjectionMaterializer"/> treats as "drop this
|
||||
/// spawn"). Unchanged since CC6a for its RESULT — a thin wrapper over
|
||||
/// <see cref="TryBuildAnimated"/> that returns exactly the same
|
||||
/// <c>WorldEntity</c> (rest-posed) this method's existing callers already
|
||||
/// expect; ALL 3 of those callers' tests still pass unmodified. Not
|
||||
/// byte-identical internally any more — <see cref="TryBuildAnimated"/>
|
||||
/// also resolves the idle DID and loads the idle Animation before this
|
||||
/// wrapper discards them, extra dat work the pre-CC6b method never did.
|
||||
/// New code that wants retail's true default (idle loop playing) should call
|
||||
/// <see cref="TryBuildAnimated"/> and wrap the result in a
|
||||
/// <see cref="ChargenPreviewAnimator"/> instead.
|
||||
/// </summary>
|
||||
/// <param name="datLock">
|
||||
/// Shared exclusion object for every dat read this method performs.
|
||||
/// <c>DatCollection</c> is NOT thread-safe (see
|
||||
/// <c>claude-memory/feedback_phase_a1_hotfix_saga.md</c>) — every other
|
||||
/// dat-touching renderer/resolver in this layer
|
||||
/// (<c>RetailPaperdollPoseApplicator</c>, <c>PlayerModeController</c>,
|
||||
/// <c>DatProjectileSetupResolver</c>, <c>EquippedChildRenderController</c>)
|
||||
/// takes the SAME <c>object datLock</c> the composition root threads
|
||||
/// through as <c>RuntimeOptions</c>/<c>d.DatLock</c>; callers MUST pass
|
||||
/// that same shared instance, not a private lock, or this method's reads
|
||||
/// race every other consumer's.
|
||||
/// </param>
|
||||
public static WorldEntity? TryBuild(
|
||||
IDatReaderWriter dats,
|
||||
IAnimationLoader animations,
|
||||
ChargenAppearanceResult appearance,
|
||||
uint heritageId,
|
||||
Quaternion heading,
|
||||
object datLock)
|
||||
{
|
||||
ChargenPreviewAnimatedBuild? build = TryBuildAnimated(
|
||||
dats, animations, appearance, heritageId, heading, datLock);
|
||||
if (build is null)
|
||||
return null;
|
||||
|
||||
build.Entity.MeshRefs = build.RestMeshRefs;
|
||||
return build.Entity;
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Builds the preview entity PLUS everything a <see cref="ChargenPreviewAnimator"/>
|
||||
/// needs to drive retail's idle-loop ↔ rest-pose swap without re-touching
|
||||
/// the dat source. The returned <see cref="ChargenPreviewAnimatedBuild.Entity"/>
|
||||
/// is initially posed with <see cref="ChargenPreviewAnimatedBuild.RestMeshRefs"/>
|
||||
/// (cheap, always available) — <see cref="ChargenPreviewAnimator"/>'s
|
||||
/// constructor immediately reposes it to the true retail default (idle
|
||||
/// frame 0) when an idle Animation resolved.
|
||||
/// </summary>
|
||||
public static ChargenPreviewAnimatedBuild? TryBuildAnimated(
|
||||
IDatReaderWriter dats,
|
||||
IAnimationLoader animations,
|
||||
ChargenAppearanceResult appearance,
|
||||
uint heritageId,
|
||||
Quaternion heading,
|
||||
object datLock)
|
||||
{
|
||||
ArgumentNullException.ThrowIfNull(dats);
|
||||
ArgumentNullException.ThrowIfNull(animations);
|
||||
ArgumentNullException.ThrowIfNull(appearance);
|
||||
ArgumentNullException.ThrowIfNull(datLock);
|
||||
|
||||
uint setupId = appearance.SetupId;
|
||||
List<ChargenPreviewDrawablePart> drawableParts;
|
||||
List<MeshRef> restMeshRefs;
|
||||
Animation? idleAnimation;
|
||||
int idleLowFrame = 0, idleHighFrame = -1;
|
||||
|
||||
// Every dat read this method performs — the Setup fetch, both pose
|
||||
// DID resolutions, the per-part GfxObj drawable checks, and the
|
||||
// texture-change surface resolution — happens inside this one lock,
|
||||
// mirroring RetailPaperdollPoseApplicator.Apply's "resolve
|
||||
// everything under lock, then do pure processing" shape.
|
||||
lock (datLock)
|
||||
{
|
||||
Setup? setup = dats.Get<Setup>(setupId);
|
||||
if (setup is null)
|
||||
return null;
|
||||
|
||||
var flattened = new List<MeshRef>(SetupMesh.Flatten(setup));
|
||||
|
||||
foreach (ChargenAnimPartChange change in appearance.ObjDesc.AnimPartChanges)
|
||||
{
|
||||
if (change.PartIndex < flattened.Count)
|
||||
flattened[change.PartIndex] = new MeshRef(change.PartId, flattened[change.PartIndex].PartTransform);
|
||||
}
|
||||
|
||||
// Rest pose: overwrite flattened's transforms with the held
|
||||
// final frame (no-op — keeps Setup-default transforms — if the
|
||||
// rest DID or its Animation don't resolve).
|
||||
ApplyHeldPoseTransforms(dats, animations, setup, ResolveRestPoseEnum(heritageId), flattened);
|
||||
|
||||
Dictionary<int, Dictionary<uint, uint>>? surfaceOverrides =
|
||||
ResolveSurfaceOverrides(dats, flattened, appearance.ObjDesc.TextureChanges);
|
||||
|
||||
drawableParts = new List<ChargenPreviewDrawablePart>(flattened.Count);
|
||||
restMeshRefs = new List<MeshRef>(flattened.Count);
|
||||
for (int partIndex = 0; partIndex < flattened.Count; partIndex++)
|
||||
{
|
||||
MeshRef part = flattened[partIndex];
|
||||
if (dats.Get<GfxObj>(part.GfxObjId) is null)
|
||||
continue; // matches DatLiveEntityProjectionMaterializer's drawable filter.
|
||||
|
||||
IReadOnlyDictionary<uint, uint>? overrides = null;
|
||||
if (surfaceOverrides is not null && surfaceOverrides.TryGetValue(partIndex, out var perPart))
|
||||
overrides = perPart;
|
||||
|
||||
restMeshRefs.Add(new MeshRef(part.GfxObjId, part.PartTransform) { SurfaceOverrides = overrides });
|
||||
|
||||
Vector3 defaultScale = partIndex < setup.DefaultScale.Count
|
||||
? setup.DefaultScale[partIndex]
|
||||
: Vector3.One;
|
||||
drawableParts.Add(new ChargenPreviewDrawablePart(partIndex, part.GfxObjId, defaultScale, overrides));
|
||||
}
|
||||
if (drawableParts.Count == 0)
|
||||
return null;
|
||||
|
||||
// Idle DID: independent lookup, no mutation of flattened.
|
||||
uint idleDid = RetailHeldPose.ResolvePoseDid(dats, ResolveIdleAnimEnum(heritageId));
|
||||
idleAnimation = (idleDid >> 24) == 0x03u ? animations.LoadAnimation(idleDid) : null;
|
||||
if (idleAnimation is not null && idleAnimation.PartFrames.Count > 0)
|
||||
{
|
||||
idleLowFrame = 0;
|
||||
idleHighFrame = idleAnimation.PartFrames.Count - 1;
|
||||
}
|
||||
else
|
||||
{
|
||||
idleAnimation = null;
|
||||
}
|
||||
}
|
||||
|
||||
var entity = new WorldEntity
|
||||
{
|
||||
Id = PreviewRenderId,
|
||||
ServerGuid = PreviewServerGuid,
|
||||
SourceGfxObjOrSetupId = setupId,
|
||||
Position = Vector3.Zero,
|
||||
Rotation = heading,
|
||||
MeshRefs = restMeshRefs,
|
||||
PaletteOverride = BuildPaletteOverride(appearance),
|
||||
PartOverrides = BuildPartOverrides(appearance),
|
||||
ParentCellId = null,
|
||||
};
|
||||
|
||||
return new ChargenPreviewAnimatedBuild
|
||||
{
|
||||
Entity = entity,
|
||||
DrawableParts = drawableParts,
|
||||
RestMeshRefs = restMeshRefs,
|
||||
IdleAnimation = idleAnimation,
|
||||
IdleLowFrame = idleLowFrame,
|
||||
IdleHighFrame = idleHighFrame,
|
||||
};
|
||||
}
|
||||
|
||||
/// <summary>No dat access — pure projection of the already-composed
|
||||
/// ObjDesc's subpalettes, safe to call outside <c>datLock</c>.</summary>
|
||||
private static PaletteOverride? BuildPaletteOverride(ChargenAppearanceResult appearance)
|
||||
{
|
||||
if (appearance.ObjDesc.SubPalettes.Count == 0)
|
||||
return null;
|
||||
|
||||
var ranges = new PaletteOverride.SubPaletteRange[appearance.ObjDesc.SubPalettes.Count];
|
||||
for (int i = 0; i < appearance.ObjDesc.SubPalettes.Count; i++)
|
||||
{
|
||||
ChargenSubPalette sub = appearance.ObjDesc.SubPalettes[i];
|
||||
ranges[i] = new PaletteOverride.SubPaletteRange(sub.SubPaletteId, sub.Offset, sub.NumColors);
|
||||
}
|
||||
return new PaletteOverride(appearance.BasePaletteId, ranges);
|
||||
}
|
||||
|
||||
/// <summary>No dat access — pure projection, safe to call outside
|
||||
/// <c>datLock</c>.</summary>
|
||||
private static PartOverride[] BuildPartOverrides(ChargenAppearanceResult appearance)
|
||||
{
|
||||
var partOverrides = new PartOverride[appearance.ObjDesc.AnimPartChanges.Count];
|
||||
for (int i = 0; i < appearance.ObjDesc.AnimPartChanges.Count; i++)
|
||||
{
|
||||
ChargenAnimPartChange change = appearance.ObjDesc.AnimPartChanges[i];
|
||||
partOverrides[i] = new PartOverride(change.PartIndex, change.PartId);
|
||||
}
|
||||
return partOverrides;
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Overwrites every part's transform from the resolved pose DID's FINAL
|
||||
/// frame — same "hold the settled last frame at zero frame rate"
|
||||
/// approach as <c>RetailPaperdollPoseApplicator.Apply</c>
|
||||
/// (<c>RedressCreature @ 0x004A3C22</c>), applied to the FULL
|
||||
/// setup-part-indexed array (before drawable filtering) so the index
|
||||
/// alignment holds even if a later part turns out to have a missing
|
||||
/// GfxObj. No-ops (keeps the default placement frame) when the pose
|
||||
/// DID or its animation can't be resolved.
|
||||
/// </summary>
|
||||
private static void ApplyHeldPoseTransforms(
|
||||
IDatReaderWriter dats,
|
||||
IAnimationLoader animations,
|
||||
Setup setup,
|
||||
uint poseEnum,
|
||||
List<MeshRef> flattened)
|
||||
{
|
||||
uint poseDid = RetailHeldPose.ResolvePoseDid(dats, poseEnum);
|
||||
if ((poseDid >> 24) != 0x03u)
|
||||
return;
|
||||
|
||||
Animation? animation = animations.LoadAnimation(poseDid);
|
||||
if (animation is null || animation.PartFrames.Count == 0)
|
||||
return;
|
||||
|
||||
var frame = animation.PartFrames[^1];
|
||||
for (int index = 0; index < flattened.Count; index++)
|
||||
{
|
||||
Vector3 scale = index < setup.DefaultScale.Count ? setup.DefaultScale[index] : Vector3.One;
|
||||
Vector3 origin = Vector3.Zero;
|
||||
Quaternion orientation = Quaternion.Identity;
|
||||
if (index < frame.Frames.Count)
|
||||
{
|
||||
origin = frame.Frames[index].Origin;
|
||||
orientation = frame.Frames[index].Orientation;
|
||||
}
|
||||
|
||||
flattened[index] = new MeshRef(
|
||||
flattened[index].GfxObjId,
|
||||
RetailHeldPose.ComposePartTransform(scale, origin, orientation));
|
||||
}
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Part-index → (old texture id → new texture id) resolution, verbatim
|
||||
/// port of <c>DatLiveEntityProjectionMaterializer.ResolveSurfaceOverrides</c>'s
|
||||
/// algorithm against <see cref="ChargenTextureChange"/> instead of the
|
||||
/// wire's <c>CreateObject.TextureChange</c>.
|
||||
/// </summary>
|
||||
private static Dictionary<int, Dictionary<uint, uint>>? ResolveSurfaceOverrides(
|
||||
IDatReaderWriter dats,
|
||||
IReadOnlyList<MeshRef> parts,
|
||||
IReadOnlyList<ChargenTextureChange> textureChanges)
|
||||
{
|
||||
if (textureChanges.Count == 0)
|
||||
return null;
|
||||
|
||||
var oldToNewByPart = new Dictionary<int, Dictionary<uint, uint>>();
|
||||
foreach (ChargenTextureChange change in textureChanges)
|
||||
{
|
||||
if (!oldToNewByPart.TryGetValue(change.PartIndex, out var oldToNew))
|
||||
{
|
||||
oldToNew = [];
|
||||
oldToNewByPart.Add(change.PartIndex, oldToNew);
|
||||
}
|
||||
oldToNew[change.OldTextureId] = change.NewTextureId;
|
||||
}
|
||||
|
||||
var result = new Dictionary<int, Dictionary<uint, uint>>();
|
||||
for (int partIndex = 0; partIndex < parts.Count; partIndex++)
|
||||
{
|
||||
if (!oldToNewByPart.TryGetValue(partIndex, out var oldToNew))
|
||||
continue;
|
||||
|
||||
GfxObj? gfx = dats.Get<GfxObj>(parts[partIndex].GfxObjId);
|
||||
if (gfx is null)
|
||||
continue;
|
||||
|
||||
Dictionary<uint, uint>? resolved = null;
|
||||
foreach (var surfaceQid in gfx.Surfaces)
|
||||
{
|
||||
uint surfaceId = (uint)surfaceQid;
|
||||
Surface? surface = dats.Get<Surface>(surfaceId);
|
||||
if (surface is null)
|
||||
continue;
|
||||
uint originalTexture = (uint)surface.OrigTextureId;
|
||||
if (originalTexture == 0 || !oldToNew.TryGetValue(originalTexture, out uint newTexture))
|
||||
continue;
|
||||
|
||||
(resolved ??= [])[surfaceId] = newTexture;
|
||||
}
|
||||
|
||||
if (resolved is not null)
|
||||
result[partIndex] = resolved;
|
||||
}
|
||||
|
||||
return result.Count == 0 ? null : result;
|
||||
}
|
||||
}
|
||||
90
src/AcDream.App/Rendering/ChargenPreviewRenderer.cs
Normal file
90
src/AcDream.App/Rendering/ChargenPreviewRenderer.cs
Normal file
|
|
@ -0,0 +1,90 @@
|
|||
using AcDream.App.Rendering.Wb;
|
||||
using AcDream.App.UI;
|
||||
using AcDream.Core.Lighting;
|
||||
using AcDream.Core.World;
|
||||
|
||||
namespace AcDream.App.Rendering;
|
||||
|
||||
/// <summary>
|
||||
/// Chargen-specific facade over the shared private creature viewport
|
||||
/// (<see cref="PrivateEntityViewportRenderer"/>) — CC6a's foundation half of
|
||||
/// the campaign plan's "chargen preview renderer" deliverable. Mirrors
|
||||
/// <see cref="PaperdollViewportRenderer"/>'s shape exactly, with a
|
||||
/// heading-capable <see cref="ChargenPreviewViewportCamera"/> in place of the
|
||||
/// paperdoll's fixed one.
|
||||
///
|
||||
/// <para>
|
||||
/// <b>NOT wired here (CC6b page-mount half, after CC4 merges per the
|
||||
/// campaign's parallelism contract):</b> mounting into the authored
|
||||
/// Appearance/Summary viewport ids (<c>0x100003bb</c> / <c>0x10000406</c>)
|
||||
/// and binding the spin/color-wheel/rotate/zoom widgets to
|
||||
/// <see cref="ChargenPreviewAnimator"/>/<see cref="ChargenPreviewRotationController"/>/
|
||||
/// <see cref="ChargenPreviewZoomController"/>. This class is a standalone,
|
||||
/// composition-root-agnostic renderer — nothing in
|
||||
/// <c>AcDream.App/UI/Layout/</c> or <c>RetailUiRuntime.cs</c> references it
|
||||
/// yet.
|
||||
/// </para>
|
||||
///
|
||||
/// <para>
|
||||
/// <b>CC6b (pre-mount half):</b> the preview now HAS a real live idle loop
|
||||
/// (<see cref="ChargenPreviewAnimator"/>, retail's <c>m_didAnimation</c> DID
|
||||
/// at 30fps via <c>set_sequence_animation</c>) instead of the CC6a-only held
|
||||
/// rest pose — TS-83 is retired. <see cref="SetPreview"/> still accepts a
|
||||
/// static <c>WorldEntity</c> for callers that only want
|
||||
/// <c>ChargenPreviewEntityBuilder.TryBuild</c>'s unchanged rest-pose
|
||||
/// snapshot; a caller that wants the animated preview constructs a
|
||||
/// <see cref="ChargenPreviewAnimator"/> from
|
||||
/// <c>ChargenPreviewEntityBuilder.TryBuildAnimated</c> and passes its
|
||||
/// <c>Entity</c> here once — the animator mutates that SAME entity's
|
||||
/// <c>MeshRefs</c> in place every <c>Tick</c>, and <c>Render</c> reads it
|
||||
/// fresh (no re-<c>SetPreview</c> needed per frame; see
|
||||
/// <c>WorldEntity.MeshRefs</c>'s own "mutable so the animation tick can
|
||||
/// replace it each frame" doc comment).
|
||||
/// </para>
|
||||
/// </summary>
|
||||
internal sealed class ChargenPreviewRenderer :
|
||||
IUiViewportRenderer,
|
||||
IDisposable
|
||||
{
|
||||
private readonly PrivateEntityViewportRenderer _renderer;
|
||||
private readonly ChargenPreviewViewportCamera _camera;
|
||||
|
||||
internal ChargenPreviewRenderer(
|
||||
IWorldPassScope scope,
|
||||
AcDream.App.Rendering.Gpu.IGpuDevice device,
|
||||
ICurrentGpuFrameSource frames,
|
||||
WbDrawDispatcher dispatcher,
|
||||
SceneLightingUboBinding lightUbo,
|
||||
IEntityTextureLifetime textureLifetime,
|
||||
IWbMeshAdapter meshAdapter,
|
||||
uint heritageId = 0u)
|
||||
{
|
||||
_camera = new ChargenPreviewViewportCamera(heritageId);
|
||||
_renderer = new PrivateEntityViewportRenderer(
|
||||
scope,
|
||||
device,
|
||||
frames,
|
||||
dispatcher,
|
||||
lightUbo,
|
||||
textureLifetime,
|
||||
meshAdapter,
|
||||
ChargenPreviewEntityBuilder.PreviewRenderId,
|
||||
_camera,
|
||||
"chargen preview");
|
||||
}
|
||||
|
||||
public bool TextureIsBottomUp => _renderer.TextureIsBottomUp;
|
||||
|
||||
/// <summary>
|
||||
/// Re-derives the fixed per-heritage camera eye
|
||||
/// (<see cref="ChargenPreviewCamera.ResolveDefaultEye"/>) — call whenever
|
||||
/// the selected heritage changes, BEFORE the next <see cref="Render"/>.
|
||||
/// </summary>
|
||||
public void SetHeritage(uint heritageId) => _camera.SetHeritage(heritageId);
|
||||
|
||||
public void SetPreview(WorldEntity? entity) => _renderer.SetEntity(entity);
|
||||
|
||||
public uint Render(int width, int height) => _renderer.Render(width, height);
|
||||
|
||||
public void Dispose() => _renderer.Dispose();
|
||||
}
|
||||
126
src/AcDream.App/Rendering/ChargenPreviewRotationController.cs
Normal file
126
src/AcDream.App/Rendering/ChargenPreviewRotationController.cs
Normal file
|
|
@ -0,0 +1,126 @@
|
|||
using System.Numerics;
|
||||
using AcDream.Core.Physics.Motion;
|
||||
|
||||
namespace AcDream.App.Rendering;
|
||||
|
||||
/// <summary>
|
||||
/// Retail's toggle direction enum
|
||||
/// (<c>gmBarberUI::ERotateDirection</c>/<c>gmCGAppearancePage::ERotateDirection</c>
|
||||
/// typedef alias, <c>acclient.h:6848-6852,6960</c>): <c>Invalid=0</c>,
|
||||
/// <c>Clockwise=1</c>, <c>CounterClockwise=2</c>.
|
||||
/// </summary>
|
||||
internal enum ChargenRotateDirection
|
||||
{
|
||||
Invalid = 0,
|
||||
Clockwise = 1,
|
||||
CounterClockwise = 2,
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Presentation-free port of <c>gmCGAppearancePage::Rotate</c>
|
||||
/// (<c>0x0047CB50</c>) + <c>DoRotation</c> (<c>0x0047CA80</c>) — the
|
||||
/// button-toggled continuous rotation retail applies to the preview
|
||||
/// CHARACTER's heading (<c>CPhysicsObj::set_heading</c> inside
|
||||
/// <c>gmCG3DView::Update</c>, pseudo-C ~0x0047eecf1), not the camera (see
|
||||
/// <see cref="ChargenPreviewCamera"/>'s own doc comment on why rotation
|
||||
/// lives here instead). Retail drives <see cref="Tick"/> once per frame from
|
||||
/// a global-message-3 tick while <see cref="IsRotating"/> is set
|
||||
/// (<c>gmCGAppearancePage::ListenToGlobalMessage @ 0x0047CED0</c>); the
|
||||
/// CC6b page-mount half will bind the Rotate Clockwise/Counter-Clockwise
|
||||
/// buttons to <see cref="Toggle"/> and the render loop to <see cref="Tick"/>.
|
||||
/// </summary>
|
||||
internal sealed class ChargenPreviewRotationController
|
||||
{
|
||||
/// <summary>
|
||||
/// <c>Rotate</c>'s explicit sentinel write
|
||||
/// (<c>this->m_dLastRotateTime = -1.0</c>, pseudo-C ~0x0047cba7/0x0047cbb1
|
||||
/// — the high dword <c>0xbff00000</c> paired with a zero low dword is the
|
||||
/// exact IEEE-754 bit pattern for <c>-1.0</c>) — invalidates the
|
||||
/// timestamp so the very next <see cref="Tick"/> resets it to "now"
|
||||
/// (a zero-length first delta) instead of computing a huge jump from a
|
||||
/// stale or never-set value.
|
||||
/// </summary>
|
||||
private const double InvalidTimeSentinel = -1.0;
|
||||
|
||||
private double _lastRotateTime = InvalidTimeSentinel;
|
||||
private ChargenRotateDirection _direction = ChargenRotateDirection.Invalid;
|
||||
private bool _rotating;
|
||||
|
||||
public bool IsRotating => _rotating;
|
||||
public ChargenRotateDirection Direction => _direction;
|
||||
|
||||
/// <summary>Retail's <c>m_fCurHeading</c>, degrees, ctor default 0 —
|
||||
/// applied to the preview entity via <c>MoveToMath.SetHeading</c>
|
||||
/// (<c>CPhysicsObj::set_heading</c>'s exact port).</summary>
|
||||
public float HeadingDegrees { get; private set; }
|
||||
|
||||
/// <summary>
|
||||
/// <c>gmCGAppearancePage::Rotate @ 0x0047CB50</c>: pressing the SAME
|
||||
/// direction a second time while already rotating STOPS rotation
|
||||
/// (retail's button-toggle UX); any other press (opposite direction, or
|
||||
/// starting from stopped) sets that direction and (re)starts,
|
||||
/// invalidating <c>m_dLastRotateTime</c> per this class's own sentinel
|
||||
/// doc.
|
||||
/// </summary>
|
||||
public void Toggle(ChargenRotateDirection direction)
|
||||
{
|
||||
if (_rotating && direction == _direction)
|
||||
{
|
||||
_rotating = false;
|
||||
return;
|
||||
}
|
||||
_direction = direction;
|
||||
_lastRotateTime = InvalidTimeSentinel;
|
||||
_rotating = true;
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// <c>gmCGAppearancePage::DoRotation @ 0x0047CA80</c>: per-tick
|
||||
/// <c>deltaDegrees = ((now - lastRotateTime) / RotationSecondsPerRevolution)
|
||||
/// * 360</c>, added for <see cref="ChargenRotateDirection.Clockwise"/>
|
||||
/// and subtracted for every other direction (pseudo-C ~0x0047cacd:
|
||||
/// <c>if (m_eRotateDir != ECG_ROTATE_CLOCKWISE) heading -= delta; else
|
||||
/// heading += delta;</c>), then a SINGLE-PASS clamp back into
|
||||
/// <c>[0, 360)</c> — not a full modulo loop; retail's own tail only
|
||||
/// adds/subtracts 360 once (pseudo-C ~0x0047caf3-0x0047cb31), which is
|
||||
/// exactly enough for any realistic per-frame delta and is reproduced
|
||||
/// here verbatim rather than "improved" into a `%=`. Fix round F3: Binary
|
||||
/// Ninja literally renders <c>x87_r7_1 = x87_r6_3</c> at <c>0x0047CAEB</c>
|
||||
/// inside the counter-clockwise branch — reassigning the local that held
|
||||
/// the "now" timestamp to the just-computed delta-degrees value — which
|
||||
/// would make the <c>0x0047CB3D</c> store into <c>m_dLastRotateTime</c>
|
||||
/// write delta-degrees instead of the timestamp for CCW only; that is an
|
||||
/// x87-FPU-stack modeling artifact of the decompiler, not real retail
|
||||
/// behavior (a shipped feature where every counter-clockwise rotation
|
||||
/// visibly diverges from clockwise is implausible, and
|
||||
/// <c>claude-memory/feedback_bn_decomp_field_names.md</c> names exactly
|
||||
/// this x87-stack-register mislabeling as a known decompiler artifact
|
||||
/// class), so this port stores <c>now</c> into <c>_lastRotateTime</c>
|
||||
/// unconditionally in BOTH directions.
|
||||
/// </summary>
|
||||
public void Tick(double now)
|
||||
{
|
||||
if (!_rotating)
|
||||
return;
|
||||
if (_lastRotateTime <= 0d)
|
||||
_lastRotateTime = now;
|
||||
|
||||
double deltaDegrees = ((now - _lastRotateTime) / ChargenPreviewCamera.RotationSecondsPerRevolution) * 360.0;
|
||||
HeadingDegrees = _direction == ChargenRotateDirection.Clockwise
|
||||
? HeadingDegrees + (float)deltaDegrees
|
||||
: HeadingDegrees - (float)deltaDegrees;
|
||||
|
||||
if (HeadingDegrees < 0f)
|
||||
HeadingDegrees += 360f;
|
||||
if (HeadingDegrees > 360f)
|
||||
HeadingDegrees -= 360f;
|
||||
|
||||
_lastRotateTime = now;
|
||||
}
|
||||
|
||||
/// <summary><c>CPhysicsObj::set_heading</c>'s exact quaternion
|
||||
/// construction — the SAME shared Core primitive retail movement already
|
||||
/// ports (<see cref="MoveToMath.SetHeading"/>).</summary>
|
||||
public Quaternion ToOrientation() =>
|
||||
MoveToMath.SetHeading(Quaternion.Identity, HeadingDegrees);
|
||||
}
|
||||
162
src/AcDream.App/Rendering/ChargenPreviewZoomController.cs
Normal file
162
src/AcDream.App/Rendering/ChargenPreviewZoomController.cs
Normal file
|
|
@ -0,0 +1,162 @@
|
|||
using System.Numerics;
|
||||
|
||||
namespace AcDream.App.Rendering;
|
||||
|
||||
/// <summary>
|
||||
/// Presentation-free port of <c>gmCGAppearancePage::ZoomIn</c>/<c>ZoomOut</c>
|
||||
/// (<c>0x0047CF00</c>/<c>0x0047D050</c>) and <c>DoZoomAnimation</c>
|
||||
/// (<c>0x0047C960</c>): a linear 0.6s tween of the preview camera's eye
|
||||
/// between <see cref="ChargenPreviewCamera.ResolveDefaultEye"/> (zoomed IN)
|
||||
/// and <see cref="ChargenPreviewCamera.ResolveZoomedOutEye"/> (zoomed OUT),
|
||||
/// driving the SAME <see cref="ChargenPreviewAnimator"/> zoom-state swap the
|
||||
/// button presses trigger in retail — immediately, not once the tween
|
||||
/// finishes (see <see cref="ChargenPreviewAnimator"/>'s own doc comment).
|
||||
///
|
||||
/// <para>
|
||||
/// <b>One owner of the zoom state (fix round F2):</b> retail's
|
||||
/// <c>m_bZoomedIn</c> is a SINGLE field on <c>gmCGAppearancePage</c> that
|
||||
/// gates both the camera target AND the animation swap — there is no way
|
||||
/// for retail's own camera and animation to disagree about which zoom state
|
||||
/// they're in. The first cut of this port kept two independent bools (one
|
||||
/// here, one on <see cref="ChargenPreviewAnimator"/>) synced only by
|
||||
/// <see cref="ZoomIn"/>/<see cref="ZoomOut"/> calling a NULLABLE animator
|
||||
/// parameter — a null pass, or any direct
|
||||
/// <see cref="ChargenPreviewAnimator.SetZoomedIn"/> call bypassing this
|
||||
/// controller, would desync the camera's target from the animation's pose.
|
||||
/// This class now takes its <see cref="ChargenPreviewAnimator"/> as a
|
||||
/// REQUIRED constructor dependency and <see cref="IsZoomedIn"/> reads
|
||||
/// straight through to <see cref="ChargenPreviewAnimator.IsZoomedIn"/> — the
|
||||
/// animator is the sole state owner, matching retail's own single-field
|
||||
/// design, and there is no longer a second bool that could disagree with it.
|
||||
/// </para>
|
||||
///
|
||||
/// <para>
|
||||
/// Retail drives <see cref="Tick"/> once per frame from a global-message-3
|
||||
/// tick while <c>m_bShouldZoomAnimate</c> is set
|
||||
/// (<c>gmCGAppearancePage::ListenToGlobalMessage @ 0x0047CED0</c>); the
|
||||
/// CC6b page-mount half will bind the Zoom In/Out buttons to
|
||||
/// <see cref="ZoomIn"/>/<see cref="ZoomOut"/> and the render loop to
|
||||
/// <see cref="Tick"/>. Direction is always <c>(0,0,0)</c> for this camera
|
||||
/// (see <see cref="ChargenPreviewCamera"/>'s own remarks), so only the eye
|
||||
/// position tweens — retail's own <c>m_vectCurDirection</c> lerp is a no-op
|
||||
/// here and is not reproduced.
|
||||
/// </para>
|
||||
/// </summary>
|
||||
internal sealed class ChargenPreviewZoomController
|
||||
{
|
||||
/// <summary>
|
||||
/// <c>ZoomIn</c>/<c>ZoomOut</c>'s explicit invalidation write
|
||||
/// (<c>this->m_dAnimDuration = -0.1</c>, pseudo-C ~0x0047cff1/0x0047cffb
|
||||
/// and ~0x0047d12c/0x0047d136 — the exact IEEE-754 bit pattern for
|
||||
/// <c>-0.1</c>) so the very next <see cref="Tick"/> resets the duration
|
||||
/// to <see cref="ChargenPreviewCamera.ZoomTweenDurationSeconds"/> and the
|
||||
/// start time to "now", matching <c>DoZoomAnimation</c>'s own
|
||||
/// reset-if-invalid guard exactly.
|
||||
/// </summary>
|
||||
private const double InvalidDurationSentinel = -0.1;
|
||||
|
||||
private readonly uint _heritageId;
|
||||
private readonly ChargenPreviewAnimator _animator;
|
||||
private Vector3 _startEye;
|
||||
private Vector3 _targetEye;
|
||||
private double _animStartTime;
|
||||
private double _animDuration;
|
||||
private bool _shouldAnimate;
|
||||
|
||||
public ChargenPreviewZoomController(uint heritageId, ChargenPreviewCamera camera, ChargenPreviewAnimator animator)
|
||||
{
|
||||
ArgumentNullException.ThrowIfNull(camera);
|
||||
ArgumentNullException.ThrowIfNull(animator);
|
||||
_heritageId = heritageId;
|
||||
Camera = camera;
|
||||
_animator = animator;
|
||||
}
|
||||
|
||||
public ChargenPreviewCamera Camera { get; }
|
||||
|
||||
/// <summary>
|
||||
/// Mirrors retail's <c>m_bZoomedIn</c> — a straight read-through to
|
||||
/// <see cref="ChargenPreviewAnimator.IsZoomedIn"/> (see this class's own
|
||||
/// "one owner" doc above), which itself defaults false per
|
||||
/// <c>gmCGAppearancePage::InitializePage @ 0x0047FDD0</c>'s explicit
|
||||
/// <c>this->m_bZoomedIn = 0;</c> at <c>0x004802C3</c> — written right
|
||||
/// after that same function points the camera at the zoomed-IN
|
||||
/// per-heritage eye (<c>0x00480286-0x0048029E</c>). One retail quirk
|
||||
/// this produces: the character starts framed close-up while
|
||||
/// NOT-zoomed-in, so the first Zoom In click (once mounted) tweens
|
||||
/// close-eye→close-eye — visually null — while still freezing the
|
||||
/// animation; this port reproduces it faithfully.
|
||||
/// </summary>
|
||||
public bool IsZoomedIn => _animator.IsZoomedIn;
|
||||
|
||||
/// <summary>
|
||||
/// <c>gmCGAppearancePage::ZoomIn @ 0x0047CF00</c>: no-op if already
|
||||
/// zoomed in (retail's own early-return guard). Otherwise starts a tween
|
||||
/// from the camera's CURRENT eye to the default (zoomed-IN) per-heritage
|
||||
/// profile and swaps the animator to the frozen rest pose IMMEDIATELY
|
||||
/// (<c>gmCG3DView::StopAnimation</c>'s call site, pseudo-C ~0x0047d024,
|
||||
/// precedes the tween's own completion by definition — it runs once,
|
||||
/// synchronously, inside <c>ZoomIn</c> itself).
|
||||
/// </summary>
|
||||
public void ZoomIn()
|
||||
{
|
||||
if (IsZoomedIn)
|
||||
return;
|
||||
StartTween(ChargenPreviewCamera.ResolveDefaultEye(_heritageId));
|
||||
_animator.SetZoomedIn(true);
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// <c>gmCGAppearancePage::ZoomOut @ 0x0047D050</c>: no-op if not
|
||||
/// currently zoomed in. Otherwise starts a tween toward the zoomed-OUT
|
||||
/// per-heritage profile and swaps the animator back to the playing idle
|
||||
/// loop immediately, mirroring <see cref="ZoomIn"/>.
|
||||
/// </summary>
|
||||
public void ZoomOut()
|
||||
{
|
||||
if (!IsZoomedIn)
|
||||
return;
|
||||
StartTween(ChargenPreviewCamera.ResolveZoomedOutEye(_heritageId));
|
||||
_animator.SetZoomedIn(false);
|
||||
}
|
||||
|
||||
private void StartTween(Vector3 targetEye)
|
||||
{
|
||||
_startEye = Camera.Eye;
|
||||
_targetEye = targetEye;
|
||||
_shouldAnimate = true;
|
||||
_animDuration = InvalidDurationSentinel;
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// <c>gmCGAppearancePage::DoZoomAnimation @ 0x0047C960</c>: a LINEAR
|
||||
/// (not eased) lerp of the eye position from <c>m_vectStartPosition</c>
|
||||
/// to <c>m_vectTargPosition</c> over
|
||||
/// <see cref="ChargenPreviewCamera.ZoomTweenDurationSeconds"/>, clamping
|
||||
/// <c>t</c> to exactly 1.0 (and clearing <c>m_bShouldZoomAnimate</c>) the
|
||||
/// tick that reaches or passes the duration — the decomp shows a
|
||||
/// straight <c>(targ - start) * t + start</c> per axis with no easing
|
||||
/// curve applied anywhere in this function.
|
||||
/// </summary>
|
||||
public void Tick(double now)
|
||||
{
|
||||
if (!_shouldAnimate)
|
||||
return;
|
||||
|
||||
if (_animDuration <= 0d)
|
||||
{
|
||||
_animDuration = ChargenPreviewCamera.ZoomTweenDurationSeconds;
|
||||
_animStartTime = now;
|
||||
}
|
||||
|
||||
double elapsed = now - _animStartTime;
|
||||
if (elapsed >= _animDuration)
|
||||
{
|
||||
_shouldAnimate = false;
|
||||
elapsed = _animDuration;
|
||||
}
|
||||
|
||||
float t = (float)(elapsed / _animDuration);
|
||||
Camera.Eye = Vector3.Lerp(_startEye, _targetEye, t);
|
||||
}
|
||||
}
|
||||
|
|
@ -335,29 +335,11 @@ internal sealed class RetailPaperdollPoseApplicator : IPaperdollPoseApplicator
|
|||
|
||||
/// <summary>
|
||||
/// Retail <c>gmPaperDollUI</c> resolves its held pose with
|
||||
/// <c>DBCache::GetDIDFromEnumStatic(0x10000005, 7)</c>. The master map
|
||||
/// therefore resolves key 7 to a sub-map, then key 0x10000005 to the
|
||||
/// Animation DID.
|
||||
/// <c>DBCache::GetDIDFromEnumStatic(0x10000005, 7)</c> —
|
||||
/// <see cref="RetailHeldPose.ResolvePoseDid"/> parameterized by the
|
||||
/// paperdoll's own fixed enum key.
|
||||
/// </summary>
|
||||
private uint ResolvePoseDid()
|
||||
{
|
||||
uint masterDid = (uint)_dats.Portal.Db.Header.MasterMapId;
|
||||
if (masterDid == 0
|
||||
|| !_dats.Portal.TryGet<DatReaderWriter.DBObjs.EnumIDMap>(
|
||||
masterDid,
|
||||
out var master)
|
||||
|| !master.ClientEnumToID.TryGetValue(7u, out uint subDid)
|
||||
|| !_dats.Portal.TryGet<DatReaderWriter.DBObjs.EnumIDMap>(
|
||||
subDid,
|
||||
out var sub))
|
||||
{
|
||||
return 0u;
|
||||
}
|
||||
|
||||
return sub.ClientEnumToID.TryGetValue(0x10000005u, out uint did)
|
||||
? did
|
||||
: 0u;
|
||||
}
|
||||
private uint ResolvePoseDid() => RetailHeldPose.ResolvePoseDid(_dats, 0x10000005u);
|
||||
|
||||
public void Apply(WorldEntity doll, uint setupId)
|
||||
{
|
||||
|
|
@ -392,9 +374,7 @@ internal sealed class RetailPaperdollPoseApplicator : IPaperdollPoseApplicator
|
|||
orientation = frame.Frames[index].Orientation;
|
||||
}
|
||||
|
||||
Matrix4x4 transform = Matrix4x4.CreateScale(scale)
|
||||
* Matrix4x4.CreateFromQuaternion(orientation)
|
||||
* Matrix4x4.CreateTranslation(origin);
|
||||
Matrix4x4 transform = RetailHeldPose.ComposePartTransform(scale, origin, orientation);
|
||||
MeshRef source = doll.MeshRefs[index];
|
||||
reposed.Add(new MeshRef(source.GfxObjId, transform)
|
||||
{
|
||||
|
|
|
|||
61
src/AcDream.App/Rendering/RetailHeldPose.cs
Normal file
61
src/AcDream.App/Rendering/RetailHeldPose.cs
Normal file
|
|
@ -0,0 +1,61 @@
|
|||
using System.Numerics;
|
||||
using AcDream.Content;
|
||||
using DatReaderWriter;
|
||||
using DatReaderWriter.DBObjs;
|
||||
|
||||
namespace AcDream.App.Rendering;
|
||||
|
||||
/// <summary>
|
||||
/// Shared primitives behind retail's "resolve a rest-pose DID via master-map
|
||||
/// slot 7, load its Animation, hold the final frame" algorithm — the
|
||||
/// mechanism <see cref="RetailPaperdollPoseApplicator"/> (paperdoll,
|
||||
/// <c>gmPaperDollUI::RedressCreature @ 0x004A3C22</c>) and
|
||||
/// <see cref="ChargenPreviewEntityBuilder"/> (chargen preview,
|
||||
/// <c>gmCG3DView::StopAnimation @ 0x004EE640</c>) both implement. Extracted
|
||||
/// per the CC6a review's F11/F12 note ("before adding a FOURTH consumer... a
|
||||
/// shared <c>RetailHeldPose</c> helper is worth extracting before a fourth
|
||||
/// held-pose consumer exists") — CC6b's own idle-loop work makes chargen's
|
||||
/// implementation grow enough that mechanically sharing the two primitives
|
||||
/// BOTH sites already had byte-identical (DID resolution, final-frame
|
||||
/// transform composition) is a clean win without forcing the two sites'
|
||||
/// slightly different per-index LOOP shapes (paperdoll walks an
|
||||
/// already-built, already-filtered <c>WorldEntity.MeshRefs</c>; chargen
|
||||
/// walks the pre-filter, Setup-part-indexed scratch list) into one method
|
||||
/// they don't actually share.
|
||||
/// </summary>
|
||||
internal static class RetailHeldPose
|
||||
{
|
||||
/// <summary>
|
||||
/// <c>DBCache::GetDIDFromEnumStatic(poseEnum, 7)</c> equivalent: master
|
||||
/// map → slot 7's sub-map → <paramref name="poseEnum"/>'s Animation DID.
|
||||
/// Returns 0 if any link in the chain is missing. MUST be called under
|
||||
/// the caller's dat lock (see <see cref="ChargenPreviewEntityBuilder.TryBuild"/>'s
|
||||
/// <c>datLock</c> doc — <c>DatCollection</c> is not thread-safe).
|
||||
/// </summary>
|
||||
public static uint ResolvePoseDid(IDatReaderWriter dats, uint poseEnum)
|
||||
{
|
||||
uint masterDid = (uint)dats.Portal.Db.Header.MasterMapId;
|
||||
if (masterDid == 0
|
||||
|| !dats.Portal.TryGet<EnumIDMap>(masterDid, out var master)
|
||||
|| !master.ClientEnumToID.TryGetValue(7u, out uint subDid)
|
||||
|| !dats.Portal.TryGet<EnumIDMap>(subDid, out var sub))
|
||||
{
|
||||
return 0u;
|
||||
}
|
||||
|
||||
return sub.ClientEnumToID.TryGetValue(poseEnum, out uint did) ? did : 0u;
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Retail's per-part pose transform: <c>Scale(defaultScale) *
|
||||
/// Rotate(orientation) * Translate(origin)</c> — the SAME composition
|
||||
/// both <c>RetailPaperdollPoseApplicator.Apply</c> and
|
||||
/// <see cref="ChargenPreviewEntityBuilder"/>'s pose steps use, whether
|
||||
/// the (origin, orientation) pair comes from a held final frame or an
|
||||
/// interpolated idle-cycle frame.
|
||||
/// </summary>
|
||||
public static Matrix4x4 ComposePartTransform(Vector3 defaultScale, Vector3 origin, Quaternion orientation) =>
|
||||
Matrix4x4.CreateScale(defaultScale)
|
||||
* Matrix4x4.CreateFromQuaternion(orientation)
|
||||
* Matrix4x4.CreateTranslation(origin);
|
||||
}
|
||||
105
src/AcDream.Content/CharGen/ChargenAppearanceCatalog.cs
Normal file
105
src/AcDream.Content/CharGen/ChargenAppearanceCatalog.cs
Normal file
|
|
@ -0,0 +1,105 @@
|
|||
using System.Collections.Concurrent;
|
||||
using System.Collections.Frozen;
|
||||
using AcDream.Core.CharGen;
|
||||
using DatClothingTable = DatReaderWriter.DBObjs.ClothingTable;
|
||||
using DatPalSet = DatReaderWriter.DBObjs.PalSet;
|
||||
using DatCloObjectEffect = DatReaderWriter.Types.CloObjectEffect;
|
||||
using DatCloSubPalette = DatReaderWriter.Types.CloSubPalette;
|
||||
|
||||
namespace AcDream.Content.CharGen;
|
||||
|
||||
/// <summary>
|
||||
/// DAT-backed <see cref="IChargenPalSetSource"/> / <see cref="IChargenClothingTableSource"/>
|
||||
/// implementation: reads PalSet (0x0F......) and ClothingTable (0x19......)
|
||||
/// dat objects on demand and projects them into <see cref="ChargenAppearanceFactory"/>'s
|
||||
/// pure Core types, matching <c>ChargenTableReader</c>'s "no Chorizite leak"
|
||||
/// discipline for everything it returns. Both lookups cache by dat id — a
|
||||
/// live preview re-composes on every appearance change, and the same
|
||||
/// PalSet/ClothingTable ids repeat constantly across heritages, genders, and
|
||||
/// re-selections within one session.
|
||||
/// </summary>
|
||||
public sealed class ChargenAppearanceCatalog : IChargenPalSetSource, IChargenClothingTableSource
|
||||
{
|
||||
private readonly IDatReaderWriter _dats;
|
||||
private readonly ConcurrentDictionary<uint, ChargenPalSet?> _palSets = new();
|
||||
private readonly ConcurrentDictionary<uint, ChargenClothingTable?> _clothingTables = new();
|
||||
|
||||
public ChargenAppearanceCatalog(IDatReaderWriter dats)
|
||||
{
|
||||
_dats = dats ?? throw new ArgumentNullException(nameof(dats));
|
||||
}
|
||||
|
||||
public ChargenPalSet? TryGetPalSet(uint palSetId) =>
|
||||
_palSets.GetOrAdd(palSetId, LoadPalSet);
|
||||
|
||||
public ChargenClothingTable? TryGetClothingTable(uint clothingTableId) =>
|
||||
_clothingTables.GetOrAdd(clothingTableId, LoadClothingTable);
|
||||
|
||||
private ChargenPalSet? LoadPalSet(uint id)
|
||||
{
|
||||
DatPalSet? palSet = _dats.Get<DatPalSet>(id);
|
||||
if (palSet is null)
|
||||
return null;
|
||||
|
||||
var ids = new uint[palSet.Palettes.Count];
|
||||
for (int i = 0; i < palSet.Palettes.Count; i++)
|
||||
ids[i] = palSet.Palettes[i].DataId;
|
||||
return new ChargenPalSet(Array.AsReadOnly(ids));
|
||||
}
|
||||
|
||||
private ChargenClothingTable? LoadClothingTable(uint id)
|
||||
{
|
||||
DatClothingTable? table = _dats.Get<DatClothingTable>(id);
|
||||
if (table is null)
|
||||
return null;
|
||||
|
||||
var baseEffects = new Dictionary<uint, ChargenClothingBaseEffect>(
|
||||
table.ClothingBaseEffects.Count);
|
||||
foreach (var pair in table.ClothingBaseEffects)
|
||||
baseEffects[pair.Key.DataId] = ProjectBaseEffect(pair.Value.CloObjectEffects);
|
||||
|
||||
var templates = new Dictionary<uint, ChargenClothingPaletteTemplate>(
|
||||
table.ClothingSubPalEffects.Count);
|
||||
foreach (var pair in table.ClothingSubPalEffects)
|
||||
templates[pair.Key] = ProjectPaletteTemplate(pair.Value.CloSubPalettes);
|
||||
|
||||
return new ChargenClothingTable(
|
||||
baseEffects.ToFrozenDictionary(),
|
||||
templates.ToFrozenDictionary());
|
||||
}
|
||||
|
||||
private static ChargenClothingBaseEffect ProjectBaseEffect(
|
||||
IReadOnlyList<DatCloObjectEffect> objectEffects)
|
||||
{
|
||||
var partChanges = new List<ChargenAnimPartChange>(objectEffects.Count);
|
||||
var textureChanges = new List<ChargenTextureChange>();
|
||||
foreach (DatCloObjectEffect effect in objectEffects)
|
||||
{
|
||||
var partIndex = (byte)effect.Index;
|
||||
partChanges.Add(new ChargenAnimPartChange(partIndex, effect.ModelId.DataId));
|
||||
foreach (var tex in effect.CloTextureEffects)
|
||||
{
|
||||
textureChanges.Add(new ChargenTextureChange(
|
||||
partIndex, tex.OldTexture.DataId, tex.NewTexture.DataId));
|
||||
}
|
||||
}
|
||||
return new ChargenClothingBaseEffect(
|
||||
Array.AsReadOnly(partChanges.ToArray()),
|
||||
Array.AsReadOnly(textureChanges.ToArray()));
|
||||
}
|
||||
|
||||
private static ChargenClothingPaletteTemplate ProjectPaletteTemplate(
|
||||
IReadOnlyList<DatCloSubPalette> subPalettes)
|
||||
{
|
||||
var choices = new ChargenClothingSubPaletteChoice[subPalettes.Count];
|
||||
for (int i = 0; i < subPalettes.Count; i++)
|
||||
{
|
||||
DatCloSubPalette sub = subPalettes[i];
|
||||
var ranges = new ChargenClothingSubPaletteRange[sub.Ranges.Count];
|
||||
for (int j = 0; j < sub.Ranges.Count; j++)
|
||||
ranges[j] = new ChargenClothingSubPaletteRange(sub.Ranges[j].Offset, sub.Ranges[j].NumColors);
|
||||
choices[i] = new ChargenClothingSubPaletteChoice(sub.PaletteSet.DataId, Array.AsReadOnly(ranges));
|
||||
}
|
||||
return new ChargenClothingPaletteTemplate(Array.AsReadOnly(choices));
|
||||
}
|
||||
}
|
||||
458
src/AcDream.Core/CharGen/ChargenAppearanceFactory.cs
Normal file
458
src/AcDream.Core/CharGen/ChargenAppearanceFactory.cs
Normal file
|
|
@ -0,0 +1,458 @@
|
|||
namespace AcDream.Core.CharGen;
|
||||
|
||||
/// <summary>
|
||||
/// The resolved render description <see cref="ChargenAppearanceFactory.TryCompose"/>
|
||||
/// produces: a body Setup id plus the composed ObjDesc a mesh builder applies
|
||||
/// to it (<c>CPhysicsObj::DoObjDescChangesFromDefault @ 0x0050F9B0</c> is
|
||||
/// retail's equivalent apply step). The three diagnostic lists let callers
|
||||
/// (and CC6a's installed-DAT test) verify a selection resolved with no
|
||||
/// missing dat data without needing to re-walk the composition themselves.
|
||||
/// </summary>
|
||||
/// <param name="SetupId">
|
||||
/// The body Setup dat id (0x02......) to build the preview mesh from —
|
||||
/// <c>gender.SetupId</c>, overridden by the selected hair style's
|
||||
/// <c>AlternateSetup</c> when it is neither 0 nor retail's <c>INVALID_DID</c>
|
||||
/// (0xFFFFFFFF — Gear Knight / Undead / Tumerok body variants), in turn
|
||||
/// overridden outright by <see cref="ChargenAppearanceFactory.TryCompose"/>'s
|
||||
/// own <c>alternateSetupIdOverride</c> parameter when THAT is not
|
||||
/// <c>INVALID_DID</c> (<c>gmCG3DView::Update</c>'s own
|
||||
/// <c>m_alternateSetupID</c> resolution, ~0x004EEA46-0x004EEA53 — see that
|
||||
/// parameter's doc for why chargen's own Appearance page never actually sets
|
||||
/// it), falling back to <see cref="ChargenAppearanceFactory.HumanSetupId"/>
|
||||
/// when the resolved id is STILL 0 OR <c>INVALID_DID</c> after all three
|
||||
/// tiers (retail: <c>CharGenState::GetSetupID @ 0x005C5B22</c> and
|
||||
/// <c>gmCG3DView::Update</c>'s own check at ~0x004EEA5F both test against
|
||||
/// <c>INVALID_DID</c>, not zero — <c>acclient.h:39909</c> types the field as
|
||||
/// <c>IDClass</c>, whose "unset" value is 0xFFFFFFFF;
|
||||
/// <c>CPhysicsObj::makeObject(setupId)</c>'s own HUMAN_SETUP_ID fallback,
|
||||
/// <c>gmCG3DView</c> ctor pseudo-C ~0x004EE79D).
|
||||
/// </param>
|
||||
/// <param name="BasePaletteId">
|
||||
/// <c>gender.BasePaletteId</c> (retail <c>Sex_CG.BasePalette</c>) — the
|
||||
/// palette a mesh builder should pass as the entity's base, NOT
|
||||
/// <c>ObjDesc.PaletteId</c> (retail's own on-disk <c>BaseObjDesc.PaletteId</c>
|
||||
/// field is unused for this purpose; cross-checked against
|
||||
/// <c>references/ACE/Source/ACE.Server/Factories/PlayerFactory.cs:58</c>,
|
||||
/// which sets <c>PropertyDataId.PaletteBase</c> from <c>sex.BasePalette</c>
|
||||
/// directly).
|
||||
/// </param>
|
||||
/// <param name="ObjDesc">
|
||||
/// The composed subpalette/texture/part-swap deltas, in retail's exact
|
||||
/// application order (see <see cref="ChargenAppearanceFactory.TryCompose"/>).
|
||||
/// </param>
|
||||
public sealed record ChargenAppearanceResult(
|
||||
uint SetupId,
|
||||
uint BasePaletteId,
|
||||
ChargenObjDesc ObjDesc,
|
||||
IReadOnlyList<uint> MissingPalSetIds,
|
||||
IReadOnlyList<uint> MissingClothingTableIds,
|
||||
IReadOnlyList<uint> ClothingTablesMissingBaseEffectForSetup);
|
||||
|
||||
/// <summary>
|
||||
/// Index→ObjDesc appearance factory: the missing piece the campaign plan's
|
||||
/// "acdream seams" section names (Appearance building: <c>DollEntityBuilder.Build</c>
|
||||
/// is index-agnostic but reads a LIVE entity; chargen needs a new index→dat
|
||||
/// →ObjDesc factory). Pure — no Chorizite types on this type's public
|
||||
/// surface, matching CC1's <c>ChargenOptions</c> family; PalSet/ClothingTable
|
||||
/// dat reads are pushed behind <see cref="IChargenPalSetSource"/>/
|
||||
/// <see cref="IChargenClothingTableSource"/>, whose production implementation
|
||||
/// (<c>AcDream.Content.CharGen.ChargenAppearanceCatalog</c>) does the actual
|
||||
/// dat work.
|
||||
///
|
||||
/// <para>
|
||||
/// Ports <c>gmCG3DView::Update @ 0x004EE9D0</c>'s ObjDesc rebuild verbatim,
|
||||
/// in its EXACT append order (verified against the decompiled control flow,
|
||||
/// not inferred from the UI's tab order or the wire's field order, both of
|
||||
/// which differ — see the per-slot XML doc below):
|
||||
/// </para>
|
||||
/// <list type="number">
|
||||
/// <item>Base body (<c>Sex_CG.BaseObjDesc</c>).</item>
|
||||
/// <item>Hair style overlay (<c>HairStyle_CG.ObjDesc</c>), if selected.</item>
|
||||
/// <item>Clothing, in retail's own order — <b>Headgear, Trousers, Shirt,
|
||||
/// Footwear</b> (NOT the UI tab order 5/6/7/8 = headgear/shirt/trousers/
|
||||
/// footwear, and NOT the wire field order from CC2's 0xF656 builder,
|
||||
/// which is also headgear/shirt/trousers/footwear). Each slot applies
|
||||
/// its <c>ClothingBase</c> part/texture overrides unconditionally, then
|
||||
/// — only when a color is also selected — its dye subpalette via
|
||||
/// <c>ClothingTable::BuildObjDesc @ 0x005A7900</c>.</item>
|
||||
/// <item>Eyes strip overlay (bald variant when the selected hair style's
|
||||
/// <c>Bald</c> flag is set), if selected.</item>
|
||||
/// <item>Nose strip overlay, if selected.</item>
|
||||
/// <item>Mouth strip overlay, if selected.</item>
|
||||
/// <item>Skin subpalette — UNCONDITIONAL, no "if selected" guard in
|
||||
/// retail (the decompiled block runs every time, unlike every style/
|
||||
/// color slot above and below it, which all gate on retail's
|
||||
/// <c>0xFFFFFFFF</c> sentinel).</item>
|
||||
/// <item>Hair color subpalette, if selected.</item>
|
||||
/// <item>Eye color subpalette, if selected.</item>
|
||||
/// </list>
|
||||
/// </summary>
|
||||
public static class ChargenAppearanceFactory
|
||||
{
|
||||
/// <summary>
|
||||
/// Retail's HUMAN_SETUP_ID fallback (<c>ACViewer.Entity.Enum.SetupConst.HumanMale</c>
|
||||
/// = 0x02000001; the same constant <c>gmCG3DView</c>'s ctor and
|
||||
/// <c>::Update</c> fall back to when no valid body Setup is resolvable).
|
||||
/// </summary>
|
||||
public const uint HumanSetupId = 0x02000001u;
|
||||
|
||||
/// <summary>
|
||||
/// Retail's <c>IDClass</c> "unset" sentinel (<c>INVALID_DID</c>,
|
||||
/// 0xFFFFFFFF — <c>acclient.h:39909</c>). <c>CharGenState::GetSetupID @
|
||||
/// 0x005C5B22</c> and <c>gmCG3DView::Update</c>'s own checks
|
||||
/// (~0x004EEA51/0x004EEA5F) both test a Setup id against THIS value, not
|
||||
/// zero — a hair style whose <c>AlternateSetup</c> field happens to
|
||||
/// store this sentinel must be treated as "no override," exactly like
|
||||
/// zero, or the factory would hand a bogus Setup id to
|
||||
/// <c>Get<Setup></c> and produce no preview at all.
|
||||
/// </summary>
|
||||
private const uint InvalidDid = 0xFFFFFFFFu;
|
||||
|
||||
/// <summary>
|
||||
/// Skin subpalette overlay range, retail's hard-coded literal at
|
||||
/// <c>gmCG3DView::Update</c> ~0x004EF066-0x004EF07E: real byte offset 0,
|
||||
/// real color count 192 (0xC0), packed to <see cref="ChargenSubPalette"/>'s
|
||||
/// *8 on-disk units as (0, 24).
|
||||
/// </summary>
|
||||
private const byte SkinRangeOffset = 0;
|
||||
private const byte SkinRangeNumColors = 24; // 192 / 8
|
||||
|
||||
/// <summary>
|
||||
/// Hair color subpalette overlay range, retail's hard-coded literal at
|
||||
/// ~0x004EF0FA-0x004EF116: real offset 192 (0xC0), real count 64 (0x40),
|
||||
/// packed to (24, 8).
|
||||
/// </summary>
|
||||
private const byte HairRangeOffset = 24; // 192 / 8
|
||||
private const byte HairRangeNumColors = 8; // 64 / 8
|
||||
|
||||
/// <summary>
|
||||
/// Eye color subpalette overlay range, retail's hard-coded literal at
|
||||
/// ~0x004EF15A-0x004EF16E: real offset 256 (0x100), real count 64
|
||||
/// (0x40), packed to (32, 8).
|
||||
/// </summary>
|
||||
private const byte EyeRangeOffset = 32; // 256 / 8
|
||||
private const byte EyeRangeNumColors = 8; // 64 / 8
|
||||
|
||||
/// <summary>
|
||||
/// Composes a preview appearance description for one heritage/gender +
|
||||
/// selection, or returns false when the heritage/gender itself doesn't
|
||||
/// resolve (mirrors the <c>Try*</c> convention <see cref="ChargenOptions"/>
|
||||
/// already uses). Never throws on missing PalSet/ClothingTable data —
|
||||
/// a miss is recorded in the result's diagnostic lists and that single
|
||||
/// contribution is skipped, matching retail's own "hash miss → no-op,
|
||||
/// caller never checks BuildObjDesc's return value" behavior.
|
||||
/// </summary>
|
||||
/// <param name="alternateSetupIdOverride">
|
||||
/// Retail's SECOND body-Setup-override source — <c>gmCG3DView</c>'s
|
||||
/// <c>m_alternateSetupID</c> field (default <c>INVALID_DID</c>, read at
|
||||
/// <c>gmCG3DView::Update @ ~0x004EEA46-0x004EEA53</c>) — which, when set
|
||||
/// to anything other than <c>INVALID_DID</c>, REPLACES the hairstyle/
|
||||
/// gender-resolved Setup id outright rather than combining with it.
|
||||
/// <b>Decomp-verified NOT to be a character-creation-time mechanism:</b>
|
||||
/// every write site for <c>m_alternateSetupID</c> (the Penumbraen-crown
|
||||
/// and Undead-no-flame variants, ~0x004DFB3F/0x004E0C54/0x004E0D42/
|
||||
/// 0x004E0DB1) lives on <c>gmBarberUI</c> — the POST-CREATION barber-
|
||||
/// shop appearance-editing screen, a wholly separate UI class from
|
||||
/// character creation's <c>gmCGAppearancePage</c>, which has no
|
||||
/// <c>m_pOption1Checkbox</c>-equivalent field and never writes
|
||||
/// <c>m_alternateSetupID</c> anywhere in its own methods (confirmed
|
||||
/// against every field on <c>gmCGAppearancePage</c>,
|
||||
/// <c>acclient.h:56373-56428</c>). For chargen's own preview,
|
||||
/// <c>m_alternateSetupID</c> is therefore ALWAYS <c>INVALID_DID</c> in
|
||||
/// retail, and this parameter's default (<see cref="InvalidDid"/>)
|
||||
/// reproduces that exactly — a real, decomp-verified precedence tier is
|
||||
/// threaded through so a future non-chargen consumer of this same
|
||||
/// factory (e.g. a barber-shop feature, out of Campaign CC's scope) can
|
||||
/// supply one, without inventing a UI source chargen's own Appearance
|
||||
/// page doesn't have.
|
||||
/// </param>
|
||||
public static bool TryCompose(
|
||||
ChargenOptions options,
|
||||
uint heritageId,
|
||||
int genderKey,
|
||||
ChargenAppearanceSelection selection,
|
||||
IChargenPalSetSource palSets,
|
||||
IChargenClothingTableSource clothingTables,
|
||||
out ChargenAppearanceResult result,
|
||||
uint alternateSetupIdOverride = InvalidDid)
|
||||
{
|
||||
ArgumentNullException.ThrowIfNull(options);
|
||||
ArgumentNullException.ThrowIfNull(palSets);
|
||||
ArgumentNullException.ThrowIfNull(clothingTables);
|
||||
|
||||
result = default!;
|
||||
if (!options.TryGetHeritage(heritageId, out ChargenHeritageOptions? heritage)
|
||||
|| !heritage.GendersByKey.TryGetValue(genderKey, out ChargenGenderOptions? gender))
|
||||
{
|
||||
return false;
|
||||
}
|
||||
|
||||
var missingPalSets = new List<uint>();
|
||||
var missingClothingTables = new List<uint>();
|
||||
var absentBaseEffects = new List<uint>();
|
||||
|
||||
// ── 1. body Setup id ────────────────────────────────────────────
|
||||
uint setupId = gender.SetupId;
|
||||
ChargenHairStyle? hairStyle = null;
|
||||
if (selection.HairStyle != ChargenAppearanceSelection.Unset
|
||||
&& selection.HairStyle < (uint)gender.HairStyles.Count)
|
||||
{
|
||||
hairStyle = gender.HairStyles[(int)selection.HairStyle];
|
||||
if (hairStyle.AlternateSetup != 0 && hairStyle.AlternateSetup != InvalidDid)
|
||||
setupId = hairStyle.AlternateSetup;
|
||||
}
|
||||
|
||||
// gmCG3DView::Update @ ~0x004EEA46-0x004EEA53: m_alternateSetupID,
|
||||
// when set, REPLACES the hairstyle/gender-resolved id outright — it
|
||||
// does not combine with it. See alternateSetupIdOverride's own doc
|
||||
// for why chargen's own Appearance page never actually supplies one.
|
||||
if (alternateSetupIdOverride != InvalidDid)
|
||||
setupId = alternateSetupIdOverride;
|
||||
|
||||
if (setupId == 0 || setupId == InvalidDid)
|
||||
setupId = HumanSetupId;
|
||||
|
||||
// ── 2. ObjDesc accumulation, retail's exact append order ───────
|
||||
var subPalettes = new List<ChargenSubPalette>();
|
||||
var textureChanges = new List<ChargenTextureChange>();
|
||||
var animPartChanges = new List<ChargenAnimPartChange>();
|
||||
|
||||
Append(gender.BaseObjDesc, subPalettes, textureChanges, animPartChanges);
|
||||
if (hairStyle is not null)
|
||||
Append(hairStyle.ObjDesc, subPalettes, textureChanges, animPartChanges);
|
||||
|
||||
ComposeClothingSlot(
|
||||
gender.Headgears, selection.HeadgearStyle,
|
||||
gender.ClothingColors, selection.HeadgearColor, selection.HeadgearShade,
|
||||
setupId, clothingTables, palSets,
|
||||
subPalettes, textureChanges, animPartChanges,
|
||||
missingClothingTables, missingPalSets, absentBaseEffects);
|
||||
ComposeClothingSlot(
|
||||
gender.Pants, selection.TrousersStyle,
|
||||
gender.ClothingColors, selection.TrousersColor, selection.TrousersShade,
|
||||
setupId, clothingTables, palSets,
|
||||
subPalettes, textureChanges, animPartChanges,
|
||||
missingClothingTables, missingPalSets, absentBaseEffects);
|
||||
ComposeClothingSlot(
|
||||
gender.Shirts, selection.ShirtStyle,
|
||||
gender.ClothingColors, selection.ShirtColor, selection.ShirtShade,
|
||||
setupId, clothingTables, palSets,
|
||||
subPalettes, textureChanges, animPartChanges,
|
||||
missingClothingTables, missingPalSets, absentBaseEffects);
|
||||
ComposeClothingSlot(
|
||||
gender.Footwear, selection.FootwearStyle,
|
||||
gender.ClothingColors, selection.FootwearColor, selection.FootwearShade,
|
||||
setupId, clothingTables, palSets,
|
||||
subPalettes, textureChanges, animPartChanges,
|
||||
missingClothingTables, missingPalSets, absentBaseEffects);
|
||||
|
||||
if (selection.EyesStrip != ChargenAppearanceSelection.Unset
|
||||
&& selection.EyesStrip < (uint)gender.EyeStrips.Count)
|
||||
{
|
||||
ChargenEyeStrip strip = gender.EyeStrips[(int)selection.EyesStrip];
|
||||
bool bald = hairStyle?.Bald == true;
|
||||
Append(bald ? strip.BaldObjDesc : strip.ObjDesc, subPalettes, textureChanges, animPartChanges);
|
||||
}
|
||||
if (selection.NoseStrip != ChargenAppearanceSelection.Unset
|
||||
&& selection.NoseStrip < (uint)gender.NoseStrips.Count)
|
||||
{
|
||||
Append(gender.NoseStrips[(int)selection.NoseStrip].ObjDesc, subPalettes, textureChanges, animPartChanges);
|
||||
}
|
||||
if (selection.MouthStrip != ChargenAppearanceSelection.Unset
|
||||
&& selection.MouthStrip < (uint)gender.MouthStrips.Count)
|
||||
{
|
||||
Append(gender.MouthStrips[(int)selection.MouthStrip].ObjDesc, subPalettes, textureChanges, animPartChanges);
|
||||
}
|
||||
|
||||
// ── Skin subpalette: UNCONDITIONAL (no selection gate in retail) ─
|
||||
ChargenPalSet? skinPalSet = palSets.TryGetPalSet(gender.SkinPalSetId);
|
||||
if (skinPalSet is null)
|
||||
{
|
||||
missingPalSets.Add(gender.SkinPalSetId);
|
||||
}
|
||||
else
|
||||
{
|
||||
int skinIndex = ChargenPalSetMath.GetPaletteIndex(skinPalSet.PaletteIds.Count, selection.SkinShade);
|
||||
if (skinIndex >= 0)
|
||||
{
|
||||
subPalettes.Add(new ChargenSubPalette(
|
||||
skinPalSet.PaletteIds[skinIndex], SkinRangeOffset, SkinRangeNumColors));
|
||||
}
|
||||
}
|
||||
|
||||
if (selection.HairColor != ChargenAppearanceSelection.Unset
|
||||
&& selection.HairColor < (uint)gender.HairColors.Count)
|
||||
{
|
||||
uint hairPalSetId = gender.HairColors[(int)selection.HairColor];
|
||||
ChargenPalSet? hairPalSet = palSets.TryGetPalSet(hairPalSetId);
|
||||
if (hairPalSet is null)
|
||||
{
|
||||
missingPalSets.Add(hairPalSetId);
|
||||
}
|
||||
else
|
||||
{
|
||||
int hairIndex = ChargenPalSetMath.GetPaletteIndex(hairPalSet.PaletteIds.Count, selection.HairShade);
|
||||
if (hairIndex >= 0)
|
||||
{
|
||||
subPalettes.Add(new ChargenSubPalette(
|
||||
hairPalSet.PaletteIds[hairIndex], HairRangeOffset, HairRangeNumColors));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if (selection.EyeColor != ChargenAppearanceSelection.Unset
|
||||
&& selection.EyeColor < (uint)gender.EyeColors.Count)
|
||||
{
|
||||
// Direct Palette id — no PalSet/shade indirection (see ChargenPalSet's doc).
|
||||
uint eyePaletteId = gender.EyeColors[(int)selection.EyeColor];
|
||||
subPalettes.Add(new ChargenSubPalette(eyePaletteId, EyeRangeOffset, EyeRangeNumColors));
|
||||
}
|
||||
|
||||
var objDesc = new ChargenObjDesc(
|
||||
gender.BasePaletteId,
|
||||
subPalettes.AsReadOnly(),
|
||||
textureChanges.AsReadOnly(),
|
||||
animPartChanges.AsReadOnly());
|
||||
|
||||
result = new ChargenAppearanceResult(
|
||||
setupId,
|
||||
gender.BasePaletteId,
|
||||
objDesc,
|
||||
missingPalSets.AsReadOnly(),
|
||||
missingClothingTables.AsReadOnly(),
|
||||
absentBaseEffects.AsReadOnly());
|
||||
return true;
|
||||
}
|
||||
|
||||
private static void Append(
|
||||
ChargenObjDesc source,
|
||||
List<ChargenSubPalette> subPalettes,
|
||||
List<ChargenTextureChange> textureChanges,
|
||||
List<ChargenAnimPartChange> animPartChanges)
|
||||
{
|
||||
subPalettes.AddRange(source.SubPalettes);
|
||||
textureChanges.AddRange(source.TextureChanges);
|
||||
animPartChanges.AddRange(source.AnimPartChanges);
|
||||
}
|
||||
|
||||
private static void ComposeClothingSlot(
|
||||
IReadOnlyList<ChargenGearOption> gearOptions,
|
||||
uint styleIndex,
|
||||
IReadOnlyList<uint> clothingColors,
|
||||
uint colorIndex,
|
||||
double shade,
|
||||
uint bodySetupId,
|
||||
IChargenClothingTableSource clothingTables,
|
||||
IChargenPalSetSource palSets,
|
||||
List<ChargenSubPalette> subPalettes,
|
||||
List<ChargenTextureChange> textureChanges,
|
||||
List<ChargenAnimPartChange> animPartChanges,
|
||||
List<uint> missingClothingTables,
|
||||
List<uint> missingPalSets,
|
||||
List<uint> absentBaseEffects)
|
||||
{
|
||||
if (styleIndex == ChargenAppearanceSelection.Unset || styleIndex >= (uint)gearOptions.Count)
|
||||
return;
|
||||
|
||||
ChargenGearOption gear = gearOptions[(int)styleIndex];
|
||||
ChargenClothingTable? table = clothingTables.TryGetClothingTable(gear.ClothingTableId);
|
||||
if (table is null)
|
||||
{
|
||||
missingClothingTables.Add(gear.ClothingTableId);
|
||||
return;
|
||||
}
|
||||
|
||||
if (table.BaseEffectsBySetupId.TryGetValue(bodySetupId, out ChargenClothingBaseEffect? baseEffect))
|
||||
{
|
||||
animPartChanges.AddRange(baseEffect.PartChanges);
|
||||
textureChanges.AddRange(baseEffect.TextureChanges);
|
||||
}
|
||||
else
|
||||
{
|
||||
absentBaseEffects.Add(gear.ClothingTableId);
|
||||
}
|
||||
|
||||
if (colorIndex == ChargenAppearanceSelection.Unset || colorIndex >= (uint)clothingColors.Count)
|
||||
return;
|
||||
|
||||
uint paletteTemplateId = clothingColors[(int)colorIndex];
|
||||
if (!table.PaletteTemplatesById.TryGetValue(paletteTemplateId, out ChargenClothingPaletteTemplate? template))
|
||||
return; // retail: hash miss on the OUTER palette-template lookup is a silent no-op.
|
||||
|
||||
foreach (ChargenClothingSubPaletteChoice choice in template.Choices)
|
||||
{
|
||||
ChargenPalSet? palSet = palSets.TryGetPalSet(choice.PalSetId);
|
||||
if (palSet is null)
|
||||
{
|
||||
// Retail's own inner loop (ClothingTable::BuildObjDesc
|
||||
// ~0x005A7B24-0x005A7BD3) returns 0 IMMEDIATELY when
|
||||
// DBObj::Get fails for one subpalEffect entry's PalSet
|
||||
// (~0x005A7B32) — aborting every REMAINING choice in this
|
||||
// same garment's palette template, not merely skipping the
|
||||
// failed one. `break`, not `continue`, matches that; the
|
||||
// miss is still recorded so callers can see it happened.
|
||||
missingPalSets.Add(choice.PalSetId);
|
||||
break;
|
||||
}
|
||||
|
||||
int index = ChargenPalSetMath.GetPaletteIndex(palSet.PaletteIds.Count, shade);
|
||||
if (index < 0)
|
||||
continue;
|
||||
|
||||
uint paletteId = palSet.PaletteIds[index];
|
||||
foreach (ChargenClothingSubPaletteRange range in choice.Ranges)
|
||||
{
|
||||
subPalettes.Add(new ChargenSubPalette(
|
||||
paletteId,
|
||||
PackOffset(range.Offset),
|
||||
PackNumColors(range.NumColors)));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Converts a real (unpacked) clothing subpalette offset into
|
||||
/// <see cref="ChargenSubPalette"/>'s packed *8 on-disk unit. Throws
|
||||
/// rather than silently truncating on a shape we've never seen and
|
||||
/// don't know how to represent losslessly (guards against the
|
||||
/// unchecked-narrowing footgun a plain <c>(byte)(value / 8)</c> cast
|
||||
/// would otherwise hide).
|
||||
/// </summary>
|
||||
private static byte PackOffset(uint realOffset)
|
||||
{
|
||||
if (realOffset % 8u != 0 || realOffset > 2040u)
|
||||
{
|
||||
throw new ArgumentOutOfRangeException(
|
||||
nameof(realOffset),
|
||||
realOffset,
|
||||
"Clothing subpalette range offset does not fit the packed *8 byte "
|
||||
+ "convention (expected a multiple of 8 in [0, 2040]).");
|
||||
}
|
||||
return (byte)(realOffset / 8u);
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Same packing as <see cref="PackOffset"/>, plus retail's own explicit
|
||||
/// "whole palette" sentinel: a packed <c>NumColors</c> of 0 means "the
|
||||
/// entire palette" (<see cref="AcDream.Core.World.PaletteOverride"/>'s
|
||||
/// doc: "Length=0 is a sentinel meaning entire palette... defaulting to
|
||||
/// 256*8"). A real count of exactly 2048 (256*8) IS that same value
|
||||
/// spelled out in real units, so it packs to 0 BY DESIGN — not because
|
||||
/// an unchecked <c>(byte)</c> cast happens to wrap 256 back to 0.
|
||||
/// </summary>
|
||||
private static byte PackNumColors(uint realNumColors)
|
||||
{
|
||||
if (realNumColors == 2048u)
|
||||
return 0;
|
||||
if (realNumColors % 8u != 0 || realNumColors > 2040u)
|
||||
{
|
||||
throw new ArgumentOutOfRangeException(
|
||||
nameof(realNumColors),
|
||||
realNumColors,
|
||||
"Clothing subpalette range color count does not fit the packed *8 byte "
|
||||
+ "convention (expected a multiple of 8 in [0, 2040], or exactly 2048 "
|
||||
+ "for the whole-palette sentinel).");
|
||||
}
|
||||
return (byte)(realNumColors / 8u);
|
||||
}
|
||||
}
|
||||
52
src/AcDream.Core/CharGen/ChargenAppearanceSelection.cs
Normal file
52
src/AcDream.Core/CharGen/ChargenAppearanceSelection.cs
Normal file
|
|
@ -0,0 +1,52 @@
|
|||
namespace AcDream.Core.CharGen;
|
||||
|
||||
/// <summary>
|
||||
/// The fourteen style/color indices plus the six f64 shades
|
||||
/// <see cref="ChargenAppearanceFactory.TryCompose"/> needs to build a preview
|
||||
/// description — field-for-field the same shape as CC3's
|
||||
/// <c>AcDream.Runtime.Session.RuntimeCharacterCreationAppearance</c> (and,
|
||||
/// through it, <c>CharacterCreate.Appearance</c>'s wire fields), kept as a
|
||||
/// SEPARATE type here rather than referenced directly because
|
||||
/// <c>AcDream.Runtime</c> depends on <c>AcDream.Core</c> and not the other
|
||||
/// way around. CC6b's job is the trivial field-by-field copy from the
|
||||
/// Runtime owner's snapshot into this type. <see cref="Unset"/>/
|
||||
/// <see cref="UnsetShade"/> mirror retail's own sentinels exactly (same
|
||||
/// citations CC3 already recorded): <c>0xFFFFFFFF</c> for "nothing selected"
|
||||
/// and the IEEE-754 <c>-1.0</c> construction-time shade default
|
||||
/// (<c>CharGenState::Reset @ 0x005C68A0</c>).
|
||||
/// </summary>
|
||||
public readonly record struct ChargenAppearanceSelection(
|
||||
uint EyesStrip,
|
||||
uint NoseStrip,
|
||||
uint MouthStrip,
|
||||
uint HairStyle,
|
||||
uint HairColor,
|
||||
uint EyeColor,
|
||||
uint HeadgearStyle,
|
||||
uint HeadgearColor,
|
||||
uint ShirtStyle,
|
||||
uint ShirtColor,
|
||||
uint TrousersStyle,
|
||||
uint TrousersColor,
|
||||
uint FootwearStyle,
|
||||
uint FootwearColor,
|
||||
double SkinShade,
|
||||
double HairShade,
|
||||
double HeadgearShade,
|
||||
double ShirtShade,
|
||||
double TrousersShade,
|
||||
double FootwearShade)
|
||||
{
|
||||
public const uint Unset = 0xFFFFFFFFu;
|
||||
public const double UnsetShade = -1.0;
|
||||
|
||||
public static ChargenAppearanceSelection Default { get; } = new(
|
||||
Unset, Unset, Unset,
|
||||
Unset, Unset, Unset,
|
||||
Unset, Unset,
|
||||
Unset, Unset,
|
||||
Unset, Unset,
|
||||
Unset, Unset,
|
||||
UnsetShade, UnsetShade, UnsetShade,
|
||||
UnsetShade, UnsetShade, UnsetShade);
|
||||
}
|
||||
147
src/AcDream.Core/CharGen/ChargenClothingTable.cs
Normal file
147
src/AcDream.Core/CharGen/ChargenClothingTable.cs
Normal file
|
|
@ -0,0 +1,147 @@
|
|||
using System.Collections.Frozen;
|
||||
|
||||
namespace AcDream.Core.CharGen;
|
||||
|
||||
/// <summary>
|
||||
/// One un-resolved dye-shade choice inside a clothing "palette template"
|
||||
/// (retail's inner <c>CloSubpalEffect</c> array entry, one per
|
||||
/// <c>ClothingTable::BuildObjDesc @ 0x005A7900</c> loop iteration; Chorizite
|
||||
/// projects the identical shape as <c>DatReaderWriter.Types.CloSubPalette</c>
|
||||
/// — a <c>PaletteSet</c> id plus a list of overlay ranges). Offsets/counts
|
||||
/// here are the REAL (unpacked) color units read straight off the dat
|
||||
/// (installed-DAT probe: Aluvian male "Cloth Cap" headgear reads
|
||||
/// off=2000,n=48 for every one of its 28 palette-template entries) — the
|
||||
/// *8-packed byte convention only applies to the OUTPUT
|
||||
/// <see cref="ChargenSubPalette"/>, converted once at composition time
|
||||
/// (<see cref="ChargenAppearanceFactory"/>).
|
||||
/// </summary>
|
||||
public readonly record struct ChargenClothingSubPaletteRange(uint Offset, uint NumColors);
|
||||
|
||||
/// <summary>
|
||||
/// One resolvable-by-shade colour choice for a clothing palette template:
|
||||
/// the PalSet id (0x0F......) to resolve via
|
||||
/// <see cref="ChargenPalSetMath.GetPaletteIndex"/>, plus every overlay range
|
||||
/// to apply once resolved.
|
||||
/// </summary>
|
||||
public readonly record struct ChargenClothingSubPaletteChoice(
|
||||
uint PalSetId,
|
||||
IReadOnlyList<ChargenClothingSubPaletteRange> Ranges);
|
||||
|
||||
/// <summary>
|
||||
/// One clothing-table "palette template" (retail's <c>CloPaletteTemplate</c>,
|
||||
/// looked up in <c>ClothingTable::_paletteTemplatesHash</c> by the id
|
||||
/// <c>CharGenState::GetHeadgearPaletteTemplateID</c> (and its Shirt/Trousers/
|
||||
/// Footwear siblings, all at 0x005C38F0-0x005C3980) return — which is itself
|
||||
/// just a bounds-checked passthrough of <c>Sex_CG.ClothingColors[index]</c>:
|
||||
/// every one of the four per-slot template-id arrays
|
||||
/// (<c>headgearPaletteTemplateIDs</c>/<c>shirtPaletteTemplateIDs</c>/
|
||||
/// <c>trousersPaletteTemplateIDs</c>/<c>footwearPaletteTemplateIDs</c>) is
|
||||
/// populated from the SAME single <c>Sex_CG::ClothingColors</c> dat field —
|
||||
/// there is no per-clothing-slot color list in the dat schema at all. This
|
||||
/// CONFIRMS (does not merely approximate) register row AP-208's shared-list
|
||||
/// design in <c>RuntimeCharacterCreationAppearance</c>/
|
||||
/// <c>ChargenAppearanceSlot</c> — installed-DAT probe: Aluvian male's
|
||||
/// <c>ClothingColors</c> = {9,6,4,8,7,5,2,3,13}, and the "Cloth Cap"
|
||||
/// headgear's <c>ClothingSubPalEffects</c> keys include 2,3,4,5,6,7,8,9,13 —
|
||||
/// the shared list's raw values ARE the template-id keys, verified live.
|
||||
/// </summary>
|
||||
public sealed record ChargenClothingPaletteTemplate(
|
||||
IReadOnlyList<ChargenClothingSubPaletteChoice> Choices)
|
||||
{
|
||||
public static ChargenClothingPaletteTemplate Empty { get; } =
|
||||
new(Array.Empty<ChargenClothingSubPaletteChoice>());
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// One body-Setup-specific part/texture override set (retail's
|
||||
/// <c>ClothingBaseEffect</c>, applied by
|
||||
/// <c>ClothingBase::ApplyPartAndTextureChanges @ 0x005A8EB0</c>): for each
|
||||
/// <c>CloObjectEffect</c>, an unconditional <see cref="ChargenAnimPartChange"/>
|
||||
/// (part index → replacement GfxObj) plus every
|
||||
/// <see cref="ChargenTextureChange"/> the SAME object effect carries for
|
||||
/// that part.
|
||||
/// </summary>
|
||||
public sealed record ChargenClothingBaseEffect(
|
||||
IReadOnlyList<ChargenAnimPartChange> PartChanges,
|
||||
IReadOnlyList<ChargenTextureChange> TextureChanges)
|
||||
{
|
||||
public static ChargenClothingBaseEffect Empty { get; } = new(
|
||||
Array.Empty<ChargenAnimPartChange>(),
|
||||
Array.Empty<ChargenTextureChange>());
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Pure projection of one ClothingTable dat object (0x19......, retail
|
||||
/// <c>ClothingTable::Unpack</c> / Chorizite
|
||||
/// <c>DatReaderWriter.DBObjs.ClothingTable</c>). One instance is referenced
|
||||
/// per <see cref="ChargenGearOption.ClothingTableId"/> — a single garment
|
||||
/// CHOICE (e.g. "Cloth Cowl") carries its own table covering every body
|
||||
/// Setup it can be worn on plus every dye choice offered for it.
|
||||
///
|
||||
/// <para>
|
||||
/// <b>Deliberate scope cut (CC6a) — MEASURED, not just asserted:</b> retail's
|
||||
/// <c>ClothingTable::BuildObjDesc</c> falls back through a chain of ~8
|
||||
/// hard-coded Setup-id substitutions (Umbraen crown/no-crown/void,
|
||||
/// Penumbraen, Undead skeleton/zombie, Anakshay) when
|
||||
/// <see cref="BaseEffectsBySetupId"/> has no direct entry for the requested
|
||||
/// body Setup. CC6a's composer looks up <see cref="BaseEffectsBySetupId"/>
|
||||
/// directly and skips a slot's part/texture contribution on a miss (this is
|
||||
/// the OUTER lookup — <c>ClothingTable::_cloBaseHash</c> — whose retail
|
||||
/// miss behavior is genuinely a no-op the caller never checks; the SEPARATE
|
||||
/// inner per-choice PalSet lookup inside the same function's subpalette loop
|
||||
/// has its own, stricter, abort-on-miss behavior — see
|
||||
/// <c>ChargenAppearanceFactory.ComposeClothingSlot</c>'s own doc, ported
|
||||
/// faithfully there) rather than porting the Setup-substitution chain. The
|
||||
/// installed-DAT catalog test (<c>ChargenAppearanceCatalogInstalledDatTests</c>)
|
||||
/// MEASURED this directly across all 26 heritage/gender combinations rather
|
||||
/// than assuming it: for the 9 standard heritages where retail's own UI
|
||||
/// actually shows clothing controls (everything except Gear Knight and the
|
||||
/// two Olthoi variants, which retail hides the clothes button for entirely
|
||||
/// — <c>gmCGAppearancePage::Update @ 0x0047E8F0</c>'s
|
||||
/// <c>m_pClothesButton->SetVisible(0)</c> branches for
|
||||
/// <c>mHeritageGroup == 6</c> and <c>== 0xc || == 0xd</c>), the default
|
||||
/// gear choices resolve against their own body Setup with ZERO missing
|
||||
/// coverage. <b>Undead IS a real gap</b> — retail DOES show clothing
|
||||
/// controls for Undead, and MEASURED coverage is missing for <b>ALL FOUR</b>
|
||||
/// clothing slots (headgear, trousers, shirt, AND footwear — not just three
|
||||
/// of the four), on both genders: neither gender's live body Setup has a
|
||||
/// <see cref="BaseEffectsBySetupId"/> entry in any of its four default gear
|
||||
/// choices' clothing tables, because Undead's live body Setup IS one of the
|
||||
/// skeleton/zombie variants the un-ported substitution chain exists to
|
||||
/// redirect. A live preview for Undead will therefore render its default
|
||||
/// clothing selection with NO part/texture override applied on any of the
|
||||
/// four slots (the underlying body shows through unclothed) until the
|
||||
/// substitution chain — or an equivalent per-heritage default-clothing-setup
|
||||
/// mapping — lands. Filed as a known CC6a limitation for CC6b/a follow-up
|
||||
/// rather than silently "confirmed unreachable."
|
||||
/// </para>
|
||||
/// </summary>
|
||||
public sealed record ChargenClothingTable(
|
||||
IReadOnlyDictionary<uint, ChargenClothingBaseEffect> BaseEffectsBySetupId,
|
||||
IReadOnlyDictionary<uint, ChargenClothingPaletteTemplate> PaletteTemplatesById)
|
||||
{
|
||||
public static ChargenClothingTable Empty { get; } = new(
|
||||
FrozenDictionary<uint, ChargenClothingBaseEffect>.Empty,
|
||||
FrozenDictionary<uint, ChargenClothingPaletteTemplate>.Empty);
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Resolves a PalSet dat id (0x0F......) to its pure projection. The
|
||||
/// production implementation (<c>AcDream.Content.CharGen.ChargenAppearanceCatalog</c>)
|
||||
/// reads and caches the real dat object; this interface keeps
|
||||
/// <see cref="ChargenAppearanceFactory"/> free of any Chorizite dependency
|
||||
/// (unit tests supply a hand-built fake).
|
||||
/// </summary>
|
||||
public interface IChargenPalSetSource
|
||||
{
|
||||
ChargenPalSet? TryGetPalSet(uint palSetId);
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Resolves a ClothingTable dat id (0x19......) to its pure projection.
|
||||
/// Same production/test split as <see cref="IChargenPalSetSource"/>.
|
||||
/// </summary>
|
||||
public interface IChargenClothingTableSource
|
||||
{
|
||||
ChargenClothingTable? TryGetClothingTable(uint clothingTableId);
|
||||
}
|
||||
23
src/AcDream.Core/CharGen/ChargenPalSet.cs
Normal file
23
src/AcDream.Core/CharGen/ChargenPalSet.cs
Normal file
|
|
@ -0,0 +1,23 @@
|
|||
namespace AcDream.Core.CharGen;
|
||||
|
||||
/// <summary>
|
||||
/// Pure projection of a PalSet dat object (0x0F......, retail
|
||||
/// <c>PalSet::Unpack</c> / Chorizite <c>DatReaderWriter.DBObjs.PalSet</c>):
|
||||
/// the ordered list of Palette dat ids (0x04......) a shade fraction picks
|
||||
/// from via <see cref="ChargenPalSetMath.GetPaletteIndex"/>. Every appearance
|
||||
/// color slot that resolves "by shade" — skin (<c>ChargenGenderOptions.SkinPalSetId</c>),
|
||||
/// hair (<c>ChargenGenderOptions.HairColors[i]</c>), and every clothing
|
||||
/// dye choice (<c>ChargenClothingSubPaletteChoice.PalSetId</c>) — reads one
|
||||
/// of these. Eye color is the one exception: retail uses the raw entry
|
||||
/// from <c>ChargenGenderOptions.EyeColors</c> directly as a Palette id, no
|
||||
/// PalSet/shade indirection (<c>gmCG3DView::Update</c> pseudo-C ~0x004EF12F;
|
||||
/// cross-checked against
|
||||
/// <c>references/ACE/Source/ACE.Server/Factories/PlayerFactory.cs:100</c>,
|
||||
/// which sets <c>EyesPalette</c> straight from <c>sex.EyeColorList[eyeColor]</c>
|
||||
/// with no <c>GetPaletteID</c> call, unlike the Skin/Hair lines immediately
|
||||
/// above it).
|
||||
/// </summary>
|
||||
public sealed record ChargenPalSet(IReadOnlyList<uint> PaletteIds)
|
||||
{
|
||||
public static ChargenPalSet Empty { get; } = new(Array.Empty<uint>());
|
||||
}
|
||||
57
src/AcDream.Core/CharGen/ChargenPalSetMath.cs
Normal file
57
src/AcDream.Core/CharGen/ChargenPalSetMath.cs
Normal file
|
|
@ -0,0 +1,57 @@
|
|||
namespace AcDream.Core.CharGen;
|
||||
|
||||
/// <summary>
|
||||
/// Pure port of retail's shade→palette-index resolution
|
||||
/// (<c>PalSet::GetPaletteID @ 0x005AC570</c>, invoked from
|
||||
/// <c>gmCG3DView::Update @ 0x004EE9D0</c> for the skin/hair subpalette
|
||||
/// build and from <c>ClothingTable::BuildObjDesc @ 0x005A7900</c> for every
|
||||
/// clothing-slot dye choice). The decompiled body is genuinely FPU-elided —
|
||||
/// the <c>_ftol2()</c> truncating-cast operand is lost to the decompiler,
|
||||
/// and can only be read as "some product of <paramref name="count"/>-ish and
|
||||
/// <paramref name="shade"/>-ish operands" from the surrounding x87 stack
|
||||
/// traffic — but the decomp's own control-flow SHAPE is still verifiable
|
||||
/// independent of that lost operand: a two-sided FPU compare at
|
||||
/// <c>0x005AC5A0</c> gating on <c>>= 0.0</c>, consistent with a
|
||||
/// <c>[0,1]</c> shade bounds check before the cast. What resolves the
|
||||
/// elided operand is ACE's <c>ACE.DatLoader.FileTypes.PaletteSet.GetPaletteID</c>,
|
||||
/// which carries the explicit comment "Taken from acclient.c
|
||||
/// (PalSet::GetPaletteID)" against the exact formula below. That is TWO
|
||||
/// sources (decomp control flow + ACE's cited port), not three: the
|
||||
/// <c>PaletteSet.cs</c> file present in the vendored ACViewer checkout is
|
||||
/// ACE's own file, not an independent reimplementation, and ACViewer's
|
||||
/// <c>ClothingTableList.xaml.cs:97</c> UI slider computes a DIFFERENT
|
||||
/// expression for a DIFFERENT problem (mapping a shade back to a slider tick
|
||||
/// position against <c>Shades.Maximum</c>, i.e. <c>count-1</c>, not
|
||||
/// <c>count</c>) — neither corroborates this formula and both are dropped
|
||||
/// from the evidence chain here.
|
||||
/// </summary>
|
||||
public static class ChargenPalSetMath
|
||||
{
|
||||
/// <summary>
|
||||
/// Resolves a shade fraction to an index into a palette-id list of the
|
||||
/// given <paramref name="count"/>. Returns -1 (retail's
|
||||
/// <c>INVALID_DID</c> outcome) when <paramref name="count"/> is
|
||||
/// non-positive or <paramref name="shade"/> falls outside
|
||||
/// <c>[0.0, 1.0]</c> — including retail's own <c>-1.0</c> "unset"
|
||||
/// sentinel (<c>CharGenState::Reset @ 0x005C68A0</c>), which is
|
||||
/// deliberately out of range so an untouched shade resolves to
|
||||
/// "nothing," matching retail. Callers should treat -1 as "skip this
|
||||
/// subpalette contribution" rather than emit a placeholder id.
|
||||
/// </summary>
|
||||
public static int GetPaletteIndex(int count, double shade)
|
||||
{
|
||||
if (count <= 0 || shade < 0.0 || shade > 1.0)
|
||||
return -1;
|
||||
|
||||
// Truncating cast, exactly as ACE's cited port and the decomp's
|
||||
// _ftol2() (which truncates toward zero on x86, matching a plain
|
||||
// C-style (int) cast here since count > 0 and 0 <= shade <= 1 keep
|
||||
// the product non-negative).
|
||||
int index = (int)((count - 0.000001) * shade);
|
||||
if (index < 0)
|
||||
index = 0;
|
||||
if (index > count - 1)
|
||||
index = count - 1;
|
||||
return index;
|
||||
}
|
||||
}
|
||||
124
src/AcDream.Core/Physics/RetailAnimationCyclePlayback.cs
Normal file
124
src/AcDream.Core/Physics/RetailAnimationCyclePlayback.cs
Normal file
|
|
@ -0,0 +1,124 @@
|
|||
using System;
|
||||
using System.Numerics;
|
||||
using DatReaderWriter.DBObjs;
|
||||
|
||||
namespace AcDream.Core.Physics;
|
||||
|
||||
/// <summary>
|
||||
/// Retail's simplest animation-clip playback shape: advance a frame position
|
||||
/// at a fixed framerate and wrap it back into <c>[LowFrame, HighFrame]</c>,
|
||||
/// then linearly interpolate one part's origin/orientation between the two
|
||||
/// bracketing frames. This is the effect of
|
||||
/// <c>CPhysicsObj::set_sequence_animation</c> (<c>0x0050F6F0</c>) when called
|
||||
/// with a constant DID and a nonzero framerate and no further motion-command
|
||||
/// traffic — e.g. <c>gmCG3DView::StartAnimation</c> (<c>0x004EE600</c>),
|
||||
/// which plays the chargen preview's idle DID at a flat 30 fps with no
|
||||
/// transitional blending.
|
||||
///
|
||||
/// <para>
|
||||
/// This exact advance-with-wrap-then-lerp/slerp algorithm already exists as
|
||||
/// an inline, App-layer-only implementation for the "legacy" (no
|
||||
/// <see cref="AnimationSequencer"/>) NPC idle-cycle path —
|
||||
/// <c>LiveEntityAnimationPresenter.Present</c>'s non-sequencer branch
|
||||
/// (<c>CurrFrame += legacyAdvanceSeconds * Framerate</c> with the same
|
||||
/// modulo wrap) and its private <c>TryResolvePartFrame</c> helper (the same
|
||||
/// frame-bracket lerp/slerp). That call site has a live entity, a
|
||||
/// <c>LiveEntityRuntime</c> membership, and per-tick elapsed time supplied by
|
||||
/// the render loop; the chargen preview has none of that (there is no live
|
||||
/// entity — character creation hasn't happened yet), so it cannot reuse that
|
||||
/// class directly. Rather than re-typing the same formula a second time,
|
||||
/// this Core, pure, unit-testable class is the shared primitive: the
|
||||
/// chargen preview (<c>AcDream.App.Rendering.ChargenPreviewAnimator</c>)
|
||||
/// consumes it directly, and it is safe for a future pass to redirect
|
||||
/// <c>LiveEntityAnimationPresenter</c>'s inline copy through it as a
|
||||
/// behavior-preserving mechanical follow-up (not done here — that file is
|
||||
/// live, heavily tested production entity-rendering code with zero relation
|
||||
/// to this preview-only feature, so touching it is out of this slice's
|
||||
/// blast radius by design, not oversight). Tracked as
|
||||
/// <c>docs/ISSUES.md</c> #403 so the follow-up has an owner.
|
||||
/// </para>
|
||||
/// </summary>
|
||||
public static class RetailAnimationCyclePlayback
|
||||
{
|
||||
/// <summary>
|
||||
/// Advances <paramref name="currFrame"/> by <c>elapsedSeconds * framerate</c>
|
||||
/// and wraps it back into <c>[lowFrame, highFrame]</c> with the SAME modulo
|
||||
/// shape <c>LiveEntityAnimationPresenter.Present</c>'s legacy branch uses
|
||||
/// (<c>over % (span + 1)</c>, not a plain clamp — a frame position that
|
||||
/// overshoots the end by more than one span wraps around more than once
|
||||
/// rather than sticking at the boundary, matching a long stall/resume).
|
||||
/// Returns <paramref name="currFrame"/> unchanged for a degenerate cycle
|
||||
/// (<paramref name="highFrame"/> <= <paramref name="lowFrame"/>), a
|
||||
/// non-positive <paramref name="framerate"/>, or a non-positive
|
||||
/// <paramref name="elapsedSeconds"/>.
|
||||
/// </summary>
|
||||
public static float Advance(
|
||||
float currFrame,
|
||||
int lowFrame,
|
||||
int highFrame,
|
||||
float framerate,
|
||||
float elapsedSeconds)
|
||||
{
|
||||
int span = highFrame - lowFrame;
|
||||
if (span <= 0 || framerate <= 0f || elapsedSeconds <= 0f)
|
||||
return currFrame;
|
||||
|
||||
float next = currFrame + elapsedSeconds * framerate;
|
||||
if (next > highFrame)
|
||||
{
|
||||
float over = next - lowFrame;
|
||||
next = lowFrame + (over % (span + 1));
|
||||
}
|
||||
else if (next < lowFrame)
|
||||
{
|
||||
next = lowFrame;
|
||||
}
|
||||
return next;
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Resolves part <paramref name="partIndex"/>'s origin/orientation at
|
||||
/// <paramref name="currFrame"/> by linearly interpolating (lerp origin,
|
||||
/// slerp orientation) between the frame at <c>floor(currFrame)</c> and
|
||||
/// the next frame in the cycle (wrapping <paramref name="highFrame"/>+1
|
||||
/// back to <paramref name="lowFrame"/>). Returns <c>false</c> — with
|
||||
/// <c>default</c> outputs — when <paramref name="partIndex"/> is outside
|
||||
/// the bracketing frame's part list, matching
|
||||
/// <c>LiveEntityAnimationPresenter.TryResolvePartFrame</c>'s no-
|
||||
/// sequence-frames branch exactly.
|
||||
/// </summary>
|
||||
public static bool TryInterpolatePart(
|
||||
Animation animation,
|
||||
float currFrame,
|
||||
int lowFrame,
|
||||
int highFrame,
|
||||
int partIndex,
|
||||
out Vector3 origin,
|
||||
out Quaternion orientation)
|
||||
{
|
||||
ArgumentNullException.ThrowIfNull(animation);
|
||||
|
||||
int frameIndex = (int)MathF.Floor(currFrame);
|
||||
if (frameIndex < lowFrame || frameIndex > highFrame || frameIndex >= animation.PartFrames.Count)
|
||||
frameIndex = lowFrame;
|
||||
int nextIndex = frameIndex + 1;
|
||||
if (nextIndex > highFrame || nextIndex >= animation.PartFrames.Count)
|
||||
nextIndex = lowFrame;
|
||||
float t = Math.Clamp(currFrame - frameIndex, 0f, 1f);
|
||||
|
||||
var frames = animation.PartFrames[frameIndex].Frames;
|
||||
var nextFrames = animation.PartFrames[nextIndex].Frames;
|
||||
if (partIndex < frames.Count)
|
||||
{
|
||||
var first = frames[partIndex];
|
||||
var next = partIndex < nextFrames.Count ? nextFrames[partIndex] : first;
|
||||
origin = Vector3.Lerp(first.Origin, next.Origin, t);
|
||||
orientation = Quaternion.Slerp(first.Orientation, next.Orientation, t);
|
||||
return true;
|
||||
}
|
||||
|
||||
origin = default;
|
||||
orientation = default;
|
||||
return false;
|
||||
}
|
||||
}
|
||||
Loading…
Add table
Add a link
Reference in a new issue