{{ message }}

Instantly share code, notes, and snippets.

# csprance/Snippets.md

Last active Jun 20, 2019
VEX Snippets for Houdini
 //////////////////////////////////////////////////////////////// // Point Wrangle // Bisects a vector fixing the first and last points // Get the next points N vector prevPointP = point(0, 'P', @ptnum + 1); vector nextPointP = point(0, 'P', @ptnum - 1); // Create the bisected vector v@N = cross(normalize(nextPointP - prevPointP), v@up); // Check if it's the fist point if (@ptnum == 0){ // Create the bisected vector v@N = -cross(normalize(prevPointP - @P), v@up); } // Check if it's the last point if (@ptnum == @numpt - 1){ vector vec = normalize(-cross(@P - point(0, 'P', @ptnum - 1), {0, 1, 0})); @N = vec; } //////////////////////////////////////////////////////////////// // Prim Wrangle // Makes a primitive polywire sag good idea to resample it first int Count, Pt_List[]; float Fitted_Pt_Num, Ramped_Pt_Num; vector Modifier; Pt_List = primpoints(geoself(), 0); for(Count = 0; Count < len(Pt_List); Count++){ Modifier = set(0,0,0); Fitted_Pt_Num = efit(Count, 0, (len(Pt_List) - 1), 0, 1); Ramped_Pt_Num = chramp("sag_control", Fitted_Pt_Num); Modifier.y = -(Ramped_Pt_Num * chf("sag_multiplier")); //Modifier = set(1,Ramped_Pt_Num,1); setpointattrib(geoself(), "P", Pt_List[Count], Modifier, "add"); } //////////////////////////////////////////////////////////////// // Prim wrangle (Points Line N at next point) // Get Point Numbers (Should only ever be 2) int points[] = primpoints(0, @primnum); // resize(points, 2); // Get P of each point vector points_P[]; foreach (int point; points) { vector P = point(0, 'P', point); push(points_P, P); } setpointattrib(0, 'N', points[0], (points_P[1] - points_P[0])); setpointattrib(0, 'N', points[1], (points_P[0] - points_P[1])); //////////////////////////////////////////////////////////////// // Look for a value in an array // You should use find() instead int contains(int array[]; int value){ foreach (int check_val; array){ if (check_val == value){ return 1; } } return 0; } //////////////////////////////////////////////////////////////// // Prim Wrangle // This vex wrangle will find all the connected prim neighbors of an object int prim_edge, edge, prim, i, n, num; string neighbours = ""; i = 0; prim_edge = primhedge(@OpInput1, @primnum); while(i < primvertexcount(@OpInput1, @primnum)) { num = hedge_equivcount(@OpInput1, prim_edge); n = 0; while(n < num) { edge = hedge_nextequiv(@OpInput1, prim_edge); prim = hedge_prim(@OpInput1, edge); if(prim != @primnum) neighbours += sprintf("%g ", prim); prim_edge = edge; n++; } prim_edge = hedge_next(@OpInput1, prim_edge); i++; } s@neighbours = neighbours; /////////////////////////////////////////////// // If a prim @Cd is red return its primnum int has_red_neighbor(string primnums) { foreach(string s_primnum; split(primnums)) { int primnum = atoi(s_primnum); if (prim(0, 'Cd', primnum) == set(1, 0, 0)) return primnum; } return -1; } //////////////////////////////////////////////////////////////// int find_non_outerwall_neighbor(string primnums) { foreach(string s_primnum; split(primnums)) { int primnum = atoi(s_primnum); if (prim(0, 'group_outer_walls', primnum) == 0) return primnum; } return -1; } //////////////////////////////////////////////////////////////// // Get an interger list of the primitive attribute neighbors int[] get_neighbors_from_primnum(int primnum) { int int_neighbors[] = array(); string neighbors[] = split(prim(0, 'neighbors', primnum)); foreach(string n_primnum; neighbors) { push(int_neighbors, atoi(n_primnum)); } return int_neighbors; } //////////////////////////////////////////////////////////////// // If a primitive has any neighbor primitive points that share a point with any other neighbor // that piece is an elbow piece int is_elbow(int primnum) { int seen_points[] = array(); // Get the neighbors int neighbors[] = get_neighbors_from_primnum(primnum); foreach(int n_primnum; neighbors) { // get the neigbor points int neighbor_points[] = primpoints(0, n_primnum); foreach(int pointnum; neighbor_points) { // If we've seen the point return immediatly if (find(seen_points, pointnum) >= 0) { return 1; } // add the seen points to the arry push(seen_points, pointnum); } } return 0; } //////////////////////////////////////////////////////////////// int[] split_neighbors_to_int_array(string neighbors) { int ret_arr[] = array(); foreach(string primnum; split(neighbors)) { push(ret_arr, atoi(primnum)); } return ret_arr; } //////////////////////////////////////////////////////////////// int[] get_blue_neighbors(string str_neighbors) { int blue_neighbors[] = array(); int neighbors[] = split_neighbors_to_int_array(str_neighbors); foreach(int primnum; neighbors) { if (prim(0, 'Cd', primnum) == set(0, 0, 1)) { push(blue_neighbors, primnum); } } return blue_neighbors; } //////////////////////////////////////////////////////////////// vector get_first_blue_neighbors_vector(int blue_neighbors[]) { vector facing_arr[] = array(); foreach(int primnum; blue_neighbors) { vector facing = prim(0, 'facing', primnum); push(facing_arr, facing); } return facing_arr[1]; } //////////////////////////////////////////////////////////////// int find_first_unseen(int seen_prims[]; int neighbors[]) { foreach(int neighbor; neighbors) { if (find(seen_prims, neighbor) >= 0) {} else { return neighbor; } } } //////////////////////////////////////////////////////////////// // OpInput1: is usually just @OpInput1 and primnum is @primnum string neighbor_prims(string OpInput1; int primnum) { int prim_edge, edge, prim, i, n, num; int neighbours_arr[] = array(); string neighbors = ""; i = 0; prim_edge = primhedge(OpInput1, primnum); while (i < primvertexcount(OpInput1, primnum)) { num = hedge_equivcount(OpInput1, prim_edge); n = 0; while (n < num) { edge = hedge_nextequiv(OpInput1, prim_edge); prim = hedge_prim(OpInput1, edge); if (prim != primnum) { neighbors += sprintf("%s ", prim); push(neighbours_arr, prim);; } prim_edge = edge; n++; } prim_edge = hedge_next(OpInput1, prim_edge); i++; } return neighbors; } //////////////////////////////////////////////////////////////// // OpInput1: is usually just @OpInput1 and primnum is @primnum int[] neighbor_prims_i(string OpInput1; int primnum) { int prim_edge, edge, prim, i, n, num; int neighbours_arr[] = array(); i = 0; prim_edge = primhedge(OpInput1, primnum); while (i < primvertexcount(OpInput1, primnum)) { num = hedge_equivcount(OpInput1, prim_edge); n = 0; while (n < num) { edge = hedge_nextequiv(OpInput1, prim_edge); prim = hedge_prim(OpInput1, edge); if (prim != primnum) { push(neighbours_arr, prim);; } prim_edge = edge; n++; } prim_edge = hedge_next(OpInput1, prim_edge); i++; } return neighbours_arr; } //////////////////////////////////////////////////////////////// vector get_direction_from(int primnum1; int primnum2){ vector direction = prim(0,'P', primnum2) - prim(0, 'P', primnum1); return normalize(set(direction.x, direction.y, direction.z)); } //////////////////////////////////////////////////////////////// int is_left(int primnum; int neighbor_primnum){ if (get_direction_from(primnum, neighbor_primnum) == set(1, 0, 0) ){ return 1; } return 0; } //////////////////////////////////////////////////////////////// int is_right(int primnum; int neighbor_primnum){ if (get_direction_from(primnum, neighbor_primnum) == set(-1, 0, 0) ){ return 1; } return 0; } //////////////////////////////////////////////////////////////// int is_above(int primnum; int neighbor_primnum){ if (get_direction_from(primnum, neighbor_primnum) == set(0, 0, 1) ){ return 1; } return 0; } //////////////////////////////////////////////////////////////// int is_below(int primnum; int neighbor_primnum){ vector dir = get_direction_from(primnum, neighbor_primnum); if (dir == set(0, 0, -1)){ return 1; } return 0; } //////////////////////////////////////////////////////////////// int has_neighbors_above(int primnum){ int neighbors[] = get_neighbors_from_primnum(primnum); foreach (int neighbor_prim; neighbors){ if (is_above(primnum, neighbor_prim)){ return 1; } } return 0; } //////////////////////////////////////////////////////////////// int has_neighbors_left(int primnum){ int neighbors[] = get_neighbors_from_primnum(primnum); foreach (int neighbor_prim; neighbors){ if (is_left(primnum, neighbor_prim)){ return 1; } } return 0; } //////////////////////////////////////////////////////////////// int has_neighbors_right(int primnum){ int neighbors[] = get_neighbors_from_primnum(primnum); foreach (int neighbor_prim; neighbors){ if (is_right(primnum, neighbor_prim)){ return 1; } } return 0; } //////////////////////////////////////////////////////////////// int has_neighbors_below(int primnum){ int neighbors[] = get_neighbors_from_primnum(primnum); foreach (int neighbor_prim; neighbors){ if (is_below(primnum, neighbor_prim)){ return 1; } } return 0; } //////////////////////////////////////////////////////////////// int[] get_shape_array(int primnum){ int shape_array[] = array(); push(shape_array, has_neighbors_left(primnum)); push(shape_array, has_neighbors_right(primnum)); push(shape_array, has_neighbors_above(primnum)); push(shape_array, has_neighbors_below(primnum)); return shape_array; } //////////////////////////////////////////////////////////////// int array_equivelant(int arr1[]; int arr2[]){ int i = 0; foreach(int val; arr2) { // If a value doesn't match return back false if (val != arr1[i]){ return 0; } i += 1; } // All the values match return true return 1; }
```// Detail Wrangle
vector bbsize = getbbox_size(0);
v@size = bbsize; // For reference

s@x = sprintf('%.3f', bbsize.x);
s@y = sprintf('%.3f', bbsize.y);
s@z = sprintf('%.3f', bbsize.z);```

The long way around. No Rounding

```//Detail Wrangle No Rounding
string trunced_vec[] = array();
resize(trunced_vec, 3);
vector bbsize = getbbox_size(0);
v@size = bbsize;
string str_bbsize[] = array(sprintf('%f', bbsize.x),sprintf('%f', bbsize.y),sprintf('%f', bbsize.z));

int i = 0;
foreach (string axis; str_bbsize){
string whole_number = split(axis, '.')[0];
string decimal = split(axis, '.')[1][:3];
trunced_vec[i] = sprintf('%s.%s', whole_number, decimal);
i++;
}

s@x = trunced_vec[0];
s@y = trunced_vec[1];
s@z = trunced_vec[2];```

and then if you use a spare input on a Font Sop or whatever node you're using you can do a

`details(-1, 'x')`

`details(-1, 'y')`

`details(-1, 'z')`