Home | History | Annotate | Download | only in ddl 
      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 GrDDLGpu_DEFINED
      9 #define GrDDLGpu_DEFINED
     10 
     11 #include "GrGpu.h"
     12 
     13 #include "GrRenderTarget.h"
     14 #include "GrSemaphore.h"
     15 #include "GrTexture.h"
     16 
     17 class GrDDLGpu : public GrGpu {
     18 public:
     19     static sk_sp<GrGpu> Make(GrContext*, sk_sp<const GrCaps>);
     20 
     21     ~GrDDLGpu() override {}
     22 
     23     bool onGetReadPixelsInfo(GrSurface* srcSurface, GrSurfaceOrigin srcOrigin,
     24                              int readWidth, int readHeight, size_t rowBytes,
     25                              GrPixelConfig readConfig, DrawPreference*,
     26                              ReadPixelTempDrawInfo*) override {
     27         SkASSERT(0);
     28         return true;
     29     }
     30 
     31     bool onGetWritePixelsInfo(GrSurface* dstSurface, GrSurfaceOrigin dstOrigin,
     32                               int width, int height,
     33                               GrPixelConfig srcConfig, DrawPreference*,
     34                               WritePixelTempDrawInfo*) override {
     35         SkASSERT(0);
     36         return true;
     37     }
     38 
     39     bool onCopySurface(GrSurface* dst, GrSurfaceOrigin dstOrigin,
     40                        GrSurface* src, GrSurfaceOrigin srcOrigin,
     41                        const SkIRect& srcRect, const SkIPoint& dstPoint,
     42                        bool canDiscardOutsideDstRect) override {
     43         SkASSERT(0);
     44         return true;
     45     }
     46 
     47     void onQueryMultisampleSpecs(GrRenderTarget* rt, GrSurfaceOrigin, const GrStencilSettings&,
     48                                  int* effectiveSampleCnt, SamplePattern*) override {
     49         SkASSERT(0);
     50         *effectiveSampleCnt = 1;  // ??
     51     }
     52 
     53     GrGpuRTCommandBuffer* createCommandBuffer(
     54                                     GrRenderTarget*, GrSurfaceOrigin,
     55                                     const GrGpuRTCommandBuffer::LoadAndStoreInfo&,
     56                                     const GrGpuRTCommandBuffer::StencilLoadAndStoreInfo&) override;
     57 
     58     GrGpuTextureCommandBuffer* createCommandBuffer(GrTexture*, GrSurfaceOrigin) override;
     59 
     60     GrFence SK_WARN_UNUSED_RESULT insertFence() override {
     61         SkASSERT(0);
     62         return 0;
     63     }
     64     bool waitFence(GrFence, uint64_t) override {
     65         SkASSERT(0);
     66         return true;
     67     }
     68     void deleteFence(GrFence) const override {
     69         SkASSERT(0);
     70     }
     71 
     72     sk_sp<GrSemaphore> SK_WARN_UNUSED_RESULT makeSemaphore(bool isOwned) override {
     73         SkASSERT(0);
     74         return nullptr;
     75     }
     76     sk_sp<GrSemaphore> wrapBackendSemaphore(const GrBackendSemaphore& semaphore,
     77                                             GrResourceProvider::SemaphoreWrapType wrapType,
     78                                             GrWrapOwnership ownership) override {
     79         SkASSERT(0);
     80         return nullptr;
     81     }
     82     void insertSemaphore(sk_sp<GrSemaphore> semaphore, bool flush) override {
     83         SkASSERT(0);
     84     }
     85     void waitSemaphore(sk_sp<GrSemaphore> semaphore) override {
     86         SkASSERT(0);
     87     }
     88     sk_sp<GrSemaphore> prepareTextureForCrossContextUsage(GrTexture*) override {
     89         SkASSERT(0);
     90         return nullptr;
     91     }
     92 
     93     void submitCommandBuffer(const GrGpuRTCommandBuffer*);
     94 
     95 private:
     96     GrDDLGpu(GrContext* context, sk_sp<const GrCaps> caps);
     97 
     98     void onResetContext(uint32_t resetBits) override { SkASSERT(0); }
     99 
    100     void xferBarrier(GrRenderTarget*, GrXferBarrierType) override { SkASSERT(0); }
    101 
    102     sk_sp<GrTexture> onCreateTexture(const GrSurfaceDesc&, SkBudgeted,
    103                                      const GrMipLevel texels[], int mipLevelCount) override;
    104 
    105     sk_sp<GrTexture> onWrapBackendTexture(const GrBackendTexture&, GrWrapOwnership) override {
    106         SkASSERT(0);
    107         return nullptr;
    108     }
    109 
    110     sk_sp<GrTexture> onWrapRenderableBackendTexture(const GrBackendTexture&,
    111                                                     int sampleCnt,
    112                                                     GrWrapOwnership) override {
    113         SkASSERT(0);
    114         return nullptr;
    115     }
    116 
    117     sk_sp<GrRenderTarget> onWrapBackendRenderTarget(const GrBackendRenderTarget&) override {
    118         SkASSERT(0);
    119         return nullptr;
    120     }
    121 
    122     sk_sp<GrRenderTarget> onWrapBackendTextureAsRenderTarget(const GrBackendTexture&,
    123                                                              int sampleCnt) override {
    124         SkASSERT(0);
    125         return nullptr;
    126     }
    127 
    128     GrBuffer* onCreateBuffer(size_t sizeInBytes, GrBufferType, GrAccessPattern,
    129                              const void*) override;
    130 
    131     bool onReadPixels(GrSurface* surface, GrSurfaceOrigin,
    132                       int left, int top, int width, int height,
    133                       GrPixelConfig,
    134                       void* buffer,
    135                       size_t rowBytes) override {
    136         SkASSERT(0);
    137         return true;
    138     }
    139 
    140     bool onWritePixels(GrSurface* surface, GrSurfaceOrigin,
    141                        int left, int top, int width, int height,
    142                        GrPixelConfig config,
    143                        const GrMipLevel texels[], int mipLevelCount) override {
    144         SkASSERT(0);
    145         return true;
    146     }
    147 
    148     bool onTransferPixels(GrTexture* texture,
    149                           int left, int top, int width, int height,
    150                           GrPixelConfig config, GrBuffer* transferBuffer,
    151                           size_t offset, size_t rowBytes) override {
    152         SkASSERT(0);
    153         return true;
    154     }
    155 
    156     void onResolveRenderTarget(GrRenderTarget* target, GrSurfaceOrigin) override {
    157         SkASSERT(0);
    158         return;
    159     }
    160 
    161     void onFinishFlush(bool insertedSemaphores) override { SkASSERT(0); }
    162 
    163     GrStencilAttachment* createStencilAttachmentForRenderTarget(const GrRenderTarget*,
    164                                                                 int width,
    165                                                                 int height) override;
    166     void clearStencil(GrRenderTarget*, int clearValue) override  { SkASSERT(0); }
    167 
    168     GrBackendTexture createTestingOnlyBackendTexture(void* pixels, int w, int h, GrPixelConfig,
    169                                                      bool isRT, GrMipMapped) override;
    170     bool isTestingOnlyBackendTexture(const GrBackendTexture&) const override;
    171     void deleteTestingOnlyBackendTexture(GrBackendTexture*, bool abandon = false) override;
    172 
    173     void testingOnly_flushGpuAndSync() override {}
    174 
    175     typedef GrGpu INHERITED;
    176 };
    177 
    178 #endif
    179