static void InputAngle(TransInfo *UNUSED(t), MouseInput *mi, const int mval[2], float output[3])
{
double dx2 = mval[0] - mi->center[0];
double dy2 = mval[1] - mi->center[1];
double B = sqrt(dx2*dx2+dy2*dy2);
double dx1 = mi->imval[0] - mi->center[0];
double dy1 = mi->imval[1] - mi->center[1];
double A = sqrt(dx1*dx1+dy1*dy1);
double dx3 = mval[0] - mi->imval[0];
double dy3 = mval[1] - mi->imval[1];
double *angle = mi->data;
/* use doubles here, to make sure a "1.0" (no rotation) doesnt become 9.999999e-01, which gives 0.02 for acos */
double deler = ((dx1*dx1+dy1*dy1)+(dx2*dx2+dy2*dy2)-(dx3*dx3+dy3*dy3))
/ (2.0 * ((A*B)?(A*B):1.0));
/* ((A*B)?(A*B):1.0) this takes care of potential divide by zero errors */
float dphi;
dphi = saacos((float)deler);
if( (dx1*dy2-dx2*dy1)>0.0 ) dphi= -dphi;
/* If the angle is zero, because of lack of precision close to the 1.0 value in acos
* approximate the angle with the opposite side of the normalized triangle
* This is a good approximation here since the smallest acos value seems to be around
* 0.02 degree and lower values don't even have a 0.01% error compared to the approximation
* */
if (dphi == 0)
{
double dx, dy;
dx2 /= A;
dy2 /= A;
dx1 /= B;
dy1 /= B;
dx = dx1 - dx2;
dy = dy1 - dy2;
dphi = sqrt(dx*dx + dy*dy);
if( (dx1*dy2-dx2*dy1)>0.0 ) dphi= -dphi;
}
if(mi->precision) dphi = dphi/30.0f;
/* if no delta angle, don't update initial position */
if (dphi != 0)
{
mi->imval[0] = mval[0];
mi->imval[1] = mval[1];
}
*angle += (double)dphi;
output[0] = *angle;
}
static PyObject *Quaternion_angle_get(QuaternionObject *self, void *UNUSED(closure))
{
float tquat[4];
float angle;
if (BaseMath_ReadCallback(self) == -1)
return NULL;
normalize_qt_qt(tquat, self->quat);
angle = 2.0f * saacos(tquat[0]);
quat__axis_angle_sanitize(NULL, &angle);
return PyFloat_FromDouble(angle);
}
int BLI_lasso_is_point_inside(int mcords[][2], short moves,
const int sx, const int sy,
const int error_value)
{
/* we do the angle rule, define that all added angles should be about zero or (2 * PI) */
float angletot = 0.0, dot, ang, cross, fp1[2], fp2[2];
int a;
int *p1, *p2;
if (sx == error_value) {
return 0;
}
p1 = mcords[moves - 1];
p2 = mcords[0];
/* first vector */
fp1[0] = (float)(p1[0] - sx);
fp1[1] = (float)(p1[1] - sy);
normalize_v2(fp1);
for (a = 0; a < moves; a++) {
/* second vector */
fp2[0] = (float)(p2[0] - sx);
fp2[1] = (float)(p2[1] - sy);
normalize_v2(fp2);
/* dot and angle and cross */
dot = fp1[0] * fp2[0] + fp1[1] * fp2[1];
ang = fabs(saacos(dot));
cross = (float)((p1[1] - p2[1]) * (p1[0] - sx) + (p2[0] - p1[0]) * (p1[1] - sy));
if (cross < 0.0f) angletot -= ang;
else angletot += ang;
/* circulate */
fp1[0] = fp2[0]; fp1[1] = fp2[1];
p1 = p2;
p2 = mcords[a + 1];
}
if (fabs(angletot) > 4.0) return 1;
return 0;
}
float effector_falloff(EffectorCache *eff, EffectorData *efd, EffectedPoint *UNUSED(point), EffectorWeights *weights)
{
float temp[3];
float falloff = weights ? weights->weight[0] * weights->weight[eff->pd->forcefield] : 1.0f;
float fac, r_fac;
fac = dot_v3v3(efd->nor, efd->vec_to_point2);
if (eff->pd->zdir == PFIELD_Z_POS && fac < 0.0f)
falloff=0.0f;
else if (eff->pd->zdir == PFIELD_Z_NEG && fac > 0.0f)
falloff=0.0f;
else {
switch (eff->pd->falloff) {
case PFIELD_FALL_SPHERE:
falloff*= falloff_func_dist(eff->pd, efd->distance);
break;
case PFIELD_FALL_TUBE:
falloff*= falloff_func_dist(eff->pd, ABS(fac));
if (falloff == 0.0f)
break;
madd_v3_v3v3fl(temp, efd->vec_to_point, efd->nor, -fac);
r_fac= len_v3(temp);
falloff*= falloff_func_rad(eff->pd, r_fac);
break;
case PFIELD_FALL_CONE:
falloff*= falloff_func_dist(eff->pd, ABS(fac));
if (falloff == 0.0f)
break;
r_fac= RAD2DEGF(saacos(fac/len_v3(efd->vec_to_point)));
falloff*= falloff_func_rad(eff->pd, r_fac);
break;
}
}
return falloff;
}
/* Gets the lens and clipping values from a camera of lamp type object */
void ED_view3d_ob_clip_range_get(Object *ob, float *lens, float *clipsta, float *clipend)
{
if(ob->type==OB_LAMP ) {
Lamp *la = ob->data;
if (lens) {
float x1, fac;
fac= cosf((float)M_PI*la->spotsize/360.0f);
x1= saacos(fac);
*lens= 16.0f*fac/sinf(x1);
}
if (clipsta) *clipsta= la->clipsta;
if (clipend) *clipend= la->clipend;
}
else if(ob->type==OB_CAMERA) {
Camera *cam= ob->data;
if (lens) *lens= cam->lens;
if (clipsta) *clipsta= cam->clipsta;
if (clipend) *clipend= cam->clipend;
}
else {
if (lens) *lens= 35.0f;
}
}
static DerivedMesh * applyModifier(ModifierData *md, Object *ob,
DerivedMesh *derivedData,
int UNUSED(useRenderParams),
int UNUSED(isFinalCalc))
{
DerivedMesh *dm = derivedData, *result;
ParticleInstanceModifierData *pimd= (ParticleInstanceModifierData*) md;
ParticleSimulationData sim;
ParticleSystem *psys= NULL;
ParticleData *pa= NULL, *pars= NULL;
MFace *mface, *orig_mface;
MVert *mvert, *orig_mvert;
int i,totvert, totpart=0, totface, maxvert, maxface, first_particle=0;
short track=ob->trackflag%3, trackneg, axis = pimd->axis;
float max_co=0.0, min_co=0.0, temp_co[3], cross[3];
float *size=NULL;
trackneg=((ob->trackflag>2)?1:0);
if(pimd->ob==ob){
pimd->ob= NULL;
return derivedData;
}
if(pimd->ob){
psys = BLI_findlink(&pimd->ob->particlesystem,pimd->psys-1);
if(psys==NULL || psys->totpart==0)
return derivedData;
}
else return derivedData;
if(pimd->flag & eParticleInstanceFlag_Parents)
totpart+=psys->totpart;
if(pimd->flag & eParticleInstanceFlag_Children){
if(totpart==0)
first_particle=psys->totpart;
totpart+=psys->totchild;
}
if(totpart==0)
return derivedData;
sim.scene = md->scene;
sim.ob = pimd->ob;
sim.psys = psys;
sim.psmd = psys_get_modifier(pimd->ob, psys);
if(pimd->flag & eParticleInstanceFlag_UseSize) {
int p;
float *si;
si = size = MEM_callocN(totpart * sizeof(float), "particle size array");
if(pimd->flag & eParticleInstanceFlag_Parents) {
for(p=0, pa= psys->particles; p<psys->totpart; p++, pa++, si++)
*si = pa->size;
}
if(pimd->flag & eParticleInstanceFlag_Children) {
ChildParticle *cpa = psys->child;
for(p=0; p<psys->totchild; p++, cpa++, si++) {
*si = psys_get_child_size(psys, cpa, 0.0f, NULL);
}
}
}
pars=psys->particles;
totvert=dm->getNumVerts(dm);
totface=dm->getNumFaces(dm);
maxvert=totvert*totpart;
maxface=totface*totpart;
psys->lattice=psys_get_lattice(&sim);
if(psys->flag & (PSYS_HAIR_DONE|PSYS_KEYED) || psys->pointcache->flag & PTCACHE_BAKED){
float min_r[3], max_r[3];
INIT_MINMAX(min_r, max_r);
dm->getMinMax(dm, min_r, max_r);
min_co=min_r[track];
max_co=max_r[track];
}
result = CDDM_from_template(dm, maxvert,dm->getNumEdges(dm)*totpart,maxface);
mvert=result->getVertArray(result);
orig_mvert=dm->getVertArray(dm);
for(i=0; i<maxvert; i++){
MVert *inMV;
MVert *mv = mvert + i;
ParticleKey state;
inMV = orig_mvert + i%totvert;
DM_copy_vert_data(dm, result, i%totvert, i, 1);
*mv = *inMV;
/*change orientation based on object trackflag*/
copy_v3_v3(temp_co, mv->co);
mv->co[axis]=temp_co[track];
mv->co[(axis+1)%3]=temp_co[(track+1)%3];
mv->co[(axis+2)%3]=temp_co[(track+2)%3];
if((psys->flag & (PSYS_HAIR_DONE|PSYS_KEYED) || psys->pointcache->flag & PTCACHE_BAKED) && pimd->flag & eParticleInstanceFlag_Path){
float ran = 0.0f;
if(pimd->random_position != 0.0f) {
BLI_srandom(psys->seed + (i/totvert)%totpart);
ran = pimd->random_position * BLI_frand();
}
if(pimd->flag & eParticleInstanceFlag_KeepShape) {
state.time = pimd->position * (1.0f - ran);
}
else {
state.time=(mv->co[axis]-min_co)/(max_co-min_co) * pimd->position * (1.0f - ran);
if(trackneg)
state.time=1.0f-state.time;
mv->co[axis] = 0.0;
}
psys_get_particle_on_path(&sim, first_particle + i/totvert, &state,1);
normalize_v3(state.vel);
/* TODO: incremental rotations somehow */
if(state.vel[axis] < -0.9999f || state.vel[axis] > 0.9999f) {
state.rot[0] = 1;
state.rot[1] = state.rot[2] = state.rot[3] = 0.0f;
}
else {
float temp[3] = {0.0f,0.0f,0.0f};
temp[axis] = 1.0f;
cross_v3_v3v3(cross, temp, state.vel);
/* state.vel[axis] is the only component surviving from a dot product with the axis */
axis_angle_to_quat(state.rot,cross,saacos(state.vel[axis]));
}
}
else{
state.time=-1.0;
psys_get_particle_state(&sim, first_particle + i/totvert, &state,1);
}
mul_qt_v3(state.rot,mv->co);
if(pimd->flag & eParticleInstanceFlag_UseSize)
mul_v3_fl(mv->co, size[i/totvert]);
VECADD(mv->co,mv->co,state.co);
}
mface=result->getFaceArray(result);
orig_mface=dm->getFaceArray(dm);
for(i=0; i<maxface; i++){
MFace *inMF;
MFace *mf = mface + i;
if(pimd->flag & eParticleInstanceFlag_Parents){
if(i/totface>=psys->totpart){
if(psys->part->childtype==PART_CHILD_PARTICLES)
pa=psys->particles+(psys->child+i/totface-psys->totpart)->parent;
else
pa= NULL;
}
else
pa=pars+i/totface;
}
else{
if(psys->part->childtype==PART_CHILD_PARTICLES)
pa=psys->particles+(psys->child+i/totface)->parent;
else
pa= NULL;
}
if(pa){
if(pa->alive==PARS_UNBORN && (pimd->flag&eParticleInstanceFlag_Unborn)==0) continue;
if(pa->alive==PARS_ALIVE && (pimd->flag&eParticleInstanceFlag_Alive)==0) continue;
if(pa->alive==PARS_DEAD && (pimd->flag&eParticleInstanceFlag_Dead)==0) continue;
}
inMF = orig_mface + i%totface;
DM_copy_face_data(dm, result, i%totface, i, 1);
*mf = *inMF;
mf->v1+=(i/totface)*totvert;
mf->v2+=(i/totface)*totvert;
mf->v3+=(i/totface)*totvert;
if(mf->v4)
mf->v4+=(i/totface)*totvert;
}
CDDM_calc_edges(result);
CDDM_calc_normals(result);
if(psys->lattice){
end_latt_deform(psys->lattice);
psys->lattice= NULL;
}
if(size)
MEM_freeN(size);
return result;
}
/* tries to realize the wanted velocity taking all constraints into account */
void boid_body(BoidBrainData *bbd, ParticleData *pa)
{
BoidSettings *boids = bbd->part->boids;
BoidParticle *bpa = pa->boid;
BoidValues val;
EffectedPoint epoint;
float acc[3] = {0.0f, 0.0f, 0.0f}, tan_acc[3], nor_acc[3];
float dvec[3], bvec[3];
float new_dir[3], new_speed;
float old_dir[3], old_speed;
float wanted_dir[3];
float q[4], mat[3][3]; /* rotation */
float ground_co[3] = {0.0f, 0.0f, 0.0f}, ground_nor[3] = {0.0f, 0.0f, 1.0f};
float force[3] = {0.0f, 0.0f, 0.0f};
float pa_mass=bbd->part->mass, dtime=bbd->dfra*bbd->timestep;
set_boid_values(&val, boids, pa);
/* make sure there's something in new velocity, location & rotation */
copy_particle_key(&pa->state, &pa->prev_state, 0);
if (bbd->part->flag & PART_SIZEMASS)
pa_mass*=pa->size;
/* if boids can't fly they fall to the ground */
if ((boids->options & BOID_ALLOW_FLIGHT)==0 && ELEM(bpa->data.mode, eBoidMode_OnLand, eBoidMode_Climbing)==0 && psys_uses_gravity(bbd->sim))
bpa->data.mode = eBoidMode_Falling;
if (bpa->data.mode == eBoidMode_Falling) {
/* Falling boids are only effected by gravity. */
acc[2] = bbd->sim->scene->physics_settings.gravity[2];
}
else {
/* figure out acceleration */
float landing_level = 2.0f;
float level = landing_level + 1.0f;
float new_vel[3];
if (bpa->data.mode == eBoidMode_Liftoff) {
bpa->data.mode = eBoidMode_InAir;
bpa->ground = boid_find_ground(bbd, pa, ground_co, ground_nor);
}
else if (bpa->data.mode == eBoidMode_InAir && boids->options & BOID_ALLOW_LAND) {
/* auto-leveling & landing if close to ground */
bpa->ground = boid_find_ground(bbd, pa, ground_co, ground_nor);
/* level = how many particle sizes above ground */
level = (pa->prev_state.co[2] - ground_co[2])/(2.0f * pa->size) - 0.5f;
landing_level = - boids->landing_smoothness * pa->prev_state.vel[2] * pa_mass;
if (pa->prev_state.vel[2] < 0.0f) {
if (level < 1.0f) {
bbd->wanted_co[0] = bbd->wanted_co[1] = bbd->wanted_co[2] = 0.0f;
bbd->wanted_speed = 0.0f;
bpa->data.mode = eBoidMode_Falling;
}
else if (level < landing_level) {
bbd->wanted_speed *= (level - 1.0f)/landing_level;
bbd->wanted_co[2] *= (level - 1.0f)/landing_level;
}
}
}
copy_v3_v3(old_dir, pa->prev_state.ave);
new_speed = normalize_v3_v3(wanted_dir, bbd->wanted_co);
/* first check if we have valid direction we want to go towards */
if (new_speed == 0.0f) {
copy_v3_v3(new_dir, old_dir);
}
else {
float old_dir2[2], wanted_dir2[2], nor[3], angle;
copy_v2_v2(old_dir2, old_dir);
normalize_v2(old_dir2);
copy_v2_v2(wanted_dir2, wanted_dir);
normalize_v2(wanted_dir2);
/* choose random direction to turn if wanted velocity */
/* is directly behind regardless of z-coordinate */
if (dot_v2v2(old_dir2, wanted_dir2) < -0.99f) {
wanted_dir[0] = 2.0f*(0.5f - BLI_rng_get_float(bbd->rng));
wanted_dir[1] = 2.0f*(0.5f - BLI_rng_get_float(bbd->rng));
wanted_dir[2] = 2.0f*(0.5f - BLI_rng_get_float(bbd->rng));
normalize_v3(wanted_dir);
}
/* constrain direction with maximum angular velocity */
angle = saacos(dot_v3v3(old_dir, wanted_dir));
angle = min_ff(angle, val.max_ave);
cross_v3_v3v3(nor, old_dir, wanted_dir);
axis_angle_to_quat(q, nor, angle);
copy_v3_v3(new_dir, old_dir);
mul_qt_v3(q, new_dir);
normalize_v3(new_dir);
/* save direction in case resulting velocity too small */
axis_angle_to_quat(q, nor, angle*dtime);
copy_v3_v3(pa->state.ave, old_dir);
mul_qt_v3(q, pa->state.ave);
normalize_v3(pa->state.ave);
}
/* constrain speed with maximum acceleration */
old_speed = len_v3(pa->prev_state.vel);
if (bbd->wanted_speed < old_speed)
new_speed = MAX2(bbd->wanted_speed, old_speed - val.max_acc);
else
new_speed = MIN2(bbd->wanted_speed, old_speed + val.max_acc);
/* combine direction and speed */
copy_v3_v3(new_vel, new_dir);
mul_v3_fl(new_vel, new_speed);
/* maintain minimum flying velocity if not landing */
if (level >= landing_level) {
float len2 = dot_v2v2(new_vel, new_vel);
float root;
len2 = MAX2(len2, val.min_speed*val.min_speed);
root = sasqrt(new_speed*new_speed - len2);
new_vel[2] = new_vel[2] < 0.0f ? -root : root;
normalize_v2(new_vel);
mul_v2_fl(new_vel, sasqrt(len2));
}
/* finally constrain speed to max speed */
new_speed = normalize_v3(new_vel);
mul_v3_fl(new_vel, MIN2(new_speed, val.max_speed));
/* get acceleration from difference of velocities */
sub_v3_v3v3(acc, new_vel, pa->prev_state.vel);
/* break acceleration to components */
project_v3_v3v3(tan_acc, acc, pa->prev_state.ave);
sub_v3_v3v3(nor_acc, acc, tan_acc);
}
/* account for effectors */
pd_point_from_particle(bbd->sim, pa, &pa->state, &epoint);
pdDoEffectors(bbd->sim->psys->effectors, bbd->sim->colliders, bbd->part->effector_weights, &epoint, force, NULL);
if (ELEM(bpa->data.mode, eBoidMode_OnLand, eBoidMode_Climbing)) {
float length = normalize_v3(force);
length = MAX2(0.0f, length - boids->land_stick_force);
mul_v3_fl(force, length);
}
add_v3_v3(acc, force);
/* store smoothed acceleration for nice banking etc. */
madd_v3_v3fl(bpa->data.acc, acc, dtime);
mul_v3_fl(bpa->data.acc, 1.0f / (1.0f + dtime));
/* integrate new location & velocity */
/* by regarding the acceleration as a force at this stage we*/
/* can get better control allthough it's a bit unphysical */
mul_v3_fl(acc, 1.0f/pa_mass);
copy_v3_v3(dvec, acc);
mul_v3_fl(dvec, dtime*dtime*0.5f);
copy_v3_v3(bvec, pa->prev_state.vel);
mul_v3_fl(bvec, dtime);
add_v3_v3(dvec, bvec);
add_v3_v3(pa->state.co, dvec);
madd_v3_v3fl(pa->state.vel, acc, dtime);
//if (bpa->data.mode != eBoidMode_InAir)
bpa->ground = boid_find_ground(bbd, pa, ground_co, ground_nor);
/* change modes, constrain movement & keep track of down vector */
switch (bpa->data.mode) {
case eBoidMode_InAir:
{
float grav[3];
grav[0] = 0.0f;
grav[1] = 0.0f;
grav[2] = bbd->sim->scene->physics_settings.gravity[2] < 0.0f ? -1.0f : 0.0f;
/* don't take forward acceleration into account (better banking) */
if (dot_v3v3(bpa->data.acc, pa->state.vel) > 0.0f) {
project_v3_v3v3(dvec, bpa->data.acc, pa->state.vel);
sub_v3_v3v3(dvec, bpa->data.acc, dvec);
}
else {
copy_v3_v3(dvec, bpa->data.acc);
}
/* gather apparent gravity */
madd_v3_v3v3fl(bpa->gravity, grav, dvec, -boids->banking);
normalize_v3(bpa->gravity);
/* stick boid on goal when close enough */
if (bbd->goal_ob && boid_goal_signed_dist(pa->state.co, bbd->goal_co, bbd->goal_nor) <= pa->size * boids->height) {
bpa->data.mode = eBoidMode_Climbing;
bpa->ground = bbd->goal_ob;
boid_find_ground(bbd, pa, ground_co, ground_nor);
boid_climb(boids, pa, ground_co, ground_nor);
}
else if (pa->state.co[2] <= ground_co[2] + pa->size * boids->height) {
/* land boid when below ground */
if (boids->options & BOID_ALLOW_LAND) {
pa->state.co[2] = ground_co[2] + pa->size * boids->height;
pa->state.vel[2] = 0.0f;
bpa->data.mode = eBoidMode_OnLand;
}
/* fly above ground */
else if (bpa->ground) {
pa->state.co[2] = ground_co[2] + pa->size * boids->height;
pa->state.vel[2] = 0.0f;
}
}
break;
}
case eBoidMode_Falling:
{
float grav[3];
grav[0] = 0.0f;
grav[1] = 0.0f;
grav[2] = bbd->sim->scene->physics_settings.gravity[2] < 0.0f ? -1.0f : 0.0f;
/* gather apparent gravity */
madd_v3_v3fl(bpa->gravity, grav, dtime);
normalize_v3(bpa->gravity);
if (boids->options & BOID_ALLOW_LAND) {
/* stick boid on goal when close enough */
if (bbd->goal_ob && boid_goal_signed_dist(pa->state.co, bbd->goal_co, bbd->goal_nor) <= pa->size * boids->height) {
bpa->data.mode = eBoidMode_Climbing;
bpa->ground = bbd->goal_ob;
boid_find_ground(bbd, pa, ground_co, ground_nor);
boid_climb(boids, pa, ground_co, ground_nor);
}
/* land boid when really near ground */
else if (pa->state.co[2] <= ground_co[2] + 1.01f * pa->size * boids->height) {
pa->state.co[2] = ground_co[2] + pa->size * boids->height;
pa->state.vel[2] = 0.0f;
bpa->data.mode = eBoidMode_OnLand;
}
/* if we're falling, can fly and want to go upwards lets fly */
else if (boids->options & BOID_ALLOW_FLIGHT && bbd->wanted_co[2] > 0.0f)
bpa->data.mode = eBoidMode_InAir;
}
else
bpa->data.mode = eBoidMode_InAir;
break;
}
case eBoidMode_Climbing:
{
boid_climb(boids, pa, ground_co, ground_nor);
//float nor[3];
//copy_v3_v3(nor, ground_nor);
///* gather apparent gravity to r_ve */
//madd_v3_v3fl(pa->r_ve, ground_nor, -1.0);
//normalize_v3(pa->r_ve);
///* raise boid it's size from surface */
//mul_v3_fl(nor, pa->size * boids->height);
//add_v3_v3v3(pa->state.co, ground_co, nor);
///* remove normal component from velocity */
//project_v3_v3v3(v, pa->state.vel, ground_nor);
//sub_v3_v3v3(pa->state.vel, pa->state.vel, v);
break;
}
case eBoidMode_OnLand:
{
/* stick boid on goal when close enough */
if (bbd->goal_ob && boid_goal_signed_dist(pa->state.co, bbd->goal_co, bbd->goal_nor) <= pa->size * boids->height) {
bpa->data.mode = eBoidMode_Climbing;
bpa->ground = bbd->goal_ob;
boid_find_ground(bbd, pa, ground_co, ground_nor);
boid_climb(boids, pa, ground_co, ground_nor);
}
/* ground is too far away so boid falls */
else if (pa->state.co[2]-ground_co[2] > 1.1f * pa->size * boids->height)
bpa->data.mode = eBoidMode_Falling;
else {
/* constrain to surface */
pa->state.co[2] = ground_co[2] + pa->size * boids->height;
pa->state.vel[2] = 0.0f;
}
if (boids->banking > 0.0f) {
float grav[3];
/* Don't take gravity's strength in to account, */
/* otherwise amount of banking is hard to control. */
negate_v3_v3(grav, ground_nor);
project_v3_v3v3(dvec, bpa->data.acc, pa->state.vel);
sub_v3_v3v3(dvec, bpa->data.acc, dvec);
/* gather apparent gravity */
madd_v3_v3v3fl(bpa->gravity, grav, dvec, -boids->banking);
normalize_v3(bpa->gravity);
}
else {
/* gather negative surface normal */
madd_v3_v3fl(bpa->gravity, ground_nor, -1.0f);
normalize_v3(bpa->gravity);
}
break;
}
}
/* save direction to state.ave unless the boid is falling */
/* (boids can't effect their direction when falling) */
if (bpa->data.mode!=eBoidMode_Falling && len_v3(pa->state.vel) > 0.1f*pa->size) {
copy_v3_v3(pa->state.ave, pa->state.vel);
pa->state.ave[2] *= bbd->part->boids->pitch;
normalize_v3(pa->state.ave);
}
/* apply damping */
if (ELEM(bpa->data.mode, eBoidMode_OnLand, eBoidMode_Climbing))
mul_v3_fl(pa->state.vel, 1.0f - 0.2f*bbd->part->dampfac);
/* calculate rotation matrix based on forward & down vectors */
if (bpa->data.mode == eBoidMode_InAir) {
copy_v3_v3(mat[0], pa->state.ave);
project_v3_v3v3(dvec, bpa->gravity, pa->state.ave);
sub_v3_v3v3(mat[2], bpa->gravity, dvec);
normalize_v3(mat[2]);
}
else {
project_v3_v3v3(dvec, pa->state.ave, bpa->gravity);
sub_v3_v3v3(mat[0], pa->state.ave, dvec);
normalize_v3(mat[0]);
copy_v3_v3(mat[2], bpa->gravity);
}
negate_v3(mat[2]);
cross_v3_v3v3(mat[1], mat[2], mat[0]);
/* apply rotation */
mat3_to_quat_is_ok(q, mat);
copy_qt_qt(pa->state.rot, q);
}
static DerivedMesh *applyModifier(ModifierData *md, Object *ob,
DerivedMesh *derivedData,
ModifierApplyFlag UNUSED(flag))
{
DerivedMesh *dm = derivedData, *result;
ParticleInstanceModifierData *pimd = (ParticleInstanceModifierData *) md;
ParticleSimulationData sim;
ParticleSystem *psys = NULL;
ParticleData *pa = NULL;
MPoly *mpoly, *orig_mpoly;
MLoop *mloop, *orig_mloop;
MVert *mvert, *orig_mvert;
int totvert, totpoly, totloop /* , totedge */;
int maxvert, maxpoly, maxloop, totpart = 0, first_particle = 0;
int k, p, p_skip;
short track = ob->trackflag % 3, trackneg, axis = pimd->axis;
float max_co = 0.0, min_co = 0.0, temp_co[3];
float *size = NULL;
trackneg = ((ob->trackflag > 2) ? 1 : 0);
if (pimd->ob == ob) {
pimd->ob = NULL;
return derivedData;
}
if (pimd->ob) {
psys = BLI_findlink(&pimd->ob->particlesystem, pimd->psys - 1);
if (psys == NULL || psys->totpart == 0)
return derivedData;
}
else {
return derivedData;
}
if (pimd->flag & eParticleInstanceFlag_Parents)
totpart += psys->totpart;
if (pimd->flag & eParticleInstanceFlag_Children) {
if (totpart == 0)
first_particle = psys->totpart;
totpart += psys->totchild;
}
if (totpart == 0)
return derivedData;
sim.scene = md->scene;
sim.ob = pimd->ob;
sim.psys = psys;
sim.psmd = psys_get_modifier(pimd->ob, psys);
if (pimd->flag & eParticleInstanceFlag_UseSize) {
float *si;
si = size = MEM_callocN(totpart * sizeof(float), "particle size array");
if (pimd->flag & eParticleInstanceFlag_Parents) {
for (p = 0, pa = psys->particles; p < psys->totpart; p++, pa++, si++)
*si = pa->size;
}
if (pimd->flag & eParticleInstanceFlag_Children) {
ChildParticle *cpa = psys->child;
for (p = 0; p < psys->totchild; p++, cpa++, si++) {
*si = psys_get_child_size(psys, cpa, 0.0f, NULL);
}
}
}
totvert = dm->getNumVerts(dm);
totpoly = dm->getNumPolys(dm);
totloop = dm->getNumLoops(dm);
/* totedge = dm->getNumEdges(dm); */ /* UNUSED */
/* count particles */
maxvert = 0;
maxpoly = 0;
maxloop = 0;
for (p = 0; p < totpart; p++) {
if (particle_skip(pimd, psys, p))
continue;
maxvert += totvert;
maxpoly += totpoly;
maxloop += totloop;
}
psys->lattice_deform_data = psys_create_lattice_deform_data(&sim);
if (psys->flag & (PSYS_HAIR_DONE | PSYS_KEYED) || psys->pointcache->flag & PTCACHE_BAKED) {
float min[3], max[3];
INIT_MINMAX(min, max);
dm->getMinMax(dm, min, max);
min_co = min[track];
max_co = max[track];
}
result = CDDM_from_template(dm, maxvert, 0, 0, maxloop, maxpoly);
mvert = result->getVertArray(result);
orig_mvert = dm->getVertArray(dm);
mpoly = result->getPolyArray(result);
orig_mpoly = dm->getPolyArray(dm);
mloop = result->getLoopArray(result);
orig_mloop = dm->getLoopArray(dm);
for (p = 0, p_skip = 0; p < totpart; p++) {
float prev_dir[3];
float frame[4]; /* frame orientation quaternion */
/* skip particle? */
if (particle_skip(pimd, psys, p))
continue;
/* set vertices coordinates */
for (k = 0; k < totvert; k++) {
ParticleKey state;
MVert *inMV;
MVert *mv = mvert + p_skip * totvert + k;
inMV = orig_mvert + k;
DM_copy_vert_data(dm, result, k, p_skip * totvert + k, 1);
*mv = *inMV;
/*change orientation based on object trackflag*/
copy_v3_v3(temp_co, mv->co);
mv->co[axis] = temp_co[track];
mv->co[(axis + 1) % 3] = temp_co[(track + 1) % 3];
mv->co[(axis + 2) % 3] = temp_co[(track + 2) % 3];
/* get particle state */
if ((psys->flag & (PSYS_HAIR_DONE | PSYS_KEYED) || psys->pointcache->flag & PTCACHE_BAKED) &&
(pimd->flag & eParticleInstanceFlag_Path))
{
float ran = 0.0f;
if (pimd->random_position != 0.0f) {
ran = pimd->random_position * BLI_hash_frand(psys->seed + p);
}
if (pimd->flag & eParticleInstanceFlag_KeepShape) {
state.time = pimd->position * (1.0f - ran);
}
else {
state.time = (mv->co[axis] - min_co) / (max_co - min_co) * pimd->position * (1.0f - ran);
if (trackneg)
state.time = 1.0f - state.time;
mv->co[axis] = 0.0;
}
psys_get_particle_on_path(&sim, first_particle + p, &state, 1);
normalize_v3(state.vel);
/* Incrementally Rotating Frame (Bishop Frame) */
if (k == 0) {
float hairmat[4][4];
float mat[3][3];
if (first_particle + p < psys->totpart)
pa = psys->particles + first_particle + p;
else {
ChildParticle *cpa = psys->child + (p - psys->totpart);
pa = psys->particles + cpa->parent;
}
psys_mat_hair_to_global(sim.ob, sim.psmd->dm, sim.psys->part->from, pa, hairmat);
copy_m3_m4(mat, hairmat);
/* to quaternion */
mat3_to_quat(frame, mat);
/* note: direction is same as normal vector currently,
* but best to keep this separate so the frame can be
* rotated later if necessary
*/
copy_v3_v3(prev_dir, state.vel);
}
else {
float rot[4];
/* incrementally rotate along bend direction */
rotation_between_vecs_to_quat(rot, prev_dir, state.vel);
mul_qt_qtqt(frame, rot, frame);
copy_v3_v3(prev_dir, state.vel);
}
copy_qt_qt(state.rot, frame);
#if 0
/* Absolute Frame (Frenet Frame) */
if (state.vel[axis] < -0.9999f || state.vel[axis] > 0.9999f) {
unit_qt(state.rot);
}
else {
float cross[3];
float temp[3] = {0.0f, 0.0f, 0.0f};
temp[axis] = 1.0f;
cross_v3_v3v3(cross, temp, state.vel);
/* state.vel[axis] is the only component surviving from a dot product with the axis */
axis_angle_to_quat(state.rot, cross, saacos(state.vel[axis]));
}
#endif
}
else {
state.time = -1.0;
psys_get_particle_state(&sim, first_particle + p, &state, 1);
}
mul_qt_v3(state.rot, mv->co);
if (pimd->flag & eParticleInstanceFlag_UseSize)
mul_v3_fl(mv->co, size[p]);
add_v3_v3(mv->co, state.co);
}
/* create polys and loops */
for (k = 0; k < totpoly; k++) {
MPoly *inMP = orig_mpoly + k;
MPoly *mp = mpoly + p_skip * totpoly + k;
DM_copy_poly_data(dm, result, k, p_skip * totpoly + k, 1);
*mp = *inMP;
mp->loopstart += p_skip * totloop;
{
MLoop *inML = orig_mloop + inMP->loopstart;
MLoop *ml = mloop + mp->loopstart;
int j = mp->totloop;
DM_copy_loop_data(dm, result, inMP->loopstart, mp->loopstart, j);
for (; j; j--, ml++, inML++) {
ml->v = inML->v + (p_skip * totvert);
}
}
}
p_skip++;
}
CDDM_calc_edges(result);
if (psys->lattice_deform_data) {
end_latt_deform(psys->lattice_deform_data);
psys->lattice_deform_data = NULL;
}
if (size)
MEM_freeN(size);
result->dirty |= DM_DIRTY_NORMALS;
return result;
}
static int dupli_extrude_cursor(bContext *C, wmOperator *op, wmEvent *event)
{
ViewContext vc;
EditVert *eve;
float min[3], max[3];
int done= 0;
short use_proj;
em_setup_viewcontext(C, &vc);
use_proj= (vc.scene->toolsettings->snap_flag & SCE_SNAP) && (vc.scene->toolsettings->snap_mode==SCE_SNAP_MODE_FACE);
invert_m4_m4(vc.obedit->imat, vc.obedit->obmat);
INIT_MINMAX(min, max);
for(eve= vc.em->verts.first; eve; eve= eve->next) {
if(eve->f & SELECT) {
DO_MINMAX(eve->co, min, max);
done= 1;
}
}
/* call extrude? */
if(done) {
const short rot_src= RNA_boolean_get(op->ptr, "rotate_source");
EditEdge *eed;
float vec[3], cent[3], mat[3][3];
float nor[3]= {0.0, 0.0, 0.0};
/* 2D normal calc */
float mval_f[2];
mval_f[0]= (float)event->mval[0];
mval_f[1]= (float)event->mval[1];
done= 0;
/* calculate the normal for selected edges */
for(eed= vc.em->edges.first; eed; eed= eed->next) {
if(eed->f & SELECT) {
float co1[3], co2[3];
mul_v3_m4v3(co1, vc.obedit->obmat, eed->v1->co);
mul_v3_m4v3(co2, vc.obedit->obmat, eed->v2->co);
project_float_noclip(vc.ar, co1, co1);
project_float_noclip(vc.ar, co2, co2);
/* 2D rotate by 90d while adding.
* (x, y) = (y, -x)
*
* accumulate the screenspace normal in 2D,
* with screenspace edge length weighting the result. */
if(line_point_side_v2(co1, co2, mval_f) >= 0.0f) {
nor[0] += (co1[1] - co2[1]);
nor[1] += -(co1[0] - co2[0]);
}
else {
nor[0] += (co2[1] - co1[1]);
nor[1] += -(co2[0] - co1[0]);
}
done= 1;
}
}
if(done) {
float view_vec[3], cross[3];
/* convert the 2D nomal into 3D */
mul_mat3_m4_v3(vc.rv3d->viewinv, nor); /* worldspace */
mul_mat3_m4_v3(vc.obedit->imat, nor); /* local space */
/* correct the normal to be aligned on the view plane */
copy_v3_v3(view_vec, vc.rv3d->viewinv[2]);
mul_mat3_m4_v3(vc.obedit->imat, view_vec);
cross_v3_v3v3(cross, nor, view_vec);
cross_v3_v3v3(nor, view_vec, cross);
normalize_v3(nor);
}
/* center */
mid_v3_v3v3(cent, min, max);
copy_v3_v3(min, cent);
mul_m4_v3(vc.obedit->obmat, min); // view space
view3d_get_view_aligned_coordinate(&vc, min, event->mval, TRUE);
mul_m4_v3(vc.obedit->imat, min); // back in object space
sub_v3_v3(min, cent);
/* calculate rotation */
unit_m3(mat);
if(done) {
float dot;
copy_v3_v3(vec, min);
normalize_v3(vec);
dot= dot_v3v3(vec, nor);
if( fabs(dot)<0.999) {
float cross[3], si, q1[4];
cross_v3_v3v3(cross, nor, vec);
normalize_v3(cross);
dot= 0.5f*saacos(dot);
/* halve the rotation if its applied twice */
if(rot_src) dot *= 0.5f;
si= (float)sin(dot);
q1[0]= (float)cos(dot);
q1[1]= cross[0]*si;
q1[2]= cross[1]*si;
q1[3]= cross[2]*si;
quat_to_mat3( mat,q1);
}
}
if(rot_src) {
rotateflag(vc.em, SELECT, cent, mat);
/* also project the source, for retopo workflow */
if(use_proj)
EM_project_snap_verts(C, vc.ar, vc.obedit, vc.em);
}
extrudeflag(vc.obedit, vc.em, SELECT, nor, 0);
rotateflag(vc.em, SELECT, cent, mat);
translateflag(vc.em, SELECT, min);
recalc_editnormals(vc.em);
}
else if(vc.em->selectmode & SCE_SELECT_VERTEX) {
float imat[4][4];
const float *curs= give_cursor(vc.scene, vc.v3d);
copy_v3_v3(min, curs);
view3d_get_view_aligned_coordinate(&vc, min, event->mval, TRUE);
eve= addvertlist(vc.em, 0, NULL);
invert_m4_m4(imat, vc.obedit->obmat);
mul_v3_m4v3(eve->co, imat, min);
eve->f= SELECT;
}
if(use_proj)
EM_project_snap_verts(C, vc.ar, vc.obedit, vc.em);
WM_event_add_notifier(C, NC_GEOM|ND_DATA, vc.obedit->data);
DAG_id_tag_update(vc.obedit->data, 0);
return OPERATOR_FINISHED;
}
/* also exposed in previewrender.c */
int ED_view3d_viewplane_get(View3D *v3d, RegionView3D *rv3d, int winxi, int winyi, rctf *viewplane, float *clipsta, float *clipend, float *pixsize)
{
Camera *cam=NULL;
float lens, fac, x1, y1, x2, y2;
float winx= (float)winxi, winy= (float)winyi;
int orth= 0;
lens= v3d->lens;
*clipsta= v3d->near;
*clipend= v3d->far;
if(rv3d->persp==RV3D_CAMOB) {
if(v3d->camera) {
if(v3d->camera->type==OB_LAMP ) {
Lamp *la;
la= v3d->camera->data;
fac= cosf(((float)M_PI)*la->spotsize/360.0f);
x1= saacos(fac);
lens= 16.0f*fac/sinf(x1);
*clipsta= la->clipsta;
*clipend= la->clipend;
}
else if(v3d->camera->type==OB_CAMERA) {
cam= v3d->camera->data;
lens= cam->lens;
*clipsta= cam->clipsta;
*clipend= cam->clipend;
}
}
}
if(rv3d->persp==RV3D_ORTHO) {
if(winx>winy) x1= -rv3d->dist;
else x1= -winx*rv3d->dist/winy;
x2= -x1;
if(winx>winy) y1= -winy*rv3d->dist/winx;
else y1= -rv3d->dist;
y2= -y1;
*clipend *= 0.5f; // otherwise too extreme low zbuffer quality
*clipsta= - *clipend;
orth= 1;
}
else {
/* fac for zoom, also used for camdx */
if(rv3d->persp==RV3D_CAMOB) {
fac= BKE_screen_view3d_zoom_to_fac((float)rv3d->camzoom) * 4.0f;
}
else {
fac= 2.0;
}
/* viewplane size depends... */
if(cam && cam->type==CAM_ORTHO) {
/* ortho_scale == 1 means exact 1 to 1 mapping */
float dfac= 2.0f*cam->ortho_scale/fac;
if(winx>winy) x1= -dfac;
else x1= -winx*dfac/winy;
x2= -x1;
if(winx>winy) y1= -winy*dfac/winx;
else y1= -dfac;
y2= -y1;
orth= 1;
}
else {
float dfac;
if(winx>winy) dfac= 64.0f/(fac*winx*lens);
else dfac= 64.0f/(fac*winy*lens);
x1= - *clipsta * winx*dfac;
x2= -x1;
y1= - *clipsta * winy*dfac;
y2= -y1;
orth= 0;
}
/* cam view offset */
if(cam) {
float dx= 0.5f*fac*rv3d->camdx*(x2-x1);
float dy= 0.5f*fac*rv3d->camdy*(y2-y1);
/* shift offset */
if(cam->type==CAM_ORTHO) {
dx += cam->shiftx * cam->ortho_scale;
dy += cam->shifty * cam->ortho_scale;
}
else {
dx += cam->shiftx * (cam->clipsta / cam->lens) * 32.0f;
dy += cam->shifty * (cam->clipsta / cam->lens) * 32.0f;
}
x1+= dx;
x2+= dx;
y1+= dy;
y2+= dy;
}
}
if(pixsize) {
float viewfac;
if(orth) {
viewfac= (winx >= winy)? winx: winy;
*pixsize= 1.0f/viewfac;
}
else {
viewfac= (((winx >= winy)? winx: winy)*lens)/32.0f;
*pixsize= *clipsta/viewfac;
}
}
viewplane->xmin= x1;
viewplane->ymin= y1;
viewplane->xmax= x2;
viewplane->ymax= y2;
return orth;
}