That last is an impressive video. I wonder if Houdini will eventually bundle more example files that have nodes that can be reused for more complicated scenes. The few that are available under the help menu can be quite useful, but basic procedural shaders, UV mapped objects, etc. are limited. Personally, I haven't found anything I can use for real work in Houdini that doesn't require at least a few lines of VEX code and or hscript. I've used Softimage, Maya, Modo, C4D, and sculpting software (zbrush, 3D coat) and there was certainly less/no programming needed for most models.

I needed to model a snake recently and it was very quick and easy in C4D and a pain trying to do that quickly in Houdini. I would agree with you about the limitations of C4D, though. I have some of the Nitro plugins and would use Houdini over any of them for realistic fracturing/explosions. Lacking realflow, I cannot come close to realistic fluids in C4D even with quite complicated shaders and animations. I have looked at x-particles and am not that impressed with the demo videos I've seen. C4D's mograph is great until you need to add a few effectors and then it is actually easier to do in Houdini. For that matter, the procedural operations in C4D hit a ceiling pretty quickly. For instance, creating a tree with branches is not easy in C4D, as the sweep has to be made editable for the first branch and then one loses the ability to go back and change the thickness or curve of the trunk. The same can be said for Modo's newest procedural operators.

I think the problem is much more fundamental than having more primitives. Compared with working in Maya or C4D, working in Houdini is like programming in Visual C++ compared with Visual Basic. You have to create absolutely everything from scratch. For instance, the sweep, helix, and circle in C4D creates a helix without VEX programming. The sweep adds caps and they caps can be beveled. Groups are assigned to the beveling part as well as each cap automatically. Proper UVs are created based on behind the scene unwrapping the circle. In Houdini, none of this is done.

SideFx is trying to market Houdini to artists who don't want to do a lot of programming. My experience is that you can create production ready renders in C4D, Maya, Modo, etc without programming; but that is impossible to do in Houdini. The benefit of Houdini basically being a mid level programming language is that you have much more control over everythiing, as you have specified yourself how you want everything to work. You hit a ceiling with other programs as they do a lot of stuff behind the scenes that is inaccessible.

It would be good if Houdini added some extra options to their nodes. There are several that allow operators to create groups, and it would not be difficult to have a similar option for the sweep where caps are added and group names given to the beginning and end caps. It would also be nice to have an option for creating reasonable UVs without having to create them yourself with a lot of extra nodes. Similarly, materials get very complicated quick in Houdini and assigning procedural textures is much easier in other programs. One can only hope.

For a long time I thought this was a bug, but if you read the help for sweep, you will see that autoclosure refers to closure of the spline used in the sweep. See attachment for the difference in the two skin types.

So yes, you need to create caps. The sweep is a lot more tedious and complicated than in other 3D apps, and I would hope Houdini would eventually have option buttons to recreate some of the difficult parts (like automatically creating caps, proper UVs, etc.). If you look at the recreation of the C4D helix (in this section of the forum), you can see how many things need to be added to make the sweep “work”.

I think I figured out most of the mistakes. I needed to add a fuse, change uvmapping from point to vertex, and change the group to an expression for last two polygons created. Updated:

I am trying to recreate the Cinema 4D Helix in Houdini, but have hit a couple of road blocks. The C4D Helix is pretty intuitive and automatically creates good UV's. It allows one to control the height, turns, cross sectional scaling, and caps. It creates polygon groups for the end and rounding part of the caps so that it is easy to texture these parts separately.

I can get somewhat close in Houdini, but I have several issues. I would like to create caps for the ends of the sweep that have group names that are procedurally calculated, so that I don't have to create these manually. The system I used will not work if I change the helix or circle number of points. I would appreciate any suggestions. Thanks.

This is how I would like the outline to occur in Houdini (render from C4D with sketch and toon, using substance material)

Playing with this some more in Houdini, it looks like the toon outline shader is pretty buggy, and sometimes it must get cached incorrectly and refuse to outline. One repeatable issue is that for this to work, using an instance for the outline frequently does not work, but if I create a copy of the object - then the outline works even with principle shader assigned to the original object.

