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 50 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
61 return true; | 61 return true; |
62 } | 62 } |
63 | 63 |
64 SkCanvas* SkSurface_Gpu::onNewCanvas() { | 64 SkCanvas* SkSurface_Gpu::onNewCanvas() { |
65 SkCanvas::InitFlags flags = SkCanvas::kDefault_InitFlags; | 65 SkCanvas::InitFlags flags = SkCanvas::kDefault_InitFlags; |
66 flags = static_cast<SkCanvas::InitFlags>(flags | SkCanvas::kConservativeRast
erClip_InitFlag); | 66 flags = static_cast<SkCanvas::InitFlags>(flags | SkCanvas::kConservativeRast
erClip_InitFlag); |
67 | 67 |
68 return new SkCanvas(fDevice, flags); | 68 return new SkCanvas(fDevice, flags); |
69 } | 69 } |
70 | 70 |
71 SkSurface* SkSurface_Gpu::onNewSurface(const SkImageInfo& info) { | 71 sk_sp<SkSurface> SkSurface_Gpu::onNewSurface(const SkImageInfo& info) { |
72 GrRenderTarget* rt = fDevice->accessRenderTarget(); | 72 GrRenderTarget* rt = fDevice->accessRenderTarget(); |
73 int sampleCount = rt->numColorSamples(); | 73 int sampleCount = rt->numColorSamples(); |
74 // TODO: Make caller specify this (change virtual signature of onNewSurface)
. | 74 // TODO: Make caller specify this (change virtual signature of onNewSurface)
. |
75 static const SkBudgeted kBudgeted = SkBudgeted::kNo; | 75 static const SkBudgeted kBudgeted = SkBudgeted::kNo; |
76 return SkSurface::NewRenderTarget(fDevice->context(), kBudgeted, info, sampl
eCount, | 76 return SkSurface::MakeRenderTarget(fDevice->context(), kBudgeted, info, samp
leCount, |
77 &this->props()); | 77 &this->props()); |
78 } | 78 } |
79 | 79 |
80 SkImage* SkSurface_Gpu::onNewImageSnapshot(SkBudgeted budgeted, ForceCopyMode fo
rceCopyMode) { | 80 sk_sp<SkImage> SkSurface_Gpu::onNewImageSnapshot(SkBudgeted budgeted, ForceCopyM
ode forceCopyMode) { |
81 GrRenderTarget* rt = fDevice->accessRenderTarget(); | 81 GrRenderTarget* rt = fDevice->accessRenderTarget(); |
82 SkASSERT(rt); | 82 SkASSERT(rt); |
83 GrTexture* tex = rt->asTexture(); | 83 GrTexture* tex = rt->asTexture(); |
84 SkAutoTUnref<GrTexture> copy; | 84 SkAutoTUnref<GrTexture> copy; |
85 // If the original render target is a buffer originally created by the clien
t, then we don't | 85 // If the original render target is a buffer originally created by the clien
t, then we don't |
86 // want to ever retarget the SkSurface at another buffer we create. Force a
copy now to avoid | 86 // want to ever retarget the SkSurface at another buffer we create. Force a
copy now to avoid |
87 // copy-on-write. | 87 // copy-on-write. |
88 if (kYes_ForceCopyMode == forceCopyMode || !tex || rt->resourcePriv().isExte
rnal()) { | 88 if (kYes_ForceCopyMode == forceCopyMode || !tex || rt->resourcePriv().isExte
rnal()) { |
89 GrSurfaceDesc desc = fDevice->accessRenderTarget()->desc(); | 89 GrSurfaceDesc desc = fDevice->accessRenderTarget()->desc(); |
90 GrContext* ctx = fDevice->context(); | 90 GrContext* ctx = fDevice->context(); |
91 desc.fFlags = desc.fFlags & ~kRenderTarget_GrSurfaceFlag; | 91 desc.fFlags = desc.fFlags & ~kRenderTarget_GrSurfaceFlag; |
92 copy.reset(ctx->textureProvider()->createTexture(desc, budgeted)); | 92 copy.reset(ctx->textureProvider()->createTexture(desc, budgeted)); |
93 if (!copy) { | 93 if (!copy) { |
94 return nullptr; | 94 return nullptr; |
95 } | 95 } |
96 if (!ctx->copySurface(copy, rt)) { | 96 if (!ctx->copySurface(copy, rt)) { |
97 return nullptr; | 97 return nullptr; |
98 } | 98 } |
99 tex = copy; | 99 tex = copy; |
100 } | 100 } |
101 const SkImageInfo info = fDevice->imageInfo(); | 101 const SkImageInfo info = fDevice->imageInfo(); |
102 SkImage* image = nullptr; | 102 sk_sp<SkImage> image; |
103 if (tex) { | 103 if (tex) { |
104 image = new SkImage_Gpu(info.width(), info.height(), kNeedNewImageUnique
ID, | 104 image = sk_make_sp<SkImage_Gpu>(info.width(), info.height(), kNeedNewIma
geUniqueID, |
105 info.alphaType(), tex, budgeted); | 105 info.alphaType(), tex, budgeted); |
106 } | 106 } |
107 return image; | 107 return image; |
108 } | 108 } |
109 | 109 |
110 // Create a new render target and, if necessary, copy the contents of the old | 110 // Create a new render target and, if necessary, copy the contents of the old |
111 // render target into it. Note that this flushes the SkGpuDevice but | 111 // render target into it. Note that this flushes the SkGpuDevice but |
112 // doesn't force an OpenGL flush. | 112 // doesn't force an OpenGL flush. |
113 void SkSurface_Gpu::onCopyOnWrite(ContentChangeMode mode) { | 113 void SkSurface_Gpu::onCopyOnWrite(ContentChangeMode mode) { |
114 GrRenderTarget* rt = fDevice->accessRenderTarget(); | 114 GrRenderTarget* rt = fDevice->accessRenderTarget(); |
115 // are we sharing our render target with the image? Note this call should ne
ver create a new | 115 // are we sharing our render target with the image? Note this call should ne
ver create a new |
(...skipping 11 matching lines...) Expand all Loading... |
127 void SkSurface_Gpu::onDiscard() { | 127 void SkSurface_Gpu::onDiscard() { |
128 fDevice->accessRenderTarget()->discard(); | 128 fDevice->accessRenderTarget()->discard(); |
129 } | 129 } |
130 | 130 |
131 void SkSurface_Gpu::onPrepareForExternalIO() { | 131 void SkSurface_Gpu::onPrepareForExternalIO() { |
132 fDevice->accessRenderTarget()->prepareForExternalIO(); | 132 fDevice->accessRenderTarget()->prepareForExternalIO(); |
133 } | 133 } |
134 | 134 |
135 /////////////////////////////////////////////////////////////////////////////// | 135 /////////////////////////////////////////////////////////////////////////////// |
136 | 136 |
137 SkSurface* SkSurface::NewRenderTargetDirect(GrRenderTarget* target, const SkSurf
aceProps* props) { | 137 sk_sp<SkSurface> SkSurface::MakeRenderTargetDirect(GrRenderTarget* target, |
| 138 const SkSurfaceProps* props)
{ |
138 SkAutoTUnref<SkGpuDevice> device( | 139 SkAutoTUnref<SkGpuDevice> device( |
139 SkGpuDevice::Create(target, props, SkGpuDevice::kUninit_InitContents)); | 140 SkGpuDevice::Create(target, props, SkGpuDevice::kUninit_InitContents)); |
140 if (!device) { | 141 if (!device) { |
141 return nullptr; | 142 return nullptr; |
142 } | 143 } |
143 return new SkSurface_Gpu(device); | 144 return sk_make_sp<SkSurface_Gpu>(device); |
144 } | 145 } |
145 | 146 |
146 SkSurface* SkSurface::NewRenderTarget(GrContext* ctx, SkBudgeted budgeted, const
SkImageInfo& info, | 147 sk_sp<SkSurface> SkSurface::MakeRenderTarget(GrContext* ctx, SkBudgeted budgeted
, |
147 int sampleCount, const SkSurfaceProps* pro
ps, | 148 const SkImageInfo& info, int sample
Count, |
148 GrTextureStorageAllocator customAllocator)
{ | 149 const SkSurfaceProps* props, |
| 150 GrTextureStorageAllocator customAll
ocator) { |
149 SkAutoTUnref<SkGpuDevice> device(SkGpuDevice::Create( | 151 SkAutoTUnref<SkGpuDevice> device(SkGpuDevice::Create( |
150 ctx, budgeted, info, sampleCount, props, SkGpuDevice::kClear_InitCon
tents, | 152 ctx, budgeted, info, sampleCount, props, SkGpuDevice::kClear_InitCon
tents, |
151 customAllocator)); | 153 customAllocator)); |
152 if (!device) { | 154 if (!device) { |
153 return nullptr; | 155 return nullptr; |
154 } | 156 } |
155 return new SkSurface_Gpu(device); | 157 return sk_make_sp<SkSurface_Gpu>(device); |
156 } | 158 } |
157 | 159 |
158 SkSurface* SkSurface::NewFromBackendTexture(GrContext* context, const GrBackendT
extureDesc& desc, | 160 sk_sp<SkSurface> SkSurface::MakeFromBackendTexture(GrContext* context, |
159 const SkSurfaceProps* props) { | 161 const GrBackendTextureDesc& d
esc, |
| 162 const SkSurfaceProps* props)
{ |
160 if (nullptr == context) { | 163 if (nullptr == context) { |
161 return nullptr; | 164 return nullptr; |
162 } | 165 } |
163 if (!SkToBool(desc.fFlags & kRenderTarget_GrBackendTextureFlag)) { | 166 if (!SkToBool(desc.fFlags & kRenderTarget_GrBackendTextureFlag)) { |
164 return nullptr; | 167 return nullptr; |
165 } | 168 } |
166 SkAutoTUnref<GrSurface> surface(context->textureProvider()->wrapBackendTextu
re(desc, | 169 SkAutoTUnref<GrSurface> surface(context->textureProvider()->wrapBackendTextu
re(desc, |
167 kBorrow_GrWrapOwnership)); | 170 kBorrow_GrWrapOwnership)); |
168 if (!surface) { | 171 if (!surface) { |
169 return nullptr; | 172 return nullptr; |
170 } | 173 } |
171 SkAutoTUnref<SkGpuDevice> device(SkGpuDevice::Create(surface->asRenderTarget
(), props, | 174 SkAutoTUnref<SkGpuDevice> device(SkGpuDevice::Create(surface->asRenderTarget
(), props, |
172 SkGpuDevice::kUninit_In
itContents)); | 175 SkGpuDevice::kUninit_In
itContents)); |
173 if (!device) { | 176 if (!device) { |
174 return nullptr; | 177 return nullptr; |
175 } | 178 } |
176 return new SkSurface_Gpu(device); | 179 return sk_make_sp<SkSurface_Gpu>(device); |
177 } | 180 } |
178 | 181 |
179 SkSurface* SkSurface::NewFromBackendRenderTarget(GrContext* context, | 182 sk_sp<SkSurface> SkSurface::MakeFromBackendRenderTarget(GrContext* context, |
180 const GrBackendRenderTargetDesc
& desc, | 183 const GrBackendRenderTar
getDesc& desc, |
181 const SkSurfaceProps* props) { | 184 const SkSurfaceProps* pr
ops) { |
182 if (nullptr == context) { | 185 if (nullptr == context) { |
183 return nullptr; | 186 return nullptr; |
184 } | 187 } |
185 SkAutoTUnref<GrRenderTarget> rt(context->textureProvider()->wrapBackendRende
rTarget(desc)); | 188 SkAutoTUnref<GrRenderTarget> rt(context->textureProvider()->wrapBackendRende
rTarget(desc)); |
186 if (!rt) { | 189 if (!rt) { |
187 return nullptr; | 190 return nullptr; |
188 } | 191 } |
189 SkAutoTUnref<SkGpuDevice> device(SkGpuDevice::Create(rt, props, | 192 SkAutoTUnref<SkGpuDevice> device(SkGpuDevice::Create(rt, props, |
190 SkGpuDevice::kUninit_In
itContents)); | 193 SkGpuDevice::kUninit_In
itContents)); |
191 if (!device) { | 194 if (!device) { |
192 return nullptr; | 195 return nullptr; |
193 } | 196 } |
194 return new SkSurface_Gpu(device); | 197 return sk_make_sp<SkSurface_Gpu>(device); |
195 } | 198 } |
196 | 199 |
197 SkSurface* SkSurface::NewFromBackendTextureAsRenderTarget(GrContext* context, | 200 sk_sp<SkSurface> SkSurface::MakeFromBackendTextureAsRenderTarget(GrContext* cont
ext, |
198 const GrBackendTexture
Desc& desc, | 201 const GrBackend
TextureDesc& desc, |
199 const SkSurfaceProps*
props) { | 202 const SkSurface
Props* props) { |
200 if (nullptr == context) { | 203 if (nullptr == context) { |
201 return nullptr; | 204 return nullptr; |
202 } | 205 } |
203 SkAutoTUnref<GrRenderTarget> rt( | 206 SkAutoTUnref<GrRenderTarget> rt( |
204 context->resourceProvider()->wrapBackendTextureAsRenderTarget(desc))
; | 207 context->resourceProvider()->wrapBackendTextureAsRenderTarget(desc))
; |
205 if (!rt) { | 208 if (!rt) { |
206 return nullptr; | 209 return nullptr; |
207 } | 210 } |
208 SkAutoTUnref<SkGpuDevice> device(SkGpuDevice::Create(rt, props, | 211 SkAutoTUnref<SkGpuDevice> device(SkGpuDevice::Create(rt, props, |
209 SkGpuDevice::kUninit_In
itContents)); | 212 SkGpuDevice::kUninit_In
itContents)); |
210 if (!device) { | 213 if (!device) { |
211 return nullptr; | 214 return nullptr; |
212 } | 215 } |
213 return new SkSurface_Gpu(device); | 216 return sk_make_sp<SkSurface_Gpu>(device); |
214 } | 217 } |
215 | 218 |
216 #endif | 219 #endif |
OLD | NEW |