Jump to content


  • Content count

  • Donations

    0.00 CAD 
  • Joined

  • Last visited

  • Days Won


toadstorm last won the day on June 16

toadstorm had the most liked content!

Community Reputation

98 Excellent


About toadstorm

Contact Methods

  • Website URL

Personal Information

  • Name
  • Location
    San Jose, CA

Recent Profile Visitors

3,484 profile views
  1. How is this effect made?

    looks to me like the effect is called "rotating a bunch of things and then meshing them together". learning how the copy SOP works with template point attributes, and how VDB surfacing works, are probably your main goals for this.
  2. Building a new station

    AMD cards (as far as I know) can't run CUDA, which is required for GPU renderers such as Redshift. If you don't plan on GPU rendering then by all means save your money and go with ATI cards, but otherwise you're better off with Nvidia for the time being.
  3. cops to material

    anytime you have a parameter that expects a file, like a bump map slot, if you want to use live data from your hip you need to use the op: syntax.
  4. MOPs: Motion Graphics Operators for Houdini

    ah right! you'd think i'd know better by now. we'll have that in the next build.
  5. MOPs: Motion Graphics Operators for Houdini

    Okay, I think all of those group masking bugs are fixed. There's a few other fixes and features added as well; details are in our updates thread.
  6. orientation not matching

    The problem is that you're transforming the coins pre-pack using copy stamping. You want to use template point attributes so that the coins are all identical going into the copy SOP, and the transforms are defined entirely by the packed intrinsics.
  7. MOPs: Motion Graphics Operators for Houdini

    @Noobini I found the bug; it's in Apply Attributes. It's incorrectly combining the existing group mask (group1) with `@mops_falloff>0` via a Python script, and it was doing it with bad syntax to boot. If you disable "Ignore zero falloff prims" it will work in the meantime. I'll have this fixed in the next build.
  8. MOPs: Motion Graphics Operators for Houdini

    This is probably a discussion better suited for another thread. @Noobini I'll take a look at your scene in a couple hours. If anyone else discovers any other bugs or inconsistencies, please feel free to report them here or (preferably) on our forums.
  9. MOPs: Motion Graphics Operators for Houdini

    You're losing sight of the bigger picture here, which is to create art. FX TD's are by definition going to be on the technical side of things, but their goal is to facilitate the creation of art. The final image is what matters, 99% of the time. People with engineering mindsets sometimes like to get caught up in the "elegance" or "physical correctness" of their solutions, but that stuff rarely (if ever) matters in this field. Rotating an object is conceptually a simple thing, but it turns out that there's quite a bit of math involved. Is it really insulting one's intelligence to not assume that every artist is willing to study linear algebra to rotate a cube on its local axis? I do know how to do this, and I still don't want to have to write that code out every single time. It's a pain in the ass! Creating a transform matrix, converting to a quaternion, slerping between the two quaternions, remembering the order of multiplication... remembering and executing these steps every time gets in the way of exploration and play. Besides, all of that is only possible because SESI wrote a library of functions to handle this. Should we be expected to also write our own C++ libraries to interpolate quaternions? Should we be using Houdini at all, instead of writing our own visual effects software? Who engineered the processor that you're using to compute all this? This is a rabbit hole you'll never escape from. Anyways, Entagma and MOPs are not officially affiliated at all, so Entagma's core mission of reading white papers so that you don't have to is unlikely to change.
  10. coins stacking noise (vops)

    You don't have an up or N attribute defined, so the coin points are trying to compute N for you based on the path of the curve points. If you explicitly define N and/or up, your orientations will behave the way you want. Try using a Point Wrangle to do this after you displace your points: v@N = {0,0,1}; v@up = {0,1,0};
  11. Create Reference Copy With Python

    I believe hou.Node.copyItems(items, channel_reference_originals=True) is what you're looking for. This won't reference any nested operators in a subnetwork, though.
  12. Attribute blur in shader

    Yes, it will work, but only when the op: is pointing to a path that is considered "renderable," meaning the object's description will be written to or linked in the IFD. Whether or not you're rendering locally, an IFD is still going to be automatically generated, so it helps to think in this way. If you're trying to point to geometry using op: syntax and it isn't considered renderable by the ROP, it's going to be omitted from the scene description and so no point cloud operations will work on it. The solution is to add your point cloud geometry as a "force object" on your ROP, then add the "vm_renderable" property to the point cloud's geo container and uncheck it so that it doesn't actually render, but the point cloud will still be written out with the IFD. point_cloud_renderable.hip
  13. Attribute blur in shader

    If you have all the objects together in one SOP that you want to average the N of, you could use op: syntax to point to that SOP for the point cloud instead of pointing to geo on disk. The only catch is that the merged object must be flagged as "renderable" for Mantra to export it to the IFD, so if you don't actually want to render this combined object (just a part of it) you'd need to add the `vm_renderable` object property to ensure it exports.
  14. Cell Shader

    you're almost there, just need to compute abs(0.5 - s) and see if it's less than your chosen edge threshold value. granted, this still is going to render the edge width as a percentage of the parametric UVs instead of a constant world space width, which is why i like the Convert Line method better. FakeCellShader_ts.hipnc
  15. Attribute blur in shader

    If your geometry is saved to disk, you could use point cloud operations to sample nearby points and average the N attributes together... would probably be faster than gather().