Differential D1405 Diff 4661 source/blender/gpu/intern/gpu_buffers.c

Changeset View

Standalone View

source/blender/gpu/intern/gpu_buffers.c

Show First 20 Lines • Show All 54 Lines • ▼ Show 20 Lines

#include "DNA_userdef_types.h"		#include "DNA_userdef_types.h"

#include "GPU_buffers.h"		#include "GPU_buffers.h"
#include "GPU_draw.h"		#include "GPU_draw.h"

#include "bmesh.h"		#include "bmesh.h"


typedef enum {		typedef enum {
GPU_BUFFER_VERTEX_STATE = (1 << 0),		GPU_BUFFER_VERTEX_STATE = (1 << 0),
GPU_BUFFER_NORMAL_STATE = (1 << 1),		GPU_BUFFER_NORMAL_STATE = (1 << 1),
GPU_BUFFER_TEXCOORD_UNIT_0_STATE = (1 << 2),		GPU_BUFFER_TEXCOORD_UNIT_0_STATE = (1 << 2),
GPU_BUFFER_TEXCOORD_UNIT_2_STATE = (1 << 3),		GPU_BUFFER_TEXCOORD_UNIT_2_STATE = (1 << 3),
GPU_BUFFER_COLOR_STATE = (1 << 4),		GPU_BUFFER_COLOR_STATE = (1 << 4),
GPU_BUFFER_ELEMENT_STATE = (1 << 5),		GPU_BUFFER_ELEMENT_STATE = (1 << 5),
} GPUBufferState;		} GPUBufferState;
▲ Show 20 Lines • Show All 545 Lines • ▼ Show 20 Lines
/* call gpu_buffer_setup with settings for a particular type of buffer */		/* call gpu_buffer_setup with settings for a particular type of buffer */
static GPUBuffer gpu_buffer_setup_type(DerivedMesh dm, GPUBufferType type)		static GPUBuffer gpu_buffer_setup_type(DerivedMesh dm, GPUBufferType type)
{		{
void *user_data = NULL;		void *user_data = NULL;
GPUBuffer *buf;		GPUBuffer *buf;

/* special handling for MCol and UV buffers */		/* special handling for MCol and UV buffers */
if (type == GPU_BUFFER_COLOR) {		if (type == GPU_BUFFER_COLOR) {
if (!(user_data = DM_get_tessface_data_layer(dm, dm->drawObject->colType)))		if (!(user_data = DM_get_loop_data_layer(dm, dm->drawObject->colType)))
return NULL;		return NULL;
}		}
else if (ELEM(type, GPU_BUFFER_UV, GPU_BUFFER_UV_TEXPAINT)) {		else if (ELEM(type, GPU_BUFFER_UV, GPU_BUFFER_UV_TEXPAINT)) {
if (!DM_get_tessface_data_layer(dm, CD_MTFACE))		if (!DM_get_loop_data_layer(dm, CD_MLOOPUV))
return NULL;		return NULL;
}		}

buf = gpu_buffer_setup(dm, dm->drawObject, type, user_data);		buf = gpu_buffer_setup(dm, dm->drawObject, type, user_data);

return buf;		return buf;
}		}

▲ Show 20 Lines • Show All 402 Lines • ▼ Show 20 Lines
} VertexBufferFormat;		} VertexBufferFormat;

struct GPU_PBVH_Buffers {		struct GPU_PBVH_Buffers {
/* opengl buffer handles */		/* opengl buffer handles */
GLuint vert_buf, index_buf, index_buf_fast;		GLuint vert_buf, index_buf, index_buf_fast;
GLenum index_type;		GLenum index_type;

/* mesh pointers in case buffer allocation fails */		/* mesh pointers in case buffer allocation fails */
const MFace *mface;		const MPoly *mpoly;
		const MLoop *mloop;
		const MLoopTri *looptri;
const MVert *mvert;		const MVert *mvert;
const int *face_indices;		const int *face_indices;
int totface;		int totface;
const float *vmask;		const float *vmask;

/* grid pointers */		/* grid pointers */
CCGKey gridkey;		CCGKey gridkey;
CCGElem **grids;		CCGElem **grids;
▲ Show 20 Lines • Show All 95 Lines • ▼ Show 20 Lines
}		}

