THE GRIMOIRE

DISPUTES finding.d2dx_gamesize_960. What is D2DX's ACTUAL runtime gameSize in-game (panel open)? Workflow inferred 960 (narrow). But forcing 1280 via SetCustomResolution (D2DXWiden) SHRANK the menu (black margin) -> implies native was LARGER than 1280, contradicting 960. Need a runtime read (probe gameSize / grSstWinOpen args), not source inference.

Units/NPCs shift LEFT on inventory-open (they must NOT shift). Source unknown: the ctx+0x0C widen, D2DXWiden (now reverted), or the double-motion-smoothing (d2fps+D2DX both on). Re-check with D2DXWiden off. → PROGRESS 2026-07-12: terrain shift CONFIRMED = -320 (1x) via offX(0x6FBCC418)->ctx+0x04; scrollX untouched. Shared tile projection is 1x for all layers, so the objects' extra -320 is downstream/unit-specific. STILL OPEN: unit-layer re-read of offX (theory a) vs motion-smoothing (theory b). NEXT: xref offX reads -- if the unit/PASS2 path reads 0x6FBCC418 too, theory (a). ==> 2026-07-12 xref: offX read 173x, 1 write (0x6FB5AF7C). Attempt A (offX=0) un-shifted floor+units but NOT walls (separate source) + broke clicks. Shift is MULTI-SOURCE + hit-test-coupled; units lean theory (a). Naive offX-kill is OUT.

ONE clip (D2Glide 640) or TWO (D2Glide 640 + a D2DX target)? Panel-open probe=640, no-panel probe=1296 => the D2Glide clip is panel-mode-dependent. Whether D2DX ALSO clips once geometry passes 640 is blocked by OQ.d2dx_runtime_gamesize.

D2DXWiden(1280) regressed the menu resolution. Is forcing 1280 wrong for the low-res menu, or is the game's native size >1280? Ties to OQ.d2dx_runtime_gamesize. If D2DXWiden is re-applied, scope it IN-GAME only.

DISAMBIGUATOR (council chat+clau demanded, never run): what is D2DX's ACTUAL D3D11 world render-target width + viewport, panel-open vs closed? Pairs with the panel-gated D2Glide submit probe to triangulate the stop point: (submit 640 + RT 1280)=>upstream D2Glide; (submit 1296 + RT 960)=>D2DX extent; (submit 1296 + RT 1280)=>wide-but-retagged (inspect MRTs). Build: hook ID3D11DeviceContext::Draw or read D2DX gameSize; or log grSstWinOpen incoming res arg (feature_d2dx already hooks it).

v1.12.0: after authoring the no-panel lens (offX=0/ctxL=0/ctxR=DispW each frame), the WORLD, WALLS and UNITS un-shift correctly -- but 1-2 FLOOR sub-layers still sit at the shifted position. So a floor sub-layer projects through a source our per-frame ctx authoring does NOT cover (a cached projection, a pre-PASS1 draw, or an offX re-read in the tilesub/floor-sublayer path 0x6FAF4307). Minor visual residual. Find via which draw path emits the lagging layer. Polish -- lower priority than the black. ==> IDENTIFIED (v1.12.2): it's the play-area rect playAreaW (0x6FBA9E14) -- the floor draws into it AND the hit-test reads it; narrowed to ~640 on panel-open (EP's 2022 HOM/4-tile-buffer notes). Authoring playAreaW=DispW/frame is the test. ==> v1.12.3: nViewXOffset was ALREADY 0 at our pre-PASS1 hook (no-op) -> the floor shift is COMPUTED INSIDE PASS1, not a pre-authorable global. See finding.floor_shift_internal_to_pass1. Council consult queued. ==> v1.12.6 [PROBE glidevtx count=0 @0xBEFC]: 0xBEFC is NOT the floor's live submit path. The floor's actual grDraw site is unidentified. See finding.floor_shift_ledger. Next = unfiltered return-addr logger.

THE LAST BARRIER TO ZERO BLACK: with the world un-shifted, floor geometry reaches x>=640 (probe band[960,1280)=66-104) and D2DX renders it BLACK. Confirmed m2's prediction: D2DX SurfaceIdTracker retags world batches with minx>=gameSize/2(=640) as USER_INTERFACE while ScreenOpenMode&1 -> the UI projection drops the world verts. Fix (council m2): runtime hot-patch the minx>=640 retag compare in glide3x during the world draw, restore after. We CANNOT rebuild D2DX. First step: read the D2DX source (bolrog/d2dx SurfaceIdTracker.cpp) to nail whether the retag drops COLOR or only writes metadata (m5 disputed) -> then locate + hot-patch it. ==> CORRECTED 2026-07-13 (read D2DX source): the surfaceId retag is METADATA ONLY (SetSurfaceId on vertices, for AA/motion) -- it does NOT relocate color (m5/chat was right, m2 wrong). The real clip is D2DX RenderContext::UpdateViewport, which sets the game VIEWPORT + SCISSOR to _gameSize.width (=960 for our desktop). World pixels x in [960,1280] are scissored -> black. FIX = widen _gameSize to 1280 via SetCustomResolution (our feature_d2dx.c / D2DXWiden). It failed alone earlier ONLY because the world was still SHIFTED (geometry never reached [960,1280]); with v1.12.0 no-shift the world fills [0,1280], so no-shift + D2DXWiden TOGETHER should fill the dead zone. RT is >=1024 (max(1024,w)); if a thin [1024,1280] band stays black, the RT alloc is the next tweak.

Panel open: is the D2Glide floor submit clamped at 640(=DispW/2) by the [esp+0x38] per-subtile CULL (NOP-able @0x856889) or by a VERTEX-X CLAMP elsewhere in 0x856840's projection? v1.11.2 gated probe (GlideUnclamp=1) settles it: submit max ~1280 => cull is the lever; ~640 => clamp is elsewhere. → ANSWER It's the CULL. v1.11.2 gated probe (mode=1): GlideUnclamp=1 -> panel-open D2Glide floor submit max 1264-1296 with 338 verts IN [960,1280); GlideUnclamp=0 was 640. The NOP defeats the cull (640->1264). The remaining black is a DROP at/after D2DX -- geometry reaches the dead zone, D2DX doesn't paint it.

Why did v1.9.1/v1.11.0 GlideUnclamp (NOP the cull narrowing 0x856889/0x85689E) show NO visual change if 640 is the cull? Either the NOP widens the submit but a downstream layer hides it, or 640 comes from a clamp the NOP doesn't touch. Depends on OQ.panelopen_640_cull_vs_clamp. → ANSWER GlideUnclamp DOES widen the submit (640->1264, 338 verts into the dead zone) -- never 'no effect'. The visual didn't change because the widened geometry is dropped downstream at/after D2DX.

BLOCKER (council wave-5 m1+m4): walls/roofs shift via a SEPARATE source, NOT offX (attempt A: offX=0 un-shifted floor+units but not walls). The authored no-panel view-state is INCOMPLETE until this source is named. Find it: read-breakpoint on the wall projection input during PASS2 (0x6FB3B110), or resolution-differential (vary DisplayWidth, scan for the value that tracks it AND encodes panel-open). Last unknown before the view-state-authorship patch. ==> TESTING (v1.12.0 attempt.I_noshift_lens): authoring ctxL=0 will show if walls read the ctx (un-shift) or a PASS2 recompute (stay shifted). ==> CLOSED (v1.12.0): the walls UN-SHIFTED with our ctxL=0 authoring -> the walls read the render context, NOT a separate source. Authoring the no-panel lens covers them.

2026-07-12 (v1.10.0 probe): the panel-world dead-zone clip is IN D2DX. Floor geometry crosses grDrawVertexArrayContiguous at max 1296 (138 verts in [960,1280)) yet the dead zone is BLACK. NOT D2Client (issues 1236), NOT D2Glide (submits past 960). The [640,960] tiles render via the SAME path, so the [960,1280] verts are valid, not degenerate -> D2DX clips them. Fix belongs at D2DX via a runtime glide3x hook from esoteric.dll (rebuild not available here).

2026-07-12 (workflow d2dx-panel-clip-fix, source+bytes): D2DX renders the world into its NARROW _gameSize={960,720} (Metrics.cpp desktop 1280x720). Clip cutoff == 960 == _gameSize.width: framebuffer sized to gameSize (SetFramebufferSize), UpdateViewport sets RSSetViewports+RSSetScissorRects to that rect, GameVS.hlsl NDC.x/960 -> x>=960 off-RT+out-of-scissor+NDC>1, rasterizer-clipped. The SurfaceIdTracker retag (minx>=gameSize/2) is a RED HERRING (surfaceId only feeds FXAA, color write unconditional). Fix = force gameSizeWide via SetCustomResolution(1280,720).

[SUPERSEDED 2026-07-12: the 640 was the CULL with GlideUnclamp=0. Gated probe with GlideUnclamp=1 -> submit 1264, 338 verts in the dead zone, still black => the binding clip is a D2DX-downstream DROP, not D2Glide 640.] CORRECTION 2026-07-12 (v1.10.0 probe, PANEL-OPEN frames): with a panel open, the D2Glide live drawer 0x6F856840 submits floor geometry to grDrawVertexArrayContiguous at max screenX ONLY 640 (=DisplayWidth/2, the mode-1 right bound), band[960,1280)=0. D2Client still ISSUES to 1280 (TILEBAND). So the binding panel-open clip is D2Glide 0x856840 at 640, NOT D2DX. My earlier 'crosses at 1296 -> D2DX' read used NO-PANEL frames (before [WIDEN] mode=1) by mistake -- the harness was right, I read the wrong frames. finding.panelworld_clip_in_d2dx and finding.d2dx_gamesize_960 describe the NO-PANEL/second clip; the panel-open lever is here. Likely TWO clips: D2Glide 640 (panel) + D2DX 960 target; both need fixing. v1.9.1 cull-NOP showed no visual change -> re-testing GlideUnclamp WITH the probe to see if it widens the submit past 640 (cull-skip) or the 640 is a vertex-X clamp elsewhere in 0x856840.

Council wave-4 (chat m5 + clau m6 converge): the panel-open dead zone is the 960-WIDE RENDER-TARGET EXTENT, not a surfaceId routing/split. D2Glide announces 960 gameSize to D2DX at grSstWinOpen; SGD2FreeRes widened D2 to 1280 without updating that; D2DX allocates a 960 world RT and clips the 1280-coord floor. Fix they gave = D2DXGetConfigurator->SetCustomResolution(1280,720) before grSstWinOpen. STATUS: we BUILT this (feature_d2dx.c / D2DXWiden) -> 122 successful calls but it REGRESSED the menu res and did NOT fill. So their consensus fix is tested-and-insufficient.

Council wave-4 dissent (gem m4): the drop is the UI-RETAG. D2DX SurfaceIdTracker:88 retags world batches with minx>=640 as USER_INTERFACE when a panel is open; retagged verts get the UI orthographic projection (wrong for world coords) and render into the void = black. Fix he gave = hot-patch the minx>=640 Jcc in glide3x to fail ONLY during the floor draw call, then restore. NOTE: clau m6 REFUTES this - [640,960) is retagged too yet renders fine, so a rule that fires on visible geometry can't be the blackout rule.

Council wave-4: BOTH chat m5 and clau m6 demanded a PRE-PATCH measurement we never ran -- read D2DX's ACTUAL D3D11 world render-target width + viewport (RSGetViewports width; OMGetRenderTargets->GetDesc width/height) at the first Game-pass Draw, plus grSstWinOpen incoming args. chat's decision tree last branch: 'viewport 1280, RTV 1280+, constants 1280, still cutoff at 960 => your binary differs; next hook is ID3D11DeviceContext::Draw, inspect bound VS/PS and MRTs on the first missing floor batch' -- NOT SurfaceIdTracker.

Doug reframe 2026-07-12: the dead zone, the panel-open camera SHIFT, and the world-vs-units DESYNC are ONE cause -- opening a panel CHANGES THE WORLD VIEW-STATE (offX=-320 + play-area narrowing). Clean target: render the world in the NO-PANEL view-state (no shift, full width) and composite the panel on top = ONE view-state (matches the ledger META-LESSON). Neutralize the change AT ITS SOURCE (the panel-open handler 0x6FB5AEC0 writing offX @0x6FB5AF7C), leaving the mode flag 0x6FBCC414 intact for culling (attempt A proved mode is load-bearing).

RETIRED CONSTRAINT: 'keep the native -320 left-shift' (offX=0x6FBCC418, written @0x6FB5AF7C). Preserved through attempts A-H. Doug 2026-07-12 REVERSES it: wants ZERO shift on panel-open (world stays put, panel composites on top). 'both moves are inappropriate when opening the inventory if we have the world behind as we want.'

Doug confirms 2026-07-12: panel-open, the WORLD shifts HALF as much as characters/items (units = ~2x world). Ledger theories (both unconfirmed): (a) multi-layer shift (floor vs wall/roof/units = separate draw fns), (b) double motion-smoothing (d2fps + D2DX both interpolate the camera move -> 2x on moving units, 1x on static terrain). Exactly-2x favors (b). MEASURE before patch: log offX(0x6FBCC418) + ctx+0x24 world-scroll + one unit screenpos, panel-open vs closed.

CONFIRMED 2026-07-12 (v1.11.2 panel-gated probe, mode=1, GlideUnclamp=1): floor geometry REACHES the dead zone at the D2Glide->D2DX seam -- submit max 1264-1296, 338 verts in [960,1280) -- yet renders BLACK. The dead-zone black is a DROP at/after D2DX, NOT a D2Glide clip (GlideUnclamp already carries the submit to 1264). Independently reproduces council wave-4 (geometry crosses into D2DX in the dead zone, black). Next diagnostic = the council's demanded D2DX world-RT-width read (extent 960 vs UI-retag). SEPARATE from the world/objects SHIFT desync.

CONFIRMED 2026-07-12 (v1.11.3 [SHIFT] snapshot, standing still): opening a side panel shifts the FLOOR/terrain by exactly -320 (1x = -DispW/4), and the WHOLE shift is offX(0x6FBCC418) 0->-320 driving ctx+0x04 0->-320. scrollX(ctx+0x24) is NOT touched by the panel (log changes there = the player walking). Terrain pan (ctxL - scrollX) moves -320. So the terrain-shift LEVER is offX->ctx+0x04. The objects-2x is a SEPARATE source: the shared tile projection is only 1x, so units (PASS2, a separate draw fn) pick up an EXTRA -320 downstream, NOT the camera/ctx. Which source (unit re-read of offX vs motion-smoothing) is unmeasured.

CONFIRMED 2026-07-12 (d2re xref 0x6FBCC418): offX is READ at 173 sites across D2Client, but WRITTEN once (0x6FB5AF7C, =-DispW/4=-320 on panel-open). So the surgical lever is the single write, not the 173 reads (blanket-patching reads = ledger attempt A = infeasible). CROSS-REF attempt A (held offX=0): un-shifted FLOOR + UNITS but NOT walls/roofs (a SEPARATE shift source) AND broke click-to-move (the hit-test reads offX). CONCLUSION: the panel shift is MULTI-SOURCE (offX for floor/units; a different global for walls/roofs) and HIT-TEST-COUPLED. Units read offX twice -> the 2x (theory a favored; not proven vs motion-smoothing). Naive offX=0 is OUT (already failed). The reframe goal (render world in no-panel view-state) needs an architecture decision, not a single patch.

