Beta 1.00 Release

After more than a year in Alpha, today I am releasing the first Beta version of the Cycles for Max plugin. This release brings a mix of new features, fixes, and support for Max 2018. The download and changelog pages have been updated.

sample

I have also uploaded a new youtube video to demonstrate some of the new features here:

Full changelog:

  • Changed: Improved accuracy of Physical Material
    • Emission strength has been adjusted to match ART
    • Color temperature curves have been adjusted to match ART
  • Changed: Imporved accuracy of Physical Sun and Sky
    • Emission strength has been adjusted to match ART
    • Corrected minor distortion in baked map
  • Changed: Bitmaps and the Physical Sun and Sky map can now be used directly in the environment map slot
  • Added: Support for 3ds Max 2018
  • Added: Basic support for Free Light
    • Only point lights are currently supported
  • Added: Various translation options [MAXScript variable name in brackets]
    • Environment strength multiplier (previously named “sky intensity”) [cyclesRender.skyIntensity]
    • Environment MIS map size [cyclesRender.misMapSize]
    • Point light size [cyclesRender.pointLightSize]
    • Default procedural texmap bake size [cyclesRender.texmapBakeWidth, cyclesRender.texmapBakeHeight]
  • Added: Support for Max exposure control
  • Added: Option to use a different random noise seed for each frame of an animation
  • Fixed: Environment maps will no longer bake incorrectly when set to non-texture coordinate mapping
  • Fixed: HDR environment maps will no longer be used in non-HDR mode by default
  • Fixed: UI will now remain responsive when translating large scenes
  • Fixed: Physical Material can now be used as an input to Mix or Add nodes
  • Fixed: Light path settings will now apply to activeshade renders
  • Fixed: Improved bitmap resolution autodetection
  • Fixed: HDR texmaps will now bake to non-HDR textures correctly

Upcoming Beta Release

Just a quick post here as I’ve been pretty quiet on this site lately. Since the release of Alpha 3.10 I’ve been hard at work getting the plugin ready for its first beta release. This next release will be the biggest update yet and will include a bunch of new features, fixes, and support for Max 2018.

More details to come as we get closer to release, which I expect will be some time in early May.

Alpha 3.10 Release

Today I’m releasing version Alpha 3.10 of the plugin. The download and changelog pages have been updated and I’ve also included the changelog at the end of this post.

The biggest feature of this release is support for rendering (most of) the 3ds Max Physical Material. This will allow a more artist-friendly approach to creating materials than was previously possible with this plugin. Right now not all parameters are supported, you can read more about supported bits in the FAQ.

I’ve created a couple comparison pictures showing what both the presets “Red Sports Car Paint” and “Copper” look like in Cycles compared to ART. These renders use the Happy Buddha model provided by Morgan McGuire’s Computer Graphics Archive. Click for full size images.

buddha_compare_carpaintbuddha_compare_copper

I’m also still looking for gallery contributions. If you have made something with this plugin you would like me to share on this site, please send it in.

Full changelog:

  • Changed: Improved lighting for material previews
  • Added: Max 2017’s Physical Material can now be used
  • Fixed: Corrected error that could cause non-progressive-refine multi-GPU CUDA renders to hang up
  • Fixed: Objects flagged as not renderable will no longer be rendered

Approximating Max Physical Material – Reflection

I’ve recently been working on building an approximation of the Max Physical Material as a Cycles shader node graph. Once complete, this will allow this plugin to render the Physical Material with a similar appearance to ART. For this post I will be explaining how I built the reflection component of this Cycles shader graph.

To start, we need to know what the reflection component on its own looks like. Fortunately Max makes this easy by simply allowing one to disable all other components. Using default settings, the reflection component looks like this when rendered on a sphere using ART:

reflection_art_default

From this image, we can learn three important things:

  1. Looking closely at the top-left and bottom-right reflection, we can see there are no light gray pixels surrounding the white reflections. This means that the reflection is very sharp.
  2. This surface is only reflecting some of the light that hits it. Were it reflecting everything, the whole thing would be the color of the gray background. Every part that is darker than the background is absorbing some light.
  3. Looking around the edges of the sphere, there is a very noticeable vignetting effect. This is a result of the material reflecting a different amount of light based on the relative angle between the light and the surface. This phenomenon is known as Fresnel reflection. In this case, the material reflects more light at low angles of incidence that at high angles. The gray color around the edge comes from the sphere reflecting the gray background.