void GPU_update_mesh_pbvh_buffers(		void GPU_update_mesh_pbvh_buffers(
GPU_PBVH_Buffers buffers, const MVert mvert,		GPU_PBVH_Buffers buffers, const MVert mvert,
const int vert_indices, int totvert, const float vmask,		const int vert_indices, int totvert, const float vmask,
const int (*face_vert_indices)[4], bool show_diffuse_color)		const int (*face_vert_indices)[4], bool show_diffuse_color)
{		{
VertexBufferFormat *vert_data;		VertexBufferFormat *vert_data;
int i, j, k;		int i, j;

buffers->vmask = vmask;		buffers->vmask = vmask;
buffers->show_diffuse_color = show_diffuse_color;		buffers->show_diffuse_color = show_diffuse_color;
buffers->use_matcaps = GPU_material_use_matcaps_get();		buffers->use_matcaps = GPU_material_use_matcaps_get();

if (buffers->vert_buf) {		if (buffers->vert_buf) {
int totelem = (buffers->smooth ? totvert : (buffers->tot_tri * 3));		int totelem = (buffers->smooth ? totvert : (buffers->tot_tri * 3));
float diffuse_color[4] = {0.8f, 0.8f, 0.8f, 0.8f};		float diffuse_color[4] = {0.8f, 0.8f, 0.8f, 0.8f};

if (buffers->use_matcaps)		if (buffers->use_matcaps)
diffuse_color[0] = diffuse_color[1] = diffuse_color[2] = 1.0;		diffuse_color[0] = diffuse_color[1] = diffuse_color[2] = 1.0;
else if (show_diffuse_color) {		else if (show_diffuse_color) {
const MFace *f = buffers->mface + buffers->face_indices[0];		const MLoopTri *lt = &buffers->looptri[buffers->face_indices[0]];
		const MPoly *mp = &buffers->mpoly[lt->poly];

GPU_material_diffuse_get(f->mat_nr + 1, diffuse_color);		GPU_material_diffuse_get(mp->mat_nr + 1, diffuse_color);
}		}

copy_v4_v4(buffers->diffuse_color, diffuse_color);		copy_v4_v4(buffers->diffuse_color, diffuse_color);

/* Build VBO */		/* Build VBO */
glBindBufferARB(GL_ARRAY_BUFFER_ARB, buffers->vert_buf);		glBindBufferARB(GL_ARRAY_BUFFER_ARB, buffers->vert_buf);
glBufferDataARB(GL_ARRAY_BUFFER_ARB,		glBufferDataARB(GL_ARRAY_BUFFER_ARB,
sizeof(VertexBufferFormat) * totelem,		sizeof(VertexBufferFormat) * totelem,
Show All 19 Lines	#define UPDATE_VERTEX(face, vertex, index, diffuse_color) \
VertexBufferFormat *out = vert_data + face_vert_indices[face][index]; \		VertexBufferFormat *out = vert_data + face_vert_indices[face][index]; \
if (vmask) \		if (vmask) \
gpu_color_from_mask_copy(vmask[vertex], diffuse_color, out->color); \		gpu_color_from_mask_copy(vmask[vertex], diffuse_color, out->color); \
else \		else \
rgb_float_to_uchar(out->color, diffuse_color); \		rgb_float_to_uchar(out->color, diffuse_color); \
} (void)0		} (void)0

for (i = 0; i < buffers->totface; i++) {		for (i = 0; i < buffers->totface; i++) {
const MFace *f = buffers->mface + buffers->face_indices[i];		const MLoopTri *lt = &buffers->looptri[buffers->face_indices[i]];
		const unsigned int vtri[3] = {
		buffers->mloop[lt->tri[0]].v,
		buffers->mloop[lt->tri[1]].v,
		buffers->mloop[lt->tri[2]].v,
		};

UPDATE_VERTEX(i, f->v1, 0, diffuse_color);		UPDATE_VERTEX(i, vtri[0], 0, diffuse_color);
UPDATE_VERTEX(i, f->v2, 1, diffuse_color);		UPDATE_VERTEX(i, vtri[1], 1, diffuse_color);
UPDATE_VERTEX(i, f->v3, 2, diffuse_color);		UPDATE_VERTEX(i, vtri[2], 2, diffuse_color);
if (f->v4)
UPDATE_VERTEX(i, f->v4, 3, diffuse_color);
}		}
#undef UPDATE_VERTEX		#undef UPDATE_VERTEX
}		}
else {		else {
for (i = 0; i < buffers->totface; ++i) {		for (i = 0; i < buffers->totface; ++i) {
const MFace *f = &buffers->mface[buffers->face_indices[i]];		const MLoopTri *lt = &buffers->looptri[buffers->face_indices[i]];
const unsigned int *fv = &f->v1;		const unsigned int vtri[3] = {
const int vi[2][3] = {{0, 1, 2}, {3, 0, 2}};		buffers->mloop[lt->tri[0]].v,
		buffers->mloop[lt->tri[1]].v,
		buffers->mloop[lt->tri[2]].v,
		};
float fno[3];		float fno[3];
short no[3];		short no[3];

float fmask;		float fmask;

if (paint_is_face_hidden(f, mvert))		if (paint_is_face_hidden(lt, mvert, buffers->mloop))
continue;		continue;

/* Face normal and mask */		/* Face normal and mask */
if (f->v4) {
normal_quad_v3(fno,
mvert[fv[0]].co,
mvert[fv[1]].co,
mvert[fv[2]].co,
mvert[fv[3]].co);
if (vmask) {
fmask = (vmask[fv[0]] +
vmask[fv[1]] +
vmask[fv[2]] +
vmask[fv[3]]) * 0.25f;
}
}
else {
normal_tri_v3(fno,		normal_tri_v3(fno,
mvert[fv[0]].co,		mvert[vtri[0]].co,
mvert[fv[1]].co,		mvert[vtri[1]].co,
mvert[fv[2]].co);		mvert[vtri[2]].co);
if (vmask) {		if (vmask) {
fmask = (vmask[fv[0]] +		fmask = (vmask[vtri[0]] +
vmask[fv[1]] +		vmask[vtri[1]] +
vmask[fv[2]]) / 3.0f;		vmask[vtri[2]]) / 3.0f;
}
}		}
normal_float_to_short_v3(no, fno);		normal_float_to_short_v3(no, fno);

for (j = 0; j < (f->v4 ? 2 : 1); j++) {		for (j = 0; j < 3; j++) {
for (k = 0; k < 3; k++) {		const MVert *v = &mvert[vtri[j]];
const MVert *v = &mvert[fv[vi[j][k]]];
VertexBufferFormat *out = vert_data;		VertexBufferFormat *out = vert_data;

copy_v3_v3(out->co, v->co);		copy_v3_v3(out->co, v->co);
memcpy(out->no, no, sizeof(short) * 3);		memcpy(out->no, no, sizeof(short) * 3);

if (vmask)		if (vmask)
gpu_color_from_mask_copy(fmask, diffuse_color, out->color);		gpu_color_from_mask_copy(fmask, diffuse_color, out->color);
else		else
rgb_float_to_uchar(out->color, diffuse_color);		rgb_float_to_uchar(out->color, diffuse_color);

vert_data++;		vert_data++;
}		}
}		}
}		}
}

glUnmapBufferARB(GL_ARRAY_BUFFER_ARB);		glUnmapBufferARB(GL_ARRAY_BUFFER_ARB);
}		}
else {		else {
glDeleteBuffersARB(1, &buffers->vert_buf);		glDeleteBuffersARB(1, &buffers->vert_buf);
buffers->vert_buf = 0;		buffers->vert_buf = 0;
}		}

