By Brian Freisinger

November 5, 2012

(Reminder: Click on images to enlarge)

A common request I get from compositors, is for an XYZ WPP pass in addition to my standard passes. The XYZ or World Point Position pass can be used in multiple ways, from doing some re-lighting in Nuke, to creating atmosphere (ground fog) and a variety of other uses.

The XYZ WPP pass doesn’t appear in the Render Elements tab, so you’ll have to create it using the vrayRE_Extra_Tex

The vrayRE_Extra_Tex is a very powerful and often underused render element. You can plug almost anything into it to create a custom pass. For example, you can plug the VrayDirt shader into it and kick out basically an ambient occlusion pass. Again, that’s just one of many things that can be plugged into this node to get almost any pass or variant of pass out painlessly and easily.

For this one I just created a vrayDirt shader in the hypershade and dragged and dropped it into the vray_ExtraTex “Texture” field. (Make sure you hit enter after doing this so it connects, otherwise you’ll be wondering why it doesn’t work)

Creating the xyzWPP pass

The XYZ WPP pass takes a little more work, but isn’t difficult.
I’m just going to set up some spheres in my scene in a loose array so we have multiple objects that exist in multiple xyz coordinate space to make our pass pretty obvious when we render it.

Next I’m going to create my vrayRE_Extra_Tex pass.

Make sure you open the vrayRE_Extra_Tex up in the attribute editor.
You’ll see some empty fields.
The first field we want to fill is the Vray Name Extratex, without a name in here it’ll be a blank field in the VFB, and hard to find as a comp pass later.
So I’m just going to name mine xyzWPP

Ok, so the xyzWPP pass has now been created, but the render element itself needs to get information, so we’ll create a samplerInfo node in the hypershade.

So we’ve got our samplerInfo node and our xyxWPP pass created. Next we’ll need to get them to talk, so opening up the connection edtor, we want to load the samplerInfo node on the left and the vrayRE_Extra_Tex, on the right.

You can see I’ve expanded the “pointWorld” field on the left, and the vray_texture_extraTex on the right.
So now it’s a simple case of connecting pointWorldX to R, pointWorldY to G, and pointWorldZ to B

That’s it. You now have an xyzWPP pass created for your scene.

Rendering it can be a bit deceptive. It may not look like there is any gradient to your passes.
The render will all channels on should look something like this

So I’ll load this pass into Nuke, add a shuffle and a grade and take a look at the “G” channel which is assigned to our Y

I’ve added the grade so I could see a better representation of the gradient I would expect in this pass.

And that’s pretty much it. You can look at your X and Z channel and see how they look at this point.

For more info about using xyzWPP passes check out some of The Foundry’s tutorials.

Multi-Tile UV Mapping/Displacement Part 4

By Brian Freisinger

June 9, 2012

(This tutorial is designed around Maya and Mudbox. Several of the concepts here can be transposed into other 3d software packages that have UV grid control)

This is a continuation of the multi tile UV mapping tutorial.

Click on the images to enlarge for more detail.

To understand how to layout the ‘tiles’ for maya and mudbox please refer to Multi-Tile UV Mapping Part 1

Here we will cover both how to use displacement with multi-tile UV mapping, as well as an alternate method of assigning multi-tile color.

Why 32 bit?

(if you already use 32 bit and don’t want a history lesson you can skip to the ‘how’ part)

First off, we’ll discuss 32 bit displacement vs 8 or 16 bit.

I highly recommend using 32 bit .exr format for anything you’ve done custom sculpting on in Mudbox or Zbrush.

8 and 16 bit have a variety of problems, so does .tif format.

The main problem with anything less than 32 bit is it only goes in a single normal direction. I.E. it’s only 16 (or 8) bit in or out.

What’s this mean? If you sculpt a landscape and have hills and valleys, and export a 16 bit, it’s either going to have only the hills or the valleys. To get both you’d need two 16 bit maps, one for the positive normal values (the hills) and one for the negative (the valleys)

16 in/16 out/water level

32 bit will handle both at the same time, so we only have a single file to work with.

Another pitfall to 16 bit or less is the need to adjust the map to display correctly. The user may need to shift the displacement +/- to get it to render 1:1 as expected from the sculpt.

32 bit knows about this internally based off the scale of the object, so it’s simply assign and render to get the same levels of displacement one would expect to see based off your sculpt.

IMPORTANT:

Because 32 bit does recognize the scale of the object you started with, change the scale AFTER you’ve sculpted and extracted displacement maps can have unexpected and mostly undesirable effects on your displacement render.

Scaling the object up will reduce the displacement amount to almost non existent, and scaling an object down will result in it looking ‘exploded’ or blown up.

So before painting a 32 bit displacement map it is very important to ESTABLISH THE SCALE OF YOUR OBJECT. If you paint on an object that is 5 cm across only to find out it needs to be 5 meters in the scene will cause some problems for you.

There are some workarounds using Nuke to change the scale, and it is possible to scale up and object in mudbox and then re-extract if a mistake is made, but it’s better to start with a properly scaled object.

Last thing. Mudbox saves an LZW compression tif. Bluntly this is horrible. Maya won’t read it, so you need to take it into Photoshop (which clamps your 32bit map and ruins the high/low details) or into Nuke to save it out in a non-compressed format. The EXR format saves properly, is lighter than tif and retains far more fidelity to the original sculpt.

In my personal opinion the whole .tif format is horrible. I use .png for color and .exr for displacement.

Ok, we’ll now move on to the how.

Extracting the displacement map.

multi tile layout

