Material Series
Version 1.0, Updated Sep 2025 using Octane 2025.3 and Cinema 4D 2025.3
~5350 words, average read time: 25 min
About this guide
This is a practical step-by-step walkthrough that covers building a texture in a non-MeshUV projection and then either using the Rest Attribute system or baking it to a MeshUV-friendly texture so it scales or deforms properly.
Downloads
Project files for this guide can be 💾 found here
This guide is also available in 📄 PDF format here
Introduction
We have this sculpture that’s a single mesh made up of a bunch of little unconnected pieces that are mashed together and overlapping. It’s not the best model in the world, but hey, making good models is your job. My job is to show you how to texture them in Octane ;)
We want to put one single gradient texture on it that spans the whole object, and we want the model to be able to scale and deform and have the texture stick to it. If we can avoid altering the mesh, that’d be great.
As we learned in the Projection and UVs for Octane guide, the easiest way to project a gradient across the whole model is to use a non-MeshUV projection like XYZ to UVW. The problem is that when we go to scale or deform the sculpture, the model “swims” through the texture.
Let’s look at how to build the gradient, and then two ways to solve the swimming problem.
Note: This walkthrough assumes you’re using Cinema 4D, but many of these concepts will translate into other host apps running Octane.
Part I
Setup
Getting Started
First thing we need to do is open up our starter file. The C4D file (and an ORBX for other DCCs) can be found here.
We’ll notice that we have an abstract sculpture, a few lights, a camera, a Universal material (not applied to the model) and a backdrop.
In the .C4D file, there’s also a null with the original cloner & effector. In order for this entire thing to work, the model had to be made editable, but it’s always a good idea to keep the original procedural bits around in case we need to tweak it.
We can get rid of the annotation by either deleting the tag or clicking it, going into its Display tab and unchecking “show in viewport”
Our goal is to make a gradient texture that spans the whole sculpture, top to bottom, so before we even make a material, we’re going to need to know some dimensions.
Finding the Scale Value
Non-MeshUV projections aren’t aware of the size/scale of the model, so procedural textures have to come in at a default, pre-determined size. In C4D, that size is usually 200x200x200 cm. In other DCCs, this may be different.
To get a texture to span the height of the model, we’ll need both the texture and the model to be about the same size. This means either scaling the model closer to 200 cm tall, or reducing the scale of the texture to match the height of the model. Either way is fine, but in this guide we’re going to scale the texture.
If we drop a cube in the scene and make it about the size of the sculpture, we’ll find it’s a little under 55 cm tall. The default texture height in C4D is 200 cm, so if we want it to fit, we can bring up our calculator and find that 55/200=0.275.
That’ll be roughly the scale we’re after for the height of this model. This doesn’t have to be exact most of the time, we’re just looking for it to not repeat and cause weird texture errors, so if the texture is a little taller than the model, it’ll just bleed off and look fine.
Nerd Method
Oh, we want to be exact? OK, fine. We can use Xpresso to get the bounding box of the sculpture so we know the actual height.
To start off, we need to add an Xpresso tag to something in the object manager (a null, the sculpture, whatever). When we double-click that tag, we get the Xpresso editor. Next, we want to drag the Sculpture object from the object manager into the Xpresso window (yes, you can do that). That creates a node for it.
From there, we need three other nodes that we can search for: Bounding Box, Vector2Reals (of course, duh), and Result. Bounding box’s Box size output goes into Vector2Reals’ input, and Vector2Reals’ Y output goes into the Result input (because we’re interested in the Y height of the model and don’t care about the X width or Z depth).
The Sculpture node starts out empty, so we need to expose an Object output so it can hook up to the Bounding Box’s Object input. We do that by clicking the red box in the upper right of the node and selecting Object (right there in the top level), and now we can hook those up and see the height is 54.402.
54.402/200 gives us 0.27201. How’s that for exact?
UVs
We’ll also want to take a quick look at the UVs. This section assumes C4D, but other DCCs should have the ability to automatically lay out UVs. If not, 3rd party tools are available that do this.
In C4D we can shift-double-click the UV tag and it’ll pop up a window that shows them to us. Turns out because of the way this model was constructed, it’s an absolute dumpster fire. The UVs for all the different parts are stretched and overlapping - there’s no way we’re getting a usable UV-mapped texture with this.
Fortunately we don’t need them to be laid out in a way that makes them easily usable with standard texture sets (otherwise we’d be here all day). All we’re looking for in order to use this technique successfully is that:
- They’re sized properly relative to one another.
- They’re not overlapping.
- They’re taking up as much space on the UV tile as possible (packed well). This allows us to get away with a lower resolution image which saves some VRAM.
Now that we can do in a few clicks.
Important: Let’s first make sure we pause the Live Viewer - this has caused issues with C4D’s UV edit tools in the past, so better safe than sorry.
Also Important: We need to make sure that either all of the polygons in the mesh are selected or none are. If just some polygons are selected, the UV tools will only act on those polygons. C4D does this even if we aren’t in Polygons mode at the time. Let’s go into Polygons mode (top-middle of the C4D UI) and then go to the Select menu and choose “Deselect All”.
Let’s make sure we have our Sculpture object selected and go into the UVEdit layout found in the top right.
In the Automatic UV tab in the bottom left, we’re going to want to:
- Select Cubic mode. This is going to work the best with the Baking Camera most of the time.
- Set our resolution to 2048x2048. This model probably doesn’t need a 4K texture and we can always bake it out at a higher res later if needed.
- Make sure that Preserve Orientation is OFF. This will help pack the UVs in better and we don’t care about orientation here since the baking camera will figure that out for us.
- Hit Apply. Voila! A good enough UV set.
Axis
The final step before we start in on the material is checking the axis of the sculpture mesh. If it’s not centered, it’s going to throw off all our calculations and we’ll be sitting there edging up the texture 0.001cm at a time until it looks right. No fun. C4D has an Axis Center tool we can search (Shift-C) for after selecting the model. We just need to be in Object/Model mode and hit Apply.
Material
The starter file came with a stock Universal Material. Let’s rename it to “Sculpture Mat” (or anything else you’d like to call it) and add it to our sculpture. The reflections are a bit harsh because of the area lights, so let’s add a little roughness in the Roughness channel to tone it down - how about 0.1? Great.
Now let’s add a Gradient Generator (the blue one, not the magenta Octane Gradient) texture in the Albedo channel. The results are unexpected, to say the least. Since the default projection for a texture is MeshUV, what we’re seeing is a left-to-right gradient overlapping our super fragmented UV map on the model.
All those little UV islands were laid out in the most efficient way possible to pack them into the UV tile, NOT to be anywhere near each other, so different UV islands get vastly different grays since they’re spread out all over the map.
To get the texture to span the whole model, we’ll need to use a different projection that ignores the UVs. Yes, we just painstakingly hit three buttons to get this UV set, but not to worry - we’ll need it later. Since what we’re after is a simple bottom-to-top gradient, XYZ to UVW projection is our best bet - it’ll get us what we’re after with minimal fiddling.
Let’s attach a Projection node to the Gradient Generator and choose XYZ to UVW. The model will be kind of a uniform-ish gray. The texture is still going left-to-right, but it’s now too big for the model at 200cm x 200cm. Since the model is only 40 cm wide, it’s only getting a chunk of grays out of the middle.
This is why we did the calculation earlier.
First off, let’s rotate the gradient so it’s going bottom-to-top. We can either do this in the projection node or by adding a transform node. The transform node is a little more obvious when we revisit the material, so let’s use that, and change R.Z to 90°. That will rotate the texture so it’s top to bottom.
That didn’t really do much visually because the texture is still 200cm and our model is only 55 cm high. Time to scale it down.
Let’s uncheck “keep aspect ratio” and use that calculation we made earlier to change S.Y to 0.275 (or 0.27201 for the more precision-based among us). Prest…. oh, wait, that still looks wrong.. why?
The original texture goes along the U axis (left to right). When we rotate the texture, it’s still going along the U axis, the whole thing just rotated now so it looks like it’s going bottom to top. If we want to scale it, we need to scale along U, which is S.X, so let’s move the 0.275 (or 0.27201) value in there, and presto! (for real now).
Making it Pop (sigh)
To make it more interesting, we can put an Octane gradient node (the magenta one) after the Gradient Generator node (the blue one) and find the Supersonic preset to make it more colorful. We may notice that the ramp is a bit weird though - there’s a lot more blue and purple at the bottom and a lot less red and orange at the top. The solution to this is to go back into the Gradient Generator node and set the gamma to 1.
Why?
This is a concept that is likely going to need its own guide, but the short answer is this: The Gradient Generator node is set to a non-linear scale by default (gamma=2.2). This is the right way to build a gradient that looks good to the human eye, but it’s the wrong setting if we want to use it as a utility map.
Predicting what the color remapping will do is far easier if we start with our source being linear and then lean on the remapping to place the colors where we want. To achieve that, we have to set the gamma to 1 (which is what linear means in this context).
The Scaling Issue
So ~2,200 words later, we have a nice bottom-to-top gradient, and since it’s set to Object Space (which is the default and what we want here), we can move the sculpture around and rotate it and the gradient will stick.
Scaling is another matter though - as we now know, non-MeshUV projections do not scale with the model since they’re not aware of the size of the geometry. If we take our model and make it twice as large, the texture will start to repeat, and we’ll have to go back in and recalculate the size. Not ideal.
What to do then?
We’re at kind of a crossroads here. As of 2025.1.2, Octane has a Rest Attribute system which allows us to create kind of a quick bake situation by pinning the texture to a vertex map. This solves our scaling problem, but if we were hoping to pass the maps off to other artists using other render engines (heaven forbid!) or sell them online or something, we’d need a more compatible solution. That’s where texture baking comes in.
We have more words to burn, so let’s look at both methods.
Part II:
Quick n’ Dirty with Rest Attributes
What Is It?
The Rest Attributes system is a way to cache a current state of the model at a particular frame and then use attributes from the cached version for our own nefarious purposes. So far we have one attribute at our disposal: Rest Position. Fortunately, that’s what we’re after here. We’re going to use this to generate a vertex map that we can use as sort of a pseudo-UV map to pin our texture in place so it scales and deforms properly.
It’s easier than it sounds - let’s get into it.
Rest Attributes in the Material
First off, we need to select our Texture projection node, and since it’s using a compatible projection (XYZ to UVW), we just need to check the “Use rest attributes” checkbox. That’s all that’s needed in the material.
Rest Attribute Tag
The next step involves putting the new Rest Position Tag on the mesh. This is found in the Tags menu in the Object Manager, under Extensions>OctaneRender…>Octane Rest Position Tag (or we can hit shift-C and search for “rest pos” and find it quickly that way).
The tag starts out yellow, meaning it has no data stored.
If we hit the Store rest position tag, it will create a vertex map, pin the texture to it, turn the icon green (meaning data is stored), and now we can scale the model and the texture scales with it. Cool :)
Problem is, if someone sees our killer sculpture online and wants to use it as a game asset in Unreal or something, advanced Octane stuff like the Rest Attribute system doesn’t work in their game engine. What now?
Part III:
Low & Slow with Texture Baking
What We’re Doing
To distribute a compatible version of our texture with our sculpture, we need to create an Albedo (or Diffuse, or Color, or Basecolor) map that’s matched to the UV map we set up so we can hand it off to someone that’s not using Octane.
To achieve this in Octane, we’re going to set up a special Octane camera called a Baking Camera.
This can be thought of as the reverse of MeshUV projection: Rather than overlay a flat texture on a UV map and use that to figure out where on the 3D model each pixel of the texture goes, the Baking Camera captures the location of all the texture’s pixels from the 3D model and puts those on the flat texture wherever they map to on the UV tile. The result is the Albedo/Diffuse/Color/Basecolor map that we need.
Important: We should really disable or delete the Rest Position tag before moving forward. It probably won’t mess with things (especially if we’re not altering the geo of the model), but why risk it?
Document Settings
Before we get started, we need to get our document settings right. The output we’re aiming for is a 1x1 texture, so we need to specify the pixel dimensions. Texture sizes are usually standardized depending on the target (a game engine may need one or several resolutions where an archviz app might need another, etc.)
If we remember a bit further back when we were messing around with the UVs, we decided to optimize our UV layout for a 2k texture. To match this, we’ll want to hit Command-B (or Control-B on the PC) to get to C4D’s render settings and set the Output size to 2048x2048.
Since there are a few pixels of padding between islands, it shouldn’t matter if we want to build a 1K or 4K texture later, but we can always redo the UVs to optimize for those resolutions if there are any slight texture errors when trying to put a different resolution map on.
Baking Camera
Let’s make a new Octane camera, call it “Baking Cam” so we don’t get confused, and click the Octane Camera Tag and choose Baking from the Camera type dropdown. When we look through that camera, we’ll see some weird stuff going on in the Live Viewer.
The issue here is that the baking camera defaults to baking EVERY texture for every material on every object at the scene at once. Not super useful.
Bake IDs
To tell Octane what we’re trying to bake, we need to use the Bake ID system. This is similar to the Object ID or Layer ID systems - everything starts on the same ID (1), and then we need to put what we’re trying to single out on an ID that’s not 1.
With the Baking Cam’s Camera Tag still selected, we’ll see the Baking group ID in the Baking tab - let’s set that to 2. Now the camera knows what to single out, but none of the objects match that.
So let’s put an Octane Object Tag on the sculpture. The fastest way is to highlight the sculpture object in the Object Manager, hit shift-C and search for “octane ob”. When we double click it from the search window, it applies it to the sculpture. In the Object layer tab of the tag, we can set the Bake ID to 2 to match what the camera was expecting.
Great, now when we hit render in the in Live Viewer we see what looks like our UV map, but with lots of little gradients all over it. It’s kind of like a jigsaw puzzle. When each of those texture islands are put back together on the 3D model, the gradients will line up and we’re done, right?
…nope
The Light & Shadow Issue
The biggest issue we run into during this process is that the Baking Camera is still a camera. This means it’s going to pick up all the material channels PLUS all the lighting and shadows in the scene. All of that lighting and shading will get baked into the texture if we save this image out.
If we were to add this texture to our model it would cause all kinds of problems. If it’s in the original orientation with the same lighting, all the highlights and shadows will double up and there will be texture errors (panel 2 above). If the lighting in the scene changes or if the model moves, the original lighting that was baked in will go with it and the current lighting will add to it, so it’s just going to be a trainwreck (panel 4 above).
What we’re really after is JUST the diffuse color contribution in this case (because it’s going into the Albedo or Color channel).
So how do we get rid of all the lighting and shadows?
Fixing It The Hard Way
(Don’t do this).
One way is to alter the properties of the material itself. This involves taking everything out of the albedo channel and putting it into a texture emission node and hooking that up to the emission channel. This then needs to be set to a power of 1 and surface brightness=ON.
Then the rest of the channels have to be reduced to 0 contribution (anything with color gets 0/0/0 or black, anything with float goes to 0).
Then we need to figure out all the optimal render settings for it and blah blah blah. This is super tedious and irritating if we’re trying a bunch of different looks out, or want to go back and alter it later and re-bake the map.
Fixing It The Easy Way
(Do this instead).
A much faster and better way to do this is to just use the Diffuse Filter pass. This does the same thing as all the rigamarole in the last paragraph without the rigamarole part. There are two ways we can access this - either via AOVs or the Info Channels kernel. The kernel method is a bit more straightforward and designed for this type of thing, so let’s go that route.
The Info Channels Kernel
The Info Channels Kernel was built to create utility maps and renders as opposed to beauty renders (which is what the Direct Light, Path Tracing, PMC, & Photon Tracing kernels are meant to do.
Info Channels is for things like Z-depth passes, bump and normal maps, wireframes, and other non-beauty things. The color/diffuse/albedo map that we’re building right now falls squarely into the non-beauty category.
If we hit the Gear icon in the Live Viewer to get to settings, the long bar at the top of the Kernels window lets us pick our kernel. Let’s drop it down and pick Info channels. The only other thing we need to change here is to set the Type to Diffuse Filter (filters out everything that’s not Diffuse). That will give us just the color data without any of the lighting and shading.
When we hit render now, our map will be a lot brighter and more colorful, but more importantly, correct.
Important: It’s also good practice to NOT use the denoiser when baking maps. It can lead to weirdness around the seams.
Saving the Texture
We can save this out of the Live viewer once it’s done rendering (should be really fast since it’s not getting bogged down with rough reflections or caustics or other GPU-beating things). If we head up to the Live Viewer’s File menu and choose Save image as…, we get a save dialogue box.
Important: The default settings are correct for this walkthrough, especially the Color Space being set to sRGB. We don’t want to bake in ACES or AgX or other OCIO tone mapping - even if that’s what we’re using in our final render - otherwise it’ll double the tone mapping when it’s brought back in as a texture and look terrible and we’ll be sad.
8-bit PNG is typically fine for a diffuse/albedo/basecolor map meant to be used in a wide variety of situations (and different render engines) like what we’re producing here.
Reapplying the Texture
Let’s make a new material, bring in an Image Texture node with our baked map and plug it into the Albedo channel. To make sure it looks the same as the original, we’ll want to put in the same Specular (1) and Roughness (0.1). Let’s add this to our sculpture and see what we’ve got.
Now we just need to look through our original camera and set our Kernel back to Path Tracing. We can also reset the resolution to where it was to save some time (1280x1280), and when we hit render, it should look the same as the procedural version of the material.
We can then use the A/B compare feature in the Octane C4D plugin to make sure we followed all the steps right. First let’s let this new render finish, and then go to the Compare menu in the Live Viewer and select Store Render Buffer. Now let’s put the original procedural material back on the sculpture and let that finish rendering. If we grab the vertical bar between the two renders and drag it left and right, we can make sure it matches up.
We can export this model and include the texture map that we baked and make big bucks off this sculpture as an asset that’s compatible with just about every engine out there.
Part IV:
Expert Mode - Linear Workflow
Baking and Tweaking
We’re going to look at one more use case here. What if we’re happy with our basic gradient design, but now we want to try out a number of variations for the color scheme while keeping the ability to scale the model?
Honestly, since 2025.1.2 (which just came out during the course of writing this guide), we’d just go back to the Rest Attribute system since it’d be easier, but let’s just say we’re doing our color explorations in Unreal or Unity or need to use an older version of Octane for some reason.
What we can do instead is bake out a UV-friendly linear grayscale map to put the right pixels on the right polygons, feed that back into the material to replace the Gradient Generator, and then recolor that using the same Octane Gradient.
Prepping the Material
In our original procedural material, we’ll want to disconnect the Octane Gradient, and keep the Gamma at 1. We’re kicking the color mapping down the line, so our settings are still correct, even if they look odd in the Live Viewer.
Exporting the Map
Let’s make our Baking Camera active again and make sure we’re in the Info Channels kernel. Now we can start the render again.
When we go to save our texture this time, we want to export a map in a linear color space (Gamma=1) because it’s going to replace the linear gradient generator that we set up
Let’s change the File type to EXR instead of PNG. Because it’s designed to work with linear data, EXR is a better and more efficient option for what we’re doing here.
16-bit is good enough for our needs (32-bit is more for displacement, fine normal maps or serious z-depth compositing with tricky backgrounds or volumes where every shade of gray counts).
PIZ compression still remains the best quality vs. file size compromise.
Interesting note here - the EXR with PIZ compression is actually smaller than a 16-bit PNG version (and both take up the exact same amount of VRAM), so there’s no reason not to use EXR unless the target render engine doesn’t support it for some reason.
Final Recolorable Material
Let’s make sure we remember to set the kernel back to Path Tracing or it’s going to look awful flat.
Now we can bring our linear export into an Image Texture node and set the color space to non-color data (which is the same as Gamma=1). All this talk about making sure things are linear goes right out the window when the Image Texture node thinks it’s sRGB (which it’s set to by default), so we have to tell it not to do that.
More on color spaces can be found in the Color Management Overview guide.
Now we can run that into an Octane Gradient, set it to Supersonic and we’re back where we were… except… we can still scale the model however we like AND change the gradient all day and it will still work.
Part V:
TL;DR: Just List Steps Plz
This is here for when you have a good idea of how to do this, but haven’t done it in a while, don’t want to miss any steps, and don’t want to go through the last 4000+ words just to knock out a map or remember how to use rest attributes.
Rest Attribute (Position)
This will allow us to scale or deform the model without the non-MeshUV textures swimming, but it limits us to Octane (can’t build game assets this way).
- Attach a projection node to the texture, make sure it’s using a projection that supports Rest Attributes (XYZ to UVW, Triplanar, etc).
- Check “Use rest attributes” in the Projection node.
- Put a Rest Position tag on the mesh - it should start out yellow (no data stored)
- Pick the frame you want to use as your base state (before deformation or animation or whatever), and hit the Store rest position button in the Rest Position tag.
-
Scale the model - the texture should now stick.
Baking a Texture Map
These steps assume we’ve already created a texture using one or more non-MeshUV projections (box, triplanar, etc), and now we want to bake it into a UV-compatible texture.
-
Make sure the UVs of the model are sized properly to one another, don’t overlap, and are packed well. The orientation and makeup of the islands do not matter for this process.
In C4D: UV layout>Automatic UV, use Cubic mode, set a resolution, preserve orientation OFF, hit Apply. -
Set the resolution of the render . This should be in a 1:1 ratio and usually works best in powers of 2 (1024x1024, 2048x2048, etc).
In C4D: Ctl-B or Cmd-B, Output section on the left. - Make a new Octane camera, set it to Baking Camera in the Octane Camera tag under the Thinlens tab > Camera type.
- Set the camera’s baking group ID to anything other than 1 (2, 3, 4, etc).
- Put an Octane Object tag on the model, and in the Tag’s Object layer tab, set the object’s Bake ID to the same value that we set the camera’s baking group ID to (use 2, 3, 4, etc).
- Click the reticle to look through the baking camera - it should like the object’s UV map, but with textures instead of UV outlines.
- Go into the Octane Settings (gear icon), choose the Info Channels kernel and then pick “Diffuse Filter” as the type.
- Render.
-
Go to the File menu in the Live Viewer and select Save Image As…
- File type should be PNG for Color/Diffuse/Albedo maps, or EXR for other types of maps (bump/normal/displacement/specular/etc.)
- Bit depth should be 8-bit for Color/Diffuse/Albedo, 16-bit float for other maps, or 32-bit if we’re running into problems with stepping or other artifacts with normal/displacement
- Color space should be sRGB for Color/Diffuse/Albedo, or Linear sRGB for most other maps. Whatever color space we’re using for the source texture is what we want to bake into the file we’re making.
- The best compression as of this writing for EXR is PIZ - Hit Save and put the texture in the /tex folder for the project.
- Make a new material or replace the generated texture with the baked one we just saved in the current material, and make sure to set the color space appropriately in the Image Texture node (sRGB for Color/Diffuse/Albedo, non-color data for most others).
- Set the kernel back to PT/DL/whatever and render. Use A/B Compare to test it against the original material.
Wrap Up
If you made it all the way through this guide, you should have a good idea how to stick textures to models and bake out UV-friendly maps for use with other render engines.