Jarkko Poyry | 3c82736 | 2014-09-02 11:48:52 +0300 | [diff] [blame] | 1 | /* WARNING: This is auto-generated file. Do not modify, since changes will |
| 2 | * be lost! Modify the generating script instead. |
Pyry Haulos | 1abab60 | 2014-11-05 17:41:42 -0800 | [diff] [blame] | 3 | * |
Alexander Galazin | e4b6ab9 | 2016-11-29 15:14:44 +0100 | [diff] [blame] | 4 | * Generated from Khronos GL API description (gl.xml) revision 33312. |
Jarkko Poyry | 3c82736 | 2014-09-02 11:48:52 +0300 | [diff] [blame] | 5 | */ |
| 6 | |
Pyry Haulos | 1abab60 | 2014-11-05 17:41:42 -0800 | [diff] [blame] | 7 | void glwActiveShaderProgram (GLuint pipeline, GLuint program) |
Jarkko Poyry | 3c82736 | 2014-09-02 11:48:52 +0300 | [diff] [blame] | 8 | { |
| 9 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 10 | if (!gl) |
Pyry Haulos | 1abab60 | 2014-11-05 17:41:42 -0800 | [diff] [blame] | 11 | return; |
| 12 | gl->activeShaderProgram(pipeline, program); |
Jarkko Poyry | 3c82736 | 2014-09-02 11:48:52 +0300 | [diff] [blame] | 13 | } |
| 14 | |
Pyry Haulos | 1abab60 | 2014-11-05 17:41:42 -0800 | [diff] [blame] | 15 | void glwActiveTexture (GLenum texture) |
Jarkko Poyry | 3c82736 | 2014-09-02 11:48:52 +0300 | [diff] [blame] | 16 | { |
| 17 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 18 | if (!gl) |
Pyry Haulos | 1abab60 | 2014-11-05 17:41:42 -0800 | [diff] [blame] | 19 | return; |
| 20 | gl->activeTexture(texture); |
Jarkko Poyry | 3c82736 | 2014-09-02 11:48:52 +0300 | [diff] [blame] | 21 | } |
| 22 | |
Pyry Haulos | 1abab60 | 2014-11-05 17:41:42 -0800 | [diff] [blame] | 23 | void glwAttachShader (GLuint program, GLuint shader) |
Jarkko Poyry | 3c82736 | 2014-09-02 11:48:52 +0300 | [diff] [blame] | 24 | { |
| 25 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 26 | if (!gl) |
Pyry Haulos | 1abab60 | 2014-11-05 17:41:42 -0800 | [diff] [blame] | 27 | return; |
| 28 | gl->attachShader(program, shader); |
Jarkko Poyry | 3c82736 | 2014-09-02 11:48:52 +0300 | [diff] [blame] | 29 | } |
| 30 | |
Pyry Haulos | 1abab60 | 2014-11-05 17:41:42 -0800 | [diff] [blame] | 31 | void glwBeginConditionalRender (GLuint id, GLenum mode) |
Jarkko Poyry | 3c82736 | 2014-09-02 11:48:52 +0300 | [diff] [blame] | 32 | { |
| 33 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 34 | if (!gl) |
Pyry Haulos | 1abab60 | 2014-11-05 17:41:42 -0800 | [diff] [blame] | 35 | return; |
| 36 | gl->beginConditionalRender(id, mode); |
Jarkko Poyry | 3c82736 | 2014-09-02 11:48:52 +0300 | [diff] [blame] | 37 | } |
| 38 | |
Pyry Haulos | 1abab60 | 2014-11-05 17:41:42 -0800 | [diff] [blame] | 39 | void glwBeginQuery (GLenum target, GLuint id) |
Jarkko Poyry | 3c82736 | 2014-09-02 11:48:52 +0300 | [diff] [blame] | 40 | { |
| 41 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 42 | if (!gl) |
Pyry Haulos | 1abab60 | 2014-11-05 17:41:42 -0800 | [diff] [blame] | 43 | return; |
| 44 | gl->beginQuery(target, id); |
Jarkko Poyry | 3c82736 | 2014-09-02 11:48:52 +0300 | [diff] [blame] | 45 | } |
| 46 | |
Pyry Haulos | 1abab60 | 2014-11-05 17:41:42 -0800 | [diff] [blame] | 47 | void glwBeginQueryIndexed (GLenum target, GLuint index, GLuint id) |
Jarkko Poyry | 3c82736 | 2014-09-02 11:48:52 +0300 | [diff] [blame] | 48 | { |
| 49 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 50 | if (!gl) |
Pyry Haulos | 1abab60 | 2014-11-05 17:41:42 -0800 | [diff] [blame] | 51 | return; |
| 52 | gl->beginQueryIndexed(target, index, id); |
Jarkko Poyry | 3c82736 | 2014-09-02 11:48:52 +0300 | [diff] [blame] | 53 | } |
| 54 | |
Pyry Haulos | 1abab60 | 2014-11-05 17:41:42 -0800 | [diff] [blame] | 55 | void glwBeginTransformFeedback (GLenum primitiveMode) |
Jarkko Poyry | 3c82736 | 2014-09-02 11:48:52 +0300 | [diff] [blame] | 56 | { |
| 57 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 58 | if (!gl) |
Pyry Haulos | 1abab60 | 2014-11-05 17:41:42 -0800 | [diff] [blame] | 59 | return; |
| 60 | gl->beginTransformFeedback(primitiveMode); |
Jarkko Poyry | 3c82736 | 2014-09-02 11:48:52 +0300 | [diff] [blame] | 61 | } |
| 62 | |
Pyry Haulos | 1abab60 | 2014-11-05 17:41:42 -0800 | [diff] [blame] | 63 | void glwBindAttribLocation (GLuint program, GLuint index, const GLchar *name) |
Jarkko Poyry | 3c82736 | 2014-09-02 11:48:52 +0300 | [diff] [blame] | 64 | { |
| 65 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 66 | if (!gl) |
Pyry Haulos | 1abab60 | 2014-11-05 17:41:42 -0800 | [diff] [blame] | 67 | return; |
| 68 | gl->bindAttribLocation(program, index, name); |
Jarkko Poyry | 3c82736 | 2014-09-02 11:48:52 +0300 | [diff] [blame] | 69 | } |
| 70 | |
Pyry Haulos | 1abab60 | 2014-11-05 17:41:42 -0800 | [diff] [blame] | 71 | void glwBindBuffer (GLenum target, GLuint buffer) |
Jarkko Poyry | 3c82736 | 2014-09-02 11:48:52 +0300 | [diff] [blame] | 72 | { |
| 73 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 74 | if (!gl) |
Pyry Haulos | 1abab60 | 2014-11-05 17:41:42 -0800 | [diff] [blame] | 75 | return; |
| 76 | gl->bindBuffer(target, buffer); |
Jarkko Poyry | 3c82736 | 2014-09-02 11:48:52 +0300 | [diff] [blame] | 77 | } |
| 78 | |
Pyry Haulos | 1abab60 | 2014-11-05 17:41:42 -0800 | [diff] [blame] | 79 | void glwBindBufferBase (GLenum target, GLuint index, GLuint buffer) |
Jarkko Poyry | 3c82736 | 2014-09-02 11:48:52 +0300 | [diff] [blame] | 80 | { |
| 81 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 82 | if (!gl) |
Pyry Haulos | 1abab60 | 2014-11-05 17:41:42 -0800 | [diff] [blame] | 83 | return; |
| 84 | gl->bindBufferBase(target, index, buffer); |
Jarkko Poyry | 3c82736 | 2014-09-02 11:48:52 +0300 | [diff] [blame] | 85 | } |
| 86 | |
Pyry Haulos | 1abab60 | 2014-11-05 17:41:42 -0800 | [diff] [blame] | 87 | void glwBindBufferRange (GLenum target, GLuint index, GLuint buffer, GLintptr offset, GLsizeiptr size) |
Jarkko Poyry | 3c82736 | 2014-09-02 11:48:52 +0300 | [diff] [blame] | 88 | { |
| 89 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 90 | if (!gl) |
Pyry Haulos | 1abab60 | 2014-11-05 17:41:42 -0800 | [diff] [blame] | 91 | return; |
| 92 | gl->bindBufferRange(target, index, buffer, offset, size); |
Jarkko Poyry | 3c82736 | 2014-09-02 11:48:52 +0300 | [diff] [blame] | 93 | } |
| 94 | |
Pyry Haulos | 1abab60 | 2014-11-05 17:41:42 -0800 | [diff] [blame] | 95 | void glwBindBuffersBase (GLenum target, GLuint first, GLsizei count, const GLuint *buffers) |
Jarkko Poyry | 3c82736 | 2014-09-02 11:48:52 +0300 | [diff] [blame] | 96 | { |
| 97 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 98 | if (!gl) |
Pyry Haulos | 1abab60 | 2014-11-05 17:41:42 -0800 | [diff] [blame] | 99 | return; |
| 100 | gl->bindBuffersBase(target, first, count, buffers); |
Jarkko Poyry | 3c82736 | 2014-09-02 11:48:52 +0300 | [diff] [blame] | 101 | } |
| 102 | |
Pyry Haulos | 1abab60 | 2014-11-05 17:41:42 -0800 | [diff] [blame] | 103 | void glwBindBuffersRange (GLenum target, GLuint first, GLsizei count, const GLuint *buffers, const GLintptr *offsets, const GLsizeiptr *sizes) |
Jarkko Poyry | 3c82736 | 2014-09-02 11:48:52 +0300 | [diff] [blame] | 104 | { |
| 105 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 106 | if (!gl) |
Pyry Haulos | 1abab60 | 2014-11-05 17:41:42 -0800 | [diff] [blame] | 107 | return; |
| 108 | gl->bindBuffersRange(target, first, count, buffers, offsets, sizes); |
Jarkko Poyry | 3c82736 | 2014-09-02 11:48:52 +0300 | [diff] [blame] | 109 | } |
| 110 | |
Pyry Haulos | 1abab60 | 2014-11-05 17:41:42 -0800 | [diff] [blame] | 111 | void glwBindFragDataLocation (GLuint program, GLuint color, const GLchar *name) |
Jarkko Poyry | 3c82736 | 2014-09-02 11:48:52 +0300 | [diff] [blame] | 112 | { |
| 113 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 114 | if (!gl) |
Pyry Haulos | 1abab60 | 2014-11-05 17:41:42 -0800 | [diff] [blame] | 115 | return; |
| 116 | gl->bindFragDataLocation(program, color, name); |
Jarkko Poyry | 3c82736 | 2014-09-02 11:48:52 +0300 | [diff] [blame] | 117 | } |
| 118 | |
Pyry Haulos | 1abab60 | 2014-11-05 17:41:42 -0800 | [diff] [blame] | 119 | void glwBindFragDataLocationIndexed (GLuint program, GLuint colorNumber, GLuint index, const GLchar *name) |
Jarkko Poyry | 3c82736 | 2014-09-02 11:48:52 +0300 | [diff] [blame] | 120 | { |
| 121 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 122 | if (!gl) |
Pyry Haulos | 1abab60 | 2014-11-05 17:41:42 -0800 | [diff] [blame] | 123 | return; |
| 124 | gl->bindFragDataLocationIndexed(program, colorNumber, index, name); |
Jarkko Poyry | 3c82736 | 2014-09-02 11:48:52 +0300 | [diff] [blame] | 125 | } |
| 126 | |
Pyry Haulos | 1abab60 | 2014-11-05 17:41:42 -0800 | [diff] [blame] | 127 | void glwBindFramebuffer (GLenum target, GLuint framebuffer) |
Jarkko Poyry | 3c82736 | 2014-09-02 11:48:52 +0300 | [diff] [blame] | 128 | { |
| 129 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 130 | if (!gl) |
Pyry Haulos | 1abab60 | 2014-11-05 17:41:42 -0800 | [diff] [blame] | 131 | return; |
| 132 | gl->bindFramebuffer(target, framebuffer); |
Jarkko Poyry | 3c82736 | 2014-09-02 11:48:52 +0300 | [diff] [blame] | 133 | } |
| 134 | |
Pyry Haulos | 1abab60 | 2014-11-05 17:41:42 -0800 | [diff] [blame] | 135 | void glwBindImageTexture (GLuint unit, GLuint texture, GLint level, GLboolean layered, GLint layer, GLenum access, GLenum format) |
Jarkko Poyry | 3c82736 | 2014-09-02 11:48:52 +0300 | [diff] [blame] | 136 | { |
| 137 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 138 | if (!gl) |
Pyry Haulos | 1abab60 | 2014-11-05 17:41:42 -0800 | [diff] [blame] | 139 | return; |
| 140 | gl->bindImageTexture(unit, texture, level, layered, layer, access, format); |
Jarkko Poyry | 3c82736 | 2014-09-02 11:48:52 +0300 | [diff] [blame] | 141 | } |
| 142 | |
Pyry Haulos | 1abab60 | 2014-11-05 17:41:42 -0800 | [diff] [blame] | 143 | void glwBindImageTextures (GLuint first, GLsizei count, const GLuint *textures) |
Jarkko Poyry | 3c82736 | 2014-09-02 11:48:52 +0300 | [diff] [blame] | 144 | { |
| 145 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 146 | if (!gl) |
Pyry Haulos | 1abab60 | 2014-11-05 17:41:42 -0800 | [diff] [blame] | 147 | return; |
| 148 | gl->bindImageTextures(first, count, textures); |
Jarkko Poyry | 3c82736 | 2014-09-02 11:48:52 +0300 | [diff] [blame] | 149 | } |
| 150 | |
Pyry Haulos | 933ef4d | 2016-11-14 13:01:12 -0800 | [diff] [blame] | 151 | void glwBindMultiTextureEXT (GLenum texunit, GLenum target, GLuint texture) |
| 152 | { |
| 153 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 154 | if (!gl) |
| 155 | return; |
| 156 | gl->bindMultiTextureEXT(texunit, target, texture); |
| 157 | } |
| 158 | |
Pyry Haulos | 1abab60 | 2014-11-05 17:41:42 -0800 | [diff] [blame] | 159 | void glwBindProgramPipeline (GLuint pipeline) |
Jarkko Poyry | 3c82736 | 2014-09-02 11:48:52 +0300 | [diff] [blame] | 160 | { |
| 161 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 162 | if (!gl) |
Pyry Haulos | 1abab60 | 2014-11-05 17:41:42 -0800 | [diff] [blame] | 163 | return; |
| 164 | gl->bindProgramPipeline(pipeline); |
Jarkko Poyry | 3c82736 | 2014-09-02 11:48:52 +0300 | [diff] [blame] | 165 | } |
| 166 | |
Pyry Haulos | 1abab60 | 2014-11-05 17:41:42 -0800 | [diff] [blame] | 167 | void glwBindRenderbuffer (GLenum target, GLuint renderbuffer) |
Jarkko Poyry | 3c82736 | 2014-09-02 11:48:52 +0300 | [diff] [blame] | 168 | { |
| 169 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 170 | if (!gl) |
Pyry Haulos | 1abab60 | 2014-11-05 17:41:42 -0800 | [diff] [blame] | 171 | return; |
| 172 | gl->bindRenderbuffer(target, renderbuffer); |
Jarkko Poyry | 3c82736 | 2014-09-02 11:48:52 +0300 | [diff] [blame] | 173 | } |
| 174 | |
Pyry Haulos | 1abab60 | 2014-11-05 17:41:42 -0800 | [diff] [blame] | 175 | void glwBindSampler (GLuint unit, GLuint sampler) |
Jarkko Poyry | 3c82736 | 2014-09-02 11:48:52 +0300 | [diff] [blame] | 176 | { |
| 177 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 178 | if (!gl) |
Pyry Haulos | 1abab60 | 2014-11-05 17:41:42 -0800 | [diff] [blame] | 179 | return; |
| 180 | gl->bindSampler(unit, sampler); |
Jarkko Poyry | 3c82736 | 2014-09-02 11:48:52 +0300 | [diff] [blame] | 181 | } |
| 182 | |
Pyry Haulos | 1abab60 | 2014-11-05 17:41:42 -0800 | [diff] [blame] | 183 | void glwBindSamplers (GLuint first, GLsizei count, const GLuint *samplers) |
Jarkko Poyry | 3c82736 | 2014-09-02 11:48:52 +0300 | [diff] [blame] | 184 | { |
| 185 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 186 | if (!gl) |
Pyry Haulos | 1abab60 | 2014-11-05 17:41:42 -0800 | [diff] [blame] | 187 | return; |
| 188 | gl->bindSamplers(first, count, samplers); |
Jarkko Poyry | 3c82736 | 2014-09-02 11:48:52 +0300 | [diff] [blame] | 189 | } |
| 190 | |
| 191 | void glwBindTexture (GLenum target, GLuint texture) |
| 192 | { |
| 193 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 194 | if (!gl) |
Pyry Haulos | 1abab60 | 2014-11-05 17:41:42 -0800 | [diff] [blame] | 195 | return; |
Jarkko Poyry | 3c82736 | 2014-09-02 11:48:52 +0300 | [diff] [blame] | 196 | gl->bindTexture(target, texture); |
| 197 | } |
| 198 | |
Pyry Haulos | 1abab60 | 2014-11-05 17:41:42 -0800 | [diff] [blame] | 199 | void glwBindTextureUnit (GLuint unit, GLuint texture) |
Jarkko Poyry | 3c82736 | 2014-09-02 11:48:52 +0300 | [diff] [blame] | 200 | { |
| 201 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 202 | if (!gl) |
Pyry Haulos | 1abab60 | 2014-11-05 17:41:42 -0800 | [diff] [blame] | 203 | return; |
| 204 | gl->bindTextureUnit(unit, texture); |
Jarkko Poyry | 3c82736 | 2014-09-02 11:48:52 +0300 | [diff] [blame] | 205 | } |
| 206 | |
Pyry Haulos | 1abab60 | 2014-11-05 17:41:42 -0800 | [diff] [blame] | 207 | void glwBindTextures (GLuint first, GLsizei count, const GLuint *textures) |
Jarkko Poyry | 3c82736 | 2014-09-02 11:48:52 +0300 | [diff] [blame] | 208 | { |
| 209 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 210 | if (!gl) |
Pyry Haulos | 1abab60 | 2014-11-05 17:41:42 -0800 | [diff] [blame] | 211 | return; |
| 212 | gl->bindTextures(first, count, textures); |
Jarkko Poyry | 3c82736 | 2014-09-02 11:48:52 +0300 | [diff] [blame] | 213 | } |
| 214 | |
Pyry Haulos | 1abab60 | 2014-11-05 17:41:42 -0800 | [diff] [blame] | 215 | void glwBindTransformFeedback (GLenum target, GLuint id) |
Jarkko Poyry | 3c82736 | 2014-09-02 11:48:52 +0300 | [diff] [blame] | 216 | { |
| 217 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 218 | if (!gl) |
Pyry Haulos | 1abab60 | 2014-11-05 17:41:42 -0800 | [diff] [blame] | 219 | return; |
| 220 | gl->bindTransformFeedback(target, id); |
| 221 | } |
| 222 | |
| 223 | void glwBindVertexArray (GLuint array) |
| 224 | { |
| 225 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 226 | if (!gl) |
| 227 | return; |
| 228 | gl->bindVertexArray(array); |
| 229 | } |
| 230 | |
| 231 | void glwBindVertexBuffer (GLuint bindingindex, GLuint buffer, GLintptr offset, GLsizei stride) |
| 232 | { |
| 233 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 234 | if (!gl) |
| 235 | return; |
| 236 | gl->bindVertexBuffer(bindingindex, buffer, offset, stride); |
| 237 | } |
| 238 | |
| 239 | void glwBindVertexBuffers (GLuint first, GLsizei count, const GLuint *buffers, const GLintptr *offsets, const GLsizei *strides) |
| 240 | { |
| 241 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 242 | if (!gl) |
| 243 | return; |
| 244 | gl->bindVertexBuffers(first, count, buffers, offsets, strides); |
| 245 | } |
| 246 | |
Daniel Andrade Groppe | 485a2d1 | 2015-12-02 15:45:41 -0600 | [diff] [blame] | 247 | void glwBlendBarrier (void) |
Pyry Haulos | 1abab60 | 2014-11-05 17:41:42 -0800 | [diff] [blame] | 248 | { |
| 249 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 250 | if (!gl) |
| 251 | return; |
Daniel Andrade Groppe | 485a2d1 | 2015-12-02 15:45:41 -0600 | [diff] [blame] | 252 | gl->blendBarrier(); |
Jarkko Poyry | 3c82736 | 2014-09-02 11:48:52 +0300 | [diff] [blame] | 253 | } |
| 254 | |
| 255 | void glwBlendColor (GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha) |
| 256 | { |
| 257 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 258 | if (!gl) |
Pyry Haulos | 1abab60 | 2014-11-05 17:41:42 -0800 | [diff] [blame] | 259 | return; |
Jarkko Poyry | 3c82736 | 2014-09-02 11:48:52 +0300 | [diff] [blame] | 260 | gl->blendColor(red, green, blue, alpha); |
| 261 | } |
| 262 | |
| 263 | void glwBlendEquation (GLenum mode) |
| 264 | { |
| 265 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 266 | if (!gl) |
Pyry Haulos | 1abab60 | 2014-11-05 17:41:42 -0800 | [diff] [blame] | 267 | return; |
Jarkko Poyry | 3c82736 | 2014-09-02 11:48:52 +0300 | [diff] [blame] | 268 | gl->blendEquation(mode); |
| 269 | } |
| 270 | |
Jarkko Poyry | 3c82736 | 2014-09-02 11:48:52 +0300 | [diff] [blame] | 271 | void glwBlendEquationSeparate (GLenum modeRGB, GLenum modeAlpha) |
| 272 | { |
| 273 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 274 | if (!gl) |
Pyry Haulos | 1abab60 | 2014-11-05 17:41:42 -0800 | [diff] [blame] | 275 | return; |
Jarkko Poyry | 3c82736 | 2014-09-02 11:48:52 +0300 | [diff] [blame] | 276 | gl->blendEquationSeparate(modeRGB, modeAlpha); |
| 277 | } |
| 278 | |
Jarkko Poyry | 3c82736 | 2014-09-02 11:48:52 +0300 | [diff] [blame] | 279 | void glwBlendEquationSeparatei (GLuint buf, GLenum modeRGB, GLenum modeAlpha) |
| 280 | { |
| 281 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 282 | if (!gl) |
Pyry Haulos | 1abab60 | 2014-11-05 17:41:42 -0800 | [diff] [blame] | 283 | return; |
Jarkko Poyry | 3c82736 | 2014-09-02 11:48:52 +0300 | [diff] [blame] | 284 | gl->blendEquationSeparatei(buf, modeRGB, modeAlpha); |
| 285 | } |
| 286 | |
Pyry Haulos | 1abab60 | 2014-11-05 17:41:42 -0800 | [diff] [blame] | 287 | void glwBlendEquationi (GLuint buf, GLenum mode) |
Jarkko Poyry | 3c82736 | 2014-09-02 11:48:52 +0300 | [diff] [blame] | 288 | { |
| 289 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 290 | if (!gl) |
Pyry Haulos | 1abab60 | 2014-11-05 17:41:42 -0800 | [diff] [blame] | 291 | return; |
| 292 | gl->blendEquationi(buf, mode); |
| 293 | } |
| 294 | |
| 295 | void glwBlendFunc (GLenum sfactor, GLenum dfactor) |
| 296 | { |
| 297 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 298 | if (!gl) |
| 299 | return; |
| 300 | gl->blendFunc(sfactor, dfactor); |
| 301 | } |
| 302 | |
| 303 | void glwBlendFuncSeparate (GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha) |
| 304 | { |
| 305 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 306 | if (!gl) |
| 307 | return; |
| 308 | gl->blendFuncSeparate(sfactorRGB, dfactorRGB, sfactorAlpha, dfactorAlpha); |
Jarkko Poyry | 3c82736 | 2014-09-02 11:48:52 +0300 | [diff] [blame] | 309 | } |
| 310 | |
| 311 | void glwBlendFuncSeparatei (GLuint buf, GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha) |
| 312 | { |
| 313 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 314 | if (!gl) |
Pyry Haulos | 1abab60 | 2014-11-05 17:41:42 -0800 | [diff] [blame] | 315 | return; |
Jarkko Poyry | 3c82736 | 2014-09-02 11:48:52 +0300 | [diff] [blame] | 316 | gl->blendFuncSeparatei(buf, srcRGB, dstRGB, srcAlpha, dstAlpha); |
| 317 | } |
| 318 | |
Pyry Haulos | 1abab60 | 2014-11-05 17:41:42 -0800 | [diff] [blame] | 319 | void glwBlendFunci (GLuint buf, GLenum src, GLenum dst) |
Jarkko Poyry | 3c82736 | 2014-09-02 11:48:52 +0300 | [diff] [blame] | 320 | { |
| 321 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 322 | if (!gl) |
Pyry Haulos | 1abab60 | 2014-11-05 17:41:42 -0800 | [diff] [blame] | 323 | return; |
| 324 | gl->blendFunci(buf, src, dst); |
Jarkko Poyry | 3c82736 | 2014-09-02 11:48:52 +0300 | [diff] [blame] | 325 | } |
| 326 | |
Pyry Haulos | 1abab60 | 2014-11-05 17:41:42 -0800 | [diff] [blame] | 327 | void glwBlitFramebuffer (GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter) |
Jarkko Poyry | 3c82736 | 2014-09-02 11:48:52 +0300 | [diff] [blame] | 328 | { |
| 329 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 330 | if (!gl) |
Pyry Haulos | 1abab60 | 2014-11-05 17:41:42 -0800 | [diff] [blame] | 331 | return; |
| 332 | gl->blitFramebuffer(srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter); |
Jarkko Poyry | 3c82736 | 2014-09-02 11:48:52 +0300 | [diff] [blame] | 333 | } |
| 334 | |
Pyry Haulos | 1abab60 | 2014-11-05 17:41:42 -0800 | [diff] [blame] | 335 | void glwBlitNamedFramebuffer (GLuint readFramebuffer, GLuint drawFramebuffer, GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter) |
Jarkko Poyry | 3c82736 | 2014-09-02 11:48:52 +0300 | [diff] [blame] | 336 | { |
| 337 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 338 | if (!gl) |
Pyry Haulos | 1abab60 | 2014-11-05 17:41:42 -0800 | [diff] [blame] | 339 | return; |
| 340 | gl->blitNamedFramebuffer(readFramebuffer, drawFramebuffer, srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter); |
Jarkko Poyry | 3c82736 | 2014-09-02 11:48:52 +0300 | [diff] [blame] | 341 | } |
| 342 | |
Pyry Haulos | 1abab60 | 2014-11-05 17:41:42 -0800 | [diff] [blame] | 343 | void glwBufferData (GLenum target, GLsizeiptr size, const void *data, GLenum usage) |
Jarkko Poyry | 3c82736 | 2014-09-02 11:48:52 +0300 | [diff] [blame] | 344 | { |
| 345 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 346 | if (!gl) |
Pyry Haulos | 1abab60 | 2014-11-05 17:41:42 -0800 | [diff] [blame] | 347 | return; |
| 348 | gl->bufferData(target, size, data, usage); |
Jarkko Poyry | 3c82736 | 2014-09-02 11:48:52 +0300 | [diff] [blame] | 349 | } |
| 350 | |
Pyry Haulos | 933ef4d | 2016-11-14 13:01:12 -0800 | [diff] [blame] | 351 | void glwBufferPageCommitmentARB (GLenum target, GLintptr offset, GLsizeiptr size, GLboolean commit) |
| 352 | { |
| 353 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 354 | if (!gl) |
| 355 | return; |
| 356 | gl->bufferPageCommitmentARB(target, offset, size, commit); |
| 357 | } |
| 358 | |
Pyry Haulos | 1abab60 | 2014-11-05 17:41:42 -0800 | [diff] [blame] | 359 | void glwBufferStorage (GLenum target, GLsizeiptr size, const void *data, GLbitfield flags) |
Jarkko Poyry | 3c82736 | 2014-09-02 11:48:52 +0300 | [diff] [blame] | 360 | { |
| 361 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 362 | if (!gl) |
Pyry Haulos | 1abab60 | 2014-11-05 17:41:42 -0800 | [diff] [blame] | 363 | return; |
| 364 | gl->bufferStorage(target, size, data, flags); |
Jarkko Poyry | 3c82736 | 2014-09-02 11:48:52 +0300 | [diff] [blame] | 365 | } |
| 366 | |
Pyry Haulos | 1abab60 | 2014-11-05 17:41:42 -0800 | [diff] [blame] | 367 | void glwBufferSubData (GLenum target, GLintptr offset, GLsizeiptr size, const void *data) |
Jarkko Poyry | 3c82736 | 2014-09-02 11:48:52 +0300 | [diff] [blame] | 368 | { |
| 369 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 370 | if (!gl) |
Pyry Haulos | 1abab60 | 2014-11-05 17:41:42 -0800 | [diff] [blame] | 371 | return; |
| 372 | gl->bufferSubData(target, offset, size, data); |
Jarkko Poyry | 3c82736 | 2014-09-02 11:48:52 +0300 | [diff] [blame] | 373 | } |
| 374 | |
Pyry Haulos | 1abab60 | 2014-11-05 17:41:42 -0800 | [diff] [blame] | 375 | GLenum glwCheckFramebufferStatus (GLenum target) |
Jarkko Poyry | 3c82736 | 2014-09-02 11:48:52 +0300 | [diff] [blame] | 376 | { |
| 377 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 378 | if (!gl) |
Pyry Haulos | 1abab60 | 2014-11-05 17:41:42 -0800 | [diff] [blame] | 379 | return (GLenum)0; |
| 380 | return gl->checkFramebufferStatus(target); |
Jarkko Poyry | 3c82736 | 2014-09-02 11:48:52 +0300 | [diff] [blame] | 381 | } |
| 382 | |
Pyry Haulos | 1abab60 | 2014-11-05 17:41:42 -0800 | [diff] [blame] | 383 | GLenum glwCheckNamedFramebufferStatus (GLuint framebuffer, GLenum target) |
Jarkko Poyry | 3c82736 | 2014-09-02 11:48:52 +0300 | [diff] [blame] | 384 | { |
| 385 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 386 | if (!gl) |
Pyry Haulos | 1abab60 | 2014-11-05 17:41:42 -0800 | [diff] [blame] | 387 | return (GLenum)0; |
| 388 | return gl->checkNamedFramebufferStatus(framebuffer, target); |
Jarkko Poyry | 3c82736 | 2014-09-02 11:48:52 +0300 | [diff] [blame] | 389 | } |
| 390 | |
Pyry Haulos | 1abab60 | 2014-11-05 17:41:42 -0800 | [diff] [blame] | 391 | void glwClampColor (GLenum target, GLenum clamp) |
Jarkko Poyry | 3c82736 | 2014-09-02 11:48:52 +0300 | [diff] [blame] | 392 | { |
| 393 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 394 | if (!gl) |
Pyry Haulos | 1abab60 | 2014-11-05 17:41:42 -0800 | [diff] [blame] | 395 | return; |
| 396 | gl->clampColor(target, clamp); |
Jarkko Poyry | 3c82736 | 2014-09-02 11:48:52 +0300 | [diff] [blame] | 397 | } |
| 398 | |
Pyry Haulos | 1abab60 | 2014-11-05 17:41:42 -0800 | [diff] [blame] | 399 | void glwClear (GLbitfield mask) |
Jarkko Poyry | 3c82736 | 2014-09-02 11:48:52 +0300 | [diff] [blame] | 400 | { |
| 401 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 402 | if (!gl) |
Pyry Haulos | 1abab60 | 2014-11-05 17:41:42 -0800 | [diff] [blame] | 403 | return; |
| 404 | gl->clear(mask); |
Jarkko Poyry | 3c82736 | 2014-09-02 11:48:52 +0300 | [diff] [blame] | 405 | } |
| 406 | |
Pyry Haulos | 1abab60 | 2014-11-05 17:41:42 -0800 | [diff] [blame] | 407 | void glwClearBufferData (GLenum target, GLenum internalformat, GLenum format, GLenum type, const void *data) |
Jarkko Poyry | 3c82736 | 2014-09-02 11:48:52 +0300 | [diff] [blame] | 408 | { |
| 409 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 410 | if (!gl) |
Pyry Haulos | 1abab60 | 2014-11-05 17:41:42 -0800 | [diff] [blame] | 411 | return; |
| 412 | gl->clearBufferData(target, internalformat, format, type, data); |
Jarkko Poyry | 3c82736 | 2014-09-02 11:48:52 +0300 | [diff] [blame] | 413 | } |
| 414 | |
Pyry Haulos | 1abab60 | 2014-11-05 17:41:42 -0800 | [diff] [blame] | 415 | void glwClearBufferSubData (GLenum target, GLenum internalformat, GLintptr offset, GLsizeiptr size, GLenum format, GLenum type, const void *data) |
Jarkko Poyry | 3c82736 | 2014-09-02 11:48:52 +0300 | [diff] [blame] | 416 | { |
| 417 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 418 | if (!gl) |
Pyry Haulos | 1abab60 | 2014-11-05 17:41:42 -0800 | [diff] [blame] | 419 | return; |
| 420 | gl->clearBufferSubData(target, internalformat, offset, size, format, type, data); |
Jarkko Poyry | 3c82736 | 2014-09-02 11:48:52 +0300 | [diff] [blame] | 421 | } |
| 422 | |
Pyry Haulos | 1abab60 | 2014-11-05 17:41:42 -0800 | [diff] [blame] | 423 | void glwClearBufferfi (GLenum buffer, GLint drawbuffer, GLfloat depth, GLint stencil) |
Jarkko Poyry | 3c82736 | 2014-09-02 11:48:52 +0300 | [diff] [blame] | 424 | { |
| 425 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 426 | if (!gl) |
Pyry Haulos | 1abab60 | 2014-11-05 17:41:42 -0800 | [diff] [blame] | 427 | return; |
| 428 | gl->clearBufferfi(buffer, drawbuffer, depth, stencil); |
Jarkko Poyry | 3c82736 | 2014-09-02 11:48:52 +0300 | [diff] [blame] | 429 | } |
| 430 | |
Pyry Haulos | 1abab60 | 2014-11-05 17:41:42 -0800 | [diff] [blame] | 431 | void glwClearBufferfv (GLenum buffer, GLint drawbuffer, const GLfloat *value) |
Jarkko Poyry | 3c82736 | 2014-09-02 11:48:52 +0300 | [diff] [blame] | 432 | { |
| 433 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 434 | if (!gl) |
Pyry Haulos | 1abab60 | 2014-11-05 17:41:42 -0800 | [diff] [blame] | 435 | return; |
| 436 | gl->clearBufferfv(buffer, drawbuffer, value); |
Jarkko Poyry | 3c82736 | 2014-09-02 11:48:52 +0300 | [diff] [blame] | 437 | } |
| 438 | |
Pyry Haulos | 1abab60 | 2014-11-05 17:41:42 -0800 | [diff] [blame] | 439 | void glwClearBufferiv (GLenum buffer, GLint drawbuffer, const GLint *value) |
Jarkko Poyry | 3c82736 | 2014-09-02 11:48:52 +0300 | [diff] [blame] | 440 | { |
| 441 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 442 | if (!gl) |
Pyry Haulos | 1abab60 | 2014-11-05 17:41:42 -0800 | [diff] [blame] | 443 | return; |
| 444 | gl->clearBufferiv(buffer, drawbuffer, value); |
Jarkko Poyry | 3c82736 | 2014-09-02 11:48:52 +0300 | [diff] [blame] | 445 | } |
| 446 | |
Pyry Haulos | 1abab60 | 2014-11-05 17:41:42 -0800 | [diff] [blame] | 447 | void glwClearBufferuiv (GLenum buffer, GLint drawbuffer, const GLuint *value) |
Jarkko Poyry | 3c82736 | 2014-09-02 11:48:52 +0300 | [diff] [blame] | 448 | { |
| 449 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 450 | if (!gl) |
Pyry Haulos | 1abab60 | 2014-11-05 17:41:42 -0800 | [diff] [blame] | 451 | return; |
| 452 | gl->clearBufferuiv(buffer, drawbuffer, value); |
Jarkko Poyry | 3c82736 | 2014-09-02 11:48:52 +0300 | [diff] [blame] | 453 | } |
| 454 | |
Pyry Haulos | 1abab60 | 2014-11-05 17:41:42 -0800 | [diff] [blame] | 455 | void glwClearColor (GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha) |
Jarkko Poyry | 3c82736 | 2014-09-02 11:48:52 +0300 | [diff] [blame] | 456 | { |
| 457 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 458 | if (!gl) |
Pyry Haulos | 1abab60 | 2014-11-05 17:41:42 -0800 | [diff] [blame] | 459 | return; |
| 460 | gl->clearColor(red, green, blue, alpha); |
Jarkko Poyry | 3c82736 | 2014-09-02 11:48:52 +0300 | [diff] [blame] | 461 | } |
| 462 | |
Pyry Haulos | 1abab60 | 2014-11-05 17:41:42 -0800 | [diff] [blame] | 463 | void glwClearDepth (GLdouble depth) |
Jarkko Poyry | 3c82736 | 2014-09-02 11:48:52 +0300 | [diff] [blame] | 464 | { |
| 465 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 466 | if (!gl) |
Pyry Haulos | 1abab60 | 2014-11-05 17:41:42 -0800 | [diff] [blame] | 467 | return; |
| 468 | gl->clearDepth(depth); |
Jarkko Poyry | 3c82736 | 2014-09-02 11:48:52 +0300 | [diff] [blame] | 469 | } |
| 470 | |
| 471 | void glwClearDepthf (GLfloat d) |
| 472 | { |
| 473 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 474 | if (!gl) |
Pyry Haulos | 1abab60 | 2014-11-05 17:41:42 -0800 | [diff] [blame] | 475 | return; |
Jarkko Poyry | 3c82736 | 2014-09-02 11:48:52 +0300 | [diff] [blame] | 476 | gl->clearDepthf(d); |
| 477 | } |
| 478 | |
Pyry Haulos | 1abab60 | 2014-11-05 17:41:42 -0800 | [diff] [blame] | 479 | void glwClearNamedBufferData (GLuint buffer, GLenum internalformat, GLenum format, GLenum type, const void *data) |
Jarkko Poyry | 3c82736 | 2014-09-02 11:48:52 +0300 | [diff] [blame] | 480 | { |
| 481 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 482 | if (!gl) |
Pyry Haulos | 1abab60 | 2014-11-05 17:41:42 -0800 | [diff] [blame] | 483 | return; |
| 484 | gl->clearNamedBufferData(buffer, internalformat, format, type, data); |
Jarkko Poyry | 3c82736 | 2014-09-02 11:48:52 +0300 | [diff] [blame] | 485 | } |
| 486 | |
Mika Isojärvi | 314799d | 2015-01-23 15:01:53 -0800 | [diff] [blame] | 487 | void glwClearNamedBufferSubData (GLuint buffer, GLenum internalformat, GLintptr offset, GLsizeiptr size, GLenum format, GLenum type, const void *data) |
Jarkko Poyry | 3c82736 | 2014-09-02 11:48:52 +0300 | [diff] [blame] | 488 | { |
| 489 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 490 | if (!gl) |
Pyry Haulos | 1abab60 | 2014-11-05 17:41:42 -0800 | [diff] [blame] | 491 | return; |
| 492 | gl->clearNamedBufferSubData(buffer, internalformat, offset, size, format, type, data); |
Jarkko Poyry | 3c82736 | 2014-09-02 11:48:52 +0300 | [diff] [blame] | 493 | } |
| 494 | |
Pyry Haulos | 933ef4d | 2016-11-14 13:01:12 -0800 | [diff] [blame] | 495 | void glwClearNamedFramebufferfi (GLuint framebuffer, GLenum buffer, GLint drawbuffer, GLfloat depth, GLint stencil) |
Jarkko Poyry | 3c82736 | 2014-09-02 11:48:52 +0300 | [diff] [blame] | 496 | { |
| 497 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 498 | if (!gl) |
Pyry Haulos | 1abab60 | 2014-11-05 17:41:42 -0800 | [diff] [blame] | 499 | return; |
Pyry Haulos | 933ef4d | 2016-11-14 13:01:12 -0800 | [diff] [blame] | 500 | gl->clearNamedFramebufferfi(framebuffer, buffer, drawbuffer, depth, stencil); |
Jarkko Poyry | 3c82736 | 2014-09-02 11:48:52 +0300 | [diff] [blame] | 501 | } |
| 502 | |
Pyry Haulos | 1abab60 | 2014-11-05 17:41:42 -0800 | [diff] [blame] | 503 | void glwClearNamedFramebufferfv (GLuint framebuffer, GLenum buffer, GLint drawbuffer, const GLfloat *value) |
Jarkko Poyry | 3c82736 | 2014-09-02 11:48:52 +0300 | [diff] [blame] | 504 | { |
| 505 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 506 | if (!gl) |
Pyry Haulos | 1abab60 | 2014-11-05 17:41:42 -0800 | [diff] [blame] | 507 | return; |
| 508 | gl->clearNamedFramebufferfv(framebuffer, buffer, drawbuffer, value); |
Jarkko Poyry | 3c82736 | 2014-09-02 11:48:52 +0300 | [diff] [blame] | 509 | } |
| 510 | |
Pyry Haulos | 1abab60 | 2014-11-05 17:41:42 -0800 | [diff] [blame] | 511 | void glwClearNamedFramebufferiv (GLuint framebuffer, GLenum buffer, GLint drawbuffer, const GLint *value) |
Jarkko Poyry | 3c82736 | 2014-09-02 11:48:52 +0300 | [diff] [blame] | 512 | { |
| 513 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 514 | if (!gl) |
Pyry Haulos | 1abab60 | 2014-11-05 17:41:42 -0800 | [diff] [blame] | 515 | return; |
| 516 | gl->clearNamedFramebufferiv(framebuffer, buffer, drawbuffer, value); |
Jarkko Poyry | 3c82736 | 2014-09-02 11:48:52 +0300 | [diff] [blame] | 517 | } |
| 518 | |
Pyry Haulos | 1abab60 | 2014-11-05 17:41:42 -0800 | [diff] [blame] | 519 | void glwClearNamedFramebufferuiv (GLuint framebuffer, GLenum buffer, GLint drawbuffer, const GLuint *value) |
Jarkko Poyry | 3c82736 | 2014-09-02 11:48:52 +0300 | [diff] [blame] | 520 | { |
| 521 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 522 | if (!gl) |
Pyry Haulos | 1abab60 | 2014-11-05 17:41:42 -0800 | [diff] [blame] | 523 | return; |
| 524 | gl->clearNamedFramebufferuiv(framebuffer, buffer, drawbuffer, value); |
| 525 | } |
| 526 | |
| 527 | void glwClearStencil (GLint s) |
| 528 | { |
| 529 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 530 | if (!gl) |
| 531 | return; |
| 532 | gl->clearStencil(s); |
| 533 | } |
| 534 | |
| 535 | void glwClearTexImage (GLuint texture, GLint level, GLenum format, GLenum type, const void *data) |
| 536 | { |
| 537 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 538 | if (!gl) |
| 539 | return; |
| 540 | gl->clearTexImage(texture, level, format, type, data); |
| 541 | } |
| 542 | |
| 543 | void glwClearTexSubImage (GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const void *data) |
| 544 | { |
| 545 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 546 | if (!gl) |
| 547 | return; |
| 548 | gl->clearTexSubImage(texture, level, xoffset, yoffset, zoffset, width, height, depth, format, type, data); |
| 549 | } |
| 550 | |
Pyry Haulos | 933ef4d | 2016-11-14 13:01:12 -0800 | [diff] [blame] | 551 | void glwClientAttribDefaultEXT (GLbitfield mask) |
| 552 | { |
| 553 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 554 | if (!gl) |
| 555 | return; |
| 556 | gl->clientAttribDefaultEXT(mask); |
| 557 | } |
| 558 | |
Pyry Haulos | 1abab60 | 2014-11-05 17:41:42 -0800 | [diff] [blame] | 559 | GLenum glwClientWaitSync (GLsync sync, GLbitfield flags, GLuint64 timeout) |
| 560 | { |
| 561 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 562 | if (!gl) |
| 563 | return (GLenum)0; |
| 564 | return gl->clientWaitSync(sync, flags, timeout); |
| 565 | } |
| 566 | |
| 567 | void glwClipControl (GLenum origin, GLenum depth) |
| 568 | { |
| 569 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 570 | if (!gl) |
| 571 | return; |
| 572 | gl->clipControl(origin, depth); |
| 573 | } |
| 574 | |
| 575 | void glwColorMask (GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha) |
| 576 | { |
| 577 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 578 | if (!gl) |
| 579 | return; |
| 580 | gl->colorMask(red, green, blue, alpha); |
| 581 | } |
| 582 | |
| 583 | void glwColorMaski (GLuint index, GLboolean r, GLboolean g, GLboolean b, GLboolean a) |
| 584 | { |
| 585 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 586 | if (!gl) |
| 587 | return; |
| 588 | gl->colorMaski(index, r, g, b, a); |
| 589 | } |
| 590 | |
| 591 | void glwCompileShader (GLuint shader) |
| 592 | { |
| 593 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 594 | if (!gl) |
| 595 | return; |
| 596 | gl->compileShader(shader); |
| 597 | } |
| 598 | |
Pyry Haulos | 933ef4d | 2016-11-14 13:01:12 -0800 | [diff] [blame] | 599 | void glwCompressedMultiTexImage1DEXT (GLenum texunit, GLenum target, GLint level, GLenum internalformat, GLsizei width, GLint border, GLsizei imageSize, const void *bits) |
| 600 | { |
| 601 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 602 | if (!gl) |
| 603 | return; |
| 604 | gl->compressedMultiTexImage1DEXT(texunit, target, level, internalformat, width, border, imageSize, bits); |
| 605 | } |
| 606 | |
| 607 | void glwCompressedMultiTexImage2DEXT (GLenum texunit, GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const void *bits) |
| 608 | { |
| 609 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 610 | if (!gl) |
| 611 | return; |
| 612 | gl->compressedMultiTexImage2DEXT(texunit, target, level, internalformat, width, height, border, imageSize, bits); |
| 613 | } |
| 614 | |
| 615 | void glwCompressedMultiTexImage3DEXT (GLenum texunit, GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const void *bits) |
| 616 | { |
| 617 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 618 | if (!gl) |
| 619 | return; |
| 620 | gl->compressedMultiTexImage3DEXT(texunit, target, level, internalformat, width, height, depth, border, imageSize, bits); |
| 621 | } |
| 622 | |
| 623 | void glwCompressedMultiTexSubImage1DEXT (GLenum texunit, GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const void *bits) |
| 624 | { |
| 625 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 626 | if (!gl) |
| 627 | return; |
| 628 | gl->compressedMultiTexSubImage1DEXT(texunit, target, level, xoffset, width, format, imageSize, bits); |
| 629 | } |
| 630 | |
| 631 | void glwCompressedMultiTexSubImage2DEXT (GLenum texunit, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const void *bits) |
| 632 | { |
| 633 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 634 | if (!gl) |
| 635 | return; |
| 636 | gl->compressedMultiTexSubImage2DEXT(texunit, target, level, xoffset, yoffset, width, height, format, imageSize, bits); |
| 637 | } |
| 638 | |
| 639 | void glwCompressedMultiTexSubImage3DEXT (GLenum texunit, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const void *bits) |
| 640 | { |
| 641 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 642 | if (!gl) |
| 643 | return; |
| 644 | gl->compressedMultiTexSubImage3DEXT(texunit, target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, bits); |
| 645 | } |
| 646 | |
Pyry Haulos | 1abab60 | 2014-11-05 17:41:42 -0800 | [diff] [blame] | 647 | void glwCompressedTexImage1D (GLenum target, GLint level, GLenum internalformat, GLsizei width, GLint border, GLsizei imageSize, const void *data) |
| 648 | { |
| 649 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 650 | if (!gl) |
| 651 | return; |
| 652 | gl->compressedTexImage1D(target, level, internalformat, width, border, imageSize, data); |
| 653 | } |
| 654 | |
| 655 | void glwCompressedTexImage2D (GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const void *data) |
| 656 | { |
| 657 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 658 | if (!gl) |
| 659 | return; |
| 660 | gl->compressedTexImage2D(target, level, internalformat, width, height, border, imageSize, data); |
| 661 | } |
| 662 | |
| 663 | void glwCompressedTexImage3D (GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const void *data) |
| 664 | { |
| 665 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 666 | if (!gl) |
| 667 | return; |
| 668 | gl->compressedTexImage3D(target, level, internalformat, width, height, depth, border, imageSize, data); |
| 669 | } |
| 670 | |
Pyry Haulos | 933ef4d | 2016-11-14 13:01:12 -0800 | [diff] [blame] | 671 | void glwCompressedTexImage3DOES (GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const void *data) |
| 672 | { |
| 673 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 674 | if (!gl) |
| 675 | return; |
| 676 | gl->compressedTexImage3DOES(target, level, internalformat, width, height, depth, border, imageSize, data); |
| 677 | } |
| 678 | |
Pyry Haulos | 1abab60 | 2014-11-05 17:41:42 -0800 | [diff] [blame] | 679 | void glwCompressedTexSubImage1D (GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const void *data) |
| 680 | { |
| 681 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 682 | if (!gl) |
| 683 | return; |
| 684 | gl->compressedTexSubImage1D(target, level, xoffset, width, format, imageSize, data); |
| 685 | } |
| 686 | |
| 687 | void glwCompressedTexSubImage2D (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const void *data) |
| 688 | { |
| 689 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 690 | if (!gl) |
| 691 | return; |
| 692 | gl->compressedTexSubImage2D(target, level, xoffset, yoffset, width, height, format, imageSize, data); |
| 693 | } |
| 694 | |
| 695 | void glwCompressedTexSubImage3D (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const void *data) |
| 696 | { |
| 697 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 698 | if (!gl) |
| 699 | return; |
| 700 | gl->compressedTexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, data); |
| 701 | } |
| 702 | |
Pyry Haulos | 933ef4d | 2016-11-14 13:01:12 -0800 | [diff] [blame] | 703 | void glwCompressedTexSubImage3DOES (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const void *data) |
| 704 | { |
| 705 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 706 | if (!gl) |
| 707 | return; |
| 708 | gl->compressedTexSubImage3DOES(target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, data); |
| 709 | } |
| 710 | |
| 711 | void glwCompressedTextureImage1DEXT (GLuint texture, GLenum target, GLint level, GLenum internalformat, GLsizei width, GLint border, GLsizei imageSize, const void *bits) |
| 712 | { |
| 713 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 714 | if (!gl) |
| 715 | return; |
| 716 | gl->compressedTextureImage1DEXT(texture, target, level, internalformat, width, border, imageSize, bits); |
| 717 | } |
| 718 | |
| 719 | void glwCompressedTextureImage2DEXT (GLuint texture, GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const void *bits) |
| 720 | { |
| 721 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 722 | if (!gl) |
| 723 | return; |
| 724 | gl->compressedTextureImage2DEXT(texture, target, level, internalformat, width, height, border, imageSize, bits); |
| 725 | } |
| 726 | |
| 727 | void glwCompressedTextureImage3DEXT (GLuint texture, GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const void *bits) |
| 728 | { |
| 729 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 730 | if (!gl) |
| 731 | return; |
| 732 | gl->compressedTextureImage3DEXT(texture, target, level, internalformat, width, height, depth, border, imageSize, bits); |
| 733 | } |
| 734 | |
Pyry Haulos | 1abab60 | 2014-11-05 17:41:42 -0800 | [diff] [blame] | 735 | void glwCompressedTextureSubImage1D (GLuint texture, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const void *data) |
| 736 | { |
| 737 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 738 | if (!gl) |
| 739 | return; |
| 740 | gl->compressedTextureSubImage1D(texture, level, xoffset, width, format, imageSize, data); |
| 741 | } |
| 742 | |
Pyry Haulos | 933ef4d | 2016-11-14 13:01:12 -0800 | [diff] [blame] | 743 | void glwCompressedTextureSubImage1DEXT (GLuint texture, GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const void *bits) |
| 744 | { |
| 745 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 746 | if (!gl) |
| 747 | return; |
| 748 | gl->compressedTextureSubImage1DEXT(texture, target, level, xoffset, width, format, imageSize, bits); |
| 749 | } |
| 750 | |
Pyry Haulos | 1abab60 | 2014-11-05 17:41:42 -0800 | [diff] [blame] | 751 | void glwCompressedTextureSubImage2D (GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const void *data) |
| 752 | { |
| 753 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 754 | if (!gl) |
| 755 | return; |
| 756 | gl->compressedTextureSubImage2D(texture, level, xoffset, yoffset, width, height, format, imageSize, data); |
| 757 | } |
| 758 | |
Pyry Haulos | 933ef4d | 2016-11-14 13:01:12 -0800 | [diff] [blame] | 759 | void glwCompressedTextureSubImage2DEXT (GLuint texture, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const void *bits) |
| 760 | { |
| 761 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 762 | if (!gl) |
| 763 | return; |
| 764 | gl->compressedTextureSubImage2DEXT(texture, target, level, xoffset, yoffset, width, height, format, imageSize, bits); |
| 765 | } |
| 766 | |
Pyry Haulos | 1abab60 | 2014-11-05 17:41:42 -0800 | [diff] [blame] | 767 | void glwCompressedTextureSubImage3D (GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const void *data) |
| 768 | { |
| 769 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 770 | if (!gl) |
| 771 | return; |
| 772 | gl->compressedTextureSubImage3D(texture, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, data); |
| 773 | } |
| 774 | |
Pyry Haulos | 933ef4d | 2016-11-14 13:01:12 -0800 | [diff] [blame] | 775 | void glwCompressedTextureSubImage3DEXT (GLuint texture, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const void *bits) |
| 776 | { |
| 777 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 778 | if (!gl) |
| 779 | return; |
| 780 | gl->compressedTextureSubImage3DEXT(texture, target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, bits); |
| 781 | } |
| 782 | |
Pyry Haulos | 1abab60 | 2014-11-05 17:41:42 -0800 | [diff] [blame] | 783 | void glwCopyBufferSubData (GLenum readTarget, GLenum writeTarget, GLintptr readOffset, GLintptr writeOffset, GLsizeiptr size) |
| 784 | { |
| 785 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 786 | if (!gl) |
| 787 | return; |
| 788 | gl->copyBufferSubData(readTarget, writeTarget, readOffset, writeOffset, size); |
| 789 | } |
| 790 | |
| 791 | void glwCopyImageSubData (GLuint srcName, GLenum srcTarget, GLint srcLevel, GLint srcX, GLint srcY, GLint srcZ, GLuint dstName, GLenum dstTarget, GLint dstLevel, GLint dstX, GLint dstY, GLint dstZ, GLsizei srcWidth, GLsizei srcHeight, GLsizei srcDepth) |
| 792 | { |
| 793 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 794 | if (!gl) |
| 795 | return; |
| 796 | gl->copyImageSubData(srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth); |
| 797 | } |
| 798 | |
Pyry Haulos | 933ef4d | 2016-11-14 13:01:12 -0800 | [diff] [blame] | 799 | void glwCopyMultiTexImage1DEXT (GLenum texunit, GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLint border) |
| 800 | { |
| 801 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 802 | if (!gl) |
| 803 | return; |
| 804 | gl->copyMultiTexImage1DEXT(texunit, target, level, internalformat, x, y, width, border); |
| 805 | } |
| 806 | |
| 807 | void glwCopyMultiTexImage2DEXT (GLenum texunit, GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border) |
| 808 | { |
| 809 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 810 | if (!gl) |
| 811 | return; |
| 812 | gl->copyMultiTexImage2DEXT(texunit, target, level, internalformat, x, y, width, height, border); |
| 813 | } |
| 814 | |
| 815 | void glwCopyMultiTexSubImage1DEXT (GLenum texunit, GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width) |
| 816 | { |
| 817 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 818 | if (!gl) |
| 819 | return; |
| 820 | gl->copyMultiTexSubImage1DEXT(texunit, target, level, xoffset, x, y, width); |
| 821 | } |
| 822 | |
| 823 | void glwCopyMultiTexSubImage2DEXT (GLenum texunit, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height) |
| 824 | { |
| 825 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 826 | if (!gl) |
| 827 | return; |
| 828 | gl->copyMultiTexSubImage2DEXT(texunit, target, level, xoffset, yoffset, x, y, width, height); |
| 829 | } |
| 830 | |
| 831 | void glwCopyMultiTexSubImage3DEXT (GLenum texunit, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height) |
| 832 | { |
| 833 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 834 | if (!gl) |
| 835 | return; |
| 836 | gl->copyMultiTexSubImage3DEXT(texunit, target, level, xoffset, yoffset, zoffset, x, y, width, height); |
| 837 | } |
| 838 | |
Mika Isojärvi | 314799d | 2015-01-23 15:01:53 -0800 | [diff] [blame] | 839 | void glwCopyNamedBufferSubData (GLuint readBuffer, GLuint writeBuffer, GLintptr readOffset, GLintptr writeOffset, GLsizeiptr size) |
Pyry Haulos | 1abab60 | 2014-11-05 17:41:42 -0800 | [diff] [blame] | 840 | { |
| 841 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 842 | if (!gl) |
| 843 | return; |
| 844 | gl->copyNamedBufferSubData(readBuffer, writeBuffer, readOffset, writeOffset, size); |
| 845 | } |
| 846 | |
| 847 | void glwCopyTexImage1D (GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLint border) |
| 848 | { |
| 849 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 850 | if (!gl) |
| 851 | return; |
| 852 | gl->copyTexImage1D(target, level, internalformat, x, y, width, border); |
| 853 | } |
| 854 | |
| 855 | void glwCopyTexImage2D (GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border) |
| 856 | { |
| 857 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 858 | if (!gl) |
| 859 | return; |
| 860 | gl->copyTexImage2D(target, level, internalformat, x, y, width, height, border); |
| 861 | } |
| 862 | |
| 863 | void glwCopyTexSubImage1D (GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width) |
| 864 | { |
| 865 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 866 | if (!gl) |
| 867 | return; |
| 868 | gl->copyTexSubImage1D(target, level, xoffset, x, y, width); |
| 869 | } |
| 870 | |
| 871 | void glwCopyTexSubImage2D (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height) |
| 872 | { |
| 873 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 874 | if (!gl) |
| 875 | return; |
| 876 | gl->copyTexSubImage2D(target, level, xoffset, yoffset, x, y, width, height); |
| 877 | } |
| 878 | |
| 879 | void glwCopyTexSubImage3D (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height) |
| 880 | { |
| 881 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 882 | if (!gl) |
| 883 | return; |
| 884 | gl->copyTexSubImage3D(target, level, xoffset, yoffset, zoffset, x, y, width, height); |
| 885 | } |
| 886 | |
Pyry Haulos | 933ef4d | 2016-11-14 13:01:12 -0800 | [diff] [blame] | 887 | void glwCopyTexSubImage3DOES (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height) |
| 888 | { |
| 889 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 890 | if (!gl) |
| 891 | return; |
| 892 | gl->copyTexSubImage3DOES(target, level, xoffset, yoffset, zoffset, x, y, width, height); |
| 893 | } |
| 894 | |
| 895 | void glwCopyTextureImage1DEXT (GLuint texture, GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLint border) |
| 896 | { |
| 897 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 898 | if (!gl) |
| 899 | return; |
| 900 | gl->copyTextureImage1DEXT(texture, target, level, internalformat, x, y, width, border); |
| 901 | } |
| 902 | |
| 903 | void glwCopyTextureImage2DEXT (GLuint texture, GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border) |
| 904 | { |
| 905 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 906 | if (!gl) |
| 907 | return; |
| 908 | gl->copyTextureImage2DEXT(texture, target, level, internalformat, x, y, width, height, border); |
| 909 | } |
| 910 | |
Pyry Haulos | 1abab60 | 2014-11-05 17:41:42 -0800 | [diff] [blame] | 911 | void glwCopyTextureSubImage1D (GLuint texture, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width) |
| 912 | { |
| 913 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 914 | if (!gl) |
| 915 | return; |
| 916 | gl->copyTextureSubImage1D(texture, level, xoffset, x, y, width); |
| 917 | } |
| 918 | |
Pyry Haulos | 933ef4d | 2016-11-14 13:01:12 -0800 | [diff] [blame] | 919 | void glwCopyTextureSubImage1DEXT (GLuint texture, GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width) |
| 920 | { |
| 921 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 922 | if (!gl) |
| 923 | return; |
| 924 | gl->copyTextureSubImage1DEXT(texture, target, level, xoffset, x, y, width); |
| 925 | } |
| 926 | |
Pyry Haulos | 1abab60 | 2014-11-05 17:41:42 -0800 | [diff] [blame] | 927 | void glwCopyTextureSubImage2D (GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height) |
| 928 | { |
| 929 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 930 | if (!gl) |
| 931 | return; |
| 932 | gl->copyTextureSubImage2D(texture, level, xoffset, yoffset, x, y, width, height); |
| 933 | } |
| 934 | |
Pyry Haulos | 933ef4d | 2016-11-14 13:01:12 -0800 | [diff] [blame] | 935 | void glwCopyTextureSubImage2DEXT (GLuint texture, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height) |
| 936 | { |
| 937 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 938 | if (!gl) |
| 939 | return; |
| 940 | gl->copyTextureSubImage2DEXT(texture, target, level, xoffset, yoffset, x, y, width, height); |
| 941 | } |
| 942 | |
Pyry Haulos | 1abab60 | 2014-11-05 17:41:42 -0800 | [diff] [blame] | 943 | void glwCopyTextureSubImage3D (GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height) |
| 944 | { |
| 945 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 946 | if (!gl) |
| 947 | return; |
| 948 | gl->copyTextureSubImage3D(texture, level, xoffset, yoffset, zoffset, x, y, width, height); |
| 949 | } |
| 950 | |
Pyry Haulos | 933ef4d | 2016-11-14 13:01:12 -0800 | [diff] [blame] | 951 | void glwCopyTextureSubImage3DEXT (GLuint texture, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height) |
| 952 | { |
| 953 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 954 | if (!gl) |
| 955 | return; |
| 956 | gl->copyTextureSubImage3DEXT(texture, target, level, xoffset, yoffset, zoffset, x, y, width, height); |
| 957 | } |
| 958 | |
Pyry Haulos | 1abab60 | 2014-11-05 17:41:42 -0800 | [diff] [blame] | 959 | void glwCreateBuffers (GLsizei n, GLuint *buffers) |
| 960 | { |
| 961 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 962 | if (!gl) |
| 963 | return; |
| 964 | gl->createBuffers(n, buffers); |
| 965 | } |
| 966 | |
| 967 | void glwCreateFramebuffers (GLsizei n, GLuint *framebuffers) |
| 968 | { |
| 969 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 970 | if (!gl) |
| 971 | return; |
| 972 | gl->createFramebuffers(n, framebuffers); |
| 973 | } |
| 974 | |
| 975 | GLuint glwCreateProgram (void) |
| 976 | { |
| 977 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 978 | if (!gl) |
| 979 | return (GLuint)0; |
| 980 | return gl->createProgram(); |
| 981 | } |
| 982 | |
| 983 | void glwCreateProgramPipelines (GLsizei n, GLuint *pipelines) |
| 984 | { |
| 985 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 986 | if (!gl) |
| 987 | return; |
| 988 | gl->createProgramPipelines(n, pipelines); |
| 989 | } |
| 990 | |
| 991 | void glwCreateQueries (GLenum target, GLsizei n, GLuint *ids) |
| 992 | { |
| 993 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 994 | if (!gl) |
| 995 | return; |
| 996 | gl->createQueries(target, n, ids); |
| 997 | } |
| 998 | |
| 999 | void glwCreateRenderbuffers (GLsizei n, GLuint *renderbuffers) |
| 1000 | { |
| 1001 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 1002 | if (!gl) |
| 1003 | return; |
| 1004 | gl->createRenderbuffers(n, renderbuffers); |
| 1005 | } |
| 1006 | |
| 1007 | void glwCreateSamplers (GLsizei n, GLuint *samplers) |
| 1008 | { |
| 1009 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 1010 | if (!gl) |
| 1011 | return; |
| 1012 | gl->createSamplers(n, samplers); |
| 1013 | } |
| 1014 | |
| 1015 | GLuint glwCreateShader (GLenum type) |
| 1016 | { |
| 1017 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 1018 | if (!gl) |
| 1019 | return (GLuint)0; |
| 1020 | return gl->createShader(type); |
| 1021 | } |
| 1022 | |
| 1023 | GLuint glwCreateShaderProgramv (GLenum type, GLsizei count, const GLchar *const*strings) |
| 1024 | { |
| 1025 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 1026 | if (!gl) |
| 1027 | return (GLuint)0; |
Jarkko Poyry | 3c82736 | 2014-09-02 11:48:52 +0300 | [diff] [blame] | 1028 | return gl->createShaderProgramv(type, count, strings); |
| 1029 | } |
| 1030 | |
Pyry Haulos | 1abab60 | 2014-11-05 17:41:42 -0800 | [diff] [blame] | 1031 | void glwCreateTextures (GLenum target, GLsizei n, GLuint *textures) |
Jarkko Poyry | 3c82736 | 2014-09-02 11:48:52 +0300 | [diff] [blame] | 1032 | { |
| 1033 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 1034 | if (!gl) |
Pyry Haulos | 1abab60 | 2014-11-05 17:41:42 -0800 | [diff] [blame] | 1035 | return; |
| 1036 | gl->createTextures(target, n, textures); |
Jarkko Poyry | 3c82736 | 2014-09-02 11:48:52 +0300 | [diff] [blame] | 1037 | } |
| 1038 | |
Pyry Haulos | 1abab60 | 2014-11-05 17:41:42 -0800 | [diff] [blame] | 1039 | void glwCreateTransformFeedbacks (GLsizei n, GLuint *ids) |
Jarkko Poyry | 3c82736 | 2014-09-02 11:48:52 +0300 | [diff] [blame] | 1040 | { |
| 1041 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 1042 | if (!gl) |
Pyry Haulos | 1abab60 | 2014-11-05 17:41:42 -0800 | [diff] [blame] | 1043 | return; |
| 1044 | gl->createTransformFeedbacks(n, ids); |
| 1045 | } |
| 1046 | |
| 1047 | void glwCreateVertexArrays (GLsizei n, GLuint *arrays) |
| 1048 | { |
| 1049 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 1050 | if (!gl) |
| 1051 | return; |
| 1052 | gl->createVertexArrays(n, arrays); |
| 1053 | } |
| 1054 | |
| 1055 | void glwCullFace (GLenum mode) |
| 1056 | { |
| 1057 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 1058 | if (!gl) |
| 1059 | return; |
| 1060 | gl->cullFace(mode); |
| 1061 | } |
| 1062 | |
| 1063 | void glwDebugMessageCallback (GLDEBUGPROC callback, const void *userParam) |
| 1064 | { |
| 1065 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 1066 | if (!gl) |
| 1067 | return; |
| 1068 | gl->debugMessageCallback(callback, userParam); |
| 1069 | } |
| 1070 | |
| 1071 | void glwDebugMessageControl (GLenum source, GLenum type, GLenum severity, GLsizei count, const GLuint *ids, GLboolean enabled) |
| 1072 | { |
| 1073 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 1074 | if (!gl) |
| 1075 | return; |
| 1076 | gl->debugMessageControl(source, type, severity, count, ids, enabled); |
| 1077 | } |
| 1078 | |
| 1079 | void glwDebugMessageInsert (GLenum source, GLenum type, GLuint id, GLenum severity, GLsizei length, const GLchar *buf) |
| 1080 | { |
| 1081 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 1082 | if (!gl) |
| 1083 | return; |
| 1084 | gl->debugMessageInsert(source, type, id, severity, length, buf); |
| 1085 | } |
| 1086 | |
| 1087 | void glwDeleteBuffers (GLsizei n, const GLuint *buffers) |
| 1088 | { |
| 1089 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 1090 | if (!gl) |
| 1091 | return; |
| 1092 | gl->deleteBuffers(n, buffers); |
| 1093 | } |
| 1094 | |
| 1095 | void glwDeleteFramebuffers (GLsizei n, const GLuint *framebuffers) |
| 1096 | { |
| 1097 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 1098 | if (!gl) |
| 1099 | return; |
| 1100 | gl->deleteFramebuffers(n, framebuffers); |
| 1101 | } |
| 1102 | |
| 1103 | void glwDeleteProgram (GLuint program) |
| 1104 | { |
| 1105 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 1106 | if (!gl) |
| 1107 | return; |
| 1108 | gl->deleteProgram(program); |
| 1109 | } |
| 1110 | |
| 1111 | void glwDeleteProgramPipelines (GLsizei n, const GLuint *pipelines) |
| 1112 | { |
| 1113 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 1114 | if (!gl) |
| 1115 | return; |
Jarkko Poyry | 3c82736 | 2014-09-02 11:48:52 +0300 | [diff] [blame] | 1116 | gl->deleteProgramPipelines(n, pipelines); |
| 1117 | } |
| 1118 | |
Pyry Haulos | 1abab60 | 2014-11-05 17:41:42 -0800 | [diff] [blame] | 1119 | void glwDeleteQueries (GLsizei n, const GLuint *ids) |
Jarkko Poyry | 3c82736 | 2014-09-02 11:48:52 +0300 | [diff] [blame] | 1120 | { |
| 1121 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 1122 | if (!gl) |
Pyry Haulos | 1abab60 | 2014-11-05 17:41:42 -0800 | [diff] [blame] | 1123 | return; |
| 1124 | gl->deleteQueries(n, ids); |
Jarkko Poyry | 3c82736 | 2014-09-02 11:48:52 +0300 | [diff] [blame] | 1125 | } |
| 1126 | |
Pyry Haulos | 1abab60 | 2014-11-05 17:41:42 -0800 | [diff] [blame] | 1127 | void glwDeleteRenderbuffers (GLsizei n, const GLuint *renderbuffers) |
Jarkko Poyry | 3c82736 | 2014-09-02 11:48:52 +0300 | [diff] [blame] | 1128 | { |
| 1129 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 1130 | if (!gl) |
Pyry Haulos | 1abab60 | 2014-11-05 17:41:42 -0800 | [diff] [blame] | 1131 | return; |
| 1132 | gl->deleteRenderbuffers(n, renderbuffers); |
Jarkko Poyry | 3c82736 | 2014-09-02 11:48:52 +0300 | [diff] [blame] | 1133 | } |
| 1134 | |
Pyry Haulos | 1abab60 | 2014-11-05 17:41:42 -0800 | [diff] [blame] | 1135 | void glwDeleteSamplers (GLsizei count, const GLuint *samplers) |
Jarkko Poyry | 3c82736 | 2014-09-02 11:48:52 +0300 | [diff] [blame] | 1136 | { |
| 1137 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 1138 | if (!gl) |
Pyry Haulos | 1abab60 | 2014-11-05 17:41:42 -0800 | [diff] [blame] | 1139 | return; |
| 1140 | gl->deleteSamplers(count, samplers); |
Jarkko Poyry | 3c82736 | 2014-09-02 11:48:52 +0300 | [diff] [blame] | 1141 | } |
| 1142 | |
Pyry Haulos | 1abab60 | 2014-11-05 17:41:42 -0800 | [diff] [blame] | 1143 | void glwDeleteShader (GLuint shader) |
Jarkko Poyry | 3c82736 | 2014-09-02 11:48:52 +0300 | [diff] [blame] | 1144 | { |
| 1145 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 1146 | if (!gl) |
Pyry Haulos | 1abab60 | 2014-11-05 17:41:42 -0800 | [diff] [blame] | 1147 | return; |
| 1148 | gl->deleteShader(shader); |
Jarkko Poyry | 3c82736 | 2014-09-02 11:48:52 +0300 | [diff] [blame] | 1149 | } |
| 1150 | |
Pyry Haulos | 1abab60 | 2014-11-05 17:41:42 -0800 | [diff] [blame] | 1151 | void glwDeleteSync (GLsync sync) |
Jarkko Poyry | 3c82736 | 2014-09-02 11:48:52 +0300 | [diff] [blame] | 1152 | { |
| 1153 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 1154 | if (!gl) |
Pyry Haulos | 1abab60 | 2014-11-05 17:41:42 -0800 | [diff] [blame] | 1155 | return; |
| 1156 | gl->deleteSync(sync); |
Jarkko Poyry | 3c82736 | 2014-09-02 11:48:52 +0300 | [diff] [blame] | 1157 | } |
| 1158 | |
Pyry Haulos | 1abab60 | 2014-11-05 17:41:42 -0800 | [diff] [blame] | 1159 | void glwDeleteTextures (GLsizei n, const GLuint *textures) |
Jarkko Poyry | 3c82736 | 2014-09-02 11:48:52 +0300 | [diff] [blame] | 1160 | { |
| 1161 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 1162 | if (!gl) |
Pyry Haulos | 1abab60 | 2014-11-05 17:41:42 -0800 | [diff] [blame] | 1163 | return; |
| 1164 | gl->deleteTextures(n, textures); |
Jarkko Poyry | 3c82736 | 2014-09-02 11:48:52 +0300 | [diff] [blame] | 1165 | } |
| 1166 | |
Pyry Haulos | 1abab60 | 2014-11-05 17:41:42 -0800 | [diff] [blame] | 1167 | void glwDeleteTransformFeedbacks (GLsizei n, const GLuint *ids) |
Jarkko Poyry | 3c82736 | 2014-09-02 11:48:52 +0300 | [diff] [blame] | 1168 | { |
| 1169 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 1170 | if (!gl) |
Pyry Haulos | 1abab60 | 2014-11-05 17:41:42 -0800 | [diff] [blame] | 1171 | return; |
| 1172 | gl->deleteTransformFeedbacks(n, ids); |
Jarkko Poyry | 3c82736 | 2014-09-02 11:48:52 +0300 | [diff] [blame] | 1173 | } |
| 1174 | |
Pyry Haulos | 1abab60 | 2014-11-05 17:41:42 -0800 | [diff] [blame] | 1175 | void glwDeleteVertexArrays (GLsizei n, const GLuint *arrays) |
Jarkko Poyry | 3c82736 | 2014-09-02 11:48:52 +0300 | [diff] [blame] | 1176 | { |
| 1177 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 1178 | if (!gl) |
Pyry Haulos | 1abab60 | 2014-11-05 17:41:42 -0800 | [diff] [blame] | 1179 | return; |
| 1180 | gl->deleteVertexArrays(n, arrays); |
Jarkko Poyry | 3c82736 | 2014-09-02 11:48:52 +0300 | [diff] [blame] | 1181 | } |
| 1182 | |
Adam Czupryna | 54b4f43 | 2016-11-30 16:54:57 +0100 | [diff] [blame^] | 1183 | void glwDepthBoundsEXT (GLclampd zmin, GLclampd zmax) |
| 1184 | { |
| 1185 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 1186 | if (!gl) |
| 1187 | return; |
| 1188 | gl->depthBoundsEXT(zmin, zmax); |
| 1189 | } |
| 1190 | |
Pyry Haulos | 1abab60 | 2014-11-05 17:41:42 -0800 | [diff] [blame] | 1191 | void glwDepthFunc (GLenum func) |
Jarkko Poyry | 3c82736 | 2014-09-02 11:48:52 +0300 | [diff] [blame] | 1192 | { |
| 1193 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 1194 | if (!gl) |
Pyry Haulos | 1abab60 | 2014-11-05 17:41:42 -0800 | [diff] [blame] | 1195 | return; |
| 1196 | gl->depthFunc(func); |
Jarkko Poyry | 3c82736 | 2014-09-02 11:48:52 +0300 | [diff] [blame] | 1197 | } |
| 1198 | |
Pyry Haulos | 1abab60 | 2014-11-05 17:41:42 -0800 | [diff] [blame] | 1199 | void glwDepthMask (GLboolean flag) |
Jarkko Poyry | 3c82736 | 2014-09-02 11:48:52 +0300 | [diff] [blame] | 1200 | { |
| 1201 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 1202 | if (!gl) |
Pyry Haulos | 1abab60 | 2014-11-05 17:41:42 -0800 | [diff] [blame] | 1203 | return; |
| 1204 | gl->depthMask(flag); |
Jarkko Poyry | 3c82736 | 2014-09-02 11:48:52 +0300 | [diff] [blame] | 1205 | } |
| 1206 | |
Pyry Haulos | 1abab60 | 2014-11-05 17:41:42 -0800 | [diff] [blame] | 1207 | void glwDepthRange (GLdouble near, GLdouble far) |
Jarkko Poyry | 3c82736 | 2014-09-02 11:48:52 +0300 | [diff] [blame] | 1208 | { |
| 1209 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 1210 | if (!gl) |
Pyry Haulos | 1abab60 | 2014-11-05 17:41:42 -0800 | [diff] [blame] | 1211 | return; |
| 1212 | gl->depthRange(near, far); |
Jarkko Poyry | 3c82736 | 2014-09-02 11:48:52 +0300 | [diff] [blame] | 1213 | } |
| 1214 | |
Daniel Koch | 2369fdf | 2016-12-11 16:30:19 -0500 | [diff] [blame] | 1215 | void glwDepthRangeArrayfvOES (GLuint first, GLsizei count, const GLfloat *v) |
| 1216 | { |
| 1217 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 1218 | if (!gl) |
| 1219 | return; |
| 1220 | gl->depthRangeArrayfvOES(first, count, v); |
| 1221 | } |
| 1222 | |
Pyry Haulos | 1abab60 | 2014-11-05 17:41:42 -0800 | [diff] [blame] | 1223 | void glwDepthRangeArrayv (GLuint first, GLsizei count, const GLdouble *v) |
Jarkko Poyry | 3c82736 | 2014-09-02 11:48:52 +0300 | [diff] [blame] | 1224 | { |
| 1225 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 1226 | if (!gl) |
Pyry Haulos | 1abab60 | 2014-11-05 17:41:42 -0800 | [diff] [blame] | 1227 | return; |
Jarkko Poyry | 3c82736 | 2014-09-02 11:48:52 +0300 | [diff] [blame] | 1228 | gl->depthRangeArrayv(first, count, v); |
| 1229 | } |
| 1230 | |
| 1231 | void glwDepthRangeIndexed (GLuint index, GLdouble n, GLdouble f) |
| 1232 | { |
| 1233 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 1234 | if (!gl) |
Pyry Haulos | 1abab60 | 2014-11-05 17:41:42 -0800 | [diff] [blame] | 1235 | return; |
Jarkko Poyry | 3c82736 | 2014-09-02 11:48:52 +0300 | [diff] [blame] | 1236 | gl->depthRangeIndexed(index, n, f); |
| 1237 | } |
| 1238 | |
Daniel Koch | 2369fdf | 2016-12-11 16:30:19 -0500 | [diff] [blame] | 1239 | void glwDepthRangeIndexedfOES (GLuint index, GLfloat n, GLfloat f) |
| 1240 | { |
| 1241 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 1242 | if (!gl) |
| 1243 | return; |
| 1244 | gl->depthRangeIndexedfOES(index, n, f); |
| 1245 | } |
| 1246 | |
Pyry Haulos | 1abab60 | 2014-11-05 17:41:42 -0800 | [diff] [blame] | 1247 | void glwDepthRangef (GLfloat n, GLfloat f) |
Jarkko Poyry | 3c82736 | 2014-09-02 11:48:52 +0300 | [diff] [blame] | 1248 | { |
| 1249 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 1250 | if (!gl) |
Pyry Haulos | 1abab60 | 2014-11-05 17:41:42 -0800 | [diff] [blame] | 1251 | return; |
| 1252 | gl->depthRangef(n, f); |
Jarkko Poyry | 3c82736 | 2014-09-02 11:48:52 +0300 | [diff] [blame] | 1253 | } |
| 1254 | |
Pyry Haulos | 1abab60 | 2014-11-05 17:41:42 -0800 | [diff] [blame] | 1255 | void glwDetachShader (GLuint program, GLuint shader) |
Jarkko Poyry | 3c82736 | 2014-09-02 11:48:52 +0300 | [diff] [blame] | 1256 | { |
| 1257 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 1258 | if (!gl) |
Pyry Haulos | 1abab60 | 2014-11-05 17:41:42 -0800 | [diff] [blame] | 1259 | return; |
| 1260 | gl->detachShader(program, shader); |
Jarkko Poyry | 3c82736 | 2014-09-02 11:48:52 +0300 | [diff] [blame] | 1261 | } |
| 1262 | |
Pyry Haulos | 1abab60 | 2014-11-05 17:41:42 -0800 | [diff] [blame] | 1263 | void glwDisable (GLenum cap) |
Jarkko Poyry | 3c82736 | 2014-09-02 11:48:52 +0300 | [diff] [blame] | 1264 | { |
| 1265 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 1266 | if (!gl) |
Pyry Haulos | 1abab60 | 2014-11-05 17:41:42 -0800 | [diff] [blame] | 1267 | return; |
| 1268 | gl->disable(cap); |
Jarkko Poyry | 3c82736 | 2014-09-02 11:48:52 +0300 | [diff] [blame] | 1269 | } |
| 1270 | |
Pyry Haulos | 933ef4d | 2016-11-14 13:01:12 -0800 | [diff] [blame] | 1271 | void glwDisableClientStateIndexedEXT (GLenum array, GLuint index) |
| 1272 | { |
| 1273 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 1274 | if (!gl) |
| 1275 | return; |
| 1276 | gl->disableClientStateIndexedEXT(array, index); |
| 1277 | } |
| 1278 | |
| 1279 | void glwDisableClientStateiEXT (GLenum array, GLuint index) |
| 1280 | { |
| 1281 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 1282 | if (!gl) |
| 1283 | return; |
| 1284 | gl->disableClientStateiEXT(array, index); |
| 1285 | } |
| 1286 | |
| 1287 | void glwDisableIndexedEXT (GLenum target, GLuint index) |
| 1288 | { |
| 1289 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 1290 | if (!gl) |
| 1291 | return; |
| 1292 | gl->disableIndexedEXT(target, index); |
| 1293 | } |
| 1294 | |
Pyry Haulos | 1abab60 | 2014-11-05 17:41:42 -0800 | [diff] [blame] | 1295 | void glwDisableVertexArrayAttrib (GLuint vaobj, GLuint index) |
Jarkko Poyry | 3c82736 | 2014-09-02 11:48:52 +0300 | [diff] [blame] | 1296 | { |
| 1297 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 1298 | if (!gl) |
Pyry Haulos | 1abab60 | 2014-11-05 17:41:42 -0800 | [diff] [blame] | 1299 | return; |
| 1300 | gl->disableVertexArrayAttrib(vaobj, index); |
Jarkko Poyry | 3c82736 | 2014-09-02 11:48:52 +0300 | [diff] [blame] | 1301 | } |
| 1302 | |
Pyry Haulos | 933ef4d | 2016-11-14 13:01:12 -0800 | [diff] [blame] | 1303 | void glwDisableVertexArrayEXT (GLuint vaobj, GLenum array) |
| 1304 | { |
| 1305 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 1306 | if (!gl) |
| 1307 | return; |
| 1308 | gl->disableVertexArrayEXT(vaobj, array); |
| 1309 | } |
| 1310 | |
Pyry Haulos | 1abab60 | 2014-11-05 17:41:42 -0800 | [diff] [blame] | 1311 | void glwDisableVertexAttribArray (GLuint index) |
Jarkko Poyry | 3c82736 | 2014-09-02 11:48:52 +0300 | [diff] [blame] | 1312 | { |
| 1313 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 1314 | if (!gl) |
Pyry Haulos | 1abab60 | 2014-11-05 17:41:42 -0800 | [diff] [blame] | 1315 | return; |
| 1316 | gl->disableVertexAttribArray(index); |
Jarkko Poyry | 3c82736 | 2014-09-02 11:48:52 +0300 | [diff] [blame] | 1317 | } |
| 1318 | |
Pyry Haulos | 1abab60 | 2014-11-05 17:41:42 -0800 | [diff] [blame] | 1319 | void glwDisablei (GLenum target, GLuint index) |
Jarkko Poyry | 3c82736 | 2014-09-02 11:48:52 +0300 | [diff] [blame] | 1320 | { |
| 1321 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 1322 | if (!gl) |
Pyry Haulos | 1abab60 | 2014-11-05 17:41:42 -0800 | [diff] [blame] | 1323 | return; |
| 1324 | gl->disablei(target, index); |
Jarkko Poyry | 3c82736 | 2014-09-02 11:48:52 +0300 | [diff] [blame] | 1325 | } |
| 1326 | |
| 1327 | void glwDispatchCompute (GLuint num_groups_x, GLuint num_groups_y, GLuint num_groups_z) |
| 1328 | { |
| 1329 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 1330 | if (!gl) |
Pyry Haulos | 1abab60 | 2014-11-05 17:41:42 -0800 | [diff] [blame] | 1331 | return; |
Jarkko Poyry | 3c82736 | 2014-09-02 11:48:52 +0300 | [diff] [blame] | 1332 | gl->dispatchCompute(num_groups_x, num_groups_y, num_groups_z); |
| 1333 | } |
| 1334 | |
| 1335 | void glwDispatchComputeIndirect (GLintptr indirect) |
| 1336 | { |
| 1337 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 1338 | if (!gl) |
Pyry Haulos | 1abab60 | 2014-11-05 17:41:42 -0800 | [diff] [blame] | 1339 | return; |
Jarkko Poyry | 3c82736 | 2014-09-02 11:48:52 +0300 | [diff] [blame] | 1340 | gl->dispatchComputeIndirect(indirect); |
| 1341 | } |
| 1342 | |
Pyry Haulos | 1abab60 | 2014-11-05 17:41:42 -0800 | [diff] [blame] | 1343 | void glwDrawArrays (GLenum mode, GLint first, GLsizei count) |
Jarkko Poyry | 3c82736 | 2014-09-02 11:48:52 +0300 | [diff] [blame] | 1344 | { |
| 1345 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 1346 | if (!gl) |
Pyry Haulos | 1abab60 | 2014-11-05 17:41:42 -0800 | [diff] [blame] | 1347 | return; |
| 1348 | gl->drawArrays(mode, first, count); |
Jarkko Poyry | 3c82736 | 2014-09-02 11:48:52 +0300 | [diff] [blame] | 1349 | } |
| 1350 | |
Pyry Haulos | 1abab60 | 2014-11-05 17:41:42 -0800 | [diff] [blame] | 1351 | void glwDrawArraysIndirect (GLenum mode, const void *indirect) |
Jarkko Poyry | 3c82736 | 2014-09-02 11:48:52 +0300 | [diff] [blame] | 1352 | { |
| 1353 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 1354 | if (!gl) |
Pyry Haulos | 1abab60 | 2014-11-05 17:41:42 -0800 | [diff] [blame] | 1355 | return; |
| 1356 | gl->drawArraysIndirect(mode, indirect); |
Jarkko Poyry | 3c82736 | 2014-09-02 11:48:52 +0300 | [diff] [blame] | 1357 | } |
| 1358 | |
Pyry Haulos | 1abab60 | 2014-11-05 17:41:42 -0800 | [diff] [blame] | 1359 | void glwDrawArraysInstanced (GLenum mode, GLint first, GLsizei count, GLsizei instancecount) |
Jarkko Poyry | 3c82736 | 2014-09-02 11:48:52 +0300 | [diff] [blame] | 1360 | { |
| 1361 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 1362 | if (!gl) |
Pyry Haulos | 1abab60 | 2014-11-05 17:41:42 -0800 | [diff] [blame] | 1363 | return; |
| 1364 | gl->drawArraysInstanced(mode, first, count, instancecount); |
Jarkko Poyry | 3c82736 | 2014-09-02 11:48:52 +0300 | [diff] [blame] | 1365 | } |
| 1366 | |
Pyry Haulos | 1abab60 | 2014-11-05 17:41:42 -0800 | [diff] [blame] | 1367 | void glwDrawArraysInstancedBaseInstance (GLenum mode, GLint first, GLsizei count, GLsizei instancecount, GLuint baseinstance) |
Jarkko Poyry | 3c82736 | 2014-09-02 11:48:52 +0300 | [diff] [blame] | 1368 | { |
| 1369 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 1370 | if (!gl) |
Pyry Haulos | 1abab60 | 2014-11-05 17:41:42 -0800 | [diff] [blame] | 1371 | return; |
| 1372 | gl->drawArraysInstancedBaseInstance(mode, first, count, instancecount, baseinstance); |
Jarkko Poyry | 3c82736 | 2014-09-02 11:48:52 +0300 | [diff] [blame] | 1373 | } |
| 1374 | |
Pyry Haulos | 1abab60 | 2014-11-05 17:41:42 -0800 | [diff] [blame] | 1375 | void glwDrawBuffer (GLenum buf) |
Jarkko Poyry | 3c82736 | 2014-09-02 11:48:52 +0300 | [diff] [blame] | 1376 | { |
| 1377 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 1378 | if (!gl) |
Pyry Haulos | 1abab60 | 2014-11-05 17:41:42 -0800 | [diff] [blame] | 1379 | return; |
| 1380 | gl->drawBuffer(buf); |
Jarkko Poyry | 3c82736 | 2014-09-02 11:48:52 +0300 | [diff] [blame] | 1381 | } |
| 1382 | |
Pyry Haulos | 1abab60 | 2014-11-05 17:41:42 -0800 | [diff] [blame] | 1383 | void glwDrawBuffers (GLsizei n, const GLenum *bufs) |
Jarkko Poyry | 3c82736 | 2014-09-02 11:48:52 +0300 | [diff] [blame] | 1384 | { |
| 1385 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 1386 | if (!gl) |
Pyry Haulos | 1abab60 | 2014-11-05 17:41:42 -0800 | [diff] [blame] | 1387 | return; |
| 1388 | gl->drawBuffers(n, bufs); |
Jarkko Poyry | 3c82736 | 2014-09-02 11:48:52 +0300 | [diff] [blame] | 1389 | } |
| 1390 | |
Pyry Haulos | 1abab60 | 2014-11-05 17:41:42 -0800 | [diff] [blame] | 1391 | void glwDrawElements (GLenum mode, GLsizei count, GLenum type, const void *indices) |
Jarkko Poyry | 3c82736 | 2014-09-02 11:48:52 +0300 | [diff] [blame] | 1392 | { |
| 1393 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 1394 | if (!gl) |
Pyry Haulos | 1abab60 | 2014-11-05 17:41:42 -0800 | [diff] [blame] | 1395 | return; |
| 1396 | gl->drawElements(mode, count, type, indices); |
Jarkko Poyry | 3c82736 | 2014-09-02 11:48:52 +0300 | [diff] [blame] | 1397 | } |
| 1398 | |
Pyry Haulos | 1abab60 | 2014-11-05 17:41:42 -0800 | [diff] [blame] | 1399 | void glwDrawElementsBaseVertex (GLenum mode, GLsizei count, GLenum type, const void *indices, GLint basevertex) |
Jarkko Poyry | 3c82736 | 2014-09-02 11:48:52 +0300 | [diff] [blame] | 1400 | { |
| 1401 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 1402 | if (!gl) |
Pyry Haulos | 1abab60 | 2014-11-05 17:41:42 -0800 | [diff] [blame] | 1403 | return; |
| 1404 | gl->drawElementsBaseVertex(mode, count, type, indices, basevertex); |
Jarkko Poyry | 3c82736 | 2014-09-02 11:48:52 +0300 | [diff] [blame] | 1405 | } |
| 1406 | |
Pyry Haulos | 1abab60 | 2014-11-05 17:41:42 -0800 | [diff] [blame] | 1407 | void glwDrawElementsIndirect (GLenum mode, GLenum type, const void *indirect) |
Jarkko Poyry | 3c82736 | 2014-09-02 11:48:52 +0300 | [diff] [blame] | 1408 | { |
| 1409 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 1410 | if (!gl) |
Pyry Haulos | 1abab60 | 2014-11-05 17:41:42 -0800 | [diff] [blame] | 1411 | return; |
| 1412 | gl->drawElementsIndirect(mode, type, indirect); |
Jarkko Poyry | 3c82736 | 2014-09-02 11:48:52 +0300 | [diff] [blame] | 1413 | } |
| 1414 | |
Pyry Haulos | 1abab60 | 2014-11-05 17:41:42 -0800 | [diff] [blame] | 1415 | void glwDrawElementsInstanced (GLenum mode, GLsizei count, GLenum type, const void *indices, GLsizei instancecount) |
Jarkko Poyry | 3c82736 | 2014-09-02 11:48:52 +0300 | [diff] [blame] | 1416 | { |
| 1417 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 1418 | if (!gl) |
Pyry Haulos | 1abab60 | 2014-11-05 17:41:42 -0800 | [diff] [blame] | 1419 | return; |
| 1420 | gl->drawElementsInstanced(mode, count, type, indices, instancecount); |
Jarkko Poyry | 3c82736 | 2014-09-02 11:48:52 +0300 | [diff] [blame] | 1421 | } |
| 1422 | |
Pyry Haulos | 1abab60 | 2014-11-05 17:41:42 -0800 | [diff] [blame] | 1423 | void glwDrawElementsInstancedBaseInstance (GLenum mode, GLsizei count, GLenum type, const void *indices, GLsizei instancecount, GLuint baseinstance) |
Jarkko Poyry | 3c82736 | 2014-09-02 11:48:52 +0300 | [diff] [blame] | 1424 | { |
| 1425 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 1426 | if (!gl) |
Pyry Haulos | 1abab60 | 2014-11-05 17:41:42 -0800 | [diff] [blame] | 1427 | return; |
| 1428 | gl->drawElementsInstancedBaseInstance(mode, count, type, indices, instancecount, baseinstance); |
| 1429 | } |
| 1430 | |
| 1431 | void glwDrawElementsInstancedBaseVertex (GLenum mode, GLsizei count, GLenum type, const void *indices, GLsizei instancecount, GLint basevertex) |
| 1432 | { |
| 1433 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 1434 | if (!gl) |
| 1435 | return; |
| 1436 | gl->drawElementsInstancedBaseVertex(mode, count, type, indices, instancecount, basevertex); |
| 1437 | } |
| 1438 | |
| 1439 | void glwDrawElementsInstancedBaseVertexBaseInstance (GLenum mode, GLsizei count, GLenum type, const void *indices, GLsizei instancecount, GLint basevertex, GLuint baseinstance) |
| 1440 | { |
| 1441 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 1442 | if (!gl) |
| 1443 | return; |
| 1444 | gl->drawElementsInstancedBaseVertexBaseInstance(mode, count, type, indices, instancecount, basevertex, baseinstance); |
| 1445 | } |
| 1446 | |
| 1447 | void glwDrawRangeElements (GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const void *indices) |
| 1448 | { |
| 1449 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 1450 | if (!gl) |
| 1451 | return; |
| 1452 | gl->drawRangeElements(mode, start, end, count, type, indices); |
| 1453 | } |
| 1454 | |
| 1455 | void glwDrawRangeElementsBaseVertex (GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const void *indices, GLint basevertex) |
| 1456 | { |
| 1457 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 1458 | if (!gl) |
| 1459 | return; |
| 1460 | gl->drawRangeElementsBaseVertex(mode, start, end, count, type, indices, basevertex); |
| 1461 | } |
| 1462 | |
| 1463 | void glwDrawTransformFeedback (GLenum mode, GLuint id) |
| 1464 | { |
| 1465 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 1466 | if (!gl) |
| 1467 | return; |
| 1468 | gl->drawTransformFeedback(mode, id); |
| 1469 | } |
| 1470 | |
| 1471 | void glwDrawTransformFeedbackInstanced (GLenum mode, GLuint id, GLsizei instancecount) |
| 1472 | { |
| 1473 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 1474 | if (!gl) |
| 1475 | return; |
| 1476 | gl->drawTransformFeedbackInstanced(mode, id, instancecount); |
| 1477 | } |
| 1478 | |
| 1479 | void glwDrawTransformFeedbackStream (GLenum mode, GLuint id, GLuint stream) |
| 1480 | { |
| 1481 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 1482 | if (!gl) |
| 1483 | return; |
| 1484 | gl->drawTransformFeedbackStream(mode, id, stream); |
| 1485 | } |
| 1486 | |
| 1487 | void glwDrawTransformFeedbackStreamInstanced (GLenum mode, GLuint id, GLuint stream, GLsizei instancecount) |
| 1488 | { |
| 1489 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 1490 | if (!gl) |
| 1491 | return; |
| 1492 | gl->drawTransformFeedbackStreamInstanced(mode, id, stream, instancecount); |
| 1493 | } |
| 1494 | |
| 1495 | void glwEGLImageTargetRenderbufferStorageOES (GLenum target, GLeglImageOES image) |
| 1496 | { |
| 1497 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 1498 | if (!gl) |
| 1499 | return; |
| 1500 | gl->eglImageTargetRenderbufferStorageOES(target, image); |
| 1501 | } |
| 1502 | |
| 1503 | void glwEGLImageTargetTexture2DOES (GLenum target, GLeglImageOES image) |
| 1504 | { |
| 1505 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 1506 | if (!gl) |
| 1507 | return; |
| 1508 | gl->eglImageTargetTexture2DOES(target, image); |
| 1509 | } |
| 1510 | |
| 1511 | void glwEnable (GLenum cap) |
| 1512 | { |
| 1513 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 1514 | if (!gl) |
| 1515 | return; |
| 1516 | gl->enable(cap); |
| 1517 | } |
| 1518 | |
Pyry Haulos | 933ef4d | 2016-11-14 13:01:12 -0800 | [diff] [blame] | 1519 | void glwEnableClientStateIndexedEXT (GLenum array, GLuint index) |
| 1520 | { |
| 1521 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 1522 | if (!gl) |
| 1523 | return; |
| 1524 | gl->enableClientStateIndexedEXT(array, index); |
| 1525 | } |
| 1526 | |
| 1527 | void glwEnableClientStateiEXT (GLenum array, GLuint index) |
| 1528 | { |
| 1529 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 1530 | if (!gl) |
| 1531 | return; |
| 1532 | gl->enableClientStateiEXT(array, index); |
| 1533 | } |
| 1534 | |
| 1535 | void glwEnableIndexedEXT (GLenum target, GLuint index) |
| 1536 | { |
| 1537 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 1538 | if (!gl) |
| 1539 | return; |
| 1540 | gl->enableIndexedEXT(target, index); |
| 1541 | } |
| 1542 | |
Pyry Haulos | 1abab60 | 2014-11-05 17:41:42 -0800 | [diff] [blame] | 1543 | void glwEnableVertexArrayAttrib (GLuint vaobj, GLuint index) |
| 1544 | { |
| 1545 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 1546 | if (!gl) |
| 1547 | return; |
| 1548 | gl->enableVertexArrayAttrib(vaobj, index); |
| 1549 | } |
| 1550 | |
Pyry Haulos | 933ef4d | 2016-11-14 13:01:12 -0800 | [diff] [blame] | 1551 | void glwEnableVertexArrayEXT (GLuint vaobj, GLenum array) |
| 1552 | { |
| 1553 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 1554 | if (!gl) |
| 1555 | return; |
| 1556 | gl->enableVertexArrayEXT(vaobj, array); |
| 1557 | } |
| 1558 | |
Pyry Haulos | 1abab60 | 2014-11-05 17:41:42 -0800 | [diff] [blame] | 1559 | void glwEnableVertexAttribArray (GLuint index) |
| 1560 | { |
| 1561 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 1562 | if (!gl) |
| 1563 | return; |
| 1564 | gl->enableVertexAttribArray(index); |
| 1565 | } |
| 1566 | |
| 1567 | void glwEnablei (GLenum target, GLuint index) |
| 1568 | { |
| 1569 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 1570 | if (!gl) |
| 1571 | return; |
| 1572 | gl->enablei(target, index); |
| 1573 | } |
| 1574 | |
| 1575 | void glwEndConditionalRender (void) |
| 1576 | { |
| 1577 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 1578 | if (!gl) |
| 1579 | return; |
| 1580 | gl->endConditionalRender(); |
| 1581 | } |
| 1582 | |
| 1583 | void glwEndQuery (GLenum target) |
| 1584 | { |
| 1585 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 1586 | if (!gl) |
| 1587 | return; |
| 1588 | gl->endQuery(target); |
| 1589 | } |
| 1590 | |
| 1591 | void glwEndQueryIndexed (GLenum target, GLuint index) |
| 1592 | { |
| 1593 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 1594 | if (!gl) |
| 1595 | return; |
| 1596 | gl->endQueryIndexed(target, index); |
| 1597 | } |
| 1598 | |
| 1599 | void glwEndTransformFeedback (void) |
| 1600 | { |
| 1601 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 1602 | if (!gl) |
| 1603 | return; |
| 1604 | gl->endTransformFeedback(); |
| 1605 | } |
| 1606 | |
| 1607 | GLsync glwFenceSync (GLenum condition, GLbitfield flags) |
| 1608 | { |
| 1609 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 1610 | if (!gl) |
| 1611 | return (GLsync)0; |
| 1612 | return gl->fenceSync(condition, flags); |
| 1613 | } |
| 1614 | |
| 1615 | void glwFinish (void) |
| 1616 | { |
| 1617 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 1618 | if (!gl) |
| 1619 | return; |
| 1620 | gl->finish(); |
| 1621 | } |
| 1622 | |
| 1623 | void glwFlush (void) |
| 1624 | { |
| 1625 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 1626 | if (!gl) |
| 1627 | return; |
| 1628 | gl->flush(); |
| 1629 | } |
| 1630 | |
| 1631 | void glwFlushMappedBufferRange (GLenum target, GLintptr offset, GLsizeiptr length) |
| 1632 | { |
| 1633 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 1634 | if (!gl) |
| 1635 | return; |
| 1636 | gl->flushMappedBufferRange(target, offset, length); |
| 1637 | } |
| 1638 | |
Mika Isojärvi | 314799d | 2015-01-23 15:01:53 -0800 | [diff] [blame] | 1639 | void glwFlushMappedNamedBufferRange (GLuint buffer, GLintptr offset, GLsizeiptr length) |
Pyry Haulos | 1abab60 | 2014-11-05 17:41:42 -0800 | [diff] [blame] | 1640 | { |
| 1641 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 1642 | if (!gl) |
| 1643 | return; |
| 1644 | gl->flushMappedNamedBufferRange(buffer, offset, length); |
Jarkko Poyry | 3c82736 | 2014-09-02 11:48:52 +0300 | [diff] [blame] | 1645 | } |
| 1646 | |
Pyry Haulos | 933ef4d | 2016-11-14 13:01:12 -0800 | [diff] [blame] | 1647 | void glwFramebufferDrawBufferEXT (GLuint framebuffer, GLenum mode) |
| 1648 | { |
| 1649 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 1650 | if (!gl) |
| 1651 | return; |
| 1652 | gl->framebufferDrawBufferEXT(framebuffer, mode); |
| 1653 | } |
| 1654 | |
| 1655 | void glwFramebufferDrawBuffersEXT (GLuint framebuffer, GLsizei n, const GLenum *bufs) |
| 1656 | { |
| 1657 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 1658 | if (!gl) |
| 1659 | return; |
| 1660 | gl->framebufferDrawBuffersEXT(framebuffer, n, bufs); |
| 1661 | } |
| 1662 | |
Jarkko Poyry | 3c82736 | 2014-09-02 11:48:52 +0300 | [diff] [blame] | 1663 | void glwFramebufferParameteri (GLenum target, GLenum pname, GLint param) |
| 1664 | { |
| 1665 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 1666 | if (!gl) |
Pyry Haulos | 1abab60 | 2014-11-05 17:41:42 -0800 | [diff] [blame] | 1667 | return; |
Jarkko Poyry | 3c82736 | 2014-09-02 11:48:52 +0300 | [diff] [blame] | 1668 | gl->framebufferParameteri(target, pname, param); |
| 1669 | } |
| 1670 | |
Pyry Haulos | 933ef4d | 2016-11-14 13:01:12 -0800 | [diff] [blame] | 1671 | void glwFramebufferReadBufferEXT (GLuint framebuffer, GLenum mode) |
| 1672 | { |
| 1673 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 1674 | if (!gl) |
| 1675 | return; |
| 1676 | gl->framebufferReadBufferEXT(framebuffer, mode); |
| 1677 | } |
| 1678 | |
Pyry Haulos | 1abab60 | 2014-11-05 17:41:42 -0800 | [diff] [blame] | 1679 | void glwFramebufferRenderbuffer (GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer) |
Jarkko Poyry | 3c82736 | 2014-09-02 11:48:52 +0300 | [diff] [blame] | 1680 | { |
| 1681 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 1682 | if (!gl) |
Pyry Haulos | 1abab60 | 2014-11-05 17:41:42 -0800 | [diff] [blame] | 1683 | return; |
| 1684 | gl->framebufferRenderbuffer(target, attachment, renderbuffertarget, renderbuffer); |
| 1685 | } |
| 1686 | |
| 1687 | void glwFramebufferTexture (GLenum target, GLenum attachment, GLuint texture, GLint level) |
| 1688 | { |
| 1689 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 1690 | if (!gl) |
| 1691 | return; |
| 1692 | gl->framebufferTexture(target, attachment, texture, level); |
| 1693 | } |
| 1694 | |
| 1695 | void glwFramebufferTexture1D (GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level) |
| 1696 | { |
| 1697 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 1698 | if (!gl) |
| 1699 | return; |
| 1700 | gl->framebufferTexture1D(target, attachment, textarget, texture, level); |
| 1701 | } |
| 1702 | |
| 1703 | void glwFramebufferTexture2D (GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level) |
| 1704 | { |
| 1705 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 1706 | if (!gl) |
| 1707 | return; |
| 1708 | gl->framebufferTexture2D(target, attachment, textarget, texture, level); |
| 1709 | } |
| 1710 | |
| 1711 | void glwFramebufferTexture3D (GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level, GLint zoffset) |
| 1712 | { |
| 1713 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 1714 | if (!gl) |
| 1715 | return; |
| 1716 | gl->framebufferTexture3D(target, attachment, textarget, texture, level, zoffset); |
| 1717 | } |
| 1718 | |
Pyry Haulos | 933ef4d | 2016-11-14 13:01:12 -0800 | [diff] [blame] | 1719 | void glwFramebufferTexture3DOES (GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level, GLint zoffset) |
| 1720 | { |
| 1721 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 1722 | if (!gl) |
| 1723 | return; |
| 1724 | gl->framebufferTexture3DOES(target, attachment, textarget, texture, level, zoffset); |
| 1725 | } |
| 1726 | |
Pyry Haulos | 1abab60 | 2014-11-05 17:41:42 -0800 | [diff] [blame] | 1727 | void glwFramebufferTextureLayer (GLenum target, GLenum attachment, GLuint texture, GLint level, GLint layer) |
| 1728 | { |
| 1729 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 1730 | if (!gl) |
| 1731 | return; |
| 1732 | gl->framebufferTextureLayer(target, attachment, texture, level, layer); |
| 1733 | } |
| 1734 | |
| 1735 | void glwFrontFace (GLenum mode) |
| 1736 | { |
| 1737 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 1738 | if (!gl) |
| 1739 | return; |
| 1740 | gl->frontFace(mode); |
| 1741 | } |
| 1742 | |
| 1743 | void glwGenBuffers (GLsizei n, GLuint *buffers) |
| 1744 | { |
| 1745 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 1746 | if (!gl) |
| 1747 | return; |
| 1748 | gl->genBuffers(n, buffers); |
| 1749 | } |
| 1750 | |
| 1751 | void glwGenFramebuffers (GLsizei n, GLuint *framebuffers) |
| 1752 | { |
| 1753 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 1754 | if (!gl) |
| 1755 | return; |
| 1756 | gl->genFramebuffers(n, framebuffers); |
| 1757 | } |
| 1758 | |
| 1759 | void glwGenProgramPipelines (GLsizei n, GLuint *pipelines) |
| 1760 | { |
| 1761 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 1762 | if (!gl) |
| 1763 | return; |
| 1764 | gl->genProgramPipelines(n, pipelines); |
| 1765 | } |
| 1766 | |
| 1767 | void glwGenQueries (GLsizei n, GLuint *ids) |
| 1768 | { |
| 1769 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 1770 | if (!gl) |
| 1771 | return; |
| 1772 | gl->genQueries(n, ids); |
| 1773 | } |
| 1774 | |
| 1775 | void glwGenRenderbuffers (GLsizei n, GLuint *renderbuffers) |
| 1776 | { |
| 1777 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 1778 | if (!gl) |
| 1779 | return; |
| 1780 | gl->genRenderbuffers(n, renderbuffers); |
| 1781 | } |
| 1782 | |
| 1783 | void glwGenSamplers (GLsizei count, GLuint *samplers) |
| 1784 | { |
| 1785 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 1786 | if (!gl) |
| 1787 | return; |
| 1788 | gl->genSamplers(count, samplers); |
| 1789 | } |
| 1790 | |
| 1791 | void glwGenTextures (GLsizei n, GLuint *textures) |
| 1792 | { |
| 1793 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 1794 | if (!gl) |
| 1795 | return; |
| 1796 | gl->genTextures(n, textures); |
| 1797 | } |
| 1798 | |
| 1799 | void glwGenTransformFeedbacks (GLsizei n, GLuint *ids) |
| 1800 | { |
| 1801 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 1802 | if (!gl) |
| 1803 | return; |
| 1804 | gl->genTransformFeedbacks(n, ids); |
| 1805 | } |
| 1806 | |
| 1807 | void glwGenVertexArrays (GLsizei n, GLuint *arrays) |
| 1808 | { |
| 1809 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 1810 | if (!gl) |
| 1811 | return; |
| 1812 | gl->genVertexArrays(n, arrays); |
| 1813 | } |
| 1814 | |
| 1815 | void glwGenerateMipmap (GLenum target) |
| 1816 | { |
| 1817 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 1818 | if (!gl) |
| 1819 | return; |
| 1820 | gl->generateMipmap(target); |
| 1821 | } |
| 1822 | |
Pyry Haulos | 933ef4d | 2016-11-14 13:01:12 -0800 | [diff] [blame] | 1823 | void glwGenerateMultiTexMipmapEXT (GLenum texunit, GLenum target) |
| 1824 | { |
| 1825 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 1826 | if (!gl) |
| 1827 | return; |
| 1828 | gl->generateMultiTexMipmapEXT(texunit, target); |
| 1829 | } |
| 1830 | |
Pyry Haulos | 1abab60 | 2014-11-05 17:41:42 -0800 | [diff] [blame] | 1831 | void glwGenerateTextureMipmap (GLuint texture) |
| 1832 | { |
| 1833 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 1834 | if (!gl) |
| 1835 | return; |
| 1836 | gl->generateTextureMipmap(texture); |
| 1837 | } |
| 1838 | |
| 1839 | void glwGetActiveAtomicCounterBufferiv (GLuint program, GLuint bufferIndex, GLenum pname, GLint *params) |
| 1840 | { |
| 1841 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 1842 | if (!gl) |
| 1843 | return; |
| 1844 | gl->getActiveAtomicCounterBufferiv(program, bufferIndex, pname, params); |
| 1845 | } |
| 1846 | |
| 1847 | void glwGetActiveAttrib (GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLint *size, GLenum *type, GLchar *name) |
| 1848 | { |
| 1849 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 1850 | if (!gl) |
| 1851 | return; |
| 1852 | gl->getActiveAttrib(program, index, bufSize, length, size, type, name); |
| 1853 | } |
| 1854 | |
| 1855 | void glwGetActiveSubroutineName (GLuint program, GLenum shadertype, GLuint index, GLsizei bufsize, GLsizei *length, GLchar *name) |
| 1856 | { |
| 1857 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 1858 | if (!gl) |
| 1859 | return; |
| 1860 | gl->getActiveSubroutineName(program, shadertype, index, bufsize, length, name); |
| 1861 | } |
| 1862 | |
| 1863 | void glwGetActiveSubroutineUniformName (GLuint program, GLenum shadertype, GLuint index, GLsizei bufsize, GLsizei *length, GLchar *name) |
| 1864 | { |
| 1865 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 1866 | if (!gl) |
| 1867 | return; |
| 1868 | gl->getActiveSubroutineUniformName(program, shadertype, index, bufsize, length, name); |
| 1869 | } |
| 1870 | |
| 1871 | void glwGetActiveSubroutineUniformiv (GLuint program, GLenum shadertype, GLuint index, GLenum pname, GLint *values) |
| 1872 | { |
| 1873 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 1874 | if (!gl) |
| 1875 | return; |
| 1876 | gl->getActiveSubroutineUniformiv(program, shadertype, index, pname, values); |
| 1877 | } |
| 1878 | |
| 1879 | void glwGetActiveUniform (GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLint *size, GLenum *type, GLchar *name) |
| 1880 | { |
| 1881 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 1882 | if (!gl) |
| 1883 | return; |
| 1884 | gl->getActiveUniform(program, index, bufSize, length, size, type, name); |
| 1885 | } |
| 1886 | |
| 1887 | void glwGetActiveUniformBlockName (GLuint program, GLuint uniformBlockIndex, GLsizei bufSize, GLsizei *length, GLchar *uniformBlockName) |
| 1888 | { |
| 1889 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 1890 | if (!gl) |
| 1891 | return; |
| 1892 | gl->getActiveUniformBlockName(program, uniformBlockIndex, bufSize, length, uniformBlockName); |
| 1893 | } |
| 1894 | |
| 1895 | void glwGetActiveUniformBlockiv (GLuint program, GLuint uniformBlockIndex, GLenum pname, GLint *params) |
| 1896 | { |
| 1897 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 1898 | if (!gl) |
| 1899 | return; |
| 1900 | gl->getActiveUniformBlockiv(program, uniformBlockIndex, pname, params); |
| 1901 | } |
| 1902 | |
| 1903 | void glwGetActiveUniformName (GLuint program, GLuint uniformIndex, GLsizei bufSize, GLsizei *length, GLchar *uniformName) |
| 1904 | { |
| 1905 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 1906 | if (!gl) |
| 1907 | return; |
| 1908 | gl->getActiveUniformName(program, uniformIndex, bufSize, length, uniformName); |
| 1909 | } |
| 1910 | |
| 1911 | void glwGetActiveUniformsiv (GLuint program, GLsizei uniformCount, const GLuint *uniformIndices, GLenum pname, GLint *params) |
| 1912 | { |
| 1913 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 1914 | if (!gl) |
| 1915 | return; |
| 1916 | gl->getActiveUniformsiv(program, uniformCount, uniformIndices, pname, params); |
| 1917 | } |
| 1918 | |
| 1919 | void glwGetAttachedShaders (GLuint program, GLsizei maxCount, GLsizei *count, GLuint *shaders) |
| 1920 | { |
| 1921 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 1922 | if (!gl) |
| 1923 | return; |
| 1924 | gl->getAttachedShaders(program, maxCount, count, shaders); |
| 1925 | } |
| 1926 | |
| 1927 | GLint glwGetAttribLocation (GLuint program, const GLchar *name) |
| 1928 | { |
| 1929 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 1930 | if (!gl) |
| 1931 | return (GLint)0; |
| 1932 | return gl->getAttribLocation(program, name); |
| 1933 | } |
| 1934 | |
Pyry Haulos | 933ef4d | 2016-11-14 13:01:12 -0800 | [diff] [blame] | 1935 | void glwGetBooleanIndexedvEXT (GLenum target, GLuint index, GLboolean *data) |
| 1936 | { |
| 1937 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 1938 | if (!gl) |
| 1939 | return; |
| 1940 | gl->getBooleanIndexedvEXT(target, index, data); |
| 1941 | } |
| 1942 | |
Pyry Haulos | 1abab60 | 2014-11-05 17:41:42 -0800 | [diff] [blame] | 1943 | void glwGetBooleani_v (GLenum target, GLuint index, GLboolean *data) |
| 1944 | { |
| 1945 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 1946 | if (!gl) |
| 1947 | return; |
| 1948 | gl->getBooleani_v(target, index, data); |
| 1949 | } |
| 1950 | |
| 1951 | void glwGetBooleanv (GLenum pname, GLboolean *data) |
| 1952 | { |
| 1953 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 1954 | if (!gl) |
| 1955 | return; |
| 1956 | gl->getBooleanv(pname, data); |
| 1957 | } |
| 1958 | |
| 1959 | void glwGetBufferParameteri64v (GLenum target, GLenum pname, GLint64 *params) |
| 1960 | { |
| 1961 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 1962 | if (!gl) |
| 1963 | return; |
| 1964 | gl->getBufferParameteri64v(target, pname, params); |
| 1965 | } |
| 1966 | |
| 1967 | void glwGetBufferParameteriv (GLenum target, GLenum pname, GLint *params) |
| 1968 | { |
| 1969 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 1970 | if (!gl) |
| 1971 | return; |
| 1972 | gl->getBufferParameteriv(target, pname, params); |
| 1973 | } |
| 1974 | |
| 1975 | void glwGetBufferPointerv (GLenum target, GLenum pname, void **params) |
| 1976 | { |
| 1977 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 1978 | if (!gl) |
| 1979 | return; |
| 1980 | gl->getBufferPointerv(target, pname, params); |
| 1981 | } |
| 1982 | |
| 1983 | void glwGetBufferSubData (GLenum target, GLintptr offset, GLsizeiptr size, void *data) |
| 1984 | { |
| 1985 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 1986 | if (!gl) |
| 1987 | return; |
| 1988 | gl->getBufferSubData(target, offset, size, data); |
| 1989 | } |
| 1990 | |
Pyry Haulos | 933ef4d | 2016-11-14 13:01:12 -0800 | [diff] [blame] | 1991 | void glwGetCompressedMultiTexImageEXT (GLenum texunit, GLenum target, GLint lod, void *img) |
| 1992 | { |
| 1993 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 1994 | if (!gl) |
| 1995 | return; |
| 1996 | gl->getCompressedMultiTexImageEXT(texunit, target, lod, img); |
| 1997 | } |
| 1998 | |
Pyry Haulos | 1abab60 | 2014-11-05 17:41:42 -0800 | [diff] [blame] | 1999 | void glwGetCompressedTexImage (GLenum target, GLint level, void *img) |
| 2000 | { |
| 2001 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 2002 | if (!gl) |
| 2003 | return; |
| 2004 | gl->getCompressedTexImage(target, level, img); |
| 2005 | } |
| 2006 | |
| 2007 | void glwGetCompressedTextureImage (GLuint texture, GLint level, GLsizei bufSize, void *pixels) |
| 2008 | { |
| 2009 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 2010 | if (!gl) |
| 2011 | return; |
| 2012 | gl->getCompressedTextureImage(texture, level, bufSize, pixels); |
| 2013 | } |
| 2014 | |
| 2015 | void glwGetCompressedTextureSubImage (GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLsizei bufSize, void *pixels) |
| 2016 | { |
| 2017 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 2018 | if (!gl) |
| 2019 | return; |
| 2020 | gl->getCompressedTextureSubImage(texture, level, xoffset, yoffset, zoffset, width, height, depth, bufSize, pixels); |
| 2021 | } |
| 2022 | |
| 2023 | GLuint glwGetDebugMessageLog (GLuint count, GLsizei bufSize, GLenum *sources, GLenum *types, GLuint *ids, GLenum *severities, GLsizei *lengths, GLchar *messageLog) |
| 2024 | { |
| 2025 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 2026 | if (!gl) |
| 2027 | return (GLuint)0; |
| 2028 | return gl->getDebugMessageLog(count, bufSize, sources, types, ids, severities, lengths, messageLog); |
| 2029 | } |
| 2030 | |
Pyry Haulos | 933ef4d | 2016-11-14 13:01:12 -0800 | [diff] [blame] | 2031 | void glwGetDoubleIndexedvEXT (GLenum target, GLuint index, GLdouble *data) |
| 2032 | { |
| 2033 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 2034 | if (!gl) |
| 2035 | return; |
| 2036 | gl->getDoubleIndexedvEXT(target, index, data); |
| 2037 | } |
| 2038 | |
Pyry Haulos | 1abab60 | 2014-11-05 17:41:42 -0800 | [diff] [blame] | 2039 | void glwGetDoublei_v (GLenum target, GLuint index, GLdouble *data) |
| 2040 | { |
| 2041 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 2042 | if (!gl) |
| 2043 | return; |
| 2044 | gl->getDoublei_v(target, index, data); |
| 2045 | } |
| 2046 | |
| 2047 | void glwGetDoublev (GLenum pname, GLdouble *data) |
| 2048 | { |
| 2049 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 2050 | if (!gl) |
| 2051 | return; |
| 2052 | gl->getDoublev(pname, data); |
| 2053 | } |
| 2054 | |
| 2055 | GLenum glwGetError (void) |
| 2056 | { |
| 2057 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 2058 | if (!gl) |
| 2059 | return GL_INVALID_OPERATION; |
| 2060 | return gl->getError(); |
| 2061 | } |
| 2062 | |
Pyry Haulos | 933ef4d | 2016-11-14 13:01:12 -0800 | [diff] [blame] | 2063 | void glwGetFloatIndexedvEXT (GLenum target, GLuint index, GLfloat *data) |
| 2064 | { |
| 2065 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 2066 | if (!gl) |
| 2067 | return; |
| 2068 | gl->getFloatIndexedvEXT(target, index, data); |
| 2069 | } |
| 2070 | |
Pyry Haulos | 1abab60 | 2014-11-05 17:41:42 -0800 | [diff] [blame] | 2071 | void glwGetFloati_v (GLenum target, GLuint index, GLfloat *data) |
| 2072 | { |
| 2073 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 2074 | if (!gl) |
| 2075 | return; |
| 2076 | gl->getFloati_v(target, index, data); |
| 2077 | } |
| 2078 | |
| 2079 | void glwGetFloatv (GLenum pname, GLfloat *data) |
| 2080 | { |
| 2081 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 2082 | if (!gl) |
| 2083 | return; |
| 2084 | gl->getFloatv(pname, data); |
| 2085 | } |
| 2086 | |
| 2087 | GLint glwGetFragDataIndex (GLuint program, const GLchar *name) |
| 2088 | { |
| 2089 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 2090 | if (!gl) |
| 2091 | return (GLint)0; |
| 2092 | return gl->getFragDataIndex(program, name); |
| 2093 | } |
| 2094 | |
| 2095 | GLint glwGetFragDataLocation (GLuint program, const GLchar *name) |
| 2096 | { |
| 2097 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 2098 | if (!gl) |
| 2099 | return (GLint)0; |
| 2100 | return gl->getFragDataLocation(program, name); |
| 2101 | } |
| 2102 | |
| 2103 | void glwGetFramebufferAttachmentParameteriv (GLenum target, GLenum attachment, GLenum pname, GLint *params) |
| 2104 | { |
| 2105 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 2106 | if (!gl) |
| 2107 | return; |
| 2108 | gl->getFramebufferAttachmentParameteriv(target, attachment, pname, params); |
| 2109 | } |
| 2110 | |
| 2111 | void glwGetFramebufferParameteriv (GLenum target, GLenum pname, GLint *params) |
| 2112 | { |
| 2113 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 2114 | if (!gl) |
| 2115 | return; |
Jarkko Poyry | 3c82736 | 2014-09-02 11:48:52 +0300 | [diff] [blame] | 2116 | gl->getFramebufferParameteriv(target, pname, params); |
| 2117 | } |
| 2118 | |
Pyry Haulos | 1abab60 | 2014-11-05 17:41:42 -0800 | [diff] [blame] | 2119 | GLenum glwGetGraphicsResetStatus (void) |
Jarkko Poyry | 3c82736 | 2014-09-02 11:48:52 +0300 | [diff] [blame] | 2120 | { |
| 2121 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 2122 | if (!gl) |
Pyry Haulos | 1abab60 | 2014-11-05 17:41:42 -0800 | [diff] [blame] | 2123 | return (GLenum)0; |
| 2124 | return gl->getGraphicsResetStatus(); |
| 2125 | } |
| 2126 | |
| 2127 | void glwGetInteger64i_v (GLenum target, GLuint index, GLint64 *data) |
| 2128 | { |
| 2129 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 2130 | if (!gl) |
| 2131 | return; |
| 2132 | gl->getInteger64i_v(target, index, data); |
| 2133 | } |
| 2134 | |
| 2135 | void glwGetInteger64v (GLenum pname, GLint64 *data) |
| 2136 | { |
| 2137 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 2138 | if (!gl) |
| 2139 | return; |
| 2140 | gl->getInteger64v(pname, data); |
| 2141 | } |
| 2142 | |
Pyry Haulos | 933ef4d | 2016-11-14 13:01:12 -0800 | [diff] [blame] | 2143 | void glwGetIntegerIndexedvEXT (GLenum target, GLuint index, GLint *data) |
| 2144 | { |
| 2145 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 2146 | if (!gl) |
| 2147 | return; |
| 2148 | gl->getIntegerIndexedvEXT(target, index, data); |
| 2149 | } |
| 2150 | |
Pyry Haulos | 1abab60 | 2014-11-05 17:41:42 -0800 | [diff] [blame] | 2151 | void glwGetIntegeri_v (GLenum target, GLuint index, GLint *data) |
| 2152 | { |
| 2153 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 2154 | if (!gl) |
| 2155 | return; |
| 2156 | gl->getIntegeri_v(target, index, data); |
| 2157 | } |
| 2158 | |
| 2159 | void glwGetIntegerv (GLenum pname, GLint *data) |
| 2160 | { |
| 2161 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 2162 | if (!gl) |
| 2163 | return; |
| 2164 | gl->getIntegerv(pname, data); |
| 2165 | } |
| 2166 | |
Pyry Haulos | 933ef4d | 2016-11-14 13:01:12 -0800 | [diff] [blame] | 2167 | void glwGetInternalformatSampleivNV (GLenum target, GLenum internalformat, GLsizei samples, GLenum pname, GLsizei bufSize, GLint *params) |
| 2168 | { |
| 2169 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 2170 | if (!gl) |
| 2171 | return; |
| 2172 | gl->getInternalformatSampleivNV(target, internalformat, samples, pname, bufSize, params); |
| 2173 | } |
| 2174 | |
Pyry Haulos | 1abab60 | 2014-11-05 17:41:42 -0800 | [diff] [blame] | 2175 | void glwGetInternalformati64v (GLenum target, GLenum internalformat, GLenum pname, GLsizei bufSize, GLint64 *params) |
| 2176 | { |
| 2177 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 2178 | if (!gl) |
| 2179 | return; |
Jarkko Poyry | 3c82736 | 2014-09-02 11:48:52 +0300 | [diff] [blame] | 2180 | gl->getInternalformati64v(target, internalformat, pname, bufSize, params); |
| 2181 | } |
| 2182 | |
Pyry Haulos | 1abab60 | 2014-11-05 17:41:42 -0800 | [diff] [blame] | 2183 | void glwGetInternalformativ (GLenum target, GLenum internalformat, GLenum pname, GLsizei bufSize, GLint *params) |
Jarkko Poyry | 3c82736 | 2014-09-02 11:48:52 +0300 | [diff] [blame] | 2184 | { |
| 2185 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 2186 | if (!gl) |
Pyry Haulos | 1abab60 | 2014-11-05 17:41:42 -0800 | [diff] [blame] | 2187 | return; |
| 2188 | gl->getInternalformativ(target, internalformat, pname, bufSize, params); |
Jarkko Poyry | 3c82736 | 2014-09-02 11:48:52 +0300 | [diff] [blame] | 2189 | } |
| 2190 | |
Pyry Haulos | 933ef4d | 2016-11-14 13:01:12 -0800 | [diff] [blame] | 2191 | void glwGetMultiTexEnvfvEXT (GLenum texunit, GLenum target, GLenum pname, GLfloat *params) |
| 2192 | { |
| 2193 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 2194 | if (!gl) |
| 2195 | return; |
| 2196 | gl->getMultiTexEnvfvEXT(texunit, target, pname, params); |
| 2197 | } |
| 2198 | |
| 2199 | void glwGetMultiTexEnvivEXT (GLenum texunit, GLenum target, GLenum pname, GLint *params) |
| 2200 | { |
| 2201 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 2202 | if (!gl) |
| 2203 | return; |
| 2204 | gl->getMultiTexEnvivEXT(texunit, target, pname, params); |
| 2205 | } |
| 2206 | |
| 2207 | void glwGetMultiTexGendvEXT (GLenum texunit, GLenum coord, GLenum pname, GLdouble *params) |
| 2208 | { |
| 2209 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 2210 | if (!gl) |
| 2211 | return; |
| 2212 | gl->getMultiTexGendvEXT(texunit, coord, pname, params); |
| 2213 | } |
| 2214 | |
| 2215 | void glwGetMultiTexGenfvEXT (GLenum texunit, GLenum coord, GLenum pname, GLfloat *params) |
| 2216 | { |
| 2217 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 2218 | if (!gl) |
| 2219 | return; |
| 2220 | gl->getMultiTexGenfvEXT(texunit, coord, pname, params); |
| 2221 | } |
| 2222 | |
| 2223 | void glwGetMultiTexGenivEXT (GLenum texunit, GLenum coord, GLenum pname, GLint *params) |
| 2224 | { |
| 2225 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 2226 | if (!gl) |
| 2227 | return; |
| 2228 | gl->getMultiTexGenivEXT(texunit, coord, pname, params); |
| 2229 | } |
| 2230 | |
| 2231 | void glwGetMultiTexImageEXT (GLenum texunit, GLenum target, GLint level, GLenum format, GLenum type, void *pixels) |
| 2232 | { |
| 2233 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 2234 | if (!gl) |
| 2235 | return; |
| 2236 | gl->getMultiTexImageEXT(texunit, target, level, format, type, pixels); |
| 2237 | } |
| 2238 | |
| 2239 | void glwGetMultiTexLevelParameterfvEXT (GLenum texunit, GLenum target, GLint level, GLenum pname, GLfloat *params) |
| 2240 | { |
| 2241 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 2242 | if (!gl) |
| 2243 | return; |
| 2244 | gl->getMultiTexLevelParameterfvEXT(texunit, target, level, pname, params); |
| 2245 | } |
| 2246 | |
| 2247 | void glwGetMultiTexLevelParameterivEXT (GLenum texunit, GLenum target, GLint level, GLenum pname, GLint *params) |
| 2248 | { |
| 2249 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 2250 | if (!gl) |
| 2251 | return; |
| 2252 | gl->getMultiTexLevelParameterivEXT(texunit, target, level, pname, params); |
| 2253 | } |
| 2254 | |
| 2255 | void glwGetMultiTexParameterIivEXT (GLenum texunit, GLenum target, GLenum pname, GLint *params) |
| 2256 | { |
| 2257 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 2258 | if (!gl) |
| 2259 | return; |
| 2260 | gl->getMultiTexParameterIivEXT(texunit, target, pname, params); |
| 2261 | } |
| 2262 | |
| 2263 | void glwGetMultiTexParameterIuivEXT (GLenum texunit, GLenum target, GLenum pname, GLuint *params) |
| 2264 | { |
| 2265 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 2266 | if (!gl) |
| 2267 | return; |
| 2268 | gl->getMultiTexParameterIuivEXT(texunit, target, pname, params); |
| 2269 | } |
| 2270 | |
| 2271 | void glwGetMultiTexParameterfvEXT (GLenum texunit, GLenum target, GLenum pname, GLfloat *params) |
| 2272 | { |
| 2273 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 2274 | if (!gl) |
| 2275 | return; |
| 2276 | gl->getMultiTexParameterfvEXT(texunit, target, pname, params); |
| 2277 | } |
| 2278 | |
| 2279 | void glwGetMultiTexParameterivEXT (GLenum texunit, GLenum target, GLenum pname, GLint *params) |
| 2280 | { |
| 2281 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 2282 | if (!gl) |
| 2283 | return; |
| 2284 | gl->getMultiTexParameterivEXT(texunit, target, pname, params); |
| 2285 | } |
| 2286 | |
Pyry Haulos | 1abab60 | 2014-11-05 17:41:42 -0800 | [diff] [blame] | 2287 | void glwGetMultisamplefv (GLenum pname, GLuint index, GLfloat *val) |
Jarkko Poyry | 3c82736 | 2014-09-02 11:48:52 +0300 | [diff] [blame] | 2288 | { |
| 2289 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 2290 | if (!gl) |
Pyry Haulos | 1abab60 | 2014-11-05 17:41:42 -0800 | [diff] [blame] | 2291 | return; |
| 2292 | gl->getMultisamplefv(pname, index, val); |
Jarkko Poyry | 3c82736 | 2014-09-02 11:48:52 +0300 | [diff] [blame] | 2293 | } |
| 2294 | |
Pyry Haulos | 1abab60 | 2014-11-05 17:41:42 -0800 | [diff] [blame] | 2295 | void glwGetNamedBufferParameteri64v (GLuint buffer, GLenum pname, GLint64 *params) |
Jarkko Poyry | 3c82736 | 2014-09-02 11:48:52 +0300 | [diff] [blame] | 2296 | { |
| 2297 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 2298 | if (!gl) |
Pyry Haulos | 1abab60 | 2014-11-05 17:41:42 -0800 | [diff] [blame] | 2299 | return; |
| 2300 | gl->getNamedBufferParameteri64v(buffer, pname, params); |
| 2301 | } |
| 2302 | |
| 2303 | void glwGetNamedBufferParameteriv (GLuint buffer, GLenum pname, GLint *params) |
| 2304 | { |
| 2305 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 2306 | if (!gl) |
| 2307 | return; |
| 2308 | gl->getNamedBufferParameteriv(buffer, pname, params); |
| 2309 | } |
| 2310 | |
| 2311 | void glwGetNamedBufferPointerv (GLuint buffer, GLenum pname, void **params) |
| 2312 | { |
| 2313 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 2314 | if (!gl) |
| 2315 | return; |
| 2316 | gl->getNamedBufferPointerv(buffer, pname, params); |
| 2317 | } |
| 2318 | |
Mika Isojärvi | 314799d | 2015-01-23 15:01:53 -0800 | [diff] [blame] | 2319 | void glwGetNamedBufferSubData (GLuint buffer, GLintptr offset, GLsizeiptr size, void *data) |
Pyry Haulos | 1abab60 | 2014-11-05 17:41:42 -0800 | [diff] [blame] | 2320 | { |
| 2321 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 2322 | if (!gl) |
| 2323 | return; |
| 2324 | gl->getNamedBufferSubData(buffer, offset, size, data); |
| 2325 | } |
| 2326 | |
| 2327 | void glwGetNamedFramebufferAttachmentParameteriv (GLuint framebuffer, GLenum attachment, GLenum pname, GLint *params) |
| 2328 | { |
| 2329 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 2330 | if (!gl) |
| 2331 | return; |
| 2332 | gl->getNamedFramebufferAttachmentParameteriv(framebuffer, attachment, pname, params); |
| 2333 | } |
| 2334 | |
| 2335 | void glwGetNamedFramebufferParameteriv (GLuint framebuffer, GLenum pname, GLint *param) |
| 2336 | { |
| 2337 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 2338 | if (!gl) |
| 2339 | return; |
| 2340 | gl->getNamedFramebufferParameteriv(framebuffer, pname, param); |
| 2341 | } |
| 2342 | |
Pyry Haulos | 933ef4d | 2016-11-14 13:01:12 -0800 | [diff] [blame] | 2343 | void glwGetNamedProgramLocalParameterIivEXT (GLuint program, GLenum target, GLuint index, GLint *params) |
| 2344 | { |
| 2345 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 2346 | if (!gl) |
| 2347 | return; |
| 2348 | gl->getNamedProgramLocalParameterIivEXT(program, target, index, params); |
| 2349 | } |
| 2350 | |
| 2351 | void glwGetNamedProgramLocalParameterIuivEXT (GLuint program, GLenum target, GLuint index, GLuint *params) |
| 2352 | { |
| 2353 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 2354 | if (!gl) |
| 2355 | return; |
| 2356 | gl->getNamedProgramLocalParameterIuivEXT(program, target, index, params); |
| 2357 | } |
| 2358 | |
| 2359 | void glwGetNamedProgramLocalParameterdvEXT (GLuint program, GLenum target, GLuint index, GLdouble *params) |
| 2360 | { |
| 2361 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 2362 | if (!gl) |
| 2363 | return; |
| 2364 | gl->getNamedProgramLocalParameterdvEXT(program, target, index, params); |
| 2365 | } |
| 2366 | |
| 2367 | void glwGetNamedProgramLocalParameterfvEXT (GLuint program, GLenum target, GLuint index, GLfloat *params) |
| 2368 | { |
| 2369 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 2370 | if (!gl) |
| 2371 | return; |
| 2372 | gl->getNamedProgramLocalParameterfvEXT(program, target, index, params); |
| 2373 | } |
| 2374 | |
| 2375 | void glwGetNamedProgramStringEXT (GLuint program, GLenum target, GLenum pname, void *string) |
| 2376 | { |
| 2377 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 2378 | if (!gl) |
| 2379 | return; |
| 2380 | gl->getNamedProgramStringEXT(program, target, pname, string); |
| 2381 | } |
| 2382 | |
| 2383 | void glwGetNamedProgramivEXT (GLuint program, GLenum target, GLenum pname, GLint *params) |
| 2384 | { |
| 2385 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 2386 | if (!gl) |
| 2387 | return; |
| 2388 | gl->getNamedProgramivEXT(program, target, pname, params); |
| 2389 | } |
| 2390 | |
Pyry Haulos | 1abab60 | 2014-11-05 17:41:42 -0800 | [diff] [blame] | 2391 | void glwGetNamedRenderbufferParameteriv (GLuint renderbuffer, GLenum pname, GLint *params) |
| 2392 | { |
| 2393 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 2394 | if (!gl) |
| 2395 | return; |
| 2396 | gl->getNamedRenderbufferParameteriv(renderbuffer, pname, params); |
| 2397 | } |
| 2398 | |
| 2399 | void glwGetObjectLabel (GLenum identifier, GLuint name, GLsizei bufSize, GLsizei *length, GLchar *label) |
| 2400 | { |
| 2401 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 2402 | if (!gl) |
| 2403 | return; |
| 2404 | gl->getObjectLabel(identifier, name, bufSize, length, label); |
| 2405 | } |
| 2406 | |
| 2407 | void glwGetObjectPtrLabel (const void *ptr, GLsizei bufSize, GLsizei *length, GLchar *label) |
| 2408 | { |
| 2409 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 2410 | if (!gl) |
| 2411 | return; |
| 2412 | gl->getObjectPtrLabel(ptr, bufSize, length, label); |
| 2413 | } |
| 2414 | |
Pyry Haulos | 933ef4d | 2016-11-14 13:01:12 -0800 | [diff] [blame] | 2415 | void glwGetPointerIndexedvEXT (GLenum target, GLuint index, void **data) |
| 2416 | { |
| 2417 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 2418 | if (!gl) |
| 2419 | return; |
| 2420 | gl->getPointerIndexedvEXT(target, index, data); |
| 2421 | } |
| 2422 | |
| 2423 | void glwGetPointeri_vEXT (GLenum pname, GLuint index, void **params) |
| 2424 | { |
| 2425 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 2426 | if (!gl) |
| 2427 | return; |
| 2428 | gl->getPointeri_vEXT(pname, index, params); |
| 2429 | } |
| 2430 | |
Pyry Haulos | 1abab60 | 2014-11-05 17:41:42 -0800 | [diff] [blame] | 2431 | void glwGetPointerv (GLenum pname, void **params) |
| 2432 | { |
| 2433 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 2434 | if (!gl) |
| 2435 | return; |
| 2436 | gl->getPointerv(pname, params); |
| 2437 | } |
| 2438 | |
| 2439 | void glwGetProgramBinary (GLuint program, GLsizei bufSize, GLsizei *length, GLenum *binaryFormat, void *binary) |
| 2440 | { |
| 2441 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 2442 | if (!gl) |
| 2443 | return; |
| 2444 | gl->getProgramBinary(program, bufSize, length, binaryFormat, binary); |
| 2445 | } |
| 2446 | |
| 2447 | void glwGetProgramInfoLog (GLuint program, GLsizei bufSize, GLsizei *length, GLchar *infoLog) |
| 2448 | { |
| 2449 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 2450 | if (!gl) |
| 2451 | return; |
| 2452 | gl->getProgramInfoLog(program, bufSize, length, infoLog); |
| 2453 | } |
| 2454 | |
| 2455 | void glwGetProgramInterfaceiv (GLuint program, GLenum programInterface, GLenum pname, GLint *params) |
| 2456 | { |
| 2457 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 2458 | if (!gl) |
| 2459 | return; |
| 2460 | gl->getProgramInterfaceiv(program, programInterface, pname, params); |
| 2461 | } |
| 2462 | |
| 2463 | void glwGetProgramPipelineInfoLog (GLuint pipeline, GLsizei bufSize, GLsizei *length, GLchar *infoLog) |
| 2464 | { |
| 2465 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 2466 | if (!gl) |
| 2467 | return; |
| 2468 | gl->getProgramPipelineInfoLog(pipeline, bufSize, length, infoLog); |
| 2469 | } |
| 2470 | |
| 2471 | void glwGetProgramPipelineiv (GLuint pipeline, GLenum pname, GLint *params) |
| 2472 | { |
| 2473 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 2474 | if (!gl) |
| 2475 | return; |
| 2476 | gl->getProgramPipelineiv(pipeline, pname, params); |
| 2477 | } |
| 2478 | |
| 2479 | GLuint glwGetProgramResourceIndex (GLuint program, GLenum programInterface, const GLchar *name) |
| 2480 | { |
| 2481 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 2482 | if (!gl) |
| 2483 | return (GLuint)0; |
| 2484 | return gl->getProgramResourceIndex(program, programInterface, name); |
| 2485 | } |
| 2486 | |
| 2487 | GLint glwGetProgramResourceLocation (GLuint program, GLenum programInterface, const GLchar *name) |
| 2488 | { |
| 2489 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 2490 | if (!gl) |
| 2491 | return (GLint)0; |
| 2492 | return gl->getProgramResourceLocation(program, programInterface, name); |
| 2493 | } |
| 2494 | |
| 2495 | GLint glwGetProgramResourceLocationIndex (GLuint program, GLenum programInterface, const GLchar *name) |
| 2496 | { |
| 2497 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 2498 | if (!gl) |
| 2499 | return (GLint)0; |
| 2500 | return gl->getProgramResourceLocationIndex(program, programInterface, name); |
| 2501 | } |
| 2502 | |
| 2503 | void glwGetProgramResourceName (GLuint program, GLenum programInterface, GLuint index, GLsizei bufSize, GLsizei *length, GLchar *name) |
| 2504 | { |
| 2505 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 2506 | if (!gl) |
| 2507 | return; |
| 2508 | gl->getProgramResourceName(program, programInterface, index, bufSize, length, name); |
| 2509 | } |
| 2510 | |
| 2511 | void glwGetProgramResourceiv (GLuint program, GLenum programInterface, GLuint index, GLsizei propCount, const GLenum *props, GLsizei bufSize, GLsizei *length, GLint *params) |
| 2512 | { |
| 2513 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 2514 | if (!gl) |
| 2515 | return; |
| 2516 | gl->getProgramResourceiv(program, programInterface, index, propCount, props, bufSize, length, params); |
| 2517 | } |
| 2518 | |
| 2519 | void glwGetProgramStageiv (GLuint program, GLenum shadertype, GLenum pname, GLint *values) |
| 2520 | { |
| 2521 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 2522 | if (!gl) |
| 2523 | return; |
| 2524 | gl->getProgramStageiv(program, shadertype, pname, values); |
| 2525 | } |
| 2526 | |
| 2527 | void glwGetProgramiv (GLuint program, GLenum pname, GLint *params) |
| 2528 | { |
| 2529 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 2530 | if (!gl) |
| 2531 | return; |
| 2532 | gl->getProgramiv(program, pname, params); |
| 2533 | } |
| 2534 | |
| 2535 | void glwGetQueryBufferObjecti64v (GLuint id, GLuint buffer, GLenum pname, GLintptr offset) |
| 2536 | { |
| 2537 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 2538 | if (!gl) |
| 2539 | return; |
| 2540 | gl->getQueryBufferObjecti64v(id, buffer, pname, offset); |
| 2541 | } |
| 2542 | |
| 2543 | void glwGetQueryBufferObjectiv (GLuint id, GLuint buffer, GLenum pname, GLintptr offset) |
| 2544 | { |
| 2545 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 2546 | if (!gl) |
| 2547 | return; |
| 2548 | gl->getQueryBufferObjectiv(id, buffer, pname, offset); |
| 2549 | } |
| 2550 | |
| 2551 | void glwGetQueryBufferObjectui64v (GLuint id, GLuint buffer, GLenum pname, GLintptr offset) |
| 2552 | { |
| 2553 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 2554 | if (!gl) |
| 2555 | return; |
| 2556 | gl->getQueryBufferObjectui64v(id, buffer, pname, offset); |
| 2557 | } |
| 2558 | |
| 2559 | void glwGetQueryBufferObjectuiv (GLuint id, GLuint buffer, GLenum pname, GLintptr offset) |
| 2560 | { |
| 2561 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 2562 | if (!gl) |
| 2563 | return; |
| 2564 | gl->getQueryBufferObjectuiv(id, buffer, pname, offset); |
| 2565 | } |
| 2566 | |
| 2567 | void glwGetQueryIndexediv (GLenum target, GLuint index, GLenum pname, GLint *params) |
| 2568 | { |
| 2569 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 2570 | if (!gl) |
| 2571 | return; |
| 2572 | gl->getQueryIndexediv(target, index, pname, params); |
| 2573 | } |
| 2574 | |
| 2575 | void glwGetQueryObjecti64v (GLuint id, GLenum pname, GLint64 *params) |
| 2576 | { |
| 2577 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 2578 | if (!gl) |
| 2579 | return; |
| 2580 | gl->getQueryObjecti64v(id, pname, params); |
| 2581 | } |
| 2582 | |
| 2583 | void glwGetQueryObjectiv (GLuint id, GLenum pname, GLint *params) |
| 2584 | { |
| 2585 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 2586 | if (!gl) |
| 2587 | return; |
| 2588 | gl->getQueryObjectiv(id, pname, params); |
| 2589 | } |
| 2590 | |
| 2591 | void glwGetQueryObjectui64v (GLuint id, GLenum pname, GLuint64 *params) |
| 2592 | { |
| 2593 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 2594 | if (!gl) |
| 2595 | return; |
| 2596 | gl->getQueryObjectui64v(id, pname, params); |
| 2597 | } |
| 2598 | |
| 2599 | void glwGetQueryObjectuiv (GLuint id, GLenum pname, GLuint *params) |
| 2600 | { |
| 2601 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 2602 | if (!gl) |
| 2603 | return; |
| 2604 | gl->getQueryObjectuiv(id, pname, params); |
| 2605 | } |
| 2606 | |
| 2607 | void glwGetQueryiv (GLenum target, GLenum pname, GLint *params) |
| 2608 | { |
| 2609 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 2610 | if (!gl) |
| 2611 | return; |
| 2612 | gl->getQueryiv(target, pname, params); |
| 2613 | } |
| 2614 | |
| 2615 | void glwGetRenderbufferParameteriv (GLenum target, GLenum pname, GLint *params) |
| 2616 | { |
| 2617 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 2618 | if (!gl) |
| 2619 | return; |
| 2620 | gl->getRenderbufferParameteriv(target, pname, params); |
| 2621 | } |
| 2622 | |
| 2623 | void glwGetSamplerParameterIiv (GLuint sampler, GLenum pname, GLint *params) |
| 2624 | { |
| 2625 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 2626 | if (!gl) |
| 2627 | return; |
| 2628 | gl->getSamplerParameterIiv(sampler, pname, params); |
| 2629 | } |
| 2630 | |
| 2631 | void glwGetSamplerParameterIuiv (GLuint sampler, GLenum pname, GLuint *params) |
| 2632 | { |
| 2633 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 2634 | if (!gl) |
| 2635 | return; |
| 2636 | gl->getSamplerParameterIuiv(sampler, pname, params); |
| 2637 | } |
| 2638 | |
| 2639 | void glwGetSamplerParameterfv (GLuint sampler, GLenum pname, GLfloat *params) |
| 2640 | { |
| 2641 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 2642 | if (!gl) |
| 2643 | return; |
| 2644 | gl->getSamplerParameterfv(sampler, pname, params); |
| 2645 | } |
| 2646 | |
| 2647 | void glwGetSamplerParameteriv (GLuint sampler, GLenum pname, GLint *params) |
| 2648 | { |
| 2649 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 2650 | if (!gl) |
| 2651 | return; |
| 2652 | gl->getSamplerParameteriv(sampler, pname, params); |
| 2653 | } |
| 2654 | |
| 2655 | void glwGetShaderInfoLog (GLuint shader, GLsizei bufSize, GLsizei *length, GLchar *infoLog) |
| 2656 | { |
| 2657 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 2658 | if (!gl) |
| 2659 | return; |
| 2660 | gl->getShaderInfoLog(shader, bufSize, length, infoLog); |
| 2661 | } |
| 2662 | |
| 2663 | void glwGetShaderPrecisionFormat (GLenum shadertype, GLenum precisiontype, GLint *range, GLint *precision) |
| 2664 | { |
| 2665 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 2666 | if (!gl) |
| 2667 | return; |
| 2668 | gl->getShaderPrecisionFormat(shadertype, precisiontype, range, precision); |
| 2669 | } |
| 2670 | |
| 2671 | void glwGetShaderSource (GLuint shader, GLsizei bufSize, GLsizei *length, GLchar *source) |
| 2672 | { |
| 2673 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 2674 | if (!gl) |
| 2675 | return; |
| 2676 | gl->getShaderSource(shader, bufSize, length, source); |
| 2677 | } |
| 2678 | |
| 2679 | void glwGetShaderiv (GLuint shader, GLenum pname, GLint *params) |
| 2680 | { |
| 2681 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 2682 | if (!gl) |
| 2683 | return; |
| 2684 | gl->getShaderiv(shader, pname, params); |
| 2685 | } |
| 2686 | |
| 2687 | const GLubyte * glwGetString (GLenum name) |
| 2688 | { |
| 2689 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 2690 | if (!gl) |
| 2691 | return (const GLubyte *)0; |
| 2692 | return gl->getString(name); |
| 2693 | } |
| 2694 | |
| 2695 | const GLubyte * glwGetStringi (GLenum name, GLuint index) |
| 2696 | { |
| 2697 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 2698 | if (!gl) |
| 2699 | return (const GLubyte *)0; |
| 2700 | return gl->getStringi(name, index); |
| 2701 | } |
| 2702 | |
| 2703 | GLuint glwGetSubroutineIndex (GLuint program, GLenum shadertype, const GLchar *name) |
| 2704 | { |
| 2705 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 2706 | if (!gl) |
| 2707 | return (GLuint)0; |
| 2708 | return gl->getSubroutineIndex(program, shadertype, name); |
| 2709 | } |
| 2710 | |
| 2711 | GLint glwGetSubroutineUniformLocation (GLuint program, GLenum shadertype, const GLchar *name) |
| 2712 | { |
| 2713 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 2714 | if (!gl) |
| 2715 | return (GLint)0; |
| 2716 | return gl->getSubroutineUniformLocation(program, shadertype, name); |
| 2717 | } |
| 2718 | |
| 2719 | void glwGetSynciv (GLsync sync, GLenum pname, GLsizei bufSize, GLsizei *length, GLint *values) |
| 2720 | { |
| 2721 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 2722 | if (!gl) |
| 2723 | return; |
| 2724 | gl->getSynciv(sync, pname, bufSize, length, values); |
| 2725 | } |
| 2726 | |
| 2727 | void glwGetTexImage (GLenum target, GLint level, GLenum format, GLenum type, void *pixels) |
| 2728 | { |
| 2729 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 2730 | if (!gl) |
| 2731 | return; |
| 2732 | gl->getTexImage(target, level, format, type, pixels); |
| 2733 | } |
| 2734 | |
| 2735 | void glwGetTexLevelParameterfv (GLenum target, GLint level, GLenum pname, GLfloat *params) |
| 2736 | { |
| 2737 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 2738 | if (!gl) |
| 2739 | return; |
| 2740 | gl->getTexLevelParameterfv(target, level, pname, params); |
| 2741 | } |
| 2742 | |
| 2743 | void glwGetTexLevelParameteriv (GLenum target, GLint level, GLenum pname, GLint *params) |
| 2744 | { |
| 2745 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 2746 | if (!gl) |
| 2747 | return; |
| 2748 | gl->getTexLevelParameteriv(target, level, pname, params); |
| 2749 | } |
| 2750 | |
| 2751 | void glwGetTexParameterIiv (GLenum target, GLenum pname, GLint *params) |
| 2752 | { |
| 2753 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 2754 | if (!gl) |
| 2755 | return; |
| 2756 | gl->getTexParameterIiv(target, pname, params); |
| 2757 | } |
| 2758 | |
| 2759 | void glwGetTexParameterIuiv (GLenum target, GLenum pname, GLuint *params) |
| 2760 | { |
| 2761 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 2762 | if (!gl) |
| 2763 | return; |
| 2764 | gl->getTexParameterIuiv(target, pname, params); |
| 2765 | } |
| 2766 | |
| 2767 | void glwGetTexParameterfv (GLenum target, GLenum pname, GLfloat *params) |
| 2768 | { |
| 2769 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 2770 | if (!gl) |
| 2771 | return; |
| 2772 | gl->getTexParameterfv(target, pname, params); |
| 2773 | } |
| 2774 | |
| 2775 | void glwGetTexParameteriv (GLenum target, GLenum pname, GLint *params) |
| 2776 | { |
| 2777 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 2778 | if (!gl) |
| 2779 | return; |
| 2780 | gl->getTexParameteriv(target, pname, params); |
| 2781 | } |
| 2782 | |
| 2783 | void glwGetTextureImage (GLuint texture, GLint level, GLenum format, GLenum type, GLsizei bufSize, void *pixels) |
| 2784 | { |
| 2785 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 2786 | if (!gl) |
| 2787 | return; |
| 2788 | gl->getTextureImage(texture, level, format, type, bufSize, pixels); |
| 2789 | } |
| 2790 | |
| 2791 | void glwGetTextureLevelParameterfv (GLuint texture, GLint level, GLenum pname, GLfloat *params) |
| 2792 | { |
| 2793 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 2794 | if (!gl) |
| 2795 | return; |
| 2796 | gl->getTextureLevelParameterfv(texture, level, pname, params); |
| 2797 | } |
| 2798 | |
| 2799 | void glwGetTextureLevelParameteriv (GLuint texture, GLint level, GLenum pname, GLint *params) |
| 2800 | { |
| 2801 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 2802 | if (!gl) |
| 2803 | return; |
| 2804 | gl->getTextureLevelParameteriv(texture, level, pname, params); |
| 2805 | } |
| 2806 | |
| 2807 | void glwGetTextureParameterIiv (GLuint texture, GLenum pname, GLint *params) |
| 2808 | { |
| 2809 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 2810 | if (!gl) |
| 2811 | return; |
| 2812 | gl->getTextureParameterIiv(texture, pname, params); |
| 2813 | } |
| 2814 | |
| 2815 | void glwGetTextureParameterIuiv (GLuint texture, GLenum pname, GLuint *params) |
| 2816 | { |
| 2817 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 2818 | if (!gl) |
| 2819 | return; |
| 2820 | gl->getTextureParameterIuiv(texture, pname, params); |
| 2821 | } |
| 2822 | |
| 2823 | void glwGetTextureParameterfv (GLuint texture, GLenum pname, GLfloat *params) |
| 2824 | { |
| 2825 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 2826 | if (!gl) |
| 2827 | return; |
| 2828 | gl->getTextureParameterfv(texture, pname, params); |
| 2829 | } |
| 2830 | |
| 2831 | void glwGetTextureParameteriv (GLuint texture, GLenum pname, GLint *params) |
| 2832 | { |
| 2833 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 2834 | if (!gl) |
| 2835 | return; |
| 2836 | gl->getTextureParameteriv(texture, pname, params); |
| 2837 | } |
| 2838 | |
| 2839 | void glwGetTextureSubImage (GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, GLsizei bufSize, void *pixels) |
| 2840 | { |
| 2841 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 2842 | if (!gl) |
| 2843 | return; |
| 2844 | gl->getTextureSubImage(texture, level, xoffset, yoffset, zoffset, width, height, depth, format, type, bufSize, pixels); |
| 2845 | } |
| 2846 | |
| 2847 | void glwGetTransformFeedbackVarying (GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLsizei *size, GLenum *type, GLchar *name) |
| 2848 | { |
| 2849 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 2850 | if (!gl) |
| 2851 | return; |
| 2852 | gl->getTransformFeedbackVarying(program, index, bufSize, length, size, type, name); |
| 2853 | } |
| 2854 | |
| 2855 | void glwGetTransformFeedbacki64_v (GLuint xfb, GLenum pname, GLuint index, GLint64 *param) |
| 2856 | { |
| 2857 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 2858 | if (!gl) |
| 2859 | return; |
| 2860 | gl->getTransformFeedbacki64_v(xfb, pname, index, param); |
| 2861 | } |
| 2862 | |
| 2863 | void glwGetTransformFeedbacki_v (GLuint xfb, GLenum pname, GLuint index, GLint *param) |
| 2864 | { |
| 2865 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 2866 | if (!gl) |
| 2867 | return; |
| 2868 | gl->getTransformFeedbacki_v(xfb, pname, index, param); |
| 2869 | } |
| 2870 | |
| 2871 | void glwGetTransformFeedbackiv (GLuint xfb, GLenum pname, GLint *param) |
| 2872 | { |
| 2873 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 2874 | if (!gl) |
| 2875 | return; |
| 2876 | gl->getTransformFeedbackiv(xfb, pname, param); |
| 2877 | } |
| 2878 | |
| 2879 | GLuint glwGetUniformBlockIndex (GLuint program, const GLchar *uniformBlockName) |
| 2880 | { |
| 2881 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 2882 | if (!gl) |
| 2883 | return (GLuint)0; |
| 2884 | return gl->getUniformBlockIndex(program, uniformBlockName); |
| 2885 | } |
| 2886 | |
| 2887 | void glwGetUniformIndices (GLuint program, GLsizei uniformCount, const GLchar *const*uniformNames, GLuint *uniformIndices) |
| 2888 | { |
| 2889 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 2890 | if (!gl) |
| 2891 | return; |
| 2892 | gl->getUniformIndices(program, uniformCount, uniformNames, uniformIndices); |
| 2893 | } |
| 2894 | |
| 2895 | GLint glwGetUniformLocation (GLuint program, const GLchar *name) |
| 2896 | { |
| 2897 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 2898 | if (!gl) |
| 2899 | return (GLint)0; |
| 2900 | return gl->getUniformLocation(program, name); |
| 2901 | } |
| 2902 | |
| 2903 | void glwGetUniformSubroutineuiv (GLenum shadertype, GLint location, GLuint *params) |
| 2904 | { |
| 2905 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 2906 | if (!gl) |
| 2907 | return; |
| 2908 | gl->getUniformSubroutineuiv(shadertype, location, params); |
| 2909 | } |
| 2910 | |
| 2911 | void glwGetUniformdv (GLuint program, GLint location, GLdouble *params) |
| 2912 | { |
| 2913 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 2914 | if (!gl) |
| 2915 | return; |
| 2916 | gl->getUniformdv(program, location, params); |
| 2917 | } |
| 2918 | |
| 2919 | void glwGetUniformfv (GLuint program, GLint location, GLfloat *params) |
| 2920 | { |
| 2921 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 2922 | if (!gl) |
| 2923 | return; |
| 2924 | gl->getUniformfv(program, location, params); |
| 2925 | } |
| 2926 | |
| 2927 | void glwGetUniformiv (GLuint program, GLint location, GLint *params) |
| 2928 | { |
| 2929 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 2930 | if (!gl) |
| 2931 | return; |
| 2932 | gl->getUniformiv(program, location, params); |
| 2933 | } |
| 2934 | |
| 2935 | void glwGetUniformuiv (GLuint program, GLint location, GLuint *params) |
| 2936 | { |
| 2937 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 2938 | if (!gl) |
| 2939 | return; |
| 2940 | gl->getUniformuiv(program, location, params); |
| 2941 | } |
| 2942 | |
| 2943 | void glwGetVertexArrayIndexed64iv (GLuint vaobj, GLuint index, GLenum pname, GLint64 *param) |
| 2944 | { |
| 2945 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 2946 | if (!gl) |
| 2947 | return; |
| 2948 | gl->getVertexArrayIndexed64iv(vaobj, index, pname, param); |
| 2949 | } |
| 2950 | |
| 2951 | void glwGetVertexArrayIndexediv (GLuint vaobj, GLuint index, GLenum pname, GLint *param) |
| 2952 | { |
| 2953 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 2954 | if (!gl) |
| 2955 | return; |
| 2956 | gl->getVertexArrayIndexediv(vaobj, index, pname, param); |
| 2957 | } |
| 2958 | |
Pyry Haulos | 933ef4d | 2016-11-14 13:01:12 -0800 | [diff] [blame] | 2959 | void glwGetVertexArrayIntegeri_vEXT (GLuint vaobj, GLuint index, GLenum pname, GLint *param) |
| 2960 | { |
| 2961 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 2962 | if (!gl) |
| 2963 | return; |
| 2964 | gl->getVertexArrayIntegeri_vEXT(vaobj, index, pname, param); |
| 2965 | } |
| 2966 | |
| 2967 | void glwGetVertexArrayIntegervEXT (GLuint vaobj, GLenum pname, GLint *param) |
| 2968 | { |
| 2969 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 2970 | if (!gl) |
| 2971 | return; |
| 2972 | gl->getVertexArrayIntegervEXT(vaobj, pname, param); |
| 2973 | } |
| 2974 | |
| 2975 | void glwGetVertexArrayPointeri_vEXT (GLuint vaobj, GLuint index, GLenum pname, void **param) |
| 2976 | { |
| 2977 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 2978 | if (!gl) |
| 2979 | return; |
| 2980 | gl->getVertexArrayPointeri_vEXT(vaobj, index, pname, param); |
| 2981 | } |
| 2982 | |
| 2983 | void glwGetVertexArrayPointervEXT (GLuint vaobj, GLenum pname, void **param) |
| 2984 | { |
| 2985 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 2986 | if (!gl) |
| 2987 | return; |
| 2988 | gl->getVertexArrayPointervEXT(vaobj, pname, param); |
| 2989 | } |
| 2990 | |
Pyry Haulos | 1abab60 | 2014-11-05 17:41:42 -0800 | [diff] [blame] | 2991 | void glwGetVertexArrayiv (GLuint vaobj, GLenum pname, GLint *param) |
| 2992 | { |
| 2993 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 2994 | if (!gl) |
| 2995 | return; |
| 2996 | gl->getVertexArrayiv(vaobj, pname, param); |
| 2997 | } |
| 2998 | |
| 2999 | void glwGetVertexAttribIiv (GLuint index, GLenum pname, GLint *params) |
| 3000 | { |
| 3001 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 3002 | if (!gl) |
| 3003 | return; |
| 3004 | gl->getVertexAttribIiv(index, pname, params); |
| 3005 | } |
| 3006 | |
| 3007 | void glwGetVertexAttribIuiv (GLuint index, GLenum pname, GLuint *params) |
| 3008 | { |
| 3009 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 3010 | if (!gl) |
| 3011 | return; |
| 3012 | gl->getVertexAttribIuiv(index, pname, params); |
| 3013 | } |
| 3014 | |
| 3015 | void glwGetVertexAttribLdv (GLuint index, GLenum pname, GLdouble *params) |
| 3016 | { |
| 3017 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 3018 | if (!gl) |
| 3019 | return; |
| 3020 | gl->getVertexAttribLdv(index, pname, params); |
| 3021 | } |
| 3022 | |
| 3023 | void glwGetVertexAttribPointerv (GLuint index, GLenum pname, void **pointer) |
| 3024 | { |
| 3025 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 3026 | if (!gl) |
| 3027 | return; |
| 3028 | gl->getVertexAttribPointerv(index, pname, pointer); |
| 3029 | } |
| 3030 | |
| 3031 | void glwGetVertexAttribdv (GLuint index, GLenum pname, GLdouble *params) |
| 3032 | { |
| 3033 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 3034 | if (!gl) |
| 3035 | return; |
| 3036 | gl->getVertexAttribdv(index, pname, params); |
| 3037 | } |
| 3038 | |
| 3039 | void glwGetVertexAttribfv (GLuint index, GLenum pname, GLfloat *params) |
| 3040 | { |
| 3041 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 3042 | if (!gl) |
| 3043 | return; |
| 3044 | gl->getVertexAttribfv(index, pname, params); |
| 3045 | } |
| 3046 | |
| 3047 | void glwGetVertexAttribiv (GLuint index, GLenum pname, GLint *params) |
| 3048 | { |
| 3049 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 3050 | if (!gl) |
| 3051 | return; |
| 3052 | gl->getVertexAttribiv(index, pname, params); |
| 3053 | } |
| 3054 | |
| 3055 | void glwGetnCompressedTexImage (GLenum target, GLint lod, GLsizei bufSize, void *pixels) |
| 3056 | { |
| 3057 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 3058 | if (!gl) |
| 3059 | return; |
| 3060 | gl->getnCompressedTexImage(target, lod, bufSize, pixels); |
| 3061 | } |
| 3062 | |
| 3063 | void glwGetnTexImage (GLenum target, GLint level, GLenum format, GLenum type, GLsizei bufSize, void *pixels) |
| 3064 | { |
| 3065 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 3066 | if (!gl) |
| 3067 | return; |
| 3068 | gl->getnTexImage(target, level, format, type, bufSize, pixels); |
| 3069 | } |
| 3070 | |
| 3071 | void glwGetnUniformdv (GLuint program, GLint location, GLsizei bufSize, GLdouble *params) |
| 3072 | { |
| 3073 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 3074 | if (!gl) |
| 3075 | return; |
| 3076 | gl->getnUniformdv(program, location, bufSize, params); |
| 3077 | } |
| 3078 | |
| 3079 | void glwGetnUniformfv (GLuint program, GLint location, GLsizei bufSize, GLfloat *params) |
| 3080 | { |
| 3081 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 3082 | if (!gl) |
| 3083 | return; |
| 3084 | gl->getnUniformfv(program, location, bufSize, params); |
| 3085 | } |
| 3086 | |
| 3087 | void glwGetnUniformiv (GLuint program, GLint location, GLsizei bufSize, GLint *params) |
| 3088 | { |
| 3089 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 3090 | if (!gl) |
| 3091 | return; |
| 3092 | gl->getnUniformiv(program, location, bufSize, params); |
| 3093 | } |
| 3094 | |
| 3095 | void glwGetnUniformuiv (GLuint program, GLint location, GLsizei bufSize, GLuint *params) |
| 3096 | { |
| 3097 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 3098 | if (!gl) |
| 3099 | return; |
| 3100 | gl->getnUniformuiv(program, location, bufSize, params); |
| 3101 | } |
| 3102 | |
| 3103 | void glwHint (GLenum target, GLenum mode) |
| 3104 | { |
| 3105 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 3106 | if (!gl) |
| 3107 | return; |
| 3108 | gl->hint(target, mode); |
Jarkko Poyry | 3c82736 | 2014-09-02 11:48:52 +0300 | [diff] [blame] | 3109 | } |
| 3110 | |
Pyry Haulos | 1a9576a | 2015-05-20 15:36:20 -0700 | [diff] [blame] | 3111 | void glwInsertEventMarkerEXT (GLsizei length, const GLchar *marker) |
| 3112 | { |
| 3113 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 3114 | if (!gl) |
| 3115 | return; |
| 3116 | gl->insertEventMarkerEXT(length, marker); |
| 3117 | } |
| 3118 | |
Jarkko Poyry | 3c82736 | 2014-09-02 11:48:52 +0300 | [diff] [blame] | 3119 | void glwInvalidateBufferData (GLuint buffer) |
| 3120 | { |
| 3121 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 3122 | if (!gl) |
Pyry Haulos | 1abab60 | 2014-11-05 17:41:42 -0800 | [diff] [blame] | 3123 | return; |
Jarkko Poyry | 3c82736 | 2014-09-02 11:48:52 +0300 | [diff] [blame] | 3124 | gl->invalidateBufferData(buffer); |
| 3125 | } |
| 3126 | |
Pyry Haulos | 1abab60 | 2014-11-05 17:41:42 -0800 | [diff] [blame] | 3127 | void glwInvalidateBufferSubData (GLuint buffer, GLintptr offset, GLsizeiptr length) |
Jarkko Poyry | 3c82736 | 2014-09-02 11:48:52 +0300 | [diff] [blame] | 3128 | { |
| 3129 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 3130 | if (!gl) |
Pyry Haulos | 1abab60 | 2014-11-05 17:41:42 -0800 | [diff] [blame] | 3131 | return; |
| 3132 | gl->invalidateBufferSubData(buffer, offset, length); |
| 3133 | } |
| 3134 | |
| 3135 | void glwInvalidateFramebuffer (GLenum target, GLsizei numAttachments, const GLenum *attachments) |
| 3136 | { |
| 3137 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 3138 | if (!gl) |
| 3139 | return; |
Jarkko Poyry | 3c82736 | 2014-09-02 11:48:52 +0300 | [diff] [blame] | 3140 | gl->invalidateFramebuffer(target, numAttachments, attachments); |
| 3141 | } |
| 3142 | |
Pyry Haulos | 1abab60 | 2014-11-05 17:41:42 -0800 | [diff] [blame] | 3143 | void glwInvalidateNamedFramebufferData (GLuint framebuffer, GLsizei numAttachments, const GLenum *attachments) |
Jarkko Poyry | 3c82736 | 2014-09-02 11:48:52 +0300 | [diff] [blame] | 3144 | { |
| 3145 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 3146 | if (!gl) |
Pyry Haulos | 1abab60 | 2014-11-05 17:41:42 -0800 | [diff] [blame] | 3147 | return; |
| 3148 | gl->invalidateNamedFramebufferData(framebuffer, numAttachments, attachments); |
| 3149 | } |
| 3150 | |
| 3151 | void glwInvalidateNamedFramebufferSubData (GLuint framebuffer, GLsizei numAttachments, const GLenum *attachments, GLint x, GLint y, GLsizei width, GLsizei height) |
| 3152 | { |
| 3153 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 3154 | if (!gl) |
| 3155 | return; |
| 3156 | gl->invalidateNamedFramebufferSubData(framebuffer, numAttachments, attachments, x, y, width, height); |
| 3157 | } |
| 3158 | |
| 3159 | void glwInvalidateSubFramebuffer (GLenum target, GLsizei numAttachments, const GLenum *attachments, GLint x, GLint y, GLsizei width, GLsizei height) |
| 3160 | { |
| 3161 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 3162 | if (!gl) |
| 3163 | return; |
Jarkko Poyry | 3c82736 | 2014-09-02 11:48:52 +0300 | [diff] [blame] | 3164 | gl->invalidateSubFramebuffer(target, numAttachments, attachments, x, y, width, height); |
| 3165 | } |
| 3166 | |
Pyry Haulos | 1abab60 | 2014-11-05 17:41:42 -0800 | [diff] [blame] | 3167 | void glwInvalidateTexImage (GLuint texture, GLint level) |
Jarkko Poyry | 3c82736 | 2014-09-02 11:48:52 +0300 | [diff] [blame] | 3168 | { |
| 3169 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 3170 | if (!gl) |
Pyry Haulos | 1abab60 | 2014-11-05 17:41:42 -0800 | [diff] [blame] | 3171 | return; |
| 3172 | gl->invalidateTexImage(texture, level); |
| 3173 | } |
| 3174 | |
| 3175 | void glwInvalidateTexSubImage (GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth) |
| 3176 | { |
| 3177 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 3178 | if (!gl) |
| 3179 | return; |
| 3180 | gl->invalidateTexSubImage(texture, level, xoffset, yoffset, zoffset, width, height, depth); |
| 3181 | } |
| 3182 | |
| 3183 | GLboolean glwIsBuffer (GLuint buffer) |
| 3184 | { |
| 3185 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 3186 | if (!gl) |
| 3187 | return (GLboolean)0; |
| 3188 | return gl->isBuffer(buffer); |
| 3189 | } |
| 3190 | |
| 3191 | GLboolean glwIsEnabled (GLenum cap) |
| 3192 | { |
| 3193 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 3194 | if (!gl) |
| 3195 | return (GLboolean)0; |
| 3196 | return gl->isEnabled(cap); |
| 3197 | } |
| 3198 | |
Pyry Haulos | 933ef4d | 2016-11-14 13:01:12 -0800 | [diff] [blame] | 3199 | GLboolean glwIsEnabledIndexedEXT (GLenum target, GLuint index) |
| 3200 | { |
| 3201 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 3202 | if (!gl) |
| 3203 | return (GLboolean)0; |
| 3204 | return gl->isEnabledIndexedEXT(target, index); |
| 3205 | } |
| 3206 | |
Pyry Haulos | 1abab60 | 2014-11-05 17:41:42 -0800 | [diff] [blame] | 3207 | GLboolean glwIsEnabledi (GLenum target, GLuint index) |
| 3208 | { |
| 3209 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 3210 | if (!gl) |
| 3211 | return (GLboolean)0; |
| 3212 | return gl->isEnabledi(target, index); |
| 3213 | } |
| 3214 | |
| 3215 | GLboolean glwIsFramebuffer (GLuint framebuffer) |
| 3216 | { |
| 3217 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 3218 | if (!gl) |
| 3219 | return (GLboolean)0; |
| 3220 | return gl->isFramebuffer(framebuffer); |
| 3221 | } |
| 3222 | |
| 3223 | GLboolean glwIsProgram (GLuint program) |
| 3224 | { |
| 3225 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 3226 | if (!gl) |
| 3227 | return (GLboolean)0; |
| 3228 | return gl->isProgram(program); |
| 3229 | } |
| 3230 | |
| 3231 | GLboolean glwIsProgramPipeline (GLuint pipeline) |
| 3232 | { |
| 3233 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 3234 | if (!gl) |
| 3235 | return (GLboolean)0; |
| 3236 | return gl->isProgramPipeline(pipeline); |
| 3237 | } |
| 3238 | |
| 3239 | GLboolean glwIsQuery (GLuint id) |
| 3240 | { |
| 3241 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 3242 | if (!gl) |
| 3243 | return (GLboolean)0; |
| 3244 | return gl->isQuery(id); |
| 3245 | } |
| 3246 | |
| 3247 | GLboolean glwIsRenderbuffer (GLuint renderbuffer) |
| 3248 | { |
| 3249 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 3250 | if (!gl) |
| 3251 | return (GLboolean)0; |
| 3252 | return gl->isRenderbuffer(renderbuffer); |
| 3253 | } |
| 3254 | |
| 3255 | GLboolean glwIsSampler (GLuint sampler) |
| 3256 | { |
| 3257 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 3258 | if (!gl) |
| 3259 | return (GLboolean)0; |
| 3260 | return gl->isSampler(sampler); |
| 3261 | } |
| 3262 | |
| 3263 | GLboolean glwIsShader (GLuint shader) |
| 3264 | { |
| 3265 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 3266 | if (!gl) |
| 3267 | return (GLboolean)0; |
| 3268 | return gl->isShader(shader); |
| 3269 | } |
| 3270 | |
| 3271 | GLboolean glwIsSync (GLsync sync) |
| 3272 | { |
| 3273 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 3274 | if (!gl) |
| 3275 | return (GLboolean)0; |
| 3276 | return gl->isSync(sync); |
| 3277 | } |
| 3278 | |
| 3279 | GLboolean glwIsTexture (GLuint texture) |
| 3280 | { |
| 3281 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 3282 | if (!gl) |
| 3283 | return (GLboolean)0; |
| 3284 | return gl->isTexture(texture); |
| 3285 | } |
| 3286 | |
| 3287 | GLboolean glwIsTransformFeedback (GLuint id) |
| 3288 | { |
| 3289 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 3290 | if (!gl) |
| 3291 | return (GLboolean)0; |
| 3292 | return gl->isTransformFeedback(id); |
| 3293 | } |
| 3294 | |
| 3295 | GLboolean glwIsVertexArray (GLuint array) |
| 3296 | { |
| 3297 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 3298 | if (!gl) |
| 3299 | return (GLboolean)0; |
| 3300 | return gl->isVertexArray(array); |
| 3301 | } |
| 3302 | |
| 3303 | void glwLineWidth (GLfloat width) |
| 3304 | { |
| 3305 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 3306 | if (!gl) |
| 3307 | return; |
| 3308 | gl->lineWidth(width); |
| 3309 | } |
| 3310 | |
| 3311 | void glwLinkProgram (GLuint program) |
| 3312 | { |
| 3313 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 3314 | if (!gl) |
| 3315 | return; |
| 3316 | gl->linkProgram(program); |
| 3317 | } |
| 3318 | |
| 3319 | void glwLogicOp (GLenum opcode) |
| 3320 | { |
| 3321 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 3322 | if (!gl) |
| 3323 | return; |
| 3324 | gl->logicOp(opcode); |
| 3325 | } |
| 3326 | |
| 3327 | void * glwMapBuffer (GLenum target, GLenum access) |
| 3328 | { |
| 3329 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 3330 | if (!gl) |
| 3331 | return (void *)0; |
| 3332 | return gl->mapBuffer(target, access); |
| 3333 | } |
| 3334 | |
| 3335 | void * glwMapBufferRange (GLenum target, GLintptr offset, GLsizeiptr length, GLbitfield access) |
| 3336 | { |
| 3337 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 3338 | if (!gl) |
| 3339 | return (void *)0; |
| 3340 | return gl->mapBufferRange(target, offset, length, access); |
| 3341 | } |
| 3342 | |
| 3343 | void * glwMapNamedBuffer (GLuint buffer, GLenum access) |
| 3344 | { |
| 3345 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 3346 | if (!gl) |
| 3347 | return (void *)0; |
| 3348 | return gl->mapNamedBuffer(buffer, access); |
| 3349 | } |
| 3350 | |
Mika Isojärvi | 314799d | 2015-01-23 15:01:53 -0800 | [diff] [blame] | 3351 | void * glwMapNamedBufferRange (GLuint buffer, GLintptr offset, GLsizeiptr length, GLbitfield access) |
Pyry Haulos | 1abab60 | 2014-11-05 17:41:42 -0800 | [diff] [blame] | 3352 | { |
| 3353 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 3354 | if (!gl) |
| 3355 | return (void *)0; |
| 3356 | return gl->mapNamedBufferRange(buffer, offset, length, access); |
| 3357 | } |
| 3358 | |
Pyry Haulos | 933ef4d | 2016-11-14 13:01:12 -0800 | [diff] [blame] | 3359 | void glwMatrixFrustumEXT (GLenum mode, GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar) |
| 3360 | { |
| 3361 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 3362 | if (!gl) |
| 3363 | return; |
| 3364 | gl->matrixFrustumEXT(mode, left, right, bottom, top, zNear, zFar); |
| 3365 | } |
| 3366 | |
| 3367 | void glwMatrixLoadIdentityEXT (GLenum mode) |
| 3368 | { |
| 3369 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 3370 | if (!gl) |
| 3371 | return; |
| 3372 | gl->matrixLoadIdentityEXT(mode); |
| 3373 | } |
| 3374 | |
| 3375 | void glwMatrixLoadTransposedEXT (GLenum mode, const GLdouble *m) |
| 3376 | { |
| 3377 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 3378 | if (!gl) |
| 3379 | return; |
| 3380 | gl->matrixLoadTransposedEXT(mode, m); |
| 3381 | } |
| 3382 | |
| 3383 | void glwMatrixLoadTransposefEXT (GLenum mode, const GLfloat *m) |
| 3384 | { |
| 3385 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 3386 | if (!gl) |
| 3387 | return; |
| 3388 | gl->matrixLoadTransposefEXT(mode, m); |
| 3389 | } |
| 3390 | |
| 3391 | void glwMatrixLoaddEXT (GLenum mode, const GLdouble *m) |
| 3392 | { |
| 3393 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 3394 | if (!gl) |
| 3395 | return; |
| 3396 | gl->matrixLoaddEXT(mode, m); |
| 3397 | } |
| 3398 | |
| 3399 | void glwMatrixLoadfEXT (GLenum mode, const GLfloat *m) |
| 3400 | { |
| 3401 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 3402 | if (!gl) |
| 3403 | return; |
| 3404 | gl->matrixLoadfEXT(mode, m); |
| 3405 | } |
| 3406 | |
| 3407 | void glwMatrixMultTransposedEXT (GLenum mode, const GLdouble *m) |
| 3408 | { |
| 3409 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 3410 | if (!gl) |
| 3411 | return; |
| 3412 | gl->matrixMultTransposedEXT(mode, m); |
| 3413 | } |
| 3414 | |
| 3415 | void glwMatrixMultTransposefEXT (GLenum mode, const GLfloat *m) |
| 3416 | { |
| 3417 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 3418 | if (!gl) |
| 3419 | return; |
| 3420 | gl->matrixMultTransposefEXT(mode, m); |
| 3421 | } |
| 3422 | |
| 3423 | void glwMatrixMultdEXT (GLenum mode, const GLdouble *m) |
| 3424 | { |
| 3425 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 3426 | if (!gl) |
| 3427 | return; |
| 3428 | gl->matrixMultdEXT(mode, m); |
| 3429 | } |
| 3430 | |
| 3431 | void glwMatrixMultfEXT (GLenum mode, const GLfloat *m) |
| 3432 | { |
| 3433 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 3434 | if (!gl) |
| 3435 | return; |
| 3436 | gl->matrixMultfEXT(mode, m); |
| 3437 | } |
| 3438 | |
| 3439 | void glwMatrixOrthoEXT (GLenum mode, GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar) |
| 3440 | { |
| 3441 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 3442 | if (!gl) |
| 3443 | return; |
| 3444 | gl->matrixOrthoEXT(mode, left, right, bottom, top, zNear, zFar); |
| 3445 | } |
| 3446 | |
| 3447 | void glwMatrixPopEXT (GLenum mode) |
| 3448 | { |
| 3449 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 3450 | if (!gl) |
| 3451 | return; |
| 3452 | gl->matrixPopEXT(mode); |
| 3453 | } |
| 3454 | |
| 3455 | void glwMatrixPushEXT (GLenum mode) |
| 3456 | { |
| 3457 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 3458 | if (!gl) |
| 3459 | return; |
| 3460 | gl->matrixPushEXT(mode); |
| 3461 | } |
| 3462 | |
| 3463 | void glwMatrixRotatedEXT (GLenum mode, GLdouble angle, GLdouble x, GLdouble y, GLdouble z) |
| 3464 | { |
| 3465 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 3466 | if (!gl) |
| 3467 | return; |
| 3468 | gl->matrixRotatedEXT(mode, angle, x, y, z); |
| 3469 | } |
| 3470 | |
| 3471 | void glwMatrixRotatefEXT (GLenum mode, GLfloat angle, GLfloat x, GLfloat y, GLfloat z) |
| 3472 | { |
| 3473 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 3474 | if (!gl) |
| 3475 | return; |
| 3476 | gl->matrixRotatefEXT(mode, angle, x, y, z); |
| 3477 | } |
| 3478 | |
| 3479 | void glwMatrixScaledEXT (GLenum mode, GLdouble x, GLdouble y, GLdouble z) |
| 3480 | { |
| 3481 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 3482 | if (!gl) |
| 3483 | return; |
| 3484 | gl->matrixScaledEXT(mode, x, y, z); |
| 3485 | } |
| 3486 | |
| 3487 | void glwMatrixScalefEXT (GLenum mode, GLfloat x, GLfloat y, GLfloat z) |
| 3488 | { |
| 3489 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 3490 | if (!gl) |
| 3491 | return; |
| 3492 | gl->matrixScalefEXT(mode, x, y, z); |
| 3493 | } |
| 3494 | |
| 3495 | void glwMatrixTranslatedEXT (GLenum mode, GLdouble x, GLdouble y, GLdouble z) |
| 3496 | { |
| 3497 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 3498 | if (!gl) |
| 3499 | return; |
| 3500 | gl->matrixTranslatedEXT(mode, x, y, z); |
| 3501 | } |
| 3502 | |
| 3503 | void glwMatrixTranslatefEXT (GLenum mode, GLfloat x, GLfloat y, GLfloat z) |
| 3504 | { |
| 3505 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 3506 | if (!gl) |
| 3507 | return; |
| 3508 | gl->matrixTranslatefEXT(mode, x, y, z); |
| 3509 | } |
| 3510 | |
| 3511 | void glwMaxShaderCompilerThreadsARB (GLuint count) |
| 3512 | { |
| 3513 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 3514 | if (!gl) |
| 3515 | return; |
| 3516 | gl->maxShaderCompilerThreadsARB(count); |
| 3517 | } |
| 3518 | |
Pyry Haulos | 1abab60 | 2014-11-05 17:41:42 -0800 | [diff] [blame] | 3519 | void glwMemoryBarrier (GLbitfield barriers) |
| 3520 | { |
| 3521 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 3522 | if (!gl) |
| 3523 | return; |
| 3524 | gl->memoryBarrier(barriers); |
| 3525 | } |
| 3526 | |
| 3527 | void glwMemoryBarrierByRegion (GLbitfield barriers) |
| 3528 | { |
| 3529 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 3530 | if (!gl) |
| 3531 | return; |
| 3532 | gl->memoryBarrierByRegion(barriers); |
| 3533 | } |
| 3534 | |
| 3535 | void glwMinSampleShading (GLfloat value) |
| 3536 | { |
| 3537 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 3538 | if (!gl) |
| 3539 | return; |
| 3540 | gl->minSampleShading(value); |
| 3541 | } |
| 3542 | |
| 3543 | void glwMultiDrawArrays (GLenum mode, const GLint *first, const GLsizei *count, GLsizei drawcount) |
| 3544 | { |
| 3545 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 3546 | if (!gl) |
| 3547 | return; |
| 3548 | gl->multiDrawArrays(mode, first, count, drawcount); |
| 3549 | } |
| 3550 | |
| 3551 | void glwMultiDrawArraysIndirect (GLenum mode, const void *indirect, GLsizei drawcount, GLsizei stride) |
| 3552 | { |
| 3553 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 3554 | if (!gl) |
| 3555 | return; |
Jarkko Poyry | 3c82736 | 2014-09-02 11:48:52 +0300 | [diff] [blame] | 3556 | gl->multiDrawArraysIndirect(mode, indirect, drawcount, stride); |
| 3557 | } |
| 3558 | |
Pyry Haulos | 1abab60 | 2014-11-05 17:41:42 -0800 | [diff] [blame] | 3559 | void glwMultiDrawElements (GLenum mode, const GLsizei *count, GLenum type, const void *const*indices, GLsizei drawcount) |
Jarkko Poyry | 3c82736 | 2014-09-02 11:48:52 +0300 | [diff] [blame] | 3560 | { |
| 3561 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 3562 | if (!gl) |
Pyry Haulos | 1abab60 | 2014-11-05 17:41:42 -0800 | [diff] [blame] | 3563 | return; |
| 3564 | gl->multiDrawElements(mode, count, type, indices, drawcount); |
| 3565 | } |
| 3566 | |
| 3567 | void glwMultiDrawElementsBaseVertex (GLenum mode, const GLsizei *count, GLenum type, const void *const*indices, GLsizei drawcount, const GLint *basevertex) |
| 3568 | { |
| 3569 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 3570 | if (!gl) |
| 3571 | return; |
| 3572 | gl->multiDrawElementsBaseVertex(mode, count, type, indices, drawcount, basevertex); |
| 3573 | } |
| 3574 | |
| 3575 | void glwMultiDrawElementsIndirect (GLenum mode, GLenum type, const void *indirect, GLsizei drawcount, GLsizei stride) |
| 3576 | { |
| 3577 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 3578 | if (!gl) |
| 3579 | return; |
Jarkko Poyry | 3c82736 | 2014-09-02 11:48:52 +0300 | [diff] [blame] | 3580 | gl->multiDrawElementsIndirect(mode, type, indirect, drawcount, stride); |
| 3581 | } |
| 3582 | |
Pyry Haulos | 933ef4d | 2016-11-14 13:01:12 -0800 | [diff] [blame] | 3583 | void glwMultiTexBufferEXT (GLenum texunit, GLenum target, GLenum internalformat, GLuint buffer) |
| 3584 | { |
| 3585 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 3586 | if (!gl) |
| 3587 | return; |
| 3588 | gl->multiTexBufferEXT(texunit, target, internalformat, buffer); |
| 3589 | } |
| 3590 | |
| 3591 | void glwMultiTexCoordPointerEXT (GLenum texunit, GLint size, GLenum type, GLsizei stride, const void *pointer) |
| 3592 | { |
| 3593 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 3594 | if (!gl) |
| 3595 | return; |
| 3596 | gl->multiTexCoordPointerEXT(texunit, size, type, stride, pointer); |
| 3597 | } |
| 3598 | |
| 3599 | void glwMultiTexEnvfEXT (GLenum texunit, GLenum target, GLenum pname, GLfloat param) |
| 3600 | { |
| 3601 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 3602 | if (!gl) |
| 3603 | return; |
| 3604 | gl->multiTexEnvfEXT(texunit, target, pname, param); |
| 3605 | } |
| 3606 | |
| 3607 | void glwMultiTexEnvfvEXT (GLenum texunit, GLenum target, GLenum pname, const GLfloat *params) |
| 3608 | { |
| 3609 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 3610 | if (!gl) |
| 3611 | return; |
| 3612 | gl->multiTexEnvfvEXT(texunit, target, pname, params); |
| 3613 | } |
| 3614 | |
| 3615 | void glwMultiTexEnviEXT (GLenum texunit, GLenum target, GLenum pname, GLint param) |
| 3616 | { |
| 3617 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 3618 | if (!gl) |
| 3619 | return; |
| 3620 | gl->multiTexEnviEXT(texunit, target, pname, param); |
| 3621 | } |
| 3622 | |
| 3623 | void glwMultiTexEnvivEXT (GLenum texunit, GLenum target, GLenum pname, const GLint *params) |
| 3624 | { |
| 3625 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 3626 | if (!gl) |
| 3627 | return; |
| 3628 | gl->multiTexEnvivEXT(texunit, target, pname, params); |
| 3629 | } |
| 3630 | |
| 3631 | void glwMultiTexGendEXT (GLenum texunit, GLenum coord, GLenum pname, GLdouble param) |
| 3632 | { |
| 3633 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 3634 | if (!gl) |
| 3635 | return; |
| 3636 | gl->multiTexGendEXT(texunit, coord, pname, param); |
| 3637 | } |
| 3638 | |
| 3639 | void glwMultiTexGendvEXT (GLenum texunit, GLenum coord, GLenum pname, const GLdouble *params) |
| 3640 | { |
| 3641 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 3642 | if (!gl) |
| 3643 | return; |
| 3644 | gl->multiTexGendvEXT(texunit, coord, pname, params); |
| 3645 | } |
| 3646 | |
| 3647 | void glwMultiTexGenfEXT (GLenum texunit, GLenum coord, GLenum pname, GLfloat param) |
| 3648 | { |
| 3649 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 3650 | if (!gl) |
| 3651 | return; |
| 3652 | gl->multiTexGenfEXT(texunit, coord, pname, param); |
| 3653 | } |
| 3654 | |
| 3655 | void glwMultiTexGenfvEXT (GLenum texunit, GLenum coord, GLenum pname, const GLfloat *params) |
| 3656 | { |
| 3657 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 3658 | if (!gl) |
| 3659 | return; |
| 3660 | gl->multiTexGenfvEXT(texunit, coord, pname, params); |
| 3661 | } |
| 3662 | |
| 3663 | void glwMultiTexGeniEXT (GLenum texunit, GLenum coord, GLenum pname, GLint param) |
| 3664 | { |
| 3665 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 3666 | if (!gl) |
| 3667 | return; |
| 3668 | gl->multiTexGeniEXT(texunit, coord, pname, param); |
| 3669 | } |
| 3670 | |
| 3671 | void glwMultiTexGenivEXT (GLenum texunit, GLenum coord, GLenum pname, const GLint *params) |
| 3672 | { |
| 3673 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 3674 | if (!gl) |
| 3675 | return; |
| 3676 | gl->multiTexGenivEXT(texunit, coord, pname, params); |
| 3677 | } |
| 3678 | |
| 3679 | void glwMultiTexImage1DEXT (GLenum texunit, GLenum target, GLint level, GLint internalformat, GLsizei width, GLint border, GLenum format, GLenum type, const void *pixels) |
| 3680 | { |
| 3681 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 3682 | if (!gl) |
| 3683 | return; |
| 3684 | gl->multiTexImage1DEXT(texunit, target, level, internalformat, width, border, format, type, pixels); |
| 3685 | } |
| 3686 | |
| 3687 | void glwMultiTexImage2DEXT (GLenum texunit, GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const void *pixels) |
| 3688 | { |
| 3689 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 3690 | if (!gl) |
| 3691 | return; |
| 3692 | gl->multiTexImage2DEXT(texunit, target, level, internalformat, width, height, border, format, type, pixels); |
| 3693 | } |
| 3694 | |
| 3695 | void glwMultiTexImage3DEXT (GLenum texunit, GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const void *pixels) |
| 3696 | { |
| 3697 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 3698 | if (!gl) |
| 3699 | return; |
| 3700 | gl->multiTexImage3DEXT(texunit, target, level, internalformat, width, height, depth, border, format, type, pixels); |
| 3701 | } |
| 3702 | |
| 3703 | void glwMultiTexParameterIivEXT (GLenum texunit, GLenum target, GLenum pname, const GLint *params) |
| 3704 | { |
| 3705 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 3706 | if (!gl) |
| 3707 | return; |
| 3708 | gl->multiTexParameterIivEXT(texunit, target, pname, params); |
| 3709 | } |
| 3710 | |
| 3711 | void glwMultiTexParameterIuivEXT (GLenum texunit, GLenum target, GLenum pname, const GLuint *params) |
| 3712 | { |
| 3713 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 3714 | if (!gl) |
| 3715 | return; |
| 3716 | gl->multiTexParameterIuivEXT(texunit, target, pname, params); |
| 3717 | } |
| 3718 | |
| 3719 | void glwMultiTexParameterfEXT (GLenum texunit, GLenum target, GLenum pname, GLfloat param) |
| 3720 | { |
| 3721 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 3722 | if (!gl) |
| 3723 | return; |
| 3724 | gl->multiTexParameterfEXT(texunit, target, pname, param); |
| 3725 | } |
| 3726 | |
| 3727 | void glwMultiTexParameterfvEXT (GLenum texunit, GLenum target, GLenum pname, const GLfloat *params) |
| 3728 | { |
| 3729 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 3730 | if (!gl) |
| 3731 | return; |
| 3732 | gl->multiTexParameterfvEXT(texunit, target, pname, params); |
| 3733 | } |
| 3734 | |
| 3735 | void glwMultiTexParameteriEXT (GLenum texunit, GLenum target, GLenum pname, GLint param) |
| 3736 | { |
| 3737 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 3738 | if (!gl) |
| 3739 | return; |
| 3740 | gl->multiTexParameteriEXT(texunit, target, pname, param); |
| 3741 | } |
| 3742 | |
| 3743 | void glwMultiTexParameterivEXT (GLenum texunit, GLenum target, GLenum pname, const GLint *params) |
| 3744 | { |
| 3745 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 3746 | if (!gl) |
| 3747 | return; |
| 3748 | gl->multiTexParameterivEXT(texunit, target, pname, params); |
| 3749 | } |
| 3750 | |
| 3751 | void glwMultiTexRenderbufferEXT (GLenum texunit, GLenum target, GLuint renderbuffer) |
| 3752 | { |
| 3753 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 3754 | if (!gl) |
| 3755 | return; |
| 3756 | gl->multiTexRenderbufferEXT(texunit, target, renderbuffer); |
| 3757 | } |
| 3758 | |
| 3759 | void glwMultiTexSubImage1DEXT (GLenum texunit, GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const void *pixels) |
| 3760 | { |
| 3761 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 3762 | if (!gl) |
| 3763 | return; |
| 3764 | gl->multiTexSubImage1DEXT(texunit, target, level, xoffset, width, format, type, pixels); |
| 3765 | } |
| 3766 | |
| 3767 | void glwMultiTexSubImage2DEXT (GLenum texunit, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const void *pixels) |
| 3768 | { |
| 3769 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 3770 | if (!gl) |
| 3771 | return; |
| 3772 | gl->multiTexSubImage2DEXT(texunit, target, level, xoffset, yoffset, width, height, format, type, pixels); |
| 3773 | } |
| 3774 | |
| 3775 | void glwMultiTexSubImage3DEXT (GLenum texunit, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const void *pixels) |
| 3776 | { |
| 3777 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 3778 | if (!gl) |
| 3779 | return; |
| 3780 | gl->multiTexSubImage3DEXT(texunit, target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels); |
| 3781 | } |
| 3782 | |
Mika Isojärvi | 314799d | 2015-01-23 15:01:53 -0800 | [diff] [blame] | 3783 | void glwNamedBufferData (GLuint buffer, GLsizeiptr size, const void *data, GLenum usage) |
Jarkko Poyry | 3c82736 | 2014-09-02 11:48:52 +0300 | [diff] [blame] | 3784 | { |
| 3785 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 3786 | if (!gl) |
Pyry Haulos | 1abab60 | 2014-11-05 17:41:42 -0800 | [diff] [blame] | 3787 | return; |
| 3788 | gl->namedBufferData(buffer, size, data, usage); |
Jarkko Poyry | 3c82736 | 2014-09-02 11:48:52 +0300 | [diff] [blame] | 3789 | } |
| 3790 | |
Pyry Haulos | 933ef4d | 2016-11-14 13:01:12 -0800 | [diff] [blame] | 3791 | void glwNamedBufferPageCommitmentARB (GLuint buffer, GLintptr offset, GLsizeiptr size, GLboolean commit) |
| 3792 | { |
| 3793 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 3794 | if (!gl) |
| 3795 | return; |
| 3796 | gl->namedBufferPageCommitmentARB(buffer, offset, size, commit); |
| 3797 | } |
| 3798 | |
| 3799 | void glwNamedBufferPageCommitmentEXT (GLuint buffer, GLintptr offset, GLsizeiptr size, GLboolean commit) |
| 3800 | { |
| 3801 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 3802 | if (!gl) |
| 3803 | return; |
| 3804 | gl->namedBufferPageCommitmentEXT(buffer, offset, size, commit); |
| 3805 | } |
| 3806 | |
Mika Isojärvi | 314799d | 2015-01-23 15:01:53 -0800 | [diff] [blame] | 3807 | void glwNamedBufferStorage (GLuint buffer, GLsizeiptr size, const void *data, GLbitfield flags) |
Jarkko Poyry | 3c82736 | 2014-09-02 11:48:52 +0300 | [diff] [blame] | 3808 | { |
| 3809 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 3810 | if (!gl) |
Pyry Haulos | 1abab60 | 2014-11-05 17:41:42 -0800 | [diff] [blame] | 3811 | return; |
| 3812 | gl->namedBufferStorage(buffer, size, data, flags); |
Jarkko Poyry | 3c82736 | 2014-09-02 11:48:52 +0300 | [diff] [blame] | 3813 | } |
| 3814 | |
Mika Isojärvi | 314799d | 2015-01-23 15:01:53 -0800 | [diff] [blame] | 3815 | void glwNamedBufferSubData (GLuint buffer, GLintptr offset, GLsizeiptr size, const void *data) |
Jarkko Poyry | 3c82736 | 2014-09-02 11:48:52 +0300 | [diff] [blame] | 3816 | { |
| 3817 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 3818 | if (!gl) |
Pyry Haulos | 1abab60 | 2014-11-05 17:41:42 -0800 | [diff] [blame] | 3819 | return; |
| 3820 | gl->namedBufferSubData(buffer, offset, size, data); |
Jarkko Poyry | 3c82736 | 2014-09-02 11:48:52 +0300 | [diff] [blame] | 3821 | } |
| 3822 | |
Pyry Haulos | 933ef4d | 2016-11-14 13:01:12 -0800 | [diff] [blame] | 3823 | void glwNamedCopyBufferSubDataEXT (GLuint readBuffer, GLuint writeBuffer, GLintptr readOffset, GLintptr writeOffset, GLsizeiptr size) |
| 3824 | { |
| 3825 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 3826 | if (!gl) |
| 3827 | return; |
| 3828 | gl->namedCopyBufferSubDataEXT(readBuffer, writeBuffer, readOffset, writeOffset, size); |
| 3829 | } |
| 3830 | |
Pyry Haulos | 1abab60 | 2014-11-05 17:41:42 -0800 | [diff] [blame] | 3831 | void glwNamedFramebufferDrawBuffer (GLuint framebuffer, GLenum buf) |
Jarkko Poyry | 3c82736 | 2014-09-02 11:48:52 +0300 | [diff] [blame] | 3832 | { |
| 3833 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 3834 | if (!gl) |
Pyry Haulos | 1abab60 | 2014-11-05 17:41:42 -0800 | [diff] [blame] | 3835 | return; |
| 3836 | gl->namedFramebufferDrawBuffer(framebuffer, buf); |
Jarkko Poyry | 3c82736 | 2014-09-02 11:48:52 +0300 | [diff] [blame] | 3837 | } |
| 3838 | |
Pyry Haulos | 1abab60 | 2014-11-05 17:41:42 -0800 | [diff] [blame] | 3839 | void glwNamedFramebufferDrawBuffers (GLuint framebuffer, GLsizei n, const GLenum *bufs) |
Jarkko Poyry | 3c82736 | 2014-09-02 11:48:52 +0300 | [diff] [blame] | 3840 | { |
| 3841 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 3842 | if (!gl) |
Pyry Haulos | 1abab60 | 2014-11-05 17:41:42 -0800 | [diff] [blame] | 3843 | return; |
| 3844 | gl->namedFramebufferDrawBuffers(framebuffer, n, bufs); |
Jarkko Poyry | 3c82736 | 2014-09-02 11:48:52 +0300 | [diff] [blame] | 3845 | } |
| 3846 | |
Pyry Haulos | 1abab60 | 2014-11-05 17:41:42 -0800 | [diff] [blame] | 3847 | void glwNamedFramebufferParameteri (GLuint framebuffer, GLenum pname, GLint param) |
Jarkko Poyry | 3c82736 | 2014-09-02 11:48:52 +0300 | [diff] [blame] | 3848 | { |
| 3849 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 3850 | if (!gl) |
Pyry Haulos | 1abab60 | 2014-11-05 17:41:42 -0800 | [diff] [blame] | 3851 | return; |
| 3852 | gl->namedFramebufferParameteri(framebuffer, pname, param); |
| 3853 | } |
| 3854 | |
| 3855 | void glwNamedFramebufferReadBuffer (GLuint framebuffer, GLenum src) |
| 3856 | { |
| 3857 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 3858 | if (!gl) |
| 3859 | return; |
| 3860 | gl->namedFramebufferReadBuffer(framebuffer, src); |
| 3861 | } |
| 3862 | |
| 3863 | void glwNamedFramebufferRenderbuffer (GLuint framebuffer, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer) |
| 3864 | { |
| 3865 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 3866 | if (!gl) |
| 3867 | return; |
| 3868 | gl->namedFramebufferRenderbuffer(framebuffer, attachment, renderbuffertarget, renderbuffer); |
| 3869 | } |
| 3870 | |
| 3871 | void glwNamedFramebufferTexture (GLuint framebuffer, GLenum attachment, GLuint texture, GLint level) |
| 3872 | { |
| 3873 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 3874 | if (!gl) |
| 3875 | return; |
| 3876 | gl->namedFramebufferTexture(framebuffer, attachment, texture, level); |
| 3877 | } |
| 3878 | |
Pyry Haulos | 933ef4d | 2016-11-14 13:01:12 -0800 | [diff] [blame] | 3879 | void glwNamedFramebufferTexture1DEXT (GLuint framebuffer, GLenum attachment, GLenum textarget, GLuint texture, GLint level) |
| 3880 | { |
| 3881 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 3882 | if (!gl) |
| 3883 | return; |
| 3884 | gl->namedFramebufferTexture1DEXT(framebuffer, attachment, textarget, texture, level); |
| 3885 | } |
| 3886 | |
| 3887 | void glwNamedFramebufferTexture2DEXT (GLuint framebuffer, GLenum attachment, GLenum textarget, GLuint texture, GLint level) |
| 3888 | { |
| 3889 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 3890 | if (!gl) |
| 3891 | return; |
| 3892 | gl->namedFramebufferTexture2DEXT(framebuffer, attachment, textarget, texture, level); |
| 3893 | } |
| 3894 | |
| 3895 | void glwNamedFramebufferTexture3DEXT (GLuint framebuffer, GLenum attachment, GLenum textarget, GLuint texture, GLint level, GLint zoffset) |
| 3896 | { |
| 3897 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 3898 | if (!gl) |
| 3899 | return; |
| 3900 | gl->namedFramebufferTexture3DEXT(framebuffer, attachment, textarget, texture, level, zoffset); |
| 3901 | } |
| 3902 | |
| 3903 | void glwNamedFramebufferTextureFaceEXT (GLuint framebuffer, GLenum attachment, GLuint texture, GLint level, GLenum face) |
| 3904 | { |
| 3905 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 3906 | if (!gl) |
| 3907 | return; |
| 3908 | gl->namedFramebufferTextureFaceEXT(framebuffer, attachment, texture, level, face); |
| 3909 | } |
| 3910 | |
Pyry Haulos | 1abab60 | 2014-11-05 17:41:42 -0800 | [diff] [blame] | 3911 | void glwNamedFramebufferTextureLayer (GLuint framebuffer, GLenum attachment, GLuint texture, GLint level, GLint layer) |
| 3912 | { |
| 3913 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 3914 | if (!gl) |
| 3915 | return; |
| 3916 | gl->namedFramebufferTextureLayer(framebuffer, attachment, texture, level, layer); |
| 3917 | } |
| 3918 | |
Pyry Haulos | 933ef4d | 2016-11-14 13:01:12 -0800 | [diff] [blame] | 3919 | void glwNamedProgramLocalParameter4dEXT (GLuint program, GLenum target, GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w) |
| 3920 | { |
| 3921 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 3922 | if (!gl) |
| 3923 | return; |
| 3924 | gl->namedProgramLocalParameter4dEXT(program, target, index, x, y, z, w); |
| 3925 | } |
| 3926 | |
| 3927 | void glwNamedProgramLocalParameter4dvEXT (GLuint program, GLenum target, GLuint index, const GLdouble *params) |
| 3928 | { |
| 3929 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 3930 | if (!gl) |
| 3931 | return; |
| 3932 | gl->namedProgramLocalParameter4dvEXT(program, target, index, params); |
| 3933 | } |
| 3934 | |
| 3935 | void glwNamedProgramLocalParameter4fEXT (GLuint program, GLenum target, GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w) |
| 3936 | { |
| 3937 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 3938 | if (!gl) |
| 3939 | return; |
| 3940 | gl->namedProgramLocalParameter4fEXT(program, target, index, x, y, z, w); |
| 3941 | } |
| 3942 | |
| 3943 | void glwNamedProgramLocalParameter4fvEXT (GLuint program, GLenum target, GLuint index, const GLfloat *params) |
| 3944 | { |
| 3945 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 3946 | if (!gl) |
| 3947 | return; |
| 3948 | gl->namedProgramLocalParameter4fvEXT(program, target, index, params); |
| 3949 | } |
| 3950 | |
| 3951 | void glwNamedProgramLocalParameterI4iEXT (GLuint program, GLenum target, GLuint index, GLint x, GLint y, GLint z, GLint w) |
| 3952 | { |
| 3953 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 3954 | if (!gl) |
| 3955 | return; |
| 3956 | gl->namedProgramLocalParameterI4iEXT(program, target, index, x, y, z, w); |
| 3957 | } |
| 3958 | |
| 3959 | void glwNamedProgramLocalParameterI4ivEXT (GLuint program, GLenum target, GLuint index, const GLint *params) |
| 3960 | { |
| 3961 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 3962 | if (!gl) |
| 3963 | return; |
| 3964 | gl->namedProgramLocalParameterI4ivEXT(program, target, index, params); |
| 3965 | } |
| 3966 | |
| 3967 | void glwNamedProgramLocalParameterI4uiEXT (GLuint program, GLenum target, GLuint index, GLuint x, GLuint y, GLuint z, GLuint w) |
| 3968 | { |
| 3969 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 3970 | if (!gl) |
| 3971 | return; |
| 3972 | gl->namedProgramLocalParameterI4uiEXT(program, target, index, x, y, z, w); |
| 3973 | } |
| 3974 | |
| 3975 | void glwNamedProgramLocalParameterI4uivEXT (GLuint program, GLenum target, GLuint index, const GLuint *params) |
| 3976 | { |
| 3977 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 3978 | if (!gl) |
| 3979 | return; |
| 3980 | gl->namedProgramLocalParameterI4uivEXT(program, target, index, params); |
| 3981 | } |
| 3982 | |
| 3983 | void glwNamedProgramLocalParameters4fvEXT (GLuint program, GLenum target, GLuint index, GLsizei count, const GLfloat *params) |
| 3984 | { |
| 3985 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 3986 | if (!gl) |
| 3987 | return; |
| 3988 | gl->namedProgramLocalParameters4fvEXT(program, target, index, count, params); |
| 3989 | } |
| 3990 | |
| 3991 | void glwNamedProgramLocalParametersI4ivEXT (GLuint program, GLenum target, GLuint index, GLsizei count, const GLint *params) |
| 3992 | { |
| 3993 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 3994 | if (!gl) |
| 3995 | return; |
| 3996 | gl->namedProgramLocalParametersI4ivEXT(program, target, index, count, params); |
| 3997 | } |
| 3998 | |
| 3999 | void glwNamedProgramLocalParametersI4uivEXT (GLuint program, GLenum target, GLuint index, GLsizei count, const GLuint *params) |
| 4000 | { |
| 4001 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 4002 | if (!gl) |
| 4003 | return; |
| 4004 | gl->namedProgramLocalParametersI4uivEXT(program, target, index, count, params); |
| 4005 | } |
| 4006 | |
| 4007 | void glwNamedProgramStringEXT (GLuint program, GLenum target, GLenum format, GLsizei len, const void *string) |
| 4008 | { |
| 4009 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 4010 | if (!gl) |
| 4011 | return; |
| 4012 | gl->namedProgramStringEXT(program, target, format, len, string); |
| 4013 | } |
| 4014 | |
Pyry Haulos | 1abab60 | 2014-11-05 17:41:42 -0800 | [diff] [blame] | 4015 | void glwNamedRenderbufferStorage (GLuint renderbuffer, GLenum internalformat, GLsizei width, GLsizei height) |
| 4016 | { |
| 4017 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 4018 | if (!gl) |
| 4019 | return; |
| 4020 | gl->namedRenderbufferStorage(renderbuffer, internalformat, width, height); |
| 4021 | } |
| 4022 | |
| 4023 | void glwNamedRenderbufferStorageMultisample (GLuint renderbuffer, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height) |
| 4024 | { |
| 4025 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 4026 | if (!gl) |
| 4027 | return; |
| 4028 | gl->namedRenderbufferStorageMultisample(renderbuffer, samples, internalformat, width, height); |
| 4029 | } |
| 4030 | |
Pyry Haulos | 933ef4d | 2016-11-14 13:01:12 -0800 | [diff] [blame] | 4031 | void glwNamedRenderbufferStorageMultisampleCoverageEXT (GLuint renderbuffer, GLsizei coverageSamples, GLsizei colorSamples, GLenum internalformat, GLsizei width, GLsizei height) |
| 4032 | { |
| 4033 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 4034 | if (!gl) |
| 4035 | return; |
| 4036 | gl->namedRenderbufferStorageMultisampleCoverageEXT(renderbuffer, coverageSamples, colorSamples, internalformat, width, height); |
| 4037 | } |
| 4038 | |
Pyry Haulos | 1abab60 | 2014-11-05 17:41:42 -0800 | [diff] [blame] | 4039 | void glwObjectLabel (GLenum identifier, GLuint name, GLsizei length, const GLchar *label) |
| 4040 | { |
| 4041 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 4042 | if (!gl) |
| 4043 | return; |
| 4044 | gl->objectLabel(identifier, name, length, label); |
| 4045 | } |
| 4046 | |
| 4047 | void glwObjectPtrLabel (const void *ptr, GLsizei length, const GLchar *label) |
| 4048 | { |
| 4049 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 4050 | if (!gl) |
| 4051 | return; |
| 4052 | gl->objectPtrLabel(ptr, length, label); |
| 4053 | } |
| 4054 | |
| 4055 | void glwPatchParameterfv (GLenum pname, const GLfloat *values) |
| 4056 | { |
| 4057 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 4058 | if (!gl) |
| 4059 | return; |
| 4060 | gl->patchParameterfv(pname, values); |
| 4061 | } |
| 4062 | |
| 4063 | void glwPatchParameteri (GLenum pname, GLint value) |
| 4064 | { |
| 4065 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 4066 | if (!gl) |
| 4067 | return; |
| 4068 | gl->patchParameteri(pname, value); |
| 4069 | } |
| 4070 | |
| 4071 | void glwPauseTransformFeedback (void) |
| 4072 | { |
| 4073 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 4074 | if (!gl) |
| 4075 | return; |
| 4076 | gl->pauseTransformFeedback(); |
| 4077 | } |
| 4078 | |
| 4079 | void glwPixelStoref (GLenum pname, GLfloat param) |
| 4080 | { |
| 4081 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 4082 | if (!gl) |
| 4083 | return; |
| 4084 | gl->pixelStoref(pname, param); |
| 4085 | } |
| 4086 | |
| 4087 | void glwPixelStorei (GLenum pname, GLint param) |
| 4088 | { |
| 4089 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 4090 | if (!gl) |
| 4091 | return; |
| 4092 | gl->pixelStorei(pname, param); |
| 4093 | } |
| 4094 | |
| 4095 | void glwPointParameterf (GLenum pname, GLfloat param) |
| 4096 | { |
| 4097 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 4098 | if (!gl) |
| 4099 | return; |
| 4100 | gl->pointParameterf(pname, param); |
| 4101 | } |
| 4102 | |
| 4103 | void glwPointParameterfv (GLenum pname, const GLfloat *params) |
| 4104 | { |
| 4105 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 4106 | if (!gl) |
| 4107 | return; |
| 4108 | gl->pointParameterfv(pname, params); |
| 4109 | } |
| 4110 | |
| 4111 | void glwPointParameteri (GLenum pname, GLint param) |
| 4112 | { |
| 4113 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 4114 | if (!gl) |
| 4115 | return; |
| 4116 | gl->pointParameteri(pname, param); |
| 4117 | } |
| 4118 | |
| 4119 | void glwPointParameteriv (GLenum pname, const GLint *params) |
| 4120 | { |
| 4121 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 4122 | if (!gl) |
| 4123 | return; |
| 4124 | gl->pointParameteriv(pname, params); |
| 4125 | } |
| 4126 | |
| 4127 | void glwPointSize (GLfloat size) |
| 4128 | { |
| 4129 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 4130 | if (!gl) |
| 4131 | return; |
| 4132 | gl->pointSize(size); |
| 4133 | } |
| 4134 | |
| 4135 | void glwPolygonMode (GLenum face, GLenum mode) |
| 4136 | { |
| 4137 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 4138 | if (!gl) |
| 4139 | return; |
| 4140 | gl->polygonMode(face, mode); |
| 4141 | } |
| 4142 | |
| 4143 | void glwPolygonOffset (GLfloat factor, GLfloat units) |
| 4144 | { |
| 4145 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 4146 | if (!gl) |
| 4147 | return; |
| 4148 | gl->polygonOffset(factor, units); |
| 4149 | } |
| 4150 | |
| 4151 | void glwPopDebugGroup (void) |
| 4152 | { |
| 4153 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 4154 | if (!gl) |
| 4155 | return; |
| 4156 | gl->popDebugGroup(); |
| 4157 | } |
| 4158 | |
Pyry Haulos | 1a9576a | 2015-05-20 15:36:20 -0700 | [diff] [blame] | 4159 | void glwPopGroupMarkerEXT (void) |
| 4160 | { |
| 4161 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 4162 | if (!gl) |
| 4163 | return; |
| 4164 | gl->popGroupMarkerEXT(); |
| 4165 | } |
| 4166 | |
Daniel Andrade Groppe | 485a2d1 | 2015-12-02 15:45:41 -0600 | [diff] [blame] | 4167 | void glwPrimitiveBoundingBox (GLfloat minX, GLfloat minY, GLfloat minZ, GLfloat minW, GLfloat maxX, GLfloat maxY, GLfloat maxZ, GLfloat maxW) |
Jarkko Pöyry | 1f99d69 | 2014-11-17 14:21:54 -0800 | [diff] [blame] | 4168 | { |
| 4169 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 4170 | if (!gl) |
| 4171 | return; |
Daniel Andrade Groppe | 485a2d1 | 2015-12-02 15:45:41 -0600 | [diff] [blame] | 4172 | gl->primitiveBoundingBox(minX, minY, minZ, minW, maxX, maxY, maxZ, maxW); |
Jarkko Pöyry | 1f99d69 | 2014-11-17 14:21:54 -0800 | [diff] [blame] | 4173 | } |
| 4174 | |
Pyry Haulos | 1abab60 | 2014-11-05 17:41:42 -0800 | [diff] [blame] | 4175 | void glwPrimitiveRestartIndex (GLuint index) |
| 4176 | { |
| 4177 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 4178 | if (!gl) |
| 4179 | return; |
| 4180 | gl->primitiveRestartIndex(index); |
| 4181 | } |
| 4182 | |
| 4183 | void glwProgramBinary (GLuint program, GLenum binaryFormat, const void *binary, GLsizei length) |
| 4184 | { |
| 4185 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 4186 | if (!gl) |
| 4187 | return; |
| 4188 | gl->programBinary(program, binaryFormat, binary, length); |
| 4189 | } |
| 4190 | |
| 4191 | void glwProgramParameteri (GLuint program, GLenum pname, GLint value) |
| 4192 | { |
| 4193 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 4194 | if (!gl) |
| 4195 | return; |
| 4196 | gl->programParameteri(program, pname, value); |
| 4197 | } |
| 4198 | |
| 4199 | void glwProgramUniform1d (GLuint program, GLint location, GLdouble v0) |
| 4200 | { |
| 4201 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 4202 | if (!gl) |
| 4203 | return; |
| 4204 | gl->programUniform1d(program, location, v0); |
| 4205 | } |
| 4206 | |
| 4207 | void glwProgramUniform1dv (GLuint program, GLint location, GLsizei count, const GLdouble *value) |
| 4208 | { |
| 4209 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 4210 | if (!gl) |
| 4211 | return; |
| 4212 | gl->programUniform1dv(program, location, count, value); |
| 4213 | } |
| 4214 | |
| 4215 | void glwProgramUniform1f (GLuint program, GLint location, GLfloat v0) |
| 4216 | { |
| 4217 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 4218 | if (!gl) |
| 4219 | return; |
| 4220 | gl->programUniform1f(program, location, v0); |
| 4221 | } |
| 4222 | |
| 4223 | void glwProgramUniform1fv (GLuint program, GLint location, GLsizei count, const GLfloat *value) |
| 4224 | { |
| 4225 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 4226 | if (!gl) |
| 4227 | return; |
| 4228 | gl->programUniform1fv(program, location, count, value); |
| 4229 | } |
| 4230 | |
| 4231 | void glwProgramUniform1i (GLuint program, GLint location, GLint v0) |
| 4232 | { |
| 4233 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 4234 | if (!gl) |
| 4235 | return; |
| 4236 | gl->programUniform1i(program, location, v0); |
| 4237 | } |
| 4238 | |
| 4239 | void glwProgramUniform1iv (GLuint program, GLint location, GLsizei count, const GLint *value) |
| 4240 | { |
| 4241 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 4242 | if (!gl) |
| 4243 | return; |
| 4244 | gl->programUniform1iv(program, location, count, value); |
| 4245 | } |
| 4246 | |
| 4247 | void glwProgramUniform1ui (GLuint program, GLint location, GLuint v0) |
| 4248 | { |
| 4249 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 4250 | if (!gl) |
| 4251 | return; |
| 4252 | gl->programUniform1ui(program, location, v0); |
| 4253 | } |
| 4254 | |
| 4255 | void glwProgramUniform1uiv (GLuint program, GLint location, GLsizei count, const GLuint *value) |
| 4256 | { |
| 4257 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 4258 | if (!gl) |
| 4259 | return; |
| 4260 | gl->programUniform1uiv(program, location, count, value); |
| 4261 | } |
| 4262 | |
| 4263 | void glwProgramUniform2d (GLuint program, GLint location, GLdouble v0, GLdouble v1) |
| 4264 | { |
| 4265 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 4266 | if (!gl) |
| 4267 | return; |
| 4268 | gl->programUniform2d(program, location, v0, v1); |
| 4269 | } |
| 4270 | |
| 4271 | void glwProgramUniform2dv (GLuint program, GLint location, GLsizei count, const GLdouble *value) |
| 4272 | { |
| 4273 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 4274 | if (!gl) |
| 4275 | return; |
| 4276 | gl->programUniform2dv(program, location, count, value); |
| 4277 | } |
| 4278 | |
| 4279 | void glwProgramUniform2f (GLuint program, GLint location, GLfloat v0, GLfloat v1) |
| 4280 | { |
| 4281 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 4282 | if (!gl) |
| 4283 | return; |
| 4284 | gl->programUniform2f(program, location, v0, v1); |
| 4285 | } |
| 4286 | |
| 4287 | void glwProgramUniform2fv (GLuint program, GLint location, GLsizei count, const GLfloat *value) |
| 4288 | { |
| 4289 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 4290 | if (!gl) |
| 4291 | return; |
| 4292 | gl->programUniform2fv(program, location, count, value); |
| 4293 | } |
| 4294 | |
| 4295 | void glwProgramUniform2i (GLuint program, GLint location, GLint v0, GLint v1) |
| 4296 | { |
| 4297 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 4298 | if (!gl) |
| 4299 | return; |
| 4300 | gl->programUniform2i(program, location, v0, v1); |
| 4301 | } |
| 4302 | |
| 4303 | void glwProgramUniform2iv (GLuint program, GLint location, GLsizei count, const GLint *value) |
| 4304 | { |
| 4305 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 4306 | if (!gl) |
| 4307 | return; |
| 4308 | gl->programUniform2iv(program, location, count, value); |
| 4309 | } |
| 4310 | |
| 4311 | void glwProgramUniform2ui (GLuint program, GLint location, GLuint v0, GLuint v1) |
| 4312 | { |
| 4313 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 4314 | if (!gl) |
| 4315 | return; |
| 4316 | gl->programUniform2ui(program, location, v0, v1); |
| 4317 | } |
| 4318 | |
| 4319 | void glwProgramUniform2uiv (GLuint program, GLint location, GLsizei count, const GLuint *value) |
| 4320 | { |
| 4321 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 4322 | if (!gl) |
| 4323 | return; |
| 4324 | gl->programUniform2uiv(program, location, count, value); |
| 4325 | } |
| 4326 | |
| 4327 | void glwProgramUniform3d (GLuint program, GLint location, GLdouble v0, GLdouble v1, GLdouble v2) |
| 4328 | { |
| 4329 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 4330 | if (!gl) |
| 4331 | return; |
| 4332 | gl->programUniform3d(program, location, v0, v1, v2); |
| 4333 | } |
| 4334 | |
| 4335 | void glwProgramUniform3dv (GLuint program, GLint location, GLsizei count, const GLdouble *value) |
| 4336 | { |
| 4337 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 4338 | if (!gl) |
| 4339 | return; |
| 4340 | gl->programUniform3dv(program, location, count, value); |
| 4341 | } |
| 4342 | |
| 4343 | void glwProgramUniform3f (GLuint program, GLint location, GLfloat v0, GLfloat v1, GLfloat v2) |
| 4344 | { |
| 4345 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 4346 | if (!gl) |
| 4347 | return; |
| 4348 | gl->programUniform3f(program, location, v0, v1, v2); |
| 4349 | } |
| 4350 | |
| 4351 | void glwProgramUniform3fv (GLuint program, GLint location, GLsizei count, const GLfloat *value) |
| 4352 | { |
| 4353 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 4354 | if (!gl) |
| 4355 | return; |
| 4356 | gl->programUniform3fv(program, location, count, value); |
| 4357 | } |
| 4358 | |
| 4359 | void glwProgramUniform3i (GLuint program, GLint location, GLint v0, GLint v1, GLint v2) |
| 4360 | { |
| 4361 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 4362 | if (!gl) |
| 4363 | return; |
| 4364 | gl->programUniform3i(program, location, v0, v1, v2); |
| 4365 | } |
| 4366 | |
| 4367 | void glwProgramUniform3iv (GLuint program, GLint location, GLsizei count, const GLint *value) |
| 4368 | { |
| 4369 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 4370 | if (!gl) |
| 4371 | return; |
| 4372 | gl->programUniform3iv(program, location, count, value); |
| 4373 | } |
| 4374 | |
| 4375 | void glwProgramUniform3ui (GLuint program, GLint location, GLuint v0, GLuint v1, GLuint v2) |
| 4376 | { |
| 4377 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 4378 | if (!gl) |
| 4379 | return; |
| 4380 | gl->programUniform3ui(program, location, v0, v1, v2); |
| 4381 | } |
| 4382 | |
| 4383 | void glwProgramUniform3uiv (GLuint program, GLint location, GLsizei count, const GLuint *value) |
| 4384 | { |
| 4385 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 4386 | if (!gl) |
| 4387 | return; |
| 4388 | gl->programUniform3uiv(program, location, count, value); |
| 4389 | } |
| 4390 | |
| 4391 | void glwProgramUniform4d (GLuint program, GLint location, GLdouble v0, GLdouble v1, GLdouble v2, GLdouble v3) |
| 4392 | { |
| 4393 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 4394 | if (!gl) |
| 4395 | return; |
| 4396 | gl->programUniform4d(program, location, v0, v1, v2, v3); |
| 4397 | } |
| 4398 | |
| 4399 | void glwProgramUniform4dv (GLuint program, GLint location, GLsizei count, const GLdouble *value) |
| 4400 | { |
| 4401 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 4402 | if (!gl) |
| 4403 | return; |
| 4404 | gl->programUniform4dv(program, location, count, value); |
| 4405 | } |
| 4406 | |
| 4407 | void glwProgramUniform4f (GLuint program, GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3) |
| 4408 | { |
| 4409 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 4410 | if (!gl) |
| 4411 | return; |
| 4412 | gl->programUniform4f(program, location, v0, v1, v2, v3); |
| 4413 | } |
| 4414 | |
| 4415 | void glwProgramUniform4fv (GLuint program, GLint location, GLsizei count, const GLfloat *value) |
| 4416 | { |
| 4417 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 4418 | if (!gl) |
| 4419 | return; |
| 4420 | gl->programUniform4fv(program, location, count, value); |
| 4421 | } |
| 4422 | |
| 4423 | void glwProgramUniform4i (GLuint program, GLint location, GLint v0, GLint v1, GLint v2, GLint v3) |
| 4424 | { |
| 4425 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 4426 | if (!gl) |
| 4427 | return; |
| 4428 | gl->programUniform4i(program, location, v0, v1, v2, v3); |
| 4429 | } |
| 4430 | |
| 4431 | void glwProgramUniform4iv (GLuint program, GLint location, GLsizei count, const GLint *value) |
| 4432 | { |
| 4433 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 4434 | if (!gl) |
| 4435 | return; |
| 4436 | gl->programUniform4iv(program, location, count, value); |
| 4437 | } |
| 4438 | |
| 4439 | void glwProgramUniform4ui (GLuint program, GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3) |
| 4440 | { |
| 4441 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 4442 | if (!gl) |
| 4443 | return; |
| 4444 | gl->programUniform4ui(program, location, v0, v1, v2, v3); |
| 4445 | } |
| 4446 | |
| 4447 | void glwProgramUniform4uiv (GLuint program, GLint location, GLsizei count, const GLuint *value) |
| 4448 | { |
| 4449 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 4450 | if (!gl) |
| 4451 | return; |
| 4452 | gl->programUniform4uiv(program, location, count, value); |
| 4453 | } |
| 4454 | |
| 4455 | void glwProgramUniformMatrix2dv (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value) |
| 4456 | { |
| 4457 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 4458 | if (!gl) |
| 4459 | return; |
| 4460 | gl->programUniformMatrix2dv(program, location, count, transpose, value); |
| 4461 | } |
| 4462 | |
| 4463 | void glwProgramUniformMatrix2fv (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value) |
| 4464 | { |
| 4465 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 4466 | if (!gl) |
| 4467 | return; |
| 4468 | gl->programUniformMatrix2fv(program, location, count, transpose, value); |
| 4469 | } |
| 4470 | |
| 4471 | void glwProgramUniformMatrix2x3dv (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value) |
| 4472 | { |
| 4473 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 4474 | if (!gl) |
| 4475 | return; |
| 4476 | gl->programUniformMatrix2x3dv(program, location, count, transpose, value); |
| 4477 | } |
| 4478 | |
| 4479 | void glwProgramUniformMatrix2x3fv (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value) |
| 4480 | { |
| 4481 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 4482 | if (!gl) |
| 4483 | return; |
| 4484 | gl->programUniformMatrix2x3fv(program, location, count, transpose, value); |
| 4485 | } |
| 4486 | |
| 4487 | void glwProgramUniformMatrix2x4dv (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value) |
| 4488 | { |
| 4489 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 4490 | if (!gl) |
| 4491 | return; |
| 4492 | gl->programUniformMatrix2x4dv(program, location, count, transpose, value); |
| 4493 | } |
| 4494 | |
| 4495 | void glwProgramUniformMatrix2x4fv (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value) |
| 4496 | { |
| 4497 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 4498 | if (!gl) |
| 4499 | return; |
| 4500 | gl->programUniformMatrix2x4fv(program, location, count, transpose, value); |
| 4501 | } |
| 4502 | |
| 4503 | void glwProgramUniformMatrix3dv (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value) |
| 4504 | { |
| 4505 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 4506 | if (!gl) |
| 4507 | return; |
| 4508 | gl->programUniformMatrix3dv(program, location, count, transpose, value); |
| 4509 | } |
| 4510 | |
| 4511 | void glwProgramUniformMatrix3fv (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value) |
| 4512 | { |
| 4513 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 4514 | if (!gl) |
| 4515 | return; |
| 4516 | gl->programUniformMatrix3fv(program, location, count, transpose, value); |
| 4517 | } |
| 4518 | |
| 4519 | void glwProgramUniformMatrix3x2dv (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value) |
| 4520 | { |
| 4521 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 4522 | if (!gl) |
| 4523 | return; |
| 4524 | gl->programUniformMatrix3x2dv(program, location, count, transpose, value); |
| 4525 | } |
| 4526 | |
| 4527 | void glwProgramUniformMatrix3x2fv (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value) |
| 4528 | { |
| 4529 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 4530 | if (!gl) |
| 4531 | return; |
| 4532 | gl->programUniformMatrix3x2fv(program, location, count, transpose, value); |
| 4533 | } |
| 4534 | |
| 4535 | void glwProgramUniformMatrix3x4dv (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value) |
| 4536 | { |
| 4537 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 4538 | if (!gl) |
| 4539 | return; |
| 4540 | gl->programUniformMatrix3x4dv(program, location, count, transpose, value); |
| 4541 | } |
| 4542 | |
| 4543 | void glwProgramUniformMatrix3x4fv (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value) |
| 4544 | { |
| 4545 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 4546 | if (!gl) |
| 4547 | return; |
| 4548 | gl->programUniformMatrix3x4fv(program, location, count, transpose, value); |
| 4549 | } |
| 4550 | |
| 4551 | void glwProgramUniformMatrix4dv (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value) |
| 4552 | { |
| 4553 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 4554 | if (!gl) |
| 4555 | return; |
| 4556 | gl->programUniformMatrix4dv(program, location, count, transpose, value); |
| 4557 | } |
| 4558 | |
| 4559 | void glwProgramUniformMatrix4fv (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value) |
| 4560 | { |
| 4561 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 4562 | if (!gl) |
| 4563 | return; |
| 4564 | gl->programUniformMatrix4fv(program, location, count, transpose, value); |
| 4565 | } |
| 4566 | |
| 4567 | void glwProgramUniformMatrix4x2dv (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value) |
| 4568 | { |
| 4569 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 4570 | if (!gl) |
| 4571 | return; |
| 4572 | gl->programUniformMatrix4x2dv(program, location, count, transpose, value); |
| 4573 | } |
| 4574 | |
| 4575 | void glwProgramUniformMatrix4x2fv (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value) |
| 4576 | { |
| 4577 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 4578 | if (!gl) |
| 4579 | return; |
| 4580 | gl->programUniformMatrix4x2fv(program, location, count, transpose, value); |
| 4581 | } |
| 4582 | |
| 4583 | void glwProgramUniformMatrix4x3dv (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value) |
| 4584 | { |
| 4585 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 4586 | if (!gl) |
| 4587 | return; |
| 4588 | gl->programUniformMatrix4x3dv(program, location, count, transpose, value); |
| 4589 | } |
| 4590 | |
| 4591 | void glwProgramUniformMatrix4x3fv (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value) |
| 4592 | { |
| 4593 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 4594 | if (!gl) |
| 4595 | return; |
| 4596 | gl->programUniformMatrix4x3fv(program, location, count, transpose, value); |
| 4597 | } |
| 4598 | |
| 4599 | void glwProvokingVertex (GLenum mode) |
| 4600 | { |
| 4601 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 4602 | if (!gl) |
| 4603 | return; |
| 4604 | gl->provokingVertex(mode); |
| 4605 | } |
| 4606 | |
Pyry Haulos | 933ef4d | 2016-11-14 13:01:12 -0800 | [diff] [blame] | 4607 | void glwPushClientAttribDefaultEXT (GLbitfield mask) |
| 4608 | { |
| 4609 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 4610 | if (!gl) |
| 4611 | return; |
| 4612 | gl->pushClientAttribDefaultEXT(mask); |
| 4613 | } |
| 4614 | |
Pyry Haulos | 1abab60 | 2014-11-05 17:41:42 -0800 | [diff] [blame] | 4615 | void glwPushDebugGroup (GLenum source, GLuint id, GLsizei length, const GLchar *message) |
| 4616 | { |
| 4617 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 4618 | if (!gl) |
| 4619 | return; |
| 4620 | gl->pushDebugGroup(source, id, length, message); |
| 4621 | } |
| 4622 | |
Pyry Haulos | 1a9576a | 2015-05-20 15:36:20 -0700 | [diff] [blame] | 4623 | void glwPushGroupMarkerEXT (GLsizei length, const GLchar *marker) |
| 4624 | { |
| 4625 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 4626 | if (!gl) |
| 4627 | return; |
| 4628 | gl->pushGroupMarkerEXT(length, marker); |
| 4629 | } |
| 4630 | |
Pyry Haulos | 1abab60 | 2014-11-05 17:41:42 -0800 | [diff] [blame] | 4631 | void glwQueryCounter (GLuint id, GLenum target) |
| 4632 | { |
| 4633 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 4634 | if (!gl) |
| 4635 | return; |
| 4636 | gl->queryCounter(id, target); |
| 4637 | } |
| 4638 | |
| 4639 | void glwReadBuffer (GLenum src) |
| 4640 | { |
| 4641 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 4642 | if (!gl) |
| 4643 | return; |
| 4644 | gl->readBuffer(src); |
| 4645 | } |
| 4646 | |
| 4647 | void glwReadPixels (GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, void *pixels) |
| 4648 | { |
| 4649 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 4650 | if (!gl) |
| 4651 | return; |
| 4652 | gl->readPixels(x, y, width, height, format, type, pixels); |
| 4653 | } |
| 4654 | |
| 4655 | void glwReadnPixels (GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLsizei bufSize, void *data) |
| 4656 | { |
| 4657 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 4658 | if (!gl) |
| 4659 | return; |
| 4660 | gl->readnPixels(x, y, width, height, format, type, bufSize, data); |
| 4661 | } |
| 4662 | |
| 4663 | void glwReleaseShaderCompiler (void) |
| 4664 | { |
| 4665 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 4666 | if (!gl) |
| 4667 | return; |
| 4668 | gl->releaseShaderCompiler(); |
| 4669 | } |
| 4670 | |
| 4671 | void glwRenderbufferStorage (GLenum target, GLenum internalformat, GLsizei width, GLsizei height) |
| 4672 | { |
| 4673 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 4674 | if (!gl) |
| 4675 | return; |
| 4676 | gl->renderbufferStorage(target, internalformat, width, height); |
| 4677 | } |
| 4678 | |
| 4679 | void glwRenderbufferStorageMultisample (GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height) |
| 4680 | { |
| 4681 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 4682 | if (!gl) |
| 4683 | return; |
| 4684 | gl->renderbufferStorageMultisample(target, samples, internalformat, width, height); |
| 4685 | } |
| 4686 | |
| 4687 | void glwResumeTransformFeedback (void) |
| 4688 | { |
| 4689 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 4690 | if (!gl) |
| 4691 | return; |
| 4692 | gl->resumeTransformFeedback(); |
| 4693 | } |
| 4694 | |
| 4695 | void glwSampleCoverage (GLfloat value, GLboolean invert) |
| 4696 | { |
| 4697 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 4698 | if (!gl) |
| 4699 | return; |
| 4700 | gl->sampleCoverage(value, invert); |
| 4701 | } |
| 4702 | |
| 4703 | void glwSampleMaski (GLuint maskNumber, GLbitfield mask) |
| 4704 | { |
| 4705 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 4706 | if (!gl) |
| 4707 | return; |
| 4708 | gl->sampleMaski(maskNumber, mask); |
| 4709 | } |
| 4710 | |
| 4711 | void glwSamplerParameterIiv (GLuint sampler, GLenum pname, const GLint *param) |
| 4712 | { |
| 4713 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 4714 | if (!gl) |
| 4715 | return; |
| 4716 | gl->samplerParameterIiv(sampler, pname, param); |
| 4717 | } |
| 4718 | |
| 4719 | void glwSamplerParameterIuiv (GLuint sampler, GLenum pname, const GLuint *param) |
| 4720 | { |
| 4721 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 4722 | if (!gl) |
| 4723 | return; |
| 4724 | gl->samplerParameterIuiv(sampler, pname, param); |
| 4725 | } |
| 4726 | |
| 4727 | void glwSamplerParameterf (GLuint sampler, GLenum pname, GLfloat param) |
| 4728 | { |
| 4729 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 4730 | if (!gl) |
| 4731 | return; |
| 4732 | gl->samplerParameterf(sampler, pname, param); |
| 4733 | } |
| 4734 | |
| 4735 | void glwSamplerParameterfv (GLuint sampler, GLenum pname, const GLfloat *param) |
| 4736 | { |
| 4737 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 4738 | if (!gl) |
| 4739 | return; |
| 4740 | gl->samplerParameterfv(sampler, pname, param); |
| 4741 | } |
| 4742 | |
| 4743 | void glwSamplerParameteri (GLuint sampler, GLenum pname, GLint param) |
| 4744 | { |
| 4745 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 4746 | if (!gl) |
| 4747 | return; |
| 4748 | gl->samplerParameteri(sampler, pname, param); |
| 4749 | } |
| 4750 | |
| 4751 | void glwSamplerParameteriv (GLuint sampler, GLenum pname, const GLint *param) |
| 4752 | { |
| 4753 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 4754 | if (!gl) |
| 4755 | return; |
| 4756 | gl->samplerParameteriv(sampler, pname, param); |
| 4757 | } |
| 4758 | |
| 4759 | void glwScissor (GLint x, GLint y, GLsizei width, GLsizei height) |
| 4760 | { |
| 4761 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 4762 | if (!gl) |
| 4763 | return; |
| 4764 | gl->scissor(x, y, width, height); |
| 4765 | } |
| 4766 | |
| 4767 | void glwScissorArrayv (GLuint first, GLsizei count, const GLint *v) |
| 4768 | { |
| 4769 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 4770 | if (!gl) |
| 4771 | return; |
| 4772 | gl->scissorArrayv(first, count, v); |
| 4773 | } |
| 4774 | |
| 4775 | void glwScissorIndexed (GLuint index, GLint left, GLint bottom, GLsizei width, GLsizei height) |
| 4776 | { |
| 4777 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 4778 | if (!gl) |
| 4779 | return; |
| 4780 | gl->scissorIndexed(index, left, bottom, width, height); |
| 4781 | } |
| 4782 | |
| 4783 | void glwScissorIndexedv (GLuint index, const GLint *v) |
| 4784 | { |
| 4785 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 4786 | if (!gl) |
| 4787 | return; |
| 4788 | gl->scissorIndexedv(index, v); |
| 4789 | } |
| 4790 | |
| 4791 | void glwShaderBinary (GLsizei count, const GLuint *shaders, GLenum binaryformat, const void *binary, GLsizei length) |
| 4792 | { |
| 4793 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 4794 | if (!gl) |
| 4795 | return; |
| 4796 | gl->shaderBinary(count, shaders, binaryformat, binary, length); |
| 4797 | } |
| 4798 | |
| 4799 | void glwShaderSource (GLuint shader, GLsizei count, const GLchar *const*string, const GLint *length) |
| 4800 | { |
| 4801 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 4802 | if (!gl) |
| 4803 | return; |
| 4804 | gl->shaderSource(shader, count, string, length); |
Jarkko Poyry | 3c82736 | 2014-09-02 11:48:52 +0300 | [diff] [blame] | 4805 | } |
| 4806 | |
| 4807 | void glwShaderStorageBlockBinding (GLuint program, GLuint storageBlockIndex, GLuint storageBlockBinding) |
| 4808 | { |
| 4809 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 4810 | if (!gl) |
Pyry Haulos | 1abab60 | 2014-11-05 17:41:42 -0800 | [diff] [blame] | 4811 | return; |
Jarkko Poyry | 3c82736 | 2014-09-02 11:48:52 +0300 | [diff] [blame] | 4812 | gl->shaderStorageBlockBinding(program, storageBlockIndex, storageBlockBinding); |
| 4813 | } |
| 4814 | |
Pyry Haulos | 1abab60 | 2014-11-05 17:41:42 -0800 | [diff] [blame] | 4815 | void glwStencilFunc (GLenum func, GLint ref, GLuint mask) |
| 4816 | { |
| 4817 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 4818 | if (!gl) |
| 4819 | return; |
| 4820 | gl->stencilFunc(func, ref, mask); |
| 4821 | } |
| 4822 | |
| 4823 | void glwStencilFuncSeparate (GLenum face, GLenum func, GLint ref, GLuint mask) |
| 4824 | { |
| 4825 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 4826 | if (!gl) |
| 4827 | return; |
| 4828 | gl->stencilFuncSeparate(face, func, ref, mask); |
| 4829 | } |
| 4830 | |
| 4831 | void glwStencilMask (GLuint mask) |
| 4832 | { |
| 4833 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 4834 | if (!gl) |
| 4835 | return; |
| 4836 | gl->stencilMask(mask); |
| 4837 | } |
| 4838 | |
| 4839 | void glwStencilMaskSeparate (GLenum face, GLuint mask) |
| 4840 | { |
| 4841 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 4842 | if (!gl) |
| 4843 | return; |
| 4844 | gl->stencilMaskSeparate(face, mask); |
| 4845 | } |
| 4846 | |
| 4847 | void glwStencilOp (GLenum fail, GLenum zfail, GLenum zpass) |
| 4848 | { |
| 4849 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 4850 | if (!gl) |
| 4851 | return; |
| 4852 | gl->stencilOp(fail, zfail, zpass); |
| 4853 | } |
| 4854 | |
| 4855 | void glwStencilOpSeparate (GLenum face, GLenum sfail, GLenum dpfail, GLenum dppass) |
| 4856 | { |
| 4857 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 4858 | if (!gl) |
| 4859 | return; |
| 4860 | gl->stencilOpSeparate(face, sfail, dpfail, dppass); |
| 4861 | } |
| 4862 | |
| 4863 | void glwTexBuffer (GLenum target, GLenum internalformat, GLuint buffer) |
| 4864 | { |
| 4865 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 4866 | if (!gl) |
| 4867 | return; |
| 4868 | gl->texBuffer(target, internalformat, buffer); |
| 4869 | } |
| 4870 | |
Jarkko Poyry | 3c82736 | 2014-09-02 11:48:52 +0300 | [diff] [blame] | 4871 | void glwTexBufferRange (GLenum target, GLenum internalformat, GLuint buffer, GLintptr offset, GLsizeiptr size) |
| 4872 | { |
| 4873 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 4874 | if (!gl) |
Pyry Haulos | 1abab60 | 2014-11-05 17:41:42 -0800 | [diff] [blame] | 4875 | return; |
Jarkko Poyry | 3c82736 | 2014-09-02 11:48:52 +0300 | [diff] [blame] | 4876 | gl->texBufferRange(target, internalformat, buffer, offset, size); |
| 4877 | } |
| 4878 | |
Pyry Haulos | 1abab60 | 2014-11-05 17:41:42 -0800 | [diff] [blame] | 4879 | void glwTexImage1D (GLenum target, GLint level, GLint internalformat, GLsizei width, GLint border, GLenum format, GLenum type, const void *pixels) |
| 4880 | { |
| 4881 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 4882 | if (!gl) |
| 4883 | return; |
| 4884 | gl->texImage1D(target, level, internalformat, width, border, format, type, pixels); |
| 4885 | } |
| 4886 | |
| 4887 | void glwTexImage2D (GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const void *pixels) |
| 4888 | { |
| 4889 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 4890 | if (!gl) |
| 4891 | return; |
| 4892 | gl->texImage2D(target, level, internalformat, width, height, border, format, type, pixels); |
| 4893 | } |
| 4894 | |
| 4895 | void glwTexImage2DMultisample (GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLboolean fixedsamplelocations) |
| 4896 | { |
| 4897 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 4898 | if (!gl) |
| 4899 | return; |
| 4900 | gl->texImage2DMultisample(target, samples, internalformat, width, height, fixedsamplelocations); |
| 4901 | } |
| 4902 | |
| 4903 | void glwTexImage3D (GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const void *pixels) |
| 4904 | { |
| 4905 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 4906 | if (!gl) |
| 4907 | return; |
| 4908 | gl->texImage3D(target, level, internalformat, width, height, depth, border, format, type, pixels); |
| 4909 | } |
| 4910 | |
| 4911 | void glwTexImage3DMultisample (GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLboolean fixedsamplelocations) |
| 4912 | { |
| 4913 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 4914 | if (!gl) |
| 4915 | return; |
| 4916 | gl->texImage3DMultisample(target, samples, internalformat, width, height, depth, fixedsamplelocations); |
| 4917 | } |
| 4918 | |
Pyry Haulos | 933ef4d | 2016-11-14 13:01:12 -0800 | [diff] [blame] | 4919 | void glwTexImage3DOES (GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const void *pixels) |
| 4920 | { |
| 4921 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 4922 | if (!gl) |
| 4923 | return; |
| 4924 | gl->texImage3DOES(target, level, internalformat, width, height, depth, border, format, type, pixels); |
| 4925 | } |
| 4926 | |
| 4927 | void glwTexPageCommitmentARB (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLboolean commit) |
| 4928 | { |
| 4929 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 4930 | if (!gl) |
| 4931 | return; |
| 4932 | gl->texPageCommitmentARB(target, level, xoffset, yoffset, zoffset, width, height, depth, commit); |
| 4933 | } |
| 4934 | |
Pyry Haulos | 1abab60 | 2014-11-05 17:41:42 -0800 | [diff] [blame] | 4935 | void glwTexParameterIiv (GLenum target, GLenum pname, const GLint *params) |
| 4936 | { |
| 4937 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 4938 | if (!gl) |
| 4939 | return; |
| 4940 | gl->texParameterIiv(target, pname, params); |
| 4941 | } |
| 4942 | |
| 4943 | void glwTexParameterIuiv (GLenum target, GLenum pname, const GLuint *params) |
| 4944 | { |
| 4945 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 4946 | if (!gl) |
| 4947 | return; |
| 4948 | gl->texParameterIuiv(target, pname, params); |
| 4949 | } |
| 4950 | |
| 4951 | void glwTexParameterf (GLenum target, GLenum pname, GLfloat param) |
| 4952 | { |
| 4953 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 4954 | if (!gl) |
| 4955 | return; |
| 4956 | gl->texParameterf(target, pname, param); |
| 4957 | } |
| 4958 | |
| 4959 | void glwTexParameterfv (GLenum target, GLenum pname, const GLfloat *params) |
| 4960 | { |
| 4961 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 4962 | if (!gl) |
| 4963 | return; |
| 4964 | gl->texParameterfv(target, pname, params); |
| 4965 | } |
| 4966 | |
| 4967 | void glwTexParameteri (GLenum target, GLenum pname, GLint param) |
| 4968 | { |
| 4969 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 4970 | if (!gl) |
| 4971 | return; |
| 4972 | gl->texParameteri(target, pname, param); |
| 4973 | } |
| 4974 | |
| 4975 | void glwTexParameteriv (GLenum target, GLenum pname, const GLint *params) |
| 4976 | { |
| 4977 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 4978 | if (!gl) |
| 4979 | return; |
| 4980 | gl->texParameteriv(target, pname, params); |
| 4981 | } |
| 4982 | |
| 4983 | void glwTexStorage1D (GLenum target, GLsizei levels, GLenum internalformat, GLsizei width) |
| 4984 | { |
| 4985 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 4986 | if (!gl) |
| 4987 | return; |
| 4988 | gl->texStorage1D(target, levels, internalformat, width); |
| 4989 | } |
| 4990 | |
Pyry Haulos | 933ef4d | 2016-11-14 13:01:12 -0800 | [diff] [blame] | 4991 | void glwTexStorage1DEXT (GLenum target, GLsizei levels, GLenum internalformat, GLsizei width) |
| 4992 | { |
| 4993 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 4994 | if (!gl) |
| 4995 | return; |
| 4996 | gl->texStorage1DEXT(target, levels, internalformat, width); |
| 4997 | } |
| 4998 | |
Pyry Haulos | 1abab60 | 2014-11-05 17:41:42 -0800 | [diff] [blame] | 4999 | void glwTexStorage2D (GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height) |
| 5000 | { |
| 5001 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 5002 | if (!gl) |
| 5003 | return; |
| 5004 | gl->texStorage2D(target, levels, internalformat, width, height); |
| 5005 | } |
| 5006 | |
Pyry Haulos | 933ef4d | 2016-11-14 13:01:12 -0800 | [diff] [blame] | 5007 | void glwTexStorage2DEXT (GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height) |
| 5008 | { |
| 5009 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 5010 | if (!gl) |
| 5011 | return; |
| 5012 | gl->texStorage2DEXT(target, levels, internalformat, width, height); |
| 5013 | } |
| 5014 | |
Jarkko Poyry | 3c82736 | 2014-09-02 11:48:52 +0300 | [diff] [blame] | 5015 | void glwTexStorage2DMultisample (GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLboolean fixedsamplelocations) |
| 5016 | { |
| 5017 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 5018 | if (!gl) |
Pyry Haulos | 1abab60 | 2014-11-05 17:41:42 -0800 | [diff] [blame] | 5019 | return; |
Jarkko Poyry | 3c82736 | 2014-09-02 11:48:52 +0300 | [diff] [blame] | 5020 | gl->texStorage2DMultisample(target, samples, internalformat, width, height, fixedsamplelocations); |
| 5021 | } |
| 5022 | |
Pyry Haulos | 1abab60 | 2014-11-05 17:41:42 -0800 | [diff] [blame] | 5023 | void glwTexStorage3D (GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth) |
| 5024 | { |
| 5025 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 5026 | if (!gl) |
| 5027 | return; |
| 5028 | gl->texStorage3D(target, levels, internalformat, width, height, depth); |
| 5029 | } |
| 5030 | |
Pyry Haulos | 933ef4d | 2016-11-14 13:01:12 -0800 | [diff] [blame] | 5031 | void glwTexStorage3DEXT (GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth) |
| 5032 | { |
| 5033 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 5034 | if (!gl) |
| 5035 | return; |
| 5036 | gl->texStorage3DEXT(target, levels, internalformat, width, height, depth); |
| 5037 | } |
| 5038 | |
Jarkko Poyry | 3c82736 | 2014-09-02 11:48:52 +0300 | [diff] [blame] | 5039 | void glwTexStorage3DMultisample (GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLboolean fixedsamplelocations) |
| 5040 | { |
| 5041 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 5042 | if (!gl) |
Pyry Haulos | 1abab60 | 2014-11-05 17:41:42 -0800 | [diff] [blame] | 5043 | return; |
Jarkko Poyry | 3c82736 | 2014-09-02 11:48:52 +0300 | [diff] [blame] | 5044 | gl->texStorage3DMultisample(target, samples, internalformat, width, height, depth, fixedsamplelocations); |
| 5045 | } |
| 5046 | |
Pyry Haulos | 1abab60 | 2014-11-05 17:41:42 -0800 | [diff] [blame] | 5047 | void glwTexSubImage1D (GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const void *pixels) |
| 5048 | { |
| 5049 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 5050 | if (!gl) |
| 5051 | return; |
| 5052 | gl->texSubImage1D(target, level, xoffset, width, format, type, pixels); |
| 5053 | } |
| 5054 | |
| 5055 | void glwTexSubImage2D (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const void *pixels) |
| 5056 | { |
| 5057 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 5058 | if (!gl) |
| 5059 | return; |
| 5060 | gl->texSubImage2D(target, level, xoffset, yoffset, width, height, format, type, pixels); |
| 5061 | } |
| 5062 | |
| 5063 | void glwTexSubImage3D (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const void *pixels) |
| 5064 | { |
| 5065 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 5066 | if (!gl) |
| 5067 | return; |
| 5068 | gl->texSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels); |
| 5069 | } |
| 5070 | |
Pyry Haulos | 933ef4d | 2016-11-14 13:01:12 -0800 | [diff] [blame] | 5071 | void glwTexSubImage3DOES (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const void *pixels) |
| 5072 | { |
| 5073 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 5074 | if (!gl) |
| 5075 | return; |
| 5076 | gl->texSubImage3DOES(target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels); |
| 5077 | } |
| 5078 | |
Pyry Haulos | 1abab60 | 2014-11-05 17:41:42 -0800 | [diff] [blame] | 5079 | void glwTextureBarrier (void) |
| 5080 | { |
| 5081 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 5082 | if (!gl) |
| 5083 | return; |
| 5084 | gl->textureBarrier(); |
| 5085 | } |
| 5086 | |
| 5087 | void glwTextureBuffer (GLuint texture, GLenum internalformat, GLuint buffer) |
| 5088 | { |
| 5089 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 5090 | if (!gl) |
| 5091 | return; |
| 5092 | gl->textureBuffer(texture, internalformat, buffer); |
| 5093 | } |
| 5094 | |
Mika Isojärvi | 314799d | 2015-01-23 15:01:53 -0800 | [diff] [blame] | 5095 | void glwTextureBufferRange (GLuint texture, GLenum internalformat, GLuint buffer, GLintptr offset, GLsizeiptr size) |
Pyry Haulos | 1abab60 | 2014-11-05 17:41:42 -0800 | [diff] [blame] | 5096 | { |
| 5097 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 5098 | if (!gl) |
| 5099 | return; |
| 5100 | gl->textureBufferRange(texture, internalformat, buffer, offset, size); |
| 5101 | } |
| 5102 | |
Pyry Haulos | 933ef4d | 2016-11-14 13:01:12 -0800 | [diff] [blame] | 5103 | void glwTextureImage1DEXT (GLuint texture, GLenum target, GLint level, GLint internalformat, GLsizei width, GLint border, GLenum format, GLenum type, const void *pixels) |
| 5104 | { |
| 5105 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 5106 | if (!gl) |
| 5107 | return; |
| 5108 | gl->textureImage1DEXT(texture, target, level, internalformat, width, border, format, type, pixels); |
| 5109 | } |
| 5110 | |
| 5111 | void glwTextureImage2DEXT (GLuint texture, GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const void *pixels) |
| 5112 | { |
| 5113 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 5114 | if (!gl) |
| 5115 | return; |
| 5116 | gl->textureImage2DEXT(texture, target, level, internalformat, width, height, border, format, type, pixels); |
| 5117 | } |
| 5118 | |
| 5119 | void glwTextureImage3DEXT (GLuint texture, GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const void *pixels) |
| 5120 | { |
| 5121 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 5122 | if (!gl) |
| 5123 | return; |
| 5124 | gl->textureImage3DEXT(texture, target, level, internalformat, width, height, depth, border, format, type, pixels); |
| 5125 | } |
| 5126 | |
| 5127 | void glwTexturePageCommitmentEXT (GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLboolean commit) |
| 5128 | { |
| 5129 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 5130 | if (!gl) |
| 5131 | return; |
| 5132 | gl->texturePageCommitmentEXT(texture, level, xoffset, yoffset, zoffset, width, height, depth, commit); |
| 5133 | } |
| 5134 | |
Pyry Haulos | 1abab60 | 2014-11-05 17:41:42 -0800 | [diff] [blame] | 5135 | void glwTextureParameterIiv (GLuint texture, GLenum pname, const GLint *params) |
| 5136 | { |
| 5137 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 5138 | if (!gl) |
| 5139 | return; |
| 5140 | gl->textureParameterIiv(texture, pname, params); |
| 5141 | } |
| 5142 | |
| 5143 | void glwTextureParameterIuiv (GLuint texture, GLenum pname, const GLuint *params) |
| 5144 | { |
| 5145 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 5146 | if (!gl) |
| 5147 | return; |
| 5148 | gl->textureParameterIuiv(texture, pname, params); |
| 5149 | } |
| 5150 | |
| 5151 | void glwTextureParameterf (GLuint texture, GLenum pname, GLfloat param) |
| 5152 | { |
| 5153 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 5154 | if (!gl) |
| 5155 | return; |
| 5156 | gl->textureParameterf(texture, pname, param); |
| 5157 | } |
| 5158 | |
| 5159 | void glwTextureParameterfv (GLuint texture, GLenum pname, const GLfloat *param) |
| 5160 | { |
| 5161 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 5162 | if (!gl) |
| 5163 | return; |
| 5164 | gl->textureParameterfv(texture, pname, param); |
| 5165 | } |
| 5166 | |
| 5167 | void glwTextureParameteri (GLuint texture, GLenum pname, GLint param) |
| 5168 | { |
| 5169 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 5170 | if (!gl) |
| 5171 | return; |
| 5172 | gl->textureParameteri(texture, pname, param); |
| 5173 | } |
| 5174 | |
| 5175 | void glwTextureParameteriv (GLuint texture, GLenum pname, const GLint *param) |
| 5176 | { |
| 5177 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 5178 | if (!gl) |
| 5179 | return; |
| 5180 | gl->textureParameteriv(texture, pname, param); |
| 5181 | } |
| 5182 | |
Pyry Haulos | 933ef4d | 2016-11-14 13:01:12 -0800 | [diff] [blame] | 5183 | void glwTextureRenderbufferEXT (GLuint texture, GLenum target, GLuint renderbuffer) |
| 5184 | { |
| 5185 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 5186 | if (!gl) |
| 5187 | return; |
| 5188 | gl->textureRenderbufferEXT(texture, target, renderbuffer); |
| 5189 | } |
| 5190 | |
Pyry Haulos | 1abab60 | 2014-11-05 17:41:42 -0800 | [diff] [blame] | 5191 | void glwTextureStorage1D (GLuint texture, GLsizei levels, GLenum internalformat, GLsizei width) |
| 5192 | { |
| 5193 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 5194 | if (!gl) |
| 5195 | return; |
| 5196 | gl->textureStorage1D(texture, levels, internalformat, width); |
| 5197 | } |
| 5198 | |
Pyry Haulos | 933ef4d | 2016-11-14 13:01:12 -0800 | [diff] [blame] | 5199 | void glwTextureStorage1DEXT (GLuint texture, GLenum target, GLsizei levels, GLenum internalformat, GLsizei width) |
| 5200 | { |
| 5201 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 5202 | if (!gl) |
| 5203 | return; |
| 5204 | gl->textureStorage1DEXT(texture, target, levels, internalformat, width); |
| 5205 | } |
| 5206 | |
Pyry Haulos | 1abab60 | 2014-11-05 17:41:42 -0800 | [diff] [blame] | 5207 | void glwTextureStorage2D (GLuint texture, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height) |
| 5208 | { |
| 5209 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 5210 | if (!gl) |
| 5211 | return; |
| 5212 | gl->textureStorage2D(texture, levels, internalformat, width, height); |
| 5213 | } |
| 5214 | |
Pyry Haulos | 933ef4d | 2016-11-14 13:01:12 -0800 | [diff] [blame] | 5215 | void glwTextureStorage2DEXT (GLuint texture, GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height) |
| 5216 | { |
| 5217 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 5218 | if (!gl) |
| 5219 | return; |
| 5220 | gl->textureStorage2DEXT(texture, target, levels, internalformat, width, height); |
| 5221 | } |
| 5222 | |
Pyry Haulos | 1abab60 | 2014-11-05 17:41:42 -0800 | [diff] [blame] | 5223 | void glwTextureStorage2DMultisample (GLuint texture, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLboolean fixedsamplelocations) |
| 5224 | { |
| 5225 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 5226 | if (!gl) |
| 5227 | return; |
| 5228 | gl->textureStorage2DMultisample(texture, samples, internalformat, width, height, fixedsamplelocations); |
| 5229 | } |
| 5230 | |
| 5231 | void glwTextureStorage3D (GLuint texture, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth) |
| 5232 | { |
| 5233 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 5234 | if (!gl) |
| 5235 | return; |
| 5236 | gl->textureStorage3D(texture, levels, internalformat, width, height, depth); |
| 5237 | } |
| 5238 | |
Pyry Haulos | 933ef4d | 2016-11-14 13:01:12 -0800 | [diff] [blame] | 5239 | void glwTextureStorage3DEXT (GLuint texture, GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth) |
| 5240 | { |
| 5241 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 5242 | if (!gl) |
| 5243 | return; |
| 5244 | gl->textureStorage3DEXT(texture, target, levels, internalformat, width, height, depth); |
| 5245 | } |
| 5246 | |
Pyry Haulos | 1abab60 | 2014-11-05 17:41:42 -0800 | [diff] [blame] | 5247 | void glwTextureStorage3DMultisample (GLuint texture, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLboolean fixedsamplelocations) |
| 5248 | { |
| 5249 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 5250 | if (!gl) |
| 5251 | return; |
| 5252 | gl->textureStorage3DMultisample(texture, samples, internalformat, width, height, depth, fixedsamplelocations); |
| 5253 | } |
| 5254 | |
| 5255 | void glwTextureSubImage1D (GLuint texture, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const void *pixels) |
| 5256 | { |
| 5257 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 5258 | if (!gl) |
| 5259 | return; |
| 5260 | gl->textureSubImage1D(texture, level, xoffset, width, format, type, pixels); |
| 5261 | } |
| 5262 | |
Pyry Haulos | 933ef4d | 2016-11-14 13:01:12 -0800 | [diff] [blame] | 5263 | void glwTextureSubImage1DEXT (GLuint texture, GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const void *pixels) |
| 5264 | { |
| 5265 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 5266 | if (!gl) |
| 5267 | return; |
| 5268 | gl->textureSubImage1DEXT(texture, target, level, xoffset, width, format, type, pixels); |
| 5269 | } |
| 5270 | |
Pyry Haulos | 1abab60 | 2014-11-05 17:41:42 -0800 | [diff] [blame] | 5271 | void glwTextureSubImage2D (GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const void *pixels) |
| 5272 | { |
| 5273 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 5274 | if (!gl) |
| 5275 | return; |
| 5276 | gl->textureSubImage2D(texture, level, xoffset, yoffset, width, height, format, type, pixels); |
| 5277 | } |
| 5278 | |
Pyry Haulos | 933ef4d | 2016-11-14 13:01:12 -0800 | [diff] [blame] | 5279 | void glwTextureSubImage2DEXT (GLuint texture, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const void *pixels) |
| 5280 | { |
| 5281 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 5282 | if (!gl) |
| 5283 | return; |
| 5284 | gl->textureSubImage2DEXT(texture, target, level, xoffset, yoffset, width, height, format, type, pixels); |
| 5285 | } |
| 5286 | |
Pyry Haulos | 1abab60 | 2014-11-05 17:41:42 -0800 | [diff] [blame] | 5287 | void glwTextureSubImage3D (GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const void *pixels) |
| 5288 | { |
| 5289 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 5290 | if (!gl) |
| 5291 | return; |
| 5292 | gl->textureSubImage3D(texture, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels); |
| 5293 | } |
| 5294 | |
Pyry Haulos | 933ef4d | 2016-11-14 13:01:12 -0800 | [diff] [blame] | 5295 | void glwTextureSubImage3DEXT (GLuint texture, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const void *pixels) |
| 5296 | { |
| 5297 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 5298 | if (!gl) |
| 5299 | return; |
| 5300 | gl->textureSubImage3DEXT(texture, target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels); |
| 5301 | } |
| 5302 | |
Jarkko Poyry | 3c82736 | 2014-09-02 11:48:52 +0300 | [diff] [blame] | 5303 | void glwTextureView (GLuint texture, GLenum target, GLuint origtexture, GLenum internalformat, GLuint minlevel, GLuint numlevels, GLuint minlayer, GLuint numlayers) |
| 5304 | { |
| 5305 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 5306 | if (!gl) |
Pyry Haulos | 1abab60 | 2014-11-05 17:41:42 -0800 | [diff] [blame] | 5307 | return; |
Jarkko Poyry | 3c82736 | 2014-09-02 11:48:52 +0300 | [diff] [blame] | 5308 | gl->textureView(texture, target, origtexture, internalformat, minlevel, numlevels, minlayer, numlayers); |
| 5309 | } |
| 5310 | |
Pyry Haulos | 1abab60 | 2014-11-05 17:41:42 -0800 | [diff] [blame] | 5311 | void glwTransformFeedbackBufferBase (GLuint xfb, GLuint index, GLuint buffer) |
Jarkko Poyry | 3c82736 | 2014-09-02 11:48:52 +0300 | [diff] [blame] | 5312 | { |
| 5313 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 5314 | if (!gl) |
Pyry Haulos | 1abab60 | 2014-11-05 17:41:42 -0800 | [diff] [blame] | 5315 | return; |
| 5316 | gl->transformFeedbackBufferBase(xfb, index, buffer); |
Jarkko Poyry | 3c82736 | 2014-09-02 11:48:52 +0300 | [diff] [blame] | 5317 | } |
| 5318 | |
Mika Isojärvi | 314799d | 2015-01-23 15:01:53 -0800 | [diff] [blame] | 5319 | void glwTransformFeedbackBufferRange (GLuint xfb, GLuint index, GLuint buffer, GLintptr offset, GLsizeiptr size) |
Jarkko Poyry | 3c82736 | 2014-09-02 11:48:52 +0300 | [diff] [blame] | 5320 | { |
| 5321 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 5322 | if (!gl) |
Pyry Haulos | 1abab60 | 2014-11-05 17:41:42 -0800 | [diff] [blame] | 5323 | return; |
| 5324 | gl->transformFeedbackBufferRange(xfb, index, buffer, offset, size); |
Jarkko Poyry | 3c82736 | 2014-09-02 11:48:52 +0300 | [diff] [blame] | 5325 | } |
| 5326 | |
Pyry Haulos | 1abab60 | 2014-11-05 17:41:42 -0800 | [diff] [blame] | 5327 | void glwTransformFeedbackVaryings (GLuint program, GLsizei count, const GLchar *const*varyings, GLenum bufferMode) |
Jarkko Poyry | 3c82736 | 2014-09-02 11:48:52 +0300 | [diff] [blame] | 5328 | { |
| 5329 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 5330 | if (!gl) |
Pyry Haulos | 1abab60 | 2014-11-05 17:41:42 -0800 | [diff] [blame] | 5331 | return; |
| 5332 | gl->transformFeedbackVaryings(program, count, varyings, bufferMode); |
Jarkko Poyry | 3c82736 | 2014-09-02 11:48:52 +0300 | [diff] [blame] | 5333 | } |
| 5334 | |
Pyry Haulos | 1abab60 | 2014-11-05 17:41:42 -0800 | [diff] [blame] | 5335 | void glwUniform1d (GLint location, GLdouble x) |
Jarkko Poyry | 3c82736 | 2014-09-02 11:48:52 +0300 | [diff] [blame] | 5336 | { |
| 5337 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 5338 | if (!gl) |
Pyry Haulos | 1abab60 | 2014-11-05 17:41:42 -0800 | [diff] [blame] | 5339 | return; |
| 5340 | gl->uniform1d(location, x); |
| 5341 | } |
| 5342 | |
| 5343 | void glwUniform1dv (GLint location, GLsizei count, const GLdouble *value) |
| 5344 | { |
| 5345 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 5346 | if (!gl) |
| 5347 | return; |
| 5348 | gl->uniform1dv(location, count, value); |
| 5349 | } |
| 5350 | |
| 5351 | void glwUniform1f (GLint location, GLfloat v0) |
| 5352 | { |
| 5353 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 5354 | if (!gl) |
| 5355 | return; |
| 5356 | gl->uniform1f(location, v0); |
| 5357 | } |
| 5358 | |
| 5359 | void glwUniform1fv (GLint location, GLsizei count, const GLfloat *value) |
| 5360 | { |
| 5361 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 5362 | if (!gl) |
| 5363 | return; |
| 5364 | gl->uniform1fv(location, count, value); |
| 5365 | } |
| 5366 | |
| 5367 | void glwUniform1i (GLint location, GLint v0) |
| 5368 | { |
| 5369 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 5370 | if (!gl) |
| 5371 | return; |
| 5372 | gl->uniform1i(location, v0); |
| 5373 | } |
| 5374 | |
| 5375 | void glwUniform1iv (GLint location, GLsizei count, const GLint *value) |
| 5376 | { |
| 5377 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 5378 | if (!gl) |
| 5379 | return; |
| 5380 | gl->uniform1iv(location, count, value); |
| 5381 | } |
| 5382 | |
| 5383 | void glwUniform1ui (GLint location, GLuint v0) |
| 5384 | { |
| 5385 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 5386 | if (!gl) |
| 5387 | return; |
| 5388 | gl->uniform1ui(location, v0); |
| 5389 | } |
| 5390 | |
| 5391 | void glwUniform1uiv (GLint location, GLsizei count, const GLuint *value) |
| 5392 | { |
| 5393 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 5394 | if (!gl) |
| 5395 | return; |
| 5396 | gl->uniform1uiv(location, count, value); |
| 5397 | } |
| 5398 | |
| 5399 | void glwUniform2d (GLint location, GLdouble x, GLdouble y) |
| 5400 | { |
| 5401 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 5402 | if (!gl) |
| 5403 | return; |
| 5404 | gl->uniform2d(location, x, y); |
| 5405 | } |
| 5406 | |
| 5407 | void glwUniform2dv (GLint location, GLsizei count, const GLdouble *value) |
| 5408 | { |
| 5409 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 5410 | if (!gl) |
| 5411 | return; |
| 5412 | gl->uniform2dv(location, count, value); |
| 5413 | } |
| 5414 | |
| 5415 | void glwUniform2f (GLint location, GLfloat v0, GLfloat v1) |
| 5416 | { |
| 5417 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 5418 | if (!gl) |
| 5419 | return; |
| 5420 | gl->uniform2f(location, v0, v1); |
| 5421 | } |
| 5422 | |
| 5423 | void glwUniform2fv (GLint location, GLsizei count, const GLfloat *value) |
| 5424 | { |
| 5425 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 5426 | if (!gl) |
| 5427 | return; |
| 5428 | gl->uniform2fv(location, count, value); |
| 5429 | } |
| 5430 | |
| 5431 | void glwUniform2i (GLint location, GLint v0, GLint v1) |
| 5432 | { |
| 5433 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 5434 | if (!gl) |
| 5435 | return; |
| 5436 | gl->uniform2i(location, v0, v1); |
| 5437 | } |
| 5438 | |
| 5439 | void glwUniform2iv (GLint location, GLsizei count, const GLint *value) |
| 5440 | { |
| 5441 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 5442 | if (!gl) |
| 5443 | return; |
| 5444 | gl->uniform2iv(location, count, value); |
| 5445 | } |
| 5446 | |
| 5447 | void glwUniform2ui (GLint location, GLuint v0, GLuint v1) |
| 5448 | { |
| 5449 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 5450 | if (!gl) |
| 5451 | return; |
| 5452 | gl->uniform2ui(location, v0, v1); |
| 5453 | } |
| 5454 | |
| 5455 | void glwUniform2uiv (GLint location, GLsizei count, const GLuint *value) |
| 5456 | { |
| 5457 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 5458 | if (!gl) |
| 5459 | return; |
| 5460 | gl->uniform2uiv(location, count, value); |
| 5461 | } |
| 5462 | |
| 5463 | void glwUniform3d (GLint location, GLdouble x, GLdouble y, GLdouble z) |
| 5464 | { |
| 5465 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 5466 | if (!gl) |
| 5467 | return; |
| 5468 | gl->uniform3d(location, x, y, z); |
| 5469 | } |
| 5470 | |
| 5471 | void glwUniform3dv (GLint location, GLsizei count, const GLdouble *value) |
| 5472 | { |
| 5473 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 5474 | if (!gl) |
| 5475 | return; |
| 5476 | gl->uniform3dv(location, count, value); |
| 5477 | } |
| 5478 | |
| 5479 | void glwUniform3f (GLint location, GLfloat v0, GLfloat v1, GLfloat v2) |
| 5480 | { |
| 5481 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 5482 | if (!gl) |
| 5483 | return; |
| 5484 | gl->uniform3f(location, v0, v1, v2); |
| 5485 | } |
| 5486 | |
| 5487 | void glwUniform3fv (GLint location, GLsizei count, const GLfloat *value) |
| 5488 | { |
| 5489 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 5490 | if (!gl) |
| 5491 | return; |
| 5492 | gl->uniform3fv(location, count, value); |
| 5493 | } |
| 5494 | |
| 5495 | void glwUniform3i (GLint location, GLint v0, GLint v1, GLint v2) |
| 5496 | { |
| 5497 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 5498 | if (!gl) |
| 5499 | return; |
| 5500 | gl->uniform3i(location, v0, v1, v2); |
| 5501 | } |
| 5502 | |
| 5503 | void glwUniform3iv (GLint location, GLsizei count, const GLint *value) |
| 5504 | { |
| 5505 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 5506 | if (!gl) |
| 5507 | return; |
| 5508 | gl->uniform3iv(location, count, value); |
| 5509 | } |
| 5510 | |
| 5511 | void glwUniform3ui (GLint location, GLuint v0, GLuint v1, GLuint v2) |
| 5512 | { |
| 5513 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 5514 | if (!gl) |
| 5515 | return; |
| 5516 | gl->uniform3ui(location, v0, v1, v2); |
| 5517 | } |
| 5518 | |
| 5519 | void glwUniform3uiv (GLint location, GLsizei count, const GLuint *value) |
| 5520 | { |
| 5521 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 5522 | if (!gl) |
| 5523 | return; |
| 5524 | gl->uniform3uiv(location, count, value); |
| 5525 | } |
| 5526 | |
| 5527 | void glwUniform4d (GLint location, GLdouble x, GLdouble y, GLdouble z, GLdouble w) |
| 5528 | { |
| 5529 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 5530 | if (!gl) |
| 5531 | return; |
| 5532 | gl->uniform4d(location, x, y, z, w); |
| 5533 | } |
| 5534 | |
| 5535 | void glwUniform4dv (GLint location, GLsizei count, const GLdouble *value) |
| 5536 | { |
| 5537 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 5538 | if (!gl) |
| 5539 | return; |
| 5540 | gl->uniform4dv(location, count, value); |
| 5541 | } |
| 5542 | |
| 5543 | void glwUniform4f (GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3) |
| 5544 | { |
| 5545 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 5546 | if (!gl) |
| 5547 | return; |
| 5548 | gl->uniform4f(location, v0, v1, v2, v3); |
| 5549 | } |
| 5550 | |
| 5551 | void glwUniform4fv (GLint location, GLsizei count, const GLfloat *value) |
| 5552 | { |
| 5553 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 5554 | if (!gl) |
| 5555 | return; |
| 5556 | gl->uniform4fv(location, count, value); |
| 5557 | } |
| 5558 | |
| 5559 | void glwUniform4i (GLint location, GLint v0, GLint v1, GLint v2, GLint v3) |
| 5560 | { |
| 5561 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 5562 | if (!gl) |
| 5563 | return; |
| 5564 | gl->uniform4i(location, v0, v1, v2, v3); |
| 5565 | } |
| 5566 | |
| 5567 | void glwUniform4iv (GLint location, GLsizei count, const GLint *value) |
| 5568 | { |
| 5569 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 5570 | if (!gl) |
| 5571 | return; |
| 5572 | gl->uniform4iv(location, count, value); |
| 5573 | } |
| 5574 | |
| 5575 | void glwUniform4ui (GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3) |
| 5576 | { |
| 5577 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 5578 | if (!gl) |
| 5579 | return; |
| 5580 | gl->uniform4ui(location, v0, v1, v2, v3); |
| 5581 | } |
| 5582 | |
| 5583 | void glwUniform4uiv (GLint location, GLsizei count, const GLuint *value) |
| 5584 | { |
| 5585 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 5586 | if (!gl) |
| 5587 | return; |
| 5588 | gl->uniform4uiv(location, count, value); |
| 5589 | } |
| 5590 | |
| 5591 | void glwUniformBlockBinding (GLuint program, GLuint uniformBlockIndex, GLuint uniformBlockBinding) |
| 5592 | { |
| 5593 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 5594 | if (!gl) |
| 5595 | return; |
| 5596 | gl->uniformBlockBinding(program, uniformBlockIndex, uniformBlockBinding); |
| 5597 | } |
| 5598 | |
| 5599 | void glwUniformMatrix2dv (GLint location, GLsizei count, GLboolean transpose, const GLdouble *value) |
| 5600 | { |
| 5601 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 5602 | if (!gl) |
| 5603 | return; |
| 5604 | gl->uniformMatrix2dv(location, count, transpose, value); |
| 5605 | } |
| 5606 | |
| 5607 | void glwUniformMatrix2fv (GLint location, GLsizei count, GLboolean transpose, const GLfloat *value) |
| 5608 | { |
| 5609 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 5610 | if (!gl) |
| 5611 | return; |
| 5612 | gl->uniformMatrix2fv(location, count, transpose, value); |
| 5613 | } |
| 5614 | |
| 5615 | void glwUniformMatrix2x3dv (GLint location, GLsizei count, GLboolean transpose, const GLdouble *value) |
| 5616 | { |
| 5617 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 5618 | if (!gl) |
| 5619 | return; |
| 5620 | gl->uniformMatrix2x3dv(location, count, transpose, value); |
| 5621 | } |
| 5622 | |
| 5623 | void glwUniformMatrix2x3fv (GLint location, GLsizei count, GLboolean transpose, const GLfloat *value) |
| 5624 | { |
| 5625 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 5626 | if (!gl) |
| 5627 | return; |
| 5628 | gl->uniformMatrix2x3fv(location, count, transpose, value); |
| 5629 | } |
| 5630 | |
| 5631 | void glwUniformMatrix2x4dv (GLint location, GLsizei count, GLboolean transpose, const GLdouble *value) |
| 5632 | { |
| 5633 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 5634 | if (!gl) |
| 5635 | return; |
| 5636 | gl->uniformMatrix2x4dv(location, count, transpose, value); |
| 5637 | } |
| 5638 | |
| 5639 | void glwUniformMatrix2x4fv (GLint location, GLsizei count, GLboolean transpose, const GLfloat *value) |
| 5640 | { |
| 5641 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 5642 | if (!gl) |
| 5643 | return; |
| 5644 | gl->uniformMatrix2x4fv(location, count, transpose, value); |
| 5645 | } |
| 5646 | |
| 5647 | void glwUniformMatrix3dv (GLint location, GLsizei count, GLboolean transpose, const GLdouble *value) |
| 5648 | { |
| 5649 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 5650 | if (!gl) |
| 5651 | return; |
| 5652 | gl->uniformMatrix3dv(location, count, transpose, value); |
| 5653 | } |
| 5654 | |
| 5655 | void glwUniformMatrix3fv (GLint location, GLsizei count, GLboolean transpose, const GLfloat *value) |
| 5656 | { |
| 5657 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 5658 | if (!gl) |
| 5659 | return; |
| 5660 | gl->uniformMatrix3fv(location, count, transpose, value); |
| 5661 | } |
| 5662 | |
| 5663 | void glwUniformMatrix3x2dv (GLint location, GLsizei count, GLboolean transpose, const GLdouble *value) |
| 5664 | { |
| 5665 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 5666 | if (!gl) |
| 5667 | return; |
| 5668 | gl->uniformMatrix3x2dv(location, count, transpose, value); |
| 5669 | } |
| 5670 | |
| 5671 | void glwUniformMatrix3x2fv (GLint location, GLsizei count, GLboolean transpose, const GLfloat *value) |
| 5672 | { |
| 5673 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 5674 | if (!gl) |
| 5675 | return; |
| 5676 | gl->uniformMatrix3x2fv(location, count, transpose, value); |
| 5677 | } |
| 5678 | |
| 5679 | void glwUniformMatrix3x4dv (GLint location, GLsizei count, GLboolean transpose, const GLdouble *value) |
| 5680 | { |
| 5681 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 5682 | if (!gl) |
| 5683 | return; |
| 5684 | gl->uniformMatrix3x4dv(location, count, transpose, value); |
| 5685 | } |
| 5686 | |
| 5687 | void glwUniformMatrix3x4fv (GLint location, GLsizei count, GLboolean transpose, const GLfloat *value) |
| 5688 | { |
| 5689 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 5690 | if (!gl) |
| 5691 | return; |
| 5692 | gl->uniformMatrix3x4fv(location, count, transpose, value); |
| 5693 | } |
| 5694 | |
| 5695 | void glwUniformMatrix4dv (GLint location, GLsizei count, GLboolean transpose, const GLdouble *value) |
| 5696 | { |
| 5697 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 5698 | if (!gl) |
| 5699 | return; |
| 5700 | gl->uniformMatrix4dv(location, count, transpose, value); |
| 5701 | } |
| 5702 | |
| 5703 | void glwUniformMatrix4fv (GLint location, GLsizei count, GLboolean transpose, const GLfloat *value) |
| 5704 | { |
| 5705 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 5706 | if (!gl) |
| 5707 | return; |
| 5708 | gl->uniformMatrix4fv(location, count, transpose, value); |
| 5709 | } |
| 5710 | |
| 5711 | void glwUniformMatrix4x2dv (GLint location, GLsizei count, GLboolean transpose, const GLdouble *value) |
| 5712 | { |
| 5713 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 5714 | if (!gl) |
| 5715 | return; |
| 5716 | gl->uniformMatrix4x2dv(location, count, transpose, value); |
| 5717 | } |
| 5718 | |
| 5719 | void glwUniformMatrix4x2fv (GLint location, GLsizei count, GLboolean transpose, const GLfloat *value) |
| 5720 | { |
| 5721 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 5722 | if (!gl) |
| 5723 | return; |
| 5724 | gl->uniformMatrix4x2fv(location, count, transpose, value); |
| 5725 | } |
| 5726 | |
| 5727 | void glwUniformMatrix4x3dv (GLint location, GLsizei count, GLboolean transpose, const GLdouble *value) |
| 5728 | { |
| 5729 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 5730 | if (!gl) |
| 5731 | return; |
| 5732 | gl->uniformMatrix4x3dv(location, count, transpose, value); |
| 5733 | } |
| 5734 | |
| 5735 | void glwUniformMatrix4x3fv (GLint location, GLsizei count, GLboolean transpose, const GLfloat *value) |
| 5736 | { |
| 5737 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 5738 | if (!gl) |
| 5739 | return; |
| 5740 | gl->uniformMatrix4x3fv(location, count, transpose, value); |
| 5741 | } |
| 5742 | |
| 5743 | void glwUniformSubroutinesuiv (GLenum shadertype, GLsizei count, const GLuint *indices) |
| 5744 | { |
| 5745 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 5746 | if (!gl) |
| 5747 | return; |
| 5748 | gl->uniformSubroutinesuiv(shadertype, count, indices); |
| 5749 | } |
| 5750 | |
| 5751 | GLboolean glwUnmapBuffer (GLenum target) |
| 5752 | { |
| 5753 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 5754 | if (!gl) |
| 5755 | return (GLboolean)0; |
| 5756 | return gl->unmapBuffer(target); |
| 5757 | } |
| 5758 | |
| 5759 | GLboolean glwUnmapNamedBuffer (GLuint buffer) |
| 5760 | { |
| 5761 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 5762 | if (!gl) |
| 5763 | return (GLboolean)0; |
| 5764 | return gl->unmapNamedBuffer(buffer); |
| 5765 | } |
| 5766 | |
| 5767 | void glwUseProgram (GLuint program) |
| 5768 | { |
| 5769 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 5770 | if (!gl) |
| 5771 | return; |
| 5772 | gl->useProgram(program); |
| 5773 | } |
| 5774 | |
| 5775 | void glwUseProgramStages (GLuint pipeline, GLbitfield stages, GLuint program) |
| 5776 | { |
| 5777 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 5778 | if (!gl) |
| 5779 | return; |
| 5780 | gl->useProgramStages(pipeline, stages, program); |
| 5781 | } |
| 5782 | |
| 5783 | void glwValidateProgram (GLuint program) |
| 5784 | { |
| 5785 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 5786 | if (!gl) |
| 5787 | return; |
| 5788 | gl->validateProgram(program); |
| 5789 | } |
| 5790 | |
| 5791 | void glwValidateProgramPipeline (GLuint pipeline) |
| 5792 | { |
| 5793 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 5794 | if (!gl) |
| 5795 | return; |
| 5796 | gl->validateProgramPipeline(pipeline); |
| 5797 | } |
| 5798 | |
| 5799 | void glwVertexArrayAttribBinding (GLuint vaobj, GLuint attribindex, GLuint bindingindex) |
| 5800 | { |
| 5801 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 5802 | if (!gl) |
| 5803 | return; |
| 5804 | gl->vertexArrayAttribBinding(vaobj, attribindex, bindingindex); |
| 5805 | } |
| 5806 | |
| 5807 | void glwVertexArrayAttribFormat (GLuint vaobj, GLuint attribindex, GLint size, GLenum type, GLboolean normalized, GLuint relativeoffset) |
| 5808 | { |
| 5809 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 5810 | if (!gl) |
| 5811 | return; |
| 5812 | gl->vertexArrayAttribFormat(vaobj, attribindex, size, type, normalized, relativeoffset); |
| 5813 | } |
| 5814 | |
| 5815 | void glwVertexArrayAttribIFormat (GLuint vaobj, GLuint attribindex, GLint size, GLenum type, GLuint relativeoffset) |
| 5816 | { |
| 5817 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 5818 | if (!gl) |
| 5819 | return; |
| 5820 | gl->vertexArrayAttribIFormat(vaobj, attribindex, size, type, relativeoffset); |
| 5821 | } |
| 5822 | |
| 5823 | void glwVertexArrayAttribLFormat (GLuint vaobj, GLuint attribindex, GLint size, GLenum type, GLuint relativeoffset) |
| 5824 | { |
| 5825 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 5826 | if (!gl) |
| 5827 | return; |
| 5828 | gl->vertexArrayAttribLFormat(vaobj, attribindex, size, type, relativeoffset); |
| 5829 | } |
| 5830 | |
Pyry Haulos | 933ef4d | 2016-11-14 13:01:12 -0800 | [diff] [blame] | 5831 | void glwVertexArrayBindVertexBufferEXT (GLuint vaobj, GLuint bindingindex, GLuint buffer, GLintptr offset, GLsizei stride) |
| 5832 | { |
| 5833 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 5834 | if (!gl) |
| 5835 | return; |
| 5836 | gl->vertexArrayBindVertexBufferEXT(vaobj, bindingindex, buffer, offset, stride); |
| 5837 | } |
| 5838 | |
Pyry Haulos | 1abab60 | 2014-11-05 17:41:42 -0800 | [diff] [blame] | 5839 | void glwVertexArrayBindingDivisor (GLuint vaobj, GLuint bindingindex, GLuint divisor) |
| 5840 | { |
| 5841 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 5842 | if (!gl) |
| 5843 | return; |
| 5844 | gl->vertexArrayBindingDivisor(vaobj, bindingindex, divisor); |
| 5845 | } |
| 5846 | |
Pyry Haulos | 933ef4d | 2016-11-14 13:01:12 -0800 | [diff] [blame] | 5847 | void glwVertexArrayColorOffsetEXT (GLuint vaobj, GLuint buffer, GLint size, GLenum type, GLsizei stride, GLintptr offset) |
| 5848 | { |
| 5849 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 5850 | if (!gl) |
| 5851 | return; |
| 5852 | gl->vertexArrayColorOffsetEXT(vaobj, buffer, size, type, stride, offset); |
| 5853 | } |
| 5854 | |
| 5855 | void glwVertexArrayEdgeFlagOffsetEXT (GLuint vaobj, GLuint buffer, GLsizei stride, GLintptr offset) |
| 5856 | { |
| 5857 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 5858 | if (!gl) |
| 5859 | return; |
| 5860 | gl->vertexArrayEdgeFlagOffsetEXT(vaobj, buffer, stride, offset); |
| 5861 | } |
| 5862 | |
Pyry Haulos | 1abab60 | 2014-11-05 17:41:42 -0800 | [diff] [blame] | 5863 | void glwVertexArrayElementBuffer (GLuint vaobj, GLuint buffer) |
| 5864 | { |
| 5865 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 5866 | if (!gl) |
| 5867 | return; |
| 5868 | gl->vertexArrayElementBuffer(vaobj, buffer); |
| 5869 | } |
| 5870 | |
Pyry Haulos | 933ef4d | 2016-11-14 13:01:12 -0800 | [diff] [blame] | 5871 | void glwVertexArrayFogCoordOffsetEXT (GLuint vaobj, GLuint buffer, GLenum type, GLsizei stride, GLintptr offset) |
| 5872 | { |
| 5873 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 5874 | if (!gl) |
| 5875 | return; |
| 5876 | gl->vertexArrayFogCoordOffsetEXT(vaobj, buffer, type, stride, offset); |
| 5877 | } |
| 5878 | |
| 5879 | void glwVertexArrayIndexOffsetEXT (GLuint vaobj, GLuint buffer, GLenum type, GLsizei stride, GLintptr offset) |
| 5880 | { |
| 5881 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 5882 | if (!gl) |
| 5883 | return; |
| 5884 | gl->vertexArrayIndexOffsetEXT(vaobj, buffer, type, stride, offset); |
| 5885 | } |
| 5886 | |
| 5887 | void glwVertexArrayMultiTexCoordOffsetEXT (GLuint vaobj, GLuint buffer, GLenum texunit, GLint size, GLenum type, GLsizei stride, GLintptr offset) |
| 5888 | { |
| 5889 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 5890 | if (!gl) |
| 5891 | return; |
| 5892 | gl->vertexArrayMultiTexCoordOffsetEXT(vaobj, buffer, texunit, size, type, stride, offset); |
| 5893 | } |
| 5894 | |
| 5895 | void glwVertexArrayNormalOffsetEXT (GLuint vaobj, GLuint buffer, GLenum type, GLsizei stride, GLintptr offset) |
| 5896 | { |
| 5897 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 5898 | if (!gl) |
| 5899 | return; |
| 5900 | gl->vertexArrayNormalOffsetEXT(vaobj, buffer, type, stride, offset); |
| 5901 | } |
| 5902 | |
| 5903 | void glwVertexArraySecondaryColorOffsetEXT (GLuint vaobj, GLuint buffer, GLint size, GLenum type, GLsizei stride, GLintptr offset) |
| 5904 | { |
| 5905 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 5906 | if (!gl) |
| 5907 | return; |
| 5908 | gl->vertexArraySecondaryColorOffsetEXT(vaobj, buffer, size, type, stride, offset); |
| 5909 | } |
| 5910 | |
| 5911 | void glwVertexArrayTexCoordOffsetEXT (GLuint vaobj, GLuint buffer, GLint size, GLenum type, GLsizei stride, GLintptr offset) |
| 5912 | { |
| 5913 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 5914 | if (!gl) |
| 5915 | return; |
| 5916 | gl->vertexArrayTexCoordOffsetEXT(vaobj, buffer, size, type, stride, offset); |
| 5917 | } |
| 5918 | |
| 5919 | void glwVertexArrayVertexAttribBindingEXT (GLuint vaobj, GLuint attribindex, GLuint bindingindex) |
| 5920 | { |
| 5921 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 5922 | if (!gl) |
| 5923 | return; |
| 5924 | gl->vertexArrayVertexAttribBindingEXT(vaobj, attribindex, bindingindex); |
| 5925 | } |
| 5926 | |
| 5927 | void glwVertexArrayVertexAttribDivisorEXT (GLuint vaobj, GLuint index, GLuint divisor) |
| 5928 | { |
| 5929 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 5930 | if (!gl) |
| 5931 | return; |
| 5932 | gl->vertexArrayVertexAttribDivisorEXT(vaobj, index, divisor); |
| 5933 | } |
| 5934 | |
| 5935 | void glwVertexArrayVertexAttribFormatEXT (GLuint vaobj, GLuint attribindex, GLint size, GLenum type, GLboolean normalized, GLuint relativeoffset) |
| 5936 | { |
| 5937 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 5938 | if (!gl) |
| 5939 | return; |
| 5940 | gl->vertexArrayVertexAttribFormatEXT(vaobj, attribindex, size, type, normalized, relativeoffset); |
| 5941 | } |
| 5942 | |
| 5943 | void glwVertexArrayVertexAttribIFormatEXT (GLuint vaobj, GLuint attribindex, GLint size, GLenum type, GLuint relativeoffset) |
| 5944 | { |
| 5945 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 5946 | if (!gl) |
| 5947 | return; |
| 5948 | gl->vertexArrayVertexAttribIFormatEXT(vaobj, attribindex, size, type, relativeoffset); |
| 5949 | } |
| 5950 | |
| 5951 | void glwVertexArrayVertexAttribIOffsetEXT (GLuint vaobj, GLuint buffer, GLuint index, GLint size, GLenum type, GLsizei stride, GLintptr offset) |
| 5952 | { |
| 5953 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 5954 | if (!gl) |
| 5955 | return; |
| 5956 | gl->vertexArrayVertexAttribIOffsetEXT(vaobj, buffer, index, size, type, stride, offset); |
| 5957 | } |
| 5958 | |
| 5959 | void glwVertexArrayVertexAttribLFormatEXT (GLuint vaobj, GLuint attribindex, GLint size, GLenum type, GLuint relativeoffset) |
| 5960 | { |
| 5961 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 5962 | if (!gl) |
| 5963 | return; |
| 5964 | gl->vertexArrayVertexAttribLFormatEXT(vaobj, attribindex, size, type, relativeoffset); |
| 5965 | } |
| 5966 | |
| 5967 | void glwVertexArrayVertexAttribLOffsetEXT (GLuint vaobj, GLuint buffer, GLuint index, GLint size, GLenum type, GLsizei stride, GLintptr offset) |
| 5968 | { |
| 5969 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 5970 | if (!gl) |
| 5971 | return; |
| 5972 | gl->vertexArrayVertexAttribLOffsetEXT(vaobj, buffer, index, size, type, stride, offset); |
| 5973 | } |
| 5974 | |
| 5975 | void glwVertexArrayVertexAttribOffsetEXT (GLuint vaobj, GLuint buffer, GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, GLintptr offset) |
| 5976 | { |
| 5977 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 5978 | if (!gl) |
| 5979 | return; |
| 5980 | gl->vertexArrayVertexAttribOffsetEXT(vaobj, buffer, index, size, type, normalized, stride, offset); |
| 5981 | } |
| 5982 | |
| 5983 | void glwVertexArrayVertexBindingDivisorEXT (GLuint vaobj, GLuint bindingindex, GLuint divisor) |
| 5984 | { |
| 5985 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 5986 | if (!gl) |
| 5987 | return; |
| 5988 | gl->vertexArrayVertexBindingDivisorEXT(vaobj, bindingindex, divisor); |
| 5989 | } |
| 5990 | |
Pyry Haulos | 1abab60 | 2014-11-05 17:41:42 -0800 | [diff] [blame] | 5991 | void glwVertexArrayVertexBuffer (GLuint vaobj, GLuint bindingindex, GLuint buffer, GLintptr offset, GLsizei stride) |
| 5992 | { |
| 5993 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 5994 | if (!gl) |
| 5995 | return; |
| 5996 | gl->vertexArrayVertexBuffer(vaobj, bindingindex, buffer, offset, stride); |
| 5997 | } |
| 5998 | |
| 5999 | void glwVertexArrayVertexBuffers (GLuint vaobj, GLuint first, GLsizei count, const GLuint *buffers, const GLintptr *offsets, const GLsizei *strides) |
| 6000 | { |
| 6001 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 6002 | if (!gl) |
| 6003 | return; |
| 6004 | gl->vertexArrayVertexBuffers(vaobj, first, count, buffers, offsets, strides); |
| 6005 | } |
| 6006 | |
Pyry Haulos | 933ef4d | 2016-11-14 13:01:12 -0800 | [diff] [blame] | 6007 | void glwVertexArrayVertexOffsetEXT (GLuint vaobj, GLuint buffer, GLint size, GLenum type, GLsizei stride, GLintptr offset) |
| 6008 | { |
| 6009 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 6010 | if (!gl) |
| 6011 | return; |
| 6012 | gl->vertexArrayVertexOffsetEXT(vaobj, buffer, size, type, stride, offset); |
| 6013 | } |
| 6014 | |
Pyry Haulos | 1abab60 | 2014-11-05 17:41:42 -0800 | [diff] [blame] | 6015 | void glwVertexAttrib1d (GLuint index, GLdouble x) |
| 6016 | { |
| 6017 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 6018 | if (!gl) |
| 6019 | return; |
| 6020 | gl->vertexAttrib1d(index, x); |
| 6021 | } |
| 6022 | |
| 6023 | void glwVertexAttrib1dv (GLuint index, const GLdouble *v) |
| 6024 | { |
| 6025 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 6026 | if (!gl) |
| 6027 | return; |
| 6028 | gl->vertexAttrib1dv(index, v); |
| 6029 | } |
| 6030 | |
| 6031 | void glwVertexAttrib1f (GLuint index, GLfloat x) |
| 6032 | { |
| 6033 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 6034 | if (!gl) |
| 6035 | return; |
| 6036 | gl->vertexAttrib1f(index, x); |
| 6037 | } |
| 6038 | |
| 6039 | void glwVertexAttrib1fv (GLuint index, const GLfloat *v) |
| 6040 | { |
| 6041 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 6042 | if (!gl) |
| 6043 | return; |
| 6044 | gl->vertexAttrib1fv(index, v); |
| 6045 | } |
| 6046 | |
| 6047 | void glwVertexAttrib1s (GLuint index, GLshort x) |
| 6048 | { |
| 6049 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 6050 | if (!gl) |
| 6051 | return; |
| 6052 | gl->vertexAttrib1s(index, x); |
| 6053 | } |
| 6054 | |
| 6055 | void glwVertexAttrib1sv (GLuint index, const GLshort *v) |
| 6056 | { |
| 6057 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 6058 | if (!gl) |
| 6059 | return; |
| 6060 | gl->vertexAttrib1sv(index, v); |
| 6061 | } |
| 6062 | |
| 6063 | void glwVertexAttrib2d (GLuint index, GLdouble x, GLdouble y) |
| 6064 | { |
| 6065 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 6066 | if (!gl) |
| 6067 | return; |
| 6068 | gl->vertexAttrib2d(index, x, y); |
| 6069 | } |
| 6070 | |
| 6071 | void glwVertexAttrib2dv (GLuint index, const GLdouble *v) |
| 6072 | { |
| 6073 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 6074 | if (!gl) |
| 6075 | return; |
| 6076 | gl->vertexAttrib2dv(index, v); |
| 6077 | } |
| 6078 | |
| 6079 | void glwVertexAttrib2f (GLuint index, GLfloat x, GLfloat y) |
| 6080 | { |
| 6081 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 6082 | if (!gl) |
| 6083 | return; |
| 6084 | gl->vertexAttrib2f(index, x, y); |
| 6085 | } |
| 6086 | |
| 6087 | void glwVertexAttrib2fv (GLuint index, const GLfloat *v) |
| 6088 | { |
| 6089 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 6090 | if (!gl) |
| 6091 | return; |
| 6092 | gl->vertexAttrib2fv(index, v); |
| 6093 | } |
| 6094 | |
| 6095 | void glwVertexAttrib2s (GLuint index, GLshort x, GLshort y) |
| 6096 | { |
| 6097 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 6098 | if (!gl) |
| 6099 | return; |
| 6100 | gl->vertexAttrib2s(index, x, y); |
| 6101 | } |
| 6102 | |
| 6103 | void glwVertexAttrib2sv (GLuint index, const GLshort *v) |
| 6104 | { |
| 6105 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 6106 | if (!gl) |
| 6107 | return; |
| 6108 | gl->vertexAttrib2sv(index, v); |
| 6109 | } |
| 6110 | |
| 6111 | void glwVertexAttrib3d (GLuint index, GLdouble x, GLdouble y, GLdouble z) |
| 6112 | { |
| 6113 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 6114 | if (!gl) |
| 6115 | return; |
| 6116 | gl->vertexAttrib3d(index, x, y, z); |
| 6117 | } |
| 6118 | |
| 6119 | void glwVertexAttrib3dv (GLuint index, const GLdouble *v) |
| 6120 | { |
| 6121 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 6122 | if (!gl) |
| 6123 | return; |
| 6124 | gl->vertexAttrib3dv(index, v); |
| 6125 | } |
| 6126 | |
| 6127 | void glwVertexAttrib3f (GLuint index, GLfloat x, GLfloat y, GLfloat z) |
| 6128 | { |
| 6129 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 6130 | if (!gl) |
| 6131 | return; |
| 6132 | gl->vertexAttrib3f(index, x, y, z); |
| 6133 | } |
| 6134 | |
| 6135 | void glwVertexAttrib3fv (GLuint index, const GLfloat *v) |
| 6136 | { |
| 6137 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 6138 | if (!gl) |
| 6139 | return; |
| 6140 | gl->vertexAttrib3fv(index, v); |
| 6141 | } |
| 6142 | |
| 6143 | void glwVertexAttrib3s (GLuint index, GLshort x, GLshort y, GLshort z) |
| 6144 | { |
| 6145 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 6146 | if (!gl) |
| 6147 | return; |
| 6148 | gl->vertexAttrib3s(index, x, y, z); |
| 6149 | } |
| 6150 | |
| 6151 | void glwVertexAttrib3sv (GLuint index, const GLshort *v) |
| 6152 | { |
| 6153 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 6154 | if (!gl) |
| 6155 | return; |
| 6156 | gl->vertexAttrib3sv(index, v); |
| 6157 | } |
| 6158 | |
| 6159 | void glwVertexAttrib4Nbv (GLuint index, const GLbyte *v) |
| 6160 | { |
| 6161 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 6162 | if (!gl) |
| 6163 | return; |
| 6164 | gl->vertexAttrib4Nbv(index, v); |
| 6165 | } |
| 6166 | |
| 6167 | void glwVertexAttrib4Niv (GLuint index, const GLint *v) |
| 6168 | { |
| 6169 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 6170 | if (!gl) |
| 6171 | return; |
| 6172 | gl->vertexAttrib4Niv(index, v); |
| 6173 | } |
| 6174 | |
| 6175 | void glwVertexAttrib4Nsv (GLuint index, const GLshort *v) |
| 6176 | { |
| 6177 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 6178 | if (!gl) |
| 6179 | return; |
| 6180 | gl->vertexAttrib4Nsv(index, v); |
| 6181 | } |
| 6182 | |
| 6183 | void glwVertexAttrib4Nub (GLuint index, GLubyte x, GLubyte y, GLubyte z, GLubyte w) |
| 6184 | { |
| 6185 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 6186 | if (!gl) |
| 6187 | return; |
| 6188 | gl->vertexAttrib4Nub(index, x, y, z, w); |
| 6189 | } |
| 6190 | |
| 6191 | void glwVertexAttrib4Nubv (GLuint index, const GLubyte *v) |
| 6192 | { |
| 6193 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 6194 | if (!gl) |
| 6195 | return; |
| 6196 | gl->vertexAttrib4Nubv(index, v); |
| 6197 | } |
| 6198 | |
| 6199 | void glwVertexAttrib4Nuiv (GLuint index, const GLuint *v) |
| 6200 | { |
| 6201 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 6202 | if (!gl) |
| 6203 | return; |
| 6204 | gl->vertexAttrib4Nuiv(index, v); |
| 6205 | } |
| 6206 | |
| 6207 | void glwVertexAttrib4Nusv (GLuint index, const GLushort *v) |
| 6208 | { |
| 6209 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 6210 | if (!gl) |
| 6211 | return; |
| 6212 | gl->vertexAttrib4Nusv(index, v); |
| 6213 | } |
| 6214 | |
| 6215 | void glwVertexAttrib4bv (GLuint index, const GLbyte *v) |
| 6216 | { |
| 6217 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 6218 | if (!gl) |
| 6219 | return; |
| 6220 | gl->vertexAttrib4bv(index, v); |
| 6221 | } |
| 6222 | |
| 6223 | void glwVertexAttrib4d (GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w) |
| 6224 | { |
| 6225 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 6226 | if (!gl) |
| 6227 | return; |
| 6228 | gl->vertexAttrib4d(index, x, y, z, w); |
| 6229 | } |
| 6230 | |
| 6231 | void glwVertexAttrib4dv (GLuint index, const GLdouble *v) |
| 6232 | { |
| 6233 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 6234 | if (!gl) |
| 6235 | return; |
| 6236 | gl->vertexAttrib4dv(index, v); |
| 6237 | } |
| 6238 | |
| 6239 | void glwVertexAttrib4f (GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w) |
| 6240 | { |
| 6241 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 6242 | if (!gl) |
| 6243 | return; |
| 6244 | gl->vertexAttrib4f(index, x, y, z, w); |
| 6245 | } |
| 6246 | |
| 6247 | void glwVertexAttrib4fv (GLuint index, const GLfloat *v) |
| 6248 | { |
| 6249 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 6250 | if (!gl) |
| 6251 | return; |
| 6252 | gl->vertexAttrib4fv(index, v); |
| 6253 | } |
| 6254 | |
| 6255 | void glwVertexAttrib4iv (GLuint index, const GLint *v) |
| 6256 | { |
| 6257 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 6258 | if (!gl) |
| 6259 | return; |
| 6260 | gl->vertexAttrib4iv(index, v); |
| 6261 | } |
| 6262 | |
| 6263 | void glwVertexAttrib4s (GLuint index, GLshort x, GLshort y, GLshort z, GLshort w) |
| 6264 | { |
| 6265 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 6266 | if (!gl) |
| 6267 | return; |
| 6268 | gl->vertexAttrib4s(index, x, y, z, w); |
| 6269 | } |
| 6270 | |
| 6271 | void glwVertexAttrib4sv (GLuint index, const GLshort *v) |
| 6272 | { |
| 6273 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 6274 | if (!gl) |
| 6275 | return; |
| 6276 | gl->vertexAttrib4sv(index, v); |
| 6277 | } |
| 6278 | |
| 6279 | void glwVertexAttrib4ubv (GLuint index, const GLubyte *v) |
| 6280 | { |
| 6281 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 6282 | if (!gl) |
| 6283 | return; |
| 6284 | gl->vertexAttrib4ubv(index, v); |
| 6285 | } |
| 6286 | |
| 6287 | void glwVertexAttrib4uiv (GLuint index, const GLuint *v) |
| 6288 | { |
| 6289 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 6290 | if (!gl) |
| 6291 | return; |
| 6292 | gl->vertexAttrib4uiv(index, v); |
| 6293 | } |
| 6294 | |
| 6295 | void glwVertexAttrib4usv (GLuint index, const GLushort *v) |
| 6296 | { |
| 6297 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 6298 | if (!gl) |
| 6299 | return; |
| 6300 | gl->vertexAttrib4usv(index, v); |
Jarkko Poyry | 3c82736 | 2014-09-02 11:48:52 +0300 | [diff] [blame] | 6301 | } |
| 6302 | |
| 6303 | void glwVertexAttribBinding (GLuint attribindex, GLuint bindingindex) |
| 6304 | { |
| 6305 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 6306 | if (!gl) |
Pyry Haulos | 1abab60 | 2014-11-05 17:41:42 -0800 | [diff] [blame] | 6307 | return; |
Jarkko Poyry | 3c82736 | 2014-09-02 11:48:52 +0300 | [diff] [blame] | 6308 | gl->vertexAttribBinding(attribindex, bindingindex); |
| 6309 | } |
| 6310 | |
Pyry Haulos | 1abab60 | 2014-11-05 17:41:42 -0800 | [diff] [blame] | 6311 | void glwVertexAttribDivisor (GLuint index, GLuint divisor) |
| 6312 | { |
| 6313 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 6314 | if (!gl) |
| 6315 | return; |
| 6316 | gl->vertexAttribDivisor(index, divisor); |
| 6317 | } |
| 6318 | |
| 6319 | void glwVertexAttribFormat (GLuint attribindex, GLint size, GLenum type, GLboolean normalized, GLuint relativeoffset) |
| 6320 | { |
| 6321 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 6322 | if (!gl) |
| 6323 | return; |
| 6324 | gl->vertexAttribFormat(attribindex, size, type, normalized, relativeoffset); |
| 6325 | } |
| 6326 | |
| 6327 | void glwVertexAttribI1i (GLuint index, GLint x) |
| 6328 | { |
| 6329 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 6330 | if (!gl) |
| 6331 | return; |
| 6332 | gl->vertexAttribI1i(index, x); |
| 6333 | } |
| 6334 | |
| 6335 | void glwVertexAttribI1iv (GLuint index, const GLint *v) |
| 6336 | { |
| 6337 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 6338 | if (!gl) |
| 6339 | return; |
| 6340 | gl->vertexAttribI1iv(index, v); |
| 6341 | } |
| 6342 | |
| 6343 | void glwVertexAttribI1ui (GLuint index, GLuint x) |
| 6344 | { |
| 6345 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 6346 | if (!gl) |
| 6347 | return; |
| 6348 | gl->vertexAttribI1ui(index, x); |
| 6349 | } |
| 6350 | |
| 6351 | void glwVertexAttribI1uiv (GLuint index, const GLuint *v) |
| 6352 | { |
| 6353 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 6354 | if (!gl) |
| 6355 | return; |
| 6356 | gl->vertexAttribI1uiv(index, v); |
| 6357 | } |
| 6358 | |
| 6359 | void glwVertexAttribI2i (GLuint index, GLint x, GLint y) |
| 6360 | { |
| 6361 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 6362 | if (!gl) |
| 6363 | return; |
| 6364 | gl->vertexAttribI2i(index, x, y); |
| 6365 | } |
| 6366 | |
| 6367 | void glwVertexAttribI2iv (GLuint index, const GLint *v) |
| 6368 | { |
| 6369 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 6370 | if (!gl) |
| 6371 | return; |
| 6372 | gl->vertexAttribI2iv(index, v); |
| 6373 | } |
| 6374 | |
| 6375 | void glwVertexAttribI2ui (GLuint index, GLuint x, GLuint y) |
| 6376 | { |
| 6377 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 6378 | if (!gl) |
| 6379 | return; |
| 6380 | gl->vertexAttribI2ui(index, x, y); |
| 6381 | } |
| 6382 | |
| 6383 | void glwVertexAttribI2uiv (GLuint index, const GLuint *v) |
| 6384 | { |
| 6385 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 6386 | if (!gl) |
| 6387 | return; |
| 6388 | gl->vertexAttribI2uiv(index, v); |
| 6389 | } |
| 6390 | |
| 6391 | void glwVertexAttribI3i (GLuint index, GLint x, GLint y, GLint z) |
| 6392 | { |
| 6393 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 6394 | if (!gl) |
| 6395 | return; |
| 6396 | gl->vertexAttribI3i(index, x, y, z); |
| 6397 | } |
| 6398 | |
| 6399 | void glwVertexAttribI3iv (GLuint index, const GLint *v) |
| 6400 | { |
| 6401 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 6402 | if (!gl) |
| 6403 | return; |
| 6404 | gl->vertexAttribI3iv(index, v); |
| 6405 | } |
| 6406 | |
| 6407 | void glwVertexAttribI3ui (GLuint index, GLuint x, GLuint y, GLuint z) |
| 6408 | { |
| 6409 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 6410 | if (!gl) |
| 6411 | return; |
| 6412 | gl->vertexAttribI3ui(index, x, y, z); |
| 6413 | } |
| 6414 | |
| 6415 | void glwVertexAttribI3uiv (GLuint index, const GLuint *v) |
| 6416 | { |
| 6417 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 6418 | if (!gl) |
| 6419 | return; |
| 6420 | gl->vertexAttribI3uiv(index, v); |
| 6421 | } |
| 6422 | |
| 6423 | void glwVertexAttribI4bv (GLuint index, const GLbyte *v) |
| 6424 | { |
| 6425 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 6426 | if (!gl) |
| 6427 | return; |
| 6428 | gl->vertexAttribI4bv(index, v); |
| 6429 | } |
| 6430 | |
| 6431 | void glwVertexAttribI4i (GLuint index, GLint x, GLint y, GLint z, GLint w) |
| 6432 | { |
| 6433 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 6434 | if (!gl) |
| 6435 | return; |
| 6436 | gl->vertexAttribI4i(index, x, y, z, w); |
| 6437 | } |
| 6438 | |
| 6439 | void glwVertexAttribI4iv (GLuint index, const GLint *v) |
| 6440 | { |
| 6441 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 6442 | if (!gl) |
| 6443 | return; |
| 6444 | gl->vertexAttribI4iv(index, v); |
| 6445 | } |
| 6446 | |
| 6447 | void glwVertexAttribI4sv (GLuint index, const GLshort *v) |
| 6448 | { |
| 6449 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 6450 | if (!gl) |
| 6451 | return; |
| 6452 | gl->vertexAttribI4sv(index, v); |
| 6453 | } |
| 6454 | |
| 6455 | void glwVertexAttribI4ubv (GLuint index, const GLubyte *v) |
| 6456 | { |
| 6457 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 6458 | if (!gl) |
| 6459 | return; |
| 6460 | gl->vertexAttribI4ubv(index, v); |
| 6461 | } |
| 6462 | |
| 6463 | void glwVertexAttribI4ui (GLuint index, GLuint x, GLuint y, GLuint z, GLuint w) |
| 6464 | { |
| 6465 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 6466 | if (!gl) |
| 6467 | return; |
| 6468 | gl->vertexAttribI4ui(index, x, y, z, w); |
| 6469 | } |
| 6470 | |
| 6471 | void glwVertexAttribI4uiv (GLuint index, const GLuint *v) |
| 6472 | { |
| 6473 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 6474 | if (!gl) |
| 6475 | return; |
| 6476 | gl->vertexAttribI4uiv(index, v); |
| 6477 | } |
| 6478 | |
| 6479 | void glwVertexAttribI4usv (GLuint index, const GLushort *v) |
| 6480 | { |
| 6481 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 6482 | if (!gl) |
| 6483 | return; |
| 6484 | gl->vertexAttribI4usv(index, v); |
| 6485 | } |
| 6486 | |
| 6487 | void glwVertexAttribIFormat (GLuint attribindex, GLint size, GLenum type, GLuint relativeoffset) |
| 6488 | { |
| 6489 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 6490 | if (!gl) |
| 6491 | return; |
| 6492 | gl->vertexAttribIFormat(attribindex, size, type, relativeoffset); |
| 6493 | } |
| 6494 | |
| 6495 | void glwVertexAttribIPointer (GLuint index, GLint size, GLenum type, GLsizei stride, const void *pointer) |
| 6496 | { |
| 6497 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 6498 | if (!gl) |
| 6499 | return; |
| 6500 | gl->vertexAttribIPointer(index, size, type, stride, pointer); |
| 6501 | } |
| 6502 | |
| 6503 | void glwVertexAttribL1d (GLuint index, GLdouble x) |
| 6504 | { |
| 6505 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 6506 | if (!gl) |
| 6507 | return; |
| 6508 | gl->vertexAttribL1d(index, x); |
| 6509 | } |
| 6510 | |
| 6511 | void glwVertexAttribL1dv (GLuint index, const GLdouble *v) |
| 6512 | { |
| 6513 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 6514 | if (!gl) |
| 6515 | return; |
| 6516 | gl->vertexAttribL1dv(index, v); |
| 6517 | } |
| 6518 | |
| 6519 | void glwVertexAttribL2d (GLuint index, GLdouble x, GLdouble y) |
| 6520 | { |
| 6521 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 6522 | if (!gl) |
| 6523 | return; |
| 6524 | gl->vertexAttribL2d(index, x, y); |
| 6525 | } |
| 6526 | |
| 6527 | void glwVertexAttribL2dv (GLuint index, const GLdouble *v) |
| 6528 | { |
| 6529 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 6530 | if (!gl) |
| 6531 | return; |
| 6532 | gl->vertexAttribL2dv(index, v); |
| 6533 | } |
| 6534 | |
| 6535 | void glwVertexAttribL3d (GLuint index, GLdouble x, GLdouble y, GLdouble z) |
| 6536 | { |
| 6537 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 6538 | if (!gl) |
| 6539 | return; |
| 6540 | gl->vertexAttribL3d(index, x, y, z); |
| 6541 | } |
| 6542 | |
| 6543 | void glwVertexAttribL3dv (GLuint index, const GLdouble *v) |
| 6544 | { |
| 6545 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 6546 | if (!gl) |
| 6547 | return; |
| 6548 | gl->vertexAttribL3dv(index, v); |
| 6549 | } |
| 6550 | |
| 6551 | void glwVertexAttribL4d (GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w) |
| 6552 | { |
| 6553 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 6554 | if (!gl) |
| 6555 | return; |
| 6556 | gl->vertexAttribL4d(index, x, y, z, w); |
| 6557 | } |
| 6558 | |
| 6559 | void glwVertexAttribL4dv (GLuint index, const GLdouble *v) |
| 6560 | { |
| 6561 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 6562 | if (!gl) |
| 6563 | return; |
| 6564 | gl->vertexAttribL4dv(index, v); |
| 6565 | } |
| 6566 | |
| 6567 | void glwVertexAttribLFormat (GLuint attribindex, GLint size, GLenum type, GLuint relativeoffset) |
| 6568 | { |
| 6569 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 6570 | if (!gl) |
| 6571 | return; |
| 6572 | gl->vertexAttribLFormat(attribindex, size, type, relativeoffset); |
| 6573 | } |
| 6574 | |
| 6575 | void glwVertexAttribLPointer (GLuint index, GLint size, GLenum type, GLsizei stride, const void *pointer) |
| 6576 | { |
| 6577 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 6578 | if (!gl) |
| 6579 | return; |
| 6580 | gl->vertexAttribLPointer(index, size, type, stride, pointer); |
| 6581 | } |
| 6582 | |
| 6583 | void glwVertexAttribP1ui (GLuint index, GLenum type, GLboolean normalized, GLuint value) |
| 6584 | { |
| 6585 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 6586 | if (!gl) |
| 6587 | return; |
| 6588 | gl->vertexAttribP1ui(index, type, normalized, value); |
| 6589 | } |
| 6590 | |
| 6591 | void glwVertexAttribP1uiv (GLuint index, GLenum type, GLboolean normalized, const GLuint *value) |
| 6592 | { |
| 6593 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 6594 | if (!gl) |
| 6595 | return; |
| 6596 | gl->vertexAttribP1uiv(index, type, normalized, value); |
| 6597 | } |
| 6598 | |
| 6599 | void glwVertexAttribP2ui (GLuint index, GLenum type, GLboolean normalized, GLuint value) |
| 6600 | { |
| 6601 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 6602 | if (!gl) |
| 6603 | return; |
| 6604 | gl->vertexAttribP2ui(index, type, normalized, value); |
| 6605 | } |
| 6606 | |
| 6607 | void glwVertexAttribP2uiv (GLuint index, GLenum type, GLboolean normalized, const GLuint *value) |
| 6608 | { |
| 6609 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 6610 | if (!gl) |
| 6611 | return; |
| 6612 | gl->vertexAttribP2uiv(index, type, normalized, value); |
| 6613 | } |
| 6614 | |
| 6615 | void glwVertexAttribP3ui (GLuint index, GLenum type, GLboolean normalized, GLuint value) |
| 6616 | { |
| 6617 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 6618 | if (!gl) |
| 6619 | return; |
| 6620 | gl->vertexAttribP3ui(index, type, normalized, value); |
| 6621 | } |
| 6622 | |
| 6623 | void glwVertexAttribP3uiv (GLuint index, GLenum type, GLboolean normalized, const GLuint *value) |
| 6624 | { |
| 6625 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 6626 | if (!gl) |
| 6627 | return; |
| 6628 | gl->vertexAttribP3uiv(index, type, normalized, value); |
| 6629 | } |
| 6630 | |
| 6631 | void glwVertexAttribP4ui (GLuint index, GLenum type, GLboolean normalized, GLuint value) |
| 6632 | { |
| 6633 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 6634 | if (!gl) |
| 6635 | return; |
| 6636 | gl->vertexAttribP4ui(index, type, normalized, value); |
| 6637 | } |
| 6638 | |
| 6639 | void glwVertexAttribP4uiv (GLuint index, GLenum type, GLboolean normalized, const GLuint *value) |
| 6640 | { |
| 6641 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 6642 | if (!gl) |
| 6643 | return; |
| 6644 | gl->vertexAttribP4uiv(index, type, normalized, value); |
| 6645 | } |
| 6646 | |
| 6647 | void glwVertexAttribPointer (GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const void *pointer) |
| 6648 | { |
| 6649 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 6650 | if (!gl) |
| 6651 | return; |
| 6652 | gl->vertexAttribPointer(index, size, type, normalized, stride, pointer); |
| 6653 | } |
| 6654 | |
Jarkko Poyry | 3c82736 | 2014-09-02 11:48:52 +0300 | [diff] [blame] | 6655 | void glwVertexBindingDivisor (GLuint bindingindex, GLuint divisor) |
| 6656 | { |
| 6657 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 6658 | if (!gl) |
Pyry Haulos | 1abab60 | 2014-11-05 17:41:42 -0800 | [diff] [blame] | 6659 | return; |
Jarkko Poyry | 3c82736 | 2014-09-02 11:48:52 +0300 | [diff] [blame] | 6660 | gl->vertexBindingDivisor(bindingindex, divisor); |
| 6661 | } |
| 6662 | |
Pyry Haulos | 1abab60 | 2014-11-05 17:41:42 -0800 | [diff] [blame] | 6663 | void glwViewport (GLint x, GLint y, GLsizei width, GLsizei height) |
Jarkko Poyry | 3c82736 | 2014-09-02 11:48:52 +0300 | [diff] [blame] | 6664 | { |
| 6665 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 6666 | if (!gl) |
Pyry Haulos | 1abab60 | 2014-11-05 17:41:42 -0800 | [diff] [blame] | 6667 | return; |
| 6668 | gl->viewport(x, y, width, height); |
Jarkko Poyry | 3c82736 | 2014-09-02 11:48:52 +0300 | [diff] [blame] | 6669 | } |
| 6670 | |
Pyry Haulos | 1abab60 | 2014-11-05 17:41:42 -0800 | [diff] [blame] | 6671 | void glwViewportArrayv (GLuint first, GLsizei count, const GLfloat *v) |
Jarkko Poyry | 3c82736 | 2014-09-02 11:48:52 +0300 | [diff] [blame] | 6672 | { |
| 6673 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 6674 | if (!gl) |
Pyry Haulos | 1abab60 | 2014-11-05 17:41:42 -0800 | [diff] [blame] | 6675 | return; |
| 6676 | gl->viewportArrayv(first, count, v); |
Jarkko Poyry | 3c82736 | 2014-09-02 11:48:52 +0300 | [diff] [blame] | 6677 | } |
| 6678 | |
Pyry Haulos | 1abab60 | 2014-11-05 17:41:42 -0800 | [diff] [blame] | 6679 | void glwViewportIndexedf (GLuint index, GLfloat x, GLfloat y, GLfloat w, GLfloat h) |
Jarkko Poyry | 3c82736 | 2014-09-02 11:48:52 +0300 | [diff] [blame] | 6680 | { |
| 6681 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 6682 | if (!gl) |
Pyry Haulos | 1abab60 | 2014-11-05 17:41:42 -0800 | [diff] [blame] | 6683 | return; |
| 6684 | gl->viewportIndexedf(index, x, y, w, h); |
Jarkko Poyry | 3c82736 | 2014-09-02 11:48:52 +0300 | [diff] [blame] | 6685 | } |
| 6686 | |
Pyry Haulos | 1abab60 | 2014-11-05 17:41:42 -0800 | [diff] [blame] | 6687 | void glwViewportIndexedfv (GLuint index, const GLfloat *v) |
Jarkko Poyry | 3c82736 | 2014-09-02 11:48:52 +0300 | [diff] [blame] | 6688 | { |
| 6689 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 6690 | if (!gl) |
Pyry Haulos | 1abab60 | 2014-11-05 17:41:42 -0800 | [diff] [blame] | 6691 | return; |
| 6692 | gl->viewportIndexedfv(index, v); |
Jarkko Poyry | 3c82736 | 2014-09-02 11:48:52 +0300 | [diff] [blame] | 6693 | } |
| 6694 | |
Pyry Haulos | 1abab60 | 2014-11-05 17:41:42 -0800 | [diff] [blame] | 6695 | void glwWaitSync (GLsync sync, GLbitfield flags, GLuint64 timeout) |
Jarkko Poyry | 3c82736 | 2014-09-02 11:48:52 +0300 | [diff] [blame] | 6696 | { |
| 6697 | const glw::Functions* gl = glw::getCurrentThreadFunctions(); |
| 6698 | if (!gl) |
Pyry Haulos | 1abab60 | 2014-11-05 17:41:42 -0800 | [diff] [blame] | 6699 | return; |
| 6700 | gl->waitSync(sync, flags, timeout); |
Jarkko Poyry | 3c82736 | 2014-09-02 11:48:52 +0300 | [diff] [blame] | 6701 | } |