Council wave-5 (all 3 CONVERGE): kill the panel shift by AUTHORING a coherent NO-PANEL WORLD VIEW-STATE for the whole world-draw -- NOT per-value patching, NOT a mid-frame ctx swap (that's the C-G scheduling trap: 173 readers read at different times, no single safe instant). Two flavors: m1(chat)=post-hook the panel-transition routine (holds offX write 0x6FB5AF7C); after it runs, canonicalize the world-camera outputs (offX=0, wall/roof offset=0, ctx+0x04=0, ctx+0x0C=DispW) and HOLD persistent; keep ScreenOpenMode=1/2 (UI+input stay live). m2(gem)+m4(clau)=STATE-SPOOF: hook the world-draw, temporarily set the panel-state flags to 0 (lie 'no panel open'), call original (D2 naturally zeroes offX + wall offsets + hit-test), restore flags before the panel compositor 0x6FB739E0 -> ONE hook, hit-test solves itself, UI intact. Hit-test coherent BY CONSTRUCTION (render + mouse ray read the same authored state).

Council wave-5 CRITICAL LINK (m2 gem): the SHIFT fix and the dead-zone BLACK are the SAME downstream issue. Unshifting the world pushes valid geometry into x>=640; D2DX SurfaceIdTracker:88 retags world batches minx>=640 as USER_INTERFACE while a panel is open -> the UI orthographic projection drops those world verts -> black/corrupt right half. So authoring the no-panel view in D2Client is NECESSARY BUT NOT SUFFICIENT: we must ALSO defeat the D2DX minx>=640 retag during the world draw (runtime hot-patch the compare in glide3x, restore after). Defeating that retag IS the fix for the black.

ATTEMPT I (v1.12.0, council wave-5 recipe): author the NO-PANEL world lens each frame before PASS1 -- in the existing widen hook (0x6FAF4302), when a panel is open set offX(0x6FBCC418)=0, ctx+0x04(draw_left)=0, ctx+0x0C(draw_right)=DispW, dirty|=1; ScreenOpenMode left TRUE (culling+UI live). Grounded: the panel handler 0x6FB5AEC0 writes ONLY offX+mode from DisplayWidth (no separate wall global), so this run also DIAGNOSES OQ.walls_shift_source. OUTCOMES: (a) floor+walls+units all un-shift (character/waypoint bisected by panel) => walls' source IS the ctx, blocker closed; (b) floor+units un-shift but walls stay => walls recompute in PASS2 (0x6FB3B110) => name that next; (c) clicks coherent? (offX=0 persistent should self-solve per m1/m2); (d) x>=640 goes black => D2DX SurfaceIdTracker retag confirmed = the 2nd knob (m2). ==> RESULT (v1.12.0, WIN): [NOSHIFT] fired once (offX -320->0, ctxL -320->0, ctxR->1280) and HELD every frame (offX 0->0). The WORLD UN-SHIFTED -- character/waypoint bisected by the panel, walls came with it, clicks fine. Geometry reaches the dead zone (probe band[960,1280)=66-104, TILEBAND max=1277). TWO residuals remain: (1) the dead zone is still BLACK = the D2DX retag (m2's 2nd knob); (2) 1-2 FLOOR sub-layers still shift (a source our ctx authoring doesn't cover). The multi-source shift is otherwise SOLVED by authoring the no-panel lens each frame.

THE FLOOR + THE MOUSE HIT-TEST are governed by the SAME play-area rect: playAreaW (0x6FBA9E14, RVA 0xF9E14) / playAreaH (0x6FBA9E18), narrowed to ~640 on panel-open. This is the '4-tile buffer'/Hall-of-Mirrors region: the world isn't rendered there by default. SOURCES (all trusted): EP's own d2-re-reference v0.8 note (playAreaW view struct, 'same rect governs mouse hit-test -> the non-clickable black') + our diag.c RD(0xF9E14); phrozen_code Discord 2022-11 -- Necrolis: 'd2dx might be doing it via a clipping rect' (= the RenderContext viewport/scissor we re-found); Mir Drualga (SGD2FreeRes author): 'those black rects are hardcoded in SGD2FreeRes to hide the HOM from not adding assets'; EP: 'a 4 tile buffer... also appears on the left if you open the character stats pane'. FIX (v1.12.2): author playAreaW=DispW each frame -- the bottom-void fix on the horizontal axis. Should make the floor cover the dead zone AND make click-to-move work standing still (currently only works while moving).

THE FLOOR SHIFT IS INTERNAL TO PASS1 (0x6FB3B0C0), not a pre-authorable global. Authoring the no-panel lens each frame BEFORE PASS1 (offX=0, ctxL=0, ctxR=DispW) un-shifts WALLS + UNITS perfectly (they read ctxL) but the FLOOR still shifts. Ruled out, each a NO-OP at our pre-PASS1 hook: playAreaW(0x6FBA9E14)=already 1280; nViewXOffset(D2FloorTileParamsStrc 0x6FB9A9CC, EP's 'terrain shift')=already 0 ([FLOORPARAMS] never fired). Yet the floor is ISSUED full-width (TILEBAND tiles reach screenX 1278, 637 in [960,1280)) -- so it's drawn wide but at the SHIFTED position. The floor-flush projection we RE'd (screenX=ctx+0x04 - ctx+0x24 + tileAbsX) SHOULD use our ctxL=0; since the floor is shifted anyway, the FLOOR uses a different scroll/offset OR its collected tileAbsX carry the shift. Candidate: the DrawGame scratch scroll (0x6FBA9F60/5C) the passes overwrite. Need to hook INSIDE PASS1 or find the floor's internal horizontal source.

CONVERGENCE: the floor's shift is applied at a point our PASS1-call hook (0x6FAF4302) MISSES -- we zero the globals AFTER the floor grabbed the shifted value. Candidates: (m4/clau) the floor SNAPSHOTS the scratch scroll at the DrawGame prologue (0x6FAF42E0 mov[0x6FBA9F60],ecx / 0x6FAF42E6 mov[0x6FBA9F5C],edx from ctx, at the TOP of DrawGame, before our hook) OR bakes the shift into tileAbsX at room COLLECTION (tilesub pre-projects); (m2/gem) the floor's D2Gfx draw-offset (ctx+0x04) is set early via D2Gfx_SetDrawOffset before our hook -> hook HIGHER; (m1/chat) the floor submits the CORRECT unshifted X and D2Glide applies -DispW/4 INTERNALLY via its nScreenPanels arg in the live drawer 0x6F856840 -> force nScreenPanels=0 for the floor path. DECISIVE delta (m1): track one floor tile's submittedX (D2Client) vs vertexX (D2Glide) panel-open vs closed -- clientDelta=-320 => upstream (D2Client); glideDelta=-320 => D2Glide. v1.12.4 tests the scratch-scroll hypothesis (author 0x6FBA9F60/5C = ctx + log the delta). UNIFYING PIN (m4): both the floor AND the click are a value = DispW-320 that our hook doesn't reach; one resolution-differential scan collects EVERY DispW-320 address.

TWO side-answers for later. (1) MENU shrink from SetCustomResolution(1280): no native menu-exclusion; scope it DYNAMICALLY by D2 client state -- hook the game-enter/exit (state 0x01 menu / 0x03 in-game) and toggle SetCustomResolution(800 menu / 1280 in-game), or gate it in the top-level render dispatch. (2) CLICK-into-black-only-while-moving (m4): it's the click-to-move path-VALIDITY / acceptance rect, a separate rect derived from DispW-320, refreshed only by motion (stale when standing still). Fix: widen the acceptance rect (find via the resolution-differential DispW-320 scan); if clicks then register but won't path, force the walkable-region refresh independent of motion.

NEW LEADING THEORY (m10, corroborated by m12): the floor/roof shift is a D2DX POST-SUBMIT bug, not a D2Client origin. (1) D2DX SurfaceIdTracker retags world batches with minx>=gameSize.w/2(=640) as USER_INTERFACE when a panel is open. (2) In OnBufferSwap, D2DX applies the player MOTION-PREDICTION offset ONLY to surfaceId!=UI && cat!=Player -- so the UI-mislabeled floor/roof batches SKIP the camera offset while the walls get it -> they slide apart AS the prediction changes with click-to-move = 'follows the mouse'. Isolated batches (the palace doorway) most susceptible. Ruled out upstream: offX held 0, floor still shifts (D2Client camera not the source). m12: the mouse-tracking PROVES live-read (not baked at collection); the black split MIRRORS sides with the panel = a compositing/retag split, not a clip. DEFINITIVE TEST (m10): d2dx.cfg [optouts] nomotionprediction=true -> if the slide stops, confirmed. FIX (m10, keeps motion pred): in the grDrawVertexArrayContiguous hook, temporarily set ScreenOpenMode(0x6FBCC414)=0 for WORLD-TILE calls only (filter by return addr: D2Glide+0xBEFC DrawFloor, +0x67AB/+0x67B9 DrawWall1/2), restore after -> D2DX won't retag the floor as UI. Start with +0xBEFC.

THE FLOOR AND WALLS SUBMIT FROM DIFFERENT D2Glide CALL SITES (verified via disasm of the call to the grDraw wrapper 0x6F856026): DrawFloor -> 0x6F85BEF7 call (return 0x6F85BEFC = D2Glide+0xBEFC); DrawWall1 -> 0x6F8567A6 (return 0x67AB); DrawWall2 -> 0x6F8567B4 (return 0x67B9). Our glidevtx probe was filtering return-addrs [0x6840..0x6B40] = the WALL calls, so all our floor-drawer RE + the FloorCompX seam-compensation were hitting the WALLS, not the floor -- which is exactly what Doug saw (the correctly-placed tiles moving by +320). CORRECT floor filter = 0xBEFC. chat's public-1.13c-table mapping (DrawWall1/2=0x67AB/0x67B9, DrawFloor=0xBEFC) is CONFIRMED for our build. v1.12.6 + INI: glidevtx arg=0xBEFC, FloorCompX=320 -> compensate the FLOOR at its seam.

FLOOR+ROOF SHIFT LEDGER (evidence-backed; walls+units are FIXED, floor+roof still shift when a panel opens). Each source RULED OUT with version+log: * WALLS/UNITS fixed: v1.12.0 authoring no-panel lens (offX=0/ctxL=0/ctxR=DispW) pre-PASS1. PROVEN: [NOSHIFT] log fires each frame + visual (walls/units snap into place). * offX (0x6FBCC418): RULED OUT v1.12.5. PROVEN: [SHIFT] 'offX 0->0' held every frame, floor STILL shifted. * playAreaW (0x6FBA9E14): RULED OUT v1.12.2. PROVEN: [NOSHIFT] 'playAreaW 1280->1280' (already full, no-op). * nViewXOffset (D2FloorTileParamsStrc 0x6FB9A9CC): RULED OUT v1.12.3. PROVEN: [FLOORPARAMS] NEVER logged (condition fvx!=0 false -> already 0 at our hook). * scratch scroll (0x6FBA9F60/5C): RULED OUT v1.12.4. PROVEN: [SCRATCH] NEVER logged (already == ctx scroll). * D2Glide drawer 0x856840 vertex math: RULED OUT by DISASM -- vertexX = baseX + subtileX; the 640 midpoint feeds ONLY the cull bounds ([esp+0x30]/[esp+0x38], already NOP'd), no -DispW/4 on the vertex. * D2DX motion prediction: RULED OUT -- d2dx.cfg nomotionprediction=true -> no change (Doug); + the shift is STATIC not dynamic (Doug correction), which motion-prediction wouldn't produce. * grDraw site 0xBEFC (chat's 'DrawFloor'): RULED OUT v1.12.6. PROVEN: [PROBE glidevtx] arg=0xBEFC -> count=0 (0 hits). 0x6F85BEF7 IS a call site on disk but is NOT on the live floor path in our build. VERIFIED-live: WALLS submit via grDraw returns 0x67AB/0x67B9 (disasm: 0x6F8567A6/B4 call the wrapper 0x856026; probe with arg=0x6840 fired in v1.11-1.12.5). 0x6840==walls is INFERRED (Doug: compensating that filter moved the CORRECTLY-placed tiles) + chat labels them DrawWall1/2. OPEN: the FLOOR's actual LIVE grDraw return address is UNIDENTIFIED (not 0x6840=walls, not 0xBEFC=count0). RIGOROUS NEXT: an UNFILTERED return-address logger (probe arg=0) that dumps every distinct grDraw return addr + its vertex-X range + count -> identify the floor by its signature, THEN compensate/fix that exact site.

CONVERGENCE: measure the floor batch's vertex X at the grDraw seam, panel-CLOSED vs panel-OPEN. dMinX=-320 => D2Client submits the floor shifted (UPSTREAM); dMinX=0 => D2DX shifts it (DOWNSTREAM). Also capture the caller return-addr to NAME the floor's live site (our 0xBEFC guess fired 0x). chat: D2DX's 0xBEFC 'DrawFloor' is only an IdentifyGameAddress label, not the live path; forward is unchanged (OnDrawVertexArrayContiguous copies x/y verbatim). gem: if downstream, read D2DX's VS projection matrix via a D3D11 VSSetConstantBuffers vtable hook (matrix[12]=X translation). clau: DISSENT-then-agree -- 'mouse kills it' argument uses the RETRACTED mouse-tracking premise (Doug corrected to STATIC), so its mouse-sweep isn't our discriminator; BUT clau's mouse-INDEPENDENT argument is strong: walls render correct through the SAME D2DX pipeline, so if D2DX shifted world batches walls would shift too -> predicts dMinX=-320 (client-side). clau CAUTION taken: do NOT do the ScreenOpenMode=0 mask (attempt-A anti-pattern: fixes readers who look, misses others, desyncs hit-test). IMPLEMENTED v1.12.7 [Probes] Survey=1 + glidevtx arg=0 -> [SURVEY] rows per caller, closed vs open.

THE LIVE grDraw CALLERS (v1.12.8 Survey, panel-CLOSED only so far): D2Glide+0x6A55 (n=87710, x=-32..1296, the dense one), 0xA344 (n=16767, x=0..1151), 0xA555 (n=5340, x=303..1152), 0x704A (n=895, x=1216..1296), 0x9AF4 (n=293, x=11..788). CORRECTION (rigor): finding.floor_vs_wall_grdraw_sites claimed walls=0x67AB/0x67B9 (from disasm of call sites 0x6F8567A6/B4) -- but those return-addrs DO NOT APPEAR in the survey, so they do NOT fire on the live path. The disasm found call sites that aren't reached. The REAL callers are the 5 above. Still OPEN: which is the FLOOR (need panel-OPEN data -> the caller with dMinX~-320). v1.12.8's run was the menu run (open[n=0] everywhere); a park+toggle run is needed. NOTE the survey only counts IN-GAME frames (eso_probe_frame runs from the DrawGame hook, not at the menu).

MENU FIX. v1.12.9 grSstWinOpen log: the IN-GAME open = res=4099(0x1003) with worldCtx=0x214439AC (NON-NULL); the MENU opens = res=7 and res=4097 with worldCtx=NULL. The world render ctx (*0x6FBCC3C4) is set at the in-game open and null at the menu -> gate is worldCtx!=null. FIX v1.13.0: eso_d2dx_set_wide calls SetCustomResolution(1280) only when worldCtx!=null -> menu keeps native size, in-game world stays widened. (grSstWinOpen arg1=window handle; the resolution is arg2=[esp+0x2C].)

SURPRISE: the floor shift is likely DOWNSTREAM in D2DX, not at the D2Client->grDraw submit. Survey open-vs-closed, 5 live callers: 0x6A55 (floor, n=828558, closed x=-32..1311 / open x=-32..1296 => dMinX=0, dMaxX~-15: STABLE, NOT shifted at submit); 0x09AF4 (dead-zone FILL, open x=640..1280 n=22082 = the world we enabled behind the panel, WORKING); 0xA555 (dMinX=-84); 0xA344 (dMinX=33); 0x704A (dMinX=16). NO CALLER submits shifted by -320. So the floor is submitted un-shifted and D2DX shifts it downstream => chat/gem's branch, AGAINST clau's client-side prediction (reconciled: D2DX shifts only floor-category batches, not walls). CAVEAT: aggregate min/max is confounded by the changing tile set on open, but the ABSENCE of any -320 across all 5 callers is robust. nomotionprediction=true gave no change, so it's a D2DX transform OTHER than motion-prediction. NEXT: specific-tile track OR gem's D3D11 VSSetConstantBuffers matrix read.

BREAKTHROUGH: the -320 FLOOR/ROOF shift source is ScreenShiftX = D2Client+0x11B9A0 (mir names it 'ScreenShiftX'; planqi names 0x11B9A0 'PanelOffsetX -- horizontal shift applied when side panels are open'). SGD2FreeRes REPLACES vanilla SetScreenShift with Sgd2fr_D2Client_SetScreenShift (set_screen_shift/replacement.cpp L54-63; hook D2Client+0xC39F6 in 1.13c, found via write-BP on ScreenShiftX/Y): screen_shift_x = display_width/2 - 640/2 => at 1280 wide = 640-320 = the centering shift. The floor/tile projection reads ScreenShiftX. Our no-shift lens zeroed offX (GeneralPlayAreaCameraShiftX 0x11C418) + ctx draw_left -- fixing WALLS+UNITS -- but NEVER touched 0x11B9A0, so FLOOR/ROOF stayed shifted. That is the exact residual. NEXT: author 0x11B9A0=0 each frame alongside offX (or neutralize the SetScreenShift hook @0xC39F6); x32dbg live-read of 0x11B9A0 panel-open expects the -320-class value.

OVERTURNS finding.survey_floor_is_downstream. Full source read of D2DX (bolrog + Necrolis fork): D2DX applies NO per-category floor-vs-wall positional transform -- TextureCategory::Floor(4)/Wall(6) are never used to offset geometry (GameHelper::RefineTextureCategoryFromGameAddress only TAGS batches for AA). The ONLY post-capture world shift is UnitMotionPrediction (D2DXContext.cpp OnBufferSwap ~408-436): UNIFORM across all world geometry (floor AND wall), skipped only for surfaceId==USER_INTERFACE(16383). We already set nomotionprediction=true -> no change. RenderContext::UpdateViewport sets ONE uniform viewport+scissor; Constants CB carries only screenSize/invScreenSize, no translate. => the -320 floor shift is NOT downstream in D2DX; it is upstream (ScreenShiftX). The survey's dMinX 'downstream' read was an artifact of the confounded aggregate + not having neutralized 0x11B9A0.

The panel/dead-zone architecture SGD2FreeRes imposes (clean-room from its develop-branch source): (1) SetGeneralDisplayWidthAndHeight -> GeneralDisplayWidth/Height (0xDBC48/4C). (2) SetScreenShift (hook D2Client+0xC39F6) -> ScreenShiftX/Y (0x11B9A0/4) centering = the -320 floor shift. (3) SetTileCullingBound (hook D2Client+0x8A4D0; CullingSpec{flags@0x0, draw_window_rect RECT@0x4}) -> tile draw + cull windows. (4) DrawLeft/RightScreenBackground (hook D2Client+0xC3AA6) -> paints the BLACK dead-zone: d2gfx::DrawRectangle(0,0,width/2,height) 'to stop transparent-DC6 cheaters' + tiles 800BorderFrame around the 640 play area; stock bg draws NOP'd at +0x271ED / +0x270F1. => black perimeter = DrawScreenBackground; floor shift = SetScreenShift. To reveal the world behind the panel: neutralize DrawScreenBackground and zero ScreenShiftX.

LIVE against the running 1.13c binary (esoteric.dll mod ON), via elevated ReadProcessMemory/WriteProcessMemory. (1) worldCtx (D2Client+0x11C3C4) CONFIRMED null@menu, non-null in-game (0x214739D4) -> verifies finding.menu_worldctx_gate vs the binary. (2) FALSIFIES finding.screenshiftx_is_floor_shift: ScreenShiftX (0x11B9A0) = +320 CONSTANT in-game (SGD2FreeRes centering, re-written per-frame), identical in mode 0/1/2; a live freeze of 0x11B9A0=0 did NOT move the floor (only a border element flickered) -> the FLOOR does NOT read ScreenShiftX. (3) PANEL-DELTA SCAN (12 globals + render-ctx struct fields, panel-closed vs inventory vs character): opening a panel changes NO horizontal shift global -- ScreenShiftX, offX(0x11C418; our lens holds 0), OffsetPtX(0x11C1F8=0), ctxL(0), ctxR(1280), playAreaW(0xF9E14=1280) ALL constant across mode 0/1/2. Only ctxScrollX(=global 0x119960) and mouse offsets vary, and that is CAMERA MOVEMENT (character walking), not the panel. (4) CONCLUSION: the floor residual shift is STATIC (matches Doug: 'always shifted, not sliding') and is driven by NO authorable global on panel-open -> it is INTERNAL to the floor pass (PASS1 / FloorFlush 0x9ED50), a constant floor-vs-wall X-base difference. Re-confirms finding.floor_shift_internal_to_pass1; global-poke approach exhausted. NEXT: x32dbg breakpoint inside FloorFlush 0x9ED50 with a panel open -> read the X base the floor computes and compare to the wall pass (PASS2 0x8B110). RPM cannot observe internal computed values.

CORPUS-CONFIRMED floor-shift mechanism -- converges with finding.floor_shift_internal_to_pass1. The FLOOR is a SEPARATE drawer from walls/roofs (Necrolis: MULTIRES_DrawGroundTiles vs DrawLowerWallTiles/DrawUpperWallTiles/DrawRoofTiles; SwineFlu confirms floor is a distinct recursive fn per Necrolis's reversed code at d2mods.info t=59615). Floor horizontal placement = D2FloorTileParamsStrc @ D2Client+0xEA990 (0x6FB9A990, sizeof 0x44): nScreenPanels(+0x20)=which panels open, pView(+0x24), clip nXMin/Max nYMin/Max(+0x2C..0x38), nViewXOffset(+0x3C = D2Client+0xEA9CC)/nViewYOffset(+0x40). Necrolis: 'anyone chasing the D2DX floor -320 shift should hook the FILL of this struct and watch nScreenPanels -> nViewXOffset.' Struct filled INSIDE the floor path (1.10f fill 0x6FAA3330 -- rebase to 1.13c by xref of writes to +0xEA990). EXPLAINS why our lens fails on the floor: pre-PASS1 hook authors the render ctx (walls read it -> fixed) but nViewXOffset is set LATER internally from nScreenPanels; our ledger's 'nViewXOffset already 0' was a PRE-fill timing error. FIX: hook the struct fill / DrawGroundTiles and zero nViewXOffset (or force nScreenPanels=0 for the floor pass only) so floor matches the unshifted walls. Cull rect = D2RoomCullArgsStrc{pView,pCullingRect,pClientRoom,bTilesOnly} (Necrolis).

ROOT CAUSE PINNED. The floor+roof static -320 shift is ctx[+0x24] (scrollX), NOT ctx[+0x04] and NOT any global we ruled out. TWO PROJECTION FAMILIES: (1) FLOOR+ROOF flush @0x6FB4ED50 (D2Client+0x9ED50): screenX = ctx[+0x04](drawL) - ctx[+0x24](scrollX) + tileAbsX -- NO offX term. (2) WALLS+UNITS project via offX=ScreenXShift 0x6FBCC418 (RVA 0x11C418) which our lens zeroes -> they re-center. ctx = *0x6FBCC3C4 (RVA 0x11C3C4) = the SAME struct the lens writes (confirmed: both callers of tile drawer 0x6FB4EC10 -- 0x6FB3B224 in PASS2 + 0x6FB4EE7A -- push edi=ctx; PASS1 0x6FB3B0C0->DrawRooms 0x6FB2A9F0 on same ctx). So ctx[+0x04]=0 DOES reach the floor -> not the residual. THE 320 ENTERS ctx[+0x24] at DrawGame 0x6FAF4230: scrollX = scrollCenterX(thunk 0x6FABC1D2 on view *0x6FBCBBFC=playerBase) - (R-L)/2 (0x6FAF4270-79), written 0x6FAF42F8 'mov [esi+0x24],ecx' (esi=*0x6FBCC3C4) right before PASS1 call 0x6FAF4302. Lens moves ctx[+0x04]/[+0x0C] SYMMETRICALLY (-320,960->0,1280) so R-L stays 1280, (R-L)/2 stays 640, scrollX UNAFFECTED -> panel camera re-center +DispW/4=320 survives in ctx[+0x24]. Floor pan = 0-(scrollX_nopanel+320) = static -320. DispW/4=1280/4=320. Roof same path. SUPERSEDES finding.screenshiftx_is_floor_shift, finding.survey_floor_is_downstream, finding.d2floortileparams_floor_shift (that struct was 1.10f). FIX: correct ctx[+0x24] to hold no-panel pan before PASS1 (extend lens; ctx[+0x24]-=DispW/4 for open-panel side, sign per ScreenOpenMode 0x6FBCC414). Floor+roof only. Confirm sign/magnitude via one live RPM of ctx[+0x24] panel-open vs closed standing still.

DEFINITIVE ROOT CAUSE of the floor/roof panel-shift. It is in SGD2FreeRes.dll (loaded @0x739C0000), NOT D2Client -- D2Client's whole floor path is 100% VANILLA (verified by live-vs-disk patch map: DrawGame 0x44230, scroll write 0x442F8, floor flush 0x9ED50, floor drawer 0x9EC10, DrawRooms 0x7A9F0, PASS1 0x8B0C0, PASS2 0x8B110 all byte-identical to disk). SGD2FreeRes hijacks SetTileCullingBound: D2Client+0x8A4D0 is patched 'jmp 0x739C16B0' (trampoline) -> real fn 0x739D21D0. Inside 0x739D21D0 a PANEL-CONDITIONAL block: 0x739D2212 call 0x739D64A0 (nonzero when a side panel open); 0x739D221A je 0x739D2230 (skip if none); 0x739D221C add [ebx+4],0xFFFFFF60 (top-=160); 0x739D2223 add [ebx],0xFFFFFEC0 (LEFT-=320=DispW/4=0x140); 0x739D2229 add [ebx+8],0x140 (RIGHT+=320). ebx = the tile-cull/draw window (arg+0x14). => on panel-open SGD2 moves the floor's tile window by +/-320. The vanilla flush (screenX = ctx+0x04 - ctx+0x24 + tileAbsX) then faithfully draws the shifted tiles; walls read offX (our lens holds 0) so they don't move -> floor vs walls split by 320. RECONCILES the paradox that render ctx (drawL/scrollX) measured FLAT open-vs-closed (floor_scan same-position: both drawL=0 scrollX=-208, delta 0): the shift rides in tileAbsX collected from the shifted cull window, NOT in the ctx. Other SGD2 hooks confirmed live: SetScreenShift 0xC39F6 -> 0x739D1F80; DrawScreenBg 0xC3AA6 -> 0x739C10B0; stock left/right bg NOP'd @0x271ED/0x270F1. FIX target: neutralize/adjust the panel block at 0x739D221C or its gate je@0x739D221A (NOP-test flips je->jmp). CONFIRMED SHIFT (Doug's 3 screenshots: no-panel centered, inventory=world pushed left, character=pushed right).

FLOOR-SHIFT HYPOTHESIS LEDGER (chain of superseded theories, each with why it fell): (a) ScreenShiftX D2Client+0x11B9A0 -- FALSIFIED live (WriteProcessMemory froze it to 0, floor did not move; only a border flickered). (b) 'D2DX shifts floor-category downstream' -- FALSIFIED by reading bolrog+Necrolis D2DX source (NO per-category transform; only uniform UnitMotionPrediction, and nomotionprediction=true gave no change). (c) D2FloorTileParamsStrc.nViewXOffset @0x6FB9A990/0x6FB9A9CC -- FALSIFIED: that instance address is 1.10f, ZERO refs in our 1.13c DLL (xref + immediate byte-search); the struct LAYOUT transfers but the 1.13c instance differs. (d) 'ctx+0x24 scrollX carries +320' (5-front on-disk disasm assault) -- FALSIFIED live: floor_scan same-position closed-vs-open showed drawL=0/scrollX=-208 in BOTH (delta 0). (e) CONFIRMED: SGD2FreeRes SetTileCullingBound live patch shifts the tile-cull window +/-320 on panel-open (finding.floor_shift_sgd2_tileculling). META-LESSON: (a)-(d) all came from analyzing the ON-DISK vanilla DLL. The shift is in a MOD's live patch. Doug flagged the layered-mod interaction; the live-vs-disk patch map resolved it. Also: a same-position live read (stand still) is required -- 20-min-apart readings are confounded by camera movement.

FREEZE-scrollX TEST (hammered ctx+0x24 = *(D2Client+0x11C3C4)+0x24 from -240 to -600, 3439 writes/30s): BOTH floor AND walls flickered/slid (Doug: 'a lot of flickering on the walls and floors'). CONCLUSIONS: (1) the D2Client flush 0x6FB4ED50 / render-ctx path IS the LIVE world render -- SGD2FreeRes does NOT draw the floor via its own renderer; the vanilla screenX = ctx+0x04(drawL) - ctx+0x24(scrollX) + tileAbsX is what shows. Rules IN the D2Client path. (2) CORRECTS finding.floor_shift_is_ctx_scrollx: walls do NOT use offX-not-scrollX -- BOTH floor and walls read ctx+0x24. The world renders as a unit through this ctx. (3) By elimination: drawL+scrollX are FLAT panel-open-vs-closed (floor_scan same-position delta 0), the flush is live, so the panel shift can only ride in tileAbsX (the COLLECTED tile coords). Leading theory: our no-shift lens forces drawL=0 AFTER DrawRooms already collected tiles using the game's shifted drawL (the council-wave-6 'hook too late'). ALSO: NOP of SGD2 SetTileCullingBound panel-block (0x739D221C) had ZERO impact -> that cull-widen is not the shift. NEXT: read tileAbsX/screenX at the flush (codecave probe or hardware BP) panel-open vs closed; and re-check WHEN our lens sets drawL vs when DrawRooms reads it.

OBJECTIVE PIXEL-PRECISE MEASUREMENT of the floor shift. Setup (Doug): Barbarian standing on the Act1 encampment waypoint, no merc, no effects. The waypoint = co-located FLOOR marker (brown cross-diamond) + UNIT markers (blue swirls). Captured game frames closed vs open, template-matched each marker: waypoint brown-cross (FLOOR tile) moved LEFT 480 screen-px (dy 0, conf 0.56); blue swirl (UNIT) 0px (conf 0.82); campfire embers (OBJECT) 0px (conf 0.68); walls 0 (prior overlay). Screen is 1920w upscaled by D2DX from game-render 1280 (DispW) => factor 1.5 => 480 screen-px = 320 GAME-px = exactly DispW/4. DEFINITIVE: the FLOOR-TILE LAYER shifts exactly DispW/4 = 320 game-px LEFT on panel-open; units/objects/walls hold at 0 (offX layer, our lens already fixes them). Confirms Doug's exact claim to the pixel. RECONCILES the whole investigation: the render ctx (drawL/scrollX) reads FLAT open-vs-closed because the 320 rides in the collected floor tileAbsX, NOT the camera scalars; the earlier full-floor overlay aliased the 320 (=~5 tiles) but the waypoint's non-periodic cross revealed it. Method note: capture the game window via PIL ImageGrab (D2DX/D3D content grabs fine); measure in GAME-space = screen/1.5. FIX TARGET: un-shift the floor tile collection (tileAbsX) by DispW/4. Ruled out as the source: ScreenShiftX 0x11B9A0 (poke null), SGD2 SetTileCullingBound cull-block 0x739D221C (NOP null), the render ctx (flat). It is in the floor tile-coordinate computation (DrawRooms / the floor pass tileAbsX).

The world render context. Instance pointer = *0x6FBCC3C4. It IS the world view-state: the tile projection reads screenX = (+0x04) - (+0x24) + tileAbsX, screenY = tileAbsY - (+0x28) + (+0x08). A side panel writes +0x04 = offX = -320 (the shift) and narrows +0x0C to the play-area edge (the clip). See finding.terrain_shift_is_offx_ctxL and reframe.one_cause_view_state.

The universal client-side game-entity struct; every player, monster, item, and object shares this layout, with a union selecting the type-specific data block.

Per-player data block (name, quest flags, waypoints, assigned/switch skills, trade state) hung off UnitAny.pPlayerData; copied from the serverside layout.

Per-monster data block (txt record, gfx components, name seed, unique/champion/minion bit-flags, enchantments, AI pointer, name) hung off UnitAny.pMonsterData.

Per-object data block (object txt record, interaction type, owner name) hung off UnitAny.pObjectData.

Per-item data block (quality, seeds, owner, flags, prefixes/suffixes, body & inventory location, socket linkage) hung off UnitAny.pItemData.

Movement/position path for an active (moving) unit: current and target coordinates, owning rooms, collision flags, path type, target unit, and facing direction.

Simplified position record (size 0x20) for units that do not move (items/objects): owning room plus offset and grid position.

Skill container hung off UnitAny.pInfo: mem pool plus pointers to the first, left-hand, and right-hand active skills.

A single skill entry in a unit's skill linked list: txt record, next-link, mode, level, and flags.

Skill identifier record referenced by Skill.pSkillInfo; holds the skill id. NOTE: absent from D2Structs_113D.h (which uses SkillsTxt* directly) — this definition comes only from the d2bs D2Structs.h.

Active/in-memory room node holding collision map, units, and nearby-room links for a level.

Static/preset room descriptor (DRLG layout) linking to its Room1, level, tiles, and preset units.

A single DRLG level (map area) with its rooms, size/position, seed, presets, and warp/room-center coordinates. sizeof = 0x230.

Per-act runtime container holding the act's environment, town level, map seed, root room, and DRLG misc pointer.

DRLG-level misc/generation state for an act (aka Drlg): seeds, tile pointers, callbacks, level list, and back-pointer to Act. sizeof(0x48C).

A preplaced (preset) unit within a Room2 — class/type id and tile position, linked as a list.

A tile linking a Room2 to a neighboring room (warp/connection), stored as a linked list.

A single stat entry: sub-index, stat index, and value.

A stat vector/array container: pointer to a Stat array plus counts (size 0x8).

A node in a unit's linked list of stats (size 0x40).

Extended stat list container tracking base/full/mod stats for a unit or item (size 0x64).

A unit's inventory: item linked list plus cursor/owner/count data.

Layout/geometry of an inventory grid panel (slot sizes and screen bounds). Not present in D2Structs_113D.h; taken from d2bs D2Structs.h, which has no offset comments.

A single frame/cell of a DC6/DCC sprite graphic (dimensions, draw offsets, pixel data length).

Rendering context binding a unit/component to its cell file and current graphics cell and facing direction (size 0x48).

Graphics draw-info block holding the draw-offset table pointer and palette-shift index for a sprite.

A dynamic light source in the game world (type, static lightmap validity flag and map pointer). Only a forward declaration exists in 113D, so the d2bs body is used.

A layer of the automap holding linked lists of floor/wall/object/extra cells (sizeof = 0x1C). Verbatim source spelling is AutoMapLayer.

A single automap tile node (cell number, pixel position, weight) linked as a binary tree via pLess/pMore. Verbatim source spelling is AutoMapCell.

A UI control/widget (button, textbox, etc.) with position, size, handler pointers, linked text and edit state. Only a forward declaration exists in 113D, so the d2bs body is used.

A single waypoint activation record (flags bitfield). Only a forward declaration exists in 113D, so the d2bs body is used.

Struct the game passes to the tile-culling function. Layout verified by static_assert: flags at 0x0 (uint32_t), draw_window_rect (RECT) at 0x4, tile_culling_window (RECT) at 0x14 (20). RECT is 16 bytes (left/top/right/bottom int32). | src: struct CullingSpec { uint32_t flags; RECT draw_window_rect; RECT tile_culling_window; }; static_assert(offsetof(CullingSpec, flags)==0); static_assert(offsetof(CullingSpec, draw_wi

Full layout (32 bytes, static_assert): float screenSize[2]={0,0}; float invScreenSize[2]={0,0}; uint32_t flags[4]={0,0,0,0};. NO translate/offset/textureOffset field exists. Therefore the GPU-side constants apply NO per-batch or per-geometry positional translate; any floor-vs-wall positional difference must originate in the CPU vertex data, not the CB. | src: float screenSize[2]; float invScreenSize[2]; uint32_t flags[4]; // static_assert size==32

struct with 3 Size fields: desktopSize, gameSize, gameSizeWide. 26 rows (desktop -> game / gameWide): 1280x720->960x720/1280x720; 1360x768->1024x768/1360x768; 1366x768->1024x768/1366x768; 1280x800->1066x800/1280x800; 1536x864->1152x864/1536x864; 1440x900->1200x900/1440x900; 1600x900->1200x900/1600x900; 1280x1024->640x480/640x512; 1400x1050->700x525/700x525; 1680x1050->700x525/840x525; 1920x1080->720x540/960x540; 2560x1080->720x540/960x540; 2048x1152->768x576/1024x576; 1600x12

Packed 16-byte batch key. uint32 _textureHash @0; uint16 _startVertexLow @4; uint16 _vertexCount @6; uint16 _textureStartAddress @8 (byte addr/256 stored as (addr>>8)+1); uint16 _startVertexHigh_textureIndex @10 (VVVV + 12-bit texIndex); uint8 _textureHeight_textureWidth_alphaBlend @12 (HHHWWWBB); uint8 _isChromaKeyEnabled_gameAddress_paletteIndex @13 (CGGGPPPP); uint8 _textureCategory_primitiveType_combiners @14 (category in bits 5-7); uint8 _textureAtlas @15 (bits 0-2). No | src: uint8_t _textureCategory_primitiveType_combiners; // TTT.PPCC (GetTextureCategory = value>>5)

int16 _x,_y,_s,_t; uint32 _color; uint16 _paletteIndex_atlasIndex (palette<<12 | atlas&4095); uint16 _isChromaKeyEnabled_surfaceId (bit14 chroma | surfaceId&16383). Position is int16 screen-space; ctor asserts x,y in [INT16_MIN,INT16_MAX]. AddOffset(x,y) does _x+=x,_y+=y — mechanism the MoP loop uses. | src: int16_t _x; int16_t _y; int16_t _s; int16_t _t; ... inline void AddOffset(int32_t x,int32_t y){ _x += x; _y += y; }

Unknown=0, MousePointer=1, Player=2, LoadingScreen=3, Floor=4, TitleScreen=5, Wall=6, UserInterface=7, Count=8. Floor and Wall distinct values but geometry-identical. | src: Floor = 4, TitleScreen = 5, Wall = 6, UserInterface = 7

Unknown=0, DrawWall1=1, DrawWall2=2, DrawFloor=3, DrawShadow=4, DrawDynamic=5, DrawSomething1=6, DrawLine=7, Count=8. Index into gameAddresses_* tables. | src: DrawWall1 = 1, DrawWall2 = 2, DrawFloor = 3, DrawShadow = 4, DrawDynamic = 5

Sprite/cell file container. dwVersion 0x00; an anonymous struct at 0x04 { WORD dwFlags; BYTE mylastcol; BYTE mytabno:1 }; eFormat 0x08; termination 0x0C; numdirs 0x10; numcells 0x14; GfxCell* cells[255] at 0x18 (array of pointers to decoded GfxCell frames). | src: DWORD dwVersion; //0x00 | struct{WORD dwFlags;BYTE mylastcol;BYTE mytabno:1;}; //0x04 | DWORD eFormat; //0x08 | DWORD termination; //0x0C | DWORD numdirs; //0x10 | DWORD numcells;

Small automap layer variant: _1[2] 0x00; nLayerNo at 0x08. | src: DWORD _1[2]; //0x00 | DWORD nLayerNo; //0x08

Item position path head: _1[3] 0x00; dwPosX 0x0C; dwPosY 0x10 (DWORD tile coords). 'Use Path for the rest.' | src: DWORD _1[3]; //0x00 | DWORD dwPosX; //0x0C | DWORD dwPosY; //0x10

Object position path head: pRoom1 0x00; _1[2] 0x04; dwPosX 0x0C; dwPosY 0x10. 'Leaving rest undefined, use Path.' | src: Room1* pRoom1; //0x00 | DWORD _1[2]; //0x04 | DWORD dwPosX; //0x0C | DWORD dwPosY; //0x10

Collision map grid. dwPosGameX 0x00; dwPosGameY 0x04; dwSizeGameX 0x08; dwSizeGameY 0x0C; dwPosRoomX 0x10; dwPosRoomY 0x14; dwSizeRoomX 0x18; dwSizeRoomY 0x1C; pMapStart 0x20 (WORD*); pMapEnd 0x22 (WORD*). Game vs Room coordinate spaces both present; pMapStart is the walkability grid used for map rendering/pathing. | src: DWORD dwPosGameX;0x00 | DWORD dwPosGameY;0x04 | DWORD dwSizeGameX;0x08 | DWORD dwSizeGameY;0x0C | DWORD dwPosRoomX;0x10 | DWORD dwPosRoomY;0x14 | DWORD dwSizeRoomX;0x18 | DWORD dwS

Object type record. Render-relevant: nOrientation at 0x14C (draw orientation) and nAutoMap at 0x1BB (automap icon index). Also szName 0x00, wszName 0x40, nSelectable0 0xC4, nSubClass 0x166, nParm0 0x178, nPopulateFn 0x1B2, nOperateFn 0x1B3. | src: BYTE nOrientation; //0x14C | DWORD nAutoMap; //0x1BB

Party roster entry. szName[16] 0x00; dwUnitId 0x10; dwClassId 0x1C; wLevel 0x20; wPartyId 0x22; dwLevelId 0x24; Xpos 0x28; Ypos 0x2C; dwPartyFlags 0x30; szName2[16] 0x66; pNext 0x80. Xpos/Ypos are party-member map coords (minimap/render). | src: DWORD Xpos;0x28 | DWORD Ypos;0x2C | DWORD dwLevelId;0x24

Dynamic (moving) entity position. #[repr(C)]. Fields in order: linear_pos: LinearM2d<FU16>; iso_pos: IsoP2d<i32>; target_pos: [LinearM2d<u16>; 3]; room: Option<NonNull<Room>>; _padding1: [u32;4]; entity: NonNull<Entity>. This is the struct apply_pos_change mutates (ptr in ESI). | src: #[repr(C)] pub struct DyPos { pub linear_pos: LinearM2d<FU16>, pub iso_pos: IsoP2d<i32>, pub target_pos: [LinearM2d<u16>; 3], pub room: Option<NonNull<Room>>, pub _padding1: [u32;

Static (non-moving) entity position. #[repr(C)]. Fields: room: Option<NonNull<Room>>; iso_pos: IsoP2d<i32>; linear_pos: LinearM2d<u32>; _padding1: [u32;3]. | src: #[repr(C)] pub struct StaticPos { pub room: Option<NonNull<Room>>, pub iso_pos: IsoP2d<i32>, pub linear_pos: LinearM2d<u32>, pub _padding1: [u32; 3], }

#[repr(C)] union: s: Option<NonNull<StaticPos>> | d: Option<NonNull<DyPos>>. Which arm is valid depends on Entity.kind. | src: #[repr(C)] pub union EntityPos { pub s: Option<NonNull<StaticPos>>, pub d: Option<NonNull<DyPos>>, }

#[repr(C)]. Render-relevant fields: kind: EntityKind; class_id:u32; mem_pool; id:u32; state:u32; data; act_id:u32; dungeon; rng:Rng; seed:u32; pos: EntityPos; anim_frame_def; seq_frame_count:FU8; seq_frame:FU8; seq_anim_rate:FU8; anim_state:u32; frame:FU8; frame_count:FU8; anim_rate:u16; frame_event:u8; anim_data; gfx_info; _padding0:[u32;1]; stats; inv; light; light_width:u32; _padding1:[u32;30]; next_entity: Option<NonNull<Entity>>; next_in_room: Option<NonNull<Entity>>; _p | src: pub kind: EntityKind, pub class_id: u32, ... pub pos: EntityPos, pub anim_frame_def: *mut (), pub seq_frame_count: FU8, pub seq_frame: FU8, pub seq_anim_rate: FU8, pub anim_state:

#[repr(C)]. connected: Option<NonNull<NonNull<Room>>>; _padding1:[u32;3]; data:u32; _padding2:[u32;4]; connected_count:u32; _padding3:[u32;9]; pos: LinearM2d<u32>; size: M2d<u32>; _padding4:[u32;9]. pos/size are the room world placement used to resolve iso/linear coords. | src: #[repr(C)] pub struct Room { pub connected: Option<NonNull<NonNull<Room>>>, pub _padding1: [u32; 3], pub data: u32, pub _padding2: [u32; 4], pub connected_count: u32, pub _padding3

pub struct BaseAddresses { pub client: usize, pub common: usize, pub fog: usize, pub game: usize, pub gfx: usize, pub win: usize } | src: pub struct BaseAddresses { pub client: usize, pub common: usize, pub fog: usize, pub game: usize, pub gfx: usize, pub win: usize, }

Full per-subtile collision bitmask enum. Notably COLLIDE_BLOCK_PLAYER 0x0001 = 'black space' in Arcane Sanctuary / cliff walls (the void/dead-zone tiles); COLLIDE_ALTERNATE_FLOOR 0x0010 (some floors set it); COLLIDE_BLANK 0x0020 returned for invalid subtile; COLLIDE_WALL 0x0004. Directly relevant to floor/void rendering behavior. | COLLIDE_BLOCK_PLAYER = 0x0001, // 'black space' in arcane sanctuary, cliff walls etc ... COLLIDE_ALTERNATE_FLOOR = 0x0010 ... COLLIDE_BLANK = 0x0020,

Reverse-engineer's abstracted renderer interface mirroring D2's draw model: RF_Init/Shutdown/Present, RF_RegisterTexture, RF_SetTexturePixels(tex,pixels,nPalette), RF_DrawTexture(tex,x,y,w,h,u,v). Notes a TODO for palshifted-cel drawing. Useful mental model of the D2 blit pipeline. | struct D2Renderer{ void (*RF_Present)(); ... void (*RF_DrawTexture)(tex_handle texture, DWORD x, DWORD y, DWORD w, DWORD h, DWORD u, DWORD v); // TODO

DC6 image load layout: frames indexed dir*dwFrames+frame, each DC6Frame has dwWidth/dwHeight and dwNextBlock set to running pixel offset; the file offset/pointer table lives outside the dc6 body. Relevant to cel/graphics decoding. | memcpy(&pImage->pFrames[dwFramePos], gpDecodeBuffer + pFramePointers[dwFramePos], sizeof(DC6Frame)); pImage->pFrames[dwFramePos].dwNextBlock = dwTotal

D2Win UI control struct: dwType +0x00, pCellFile +0x04, dwDisabled +0x08, pos X/Y +0x0C/0x10, size X/Y +0x14/0x18, Initialize fn +0x1C, CallFunc (button) +0x28, CallBackFunc +0x34, pNext +0x3C, dwMaxLength/ButtonFlag +0x44, pFirstText/dwScrollEntries +0x48, pLastText/dwScrollPosition +0x4C, pSelectedText +0x50, wText[0x1A] +0x5C, pChildControl +0x90 | struct Control { DWORD dwType; //0x00 ... Control* pChildControl; //0x90 };

UnitAny: dwType 0x00, dwTxtFileNo 0x04, pMemPool 0x08, dwUnitId 0x0C, dwMode 0x10, union pPlayerData/pItemData/... 0x14, dwAct 0x18, pAct 0x1C, seeds 0x20/24/28, pPath 0x2C, dwGfxFrame 0x44, dwFrameRemain 0x48, wFrameRate 0x4C, pAnimData 0x50, pGfxInfo(D2GfxDataStrc*) 0x54, pGfxInfo2 0x58, pStatsEx 0x5C, pInventory 0x60, pLight 0x64, dwLightRadius 0x68, nPalShiftIdx 0x6C, wX 0x8C, wY 0x8E, dwFlags 0xC4, dwFlagsEx 0xC | D2GfxDataStrc* pGfxInfo; //0x54 ... Light * pLight; //0x64 ... WORD nPalShiftIdx; //0x6C

pUnit+0x6C is a union: bool bInteracting / char nPL2Shift (palette-shift index). Confirmed by disasm MOV BL,[ESI+6C] as pPlayer->nInteract | union { bool bInteracting; char nPL2Shift; }; //+6C

Necrolis authoritative gfx data struct: pCellInit +00, pCellFile +04, nFrame +08, nDirection +0C, nMaxDirections +10, nMaxFrames +14, fFlags +18, fState +1C, nComponent/fItemFlags +1D, nUnitType +20, nUnitIndex +24, nMode +28, nOverlay +2C, union{dwToken +30, dwComponent +34, dwArmorType +38, dwMode +3C, dwHitClass +40} , pName +44. This is UnitAny->pGfxInfo (+0x54) | struct D2GFXDataStrc //sizeof 0x48 { D2GFXCellStrc* pCellInit; //+00 ... const char* pName; //+44 };

AnimToken{ D2TokenType tokenType; union{ cof_handle plrCof[PLRMODE_MAX][WC_MAX]; monCof[MONMODE_MAX]; objCof[OBJMODE_MAX]; } }. COFs load with token; .dcc directions loaded lazily per direction needed | struct AnimToken { D2TokenType tokenType; union { cof_handle plrCof[PLRMODE_MAX][WC_MAX]; ... } };

Struct for the expanded on-screen item-display (ALT-highlight) draw array, gptAltDrawArray. Fields: nLeft/nTop/nRight/nBottom rect (+0x00..+0x0C), Unit* pItem (+0x10), wchar_t wszName[128] (+0x14), nRectColor (+0x114), nRectDrawMode (+0x118), nColor (+0x11C). Whist gives a full 1.13c patch table hooking D2Client at 0x58E59/0x59089/0xCDBB9 (max-count patches to 0x7F), and 0x58E83/0x58F07/0x5909D/0x59448/0x58F94/0x58F2 | struct AltItem { int nLeft; int nTop; int nRight; int nBottom; Unit* pItem; wchar_t wszName[128]; int nRectColor; int nRectDrawMode; int nColor; };

Cell-file (sprite) header, sizeof 0x18 + frame data: dwVersion(+00), fCellFlags(+04), nEncodeType(+08), dwPaletteOffset(+0C), nDirections(+10), nFrames(+14), D2GFXCellStrc* pFrames[](+18). Necrolis clarifies 24-bit DC6's aren't really 24-bit - they carry their own PCX-style palette, and the 'zeros' field is the offset to that internal palette. He states he has mapped out most of D2CMP's ordinals. | struct D2CellFileStrc ... DWORD dwPaletteOffset; //+0C ... 24bit DC6's aren't 24bit, they just have their own palette

COF animation file layout. D2COFLayerInfoStrc sizeof 0x9: nComponent(+0), bShadow(+1), bSelectable(+2), bOverrideTrans(+3), nTransLevel(+4), hitclass szHitClass[4]/dwHitClass(+5). D2COFStrc sizeof 0x1C: nLayers(+00), nFrames(+01), nDirections(+02), nVersion(+03=0x14), dwUnk(+04), then a union of Yoffset/Xoffset box OR nXpos/nWidth/nYpos/nHeight rect (+08..+14), nAnimRate(+18), nArmType(+19). Trailing: pLayerInfo[nLay | struct D2COFStrc //sizeof 0x1C ... BYTE nAnimRate; //+18 BYTE nArmType; //+19

COF file header: layers,frames,directions,version(=20),unknown1(bitfield e.g. loopAnim),bbox xMin/xMax/yMin/yMax(int32),animRate(int16,256),zeros(int16). Governs animation component layers & bounding box. | uint8_t layers; ... int32_t xMin; int32_t xMax; int32_t yMin; int32_t yMax; int16_t animRate;

DCC file header: signature(0x74),version(6),directions(max32),framesPerDir,padding0[3],tag(=1),finalDc6Size. Sprite-encoding header. | uint8_t signature; ///< Magic number for DCC files, must be 0x74

Item cell draw flags: CELLFLAG_UNIQUE=0x01, CELLFLAG_OVERLAY=0x02, CELLFLAG_CLIENT=0x08, CELLFLAG_SET=0x10. Drive item graphic/overlay drawing. | CELLFLAG_UNIQUE = 0x01, CELLFLAG_OVERLAY = 0x02, CELLFLAG_CLIENT = 0x08, CELLFLAG_SET = 0x10

Dialog function-pointer table used by deposit dialogs: pfCreate+00, pfDraw+04, pfMouseScroll+08, pfClickDown+0C, pfClickUp+10, pfMouseMove+14, pfNumpadMove+18, pfKeyScrollUp+1C, pfKeyScrollDown+20, pfKeyScrollRight+24, pfKeyScrollLeft+28. Panel dialog draw+input dispatch. | tDialogDraw pfDraw; // +04 ... pfKeyScrollLeft; // +28

AnimData.d2 record: char szAnimDataName[8]@0x00, DWORD dwFrames@0x08, DWORD dwAnimSpeed@0x0C. Frame count + speed for animations. | char szAnimDataName[8]; //0x00 DWORD dwFrames; //0x08 DWORD dwAnimSpeed; //0x0C

1.13c: pDrlgAct + 0x18 holds a DrlgTileData structure (level tile data). | DrlgTileData DrlgTileData; //0x18

Monster sequence record: WORD wSequence@0x00, BYTE nMode@0x02, nFrame@0x03, nDir@0x04, nEvent@0x05. | WORD wSequence; //0x00 BYTE nMode; //0x02 BYTE nFrame; //0x03 BYTE nDir; //0x04 BYTE nEvent; //0x05

Layout of an inventory grid panel: grid cell counts (X/Y), the pixel bounds of the grid (left/right/top/bottom) and per-cell box width/height. This is the geometry of a side panel's item grid. | int nGridLeft;//0x04 ... int nGridBottom;//0x10 BYTE nGridBoxWidth;//0x14 BYTE nGridBoxHeight;//0x15

Layout of the DT1 floor/wall tile header used by the map renderer, including per-tile collision bitmap (25 bytes), runtime cache index, block offset, light direction, roof height, dimensions, type/style/sequence, and 24-bit transparent color. Direct floor/tile rendering data. | uint8_t fCollisionInfo[25];//+28 ... uint16_t wCacheIndex;//+42 - runtime only ... uint32_t dwBlockOffset;//+48

Sub-tile (tile component) descriptor for DT1 rendering: screen X/Y, grid X/Y, pixel format, encoded length, and offset/pointer to the pixel data block. | struct D2SubTileStrc //sizeof 0x14 { short nXpos;//+00 short nYpos;//+02 ... uint16_t wFormat;//+08 int nLength;//+0A

On-disk DT1 tile-library header layout for both current (v7) and older (v4) formats; v4's skipColor is the RGB skipped in D2CMP CelIteratePixels. Floor/tile file format. | uint32_t version; ... if(version == 7){ char libraryName[260]; uint32_t numTiles; uint32_t firstTile; }

Level/room bookkeeping offsets; nRooms increments on room init while nActiveRooms tracks active count. GetActiveRooms(Act* pAct, int dwLevelNo). Relevant to map streaming around the play area. | int nRooms;//0x004 ... int nActiveRooms;//0x00C ... GetActiveRooms ... -10662

Objects.txt runtime record has a frame-count array around offset 0xD8-0xD9 (pad0xD8 then dwFrameCnt[7]); relevant to object animation frame rendering. | BYTE pad0xD8;//0xD8 DWORD dwFrameCnt[7];//0xD9

The parameter struct passed to the D2Client floor/tile-drawing routine. Directly names the render-pipeline fields we care about: nScreenPanels at +0x20 (which side panels are open), pView (D2ViewStrc*) at +0x24, bDrawEdgeTiles at +0x28, tile bounds nXMin/nXMax/nYMin/nYMax at +0x2C..+0x38, and the crucial nViewXOffset (+0x3C) and nViewYOffset (+0x40, typo'd nnViewYOffset). This is the screen-shift/dead-zone control bl | struct D2FloorTileParamsStrc //sizeof 0x44 - D2Client.0x6FB9A990 { ... int nScreenPanels; //+20 D2ViewStrc* pView; //+24 ... int nViewXOffset; //+3C

Whist's (incomplete) definition of the struct passed to the d2gfx tile-drawing ordinals; only szDT1FileName mapped at +0x058 (the DT1 tile file name), first 0x58 bytes unknown. | struct TileGfxData { DWORD __000[88]; //0x000 char* szDT1FileName; //0x058 };

Layout of the inventory-panel grid array (Inventory+0x14 -> pInvInfo points to array of these). Fields: pFirstItem +0x00, pLastItem +0x04, nWidth +0x08, nHeight +0x09, ppItems (grid cell pointer array) +0x0C. Grid index enum: BODYLOC=0, BELT=1, INVENTORY=2. | struct InventoryGrid { Unit* pFirstItem; //0x00 ... BYTE nWidth; //0x08 BYTE nHeight; //0x09 ... Unit** ppItems; //0x0C };

The per-view render struct that controls the play-area viewport: dwFlags, ViewRadius (RECT), CheckRadius (RECT), nOffsetX/nOffsetY screen offsets, three Gouraud lighting tables, and embedded render data. This is the struct passed to every tile-draw call as pView. | struct D2GameViewStrc { int dwFlags; RECT ViewRadius; RECT CheckRadius; int nOffsetX; int nOffsetY; ...

sizeof 0x24 render batching struct: nStart(+08), nEnd(+0C), then five linked lists of D2UnitDrawStrc -- pShadows(+10), pUpperWallTiles(+14), pUnits(+18), pRoofTiles(+1C), pLowerWallTiles(+20). This is the per-slot draw list that orders shadows/walls/units/roofs in the play area. | struct D2DrawSlotStrc { ... D2UnitDrawStrc* pShadows; //+10 ... pLowerWallTiles; //+20 };

Tile dwFlags bit meanings: 0x4000 DRAW_GROUND (layers 1-4), 0x8000 DRAW_FLOOR (trans tiles above ground e.g. fog), 0x10000 DRAW_ROOF, 0x20000 DRAWN, 0x40000 REVEALED, 0x8 HIDDEN, 0x400 FADED. DRAWCTRL mask = ROOF|FLOOR|GROUND; remaining layers are shadow. Governs which layer a tile draws in. | TILEFLAG_DRAW_GROUND = 0x00004000, //these are tile layers 1,2,3,4 ... TILEFLAG_DRAW_ROOF = 0x00010000

Weather/particle entry: dataArrayVersion, nPosX, nPosY, dwSomeThresholdForSin (destroys particle randomly by Y position), nSizeIdx, a boolean, colorIdx, alpha. align(4). | struct ParticleData { ... DWORD dwSomeThresholdForSin; // Used to destroy the particle randomly based on the Y position ...

Splash/bubble particle: dataArrayVersion, nXpos, nYpos, nWhichRain, nCurFrame, rainGfxIdx. Used for rain ripples/bubbles on water tiles. | struct RainParticleData { ... DWORD nWhichRain; DWORD nCurFrame; DWORD rainGfxIdx; };

Automap cache linked-list node: array of 512 automap cells plus a pPrev link. The automap-overlay data structure sitting over the play area. | struct D2AutoMapCacheStrc //sizeof 0x2804 { D2AutoMapCellStrc pCells[512]; //+0000 D2AutoMapCacheStrc* pPrev; //+2800 };

Act: pEnviroment+0x04, nTownLevel+0x08, dwMapSeed+0x0C, pRoom1+0x10, TileData+0x18, ActMisc*+0x48, pMemoryPool+0x5C. RoomCoords (Room1+0x4C, 0x20 bytes): dwXStart/YStart/XSize/YSize, wTileX+0x10, wTileY+0x14, dwTilesWidth+0x18, dwTilesHeight+0x1C -- tile origin/extent of a room. | struct RoomCoords // sizeof(0x20) 32 bytes of Room1+4C

Day/night lighting env: nTimeIndex, nDaytime, nIntensity+0x0C, nRed/nGreen/nBlue +0x18-0x1A, fCos/fLast/fSin +0x1C-0x24, dwTimeRate+0x28, bEclipse+0x30. Drives the outdoor floor/ambient light color. | struct ActEnvironment // sizeof(0x38)

Tile placement record: nWidth/nXposEx+00, nHeight/nYposEx+04, nXpos+08, nYpos+0C, fFlags+14, D2TileLibraryEntryStrc* pTile+18, nRed/nGreen/nBlue/nIntensity +0x28-0x2B. Per-tile screen position + tint for floor rendering. | struct TileData //sizeof 0x30

Tile library entry; DT1 filename pointer at offset 0x58 (88 dwords in). | char* szDT1FileName; //0x058

Item location is read from itemData->invPage compared against INVPAGE_INVENTORY / INVPAGE_CUBE / INVPAGE_STASH to distinguish inventory vs cube vs stash. Panel-context test. | return itemData->invPage == INVPAGE_STASH;

Full vtable of the swappable renderer backend (GDI/DirectDraw/Glide/D3D). D2 swaps this table on init depending on selected renderer. Includes fpBeginScene, fpEndScene, fpFlipBufferProbably, fpGetBackBuffer, fpGetScreenSize, fpUpdateScaleFactor, fpSetPerspectiveScale, fpAdjustPerspectivePosition, fpPerspectiveScalePosition, fpSetDefaultPerspectiveFactor, fpSetPalette, fpSetGlobalLight, fpDrawRect/RectEx, fpDrawSolidR | I am trying to figure out what are those undefined functions for each of renderer modes ... D2 swap table upon initialization depending on selected re

DrlgLevel+0x1CC (1.13c) / +0x21C (1.10) points to the LevelPreset structure {dwDef, dwFiles, dwPreset, pNext*}. Level/DRLG generation data. | [1.13c] DrlgLevel + 0x1CC [1.10] DrlgLevel + 0x21C ... struct LevelPreset

Automap cell-range record {int nFirst;+00, int nLast;+04} indexed per level-type; gpMapGfxCells[MAX_LEVELTYPES] gives first/last automap gfx cell for each of the 45 level types (full name table listed). Automap/render data | struct D2AutoMapRecordStrc { int nFirst; //+00 int nLast; //+04 };

Cel graphic header: +00 bFlip, +04 nWidth, +08 nHeight, +0C nXOffset, +10 nYOffset, +14 dwNodeLength, +18 pCelNode (also offset to next cel in file), +1C dwLength, +20 pPixels[]. Core sprite/floor-tile blit struct. | struct D2GFXCelStrc //sizeof 0x20 + x { BOOL bFlip; //+00 int nWidth; //+04 ... uint8_t pPixels[]; //+20 };

Full DRLG Level struct layout: dwDrlgType@0x00 (1 maze,2 preset,3 wilderness), pRoom2First@0x10, union maze/preset/wilderness@0x14, dwPosX@0x1C, dwPosY@0x20, dwSizeX@0x24, dwSizeY@0x28, pNextLevel@0x1AC, pMisc@0x1B4, dwLevelType@0x1C0, hSeed@0x1C4, pLevelPresets@0x1CC, dwLevelNo@0x1D0, RoomCenterX/WarpX[9]@0x1E0, RoomCenterY/WarpY[9]@0x204, dwRoomEntries@0x228. Crash in D2Common #10322 DRLGInitLevel tied to sizeX/siz | DWORD dwDrlgType; //0x00 1 - maze, 2 - preset, 3 - wilderness ... DWORD dwSizeX; //0x24 DWORD dwSizeY; //0x28

Automap record {int nFirst;+00, int nLast;+04}; MAX_LEVELTYPES 255; level-type name table gpfMapNamesSize[] (0=None..35 '5 Lava', 36+ Dark Alliance/dummy). Patch points to repoint gpMapGfxCells and name table at D2Common +0x22C7F/22D46 (nFirst), +0x22C4E/22C9F/22D4D (nLast), +0x22AF5/22B32 (names) | struct D2AutoMapRecordStrc { int nFirst; //+00 int nLast; //+04 };

RoomEx flag bits incl HAS_WARP_0..7 (0x10-0x800), SUBSHRINE_ROW1-4, HAS_WAYPOINT 0x10000, AUTOMAP_REVEAL 0x40000, NO_LOS_DRAW 0x80000 (line-of-sight draw suppression), HAS_ROOM 0x100000, HASPORTAL 0x400000, POPULATION_ZERO 0x800000 (towns/nospawn), TILELIB_LOADED 0x1000000, PRESET_UNITS_ADDED/SPAWNED, ANIMATED_FLOOR 0x8000000 (river of flame, hell act5) | ROOMEXFLAG_NO_LOS_DRAW = 0x00080000, ... ROOMEXFLAG_ANIMATED_FLOOR = 0x08000000, //animated floors (river of flame, hell act5)

Per-room tile container holding wall/floor/shadow tile data; sizeof 0x2C. Fields: pMapLinks+00, pAnimTiles+04, nWalls+08, nFloors+0C, nShadows+10, pTiles+14. SwineFlu asks whether it can be surgically removed and rebuilt from the room seed without client/server desync. Core of floor/tile rendering data. | struct DLRGTileGrid //sizeof 0x2C { DRLGTileLink* pMapLinks; //+00 ... int nFloors; //+0C int nShadows; //+10 DRLGRoomTiles pTiles; //+14 };

Static path struct (used by items/objects on ground): pRoom@0x00, nTargetX@0x04, nTargetY@0x08, nXPos@0x0C, nYPos@0x10, unk[2]@0x14, nDirection(BYTE)@0x1C. (Canight variant puts dwHeight@0x50.) Ground-position data feeding unit placement. | struct D2StaticPathStrc { D2RoomStrc* pRoom; //0x00 int nTargetX; //0x04 ... int nXPos; //0x0C int nYPos; //0x10 ... BYTE nDirection; //0x1C };

Per-panel message table entry: param, key, __stdcall callback taking D2WinMsgStrc* | struct D2ClientFnMsg { uint32_t dwPar; DWORD dwKey; D2WinMSGS_CLT pCallback; };

Automap graphics cell first/last per level type; level-type name table (0=None..44) drives automap tile ranges; two dword patches point the engine at an enlarged name table | D2AutoMapRecordStrc gpMapGfxCells[MAX_LEVELTYPES]; ... struct { int nFirst; int nLast; }

Vendor gamble/inventory chain, size 0xC: +0x00 dwPlayerGUID, +0x04 bGamble (whether sold item appears in vendor inventory), +0x08 pPrev. | struct D2VendorChainStrc //sizeof 0xC { DWORD dwPlayerGUID; BOOL bGamble; D2VendorChainStrc* pPrev; }

1.13c D2DrlgStrc fields: +0x098 (=1.10 +0x3E0, DWORD added-active-rooms counter, never decremented), +0x45C (=1.10 +0x3DC, BYTE counter, can overflow), +0x008 (=1.10 +0x3DD, set to 5 or 7 per +0x24 dwFlags, can be decremented). Client-side active-room processing; see D2Common.#10715 (1.13c) / #10003 (1.10). | offsets for these fields in 1.13c are D2DrlgStrc +0x098 +0x45C +0x008 ... 0x3E0 is the amount of added active rooms

Environment lighting cycle tables: {angle, phase, R,G,B, 0} keyframes driving the screen ambient color tint per act | const D2EnvironmentCycleStrc gNormalEnvironmentCycle[6] = { { 320, 3, 125, 144, 243, 0 }, ...

Full tile struct layout for floor/tile rendering: +00 nDirection, +04 nRoofHeight, +06 fMaterial, +08 nHeight, +0C nWidth, +10 nHeightToBottom, +14 nType, +18 nStyle, +1C nSequence, +20 nRarity/nFrame union, +24 dw24To8BitFilterMask, +28 fTileFlags[26] (first byte index, 25 subtile flags), +42 wCacheIndex, +44 dwUnk44, +48 dwBlockOffset, +4C nBlockSize, +50 nBlocks, +54 pBlock, +58 pLibraryName (runtime), +5C pLRUCac | struct D2TileStrc //sizeof 0x60 { int32_t nDirection; //+00 ... int32_t nHeightToBottom; //+10 ... D2TileBlockStrc* pBlock; //+54

Args struct for room culling during render: +00 D2ViewStrc* pView, +04 RECT pCullingRect, +14 DRLGRoom* pClientRoom, +18 BOOL bTilesOnly. Directly about the viewport/culling rectangle that decides what tiles/rooms get drawn -- relevant to play-area vs panel clipping. | struct D2RoomCullArgsStrc { D2ViewStrc* pView; //+00 RECT pCullingRect; //+04 DRLGRoom* pClientRoom; //+14 BOOL bTilesOnly; //+18 };

Client-local simplified struct used to draw the waypoints panel: +00 int levelId, +04 byte activated. Client keeps its own copy separate from server PlayerData waypointData. | the client has it's own local copy, and also uses a separate simplified struct to draw the waypoints panel // D2Client.0xFCD8C struct WaypointClientDa

Char/stat-screen string layout table array at D2Client.6FB78010. Struct: int nXstart, int nY, int nXend, short nString, int nArg. Governs stat-panel text positioning. | //D2Client.6FB78010 CharScreenStringTable gpCharScreenStringTable[] ... struct CharScreenStringTable { int nXstart; int nY; int nXend; short nString;

Full room struct layout -- the world floor/tile geometry a floor renderer walks. nSubtileX 0x00, nSubtileY 0x04, nSubtileWidth 0x08, nSubtileHeight 0x0C, nTileXPos 0x10, nTileYPos 0x14, nTileWidth 0x18, nTileHeight 0x1C; pRoomTiles 0x20; ppRoomList 0x24; nNumRooms 0x28; pUnitFirst 0x2C; pUnitUpdate 0x30; pCollisionGrid 0x34; pRoomEx 0x38; pSeed 0x3C; dwFlags 0x48; ppClients 0x4C; nTileCount 0x58; pAct 0x78; pRoomNext | int nSubtileX;//0x00 ... int nTileXPos;//0x10 ... D2RoomCollisionGridStrc* pCollisionGrid;//0x34

Disassembly of D2Common.0x6F68D570 charm-requirement/inventory-slot bounds check. pItem is [ESP+4]; pItem->pDynamicPath/pStaticPath union at +0x2C; grid posX at pPath+0x0C; posY at pPath+0x10. This is the inventory PANEL grid coordinate model used by CharmZone. | 6F68D57B . 8B40 2C MOV EAX,DWORD PTR DS:[EAX+2C] ; pitem->pPath ... CMP DWORD PTR DS:[EAX+0C],5 ; pPath->posX

Full COLLISION_* bitflag table 0x0001-0x8000 (BlockWalk, BlockLOS, Wall, BlockPlayer, Missile, Player, DeadBody etc.) used in path/tile collision map | #define COLLISION_BLOCKWALK 0x0001 ... #define COLLISION_DEADBODY 0x8000

{ CelFile* pCelFile; RECT tRect; DWORD nOffsetX; DWORD nOffsetY; } - describes an automap cell graphic | struct AutomapCellTypeInfo { CelFile *pCelFile; RECT tRect; DWORD nOffsetX; DWORD nOffsetY; }

Vendor/store tab struct {int x@0;int y@4;short stringId@8;BOOL isSelected@0xA;BOOL isActive@0xE}; array based at D2Client.0xE1178 | struct VendorTab { int x; int y; short stringId; BOOL isSelected; BOOL isActive; }

Weather tick decrements timer, re-rolls via FUN_00472280, and draws overlay via FUN_004f6300 with screen-relative offsets DAT_0071146c/711470 | FUN_004f6300(iVar7,0,iVar5,iVar6,0xff,5); return;

{ wchar_t wszDesc[2][30]; DWORD dwStatNo; DWORD dwTimer; DWORD dwColor; BOOL fEnable; } (asks if same in 1.11b/1.13c) | struct StatMonitor { wchar_t wszDesc[2][30]; DWORD dwStatNo; DWORD dwTimer; DWORD dwColor; BOOL fEnable; }

main world render entry. body: PASS1(0x44302) -> tilesub(0x44307) -> PASS2(0x4436F, gated mode!=3) -> compositor(0x4437B) -> present #10040(0x443B9) -> RET(0x443BE)

floor pass wrapper; esi=ctx, [esp+4]=bTilesOnly, ret 4; calls DrawRooms

wall/roof + unit pass; eax=CullingSpec; gated cmp[ScreenOpenMode],3;je

builds room-iteration RECT from ctx draw-window+scroll (band=[scrollX,scrollX+(R-L)]); per-tile cull skip if tileWorldX>RECT.R; grid helper 0x6FB2A0D0 sizes ctx+0xEAA8 (HEAP UAF trap on save/restore)

floor tile flush; screenX=ctx+0x04-ctx+0x24+tileAbsX; NO inline clip; hands each tile to the cel blit thunks

jmp [IAT 0x6FB7EC3C] -> D2gfx #10001. TILE-DEDICATED; the TILEBAND/GROUND-COLLECT counter hook site

jmp [IAT 0x6FB7EC40] -> D2gfx #10058 (alpha)

mov eax,[0x6FA91268]; call [eax+0x9c]; ret 0x14 -- thin forwarder into the driver cel handler, no clip

solid fill; forwarder to driver vtable +0x84; 295 D2Client callers, none targets [960,1280] (overdraw ruled out)

the ONLY export: mov eax,0x6F8649F0; ret -- hands D2gfx the driver dispatch struct

pfTileDrawLit (dispatch struct +0x9c); the live cel handler D2Client #10001 reaches; calls worker 0x7080

gates on [0x6F865A8C]: null -> LIVE drawer 0x6840; non-null -> DEAD 0x6290

THE live cel->vertex drawer (confirmed fires: [GLIDECULL] edx=ScreenOpenMode). Per-subtile cull vs [esp+0x30]left,[esp+0x38]right narrowed by panel-mode (mode1 right=DispW/2=640 @0x6889, mode2 left=DispW/2-0x20=608 @0x689E). v1.9.1 NOP'd both -> NO visual change => this cull is world-space, NOT the screen clip. Submits via grDrawVertexArrayContiguous

DECOY -- DO NOT HOOK. Software/LFB drawer reached only via the non-taken branch of worker 0x7080; PROVEN dead (v1.9.0 hook never fired). Computes DisplayWidth-DisplayWidth/4=960 but never executes -- the 960 was mis-inferred off this dead code

DECOY -- DO NOT HOOK. Uncalled twin of 0x6290 (0 E8/dword refs); identical width math; register-arg convention. Dead

D2DX Glide-vertex submit = the D2Glide->D2DX crossing. PROBE v1.10.0 (filtered to the tile drawer by return-addr): floor geometry crosses at max screenX 1296, ~138 verts/frame in dead-zone [960,1280). The world geometry REACHES D2DX past 960 yet renders BLACK -> the panel-world clip is IN D2DX (m2 was right).

D2DX grSstWinOpen (export _grSstWinOpen@28). OnSstWinOpen consumes _customGameSize as gameSize (D2DXContext.cpp:176-180) then creates/sizes the RenderContext. THE fix hook site: detour entry, call SetCustomResolution(1280,720) before delegating so the world target opens WIDE. Prologue 55 8B EC 6A FF (push ebp;mov ebp,esp;push -1).

exported _D2DXGetConfigurator@0 (NOT @4 -- the header D2DXConfigurator.h:98 string is a bug; use @0 or ordinal 1). Returns ID2DXConfigurator*; vtable [0]QI [1]AddRef [2]Release [3]SetCustomResolution(w,h) __stdcall. SetCustomResolution sets _customGameSize (a flag consumed at the next grSstWinOpen).

Draws centered unicode text on screen. | src: D2Client.dll DrawCenteredUnicodeText Offset 0xBC4E0

Draws a CEL (sprite) via graphics context — core sprite/cell blit entry point. | src: D2GFX.dll DrawCelContext Ordinal 10041

Draws a rectangle primitive. Named in FOCUS. | src: D2GFX.dll DrawRectangle Ordinal 10014

Draws unicode text. | src: D2Win.dll DrawUnicodeText Ordinal 10150

Measures popup text width/height (layout). | src: D2Win.dll GetPopupUnicodeTextWidthAndHeight Ordinal 10177

Measures drawn text width (layout). | src: D2Win.dll GetUnicodeTextDrawWidth Ordinal 10028

Measures drawn text width for N chars (layout). | src: D2Win.dll GetUnicodeTextNDrawWidth Ordinal 10055

Sets popup text content. | src: D2Win.dll SetPopUpUnicodeText Ordinal 10085

Selects active text font for drawing. | src: D2Win.dll SetUnicodeTextFont Ordinal 10184

Loads a CEL sprite file. | src: D2Win.dll LoadCelFile Ordinal 10111

Unloads a CEL sprite file. | src: D2Win.dll UnloadCelFile Ordinal 10126

Retrieves a CEL frame from a CEL context (sprite frame access). | src: D2CMP.dll GetCelFromCelContext Ordinal 10021

Closes a CEL file (sprite resource cleanup). | src: D2CMP.dll CloseCelFile Ordinal 10065

Resizes the game window on resolution change. Sets screen width [eax] then screen height [ecx]. Left unmodified: game crunches elements, mouse cannot move past 640th x / 480th y, black lines. RENDER/window sizing. | src: ORIG: C7 00 80020000 mov [eax],00000280 (640 screen width); C7 01 E0010000 mov [ecx],000001E0 (480 screen height). PATCH: C7 00 2A040000 mov [eax],0000042A (1066); C7 01 5802000

Sets values determining how D2 renders the game (width render into esi, height render into edx). Unaltered: stretches 640x480 to fill window then crashes. WIDTH RENDER USES 1064 (0x428) NOT 1066 — author: non-multiple-of-4 width overflows onto LEFT side of screen. Height render 600. | src: ORIG: BE 80020000 mov esi,00000280 (640 game's width render); BE E0010000 mov edx,000001E0 (480 height render). PATCH: BE 28040000 mov esi,00000428 (1064 width render); BE 58020000

Sets x-position where D2 should STOP rendering entities (walls, pillars). Unmodified: anything past x=640 not rendered (or incorrectly); no crash. Write target [D2gdi.dll+0xCA9C]. RENDER BOUNDARY. | src: ORIG: C7 05 9CCA876F 80020000 mov [D2gdi.dll+0xCA9C],00000280 (640, x-pos stop rendering). PATCH: C7 05 9CCA876F 2A040000 mov [D2gdi.dll+0xCA9C],0000042A (1066)

THE 0x10E29 BLOCK. Sets D2 field-of-vision, character/map positioning, and UI element positions. mov eax,0x280 then stores eax to [D2client+0xDBC48] (width logic), then mov [D2client+0xDBC4C],0x1E0 (height logic). Unmodified: renders as 640x480 and places game at upper-left of window. The width store (A3 48BCB86F) is left UNMODIFIED; only the eax immediate (640->1066) and the height DWORD (480->600) change. | src: ORIG: B8 80020000 mov eax,00000280 (640); A3 48BCB86F mov [D2client.dll+0xDBC48],eax (width logic); C7 05 4CBCB86F E0010000 mov [D2client.dll+0xDBC4C],000001E0 (480 height logic).

THE 0xC3A11 UI-PANEL OFFSET SITE. Original 640x480-mode panel placement: writes ebx (=0) into panel x-offset [+0x11B9A0] and y-offset [+0x11B9A4]. Governs alignment of quest buttons, waypoint buttons, mercenary stats. reg->mem is fewer bytes than DWORD-const->mem, so 8 extra bytes needed to inject HD constants. | src: 89 1D A0B9BC6F mov [D2client.dll+0x11B9A0],ebx (x-offset of panels, ebx=0); 89 1D A4B9BC6F mov [D2client.dll+0x11B9A4],ebx (y-offset of panels, ebx=0)

THE 75 16 PER-RESOLUTION BRANCH. Original: jne to 0xC3A11 (640x480 code) if not 800x600 mode. 800x600 block sets x-offset=0x50(80) and y-offset=0xFFFFFFC4(-60), then EB 0C jmp to 0xC3A1D past the 640x480 code. 640x480 block (at 0xC3A11) writes ebx(0) to both offsets. jne displacement = 0x16. | src: 75 16 jne D2client.dll+0xC3A11 (jump to 640x480 code if not 800x600); C7 05 A0B9BC6F 50000000 mov [+0x11B9A0],00000050 (80 x-offset); C7 05 A4B9BC6F C4FFFFFF mov [+0x11B9A4],FFFFF

PATCHED per-resolution branch: author reorders so the shared y-offset store (-60) runs FIRST for both 800x600 and 1066x600 (both height 600), freeing 6 bytes and cutting needed bytes 8->4. jne displacement CHANGED from 0x16 to 0x0C. Now: write y-offset -60; jne 0xC3A11 (=1066x600 code) if not 800x600; 800x600 sets x=0x50(80); jmp past; the 0xC3A11 '1066x600 code' sets x-offset=0xD5(213); two trailing 90 NOPs (leftover bytes). CONCLUSION ON PANEL SHIFT: panel x-offset 213 for | src: C7 05 A4B9BC6F C4FFFFFF mov [+0x11B9A4],FFFFFFC4 (-60 y-offset); 75 0C jne D2client.dll+0xC3A11 (jump to 1066x600 code if not 800x600); C7 05 A0B9BC6F 50000000 mov [+0x11B9A0],0000

Glide mode entity render dimensions. Writes rendering width [D2glide.dll+0x15A68] and height [D2glide.dll+0x15B04]. Unchanged: entities rendered at incorrect location. RENDER. | src: ORIG: C7 05 685A866F 80020000 mov [D2glide.dll+0x15A68],00000280 (width 640); C7 05 045B866F E0010000 mov [D2glide.dll+0x15B04],000001E0 (height 480). PATCH: ...2A040000 (1066); ..

Sets D2 (Glide) window size. Loads ptr [glide3x.dll+0x1C9A0] (width addr) into edx then writes 640; loads ptr [glide3x.dll+0x1C82C] (height addr) into ecx then writes 480. NOTE: Cheat-Engine relative addresses differ from hex-editor addresses (offset by 0xA00). In the printed PATCH the loader/immediate opcodes C7 02 80020000 / C7 01 E0010000 are shown unchanged but the target values in comments become 1066/600 — the immediates to actually write are 0000042A and 00000258. | src: 8B 15 A0C94100 mov edx,[glide3x.dll+0x1C9A0] (Glide window width addr); C7 02 80020000 mov [edx],00000280 (640->1066 0000042A); 8B 0D 2CC84100 mov ecx,[glide3x.dll+0x1C82C] (height

Fills the LEFT half of the screen. First draws a solid black rectangle over the left half to block transparent-DC6 cheats, then tiles the config screen-background DC6 across it. This is the perimeter/letterbox fill on the left of the 640-wide play area. | src: ::d2::d2gfx::DrawRectangle(0, 0, resolution.width / 2, resolution.height, 0, ::d2::DrawEffect::kNone);

Fills the RIGHT half of the screen. Draws a black rectangle from x=width/2 to x=width over full height, then tiles the background DC6 rightward. Left+Right together produce the full perimeter fill around the centered 640x480 UI region. | src: ::d2::d2gfx::DrawRectangle(resolution.width / 2, 0, resolution.width, resolution.height, 0, ::d2::DrawEffect::kNone);

Public interception entry (extern "C" __cdecl). Reads d2client::GetScreenOpenMode() and dispatches: kRight -> DrawRight{Background,BorderFrame,BackgroundRibbon}; kLeft -> DrawLeft*; kBoth -> both; kNone -> nothing. Then calls original d2::d2client::DrawScreens(). Declared in replacement.hpp. | src: extern "C" void __cdecl Sgd2fr_D2Client_DrawScreenBackground();

1.13c call-branch patch that redirects into Sgd2fr_D2Client_DrawScreenBackground via the asm shim InterceptionFunc01. Found by tracing the 'ACT%d' string usage to the function return. Other versions: 1.09D 0x8696B, 1.10 0x81F08, 1.12A 0x90216, 1.13D 0x1D4A6, LoD1.14C 0x5264D, LoD1.14D 0x56FAF (all size 5).

NOP patch removing the game's original left-screen 800BorderFrame draw. Located via the 'Panel\800BorderFrame' string (two usages; this is the left one). 1.09D 0x58F1B(sz0x96), 1.10 0x5F4EB(0x9B), 1.12A 0x8218D(0x9A), 1.13D 0x6D2DD(0x9A), LoD1.14C 0x94B0C(0xAA), LoD1.14D 0x9865E(0x9E).

NOP patch removing the game's original right-screen 800BorderFrame draw. 1.09D 0x58FF0(0xAC), 1.10 0x5F5C0(0xAC), 1.12A 0x82094(0xB9), 1.13D 0x6D1E1(0xBD), LoD1.14C 0x94BF1(0xB3), LoD1.14D 0x98733(0xA7).

THE origin of the -320 render shift. Recomputes D2's screen-shift so the 640x480 play area is centered. screen_shift_x = (general_display_width/2) - (640/2); screen_shift_y = -((general_display_height/2) - (480/2)). Note the 640/2 = 320 term and the NEGATION on the Y term. For a 1280x720 display: shift_x = 640-320 = 320, shift_y = -(360-240) = -120. The '-320'-family value is the (640/2) offset that recenters the viewport origin. Uses d2client::GetGeneralDisplayWidth/Height a | src: int screen_shift_x = (general_display_width / 2) - (640 / 2); int screen_shift_y = -((general_display_height / 2) - (480 / 2)); ::d2::d2client::SetScreenShiftX(screen_shift_x);

Call-branch patch feeding Sgd2fr_D2Client_SetScreenShift. Found via write-breakpoint on ScreenShiftX/Y variable. 1.09D 0x865BF, 1.10 0x81B8F, 1.12A 0x90166, 1.13D 0x1D3F6, LoD1.14C 0x5259B, LoD1.14D 0x56EFD (all size 0x27 = 0x...1D-0x...F6).

Sets the map/tile draw and culling windows. draw_window_rect = SetRect(left,top,right,bottom) from args. tile_culling_window base = SetRect(-80, -80, width+80, height+40) using GetGeneralDisplayWidth/Height. If perspective mode enabled, expands top/left/right/bottom by ratios (866px up = -204.375 unit space; ratio = 1732/(1732-height/2) - 1, capped at 1.0; bottom uses ratio = 1 - 1500/(1500+height/2)). Finally sets culling_spec->flags |= 0x1. The -80/-80/+80/+40 margins are t | src: SetRect(tile_culling_rect, -80, -80, width + 80, height + 40); ... culling_spec->flags |= 0x1;

Jump-branch patch to the tile-culling replacement (via patch_1_11_shim). Found via 'Perspective' Video-Options string -> first D2Client-space call. 1.11 0x5B560, 1.11B 0x927A0, 1.12A 0xBA990, 1.13ABeta 0x3F490, 1.13D 0xB5330, LoD1.14A 0xB5330 (all size 5). Separate patch_1_07.cpp covers 1.07-1.10 & 1.14A-D with different offsets (e.g. 1.09D 0x16000, LoD1.14C 0x71D30, LoD1.14D 0x76000).

Sets the D2GDI cel horizontal draw window to the full width: SetCelDisplayLeft(0), SetCelDisplayRight(resolution.width). Resolution from GetIngameResolutionFromId(resolution_mode). This is the render-window widening that removes the stock 640-wide clip so the perimeter can be drawn. | src: d2::d2gdi::SetCelDisplayLeft(0); d2::d2gdi::SetCelDisplayRight(resolution.width);

Jump-branch patch in D2GDI (not D2Client) for the cel display left/right. 1.11 0x6529, 1.11B 0x7239, 1.12A 0x6599, 1.13ABeta 0x65F9, 1.13C 0x7049, 1.13D 0x7E99 (size 0x2E each). Library = kD2GDI.

Feeds the resolution into the GeneralDisplayWidth/Height globals that everything above reads: SetGeneralDisplayWidth(resolution.width), SetGeneralDisplayHeight(resolution.height). Also cycles SetInventoryArrangeMode(inventory_arrange_mode++) as a workaround to stop inventory arrangement from transferring (overflow intentional). | src: d2::d2client::SetGeneralDisplayWidth(resolution.width); d2::d2client::SetGeneralDisplayHeight(resolution.height);

Re-anchors a PositionalRectangle from the source (inventory-arrange) resolution center to the current resolution center, preserving width/height. dist = out.Left - source.width/2; out.Left = current.width/2 + dist; out.Right = out.Left + rectangle_width. Same for top/bottom about height/2. Uses GetIngameResolutionFromId(GetResolutionMode()) and GetSourceInventoryArrangeResolution(). | src: out_position_wrapper.SetLeft((current_resolution.width / 2) + dist_from_rect_left_to_display_center);

Like RealignPositionFromCenter for X, but anchors Y to the display BOTTOM: dist_from_rect_top_to_display_bottom = source.height - out.Top; out.Top = current.height - dist; out.Bottom = out.Top + rectangle_height. Used for bottom-docked UI (belt/skill bar).

NOPs the D2GFX.DrawRectangle call that draws the black rectangle on the Scroll-of-Inifuss (Cain quest) screen, which otherwise mis-renders at high res. Located via the '%s\UI\MENU\scroin' string then scrolling up to the DrawRectangle call. Single NOP patch per version. 1.13C at D2Client +0x7C38D (size 0x2D = 0x7C3BA-0x7C38D); 1.09D 0x8330C, 1.12A 0x70FBD, 1.13D 0x7516D, LoD1.14C 0x9C20D, LoD1.14D 0x9FA20 (all size 0x2D). Applies to essentially all versions 1.07-1.14D.

Sets viewport + scissor from a Rect, then updates the Constants CB. Verbatim: CD3D11_VIEWPORT viewport{ (float)rect.offset.x, (float)rect.offset.y, (float)rect.size.width, (float)rect.size.height }; _deviceContext->RSSetViewports(1,&viewport); CD3D11_RECT scissorRect{ rect.offset.x, rect.offset.y, rect.size.width, rect.size.height }; _deviceContext->RSSetScissorRects(1,&scissorRect); then writes _constants.screenSize[0/1]=size.width/height, invScreenSize=1/size, flags[0]=NoAn | src: CD3D11_VIEWPORT viewport{ (float)rect.offset.x, (float)rect.offset.y, (float)rect.size.width, (float)rect.size.height };

Called 3 places. SetSizes: UpdateViewport({0,0,_gameSize.width,_gameSize.height}) (offscreen game-size target, offset 0). Present: called with game-size dims AND with _renderRect (the centered/scaled final blit to screen). WriteToScreen: UpdateViewport({0,0,_gameSize.width,_gameSize.height}). Only the Present-with-_renderRect path carries a non-zero centering offset.

Stores _gameSize/_windowSize. displaySize = (FullscreenDefault ? _desktopSize : _windowSize). _renderRect = Metrics::GetRenderRect(_gameSize, displaySize, !NoWide flag). Computes desktopCenterX=_desktopSize.width/2, desktopCenterY=(FullscreenDefault?_desktopSize.height/2:_desktopClientMaxHeight/2), reads GetWindowPosition() preferred position (used iff x>=0 && y>=0). Branches Windowed vs FullscreenDefault for placement. Then ClipCursor(); and if(_resources){ ResizeBackbuffer( | src: _renderRect = Metrics::GetRenderRect(_gameSize, displaySize, !_d2dxContext->GetOptions().GetFlag(OptionsFlag::NoWide));

SetBlendState(batch.GetAlphaBlend()); picks atlas via GetTextureCache(batch); SetShaderState with Game vertex+pixel shaders, atlas SRV (batch.GetTextureAtlas()) and Palette Texture1D SRV; then _deviceContext->Draw(batch.GetVertexCount(), startVertexLocation + batch.GetStartVertex()). No positional transform here — geometry comes straight from the vertex buffer; the only offset is the vertex START index. | src: _deviceContext->Draw(batch.GetVertexCount(), startVertexLocation + batch.GetStartVertex());

First tries MetricsTable exact-match on desktop size (narrow vs wide variant). Fallback: loop scaleFactor=1..8 { size.width=desktop.width/scaleFactor; size.height=desktop.height/scaleFactor; if (desktop.height/(scaleFactor+1) <= 600) break; }. Height cap: if size.height>720 { aspect=desktop.width/desktop.height; size.width=(int32_t)(aspect*720); size.height=720; }. Constants: 600 (break threshold), 720 (max game height), scale range 1..8.

Integer scale: scaleFactor=1; while(gameSize.width*(scaleFactor+1)<=desktop.width && gameSize.height*(scaleFactor+1)<=desktop.height) ++scaleFactor;. Centering (integer): rect.size={gameSize.width*scaleFactor, gameSize.height*scaleFactor}; rect.offset.x=(desktop.width-gameSize.width*scaleFactor)/2; rect.offset.y=(desktop.height-gameSize.height*scaleFactor)/2. Non-integer trigger: if(rect.offset.x<0 || rect.offset.y<0 || (rect.offset.x>=16 && rect.offset.y>=16)) apply fraction

Assigns/reuses a surfaceId per batch (tag stored on vertices via SetSurfaceId; used by AA/edge pixel shader, NOT a positional transform). Order: (1) if majorGameState!=InGame -> D2DX_SURFACE_ID_USER_INTERFACE. (2) if chroma-key disabled (text bg) -> UI. (3) gameplay-with-chroma UI reclassifications: draw-line single-pixel '(maxy - miny) == 1' -> UI; bottom band 'miny >= (gameSize.height - 48)' -> UI (48px); panels: '(_gameHelper->ScreenOpenMode() & 1)' left-panel open && 'min

KEY per-batch positional translate. Gated by IsFeatureEnabled(Feature::UnitMotionPrediction) && _majorGameState==MajorGameState::InGame. offset = _unitMotionPredictor.GetOffset(_gameHelper->GetPlayerUnit()). Applied to EVERY batch EXCEPT surfaceId==D2DX_SURFACE_ID_USER_INTERFACE and TextureCategory::Player, via _vertices.items[vertexIndex++].AddOffset(-offset.x, -offset.y) (NEGATED). Floor AND wall batches are non-UI/non-player, so BOTH receive -offset; player+UI stay put. No | src: _vertices.items[vertexIndex++].AddOffset(-offset.x, -offset.y);

Weather/rain particle motion prediction: computes a directional offset and applies startPos += offset; endPos += offset; to line endpoints before vertex creation (~640-644). Separate from the world-geometry offset; affects only line primitives (weather).

pos.x=(int32_t)(pos.x*scale+mouseOffsetX); pos.y=(int32_t)(pos.y*scale); maps OS cursor into scaled/centered render area (mouseOffsetX centers horizontally in fullscreen). Confirms centering offset is horizontal-only for cursor; not applied to world geometry.

Primary draw capture. Grabs _ReturnAddress() and forwards to the context factory singleton. This return address is later used to classify the draw as floor/wall/etc. | src: const auto returnAddress = (uintptr_t)_ReturnAddress(); D2DXContextFactory::GetInstance()->OnDrawVertexArray(mode, Count, (uint8_t**)pointers, returnAddress);

Second capture path (used for 4-vertex TRIANGLE_FAN quads). Same _ReturnAddress() -> OnDrawVertexArrayContiguous(mode,Count,vertex,stride,returnAddress). | src: D2DXContextFactory::GetInstance()->OnDrawVertexArrayContiguous(mode, Count, (uint8_t*)vertex, stride, returnAddress);

Glide grViewport does nothing except assert x==0 && y==0. The game never sets a shifted Glide viewport; all viewport control is D2DX-internal. | src: grViewport(FxI32 x, FxI32 y, FxI32 width, FxI32 height){ assert(x == 0 && y == 0); }

grClipWindow => assert(false, Unsupported). grCoordinateSpace is an empty stub. No Glide-level scissor/clip or coordinate-space transform enters the pipeline. | src: grClipWindow(...){ assert(false && "grClipWindow: Unsupported"); } grCoordinateSpace(GrCoordinateSpaceMode_t mode){ }

Resolves 640x480/800x600/1024x768 then calls OnSstWinOpen(hWnd,width,height). Asserts color_format==GR_COLORFORMAT_RGBA. | src: D2DXContextFactory::GetInstance()->OnSstWinOpen(hWnd, width, height); return 1;

Where a Batch's category is finalized. gameAddress = IdentifyGameAddress(returnAddress); category = RefineTextureCategoryFromGameAddress(existing, gameAddress). Sets StartVertex=_vertexCount, VertexCount. NO position offset applied for any category. | src: batch.SetTextureCategory(_gameHelper->RefineTextureCategoryFromGameAddress(batch.GetTextureCategory(), gameAddress));

THE ONLY post-capture positional shift of world geometry. If UnitMotionPrediction enabled and InGame: offset=_unitMotionPredictor.GetOffset(playerUnit); then for every batch with surfaceId != D2DX_SURFACE_ID_USER_INTERFACE AND category != Player, each vertex gets AddOffset(-offset.x,-offset.y). Floor AND wall both qualify -> identical uniform shift. | src: if (surfaceId != D2DX_SURFACE_ID_USER_INTERFACE && batch.GetTextureCategory() != TextureCategory::Player){ ... _vertices.items[vertexIndex++].AddOffset(-offset.x, -offset.y); }

After BulkWriteVertices, merges consecutive batches when same texture-cache/atlas/alphaBlend and combined vertexCount<=65535, else flushes via _renderContext->Draw(mergedBatch,startVertexLocation). Category is NOT part of the merge key and NOT used to offset. | src: _renderContext->GetTextureCache(batch) != _renderContext->GetTextureCache(mergedBatch) || batch.GetTextureAtlas() != mergedBatch.GetTextureAtlas() || batch.GetAlphaBlend() != merge

Sets ONE viewport and ONE scissor rect, both == the passed Rect (offset+size). Also writes Constants.screenSize/invScreenSize used by the vertex shader to map int16 screen coords to NDC. No per-batch or per-category viewport/scissor; set per render-pass only. | src: CD3D11_VIEWPORT viewport{ (float)rect.offset.x, (float)rect.offset.y, (float)rect.size.width, (float)rect.size.height }; ... CD3D11_RECT scissorRect{ rect.offset.x, rect.offset.y,

Game batches render into the Game framebuffer under UpdateViewport({0,0,_gameSize.width,_gameSize.height}) (set at end of prior Present, line 491). Gamma/AA passes also use {0,0,gameSize}. Final display blit to backbuffer uses UpdateViewport(_renderRect) (centered, letterboxed dest). gameSize=internal render res; renderRect=on-screen placement. | src: UpdateViewport({ 0,0,_gameSize.width, _gameSize.height }); ... UpdateViewport(_renderRect);

Per merged batch: SetBlendState, pick atlas SRV, SetShaderState(Game VS/PS), then Draw(vertexCount, startVertexLocation + batch.GetStartVertex()). No matrix/offset/scissor per batch or category. | src: _deviceContext->Draw(batch.GetVertexCount(), startVertexLocation + batch.GetStartVertex());

Converts predicted vs last world pos (16.16 fixed) into a SCREEN-space isometric pixel offset. scaleFactors={32/sqrt2,16/sqrt2}; screenOffset=scaleFactors*{dx-dy,dx+dy}+0.5. Magnitude of the uniform world shift; a few px, never hundreds. | src: const OffsetF scaleFactors{ 32.0f / sqrtf(2.0f), 16.0f / sqrtf(2.0f) }; const OffsetF screenOffset = scaleFactors * OffsetF{ offset.x - offset.y, offset.x + offset.y } + 0.5f;

Maps captured return address's GameAddress to a category ONLY when previous category is Unknown: DrawFloor->Floor, DrawWall1/DrawWall2->Wall, else unchanged. Category never triggers coordinate change. | src: case GameAddress::DrawFloor: return TextureCategory::Floor; case GameAddress::DrawWall1: case GameAddress::DrawWall2: return TextureCategory::Wall;

Computes gameSize from width/height (or _customGameSize override); if NoResMod off, windowSize forced 800x600; if gameSize != 640x480 then windowSize=gameSize. Creates/resizes RenderContext with (gameSize, windowSize*windowScale). Establishes internal render res (gameSize) that becomes the {0,0,gameSize} viewport. | src: Size gameSize{ width, height }; if (_customGameSize.width > 0){ gameSize = _customGameSize; } if (gameSize.width != 640 || gameSize.height != 480){ windowSize = gameSize; }

Computes on-screen _renderRect: integer-scales gameSize into desktop/window, centers it (offset=(dst-game*scale)/2); if margins exceed 16px falls back to non-integer scale filling width or height. This centered offset shifts only the final display blit, NOT world batches. | src: Rect rect{ (desktopSize.width - gameSize.width * scaleFactor) / 2, (desktopSize.height - gameSize.height * scaleFactor) / 2, gameSize.width * scaleFactor, gameSize.height * scaleFa

Draws a line between two screen points with color. | src: FUNCPTR(D2GFX, DrawLine, void __stdcall, (int X1, int Y1, int X2, int Y2, DWORD dwColor, DWORD dwUnk), -10010)

Fills/draws a screen rectangle with color and transparency mode. | src: FUNCPTR(D2GFX, DrawRectangle, void __stdcall, (int X1, int Y1, int X2, int Y2, DWORD dwColor, DWORD dwTrans), -10014)

Renders a single automap cell/tile at screen xpos/ypos with two brightness values and a color table. Core automap-draw primitive. | src: FUNCPTR(D2GFX, DrawAutomapCell2, void __stdcall, (CellContext* context, DWORD xpos, DWORD ypos, DWORD bright2, DWORD bright, BYTE *coltab), -10041)

Returns encoded screen resolution (packed WxH). Render viewport sizing. | src: FUNCPTR(D2GFX, GetScreenSize, DWORD __stdcall, (void), -10031)

Returns the game render window HWND. | src: FUNCPTR(D2GFX, GetHwnd, HWND __stdcall, (void), -10048)

Draws sprite batch (fastcall). Under 'D2Win Functions' header. | src: FUNCPTR(D2WIN, DrawSprites, void __fastcall, (void), 0x18750)

Captures the current frame to a screenshot. | src: FUNCPTR(D2WIN, TakeScreenshot, void __fastcall, (), 0x17EB0)

Draws a wide-char string at screen xPos/yPos with color. Primary on-screen text primitive. | src: FUNCPTR(D2WIN, DrawText, void __fastcall, (wchar_t *wStr, int xPos, int yPos, DWORD dwColor, DWORD dwUnk), -10150)

Measures pixel width (and font file no) of a string for layout/centering. | src: FUNCPTR(D2WIN, GetTextSize, DWORD __fastcall, (wchar_t *wStr, DWORD* dwWidth, DWORD* dwFileNo), -10177)

Selects the active font/text size for subsequent DrawText calls. | src: FUNCPTR(D2WIN, SetTextSize, DWORD __fastcall, (DWORD dwSize), -10184)

Word-wraps text to a pixel width, returning line array + count (text-layout helper). | src: FUNCPTR(D2WIN, SplitText, SplitText* __fastcall, (wchar_t* text, int* lineCount, int width), -10059)

Frees a SplitText layout result. | src: FUNCPTR(D2WIN, FreeSplitText, void __fastcall, (SplitText* text), -10008)

Sets the text of a UI Control (edit box/button). UI, borderline render. | src: FUNCPTR(D2WIN, SetControlText, void* __fastcall, (Control* box, wchar_t* txt), -10042)

Returns a unit's world X coordinate. Feeds world->screen projection. | src: FUNCPTR(D2CLIENT, GetUnitX, int __fastcall, (UnitAny* pUnit), 0x1630)

Returns a unit's world Y coordinate. | src: FUNCPTR(D2CLIENT, GetUnitY, int __fastcall, (UnitAny* pUnit), 0x1660)

Clears the screen/framebuffer. | src: FUNCPTR(D2CLIENT, ClearScreen, void __fastcall, (void), 0x48350)

Returns automap size metric used for automap draw scaling. | src: FUNCPTR(D2CLIENT, GetAutomapSize, DWORD __stdcall, (void), 0x5F080)

Allocates a new AutomapCell node. | src: FUNCPTR(D2CLIENT, NewAutomapCell, AutomapCell * __fastcall, (void), 0x5F6B0)

Links an AutomapCell into an automap layer node list. | src: FUNCPTR(D2CLIENT, AddAutomapCell, void __fastcall, (AutomapCell *aCell, AutomapCell **node), 0x61320)

Reveals a Room1's automap cells onto an AutomapLayer (with clip flag). Core map-reveal. | src: FUNCPTR(D2CLIENT, RevealAutomapRoom, void __stdcall, (Room1 *pRoom1, DWORD dwClipFlag, AutomapLayer *aLayer), 0x62580)

Initializes/returns the AutomapLayer for a given layer number. | src: FUNCPTR(D2CLIENT, InitAutomapLayer_I, AutomapLayer* __fastcall, (DWORD nLayerNo), 0x62710)

Handles a click at screen x,y (translates screen->world action). Coordinate-relevant. | src: FUNCPTR(D2CLIENT, ClickMap, void __stdcall, (DWORD MouseFlag, DWORD x, DWORD y, DWORD Type), 0x1BF20)

Returns the mouse X offset used in screen<->world coordinate math. | src: FUNCPTR(D2CLIENT, GetMouseXOffset, DWORD __fastcall, (void), 0x3F6C0)

Returns the mouse Y offset used in screen<->world coordinate math. | src: FUNCPTR(D2CLIENT, GetMouseYOffset, DWORD __fastcall, (void), 0x3F6D0)

Prints a message to the on-screen game message area. | src: FUNCPTR(D2CLIENT, PrintGameString, void __stdcall, (wchar_t *wMessage, int nColor), 0x7D850)

Prints a party message to screen. | src: FUNCPTR(D2CLIENT, PrintPartyString, void __stdcall, (wchar_t *wMessage, int nColor), 0x7D610)

Draws a rectangular frame on screen. | src: FUNCPTR(D2CLIENT, DrawRectFrame, void __fastcall, (DWORD Rect), 0xBE4C0)

ASM patch anchor near the cursor/hover click-target table (adjacent to CursorHoverX/Y). | src: ASMPTR(D2CLIENT, BodyClickTable, 0xE0EC4)

ASM patch anchor for click-to-move handling (adjacent to AutomapOn 0xFADA8). | src: ASMPTR(D2CLIENT, ClickMap_I, 0xFADA4)

ASM patch anchor for click-map coordinate handling. | src: ASMPTR(D2CLIENT, ClickMap_II, 0x11C4D8)

ASM patch anchor for click-map (near GetMouseX/YOffset 0x3F6C0/0x3F6D0). | src: ASMPTR(D2CLIENT, ClickMap_III, 0x3F5F0)

ASM patch anchor inside ClickMap (0x1BF20 + 0x79). | src: ASMPTR(D2CLIENT, ClickMap_IV, 0x1BF99)

Draws a line. Args (int X1,int Y1,int X2,int Y2,DWORD dwColor,DWORD dwUnk), __stdcall. Dual = export ordinals. | src: FUNCPTR(D2GFX, DrawLine, void __stdcall, (int X1, int Y1, int X2, int Y2, DWORD dwColor, DWORD dwUnk), -10010, -10013)

Draws a filled/trans rectangle. Args (int X1,int Y1,int X2,int Y2,DWORD dwColor,DWORD dwTrans), __stdcall. | src: FUNCPTR(D2GFX, DrawRectangle, void __stdcall, (int X1, int Y1, int X2, int Y2, DWORD dwColor, DWORD dwTrans), -10014, -10028)

Core automap-cell blitter. ASMPTR. Args (CellContext *context,DWORD xpos,DWORD ypos,RECT *cliprect,DWORD bright), __stdcall. | src: ASMPTR(D2GFX, DrawAutomapCell, void __stdcall, (CellContext *context, DWORD xpos, DWORD ypos, RECT *cliprect, DWORD bright), -10079, -10060)

Second automap-cell draw variant. Args (CellContext* context,DWORD xpos,DWORD ypos,DWORD bright2,DWORD bright,BYTE *coltab), __stdcall. | src: FUNCPTR(D2GFX, DrawAutomapCell2, void __stdcall, (CellContext* context, DWORD xpos, DWORD ypos, DWORD bright2, DWORD bright, BYTE *coltab), -10041, -10042)

Draws a cell context (sprite) with transparency/color. Args (CellContext *context,int Xpos,int Ypos,int dwl,int nTransLvl,BYTE Color), __stdcall. | src: FUNCPTR(D2GFX, DrawCellContextEx, void __stdcall, (CellContext *context, int Xpos, int Ypos, int dwl, int nTransLvl, BYTE Color), -10019, -10067)

Returns the current screen size. __stdcall (void). Render/viewport query. | src: FUNCPTR(D2GFX, GetScreenSize, DWORD __stdcall, (void), -10031, -10012)

Batched sprite draw. __fastcall (void). NOTE: dual values are DIRECT OFFSETS (positive hex), not ordinals — key rebasing distinction. | src: FUNCPTR(D2WIN, DrawSprites, void __fastcall, (void), 0x18750, 0xEAA0)

Draws a CellFile sprite. Args (CellFile * pCellFile,int xPos,int yPos,int div,int trans,int Color), __fastcall. | src: FUNCPTR(D2WIN, DrawCellFile, void __fastcall, (CellFile * pCellFile, int xPos, int yPos, int div, int trans, int Color), -10138, -10172)

Draws a unicode text string. Args (const wchar_t *wStr,int xPos,int yPos,DWORD dwColor,DWORD dwUnk), __fastcall. | src: FUNCPTR(D2WIN, DrawText, void __fastcall, (const wchar_t *wStr, int xPos, int yPos, DWORD dwColor, DWORD dwUnk), -10150, -10076)

Text-buffer draw routine. ASMPTR with DIRECT OFFSETS (positive hex), not ordinals. | src: ASMPTR(D2WIN, DrawTextBuffer, 0x12940, 0x134D0)

Measures text width/height. Args (wchar_t *wStr,DWORD* dwWidth,DWORD* dwFileNo), __fastcall. | src: FUNCPTR(D2WIN, GetTextSize, DWORD __fastcall, (wchar_t *wStr, DWORD* dwWidth, DWORD* dwFileNo), -10177, -10179)

Sets the active font/text size. Args (DWORD dwSize), __fastcall. | src: FUNCPTR(D2WIN, SetTextSize, DWORD __fastcall, (DWORD dwSize), -10184, -10047)

Text width + file-number query. Same ordinals as GetTextSize (-10177/-10179) — aliased export. Args (wchar_t *wStr,DWORD* dwWidth,DWORD* dwFileNo), __fastcall. | src: FUNCPTR(D2WIN, GetTextWidthFileNo, DWORD __fastcall, (wchar_t *wStr, DWORD* dwWidth, DWORD* dwFileNo), -10177, -10179)

Non-perspective (isometric) screen position of a unit. Two-line math: X offset minus (camera-X minus secondary-X), Y offset minus camera-Y. This is the core render-position formula for the FOCUS constants. | src: pPos->nX = D2COMMON_GetUnitOffsetX(pUnit) - (*D2CLIENT_6FBC9960 - *D2CLIENT_6FBCC418); pPos->nY = D2COMMON_GetUnitOffsetY(pUnit) - *D2CLIENT_6FBC995C;

Perspective-mode screen position. Reads unit world position (not offset), guards with D2GFX_CheckPerspectivePosition, transforms via D2GFX_AdjustPerspectivePosition, then applies +/-256 X shift based on UI panel state. | src: int nX = D2COMMON_GetUnitPositionX(pUnit); int nY = D2COMMON_GetUnitPositionY(pUnit); int nAdjustX = 0; int nAdjustY = 0; if (!D2GFX_CheckPerspectivePosition(nX, nY)) return FALSE;

Signature and null-guard of the reconstructed C function that kidpaddle94 describes as a slightly modified version of what the unit-hover handler uses. Returns FALSE on null args or failed perspective-position check. | src: BOOL __fastcall UNITS_GetDrawingPosition(D2UnitStrc* pUnit, D2CoordStrc* pPos) { if (!pUnit || !pPos) return FALSE;

Unit-hover main handler. Comment notes it 'originally had pUnit arg'; reconstructed as void __fastcall pulling the unit from D2CLIENT_GetSelectedUnit(). Writes gnHoverX/gnHoverY then dispatches by pUnit->dwType. | src: /* Function: UNITHOVER_Main Address: D2Client.0xC0D30 Notes: originally had pUnit arg */ void __fastcall UNITHOVER_Main()

Non-perspective hover coordinate math. IDENTICAL X formula to UNITS_GetDrawingPosition, but Y subtracts an extra 8: (*D2CLIENT_6FBC995C - 8). This is the key difference from the drawing-position formula. | src: *D2CLIENT_gnHoverX = D2COMMON_GetUnitOffsetX(pUnit) - (*D2CLIENT_6FBC9960 - *D2CLIENT_6FBCC418); *D2CLIENT_gnHoverY = D2COMMON_GetUnitOffsetY(pUnit) - (*D2CLIENT_6FBC995C - 8);

Perspective hover math. Same CheckPerspectivePosition guard + AdjustPerspectivePosition + UISTATE +/-256 X shift as the drawing-position function, but the final Y adds 16: gnHoverY = nAdjustY + 16. | src: if (!D2GFX_CheckPerspectivePosition(nX, nY)) return; D2GFX_AdjustPerspectivePosition(nX, nY, 0, &nAdjustX, &nAdjustY); switch (*D2CLIENT_gnGlobalUiState) { case UISTATE_RIGHT:

Boolean gate selecting perspective vs isometric branch. Returns nonzero when D3D perspective (depth distortion) mode is active. No numeric address given in the thread. | src: if (!D2GFX_CheckPerspective())

Validates a world (nX,nY) coordinate for perspective transform; failure aborts (return FALSE / return). Called before D2GFX_AdjustPerspectivePosition. | src: if (!D2GFX_CheckPerspectivePosition(nX, nY)) return FALSE;

The perspective-adjust entry point. Signature as used: (int nX, int nY, int 0, int* pAdjustX, int* pAdjustY) — takes world X/Y and a literal 0 third arg, writes screen-adjusted X/Y through the two out-pointers. Output then gets the UISTATE +/-256 X correction. | src: D2GFX_AdjustPerspectivePosition(nX, nY, 0, &nAdjustX, &nAdjustY);

Supply the isometric screen-offset X/Y of a unit; consumed by the NON-perspective branch of both functions. | src: D2COMMON_GetUnitOffsetX(pUnit) ... D2COMMON_GetUnitOffsetY(pUnit)

Supply the world-space X/Y of a unit; consumed by the PERSPECTIVE branch (fed into D2GFX_AdjustPerspectivePosition). | src: int nX = D2COMMON_GetUnitPositionX(pUnit); int nY = D2COMMON_GetUnitPositionY(pUnit);

After computing hover coords, dispatches to per-type handlers: UNIT_PLAYER->UNITHOVER_PlayerUnits, UNIT_MONSTER->UNITHOVER_MonsterUnits, UNIT_OBJECT->UNITHOVER_ObjectUnits, UNIT_ITEM->UNITHOVER_ItemUnits, UNIT_TILE->UNITHOVER_TileUnits; default returns. | src: switch (pUnit->dwType) { case UNIT_PLAYER: UNITHOVER_PlayerUnits(pUnit); case UNIT_MONSTER: UNITHOVER_MonsterUnits(pUnit); case UNIT_OBJECT: UNITHOVER_ObjectUnits(pUnit); case UNIT

D2Client.dll version probe: DWORD at base+0x17F. Render-critical module (client-side draw/UI); its detected version selects the offset table used for all client render hacks. | src: GET_VERSION(D2Client, 17F, 00000000, 14500000, 12500000, 0D814800, 0D812800, 0DA01000, 0DA03000);

D2gfx.dll (D2Gfx) version probe: DWORD at base+0x10D. Graphics/present module; version selects render offsets. Note col7 (V113c) sig is 00000000 (same literal as D2Client col1) — value copied verbatim as read. | src: GET_VERSION(D2gfx, 10D, EB000000, 006FA700, 00000010, 2A000401, 19000401, 0B210E00, 00000000);

D2Win.dll version probe: DWORD at base+0x1699. UI/window/panel module; version selects offsets used by the panel (new-interfaces / stash) render hacks. | src: GET_VERSION(D2Win, 1699, 88686F8C, 84686F8C, D094686F, F0030000, 001435E8, 8B088F44, 0013F5E8);

Panel installer entry point: the new-interfaces (large stash / shared-stash panels + reworked inventory UI) hooks are installed only when the active_newInterfaces config flag is set. The Install_NewInterfaces() DEFINITION is NOT in D2wrapper.cpp (it lives in the interface/panel source, referenced via #include); D2wrapper.cpp holds only the gated call site. | src: if (active_newInterfaces) Install_NewInterfaces();

Panel installer entry point: the multi-page (paged) stash hooks are installed only when active_multiPageStash is set. Definition not in D2wrapper.cpp (external source via #include); D2wrapper.cpp holds only the gated call site. | src: if (active_multiPageStash) Install_MultiPageStash();

Applies a DyPos position change. Signature per comment: __stdcall(DyPos* @ esi, FixedU16, FixedU16, Room*). DyPos pointer passed in ESI (register/thiscall-ish stdcall). | src: // Signature: `__stdcall(DyPos* @ esi, FixedU16, FixedU16, Room*)` apply_pos_change: 0xda40,

perspective-mode check (draw/render path)

main window handle accessor

draw menu function

draw line primitive

palette find-closest-color

generate one weather particle. Signature: stdcall(&mut Rng). | src: // Signature: stdcall(&mut Rng) gen_weather_particle: 0x80700,

remove entry from environment array

Draws framed text: (wchar_t* text, int nX, int nY, int nTextColor, int nAlign, int nRectColor). UI text-render primitive. | D2FUNC(D2WIN, DrawFramedTextExt, void, __fastcall, (wchar_t *wszText, int nX, int nY, int nTextColor, int nAlign, int nRectColor), 0xACD0) //D2Win.#10

Builds a PL2 (palette+shift-tables) from a 256-color palette; entry point for changing D2's color scheme. D2PL2Strc* __stdcall D2CreatePL2(BYTE pPalette[256]). | D2CMP.#10000 D2PL2Strc* __stdcall D2CreatePL2(BYTE pPalette[256])

Draws the selection/aura outline around a unit. BOOL __fastcall UNITDRAW_DrawOutline(D2UnitStrc* pUnit). Part of the client unit-render path. | Function: UNITDRAW_DrawOutline Address: D2Client.0x6FB59F20

Decrements a unit's outline tick and returns whether to draw it (unless STATE_ATTACHED). Reads pUnit->dwOutlineTick. Part of unit-render tick. | Function: UNITDRAW_TickOutline Address: D2Client.0x6FB29A40 ... DWORD dwTick = pUnit->dwOutlineTick;

Under 1.10 determines whether a unit is drawn/shown; forcing its dead-check to return false keeps dead units visible. A gate in the client draw path. | D2Client.0x6FACE8F0 under 1.10 determines if a unit is shown

Draws the (life/mana) orb on the HUD panel. Direct panel/HUD render entry. | D2Client.0x6FAFF9D0 draws the orb

The room draw-list build step: D2Client passes its D2AddRoomToDrawList callback to D2IterateRooms (D2Common #10049) to walk visible rooms and enqueue them for drawing. Core of the world/floor render pipeline. | PUSH <D2Client.D2AddRoomToDrawList> ... CALL <D2Client.D2IterateRooms> ; JMP to D2Common.#10049

Reads the per-subtile collision mask for a room coord: indexes pRoom->pCollisionGrid->pCollisionMask via ((y - subtilesTop)*subtilesWidth - subtilesLeft + x) & fMask. Reveals D2RoomCollisionStrc layout (pCollisionMask, pCoords with dwSubtilesTop/Left/Width). Governs floor/tile walkability that render+pathing share. | WORD __fastcall COLLISION_CheckMask(DRLGRoom* pRoom, int nXpos, int nYpos, WORD fMask) ... pMask[(((nYpos - pCoords->dwSubtilesTop) * pCoords->dwSubti

Client-side view/render init trio: D2CreateView (called at 6FAA9501), D2BuildGouraudTables (6FAAB3C7), D2FreeGuaraudTables (6FAABB40). Gouraud tables drive the lighting/shading of the play-area render. | CALL D2Client.6FAB6FF0 ; D2CreateView() ... CALL D2Client.6FAB6AC0 ; D2BuildGouraudTables() ... CALL D2Client.6FAB6EB0 ; D2FreeGuaraudTables()

Normalizes an X/Y coord pair (in place). __forceinline void __fastcall PATH_NormalizeCoords(int* pXpos, int* pYpos). Coordinate transform used in pathing/positioning. | Function: PATH_NormalizeCoords Address: D2Common.#10111

Draws a unit's overlays; repeats the same world-offset/panel-adjust/perspective transform (subtract WorldX/YOffset, else-branch; or D2AdjustPerspectiveCoords + GetPanelAdjust + 16 in perspective). Second confirmed site of the panel-adjust screen-shift logic. void __fastcall(pUnit, dwColorTint, bBack, nXpos, nYpos, bPerspectiveDisabled). | Function: UNITDRAW_DrawOverlays Address: D2Client.0x6FB5A490 ... nXpos += UNITDRAW_GetPanelAdjust(); nXpos += 16; ... nXpos = pCoord.nXpos - UNITDRAW

void __fastcall(D2GameStrc* pGame, DRLGRoom* pRoom) - re-initialises a room | D2FUNC(D2GAME,0x85A0,void,__fastcall,D2ReInitRoom,(D2GameStrc* pGame, DRLGRoom* pRoom));

D2Gfx image-blit-to-window function (ordinal 10072) at GfxOffset+0x42A0 | D2DrawImageToWindow = (GfxOffset + 0x42A0); // D2Gfx.10072

Internal item gfx data fetch: (D2GfxDataStrc*, UnitAny*, CellFile*, int nDirection, int nFrame, BYTE fFlags, DWORD dwColorTint, int* pIndex). 1.13c offset 0x6E2C0 confirmed. Various naked __fastcall/__stdcall wrappers posted | D2PTR(D2CLIENT, GetItemGfxData_I,0x6E2C0) //0x6FB1E2C0

Builds the composite comp/color arrays (nComp[16] +088, nColor[16] +098). eD2CompositeItem enum: HEAD0,TORSO1,LEGS2,RARM3,LARM4,RHAND5,LHAND6,SHIELD7,SPECIAL1-8=8..15,COUNT16,INVALID0xFF | Function: ITEMS_GetCompData Address: D2Common.#10298

The function that handles inventory drawing. IMPORTANT for panel work: it ALSO draws the Stash, Cube, and Trade panels, so it's non-trivial to isolate a single panel. Advice: search for the .dc6 names to find the globals that store the panel images. | The function that handles the inventory drawing is located at D2Client.0x3EAC0 ... it also draws the Stash, Cube, Trade Panels

Necrolis-labeled function returning the component/draw-priority bytes for a unit's COF given rotation+frame. Indexes into the COF trailing arrays: nPos = ((nRotation*nFrames + nFrame + sizeof(D2COFLayerInfoStrc)) * nLayers) + nFrames, then adds sizeof(D2COFStrc). Part of the character/unit sprite render path. | Function: UNITDRAW_GetComponents Address: D2Client.0x6FB5EFC0

D2Win ordinal 10127 = D2SetFont, at WinOffset+0x09FF0 (6F8A9FF0). Text-render setup. | D2SetFont = (D2Win10127)(WinOffset + 0x09FF0); // D2Win.6F8A9FF0 #10127

signed int __stdcall ReadDC6Header(CelFile* pFile, DC6Header** a2, int a3, int a4). Asserts pFile->dwFlags & CELFILE_24BIT; allocates 4*framesPerDir*directions + sizeof(DC6Header); sets version=6, subVersion = dwFlags & 0xF8, copies directions/framesPerDir; dispatches via off_6FE091C0 table indexed by pFile->gap8. Related build-DC6 code sets subVersion 5 if 24bit else 1. | signed int __stdcall D2CMP_10025_ReadDC6Header(CelFile *pFile, DC6Header **a2, int a3, int a4)

D2Common export at 6FC711D6 named TileGetRarity (tile rarity accessor). | 6FC711D6 .text Export TileGetRarity

D2Common export at 6FC71668 named TileProjectSerialize (tile projection serialization). | 6FC71668 .text Export TileProjectSerialize

Layer draw loop over COF layers: for each selectable component, memset gfx, D2CLIENT_GetItemGfxData_6FB5EC80 fills a CelContext (dir, frame, component), then D2GFX_10076_DrawImageFast(&gfx, pXAdjust, pYAdjust, palette). Iterates layerIdx < cofFile->header.layers. Core unit/item composite rendering. | D2CLIENT_GetItemGfxData_6FB5EC80(...) ... D2GFX_10076_DrawImageFast(&tmpGfxInfo, pXAdjust, pYAdjust, nPaletteIndex[0]);

Computes the outline color index when a unit is hit: lazily inits color indices via D2WIN_10034_GetClosestColorIndex (green 0,C0,0 / yellow E0,E0,0 / red E0,0,0 / blue 0,0,C0); for monsters checks MonStatsFlags bit1 (->blue), else colors by life% (<33 red, <66 yellow, else green). Uses ConvertMode #11013, GetAnimOrSeqMode #10369, QuickGetTotalMaxLife #10564, GetUnitStat #10519. | gGreenColorIndex = D2WIN_10034_GetClosestColorIndex(0, 0xC0u, 0); ... nLifePercentage < 33) return gRedColorIndex

Returns the color/transform palette for drawing an item: __stdcall(pOwner, pItem, pColor, nTransType). Key gotcha: passing the player as pOwner tints inventory items by the player's palette; must pass NULL as pOwner so inventory items draw with correct colors. | BYTE* __stdcall ITEMS_GetItemPalette(Unit* pOwner, Unit* pItem, BYTE* pColor, int nTransType)

Draws an item into the inventory/character panel: validates UNIT_ITEM, gets client player, GetItemCacheGfxData + D2CMP_InitGfxData, animates via GfxData.nFrame=((GetTickCount()>>7)+item LoSeed)%nMaxFrames, applies DRAWMODE_TRANS50 for ethereal, then D2GFX_DrawImage(&gfx, nPosX, nPosY+cell->nHeight, -1, drawMode, ITEMS_GetItemPalette(NULL,pItem,&nColor,1)). The pOwner=NULL fix lives here. | INVENTORYSCREEN_DrawItem Address: D2Client.0x6B5A0 ... D2GFX_DrawImage(&GfxData, nPosX, (nPosY + pCell->nHeight), -1, nDrawMode, ITEMS_GetItemPalette(

__fastcall(D2UnitStrc* pUnit, D2COFStrc* pCOF) BOOL — determines whether a unit/COF is selectable (mouse-over hit eligibility). | D2Client.6FB5F7F0 BOOL __fastcall D2CheckUnitSelectable(D2UnitStrc* pUnit, D2COFStrc* pCOF)

Draws the colored cell background behind an inventory item, given the grid-info struct, X/Y, item width/height in cells, and a color index. Side-panel (inventory) rendering primitive. | void __fastcall UI_INVENTORY_DrawItemBackground(D2InventoryGridInfoStrc* pInventoryGridInfo, int nX, int nY, BYTE nItemWidth, BYTE nItemHeight, DWORD

Loads the inventory item-background colors in advance (paired with UI_INVENTORY_DrawItemBackground). | void __fastcall UI_INVENTORY_LoadItemBackgroundColors()

Draws socket overlays in the inventory grid. Signature sub_6FAE0DC0(UnitAny* ptItem, InventoryGrid* pGrid, int nLeft, int nBottom). Uses a socket-position lookup array (first 2 dwords = where socket should be drawn, then 10 zero dwords per entry). 1.13c client base is 0x6FAA0000. | void __fastcall sub_6FAE0DC0(UnitAny *ptItem, InventoryGrid *pGrid, int nLeft, int nBottom)

Decompiled socket-drawing loop: indexes gSocketPositions by [height + 4*(width + 2*nbSockets) - 13], computes cell-centered X/Y from nGridBoxWidth/Height, sets up a D2GfxData with pCelFile = GEMSOCKET cellfile global (0x6FBB5E34) and calls D2GFX ordinal #10072 DrawImage, then draws each socketed item via DrawInventoryItems at 0x6FB5A320. Panel item/socket render pipeline. | pData.pCelFile = (CelFile *)gpCellfile_GEMSOCKET_6FBB5E34; D2GFX_10072_DrawImage(&pData, v10 - 1, v12, -1, 0, 0);

Checks whether a unit is the current selection target during unit drawing; called from the unit-draw routine at 0x6FB5A720. Part of the play-area unit render path. | BOOL __fastcall UNITDRAW_CheckSelection(D2UnitStrc* pUnit) // D2Client.0x6FB286B0

Ordinal exports that parse/load a 24-bit tile library, taking a per-pixel RGB mapping callback. Part of the DT1 tile-loading pipeline for the floor renderer. | 10074 void __stdcall D2Parse24BitTileLibrary(D2TileLibraryStrc* pLibrary, void (__stdcall* pfMap)(DWORD dwRGB))

Fills a D2GfxDataStrc for an item given cell file, direction, frame, component and mode. Item graphic-data resolver used in inventory/ground rendering. | BOOL __fastcall D2CLIENT_GetItemGfxData_6FB5EC80(D2GfxDataStrc* pGfxData, D2UnitStrc* pItem, D2CellFileStrc* pCellFile, int nDirection, int nFrame, in

Whist identifies D2Client 6FAA3330 (1.10f) as where the tile-draw params struct is set up; Lectem notes one member is ptRect at +0x24 (matches pView slot in the 1.13c struct). Confirms the floor-render param block is built here before the d2gfx tile ordinals are called. | only def I have is the struct that gets passed to the tile drawing d2gfx ordinals and it's really incomplete

Screen->world isometric coordinate transform (D2Common ordinal #10108). nX*=2; outX=(nX+nY)>>5; outY=(nX-nY)>>5. Core camera/iso projection math used when converting cursor/screen to tile world coords. | PATH_ScreenToWorld ... nXpos *= 2; *pXpos = (nXpos + nYpos) >> 5; *pYpos = (nXpos - nYpos) >> 5;

World->screen isometric transform (D2Common #10111): outX=(nX-nY)<<4; outY=(nX+nY)<<3. The inverse projection that places world tiles onto the play-area viewport. | PATH_WorldToScreen ... *pXpos = (nXpos - nYpos) << 4; *pYpos = (nXpos + nYpos) << 3;

D2Common #10112 coordinate flatten: outX=(nX-nY)>>1; outY=(nX+nY)>>2. Another iso coordinate transform in the path/render coordinate family. | PATH_FlattenCoords ... *pXpos = (nXpos - nYpos) >> 1; *pYpos = (nXpos + nYpos) >> 2;

Tile coordinate expansion helpers: DUNGEON_TILES_ExpandCoords = D2Common #10110, DUNGEON_ExpandCoords = D2Common #10113. Part of the dungeon-tile coordinate transform set. | DUNGEON_TILES_ExpandCoords ... Address: D2Common.#10110 ... DUNGEON_ExpandCoords ... Address: D2Common.#10113

Waypoint-panel drawing loop: WaypointTable at D2CLIENT 0xFCD8C, WaypointCoordTable at 0xDE6D8. Every cell/text is drawn at (*D2CLIENT_WindowStartX + coordTable->nX, coordTable->nY - *D2CLIENT_NegWindowStartY) via D2GFX_DrawCellContext / D2WIN_DrawText. Shows how side-panel UI is offset by the WindowStartX / NegWindowStartY globals -- directly relevant to panel-vs-playarea coordinate origin. | D2GFX_DrawCellContext(&pData, *D2CLIENT_WindowStartX + ptCoordTable->nX, ptCoordTable->nY - *D2CLIENT_NegWindowStartY, ...)

D2Client.0x6FAA3B90 -- draws roof tile layer for the play area, takes D2ViewStrc* pView. | //D2Client.0x6FAA3B90 void __fastcall MULTIRES_DrawRoofTiles(D2ViewStrc* pView)

D2Client.0x6FAA63E0 -- draws upper wall tiles; takes a D2DrawSlotStrc, a bOnlyShadows flag, and pView. | void __fastcall MULTIRES_DrawUpperWallTiles(D2DrawSlotStrc* pDrawSlot, BOOL bOnlyShadows, D2ViewStrc* pView)

D2Client.0x6FAA6670 -- draws lower wall tiles; takes pView. | void __fastcall MULTIRES_DrawLowerWallTiles(D2ViewStrc* pView)

D2Client.0x6FAA2E60 & D2Client.0x6FAA3330 -- draws the ground tile layers; takes pView. This is the core floor/ground draw pair that Lectem's dFloor snippets belong to. | //D2Client.0x6FAA2E60 & D2Client.0x6FAA3330 void __fastcall MULTIRES_DrawGroundTiles(D2ViewStrc* pView)

D2Client.0x6FAA23B0. Sets gdwScreenWidth/Height (640x480 or 800x600), sets gpExpansionUI, then gdwViewWidth = gdwScreenWidth and gdwViewHeight = gdwScreenHeight - kMultiResolutionUIHeightAdjustment. Calls MULTIRES_ResolutionChanged, MULTIRES_UpdateView(*gdwScreenPanels), D2ResizeAutomap, D2ResizeDialogs. THE function that derives the play-area view size from screen size minus UI height -- core to panel/viewport layou | *gdwViewWidth = *gdwScreenWidth; *gdwViewHeight = *gdwScreenHeight - kMultiResolutionUIHeightAdjustment; ... MULTIRES_UpdateView(*gdwScreenPanels);

D2WIN.0x17B60 (ordinal #10176), __stdcall(nResolutionMode). Passes the resolution mode down to D2GFX #10025 to resize the window rect. | D2FUNC(D2WIN, ResizeWindow, void, __stdcall, (int nResolutionMode), 0x17B60);//D2WIN.#10176 - Pass resolution mode to D2GFX.#10025

D2GFX.0x7FD0 (ordinal #10025). Maps resolution mode -> out RECT right/bottom: 0=640x480, 1/2=800x600, 3=1344x700, default=0x0. Selects resolution mode and resizes the window rect. | D2FUNC(D2GFX,SelectResolutionMode,void,__stdcall,(int nResolutionMode,int *Out_RECT_right,int *Out_RECT_Bottom),0x7FD0)

D2Win #10179 = PAL_Update() (applies palette); D2Win #10176 = PAL_SetUpdate(BOOL) sets the palette globals to activate/deactivate the update. (Note ordinal #10176 also cited for ResizeWindow -- version ambiguity to watch.) | //D2Win.#10176 void __fastcall PAL_SetUpdate(BOOL bActive) ... activate or deactivate D2Win.#10179

Full client entry point: loads LNG, UI_Init, tables, then runs the app-mode function table (nMode loop) until APPMODE_CONTINUE. APPMODE_RENDER=6 is one of the client app modes. gszInterfaces[] maps D2Client/D2Server/D2Multi/D2Launch/D2EClient. | appmode_t* pfModes = VDEF(appmode_t*,D2CLIENT,0x44EC); ... *VDEF(DWORD*,D2CLIENT,0xD44D8) = nMode;

Client-side data-table loader; note bPrecacheTileLibraries param governs tile-library precache (floor/tile relevance). | CLIENT_LoadDataTables(D2PoolManagerStrc* pMemPool, BOOL bPrecacheTileLibraries, BOOL bCreateLvlSubList)

Line/rect draw helpers positioned via ScreenWidth/2 - 0x90 (144) etc. DrawRectangle callable at D2Client.0xD0BA on 1.13c; D2gfx_DrawRectangle used with ScreenWidth/ScreenHeight to place a centered rect. | call D2Gfx_DrawLine -> D2Gfx_DrawRectangle

Draws a rectangle at (ScreenWidth/2 - 0x7F, ScreenHeight-0x1B) sized region -- another centered-on-play-area placement using ScreenWidth/2. | sub eax, 7Fh ... call D2gfx_DrawRectangle

Bottom-panel HUD draw functions (health globe, mana globe, exp bar). | //D2Client.0x6DDE0 - UI_DrawHealthGlobe

Draws the active skill icons in the bottom control panel. Left uses nX=0x75; right uses ScreenWidth + 0xFFFFFF5B (i.e. ScreenWidth-0xA5). bLeftSide flag distinguishes the two panels. | push 75h ; nX ... call UI_DrawActiveSkillIcon

Skill-select menu draw. Right column at nX=0x50; left column at ScreenWidth + 0xFFFFFF80 (ScreenWidth-0x80). Input coords for the buttons live at 0x6F710; shifting the listed X offsets moves the popup menu too. | That's in UI_DrawSkillSelect, which is D2Client.0xA77D0

whist: THE entry point for in-game UI drawing -- 'the best place to start looking for ui drawing code is always there'. Takes a GameView*. Top of the panel/HUD draw tree; prime hook target for panel/play-area work. | the best place to start looking for ui drawing code is always there ... GAMEUI_DrawInterface

The mini-panel (the small button strip that opens inventory/character/skill panels). Input handler table + the drawing routine at 0x64990. | The drawing code is at D2Client.0x64990

Cell lookup: pCellPos[nCellPosId + pCellFlags[nCellFlagId]]. DRLGGrid = {int* pCellPos, int* pCellFlags, nWidth(nCells), nHeight, nullOnInit}; Lectem's D2DrlgCoordIndexStrc variant has pIndexList checked via bitmasks. drlg tile flags at D2DrlgTileDataStrc+0x14. | return pDrlgGrid->pCellPos[nCellPosId + pDrlgGrid->pCellFlags[nCellFlagId]];

Where the majority of input coordinates for the skill-button inputs live; shifting the X offsets also moves the skill-select popup that appears. | D2Client.0x6F710 is where the majority of the input coordinates for the skill button inputs are on 1.13d

Client image preload routine at 0x5E370 + ClientOffset. | D2PreLoadImages = (0x5E370 + ClientOffset); // D2Client.6FAFE370

CORE RENDER: __fastcall(pUnit,dwColorTint,nXpos,nYpos,bFade,bDrawOverlays) - draws a unit's sprite at screen X/Y with tint/fade/overlays. This is the per-unit draw entry in the play-area render path. | Function: UNITDRAW_DrawUnit Address: D2Client.0x6FB5A720

RENDER: __forceinline __fastcall(pGFXData,pUnit,pCellFile,nDirection,nFrame,fFlags,dwColorTint,pIndex) - caches the cell/DCC gfx data for a unit before drawing; called from UNITDRAW_DrawUnit. | Function: UNITDRAW_CacheGFXData Address: D2Client.0x6FB5EC80

Inventory action handler sig (Game* pGame, Inventory* pInv, int nInput, int* a5, int* a6); a5/a6 last two args undetermined. | (Game* pGame, Inventory* pInv, int nInput, int* a5, int* a6)

UI panel open/close state reader: BOOL __fastcall UI_GetState(int nUiIndex) at D2Client.0x6FB23230 (1.10f); reads global array D2CLIENT_gnUiToggle[nUiIndex]; UITOGGLE_ESCMENU=9, bounded by NUM_UI. Core of knowing which side panels are open. | Address: D2Client.0x6FB23230 ... return D2CLIENT_gnUiToggle[nUiIndex];

D2Client.6FAD7210 = D2GetItemName(pItem, wszBuffer, nBufferSize); called from 5 sites (6FADBBD6/6FADC43D/6FADC9B5/6FADD488/6FADD90D) — the item-description name builders, hookable to inject extra tooltip lines. | CALL D2Client.6FAD7210 ; D2GetItemName(D2UnitStrc* pItem, wchar_t* wszBuffer, size_t nBufferSize)

Item-Level-on-tooltip hook: patch site file offset 0x438A1 (1.9-1.13 variants 3D47C/438A1/ADD0A/789DA/AE0AA/941C0); 1.13 live 0x6FB341C0-... ; Set-item variant patch at 0x427BE. Uses D2CLIENT_SetColourPopUp (D2SetColorPopup, D2Client 85A60 in 1.11). | {D2DLL_D2CLIENT, 0x438A1, PATCH_CALL, FALSE, 1}, //6FAE38A1

Skill speed-book (radial skill selector) draw routine: void __fastcall SPEEDBOOK_DrawMenu(int nStart, BOOL bLeft, BOOL bDesc) at D2Client.0x6FB19720. On-screen HUD panel render. | Function: SPEEDBOOK_DrawMenu Address: D2Client.0x6FB19720

Speed-book click handler: void __stdcall SPEEDBOOK_ClickDown(D2WinMsgStrc* pMsg) at D2Client.0x6FB19BB0. | Function: SPEEDBOOK_ClickDown Address: D2Client.0x6FB19BB0

Speed-book skill-icon draw: void __fastcall SPEEDBOOK_DrawIconEx(D2CellFileStrc* pCells, D2SkillStrc* pSkill, SkillsTXT* pRecord, DWORD dwGUID, int nValue, int nColor, int nXpos, int nYpos, BOOL bLeft) at D2Client.0x6FB18AC0. Takes explicit X/Y screen coords. | Function: SPEEDBOOK_DrawIconEx Address: D2Client.0x6FB18AC0

Skill-tree panel tab-icon draw: void __fastcall SKILLTREE_DrawTabIcons(D2UnitStrc* pPlayer, int nTab, int nClass) at D2Client.0x6FB163B0 and 0x6FB16A50 (two entry points). Left-side skill panel render. | Function: SKILLTREE_DrawTabIcons Address: D2Client.0x6FB163B0 & D2Client.0x6FB16A50

Skill-tree panel mouse handlers: SKILLTREE_ClickDown at D2Client.0x6FB17A80 and SKILLTREE_ClickUp at D2Client.0x6FB18100, both __stdcall(D2WinMsgStrc*). | Function: SKILLTREE_ClickDown Address: D2Client.0x6FB17A80

Draws a Unicode string: ECX=ptr to unicode string, EDX=x, Arg1=y, Arg2=colour, Arg3=always 0. Called from D2Client to print stats on character screen. | Function: Display Text Address: 6F8AAD40 in v1.10 ECX - pointer to Unicode String EDX - x coord Arg1 - y coord Arg2 - colour

Returns which container/page an item is in: 00 Inventory, 01 BodyLoc, 02 Belt, 03 Ground, 04 Cursor. Core mapping for inventory/equip side-panel item location. | Get the Node Page Offset: 00052100 (6FD92100) ... 00: Inventory 01: BodyLoc 02: Belt 03: Ground 04: Cursor

D2FillArea passes 6 params; in 1.13d the CALL EAX lands in D2Gdi 0x6f877370 (takes all 6), in 1.14d lands at 0x006c8a60 windowed renderer (uses only params 3-6). Area-fill (solid rect) render path. | in 13d the CALL goes to this address 0x6f877370 in D2Gdi.dll that function takes all 6 paramters from D2FillArea

void(nXStart,nYStart,nXEnd,nYEnd,dwColor,nDrawMode) - wrapper to every renderer. Guards x<=xEnd && y<=yEnd then calls [DAT_007c8cc0+0xB8](xEnd,yEnd,color,mode). This is the solid-rectangle fill primitive (relevant to dead-zone/panel-area fills). | void D2GFX_DrawSolidRectEx(int nXStart,int nYStart,int nXEnd,int nYEnd,DWORD dwColor,int nDrawMode)

Windowed-mode renderer solid-rect fill; __fastcall(x1,y1,x2,y2,byte color,int mode). The concrete windowed backend behind D2GFX_DrawSolidRectEx wrapper (0x4f6300). | //0x6c8a60 void __fastcall RENDERER_WINDOWED_DrawSolidRectEx (uint param_1,uint param_2,...)

1.14 (post-DLL-merge) addresses; note subtract 0x400000 to get RVA. Mouse X/Y getters useful for cursor-vs-viewport mapping. | D2GetMouseX ... -> 0x468730 ... D2GetMouseY ... -> 0x468740

void __fastcall(wchar_t* pString,int nXpos,int nYpos,int nColour,int nTransTbl). Main HUD unicode draw call. | D2FUNC(D2WIN, D2DrawText, void, __fastcall, (wchar_t* pString, int nXpos, int nYpos, int nColour, int nTransTbl), 0xAD40)

void __fastcall(func1,func2) that initializes two function-pointer globals. Kingpin named it D2SetScrollEndFunc. Named for scroll-end handling (viewport scroll callbacks). | static D2Client6FB1CBD0 D2SetScrollEndFunc = (D2Client6FB1CBD0)(0x7CBD0 + ClientOffset); // D2Client.6FB1CBD0

Function responsible for drawing the skill icons in 1.10 | In 1.10 have a look at D2Client.0x6FB18AC0, its responsible for drawing the icons.

Core game-UI draw function; hook target for drawing UI (calls #10072). Called from within larger UI routine; also builds a 0x13C stack frame at 6FB21B70 | //D2Client.6FB20A30 D2FUNC(D2CLIENT, CDraw_Game_UI, void, __fastcall, (DWORD Arg01), 0x80A30)

Inside the GUI draw routine: CALL 6FAEF360 draws stat-points buttons, CALL 6FAEF730 draws skill-points buttons (at 6FB22030/6FB22044) | CALL d2client.6FAEF360 ; GUI Buttons -> stat points ... CALL d2client.6FAEF730 ; GUI Buttons -> skillpts

D2Win ordinal 10110 draws a text popup background; helpers 6f8f1fb0 (text->background width, param in EAX) and 6f8f1e80 (text->background height, param in ESI); width/height feed D2GFX_DrawRectangle | 6f8f1fb0, takes text as param1 ... returns background width ... passed into the D2GFX_DrawRectangle function

kain_abel_666 located where a background is drawn: a D2gfx.#10072 draw call at 04D72AE5 that takes an X (EAX from [EBP-18C]) and a Y value (EDX from [EBP-190]); he identifies the Y push at 04D72AD0 as the value that is 'messing up' his positioning. Directly a render-pipeline / draw-position problem analogous to ours. | so i figured out where it draws the background ... CALL DWORD PTR DS:[4D76AA4] ; D2gfx.#10072 ... is the Y Value that is messing up

Necrolis' reversed inventory item-draw function (draws an item cel inside the inventory/side panel, with overlay support). Shows the full draw path: UNITDRAW_CacheGFXData -> D2LoadCelFile -> GFXUTIL_CellWithinScreen -> D2DrawImage -> UNITDRAW_DrawOverlays. Directly the side-panel render pipeline. | Function: ITEMS_InventoryDraw Address: D2Client.0x6FB5A320 ... BOOL __fastcall ITEMS_InventoryDraw(D2UnitStrc* pItem, int nXpos, int nYpos)

D2Client.6FB57BD0 reads global at 6FBC1AE8; Harvest identifies it as GetMouseYCoordinate (RVA 0xB7BD0, __stdcall, no args). Screen-space coordinate accessor. | D2FUNC(D2CLIENT, GetMouseYCoordinate, DWORD, __stdcall, (), 0xB7BD0) //D2Client6FB57BD0

kain_abel_666 repositioning D2BuffIcons: text via D2Win.#10117 D2DrawText(pString,nX,nY,nColour,nTransTbl); icon images via GFX.#10073. Asks what -1 as the transtbl arg means. UI-panel overlay positioning. | D2DrawText(wchar_t* pString, int nXpos, int nYpos, int nColour, int nTransTbl); ... the only called to GFX.#10073 for the images

Client-side handler run when clicking an item; takes inventory pointer, mouse X/Y and inventory page. Relevant to side-panel/inventory hit-testing. | //D2Client.0x475C0 D2FUNC(D2CLIENT, Item_Click, int32_t, __fastcall, (D2UnitStrc* pPlayer, D2InventoryStrc* pInventory, int pMouse_X, int pMouse_Y, ui

Gets the inventory record id for a unit/inv page (Inventory.txt). Used for inventory/panel geometry. | //D2Common.0x6FDBEBE0 (#10409) int __stdcall UNITS_GetInventoryRecordId(D2UnitStrc* pUnit, int nInvPage, BOOL bLoD)

Two state-flag accessors returning DWORD* into a unit's state bitfield: #10492 GetGfxStateFlags @0x6FDB4760, #10494 GetStatFlags @0x6FDB48F0. GfxStateFlags governs which overlay/graphic states are active on a unit. | //D2Common.0x6FDB4760 (#10492) DWORD* __stdcall STATES_GetGfxStateFlags(D2UnitStrc* pUnit) ... //D2Common.0x6FDB48F0 (#10494)

Necrolis: void __fastcall PLAYERMODE_Change(pGame,pPlayer,pSkill,BYTE nMode,int nUnitType,DWORD dwGUID,BOOL bAllowReEnter) at D2Game.0x6FC81A00 (RVA 0x51A00). Changes a unit's animation/mode. | Function: PLAYERMODE_Change Address: D2Game.0x6FC81A00 ... void __fastcall PLAYERMODE_Change(D2GameStrc* pGame, D2UnitStrc* pPlayer, D2SkillStrc* pSki

whist: 0xC39E0 is the main ui loop where all panels are rendered; it calls 0x58FB0 which draws the boxes shown when ALT is pressed to show ground items; hookable via d2template | at D2Client.0xC39E0 is the main ui loop where all the different panels are rendered ... a call to D2Client.0x58FB0, which is the function that handles

Master click/message dispatcher for all menu panels; found by locating the 4 adjacent Storm#414-417 Input* calls, the function just before them handles all menu clicks; called ~40 times, one callback per panel type; callbacks share globals with the drawing function | the function immediately before is the one that controls all the Clicks of the Menus ... called about 40 times ... one for each type of Panel

Builds each room's ppRoomsNear list by scanning level rooms within tile distance <10 in X and Y (nTileXPos/YPos/Width/Height), sorts by position; D2Moo raises near cap 6->10 (ppNearRooms[1024]) | Function: DRLGROOM_AllocRoomNears Adress: D2Common.0x6FD77BB0 ... Improvement 6 --> 10

Draws multi-item ground hover boxes; second half is the relevant part; uses FONTS_GetTextDimensions then nWidth += 8 for box sizing | Function: ITEMDESC_DrawGroundMultiHover Address: D2Client.0x6FB09F60

Single top-level handler that draws the entire bottom control panel and the exp bar. NOPing its no-arg calls reveals what each sub-call draws. | that's the function I mentioned ... D2Client.0xC39E0 (top level handler necrolis mentioned)

Renders the orb text (life/mana orb display) on the control panel. | Function: ControlPanel::OrbTextDisplay Address: D2Client.0x6FAFF0B0

Sets bit 8 of pTileData->dwFlags from the sign bit (0x80000000) of nTileFlags; floor/room tile flag handling. | 0x6FD88AC0 ... if (nTileFlags & 0x80000000) pTileData->dwFlags |= 8

void __fastcall UNITDESC_DrawInformation(D2UnitStrc* pUnit) at D2Client.0x6FB20A30 (1.10). Draws the unit info/nameplate; contains a large per-unit-type switch that looks up the display name. Render-relevant (unit nameplate drawing). | Function: UNITDESC_DrawInformation Address: D2Client.0x6FB20A30 ... large switch inside it for each unit type

Function responsible for drawing the stamina bar; 0x7BEFBA is an array of palette indexes picking bar color by remaining stamina | 0x4975B0. that is the func responsible for drawing the stamina bar ... 0x7BEFBA is an array of pallette indexes

Function that draws the experience bar | try looking at 0x498EA0 for xp bar

D2RoomStrc* __stdcall DUNGEON_StreamRoomAtCoords(D2DrlgActStrc* pAct, int nX, int nY) — resolves the room at world coords | D2RoomStrc* __stdcall DUNGEON_StreamRoomAtCoords(D2DrlgActStrc* pAct, int nX, int nY)

Allocates a DRLG level from mempool; sets pDrlg, nLevelId, nLevelType, nDrlgType from DATATBLS_GetLevelDefRecord | D2DrlgLevelStrc* __fastcall DRLG_AllocLevel(D2DrlgStrc* pDrlg, int nLevelId)

The callback that fills the Units renderer structure to later draw; invoked from D2Common.#10049 DUNGEON_CallRoomCallback. Central to the play-area unit render pipeline. Signature: BOOL __stdcall INTERFACE_FillRender(D2RoomStrc* pRoom, D2GameViewRenderDataCallBackStrc* pArgs). Hazel hit a crash here throwing many-CtC items into a crowd. | This is a callback from D2Common.#10049 (DUNGEON_CallRoomCallback). It is the function that is responsible for filling the Units renderer structure to

Hover/tooltip text draw. Clamps X/Y against screen size via D2GFX_GetScreenSize(&nGameWidth,&nGameHeight); positions box so it stays on screen (nXpos > nGameWidth-nWidth -> nGameWidth-nWidth-5). Draws background via D2GFX_DrawSolidRectEx. Shows how the game reads viewport dimensions for UI placement -- the nGameWidth/nGameHeight globals bound the drawable area. | D2GFX_GetScreenSize(&nGameWidth, &nGameHeight); ... if ((uint32_t)nXpos > nGameWidth - nWidth) nXpos = nGameWidth - nWidth - 5;

Function that draws the waypoint panel in 1.13c. Active tab is a D2Client global variable (no server round-trip to switch tabs). Good entry point for locating panel-tab state globals. | the function that draws the waypoint panel (D2Client.0xAAEC0 on 1.13c)

Draws the selected-unit name over the play area. Two names for same addr: D2FUNC CDraw_Game_UI (0x80A30) and Araksson's INTERFACE_DrawUnitSelectedName (void __fastcall(D2UnitStrc*)). Silvermane long wanted to rewrite this hover-name function. | Function: INTERFACE_DrawUnitSelectedName Adress: D2Client.0x80A30 void __fastcall INTERFACE_DrawUnitSelectedName(D2UnitStrc* pUnit)

Draws the ground item hover name in the play area: void __fastcall UI_DrawGroundHoverItem(D2UnitStrc* pItem, wchar_t* pBuffer, int nSize). | //D2Client.6FB20740 void __fastcall UI_DrawGroundHoverItem(D2UnitStrc* pItem, wchar_t* pBuffer, int nSize)

D2Client.0x6FADD360 handles item names only; D2Client.0x6FB297F0 works for everything but players and vistiles (items always return base name). Used to resolve hovered-unit display names. | D2Client.0x6FADD360 is purely for item names, D2Client.0x6FB297F0 works for everything but players and vistiles

OOG (out-of-game) menu draw/input entry points (1.13c): MENUS_DrawRegisteredControls (D2Win.#10024), INPUT_HandleMenuMouseInput (0x180F0), INPUT_HandleMenuKeyDownInput (0x182A0), INPUT_HandleMenuKeyCharInput (0x18370). | Function: MENUS_DrawRegisteredControls Address: D2Win.#10024 ... INPUT_HandleMenuMouseInput D2Win.0x180F0

INTERFACE_StatScreenClickDown (D2Client.0x31290) and INTERFACE_StatScreenClickUp (0x31470), both void __stdcall(D2WinMsgStrc*). Handle input on the character/stat side panel. | Function: INTERFACE_StatScreenClickDown Adress: D2Client.0x31290 ... INTERFACE_StatScreenClickUp Adress: D2Client.0x31470

1.13c inventory-panel left-button handlers, __stdcall taking D2WinMsgStrc*. (1.10 equivalents: down 0x46E60, up 0x48140, InteractClickItem 0x475C0.) | D2FUNC(D2CLIENT, INTERFACE_InventoryLButtonDown, ... 0x98DC0) ... INTERFACE_InventoryLButtonUP ... 0x9C630)

BYTE __stdcall taking D2RoomStrc*; returns the level id for a room. Pair with UNITS_GetRoom to get the level a unit is standing in. | //D2Common.0x6FD8C7A0 (#10057) BYTE __stdcall DUNGEON_GetLevelIdFromRoom(D2RoomStrc* pRoom)

D2RoomStrc* __stdcall taking D2UnitStrc*; returns the room a unit occupies. | //D2Common.0x6FDBE270 (#10342) D2RoomStrc* __stdcall UNITS_GetRoom(D2UnitStrc* pUnit)

D2ActiveRoomStrc* getter at a target X/Y within a unit's room; DUNGEON_IsRoomInTown tests town membership. | D2ActiveRoomStrc* pRoom = D2GAME_GetRoom_6FC52070(UNITS_GetRoom(pUnit), nTargetX, nTargetY);

CharmZone technique: rewrite of D2Common.#10840 requirement check restricting charms to an inventory sub-rectangle. Returns TRUE only if item is a charm, unit-type UNIT_ITEM, node page NODEPAGE_STORAGE, and pStaticPath->nYPos >= 6 and reqs met. Hooked from both D2Common (0x5FE70) and D2Client (0x4118B). | { D2DLL_D2COMMON, 0x5FE70, (DWORD)PATCH_JMP, FALSE, 0x01 }, { D2DLL_D2COMMON, 0x5FE71, (DWORD)D2Common_CharmRequirements, TRUE, 0x00 }, { D2DLL_D2CLIE

NewAutomapCell returns pCell; +0x04 nCellNo determines the graphic drawn in the automap cell (asks re lookup table) | pCell(returned by NewAutomapCell)->nCellNo(offset +0x04) is what determines what is drawn in the cell

Automap cell drawing routine | See AUTOMAP_DrawCells 1.10f:0x6FACE230

Sets phase of a storm: phase 0 no rain, 1 wind-up, 2 rain, 3 wind-down; contains act5 level-id switch feeding snow/weather globals | D2Client.0x6FAA6D40 ... sets the phase of a storm (with phase 2 being the rain phase

Act palette load: D2Client sets act palette via D2Win.#10177 PAL_LoadActData(nActPalette) which calls D2Win.0x6F8AE5E0 with pl2/dat pair; to swap palettes load tile palette each frame, then reload units palette AFTER all tiles rendered (optional 3rd call for UI) | load the tile palette each frame ... make a second call ... just after all tiles have been rendered to load the units palette (and UI

Draws HP bar for spirits, vines and golems (shared); monID check inside failed for user | its offset is 6FADB5F0. But it draws hp bar for spirits, vines and golems

Exp-bar popup init: hit-test uses gnScreenWidth/2-0x92..-0x17 and *D2CLIENT_ScreenHeight-0x2b..-0x22, calls WIN_HoverText; waypoint text via WIN_DrawNormalText(text,x,y,color,transTbl) at 0x6fb2610a | Init here D2Client.0x6faffd58 ... gnScreenWidth / 2 + -0x92 <= nMouseXPos ... WIN_DrawNormalText

Unit palette assignment: 0x6FB27A23 begins it, 0x6FB5BFC0 writes palette index into unit draw data; bosses/champions roll random PL2 shift from unit GUID (source of random color shifts) | D2Client.6FB27A23 is the start of the unit palette assignment (D2Client.0x6FB5BFC0 sets the palette index in the units draw data) for monsters

which side panel(s) open: 0=none,1/2/3=side/both; drives the L/R world-view shift; == nScreenPanels passed to the driver tile-draw fns

offX: 0 with no panel, +/-DispW/4 (=320) with one; the native left-shift the mod KEEPS

*[this] = the render ctx (ONE struct): draw-window +0x04(L)/+0x08(T)/+0x0C(R)/+0x10(B), scroll +0x24/+0x28, dirty +0x00, visited-room grid +0xEA9C

DispW=1280 (SGD2FreeRes). +4=height, +8=w-copy, +0xC=centerX, +0x10=centerY

per-panel open flags: inventory +4, char +8, skill +0x10, waypoint +0x50

*[this] = the active video-driver dispatch struct (= D2Glide's 0x6F8649F0); slot +0x9c = the cel handler D2Client #10001 invokes

driver DisplayWidth; SGD2FreeRes rewrites 800->1280 at RVA 0xDCF1 at runtime; the -/4 math survives -> 960

driver DisplayHeight; stock 600, SGD2->720

[this]+4 / [this] gate the worker 0x7080: both-nonzero -> DEAD software drawer 0x6290; else -> LIVE drawer 0x6840

the driver vtable D2gfx installs at [0x6FA91268]; +0x9c=0x6F8572F0 (cel handler)

D2Glide IAT slot for glide3x!grDrawVertexArrayContiguous@16 (into D2DX). 0x6F856032 = jmp [this]. THE D2Glide->D2DX crossing; hook target for the pipeline-trace probe

Horizontal screen shift (viewport pan offset). Named exactly in FOCUS. | src: D2Client.dll ScreenShiftX Offset 0x11B9A0

Vertical screen shift (viewport pan offset). Named exactly in FOCUS. | src: D2Client.dll ScreenShiftY Offset 0x11B9A4

General display height. Named exactly in FOCUS. | src: D2Client.dll GeneralDisplayHeight Offset 0xDBC4C

Automap open flag. | src: D2Client.dll IsAutomapOpen Offset 0xFADA8

Game menu open flag. | src: D2Client.dll IsGameMenuOpen Offset 0xFADA4

Help screen open flag. | src: D2Client.dll IsHelpScreenOpen Offset 0xFAE04

Inventory arrange mode (UI panel layout state). | src: D2Client.dll InventoryArrangeMode Offset 0x11B99C

New-skill button pressed flag (UI element state). | src: D2Client.dll IsNewSkillButtonPressed Offset 0x11C30C

New-stats button pressed flag (UI element state). | src: D2Client.dll IsNewStatsButtonPressed Offset 0x11C308

In-game mouse cursor X (screen coordinate). | src: D2Client.dll IngameMousePositionX Offset 0x11B828

In-game mouse cursor Y (screen coordinate). | src: D2Client.dll IngameMousePositionY Offset 0x11B824

Render resolution mode selector. Comment gives enum values. | src: D2GFX.dll ResolutionMode Offset 0x11260 0 = 640x480, 1 = Main Menu, 2 = 800x600, 3 = 1344x700

Active video/render backend selector. Comment gives enum values. | src: D2GFX.dll VideoMode Offset 0x11258 1 = GDI, 2 = Software, 3 = DirectDraw, 4 = Glide, 5 = OpenGL, 6 = Direct3D, 7 = Rave

Windowed vs fullscreen flag. | src: D2GFX.dll IsWindowedMode Offset 0x1125C

HWND of the render window. | src: D2GFX.dll WindowHandle Offset 0x11264 gtGfxSystem.hWnd

DirectDraw backend display width. | src: D2DDraw.dll DisplayWidth Offset 0x101D4

DirectDraw backend display height. | src: D2DDraw.dll DisplayHeight Offset 0x101CC

DirectDraw bit-block (blit) width. | src: D2DDraw.dll BitBlockWidth Offset 0x101C8

DirectDraw bit-block (blit) height. | src: D2DDraw.dll BitBlockHeight Offset 0x101D8

DirectDraw CEL display left bound. | src: D2DDraw.dll CelDisplayLeft Offset 0x101E8

DirectDraw CEL display right bound. | src: D2DDraw.dll CelDisplayRight Offset 0x101EC

GDI backend bit-block (blit) width. | src: D2GDI.dll BitBlockWidth Offset 0xCA80

GDI backend bit-block (blit) height. | src: D2GDI.dll BitBlockHeight Offset 0xCA90

GDI CEL display left bound. | src: D2GDI.dll CelDisplayLeft Offset 0xCA98

GDI CEL display right bound. | src: D2GDI.dll CelDisplayRight Offset 0xCA9C

Direct3D backend display width. | src: D2Direct3D.dll DisplayWidth Offset 0x1AB44

Direct3D backend display height. | src: D2Direct3D.dll DisplayHeight Offset 0x1AFD4

Main-menu mouse cursor X (screen coordinate). | src: D2Win.dll MainMenuMousePositionX Offset 0x21488

Main-menu mouse cursor Y (screen coordinate). | src: D2Win.dll MainMenuMousePositionY Offset 0x2148C

Memory location storing the game's logic height. Written directly as DWORD constant in the 0x10E29 block. | src: C7 05 4CBCB86F 58020000 mov [D2client.dll+0xDBC4C], 00000258 ; 600 height logic

Memory storing X-offset positioning of UI panels. 640x480 -> 0; 800x600 -> 0x50 (80); 1066x600 -> 0xD5 (213). Written via 89 1D A0B9BC6F (reg) or C7 05 A0B9BC6F (const). | src: stores the x-offset positioning of panels; 1066x600 value 000000D5 (213)

Memory storing Y-offset positioning of UI panels. 640x480 -> 0; 800x600 AND 1066x600 -> 0xFFFFFFC4 (-60). Because 1066x600 shares 800x600's height (600), the y-offset code for 800x600 is reused. | src: stores the y-offset positioning of panels; value FFFFFFC4 (-60)

Original 800x600 border-frame DC6 path used when IsUseOriginalScreenBorderFrame() is true. | src: constexpr std::string_view kOriginalScreenBorderFrameImagePath = "data\\global\\UI\\Panel\\800BorderFrame";

Per-version glide3x.dll return-address constants identifying floor/wall draws. Index order: [1]=DrawWall1,[2]=DrawWall2,[3]=DrawFloor. | src: 113c: 0x6f8567ab DrawWall1, 0x6f8567b9 DrawWall2, 0x6f85befc DrawFloor | 114d: 0x50d39f DrawWall1, 0x50d3ae DrawWall2, 0x50db03 DrawFloor | 109d: 0x6f818468/0x6f818476/0x6f813e2f

=16383. UI surfaceId; MoP loop skips batches whose start vertex has this surfaceId (UI never shifts, world geometry incl. floor/wall does).

Head of the UI Control linked list. UI, borderline render. | src: VARPTR(D2WIN, FirstControl, Control*, 0x214A0)

Currently focused UI Control. | src: VARPTR(D2WIN, FocusedControl, Control*, 0x214B0)

Current viewport height in pixels. | src: VARPTR(D2CLIENT, ScreenSizeY, DWORD, 0xDBC4C)

Screen X of the hovered cell/cursor target. | src: VARPTR(D2CLIENT, CursorHoverX, DWORD, 0xE0EB8)

Screen Y of the hovered cell/cursor target. | src: VARPTR(D2CLIENT, CursorHoverY, DWORD, 0xE0EBC)

Current mouse cursor X in screen pixels. | src: VARPTR(D2CLIENT, MouseX, DWORD, 0x11B828)

Current mouse cursor Y in screen pixels. | src: VARPTR(D2CLIENT, MouseY, DWORD, 0x11B824)

Viewport/gamewindow X extent (int). Used with ViewportY for world->screen shift. | src: VARPTR(D2CLIENT, ViewportX, int, 0x119960)

Viewport/gamewindow Y extent (int). | src: VARPTR(D2CLIENT, ViewportY, int, 0x11995C)

Nonzero when the automap is displayed. | src: VARPTR(D2CLIENT, AutomapOn, DWORD, 0xFADA8)

Automap display mode (full/mini/etc). | src: VARPTR(D2CLIENT, AutomapMode, int, 0xF16B0)

POINT screen offset applied when drawing (render/scroll origin). Coordinate-shift global. | src: VARPTR(D2CLIENT, Offset, POINT, 0x11C1F8)

Pointer to the active AutomapLayer being drawn. | src: VARPTR(D2CLIENT, AutomapLayer, AutomapLayer*, 0x11C1C4)

Screen height global (DWORD). | src: VARPTR(D2CLIENT, ScreenSizeY, DWORD, 0xDBC4C, 0xF7038)

Cursor hover X coordinate (DWORD). | src: VARPTR(D2CLIENT, CursorHoverX, DWORD, 0xE0EB8, 0xEE4AC)

Cursor hover Y coordinate (DWORD). | src: VARPTR(D2CLIENT, CursorHoverY, DWORD, 0xE0EBC, 0xEE4B0)

Mouse X screen position (DWORD). | src: VARPTR(D2CLIENT, MouseX, DWORD, 0x11B828, 0x11C950)

Mouse Y screen position (DWORD). | src: VARPTR(D2CLIENT, MouseY, DWORD, 0x11B824, 0x11C94C)

Mouse offset X (int) — screen-to-world/viewport offset. | src: VARPTR(D2CLIENT, MouseOffsetX, int, 0x119960, 0x106844)

Mouse offset Y (int) — screen-to-world/viewport offset. | src: VARPTR(D2CLIENT, MouseOffsetY, int, 0x11995C, 0x106840)

Screen render Offset (POINT struct) — the world-to-screen scroll/camera offset used when drawing units and automap. | src: VARPTR(D2CLIENT, Offset, POINT, 0x11C1F8, 0x11CF5C)

Panel offset X (int) — horizontal shift applied when side panels (inventory/skill) are open. Directly relevant to viewport shift. | src: VARPTR(D2CLIENT, PanelOffsetX, int, 0x11B9A0, 0x11D354)

Screen-shake X offset (int) applied to render position. | src: VARPTR(D2CLIENT, xShake, int, 0x11BF00, 0x11CA6C)

Screen-shake Y offset (int) applied to render position. | src: VARPTR(D2CLIENT, yShake, int, 0x10B9DC, 0xFC3DC)

Automap-visible flag (DWORD). | src: VARPTR(D2CLIENT, AutomapOn, DWORD, 0xFADA8, 0x11C8B8)