F Texture Tools

About F Texture Tools – Unity Editor Tool & Plugin

F Texture Tools Unity Asset Overview

As a senior Unity developer who has spent years shipping titles across mobile and PC platforms, context-switching between Unity and external image editors like Photoshop or Substance Designer is one of the biggest bottlenecks in content pipelines. Every time an environment artist needs to invert a glossiness map into a smoothness map, adjust channel packing, or bake quick normal maps from diffuse textures, precious iteration time is wasted.

F Texture Tools addresses this workflow friction head-on. Designed as a native Editor extension powered by GPU compute shaders and optional AI utilities, it brings deep texture manipulation, channel packing, map generation, and automated batch processing straight into your Unity workspace. Rather than acting as a simple visual wrapper over Unity's built-in TextureImporter, the asset operates on low-level pixel data via compute passes, making high-resolution operations blazingly fast even when working with 4K or 8K source assets.

Core Technical Features & Highlights

1. Multi-Channel Texture Packing Engine

Modern render pipelines like URP and HDRP rely heavily on channel-packed textures (for instance, combining Metallic, Ambient Occlusion, Detail Mask, and Smoothness into a single RGBA map). F Texture Tools features an intuitive channel matrix UI that allows you to route any channel from any source texture into target output channels (R, G, B, A). It handles color space conversions (Linear to sRGB) on the fly, preventing subtle visual bugs when packing PBR data.

2. GPU Compute-Accelerated Map Generators

Instead of relying on slow CPU loops to process pixels, the asset utilizes custom compute shaders for generating standard texture maps. In my testing, creating normal maps using Sobel filter variations or calculating specular maps from raw Albedo runs in real-time. Key procedural capabilities include:

• Sobel Normal Map Baking: Extract sharp or smooth normal details from diffuse/albedo maps with real-time intensity control.
• Height & Ambient Occlusion Generation: Estimate surface depth maps straight from height variations.
• Seamless Tiling Utilities: Automatically offset and blend texture borders to eradicate visible repeating seams across large terrain meshes.

3. AI-Assisted Texture Utilities

The included AI module assists with intelligent noise removal, detail enhancement, and upscaling low-resolution textures. It is particularly helpful when working with legacy project assets or fast grey-box prototyping where high-resolution source graphics are not yet available.

4. Batch Operations & Import Overrides

Managing asset sizes across target platforms can turn into a maintenance nightmare. With this asset's batch engine, you can multi-select hundreds of textures and apply global compression changes (such as enforcing ASTC_6x6 for mobile or BC7 for desktop), set max resolution limits, and strip unneeded alpha channels to save memory overhead.

Ideal Use Cases & Game Genres

• Mobile Racing & Action Games: Crucial for packing extra surface data into minimal textures, reducing texture sampler counts in custom URP shaders, and keeping draw calls low.
• Indie RPGs & Modular Environment Design: Accelerates terrain and prop workflows by allowing artists to generate normal and AO maps directly inside Unity during level assembly.
• Stylized & Hyper-Casual Projects: Perfect for rapid color-palette swaps, texture atlas creation, and noise reduction across low-poly asset packs.
• VR & Standalone Hardware Optimizations: Allows tight control over runtime memory footprints by eliminating redundant channels and forcing linear compression flags on non-color data maps.

Quick-Start Unity Setup & Integration Guide

Integrating F Texture Tools into an active Unity project is straightforward. Once imported, the tool adds a main control window under Tools > F Texture Tools.

Custom Editor Pipeline Automation

Beyond the editor UI, you can call the tool's core processing classes programmatically within custom build scripts or asset import pipelines. Here is an example of an editor script automating texture packing for PBR materials:

using UnityEngine;
using UnityEditor;
using FTextureTools; // Ensure namespace is referenced

public class AutomatedPackingUtility : EditorWindow
{
    private Texture2D metallicMap;
    private Texture2D aoMap;
    private Texture2D smoothnessMap;

    [MenuItem("Tools/Custom/Batch Pack PBR Texture")]
    public static void ShowWindow()
    {
        GetWindow<AutomatedPackingUtility>("PBR Packer");
    }

    private void OnGUI()
    {
        GUILayout.Label("Assign Channel Textures", EditorStyles.boldLabel);
        metallicMap = (Texture2D)EditorGUILayout.ObjectField("Metallic (Red)", metallicMap, typeof(Texture2D), false);
        aoMap = (Texture2D)EditorGUILayout.ObjectField("AO (Green)", aoMap, typeof(Texture2D), false);
        smoothnessMap = (Texture2D)EditorGUILayout.ObjectField("Smoothness (Alpha)", smoothnessMap, typeof(Texture2D), false);

        if (GUILayout.Button("Pack Texture (RGBA)"))
        {
            PackChannels();
        }
    }

    private void PackChannels()
    {
        if (metallicMap == null || smoothnessMap == null)
        {
            Debug.LogWarning("Please assign required textures before packing.");
            return;
        }

        // Initialize F Texture Tools processing engine
        TexturePackerEngine engine = new TexturePackerEngine();
        
        // Map Red -> Metallic R, Green -> AO G, Alpha -> Smoothness Alpha
        engine.SetChannelSource(TextureChannel.Red, metallicMap, TextureChannel.Red);
        engine.SetChannelSource(TextureChannel.Green, aoMap != null ? aoMap : metallicMap, TextureChannel.Green);
        engine.SetChannelSource(TextureChannel.Alpha, smoothnessMap, TextureChannel.Red);

        Texture2D result = engine.GeneratePackedTexture(1024, 1024, TextureFormat.RGBA32, true);
        
        byte[] bytes = result.EncodeToPNG();
        string outputPath = "Assets/Textures/Packed_PBR_Custom.png";
        System.IO.File.WriteAllBytes(outputPath, bytes);
        
        AssetDatabase.Refresh();
        Debug.Log("Successfully packed texture to: " + outputPath);
    }
}

Pros & Cons Assessment

Pros

• Massive Time Saver: Removes the friction of opening external graphics software for quick texture adjustments and channel packing.
• Native GPU Performance: Uses compute shaders to handle large textures instantly without freezing the Unity Editor UI thread.
• Broad Pipeline Compatibility: Works seamlessly across Built-in, Universal Render Pipeline (URP), and High Definition Render Pipeline (HDRP).
• Clean Code Architecture: Well-structured C# scripts allow developers to hook texture processing routines directly into custom AssetPostprocessor scripts.

Cons

• Learning Curve for Channel Color Spaces: Less experienced developers must pay close attention to Linear vs sRGB settings when packing maps to avoid metallic map rendering artifacts.
• Editor Memory Usage: Heavy batch processing of multiple 4K raw textures can spike RAM usage temporarily if textures aren't flushed properly from memory.

Developers Who Downloaded This Also Downloaded

Related Unity Tools Assets