Using the same cube and six tile UV layout from part 1 we’ll paint a quick displacement map in Mudbox.

Two quick protips here:

“bleed”

One it’s good practice to ‘bleed’ your UV map at least 5% away from the edge of the 0,1 grid tile.

The reason here is mudbox might return some errors in the edge of the displacement if it doesn’t have some room for bleed calculations. This also applies to multiple shells in a UV tile. If you have several UV maps separated out in a single tile you should have space between each shell to get a good extraction.

Two, as discussed before double check your scale before exporting an object to mudbox.

My cube is 5 cm in XYZ for this tutorial.

subdivision on cube

I am also going to pre subdivide the cube now so it keeps it’s ‘cubeness’ instead of turning into a sphere on subdivision.

Major work of art. VES award here I come.

I did a quick displacement sculpt in Mudbox, nothing to fancy just enough to get the point across.

The point of this is to get the sculpt detail and the highs and lows to show up the same in our render.

level 0 issue

Another catch is mudbox has a nasty habit of effecting the base model when you’re sculpting.

So if we look back at our level 0 model we can see the high and low peaks I sculpted in are in the ‘zero’ level model.

I don’t know if this is a bug or a feature, but it’s a problem. You have two solutions here.

One is to export this model and use it as your new base mesh in Maya.

I do this often.

renamed sculpt

But in the event your model is so far down the pipeline this isn’t possible then I suggest the following.

Select your sculpted object and rename it to something like ‘highrezExtract’ or similar.

Original and Sculpt in scene

Next in the same scene import the original pre sculpted object.

You should now have two objects in your scene. One you sculpted and the original one you exported from Maya.

The yellow object is the selected ‘high resolution sculpt, the other is the one I started with by doing a Maya OBJ export.

“extracting from two models”

Now we  need to extract the displacement maps.

For mudbox that’s: Maps -> Extract Texture Maps

Obviously we’re doing displacement.

But because we have two objects we’re going to do a ‘difference’ between the two. So when we select our models we’ll want the original in “Target” and the high resolution in “Source”

This is why renaming them is handy. To know which goes where without confusion. Extraction can take a long time, so minimising mistakes is handy.

We also have to use the “Ray Casting” method because we’re doing a compare/difference between the two.

Closest to Target

One thing of note here:

I want to extract a 32 bit map with both in and out, so I need to make sure “closest to lowres mesh’ (i.e. closest to target) is selected. This will look both inside and outside the mesh.

There are several other tricks and settings in mudbox for getting a good displacement map out, but they can be found in tutorals all over the web, so I’ll leave that to you.

One little trick though is figuring out your search distance. I know my cube was 5cm so I want to make sure my search distance goes out beyond that since I sculpted “out” quite a bit.

I eventually made the search distance 1.0 so the high peak on the top wouldn’t clip.

file name and EXR type

Another quick tip:

I named my file cubemaps_01 not cubemaps_v01

A lot of people like to put a v for ‘version’ behind their file iterations. While not a bad practice it can come back to haunt you with Mudbox. Mudbox uses v and u to siginify which UV tile it belongs to (see previous tutorial)

So if I had named this cubemap_v01 instead I’d get a file outputs that said:

cubemap_v01_u1_v1.exr, cubemap_v01_u2_v1.exr, etc

Not only is this confusing on a quick glance when you need to assign your maps to the shader, it will also confuse mudbox if you need to reload your maps back onto a mesh in mudbox (Sculpt using map). Mudbox won’t be able to figure out what map belongs to what tile. So I strongly suggest not using the ‘v’ or version letter for your displacement maps.

Also use the OpenEXR 32 bit floating Point RGBA file type, not the Black and White.

I can’t speak for other programs, but Maya has a problem reading the Black and White.

4k maps

My maps are now extracted (I did 4k maps for detail)

As we’ve seen in the previous tutorials, I have six maps with coordinates exported (one for each tile)

Now we’ll need to create a shader to render these in Maya.

I’m using Vray, but this technique works for Renderman, Mental Ray or almost any other render engine on the market.

Creating the multi tile displacement shader

In my previous tutorial for color maps I used the layered texture shader. I’ve actually moved away from this because, well it sucks. I’m currently using the “plusMinusAverage” node for both my color and displacement.

The main reason here, is the layered texture shader in addition to being rather buggy, also does not respect negative values.

That means anything you paint going ‘IN’ won’t show up or worse show up as ‘clipped’ when you render. That’s a huge problem.

+/- Average

So the solution is to use the +/- average node.

That node will come in handly later, but lets start by setting up our shader.

I’m using Vray here so I’ll create a Vray shader. But if you’re using another render engine the principle is the same.

Create displacement node

I need to set up/create a displacement node that’s hooked into my shader.

for Vray I need to go to the SG (or shading group) and create a file node.

What this is doing (for Vray) is creating a vray native displacement node.

Again, if you’re using Arnold, Renderman, MentalRay, etc, hook your displacment node up.

displacement node

Once I’ve created it I actually delete the file node itself. I just need the displacement node to hook into later.

Attach luminance to displacement.

Next we’ll create a luminance node.

(NOTE: If you’re using this technique  of  plus/minus Average node instead of a layered shader for color maps DO NOT use the luminance node or it will change all your color maps to black and white)

This is the big trick to getting Maya to recognize negative values in a multi tile displacement set up. Without this node we will have our displacement all going “out” but nothing going in. So best case scenario it won’t look exactly like the sculpt, worst case it’ll clip and you’ll have smooth artifacts in the render. So save yourself pain and make a luminance node.

