GPU_batch.hh

Go to the documentation of this file.

/* SPDX-FileCopyrightText: 2016 by Mike Erwin. All rights reserved.
 *
 * SPDX-License-Identifier: GPL-2.0-or-later */
 
#pragma once
 
#include "BLI_index_range.hh"
#include "BLI_utildefines.h"
 
#include "GPU_index_buffer.hh"
#include "GPU_shader.hh"
#include "GPU_storage_buffer.hh"
#include "GPU_uniform_buffer.hh"
#include "GPU_vertex_buffer.hh"
 
struct GPUShader;
 
#define GPU_BATCH_VBO_MAX_LEN 16
#define GPU_BATCH_INST_VBO_MAX_LEN 2
#define GPU_BATCH_VAO_STATIC_LEN 3
#define GPU_BATCH_VAO_DYN_ALLOC_COUNT 16
 
enum eGPUBatchFlag {
  GPU_BATCH_INVALID = 0,
 
  GPU_BATCH_OWNS_VBO = (1 << 0),
  GPU_BATCH_OWNS_VBO_MAX = (GPU_BATCH_OWNS_VBO << (GPU_BATCH_VBO_MAX_LEN - 1)),
  GPU_BATCH_OWNS_VBO_ANY = ((GPU_BATCH_OWNS_VBO << GPU_BATCH_VBO_MAX_LEN) - 1),
  GPU_BATCH_OWNS_INST_VBO = (GPU_BATCH_OWNS_VBO_MAX << 1),
  GPU_BATCH_OWNS_INST_VBO_MAX = (GPU_BATCH_OWNS_INST_VBO << (GPU_BATCH_INST_VBO_MAX_LEN - 1)),
  GPU_BATCH_OWNS_INST_VBO_ANY = ((GPU_BATCH_OWNS_INST_VBO << GPU_BATCH_INST_VBO_MAX_LEN) - 1) &
                                ~GPU_BATCH_OWNS_VBO_ANY,
  GPU_BATCH_OWNS_INDEX = (GPU_BATCH_OWNS_INST_VBO_MAX << 1),
 
  GPU_BATCH_INIT = (1 << 26),
  GPU_BATCH_BUILDING = (1 << 26),
  GPU_BATCH_DIRTY = (1 << 27),
};
 
#define GPU_BATCH_OWNS_NONE GPU_BATCH_INVALID
 
BLI_STATIC_ASSERT(GPU_BATCH_OWNS_INDEX < GPU_BATCH_INIT,
                  "eGPUBatchFlag: Error: status flags are shadowed by the ownership bits!")
 
ENUM_OPERATORS(eGPUBatchFlag, GPU_BATCH_DIRTY)
 
namespace blender::gpu {
 
class Batch {
 public:
  blender::gpu::VertBuf *verts[GPU_BATCH_VBO_MAX_LEN];
  blender::gpu::VertBuf *inst[GPU_BATCH_INST_VBO_MAX_LEN];
  blender::gpu::IndexBuf *elem;
  GPUStorageBuf *resource_id_buf;
  eGPUBatchFlag flag;
  GPUPrimType prim_type;
  GPUShader *shader;
 
  virtual ~Batch() = default;
 
  virtual void draw(int v_first, int v_count, int i_first, int i_count) = 0;
  virtual void draw_indirect(GPUStorageBuf *indirect_buf, intptr_t offset) = 0;
  virtual void multi_draw_indirect(GPUStorageBuf *indirect_buf,
                                   int count,
                                   intptr_t offset,
                                   intptr_t stride) = 0;
 
  uint32_t vertex_count_get() const
  {
    if (elem) {
      return elem_()->index_len_get();
    }
    return verts_(0)->vertex_len;
  }
 
  /* Convenience casts. */
  IndexBuf *elem_() const
  {
    return elem;
  }
  VertBuf *verts_(const int index) const
  {
    return verts[index];
  }
  VertBuf *inst_(const int index) const
  {
    return inst[index];
  }
};
 
}  // namespace blender::gpu
 
/* -------------------------------------------------------------------- */
blender::gpu::Batch *GPU_batch_calloc();
 
blender::gpu::Batch *GPU_batch_create_ex(GPUPrimType primitive_type,
                                         blender::gpu::VertBuf *vertex_buf,
                                         blender::gpu::IndexBuf *index_buf,
                                         eGPUBatchFlag owns_flag);
#define GPU_batch_create(primitive_type, vertex_buf, index_buf) \
  GPU_batch_create_ex(primitive_type, vertex_buf, index_buf, (eGPUBatchFlag)0)
 
void GPU_batch_init_ex(blender::gpu::Batch *batch,
                       GPUPrimType primitive_type,
                       blender::gpu::VertBuf *vertex_buf,
                       blender::gpu::IndexBuf *index_buf,
                       eGPUBatchFlag owns_flag);
#define GPU_batch_init(batch, primitive_type, vertex_buf, index_buf) \
  GPU_batch_init_ex(batch, primitive_type, vertex_buf, index_buf, (eGPUBatchFlag)0)
 
void GPU_batch_copy(blender::gpu::Batch *batch_dst, blender::gpu::Batch *batch_src);
 
/* -------------------------------------------------------------------- */
void GPU_batch_clear(blender::gpu::Batch *batch);
 
void GPU_batch_zero(blender::gpu::Batch *batch);
 
#define GPU_BATCH_CLEAR_SAFE(batch) \
  do { \
    if (batch != nullptr) { \
      GPU_batch_clear(batch); \
      GPU_batch_zero(batch); \
    } \
  } while (0)
 
