1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
|
/*
* Copyright 2015 Google Inc.
*
* Use of this source code is governed by a BSD-style license that can be
* found in the LICENSE file.
*/
#ifndef GrVkGpu_DEFINED
#define GrVkGpu_DEFINED
#include "GrGpu.h"
#include "GrGpuFactory.h"
#include "GrVkCaps.h"
#include "GrVkIndexBuffer.h"
#include "GrVkProgram.h"
#include "GrVkResourceProvider.h"
#include "GrVkVertexBuffer.h"
#include "GrVkUtil.h"
#include "shaderc/shaderc.h"
#include "vulkan/vulkan.h"
class GrPipeline;
class GrNonInstancedVertices;
class GrVkBufferImpl;
class GrVkCommandBuffer;
class GrVkPipeline;
class GrVkRenderPass;
class GrVkTexture;
struct GrVkInterface;
class GrVkGpu : public GrGpu {
public:
// Currently passing in the inst so that we can properly delete it when we are done.
// Normally this would be done by the client.
GrVkGpu(GrContext* context, const GrContextOptions& options,
VkPhysicalDevice physDev, VkDevice device, VkQueue queue, VkCommandPool cmdPool,
VkInstance inst);
~GrVkGpu() override;
const GrVkInterface* vkInterface() const { return fInterface.get(); }
const GrVkCaps& vkCaps() const { return *fVkCaps; }
VkDevice device() const { return fDevice; }
VkQueue queue() const { return fQueue; }
VkCommandPool cmdPool() const { return fCmdPool; }
VkPhysicalDeviceMemoryProperties physicalDeviceMemoryProperties() const {
return fPhysDevMemProps;
}
GrVkResourceProvider& resourceProvider() { return fResourceProvider; }
enum SyncQueue {
kForce_SyncQueue,
kSkip_SyncQueue
};
bool onGetReadPixelsInfo(GrSurface* srcSurface, int readWidth, int readHeight, size_t rowBytes,
GrPixelConfig readConfig, DrawPreference*,
ReadPixelTempDrawInfo*) override;
bool onGetWritePixelsInfo(GrSurface* dstSurface, int width, int height,
GrPixelConfig srcConfig, DrawPreference*,
WritePixelTempDrawInfo*) override;
void buildProgramDesc(GrProgramDesc*, const GrPrimitiveProcessor&,
const GrPipeline&) const override;
void discard(GrRenderTarget*) override {
SkDebugf("discard not yet implemented for Vulkan\n");
}
bool onCopySurface(GrSurface* dst,
GrSurface* src,
const SkIRect& srcRect,
const SkIPoint& dstPoint) override;
bool initCopySurfaceDstDesc(const GrSurface* src, GrSurfaceDesc* desc) const override {
SkDebugf("initCopySurfaceDstDesc not yet implemented for Vulkan\n");
return false;
}
void xferBarrier(GrRenderTarget*, GrXferBarrierType) override {}
GrBackendObject createTestingOnlyBackendTexture(void* pixels, int w, int h,
GrPixelConfig config) override;
bool isTestingOnlyBackendTexture(GrBackendObject id) const override;
void deleteTestingOnlyBackendTexture(GrBackendObject id, bool abandonTexture) override;
GrStencilAttachment* createStencilAttachmentForRenderTarget(const GrRenderTarget*,
int width,
int height) override;
void clearStencil(GrRenderTarget* target) override;
void drawDebugWireRect(GrRenderTarget*, const SkIRect&, GrColor) override {
SkDebugf("drawDebugWireRect not yet implemented for Vulkan\n");
}
void addMemoryBarrier(VkPipelineStageFlags srcStageMask,
VkPipelineStageFlags dstStageMask,
bool byRegion,
VkMemoryBarrier* barrier) const;
void addBufferMemoryBarrier(VkPipelineStageFlags srcStageMask,
VkPipelineStageFlags dstStageMask,
bool byRegion,
VkBufferMemoryBarrier* barrier) const;
void addImageMemoryBarrier(VkPipelineStageFlags srcStageMask,
VkPipelineStageFlags dstStageMask,
bool byRegion,
VkImageMemoryBarrier* barrier) const;
shaderc_compiler_t shadercCompiler() const {
return fCompiler;
}
void finishDrawTarget() override;
private:
void onResetContext(uint32_t resetBits) override {
SkDebugf("onResetContext not yet implemented for Vulkan\n");
}
GrTexture* onCreateTexture(const GrSurfaceDesc& desc, GrGpuResource::LifeCycle,
const SkTArray<GrMipLevel>&) override;
GrTexture* onCreateCompressedTexture(const GrSurfaceDesc& desc, GrGpuResource::LifeCycle,
const SkTArray<GrMipLevel>&) override {
SkDebugf("onCreateCompressedTexture not yet implemented for Vulkan\n");
return NULL;
}
GrTexture* onWrapBackendTexture(const GrBackendTextureDesc&, GrWrapOwnership) override;
GrRenderTarget* onWrapBackendRenderTarget(const GrBackendRenderTargetDesc&,
GrWrapOwnership) override;
GrRenderTarget* onWrapBackendTextureAsRenderTarget(const GrBackendTextureDesc&,
GrWrapOwnership) override {
SkDebugf("onWrapBackendTextureAsRenderTarget not yet implemented for Vulkan\n");
return NULL;
}
GrVertexBuffer* onCreateVertexBuffer(size_t size, bool dynamic) override;
GrIndexBuffer* onCreateIndexBuffer(size_t size, bool dynamic) override;
GrTransferBuffer* onCreateTransferBuffer(size_t size, TransferType type) override;
void onClear(GrRenderTarget*, const SkIRect& rect, GrColor color) override;
void onClearStencilClip(GrRenderTarget*, const SkIRect& rect, bool insideClip) override;
void onDraw(const DrawArgs&, const GrNonInstancedVertices&) override;
bool onReadPixels(GrSurface* surface,
int left, int top, int width, int height,
GrPixelConfig,
void* buffer,
size_t rowBytes) override;
bool onWritePixels(GrSurface* surface,
int left, int top, int width, int height,
GrPixelConfig config, const SkTArray<GrMipLevel>&) override;
bool onTransferPixels(GrSurface*,
int left, int top, int width, int height,
GrPixelConfig config, GrTransferBuffer* buffer,
size_t offset, size_t rowBytes) override {
SkDebugf("onTransferPixels not yet implemented for Vulkan\n");
return false;
}
void onResolveRenderTarget(GrRenderTarget* target) override {
SkDebugf("onResolveRenderTarget not yet implemented for Vulkan\n");
}
// Bind vertex and index buffers
void bindGeometry(const GrPrimitiveProcessor&, const GrNonInstancedVertices&);
// Ends and submits the current command buffer to the queue and then creates a new command
// buffer and begins it. If sync is set to kForce_SyncQueue, the function will wait for all
// work in the queue to finish before returning.
void submitCommandBuffer(SyncQueue sync);
void copySurfaceAsCopyImage(GrSurface* dst,
GrSurface* src,
const SkIRect& srcRect,
const SkIPoint& dstPoint);
void copySurfaceAsDraw(GrSurface* dst,
GrSurface* src,
const SkIRect& srcRect,
const SkIPoint& dstPoint);
// helper for onCreateTexture and writeTexturePixels
bool uploadTexData(GrVkTexture* tex,
int left, int top, int width, int height,
GrPixelConfig dataConfig,
const void* data,
size_t rowBytes);
SkAutoTUnref<const GrVkInterface> fInterface;
SkAutoTUnref<GrVkCaps> fVkCaps;
VkPhysicalDeviceMemoryProperties fPhysDevMemProps;
VkDevice fDevice;
VkQueue fQueue; // for now, one queue
VkCommandPool fCmdPool;
GrVkCommandBuffer* fCurrentCmdBuffer;
GrVkResourceProvider fResourceProvider;
// Shaderc compiler used for compiling glsl in spirv. We only want to create the compiler once
// since there is significant overhead to the first compile of any compiler.
shaderc_compiler_t fCompiler;
// This is only for our current testing and building. The client should be holding on to the
// VkInstance.
VkInstance fVkInstance;
typedef GrGpu INHERITED;
};
#endif
|
