archive/blender-archive
Archived
1
1
Fork 0
Code Pull Requests Packages Activity

more macro --> BLI math lib, mainly replace VECCOPY in render and blenkernel.

Browse Source
This commit is contained in:
Campbell Barton
2011-11-06 16:38:21 +00:00
parent 7c88bc5952
commit 85540d5aa7
22 changed files with 298 additions and 304 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
source/blender/blenkernel/intern/bvhutils.c
View File

@@ -384,8 +384,8 @@ static float nearest_point_in_tri_surface(const float v0[3], const float v1[3],
mul_v3_fl(x, S); mul_v3_fl(x, S);
copy_v3_v3(y, e1); copy_v3_v3(y, e1);
mul_v3_fl(y, T); mul_v3_fl(y, T);
VECADD(z, w, x); add_v3_v3v3(z, w, x);
VECADD(z, z, y); add_v3_v3v3(z, z, y);
//sub_v3_v3v3(d, p, z); //sub_v3_v3v3(d, p, z);
copy_v3_v3(nearest, z); copy_v3_v3(nearest, z);
// d = p - ( v0 + S * e0 + T * e1 ); // d = p - ( v0 + S * e0 + T * e1 );

62
source/blender/blenkernel/intern/cloth.c
View File

@@ -231,12 +231,12 @@ static BVHTree *bvhtree_build_from_cloth (ClothModifierData *clmd, float epsilon
// fill tree // fill tree
for(i = 0; i < cloth->numfaces; i++, mfaces++) for(i = 0; i < cloth->numfaces; i++, mfaces++)
{ {
VECCOPY(&co[0*3], verts[mfaces->v1].xold); copy_v3_v3(&co[0*3], verts[mfaces->v1].xold);
VECCOPY(&co[1*3], verts[mfaces->v2].xold); copy_v3_v3(&co[1*3], verts[mfaces->v2].xold);
VECCOPY(&co[2*3], verts[mfaces->v3].xold); copy_v3_v3(&co[2*3], verts[mfaces->v3].xold);
if(mfaces->v4) if(mfaces->v4)
VECCOPY(&co[3*3], verts[mfaces->v4].xold); copy_v3_v3(&co[3*3], verts[mfaces->v4].xold);
BLI_bvhtree_insert(bvhtree, i, co, (mfaces->v4 ? 4 : 3)); BLI_bvhtree_insert(bvhtree, i, co, (mfaces->v4 ? 4 : 3));
} }
@@ -267,23 +267,23 @@ void bvhtree_update_from_cloth(ClothModifierData *clmd, int moving)
{ {
for(i = 0; i < cloth->numfaces; i++, mfaces++) for(i = 0; i < cloth->numfaces; i++, mfaces++)
{ {
VECCOPY(&co[0*3], verts[mfaces->v1].txold); copy_v3_v3(&co[0*3], verts[mfaces->v1].txold);
VECCOPY(&co[1*3], verts[mfaces->v2].txold); copy_v3_v3(&co[1*3], verts[mfaces->v2].txold);
VECCOPY(&co[2*3], verts[mfaces->v3].txold); copy_v3_v3(&co[2*3], verts[mfaces->v3].txold);
if(mfaces->v4) if(mfaces->v4)
VECCOPY(&co[3*3], verts[mfaces->v4].txold); copy_v3_v3(&co[3*3], verts[mfaces->v4].txold);
// copy new locations into array // copy new locations into array
if(moving) if(moving)
{ {
// update moving positions // update moving positions
VECCOPY(&co_moving[0*3], verts[mfaces->v1].tx); copy_v3_v3(&co_moving[0*3], verts[mfaces->v1].tx);
VECCOPY(&co_moving[1*3], verts[mfaces->v2].tx); copy_v3_v3(&co_moving[1*3], verts[mfaces->v2].tx);
VECCOPY(&co_moving[2*3], verts[mfaces->v3].tx); copy_v3_v3(&co_moving[2*3], verts[mfaces->v3].tx);
if(mfaces->v4) if(mfaces->v4)
VECCOPY(&co_moving[3*3], verts[mfaces->v4].tx); copy_v3_v3(&co_moving[3*3], verts[mfaces->v4].tx);
ret = BLI_bvhtree_update_node(bvhtree, i, co, co_moving, (mfaces->v4 ? 4 : 3)); ret = BLI_bvhtree_update_node(bvhtree, i, co, co_moving, (mfaces->v4 ? 4 : 3));
} }
@@ -321,13 +321,13 @@ void bvhselftree_update_from_cloth(ClothModifierData *clmd, int moving)
{ {
for(i = 0; i < cloth->numverts; i++, verts++) for(i = 0; i < cloth->numverts; i++, verts++)
{ {
VECCOPY(&co[0*3], verts->txold); copy_v3_v3(&co[0*3], verts->txold);
// copy new locations into array // copy new locations into array
if(moving) if(moving)
{ {
// update moving positions // update moving positions
VECCOPY(&co_moving[0*3], verts->tx); copy_v3_v3(&co_moving[0*3], verts->tx);
ret = BLI_bvhtree_update_node(bvhtree, i, co, co_moving, 1); ret = BLI_bvhtree_update_node(bvhtree, i, co, co_moving, 1);
} }
@@ -399,11 +399,11 @@ static int do_step_cloth(Object *ob, ClothModifierData *clmd, DerivedMesh *resul
/* force any pinned verts to their constrained location. */ /* force any pinned verts to their constrained location. */
for(i = 0; i < clmd->clothObject->numverts; i++, verts++) { for(i = 0; i < clmd->clothObject->numverts; i++, verts++) {
/* save the previous position. */ /* save the previous position. */
VECCOPY(verts->xold, verts->xconst); copy_v3_v3(verts->xold, verts->xconst);
VECCOPY(verts->txold, verts->x); copy_v3_v3(verts->txold, verts->x);
/* Get the current position. */ /* Get the current position. */
VECCOPY(verts->xconst, mvert[i].co); copy_v3_v3(verts->xconst, mvert[i].co);
mul_m4_v3(ob->obmat, verts->xconst); mul_m4_v3(ob->obmat, verts->xconst);
} }
@@ -712,7 +712,7 @@ static void cloth_to_object (Object *ob, ClothModifierData *clmd, DerivedMesh *
for (i = 0; i < numverts; i++) for (i = 0; i < numverts; i++)
{ {
VECCOPY (mvert[i].co, cloth->verts[i].x); copy_v3_v3 (mvert[i].co, cloth->verts[i].x);
mul_m4_v3(ob->imat, mvert[i].co); /* cloth is in global coords */ mul_m4_v3(ob->imat, mvert[i].co); /* cloth is in global coords */
} }
} }
@@ -880,14 +880,14 @@ static int cloth_from_object(Object *ob, ClothModifierData *clmd, DerivedMesh *d
verts->goal= 0.0f; verts->goal= 0.0f;
verts->flags = 0; verts->flags = 0;
VECCOPY ( verts->xold, verts->x ); copy_v3_v3 ( verts->xold, verts->x );
VECCOPY ( verts->xconst, verts->x ); copy_v3_v3 ( verts->xconst, verts->x );
VECCOPY ( verts->txold, verts->x ); copy_v3_v3 ( verts->txold, verts->x );
VECCOPY ( verts->tx, verts->x ); copy_v3_v3 ( verts->tx, verts->x );
mul_v3_fl( verts->v, 0.0f ); mul_v3_fl( verts->v, 0.0f );
verts->impulse_count = 0; verts->impulse_count = 0;
VECCOPY ( verts->impulse, tnull ); copy_v3_v3 ( verts->impulse, tnull );
} }
// apply / set vertex groups // apply / set vertex groups
@@ -1053,7 +1053,6 @@ static int cloth_build_springs ( ClothModifierData *clmd, DerivedMesh *dm )
LinkNode **edgelist = NULL; LinkNode **edgelist = NULL;
EdgeHash *edgehash = NULL; EdgeHash *edgehash = NULL;
LinkNode *search = NULL, *search2 = NULL; LinkNode *search = NULL, *search2 = NULL;
float temp[3];
// error handling // error handling
if ( numedges==0 ) if ( numedges==0 )
@@ -1086,8 +1085,7 @@ static int cloth_build_springs ( ClothModifierData *clmd, DerivedMesh *dm )
{ {
spring->ij = MIN2(medge[i].v1, medge[i].v2); spring->ij = MIN2(medge[i].v1, medge[i].v2);
spring->kl = MAX2(medge[i].v2, medge[i].v1); spring->kl = MAX2(medge[i].v2, medge[i].v1);
VECSUB ( temp, cloth->verts[spring->kl].xrest, cloth->verts[spring->ij].xrest ); spring->restlen = len_v3v3(cloth->verts[spring->kl].xrest, cloth->verts[spring->ij].xrest);
spring->restlen = sqrt ( INPR ( temp, temp ) );
clmd->sim_parms->avg_spring_len += spring->restlen; clmd->sim_parms->avg_spring_len += spring->restlen;
cloth->verts[spring->ij].avg_spring_len += spring->restlen; cloth->verts[spring->ij].avg_spring_len += spring->restlen;
cloth->verts[spring->kl].avg_spring_len += spring->restlen; cloth->verts[spring->kl].avg_spring_len += spring->restlen;
@@ -1132,8 +1130,7 @@ static int cloth_build_springs ( ClothModifierData *clmd, DerivedMesh *dm )
spring->ij = MIN2(mface[i].v1, mface[i].v3); spring->ij = MIN2(mface[i].v1, mface[i].v3);
spring->kl = MAX2(mface[i].v3, mface[i].v1); spring->kl = MAX2(mface[i].v3, mface[i].v1);
VECSUB ( temp, cloth->verts[spring->kl].xrest, cloth->verts[spring->ij].xrest ); spring->restlen = len_v3v3(cloth->verts[spring->kl].xrest, cloth->verts[spring->ij].xrest);
spring->restlen = sqrt ( INPR ( temp, temp ) );
spring->type = CLOTH_SPRING_TYPE_SHEAR; spring->type = CLOTH_SPRING_TYPE_SHEAR;
spring->stiffness = (cloth->verts[spring->kl].shear_stiff + cloth->verts[spring->ij].shear_stiff) / 2.0; spring->stiffness = (cloth->verts[spring->kl].shear_stiff + cloth->verts[spring->ij].shear_stiff) / 2.0;
@@ -1155,8 +1152,7 @@ static int cloth_build_springs ( ClothModifierData *clmd, DerivedMesh *dm )
spring->ij = MIN2(mface[i].v2, mface[i].v4); spring->ij = MIN2(mface[i].v2, mface[i].v4);
spring->kl = MAX2(mface[i].v4, mface[i].v2); spring->kl = MAX2(mface[i].v4, mface[i].v2);
VECSUB ( temp, cloth->verts[spring->kl].xrest, cloth->verts[spring->ij].xrest ); spring->restlen = len_v3v3(cloth->verts[spring->kl].xrest, cloth->verts[spring->ij].xrest);
spring->restlen = sqrt ( INPR ( temp, temp ) );
spring->type = CLOTH_SPRING_TYPE_SHEAR; spring->type = CLOTH_SPRING_TYPE_SHEAR;
spring->stiffness = (cloth->verts[spring->kl].shear_stiff + cloth->verts[spring->ij].shear_stiff) / 2.0; spring->stiffness = (cloth->verts[spring->kl].shear_stiff + cloth->verts[spring->ij].shear_stiff) / 2.0;
@@ -1197,8 +1193,7 @@ static int cloth_build_springs ( ClothModifierData *clmd, DerivedMesh *dm )
spring->ij = MIN2(tspring2->ij, index2); spring->ij = MIN2(tspring2->ij, index2);
spring->kl = MAX2(tspring2->ij, index2); spring->kl = MAX2(tspring2->ij, index2);
VECSUB ( temp, cloth->verts[spring->kl].xrest, cloth->verts[spring->ij].xrest ); spring->restlen = len_v3v3(cloth->verts[spring->kl].xrest, cloth->verts[spring->ij].xrest);
spring->restlen = sqrt ( INPR ( temp, temp ) );
spring->type = CLOTH_SPRING_TYPE_BENDING; spring->type = CLOTH_SPRING_TYPE_BENDING;
spring->stiffness = (cloth->verts[spring->kl].bend_stiff + cloth->verts[spring->ij].bend_stiff) / 2.0; spring->stiffness = (cloth->verts[spring->kl].bend_stiff + cloth->verts[spring->ij].bend_stiff) / 2.0;
BLI_edgehash_insert ( edgehash, spring->ij, spring->kl, NULL ); BLI_edgehash_insert ( edgehash, spring->ij, spring->kl, NULL );
@@ -1237,8 +1232,7 @@ static int cloth_build_springs ( ClothModifierData *clmd, DerivedMesh *dm )
spring->ij = tspring2->ij; spring->ij = tspring2->ij;
spring->kl = tspring->kl; spring->kl = tspring->kl;
VECSUB ( temp, cloth->verts[spring->kl].xrest, cloth->verts[spring->ij].xrest ); spring->restlen = len_v3v3(cloth->verts[spring->kl].xrest, cloth->verts[spring->ij].xrest);
spring->restlen = sqrt ( INPR ( temp, temp ) );
spring->type = CLOTH_SPRING_TYPE_BENDING; spring->type = CLOTH_SPRING_TYPE_BENDING;
spring->stiffness = (cloth->verts[spring->kl].bend_stiff + cloth->verts[spring->ij].bend_stiff) / 2.0; spring->stiffness = (cloth->verts[spring->kl].bend_stiff + cloth->verts[spring->ij].bend_stiff) / 2.0;
bend_springs++; bend_springs++;

4
source/blender/blenkernel/intern/particle.c
View File

@@ -1663,7 +1663,7 @@ static int psys_map_index_on_dm(DerivedMesh *dm, int from, int index, int index_
return 0; return 0;
*mapindex = index; *mapindex = index;
QUATCOPY(mapfw, fw); copy_v4_v4(mapfw, fw);
} }
} else { } else {
/* for other meshes that have been modified, we try to map the particle /* for other meshes that have been modified, we try to map the particle
@@ -2835,7 +2835,7 @@ static void cache_key_incremental_rotation(ParticleCacheKey *key0, ParticleCache
* angle, since floating point accuracy makes it give * angle, since floating point accuracy makes it give
* different results across platforms */ * different results across platforms */
if(cosangle > 0.999999f) { if(cosangle > 0.999999f) {
QUATCOPY(key1->rot, key2->rot); copy_v4_v4(key1->rot, key2->rot);
} }
else { else {
angle= saacos(cosangle); angle= saacos(cosangle);

42
source/blender/blenkernel/intern/particle_system.c
View File

@@ -815,7 +815,7 @@ static void distribute_threads_exec(ParticleThread *thread, ParticleData *pa, Ch
normalize_v3(nor); normalize_v3(nor);
mul_v3_fl(nor,-100.0); mul_v3_fl(nor,-100.0);
VECADD(co2,co1,nor); add_v3_v3v3(co2,co1,nor);
min_d=2.0; min_d=2.0;
intersect=0; intersect=0;
@@ -1099,11 +1099,11 @@ static int distribute_threads_init_data(ParticleThread *threads, Scene *scene, D
for(p=0; p<totvert; p++) { for(p=0; p<totvert; p++) {
if(orcodata) { if(orcodata) {
VECCOPY(co,orcodata[p]) copy_v3_v3(co,orcodata[p]);
transform_mesh_orco_verts((Mesh*)ob->data, &co, 1, 1); transform_mesh_orco_verts((Mesh*)ob->data, &co, 1, 1);
} }
else else
VECCOPY(co,mv[p].co) copy_v3_v3(co,mv[p].co);
BLI_kdtree_insert(tree,p,co,NULL); BLI_kdtree_insert(tree,p,co,NULL);
} }
@@ -1141,14 +1141,14 @@ static int distribute_threads_init_data(ParticleThread *threads, Scene *scene, D
MFace *mf=dm->getFaceData(dm,i,CD_MFACE); MFace *mf=dm->getFaceData(dm,i,CD_MFACE);
if(orcodata) { if(orcodata) {
VECCOPY(co1, orcodata[mf->v1]); copy_v3_v3(co1, orcodata[mf->v1]);
VECCOPY(co2, orcodata[mf->v2]); copy_v3_v3(co2, orcodata[mf->v2]);
VECCOPY(co3, orcodata[mf->v3]); copy_v3_v3(co3, orcodata[mf->v3]);
transform_mesh_orco_verts((Mesh*)ob->data, &co1, 1, 1); transform_mesh_orco_verts((Mesh*)ob->data, &co1, 1, 1);
transform_mesh_orco_verts((Mesh*)ob->data, &co2, 1, 1); transform_mesh_orco_verts((Mesh*)ob->data, &co2, 1, 1);
transform_mesh_orco_verts((Mesh*)ob->data, &co3, 1, 1); transform_mesh_orco_verts((Mesh*)ob->data, &co3, 1, 1);
if(mf->v4) { if(mf->v4) {
VECCOPY(co4, orcodata[mf->v4]); copy_v3_v3(co4, orcodata[mf->v4]);
transform_mesh_orco_verts((Mesh*)ob->data, &co4, 1, 1); transform_mesh_orco_verts((Mesh*)ob->data, &co4, 1, 1);
} }
} }
@@ -1156,12 +1156,12 @@ static int distribute_threads_init_data(ParticleThread *threads, Scene *scene, D
v1= (MVert*)dm->getVertData(dm,mf->v1,CD_MVERT); v1= (MVert*)dm->getVertData(dm,mf->v1,CD_MVERT);
v2= (MVert*)dm->getVertData(dm,mf->v2,CD_MVERT); v2= (MVert*)dm->getVertData(dm,mf->v2,CD_MVERT);
v3= (MVert*)dm->getVertData(dm,mf->v3,CD_MVERT); v3= (MVert*)dm->getVertData(dm,mf->v3,CD_MVERT);
VECCOPY(co1, v1->co); copy_v3_v3(co1, v1->co);
VECCOPY(co2, v2->co); copy_v3_v3(co2, v2->co);
VECCOPY(co3, v3->co); copy_v3_v3(co3, v3->co);
if(mf->v4) { if(mf->v4) {
v4= (MVert*)dm->getVertData(dm,mf->v4,CD_MVERT); v4= (MVert*)dm->getVertData(dm,mf->v4,CD_MVERT);
VECCOPY(co4, v4->co); copy_v3_v3(co4, v4->co);
} }
} }
@@ -1648,7 +1648,7 @@ void psys_get_birth_coordinates(ParticleSimulationData *sim, ParticleData *pa, P
normalize_v3(state->ave); normalize_v3(state->ave);
} }
else { else {
VECCOPY(state->ave, nor); copy_v3_v3(state->ave, nor);
} }
/* calculate rotation matrix */ /* calculate rotation matrix */
@@ -2423,7 +2423,7 @@ static void sph_force_cb(void *sphdata_v, ParticleKey *state, float *force, floa
pfr.element_size = MAXFLOAT; pfr.element_size = MAXFLOAT;
} }
sphdata->element_size = pfr.element_size; sphdata->element_size = pfr.element_size;
VECCOPY(sphdata->flow, pfr.flow); copy_v3_v3(sphdata->flow, pfr.flow);
pressure = stiffness * (pfr.density - rest_density); pressure = stiffness * (pfr.density - rest_density);
near_pressure = stiffness_near_fac * pfr.near_density; near_pressure = stiffness_near_fac * pfr.near_density;
@@ -2520,7 +2520,7 @@ static void sph_integrate(ParticleSimulationData *sim, ParticleData *pa, float d
integrate_particle(part, pa, dtime, effector_acceleration, sph_force_cb, &sphdata); integrate_particle(part, pa, dtime, effector_acceleration, sph_force_cb, &sphdata);
*element_size = sphdata.element_size; *element_size = sphdata.element_size;
VECCOPY(flow, sphdata.flow); copy_v3_v3(flow, sphdata.flow);
} }
/************************************************/ /************************************************/
@@ -2592,19 +2592,19 @@ static void basic_integrate(ParticleSimulationData *sim, int p, float dfra, floa
if(part->dampfac != 0.f) if(part->dampfac != 0.f)
mul_v3_fl(pa->state.vel, 1.f - part->dampfac * efdata.ptex.damp * 25.f * dtime); mul_v3_fl(pa->state.vel, 1.f - part->dampfac * efdata.ptex.damp * 25.f * dtime);
//VECCOPY(pa->state.ave, states->ave); //copy_v3_v3(pa->state.ave, states->ave);
/* finally we do guides */ /* finally we do guides */
time=(cfra-pa->time)/pa->lifetime; time=(cfra-pa->time)/pa->lifetime;
CLAMP(time, 0.0f, 1.0f); CLAMP(time, 0.0f, 1.0f);
VECCOPY(tkey.co,pa->state.co); copy_v3_v3(tkey.co,pa->state.co);
VECCOPY(tkey.vel,pa->state.vel); copy_v3_v3(tkey.vel,pa->state.vel);
tkey.time=pa->state.time; tkey.time=pa->state.time;
if(part->type != PART_HAIR) { if(part->type != PART_HAIR) {
if(do_guides(sim->psys->effectors, &tkey, p, time)) { if(do_guides(sim->psys->effectors, &tkey, p, time)) {
VECCOPY(pa->state.co,tkey.co); copy_v3_v3(pa->state.co,tkey.co);
/* guides don't produce valid velocity */ /* guides don't produce valid velocity */
sub_v3_v3v3(pa->state.vel, tkey.co, pa->prev_state.co); sub_v3_v3v3(pa->state.vel, tkey.co, pa->prev_state.co);
mul_v3_fl(pa->state.vel,1.0f/dtime); mul_v3_fl(pa->state.vel,1.0f/dtime);
@@ -3472,8 +3472,8 @@ static void do_hair_dynamics(ParticleSimulationData *sim)
if(k==0) { if(k==0) {
float temp[3]; float temp[3];
sub_v3_v3v3(temp, key->co, (key+1)->co); sub_v3_v3v3(temp, key->co, (key+1)->co);
VECCOPY(mvert->co, key->co); copy_v3_v3(mvert->co, key->co);
VECADD(mvert->co, mvert->co, temp); add_v3_v3v3(mvert->co, mvert->co, temp);
mul_m4_v3(hairmat, mvert->co); mul_m4_v3(hairmat, mvert->co);
mvert++; mvert++;
@@ -3492,7 +3492,7 @@ static void do_hair_dynamics(ParticleSimulationData *sim)
} }
} }
VECCOPY(mvert->co, key->co); copy_v3_v3(mvert->co, key->co);
mul_m4_v3(hairmat, mvert->co); mul_m4_v3(hairmat, mvert->co);
mvert++; mvert++;

270
source/blender/blenkernel/intern/softbody.c
View File

@@ -321,7 +321,7 @@ static ccd_Mesh *ccd_mesh_make(Object *ob)
/* determine the ortho BB */ /* determine the ortho BB */
for(i=0; i < pccd_M->totvert; i++){ for(i=0; i < pccd_M->totvert; i++){
/* evaluate limits */ /* evaluate limits */
VECCOPY(v,pccd_M->mvert[i].co); copy_v3_v3(v,pccd_M->mvert[i].co);
pccd_M->bbmin[0] = MIN2(pccd_M->bbmin[0],v[0]-hull); pccd_M->bbmin[0] = MIN2(pccd_M->bbmin[0],v[0]-hull);
pccd_M->bbmin[1] = MIN2(pccd_M->bbmin[1],v[1]-hull); pccd_M->bbmin[1] = MIN2(pccd_M->bbmin[1],v[1]-hull);
pccd_M->bbmin[2] = MIN2(pccd_M->bbmin[2],v[2]-hull); pccd_M->bbmin[2] = MIN2(pccd_M->bbmin[2],v[2]-hull);
@@ -345,7 +345,7 @@ static ccd_Mesh *ccd_mesh_make(Object *ob)
mima->minx=mima->miny=mima->minz=1e30f; mima->minx=mima->miny=mima->minz=1e30f;
mima->maxx=mima->maxy=mima->maxz=-1e30f; mima->maxx=mima->maxy=mima->maxz=-1e30f;
VECCOPY(v,pccd_M->mvert[mface->v1].co); copy_v3_v3(v,pccd_M->mvert[mface->v1].co);
mima->minx = MIN2(mima->minx,v[0]-hull); mima->minx = MIN2(mima->minx,v[0]-hull);
mima->miny = MIN2(mima->miny,v[1]-hull); mima->miny = MIN2(mima->miny,v[1]-hull);
mima->minz = MIN2(mima->minz,v[2]-hull); mima->minz = MIN2(mima->minz,v[2]-hull);
@@ -353,7 +353,7 @@ static ccd_Mesh *ccd_mesh_make(Object *ob)
mima->maxy = MAX2(mima->maxy,v[1]+hull); mima->maxy = MAX2(mima->maxy,v[1]+hull);
mima->maxz = MAX2(mima->maxz,v[2]+hull); mima->maxz = MAX2(mima->maxz,v[2]+hull);
VECCOPY(v,pccd_M->mvert[mface->v2].co); copy_v3_v3(v,pccd_M->mvert[mface->v2].co);
mima->minx = MIN2(mima->minx,v[0]-hull); mima->minx = MIN2(mima->minx,v[0]-hull);
mima->miny = MIN2(mima->miny,v[1]-hull); mima->miny = MIN2(mima->miny,v[1]-hull);
mima->minz = MIN2(mima->minz,v[2]-hull); mima->minz = MIN2(mima->minz,v[2]-hull);
@@ -361,7 +361,7 @@ static ccd_Mesh *ccd_mesh_make(Object *ob)
mima->maxy = MAX2(mima->maxy,v[1]+hull); mima->maxy = MAX2(mima->maxy,v[1]+hull);
mima->maxz = MAX2(mima->maxz,v[2]+hull); mima->maxz = MAX2(mima->maxz,v[2]+hull);
VECCOPY(v,pccd_M->mvert[mface->v3].co); copy_v3_v3(v,pccd_M->mvert[mface->v3].co);
mima->minx = MIN2(mima->minx,v[0]-hull); mima->minx = MIN2(mima->minx,v[0]-hull);
mima->miny = MIN2(mima->miny,v[1]-hull); mima->miny = MIN2(mima->miny,v[1]-hull);
mima->minz = MIN2(mima->minz,v[2]-hull); mima->minz = MIN2(mima->minz,v[2]-hull);
@@ -370,7 +370,7 @@ static ccd_Mesh *ccd_mesh_make(Object *ob)
mima->maxz = MAX2(mima->maxz,v[2]+hull); mima->maxz = MAX2(mima->maxz,v[2]+hull);
if(mface->v4){ if(mface->v4){
VECCOPY(v,pccd_M->mvert[mface->v4].co); copy_v3_v3(v,pccd_M->mvert[mface->v4].co);
mima->minx = MIN2(mima->minx,v[0]-hull); mima->minx = MIN2(mima->minx,v[0]-hull);
mima->miny = MIN2(mima->miny,v[1]-hull); mima->miny = MIN2(mima->miny,v[1]-hull);
mima->minz = MIN2(mima->minz,v[2]-hull); mima->minz = MIN2(mima->minz,v[2]-hull);
@@ -419,7 +419,7 @@ static void ccd_mesh_update(Object *ob,ccd_Mesh *pccd_M)
/* determine the ortho BB */ /* determine the ortho BB */
for(i=0; i < pccd_M->totvert; i++){ for(i=0; i < pccd_M->totvert; i++){
/* evaluate limits */ /* evaluate limits */
VECCOPY(v,pccd_M->mvert[i].co); copy_v3_v3(v,pccd_M->mvert[i].co);
pccd_M->bbmin[0] = MIN2(pccd_M->bbmin[0],v[0]-hull); pccd_M->bbmin[0] = MIN2(pccd_M->bbmin[0],v[0]-hull);
pccd_M->bbmin[1] = MIN2(pccd_M->bbmin[1],v[1]-hull); pccd_M->bbmin[1] = MIN2(pccd_M->bbmin[1],v[1]-hull);
pccd_M->bbmin[2] = MIN2(pccd_M->bbmin[2],v[2]-hull); pccd_M->bbmin[2] = MIN2(pccd_M->bbmin[2],v[2]-hull);
@@ -429,7 +429,7 @@ static void ccd_mesh_update(Object *ob,ccd_Mesh *pccd_M)
pccd_M->bbmax[2] = MAX2(pccd_M->bbmax[2],v[2]+hull); pccd_M->bbmax[2] = MAX2(pccd_M->bbmax[2],v[2]+hull);
/* evaluate limits */ /* evaluate limits */
VECCOPY(v,pccd_M->mprevvert[i].co); copy_v3_v3(v,pccd_M->mprevvert[i].co);
pccd_M->bbmin[0] = MIN2(pccd_M->bbmin[0],v[0]-hull); pccd_M->bbmin[0] = MIN2(pccd_M->bbmin[0],v[0]-hull);
pccd_M->bbmin[1] = MIN2(pccd_M->bbmin[1],v[1]-hull); pccd_M->bbmin[1] = MIN2(pccd_M->bbmin[1],v[1]-hull);
pccd_M->bbmin[2] = MIN2(pccd_M->bbmin[2],v[2]-hull); pccd_M->bbmin[2] = MIN2(pccd_M->bbmin[2],v[2]-hull);
@@ -449,7 +449,7 @@ static void ccd_mesh_update(Object *ob,ccd_Mesh *pccd_M)
mima->minx=mima->miny=mima->minz=1e30f; mima->minx=mima->miny=mima->minz=1e30f;
mima->maxx=mima->maxy=mima->maxz=-1e30f; mima->maxx=mima->maxy=mima->maxz=-1e30f;
VECCOPY(v,pccd_M->mvert[mface->v1].co); copy_v3_v3(v,pccd_M->mvert[mface->v1].co);
mima->minx = MIN2(mima->minx,v[0]-hull); mima->minx = MIN2(mima->minx,v[0]-hull);
mima->miny = MIN2(mima->miny,v[1]-hull); mima->miny = MIN2(mima->miny,v[1]-hull);
mima->minz = MIN2(mima->minz,v[2]-hull); mima->minz = MIN2(mima->minz,v[2]-hull);
@@ -457,7 +457,7 @@ static void ccd_mesh_update(Object *ob,ccd_Mesh *pccd_M)
mima->maxy = MAX2(mima->maxy,v[1]+hull); mima->maxy = MAX2(mima->maxy,v[1]+hull);
mima->maxz = MAX2(mima->maxz,v[2]+hull); mima->maxz = MAX2(mima->maxz,v[2]+hull);
VECCOPY(v,pccd_M->mvert[mface->v2].co); copy_v3_v3(v,pccd_M->mvert[mface->v2].co);
mima->minx = MIN2(mima->minx,v[0]-hull); mima->minx = MIN2(mima->minx,v[0]-hull);
mima->miny = MIN2(mima->miny,v[1]-hull); mima->miny = MIN2(mima->miny,v[1]-hull);
mima->minz = MIN2(mima->minz,v[2]-hull); mima->minz = MIN2(mima->minz,v[2]-hull);
@@ -465,7 +465,7 @@ static void ccd_mesh_update(Object *ob,ccd_Mesh *pccd_M)
mima->maxy = MAX2(mima->maxy,v[1]+hull); mima->maxy = MAX2(mima->maxy,v[1]+hull);
mima->maxz = MAX2(mima->maxz,v[2]+hull); mima->maxz = MAX2(mima->maxz,v[2]+hull);
VECCOPY(v,pccd_M->mvert[mface->v3].co); copy_v3_v3(v,pccd_M->mvert[mface->v3].co);
mima->minx = MIN2(mima->minx,v[0]-hull); mima->minx = MIN2(mima->minx,v[0]-hull);
mima->miny = MIN2(mima->miny,v[1]-hull); mima->miny = MIN2(mima->miny,v[1]-hull);
mima->minz = MIN2(mima->minz,v[2]-hull); mima->minz = MIN2(mima->minz,v[2]-hull);
@@ -474,7 +474,7 @@ static void ccd_mesh_update(Object *ob,ccd_Mesh *pccd_M)
mima->maxz = MAX2(mima->maxz,v[2]+hull); mima->maxz = MAX2(mima->maxz,v[2]+hull);
if(mface->v4){ if(mface->v4){
VECCOPY(v,pccd_M->mvert[mface->v4].co); copy_v3_v3(v,pccd_M->mvert[mface->v4].co);
mima->minx = MIN2(mima->minx,v[0]-hull); mima->minx = MIN2(mima->minx,v[0]-hull);
mima->miny = MIN2(mima->miny,v[1]-hull); mima->miny = MIN2(mima->miny,v[1]-hull);
mima->minz = MIN2(mima->minz,v[2]-hull); mima->minz = MIN2(mima->minz,v[2]-hull);
@@ -484,7 +484,7 @@ static void ccd_mesh_update(Object *ob,ccd_Mesh *pccd_M)
} }
VECCOPY(v,pccd_M->mprevvert[mface->v1].co); copy_v3_v3(v,pccd_M->mprevvert[mface->v1].co);
mima->minx = MIN2(mima->minx,v[0]-hull); mima->minx = MIN2(mima->minx,v[0]-hull);
mima->miny = MIN2(mima->miny,v[1]-hull); mima->miny = MIN2(mima->miny,v[1]-hull);
mima->minz = MIN2(mima->minz,v[2]-hull); mima->minz = MIN2(mima->minz,v[2]-hull);
@@ -492,7 +492,7 @@ static void ccd_mesh_update(Object *ob,ccd_Mesh *pccd_M)
mima->maxy = MAX2(mima->maxy,v[1]+hull); mima->maxy = MAX2(mima->maxy,v[1]+hull);
mima->maxz = MAX2(mima->maxz,v[2]+hull); mima->maxz = MAX2(mima->maxz,v[2]+hull);
VECCOPY(v,pccd_M->mprevvert[mface->v2].co); copy_v3_v3(v,pccd_M->mprevvert[mface->v2].co);
mima->minx = MIN2(mima->minx,v[0]-hull); mima->minx = MIN2(mima->minx,v[0]-hull);
mima->miny = MIN2(mima->miny,v[1]-hull); mima->miny = MIN2(mima->miny,v[1]-hull);
mima->minz = MIN2(mima->minz,v[2]-hull); mima->minz = MIN2(mima->minz,v[2]-hull);
@@ -500,7 +500,7 @@ static void ccd_mesh_update(Object *ob,ccd_Mesh *pccd_M)
mima->maxy = MAX2(mima->maxy,v[1]+hull); mima->maxy = MAX2(mima->maxy,v[1]+hull);
mima->maxz = MAX2(mima->maxz,v[2]+hull); mima->maxz = MAX2(mima->maxz,v[2]+hull);
VECCOPY(v,pccd_M->mprevvert[mface->v3].co); copy_v3_v3(v,pccd_M->mprevvert[mface->v3].co);
mima->minx = MIN2(mima->minx,v[0]-hull); mima->minx = MIN2(mima->minx,v[0]-hull);
mima->miny = MIN2(mima->miny,v[1]-hull); mima->miny = MIN2(mima->miny,v[1]-hull);
mima->minz = MIN2(mima->minz,v[2]-hull); mima->minz = MIN2(mima->minz,v[2]-hull);
@@ -509,7 +509,7 @@ static void ccd_mesh_update(Object *ob,ccd_Mesh *pccd_M)
mima->maxz = MAX2(mima->maxz,v[2]+hull); mima->maxz = MAX2(mima->maxz,v[2]+hull);
if(mface->v4){ if(mface->v4){
VECCOPY(v,pccd_M->mprevvert[mface->v4].co); copy_v3_v3(v,pccd_M->mprevvert[mface->v4].co);
mima->minx = MIN2(mima->minx,v[0]-hull); mima->minx = MIN2(mima->minx,v[0]-hull);
mima->miny = MIN2(mima->miny,v[1]-hull); mima->miny = MIN2(mima->miny,v[1]-hull);
mima->minz = MIN2(mima->minz,v[2]-hull); mima->minz = MIN2(mima->minz,v[2]-hull);
@@ -1024,8 +1024,8 @@ static int sb_detect_aabb_collisionCached( float UNUSED(force[3]), unsigned int
#endif #endif
if ((sb == NULL) || (sb->scratch ==NULL)) return 0; if ((sb == NULL) || (sb->scratch ==NULL)) return 0;
VECCOPY(aabbmin,sb->scratch->aabbmin); copy_v3_v3(aabbmin,sb->scratch->aabbmin);
VECCOPY(aabbmax,sb->scratch->aabbmax); copy_v3_v3(aabbmax,sb->scratch->aabbmax);
hash = vertexowner->soft->scratch->colliderhash; hash = vertexowner->soft->scratch->colliderhash;
ihash = BLI_ghashIterator_new(hash); ihash = BLI_ghashIterator_new(hash);
@@ -1099,8 +1099,8 @@ static int sb_detect_face_pointCached(float face_v1[3],float face_v2[3],float fa
aabbmax[2] = MAX3(face_v1[2],face_v2[2],face_v3[2]); aabbmax[2] = MAX3(face_v1[2],face_v2[2],face_v3[2]);
/* calculate face normal once again SIGH */ /* calculate face normal once again SIGH */
VECSUB(edge1, face_v1, face_v2); sub_v3_v3v3(edge1, face_v1, face_v2);
VECSUB(edge2, face_v3, face_v2); sub_v3_v3v3(edge2, face_v3, face_v2);
cross_v3_v3v3(d_nvect, edge2, edge1); cross_v3_v3v3(d_nvect, edge2, edge1);
normalize_v3(d_nvect); normalize_v3(d_nvect);
@@ -1143,13 +1143,13 @@ static int sb_detect_face_pointCached(float face_v1[3],float face_v2[3],float fa
/* use mesh*/ /* use mesh*/
if (mvert) { if (mvert) {
while(a){ while(a){
VECCOPY(nv1,mvert[a-1].co); copy_v3_v3(nv1,mvert[a-1].co);
if(mprevvert){ if(mprevvert){
mul_v3_fl(nv1,time); mul_v3_fl(nv1,time);
Vec3PlusStVec(nv1,(1.0f-time),mprevvert[a-1].co); Vec3PlusStVec(nv1,(1.0f-time),mprevvert[a-1].co);
} }
/* origin to face_v2*/ /* origin to face_v2*/
VECSUB(nv1, nv1, face_v2); sub_v3_v3(nv1, face_v2);
facedist = dot_v3v3(nv1,d_nvect); facedist = dot_v3v3(nv1,d_nvect);
if (ABS(facedist)<outerfacethickness){ if (ABS(facedist)<outerfacethickness){
if (isect_point_tri_prism_v3(nv1, face_v1,face_v2,face_v3) ){ if (isect_point_tri_prism_v3(nv1, face_v1,face_v2,face_v3) ){
@@ -1253,11 +1253,11 @@ static int sb_detect_face_collisionCached(float face_v1[3],float face_v2[3],floa
if (mvert){ if (mvert){
VECCOPY(nv1,mvert[mface->v1].co); copy_v3_v3(nv1,mvert[mface->v1].co);
VECCOPY(nv2,mvert[mface->v2].co); copy_v3_v3(nv2,mvert[mface->v2].co);
VECCOPY(nv3,mvert[mface->v3].co); copy_v3_v3(nv3,mvert[mface->v3].co);
if (mface->v4){ if (mface->v4){
VECCOPY(nv4,mvert[mface->v4].co); copy_v3_v3(nv4,mvert[mface->v4].co);
} }
if (mprevvert){ if (mprevvert){
mul_v3_fl(nv1,time); mul_v3_fl(nv1,time);
@@ -1277,8 +1277,8 @@ static int sb_detect_face_collisionCached(float face_v1[3],float face_v2[3],floa
} }
/* switch origin to be nv2*/ /* switch origin to be nv2*/
VECSUB(edge1, nv1, nv2); sub_v3_v3v3(edge1, nv1, nv2);
VECSUB(edge2, nv3, nv2); sub_v3_v3v3(edge2, nv3, nv2);
cross_v3_v3v3(d_nvect, edge2, edge1); cross_v3_v3v3(d_nvect, edge2, edge1);
normalize_v3(d_nvect); normalize_v3(d_nvect);
if ( if (
@@ -1291,8 +1291,8 @@ static int sb_detect_face_collisionCached(float face_v1[3],float face_v2[3],floa
} }
if (mface->v4){ /* quad */ if (mface->v4){ /* quad */
/* switch origin to be nv4 */ /* switch origin to be nv4 */
VECSUB(edge1, nv3, nv4); sub_v3_v3v3(edge1, nv3, nv4);
VECSUB(edge2, nv1, nv4); sub_v3_v3v3(edge2, nv1, nv4);
cross_v3_v3v3(d_nvect, edge2, edge1); cross_v3_v3v3(d_nvect, edge2, edge1);
normalize_v3(d_nvect); normalize_v3(d_nvect);
if ( if (
@@ -1481,11 +1481,11 @@ static int sb_detect_edge_collisionCached(float edge_v1[3],float edge_v2[3],floa
if (mvert){ if (mvert){
VECCOPY(nv1,mvert[mface->v1].co); copy_v3_v3(nv1,mvert[mface->v1].co);
VECCOPY(nv2,mvert[mface->v2].co); copy_v3_v3(nv2,mvert[mface->v2].co);
VECCOPY(nv3,mvert[mface->v3].co); copy_v3_v3(nv3,mvert[mface->v3].co);
if (mface->v4){ if (mface->v4){
VECCOPY(nv4,mvert[mface->v4].co); copy_v3_v3(nv4,mvert[mface->v4].co);
} }
if (mprevvert){ if (mprevvert){
mul_v3_fl(nv1,time); mul_v3_fl(nv1,time);
@@ -1505,16 +1505,16 @@ static int sb_detect_edge_collisionCached(float edge_v1[3],float edge_v2[3],floa
} }
/* switch origin to be nv2*/ /* switch origin to be nv2*/
VECSUB(edge1, nv1, nv2); sub_v3_v3v3(edge1, nv1, nv2);
VECSUB(edge2, nv3, nv2); sub_v3_v3v3(edge2, nv3, nv2);
cross_v3_v3v3(d_nvect, edge2, edge1); cross_v3_v3v3(d_nvect, edge2, edge1);
normalize_v3(d_nvect); normalize_v3(d_nvect);
if ( isect_line_tri_v3(edge_v1, edge_v2, nv1, nv2, nv3, &t, NULL)){ if ( isect_line_tri_v3(edge_v1, edge_v2, nv1, nv2, nv3, &t, NULL)){
float v1[3],v2[3]; float v1[3],v2[3];
float intrusiondepth,i1,i2; float intrusiondepth,i1,i2;
VECSUB(v1, edge_v1, nv2); sub_v3_v3v3(v1, edge_v1, nv2);
VECSUB(v2, edge_v2, nv2); sub_v3_v3v3(v2, edge_v2, nv2);
i1 = dot_v3v3(v1,d_nvect); i1 = dot_v3v3(v1,d_nvect);
i2 = dot_v3v3(v2,d_nvect); i2 = dot_v3v3(v2,d_nvect);
intrusiondepth = -MIN2(i1,i2)/el; intrusiondepth = -MIN2(i1,i2)/el;
@@ -1524,16 +1524,16 @@ static int sb_detect_edge_collisionCached(float edge_v1[3],float edge_v2[3],floa
} }
if (mface->v4){ /* quad */ if (mface->v4){ /* quad */
/* switch origin to be nv4 */ /* switch origin to be nv4 */
VECSUB(edge1, nv3, nv4); sub_v3_v3v3(edge1, nv3, nv4);
VECSUB(edge2, nv1, nv4); sub_v3_v3v3(edge2, nv1, nv4);
cross_v3_v3v3(d_nvect, edge2, edge1); cross_v3_v3v3(d_nvect, edge2, edge1);
normalize_v3(d_nvect); normalize_v3(d_nvect);
if (isect_line_tri_v3( edge_v1, edge_v2,nv1, nv3, nv4, &t, NULL)){ if (isect_line_tri_v3( edge_v1, edge_v2,nv1, nv3, nv4, &t, NULL)){
float v1[3],v2[3]; float v1[3],v2[3];
float intrusiondepth,i1,i2; float intrusiondepth,i1,i2;
VECSUB(v1, edge_v1, nv4); sub_v3_v3v3(v1, edge_v1, nv4);
VECSUB(v2, edge_v2, nv4); sub_v3_v3v3(v2, edge_v2, nv4);
i1 = dot_v3v3(v1,d_nvect); i1 = dot_v3v3(v1,d_nvect);
i2 = dot_v3v3(v2,d_nvect); i2 = dot_v3v3(v2,d_nvect);
intrusiondepth = -MIN2(i1,i2)/el; intrusiondepth = -MIN2(i1,i2)/el;
@@ -1602,16 +1602,16 @@ static void _scan_for_ext_spring_forces(Scene *scene, Object *ob, float timenow,
} }
/* media in rest */ /* media in rest */
else{ else{
VECADD(vel, sb->bpoint[bs->v1].vec , sb->bpoint[bs->v2].vec); add_v3_v3v3(vel, sb->bpoint[bs->v1].vec , sb->bpoint[bs->v2].vec);
} }
f = normalize_v3(vel); f = normalize_v3(vel);
f = -0.0001f*f*f*sb->aeroedge; f = -0.0001f*f*f*sb->aeroedge;
/* (todo) add a nice angle dependant function done for now BUT */ /* (todo) add a nice angle dependant function done for now BUT */
/* still there could be some nice drag/lift function, but who needs it */ /* still there could be some nice drag/lift function, but who needs it */
VECSUB(sp, sb->bpoint[bs->v1].pos , sb->bpoint[bs->v2].pos); sub_v3_v3v3(sp, sb->bpoint[bs->v1].pos , sb->bpoint[bs->v2].pos);
project_v3_v3v3(pr,vel,sp); project_v3_v3v3(pr,vel,sp);
VECSUB(vel,vel,pr); sub_v3_v3(vel, pr);
normalize_v3(vel); normalize_v3(vel);
if (ob->softflag & OB_SB_AERO_ANGLE){ if (ob->softflag & OB_SB_AERO_ANGLE){
normalize_v3(sp); normalize_v3(sp);
@@ -1725,9 +1725,9 @@ static int choose_winner(float*w, float* pos,float*a,float*b,float*c,float*ca,fl
winner =3; winner =3;
} }
switch (winner){ switch (winner){
case 1: VECCOPY(w,ca); break; case 1: copy_v3_v3(w,ca); break;
case 2: VECCOPY(w,cb); break; case 2: copy_v3_v3(w,cb); break;
case 3: VECCOPY(w,cc); case 3: copy_v3_v3(w,cc);
} }
return(winner); return(winner);
} }
@@ -1824,11 +1824,11 @@ static int sb_detect_vertex_collisionCached(float opco[3], float facenormal[3],
if (mvert){ if (mvert){
VECCOPY(nv1,mvert[mface->v1].co); copy_v3_v3(nv1,mvert[mface->v1].co);
VECCOPY(nv2,mvert[mface->v2].co); copy_v3_v3(nv2,mvert[mface->v2].co);
VECCOPY(nv3,mvert[mface->v3].co); copy_v3_v3(nv3,mvert[mface->v3].co);
if (mface->v4){ if (mface->v4){
VECCOPY(nv4,mvert[mface->v4].co); copy_v3_v3(nv4,mvert[mface->v4].co);
} }
if (mprevvert){ if (mprevvert){
@@ -1838,11 +1838,11 @@ static int sb_detect_vertex_collisionCached(float opco[3], float facenormal[3],
since the AABB reduced propabitlty to get here drasticallly since the AABB reduced propabitlty to get here drasticallly
it might be a nice tradeof CPU <--> memory it might be a nice tradeof CPU <--> memory
*/ */
VECSUB(vv1,nv1,mprevvert[mface->v1].co); sub_v3_v3v3(vv1,nv1,mprevvert[mface->v1].co);
VECSUB(vv2,nv2,mprevvert[mface->v2].co); sub_v3_v3v3(vv2,nv2,mprevvert[mface->v2].co);
VECSUB(vv3,nv3,mprevvert[mface->v3].co); sub_v3_v3v3(vv3,nv3,mprevvert[mface->v3].co);
if (mface->v4){ if (mface->v4){
VECSUB(vv4,nv4,mprevvert[mface->v4].co); sub_v3_v3v3(vv4,nv4,mprevvert[mface->v4].co);
} }
mul_v3_fl(nv1,time); mul_v3_fl(nv1,time);
@@ -1862,9 +1862,9 @@ static int sb_detect_vertex_collisionCached(float opco[3], float facenormal[3],
} }
/* switch origin to be nv2*/ /* switch origin to be nv2*/
VECSUB(edge1, nv1, nv2); sub_v3_v3v3(edge1, nv1, nv2);
VECSUB(edge2, nv3, nv2); sub_v3_v3v3(edge2, nv3, nv2);
VECSUB(dv1,opco,nv2); /* abuse dv1 to have vertex in question at *origin* of triangle */ sub_v3_v3v3(dv1,opco,nv2); /* abuse dv1 to have vertex in question at *origin* of triangle */
cross_v3_v3v3(d_nvect, edge2, edge1); cross_v3_v3v3(d_nvect, edge2, edge1);
/* n_mag = */ /* UNUSED */ normalize_v3(d_nvect); /* n_mag = */ /* UNUSED */ normalize_v3(d_nvect);
@@ -1890,7 +1890,7 @@ static int sb_detect_vertex_collisionCached(float opco[3], float facenormal[3],
} }
if ((mprevvert) && (*damp > 0.0f)){ if ((mprevvert) && (*damp > 0.0f)){
choose_winner(ve,opco,nv1,nv2,nv3,vv1,vv2,vv3); choose_winner(ve,opco,nv1,nv2,nv3,vv1,vv2,vv3);
VECADD(avel,avel,ve); add_v3_v3(avel, ve);
cavel ++; cavel ++;
} }
*intrusion += facedist; *intrusion += facedist;
@@ -1899,9 +1899,9 @@ static int sb_detect_vertex_collisionCached(float opco[3], float facenormal[3],
} }
if (mface->v4){ /* quad */ if (mface->v4){ /* quad */
/* switch origin to be nv4 */ /* switch origin to be nv4 */
VECSUB(edge1, nv3, nv4); sub_v3_v3v3(edge1, nv3, nv4);
VECSUB(edge2, nv1, nv4); sub_v3_v3v3(edge2, nv1, nv4);
VECSUB(dv1,opco,nv4); /* abuse dv1 to have vertex in question at *origin* of triangle */ sub_v3_v3v3(dv1,opco,nv4); /* abuse dv1 to have vertex in question at *origin* of triangle */
cross_v3_v3v3(d_nvect, edge2, edge1); cross_v3_v3v3(d_nvect, edge2, edge1);
/* n_mag = */ /* UNUSED */ normalize_v3(d_nvect); /* n_mag = */ /* UNUSED */ normalize_v3(d_nvect);
@@ -1926,7 +1926,7 @@ static int sb_detect_vertex_collisionCached(float opco[3], float facenormal[3],
if ((mprevvert) && (*damp > 0.0f)){ if ((mprevvert) && (*damp > 0.0f)){
choose_winner(ve,opco,nv1,nv3,nv4,vv1,vv3,vv4); choose_winner(ve,opco,nv1,nv3,nv4,vv1,vv3,vv4);
VECADD(avel,avel,ve); add_v3_v3(avel, ve);
cavel ++; cavel ++;
} }
*intrusion += facedist; *intrusion += facedist;
@@ -1939,46 +1939,46 @@ static int sb_detect_vertex_collisionCached(float opco[3], float facenormal[3],
float dist; float dist;
closest_to_line_segment_v3(ve, opco, nv1, nv2); closest_to_line_segment_v3(ve, opco, nv1, nv2);
VECSUB(ve,opco,ve); sub_v3_v3v3(ve,opco,ve);
dist = normalize_v3(ve); dist = normalize_v3(ve);
if ((dist < outerfacethickness)&&(dist < mindistedge )){ if ((dist < outerfacethickness)&&(dist < mindistedge )){
VECCOPY(coledge,ve); copy_v3_v3(coledge,ve);
mindistedge = dist, mindistedge = dist,
deflected=1; deflected=1;
} }
closest_to_line_segment_v3(ve, opco, nv2, nv3); closest_to_line_segment_v3(ve, opco, nv2, nv3);
VECSUB(ve,opco,ve); sub_v3_v3v3(ve,opco,ve);
dist = normalize_v3(ve); dist = normalize_v3(ve);
if ((dist < outerfacethickness)&&(dist < mindistedge )){ if ((dist < outerfacethickness)&&(dist < mindistedge )){
VECCOPY(coledge,ve); copy_v3_v3(coledge,ve);
mindistedge = dist, mindistedge = dist,
deflected=1; deflected=1;
} }
closest_to_line_segment_v3(ve, opco, nv3, nv1); closest_to_line_segment_v3(ve, opco, nv3, nv1);
VECSUB(ve,opco,ve); sub_v3_v3v3(ve,opco,ve);
dist = normalize_v3(ve); dist = normalize_v3(ve);
if ((dist < outerfacethickness)&&(dist < mindistedge )){ if ((dist < outerfacethickness)&&(dist < mindistedge )){
VECCOPY(coledge,ve); copy_v3_v3(coledge,ve);
mindistedge = dist, mindistedge = dist,
deflected=1; deflected=1;
} }
if (mface->v4){ /* quad */ if (mface->v4){ /* quad */
closest_to_line_segment_v3(ve, opco, nv3, nv4); closest_to_line_segment_v3(ve, opco, nv3, nv4);
VECSUB(ve,opco,ve); sub_v3_v3v3(ve,opco,ve);
dist = normalize_v3(ve); dist = normalize_v3(ve);
if ((dist < outerfacethickness)&&(dist < mindistedge )){ if ((dist < outerfacethickness)&&(dist < mindistedge )){
VECCOPY(coledge,ve); copy_v3_v3(coledge,ve);
mindistedge = dist, mindistedge = dist,
deflected=1; deflected=1;
} }
closest_to_line_segment_v3(ve, opco, nv1, nv4); closest_to_line_segment_v3(ve, opco, nv1, nv4);
VECSUB(ve,opco,ve); sub_v3_v3v3(ve,opco,ve);
dist = normalize_v3(ve); dist = normalize_v3(ve);
if ((dist < outerfacethickness)&&(dist < mindistedge )){ if ((dist < outerfacethickness)&&(dist < mindistedge )){
VECCOPY(coledge,ve); copy_v3_v3(coledge,ve);
mindistedge = dist, mindistedge = dist,
deflected=1; deflected=1;
} }
@@ -2007,15 +2007,15 @@ static int sb_detect_vertex_collisionCached(float opco[3], float facenormal[3],
} }
if (deflected == 2){ // face inner detected if (deflected == 2){ // face inner detected
VECADD(force,force,innerforceaccu); add_v3_v3(force, innerforceaccu);
} }
if (deflected == 3){ // face outer detected if (deflected == 3){ // face outer detected
VECADD(force,force,outerforceaccu); add_v3_v3(force, outerforceaccu);
} }
BLI_ghashIterator_free(ihash); BLI_ghashIterator_free(ihash);
if (cavel) mul_v3_fl(avel,1.0f/(float)cavel); if (cavel) mul_v3_fl(avel,1.0f/(float)cavel);
VECCOPY(vel,avel); copy_v3_v3(vel,avel);
if (ci) *intrusion /= ci; if (ci) *intrusion /= ci;
if (deflected){ if (deflected){
normalize_v3_v3(facenormal, force); normalize_v3_v3(facenormal, force);
@@ -2029,7 +2029,7 @@ static int sb_deflect_face(Object *ob,float *actpos,float *facenormal,float *for
{ {
float s_actpos[3]; float s_actpos[3];
int deflected; int deflected;
VECCOPY(s_actpos,actpos); copy_v3_v3(s_actpos,actpos);
deflected= sb_detect_vertex_collisionCached(s_actpos, facenormal, cf, force , ob->lay, ob,time,vel,intrusion); deflected= sb_detect_vertex_collisionCached(s_actpos, facenormal, cf, force , ob->lay, ob,time,vel,intrusion);
//deflected= sb_detect_vertex_collisionCachedEx(s_actpos, facenormal, cf, force , ob->lay, ob,time,vel,intrusion); //deflected= sb_detect_vertex_collisionCachedEx(s_actpos, facenormal, cf, force , ob->lay, ob,time,vel,intrusion);
return(deflected); return(deflected);
@@ -2286,7 +2286,7 @@ static int _softbody_calc_forces_slice_in_a_thread(Scene *scene, Object *ob, flo
/* gravitation */ /* gravitation */
if (sb && scene->physics_settings.flag & PHYS_GLOBAL_GRAVITY){ if (sb && scene->physics_settings.flag & PHYS_GLOBAL_GRAVITY){
float gravity[3]; float gravity[3];
VECCOPY(gravity, scene->physics_settings.gravity); copy_v3_v3(gravity, scene->physics_settings.gravity);
mul_v3_fl(gravity, sb_grav_force_scale(ob)*_final_mass(ob,bp)*sb->effector_weights->global_gravity); /* individual mass of node here */ mul_v3_fl(gravity, sb_grav_force_scale(ob)*_final_mass(ob,bp)*sb->effector_weights->global_gravity); /* individual mass of node here */
add_v3_v3(bp->force, gravity); add_v3_v3(bp->force, gravity);
} }
@@ -2303,7 +2303,7 @@ static int _softbody_calc_forces_slice_in_a_thread(Scene *scene, Object *ob, flo
/* apply forcefield*/ /* apply forcefield*/
mul_v3_fl(force,fieldfactor* eval_sb_fric_force_scale); mul_v3_fl(force,fieldfactor* eval_sb_fric_force_scale);
VECADD(bp->force, bp->force, force); add_v3_v3(bp->force, force);
/* BP friction in moving media */ /* BP friction in moving media */
kd= sb->mediafrict* eval_sb_fric_force_scale; kd= sb->mediafrict* eval_sb_fric_force_scale;
@@ -2337,7 +2337,7 @@ static int _softbody_calc_forces_slice_in_a_thread(Scene *scene, Object *ob, flo
bp->choke = sb->choke*0.01f; bp->choke = sb->choke*0.01f;
} }
VECSUB(cfforce,bp->vec,vel); sub_v3_v3v3(cfforce,bp->vec,vel);
Vec3PlusStVec(bp->force,-cf*50.0f,cfforce); Vec3PlusStVec(bp->force,-cf*50.0f,cfforce);
Vec3PlusStVec(bp->force,kd,defforce); Vec3PlusStVec(bp->force,kd,defforce);
@@ -2524,7 +2524,7 @@ static void softbody_calc_forces(Scene *scene, Object *ob, float forcetime, floa
if (scene->physics_settings.flag & PHYS_GLOBAL_GRAVITY){ if (scene->physics_settings.flag & PHYS_GLOBAL_GRAVITY){
VECCOPY(gravity, scene->physics_settings.gravity); copy_v3_v3(gravity, scene->physics_settings.gravity);
mul_v3_fl(gravity, sb_grav_force_scale(ob)*sb->effector_weights->global_gravity); mul_v3_fl(gravity, sb_grav_force_scale(ob)*sb->effector_weights->global_gravity);
} }
@@ -2711,7 +2711,7 @@ static void softbody_calc_forces(Scene *scene, Object *ob, float forcetime, floa
/* apply forcefield*/ /* apply forcefield*/
mul_v3_fl(force,fieldfactor* eval_sb_fric_force_scale); mul_v3_fl(force,fieldfactor* eval_sb_fric_force_scale);
VECADD(bp->force, bp->force, force); add_v3_v3(bp->force, force);
/* BP friction in moving media */ /* BP friction in moving media */
kd= sb->mediafrict* eval_sb_fric_force_scale; kd= sb->mediafrict* eval_sb_fric_force_scale;
@@ -2764,7 +2764,7 @@ static void softbody_calc_forces(Scene *scene, Object *ob, float forcetime, floa
} }
else{ else{
VECSUB(cfforce,bp->vec,vel); sub_v3_v3v3(cfforce,bp->vec,vel);
Vec3PlusStVec(bp->force,-cf*50.0f,cfforce); Vec3PlusStVec(bp->force,-cf*50.0f,cfforce);
} }
@@ -2774,7 +2774,7 @@ static void softbody_calc_forces(Scene *scene, Object *ob, float forcetime, floa
bp->choke = sb->choke*0.01f; bp->choke = sb->choke*0.01f;
} }
else{ else{
VECSUB(cfforce,bp->vec,vel); sub_v3_v3v3(cfforce,bp->vec,vel);
Vec3PlusStVec(bp->force,-cf*50.0f,cfforce); Vec3PlusStVec(bp->force,-cf*50.0f,cfforce);
} }
Vec3PlusStVec(bp->force,kd,defforce); Vec3PlusStVec(bp->force,kd,defforce);
@@ -2876,7 +2876,7 @@ static void softbody_calc_forces(Scene *scene, Object *ob, float forcetime, floa
else{ else{
printf("Matrix inversion failed \n"); printf("Matrix inversion failed \n");
for(a=sb->totpoint, bp= sb->bpoint; a>0; a--, bp++) { for(a=sb->totpoint, bp= sb->bpoint; a>0; a--, bp++) {
VECCOPY(bp->impdv,bp->force); copy_v3_v3(bp->impdv,bp->force);
} }
} }
@@ -2923,7 +2923,7 @@ static void softbody_apply_forces(Object *ob, float forcetime, int mode, float *
if(_final_goal(ob,bp) < SOFTGOALSNAP){ if(_final_goal(ob,bp) < SOFTGOALSNAP){
/* this makes t~ = t */ /* this makes t~ = t */
if(mid_flags & MID_PRESERVE) VECCOPY(dx,bp->vec); if(mid_flags & MID_PRESERVE) copy_v3_v3(dx,bp->vec);
/* so here is (v)' = a(cceleration) = sum(F_springs)/m + gravitation + some friction forces + more forces*/ /* so here is (v)' = a(cceleration) = sum(F_springs)/m + gravitation + some friction forces + more forces*/
/* the ( ... )' operator denotes derivate respective time */ /* the ( ... )' operator denotes derivate respective time */
@@ -2931,11 +2931,11 @@ static void softbody_apply_forces(Object *ob, float forcetime, int mode, float *
/* v(t + dt) = v(t) + a(t) * dt */ /* v(t + dt) = v(t) + a(t) * dt */
mul_v3_fl(bp->force,timeovermass);/* individual mass of node here */ mul_v3_fl(bp->force,timeovermass);/* individual mass of node here */
/* some nasty if's to have heun in here too */ /* some nasty if's to have heun in here too */
VECCOPY(dv,bp->force); copy_v3_v3(dv,bp->force);
if (mode == 1){ if (mode == 1){
VECCOPY(bp->prevvec, bp->vec); copy_v3_v3(bp->prevvec, bp->vec);
VECCOPY(bp->prevdv, dv); copy_v3_v3(bp->prevdv, dv);
} }
if (mode ==2){ if (mode ==2){
@@ -2948,10 +2948,10 @@ static void softbody_apply_forces(Object *ob, float forcetime, int mode, float *
maxerrvel = MAX2(maxerrvel,ABS(dv[1] - bp->prevdv[1])); maxerrvel = MAX2(maxerrvel,ABS(dv[1] - bp->prevdv[1]));
maxerrvel = MAX2(maxerrvel,ABS(dv[2] - bp->prevdv[2])); maxerrvel = MAX2(maxerrvel,ABS(dv[2] - bp->prevdv[2]));
} }
else {VECADD(bp->vec, bp->vec, bp->force);} else { add_v3_v3(bp->vec, bp->force); }
/* this makes t~ = t+dt */ /* this makes t~ = t+dt */
if(!(mid_flags & MID_PRESERVE)) VECCOPY(dx,bp->vec); if(!(mid_flags & MID_PRESERVE)) copy_v3_v3(dx,bp->vec);
/* so here is (x)'= v(elocity) */ /* so here is (x)'= v(elocity) */
/* the euler step for location then becomes */ /* the euler step for location then becomes */
@@ -2970,8 +2970,8 @@ static void softbody_apply_forces(Object *ob, float forcetime, int mode, float *
*/ */
/* again some nasty if's to have heun in here too */ /* again some nasty if's to have heun in here too */
if (mode ==1){ if (mode ==1){
VECCOPY(bp->prevpos,bp->pos); copy_v3_v3(bp->prevpos,bp->pos);
VECCOPY(bp->prevdx ,dx); copy_v3_v3(bp->prevdx ,dx);
} }
if (mode ==2){ if (mode ==2){
@@ -2994,7 +2994,7 @@ static void softbody_apply_forces(Object *ob, float forcetime, int mode, float *
} }
} }
else { VECADD(bp->pos, bp->pos, dx);} else { add_v3_v3(bp->pos, dx);}
}/*snap*/ }/*snap*/
/* so while we are looping BPs anyway do statistics on the fly */ /* so while we are looping BPs anyway do statistics on the fly */
aabbmin[0] = MIN2(aabbmin[0],bp->pos[0]); aabbmin[0] = MIN2(aabbmin[0],bp->pos[0]);
@@ -3008,8 +3008,8 @@ static void softbody_apply_forces(Object *ob, float forcetime, int mode, float *
if (sb->totpoint) mul_v3_fl(cm,1.0f/sb->totpoint); if (sb->totpoint) mul_v3_fl(cm,1.0f/sb->totpoint);
if (sb->scratch){ if (sb->scratch){
VECCOPY(sb->scratch->aabbmin,aabbmin); copy_v3_v3(sb->scratch->aabbmin,aabbmin);
VECCOPY(sb->scratch->aabbmax,aabbmax); copy_v3_v3(sb->scratch->aabbmax,aabbmax);
} }
if (err){ /* so step size will be controlled by biggest difference in slope */ if (err){ /* so step size will be controlled by biggest difference in slope */
@@ -3032,8 +3032,8 @@ static void softbody_restore_prev_step(Object *ob)
int a; int a;
for(a=sb->totpoint, bp= sb->bpoint; a>0; a--, bp++) { for(a=sb->totpoint, bp= sb->bpoint; a>0; a--, bp++) {
VECCOPY(bp->vec, bp->prevvec); copy_v3_v3(bp->vec, bp->prevvec);
VECCOPY(bp->pos, bp->prevpos); copy_v3_v3(bp->pos, bp->prevpos);
} }
} }
@@ -3045,8 +3045,8 @@ static void softbody_store_step(Object *ob)
int a; int a;
for(a=sb->totpoint, bp= sb->bpoint; a>0; a--, bp++) { for(a=sb->totpoint, bp= sb->bpoint; a>0; a--, bp++) {
VECCOPY(bp->prevvec,bp->vec); copy_v3_v3(bp->prevvec,bp->vec);
VECCOPY(bp->prevpos,bp->pos); copy_v3_v3(bp->prevpos,bp->pos);
} }
} }
@@ -3061,10 +3061,10 @@ static void softbody_store_state(Object *ob,float *ppos,float *pvel)
for(a=sb->totpoint, bp= sb->bpoint; a>0; a--, bp++) { for(a=sb->totpoint, bp= sb->bpoint; a>0; a--, bp++) {
VECCOPY(pv, bp->vec); copy_v3_v3(pv, bp->vec);
pv+=3; pv+=3;
VECCOPY(pp, bp->pos); copy_v3_v3(pp, bp->pos);
pp+=3; pp+=3;
} }
} }
@@ -3079,10 +3079,10 @@ static void softbody_retrieve_state(Object *ob,float *ppos,float *pvel)
for(a=sb->totpoint, bp= sb->bpoint; a>0; a--, bp++) { for(a=sb->totpoint, bp= sb->bpoint; a>0; a--, bp++) {
VECCOPY(bp->vec,pv); copy_v3_v3(bp->vec,pv);
pv+=3; pv+=3;
VECCOPY(bp->pos,pp); copy_v3_v3(bp->pos,pp);
pp+=3; pp+=3;
} }
} }
@@ -3098,14 +3098,14 @@ static void softbody_swap_state(Object *ob,float *ppos,float *pvel)
for(a=sb->totpoint, bp= sb->bpoint; a>0; a--, bp++) { for(a=sb->totpoint, bp= sb->bpoint; a>0; a--, bp++) {
VECCOPY(temp, bp->vec); copy_v3_v3(temp, bp->vec);
VECCOPY(bp->vec,pv); copy_v3_v3(bp->vec,pv);
VECCOPY(pv,temp); copy_v3_v3(pv,temp);
pv+=3; pv+=3;
VECCOPY(temp, bp->pos); copy_v3_v3(temp, bp->pos);
VECCOPY(bp->pos,pp); copy_v3_v3(bp->pos,pp);
VECCOPY(pp,temp); copy_v3_v3(pp,temp);
pp+=3; pp+=3;
} }
} }
@@ -3126,8 +3126,8 @@ static void softbody_apply_goalsnap(Object *ob)
for(a=sb->totpoint, bp= sb->bpoint; a>0; a--, bp++) { for(a=sb->totpoint, bp= sb->bpoint; a>0; a--, bp++) {
if (_final_goal(ob,bp) >= SOFTGOALSNAP){ if (_final_goal(ob,bp) >= SOFTGOALSNAP){
VECCOPY(bp->prevpos,bp->pos); copy_v3_v3(bp->prevpos,bp->pos);
VECCOPY(bp->pos,bp->origT); copy_v3_v3(bp->pos,bp->origT);
} }
} }
} }
@@ -3238,7 +3238,7 @@ static void springs_from_mesh(Object *ob)
if(me->totvert) { if(me->totvert) {
bp= ob->soft->bpoint; bp= ob->soft->bpoint;
for(a=0; a<me->totvert; a++, bp++) { for(a=0; a<me->totvert; a++, bp++) {
VECCOPY(bp->origS, me->mvert[a].co); copy_v3_v3(bp->origS, me->mvert[a].co);
mul_m4_v3(ob->obmat, bp->origS); mul_m4_v3(ob->obmat, bp->origS);
} }
@@ -3399,12 +3399,12 @@ static void reference_to_scratch(Object *ob)
bp= ob->soft->bpoint; bp= ob->soft->bpoint;
rp= sb->scratch->Ref.ivert; rp= sb->scratch->Ref.ivert;
for(a=0; a<sb->totpoint; a++, rp++, bp++) { for(a=0; a<sb->totpoint; a++, rp++, bp++) {
VECCOPY(rp->pos,bp->pos); copy_v3_v3(rp->pos,bp->pos);
VECADD(accu_pos,accu_pos,bp->pos); add_v3_v3(accu_pos, bp->pos);
accu_mass += _final_mass(ob,bp); accu_mass += _final_mass(ob,bp);
} }
mul_v3_fl(accu_pos,1.0f/accu_mass); mul_v3_fl(accu_pos,1.0f/accu_mass);
VECCOPY(sb->scratch->Ref.com,accu_pos); copy_v3_v3(sb->scratch->Ref.com,accu_pos);
/* printf("reference_to_scratch \n"); */ /* printf("reference_to_scratch \n"); */
} }
@@ -3415,9 +3415,9 @@ when object is rescaled
static float globallen(float *v1,float *v2,Object *ob) static float globallen(float *v1,float *v2,Object *ob)
{ {
float p1[3],p2[3]; float p1[3],p2[3];
VECCOPY(p1,v1); copy_v3_v3(p1,v1);
mul_m4_v3(ob->obmat, p1); mul_m4_v3(ob->obmat, p1);
VECCOPY(p2,v2); copy_v3_v3(p2,v2);
mul_m4_v3(ob->obmat, p2); mul_m4_v3(ob->obmat, p2);
return len_v3v3(p1,p2); return len_v3v3(p1,p2);
} }
@@ -3656,7 +3656,7 @@ static void softbody_to_object(Object *ob, float (*vertexCos)[3], int numVerts,
invert_m4_m4(ob->imat, ob->obmat); invert_m4_m4(ob->imat, ob->obmat);
for(a=0; a<numVerts; a++, bp++) { for(a=0; a<numVerts; a++, bp++) {
VECCOPY(vertexCos[a], bp->pos); copy_v3_v3(vertexCos[a], bp->pos);
if(local==0) if(local==0)
mul_m4_v3(ob->imat, vertexCos[a]); /* softbody is in global coords, baked optionally not */ mul_m4_v3(ob->imat, vertexCos[a]); /* softbody is in global coords, baked optionally not */
} }
@@ -3784,14 +3784,14 @@ static void softbody_update_positions(Object *ob, SoftBody *sb, float (*vertexCo
for(a=0,bp=sb->bpoint; a<numVerts; a++, bp++) { for(a=0,bp=sb->bpoint; a<numVerts; a++, bp++) {
/* store where goals are now */ /* store where goals are now */
VECCOPY(bp->origS, bp->origE); copy_v3_v3(bp->origS, bp->origE);
/* copy the position of the goals at desired end time */ /* copy the position of the goals at desired end time */
VECCOPY(bp->origE, vertexCos[a]); copy_v3_v3(bp->origE, vertexCos[a]);
/* vertexCos came from local world, go global */ /* vertexCos came from local world, go global */
mul_m4_v3(ob->obmat, bp->origE); mul_m4_v3(ob->obmat, bp->origE);
/* just to be save give bp->origT a defined value /* just to be save give bp->origT a defined value
will be calulated in interpolate_exciter()*/ will be calulated in interpolate_exciter()*/
VECCOPY(bp->origT, bp->origE); copy_v3_v3(bp->origT, bp->origE);
} }
} }
@@ -3828,14 +3828,14 @@ void SB_estimate_transform(Object *ob,float lloc[3],float lrot[3][3],float lscal
rpos= MEM_callocN( (sb->totpoint)*3*sizeof(float), "SB_RPOS"); rpos= MEM_callocN( (sb->totpoint)*3*sizeof(float), "SB_RPOS");
/* might filter vertex selection with a vertex group */ /* might filter vertex selection with a vertex group */
for(a=0, bp=sb->bpoint, rp=sb->scratch->Ref.ivert; a<sb->totpoint; a++, bp++, rp++) { for(a=0, bp=sb->bpoint, rp=sb->scratch->Ref.ivert; a<sb->totpoint; a++, bp++, rp++) {
VECCOPY(rpos[a],rp->pos); copy_v3_v3(rpos[a],rp->pos);
VECCOPY(opos[a],bp->pos); copy_v3_v3(opos[a],bp->pos);
} }
vcloud_estimate_transform(sb->totpoint, opos, NULL, rpos, NULL, com, rcom,lrot,lscale); vcloud_estimate_transform(sb->totpoint, opos, NULL, rpos, NULL, com, rcom,lrot,lscale);
//VECSUB(com,com,rcom); //sub_v3_v3(com,rcom);
if (lloc) VECCOPY(lloc,com); if (lloc) copy_v3_v3(lloc,com);
VECCOPY(sb->lcom,com); copy_v3_v3(sb->lcom,com);
if (lscale) copy_m3_m3(sb->lscale,lscale); if (lscale) copy_m3_m3(sb->lscale,lscale);
if (lrot) copy_m3_m3(sb->lrot,lrot); if (lrot) copy_m3_m3(sb->lrot,lrot);
@@ -3850,11 +3850,11 @@ static void softbody_reset(Object *ob, SoftBody *sb, float (*vertexCos)[3], int
int a; int a;
for(a=0,bp=sb->bpoint; a<numVerts; a++, bp++) { for(a=0,bp=sb->bpoint; a<numVerts; a++, bp++) {
VECCOPY(bp->pos, vertexCos[a]); copy_v3_v3(bp->pos, vertexCos[a]);
mul_m4_v3(ob->obmat, bp->pos); /* yep, sofbody is global coords*/ mul_m4_v3(ob->obmat, bp->pos); /* yep, sofbody is global coords*/
VECCOPY(bp->origS, bp->pos); copy_v3_v3(bp->origS, bp->pos);
VECCOPY(bp->origE, bp->pos); copy_v3_v3(bp->origE, bp->pos);
VECCOPY(bp->origT, bp->pos); copy_v3_v3(bp->origT, bp->pos);
bp->vec[0]= bp->vec[1]= bp->vec[2]= 0.0f; bp->vec[0]= bp->vec[1]= bp->vec[2]= 0.0f;
/* the bp->prev*'s are for rolling back from a canceled try to propagate in time /* the bp->prev*'s are for rolling back from a canceled try to propagate in time
@@ -3869,10 +3869,10 @@ static void softbody_reset(Object *ob, SoftBody *sb, float (*vertexCos)[3], int
4.b yup we're done 4.b yup we're done
*/ */
VECCOPY(bp->prevpos, bp->pos); copy_v3_v3(bp->prevpos, bp->pos);
VECCOPY(bp->prevvec, bp->vec); copy_v3_v3(bp->prevvec, bp->vec);
VECCOPY(bp->prevdx, bp->vec); copy_v3_v3(bp->prevdx, bp->vec);
VECCOPY(bp->prevdv, bp->vec); copy_v3_v3(bp->prevdv, bp->vec);
} }
/* make a nice clean scratch struc */ /* make a nice clean scratch struc */

2
source/blender/blenkernel/intern/subsurf_ccg.c
View File

@@ -668,7 +668,7 @@ static void ccgDM_getFinalVertCo(DerivedMesh *dm, int vertNum, float co_r[3])
MVert mvert; MVert mvert;
ccgDM_getFinalVert(dm, vertNum, &mvert); ccgDM_getFinalVert(dm, vertNum, &mvert);
VECCOPY(co_r, mvert.co); copy_v3_v3(co_r, mvert.co);
} }
static void ccgDM_getFinalVertNo(DerivedMesh *dm, int vertNum, float no_r[3]) static void ccgDM_getFinalVertNo(DerivedMesh *dm, int vertNum, float no_r[3])

2
source/blender/blenkernel/intern/texture.c
View File

@@ -227,7 +227,7 @@ void init_mapping(TexMapping *texmap)
mul_m3_m3m3(mat, rmat, smat); mul_m3_m3m3(mat, rmat, smat);
copy_m4_m3(texmap->mat, mat); copy_m4_m3(texmap->mat, mat);
VECCOPY(texmap->mat[3], texmap->loc); copy_v3_v3(texmap->mat[3], texmap->loc);
} }

4
source/blender/blenlib/intern/graph.c
View File

@@ -823,14 +823,14 @@ static void testAxialSymmetry(BGraph *graph, BNode* root_node, BNode* node1, BNo
} }
/* mirror node2 along axis */ /* mirror node2 along axis */
VECCOPY(p, node2->p); copy_v3_v3(p, node2->p);
BLI_mirrorAlongAxis(p, root_node->p, nor); BLI_mirrorAlongAxis(p, root_node->p, nor);
/* check if it's within limit before continuing */ /* check if it's within limit before continuing */
if (len_v3v3(node1->p, p) <= limit) if (len_v3v3(node1->p, p) <= limit)
{ {
/* mark node as symmetric physically */ /* mark node as symmetric physically */
VECCOPY(root_node->symmetry_axis, nor); copy_v3_v3(root_node->symmetry_axis, nor);
root_node->symmetry_flag |= SYM_PHYSICAL; root_node->symmetry_flag |= SYM_PHYSICAL;
root_node->symmetry_flag |= SYM_AXIAL; root_node->symmetry_flag |= SYM_AXIAL;

18
source/blender/blenloader/intern/readfile.c
View File

@@ -4412,7 +4412,7 @@ static void direct_link_object(FileData *fd, Object *ob)
* a hook we need to make sure it gets converted * a hook we need to make sure it gets converted
* and free'd, regardless of version. * and free'd, regardless of version.
*/ */
VECCOPY(hmd->cent, hook->cent); copy_v3_v3(hmd->cent, hook->cent);
hmd->falloff = hook->falloff; hmd->falloff = hook->falloff;
hmd->force = hook->force; hmd->force = hook->force;
hmd->indexar = hook->indexar; hmd->indexar = hook->indexar;
@@ -9607,7 +9607,7 @@ static void do_versions(FileData *fd, Library *lib, Main *main)
part->obfac = paf->obfac; part->obfac = paf->obfac;
part->randfac = paf->randfac * 25.0f; part->randfac = paf->randfac * 25.0f;
part->dampfac = paf->damp; part->dampfac = paf->damp;
VECCOPY(part->acc, paf->force); copy_v3_v3(part->acc, paf->force);
/* flags */ /* flags */
if(paf->stype & PAF_VECT) { if(paf->stype & PAF_VECT) {
@@ -10658,7 +10658,7 @@ static void do_versions(FileData *fd, Library *lib, Main *main)
tot= MIN2(me->totvert, key->refkey->totelem); tot= MIN2(me->totvert, key->refkey->totelem);
for(a=0; a<tot; a++, data+=3) for(a=0; a<tot; a++, data+=3)
VECCOPY(me->mvert[a].co, data) copy_v3_v3(me->mvert[a].co, data);
} }
} }
@@ -10668,7 +10668,7 @@ static void do_versions(FileData *fd, Library *lib, Main *main)
tot= MIN2(lt->pntsu*lt->pntsv*lt->pntsw, key->refkey->totelem); tot= MIN2(lt->pntsu*lt->pntsv*lt->pntsw, key->refkey->totelem);
for(a=0; a<tot; a++, data+=3) for(a=0; a<tot; a++, data+=3)
VECCOPY(lt->def[a].vec, data) copy_v3_v3(lt->def[a].vec, data);
} }
} }
@@ -10681,9 +10681,9 @@ static void do_versions(FileData *fd, Library *lib, Main *main)
BezTriple *bezt = nu->bezt; BezTriple *bezt = nu->bezt;
for(a=0; a<nu->pntsu; a++, bezt++) { for(a=0; a<nu->pntsu; a++, bezt++) {
VECCOPY(bezt->vec[0], data); data+=3; copy_v3_v3(bezt->vec[0], data); data+=3;
VECCOPY(bezt->vec[1], data); data+=3; copy_v3_v3(bezt->vec[1], data); data+=3;
VECCOPY(bezt->vec[2], data); data+=3; copy_v3_v3(bezt->vec[2], data); data+=3;
bezt->alfa= *data; data++; bezt->alfa= *data; data++;
} }
} }
@@ -10691,7 +10691,7 @@ static void do_versions(FileData *fd, Library *lib, Main *main)
BPoint *bp = nu->bp; BPoint *bp = nu->bp;
for(a=0; a<nu->pntsu*nu->pntsv; a++, bp++) { for(a=0; a<nu->pntsu*nu->pntsv; a++, bp++) {
VECCOPY(bp->vec, data); data+=3; copy_v3_v3(bp->vec, data); data+=3;
bp->alfa= *data; data++; bp->alfa= *data; data++;
} }
} }
@@ -13376,7 +13376,7 @@ static void give_base_to_groups(Main *mainvar, Scene *scene)
ob->dup_group= group; ob->dup_group= group;
ob->transflag |= OB_DUPLIGROUP; ob->transflag |= OB_DUPLIGROUP;
rename_id(&ob->id, group->id.name+2); rename_id(&ob->id, group->id.name+2);
VECCOPY(ob->loc, scene->cursor); copy_v3_v3(ob->loc, scene->cursor);
} }
} }
} }

2
source/blender/gpu/intern/gpu_material.c
View File

@@ -296,7 +296,7 @@ void GPU_material_bind_uniforms(GPUMaterial *material, float obmat[][4], float v
GPU_shader_uniform_vector(shader, material->invobmatloc, 16, 1, (float*)invmat); GPU_shader_uniform_vector(shader, material->invobmatloc, 16, 1, (float*)invmat);
} }
if(material->builtins & GPU_OBCOLOR) { if(material->builtins & GPU_OBCOLOR) {
QUATCOPY(col, obcol); copy_v4_v4(col, obcol);
CLAMP(col[3], 0.0f, 1.0f); CLAMP(col[3], 0.0f, 1.0f);
GPU_shader_uniform_vector(shader, material->obcolloc, 4, 1, col); GPU_shader_uniform_vector(shader, material->obcolloc, 4, 1, col);
} }

2
source/blender/modifiers/intern/MOD_particleinstance.c
View File

@@ -257,7 +257,7 @@ static DerivedMesh * applyModifier(ModifierData *md, Object *ob,
mul_qt_v3(state.rot,mv->co); mul_qt_v3(state.rot,mv->co);
if(pimd->flag & eParticleInstanceFlag_UseSize) if(pimd->flag & eParticleInstanceFlag_UseSize)
mul_v3_fl(mv->co, size[i/totvert]); mul_v3_fl(mv->co, size[i/totvert]);
VECADD(mv->co,mv->co,state.co); add_v3_v3(mv->co, state.co);
} }
mface=result->getFaceArray(result); mface=result->getFaceArray(result);

4
source/blender/modifiers/intern/MOD_simpledeform.c
View File

@@ -198,7 +198,7 @@ static void SimpleDeformModifier_do(SimpleDeformModifierData *smd, struct Object
for(i=0; i<numVerts; i++) for(i=0; i<numVerts; i++)
{ {
float tmp[3]; float tmp[3];
VECCOPY(tmp, vertexCos[i]); copy_v3_v3(tmp, vertexCos[i]);
if(transf) space_transform_apply(transf, tmp); if(transf) space_transform_apply(transf, tmp);
@@ -236,7 +236,7 @@ static void SimpleDeformModifier_do(SimpleDeformModifierData *smd, struct Object
if(transf) space_transform_apply(transf, vertexCos[i]); if(transf) space_transform_apply(transf, vertexCos[i]);
VECCOPY(co, vertexCos[i]); copy_v3_v3(co, vertexCos[i]);
//Apply axis limits //Apply axis limits
if(smd->mode != MOD_SIMPLEDEFORM_MODE_BEND) //Bend mode shoulnt have any lock axis if(smd->mode != MOD_SIMPLEDEFORM_MODE_BEND) //Bend mode shoulnt have any lock axis

18
source/blender/python/mathutils/mathutils_geometry.c
View File

@@ -97,14 +97,14 @@ static PyObject *M_Geometry_intersect_ray_tri(PyObject *UNUSED(self), PyObject*
if (BaseMath_ReadCallback(vec1) == -1 || BaseMath_ReadCallback(vec2) == -1 || BaseMath_ReadCallback(vec3) == -1 || BaseMath_ReadCallback(ray) == -1 || BaseMath_ReadCallback(ray_off) == -1) if (BaseMath_ReadCallback(vec1) == -1 || BaseMath_ReadCallback(vec2) == -1 || BaseMath_ReadCallback(vec3) == -1 || BaseMath_ReadCallback(ray) == -1 || BaseMath_ReadCallback(ray_off) == -1)
return NULL; return NULL;
VECCOPY(v1, vec1->vec); copy_v3_v3(v1, vec1->vec);
VECCOPY(v2, vec2->vec); copy_v3_v3(v2, vec2->vec);
VECCOPY(v3, vec3->vec); copy_v3_v3(v3, vec3->vec);
VECCOPY(dir, ray->vec); copy_v3_v3(dir, ray->vec);
normalize_v3(dir); normalize_v3(dir);
VECCOPY(orig, ray_off->vec); copy_v3_v3(orig, ray_off->vec);
/* find vectors for two edges sharing v1 */ /* find vectors for two edges sharing v1 */
sub_v3_v3v3(e1, v2, v1); sub_v3_v3v3(e1, v2, v1);
@@ -189,10 +189,10 @@ static PyObject *M_Geometry_intersect_line_line(PyObject *UNUSED(self), PyObject
int result; int result;
if (vec1->size == 3) { if (vec1->size == 3) {
VECCOPY(v1, vec1->vec); copy_v3_v3(v1, vec1->vec);
VECCOPY(v2, vec2->vec); copy_v3_v3(v2, vec2->vec);
VECCOPY(v3, vec3->vec); copy_v3_v3(v3, vec3->vec);
VECCOPY(v4, vec4->vec); copy_v3_v3(v4, vec4->vec);
} }
else { else {
v1[0]= vec1->vec[0]; v1[0]= vec1->vec[0];

2
source/blender/render/intern/include/zbuf.h
View File

@@ -135,7 +135,7 @@ void zbufclipwire(struct ZSpan *zspan, int obi, int zvlnr, int ec, float *ho1, f
/* exported to shadeinput.c */ /* exported to shadeinput.c */
void zbuf_make_winmat(Render *re, float winmat[][4]); void zbuf_make_winmat(Render *re, float winmat[][4]);
void zbuf_render_project(float winmat[][4], float *co, float *ho); void zbuf_render_project(float winmat[][4], const float co[3], float ho[4]);
#endif #endif

2
source/blender/render/intern/source/imagetexture.c
View File

@@ -88,7 +88,7 @@ static void ibuf_get_color(float *col, struct ImBuf *ibuf, int x, int y)
if(ibuf->rect_float) { if(ibuf->rect_float) {
if(ibuf->channels==4) { if(ibuf->channels==4) {
float *fp= ibuf->rect_float + 4*ofs; float *fp= ibuf->rect_float + 4*ofs;
QUATCOPY(col, fp); copy_v4_v4(col, fp);
} }
else if(ibuf->channels==3) { else if(ibuf->channels==3) {
float *fp= ibuf->rect_float + 3*ofs; float *fp= ibuf->rect_float + 3*ofs;

2
source/blender/render/intern/source/rayshade.c
View File

@@ -1593,7 +1593,7 @@ void ray_trace(ShadeInput *shi, ShadeResult *shr)
} }
/* put back together */ /* put back together */
if(shi->combinedflag & SCE_PASS_SPEC) if(shi->combinedflag & SCE_PASS_SPEC)
VECADD(shr->combined, diff, shr->spec) /* no ; */ add_v3_v3v3(shr->combined, diff, shr->spec);
else else
copy_v3_v3(shr->combined, diff); copy_v3_v3(shr->combined, diff);
} }

6
source/blender/render/intern/source/rendercore.c
View File

@@ -562,7 +562,7 @@ static void add_passes(RenderLayer *rl, int offset, ShadeInput *shi, ShadeResult
float *fp; float *fp;
fp= rl->rectf + 4*offset; fp= rl->rectf + 4*offset;
QUATCOPY(fp, shr->combined); copy_v4_v4(fp, shr->combined);
for(rpass= rl->passes.first; rpass; rpass= rpass->next) { for(rpass= rl->passes.first; rpass; rpass= rpass->next) {
float *col= NULL, uvcol[3]; float *col= NULL, uvcol[3];
@@ -695,7 +695,7 @@ static void sky_tile(RenderPart *pa, RenderLayer *rl)
} }
if(pass[3]==0.0f) { if(pass[3]==0.0f) {
QUATCOPY(pass, col); copy_v4_v4(pass, col);
} }
else { else {
addAlphaUnderFloat(pass, col); addAlphaUnderFloat(pass, col);
@@ -2345,7 +2345,7 @@ static void do_bake_shade(void *handle, int x, int y, float u, float v)
if(bs->type==RE_BAKE_NORMALS && R.r.bake_normal_space==R_BAKE_SPACE_TANGENT) { if(bs->type==RE_BAKE_NORMALS && R.r.bake_normal_space==R_BAKE_SPACE_TANGENT) {
shade_input_set_shade_texco(shi); shade_input_set_shade_texco(shi);
VECCOPY(tvn, shi->nmapnorm); VECCOPY(tvn, shi->nmapnorm);
QUATCOPY(ttang, shi->nmaptang); copy_v4_v4(ttang, shi->nmaptang);
} }
/* if we are doing selected to active baking, find point on other face */ /* if we are doing selected to active baking, find point on other face */

18
source/blender/render/intern/source/shadeoutput.c
View File

@@ -495,10 +495,10 @@ static float area_lamp_energy_multisample(LampRen *lar, float *co, float *vn)
vec[2]= 0.0f; vec[2]= 0.0f;
mul_m3_v3(lar->mat, vec); mul_m3_v3(lar->mat, vec);
VECADD(area[0], lar->area[0], vec); add_v3_v3v3(area[0], lar->area[0], vec);
VECADD(area[1], lar->area[1], vec); add_v3_v3v3(area[1], lar->area[1], vec);
VECADD(area[2], lar->area[2], vec); add_v3_v3v3(area[2], lar->area[2], vec);
VECADD(area[3], lar->area[3], vec); add_v3_v3v3(area[3], lar->area[3], vec);
intens+= area_lamp_energy(area, co, vn); intens+= area_lamp_energy(area, co, vn);
@@ -1111,12 +1111,12 @@ void lamp_get_shadow(LampRen *lar, ShadeInput *shi, float inp, float shadfac[4],
} }
if(shi->depth==0) { if(shi->depth==0) {
QUATCOPY(lss->shadfac, shadfac); copy_v4_v4(lss->shadfac, shadfac);
lss->samplenr= shi->samplenr; lss->samplenr= shi->samplenr;
} }
} }
else { else {
QUATCOPY(shadfac, lss->shadfac); copy_v4_v4(shadfac, lss->shadfac);
} }
} }
@@ -1879,16 +1879,16 @@ void shade_lamp_loop(ShadeInput *shi, ShadeResult *shr)
/* and add emit and spec */ /* and add emit and spec */
if(shi->combinedflag & SCE_PASS_EMIT) if(shi->combinedflag & SCE_PASS_EMIT)
VECADD(shr->combined, shr->combined, shr->emit); add_v3_v3(shr->combined, shr->emit);
if(shi->combinedflag & SCE_PASS_SPEC) if(shi->combinedflag & SCE_PASS_SPEC)
VECADD(shr->combined, shr->combined, shr->spec); add_v3_v3(shr->combined, shr->spec);
/* modulate by the object color */ /* modulate by the object color */
if((ma->shade_flag & MA_OBCOLOR) && shi->obr->ob) { if((ma->shade_flag & MA_OBCOLOR) && shi->obr->ob) {
if(!(ma->sss_flag & MA_DIFF_SSS) || !sss_pass_done(&R, ma)) { if(!(ma->sss_flag & MA_DIFF_SSS) || !sss_pass_done(&R, ma)) {
float obcol[4]; float obcol[4];
QUATCOPY(obcol, shi->obr->ob->col); copy_v4_v4(obcol, shi->obr->ob->col);
CLAMP(obcol[3], 0.0f, 1.0f); CLAMP(obcol[3], 0.0f, 1.0f);
shr->combined[0] *= obcol[0]; shr->combined[0] *= obcol[0];

16
source/blender/render/intern/source/sss.c
View File

@@ -1,4 +1,4 @@
/* /*
* *
* ***** BEGIN GPL LICENSE BLOCK ***** * ***** BEGIN GPL LICENSE BLOCK *****
* *
@@ -452,11 +452,11 @@ static void compute_radiance(ScatterTree *tree, float *co, float *rad)
mul_v3_fl(result.rad, tree->ss[0]->frontweight); mul_v3_fl(result.rad, tree->ss[0]->frontweight);
mul_v3_fl(result.backrad, tree->ss[0]->backweight); mul_v3_fl(result.backrad, tree->ss[0]->backweight);
VECCOPY(rad, result.rad); copy_v3_v3(rad, result.rad);
VECADD(backrad, result.rad, result.backrad); add_v3_v3v3(backrad, result.rad, result.backrad);
VECCOPY(rdsum, result.rdsum); copy_v3_v3(rdsum, result.rdsum);
VECADD(backrdsum, result.rdsum, result.backrdsum); add_v3_v3v3(backrdsum, result.rdsum, result.backrdsum);
if(rdsum[0] > 1e-16f) rad[0]= tree->ss[0]->color*rad[0]/rdsum[0]; if(rdsum[0] > 1e-16f) rad[0]= tree->ss[0]->color*rad[0]/rdsum[0];
if(rdsum[1] > 1e-16f) rad[1]= tree->ss[1]->color*rad[1]/rdsum[1]; if(rdsum[1] > 1e-16f) rad[1]= tree->ss[1]->color*rad[1]/rdsum[1];
@@ -761,8 +761,8 @@ ScatterTree *scatter_tree_new(ScatterSettings *ss[3], float scale, float error,
INIT_MINMAX(tree->min, tree->max); INIT_MINMAX(tree->min, tree->max);
for(i=0; i<totpoint; i++) { for(i=0; i<totpoint; i++) {
VECCOPY(points[i].co, co[i]); copy_v3_v3(points[i].co, co[i]);
VECCOPY(points[i].rad, color[i]); copy_v3_v3(points[i].rad, color[i]);
points[i].area= fabsf(area[i])/(tree->scale*tree->scale); points[i].area= fabsf(area[i])/(tree->scale*tree->scale);
points[i].back= (area[i] < 0.0f); points[i].back= (area[i] < 0.0f);
@@ -818,7 +818,7 @@ void scatter_tree_sample(ScatterTree *tree, float *co, float *color)
{ {
float sco[3]; float sco[3];
VECCOPY(sco, co); copy_v3_v3(sco, co);
mul_v3_fl(sco, 1.0f/tree->scale); mul_v3_fl(sco, 1.0f/tree->scale);
compute_radiance(tree, sco, color); compute_radiance(tree, sco, color);

30
source/blender/render/intern/source/strand.c
View File

@@ -98,10 +98,10 @@ void strand_eval_point(StrandSegment *sseg, StrandPoint *spoint)
t= spoint->t; t= spoint->t;
type= (strandbuf->flag & R_STRAND_BSPLINE)? KEY_BSPLINE: KEY_CARDINAL; type= (strandbuf->flag & R_STRAND_BSPLINE)? KEY_BSPLINE: KEY_CARDINAL;
VECCOPY(p[0], sseg->v[0]->co); copy_v3_v3(p[0], sseg->v[0]->co);
VECCOPY(p[1], sseg->v[1]->co); copy_v3_v3(p[1], sseg->v[1]->co);
VECCOPY(p[2], sseg->v[2]->co); copy_v3_v3(p[2], sseg->v[2]->co);
VECCOPY(p[3], sseg->v[3]->co); copy_v3_v3(p[3], sseg->v[3]->co);
if(sseg->obi->flag & R_TRANSFORMED) { if(sseg->obi->flag & R_TRANSFORMED) {
mul_m4_v3(sseg->obi->mat, p[0]); mul_m4_v3(sseg->obi->mat, p[0]);
@@ -111,7 +111,7 @@ void strand_eval_point(StrandSegment *sseg, StrandPoint *spoint)
} }
if(t == 0.0f) { if(t == 0.0f) {
VECCOPY(spoint->co, p[1]); copy_v3_v3(spoint->co, p[1]);
spoint->strandco= sseg->v[1]->strandco; spoint->strandco= sseg->v[1]->strandco;
spoint->dtstrandco= (sseg->v[2]->strandco - sseg->v[0]->strandco); spoint->dtstrandco= (sseg->v[2]->strandco - sseg->v[0]->strandco);
@@ -119,7 +119,7 @@ void strand_eval_point(StrandSegment *sseg, StrandPoint *spoint)
spoint->dtstrandco *= 0.5f; spoint->dtstrandco *= 0.5f;
} }
else if(t == 1.0f) { else if(t == 1.0f) {
VECCOPY(spoint->co, p[2]); copy_v3_v3(spoint->co, p[2]);
spoint->strandco= sseg->v[2]->strandco; spoint->strandco= sseg->v[2]->strandco;
spoint->dtstrandco= (sseg->v[3]->strandco - sseg->v[1]->strandco); spoint->dtstrandco= (sseg->v[3]->strandco - sseg->v[1]->strandco);
@@ -139,10 +139,10 @@ void strand_eval_point(StrandSegment *sseg, StrandPoint *spoint)
spoint->dtco[1]= data[0]*p[0][1] + data[1]*p[1][1] + data[2]*p[2][1] + data[3]*p[3][1]; spoint->dtco[1]= data[0]*p[0][1] + data[1]*p[1][1] + data[2]*p[2][1] + data[3]*p[3][1];
spoint->dtco[2]= data[0]*p[0][2] + data[1]*p[1][2] + data[2]*p[2][2] + data[3]*p[3][2]; spoint->dtco[2]= data[0]*p[0][2] + data[1]*p[1][2] + data[2]*p[2][2] + data[3]*p[3][2];
VECCOPY(spoint->tan, spoint->dtco); copy_v3_v3(spoint->tan, spoint->dtco);
normalize_v3(spoint->tan); normalize_v3(spoint->tan);
VECCOPY(spoint->nor, spoint->co); copy_v3_v3(spoint->nor, spoint->co);
VECMUL(spoint->nor, -1.0f); VECMUL(spoint->nor, -1.0f);
normalize_v3(spoint->nor); normalize_v3(spoint->nor);
@@ -183,7 +183,7 @@ void strand_eval_point(StrandSegment *sseg, StrandPoint *spoint)
sub_v3_v3v3(spoint->co1, spoint->co, cross); sub_v3_v3v3(spoint->co1, spoint->co, cross);
add_v3_v3v3(spoint->co2, spoint->co, cross); add_v3_v3v3(spoint->co2, spoint->co, cross);
VECCOPY(spoint->dsco, cross); copy_v3_v3(spoint->dsco, cross);
} }
/* *************** */ /* *************** */
@@ -617,10 +617,10 @@ static void do_scanconvert_strand(Render *UNUSED(re), StrandPart *spart, ZSpan *
{ {
float jco1[3], jco2[3], jco3[3], jco4[3], jx, jy; float jco1[3], jco2[3], jco3[3], jco4[3], jx, jy;
VECCOPY(jco1, co1); copy_v3_v3(jco1, co1);
VECCOPY(jco2, co2); copy_v3_v3(jco2, co2);
VECCOPY(jco3, co3); copy_v3_v3(jco3, co3);
VECCOPY(jco4, co4); copy_v3_v3(jco4, co4);
if(spart->jit) { if(spart->jit) {
jx= -spart->jit[sample][0]; jx= -spart->jit[sample][0];
@@ -1008,7 +1008,7 @@ StrandSurface *cache_strand_surface(Render *re, ObjectRen *obr, DerivedMesh *dm,
mvert= dm->getVertArray(dm); mvert= dm->getVertArray(dm);
for(a=0; a<mesh->totvert; a++, mvert++) { for(a=0; a<mesh->totvert; a++, mvert++) {
VECCOPY(co[a], mvert->co); copy_v3_v3(co[a], mvert->co);
mul_m4_v3(mat, co[a]); mul_m4_v3(mat, co[a]);
} }
@@ -1047,7 +1047,7 @@ void strand_minmax(StrandRen *strand, float *min, float *max, float width)
int a; int a;
for(a=0, svert=strand->vert; a<strand->totvert; a++, svert++) { for(a=0, svert=strand->vert; a<strand->totvert; a++, svert++) {
VECCOPY(vec, svert->co); copy_v3_v3(vec, svert->co);
DO_MINMAX(vec, min, max); DO_MINMAX(vec, min, max);
if(width!=0.0f) { if(width!=0.0f) {

88
source/blender/render/intern/source/zbuf.c
View File

@@ -444,12 +444,12 @@ static void zbuflineAc(ZSpan *zspan, int obi, int zvlnr, float *vec1, float *vec
/* all lines from left to right */ /* all lines from left to right */
if(vec1[0]<vec2[0]) { if(vec1[0]<vec2[0]) {
VECCOPY(v1, vec1); copy_v3_v3(v1, vec1);
VECCOPY(v2, vec2); copy_v3_v3(v2, vec2);
} }
else { else {
VECCOPY(v2, vec1); copy_v3_v3(v2, vec1);
VECCOPY(v1, vec2); copy_v3_v3(v1, vec2);
dx= -dx; dy= -dy; dx= -dx; dy= -dy;
} }
@@ -512,12 +512,12 @@ static void zbuflineAc(ZSpan *zspan, int obi, int zvlnr, float *vec1, float *vec
/* all lines from top to bottom */ /* all lines from top to bottom */
if(vec1[1]<vec2[1]) { if(vec1[1]<vec2[1]) {
VECCOPY(v1, vec1); copy_v3_v3(v1, vec1);
VECCOPY(v2, vec2); copy_v3_v3(v2, vec2);
} }
else { else {
VECCOPY(v2, vec1); copy_v3_v3(v2, vec1);
VECCOPY(v1, vec2); copy_v3_v3(v1, vec2);
dx= -dx; dy= -dy; dx= -dx; dy= -dy;
} }
@@ -598,12 +598,12 @@ static void zbufline(ZSpan *zspan, int obi, int zvlnr, float *vec1, float *vec2)
/* all lines from left to right */ /* all lines from left to right */
if(vec1[0]<vec2[0]) { if(vec1[0]<vec2[0]) {
VECCOPY(v1, vec1); copy_v3_v3(v1, vec1);
VECCOPY(v2, vec2); copy_v3_v3(v2, vec2);
} }
else { else {
VECCOPY(v2, vec1); copy_v3_v3(v2, vec1);
VECCOPY(v1, vec2); copy_v3_v3(v1, vec2);
dx= -dx; dy= -dy; dx= -dx; dy= -dy;
} }
@@ -656,12 +656,12 @@ static void zbufline(ZSpan *zspan, int obi, int zvlnr, float *vec1, float *vec2)
else { else {
/* all lines from top to bottom */ /* all lines from top to bottom */
if(vec1[1]<vec2[1]) { if(vec1[1]<vec2[1]) {
VECCOPY(v1, vec1); copy_v3_v3(v1, vec1);
VECCOPY(v2, vec2); copy_v3_v3(v2, vec2);
} }
else { else {
VECCOPY(v2, vec1); copy_v3_v3(v2, vec1);
VECCOPY(v1, vec2); copy_v3_v3(v1, vec2);
dx= -dx; dy= -dy; dx= -dx; dy= -dy;
} }
@@ -728,12 +728,12 @@ static void zbufline_onlyZ(ZSpan *zspan, int UNUSED(obi), int UNUSED(zvlnr), flo
/* all lines from left to right */ /* all lines from left to right */
if(vec1[0]<vec2[0]) { if(vec1[0]<vec2[0]) {
VECCOPY(v1, vec1); copy_v3_v3(v1, vec1);
VECCOPY(v2, vec2); copy_v3_v3(v2, vec2);
} }
else { else {
VECCOPY(v2, vec1); copy_v3_v3(v2, vec1);
VECCOPY(v1, vec2); copy_v3_v3(v1, vec2);
dx= -dx; dy= -dy; dx= -dx; dy= -dy;
} }
@@ -784,12 +784,12 @@ static void zbufline_onlyZ(ZSpan *zspan, int UNUSED(obi), int UNUSED(zvlnr), flo
else { else {
/* all lines from top to bottom */ /* all lines from top to bottom */
if(vec1[1]<vec2[1]) { if(vec1[1]<vec2[1]) {
VECCOPY(v1, vec1); copy_v3_v3(v1, vec1);
VECCOPY(v2, vec2); copy_v3_v3(v2, vec2);
} }
else { else {
VECCOPY(v2, vec1); copy_v3_v3(v2, vec1);
VECCOPY(v1, vec2); copy_v3_v3(v1, vec2);
dx= -dx; dy= -dy; dx= -dx; dy= -dy;
} }
@@ -925,8 +925,8 @@ void zbufclipwire(ZSpan *zspan, int obi, int zvlnr, int ec, float *ho1, float *h
else { /* clipping */ else { /* clipping */
if(ec & ME_V1V2) { if(ec & ME_V1V2) {
QUATCOPY(vez, ho1); copy_v4_v4(vez, ho1);
QUATCOPY(vez+4, ho2); copy_v4_v4(vez+4, ho2);
if( clipline(vez, vez+4)) { if( clipline(vez, vez+4)) {
hoco_to_zco(zspan, vez, vez); hoco_to_zco(zspan, vez, vez);
hoco_to_zco(zspan, vez+4, vez+4); hoco_to_zco(zspan, vez+4, vez+4);
@@ -934,8 +934,8 @@ void zbufclipwire(ZSpan *zspan, int obi, int zvlnr, int ec, float *ho1, float *h
} }
} }
if(ec & ME_V2V3) { if(ec & ME_V2V3) {
QUATCOPY(vez, ho2); copy_v4_v4(vez, ho2);
QUATCOPY(vez+4, ho3); copy_v4_v4(vez+4, ho3);
if( clipline(vez, vez+4)) { if( clipline(vez, vez+4)) {
hoco_to_zco(zspan, vez, vez); hoco_to_zco(zspan, vez, vez);
hoco_to_zco(zspan, vez+4, vez+4); hoco_to_zco(zspan, vez+4, vez+4);
@@ -944,8 +944,8 @@ void zbufclipwire(ZSpan *zspan, int obi, int zvlnr, int ec, float *ho1, float *h
} }
if(ho4) { if(ho4) {
if(ec & ME_V3V4) { if(ec & ME_V3V4) {
QUATCOPY(vez, ho3); copy_v4_v4(vez, ho3);
QUATCOPY(vez+4, ho4); copy_v4_v4(vez+4, ho4);
if( clipline(vez, vez+4)) { if( clipline(vez, vez+4)) {
hoco_to_zco(zspan, vez, vez); hoco_to_zco(zspan, vez, vez);
hoco_to_zco(zspan, vez+4, vez+4); hoco_to_zco(zspan, vez+4, vez+4);
@@ -953,8 +953,8 @@ void zbufclipwire(ZSpan *zspan, int obi, int zvlnr, int ec, float *ho1, float *h
} }
} }
if(ec & ME_V4V1) { if(ec & ME_V4V1) {
QUATCOPY(vez, ho4); copy_v4_v4(vez, ho4);
QUATCOPY(vez+4, ho1); copy_v4_v4(vez+4, ho1);
if( clipline(vez, vez+4)) { if( clipline(vez, vez+4)) {
hoco_to_zco(zspan, vez, vez); hoco_to_zco(zspan, vez, vez);
hoco_to_zco(zspan, vez+4, vez+4); hoco_to_zco(zspan, vez+4, vez+4);
@@ -964,8 +964,8 @@ void zbufclipwire(ZSpan *zspan, int obi, int zvlnr, int ec, float *ho1, float *h
} }
else { else {
if(ec & ME_V3V1) { if(ec & ME_V3V1) {
QUATCOPY(vez, ho3); copy_v4_v4(vez, ho3);
QUATCOPY(vez+4, ho1); copy_v4_v4(vez+4, ho1);
if( clipline(vez, vez+4)) { if( clipline(vez, vez+4)) {
hoco_to_zco(zspan, vez, vez); hoco_to_zco(zspan, vez, vez);
hoco_to_zco(zspan, vez+4, vez+4); hoco_to_zco(zspan, vez+4, vez+4);
@@ -1748,7 +1748,7 @@ static int zbuf_shadow_project(ZbufProjectCache *cache, int index, float winmat[
int cindex= index & 255; int cindex= index & 255;
if(cache[cindex].index == index) { if(cache[cindex].index == index) {
QUATCOPY(ho, cache[cindex].ho); copy_v4_v4(ho, cache[cindex].ho);
return cache[cindex].clip; return cache[cindex].clip;
} }
else { else {
@@ -1756,7 +1756,7 @@ static int zbuf_shadow_project(ZbufProjectCache *cache, int index, float winmat[
projectvert(co, winmat, ho); projectvert(co, winmat, ho);
clipflag= testclip(ho); clipflag= testclip(ho);
QUATCOPY(cache[cindex].ho, ho); copy_v4_v4(cache[cindex].ho, ho);
cache[cindex].clip= clipflag; cache[cindex].clip= clipflag;
cache[cindex].index= index; cache[cindex].index= index;
@@ -1778,13 +1778,13 @@ static int zbuf_part_project(ZbufProjectCache *cache, int index, float winmat[][
int cindex= index & 255; int cindex= index & 255;
if(cache[cindex].index == index) { if(cache[cindex].index == index) {
QUATCOPY(ho, cache[cindex].ho); copy_v4_v4(ho, cache[cindex].ho);
return cache[cindex].clip; return cache[cindex].clip;
} }
else { else {
float wco; float wco;
int clipflag= 0; int clipflag= 0;
VECCOPY(vec, co) copy_v3_v3(vec, co);
projectvert(co, winmat, ho); projectvert(co, winmat, ho);
wco= ho[3]; wco= ho[3];
@@ -1793,7 +1793,7 @@ static int zbuf_part_project(ZbufProjectCache *cache, int index, float winmat[][
if(ho[1] > bounds[3]*wco) clipflag |= 4; if(ho[1] > bounds[3]*wco) clipflag |= 4;
else if(ho[1] < bounds[2]*wco) clipflag |= 8; else if(ho[1] < bounds[2]*wco) clipflag |= 8;
QUATCOPY(cache[cindex].ho, ho); copy_v4_v4(cache[cindex].ho, ho);
cache[cindex].clip= clipflag; cache[cindex].clip= clipflag;
cache[cindex].index= index; cache[cindex].index= index;
@@ -1801,11 +1801,11 @@ static int zbuf_part_project(ZbufProjectCache *cache, int index, float winmat[][
} }
} }
void zbuf_render_project(float winmat[][4], float *co, float *ho) void zbuf_render_project(float winmat[][4], const float co[3], float ho[4])
{ {
float vec[3]; float vec[3];
VECCOPY(vec, co) copy_v3_v3(vec, co);
projectvert(vec, winmat, ho); projectvert(vec, winmat, ho);
} }
@@ -3348,7 +3348,7 @@ static int zbuffer_abuf(Render *re, RenderPart *pa, APixstr *APixbuf, ListBase *
mul= 0x7FFFFFFF; mul= 0x7FFFFFFF;
zval= mul*(1.0f+ho1[2]/ho1[3]); zval= mul*(1.0f+ho1[2]/ho1[3]);
VECCOPY(vec, v1->co); copy_v3_v3(vec, v1->co);
/* z is negative, otherwise its being clipped */ /* z is negative, otherwise its being clipped */
vec[2]-= ma->zoffs; vec[2]-= ma->zoffs;
projectverto(vec, obwinmat, hoco); projectverto(vec, obwinmat, hoco);
@@ -3474,7 +3474,7 @@ void add_transp_speed(RenderLayer *rl, int offset, float *speed, float alpha, in
if(fp[3]==PASS_VECTOR_MAX) fp[3]= 0.0f; if(fp[3]==PASS_VECTOR_MAX) fp[3]= 0.0f;
} }
else if(rdrect==NULL || rdrect[offset]==0 || alpha>0.95f) { else if(rdrect==NULL || rdrect[offset]==0 || alpha>0.95f) {
QUATCOPY(fp, speed); copy_v4_v4(fp, speed);
} }
else { else {
/* add minimum speed in pixel */ /* add minimum speed in pixel */
@@ -3866,7 +3866,7 @@ static int addtosamp_shr(ShadeResult *samp_shr, ShadeSample *ssamp, int addpassf
samp_shr->z= MIN2(samp_shr->z, shr->z); samp_shr->z= MIN2(samp_shr->z, shr->z);
if(addpassflag & SCE_PASS_VECTOR) { if(addpassflag & SCE_PASS_VECTOR) {
QUATCOPY(samp_shr->winspeed, shr->winspeed); copy_v4_v4(samp_shr->winspeed, shr->winspeed);
} }
/* optim... */ /* optim... */
if(addpassflag & ~(SCE_PASS_VECTOR)) { if(addpassflag & ~(SCE_PASS_VECTOR)) {

4
source/gameengine/Converter/BL_ArmatureObject.cpp
View File

@@ -162,8 +162,8 @@ void game_blend_poses(bPose *dst, bPose *src, float srcweight/*, short mode*/)
if (schan->rotmode == ROT_MODE_QUAT) { if (schan->rotmode == ROT_MODE_QUAT) {
float dquat[4], squat[4]; float dquat[4], squat[4];
QUATCOPY(dquat, dchan->quat); copy_qt_qt(dquat, dchan->quat);
QUATCOPY(squat, schan->quat); copy_qt_qt(squat, schan->quat);
if (mode==ACTSTRIPMODE_BLEND) if (mode==ACTSTRIPMODE_BLEND)
interp_qt_qtqt(dchan->quat, dquat, squat, srcweight); interp_qt_qtqt(dchan->quat, dquat, squat, srcweight);
else { else {