Jump to content

Leaderboard


Popular Content

Showing most liked content on 01/05/2017 in all areas

  1. 5 points
    Hello everybody, I want to share with you small tool I created recently using VEX. I wanted to create wall made of non-uniform stones (with different widths and also heights). Solutions I found here are really great but I thought I might push it a bit further. I figured out algorithm that can produce such pattern. It can be customized to fit desired look. Besides it runs pretty fast compared to voronoi approach Attached test renders were done using Techie's amazing rock generator that can be found here: http://www.orbolt.com/asset/Techie::rock_generator::1.0 Have a nice day Peter pt_stone_pattern.hdalc
  2. 1 point
    Hello Everyone, This video is a preview of my "Introduction to Fx in Houdini" workshop, which showcases some of the best student work created in the duration of the course. https://vimeo.com/194219623 Enjoy! Thanks Saber
  3. 1 point
    Thank you so much David! I'm researching on topics for my MFA thesis, and there's a paper that proposed a method to post-process FLIP simulation and up-res them by generating surface points, do wave simulation on them and compute and generate the turbulence details in the form of bump or displacement maps. I thought it would be really useful to set these up in Houdini, so I originally was thinking that maybe it would works the same as the ocean tool where they simulate and generate a range of displacement map for a coarse surface. The only concern here is that I'm not quite sure how to integrate the displacement vop part into the preseted material such as the basic liquid, I've dived into the vop net and it's kind of intimidating, I thought it would be easier if I export displacement maps and apply them on the basic liquid. But thank you so much for sharing, it is really helpful to me!
  4. 1 point
    You could try to check this cutting tutorial: http://www.vfxhomeland.com/commercialtut.php https://player.vimeo.com/video/130627955
  5. 1 point
    You can try to use filter "minmax edge" or "minmax idcover" (not sure which one would work best) for that pass only. that way it won't smooth the edges of the object. That is I believe the way mantra does unpremultiply.
  6. 1 point
    Did you try emailing him? There's contact info on his website: http://www.neonjunkyard.com/about/
  7. 1 point
    @P.y= float[](detail(0, 'row0'))[1]; You need to manually specify output type for detail function signature you need, because many of them exist. VCC usually tell you that you are using ambiguous function signature. But not always. For example, first line of this code is fine for compiler, but will silently break your code with a bug which may be hard to find. @P = point(0, "P", @ptnum) * 2; // Does unexpected stuff. @P = vector(point(0, "P", @ptnum)) * 2; // Scales object twice. Compiler is not so clever. It tries to guess which one of 18 possible return types of point(int; string; int) function you need: float point( int; string; int ) float[] point( int; string; int ) int point( int; string; int ) int[] point( int; string; int ) matrix point( int; string; int ) matrix2 point( int; string; int ) matrix2[] point( int; string; int ) matrix3 point( int; string; int ) matrix3[] point( int; string; int ) matrix[] point( int; string; int ) string point( int; string; int ) string[] point( int; string; int ) vector point( int; string; int ) vector2 point( int; string; int ) vector2[] point( int; string; int ) vector4 point( int; string; int ) vector4[] point( int; string; int ) vector[] point( int; string; int ) Then it sees that it's multiplied by integer (because there is 2 instead 2.0) and chooses to use integer-returning signature. In result, @P.x value will be fetched by this function, rounded to nearest integer, then multiplied by 2, then converted to float and assigned to all three components of @P. In second case, vector-returning signature will be used. Then 2 will be converted converted to 2.0 and vector components will be multiplied with it.
  8. 1 point
    For a job that did not happen I created this as R&D for importing .csv files with lat/long coordinates and placing them on a primitive sphere via VEX: Every red dot is a town or city (or part of a larger city). Test-data from here: https://www.maxmind.com/en/free-world-cities-database Basically it's: Table Import to load -> Lat/Long remap to 0-1 in a point wrangle -> position points with primuv on a primitive sphere.
  9. 1 point
    Yo, Here's a possible fix, using xyzdist and primuv to find the correct uv value and a for loop on each connected uvsets not to have bad uv interpolation UVs Transfer Problem_fix.hiplc.hipnc
  10. 1 point
    Hi, this is the houdini's exhelp, which is available in sublime text now. It's very comfortable searching in sublime, editable and it can be equipped with your own examples. Install: First install the vex syntax of Shawn Lipowski, then put the files into a VEX folder. C:\Users\MASON\AppData\Roaming\Sublime Text 3\Packages\User\VEX Exhelp Sublime.rar
  11. 1 point
    Yep, the new polyextrude uses attributes rather than local variables. On the 'local control' tab you'll find toggles to enable attribute overrides for various properties. To randomise the distance, turn on 'zscale', and make sure you have a randomized @zscale attribute on the primitives feeding the extrude. Attached 2 ways to do this, one with a prim wrangle, the other with an attribute randomize sop. rand_polyextrude.hipnc
  12. 1 point
    In Houdini 15 you could use the convert line SOP.
  13. 1 point
    Just got Sergei-Tomas-Pavel example working in H14, if someone need this. dynamic_constraint.hipnc
  14. 1 point
    Ok! First - the most important part of the method. Check this diagram and attached file - they are the core algorithm I came up with. 1. Let's say we have a simple 2d point cloud. What we want is to add some points between them. 2. We can just scatter some random points (yellow). The tricky part here is to isolate only the ones that lay between the original point cloud and remove the rest. 3. Now we will focus just on one of the points and will check if it is valid to stay.Let's open point cloud with certain radius (green border) and isolate only tiny part of the original points. 4. What we want now is to find the center of the isolated point cloud (blue dot) and create vector from our point to the center (purple vector). 5. Next step is to go through all points of the point cloud and to create vector from yellow point to them (dark red). Then check the dot product between the [normalized] center vector (purple) and each one of them. Then keep only the smallest dot product. Why smallest - well that's the trick here. To determine if our point is inside or outside the point cloud we need only the minimum result. If all the points are outside , then the resulted minimum dot will always be above zero- the vectors will tends to be closer to the center vector. If we are outside the point cloud the result will always be above zero. On the border it will be closer to 0 and inside - below. So we are isolating the dot product corresponding to the brightest red vector. 6. In this case the minimum dot product is above 0 so we should delete our point. Then we should go to another one and just do the same check. Thats basically all what you need. I know - probably not the most accurate solution but still a good approximation. Check the attachment for simpler example. In the original example this is done using pointCloudDot function. First to speedup things I'm deleting most of the original points and I'm trying to isolate only the boundary ones (as I assume that they are closer to gaps) and try not to use the ones that are very close together (as we don't need more points in dense areas). Then I scatter some random points around them using simple spherical distribution. Then I'm trying to flatten them and to keep them closer to the original sheets - this step is not essential, but this may produce more valid points instead of just relying on the original distribution. I'm using 2 different methods - the first one ( projectToPcPlane ) just searches for closest 3 points and create plane from them. Then our scattered points are projected to these closest planes and in some cases it may produce very thin sheets (when colliding with ground for example). There is a parameter that controls the projection. Then second one is just approximation to closest points from original point cloud. Unfortunately this may produce more overlapping points, so I'm creating Fuse SOP after this step if I'm using this. The balance between these 2 projections may produce very different distributions, but I like the first one more, so when I did the tests the second one was almost always 0. Then there is THE MAIN CHECK! The same thing that I did with the original points I'm doing here again. In 2 steps with smaller and bigger radius - to ensure that there won't be any points left outside or some of them scattered lonely deep inside some hole. I'm also checking for other criteria - what I fond that may give better control. There may be left some checks that I'm not using - I think I forgot some point count check, but instead of removing it I just added +1 to ensure that it won't do anything - I just tried to see what works and what not. Oh and there are also some unused vex functions - I just made them for fun, but eventually didn't used. So there it is. If you need to know anything else just ask. Cheers EDIT: just edited some mistakes... EDIT2:file attached pointCloudDotCheck.hiplc
  15. 1 point
    Carve SOP. Fist U : 0 Second U : 1 Breakpoints : Cut At all Internal U Breakpoints
×