So if we go back to the displacement node we made, we’ll be replacing the file node we deleted with the luminance node. The easiest way to do this is just middle mouse drag the luminance node into the Displacement field of the displacement node.

If you use the connection editor it’s the ‘outvalue’ of the luminance node to the ‘displacement’ of the displacement node.

Attach +/- Average to Luminance

Now we’re going to use the +/- Average node we looked at earlier.

So create a “+/- Average” node and then middle mouse drag it to the “Value” field in the “Luminance“ node.

In the connection editor it’s the “3DOutput” of the +/- Average node connected to the “Value” of the Luminance node.

Create six “input 3d fields”

Now we’ll need to create slots in our +/- Average that will connect with our multiple displacement files.

This tutorial has 6 files, one for each side of our cube, so we’ll need to create six “slots”

So, select the +/- Average node you’ve created and go to the attribute editor.

You’ll see a field called Input 3D, and the option button to “Add New Item” if you click on this 6 times, you’ll now have six fields ready to be connected.

Create file node

We’ll now need six file nodes to hook up to the Input 3D field

There are a few things we’ll need to do with the file nodes next. A lot of these were covered in the previous multi tile color mapping tutorial, but we’ll go over them again.

File Node Attributes

Open the Attribute editor of your first file node.

FIrst I’ll load my first displacement map in which is cubemaps_01_u1_v1.exr

Next I’ll make my Default Color a solid black. If you fail to do this with either color maps or displacement maps you’ll get some rather undesirable effects. Because the node we’re using is additive we don’t want any other color introduced. I’ll spare you the long story, but just make sure you’re set to solid black. If you render looks weird, double check you did this.

Next we’ll go over the the place2dTexture node which is attached to the file node you made.

In here we’ll have a couple things to change.

Because this is our first map the “Translate Frame” values are left alone.

Mudbox numbers it’s first tile u1_v1, but in Maya it’s u0_v0

No, I have no idea why they do this.

Wrap U and Wrap V need to be unchecked. We have multi tiles, so we want one per tile at this point.

Just so we’re clear, I’ll load up my next file which is cubemaps_01_u2_v1.exr

next map

So you can see I loaded in cubemaps_01_u2_v1.exr

I made sure the default color was black (you have to do this for every node)

And in the place2dTexture node I’ve turned off the Wrap U and Wrap V again.

The Translate frame field is now set to 1 and 0

I’ve shifted it over 1 tile in u space, and none in v space.

u1_v1 was 0 and 0

u2_v1 is 1 and 0

A tile such as u5_v3 would be a translate value of?

4 and 2

It’s easy to loose track of this stuff when you have a lot of displacement tiles to keep some notes and double check your work often.

So do this for the last 4 file nodes. The should number up to 5 and 0 in Translate Frame

all nodes created.

Your hypershade should now look like this

We’ll now need to hook up the file nodes we created to the +/- average node.

Remember the six slots we made in the +/- Average node Output 3D field?

The file nodes will get attached to those.

Connection Editor

Open the connection editor (Windows->General Editors->Connection Editor)

Select the first file node and click “Reload Left” on the connection editor.

Select the +/- Average node and click “Reload Right” on the connection editor.

Now select “outColor” in the left column.

Expand the Input 3D fields by clicking the + sign and you’ll see the six fields we created earlier.

Select the first field “input3D[0]”

We’ve now established the connection between the file and the +/- Average node.

We’ll see the line appear in the hypershade showing the connection.

Now it’s a simple matter of doing this for the next 5 file nodes.

Just click on the next file node in the hypershade and click “Reload Left” in the connection editor again. Hook the next file nodes “outColor” to the next free field, “input3D[1]

Etc etc.

The connection order to the +/- Average node isn’t important.

The order of how they’ll read in render has already been established by the Translate Frame field in the place 2dTexture node.

displacement shader network.

When everything is finally hooked up your hypershade graph should look similar to this.

Make sure your shader is assigned to your object, also make sure you’ve flagged whatever subdivision surface attribute your render engine has for the object otherwise you won’t see very much.

Now we’ll render the scene.

Multi Tile Displacement Render

Success. It looks identical to the sculpt.

Basic troubleshooting for renders that don’t work.

Do I have the right files hooked up?

Did my displacement extractions actually work properly? (view them in Nuke or Photoshop to check)

Do I have my tiles and default color set correctly?

Did I remember to hook up a Luminance node.

Is it all piping into the correct displacement node.

And that’s it. Enjoy your multi tiling displacement.

Brian Freisinger

Feb 19 2012

UPDATE: May 7 2012 – The script wasn’t working correctly in Maya 2012 and Vray 2.2. It’s been updated to now work properly.

 (This tutorial requires Maya 2011 or higher, Vray 2.0 and Nuke or AfterEffects/Photoshop)

Click on any image to enlarge.

For the most part, the vray render elements are very straight forward and easy to access (not to mention easy to set up for composite)

In my opinion, the only one that requires a little more fiddling, as well as opens up a wide variety of user mistakes is the vrayRE_Light_Select.

This tutorial will only cover very basic light pass/compositing techniques to demonstrate the Light_Select technique and introduce a nice MEL script to make your life easier.

Figure 1. Turn on the VFB

The first thing necessary for working with your render elements is to switch over to the Vray VFB (Vray Frame Buffer) to view your images and passes. This will also allow you to quickly view your images in both linear and SRGB color space.

Figure 2. Three Light Scene.

I built an simple example scene with a sphere and ground plane. In addition I created three Vray rectangular lights for standard three point lighting.