void GPU_batch_discard(blender::gpu::Batch *batch);
 
#define GPU_BATCH_DISCARD_SAFE(batch) \
  do { \
    if (batch != nullptr) { \
      GPU_batch_discard(batch); \
      batch = nullptr; \
    } \
  } while (0)
 
/* -------------------------------------------------------------------- */
int GPU_batch_vertbuf_add(blender::gpu::Batch *batch,
                          blender::gpu::VertBuf *vertex_buf,
                          bool own_vbo);
 
int GPU_batch_instbuf_add(blender::gpu::Batch *batch,
                          blender::gpu::VertBuf *vertex_buf,
                          bool own_vbo);
 
void GPU_batch_instbuf_set(blender::gpu::Batch *batch,
                           blender::gpu::VertBuf *vertex_buf,
                           bool own_vbo);
 
void GPU_batch_elembuf_set(blender::gpu::Batch *batch,
                           blender::gpu::IndexBuf *index_buf,
                           bool own_ibo);
 
bool GPU_batch_vertbuf_has(const blender::gpu::Batch *batch,
                           const blender::gpu::VertBuf *vertex_buf);
 
void GPU_batch_resource_id_buf_set(blender::gpu::Batch *batch, GPUStorageBuf *resource_id_buf);
 
/* -------------------------------------------------------------------- */
/* TODO(fclem): These should be removed and replaced by `GPU_shader_bind()`. */
void GPU_batch_set_shader(blender::gpu::Batch *batch, GPUShader *shader);
void GPU_batch_program_set_builtin(blender::gpu::Batch *batch, eGPUBuiltinShader shader_id);
void GPU_batch_program_set_builtin_with_config(blender::gpu::Batch *batch,
                                               eGPUBuiltinShader shader_id,
                                               eGPUShaderConfig sh_cfg);
void GPU_batch_program_set_imm_shader(blender::gpu::Batch *batch);
 
/* TODO(fclem): These need to be replaced by GPU_shader_uniform_* with explicit shader. */
#define GPU_batch_uniform_1i(batch, name, x) GPU_shader_uniform_1i((batch)->shader, name, x);
#define GPU_batch_uniform_1b(batch, name, x) GPU_shader_uniform_1b((batch)->shader, name, x);
#define GPU_batch_uniform_1f(batch, name, x) GPU_shader_uniform_1f((batch)->shader, name, x);
#define GPU_batch_uniform_2f(batch, name, x, y) GPU_shader_uniform_2f((batch)->shader, name, x, y);
#define GPU_batch_uniform_3f(batch, name, x, y, z) \
  GPU_shader_uniform_3f((batch)->shader, name, x, y, z);
#define GPU_batch_uniform_4f(batch, name, x, y, z, w) \
  GPU_shader_uniform_4f((batch)->shader, name, x, y, z, w);
#define GPU_batch_uniform_2fv(batch, name, val) GPU_shader_uniform_2fv((batch)->shader, name, val);
#define GPU_batch_uniform_3fv(batch, name, val) GPU_shader_uniform_3fv((batch)->shader, name, val);
#define GPU_batch_uniform_4fv(batch, name, val) GPU_shader_uniform_4fv((batch)->shader, name, val);
#define GPU_batch_uniform_2fv_array(batch, name, len, val) \
  GPU_shader_uniform_2fv_array((batch)->shader, name, len, val);
#define GPU_batch_uniform_4fv_array(batch, name, len, val) \
  GPU_shader_uniform_4fv_array((batch)->shader, name, len, val);
#define GPU_batch_uniform_mat4(batch, name, val) \
  GPU_shader_uniform_mat4((batch)->shader, name, val);
#define GPU_batch_uniformbuf_bind(batch, name, ubo) \
  GPU_uniformbuf_bind(ubo, GPU_shader_get_ubo_binding((batch)->shader, name));
#define GPU_batch_texture_bind(batch, name, tex) \
  GPU_texture_bind(tex, GPU_shader_get_sampler_binding((batch)->shader, name));
 
void GPU_batch_bind_as_resources(blender::gpu::Batch *batch, GPUShader *shader);
 
/* -------------------------------------------------------------------- */
void GPU_batch_draw(blender::gpu::Batch *batch);
 
void GPU_batch_draw_range(blender::gpu::Batch *batch, int vertex_first, int vertex_count);
 
void GPU_batch_draw_instance_range(blender::gpu::Batch *batch,
                                   int instance_first,
                                   int instance_count);
 
void GPU_batch_draw_advanced(blender::gpu::Batch *batch,
                             int vertex_first,
                             int vertex_count,
                             int instance_first,
                             int instance_count);
 
void GPU_batch_draw_indirect(blender::gpu::Batch *batch,
                             GPUStorageBuf *indirect_buf,
                             intptr_t offset);
 
void GPU_batch_multi_draw_indirect(blender::gpu::Batch *batch,
                                   GPUStorageBuf *indirect_buf,
                                   int count,
                                   intptr_t offset,
                                   intptr_t stride);
 
void GPU_batch_draw_parameter_get(blender::gpu::Batch *batch,
                                  int *r_vertex_count,
                                  int *r_vertex_first,
                                  int *r_base_index,
                                  int *r_instance_count);
 
blender::IndexRange GPU_batch_draw_expanded_parameter_get(const blender::gpu::Batch *batch,
                                                          GPUPrimType expanded_prim_type,
                                                          int vertex_count,
                                                          int vertex_first);
 
/* -------------------------------------------------------------------- */
void gpu_batch_init();
void gpu_batch_exit();