Differential D3554 Diff 22834 source/blender/gpu/intern/gpu_texture.c

Changeset View

Standalone View

source/blender/gpu/intern/gpu_texture.c

Show First 20 Lines • Show All 76 Lines • ▼ Show 20 Lines	struct GPUTexture {
GLenum target; /* GL_TEXTURE_* */		GLenum target; /* GL_TEXTURE_* */
GLenum target_base; /* same as target, (but no multisample)		GLenum target_base; /* same as target, (but no multisample)
* use it for unbinding */		* use it for unbinding */
GLuint bindcode; /* opengl identifier for texture */		GLuint bindcode; /* opengl identifier for texture */

eGPUTextureFormat format;		eGPUTextureFormat format;
eGPUTextureFormatFlag format_flag;		eGPUTextureFormatFlag format_flag;

uint bytesize; /* number of byte for one pixel */		int mipmaps; /* number of mipmaps. */
int components; /* number of color/alpha channels */		int components; /* number of color/alpha channels */
int samples; /* number of samples for multisamples textures. 0 if not multisample target */		int samples; /* number of samples for multisamples textures. 0 if not multisample target */

int fb_attachment[GPU_TEX_MAX_FBO_ATTACHED];		int fb_attachment[GPU_TEX_MAX_FBO_ATTACHED];
GPUFrameBuffer *fb[GPU_TEX_MAX_FBO_ATTACHED];		GPUFrameBuffer *fb[GPU_TEX_MAX_FBO_ATTACHED];
};		};

		static uint gpu_get_bytesize(eGPUTextureFormat data_type);

/* ------ Memory Management ------- */		/* ------ Memory Management ------- */
/* Records every texture allocation / free		/* Records every texture allocation / free
* to estimate the Texture Pool Memory consumption */		* to estimate the Texture Pool Memory consumption */
static uint memory_usage;		static uint memory_usage;

static uint gpu_texture_memory_footprint_compute(GPUTexture *tex)		static uint gpu_texture_memory_footprint_compute(GPUTexture *tex)
{		{
int samp = max_ii(tex->samples, 1);		uint memsize;
		const uint bytesize = gpu_get_bytesize(tex->format);
		const int samp = max_ii(tex->samples, 1);
switch (tex->target_base) {		switch (tex->target_base) {
case GL_TEXTURE_1D:		case GL_TEXTURE_1D:
return tex->bytesize * tex->w * samp;		memsize = bytesize * tex->w * samp;
		break;
case GL_TEXTURE_1D_ARRAY:		case GL_TEXTURE_1D_ARRAY:
case GL_TEXTURE_2D:		case GL_TEXTURE_2D:
return tex->bytesize * tex->w * tex->h * samp;		memsize = bytesize * tex->w * tex->h * samp;
		break;
case GL_TEXTURE_2D_ARRAY:		case GL_TEXTURE_2D_ARRAY:
case GL_TEXTURE_3D:		case GL_TEXTURE_3D:
return tex->bytesize * tex->w * tex->h * tex->d * samp;		memsize = bytesize * tex->w * tex->h * tex->d * samp;
		break;
case GL_TEXTURE_CUBE_MAP:		case GL_TEXTURE_CUBE_MAP:
return tex->bytesize * 6 * tex->w * tex->h * samp;		memsize = bytesize * 6 * tex->w * tex->h * samp;
		break;
case GL_TEXTURE_CUBE_MAP_ARRAY_ARB:		case GL_TEXTURE_CUBE_MAP_ARRAY_ARB:
return tex->bytesize * 6 * tex->w * tex->h * tex->d * samp;		memsize = bytesize * 6 * tex->w * tex->h * tex->d * samp;
		break;
default:		default:
		BLI_assert(0);
return 0;		return 0;
}		}
		if (tex->mipmaps != 0) {
		/* Just to get an idea of the memory used here is computed
		* as if the maximum number of mipmaps was generated. */
		memsize += memsize / 3;
		}

		return memsize;
}		}

