[Bf-blender-cvs] [b717d0711c2] temp-gpu-image-engine: Use instance data to store data.
Jeroen Bakker
noreply at git.blender.org
Tue Dec 7 13:43:43 CET 2021
Commit: b717d0711c2915a08e435c1b046aee657c233a9a
Author: Jeroen Bakker
Date: Tue Dec 7 13:43:15 2021 +0100
Branches: temp-gpu-image-engine
https://developer.blender.org/rBb717d0711c2915a08e435c1b046aee657c233a9a
Use instance data to store data.
===================================================================
M source/blender/draw/engines/image/image_drawing_mode_screen_space.hh
M source/blender/draw/engines/image/image_engine.cc
M source/blender/draw/engines/image/image_private.hh
===================================================================
diff --git a/source/blender/draw/engines/image/image_drawing_mode_screen_space.hh b/source/blender/draw/engines/image/image_drawing_mode_screen_space.hh
index 3dcf271b07a..e62ccd9cc9c 100644
--- a/source/blender/draw/engines/image/image_drawing_mode_screen_space.hh
+++ b/source/blender/draw/engines/image/image_drawing_mode_screen_space.hh
@@ -117,11 +117,10 @@ class BatchUpdater {
* Texture slots info is stored in IMAGE_PrivateData. The GPUTextures are stored in
* IMAGE_TextureList. This class simplifies accessing texture slots by providing
*/
-struct PrivateDataAccessor {
- IMAGE_PrivateData *pd;
- IMAGE_TextureList *txl;
+struct InstanceDataAccessor {
+ IMAGE_InstanceData *instance_data;
- PrivateDataAccessor(IMAGE_PrivateData *pd, IMAGE_TextureList *txl) : pd(pd), txl(txl)
+ InstanceDataAccessor(IMAGE_InstanceData *instance_data) : instance_data(instance_data)
{
}
@@ -129,7 +128,7 @@ struct PrivateDataAccessor {
void clear_dirty_flag()
{
for (int i = 0; i < SCREEN_SPACE_DRAWING_MODE_TEXTURE_LEN; i++) {
- pd->screen_space.texture_infos[i].dirty = false;
+ instance_data->texture_infos[i].dirty = false;
}
}
@@ -138,13 +137,13 @@ struct PrivateDataAccessor {
{
/* Create a single texture that covers the visible screen space. */
BLI_rctf_init(
- &pd->screen_space.texture_infos[0].clipping_bounds, 0, region->winx, 0, region->winy);
- pd->screen_space.texture_infos[0].visible = true;
+ &instance_data->texture_infos[0].clipping_bounds, 0, region->winx, 0, region->winy);
+ instance_data->texture_infos[0].visible = true;
/* Mark the other textures as invalid. */
for (int i = 1; i < SCREEN_SPACE_DRAWING_MODE_TEXTURE_LEN; i++) {
- BLI_rctf_init_minmax(&pd->screen_space.texture_infos[i].clipping_bounds);
- pd->screen_space.texture_infos[i].visible = false;
+ BLI_rctf_init_minmax(&instance_data->texture_infos[i].clipping_bounds);
+ instance_data->texture_infos[i].visible = false;
}
}
@@ -165,15 +164,15 @@ struct PrivateDataAccessor {
BLI_rctf_init(&new_uv_bounds, uv_min[0], uv_max[0], uv_min[1], uv_max[1]);
if (!BLI_rctf_compare(
- &pd->screen_space.texture_infos[0].uv_bounds, &new_uv_bounds, EPSILON_UV_BOUNDS)) {
- pd->screen_space.texture_infos[0].uv_bounds = new_uv_bounds;
- pd->screen_space.texture_infos[0].dirty = true;
- update_uv_to_texture_matrix(&pd->screen_space.texture_infos[0]);
+ &instance_data->texture_infos[0].uv_bounds, &new_uv_bounds, EPSILON_UV_BOUNDS)) {
+ instance_data->texture_infos[0].uv_bounds = new_uv_bounds;
+ instance_data->texture_infos[0].dirty = true;
+ update_uv_to_texture_matrix(&instance_data->texture_infos[0]);
}
/* Mark the other textures as invalid. */
for (int i = 1; i < SCREEN_SPACE_DRAWING_MODE_TEXTURE_LEN; i++) {
- BLI_rctf_init_minmax(&pd->screen_space.texture_infos[i].clipping_bounds);
+ BLI_rctf_init_minmax(&instance_data->texture_infos[i].clipping_bounds);
}
}
@@ -195,7 +194,7 @@ struct PrivateDataAccessor {
void update_batches()
{
for (int i = 0; i < SCREEN_SPACE_DRAWING_MODE_TEXTURE_LEN; i++) {
- IMAGE_ScreenSpaceTextureInfo &info = pd->screen_space.texture_infos[i];
+ IMAGE_ScreenSpaceTextureInfo &info = instance_data->texture_infos[i];
if (!info.dirty) {
continue;
}
@@ -243,8 +242,7 @@ class ScreenSpaceDrawingMode : public AbstractDrawingMode {
}
void add_shgroups(IMAGE_PassList *psl,
- IMAGE_TextureList *txl,
- IMAGE_PrivateData *pd,
+ const IMAGE_InstanceData *instance_data,
const ShaderParameters &sh_params) const
{
GPUShader *shader = IMAGE_shader_image_get(false);
@@ -255,11 +253,11 @@ class ScreenSpaceDrawingMode : public AbstractDrawingMode {
DRW_shgroup_uniform_vec4_copy(shgrp, "shuffle", sh_params.shuffle);
DRW_shgroup_uniform_int_copy(shgrp, "drawFlags", sh_params.flags);
DRW_shgroup_uniform_bool_copy(shgrp, "imgPremultiplied", sh_params.use_premul_alpha);
- DRW_shgroup_uniform_vec2_copy(shgrp, "maxUv", pd->screen_space.max_uv);
+ DRW_shgroup_uniform_vec2_copy(shgrp, "maxUv", instance_data->max_uv);
float image_mat[4][4];
unit_m4(image_mat);
for (int i = 0; i < SCREEN_SPACE_DRAWING_MODE_TEXTURE_LEN; i++) {
- IMAGE_ScreenSpaceTextureInfo &info = pd->screen_space.texture_infos[i];
+ const IMAGE_ScreenSpaceTextureInfo &info = instance_data->texture_infos[i];
if (!info.visible) {
continue;
}
@@ -270,8 +268,7 @@ class ScreenSpaceDrawingMode : public AbstractDrawingMode {
*/
DRWShadingGroup *shgrp_sub = DRW_shgroup_create_sub(shgrp);
- DRW_shgroup_uniform_texture_ex(
- shgrp_sub, "imageTexture", txl->screen_space.textures[i], GPU_SAMPLER_DEFAULT);
+ DRW_shgroup_uniform_texture_ex(shgrp_sub, "imageTexture", info.texture, GPU_SAMPLER_DEFAULT);
DRW_shgroup_call_obmat(shgrp_sub, info.batch, image_mat);
}
}
@@ -281,55 +278,56 @@ class ScreenSpaceDrawingMode : public AbstractDrawingMode {
*
* When switching to a different image the partial update user should be recreated.
*/
- bool partial_update_is_valid(const IMAGE_PrivateData *pd, const Image *image) const
+ bool partial_update_is_valid(const IMAGE_InstanceData *instance_data, const Image *image) const
{
- if (pd->screen_space.partial_update_image != image) {
+ if (instance_data->partial_update_image != image) {
return false;
}
- return pd->screen_space.partial_update_user != nullptr;
+ return instance_data->partial_update_user != nullptr;
}
- void partial_update_allocate(IMAGE_PrivateData *pd, const Image *image) const
+ void partial_update_allocate(IMAGE_InstanceData *instance_data, const Image *image) const
{
- BLI_assert(pd->screen_space.partial_update_user == nullptr);
- pd->screen_space.partial_update_user = BKE_image_partial_update_create(image);
- pd->screen_space.partial_update_image = image;
+ BLI_assert(instance_data->partial_update_user == nullptr);
+ instance_data->partial_update_user = BKE_image_partial_update_create(image);
+ instance_data->partial_update_image = image;
}
- void partial_update_free(IMAGE_PrivateData *pd) const
+ void partial_update_free(IMAGE_InstanceData *instance_data) const
{
- if (pd->screen_space.partial_update_user != nullptr) {
- BKE_image_partial_update_free(pd->screen_space.partial_update_user);
- pd->screen_space.partial_update_user = nullptr;
+ if (instance_data->partial_update_user != nullptr) {
+ BKE_image_partial_update_free(instance_data->partial_update_user);
+ instance_data->partial_update_user = nullptr;
}
}
- void update_texture_slot_allocation(IMAGE_TextureList *txl, IMAGE_PrivateData *pd) const
+ void update_texture_slot_allocation(IMAGE_InstanceData *instance_data) const
{
for (int i = 0; i < SCREEN_SPACE_DRAWING_MODE_TEXTURE_LEN; i++) {
- const bool is_allocated = txl->screen_space.textures[i] != nullptr;
- const bool is_visible = pd->screen_space.texture_infos[i].visible;
+ IMAGE_ScreenSpaceTextureInfo &info = instance_data->texture_infos[i];
+ const bool is_allocated = info.texture != nullptr;
+ const bool is_visible = info.visible;
const bool should_be_freed = !is_visible && is_allocated;
const bool should_be_created = is_visible && !is_allocated;
if (should_be_freed) {
- GPU_texture_free(txl->screen_space.textures[i]);
- txl->screen_space.textures[i] = nullptr;
+ GPU_texture_free(info.texture);
+ info.texture = nullptr;
}
if (should_be_created) {
DRW_texture_ensure_fullscreen_2d(
- &txl->screen_space.textures[i], GPU_RGBA16F, static_cast<DRWTextureFlag>(0));
+ &info.texture, GPU_RGBA16F, static_cast<DRWTextureFlag>(0));
}
- pd->screen_space.texture_infos[i].dirty |= should_be_created;
+ info.dirty |= should_be_created;
}
}
- void mark_all_texture_slots_dirty(IMAGE_PrivateData *pd) const
+ void mark_all_texture_slots_dirty(IMAGE_InstanceData &instance_data) const
{
for (int i = 0; i < SCREEN_SPACE_DRAWING_MODE_TEXTURE_LEN; i++) {
- pd->screen_space.texture_infos[i].dirty = true;
+ instance_data.texture_infos[i].dirty = true;
}
}
@@ -339,37 +337,35 @@ class ScreenSpaceDrawingMode : public AbstractDrawingMode {
* GPUTextures that are marked dirty are rebuild. GPUTextures that aren't marked dirty are
* updated with changed region of the image.
*/
- void update_textures(IMAGE_TextureList *txl,
- IMAGE_PrivateData *pd,
+ void update_textures(IMAGE_InstanceData &instance_data,
Image *image,
ImageUser *image_user) const
{
PartialUpdateChecker<ImageTileData> checker(
- image, image_user, pd->screen_space.partial_update_user);
+ image, image_user, instance_data.partial_update_user);
PartialUpdateChecker<ImageTileData>::CollectResult changes = checker.collect_changes();
switch (changes.get_result_code()) {
case ePartialUpdateCollectResult::FullUpdateNeeded:
- mark_all_texture_slots_dirty(pd);
+ mark_all_texture_slots_dirty(instance_data);
break;
case ePartialUpdateCollectResult::NoChangesDetected:
break;
case ePartialUpdateCollectResult::PartialChangesDetected:
/* Partial update when wrap repeat is enabled is not supported. */
- if (pd->flags.do_tile_drawing) {
- mark_all_texture_slots_dirty(pd);
+ if (instance_data.flags.do_tile_drawing) {
+ mark_all_texture_slots_dirty(instance_data);
}
else {
- do_partial_update(changes, txl, pd);
+ do_partial_update(changes, instance_data);
}
break;
}
- do_full_update_for_dirty_textures(txl, pd, image_user);
+ do_full_update_for_dirty_textures(instance_data, image_user);
}
void do_partial_update(PartialUpdateChecker<Im
@@ Diff output truncated at 10240 characters. @@
More information about the Bf-blender-cvs
mailing list