blender-archive/source/blender/editors/mesh/mesh_data.c

/*
 * ***** BEGIN GPL LICENSE BLOCK *****
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation; either version 2
 * of the License, or (at your option) any later version. 
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software Foundation,
 * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
 *
 * The Original Code is Copyright (C) 2009 Blender Foundation.
 * All rights reserved.
 *
 * 
 * Contributor(s): Blender Foundation
 *
 * ***** END GPL LICENSE BLOCK *****
 */

/** \file blender/editors/mesh/mesh_data.c
 *  \ingroup edmesh
 */


#include <math.h>
#include <stdlib.h>
#include <string.h>

#include "MEM_guardedalloc.h"

#include "DNA_material_types.h"
#include "DNA_meshdata_types.h"
#include "DNA_object_types.h"
#include "DNA_scene_types.h"
#include "DNA_view3d_types.h"

#include "BLI_utildefines.h"
#include "BLI_array.h"
#include "BLI_math.h"
#include "BLI_editVert.h"
#include "BLI_edgehash.h"
#include "BLI_utildefines.h"

#include "BKE_context.h"
#include "BKE_depsgraph.h"
#include "BKE_displist.h"
#include "BKE_image.h"
#include "BKE_library.h"
#include "BKE_main.h"
#include "BKE_material.h"
#include "BKE_mesh.h"
#include "BKE_report.h"
#include "BKE_tessmesh.h"

#include "RNA_access.h"
#include "RNA_define.h"

#include "WM_api.h"
#include "WM_types.h"

#include "ED_mesh.h"
#include "ED_object.h"
#include "ED_uvedit.h"
#include "ED_view3d.h"

#include "RE_render_ext.h"

#include "mesh_intern.h"

#define GET_CD_DATA(me, data) (me->edit_btmesh ? &me->edit_btmesh->bm->data : &me->data)
static void delete_customdata_layer(bContext *C, Object *ob, CustomDataLayer *layer)
{
	Mesh *me = ob->data;
	CustomData *data;
	void *actlayerdata, *rndlayerdata, *clonelayerdata, *stencillayerdata, *layerdata=layer->data;
	int type= layer->type;
	int index;
	int i, actindex, rndindex, cloneindex, stencilindex, tot;
	
	if (layer->type == CD_MLOOPCOL || layer->type == CD_MLOOPUV) {
		data = (me->edit_btmesh)? &me->edit_btmesh->bm->ldata: &me->ldata;
		tot = me->totloop;
	} else {
		data = (me->edit_btmesh)? &me->edit_btmesh->bm->pdata: &me->pdata;
		tot = me->totpoly;
	}
	
	index = CustomData_get_layer_index(data, type);

	/* ok, deleting a non-active layer needs to preserve the active layer indices.
	  to do this, we store a pointer to the .data member of both layer and the active layer,
	  (to detect if we're deleting the active layer or not), then use the active
	  layer data pointer to find where the active layer has ended up.

	  
	  this is necassary because the deletion functions only support deleting the active
	  layer. */
	actlayerdata = data->layers[CustomData_get_active_layer_index(data, type)].data;
	rndlayerdata = data->layers[CustomData_get_render_layer_index(data, type)].data;
	clonelayerdata = data->layers[CustomData_get_clone_layer_index(data, type)].data;
	stencillayerdata = data->layers[CustomData_get_stencil_layer_index(data, type)].data;
	CustomData_set_layer_active(data, type, layer - &data->layers[index]);

	if(me->edit_btmesh) {
		BM_free_data_layer(me->edit_btmesh->bm, data, type);
	}
	else {
		CustomData_free_layer_active(data, type, tot);
		mesh_update_customdata_pointers(me);
	}

	if(!CustomData_has_layer(data, type) && (type == CD_MLOOPCOL && (ob->mode & OB_MODE_VERTEX_PAINT)))
		ED_object_toggle_modes(C, OB_MODE_VERTEX_PAINT);

	/* reconstruct active layer */
	if (actlayerdata != layerdata) {
		/* find index */
		actindex = CustomData_get_layer_index(data, type);
		for (i=actindex; i<data->totlayer; i++) {
			if (data->layers[i].data == actlayerdata) {
				actindex = i - actindex;
				break;
			}
		}

		
		/* set index */
		CustomData_set_layer_active(data, type, actindex);
	}

	
	if (rndlayerdata != layerdata) {
		/* find index */
		rndindex = CustomData_get_layer_index(data, type);
		for (i=rndindex; i<data->totlayer; i++) {
			if (data->layers[i].data == rndlayerdata) {
				rndindex = i - rndindex;
				break;
			}
		}

		
		/* set index */
		CustomData_set_layer_render(data, type, rndindex);
	}

	
	if (clonelayerdata != layerdata) {
		/* find index */
		cloneindex = CustomData_get_layer_index(data, type);
		for (i=cloneindex; i<data->totlayer; i++) {
			if (data->layers[i].data == clonelayerdata) {
				cloneindex = i - cloneindex;
				break;
			}
		}

		
		/* set index */
		CustomData_set_layer_clone(data, type, cloneindex);
	}

	
	if (stencillayerdata != layerdata) {
		/* find index */
		stencilindex = CustomData_get_layer_index(data, type);
		for (i=stencilindex; i<data->totlayer; i++) {
			if (data->layers[i].data == stencillayerdata) {
				stencilindex = i - stencilindex;
				break;
			}
		}

		
		/* set index */
		CustomData_set_layer_stencil(data, type, stencilindex);
	}
}

