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 "SkCanvas.h" | 10 #include "SkCanvas.h" |
(...skipping 48 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
59 GrRenderTarget* rt = prepare_rt_for_external_access(this, access); | 59 GrRenderTarget* rt = prepare_rt_for_external_access(this, access); |
60 *obj = rt->getRenderTargetHandle(); | 60 *obj = rt->getRenderTargetHandle(); |
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 // When we think this works... | 66 // When we think this works... |
67 // flags |= SkCanvas::kConservativeRasterClip_InitFlag; | 67 // flags |= SkCanvas::kConservativeRasterClip_InitFlag; |
68 | 68 |
69 return SkNEW_ARGS(SkCanvas, (fDevice, flags)); | 69 return new SkCanvas(fDevice, flags); |
70 } | 70 } |
71 | 71 |
72 SkSurface* SkSurface_Gpu::onNewSurface(const SkImageInfo& info) { | 72 SkSurface* SkSurface_Gpu::onNewSurface(const SkImageInfo& info) { |
73 GrRenderTarget* rt = fDevice->accessRenderTarget(); | 73 GrRenderTarget* rt = fDevice->accessRenderTarget(); |
74 int sampleCount = rt->numColorSamples(); | 74 int sampleCount = rt->numColorSamples(); |
75 // TODO: Make caller specify this (change virtual signature of onNewSurface)
. | 75 // TODO: Make caller specify this (change virtual signature of onNewSurface)
. |
76 static const Budgeted kBudgeted = kNo_Budgeted; | 76 static const Budgeted kBudgeted = kNo_Budgeted; |
77 return SkSurface::NewRenderTarget(fDevice->context(), kBudgeted, info, sampl
eCount, | 77 return SkSurface::NewRenderTarget(fDevice->context(), kBudgeted, info, sampl
eCount, |
78 &this->props()); | 78 &this->props()); |
79 } | 79 } |
80 | 80 |
81 SkImage* SkSurface_Gpu::onNewImageSnapshot(Budgeted budgeted) { | 81 SkImage* SkSurface_Gpu::onNewImageSnapshot(Budgeted budgeted) { |
82 const SkImageInfo info = fDevice->imageInfo(); | 82 const SkImageInfo info = fDevice->imageInfo(); |
83 const int sampleCount = fDevice->accessRenderTarget()->numColorSamples(); | 83 const int sampleCount = fDevice->accessRenderTarget()->numColorSamples(); |
84 SkImage* image = NULL; | 84 SkImage* image = NULL; |
85 GrTexture* tex = fDevice->accessRenderTarget()->asTexture(); | 85 GrTexture* tex = fDevice->accessRenderTarget()->asTexture(); |
86 if (tex) { | 86 if (tex) { |
87 image = SkNEW_ARGS(SkImage_Gpu, | 87 image = new SkImage_Gpu(info.width(), info.height(), kNeedNewImageUnique
ID, |
88 (info.width(), info.height(), kNeedNewImageUniqueID,
info.alphaType(), | 88 info.alphaType(), tex, sampleCount, budgeted); |
89 tex, sampleCount, budgeted)); | |
90 } | 89 } |
91 if (image) { | 90 if (image) { |
92 as_IB(image)->initWithProps(this->props()); | 91 as_IB(image)->initWithProps(this->props()); |
93 } | 92 } |
94 return image; | 93 return image; |
95 } | 94 } |
96 | 95 |
97 // Create a new render target and, if necessary, copy the contents of the old | 96 // Create a new render target and, if necessary, copy the contents of the old |
98 // render target into it. Note that this flushes the SkGpuDevice but | 97 // render target into it. Note that this flushes the SkGpuDevice but |
99 // doesn't force an OpenGL flush. | 98 // doesn't force an OpenGL flush. |
(...skipping 16 matching lines...) Expand all Loading... |
116 } | 115 } |
117 | 116 |
118 /////////////////////////////////////////////////////////////////////////////// | 117 /////////////////////////////////////////////////////////////////////////////// |
119 | 118 |
120 SkSurface* SkSurface::NewRenderTargetDirect(GrRenderTarget* target, const SkSurf
aceProps* props) { | 119 SkSurface* SkSurface::NewRenderTargetDirect(GrRenderTarget* target, const SkSurf
aceProps* props) { |
121 SkAutoTUnref<SkGpuDevice> device( | 120 SkAutoTUnref<SkGpuDevice> device( |
122 SkGpuDevice::Create(target, props, SkGpuDevice::kUninit_InitContents)); | 121 SkGpuDevice::Create(target, props, SkGpuDevice::kUninit_InitContents)); |
123 if (!device) { | 122 if (!device) { |
124 return NULL; | 123 return NULL; |
125 } | 124 } |
126 return SkNEW_ARGS(SkSurface_Gpu, (device)); | 125 return new SkSurface_Gpu(device); |
127 } | 126 } |
128 | 127 |
129 SkSurface* SkSurface::NewRenderTarget(GrContext* ctx, Budgeted budgeted, const S
kImageInfo& info, | 128 SkSurface* SkSurface::NewRenderTarget(GrContext* ctx, Budgeted budgeted, const S
kImageInfo& info, |
130 int sampleCount, const SkSurfaceProps* pro
ps) { | 129 int sampleCount, const SkSurfaceProps* pro
ps) { |
131 SkAutoTUnref<SkGpuDevice> device(SkGpuDevice::Create(ctx, budgeted, info, sa
mpleCount, props, | 130 SkAutoTUnref<SkGpuDevice> device(SkGpuDevice::Create(ctx, budgeted, info, sa
mpleCount, props, |
132 SkGpuDevice::kClear_Ini
tContents)); | 131 SkGpuDevice::kClear_Ini
tContents)); |
133 if (!device) { | 132 if (!device) { |
134 return NULL; | 133 return NULL; |
135 } | 134 } |
136 return SkNEW_ARGS(SkSurface_Gpu, (device)); | 135 return new SkSurface_Gpu(device); |
137 } | 136 } |
138 | 137 |
139 SkSurface* SkSurface::NewFromBackendTexture(GrContext* context, const GrBackendT
extureDesc& desc, | 138 SkSurface* SkSurface::NewFromBackendTexture(GrContext* context, const GrBackendT
extureDesc& desc, |
140 const SkSurfaceProps* props) { | 139 const SkSurfaceProps* props) { |
141 if (NULL == context) { | 140 if (NULL == context) { |
142 return NULL; | 141 return NULL; |
143 } | 142 } |
144 if (!SkToBool(desc.fFlags & kRenderTarget_GrBackendTextureFlag)) { | 143 if (!SkToBool(desc.fFlags & kRenderTarget_GrBackendTextureFlag)) { |
145 return NULL; | 144 return NULL; |
146 } | 145 } |
147 SkAutoTUnref<GrSurface> surface(context->textureProvider()->wrapBackendTextu
re(desc, | 146 SkAutoTUnref<GrSurface> surface(context->textureProvider()->wrapBackendTextu
re(desc, |
148 kBorrow_GrWrapOwnership)); | 147 kBorrow_GrWrapOwnership)); |
149 if (!surface) { | 148 if (!surface) { |
150 return NULL; | 149 return NULL; |
151 } | 150 } |
152 SkAutoTUnref<SkGpuDevice> device(SkGpuDevice::Create(surface->asRenderTarget
(), props, | 151 SkAutoTUnref<SkGpuDevice> device(SkGpuDevice::Create(surface->asRenderTarget
(), props, |
153 SkGpuDevice::kUninit_In
itContents)); | 152 SkGpuDevice::kUninit_In
itContents)); |
154 if (!device) { | 153 if (!device) { |
155 return NULL; | 154 return NULL; |
156 } | 155 } |
157 return SkNEW_ARGS(SkSurface_Gpu, (device)); | 156 return new SkSurface_Gpu(device); |
158 } | 157 } |
159 | 158 |
160 SkSurface* SkSurface::NewFromBackendRenderTarget(GrContext* context, | 159 SkSurface* SkSurface::NewFromBackendRenderTarget(GrContext* context, |
161 const GrBackendRenderTargetDesc
& desc, | 160 const GrBackendRenderTargetDesc
& desc, |
162 const SkSurfaceProps* props) { | 161 const SkSurfaceProps* props) { |
163 if (NULL == context) { | 162 if (NULL == context) { |
164 return NULL; | 163 return NULL; |
165 } | 164 } |
166 SkAutoTUnref<GrRenderTarget> rt(context->textureProvider()->wrapBackendRende
rTarget(desc)); | 165 SkAutoTUnref<GrRenderTarget> rt(context->textureProvider()->wrapBackendRende
rTarget(desc)); |
167 if (!rt) { | 166 if (!rt) { |
168 return NULL; | 167 return NULL; |
169 } | 168 } |
170 SkAutoTUnref<SkGpuDevice> device(SkGpuDevice::Create(rt, props, | 169 SkAutoTUnref<SkGpuDevice> device(SkGpuDevice::Create(rt, props, |
171 SkGpuDevice::kUninit_In
itContents)); | 170 SkGpuDevice::kUninit_In
itContents)); |
172 if (!device) { | 171 if (!device) { |
173 return NULL; | 172 return NULL; |
174 } | 173 } |
175 return SkNEW_ARGS(SkSurface_Gpu, (device)); | 174 return new SkSurface_Gpu(device); |
176 } | 175 } |
177 | 176 |
178 #endif | 177 #endif |
OLD | NEW |