locum 0.1.6

• A top-level build before the frame whose instances are an array of pointers is captured: its pointers are copied
  in the game's list right after it, and a list of locum's right after that list gathers each instance on the GPU
  (ExecuteIndirect, the pointer as a root SRV), armed or not. The game's list's commands after the build decide
  whether the gather holds what the build read; where that list may have written the instances after the build, the
  capture says so and replay builds the structure empty, as before. Before, every such structure was replayed empty.

locum 0.1.5

• A wrapper is another face of the real object: its AddRef and Release are the object's, one wrapper is made per
  object, and it is freed when the object is destroyed. A game sees the counts it would see without locum: a child
  holds its device, the immediate context's first reference holds the device, a back buffer holds its swap chain, an
  adapter its factory. Before, each wrapper counted on its own, and a Direct3D 12 heap a placed resource lived in was
  freed when the game released it, so a later call on it crashed (vkd3d's test_create_placed_resource).
• GetDevice on what a Direct3D 11 device made (a buffer, a texture's DXGI surface, a class instance) answers with
  locum's device, and every way to the adapter and factory (IDXGIDevice::GetAdapter, IDXGIAdapter::GetParent, an
  output's GetParent) with locum's wrappers. Before, it handed out the real device, and what a game made with that
  passed locum by.
• A wrapper answers only to the interfaces its real object answers to: a factory from CreateDXGIFactory refuses
  IDXGIFactory1, as the system's does.
• D3D11CreateDevice and D3D11CreateDeviceAndSwapChain clear the out pointers they are given and make nothing when
  given none to fill, as the system's do.
• The Agility SDK's D3D12Core.dll and d3d12SDKLayers.dll, and d3d10warp.dll, in a game's folder are the
  runtime: the factories they ask DXGI for are the real ones.
• What a Direct3D 12 capture makes beside a game's queue (a helper queue, fences) goes when the queue is destroyed.
  Before, it lived as long as the process and held the device.
• A command list run on a deferred context is not held by that context's recording. Before, the recording held it
  (and so its device) for as long as the list being recorded, or the context, lived.
• The first present that reports the device removed (or reset) logs the device's reason.
• cargo xtask smoke runs what cargo built where CARGO_TARGET_DIR points, and stages there (smoke/,
  smoke-d3d12/). Before, it built there but copied target/release's DLLs, so a smoke could pass on old ones.
• locum-cli conform (and --layer) loads what a layer's DLLs forward their exports to from the layer's folder:
  locum's stand-ins forward to locum.dll, which was otherwise the first of that name beside locum-cli or on PATH
  (cargo's target folders under cargo xtask smoke), or none, and the layer replay failed to load the system's
  d3d11.dll. The machine line names those modules too.
• A copy of locum's from a buffer the game's list had not moved by a barrier (a build's inputs, armed or not;
  ExecuteIndirect's records and DispatchRays' tables while a capture is armed) no longer leaves the buffer in a state
  the game does not know. The copy promoted it to COPY_SOURCE as well, so the game's next barrier from the state it
  expected was an error the debug layer reports, and the runtime's tracking of the buffer went wrong. Locum now moves
  it back right before that barrier, or between the lists of one ExecuteCommandLists, and joins COPY_SOURCE first
  where an earlier list of the call left the buffer in a state of its own.
• A top-level build in the frame whose instances are an array of pointers reads the buffers its pointers point into,
  so a plan makes them and they get first-use copies. Before, replay left out every instance only a pointer named.
  Such a build before the frame is still not captured (see the docs for why): replay builds it empty, and verify says
  so.
• An ExecuteIndirect whose command signature runs DispatchRays has its records read, as other records with addresses
  are: the shader tables they name are among its reads, so a plan makes them, and a table nothing else in the frame
  names is copied after it. Before, its records were a d3d12-indirect-arguments gap.
• Raytracing replays. A DispatchRays, direct or through ExecuteIndirect, runs with its state object made again
  (collections and AddToStateObject included) on copies of its shader tables in which each record's identifier and
  local root arguments are replay's; acceleration structures the frame began with are built again from the inputs the
  capture copied at their builds, and the frame's builds, updates, copies and inline traces (RayQuery) run as it ran
  them. Capture reads what each record's local root arguments name (the buffers and descriptors a dispatch reads and
  writes through its tables alone), at the Present and, for a direct DispatchRays, as its submission is made, so what
  they name gets a first-use copy; copies what a DispatchRays writes through UAVs, as a dispatch's outputs; keeps each
  state object's subobjects and the identifiers the game asked for; and names each acceleration structure view's
  buffer. Before, replay ran no DispatchRays and verify said so. Verified on WARP and NVIDIA hardware, a capture made
  on one replayed on the other, through callable shaders, compacted, updated and cloned structures, and instances by
  pointer.
• Multisampled textures are captured sample by sample, bit for bit, depth and stencil included: their contents and
  their pass-end targets on both APIs. Before, Direct3D 11 captured their resolve, and Direct3D 12 none of them (a
  gap). Draws read the samples, since no copy can: a twin of the texture's typeless family, and a pixel shader per
  sample loading its raw bits (a depth as a float turned back into its 24 or 32 bits) into a one-sample image.
• Replay writes every sample of a multisampled texture's contents the same way (a draw a sample, depth through
  SV_Depth, stencil a bit at a time), and reads its targets back sample by sample, so verify compares them. Before,
  they started empty, and Direct3D 12 replay could not read them back. A capture from 0.1.4 or earlier holds their
  resolve: replay starts them empty and says so.
• A multisampled texture's subresource is its samples' images in sample order. Its subresources row, a target read
  from it, export (PNG, DDS or raw), the viewer and pixel --draws (which shows each sample) take them as one image
  of the samples stacked top to bottom; a whole multisampled texture exports to DDS with each slice's samples as array
  slices.
• The smokes' multisampled textures include every colour format whose samples are read through a float view
  (B8G8R8A8, B8G8R8X8, B5G6R5, B5G5R5A1, B4G4R4A4, A8, R10G10B10_XR_BIAS) where the device renders it with 4 samples,
  each sample different, and name those it cannot.

locum 0.1.4

• Releases are made by release-plz and dist. The downloads are now locum-x86_64-pc-windows-msvc.zip (locum.dll,
  d3d11.dll, dxgi.dll, d3d12.dll, nvapi64.dll: the DLLs that go beside a game; was locum-dlls-<version>-…)
  and locum-cli-x86_64-pc-windows-msvc.zip, each with a .sha256, and sha256.sum for both.
• Direct3D 12 replay on a device that takes more of a heap for a placed resource than the game's GPU did, or another
  alignment, lays the heap out again instead of making the resource committed: what shared memory in the game still
  does, reserved tiles and the frame's tile remaps included. vkd3d-proton on an RTX 5070 Ti sizes 94 of an Elden Ring
  frame's placed resources so; before, they no longer shared memory and verify called the frame incomplete.
• A placed resource this device will not take at the small alignment the game placed it with is placed at the default.

locum 0.1.3

• locum-cli conform CAPTURE --layer DIR holds a translation layer (DXVK, vkd3d-proton) to a captured frame: it
  verifies the capture on the system's Direct3D and through the layer's DLLs, and names each comparison the system's
  replay passes and the layer's fails, what the layer's never reached, and what only it could not make. The docs'
  "Translation layers" section says what it found in DXVK 3.1.1 and vkd3d-proton 3.1.
• --layer DIR on any command replays through the Direct3D DLLs in DIR, and a replay's machine line names them.
• Replays run on the system's Direct3D, not on DLLs beside locum-cli. Before, a locum-cli in target/release (or
  beside a game) loaded locum's own stand-ins there and replayed through locum's wrappers.
