GPU_state.hh

Go to the documentation of this file.

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

 
#pragma once
 
#include "BLI_utildefines.h"

struct GPUFence;
 
enum GPUWriteMask {
  GPU_WRITE_NONE = 0,
  GPU_WRITE_RED = (1 << 0),
  GPU_WRITE_GREEN = (1 << 1),
  GPU_WRITE_BLUE = (1 << 2),
  GPU_WRITE_ALPHA = (1 << 3),
  GPU_WRITE_DEPTH = (1 << 4),
  GPU_WRITE_STENCIL = (1 << 5),
  GPU_WRITE_COLOR = (GPU_WRITE_RED | GPU_WRITE_GREEN | GPU_WRITE_BLUE | GPU_WRITE_ALPHA),
};
 
ENUM_OPERATORS(GPUWriteMask, GPU_WRITE_COLOR)
 
enum GPUBarrier {
  /* Texture Barrier. */

  GPU_BARRIER_FRAMEBUFFER = (1 << 0),
  GPU_BARRIER_SHADER_IMAGE_ACCESS = (1 << 1),
  GPU_BARRIER_TEXTURE_FETCH = (1 << 2),
  GPU_BARRIER_TEXTURE_UPDATE = (1 << 3),
  // GPU_BARRIER_PIXEL_BUFFER = (1 << 4), /* Not implemented yet. */
 
  /* Buffer Barrier. */

  GPU_BARRIER_COMMAND = (1 << 10),
  GPU_BARRIER_SHADER_STORAGE = (1 << 11),
  GPU_BARRIER_VERTEX_ATTRIB_ARRAY = (1 << 12),
  GPU_BARRIER_ELEMENT_ARRAY = (1 << 13),
  GPU_BARRIER_UNIFORM = (1 << 14),
  GPU_BARRIER_BUFFER_UPDATE = (1 << 15),
  // GPU_BARRIER_CLIENT_MAPPED_BUFFER = (1 << 15), /* Not implemented yet. */
};
 
ENUM_OPERATORS(GPUBarrier, GPU_BARRIER_BUFFER_UPDATE)
 
/* NOTE: For Metal and Vulkan only.
 * TODO(Metal): Update barrier calls to use stage flags. */
enum GPUStageBarrierBits {
  GPU_BARRIER_STAGE_VERTEX = (1 << 0),
  GPU_BARRIER_STAGE_FRAGMENT = (1 << 1),
  GPU_BARRIER_STAGE_COMPUTE = (1 << 2),
  GPU_BARRIER_STAGE_ANY_GRAPHICS = (GPU_BARRIER_STAGE_VERTEX | GPU_BARRIER_STAGE_FRAGMENT),
  GPU_BARRIER_STAGE_ANY = (GPU_BARRIER_STAGE_VERTEX | GPU_BARRIER_STAGE_FRAGMENT |
                           GPU_BARRIER_STAGE_COMPUTE),
};
 
ENUM_OPERATORS(GPUStageBarrierBits, GPU_BARRIER_STAGE_COMPUTE)
 

enum GPUBlend {
  GPU_BLEND_NONE = 0,
  GPU_BLEND_ALPHA,
  GPU_BLEND_ALPHA_PREMULT,
  GPU_BLEND_ADDITIVE,
  GPU_BLEND_ADDITIVE_PREMULT,
  GPU_BLEND_MULTIPLY,
  GPU_BLEND_SUBTRACT,
  GPU_BLEND_INVERT,
  GPU_BLEND_OIT,
  GPU_BLEND_BACKGROUND,
  GPU_BLEND_CUSTOM,
  GPU_BLEND_ALPHA_UNDER_PREMUL,
  GPU_BLEND_OVERLAY_MASK_FROM_ALPHA,
};
 
