GHOST_ContextCGL.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 NSOpenGLContext;
@class NSOpenGLView;
@class NSView;
 
class GHOST_ContextCGL : 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_ContextCGL(bool stereoVisual, NSView *metalView, CAMetalLayer *metalLayer, int debug);
 
  ~GHOST_ContextCGL() override;
 
  GHOST_TSuccess swapBuffers() 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 &intervalOut) 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 *m_metalView;
  CAMetalLayer *m_metalLayer;
  MTLRenderPipelineState *m_metalRenderPipeline;
  bool m_ownsMetalDevice;
 
  static const int METAL_SWAPCHAIN_SIZE = 3;
  struct MTLSwapchainTexture {
    id<MTLTexture> texture;
    unsigned int index;
  };
  MTLSwapchainTexture m_defaultFramebufferMetalTexture[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;
  const bool m_debug;
 
  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(){};
};