GHOST_ContextMTL.hh

Go to the documentation of this file.

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

 
#pragma once
 
#include "GHOST_Context.hh"
 
#include <Cocoa/Cocoa.h>
#include <Metal/Metal.h>
#include <QuartzCore/QuartzCore.h>
 
@class CAMetalLayer;
@class MTLCommandQueue;
@class MTLDevice;
@class MTLRenderPipelineState;
@class MTLTexture;
@class NSView;
 
class GHOST_ContextMTL : public GHOST_Context {
 public:
  /* Defines the number of simultaneous command buffers which can be in flight.
   * The default limit of `64` is considered to be optimal for Blender. Too many command buffers
   * will result in workload fragmentation and additional system-level overhead. This limit should
   * also only be increased if the application is consistently exceeding the limit, and there are
   * no command buffer leaks.
   *
   * If this limit is reached, starting a new command buffer will fail. The Metal back-end will
   * therefore stall until completion and log a warning when this limit is reached in order to
   * ensure correct function of the app.
   *
   * It is generally preferable to reduce the prevalence of GPU_flush or GPU Context switches
   * (which will both break command submissions), rather than increasing this limit. */
  static const int max_command_buffer_count = 64;
 
 public:
  GHOST_ContextMTL(const GHOST_ContextParams &context_params,
                   NSView *metalView,
                   CAMetalLayer *metalLayer);

  ~GHOST_ContextMTL() override;

  GHOST_TSuccess swapBufferAcquire() override
  {
    return GHOST_kSuccess;
  }

  GHOST_TSuccess swapBufferRelease() override;

  GHOST_TSuccess activateDrawingContext() override;

  GHOST_TSuccess releaseDrawingContext() override;
 
  unsigned int getDefaultFramebuffer() override;

  GHOST_TSuccess initializeDrawingContext() override;

  GHOST_TSuccess releaseNativeHandles() override;

  GHOST_TSuccess setSwapInterval(int interval) override;

  GHOST_TSuccess getSwapInterval(int &interval_out) override;

  GHOST_TSuccess updateDrawingContext() override;

  id<MTLTexture> metalOverlayTexture();

  MTLCommandQueue *metalCommandQueue();

  MTLDevice *metalDevice();

  void metalRegisterPresentCallback(void (*callback)(
      MTLRenderPassDescriptor *, id<MTLRenderPipelineState>, id<MTLTexture>, id<CAMetalDrawable>));
 
 private:
  NSView *metal_view_;
  CAMetalLayer *metal_layer_;
  MTLRenderPipelineState *metal_render_pipeline_;
  bool owns_metal_device_;

  static const int METAL_SWAPCHAIN_SIZE = 3;
  struct MTLSwapchainTexture {
    id<MTLTexture> texture;
    unsigned int index;
  };
  MTLSwapchainTexture default_framebuffer_metal_texture_[METAL_SWAPCHAIN_SIZE];
  unsigned int current_swapchain_index = 0;
 
  /* Present callback.
   * We use this such that presentation can be controlled from within the Metal
   * Context. This is required for optimal performance and clean control flow.
   * Also helps ensure flickering does not occur by present being dependent
   * on existing submissions. */
  void (*contextPresentCallback)(MTLRenderPassDescriptor *,
                                 id<MTLRenderPipelineState>,
                                 id<MTLTexture>,
                                 id<CAMetalDrawable>);
 
  int mtl_SwapInterval;
 
  static int s_sharedCount;
 
  /* Single device queue for multiple contexts. */
  static MTLCommandQueue *s_sharedMetalCommandQueue;
 
  /* Metal functions */
  void metalInit();
  void metalFree();
  void metalInitFramebuffer();
  void metalUpdateFramebuffer();
  void metalSwapBuffers();
  void initClear() {};
};