Senior FX TD / Artist

Welcome to my Everyday FX Script Collection!

Ali Rizvi

DISCOVER A SET OF ESSENTIAL VEX SCRIPTS I USE DAILY IN MY FX WORK. FROM PROCEDURAL MODELING TO SIMULATION, THESE SCRIPTS STREAMLINE TASKS AND ENHANCE PRODUCTIVITY. WHETHER YOU'RE A SEASONED PRO OR JUST STARTING, THESE TOOLS ARE DESIGNED TO ELEVATE YOUR FX PROJECTS. FEEL FREE TO EXPLORE, ADAPT, AND INTEGRATE THEM INTO YOUR WORKFLOW. HAPPY SCRIPTING!! 

​//=====================================

// Filtering data based of SDF 

float dist = volumesample(1,0,@P);
vector grad = volumegradient(1,0,@P);

if(dist<chf('val')){
    //removepoint(0,@ptnum);
    @Cd = set(1,0,0);
    }

//=====================================

// Noise in vex same as vops using Antialias noise function

#include <voptype.h>
#include <voplib.h>
float amp = chf('amplitude');
vector freq = chv('freq');
vector offset = chv('offset');
float roughness = chf('roughness');
vector noise = vop_fbmNoiseVV(@P * freq - offset, roughness, 8, "noise")*amp;
v@N = v@v+noise;

// Another antialias noise function example

#include <voptype.h>
#include <voplib.h>
float amp = chf('amplitude');
vector freq = chv('freq');
vector offset = chv('offset');
float roughness = chf('roughness');
vector noise = vop_fbmNoiseVV(@P * freq - offset, roughness, 8, "noise")*amp;
@nv = noise.x;
@noise = fit(noise.x,chf('old_min'),chf('old_max'),chf('new_min'),chf('new_max'));
@N *= @noise;

//=====================================

// Delete by Y axis position value

if(@P.y<chf('val')){
    removepoint(0,@ptnum);
    }
//=====================================

// Delete by max size index

vector bbox = relbbox(0,@P);
vector size = getbbox_size(0);
int max_index = find(set(size), max(size));
@Cd = chramp("clr_ramp",bbox[max_index]);

//=====================================

// Coloring based of bounding box information

vector bound = relbbox(0,@P);
v@Cd = set(0,0,0);
float boundfit  = fit01(bound[0],0,1);
f@Cd.x = vector(chramp("color_ramp",boundfit));

//=====================================

// Displace along normal

@P += @N*chf('push');

//=====================================

// Noise fade over a frame range

if(@Frame>fit01(@noise,chf("fade_start"),chf("fade_end"))){
    removepoint(0,@ptnum);
    } 

//=====================================

// Randomize pscale based of point numbers

i@pid = @ptnum;
@pscale = fit01(rand(@pid*chf('seed')),chf('min_val'),chf('max_val'));

//=====================================

// Center N direction

vector pos = point(1,"P",0);
vector mid = normalize(pos-@P);
float adist = distance(@P,pos);
float dist = fit(adist,1,7,chf('min_dist'),chf('max_dist'));
@N = slerp(@N,mid,chf("bias"))*dist;

//=====================================

// Curve color ramp

float ramp = @ptnum/ float (@numpt-1);
@Cd = chramp("ramp",ramp);

//=====================================

// Radial push