static void copy_editface_active_customdata(BMEditMesh *em, int type, int index)
{
#if 1 /*BMESH_TODO*/
	(void)em;
	(void)type;
	(void)index;
#else
	EditFace *efa;
	int n= CustomData_get_active_layer(&em->fdata, type);

	for(efa= em->faces.first; efa; efa= efa->next) {
		void *data= CustomData_em_get_n(&em->fdata, efa->data, type, n);
		CustomData_em_set_n(&em->fdata, efa->data, type, index, data);
	}
#endif
}

int ED_mesh_uv_loop_reset(struct bContext *C, struct Mesh *me)
{
	BMEditMesh *em= me->edit_btmesh;
	MLoopUV *luv;
	BLI_array_declare(polylengths);
	int *polylengths = NULL;
	BLI_array_declare(uvs);
	float **uvs = NULL;
	float **fuvs = NULL;
	int i, j;

	if (em) {
		/* Collect BMesh UVs */

		BMFace *efa;
		BMLoop *l;
		BMIter iter, liter;

		BLI_assert(CustomData_has_layer(&em->bm->ldata, CD_MLOOPUV));

		BM_ITER(efa, &iter, em->bm, BM_FACES_OF_MESH, NULL) {
			if (!BM_TestHFlag(efa, BM_SELECT))
				continue;

			i = 0;
			BM_ITER(l, &liter, em->bm, BM_LOOPS_OF_FACE, efa) {
				luv = CustomData_bmesh_get(&em->bm->ldata, l->head.data, CD_MLOOPUV);
				BLI_array_append(uvs, luv->uv);
				i++;
			}

			BLI_array_append(polylengths, efa->len);
		}
	}
	else {
		/* Collect Mesh UVs */

		MPoly *mp;

		BLI_assert(CustomData_has_layer(&me->ldata, CD_MLOOPUV));

		for (j = 0; j < me->totpoly; j++) {
			mp = &me->mpoly[j];

			for (i = 0; i < mp->totloop; i++) {
				luv = &me->mloopuv[mp->loopstart + i];
				BLI_array_append(uvs, luv->uv);
			}

			BLI_array_append(polylengths, mp->totloop);
		}
	}

	fuvs = uvs;
	for (j = 0; j < BLI_array_count(polylengths); j++) {
		int len = polylengths[j];

		if (len == 3) {
			fuvs[0][0] = 0.0;
			fuvs[0][1] = 0.0;
			
			fuvs[1][0] = 1.0;
			fuvs[1][1] = 0.0;

			fuvs[2][0] = 1.0;
			fuvs[2][1] = 1.0;
		} else if (len == 4) {
			fuvs[0][0] = 0.0;
			fuvs[0][1] = 0.0;
			
			fuvs[1][0] = 1.0;
			fuvs[1][1] = 0.0;

			fuvs[2][0] = 1.0;
			fuvs[2][1] = 1.0;

			fuvs[3][0] = 0.0;
			fuvs[3][1] = 1.0;
		  /*make sure we ignore 2-sided faces*/
		} else if (len > 2) {
			float fac = 0.0f, dfac = 1.0f / (float)len;

			dfac *= M_PI*2;

			for (i = 0; i < len; i++) {
				fuvs[i][0] = 0.5f * sin(fac) + 0.5f;
				fuvs[i][1] = 0.5f * cos(fac) + 0.5f;

				fac += dfac;
			}
		}

		fuvs += len;
	}

	/* BMESH_TODO: Copy poly UVs onto CD_MTFACE layer for tesselated faces */

	BLI_array_free(uvs);
	BLI_array_free(polylengths);

	DAG_id_tag_update(&me->id, 0);
	WM_event_add_notifier(C, NC_GEOM|ND_DATA, me);

	return 1;
}