• verify --report FILE writes every comparison it made as JSON.
• overrides.txt is read when a device is made, so a program that never presents gets its rules.
• cargo xtask smoke --api d3d12 starts each run with an empty log folder; captures of every earlier run had piled
  up there (1 GB here).

Crates

• locum-capture 0.1.3
• locum-cli 0.1.3
• locum-d3d11 0.1.3
• locum 0.1.3

locum 0.1.2

• Each release now has the DLLs that go beside a game as a download, locum-dlls-<version>-x86_64-pc-windows-msvc.zip
  (locum.dll, d3d11.dll, dxgi.dll, d3d12.dll, nvapi64.dll), beside locum-cli. The README's Installation
  section says which go where.
• Direct3D 12: ExecuteIndirect with an incrementing constant (ExecuteIndirect tier 1.1) is captured and replayed.
  Before, capture called its records unreadable and replay skipped it.
• cargo xtask smoke --api d3d12 --debug verifies every capture of the run under GPU-based validation and the debug
  layer, not only two of them.
• cargo xtask smoke --dlls DIR (and --api d3d12) runs the smokes on the DLLs in DIR, such as a release's, instead
  of building them.

Crates

• locum-capture 0.1.2
• locum-cli 0.1.2
• locum-d3d11 0.1.2
• locum 0.1.2

