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
|
/*
* 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 GrVkImage_DEFINED
#define GrVkImage_DEFINED
#include "GrVkResource.h"
#include "GrTypesPriv.h"
#include "SkTypes.h"
#include "vk/GrVkDefines.h"
#include "vk/GrVkTypes.h"
class GrVkGpu;
class GrVkImage : SkNoncopyable {
private:
class Resource;
public:
GrVkImage(const GrVkImageInfo& info, GrBackendObjectOwnership ownership)
: fInfo(info)
, fIsBorrowed(GrBackendObjectOwnership::kBorrowed == ownership) {
if (fIsBorrowed) {
fResource = new BorrowedResource(info.fImage, info.fAlloc, info.fImageTiling);
} else {
fResource = new Resource(info.fImage, info.fAlloc, info.fImageTiling);
}
}
virtual ~GrVkImage();
VkImage image() const { return fInfo.fImage; }
const GrVkAlloc& alloc() const { return fInfo.fAlloc; }
VkFormat imageFormat() const { return fInfo.fFormat; }
uint32_t mipLevels() const { return fInfo.fLevelCount; }
const Resource* resource() const { return fResource; }
bool isLinearTiled() const {
return SkToBool(VK_IMAGE_TILING_LINEAR == fInfo.fImageTiling);
}
bool isBorrowed() const { return fIsBorrowed; }
VkImageLayout currentLayout() const { return fInfo.fImageLayout; }
void setImageLayout(const GrVkGpu* gpu,
VkImageLayout newLayout,
VkAccessFlags dstAccessMask,
VkPipelineStageFlags dstStageMask,
bool byRegion);
struct ImageDesc {
VkImageType fImageType;
VkFormat fFormat;
uint32_t fWidth;
uint32_t fHeight;
uint32_t fLevels;
uint32_t fSamples;
VkImageTiling fImageTiling;
VkImageUsageFlags fUsageFlags;
VkFlags fMemProps;
ImageDesc()
: fImageType(VK_IMAGE_TYPE_2D)
, fFormat(VK_FORMAT_UNDEFINED)
, fWidth(0)
, fHeight(0)
, fLevels(1)
, fSamples(1)
, fImageTiling(VK_IMAGE_TILING_OPTIMAL)
, fUsageFlags(0)
, fMemProps(VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT) {}
};
static bool InitImageInfo(const GrVkGpu* gpu, const ImageDesc& imageDesc, GrVkImageInfo*);
// Destroys the internal VkImage and VkDeviceMemory in the GrVkImageInfo
static void DestroyImageInfo(const GrVkGpu* gpu, GrVkImageInfo*);
// These match the definitions in SkImage, for whence they came
typedef void* ReleaseCtx;
typedef void (*ReleaseProc)(ReleaseCtx);
void setResourceRelease(ReleaseProc proc, ReleaseCtx ctx);
protected:
void releaseImage(const GrVkGpu* gpu);
void abandonImage();
void setNewResource(VkImage image, const GrVkAlloc& alloc, VkImageTiling tiling);
GrVkImageInfo fInfo;
bool fIsBorrowed;
private:
class Resource : public GrVkResource {
public:
Resource()
: INHERITED()
, fReleaseProc(nullptr)
, fReleaseCtx(nullptr)
, fImage(VK_NULL_HANDLE) {
fAlloc.fMemory = VK_NULL_HANDLE;
fAlloc.fOffset = 0;
}
Resource(VkImage image, const GrVkAlloc& alloc, VkImageTiling tiling)
: fReleaseProc(nullptr)
, fReleaseCtx(nullptr)
, fImage(image)
, fAlloc(alloc)
, fImageTiling(tiling) {}
~Resource() override {
SkASSERT(!fReleaseProc);
}
#ifdef SK_TRACE_VK_RESOURCES
void dumpInfo() const override {
SkDebugf("GrVkImage: %d (%d refs)\n", fImage, this->getRefCnt());
}
#endif
void setRelease(ReleaseProc proc, ReleaseCtx ctx) const {
fReleaseProc = proc;
fReleaseCtx = ctx;
}
protected:
mutable ReleaseProc fReleaseProc;
mutable ReleaseCtx fReleaseCtx;
private:
void freeGPUData(const GrVkGpu* gpu) const override;
void abandonGPUData() const override {
SkASSERT(!fReleaseProc);
}
VkImage fImage;
GrVkAlloc fAlloc;
VkImageTiling fImageTiling;
typedef GrVkResource INHERITED;
};
// for wrapped textures
class BorrowedResource : public Resource {
public:
BorrowedResource(VkImage image, const GrVkAlloc& alloc, VkImageTiling tiling)
: Resource(image, alloc, tiling) {
}
private:
void invokeReleaseProc() const {
if (fReleaseProc) {
fReleaseProc(fReleaseCtx);
fReleaseProc = nullptr;
}
}
void freeGPUData(const GrVkGpu* gpu) const override;
void abandonGPUData() const override;
};
const Resource* fResource;
friend class GrVkRenderTarget;
};
#endif
|
