Page MenuHome
Differential D15953 Diff 56012 source/blender/gpu/metal/mtl_immediate.mm

Changeset View

Standalone View

View Options

source/blender/gpu/metal/mtl_immediate.mm

  • This file was added.
/* SPDX-License-Identifier: GPL-2.0-or-later */
/** \file
* \ingroup gpu
*
* Mimics old style opengl immediate mode drawing.
*/
#include "BKE_global.h"
#include "GPU_vertex_format.h"
#include "gpu_context_private.hh"
#include "gpu_shader_private.hh"
#include "gpu_vertex_format_private.h"
#include "mtl_context.hh"
#include "mtl_debug.hh"
#include "mtl_immediate.hh"
#include "mtl_primitive.hh"
#include "mtl_shader.hh"
namespace blender::gpu {
MTLImmediate::MTLImmediate(MTLContext *ctx)
{
context_ = ctx;
}
MTLImmediate::~MTLImmediate()
{
}
uchar *MTLImmediate::begin()
{
BLI_assert(!has_begun_);
/* Determine primitive type. */
metal_primitive_type_ = gpu_prim_type_to_metal(this->prim_type);
metal_primitive_mode_ = mtl_prim_type_to_topology_class(metal_primitive_type_);
has_begun_ = true;
/* Allocate a range of data and return host-accessible pointer. */
const size_t bytes_needed = vertex_buffer_size(&vertex_format, vertex_len);
current_allocation_ = context_->get_scratchbuffer_manager()
.scratch_buffer_allocate_range_aligned(bytes_needed, 256);
[current_allocation_.metal_buffer retain];
return reinterpret_cast<uchar *>(current_allocation_.data);
}
void MTLImmediate::end()
{
/* Ensure we're between a imm::begin/imm:end pair. */
BLI_assert(has_begun_);
BLI_assert(prim_type != GPU_PRIM_NONE);
/* Verify context is valid, vertex data is written and a valid shader is bound. */
if (context_ && this->vertex_idx > 0 && this->shader) {
MTLShader *active_mtl_shader = static_cast<MTLShader *>(unwrap(shader));
/* Skip draw if Metal shader is not valid. */
if (active_mtl_shader == nullptr || !active_mtl_shader->is_valid() ||
active_mtl_shader->get_interface() == nullptr) {
const char *ptr = (active_mtl_shader) ? active_mtl_shader->name_get() : nullptr;
MTL_LOG_WARNING(
"MTLImmediate::end -- cannot perform draw as active shader is NULL or invalid (likely "
"unimplemented) (shader %p '%s')\n",
active_mtl_shader,
ptr);
return;
}
/* Ensure we are inside a render pass and fetch active RenderCommandEncoder. */
id<MTLRenderCommandEncoder> rec = context_->ensure_begin_render_pass();
BLI_assert(rec != nil);
/* Fetch active render pipeline state. */
MTLRenderPassState &rps = context_->main_command_buffer.get_render_pass_state();
/* Bind Shader. */
GPU_shader_bind(this->shader);
/* Debug markers for frame-capture and detailed error messages. */
if (G.debug & G_DEBUG_GPU) {
[rec pushDebugGroup:[NSString
stringWithFormat:@"immEnd(verts: %d, shader: %s)",
this->vertex_idx,
active_mtl_shader->get_interface()->get_name()]];
[rec insertDebugSignpost:[NSString stringWithFormat:@"immEnd(verts: %d, shader: %s)",
this->vertex_idx,
active_mtl_shader->get_interface()
->get_name()]];
}
/* Populate pipeline state vertex descriptor. */
MTLStateManager *state_manager = static_cast<MTLStateManager *>(
MTLContext::get()->state_manager);
MTLRenderPipelineStateDescriptor &desc = state_manager->get_pipeline_descriptor();
const MTLShaderInterface *interface = active_mtl_shader->get_interface();
desc.vertex_descriptor.num_attributes = interface->get_total_attributes();
desc.vertex_descriptor.num_vert_buffers = 1;
for (int i = 0; i < desc.vertex_descriptor.num_attributes; i++) {
desc.vertex_descriptor.attributes[i].format = MTLVertexFormatInvalid;
}
desc.vertex_descriptor.uses_ssbo_vertex_fetch =
active_mtl_shader->get_uses_ssbo_vertex_fetch();
desc.vertex_descriptor.num_ssbo_attributes = 0;
/* SSBO Vertex Fetch -- Verify Attributes. */
if (active_mtl_shader->get_uses_ssbo_vertex_fetch()) {
active_mtl_shader->ssbo_vertex_fetch_bind_attributes_begin();
/* Disable Indexed rendering in SSBO vertex fetch. */
int uniform_ssbo_use_indexed = active_mtl_shader->uni_ssbo_uses_indexed_rendering;
BLI_assert_msg(uniform_ssbo_use_indexed != -1, "Expected valid uniform location for ssbo_uses_indexed_rendering.");
int uses_indexed_rendering = 0;
active_mtl_shader->uniform_int(uniform_ssbo_use_indexed, 1, 1, &uses_indexed_rendering);
}
/* Populate Vertex descriptor and verify attributes.
* TODO(Metal): Cache this vertex state based on Vertex format and shaders. */
for (int i = 0; i < interface->get_total_attributes(); i++) {
/* Note: Attribute in VERTEX FORMAT does not necessarily share the same array index as
* attributes in shader interface. */
GPUVertAttr *attr = nullptr;
const MTLShaderInputAttribute &mtl_shader_attribute = interface->get_attribute(i);
/* Scan through vertex_format attributes until one with a name matching the shader interface
* is found. */
for (uint32_t a_idx = 0; a_idx < this->vertex_format.attr_len && attr == nullptr; a_idx++) {
GPUVertAttr *check_attribute = &this->vertex_format.attrs[a_idx];
/* Attributes can have multiple name aliases associated with them. */
for (uint32_t n_idx = 0; n_idx < check_attribute->name_len; n_idx++) {
const char *name = GPU_vertformat_attr_name_get(
&this->vertex_format, check_attribute, n_idx);
if (strcmp(name, interface->get_name_at_offset(mtl_shader_attribute.name_offset)) == 0) {
attr = check_attribute;
break;
}
}
}
BLI_assert_msg(attr != nullptr,
"Could not find expected attribute in immediate mode vertex format.");
if (attr == nullptr) {
MTL_LOG_ERROR(
"MTLImmediate::end Could not find matching attribute '%s' from Shader Interface in "
"Vertex Format! - TODO: Bind Dummy attribute\n",
interface->get_name_at_offset(mtl_shader_attribute.name_offset));
return;
}
/* Determine whether implicit type conversion between input vertex format
* and shader interface vertex format is supported. */
MTLVertexFormat convertedFormat;
bool can_use_implicit_conversion = mtl_convert_vertex_format(
mtl_shader_attribute.format,
(GPUVertCompType)attr->comp_type,
attr->comp_len,
(GPUVertFetchMode)attr->fetch_mode,
&convertedFormat);
if (can_use_implicit_conversion) {
/* Metal API can implicitly convert some formats during vertex assembly:
* - Converting from a normalized short2 format to float2
* - Type truncation e.g. Float4 to Float2.
* - Type expansion from Float3 to Float4.
* - Note: extra components are filled with the corresponding components of (0,0,0,1).
* (See
* https://developer.apple.com/documentation/metal/mtlvertexattributedescriptor/1516081-format)
*/
bool is_floating_point_format = (attr->comp_type == GPU_COMP_F32);
desc.vertex_descriptor.attributes[i].format = convertedFormat;
desc.vertex_descriptor.attributes[i].format_conversion_mode =
(is_floating_point_format) ? (GPUVertFetchMode)GPU_FETCH_FLOAT :
(GPUVertFetchMode)GPU_FETCH_INT;
BLI_assert(convertedFormat != MTLVertexFormatInvalid);
}
else {
/* Some conversions are NOT valid, e.g. Int4 to Float4
* - In this case, we need to implement a conversion routine inside the shader.
* - This is handled using the format_conversion_mode flag
* - This flag is passed into the PSO as a function specialisation,
* and will generate an appropriate conversion function when reading the vertex attribute
* value into local shader storage.
* (If no explicit conversion is needed, the function specialize to a pass-through). */
MTLVertexFormat converted_format;
bool can_convert = mtl_vertex_format_resize(
mtl_shader_attribute.format, attr->comp_len, &converted_format);
desc.vertex_descriptor.attributes[i].format = (can_convert) ? converted_format :
mtl_shader_attribute.format;
desc.vertex_descriptor.attributes[i].format_conversion_mode = (GPUVertFetchMode)
attr->fetch_mode;
BLI_assert(desc.vertex_descriptor.attributes[i].format != MTLVertexFormatInvalid);
}
/* Using attribute offset in vertex format, as this will be correct */
desc.vertex_descriptor.attributes[i].offset = attr->offset;
desc.vertex_descriptor.attributes[i].buffer_index = mtl_shader_attribute.buffer_index;
/* SSBO Vertex Fetch Attribute bind. */
if (active_mtl_shader->get_uses_ssbo_vertex_fetch()) {
BLI_assert_msg(mtl_shader_attribute.buffer_index == 0,
"All attributes should be in buffer index zero");
MTLSSBOAttribute ssbo_attr(
mtl_shader_attribute.index,
mtl_shader_attribute.buffer_index,
attr->offset,
this->vertex_format.stride,
MTLShader::ssbo_vertex_type_to_attr_type(desc.vertex_descriptor.attributes[i].format),
false);
desc.vertex_descriptor.ssbo_attributes[desc.vertex_descriptor.num_ssbo_attributes] =
ssbo_attr;
desc.vertex_descriptor.num_ssbo_attributes++;
active_mtl_shader->ssbo_vertex_fetch_bind_attribute(ssbo_attr);
}
}
/* Buffer bindings for singular vertex buffer. */
desc.vertex_descriptor.buffer_layouts[0].step_function = MTLVertexStepFunctionPerVertex;
desc.vertex_descriptor.buffer_layouts[0].step_rate = 1;
desc.vertex_descriptor.buffer_layouts[0].stride = this->vertex_format.stride;
BLI_assert(this->vertex_format.stride > 0);
/* SSBO Vertex Fetch -- Verify Attributes. */
if (active_mtl_shader->get_uses_ssbo_vertex_fetch()) {
active_mtl_shader->ssbo_vertex_fetch_bind_attributes_end(rec);
/* Set Status uniforms. */
BLI_assert_msg(active_mtl_shader->uni_ssbo_input_prim_type_loc != -1,
"ssbo_input_prim_type uniform location invalid!");
BLI_assert_msg(active_mtl_shader->uni_ssbo_input_vert_count_loc != -1,
"ssbo_input_vert_count uniform location invalid!");
GPU_shader_uniform_vector_int(reinterpret_cast<GPUShader *>(wrap(active_mtl_shader)),
active_mtl_shader->uni_ssbo_input_prim_type_loc,
1,
1,
(const int *)(&this->prim_type));
GPU_shader_uniform_vector_int(reinterpret_cast<GPUShader *>(wrap(active_mtl_shader)),
active_mtl_shader->uni_ssbo_input_vert_count_loc,
1,
1,
(const int *)(&this->vertex_idx));
}
MTLPrimitiveType mtl_prim_type = gpu_prim_type_to_metal(this->prim_type);
if (context_->ensure_render_pipeline_state(mtl_prim_type)) {
/* Issue draw call. */
BLI_assert(this->vertex_idx > 0);
/* Metal API does not support triangle fan, so we can emulate this
* input data by generating an index buffer to re-map indices to
* a TriangleList.
*
* NOTE(Metal): Consider caching generated triangle fan index buffers.
* For immediate mode, generating these is currently very cheap, as we use
* fast scratch buffer allocations. Though we may benefit from caching of
* frequently used buffer sizes. */
if (mtl_needs_topology_emulation(this->prim_type)) {
/* Debug safety check for SSBO FETCH MODE. */
if (active_mtl_shader->get_uses_ssbo_vertex_fetch()) {
BLI_assert(false && "Topology emulation not supported with SSBO Vertex Fetch mode");
}
/* Emulate Tri-fan. */
if (this->prim_type == GPU_PRIM_TRI_FAN) {
/* Prepare Triangle-Fan emulation index buffer on CPU based on number of input
* vertices. */
uint32_t base_vert_count = this->vertex_idx;
uint32_t num_triangles = max_ii(base_vert_count - 2, 0);
uint32_t fan_index_count = num_triangles * 3;
BLI_assert(num_triangles > 0);
uint32_t alloc_size = sizeof(uint32_t) * fan_index_count;
uint32_t *index_buffer = nullptr;
MTLTemporaryBuffer allocation =
context_->get_scratchbuffer_manager().scratch_buffer_allocate_range_aligned(
alloc_size, 128);
index_buffer = (uint32_t *)allocation.data;
int a = 0;
for (int i = 0; i < num_triangles; i++) {
index_buffer[a++] = 0;
index_buffer[a++] = i + 1;
index_buffer[a++] = i + 2;
}
@autoreleasepool {
id<MTLBuffer> index_buffer_mtl = nil;
uint32_t index_buffer_offset = 0;
/* Region of scratch buffer used for topology emulation element data.
* NOTE(Metal): We do not need to manually flush as the entire scratch
* buffer for current command buffer is flushed upon submission. */
index_buffer_mtl = allocation.metal_buffer;
index_buffer_offset = allocation.buffer_offset;
/* Set depth stencil state (requires knowledge of primitive type). */
context_->ensure_depth_stencil_state(MTLPrimitiveTypeTriangle);
/* Bind Vertex Buffer. */
rps.bind_vertex_buffer(
current_allocation_.metal_buffer, current_allocation_.buffer_offset, 0);
/* Draw. */
[rec drawIndexedPrimitives:MTLPrimitiveTypeTriangle
indexCount:fan_index_count
indexType:MTLIndexTypeUInt32
indexBuffer:index_buffer_mtl
indexBufferOffset:index_buffer_offset];
}
}
else {
/* TODO(Metal): Topology emulation for line loop.
* NOTE(Metal): This is currently not used anywhere and modified at the high
* level for efficiency in such cases. */
BLI_assert_msg(false, "LineLoop requires emulation support in immediate mode.");
}
}
else {
MTLPrimitiveType primitive_type = metal_primitive_type_;
int vertex_count = this->vertex_idx;
/* Bind Vertex Buffer. */
rps.bind_vertex_buffer(
current_allocation_.metal_buffer, current_allocation_.buffer_offset, 0);
/* Set depth stencil state (requires knowledge of primitive type). */
context_->ensure_depth_stencil_state(primitive_type);
if (active_mtl_shader->get_uses_ssbo_vertex_fetch()) {
/* Bind Null Buffers for empty/missing bind slots. */
id<MTLBuffer> null_buffer = context_->get_null_buffer();
BLI_assert(null_buffer != nil);
for (int i = 1; i < MTL_SSBO_VERTEX_FETCH_MAX_VBOS; i++) {
/* We only need to ensure a buffer is bound to the context, its contents do not matter
* as it will not be used. */
if (rps.cached_vertex_buffer_bindings[i].metal_buffer == nil) {
rps.bind_vertex_buffer(null_buffer, 0, i);
}
}
/* SSBO vertex fetch - Nullify elements buffer. */
if (rps.cached_vertex_buffer_bindings[MTL_SSBO_VERTEX_FETCH_IBO_INDEX].metal_buffer ==
nil) {
rps.bind_vertex_buffer(null_buffer, 0, MTL_SSBO_VERTEX_FETCH_IBO_INDEX);
}
/* Submit draw call with modified vertex count, which reflects vertices per primitive
* defined in the USE_SSBO_VERTEX_FETCH pragma. */
int num_input_primitives = gpu_get_prim_count_from_type(vertex_count, this->prim_type);
int output_num_verts = num_input_primitives *
active_mtl_shader->get_ssbo_vertex_fetch_output_num_verts();
#ifndef NDEBUG
BLI_assert(
mtl_vertex_count_fits_primitive_type(
output_num_verts, active_mtl_shader->get_ssbo_vertex_fetch_output_prim_type()) &&
"Output Vertex count is not compatible with the requested output vertex primitive "
"type");
#endif
[rec drawPrimitives:active_mtl_shader->get_ssbo_vertex_fetch_output_prim_type()
vertexStart:0
vertexCount:output_num_verts];
context_->main_command_buffer.register_draw_counters(output_num_verts);
}
else {
/* Regular draw. */
[rec drawPrimitives:primitive_type vertexStart:0 vertexCount:vertex_count];
context_->main_command_buffer.register_draw_counters(vertex_count);
}
}
}
if (G.debug & G_DEBUG_GPU) {
[rec popDebugGroup];
}
}
/* Reset allocation after draw submission. */
has_begun_ = false;
if (current_allocation_.metal_buffer) {
[current_allocation_.metal_buffer release];
current_allocation_.metal_buffer = nil;
}
}
} // blender::gpu