Optimize your VRAM footprint. This toolkit batch-resizes heavy textures, mathematically packs PBR channels on the GPU, and automatically rewires project dependencies via raw YAML injection.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 & CapabilitiesThe toolkit is divided into two primary modules:1. The Batch Resizer & ConverterThis 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 PackerAssigning 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 LimitsThis 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 & SupportThe 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.I built the Texture Converter to bypass Unity’s standard synchronous CPU bottlenecks while aggressively managing RAM to prevent the Editor from crashing during massive batches. Here is exactly how the engine operates:Requirements & CompatibilityMinimum Unity Version: Unity 6 or newer.Render Pipelines: Fully pipeline agnostic. The texture data generation and dependency rewiring mechanics are universally compatible with the Universal Render Pipeline (URP), High Definition Render Pipeline (HDRP), and the Built-in Render Pipeline.Native Dependencies: Relies strictly on standard Unity packages (Unity.Burst, Unity.Collections, Unity.Mathematics) which are included natively in modern engine versions. There are no external third-party DLLs to worry about.Core Processing Architecture & Memory ManagementAsynchronous GPU Compute & Readback: Standard texture scaling via Texture2D.GetPixels() runs synchronously on the main thread. If you try to process fifty 4K textures this way, Unity will completely lock up. The Converter Engine avoids this entirely. Pixel data is pushed directly to your graphics card via custom TextureResizer and CSChannelPack Compute Shaders. It then uses AsyncGPUReadback and C# async/await Task models to pull the pixels back into memory asynchronously, keeping your Editor interface fully responsive.Burst-Compiled Padding Math: When canvas expansion or POT padding is required, the spatial layout calculations are handed directly to the C# Job System. The PadTextureJob utilizes NativeArrays and the Burst compiler to calculate pixel coordinate offsets concurrently across multiple CPU threads.Active RAM Flushing: Uncompressed pixel arrays rapidly consume system RAM. To prevent Out-Of-Memory (OOM) crashes, the tool enforces a strict 300-texture maximum queue limit. Furthermore, it utilizes a configurable "Memory Flush Interval." Every 50 textures (by default), the pipeline intentionally halts execution, forces a deep C# Garbage Collection cycle, and triggers Resources.UnloadUnusedAssets() to prune the RAM cache before safely continuing.Block Compression Sizing: Modern GPU compression formats (ASTC, BCn, DXT) require texture dimensions to conform to specific block boundaries (multiples of 4). If a dynamic sizing constraint evaluates to an irregular number, the pipeline automatically rounds the output dimension to the nearest multiple of 4 to guarantee flawless compression compatibility on disk.Import Settings Hijacking: To execute mathematical alterations on the GPU, the engine requires low-level, uncompressed memory access. The tool dynamically pre-processes input batches by backing up your texture import settings, temporarily forcing Read/Write access to true, and disabling compression. It meticulously restores your original optimized states once the file is written to disk.Normal Map Vector Protection: During padding and packing operations, the engine specifically protects the background space of Normal maps. Instead of padding with absolute black (0, 0, 0)—which breaks tangent math and creates rendering artifacts in the shader—blank space is mechanically filled with a neutral flat-normal vector of (0.5, 0.5, 1.0).Project ArchitectureAsynchronous YAML Injection: Loading thousands of Prefabs and Materials into active memory via standard AssetDatabase APIs just to replace a texture reference causes massive RAM spikes. The AssetReplacementWorker bypasses these APIs entirely. It utilizes asynchronous parallel background threads to read the raw text of your project's serialized YAML files. It takes a dictionary of old and new 32-character GUIDs and physically injects the optimized references directly at the text level, successfully rewiring thousands of dependencies across an entire project in seconds.Tail Latency Optimization: When conducting project-wide dependency scans, the worker intelligently sorts the targeted files by size (largest first). This solves the "tail-latency problem," ensuring massive files are assigned to processor cores immediately, allowing smaller files to fill in the multithreading gaps at the end of the batch, which massively speeds up disk read/write times.API Reference & Headless ExecutionDecoupled Architecture: The Editor window is strictly a UI wrapper. The underlying processing logic is housed within the Veridian.Perspective.Converter namespace, allowing technical artists and pipeline engineers to trigger the tools directly via their own C# scripts.Task-Based Asynchronous API: Developers can invoke the async ConverterWorkflowService via script to build automated pre-build processing pipelines. You can instantiate a headless ConverterSettings ScriptableObject, feed it a queue of wrapped TextureInfo objects, and run optimizations entirely in the background.Headless Compute Execution: The core ConverterEngine exposes its compute shader wrappers natively. Developers writing custom VRAM-auditing utilities can call await ConverterEngine.ResizeAsync() to scale textures efficiently on the GPU without relying on slow CPU-side arrays.Hard LimitsAs a pragmatic tool designed to keep your project safe, it operates with a few non-negotiable boundaries:Serialization Mode: The automated reference replacer strictly requires the project's Asset Serialization Mode to be set to "Force Text". If your project uses Binary or Mixed serialization, the tool will physically lock execution to prevent file corruption.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.Strict Aspect Ratios for Packing: The PBR Packer can successfully scale mismatched inputs, but they must all share the exact same aspect ratio (e.g., all 1:1 squares). You cannot pack a square with a rectangle without stretching the UVs.
