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 ¶m = 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;
}
/* can we edit colors for this mesh?*/
int EM_vertColorCheck(EditMesh *em)
{
/* some of these checks could be a touch overkill */
if ( (em) &&
(em->faces.first) &&
(CustomData_has_layer(&em->fdata, CD_MCOL)))
return 1;
return 0;
}
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);
}
void BKE_editmesh_update_linked_customdata(BMEditMesh *em)
{
BMesh *bm = em->bm;
int act;
if (CustomData_has_layer(&bm->pdata, CD_MTEXPOLY)) {
act = CustomData_get_active_layer(&bm->pdata, CD_MTEXPOLY);
CustomData_set_layer_active(&bm->ldata, CD_MLOOPUV, act);
act = CustomData_get_render_layer(&bm->pdata, CD_MTEXPOLY);
CustomData_set_layer_render(&bm->ldata, CD_MLOOPUV, act);
act = CustomData_get_clone_layer(&bm->pdata, CD_MTEXPOLY);
CustomData_set_layer_clone(&bm->ldata, CD_MLOOPUV, act);
act = CustomData_get_stencil_layer(&bm->pdata, CD_MTEXPOLY);
CustomData_set_layer_stencil(&bm->ldata, CD_MLOOPUV, act);
}
}
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(<->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);
}
}
}
static DerivedMesh *applyModifier(ModifierData *md, Object *ob,
DerivedMesh *derivedData,
ModifierApplyFlag flag)
{
DerivedMesh *dm = derivedData;
DerivedMesh *result;
ScrewModifierData *ltmd = (ScrewModifierData *) md;
const int useRenderParams = flag & MOD_APPLY_RENDER;
int *origindex;
int mpoly_index = 0;
unsigned int step;
unsigned int i, j;
unsigned int i1, i2;
unsigned int step_tot = useRenderParams ? ltmd->render_steps : ltmd->steps;
const bool do_flip = ltmd->flag & MOD_SCREW_NORMAL_FLIP ? 1 : 0;
const int quad_ord[4] = {
do_flip ? 3 : 0,
do_flip ? 2 : 1,
do_flip ? 1 : 2,
do_flip ? 0 : 3,
};
const int quad_ord_ofs[4] = {
do_flip ? 2 : 0,
do_flip ? 1 : 1,
do_flip ? 0 : 2,
do_flip ? 3 : 3,
};
unsigned int maxVerts = 0, maxEdges = 0, maxPolys = 0;
const unsigned int totvert = (unsigned int)dm->getNumVerts(dm);
const unsigned int totedge = (unsigned int)dm->getNumEdges(dm);
const unsigned int totpoly = (unsigned int)dm->getNumPolys(dm);
unsigned int *edge_poly_map = NULL; /* orig edge to orig poly */
unsigned int *vert_loop_map = NULL; /* orig vert to orig loop */
/* UV Coords */
const unsigned int mloopuv_layers_tot = (unsigned int)CustomData_number_of_layers(&dm->loopData, CD_MLOOPUV);
MLoopUV **mloopuv_layers = BLI_array_alloca(mloopuv_layers, mloopuv_layers_tot);
float uv_u_scale;
float uv_v_minmax[2] = {FLT_MAX, -FLT_MAX};
float uv_v_range_inv;
float uv_axis_plane[4];
char axis_char = 'X';
bool close;
float angle = ltmd->angle;
float screw_ofs = ltmd->screw_ofs;
float axis_vec[3] = {0.0f, 0.0f, 0.0f};
float tmp_vec1[3], tmp_vec2[3];
float mat3[3][3];
float mtx_tx[4][4]; /* transform the coords by an object relative to this objects transformation */
float mtx_tx_inv[4][4]; /* inverted */
float mtx_tmp_a[4][4];
unsigned int vc_tot_linked = 0;
short other_axis_1, other_axis_2;
const float *tmpf1, *tmpf2;
unsigned int edge_offset;
MPoly *mpoly_orig, *mpoly_new, *mp_new;
MLoop *mloop_orig, *mloop_new, *ml_new;
MEdge *medge_orig, *med_orig, *med_new, *med_new_firstloop, *medge_new;
MVert *mvert_new, *mvert_orig, *mv_orig, *mv_new, *mv_new_base;
ScrewVertConnect *vc, *vc_tmp, *vert_connect = NULL;
const char mpoly_flag = (ltmd->flag & MOD_SCREW_SMOOTH_SHADING) ? ME_SMOOTH : 0;
/* don't do anything? */
if (!totvert)
return CDDM_from_template(dm, 0, 0, 0, 0, 0);
switch (ltmd->axis) {
case 0:
other_axis_1 = 1;
other_axis_2 = 2;
break;
case 1:
other_axis_1 = 0;
other_axis_2 = 2;
break;
default: /* 2, use default to quiet warnings */
other_axis_1 = 0;
other_axis_2 = 1;
break;
}
axis_vec[ltmd->axis] = 1.0f;
if (ltmd->ob_axis) {
/* calc the matrix relative to the axis object */
invert_m4_m4(mtx_tmp_a, ob->obmat);
copy_m4_m4(mtx_tx_inv, ltmd->ob_axis->obmat);
mul_m4_m4m4(mtx_tx, mtx_tmp_a, mtx_tx_inv);
/* calc the axis vec */
mul_mat3_m4_v3(mtx_tx, axis_vec); /* only rotation component */
normalize_v3(axis_vec);
/* screw */
if (ltmd->flag & MOD_SCREW_OBJECT_OFFSET) {
/* find the offset along this axis relative to this objects matrix */
float totlen = len_v3(mtx_tx[3]);
if (totlen != 0.0f) {
float zero[3] = {0.0f, 0.0f, 0.0f};
float cp[3];
screw_ofs = closest_to_line_v3(cp, mtx_tx[3], zero, axis_vec);
}
else {
screw_ofs = 0.0f;
}
}
/* angle */
#if 0 /* cant incluide this, not predictable enough, though quite fun. */
if (ltmd->flag & MOD_SCREW_OBJECT_ANGLE) {
float mtx3_tx[3][3];
copy_m3_m4(mtx3_tx, mtx_tx);
float vec[3] = {0, 1, 0};
float cross1[3];
float cross2[3];
cross_v3_v3v3(cross1, vec, axis_vec);
mul_v3_m3v3(cross2, mtx3_tx, cross1);
{
float c1[3];
float c2[3];
float axis_tmp[3];
cross_v3_v3v3(c1, cross2, axis_vec);
cross_v3_v3v3(c2, axis_vec, c1);
angle = angle_v3v3(cross1, c2);
cross_v3_v3v3(axis_tmp, cross1, c2);
normalize_v3(axis_tmp);
if (len_v3v3(axis_tmp, axis_vec) > 1.0f)
angle = -angle;
}
}
#endif
}
else {
/* exis char is used by i_rotate*/
axis_char = (char)(axis_char + ltmd->axis); /* 'X' + axis */
/* useful to be able to use the axis vec in some cases still */
zero_v3(axis_vec);
axis_vec[ltmd->axis] = 1.0f;
}
/* apply the multiplier */
angle *= (float)ltmd->iter;
screw_ofs *= (float)ltmd->iter;
uv_u_scale = 1.0f / (float)(step_tot);
/* multiplying the steps is a bit tricky, this works best */
step_tot = ((step_tot + 1) * ltmd->iter) - (ltmd->iter - 1);
/* will the screw be closed?
* Note! smaller then FLT_EPSILON * 100 gives problems with float precision so its never closed. */
if (fabsf(screw_ofs) <= (FLT_EPSILON * 100.0f) &&
fabsf(fabsf(angle) - ((float)M_PI * 2.0f)) <= (FLT_EPSILON * 100.0f))
{
close = 1;
step_tot--;
if (step_tot < 3) step_tot = 3;
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;
}
/* Set the locations of the first set of verts */
mv_new = mvert_new;
mv_orig = mvert_orig;
/* Copy the first set of edges */
med_orig = medge_orig;
med_new = medge_new;
for (i = 0; i < totedge; i++, med_orig++, med_new++) {
med_new->v1 = med_orig->v1;
med_new->v2 = med_orig->v2;
med_new->crease = med_orig->crease;
med_new->flag = med_orig->flag & ~ME_LOOSEEDGE;
}
/* build polygon -> edge map */
if (totpoly) {
MPoly *mp_orig;
mpoly_orig = dm->getPolyArray(dm);
mloop_orig = dm->getLoopArray(dm);
edge_poly_map = MEM_mallocN(sizeof(*edge_poly_map) * totedge, __func__);
memset(edge_poly_map, 0xff, sizeof(*edge_poly_map) * totedge);
vert_loop_map = MEM_mallocN(sizeof(*vert_loop_map) * totvert, __func__);
memset(vert_loop_map, 0xff, sizeof(*vert_loop_map) * totvert);
for (i = 0, mp_orig = mpoly_orig; i < totpoly; i++, mp_orig++) {
unsigned int loopstart = (unsigned int)mp_orig->loopstart;
unsigned int loopend = loopstart + (unsigned int)mp_orig->totloop;
MLoop *ml_orig = &mloop_orig[loopstart];
unsigned int k;
for (k = loopstart; k < loopend; k++, ml_orig++) {
edge_poly_map[ml_orig->e] = i;
vert_loop_map[ml_orig->v] = k;
/* also order edges based on faces */
if (medge_new[ml_orig->e].v1 != ml_orig->v) {
SWAP(unsigned int, medge_new[ml_orig->e].v1, medge_new[ml_orig->e].v2);
}
}
}
}
void get_texture_coords(MappingInfoModifierData *dmd, Object *ob,
DerivedMesh *dm,
float (*co)[3], float (*texco)[3],
int numVerts)
{
int i;
int texmapping = dmd->texmapping;
float mapob_imat[4][4];
if (texmapping == MOD_DISP_MAP_OBJECT) {
if (dmd->map_object)
invert_m4_m4(mapob_imat, dmd->map_object->obmat);
else /* if there is no map object, default to local */
texmapping = MOD_DISP_MAP_LOCAL;
}
/* UVs need special handling, since they come from faces */
if (texmapping == MOD_DISP_MAP_UV) {
if (CustomData_has_layer(&dm->loopData, CD_MLOOPUV)) {
MPoly *mpoly = dm->getPolyArray(dm);
MPoly *mp;
MLoop *mloop = dm->getLoopArray(dm);
char *done = MEM_callocN(sizeof(*done) * numVerts,
"get_texture_coords done");
int numPolys = dm->getNumPolys(dm);
char uvname[MAX_CUSTOMDATA_LAYER_NAME];
MLoopUV *mloop_uv;
CustomData_validate_layer_name(&dm->loopData, CD_MLOOPUV, dmd->uvlayer_name, uvname);
mloop_uv = CustomData_get_layer_named(&dm->loopData, CD_MLOOPUV, uvname);
/* verts are given the UV from the first face that uses them */
for (i = 0, mp = mpoly; i < numPolys; ++i, ++mp) {
unsigned int fidx = mp->totloop - 1;
do {
unsigned int lidx = mp->loopstart + fidx;
unsigned int vidx = mloop[lidx].v;
if (done[vidx] == 0) {
/* remap UVs from [0, 1] to [-1, 1] */
texco[vidx][0] = (mloop_uv[lidx].uv[0] * 2.0f) - 1.0f;
texco[vidx][1] = (mloop_uv[lidx].uv[1] * 2.0f) - 1.0f;
done[vidx] = 1;
}
} while (fidx--);
}
MEM_freeN(done);
return;
}
else /* if there are no UVs, default to local */
texmapping = MOD_DISP_MAP_LOCAL;
}
for (i = 0; i < numVerts; ++i, ++co, ++texco) {
switch (texmapping) {
case MOD_DISP_MAP_LOCAL:
copy_v3_v3(*texco, *co);
break;
case MOD_DISP_MAP_GLOBAL:
mul_v3_m4v3(*texco, ob->obmat, *co);
break;
case MOD_DISP_MAP_OBJECT:
mul_v3_m4v3(*texco, ob->obmat, *co);
mul_m4_v3(mapob_imat, *texco);
break;
}
}
}
static void wavemod_get_texture_coords(WaveModifierData *wmd, Object *ob,
DerivedMesh *dm,
float (*co)[3], float (*texco)[3],
int numVerts)
{
int i;
int texmapping = wmd->texmapping;
if(texmapping == MOD_WAV_MAP_OBJECT) {
if(wmd->map_object)
invert_m4_m4(wmd->map_object->imat, wmd->map_object->obmat);
else /* if there is no map object, default to local */
texmapping = MOD_WAV_MAP_LOCAL;
}
/* UVs need special handling, since they come from faces */
if(texmapping == MOD_WAV_MAP_UV) {
if(CustomData_has_layer(&dm->faceData, CD_MTFACE)) {
MFace *mface = dm->getFaceArray(dm);
MFace *mf;
char *done = MEM_callocN(sizeof(*done) * numVerts,
"get_texture_coords done");
int numFaces = dm->getNumFaces(dm);
char uvname[32];
MTFace *tf;
validate_layer_name(&dm->faceData, CD_MTFACE, wmd->uvlayer_name, uvname);
tf = CustomData_get_layer_named(&dm->faceData, CD_MTFACE, uvname);
/* verts are given the UV from the first face that uses them */
for(i = 0, mf = mface; i < numFaces; ++i, ++mf, ++tf) {
if(!done[mf->v1]) {
texco[mf->v1][0] = tf->uv[0][0];
texco[mf->v1][1] = tf->uv[0][1];
texco[mf->v1][2] = 0;
done[mf->v1] = 1;
}
if(!done[mf->v2]) {
texco[mf->v2][0] = tf->uv[1][0];
texco[mf->v2][1] = tf->uv[1][1];
texco[mf->v2][2] = 0;
done[mf->v2] = 1;
}
if(!done[mf->v3]) {
texco[mf->v3][0] = tf->uv[2][0];
texco[mf->v3][1] = tf->uv[2][1];
texco[mf->v3][2] = 0;
done[mf->v3] = 1;
}
if(!done[mf->v4]) {
texco[mf->v4][0] = tf->uv[3][0];
texco[mf->v4][1] = tf->uv[3][1];
texco[mf->v4][2] = 0;
done[mf->v4] = 1;
}
}
/* remap UVs from [0, 1] to [-1, 1] */
for(i = 0; i < numVerts; ++i) {
texco[i][0] = texco[i][0] * 2 - 1;
texco[i][1] = texco[i][1] * 2 - 1;
}
MEM_freeN(done);
return;
} else /* if there are no UVs, default to local */
texmapping = MOD_WAV_MAP_LOCAL;
}
for(i = 0; i < numVerts; ++i, ++co, ++texco) {
switch(texmapping) {
case MOD_WAV_MAP_LOCAL:
copy_v3_v3(*texco, *co);
break;
case MOD_WAV_MAP_GLOBAL:
mul_v3_m4v3(*texco, ob->obmat, *co);
break;
case MOD_WAV_MAP_OBJECT:
mul_v3_m4v3(*texco, ob->obmat, *co);
mul_m4_v3(wmd->map_object->imat, *texco);
break;
}
}
}
/* 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;
}
}
if (tex_co) {
MEM_freeN(tex_co);
}
if (vert_clnors) {
MEM_freeN(vert_clnors);
}
}