Noise Texture Generator: Procedural PBR Baker View on Asset Store (opens in new tab)

Package details

Latest version
1.0
Last updated
First released
Unity version
6000.4.5 or later
Package size
151 KB
Files
27
Favorites
11
Views in the past week
16

Price tracking

Last checked
Tracked since
Lowest recorded
$7.50 on

Keywords

Noise Texture Generator: Procedural PBR Baker

by Veridian Systems (opens in new tab)

No ratings yet

A procedural texture baker powered by the Burst Compiler. Blend Voronoi, FBM, and SDF math to algorithmically generate and bake seamlessly tiling PBR materials without leaving the Unity Editor.

Price $15.00

Buy on Asset Store (opens in new tab)

Affiliate link · Purchases support this site

Price history

Last 6 months

USD
Price history for Noise Texture Generator: Procedural PBR Baker, 6 months Current $15.00; lowest $7.50; highest $15.00 in this period. $0 $10 $20 Jul Aug Sep Oct Nov

Asset preview

1 / 22

Noise Texture Generator: Procedural PBR Baker screenshot 1

Noise Texture Generator: Procedural PBR Baker screenshot 1

About this asset

The Noise Texture Generator is a multithreaded procedural noise engine and PBR material baker built for the Unity Editor and Runtime. Rather than relying on imported images or scanned data, this tool evaluates mathematical algorithms to synthesize physical material sets from scratch. It outputs a complete suite of textures—including Albedo, Normal, Height, Ambient Occlusion, Curvature, and Roughness maps—directly within Unity.

This tool is highly practical for:

  • Generating tileable, 32-bit displacement heightmaps for massive terrains.
  • Synthesizing organic surfaces like wood grain, eroded rock, or reptilian scales.
  • Building intricate cellular structures like cobblestone, cracked ice, or pumice.
  • Baking custom-packed RGBA masks to optimize memory for specialized environment shaders.

Total Commercial Ownership

Because this engine synthesizes pixels strictly from mathematical algorithms, the resulting outputs are entirely your own. You retain 100% commercial ownership over any textures, heightmaps, or materials you generate. You are completely free to use them in your commercial projects, or even to pack and resell the exported textures as standalone assets on the Unity Asset Store.

Dual-Layer Architecture & Analytical Derivatives

At the core of the engine is a dual-layer generation system. You can establish a base structure (Layer A) and a secondary detail pass (Layer B), blending them together to create highly complex material profiles.

A major factor in the visual fidelity of these generated maps is the engine's use of analytical derivatives. Traditional procedural generators often output a flat heightmap and apply an image-based blur (like a Sobel filter) to approximate depth. Instead, this engine calculates the exact mathematical slope of the noise functions in both the X and Y directions simultaneously with the elevation.

When Layer A and Layer B are combined—whether through standard mathematical blending or Signed Distance Field (SDF) boolean operations—their analytical derivatives are accurately calculated together. Because the resulting Normal and Curvature maps are derived directly from these combined numerical slopes, the textures retain exceptionally crisp micro-details without digital artifacting or stair-stepping.

Accurate Seamless Tiling

For environments requiring repeating surfaces, seamless tiling is a core architectural feature. With a single toggle, the engine mathematically wraps its coordinate space to create tileable outputs.

This approach ensures that nearly all of the included noise algorithms and applications tile accurately across massive terrains and modular architecture. While minor mathematical approximations exist when using high-octave Fractal Brownian Motion (FBM), the system cleanly handles complex overlaps and domain warping to provide reliable, continuous patterns without relying on mirrored edges or causing texture stretching.

Deep Procedural Toolset

The generator features an extensive library of mathematical functions to shape your materials:

  • Base Algorithms: Simplex, Perlin, Value, White Noise, and Phasor (for anisotropic woven ripples).
  • Voronoi Cellular Suite: F1, F2, F2-F1, F1/F2, Edge, and Cell ID modes with customizable Euclidean, Manhattan, or Chebyshev distance metrics.
  • Fractal Brownian Motion (FBM): Stack noise frequencies using Standard, Billow, Ridged, PingPong, Swiss Erosion (thermal weathering), Flow (derivative-warped distortion), or Hybrid modes.
  • Modifiers: Alter coordinates with Directional or Radial Domain Warping, apply stepped Topographical Terracing, or use Shape Masking.
  • SDF Boolean Compositing: Combine procedural layers using standard math operations or SDF logic (Smooth Union, Subtraction, Intersection). SDF operations maintain continuous analytical derivatives even where distinct procedural shapes intersect.

Intelligent Colorization & PBR Packing

