Differential D1405 Diff 4685 source/blender/blenkernel/intern/subsurf_ccg.c

Changeset View

Standalone View

source/blender/blenkernel/intern/subsurf_ccg.c

Show First 20 Lines • Show All 1,763 Lines • ▼ Show 20 Lines

/* Only used by non-editmesh types */		/* Only used by non-editmesh types */
static void ccgDM_buffer_copy_normal(		static void ccgDM_buffer_copy_normal(
DerivedMesh dm, short varray)		DerivedMesh dm, short varray)
{		{
CCGDerivedMesh ccgdm = (CCGDerivedMesh ) dm;		CCGDerivedMesh ccgdm = (CCGDerivedMesh ) dm;
CCGSubSurf *ss = ccgdm->ss;		CCGSubSurf *ss = ccgdm->ss;
CCGKey key;		CCGKey key;
const short (*lnors)[4][3] = dm->getTessFaceDataArray(dm, CD_TESSLOOPNORMAL);		const float (*lnors)[3] = dm->getLoopDataArray(dm, CD_NORMAL);
int gridSize = ccgSubSurf_getGridSize(ss);		int gridSize = ccgSubSurf_getGridSize(ss);
int gridFaces = gridSize - 1;		int gridFaces = gridSize - 1;
DMFlagMat *faceFlags = ccgdm->faceFlags;		DMFlagMat *faceFlags = ccgdm->faceFlags;
int i, totface = ccgSubSurf_getNumFaces(ss);		int i, totface = ccgSubSurf_getNumFaces(ss);
int shademodel;		int shademodel;
int start = 0;		int start = 0;

CCG_key_top_level(&key, ss);		CCG_key_top_level(&key, ss);
ccgdm_pbvh_update(ccgdm);		ccgdm_pbvh_update(ccgdm);

for (i = 0; i < totface; i++) {		for (i = 0; i < totface; i++) {
CCGFace *f = ccgdm->faceMap[i].face;		CCGFace *f = ccgdm->faceMap[i].face;
int S, x, y, numVerts = ccgSubSurf_getFaceNumVerts(f);		int S, x, y, numVerts = ccgSubSurf_getFaceNumVerts(f);
int index = GET_INT_FROM_POINTER(ccgSubSurf_getFaceFaceHandle(f));		int index = GET_INT_FROM_POINTER(ccgSubSurf_getFaceFaceHandle(f));
const short (*ln)[3] = NULL;		const float (*ln)[3] = NULL;

if (faceFlags) {		if (faceFlags) {
shademodel = (lnors \|\| (faceFlags[index].flag & ME_SMOOTH)) ? GL_SMOOTH : GL_FLAT;		shademodel = (lnors \|\| (faceFlags[index].flag & ME_SMOOTH)) ? GL_SMOOTH : GL_FLAT;
}		}
else {		else {
shademodel = GL_SMOOTH;		shademodel = GL_SMOOTH;
}		}

if (lnors) {		if (lnors) {
ln = *lnors;		ln = lnors;
lnors += gridFaces * gridFaces * numVerts;		lnors += gridFaces * gridFaces * numVerts * 4;
}		}

for (S = 0; S < numVerts; S++) {		for (S = 0; S < numVerts; S++) {
CCGElem *faceGridData = ccgSubSurf_getFaceGridDataArray(ss, f, S);		CCGElem *faceGridData = ccgSubSurf_getFaceGridDataArray(ss, f, S);

if (ln) {		if (ln) {
/* Can't use quad strips here... */		/* Can't use quad strips here... */
for (y = 0; y < gridFaces; y ++) {		for (y = 0; y < gridFaces; y ++) {
for (x = 0; x < gridFaces; x ++) {		for (x = 0; x < gridFaces; x ++) {
copy_v3_v3_short(&varray[start], ln[0]);		normal_float_to_short_v3(&varray[start + 0], ln[0]);
copy_v3_v3_short(&varray[start + 4], ln[3]);		normal_float_to_short_v3(&varray[start + 4], ln[3]);
copy_v3_v3_short(&varray[start + 8], ln[2]);		normal_float_to_short_v3(&varray[start + 8], ln[2]);
copy_v3_v3_short(&varray[start + 12], ln[1]);		normal_float_to_short_v3(&varray[start + 12], ln[1]);

start += 16;		start += 16;
ln += 4;		ln += 4;
}		}
}		}
}		}
else if (shademodel == GL_SMOOTH) {		else if (shademodel == GL_SMOOTH) {
for (y = 0; y < gridFaces; y ++) {		for (y = 0; y < gridFaces; y ++) {
▲ Show 20 Lines • Show All 128 Lines • ▼ Show 20 Lines	for (S = 0; S < numVerts; S++) {

start += 12;		start += 12;
}		}
}		}
}		}
}		}
}		}

static void copy_mcol_uc3(unsigned char v, const unsigned char col)
{
v[0] = col[3];
v[1] = col[2];
v[2] = col[1];
}

/* Only used by non-editmesh types */		/* Only used by non-editmesh types */
static void ccgDM_buffer_copy_color(		static void ccgDM_buffer_copy_color(
DerivedMesh dm, unsigned char varray,		DerivedMesh dm, unsigned char varray,
const void *user_data)		const void *user_data)
{		{
CCGDerivedMesh ccgdm = (CCGDerivedMesh ) dm;		CCGDerivedMesh ccgdm = (CCGDerivedMesh ) dm;
CCGSubSurf *ss = ccgdm->ss;		CCGSubSurf *ss = ccgdm->ss;
CCGKey key;		CCGKey key;
const unsigned char *mcol = user_data;		const char *mloopcol = user_data;
int gridSize = ccgSubSurf_getGridSize(ss);		int gridSize = ccgSubSurf_getGridSize(ss);
int gridFaces = gridSize - 1;		int gridFaces = gridSize - 1;
int i, totface = ccgSubSurf_getNumFaces(ss);		int i, totface = ccgSubSurf_getNumFaces(ss);
int start = 0;		int start = 0;
int iface = 0;		int iface = 0;

CCG_key_top_level(&key, ss);		CCG_key_top_level(&key, ss);


for (i = 0; i < totface; i++) {		for (i = 0; i < totface; i++) {
CCGFace *f = ccgdm->faceMap[i].face;		CCGFace *f = ccgdm->faceMap[i].face;
int S, x, y, numVerts = ccgSubSurf_getFaceNumVerts(f);		int S, x, y, numVerts = ccgSubSurf_getFaceNumVerts(f);

for (S = 0; S < numVerts; S++) {		for (S = 0; S < numVerts; S++) {
for (y = 0; y < gridFaces; y++) {		for (y = 0; y < gridFaces; y++) {
for (x = 0; x < gridFaces; x++) {		for (x = 0; x < gridFaces; x++) {
copy_mcol_uc3(&varray[start], &mcol[iface * 16]);		copy_v3_v3_char((char )&varray[start + 0], &mloopcol[iface 16 + 0]);
copy_mcol_uc3(&varray[start + 3], &mcol[iface * 16 + 12]);		copy_v3_v3_char((char )&varray[start + 3], &mloopcol[iface 16 + 12]);
copy_mcol_uc3(&varray[start + 6], &mcol[iface * 16 + 8]);		copy_v3_v3_char((char )&varray[start + 6], &mloopcol[iface 16 + 8]);
copy_mcol_uc3(&varray[start + 9], &mcol[iface * 16 + 4]);		copy_v3_v3_char((char )&varray[start + 9], &mloopcol[iface 16 + 4]);

start += 12;		start += 12;
iface++;		iface++;
}		}
}		}
}		}
}		}
}		}

static void ccgDM_buffer_copy_uv(		static void ccgDM_buffer_copy_uv(
DerivedMesh dm, void varray_p)		DerivedMesh dm, void varray_p)
{		{
float *varray = varray_p;		float *varray = varray_p;
CCGDerivedMesh ccgdm = (CCGDerivedMesh ) dm;		CCGDerivedMesh ccgdm = (CCGDerivedMesh ) dm;
CCGSubSurf *ss = ccgdm->ss;		CCGSubSurf *ss = ccgdm->ss;
CCGKey key;		CCGKey key;
MTFace *tf = DM_get_tessface_data_layer(dm, CD_MTFACE);		MLoopUV *mloopuv = DM_get_loop_data_layer(dm, CD_MLOOPUV);
int gridSize = ccgSubSurf_getGridSize(ss);		int gridSize = ccgSubSurf_getGridSize(ss);
int gridFaces = gridSize - 1;		int gridFaces = gridSize - 1;
int i, totface = ccgSubSurf_getNumFaces(ss);		int i, totface = ccgSubSurf_getNumFaces(ss);
int start = 0;		int start = 0;

CCG_key_top_level(&key, ss);		CCG_key_top_level(&key, ss);

for (i = 0; i < totface; i++) {		for (i = 0; i < totface; i++) {
CCGFace *f = ccgdm->faceMap[i].face;		CCGFace *f = ccgdm->faceMap[i].face;
int S, x, y, numVerts = ccgSubSurf_getFaceNumVerts(f);		int S, x, y, numVerts = ccgSubSurf_getFaceNumVerts(f);

for (S = 0; S < numVerts; S++) {		for (S = 0; S < numVerts; S++) {
for (y = 0; y < gridFaces; y++) {		for (y = 0; y < gridFaces; y++) {
for (x = 0; x < gridFaces; x++) {		for (x = 0; x < gridFaces; x++) {
copy_v2_v2(&varray[start], tf->uv[0]);		copy_v2_v2(&varray[start + 0], mloopuv[0].uv);
copy_v2_v2(&varray[start + 2], tf->uv[3]);		copy_v2_v2(&varray[start + 2], mloopuv[3].uv);
copy_v2_v2(&varray[start + 4], tf->uv[2]);		copy_v2_v2(&varray[start + 4], mloopuv[2].uv);
copy_v2_v2(&varray[start + 6], tf->uv[1]);		copy_v2_v2(&varray[start + 6], mloopuv[1].uv);

tf++;		mloopuv += 4;
start += 8;		start += 8;
}		}
}		}
}		}
}		}
}		}

static void ccgDM_buffer_copy_uv_texpaint(		static void ccgDM_buffer_copy_uv_texpaint(
DerivedMesh dm, float varray)		DerivedMesh dm, float varray)
{		{
CCGDerivedMesh ccgdm = (CCGDerivedMesh ) dm;		CCGDerivedMesh ccgdm = (CCGDerivedMesh ) dm;
CCGSubSurf *ss = ccgdm->ss;		CCGSubSurf *ss = ccgdm->ss;
CCGKey key;		CCGKey key;
int gridSize = ccgSubSurf_getGridSize(ss);		int gridSize = ccgSubSurf_getGridSize(ss);
int gridFaces = gridSize - 1;		int gridFaces = gridSize - 1;
int i, totface = ccgSubSurf_getNumFaces(ss);		int i, totface = ccgSubSurf_getNumFaces(ss);
int start = 0;		int start = 0;
DMFlagMat *faceFlags = ccgdm->faceFlags;		DMFlagMat *faceFlags = ccgdm->faceFlags;
int totmaterial = dm->totmat;		int totmaterial = dm->totmat;
MTFace **mtface_base;		MLoopUV **mloopuv_base;
MTFace *stencil_base;		MLoopUV *stencil_base;
int stencil;		int stencil;

CCG_key_top_level(&key, ss);		CCG_key_top_level(&key, ss);

/* should have been checked for before, reassert */		/* should have been checked for before, reassert */
BLI_assert(DM_get_tessface_data_layer(dm, CD_MTFACE));		BLI_assert(DM_get_loop_data_layer(dm, CD_MLOOPUV));
mtface_base = MEM_mallocN(totmaterial * sizeof(*mtface_base), "texslots");		mloopuv_base = MEM_mallocN(totmaterial * sizeof(*mloopuv_base), "texslots");

for (i = 0; i < totmaterial; i++) {		for (i = 0; i < totmaterial; i++) {
mtface_base[i] = DM_paint_uvlayer_active_get(dm, i);		mloopuv_base[i] = DM_paint_uvlayer_active_get_mloopuv(dm, i);
}		}

stencil = CustomData_get_stencil_layer(&dm->faceData, CD_MTFACE);		stencil = CustomData_get_stencil_layer(&dm->loopData, CD_MLOOPUV);
stencil_base = CustomData_get_layer_n(&dm->faceData, CD_MTFACE, stencil);		stencil_base = CustomData_get_layer_n(&dm->loopData, CD_MLOOPUV, stencil);

start = 0;		start = 0;

for (i = 0; i < totface; i++) {		for (i = 0; i < totface; i++) {
CCGFace *f = ccgdm->faceMap[i].face;		CCGFace *f = ccgdm->faceMap[i].face;
int S, x, y, numVerts = ccgSubSurf_getFaceNumVerts(f);		int S, x, y, numVerts = ccgSubSurf_getFaceNumVerts(f);
int index = GET_INT_FROM_POINTER(ccgSubSurf_getFaceFaceHandle(f));		int index = GET_INT_FROM_POINTER(ccgSubSurf_getFaceFaceHandle(f));
int matnr;		int matnr;

if (faceFlags) {		if (faceFlags) {
matnr = faceFlags[index].mat_nr;		matnr = faceFlags[index].mat_nr;
}		}
else {		else {
matnr = 0;		matnr = 0;
}		}

for (S = 0; S < numVerts; S++) {		for (S = 0; S < numVerts; S++) {
for (y = 0; y < gridFaces; y++) {		for (y = 0; y < gridFaces; y++) {
for (x = 0; x < gridFaces; x++) {		for (x = 0; x < gridFaces; x++) {
/* divide by 16, gives us current tface */		/* divide by 4, gives us current loop-index */
unsigned int i_tf = start / 16;		unsigned int i_ml = start / 4;
copy_v2_v2(&varray[start], mtface_base[matnr][i_tf].uv[0]);		copy_v2_v2(&varray[start + 0], mloopuv_base[matnr][i_ml + 0].uv);
copy_v2_v2(&varray[start + 2], stencil_base[i_tf].uv[0]);		copy_v2_v2(&varray[start + 2], stencil_base[i_ml + 0].uv);
copy_v2_v2(&varray[start + 4], mtface_base[matnr][i_tf].uv[3]);		copy_v2_v2(&varray[start + 4], mloopuv_base[matnr][i_ml + 3].uv);
copy_v2_v2(&varray[start + 6], stencil_base[i_tf].uv[3]);		copy_v2_v2(&varray[start + 6], stencil_base[i_ml + 3].uv);
copy_v2_v2(&varray[start + 8], mtface_base[matnr][i_tf].uv[2]);		copy_v2_v2(&varray[start + 8], mloopuv_base[matnr][i_ml + 2].uv);
copy_v2_v2(&varray[start + 10], stencil_base[i_tf].uv[2]);		copy_v2_v2(&varray[start + 10], stencil_base[i_ml + 2].uv);
copy_v2_v2(&varray[start + 12], mtface_base[matnr][i_tf].uv[1]);		copy_v2_v2(&varray[start + 12], mloopuv_base[matnr][i_ml + 1].uv);
copy_v2_v2(&varray[start + 14], stencil_base[i_tf].uv[1]);		copy_v2_v2(&varray[start + 14], stencil_base[i_ml + 1].uv);
start += 16;		start += 16;
}		}
}		}
}		}
}		}

MEM_freeN(mtface_base);		MEM_freeN(mloopuv_base);
}		}

static void ccgDM_copy_gpu_data(		static void ccgDM_copy_gpu_data(
DerivedMesh dm, int type, void varray_p,		DerivedMesh dm, int type, void varray_p,
const int mat_orig_to_new, const void user_data)		const int mat_orig_to_new, const void user_data)
{		{
/* 'varray_p' cast is redundant but include for self-documentation */		/* 'varray_p' cast is redundant but include for self-documentation */
switch (type) {		switch (type) {
▲ Show 20 Lines • Show All 186 Lines • ▼ Show 20 Lines	static void ccgDM_drawMappedFacesGLSL(DerivedMesh *dm,
do_draw = 0;		do_draw = 0;
matnr = -1;		matnr = -1;

#define PASSATTRIB(dx, dy, vert) { \		#define PASSATTRIB(dx, dy, vert) { \
if (attribs.totorco) \		if (attribs.totorco) \
index = getFaceIndex(ss, f, S, x + dx, y + dy, edgeSize, gridSize); \		index = getFaceIndex(ss, f, S, x + dx, y + dy, edgeSize, gridSize); \
else \		else \
index = 0; \		index = 0; \
DM_draw_attrib_vertex(&attribs, a, index, vert); \		DM_draw_attrib_vertex(&attribs, a, index, vert, (a * 4) + vert); \
} (void)0		} (void)0

totface = ccgSubSurf_getNumFaces(ss);		totface = ccgSubSurf_getNumFaces(ss);
for (a = 0, i = 0; i < totface; i++) {		for (a = 0, i = 0; i < totface; i++) {
CCGFace *f = ccgdm->faceMap[i].face;		CCGFace *f = ccgdm->faceMap[i].face;
short (*ln)[4][3] = NULL;		short (*ln)[4][3] = NULL;
int S, x, y, drawSmooth;		int S, x, y, drawSmooth;
int index = GET_INT_FROM_POINTER(ccgSubSurf_getFaceFaceHandle(f));		int index = GET_INT_FROM_POINTER(ccgSubSurf_getFaceFaceHandle(f));
▲ Show 20 Lines • Show All 110 Lines • ▼ Show 20 Lines	for (S = 0; S < numVerts; S++) {
PASSATTRIB(0, 1, 1);		PASSATTRIB(0, 1, 1);
glVertex3fv(dco);		glVertex3fv(dco);
PASSATTRIB(1, 1, 2);		PASSATTRIB(1, 1, 2);
glVertex3fv(cco);		glVertex3fv(cco);
PASSATTRIB(1, 0, 3);		PASSATTRIB(1, 0, 3);
glVertex3fv(bco);		glVertex3fv(bco);
PASSATTRIB(0, 0, 0);		PASSATTRIB(0, 0, 0);
glVertex3fv(aco);		glVertex3fv(aco);

a++;		a++;
}		}
}		}
glEnd();		glEnd();
}		}
}		}
}		}

