OLD | NEW |
1 /* | 1 /* |
2 * Copyright 2012 Google Inc. | 2 * Copyright 2012 Google Inc. |
3 * | 3 * |
4 * Use of this source code is governed by a BSD-style license that can be | 4 * Use of this source code is governed by a BSD-style license that can be |
5 * found in the LICENSE file. | 5 * found in the LICENSE file. |
6 */ | 6 */ |
7 | 7 |
8 #include "SkSurface_Gpu.h" | 8 #include "SkSurface_Gpu.h" |
9 | 9 |
10 #include "GrResourceProvider.h" | 10 #include "GrResourceProvider.h" |
(...skipping 117 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
128 | 128 |
129 void SkSurface_Gpu::onPrepareForExternalIO() { | 129 void SkSurface_Gpu::onPrepareForExternalIO() { |
130 fDevice->flush(); | 130 fDevice->flush(); |
131 } | 131 } |
132 | 132 |
133 /////////////////////////////////////////////////////////////////////////////// | 133 /////////////////////////////////////////////////////////////////////////////// |
134 | 134 |
135 sk_sp<SkSurface> SkSurface::MakeRenderTargetDirect(GrRenderTarget* target, | 135 sk_sp<SkSurface> SkSurface::MakeRenderTargetDirect(GrRenderTarget* target, |
136 const SkSurfaceProps* props)
{ | 136 const SkSurfaceProps* props)
{ |
137 sk_sp<SkGpuDevice> device( | 137 sk_sp<SkGpuDevice> device( |
138 SkGpuDevice::Make(sk_ref_sp(target), props, SkGpuDevice::kUninit_InitCon
tents)); | 138 SkGpuDevice::Make(target->width(), target->height(), |
| 139 sk_ref_sp(target), props, SkGpuDevice::kUninit_InitCon
tents)); |
139 if (!device) { | 140 if (!device) { |
140 return nullptr; | 141 return nullptr; |
141 } | 142 } |
142 return sk_make_sp<SkSurface_Gpu>(std::move(device)); | 143 return sk_make_sp<SkSurface_Gpu>(std::move(device)); |
143 } | 144 } |
144 | 145 |
145 sk_sp<SkSurface> SkSurface::MakeRenderTarget(GrContext* ctx, SkBudgeted budgeted
, | 146 sk_sp<SkSurface> SkSurface::MakeRenderTarget(GrContext* ctx, SkBudgeted budgeted
, |
146 const SkImageInfo& info, int sample
Count, | 147 const SkImageInfo& info, int sample
Count, |
147 const SkSurfaceProps* props) { | 148 const SkSurfaceProps* props) { |
148 sk_sp<SkGpuDevice> device(SkGpuDevice::Make( | 149 sk_sp<SkGpuDevice> device(SkGpuDevice::Make( |
(...skipping 11 matching lines...) Expand all Loading... |
160 return nullptr; | 161 return nullptr; |
161 } | 162 } |
162 if (!SkToBool(desc.fFlags & kRenderTarget_GrBackendTextureFlag)) { | 163 if (!SkToBool(desc.fFlags & kRenderTarget_GrBackendTextureFlag)) { |
163 return nullptr; | 164 return nullptr; |
164 } | 165 } |
165 SkAutoTUnref<GrSurface> surface(context->textureProvider()->wrapBackendTextu
re(desc, | 166 SkAutoTUnref<GrSurface> surface(context->textureProvider()->wrapBackendTextu
re(desc, |
166 kBorrow_GrWrapOwnership)); | 167 kBorrow_GrWrapOwnership)); |
167 if (!surface) { | 168 if (!surface) { |
168 return nullptr; | 169 return nullptr; |
169 } | 170 } |
170 sk_sp<SkGpuDevice> device(SkGpuDevice::Make(sk_ref_sp(surface->asRenderTarge
t()), props, | 171 sk_sp<SkGpuDevice> device(SkGpuDevice::Make(desc.fWidth, desc.fHeight, |
| 172 sk_ref_sp(surface->asRenderTarge
t()), props, |
171 SkGpuDevice::kUninit_InitContent
s)); | 173 SkGpuDevice::kUninit_InitContent
s)); |
172 if (!device) { | 174 if (!device) { |
173 return nullptr; | 175 return nullptr; |
174 } | 176 } |
175 return sk_make_sp<SkSurface_Gpu>(std::move(device)); | 177 return sk_make_sp<SkSurface_Gpu>(std::move(device)); |
176 } | 178 } |
177 | 179 |
178 sk_sp<SkSurface> SkSurface::MakeFromBackendRenderTarget(GrContext* context, | 180 sk_sp<SkSurface> SkSurface::MakeFromBackendRenderTarget(GrContext* context, |
179 const GrBackendRenderTar
getDesc& desc, | 181 const GrBackendRenderTar
getDesc& desc, |
180 const SkSurfaceProps* pr
ops) { | 182 const SkSurfaceProps* pr
ops) { |
181 if (!context) { | 183 if (!context) { |
182 return nullptr; | 184 return nullptr; |
183 } | 185 } |
184 sk_sp<GrRenderTarget> rt(context->textureProvider()->wrapBackendRenderTarget
(desc)); | 186 sk_sp<GrRenderTarget> rt(context->textureProvider()->wrapBackendRenderTarget
(desc)); |
185 if (!rt) { | 187 if (!rt) { |
186 return nullptr; | 188 return nullptr; |
187 } | 189 } |
188 sk_sp<SkGpuDevice> device(SkGpuDevice::Make(std::move(rt), props, | 190 sk_sp<SkGpuDevice> device(SkGpuDevice::Make(desc.fWidth, desc.fHeight, |
| 191 std::move(rt), props, |
189 SkGpuDevice::kUninit_InitContent
s)); | 192 SkGpuDevice::kUninit_InitContent
s)); |
190 if (!device) { | 193 if (!device) { |
191 return nullptr; | 194 return nullptr; |
192 } | 195 } |
193 return sk_make_sp<SkSurface_Gpu>(std::move(device)); | 196 return sk_make_sp<SkSurface_Gpu>(std::move(device)); |
194 } | 197 } |
195 | 198 |
196 sk_sp<SkSurface> SkSurface::MakeFromBackendTextureAsRenderTarget(GrContext* cont
ext, | 199 sk_sp<SkSurface> SkSurface::MakeFromBackendTextureAsRenderTarget(GrContext* cont
ext, |
197 const GrBackend
TextureDesc& desc, | 200 const GrBackend
TextureDesc& desc, |
198 const SkSurface
Props* props) { | 201 const SkSurface
Props* props) { |
199 if (!context) { | 202 if (!context) { |
200 return nullptr; | 203 return nullptr; |
201 } | 204 } |
202 sk_sp<GrRenderTarget> rt(context->resourceProvider()->wrapBackendTextureAsRe
nderTarget(desc)); | 205 sk_sp<GrRenderTarget> rt(context->resourceProvider()->wrapBackendTextureAsRe
nderTarget(desc)); |
203 if (!rt) { | 206 if (!rt) { |
204 return nullptr; | 207 return nullptr; |
205 } | 208 } |
206 sk_sp<SkGpuDevice> device(SkGpuDevice::Make(std::move(rt), props, | 209 sk_sp<SkGpuDevice> device(SkGpuDevice::Make(desc.fWidth, desc.fHeight, |
| 210 std::move(rt), props, |
207 SkGpuDevice::kUninit_InitContent
s)); | 211 SkGpuDevice::kUninit_InitContent
s)); |
208 if (!device) { | 212 if (!device) { |
209 return nullptr; | 213 return nullptr; |
210 } | 214 } |
211 return sk_make_sp<SkSurface_Gpu>(std::move(device)); | 215 return sk_make_sp<SkSurface_Gpu>(std::move(device)); |
212 } | 216 } |
213 | 217 |
214 #endif | 218 #endif |
OLD | NEW |