Category: hou-general

Archived post by Bender

From @trzanko ray sop or prim uv’s don’t yield super great accuracy, as it only interpolates among a primitive’s points, to get a smooth position you can leverage the osd vex functions
here’s my subdiv ray snippet which illustrates this, you can see the diff between the osd pos and the primuv pos if you comment out the line which declares the variable sDP
“`int primNum; vector UV;
float dist = xyzdist( 1, @P, primNum, UV);
vector restN = primuv(1,”N”,primNum,UV); vector posOnRest = primuv(1,”P”,primNum,UV);
//subdiv float pU, pV; int pId; int patch = osd_lookuppatch( 1, primNum, UV.x, UV.y, pId, pU, pV);
//these two functions return the last argument //so posOnRest is being overwritten in the function, much like xyzdist() int sDN = osd_limitsurface( 1, ‘N’, pId, pU, pV, restN); int sDP = osd_limitsurface( 1, ‘P’, pId, pU, pV, posOnRest);
@P = posOnRest;“`

posting Tighe’s post for re-gemming

Archived post by Lorne

I can’t believe that all my years in Houdini I havent thought to just make a little pop solver to create decent drone camera moves

get a curve force in there, some wind, blend between a few lookat targets that have some drift on them as well

it’s pretty cinematic

disclaimer: this was like a 15min thing and I’m sure this is a mess

you could also set up an @v on the main follow curve and pipe that into the popcurveforce if you wanted regions where the camera speeds up/slows down

Attachments in this post:
http://fx-td.com/houdiniandchill/wp-content/uploads/discord/20191809/20/19/drone_cam_sim_v001.mp4
http://fx-td.com/houdiniandchill/wp-content/uploads/discord/20191809/20/19/drone_cam_sim_v001.hip

Archived post by chris_gardner

“`import tempfile import glob import os.path tempDir = tempfile.gettempdir()
files = filter(os.path.isfile, glob.glob(tempDir + “/crash.*.hip”)) if files: files.sort(key=lambda x: os.path.getmtime(x)) lastFile = os.path.join(tempDir, files[-1]).replace(‘\\’, ‘/’) hou.hipFile.load(file_name=str(lastFile), suppress_save_prompt=False)“`

load latest crash file

Archived post by Mark

it might not be the most efficient way, but iw as able to do it using l systems and a find shortest path – convert curveu to worldspace, apply parallel transport, and rewrap the wires using one of my weaving setups.

i basically made sure the l system was branching in only 2 directions each generation and just hand selected a group right after the first branch haha

Attachments in this post:
http://fx-td.com/houdiniandchill/wp-content/uploads/discord/20191109/17/19/MF_Branch_Wrap_v01.hip

Archived post by Nick D

@Sepu swap $HIP to $JOB for all redshift textures

`def hipToJob(): for node in hou.node(“/”).allSubChildren(): if node.type().name()==”redshift::TextureSampler”: fileJob = node.parm(“tex0”).rawValue().replace(“$HIP”,”$JOB”) node.parm(“tex0”).set(fileJob)`

Archived post by rich lord

`// formula to change from one space to another // P = inverse(m1) * m2
// get the position and orient data vector start_p = point(0, “P”, 1); vector end_p = point(0, “P”, 2); vector4 start_orient = point(0, “orient”, 1); vector4 end_orient = point(0, “orient”, 2);
// calculate the blended values float blend = fit(@Frame, 1, 48, 0, 1); end_p = lerp(start_p, end_p, blend); end_orient = slerp(start_orient, end_orient, blend);
// matrix at start matrix3 start_m = qconvert(start_orient); vector start_n = set(start_m.zx, start_m.zy, start_m.zz); vector start_up = set(start_m.yx, start_m.yy, start_m.yz); matrix a = maketransform(start_n, start_up, start_p);
// matrix at end matrix3 end_m = qconvert(end_orient); vector end_n = set(end_m.zx, end_m.zy, end_m.zz); vector end_up = set(end_m.yx, end_m.yy, end_m.yz); matrix b = maketransform(end_n, end_up, end_p);
matrix final = invert(a) * b; pos = pos * final;`

There we go! Thanks so much! @TOADSTORM + @jake rice 😮 . Infinite fishies for me!

Need to handle scale, but I already have code for that.