glBindBufferARB(GL_ARRAY_BUFFER_ARB, 0);		glBindBufferARB(GL_ARRAY_BUFFER_ARB, 0);
}		}

buffers->mvert = mvert;		buffers->mvert = mvert;
}		}

GPU_PBVH_Buffers *GPU_build_mesh_pbvh_buffers(		GPU_PBVH_Buffers *GPU_build_mesh_pbvh_buffers(
const int (*face_vert_indices)[4],		const int (*face_vert_indices)[4],
const MFace mface, const MVert mvert,		const MPoly mpoly, const MLoop mloop, const MLoopTri *looptri,
		const MVert *mvert,
const int *face_indices,		const int *face_indices,
int totface)		int looptri_num)
{		{
GPU_PBVH_Buffers *buffers;		GPU_PBVH_Buffers *buffers;
unsigned short *tri_data;		unsigned short *tri_data;
int i, j, k, tottri;		int i, j, tottri;

buffers = MEM_callocN(sizeof(GPU_PBVH_Buffers), "GPU_Buffers");		buffers = MEM_callocN(sizeof(GPU_PBVH_Buffers), "GPU_Buffers");
buffers->index_type = GL_UNSIGNED_SHORT;		buffers->index_type = GL_UNSIGNED_SHORT;
buffers->smooth = mface[face_indices[0]].flag & ME_SMOOTH;		buffers->smooth = mpoly[face_indices[0]].flag & ME_SMOOTH;

buffers->show_diffuse_color = false;		buffers->show_diffuse_color = false;
buffers->use_matcaps = false;		buffers->use_matcaps = false;

/* Count the number of visible triangles */		/* Count the number of visible triangles */
for (i = 0, tottri = 0; i < totface; ++i) {		for (i = 0, tottri = 0; i < looptri_num; ++i) {
const MFace *f = &mface[face_indices[i]];		const MLoopTri *lt = &looptri[face_indices[i]];
if (!paint_is_face_hidden(f, mvert))		if (!paint_is_face_hidden(lt, mvert, mloop))
tottri += f->v4 ? 2 : 1;		tottri++;
}		}

if (tottri == 0) {		if (tottri == 0) {
buffers->tot_tri = 0;		buffers->tot_tri = 0;

buffers->mface = mface;		buffers->mpoly = mpoly;
		buffers->mloop = mloop;
		buffers->looptri = looptri;
buffers->face_indices = face_indices;		buffers->face_indices = face_indices;
buffers->totface = 0;		buffers->totface = 0;

return buffers;		return buffers;
}		}

/* An element index buffer is used for smooth shading, but flat		/* An element index buffer is used for smooth shading, but flat
* shading requires separate vertex normals so an index buffer is		* shading requires separate vertex normals so an index buffer is
* can't be used there. */		* can't be used there. */
if (gpu_vbo_enabled() && buffers->smooth)		if (gpu_vbo_enabled() && buffers->smooth)
glGenBuffersARB(1, &buffers->index_buf);		glGenBuffersARB(1, &buffers->index_buf);

if (buffers->index_buf) {		if (buffers->index_buf) {
/* Generate index buffer object */		/* Generate index buffer object */
glBindBufferARB(GL_ELEMENT_ARRAY_BUFFER_ARB, buffers->index_buf);		glBindBufferARB(GL_ELEMENT_ARRAY_BUFFER_ARB, buffers->index_buf);
glBufferDataARB(GL_ELEMENT_ARRAY_BUFFER_ARB,		glBufferDataARB(GL_ELEMENT_ARRAY_BUFFER_ARB,
sizeof(unsigned short) * tottri * 3, NULL, GL_STATIC_DRAW_ARB);		sizeof(unsigned short) * tottri * 3, NULL, GL_STATIC_DRAW_ARB);

/* Fill the triangle buffer */		/* Fill the triangle buffer */
tri_data = glMapBufferARB(GL_ELEMENT_ARRAY_BUFFER_ARB, GL_WRITE_ONLY_ARB);		tri_data = glMapBufferARB(GL_ELEMENT_ARRAY_BUFFER_ARB, GL_WRITE_ONLY_ARB);
if (tri_data) {		if (tri_data) {
for (i = 0; i < totface; ++i) {		for (i = 0; i < looptri_num; ++i) {
const MFace *f = mface + face_indices[i];		const MLoopTri *lt = &looptri[face_indices[i]];
int v[3];

/* Skip hidden faces */		/* Skip hidden faces */
if (paint_is_face_hidden(f, mvert))		if (paint_is_face_hidden(lt, mvert, mloop))
continue;		continue;

v[0] = 0;		for (j = 0; j < 3; ++j) {
v[1] = 1;		*tri_data = face_vert_indices[i][j];
v[2] = 2;

for (j = 0; j < (f->v4 ? 2 : 1); ++j) {
for (k = 0; k < 3; ++k) {
*tri_data = face_vert_indices[i][v[k]];
tri_data++;		tri_data++;
}		}
v[0] = 3;
v[1] = 0;
v[2] = 2;
}
}		}
glUnmapBufferARB(GL_ELEMENT_ARRAY_BUFFER_ARB);		glUnmapBufferARB(GL_ELEMENT_ARRAY_BUFFER_ARB);
}		}
else {		else {
glDeleteBuffersARB(1, &buffers->index_buf);		glDeleteBuffersARB(1, &buffers->index_buf);
buffers->index_buf = 0;		buffers->index_buf = 0;
}		}

glBindBufferARB(GL_ELEMENT_ARRAY_BUFFER_ARB, 0);		glBindBufferARB(GL_ELEMENT_ARRAY_BUFFER_ARB, 0);
}		}

if (gpu_vbo_enabled() && (buffers->index_buf \|\| !buffers->smooth))		if (gpu_vbo_enabled() && (buffers->index_buf \|\| !buffers->smooth))
glGenBuffersARB(1, &buffers->vert_buf);		glGenBuffersARB(1, &buffers->vert_buf);

buffers->tot_tri = tottri;		buffers->tot_tri = tottri;

buffers->mface = mface;		buffers->mpoly = mpoly;
		buffers->mloop = mloop;
		buffers->looptri = looptri;

buffers->face_indices = face_indices;		buffers->face_indices = face_indices;
buffers->totface = totface;		buffers->totface = looptri_num;

return buffers;		return buffers;
}		}

