kunz Difference between revisions of "VEX Wrangle Snippets"

Difference between revisions of "VEX Wrangle Snippets"

From kunz
Line 440: Line 440:
[[File:vex_map_grid_to_circle.gif | 340px | right]]
[[File:vex_map_grid_to_circle.gif | 340px | right]]
Working with polar coordinates to map a square onto a circle.
Working with polar coordinates to map a square onto a circle.





Revision as of 21:12, 27 July 2023

Translate

vex offset position.gif

Offset the position of geometry







vex_offset_position.hiplc

@P += {1, 0, 0};

Taper

taper vex 001.gif


Reduces the circumference by scaling along the XZ plane based on the height of the geometry.



taper_vex_001.hiplc

float taper = relbbox(0,@P).y;
// Remap the taper range
taper = fit01(taper, 1, fit01(sin(@Time*PI/5)*0.5+0.5, 2.5, .5));
// Apply the taper by scaling along the X and Y axis
@P *= set(taper,1,taper);


Boxify

vex boxify 001.gif


Distorts the geometry, morphing it into a box shape

vex_boxify_001.hiplc

vector centroid = getbbox_center(0);
vector size = getbbox_size(0);
size = min(size); // Largest component
@P -= centroid;
@P *= (1.0/size);
@P = lerp(@P, @P+clamp(normalize(@P)*1.75,vector(-1),vector(1)) * (1.0-length(max(abs(@P)))), chf('blend'));
@P *= size;
@P += centroid;


Spherify

vex spherify 001.gif

Distorts the geometry into a sphere shape



vex_spherify_001.hiplc

vector centroid = getbbox_center(0);
vector size = getbbox_size(0);
size = min(size); // Largest component
@P -= centroid;
@P *= (1.0/size);
@P = lerp(@P, normalize(@P), chf('blend'));
@P *= size;
@P += centroid;

Stretch

vex stretch 001.gif

Stretch the geometry across it's X axis

Add one component of position to itself to stretch the geometry away from it's center. You can control the amount of stretching by multiplying the position before adding it to itself.



vex_stretch_001.hiplc

vector centroid = getbbox_center(0);
@P -= centroid;
@P.x += @P.x*chf('amt');
@P += centroid;

Shape Blending

vex position blend.gif

Blend between point attributes to produce a morph effect






vex_position_blend.hiplc

@P = lerp(@P, @opinput1_P, chf('blend'));
@N = lerp(@N, @opinput1_N, chf('blend'));

Snap to Grid

vex snap to grid.gif

Snap (quantize) point positions to a grid for a downres effect






File:vex_snap_to_grid.hiplc

float grid_scale = chf('grid_scale');
@P = rint(@P*grid_scale)/grid_scale;

Swizzle Coordinate System

Switch between Y up and Z up coordinates using swizzle

@P = @P.xzy * set(-1,1,1);

Twirl

vex twirl.gif

Twirl the geometry around the Y axis





vex_twirl.hiplc

float a = chf('angle') * length(@P * {1, 0, 1});
float u = atan2(@P.x, @P.z);
float r = length(@P * {1, 0, 1});
@P = set(sin(u-a), @P.y, cos(u-a)) * set(r,1,r);



Peak

vex push surface along normals.gif

Move the surface along it's normals, producing an inflation effect







vex_push_surface_along_normals.hip

@P += normalize(@P) * chf('scale');

Exploded View

vex exploded view.gif

Moves each packed piece outward from the geometry centroid







vex_exploded_view.hiplc

@P += (@P - getbbox_center(0)) * chf('scale');

Point Jitter

Jitter each point by a random spherical direction

@P += sample_sphere_uniform(rand(@elemnum+chf('seed'))) * chf('scale');

Plexus Effect

Connect nearby points

foreach(int pt; nearpoints(0, @P, 0.5, 250))    {
    if(pt > @ptnum)
        addprim(0, 'polyline', @ptnum, pt);
}

Connect to Nearest Point

Draw a line to the closest point of the second input

addprim(0, 'polyline', @ptnum, addpoint(0, vector(point(1,'P',nearpoint(1,@P)))) );

Connect to Closest Surface Position

Draw a line to the closest surface position

