Phoenix Tools was a plugin company for Softimage 3D, and I was one of the founders. We did good and bad, and we eventually closed down in 2002.

Arete had an excellent reputation for their ocean and atmospheric library, called Digital Nature Tools. I think their main business was in military simulation, however they had a part in every cg-generated ocean in the movies of the 90s.

In 2001 we joined forces to port their software under XSI (I think it was 2.0). Unfortunately, after the first version came out, both companies shut down.

8 years later, I am working on a feature animation with a few shots in water, and I realized I still had on some cd the arete psunami libraries. So, I decided to give it a try. I removed the license check from the shaders and I compiled them with good old Visual Studio 6, linking against the oldest mental ray library I could find (3.3), and in the end it worked. I was kind of touched when I finally saw the displaced grid rendering in Softimage 2010.

I think I will do no harm to anybody releasing these shaders. Both companies are dead since long, and this is my little tribute to them and the talented people who worked there.

The addon is only available for win32, and no, no chances for other platforms. That Arete library is the only one I have. If you do, use it at your own risk (and fun, i would say. There are probably better ways to do oceans nowadays).

And, you know what, I don’t even know how the full package works. I don’t have anymore the documentation, nor the scripts we provided. If my old companions will find them, I will post them later.

The basic usage however is easy. You have to connect a DNT_Ocean_Sh and DNT_Time to a DNT_Ocean_Evolver. What come out is the ocean instance, that can then go into the other nodes. Also, you want to apply DNT_Air as environment to have nice reflection and the atmosphere.

However, it has some limitations, for instance not supporting texture pre-filtering, and the fact that its spacing is expressed in world coordinates instead of uv coordinates like the old node. This leads to frequent aliasing problems, that can sometimes be limited by texturing the spacing based on the object’s distance from the camera.

Another way of fixing the aliasing is to filter the high frequencies of the input texture. The primary way to achieve this filtering is to do it on the image in an editing program like Photoshop, but this is harder to do with procedural nodes.

However, by using a few nodes in the rendertree, it is possible to do it there also.

The bump node outputs the new normal (N’), after having bent the original one (N) based on the texture gradient at the current point.

So, we can compare N to N’ by subtracting them and getting the length (L) of this difference vector (D). Since N and N’ are normalized, and the maximum bump angle is 90 degrees, D ranges from 0 (no bump) to 1.41, ie the hypotenuse of a right triangle with unit catheti.

We can then set a maximum length for D, and re-arrange N’ in order not to exceed it, so to filter off the high frequencies and limit the aliasing.

In this first rendertree, we simply want to check the “dangerous” zones. We take the length (L) of the normal’s difference (D) and check it against a maximum scalar. If this scalar is exceeded red is returned or green otherwise.

In this example the scalar is set to 1, we are seeing in red the parts where the bending angle exceeds 60 degrees.

To output the filtered normal, we do the same test as above, but connected to a scalar switch.
The switcher outputs the maximum between Max Displacement and L. This value is used to set the new length of D (VectorNormalize + VectorSetLength).

This vector is then added to the original normal N and normalized. This is our new, filtered normal.

Of course this is a very basic filter, more complex ones can easily be built to fit your needs.

You can grab the scene if you want. The red and green subtree is also included, connected to the shadow port.

The sRGB Standard

The sRGB colour space is based on the monitor characteristics expected in a dimly lit office, and has been standardised by the IEC (as IEC 61966-1-2). This colour space has been widely adopted by the industry, and is used universally for CRT, LCD and projector displays. Modern 8-bit image file formats (such as JPEG 2000 or PNG) default to the sRGB colour space.

A value in the sRGB colour space is a floating-point triple, with each value between 0.0 and 1.0. Values outside of this range are clipped. An sRGB colour from this [0, 1] interval is commonly encoded as an 8-bit unsigned integer between 0 and 255.

The pivotal fact to remember about sRGB is that it is non-linear. It roughly follows the curve y = x ^2.2, although the actual standard curve is slightly more complicated (and will be listed at the end of this article). A graph of sRGB against gamma 2.2 looks as follows:

This mapping has the nice property that more resolution is given to low-luminance RGB values, which fits the human visual model well.

The Gamma Function As An Approximation

As can be seen by the above graph, the sRGB standard is very close to the gamma 2.2 curve. For this reason, the full sRGB conversion function is often approximated with the much simpler gamma function.