static void gpu_texture_memory_footprint_add(GPUTexture *tex)		static void gpu_texture_memory_footprint_add(GPUTexture *tex)
{		{
memory_usage += gpu_texture_memory_footprint_compute(tex);		memory_usage += gpu_texture_memory_footprint_compute(tex);
}		}

static void gpu_texture_memory_footprint_remove(GPUTexture *tex)		static void gpu_texture_memory_footprint_remove(GPUTexture *tex)
▲ Show 20 Lines • Show All 232 Lines • ▼ Show 20 Lines	switch (data_type) {
case GPU_RGBA32F:		case GPU_RGBA32F:
return 32;		return 32;
case GPU_RG32F:		case GPU_RG32F:
case GPU_RGBA16F:		case GPU_RGBA16F:
case GPU_RGBA16:		case GPU_RGBA16:
return 16;		return 16;
case GPU_RGB16F:		case GPU_RGB16F:
return 12;		return 12;
case GPU_DEPTH32F_STENCIL8:		case GPU_DEPTH32F_STENCIL8: /* 32-bit depth, 8 bits stencil, and 24 unused bites. */
		fclemUnsubmitted Done Inline Actions typo: bits * fclem: typo: bits *
return 8;		return 8;
case GPU_RG16F:		case GPU_RG16F:
case GPU_RG16I:		case GPU_RG16I:
case GPU_RG16UI:		case GPU_RG16UI:
case GPU_RG16:		case GPU_RG16:
case GPU_DEPTH24_STENCIL8:		case GPU_DEPTH24_STENCIL8:
case GPU_DEPTH_COMPONENT32F:		case GPU_DEPTH_COMPONENT32F:
case GPU_RGBA8UI:		case GPU_RGBA8UI:
Show All 17 Lines	switch (data_type) {
case GPU_R8UI:		case GPU_R8UI:
return 1;		return 1;
default:		default:
BLI_assert(!"Texture format incorrect or unsupported\n");		BLI_assert(!"Texture format incorrect or unsupported\n");
return 0;		return 0;
}		}
}		}

static GLenum gpu_get_gl_internalformat(eGPUTextureFormat format)		static GLenum gpu_get_gl_internalformat(eGPUTextureFormat format)
		fclemUnsubmitted Done Inline Actions change function name to `gpu_format_to_gl_internalformat` fclem: change function name to `gpu_format_to_gl_internalformat`
{		{
/* You can add any of the available type to this list		/* You can add any of the available type to this list
		fclemUnsubmitted Done Inline Actions I don't really like this. Keep the switch case and duplicate for `gl_internalformat_to_gpu_format`. We could use macros to avoid too much duplication. fclem: I don't really like this. Keep the switch case and duplicate for…
* For available types see GPU_texture.h */		* For available types see GPU_texture.h */
switch (format) {		switch (format) {
/* Formats texture & renderbuffer */		/* Formats texture & renderbuffer */
case GPU_RGBA32F:		case GPU_RGBA32F:
return GL_RGBA32F;		return GL_RGBA32F;
case GPU_RGBA16F:		case GPU_RGBA16F:
return GL_RGBA16F;		return GL_RGBA16F;
case GPU_RGBA16:		case GPU_RGBA16:
▲ Show 20 Lines • Show All 56 Lines • ▼ Show 20 Lines	case GPU_DEPTH_COMPONENT16:
return GL_DEPTH_COMPONENT16;		return GL_DEPTH_COMPONENT16;
default:		default:
BLI_assert(!"Texture format incorrect or unsupported\n");		BLI_assert(!"Texture format incorrect or unsupported\n");
return 0;		return 0;
}		}
}		}

