BKE_image_partial_update.hh

Go to the documentation of this file.

/* SPDX-FileCopyrightText: 2021 Blender Authors
 *
 * SPDX-License-Identifier: GPL-2.0-or-later */
 
#pragma once
 
#include "BLI_utildefines.h"
 
#include "BLI_rect.h"
 
#include "BKE_image_wrappers.hh"
 
#include "DNA_image_types.h"
 
extern "C" {
struct PartialUpdateUser;
}
 
namespace blender::bke::image {
 
namespace partial_update {
 
/* --- image_partial_update.cc --- */
enum class ePartialUpdateCollectResult {
  FullUpdateNeeded,
 
  NoChangesDetected,
 
  PartialChangesDetected,
};
 
struct PartialUpdateRegion {
  struct rcti region;
 
  TileNumber tile_number;
};
 
enum class ePartialUpdateIterResult {
  Finished = 0,
 
  ChangeAvailable = 1,
};
 
ePartialUpdateCollectResult BKE_image_partial_update_collect_changes(Image *image,
                                                                     PartialUpdateUser *user);
 
ePartialUpdateIterResult BKE_image_partial_update_get_next_change(PartialUpdateUser *user,
                                                                  PartialUpdateRegion *r_region);
 
class AbstractTileData {
 protected:
  virtual ~AbstractTileData() = default;
 
 public:
  virtual void init_data(TileNumber tile_number) = 0;
  virtual void free_data() = 0;
};
 
class NoTileData : AbstractTileData {
 public:
  NoTileData(Image * /*image*/, ImageUser * /*image_user*/) {}
 
  void init_data(TileNumber /*new_tile_number*/) override {}
 
  void free_data() override {}
};
 
class ImageTileData : AbstractTileData {
 public:
  Image *image;
 
  ImageUser image_user = {0};
 
  ImageTile *tile = nullptr;
 
  ImBuf *tile_buffer = nullptr;
  void *tile_buffer_lock = nullptr;
 
  ImageTileData(Image *image, ImageUser *image_user) : image(image)
  {
    if (image_user != nullptr) {
      this->image_user = *image_user;
    }
    else {
      /* When no image user is given the lastframe of the image should be used. This reflect the
       * same logic when using a stencil image in the clone tool. */
      this->image_user.framenr = image->lastframe;
    }
  }
 
  void init_data(TileNumber new_tile_number) override
  {
    image_user.tile = new_tile_number;
    tile = BKE_image_get_tile(image, new_tile_number);
    tile_buffer = BKE_image_acquire_ibuf(image, &image_user, &tile_buffer_lock);
  }
 
  void free_data() override
  {
    BKE_image_release_ibuf(image, tile_buffer, tile_buffer_lock);
    tile = nullptr;
    tile_buffer = nullptr;
    tile_buffer_lock = nullptr;
  }
};
 
template<typename TileData = NoTileData> struct PartialUpdateChecker {
 
  Image *image;
  ImageUser *image_user;
 
  PartialUpdateUser *user;
 
  struct CollectResult {
    PartialUpdateChecker<TileData> *checker;
 
    TileData tile_data;
    PartialUpdateRegion changed_region;
    ePartialUpdateCollectResult result_code;
 
   private:
    TileNumber last_tile_number = 0;
 
   public:
    CollectResult(PartialUpdateChecker<TileData> *checker, ePartialUpdateCollectResult result_code)
        : checker(checker),
          tile_data(checker->image, checker->image_user),
          result_code(result_code)
    {
    }
 
    const ePartialUpdateCollectResult get_result_code() const
    {
      return result_code;
    }
 
    ePartialUpdateIterResult get_next_change()
    {
      BLI_assert(result_code == ePartialUpdateCollectResult::PartialChangesDetected);
      ePartialUpdateIterResult result = BKE_image_partial_update_get_next_change(checker->user,
                                                                                 &changed_region);
      switch (result) {
        case ePartialUpdateIterResult::Finished:
          tile_data.free_data();
          return result;
 
        case ePartialUpdateIterResult::ChangeAvailable:
          if (last_tile_number == changed_region.tile_number) {
            return result;
          }
          tile_data.free_data();
          tile_data.init_data(changed_region.tile_number);
          last_tile_number = changed_region.tile_number;
          return result;
 
        default:
          BLI_assert_unreachable();
          return result;
      }
    }
  };
 
 public:
  PartialUpdateChecker(Image *image, ImageUser *image_user, PartialUpdateUser *user)
      : image(image), image_user(image_user), user(user)
  {
  }
 
  CollectResult collect_changes()
  {
    ePartialUpdateCollectResult collect_result = BKE_image_partial_update_collect_changes(image,
                                                                                          user);
    return CollectResult(this, collect_result);
  }
};
 
}  // namespace partial_update
}  // namespace blender::bke::image