int maxpts = chi("max_points");
float maxdist = chf("max_dist");
int n[] = nearpoints(1,@P,maxdist,maxpts);
foreach(int pt; n){
    vector pos = point(1,"P",pt);
    int id_match = point(1,"cid",pt); //cid is an color attribute value coming in from previous input
    float dist = distance(pos,@P);
    //@dist = dist;
    if(id_match==@cid && dist>=0){
        @N = normalize(pos-@P);
        @P += @N * min(chf("push")*pow(fit(dist,0,0.2,0,1),1.25),dist);
        }

//=====================================

// Curve lookup

float radius = chf("radius");
int maxpt = chi("maxpt");
int closepts[] = pcfind(1,"P",@P,radius,maxpt);
i[]@test = closepts;
foreach(int pt; closepts){
    float int_radius= chf("int_radius");
    int int_maxpt= chi("int_maxpt");
    int h = pcopen(1,"P",@P,int_radius,int_maxpt);
    vector clr = pcfilter(h,"Cd");
    vector dir = pcfilter(h,"N");
    float cnum = pcfilter(h,"curve_num");
    @ttest = cnum;
    if(cnum==@cid){
        @Cd = clr;
        @N=dir;
        }
}

//=====================================

// Points lookup from second input to create a soft Cd attriuteb transfer falloff 

float maxrad = chf("maxrad"); 
int maxpt = chi("maxpts"); 
//int handle = pcopen(1,"P",@P,maxrad,maxpt); 
int closept[] = pcfind(1,"P", @P, maxrad,maxpt); 
foreach(int pt; closept){ 
    float pscale = point(1, "pscale", pt); 
    vector color = point(1, "Cd", pt); 
    vector pos =  point(1, "P", pt); 
    i@id = point(1,"id",pt); 
    @Cd = pow(max(@Cd,color * fit(distance(@P, pos), 0, pscale, 1, 0)),0.9); 
} 

//=====================================

// Push on direction and applying noise on impacted region (position push and direction from the center) 

#include <voptype.h> 
#include <voplib.h> 
int ref_pt = idtopoint(1, i@id); 
vector pos = point(1, 'P', ref_pt); 
vector point_POS = point(1,"P",ref_pt); 
float flow_red = @Cd.r; 
if(flow_red>0){ 
    @Cd.r = flow_red; 
    vector dir_POS = normalize (point_POS - @P); 
    vector freq = chv("freq"); 
    vector offset = chv("offset"); 
    float amp = chf("amp"); 
    //float dist_N = len(@N); 
    float noise; 
    noise = abs(vop_fbmNoiseVV(v@rest * freq - offset, 0.1, 4, "noise")); 
    noise = fit01(noise,0,0.7); 
    noise *= amp; 
    noise *= flow_red; 
    //float noise = (noise(@P*freq+offset)*amp)*flow_red; 
    //dir_POS *= dist_N*0.4; 
      dir_POS *=  chf("scale")*noise; 
    //v@dir_POS=dir_POS; 
    @P += dir_POS*flow_red; 
    }  

//=====================================

// Rotating vector for source/thruster direction 

v@N = normalize(@N); 
vector pos = point(1,"P",0); 
vector pos1 = point(2,"P",0); 
vector z = normalize(@P-pos); 
vector y = normalize(@P-pos1); 
vector x = normalize(cross(y,z)); // z-axis (horizontal rotation) 
v@x = x ;    // NEW NORMAL 
v@y = y ; 
v@z  = z ; 
v@up = y; 
v@N = x; 

matrix3 m = ident(); 
float angle1 = chf("angle1"); 
rotate(m,angle1,z); 
v@N *= m; 

matrix3 m1 = ident(); 
float angle2 = chf("angle2"); 
rotate(m1,angle2,y); 

v@N *= m1;

//=====================================

// String attribute iterate/hack

string seperate[]  = split(s@path,"/");
s@splitgrp = seperate[4];
string getv = s@splitgrp;
s@catch_sup = getv[0:14];
//s@middle = getv[7:-9];
i@length = len(getv);
//s@catch = getv[7:-8];
//s@name = "debri"+@catch;
if(@length>23){
    s@catch = getv[7:-7];
    }
    else if (@length==23){
        s@catch = getv[7:-8];
        }
    else if (@length<23){
        s@catch = getv[7:-8];
        }
if(@length==23 && s@catch_sup=="catwalkSupport"){
    s@catch += getv[15];
    }
string num = re_find("([0-9]+)",s@catch);
s@aaa = num;
/*
string sep_catch[] = split(s@catch,"Support");
s[]@sep_catch = sep_catch;
string num = re_find("Shape", s@csplitgrp);
//s@tst = num;
s@csplitgrp = re_replace(num,"",@csplitgrp);    
*/

//=====================================

// Path Isolate

string seperate[]  = split(s@path,"/");
s@splitgrp = seperate[3];
string getv = s@splitgrp;
i@length = len(getv);
s@catch = getv[13];
s@debri = "debri"+@catch;

//=====================================

// Create orient attribute based on Normal and UP vectors

vector z = {0,0,1};
v@up = normalize(cross(v@N, z));
v@N = -normalize(v@N);
@orient = quaternion(maketransform(@N, @up));

//=====================================

​// Create a color ramp on a curve

float ramp = 1-@ptnum / float (@numpt);
v@map = vector(chramp("ramp",ramp));

//=====================================

// Create an array based of a point group then fech the data from index value

int rt_grp[] =expandpointgroup(0,"root");
i@root_num= rt_grp[0];

//=====================================

// Finding a nearby point using pcfind

float radius = 0.01;
int maxpts = 1;
int closept[] = pcfind(1,"P",@P,radius,maxpts);
i@root_ptnum = closept[0];
//i[]@test = closept;

// Use the above example  to iterate over found points

foreach(int num; closept){
    @map = point(1,"map",num);
    }

//=====================================

// Interpolating points on a curve/surface

f@sourceprim=0;
v@sourceprimuv[0]=@ptnum / float (@numpt);

float distance = xyzdistance(0,@P,sourceprim,sourceprimuv,maxdistance)

//=====================================

// This is commonly used inside solver sop if 2 inputs are coming in to record something based of any event over time

if(@trig!=1){

    vector pos = point(1,"P",0);
    float dist = distance(@P,pos);
    //f@dist=dist;
    if(dist>0.01){
        @trig=1;
        i@getFrame = @Frame;
        }
}

//=====================================

// Trasform a curve if it has proper tangents and normal at origin

vector tangentu_orig= point(0,"tangentu",0);
vector tangentv_orig= point(0,"tangentv",0);
vector NCross = cross(normalize(v@tangentu),normalize(v@tangentv));
//v@N = NCross;
vector center = getbbox_center(0);
vector P0 = point(0,"P",npoints(0)-1);
vector X = tangentu_orig;;
vector Y = v@N;//tangentu_orig;//v@tangentv;
vector Z = tangentv_orig;//v@tangentu;

matrix m = set(X,Y,Z,P0);
setcomp(m,0,0,3);
setcomp(m,0,1,3);
setcomp(m,0,2,3);

@P *= invert(m);

// Scaling and animating it using maketransform sop

​
@rEnd = ceil(fit01(rand(@prim_Id*seed),@getFrame,$FEND-@offset));

@range= fit(@Frame,@getFrame,@rEnd,0,1);
f@c_angle = fit(@Frame,@getFrame,@rEnd,180,0);

vector t=set(0,0,0);
vector r=set(@c_angle,0,0)*@map;//*@range*@map;
vector s=set(1,1,1)*@range*@trig;
vector p= point(0,"P",npoints(0)-1);

vector temp_r = set(0,0,0);
vector temp_s = set(1,1,1);
matrix xform = maketransform(0,0,t,r,s,p);
//4@myTransform *=xform;

v@P *= xform;

// Transforming it back to original location using second input

matrix myTransform = point(1,"myTransform",@ptnum);
@P *= myTransform;

//=====================================

// Postition & Vector Transformation

vector P1 = point(0,"P",0);
vector P2 = point(1,"P",0);
vector upVector = set(0,1,0);
vector xAxis = normalize(P2-P1);
vector zAxis = normalize(cross(xAxis,upVector));
vector yAxis = normalize(cross(zAxis,xAxis));

v@xAxis= xAxis;
v@yAxis= yAxis;
v@zAxis= zAxis;

vector center = P1 + (P2-P1) / 2;

matrix myTransform = set(xAxis,yAxis,zAxis,center);
setcomponent(myTransform,0,0,3);
setcomponent(myTransform,0,1,3);
setcomponent(myTransform,0,2,3);

4@myTransform = myTransform;

//=====================================

matrix myTransform = point(1,"myTransform",0);

@P *= invert(myTransform);
@N *= matrix3 (invert(myTransform));
@v *= matrix3 (invert(myTransform));

//=====================================

// Curve Mask

float s = chf('scale');
float u = vertexcurveparam(0,i@vtxnum);
float a = primintrinsic(0,'measuredperimeter', i@primnum);
v@Cd= set(u,1.0-u,0.0);

float mask = u * (1.0 - u) * s *a * a;
f@curve_mask=mask;
v@P.y -= mask;

//=====================================

// AddPrims to pts
//vector pos = point(1,"P",@ptnum);
float radius = chf('max_radius');
int maxpt = chi('max_pt');
int closept[] = pcfind(1,"target","P",@P,radius,maxpt);

foreach(int pt;closept){

    vector pos =point(1,"P",pt);
    int r_id = point(1,"r_id",pt);
    int add_pt = addpoint(0,pos);
    if(i@r_id==r_id){
            addprim(0,"polyline",i@ptnum,add_pt);
            }
}

//=====================================

// inverting inside velocities to outside
float dot = dot(v@N,v@v);
if(dot<chf('dot_val')){
    v@v *=-1;
    }

//=====================================

// Additive color shading // Point Wrangle 1

vector camP = point(1,"P",0);
@P = normalize(@P - camP) + camP;

// Point Wrangle 2
float maxdist = chf('maxdist');
int maxpt = chi('maxpt');
int nearpts[] = nearpoints(0,@P,maxdist,maxpt);
int closepts = len(nearpts);
f@glow = float (closepts -1) / (maxpt -1) ;
f@glow_r  = chramp("colorize",@glow);
v@P = v@rest; //Original Position

//=====================================

​
// Throwing object to center origin
matrix xform = ident();
//4@xform=ident();
vector center = getbbox_center(0);
center *= -1;
translate(xform,center);
v@P *= xform;

//=====================================

// Velocity based particle rotation for instance objects 

v@cross = cross(v@N,{0,1,0});
matrix3 m  = ident();
float angle= radians(length(v@v))*10;
//@test = angle;
vector axis = v@cross;
rotate(m,angle,axis);
v@cross *=m;
vector4 extrarot = quaternion(angle,v@cross);
@orient = quaternion(maketransform(v@v,v@cross));
@orient = qmultiply(@orient,extrarot);

//=====================================

// ID based random scale
@pscale = fit(rand(i@id*chf('seed')),0,1,0.1,1);

//=====================================

// ID based random delete

float rand = rand(@id*chf('seed'));

if(rand>chf('val')){
    removepoint(0,@ptnum);
    }

//=====================================

// ID based random trigger frame number
i@trig_frame = fit(rand(i@id*chf('seed')),0,1,1008,1018);

//=====================================

// Point based vector direction
vector pos = point(1,"P",0);
v@dir = normalize(pos-@P);
v@dir = lerp(v@N,v@dir,chf('mix'));

//=====================================