static GLenum gpu_get_gl_datatype(eGPUDataFormat format)		static GLenum gpu_get_gl_datatype(eGPUDataFormat format)
{		{
		fclemUnsubmitted Done Inline Actions change function name to `gl_internalformat_to_gpu_format` fclem: change function name to `gl_internalformat_to_gpu_format`
switch (format) {		switch (format) {
case GPU_DATA_FLOAT:		case GPU_DATA_FLOAT:
return GL_FLOAT;		return GL_FLOAT;
case GPU_DATA_INT:		case GPU_DATA_INT:
return GL_INT;		return GL_INT;
case GPU_DATA_UNSIGNED_INT:		case GPU_DATA_UNSIGNED_INT:
return GL_UNSIGNED_INT;		return GL_UNSIGNED_INT;
case GPU_DATA_UNSIGNED_BYTE:		case GPU_DATA_UNSIGNED_BYTE:
▲ Show 20 Lines • Show All 202 Lines • ▼ Show 20 Lines	GPUTexture *GPU_texture_create_nD(int w,
tex->w = w;		tex->w = w;
tex->h = h;		tex->h = h;
tex->d = d;		tex->d = d;
tex->samples = samples;		tex->samples = samples;
tex->number = -1;		tex->number = -1;
tex->refcount = 1;		tex->refcount = 1;
tex->format = tex_format;		tex->format = tex_format;
tex->components = gpu_get_component_count(tex_format);		tex->components = gpu_get_component_count(tex_format);
tex->bytesize = gpu_get_bytesize(tex_format);		tex->mipmaps = 0;
tex->format_flag = 0;		tex->format_flag = 0;

if (n == 2) {		if (n == 2) {
if (d == 0) {		if (d == 0) {
tex->target_base = tex->target = GL_TEXTURE_2D;		tex->target_base = tex->target = GL_TEXTURE_2D;
}		}
else {		else {
tex->target_base = tex->target = GL_TEXTURE_2D_ARRAY;		tex->target_base = tex->target = GL_TEXTURE_2D_ARRAY;
▲ Show 20 Lines • Show All 170 Lines • ▼ Show 20 Lines	GPUTexture *GPU_texture_cube_create(int w,
tex->w = w;		tex->w = w;
tex->h = w;		tex->h = w;
tex->d = d;		tex->d = d;
tex->samples = 0;		tex->samples = 0;
tex->number = -1;		tex->number = -1;
tex->refcount = 1;		tex->refcount = 1;
tex->format = tex_format;		tex->format = tex_format;
tex->components = gpu_get_component_count(tex_format);		tex->components = gpu_get_component_count(tex_format);
tex->bytesize = gpu_get_bytesize(tex_format);		tex->mipmaps = 0;
tex->format_flag = GPU_FORMAT_CUBE;		tex->format_flag = GPU_FORMAT_CUBE;

if (d == 0) {		if (d == 0) {
tex->target_base = tex->target = GL_TEXTURE_CUBE_MAP;		tex->target_base = tex->target = GL_TEXTURE_CUBE_MAP;
}		}
else {		else {
tex->target_base = tex->target = GL_TEXTURE_CUBE_MAP_ARRAY_ARB;		tex->target_base = tex->target = GL_TEXTURE_CUBE_MAP_ARRAY_ARB;
tex->format_flag \|= GPU_FORMAT_ARRAY;		tex->format_flag \|= GPU_FORMAT_ARRAY;
▲ Show 20 Lines • Show All 114 Lines • ▼ Show 20 Lines
{		{
GPUTexture *tex = MEM_callocN(sizeof(GPUTexture), "GPUTexture");		GPUTexture *tex = MEM_callocN(sizeof(GPUTexture), "GPUTexture");
tex->number = -1;		tex->number = -1;
tex->refcount = 1;		tex->refcount = 1;
tex->format = tex_format;		tex->format = tex_format;
tex->components = gpu_get_component_count(tex_format);		tex->components = gpu_get_component_count(tex_format);
tex->format_flag = 0;		tex->format_flag = 0;
tex->target_base = tex->target = GL_TEXTURE_BUFFER;		tex->target_base = tex->target = GL_TEXTURE_BUFFER;
tex->bytesize = gpu_get_bytesize(tex_format);		tex->mipmaps = 0;

GLenum internalformat = gpu_get_gl_internalformat(tex_format);		GLenum internalformat = gpu_get_gl_internalformat(tex_format);

gpu_get_gl_dataformat(tex_format, &tex->format_flag);		gpu_get_gl_dataformat(tex_format, &tex->format_flag);

if (!(ELEM(tex_format, GPU_R8, GPU_R16) \|\| ELEM(tex_format, GPU_R16F, GPU_R32F) \|\|		if (!(ELEM(tex_format, GPU_R8, GPU_R16) \|\| ELEM(tex_format, GPU_R16F, GPU_R32F) \|\|
ELEM(tex_format, GPU_R8I, GPU_R16I, GPU_R32I) \|\|		ELEM(tex_format, GPU_R8I, GPU_R16I, GPU_R32I) \|\|
ELEM(tex_format, GPU_R8UI, GPU_R16UI, GPU_R32UI) \|\| ELEM(tex_format, GPU_RG8, GPU_RG16) \|\|		ELEM(tex_format, GPU_R8UI, GPU_R16UI, GPU_R32UI) \|\| ELEM(tex_format, GPU_RG8, GPU_RG16) \|\|
▲ Show 20 Lines • Show All 52 Lines • ▼ Show 20 Lines	else {
}		}

glBindTexture(textarget, tex->bindcode);		glBindTexture(textarget, tex->bindcode);
glGetTexLevelParameteriv(gettarget, 0, GL_TEXTURE_WIDTH, &w);		glGetTexLevelParameteriv(gettarget, 0, GL_TEXTURE_WIDTH, &w);
glGetTexLevelParameteriv(gettarget, 0, GL_TEXTURE_HEIGHT, &h);		glGetTexLevelParameteriv(gettarget, 0, GL_TEXTURE_HEIGHT, &h);
tex->w = w;		tex->w = w;
tex->h = h;		tex->h = h;
glBindTexture(textarget, 0);		glBindTexture(textarget, 0);

		/* Depending on how this bindcode was obtained, the memory used here could
		* already have been computed.
		* But that is not the case currently. */
		gpu_texture_memory_footprint_add(tex);
}		}

return tex;		return tex;
}		}

GPUTexture *GPU_texture_create_1d(int w,		GPUTexture *GPU_texture_create_1d(int w,
eGPUTextureFormat tex_format,		eGPUTextureFormat tex_format,
const float *pixels,		const float *pixels,
▲ Show 20 Lines • Show All 168 Lines • ▼ Show 20 Lines

void GPU_texture_add_mipmap(GPUTexture *tex,		void GPU_texture_add_mipmap(GPUTexture *tex,
eGPUDataFormat gpu_data_format,		eGPUDataFormat gpu_data_format,
int miplvl,		int miplvl,
const void *pixels)		const void *pixels)
{		{
BLI_assert((int)tex->format > -1);		BLI_assert((int)tex->format > -1);
BLI_assert(tex->components > -1);		BLI_assert(tex->components > -1);
		BLI_assert(tex->mipmaps < miplvl);
		fclemUnsubmitted Done Inline Actions Prefer testing miplvl > tex->mipmaps. fclem: Prefer testing miplvl > tex->mipmaps.

gpu_validate_data_format(tex->format, gpu_data_format);		gpu_validate_data_format(tex->format, gpu_data_format);

GLenum internalformat = gpu_get_gl_internalformat(tex->format);		GLenum internalformat = gpu_get_gl_internalformat(tex->format);
GLenum data_format = gpu_get_gl_dataformat(tex->format, &tex->format_flag);		GLenum data_format = gpu_get_gl_dataformat(tex->format, &tex->format_flag);
GLenum data_type = gpu_get_gl_datatype(gpu_data_format);		GLenum data_type = gpu_get_gl_datatype(gpu_data_format);

glBindTexture(tex->target, tex->bindcode);		glBindTexture(tex->target, tex->bindcode);
Show All 33 Lines	case GL_TEXTURE_CUBE_MAP_ARRAY_ARB:
pixels);		pixels);
break;		break;
case GL_TEXTURE_2D_MULTISAMPLE:		case GL_TEXTURE_2D_MULTISAMPLE:
/* Multisample textures cannot have mipmaps. */		/* Multisample textures cannot have mipmaps. */
default:		default:
BLI_assert(!"tex->target mode not supported");		BLI_assert(!"tex->target mode not supported");
}		}

		tex->mipmaps = miplvl;
glTexParameteri(GPU_texture_target(tex), GL_TEXTURE_MAX_LEVEL, miplvl);		glTexParameteri(GPU_texture_target(tex), GL_TEXTURE_MAX_LEVEL, miplvl);

glBindTexture(tex->target, 0);		glBindTexture(tex->target, 0);
}		}

void GPU_texture_update_sub(GPUTexture *tex,		void GPU_texture_update_sub(GPUTexture *tex,
eGPUDataFormat gpu_data_format,		eGPUDataFormat gpu_data_format,
const void *pixels,		const void *pixels,
int offset_x,		int offset_x,
int offset_y,		int offset_y,
int offset_z,		int offset_z,
int width,		int width,
int height,		int height,
int depth)		int depth)
{		{
BLI_assert((int)tex->format > -1);		BLI_assert((int)tex->format > -1);
BLI_assert(tex->components > -1);		BLI_assert(tex->components > -1);

		const uint bytesize = gpu_get_bytesize(tex->format);
GLenum data_format = gpu_get_gl_dataformat(tex->format, &tex->format_flag);		GLenum data_format = gpu_get_gl_dataformat(tex->format, &tex->format_flag);
GLenum data_type = gpu_get_gl_datatype(gpu_data_format);		GLenum data_type = gpu_get_gl_datatype(gpu_data_format);
GLint alignment;		GLint alignment;

/* The default pack size for textures is 4, which won't work for byte based textures */		/* The default pack size for textures is 4, which won't work for byte based textures */
if (tex->bytesize == 1) {		if (bytesize == 1) {
glGetIntegerv(GL_UNPACK_ALIGNMENT, &alignment);		glGetIntegerv(GL_UNPACK_ALIGNMENT, &alignment);
glPixelStorei(GL_UNPACK_ALIGNMENT, 1);		glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
}		}

glBindTexture(tex->target, tex->bindcode);		glBindTexture(tex->target, tex->bindcode);
switch (tex->target) {		switch (tex->target) {
case GL_TEXTURE_1D:		case GL_TEXTURE_1D:
glTexSubImage1D(tex->target, 0, offset_x, width, data_format, data_type, pixels);		glTexSubImage1D(tex->target, 0, offset_x, width, data_format, data_type, pixels);
Show All 17 Lines	case GL_TEXTURE_2D_ARRAY:
data_format,		data_format,
data_type,		data_type,
pixels);		pixels);
break;		break;
default:		default:
BLI_assert(!"tex->target mode not supported");		BLI_assert(!"tex->target mode not supported");
}		}

if (tex->bytesize == 1) {		if (bytesize == 1) {
glPixelStorei(GL_UNPACK_ALIGNMENT, alignment);		glPixelStorei(GL_UNPACK_ALIGNMENT, alignment);
}		}

glBindTexture(tex->target, 0);		glBindTexture(tex->target, 0);
}		}

void GPU_texture_read(GPUTexture tex, eGPUDataFormat gpu_data_format, int miplvl)		void GPU_texture_read(GPUTexture tex, eGPUDataFormat gpu_data_format, int miplvl)
{		{
		BLI_assert(tex->mipmaps >= miplvl);
		fclemUnsubmitted Done Inline Actions Prefer testing miplvl <= tex->mipmaps fclem: Prefer testing miplvl <= tex->mipmaps

int size[3] = {0, 0, 0};		int size[3] = {0, 0, 0};
GPU_texture_get_mipmap_size(tex, miplvl, size);		GPU_texture_get_mipmap_size(tex, miplvl, size);

gpu_validate_data_format(tex->format, gpu_data_format);		gpu_validate_data_format(tex->format, gpu_data_format);

size_t samples_count = max_ii(1, tex->samples);		size_t samples_count = max_ii(1, tex->samples);
samples_count *= size[0];		samples_count *= size[0];
samples_count *= max_ii(1, size[1]);		samples_count *= max_ii(1, size[1]);
Show All 36 Lines	if (GLEW_ARB_clear_texture) {
GLenum data_format = gpu_get_gl_dataformat(tex->format, &tex->format_flag);		GLenum data_format = gpu_get_gl_dataformat(tex->format, &tex->format_flag);
GLenum data_type = gpu_get_gl_datatype(gpu_data_format);		GLenum data_type = gpu_get_gl_datatype(gpu_data_format);
glClearTexImage(tex->bindcode, 0, data_format, data_type, color);		glClearTexImage(tex->bindcode, 0, data_format, data_type, color);
}		}
else {		else {
size_t buffer_len = gpu_texture_memory_footprint_compute(tex);		size_t buffer_len = gpu_texture_memory_footprint_compute(tex);
unsigned char *pixels = MEM_mallocN(buffer_len, __func__);		unsigned char *pixels = MEM_mallocN(buffer_len, __func__);
if (color) {		if (color) {
size_t bytesize = tex->bytesize;		const uint bytesize = (size_t)gpu_get_bytesize(tex->format);
		fclemUnsubmitted Done Inline Actions why uint? fclem: why uint?
for (size_t byte = 0; byte < buffer_len; byte += bytesize) {		for (size_t byte = 0; byte < buffer_len; byte += bytesize) {
memcpy(&pixels[byte], color, bytesize);		memcpy(&pixels[byte], color, bytesize);
}		}
}		}
else {		else {
memset(pixels, 0, buffer_len);		memset(pixels, 0, buffer_len);
}		}
GPU_texture_update(tex, gpu_data_format, pixels);		GPU_texture_update(tex, gpu_data_format, pixels);
▲ Show 20 Lines • Show All 102 Lines • ▼ Show 20 Lines	#define WARN_NOT_BOUND(_tex) \
} \		} \
} \		} \
((void)0)		((void)0)

void GPU_texture_generate_mipmap(GPUTexture *tex)		void GPU_texture_generate_mipmap(GPUTexture *tex)
{		{
WARN_NOT_BOUND(tex);		WARN_NOT_BOUND(tex);

		gpu_texture_memory_footprint_remove(tex);
		int levels = 1 + floor(log2(max_ii(tex->w, tex->h)));

glActiveTexture(GL_TEXTURE0 + tex->number);		glActiveTexture(GL_TEXTURE0 + tex->number);

if (GPU_texture_depth(tex)) {		if (GPU_texture_depth(tex)) {
/* Some drivers have bugs when using glGenerateMipmap with depth textures (see T56789).		/* Some drivers have bugs when using glGenerateMipmap with depth textures (see T56789).
* In this case we just create a complete texture with mipmaps manually without down-sampling.		* In this case we just create a complete texture with mipmaps manually without down-sampling.
* You must initialize the texture levels using other methods like		* You must initialize the texture levels using other methods like
* GPU_framebuffer_recursive_downsample(). */		* GPU_framebuffer_recursive_downsample(). */
int levels = 1 + floor(log2(max_ii(tex->w, tex->h)));
eGPUDataFormat data_format = gpu_get_data_format_from_tex_format(tex->format);		eGPUDataFormat data_format = gpu_get_data_format_from_tex_format(tex->format);
for (int i = 1; i < levels; i++) {		for (int i = 1; i < levels; i++) {
GPU_texture_add_mipmap(tex, data_format, i, NULL);		GPU_texture_add_mipmap(tex, data_format, i, NULL);
}		}
glBindTexture(tex->target, tex->bindcode);		glBindTexture(tex->target, tex->bindcode);
}		}
else {		else {
glGenerateMipmap(tex->target_base);		glGenerateMipmap(tex->target_base);
}		}

		tex->mipmaps = (short)levels;
		gpu_texture_memory_footprint_add(tex);
}		}

void GPU_texture_compare_mode(GPUTexture *tex, bool use_compare)		void GPU_texture_compare_mode(GPUTexture *tex, bool use_compare)
{		{
WARN_NOT_BOUND(tex);		WARN_NOT_BOUND(tex);

/* Could become an assertion ? (fclem) */		/* Could become an assertion ? (fclem) */
if (!GPU_texture_depth(tex)) {		if (!GPU_texture_depth(tex)) {
▲ Show 20 Lines • Show All 252 Lines • Show Last 20 Lines