kannonier8/blender
1
0
Fork 0
forked from bartvdbraak/blender
Code Pull Requests 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
Show Stats 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);
copy_v3_v3(y, e1);
mul_v3_fl(y, T);
VECADD(z, w, x);
VECADD(z, z, y);
add_v3_v3v3(z, w, x);
add_v3_v3v3(z, z, y);
//sub_v3_v3v3(d, p, z);
copy_v3_v3(nearest, z);
// 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
for(i = 0; i < cloth->numfaces; i++, mfaces++)
{
VECCOPY(&co[0*3], verts[mfaces->v1].xold);
VECCOPY(&co[1*3], verts[mfaces->v2].xold);
VECCOPY(&co[2*3], verts[mfaces->v3].xold);
copy_v3_v3(&co[0*3], verts[mfaces->v1].xold);
copy_v3_v3(&co[1*3], verts[mfaces->v2].xold);
copy_v3_v3(&co[2*3], verts[mfaces->v3].xold);
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));
}
@ -267,23 +267,23 @@ void bvhtree_update_from_cloth(ClothModifierData *clmd, int moving)
{
for(i = 0; i < cloth->numfaces; i++, mfaces++)
{
VECCOPY(&co[0*3], verts[mfaces->v1].txold);
VECCOPY(&co[1*3], verts[mfaces->v2].txold);
VECCOPY(&co[2*3], verts[mfaces->v3].txold);
copy_v3_v3(&co[0*3], verts[mfaces->v1].txold);
copy_v3_v3(&co[1*3], verts[mfaces->v2].txold);
copy_v3_v3(&co[2*3], verts[mfaces->v3].txold);
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
if(moving)
{
// update moving positions
VECCOPY(&co_moving[0*3], verts[mfaces->v1].tx);
VECCOPY(&co_moving[1*3], verts[mfaces->v2].tx);
VECCOPY(&co_moving[2*3], verts[mfaces->v3].tx);
copy_v3_v3(&co_moving[0*3], verts[mfaces->v1].tx);
copy_v3_v3(&co_moving[1*3], verts[mfaces->v2].tx);
copy_v3_v3(&co_moving[2*3], verts[mfaces->v3].tx);
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));
}
@ -321,13 +321,13 @@ void bvhselftree_update_from_cloth(ClothModifierData *clmd, int moving)
{
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
if(moving)
{
// 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);
}
@ -399,11 +399,11 @@ static int do_step_cloth(Object *ob, ClothModifierData *clmd, DerivedMesh *resul
/* force any pinned verts to their constrained location. */
for(i = 0; i < clmd->clothObject->numverts; i++, verts++) {
/* save the previous position. */
VECCOPY(verts->xold, verts->xconst);
VECCOPY(verts->txold, verts->x);
copy_v3_v3(verts->xold, verts->xconst);
copy_v3_v3(verts->txold, verts->x);
/* 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);
}
@ -712,7 +712,7 @@ static void cloth_to_object (Object *ob, ClothModifierData *clmd, DerivedMesh *
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 */
}
}
@ -880,14 +880,14 @@ static int cloth_from_object(Object *ob, ClothModifierData *clmd, DerivedMesh *d
verts->goal= 0.0f;
verts->flags = 0;
VECCOPY ( verts->xold, verts->x );
VECCOPY ( verts->xconst, verts->x );
VECCOPY ( verts->txold, verts->x );
VECCOPY ( verts->tx, verts->x );
copy_v3_v3 ( verts->xold, verts->x );
copy_v3_v3 ( verts->xconst, verts->x );
copy_v3_v3 ( verts->txold, verts->x );
copy_v3_v3 ( verts->tx, verts->x );
mul_v3_fl( verts->v, 0.0f );
verts->impulse_count = 0;
VECCOPY ( verts->impulse, tnull );
copy_v3_v3 ( verts->impulse, tnull );
}
// apply / set vertex groups
@ -1053,7 +1053,6 @@ static int cloth_build_springs ( ClothModifierData *clmd, DerivedMesh *dm )
LinkNode **edgelist = NULL;
EdgeHash *edgehash = NULL;
LinkNode *search = NULL, *search2 = NULL;
float temp[3];
// error handling
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->kl = MAX2(medge[i].v2, medge[i].v1);
VECSUB ( temp, cloth->verts[spring->kl].xrest, cloth->verts[spring->ij].xrest );
spring->restlen = sqrt ( INPR ( temp, temp ) );
spring->restlen = len_v3v3(cloth->verts[spring->kl].xrest, cloth->verts[spring->ij].xrest);
clmd->sim_parms->avg_spring_len += spring->restlen;
cloth->verts[spring->ij].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->kl = MAX2(mface[i].v3, mface[i].v1);
VECSUB ( temp, cloth->verts[spring->kl].xrest, cloth->verts[spring->ij].xrest );
spring->restlen = sqrt ( INPR ( temp, temp ) );
spring->restlen = len_v3v3(cloth->verts[spring->kl].xrest, cloth->verts[spring->ij].xrest);
spring->type = CLOTH_SPRING_TYPE_SHEAR;
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->kl = MAX2(mface[i].v4, mface[i].v2);
VECSUB ( temp, cloth->verts[spring->kl].xrest, cloth->verts[spring->ij].xrest );
spring->restlen = sqrt ( INPR ( temp, temp ) );
spring->restlen = len_v3v3(cloth->verts[spring->kl].xrest, cloth->verts[spring->ij].xrest);
spring->type = CLOTH_SPRING_TYPE_SHEAR;
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->kl = MAX2(tspring2->ij, index2);
VECSUB ( temp, cloth->verts[spring->kl].xrest, cloth->verts[spring->ij].xrest );
spring->restlen = sqrt ( INPR ( temp, temp ) );
spring->restlen = len_v3v3(cloth->verts[spring->kl].xrest, cloth->verts[spring->ij].xrest);
spring->type = CLOTH_SPRING_TYPE_BENDING;
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 );
@ -1237,8 +1232,7 @@ static int cloth_build_springs ( ClothModifierData *clmd, DerivedMesh *dm )
spring->ij = tspring2->ij;
spring->kl = tspring->kl;
VECSUB ( temp, cloth->verts[spring->kl].xrest, cloth->verts[spring->ij].xrest );
spring->restlen = sqrt ( INPR ( temp, temp ) );
spring->restlen = len_v3v3(cloth->verts[spring->kl].xrest, cloth->verts[spring->ij].xrest);
spring->type = CLOTH_SPRING_TYPE_BENDING;
spring->stiffness = (cloth->verts[spring->kl].bend_stiff + cloth->verts[spring->ij].bend_stiff) / 2.0;
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;
*mapindex = index;
QUATCOPY(mapfw, fw);
copy_v4_v4(mapfw, fw);
}
} else {
/* 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
* different results across platforms */
if(cosangle > 0.999999f) {
QUATCOPY(key1->rot, key2->rot);
copy_v4_v4(key1->rot, key2->rot);
}
else {
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);
mul_v3_fl(nor,-100.0);
VECADD(co2,co1,nor);
add_v3_v3v3(co2,co1,nor);
min_d=2.0;
intersect=0;
@ -1099,11 +1099,11 @@ static int distribute_threads_init_data(ParticleThread *threads, Scene *scene, D
for(p=0; p<totvert; p++) {
if(orcodata) {
VECCOPY(co,orcodata[p])
copy_v3_v3(co,orcodata[p]);
transform_mesh_orco_verts((Mesh*)ob->data, &co, 1, 1);
}
else
VECCOPY(co,mv[p].co)
copy_v3_v3(co,mv[p].co);
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);
if(orcodata) {
VECCOPY(co1, orcodata[mf->v1]);
VECCOPY(co2, orcodata[mf->v2]);
VECCOPY(co3, orcodata[mf->v3]);
copy_v3_v3(co1, orcodata[mf->v1]);
copy_v3_v3(co2, orcodata[mf->v2]);
copy_v3_v3(co3, orcodata[mf->v3]);
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, &co3, 1, 1);
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);
}
}
@ -1156,12 +1156,12 @@ static int distribute_threads_init_data(ParticleThread *threads, Scene *scene, D
v1= (MVert*)dm->getVertData(dm,mf->v1,CD_MVERT);
v2= (MVert*)dm->getVertData(dm,mf->v2,CD_MVERT);
v3= (MVert*)dm->getVertData(dm,mf->v3,CD_MVERT);
VECCOPY(co1, v1->co);
VECCOPY(co2, v2->co);
VECCOPY(co3, v3->co);
copy_v3_v3(co1, v1->co);
copy_v3_v3(co2, v2->co);
copy_v3_v3(co3, v3->co);
if(mf->v4) {
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);
}
else {
VECCOPY(state->ave, nor);
copy_v3_v3(state->ave, nor);
}
/* calculate rotation matrix */
@ -2423,7 +2423,7 @@ static void sph_force_cb(void *sphdata_v, ParticleKey *state, float *force, floa
pfr.element_size = MAXFLOAT;
}
sphdata->element_size = pfr.element_size;
VECCOPY(sphdata->flow, pfr.flow);
copy_v3_v3(sphdata->flow, pfr.flow);
pressure = stiffness * (pfr.density - rest_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);
*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)
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 */
time=(cfra-pa->time)/pa->lifetime;
CLAMP(time, 0.0f, 1.0f);
VECCOPY(tkey.co,pa->state.co);
VECCOPY(tkey.vel,pa->state.vel);
copy_v3_v3(tkey.co,pa->state.co);
copy_v3_v3(tkey.vel,pa->state.vel);
tkey.time=pa->state.time;
if(part->type != PART_HAIR) {
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 */
sub_v3_v3v3(pa->state.vel, tkey.co, pa->prev_state.co);
mul_v3_fl(pa->state.vel,1.0f/dtime);
@ -3472,8 +3472,8 @@ static void do_hair_dynamics(ParticleSimulationData *sim)
if(k==0) {
float temp[3];
sub_v3_v3v3(temp, key->co, (key+1)->co);
VECCOPY(mvert->co, key->co);
VECADD(mvert->co, mvert->co, temp);
copy_v3_v3(mvert->co, key->co);
add_v3_v3v3(mvert->co, mvert->co, temp);
mul_m4_v3(hairmat, mvert->co);
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);
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 */
for(i=0; i < pccd_M->totvert; i++){
/* 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[1] = MIN2(pccd_M->bbmin[1],v[1]-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->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->miny = MIN2(mima->miny,v[1]-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->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->miny = MIN2(mima->miny,v[1]-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->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->miny = MIN2(mima->miny,v[1]-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);
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->miny = MIN2(mima->miny,v[1]-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 */
for(i=0; i < pccd_M->totvert; i++){
/* 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[1] = MIN2(pccd_M->bbmin[1],v[1]-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);
/* 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[1] = MIN2(pccd_M->bbmin[1],v[1]-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->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->miny = MIN2(mima->miny,v[1]-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->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->miny = MIN2(mima->miny,v[1]-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->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->miny = MIN2(mima->miny,v[1]-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);
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->miny = MIN2(mima->miny,v[1]-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->miny = MIN2(mima->miny,v[1]-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->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->miny = MIN2(mima->miny,v[1]-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->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->miny = MIN2(mima->miny,v[1]-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);
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->miny = MIN2(mima->miny,v[1]-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
if ((sb == NULL) || (sb->scratch ==NULL)) return 0;
VECCOPY(aabbmin,sb->scratch->aabbmin);
VECCOPY(aabbmax,sb->scratch->aabbmax);
copy_v3_v3(aabbmin,sb->scratch->aabbmin);
copy_v3_v3(aabbmax,sb->scratch->aabbmax);
hash = vertexowner->soft->scratch->colliderhash;
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]);
/* calculate face normal once again SIGH */
VECSUB(edge1, face_v1, face_v2);
VECSUB(edge2, face_v3, face_v2);
sub_v3_v3v3(edge1, face_v1, face_v2);
sub_v3_v3v3(edge2, face_v3, face_v2);
cross_v3_v3v3(d_nvect, edge2, edge1);
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*/
if (mvert) {
while(a){
VECCOPY(nv1,mvert[a-1].co);
copy_v3_v3(nv1,mvert[a-1].co);
if(mprevvert){
mul_v3_fl(nv1,time);
Vec3PlusStVec(nv1,(1.0f-time),mprevvert[a-1].co);
}
/* origin to face_v2*/
VECSUB(nv1, nv1, face_v2);
sub_v3_v3(nv1, face_v2);
facedist = dot_v3v3(nv1,d_nvect);
if (ABS(facedist)<outerfacethickness){
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){
VECCOPY(nv1,mvert[mface->v1].co);
VECCOPY(nv2,mvert[mface->v2].co);
VECCOPY(nv3,mvert[mface->v3].co);
copy_v3_v3(nv1,mvert[mface->v1].co);
copy_v3_v3(nv2,mvert[mface->v2].co);
copy_v3_v3(nv3,mvert[mface->v3].co);
if (mface->v4){
VECCOPY(nv4,mvert[mface->v4].co);
copy_v3_v3(nv4,mvert[mface->v4].co);
}
if (mprevvert){
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*/
VECSUB(edge1, nv1, nv2);
VECSUB(edge2, nv3, nv2);
sub_v3_v3v3(edge1, nv1, nv2);
sub_v3_v3v3(edge2, nv3, nv2);
cross_v3_v3v3(d_nvect, edge2, edge1);
normalize_v3(d_nvect);
if (
@ -1291,8 +1291,8 @@ static int sb_detect_face_collisionCached(float face_v1[3],float face_v2[3],floa
}
if (mface->v4){ /* quad */
/* switch origin to be nv4 */
VECSUB(edge1, nv3, nv4);
VECSUB(edge2, nv1, nv4);
sub_v3_v3v3(edge1, nv3, nv4);
sub_v3_v3v3(edge2, nv1, nv4);
cross_v3_v3v3(d_nvect, edge2, edge1);
normalize_v3(d_nvect);
if (
@ -1481,11 +1481,11 @@ static int sb_detect_edge_collisionCached(float edge_v1[3],float edge_v2[3],floa
if (mvert){
VECCOPY(nv1,mvert[mface->v1].co);
VECCOPY(nv2,mvert[mface->v2].co);
VECCOPY(nv3,mvert[mface->v3].co);
copy_v3_v3(nv1,mvert[mface->v1].co);
copy_v3_v3(nv2,mvert[mface->v2].co);
copy_v3_v3(nv3,mvert[mface->v3].co);
if (mface->v4){
VECCOPY(nv4,mvert[mface->v4].co);
copy_v3_v3(nv4,mvert[mface->v4].co);
}
if (mprevvert){
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*/
VECSUB(edge1, nv1, nv2);
VECSUB(edge2, nv3, nv2);
sub_v3_v3v3(edge1, nv1, nv2);
sub_v3_v3v3(edge2, nv3, nv2);
cross_v3_v3v3(d_nvect, edge2, edge1);
normalize_v3(d_nvect);
if ( isect_line_tri_v3(edge_v1, edge_v2, nv1, nv2, nv3, &t, NULL)){
float v1[3],v2[3];
float intrusiondepth,i1,i2;
VECSUB(v1, edge_v1, nv2);
VECSUB(v2, edge_v2, nv2);
sub_v3_v3v3(v1, edge_v1, nv2);
sub_v3_v3v3(v2, edge_v2, nv2);
i1 = dot_v3v3(v1,d_nvect);
i2 = dot_v3v3(v2,d_nvect);
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 */
/* switch origin to be nv4 */
VECSUB(edge1, nv3, nv4);
VECSUB(edge2, nv1, nv4);
sub_v3_v3v3(edge1, nv3, nv4);
sub_v3_v3v3(edge2, nv1, nv4);
cross_v3_v3v3(d_nvect, edge2, edge1);
normalize_v3(d_nvect);
if (isect_line_tri_v3( edge_v1, edge_v2,nv1, nv3, nv4, &t, NULL)){
float v1[3],v2[3];
float intrusiondepth,i1,i2;
VECSUB(v1, edge_v1, nv4);
VECSUB(v2, edge_v2, nv4);
sub_v3_v3v3(v1, edge_v1, nv4);
sub_v3_v3v3(v2, edge_v2, nv4);
i1 = dot_v3v3(v1,d_nvect);
i2 = dot_v3v3(v2,d_nvect);
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 */
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 = -0.0001f*f*f*sb->aeroedge;
/* (todo) add a nice angle dependant function done for now BUT */
/* 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);
VECSUB(vel,vel,pr);
sub_v3_v3(vel, pr);
normalize_v3(vel);
if (ob->softflag & OB_SB_AERO_ANGLE){
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;
}
switch (winner){
case 1: VECCOPY(w,ca); break;
case 2: VECCOPY(w,cb); break;
case 3: VECCOPY(w,cc);
case 1: copy_v3_v3(w,ca); break;
case 2: copy_v3_v3(w,cb); break;
case 3: copy_v3_v3(w,cc);
}
return(winner);
}
@ -1824,11 +1824,11 @@ static int sb_detect_vertex_collisionCached(float opco[3], float facenormal[3],
if (mvert){
VECCOPY(nv1,mvert[mface->v1].co);
VECCOPY(nv2,mvert[mface->v2].co);
VECCOPY(nv3,mvert[mface->v3].co);
copy_v3_v3(nv1,mvert[mface->v1].co);
copy_v3_v3(nv2,mvert[mface->v2].co);
copy_v3_v3(nv3,mvert[mface->v3].co);
if (mface->v4){
VECCOPY(nv4,mvert[mface->v4].co);
copy_v3_v3(nv4,mvert[mface->v4].co);
}
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
it might be a nice tradeof CPU <--> memory
*/
VECSUB(vv1,nv1,mprevvert[mface->v1].co);
VECSUB(vv2,nv2,mprevvert[mface->v2].co);
VECSUB(vv3,nv3,mprevvert[mface->v3].co);
sub_v3_v3v3(vv1,nv1,mprevvert[mface->v1].co);
sub_v3_v3v3(vv2,nv2,mprevvert[mface->v2].co);
sub_v3_v3v3(vv3,nv3,mprevvert[mface->v3].co);
if (mface->v4){
VECSUB(vv4,nv4,mprevvert[mface->v4].co);
sub_v3_v3v3(vv4,nv4,mprevvert[mface->v4].co);
}
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*/
VECSUB(edge1, nv1, nv2);
VECSUB(edge2, nv3, nv2);
VECSUB(dv1,opco,nv2); /* abuse dv1 to have vertex in question at *origin* of triangle */
sub_v3_v3v3(edge1, nv1, nv2);
sub_v3_v3v3(edge2, nv3, nv2);
sub_v3_v3v3(dv1,opco,nv2); /* abuse dv1 to have vertex in question at *origin* of triangle */
cross_v3_v3v3(d_nvect, edge2, edge1);
/* 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)){
choose_winner(ve,opco,nv1,nv2,nv3,vv1,vv2,vv3);
VECADD(avel,avel,ve);
add_v3_v3(avel, ve);
cavel ++;
}
*intrusion += facedist;
@ -1899,9 +1899,9 @@ static int sb_detect_vertex_collisionCached(float opco[3], float facenormal[3],
}
if (mface->v4){ /* quad */
/* switch origin to be nv4 */
VECSUB(edge1, nv3, nv4);
VECSUB(edge2, nv1, nv4);
VECSUB(dv1,opco,nv4); /* abuse dv1 to have vertex in question at *origin* of triangle */
sub_v3_v3v3(edge1, nv3, nv4);
sub_v3_v3v3(edge2, nv1, nv4);
sub_v3_v3v3(dv1,opco,nv4); /* abuse dv1 to have vertex in question at *origin* of triangle */
cross_v3_v3v3(d_nvect, edge2, edge1);
/* 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)){
choose_winner(ve,opco,nv1,nv3,nv4,vv1,vv3,vv4);
VECADD(avel,avel,ve);
add_v3_v3(avel, ve);
cavel ++;
}
*intrusion += facedist;
@ -1939,46 +1939,46 @@ static int sb_detect_vertex_collisionCached(float opco[3], float facenormal[3],
float dist;
closest_to_line_segment_v3(ve, opco, nv1, nv2);
VECSUB(ve,opco,ve);
sub_v3_v3v3(ve,opco,ve);
dist = normalize_v3(ve);
if ((dist < outerfacethickness)&&(dist < mindistedge )){
VECCOPY(coledge,ve);
copy_v3_v3(coledge,ve);
mindistedge = dist,
deflected=1;
}
closest_to_line_segment_v3(ve, opco, nv2, nv3);
VECSUB(ve,opco,ve);
sub_v3_v3v3(ve,opco,ve);
dist = normalize_v3(ve);
if ((dist < outerfacethickness)&&(dist < mindistedge )){
VECCOPY(coledge,ve);
copy_v3_v3(coledge,ve);
mindistedge = dist,
deflected=1;
}
closest_to_line_segment_v3(ve, opco, nv3, nv1);
VECSUB(ve,opco,ve);
sub_v3_v3v3(ve,opco,ve);
dist = normalize_v3(ve);
if ((dist < outerfacethickness)&&(dist < mindistedge )){
VECCOPY(coledge,ve);
copy_v3_v3(coledge,ve);
mindistedge = dist,
deflected=1;
}
if (mface->v4){ /* quad */
closest_to_line_segment_v3(ve, opco, nv3, nv4);
VECSUB(ve,opco,ve);
sub_v3_v3v3(ve,opco,ve);
dist = normalize_v3(ve);
if ((dist < outerfacethickness)&&(dist < mindistedge )){
VECCOPY(coledge,ve);
copy_v3_v3(coledge,ve);
mindistedge = dist,
deflected=1;
}
closest_to_line_segment_v3(ve, opco, nv1, nv4);
VECSUB(ve,opco,ve);
sub_v3_v3v3(ve,opco,ve);
dist = normalize_v3(ve);
if ((dist < outerfacethickness)&&(dist < mindistedge )){
VECCOPY(coledge,ve);
copy_v3_v3(coledge,ve);
mindistedge = dist,
deflected=1;
}
@ -2007,15 +2007,15 @@ static int sb_detect_vertex_collisionCached(float opco[3], float facenormal[3],
}
if (deflected == 2){ // face inner detected
VECADD(force,force,innerforceaccu);
add_v3_v3(force, innerforceaccu);
}
if (deflected == 3){ // face outer detected
VECADD(force,force,outerforceaccu);
add_v3_v3(force, outerforceaccu);
}
BLI_ghashIterator_free(ihash);
if (cavel) mul_v3_fl(avel,1.0f/(float)cavel);
VECCOPY(vel,avel);
copy_v3_v3(vel,avel);
if (ci) *intrusion /= ci;
if (deflected){
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];
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_collisionCachedEx(s_actpos, facenormal, cf, force , ob->lay, ob,time,vel,intrusion);
return(deflected);
@ -2286,7 +2286,7 @@ static int _softbody_calc_forces_slice_in_a_thread(Scene *scene, Object *ob, flo
/* gravitation */
if (sb && scene->physics_settings.flag & PHYS_GLOBAL_GRAVITY){
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 */
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*/
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 */
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;
}
VECSUB(cfforce,bp->vec,vel);
sub_v3_v3v3(cfforce,bp->vec,vel);
Vec3PlusStVec(bp->force,-cf*50.0f,cfforce);
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){
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);
}
@ -2711,7 +2711,7 @@ static void softbody_calc_forces(Scene *scene, Object *ob, float forcetime, floa
/* apply forcefield*/
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 */
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{
VECSUB(cfforce,bp->vec,vel);
sub_v3_v3v3(cfforce,bp->vec,vel);
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;
}
else{
VECSUB(cfforce,bp->vec,vel);
sub_v3_v3v3(cfforce,bp->vec,vel);
Vec3PlusStVec(bp->force,-cf*50.0f,cfforce);
}
Vec3PlusStVec(bp->force,kd,defforce);
@ -2876,7 +2876,7 @@ static void softbody_calc_forces(Scene *scene, Object *ob, float forcetime, floa
else{
printf("Matrix inversion failed \n");
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){
/* 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*/
/* 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 */
mul_v3_fl(bp->force,timeovermass);/* individual mass of node here */
/* some nasty if's to have heun in here too */
VECCOPY(dv,bp->force);
copy_v3_v3(dv,bp->force);
if (mode == 1){
VECCOPY(bp->prevvec, bp->vec);
VECCOPY(bp->prevdv, dv);
copy_v3_v3(bp->prevvec, bp->vec);
copy_v3_v3(bp->prevdv, dv);
}
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[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 */
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) */
/* 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 */
if (mode ==1){
VECCOPY(bp->prevpos,bp->pos);
VECCOPY(bp->prevdx ,dx);
copy_v3_v3(bp->prevpos,bp->pos);
copy_v3_v3(bp->prevdx ,dx);
}
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*/
/* so while we are looping BPs anyway do statistics on the fly */
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->scratch){
VECCOPY(sb->scratch->aabbmin,aabbmin);
VECCOPY(sb->scratch->aabbmax,aabbmax);
copy_v3_v3(sb->scratch->aabbmin,aabbmin);
copy_v3_v3(sb->scratch->aabbmax,aabbmax);
}
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;
for(a=sb->totpoint, bp= sb->bpoint; a>0; a--, bp++) {
VECCOPY(bp->vec, bp->prevvec);
VECCOPY(bp->pos, bp->prevpos);
copy_v3_v3(bp->vec, bp->prevvec);
copy_v3_v3(bp->pos, bp->prevpos);
}
}
@ -3045,8 +3045,8 @@ static void softbody_store_step(Object *ob)
int a;
for(a=sb->totpoint, bp= sb->bpoint; a>0; a--, bp++) {
VECCOPY(bp->prevvec,bp->vec);
VECCOPY(bp->prevpos,bp->pos);
copy_v3_v3(bp->prevvec,bp->vec);
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++) {
VECCOPY(pv, bp->vec);
copy_v3_v3(pv, bp->vec);
pv+=3;
VECCOPY(pp, bp->pos);
copy_v3_v3(pp, bp->pos);
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++) {
VECCOPY(bp->vec,pv);
copy_v3_v3(bp->vec,pv);
pv+=3;
VECCOPY(bp->pos,pp);
copy_v3_v3(bp->pos,pp);
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++) {
VECCOPY(temp, bp->vec);
VECCOPY(bp->vec,pv);
VECCOPY(pv,temp);
copy_v3_v3(temp, bp->vec);
copy_v3_v3(bp->vec,pv);
copy_v3_v3(pv,temp);
pv+=3;
VECCOPY(temp, bp->pos);
VECCOPY(bp->pos,pp);
VECCOPY(pp,temp);
copy_v3_v3(temp, bp->pos);
copy_v3_v3(bp->pos,pp);
copy_v3_v3(pp,temp);
pp+=3;
}
}
@ -3126,8 +3126,8 @@ static void softbody_apply_goalsnap(Object *ob)
for(a=sb->totpoint, bp= sb->bpoint; a>0; a--, bp++) {
if (_final_goal(ob,bp) >= SOFTGOALSNAP){
VECCOPY(bp->prevpos,bp->pos);
VECCOPY(bp->pos,bp->origT);
copy_v3_v3(bp->prevpos,bp->pos);
copy_v3_v3(bp->pos,bp->origT);
}
}
}
@ -3238,7 +3238,7 @@ static void springs_from_mesh(Object *ob)
if(me->totvert) {
bp= ob->soft->bpoint;
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);
}
@ -3399,12 +3399,12 @@ static void reference_to_scratch(Object *ob)
bp= ob->soft->bpoint;
rp= sb->scratch->Ref.ivert;
for(a=0; a<sb->totpoint; a++, rp++, bp++) {
VECCOPY(rp->pos,bp->pos);
VECADD(accu_pos,accu_pos,bp->pos);
copy_v3_v3(rp->pos,bp->pos);
add_v3_v3(accu_pos, bp->pos);
accu_mass += _final_mass(ob,bp);
}
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"); */
}
@ -3415,9 +3415,9 @@ when object is rescaled
static float globallen(float *v1,float *v2,Object *ob)
{
float p1[3],p2[3];
VECCOPY(p1,v1);
copy_v3_v3(p1,v1);
mul_m4_v3(ob->obmat, p1);
VECCOPY(p2,v2);
copy_v3_v3(p2,v2);
mul_m4_v3(ob->obmat, 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);
for(a=0; a<numVerts; a++, bp++) {
VECCOPY(vertexCos[a], bp->pos);
copy_v3_v3(vertexCos[a], bp->pos);
if(local==0)
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++) {
/* 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 */
VECCOPY(bp->origE, vertexCos[a]);
copy_v3_v3(bp->origE, vertexCos[a]);
/* vertexCos came from local world, go global */
mul_m4_v3(ob->obmat, bp->origE);
/* just to be save give bp->origT a defined value
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");
/* 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++) {
VECCOPY(rpos[a],rp->pos);
VECCOPY(opos[a],bp->pos);
copy_v3_v3(rpos[a],rp->pos);
copy_v3_v3(opos[a],bp->pos);
}
vcloud_estimate_transform(sb->totpoint, opos, NULL, rpos, NULL, com, rcom,lrot,lscale);
//VECSUB(com,com,rcom);
if (lloc) VECCOPY(lloc,com);
VECCOPY(sb->lcom,com);
//sub_v3_v3(com,rcom);
if (lloc) copy_v3_v3(lloc,com);
copy_v3_v3(sb->lcom,com);
if (lscale) copy_m3_m3(sb->lscale,lscale);
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;
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*/
VECCOPY(bp->origS, bp->pos);
VECCOPY(bp->origE, bp->pos);
VECCOPY(bp->origT, bp->pos);
copy_v3_v3(bp->origS, bp->pos);
copy_v3_v3(bp->origE, bp->pos);
copy_v3_v3(bp->origT, bp->pos);
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
@ -3869,10 +3869,10 @@ static void softbody_reset(Object *ob, SoftBody *sb, float (*vertexCos)[3], int
4.b yup we're done
*/
VECCOPY(bp->prevpos, bp->pos);
VECCOPY(bp->prevvec, bp->vec);
VECCOPY(bp->prevdx, bp->vec);
VECCOPY(bp->prevdv, bp->vec);
copy_v3_v3(bp->prevpos, bp->pos);
copy_v3_v3(bp->prevvec, bp->vec);
copy_v3_v3(bp->prevdx, bp->vec);
copy_v3_v3(bp->prevdv, bp->vec);
}
/* 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;
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])

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

@ -227,7 +227,7 @@ void init_mapping(TexMapping *texmap)
mul_m3_m3m3(mat, rmat, smat);
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 */
VECCOPY(p, node2->p);
copy_v3_v3(p, node2->p);
BLI_mirrorAlongAxis(p, root_node->p, nor);
/* check if it's within limit before continuing */
if (len_v3v3(node1->p, p) <= limit)
{
/* 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_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
* and free'd, regardless of version.
*/
VECCOPY(hmd->cent, hook->cent);
copy_v3_v3(hmd->cent, hook->cent);
hmd->falloff = hook->falloff;
hmd->force = hook->force;
hmd->indexar = hook->indexar;
@ -9607,7 +9607,7 @@ static void do_versions(FileData *fd, Library *lib, Main *main)
part->obfac = paf->obfac;
part->randfac = paf->randfac * 25.0f;
part->dampfac = paf->damp;
VECCOPY(part->acc, paf->force);
copy_v3_v3(part->acc, paf->force);
/* flags */
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);
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);
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;
for(a=0; a<nu->pntsu; a++, bezt++) {
VECCOPY(bezt->vec[0], data); data+=3;
VECCOPY(bezt->vec[1], data); data+=3;
VECCOPY(bezt->vec[2], data); data+=3;
copy_v3_v3(bezt->vec[0], data); data+=3;
copy_v3_v3(bezt->vec[1], data); data+=3;
copy_v3_v3(bezt->vec[2], data); data+=3;
bezt->alfa= *data; data++;
}
}
@ -10691,7 +10691,7 @@ static void do_versions(FileData *fd, Library *lib, Main *main)
BPoint *bp = nu->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++;
}
}
@ -13376,7 +13376,7 @@ static void give_base_to_groups(Main *mainvar, Scene *scene)
ob->dup_group= group;
ob->transflag |= OB_DUPLIGROUP;
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);
}
if(material->builtins & GPU_OBCOLOR) {
QUATCOPY(col, obcol);
copy_v4_v4(col, obcol);
CLAMP(col[3], 0.0f, 1.0f);
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);
if(pimd->flag & eParticleInstanceFlag_UseSize)
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);

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++)
{
float tmp[3];
VECCOPY(tmp, vertexCos[i]);
copy_v3_v3(tmp, vertexCos[i]);
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]);
VECCOPY(co, vertexCos[i]);
copy_v3_v3(co, vertexCos[i]);
//Apply axis limits
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)
return NULL;
VECCOPY(v1, vec1->vec);
VECCOPY(v2, vec2->vec);
VECCOPY(v3, vec3->vec);
copy_v3_v3(v1, vec1->vec);
copy_v3_v3(v2, vec2->vec);
copy_v3_v3(v3, vec3->vec);
VECCOPY(dir, ray->vec);
copy_v3_v3(dir, ray->vec);
normalize_v3(dir);
VECCOPY(orig, ray_off->vec);
copy_v3_v3(orig, ray_off->vec);
/* find vectors for two edges sharing v1 */
sub_v3_v3v3(e1, v2, v1);
@ -189,10 +189,10 @@ static PyObject *M_Geometry_intersect_line_line(PyObject *UNUSED(self), PyObject
int result;
if (vec1->size == 3) {
VECCOPY(v1, vec1->vec);
VECCOPY(v2, vec2->vec);
VECCOPY(v3, vec3->vec);
VECCOPY(v4, vec4->vec);
copy_v3_v3(v1, vec1->vec);
copy_v3_v3(v2, vec2->vec);
copy_v3_v3(v3, vec3->vec);
copy_v3_v3(v4, vec4->vec);
}
else {
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 */
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

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->channels==4) {
float *fp= ibuf->rect_float + 4*ofs;
QUATCOPY(col, fp);
copy_v4_v4(col, fp);
}
else if(ibuf->channels==3) {
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 */
if(shi->combinedflag & SCE_PASS_SPEC)
VECADD(shr->combined, diff, shr->spec) /* no ; */
add_v3_v3v3(shr->combined, diff, shr->spec);
else
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;
fp= rl->rectf + 4*offset;
QUATCOPY(fp, shr->combined);
copy_v4_v4(fp, shr->combined);
for(rpass= rl->passes.first; rpass; rpass= rpass->next) {
float *col= NULL, uvcol[3];
@ -695,7 +695,7 @@ static void sky_tile(RenderPart *pa, RenderLayer *rl)
}
if(pass[3]==0.0f) {
QUATCOPY(pass, col);
copy_v4_v4(pass, col);
}
else {
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) {
shade_input_set_shade_texco(shi);
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 */

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;
mul_m3_v3(lar->mat, vec);
VECADD(area[0], lar->area[0], vec);
VECADD(area[1], lar->area[1], vec);
VECADD(area[2], lar->area[2], vec);
VECADD(area[3], lar->area[3], vec);
add_v3_v3v3(area[0], lar->area[0], vec);
add_v3_v3v3(area[1], lar->area[1], vec);
add_v3_v3v3(area[2], lar->area[2], vec);
add_v3_v3v3(area[3], lar->area[3], vec);
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) {
QUATCOPY(lss->shadfac, shadfac);
copy_v4_v4(lss->shadfac, shadfac);
lss->samplenr= shi->samplenr;
}
}
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 */
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)
VECADD(shr->combined, shr->combined, shr->spec);
add_v3_v3(shr->combined, shr->spec);
/* modulate by the object color */
if((ma->shade_flag & MA_OBCOLOR) && shi->obr->ob) {
if(!(ma->sss_flag & MA_DIFF_SSS) || !sss_pass_done(&R, ma)) {
float obcol[4];
QUATCOPY(obcol, shi->obr->ob->col);
copy_v4_v4(obcol, shi->obr->ob->col);
CLAMP(obcol[3], 0.0f, 1.0f);
shr->combined[0] *= obcol[0];

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

@ -1,4 +1,4 @@
/*
/*
*
* ***** 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.backrad, tree->ss[0]->backweight);
VECCOPY(rad, result.rad);
VECADD(backrad, result.rad, result.backrad);
copy_v3_v3(rad, result.rad);
add_v3_v3v3(backrad, result.rad, result.backrad);
VECCOPY(rdsum, result.rdsum);
VECADD(backrdsum, result.rdsum, result.backrdsum);
copy_v3_v3(rdsum, result.rdsum);
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[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);
for(i=0; i<totpoint; i++) {
VECCOPY(points[i].co, co[i]);
VECCOPY(points[i].rad, color[i]);
copy_v3_v3(points[i].co, co[i]);
copy_v3_v3(points[i].rad, color[i]);
points[i].area= fabsf(area[i])/(tree->scale*tree->scale);
points[i].back= (area[i] < 0.0f);
@ -818,7 +818,7 @@ void scatter_tree_sample(ScatterTree *tree, float *co, float *color)
{
float sco[3];
VECCOPY(sco, co);
copy_v3_v3(sco, co);
mul_v3_fl(sco, 1.0f/tree->scale);
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;
type= (strandbuf->flag & R_STRAND_BSPLINE)? KEY_BSPLINE: KEY_CARDINAL;
VECCOPY(p[0], sseg->v[0]->co);
VECCOPY(p[1], sseg->v[1]->co);
VECCOPY(p[2], sseg->v[2]->co);
VECCOPY(p[3], sseg->v[3]->co);
copy_v3_v3(p[0], sseg->v[0]->co);
copy_v3_v3(p[1], sseg->v[1]->co);
copy_v3_v3(p[2], sseg->v[2]->co);
copy_v3_v3(p[3], sseg->v[3]->co);
if(sseg->obi->flag & R_TRANSFORMED) {
mul_m4_v3(sseg->obi->mat, p[0]);
@ -111,7 +111,7 @@ void strand_eval_point(StrandSegment *sseg, StrandPoint *spoint)
}
if(t == 0.0f) {
VECCOPY(spoint->co, p[1]);
copy_v3_v3(spoint->co, p[1]);
spoint->strandco= sseg->v[1]->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;
}
else if(t == 1.0f) {
VECCOPY(spoint->co, p[2]);
copy_v3_v3(spoint->co, p[2]);
spoint->strandco= sseg->v[2]->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[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);
VECCOPY(spoint->nor, spoint->co);
copy_v3_v3(spoint->nor, spoint->co);
VECMUL(spoint->nor, -1.0f);
normalize_v3(spoint->nor);
@ -183,7 +183,7 @@ void strand_eval_point(StrandSegment *sseg, StrandPoint *spoint)
sub_v3_v3v3(spoint->co1, 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;
VECCOPY(jco1, co1);
VECCOPY(jco2, co2);
VECCOPY(jco3, co3);
VECCOPY(jco4, co4);
copy_v3_v3(jco1, co1);
copy_v3_v3(jco2, co2);
copy_v3_v3(jco3, co3);
copy_v3_v3(jco4, co4);
if(spart->jit) {
jx= -spart->jit[sample][0];
@ -1008,7 +1008,7 @@ StrandSurface *cache_strand_surface(Render *re, ObjectRen *obr, DerivedMesh *dm,
mvert= dm->getVertArray(dm);
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]);
}
@ -1047,7 +1047,7 @@ void strand_minmax(StrandRen *strand, float *min, float *max, float width)
int a;
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);
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 */
if(vec1[0]<vec2[0]) {
VECCOPY(v1, vec1);
VECCOPY(v2, vec2);
copy_v3_v3(v1, vec1);
copy_v3_v3(v2, vec2);
}
else {
VECCOPY(v2, vec1);
VECCOPY(v1, vec2);
copy_v3_v3(v2, vec1);
copy_v3_v3(v1, vec2);
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 */
if(vec1[1]<vec2[1]) {
VECCOPY(v1, vec1);
VECCOPY(v2, vec2);
copy_v3_v3(v1, vec1);
copy_v3_v3(v2, vec2);
}
else {
VECCOPY(v2, vec1);
VECCOPY(v1, vec2);
copy_v3_v3(v2, vec1);
copy_v3_v3(v1, vec2);
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 */
if(vec1[0]<vec2[0]) {
VECCOPY(v1, vec1);
VECCOPY(v2, vec2);
copy_v3_v3(v1, vec1);
copy_v3_v3(v2, vec2);
}
else {
VECCOPY(v2, vec1);
VECCOPY(v1, vec2);
copy_v3_v3(v2, vec1);
copy_v3_v3(v1, vec2);
dx= -dx; dy= -dy;
}
@ -656,12 +656,12 @@ static void zbufline(ZSpan *zspan, int obi, int zvlnr, float *vec1, float *vec2)
else {
/* all lines from top to bottom */
if(vec1[1]<vec2[1]) {
VECCOPY(v1, vec1);
VECCOPY(v2, vec2);
copy_v3_v3(v1, vec1);
copy_v3_v3(v2, vec2);
}
else {
VECCOPY(v2, vec1);
VECCOPY(v1, vec2);
copy_v3_v3(v2, vec1);
copy_v3_v3(v1, vec2);
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 */
if(vec1[0]<vec2[0]) {
VECCOPY(v1, vec1);
VECCOPY(v2, vec2);
copy_v3_v3(v1, vec1);
copy_v3_v3(v2, vec2);
}
else {
VECCOPY(v2, vec1);
VECCOPY(v1, vec2);
copy_v3_v3(v2, vec1);
copy_v3_v3(v1, vec2);
dx= -dx; dy= -dy;
}
@ -784,12 +784,12 @@ static void zbufline_onlyZ(ZSpan *zspan, int UNUSED(obi), int UNUSED(zvlnr), flo
else {
/* all lines from top to bottom */
if(vec1[1]<vec2[1]) {
VECCOPY(v1, vec1);
VECCOPY(v2, vec2);
copy_v3_v3(v1, vec1);
copy_v3_v3(v2, vec2);
}
else {
VECCOPY(v2, vec1);
VECCOPY(v1, vec2);
copy_v3_v3(v2, vec1);
copy_v3_v3(v1, vec2);
dx= -dx; dy= -dy;
}
@ -925,8 +925,8 @@ void zbufclipwire(ZSpan *zspan, int obi, int zvlnr, int ec, float *ho1, float *h
else { /* clipping */
if(ec & ME_V1V2) {
QUATCOPY(vez, ho1);
QUATCOPY(vez+4, ho2);
copy_v4_v4(vez, ho1);
copy_v4_v4(vez+4, ho2);
if( clipline(vez, vez+4)) {
hoco_to_zco(zspan, vez, vez);
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) {
QUATCOPY(vez, ho2);
QUATCOPY(vez+4, ho3);
copy_v4_v4(vez, ho2);
copy_v4_v4(vez+4, ho3);
if( clipline(vez, vez+4)) {
hoco_to_zco(zspan, vez, vez);
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(ec & ME_V3V4) {
QUATCOPY(vez, ho3);
QUATCOPY(vez+4, ho4);
copy_v4_v4(vez, ho3);
copy_v4_v4(vez+4, ho4);
if( clipline(vez, vez+4)) {
hoco_to_zco(zspan, vez, vez);
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) {
QUATCOPY(vez, ho4);
QUATCOPY(vez+4, ho1);
copy_v4_v4(vez, ho4);
copy_v4_v4(vez+4, ho1);
if( clipline(vez, vez+4)) {
hoco_to_zco(zspan, vez, vez);
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 {
if(ec & ME_V3V1) {
QUATCOPY(vez, ho3);
QUATCOPY(vez+4, ho1);
copy_v4_v4(vez, ho3);
copy_v4_v4(vez+4, ho1);
if( clipline(vez, vez+4)) {
hoco_to_zco(zspan, vez, vez);
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;
if(cache[cindex].index == index) {
QUATCOPY(ho, cache[cindex].ho);
copy_v4_v4(ho, cache[cindex].ho);
return cache[cindex].clip;
}
else {
@ -1756,7 +1756,7 @@ static int zbuf_shadow_project(ZbufProjectCache *cache, int index, float winmat[
projectvert(co, winmat, ho);
clipflag= testclip(ho);
QUATCOPY(cache[cindex].ho, ho);
copy_v4_v4(cache[cindex].ho, ho);
cache[cindex].clip= clipflag;
cache[cindex].index= index;
@ -1778,13 +1778,13 @@ static int zbuf_part_project(ZbufProjectCache *cache, int index, float winmat[][
int cindex= index & 255;
if(cache[cindex].index == index) {
QUATCOPY(ho, cache[cindex].ho);
copy_v4_v4(ho, cache[cindex].ho);
return cache[cindex].clip;
}
else {
float wco;
int clipflag= 0;
VECCOPY(vec, co)
copy_v3_v3(vec, co);
projectvert(co, winmat, ho);
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;
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].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];
VECCOPY(vec, co)
copy_v3_v3(vec, co);
projectvert(vec, winmat, ho);
}
@ -3348,7 +3348,7 @@ static int zbuffer_abuf(Render *re, RenderPart *pa, APixstr *APixbuf, ListBase *
mul= 0x7FFFFFFF;
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 */
vec[2]-= ma->zoffs;
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;
}
else if(rdrect==NULL || rdrect[offset]==0 || alpha>0.95f) {
QUATCOPY(fp, speed);
copy_v4_v4(fp, speed);
}
else {
/* 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);
if(addpassflag & SCE_PASS_VECTOR) {
QUATCOPY(samp_shr->winspeed, shr->winspeed);
copy_v4_v4(samp_shr->winspeed, shr->winspeed);
}
/* optim... */
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) {
float dquat[4], squat[4];
QUATCOPY(dquat, dchan->quat);
QUATCOPY(squat, schan->quat);
copy_qt_qt(dquat, dchan->quat);
copy_qt_qt(squat, schan->quat);
if (mode==ACTSTRIPMODE_BLEND)
interp_qt_qtqt(dchan->quat, dquat, squat, srcweight);
else {