21void ScreenSpaceDrawingMode::add_shgroups()
const
25 const ShaderParameters &sh_params = instance_.state.sh_params;
28 pass.shader_set(shader);
29 pass.push_constant(
"far_near_distances", sh_params.far_near);
30 pass.push_constant(
"shuffle", sh_params.shuffle);
31 pass.push_constant(
"draw_flags",
int32_t(sh_params.flags));
32 pass.push_constant(
"is_image_premultiplied", sh_params.use_premul_alpha);
33 pass.bind_texture(
"depth_tx", dtxl->depth);
36 ResourceHandleRange handle = instance_.manager->resource_handle(image_mat);
37 for (
const TextureInfo &info : instance_.state.texture_infos) {
39 sub.push_constant(
"offset", info.offset());
40 sub.bind_texture(
"image_tx", info.texture);
41 sub.draw(info.batch, handle);
45void ScreenSpaceDrawingMode::add_depth_shgroups(
blender::Image *image, ImageUser *image_user)
const
49 pass.shader_set(shader);
52 ResourceHandleRange handle = instance_.manager->resource_handle(image_mat);
54 ImageUser tile_user = {
nullptr};
56 tile_user = *image_user;
59 for (
const TextureInfo &info : instance_.state.texture_infos) {
60 for (ImageTile &image_tile_ptr :
image->tiles) {
61 const ImageTileWrapper image_tile(&image_tile_ptr);
62 const int tile_x = image_tile.get_tile_x_offset();
63 const int tile_y = image_tile.get_tile_y_offset();
64 tile_user.tile = image_tile.get_tile_number();
70 if (tile_buffer !=
nullptr) {
71 instance_.state.float_buffers.mark_used(tile_buffer);
73 float4 min_max_uv(tile_x, tile_y, tile_x + 1, tile_y + 1);
74 sub.push_constant(
"min_max_uv", min_max_uv);
75 sub.draw(info.batch, handle);
82void ScreenSpaceDrawingMode::update_textures(
blender::Image *image, ImageUser *image_user)
const
84 using namespace blender::imbuf::partial_update;
85 State &
state = instance_.state;
87 ImageUser tile_user = {};
89 tile_user = *image_user;
96 bool need_full_update =
false;
97 for (ImageTile &image_tile_ptr :
image->tiles) {
98 const ImageTileWrapper image_tile(&image_tile_ptr);
99 tile_user.
tile = image_tile.get_tile_number();
103 if (tile_buffer ==
nullptr) {
109 switch (changes.
kind) {
110 case Changes::Kind::Full:
111 case Changes::Kind::Resized:
112 need_full_update =
true;
114 case Changes::Kind::Partial:
116 if (
state.flags.do_tile_drawing) {
117 need_full_update =
true;
120 ImBuf *float_buffer =
state.float_buffers.cached_float_buffer(tile_buffer);
122 if (float_buffer != tile_buffer) {
123 do_partial_update_float_buffer(float_buffer, tile_buffer, region);
125 apply_partial_change(float_buffer, image_tile, region);
129 case Changes::Kind::None:
135 state.partial_update.last_changeset_id = new_changeset_id;
137 if (need_full_update) {
138 state.float_buffers.clear();
139 state.mark_all_texture_slots_dirty();
141 do_full_update_for_dirty_textures(image_user);
144void ScreenSpaceDrawingMode::do_partial_update_float_buffer(ImBuf *float_buffer,
146 const rcti ®ion)
const
158 rcti clipped_update_region;
159 const bool has_overlap =
BLI_rcti_isect(&buffer_rect, ®ion, &clipped_update_region);
167void ScreenSpaceDrawingMode::apply_partial_change(ImBuf *src_buffer,
169 const rcti ®ion)
const
173 const float tile_offset_x =
float(image_tile.get_tile_x_offset());
174 const float tile_offset_y =
float(image_tile.get_tile_y_offset());
176 for (
const TextureInfo &info : instance_.state.texture_infos) {
178 if (info.need_full_update) {
181 gpu::Texture *
texture = info.texture;
185 rctf changed_region_in_uv_space;
187 float(region.
xmin) / tile_width + tile_offset_x,
188 float(region.
xmax) / tile_width + tile_offset_x,
189 float(region.
ymin) / tile_height + tile_offset_y,
190 float(region.
ymax) / tile_height + tile_offset_y);
191 rctf changed_overlapping_region_in_uv_space;
192 const bool region_overlap =
BLI_rctf_isect(&info.clipping_uv_bounds,
193 &changed_region_in_uv_space,
194 &changed_overlapping_region_in_uv_space);
195 if (!region_overlap) {
201 rcti gpu_texture_region_to_update;
203 &gpu_texture_region_to_update,
204 floor((changed_overlapping_region_in_uv_space.
xmin - info.clipping_uv_bounds.xmin) *
206 floor((changed_overlapping_region_in_uv_space.
xmax - info.clipping_uv_bounds.xmin) *
208 ceil((changed_overlapping_region_in_uv_space.
ymin - info.clipping_uv_bounds.ymin) *
210 ceil((changed_overlapping_region_in_uv_space.
ymax - info.clipping_uv_bounds.ymin) *
212 gpu_texture_region_to_update.
xmax =
min_ii(gpu_texture_region_to_update.
xmax,
213 info.clipping_bounds.xmax);
214 gpu_texture_region_to_update.
ymax =
min_ii(gpu_texture_region_to_update.
ymax,
215 info.clipping_bounds.ymax);
219 const int texture_region_width =
BLI_rcti_size_x(&gpu_texture_region_to_update);
220 const int texture_region_height =
BLI_rcti_size_y(&gpu_texture_region_to_update);
222 ImBuf extracted_buffer;
228 for (
int y = gpu_texture_region_to_update.
ymin;
y < gpu_texture_region_to_update.
ymax;
y++) {
229 float yf =
y /
float(texture_height);
230 float v = info.clipping_uv_bounds.ymax * yf + info.clipping_uv_bounds.ymin * (1.0 - yf) -
232 for (
int x = gpu_texture_region_to_update.
xmin;
x < gpu_texture_region_to_update.
xmax;
x++) {
233 float xf =
x /
float(texture_width);
234 float u = info.clipping_uv_bounds.xmax * xf + info.clipping_uv_bounds.xmin * (1.0 - xf) -
237 src_buffer, &float_data[offset * 4], u * src_buffer->
x,
v * src_buffer->
y);
246 gpu_texture_region_to_update.
xmin,
247 gpu_texture_region_to_update.
ymin,
256void ScreenSpaceDrawingMode::do_full_update_for_dirty_textures(
const ImageUser *image_user)
const
258 for (TextureInfo &info : instance_.state.texture_infos) {
259 if (!info.need_full_update) {
262 do_full_update_gpu_texture(info, image_user);
266void ScreenSpaceDrawingMode::do_full_update_gpu_texture(
TextureInfo &info,
267 const ImageUser *image_user)
const
269 ImBuf texture_buffer;
273 ImageUser tile_user = {
nullptr};
275 tile_user = *image_user;
281 for (ImageTile &image_tile_ptr :
image->tiles) {
282 const ImageTileWrapper image_tile(&image_tile_ptr);
283 tile_user.
tile = image_tile.get_tile_number();
286 if (tile_buffer !=
nullptr) {
287 do_full_update_texture_slot(info, texture_buffer, *tile_buffer, image_tile);
296void ScreenSpaceDrawingMode::do_full_update_texture_slot(
const TextureInfo &texture_info,
297 ImBuf &texture_buffer,
301 const int texture_width = texture_buffer.
x;
302 const int texture_height = texture_buffer.
y;
303 ImBuf *float_tile_buffer = instance_.state.float_buffers.cached_float_buffer(&tile_buffer);
312 BLI_rctf_init(&texture_area, 0.0, texture_width, 0.0, texture_height);
315 tile_buffer.
x * (texture_info.clipping_uv_bounds.xmin - image_tile.get_tile_x_offset()),
316 tile_buffer.
x * (texture_info.clipping_uv_bounds.xmax - image_tile.get_tile_x_offset()),
317 tile_buffer.
y * (texture_info.clipping_uv_bounds.ymin - image_tile.get_tile_y_offset()),
318 tile_buffer.
y * (texture_info.clipping_uv_bounds.ymax - image_tile.get_tile_y_offset()));
323 const rctf *crop_rect_ptr =
nullptr;
325 if (instance_.state.flags.do_tile_drawing) {
330 crop_rect_ptr = &crop_rect;
366 state.clear_need_full_update_flag();
375 state.update_image_usage(iuser);
379 update_textures(
image, iuser);
382 state.update_batches();
383 if (!
state.flags.do_tile_drawing) {
384 add_depth_shgroups(
image, iuser);
391 float clear_depth = instance_.state.flags.do_tile_drawing ? 0.75 : 1.0f;
393 instance_.state.depth_fb.clear_depth(clear_depth);
394 instance_.manager->submit(instance_.state.depth_ps, instance_.state.view);
398 instance_.manager->submit(instance_.state.image_ps, instance_.state.view);
#define GPU_ATTACHMENT_TEXTURE(_texture)
#define GPU_ATTACHMENT_NONE
void state_set(DRWState state, int clip_plane_count=0)
detail::PassBase< command::DrawCommandBuf > Sub
void update_bounds(const ARegion *region) override
Update the uv and region bounds of all texture_infos of instance_data.
void ensure_gpu_textures_allocation() override
void ensure_texture_infos() override
Ensure enough texture infos are allocated in instance_data.
void draw_viewport() const override
void begin_sync() const override
void image_sync(blender::Image *image, blender::ImageUser *iuser) const override
static ShaderModule & module_get()
#define image(slot, qualifiers, format)
TEX_TEMPLATE DataVec texture(T, FltCoord, float=0.0f) RET
detail::Pass< command::DrawCommandBuf > PassSimple
int tile_height(const AssetShelfSettings &settings)
int tile_width(const AssetShelfSettings &settings)
float4 interpolate_nearest_border_fl(const ImBuf *in, float u, float v)
CartesianBasis invert(const CartesianBasis &basis)
void GPU_framebuffer_bind(gpu::FrameBuffer *fb)
void IMB_float_from_byte_ex(ImBuf *dst, const ImBuf *src, const rcti *region_to_update)
void GPU_texture_update(gpu::Texture *texture, eGPUDataFormat data_format, const void *data)
bool BLI_rcti_isect(const struct rcti *src1, const struct rcti *src2, struct rcti *dest)
void GPU_framebuffer_clear_color(gpu::FrameBuffer *fb, const double4 clear_col)
ATTR_WARN_UNUSED_RESULT const BMVert * v
MatBase< float, 4, 4 > float4x4
bool IMB_initImBuf(ImBuf *ibuf, unsigned int x, unsigned int y, ImBufFlags flags)
VecBase< float, 4 > float4
void GPU_texture_update_sub(gpu::Texture *texture, eGPUDataFormat data_format, const void *pixels, int offset_x, int offset_y, int offset_z, int width, int height, int depth, uint unpack_row_length=0)
void IMB_transform(const ImBuf *src, ImBuf *dst, eIMBTransformMode mode, eIMBInterpolationFilterMode filter, const float3x3 &transform_matrix, const rctf *src_crop)
Transform source image buffer onto destination image buffer using a transform matrix.
BLI_INLINE int BLI_rcti_size_y(const struct rcti *rct)
void IMB_gpu_clamp_half_float(ImBuf *image_buffer)
BLI_INLINE float BLI_rctf_size_y(const struct rctf *rct)
int GPU_texture_width(const gpu::Texture *texture)
void BLI_rctf_transform_calc_m3_pivot_min(const rctf *dst, const rctf *src, float matrix[3][3])
@ DRW_STATE_BLEND_ALPHA_PREMUL
@ DRW_STATE_DEPTH_LESS_EQUAL
const DRWContext * DRW_context_get()
MatBase< float, 3, 3 > float3x3
BLI_INLINE int BLI_rcti_size_x(const struct rcti *rct)
int64_t BKE_image_partial_update_flush(Image *ima, const ImageUser *iuser)
void BLI_rcti_init(struct rcti *rect, int xmin, int xmax, int ymin, int ymax)
ImBuf * BKE_image_acquire_ibuf(Image *ima, ImageUser *iuser, void **r_lock)
BLI_INLINE float BLI_rctf_size_x(const struct rctf *rct)
int GPU_texture_height(const gpu::Texture *texture)
bool BLI_rctf_isect(const struct rctf *src1, const struct rctf *src2, struct rctf *dest)
void IMB_free_all_data(ImBuf *ibuf)
imbuf::partial_update::Changes IMB_partial_update_collect(ImBuf *ibuf, imbuf::ChangesetID last_changeset_id)
MINLINE int min_ii(int a, int b)
VecBase< double, 4 > double4
eIMBTransformMode
Transform modes to use for IMB_transform function.
@ IMB_TRANSFORM_MODE_WRAP_REPEAT
Wrap repeat the source buffer. Only supported in with nearest filtering.
@ IMB_TRANSFORM_MODE_CROP_SRC
Crop the source buffer.
void BLI_rctf_init(struct rctf *rect, float xmin, float xmax, float ymin, float ymax)
void BKE_image_release_ibuf(Image *ima, ImBuf *ibuf, void *lock)
KERNEL_FEATURE_LIGHT_PASSES KERNEL_FEATURE_PATH_GUIDING float
DefaultTextureList * viewport_texture_list_get() const
const uint8_t * byte_data() const
const float * float_data() const
float * float_data_for_write()
static MatBase identity()
Vector< rcti > modified_regions() const