I am trying to use a toon shader in Houdini to add a black outline for 3D objects for a book on illustrated knots. I want to preserve the texture on the objects but add the outline. In C4D this is easily done with the sketch and toon shader, and the outline will be there whether objects themselves have the equivalent of a principleshader or a tooncolor shader. (see attachment). In Houdini, the outline seems only to work if the object is given a tooncolor shader, and will not work with a principleshader assigned to the object. (see attachment). Obviously the setup in Houdini is more complicated than in C4D, and I created instances of the objects in Houdini and assigned these instances the outline shader. How do I create an outline yet keep the principle shader on the object? Houdini file attached.

The description in your link above for arclen was not particularly intuitive, but your solution was very helpful. The index of a curve and way of expressing what node was being measured were not things that I could have figured out with the links.

Thank you again. I would never in a million years have been able to come up with that expression on my own with SideFx help and Google.

That is VERY helpful. Rotating one Uv texture -90 degrees made the need to map v coordinates from u coordinates not necessary. The digital asset idea will make this process easier and I liked that your method doesn’t require a 359 degree open arc and adjusting the fuse distance.

Is there a way in uv transform to put in an expression that scales the y axis by arclen circle divided by arclen curve?

I was partially able to solve this, but I don't know why this is so much more complicated than Cinema 4D's sweep nurb. In C4D, a sweep allows spine control (for varying thickness) easily, creates UV's automatically, and doesn't have to do strange things like start with an open circle of 359 degrees and exchanging U and V coordinates to avoid ugly seams. If one adds a polycap, it creates ugly renders like above. I have to select the end loop and create groups to have it behave properly. Here is a fix with notes to show the issues and an updated file. Please, SideFx, make this easier - if you want to market Houdini to modelers.

I've been trying to UV map a sweep model of a square knot, and I added a rotation over time to the cross section (circle). Most of the time it animates ok, but for certain frames, I get an ugly artifact (see attachment). I'm not sure what I am doing wrong.

Thank you so much! That was the issue. I wonder why the preference got set to “never” or even why that might be a preference, but no matter.

With Version 16.5.439 of Houdini Indie, it doesn't seem to matter whether “Keep position when parenting” is checked or unchecked. In either case, the child object moves to the position of the parent. I know this is a beginner issue, but it does not do what it does in several tutorials. (OSX) If you open the attached file and drag wires between the null and either the box (where Keep position when parenting is selected)or tube (where Keep position when parenting is deselected) the objects move to the nulls position.

The errors persisted after latest daily build as well as after deleting houdini_temp from /tmp and deleting the deleting my $HOME/houdini16.5 directory. It goes away with scaling the objects and also is not present if I change the area light's shadow to raytraced. I've created a simpler scene that was not scaled and it did not have this problem, so it must be a combination of number of objects, size of objects, and depth map shadows.

Apparently the issue is that render view uses ray traced shadows and mplay or render to disk uses the setting in the file of depth map shadows. If the objects are too small, depth map shadows don’t work correctly. Scaling the objects in the scene fixes this.

I was trying to simulate GI in a very simple scene and the render view looks ok but the render is messed up with shadows (see attachments). Initially it output correctly. I now see an error message in the Mantra node that says
Command Exit Code: 139

