GPUTexture: Change texture creation API
This is to modernize the API: - Add meaningful name to all textures (except DRW textures). - Remove unused err_out argument: only used for offscreen python. - Add mipmap count to creation functions for future changes. - Clarify the data usage in creation functions. This is a cleanup commit, there is no functional change. # Conflicts: # source/blender/gpu/GPU_texture.h
This commit is contained in:
parent
bac4606937
commit
ab95cdaba9
Notes:
blender-bot
2023-02-14 02:27:51 +01:00
Referenced by issue #80533, VSE: Sequencer & Playhead drawing is broken after hibernate
|
@ -282,18 +282,20 @@ static void ensureGLSLLut3d(OCIO_GLSLLut3d **lut3d_ptr,
|
|||
|
||||
OCIO_GLSLLut3d *lut3d = OBJECT_GUARDED_NEW(OCIO_GLSLLut3d);
|
||||
|
||||
for (int i = 0; i < 2; i++) {
|
||||
int extent[3] = {LUT3D_EDGE_SIZE, LUT3D_EDGE_SIZE, LUT3D_EDGE_SIZE};
|
||||
GPUTexture *tex = GPU_texture_create_3d(UNPACK3(extent), GPU_RGB16F, NULL, NULL);
|
||||
GPU_texture_filter_mode(tex, true);
|
||||
GPU_texture_wrap_mode(tex, false, true);
|
||||
int extent[3] = {LUT3D_EDGE_SIZE, LUT3D_EDGE_SIZE, LUT3D_EDGE_SIZE};
|
||||
|
||||
(&lut3d->texture)[i] = tex;
|
||||
}
|
||||
lut3d->texture = GPU_texture_create_3d("OCIOLut", UNPACK3(extent), 1, GPU_RGB16F, NULL);
|
||||
GPU_texture_filter_mode(lut3d->texture, true);
|
||||
GPU_texture_wrap_mode(lut3d->texture, false, true);
|
||||
|
||||
lut3d->texture_display = GPU_texture_create_3d(
|
||||
"OCIOLutDisplay", UNPACK3(extent), 1, GPU_RGB16F, NULL);
|
||||
GPU_texture_filter_mode(lut3d->texture_display, true);
|
||||
GPU_texture_wrap_mode(lut3d->texture_display, false, true);
|
||||
|
||||
updateGLSLLut3d(lut3d, processor_scene_to_ui, processpr_ui_to_display, shaderDesc, cache_id);
|
||||
|
||||
lut3d->valid = (lut3d->texture != 0);
|
||||
lut3d->valid = (lut3d->texture && lut3d->texture_display);
|
||||
|
||||
*lut3d_ptr = lut3d;
|
||||
}
|
||||
|
@ -316,7 +318,7 @@ static void allocateCurveMappingTexture(OCIO_GLSLCurveMappping *curvemap,
|
|||
{
|
||||
int lut_size = curve_mapping_settings ? curve_mapping_settings->lut_size : 1;
|
||||
/* Do not initialize. Only if used. */
|
||||
curvemap->texture = GPU_texture_create_1d(lut_size, GPU_RGBA16F, NULL, NULL);
|
||||
curvemap->texture = GPU_texture_create_1d("OCIOCurveMap", lut_size, 1, GPU_RGBA16F, NULL);
|
||||
GPU_texture_filter_mode(curvemap->texture, false);
|
||||
GPU_texture_wrap_mode(curvemap->texture, false, true);
|
||||
}
|
||||
|
|
|
@ -508,7 +508,7 @@ void blf_glyph_render(FontBLF *font, GlyphCacheBLF *gc, GlyphBLF *g, float x, fl
|
|||
if (gc->texture) {
|
||||
GPU_texture_free(gc->texture);
|
||||
}
|
||||
gc->texture = GPU_texture_create_1d_array(w, h, GPU_R8, false, NULL);
|
||||
gc->texture = GPU_texture_create_1d_array(__func__, w, h, 1, GPU_R8, NULL);
|
||||
|
||||
gc->bitmap_len_landed = 0;
|
||||
}
|
||||
|
|
|
@ -95,7 +95,7 @@ static GPUTexture *gpu_texture_create_tile_mapping(Image *ima, const int multivi
|
|||
tile_info[3] = tile->runtime.tilearray_size[1] / array_h;
|
||||
}
|
||||
|
||||
GPUTexture *tex = GPU_texture_create_1d_array(width, 2, GPU_RGBA32F, data, NULL);
|
||||
GPUTexture *tex = GPU_texture_create_1d_array(ima->id.name + 2, width, 2, 1, GPU_RGBA32F, data);
|
||||
GPU_texture_mipmap_mode(tex, false, false);
|
||||
|
||||
MEM_freeN(data);
|
||||
|
@ -180,7 +180,7 @@ static GPUTexture *gpu_texture_create_tile_array(Image *ima, ImBuf *main_ibuf)
|
|||
const bool use_high_bitdepth = (ima->flag & IMA_HIGH_BITDEPTH);
|
||||
/* Create Texture without content. */
|
||||
GPUTexture *tex = IMB_touch_gpu_texture(
|
||||
main_ibuf, arraywidth, arrayheight, arraylayers, use_high_bitdepth);
|
||||
ima->id.name + 2, main_ibuf, arraywidth, arrayheight, arraylayers, use_high_bitdepth);
|
||||
|
||||
/* Upload each tile one by one. */
|
||||
LISTBASE_FOREACH (ImageTile *, tile, &ima->tiles) {
|
||||
|
@ -316,7 +316,8 @@ static GPUTexture *image_get_gpu_texture(Image *ima,
|
|||
(ima ? (ima->alpha_mode != IMA_ALPHA_STRAIGHT) : false) :
|
||||
(ima ? (ima->alpha_mode == IMA_ALPHA_PREMUL) : true);
|
||||
|
||||
*tex = IMB_create_gpu_texture(ibuf_intern, use_high_bitdepth, store_premultiplied);
|
||||
*tex = IMB_create_gpu_texture(
|
||||
ima->id.name + 2, ibuf_intern, use_high_bitdepth, store_premultiplied);
|
||||
|
||||
if (GPU_mipmap_enabled()) {
|
||||
GPU_texture_generate_mipmap(*tex);
|
||||
|
|
|
@ -1924,7 +1924,7 @@ GPUTexture *BKE_movieclip_get_gpu_texture(MovieClip *clip, MovieClipUser *cuser)
|
|||
/* This only means RGBA16F instead of RGBA32F. */
|
||||
const bool high_bitdepth = false;
|
||||
const bool store_premultiplied = ibuf->rect_float ? false : true;
|
||||
*tex = IMB_create_gpu_texture(ibuf, high_bitdepth, store_premultiplied);
|
||||
*tex = IMB_create_gpu_texture(clip->id.name + 2, ibuf, high_bitdepth, store_premultiplied);
|
||||
|
||||
/* Do not generate mips for movieclips... too slow. */
|
||||
GPU_texture_mipmap_mode(*tex, false, true);
|
||||
|
|
|
@ -500,7 +500,7 @@ static void studiolight_create_equirect_radiance_gputexture(StudioLight *sl)
|
|||
ImBuf *ibuf = sl->equirect_radiance_buffer;
|
||||
|
||||
sl->equirect_radiance_gputexture = GPU_texture_create_2d(
|
||||
ibuf->x, ibuf->y, GPU_RGBA16F, ibuf->rect_float, NULL);
|
||||
"studiolight_radiance", ibuf->x, ibuf->y, 1, GPU_RGBA16F, ibuf->rect_float);
|
||||
GPUTexture *tex = sl->equirect_radiance_gputexture;
|
||||
GPU_texture_filter_mode(tex, true);
|
||||
GPU_texture_wrap_mode(tex, true, true);
|
||||
|
@ -520,7 +520,7 @@ static void studiolight_create_matcap_gputexture(StudioLightImage *sli)
|
|||
copy_v3_v3(*offset3, *offset4);
|
||||
}
|
||||
|
||||
sli->gputexture = GPU_texture_create_2d(ibuf->x, ibuf->y, GPU_R11F_G11F_B10F, NULL, NULL);
|
||||
sli->gputexture = GPU_texture_create_2d("matcap", ibuf->x, ibuf->y, 1, GPU_R11F_G11F_B10F, NULL);
|
||||
GPU_texture_update(sli->gputexture, GPU_DATA_FLOAT, gpu_matcap_3components);
|
||||
|
||||
MEM_SAFE_FREE(gpu_matcap_3components);
|
||||
|
@ -555,7 +555,7 @@ static void studiolight_create_equirect_irradiance_gputexture(StudioLight *sl)
|
|||
BKE_studiolight_ensure_flag(sl, STUDIOLIGHT_EQUIRECT_IRRADIANCE_IMAGE_CALCULATED);
|
||||
ImBuf *ibuf = sl->equirect_irradiance_buffer;
|
||||
sl->equirect_irradiance_gputexture = GPU_texture_create_2d(
|
||||
ibuf->x, ibuf->y, GPU_RGBA16F, ibuf->rect_float, NULL);
|
||||
"studiolight_irradiance", ibuf->x, ibuf->y, 1, GPU_RGBA16F, ibuf->rect_float);
|
||||
GPUTexture *tex = sl->equirect_irradiance_gputexture;
|
||||
GPU_texture_filter_mode(tex, true);
|
||||
GPU_texture_wrap_mode(tex, true, true);
|
||||
|
|
|
@ -402,7 +402,7 @@ static bool eevee_lightcache_static_load(LightCache *lcache)
|
|||
|
||||
if (lcache->grid_tx.tex == NULL) {
|
||||
lcache->grid_tx.tex = GPU_texture_create_2d_array(
|
||||
UNPACK3(lcache->grid_tx.tex_size), IRRADIANCE_FORMAT, NULL, NULL);
|
||||
"lightcache_irradiance", UNPACK3(lcache->grid_tx.tex_size), 1, IRRADIANCE_FORMAT, NULL);
|
||||
GPU_texture_update(lcache->grid_tx.tex, GPU_DATA_UNSIGNED_BYTE, lcache->grid_tx.data);
|
||||
|
||||
if (lcache->grid_tx.tex == NULL) {
|
||||
|
@ -415,17 +415,19 @@ static bool eevee_lightcache_static_load(LightCache *lcache)
|
|||
|
||||
if (lcache->cube_tx.tex == NULL) {
|
||||
if (GPU_arb_texture_cube_map_array_is_supported()) {
|
||||
lcache->cube_tx.tex = GPU_texture_create_cube_array(lcache->cube_tx.tex_size[0],
|
||||
lcache->cube_tx.tex = GPU_texture_create_cube_array("lightcache_cubemaps",
|
||||
lcache->cube_tx.tex_size[0],
|
||||
lcache->cube_tx.tex_size[2] / 6,
|
||||
lcache->mips_len + 1,
|
||||
GPU_R11F_G11F_B10F,
|
||||
NULL,
|
||||
NULL);
|
||||
GPU_texture_update(lcache->cube_tx.tex, GPU_DATA_10_11_11_REV, lcache->cube_tx.data);
|
||||
}
|
||||
else {
|
||||
lcache->cube_tx.tex = GPU_texture_create_2d_array(
|
||||
UNPACK3(lcache->cube_tx.tex_size), GPU_R11F_G11F_B10F, NULL, NULL);
|
||||
GPU_texture_update(lcache->cube_tx.tex, GPU_DATA_10_11_11_REV, lcache->cube_tx.data);
|
||||
lcache->cube_tx.tex = GPU_texture_create_2d_array("lightcache_cubemaps_fallback",
|
||||
UNPACK3(lcache->cube_tx.tex_size),
|
||||
lcache->mips_len + 1,
|
||||
GPU_R11F_G11F_B10F,
|
||||
NULL);
|
||||
}
|
||||
|
||||
if (lcache->cube_tx.tex == NULL) {
|
||||
|
@ -433,9 +435,9 @@ static bool eevee_lightcache_static_load(LightCache *lcache)
|
|||
return false;
|
||||
}
|
||||
|
||||
for (int mip = 0; mip < lcache->mips_len; mip++) {
|
||||
GPU_texture_add_mipmap(
|
||||
lcache->cube_tx.tex, GPU_DATA_10_11_11_REV, mip + 1, lcache->cube_mips[mip].data);
|
||||
for (int mip = 0; mip <= lcache->mips_len; mip++) {
|
||||
const void *data = (mip == 0) ? lcache->cube_tx.data : lcache->cube_mips[mip - 1].data;
|
||||
GPU_texture_update_mipmap(lcache->cube_tx.tex, mip, GPU_DATA_10_11_11_REV, data);
|
||||
}
|
||||
GPU_texture_mipmap_mode(lcache->cube_tx.tex, true, true);
|
||||
}
|
||||
|
|
|
@ -468,7 +468,7 @@ void EEVEE_motion_blur_cache_finish(EEVEE_Data *vedata)
|
|||
GPU_vertbuf_use(mb_hair->psys[i].hair_pos[mb_step]);
|
||||
|
||||
mb_hair->psys[i].hair_pos_tx[mb_step] = GPU_texture_create_from_vertbuf(
|
||||
mb_hair->psys[i].hair_pos[mb_step]);
|
||||
"hair_pos_motion_blur", mb_hair->psys[i].hair_pos[mb_step]);
|
||||
}
|
||||
}
|
||||
break;
|
||||
|
|
|
@ -57,10 +57,11 @@ void GPENCIL_antialiasing_init(struct GPENCIL_Data *vedata)
|
|||
|
||||
if (txl->smaa_search_tx == NULL) {
|
||||
txl->smaa_search_tx = GPU_texture_create_2d(
|
||||
SEARCHTEX_WIDTH, SEARCHTEX_HEIGHT, GPU_R8, NULL, NULL);
|
||||
"smaa_search", SEARCHTEX_WIDTH, SEARCHTEX_HEIGHT, 1, GPU_R8, NULL);
|
||||
GPU_texture_update(txl->smaa_search_tx, GPU_DATA_UNSIGNED_BYTE, searchTexBytes);
|
||||
|
||||
txl->smaa_area_tx = GPU_texture_create_2d(AREATEX_WIDTH, AREATEX_HEIGHT, GPU_RG8, NULL, NULL);
|
||||
txl->smaa_area_tx = GPU_texture_create_2d(
|
||||
"smaa_area", AREATEX_WIDTH, AREATEX_HEIGHT, 1, GPU_RG8, NULL);
|
||||
GPU_texture_update(txl->smaa_area_tx, GPU_DATA_UNSIGNED_BYTE, areaTexBytes);
|
||||
|
||||
GPU_texture_filter_mode(txl->smaa_search_tx, true);
|
||||
|
|
|
@ -79,7 +79,8 @@ static void select_engine_framebuffer_setup(void)
|
|||
GPU_framebuffer_texture_attach(e_data.framebuffer_select_id, dtxl->depth, 0, 0);
|
||||
|
||||
if (e_data.texture_u32 == NULL) {
|
||||
e_data.texture_u32 = GPU_texture_create_2d(size[0], size[1], GPU_R32UI, NULL, NULL);
|
||||
e_data.texture_u32 = GPU_texture_create_2d(
|
||||
"select_buf_ids", size[0], size[1], 1, GPU_R32UI, NULL);
|
||||
GPU_framebuffer_texture_attach(e_data.framebuffer_select_id, e_data.texture_u32, 0, 0);
|
||||
|
||||
GPU_framebuffer_check_valid(e_data.framebuffer_select_id, NULL);
|
||||
|
|
|
@ -243,11 +243,11 @@ void workbench_antialiasing_engine_init(WORKBENCH_Data *vedata)
|
|||
/* TODO could be shared for all viewports. */
|
||||
if (txl->smaa_search_tx == NULL) {
|
||||
txl->smaa_search_tx = GPU_texture_create_2d(
|
||||
SEARCHTEX_WIDTH, SEARCHTEX_HEIGHT, GPU_R8, NULL, NULL);
|
||||
"smaa_search", SEARCHTEX_WIDTH, SEARCHTEX_HEIGHT, 1, GPU_R8, NULL);
|
||||
GPU_texture_update(txl->smaa_search_tx, GPU_DATA_UNSIGNED_BYTE, searchTexBytes);
|
||||
|
||||
txl->smaa_area_tx = GPU_texture_create_2d(
|
||||
AREATEX_WIDTH, AREATEX_HEIGHT, GPU_RG8, NULL, NULL);
|
||||
"smaa_area", AREATEX_WIDTH, AREATEX_HEIGHT, 1, GPU_RG8, NULL);
|
||||
GPU_texture_update(txl->smaa_area_tx, GPU_DATA_UNSIGNED_BYTE, areaTexBytes);
|
||||
|
||||
GPU_texture_filter_mode(txl->smaa_search_tx, true);
|
||||
|
|
|
@ -79,8 +79,8 @@ static bool workbench_render_framebuffers_init(void)
|
|||
* the other views will reuse these buffers */
|
||||
if (dtxl->color == NULL) {
|
||||
BLI_assert(dtxl->depth == NULL);
|
||||
dtxl->color = GPU_texture_create_2d(size[0], size[1], GPU_RGBA16F, NULL, NULL);
|
||||
dtxl->depth = GPU_texture_create_2d(size[0], size[1], GPU_DEPTH24_STENCIL8, NULL, NULL);
|
||||
dtxl->color = GPU_texture_create_2d("txl.color", UNPACK2(size), 1, GPU_RGBA16F, NULL);
|
||||
dtxl->depth = GPU_texture_create_2d("txl.depth", UNPACK2(size), 1, GPU_DEPTH24_STENCIL8, NULL);
|
||||
}
|
||||
|
||||
if (!(dtxl->depth && dtxl->color)) {
|
||||
|
|
|
@ -45,9 +45,9 @@ void workbench_volume_engine_init(WORKBENCH_Data *vedata)
|
|||
if (txl->dummy_volume_tx == NULL) {
|
||||
const float zero[4] = {0.0f, 0.0f, 0.0f, 0.0f};
|
||||
const float one[4] = {1.0f, 1.0f, 1.0f, 1.0f};
|
||||
txl->dummy_volume_tx = GPU_texture_create_3d(1, 1, 1, GPU_RGBA8, zero, NULL);
|
||||
txl->dummy_shadow_tx = GPU_texture_create_3d(1, 1, 1, GPU_RGBA8, one, NULL);
|
||||
txl->dummy_coba_tx = GPU_texture_create_1d(1, GPU_RGBA8, zero, NULL);
|
||||
txl->dummy_volume_tx = GPU_texture_create_3d("dummy_volume", 1, 1, 1, 1, GPU_RGBA8, zero);
|
||||
txl->dummy_shadow_tx = GPU_texture_create_3d("dummy_shadow", 1, 1, 1, 1, GPU_RGBA8, one);
|
||||
txl->dummy_coba_tx = GPU_texture_create_1d("dummy_coba", 1, 1, GPU_RGBA8, zero);
|
||||
}
|
||||
}
|
||||
|
||||
|
|
|
@ -192,7 +192,7 @@ static void hair_batch_cache_ensure_procedural_pos(Hair *hair, ParticleHairCache
|
|||
/* Create vbo immediately to bind to texture buffer. */
|
||||
GPU_vertbuf_use(cache->proc_point_buf);
|
||||
|
||||
cache->point_tex = GPU_texture_create_from_vertbuf(cache->proc_point_buf);
|
||||
cache->point_tex = GPU_texture_create_from_vertbuf("hair_point", cache->proc_point_buf);
|
||||
}
|
||||
|
||||
static void hair_batch_cache_fill_strands_data(Hair *hair,
|
||||
|
@ -230,10 +230,11 @@ static void hair_batch_cache_ensure_procedural_strand_data(Hair *hair, ParticleH
|
|||
|
||||
/* Create vbo immediately to bind to texture buffer. */
|
||||
GPU_vertbuf_use(cache->proc_strand_buf);
|
||||
cache->strand_tex = GPU_texture_create_from_vertbuf(cache->proc_strand_buf);
|
||||
cache->strand_tex = GPU_texture_create_from_vertbuf("hair_strand", cache->proc_strand_buf);
|
||||
|
||||
GPU_vertbuf_use(cache->proc_strand_seg_buf);
|
||||
cache->strand_seg_tex = GPU_texture_create_from_vertbuf(cache->proc_strand_seg_buf);
|
||||
cache->strand_seg_tex = GPU_texture_create_from_vertbuf("hair_strand_seg",
|
||||
cache->proc_strand_seg_buf);
|
||||
}
|
||||
|
||||
static void hair_batch_cache_ensure_procedural_final_points(ParticleHairCache *cache, int subdiv)
|
||||
|
@ -252,7 +253,8 @@ static void hair_batch_cache_ensure_procedural_final_points(ParticleHairCache *c
|
|||
/* Create vbo immediately to bind to texture buffer. */
|
||||
GPU_vertbuf_use(cache->final[subdiv].proc_buf);
|
||||
|
||||
cache->final[subdiv].proc_tex = GPU_texture_create_from_vertbuf(cache->final[subdiv].proc_buf);
|
||||
cache->final[subdiv].proc_tex = GPU_texture_create_from_vertbuf("hair_proc",
|
||||
cache->final[subdiv].proc_buf);
|
||||
}
|
||||
|
||||
static void hair_batch_cache_fill_segments_indices(Hair *hair,
|
||||
|
|
|
@ -809,7 +809,8 @@ static void particle_batch_cache_ensure_procedural_final_points(ParticleHairCach
|
|||
/* Create vbo immediately to bind to texture buffer. */
|
||||
GPU_vertbuf_use(cache->final[subdiv].proc_buf);
|
||||
|
||||
cache->final[subdiv].proc_tex = GPU_texture_create_from_vertbuf(cache->final[subdiv].proc_buf);
|
||||
cache->final[subdiv].proc_tex = GPU_texture_create_from_vertbuf("part_proc",
|
||||
cache->final[subdiv].proc_buf);
|
||||
}
|
||||
|
||||
static void particle_batch_cache_ensure_procedural_strand_data(PTCacheEdit *edit,
|
||||
|
@ -1008,18 +1009,19 @@ static void particle_batch_cache_ensure_procedural_strand_data(PTCacheEdit *edit
|
|||
|
||||
/* Create vbo immediately to bind to texture buffer. */
|
||||
GPU_vertbuf_use(cache->proc_strand_buf);
|
||||
cache->strand_tex = GPU_texture_create_from_vertbuf(cache->proc_strand_buf);
|
||||
cache->strand_tex = GPU_texture_create_from_vertbuf("part_strand", cache->proc_strand_buf);
|
||||
|
||||
GPU_vertbuf_use(cache->proc_strand_seg_buf);
|
||||
cache->strand_seg_tex = GPU_texture_create_from_vertbuf(cache->proc_strand_seg_buf);
|
||||
cache->strand_seg_tex = GPU_texture_create_from_vertbuf("part_strand_seg",
|
||||
cache->proc_strand_seg_buf);
|
||||
|
||||
for (int i = 0; i < cache->num_uv_layers; i++) {
|
||||
GPU_vertbuf_use(cache->proc_uv_buf[i]);
|
||||
cache->uv_tex[i] = GPU_texture_create_from_vertbuf(cache->proc_uv_buf[i]);
|
||||
cache->uv_tex[i] = GPU_texture_create_from_vertbuf("part_uv", cache->proc_uv_buf[i]);
|
||||
}
|
||||
for (int i = 0; i < cache->num_col_layers; i++) {
|
||||
GPU_vertbuf_use(cache->proc_col_buf[i]);
|
||||
cache->col_tex[i] = GPU_texture_create_from_vertbuf(cache->proc_col_buf[i]);
|
||||
cache->col_tex[i] = GPU_texture_create_from_vertbuf("part_col", cache->proc_col_buf[i]);
|
||||
}
|
||||
}
|
||||
|
||||
|
@ -1109,7 +1111,7 @@ static void particle_batch_cache_ensure_procedural_pos(PTCacheEdit *edit,
|
|||
/* Create vbo immediately to bind to texture buffer. */
|
||||
GPU_vertbuf_use(cache->proc_point_buf);
|
||||
|
||||
cache->point_tex = GPU_texture_create_from_vertbuf(cache->proc_point_buf);
|
||||
cache->point_tex = GPU_texture_create_from_vertbuf("part_point", cache->proc_point_buf);
|
||||
}
|
||||
|
||||
static void particle_batch_cache_ensure_pos_and_seg(PTCacheEdit *edit,
|
||||
|
|
|
@ -258,12 +258,9 @@ static DRWVolumeGrid *volume_grid_cache_get(Volume *volume,
|
|||
BKE_volume_grid_dense_voxels(volume, grid, dense_min, dense_max, voxels);
|
||||
|
||||
/* Create GPU texture. */
|
||||
cache_grid->texture = GPU_texture_create_3d(resolution[0],
|
||||
resolution[1],
|
||||
resolution[2],
|
||||
(channels == 3) ? GPU_RGB16F : GPU_R16F,
|
||||
voxels,
|
||||
NULL);
|
||||
eGPUTextureFormat format = (channels == 3) ? GPU_RGB16F : GPU_R16F;
|
||||
cache_grid->texture = GPU_texture_create_3d(
|
||||
"volume_grid", UNPACK3(resolution), 1, format, voxels);
|
||||
|
||||
GPU_texture_swizzle_set(cache_grid->texture, (channels == 3) ? "rgb1" : "rrr1");
|
||||
GPU_texture_wrap_mode(cache_grid->texture, false, false);
|
||||
|
|
|
@ -238,7 +238,7 @@ void DRW_globals_update(void)
|
|||
|
||||
BKE_colorband_evaluate_table_rgba(&ramp, &colors, &col_size);
|
||||
|
||||
G_draw.ramp = GPU_texture_create_1d(col_size, GPU_RGBA8, colors, NULL);
|
||||
G_draw.ramp = GPU_texture_create_1d("ramp", col_size, 1, GPU_RGBA8, colors);
|
||||
|
||||
MEM_freeN(colors);
|
||||
}
|
||||
|
@ -503,12 +503,11 @@ static void DRW_evaluate_weight_to_color(const float weight, float result[4])
|
|||
|
||||
static GPUTexture *DRW_create_weight_colorramp_texture(void)
|
||||
{
|
||||
char error[256];
|
||||
float pixels[256][4];
|
||||
for (int i = 0; i < 256; i++) {
|
||||
DRW_evaluate_weight_to_color(i / 255.0f, pixels[i]);
|
||||
pixels[i][3] = 1.0f;
|
||||
}
|
||||
|
||||
return GPU_texture_create_1d(256, GPU_SRGB8_A8, pixels[0], error);
|
||||
return GPU_texture_create_1d("weight_color_ramp", 256, 1, GPU_SRGB8_A8, pixels[0]);
|
||||
}
|
||||
|
|
|
@ -117,7 +117,7 @@ static GPUTexture *create_transfer_function(int type, const struct ColorBand *co
|
|||
break;
|
||||
}
|
||||
|
||||
GPUTexture *tex = GPU_texture_create_1d(TFUNC_WIDTH, GPU_SRGB8_A8, data, NULL);
|
||||
GPUTexture *tex = GPU_texture_create_1d("transf_func", TFUNC_WIDTH, 1, GPU_SRGB8_A8, data);
|
||||
|
||||
MEM_freeN(data);
|
||||
|
||||
|
@ -184,7 +184,7 @@ static GPUTexture *create_volume_texture(const int dim[3],
|
|||
int final_dim[3] = {UNPACK3(dim)};
|
||||
|
||||
while (1) {
|
||||
tex = GPU_texture_create_3d(UNPACK3(final_dim), format, NULL, NULL);
|
||||
tex = GPU_texture_create_3d("volume", UNPACK3(final_dim), 1, format, NULL);
|
||||
|
||||
if (tex != NULL) {
|
||||
break;
|
||||
|
@ -462,9 +462,9 @@ void DRW_smoke_ensure_velocity(FluidModifierData *fmd)
|
|||
}
|
||||
|
||||
if (!fds->tex_velocity_x) {
|
||||
fds->tex_velocity_x = GPU_texture_create_3d(UNPACK3(fds->res), GPU_R16F, vel_x, NULL);
|
||||
fds->tex_velocity_y = GPU_texture_create_3d(UNPACK3(fds->res), GPU_R16F, vel_y, NULL);
|
||||
fds->tex_velocity_z = GPU_texture_create_3d(UNPACK3(fds->res), GPU_R16F, vel_z, NULL);
|
||||
fds->tex_velocity_x = GPU_texture_create_3d("velx", UNPACK3(fds->res), 1, GPU_R16F, vel_x);
|
||||
fds->tex_velocity_y = GPU_texture_create_3d("vely", UNPACK3(fds->res), 1, GPU_R16F, vel_y);
|
||||
fds->tex_velocity_z = GPU_texture_create_3d("velz", UNPACK3(fds->res), 1, GPU_R16F, vel_z);
|
||||
}
|
||||
}
|
||||
#endif /* WITH_FLUID */
|
||||
|
|
|
@ -120,7 +120,7 @@ void DRW_hair_init(void)
|
|||
/* Create vbo immediately to bind to texture buffer. */
|
||||
GPU_vertbuf_use(g_dummy_vbo);
|
||||
|
||||
g_dummy_texture = GPU_texture_create_from_vertbuf(g_dummy_vbo);
|
||||
g_dummy_texture = GPU_texture_create_from_vertbuf("hair_dummy_attr", g_dummy_vbo);
|
||||
}
|
||||
}
|
||||
|
||||
|
|
|
@ -1929,7 +1929,7 @@ static void draw_select_framebuffer_depth_only_setup(const int size[2])
|
|||
|
||||
if (g_select_buffer.texture_depth == NULL) {
|
||||
g_select_buffer.texture_depth = GPU_texture_create_2d(
|
||||
size[0], size[1], GPU_DEPTH_COMPONENT24, NULL, NULL);
|
||||
"select_depth", size[0], size[1], 1, GPU_DEPTH_COMPONENT24, NULL);
|
||||
|
||||
GPU_framebuffer_texture_attach(
|
||||
g_select_buffer.framebuffer_depth_only, g_select_buffer.texture_depth, 0, 0);
|
||||
|
|
|
@ -81,7 +81,8 @@ GPUTexture *DRW_texture_create_1d(int w,
|
|||
DRWTextureFlag flags,
|
||||
const float *fpixels)
|
||||
{
|
||||
GPUTexture *tex = GPU_texture_create_1d(w, format, fpixels, NULL);
|
||||
int mips = (flags & DRW_TEX_MIPMAP) ? 9999 : 1;
|
||||
GPUTexture *tex = GPU_texture_create_1d(__func__, w, mips, format, fpixels);
|
||||
drw_texture_set_parameters(tex, flags);
|
||||
|
||||
return tex;
|
||||
|
@ -90,7 +91,8 @@ GPUTexture *DRW_texture_create_1d(int w,
|
|||
GPUTexture *DRW_texture_create_2d(
|
||||
int w, int h, eGPUTextureFormat format, DRWTextureFlag flags, const float *fpixels)
|
||||
{
|
||||
GPUTexture *tex = GPU_texture_create_2d(w, h, format, fpixels, NULL);
|
||||
int mips = (flags & DRW_TEX_MIPMAP) ? 9999 : 1;
|
||||
GPUTexture *tex = GPU_texture_create_2d(__func__, w, h, mips, format, fpixels);
|
||||
drw_texture_set_parameters(tex, flags);
|
||||
|
||||
return tex;
|
||||
|
@ -99,7 +101,8 @@ GPUTexture *DRW_texture_create_2d(
|
|||
GPUTexture *DRW_texture_create_2d_array(
|
||||
int w, int h, int d, eGPUTextureFormat format, DRWTextureFlag flags, const float *fpixels)
|
||||
{
|
||||
GPUTexture *tex = GPU_texture_create_2d_array(w, h, d, format, fpixels, NULL);
|
||||
int mips = (flags & DRW_TEX_MIPMAP) ? 9999 : 1;
|
||||
GPUTexture *tex = GPU_texture_create_2d_array(__func__, w, h, d, mips, format, fpixels);
|
||||
drw_texture_set_parameters(tex, flags);
|
||||
|
||||
return tex;
|
||||
|
@ -108,7 +111,8 @@ GPUTexture *DRW_texture_create_2d_array(
|
|||
GPUTexture *DRW_texture_create_3d(
|
||||
int w, int h, int d, eGPUTextureFormat format, DRWTextureFlag flags, const float *fpixels)
|
||||
{
|
||||
GPUTexture *tex = GPU_texture_create_3d(w, h, d, format, fpixels, NULL);
|
||||
int mips = (flags & DRW_TEX_MIPMAP) ? 9999 : 1;
|
||||
GPUTexture *tex = GPU_texture_create_3d(__func__, w, h, d, mips, format, fpixels);
|
||||
drw_texture_set_parameters(tex, flags);
|
||||
|
||||
return tex;
|
||||
|
@ -119,7 +123,8 @@ GPUTexture *DRW_texture_create_cube(int w,
|
|||
DRWTextureFlag flags,
|
||||
const float *fpixels)
|
||||
{
|
||||
GPUTexture *tex = GPU_texture_create_cube(w, format, fpixels, NULL);
|
||||
int mips = (flags & DRW_TEX_MIPMAP) ? 9999 : 1;
|
||||
GPUTexture *tex = GPU_texture_create_cube(__func__, w, mips, format, fpixels);
|
||||
drw_texture_set_parameters(tex, flags);
|
||||
return tex;
|
||||
}
|
||||
|
@ -127,7 +132,8 @@ GPUTexture *DRW_texture_create_cube(int w,
|
|||
GPUTexture *DRW_texture_create_cube_array(
|
||||
int w, int d, eGPUTextureFormat format, DRWTextureFlag flags, const float *fpixels)
|
||||
{
|
||||
GPUTexture *tex = GPU_texture_create_cube_array(w, d, format, fpixels, NULL);
|
||||
int mips = (flags & DRW_TEX_MIPMAP) ? 9999 : 1;
|
||||
GPUTexture *tex = GPU_texture_create_cube_array(__func__, w, d, mips, format, fpixels);
|
||||
drw_texture_set_parameters(tex, flags);
|
||||
return tex;
|
||||
}
|
||||
|
|
|
@ -866,16 +866,16 @@ void UI_icons_reload_internal_textures(void)
|
|||
icongltex.invw = 1.0f / b32buf->x;
|
||||
icongltex.invh = 1.0f / b32buf->y;
|
||||
|
||||
icongltex.tex[0] = GPU_texture_create_2d(b32buf->x, b32buf->y, GPU_RGBA8, NULL, NULL);
|
||||
GPU_texture_add_mipmap(icongltex.tex[0], GPU_DATA_UNSIGNED_BYTE, 0, b32buf->rect);
|
||||
GPU_texture_add_mipmap(icongltex.tex[0], GPU_DATA_UNSIGNED_BYTE, 1, b16buf->rect);
|
||||
icongltex.tex[0] = GPU_texture_create_2d("icons", b32buf->x, b32buf->y, 2, GPU_RGBA8, NULL);
|
||||
GPU_texture_update_mipmap(icongltex.tex[0], 0, GPU_DATA_UNSIGNED_BYTE, b32buf->rect);
|
||||
GPU_texture_update_mipmap(icongltex.tex[0], 1, GPU_DATA_UNSIGNED_BYTE, b16buf->rect);
|
||||
}
|
||||
|
||||
if (need_icons_with_border && icongltex.tex[1] == NULL) {
|
||||
icongltex.tex[1] = GPU_texture_create_2d(
|
||||
b32buf_border->x, b32buf_border->y, GPU_RGBA8, NULL, NULL);
|
||||
GPU_texture_add_mipmap(icongltex.tex[1], GPU_DATA_UNSIGNED_BYTE, 0, b32buf_border->rect);
|
||||
GPU_texture_add_mipmap(icongltex.tex[1], GPU_DATA_UNSIGNED_BYTE, 1, b16buf_border->rect);
|
||||
"icons_border", b32buf_border->x, b32buf_border->y, 2, GPU_RGBA8, NULL);
|
||||
GPU_texture_update_mipmap(icongltex.tex[1], 0, GPU_DATA_UNSIGNED_BYTE, b32buf_border->rect);
|
||||
GPU_texture_update_mipmap(icongltex.tex[1], 1, GPU_DATA_UNSIGNED_BYTE, b16buf_border->rect);
|
||||
}
|
||||
}
|
||||
|
||||
|
|
|
@ -132,7 +132,7 @@ void immDrawPixelsTexScaled_clipping(IMMDrawPixelsTexState *state,
|
|||
eGPUDataFormat gpu_data = (use_float_data) ? GPU_DATA_FLOAT : GPU_DATA_UNSIGNED_BYTE;
|
||||
size_t stride = components * ((use_float_data) ? sizeof(float) : sizeof(uchar));
|
||||
|
||||
GPUTexture *tex = GPU_texture_create_2d(tex_w, tex_h, gpu_format, NULL, NULL);
|
||||
GPUTexture *tex = GPU_texture_create_2d("immDrawPixels", tex_w, tex_h, 1, gpu_format, NULL);
|
||||
|
||||
GPU_texture_filter_mode(tex, use_filter);
|
||||
GPU_texture_wrap_mode(tex, false, true);
|
||||
|
|
|
@ -348,7 +348,8 @@ static int load_tex(Brush *br, ViewContext *vc, float zoom, bool col, bool prima
|
|||
|
||||
if (!target->overlay_texture) {
|
||||
eGPUTextureFormat format = col ? GPU_RGBA8 : GPU_R8;
|
||||
target->overlay_texture = GPU_texture_create_2d(size, size, format, NULL, NULL);
|
||||
target->overlay_texture = GPU_texture_create_2d(
|
||||
"paint_cursor_overlay", size, size, 1, format, NULL);
|
||||
GPU_texture_update(target->overlay_texture, GPU_DATA_UNSIGNED_BYTE, buffer);
|
||||
|
||||
if (!col) {
|
||||
|
@ -466,7 +467,8 @@ static int load_tex_cursor(Brush *br, ViewContext *vc, float zoom)
|
|||
BLI_task_parallel_range(0, size, &data, load_tex_cursor_task_cb, &settings);
|
||||
|
||||
if (!cursor_snap.overlay_texture) {
|
||||
cursor_snap.overlay_texture = GPU_texture_create_2d(size, size, GPU_R8, NULL, NULL);
|
||||
cursor_snap.overlay_texture = GPU_texture_create_2d(
|
||||
"cursor_snap_overaly", size, size, 1, GPU_R8, NULL);
|
||||
GPU_texture_update(cursor_snap.overlay_texture, GPU_DATA_UNSIGNED_BYTE, buffer);
|
||||
|
||||
GPU_texture_swizzle_set(cursor_snap.overlay_texture, "rrrr");
|
||||
|
|
|
@ -1211,7 +1211,8 @@ static void draw_plane_marker_image(Scene *scene,
|
|||
GPU_blend(GPU_BLEND_ALPHA);
|
||||
}
|
||||
|
||||
GPUTexture *texture = GPU_texture_create_2d(ibuf->x, ibuf->y, GPU_RGBA8, NULL, NULL);
|
||||
GPUTexture *texture = GPU_texture_create_2d(
|
||||
"plane_marker_image", ibuf->x, ibuf->y, 1, GPU_RGBA8, NULL);
|
||||
GPU_texture_update(texture, GPU_DATA_UNSIGNED_BYTE, display_buffer);
|
||||
GPU_texture_filter_mode(texture, false);
|
||||
|
||||
|
|
|
@ -1639,7 +1639,8 @@ static void sequencer_draw_display_buffer(const bContext *C,
|
|||
GPU_matrix_identity_projection_set();
|
||||
}
|
||||
|
||||
GPUTexture *texture = GPU_texture_create_2d(ibuf->x, ibuf->y, format, NULL, NULL);
|
||||
GPUTexture *texture = GPU_texture_create_2d(
|
||||
"seq_display_buf", ibuf->x, ibuf->y, 1, format, NULL);
|
||||
GPU_texture_update(texture, data, display_buffer);
|
||||
GPU_texture_filter_mode(texture, false);
|
||||
|
||||
|
|
|
@ -183,54 +183,40 @@ typedef enum eGPUDataFormat {
|
|||
|
||||
unsigned int GPU_texture_memory_usage_get(void);
|
||||
|
||||
/* TODO make it static function again. (create function with eGPUDataFormat exposed) */
|
||||
GPUTexture *GPU_texture_create_nD(int w,
|
||||
int h,
|
||||
int d,
|
||||
int n,
|
||||
const void *pixels,
|
||||
eGPUTextureFormat tex_format,
|
||||
eGPUDataFormat gpu_data_format,
|
||||
int samples,
|
||||
const bool can_rescale,
|
||||
char err_out[256]);
|
||||
GPUTexture *GPU_texture_cube_create(int w,
|
||||
int d,
|
||||
const void *pixels,
|
||||
eGPUTextureFormat tex_format,
|
||||
eGPUDataFormat gpu_data_format,
|
||||
char err_out[256]);
|
||||
|
||||
GPUTexture *GPU_texture_create_1d(int w,
|
||||
eGPUTextureFormat tex_format,
|
||||
const float *pixels,
|
||||
char err_out[256]);
|
||||
/**
|
||||
* \note \a data is expected to be float. If the \a format is not compatible with float data or if
|
||||
* the data is not in float format, use GPU_texture_update to upload the data with the right data
|
||||
* format.
|
||||
* \a mips is the number of mip level to allocate. It must be >= 1.
|
||||
*/
|
||||
GPUTexture *GPU_texture_create_1d(
|
||||
const char *name, int w, int mips, eGPUTextureFormat format, const float *data);
|
||||
GPUTexture *GPU_texture_create_1d_array(
|
||||
int w, int h, eGPUTextureFormat tex_format, const float *pixels, char err_out[256]);
|
||||
const char *name, int w, int h, int mips, eGPUTextureFormat format, const float *data);
|
||||
GPUTexture *GPU_texture_create_2d(
|
||||
int w, int h, eGPUTextureFormat tex_format, const float *pixels, char err_out[256]);
|
||||
const char *name, int w, int h, int mips, eGPUTextureFormat format, const float *data);
|
||||
GPUTexture *GPU_texture_create_2d_array(
|
||||
int w, int h, int d, eGPUTextureFormat tex_format, const float *pixels, char err_out[256]);
|
||||
const char *name, int w, int h, int d, int mips, eGPUTextureFormat format, const float *data);
|
||||
GPUTexture *GPU_texture_create_3d(
|
||||
int w, int h, int d, eGPUTextureFormat tex_format, const float *pixels, char err_out[256]);
|
||||
GPUTexture *GPU_texture_create_cube(int w,
|
||||
eGPUTextureFormat tex_format,
|
||||
const float *pixels,
|
||||
char err_out[256]);
|
||||
const char *name, int w, int h, int d, int mips, eGPUTextureFormat format, const float *data);
|
||||
GPUTexture *GPU_texture_create_cube(
|
||||
const char *name, int w, int mips, eGPUTextureFormat format, const float *data);
|
||||
GPUTexture *GPU_texture_create_cube_array(
|
||||
int w, int d, eGPUTextureFormat tex_format, const float *pixels, char err_out[256]);
|
||||
|
||||
GPUTexture *GPU_texture_create_from_vertbuf(struct GPUVertBuf *vert);
|
||||
|
||||
GPUTexture *GPU_texture_create_compressed(
|
||||
int w, int h, int miplen, eGPUTextureFormat format, const void *data);
|
||||
const char *name, int w, int d, int mips, eGPUTextureFormat format, const float *data);
|
||||
|
||||
/* Special textures. */
|
||||
GPUTexture *GPU_texture_create_from_vertbuf(const char *name, struct GPUVertBuf *vert);
|
||||
/**
|
||||
* \a data should hold all the data for all mipmaps.
|
||||
*/
|
||||
GPUTexture *GPU_texture_create_compressed_2d(
|
||||
const char *name, int w, int h, int miplen, eGPUTextureFormat format, const void *data);
|
||||
GPUTexture *GPU_texture_create_error(int dimension, bool array);
|
||||
|
||||
void GPU_texture_add_mipmap(GPUTexture *tex,
|
||||
eGPUDataFormat gpu_data_format,
|
||||
int miplvl,
|
||||
const void *pixels);
|
||||
void GPU_texture_update_mipmap(GPUTexture *tex,
|
||||
int miplvl,
|
||||
eGPUDataFormat gpu_data_format,
|
||||
const void *pixels);
|
||||
|
||||
void GPU_texture_update(GPUTexture *tex, eGPUDataFormat data_format, const void *pixels);
|
||||
void GPU_texture_update_sub(GPUTexture *tex,
|
||||
|
|
|
@ -108,7 +108,7 @@ static void gpu_detect_mip_render_workaround(void)
|
|||
float *source_pix = (float *)MEM_callocN(sizeof(float[4][6]) * cube_size * cube_size, __func__);
|
||||
float clear_color[4] = {1.0f, 0.5f, 0.0f, 0.0f};
|
||||
|
||||
GPUTexture *tex = GPU_texture_create_cube(cube_size, GPU_RGBA16F, source_pix, NULL);
|
||||
GPUTexture *tex = GPU_texture_create_cube(__func__, cube_size, 2, GPU_RGBA16F, source_pix);
|
||||
MEM_freeN(source_pix);
|
||||
|
||||
GPU_texture_bind(tex, 0);
|
||||
|
|
|
@ -577,13 +577,14 @@ GPUOffScreen *GPU_offscreen_create(
|
|||
width = max_ii(1, width);
|
||||
|
||||
ofs->color = GPU_texture_create_2d(
|
||||
width, height, (high_bitdepth) ? GPU_RGBA16F : GPU_RGBA8, NULL, err_out);
|
||||
"ofs_color", width, height, 1, (high_bitdepth) ? GPU_RGBA16F : GPU_RGBA8, NULL);
|
||||
|
||||
if (depth) {
|
||||
ofs->depth = GPU_texture_create_2d(width, height, GPU_DEPTH24_STENCIL8, NULL, err_out);
|
||||
ofs->depth = GPU_texture_create_2d("ofs_depth", width, height, 1, GPU_DEPTH24_STENCIL8, NULL);
|
||||
}
|
||||
|
||||
if ((depth && !ofs->depth) || !ofs->color) {
|
||||
BLI_snprintf(err_out, 256, "GPUTexture: Texture allocation failed.");
|
||||
GPU_offscreen_free(ofs);
|
||||
return NULL;
|
||||
}
|
||||
|
|
|
@ -157,7 +157,7 @@ static void gpu_material_ramp_texture_build(GPUMaterial *mat)
|
|||
GPUColorBandBuilder *builder = mat->coba_builder;
|
||||
|
||||
mat->coba_tex = GPU_texture_create_1d_array(
|
||||
CM_TABLE + 1, builder->current_layer, GPU_RGBA16F, (float *)builder->pixels, NULL);
|
||||
"mat_ramp", CM_TABLE + 1, builder->current_layer, 1, GPU_RGBA16F, (float *)builder->pixels);
|
||||
|
||||
MEM_freeN(builder);
|
||||
mat->coba_builder = NULL;
|
||||
|
@ -546,7 +546,8 @@ struct GPUUniformBuf *GPU_material_sss_profile_get(GPUMaterial *material,
|
|||
GPU_texture_free(material->sss_tex_profile);
|
||||
}
|
||||
|
||||
material->sss_tex_profile = GPU_texture_create_1d(64, GPU_RGBA16F, translucence_profile, NULL);
|
||||
material->sss_tex_profile = GPU_texture_create_1d(
|
||||
"sss_tex_profile", 64, 1, GPU_RGBA16F, translucence_profile);
|
||||
|
||||
MEM_freeN(translucence_profile);
|
||||
|
||||
|
|
|
@ -181,7 +181,7 @@ void Texture::update(eGPUDataFormat format, const void *data)
|
|||
using namespace blender;
|
||||
using namespace blender::gpu;
|
||||
|
||||
/* ------ Memory Management ------- */
|
||||
/* ------ Memory Management ------ */
|
||||
|
||||
uint GPU_texture_memory_usage_get(void)
|
||||
{
|
||||
|
@ -189,31 +189,35 @@ uint GPU_texture_memory_usage_get(void)
|
|||
return 0;
|
||||
}
|
||||
|
||||
/* -------------------------------- */
|
||||
/* ------ Texture Creation ------ */
|
||||
|
||||
GPUTexture *GPU_texture_create_nD(int w,
|
||||
int h,
|
||||
int d,
|
||||
int n,
|
||||
const void *pixels,
|
||||
eGPUTextureFormat tex_format,
|
||||
eGPUDataFormat data_format,
|
||||
int UNUSED(samples),
|
||||
const bool UNUSED(can_rescale),
|
||||
char UNUSED(err_out[256]))
|
||||
static inline GPUTexture *gpu_texture_create(const char *name,
|
||||
const int w,
|
||||
const int h,
|
||||
const int d,
|
||||
const eGPUTextureType type,
|
||||
int UNUSED(mips),
|
||||
eGPUTextureFormat tex_format,
|
||||
const float *fpixels)
|
||||
{
|
||||
Texture *tex = GPUBackend::get()->texture_alloc("nD");
|
||||
Texture *tex = GPUBackend::get()->texture_alloc(name);
|
||||
bool success = false;
|
||||
switch (n) {
|
||||
case 1:
|
||||
switch (type) {
|
||||
case GPU_TEXTURE_1D:
|
||||
case GPU_TEXTURE_1D_ARRAY:
|
||||
success = tex->init_1D(w, h, tex_format);
|
||||
break;
|
||||
case 2:
|
||||
case GPU_TEXTURE_2D:
|
||||
case GPU_TEXTURE_2D_ARRAY:
|
||||
success = tex->init_2D(w, h, d, tex_format);
|
||||
break;
|
||||
case 3:
|
||||
case GPU_TEXTURE_3D:
|
||||
success = tex->init_3D(w, h, d, tex_format);
|
||||
break;
|
||||
case GPU_TEXTURE_CUBE:
|
||||
case GPU_TEXTURE_CUBE_ARRAY:
|
||||
success = tex->init_cubemap(w, d, tex_format);
|
||||
break;
|
||||
default:
|
||||
break;
|
||||
}
|
||||
|
@ -222,37 +226,59 @@ GPUTexture *GPU_texture_create_nD(int w,
|
|||
delete tex;
|
||||
return NULL;
|
||||
}
|
||||
if (pixels) {
|
||||
tex->update(data_format, pixels);
|
||||
if (fpixels) {
|
||||
tex->update(GPU_DATA_FLOAT, fpixels);
|
||||
}
|
||||
return reinterpret_cast<GPUTexture *>(tex);
|
||||
}
|
||||
|
||||
GPUTexture *GPU_texture_cube_create(int w,
|
||||
int d,
|
||||
const void *pixels,
|
||||
eGPUTextureFormat tex_format,
|
||||
eGPUDataFormat data_format,
|
||||
char UNUSED(err_out[256]))
|
||||
GPUTexture *GPU_texture_create_1d(
|
||||
const char *name, int w, int mips, eGPUTextureFormat format, const float *data)
|
||||
{
|
||||
Texture *tex = GPUBackend::get()->texture_alloc("Cube");
|
||||
bool success = tex->init_cubemap(w, d, tex_format);
|
||||
return gpu_texture_create(name, w, 0, 0, GPU_TEXTURE_1D, mips, format, data);
|
||||
}
|
||||
|
||||
if (!success) {
|
||||
delete tex;
|
||||
return NULL;
|
||||
}
|
||||
if (pixels) {
|
||||
tex->update(data_format, pixels);
|
||||
}
|
||||
return reinterpret_cast<GPUTexture *>(tex);
|
||||
GPUTexture *GPU_texture_create_1d_array(
|
||||
const char *name, int w, int h, int mips, eGPUTextureFormat format, const float *data)
|
||||
{
|
||||
return gpu_texture_create(name, w, h, 0, GPU_TEXTURE_1D_ARRAY, mips, format, data);
|
||||
}
|
||||
|
||||
GPUTexture *GPU_texture_create_2d(
|
||||
const char *name, int w, int h, int mips, eGPUTextureFormat format, const float *data)
|
||||
{
|
||||
return gpu_texture_create(name, w, h, 0, GPU_TEXTURE_2D, mips, format, data);
|
||||
}
|
||||
|
||||
GPUTexture *GPU_texture_create_2d_array(
|
||||
const char *name, int w, int h, int d, int mips, eGPUTextureFormat format, const float *data)
|
||||
{
|
||||
return gpu_texture_create(name, w, h, d, GPU_TEXTURE_2D_ARRAY, mips, format, data);
|
||||
}
|
||||
|
||||
GPUTexture *GPU_texture_create_3d(
|
||||
const char *name, int w, int h, int d, int mips, eGPUTextureFormat format, const float *data)
|
||||
{
|
||||
return gpu_texture_create(name, w, h, d, GPU_TEXTURE_3D, mips, format, data);
|
||||
}
|
||||
|
||||
GPUTexture *GPU_texture_create_cube(
|
||||
const char *name, int w, int mips, eGPUTextureFormat format, const float *data)
|
||||
{
|
||||
return gpu_texture_create(name, w, w, 0, GPU_TEXTURE_CUBE, mips, format, data);
|
||||
}
|
||||
|
||||
GPUTexture *GPU_texture_create_cube_array(
|
||||
const char *name, int w, int d, int mips, eGPUTextureFormat format, const float *data)
|
||||
{
|
||||
return gpu_texture_create(name, w, w, d, GPU_TEXTURE_CUBE_ARRAY, mips, format, data);
|
||||
}
|
||||
|
||||
/* DDS texture loading. Return NULL if support is not available. */
|
||||
GPUTexture *GPU_texture_create_compressed(
|
||||
int w, int h, int miplen, eGPUTextureFormat tex_format, const void *data)
|
||||
GPUTexture *GPU_texture_create_compressed_2d(
|
||||
const char *name, int w, int h, int miplen, eGPUTextureFormat tex_format, const void *data)
|
||||
{
|
||||
Texture *tex = GPUBackend::get()->texture_alloc("Cube");
|
||||
Texture *tex = GPUBackend::get()->texture_alloc(name);
|
||||
bool success = tex->init_2D(w, h, 0, tex_format);
|
||||
|
||||
if (!success) {
|
||||
|
@ -274,100 +300,10 @@ GPUTexture *GPU_texture_create_compressed(
|
|||
return reinterpret_cast<GPUTexture *>(tex);
|
||||
}
|
||||
|
||||
/* Create an error texture that will bind an invalid texture (pink) at draw time. */
|
||||
GPUTexture *GPU_texture_create_error(int dimension, bool is_array)
|
||||
{
|
||||
float pixel[4] = {1.0f, 0.0f, 1.0f, 1.0f};
|
||||
int w = 1;
|
||||
int h = (dimension < 2 && !is_array) ? 0 : 1;
|
||||
int d = (dimension < 3 && !is_array) ? 0 : 1;
|
||||
|
||||
fprintf(stderr, "GPUTexture: Blender Texture Not Loaded!");
|
||||
return GPU_texture_create_nD(
|
||||
w, h, d, dimension, pixel, GPU_RGBA8, GPU_DATA_FLOAT, 0, false, NULL);
|
||||
}
|
||||
|
||||
static inline eGPUTextureFormat to_texture_format(const GPUVertFormat *format)
|
||||
{
|
||||
if (format->attr_len > 1 || format->attr_len == 0) {
|
||||
BLI_assert(!"Incorrect vertex format for buffer texture");
|
||||
return GPU_DEPTH_COMPONENT24;
|
||||
}
|
||||
switch (format->attrs[0].comp_len) {
|
||||
case 1:
|
||||
switch (format->attrs[0].comp_type) {
|
||||
case GPU_COMP_I8:
|
||||
return GPU_R8I;
|
||||
case GPU_COMP_U8:
|
||||
return GPU_R8UI;
|
||||
case GPU_COMP_I16:
|
||||
return GPU_R16I;
|
||||
case GPU_COMP_U16:
|
||||
return GPU_R16UI;
|
||||
case GPU_COMP_I32:
|
||||
return GPU_R32I;
|
||||
case GPU_COMP_U32:
|
||||
return GPU_R32UI;
|
||||
case GPU_COMP_F32:
|
||||
return GPU_R32F;
|
||||
default:
|
||||
break;
|
||||
}
|
||||
break;
|
||||
case 2:
|
||||
switch (format->attrs[0].comp_type) {
|
||||
case GPU_COMP_I8:
|
||||
return GPU_RG8I;
|
||||
case GPU_COMP_U8:
|
||||
return GPU_RG8UI;
|
||||
case GPU_COMP_I16:
|
||||
return GPU_RG16I;
|
||||
case GPU_COMP_U16:
|
||||
return GPU_RG16UI;
|
||||
case GPU_COMP_I32:
|
||||
return GPU_RG32I;
|
||||
case GPU_COMP_U32:
|
||||
return GPU_RG32UI;
|
||||
case GPU_COMP_F32:
|
||||
return GPU_RG32F;
|
||||
default:
|
||||
break;
|
||||
}
|
||||
break;
|
||||
case 3:
|
||||
/* Not supported until GL 4.0 */
|
||||
break;
|
||||
case 4:
|
||||
switch (format->attrs[0].comp_type) {
|
||||
case GPU_COMP_I8:
|
||||
return GPU_RGBA8I;
|
||||
case GPU_COMP_U8:
|
||||
return GPU_RGBA8UI;
|
||||
case GPU_COMP_I16:
|
||||
return GPU_RGBA16I;
|
||||
case GPU_COMP_U16:
|
||||
return GPU_RGBA16UI;
|
||||
case GPU_COMP_I32:
|
||||
return GPU_RGBA32I;
|
||||
case GPU_COMP_U32:
|
||||
return GPU_RGBA32UI;
|
||||
case GPU_COMP_F32:
|
||||
return GPU_RGBA32F;
|
||||
default:
|
||||
break;
|
||||
}
|
||||
break;
|
||||
default:
|
||||
break;
|
||||
}
|
||||
BLI_assert(!"Unsupported vertex format for buffer texture");
|
||||
return GPU_DEPTH_COMPONENT24;
|
||||
}
|
||||
|
||||
GPUTexture *GPU_texture_create_from_vertbuf(GPUVertBuf *vert)
|
||||
GPUTexture *GPU_texture_create_from_vertbuf(const char *name, GPUVertBuf *vert)
|
||||
{
|
||||
eGPUTextureFormat tex_format = to_texture_format(&vert->format);
|
||||
Texture *tex = GPUBackend::get()->texture_alloc("Cube");
|
||||
Texture *tex = GPUBackend::get()->texture_alloc(name);
|
||||
|
||||
bool success = tex->init_buffer(vert, tex_format);
|
||||
if (!success) {
|
||||
|
@ -377,56 +313,26 @@ GPUTexture *GPU_texture_create_from_vertbuf(GPUVertBuf *vert)
|
|||
return reinterpret_cast<GPUTexture *>(tex);
|
||||
}
|
||||
|
||||
GPUTexture *GPU_texture_create_1d(int w,
|
||||
eGPUTextureFormat format,
|
||||
const float *pixels,
|
||||
char out[256])
|
||||
/* Create an error texture that will bind an invalid texture (pink) at draw time. */
|
||||
GPUTexture *GPU_texture_create_error(int dimension, bool is_array)
|
||||
{
|
||||
return GPU_texture_create_nD(w, 0, 0, 1, pixels, format, GPU_DATA_FLOAT, 0, false, out);
|
||||
float pixel[4] = {1.0f, 0.0f, 1.0f, 1.0f};
|
||||
int w = 1;
|
||||
int h = (dimension < 2 && !is_array) ? 0 : 1;
|
||||
int d = (dimension < 3 && !is_array) ? 0 : 1;
|
||||
|
||||
eGPUTextureType type = GPU_TEXTURE_3D;
|
||||
type = (dimension == 2) ? (is_array ? GPU_TEXTURE_2D_ARRAY : GPU_TEXTURE_2D) : type;
|
||||
type = (dimension == 1) ? (is_array ? GPU_TEXTURE_1D_ARRAY : GPU_TEXTURE_1D) : type;
|
||||
|
||||
fprintf(stderr, "GPUTexture: Blender Texture Not Loaded!");
|
||||
return gpu_texture_create("invalid_tex", w, h, d, type, 1, GPU_RGBA8, pixel);
|
||||
}
|
||||
|
||||
GPUTexture *GPU_texture_create_1d_array(
|
||||
int w, int h, eGPUTextureFormat format, const float *pixels, char out[256])
|
||||
{
|
||||
return GPU_texture_create_nD(w, h, 0, 1, pixels, format, GPU_DATA_FLOAT, 0, false, out);
|
||||
}
|
||||
|
||||
GPUTexture *GPU_texture_create_2d(
|
||||
int w, int h, eGPUTextureFormat format, const float *pixels, char out[256])
|
||||
{
|
||||
return GPU_texture_create_nD(w, h, 0, 2, pixels, format, GPU_DATA_FLOAT, 0, false, out);
|
||||
}
|
||||
|
||||
GPUTexture *GPU_texture_create_2d_array(
|
||||
int w, int h, int d, eGPUTextureFormat format, const float *pixels, char out[256])
|
||||
{
|
||||
return GPU_texture_create_nD(w, h, d, 2, pixels, format, GPU_DATA_FLOAT, 0, false, out);
|
||||
}
|
||||
|
||||
GPUTexture *GPU_texture_create_3d(
|
||||
int w, int h, int d, eGPUTextureFormat format, const float *pixels, char out[256])
|
||||
{
|
||||
return GPU_texture_create_nD(w, h, d, 3, pixels, format, GPU_DATA_FLOAT, 0, true, out);
|
||||
}
|
||||
|
||||
GPUTexture *GPU_texture_create_cube(int w,
|
||||
eGPUTextureFormat format,
|
||||
const float *fpixels,
|
||||
char out[256])
|
||||
{
|
||||
return GPU_texture_cube_create(w, 0, fpixels, format, GPU_DATA_FLOAT, out);
|
||||
}
|
||||
|
||||
GPUTexture *GPU_texture_create_cube_array(
|
||||
int w, int d, eGPUTextureFormat format, const float *fpixels, char out[256])
|
||||
{
|
||||
return GPU_texture_cube_create(w, d, fpixels, format, GPU_DATA_FLOAT, out);
|
||||
}
|
||||
|
||||
void GPU_texture_add_mipmap(GPUTexture *tex_,
|
||||
eGPUDataFormat gpu_data_format,
|
||||
int miplvl,
|
||||
const void *pixels)
|
||||
void GPU_texture_update_mipmap(GPUTexture *tex_,
|
||||
int miplvl,
|
||||
eGPUDataFormat gpu_data_format,
|
||||
const void *pixels)
|
||||
{
|
||||
Texture *tex = reinterpret_cast<Texture *>(tex_);
|
||||
int extent[3] = {1, 1, 1}, offset[3] = {0, 0, 0};
|
||||
|
@ -468,6 +374,7 @@ void GPU_texture_clear(GPUTexture *tex, eGPUDataFormat data_format, const void *
|
|||
reinterpret_cast<Texture *>(tex)->clear(data_format, data);
|
||||
}
|
||||
|
||||
/* NOTE: Updates only mip 0. */
|
||||
void GPU_texture_update(GPUTexture *tex, eGPUDataFormat data_format, const void *data)
|
||||
{
|
||||
reinterpret_cast<Texture *>(tex)->update(data_format, data);
|
||||
|
@ -517,11 +424,7 @@ void GPU_texture_unbind_all(void)
|
|||
|
||||
void GPU_texture_generate_mipmap(GPUTexture *tex)
|
||||
{
|
||||
// gpu_texture_memory_footprint_remove(tex);
|
||||
|
||||
reinterpret_cast<Texture *>(tex)->generate_mipmap();
|
||||
|
||||
// gpu_texture_memory_footprint_add(tex);
|
||||
}
|
||||
|
||||
/* Copy a texture content to a similar texture. Only Mip 0 is copied. */
|
||||
|
|
|
@ -25,6 +25,8 @@
|
|||
|
||||
#include "BLI_assert.h"
|
||||
|
||||
#include "GPU_vertex_buffer.h"
|
||||
|
||||
#include "gpu_framebuffer_private.hh"
|
||||
|
||||
namespace blender {
|
||||
|
@ -460,5 +462,82 @@ inline eGPUFrameBufferBits to_framebuffer_bits(eGPUTextureFormat tex_format)
|
|||
}
|
||||
}
|
||||
|
||||
static inline eGPUTextureFormat to_texture_format(const GPUVertFormat *format)
|
||||
{
|
||||
if (format->attr_len > 1 || format->attr_len == 0) {
|
||||
BLI_assert(!"Incorrect vertex format for buffer texture");
|
||||
return GPU_DEPTH_COMPONENT24;
|
||||
}
|
||||
switch (format->attrs[0].comp_len) {
|
||||
case 1:
|
||||
switch (format->attrs[0].comp_type) {
|
||||
case GPU_COMP_I8:
|
||||
return GPU_R8I;
|
||||
case GPU_COMP_U8:
|
||||
return GPU_R8UI;
|
||||
case GPU_COMP_I16:
|
||||
return GPU_R16I;
|
||||
case GPU_COMP_U16:
|
||||
return GPU_R16UI;
|
||||
case GPU_COMP_I32:
|
||||
return GPU_R32I;
|
||||
case GPU_COMP_U32:
|
||||
return GPU_R32UI;
|
||||
case GPU_COMP_F32:
|
||||
return GPU_R32F;
|
||||
default:
|
||||
break;
|
||||
}
|
||||
break;
|
||||
case 2:
|
||||
switch (format->attrs[0].comp_type) {
|
||||
case GPU_COMP_I8:
|
||||
return GPU_RG8I;
|
||||
case GPU_COMP_U8:
|
||||
return GPU_RG8UI;
|
||||
case GPU_COMP_I16:
|
||||
return GPU_RG16I;
|
||||
case GPU_COMP_U16:
|
||||
return GPU_RG16UI;
|
||||
case GPU_COMP_I32:
|
||||
return GPU_RG32I;
|
||||
case GPU_COMP_U32:
|
||||
return GPU_RG32UI;
|
||||
case GPU_COMP_F32:
|
||||
return GPU_RG32F;
|
||||
default:
|
||||
break;
|
||||
}
|
||||
break;
|
||||
case 3:
|
||||
/* Not supported until GL 4.0 */
|
||||
break;
|
||||
case 4:
|
||||
switch (format->attrs[0].comp_type) {
|
||||
case GPU_COMP_I8:
|
||||
return GPU_RGBA8I;
|
||||
case GPU_COMP_U8:
|
||||
return GPU_RGBA8UI;
|
||||
case GPU_COMP_I16:
|
||||
return GPU_RGBA16I;
|
||||
case GPU_COMP_U16:
|
||||
return GPU_RGBA16UI;
|
||||
case GPU_COMP_I32:
|
||||
return GPU_RGBA32I;
|
||||
case GPU_COMP_U32:
|
||||
return GPU_RGBA32UI;
|
||||
case GPU_COMP_F32:
|
||||
return GPU_RGBA32F;
|
||||
default:
|
||||
break;
|
||||
}
|
||||
break;
|
||||
default:
|
||||
break;
|
||||
}
|
||||
BLI_assert(!"Unsupported vertex format for buffer texture");
|
||||
return GPU_DEPTH_COMPONENT24;
|
||||
}
|
||||
|
||||
} // namespace gpu
|
||||
} // namespace blender
|
||||
|
|
|
@ -380,7 +380,7 @@ GPUTexture *GPU_viewport_texture_pool_query(
|
|||
}
|
||||
}
|
||||
|
||||
tex = GPU_texture_create_2d(width, height, format, NULL, NULL);
|
||||
tex = GPU_texture_create_2d("temp_from_pool", width, height, 1, format, NULL);
|
||||
/* Doing filtering for depth does not make sense when not doing shadow mapping,
|
||||
* and enabling texture filtering on integer texture make them unreadable. */
|
||||
bool do_filter = !GPU_texture_depth(tex) && !GPU_texture_integer(tex);
|
||||
|
@ -453,16 +453,21 @@ static void gpu_viewport_default_fb_create(GPUViewport *viewport)
|
|||
int *size = viewport->size;
|
||||
bool ok = true;
|
||||
|
||||
dtxl->color = GPU_texture_create_2d(size[0], size[1], GPU_RGBA16F, NULL, NULL);
|
||||
dtxl->color_overlay = GPU_texture_create_2d(size[0], size[1], GPU_SRGB8_A8, NULL, NULL);
|
||||
if (((viewport->flag & GPU_VIEWPORT_STEREO) != 0)) {
|
||||
dtxl->color_stereo = GPU_texture_create_2d(size[0], size[1], GPU_RGBA16F, NULL, NULL);
|
||||
dtxl->color_overlay_stereo = GPU_texture_create_2d(size[0], size[1], GPU_SRGB8_A8, NULL, NULL);
|
||||
dtxl->color = GPU_texture_create_2d("dtxl_color", UNPACK2(size), 1, GPU_RGBA16F, NULL);
|
||||
dtxl->color_overlay = GPU_texture_create_2d(
|
||||
"dtxl_color_overlay", UNPACK2(size), 1, GPU_SRGB8_A8, NULL);
|
||||
|
||||
if (viewport->flag & GPU_VIEWPORT_STEREO) {
|
||||
dtxl->color_stereo = GPU_texture_create_2d(
|
||||
"dtxl_color_stereo", UNPACK2(size), 1, GPU_RGBA16F, NULL);
|
||||
dtxl->color_overlay_stereo = GPU_texture_create_2d(
|
||||
"dtxl_color_overlay_stereo", UNPACK2(size), 1, GPU_SRGB8_A8, NULL);
|
||||
}
|
||||
|
||||
/* Can be shared with GPUOffscreen. */
|
||||
if (dtxl->depth == NULL) {
|
||||
dtxl->depth = GPU_texture_create_2d(size[0], size[1], GPU_DEPTH24_STENCIL8, NULL, NULL);
|
||||
dtxl->depth = GPU_texture_create_2d(
|
||||
"dtxl_depth", UNPACK2(size), 1, GPU_DEPTH24_STENCIL8, NULL);
|
||||
}
|
||||
|
||||
if (!dtxl->depth || !dtxl->color) {
|
||||
|
|
|
@ -736,11 +736,12 @@ const char *IMB_ffmpeg_last_error(void);
|
|||
*
|
||||
* \attention defined in util_gpu.c
|
||||
*/
|
||||
struct GPUTexture *IMB_create_gpu_texture(struct ImBuf *ibuf,
|
||||
struct GPUTexture *IMB_create_gpu_texture(const char *name,
|
||||
struct ImBuf *ibuf,
|
||||
bool use_high_bitdepth,
|
||||
bool use_premult);
|
||||
struct GPUTexture *IMB_touch_gpu_texture(
|
||||
struct ImBuf *ibuf, int w, int h, int layers, bool use_high_bitdepth);
|
||||
const char *name, struct ImBuf *ibuf, int w, int h, int layers, bool use_high_bitdepth);
|
||||
void IMB_update_gpu_texture_sub(struct GPUTexture *tex,
|
||||
struct ImBuf *ibuf,
|
||||
int x,
|
||||
|
|
|
@ -159,7 +159,8 @@ static void *imb_gpu_get_data(const ImBuf *ibuf,
|
|||
|
||||
/* The ibuf is only here to detect the storage type. The produced texture will have undefined
|
||||
* content. It will need to be populated by using IMB_update_gpu_texture_sub(). */
|
||||
GPUTexture *IMB_touch_gpu_texture(ImBuf *ibuf, int w, int h, int layers, bool use_high_bitdepth)
|
||||
GPUTexture *IMB_touch_gpu_texture(
|
||||
const char *name, ImBuf *ibuf, int w, int h, int layers, bool use_high_bitdepth)
|
||||
{
|
||||
eGPUDataFormat data_format;
|
||||
eGPUTextureFormat tex_format;
|
||||
|
@ -167,10 +168,10 @@ GPUTexture *IMB_touch_gpu_texture(ImBuf *ibuf, int w, int h, int layers, bool us
|
|||
|
||||
GPUTexture *tex;
|
||||
if (layers > 0) {
|
||||
tex = GPU_texture_create_2d_array(w, h, layers, tex_format, NULL, NULL);
|
||||
tex = GPU_texture_create_2d_array(name, w, h, layers, 1, tex_format, NULL);
|
||||
}
|
||||
else {
|
||||
tex = GPU_texture_create_2d(w, h, tex_format, NULL, NULL);
|
||||
tex = GPU_texture_create_2d(name, w, h, 9999, tex_format, NULL);
|
||||
}
|
||||
|
||||
GPU_texture_anisotropic_filter(tex, true);
|
||||
|
@ -210,7 +211,10 @@ void IMB_update_gpu_texture_sub(GPUTexture *tex,
|
|||
}
|
||||
}
|
||||
|
||||
GPUTexture *IMB_create_gpu_texture(ImBuf *ibuf, bool use_high_bitdepth, bool use_premult)
|
||||
GPUTexture *IMB_create_gpu_texture(const char *name,
|
||||
ImBuf *ibuf,
|
||||
bool use_high_bitdepth,
|
||||
bool use_premult)
|
||||
{
|
||||
GPUTexture *tex = NULL;
|
||||
const int size[2] = {GPU_texture_size_with_limit(ibuf->x), GPU_texture_size_with_limit(ibuf->y)};
|
||||
|
@ -229,8 +233,12 @@ GPUTexture *IMB_create_gpu_texture(ImBuf *ibuf, bool use_high_bitdepth, bool use
|
|||
fprintf(stderr, "Unable to load non-power-of-two DXT image resolution,");
|
||||
}
|
||||
else {
|
||||
tex = GPU_texture_create_compressed(
|
||||
ibuf->x, ibuf->y, ibuf->dds_data.nummipmaps, compressed_format, ibuf->dds_data.data);
|
||||
tex = GPU_texture_create_compressed_2d(name,
|
||||
ibuf->x,
|
||||
ibuf->y,
|
||||
ibuf->dds_data.nummipmaps,
|
||||
compressed_format,
|
||||
ibuf->dds_data.data);
|
||||
|
||||
if (tex != NULL) {
|
||||
return tex;
|
||||
|
@ -253,7 +261,7 @@ GPUTexture *IMB_create_gpu_texture(ImBuf *ibuf, bool use_high_bitdepth, bool use
|
|||
void *data = imb_gpu_get_data(ibuf, do_rescale, size, compress_as_srgb, use_premult, &freebuf);
|
||||
|
||||
/* Create Texture. */
|
||||
tex = GPU_texture_create_2d(UNPACK2(size), tex_format, NULL, NULL);
|
||||
tex = GPU_texture_create_2d(name, UNPACK2(size), 9999, tex_format, NULL);
|
||||
GPU_texture_update(tex, data_format, data);
|
||||
|
||||
GPU_texture_anisotropic_filter(tex, true);
|
||||
|
|
|
@ -2217,7 +2217,8 @@ static void radial_control_set_tex(RadialControl *rc)
|
|||
rc->use_secondary_tex,
|
||||
!ELEM(rc->subtype, PROP_NONE, PROP_PIXEL, PROP_DISTANCE)))) {
|
||||
|
||||
rc->texture = GPU_texture_create_2d(ibuf->x, ibuf->y, GPU_R8, ibuf->rect_float, NULL);
|
||||
rc->texture = GPU_texture_create_2d(
|
||||
"radial_control", ibuf->x, ibuf->y, 1, GPU_R8, ibuf->rect_float);
|
||||
|
||||
GPU_texture_filter_mode(rc->texture, true);
|
||||
GPU_texture_swizzle_set(rc->texture, "111r");
|
||||
|
|
Loading…
Reference in New Issue