Jump to content

toadstorm

Members
  • Content count

    340
  • Donations

    0.00 CAD 
  • Joined

  • Last visited

  • Days Won

    18

toadstorm last won the day on November 6

toadstorm had the most liked content!

Community Reputation

228 Excellent

About toadstorm

  • Rank
    Illusionist

Contact Methods

  • Website URL
    http://www.toadstorm.com

Personal Information

  • Name
    Henry
  • Location
    San Jose, CA

Recent Profile Visitors

4,717 profile views
  1. you're right, this is a terrible place and you should probably leave
  2. Assuming you're using Alembic to get your primitives out of Maya and back into Houdini, you need to get the "packedfulltransform" intrinsic of each packed Alembic. In VEX you can use the "primintrinsic" function to get this matrix. However, points don't have primitive intrinsics, and so when you delete your primitives you're going to lose all your transform information except for @P. You'll want to keep the primitives loaded, unless you're manually converting the primitive intrinsic transforms to template point attributes. To manually get an orient attribute from a packed Alembic: matrix m = primintrinsic(0, "packedfulltransform", @primnum); matrix3 m3 = matrix3(m); p@orient = quaternion(m3); To get the pivot: vector3 pivot = primintrinsic(0, "pivot", @primnum); v@pivot = pivot; If you want to try the easy route, MOPs has built-in tools to handle this. Use MOPs Extract Attributes on your Alembic primitives, and it'll automatically pull an `orient` and `pivot` attribute out of your primitives (make sure to enable Extract Full Transform). You can then use Transform Pieces, or use MOPs Apply Attributes if your source and destination primitives have either the same sorting order or matching i@id attributes.
  3. VOPs don't work in a vacuum; they modify geometry. If you want to combine the results of multiple VOPs, you'd have to either daisy chain multiple VOPs that all bound the noise function to a geometry attribute, or import some kind of attribute from both VOPs so that you know what the value is you're trying to read in. I'm attaching both approaches. layering_noise.hip
  4. Infection system with growing geometry

    You need to define an "age" that would be equivalent to the current frame, minus the frame at which the current point was first activated by the infection system. You could store that frame in your solver, then compute the difference afterwards and use that value to map to @pscale.
  5. I don't understand why this must be done in a single VOP network...? Like Tomas said, VOPs run in parallel over all points so you can't really smooth your geo between noises. You either need to add up all your noises and then blur at once, or apply blurs in between noise stages. If you really need to keep the appearance of a single work environment and you're good with Python, you could of course wrap this whole process into a single HDA and use a multiparm block to create new noise functions and associated blurs upon user demand.
  6. Cinema4D is just not built to handle that amount of data. If you don't need to modify the geometry at all, depending on your render engine you could load in a viewport proxy that would stream in the real geometry at rendertime... this would be something like an Arnold .ass file, or a VRay .vrmesh, or a Redshift3D .rsproxy. You'll see a bounding box or some other downrezzed representation in the viewport, but it'll still render normally.
  7. Straighten Curve Segments?

    I used minimal VEX for this... just to create the v@sourceprimuv and i@sourceprim attributes. Attribute Interpolate automatically reads these attributes when computing the final values for any attributes that are run through it. interpolate_curve.hip
  8. I don't think this is possible without modifying the Principled Shader, since it's using GGX as its specular model and there's no parameter to change that. I'm not sure if this is an inherent problem with the GGX microfacet model or with Houdini's implementation of it, but GGX will not resolve to a mirror surface. If you wanted to force the Principled Shader to allow for non-GGX specular models, you need to right-click > Allow Editing of Contents, then dive inside, find the Principled Shader Core node, Allow Editing of that node, then look for the node "metallic_reflection" and change the Specular Model there to Phong or Blinn. Then jump out and set your material's Base Color to be pure white, and Metallic to 1.0. That should create a pure mirror material. I hope in future builds that SideFX can add a switch in here to override the specular model if roughness is zero. Might be worth an RFE?
  9. Taper multiple curves

    damn straight you do, see you next month i hope
  10. Taper multiple curves

    Sure, you just need to figure out what your central axis is (in your scene it's just the Z-axis) and then figure out a vector from each point to that line... then cross that with N (the tangent of each curve) and you have yourself a bend axis. Bendlines_v002_toadstorm.hip
  11. Taper multiple curves

    The Guide Process SOP in Bend mode works for this. You just have to define a prim attr that you can use as a bend axis... for this it'd be crossing N and up (the "forward" axis of the curves). Check the attached file. xoxo bend_curves_out_toadstorm.hip
  12. DOP I/O vs DOP Import Fields

    You can think of it like the difference between a File SOP and a File Cache SOP. Dop Import Fields is built to... import fields from DOPs. Dop I/O has built-in controls to automatically cache import fields to disk and then read them back, just like File Cache. It's a convenience node; up to you if it's worth using for your own workflows.
  13. alembic objects into copy to points

    A hacky way to do this would be to load up your packed Alembics so you have 200 packed Alembic primitives or whatever, then blast all but piece`$F` over the course of 200 frames, then unpack and write this out as a sequence, so that you have 200 frames written out with a single piece in each frame. Then load this back in as a packed disk sequence. You could then copy that packed disk sequence to each instance point, and then use `setprimintrinsic()` to set the `index` primitive intrinsic of each copy to be whatever frame/piece you want.
  14. @evilRainbow Hey sorry I didn't reply sooner. I'm posting an updated file that goes into a little bit more depth as to how orientations are computed by the Copy SOP, and then how to modify those rotations one axis at a time, all using quaternions. Basically the Copy SOP is going to try to do whatever it can to figure out how to orient your copies if you don't provide enough information in the form of template point attributes. An orientation requires a minimum of two vectors: the third can be automatically calculated by finding the cross product of the other two. Once you have three vectors, you have a 3x3 transform matrix, and so you know which way each axis (X,Y,Z) should be facing. If all you do is provide N, which is typically the case when you're just starting with any old geometry, Houdini is going to guess at an "up" axis by figuring out the matrix that would rotate world N (the +Z axis) to the current surface normal, and then multiply that same matrix by world up (the +Y axis). This "guess" in VEX is the dihedral() function. Then it will cross N and up to find the implicit third axis, and that's your final orientation. I'm doing that manually inside the VOP network "determine_initial_orient" here, converting it to a quaternion, and then binding the result to "orient". Quaternions and 3x3 matrices are interchangeable when you're just talking about orientations (matrices can also describe scale and shear but we won't get into that here). Next, the extra rotations... a quaternion can be described as an axis to rotate around and a number of radians to rotate around that axis. In the second VOP "twisting_manual", first we decompose the orient attribute back into N and up vectors by multiplying +Z and +Y by the orient quaternion... this effectively recreates the original orientation we did in the previous VOP, but now it's relative to a specific axis. Now we can just create a new quaternion out of that axis, and any angle we like; this will create a "twist" around whatever axis. Finally, all these new twists are combined by multiplying the quaternions together, and then multiplying the combined rotations by the original orient quaternion. You can try dragging the "twist" parameters around on that second VOPnet to see the sprinkles twisting around. You could easily modify this VOP to generate random values for the "angle" of both axes rather than using a parameter. Sorry this is so wordy but quaternions and orientation in general is a pretty complicated thing and I still only really understand half of it. There's more notes inside the HIP file... it's probably easier to just look for yourself and play with the settings. manual_rot_around_axis_toadstorm.hiplc
  15. I think that was just a dumb oversight on my part... i meant to fit that to (-pi, pi). Thanks for catching that!
×