//get X Y Z Vector per prim


int primpts[] = primpoints(0,@primnum);

//get prim edge
int edgeA = primhedge(0, @primnum);
int edgeB = hedge_next(0, edgeA);

//get prim edge points id
int edgeA_p1 = hedge_srcpoint(0, edgeA);
int edgeA_p2 = hedge_dstpoint(0, edgeA);
int edgeB_p1 = hedge_srcpoint(0, edgeB);
int edgeB_p2 = hedge_dstpoint(0, edgeB);

//get prim edge points poistion
vector a1 = point(0, "P", edgeA_p1);
vector a2 = point(0, "P", edgeA_p2);
vector b1 = point(0, "P", edgeB_p1);
vector b2 = point(0, "P", edgeB_p2);

vector x = normalize(a2-a1);
vector t = normalize(b2-b1);
vector y = cross(x, t);
vector z = cross(x, y);

v@vX = x;
v@vY = y;
v@vZ = z;

/*
vector center = getbbox_center(0);

matrix m = set(x,y,z, center);
setcomp(m, 0, 0, 3);
setcomp(m, 0, 1, 3);
setcomp(m, 0, 2, 3);

4@xform = m;
*/

v@N = set(v@vZ[0], v@vZ[1], v@vZ[2]);

float t = chf("t");

// matrix to transform by
matrix tf = ident();
rotate(tf, radians(t), {0,1,0});
//rotate(tf, radians(t), @N);


// prim existing matrice
matrix transform = getpackedtransform(0, @primnum);
setpackedtransform(0, @primnum, transform * tf);

// we can't rotate locally around a world axis, we need to rotate around a local axis. 
// the "spin" axis for this flag is Z if you look at the original instance.
// to find local Z, we can multiply world Z by our transform matrix.

// we don't want to affect @P, so rather than using getpackedtransform and setpackedtransform,
// we'll use primintrinsic() and setprimintrinsic() to set the "transform" intrinsic, which
// does not modify @P.

matrix3 transform = primintrinsic(0, "transform", @ptnum);
vector axis = transform * {0,0,1};


// the rotate VEX function applies to matrix3 transform "in-place" (that's what the "&" means in the documentation)
rotate(transform, radians(i@randRot), axis);
// now set the packed transform intrinsic to this transform we rotated
//setprimintrinsic(0, "transform", @ptnum, transform, "set");

vector vScale = {0.5, 0.5,0.5};
vector vTrans = {0,0,-0.25};

matrix transform2 = set(transform);
scale(transform2, vScale);
translate(transform2, vTrans);

setprimintrinsic(0, "transform", @ptnum, transform2, "set");