addprim(0, 'polyline', @ptnum, addpoint(0, minpos(1,@P) );

Randomize the Rotation of Packed Primitives

Update the transform intrinsic to a random orientation

vector r = sample_direction_uniform(rand(@primnum));
matrix3 x = primintrinsic(0,'transform',i@primnum);
rotate(x, PI*pow(rand(@primnum-666),0.5), r);
setprimintrinsic(0,'transform',i@primnum,x);

Randomize the Scale of Packed Primitives

Update the transform intrinsic to a apply a random scale

vector s = rand(i@primnum);
s = s.yyy;  // Uniform Scale
matrix3 x = primintrinsic(0,'transform',i@primnum);
scale(x, s);
setprimintrinsic(0,'transform',i@primnum,x);

Random Color from Normal Direction

Generate random colors based on the surface normal, adjust the multiplier to control the amount of colors

v@Cd = rand(rint(v@N*8));

Iterative Face Insetting

Recursive divide and inset edges, via @d_gfx, excellent use of arrays

int pts[] = primpoints(0,@primnum); vector pos[];
int edge_div_pts[]; vector edge_div_pos[];
foreach( int pt; pts ) 
    append(pos, vector(point(0,'P',pt)));
for( int i = 0; i < chi('iterations'); i++ )    {
    resize(edge_div_pts,0); // empty
    resize(edge_div_pos,0); // empty
    for( int j = 0; j < len(pts); j++ ) {
        append(edge_div_pos, lerp( pos[j], pos[(j+1)%len(pts)], chf('div_ratio') ));
        append(edge_div_pts, addpoint(0, edge_div_pos[-1])); // [-1] grabs the last item from an array
    }
    for (int k = 0; k < len(pts); k++ ) {
        addprim(0, 'poly', pts[k], edge_div_pts[k], edge_div_pts[(k+2)%len(pts)]);
    }
    pts = edge_div_pts;
    pos = edge_div_pos;
}
addprim(0, 'poly', edge_div_pts);
removeprim(0,@primnum,1); // Remove the input prim and any points belonging to it

Iridescent Color Function

vex iridescent.gif


Produce an iridescent color ramp from any varying value, from shadertoy





vex_iridescent.hiplc

float amt = dot(@N, set(0,1,0))*0.5+0.5;
v@Cd =  (0.5 + 0.5 * cos( PI*2*( amt + set(0,1,2)/3) ) );

Rainbow Colors from HSV Colorspace

vex hsvtorgb rainbow 001.gif


You can easily control the hue, while keeping the saturation and value the same using the hsvtorgb function.

This allows you to easily create rainbows, gradients, perform hue rotations and produce complimentary colors.





vex_hsvtorgb_rainbow_001.hiplc

v@Cd = hsvtorgb( set(relbbox(0,@P).z - @Time/5 + dot(@N,set(0,1,0))/2, 1, 1));

Rainbow Cycle with frac function

rainbow cycle w frac VEX.gif


Using the frac function, you can cycle through a rainbow over a desired amount of elements.

This is then offset by adding the current time to the fractional value, which produces the scrolling effect.




vex_frac_rainbow_cycle_001.hiplc

v@Cd = hsvtorgb(set(frac(@elemnum/8.0)+@Time/10, 1, 1));

Loop Over All Attributes

string pt_attrs[] = detailintrinsic(1,'pointattributes');
foreach( string pt_attr; pt_attrs ) {
    if( pt_attr ~= 'attr_name*' ) {
        setpointgroup(0, pt_attr, @ptnum, 1);
    }
}

Remove Faces Across Bounding Box

if( relbbox(0,@P).x < rand(@primnum) )
    removeprim(0,@primnum,1);

Torus Knot

Online Knot Viewer

float u = float(@ptnum)/(@numpt-1);
u += @Time/10.0;
u %= 1.0;
u *= PI * 2;
float r = 2.0;
float q = 2;
float p = 3;
f@u = u;
@P.x += cos(u*q) * (cos(u*p)+r);
@P.y += sin(u*q) * (cos(u*p)+r);
@P.z += sin(u*p);

Remap Grid to Circle

vex map grid to circle.gif

Working with polar coordinates to map a square onto a circle.


vex_map_grid_to_circle.hiplc

@P += {0.5, 0.5, 0}; // Remap the grid to zero to one range
float theta = @P.x;
float radius = @P.y/2;
@P = 0;
@P.x = sin(theta*PI*2 ) * radius;
@P.y = cos(theta*PI*2 ) * radius;

Make a Quad

int prim = addprim(0,'poly');
addvertex(0,prim,addpoint(0,set(0,0,0)) );
addvertex(0,prim,addpoint(0,set(1,0,0)) );
addvertex(0,prim,addpoint(0,set(1,0,1)) );
addvertex(0,prim,addpoint(0,set(0,0,1)) );

Make a Grid

for(int i = 0; i<8; i++)    {
    for(int j = 0; j<8; j++)    {
        int prim = addprim(0,'poly');
        addvertex(0,prim,addpoint(0,set(i,0,j)) );
        addvertex(0,prim,addpoint(0,set(i+1,0,j)) );
        addvertex(0,prim,addpoint(0,set(i+1,0,j+1)) );
        addvertex(0,prim,addpoint(0,set(i,0,j+1)) );
    }
}

Make a Circle

vex make circle.gif

This example shows how you can generate a circle or N sided polygon using a for loop, sin and cos.

Run the code in detail mode with an attribute wrangle.

This is essentially the same idea as the circle node but hopefully a beneficial example to see how this type of geometry is generated via VEX.

vex_make_circle_001.hiplc

int prim = addprim(0,'poly');
int seg = chi('segments');
for( int i = 0; i<seg; i++ )  {
    float u = float(i)/seg * 2*PI;
    addvertex(0, prim, addpoint(0, set(sin(u),0,cos(u))) );
}

Groups to Attribute

From zybrand

//convert numbered groups to a numbered attribute
string groups[] = detailintrinsic(0, "primitivegroups");
int prim = @primnum;
string elemnum;

foreach(string i; groups)
{
    //if the current primitive is in group i
    if(inprimgroup(0,i,prim) == 1)
    {
        elemnum = re_find(r"\d{3,6}",i);
    }
}
s@number = elemnum;


Looping Curl Noise

2022 12 11 looping curl noise.gif


It's possible to achieve seamless looping animation from curl noise by blending between two noises.

In this example one noise function is evaluated at the current time, and a second noise function is evaluated at the time shifted back by the desired loop duration.

The result of these two noise functions are blended from one to the other over the duration.




vex_looping_noises.hiplc

// Position x Frequency
vector p = @P*0.5;
// Speed
float s = 0.5;
// Loop Length (in seconds)
float l = 5;
// Time % duration
float t = (@Time%l);
// Blending
vector v0 = curlgxnoise(p + set(0,0,0,t*s));
vector v1 = curlgxnoise(p + set(0,0,0,(t-l)*s));
@P += lerp(v0,v1,frac(@Time/l)) * 0.35;