void GPU_update_grid_pbvh_buffers(GPU_PBVH_Buffers buffers, CCGElem *grids,		void GPU_update_grid_pbvh_buffers(GPU_PBVH_Buffers buffers, CCGElem *grids,
const DMFlagMat grid_flag_mats, int grid_indices,		const DMFlagMat grid_flag_mats, int grid_indices,
int totgrid, const CCGKey *key, bool show_diffuse_color)		int totgrid, const CCGKey *key, bool show_diffuse_color)
{		{
▲ Show 20 Lines • Show All 581 Lines • ▼ Show 20 Lines	GPU_PBVH_Buffers *GPU_build_bmesh_pbvh_buffers(int smooth_shading)
return buffers;		return buffers;
}		}

static void gpu_draw_buffers_legacy_mesh(GPU_PBVH_Buffers *buffers)		static void gpu_draw_buffers_legacy_mesh(GPU_PBVH_Buffers *buffers)
{		{
const MVert *mvert = buffers->mvert;		const MVert *mvert = buffers->mvert;
int i, j;		int i, j;
const int has_mask = (buffers->vmask != NULL);		const int has_mask = (buffers->vmask != NULL);
const MFace *face = &buffers->mface[buffers->face_indices[0]];		const MLoopTri *lt = &buffers->looptri[buffers->face_indices[0]];
		const MPoly *mp = &buffers->mpoly[lt->poly];
float diffuse_color[4] = {0.8f, 0.8f, 0.8f, 1.0f};		float diffuse_color[4] = {0.8f, 0.8f, 0.8f, 1.0f};

if (buffers->use_matcaps)		if (buffers->use_matcaps)
diffuse_color[0] = diffuse_color[1] = diffuse_color[2] = 1.0;		diffuse_color[0] = diffuse_color[1] = diffuse_color[2] = 1.0;
else if (buffers->show_diffuse_color)		else if (buffers->show_diffuse_color)
GPU_material_diffuse_get(face->mat_nr + 1, diffuse_color);		GPU_material_diffuse_get(mp->mat_nr + 1, diffuse_color);

if (has_mask) {		if (has_mask) {
gpu_colors_enable(VBO_DISABLED);		gpu_colors_enable(VBO_DISABLED);
}		}

for (i = 0; i < buffers->totface; ++i) {		for (i = 0; i < buffers->totface; ++i) {
const MFace *f = &buffers->mface[buffers->face_indices[i]];		const MLoopTri *lt = &buffers->looptri[buffers->face_indices[i]];
int S = f->v4 ? 4 : 3;		int sides = 3;
const unsigned int *fv = &f->v1;		const unsigned int vtri[3] = {
		buffers->mloop[lt->tri[0]].v,
		buffers->mloop[lt->tri[1]].v,
		buffers->mloop[lt->tri[2]].v,
		};

if (paint_is_face_hidden(f, buffers->mvert))		if (paint_is_face_hidden(lt, buffers->mvert, buffers->mloop))
continue;		continue;

glBegin((f->v4) ? GL_QUADS : GL_TRIANGLES);		glBegin(GL_TRIANGLES);

if (buffers->smooth) {		if (buffers->smooth) {
for (j = 0; j < S; j++) {		for (j = 0; j < sides; j++) {
if (has_mask) {		if (has_mask) {
gpu_color_from_mask_set(buffers->vmask[fv[j]], diffuse_color);		gpu_color_from_mask_set(buffers->vmask[vtri[j]], diffuse_color);
}		}
glNormal3sv(mvert[fv[j]].no);		glNormal3sv(mvert[vtri[j]].no);
glVertex3fv(mvert[fv[j]].co);		glVertex3fv(mvert[vtri[j]].co);
}		}
}		}
else {		else {
float fno[3];		float fno[3];

/* calculate face normal */		/* calculate face normal */
if (f->v4) {		normal_tri_v3(fno, mvert[vtri[0]].co, mvert[vtri[1]].co, mvert[vtri[2]].co);
normal_quad_v3(fno, mvert[fv[0]].co, mvert[fv[1]].co,
mvert[fv[2]].co, mvert[fv[3]].co);
}
else
normal_tri_v3(fno, mvert[fv[0]].co, mvert[fv[1]].co, mvert[fv[2]].co);
glNormal3fv(fno);		glNormal3fv(fno);

if (has_mask) {		if (has_mask) {
float fmask;		float fmask;

/* calculate face mask color */		/* calculate face mask color */
fmask = (buffers->vmask[fv[0]] +		fmask = (buffers->vmask[vtri[0]] +
buffers->vmask[fv[1]] +		buffers->vmask[vtri[1]] +
buffers->vmask[fv[2]]);		buffers->vmask[vtri[2]]) / 3.0f;
if (f->v4)
fmask = (fmask + buffers->vmask[fv[3]]) * 0.25f;
else
fmask /= 3.0f;
gpu_color_from_mask_set(fmask, diffuse_color);		gpu_color_from_mask_set(fmask, diffuse_color);
}		}

for (j = 0; j < S; j++)		for (j = 0; j < sides; j++)
glVertex3fv(mvert[fv[j]].co);		glVertex3fv(mvert[vtri[j]].co);
}		}

glEnd();		glEnd();
}		}

if (has_mask) {		if (has_mask) {
gpu_colors_disable(VBO_DISABLED);		gpu_colors_disable(VBO_DISABLED);
}		}
▲ Show 20 Lines • Show All 130 Lines • ▼ Show 20 Lines
void GPU_draw_pbvh_buffers(GPU_PBVH_Buffers *buffers, DMSetMaterial setMaterial,		void GPU_draw_pbvh_buffers(GPU_PBVH_Buffers *buffers, DMSetMaterial setMaterial,
bool wireframe, bool fast)		bool wireframe, bool fast)
{		{
bool do_fast = fast && buffers->index_buf_fast;		bool do_fast = fast && buffers->index_buf_fast;
/* sets material from the first face, to solve properly face would need to		/* sets material from the first face, to solve properly face would need to
* be sorted in buckets by materials */		* be sorted in buckets by materials */
if (setMaterial) {		if (setMaterial) {
if (buffers->totface) {		if (buffers->totface) {
const MFace *f = &buffers->mface[buffers->face_indices[0]];		const MLoopTri *lt = &buffers->looptri[buffers->face_indices[0]];
if (!setMaterial(f->mat_nr + 1, NULL))		const MPoly *mp = &buffers->mpoly[lt->poly];
		if (!setMaterial(mp->mat_nr + 1, NULL))
return;		return;
}		}
else if (buffers->totgrid) {		else if (buffers->totgrid) {
const DMFlagMat *f = &buffers->grid_flag_mats[buffers->grid_indices[0]];		const DMFlagMat *f = &buffers->grid_flag_mats[buffers->grid_indices[0]];
if (!setMaterial(f->mat_nr + 1, NULL))		if (!setMaterial(f->mat_nr + 1, NULL))
return;		return;
}		}
else {		else {
▲ Show 20 Lines • Show All 87 Lines • ▼ Show 20 Lines	if (buffers->show_diffuse_color != show_diffuse_color)
return true;		return true;

if (buffers->use_matcaps != use_matcaps)		if (buffers->use_matcaps != use_matcaps)
return true;		return true;

if ((buffers->show_diffuse_color == false) \|\| use_matcaps)		if ((buffers->show_diffuse_color == false) \|\| use_matcaps)
return false;		return false;

if (buffers->mface) {		if (buffers->looptri) {
const MFace *f = &buffers->mface[buffers->face_indices[0]];		const MLoopTri *lt = &buffers->looptri[buffers->face_indices[0]];
		const MPoly *mp = &buffers->mpoly[lt->poly];

GPU_material_diffuse_get(f->mat_nr + 1, diffuse_color);		GPU_material_diffuse_get(mp->mat_nr + 1, diffuse_color);
}		}
else if (buffers->use_bmesh) {		else if (buffers->use_bmesh) {
/* due to dynamic nature of dyntopo, only get first material */		/* due to dynamic nature of dyntopo, only get first material */
if (BLI_gset_size(bm_faces) > 0) {		if (BLI_gset_size(bm_faces) > 0) {
GSetIterator gs_iter;		GSetIterator gs_iter;
BMFace *f;		BMFace *f;

BLI_gsetIterator_init(&gs_iter, bm_faces);		BLI_gsetIterator_init(&gs_iter, bm_faces);
▲ Show 20 Lines • Show All 128 Lines • Show Last 20 Lines