自学教程：C++ CustomData_has_layer函数代码示例

void RE_set_customdata_names(ObjectRen *obr, CustomData *data){	/* CustomData layer names are stored per object here, because the	 * DerivedMesh which stores the layers is freed */		CustomDataLayer *layer;	int numtf = 0, numcol = 0, i, mtfn, mcn;	if (CustomData_has_layer(data, CD_MTFACE)) {		numtf= CustomData_number_of_layers(data, CD_MTFACE);		obr->mtface= MEM_callocN(sizeof(*obr->mtface)*numtf, "mtfacenames");	}	if (CustomData_has_layer(data, CD_MCOL)) {		numcol= CustomData_number_of_layers(data, CD_MCOL);		obr->mcol= MEM_callocN(sizeof(*obr->mcol)*numcol, "mcolnames");	}	for (i=0, mtfn=0, mcn=0; i < data->totlayer; i++) {		layer= &data->layers[i];		if (layer->type == CD_MTFACE) {			BLI_strncpy(obr->mtface[mtfn++], layer->name, sizeof(layer->name));			obr->actmtface= CLAMPIS(layer->active_rnd, 0, numtf);			obr->bakemtface= layer->active;		}		else if (layer->type == CD_MCOL) {			BLI_strncpy(obr->mcol[mcn++], layer->name, sizeof(layer->name));			obr->actmcol= CLAMPIS(layer->active_rnd, 0, numcol);		}	}}

char BM_mesh_cd_flag_from_bmesh(BMesh *bm){	char cd_flag = 0;	if (CustomData_has_layer(&bm->vdata, CD_BWEIGHT)) {		cd_flag |= ME_CDFLAG_VERT_BWEIGHT;	}	if (CustomData_has_layer(&bm->edata, CD_BWEIGHT)) {		cd_flag |= ME_CDFLAG_EDGE_BWEIGHT;	}	if (CustomData_has_layer(&bm->edata, CD_CREASE)) {		cd_flag |= ME_CDFLAG_EDGE_CREASE;	}	return cd_flag;}

void GeometryExporter::createVertexColorSource(std::string geom_id, Mesh *me){	if (!CustomData_has_layer(&me->fdata, CD_MCOL))		return;	MFace *f;	int totcolor = 0, i, j;	for (i = 0, f = me->mface; i < me->totface; i++, f++)		totcolor += f->v4 ? 4 : 3;	COLLADASW::FloatSourceF source(mSW);	source.setId(getIdBySemantics(geom_id, COLLADASW::InputSemantic::COLOR));	source.setArrayId(getIdBySemantics(geom_id, COLLADASW::InputSemantic::COLOR) + ARRAY_ID_SUFFIX);	source.setAccessorCount(totcolor);	source.setAccessorStride(3);	COLLADASW::SourceBase::ParameterNameList &param = source.getParameterNameList();	param.push_back("R");	param.push_back("G");	param.push_back("B");	source.prepareToAppendValues();	int index = CustomData_get_active_layer_index(&me->fdata, CD_MCOL);	MCol *mcol = (MCol*)me->fdata.layers[index].data;	MCol *c = mcol;	for (i = 0, f = me->mface; i < me->totface; i++, c += 4, f++)		for (j = 0; j < (f->v4 ? 4 : 3); j++)			source.appendValues(c[j].b / 255.0f, c[j].g / 255.0f, c[j].r / 255.0f);		source.finish();}

