random spin to particles/packed rigid bodies

stolen from a Toadstorm reply somewhere...

axis might be more finessed than just setting to z as shown.. Same goes for the angle, which I've brute forced to -90 times. Anyway, this will give a bit of spin to your packed rigid bodies

vector axis = set(0,0,1); // the random axis attribute you created

float angle = -90*fit01(rand(@ptnum), -1, 1); // change this to whatever range, in radians

vector4 q = quaternion(angle, axis);

v@w = qconvert(q);

solver storing the frame when attribute changes

 

Say you're transferring an attribute to an object. Eg. a sphere going along a curve and making it red.

Now you might want to store the frame that the curve receives the red attribute and use that information later - eg. do an attribute fade, so the attrib only starts fading when we reach the stored frame.

What you want to do is plug things into a solver, as above (just one input) and then....

in a wrangle-

vector newCd=point(1,"Cd",@ptnum);

if(@Cd!=newCd){

    if(@change_frame==0){

    @change_frame=@Frame;

    //i@changed += 1; //debugging

    }

    

}

What does this mean? Well, the Prev Frame is typically on the first input of point wrangles when in a solver... you are generally "adding" onto whatever was in the previous frame. (I always think about it the other way, but there you go). So we check to see what the "new" (or current frame) Cd value is.. And compare it to the existing (previous frame) value. If it is not the same, that means a change has occurred.

Now we check to see if the @change_frame value has been altered from zero or not. If it hasn't and is still zero, then we now make it equal to the current frame value.

solver transfer attribute, eg. colour accumulation

i always have to look this up on cgwiki...

the left stream is some sweat drops falling down a surface.. the right stream is the surface. 

It goes into a solver

The slight 0.0075 blend in the blendshape causes a slight fade of the attribute being transferred. Leaving it at zero will result in an absolute solver-accumulation of the value.

bringing object to origin

Not entirely sure how this deals with objects that move around A LOT, but for something mostly static that isn't near the origin it's good. Useful for simming stuff at zero then shoving back to where it came from.

In a point wrangle, move object to 0.0.0..

 // Get center of the oject bounding box (centroid)

vector min = {0, 0, 0};

vector max = {0, 0, 0};

getpointbbox(0, min, max);

vector centroid = (max + min)/2.0;

// Build and apply transformation matrix

vector translate = centroid + {0,-0.2,0};

vector rotate = {0,0,0};

vector scale = {1,1,1};

matrix xform = invert(maketransform(0, 0, translate, rotate, scale));

@P *= xform;

// Store transformation matrix in attribute

4@xform_matrix = xform;

Then in a later point wrangle, to revert back to original position

@P *= invert(4@xform_matrix);

queuing rops (for local renders)

 it seems like chaining rops breaks a bit - the frame ranges don't seem to get respected.

It's better to use a merge rop & specify strict frame range

mark fancher mograph video notes

 some mark fancher youtube vex tidbits-

//in a rig attrib wrangle, to rotate joints - take into account parenting!-

vector axis={1,0,0};

prerotate(4@localtransform, chf("angle"),axis);

-----------------------------------------------------------------------------------------

//in a rig attrib wrangle,to scale joints - take into account parenting-

prescale(4@localtransform, chf("scale"));

--------------------------------------------------------------------------------------------------------

//point wrangle, after a distance along geometry - nice rampable normalised mask

float map=f@map;

float p=chf("position");

float t=chf("transition");

t=max(t,0.0001); //clamps down value

p=fit01(p,-t,1); //makes mask zero when t at low values and p at zero

float mask=fit(map,p,p+t,1,0);

mask=chramp("ramp",mask);

f@mask=mask;

--------------------------------------------------------------------------------------------

how to store activation frame based on a threshold of something

in a point wrangle

if(@value>chf("threshold")){

i@group_active=1;

}

inside a solver...connect prev_frame to input 2 and input 1 to 1 of a point wrangle..

int prev_active=inpointgroup(1,"active",@ptnum); //check if previous frame was active

//if group active and NOT previously active then give active_frame value of current frame

if(i@group_active==1 && prev_active==0){

f@active_frame=@Frame;

}

float activationFramePrevious=point(1,"active_frame",@ptnum);

f@active_frame=max(activationFramePrevious, @active_frame);

simple spring solver - prev frame into input 1, input 1 into 2nd input of wrangle

based on F=-kx -bv

where F is force, k is the spring coefficient (stiffness), x is the distance, b is the damping and v is velocity. We also use F=ma to calculate acceleration (and use that for velocity, which ultimately gets added to Position)

float m=chf("mass");

float k=chf("stiffness");//stiffness coefficient

float b=chf("damping");//damping coefficient

vector p2=point(1,"P",@ptnum);//position of point on "current" frame

vector x=@P-p2; //distance between previous and current

vector f=-k*x -b*v@_v;//calculate force using damped harmonic motion equation

vector a =f/m; //get acceleration from f=ma to then find...

v@_v+=a;//velocity

v@P+=v@_v;//new position is calculated by adding velocity vector to current pos

creating orient and rotating points around vector

I think Toadstorm posted this somewhere on odforce... but it's a useful little vex snippet

 vector fwd = v@N;

vector up = {0,1,0};
// if you don't have a defined up vector but want to compute one the way houdini does it natively,
// compute the rotation that rotates +Z to N and apply this to +Y...
// matrix3 d = dihedral({0,0,1}, fwd);
// up = normalize(d * up);matrix3 m = maketransform(fwd, up);
// now you can rotate this around whatever axis you want.
vector axis = normalize(chv("axis")); // or use an existing vector attribute!
float angle = @noiseVal*radians(ch("angle")); // or use a random float attribute!
rotate(m, angle, axis);// now convert this rotated matrix to a quaternion and bind to p@orient. copy to points and/or DOPs will understand this.
@orient = quaternion(m);