Jump to content


  • Content count

  • Donations

    0.00 CAD 
  • Joined

  • Last visited

  • Days Won


StepbyStepVFX last won the day on April 21

StepbyStepVFX had the most liked content!

Community Reputation

30 Excellent


About StepbyStepVFX

Contact Methods

  • Website URL

Personal Information

  • Name
  • Location
  • Interests
    VFX, Computer Graphics, AI, Deep Learning, Cinema and many more...
  1. Small tablet or laptop for Houdini

    Hey, look at what MSI is doing on laptop workstations, with nvidia cards. I have one since 2015 and it is working like a charm. Hope this helps.
  2. VEX: get attribute values into an array

    If one wants to run it in Detail mode, one should indeed use the npoints(0) function that returns the number of points of the first stream of geo incoming in the Wrangle node. That being said, I don't see the point of running that code on Points, as it basically process the same thing npoints times :-)
  3. Packing circles of different radius

    I tried an algorithm that plays with the radius of circles given some fixed points, but it is not optimally packed. Moving the points on top of that would bring better results.... I share the file although that's not quite a good solution. To get a better solution I think it would require an algo that would be using an iterative process with both the radius and positions. packedCircles.hip
  4. Packing circles of different radius

    Interesting challenge again :-) Maybe use a point wrangle, and use nearpoints to return, for each point, the closest point surrounding it. Then store an attribute with half of the distance between the 2 points. Call it firstRadius for this example. Then in a second pass (another point wrangle) we can see if there is room to increase the firstRadius of each point, depending on the firstRadius of surrounding points. Store a list/array of, say, the 10 closest points of each points. And for each points of this list compare the distance between your current point (ptnum) and the point of the list you are iterating in, and the sum of their firstRadius attributes. Take the point for which this difference is minimal, and increase the firstRadius accordingly. Then instance a sphere or a circle with the radius stored in FirstRadius. Not sure if my explanations are clear... I haven’t tested, but I am curious to see if this works. Maybe tonight :-)
  5. UV boundaries to edges

    The way you would do your own VEX "Connectivity SOP" with "Use UV Connectivity" and therefore determine a border of your UV is by returning the list of all vertex associated with a point, and check if the UV attribute is the same for each one. If one vertex relative to a point has different UV attrobute, then the primitive it belongs to is on another island. So to compute the "class" of each island, a non optimal algorithm could be : take a primitive, assign it a "class" number attribute, list its prim neighbours (take its points, and use pointprims function to retrieve the prims containing this point); then for each points of this prim, list the vertices that refer to it; for each vertices, retrieve the prim to which it belong, and assign the same "class" number to neighbour prims only if the vertices refering to the same point have the same UV attribute. If not, skip the primitve. Iterate over all neighbours prims, and for all those prims that has the same "class", list their neighbours that hasn't been assigned a "class" (to avoid infinite loops over the same island), and apply the algorithm until there are no neighbours that (i) hasn't been assigned a class attribute or (ii) that hasn't been skiped in that loop. Then iterate on the "remaining" primitives (the ones that has not yet been assigned a class or that has been previously skipped because belonging to another island). I am pretty sure this can be run more efficiently to avoid some prims to be visited several times before being assigned a class, but this should work...
  6. UV boundaries to edges

    I think you can also use the Connectivity SOP node, with the UV function. It creates an attribute that you can later use to define groups.
  7. Extra small particle effects - flour, powdered chalk, etc

    I would definitely use a POP network to drive the biggest chunks of chalk. I would then create a particles trail to those chunks and use that as a source for a fluid/smoke sim...
  8. Break constraints problem setting attributes at sop level

    Strange it doesn’t work... maybe it is breaking and deleting the primitive correctly, but reimporting it from sop afterward ? To avoid that, check if your constraint network in SOP context (outside DOP, where the Geometry Source of you Constraint Network is pointing to) is « animated » or considered time dependent. In this case, you have to manually set Overwrite with SOP to 0 on the Constraint Network DOP node, and delete the default expression inside this parameter. In short, it will import your network once at the start, and then relationship will live only inside DOP without being updated from SOP. And check that your display flags are set correctly to your last node in SOP Solver, sometimes i make this simple mistake :-)
  9. opinput question

    The color goes to the center of the grid because the @myP is set to zero, which indicates the @opinput_P returns 0, for most of the points : don’t forget that it returns the position P of the corresponding point in your opinput1, and there is only 1 point (with id 0). As the wrangle run the code over each point, the @myP is OK for point 0, but as soon as it iterates over the points that have a number higher than zero, it can find the opinput1_P of the corresponding points in this input, because there are not. That’s why I used the point(1, « P »,0) = it stands for (input1, Position P, point number 0) Not sure if I am clear :-) The @opinput1_attribute is OK when you look for « bijective » streams of geometry in terms of topology (or at least when what you seek to do doesn’t need to reference any particular points, as in this example)
  10. Help to solve my struggle and to finish my suffering

    Hi, I can't encourage you enough to watch those video from Entagma, where they talk about creating geometry, space colonization algorithm and much more stuff that you can use as your primary toolbox to achieve what you're looking for (and by the way, learn how Houdini works :-) :
  11. opinput question

    The Point Wrangle is running th epoint over each point of your grid, therefore when you write @P=v@origP, you are basically telling him to change the position of each point of the grid to v@origP, which is the null vector (because it hasn't been set to anything else previously). So the grid collapse. Can you explain what you are trying to do ? What is the "current position of the grid" ? You talk about the center of the grid ?. If you want to color the points of the grid proportionally to their distance to the center of the sphere, then maybe just put that code into tha wrangle : v@myP = point(1,"P",0); @Cd = fit(length(v@P-v@myP),0,5,0,1); Don't forget to use fit() because your length maybe outside of what you can display (r,g,b) values should be between 0 and 1. If you want to color them based on the distance to the closest point of the sphere (because it is deformed and you want that to influence the color), then use that code instead : @Cd = fit(xyzdist(1,@P),0,2,0,1); Hope that helps
  12. Python numpy geometry question

    I am not an expert but I would store info in different .txt files : a first one with all the points and their coordinates (each line with the point number, 3 coordinates, separeted by coma or else), a second one where lines contains prim number and its vertices numbers, and finally a third one with the coresspondance between vertices and points number. Then, using dictionnaries, you could rebuild the points, and recreates the primitives using hou.Geometry creation methods. http://www.sidefx.com/docs/houdini/hom/hou/Geometry.html Hope that helps
  13. Detect Collision intersection in bullet sim

    I understand better. What you can do is run a Connectivity SOP to create an attribute that will be piece-specific, then loop over each piece, create a nested loop and run a boolean to have the intersection between the piece of outter loop and piece of inner loop. Not sure if I am clear, but the idea is to « test » each piece of your model with each other piece and just keep the intersection. Therefore it will be easier to visualize... Noit fantastic but it can work :-) By the way, the Boolean SOP is eligible to multithreading when you place your loops into a Compiled Block, to accelerate the process if you have many pieces. http://www.sidefx.com/docs/houdini/model/compile Hope this helps you
  14. Detect Collision intersection in bullet sim

    The impacts are recorded (if option is on - it is by default) as data for your object. You can see them and use those impacts within a SOP Solver node plugged onto your rigid body solver. By the way, you can use an impact analysis node to filter those impact data (there can be a lot... ) : http://www.sidefx.com/docs/houdini/nodes/dop/impactanalysis.html Concerning concave objects: there are many ways to solve that to get more accurate results in collisions : you can break it (voronoi fracture for example) and check the "Create Convex Hull Per Set Of Connected Primitive " in the Bullet data tab of your packed object. Don't use the Concave object option : it is truly unstable, and you get inter-penetrating objects all the time with that option. It really sucks... Hope that helps
  15. breaking glue and hard constraints;

    Instead of changing the constraint name, you could just put it in the broken group, and append a dlete node after your Wrangle, setup to delete primitives that belong to broken group. So just replace the line s@constraint_name = "pin_broken"; by @group_broken = 1; and append a delete node with the group mask with "broken" inside.