// =================================================================// This functin is copied from source/blender/editors/mesh/mesh_data.c//// TODO: (As discussed with sergey-) :// Maybe move this function to blenderkernel/intern/mesh.c // and add definition to BKE_mesh.c// =================================================================void MeshImporter::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;	BKE_mesh_update_customdata_pointers(mesh, false); /* new edges don't change tessellation */	/* 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 int navmesh_face_add_exec(bContext *C, wmOperator *UNUSED(op)){	Object *obedit= CTX_data_edit_object(C);	EditMesh *em= BKE_mesh_get_editmesh((Mesh *)obedit->data);	EditFace *ef;	if(CustomData_has_layer(&em->fdata, CD_RECAST)) {		int targetPolyIdx= findFreeNavPolyIndex(em);		if(targetPolyIdx>0) {			/* set target poly idx to selected faces */			ef= (EditFace*)em->faces.last;			while(ef) {				if(ef->f & SELECT) {					int *recastDataBlock= (int*)CustomData_em_get(&em->fdata, ef->data, CD_RECAST);					*recastDataBlock= targetPolyIdx;				}				ef= ef->prev;			}		}	}	DAG_id_tag_update((ID*)obedit->data, OB_RECALC_DATA);	WM_event_add_notifier(C, NC_GEOM|ND_DATA, obedit->data);	BKE_mesh_end_editmesh((Mesh*)obedit->data, em);	return OPERATOR_FINISHED;}

static PyObject *bpy_bmlayercollection_new(BPy_BMLayerCollection *self, PyObject *args){	const char *name = NULL;	int index;	CustomData *data;	BPY_BM_CHECK_OBJ(self);	if (!PyArg_ParseTuple(args, "|s:new", &name)) {		return NULL;	}	data = bpy_bm_customdata_get(self->bm, self->htype);	if (CustomData_layertype_is_singleton(self->type) &&	    CustomData_has_layer(data, self->type))	{		PyErr_SetString(PyExc_ValueError,		                "layers.new(): is a singleton, use verify() instead");		return NULL;	}	if (name) {		BM_data_layer_add_named(self->bm, data, self->type, name);	}	else {		BM_data_layer_add(self->bm, data, self->type);	}	index = CustomData_number_of_layers(data, self->type) - 1;	BLI_assert(index >= 0);	return BPy_BMLayerItem_CreatePyObject(self->bm, self->htype, self->type, index);}

static void rna_Mesh_create_normals_split(Mesh *mesh){	if (!CustomData_has_layer(&mesh->ldata, CD_NORMAL)) {		CustomData_add_layer(&mesh->ldata, CD_NORMAL, CD_CALLOC, NULL, mesh->totloop);		CustomData_set_layer_flag(&mesh->ldata, CD_NORMAL, CD_FLAG_TEMPORARY);	}}

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_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;}

/* Set a vertex's paint-mask value * * Has no effect is no paint-mask layer is present */static void vert_mask_set(BMesh *bm, BMVert *v, float new_mask){	CustomData *cd = &bm->vdata;	if (CustomData_has_layer(cd, CD_PAINT_MASK)) {		float *mask = CustomData_bmesh_get(cd, v->head.data, CD_PAINT_MASK);		(*mask) = new_mask;	}}

static int navmesh_obmode_data_poll(bContext *C){	Object *ob = ED_object_active_context(C);	if (ob && (ob->mode == OB_MODE_OBJECT) && (ob->type == OB_MESH)) {		Mesh *me= ob->data;		return CustomData_has_layer(&me->fdata, CD_RECAST);	}	return FALSE;}

static int skin_resize_poll(bContext *C){	struct Object *obedit = CTX_data_edit_object(C);	if (obedit && obedit->type == OB_MESH) {		BMEditMesh *em = BKE_editmesh_from_object(obedit);		return (em && CustomData_has_layer(&em->bm->vdata, CD_MVERT_SKIN));	}	return 0;}

