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

22 files changed, 298 insertions, 304 deletions

diff --git a/source/blender/blenkernel/intern/bvhutils.c b/source/blender/blenkernel/intern/bvhutils.c
index 93abad8858f..1a27a640797 100644
--- a/source/blender/blenkernel/intern/bvhutils.c
+++ b/source/blender/blenkernel/intern/bvhutils.c
@@ -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 );
diff --git a/source/blender/blenkernel/intern/cloth.c b/source/blender/blenkernel/intern/cloth.c
index f917a0fe68c..ae6a6ec012a 100644
--- a/source/blender/blenkernel/intern/cloth.c
+++ b/source/blender/blenkernel/intern/cloth.c
@@ -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++;
diff --git a/source/blender/blenkernel/intern/particle.c b/source/blender/blenkernel/intern/particle.c
index 3b6fc09ad4f..56e4c91ba5e 100644
--- a/source/blender/blenkernel/intern/particle.c
+++ b/source/blender/blenkernel/intern/particle.c
@@ -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);
diff --git a/source/blender/blenkernel/intern/particle_system.c b/source/blender/blenkernel/intern/particle_system.c
index f92fb4444cc..3e88fb7d65e 100644
--- a/source/blender/blenkernel/intern/particle_system.c
+++ b/source/blender/blenkernel/intern/particle_system.c
@@ -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++;
 			
diff --git a/source/blender/blenkernel/intern/softbody.c b/source/blender/blenkernel/intern/softbody.c
index accf3e442e8..5b02731050e 100644
--- a/source/blender/blenkernel/intern/softbody.c
+++ b/source/blender/blenkernel/intern/softbody.c
@@ -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 */
diff --git a/source/blender/blenkernel/intern/subsurf_ccg.c b/source/blender/blenkernel/intern/subsurf_ccg.c
index 986e0e2b552..9848b27d32e 100644
--- a/source/blender/blenkernel/intern/subsurf_ccg.c
+++ b/source/blender/blenkernel/intern/subsurf_ccg.c
@@ -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])
diff --git a/source/blender/blenkernel/intern/texture.c b/source/blender/blenkernel/intern/texture.c
index d3bd7d7b766..3aa289d0ef8 100644
--- a/source/blender/blenkernel/intern/texture.c
+++ b/source/blender/blenkernel/intern/texture.c
@@ -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);
 
 }
 
diff --git a/source/blender/blenlib/intern/graph.c b/source/blender/blenlib/intern/graph.c
index 6dd278ed777..d0d3d0e137e 100644
--- a/source/blender/blenlib/intern/graph.c
+++ b/source/blender/blenlib/intern/graph.c
@@ -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;
 
diff --git a/source/blender/blenloader/intern/readfile.c b/source/blender/blenloader/intern/readfile.c
index e17f8c720a5..3a03a11b849 100644
--- a/source/blender/blenloader/intern/readfile.c
+++ b/source/blender/blenloader/intern/readfile.c
@@ -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);
 		}
 	}
 }
diff --git a/source/blender/gpu/intern/gpu_material.c b/source/blender/gpu/intern/gpu_material.c
index 26c08f6cae5..a438d5c86e9 100644
--- a/source/blender/gpu/intern/gpu_material.c
+++ b/source/blender/gpu/intern/gpu_material.c
@@ -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);
 		}
diff --git a/source/blender/modifiers/intern/MOD_particleinstance.c b/source/blender/modifiers/intern/MOD_particleinstance.c
index f93e0469686..509c916941f 100644
--- a/source/blender/modifiers/intern/MOD_particleinstance.c
+++ b/source/blender/modifiers/intern/MOD_particleinstance.c
@@ -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);
diff --git a/source/blender/modifiers/intern/MOD_simpledeform.c b/source/blender/modifiers/intern/MOD_simpledeform.c
index 4609ee221a4..2c056ad4021 100644
--- a/source/blender/modifiers/intern/MOD_simpledeform.c
+++ b/source/blender/modifiers/intern/MOD_simpledeform.c
@@ -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
diff --git a/source/blender/python/mathutils/mathutils_geometry.c b/source/blender/python/mathutils/mathutils_geometry.c
index e8721a3a91d..3518c8008c6 100644
--- a/source/blender/python/mathutils/mathutils_geometry.c
+++ b/source/blender/python/mathutils/mathutils_geometry.c
@@ -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];
diff --git a/source/blender/render/intern/include/zbuf.h b/source/blender/render/intern/include/zbuf.h
index 6567cdacf0e..c467c31b5a6 100644
--- a/source/blender/render/intern/include/zbuf.h
+++ b/source/blender/render/intern/include/zbuf.h
@@ -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
 
diff --git a/source/blender/render/intern/source/imagetexture.c b/source/blender/render/intern/source/imagetexture.c
index 719b9674b80..1887f22198d 100644
--- a/source/blender/render/intern/source/imagetexture.c
+++ b/source/blender/render/intern/source/imagetexture.c
@@ -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;
diff --git a/source/blender/render/intern/source/rayshade.c b/source/blender/render/intern/source/rayshade.c
index a02c5681e5e..1a58a665e0a 100644
--- a/source/blender/render/intern/source/rayshade.c
+++ b/source/blender/render/intern/source/rayshade.c
@@ -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);
 }
diff --git a/source/blender/render/intern/source/rendercore.c b/source/blender/render/intern/source/rendercore.c
index d2683f26c3a..48134c46c61 100644
--- a/source/blender/render/intern/source/rendercore.c
+++ b/source/blender/render/intern/source/rendercore.c
@@ -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 */
diff --git a/source/blender/render/intern/source/shadeoutput.c b/source/blender/render/intern/source/shadeoutput.c
index ddfe3199d30..0ed3a094cf8 100644
--- a/source/blender/render/intern/source/shadeoutput.c
+++ b/source/blender/render/intern/source/shadeoutput.c
@@ -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];
diff --git a/source/blender/render/intern/source/sss.c b/source/blender/render/intern/source/sss.c
index cf97a63d8a0..4192aaf42aa 100644
--- a/source/blender/render/intern/source/sss.c
+++ b/source/blender/render/intern/source/sss.c
@@ -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);
diff --git a/source/blender/render/intern/source/strand.c b/source/blender/render/intern/source/strand.c
index ed12c08c193..ddcffcc303b 100644
--- a/source/blender/render/intern/source/strand.c
+++ b/source/blender/render/intern/source/strand.c
@@ -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) {
diff --git a/source/blender/render/intern/source/zbuf.c b/source/blender/render/intern/source/zbuf.c
index 7a8779ee969..8b383992e65 100644
--- a/source/blender/render/intern/source/zbuf.c
+++ b/source/blender/render/intern/source/zbuf.c
@@ -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)) {
diff --git a/source/gameengine/Converter/BL_ArmatureObject.cpp b/source/gameengine/Converter/BL_ArmatureObject.cpp
index 836cfab6b49..5a44e1022ff 100644
--- a/source/gameengine/Converter/BL_ArmatureObject.cpp
+++ b/source/gameengine/Converter/BL_ArmatureObject.cpp
@@ -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 {