(Standard maya lights also work for this, but I prefer using the Vray native lights)

You’ll notice right away I’ve named my lights and objects. It’s just a good standard practice.

It can be as complex or simple as you like, but later on knowing which light you’re looking with or modifying in compositing makes it priceless.

Figure 3. Basic Render Elements for Comp

The first thing we’ll do is set up our Render Elements found under the Render Settings.

You’ll see a huge list of possibilities under this tab, but for simplicity we’ll just do one of the more basic setups.

As I mentioned before, we’re just going to focus on these basic controls since the point here is about Light Passes, not advanced compositing and pass management.

Figure 4. Specular Material

A little note about the specular pass and specular materials in Vray.

More spec and less reflection on an object is controlled by the “Reflection Glossiness” in the Material Editor.

Glossiness set for a mix of spec and reflection.

If the Reflection Glossiness is set for 1.0 you’ll see no specular whatsoever in the spec pass. It’s all being pumped through the reflection pass. Great for a mirror ball, bad for a bowling ball…

So for our test I want a mix of both, with hot spec we can see, hence my .632 range.

Figure 5. Render in SRGB color space.

Now with the lights set, material set and render elements set we can render.

Figure 6. Linear Color Space button.

To switch between linear and SRGB color space you need to click on this button.

I will be writing a tutorial in the future on Linear Workflow, but if you’re unfamiliar with it basically in Linear color space the image should look far darker than the SRGB space.

SRGB is how we’re seeing it on our monitor, Linear is the “true” color space and gives us more room to move in compositing especially with our whites/blacks and other post correction.

Figure 7. Lighting Pass Only.

Next up is our ability to see our passes using the VFB.

What we’re looking at in the “lighting” pass is simply the combination of the shadow and diffuse pass. We’re also left with very limited control of the lights.

Figure 8. Basic Nuke Comp

If we were to write these out for compositing they’d be combined with a Plus Merge in Nuke (Linear Dodge/Add in Adobe products)

So, how do we break each light out separately?

Figure 9. Create a “Light Select” pass

We’re going back to our Render Element Tab in the Render Settings and a new pass.

At this point we’ll need  to use the VrayRE_Light Select to isolate our lights.

As a test we can  just set one up quickly and hook into the render.

Just double click on it as you would any pass and it should appear in the right column.

Figure 10. Naming your Pass

Just like we wanted to name our lights earlier, we’ll want to name our Light_Select to know which light it’s controlling.

Let’s start off by using the keyLight for our test.

I’m just changing the fields highlighted in green.

The top one effects how it’s seen in the render elements tab as well as the outliner.

The field below it in green effects how it’s seen in the next step, the set editor.

Currently the “Type” (at the bottom of the image in Figure 10) is set for “Normal”

We’ll get into the more advanced functions of this later.

Just because the pass was created and named the same as the light doesn’t mean it automagically knows which light to connect to unfortunately.

So we’ll have to open up the set editor.

Figure 11. Finding the Set Editor

The set editor is found under: Windows ->Relationship Editors -> Sets

Figure 12. Set Editor Connection

Once the window comes up any Vray Light Select element we’ve made should show up in the left column. This is also why naming your light pass and light is relatively important.

Simply select the light pass on in the left column, and then select the correct light in the right column. In our case it’s the keyLight_pass connected to the keyLight

Figure 13. Key Light Pass

Now if we re-render our image with the VFB active we can look at our keyLight_pass

We’ve got the light now seperated, but comparing it to the lighting pass and the specular pass we can see that the new pass (keyLight_pass) has not only the lighting, but the specular combined. This will be a problem later on in compositing since generally having your light pass and spec pass separated give a lot more control.

Figure 14. “Types” of Light Select

Looking back at the keyLight_pass in the attribute editor we can go down to the bottom and see some options under “Type” : Normal, Raw, Diffuse, Specular

We left it at default, so now we’ll switch it over to “Diffuse” and re-render the image.

Figure 15. Setting up the diffuse pass

I’m also going to take the time to rename my pass from “keyLight_pass” to “keyLight_diff”

The reason being, we will have to connect up a “keyLight_spec” pass seperately if we want that as an individual control. When they write out a multichannel EXR or single files you’ll want to know what’s what when putting the comp together. It’ll also help diagnose problem using the VFB

Figure 16b. keyLight_diff / diffuse pass only.

The new render shows   that we lost all the spec from our first render.

That’s good, but we’ll need to make another pass to get the spec and hook it up in the set editor.

Setting this up for production at this point would require six passes just for the lights.

(Three Diffuse and Three Specular) Doing this manually can be a major pain.

First off it’s easy to make a mistake. I’ve often forgot to set a pass to be diffuse, or accidentally set two to be specular. Forget to connect a new pass up in the set editor. Lost all my passes and connections when Maya decided to be helpful and ‘clean up unknown nodes…’ etc etc

So I wrote a mel script to do all this for you.

I walked through the process of doing this manually so we’d understand what’s going on under the hood.

Ok, on with the script:

Here’s the code:

////////////////////////////////////////////////////

//Create Vray LightPass Render Elements//

//Dec 2011

//Updated May 2012 for Vray 2.2

//Brian Freisinger

//faust@disopolis.com

//www.disopolis.com

//Feel free to steal, edit, modify.

///////////////////////////////////////////////////

//Call selection list

