Tag Archive for: Tutorial

If you’re new to 3D graphics or looking to level up your skills, you’ve come to the right place. PBR materials allow you to create realistic surfaces in your 3D scenes. In this guide, I’ll walk you through the basics, but first,

What are PBR Materials?

PBR stands for Physically Based Rendering. Unlike traditional rendering techniques, PBR materials simulate how light interacts with real-world surfaces. This means your materials will look more accurate and lifelike.

“Hang on, materials and textures are different?!”

PBR materials are basically a collection of textures that are designed to be connected as maps into a Arnold/Redshift/<insert your renderer>StandardMaterial. “Hang on, materials and textures are different?!” Yup, read “Difference between Textures, Shaders, and Materials” for disambiguation.

How to Use PBR Materials:

  • Texture Basics:
    • PBR textures include maps for Base Color, Roughness, Height, Normal, Metallic, and Ambient Occlusion, each defining different material properties.
  • Material Setup:
    • Import and map the texture files onto your model in Blender or Maya, ensuring proper UV unwrapping. Be sure to interpret Base Color as sRGB, and the other maps as RAW data.
  • Connect Maps:
    • Link the maps to corresponding inputs of the Principled BSDF shader: Base Color to Base Color, Roughness to Reflection Roughness, etc.
    • If you need a video guide on connect maps, you can find it here.
  • Specialized Properties / Limitations:
    • Certain real-world material properties cannot be properly mimicked by game engines, hence they are not commonly supported as PBR materials. And we’d need to rely on offline renderers like Arnold or Redshift. Like believable murky liquids, colored glass, sheen etc.
    • Examples of specialized material properties
      • Implement opacity, translucency, and double-sided rendering for realistic leaf materials.
      • Implement thin film for oily, iridescent, or pearlescent materials.
  • Surface Imperfections:
    • Enhance material realism with surface imperfections like smudges, fingerprints, and water droplets, adjusting their blending and strength accordingly.
    • These maps can be layered on to supplement the base PBR material that has been pre-designed.

Conclusion

Using PBR materials is a reliable and predictable way enhance the realism of your 3D projects, and you can find them for free at PolyHaven. With a bit of practice, you’ll be creating realistic materials in no time. For a more detailed guide on doing this Blender, please visit “How to use PBR Textures in Blender”. Also, I’ll write about the common misconceptions of PBR Materials, just to help student-types out a little bit with all the confusing terminology and less intuitive features. Happy rendering, and stay tuned!

A video documentation on how to use the tool.

It’s Episode 3! In this video, I’ll show you how to set up a simple RBD simulation in Houdini and this time, as you’ve asked for it, I’ll cover the Redshift rendering setup too! I planned to keep the videos short, but to include the rendering setup, I had to add 10 minutes to the video length. Let me know if you prefer for me to cover the rendering setup each time, or simply focus on the simulation and keep the video bite-sized. As always, if you don’t know the basics of Houdini, check out Houdini Isn’t Scary: https://www.youtube.com/watch?v=Tsv8UGqDibc See you next Friday!

https://www.youtube.com/watch?v=Iw0SsBdXXQo

Welcome back to the series in Episode 2. In this video, I’ll show you how to create this classic particle disintegration effect in Houdini. I hear some of you will like a render setup portion to the video, but I wonder if it’ll make the video too long for you guys, let me know! In any case, I’ll try to incude that in Episode 3 and see how it goes ya? As always, if you don’t know the basics of Houdini, check out Houdini Isn’t Scary: https://www.youtube.com/watch?v=Tsv8U… Otherwise, have fun and see you next Friday!

Here’s a 10-part mini tutorial series to serve as bite-sized introduction to Houdini’s simulation tools. Let’s start easy for Episode 1 – Particles. If you don’t know the basics of Houdini, check out Houdini Isn’t Scary: https://www.youtube.com/watch?v=Tsv8U… Otherwise, have fun and see you next Friday!

Developed this iridescent glass shader in Maya / Redshift based on IG @odddough ‘s request at work.

  1. Start with the Redshift “Glass” present.
  2. Create a RS Fresnel and remap its values into rainbow hues.
  3. Optionally, if you’ve used MASH Color to have varying colorSet values for each part of your geometry like this toy gun example, you can add a Redshift Color Correction to this resulting information, remap colorSet to 0 to 360 and use it to drive the hue variance of the Color Correction node.
  4. Feed the resulting information into the refraction color of the Glass Material
  5. Increase the Dispersion Abbe number to 1 or 30 to taste, it creates iridescent refraction
  6. Enjoy the results!
An example of what this material can achieve.
The lighting setup for this example render. Some volumetric atmosphere and a couple cylindrical mesh lights with volume contribution
Iridescent Glass Material Shading Network
Screenshot of my screen as I was working on this material. While the render at the start of this post has some simple compositing, from this screen shot, we can tell that it looks pretty good right off the bat, without any comp work.

Here’s a tool to add filecache and file nodes to your selected node in SOPs geometry context. At Masonry Studios, we base our Houdini geometry caches and its version on the file name (which contains the version number) and the node name, which is the default in Houdini’s file cache node.

However avoid using the file cache’s “Load from Disk” option to load the geometry back in, because:

  1. It’s convenient for the file cache node’s “Geometry Path” to stay as the default un-evaluated relative path, in order to generate new caches based on the current file version
  2. If we load in the geometry based on this relative path, and we version up our working file, this relative path will fail.
  3. Hence, we find it quite an elegant solution to use a file cache and a file node separately. The file node points to the absolute evaluated “Geometry Path” of the file cache node and we’ve since successfully avoided the issue of broken links to caches.
# Author: Ronald Fong
# Date: 29 Sep 2021
# Usage: Add this as a shelf tool. With a SOP node selected, use this tool to quickly create a filecache and a cache node.
# Feature 1: Names the cache nodes based on your selected node
# Feature 2: File node will automatically be the evaluated absolute path of your filecache node
selected_node = hou.selectedNodes()
geo_node = selected_node[0].parent()
name = str(selected_node[0])
filecache_node = geo_node.createNode("filecache", ("filecache_" + name))
file_node = geo_node.createNode("file", ("file_" + name))
file_node.setInput(0, filecache_node)
filecache_node.setInput(0, selected_node[0])
geo_node.layoutChildren()
filecache_node.setDisplayFlag(1)
filecache_node.setRenderFlag(1)
filecache_node.setSelected(1)
filename = filecache_node.parm("file").eval()
file_node.parm("file").set(filename)

Vellum and RBD both have the newer packaged workflows, and while it’s nifty on their own, I haven’t found a way to set up such that they can mutually affect each other properly in a single simulation.

Usually, we’d set this up in a custom dopnet using the multi-solver, but because of the way the packaged node’s geometry and constraints are group together, there’s no straightforward set up setting this up.

So here’s a quick and dirty (but efficient) way to fake the interaction between RBD packed simulation and a Vellum simulation.

The Result

The idea is to first mimic the movement we’d want of the interaction using just the RBD bullet solver. We feed that output to serve as a collisions geometry for another temporary Vellum solve, feed this temporary Vellum output back to a new RBD bullet solver for the final RBD simulation, and once again feed it back to a new Vellum solve for the final vellum interaction.

This multi-phase simulation approach yields decently convincing results. While it’s not technically accurate, it’s artist-friendly to utilise the packaged simulation nodes.

Node Tree

This screenshot of the node tree shows how Vellum and RBD packaged SOP level nodes feed into each other to arrive at the illusion of interaction.

Tag Archive for: Tutorial