Showing the changes to interface/src/gpu/GLBackend.cpp (1 of 4 files). Show all
Unified · Split
| @@ -0,0 +1,736 @@ | |||
| 1 | // | ||
| 2 | // GLBackend.cpp | ||
| 3 | // interface/src/gpu | ||
| 4 | // | ||
| 5 | // Created by Sam Gateau on 10/27/2014. | ||
| 6 | // Copyright 2014 High Fidelity, Inc. | ||
| 7 | // | ||
| 8 | // Distributed under the Apache License, Version 2.0. | ||
| 9 | // See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html | ||
| 10 | // | ||
| 11 | #include "GLBackend.h" | ||
| 12 | |||
| 13 | #include <QDebug> | ||
| 14 | |||
| 15 | #include "gpu/Resource.h" | ||
| 16 | |||
| 17 | using namespace gpu; | ||
| 18 | |||
| 19 | GLBackend::CommandCall GLBackend::_commandCalls[Batch::NUM_COMMANDS] = | ||
| 20 | { | ||
| 21 | (&::gpu::GLBackend::do_glEnable), | ||
| 22 | (&::gpu::GLBackend::do_glDisable), | ||
| 23 | |||
| 24 | (&::gpu::GLBackend::do_glEnableClientState), | ||
| 25 | (&::gpu::GLBackend::do_glDisableClientState), | ||
| 26 | |||
| 27 | (&::gpu::GLBackend::do_glCullFace), | ||
| 28 | (&::gpu::GLBackend::do_glAlphaFunc), | ||
| 29 | |||
| 30 | (&::gpu::GLBackend::do_glDepthFunc), | ||
| 31 | (&::gpu::GLBackend::do_glDepthMask), | ||
| 32 | (&::gpu::GLBackend::do_glDepthRange), | ||
| 33 | |||
| 34 | (&::gpu::GLBackend::do_glBindBuffer), | ||
| 35 | |||
| 36 | (&::gpu::GLBackend::do_glBindTexture), | ||
| 37 | (&::gpu::GLBackend::do_glActiveTexture), | ||
| 38 | |||
| 39 | (&::gpu::GLBackend::do_glDrawBuffers), | ||
| 40 | |||
| 41 | (&::gpu::GLBackend::do_glUseProgram), | ||
| 42 | (&::gpu::GLBackend::do_glUniform1f), | ||
| 43 | (&::gpu::GLBackend::do_glUniformMatrix4fv), | ||
| 44 | |||
| 45 | (&::gpu::GLBackend::do_glMatrixMode), | ||
| 46 | (&::gpu::GLBackend::do_glPushMatrix), | ||
| 47 | (&::gpu::GLBackend::do_glPopMatrix), | ||
| 48 | (&::gpu::GLBackend::do_glMultMatrixf), | ||
| 49 | (&::gpu::GLBackend::do_glLoadMatrixf), | ||
| 50 | (&::gpu::GLBackend::do_glLoadIdentity), | ||
| 51 | (&::gpu::GLBackend::do_glRotatef), | ||
| 52 | (&::gpu::GLBackend::do_glScalef), | ||
| 53 | (&::gpu::GLBackend::do_glTranslatef), | ||
| 54 | |||
| 55 | (&::gpu::GLBackend::do_glDrawArrays), | ||
| 56 | (&::gpu::GLBackend::do_glDrawRangeElements), | ||
| 57 | |||
| 58 | (&::gpu::GLBackend::do_glColorPointer), | ||
| 59 | (&::gpu::GLBackend::do_glNormalPointer), | ||
| 60 | (&::gpu::GLBackend::do_glTexCoordPointer), | ||
| 61 | (&::gpu::GLBackend::do_glVertexPointer), | ||
| 62 | |||
| 63 | (&::gpu::GLBackend::do_glVertexAttribPointer), | ||
| 64 | (&::gpu::GLBackend::do_glEnableVertexAttribArray), | ||
| 65 | (&::gpu::GLBackend::do_glDisableVertexAttribArray), | ||
| 66 | |||
| 67 | (&::gpu::GLBackend::do_glColor4f), | ||
| 68 | |||
| 69 | (&::gpu::GLBackend::do_glMaterialf), | ||
| 70 | (&::gpu::GLBackend::do_glMaterialfv), | ||
| 71 | }; | ||
| 72 | |||
| 73 | |||
| 74 | GLBackend::GLBackend() { | ||
| 75 | |||
| 76 | } | ||
| 77 | |||
| 78 | GLBackend::~GLBackend() { | ||
| 79 | |||
| 80 | } | ||
| 81 | |||
| 82 | void GLBackend::renderBatch(Batch& batch) { | ||
| 83 | uint32 numCommands = batch.getCommands().size(); | ||
| 84 | const Batch::Commands::value_type* command = batch.getCommands().data(); | ||
| 85 | const Batch::CommandOffsets::value_type* offset = batch.getCommandOffsets().data(); | ||
| 86 | |||
| 87 | GLBackend backend; | ||
| 88 | |||
| 89 | for (int i = 0; i < numCommands; i++) { | ||
| 90 | CommandCall call = _commandCalls[((*command) - Batch::COMMAND_glEnable)]; | ||
| 91 | (backend.*(call))(batch, *offset); | ||
| 92 | command++; | ||
| 93 | offset++; | ||
| 94 | } | ||
| 95 | } | ||
| 96 | |||
| 97 | void GLBackend::checkGLError() { | ||
| 98 | GLenum error = glGetError(); | ||
| 99 | if (!error) { | ||
| 100 | return; | ||
| 101 | } | ||
| 102 | else { | ||
| 103 | switch (error) { | ||
| 104 | case GL_INVALID_ENUM: | ||
| 105 | qDebug() << "An unacceptable value is specified for an enumerated argument.The offending command is ignored and has no other side effect than to set the error flag."; | ||
| 106 | break; | ||
| 107 | case GL_INVALID_VALUE: | ||
| 108 | qDebug() << "A numeric argument is out of range.The offending command is ignored and has no other side effect than to set the error flag"; | ||
| 109 | break; | ||
| 110 | case GL_INVALID_OPERATION: | ||
| 111 | qDebug() << "The specified operation is not allowed in the current state.The offending command is ignored and has no other side effect than to set the error flag.."; | ||
| 112 | break; | ||
| 113 | case GL_INVALID_FRAMEBUFFER_OPERATION: | ||
| 114 | qDebug() << "The framebuffer object is not complete.The offending command is ignored and has no other side effect than to set the error flag."; | ||
| 115 | break; | ||
| 116 | case GL_OUT_OF_MEMORY: | ||
| 117 | qDebug() << "There is not enough memory left to execute the command.The state of the GL is undefined, except for the state of the error flags, after this error is recorded."; | ||
| 118 | break; | ||
| 119 | case GL_STACK_UNDERFLOW: | ||
| 120 | qDebug() << "An attempt has been made to perform an operation that would cause an internal stack to underflow."; | ||
| 121 | break; | ||
| 122 | case GL_STACK_OVERFLOW: | ||
| 123 | qDebug() << "An attempt has been made to perform an operation that would cause an internal stack to overflow."; | ||
| 124 | break; | ||
| 125 | } | ||
| 126 | } | ||
| 127 | } | ||
| 128 | |||
| 129 | |||
| 130 | // TODO: As long as we have gl calls explicitely issued from interface | ||
| 131 | // code, we need to be able to record and batch these calls. THe long | ||
| 132 | // term strategy is to get rid of any GL calls in favor of the HIFI GPU API | ||
| 133 | |||
| 134 | //#define ADD_COMMAND(call) _commands.push_back(COMMAND_##call); _commandCalls.push_back(&gpu::Batch::do_##call); _commandOffsets.push_back(_params.size()); | ||
| 135 | #define ADD_COMMAND(call) _commands.push_back(COMMAND_##call); _commandOffsets.push_back(_params.size()); | ||
| 136 | //#define ADD_COMMAND_GL(call) _commands.push_back(COMMAND_##call); _commandCalls.push_back(&gpu::GLBackend::do_##call); _commandOffsets.push_back(_params.size()); | ||
| 137 | #define ADD_COMMAND_GL(call) _commands.push_back(COMMAND_##call); _commandOffsets.push_back(_params.size()); | ||
| 138 | |||
| 139 | //#define DO_IT_NOW(call, offset) runLastCommand(); | ||
| 140 | #define DO_IT_NOW(call, offset) | ||
| 141 | |||
| 142 | //#define CHECK_GL_ERROR() ::gpu::backend::checkGLError() | ||
| 143 | #define CHECK_GL_ERROR() | ||
| 144 | |||
| 145 | void Batch::_glEnable(GLenum cap) { | ||
| 146 | ADD_COMMAND(glEnable); | ||
| 147 | |||
| 148 | _params.push_back(cap); | ||
| 149 | |||
| 150 | DO_IT_NOW(_glEnable, 1); | ||
| 151 | } | ||
| 152 | void GLBackend::do_glEnable(Batch& batch, uint32 paramOffset) { | ||
| 153 | glEnable(batch._params[paramOffset]._uint); | ||
| 154 | CHECK_GL_ERROR(); | ||
| 155 | } | ||
| 156 | |||
| 157 | void Batch::_glDisable(GLenum cap) { | ||
| 158 | ADD_COMMAND(glDisable); | ||
| 159 | |||
| 160 | _params.push_back(cap); | ||
| 161 | |||
| 162 | DO_IT_NOW(_glDisable, 1); | ||
| 163 | } | ||
| 164 | void GLBackend::do_glDisable(Batch& batch, uint32 paramOffset) { | ||
| 165 | glDisable(batch._params[paramOffset]._uint); | ||
| 166 | CHECK_GL_ERROR(); | ||
| 167 | } | ||
| 168 | |||
| 169 | void Batch::_glEnableClientState(GLenum array) { | ||
| 170 | ADD_COMMAND(glEnableClientState); | ||
| 171 | |||
| 172 | _params.push_back(array); | ||
| 173 | |||
| 174 | DO_IT_NOW(_glEnableClientState, 1); | ||
| 175 | } | ||
| 176 | void GLBackend::do_glEnableClientState(Batch& batch, uint32 paramOffset) { | ||
| 177 | glEnableClientState(batch._params[paramOffset]._uint); | ||
| 178 | CHECK_GL_ERROR(); | ||
| 179 | } | ||
| 180 | |||
| 181 | void Batch::_glDisableClientState(GLenum array) { | ||
| 182 | ADD_COMMAND(glDisableClientState); | ||
| 183 | |||
| 184 | _params.push_back(array); | ||
| 185 | |||
| 186 | DO_IT_NOW(_glDisableClientState, 1); | ||
| 187 | } | ||
| 188 | void GLBackend::do_glDisableClientState(Batch& batch, uint32 paramOffset) { | ||
| 189 | glDisableClientState(batch._params[paramOffset]._uint); | ||
| 190 | CHECK_GL_ERROR(); | ||
| 191 | } | ||
| 192 | |||
| 193 | void Batch::_glCullFace(GLenum mode) { | ||
| 194 | ADD_COMMAND(glCullFace); | ||
| 195 | |||
| 196 | _params.push_back(mode); | ||
| 197 | |||
| 198 | DO_IT_NOW(_glCullFace, 1); | ||
| 199 | } | ||
| 200 | void GLBackend::do_glCullFace(Batch& batch, uint32 paramOffset) { | ||
| 201 | glCullFace(batch._params[paramOffset]._uint); | ||
| 202 | CHECK_GL_ERROR(); | ||
| 203 | } | ||
| 204 | |||
| 205 | void Batch::_glAlphaFunc(GLenum func, GLclampf ref) { | ||
| 206 | ADD_COMMAND(glAlphaFunc); | ||
| 207 | |||
| 208 | _params.push_back(ref); | ||
| 209 | _params.push_back(func); | ||
| 210 | |||
| 211 | DO_IT_NOW(_glAlphaFunc, 2); | ||
| 212 | } | ||
| 213 | void GLBackend::do_glAlphaFunc(Batch& batch, uint32 paramOffset) { | ||
| 214 | glAlphaFunc( | ||
| 215 | batch._params[paramOffset + 1]._uint, | ||
| 216 | batch._params[paramOffset + 0]._float); | ||
| 217 | CHECK_GL_ERROR(); | ||
| 218 | } | ||
| 219 | |||
| 220 | void Batch::_glDepthFunc(GLenum func) { | ||
| 221 | ADD_COMMAND(glDepthFunc); | ||
| 222 | |||
| 223 | _params.push_back(func); | ||
| 224 | |||
| 225 | DO_IT_NOW(_glDepthFunc, 1); | ||
| 226 | } | ||
| 227 | void GLBackend::do_glDepthFunc(Batch& batch, uint32 paramOffset) { | ||
| 228 | glDepthFunc(batch._params[paramOffset]._uint); | ||
| 229 | CHECK_GL_ERROR(); | ||
| 230 | } | ||
| 231 | |||
| 232 | void Batch::_glDepthMask(GLboolean flag) { | ||
| 233 | ADD_COMMAND(glDepthMask); | ||
| 234 | |||
| 235 | _params.push_back(flag); | ||
| 236 | |||
| 237 | DO_IT_NOW(_glDepthMask, 1); | ||
| 238 | } | ||
| 239 | void GLBackend::do_glDepthMask(Batch& batch, uint32 paramOffset) { | ||
| 240 | glDepthMask(batch._params[paramOffset]._uint); | ||
| 241 | CHECK_GL_ERROR(); | ||
| 242 | } | ||
| 243 | |||
| 244 | void Batch::_glDepthRange(GLclampd zNear, GLclampd zFar) { | ||
| 245 | ADD_COMMAND(glDepthRange); | ||
| 246 | |||
| 247 | _params.push_back(zFar); | ||
| 248 | _params.push_back(zNear); | ||
| 249 | |||
| 250 | DO_IT_NOW(_glDepthRange, 2); | ||
| 251 | } | ||
| 252 | void GLBackend::do_glDepthRange(Batch& batch, uint32 paramOffset) { | ||
| 253 | glDepthRange( | ||
| 254 | batch._params[paramOffset + 1]._double, | ||
| 255 | batch._params[paramOffset + 0]._double); | ||
| 256 | CHECK_GL_ERROR(); | ||
| 257 | } | ||
| 258 | |||
| 259 | void Batch::_glBindBuffer(GLenum target, GLuint buffer) { | ||
| 260 | ADD_COMMAND(glBindBuffer); | ||
| 261 | |||
| 262 | _params.push_back(buffer); | ||
| 263 | _params.push_back(target); | ||
| 264 | |||
| 265 | DO_IT_NOW(_glBindBuffer, 2); | ||
| 266 | } | ||
| 267 | void GLBackend::do_glBindBuffer(Batch& batch, uint32 paramOffset) { | ||
| 268 | glBindBuffer( | ||
| 269 | batch._params[paramOffset + 1]._uint, | ||
| 270 | batch._params[paramOffset + 0]._uint); | ||
| 271 | CHECK_GL_ERROR(); | ||
| 272 | } | ||
| 273 | |||
| 274 | void Batch::_glBindTexture(GLenum target, GLuint texture) { | ||
| 275 | ADD_COMMAND(glBindTexture); | ||
| 276 | |||
| 277 | _params.push_back(texture); | ||
| 278 | _params.push_back(target); | ||
| 279 | |||
| 280 | DO_IT_NOW(_glBindTexture, 2); | ||
| 281 | } | ||
| 282 | void GLBackend::do_glBindTexture(Batch& batch, uint32 paramOffset) { | ||
| 283 | glBindTexture( | ||
| 284 | batch._params[paramOffset + 1]._uint, | ||
| 285 | batch._params[paramOffset + 0]._uint); | ||
| 286 | CHECK_GL_ERROR(); | ||
| 287 | } | ||
| 288 | |||
| 289 | void Batch::_glActiveTexture(GLenum texture) { | ||
| 290 | ADD_COMMAND(glActiveTexture); | ||
| 291 | |||
| 292 | _params.push_back(texture); | ||
| 293 | |||
| 294 | DO_IT_NOW(_glActiveTexture, 1); | ||
| 295 | } | ||
| 296 | void GLBackend::do_glActiveTexture(Batch& batch, uint32 paramOffset) { | ||
| 297 | glActiveTexture(batch._params[paramOffset]._uint); | ||
| 298 | CHECK_GL_ERROR(); | ||
| 299 | } | ||
| 300 | |||
| 301 | void Batch::_glDrawBuffers(GLsizei n, const GLenum* bufs) { | ||
| 302 | ADD_COMMAND(glDrawBuffers); | ||
| 303 | |||
| 304 | _params.push_back(cacheData(n * sizeof(GLenum), bufs)); | ||
| 305 | _params.push_back(n); | ||
| 306 | |||
| 307 | DO_IT_NOW(_glDrawBuffers, 2); | ||
| 308 | } | ||
| 309 | void GLBackend::do_glDrawBuffers(Batch& batch, uint32 paramOffset) { | ||
| 310 | glDrawBuffers( | ||
| 311 | batch._params[paramOffset + 1]._uint, | ||
| 312 | (const GLenum*)batch.editData(batch._params[paramOffset + 0]._uint)); | ||
| 313 | CHECK_GL_ERROR(); | ||
| 314 | } | ||
| 315 | |||
| 316 | void Batch::_glUseProgram(GLuint program) { | ||
| 317 | ADD_COMMAND(glUseProgram); | ||
| 318 | |||
| 319 | _params.push_back(program); | ||
| 320 | |||
| 321 | DO_IT_NOW(_glUseProgram, 1); | ||
| 322 | } | ||
| 323 | void GLBackend::do_glUseProgram(Batch& batch, uint32 paramOffset) { | ||
| 324 | glUseProgram(batch._params[paramOffset]._uint); | ||
| 325 | CHECK_GL_ERROR(); | ||
| 326 | } | ||
| 327 | |||
| 328 | void Batch::_glUniform1f(GLint location, GLfloat v0) { | ||
| 329 | ADD_COMMAND(glUniform1f); | ||
| 330 | |||
| 331 | _params.push_back(v0); | ||
| 332 | _params.push_back(location); | ||
| 333 | |||
| 334 | DO_IT_NOW(_glUniform1f, 1); | ||
| 335 | } | ||
| 336 | void GLBackend::do_glUniform1f(Batch& batch, uint32 paramOffset) { | ||
| 337 | glUniform1f( | ||
| 338 | batch._params[paramOffset + 1]._int, | ||
| 339 | batch._params[paramOffset + 0]._float); | ||
| 340 | CHECK_GL_ERROR(); | ||
| 341 | } | ||
| 342 | |||
| 343 | void Batch::_glUniformMatrix4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) { | ||
| 344 | ADD_COMMAND(glUniformMatrix4fv); | ||
| 345 | |||
| 346 | const int MATRIX4_SIZE = 16 * sizeof(float); | ||
| 347 | _params.push_back(cacheData(count * MATRIX4_SIZE, value)); | ||
| 348 | _params.push_back(transpose); | ||
| 349 | _params.push_back(count); | ||
| 350 | _params.push_back(location); | ||
| 351 | |||
| 352 | DO_IT_NOW(_glUniformMatrix4fv, 4); | ||
| 353 | } | ||
| 354 | void GLBackend::do_glUniformMatrix4fv(Batch& batch, uint32 paramOffset) { | ||
| 355 | glUniformMatrix4fv( | ||
| 356 | batch._params[paramOffset + 3]._int, | ||
| 357 | batch._params[paramOffset + 2]._uint, | ||
| 358 | batch._params[paramOffset + 1]._uint, | ||
| 359 | (const GLfloat*)batch.editData(batch._params[paramOffset + 0]._uint)); | ||
| 360 | CHECK_GL_ERROR(); | ||
| 361 | } | ||
| 362 | |||
| 363 | void Batch::_glMatrixMode(GLenum mode) { | ||
| 364 | ADD_COMMAND(glMatrixMode); | ||
| 365 | |||
| 366 | _params.push_back(mode); | ||
| 367 | |||
| 368 | DO_IT_NOW(_glMatrixMode, 1); | ||
| 369 | } | ||
| 370 | void GLBackend::do_glMatrixMode(Batch& batch, uint32 paramOffset) { | ||
| 371 | glMatrixMode(batch._params[paramOffset]._uint); | ||
| 372 | CHECK_GL_ERROR(); | ||
| 373 | } | ||
| 374 | |||
| 375 | void Batch::_glPushMatrix() { | ||
| 376 | ADD_COMMAND(glPushMatrix); | ||
| 377 | |||
| 378 | DO_IT_NOW(_glPushMatrix, 0); | ||
| 379 | } | ||
| 380 | void GLBackend::do_glPushMatrix(Batch& batch, uint32 paramOffset) { | ||
| 381 | glPushMatrix(); | ||
| 382 | CHECK_GL_ERROR(); | ||
| 383 | } | ||
| 384 | |||
| 385 | void Batch::_glPopMatrix() { | ||
| 386 | ADD_COMMAND(glPopMatrix); | ||
| 387 | |||
| 388 | DO_IT_NOW(_glPopMatrix, 0); | ||
| 389 | } | ||
| 390 | void GLBackend::do_glPopMatrix(Batch& batch, uint32 paramOffset) { | ||
| 391 | glPopMatrix(); | ||
| 392 | CHECK_GL_ERROR(); | ||
| 393 | } | ||
| 394 | |||
| 395 | void Batch::_glMultMatrixf(const GLfloat *m) { | ||
| 396 | ADD_COMMAND(glMultMatrixf); | ||
| 397 | |||
| 398 | const int MATRIX4_SIZE = 16 * sizeof(float); | ||
| 399 | _params.push_back(cacheData(MATRIX4_SIZE, m)); | ||
| 400 | |||
| 401 | DO_IT_NOW(_glMultMatrixf, 1); | ||
| 402 | } | ||
| 403 | void GLBackend::do_glMultMatrixf(Batch& batch, uint32 paramOffset) { | ||
| 404 | glMultMatrixf((const GLfloat*)batch.editData(batch._params[paramOffset]._uint)); | ||
| 405 | CHECK_GL_ERROR(); | ||
| 406 | } | ||
| 407 | |||
| 408 | void Batch::_glLoadMatrixf(const GLfloat *m) { | ||
| 409 | ADD_COMMAND(glLoadMatrixf); | ||
| 410 | |||
| 411 | const int MATRIX4_SIZE = 16 * sizeof(float); | ||
| 412 | _params.push_back(cacheData(MATRIX4_SIZE, m)); | ||
| 413 | |||
| 414 | DO_IT_NOW(_glLoadMatrixf, 1); | ||
| 415 | } | ||
| 416 | void GLBackend::do_glLoadMatrixf(Batch& batch, uint32 paramOffset) { | ||
| 417 | glLoadMatrixf((const GLfloat*)batch.editData(batch._params[paramOffset]._uint)); | ||
| 418 | CHECK_GL_ERROR(); | ||
| 419 | } | ||
| 420 | |||
| 421 | void Batch::_glLoadIdentity(void) { | ||
| 422 | ADD_COMMAND(glLoadIdentity); | ||
| 423 | |||
| 424 | DO_IT_NOW(_glLoadIdentity, 0); | ||
| 425 | } | ||
| 426 | void GLBackend::do_glLoadIdentity(Batch& batch, uint32 paramOffset) { | ||
| 427 | glLoadIdentity(); | ||
| 428 | CHECK_GL_ERROR(); | ||
| 429 | } | ||
| 430 | |||
| 431 | void Batch::_glRotatef(GLfloat angle, GLfloat x, GLfloat y, GLfloat z) { | ||
| 432 | ADD_COMMAND(glRotatef); | ||
| 433 | |||
| 434 | _params.push_back(z); | ||
| 435 | _params.push_back(y); | ||
| 436 | _params.push_back(x); | ||
| 437 | _params.push_back(angle); | ||
| 438 | |||
| 439 | DO_IT_NOW(_glRotatef, 4); | ||
| 440 | } | ||
| 441 | void GLBackend::do_glRotatef(Batch& batch, uint32 paramOffset) { | ||
| 442 | glRotatef( | ||
| 443 | batch._params[paramOffset + 3]._float, | ||
| 444 | batch._params[paramOffset + 2]._float, | ||
| 445 | batch._params[paramOffset + 1]._float, | ||
| 446 | batch._params[paramOffset + 0]._float); | ||
| 447 | CHECK_GL_ERROR(); | ||
| 448 | } | ||
| 449 | |||
| 450 | void Batch::_glScalef(GLfloat x, GLfloat y, GLfloat z) { | ||
| 451 | ADD_COMMAND(glScalef); | ||
| 452 | |||
| 453 | _params.push_back(z); | ||
| 454 | _params.push_back(y); | ||
| 455 | _params.push_back(x); | ||
| 456 | |||
| 457 | DO_IT_NOW(_glScalef, 3); | ||
| 458 | } | ||
| 459 | void GLBackend::do_glScalef(Batch& batch, uint32 paramOffset) { | ||
| 460 | glScalef( | ||
| 461 | batch._params[paramOffset + 2]._float, | ||
| 462 | batch._params[paramOffset + 1]._float, | ||
| 463 | batch._params[paramOffset + 0]._float); | ||
| 464 | CHECK_GL_ERROR(); | ||
| 465 | } | ||
| 466 | |||
| 467 | void Batch::_glTranslatef(GLfloat x, GLfloat y, GLfloat z) { | ||
| 468 | ADD_COMMAND(glTranslatef); | ||
| 469 | |||
| 470 | _params.push_back(z); | ||
| 471 | _params.push_back(y); | ||
| 472 | _params.push_back(x); | ||
| 473 | |||
| 474 | DO_IT_NOW(_glTranslatef, 3); | ||
| 475 | } | ||
| 476 | void GLBackend::do_glTranslatef(Batch& batch, uint32 paramOffset) { | ||
| 477 | glTranslatef( | ||
| 478 | batch._params[paramOffset + 2]._float, | ||
| 479 | batch._params[paramOffset + 1]._float, | ||
| 480 | batch._params[paramOffset + 0]._float); | ||
| 481 | CHECK_GL_ERROR(); | ||
| 482 | } | ||
| 483 | |||
| 484 | void Batch::_glDrawArrays(GLenum mode, GLint first, GLsizei count) { | ||
| 485 | ADD_COMMAND(glDrawArrays); | ||
| 486 | |||
| 487 | _params.push_back(count); | ||
| 488 | _params.push_back(first); | ||
| 489 | _params.push_back(mode); | ||
| 490 | |||
| 491 | DO_IT_NOW(_glDrawArrays, 3); | ||
| 492 | } | ||
| 493 | void GLBackend::do_glDrawArrays(Batch& batch, uint32 paramOffset) { | ||
| 494 | glDrawArrays( | ||
| 495 | batch._params[paramOffset + 2]._uint, | ||
| 496 | batch._params[paramOffset + 1]._int, | ||
| 497 | batch._params[paramOffset + 0]._int); | ||
| 498 | CHECK_GL_ERROR(); | ||
| 499 | } | ||
| 500 | |||
| 501 | void Batch::_glDrawRangeElements(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const void *indices) { | ||
| 502 | ADD_COMMAND(glDrawRangeElements); | ||
| 503 | |||
| 504 | _params.push_back(cacheResource(indices)); | ||
| 505 | _params.push_back(type); | ||
| 506 | _params.push_back(count); | ||
| 507 | _params.push_back(end); | ||
| 508 | _params.push_back(start); | ||
| 509 | _params.push_back(mode); | ||
| 510 | |||
| 511 | DO_IT_NOW(_glDrawRangeElements, 6); | ||
| 512 | } | ||
| 513 | void GLBackend::do_glDrawRangeElements(Batch& batch, uint32 paramOffset) { | ||
| 514 | glDrawRangeElements( | ||
| 515 | batch._params[paramOffset + 5]._uint, | ||
| 516 | batch._params[paramOffset + 4]._uint, | ||
| 517 | batch._params[paramOffset + 3]._uint, | ||
| 518 | batch._params[paramOffset + 2]._int, | ||
| 519 | batch._params[paramOffset + 1]._uint, | ||
| 520 | batch.editResource(batch._params[paramOffset + 0]._uint)->_pointer); | ||
| 521 | CHECK_GL_ERROR(); | ||
| 522 | } | ||
| 523 | |||
| 524 | void Batch::_glColorPointer(GLint size, GLenum type, GLsizei stride, const void *pointer) { | ||
| 525 | ADD_COMMAND(glColorPointer); | ||
| 526 | |||
| 527 | _params.push_back(cacheResource(pointer)); | ||
| 528 | _params.push_back(stride); | ||
| 529 | _params.push_back(type); | ||
| 530 | _params.push_back(size); | ||
| 531 | |||
| 532 | DO_IT_NOW(_glColorPointer, 4); | ||
| 533 | } | ||
| 534 | void GLBackend::do_glColorPointer(Batch& batch, uint32 paramOffset) { | ||
| 535 | glColorPointer( | ||
| 536 | batch._params[paramOffset + 3]._int, | ||
| 537 | batch._params[paramOffset + 2]._uint, | ||
| 538 | batch._params[paramOffset + 1]._int, | ||
| 539 | batch.editResource(batch._params[paramOffset + 0]._uint)->_pointer); | ||
| 540 | CHECK_GL_ERROR(); | ||
| 541 | } | ||
| 542 | |||
| 543 | void Batch::_glNormalPointer(GLenum type, GLsizei stride, const void *pointer) { | ||
| 544 | ADD_COMMAND(glNormalPointer); | ||
| 545 | |||
| 546 | _params.push_back(cacheResource(pointer)); | ||
| 547 | _params.push_back(stride); | ||
| 548 | _params.push_back(type); | ||
| 549 | |||
| 550 | DO_IT_NOW(_glNormalPointer, 3); | ||
| 551 | } | ||
| 552 | void GLBackend::do_glNormalPointer(Batch& batch, uint32 paramOffset) { | ||
| 553 | glNormalPointer( | ||
| 554 | batch._params[paramOffset + 2]._uint, | ||
| 555 | batch._params[paramOffset + 1]._int, | ||
| 556 | batch.editResource(batch._params[paramOffset + 0]._uint)->_pointer); | ||
| 557 | CHECK_GL_ERROR(); | ||
| 558 | } | ||
| 559 | |||
| 560 | void Batch::_glTexCoordPointer(GLint size, GLenum type, GLsizei stride, const void *pointer) { | ||
| 561 | ADD_COMMAND(glTexCoordPointer); | ||
| 562 | |||
| 563 | _params.push_back(cacheResource(pointer)); | ||
| 564 | _params.push_back(stride); | ||
| 565 | _params.push_back(type); | ||
| 566 | _params.push_back(size); | ||
| 567 | |||
| 568 | DO_IT_NOW(_glTexCoordPointer, 4); | ||
| 569 | } | ||
| 570 | void GLBackend::do_glTexCoordPointer(Batch& batch, uint32 paramOffset) { | ||
| 571 | glTexCoordPointer( | ||
| 572 | batch._params[paramOffset + 3]._int, | ||
| 573 | batch._params[paramOffset + 2]._uint, | ||
| 574 | batch._params[paramOffset + 1]._int, | ||
| 575 | batch.editResource(batch._params[paramOffset + 0]._uint)->_pointer); | ||
| 576 | CHECK_GL_ERROR(); | ||
| 577 | } | ||
| 578 | |||
| 579 | void Batch::_glVertexPointer(GLint size, GLenum type, GLsizei stride, const void *pointer) { | ||
| 580 | ADD_COMMAND(glVertexPointer); | ||
| 581 | |||
| 582 | _params.push_back(cacheResource(pointer)); | ||
| 583 | _params.push_back(stride); | ||
| 584 | _params.push_back(type); | ||
| 585 | _params.push_back(size); | ||
| 586 | |||
| 587 | DO_IT_NOW(_glVertexPointer, 4); | ||
| 588 | } | ||
| 589 | void GLBackend::do_glVertexPointer(Batch& batch, uint32 paramOffset) { | ||
| 590 | glVertexPointer( | ||
| 591 | batch._params[paramOffset + 3]._int, | ||
| 592 | batch._params[paramOffset + 2]._uint, | ||
| 593 | batch._params[paramOffset + 1]._int, | ||
| 594 | batch.editResource(batch._params[paramOffset + 0]._uint)->_pointer); | ||
| 595 | CHECK_GL_ERROR(); | ||
| 596 | } | ||
| 597 | |||
| 598 | |||
| 599 | void Batch::_glVertexAttribPointer(GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const void *pointer) { | ||
| 600 | ADD_COMMAND(glVertexAttribPointer); | ||
| 601 | |||
| 602 | _params.push_back(cacheResource(pointer)); | ||
| 603 | _params.push_back(stride); | ||
| 604 | _params.push_back(normalized); | ||
| 605 | _params.push_back(type); | ||
| 606 | _params.push_back(size); | ||
| 607 | _params.push_back(index); | ||
| 608 | |||
| 609 | DO_IT_NOW(_glVertexAttribPointer, 6); | ||
| 610 | } | ||
| 611 | void GLBackend::do_glVertexAttribPointer(Batch& batch, uint32 paramOffset) { | ||
| 612 | glVertexAttribPointer( | ||
| 613 | batch._params[paramOffset + 5]._uint, | ||
| 614 | batch._params[paramOffset + 4]._int, | ||
| 615 | batch._params[paramOffset + 3]._uint, | ||
| 616 | batch._params[paramOffset + 2]._uint, | ||
| 617 | batch._params[paramOffset + 1]._int, | ||
| 618 | batch.editResource(batch._params[paramOffset + 0]._uint)->_pointer); | ||
| 619 | CHECK_GL_ERROR(); | ||
| 620 | } | ||
| 621 | |||
| 622 | void Batch::_glEnableVertexAttribArray(GLint location) { | ||
| 623 | ADD_COMMAND(glEnableVertexAttribArray); | ||
| 624 | |||
| 625 | _params.push_back(location); | ||
| 626 | |||
| 627 | DO_IT_NOW(_glEnableVertexAttribArray, 1); | ||
| 628 | } | ||
| 629 | void GLBackend::do_glEnableVertexAttribArray(Batch& batch, uint32 paramOffset) { | ||
| 630 | glEnableVertexAttribArray(batch._params[paramOffset]._uint); | ||
| 631 | CHECK_GL_ERROR(); | ||
| 632 | } | ||
| 633 | |||
| 634 | void Batch::_glDisableVertexAttribArray(GLint location) { | ||
| 635 | ADD_COMMAND(glDisableVertexAttribArray); | ||
| 636 | |||
| 637 | _params.push_back(location); | ||
| 638 | |||
| 639 | DO_IT_NOW(_glDisableVertexAttribArray, 1); | ||
| 640 | } | ||
| 641 | void GLBackend::do_glDisableVertexAttribArray(Batch& batch, uint32 paramOffset) { | ||
| 642 | glDisableVertexAttribArray(batch._params[paramOffset]._uint); | ||
| 643 | CHECK_GL_ERROR(); | ||
| 644 | } | ||
| 645 | |||
| 646 | void Batch::_glColor4f(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha) { | ||
| 647 | ADD_COMMAND(glColor4f); | ||
| 648 | |||
| 649 | _params.push_back(alpha); | ||
| 650 | _params.push_back(blue); | ||
| 651 | _params.push_back(green); | ||
| 652 | _params.push_back(red); | ||
| 653 | |||
| 654 | DO_IT_NOW(_glColor4f, 4); | ||
| 655 | } | ||
| 656 | void GLBackend::do_glColor4f(Batch& batch, uint32 paramOffset) { | ||
| 657 | glColor4f( | ||
| 658 | batch._params[paramOffset + 3]._float, | ||
| 659 | batch._params[paramOffset + 2]._float, | ||
| 660 | batch._params[paramOffset + 1]._float, | ||
| 661 | batch._params[paramOffset + 0]._float); | ||
| 662 | CHECK_GL_ERROR(); | ||
| 663 | } | ||
| 664 | |||
| 665 | void Batch::_glMaterialf(GLenum face, GLenum pname, GLfloat param) { | ||
| 666 | ADD_COMMAND(glMaterialf); | ||
| 667 | |||
| 668 | _params.push_back(param); | ||
| 669 | _params.push_back(pname); | ||
| 670 | _params.push_back(face); | ||
| 671 | |||
| 672 | DO_IT_NOW(_glMaterialf, 3); | ||
| 673 | } | ||
| 674 | void GLBackend::do_glMaterialf(Batch& batch, uint32 paramOffset) { | ||
| 675 | glMaterialf( | ||
| 676 | batch._params[paramOffset + 2]._uint, | ||
| 677 | batch._params[paramOffset + 1]._uint, | ||
| 678 | batch._params[paramOffset + 0]._float); | ||
| 679 | CHECK_GL_ERROR(); | ||
| 680 | } | ||
| 681 | |||
| 682 | void Batch::_glMaterialfv(GLenum face, GLenum pname, const GLfloat *params) { | ||
| 683 | ADD_COMMAND(glMaterialfv); | ||
| 684 | |||
| 685 | _params.push_back(cacheData(4 * sizeof(float), params)); | ||
| 686 | _params.push_back(pname); | ||
| 687 | _params.push_back(face); | ||
| 688 | |||
| 689 | DO_IT_NOW(_glMaterialfv, 3); | ||
| 690 | } | ||
| 691 | void GLBackend::do_glMaterialfv(Batch& batch, uint32 paramOffset) { | ||
| 692 | glMaterialfv( | ||
| 693 | batch._params[paramOffset + 2]._uint, | ||
| 694 | batch._params[paramOffset + 1]._uint, | ||
| 695 | (const GLfloat*)batch.editData(batch._params[paramOffset + 0]._uint)); | ||
| 696 | CHECK_GL_ERROR(); | ||
| 697 | } | ||
| 698 | |||
| 699 | |||
| 700 | GLBackend::BufferObject::~BufferObject() { | ||
| 701 | if (_buffer != 0) { | ||
| 702 | glDeleteBuffers(1, &_buffer); | ||
| 703 | } | ||
| 704 | } | ||
| 705 | |||
| 706 | void GLBackend::syncGPUObject(const Buffer& buffer) { | ||
| 707 | BufferObject* object = Backend::getGPUObject<GLBackend::BufferObject>(buffer); | ||
| 708 | |||
| 709 | if (object && (object->_stamp == buffer.getSysmem().getStamp())) { | ||
| 710 | return; | ||
| 711 | } | ||
| 712 | |||
| 713 | // need to have a gpu object? | ||
| 714 | if (!object) { | ||
| 715 | object = new BufferObject(); | ||
| 716 | glGenBuffers(1, &object->_buffer); | ||
| 717 | Backend::setGPUObject(buffer, object); | ||
| 718 | } | ||
| 719 | |||
| 720 | // Now let's update the content of the bo with the sysmem version | ||
| 721 | // TODO: in the future, be smarter about when to actually upload the glBO version based on the data that did change | ||
| 722 | //if () { | ||
| 723 | glBindBuffer(GL_ARRAY_BUFFER, object->_buffer); | ||
| 724 | glBufferData(GL_ARRAY_BUFFER, buffer.getSysmem().getSize(), buffer.getSysmem().readData(), GL_DYNAMIC_DRAW); | ||
| 725 | glBindBuffer(GL_ARRAY_BUFFER, 0); | ||
| 726 | object->_stamp = buffer.getSysmem().getStamp(); | ||
| 727 | object->_size = buffer.getSysmem().getSize(); | ||
| 728 | //} | ||
| 729 | } | ||
| 730 | |||
| 731 | |||
| 732 | |||
| 733 | GLuint GLBackend::getBufferID(const Buffer& buffer) { | ||
| 734 | GLBackend::syncGPUObject(buffer); | ||
| 735 | return Backend::getGPUObject<GLBackend::BufferObject>(buffer)->_buffer; | ||
| 736 | } | ||