Color gradients are applied via programmatic evaluation rather than flat mapping, giving you precise control over the final material.

  • Mathematical Color Modes: Apply colors based on surface geometry. Use Topological blending to apply gradients based on slopes and cavities, Voronoi Palette for tilework with adjustable grout lines, or Banded coloring for contour lines and wood grain.
  • Custom PBR Packing: Automatically pack Metallic, AO, and Roughness data to match URP or HDRP Lit shader layouts. Alternatively, custom-route specific data buffers (Height, Curvature, Smoothness, etc.) into any exact RGBA channel to fit your own shader requirements.
  • 32-Bit Displacement Export: The tool automatically intercepts the Unity TextureImporter to force Heightmaps to export as 32-bit floating-point .exr files, ensuring no quantization data is lost.
  • Automated Material Setup: The baker dynamically queries your active render pipeline, constructs a native Lit material, assigns the generated textures, and enables the correct shader keywords automatically.

Responsive Editor Workflow

Creating procedural materials involves iteration, so the tool is built to keep feedback loops as short as possible.

  • Multithreaded Performance: Evaluates heavy mathematical operations concurrently across background CPU threads using Unity's Burst compiler, keeping your editor responsive.
  • Interactive Preview: The custom baker window features a split-screen viewport. Interactively preview the fully lit 3D material alongside isolated, real-time 2D maps before committing to a disk bake.
  • Non-Destructive Profiles: Procedural setups are saved safely as ScriptableObject profiles, making it easy to store, duplicate, version-control, and share your configurations.
  • VCS Friendly: Automatically hooks into AssetDatabase.MakeEditable() to gracefully handle checkouts for locked files on Perforce or Plastic SCM during the baking process.

35 Demo Profiles Included

Translating abstract parameters into recognizable materials takes practice. The package includes a script that automatically generates 35 pre-configured demo profiles directly into your project to serve as a starting point.

  • Nature & Organic: Sweeping Sand Dunes, Desert Badlands, Overgrown Moss, Brain Coral, Sedimentary Rock Strata.
  • Industrial: Brushed Steel, Damascus Steel, Woven Carbon Fiber, Rusty Corrugated Iron.
  • Sci-Fi & Abstract: Cyber Circuitry, Alien Tissue, Plasma Energy Shield, Biomechanical Giger Tubes.

Runtime Execution & Programmer APIs

The underlying procedural engine is decoupled from the Editor UI, offering extensive flexibility for programmers who want to integrate noise math directly into their own systems:

  • Runtime Texture Generation: Use the included RuntimeNoiseTextureGenerator component to evaluate profiles asynchronously and dynamically generate Texture2D materials in-game (ideal for loading screens).
  • Main Thread API: The engine caches Burst function pointers, allowing you to synchronously query the noise math at specific X/Z coordinates directly on the main thread with near-zero overhead. Highly useful for scattering objects (like trees or rocks) exactly on the peaks or valleys of a noise field.
  • Burst Job System API: Bypass the texturing pipeline entirely. Schedule highly optimized 2D noise jobs using NativeArray buffers to drive custom voxel engines, chunked terrain generators, or compute shader pipelines.

From the publisher's Asset Store listing.

Technical details

Requirements & Ecosystem Integration

  • Minimum Unity Version: Unity 6 or newer.
  • Render Pipelines: Fully compatible with the Universal Render Pipeline (URP), High Definition Render Pipeline (HDRP), and the Built-in Render Pipeline.
  • Native Packages: Built natively on Unity’s modern C# core, requiring the Unity.Burst, Unity.Collections, and Unity.Mathematics packages. Because these are included by default in standard URP and HDRP projects, the tool typically requires no external setup or third-party DLLs.

Core Procedural Architecture

The noise engine operates entirely on the CPU, evaluating purely mathematical spatial coordinates to synthesize physical textures from scratch. It does not accept external image inputs or scans.

  • Burst-Compiled Execution: The engine fully utilizes the C# Job System to run multidimensional array allocations, spatial math, and compositing concurrently across background worker threads.
  • True Analytical Partial Derivatives: Bypassing traditional image-based blurring (like Sobel filters), the engine relies on calculus. It calculates the exact X and Y slopes of the noise mathematically at the exact same time it computes the base elevation. These slopes are perfectly propagated through all Domain Warping, Fractal Brownian Motion (FBM) layers, and blending operations. The result is mathematically continuous normal and curvature vectors directly output from the procedural equations.
  • LUT-Based Colorization: To maintain high performance across multi-threaded CPU jobs, complex Unity Gradient objects are sampled on the main thread and converted into highly optimized NativeArray<float4> Look-Up Tables (LUTs). These flat arrays are then passed into the Burst jobs to rapidly calculate topological and banded Albedo maps without allocating memory inside the job loop.

