DeltaRepack

GameMaker Texture Repacking Tool
Room-aware Texture Page optimization developed for DeltaruneVita.

--- # DeltaRepack **DeltaRepack** rebuilds the Texture Page layout inside GameMaker `data.win` files to reduce the amount of texture memory that must be resident at the same time. It was developed for **DeltaruneVita**, where large GameMaker atlases can be expensive on the PlayStation Vita even when a Room only uses a small portion of them. ```text Before Few large atlases ↓ Rooms load unrelated texture data ↓ Higher working-set VRAM After More granular atlases ↓ Rooms load smaller, relevant texture sets ↓ Lower working-set VRAM ``` > DeltaRepack does not include or distribute Deltarune game files. You must provide your own `data.win`. ## Features - Global Texture Page Item repacking - Room-aware texture usage analysis - VRAM regression checks per Room - Atlas sizes from `64x64` to `2048x2048` - TextureGroup-safe reconstruction - Conservative handling of resources without known Room usage - Fast packing for large clusters - Raw source-pixel cropping - Post-save reload and verification - Recursive batch processing - Original input preservation - Reproducible Vita-specific GML optimizations - Semantic Room/resource detection instead of hardcoded IDs ## Why repack the `data.win`? GameMaker may place unrelated resources in the same large Texture Page. ```text Room uses one sprite ↓ Sprite belongs to a 2048x2048 atlas ↓ The entire atlas becomes resident ``` DeltaRepack changes the layout itself so texture residency becomes more granular. The goal is **not** to minimize the number of Texture Pages. An optimized build can contain more pages while still requiring much less memory per Room: ```text Original fewer pages + larger atlases + more unrelated content loaded together Repacked more pages + smaller atlases + more specific residency + lower working set ``` ## Project structure ```text DeltaRepack/ ├─ assets/ │ ├─ icon.png │ ├─ logo_black.png │ └─ logo_white.png ├─ chapters/ ├─ rebuild/ ├─ source/ ├─ CHANGELOG_v1_6.md └─ rebuild_data_win_v1_6.bat ``` ### `chapters/` Place the source `data.win` files here. ```text chapters/ ├─ 1/ │ └─ data.win ├─ 2/ │ └─ data.win ├─ 3/ │ └─ data.win ├─ 4/ │ └─ data.win └─ 5/ └─ data.win ``` Nested variants are supported as well: ```text chapters/ ├─ Original/ │ └─ chapter2/ │ └─ data.win ├─ PTBR/ │ └─ chapter2/ │ └─ data.win └─ Spanish/ └─ chapter2/ └─ data.win ``` Their relative folder structure is preserved in `rebuild/`. ### `rebuild/` Generated files are written here. Files under `chapters/` are not modified in place. ### `source/` Contains the rebuild scripts and required tooling. ### `assets/` Repository branding and documentation assets. ## Usage Run: ```text rebuild_data_win_v1_6.bat ``` You can process a single discovered folder or enter: ```text A ``` to recursively analyze and rebuild all `data.win` files found under `chapters/`. Batch mode uses a single confirmation. If one item fails, processing stops at that item, previously completed outputs are preserved, and a report is generated at: ```text rebuild/batch_rebuild_report.txt ``` ## Repack pipeline ```text data.win ↓ Analyze Texture Pages / TPIs ↓ Map known Room usage ↓ Build repack clusters ↓ Pack into new atlas sizes ↓ TextureGroup safety checks ↓ Room VRAM regression gate ↓ Rebuild Texture Pages ↓ Reload and verify ↓ Apply approved Vita GML optimizations ↓ optimized data.win ``` ## Room-aware VRAM gate DeltaRepack evaluates proposed atlas replacements against the Texture Pages actually required by known Rooms. If a change would make a Room more expensive, the optimization can be rejected instead of silently introducing a regression. ### v1.6 TextureGroup Room-aware gate v1.6 improves validation for mixed TextureGroup atlases. Previously, a conservative split could charge every replacement group to a Room: ```text Room uses mixed atlas ↓ split G005 + G006 ↓ Room charged G005 + G006 ``` Now DeltaRepack intersects the Room's actual texture items with the TPIs inside that atlas: ```text Room.texture_items ∩ atlas TPIs ↓ TextureGroups actually required ↓ charge only relevant replacements ``` If the RAW analysis cannot safely explain the atlas usage, the tool automatically falls back to the previous conservative behavior. ## TextureGroup safety TextureGroups are preserved during reconstruction. If a proposed optimized atlas would incorrectly mix incompatible groups, it is split before the final output is accepted. ## Unknown Room usage Static analysis cannot discover every possible runtime texture reference. Dynamic GML and indirect resource access mean: ```text "No known Room" does not mean "unused" ``` DeltaRepack preserves and handles these resources conservatively. ## Raw texture reconstruction Atlas pages are rebuilt from the original source pixels. For each TPI, DeltaRepack crops its original source rectangle and places those pixels into the new atlas. The repack changes placement information such as: ```text TexturePage SourceX SourceY ``` while preserving the TPI's dimensions and target/bounding data. This avoids scaling or re-rendering assets during reconstruction. ## Fast packing Large clusters use the fast packing path introduced in v1.5 to keep high-item-count rebuilds practical. v1.6 retains this optimization together with: - path-safe processing - TextureGroup safety - VRAM gate - RAW CROP - reload/verify - original-file preservation ## Reproducible Vita GML optimizations After atlas reconstruction, DeltaRepack can apply approved GameMaker-side optimizations through: ```text source/apply_vita_gml_optimizations.csx ``` These patches are detected semantically through Room/resource/code names rather than numeric resource IDs, making them more suitable for Original and translated `data.win` variants. Current examples include: ### Chapter 2 — Cyber Rollercoaster ```text room_dw_cyber_rollercoaster ``` Limits `scr_draw_sprite_tiled_area` to the active camera region to avoid drawing distant tiled content unnecessarily. ### Chapter 3 — Circle Zoom ```text obj_circlezoom ``` Reduces the intermediate surface from `640x480` / Room size to `320x240`, updates its mask at 30 Hz, and composites it back at `2x`. The surface uses 25% of the original pixel count and updates on half as many frames. After saving, the rebuilt file is reopened and the optimization pass is executed again to verify that the patches are idempotent. ## DeltaCache DeltaRepack only rebuilds the `data.win`. For DeltaruneVita, the result can then be passed to **DeltaCache**, which generates the external runtime texture caches: ```text DeltaRepack ↓ optimized data.win ↓ DeltaCache ↓ .r444 + .bc3.pvr ``` Always generate caches from the exact rebuilt `data.win` they will be used with. ## Requirements - Windows - Python - UndertaleModTool / UndertaleModCLI - scripts and dependencies under `source/` Do not redistribute third-party binaries unless their licenses allow it. ## Game files This repository must **not** contain: - original `data.win` files - extracted commercial Deltarune assets - redistributed game content Users must provide their own files from a legitimate installation. ## Current version ```text DeltaRepack v1.6 ``` Main v1.6 changes: - Room-aware TextureGroup validation - reduced false-positive VRAM regressions - conservative fallback when RAW usage cannot be resolved - large-cluster fast packing retained - TextureGroup-safe rebuild - RAW CROP - reload/verify - original preservation ## Related project DeltaRepack was created as part of the optimization work behind **DeltaruneVita**, focusing on adapting GameMaker texture residency to the memory constraints of the PlayStation Vita. ## Disclaimer Deltarune, GameMaker and PlayStation Vita are properties of their respective owners. DeltaRepack is a community-developed tool and is not affiliated with or endorsed by those companies or rights holders.