OLD | NEW |
| (Empty) |
1 /* | |
2 * Copyright 2016 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 #include <vector> | |
8 | |
9 #include "gm.h" | |
10 #include "GrContext.h" | |
11 #include "SkMipMap.h" | |
12 #include "Resources.h" | |
13 | |
14 #if SK_SUPPORT_GPU | |
15 | |
16 // Helper function that uploads the given SkImage using MakdeFromDeferredTexture
ImageData and then | |
17 // draws the uploaded version at the specified coordinates. | |
18 static void DrawDeferredTextureImageData(SkCanvas* canvas, | |
19 SkImage::DeferredTextureImageUsageParam
s* params) { | |
20 GrContext* context = canvas->getGrContext(); | |
21 if (!context) { | |
22 skiagm::GM::DrawGpuOnlyMessage(canvas); | |
23 return; | |
24 } | |
25 SkAutoTUnref<GrContextThreadSafeProxy> proxy(context->threadSafeProxy()); | |
26 | |
27 | |
28 | |
29 sk_sp<SkImage> encodedImage = GetResourceAsImage("mandrill_512.png"); | |
30 if (!encodedImage) { | |
31 SkDebugf("\nCould not load resource.\n"); | |
32 return; | |
33 } | |
34 | |
35 size_t requiredMemoryInBytes = encodedImage->getDeferredTextureImageData( | |
36 *proxy, params, 1, nullptr, SkSourceGammaTreatment::kRespect); | |
37 if (requiredMemoryInBytes == 0) { | |
38 SkDebugf("\nCould not create DeferredTextureImageData.\n"); | |
39 return; | |
40 } | |
41 | |
42 std::vector<uint8_t> memory; | |
43 memory.resize(requiredMemoryInBytes); | |
44 encodedImage->getDeferredTextureImageData( | |
45 *proxy, params, 1, memory.data(), SkSourceGammaTreatment::kRespect); | |
46 sk_sp<SkImage> uploadedEncodedImage = SkImage::MakeFromDeferredTextureImageD
ata( | |
47 context, memory.data(), SkBudgeted::kNo); | |
48 | |
49 canvas->drawImage(uploadedEncodedImage, 10, 10); | |
50 | |
51 | |
52 | |
53 SkBitmap bitmap; | |
54 if (!GetResourceAsBitmap("mandrill_512.png", &bitmap)) { | |
55 SkDebugf("\nCould not decode resource.\n"); | |
56 return; | |
57 } | |
58 sk_sp<SkImage> decodedImage = SkImage::MakeFromBitmap(bitmap); | |
59 | |
60 requiredMemoryInBytes = decodedImage->getDeferredTextureImageData( | |
61 *proxy, params, 1, nullptr, SkSourceGammaTreatment::kRespect); | |
62 if (requiredMemoryInBytes == 0) { | |
63 SkDebugf("\nCould not create DeferredTextureImageData.\n"); | |
64 return; | |
65 } | |
66 | |
67 memory.resize(requiredMemoryInBytes); | |
68 decodedImage->getDeferredTextureImageData( | |
69 *proxy, params, 1, memory.data(), SkSourceGammaTreatment::kRespect); | |
70 sk_sp<SkImage> uploadedDecodedImage = SkImage::MakeFromDeferredTextureImageD
ata( | |
71 context, memory.data(), SkBudgeted::kNo); | |
72 | |
73 canvas->drawImage(uploadedDecodedImage, 512 + 20, 10); | |
74 } | |
75 | |
76 static void DrawDeferredTextureImageMipMapTree(SkCanvas* canvas, SkImage* image, | |
77 SkImage::DeferredTextureImageUsag
eParams* params) { | |
78 GrContext* context = canvas->getGrContext(); | |
79 if (!context) { | |
80 skiagm::GM::DrawGpuOnlyMessage(canvas); | |
81 return; | |
82 } | |
83 SkAutoTUnref<GrContextThreadSafeProxy> proxy(context->threadSafeProxy()); | |
84 | |
85 SkPaint paint; | |
86 paint.setFilterQuality(params->fQuality); | |
87 | |
88 int mipLevelCount = SkMipMap::ComputeLevelCount(512, 512); | |
89 size_t requiredMemoryInBytes = image->getDeferredTextureImageData( | |
90 *proxy, params, 1, nullptr, SkSourceGammaTreatment::kRespect); | |
91 if (requiredMemoryInBytes == 0) { | |
92 SkDebugf("\nCould not create DeferredTextureImageData.\n"); | |
93 return; | |
94 } | |
95 | |
96 std::vector<uint8_t> memory; | |
97 memory.resize(requiredMemoryInBytes); | |
98 image->getDeferredTextureImageData( | |
99 *proxy, params, 1, memory.data(), SkSourceGammaTreatment::kRespect); | |
100 sk_sp<SkImage> uploadedImage = SkImage::MakeFromDeferredTextureImageData( | |
101 context, memory.data(), SkBudgeted::kNo); | |
102 | |
103 // draw a column using deferred texture images | |
104 SkScalar offsetHeight = 10.f; | |
105 // handle base mipmap level | |
106 canvas->save(); | |
107 canvas->translate(10.f, offsetHeight); | |
108 canvas->drawImage(uploadedImage, 0, 0, &paint); | |
109 canvas->restore(); | |
110 offsetHeight += 512 + 10; | |
111 // handle generated mipmap levels | |
112 for (int i = 0; i < mipLevelCount; i++) { | |
113 SkISize mipSize = SkMipMap::ComputeLevelSize(512, 512, i); | |
114 canvas->save(); | |
115 canvas->translate(10.f, offsetHeight); | |
116 canvas->scale(mipSize.width() / 512.f, mipSize.height() / 512.f); | |
117 canvas->drawImage(uploadedImage, 0, 0, &paint); | |
118 canvas->restore(); | |
119 offsetHeight += mipSize.height() + 10; | |
120 } | |
121 | |
122 // draw a column using SkImage | |
123 offsetHeight = 10; | |
124 // handle base mipmap level | |
125 canvas->save(); | |
126 canvas->translate(512.f + 20.f, offsetHeight); | |
127 canvas->drawImage(image, 0, 0, &paint); | |
128 canvas->restore(); | |
129 offsetHeight += 512 + 10; | |
130 // handle generated mipmap levels | |
131 for (int i = 0; i < mipLevelCount; i++) { | |
132 SkISize mipSize = SkMipMap::ComputeLevelSize(512, 512, i); | |
133 canvas->save(); | |
134 canvas->translate(512.f + 20.f, offsetHeight); | |
135 canvas->scale(mipSize.width() / 512.f, mipSize.height() / 512.f); | |
136 canvas->drawImage(image, 0, 0, &paint); | |
137 canvas->restore(); | |
138 offsetHeight += mipSize.height() + 10; | |
139 } | |
140 } | |
141 | |
142 DEF_SIMPLE_GM(deferred_texture_image_default, canvas, 512 + 512 + 30, 512 + 20)
{ | |
143 SkImage::DeferredTextureImageUsageParams params; | |
144 DrawDeferredTextureImageData(canvas, ¶ms); | |
145 } | |
146 | |
147 DEF_SIMPLE_GM(deferred_texture_image_none, canvas, 512 + 512 + 30, 512 + 20) { | |
148 SkImage::DeferredTextureImageUsageParams params; | |
149 params.fPreScaleMipLevel = 0; | |
150 params.fQuality = kNone_SkFilterQuality; | |
151 DrawDeferredTextureImageData(canvas, ¶ms); | |
152 } | |
153 | |
154 DEF_SIMPLE_GM(deferred_texture_image_low, canvas, 512 + 512 + 30, 512 + 20) { | |
155 SkImage::DeferredTextureImageUsageParams params; | |
156 params.fPreScaleMipLevel = 0; | |
157 params.fQuality = kLow_SkFilterQuality; | |
158 DrawDeferredTextureImageData(canvas, ¶ms); | |
159 } | |
160 | |
161 DEF_SIMPLE_GM(deferred_texture_image_medium_encoded, canvas, 512 + 512 + 30, 111
0) { | |
162 sk_sp<SkImage> encodedImage = GetResourceAsImage("mandrill_512.png"); | |
163 if (!encodedImage) { | |
164 SkDebugf("\nCould not load resource.\n"); | |
165 return; | |
166 } | |
167 | |
168 SkImage::DeferredTextureImageUsageParams params; | |
169 params.fMatrix = SkMatrix::MakeScale(0.25f, 0.25f); | |
170 params.fQuality = kMedium_SkFilterQuality; | |
171 DrawDeferredTextureImageMipMapTree(canvas, encodedImage.get(), ¶ms); | |
172 } | |
173 | |
174 DEF_SIMPLE_GM(deferred_texture_image_medium_decoded, canvas, 512 + 512 + 30, 111
0) { | |
175 SkBitmap bitmap; | |
176 if (!GetResourceAsBitmap("mandrill_512.png", &bitmap)) { | |
177 SkDebugf("\nCould not decode resource.\n"); | |
178 return; | |
179 } | |
180 sk_sp<SkImage> decodedImage = SkImage::MakeFromBitmap(bitmap); | |
181 | |
182 SkImage::DeferredTextureImageUsageParams params; | |
183 params.fMatrix = SkMatrix::MakeScale(0.25f, 0.25f); | |
184 params.fQuality = kMedium_SkFilterQuality; | |
185 DrawDeferredTextureImageMipMapTree(canvas, decodedImage.get(), ¶ms); | |
186 } | |
187 | |
188 DEF_SIMPLE_GM(deferred_texture_image_high, canvas, 512 + 512 + 30, 512 + 20) { | |
189 SkImage::DeferredTextureImageUsageParams params; | |
190 params.fPreScaleMipLevel = 0; | |
191 params.fQuality = kHigh_SkFilterQuality; | |
192 DrawDeferredTextureImageData(canvas, ¶ms); | |
193 } | |
194 | |
195 #endif | |
OLD | NEW |