With this knowledge, we can begin assembling the shader. The first step is to create a perfectly sharp reflective material. Cycles makes this step easy by providing a Glossy Shader that is exactly what we need, it looks like this:

reflection_cycles_glossy

The light reflections are noticeably bigger in this image, that is just side-effect of the different lighting setup being used Cycles compared with the one used in ART. Later on when we draw direct comparisons between the Cycles and ART versions of the material, we will use a scene where both are lit the same. The spheres are just a quick preview.

The next thing we need to account for is the amount of light that is reflected from and absorbed by this shader. Only three things can happen to light that hits this surface, it can either be absorbed, transmitted, or reflected. This material is completely opaque, meaning there is no transmission, so we know that for this material light can only be absorbed or reflected.

We already have a shader that reflects all light that hits it, so now we should make one that absorbs all light. We can then use a Mix shader and a weighting factor to decide how much of the light gets directed to the glossy shader, which will reflect it, and how much gets directed to the black shader, which will absorb it. Our black shader looks like this, as you may expect from its name:

reflection_cycles_black

We can combine these using a Cycles Mix node. This node takes a weighting factor and two other shaders as inputs. By default the weighting factor is 0.5 across the sphere’s entire surface, meaning that half of the light hitting the surface will be directed to one of the sub-shaders, and half to the other. Combining our glossy and black nodes using a weight of 0.5 produces the following output:

reflection_cycles_black_glossy_const_blend

This is closer to what we want, but it isn’t there yet. Now we need to account for the Fresnel reflection that is occurring in the ART render. To start, we’ll just make a Cycles Fresnel node and connect it to the color channel of an Emission shader. This will allow us to visualize what the Fresnel weighting factor looks like on its own in Cycles:

reflection_cycles_fresnel

Plugging this in as the weighting factor between the reflective and absorptive shader, such that lighter means more reflection and darker means more absorption, we get this:

reflection_cycles_fresnel_blend

Recreated in Blender, our node graph looks like this:

reflection_blender_blend_graph

Now we have a Cycles shader the closely resembles how the physical material is rendered in ART, but there is still another parameter that is part of the reflection component that we need to account for: roughness. So far all the pictured renders have used a roughness of zero.

To see how roughness changes the appearance of this material in ART, I set up a simple scene with a number of reflective planes of differing roughness all reflecting the same light source. In this image the left-most plane has roughness of 0.0 and every other plane has roughness of 0.04 higher than the plane to its left, with the right-most plane having a roughness of 0.24

reflection_art_roughness

Our Cycles Glossy node also takes a parameter named roughness. To start off, lets just take the roughness value from the physical material, plug it straight in to the Cycles shader, and render the above scene again, this time with Cycles.

reflection_cycles_roughness_100

In this image the plane with 0.0 roughness looks good, but everything else is far too rough. At 1.0 roughness both look about about the same (not pictured), so we need to find a way to map the [0, 1] range of the ART shader to visually identical values in the range [0, 1] for the Cycles Shader. Both roughness of 0.0 and 1.0 render correctly in Cycles, so it is the values in between that we must focus on.

For this, we will need to create a function to convert from Physical Material roughness to Cycles roughness. For an input of 0, it must produce a value of 0, and for an input of 1, it must produce a value of 1. For values between 0 and 1, the output (Cycles roughness) should be some amount lower than the input (material roughness), which we know from observing the above two renders.

This can be easily achieved with a power function, which is simply: out = in ^ power. For any power greater than 1, this matches the criteria we specified in the previous paragraph. Now we must find exactly what this power should be.

Just by eyeballing the above 2 images, we can see that 0.24 roughness for the Physical Material is approximately equal to 0.04 roughness for Cycles. Substituting those numbers into the power equation gives us:

0.04 = 0.24 ^ power

Solving for power, we get ~2.25. Now that we have a function that we expect will correctly convert from Physical Material roughness to Cycles roughness, we can plug it in to our Cycles shader graph and render again.

reflection_blender_final_graph

reflection_cycles_roughness_225

Much closer than before, but now we have the opposite problem. In this render, the reflections in Cycles are a bit sharper than equivalent reflections in ART. This means we need to reduce the power. I’ll skip over the tedious part here, but after a few rounds of altering the power and re-rendering I found that a value of 2.05 makes the Cycles render closely, though imperfectly, resemble the ART render.

reflection_cycles_roughness_205

And that is it, we’re done. Now we have a Cycles shader graph that approximates the reflection component of the Physical Material. Here is a quick comparison of their appearance at 0.0, 0.2, 0.5, and 1.0 roughness.

reflection_final_comparison