int ED_mesh_uv_texture_add(bContext *C, Mesh *me, const char *name, int active_set)
{
	BMEditMesh *em;
	int layernum;

	if (me->edit_btmesh) {
		em= me->edit_btmesh;

		layernum = CustomData_number_of_layers(&em->bm->pdata, CD_MTEXPOLY);
		if (layernum >= MAX_MTFACE) {
			return 0;
		}

		BM_add_data_layer(em->bm, &em->bm->pdata, CD_MTEXPOLY);
		CustomData_set_layer_active(&em->bm->pdata, CD_MTEXPOLY, layernum);
		CustomData_set_layer_name(&em->bm->pdata, CD_MTEXPOLY, layernum, name);

		/* copy data from active UV */
		if (layernum) {
			copy_editface_active_customdata(em, CD_MTFACE, layernum);
		}

		if (active_set || layernum == 0) {
			CustomData_set_layer_active(&em->bm->pdata, CD_MTEXPOLY, layernum);
		}

		BM_add_data_layer(em->bm, &em->bm->ldata, CD_MLOOPUV);
		CustomData_set_layer_name(&em->bm->ldata, CD_MLOOPUV, layernum, name);
		
		CustomData_set_layer_active(&em->bm->ldata, CD_MLOOPUV, layernum);
		if(active_set || layernum == 0) {
			CustomData_set_layer_active(&em->bm->ldata, CD_MLOOPUV, layernum);
		}
	}
	else {
		layernum = CustomData_number_of_layers(&me->pdata, CD_MTEXPOLY);
		if (layernum >= MAX_MTFACE) {
			return 0;
		}

		if (me->mtpoly) {
			CustomData_add_layer_named(&me->pdata, CD_MTEXPOLY, CD_DUPLICATE, me->mtpoly, me->totpoly, name);
			CustomData_add_layer_named(&me->ldata, CD_MLOOPUV, CD_DUPLICATE, me->mloopuv, me->totloop, name);
			CustomData_add_layer_named(&me->fdata, CD_MTFACE, CD_DUPLICATE, me->mtface, me->totface, name);
		} else {
			CustomData_add_layer_named(&me->pdata, CD_MTEXPOLY, CD_DEFAULT, NULL, me->totpoly, name);
			CustomData_add_layer_named(&me->ldata, CD_MLOOPUV, CD_DEFAULT, NULL, me->totloop, name);
			CustomData_add_layer_named(&me->fdata, CD_MTFACE, CD_DEFAULT, NULL, me->totface, name);
		}
		
		if (active_set || layernum == 0) {
			CustomData_set_layer_active(&me->pdata, CD_MTEXPOLY, layernum);
			CustomData_set_layer_active(&me->ldata, CD_MLOOPUV, layernum);

			CustomData_set_layer_active(&me->fdata, CD_MTFACE, layernum);
		}

		mesh_update_customdata_pointers(me);
	}

	ED_mesh_uv_loop_reset(C, me);

	DAG_id_tag_update(&me->id, 0);
	WM_event_add_notifier(C, NC_GEOM|ND_DATA, me);

	return 1;
}

