Material Series
Version 1.0, Updated January 2026 using Octane 2026.1 and Cinema 4D 2026.1
~10,750 words, average read time: 60-90 mins.
About this guide
This is a deep dive exploration into creating procedural wood in Octane. It’s a follow-along guide using either C4D or Octane Standalone (should also work with Blender/Houdini/etc) where we analyze a reference photo and try to get reasonably close to a material in it by understanding and mimicking qualities of real wood.
This is more than a walkthrough or a tutorial - it's meant to train you to think about the different steps involved in building a complex texture and develop good processes and workflows. As a result, it's long (10,000 words+), very text-heavy compared to other guides, and covers concepts that might be confusing to beginners and need further exploration (links to other guides are provided inline).
Downloads
A starter scene and several milestone states reached while going through this guide can be 💾 downloaded here
The reference photo we’re using is this one found on Pexels, shot by Antoni Shkraba Studio.
This guide is also available in 📄 PDF format here
Part I
Intro and Upfront
Intro
Wood is a complex thing, and is fairly difficult to reproduce in 3D. This is partly because it’s an organic substance that grows in a certain way, yet can vary wildly depending on the species of tree and conditions it has to endure. The other tricky thing is that in order to properly translate it to a 3D render engine, we need to treat the texture as a solid volume of material and “carve” our shapes out of it rather than wrap a 2D texture around the surface (unless we’re making veneers). This process utilizes several advanced 3D concepts and techniques that have other entire guides dedicated to them.
After the intro, we’re going to look at real wood and go over some of the anatomy and techniques when processing it so we have a better understanding of our target. Then we’ll look at Octane’s built-in Woodgrain node and learn how to work with it. After that we’re going to completely ditch the Woodgrain node and build our own wood shader graph from scratch, and then finally add some finishing touches to help make it look more realistic.
When we’re done, we’ll have a custom beech wood material that we can apply to our own models, and modify to look like other types of wood.
Strap in, this is a lot :)
A Note about AI
AI is a hot topic right now with all kinds of emotions attached to it. We’re going to be using it to assist with research in this guide. It’s known to very confidently lie – like a lot – so we are going to do some fact checking and thinking about plausibility. Annoying as that is, it is overall a lot faster than just randomly throwing darts on Google and hoping for the best. We’re not going to use it to generate textures or other assets (or write or edit the text in this guide ;)).
Tenets
This guide incorporates three tenets to help making working on a complex 3D project less stressful and random:
Tenet #1: Real World Values
We’re making a realistic scene, so we want physically plausible values for everything we possibly can. Octane is a physics simulator - the more realistic the values are that we feed into it, the more realistic the output is going to be.
Tenet #2: Avoid Conflation
Conflation is when two or more things combine to affect our results. While we’re working, we want to establish baselines, and then alter values one at a time if possible. We do this because predictability is important, otherwise it leads to hours of unnecessary troubleshooting and frustration. Avoiding conflation includes obvious things like not moving three sliders at the same time if we don’t know what any of them do, but also less obvious things like using flat lighting, simple geometry, and isolating objects or nodes in a material while working on them.
Tenet #3: Perfection is the Enemy
When things are too perfect looking, they break the suspension of disbelief and they look “off” to us. If reality is the goal, we want to introduce imperfection wherever possible, even if it’s just a small amount. At first blush, this may seem counter to Tenet #1, but when was the last time you saw a mathematically perfect real-world object? What we want to do is apply chaos in believable ways.
Setting Up a New Scene
Tenet #2: Avoid Conflation
When creating or heavily editing a material (especially one with 3D textures), it’s often a good idea to put it in a brand new super-minimalist scene and use the most basic geometry possible. This is done so the other objects, custom lighting, depth of field, camera imager settings, or anything else that we’re developing in our final scene doesn’t interfere and cause us to push material values too far or not far enough.
You can download the starter scene here, or make your own.
Environment
Starting with the environment for this new scene, we want the lighting to be as flat and even as possible. A texture environment with a white RGB Spectrum node hooked up to it and a power of 1 will create an evenly-lit sphere around our object. This is where tenets 1 & 2 duke it out. We’re not going to find this type of environment in the real world, but for now it’s more important to make sure the randomness of real-world lighting and reflection doesn’t cause us to make the wrong choices.
Note: In the C4D plugin, the default texture environment isn’t white, it’s like 95% for some reason - for this exercise we want pure white).
Background
We’re not going to have a cyc or other background objects so we can freely orbit around our models.
The visible background should be a mid-gray, though (let’s start with 0,0,50% in HSV or 0.21% using a linear scale) so it doesn’t affect our perception of the colors in the material too much. This is most easily achieved by creating a second texture environment, picking the color, and setting it to “visible environment”.
Camera
Generally speaking, a 50mm camera is the best option for material development so that we don’t introduce any extra lens distortion. We want to make sure depth of field is OFF (aperture = 0) so we don’t get any out of focus areas fooling us into thinking the texture is blurry.
Render Settings
The render settings should be a set of standard lookdev settings - low samples without compromising physical accuracy too much. It’s important that we don’t cap the GI clamp (leave it at a million), and make sure our bounces are high enough (16/16/8 is usually fine). Max samples are good at 256 for this scene. We want to turn off ACES tone mapping or AgX, and just use straight-up sRGB, and also turn off denoising.
Model
We’ll want a test model. Usually materials and shaders are developed on shader balls, but we have a specific target in mind for this - a wooden elephant toy that’s similar to the one in the reference photo. Working with 3D projection is tricky though, so we also have a cube about the size of the elephant in the scene so we can see what’s happening more clearly.
Part II
Wood Analysis
Wood Basics
Let’s quickly go over some tree anatomy so we know what we’re aiming for.
Fibers
Wood is made up of fibers that run the length of a tree trunk (or branch). There’s a lot of confusion (even among woodworkers) as to what “grain” means, but most of them agree that one of the main factors in it is the direction the fibers are running.
Rings
If we were to cut a tree down and look at the cross-section, it would appear to us as a series of wavy nested rings. Rings are usually annual (one light/dark ring set per year) and different trees grow at different rates in different conditions.
Medullary Rays
Medullary rays are strips of cells that extend in a radial pattern out from the center of the tree like wheel spokes. These help transport nutrients horizontally (if the tree is standing upright like a tree should be). Depending on the species of wood, these rays create different appearances and add to the visual interest of the wood. In beech, this is what creates the signature dark dotted lines in the elephant in the reference photo.
Pores
If we look really closely through a magnifying glass at the end where it was cut (don’t do this if you’re a trypophobe), we’d see small holes throughout the wood - these are technically called vessel elements, but they’re commonly referred to as pores. These pores are tall hollow tubes like straws that grow in the same direction as the fibers and transport water and nutrients up the tree from the roots. Depending on the wood, these pores are more or less apparent. Typically in a hardwood like the beech we’re going to be making they’re nearly invisible to the eye (just a few micrometers across), so we’re just going to lump them in with the fibers to make a “grainy” overlay for our material.
Sawing
As if that’s not enough, we also have a choice as to how we cut the wood perpendicularly to the rings.
There are a few ways that a log is traditionally cut into boards:
Flat-sawing wood is the cheapest and easiest way to process a log, and has the least wastage. It’s basically like putting it through a giant bread slicer and then squaring off the edges. It has the most variation in the grain pattern on the flat side of the board, but since it’s shearing the medullary rays at odd angles, they’ll tend to be less apparent.
Quarter-sawing wood is a little more time- and cost-intensive. This involves cutting the log in quarters (like a pie if we looked at the circular end), and then extracting planks from that. It’s stronger than flat-sawn wood because of the grain, and because it’s lining up a bit better with the medullary rays, they’re more apparent.
Rift-sawing wood is the most expensive and wasteful way to extract wood, but produces a really nice straight grain pattern that’s desirable for things like wood planking. Rift sawing hides the medullary rays the best because of the angle in which it’s cut.
Wood Material Properties
On top of all of that, wood itself has other material properties that we’ll want to keep in mind.
Albedo: Most untreated wood ranges between pale tan and dark brownish or reddish, but it can be stained or painted to achieve other colors.
Roughness, Specular, Coating & Sheen: The surface appears matte in its natural state (more or less so depending on the type of wood), though depending on the variety, it can have a visible natural sheen. It’s often coated with a varnish or other treatment that can make it glossier, and then it can be treated further or handled over time to make it appear more rough again.
Transmission & Medium: Because it’s an organic cell-based material, it allows light through (SSS), but often it’s too dense to see this effect. Our models aren’t super thin in places, so it likely won’t be worth the render time hit caused by adding this effect.
Bump, Normal & Displacement:The surface properties depend on how it was worked with. Natural wood is irregular and bumpy, but very often we mill/lathe/sand/polish it to make it smoother. Less porous wood tends to smooth out better when sanded than more porous wood.
Other effects:It’s not metallic and it’s not emissive. It doesn’t have a thin film layer unless it’s coated with something that does. It has dispersion properties (everything with any kind of transmission short of a vacuum does), but again, our models aren’t thin and we won’t be backlighting them, especially not in a way that will cause caustic patterns, so this isn’t worth considering here.
AI Research
Interestingly, all three AIs polled mostly agreed on the different sawing techniques and anatomy of wood, and all were pretty certain the small elephant and ring were beech, but when asked “what are the small dark dashed lines running across the small elephant?”, Gemini and Claude answered “medullary rays”, while ChatGPT thought they were deep pores. Through a bunch of manual research, it seems like medullary rays is the correct answer.
Again, we don’t even want to be “trusting and verifying” here, we want to make good and well sure the information we get is accurate by verifying and pressing the AI further until it starts to apologize for spitting out false info just to get you off its back, and make it do some actual research.
Part III
Woodgrain Node
Before we start…
Important: We’re going to start with Octane’s built-in woodgrain shader in this section and see how it relates to how real wood works. We’re not going to end up using it in our final render, but it will help us understand our target for a custom wood shader, so it’s worth exploring
This guide was developed using Octane Standalone and Octane for Cinema 4D on parallel tracks. The differences between the two are called out in this guide, but between them, you should be able to apply the concepts to your DCC (if you’re using Blender or Houdini or something else).
Note: The defaults in nodes and objects may differ from plugin to plugin.
We’re going to be using a couple of different non-MeshUV projections which are fairly confusing if we’re not used to working with them. It’d be worth reading the Intro to Texture Projection & UVs guide at some point if you’re not familiar with this concept. It’s not a dealbreaker to get through this guide, but understanding the basics of projection will make more things make more sense.
This is a complex material, so we’re going to want to use the node editor to build it. This is the only way to do it in Standalone, but in C4D it’s still possible (but difficult) to do this using the Material editor.
Follow-along files
All of the files used in this guide and various completion states can be found here for Standalone and C4D. There’s also an .orbx 000 Starter Scene file that should be able to be imported into any DCC, but the UIs are too different to provide other states for other DCCs. Let’s crack open 000 Starter Scene.
Octane’s Woodgrain Texture
We’re going to start this process by investigating Octane’s built-in woodgrain texture, which is based on the MAWoodGrain OSL script by Michel J. Anders. It’s a pretty versatile texture, but it’s also fairly advanced and requires a decent amount of setup before seeing good results.
Important stuff
There are a few things to know right off the bat:
- Octane’s Woodgrain is a 3D texture. We’re all probably familiar with 2D textures that wrap around the surface of a model, but a 3D texture is more like a volume of texture “stuff” that the model sits in, and what we end up seeing on the surface is the pixels of the texture that intersect with the geometry at that particular point. This makes it hard to visualize how it will fall on a model if we’re just looking at a 2D representation of the texture. There are two guides on this concept starting with this one.
- 3D textures operate best using XYZ to UVW projection. This projection relies on the object’s axis (assuming it’s set to Object Space like it should be) for its center point and orientation. If the object axis is rotated or positioned oddly, the appearance of the texture on a model will be even more difficult to predict than it already would be if the axis is centered and oriented properly.
- XYZ to UVW projection moves and rotates with a model, but it does not scale with it. There’s a whole guide on how to deal with this if we need the model to scale and keep the texture intact. This also means the texture has to have a default “tile” size (in quotes because the woodgrain texture doesn’t actually tile, it just keeps generating more of the pattern forever). In both C4D and Standalone, that default is 200cm (2 meters).
Felling a Tree
Tree trunks are essentially cylinders. We’re curious about how to get patterns in wood, so let’s imitate a tree trunk and make a cylinder primitive.
The default cylinder size in C4D is 50 cm radius x 200 cm tall. The texture size is 200 x 200 x 200 cm, so if we want to see one single default “tile” of it, we’ll want the radius to be 100 cm to give us a 200 cm diameter.
If we’re building the same thing in Standalone, we’d use a Cylinder primitive or Vectron object and set the radius to 1. Standalone also uses meters for its scene scale, so a radius of 1 would yield a 2 meter diameter cylinder that matches up to the 200 x 200 x 200 cm texture size, and a height of 2 would match the C4D version.
Great, now we have a very large, upright log.
Material Setup
Let’s make a new Universal or Standard Surface material (either is fine). We’re going to use a Universal one in this guide, so we’ll be referring to the base color channel as “Albedo”. If you go Standard Surface, use the Color pin in the Base layer instead.
Let’s “turn off” the specular channel by making its color HSV/RGB 0,0,0 & float=0 (or just turn the internal specular control to 0 in Standalone) so we’re not catching any glare.
This is another good example of tenet #2: Avoid conflation: We don’t want the reflections influencing our decisions for the values we pick, only to have to change them all when we orbit the camera around the model or swap the lighting out.
If we plug a default Woodgrain node into the Albedo channel of our material and put that on our log, we’ll see something weird. The rings are on the side, which is definitely not how wood works. Why?
Axis Orientation
In both Standalone and C4D, as well as probably most DCCs out there, a default cylinder is oriented upright like a soda can. In both the apps we’re using here, that means the long side goes along the Y axis. In Blender as well as a few other Z-up apps, it means the long side is along Z.
The woodgrain texture defaults to (or should default to) XYZ to UVW projection, and it’s oriented along the Z axis in Standalone/C4D, so it’s “laying down”. We need to reconcile the two orientations, and this is where the two apps diverge a bit:
In Cinema 4D, the woodgrain texture’s built-in XYZ to UVW projection node is set to Object space, meaning the texture will move and rotate with the geometry. If we rotate the cylinder 90° on R.X, it’ll be laying down, but the texture will still be wrong. We have two choices here - we can either rotate the projection itself, or reorient the cylinder so its axis matches the texture. In this case, it’s easier to reorient the cylinder by going into its Object settings and setting the orientation to -Z.
In Standalone, there’s no concept of “orientation” in either the geometric primitive or Vectron version of the cylinder object (we’re using the Vectron version here because it’s more versatile), so we need to rotate either the texture or the projection itself 90° on R.X, and then we can rotate the cylinder to lay it down. In the example above, we’re rotating the texture itself with a Transform Value node.
Now that the texture size matches the log size and is oriented correctly, we can really see what’s going on here. There are 8 sets of rings - a set being made up of a light ring, or “earlywood”, and a dark ring, or “latewood”. This pattern is formed by the tree reacting to different seasons: Dark rings were grown when it was colder and the growth rate was slower, making for more dense cells.
We may notice that the rings start much thicker in the middle and get thinner over time as the tree gets older- we can’t do that with our wood texture, but that’s ok - it won’t impact our elephant model since we only are going to need a very small slice of the log.
We might also notice that the dark rings tend to be thinner than the light rings because the growth is slower during the colder seasons. This is going to be a problem later since the woodgrain shader can’t do that, but we’ll burn that bridge when we get to it :)
A Reasonable Log
Tenet #1: Real-world Values
The 8 sets of rings we see in the log at 200cm match up to the default ring frequency setting of 8.
Very few (if any) trees grow to 200 cm in diameter with only eight rings, and beech certainly does not work that way.
If we ask ChatGPT how many rings a 200 cm beech tree would have, it comes back with between 333-1000. Claude thinks it’s more like 250-500, and Gemini thinks 315 or 450 depending on whether it’s American or European beech.
Definitely not eight.
When we set the ring frequency to 333, it creates a very tight pattern that we can barely see in the viewport. That makes sense though, because our current log’s diameter is as tall as a basketball player, so seeing individual rings from the distance we’re at would be hard.
Is there even a 200cm beech tree?
Turns out most commercially-harvested beech logs are between 15-20cm in radius (thanks again, AI!). If we make the radius of our log 20 cm (and reduce the height to 40 cm), we can move in closer and the pattern becomes more obvious.
We didn’t need to adjust the ring frequency because the texture is still a 200 cm “tile”. We’re specifying how many ring sets occur every 200 cm, not how many rings in total are on our specific model. By making our log smaller, we’re cropping in on the texture, not scaling it.
There are these huge blotchy areas that make it really hard to see what’s going on. These are caused by the texture’s “graininess” setting which overlays a noise on top of the ring pattern that creates some variation in the ring pattern on the side, but it’s super distracting right now, so let’s take it down to zero. Ahh, now it’s starting to make sense!
Grayscale FTW
Respecting Tenet #2 and avoiding conflation, we don’t want to get into coloring yet because we want to see what all the woodgrain node settings do, and that’s much easier when we’re looking at grayscale values.
Let’s make the dark wood color black, and the light wood color white. That will give us the most flexibility later for recoloring the values as we see fit. Let’s also crank the ring intensity up to 2 to up the contrast so we can really see it clearly.
Carving out a Block
Right now we have an entire tree trunk, but we only need a small block of wood that would be used as a base to carve our tiny elephant. The tricky thing about wood is that the pattern completely changes based on where from the log we’re taking it from.
Let’s hide the log and unhide the geometry that came with the starter file. We have our elephant, and also a small cube that’s about the same size (8 cm long from trunk to tail, 6 cm tall, and 3.75 cm wide). This cube is here to help us visualize the ring pattern.
Important: The elephant and wood block are already set up to have their axes oriented correctly, so if we rotated the texture in the last step, we’ll need to set it back to zero so it looks right on these models.
When we apply our wood material to both the elephant and the block, we’ll see the ring pattern on the “front” face of our block, and it will be positioned as if we took our log and cut a rectangle right out of the center. It’s easier to understand what the pattern is doing on the block than the elephant because of how 3D textures work with curved geometry - that’s why we have both.
At this point we’re going to want to either duplicate our material or duplicate several of the nodes inside of it so we can have a “pushed over” version for the elephant and a centered version for the log. In the C4D follow-along we duplicated the material. In the Standalone files we duplicated some of the nodes.
Thinking about the pattern
So where in the log was our elephant pulled from? Our first thought might be to look at the side of the elephant and think about how to reproduce that pattern, but we’re looking at a 3D texture here, so predicting what carved wood rings look like with a curved piece of geometry would be extremely hard.
We can look for other clues though - the front of the legs are pretty well squared off, so that should be very similar to the original block. When we zoom in on the photo, we’ll see that the lines form a pretty tight parallel endgrain pattern that isn’t curved or slanted much, so the wood block was likely taken from further out toward the bark and oriented in a way that kept the ring lines fairly straight up and down like we can see in the diagram above.
Positioning the Texture
Once again, we have two options here. We can do the shift in the Transform node, or the Projection node. The difference is pretty heady and is explored more in another guide. We’re going to use a Transform node (may be called Transform Value in your DCC) in this case since it really doesn’t matter for the type of texture we’re using.
Tenet #2: Avoid Conflation. One axis at a time.
The most obvious thing here is that the elephant’s leg in the reference photo has parallel-ish end grain going on, so we want to get that in place first. Thinking back to the diagram, we want to push it pretty far over on X to get closer to the bark, so let’s start there.
If we set T.X to 0.8, it’s not moving it 8 cm or 8 mm, it’s moving it 80% of the width of the texture tile (so about 160 cm over because the default texture size is 200 cm). This isn’t correct for a 40 cm log, but it’ll be faster and easier than trying to find the exact spot in a smaller log where all the lines line up.
Next thing we’ll notice is that the rings are a lot tighter toward the top of the elephant than the bottom. We can mess with the T.Y value to bunch the rings up one way or or the other. About a quarter of the way down seems to do the trick (-0.28). We could have also rotated the texture to get this effect, but again, this is a little easier.
Finally we want to fine tune the pattern a little. If we move the texture on Z, it’ll take the wood from further down the length of log, and since trees don’t grow perfectly straight, that means we’ll get different grain patterns as it shifts. If we move T.Z to 0.05, we get something that has a nice pattern around the legs. Again, we’re not looking to perfectly mimic the reference (good luck with that - every tree is unique), we’re just trying to understand how to work with 3D wood by getting reasonably close.
Refining the Rings
Tenet #2: Avoid Conflation. Practice on an object that makes sense.
We now have a pretty good understanding of the ring pattern and how it affects the wood, but if we start messing with the other settings here, it’s going to get confusing fast. This is exactly why we kept our log setup around. It’s much easier to zoom out, experiment with the values, and see what’s happening to the texture as a whole so we can make informed decisions about our super zoomed-in version that we need for our real model.
Let’s take the ring noise setting for example. Our first inclination is probably to grab the slider and start shifting it left and right to see what it does. If we’re doing this on our tiny elephant, the pattern is going to start shifting in seemingly random and crazy ways, and we’ll have no frame of reference for what it’s doing. If we do the same thing on the whole log, we can see that it start distorting the rings using a noise and suddenly it makes a lot more sense (and we’ll quickly understand that we have a very small window of this very large slider to work in before things go completely out of control).
In the illustration above, we can clearly see what’s happening in the log and then understand how that’s affecting the small red rectangle in the lower right corner that represents the block of wood we’re working with for our final texture.
The Other Settings
Here’s what the other settings in the Woodgrain texture do:
Ring unevenness shifts some of the rings closer together or further apart randomly. Trees grow in accordance to the weather which varies from year to year, so this is somewhat useful to give a little extra realism.
Ring noise and Ring noise frequency distorts the rings on all three axes at the same time using a set noise. This is too heavy-handed for our purposes, but might be useful if we’re not trying to get close to a reference image.
Trunk wobble twists the texture as it goes down the length of the tree and Angular wobble appears to rotate the ring texture. These are used to mimic the uneven growth of a tree over time. These only affect the ring pattern, not the grain.
Graininess and Graininess frequency create a stretched noise overlay that mimics the fibers in wood (and to a lesser extent pores). Graininess is like an opacity slider for the grain texture, and frequency is how large the noise is (again, along all three axes at the same time which isn’t super versatile. Something like 0.5 is a good start for moderately grainy wood.
Important: As of this writing (2026.1) The default value for grain frequency is 25 which isn’t realistic and can cause a lot of confusion. 1500 is a better starting value to achieve a finer grain, and then go up or down from there to simulate different types of wood.
Hitting a (Wooden) Wall
Unfortunately, no combination of settings do exactly what we need. If we look closely at our reference, we’ll see small ripples in the ring lines, but they still remain fairly parallel to one another. That gives us a clue that we’re looking for a way to distort more heavily on one or two axes than the others. It’d also be nice to have some control over the type of noise and some of its parameters. Same holds true for the gradient between earlywood and latewood and the size of the grain, not to mention the lack of medullary rings.
Basically we need more -ahem - granular control, so rather than spend more time recoloring and altering more settings here, it’s time to make our own custom wood texture.
Final Section File
001 Woodgrain Exploration is the final project file that deals with the Woodgrain node. From here on we’re going to start over with 000 Starter Scene again for the custom shader.
Part IV
Custom Wood Material
Where we’re at
We now know that we need a concentric ring texture, a “graininess” texture, and something that looks like the dark dotted medullary rays pattern that we weren’t able to get with the woodgrain shader.
Sticking with tenet #2, let’s go back to our original 200 cm diameter log so we can see what’s happening to the whole tree as we make adjustments.
Project Files
We’re going to start over with 000 Starter Scene to avoid conflation :)
Making a new rings shader
Let’s start with a brand new material. Once again, we’re going to use a Universal material here, but you’re welcome to use a Standard Surface type if you prefer.
One of the big issues we had with the woodgrain texture was the lack of ability to control the transition from the earlywood (light) and latewood (dark) portions of the rings. By using a Gradient Generator node (not an Octane Gradient or Gradient Mapping node), we can get control back over this.
Let’s add one in, set the mode to Radial so it creates a ring, and apply it to our log. Regardless of whether we’re using C4D or Standalone, we’re going to need to hook up an XYZ to UVW node (or just a Projection node set to XYZ to UVW) into the projection pin, and we’re going to need a Transform (value) node as well.
Orientation
For C4D or any DCC that allows us to adjust the geometry axis, if we reoriented our log in the last section (changed the orientation from +Y to -Z), then we don’t need to rotate our texture.
For Standalone or any DCC that doesn’t allow for axis reorientation, we’ll need to have two projection nodes that we switch between: One with R.X=90° for the log, one with R.X=0° for the elephant. Alternatively we can find a way to bring in a cylinder in the same orientation as the elephant so we don’t have to do that.
Scale
We currently have a dark center that goes out to a white edge, or a single ring per 200 cm. If we scale this texture down on both S.X and S.Y (S.Z doesn’t matter), it will start repeating and create the concentric ring pattern we’re after.
Important: We want to be sure to hook a Transform (values) node up to the gradient generator texture to scale it. We do not want to scale the projection itself.
How do we know how much to scale it though?
We know we have one ring now per 200 cm, so if we want 333 rings, we just divide 1 by 333, and that will scale it down so that we get 333 rings in 200 cm. Fortunately, both C4D and Standalone (and probably most DCCs at this point) let us do simple math calcs right in the field. If we make sure all the Scale axes are locked together and type 1/333 in one of those fields, it will do the math and give us 0.003003, or 333 rings. Excellent.
Let’s unhide our elephant and small cube and apply this new material. If we had rotated it in the last step, we’ll need to set it back to R.X=0 so it aligns properly on the geo.
Refining the Rings
Next up we want to shift the rings so we’re not looking at a center cut from the log. Once again we can either shift the texture or the projection. In this case, It’s going to be easier to duplicate the Transform (values) node going into the texture and have one with no movement for the log, and one that translates the texture for the elephant.
Just like the woodgrain texture, we’re going to have to decide whether to keep a separate set of transform nodes for the log and elephant, or duplicate the material. Either approach is fine.
For the elephant transform, we can use the same values that we used last time. T.X = 0.8 and T.Y = -0.28. Thing is, T.Z=0.05 no longer seems to do anything though, why?
The native wood shader has some distortion built in along the length of the log, so where up and down the tree we cut the block from affects the pattern a bit. Our rings shader is mathematically perfect, so it extrudes down the log with no variation - regardless of where on the log we’re taking this (on Z), the pattern will always be the same. We’ll start distorting it soon, but it’s just good to know what’s happening at this stage.
The gradient generator also has an invert checkbox - let’s hit that. That makes it look like the “shadowing” is going in the right direction and looks a bit more like the reference photo. Great.
Last thing we’re going to do here is reduce the Gamma of the gradient generator to 1. This will give that sharp falloff that we’re looking for when we’re comparing it to the reference photo (it’ll also make it easier to recolor later).
Distorting the Rings
Tenet #3: Perfection is the enemy.
If we look closely at the rings in the photo, we’ll notice that they’re not perfectly smooth - they’ve kind of wavy because they’re organic. Roughing those up will go a long way to selling this as real. There’s a new node in Octane 2026 that lets us add this kind of effect, which is pretty exciting. It’s called Distorted UVW Projection (not distorted MeshUV - that’s different). In C4D, we have to bring out a Projection node and select Distorted UVW from a list - it may be different in other DCCs. This node is explored in full in this shorty series guide, so to keep this guide to a manageable length, we’ll just look at the setup to distort the rings.
Important: Distorted UVW Projection does not work in the 1.8.2 version of the C4D plugin (found in the forums). It still works in the 1.8.1 version, and isn’t an issue in Standalone.
Also Important: As of this writing, in the Cinema 4D plugin, Distorted UVW projection defaults to MeshUV instead of XYZ to UVW projection. In order for it to work properly for a 3D texture, we need to create a second XYZ to UVW projection node and feed it into the Input Point of the Distorted UVW projection node. That will get it in line with Octane Standalone and allow us to keep our woodgrain texture 3D instead of converting it to mesh UV and undoing a lot of what we did in this chapter.
Following the layout above, we can make the wood rings look a lot more natural and organic. It won’t match our reference photo exactly (every tree is unique, and none of them use computer-generated 3D noise), but it’s reasonably close and should be more believable once we recolor it.
Changes from Defaults
Turbulence texture: goes into Distorted UVW’s Strength pin. Stock, no changes. Experiment with other noises - they all have different flavors.
Transform Values node attached to Turbulence - S.X, S.Y, S.Z = 0.1.
Texture Projection attached to Turbulence XYZ to UVW projection (MeshUV is default in C4D, XYZ to UVW is already default in Standalone, but worth adding the node anyway).
Float value for Distorted UVW’s Scale All Axes = 0.01 (This is a Float Texture in C4D, Grayscale Color in Standalone, and possibly called something else in other DCCs - we’re just looking for a single linear 0-1 value here).
Follow-along File
If you’re following along, your setup should match up with 101 Custom Rings. If the rings aren’t distorted, you might be using the 1.8.2 versions of the C4D plugin where Distorted UVW isn’t working. Going back to 1.8.1 (or hopefully forward to 1.8.3 and beyond) should fix this.
Composite Texture
We’re going to use a composite texture system to layer all the pieces together. The structure of the composite texture node and availability of blend modes makes this a perfect choice for a complex material like this.
Let’s drag out a composite texture node (not a composite material node) and hook it up to the Albedo channel.
Important: The composite texture node needs a composite texture layer node for each layer. In C4D, this is relatively easy - we hit the “Add Layer” button and pick “Texture” and it will build a new composite texture layer node for us. We can then run our Grain Noise texture into it.
In Standalone it’s a little trickier. There’s still an Add button, but we don’t get a new composite texture layer node when we hit it, just a pin for it to attach to. We then need to manually make a new composite texture layer node, but if we look in the list, what we’re after is called “Texture”, and it has some helper text next to it that doesn’t show up in the search, so we just have to know what it is and what it’s called.
We’re going to need four layers in total for this, so let’s build them out and make sure to hook up the layer nodes to them as well.
Blend Modes
The composite texture works similarly to a 2D compositor like Photoshop or Affinity Photo - Layer 1 is the “bottom”, then layer 2 sits on top of that, etc. Each layer can have a different blend mode to composite in with the layers below. We’ll explore this later after we get into recoloring.
Our final layer order will be: Rings in layer 1, Grain in layer 2, Rays in layer 3 and Eye in layer 4. Let’s hook up our Gradient Generator into the Layer 1 Composite Texture Layer node (in the “Texture” pin).
Important: We also need to go back to the other three Composite Texture Layer nodes and uncheck their “Enabled” checkboxes so they aren’t overriding our rings.
Annotation
This is also a good time to add comments to the scene. Octane has a commenting system that contains a title and body text. In C4D the node is called “comment”, and we can select a group of nodes and drag a comment on it and it will draw a box around them. In Standalone it’s called “Note”, and it’s just a node that we can rename and add some text under. It’s also handy to color-code these to make them stand out.
Follow-along File
If you’re following along, your setup should match up with 102 Composite and Annotation
Grain Layer
Tenet #3: Perfection is the enemy
The rings are in pretty good shape now, but the wood itself is far too smooth. What we’re missing is the graininess from the wood shader. Breaking the surface up will add imperfections that will sell this texture better.
As we learned earlier, grain in wood is created by both the fibrous makeup of the wood cells and tiny tubular holes that run up and down the length of the log that help transport water and nutrients from the roots up the trunk. For the most part, grain runs in one direction (“with the grain”) and the fibers are long and thin. A good way to make this is by stretching a noise.
Perlin noise works particularly well for this since it’s a bunch of random gray dots, more or less. If we keep the X and Y scale small and stretch out the Z quite a bit, it should give us the texture we’re after.
Adding the Noise
Let’s add in our Perlin noise. In C4D this node is called Octane Noise, and in Standalone it’s called Noise Texture. It’s not Noise4D which is a collection of C4D noises, it’s Octane’s original noise texture. Both default to Perlin, so that’s good. This node goes into the Composite Texture Layer (Layer 2).
Tenet #2: Avoid Conflation
Let’s check the Enable checkbox in the Composite Texture Layer to turn it on. By default, it’s set to the Normal blend mode which will override the rings. This is what we want now since we’re focused on the grain.
The results are going to differ quite a bit from Standalone to C4D because of the default projection. Let’s remedy this:
Grain Projection
Grain is a series of parallel-ish strands, so we want XYZ to UVW projection again. Unlike the rings, we don’t need to worry about rotating the projection for the grain since we can just stretch it in the direction we need (Z in this case).
Standalone defaults XYZ to UVW projection, but it’s always a good idea to add an external projection node anyway to get more control and make sure we’re operating in Object Space instead of World Space (different textures have different defaults).
C4D (and possibly other DCCs) uses MeshUV by default, so we absolutely need an external projection set to XYZ to UVW or else it’s never going to look right.
Grain Transform
We can either transform the projection itself or the texture here and get the same results. Let’s transform the texture by adding a Transform (values) node into the Noise texture.
We want the S.X and S.Y to be the same tiny value to produce a small cross-section. Claude thinks birch fibers are ~0.7-1.5 mm long, and 20-40 micrometers thick (1 mm = 1,000 µm). We can’t know how big one of the perlin “dots” are, but at least we know a ratio now, so if we put in 0.15 for S.Z and 0.002 for S.X and S.Y to get a plausible ratio that looks fibrous, we can scale it up or down from there if needed.
Finally, let’s be sure to label this section “Grain” so it’s easy to come back to later.
Follow-along File
If you’re following along, your setup should match up with 103 Grain Layer
Medullary Rays Layer
Medullary rays are long, flat cell structures that grow outward from the center of the tree sort of like spokes in a wheel. When we see them in our block of beech and elephant, they look like dark, dotted lines.
If we were to find these rays on a log, they’d appear kind of like flat noodles. They’re pretty long in one direction (starting at the center of the tree and stretching outwards toward the bark), relatively thin along another (growing upward), and then not terribly wide in the third (“left to right” if the tree is standing upright).
We’re going to do something similar to what we did with the grain, but with some key differences, notably the projection.
Setup
This is going to be very difficult to comprehend on our elephant model at first, so let’s hide it and bring back our 40 cm log geometry. Another good example of Tenet #2: Avoid Conflation.
We’ll also need to set our texture back up to be in “log mode” if we’re running a parallel track of nodes in the material, or just connect the duplicate material up if we’re taking that path.
Starting with Noise
Once again, a Perlin noise works pretty well for something like this. Let’s add one in and attach it to the third Composite Texture Layer. Let’s make sure we remember to check “Enable” in the node to turn it on.
Projection and Scale
Reproducing the pattern Medullary rays grow in is a perfect example of where we’d use Cylindrical projection in 3D. We want all of the lines to converge and pinch at the center of the disc side of the cylinder, but not distort much around the circumference or up and down the height of it.
Cylindrical projection by default is “upright” like a soda can on a table, which is the same orientation as the default cylinder object in both C4D and Standalone (+Y). This is different from the Gradient Generator we used for the rings (+Z), which means in Standalone we’ll need to rotate it R.X=90° for the elephant, but not for the cylinder. In C4D if we reoriented the cylinder, we’ll need to rotate it R.X=90° for both.
Important: Cylindrical projection doesn’t work like XYZ to UVW - when we rotate the texture it does all kinds of funky things around the various axes of the projection. Rotating the projection itself turns the whole projector in space, which is what we need in order to reorient it.
Let’s attach a Cylindrical projection node (or just a projection node set to “Cylindrical”) to our noise.
Once again, the noise starts out huge, so let’s use the Transform node to scale the texture itself (not the projection) and drop it down to 0.1 on S.X, S.Y, and S.Z. Now let’s unlock the aspect ratio and when we start increasing S.Z by itself, it stretches the noise toward the pinch point in the center of the face where the rings would be. When it hits 0.8 or so, we can start to see the pattern we’re after.
Seeing the noise more clearly
At this point, we can go back to our elephant and wood block. If we were using a DCC like C4D that let us reorient the cylinder, then we’ll notice the pattern is going the wrong way on our elephant/block geometry. To fix this, we just need to rotate the projection itself 90° on S.X.
The noise texture has a few built-in settings that will make our lives easier. To get random black marks, we want to crank the contrast, and then use the gamma slider as sort of a threshold to get the right amount of black vs. white pixels.
Lucky for us, there’s a Contrast slider in the Octane noise that’s set to 0.1. Let’s move that all the way up to 100. It’s now too dark overall, so to favor more light values over more dark values, let’s bring the Gamma slider down to 0.65. Now we can clearly start to see the pattern we’re after.
Refining the Rays
If we ask Claude what the dimensions of medullary rays for birch are, it’ll say something like 200-600 micrometers from the center of the tree outward, 15-40 micrometers thick, and 40-80 micrometers wide, which seems plausible. The issue is that we don’t have a good baseline for how large Perlin noise bits are, and even if we did, they’re being stretched and distorted already because of the cylindrical projection.
The interesting thing here is that we’re still sort of using tenet #1. Rather than going at it blind and trying to get the noise to work with MeshUV or XYZ to UVW projection, setting the texture up the way these rays really grow means we’re still mimicking the effect we’re after, we just have to eyeball the actual scale.
We want to push the projection over 0.1 on T.X (not the transform node) so we’re taking the wood from further out on the log. Because Cylindrical projection isn’t exactly how these rays are formed, we would get far too much distortion if we try going all the way out to 0.8 where our rings are.
Now that the texture is coming from the right place in the log, after a bit of trial and error, S.X=0.005, S.Y=0.08, and S.Z=0.16 seem like a pretty good set of values for the transform (values) node to get the scale we’re after.
Yes, this is confusing, but it starts to make sense the more we solve these issues. When in doubt, go back to more basic geometry to see what the values are doing.
Let’s add a note/comment to this section to make sure we remember it’s for the rays.
Follow-along File
If you’re following along, your setup should match up with 104 Medullary Rays Layer
The Eye
The last part before we get to recoloring is the eye. There are a few valid approaches to this that range from the new decal system to a UV texture, but in the spirit of keeping everything procedural and simple, we’re just going to use another Gradient Generator.
Let’s build a new one of those and hook it into the last Composite Texture Layer (#4), and remember to check “Enable” to turn it on.
Once again we want to set it to Radial, and hook up both a XYZ to UVW projection node and a transform value node to it.
So, first thing we’ll notice is that it turned our elephant and block of wood black - by this point we can intuit that it’s because the texture is 200 cm tall and our elephant is a few cm, so we’re only seeing the dark values in the middle of the texture. Let’s scale this way, way down to 0.004 in our Transform node so the middle ring is about the size of the eye in the reference photo. We can adjust that later if needed, but anything in this range should work.
The Gradient Generator starts off repeating the gradient which was great for our rings shader, but not great for an eye. The trick to stopping it from repeating is to change the Repetition mode to White Color. We’re using White Color here because the gradient starts black in the center and goes out to white - what we’re asking it to do is keep repeating white pixels after that.
We’re not after a cyclops elephant here, so let’s rotate the projection node (not the texture) 90° on R.Y.
The reference photo shows a sharp black mark for the eye, so we’ll want to use a gradient map (called Octane Gradient in C4D or Gradient Map in Standalone) to achieve this. It’s not strictly necessary, but always a good idea to change the Gradient Generator’s gamma to 1 if we’re going to be recoloring it using a Gradient Map. This is a complex topic which is explained in detail in the Linear guide toward the end.
Since we’re using this Gradient Map to crush the values, we only need a black knot and a white knot and just move them together so we have a sharp-ish black dot that’s about the right size. In Standalone this means building two new knots (a black one at about 0.2 and a white one at about 0.3). In C4D it just means moving the existing knots to about 10% and 20% (assuming we set the gamma to 1 in the Gradient Generator)
Last step is to reposition the eye - we can either do this in the projection or the texture transform node - it doesn’t really matter, but the values will be very different. Let’s use the texture transform node and move it -0.006 on T.X and 0.007 on T.Y. The values are tiny because we scaled the texture way down, so we’re just nudging this tiny circle over a small amount. If we were to move the projection, the values would be a lot larger since the whole projector would be moving.
Follow-along File
If you’re following along, your setup should match up with 105 Eye Layer
At this point we have all the bones of our texture ready to combine. In the next section we’re going to do that while recoloring them.
Part V
Finishing Up
Combining the Layers
In a real-world scenario, we probably would have gone through iterations already of turning on and off various layers to see how the textures worked with one another to inform decisions about the values. This guide was written to show the process more linearly to cut down on confusion, tweakiness, and word count (believe it or not).
Regardless of when we do this portion in our process, tenet #2: Avoid conflation is very important to keep in mind. We want to think about how to design the material in a way where if we do want to modify it, we need to tweak the minimum number of values to get good results.
Coloring is a good example of this. For this setup, our first thought might be to assign a set of colors for each layer, but it turns out that just using blend modes for 3 of the 4 layers gets us where we want to be, and then we can recolor the wood easily in the future by just changing the gradient map on the bottom layer.
Starting with the Rings texture
Once again, we’re going to want to do this one section at a time, so let’s uncheck the Enable checkbox in the Grain, Rays, and Eye Composite Texture Layer nodes (layers 2, 3 and 4).
Since the rings texture is the base layer, we need to make sure its Composite Texture Layer node is set to the Normal blend mode. If it’s set to any other blend mode, the real base layer will be black and the results will be way off as our layer blends in with it.
To recolor it, we want to do the same thing we did for the eye and use a Gradient Map (Octane Gradient), so let’s put one of those between the Gradient Generator and the Composite Texture Layer that it’s currently hooked into.
From here it’s a matter of picking colors. We can either try to pick them from our source image, ask AI, or just guess (or some combo of those). There are no real-world values to fall back on here for this specific stained wood, and any number of other factors like lighting, material properties, reflections, post processing, etc can alter the colors in the source photograph.
Asking AI “What is a good set of a light and dark base color for beechwood in hex values?” returns an okay starting point that we can adjust. In this case, ChatGPT gives us #F3DCC4 for the lightest color, and #C08A5A for the darkest.
After we plug those in and get a baseline, we can start playing with knots and color values to get closer to what we’re seeing in the reference. Either the stain, lighting, or white balance in the scene is making it more orangey, so let’s adjust a little to get closer.
Setting the furthest left knot to #BA6520, the furthest right knot to #D69356, and a knot at about 13% that’s #CC7E39 seems about right. Adding the third knot crushes in the darks a little to give a sharper falloff between the latewood and earlywood like we see in the photo.
Adding in the Grain
The next layer we’re going to add is the grain. Let’s check it’s Enable checkbox to turn it on.
Blend modes are divided up into different categories, and there are a LOT of them. It takes time to learn which ones do what, but there are a few basic go-tos. If we want just the darker pixels to come through, we’d use one of the Darken/Burn/Multiply type modes. If we want just the lighter pixels, we’d use Lighten/Dodge/Add type modes. In this case we want the underlying texture to be affected by both darker and lighter pixels, so we’d use one of the translucent type ones like anything with the word “light” in, hard mix, or Overlay.
After experimenting with a few of those, it looks like Overlay is the winner here - it doesn’t muddy up our colors and looks pretty good, but it’s really strong. We can dial it back in the Composite texture layer node by changing the opacity to 0.6 to further blend it in.
Turns out the grayscale values produced by our noise work fine with the texture color, so no need to recolor the grain as well. This is what we were talking about earlier with keeping the number of changeable parameters to a minimum to make life easier on ourselves.
Adding in the Rays & Eye
The last two layers are pretty easy, but we still want to enable them one at a time.
We really only want the dark pixels to show here, so we want to investigate the darkening-type blend modes (Multiply, Darkens, Burns).
After trying a few, Color Burn (Photometric/Color Burn in C4D) seems to give us a natural look here. Knocking the layer’s opacity back to 90% blends it in just a touch so it’s not as harsh looking and helps sell the look. Subtle, but easy and effective.
Finally, we want to drop in the eye. Similar to the rays layer, we just want the dark pixels, so after cycling through a few modes, it seems like the Multiply (Blend/Multiply in C4D) blend mode does the best job.
That wasn’t too bad because we set ourselves up for success earlier by building self-contained “modules” that we just had to connect together.
Follow-along File
If you’re following along, your setup should match up with 201 Recolor
Lighting
At this point, we have our Albedo channel about done. The material doesn’t look realistic yet because we’ve only isolated one channel. Let’s remedy that.
First things first though, Tenet #1: Real World Values. Nothing in the real world exists in a completely evenly lit sphere. This served us well for developing the Albedo channel, but it’s not going to interact great with the specular or bump channels, so time to get some better lighting in.
Small Studio 09 by Sergej Majboroda @ Poly Haven is a great material vizdev HDRI because it’s mostly monochrome and has a nice minimally varied light distribution and a few things in the background to add subtle reflections. This another good use for tenet #2 - we don’t want super bright lights or wild reflections that will influence our decisions. Let’s make a new Environment (Standalone) and attach an RGB Image to it with this environment, or a new HDRI Environment (C4D) and load our image in.
Important: HDRIs need to be set to Gamma=1 to work correctly
Follow-along File
If you’re following along, your setup should match up with 202 Lighting
Other Material Properties
In order to see what roughness will do, we need some specular contribution. Let’s set Specular to 1. Wood is pretty matte, so the Roughness should go all the way to 1. This particular finish isn’t very reflective, so we can reduce the Specular down to 0.5 to cut the glare and adjust later if needed.
Bump will help give it just a touch more realism and disperse the specular highlights a bit more. We want the grayscale values from the medullary rays and the grain to affect bump, so let’s make a new Multiply node and feed the Noise texture from both of these into it, and then run that into Bump. It’s a bit strong, so let’s reduce the height to 0.0003 (down from the default of 0.001).
There are other things we can experiment with like Normals/Displacement/SSS later if needed, but this is a good stopping point for our needs right now.
Scaling the final texture
Our final texture uses several projections that do not scale with the model. Since it’s based on real wood, if we apply it to a larger model (assuming it’s based on real-world values), it will look like it’s carved from a larger chunk of wood (the pattern will be a lot smaller, but still realistic), but if we’re expecting to take our elephant and make it 200cm tall and keep the pattern the same (or animate the scale) we’re going to be in for a world of hurt.
There are techniques to get around this by baking the texture or using Rest Attributes covered in the Baking Camera & Rest Position guide.
Wrap Up
At this point we got reasonably close to our reference. We could go back and tweak some of the values to get it even closer if we wanted, but the important part here is that we now have a much better understanding of how both real wood and a 3D wood texture works, and can use that knowledge to build a lot of different types of wooden objects in the future.
The final state of this walkthrough is here: 203 Final Material