Please note that the value associated with the word gamma is the power value used in the function y = x^p. Unfortunately gamma is often associated with brightness, which is not exactly what it is doing. The full [0, 1] interval is always mapped back onto the full [0, 1] interval.

What Maths Work In This Colour Space?

In general your lighting pipeline should be done in linear space, so that all lighting is accumulated linearly. This is the approach taken in many film pipeline, and is the only way to ensure that you are being physically correct.

However, assuming that the gamma function approximation is good enough, you can still perform modulate operations. In this case we have some constant A that we wish to modulate our sRGB source data x with, and store the result in sRGB as y. In linear space this would be written as:

y^2.2= A x^2.2 = ( A^1/2.2 x )^2.2

Since we are working only in the [0, 1] interval, we can remove the power from both sides and work in the sRGB space itself. In which case:

y = A ^1/2.2 x

So if we convert our constants into sRGB, then modulate operations can still be performed. However, there are only very few operations that work this way. Additive operations (which are used in additive lighting models, or for alpha-blending) cannot be reformulated to work in a gamma 2.2 space, simply because the space is non-linear. If you wish to have a correct additive lighting model, then you have to work in a linear space, which will mean that you need a higher-precision framebuffer to at least match the low-luminance granularity of sRGB.

sRGB to linear RGB: rgb (sRGB), RGB (linear RGB)

This is commonly approximated as X = x ^2.2 for all channels.

linear RGB to sRGB: RGB (linear RGB), rgb (sRGB)

This is commonly approximated as x = X ^1/2.2 for all channels.

Ok But How To Do That in XSI ?

Before the release of XSI v6, we could change the ouput gamma of Mental ray and match approximately the sRGB by using a gamma of 2.2 ( put 1/2.2 in the active effect tab). In version 6 this option is missing unfortunately but don’t worry there are others third party addon that can do the job for you.

I wrote one of them and you can find them here.

This addon include two shaders. A texture node that convert sRGB image in linear space and a lens shader that convert linear render to sRGB color space.

These shader are intended to be used in a context where you don’t output anything in float format. I didn’t try it in this context so you don’t have any warranty.

The idea is to convert every texture that you create in Lin space and convert every render in sRGB space. By texture I mean any images that are not used to drive data such as displacement map, bump map or normal map. I exclude also floating point image which are considered linear defacto.

Let’s see these shader in action

I will first focus on the lens shader and then on the texture node.

As I said we need to watch our result according to the monitor profile (sRGB) so to convert our render we need to apply the lens shader. It’s really easy use add it on the lens shader stack.

My first example is simple. A grid with a phong shader and a light. An area light with a realistic falloff. To do this I am using the D2S_light with a temperature of 6500 K (White). I set the light intensity to get the same result in the red area.

The left picture is rendered as-is in XSI while the other one is rendered with Lin_to_sRGB Lens shader. As you can see the left picture is overlighted. (intensity around 4000) While the right one behave nicely (with an intensity of 750 only).

Note that even the specular from phong shader looks correct. It looks like the reflection of the area light.

My second example is a simple FG scene with 2 spheres and a plane. The plane and one of the sphere got a DGS shader with only a diffuse term set to a neutral gray. The second sphere is fully reflective to see the environment map.

I used an HDR image from Paul Debevec’s website called beach.hdr to light my scene with Final Gathering.

The first test is a render as-is:

As you can see the color of the environement map are more contrast / darker than what we can see in HDR shop. To correct this naturally we will change the exposure but the color will be affected and we will got a more saturated image which is wrong.

If we use the lens shader we go this result:

The result this time is what we expected. The color match to what we can see in HDR shop. We can start to work safely because we got the right illumination.

On my next example I am introducing a texture on the grey plane by plug to the diffuse slot an image node. I am keeping the same HDR illumination and the lens shader.

As you can see the texture is washed out. This doesn’t come from illumination. This wood texture has been generated in sRGB color space. With the lens shader we simply apply an another time the sRGB convertion. What we need is to convert this texture in linear space before the render. It is the purpose of the sRGB_to_Lin texture node. Just plug it between your image node and the diffuse slot and re-render.

As you can see now our texture is corrected and looks natural.

Bonus

If you need to change your setup and include these two node to your existing setup your can use the existing script written by Guillaume Laforge and included in the first archive. It will insert a sRGB_to_Lin node after your image node.

