Tag Archive for: Houdini

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!

MLOPs – Machine Learning Operators

Some wonder(ful) humans developed this Houdini plugin that allows us to use Stable Diffusion directly in Houdini!

Made some renders from the generated point cloud! MLOPs makes the whole process so convenient and opens up so much possibilities!

I just want to share that I did run into VRAM issues – after generating an image, it fully utilities and holds the VRAM hostage for that Houdini MLOPs session, so I cannot render using my GPU in that same H session. I work around it by restarting a H session to render.

Wonder if it’s only me facing this issue, or there could some memory management options in the next build?

Anyhow, it’s already very beautiful!
Thanks @therealentagma @sidefxhoudini @redshift3d

www.entagma.com

www.sidefx.com

www.redshift3d.com

3d #aiimages #aiart #stablediffusion #sd #houdinifx #houdinihoudono #redshift3d #render #cgi #vfx #dalle2 #midjourney #midjourneyart #abstract #shapes #forms #curves #blender #blender3d #mdcommunity #blendercommunity

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!

I’ve decided to write my own 3D software biography having watched Entagma’s nerd rant on their software biography. It’s interesting, at least to me, that there are many interesting ways of entry into this beautiful world of 3D computer graphics. I’ll also leave my opinions and impressions of the software based on what I last used, tested or researched on them. You’re most welcome to disagree with my opinions and impressions and I’m interested to hear your point of view. Likely, the differences in opinion will stem from the fact that we use the software for different purposes. Still, happy to hear from you!

SoftwareTypeFirst UsedLast UsedOpinions and Last impressions
TrueSpaceFull DCC20032004My first 3D software, it had a raytracer and floating shelfs. It was cool.
Swift3DModelling20042005A very friendly looking 3D software I used to get 3D designs into Flash and onto websites. Did I just mention Flash? That’s probably indicative of how irrelevant this software is
LightWave 3DFull DCC20052005It was good while it lasted, had some nice modelling workflows.
Rhinoceros 3DModelling20052005Did some modelling in there once to realise that the whole software was meant more for actual production/fabrication modelling than for design/animation purposes.
Mental RayRenderer20052016Produces photo-realistic results had quite a messing shading module, but it works.
3ds MaxFull DCC20072009Great for architechtural visualization but I suspect it’s largely due to the legacy library of presets and materials built over the years
Wings 3DModelling20072007A free poly-modelling toolkit that looked promising back in day, but there’s Blender now, so…
MayaFull DCC20082021The go-to for character animation but the development of new tools is slow and often disjointed
ZbrushModelling20082021The go-to for sculpting, not so great for hard-surface stuff, people keep complaining about its strange navigation from other 3D softwares and I agree, but I’ve also developed the intuition for it in 2 weeks so it’s not that big of a deal
MudboxModelling20092015A Zbrush with less strange navigation, but didn’t have Dynamesh or powerful retopologizing tools so it lost the race to Zbrush, but got shoved into Maya as a sculpting module. Great move.
MotionbuilderMotion Capture20092009Used it for optical motion capture and clean up, but now we use inertia based mocap and the clean up module is somewhat half implemented directly into Maya, so it’s not so relevant as of 2021
ModoModelling20102010Used to be extremely hyped for it’s modelling prowess, can’t say the same now
SketchUpModelling20112011It was not very flexible or intuitive, but then again, I last used it in 2011
NukeCompositing20132021The go-to for compositing, I just wish it’s more affordable
SoftimageFull DCC20152016It was very similar to Maya, except slightly more powerful, slightly less popular, so I can understand why it was acquired and killed
Cinema 4DFull DCC20172017The go-to for 3D motion graphics, useful for a single designer environments
ZmodellerModelling20172017When you want to poly-model hard surfaces in Zbrush. If you come from a more “traditional” software like Maya, it doesn’t offer much more than those legacy poly-modelling tools.
Arnold CPURenderer20172019Very powerful and intuitive shading module, beautiful and natural-looking details and colors, too slow for small studios / freelancers.
V-RayRenderer20172018Shading module is very similar to mental ray so I felt at home when transiting to V-Ray, except that the IPR was actually interactive. Of course, then GPU rendering came along.
FusionCompositing20182018Tried it once, not as intuitive as Nuke, but a much more cost-effective
BlenderFull DCC20182021The go-to for getting started in 3D because it’s free and capable, and the development is exciting and fun
MixamoMotion Capture20182021Superb library for motion capture clips. I have found it largely largely difficult to implement library motion clips into real-world projects because we usually need customized action and there’s still quite a bit of retime and collision fixes to make on top of library clips.
V-Ray GPURenderer20182019Very capable and decently fast renderer with nice details and colors. SSS is relatively slow, but usable.
HoudiniFull DCC20192021The go-to for VFX and procedural animation, steep learning curve for people unfamiliar with node-based workflows
Arnold GPURenderer20192021Either broken or very unstable the last I tried in early 2021. The CPU on the other hand still is beautiful.
MantraRenderer20192019Houdini’s built-in renderer. The time to first pixel can go up to a minute for a simple scene, while renderers like Redshift is a couple of seconds, so I find this renderer not very usuable in a small-studio design oriented production environment
RedshiftRenderer20192021Extremely capable and blazing fast renderer with decent details and colors. Perfect for small studios.
ResolveColoring20202021The go-to for coloring / grading
3DCoatModelling20202020Don’t know much about it except I tried their auto-retopologizing tool. Pretty good results, but Exoside’s Quadremesher results were still better
CyclesRenderer20212021Nice production renderer with speeds comparable to other paid renderers. It’s mind-blowing
EeveeRenderer20212021Nice volume lights, great for mood and concepts
Daz StudioGeneratorHaven’t used it but it looks like a character generator for fantasy / game-ish characters
SpeedtreeGeneratorThe go-to for 3D trees
ClarisseRendererLearnt of this software in mid-2021, and I find it interesting, but that’s about it. Sounds like a little Solaris of sorts which I find mildly cumbersome but I acknowledge its ability to handle large amounts of geometry efficiently.
OctaneRendererBack when I was using Mental Ray and V-Ray, Octane looked extremely tempting
RenderMan XPURendererXPU delivers identical pixels from both CPUs and GPUs, but it’s on an indefinitely release date as of mid 2021, so who knows if it’s actually practical?