int ED_mesh_uv_texture_remove(bContext *C, Object *ob, Mesh *me)
{
	CustomData *pdata = GET_CD_DATA(me, pdata), *ldata = GET_CD_DATA(me, ldata);
	CustomDataLayer *cdlp, *cdlu;
	int index;

 	index= CustomData_get_active_layer_index(pdata, CD_MTEXPOLY);
	cdlp= (index == -1)? NULL: &pdata->layers[index];

 	index= CustomData_get_active_layer_index(ldata, CD_MLOOPUV);
	cdlu= (index == -1)? NULL: &ldata->layers[index];
	
	if (!cdlp || !cdlu)
		return 0;

	delete_customdata_layer(C, ob, cdlp);
	delete_customdata_layer(C, ob, cdlu);
	
	DAG_id_tag_update(&me->id, 0);
	WM_event_add_notifier(C, NC_GEOM|ND_DATA, me);

	return 1;
}

int ED_mesh_color_add(bContext *C, Scene *UNUSED(scene), Object *UNUSED(ob), Mesh *me, const char *name, int active_set)
{
	BMEditMesh *em;
	int layernum;

	if (me->edit_btmesh) {
		em= me->edit_btmesh;

		layernum= CustomData_number_of_layers(&em->bm->ldata, CD_MLOOPCOL);
		if (layernum >= MAX_MCOL) {
			return 0;
		}

		BM_add_data_layer(em->bm, &em->bm->pdata, CD_MLOOPCOL);
		CustomData_set_layer_active(&em->bm->ldata, CD_MLOOPCOL, layernum);

		/* copy data from active vertex color layer */
		if (layernum) {
			copy_editface_active_customdata(em, CD_MCOL, layernum);
		}

		if (active_set || layernum == 0) {
			CustomData_set_layer_active(&em->bm->ldata, CD_MLOOPCOL, layernum);
		}
	}
	else {
		layernum= CustomData_number_of_layers(&me->ldata, CD_MLOOPCOL);
		if (layernum >= CD_MLOOPCOL) {
			return 0;
		}

		if(me->mloopcol) {
			CustomData_add_layer_named(&me->ldata, CD_MLOOPCOL, CD_DUPLICATE, me->mloopcol, me->totloop, name);
			CustomData_add_layer_named(&me->fdata, CD_MCOL, CD_DUPLICATE, me->mloopcol, me->totface, name);
		}
		else {
			CustomData_add_layer_named(&me->ldata, CD_MLOOPCOL, CD_DEFAULT, NULL, me->totloop, name);
			CustomData_add_layer_named(&me->fdata, CD_MCOL, CD_DEFAULT, NULL, me->totface, name);
		}

		if(active_set || layernum==0) {
			CustomData_set_layer_active(&me->ldata, CD_MLOOPCOL, layernum);
			CustomData_set_layer_active(&me->fdata, CD_MCOL, layernum);
		}

		mesh_update_customdata_pointers(me);
	}

	DAG_id_tag_update(&me->id, 0);
	WM_event_add_notifier(C, NC_GEOM|ND_DATA, me);

	return 1;
}

int ED_mesh_color_remove(bContext *C, Object *ob, Mesh *me)
{
	CustomDataLayer *cdl;
	int index;

	index= CustomData_get_active_layer_index(&me->ldata, CD_MLOOPCOL);
	cdl= (index == -1)? NULL: &me->ldata.layers[index];

	if(!cdl)
		return 0;

	delete_customdata_layer(C, ob, cdl);
	DAG_id_tag_update(&me->id, 0);
	WM_event_add_notifier(C, NC_GEOM|ND_DATA, me);

	return 1;
}

int ED_mesh_color_remove_named(bContext *C, Object *ob, Mesh *me, const char *name)
{
	CustomDataLayer *cdl;
	int index;

	index= CustomData_get_named_layer_index(&me->ldata, CD_MLOOPCOL, name);
	cdl= (index == -1)? NULL: &me->ldata.layers[index];

	if(!cdl)
		return 0;

	delete_customdata_layer(C, ob, cdl);
	DAG_id_tag_update(&me->id, 0);
	WM_event_add_notifier(C, NC_GEOM|ND_DATA, me);

	return 1;
}

/*********************** UV texture operators ************************/

static int layers_poll(bContext *C)
{
	Object *ob= CTX_data_pointer_get_type(C, "object", &RNA_Object).data;
	ID *data= (ob)? ob->data: NULL;
	return (ob && !ob->id.lib && ob->type==OB_MESH && data && !data->lib);
}