Error: Couldn't remove old operator type definition sesi_temporary::Object/subnet
89268: Fatal error: Segmentation fault (sent by pid 0)
– TRACEBACK BEGIN –
2 libHoudiniUT.dylib 0x000000010729e964 stackTrace() + 244
3 libHoudiniUT.dylib 0x000000010729e5fc signalCallback(UTsignalHandlerArg) + 492
4 libHoudiniUT.dylib 0x0000000107594a30 UT_Signal::processSignal(int, __siginfo*, void*) + 176
5 libsystem_platform.dylib 0x00007fff593c4f5a _sigtramp + 26
6 ??? 0x0000000000000000 0x0 + 0
7 IMG_OpenEXR.dylib 0x00000001235bf1c5 IMG_OpenEXR::readScanline(int, void*) + 565
8 libHoudiniUT.dylib 0x00000001079a3ca5 IMG_File::read(int, IMG_Plane const*) + 661
9 libHoudiniUT.dylib 0x00000001079d6205 IMG_FileFilterConvert::readPlaneScanline(int, IMG_Plane const&) + 117
10 libHoudiniUT.dylib 0x00000001079a3cc6 IMG_File::read(int, IMG_Plane const*) + 694
11 libHoudiniUT.dylib 0x00000001079d7c78 IMG_FileFilterFlip::readPlaneScanline(int, IMG_Plane const&) + 168
12 libHoudiniUT.dylib 0x00000001079a3cc6 IMG_File::read(int, IMG_Plane const*) + 694
13 libHoudiniUT.dylib 0x000000010799cdb9 IMGfindDataWindow(IMG_File*, UT_Rect&, double, std::__1::basic_ostream >*) + 1577
14 libHoudiniUT.dylib 0x000000010799d19f IMGfindAndSetDataWindow(char const*, char const*, double, long long, bool, int, bool, bool, char const*, double, bool, std::__1::basic_ostream >*, std::__1::basic_ostream >*, bool, UT_Options*) + 479
15 IMG_OpenEXR.dylib 0x00000001235c6aa7 IMG_OpenEXR::postCloseAction() + 391
16 libHoudiniUT.dylib 0x00000001079a5cde IMG_File::close() + 222
17 libHoudiniUT.dylib 0x00000001079d31f2 IMG_FileFilter::closeFile() + 34
18 libHoudiniUT.dylib 0x00000001079a5c32 IMG_File::close() + 50
19 libHoudiniUT.dylib 0x00000001079d31f2 IMG_FileFilter::closeFile() + 34
20 libHoudiniUT.dylib 0x00000001079a5c32 IMG_File::close() + 50
21 libHoudiniUT.dylib 0x00000001079d31f2 IMG_FileFilter::closeFile() + 34
22 libHoudiniUT.dylib 0x00000001079a5c32 IMG_File::close() + 50
23 libHoudiniUT.dylib 0x00000001079ce995 IMG_TileFile::close(bool) + 69
24 libHoudiniRAY.dylib 0x000000011e2b793b RAY_TileDevice::close() + 139
25 libHoudiniRAY.dylib 0x000000011e17bca4 RAY_ImagerFile::closeDevice() + 468
26 libHoudiniRAY.dylib 0x000000011e1755f0 RAY_Imager::close() + 16
27 libHoudiniRAY.dylib 0x000000011e2265db RAY_Scene::finishRender() + 59
28 libHoudiniRAY.dylib 0x000000011e22978b RAY_Scene::render() + 2027
29 libHoudiniRAY.dylib 0x000000011e26a44d RAY_SceneIO::doRender(CMD_Args&) + 1661
30 libHoudiniPRM.dylib 0x0000000109b377c2 CMD_Manager::runCommand(char*) + 4146
31 libHoudiniPRM.dylib 0x0000000109b2373e CMD_Manager::internalExecute(char const*) + 3534
32 libHoudiniPRM.dylib 0x0000000109b34c3c CMD_Manager::processInput(CMD_Source*, char const*) + 140
33 libHoudiniPRM.dylib 0x0000000109b355bf CMD_Manager::internalSendInput(char const*, bool) + 1535
34 libHoudiniPRM.dylib 0x0000000109b35cb4 CMD_Manager::sendInputNoLock(char const*, bool) + 68
35 libHoudiniRAY.dylib 0x000000011e263118 RAY_Scene::load(UT_IStream&) + 472
36 mantra 0x0000000105039e56 main + 2694
37 libdyld.dylib 0x00007fff590b6015 start + 1
– TRACEBACK END –
Error: Couldn't remove old operator type definition sesi_temporary::Object/subnet

I tried to delete and recreate the Mantra node and I still get the errors on render that are not on renderview. I am stumped.

Thank you. That is helpful. I am trying to get away from fake looking speculars.

Most 3D programs have a way of importing older models (to prevent obsolescence). Is that not the case with Houdini? Was the mantra shader system changed substantially between version 15 and 16.5?

https://www.orbolt.com/asset/_danylyon::PBR_layered_material