Jump to content

toadstorm

Members
  • Content count

    157
  • Donations

    0.00 CAD 
  • Joined

  • Last visited

  • Days Won

    10

Everything posted by toadstorm

  1. Alembic is the usual standard here for getting geometry across, unless you need the skeletal data (most likely you don't). For this LED bank example, you could extract the mesh that the LEDs sit on and use Extract Transform to get a null that you could then transform your LED grid with. If you're rendering your effects in Houdini, you can just use the Alembic geo as holdouts and you're good to go. Getting effects assets out of Houdini and into Maya can be a real trick depending on the type of data, so aim to render in Houdini if at all possible.
  2. MOPs: Motion Graphics Operators for Houdini

    The solver parameter issue has been patched, along with a bunch of other ones. See the updates thread for details.
  3. Pixelkram / Moritz S. (of Entagma) and I are proud to announce MOPs: an open-source toolkit for creating motion graphics in Houdini! MOPs is both a suite of ready-to-use tools for solving typical motion graphics problems, and a framework for building your own custom operators easily. More information is available from our website: http://www.motionoperators.com Enjoy!
  4. 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.
  5. 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.
  6. 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.
  7. 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.
  8. 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.
  9. 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.
  10. 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.
  11. 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.
  12. 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.
  13. 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};
  14. 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.
  15. 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
  16. 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.
  17. 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
  18. 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().
  19. MOPs: Motion Graphics Operators for Houdini

    Feel free to not use it.
  20. Array contains single primitive as 0 ?

    Because you're iterating for each primitive. That means that there's only one primitive per iteration through the loop, so the only primitive you can see is primitive zero. It's beating a dead horse at this point, but this is one of many reasons why you should use primitive wrangles rather than for-each loops when you want to iterate over a set of primitives.
  21. Polywire shape adjustments

    MOPs is a custom toolkit, it doesn't ship with Houdini. You can download it here: http://www.motionoperators.com
  22. Access Primitives in Y axis ?

    The code would be exactly the same, it would just run a lot slower. Primitive Wrangles are inherently running for-each. This has been brought up in past threads.
  23. Access Primitives in Y axis ?

    A.) don't use a for-each to loop over all primitives, use a primitive wrangle. they inherently loop over all primitives. B.) assuming you have vertex or point normals already, before the wrangle, promote N to a primitive attribute. C.) in your prim wrangle, compute dot(@N, {0,1,0}). something like this: float d = dot(@N, {0,1,0}); float threshold = 0.75; // closer to 1.0 = more sensitive if(dot > ch("threshold")) { // do whatever }
  24. Blending between RBD and initial state

    You can use the MOPs Apply Attributes and MOPs Extract Attributes nodes to get the nodes back to their original states, as long as the i@id attribute is still in place. MOPs Extract Attributes will convert intrinsics into point attributes that can be used by Apply Attributes. I'm attaching an example file; the strength of the return to the initial state is determined by an animated MOPs Shape Falloff, but you could use any falloff for this. AttracttoPoints_01b_toadstorm.hiplc
  25. POP Wrangle Group

    I think this is just order of operations... if you wire your popwrangle3 that increments f@myage into the pre-solve input instead of post-solve, it works as expected.
×