Home | History | Annotate | Download | only in mtl 
      1 /*
      2  * Copyright 2017 Google Inc.
      3  *
      4  * Use of this source code is governed by a BSD-style license that can be
      5  * found in the LICENSE file.
      6  */
      7 
      8 #ifndef GrMtlGpu_DEFINED
      9 #define GrMtlGpu_DEFINED
     10 
     11 #include "GrGpu.h"
     12 #include "GrRenderTarget.h"
     13 #include "GrSemaphore.h"
     14 #include "GrTexture.h"
     15 
     16 #include "GrMtlCaps.h"
     17 
     18 #import <Metal/Metal.h>
     19 
     20 class GrSemaphore;
     21 struct GrMtlBackendContext;
     22 
     23 class GrMtlGpu : public GrGpu {
     24 public:
     25     static sk_sp<GrGpu> Make(GrContext* context, const GrContextOptions& options,
     26                              id<MTLDevice> device, id<MTLCommandQueue> queue);
     27 
     28     ~GrMtlGpu() override {}
     29 
     30     const GrMtlCaps& mtlCaps() const { return *fMtlCaps.get(); }
     31 
     32     id<MTLDevice> device() const { return fDevice; }
     33 
     34     bool onGetReadPixelsInfo(GrSurface* srcSurface, GrSurfaceOrigin origin, int readWidth,
     35                              int readHeight, size_t rowBytes, GrColorType readConfig,
     36                              DrawPreference*, ReadPixelTempDrawInfo*) override {
     37         return false;
     38     }
     39 
     40     bool onGetWritePixelsInfo(GrSurface* dstSurface, GrSurfaceOrigin dstOrigin, int width,
     41                               int height, GrColorType srcColorType, DrawPreference*,
     42                               WritePixelTempDrawInfo*) override {
     43         return false;
     44     }
     45 
     46     bool onCopySurface(GrSurface* dst, GrSurfaceOrigin dstOrigin,
     47                        GrSurface* src, GrSurfaceOrigin srcOrigin,
     48                        const SkIRect& srcRect,
     49                        const SkIPoint& dstPoint) override { return false; }
     50 
     51     GrGpuRTCommandBuffer* createCommandBuffer(
     52                                     GrRenderTarget*, GrSurfaceOrigin,
     53                                     const GrGpuRTCommandBuffer::LoadAndStoreInfo&,
     54                                     const GrGpuRTCommandBuffer::StencilLoadAndStoreInfo&) override {
     55         return nullptr;
     56     }
     57 
     58     GrGpuTextureCommandBuffer* createCommandBuffer(GrTexture*, GrSurfaceOrigin) override {
     59         return nullptr;
     60     }
     61 
     62     GrFence SK_WARN_UNUSED_RESULT insertFence() override { return 0; }
     63     bool waitFence(GrFence, uint64_t) override { return true; }
     64     void deleteFence(GrFence) const override {}
     65 
     66     sk_sp<GrSemaphore> SK_WARN_UNUSED_RESULT makeSemaphore(bool isOwned) override {
     67         return nullptr;
     68     }
     69     sk_sp<GrSemaphore> wrapBackendSemaphore(const GrBackendSemaphore& semaphore,
     70                                             GrResourceProvider::SemaphoreWrapType wrapType,
     71                                             GrWrapOwnership ownership) override { return nullptr; }
     72     void insertSemaphore(sk_sp<GrSemaphore> semaphore, bool flush) override {}
     73     void waitSemaphore(sk_sp<GrSemaphore> semaphore) override {}
     74     sk_sp<GrSemaphore> prepareTextureForCrossContextUsage(GrTexture*) override { return nullptr; }
     75 
     76 private:
     77     GrMtlGpu(GrContext* context, const GrContextOptions& options,
     78              id<MTLDevice> device, id<MTLCommandQueue> queue, MTLFeatureSet featureSet);
     79 
     80     void onResetContext(uint32_t resetBits) override {}
     81 
     82     void xferBarrier(GrRenderTarget*, GrXferBarrierType) override {}
     83 
     84     sk_sp<GrTexture> onCreateTexture(const GrSurfaceDesc& desc, SkBudgeted budgeted,
     85                                      const GrMipLevel texels[], int mipLevelCount) override;
     86 
     87     sk_sp<GrTexture> onWrapBackendTexture(const GrBackendTexture&, GrWrapOwnership) override {
     88         return nullptr;
     89     }
     90 
     91     sk_sp<GrTexture> onWrapRenderableBackendTexture(const GrBackendTexture&,
     92                                                     int sampleCnt,
     93                                                     GrWrapOwnership) override {
     94         return nullptr;
     95     }
     96 
     97     sk_sp<GrRenderTarget> onWrapBackendRenderTarget(const GrBackendRenderTarget&) override {
     98         return nullptr;
     99     }
    100 
    101     sk_sp<GrRenderTarget> onWrapBackendTextureAsRenderTarget(const GrBackendTexture&,
    102                                                              int sampleCnt) override {
    103         return nullptr;
    104     }
    105 
    106     GrBuffer* onCreateBuffer(size_t, GrBufferType, GrAccessPattern, const void*) override {
    107         return nullptr;
    108     }
    109 
    110     bool onReadPixels(GrSurface* surface, GrSurfaceOrigin, int left, int top, int width, int height,
    111                       GrColorType, void* buffer, size_t rowBytes) override {
    112         return false;
    113     }
    114 
    115     bool onWritePixels(GrSurface*, GrSurfaceOrigin, int left, int top, int width,
    116                        int height, GrColorType, const GrMipLevel[],
    117                        int) override {
    118         return false;
    119     }
    120 
    121     bool onTransferPixels(GrTexture*,
    122                           int left, int top, int width, int height,
    123                           GrColorType, GrBuffer*,
    124                           size_t offset, size_t rowBytes) override {
    125         return false;
    126     }
    127 
    128     void onResolveRenderTarget(GrRenderTarget* target) override { return; }
    129 
    130     void onFinishFlush(bool insertedSemaphores) override {}
    131 
    132     GrStencilAttachment* createStencilAttachmentForRenderTarget(const GrRenderTarget*,
    133                                                                 int width,
    134                                                                 int height) override {
    135         return nullptr;
    136     }
    137 
    138     void clearStencil(GrRenderTarget* target, int clearValue) override  {}
    139 
    140     GrBackendTexture createTestingOnlyBackendTexture(void* pixels, int w, int h,
    141                                                      GrPixelConfig config, bool isRT,
    142                                                      GrMipMapped) override {
    143         return GrBackendTexture();
    144     }
    145     bool isTestingOnlyBackendTexture(const GrBackendTexture&) const override { return false; }
    146     void deleteTestingOnlyBackendTexture(GrBackendTexture*, bool abandon = false) override {}
    147 
    148     sk_sp<GrMtlCaps> fMtlCaps;
    149 
    150     id<MTLDevice> fDevice;
    151     id<MTLCommandQueue> fQueue;
    152 
    153 
    154     typedef GrGpu INHERITED;
    155 };
    156 
    157 #endif
    158 
    159