static int uv_texture_add_exec(bContext *C, wmOperator *UNUSED(op))
{
	Object *ob= CTX_data_pointer_get_type(C, "object", &RNA_Object).data;
	Mesh *me= ob->data;

	if(!ED_mesh_uv_texture_add(C, me, NULL, TRUE))
		return OPERATOR_CANCELLED;

	return OPERATOR_FINISHED;
}

void MESH_OT_uv_texture_add(wmOperatorType *ot)
{
	/* identifiers */
	ot->name= "Add UV Map";
	ot->description= "Add UV Map";
	ot->idname= "MESH_OT_uv_texture_add";

	
	/* api callbacks */
	ot->poll= layers_poll;
	ot->exec= uv_texture_add_exec;

	/* flags */
	ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
}

static int drop_named_image_invoke(bContext *C, wmOperator *op, wmEvent *event)
{
	Main *bmain= CTX_data_main(C);
	Scene *scene= CTX_data_scene(C);
	View3D *v3d= CTX_wm_view3d(C);
	Base *base= ED_view3d_give_base_under_cursor(C, event->mval);
	Image *ima= NULL;
	Mesh *me;
	Object *obedit;
	int exitmode= 0;
	char name[32];

	
	/* Check context */
	if(base==NULL || base->object->type!=OB_MESH) {
		BKE_report(op->reports, RPT_ERROR, "Not an Object or Mesh");
		return OPERATOR_CANCELLED;
	}

	
	/* check input variables */
	if(RNA_property_is_set(op->ptr, "filepath")) {
		char path[FILE_MAX];

		
		RNA_string_get(op->ptr, "filepath", path);
		ima= BKE_add_image_file(path);
	}
	else {
		RNA_string_get(op->ptr, "name", name);
		ima= (Image *)find_id("IM", name);
	}

	
	if(!ima) {
		BKE_report(op->reports, RPT_ERROR, "Not an Image");
		return OPERATOR_CANCELLED;
	}

	
	/* put mesh in editmode */

	obedit= base->object;
	me= obedit->data;
	if(me->edit_btmesh==NULL) {
		EDBM_MakeEditBMesh(scene->toolsettings, scene, obedit);
		exitmode= 1;
	}
	if(me->edit_btmesh==NULL)
		return OPERATOR_CANCELLED;

	
	ED_uvedit_assign_image(bmain, scene, obedit, ima, NULL);

	if(exitmode) {
		EDBM_LoadEditBMesh(scene, obedit);
		EDBM_FreeEditBMesh(me->edit_btmesh);
		MEM_freeN(me->edit_btmesh);
		me->edit_btmesh= NULL;
	}

	/* dummie drop support; ensure view shows a result :) */
	if(v3d)
		v3d->flag2 |= V3D_SOLID_TEX;

	
	WM_event_add_notifier(C, NC_GEOM|ND_DATA, obedit->data);

	
	return OPERATOR_FINISHED;
}

void MESH_OT_drop_named_image(wmOperatorType *ot)
{
	/* identifiers */
	ot->name= "Assign Image to UV Map";
	ot->description= "Assign Image to active UV Map, or create an UV Map";
	ot->idname= "MESH_OT_drop_named_image";

	
	/* api callbacks */
	ot->poll= layers_poll;
	ot->invoke= drop_named_image_invoke;

	
	/* flags */
	ot->flag= OPTYPE_UNDO;

	
	/* properties */
	RNA_def_string(ot->srna, "name", "Image", 24, "Name", "Image name to assign");
	RNA_def_string(ot->srna, "filepath", "Path", FILE_MAX, "Filepath", "Path to image file");
}

static int uv_texture_remove_exec(bContext *C, wmOperator *UNUSED(op))
{
	Object *ob= CTX_data_pointer_get_type(C, "object", &RNA_Object).data;
	Mesh *me= ob->data;

	if(!ED_mesh_uv_texture_remove(C, ob, me))
		return OPERATOR_CANCELLED;

	return OPERATOR_FINISHED;
}

void MESH_OT_uv_texture_remove(wmOperatorType *ot)
{
	/* identifiers */
	ot->name= "Remove UV Map";
	ot->description= "Remove UV Map";
	ot->idname= "MESH_OT_uv_texture_remove";

	
	/* api callbacks */
	ot->poll= layers_poll;
	ot->exec= uv_texture_remove_exec;

	/* flags */
	ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
}

