static DerivedMesh *applyModifier(ModifierData *md, Object *UNUSED(ob),
DerivedMesh *derivedData,
ModifierApplyFlag UNUSED(flag))
{
DerivedMesh *dm = derivedData;
DerivedMesh *result;
BuildModifierData *bmd = (BuildModifierData *) md;
int i, j, k;
int numFaces_dst, numEdges_dst, numLoops_dst = 0;
int *vertMap, *edgeMap, *faceMap;
float frac;
MPoly *mpoly_dst;
MLoop *ml_dst, *ml_src /*, *mloop_dst */;
GHashIterator *hashIter;
/* maps vert indices in old mesh to indices in new mesh */
GHash *vertHash = BLI_ghash_int_new("build ve apply gh");
/* maps edge indices in new mesh to indices in old mesh */
GHash *edgeHash = BLI_ghash_int_new("build ed apply gh");
GHash *edgeHash2 = BLI_ghash_int_new("build ed apply gh");
const int numVert_src = dm->getNumVerts(dm);
const int numEdge_src = dm->getNumEdges(dm);
const int numPoly_src = dm->getNumPolys(dm);
MPoly *mpoly_src = dm->getPolyArray(dm);
MLoop *mloop_src = dm->getLoopArray(dm);
MEdge *medge_src = dm->getEdgeArray(dm);
MVert *mvert_src = dm->getVertArray(dm);
vertMap = MEM_mallocN(sizeof(*vertMap) * numVert_src, "build modifier vertMap");
edgeMap = MEM_mallocN(sizeof(*edgeMap) * numEdge_src, "build modifier edgeMap");
faceMap = MEM_mallocN(sizeof(*faceMap) * numPoly_src, "build modifier faceMap");
#pragma omp parallel sections if (numVert_src + numEdge_src + numPoly_src >= DM_OMP_LIMIT)
{
#pragma omp section
{ range_vn_i(vertMap, numVert_src, 0); }
#pragma omp section
{ range_vn_i(edgeMap, numEdge_src, 0); }
#pragma omp section
{ range_vn_i(faceMap, numPoly_src, 0); }
}
frac = (BKE_scene_frame_get(md->scene) - bmd->start) / bmd->length;
CLAMP(frac, 0.0f, 1.0f);
numFaces_dst = numPoly_src * frac;
numEdges_dst = numEdge_src * frac;
/* if there's at least one face, build based on faces */
if (numFaces_dst) {
MPoly *mpoly, *mp;
MLoop *ml, *mloop;
MEdge *medge;
if (bmd->randomize) {
BLI_array_randomize(faceMap, sizeof(*faceMap),
numPoly_src, bmd->seed);
}
/* get the set of all vert indices that will be in the final mesh,
* mapped to the new indices
*/
mpoly = mpoly_src;
mloop = mloop_src;
for (i = 0; i < numFaces_dst; i++) {
mp = mpoly + faceMap[i];
ml = mloop + mp->loopstart;
for (j = 0; j < mp->totloop; j++, ml++) {
if (!BLI_ghash_haskey(vertHash, SET_INT_IN_POINTER(ml->v)))
BLI_ghash_insert(vertHash, SET_INT_IN_POINTER(ml->v),
SET_INT_IN_POINTER(BLI_ghash_size(vertHash)));
}
numLoops_dst += mp->totloop;
}
/* get the set of edges that will be in the new mesh (i.e. all edges
* that have both verts in the new mesh)
*/
medge = medge_src;
for (i = 0; i < numEdge_src; i++) {
MEdge *me = medge + i;
if (BLI_ghash_haskey(vertHash, SET_INT_IN_POINTER(me->v1)) &&
BLI_ghash_haskey(vertHash, SET_INT_IN_POINTER(me->v2)))
{
j = BLI_ghash_size(edgeHash);
BLI_ghash_insert(edgeHash, SET_INT_IN_POINTER(j),
SET_INT_IN_POINTER(i));
BLI_ghash_insert(edgeHash2, SET_INT_IN_POINTER(i),
SET_INT_IN_POINTER(j));
}
}
}
else if (numEdges_dst) {
MEdge *medge, *me;
if (bmd->randomize)
BLI_array_randomize(edgeMap, sizeof(*edgeMap),
numEdge_src, bmd->seed);
/* get the set of all vert indices that will be in the final mesh,
* mapped to the new indices
*/
medge = medge_src;
for (i = 0; i < numEdges_dst; i++) {
me = medge + edgeMap[i];
if (!BLI_ghash_haskey(vertHash, SET_INT_IN_POINTER(me->v1))) {
BLI_ghash_insert(vertHash, SET_INT_IN_POINTER(me->v1),
SET_INT_IN_POINTER(BLI_ghash_size(vertHash)));
}
if (!BLI_ghash_haskey(vertHash, SET_INT_IN_POINTER(me->v2))) {
BLI_ghash_insert(vertHash, SET_INT_IN_POINTER(me->v2), SET_INT_IN_POINTER(BLI_ghash_size(vertHash)));
}
}
/* get the set of edges that will be in the new mesh */
for (i = 0; i < numEdges_dst; i++) {
j = BLI_ghash_size(edgeHash);
BLI_ghash_insert(edgeHash, SET_INT_IN_POINTER(j),
SET_INT_IN_POINTER(edgeMap[i]));
BLI_ghash_insert(edgeHash2, SET_INT_IN_POINTER(edgeMap[i]),
SET_INT_IN_POINTER(j));
}
}
else {
int numVerts = numVert_src * frac;
if (bmd->randomize) {
BLI_array_randomize(vertMap, sizeof(*vertMap),
numVert_src, bmd->seed);
}
/* get the set of all vert indices that will be in the final mesh,
* mapped to the new indices
*/
for (i = 0; i < numVerts; i++) {
BLI_ghash_insert(vertHash, SET_INT_IN_POINTER(vertMap[i]), SET_INT_IN_POINTER(i));
}
}
/* now we know the number of verts, edges and faces, we can create
* the mesh
*/
result = CDDM_from_template(dm, BLI_ghash_size(vertHash),
BLI_ghash_size(edgeHash), 0, numLoops_dst, numFaces_dst);
/* copy the vertices across */
for (hashIter = BLI_ghashIterator_new(vertHash);
BLI_ghashIterator_done(hashIter) == false;
BLI_ghashIterator_step(hashIter)
)
{
MVert source;
MVert *dest;
int oldIndex = GET_INT_FROM_POINTER(BLI_ghashIterator_getKey(hashIter));
int newIndex = GET_INT_FROM_POINTER(BLI_ghashIterator_getValue(hashIter));
source = mvert_src[oldIndex];
dest = CDDM_get_vert(result, newIndex);
DM_copy_vert_data(dm, result, oldIndex, newIndex, 1);
*dest = source;
}
BLI_ghashIterator_free(hashIter);
/* copy the edges across, remapping indices */
for (i = 0; i < BLI_ghash_size(edgeHash); i++) {
MEdge source;
MEdge *dest;
int oldIndex = GET_INT_FROM_POINTER(BLI_ghash_lookup(edgeHash, SET_INT_IN_POINTER(i)));
source = medge_src[oldIndex];
dest = CDDM_get_edge(result, i);
source.v1 = GET_INT_FROM_POINTER(BLI_ghash_lookup(vertHash, SET_INT_IN_POINTER(source.v1)));
source.v2 = GET_INT_FROM_POINTER(BLI_ghash_lookup(vertHash, SET_INT_IN_POINTER(source.v2)));
DM_copy_edge_data(dm, result, oldIndex, i, 1);
*dest = source;
}
mpoly_dst = CDDM_get_polys(result);
/* mloop_dst = */ ml_dst = CDDM_get_loops(result);
/* copy the faces across, remapping indices */
k = 0;
for (i = 0; i < numFaces_dst; i++) {
MPoly *source;
MPoly *dest;
source = mpoly_src + faceMap[i];
dest = mpoly_dst + i;
DM_copy_poly_data(dm, result, faceMap[i], i, 1);
*dest = *source;
dest->loopstart = k;
DM_copy_loop_data(dm, result, source->loopstart, dest->loopstart, dest->totloop);
ml_src = mloop_src + source->loopstart;
for (j = 0; j < source->totloop; j++, k++, ml_src++, ml_dst++) {
ml_dst->v = GET_INT_FROM_POINTER(BLI_ghash_lookup(vertHash, SET_INT_IN_POINTER(ml_src->v)));
ml_dst->e = GET_INT_FROM_POINTER(BLI_ghash_lookup(edgeHash2, SET_INT_IN_POINTER(ml_src->e)));
}
}
BLI_ghash_free(vertHash, NULL, NULL);
BLI_ghash_free(edgeHash, NULL, NULL);
BLI_ghash_free(edgeHash2, NULL, NULL);
MEM_freeN(vertMap);
MEM_freeN(edgeMap);
MEM_freeN(faceMap);
if (dm->dirty & DM_DIRTY_NORMALS) {
result->dirty |= DM_DIRTY_NORMALS;
}
return result;
}
static DerivedMesh *applyModifier(ModifierData *md, Object *UNUSED(ob),
DerivedMesh *derivedData,
int UNUSED(useRenderParams),
int UNUSED(isFinalCalc))
{
DerivedMesh *dm = derivedData;
DerivedMesh *result;
BuildModifierData *bmd = (BuildModifierData*) md;
int i;
int numFaces, numEdges;
int *vertMap, *edgeMap, *faceMap;
float frac;
GHashIterator *hashIter;
/* maps vert indices in old mesh to indices in new mesh */
GHash *vertHash = BLI_ghash_new(BLI_ghashutil_inthash,
BLI_ghashutil_intcmp, "build ve apply gh");
/* maps edge indices in new mesh to indices in old mesh */
GHash *edgeHash = BLI_ghash_new(BLI_ghashutil_inthash,
BLI_ghashutil_intcmp, "build ed apply gh");
const int maxVerts= dm->getNumVerts(dm);
const int maxEdges= dm->getNumEdges(dm);
const int maxFaces= dm->getNumFaces(dm);
vertMap = MEM_callocN(sizeof(*vertMap) * maxVerts, "build modifier vertMap");
for(i = 0; i < maxVerts; ++i) vertMap[i] = i;
edgeMap = MEM_callocN(sizeof(*edgeMap) * maxEdges, "build modifier edgeMap");
for(i = 0; i < maxEdges; ++i) edgeMap[i] = i;
faceMap = MEM_callocN(sizeof(*faceMap) * maxFaces, "build modifier faceMap");
for(i = 0; i < maxFaces; ++i) faceMap[i] = i;
frac = (BKE_curframe(md->scene) - bmd->start) / bmd->length;
CLAMP(frac, 0.0f, 1.0f);
numFaces = dm->getNumFaces(dm) * frac;
numEdges = dm->getNumEdges(dm) * frac;
/* if there's at least one face, build based on faces */
if(numFaces) {
if(bmd->randomize)
BLI_array_randomize(faceMap, sizeof(*faceMap),
maxFaces, bmd->seed);
/* get the set of all vert indices that will be in the final mesh,
* mapped to the new indices
*/
for(i = 0; i < numFaces; ++i) {
MFace mf;
dm->getFace(dm, faceMap[i], &mf);
if(!BLI_ghash_haskey(vertHash, SET_INT_IN_POINTER(mf.v1)))
BLI_ghash_insert(vertHash, SET_INT_IN_POINTER(mf.v1),
SET_INT_IN_POINTER(BLI_ghash_size(vertHash)));
if(!BLI_ghash_haskey(vertHash, SET_INT_IN_POINTER(mf.v2)))
BLI_ghash_insert(vertHash, SET_INT_IN_POINTER(mf.v2),
SET_INT_IN_POINTER(BLI_ghash_size(vertHash)));
if(!BLI_ghash_haskey(vertHash, SET_INT_IN_POINTER(mf.v3)))
BLI_ghash_insert(vertHash, SET_INT_IN_POINTER(mf.v3),
SET_INT_IN_POINTER(BLI_ghash_size(vertHash)));
if(mf.v4 && !BLI_ghash_haskey(vertHash, SET_INT_IN_POINTER(mf.v4)))
BLI_ghash_insert(vertHash, SET_INT_IN_POINTER(mf.v4),
SET_INT_IN_POINTER(BLI_ghash_size(vertHash)));
}
/* get the set of edges that will be in the new mesh (i.e. all edges
* that have both verts in the new mesh)
*/
for(i = 0; i < maxEdges; ++i) {
MEdge me;
dm->getEdge(dm, i, &me);
if(BLI_ghash_haskey(vertHash, SET_INT_IN_POINTER(me.v1))
&& BLI_ghash_haskey(vertHash, SET_INT_IN_POINTER(me.v2)))
BLI_ghash_insert(edgeHash,
SET_INT_IN_POINTER(BLI_ghash_size(edgeHash)), SET_INT_IN_POINTER(i));
}
} else if(numEdges) {
if(bmd->randomize)
BLI_array_randomize(edgeMap, sizeof(*edgeMap),
maxEdges, bmd->seed);
/* get the set of all vert indices that will be in the final mesh,
* mapped to the new indices
*/
for(i = 0; i < numEdges; ++i) {
MEdge me;
dm->getEdge(dm, edgeMap[i], &me);
if(!BLI_ghash_haskey(vertHash, SET_INT_IN_POINTER(me.v1)))
BLI_ghash_insert(vertHash, SET_INT_IN_POINTER(me.v1),
SET_INT_IN_POINTER(BLI_ghash_size(vertHash)));
if(!BLI_ghash_haskey(vertHash, SET_INT_IN_POINTER(me.v2)))
BLI_ghash_insert(vertHash, SET_INT_IN_POINTER(me.v2),
SET_INT_IN_POINTER(BLI_ghash_size(vertHash)));
}
/* get the set of edges that will be in the new mesh
*/
for(i = 0; i < numEdges; ++i) {
MEdge me;
dm->getEdge(dm, edgeMap[i], &me);
BLI_ghash_insert(edgeHash, SET_INT_IN_POINTER(BLI_ghash_size(edgeHash)),
SET_INT_IN_POINTER(edgeMap[i]));
}
} else {
int numVerts = dm->getNumVerts(dm) * frac;
if(bmd->randomize)
BLI_array_randomize(vertMap, sizeof(*vertMap),
maxVerts, bmd->seed);
/* get the set of all vert indices that will be in the final mesh,
* mapped to the new indices
*/
for(i = 0; i < numVerts; ++i)
BLI_ghash_insert(vertHash, SET_INT_IN_POINTER(vertMap[i]), SET_INT_IN_POINTER(i));
}
/* now we know the number of verts, edges and faces, we can create
* the mesh
*/
result = CDDM_from_template(dm, BLI_ghash_size(vertHash),
BLI_ghash_size(edgeHash), numFaces);
/* copy the vertices across */
for( hashIter = BLI_ghashIterator_new(vertHash);
!BLI_ghashIterator_isDone(hashIter);
BLI_ghashIterator_step(hashIter)
) {
MVert source;
MVert *dest;
int oldIndex = GET_INT_FROM_POINTER(BLI_ghashIterator_getKey(hashIter));
int newIndex = GET_INT_FROM_POINTER(BLI_ghashIterator_getValue(hashIter));
dm->getVert(dm, oldIndex, &source);
dest = CDDM_get_vert(result, newIndex);
DM_copy_vert_data(dm, result, oldIndex, newIndex, 1);
*dest = source;
}
BLI_ghashIterator_free(hashIter);
/* copy the edges across, remapping indices */
for(i = 0; i < BLI_ghash_size(edgeHash); ++i) {
MEdge source;
MEdge *dest;
int oldIndex = GET_INT_FROM_POINTER(BLI_ghash_lookup(edgeHash, SET_INT_IN_POINTER(i)));
dm->getEdge(dm, oldIndex, &source);
dest = CDDM_get_edge(result, i);
source.v1 = GET_INT_FROM_POINTER(BLI_ghash_lookup(vertHash, SET_INT_IN_POINTER(source.v1)));
source.v2 = GET_INT_FROM_POINTER(BLI_ghash_lookup(vertHash, SET_INT_IN_POINTER(source.v2)));
DM_copy_edge_data(dm, result, oldIndex, i, 1);
*dest = source;
}
/* copy the faces across, remapping indices */
for(i = 0; i < numFaces; ++i) {
MFace source;
MFace *dest;
int orig_v4;
dm->getFace(dm, faceMap[i], &source);
dest = CDDM_get_face(result, i);
orig_v4 = source.v4;
source.v1 = GET_INT_FROM_POINTER(BLI_ghash_lookup(vertHash, SET_INT_IN_POINTER(source.v1)));
source.v2 = GET_INT_FROM_POINTER(BLI_ghash_lookup(vertHash, SET_INT_IN_POINTER(source.v2)));
source.v3 = GET_INT_FROM_POINTER(BLI_ghash_lookup(vertHash, SET_INT_IN_POINTER(source.v3)));
if(source.v4)
source.v4 = GET_INT_FROM_POINTER(BLI_ghash_lookup(vertHash, SET_INT_IN_POINTER(source.v4)));
DM_copy_face_data(dm, result, faceMap[i], i, 1);
*dest = source;
test_index_face(dest, &result->faceData, i, (orig_v4 ? 4 : 3));
}
CDDM_calc_normals(result);
BLI_ghash_free(vertHash, NULL, NULL);
BLI_ghash_free(edgeHash, NULL, NULL);
MEM_freeN(vertMap);
MEM_freeN(edgeMap);
MEM_freeN(faceMap);
return result;
}
static DerivedMesh *doMirrorOnAxis(MirrorModifierData *mmd,
Object *ob,
DerivedMesh *dm,
int axis)
{
int i;
float tolerance = mmd->tolerance;
DerivedMesh *result;
int numVerts, numEdges, numFaces;
int maxVerts = dm->getNumVerts(dm);
int maxEdges = dm->getNumEdges(dm);
int maxFaces = dm->getNumFaces(dm);
int *flip_map= NULL, flip_map_len= 0;
int do_vgroup_mirr= (mmd->flag & MOD_MIR_VGROUP);
unsigned int (*indexMap)[2];
float mtx[4][4], imtx[4][4];
numVerts = numEdges = numFaces = 0;
indexMap = MEM_mallocN(sizeof(*indexMap) * maxVerts, "indexmap");
result = CDDM_from_template(dm, maxVerts * 2, maxEdges * 2, maxFaces * 2);
if (do_vgroup_mirr) {
flip_map= defgroup_flip_map(ob, &flip_map_len, FALSE);
if(flip_map == NULL)
do_vgroup_mirr= 0;
}
if (mmd->mirror_ob) {
float obinv[4][4];
invert_m4_m4(obinv, mmd->mirror_ob->obmat);
mult_m4_m4m4(mtx, obinv, ob->obmat);
invert_m4_m4(imtx, mtx);
}
for(i = 0; i < maxVerts; i++) {
MVert inMV;
MVert *mv = CDDM_get_vert(result, numVerts);
int isShared;
float co[3];
dm->getVert(dm, i, &inMV);
copy_v3_v3(co, inMV.co);
if (mmd->mirror_ob) {
mul_m4_v3(mtx, co);
}
if(mmd->flag & MOD_MIR_NO_MERGE)
isShared = 0;
else
isShared = ABS(co[axis])<=tolerance;
/* Because the topology result (# of vertices) must be the same if
* the mesh data is overridden by vertex cos, have to calc sharedness
* based on original coordinates. This is why we test before copy.
*/
DM_copy_vert_data(dm, result, i, numVerts, 1);
*mv = inMV;
indexMap[i][0] = numVerts;
indexMap[i][1] = !isShared;
numVerts++;
if(isShared ) {
co[axis] = 0.0f;
if (mmd->mirror_ob) {
mul_m4_v3(imtx, co);
}
copy_v3_v3(mv->co, co);
mv->flag |= ME_VERT_MERGED;
}
else {
MVert *mv2 = CDDM_get_vert(result, numVerts);
DM_copy_vert_data(dm, result, i, numVerts, 1);
*mv2 = *mv;
co[axis] = -co[axis];
if (mmd->mirror_ob) {
mul_m4_v3(imtx, co);
}
copy_v3_v3(mv2->co, co);
if (do_vgroup_mirr) {
MDeformVert *dvert= DM_get_vert_data(result, numVerts, CD_MDEFORMVERT);
if(dvert) {
defvert_flip(dvert, flip_map, flip_map_len);
}
}
numVerts++;
}
}
for(i = 0; i < maxEdges; i++) {
MEdge inMED;
MEdge *med = CDDM_get_edge(result, numEdges);
dm->getEdge(dm, i, &inMED);
DM_copy_edge_data(dm, result, i, numEdges, 1);
*med = inMED;
numEdges++;
med->v1 = indexMap[inMED.v1][0];
med->v2 = indexMap[inMED.v2][0];
if(indexMap[inMED.v1][1] || indexMap[inMED.v2][1]) {
MEdge *med2 = CDDM_get_edge(result, numEdges);
DM_copy_edge_data(dm, result, i, numEdges, 1);
*med2 = *med;
numEdges++;
med2->v1 += indexMap[inMED.v1][1];
med2->v2 += indexMap[inMED.v2][1];
}
}
for(i = 0; i < maxFaces; i++) {
MFace inMF;
MFace *mf = CDDM_get_face(result, numFaces);
dm->getFace(dm, i, &inMF);
DM_copy_face_data(dm, result, i, numFaces, 1);
*mf = inMF;
numFaces++;
mf->v1 = indexMap[inMF.v1][0];
mf->v2 = indexMap[inMF.v2][0];
mf->v3 = indexMap[inMF.v3][0];
mf->v4 = indexMap[inMF.v4][0];
if ( indexMap[inMF.v1][1] ||
indexMap[inMF.v2][1] ||
indexMap[inMF.v3][1] ||
(mf->v4 && indexMap[inMF.v4][1]))
{
MFace *mf2 = CDDM_get_face(result, numFaces);
static int corner_indices[4] = {2, 1, 0, 3};
DM_copy_face_data(dm, result, i, numFaces, 1);
*mf2 = *mf;
mf2->v1 += indexMap[inMF.v1][1];
mf2->v2 += indexMap[inMF.v2][1];
mf2->v3 += indexMap[inMF.v3][1];
if(inMF.v4) mf2->v4 += indexMap[inMF.v4][1];
/* mirror UVs if enabled */
if(mmd->flag & (MOD_MIR_MIRROR_U | MOD_MIR_MIRROR_V)) {
MTFace *tf = result->getFaceData(result, numFaces, CD_MTFACE);
if(tf) {
int j;
for(j = 0; j < 4; ++j) {
if(mmd->flag & MOD_MIR_MIRROR_U)
tf->uv[j][0] = 1.0f - tf->uv[j][0];
if(mmd->flag & MOD_MIR_MIRROR_V)
tf->uv[j][1] = 1.0f - tf->uv[j][1];
}
}
}
/* Flip face normal */
SWAP(unsigned int, mf2->v1, mf2->v3);
DM_swap_face_data(result, numFaces, corner_indices);
test_index_face(mf2, &result->faceData, numFaces, inMF.v4?4:3);
numFaces++;
}
}
static DerivedMesh *applyModifier(ModifierData *md, Object *ob,
DerivedMesh *derivedData,
int UNUSED(useRenderParams),
int UNUSED(isFinalCalc))
{
MaskModifierData *mmd= (MaskModifierData *)md;
DerivedMesh *dm= derivedData, *result= NULL;
GHash *vertHash=NULL, *edgeHash, *faceHash;
GHashIterator *hashIter;
MDeformVert *dvert= NULL, *dv;
int numFaces=0, numEdges=0, numVerts=0;
int maxVerts, maxEdges, maxFaces;
int i;
/* Overview of Method:
* 1. Get the vertices that are in the vertexgroup of interest
* 2. Filter out unwanted geometry (i.e. not in vertexgroup), by populating mappings with new vs old indices
* 3. Make a new mesh containing only the mapping data
*/
/* get original number of verts, edges, and faces */
maxVerts= dm->getNumVerts(dm);
maxEdges= dm->getNumEdges(dm);
maxFaces= dm->getNumFaces(dm);
/* check if we can just return the original mesh
* - must have verts and therefore verts assigned to vgroups to do anything useful
*/
if ( !(ELEM(mmd->mode, MOD_MASK_MODE_ARM, MOD_MASK_MODE_VGROUP)) ||
(maxVerts == 0) || (ob->defbase.first == NULL) )
{
return derivedData;
}
/* if mode is to use selected armature bones, aggregate the bone groups */
if (mmd->mode == MOD_MASK_MODE_ARM) /* --- using selected bones --- */
{
GHash *vgroupHash;
Object *oba= mmd->ob_arm;
bPoseChannel *pchan;
bDeformGroup *def;
char *bone_select_array;
int bone_select_tot= 0;
/* check that there is armature object with bones to use, otherwise return original mesh */
if (ELEM3(NULL, mmd->ob_arm, mmd->ob_arm->pose, ob->defbase.first))
return derivedData;
bone_select_array= MEM_mallocN(BLI_countlist(&ob->defbase) * sizeof(char), "mask array");
for (i = 0, def = ob->defbase.first; def; def = def->next, i++)
{
if (((pchan= get_pose_channel(oba->pose, def->name)) && pchan->bone && (pchan->bone->flag & BONE_SELECTED)))
{
bone_select_array[i]= TRUE;
bone_select_tot++;
}
else {
bone_select_array[i]= FALSE;
}
}
/* hashes for finding mapping of:
* - vgroups to indices -> vgroupHash (string, int)
* - bones to vgroup indices -> boneHash (index of vgroup, dummy)
*/
vgroupHash= BLI_ghash_new(BLI_ghashutil_strhash, BLI_ghashutil_strcmp, "mask vgroup gh");
/* build mapping of names of vertex groups to indices */
for (i = 0, def = ob->defbase.first; def; def = def->next, i++)
BLI_ghash_insert(vgroupHash, def->name, SET_INT_IN_POINTER(i));
/* if no bones selected, free hashes and return original mesh */
if (bone_select_tot == 0)
{
BLI_ghash_free(vgroupHash, NULL, NULL);
MEM_freeN(bone_select_array);
return derivedData;
}
/* repeat the previous check, but for dverts */
dvert= dm->getVertDataArray(dm, CD_MDEFORMVERT);
if (dvert == NULL)
{
BLI_ghash_free(vgroupHash, NULL, NULL);
MEM_freeN(bone_select_array);
return derivedData;
}
/* hashes for quickly providing a mapping from old to new - use key=oldindex, value=newindex */
vertHash= BLI_ghash_new(BLI_ghashutil_inthash, BLI_ghashutil_intcmp, "mask vert gh");
/* add vertices which exist in vertexgroups into vertHash for filtering */
for (i= 0, dv= dvert; i < maxVerts; i++, dv++)
{
MDeformWeight *dw= dv->dw;
int j;
for (j= dv->totweight; j > 0; j--, dw++)
{
if (bone_select_array[dw->def_nr])
{
if(dw->weight != 0.0f) {
break;
}
}
}
/* check if include vert in vertHash */
if (mmd->flag & MOD_MASK_INV) {
/* if this vert is in the vgroup, don't include it in vertHash */
if (dw) continue;
}
else {
/* if this vert isn't in the vgroup, don't include it in vertHash */
if (!dw) continue;
}
/* add to ghash for verts (numVerts acts as counter for mapping) */
BLI_ghash_insert(vertHash, SET_INT_IN_POINTER(i), SET_INT_IN_POINTER(numVerts));
numVerts++;
}
/* free temp hashes */
BLI_ghash_free(vgroupHash, NULL, NULL);
MEM_freeN(bone_select_array);
}
else /* --- Using Nominated VertexGroup only --- */
{
int defgrp_index = defgroup_name_index(ob, mmd->vgroup);
/* get dverts */
if (defgrp_index >= 0)
dvert = dm->getVertDataArray(dm, CD_MDEFORMVERT);
/* if no vgroup (i.e. dverts) found, return the initial mesh */
if ((defgrp_index < 0) || (dvert == NULL))
return dm;
/* hashes for quickly providing a mapping from old to new - use key=oldindex, value=newindex */
vertHash= BLI_ghash_new(BLI_ghashutil_inthash, BLI_ghashutil_intcmp, "mask vert2 bh");
/* add vertices which exist in vertexgroup into ghash for filtering */
for (i= 0, dv= dvert; i < maxVerts; i++, dv++)
{
const int weight_set= defvert_find_weight(dv, defgrp_index) != 0.0f;
/* check if include vert in vertHash */
if (mmd->flag & MOD_MASK_INV) {
/* if this vert is in the vgroup, don't include it in vertHash */
if (weight_set) continue;
}
else {
/* if this vert isn't in the vgroup, don't include it in vertHash */
if (!weight_set) continue;
}
/* add to ghash for verts (numVerts acts as counter for mapping) */
BLI_ghash_insert(vertHash, SET_INT_IN_POINTER(i), SET_INT_IN_POINTER(numVerts));
numVerts++;
}
}
/* hashes for quickly providing a mapping from old to new - use key=oldindex, value=newindex */
edgeHash= BLI_ghash_new(BLI_ghashutil_inthash, BLI_ghashutil_intcmp, "mask ed2 gh");
faceHash= BLI_ghash_new(BLI_ghashutil_inthash, BLI_ghashutil_intcmp, "mask fa2 gh");
/* loop over edges and faces, and do the same thing to
* ensure that they only reference existing verts
*/
for (i = 0; i < maxEdges; i++)
{
MEdge me;
dm->getEdge(dm, i, &me);
/* only add if both verts will be in new mesh */
if ( BLI_ghash_haskey(vertHash, SET_INT_IN_POINTER(me.v1)) &&
BLI_ghash_haskey(vertHash, SET_INT_IN_POINTER(me.v2)) )
{
BLI_ghash_insert(edgeHash, SET_INT_IN_POINTER(i), SET_INT_IN_POINTER(numEdges));
numEdges++;
}
}
for (i = 0; i < maxFaces; i++)
{
MFace mf;
dm->getFace(dm, i, &mf);
/* all verts must be available */
if ( BLI_ghash_haskey(vertHash, SET_INT_IN_POINTER(mf.v1)) &&
BLI_ghash_haskey(vertHash, SET_INT_IN_POINTER(mf.v2)) &&
BLI_ghash_haskey(vertHash, SET_INT_IN_POINTER(mf.v3)) &&
(mf.v4==0 || BLI_ghash_haskey(vertHash, SET_INT_IN_POINTER(mf.v4))) )
{
BLI_ghash_insert(faceHash, SET_INT_IN_POINTER(i), SET_INT_IN_POINTER(numFaces));
numFaces++;
}
}
/* now we know the number of verts, edges and faces,
* we can create the new (reduced) mesh
*/
result = CDDM_from_template(dm, numVerts, numEdges, numFaces);
/* using ghash-iterators, map data into new mesh */
/* vertices */
for ( hashIter = BLI_ghashIterator_new(vertHash);
!BLI_ghashIterator_isDone(hashIter);
BLI_ghashIterator_step(hashIter) )
{
MVert source;
MVert *dest;
int oldIndex = GET_INT_FROM_POINTER(BLI_ghashIterator_getKey(hashIter));
int newIndex = GET_INT_FROM_POINTER(BLI_ghashIterator_getValue(hashIter));
dm->getVert(dm, oldIndex, &source);
dest = CDDM_get_vert(result, newIndex);
DM_copy_vert_data(dm, result, oldIndex, newIndex, 1);
*dest = source;
}
BLI_ghashIterator_free(hashIter);
/* edges */
for ( hashIter = BLI_ghashIterator_new(edgeHash);
!BLI_ghashIterator_isDone(hashIter);
BLI_ghashIterator_step(hashIter) )
{
MEdge source;
MEdge *dest;
int oldIndex = GET_INT_FROM_POINTER(BLI_ghashIterator_getKey(hashIter));
int newIndex = GET_INT_FROM_POINTER(BLI_ghashIterator_getValue(hashIter));
dm->getEdge(dm, oldIndex, &source);
dest = CDDM_get_edge(result, newIndex);
source.v1 = GET_INT_FROM_POINTER(BLI_ghash_lookup(vertHash, SET_INT_IN_POINTER(source.v1)));
source.v2 = GET_INT_FROM_POINTER(BLI_ghash_lookup(vertHash, SET_INT_IN_POINTER(source.v2)));
DM_copy_edge_data(dm, result, oldIndex, newIndex, 1);
*dest = source;
}
BLI_ghashIterator_free(hashIter);
/* faces */
for ( hashIter = BLI_ghashIterator_new(faceHash);
!BLI_ghashIterator_isDone(hashIter);
BLI_ghashIterator_step(hashIter) )
{
MFace source;
MFace *dest;
int oldIndex = GET_INT_FROM_POINTER(BLI_ghashIterator_getKey(hashIter));
int newIndex = GET_INT_FROM_POINTER(BLI_ghashIterator_getValue(hashIter));
int orig_v4;
dm->getFace(dm, oldIndex, &source);
dest = CDDM_get_face(result, newIndex);
orig_v4 = source.v4;
source.v1 = GET_INT_FROM_POINTER(BLI_ghash_lookup(vertHash, SET_INT_IN_POINTER(source.v1)));
source.v2 = GET_INT_FROM_POINTER(BLI_ghash_lookup(vertHash, SET_INT_IN_POINTER(source.v2)));
source.v3 = GET_INT_FROM_POINTER(BLI_ghash_lookup(vertHash, SET_INT_IN_POINTER(source.v3)));
if (source.v4)
source.v4 = GET_INT_FROM_POINTER(BLI_ghash_lookup(vertHash, SET_INT_IN_POINTER(source.v4)));
DM_copy_face_data(dm, result, oldIndex, newIndex, 1);
*dest = source;
test_index_face(dest, &result->faceData, newIndex, (orig_v4 ? 4 : 3));
}
BLI_ghashIterator_free(hashIter);
/* recalculate normals */
CDDM_calc_normals(result);
/* free hashes */
BLI_ghash_free(vertHash, NULL, NULL);
BLI_ghash_free(edgeHash, NULL, NULL);
BLI_ghash_free(faceHash, NULL, NULL);
/* return the new mesh */
return result;
}