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
17class GrDDLGpu : public GrGpu {
18public:
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
95private:
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