If you have any questions, critics or correction please don’t hesitate : harry.bardak@wanadoo.fr

Edit : Gradient example removed because it seams to confuse more people than it helps. Shaders source code fixed I didn’t realised that this article was read by non XSI users.

For instance, let’s see how it is possible to texture a spot light’s color based on the angular distance from the spot direction. We just need a few vector math, based on the spot direction and on the point being lit.

First, we need to bring the light’s position and interest into the rendertee. The interest (Spot_Interest) is a Vector_share node whose x,y,z are linked, via an expression, to the spot interest. The position (State_Origin) is a Vector_state node set to Origin. This stands for the origin of the current ray, the light ray in our case. We could have used expressions to do this but using shaders is faster.

Once the two vectors are subtracted the result is a vector that, once normalized, is the direction from the spot to the interest.

Then, we need the direction of the current light ray. This is provided by another Vector_state node, set to Eye Ray. This nomenclature is incorrect because what the node returns in Eye Ray is in fact the current ray direction, not the eye direction.

If we dot product the two nodes (Vector_math_scalar, set to Dot…), we have an output ranging [0..1]. In particular,

dot == 0 if the two vectors are perpendicular
dot == 1 if the two vectors are parallel

We just have to use this value to drive a gradient node which then plugs into the light color.

Similar techniques can be used to drive the distance falloff (based on the ray length value) as well as other lights attributes.

Have fun!

This article is intended more as a tutorial rather than technical or idea discussion. In this article I will explore a few texturing techniques to avoid the use of cluster materials.

INTRODUCTION

Fundamentally, putting materials on clusters seem to be the most logical approach to put different materials on a single mesh. For example, when I came into the world of XSI as a 3ds max user, the first thing I did was to put material on clusters. But that was without considering that the 3ds max workflow for materials is not the same as XSI, and it wasn’t that long that I faced problems. I changed my ways of doing things, but since then I would often read on forums about people having the same kinds of problems. So I thought I could put a few ideas together and share them with those having these issues.

To summarize, my opinion about cluster materials is that from a workflow perspective, they are not good for anything, and from a rendering perspective, they are good only for game production.

WHY CLUSTER MATERIALS ARE NOT GOOD

Here are few reasons why I think cluster materials should be avoided:

Workflow

• To get to clusters in the Explorer, it means you have to dig two levels down in under an object. In larger scenes, it will quickly become painful.
• Outside of the Explorer, you can access clusters using the F3 key, wich either involves clicking more times down the hierarchy and not having synoptic properties attached, or you can click on the Cluster button from the MCP. Either way it’s not good enough when you want to work fast.
• You can’t select clusters using a filter in viewports, nor there is a special vibility filter for polygon clusters, even less for those with materials.
• There is nothing that identifies the cluster material as a cluster material when viewed in the Explorer. So if you happen to be in the Materials scope, good luck finding to wich cluster this materials attached to.
• Worse, if you click on the material icon, it will highlight the entire object (turning its wireframe to pink if you have Highlight Property Set Owners enabled), not just the cluster.
• Cluster materials have precedence over the object when it comes to property propagation, and there is no parent-child relationship between an object and its clusters that would allow a branch-select for example, as clusters are considered sub-elements of objects.
• Clusters are not visible from partitions, which is a big minus for overrides and materials applied to partitions.
• Putting overrides on cluster materials is possible, but convoluted. You either have to group the clusters and add the override to the group, or use scripted operators.
• Clusters can’t be associated with lights.
• To make things even worse, when you use cluster materials you will generally use local texture projections as well….. productivity just went down to the toilet.

Bugs

• Clusters sometimes render in constant colors, like black or gray.
• Sometimes clusters render well but not the rest of the object.

If these have not convinced you, then I’m afraid the remainder of this article will be of little interest for you. But as far as I’m concerned, a fast and reliable workflow prime over any other consideration, so……. So the next question would probably be “fine, so what can I do to avoid cluster materials?”. Actually there are few options available for you.

XSI WEIGHT MAPS

You could use the XSI weight map functionality. Apply one or more weight map on the object, and start painting those weight maps using intensities of 0 and 1.

On this picture, I have painted the skin using an intensity of 1, and the rest black. So in the render tree, I would lookup the weight map, connect to a mixer shader, as shown below.

If you have a continuous mesh that you wish to have a clear edge between two different materials, hide the polygons that you don’t want to paint, and paint the visible ones. When you are done, unhide the hidden polygons.

