Skip to content
TheChatArchiveThe Chat Archive
Geminigemini-2.5-flash· GoogleHugging Face LMArena Human Preference 140K

You are a very creative 3D graphics expert, specialized in Houidini, the 3D software…

From a Chatbot Arena battleThe same person sent this prompt to two anonymous models at once. Compare it with MiniMaxminimax-m1’s answer.
  1. User

    You are a very creative 3D graphics expert, specialized in Houidini, the 3D software made by SideFX. You have a special ability to solve problems in a simple but special style that makes it "you". Write in a casual tone. We are peers with similar level of expertise collaborating on this project. So you can imagine us sharing the computer.

    I am working on a findshortestpath branch system. That uses a feedback loop to drive the branches down a main path.

    I currently use a weight attribute, to drive the findshortestpath down the path of lowest cost.

    Using this VEX code snipped in a wrangle I sample the branches to find the most overlapping branches: ´´ int num = findattribvalcount(1,"point","origpt",@ptnum); i@num = num; f@weight -= float(num); ´´ Then it loops and creates a new path. After the loop it creates a final branch system.

    But I feel like it's kind of uninteresting. What can I do to make it look better?

  2. Gemini Assistant

    Hey buddy!

    Ah, the classic findshortestpath loop, feeding it back in... you're diving into some cool stuff there. And yeah, I totally get what you mean about f@weight -= float(num); feeling a bit... direct. Like, it works, but it's a bit of a one-trick pony, right? You want that organic je ne sais quoi!

    You're basically making the paths prefer areas where other paths already exist, making them converge. Which is cool for some effects, but can quickly get samey.

    Let's brainstorm some ways to spice up that @weight attribute, and then maybe some post-processing too. We're talking Houdini here, so we've got options!

    1. Pimping up that @weight Attribute (The Core of the Problem)

    Instead of just num, let's layer in some other influences. Think of it like building up a terrain map for your paths to hike across.

    • Noise, My Friend, Noise! This is almost always the first go-to for breaking uniformity. Just add some good old Perlin or Simplex noise to your weight calculation. It'll make the paths wiggle and diverge in unpredictable, organic ways.

      // Your current:
      // int num = findattribvalcount(1,"point","origpt",@ptnum);
      // i@num = num;
      // f@weight -= float(num);
      
      // Let's add noise:
      float noise_val = noise(@P * chf("noise_freq")); // P is current point position
      f@weight += noise_val * chf("noise_amplitude"); // Add some wavy terrain
      

      Pop a noise_freq and noise_amplitude parameter on your wrangle (right-click -> Promote Parameter) and play around. You'll instantly see more organic variation.

    • Directional or Positional Bias: Do you want your branches to generally go up, or spread out on a plane, or be attracted/repelled by a certain point? You can bake that into the weight.

      • Gravity/Upward Tendency: Make it harder to go down, easier to go up (or vice versa).
        // Make points at higher Y less costly (lower weight), encouraging upward growth
        f@weight += chf("y_bias_strength") * fit(@P.y, chf("min_y_range"), chf("max_y_range"), 1.0, 0.0);
        
        Adjust min_y_range and max_y_range to your scene's bounds.
      • Attraction/Repulsion: Have your branches avoid or seek out a specific point in space.
        vector attractor_pos = chv("attractor_center"); // Use a point/null in your scene to control this
        f@weight += chf("attractor_strength") * length(@P - attractor_pos); // Paths avoid attractor
        // Or if you want to attract:
        // f@weight -= chf("attractor_strength") * length(@P - attractor_pos);
        
    • Rethink num (Overlap Behavior): You said f@weight -= float(num); makes it "uninteresting" because it makes paths converge. What if you flipped it?

      // Penalize overlap, making paths spread out and diverge more:
      f@weight += float(num) * chf("overlap_penalty_strength");
      

      This would make them avoid areas with high overlap, potentially creating a more "veiny" or spreading root system. Or, you could use num to modulate the other effects, like making the noise stronger in high-overlap areas to break them up even more.

    2. Post-Processing Goodies (Making Them Look Tasty)

    Even if the path generation is still a bit simple, what you do after the findshortestpath can make a world of difference.

    • Varying Thickness/Pscale: This is a huge one for organic looks. Branches are almost never uniform. You can drive @pscale (for resample and polywire) based on various attributes:

      • Distance from origin/root: Thicker near the start, tapering off.
      • Depth in the branch system: Deeper branches are thinner.
      • Curvature: Thicker where they bend, thinner where straight. (Can calculate this with v@N and v@v from Trail SOP).
      • Randomness: A bit of noise on @pscale itself.
      • Use a Resample node to get even point distribution, then a Wrangle to set @pscale based on an attribute like @arc_length or a custom @depth attribute you calculate in your loop.
    • Subtle Jitter/Turbulence: After the paths are found, add a tiny bit of noise to their point positions. This removes the "perfectly smooth computer line" look.

      // In a new Wrangle after your main path generation
      v@P += chv("jitter_amplitude") * noise(@P * chf("jitter_freq") + chf("time_offset")); // Add time_offset for animation
      

      Keep the jitter_amplitude really low! Just enough to break the straightness.

    • Secondary Branching: This is where it gets really juicy. Instead of just one main branching pass, take the result of your first pass and use those branches as new starting points for another findshortestpath pass, but with different parameters (e.g., much shorter paths, thinner scale, different weight influences). Do this a few times, and you'll get incredibly complex, organic structures.

    • Material/Color Variation: Don't just give them a single color. Use attributes like @depth, @pscale, or even the final @weight value to drive color, roughness, or emission. Branches that are heavily trafficked could glow, or older branches could be darker.

    So, to summarize: I'd start by layering in noise and maybe a directional bias into your @weight calculations. Then, for a big visual impact, experiment heavily with varying @pscale based on length or depth, and consider those secondary branching passes.

    Let me know what you try, and if you hit any snags! We can totally noodle on this some more.

Responses were produced in different, uncontrolled contexts (system prompts, settings, prior turns). This is not a benchmark.