GPU_framebuffer.hh

Go to the documentation of this file.

/* SPDX-FileCopyrightText: 2005 Blender Authors
 *
 * SPDX-License-Identifier: GPL-2.0-or-later */

 
#pragma once
 
#include "GPU_common_types.hh"
#include "GPU_texture.hh"
 
namespace blender::gpu {
class Texture;
class FrameBuffer;
}  // namespace blender::gpu
 
enum GPUFrameBufferBits {
  GPU_COLOR_BIT = (1 << 0),
  GPU_DEPTH_BIT = (1 << 1),
  GPU_STENCIL_BIT = (1 << 2),
};
 
ENUM_OPERATORS(GPUFrameBufferBits, GPU_STENCIL_BIT)
 
/* Guaranteed by the spec and is never greater than 16 on any hardware or implementation. */
constexpr static int GPU_MAX_VIEWPORTS = 16;
 
struct GPUAttachment {
  blender::gpu::Texture *tex;
  int layer, mip;
};
 
/* -------------------------------------------------------------------- */

blender::gpu::FrameBuffer *GPU_framebuffer_create(const char *name);

blender::gpu::FrameBuffer *GPU_framebuffer_active_get();

blender::gpu::FrameBuffer *GPU_framebuffer_back_get();

 
/* -------------------------------------------------------------------- */

void GPU_framebuffer_free(blender::gpu::FrameBuffer *fb);
 
#define GPU_FRAMEBUFFER_FREE_SAFE(fb) \
  do { \
    if (fb != nullptr) { \
      GPU_framebuffer_free(fb); \
      fb = nullptr; \
    } \
  } while (0)

 
/* -------------------------------------------------------------------- */
 
enum GPUBackBuffer {
  GPU_BACKBUFFER_LEFT = 0,
  GPU_BACKBUFFER_RIGHT,
};

void GPU_backbuffer_bind(GPUBackBuffer back_buffer_type);

void GPU_framebuffer_bind(blender::gpu::FrameBuffer *fb);

void GPU_framebuffer_bind_no_srgb(blender::gpu::FrameBuffer *fb);

void GPU_framebuffer_restore();

 
/* -------------------------------------------------------------------- */
 
struct GPULoadStore {
  GPULoadOp load_action;
  GPUStoreOp store_action;
  float clear_value[4];
};
 
/* Empty bind point. */
#define NULL_ATTACHMENT_COLOR {0.0, 0.0, 0.0, 0.0}
#define NULL_LOAD_STORE \
  {GPU_LOADACTION_DONT_CARE, GPU_STOREACTION_DONT_CARE, NULL_ATTACHMENT_COLOR}

void GPU_framebuffer_bind_loadstore(blender::gpu::FrameBuffer *fb,
                                    const GPULoadStore *load_store_actions,
                                    uint load_store_actions_len);
#define GPU_framebuffer_bind_ex(_fb, ...) \
  { \
    GPULoadStore actions[] = __VA_ARGS__; \
    GPU_framebuffer_bind_loadstore(_fb, actions, (sizeof(actions) / sizeof(GPULoadStore))); \
  }

void GPU_framebuffer_subpass_transition_array(blender::gpu::FrameBuffer *fb,
                                              const GPUAttachmentState *attachment_states,
                                              uint attachment_len);
 
#define GPU_framebuffer_subpass_transition(_fb, ...) \
  { \
    GPUAttachmentState actions[] = __VA_ARGS__; \
    GPU_framebuffer_subpass_transition_array( \
        _fb, actions, (sizeof(actions) / sizeof(GPUAttachmentState))); \
  }

 
/* -------------------------------------------------------------------- */