void GeometryExporter::create_normals(std::vector<Normal> &normals, std::vector<BCPolygonNormalsIndices> &polygons_normals, Mesh *me){	std::map<Normal, unsigned int> shared_normal_indices;	int last_normal_index = -1;	MVert *verts  = me->mvert;	MLoop *mloops = me->mloop;	float(*lnors)[3];	BKE_mesh_calc_normals_split(me);	if (CustomData_has_layer(&me->ldata, CD_NORMAL)) {		lnors = (float(*)[3])CustomData_get_layer(&me->ldata, CD_NORMAL);	}	for (int poly_index = 0; poly_index < me->totpoly; poly_index++) {		MPoly *mpoly  = &me->mpoly[poly_index];		if (!(mpoly->flag & ME_SMOOTH)) {			// For flat faces use face normal as vertex normal:			float vector[3];			BKE_mesh_calc_poly_normal(mpoly, mloops+mpoly->loopstart, verts, vector);			Normal n = { vector[0], vector[1], vector[2] };			normals.push_back(n);			last_normal_index++;		}		MLoop *mloop = mloops + mpoly->loopstart;		BCPolygonNormalsIndices poly_indices;		for (int loop_index = 0; loop_index < mpoly->totloop; loop_index++) {			unsigned int loop_idx = mpoly->loopstart + loop_index;			if (mpoly->flag & ME_SMOOTH) {				float normalized[3];				normalize_v3_v3(normalized, lnors[loop_idx]);				Normal n = { normalized[0], normalized[1], normalized[2] };				if (shared_normal_indices.find(n) != shared_normal_indices.end()) {					poly_indices.add_index(shared_normal_indices[n]);				}				else {					last_normal_index++;					poly_indices.add_index(last_normal_index);					shared_normal_indices[n] = last_normal_index;					normals.push_back(n);				}			}			else {				poly_indices.add_index(last_normal_index);			}		}		polygons_normals.push_back(poly_indices);	}}

/* Get a vertex's paint-mask value * * Returns zero if no paint-mask layer is present */static float vert_mask_get(BMesh *bm, BMVert *v){	CustomData *cd = &bm->vdata;	if (CustomData_has_layer(&bm->vdata, CD_PAINT_MASK)) {		float *mask = CustomData_bmesh_get(cd, v->head.data, CD_PAINT_MASK);		return *mask;	}	else {		return 0;	}}

static void rna_Mesh_calc_tangents(Mesh *mesh, ReportList *reports, const char *uvmap){	float (*r_looptangents)[4];	if (CustomData_has_layer(&mesh->ldata, CD_MLOOPTANGENT)) {		r_looptangents = CustomData_get_layer(&mesh->ldata, CD_MLOOPTANGENT);		memset(r_looptangents, 0, sizeof(float[4]) * mesh->totloop);	}	else {		r_looptangents = CustomData_add_layer(&mesh->ldata, CD_MLOOPTANGENT, CD_CALLOC, NULL, mesh->totloop);		CustomData_set_layer_flag(&mesh->ldata, CD_MLOOPTANGENT, CD_FLAG_TEMPORARY);	}	/* Compute loop normals if needed. */	if (!CustomData_has_layer(&mesh->ldata, CD_NORMAL)) {		BKE_mesh_calc_normals_split(mesh);	}	BKE_mesh_loop_tangents(mesh, uvmap, r_looptangents, reports);}

static int draw_uvs_dm_shadow(DerivedMesh *dm){	/* draw shadow mesh - this is the mesh with the modifier applied */	if(dm && dm->drawUVEdges && CustomData_has_layer(&dm->faceData, CD_MTFACE)) {		glColor3ub(112, 112, 112);		dm->drawUVEdges(dm);		return 1;	}	return 0;}

void modwrap_deformVertsEM(        ModifierData *md, Object *ob,        struct BMEditMesh *em, DerivedMesh *dm,        float (*vertexCos)[3], int numVerts){	ModifierTypeInfo *mti = modifierType_getInfo(md->type);	BLI_assert(!dm || CustomData_has_layer(&dm->polyData, CD_NORMAL) == false);	if (dm && mti->dependsOnNormals && mti->dependsOnNormals(md)) {		DM_ensure_normals(dm);	}	mti->deformVertsEM(md, ob, em, dm, vertexCos, numVerts);}

struct DerivedMesh *modwrap_applyModifier(        ModifierData *md, Object *ob,        struct DerivedMesh *dm,        ModifierApplyFlag flag){	ModifierTypeInfo *mti = modifierType_getInfo(md->type);	BLI_assert(CustomData_has_layer(&dm->polyData, CD_NORMAL) == false);	if (mti->dependsOnNormals && mti->dependsOnNormals(md)) {		DM_ensure_normals(dm);	}	return mti->applyModifier(md, ob, dm, flag);}

void modwrap_deformVerts(        ModifierData *md, Object *ob,        DerivedMesh *dm,        float (*vertexCos)[3], int numVerts,        ModifierApplyFlag flag){	const ModifierTypeInfo *mti = modifierType_getInfo(md->type);	BLI_assert(!dm || CustomData_has_layer(&dm->polyData, CD_NORMAL) == false);	if (dm && mti->dependsOnNormals && mti->dependsOnNormals(md)) {		DM_ensure_normals(dm);	}	mti->deformVerts(md, ob, dm, vertexCos, numVerts, flag);}

static void rna_Mesh_normals_split_custom_do(Mesh *mesh, float (*custom_loopnors)[3], const bool use_vertices){	float (*polynors)[3];	short (*clnors)[2];	const int numloops = mesh->totloop;	bool free_polynors = false;	clnors = CustomData_get_layer(&mesh->ldata, CD_CUSTOMLOOPNORMAL);	if (clnors) {		memset(clnors, 0, sizeof(*clnors) * numloops);	}	else {		clnors = CustomData_add_layer(&mesh->ldata, CD_CUSTOMLOOPNORMAL, CD_DEFAULT, NULL, numloops);	}	if (CustomData_has_layer(&mesh->pdata, CD_NORMAL)) {		polynors = CustomData_get_layer(&mesh->pdata, CD_NORMAL);	}	else {		polynors = MEM_mallocN(sizeof(float[3]) * mesh->totpoly, __func__);		BKE_mesh_calc_normals_poly(		            mesh->mvert, NULL, mesh->totvert,		            mesh->mloop, mesh->mpoly, mesh->totloop, mesh->totpoly, polynors, false);		free_polynors = true;	}	if (use_vertices) {		BKE_mesh_normals_loop_custom_from_vertices_set(		        mesh->mvert, custom_loopnors, mesh->totvert, mesh->medge, mesh->totedge, mesh->mloop, mesh->totloop,		        mesh->mpoly, (const float (*)[3])polynors, mesh->totpoly, clnors);	}	else {		BKE_mesh_normals_loop_custom_set(		        mesh->mvert, mesh->totvert, mesh->medge, mesh->totedge, mesh->mloop, custom_loopnors, mesh->totloop,		        mesh->mpoly, (const float (*)[3])polynors, mesh->totpoly, clnors);	}	if (free_polynors) {		MEM_freeN(polynors);	}}

bool ImagesExporter::hasImages(Scene *sce){	LinkNode *node;		for (node = this->export_settings->export_set; node; node = node->next) {		Object *ob = (Object *)node->link;		int a;		for (a = 0; a < ob->totcol; a++) {			Material *ma = give_current_material(ob, a + 1);			// no material, but check all of the slots			if (!ma) continue;			int b;			for (b = 0; b < MAX_MTEX; b++) {				MTex *mtex = ma->mtex[b];				if (mtex && mtex->tex && mtex->tex->ima) return true;			}		}		if (ob->type == OB_MESH) {			Mesh *me     = (Mesh *) ob->data;			BKE_mesh_tessface_ensure(me);			bool has_uvs = (bool)CustomData_has_layer(&me->fdata, CD_MTFACE);			if (has_uvs) {				int num_layers = CustomData_number_of_layers(&me->fdata, CD_MTFACE);				for (int a = 0; a < num_layers; a++) {					MTFace *tface = (MTFace *)CustomData_get_layer_n(&me->fdata, CD_MTFACE, a);					Image *img = tface->tpage;					if (img) return true;				}			}		}	}	return false;}

static int navmesh_face_copy_exec(bContext *C, wmOperator *op){	Object *obedit= CTX_data_edit_object(C);	EditMesh *em= BKE_mesh_get_editmesh((Mesh *)obedit->data);	/* do work here */	EditFace *efa_act= EM_get_actFace(em, 0);	if(efa_act) {		if(CustomData_has_layer(&em->fdata, CD_RECAST)) {			EditFace *efa;			int targetPolyIdx= *(int*)CustomData_em_get(&em->fdata, efa_act->data, CD_RECAST);			targetPolyIdx= targetPolyIdx>=0? targetPolyIdx : -targetPolyIdx;			if(targetPolyIdx > 0) {				/* set target poly idx to other selected faces */				for (efa= (EditFace *)em->faces.first; efa; efa= efa->next) {					if((efa->f & SELECT) && efa != efa_act)  {						int* recastDataBlock= (int*)CustomData_em_get(&em->fdata, efa->data, CD_RECAST);						*recastDataBlock= targetPolyIdx;					}				}			}			else {				BKE_report(op->reports, RPT_ERROR, "Active face has no index set");			}		}	}	DAG_id_tag_update((ID*)obedit->data, OB_RECALC_DATA);	WM_event_add_notifier(C, NC_GEOM|ND_DATA, obedit->data);	BKE_mesh_end_editmesh((Mesh*)obedit->data, em);	return OPERATOR_FINISHED;}

void BM_mesh_cd_flag_apply(BMesh *bm, const char cd_flag){	/* CustomData_bmesh_init_pool() must run first */	BLI_assert(bm->vdata.totlayer == 0 || bm->vdata.pool != NULL);	BLI_assert(bm->edata.totlayer == 0 || bm->edata.pool != NULL);	BLI_assert(bm->pdata.totlayer == 0 || bm->pdata.pool != NULL);	if (cd_flag & ME_CDFLAG_VERT_BWEIGHT) {		if (!CustomData_has_layer(&bm->vdata, CD_BWEIGHT)) {			BM_data_layer_add(bm, &bm->vdata, CD_BWEIGHT);		}	}	else {		if (CustomData_has_layer(&bm->vdata, CD_BWEIGHT)) {			BM_data_layer_free(bm, &bm->vdata, CD_BWEIGHT);		}	}	if (cd_flag & ME_CDFLAG_EDGE_BWEIGHT) {		if (!CustomData_has_layer(&bm->edata, CD_BWEIGHT)) {			BM_data_layer_add(bm, &bm->edata, CD_BWEIGHT);		}	}	else {		if (CustomData_has_layer(&bm->edata, CD_BWEIGHT)) {			BM_data_layer_free(bm, &bm->edata, CD_BWEIGHT);		}	}	if (cd_flag & ME_CDFLAG_EDGE_CREASE) {		if (!CustomData_has_layer(&bm->edata, CD_CREASE)) {			BM_data_layer_add(bm, &bm->edata, CD_CREASE);		}	}	else {		if (CustomData_has_layer(&bm->edata, CD_CREASE)) {			BM_data_layer_free(bm, &bm->edata, CD_CREASE);		}	}}

/* only in editmode */static void vgroup_assign_verts(Object *ob, float weight){	EditVert *eve;	bDeformGroup *dg, *eg;	MDeformWeight *newdw;	MDeformVert *dvert;	int	i, done;	dg=BLI_findlink(&ob->defbase, ob->actdef-1);	if(!dg)		return;	if(ob->type == OB_MESH) {		Mesh *me= ob->data;		EditMesh *em = BKE_mesh_get_editmesh(me);		if(!CustomData_has_layer(&em->vdata, CD_MDEFORMVERT))			EM_add_data_layer(em, &em->vdata, CD_MDEFORMVERT);		/* Go through the list of editverts and assign them */		for(eve=em->verts.first; eve; eve=eve->next){			dvert= CustomData_em_get(&em->vdata, eve->data, CD_MDEFORMVERT);			if(dvert && (eve->f & 1)){				done=0;				/* See if this vert already has a reference to this group */				/*		If so: Change its weight */				done=0;				for(i=0; i<dvert->totweight; i++){					eg = BLI_findlink(&ob->defbase, dvert->dw[i].def_nr);					/* Find the actual group */					if(eg==dg){						dvert->dw[i].weight= weight;						done=1;						break;					}			 	}				/*		If not: Add the group and set its weight */				if(!done){					newdw = MEM_callocN(sizeof(MDeformWeight)*(dvert->totweight+1), "deformWeight");					if(dvert->dw){						memcpy(newdw, dvert->dw, sizeof(MDeformWeight)*dvert->totweight);						MEM_freeN(dvert->dw);					}					dvert->dw=newdw;					dvert->dw[dvert->totweight].weight= weight;					dvert->dw[dvert->totweight].def_nr= ob->actdef-1;					dvert->totweight++;				}			}		}		BKE_mesh_end_editmesh(me, em);	}	else if(ob->type == OB_LATTICE) {		Lattice *lt= vgroup_edit_lattice(ob);		BPoint *bp;		int a, tot;				if(lt->dvert==NULL)			ED_vgroup_data_create(&lt->id);				tot= lt->pntsu*lt->pntsv*lt->pntsw;		for(a=0, bp= lt->def; a<tot; a++, bp++) {			if(bp->f1 & SELECT)				ED_vgroup_nr_vert_add(ob, ob->actdef-1, a, weight, WEIGHT_REPLACE);		}	}}

//.........这里部分代码省略.........			maxVerts = totvert  * step_tot;   /* -1 because we're joining back up */		maxEdges = (totvert * step_tot) + /* these are the edges between new verts */		           (totedge * step_tot);  /* -1 because vert edges join */		maxPolys = totedge * step_tot;		screw_ofs = 0.0f;	}	else {		close = 0;		if (step_tot < 3) step_tot = 3;		maxVerts =  totvert  * step_tot; /* -1 because we're joining back up */		maxEdges =  (totvert * (step_tot - 1)) + /* these are the edges between new verts */		           (totedge * step_tot);  /* -1 because vert edges join */		maxPolys =  totedge * (step_tot - 1);	}	if ((ltmd->flag & MOD_SCREW_UV_STRETCH_U) == 0) {		uv_u_scale = (uv_u_scale / (float)ltmd->iter) * (angle / ((float)M_PI * 2.0f));	}		result = CDDM_from_template(dm, (int)maxVerts, (int)maxEdges, 0, (int)maxPolys * 4, (int)maxPolys);		/* copy verts from mesh */	mvert_orig =    dm->getVertArray(dm);	medge_orig =    dm->getEdgeArray(dm);		mvert_new =     result->getVertArray(result);	mpoly_new =     result->getPolyArray(result);	mloop_new =     result->getLoopArray(result);	medge_new =     result->getEdgeArray(result);	if (!CustomData_has_layer(&result->polyData, CD_ORIGINDEX)) {		CustomData_add_layer(&result->polyData, CD_ORIGINDEX, CD_CALLOC, NULL, (int)maxPolys);	}	origindex = CustomData_get_layer(&result->polyData, CD_ORIGINDEX);	DM_copy_vert_data(dm, result, 0, 0, (int)totvert); /* copy first otherwise this overwrites our own vertex normals */	if (mloopuv_layers_tot) {		float zero_co[3] = {0};		plane_from_point_normal_v3(uv_axis_plane, zero_co, axis_vec);	}	if (mloopuv_layers_tot) {		unsigned int uv_lay;		for (uv_lay = 0; uv_lay < mloopuv_layers_tot; uv_lay++) {			mloopuv_layers[uv_lay] = CustomData_get_layer_n(&result->loopData, CD_MLOOPUV, (int)uv_lay);		}		if (ltmd->flag & MOD_SCREW_UV_STRETCH_V) {			for (i = 0, mv_orig = mvert_orig; i < totvert; i++, mv_orig++) {				const float v = dist_squared_to_plane_v3(mv_orig->co, uv_axis_plane);				uv_v_minmax[0] = min_ff(v, uv_v_minmax[0]);				uv_v_minmax[1] = max_ff(v, uv_v_minmax[1]);			}			uv_v_minmax[0] = sqrtf_signed(uv_v_minmax[0]);			uv_v_minmax[1] = sqrtf_signed(uv_v_minmax[1]);		}		uv_v_range_inv = uv_v_minmax[1] - uv_v_minmax[0];		uv_v_range_inv = uv_v_range_inv ? 1.0f / uv_v_range_inv : 0.0f;	}

/* dm must be a CDDerivedMesh */static void displaceModifier_do(        DisplaceModifierData *dmd, Object *ob,        DerivedMesh *dm, float (*vertexCos)[3], int numVerts){	int i;	MVert *mvert;	MDeformVert *dvert;	int direction = dmd->direction;	int defgrp_index;	float (*tex_co)[3];	float weight = 1.0f; /* init value unused but some compilers may complain */	const float delta_fixed = 1.0f - dmd->midlevel;  /* when no texture is used, we fallback to white */	float (*vert_clnors)[3] = NULL;	if (!dmd->texture && dmd->direction == MOD_DISP_DIR_RGB_XYZ) return;	if (dmd->strength == 0.0f) return;	mvert = CDDM_get_verts(dm);	modifier_get_vgroup(ob, dm, dmd->defgrp_name, &dvert, &defgrp_index);	if (dmd->texture) {		tex_co = MEM_callocN(sizeof(*tex_co) * numVerts,		                     "displaceModifier_do tex_co");		get_texture_coords((MappingInfoModifierData *)dmd, ob, dm, vertexCos, tex_co, numVerts);		modifier_init_texture(dmd->modifier.scene, dmd->texture);	}	else {		tex_co = NULL;	}	if (direction == MOD_DISP_DIR_CLNOR) {		CustomData *ldata = dm->getLoopDataLayout(dm);		if (CustomData_has_layer(ldata, CD_CUSTOMLOOPNORMAL)) {			float (*clnors)[3] = NULL;			if ((dm->dirty & DM_DIRTY_NORMALS) || !CustomData_has_layer(ldata, CD_NORMAL)) {				dm->calcLoopNormals(dm, true, (float)M_PI);			}			clnors = CustomData_get_layer(ldata, CD_NORMAL);			vert_clnors = MEM_mallocN(sizeof(*vert_clnors) * (size_t)numVerts, __func__);			BKE_mesh_normals_loop_to_vertex(numVerts, dm->getLoopArray(dm), dm->getNumLoops(dm),			                                (const float (*)[3])clnors, vert_clnors);		}		else {			direction = MOD_DISP_DIR_NOR;		}	}	for (i = 0; i < numVerts; i++) {		TexResult texres;		float strength = dmd->strength;		float delta;		if (dvert) {			weight = defvert_find_weight(dvert + i, defgrp_index);			if (weight == 0.0f) continue;		}		if (dmd->texture) {			texres.nor = NULL;			BKE_texture_get_value(dmd->modifier.scene, dmd->texture, tex_co[i], &texres, false);			delta = texres.tin - dmd->midlevel;		}		else {			delta = delta_fixed;  /* (1.0f - dmd->midlevel) */  /* never changes */		}		if (dvert) strength *= weight;		delta *= strength;		CLAMP(delta, -10000, 10000);		switch (direction) {			case MOD_DISP_DIR_X:				vertexCos[i][0] += delta;				break;			case MOD_DISP_DIR_Y:				vertexCos[i][1] += delta;				break;			case MOD_DISP_DIR_Z:				vertexCos[i][2] += delta;				break;			case MOD_DISP_DIR_RGB_XYZ:				vertexCos[i][0] += (texres.tr - dmd->midlevel) * strength;				vertexCos[i][1] += (texres.tg - dmd->midlevel) * strength;				vertexCos[i][2] += (texres.tb - dmd->midlevel) * strength;				break;			case MOD_DISP_DIR_NOR:				vertexCos[i][0] += delta * (mvert[i].no[0] / 32767.0f);				vertexCos[i][1] += delta * (mvert[i].no[1] / 32767.0f);				vertexCos[i][2] += delta * (mvert[i].no[2] / 32767.0f);				break;			case MOD_DISP_DIR_CLNOR:				madd_v3_v3fl(vertexCos[i], vert_clnors[i], delta);				break;		}//.........这里部分代码省略.........