Cleanup: Split image engine into ImageEngine, SpaceAccessor and DrawingMode.
Image engine is used to draw an image into a space. The current structure wasn't clear and couldn't be easilly extended. This refactor spliced the image draw engine into 3 main components. - Space accessors: contains an interface to communicate with space data (Image editor, UV Editor, Node Editor) in a common way. This reduced the branching in the code base. - DrawingMode: contains an interface to the used tactic to draw an image inside the space framebuffer. Currently only one mode is implemented; in the future there could be a separate drawing mode for huge images. - ImageEngine: the core that connects the draw manager with the space data and drawing mode.
This commit is contained in:
parent
d7f4fdf845
commit
32c90d2d7c
|
@ -0,0 +1,154 @@
|
|||
/*
|
||||
* This program is free software; you can redistribute it and/or
|
||||
* modify it under the terms of the GNU General Public License
|
||||
* as published by the Free Software Foundation; either version 2
|
||||
* of the License, or (at your option) any later version.
|
||||
*
|
||||
* This program is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
* GNU General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License
|
||||
* along with this program; if not, write to the Free Software Foundation,
|
||||
* Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
|
||||
*
|
||||
* Copyright 2021, Blender Foundation.
|
||||
*/
|
||||
|
||||
/** \file
|
||||
* \ingroup draw_engine
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
|
||||
#include "image_private.hh"
|
||||
|
||||
namespace blender::draw::image_engine {
|
||||
|
||||
class DefaultDrawingMode : public AbstractDrawingMode {
|
||||
private:
|
||||
DRWPass *create_image_pass() const
|
||||
{
|
||||
/* Write depth is needed for background overlay rendering. Near depth is used for
|
||||
* transparency checker and Far depth is used for indicating the image size. */
|
||||
DRWState state = static_cast<DRWState>(DRW_STATE_WRITE_COLOR | DRW_STATE_WRITE_DEPTH |
|
||||
DRW_STATE_DEPTH_ALWAYS | DRW_STATE_BLEND_ALPHA_PREMUL);
|
||||
return DRW_pass_create("Image", state);
|
||||
}
|
||||
|
||||
void add_to_shgroup(AbstractSpaceAccessor *space,
|
||||
DRWShadingGroup *grp,
|
||||
const Image *image,
|
||||
const ImBuf *image_buffer) const
|
||||
{
|
||||
float image_mat[4][4];
|
||||
|
||||
const DRWContextState *draw_ctx = DRW_context_state_get();
|
||||
const ARegion *region = draw_ctx->region;
|
||||
space->get_image_mat(image_buffer, region, image_mat);
|
||||
|
||||
GPUBatch *geom = DRW_cache_quad_get();
|
||||
|
||||
const bool is_tiled_texture = image && image->source == IMA_SRC_TILED;
|
||||
if (is_tiled_texture) {
|
||||
const float translate_x = image_mat[3][0];
|
||||
const float translate_y = image_mat[3][1];
|
||||
LISTBASE_FOREACH (ImageTile *, tile, &image->tiles) {
|
||||
const int tile_x = ((tile->tile_number - 1001) % 10);
|
||||
const int tile_y = ((tile->tile_number - 1001) / 10);
|
||||
image_mat[3][0] = (float)tile_x + translate_x;
|
||||
image_mat[3][1] = (float)tile_y + translate_y;
|
||||
DRW_shgroup_call_obmat(grp, geom, image_mat);
|
||||
}
|
||||
}
|
||||
else {
|
||||
DRW_shgroup_call_obmat(grp, geom, image_mat);
|
||||
}
|
||||
}
|
||||
|
||||
public:
|
||||
void cache_init(IMAGE_Data *vedata) const override
|
||||
{
|
||||
IMAGE_PassList *psl = vedata->psl;
|
||||
|
||||
psl->image_pass = create_image_pass();
|
||||
}
|
||||
|
||||
void cache_image(AbstractSpaceAccessor *space,
|
||||
IMAGE_Data *vedata,
|
||||
Image *image,
|
||||
ImageUser *iuser,
|
||||
ImBuf *image_buffer) const override
|
||||
{
|
||||
IMAGE_PassList *psl = vedata->psl;
|
||||
IMAGE_StorageList *stl = vedata->stl;
|
||||
IMAGE_PrivateData *pd = stl->pd;
|
||||
|
||||
GPUTexture *tex_tile_data = nullptr;
|
||||
space->get_gpu_textures(
|
||||
image, iuser, image_buffer, &pd->texture, &pd->owns_texture, &tex_tile_data);
|
||||
if (pd->texture == nullptr) {
|
||||
return;
|
||||
}
|
||||
const bool is_tiled_texture = tex_tile_data != nullptr;
|
||||
|
||||
ShaderParameters sh_params;
|
||||
sh_params.use_premul_alpha = BKE_image_has_gpu_texture_premultiplied_alpha(image,
|
||||
image_buffer);
|
||||
const DRWContextState *draw_ctx = DRW_context_state_get();
|
||||
const Scene *scene = draw_ctx->scene;
|
||||
if (scene->camera && scene->camera->type == OB_CAMERA) {
|
||||
Camera *camera = static_cast<Camera *>(scene->camera->data);
|
||||
copy_v2_fl2(sh_params.far_near, camera->clip_end, camera->clip_start);
|
||||
}
|
||||
space->get_shader_parameters(sh_params, image_buffer, is_tiled_texture);
|
||||
|
||||
GPUShader *shader = IMAGE_shader_image_get(is_tiled_texture);
|
||||
DRWShadingGroup *shgrp = DRW_shgroup_create(shader, psl->image_pass);
|
||||
if (is_tiled_texture) {
|
||||
DRW_shgroup_uniform_texture_ex(shgrp, "imageTileArray", pd->texture, GPU_SAMPLER_DEFAULT);
|
||||
DRW_shgroup_uniform_texture(shgrp, "imageTileData", tex_tile_data);
|
||||
}
|
||||
else {
|
||||
DRW_shgroup_uniform_texture_ex(shgrp, "imageTexture", pd->texture, GPU_SAMPLER_DEFAULT);
|
||||
}
|
||||
DRW_shgroup_uniform_vec2_copy(shgrp, "farNearDistances", sh_params.far_near);
|
||||
DRW_shgroup_uniform_vec4_copy(shgrp, "color", ShaderParameters::color);
|
||||
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);
|
||||
|
||||
add_to_shgroup(space, shgrp, image, image_buffer);
|
||||
}
|
||||
|
||||
void draw_finish(IMAGE_Data *vedata) const override
|
||||
{
|
||||
IMAGE_StorageList *stl = vedata->stl;
|
||||
IMAGE_PrivateData *pd = stl->pd;
|
||||
|
||||
if (pd->texture && pd->owns_texture) {
|
||||
GPU_texture_free(pd->texture);
|
||||
pd->owns_texture = false;
|
||||
}
|
||||
pd->texture = nullptr;
|
||||
}
|
||||
|
||||
void draw_scene(IMAGE_Data *vedata) const override
|
||||
{
|
||||
IMAGE_PassList *psl = vedata->psl;
|
||||
IMAGE_PrivateData *pd = vedata->stl->pd;
|
||||
|
||||
DefaultFramebufferList *dfbl = DRW_viewport_framebuffer_list_get();
|
||||
GPU_framebuffer_bind(dfbl->default_fb);
|
||||
static float clear_col[4] = {0.0f, 0.0f, 0.0f, 0.0f};
|
||||
GPU_framebuffer_clear_color_depth(dfbl->default_fb, clear_col, 1.0);
|
||||
|
||||
DRW_view_set_active(pd->view);
|
||||
DRW_draw_pass(psl->image_pass);
|
||||
DRW_view_set_active(nullptr);
|
||||
}
|
||||
};
|
||||
|
||||
} // namespace blender::draw::image_engine
|
||||
|
|
@ -17,13 +17,16 @@
|
|||
*/
|
||||
|
||||
/** \file
|
||||
* \ingroup draw_editors
|
||||
* \ingroup draw_engine
|
||||
*
|
||||
* Draw engine to draw the Image/UV editor
|
||||
*/
|
||||
|
||||
#include "DRW_render.h"
|
||||
|
||||
#include <memory>
|
||||
#include <optional>
|
||||
|
||||
#include "BKE_image.h"
|
||||
#include "BKE_main.h"
|
||||
#include "BKE_object.h"
|
||||
|
@ -38,291 +41,89 @@
|
|||
|
||||
#include "GPU_batch.h"
|
||||
|
||||
#include "image_drawing_mode.hh"
|
||||
#include "image_engine.h"
|
||||
#include "image_private.hh"
|
||||
#include "image_space_image.hh"
|
||||
#include "image_space_node.hh"
|
||||
|
||||
namespace blender::draw::image_engine {
|
||||
|
||||
#define IMAGE_DRAW_FLAG_SHOW_ALPHA (1 << 0)
|
||||
#define IMAGE_DRAW_FLAG_APPLY_ALPHA (1 << 1)
|
||||
#define IMAGE_DRAW_FLAG_SHUFFLING (1 << 2)
|
||||
#define IMAGE_DRAW_FLAG_DEPTH (1 << 3)
|
||||
#define IMAGE_DRAW_FLAG_DO_REPEAT (1 << 4)
|
||||
#define IMAGE_DRAW_FLAG_USE_WORLD_POS (1 << 5)
|
||||
|
||||
static void image_cache_image_add(DRWShadingGroup *grp, Image *image, ImBuf *ibuf)
|
||||
static std::unique_ptr<AbstractSpaceAccessor> space_accessor_from_context(
|
||||
const DRWContextState *draw_ctx)
|
||||
{
|
||||
const DRWContextState *draw_ctx = DRW_context_state_get();
|
||||
const ARegion *region = draw_ctx->region;
|
||||
const char space_type = draw_ctx->space_data->spacetype;
|
||||
|
||||
float zoom_x = 1.0f;
|
||||
float zoom_y = 1.0f;
|
||||
float translate_x = 0.0f;
|
||||
float translate_y = 0.0f;
|
||||
|
||||
/* User can freely move the backdrop in the space of the node editor */
|
||||
if (space_type == SPACE_NODE) {
|
||||
SpaceNode *snode = (SpaceNode *)draw_ctx->space_data;
|
||||
const float ibuf_width = ibuf->x;
|
||||
const float ibuf_height = ibuf->y;
|
||||
const float x = (region->winx - snode->zoom * ibuf_width) / 2 + snode->xof;
|
||||
const float y = (region->winy - snode->zoom * ibuf_height) / 2 + snode->yof;
|
||||
|
||||
zoom_x = ibuf_width * snode->zoom;
|
||||
zoom_y = ibuf_height * snode->zoom;
|
||||
translate_x = x;
|
||||
translate_y = y;
|
||||
}
|
||||
|
||||
const bool is_tiled_texture = image && image->source == IMA_SRC_TILED;
|
||||
float obmat[4][4];
|
||||
unit_m4(obmat);
|
||||
|
||||
GPUBatch *geom = DRW_cache_quad_get();
|
||||
|
||||
obmat[0][0] = zoom_x;
|
||||
obmat[1][1] = zoom_y;
|
||||
obmat[3][1] = translate_y;
|
||||
obmat[3][0] = translate_x;
|
||||
|
||||
if (is_tiled_texture) {
|
||||
LISTBASE_FOREACH (ImageTile *, tile, &image->tiles) {
|
||||
const int tile_x = ((tile->tile_number - 1001) % 10);
|
||||
const int tile_y = ((tile->tile_number - 1001) / 10);
|
||||
obmat[3][1] = (float)tile_y + translate_y;
|
||||
obmat[3][0] = (float)tile_x + translate_x;
|
||||
DRW_shgroup_call_obmat(grp, geom, obmat);
|
||||
}
|
||||
}
|
||||
else {
|
||||
DRW_shgroup_call_obmat(grp, geom, obmat);
|
||||
}
|
||||
}
|
||||
|
||||
static void space_image_gpu_texture_get(Image *image,
|
||||
ImageUser *iuser,
|
||||
ImBuf *ibuf,
|
||||
GPUTexture **r_gpu_texture,
|
||||
bool *r_owns_texture,
|
||||
GPUTexture **r_tex_tile_data)
|
||||
{
|
||||
const DRWContextState *draw_ctx = DRW_context_state_get();
|
||||
SpaceImage *sima = (SpaceImage *)draw_ctx->space_data;
|
||||
if (image->rr != nullptr) {
|
||||
/* Update multi-index and pass for the current eye. */
|
||||
BKE_image_multilayer_index(image->rr, &sima->iuser);
|
||||
}
|
||||
else {
|
||||
BKE_image_multiview_index(image, &sima->iuser);
|
||||
}
|
||||
|
||||
if (ibuf == nullptr) {
|
||||
return;
|
||||
}
|
||||
|
||||
if (ibuf->rect == nullptr && ibuf->rect_float == nullptr) {
|
||||
/* This code-path is only supposed to happen when drawing a lazily-allocatable render result.
|
||||
* In all the other cases the `ED_space_image_acquire_buffer()` is expected to return nullptr
|
||||
* as an image buffer when it has no pixels. */
|
||||
|
||||
BLI_assert(image->type == IMA_TYPE_R_RESULT);
|
||||
|
||||
float zero[4] = {0, 0, 0, 0};
|
||||
*r_gpu_texture = GPU_texture_create_2d(__func__, 1, 1, 0, GPU_RGBA16F, zero);
|
||||
*r_owns_texture = true;
|
||||
return;
|
||||
}
|
||||
|
||||
const int sima_flag = sima->flag & ED_space_image_get_display_channel_mask(ibuf);
|
||||
if (sima_flag & SI_SHOW_ZBUF && (ibuf->zbuf || ibuf->zbuf_float || (ibuf->channels == 1))) {
|
||||
if (ibuf->zbuf) {
|
||||
BLI_assert_msg(0, "Integer based depth buffers not supported");
|
||||
}
|
||||
else if (ibuf->zbuf_float) {
|
||||
*r_gpu_texture = GPU_texture_create_2d(
|
||||
__func__, ibuf->x, ibuf->y, 0, GPU_R16F, ibuf->zbuf_float);
|
||||
*r_owns_texture = true;
|
||||
}
|
||||
else if (ibuf->rect_float && ibuf->channels == 1) {
|
||||
*r_gpu_texture = GPU_texture_create_2d(
|
||||
__func__, ibuf->x, ibuf->y, 0, GPU_R16F, ibuf->rect_float);
|
||||
*r_owns_texture = true;
|
||||
}
|
||||
}
|
||||
else if (image->source == IMA_SRC_TILED) {
|
||||
*r_gpu_texture = BKE_image_get_gpu_tiles(image, iuser, ibuf);
|
||||
*r_tex_tile_data = BKE_image_get_gpu_tilemap(image, iuser, nullptr);
|
||||
*r_owns_texture = false;
|
||||
}
|
||||
else {
|
||||
*r_gpu_texture = BKE_image_get_gpu_texture(image, iuser, ibuf);
|
||||
*r_owns_texture = false;
|
||||
}
|
||||
}
|
||||
|
||||
static void space_node_gpu_texture_get(Image *image,
|
||||
ImageUser *iuser,
|
||||
ImBuf *ibuf,
|
||||
GPUTexture **r_gpu_texture,
|
||||
bool *r_owns_texture,
|
||||
GPUTexture **r_tex_tile_data)
|
||||
{
|
||||
*r_gpu_texture = BKE_image_get_gpu_texture(image, iuser, ibuf);
|
||||
*r_owns_texture = false;
|
||||
*r_tex_tile_data = nullptr;
|
||||
}
|
||||
|
||||
static void image_gpu_texture_get(Image *image,
|
||||
ImageUser *iuser,
|
||||
ImBuf *ibuf,
|
||||
GPUTexture **r_gpu_texture,
|
||||
bool *r_owns_texture,
|
||||
GPUTexture **r_tex_tile_data)
|
||||
{
|
||||
if (!image) {
|
||||
return;
|
||||
}
|
||||
|
||||
const DRWContextState *draw_ctx = DRW_context_state_get();
|
||||
const char space_type = draw_ctx->space_data->spacetype;
|
||||
|
||||
if (space_type == SPACE_IMAGE) {
|
||||
space_image_gpu_texture_get(
|
||||
image, iuser, ibuf, r_gpu_texture, r_owns_texture, r_tex_tile_data);
|
||||
return std::make_unique<SpaceImageAccessor>((SpaceImage *)draw_ctx->space_data);
|
||||
}
|
||||
else if (space_type == SPACE_NODE) {
|
||||
space_node_gpu_texture_get(image, iuser, ibuf, r_gpu_texture, r_owns_texture, r_tex_tile_data);
|
||||
if (space_type == SPACE_NODE) {
|
||||
return std::make_unique<SpaceNodeAccessor>((SpaceNode *)draw_ctx->space_data);
|
||||
}
|
||||
BLI_assert_unreachable();
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
static void image_cache_image(IMAGE_Data *vedata, Image *image, ImageUser *iuser, ImBuf *ibuf)
|
||||
{
|
||||
IMAGE_PassList *psl = vedata->psl;
|
||||
IMAGE_StorageList *stl = vedata->stl;
|
||||
IMAGE_PrivateData *pd = stl->pd;
|
||||
class ImageEngine {
|
||||
private:
|
||||
const DRWContextState *draw_ctx;
|
||||
IMAGE_Data *vedata;
|
||||
std::unique_ptr<AbstractSpaceAccessor> space;
|
||||
DefaultDrawingMode drawing_mode;
|
||||
|
||||
const DRWContextState *draw_ctx = DRW_context_state_get();
|
||||
const char space_type = draw_ctx->space_data->spacetype;
|
||||
const Scene *scene = draw_ctx->scene;
|
||||
|
||||
GPUTexture *tex_tile_data = nullptr;
|
||||
image_gpu_texture_get(image, iuser, ibuf, &pd->texture, &pd->owns_texture, &tex_tile_data);
|
||||
|
||||
if (pd->texture) {
|
||||
static float color[4] = {1.0f, 1.0f, 1.0f, 1.0f};
|
||||
static float shuffle[4] = {1.0f, 1.0f, 1.0f, 1.0f};
|
||||
static float far_near[2] = {100.0f, 0.0f};
|
||||
|
||||
if (scene->camera && scene->camera->type == OB_CAMERA) {
|
||||
far_near[1] = ((Camera *)scene->camera->data)->clip_start;
|
||||
far_near[0] = ((Camera *)scene->camera->data)->clip_end;
|
||||
}
|
||||
|
||||
const bool use_premul_alpha = BKE_image_has_gpu_texture_premultiplied_alpha(image, ibuf);
|
||||
const bool is_tiled_texture = tex_tile_data != nullptr;
|
||||
|
||||
int draw_flags = 0;
|
||||
if (space_type == SPACE_IMAGE) {
|
||||
SpaceImage *sima = (SpaceImage *)draw_ctx->space_data;
|
||||
const int sima_flag = sima->flag & ED_space_image_get_display_channel_mask(ibuf);
|
||||
const bool do_repeat = (!is_tiled_texture) && ((sima->flag & SI_DRAW_TILE) != 0);
|
||||
SET_FLAG_FROM_TEST(draw_flags, do_repeat, IMAGE_DRAW_FLAG_DO_REPEAT);
|
||||
SET_FLAG_FROM_TEST(draw_flags, is_tiled_texture, IMAGE_DRAW_FLAG_USE_WORLD_POS);
|
||||
if ((sima_flag & SI_USE_ALPHA) != 0) {
|
||||
/* Show RGBA */
|
||||
draw_flags |= IMAGE_DRAW_FLAG_SHOW_ALPHA | IMAGE_DRAW_FLAG_APPLY_ALPHA;
|
||||
}
|
||||
else if ((sima_flag & SI_SHOW_ALPHA) != 0) {
|
||||
draw_flags |= IMAGE_DRAW_FLAG_SHUFFLING;
|
||||
copy_v4_fl4(shuffle, 0.0f, 0.0f, 0.0f, 1.0f);
|
||||
}
|
||||
else if ((sima_flag & SI_SHOW_ZBUF) != 0) {
|
||||
draw_flags |= IMAGE_DRAW_FLAG_DEPTH | IMAGE_DRAW_FLAG_SHUFFLING;
|
||||
copy_v4_fl4(shuffle, 1.0f, 0.0f, 0.0f, 0.0f);
|
||||
}
|
||||
else if ((sima_flag & SI_SHOW_R) != 0) {
|
||||
draw_flags |= IMAGE_DRAW_FLAG_SHUFFLING;
|
||||
if (IMB_alpha_affects_rgb(ibuf)) {
|
||||
draw_flags |= IMAGE_DRAW_FLAG_APPLY_ALPHA;
|
||||
}
|
||||
copy_v4_fl4(shuffle, 1.0f, 0.0f, 0.0f, 0.0f);
|
||||
}
|
||||
else if ((sima_flag & SI_SHOW_G) != 0) {
|
||||
draw_flags |= IMAGE_DRAW_FLAG_SHUFFLING;
|
||||
if (IMB_alpha_affects_rgb(ibuf)) {
|
||||
draw_flags |= IMAGE_DRAW_FLAG_APPLY_ALPHA;
|
||||
}
|
||||
copy_v4_fl4(shuffle, 0.0f, 1.0f, 0.0f, 0.0f);
|
||||
}
|
||||
else if ((sima_flag & SI_SHOW_B) != 0) {
|
||||
draw_flags |= IMAGE_DRAW_FLAG_SHUFFLING;
|
||||
if (IMB_alpha_affects_rgb(ibuf)) {
|
||||
draw_flags |= IMAGE_DRAW_FLAG_APPLY_ALPHA;
|
||||
}
|
||||
copy_v4_fl4(shuffle, 0.0f, 0.0f, 1.0f, 0.0f);
|
||||
}
|
||||
else /* RGB */ {
|
||||
if (IMB_alpha_affects_rgb(ibuf)) {
|
||||
draw_flags |= IMAGE_DRAW_FLAG_APPLY_ALPHA;
|
||||
}
|
||||
}
|
||||
}
|
||||
if (space_type == SPACE_NODE) {
|
||||
SpaceNode *snode = (SpaceNode *)draw_ctx->space_data;
|
||||
if ((snode->flag & SNODE_USE_ALPHA) != 0) {
|
||||
/* Show RGBA */
|
||||
draw_flags |= IMAGE_DRAW_FLAG_SHOW_ALPHA | IMAGE_DRAW_FLAG_APPLY_ALPHA;
|
||||
}
|
||||
else if ((snode->flag & SNODE_SHOW_ALPHA) != 0) {
|
||||
draw_flags |= IMAGE_DRAW_FLAG_SHUFFLING;
|
||||
copy_v4_fl4(shuffle, 0.0f, 0.0f, 0.0f, 1.0f);
|
||||
}
|
||||
else if ((snode->flag & SNODE_SHOW_R) != 0) {
|
||||
draw_flags |= IMAGE_DRAW_FLAG_SHUFFLING;
|
||||
if (IMB_alpha_affects_rgb(ibuf)) {
|
||||
draw_flags |= IMAGE_DRAW_FLAG_APPLY_ALPHA;
|
||||
}
|
||||
copy_v4_fl4(shuffle, 1.0f, 0.0f, 0.0f, 0.0f);
|
||||
}
|
||||
else if ((snode->flag & SNODE_SHOW_G) != 0) {
|
||||
draw_flags |= IMAGE_DRAW_FLAG_SHUFFLING;
|
||||
if (IMB_alpha_affects_rgb(ibuf)) {
|
||||
draw_flags |= IMAGE_DRAW_FLAG_APPLY_ALPHA;
|
||||
}
|
||||
copy_v4_fl4(shuffle, 0.0f, 1.0f, 0.0f, 0.0f);
|
||||
}
|
||||
else if ((snode->flag & SNODE_SHOW_B) != 0) {
|
||||
draw_flags |= IMAGE_DRAW_FLAG_SHUFFLING;
|
||||
if (IMB_alpha_affects_rgb(ibuf)) {
|
||||
draw_flags |= IMAGE_DRAW_FLAG_APPLY_ALPHA;
|
||||
}
|
||||
copy_v4_fl4(shuffle, 0.0f, 0.0f, 1.0f, 0.0f);
|
||||
}
|
||||
else /* RGB */ {
|
||||
if (IMB_alpha_affects_rgb(ibuf)) {
|
||||
draw_flags |= IMAGE_DRAW_FLAG_APPLY_ALPHA;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
GPUShader *shader = IMAGE_shader_image_get(is_tiled_texture);
|
||||
DRWShadingGroup *shgrp = DRW_shgroup_create(shader, psl->image_pass);
|
||||
if (is_tiled_texture) {
|
||||
DRW_shgroup_uniform_texture_ex(shgrp, "imageTileArray", pd->texture, GPU_SAMPLER_DEFAULT);
|
||||
DRW_shgroup_uniform_texture(shgrp, "imageTileData", tex_tile_data);
|
||||
}
|
||||
else {
|
||||
DRW_shgroup_uniform_texture_ex(shgrp, "imageTexture", pd->texture, GPU_SAMPLER_DEFAULT);
|
||||
}
|
||||
DRW_shgroup_uniform_vec2_copy(shgrp, "farNearDistances", far_near);
|
||||
DRW_shgroup_uniform_vec4_copy(shgrp, "color", color);
|
||||
DRW_shgroup_uniform_vec4_copy(shgrp, "shuffle", shuffle);
|
||||
DRW_shgroup_uniform_int_copy(shgrp, "drawFlags", draw_flags);
|
||||
DRW_shgroup_uniform_bool_copy(shgrp, "imgPremultiplied", use_premul_alpha);
|
||||
image_cache_image_add(shgrp, image, ibuf);
|
||||
public:
|
||||
ImageEngine(const DRWContextState *draw_ctx, IMAGE_Data *vedata)
|
||||
: draw_ctx(draw_ctx), vedata(vedata), space(space_accessor_from_context(draw_ctx))
|
||||
{
|
||||
}
|
||||
}
|
||||
|
||||
virtual ~ImageEngine() = default;
|
||||
|
||||
private:
|
||||
public:
|
||||
void cache_init()
|
||||
{
|
||||
IMAGE_StorageList *stl = vedata->stl;
|
||||
IMAGE_PrivateData *pd = stl->pd;
|
||||
|
||||
drawing_mode.cache_init(vedata);
|
||||
pd->view = nullptr;
|
||||
if (space->has_view_override()) {
|
||||
const ARegion *region = draw_ctx->region;
|
||||
pd->view = space->create_view_override(region);
|
||||
}
|
||||
}
|
||||
|
||||
void cache_populate()
|
||||
{
|
||||
IMAGE_StorageList *stl = vedata->stl;
|
||||
IMAGE_PrivateData *pd = stl->pd;
|
||||
Main *bmain = CTX_data_main(draw_ctx->evil_C);
|
||||
pd->image = space->get_image(bmain);
|
||||
if (pd->image == nullptr) {
|
||||
/* Early exit, nothing to draw. */
|
||||
return;
|
||||
}
|
||||
pd->ibuf = space->acquire_image_buffer(pd->image, &pd->lock);
|
||||
ImageUser *iuser = space->get_image_user();
|
||||
drawing_mode.cache_image(space.get(), vedata, pd->image, iuser, pd->ibuf);
|
||||
}
|
||||
|
||||
void draw_finish()
|
||||
{
|
||||
drawing_mode.draw_finish(vedata);
|
||||
|
||||
IMAGE_StorageList *stl = vedata->stl;
|
||||
IMAGE_PrivateData *pd = stl->pd;
|
||||
space->release_buffer(pd->image, pd->ibuf, pd->lock);
|
||||
pd->image = nullptr;
|
||||
pd->ibuf = nullptr;
|
||||
}
|
||||
|
||||
void draw_scene()
|
||||
{
|
||||
drawing_mode.draw_scene(vedata);
|
||||
}
|
||||
};
|
||||
|
||||
/* -------------------------------------------------------------------- */
|
||||
/** \name Engine Callbacks
|
||||
|
@ -343,49 +144,12 @@ static void IMAGE_engine_init(void *ved)
|
|||
pd->texture = nullptr;
|
||||
}
|
||||
|
||||
static void IMAGE_cache_init(void *ved)
|
||||
static void IMAGE_cache_init(void *vedata)
|
||||
{
|
||||
IMAGE_Data *vedata = (IMAGE_Data *)ved;
|
||||
IMAGE_StorageList *stl = vedata->stl;
|
||||
IMAGE_PrivateData *pd = stl->pd;
|
||||
IMAGE_PassList *psl = vedata->psl;
|
||||
const DRWContextState *draw_ctx = DRW_context_state_get();
|
||||
|
||||
{
|
||||
/* Write depth is needed for background overlay rendering. Near depth is used for
|
||||
* transparency checker and Far depth is used for indicating the image size. */
|
||||
DRWState state = static_cast<DRWState>(DRW_STATE_WRITE_COLOR | DRW_STATE_WRITE_DEPTH |
|
||||
DRW_STATE_DEPTH_ALWAYS | DRW_STATE_BLEND_ALPHA_PREMUL);
|
||||
psl->image_pass = DRW_pass_create("Image", state);
|
||||
}
|
||||
|
||||
const SpaceLink *space_link = draw_ctx->space_data;
|
||||
const char space_type = space_link->spacetype;
|
||||
pd->view = nullptr;
|
||||
if (space_type == SPACE_IMAGE) {
|
||||
SpaceImage *sima = (SpaceImage *)draw_ctx->space_data;
|
||||
Image *image = ED_space_image(sima);
|
||||
ImBuf *ibuf = ED_space_image_acquire_buffer(sima, &pd->lock, 0);
|
||||
image_cache_image(vedata, image, &sima->iuser, ibuf);
|
||||
pd->image = image;
|
||||
pd->ibuf = ibuf;
|
||||
}
|
||||
else if (space_type == SPACE_NODE) {
|
||||
ARegion *region = draw_ctx->region;
|
||||
Main *bmain = CTX_data_main(draw_ctx->evil_C);
|
||||
Image *image = BKE_image_ensure_viewer(bmain, IMA_TYPE_COMPOSITE, "Viewer Node");
|
||||
ImBuf *ibuf = BKE_image_acquire_ibuf(image, nullptr, &pd->lock);
|
||||
{
|
||||
/* Setup a screen pixel view. The backdrop of the node editor doesn't follow the region. */
|
||||
float winmat[4][4], viewmat[4][4];
|
||||
orthographic_m4(viewmat, 0.0, region->winx, 0.0, region->winy, 0.0, 1.0);
|
||||
unit_m4(winmat);
|
||||
pd->view = DRW_view_create(viewmat, winmat, nullptr, nullptr, nullptr);
|
||||
}
|
||||
image_cache_image(vedata, image, nullptr, ibuf);
|
||||
pd->image = image;
|
||||
pd->ibuf = ibuf;
|
||||
}
|
||||
ImageEngine image_engine(draw_ctx, static_cast<IMAGE_Data *>(vedata));
|
||||
image_engine.cache_init();
|
||||
image_engine.cache_populate();
|
||||
}
|
||||
|
||||
static void IMAGE_cache_populate(void *UNUSED(vedata), Object *UNUSED(ob))
|
||||
|
@ -393,45 +157,12 @@ static void IMAGE_cache_populate(void *UNUSED(vedata), Object *UNUSED(ob))
|
|||
/* Function intentional left empty. `cache_populate` is required to be implemented. */
|
||||
}
|
||||
|
||||
static void image_draw_finish(IMAGE_Data *ved)
|
||||
static void IMAGE_draw_scene(void *vedata)
|
||||
{
|
||||
IMAGE_Data *vedata = (IMAGE_Data *)ved;
|
||||
IMAGE_StorageList *stl = vedata->stl;
|
||||
IMAGE_PrivateData *pd = stl->pd;
|
||||
const DRWContextState *draw_ctx = DRW_context_state_get();
|
||||
const char space_type = draw_ctx->space_data->spacetype;
|
||||
if (space_type == SPACE_IMAGE) {
|
||||
SpaceImage *sima = (SpaceImage *)draw_ctx->space_data;
|
||||
ED_space_image_release_buffer(sima, pd->ibuf, pd->lock);
|
||||
}
|
||||
else if (space_type == SPACE_NODE) {
|
||||
BKE_image_release_ibuf(pd->image, pd->ibuf, pd->lock);
|
||||
}
|
||||
pd->image = nullptr;
|
||||
pd->ibuf = nullptr;
|
||||
|
||||
if (pd->texture && pd->owns_texture) {
|
||||
GPU_texture_free(pd->texture);
|
||||
pd->owns_texture = false;
|
||||
}
|
||||
pd->texture = nullptr;
|
||||
}
|
||||
|
||||
static void IMAGE_draw_scene(void *ved)
|
||||
{
|
||||
IMAGE_Data *vedata = (IMAGE_Data *)ved;
|
||||
IMAGE_PassList *psl = vedata->psl;
|
||||
IMAGE_PrivateData *pd = vedata->stl->pd;
|
||||
|
||||
DefaultFramebufferList *dfbl = DRW_viewport_framebuffer_list_get();
|
||||
GPU_framebuffer_bind(dfbl->default_fb);
|
||||
static float clear_col[4] = {0.0f, 0.0f, 0.0f, 0.0f};
|
||||
GPU_framebuffer_clear_color_depth(dfbl->default_fb, clear_col, 1.0);
|
||||
|
||||
DRW_view_set_active(pd->view);
|
||||
DRW_draw_pass(psl->image_pass);
|
||||
DRW_view_set_active(nullptr);
|
||||
image_draw_finish(vedata);
|
||||
ImageEngine image_engine(draw_ctx, static_cast<IMAGE_Data *>(vedata));
|
||||
image_engine.draw_scene();
|
||||
image_engine.draw_finish();
|
||||
}
|
||||
|
||||
static void IMAGE_engine_free()
|
||||
|
@ -466,4 +197,3 @@ DrawEngineType draw_engine_image_type = {
|
|||
nullptr, /* store_metadata */
|
||||
};
|
||||
}
|
||||
|
||||
|
|
|
@ -17,7 +17,7 @@
|
|||
*/
|
||||
|
||||
/** \file
|
||||
* \ingroup draw_editors
|
||||
* \ingroup draw_engine
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
|
|
|
@ -20,10 +20,16 @@
|
|||
* \ingroup draw_engine
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
|
||||
#include <optional>
|
||||
|
||||
/* Forward declarations */
|
||||
extern "C" {
|
||||
struct GPUTexture;
|
||||
struct ImBuf;
|
||||
struct Image;
|
||||
}
|
||||
|
||||
/* *********** LISTS *********** */
|
||||
|
||||
|
@ -57,6 +63,128 @@ struct IMAGE_Data {
|
|||
IMAGE_StorageList *stl;
|
||||
};
|
||||
|
||||
/* Shader parameters. */
|
||||
#define IMAGE_DRAW_FLAG_SHOW_ALPHA (1 << 0)
|
||||
#define IMAGE_DRAW_FLAG_APPLY_ALPHA (1 << 1)
|
||||
#define IMAGE_DRAW_FLAG_SHUFFLING (1 << 2)
|
||||
#define IMAGE_DRAW_FLAG_DEPTH (1 << 3)
|
||||
#define IMAGE_DRAW_FLAG_DO_REPEAT (1 << 4)
|
||||
#define IMAGE_DRAW_FLAG_USE_WORLD_POS (1 << 5)
|
||||
|
||||
struct ShaderParameters {
|
||||
constexpr static float color[4] = {1.0f, 1.0f, 1.0f, 1.0f};
|
||||
|
||||
int flags = 0;
|
||||
float shuffle[4];
|
||||
float far_near[2];
|
||||
bool use_premul_alpha = false;
|
||||
|
||||
ShaderParameters()
|
||||
{
|
||||
copy_v4_fl(shuffle, 1.0f);
|
||||
copy_v2_fl2(far_near, 100.0f, 0.0f);
|
||||
}
|
||||
};
|
||||
|
||||
/**
|
||||
* Space accessor.
|
||||
*
|
||||
* Image engine is used to draw the images inside multiple spaces \see SpaceLink.
|
||||
* The AbstractSpaceAccessor is an interface to communicate with a space.
|
||||
*/
|
||||
class AbstractSpaceAccessor {
|
||||
public:
|
||||
/**
|
||||
* Return the active image of the space.
|
||||
*
|
||||
* The returned image will be drawn in the space.
|
||||
*
|
||||
* The return value is optional.
|
||||
*/
|
||||
virtual Image *get_image(Main *bmain) = 0;
|
||||
|
||||
/**
|
||||
* Return the #ImageUser of the space.
|
||||
*
|
||||
* The return value is optional.
|
||||
*/
|
||||
virtual ImageUser *get_image_user() = 0;
|
||||
|
||||
/**
|
||||
* Acquire the image buffer of the image.
|
||||
*
|
||||
* \param image: Image to get the buffer from. Image is the same as returned from the #get_image
|
||||
* member.
|
||||
* \param lock: pointer to a lock object.
|
||||
* \return Image buffer of the given image.
|
||||
*/
|
||||
virtual ImBuf *acquire_image_buffer(Image *image, void **lock) = 0;
|
||||
|
||||
/**
|
||||
* Release a previous locked image from #acquire_image_buffer.
|
||||
*/
|
||||
virtual void release_buffer(Image *image, ImBuf *image_buffer, void *lock) = 0;
|
||||
|
||||
/**
|
||||
* Update the r_shader_parameters with space specific settings.
|
||||
*
|
||||
* Only update the #ShaderParameters.flags and #ShaderParameters.shuffle. Other parameters
|
||||
* are updated inside the image engine.
|
||||
*/
|
||||
virtual void get_shader_parameters(ShaderParameters &r_shader_parameters,
|
||||
ImBuf *image_buffer,
|
||||
bool is_tiled) = 0;
|
||||
|
||||
/**
|
||||
* Retrieve the gpu textures to draw.
|
||||
*/
|
||||
virtual void get_gpu_textures(Image *image,
|
||||
ImageUser *iuser,
|
||||
ImBuf *image_buffer,
|
||||
GPUTexture **r_gpu_texture,
|
||||
bool *r_owns_texture,
|
||||
GPUTexture **r_tex_tile_data) = 0;
|
||||
|
||||
/**
|
||||
* Does this space override the view.
|
||||
* When so this member should return true and the create_view_override must return the view to
|
||||
* use during drawing.
|
||||
*/
|
||||
virtual bool has_view_override() const = 0;
|
||||
|
||||
/**
|
||||
* Override the view for drawing.
|
||||
* Should match #has_view_override.
|
||||
*/
|
||||
virtual DRWView *create_view_override(const ARegion *UNUSED(region)) = 0;
|
||||
|
||||
/**
|
||||
* Initialize the matrix that will be used to draw the image. The matrix will be send as object
|
||||
* matrix to the drawing pipeline.
|
||||
*/
|
||||
virtual void get_image_mat(const ImBuf *image_buffer,
|
||||
const ARegion *region,
|
||||
float r_mat[4][4]) const = 0;
|
||||
}; // namespace blender::draw::image_engine
|
||||
|
||||
/**
|
||||
* Abstract class for a drawing mode of the image engine.
|
||||
*
|
||||
* The drawing mode decides how to draw the image on the screen. Each way how to draw would have
|
||||
* its own subclass. For now there is only a single drawing mode. #DefaultDrawingMode.
|
||||
**/
|
||||
class AbstractDrawingMode {
|
||||
public:
|
||||
virtual void cache_init(IMAGE_Data *vedata) const = 0;
|
||||
virtual void cache_image(AbstractSpaceAccessor *space,
|
||||
IMAGE_Data *vedata,
|
||||
Image *image,
|
||||
ImageUser *iuser,
|
||||
ImBuf *image_buffer) const = 0;
|
||||
virtual void draw_scene(IMAGE_Data *vedata) const = 0;
|
||||
virtual void draw_finish(IMAGE_Data *vedata) const = 0;
|
||||
};
|
||||
|
||||
/* image_shader.c */
|
||||
GPUShader *IMAGE_shader_image_get(bool is_tiled_image);
|
||||
void IMAGE_shader_library_ensure(void);
|
||||
|
|
|
@ -0,0 +1,183 @@
|
|||
/*
|
||||
* This program is free software; you can redistribute it and/or
|
||||
* modify it under the terms of the GNU General Public License
|
||||
* as published by the Free Software Foundation; either version 2
|
||||
* of the License, or (at your option) any later version.
|
||||
*
|
||||
* This program is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
* GNU General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License
|
||||
* along with this program; if not, write to the Free Software Foundation,
|
||||
* Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
|
||||
*
|
||||
* Copyright 2021, Blender Foundation.
|
||||
*/
|
||||
|
||||
/** \file
|
||||
* \ingroup draw_engine
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
|
||||
#include "image_private.hh"
|
||||
|
||||
namespace blender::draw::image_engine {
|
||||
|
||||
class SpaceImageAccessor : public AbstractSpaceAccessor {
|
||||
SpaceImage *sima;
|
||||
|
||||
public:
|
||||
SpaceImageAccessor(SpaceImage *sima) : sima(sima)
|
||||
{
|
||||
}
|
||||
|
||||
Image *get_image(Main *UNUSED(bmain)) override
|
||||
{
|
||||
return ED_space_image(sima);
|
||||
}
|
||||
|
||||
ImageUser *get_image_user() override
|
||||
{
|
||||
return &sima->iuser;
|
||||
}
|
||||
|
||||
ImBuf *acquire_image_buffer(Image *UNUSED(image), void **lock) override
|
||||
{
|
||||
return ED_space_image_acquire_buffer(sima, lock, 0);
|
||||
}
|
||||
|
||||
void release_buffer(Image *UNUSED(image), ImBuf *image_buffer, void *lock) override
|
||||
{
|
||||
ED_space_image_release_buffer(sima, image_buffer, lock);
|
||||
}
|
||||
|
||||
void get_shader_parameters(ShaderParameters &r_shader_parameters,
|
||||
ImBuf *image_buffer,
|
||||
bool is_tiled) override
|
||||
{
|
||||
const int sima_flag = sima->flag & ED_space_image_get_display_channel_mask(image_buffer);
|
||||
const bool do_repeat = (!is_tiled) && ((sima->flag & SI_DRAW_TILE) != 0);
|
||||
SET_FLAG_FROM_TEST(r_shader_parameters.flags, do_repeat, IMAGE_DRAW_FLAG_DO_REPEAT);
|
||||
SET_FLAG_FROM_TEST(r_shader_parameters.flags, is_tiled, IMAGE_DRAW_FLAG_USE_WORLD_POS);
|
||||
if ((sima_flag & SI_USE_ALPHA) != 0) {
|
||||
/* Show RGBA */
|
||||
r_shader_parameters.flags |= IMAGE_DRAW_FLAG_SHOW_ALPHA | IMAGE_DRAW_FLAG_APPLY_ALPHA;
|
||||
}
|
||||
else if ((sima_flag & SI_SHOW_ALPHA) != 0) {
|
||||
r_shader_parameters.flags |= IMAGE_DRAW_FLAG_SHUFFLING;
|
||||
copy_v4_fl4(r_shader_parameters.shuffle, 0.0f, 0.0f, 0.0f, 1.0f);
|
||||
}
|
||||
else if ((sima_flag & SI_SHOW_ZBUF) != 0) {
|
||||
r_shader_parameters.flags |= IMAGE_DRAW_FLAG_DEPTH | IMAGE_DRAW_FLAG_SHUFFLING;
|
||||
copy_v4_fl4(r_shader_parameters.shuffle, 1.0f, 0.0f, 0.0f, 0.0f);
|
||||
}
|
||||
else if ((sima_flag & SI_SHOW_R) != 0) {
|
||||
r_shader_parameters.flags |= IMAGE_DRAW_FLAG_SHUFFLING;
|
||||
if (IMB_alpha_affects_rgb(image_buffer)) {
|
||||
r_shader_parameters.flags |= IMAGE_DRAW_FLAG_APPLY_ALPHA;
|
||||
}
|
||||
copy_v4_fl4(r_shader_parameters.shuffle, 1.0f, 0.0f, 0.0f, 0.0f);
|
||||
}
|
||||
else if ((sima_flag & SI_SHOW_G) != 0) {
|
||||
r_shader_parameters.flags |= IMAGE_DRAW_FLAG_SHUFFLING;
|
||||
if (IMB_alpha_affects_rgb(image_buffer)) {
|
||||
r_shader_parameters.flags |= IMAGE_DRAW_FLAG_APPLY_ALPHA;
|
||||
}
|
||||
copy_v4_fl4(r_shader_parameters.shuffle, 0.0f, 1.0f, 0.0f, 0.0f);
|
||||
}
|
||||
else if ((sima_flag & SI_SHOW_B) != 0) {
|
||||
r_shader_parameters.flags |= IMAGE_DRAW_FLAG_SHUFFLING;
|
||||
if (IMB_alpha_affects_rgb(image_buffer)) {
|
||||
r_shader_parameters.flags |= IMAGE_DRAW_FLAG_APPLY_ALPHA;
|
||||
}
|
||||
copy_v4_fl4(r_shader_parameters.shuffle, 0.0f, 0.0f, 1.0f, 0.0f);
|
||||
}
|
||||
else /* RGB */ {
|
||||
if (IMB_alpha_affects_rgb(image_buffer)) {
|
||||
r_shader_parameters.flags |= IMAGE_DRAW_FLAG_APPLY_ALPHA;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
bool has_view_override() const override
|
||||
{
|
||||
return false;
|
||||
}
|
||||
DRWView *create_view_override(const ARegion *UNUSED(region)) override
|
||||
{
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
void get_gpu_textures(Image *image,
|
||||
ImageUser *iuser,
|
||||
ImBuf *image_buffer,
|
||||
GPUTexture **r_gpu_texture,
|
||||
bool *r_owns_texture,
|
||||
GPUTexture **r_tex_tile_data) override
|
||||
{
|
||||
if (image->rr != nullptr) {
|
||||
/* Update multi-index and pass for the current eye. */
|
||||
BKE_image_multilayer_index(image->rr, iuser);
|
||||
}
|
||||
else {
|
||||
BKE_image_multiview_index(image, iuser);
|
||||
}
|
||||
|
||||
if (image_buffer == nullptr) {
|
||||
return;
|
||||
}
|
||||
|
||||
if (image_buffer->rect == nullptr && image_buffer->rect_float == nullptr) {
|
||||
/* This code-path is only supposed to happen when drawing a lazily-allocatable render result.
|
||||
* In all the other cases the `ED_space_image_acquire_buffer()` is expected to return nullptr
|
||||
* as an image buffer when it has no pixels. */
|
||||
|
||||
BLI_assert(image->type == IMA_TYPE_R_RESULT);
|
||||
|
||||
float zero[4] = {0, 0, 0, 0};
|
||||
*r_gpu_texture = GPU_texture_create_2d(__func__, 1, 1, 0, GPU_RGBA16F, zero);
|
||||
*r_owns_texture = true;
|
||||
return;
|
||||
}
|
||||
|
||||
const int sima_flag = sima->flag & ED_space_image_get_display_channel_mask(image_buffer);
|
||||
if (sima_flag & SI_SHOW_ZBUF &&
|
||||
(image_buffer->zbuf || image_buffer->zbuf_float || (image_buffer->channels == 1))) {
|
||||
if (image_buffer->zbuf) {
|
||||
BLI_assert_msg(0, "Integer based depth buffers not supported");
|
||||
}
|
||||
else if (image_buffer->zbuf_float) {
|
||||
*r_gpu_texture = GPU_texture_create_2d(
|
||||
__func__, image_buffer->x, image_buffer->y, 0, GPU_R16F, image_buffer->zbuf_float);
|
||||
*r_owns_texture = true;
|
||||
}
|
||||
else if (image_buffer->rect_float && image_buffer->channels == 1) {
|
||||
*r_gpu_texture = GPU_texture_create_2d(
|
||||
__func__, image_buffer->x, image_buffer->y, 0, GPU_R16F, image_buffer->rect_float);
|
||||
*r_owns_texture = true;
|
||||
}
|
||||
}
|
||||
else if (image->source == IMA_SRC_TILED) {
|
||||
*r_gpu_texture = BKE_image_get_gpu_tiles(image, iuser, image_buffer);
|
||||
*r_tex_tile_data = BKE_image_get_gpu_tilemap(image, iuser, nullptr);
|
||||
*r_owns_texture = false;
|
||||
}
|
||||
else {
|
||||
*r_gpu_texture = BKE_image_get_gpu_texture(image, iuser, image_buffer);
|
||||
*r_owns_texture = false;
|
||||
}
|
||||
}
|
||||
|
||||
void get_image_mat(const ImBuf *UNUSED(image_buffer),
|
||||
const ARegion *UNUSED(region),
|
||||
float r_mat[4][4]) const override
|
||||
{
|
||||
unit_m4(r_mat);
|
||||
}
|
||||
};
|
||||
|
||||
} // namespace blender::draw::image_engine
|
||||
|
|
@ -0,0 +1,139 @@
|
|||
/*
|
||||
* This program is free software; you can redistribute it and/or
|
||||
* modify it under the terms of the GNU General Public License
|
||||
* as published by the Free Software Foundation; either version 2
|
||||
* of the License, or (at your option) any later version.
|
||||
*
|
||||
* This program is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
* GNU General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License
|
||||
* along with this program; if not, write to the Free Software Foundation,
|
||||
* Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
|
||||
*
|
||||
* Copyright 2021, Blender Foundation.
|
||||
*/
|
||||
|
||||
/** \file
|
||||
* \ingroup draw_engine
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
|
||||
#include "image_private.hh"
|
||||
|
||||
namespace blender::draw::image_engine {
|
||||
|
||||
class SpaceNodeAccessor : public AbstractSpaceAccessor {
|
||||
SpaceNode *snode;
|
||||
|
||||
public:
|
||||
SpaceNodeAccessor(SpaceNode *snode) : snode(snode)
|
||||
{
|
||||
}
|
||||
|
||||
Image *get_image(Main *bmain) override
|
||||
{
|
||||
return BKE_image_ensure_viewer(bmain, IMA_TYPE_COMPOSITE, "Viewer Node");
|
||||
}
|
||||
|
||||
ImageUser *get_image_user() override
|
||||
{
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
ImBuf *acquire_image_buffer(Image *image, void **lock) override
|
||||
{
|
||||
return BKE_image_acquire_ibuf(image, nullptr, lock);
|
||||
}
|
||||
|
||||
void release_buffer(Image *image, ImBuf *ibuf, void *lock) override
|
||||
{
|
||||
BKE_image_release_ibuf(image, ibuf, lock);
|
||||
}
|
||||
|
||||
bool has_view_override() const override
|
||||
{
|
||||
return true;
|
||||
}
|
||||
|
||||
DRWView *create_view_override(const ARegion *region) override
|
||||
{
|
||||
/* Setup a screen pixel view. The backdrop of the node editor doesn't follow the region. */
|
||||
float winmat[4][4], viewmat[4][4];
|
||||
orthographic_m4(viewmat, 0.0, region->winx, 0.0, region->winy, 0.0, 1.0);
|
||||
unit_m4(winmat);
|
||||
return DRW_view_create(viewmat, winmat, nullptr, nullptr, nullptr);
|
||||
}
|
||||
|
||||
void get_shader_parameters(ShaderParameters &r_shader_parameters,
|
||||
ImBuf *ibuf,
|
||||
bool UNUSED(is_tiled)) override
|
||||
{
|
||||
if ((snode->flag & SNODE_USE_ALPHA) != 0) {
|
||||
/* Show RGBA */
|
||||
r_shader_parameters.flags |= IMAGE_DRAW_FLAG_SHOW_ALPHA | IMAGE_DRAW_FLAG_APPLY_ALPHA;
|
||||
}
|
||||
else if ((snode->flag & SNODE_SHOW_ALPHA) != 0) {
|
||||
r_shader_parameters.flags |= IMAGE_DRAW_FLAG_SHUFFLING;
|
||||
copy_v4_fl4(r_shader_parameters.shuffle, 0.0f, 0.0f, 0.0f, 1.0f);
|
||||
}
|
||||
else if ((snode->flag & SNODE_SHOW_R) != 0) {
|
||||
r_shader_parameters.flags |= IMAGE_DRAW_FLAG_SHUFFLING;
|
||||
if (IMB_alpha_affects_rgb(ibuf)) {
|
||||
r_shader_parameters.flags |= IMAGE_DRAW_FLAG_APPLY_ALPHA;
|
||||
}
|
||||
copy_v4_fl4(r_shader_parameters.shuffle, 1.0f, 0.0f, 0.0f, 0.0f);
|
||||
}
|
||||
else if ((snode->flag & SNODE_SHOW_G) != 0) {
|
||||
r_shader_parameters.flags |= IMAGE_DRAW_FLAG_SHUFFLING;
|
||||
if (IMB_alpha_affects_rgb(ibuf)) {
|
||||
r_shader_parameters.flags |= IMAGE_DRAW_FLAG_APPLY_ALPHA;
|
||||
}
|
||||
copy_v4_fl4(r_shader_parameters.shuffle, 0.0f, 1.0f, 0.0f, 0.0f);
|
||||
}
|
||||
else if ((snode->flag & SNODE_SHOW_B) != 0) {
|
||||
r_shader_parameters.flags |= IMAGE_DRAW_FLAG_SHUFFLING;
|
||||
if (IMB_alpha_affects_rgb(ibuf)) {
|
||||
r_shader_parameters.flags |= IMAGE_DRAW_FLAG_APPLY_ALPHA;
|
||||
}
|
||||
copy_v4_fl4(r_shader_parameters.shuffle, 0.0f, 0.0f, 1.0f, 0.0f);
|
||||
}
|
||||
else /* RGB */ {
|
||||
if (IMB_alpha_affects_rgb(ibuf)) {
|
||||
r_shader_parameters.flags |= IMAGE_DRAW_FLAG_APPLY_ALPHA;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void get_gpu_textures(Image *image,
|
||||
ImageUser *iuser,
|
||||
ImBuf *ibuf,
|
||||
GPUTexture **r_gpu_texture,
|
||||
bool *r_owns_texture,
|
||||
GPUTexture **r_tex_tile_data) override
|
||||
{
|
||||
*r_gpu_texture = BKE_image_get_gpu_texture(image, iuser, ibuf);
|
||||
*r_owns_texture = false;
|
||||
*r_tex_tile_data = nullptr;
|
||||
}
|
||||
|
||||
void get_image_mat(const ImBuf *image_buffer,
|
||||
const ARegion *region,
|
||||
float r_mat[4][4]) const override
|
||||
{
|
||||
unit_m4(r_mat);
|
||||
const float ibuf_width = image_buffer->x;
|
||||
const float ibuf_height = image_buffer->y;
|
||||
|
||||
r_mat[0][0] = ibuf_width * snode->zoom;
|
||||
r_mat[1][1] = ibuf_height * snode->zoom;
|
||||
r_mat[3][0] = (region->winx - snode->zoom * ibuf_width) / 2 + snode->xof;
|
||||
r_mat[3][1] = (region->winy - snode->zoom * ibuf_height) / 2 + snode->yof;
|
||||
}
|
||||
};
|
||||
|
||||
} // namespace blender::draw::image_engine
|
||||
|
Loading…
Reference in New Issue