pre-merge commit. the mirror modifier is currently in pieces, to be picked back up after the merge. there should be some removedoubles fixes, along with some other assorted fixes.

6 files changed, 219 insertions, 21 deletions

diff --git a/source/blender/blenkernel/intern/BME_conversions.c b/source/blender/blenkernel/intern/BME_conversions.c
index dcfe4e6fa36..0f372790a9d 100644
--- a/source/blender/blenkernel/intern/BME_conversions.c
+++ b/source/blender/blenkernel/intern/BME_conversions.c
@@ -268,7 +268,7 @@ BME_Mesh *BME_editmesh_to_bmesh(EditMesh *em) {
 	CustomData_copy(&em->fdata, &bm->pdata, CD_MASK_BMESH, CD_CALLOC, 0);
 
 	/*copy face corner data*/
-	CustomData_to_bmeshpoly(&em->fdata, &bm->pdata, &bm->ldata);
+	CustomData_to_bmeshpoly(&em->fdata, &bm->pdata, &bm->ldata, 0, 0);
 	/*initialize memory pools*/
 	CustomData_bmesh_init_pool(&bm->vdata, allocsize[0]);
 	CustomData_bmesh_init_pool(&bm->edata, allocsize[1]);
@@ -463,7 +463,7 @@ BME_Mesh *BME_derivedmesh_to_bmesh(DerivedMesh *dm)
 	CustomData_copy(&dm->faceData, &bm->pdata, CD_MASK_BMESH, CD_CALLOC, 0);
 
 	/*copy face corner data*/
-	CustomData_to_bmeshpoly(&dm->faceData, &bm->pdata, &bm->ldata);
+	CustomData_to_bmeshpoly(&dm->faceData, &bm->pdata, &bm->ldata, 0, 0);
 	/*initialize memory pools*/
 	CustomData_bmesh_init_pool(&bm->vdata, allocsize[0]);
 	CustomData_bmesh_init_pool(&bm->edata, allocsize[1]);
diff --git a/source/blender/blenkernel/intern/customdata.c b/source/blender/blenkernel/intern/customdata.c
index 5c29ca02e7e..0173e660e18 100644
--- a/source/blender/blenkernel/intern/customdata.c
+++ b/source/blender/blenkernel/intern/customdata.c
@@ -1835,16 +1835,17 @@ void CustomData_from_em_block(const CustomData *source, CustomData *dest,
 
 /*Bmesh functions*/
 /*needed to convert to/from different face reps*/
-void CustomData_to_bmeshpoly(CustomData *fdata, CustomData *pdata, CustomData *ldata)
+void CustomData_to_bmeshpoly(CustomData *fdata, CustomData *pdata, CustomData *ldata,
+			     int totloop, int totpoly)
 {
 	int i;
 	for(i=0; i < fdata->totlayer; i++){
 		if(fdata->layers[i].type == CD_MTFACE){
-			CustomData_add_layer(pdata, CD_MTEXPOLY, CD_CALLOC, &(fdata->layers[i].name), 0);
-			CustomData_add_layer(ldata, CD_MLOOPUV, CD_CALLOC, &(fdata->layers[i].name), 0);
+			CustomData_add_layer(pdata, CD_MTEXPOLY, CD_CALLOC, &(fdata->layers[i].name), totpoly);
+			CustomData_add_layer(ldata, CD_MLOOPUV, CD_CALLOC, &(fdata->layers[i].name), totloop);
 		}
 		else if(fdata->layers[i].type == CD_MCOL)
-			CustomData_add_layer(ldata, CD_MLOOPCOL, CD_CALLOC, &(fdata->layers[i].name), 0);
+			CustomData_add_layer(ldata, CD_MLOOPCOL, CD_CALLOC, &(fdata->layers[i].name), totloop);
 	}		
 }
 void CustomData_from_bmeshpoly(CustomData *fdata, CustomData *pdata, CustomData *ldata, int total){
diff --git a/source/blender/blenkernel/intern/editderivedbmesh.c b/source/blender/blenkernel/intern/editderivedbmesh.c
index 2964914de4b..fa9747ec54f 100644
--- a/source/blender/blenkernel/intern/editderivedbmesh.c
+++ b/source/blender/blenkernel/intern/editderivedbmesh.c
@@ -310,9 +310,17 @@ static void bmdm_recalc_lookups(EditDerivedBMesh *bmdm)
 	if (bmdm->etable) MEM_freeN(bmdm->etable);
 	if (bmdm->ftable) MEM_freeN(bmdm->ftable);
 	
-	bmdm->vtable = MEM_mallocN(sizeof(void**)*bmdm->tc->bm->totvert, "bmdm->vtable");
-	bmdm->etable = MEM_mallocN(sizeof(void**)*bmdm->tc->bm->totedge, "bmdm->etable");
-	bmdm->ftable = MEM_mallocN(sizeof(void**)*bmdm->tc->bm->totface, "bmdm->ftable");
+	if (bmdm->tc->bm->totvert)
+		bmdm->vtable = MEM_mallocN(sizeof(void**)*bmdm->tc->bm->totvert, "bmdm->vtable");
+	else bmdm->vtable = NULL;
+
+	if (bmdm->tc->bm->totedge)
+		bmdm->etable = MEM_mallocN(sizeof(void**)*bmdm->tc->bm->totedge, "bmdm->etable");
+	else bmdm->etable = NULL;
+	
+	if (bmdm->tc->bm->totface)
+		bmdm->ftable = MEM_mallocN(sizeof(void**)*bmdm->tc->bm->totface, "bmdm->ftable");
+	else bmdm->ftable = NULL;
 	
 	for (a=0; a<3; a++) {
 		h = BMIter_New(&iter, bmdm->tc->bm, iters[a], NULL);
@@ -340,7 +348,6 @@ static void bmDM_recalcTesselation(DerivedMesh *dm)
 {
 	EditDerivedBMesh *bmdm= (EditDerivedBMesh*) dm;
 
-	BMEdit_RecalcTesselation_intern(bmdm->tc);
 	bmdm_recalc_lookups(bmdm);
 }
 
@@ -1403,6 +1410,14 @@ static void bmDM_release(void *dm)
 			MEM_freeN(bmdm->faceNos);
 		}
 		
+		BLI_ghash_free(bmdm->fhash, NULL, NULL);
+		BLI_ghash_free(bmdm->ehash, NULL, NULL);
+		BLI_ghash_free(bmdm->vhash, NULL, NULL);
+
+		if (bmdm->vtable) MEM_freeN(bmdm->vtable);
+		if (bmdm->etable) MEM_freeN(bmdm->etable);
+		if (bmdm->ftable) MEM_freeN(bmdm->ftable);
+		
 		MEM_freeN(bmdm);
 	}
 }
diff --git a/source/blender/blenkernel/intern/modifier.c b/source/blender/blenkernel/intern/modifier.c
index 879699e755a..4e1f6d8265a 100644
--- a/source/blender/blenkernel/intern/modifier.c
+++ b/source/blender/blenkernel/intern/modifier.c
@@ -1826,6 +1826,7 @@ void vertgroup_flip_name (char *name, int strip_number)
 	sprintf (name, "%s%s%s%s", prefix, replace, suffix, number);
 }
 