global proc vrLightPass () {

//Call selection list

string $vRE_Light[] = `ls -sl`;

for ($selection in $vRE_Light)

{

string $vrayLS = $selection;

string $diff = "_diff";

string $spec = "_spec";

//create diffuse pass

string $diffs = `vrayAddRenderElement LightSelectElement`;

string $vRE_diff[];

$vRE_diff[0] = $diffs;

//set diffuseFLAG

setAttr "vrayRE_Light_Select.vray_type_lightselect" 2;

//Set render outputname for diffuse

setAttr -type "string" vrayRE_Light_Select.vray_name_lightselect ($selection + $diff);

rename $vRE_diff ($selection + $diff);

//create spec pass

string $specs = `vrayAddRenderElement LightSelectElement`;

string $vRE_spec[];

$vRE_diff[0] = $specs;

setAttr "vrayRE_Light_Select.vray_type_lightselect" 3;

//Set render outputname for spec

setAttr -type "string" vrayRE_Light_Select.vray_name_lightselect ($selection + $spec);

rename $vRE_spec ($selection + $spec);

//Set relationships

connectAttr ($vrayLS + ".instObjGroups[0]") ($vrayLS + "_diff.dagSetMembers[0]");

connectAttr ($vrayLS + ".instObjGroups[0]") ($vrayLS + "_spec.dagSetMembers[0]");

}

}

///endcode///

You can also download it here if the wordpress formatting throws you some errors.

Start by sourcing the code.

Then select the lights you want to make passes out of.

I created a keyLight, fillLight and rimLight so I’ll select those three.

then in the command line type

vrLightPass;

and press enter.

Figure 16. vrLightPass.mel script

Now I’ve got six passes, all properly named and all properly assigned.

I really don’t need the original lighting pass or the original specular pass anymore, but I keep them around so when I comp the shot I have something besides the beauty pass around to make sure I got everything right.

Figure 17. Rim Light Pass

So now we re-render the image and we’ll take a look at the rimLight_spec pass.

So that’s it. All our light passes are broken out.

Be aware, you CANNOT break out your reflection per light, the render engine doesn’t work that way. There are comp tricks using the light or spec pass to dial up or dial down your reflection per light, but as a pass, it’s all or nothing. Same goes for Refraction.

Figure 18. Final Composite

Once you write out your passes compositing them is pretty simple, in Nuke it’s all merge plus nodes. (Or linear burn (add) in adobe products)

Figure 18b. The Nuke Comp

Here’s a quick close up of the Nuke Script

And that’s basic light pass/compositing with Vray.

 Brian Freisinger

October 18, 2011

Update: June 10, 2012 – To skip directly to how to set up for displacement jump ahead to part 4 of this tutorial series.

Also I’m no longer using the layered texture shader method and instead using the +/- Average node method as seen in Part 4. I’ll be updating this tutorial to reflect that in the future.

At the end of Part 2 you should have ended up with an object (Cube Primitive) laid out with multi-tile UV maps, and six texture maps you extracted from Mudbox.

There are now two ways you can assign your textures in a shader.

Again this applies to both texture and displacement mapping, but for this part of the tutorial we’ll just be looking at simple textures.

Let’s start by reloading the original cube scene you should have saved and then exported to Mudbox. If you forgot, just import your cube .OBJ you used in Part 2.

Simple Setup:

The first way is the down and dirty face by face assignment. I rarely use this unless I’m in a hurry or just want to run a couple tests without setting up a shader network.

It’s pretty simple to set up.

If we’ve got six tiles, and six textures, we simply create six shaders.

Figure 19. Shader per Face

I’m using Vray here and creating VrayMTL shaders, but this will work the same with Lamberts, Blinns or anything else.

You’ll also notice I named them with a u#_v# so I can keep not only my surface assignments straight, I can also quickly identify which texture goes with which shader.

Figure 20. Select each face and assign proper shader.

Now you simply grab each UV tile in order and assign the Shader to it.

This can be pretty tedious, but it’s simple and fast for diagnosing texture quality, or if you just want to check a couple of displacement maps on the fly without setting up a more complex network.

Figure 22. The correct texture tile for the correct shader.

Once that’s done, it’s pretty straight forward texture assignment per shader.

Figure 23. Make sure there is no Transparency.

There is one ‘gotcha’ when using .png files generated from Mudbox.

If you open the file in PhotoShop you’ll see it’s on ‘Layer 0’ with no background. Maya thinks that the empty background is a full alpha channel. So when it’s assigned to a shader, Maya tries to be helpful by adding a transparency or opacity channel.

So be aware, you either have to break the connection or lock the channel before adding the texture. I generally lock my opacity channels if I’m using this particular technique.

Both of these in Figure 23 have transparency added. The left is a generic Blinn, the right is a VrayMTL.

Double check this if you have render errors.

Figure 24. Render using the simple assignment technique.

If you wanted to add spec maps, reflection maps, bump, normal, or displacement maps, it’s the same method,  just the proper channels.

While this is the most simple and straight forward of setups, obviously it’s problematic for production because if you want to change Shader/Material attributes you have to make the same change to every shader, everytime. That’s why I only use this as a diagnostic tool, and not for standard production.

Master Shader:

The second and probably best method is to use a ‘layered texture’ node connected to a master shader: Blinn, Lambert, or Vray MTL etc.

The reason here is obvious, you have all your tiled textures under one node for surface property control. It takes a little more time to set up, but it’s worth it.

If you’re not familiar with the layered texture node it’s found under “other textures” in the HyperShade.

Using it can be a little tricky at times, but once it’s set up it can be invaluable.

Figure 25. layeredTexture node

Create a shader of your choice. For this one I’m going to use a lambert and name it “cubeMaster”

