Image Tiler*

Preview
Performance Cost 🟡 Medium
Signal Type Texture → Color
Implementation Native Compiled C++
Devices (Cycles) CPU / GPU (1:1)

Image Tiler solves the "visible repetition" problem with highly repeating textures. Effectively when texturing large surfaces like landscapes or floors, standard image textures create an obvious, repeating grid pattern that breaks immersion. The Image Tiler node uses Stochastic Hex-Tiling (based on the Mikkelsen algorithm) to eliminate these artifacts.

Instead of a simple grid, it maps the texture onto a randomized hexagonal lattice. Each tile is rotated and offset individually, then seamlessly blended with its neighbors using luminance-weighted interpolation. The result is an infinite, non-repeating surface texture generated from a single small input image.

Usage & Behavior

Standard Repeat (Grid Artifacts)
Rombo Tiler (Seamless)

This node is a drop-in replacement for the standard Image Texture node. Simply load your texture, plug in your UVs, and adjust the U/V Tiling. The node automatically handles the complex blending logic to hide seams. The Blend Contrast and Exponentiation controls allow you to fine-tune how the tiles merge—tighter blends preserve more detail, while softer blends hide the transition zones better.

Best Used For: Landscapes (grass, dirt, rock), asphalt roads, concrete floors, fabric patterns, and any large-scale surface where texture repetition is visible.

Key Features

  • Hexagonal Blending: Uses a triangular/hex grid instead of squares to hide seam lines.
  • Stochastic Rotation: Randomizes tile orientation to break visual patterns.
  • Detail Preservation: Luminance-aware blending prevents "ghosting" or muddy interpolation.

Deep Dive: The Hex Tiling Algorithm

Why does this look better than "Box Mapping"?

  • Triangular Tessellation: The algorithm transforms UV space into a skewed hexagonal grid. Every pixel sits inside a triangle formed by 3 hex centers.
  • Triple Sampling: The texture is sampled 3 times (once for each vertex of the triangle), each with a unique random offset and rotation derived from the cell ID.
  • Barycentric Blending: These 3 samples are blended based on how close the pixel is to each vertex. This ensures the texture is continuous everywhere, with no visible seams or sudden jumps.

Why Use This? The Efficiency Case

Standard texturing forces a hard choice: use massive, unmanageable 16K textures to cover large terrains, or tile small textures and suffer from visible grid patterns. Image Tiler solves this trade-off by decoupling Detail from Data Size.

1. Maximum Texel Density

You can use a lightweight 2K texture and tile it 50x across a landscape. The stochastic blending breaks the repetition so effectively that the eye perceives infinite, unique detail. This allows you to achieve the visual fidelity of a 16K texture while using a fraction of the GPU memory.

2. Storage & Transfer

High-res textures bloat project files and clog render farm networks. A collection of 8K maps can easily exceed 50GB. By relying on smart tiling instead of brute-force resolution, you can keep your asset library lean (under 1GB) without sacrificing the ability to render extreme close-ups.

Concept: Stochastic vs. Structured

This node works by randomizing rotation and position. This process is destructive to straight lines. Therefore, it is essential to understand which textures work with this technique.

âś… Works with Stochastic Maps

Textures that are naturally random or chaotic.
Examples: Grass, Dirt, Asphalt, Concrete, Sand, Rust, Plaster, Fabric (Micro-weave).

❌ Avoid Structured Maps

Textures that rely on straight lines or specific grid alignment. The random rotation will break the pattern.
Examples: Bricks, Tiles, Wooden Planks, Geometric Patterns, Text/Logos.

The Native Advantage

You may have seen node-groups that attempt this effect. While clever, they come with a heavy cost. Rombo Image Tiler is the first and only Native C++ Implementation for Cycles.

The Node-Group Way (Slow)
  • Requires chaining 3 separate Image Nodes manually.
  • Dozens of Math nodes to calculate barycentric weights.
  • Triple the overhead for the texture cache lookups.
  • Messy, unreadable shader graph.
The Rombo Way (Optimized)
  • Single Node: Calls the internal SVM texture engine directly.
  • Zero Overhead: Rotations and weights are calculated in native code.
  • Texture Cache Friendly: Optimized lookup pattern minimizes memory trashing.
  • Clean Graph: Drop it in, load texture, done.

Parameters

Image Pointer
The texture asset to tile. Supports standard image formats.
Vector Vector
Input texture coordinates (usually UVs).
U / V Tiling (default: 2.0)
Controls the repeat frequency of the texture. Because of the hex-blending, you can push this much higher than standard tiling without seeing a grid pattern.
Rotate Tiles (default: 0.0)
Adds a random rotation offset to each hex tile. Increasing this helps break up directional features (like wood grain or brushed metal lines) so they don't all align perfectly.
Blend Contrast (default: 0.5)
Controls the sharpness of the transition between tiles.
- High values: Sharper transitions, preserves more texture detail but seams might be visible.
- Low values: Softer blending, hides seams perfectly but may look slightly blurry.
Exponentiation (default: 1.0)
Adjusts the blending curve. A higher exponent makes the blend favor the brighter/dominant texture sample, which helps preserve high-contrast details like cracks or pebbles.
Interpolation Enum
Texture filtering mode (Linear, Cubic, Smart, Closest). Smart or Cubic is recommended for high-quality organic surfaces.

Quick Recipes

Setup guides for common materials.

Infinite Grass

  • U/V Tiling 10.0
  • Rotate Tiles 3.14
  • Blend Contrast 0.2
High rotation and soft blending completely hide the repetition of grass blades.

Concrete Floor

  • U/V Tiling 4.0
  • Rotate Tiles 0.5
  • Exponent 1.5
Higher exponent preserves the sharp cracks and pebbles in the concrete texture.

Fabric Weave

  • U/V Tiling 20.0
  • Rotate Tiles 0.0
  • Blend Contrast 0.8
Zero rotation keeps the weave aligned, while stochastic offsetting hides the grid.
↑ Back to Top

Leave a Reply