gfx/skia/trunk/src/gpu/gl/GrGLNoOpInterface.h

Wed, 31 Dec 2014 06:09:35 +0100

author
Michael Schloh von Bennewitz <michael@schloh.com>
date
Wed, 31 Dec 2014 06:09:35 +0100
changeset 0
6474c204b198
permissions
-rw-r--r--

Cloned upstream origin tor-browser at tor-browser-31.3.0esr-4.5-1-build1
revision ID fc1c9ff7c1b2defdbc039f12214767608f46423f for hacking purpose.

     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  */
     8 #ifndef GrGLNoOpInterface_DEFINED
     9 #define GrGLNoOpInterface_DEFINED
    11 #include "gl/GrGLDefines.h"
    12 #include "gl/GrGLFunctions.h"
    14 // These are constants/functions that are common to the Null and Debug GL interface implementations.
    16 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLBlendColor(GrGLclampf red,
    17                                               GrGLclampf green,
    18                                               GrGLclampf blue,
    19                                               GrGLclampf alpha);
    21 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLBindFragDataLocation(GrGLuint program,
    22                                                         GrGLuint colorNumber,
    23                                                         const GrGLchar* name);
    25 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLBlendFunc(GrGLenum sfactor,
    26                                              GrGLenum dfactor);
    28 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLBufferSubData(GrGLenum target,
    29                                                  GrGLintptr offset,
    30                                                  GrGLsizeiptr size,
    31                                                  const GrGLvoid* data);
    33 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLClear(GrGLbitfield mask);
    35 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLClearColor(GrGLclampf red,
    36                                               GrGLclampf green,
    37                                               GrGLclampf blue,
    38                                               GrGLclampf alpha);
    40 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLClearStencil(GrGLint s);
    42 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLColorMask(GrGLboolean red,
    43                                              GrGLboolean green,
    44                                              GrGLboolean blue,
    45                                              GrGLboolean alpha);
    47 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLCompileShader(GrGLuint shader);
    49 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLCompressedTexImage2D(GrGLenum target,
    50                                                         GrGLint level,
    51                                                         GrGLenum internalformat,
    52                                                         GrGLsizei width,
    53                                                         GrGLsizei height,
    54                                                         GrGLint border,
    55                                                         GrGLsizei imageSize,
    56                                                         const GrGLvoid* data);
    58 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLCopyTexSubImage2D(GrGLenum target,
    59                                                      GrGLint level,
    60                                                      GrGLint xoffset,
    61                                                      GrGLint yoffset,
    62                                                      GrGLint x,
    63                                                      GrGLint y,
    64                                                      GrGLsizei width,
    65                                                      GrGLsizei height);
    67 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLCullFace(GrGLenum mode);
    69 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLDepthMask(GrGLboolean flag);
    71 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLDisable(GrGLenum cap);
    73 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLDisableVertexAttribArray(GrGLuint index);
    75 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLDrawArrays(GrGLenum mode, GrGLint first, GrGLsizei count);
    77 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLDrawBuffer(GrGLenum mode);
    79 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLDrawBuffers(GrGLsizei n,
    80                                                 const GrGLenum* bufs);
    82 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLDrawElements(GrGLenum mode,
    83                                                 GrGLsizei count,
    84                                                 GrGLenum type,
    85                                                 const GrGLvoid* indices);
    87 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLEnable(GrGLenum cap);
    89 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLEnableVertexAttribArray(GrGLuint index);
    91 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLEndQuery(GrGLenum target);
    93 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLFinish();
    95 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLFlush();
    97 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLFrontFace(GrGLenum mode);
    99 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLLoadIdentity();
   101 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLLoadMatrixf(const GrGLfloat*);
   103 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLLineWidth(GrGLfloat width);
   105 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLLinkProgram(GrGLuint program);
   107 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLMatrixMode(GrGLenum);
   109 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLQueryCounter(GrGLuint id,
   110                                                 GrGLenum target);
   112 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLReadBuffer(GrGLenum src);
   114 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLScissor(GrGLint x,
   115                                            GrGLint y,
   116                                            GrGLsizei width,
   117                                            GrGLsizei height);
   119 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLShaderSource(GrGLuint shader,
   120                                                 GrGLsizei count,
   121 #if GR_GL_USE_NEW_SHADER_SOURCE_SIGNATURE
   122                                                 const char* const * str,
   123 #else
   124                                                 const char** str,
   125 #endif
   126                                                 const GrGLint* length);
   128 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLStencilFunc(GrGLenum func, GrGLint ref, GrGLuint mask);
   130 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLStencilFuncSeparate(GrGLenum face,
   131                                                        GrGLenum func,
   132                                                        GrGLint ref,
   133                                                        GrGLuint mask);
   135 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLStencilMask(GrGLuint mask);
   137 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLStencilMaskSeparate(GrGLenum face, GrGLuint mask);
   139 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLStencilOp(GrGLenum fail, GrGLenum zfail, GrGLenum zpass);
   141 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLStencilOpSeparate(GrGLenum face,
   142                                                      GrGLenum fail,
   143                                                      GrGLenum zfail,
   144                                                      GrGLenum zpass);
   146 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLTexImage2D(GrGLenum target,
   147                                               GrGLint level,
   148                                               GrGLint internalformat,
   149                                               GrGLsizei width,
   150                                               GrGLsizei height,
   151                                               GrGLint border,
   152                                               GrGLenum format,
   153                                               GrGLenum type,
   154                                               const GrGLvoid* pixels);
   156 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLTexParameteri(GrGLenum target, GrGLenum pname, GrGLint param);
   158 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLTexParameteriv(GrGLenum target,
   159                                                   GrGLenum pname,
   160                                                   const GrGLint* params);
   162 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLTexStorage2D(GrGLenum target,
   163                                                 GrGLsizei levels,
   164                                                 GrGLenum internalformat,
   165                                                 GrGLsizei width,
   166                                                 GrGLsizei height);
   168 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLTexGenf(GrGLenum, GrGLenum, GrGLfloat);
   170 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLTexGenfv(GrGLenum, GrGLenum, const GrGLfloat*);
   172 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLTexGeni(GrGLenum, GrGLenum, GrGLint);
   174 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLDiscardFramebuffer(GrGLenum target,
   175                                                       GrGLsizei numAttachments,
   176                                                       const GrGLenum* attachments);
   178 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLTexSubImage2D(GrGLenum target,
   179                                                  GrGLint level,
   180                                                  GrGLint xoffset,
   181                                                  GrGLint yoffset,
   182                                                  GrGLsizei width,
   183                                                  GrGLsizei height,
   184                                                  GrGLenum format,
   185                                                  GrGLenum type,
   186                                                  const GrGLvoid* pixels);
   188 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLUniform1f(GrGLint location, GrGLfloat v0);
   190 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLUniform1i(GrGLint location, GrGLint v0);
   192 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLUniform1fv(GrGLint location,
   193                                               GrGLsizei count,
   194                                               const GrGLfloat* v);
   196 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLUniform1iv(GrGLint location,
   197                                               GrGLsizei count,
   198                                               const GrGLint* v);
   200 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLUniform2f(GrGLint location,
   201                                              GrGLfloat v0,
   202                                              GrGLfloat v1);
   204 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLUniform2i(GrGLint location, GrGLint v0, GrGLint v1);
   206 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLUniform2fv(GrGLint location,
   207                                               GrGLsizei count,
   208                                               const GrGLfloat* v);
   210 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLUniform2iv(GrGLint location,
   211                                               GrGLsizei count,
   212                                               const GrGLint* v);
   214 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLUniform3f(GrGLint location,
   215                                              GrGLfloat v0,
   216                                              GrGLfloat v1,
   217                                              GrGLfloat v2);
   219 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLUniform3i(GrGLint location,
   220                                              GrGLint v0,
   221                                              GrGLint v1,
   222                                              GrGLint v2);
   224 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLUniform3fv(GrGLint location,
   225                                               GrGLsizei count,
   226                                               const GrGLfloat* v);
   228 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLUniform3iv(GrGLint location,
   229                                                GrGLsizei count,
   230                                                const GrGLint* v);
   232 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLUniform4f(GrGLint location,
   233                                               GrGLfloat v0,
   234                                               GrGLfloat v1,
   235                                               GrGLfloat v2,
   236                                               GrGLfloat v3);
   238 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLUniform4i(GrGLint location,
   239                                              GrGLint v0,
   240                                              GrGLint v1,
   241                                              GrGLint v2,
   242                                              GrGLint v3);
   244 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLUniform4fv(GrGLint location,
   245                                               GrGLsizei count,
   246                                               const GrGLfloat* v);
   248 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLUniform4iv(GrGLint location,
   249                                               GrGLsizei count,
   250                                               const GrGLint* v);
   252 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLUniformMatrix2fv(GrGLint location,
   253                                                     GrGLsizei count,
   254                                                     GrGLboolean transpose,
   255                                                     const GrGLfloat* value);
   257 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLUniformMatrix3fv(GrGLint location,
   258                                                     GrGLsizei count,
   259                                                     GrGLboolean transpose,
   260                                                     const GrGLfloat* value);
   262 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLUniformMatrix4fv(GrGLint location,
   263                                                     GrGLsizei count,
   264                                                     GrGLboolean transpose,
   265                                                     const GrGLfloat* value);
   267  GrGLvoid GR_GL_FUNCTION_TYPE noOpGLVertexAttrib4fv(GrGLuint indx, const GrGLfloat* values);
   269 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLVertexAttribPointer(GrGLuint indx,
   270                                                        GrGLint size,
   271                                                        GrGLenum type,
   272                                                        GrGLboolean normalized,
   273                                                        GrGLsizei stride,
   274                                                        const GrGLvoid* ptr);
   276 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLViewport(GrGLint x,
   277                                             GrGLint y,
   278                                             GrGLsizei width,
   279                                             GrGLsizei height);
   281   GrGLvoid GR_GL_FUNCTION_TYPE noOpGLGetFramebufferAttachmentParameteriv(GrGLenum target,
   282                                                                          GrGLenum attachment,
   283                                                                          GrGLenum pname,
   284                                                                          GrGLint* params);
   286 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLGetRenderbufferParameteriv(GrGLenum target,
   287                                                               GrGLenum pname,
   288                                                               GrGLint* params);
   290 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLRenderbufferStorage(GrGLenum target,
   291                                                        GrGLenum internalformat,
   292                                                        GrGLsizei width,
   293                                                        GrGLsizei height);
   295 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLRenderbufferStorageMultisample(GrGLenum target,
   296                                                                   GrGLsizei samples,
   297                                                                   GrGLenum internalformat,
   298                                                                   GrGLsizei width,
   299                                                                   GrGLsizei height);
   301 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLBlitFramebuffer(GrGLint srcX0,
   302                                                    GrGLint srcY0,
   303                                                    GrGLint srcX1,
   304                                                    GrGLint srcY1,
   305                                                    GrGLint dstX0,
   306                                                    GrGLint dstY0,
   307                                                    GrGLint dstX1,
   308                                                    GrGLint dstY1,
   309                                                    GrGLbitfield mask,
   310                                                    GrGLenum filter);
   312 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLResolveMultisampleFramebuffer();
   314 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLBindFragDataLocationIndexed(GrGLuint program,
   315                                                                GrGLuint colorNumber,
   316                                                                GrGLuint index,
   317                                                                const GrGLchar * name);
   319 GrGLenum GR_GL_FUNCTION_TYPE noOpGLCheckFramebufferStatus(GrGLenum target);
   321 // this function can be used for all glGen*(GLsize i, GLuint*) functions
   322 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLGenIds(GrGLsizei n, GrGLuint* ids);
   324 // this function function can be used for all glDelete*(GLsize i, const GLuint*)
   325 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLDeleteIds(GrGLsizei n, const GrGLuint* ids);
   327 GrGLenum GR_GL_FUNCTION_TYPE noOpGLGetError();
   329 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLGetIntegerv(GrGLenum pname, GrGLint* params);
   331 // can be used for both the program and shader info logs
   332 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLGetInfoLog(GrGLuint program,
   333                                               GrGLsizei bufsize,
   334                                               GrGLsizei* length,
   335                                               char* infolog);
   337 // can be used for both the program and shader params
   338 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLGetShaderOrProgramiv(GrGLuint program,
   339                                                         GrGLenum pname,
   340                                                         GrGLint* params);
   342 // Queries on bogus GLs just don't do anything at all. We could potentially make the timers work.
   343 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLGetQueryiv(GrGLenum GLtarget,
   344                                               GrGLenum pname,
   345                                               GrGLint *params);
   347 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLGetQueryObjecti64v(GrGLuint id,
   348                                                       GrGLenum pname,
   349                                                       GrGLint64 *params);
   351 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLGetQueryObjectiv(GrGLuint id, GrGLenum pname, GrGLint *params);
   353 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLGetQueryObjectui64v(GrGLuint id,
   354                                                        GrGLenum pname,
   355                                                        GrGLuint64 *params);
   357 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLGetQueryObjectuiv(GrGLuint id,
   358                                                      GrGLenum pname,
   359                                                      GrGLuint *params);
   361 const GrGLubyte* GR_GL_FUNCTION_TYPE noOpGLGetString(GrGLenum name);
   363 const GrGLubyte* GR_GL_FUNCTION_TYPE noOpGLGetStringi(GrGLenum name, GrGLuint i);
   365 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLGetTexLevelParameteriv(GrGLenum target,
   366                                                           GrGLint level,
   367                                                           GrGLenum pname,
   368                                                           GrGLint* params);
   370 GrGLint GR_GL_FUNCTION_TYPE noOpGLGetUniformLocation(GrGLuint program, const char* name);
   372 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLInsertEventMarker(GrGLsizei length, const char* marker);
   373 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLPushGroupMarker(GrGLsizei length  , const char* marker);
   374 GrGLvoid GR_GL_FUNCTION_TYPE noOpGLPopGroupMarker();
   376 #endif

mercurial