/*********************** vertex color operators ************************/

static int vertex_color_add_exec(bContext *C, wmOperator *UNUSED(op))
{
	Scene *scene= CTX_data_scene(C);
	Object *ob= CTX_data_pointer_get_type(C, "object", &RNA_Object).data;
	Mesh *me= ob->data;

	if(!ED_mesh_color_add(C, scene, ob, me, NULL, TRUE))
		return OPERATOR_CANCELLED;

	return OPERATOR_FINISHED;
}

void MESH_OT_vertex_color_add(wmOperatorType *ot)
{
	/* identifiers */
	ot->name= "Add Vertex Color";
	ot->description= "Add vertex color layer";
	ot->idname= "MESH_OT_vertex_color_add";

	
	/* api callbacks */
	ot->poll= layers_poll;
	ot->exec= vertex_color_add_exec;

	/* flags */
	ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
}

static int vertex_color_remove_exec(bContext *C, wmOperator *UNUSED(op))
{
	Object *ob= CTX_data_pointer_get_type(C, "object", &RNA_Object).data;
	Mesh *me= ob->data;

	if(!ED_mesh_color_remove(C, ob, me))
		return OPERATOR_CANCELLED;

	return OPERATOR_FINISHED;
}

void MESH_OT_vertex_color_remove(wmOperatorType *ot)
{
	/* identifiers */
	ot->name= "Remove Vertex Color";
	ot->description= "Remove vertex color layer";
	ot->idname= "MESH_OT_vertex_color_remove";

	
	/* api callbacks */
	ot->exec= vertex_color_remove_exec;
	ot->poll= layers_poll;

	/* flags */
	ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
}

/*********************** sticky operators ************************/

static int sticky_add_exec(bContext *C, wmOperator *UNUSED(op))
{
	Scene *scene= CTX_data_scene(C);
	View3D *v3d= CTX_wm_view3d(C);
	Object *ob= CTX_data_pointer_get_type(C, "object", &RNA_Object).data;
	Mesh *me= ob->data;

	/*if(me->msticky)
		return OPERATOR_CANCELLED;*/

	RE_make_sticky(scene, v3d);

	DAG_id_tag_update(&me->id, 0);
	WM_event_add_notifier(C, NC_GEOM|ND_DATA, me);

	return OPERATOR_FINISHED;
}

void MESH_OT_sticky_add(wmOperatorType *ot)
{
	/* identifiers */
	ot->name= "Add Sticky";
	ot->description= "Add sticky UV texture layer";
	ot->idname= "MESH_OT_sticky_add";

	
	/* api callbacks */
	ot->poll= layers_poll;
	ot->exec= sticky_add_exec;

	/* flags */
	ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
}

static int sticky_remove_exec(bContext *C, wmOperator *UNUSED(op))
{
	Object *ob= CTX_data_pointer_get_type(C, "object", &RNA_Object).data;
	Mesh *me= ob->data;

	if(!me->msticky)
		return OPERATOR_CANCELLED;

	CustomData_free_layer_active(&me->vdata, CD_MSTICKY, me->totvert);
	me->msticky= NULL;

	DAG_id_tag_update(&me->id, 0);
	WM_event_add_notifier(C, NC_GEOM|ND_DATA, me);

	return OPERATOR_FINISHED;
}

void MESH_OT_sticky_remove(wmOperatorType *ot)
{
	/* identifiers */
	ot->name= "Remove Sticky";
	ot->description= "Remove sticky UV texture layer";
	ot->idname= "MESH_OT_sticky_remove";

	
	/* api callbacks */
	ot->poll= layers_poll;
	ot->exec= sticky_remove_exec;

	/* flags */
	ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
}

/************************** Add Geometry Layers *************************/

