How to create wood parquet textures?
an hour ago
Hey there, fellow 3D artists, game developers, and environment builders! If you have ever worked on an architectural visualization project or designed a detailed indoor game environment, you already know the truth: the floor is arguably the most important surface in your scene. It covers the largest screen-space area, grounds your furniture, and catches the most crucial reflections from your light sources.
Among all flooring types, wood parquet stands out as an elegant, timeless, and notoriously difficult material to get exactly right. Creating a simple flat wood texture is one thing, but creating a parquet floor, where hundreds of individual wooden planks meet at distinct angles, each with its own unique grain direction, color variation, and specular response is a true test of a technical artist's skills.
In this comprehensive, step-by-step guide, we are going to dive deep into the art and science of creating a photorealistic wood parquet texture. We will explore the anatomy of the pattern, procedural generation techniques, and the secrets to nailing those Physically Based Rendering (PBR) maps. Grab a coffee, fire up your software, and let's get started!
1. Understanding the Anatomy of Wood Parquet
Before we touch a single node or brush, we need to understand what makes parquet unique in the real world. Realism comes from observation. If your texture looks fake, it is usually because it lacks the subtle imperfections of reality.
The Geometry of the Pattern
Parquet isn't just "wood." It is a mosaic of wood. The most common patterns are Herringbone (zig-zag planks that are cut at 90-degree angles) and Chevron (zig-zag planks cut at an angle to form a perfectly straight center line). There are also Basketweave and Versailles patterns. When light hits these floors, the alternating direction of the wood grain causes adjacent planks to reflect light entirely differently. This phenomenon, where one plank looks bright and the one next to it looks dark, is called anisotropy, and it is the secret sauce of a great parquet texture.
The Micro-Details and Imperfections
Real wood floors expand and contract with humidity. This means the gaps between the planks are never perfectly uniform. Some planks might be slightly warped, sitting a fraction of a millimeter higher than their neighbors. Furthermore, the finishing varnish on top of the wood gathers micro-scratches, scuff marks, and dust over time. Capturing these microscopic height and gloss variations is what separates a beginner's texture from an industry-standard masterpiece.
If you want to skip the creation process and examine high-quality, ready-to-use examples of these micro-details, you can always explore the extensive library of
2. Step-by-Step Guide: The Procedural Workflow
While you can create wood floors using photogrammetry or by painstakingly compositing photos in Photoshop, the modern industry standard for technical artists is procedural generation using software like Adobe Substance 3D Designer. Procedural generation gives you infinite resolution, perfect tiling, and the ability to change the pattern with a single slider.
Let's walk through the core logic of building this material procedurally.
Step 1: Generating the Foundation (The Plank Layout)
Start by creating the geometric layout of your planks. In Substance Designer, the Tile Generator or Tile Sampler node is your best friend.
For Herringbone: You can use a standard brick pattern but manipulate the rotation and offset, or use a custom shape input.
The Crucial Step: Once you have your basic black-and-white mask of the planks, run it through a Flood Fill node. The Flood Fill node is the holy grail for parquet floors because it assigns a unique data value to every single separated plank.
Step 2: Crafting the Height Map and Bevels
Wood planks are not razor-sharp at the edges; they have slight bevels.
Connect your Flood Fill node to a Flood Fill to BBox Size or directly into an Edge Detect node to isolate the gaps.
Use a Bevel node to soften the edges of each plank. Keep the bevel distance extremely small (e.g.,
0.005). Realism is subtle.Add macroscopic height variation. Use a Flood Fill to Random Grayscale node, lower its opacity to around 5%, and blend it with your height map. This ensures that some planks are physically slightly thicker than others, catching the light dynamically in your render engine.
For a deeper dive into node mathematics and the Flood Fill workflow, the
Step 3: Generating the Wood Grain
Creating procedural wood grain is an art form. You want to avoid the "melted plastic" look that plagues many procedural woods.
Start with a Directional Noise or Perlin Noise.
Stretch it heavily on the X or Y axis using a Transform 2D node to create long fibers.
Use a Directional Warp node, driven by a lower-frequency noise, to create organic bends and knots in the wood fibers.
The Magic Trick: Wood grain must follow the direction of the plank! Use a Flood Fill to Gradient node to get the angle of each plank, and use that data to rotate your wood grain specifically for each individual plank. This ensures the grain doesn't just flow linearly across the whole floor, which would instantly ruin the illusion.
3. Mastering the PBR Maps
Your height and pattern are set. Now, we must translate this data into the maps your game engine or renderer actually reads.
The Albedo (Base Color) Map
Real wood is incredibly rich in color. It is never just one flat shade of brown. It contains underlying reds, yellows, and even subtle greens or purples depending on the wood species (like Walnut or Oak).
Use a Gradient Map node to apply colors to your grayscale wood grain.
Sample colors from a real photograph of a wood floor.
Blend a Flood Fill to Random Grayscale node over your final color with a "Multiply" or "Overlay" blending mode at low opacity. This ensures every individual plank has a slightly different shade, replicating natural lumber sorting.
The Roughness Map (The Most Important Map)
I cannot stress this enough: the Roughness map is where your texture comes to life. A parquet floor's visual interest comes almost entirely from how the varnish reacts to light.
Start by extracting the roughness from your wood grain. The dark, porous parts of the grain should be rougher (closer to white), while the smooth surface should be glossier (closer to black).
Add Varnish: Darken the overall map to simulate a glossy clear coat.
Add Human History: Floors are walked on. Overlay grunge maps, subtle smudges, and fine scratches. Place dirt specifically in the crevices between the planks using an Ambient Occlusion mask.
If you are looking for reference on how a perfect roughness map interacts with light on a floor surface, checking out the premium
The Normal Map
Convert your final Height map into a Normal map. Ensure the intensity is balanced. The bevels should be visible, but the wood grain itself should only provide micro-details. If your Normal map is too intense, the floor will look like rough bark rather than a polished interior surface.
4. Procedural vs. Scanned Textures: Which is Better?
As a 3D artist, you always have a choice between creating textures procedurally (from scratch using math) or using scanned data (photogrammetry). Here is a breakdown of how they compare for parquet floors:
| Feature | Procedural Parquet (Substance 3D) | Scanned Parquet (Photogrammetry) |
| Realism | Extremely high, but requires deep skill. | Absolute photorealism out of the box. |
| Customization | Infinite. Change patterns, wood types, and aging instantly. | Very limited. What you see is what you get. |
| Tiling | Mathematically perfect seamless tiling. | Can suffer from visible repeating patterns over large areas. |
| Production Time | Very slow to create from scratch (hours/days). | Immediate if downloaded; slow if scanned yourself. |
| File Resolution | Infinite (Resolution Independent). | Limited by the camera sensor used. |
Pro Tip: If you are on a tight deadline, you don't always need to reinvent the wheel. Utilizing high-quality, pre-made PBR libraries from
5. Applying Your Texture in Engine
Once you have exported your Albedo, Normal, Roughness, Height, and AO maps, applying them correctly is your final hurdle.
In Unreal Engine 5: Make sure your Roughness and AO maps are imported with the sRGB checkbox turned OFF (Linear Color). If you leave sRGB on, your floor will look incredibly washed out and incorrectly glossy. To really sell the depth of the gaps, consider using the Height map with UE5's Bump Offset or Parallax Occlusion Mapping (POM) nodes.
In V-Ray / Corona: Pay close attention to your glossiness/roughness routing. Ensure your Normal map is set to the correct color space (usually linear/gamma 1.0). If your floor looks too flat, increase the strength of your light sources and position them at glancing angles to the floor to highlight the roughness imperfections.
6. Frequently Asked Questions (FAQ)
Q1: How do I fix visible tiling in my wood parquet across a large room?
Visible tiling (the "checkerboard" effect) happens when there is a unique, high-contrast detail (like a very dark plank or a distinct knot) that repeats noticeably. To fix this, reduce the macro-contrast in your Albedo map. Make the colors of the planks more uniform. Additionally, you can blend a low-frequency noise map over the entire Albedo in your game engine or renderer to break up the repetition dynamically.
Q2: Should I use actual 3D geometry for the planks, or just a Normal map?
This depends entirely on your target medium. If you are rendering an extreme close-up shot for an architectural visualization, using actual geometry (or a heavy displacement map) for the planks will yield the best shadow results. However, if you are building a real-time game environment, drawing thousands of individual polygons for a floor is terrible for performance. For games and mid-range renders, a high-quality Normal map combined with a subtle Parallax Occlusion Map (POM) is the standard and most optimized choice.
Q3: What resolution should my parquet texture be?
Because a parquet pattern consists of many tiny details, low-resolution textures will look blurry and lose the crisp bevels between the planks. For modern game engines and standard arch-viz, 4K (4096x4096px) is the sweet spot. If you are rendering extreme close-ups, you may want to push your procedural export to 8K, but be mindful of your VRAM limitations!
Creating the perfect wood parquet floor takes patience, a keen eye for real-world details, and a solid understanding of how light interacts with surfaces. Keep practicing, keep observing your surroundings, and happy texturing!