Here’s a little tool to generate a focus null based on your selected camera. Let me know if there are any bugs because I literally type this in 20mins without checking much! Thanks and cheers!

# Author: Ronald Fong
# Date: 29 Sep 2021
# Usage: Add this as a shelf tool. With a camera selected in the obj context, use this tool to generate a focus nul, and automatically sets the focus of the camera to the distance between the camera and the nul.
# Feature 1: Names the focus node based on the selected camera node
# Feature 2: Selects the focus node for user convenience
# set root
obj = hou.node("/obj")
# define nodes and create focus nul
selected_node = hou.selectedNodes()
cam_node = selected_node[0]
cam_node_name = str(cam_node) + "_focus"
focus_node = obj.createNode("null", cam_node_name)
# set camera focus code to focus nul
focus_code = "vlength(vtorigin(\".\",\"../" + cam_node_name + "\"))"
cam_node.parm("focus").setExpression(focus_code)
# layout nodes and select focus nul for user convenience
focus_node.setSelected(1)
obj.layoutChildren(items=[cam_node, focus_node], horizontal_spacing=1, vertical_spacing=1)

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)

DCC Wars

Here are some statements I hear all too often:

“Maya is the best 3D package. You cannot find any other 3D package that can do the broad spectrum of CGI work it can do for its price point”

“Cinema4D is so much easier to pick up than all the other softwares. Everybody should be using C4D”

“Houdini is the end game 3D software, don’t bother with anything else”

– passionate 3D people

Yes, I’m sure the software you use is the best 3D software…

for you! It could very well be the worst software for others!

We chose it because it fits our production/creative objectives. We then need to acknowledge that not all 3D production artists/companies do the same type of work. Some companies work on hyper realistic creatures, others work with 3D typography and simple geometric forms, while others specialize in heavy destruction VFX work.

So the question isn’t so much about which is the absolute best 3D software, but what are your 3D production/creative needs? That determines which DCC you pick!

I’ll write about my personal experience using these various softwares, and update this space!

Good luck and happy creating!

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: Houdini