Mathematical Toolset & Compositing

  • Base Algorithms: Simplex, Perlin, Value, White Noise, and Phasor (directional sine-wave noise for anisotropic woven patterns).
  • Voronoi Cellular Suite: F1, F2, F2-F1, F1/F2, Edge, and Cell ID. Supports Euclidean (with adjustable cell smoothness), Manhattan, and Chebyshev distance metrics, alongside controllable jitter.
  • FBM (Fractal Brownian Motion): Recursive octave layering modes including Standard, Billow, Ridged, PingPong, Swiss Erosion (thermal weathering simulation), Flow (derivative-warped domain distortion), and Hybrid (elevation-biased detail multiplication).
  • Modifiers: Domain Warping (Standard, Directional, and Radial transforms), Topographical Terracing (stepped contour lines), Contrast (Gain), Midpoint (Bias), and Shape Masking (Circle, Rectangle, Oval). Note: Radial Warping and Shape Masking mathematically break coordinate wrapping and are automatically disabled when Seamless Tiling is active.
  • SDF Compositing: When Layer A and Layer B overlap, standard mathematical blending often breaks analytical derivatives. By enabling Signed Distance Field (SDF) Boolean math (Smooth Union, Smooth Subtraction, Smooth Intersection), the engine mathematically interpolates the physical slopes of both shapes, ensuring the generated normal maps remain perfectly continuous across complex intersections.

Export & Packing Pipeline

  • Supported Outputs: Albedo, Normal, Height, Ambient Occlusion, Curvature, and Roughness.
  • 32-Bit Displacement Export: Intercepts the Unity TextureImporter to force Heightmaps to export as 32-bit floating-point .exr files, eliminating the stair-stepping quantization artifacts inherent in standard 8-bit images.
  • Custom PBR Packing: Maps Metallic, AO, and Roughness/Smoothness data to perfectly match URP or HDRP Lit shader layouts. Technical artists can also route specific generated buffers (Curvature, Height, AO, etc.) into exact RGBA channels to optimize shader memory.
  • VCS Integration: Hooks into AssetDatabase.MakeEditable() to automatically handle checkouts for locked files on Perforce or Plastic SCM during the texture baking process.

Versatile Programmer APIs

The generation mathematics are strictly decoupled from the Editor UI, allowing developers to directly interface with the engine via three distinct methods depending on their architectural needs:

1. Main Thread API (NoiseMainThreadAPI)Evaluating procedural noise synchronously on the main thread often introduces heavy overhead. To solve this, the engine utilizes BurstCompiler.CompileFunctionPointer to cache raw memory pointers to the Burst-compiled procedural mathematics during initialization.

  • Use Case: Exposes extremely fast, synchronous queries directly on the main thread. It is highly optimized for querying exact height data at specific X/Z coordinates to drive procedural object scattering (like placing trees strictly in valleys or on peaks) without needing to generate or store a full texture in memory.

2. Burst Job System API (NoiseJobAPI)Advanced programmers can bypass the texturing and UI pipeline entirely. This API exposes the raw IJobParallelFor structs used by the engine (e.g., ScheduleDynamic2D_Deriv), allowing you to pass in a NoiseTextureProfile and populate your own NativeArray<float3> buffers.

  • Use Case: You can schedule highly parallelized 2D noise jobs and chain the resulting JobHandles directly into your own systems, making it highly effective for feeding density data into custom voxel meshers, chunked terrain generators, or compute shader data pipelines.

3. Runtime Texture Component (RuntimeNoiseTextureGenerator)A provided MonoBehaviour designed to evaluate noise profiles asynchronously and dynamically generate physical Texture2D maps in-game via UnityEvents. Because it offloads the mathematical generation to background worker threads, it is highly effective for randomizing environmental textures or generating planetary maps during loading screens without freezing the main thread.

  • Memory Management: Generating multi-channel 4K PBR texture sets dynamically at runtime natively allocates RAM and VRAM. The runtime API returns an IDisposable wrapper (PBRTextureSet). Developers dynamically generating textures at runtime must explicitly call .Dispose() on these sets when they are no longer needed to safely release memory and prevent native memory leaks. This async API is effective for loading sequences, but is not lightweight enough for continuous, 60 FPS per-frame rendering.

Compatibility

Render pipelines supported in each Unity version
Unity version Built-in URP HDRP
6000.4.5f1 Not listed Compatible Compatible

As listed on the Asset Store.