locum 0.1.1

• docs.rs: document the libraries without building the bundled SQLite; 0.1.1 (8c4f03a)

Crates

• locum-capture 0.1.1
• locum-cli 0.1.1
• locum-d3d11 0.1.1
• locum 0.1.1

locum 0.1.0

• locum-capture: dx 0.5.0's Op::Call carries its calling convention and tail marker (cc1c64c)
• locum-cli: shader evidence names the dx and iridia builds by version, or by commit for a git build (b047135)
• dx 0.5.0, iridia 0.5.0 and primase-foundations 0.3.3 from crates.io instead of git revisions (ba7b836)
• CI on Windows, crates.io-ready manifests, releases when the version moves (750eab9)
• viewer: the LZ4 test's expected bytes are typed as what lz4Block returns (8441ead)
• docs: ExecuteIndirect's root UAV outputs, bundles, mesh, environment gaps, verifications, Motor Town (3881203)
• environment: a failed probe is a gap, and each verify is kept in the capture (f0e36d1)
• d3d12: what root UAVs in ExecuteIndirect records write is captured and verified (9ba7d3b)
• d3d12: ExecuteIndirect with GPU addresses in its records is captured and replayed (8aee6a7)
• capture: record the machine a frame ran on, and name both ends in verify (b7cac54)
• README: rewrite per write-readme skill (a9e6a20)
• store: blobs are LZ4 blocks unless that saves too little (431ddec)
• viewer: read Direct3D 12 captures of schema 6 (d846add)
• store: one blob store for every run of a game, and its space back when runs are deleted (632b521)
• values: read, set and call into a game by the names a table gives them (ca80ac6)
• resource: no Direct3D 12 tile tables asked of captures without them (5eca946)
• verify: readback buffers need no contents; results only the CPU reads are notes (cd82898)
• verify: a slice's length may be the sum of a word's two 16-bit halves (379f34f)
• docs: Elden Ring's tile records' third word is not a spot count (811ecec)
• D3D12 replay: queries, slices at other offsets, heaps from their resources (ff7c4fe)
• Shims export the system DLLs' full lists; D3D11 replay writes constant-buffer ranges by copy (5b7894a)
• D3D12 verify --debug: GPU-based validation in a pass of its own (f9cdb8d)
• D3D12 replay: placed and reserved resources in the game's heaps, and the frame's tile remaps (f5c15cb)
• D3D12 pass-end copies go back to a read-only state through COPY_DEST (1011b2e)
• D3D12 reserved resources: contents and tile mappings (cf404a3)
• Capture consecutive frames: frames N in a capture request, both APIs (d43b4e9)
• Keep what a key list says of the bytes; name the drawn face set of a known block (67dc4ca)
• Name programs built without reflection from an index (index --programs) (8a5ed2b)
• docs: a dumped image's base is to be checked, not assumed (9b2f6c3)
• docs: reading a stack's module+offset frames in a disassembler (49890f3)
• pixel --draws: which draws inside a pass wrote a texel, by replay (3e8554c)
• Programs' code keys: the code part alone, so programs differing only in names compare equal (50a7432)
• constants --with: a draw's programs, stencil reference, topology or mesh file as columns (f634321)
• draw and bindings JSON: every file with a binding's bytes, not only the first (b79dc3a)
• target and export: --channel stencil; raw depth readbacks say their texel layout (b19373a)
• trace: follow a draw through its hull, domain and geometry programs (962fc6f)
• upgrade -o: upgrade a copy, leaving the capture as it is (35c7fac)
• blob: to stdout unless -o, by a key's first digits (ccc0fc3)
• docs: wrap the bindings line (f08b011)
• bindings: each row's format, and what the draw reads of an index or vertex buffer (bf2e1ba)
• Constants of bindings without recorded bytes, read from the buffer; cb --as (7749d2c)
• cb and constants --extend: a buffer bound larger than declared, named as further elements of its last array (492341e)
• vertices: what a draw fed its vertex shader, decoded through its input layout (390fb28)
• index --tar: DDS files and programs from a tar stream (e1a9f1e)
• Format with rustfmt (6808da3)
• CLI: several draws at once, constants by name, JSON by section, stripped DXBC (8ad01b0)
• CLI: programs named from an index, hash, sql .schema, empty discard maps (42a6755)
• Record what Direct3D 12 draws, dispatches and UAV clears write (d64288a)
• D3D12 replay names its objects and says why a device was removed (a58b595)
• Replay and verify Direct3D 12 captures (c899023)
• CLI: censuses across draws and captures, run folders, D3D12 buffers at an event (4ebdefe)
• Name struct-array elements of constant buffers at the right stride (ac99f84)
• Record the back buffer each captured frame presented; target presented (f8aa989)
• cb: show the declared registers of programs built without names; join: say what has no bytes (8fabe85)
• draw: leave out vertex buffer slots the input layout does not read (2450ae3)
• Name unity-formats' mesh_keys as a source of --keys lists (114de5d)
• upgrade: bring an older capture's derived data up to the current projection (c0b6ac4)
• passes says where each pass's targets were read back; registers bound twice are flagged (56ab323)
• Index bytes alone name no file; a data block or agreeing vertex data does (27fbf56)
• Name meshes in pooled or padded buffers from listed buffer keys (0231fc1)
• trace: what a target lane is made of, to the vertex attributes (8c3714f)
• target: last for the frame's last readback of a target (0d04568)
• Pictures of one channel or part of a target; viewer draw links and stop (84b6272)
• D3D12 pass-end copies wait for the target's next naming; missing targets named (cbd3423)
• D3D12 pass ends at Close decided where the list is submitted (3453315)
• CLI: draws by declared resource name, and the texel layout export wrote (a411736)
• CLI and viewer: older D3D12 captures, stride, pass lists, copy sources (4f02a0d)
• CLI: program debug names, and DXIL shaders summarised instead of dumped (3ccdae5)
• D3D12: a barrier on a target not yet drawn to does not end its pass (9150e03)
• D3D12: constants of a default-heap buffer as each draw read it (0b915b0)
• D3D12: bind a table range only to descriptors of its own type; name what DXIL programs read (d832b32)
• D3D12: count where a frame's pass-end copies go (3d3f69b)
• D3D12: copy first uses a compute or copy queue cannot transition on a direct queue of locum's (b2ca4d7)
• D3D12: say why a resource named by a stale descriptor has no first-use copy (fd58c82)
• info: count targets from the table when the capture's meta lacks the counts (07ba3e3)
• Viewer: read D3D12 schemas 2 through 5, and test the range against db.rs (aa7b964)
• D3D12 captures: count targets, no caveat on exact contents, bind only real stages (dbaf511)
• D3D12: hide NVAPI behind an nvapi64.dll that exports nothing (74d2426)
• D3D11: record deferred lists on one tape, without an allocation per call (fec513e)
• D3D12: copy render and depth targets where each pass ends (a3dfa8c)
• D3D12: copy each resource before its first use in the armed frame (0d499ea)
• D3D12: copy armed uploads on the GPU and read CB bindings by range (b23e255)
• D3D12: wrap the newest interfaces and record every command-list method (a32b514)
• D3D12: armed submissions record descriptor changes and copy merged CB runs (3ced512)
• D3D12: copy upload buffers whole once per capture, then only the CB ranges each submission reads (9d20a20)
• D3D12: journal command lists, capture them for inspection, archive shaders, observe crashes (da4ea8e)
• Reflection: constant buffers are the cbuffers, not every laid-out buffer (4d92bef)
• D3D11: seed packed tiled mips as canonical texels (026f834)
• D3D11: record deferred command lists for replay, Map through write-watch shadows (949a783)
• D3D11: read shader reflection and atomics through dx's dxbc-reader (94f73c3)
• D3D11: replay tiled resources and tile pools natively (5d20342)
• verify --out: keep the bytes and pictures of what differs (42545a9)
• CLI: draw, cb and shader as JSON, and every draw in one call (4d5bc65)
• draw names texture, sampler and UAV slots from the shader's reflection (0c54fd0)
• CLI: draw arguments by name, replay outputs named for what they are (aaa4ba1)
• export --at: a resource's contents as an event saw them (1843a0a)
• Record tiled-resource calls and mark their captures incomplete (389ff0b)
• Name state enums in the CLI's draw and diff (6fbe04c)
• Resolve D3D12 ordinal exports past overlay redirections (b105062)
• Mark captures that execute a partly recorded command list (f47685b)

…and 46 earlier commits

Crates

• locum-capture 0.1.0
• locum-cli 0.1.0
• locum-d3d11 0.1.0
• locum 0.1.0