To facilitate the selection of polygons, I usually create a bunch of clusters. If you use such clusters, make sure to not do the mistake of applying materials to them!

COLOR AT VERTICES

Using pretty much the same workflow as XSI weight maps, you can also use color at vertices properties. The advantage of color at vertices is that you can use a wider variety of color, and extract just the color you need in the Render Tree. To do so, lookup the color at vertice, then for each color you wish to extract, connect into a RGBA_Keyer shader. In this shader, set both the Maximum and Minimum Treshold to the color you wish to extract (you must make sure you know the exact RGBA values that you painted!), set the Color if in range to white and the Color if out of range to black. Finally, connect the keyer shaders into the weight inputs of a mixer shader.

TEXTURES AS WEIGHT MAPS

You can also use a clever combination of textures and texture projections. Here are a few ways you can do the work.

Multiple mask projections, one unwrap projection, one mask texture

First, create in a tiny texture, say, 32×32. It could even be less. The left half of this texture will be pitch black, the right half will be pure white, this will be our mask texture. Bring that texture into XSI.

For each part of the object you wish to have different materials, you could create a texture projection, and label this projection as a “mask” projection.
Now, let say you want to use the same material for the skin parts, and the same material for the clothes parts. You would have two mask projections. In the mask_skin projection, collapse all UVs of the skin parts and put them in the right (white) half, collapse all UVs of other parts and put them in the left (black) half.

Then when you build the final material, connect both materials in a mixer shader, then plug the mask texture in the weight input. In the image shader, choose the right projection.

On the picture below, the clothes shader is placed on top of the skin shader. So to define where the clothes shader will be visible or invisible, I must point the image shader to the clothes mask projection. The UVs of the shirt are placed in the white area, while the other UVs are placed in the black area. So in the end, you could use a Mix_8colors and stack layers of shaders this way.

At last, you would need a single unwrap projection for the entire mesh. This projection would allow you to paint the details of the materials.

Multiple mask projections, multiple unwrap projections, one mask texture

Another approach is to have one less projection than the previous method. In fact, the only difference is that instead of collapsing points in mask projections, you will collapse only the points of the parts you don’t want to see. So each mask texture will not be only a mask, but also an unwrap. Again, you deal only with one mask texture, but instead of having it split in two halves, put everything white, create a 2×2 pixels area at the left bottom corner, and put there the UVs of parts you don’t want to see. Unwrap the other UVs in the white area.

This approach has a significant advantage of the previous one. Because the mask projection is also the unwrap projection, each part of the object can receive a texture of a resolution of your choice, without having to worry too much about the overall texture size. For example, if you want to put a 4k texture for the face and a 1k texture for everything else, nothing is easier. In the previous setup, the only to do that would be to cleverly unwrap everything in one projection so that the face would receive the maximum amount of pixel from the texture.

One projection, multiple mask textures

The next technique we’ll discuss involves doing only one projection, but carefully painting mask textures. Here, you will create one projection, unwrap the whole object, then paint one mask per part of the mesh. Each of these parts will have to match the UV space it is assigned to. For these textures, you might want to use a little higher resolution than 32×32/64×64, something in the 256×256/512×512 would be more appropriate.

For instance, let’s take again the skin vs clothes example. You unwrap the whole object. Then you create two masks. In one mask, the area occupied by the UVs of the skin will be white, while the rest is black. In the other mask, the area occupied by the clothing will be white, while the rest will be black. Then again, it’s just a matter of wiring the right mask in the right weight input of a mixer shader.

One projection, no mask

The last technique we’ll check involves doing only one texture projection, and doesn’t require the use of a mask. On the other hand, all the work of defining the surface properties will be done with the texturing. In this setup, you use only one illumination shader, and use textures in each port to give the illusion of different materials. The advantage is that you do one projection and don’t have to bother about masks as all, but it means that you have to change the range of many textures since many parameters are not expressed in a 0-1 range as color is. As a result, you may end up with such a Render Tree:

While this approach involves lots of fine-tuning, it has the big advantage of being managed as one single file. In Photoshop, each layer is treated as a single channel of the entire mesh, and lots of tweaking can be done without having to manage lots of files.

CONCLUSION

As we have seen, there are many alternatives to cluster materials, I have proposed a few of them. Just pick the one you think works best. If there are other techniques you think work better, do not hesitate to share them!