+#if 0
 static DerivedMesh *doMirrorOnAxis(MirrorModifierData *mmd,
 		Object *ob,
 		DerivedMesh *dm,
@@ -2047,6 +2048,7 @@ static DerivedMesh *doMirrorOnAxis(MirrorModifierData *mmd,
 
 	return result;
 }
+#endif
 
 static DerivedMesh *mirrorModifier__doMirror(MirrorModifierData *mmd,
 					    Object *ob, DerivedMesh *dm,
diff --git a/source/blender/blenkernel/intern/modifiers_bmesh.c b/source/blender/blenkernel/intern/modifiers_bmesh.c
index d52f624a91b..b3ce91855b2 100644
--- a/source/blender/blenkernel/intern/modifiers_bmesh.c
+++ b/source/blender/blenkernel/intern/modifiers_bmesh.c
@@ -220,14 +220,53 @@ BMEditMesh *CDDM_To_BMesh(DerivedMesh *dm, BMEditMesh *existing)
 
 float vertarray_size(MVert *mvert, int numVerts, int axis);
 
+
+typedef struct IndexMapEntry {
+	/* the new vert index that this old vert index maps to */
+	int new;
+	/* -1 if this vert isn't merged, otherwise the old vert index it
+	* should be replaced with
+	*/
+	int merge;
+	/* 1 if this vert's first copy is merged with the last copy of its
+	* merge target, otherwise 0
+	*/
+	short merge_final;
+} IndexMapEntry;
+
+/* indexMap - an array of IndexMap entries
+ * oldIndex - the old index to map
+ * copyNum - the copy number to map to (original = 0, first copy = 1, etc.)
+ */
+static int calc_mapping(IndexMapEntry *indexMap, int oldIndex, int copyNum)
+{
+	if(indexMap[oldIndex].merge < 0) {
+		/* vert wasn't merged, so use copy of this vert */
+		return indexMap[oldIndex].new + copyNum;
+	} else if(indexMap[oldIndex].merge == oldIndex) {
+		/* vert was merged with itself */
+		return indexMap[oldIndex].new;
+	} else {
+		/* vert was merged with another vert */
+		/* follow the chain of merges to the end, or until we've passed
+		* a number of vertices equal to the copy number
+		*/
+		if(copyNum <= 0)
+			return indexMap[oldIndex].new;
+		else
+			return calc_mapping(indexMap, indexMap[oldIndex].merge,
+					    copyNum - 1);
+	}
+}
+
 static DerivedMesh *arrayModifier_doArray(ArrayModifierData *amd,
 					  Scene *scene, Object *ob, DerivedMesh *dm,
                                           int initFlags)
 {
 	DerivedMesh *cddm = CDDM_copy(dm);
 	BMEditMesh *em = CDDM_To_BMesh(cddm, NULL);
-	BMOperator op, oldop;
-	int i, j;
+	BMOperator op, oldop, weldop;
+	int i, j, indexLen;
 	/* offset matrix */
 	float offset[4][4];
 	float final_offset[4][4];
@@ -237,6 +276,7 @@ static DerivedMesh *arrayModifier_doArray(ArrayModifierData *amd,
 	int numVerts, numEdges, numFaces;
 	int maxVerts, maxEdges, maxFaces;
 	int finalVerts, finalEdges, finalFaces;
+	int *indexMap;
 	DerivedMesh *result, *start_cap = NULL, *end_cap = NULL;
 	MVert *src_mvert;
 
@@ -316,16 +356,16 @@ static DerivedMesh *arrayModifier_doArray(ArrayModifierData *amd,
 	*/
 	finalVerts = dm->getNumVerts(dm) * count;
 	finalEdges = dm->getNumEdges(dm) * count;
-	finalFaces = dm->getNumTessFaces(dm) * count;
+	finalFaces = dm->getNumFaces(dm) * count;
 	if(start_cap) {
 		finalVerts += start_cap->getNumVerts(start_cap);
 		finalEdges += start_cap->getNumEdges(start_cap);
-		finalFaces += start_cap->getNumTessFaces(start_cap);
+		finalFaces += start_cap->getNumFaces(start_cap);
 	}
 	if(end_cap) {
 		finalVerts += end_cap->getNumVerts(end_cap);
 		finalEdges += end_cap->getNumEdges(end_cap);
-		finalFaces += end_cap->getNumTessFaces(end_cap);
+		finalFaces += end_cap->getNumFaces(end_cap);
 	}
 
 	/* calculate the offset matrix of the final copy (for merging) */ 
@@ -336,31 +376,103 @@ static DerivedMesh *arrayModifier_doArray(ArrayModifierData *amd,
 		MTC_Mat4CpyMat4(final_offset, tmp_mat);
 	}
 
-
 	cddm->needsFree = 1;
 	cddm->release(cddm);
 	
+	BMO_Init_Op(&weldop, "weldverts");
 	BMO_InitOpf(em->bm, &op, "dupe geom=%avef");
 	oldop = op;
 	for (j=0; j < count; j++) {
+		BMVert *v, *v2;
+		BMOpSlot *s1;
+		BMOpSlot *s2;
+
 		BMO_InitOpf(em->bm, &op, "dupe geom=%s", &oldop, j==0 ? "geom" : "newout");
 		BMO_Exec_Op(em->bm, &op);
 
-		BMO_Finish_Op(em->bm, &oldop);
-		oldop = op;
+		s1 = BMO_GetSlot(&op, "geom");
+		s2 = BMO_GetSlot(&op, "newout");
 
 		BMO_CallOpf(em->bm, "transform mat=%m4 verts=%s", offset, &op, "newout");
 
+		#define _E(s, i) ((BMVert**)(s)->data.buf)[i]
+
+		/*calculate merge mapping*/
+		if (j == 0) {
+			BMOperator findop;
+			BMOIter oiter;
+			BMIter iter;
+			BMVert *v, *v2;
+			BMHeader *h;
+
+			BMO_InitOpf(em->bm, &findop, 
+				"finddoubles verts=%av dist=%f keepverts=%s", 
+				amd->merge_dist, &op, "geom");
+
+			i = 0;
+			BMO_ITER(h, &oiter, em->bm, &op, "geom", BM_ALL) {
+				BMINDEX_SET(h, i);
+				i++;
+			}
+
+			BMO_ITER(h, &oiter, em->bm, &op, "newout", BM_ALL) {
+				BMINDEX_SET(h, i);
+				i++;
+			}
+
+			BMO_Exec_Op(em->bm, &findop);
+
+			indexLen = i;
+			indexMap = MEM_callocN(sizeof(int)*indexLen, "indexMap");
+
+			/*element type argument doesn't do anything here*/
+			BMO_ITER(v, &oiter, em->bm, &findop, "targetmapout", 0) {
+				v2 = BMO_IterMapValp(&oiter);
+
+				/*make sure merge pairs are duplicate-to-duplicate*/
+				/*if (BMINDEX_GET(v) >= s1->len && BMINDEX_GET(v2) >= s1->len) 
+					continue;
+				else if (BMINDEX_GET(v) < s1->len && BMINDEX_GET(v2) < s1->len) 
+					continue;*/
+
+				indexMap[BMINDEX_GET(v)] = BMINDEX_GET(v2)+1;
+			}
+
+			BMO_Finish_Op(em->bm, &findop);
+		} 
+
+		/*generate merge mappping using index map.  we do this by using the
+		  operator slots as lookup arrays.*/
+		#define E(i) (i) < s1->len ? _E(s1, i) : _E(s2, (i)-s1->len)
+
+		for (i=0; i<indexLen; i++) {
+			if (!indexMap[i]) continue;
+
+			v = E(i);
+			v2 = E(indexMap[i]-1);
+
+			BMO_Insert_MapPointer(em->bm, &weldop, "targetmap", v, v2);
+		}
+
+		#undef E
+		#undef _E
+
+		BMO_Finish_Op(em->bm, &oldop);
+		oldop = op;
 	}
 
 	if (j > 0) BMO_Finish_Op(em->bm, &op);
 
-	BMO_CallOpf(em->bm, "removedoubles verts=%av dist=%f", amd->merge_dist);
+	BMO_Exec_Op(em->bm, &weldop);
+	BMO_Finish_Op(em->bm, &weldop);
+
+	//BMO_CallOpf(em->bm, "removedoubles verts=%av dist=%f", amd->merge_dist);
 
 	BMEdit_RecalcTesselation(em);
 	cddm = CDDM_from_BMEditMesh(em, NULL);
 
 	BMEdit_Free(em);
+	MEM_freeN(indexMap);
 
 	return cddm;
 }
@@ -385,4 +497,72 @@ DerivedMesh *arrayModifier_applyModifierEM(ModifierData *md, Object *ob,
                                            DerivedMesh *derivedData)
 {
 	return arrayModifier_applyModifier(md, ob, derivedData, 0, 1);
-}
\ No newline at end of file
+}
+
+/* Mirror */
+
+DerivedMesh *doMirrorOnAxis(MirrorModifierData *mmd,
+		Object *ob,
+		DerivedMesh *dm,
+		int initFlags,
+		int axis)
+{
+	int i;
+	float tolerance = mmd->tolerance;
+	DerivedMesh *result, *cddm;
+	BMEditMesh *em;
+	BMesh *bm;
+	int numVerts, numEdges, numFaces;
+	int maxVerts = dm->getNumVerts(dm);
+	int maxEdges = dm->getNumEdges(dm);
+	int maxFaces = dm->getNumTessFaces(dm);
+	int vector_size=0, j, a, b;
+	bDeformGroup *def, *defb;
+	bDeformGroup **vector_def = NULL;
+	int (*indexMap)[2];
+	float mtx[4][4], imtx[4][4];
+
+	cddm = CDDM_copy(dm);
+	em = CDDM_To_BMesh(dm, NULL);
+
+	cddm->needsFree = 1;
+	cddm->release(cddm);
+	
+	/*convienence variable*/
+	bm = em->bm;
+
+	numVerts = numEdges = numFaces = 0;
+	indexMap = MEM_mallocN(sizeof(*indexMap) * maxVerts, "indexmap");
+	result = CDDM_from_template(dm, maxVerts * 2, maxEdges * 2, maxFaces * 2, 0, 0);
+
+	if (mmd->flag & MOD_MIR_VGROUP) {
+		/* calculate the number of deformedGroups */
+		for(vector_size = 0, def = ob->defbase.first; def;
+		    def = def->next, vector_size++);
+
+		/* load the deformedGroups for fast access */
+		vector_def =
+		    (bDeformGroup **)MEM_mallocN(sizeof(bDeformGroup*) * vector_size,
+		                                 "group_index");
+		for(a = 0, def = ob->defbase.first; def; def = def->next, a++) {
+			vector_def[a] = def;
+		}
+	}
+
+	if (mmd->mirror_ob) {
+		float obinv[4][4];
+		
+		Mat4Invert(obinv, mmd->mirror_ob->obmat);
+		Mat4MulMat4(mtx, ob->obmat, obinv);
+		Mat4Invert(imtx, mtx);
+	}
+
+
+
+	BMEdit_RecalcTesselation(em);
+	result = CDDM_from_BMEditMesh(em, NULL);
+
+	BMEdit_Free(em);
+
+	return result;
+}
diff --git a/source/blender/blenkernel/intern/object.c b/source/blender/blenkernel/intern/object.c
index a5ac6a7ca6c..c45a1593b8a 100644
--- a/source/blender/blenkernel/intern/object.c
+++ b/source/blender/blenkernel/intern/object.c
@@ -864,7 +864,7 @@ void free_lamp(Lamp *la)
 	
 	BKE_free_animdata((ID *)la);
 
-	curvemapping_free(la->curfalloff);
+	curvemapping_free(la->curfalloff); 
 	
 	BKE_previewimg_free(&la->preview);
 	BKE_icon_delete(&la->id);