82 bool gpu_supported_ =
true;
89 input_data_(input_data),
90 viewer_compute_context_(
bke::
compositor::compute_viewer_compute_context(
100 for (
ImBuf *pass : cached_cpu_passes_) {
107 return input_data_.main;
112 return input_data_.scene;
117 gpu_supported_ = supported;
122 return gpu_supported_ &&
128 return input_data_.needed_side_effects_outputs;
133 return viewer_compute_context_;
138 return input_data_.render_data;
173 input_data_.view_name.c_str());
177 if (
result.is_single_value()) {
179 4 *
size_t(render_result->
rectx) *
size_t(render_result->
recty), __func__);
189 if (
result.sharing_info()) {
191 .data =
static_cast<const float *
>(
result.cpu_data().
data()),
192 .sharing_info =
result.sharing_info(),
193 .colorspace =
nullptr};
197 4 *
size_t(render_result->
rectx) *
size_t(render_result->
recty), __func__);
201 render_result->
rectx * render_result->
recty * 4 *
sizeof(
float));
221 const InputDescriptor input_descriptor = {ResultType::Color,
222 InputRealizationMode::OperationDomain};
223 SimpleOperation *realization_operation = RealizeOnDomainOperation::construct_if_needed(
224 *
this,
result, input_descriptor, compositing_domain);
225 if (!realization_operation) {
231 realize_input.share_data(
result);
232 realization_operation->map_input_to_result(&realize_input);
233 realization_operation->evaluate();
234 Result &realized_result = realization_operation->get_result();
236 realized_result.release();
237 delete realization_operation;
271 input_data_.view_name.c_str());
275 input_data_.view_name.c_str()))
290 if (
int2(image_buffer->
x, image_buffer->
y) != size) {
294 image_buffer->
x = size.x;
295 image_buffer->
y = size.y;
337 .data =
static_cast<const float *
>(viewer_result.
cpu_data().
data()),
339 .colorspace =
nullptr};
345 size.x * size.y * 4 *
sizeof(
float));
403 const InputDescriptor input_descriptor = {ResultType::Color,
404 InputRealizationMode::OperationDomain};
405 SimpleOperation *realization_operation = RealizeOnDomainOperation::construct_if_needed(
406 *
this, viewer_result, input_descriptor, viewer_result.
domain());
408 if (!realization_operation) {
414 realize_input.share_data(viewer_result);
415 realization_operation->map_input_to_result(&realize_input);
416 realization_operation->evaluate();
418 Result &realized_viewer_result = realization_operation->get_result();
420 realized_viewer_result.release();
421 delete realization_operation;
488 const char *pass_name =
StringRef(name) ==
"Image" ?
"Combined" : name;
508 if (!render_result) {
533 render->result_has_gpu_texture_caches =
true;
536 cached_gpu_passes_.append(pass_texture);
544 cached_cpu_passes_.append(render_pass->
ibuf);
548 if (pass.
type() != pass_data.
type()) {
562 const std::string combined_pass_name = std::string(view_layer->
name) +
"." + pass_name;
566 struct StampCallbackData {
567 std::string cryptomatte_layer_name;
572 StampCallbackData callback_data = {cryptomatte_layer_name, &pass.
meta_data};
575 render_result->stamp_data,
576 [](
void *user_data,
const char *key,
char *value,
int ) {
577 StampCallbackData *data = static_cast<StampCallbackData *>(user_data);
579 const std::string manifest_key = bke::cryptomatte::BKE_cryptomatte_meta_data_key(
580 data->cryptomatte_layer_name,
"manifest");
581 if (key == manifest_key) {
582 data->meta_data->cryptomatte.manifest = value;
586 data->cryptomatte_layer_name,
"hash");
588 data->meta_data->cryptomatte.hash = value;
592 data->cryptomatte_layer_name,
"conversion");
593 if (key == conversion_key) {
594 data->meta_data->cryptomatte.conversion = value;
604 return input_data_.view_name;
609 switch (input_data_.scene.r.compositor_precision) {
628 return input_data_.render_context;
633 return this->
get_scene().runtime->compositor.nodes_evaluation_log.get();
645 if (this->
use_gpu() && input_data_.triggered_by_user) {
652 return input_data_.render.display->test_break();
662 input_data_.view_name.c_str());
665 if (!cached_buffer) {
675 input_data_.view_name.c_str()))
685 image_buffer->
x = cached_buffer->
x;
686 image_buffer->
y = cached_buffer->
y;
732 this->
get_scene().runtime->compositor.nodes_evaluation_log =
733 std::make_unique<nodes::eval_log::NodesEvalLog>();
777 bool last_evaluation_used_gpu_ =
false;
787 if (last_evaluation_used_gpu_) {
798 cache_manager_.free();
801 if (last_evaluation_used_gpu_) {
814 Context context(cache_manager_, compute_context_cache, input_data);
816 if (context.use_gpu()) {
826 else if (re_system_gpu_context) {
835 context.set_gpu_supported(
false);
846 if (!context.is_canceled()) {
847 context.cache_manager().reset();
850 last_evaluation_used_gpu_ = context.use_gpu();
851 last_evaluation_precision_ = context.get_precision();
854 if (context.use_gpu()) {
877 Context context(cache_manager_, compute_context_cache, input_data);
880 return context.use_gpu() != last_evaluation_used_gpu_ ||
881 context.get_precision() != last_evaluation_precision_;
#define BLI_SCOPED_DEFER(function_to_defer)
#define RE_PASSNAME_COMBINED
Read Blender memory allocation and freeing.
#define BLI_assert_unreachable()
const void * data() const
Depsgraph * preview_depsgraph
bke::compositor::Cache cache
CompositorRuntime compositor
StaticCacheManager & cache_manager()
Result create_result(ResultType type, ResultPrecision precision)
int get_frame_number() const
bke::ComputeContextCache & compute_context_cache() const
void share_data(const Result &source)
bool is_single_value() const
const ImplicitSharingPtr & sharing_info() const
static ResultType type(gpu::TextureFormat format)
gpu::TextureFormat get_gpu_texture_format() const
void set_precision(ResultPrecision precision)
static ResultPrecision precision(gpu::TextureFormat format)
const T & get_single_value() const
void map_input_to_result(Result *result)
static TexturePool & get()
Compositor(Render &render)
bool needs_to_be_recreated(const CompositorInputData &input_data)
void execute(const CompositorInputData &input_data)
const Scene & get_scene() const override
StringRef get_view_name() const override
compositor::RenderContext * render_context() const override
void write_output(compositor::Result &result)
compositor::Result get_pass(const Scene *scene, int view_layer_id, const char *name) override
compositor::ResultPrecision get_precision() const override
compositor::SideEffectOutputTypes needed_side_effect_output_types() const override
void evaluate_operation_post() const override
const ComputeContext * viewer_compute_context() const override
compositor::ResultType get_pass_data_type(const RenderPass *pass)
Context(compositor::StaticCacheManager &cache_manager, bke::ComputeContextCache &compute_context_cache, const CompositorInputData &input_data)
void write_output_image(const compositor::Result &result)
bool is_canceled() const override
void write_viewer(compositor::Result &viewer_result) override
void write_viewer_image(const compositor::Result &viewer_result)
compositor::Result get_invalid_pass()
compositor::Domain get_compositing_domain() const override
bool use_gpu() const override
const RenderData & get_render_data() const override
void set_gpu_supported(const bool supported)
bool should_cache_viewer_result()
int2 get_render_size() const
nodes::eval_log::NodesEvalLog * nodes_evaluation_log() const override
const Main & get_main() const override
compositor::ResultType get_pass_type(const RenderPass *pass)
TEX_TEMPLATE DataVec texture(T, FltCoord, float=0.0f) RET
StringRef BKE_cryptomatte_extract_layer_name(StringRef render_pass_name)
std::string BKE_cryptomatte_meta_data_key(StringRef layer_name, StringRefNull key_name)
ColorSceneLinear4f< eAlpha::Premultiplied > Color
void DRW_gpu_context_enable()
void * RE_blender_gpu_context_ensure(Render *re)
MINLINE void copy_v2_v2_int(int r[2], const int a[2])
void DRW_render_context_enable(Render *render)
void IMB_free_byte_pixels(ImBuf *ibuf)
void IMB_assign_gpu_texture(ImBuf *ibuf, gpu::Texture *texture)
gpu::TextureFormat GPU_texture_format(const gpu::Texture *texture)
void DRW_render_context_disable(Render *render)
void RE_compositor_free(Render &render)
void * MEM_new_array_uninitialized(size_t len, size_t size, const char *str) ATTR_WARN_UNUSED_RESULT ATTR_ALLOC_SIZE(1
int BKE_scene_multiview_view_id_get(const RenderData *rd, const char *viewname)
RenderLayer * RE_GetRenderLayer(RenderResult *rr, const char *name)
void IMB_rectfill(ImBuf *drect, const float col[4])
void GPU_texture_copy(gpu::Texture *dst, gpu::Texture *src)
void WM_system_gpu_context_release(GHOST_IContext *context)
void IMB_refImBuf(ImBuf *ibuf)
@ COLOR_ROLE_SCENE_LINEAR
void GPU_context_active_set(GPUContext *)
bool DRW_gpu_context_is_enabled()
void BKE_render_resolution(const RenderData *r, const bool use_crop, int *r_width, int *r_height)
ImBuf * IMB_dupImBuf(const ImBuf *ibuf1)
@ SCE_COMPOSITOR_CACHE_FRAMES
void * BLI_findlink(const ListBase *listbase, int number) ATTR_WARN_UNUSED_RESULT ATTR_NONNULL(1)
void DRW_gpu_context_disable()
Render * RE_GetSceneRender(const Scene *scene)
bool BKE_scene_multiview_is_render_view_first(const RenderData *rd, const char *viewname)
ImBuf * BKE_image_acquire_ibuf_gpu(Image *ima, ImageUser *iuser, void **r_lock, bool *r_load_failed=nullptr, bool cached_only=false)
void IMB_freeImBuf(ImBuf *ibuf)
VecBase< int32_t, 2 > int2
@ GPU_TEXTURE_USAGE_GENERAL
RenderResult * RE_AcquireResultWrite(Render *re)
void GPU_memory_barrier(GPUBarrier barrier)
@ SCE_COMPOSITOR_DEVICE_GPU
const char * IMB_colormanagement_role_colorspace_name_get(int role)
BMesh const char void * data
int GPU_texture_width(const gpu::Texture *texture)
void IMB_partial_update_mark_full(ImBuf *ibuf)
@ GPU_BARRIER_TEXTURE_UPDATE
void WM_system_gpu_context_activate(GHOST_IContext *context)
RenderResult * RE_AcquireResultRead(Render *re)
RenderPass * RE_pass_find_by_name(RenderLayer *rl, const char *name, const char *viewname)
void RE_compositor_execute(const render::CompositorInputData input_data)
T * DEG_get_original(T *id)
bool IMB_colormanagement_space_is_data(const ColorSpace *colorspace)
void BKE_stamp_info_callback(void *data, StampData *stamp_data, StampCallback callback, bool noskip)
gpu::Texture * IMB_acquire_gpu_texture(const char *name, ImBuf *ibuf, GPUTextureCreateFlags texture_create_flags, bool try_only=false)
void GPU_texture_clear(gpu::Texture *texture, eGPUDataFormat data_format, const void *data)
int GPU_texture_height(const gpu::Texture *texture)
void GPU_texture_free(gpu::Texture *texture)
const ColorSpace * IMB_colormanagement_space_get_named(const char *name)
void BKE_image_ensure_viewer_views(const RenderData *rd, Image *ima, ImageUser *iuser)
Image * BKE_image_ensure_viewer(Main *bmain, int type, const char *name)
void IMB_free_gpu_textures(ImBuf *ibuf)
RenderView * RE_RenderViewGetByName(RenderResult *rr, const char *viewname)
@ DEG_SCENE_COMP_COMPOSITOR
ImBuf * RE_RenderViewEnsureImBuf(const RenderResult *render_result, RenderView *render_view)
void * GPU_texture_read(gpu::Texture *texture, eGPUDataFormat data_format, int mip_level)
void RE_ReleaseResult(Render *re)
@ SCE_COMPOSITOR_PRECISION_AUTO
@ SCE_COMPOSITOR_PRECISION_FULL
bool IMB_alloc_float_pixels(ImBuf *ibuf, unsigned int channels, bool initialize_pixels=true)
void BLI_thread_unlock(int type)
bool DEG_scene_component_depends_on_time(const Depsgraph &depsgraph, const Scene &scene, const eDepsSceneComponentType component_type)
void IMB_free_float_pixels(ImBuf *ibuf)
GHOST_IContext * RE_system_gpu_context_get(Render *re)
gpu::Texture * GPU_texture_create_2d(const char *name, int width, int height, int mip_len, gpu::TextureFormat format, eGPUTextureUsage usage, const float *data)
void BLI_thread_lock(int type)
void BKE_image_release_ibuf(Image *ima, ImBuf *ibuf, void *lock)
ImplicitSharingPtr sharing_info
const ColorSpace * colorspace
std::atomic< gpu::Texture * > texture
ImBufFloatBuffer float_buffer
ImBufByteBuffer byte_buffer
const float * float_data() const
float * float_data_for_write()
void assign_float_data(float *data)
eCompositorDevice compositor_device
void compositor_execute(render::CompositorInputData input_data) override
render::Compositor * compositor
void compositor_free() override
ListBaseT< ViewLayer > view_layers
bke::SceneRuntime * runtime
void add_frame(int frame_number, int view_identifier, ImBuf *image_buffer)
ImBuf * get_frame(int frame_number, int view_identifier)