• Home
  • History
  • Annotate
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /*
2  * Copyright 2013 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 
8 #include "GrGLNoOpInterface.h"
9 #include "SkString.h"
10 #include "SkThread.h"
11 
12 // the OpenGLES 2.0 spec says this must be >= 128
13 static const GrGLint kDefaultMaxVertexUniformVectors = 128;
14 
15 // the OpenGLES 2.0 spec says this must be >=16
16 static const GrGLint kDefaultMaxFragmentUniformVectors = 16;
17 
18 // the OpenGLES 2.0 spec says this must be >= 8
19 static const GrGLint kDefaultMaxVertexAttribs = 8;
20 
21 // the OpenGLES 2.0 spec says this must be >= 8
22 static const GrGLint kDefaultMaxVaryingVectors = 8;
23 
24 static const char* kExtensions[] = {
25     "GL_ARB_framebuffer_object",
26     "GL_ARB_blend_func_extended",
27     "GL_ARB_timer_query",
28     "GL_ARB_draw_buffers",
29     "GL_ARB_occlusion_query",
30     "GL_EXT_blend_color",
31     "GL_EXT_stencil_wrap"
32 };
33 
34 namespace {
combined_extensions_string()35 const GrGLubyte* combined_extensions_string() {
36     static SkString gExtString;
37     static SkMutex gMutex;
38     gMutex.acquire();
39     if (0 == gExtString.size()) {
40         for (size_t i = 0; i < SK_ARRAY_COUNT(kExtensions) - 1; ++i) {
41             gExtString.append(kExtensions[i]);
42             gExtString.append(" ");
43         }
44         gExtString.append(kExtensions[SK_ARRAY_COUNT(kExtensions) - 1]);
45     }
46     gMutex.release();
47     return (const GrGLubyte*) gExtString.c_str();
48 }
49 }
50 
noOpGLBlendColor(GrGLclampf red,GrGLclampf green,GrGLclampf blue,GrGLclampf alpha)51 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLBlendColor(GrGLclampf red,
52                                               GrGLclampf green,
53                                               GrGLclampf blue,
54                                               GrGLclampf alpha) {
55 }
56 
noOpGLBindFragDataLocation(GrGLuint program,GrGLuint colorNumber,const GrGLchar * name)57 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLBindFragDataLocation(GrGLuint program,
58                                                         GrGLuint colorNumber,
59                                                         const GrGLchar* name) {
60 }
61 
noOpGLBlendFunc(GrGLenum sfactor,GrGLenum dfactor)62 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLBlendFunc(GrGLenum sfactor,
63                                               GrGLenum dfactor) {
64 }
65 
noOpGLBufferSubData(GrGLenum target,GrGLintptr offset,GrGLsizeiptr size,const GrGLvoid * data)66 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLBufferSubData(GrGLenum target,
67                                                  GrGLintptr offset,
68                                                  GrGLsizeiptr size,
69                                                  const GrGLvoid* data) {
70 }
71 
noOpGLClear(GrGLbitfield mask)72 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLClear(GrGLbitfield mask) {
73 }
74 
noOpGLClearColor(GrGLclampf red,GrGLclampf green,GrGLclampf blue,GrGLclampf alpha)75 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLClearColor(GrGLclampf red,
76                                               GrGLclampf green,
77                                               GrGLclampf blue,
78                                               GrGLclampf alpha) {
79 }
80 
noOpGLClearStencil(GrGLint s)81 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLClearStencil(GrGLint s) {
82 }
83 
noOpGLColorMask(GrGLboolean red,GrGLboolean green,GrGLboolean blue,GrGLboolean alpha)84 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLColorMask(GrGLboolean red,
85                                              GrGLboolean green,
86                                              GrGLboolean blue,
87                                              GrGLboolean alpha) {
88 }
89 
noOpGLCompileShader(GrGLuint shader)90 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLCompileShader(GrGLuint shader) {
91 }
92 
noOpGLCompressedTexImage2D(GrGLenum target,GrGLint level,GrGLenum internalformat,GrGLsizei width,GrGLsizei height,GrGLint border,GrGLsizei imageSize,const GrGLvoid * data)93 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLCompressedTexImage2D(GrGLenum target,
94                                                         GrGLint level,
95                                                         GrGLenum internalformat,
96                                                         GrGLsizei width,
97                                                         GrGLsizei height,
98                                                         GrGLint border,
99                                                         GrGLsizei imageSize,
100                                                         const GrGLvoid* data) {
101 }
102 
noOpGLCompressedTexSubImage2D(GrGLenum target,GrGLint level,GrGLint xoffset,GrGLint yoffset,GrGLsizei width,GrGLsizei height,GrGLenum format,GrGLsizei imageSize,const GrGLvoid * data)103 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLCompressedTexSubImage2D(GrGLenum target,
104                                                            GrGLint level,
105                                                            GrGLint xoffset,
106                                                            GrGLint yoffset,
107                                                            GrGLsizei width,
108                                                            GrGLsizei height,
109                                                            GrGLenum format,
110                                                            GrGLsizei imageSize,
111                                                            const GrGLvoid* data) {
112 }
113 
noOpGLCopyTexSubImage2D(GrGLenum target,GrGLint level,GrGLint xoffset,GrGLint yoffset,GrGLint x,GrGLint y,GrGLsizei width,GrGLsizei height)114 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLCopyTexSubImage2D(GrGLenum target,
115                                                      GrGLint level,
116                                                      GrGLint xoffset,
117                                                      GrGLint yoffset,
118                                                      GrGLint x,
119                                                      GrGLint y,
120                                                      GrGLsizei width,
121                                                      GrGLsizei height) {
122 }
123 
noOpGLCullFace(GrGLenum mode)124 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLCullFace(GrGLenum mode) {
125 }
126 
noOpGLDepthMask(GrGLboolean flag)127 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLDepthMask(GrGLboolean flag) {
128 }
129 
noOpGLDisable(GrGLenum cap)130 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLDisable(GrGLenum cap) {
131 }
132 
noOpGLDisableVertexAttribArray(GrGLuint index)133 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLDisableVertexAttribArray(GrGLuint index) {
134 }
135 
noOpGLDrawArrays(GrGLenum mode,GrGLint first,GrGLsizei count)136 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLDrawArrays(GrGLenum mode,
137                                               GrGLint first,
138                                               GrGLsizei count) {
139 }
140 
noOpGLDrawBuffer(GrGLenum mode)141 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLDrawBuffer(GrGLenum mode) {
142 }
143 
noOpGLDrawBuffers(GrGLsizei n,const GrGLenum * bufs)144 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLDrawBuffers(GrGLsizei n,
145                                                const GrGLenum* bufs) {
146 }
147 
noOpGLDrawElements(GrGLenum mode,GrGLsizei count,GrGLenum type,const GrGLvoid * indices)148 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLDrawElements(GrGLenum mode,
149                                                 GrGLsizei count,
150                                                 GrGLenum type,
151                                                 const GrGLvoid* indices) {
152 }
153 
noOpGLEnable(GrGLenum cap)154 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLEnable(GrGLenum cap) {
155 }
156 
noOpGLEnableVertexAttribArray(GrGLuint index)157 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLEnableVertexAttribArray(GrGLuint index) {
158 }
159 
noOpGLEndQuery(GrGLenum target)160 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLEndQuery(GrGLenum target) {
161 }
162 
noOpGLFinish()163 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLFinish() {
164 }
165 
noOpGLFlush()166 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLFlush() {
167 }
168 
noOpGLFrontFace(GrGLenum mode)169 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLFrontFace(GrGLenum mode) {
170 }
171 
noOpGLLineWidth(GrGLfloat width)172 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLLineWidth(GrGLfloat width) {
173 }
174 
noOpGLLinkProgram(GrGLuint program)175 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLLinkProgram(GrGLuint program) {
176 }
177 
noOpGLMatrixLoadf(GrGLenum,const GrGLfloat *)178 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLMatrixLoadf(GrGLenum, const GrGLfloat*) {
179 }
180 
noOpGLMatrixLoadIdentity(GrGLenum)181 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLMatrixLoadIdentity(GrGLenum) {
182 }
183 
noOpGLQueryCounter(GrGLuint id,GrGLenum target)184 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLQueryCounter(GrGLuint id, GrGLenum target) {
185 }
186 
noOpGLReadBuffer(GrGLenum src)187 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLReadBuffer(GrGLenum src) {
188 }
189 
noOpGLScissor(GrGLint x,GrGLint y,GrGLsizei width,GrGLsizei height)190 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLScissor(GrGLint x,
191                                            GrGLint y,
192                                            GrGLsizei width,
193                                            GrGLsizei height) {
194 }
195 
noOpGLShaderSource(GrGLuint shader,GrGLsizei count,const char * const * str,const GrGLint * length)196 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLShaderSource(GrGLuint shader,
197                                                 GrGLsizei count,
198 #if GR_GL_USE_NEW_SHADER_SOURCE_SIGNATURE
199                                                 const char* const * str,
200 #else
201                                                 const char** str,
202 #endif
203                                                 const GrGLint* length) {
204 }
205 
noOpGLStencilFunc(GrGLenum func,GrGLint ref,GrGLuint mask)206 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLStencilFunc(GrGLenum func, GrGLint ref, GrGLuint mask) {
207 }
208 
noOpGLStencilFuncSeparate(GrGLenum face,GrGLenum func,GrGLint ref,GrGLuint mask)209 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLStencilFuncSeparate(GrGLenum face,
210                                                        GrGLenum func,
211                                                        GrGLint ref,
212                                                        GrGLuint mask) {
213 }
214 
noOpGLStencilMask(GrGLuint mask)215 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLStencilMask(GrGLuint mask) {
216 }
217 
noOpGLStencilMaskSeparate(GrGLenum face,GrGLuint mask)218 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLStencilMaskSeparate(GrGLenum face, GrGLuint mask) {
219 }
220 
noOpGLStencilOp(GrGLenum fail,GrGLenum zfail,GrGLenum zpass)221 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLStencilOp(GrGLenum fail, GrGLenum zfail, GrGLenum zpass) {
222 }
223 
noOpGLStencilOpSeparate(GrGLenum face,GrGLenum fail,GrGLenum zfail,GrGLenum zpass)224 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLStencilOpSeparate(GrGLenum face,
225                                                      GrGLenum fail,
226                                                      GrGLenum zfail,
227                                                      GrGLenum zpass) {
228 }
229 
noOpGLTexImage2D(GrGLenum target,GrGLint level,GrGLint internalformat,GrGLsizei width,GrGLsizei height,GrGLint border,GrGLenum format,GrGLenum type,const GrGLvoid * pixels)230 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLTexImage2D(GrGLenum target,
231                                               GrGLint level,
232                                               GrGLint internalformat,
233                                               GrGLsizei width,
234                                               GrGLsizei height,
235                                               GrGLint border,
236                                               GrGLenum format,
237                                               GrGLenum type,
238                                               const GrGLvoid* pixels) {
239 }
240 
noOpGLTexParameteri(GrGLenum target,GrGLenum pname,GrGLint param)241 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLTexParameteri(GrGLenum target,
242                                                  GrGLenum pname,
243                                                  GrGLint param) {
244 }
245 
noOpGLTexParameteriv(GrGLenum target,GrGLenum pname,const GrGLint * params)246 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLTexParameteriv(GrGLenum target,
247                                                   GrGLenum pname,
248                                                   const GrGLint* params) {
249 }
250 
noOpGLTexStorage2D(GrGLenum target,GrGLsizei levels,GrGLenum internalformat,GrGLsizei width,GrGLsizei height)251 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLTexStorage2D(GrGLenum target,
252                                                 GrGLsizei levels,
253                                                 GrGLenum internalformat,
254                                                 GrGLsizei width,
255                                                 GrGLsizei height) {
256 }
257 
noOpGLDiscardFramebuffer(GrGLenum target,GrGLsizei numAttachments,const GrGLenum * attachments)258 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLDiscardFramebuffer(GrGLenum target,
259                                                       GrGLsizei numAttachments,
260                                                       const GrGLenum* attachments) {
261 }
262 
noOpGLTexSubImage2D(GrGLenum target,GrGLint level,GrGLint xoffset,GrGLint yoffset,GrGLsizei width,GrGLsizei height,GrGLenum format,GrGLenum type,const GrGLvoid * pixels)263 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLTexSubImage2D(GrGLenum target,
264                                                  GrGLint level,
265                                                  GrGLint xoffset,
266                                                  GrGLint yoffset,
267                                                  GrGLsizei width,
268                                                  GrGLsizei height,
269                                                  GrGLenum format,
270                                                  GrGLenum type,
271                                                  const GrGLvoid* pixels) {
272 }
273 
noOpGLUniform1f(GrGLint location,GrGLfloat v0)274 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLUniform1f(GrGLint location, GrGLfloat v0) {
275 }
276 
noOpGLUniform1i(GrGLint location,GrGLint v0)277 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLUniform1i(GrGLint location, GrGLint v0) {
278 }
279 
noOpGLUniform1fv(GrGLint location,GrGLsizei count,const GrGLfloat * v)280 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLUniform1fv(GrGLint location,
281                                               GrGLsizei count,
282                                               const GrGLfloat* v) {
283 }
284 
noOpGLUniform1iv(GrGLint location,GrGLsizei count,const GrGLint * v)285 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLUniform1iv(GrGLint location,
286                                               GrGLsizei count,
287                                               const GrGLint* v) {
288 }
289 
noOpGLUniform2f(GrGLint location,GrGLfloat v0,GrGLfloat v1)290 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLUniform2f(GrGLint location, GrGLfloat v0, GrGLfloat v1) {
291 }
292 
noOpGLUniform2i(GrGLint location,GrGLint v0,GrGLint v1)293 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLUniform2i(GrGLint location, GrGLint v0, GrGLint v1) {
294 }
295 
noOpGLUniform2fv(GrGLint location,GrGLsizei count,const GrGLfloat * v)296 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLUniform2fv(GrGLint location,
297                                               GrGLsizei count,
298                                               const GrGLfloat* v) {
299 }
300 
noOpGLUniform2iv(GrGLint location,GrGLsizei count,const GrGLint * v)301 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLUniform2iv(GrGLint location,
302                                               GrGLsizei count,
303                                               const GrGLint* v) {
304 }
305 
noOpGLUniform3f(GrGLint location,GrGLfloat v0,GrGLfloat v1,GrGLfloat v2)306 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLUniform3f(GrGLint location,
307                                               GrGLfloat v0,
308                                               GrGLfloat v1,
309                                               GrGLfloat v2) {
310 }
311 
noOpGLUniform3i(GrGLint location,GrGLint v0,GrGLint v1,GrGLint v2)312 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLUniform3i(GrGLint location,
313                                               GrGLint v0,
314                                               GrGLint v1,
315                                               GrGLint v2) {
316 }
317 
noOpGLUniform3fv(GrGLint location,GrGLsizei count,const GrGLfloat * v)318 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLUniform3fv(GrGLint location,
319                                               GrGLsizei count,
320                                               const GrGLfloat* v) {
321 }
322 
noOpGLUniform3iv(GrGLint location,GrGLsizei count,const GrGLint * v)323 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLUniform3iv(GrGLint location,
324                                               GrGLsizei count,
325                                               const GrGLint* v) {
326 }
327 
noOpGLUniform4f(GrGLint location,GrGLfloat v0,GrGLfloat v1,GrGLfloat v2,GrGLfloat v3)328 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLUniform4f(GrGLint location,
329                                               GrGLfloat v0,
330                                               GrGLfloat v1,
331                                               GrGLfloat v2,
332                                               GrGLfloat v3) {
333 }
334 
noOpGLUniform4i(GrGLint location,GrGLint v0,GrGLint v1,GrGLint v2,GrGLint v3)335 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLUniform4i(GrGLint location,
336                                               GrGLint v0,
337                                               GrGLint v1,
338                                               GrGLint v2,
339                                               GrGLint v3) {
340 }
341 
noOpGLUniform4fv(GrGLint location,GrGLsizei count,const GrGLfloat * v)342 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLUniform4fv(GrGLint location,
343                                               GrGLsizei count,
344                                               const GrGLfloat* v) {
345 }
346 
noOpGLUniform4iv(GrGLint location,GrGLsizei count,const GrGLint * v)347 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLUniform4iv(GrGLint location,
348                                               GrGLsizei count,
349                                               const GrGLint* v) {
350 }
351 
noOpGLUniformMatrix2fv(GrGLint location,GrGLsizei count,GrGLboolean transpose,const GrGLfloat * value)352 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLUniformMatrix2fv(GrGLint location,
353                                                     GrGLsizei count,
354                                                     GrGLboolean transpose,
355                                                     const GrGLfloat* value) {
356 }
357 
noOpGLUniformMatrix3fv(GrGLint location,GrGLsizei count,GrGLboolean transpose,const GrGLfloat * value)358 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLUniformMatrix3fv(GrGLint location,
359                                                     GrGLsizei count,
360                                                     GrGLboolean transpose,
361                                                     const GrGLfloat* value) {
362 }
363 
noOpGLUniformMatrix4fv(GrGLint location,GrGLsizei count,GrGLboolean transpose,const GrGLfloat * value)364 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLUniformMatrix4fv(GrGLint location,
365                                                     GrGLsizei count,
366                                                     GrGLboolean transpose,
367                                                     const GrGLfloat* value) {
368 }
369 
noOpGLVertexAttrib4fv(GrGLuint indx,const GrGLfloat * values)370  GrGLvoid GR_GL_FUNCTION_TYPE noOpGLVertexAttrib4fv(GrGLuint indx, const GrGLfloat* values) {
371 }
372 
noOpGLVertexAttribPointer(GrGLuint indx,GrGLint size,GrGLenum type,GrGLboolean normalized,GrGLsizei stride,const GrGLvoid * ptr)373 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLVertexAttribPointer(GrGLuint indx,
374                                                        GrGLint size,
375                                                        GrGLenum type,
376                                                        GrGLboolean normalized,
377                                                        GrGLsizei stride,
378                                                        const GrGLvoid* ptr) {
379 }
380 
noOpGLViewport(GrGLint x,GrGLint y,GrGLsizei width,GrGLsizei height)381 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLViewport(GrGLint x,
382                                             GrGLint y,
383                                             GrGLsizei width,
384                                             GrGLsizei height) {
385 }
386 
noOpGLGetFramebufferAttachmentParameteriv(GrGLenum target,GrGLenum attachment,GrGLenum pname,GrGLint * params)387   GrGLvoid GR_GL_FUNCTION_TYPE noOpGLGetFramebufferAttachmentParameteriv(GrGLenum target,
388                                                                          GrGLenum attachment,
389                                                                          GrGLenum pname,
390                                                                          GrGLint* params) {
391 }
392 
noOpGLGetRenderbufferParameteriv(GrGLenum target,GrGLenum pname,GrGLint * params)393 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLGetRenderbufferParameteriv(GrGLenum target,
394                                                               GrGLenum pname,
395                                                               GrGLint* params) {
396 }
397 
noOpGLRenderbufferStorage(GrGLenum target,GrGLenum internalformat,GrGLsizei width,GrGLsizei height)398 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLRenderbufferStorage(GrGLenum target,
399                                                        GrGLenum internalformat,
400                                                        GrGLsizei width,
401                                                        GrGLsizei height) {
402 }
403 
noOpGLRenderbufferStorageMultisample(GrGLenum target,GrGLsizei samples,GrGLenum internalformat,GrGLsizei width,GrGLsizei height)404 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLRenderbufferStorageMultisample(GrGLenum target,
405                                                                   GrGLsizei samples,
406                                                                   GrGLenum internalformat,
407                                                                   GrGLsizei width,
408                                                                   GrGLsizei height) {
409 }
410 
noOpGLBlitFramebuffer(GrGLint srcX0,GrGLint srcY0,GrGLint srcX1,GrGLint srcY1,GrGLint dstX0,GrGLint dstY0,GrGLint dstX1,GrGLint dstY1,GrGLbitfield mask,GrGLenum filter)411 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLBlitFramebuffer(GrGLint srcX0,
412                                                    GrGLint srcY0,
413                                                    GrGLint srcX1,
414                                                    GrGLint srcY1,
415                                                    GrGLint dstX0,
416                                                    GrGLint dstY0,
417                                                    GrGLint dstX1,
418                                                    GrGLint dstY1,
419                                                    GrGLbitfield mask,
420                                                    GrGLenum filter) {
421 }
422 
noOpGLResolveMultisampleFramebuffer()423 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLResolveMultisampleFramebuffer() {
424 }
425 
noOpGLBindFragDataLocationIndexed(GrGLuint program,GrGLuint colorNumber,GrGLuint index,const GrGLchar * name)426 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLBindFragDataLocationIndexed(GrGLuint program,
427                                                                GrGLuint colorNumber,
428                                                                GrGLuint index,
429                                                                const GrGLchar * name) {
430 }
431 
noOpGLCheckFramebufferStatus(GrGLenum target)432 GrGLenum GR_GL_FUNCTION_TYPE noOpGLCheckFramebufferStatus(GrGLenum target) {
433 
434     GrAlwaysAssert(GR_GL_FRAMEBUFFER == target);
435 
436     return GR_GL_FRAMEBUFFER_COMPLETE;
437 }
438 
noOpGLGenIds(GrGLsizei n,GrGLuint * ids)439 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLGenIds(GrGLsizei n, GrGLuint* ids) {
440     static int gCurrID = 1;
441     for (int i = 0; i < n; ++i) {
442         ids[i] = ++gCurrID;
443    }
444 }
445 
noOpGLDeleteIds(GrGLsizei n,const GrGLuint * ids)446 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLDeleteIds(GrGLsizei n, const GrGLuint* ids) {
447 }
448 
noOpGLGetError()449 GrGLenum GR_GL_FUNCTION_TYPE noOpGLGetError() {
450     return GR_GL_NO_ERROR;
451 }
452 
noOpGLGetIntegerv(GrGLenum pname,GrGLint * params)453 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLGetIntegerv(GrGLenum pname, GrGLint* params) {
454     // TODO: remove from Ganesh the #defines for gets we don't use.
455     // We would like to minimize gets overall due to performance issues
456     switch (pname) {
457         case GR_GL_CONTEXT_PROFILE_MASK:
458             *params = GR_GL_CONTEXT_COMPATIBILITY_PROFILE_BIT;
459             break;
460         case GR_GL_STENCIL_BITS:
461             *params = 8;
462             break;
463         case GR_GL_SAMPLES:
464             *params = 1;
465             break;
466         case GR_GL_FRAMEBUFFER_BINDING:
467             *params = 0;
468             break;
469         case GR_GL_VIEWPORT:
470             params[0] = 0;
471             params[1] = 0;
472             params[2] = 800;
473             params[3] = 600;
474             break;
475         case GR_GL_MAX_TEXTURE_IMAGE_UNITS:
476             *params = 8;
477             break;
478         case GR_GL_MAX_TEXTURE_COORDS:
479             *params = 8;
480             break;
481         case GR_GL_MAX_VERTEX_UNIFORM_VECTORS:
482             *params = kDefaultMaxVertexUniformVectors;
483             break;
484         case GR_GL_MAX_FRAGMENT_UNIFORM_VECTORS:
485             *params = kDefaultMaxFragmentUniformVectors;
486             break;
487         case GR_GL_MAX_FRAGMENT_UNIFORM_COMPONENTS:
488             *params = 16 * 4;
489             break;
490         case GR_GL_NUM_COMPRESSED_TEXTURE_FORMATS:
491             *params = 0;
492             break;
493         case GR_GL_COMPRESSED_TEXTURE_FORMATS:
494             break;
495         case GR_GL_MAX_TEXTURE_SIZE:
496             *params = 8192;
497             break;
498         case GR_GL_MAX_RENDERBUFFER_SIZE:
499             *params = 8192;
500             break;
501         case GR_GL_MAX_SAMPLES:
502             *params = 32;
503             break;
504         case GR_GL_MAX_VERTEX_ATTRIBS:
505             *params = kDefaultMaxVertexAttribs;
506             break;
507         case GR_GL_MAX_VARYING_VECTORS:
508             *params = kDefaultMaxVaryingVectors;
509             break;
510         case GR_GL_NUM_EXTENSIONS:
511             *params = SK_ARRAY_COUNT(kExtensions);
512             break;
513         default:
514             SkFAIL("Unexpected pname to GetIntegerv");
515    }
516 }
517 
noOpGLGetInfoLog(GrGLuint program,GrGLsizei bufsize,GrGLsizei * length,char * infolog)518 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLGetInfoLog(GrGLuint program,
519                                               GrGLsizei bufsize,
520                                               GrGLsizei* length,
521                                               char* infolog) {
522     if (length) {
523         *length = 0;
524    }
525     if (bufsize > 0) {
526         *infolog = 0;
527    }
528 }
529 
noOpGLGetShaderOrProgramiv(GrGLuint program,GrGLenum pname,GrGLint * params)530 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLGetShaderOrProgramiv(GrGLuint program,
531                                                         GrGLenum pname,
532                                                         GrGLint* params) {
533     switch (pname) {
534         case GR_GL_LINK_STATUS:  // fallthru
535         case GR_GL_COMPILE_STATUS:
536             *params = GR_GL_TRUE;
537             break;
538         case GR_GL_INFO_LOG_LENGTH:
539             *params = 0;
540             break;
541         // we don't expect any other pnames
542         default:
543             SkFAIL("Unexpected pname to GetProgramiv");
544             break;
545    }
546 }
547 
548 namespace {
549 template <typename T>
query_result(GrGLenum GLtarget,GrGLenum pname,T * params)550 void query_result(GrGLenum GLtarget, GrGLenum pname, T *params) {
551     switch (pname) {
552         case GR_GL_QUERY_RESULT_AVAILABLE:
553             *params = GR_GL_TRUE;
554             break;
555         case GR_GL_QUERY_RESULT:
556             *params = 0;
557             break;
558         default:
559             SkFAIL("Unexpected pname passed to GetQueryObject.");
560             break;
561    }
562 }
563 }
564 
noOpGLGetQueryiv(GrGLenum GLtarget,GrGLenum pname,GrGLint * params)565 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLGetQueryiv(GrGLenum GLtarget,
566                                               GrGLenum pname,
567                                               GrGLint *params) {
568     switch (pname) {
569         case GR_GL_CURRENT_QUERY:
570             *params = 0;
571             break;
572         case GR_GL_QUERY_COUNTER_BITS:
573             *params = 32;
574             break;
575         default:
576             SkFAIL("Unexpected pname passed GetQueryiv.");
577    }
578 }
579 
noOpGLGetQueryObjecti64v(GrGLuint id,GrGLenum pname,GrGLint64 * params)580 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLGetQueryObjecti64v(GrGLuint id,
581                                                       GrGLenum pname,
582                                                       GrGLint64 *params) {
583     query_result(id, pname, params);
584 }
585 
noOpGLGetQueryObjectiv(GrGLuint id,GrGLenum pname,GrGLint * params)586 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLGetQueryObjectiv(GrGLuint id,
587                                                     GrGLenum pname,
588                                                     GrGLint *params) {
589     query_result(id, pname, params);
590 }
591 
noOpGLGetQueryObjectui64v(GrGLuint id,GrGLenum pname,GrGLuint64 * params)592 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLGetQueryObjectui64v(GrGLuint id,
593                                                        GrGLenum pname,
594                                                        GrGLuint64 *params) {
595     query_result(id, pname, params);
596 }
597 
noOpGLGetQueryObjectuiv(GrGLuint id,GrGLenum pname,GrGLuint * params)598 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLGetQueryObjectuiv(GrGLuint id,
599                                                      GrGLenum pname,
600                                                      GrGLuint *params) {
601     query_result(id, pname, params);
602 }
603 
noOpGLGetString(GrGLenum name)604 const GrGLubyte* GR_GL_FUNCTION_TYPE noOpGLGetString(GrGLenum name) {
605     switch (name) {
606         case GR_GL_EXTENSIONS:
607             return combined_extensions_string();
608         case GR_GL_VERSION:
609             return (const GrGLubyte*)"4.0 Debug GL";
610         case GR_GL_SHADING_LANGUAGE_VERSION:
611             return (const GrGLubyte*)"4.20.8 Debug GLSL";
612         case GR_GL_VENDOR:
613             return (const GrGLubyte*)"Debug Vendor";
614         case GR_GL_RENDERER:
615             return (const GrGLubyte*)"The Debug (Non-)Renderer";
616         default:
617             SkFAIL("Unexpected name passed to GetString");
618             return NULL;
619    }
620 }
621 
noOpGLGetStringi(GrGLenum name,GrGLuint i)622 const GrGLubyte* GR_GL_FUNCTION_TYPE noOpGLGetStringi(GrGLenum name, GrGLuint i) {
623     switch (name) {
624         case GR_GL_EXTENSIONS:
625             if (static_cast<size_t>(i) <= SK_ARRAY_COUNT(kExtensions)) {
626                 return (const GrGLubyte*) kExtensions[i];
627             } else {
628                 return NULL;
629             }
630         default:
631             SkFAIL("Unexpected name passed to GetStringi");
632             return NULL;
633     }
634 }
635 
noOpGLGetTexLevelParameteriv(GrGLenum target,GrGLint level,GrGLenum pname,GrGLint * params)636 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLGetTexLevelParameteriv(GrGLenum target,
637                                                           GrGLint level,
638                                                           GrGLenum pname,
639                                                           GrGLint* params) {
640     // we used to use this to query stuff about externally created textures,
641     // now we just require clients to tell us everything about the texture.
642     SkFAIL("Should never query texture parameters.");
643 }
644 
noOpGLGetUniformLocation(GrGLuint program,const char * name)645 GrGLint GR_GL_FUNCTION_TYPE noOpGLGetUniformLocation(GrGLuint program, const char* name) {
646     static int gUniLocation = 0;
647     return ++gUniLocation;
648 }
649 
noOpGLInsertEventMarker(GrGLsizei length,const char * marker)650 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLInsertEventMarker(GrGLsizei length, const char* marker) {
651 }
noOpGLPushGroupMarker(GrGLsizei length,const char * marker)652 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLPushGroupMarker(GrGLsizei length  , const char* marker) {
653 }
noOpGLPopGroupMarker()654 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLPopGroupMarker() {
655 }
656