#define GPU_framebuffer_ensure_config(_fb, ...) \
  do { \
    if (*(_fb) == nullptr) { \
      *(_fb) = GPU_framebuffer_create(#_fb); \
    } \
    GPUAttachment config[] = __VA_ARGS__; \
    GPU_framebuffer_config_array(*(_fb), config, (sizeof(config) / sizeof(GPUAttachment))); \
  } while (0)

void GPU_framebuffer_config_array(blender::gpu::FrameBuffer *fb,
                                  const GPUAttachment *config,
                                  int config_len);

#define GPU_ATTACHMENT_NONE \
  { \
      nullptr, \
      -1, \
      0, \
  }

#define GPU_ATTACHMENT_LEAVE \
  { \
      nullptr, \
      -1, \
      -1, \
  }

#define GPU_ATTACHMENT_TEXTURE(_texture) \
  { \
      _texture, \
      -1, \
      0, \
  }

#define GPU_ATTACHMENT_TEXTURE_MIP(_texture, _mip) \
  { \
      _texture, \
      -1, \
      _mip, \
  }

#define GPU_ATTACHMENT_TEXTURE_LAYER(_texture, _layer) \
  { \
      _texture, \
      _layer, \
      0, \
  }

#define GPU_ATTACHMENT_TEXTURE_LAYER_MIP(_texture, _layer, _mip) \
  { \
      _texture, \
      _layer, \
      _mip, \
  }


#define GPU_ATTACHMENT_TEXTURE_CUBEFACE(_texture, _face) \
  { \
      _texture, \
      _face, \
      0, \
  }

#define GPU_ATTACHMENT_TEXTURE_CUBEFACE_MIP(_texture, _face, _mip) \
  { \
      _texture, \
      _face, \
      _mip, \
  }

void GPU_framebuffer_texture_attach(blender::gpu::FrameBuffer *fb,
                                    blender::gpu::Texture *texture,
                                    int slot,
                                    int mip);

void GPU_framebuffer_texture_layer_attach(
    blender::gpu::FrameBuffer *fb, blender::gpu::Texture *texture, int slot, int layer, int mip);

void GPU_framebuffer_texture_cubeface_attach(
    blender::gpu::FrameBuffer *fb, blender::gpu::Texture *texture, int slot, int face, int mip);

void GPU_framebuffer_texture_detach(blender::gpu::FrameBuffer *fb, blender::gpu::Texture *texture);

bool GPU_framebuffer_check_valid(blender::gpu::FrameBuffer *fb, char err_out[256]);

 
/* -------------------------------------------------------------------- */

void GPU_framebuffer_default_size(blender::gpu::FrameBuffer *fb, int width, int height);

 
/* -------------------------------------------------------------------- */

void GPU_framebuffer_viewport_set(
    blender::gpu::FrameBuffer *fb, int x, int y, int width, int height);

void GPU_framebuffer_multi_viewports_set(blender::gpu::FrameBuffer *gpu_fb,
                                         const int viewport_rects[GPU_MAX_VIEWPORTS][4]);

void GPU_framebuffer_viewport_get(blender::gpu::FrameBuffer *fb, int r_viewport[4]);

void GPU_framebuffer_viewport_reset(blender::gpu::FrameBuffer *fb);

 
/* -------------------------------------------------------------------- */

void GPU_framebuffer_clear(blender::gpu::FrameBuffer *fb,
                           GPUFrameBufferBits buffers,
                           const float clear_col[4],
                           float clear_depth,
                           unsigned int clear_stencil);

void GPU_framebuffer_clear_color(blender::gpu::FrameBuffer *fb, const float clear_col[4]);

void GPU_framebuffer_clear_depth(blender::gpu::FrameBuffer *fb, float clear_depth);

void GPU_framebuffer_clear_stencil(blender::gpu::FrameBuffer *fb, uint clear_stencil);

void GPU_framebuffer_clear_color_depth(blender::gpu::FrameBuffer *fb,
                                       const float clear_col[4],
                                       float clear_depth);

void GPU_framebuffer_clear_depth_stencil(blender::gpu::FrameBuffer *fb,
                                         float clear_depth,
                                         uint clear_stencil);
void GPU_framebuffer_clear_color_depth_stencil(blender::gpu::FrameBuffer *fb,
                                               const float clear_col[4],
                                               float clear_depth,
                                               uint clear_stencil);

void GPU_framebuffer_multi_clear(blender::gpu::FrameBuffer *fb, const float (*clear_colors)[4]);

void GPU_clear_color(float red, float green, float blue, float alpha);

void GPU_clear_depth(float depth);

 
/* -------------------------------------------------------------------- */
 
const char *GPU_framebuffer_get_name(blender::gpu::FrameBuffer *fb);

 
/* -------------------------------------------------------------------- */

#ifndef GPU_NO_USE_PY_REFERENCES
void **GPU_framebuffer_py_reference_get(blender::gpu::FrameBuffer *fb);
void GPU_framebuffer_py_reference_set(blender::gpu::FrameBuffer *fb, void **py_ref);
#endif

/* TODO(fclem): This has nothing to do with the GPU module and should be move to the pyGPU module.
 */
void GPU_framebuffer_push(blender::gpu::FrameBuffer *fb);
blender::gpu::FrameBuffer *GPU_framebuffer_pop();
uint GPU_framebuffer_stack_level_get();

 
/* -------------------------------------------------------------------- */

bool GPU_framebuffer_bound(blender::gpu::FrameBuffer *fb);

void GPU_framebuffer_read_depth(blender::gpu::FrameBuffer *fb,
                                int x,
                                int y,
                                int width,
                                int height,
                                eGPUDataFormat data_format,
                                void *r_data);

void GPU_framebuffer_read_color(blender::gpu::FrameBuffer *fb,
                                int x,
                                int y,
                                int width,
                                int height,
                                int channels,
                                int slot,
                                eGPUDataFormat data_format,
                                void *r_data);

void GPU_frontbuffer_read_color(
    int x, int y, int width, int height, int channels, eGPUDataFormat data_format, void *r_data);

void GPU_framebuffer_blit(blender::gpu::FrameBuffer *fb_read,
                          int read_slot,
                          blender::gpu::FrameBuffer *fb_write,
                          int write_slot,
                          GPUFrameBufferBits blit_buffers);

 
/* -------------------------------------------------------------------- */
 
struct GPUOffScreen;

GPUOffScreen *GPU_offscreen_create(int width,
                                   int height,
                                   bool with_depth_buffer,
                                   blender::gpu::TextureFormat format,
                                   eGPUTextureUsage usage,
                                   bool clear,
                                   char err_out[256]);

void GPU_offscreen_free(GPUOffScreen *offscreen);

/* TODO(fclem): Remove the `save` parameter and always save/restore. */
void GPU_offscreen_bind(GPUOffScreen *offscreen, bool save);

/* TODO(fclem): Remove the `save` parameter and always save/restore. */
void GPU_offscreen_unbind(GPUOffScreen *offscreen, bool restore);

void GPU_offscreen_read_color(GPUOffScreen *offscreen, eGPUDataFormat data_format, void *r_data);
void GPU_offscreen_read_color_region(
    GPUOffScreen *offscreen, eGPUDataFormat data_format, int x, int y, int w, int h, void *r_data);

void GPU_offscreen_draw_to_screen(GPUOffScreen *offscreen, int x, int y);

int GPU_offscreen_width(const GPUOffScreen *offscreen);

int GPU_offscreen_height(const GPUOffScreen *offscreen);

blender::gpu::Texture *GPU_offscreen_color_texture(const GPUOffScreen *offscreen);

blender::gpu::TextureFormat GPU_offscreen_format(const GPUOffScreen *offscreen);

void GPU_offscreen_viewport_data_get(GPUOffScreen *offscreen,
                                     blender::gpu::FrameBuffer **r_fb,
                                     blender::gpu::Texture **r_color,
                                     blender::gpu::Texture **r_depth);