Jump to content

StepbyStepVFX

Members
  • Content count

    18
  • Joined

  • Last visited

Community Reputation

9 Neutral

About StepbyStepVFX

  • Rank
    Peon

Contact Methods

  • Website URL
    https://vimeo.com/stepbystepvfx

Personal Information

  • Name
    JO
  • Location
    France
  1. addpoint, add attributes

    Can you tell if your Wrangle is set on « points » or « details » ? When set to run on points, it apply whathever you have coded to each point, while in details mode, it runs once for the geometry. I don’t know what you want to do exactly, but it seems to me you should run it on « details » mode, and write your algorithm to iterate over all points through a loop, check if it’s a new point and set attribute only on those new points (using setpointattrib() maybe ?). Hope this helps you
  2. space texture following the reference geometry ?

    What I understand is that they did not use fluid sim to make those cloud fx, just 3D noise texture, is that what you mean ? So you want that a 3D texture (whose value depends on the 3D position in space of the shading point), « match » or follows the deformation of your object ? If so, I would create a rest position (attribute that stores for each point its initial position in space), and I would use this restposition as input of my call to the 3D texture so that whatever is the real position of my point in space, the 3D texture « follows » that point. Do you think it can work ?
  3. Hey, you're welcome. Here is a quick render to show the result. In my solution the blend is global, but you could create new attributes to the geo to blend per points (with attrib transfers, like you did with your sphere). See U
  4. Hi again, so to animate between fractal levels, I just used your setup to subdivide with 0 distance, just to have the same topology between levels of subdiv but with same initial geo, and then used primuv to find where the points should be in space between your different levels of fractals. Then you can animate the blend attribute to go from one fractal to another. Here is the file Subdiv_Test_v2.hipnc
  5. Just a remark concerning your solution with VDB that made your computer crash : VDB is a way to subdivide a cube in space into voxels (3D pixels if you want). It is highly probable that you made those voxels too small, and therefore, it had to create lots of voxels to cover your cube of space, and took a huge space in memory of your computer, that made him crash. Reduce that voxel size and it will work. The drawback, is that it will make the small details of your geometry « blocky », like LEGO.... or you will have to reduce voxel size (careful or it will crash again). This solution maybe less acurate that the proposal to calculate displacement maps.
  6. EDIT : I have been playing with your file a bit, and my suggestions won't work so easily. You would need to do it iteratively, each step from Fractal N to Fractal N+1, because the geo is "dented" and projection cannot happen properly from step N to step N+2 for example. I will try to propose you something soon
  7. Hi, just an idea : First, I would exclude morphing geometry into another, because you would need same number of points between each geometry, which would require you to subdivide level 0 without chaning its shape. You would struggle identifying the points and it would be a mess... Maybe an option is just to « project » each geometry of subdivision N onto the first level (un-subdivided) and bake the distance between surfaces into a texture (if your first level have proper UV). I mean : take each level N of subdivided geo (your fractal level N), scatter points onto its surface, project that onto the un-subdivided geo (fractal level 0), and bake that as a displacement texture. Then just blend your textures over time, and use that as a file sequence of displacement map on the level 0 geo and check result at render time. I am not sure if I am clear, and you must dig a bit into VEX to learn how to project, get intersection, from there calculate distance and put the value onto the UV space, but I think it’s a viable option, maybe not the best :-) Hope this helps
  8. VFX Assemble questions

    VFX Assemble deadline is today and they have only 35% of people. It s a lot, but not enough to weight. https://vfxassemble.unions.org.uk/
  9. Random link of interest

    As this is a repository of random links, I share this one that I found interesting : http://www.catb.org/esr/structure-packing/ VEX being close to C, I was wondering if this structure packing was applicable, to improve the memory footprint of some code in VEX when instancing user defined structs....
  10. Destruction & Fluid works

    Thanks for feedback ! Indeed, the tornado was my first Houdini project :-) The more I see it, the less i like it. I would definitely improve it if i had time. Thanks again
  11. Renderfarms renderers and plugins

    Never used Zync, can’t tell... but reading Kev, I won’ttry :-)
  12. Renderfarms renderers and plugins

    I have been using Gridmarkets successfully. It works really fine and is easy to use. You just have to subscribe, download, install and use their ROP nodes. Though, if you plan to do some simulation work : do it through their platform, before rendering. Sending the sim files through a slow internet connection is a pain, and the gain in render time will be lost by the time of uploading the files. So be organized and prepare your files so that you can sim in the cloud, and then render. If you retime simulations, be also very careful : you cannot launch all the jobs simultaneously (sims and rendering). They explain all of that very well and they have a very reactive forum and customer support.
  13. Just another laptop question

    I clearly agree ! I have been using a MSI Pro WS60 2OJ-011F - SSD - 3K Edition for 3 years now, and never had a problem with it. Only downside : they seem to be using mSSD in RAID0, and I never found if it was possible to easily change them to increase the main drive capabilities. Shouldn’t be a problem on new ones, but check before buying / select a confortable size straight from the start :-)
  14. Just another laptop question

    This seems promising as a competitor for the Wacom Mobile Studio Pro, without the realsense sensor. I would only recommend it for people sculpting with ZBrush and who needs some rendering capabilities alongside, or for people painting. I don’t see mich interest outside of that compared to the wonderful MSI laptop workstations, for example (i have a MSI W60, that works very well and that I used even to make fluid sims with Houdini)
  15. Symmetrical Topology Mapping

    Hello, I have some models with a perfect symmetrical topology, all made of quads, but having a non-symmetrical pose. I wanted however to "symmetrize" them as much as I could to be able to resculpt them later using symmetry under ZBrush. I have worked on a very weak algorithm (very long, can be optimized to reduce the number of tests along the tree), who is nevetheless working to assign to each point its "topological" symmetrical twin. I wanted to share the code for people who might want to use it, and see what can come off from good coders :-) There are several functions and the last one is the main one, and takes two points as input (an edge who is on the middle of the model, on its topological symmetrical plane). Here is the code, to be used in a point wrangle set on DETAILS : // Function returning 1 if a point is in the list or 0 otherwise function int isInArray(int pointnum; int listPoints[]) { int isinit = 0; foreach (int i; listPoints) { if (i == pointnum) { isinit = 1; } } return isinit; } // Function returning an array with two numbers of the prims that share an edge defined by two points Origin and Destination function int[] findPrimFromEdge(int ptOrigin, ptDest) { int primsPtOrigin[] = pointprims(geoself(),ptOrigin); int primsPtDest[] = pointprims(geoself(),ptDest); int primsSiams[]; int count = 0; foreach (int iterPrimOrigin; primsPtOrigin) { foreach (int iterPrimDest;primsPtDest) { if (iterPrimDest == iterPrimOrigin) { append(primsSiams, iterPrimDest); count++; } if (count==2) { break; } } if (count==2) { break; } } return primsSiams; } // Function returning an array with two point numbers that represent the opposed edge to the one sent as input, with the first point returned being connected to the Origin point of the edge sent as input function int[] findOpposedEdge(int numprim, ptOrigin, ptDest) { int opposedEdge[]; int tempOpposedEdge[]; int pointListPrim[] = primpoints(geoself(),numprim); foreach (int iterPointPrim; pointListPrim) { if ((iterPointPrim != ptOrigin) && (iterPointPrim != ptDest)) { append(tempOpposedEdge, iterPointPrim); } } if (pointedge(geoself(),tempOpposedEdge[0],ptOrigin) != -1) { append(opposedEdge, tempOpposedEdge[0]); append(opposedEdge, tempOpposedEdge[1]); } else { append(opposedEdge, tempOpposedEdge[1]); append(opposedEdge, tempOpposedEdge[0]); } return opposedEdge; } // Function returning the number of the prim adjacent to the prim sent as input and sharing an edge defined by its two points, and return -1 if empty in case of open surface function int findAdjacentPrim(int numprim, ptOrigin, ptDest; int visitedPoints[]) { int adjprim = -1; int resultTest; int adjacentPrims[] = findPrimFromEdge(ptOrigin, ptDest); foreach (int iterprim; adjacentPrims) { if (iterprim != numprim) { adjprim = iterprim; } } return adjprim; } // Function that add the number of adjacent unvisited primitives to a list, and the id of the points of the shared edges with that prim to another list, from an input composed by a prim and an edge function int addList(int primnumR, primnumL, ptOriginR, ptDestR, ptOriginL, ptDestL; int listOfPrimsR[], listOfPrimsL[], listOfPointsR[], listOfPointsL[], visPoints[], visPrims[]; int compteur; int compteurlist[]) { int oppEdgeR[] = findOpposedEdge(primnumR, ptOriginR, ptDestR); int oppEdgeL[] = findOpposedEdge(primnumL, ptOriginL, ptDestL); int ajout = 0; append(visPrims, primnumR); append(visPrims, primnumL); int adjPrimsR[]; int adjPrimsL[]; append(adjPrimsR, findAdjacentPrim(primnumR, oppEdgeR[0], oppEdgeR[1], visPoints)); append(adjPrimsR, findAdjacentPrim(primnumR, ptOriginR, oppEdgeR[0], visPoints)); append(adjPrimsR, findAdjacentPrim(primnumR, ptDestR, oppEdgeR[1], visPoints)); append(adjPrimsL, findAdjacentPrim(primnumL, oppEdgeL[0], oppEdgeL[1], visPoints)); append(adjPrimsL, findAdjacentPrim(primnumL, ptOriginL, oppEdgeL[0], visPoints)); append(adjPrimsL, findAdjacentPrim(primnumL, ptDestL, oppEdgeL[1], visPoints)); if ((adjPrimsR[0] != -1) && (adjPrimsR[0] != primnumL)) { if (isInArray(adjPrimsR[0], visPrims) == 0) { append(listOfPrimsR, adjPrimsR[0]); append(listOfPrimsL, adjPrimsL[0]); append(listOfPointsR, oppEdgeR[0]); append(listOfPointsR, oppEdgeR[1]); append(listOfPointsL, oppEdgeL[0]); append(listOfPointsL, oppEdgeL[1]); append(visPoints, oppEdgeR[0]); append(visPoints, oppEdgeR[1]); append(visPoints, oppEdgeL[0]); append(visPoints, oppEdgeL[1]); append(compteurlist, compteur); ajout++; } } if ((adjPrimsR[1] != -1) && (adjPrimsR[1] != primnumL)) { if (isInArray(adjPrimsR[1], visPrims) == 0) { append(listOfPrimsR, adjPrimsR[1]); append(listOfPrimsL, adjPrimsL[1]); append(listOfPointsR, ptOriginR); append(listOfPointsR, oppEdgeR[0]); append(listOfPointsL, ptOriginL); append(listOfPointsL, oppEdgeL[0]); append(visPoints, ptOriginR); append(visPoints, oppEdgeR[0]); append(visPoints, ptOriginL); append(visPoints, oppEdgeL[0]); append(compteurlist, compteur); ajout++; } } if ((adjPrimsR[2]!= -1) && (adjPrimsR[2] != primnumL)) { if (isInArray(adjPrimsR[2], visPrims) == 0) { append(listOfPrimsR, adjPrimsR[2]); append(listOfPrimsL, adjPrimsL[2]); append(listOfPointsR, ptDestR); append(listOfPointsR, oppEdgeR[1]); append(listOfPointsL, ptDestL); append(listOfPointsL, oppEdgeL[1]); append(visPoints, ptOriginR); append(visPoints, oppEdgeR[0]); append(visPoints, ptOriginL); append(visPoints, oppEdgeL[0]); append(compteurlist, compteur); ajout++; } } return ajout; } // MAIN ALGORITHM FUNCTION function void findTopology(int ptOriginMedian, ptDestMedian) { int listPtR[]; int listPtL[]; int listPrimR[]; int listPrimL[]; int visitedPoints[]; int visitedPrims[]; int primsStart[]; int safeguard; int resulthandle; int countPrim; int counttreat = 0; int countlist[]; int currentPtOrigR; int currentPtDestR; int currentPtOrigL; int currentPtDestL; int currentPrimR; int currentPrimL; int actif = 1; primsStart = findPrimFromEdge(ptOriginMedian,ptDestMedian); append(listPrimR, primsStart[0]); append(listPrimL, primsStart[1]); append(listPtR, ptOriginMedian); append(visitedPoints, ptOriginMedian); append(listPtL, ptOriginMedian); append(listPtR, ptDestMedian); append(visitedPoints, ptDestMedian); append(listPtL, ptDestMedian); safeguard = 0; while ((actif != 0) && safeguard < 200) { countPrim = len(listPrimR); actif = 0; for (int i=0; i < countPrim; i++) { if (isInArray(listPrimR,visitedPrims) == 0) { currentPrimR = listPrimR; currentPrimL = listPrimL; currentPtOrigR = listPtR[2*i]; currentPtDestR = listPtR[2*i + 1]; currentPtOrigL = listPtL[2*i]; currentPtDestL = listPtL[2*i + 1]; counttreat++; actif += addList(currentPrimR, currentPrimL, currentPtOrigR, currentPtDestR, currentPtOrigL, currentPtDestL, listPrimR, listPrimL, listPtR, listPtL, visitedPoints, visitedPrims, counttreat, countlist); } } // Safeguard to avoid endless loops safeguard++; printf("Loop: %d\n",safeguard); } printf("ListPrimR : %d et ListPrimL : %d\n", len(listPrimR), len(listPrimL)); printf("ListPointR : %d et ListPointL : %d\n", len(listPtR), len(listPtL)); printf("Countlist : %d\n", len(countlist)); for (int index = 0; index<len(listPtR); index++) { resulthandle = setpointattrib(geoself(),"symnum",listPtR[index],listPtL[index]); resulthandle = setpointattrib(geoself(),"symnum",listPtL[index],listPtR[index]); resulthandle = setpointattrib(geoself(),"traitement",listPtR[index],countlist[index]); resulthandle = setpointattrib(geoself(),"traitement",listPtL[index],countlist[index]); resulthandle = setpointattrib(geoself(),"Cd", listPtL[index], {1,0,0}); resulthandle = setpointattrib(geoself(),"Cd",listPtR[index],{0,1,0}); } } // LAUNCH !! findTopology(8659, 2265); And then the code to put on a point wrangle set to run on POINTS : vector symP = point(geoself(),"P", i@symnum); vector moyP; if (@symnum == @ptnum) { @Cd = {0,0,1}; @P.x = 0; @group_center = 1; } else { moyP.x = (@P.x - symP.x)/2; moyP.y = (@P.y + symP.y)/2; moyP.z = (@P.z + symP.z)/2; @P = moyP; } Hope this can be useful for people out there.
×