Cleanup: Remove unused DerivedMesh functions
Remove functions and function pointers that were never set or never used at all. The "tessface" original index handling in `subsurf_ccg.c` can be removed because the data was never used.
This commit is contained in:
parent
ac3324f197
commit
23775f3914
Notes:
blender-bot
2023-02-14 05:36:11 +01:00
Referenced by commit c4f159cfcd, Cleanup: Add back comment removed in recent commit
|
|
@ -158,7 +158,6 @@ struct DerivedMesh {
|
|||
*/
|
||||
struct MVert *(*getVertArray)(DerivedMesh *dm);
|
||||
struct MEdge *(*getEdgeArray)(DerivedMesh *dm);
|
||||
struct MFace *(*getTessFaceArray)(DerivedMesh *dm);
|
||||
struct MLoop *(*getLoopArray)(DerivedMesh *dm);
|
||||
struct MPoly *(*getPolyArray)(DerivedMesh *dm);
|
||||
|
||||
|
|
@ -167,7 +166,6 @@ struct DerivedMesh {
|
|||
*/
|
||||
void (*copyVertArray)(DerivedMesh *dm, struct MVert *r_vert);
|
||||
void (*copyEdgeArray)(DerivedMesh *dm, struct MEdge *r_edge);
|
||||
void (*copyTessFaceArray)(DerivedMesh *dm, struct MFace *r_face);
|
||||
void (*copyLoopArray)(DerivedMesh *dm, struct MLoop *r_loop);
|
||||
void (*copyPolyArray)(DerivedMesh *dm, struct MPoly *r_poly);
|
||||
|
||||
|
|
@ -176,37 +174,18 @@ struct DerivedMesh {
|
|||
*/
|
||||
struct MVert *(*dupVertArray)(DerivedMesh *dm);
|
||||
struct MEdge *(*dupEdgeArray)(DerivedMesh *dm);
|
||||
struct MFace *(*dupTessFaceArray)(DerivedMesh *dm);
|
||||
struct MLoop *(*dupLoopArray)(DerivedMesh *dm);
|
||||
struct MPoly *(*dupPolyArray)(DerivedMesh *dm);
|
||||
|
||||
/** Return a pointer to a single element of vert/edge/face custom data
|
||||
* from the derived mesh (this gives a pointer to the actual data, not
|
||||
* a copy)
|
||||
*/
|
||||
void *(*getVertData)(DerivedMesh *dm, int index, int type);
|
||||
void *(*getEdgeData)(DerivedMesh *dm, int index, int type);
|
||||
void *(*getTessFaceData)(DerivedMesh *dm, int index, int type);
|
||||
void *(*getPolyData)(DerivedMesh *dm, int index, int type);
|
||||
|
||||
/** Return a pointer to the entire array of vert/edge/face custom data
|
||||
* from the derived mesh (this gives a pointer to the actual data, not
|
||||
* a copy)
|
||||
*/
|
||||
void *(*getVertDataArray)(DerivedMesh *dm, int type);
|
||||
void *(*getEdgeDataArray)(DerivedMesh *dm, int type);
|
||||
void *(*getTessFaceDataArray)(DerivedMesh *dm, int type);
|
||||
void *(*getLoopDataArray)(DerivedMesh *dm, int type);
|
||||
void *(*getPolyDataArray)(DerivedMesh *dm, int type);
|
||||
|
||||
/** Retrieves the base CustomData structures for
|
||||
* verts/edges/tessfaces/loops/faces. */
|
||||
CustomData *(*getVertDataLayout)(DerivedMesh *dm);
|
||||
CustomData *(*getEdgeDataLayout)(DerivedMesh *dm);
|
||||
CustomData *(*getTessFaceDataLayout)(DerivedMesh *dm);
|
||||
CustomData *(*getLoopDataLayout)(DerivedMesh *dm);
|
||||
CustomData *(*getPolyDataLayout)(DerivedMesh *dm);
|
||||
|
||||
/** Optional grid access for subsurf */
|
||||
int (*getNumGrids)(DerivedMesh *dm);
|
||||
int (*getGridSize)(DerivedMesh *dm);
|
||||
|
|
@ -225,11 +204,6 @@ struct DerivedMesh {
|
|||
|
||||
/** Get smooth vertex normal, undefined if index is not valid */
|
||||
void (*getVertNo)(DerivedMesh *dm, int index, float r_no[3]);
|
||||
void (*getPolyNo)(DerivedMesh *dm, int index, float r_no[3]);
|
||||
|
||||
/** Get a map of vertices to faces
|
||||
*/
|
||||
const struct MeshElemMap *(*getPolyMap)(struct Object *ob, DerivedMesh *dm);
|
||||
|
||||
/** Release reference to the DerivedMesh. This function decides internally
|
||||
* if the DerivedMesh will be freed, or cached for later use. */
|
||||
|
|
@ -297,25 +271,8 @@ void DM_set_only_copy(DerivedMesh *dm, const struct CustomData_MeshMasks *mask);
|
|||
|
||||
void DM_add_vert_layer(struct DerivedMesh *dm, int type, eCDAllocType alloctype, void *layer);
|
||||
void DM_add_edge_layer(struct DerivedMesh *dm, int type, eCDAllocType alloctype, void *layer);
|
||||
void DM_add_tessface_layer(struct DerivedMesh *dm, int type, eCDAllocType alloctype, void *layer);
|
||||
void DM_add_loop_layer(DerivedMesh *dm, int type, eCDAllocType alloctype, void *layer);
|
||||
void DM_add_poly_layer(struct DerivedMesh *dm, int type, eCDAllocType alloctype, void *layer);
|
||||
|
||||
/* -------------------------------------------------------------------- */
|
||||
/** \name Custom Data Access Functions
|
||||
*
|
||||
* \return pointer to data from first layer which matches type
|
||||
* if they return NULL for valid indices, data doesn't exist.
|
||||
* \note these return pointers - any change modifies the internals of the mesh.
|
||||
* \{ */
|
||||
|
||||
void *DM_get_vert_data(struct DerivedMesh *dm, int index, int type);
|
||||
void *DM_get_edge_data(struct DerivedMesh *dm, int index, int type);
|
||||
void *DM_get_tessface_data(struct DerivedMesh *dm, int index, int type);
|
||||
void *DM_get_poly_data(struct DerivedMesh *dm, int index, int type);
|
||||
|
||||
/** \} */
|
||||
|
||||
/* -------------------------------------------------------------------- */
|
||||
/** \name Custom Data Layer Access Functions
|
||||
*
|
||||
|
|
@ -326,7 +283,6 @@ void *DM_get_poly_data(struct DerivedMesh *dm, int index, int type);
|
|||
|
||||
void *DM_get_vert_data_layer(struct DerivedMesh *dm, int type);
|
||||
void *DM_get_edge_data_layer(struct DerivedMesh *dm, int type);
|
||||
void *DM_get_tessface_data_layer(struct DerivedMesh *dm, int type);
|
||||
void *DM_get_poly_data_layer(struct DerivedMesh *dm, int type);
|
||||
void *DM_get_loop_data_layer(struct DerivedMesh *dm, int type);
|
||||
|
||||
|
|
|
|||
|
|
@ -127,30 +127,6 @@ static MEdge *dm_getEdgeArray(DerivedMesh *dm)
|
|||
return medge;
|
||||
}
|
||||
|
||||
static MFace *dm_getTessFaceArray(DerivedMesh *dm)
|
||||
{
|
||||
MFace *mface = (MFace *)CustomData_get_layer(&dm->faceData, CD_MFACE);
|
||||
|
||||
if (!mface) {
|
||||
int numTessFaces = dm->getNumTessFaces(dm);
|
||||
|
||||
if (!numTessFaces) {
|
||||
/* Do not add layer if there's no elements in it, this leads to issues later when
|
||||
* this layer is needed with non-zero size, but currently CD stuff does not check
|
||||
* for requested layer size on creation and just returns layer which was previously
|
||||
* added (sergey) */
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
mface = (MFace *)CustomData_add_layer(
|
||||
&dm->faceData, CD_MFACE, CD_CALLOC, nullptr, numTessFaces);
|
||||
CustomData_set_layer_flag(&dm->faceData, CD_MFACE, CD_FLAG_TEMPORARY);
|
||||
dm->copyTessFaceArray(dm, mface);
|
||||
}
|
||||
|
||||
return mface;
|
||||
}
|
||||
|
||||
static MLoop *dm_getLoopArray(DerivedMesh *dm)
|
||||
{
|
||||
MLoop *mloop = (MLoop *)CustomData_get_layer(&dm->loopData, CD_MLOOP);
|
||||
|
|
@ -203,18 +179,6 @@ static MEdge *dm_dupEdgeArray(DerivedMesh *dm)
|
|||
return tmp;
|
||||
}
|
||||
|
||||
static MFace *dm_dupFaceArray(DerivedMesh *dm)
|
||||
{
|
||||
MFace *tmp = (MFace *)MEM_malloc_arrayN(
|
||||
dm->getNumTessFaces(dm), sizeof(*tmp), "dm_dupFaceArray tmp");
|
||||
|
||||
if (tmp) {
|
||||
dm->copyTessFaceArray(dm, tmp);
|
||||
}
|
||||
|
||||
return tmp;
|
||||
}
|
||||
|
||||
static MLoop *dm_dupLoopArray(DerivedMesh *dm)
|
||||
{
|
||||
MLoop *tmp = (MLoop *)MEM_malloc_arrayN(
|
||||
|
|
@ -270,42 +234,15 @@ static const MLoopTri *dm_getLoopTriArray(DerivedMesh *dm)
|
|||
return looptri;
|
||||
}
|
||||
|
||||
static CustomData *dm_getVertCData(DerivedMesh *dm)
|
||||
{
|
||||
return &dm->vertData;
|
||||
}
|
||||
|
||||
static CustomData *dm_getEdgeCData(DerivedMesh *dm)
|
||||
{
|
||||
return &dm->edgeData;
|
||||
}
|
||||
|
||||
static CustomData *dm_getTessFaceCData(DerivedMesh *dm)
|
||||
{
|
||||
return &dm->faceData;
|
||||
}
|
||||
|
||||
static CustomData *dm_getLoopCData(DerivedMesh *dm)
|
||||
{
|
||||
return &dm->loopData;
|
||||
}
|
||||
|
||||
static CustomData *dm_getPolyCData(DerivedMesh *dm)
|
||||
{
|
||||
return &dm->polyData;
|
||||
}
|
||||
|
||||
void DM_init_funcs(DerivedMesh *dm)
|
||||
{
|
||||
/* default function implementations */
|
||||
dm->getVertArray = dm_getVertArray;
|
||||
dm->getEdgeArray = dm_getEdgeArray;
|
||||
dm->getTessFaceArray = dm_getTessFaceArray;
|
||||
dm->getLoopArray = dm_getLoopArray;
|
||||
dm->getPolyArray = dm_getPolyArray;
|
||||
dm->dupVertArray = dm_dupVertArray;
|
||||
dm->dupEdgeArray = dm_dupEdgeArray;
|
||||
dm->dupTessFaceArray = dm_dupFaceArray;
|
||||
dm->dupLoopArray = dm_dupLoopArray;
|
||||
dm->dupPolyArray = dm_dupPolyArray;
|
||||
|
||||
|
|
@ -314,19 +251,8 @@ void DM_init_funcs(DerivedMesh *dm)
|
|||
/* subtypes handle getting actual data */
|
||||
dm->getNumLoopTri = dm_getNumLoopTri;
|
||||
|
||||
dm->getVertDataLayout = dm_getVertCData;
|
||||
dm->getEdgeDataLayout = dm_getEdgeCData;
|
||||
dm->getTessFaceDataLayout = dm_getTessFaceCData;
|
||||
dm->getLoopDataLayout = dm_getLoopCData;
|
||||
dm->getPolyDataLayout = dm_getPolyCData;
|
||||
|
||||
dm->getVertData = DM_get_vert_data;
|
||||
dm->getEdgeData = DM_get_edge_data;
|
||||
dm->getTessFaceData = DM_get_tessface_data;
|
||||
dm->getPolyData = DM_get_poly_data;
|
||||
dm->getVertDataArray = DM_get_vert_data_layer;
|
||||
dm->getEdgeDataArray = DM_get_edge_data_layer;
|
||||
dm->getTessFaceDataArray = DM_get_tessface_data_layer;
|
||||
dm->getPolyDataArray = DM_get_poly_data_layer;
|
||||
dm->getLoopDataArray = DM_get_loop_data_layer;
|
||||
}
|
||||
|
|
@ -544,45 +470,11 @@ void DM_add_edge_layer(DerivedMesh *dm, int type, eCDAllocType alloctype, void *
|
|||
CustomData_add_layer(&dm->edgeData, type, alloctype, layer, dm->numEdgeData);
|
||||
}
|
||||
|
||||
void DM_add_tessface_layer(DerivedMesh *dm, int type, eCDAllocType alloctype, void *layer)
|
||||
{
|
||||
CustomData_add_layer(&dm->faceData, type, alloctype, layer, dm->numTessFaceData);
|
||||
}
|
||||
|
||||
void DM_add_loop_layer(DerivedMesh *dm, int type, eCDAllocType alloctype, void *layer)
|
||||
{
|
||||
CustomData_add_layer(&dm->loopData, type, alloctype, layer, dm->numLoopData);
|
||||
}
|
||||
|
||||
void DM_add_poly_layer(DerivedMesh *dm, int type, eCDAllocType alloctype, void *layer)
|
||||
{
|
||||
CustomData_add_layer(&dm->polyData, type, alloctype, layer, dm->numPolyData);
|
||||
}
|
||||
|
||||
void *DM_get_vert_data(DerivedMesh *dm, int index, int type)
|
||||
{
|
||||
BLI_assert(index >= 0 && index < dm->getNumVerts(dm));
|
||||
return CustomData_get(&dm->vertData, index, type);
|
||||
}
|
||||
|
||||
void *DM_get_edge_data(DerivedMesh *dm, int index, int type)
|
||||
{
|
||||
BLI_assert(index >= 0 && index < dm->getNumEdges(dm));
|
||||
return CustomData_get(&dm->edgeData, index, type);
|
||||
}
|
||||
|
||||
void *DM_get_tessface_data(DerivedMesh *dm, int index, int type)
|
||||
{
|
||||
BLI_assert(index >= 0 && index < dm->getNumTessFaces(dm));
|
||||
return CustomData_get(&dm->faceData, index, type);
|
||||
}
|
||||
|
||||
void *DM_get_poly_data(DerivedMesh *dm, int index, int type)
|
||||
{
|
||||
BLI_assert(index >= 0 && index < dm->getNumPolys(dm));
|
||||
return CustomData_get(&dm->polyData, index, type);
|
||||
}
|
||||
|
||||
void *DM_get_vert_data_layer(DerivedMesh *dm, int type)
|
||||
{
|
||||
if (type == CD_MVERT) {
|
||||
|
|
@ -601,15 +493,6 @@ void *DM_get_edge_data_layer(DerivedMesh *dm, int type)
|
|||
return CustomData_get_layer(&dm->edgeData, type);
|
||||
}
|
||||
|
||||
void *DM_get_tessface_data_layer(DerivedMesh *dm, int type)
|
||||
{
|
||||
if (type == CD_MFACE) {
|
||||
return dm->getTessFaceArray(dm);
|
||||
}
|
||||
|
||||
return CustomData_get_layer(&dm->faceData, type);
|
||||
}
|
||||
|
||||
void *DM_get_poly_data_layer(DerivedMesh *dm, int type)
|
||||
{
|
||||
return CustomData_get_layer(&dm->polyData, type);
|
||||
|
|
|
|||
|
|
@ -116,12 +116,6 @@ static void cdDM_copyEdgeArray(DerivedMesh *dm, MEdge *r_edge)
|
|||
memcpy(r_edge, cddm->medge, sizeof(*r_edge) * dm->numEdgeData);
|
||||
}
|
||||
|
||||
static void cdDM_copyTessFaceArray(DerivedMesh *dm, MFace *r_face)
|
||||
{
|
||||
CDDerivedMesh *cddm = (CDDerivedMesh *)dm;
|
||||
memcpy(r_face, cddm->mface, sizeof(*r_face) * dm->numTessFaceData);
|
||||
}
|
||||
|
||||
static void cdDM_copyLoopArray(DerivedMesh *dm, MLoop *r_loop)
|
||||
{
|
||||
CDDerivedMesh *cddm = (CDDerivedMesh *)dm;
|
||||
|
|
@ -147,20 +141,6 @@ static void cdDM_getVertNo(DerivedMesh *dm, int index, float r_no[3])
|
|||
copy_v3_v3(r_no, cddm->vert_normals[index]);
|
||||
}
|
||||
|
||||
static const MeshElemMap *cdDM_getPolyMap(Object *ob, DerivedMesh *dm)
|
||||
{
|
||||
CDDerivedMesh *cddm = (CDDerivedMesh *)dm;
|
||||
|
||||
if (!cddm->pmap && ob->type == OB_MESH) {
|
||||
Mesh *me = ob->data;
|
||||
|
||||
BKE_mesh_vert_poly_map_create(
|
||||
&cddm->pmap, &cddm->pmap_mem, me->mpoly, me->mloop, me->totvert, me->totpoly, me->totloop);
|
||||
}
|
||||
|
||||
return cddm->pmap;
|
||||
}
|
||||
|
||||
static void cdDM_recalc_looptri(DerivedMesh *dm)
|
||||
{
|
||||
CDDerivedMesh *cddm = (CDDerivedMesh *)dm;
|
||||
|
|
@ -216,24 +196,17 @@ static CDDerivedMesh *cdDM_create(const char *desc)
|
|||
|
||||
dm->copyVertArray = cdDM_copyVertArray;
|
||||
dm->copyEdgeArray = cdDM_copyEdgeArray;
|
||||
dm->copyTessFaceArray = cdDM_copyTessFaceArray;
|
||||
dm->copyLoopArray = cdDM_copyLoopArray;
|
||||
dm->copyPolyArray = cdDM_copyPolyArray;
|
||||
|
||||
dm->getVertData = DM_get_vert_data;
|
||||
dm->getEdgeData = DM_get_edge_data;
|
||||
dm->getTessFaceData = DM_get_tessface_data;
|
||||
dm->getVertDataArray = DM_get_vert_data_layer;
|
||||
dm->getEdgeDataArray = DM_get_edge_data_layer;
|
||||
dm->getTessFaceDataArray = DM_get_tessface_data_layer;
|
||||
|
||||
dm->recalcLoopTri = cdDM_recalc_looptri;
|
||||
|
||||
dm->getVertCo = cdDM_getVertCo;
|
||||
dm->getVertNo = cdDM_getVertNo;
|
||||
|
||||
dm->getPolyMap = cdDM_getPolyMap;
|
||||
|
||||
dm->release = cdDM_release;
|
||||
|
||||
return cddm;
|
||||
|
|
|
|||
|
|
@ -580,7 +580,6 @@ static void ss_sync_ccg_from_derivedmesh(CCGSubSurf *ss,
|
|||
#endif
|
||||
MVert *mvert = dm->getVertArray(dm);
|
||||
MEdge *medge = dm->getEdgeArray(dm);
|
||||
// MFace *mface = dm->getTessFaceArray(dm); /* UNUSED */
|
||||
MVert *mv;
|
||||
MEdge *me;
|
||||
MLoop *mloop = dm->getLoopArray(dm), *ml;
|
||||
|
|
@ -1129,44 +1128,6 @@ static void ccgDM_copyFinalEdgeArray(DerivedMesh *dm, MEdge *medge)
|
|||
}
|
||||
}
|
||||
|
||||
static void ccgDM_copyFinalFaceArray(DerivedMesh *dm, MFace *mface)
|
||||
{
|
||||
CCGDerivedMesh *ccgdm = (CCGDerivedMesh *)dm;
|
||||
CCGSubSurf *ss = ccgdm->ss;
|
||||
int index;
|
||||
int totface;
|
||||
int gridSize = ccgSubSurf_getGridSize(ss);
|
||||
int edgeSize = ccgSubSurf_getEdgeSize(ss);
|
||||
int i = 0;
|
||||
DMFlagMat *faceFlags = ccgdm->faceFlags;
|
||||
|
||||
totface = dm->getNumTessFaces(dm);
|
||||
for (index = 0; index < totface; index++) {
|
||||
CCGFace *f = ccgdm->faceMap[index].face;
|
||||
int x, y, S, numVerts = ccgSubSurf_getFaceNumVerts(f);
|
||||
/* keep types in sync with MFace, avoid many conversions */
|
||||
char flag = (faceFlags) ? faceFlags[index].flag : ME_SMOOTH;
|
||||
short mat_nr = (faceFlags) ? faceFlags[index].mat_nr : 0;
|
||||
|
||||
for (S = 0; S < numVerts; S++) {
|
||||
for (y = 0; y < gridSize - 1; y++) {
|
||||
for (x = 0; x < gridSize - 1; x++) {
|
||||
MFace *mf = &mface[i];
|
||||
mf->v1 = getFaceIndex(ss, f, S, x + 0, y + 0, edgeSize, gridSize);
|
||||
mf->v2 = getFaceIndex(ss, f, S, x + 0, y + 1, edgeSize, gridSize);
|
||||
mf->v3 = getFaceIndex(ss, f, S, x + 1, y + 1, edgeSize, gridSize);
|
||||
mf->v4 = getFaceIndex(ss, f, S, x + 1, y + 0, edgeSize, gridSize);
|
||||
mf->mat_nr = mat_nr;
|
||||
mf->flag = flag;
|
||||
mf->edcode = 0;
|
||||
|
||||
i++;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
typedef struct CopyFinalLoopArrayData {
|
||||
CCGDerivedMesh *ccgdm;
|
||||
MLoop *mloop;
|
||||
|
|
@ -1457,63 +1418,6 @@ static void *ccgDM_get_edge_data_layer(DerivedMesh *dm, int type)
|
|||
return DM_get_edge_data_layer(dm, type);
|
||||
}
|
||||
|
||||
static void *ccgDM_get_tessface_data_layer(DerivedMesh *dm, int type)
|
||||
{
|
||||
if (type == CD_ORIGINDEX) {
|
||||
/* create origindex on demand to save memory */
|
||||
int *origindex;
|
||||
|
||||
/* Avoid re-creation if the layer exists already */
|
||||
origindex = DM_get_tessface_data_layer(dm, CD_ORIGINDEX);
|
||||
if (origindex) {
|
||||
return origindex;
|
||||
}
|
||||
|
||||
DM_add_tessface_layer(dm, CD_ORIGINDEX, CD_CALLOC, NULL);
|
||||
origindex = DM_get_tessface_data_layer(dm, CD_ORIGINDEX);
|
||||
|
||||
/* silly loop counting up */
|
||||
range_vn_i(origindex, dm->getNumTessFaces(dm), 0);
|
||||
|
||||
return origindex;
|
||||
}
|
||||
|
||||
if (type == CD_TESSLOOPNORMAL) {
|
||||
/* Create tessloopnormal on demand to save memory. */
|
||||
/* Note that since tessellated face corners are the same a loops in CCGDM,
|
||||
* and since all faces have four loops/corners, we can simplify the code
|
||||
* here by converting tessloopnormals from 'short (*)[4][3]' to 'short (*)[3]'. */
|
||||
short(*tlnors)[3];
|
||||
|
||||
/* Avoid re-creation if the layer exists already */
|
||||
tlnors = DM_get_tessface_data_layer(dm, CD_TESSLOOPNORMAL);
|
||||
if (!tlnors) {
|
||||
float(*lnors)[3];
|
||||
short(*tlnors_it)[3];
|
||||
const int numLoops = ccgDM_getNumLoops(dm);
|
||||
int i;
|
||||
|
||||
lnors = dm->getLoopDataArray(dm, CD_NORMAL);
|
||||
if (!lnors) {
|
||||
return NULL;
|
||||
}
|
||||
|
||||
DM_add_tessface_layer(dm, CD_TESSLOOPNORMAL, CD_CALLOC, NULL);
|
||||
tlnors = tlnors_it = (short(*)[3])DM_get_tessface_data_layer(dm, CD_TESSLOOPNORMAL);
|
||||
|
||||
/* With ccgdm, we have a simple one to one mapping between loops
|
||||
* and tessellated face corners. */
|
||||
for (i = 0; i < numLoops; i++, tlnors_it++, lnors++) {
|
||||
normal_float_to_short_v3(*tlnors_it, *lnors);
|
||||
}
|
||||
}
|
||||
|
||||
return tlnors;
|
||||
}
|
||||
|
||||
return DM_get_tessface_data_layer(dm, type);
|
||||
}
|
||||
|
||||
static void *ccgDM_get_poly_data_layer(DerivedMesh *dm, int type)
|
||||
{
|
||||
if (type == CD_ORIGINDEX) {
|
||||
|
|
@ -1551,46 +1455,6 @@ static void *ccgDM_get_poly_data_layer(DerivedMesh *dm, int type)
|
|||
return DM_get_poly_data_layer(dm, type);
|
||||
}
|
||||
|
||||
static void *ccgDM_get_vert_data(DerivedMesh *dm, int index, int type)
|
||||
{
|
||||
if (type == CD_ORIGINDEX) {
|
||||
/* ensure creation of CD_ORIGINDEX layer */
|
||||
ccgDM_get_vert_data_layer(dm, type);
|
||||
}
|
||||
|
||||
return DM_get_vert_data(dm, index, type);
|
||||
}
|
||||
|
||||
static void *ccgDM_get_edge_data(DerivedMesh *dm, int index, int type)
|
||||
{
|
||||
if (type == CD_ORIGINDEX) {
|
||||
/* ensure creation of CD_ORIGINDEX layer */
|
||||
ccgDM_get_edge_data_layer(dm, type);
|
||||
}
|
||||
|
||||
return DM_get_edge_data(dm, index, type);
|
||||
}
|
||||
|
||||
static void *ccgDM_get_tessface_data(DerivedMesh *dm, int index, int type)
|
||||
{
|
||||
if (ELEM(type, CD_ORIGINDEX, CD_TESSLOOPNORMAL)) {
|
||||
/* ensure creation of CD_ORIGINDEX/CD_TESSLOOPNORMAL layers */
|
||||
ccgDM_get_tessface_data_layer(dm, type);
|
||||
}
|
||||
|
||||
return DM_get_tessface_data(dm, index, type);
|
||||
}
|
||||
|
||||
static void *ccgDM_get_poly_data(DerivedMesh *dm, int index, int type)
|
||||
{
|
||||
if (type == CD_ORIGINDEX) {
|
||||
/* ensure creation of CD_ORIGINDEX layer */
|
||||
ccgDM_get_tessface_data_layer(dm, type);
|
||||
}
|
||||
|
||||
return DM_get_poly_data(dm, index, type);
|
||||
}
|
||||
|
||||
static int ccgDM_getNumGrids(DerivedMesh *dm)
|
||||
{
|
||||
CCGDerivedMesh *ccgdm = (CCGDerivedMesh *)dm;
|
||||
|
|
@ -1705,25 +1569,6 @@ static BLI_bitmap **ccgDM_getGridHidden(DerivedMesh *dm)
|
|||
return ccgdm->gridHidden;
|
||||
}
|
||||
|
||||
static const MeshElemMap *ccgDM_getPolyMap(Object *ob, DerivedMesh *dm)
|
||||
{
|
||||
CCGDerivedMesh *ccgdm = (CCGDerivedMesh *)dm;
|
||||
|
||||
if (!ccgdm->multires.mmd && !ccgdm->pmap && ob->type == OB_MESH) {
|
||||
Mesh *me = ob->data;
|
||||
|
||||
BKE_mesh_vert_poly_map_create(&ccgdm->pmap,
|
||||
&ccgdm->pmap_mem,
|
||||
me->mpoly,
|
||||
me->mloop,
|
||||
me->totvert,
|
||||
me->totpoly,
|
||||
me->totloop);
|
||||
}
|
||||
|
||||
return ccgdm->pmap;
|
||||
}
|
||||
|
||||
/* WARNING! *MUST* be called in an 'loops_cache_rwlock' protected thread context! */
|
||||
static void ccgDM_recalcLoopTri(DerivedMesh *dm)
|
||||
{
|
||||
|
|
@ -1773,17 +1618,11 @@ static void set_default_ccgdm_callbacks(CCGDerivedMesh *ccgdm)
|
|||
|
||||
ccgdm->dm.copyVertArray = ccgDM_copyFinalVertArray;
|
||||
ccgdm->dm.copyEdgeArray = ccgDM_copyFinalEdgeArray;
|
||||
ccgdm->dm.copyTessFaceArray = ccgDM_copyFinalFaceArray;
|
||||
ccgdm->dm.copyLoopArray = ccgDM_copyFinalLoopArray;
|
||||
ccgdm->dm.copyPolyArray = ccgDM_copyFinalPolyArray;
|
||||
|
||||
ccgdm->dm.getVertData = ccgDM_get_vert_data;
|
||||
ccgdm->dm.getEdgeData = ccgDM_get_edge_data;
|
||||
ccgdm->dm.getTessFaceData = ccgDM_get_tessface_data;
|
||||
ccgdm->dm.getPolyData = ccgDM_get_poly_data;
|
||||
ccgdm->dm.getVertDataArray = ccgDM_get_vert_data_layer;
|
||||
ccgdm->dm.getEdgeDataArray = ccgDM_get_edge_data_layer;
|
||||
ccgdm->dm.getTessFaceDataArray = ccgDM_get_tessface_data_layer;
|
||||
ccgdm->dm.getPolyDataArray = ccgDM_get_poly_data_layer;
|
||||
ccgdm->dm.getNumGrids = ccgDM_getNumGrids;
|
||||
ccgdm->dm.getGridSize = ccgDM_getGridSize;
|
||||
|
|
@ -1792,7 +1631,6 @@ static void set_default_ccgdm_callbacks(CCGDerivedMesh *ccgdm)
|
|||
ccgdm->dm.getGridKey = ccgDM_getGridKey;
|
||||
ccgdm->dm.getGridFlagMats = ccgDM_getGridFlagMats;
|
||||
ccgdm->dm.getGridHidden = ccgDM_getGridHidden;
|
||||
ccgdm->dm.getPolyMap = ccgDM_getPolyMap;
|
||||
|
||||
ccgdm->dm.recalcLoopTri = ccgDM_recalcLoopTri;
|
||||
|
||||
|
|
@ -1848,7 +1686,7 @@ static void set_ccgdm_all_geometry(CCGDerivedMesh *ccgdm,
|
|||
int index;
|
||||
int i;
|
||||
int vertNum = 0, edgeNum = 0, faceNum = 0;
|
||||
int *vertOrigIndex, *faceOrigIndex, *polyOrigIndex, *base_polyOrigIndex, *edgeOrigIndex;
|
||||
int *vertOrigIndex, *polyOrigIndex, *base_polyOrigIndex, *edgeOrigIndex;
|
||||
short *edgeFlags = ccgdm->edgeFlags;
|
||||
DMFlagMat *faceFlags = ccgdm->faceFlags;
|
||||
int *polyidx = NULL;
|
||||
|
|
@ -1884,7 +1722,6 @@ static void set_ccgdm_all_geometry(CCGDerivedMesh *ccgdm,
|
|||
vertOrigIndex = DM_get_vert_data_layer(&ccgdm->dm, CD_ORIGINDEX);
|
||||
edgeOrigIndex = DM_get_edge_data_layer(&ccgdm->dm, CD_ORIGINDEX);
|
||||
|
||||
faceOrigIndex = DM_get_tessface_data_layer(&ccgdm->dm, CD_ORIGINDEX);
|
||||
polyOrigIndex = DM_get_poly_data_layer(&ccgdm->dm, CD_ORIGINDEX);
|
||||
|
||||
has_edge_cd = ((ccgdm->dm.edgeData.totlayer - (edgeOrigIndex ? 1 : 0)) != 0);
|
||||
|
|
@ -2006,12 +1843,6 @@ static void set_ccgdm_all_geometry(CCGDerivedMesh *ccgdm,
|
|||
/* Copy over poly data, e.g. #CD_FACEMAP. */
|
||||
CustomData_copy_data(&dm->polyData, &ccgdm->dm.polyData, origIndex, faceNum, 1);
|
||||
|
||||
/* Set original index data. */
|
||||
if (faceOrigIndex) {
|
||||
/* reference the index in 'polyOrigIndex' */
|
||||
*faceOrigIndex = faceNum;
|
||||
faceOrigIndex++;
|
||||
}
|
||||
if (polyOrigIndex) {
|
||||
*polyOrigIndex = base_polyOrigIndex ? base_polyOrigIndex[origIndex] : origIndex;
|
||||
polyOrigIndex++;
|
||||
|
|
|
|||
|
|
@ -1730,17 +1730,10 @@ static float project_paint_uvpixel_mask(const ProjPaintState *ps,
|
|||
normalize_v3(no);
|
||||
}
|
||||
else {
|
||||
#if 1
|
||||
/* In case the normalizing per pixel isn't optimal,
|
||||
* we could cache or access from evaluated mesh. */
|
||||
normal_tri_v3(no,
|
||||
ps->mvert_eval[lt_vtri[0]].co,
|
||||
ps->mvert_eval[lt_vtri[1]].co,
|
||||
ps->mvert_eval[lt_vtri[2]].co);
|
||||
#else
|
||||
/* Don't use because some modifiers don't have normal data (subsurf for eg). */
|
||||
copy_v3_v3(no, (float *)ps->dm->getTessFaceData(ps->dm, tri_index, CD_NORMAL));
|
||||
#endif
|
||||
}
|
||||
|
||||
if (UNLIKELY(ps->is_flip_object)) {
|
||||
|
|
|
|||
Loading…
Reference in New Issue