Texture Converter: Resizer, Packer & Replacer

As a solo developer, I originally built the Texture Converter to solve a recurring headache: managing the massive file footprints and VRAM bloat that happens when you construct environments using modular kits and third-party asset packs.

While optimization discussions usually focus heavily on polygon counts and active draw calls, an unmanaged VRAM footprint will often choke your target hardware long before geometry becomes the bottleneck. Dropping a beautiful kitbash pack into your project frequently introduces dozens of heavy 4K textures assigned to minor background debris, fragmented PBR data maps that require multiple texture samplers, and a tangled mess of dependencies.

This free, pipeline-agnostic toolkit provides multithreaded and GPU-accelerated tools to batch-resize oversized maps, standardize file formats, mathematically pack distinct color channels into unified master textures, and physically rewrite your project's data files to consolidate those newly optimized dependencies without breaking your scene references.

Core Workflows & Capabilities

The toolkit is divided into two primary modules:

1. The Batch Resizer & Converter

This module processes large queues of source textures to universally resize them, pad them to standard Power-of-Two dimensions, and enforce uniform import configurations across varying asset tiers.

• Constraint-Based Sizing: Scale textures down via a literal percentage, or use a "Target Longest Edge" clamp. If you input a 4096x2048 texture and set the clamp target to 1024, the engine scales it to 1024x512, perfectly preserving the aspect ratio. The pipeline also automatically rounds dynamic constraints to the nearest multiple of 4 to ensure flawless compatibility with GPU block compression formats (ASTC/BCn/DXT).
• Format & Color Space Control: Output directly to standard compressed .png or fast-lookup .tga formats. You can also explicitly override the output color space (Force Linear for data maps, Force sRGB for visual maps) to correct badly imported asset packs.
• POT Padding & Alignment: Mobile platforms and GPU compression formats require square Power-of-Two (POT) dimensions. The tool mathematically expands irregular canvases to square POT boundaries. You can define specific flush-edge alignments (Top, Bottom, Left, Right) to anchor pixel data during padding, preventing UV offset errors on UI sprites or trim sheets.
• HDR to LDR Conversion: Toggling LDR conversion forces the engine to push heavy 32-bit floating-point data down into standard 8-bit files, saving massive amounts of memory on simple masks that don't need .exr precision.
• Automated Reference Replacement: Instead of manually digging through hundreds of materials to assign your optimized textures, you can run the batch in the destructive "Replace Project References" mode. The tool utilizes asynchronous I/O to read the raw text of your project's serialized files, finds the unique 32-character GUID of your old heavy asset, dynamically injects the new optimized GUID globally across your project, and safely moves your originals into a backup folder.

2. The GPU PBR Channel Packer

Assigning a distinct grayscale texture to Metallic, Ambient Occlusion, and Roughness slots forces the shader to use multiple texture samplers, eating up VRAM. The PBR Packer extracts data from up to four separate images and injects them into the distinct Red, Green, Blue, and Alpha channels of a single master texture natively on your graphics card.

• Auto-Assign & Workflow Presets: Drag a handful of textures into the Source Pool and hit "Auto-Assign"—the tool parses common file suffixes (_orm, _ao, _metallic, etc.) and routes them to the correct channels automatically. You can also click 1-button presets to perfectly configure the layout for URP or HDRP mask maps.
• Constants for Missing Maps: If an asset is missing a specific map (e.g., it has AO and Roughness, but no Metallic map), you do not need to open Photoshop to build a blank texture. Set that channel to "Constant" and inject a hard float value directly into the packed image.
• Live Preview: Visually inspect the mathematical results before saving. The preview pane lets you toggle between the combined RGBA output, or isolate the individual R, G, B, and A channels to verify your routing and inversion toggles.
• Resolution Scaling: The GPU compute shader seamlessly handles source inputs of differing resolutions (e.g., smoothly packing a 2048x2048 AO map alongside a 512x512 Roughness map) by scaling them dynamically via hardware-accelerated bilinear sampling.

Realistic Expectations & Hard Limits

This is a pragmatic utility, and it operates within strict mechanical boundaries to prevent Editor crashes. Before executing any batches, please review these technical constraints:

• Strict Serialization Requirement: The dependency-rewiring feature (the "Replace Project References" mode) bypasses standard Unity APIs. Instead, it asynchronously reads and modifies the raw text of your project files. Because of this, your project must be set to "Force Text" serialization (Edit > Project Settings > Editor > Asset Serialization > Mode). If your project uses Binary or Mixed serialization, the execution UI will physically lock you out to prevent file corruption.
• Destructive Operations: The replacement mode is intentionally destructive. When executed, the engine permanently alters your Materials, Prefabs, and Scene files on your hard drive to point to the new textures. These operations cannot be cleanly undone using Unity's standard Ctrl+Z system. Do not execute these specific functions unless your project is actively backed up or managed via Version Control (Git, PlasticSCM, Perforce, etc.).
• Queue Limits & Memory Management: Loading raw pixel arrays into active memory is heavy. To prevent Unity from crashing due to Out-Of-Memory (OOM) errors, the batch resizer is strictly capped at processing a maximum of 300 textures per run. The tool also utilizes a "Memory Flush Interval" that intentionally pauses processing every few dozen textures to force deep Garbage Collection and clear RAM.
• Aspect Ratio Constraints: The GPU PBR Packer can smoothly pack textures of different resolutions, but all inputs must share the exact same aspect ratio. You cannot pack a 1:1 square texture with a 2:1 rectangular texture without causing irreparable UV distortion.
• Immutable Unity Packages: Assets residing within standard Unity Packages (the Packages/ directory) are treated as read-only by the engine. The tool cannot destructively modify these files and will safely skip them during replacement batches.

Expand Your Pipeline & Support

The Texture Converter targets the first major bottleneck in environment design: heavy files and fragmented samplers. Standardizing your VRAM footprint is step one. If you want to get the maximum performance out of Unity, consider pairing this with the rest of the Veridian optimization pipeline:

• Step 1: Texture Converter (This Asset) – Resizes, pads, and mechanically packs fragmented textures.
• Step 2: Materials Combinator – Takes your newly standardized textures, algorithmically atlases their maps together, and rewrites the underlying mesh UVs so dozens of unique props can share a single material draw-call.
• Step 3: Mesh Constructor – Takes your atlased prefabs and physically welds their geometry together into a unified static mesh, eliminating the remaining CPU transform-hierarchy overhead.
• Step 4: BurstLOD – Generates incredibly fast, high-quality runtime or Editor-based LODs for your welded geometry.
• Terrain Slicer (FREE) – Divide massive, monolithic Unity landscapes into streamable chunks to manage open-world memory.

As a solo developer, building and maintaining these utilities takes a significant amount of time. If this toolkit speeds up your workflow and helps you hit your frame rate targets, please consider leaving a rating or review on the Asset Store. Reviews are the primary way tools gain visibility and directly support my ability to keep updating them.