enum GPUDepthTest {
  GPU_DEPTH_NONE = 0,
  GPU_DEPTH_ALWAYS, /* Used to draw to the depth buffer without really testing. */
  GPU_DEPTH_LESS,
  GPU_DEPTH_LESS_EQUAL, /* Default. */
  GPU_DEPTH_EQUAL,
  GPU_DEPTH_GREATER,
  GPU_DEPTH_GREATER_EQUAL,
};
 
enum GPUStencilTest {
  GPU_STENCIL_NONE = 0,
  GPU_STENCIL_ALWAYS,
  GPU_STENCIL_EQUAL,
  GPU_STENCIL_NEQUAL,
};
 
enum GPUStencilOp {
  GPU_STENCIL_OP_NONE = 0,
  GPU_STENCIL_OP_REPLACE,
  GPU_STENCIL_OP_COUNT_DEPTH_PASS,
  GPU_STENCIL_OP_COUNT_DEPTH_FAIL,
};
 
enum GPUFaceCullTest {
  GPU_CULL_NONE = 0, /* Culling disabled. */
  GPU_CULL_FRONT,
  GPU_CULL_BACK,
};
 
enum GPUProvokingVertex {
  GPU_VERTEX_LAST = 0,  /* Default. */
  GPU_VERTEX_FIRST = 1, /* Follow Blender loop order. */
};
 
void GPU_blend(GPUBlend blend);
void GPU_face_culling(GPUFaceCullTest culling);
void GPU_depth_test(GPUDepthTest test);
void GPU_stencil_test(GPUStencilTest test);
void GPU_provoking_vertex(GPUProvokingVertex vert);
void GPU_front_facing(bool invert);
void GPU_depth_range(float near, float far);
void GPU_scissor_test(bool enable);
void GPU_line_smooth(bool enable);
void GPU_line_width(float width);
void GPU_logic_op_xor_set(bool enable);
void GPU_point_size(float size);
void GPU_polygon_smooth(bool enable);

void GPU_program_point_size(bool enable);
void GPU_scissor(int x, int y, int width, int height);
void GPU_scissor_get(int coords[4]);
void GPU_viewport(int x, int y, int width, int height);
void GPU_viewport_size_get_f(float coords[4]);
void GPU_viewport_size_get_i(int coords[4]);
void GPU_write_mask(GPUWriteMask mask);
void GPU_color_mask(bool r, bool g, bool b, bool a);
void GPU_depth_mask(bool depth);
bool GPU_depth_mask_get();
void GPU_shadow_offset(bool enable);
void GPU_clip_distances(int distances_enabled);
bool GPU_mipmap_enabled();
void GPU_state_set(GPUWriteMask write_mask,
                   GPUBlend blend,
                   GPUFaceCullTest culling_test,
                   GPUDepthTest depth_test,
                   GPUStencilTest stencil_test,
                   GPUStencilOp stencil_op,
                   GPUProvokingVertex provoking_vert);
 
void GPU_stencil_reference_set(uint reference);
void GPU_stencil_write_mask_set(uint write_mask);
void GPU_stencil_compare_mask_set(uint compare_mask);
 
/* Sets the depth range to be 0..1. Only have effect with the OpenGL backend. Have no effect if
 * glClipControl is not supported. Shaders used for drawing with this state must use
 * BuiltinBits::CLIP_CONTROL for their vertex shader to be patched. */
void GPU_clip_control_unit_range(bool enable);
 
GPUFaceCullTest GPU_face_culling_get();
GPUBlend GPU_blend_get();
GPUDepthTest GPU_depth_test_get();
GPUWriteMask GPU_write_mask_get();
uint GPU_stencil_mask_get();
GPUStencilTest GPU_stencil_test_get();
float GPU_line_width_get();
bool GPU_line_smooth_get();
 
void GPU_flush();
void GPU_finish();
void GPU_apply_state();

void GPU_memory_barrier(GPUBarrier barrier);
 
GPUFence *GPU_fence_create();
void GPU_fence_free(GPUFence *fence);
void GPU_fence_signal(GPUFence *fence);
void GPU_fence_wait(GPUFence *fence);