void ED_mesh_update(Mesh *mesh, bContext *C, int calc_edges)
{
	int *polyindex = NULL;
	float (*face_nors)[3];

	if(mesh->totface > 0 && mesh->totpoly == 0)
		convert_mfaces_to_mpolys(mesh);

	if(calc_edges || (mesh->totpoly && mesh->totedge == 0))
		BKE_mesh_calc_edges(mesh, calc_edges);

	mesh->totface = mesh_recalcTesselation(
		&mesh->fdata,
		&mesh->ldata,
		&mesh->pdata,
		mesh->mvert,
		mesh->totface,
		mesh->totloop,
		mesh->totpoly);

	mesh_update_customdata_pointers(mesh);

	polyindex = CustomData_get_layer(&mesh->fdata, CD_POLYINDEX);
	/* add a normals layer for tesselated faces, a tessface normal will
	   contain the normal of the poly the face was tesselated from. */
	face_nors = CustomData_add_layer(&mesh->fdata, CD_NORMAL, CD_CALLOC, NULL, mesh->totface);

	mesh_calc_normals(
		mesh->mvert,
		mesh->totvert,
		mesh->mloop,
		mesh->mpoly,
		mesh->totloop,
		mesh->totpoly,
		NULL /* polyNors_r */,
		mesh->mface,
		mesh->totface,
		polyindex,
		face_nors);

	DAG_id_tag_update(&mesh->id, 0);
	WM_event_add_notifier(C, NC_GEOM|ND_DATA, mesh);
}

static void mesh_add_verts(Mesh *mesh, int len)
{
	CustomData vdata;
	MVert *mvert;
	int i, totvert;

	if(len == 0)
		return;

	totvert= mesh->totvert + len;
	CustomData_copy(&mesh->vdata, &vdata, CD_MASK_MESH, CD_DEFAULT, totvert);
	CustomData_copy_data(&mesh->vdata, &vdata, 0, 0, mesh->totvert);

	if(!CustomData_has_layer(&vdata, CD_MVERT))
		CustomData_add_layer(&vdata, CD_MVERT, CD_CALLOC, NULL, totvert);

	CustomData_free(&mesh->vdata, mesh->totvert);
	mesh->vdata= vdata;
	mesh_update_customdata_pointers(mesh);

	/* scan the input list and insert the new vertices */

	mvert= &mesh->mvert[mesh->totvert];
	for(i=0; i<len; i++, mvert++)
		mvert->flag |= SELECT;

	/* set final vertex list size */
	mesh->totvert= totvert;
}

void ED_mesh_transform(Mesh *mesh, float *mat)
{
	int i;
	MVert *mvert= mesh->mvert;

	for(i= 0; i < mesh->totvert; i++, mvert++)
		mul_m4_v3((float (*)[4])mat, mvert->co);

	mesh_calc_normals(mesh->mvert, mesh->totvert, mesh->mloop, mesh->mpoly, mesh->totloop, mesh->totpoly, NULL, NULL, 0, NULL, NULL);
}

static void mesh_add_edges(Mesh *mesh, int len)
{
	CustomData edata;
	MEdge *medge;
	int i, totedge;

	if(len == 0)
		return;

	totedge= mesh->totedge+len;

	/* update customdata  */
	CustomData_copy(&mesh->edata, &edata, CD_MASK_MESH, CD_DEFAULT, totedge);
	CustomData_copy_data(&mesh->edata, &edata, 0, 0, mesh->totedge);

	if(!CustomData_has_layer(&edata, CD_MEDGE))
		CustomData_add_layer(&edata, CD_MEDGE, CD_CALLOC, NULL, totedge);

	CustomData_free(&mesh->edata, mesh->totedge);
	mesh->edata= edata;
	mesh_update_customdata_pointers(mesh);

	/* set default flags */
	medge= &mesh->medge[mesh->totedge];
	for(i=0; i<len; i++, medge++)
		medge->flag= ME_EDGEDRAW|ME_EDGERENDER|SELECT;

	mesh->totedge= totedge;
}



static void mesh_add_faces(Mesh *mesh, int len)
{
	CustomData fdata;
	MFace *mface;
	int i, totface;

	if(len == 0)
		return;

	totface= mesh->totface + len;	/* new face count */

	/* update customdata */
	CustomData_copy(&mesh->fdata, &fdata, CD_MASK_MESH, CD_DEFAULT, totface);
	CustomData_copy_data(&mesh->fdata, &fdata, 0, 0, mesh->totface);

	if(!CustomData_has_layer(&fdata, CD_MFACE))
		CustomData_add_layer(&fdata, CD_MFACE, CD_CALLOC, NULL, totface);

	CustomData_free(&mesh->fdata, mesh->totface);
	mesh->fdata= fdata;
	mesh_update_customdata_pointers(mesh);

	/* set default flags */
	mface= &mesh->mface[mesh->totface];
	for(i=0; i<len; i++, mface++)
		mface->flag= ME_FACE_SEL;

	mesh->totface= totface;
}

