static void applyForces(struct particle_system *ps, struct particle *p)
{
int i = 0;
vec3 force;
vec3 dir;
float m, d, s;
vec3Copy(p->dir, p->acc);
do {
switch(ps->forces[i].type) {
case PARTICLE_FORCE_DIRECTIONAL:
vec3Copy(ps->forces[i].dir, force);
break;
case PARTICLE_FORCE_FLUID:
s = vec3Mag(p->acc);
vec3Copy(p->acc, force);
vec3Normalize(force, force);
vec3Mul(force, -ps->forces[i].value*s*s, force);
break;
case PARTICLE_FORCE_ATTRACTION:
vec3Sub(ps->forces[i].loc, p->loc, dir);
d = vec3Mag(dir);
vec3Normalize(dir, dir);
m = 0.00001*ps->forces[i].value*p->mass / (d*d);
vec3Mul(dir, m, force);
break;
}
vec3Add(p->acc, force, p->acc);
} while(++i < ps->nbforces);
vec3Div(p->acc, p->mass, p->acc);
vec3Add(p->vel, p->acc, p->vel);
vec3Add(p->loc, p->vel, p->loc);
}
void spherify(Solid* s) {
unsigned n = s->nVerts;
Vec3 centroid = { 0,0,0 };
unsigned i;
for(i=0;i<n;++i) {
vec3Add(centroid,centroid,s->verts[i].loc);
}
vec3Mult(centroid,centroid,1.0/n);
Vec3* diffs = malloc(n*sizeof(Vec3));
float* dists = malloc(n*sizeof(float));
float maxR = 0;
for(i=0;i<n;++i) {
vec3Sub(diffs[i],s->verts[i].loc,centroid);
float r = vec3Mag(diffs[i]);
dists[i] = r;
if(r > maxR) {
maxR = r;
}
}
for(i=0;i<n;++i) {
vec3Mult(diffs[i],diffs[i],1.0/dists[i]);
vec3Copy(s->verts[i].normal,diffs[i]);
vec3Mult(diffs[i],diffs[i],maxR);
vec3Add(s->verts[i].loc,centroid,diffs[i]);
}
free(dists);
free(diffs);
}
void shadeVertex(const Uniforms* uniforms,
Vertex* vertex,
Varyings* varyings) {
mat44MultVec3(varyings->loc,uniforms->modelViewProjection,
*vertex->loc);
vec3Copy(varyings->color,*vertex->color);
}
void copyVaryings(Varyings* out,const Varyings* src) {
vec4Copy(out->loc,src->loc);
vec3Copy(out->color,src->color);
unsigned i;
for(i=0;i<out->numAttributes;++i) {
unsigned n = out->attributes[i].numValues;
vecNCopy(n,out->attributePtrs[i],src->attributePtrs[i]);
}
}
void makeGrid(CustomVert** vertsOut,unsigned** indicesOut,unsigned* numEdgesOut,
float x0,float z0,float x1,float z1,
unsigned gridWidth, unsigned gridHeight) {
float xStep = (x1-x0)/gridWidth,
zStep = (z1-z0)/gridHeight;
gridWidth += 1;
gridHeight += 1;
unsigned vertexCount = 2*gridWidth+2*gridHeight;
CustomVert* verts = malloc(sizeof(CustomVert)*vertexCount);
Color3 white = { 1,1,1 };
unsigned vertIndex = 0;
float xLoc = x0,
zLoc = z0;
for(vertIndex=0;vertIndex<vertexCount;++vertIndex) {
CustomVert* vert = verts+vertIndex;
vert->loc[0] = xLoc;
vert->loc[1] = 0;
vert->loc[2] = zLoc;
vec3Copy(vert->color,white);
if(vertIndex < gridWidth) {
xLoc += xStep;
} else if(vertIndex >= gridWidth &&
vertIndex < gridWidth+gridHeight) {
zLoc += zStep;
} else if(vertIndex >= gridWidth+gridHeight &&
vertIndex < gridWidth*2+gridHeight) {
xLoc -= xStep;
} else {
zLoc -= zStep;
}
}
unsigned x,z;
unsigned numEdges = (gridWidth+1)+(gridHeight+1);
unsigned* indices = malloc(sizeof(unsigned)*numEdges*2);
unsigned index = 0;
for(x=0;x<=gridWidth;++x) {
indices[index++] = x;
indices[index++] = gridWidth*2+gridHeight-x;
}
for(z=0;z<=gridHeight;++z) {
indices[index++] = gridWidth+z;
if(z == 0) {
indices[index++] = 0;
} else {
indices[index++] = gridWidth*2+gridHeight*2-z;
}
}
*vertsOut = verts;
*indicesOut = indices;
*numEdgesOut = numEdges;
}
static void add(struct particle_emitter *emit, struct pool *pool)
{
struct particle p;
vec3Copy(emit->loc, p.loc);
vec3Copy(emit->dir, p.dir);
p.tex[0] = 0.0;
p.tex[1] = 0.0;
vec4Copy(emit->clr, p.clr);
// vec4Set(p.clr, 1.0, 2.0, 3.0, 4.0);
vec3Set(p.acc, 0.0, 0.0, 0.0);
vec3Set(p.vel, 0.0, 0.0, 0.0);
p.life = emit->life;
p.mass = emit->mass;
poolAdd(pool, &p);
/*
fprintf(stderr, "EMIT %d\n", pool->id);
particlesDump(pool); */
}
