Blender V5.3
compute_preview.cc
Go to the documentation of this file.
1/* SPDX-FileCopyrightText: 2024 Blender Authors
2 *
3 * SPDX-License-Identifier: GPL-2.0-or-later */
4
5#include "BLI_index_range.hh"
6#include "BLI_math_color_c.hh"
8#include "BLI_task.hh"
9
10#include "DNA_node_types.h"
11
13#include "IMB_imbuf.hh"
14
16
17#include "GPU_shader.hh"
18#include "GPU_state.hh"
19#include "GPU_texture.hh"
20
21#include "BKE_node.hh"
22
23#include "COM_context.hh"
24#include "COM_result.hh"
25#include "COM_utilities.hh"
26
28
29namespace blender::compositor {
30
31static void compute_preview_cpu(Context &context, const Result &input, ImBuf *output)
32{
33 const int2 input_size = input.domain().data_size;
34 const int2 preview_size = int2(output->x, output->y);
35
36 Result input_as_color = context.create_result(ResultType::Color);
37 if (input.type() == ResultType::Color) {
38 input_as_color.share_data(input);
39 }
40 else {
41 input_as_color.allocate_texture(input.domain());
43 conversions.convert_to_initialized_n(input.cpu_data(), input_as_color.cpu_data_for_write());
44 }
45
47 &context.get_scene().view_settings, &context.get_scene().display_settings);
48
49 uchar *data_dst = output->byte_data_for_write();
50 threading::parallel_for(IndexRange(preview_size.y), 1, [&](const IndexRange sub_y_range) {
51 for (const int64_t y : sub_y_range) {
52 for (const int64_t x : IndexRange(preview_size.x)) {
53 const int2 coordinates = int2((float2(x, y) / float2(preview_size)) * float2(input_size));
54
55 Color color = input_as_color.load_pixel<Color>(coordinates);
56 color_processor.apply_v4(color);
57
58 const int64_t index = (y * preview_size.x + x) * 4;
59 rgba_float_to_uchar(data_dst + index, color);
60 }
61 }
62 });
63
64 input_as_color.release();
65}
66
67static void compute_preview_gpu(Context &context, const Result &input_result, ImBuf *output)
68{
69 const int2 preview_size = int2(output->x, output->y);
70
71 gpu::Shader *shader = context.get_shader("compositor_compute_preview");
73
74 if (input_result.type() == ResultType::Float) {
75 GPU_texture_swizzle_set(input_result, "rrr1");
76 }
77
78 input_result.bind_as_texture(shader, "input_tx");
79
80 Result preview_result = context.create_result(ResultType::Color);
81 preview_result.allocate_texture(Domain(preview_size));
82 preview_result.bind_as_image(shader, "preview_img");
83
85
86 input_result.unbind_as_texture();
87 preview_result.unbind_as_image();
89
90 /* Restore original swizzle mask set above. */
91 if (input_result.type() == ResultType::Float) {
92 GPU_texture_swizzle_set(input_result, "rgba");
93 }
94
96 float *preview_pixels = static_cast<float *>(
97 GPU_texture_read(preview_result, GPU_DATA_FLOAT, 0));
98 preview_result.release();
99
101 &context.get_scene().view_settings, &context.get_scene().display_settings);
102
103 uchar *data_dst = output->byte_data_for_write();
104 threading::parallel_for(IndexRange(preview_size.y), 1, [&](const IndexRange sub_y_range) {
105 for (const int64_t y : sub_y_range) {
106 for (const int64_t x : IndexRange(preview_size.x)) {
107 const int64_t index = (y * preview_size.x + x) * 4;
108 color_processor.apply_v4(preview_pixels + index);
109 rgba_float_to_uchar(data_dst + index, preview_pixels + index);
110 }
111 }
112 });
113
114 MEM_delete(preview_pixels);
115}
116
117/* Given the size of a result, compute a lower resolution size for a preview. The greater dimension
118 * will be assigned an arbitrarily chosen size of 128, while the other dimension will get the size
119 * that maintains the same aspect ratio. */
121{
122 const int greater_dimension_size = 128;
123 if (size.x > size.y) {
124 return int2(greater_dimension_size, int(greater_dimension_size * (float(size.y) / size.x)));
125 }
126 return int2(int(greater_dimension_size * (float(size.x) / size.y)), greater_dimension_size);
127}
128
129ImBuf *compute_preview(Context &context, const Result &input)
130{
131 const int2 preview_size = compute_preview_size(input.domain().data_size);
132 ImBuf *image_buffer = IMB_allocImBuf(UNPACK2(preview_size), ImBufFlags::ByteData);
133 if (context.use_gpu()) {
134 compute_preview_gpu(context, input, image_buffer);
135 }
136 else {
137 compute_preview_cpu(context, input, image_buffer);
138 }
139
140 return image_buffer;
141}
142
143} // namespace blender::compositor
#define UNPACK2(a)
#define output
static ColormanageProcessor display_processor_new(const ColorManagedViewSettings *view_settings, const ColorManagedDisplaySettings *display_settings, ColorManagedDisplaySpace display_space=DISPLAY_SPACE_DRAW, bool inverse=false, const char *from_colorspace=nullptr)
constexpr IndexRange()=default
void convert_to_initialized_n(GSpan from_span, GMutableSpan to_span) const
void share_data(const Result &source)
Definition result.cc:996
void allocate_texture(const Domain domain, const bool from_pool=true, const std::optional< ResultStorageType > storage_type=std::nullopt)
Definition result.cc:554
void unbind_as_texture() const
Definition result.cc:964
GMutableSpan cpu_data_for_write()
static ResultType type(gpu::TextureFormat format)
Definition result.cc:337
void bind_as_texture(gpu::Shader *shader, const char *texture_name) const
Definition result.cc:854
void unbind_as_image() const
Definition result.cc:990
void bind_as_image(gpu::Shader *shader, const char *image_name, bool read=false) const
Definition result.cc:951
const DataTypeConversions & get_implicit_type_conversions()
void compute_dispatch_threads_at_least(gpu::Shader *shader, int2 threads_range, int2 local_size=int2(16))
Definition utilities.cc:235
static void compute_preview_gpu(Context &context, const Result &input_result, ImBuf *output)
ImBuf * compute_preview(Context &context, const Result &input)
static void compute_preview_cpu(Context &context, const Result &input, ImBuf *output)
static int2 compute_preview_size(int2 size)
void parallel_for(const IndexRange range, const int64_t grain_size, const Function &function, const TaskSizeHints &size_hints=detail::TaskSizeHints_Static(1))
Definition BLI_task.hh:69
unsigned char uchar
Definition BKE_text.h:58
void GPU_memory_barrier(GPUBarrier barrier)
Definition gpu_state.cc:305
void GPU_shader_unbind()
void GPU_texture_swizzle_set(gpu::Texture *texture, const char swizzle[4])
void GPU_shader_bind(gpu::Shader *shader, const gpu::shader::SpecializationConstants *constants_state=nullptr)
@ GPU_BARRIER_TEXTURE_FETCH
Definition GPU_state.hh:40
ImBuf * IMB_allocImBuf(unsigned int x, unsigned int y, ImBufFlags flags)
void * GPU_texture_read(gpu::Texture *texture, eGPUDataFormat data_format, int mip_level)