static void mesh_add_loops(Mesh *mesh, int len)
{
	CustomData ldata;
	int totloop;

	if(len == 0)
		return;

	totloop= mesh->totloop + len;	/* new face count */

	/* update customdata */
	CustomData_copy(&mesh->ldata, &ldata, CD_MASK_MESH, CD_DEFAULT, totloop);
	CustomData_copy_data(&mesh->ldata, &ldata, 0, 0, mesh->totloop);

	if(!CustomData_has_layer(&ldata, CD_MLOOP))
		CustomData_add_layer(&ldata, CD_MLOOP, CD_CALLOC, NULL, totloop);

	CustomData_free(&mesh->ldata, mesh->totloop);
	mesh->ldata= ldata;
	mesh_update_customdata_pointers(mesh);

	mesh->totloop= totloop;
}

static void mesh_add_polys(Mesh *mesh, int len)
{
	CustomData pdata;
	MPoly *mpoly;
	int i, totpoly;

	if(len == 0)
		return;

	totpoly= mesh->totpoly + len;	/* new face count */

	/* update customdata */
	CustomData_copy(&mesh->pdata, &pdata, CD_MASK_MESH, CD_DEFAULT, totpoly);
	CustomData_copy_data(&mesh->pdata, &pdata, 0, 0, mesh->totpoly);

	if(!CustomData_has_layer(&pdata, CD_MPOLY))
		CustomData_add_layer(&pdata, CD_MPOLY, CD_CALLOC, NULL, totpoly);

	CustomData_free(&mesh->pdata, mesh->totpoly);
	mesh->pdata= pdata;
	mesh_update_customdata_pointers(mesh);

	/* set default flags */
	mpoly= &mesh->mpoly[mesh->totpoly];
	for(i=0; i<len; i++, mpoly++)
		mpoly->flag= ME_FACE_SEL;

	mesh->totpoly= totpoly;
}

/*
void ED_mesh_geometry_add(Mesh *mesh, ReportList *reports, int verts, int edges, int faces)
{
	if(mesh->edit_btmesh) {
		BKE_report(reports, RPT_ERROR, "Can't add geometry in edit mode");
		return;
	}

	if(verts)
		mesh_add_verts(mesh, verts);
	if(edges)
		mesh_add_edges(mesh, edges);
	if(faces)
		mesh_add_faces(mesh, faces);
}
*/

void ED_mesh_faces_add(Mesh *mesh, ReportList *reports, int count)
{
	if(mesh->edit_btmesh) {
		BKE_report(reports, RPT_ERROR, "Can't add faces in edit mode");
		return;
	}

	mesh_add_faces(mesh, count);
}

void ED_mesh_edges_add(Mesh *mesh, ReportList *reports, int count)
{
	if(mesh->edit_btmesh) {
		BKE_report(reports, RPT_ERROR, "Can't add edges in edit mode");
			return;
	}

	mesh_add_edges(mesh, count);
}


void ED_mesh_vertices_add(Mesh *mesh, ReportList *reports, int count)
{
	if(mesh->edit_btmesh) {
		BKE_report(reports, RPT_ERROR, "Can't add vertices in edit mode");
		return;
	}

	mesh_add_verts(mesh, count);
}

void ED_mesh_loops_add(Mesh *mesh, ReportList *reports, int count)
{
	if(mesh->edit_btmesh) {
		BKE_report(reports, RPT_ERROR, "Can't add loops in edit mode.");
			return;
	}

	mesh_add_loops(mesh, count);
}

void ED_mesh_polys_add(Mesh *mesh, ReportList *reports, int count)
{
	if(mesh->edit_btmesh) {
		BKE_report(reports, RPT_ERROR, "Can't add polys in edit mode.");
		return;
	}

	mesh_add_polys(mesh, count);
}

void ED_mesh_calc_normals(Mesh *mesh)
{
	mesh_calc_normals(mesh->mvert, mesh->totvert, mesh->mloop, mesh->mpoly, mesh->totloop, mesh->totpoly, NULL, NULL, 0, NULL, NULL);
}