Create a render node under the “color” field, and assign the layered texture.

Figure 26. layeredTexture Attributes

Once it’s assigned should see the layered texture attributes.

Figure 27. Creating a new layer in the node.

Now select to the right of of the green swatch in the layered texture attribute edtor and create another node.

Just to make things simple, create four more for a total of six layers.

Six tiles, six layers.

Figure 28. Add your tile specific texture and make sure Blend is set to "Add"

Once that’s done we’ll assign our first tile to the first layer.

Take special node of the white boarder around what I have selected. It’s easy to mistakenly make changes to the wrong layer. Double check you see that white boarder that signifies “selected” before you make any changes or you might be doing it to the wrong layer.

You’ll also note in Figure 28, I highlighted the “Blend Mode”

It defaults with “none”, for a multi-tile texture set to work we need to set it to “add”

In the color field I’m assigning my first tile which is CubePaint_Tutorial_u1_v1.png

Figure 29. Set Default Color to solid black.

Because we’re using an “Add” Blend we’ll also need to set our default color to a solid black or it will contribute to the color.

If you forget to make this change it will start washing out your texture color until there is enough contribution to make it a solid white. It’s a very important step in the process to assure your painted textures and your rendered textures are 1:1

Figure 30. Uncheck wrap U and wrap V. Take note of the Translate Frame fields.

Next we’ll have to move down to the texture’s place2dTexture node and make some changes.

I have two areas highlighted in Figure 30.

The first is the translate frame. For our first tile we’ll do nothing, but this is important to take note of. It’s a bit counter intuitive to the process we’ve been using to count tiles, but the two fields of 0 and 0 basically mean u1_v1, or as it sees it zero translation in U or V. Basically it’s our first tile.

Second is the wrap u and wrap v fields. They’re on by default so your textures will continue repeating in each tile to infinity. Because we have textures for each tile painted we want to turn this off or the process will fail.

And that’s it, the first tile is done.

Figure 31. Keep Track of your layers.

Going back to our layered texture node, we now see tile one is blue, signifying it’s got a connection. You’ll notice the white outline around layer 2 which indicates I have it selected and am now ready to make it an “add” blend and assign the texture.

Figure 32. Translate the next texture/tile over by a full unit.

I go through the same process, making sure my default color is black, but this time in the place2dTexture node I make one change.

As I pointed out in Figure 30, I left the translate frame fields at the default 0,0

For my second tile, which I saved as CubePaint_Tutorial_u2_v1.png, I need to change the field to translate 1 in UV x, and 0 in UV v

This basically equals our u2_v1 tag.

So the next layer would have a Translate Frame of 2 for your texture u3_v1 and so on.

When a lot of files are flying around it’s easy to make the mistake of punching in the wrong numbers for your textures, so double check that if your render looks wrong.

So now it’s just a matter of going through the whole process till you have a full assignment of your tiles to the shader network.

Figure 33. Final Hypershade and Render.

In the end your Hypershade should look like this, and as you can see I did a quick render to make sure it was working. I’m using a VrayMTL in this one, but as I stated it works in any of the standard Lambert, Blinn, Phong, etc shaders.

From this point on I usually copy the network and start connecting it to the other channels I’m planning on using; Spec, Reflection, Bump, Displacement, or in the event of using a SSS shader, I’ll plug it into the Sub-surface color, Scatter color, etc.

That’s pretty much it.

Part 4, Multitile displacement mapping

Update: June 10, 2012 – To skip directly to how to set up for displacement jump ahead to part 4 of this tutorial series.

Also I’m no longer using the layered texture shader method and instead using the +/- Average node method as seen in Part 4. I’ll be updating this tutorial to reflect that in the future.

 Tags: CG, Vray, multiple UV, multiTile, multi-tile, UV mapping

By Brian Freisinger

October 17, 2011

In Part 1, you should have created a basic Cube geo and a mult-tile UV map.

We’ll now export our multi-tiled geometry as an .OBJ and bring it into mudbox

On a side note, I generally stick with the .OBJ export instead of .FBX for maya/mudbox back and forth. FBX has a tendency to scale an object up or down by a power of 100 depending on unit settings, and this will cause severe problem when painting a 32 bit displacement map.