Show All 27 Lines	static void ccgDM_drawMappedFacesMat(DerivedMesh *dm,

matnr = -1;		matnr = -1;

#define PASSATTRIB(dx, dy, vert) { \		#define PASSATTRIB(dx, dy, vert) { \
if (attribs.totorco) \		if (attribs.totorco) \
index = getFaceIndex(ss, f, S, x + dx, y + dy, edgeSize, gridSize); \		index = getFaceIndex(ss, f, S, x + dx, y + dy, edgeSize, gridSize); \
else \		else \
index = 0; \		index = 0; \
DM_draw_attrib_vertex(&attribs, a, index, vert); \		DM_draw_attrib_vertex(&attribs, a, index, vert, (a * 4) + vert); \
} (void)0		} (void)0

totface = ccgSubSurf_getNumFaces(ss);		totface = ccgSubSurf_getNumFaces(ss);
for (a = 0, i = 0; i < totface; i++) {		for (a = 0, i = 0; i < totface; i++) {
CCGFace *f = ccgdm->faceMap[i].face;		CCGFace *f = ccgdm->faceMap[i].face;
short (*ln)[4][3] = NULL;		short (*ln)[4][3] = NULL;
int S, x, y, drawSmooth;		int S, x, y, drawSmooth;
int index = GET_INT_FROM_POINTER(ccgSubSurf_getFaceFaceHandle(f));		int index = GET_INT_FROM_POINTER(ccgSubSurf_getFaceFaceHandle(f));
▲ Show 20 Lines • Show All 132 Lines • ▼ Show 20 Lines	static void ccgDM_drawFacesTex_common(DerivedMesh *dm,
DMSetDrawOptionsTex drawParams,		DMSetDrawOptionsTex drawParams,
DMSetDrawOptionsMappedTex drawParamsMapped,		DMSetDrawOptionsMappedTex drawParamsMapped,
DMCompareDrawOptions compareDrawOptions,		DMCompareDrawOptions compareDrawOptions,
void *userData, DMDrawFlag flag)		void *userData, DMDrawFlag flag)
{		{
CCGDerivedMesh ccgdm = (CCGDerivedMesh ) dm;		CCGDerivedMesh ccgdm = (CCGDerivedMesh ) dm;
CCGSubSurf *ss = ccgdm->ss;		CCGSubSurf *ss = ccgdm->ss;
CCGKey key;		CCGKey key;
int colType = CD_TEXTURE_MCOL;		int colType;
MCol *mcol = dm->getTessFaceDataArray(dm, colType);		const MLoopCol *mloopcol;
MTFace *tf = DM_get_tessface_data_layer(dm, CD_MTFACE);		MTFace *tf = DM_get_tessface_data_layer(dm, CD_MTFACE);
DMFlagMat *faceFlags = ccgdm->faceFlags;		DMFlagMat *faceFlags = ccgdm->faceFlags;
DMDrawOption draw_option;		DMDrawOption draw_option;
int i, totpoly;		int i, totpoly;
bool flush;		bool flush;
bool use_tface = (flag & DM_DRAW_USE_ACTIVE_UV) != 0;		bool use_tface = (flag & DM_DRAW_USE_ACTIVE_UV) != 0;
unsigned int next_actualFace;		unsigned int next_actualFace;
unsigned int gridFaces = ccgSubSurf_getGridSize(ss) - 1;		unsigned int gridFaces = ccgSubSurf_getGridSize(ss) - 1;
int mat_index;		int mat_index;
int tot_element, start_element, tot_drawn;		int tot_element, start_element, tot_drawn;

CCG_key_top_level(&key, ss);		CCG_key_top_level(&key, ss);
ccgdm_pbvh_update(ccgdm);		ccgdm_pbvh_update(ccgdm);

if (!mcol) {		colType = CD_TEXTURE_MLOOPCOL;
		mloopcol = dm->getLoopDataArray(dm, colType);
		if (!mloopcol) {
colType = CD_PREVIEW_MCOL;		colType = CD_PREVIEW_MCOL;
mcol = dm->getTessFaceDataArray(dm, colType);		mloopcol = dm->getLoopDataArray(dm, colType);
}		}
if (!mcol) {		if (!mloopcol) {
colType = CD_MCOL;		colType = CD_MLOOPCOL;
mcol = dm->getTessFaceDataArray(dm, colType);		mloopcol = dm->getLoopDataArray(dm, colType);
}		}

GPU_vertex_setup(dm);		GPU_vertex_setup(dm);
GPU_normal_setup(dm);		GPU_normal_setup(dm);
GPU_triangle_setup(dm);		GPU_triangle_setup(dm);
if (flag & DM_DRAW_USE_TEXPAINT_UV)		if (flag & DM_DRAW_USE_TEXPAINT_UV)
GPU_texpaint_uv_setup(dm);		GPU_texpaint_uv_setup(dm);
else		else
GPU_uv_setup(dm);		GPU_uv_setup(dm);
if (mcol) {		if (mloopcol) {
GPU_color_setup(dm, colType);		GPU_color_setup(dm, colType);
}		}

next_actualFace = 0;		next_actualFace = 0;

glShadeModel(GL_SMOOTH);		glShadeModel(GL_SMOOTH);
/* lastFlag = 0; / / UNUSED */		/* lastFlag = 0; / / UNUSED */
for (mat_index = 0; mat_index < dm->drawObject->totmaterial; mat_index++) {		for (mat_index = 0; mat_index < dm->drawObject->totmaterial; mat_index++) {
Show All 25 Lines	for (i = 0; i < totpoly; i++) {
}		}
else {		else {
mat_nr = 0;		mat_nr = 0;
}		}

if (drawParams) {		if (drawParams) {
MTexPoly tpoly;		MTexPoly tpoly;
if (tf) {		if (tf) {
		memset(&tpoly, 0, sizeof(tpoly));
ME_MTEXFACE_CPY(&tpoly, tf + actualFace);		ME_MTEXFACE_CPY(&tpoly, tf + actualFace);
}		}

draw_option = drawParams((use_tface && tf) ? &tpoly : NULL, (mcol != NULL), mat_nr);		draw_option = drawParams((use_tface && tf) ? &tpoly : NULL, (mloopcol != NULL), mat_nr);
}		}
else if (index != ORIGINDEX_NONE)		else if (index != ORIGINDEX_NONE)
draw_option = (drawParamsMapped) ? drawParamsMapped(userData, index, mat_nr) : DM_DRAW_OPTION_NORMAL;		draw_option = (drawParamsMapped) ? drawParamsMapped(userData, index, mat_nr) : DM_DRAW_OPTION_NORMAL;
else		else
draw_option = DM_DRAW_OPTION_NORMAL;		draw_option = DM_DRAW_OPTION_NORMAL;

/* flush buffer if current triangle isn't drawable or it's last triangle */		/* flush buffer if current triangle isn't drawable or it's last triangle */
flush = (draw_option == DM_DRAW_OPTION_SKIP) \|\| (i == totpoly - 1);		flush = (draw_option == DM_DRAW_OPTION_SKIP) \|\| (i == totpoly - 1);

if (!flush && compareDrawOptions) {		if (!flush && compareDrawOptions) {
/* also compare draw options and flush buffer if they're different		/* also compare draw options and flush buffer if they're different
* need for face selection highlight in edit mode */		* need for face selection highlight in edit mode */
flush \|= compareDrawOptions(userData, actualFace, next_actualFace) == 0;		flush \|= compareDrawOptions(userData, actualFace, next_actualFace) == 0;
}		}

tot_element += facequads * 6;		tot_element += facequads * 6;

if (flush) {		if (flush) {
if (draw_option != DM_DRAW_OPTION_SKIP)		if (draw_option != DM_DRAW_OPTION_SKIP)
tot_drawn += facequads * 6;		tot_drawn += facequads * 6;

if (tot_drawn) {		if (tot_drawn) {
if (mcol && draw_option != DM_DRAW_OPTION_NO_MCOL)		if (mloopcol && draw_option != DM_DRAW_OPTION_NO_MCOL)
GPU_color_switch(1);		GPU_color_switch(1);
else		else
GPU_color_switch(0);		GPU_color_switch(0);

GPU_buffer_draw_elements(dm->drawObject->triangles, GL_TRIANGLES, bufmat->start + start_element, tot_drawn);		GPU_buffer_draw_elements(dm->drawObject->triangles, GL_TRIANGLES, bufmat->start + start_element, tot_drawn);
tot_drawn = 0;		tot_drawn = 0;
}		}

▲ Show 20 Lines • Show All 63 Lines • ▼ Show 20 Lines	static void ccgDM_drawMappedFaces(DerivedMesh *dm,
DMSetDrawOptions setDrawOptions,		DMSetDrawOptions setDrawOptions,
DMSetMaterial setMaterial,		DMSetMaterial setMaterial,
DMCompareDrawOptions compareDrawOptions,		DMCompareDrawOptions compareDrawOptions,
void *userData, DMDrawFlag flag)		void *userData, DMDrawFlag flag)
{		{
CCGDerivedMesh ccgdm = (CCGDerivedMesh ) dm;		CCGDerivedMesh ccgdm = (CCGDerivedMesh ) dm;
CCGSubSurf *ss = ccgdm->ss;		CCGSubSurf *ss = ccgdm->ss;
CCGKey key;		CCGKey key;
MCol *mcol = NULL;		MLoopCol *mloopcol = NULL;
short (*lnors)[4][3] = dm->getTessFaceDataArray(dm, CD_TESSLOOPNORMAL);		short (*lnors)[4][3] = dm->getTessFaceDataArray(dm, CD_TESSLOOPNORMAL);
int i, gridSize = ccgSubSurf_getGridSize(ss);		int i, gridSize = ccgSubSurf_getGridSize(ss);
DMFlagMat *faceFlags = ccgdm->faceFlags;		DMFlagMat *faceFlags = ccgdm->faceFlags;
int useColors = flag & DM_DRAW_USE_COLORS;		int useColors = flag & DM_DRAW_USE_COLORS;
int gridFaces = gridSize - 1, totface;		int gridFaces = gridSize - 1, totface;
int prev_mat_nr = -1;		int prev_mat_nr = -1;

CCG_key_top_level(&key, ss);		CCG_key_top_level(&key, ss);

/* currently unused -- each original face is handled separately */		/* currently unused -- each original face is handled separately */
(void)compareDrawOptions;		(void)compareDrawOptions;

if (useColors) {		if (useColors) {
mcol = dm->getTessFaceDataArray(dm, CD_PREVIEW_MCOL);		mloopcol = dm->getLoopDataArray(dm, CD_PREVIEW_MLOOPCOL);
if (!mcol)		if (!mloopcol)
mcol = dm->getTessFaceDataArray(dm, CD_MCOL);		mloopcol = dm->getLoopDataArray(dm, CD_MLOOPCOL);
}		}

totface = ccgSubSurf_getNumFaces(ss);		totface = ccgSubSurf_getNumFaces(ss);
for (i = 0; i < totface; i++) {		for (i = 0; i < totface; i++) {
CCGFace *f = ccgdm->faceMap[i].face;		CCGFace *f = ccgdm->faceMap[i].face;
int S, x, y, numVerts = ccgSubSurf_getFaceNumVerts(f);		int S, x, y, numVerts = ccgSubSurf_getFaceNumVerts(f);
int drawSmooth, index = ccgDM_getFaceMapIndex(ss, f);		int drawSmooth, index = ccgDM_getFaceMapIndex(ss, f);
int origIndex;		int origIndex;
unsigned char *cp = NULL;		unsigned char *cp = NULL;
short (*ln)[4][3] = NULL;		short (*ln)[4][3] = NULL;

origIndex = GET_INT_FROM_POINTER(ccgSubSurf_getFaceFaceHandle(f));		origIndex = GET_INT_FROM_POINTER(ccgSubSurf_getFaceFaceHandle(f));

if (flag & DM_DRAW_ALWAYS_SMOOTH) drawSmooth = 1;		if (flag & DM_DRAW_ALWAYS_SMOOTH) drawSmooth = 1;
else if (faceFlags) drawSmooth = (lnors \|\| (faceFlags[origIndex].flag & ME_SMOOTH));		else if (faceFlags) drawSmooth = (lnors \|\| (faceFlags[origIndex].flag & ME_SMOOTH));
else drawSmooth = 1;		else drawSmooth = 1;

if (mcol) {		if (mloopcol) {
cp = (unsigned char *)mcol;		cp = (unsigned char *)mloopcol;
mcol += gridFaces * gridFaces * numVerts * 4;		mloopcol += gridFaces * gridFaces * numVerts * 4;
}		}

if (lnors) {		if (lnors) {
ln = lnors;		ln = lnors;
lnors += gridFaces * gridFaces * numVerts;		lnors += gridFaces * gridFaces * numVerts;
}		}

{		{
Show All 27 Lines	if (lnors) {
glBegin(GL_QUADS);		glBegin(GL_QUADS);
for (y = 0; y < gridFaces; y++) {		for (y = 0; y < gridFaces; y++) {
for (x = 0; x < gridFaces; x++) {		for (x = 0; x < gridFaces; x++) {
float *a = CCG_grid_elem_co(&key, faceGridData, x, y + 0);		float *a = CCG_grid_elem_co(&key, faceGridData, x, y + 0);
float *b = CCG_grid_elem_co(&key, faceGridData, x + 1, y + 0);		float *b = CCG_grid_elem_co(&key, faceGridData, x + 1, y + 0);
float *c = CCG_grid_elem_co(&key, faceGridData, x + 1, y + 1);		float *c = CCG_grid_elem_co(&key, faceGridData, x + 1, y + 1);
float *d = CCG_grid_elem_co(&key, faceGridData, x, y + 1);		float *d = CCG_grid_elem_co(&key, faceGridData, x, y + 1);

if (cp) glColor3ub(cp[7], cp[6], cp[5]);		if (cp) glColor3ubv(&cp[4]);
glNormal3sv(ln[0][1]);		glNormal3sv(ln[0][1]);
glVertex3fv(d);		glVertex3fv(d);
if (cp) glColor3ub(cp[11], cp[10], cp[9]);		if (cp) glColor3ubv(&cp[8]);
glNormal3sv(ln[0][2]);		glNormal3sv(ln[0][2]);
glVertex3fv(c);		glVertex3fv(c);
if (cp) glColor3ub(cp[15], cp[14], cp[13]);		if (cp) glColor3ubv(&cp[12]);
glNormal3sv(ln[0][3]);		glNormal3sv(ln[0][3]);
glVertex3fv(b);		glVertex3fv(b);
if (cp) glColor3ub(cp[3], cp[2], cp[1]);		if (cp) glColor3ubv(&cp[0]);
glNormal3sv(ln[0][0]);		glNormal3sv(ln[0][0]);
glVertex3fv(a);		glVertex3fv(a);

if (cp) cp += 16;		if (cp) cp += 16;
ln++;		ln++;
}		}
}		}
glEnd();		glEnd();
}		}
else if (drawSmooth) {		else if (drawSmooth) {
for (y = 0; y < gridFaces; y++) {		for (y = 0; y < gridFaces; y++) {
CCGElem a, b;		CCGElem a, b;
glBegin(GL_QUAD_STRIP);		glBegin(GL_QUAD_STRIP);
for (x = 0; x < gridFaces; x++) {		for (x = 0; x < gridFaces; x++) {
a = CCG_grid_elem(&key, faceGridData, x, y + 0);		a = CCG_grid_elem(&key, faceGridData, x, y + 0);
b = CCG_grid_elem(&key, faceGridData, x, y + 1);		b = CCG_grid_elem(&key, faceGridData, x, y + 1);

if (cp) glColor3ub(cp[3], cp[2], cp[1]);		if (cp) glColor3ubv(&cp[0]);
glNormal3fv(CCG_elem_no(&key, a));		glNormal3fv(CCG_elem_no(&key, a));
glVertex3fv(CCG_elem_co(&key, a));		glVertex3fv(CCG_elem_co(&key, a));
if (cp) glColor3ub(cp[7], cp[6], cp[5]);		if (cp) glColor3ubv(&cp[4]);
glNormal3fv(CCG_elem_no(&key, b));		glNormal3fv(CCG_elem_no(&key, b));
glVertex3fv(CCG_elem_co(&key, b));		glVertex3fv(CCG_elem_co(&key, b));

if (x != gridFaces - 1) {		if (x != gridFaces - 1) {
if (cp) cp += 16;		if (cp) cp += 16;
}		}
}		}

a = CCG_grid_elem(&key, faceGridData, x, y + 0);		a = CCG_grid_elem(&key, faceGridData, x, y + 0);
b = CCG_grid_elem(&key, faceGridData, x, y + 1);		b = CCG_grid_elem(&key, faceGridData, x, y + 1);

if (cp) glColor3ub(cp[15], cp[14], cp[13]);		if (cp) glColor3ubv(&cp[12]);
glNormal3fv(CCG_elem_no(&key, a));		glNormal3fv(CCG_elem_no(&key, a));
glVertex3fv(CCG_elem_co(&key, a));		glVertex3fv(CCG_elem_co(&key, a));
if (cp) glColor3ub(cp[11], cp[10], cp[9]);		if (cp) glColor3ubv(&cp[8]);
glNormal3fv(CCG_elem_no(&key, b));		glNormal3fv(CCG_elem_no(&key, b));
glVertex3fv(CCG_elem_co(&key, b));		glVertex3fv(CCG_elem_co(&key, b));

if (cp) cp += 16;		if (cp) cp += 16;

glEnd();		glEnd();
}		}
}		}
else {		else {
glBegin(GL_QUADS);		glBegin(GL_QUADS);
for (y = 0; y < gridFaces; y++) {		for (y = 0; y < gridFaces; y++) {
for (x = 0; x < gridFaces; x++) {		for (x = 0; x < gridFaces; x++) {
float *a = CCG_grid_elem_co(&key, faceGridData, x, y + 0);		float *a = CCG_grid_elem_co(&key, faceGridData, x, y + 0);
float *b = CCG_grid_elem_co(&key, faceGridData, x + 1, y + 0);		float *b = CCG_grid_elem_co(&key, faceGridData, x + 1, y + 0);
float *c = CCG_grid_elem_co(&key, faceGridData, x + 1, y + 1);		float *c = CCG_grid_elem_co(&key, faceGridData, x + 1, y + 1);
float *d = CCG_grid_elem_co(&key, faceGridData, x, y + 1);		float *d = CCG_grid_elem_co(&key, faceGridData, x, y + 1);

ccgDM_glNormalFast(a, b, c, d);		ccgDM_glNormalFast(a, b, c, d);

if (cp) glColor3ub(cp[7], cp[6], cp[5]);		if (cp) glColor3ubv(&cp[4]);
glVertex3fv(d);		glVertex3fv(d);
if (cp) glColor3ub(cp[11], cp[10], cp[9]);		if (cp) glColor3ubv(&cp[8]);
glVertex3fv(c);		glVertex3fv(c);
if (cp) glColor3ub(cp[15], cp[14], cp[13]);		if (cp) glColor3ubv(&cp[12]);
glVertex3fv(b);		glVertex3fv(b);
if (cp) glColor3ub(cp[3], cp[2], cp[1]);		if (cp) glColor3ubv(&cp[0]);
glVertex3fv(a);		glVertex3fv(a);

if (cp) cp += 16;		if (cp) cp += 16;
}		}
}		}
glEnd();		glEnd();
}		}
}		}
▲ Show 20 Lines • Show All 599 Lines • ▼ Show 20 Lines	if (grid_pbvh) {
numGrids = ccgDM_getNumGrids(dm);		numGrids = ccgDM_getNumGrids(dm);

ob->sculpt->pbvh = ccgdm->pbvh = BKE_pbvh_new();		ob->sculpt->pbvh = ccgdm->pbvh = BKE_pbvh_new();
BKE_pbvh_build_grids(ccgdm->pbvh, ccgdm->gridData,		BKE_pbvh_build_grids(ccgdm->pbvh, ccgdm->gridData,
numGrids, &key, (void **) ccgdm->gridFaces, ccgdm->gridFlagMats, ccgdm->gridHidden);		numGrids, &key, (void **) ccgdm->gridFaces, ccgdm->gridFlagMats, ccgdm->gridHidden);
}		}
else if (ob->type == OB_MESH) {		else if (ob->type == OB_MESH) {
Mesh *me = ob->data;		Mesh *me = ob->data;
		const int looptris_num = poly_to_tri_count(me->totpoly, me->totloop);
		MLoopTri *looptri;

		looptri = MEM_mallocN(sizeof(looptri) looptris_num, __func__);

ob->sculpt->pbvh = ccgdm->pbvh = BKE_pbvh_new();		ob->sculpt->pbvh = ccgdm->pbvh = BKE_pbvh_new();
BLI_assert(!(me->mface == NULL && me->mpoly != NULL)); /* BMESH ONLY complain if mpoly is valid but not mface */		BLI_assert(!(me->mface == NULL && me->mpoly != NULL)); /* BMESH ONLY complain if mpoly is valid but not mface */
BKE_pbvh_build_mesh(ccgdm->pbvh, me->mface, me->mvert,		BKE_pbvh_build_mesh(ccgdm->pbvh, me->mpoly, me->mloop, me->mvert, me->totvert, &me->vdata,
me->totface, me->totvert, &me->vdata);		looptri, looptris_num);
}		}

if (ccgdm->pbvh)		if (ccgdm->pbvh)
pbvh_show_diffuse_color_set(ccgdm->pbvh, ob->sculpt->show_diffuse_color);		pbvh_show_diffuse_color_set(ccgdm->pbvh, ob->sculpt->show_diffuse_color);

return ccgdm->pbvh;		return ccgdm->pbvh;
}		}

static void ccgDM_recalcTessellation(DerivedMesh *UNUSED(dm))		static void ccgDM_recalcTessellation(DerivedMesh *UNUSED(dm))
{		{
/* Nothing to do: CCG handles creating its own tessfaces */		/* Nothing to do: CCG handles creating its own tessfaces */
}		}

		static void ccgDM_recalcLoopTri(DerivedMesh *UNUSED(dm))
		{
		/* Nothing to do: CCG tessellation is known,
		* allocate and fill in with ccgDM_getLoopTriArray */
		}

		static const MLoopTri ccgDM_getLoopTriArray(DerivedMesh dm)
		{
		if (dm->looptris.array) {
		BLI_assert(poly_to_tri_count(dm->numPolyData, dm->numLoopData) == dm->looptris.num);
		}
		else {
		MLoopTri *mlooptri;
		const int tottri = dm->numTessFaceData * 2;
		int i, poly_index;

		DM_ensure_looptri_data(dm);
		mlooptri = dm->looptris.array;

		BLI_assert(poly_to_tri_count(dm->numPolyData, dm->numLoopData) == dm->looptris.num);
		BLI_assert(tottri == dm->looptris.num);

		for (i = 0, poly_index = 0; i < tottri; i += 2, poly_index += 1) {
		MLoopTri *lt;
		lt = &mlooptri[i];
		/* quad is (0, 3, 2, 1) */
		lt->tri[0] = (poly_index * 4) + 0;
		lt->tri[1] = (poly_index * 4) + 3;
		lt->tri[2] = (poly_index * 4) + 2;
		lt->poly = poly_index;

		lt = &mlooptri[i + 1];
		lt->tri[0] = (poly_index * 4) + 0;
		lt->tri[1] = (poly_index * 4) + 2;
		lt->tri[2] = (poly_index * 4) + 1;
		lt->poly = poly_index;
		}
		}
		return dm->looptris.array;
		}

static void ccgDM_calcNormals(DerivedMesh *dm)		static void ccgDM_calcNormals(DerivedMesh *dm)
{		{
/* Nothing to do: CCG calculates normals during drawing */		/* Nothing to do: CCG calculates normals during drawing */
dm->dirty &= ~DM_DIRTY_NORMALS;		dm->dirty &= ~DM_DIRTY_NORMALS;
}		}

static CCGDerivedMesh getCCGDerivedMesh(CCGSubSurf ss,		static CCGDerivedMesh getCCGDerivedMesh(CCGSubSurf ss,
int drawInteriorEdges,		int drawInteriorEdges,
▲ Show 20 Lines • Show All 66 Lines • ▼ Show 20 Lines	#endif
ccgdm->dm.getMinMax = ccgDM_getMinMax;		ccgdm->dm.getMinMax = ccgDM_getMinMax;
ccgdm->dm.getNumVerts = ccgDM_getNumVerts;		ccgdm->dm.getNumVerts = ccgDM_getNumVerts;
ccgdm->dm.getNumEdges = ccgDM_getNumEdges;		ccgdm->dm.getNumEdges = ccgDM_getNumEdges;
ccgdm->dm.getNumTessFaces = ccgDM_getNumTessFaces;		ccgdm->dm.getNumTessFaces = ccgDM_getNumTessFaces;
ccgdm->dm.getNumLoops = ccgDM_getNumLoops;		ccgdm->dm.getNumLoops = ccgDM_getNumLoops;
/* reuse of ccgDM_getNumTessFaces is intentional here: subsurf polys are just created from tessfaces */		/* reuse of ccgDM_getNumTessFaces is intentional here: subsurf polys are just created from tessfaces */
ccgdm->dm.getNumPolys = ccgDM_getNumTessFaces;		ccgdm->dm.getNumPolys = ccgDM_getNumTessFaces;

		ccgdm->dm.getLoopTriArray = ccgDM_getLoopTriArray;

ccgdm->dm.getVert = ccgDM_getFinalVert;		ccgdm->dm.getVert = ccgDM_getFinalVert;
ccgdm->dm.getEdge = ccgDM_getFinalEdge;		ccgdm->dm.getEdge = ccgDM_getFinalEdge;
ccgdm->dm.getTessFace = ccgDM_getFinalFace;		ccgdm->dm.getTessFace = ccgDM_getFinalFace;

ccgdm->dm.getVertCo = ccgDM_getFinalVertCo;		ccgdm->dm.getVertCo = ccgDM_getFinalVertCo;
ccgdm->dm.getVertNo = ccgDM_getFinalVertNo;		ccgdm->dm.getVertNo = ccgDM_getFinalVertNo;

ccgdm->dm.copyVertArray = ccgDM_copyFinalVertArray;		ccgdm->dm.copyVertArray = ccgDM_copyFinalVertArray;
Show All 19 Lines	#endif
ccgdm->dm.getGridHidden = ccgDM_getGridHidden;		ccgdm->dm.getGridHidden = ccgDM_getGridHidden;
ccgdm->dm.getPolyMap = ccgDM_getPolyMap;		ccgdm->dm.getPolyMap = ccgDM_getPolyMap;
ccgdm->dm.getPBVH = ccgDM_getPBVH;		ccgdm->dm.getPBVH = ccgDM_getPBVH;

ccgdm->dm.calcNormals = ccgDM_calcNormals;		ccgdm->dm.calcNormals = ccgDM_calcNormals;
ccgdm->dm.calcLoopNormals = CDDM_calc_loop_normals;		ccgdm->dm.calcLoopNormals = CDDM_calc_loop_normals;
ccgdm->dm.calcLoopNormalsSpaceArray = CDDM_calc_loop_normals_spacearr;		ccgdm->dm.calcLoopNormalsSpaceArray = CDDM_calc_loop_normals_spacearr;
ccgdm->dm.recalcTessellation = ccgDM_recalcTessellation;		ccgdm->dm.recalcTessellation = ccgDM_recalcTessellation;
		ccgdm->dm.recalcLoopTri = ccgDM_recalcLoopTri;

ccgdm->dm.getVertCos = ccgdm_getVertCos;		ccgdm->dm.getVertCos = ccgdm_getVertCos;
ccgdm->dm.foreachMappedVert = ccgDM_foreachMappedVert;		ccgdm->dm.foreachMappedVert = ccgDM_foreachMappedVert;
ccgdm->dm.foreachMappedEdge = ccgDM_foreachMappedEdge;		ccgdm->dm.foreachMappedEdge = ccgDM_foreachMappedEdge;
ccgdm->dm.foreachMappedLoop = ccgDM_foreachMappedLoop;		ccgdm->dm.foreachMappedLoop = ccgDM_foreachMappedLoop;
ccgdm->dm.foreachMappedFaceCenter = ccgDM_foreachMappedFaceCenter;		ccgdm->dm.foreachMappedFaceCenter = ccgDM_foreachMappedFaceCenter;

ccgdm->dm.drawVerts = ccgDM_drawVerts;		ccgdm->dm.drawVerts = ccgDM_drawVerts;
▲ Show 20 Lines • Show All 489 Lines • Show Last 20 Lines