32 bit displacement maps are object scale dependant in the calculations of displacement. So I stick with the .obj format which imports and exports a perfect 1:1So export your Cube as an .obj and import it into mudbox.(if it looks weirdly shaded coming in, turn smooth shade off under the ‘display’ menu. Not necessary but it’ll keep this simple primitive from looking annoying while you’re trying to work.

Figure 12. Mudbox UV Layout

Once it’s imported switch from your 3D view to the UV view using the tabs in the upper left corner.

You should see a UV layout identical to what you exported from your Maya

Now that we’re certain we have a 1:1 UV layout we’ll start painting.

Everything I’m about to go over applies equally to extracting and using displacement maps, but because this mesh isn’t exactly parameterized to be a subdivision surface object we’ll cover displacement creation/extraction/assignment in a later section.

Figure 13. Mudbox Paint Tools

Switch back to the 3D view, and instead of ‘sculpt’ mode, switch to ‘paint’ mode using the upper right “Paint” tab. Make sure you switch to Paint tools and aren’t using sculpt tools.  

Create a Mudbox Paint Layer at 2048 resolution.

I won’t get into the merits of .png vs .tiff (or .exr vs tiff for displacement) in this tutorial, so use whatever file format you want.

(For the record I use png for color and exr for displacement to get the best results.)Ok, so save your mudbox file and we’ll start laying down some quick paint.

Figure 14. Quick Painting Across Tiles

I also generally switch my base material over to a Gesso in Mudbox for paint instead of that weird flesh tone default. But again, not necessary. But for painting I prefer working off a somewhat ‘white’ surface.

I just painted some random texture using the included stamps and some color for this.

I did however be sure to paint on the corners and around the bottom to show off how the seamless painting works with multi-tile and what it looks like in our UV window now.

Figure 15. Mudbox UV view with Paint

If you switch back from the 3D view to the UV view in Mudbox you’ll see we now have 6 separate texture maps for our object.

And also evident is the fact that it’s painting perfectly across the seams.

Figure 16. Mudbox Detail Painting.

I created another layer and brought in a photo I took and used is as a stencil to paint along one edge quickly to show off how well mudbox paints across discontinuous UV maps.

So, if you decide to paint another layer or two go ahead. When you’re done save your working file, and flatten your paint layers. (Merge Visible in your Mudbox Menu)

Figure 17. Exporting Paint Layers from Mudbox

You can export each layer separately and continue working in Photoshop or another image manipulation package, but for ease in this tutorial we just want one layer exported with our UV tile coordinates.

So once we have a single layer we’ll export it. Mudbox has a variety of way to export but we’ll just use the ‘export selected’ function (make sure you have your texture selected of course)Export it to a directory of choice. In production I make a lot of subdirectories for my maps with the object name included because of the sheer volume of maps I end up working with.

Figure 18. Mudbox Exported FIles.

Your end result after exporting should be something like this.

As I mentioned earlier, this all works in an identical fashion with displacement mapping.

Once you extract your displacement maps and write them out they’ll come out with an identical u1_v1, u2_v1, etc coordinate system.

I highly recommend NEVER changing your uv coordinates at the end of the file. Changing the names is fine as long as you leave the coordinates the same. Reason? If you wish to re-import these into mudbox for any editing, both paint and displacement Mudbox looks for that coordinate I.D. to assign it to the correct tile.

So I can have a verson 2 or 3 of my original mudbox paint, that I edited in Photoshop, then import it back into Mudbox to clean up any seams or problems before kicking it back out to use in render. You just need to make sure that if you version up you put it before your U and V coordinate ID;

CubePaint_Tutorial_01_u4_v1.png

CubePaint_Tutorial_02_u4_v1.png

Now that we have both a Multi-Tile piece of Geometry and associated Texture Maps we’ll move on to assignment for rendering.

Part 3: Muli-Tile Shader Setup/Rendering in Maya.

 Tags: CG, Vray, multiple UV, multiTile, multi-tile, UV mapping

(This tutorial is designed around Maya and Mudbox. Several of the concepts here can be transposed into other 3d software packages that have UV grid control)

STANDARD UV MAPPING vs. MULTI-TILE
(This is a basic overview of UV maps and resolutions, if you’re already familiar with this skip ahead to The Multi-Tile Paint found in Part 2.)

Why use a Multi-Tile UV solution over Standard UV mapping?

The quick answer is maximum texture resolution.

This technique becomes incredibly useful when dealing with large terrains, or characters which need to have seamless subdivision surface attributes assigned to them;

i.e.there  no way to cut the geometry into smaller sections without ruining the tangent of the subD.

Generally when an object it UV mapped, it’s unwrapped into a flat 0,1 UV coordinate space as seen in the UV editor

Figure 1, Basic UV

Once your UV maps are created, it’s now time to create a shader. In the event you’re using non-procedural textures, you need to determine resolution.

Is it seen from a distance? Is it up close and in need of detail?

Basically is the texture as low as 512k, or as high as 8192k?

This tutorial won’t go into memory management and high resolution textures, but basically it’s more efficient to load several smaller textures (2k or 2096 for example than larger textures), for the individual user or small shop not using a robust pipeline, this can be almost essential.

Even in the event that the user is utilizing an 8k texture, it’s not exactly true.
If we divide each square up in UV space we actually only have 819.2k per square.
So looking at the example below, roughly each side of the box has a resolution less than 2438.7k
Probably plenty for most renders, but if you have multiple 8k textures it will start becoming problematic as the 3D program of choice has to load these these into memory, especially if your render engine of choice loads them up front.

Figure 2. Actual Pixel Resolution

As you can also see, the resolution for actual coverage area exponentially drops as we get into more common 2k texture usage.

Another issue is painting/creating/extracting 8k textures. Again, this is extremely taxing on a system and without enough ram and a good video card you might find yourself working very slowly or even crashing.

With the advent of software packages such as Mudbox and Zbrush, the user can now extract displacement maps from high resolution sculpts. One of the problems that often arises from extracting displacement maps is what is seen sculpted, is often not what is seen in rendering.
Part of this can be attributed to user render settings, but more often than not, it’s also based on the information written out during the extraction process.

The MULTI-TILE

Even with a 8 or 4k map we’re really not getting full coverage. We have to share the area with all pieces of the Geometry, even those that might go unseen or are further away from camera and don’t require all that resolution space. So how do we maximize our pixel resolution?

And the better question, how do we paint a seamless texture/displacement map across these?

Figure 3. Default UV Grid

The first thing to do is set up our UV grid in Maya so we can be organized. (And so it shares the same UV layout as Mudbox)

The default UV window in maya is set for the standard 0,1 single tile

To make sure you have a clean UV layout that “talks” to mudbox, and for organizational purposes you need to change the UV grid.

Figure 4. UV Grid Option

Open the UV Texture Editor and in the window under:
view > grid > options

Figure 5. UV Grid Settings

Change the settings to

Length and Width: 10
Grid lines every : 1
Subdivisions : 2

Leave everything else alone.

You can click the ‘tiles’ option if you like, but that doesn’t have any real effect other than darkening the tile borders. It’s visual help only, and doesn’t do anything else to effect mult-tile UV mapping.

Figure 6. UV Grid set to tile 10x10

Now looking at our UV Texture Editor it’ll look exactly the same as figure 3, until we select an object (make a default primative cube and select it.)
And we’ll notice that the Default UV map now falls into the first “tile”

Maya is now set up to visually layout and deal with Mult-TIle UV maps.
Why is this important? Because just like any other UV map, you need to be inside the 0,1 range of each tile. No crossing the borders with sloppy maps. Having the tiles set gives the user a visual boundary of what’s ‘legal’ and what’s not.
Without this new grid set up it’ll make it really difficult to deal texture assignment, just like any other UV map.

Figure 8. Mudbox Warning. UV's are crossing tile borders.

Also you’ll be able to trouble shoot quickly if a message like this comes up in Mudbox

You can ignore it and paint away, but there’s a pretty good chance mudbox will crash. Even if you manage to survive a crash and paint away, you’ll still need to import good UV’s into mudbox later if you want to extract your map. If you see this message come up, check your UV’s with a fine tooth comb and make sure everything is ‘legal’

Figure 9. Example of U and V Coordinate I.D.

We also now have a U and V coordinate system set up, with each tile representing it’s coordinate I.D.

As always, U is horizontal and V is vertical, but now each tile has it’s own coordinate number as well. As seen above (figure9), four tiles over and three tiles up is U4_V1 in coordinate space.

Figure 9a. Mudbox Mult-Tile Saved Files.

This helps not only from an organizational point of view, but when Mudbox saves out multiMaps it’ll give them a coordinate ID relating to which tile they belong to.

UV Mapping with Mult-Tile

So now that the grid is set up, we’ll continue using the simple box/cube object and set it up for a multi-tile texture assignment.

So if you haven’t done it yet, create a simple Cube Primitive in Maya. For our purposes make it perfectly square.

All we’ll going to do here is select the edges of the box in the UV Texture Editor and use the UV ‘cut’ tool to separate them from their adjoining faces. Basically making a UV per face, or six discontinuous maps.

For speed in learning this, I’d recommend doing this:

1. Select all the edges of your cube in the UV editor and use the CUT UV EDGES tool.
This will make each face a ‘discontinuous’ UV map.

Figure 10. Normalize options.

2. Select all the UV points in the window and normalize them. I recommend opening the Normalize option window and switching to “Each Face Separately”.

We don’t need to preserve aspect ratio for this since it’s a square cube, but if you’ve decided to try something else as a primitive or other Geometry you may want to click that box.

3. Next I recommend scaling the UV borders in from the tile’s edge.While not necessary having UV’s to close to the borders, or even to close to each other in UV layout can cause problems when extracting a displacement map in Mudbox (and Zbrush). You can either scale by hand, or script a 5% scale reduction. I use a quick mel command like this:

polyEditUV -pu 0.5 -pv 0.5 -su 0.95 -sv 0.95 ;

4. Now we need to separate each one into it’s own tile.
This can be someone laborious the first few times out, but it’s worth it to make choices and decisions about what goes in what tile. When doing character work I often have certain layouts I like to use based off experience.
For our tutorial though, the cube is arbitrary and we’ll just lay them out quickly across the first 6 tiles.
I can just simply select a single UV and then tell Maya to select shell border to grab a single shell to move it into the next tile over. Most of the time this is fine for initial UV layout, but what if I need to to fall into the exact same UV position of tile one? For example I have a painted texture already that works, I just need to separate each tile out to be EXACTLY in the same UV coordinate space, just different coordinate tile?
Easy.
Again, we’ll use a mel command.

polyEditUV -u 1 -v 0 ;

Will move the selected shell exactly one tile over in U to the right, or in positive U

polyEditUV -u -1 -v 0 ;

Will move the selected shell exactly one tile over in U, but this time to the left, or in negative U

polyEditUV -u 0 -v 1 ;

Will move the selected shell exactly one tile up in V, and of course negative value one tile down.

I have a series of buttons in my interface that say “UV UP, UVDOWN, UV LEFT, UV RIGHT” that I use for doing layout. This assures that if I need to shift a tile for whatever reason, I’m only shifting it in it’s tile coordinates, not it’s true UV texture coordinates.

Figure 11. Multi-Tile UV layout in Maya

However you decide to shift your UV’s, in the end they should look similar to this:

We’ll explore what to do with this and how to handle it for rendering in the next sections.

Tip:

Obviously you don’t need a single polygon face per UV tile. You can stack as many areas in a tile as necessary. It can really depend on the size/aspect ratio of your maps.

Here are a couple of more advanced examples of Mult-Tile Layout

Figure 11a. Multi-Tile Walkway

This one was for a walkway that needed a high level of displacement and paint since the camera was following along the path for the shot.

Figure 11b. Multi-Tile Character Layout

This one is for a female character for a client.

The options are pretty endless once you follow the basic rules.

Part 2. Mudbox and Mult-Tile

Tags: CG, Vray, multiple UV, multiTile, multi-tile, UV mapping

When you have a lot of objects in a scene and you want to utilize Vray’s subdivision flag, it can be time consuming to go through the whole lot and flag each one by one.

So here’s a quick mel script to help out.

Select all your objects you want flagged as Subdiv and then run this in the script editor: