//// Batch.cpp// interface/src/gpu//// Created by Sam Gateau on 10/14/2014.// Copyright 2014 High Fidelity, Inc.//// Distributed under the Apache License, Version 2.0.// See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html//#include "Batch.h" #include <QDebug> #define ADD_COMMAND(call) _commands.push_back(COMMAND_##call); _commandCalls.push_back(&gpu::Batch::do_##call); _commandOffsets.push_back(_params.size()); //#define DO_IT_NOW(call, offset) uint32 __param = _params.size() - (offset); do##call(__param);//#define DO_IT_NOW(call, offset) uint32 __param = _commandOffsets.back(); CommandCall call = _commandCalls.back(); (this->*(call))(__param);//#define DO_IT_NOW(call, offset) runLastCommand();//#define DO_IT_NOW(call, offset) uint32 __param = _params.size() - (offset); runCommand(_commands.size() -1);// do##call(__param);#define DO_IT_NOW(call, offset) using namespace gpu; Batch::Batch() : _commands(), _params(), _resources(), _data(){} Batch::~Batch() {} void Batch::clear() { _commands.clear(); _params.clear(); _resources.clear(); _data.clear();} uint32 Batch::cacheResource(Resource* res) { uint32 offset = _resources.size(); _resources.push_back(ResourceCache(res)); return offset;} uint32 Batch::cacheResource(const void* pointer) { uint32 offset = _resources.size(); _resources.push_back(ResourceCache(pointer)); return offset;} uint32 Batch::cacheData(uint32 size, const void* data) { uint32 offset = _data.size(); uint32 nbBytes = size; _data.resize(offset + nbBytes); memcpy(_data.data() + offset, data, size); return offset;} #define CASE_COMMAND(call) case COMMAND_##call: { do_##call(offset); } break; void Batch::runCommand(Command com, uint32 offset) { switch (com) { CASE_COMMAND(draw); CASE_COMMAND(drawIndexed); CASE_COMMAND(drawInstanced); CASE_COMMAND(drawIndexedInstanced); CASE_COMMAND(glEnable); CASE_COMMAND(glDisable); CASE_COMMAND(glEnableClientState); CASE_COMMAND(glDisableClientState); CASE_COMMAND(glCullFace); CASE_COMMAND(glAlphaFunc); CASE_COMMAND(glDepthFunc); CASE_COMMAND(glDepthMask); CASE_COMMAND(glDepthRange); CASE_COMMAND(glBindBuffer); CASE_COMMAND(glBindTexture); CASE_COMMAND(glActiveTexture); CASE_COMMAND(glDrawBuffers); CASE_COMMAND(glUseProgram); CASE_COMMAND(glUniform1f); CASE_COMMAND(glUniformMatrix4fv); CASE_COMMAND(glMatrixMode); CASE_COMMAND(glPushMatrix); CASE_COMMAND(glPopMatrix); CASE_COMMAND(glMultMatrixf); CASE_COMMAND(glLoadMatrixf); CASE_COMMAND(glLoadIdentity); CASE_COMMAND(glRotatef); CASE_COMMAND(glScalef); CASE_COMMAND(glTranslatef); CASE_COMMAND(glDrawArrays); CASE_COMMAND(glDrawRangeElements); CASE_COMMAND(glColorPointer); CASE_COMMAND(glNormalPointer); CASE_COMMAND(glTexCoordPointer); CASE_COMMAND(glVertexPointer); CASE_COMMAND(glVertexAttribPointer); CASE_COMMAND(glEnableVertexAttribArray); CASE_COMMAND(glDisableVertexAttribArray); CASE_COMMAND(glColor4f); CASE_COMMAND(glMaterialf); CASE_COMMAND(glMaterialfv); }} void Batch::draw( Primitive primitiveType, int nbVertices, int startVertex) { ADD_COMMAND(draw); _params.push_back(startVertex); _params.push_back(nbVertices); _params.push_back(primitiveType);} void Batch::drawIndexed( Primitive primitiveType, int nbIndices, int startIndex) { ADD_COMMAND(drawIndexed); _params.push_back(startIndex); _params.push_back(nbIndices); _params.push_back(primitiveType);} void Batch::drawInstanced( uint32 nbInstances, Primitive primitiveType, int nbVertices, int startVertex, int startInstance) { ADD_COMMAND(drawInstanced); _params.push_back(startInstance); _params.push_back(startVertex); _params.push_back(nbVertices); _params.push_back(primitiveType); _params.push_back(nbInstances);} void Batch::drawIndexedInstanced( uint32 nbInstances, Primitive primitiveType, int nbIndices, int startIndex, int startInstance) { ADD_COMMAND(drawIndexedInstanced); _params.push_back(startInstance); _params.push_back(startIndex); _params.push_back(nbIndices); _params.push_back(primitiveType); _params.push_back(nbInstances);} // TODO: As long as we have gl calls explicitely issued from interface// code, we need to be able to record and batch these calls. THe long // term strategy is to get rid of any GL calls in favor of the HIFI GPU API void Batch::_glEnable(GLenum cap) { ADD_COMMAND(glEnable); _params.push_back(cap); DO_IT_NOW(_glEnable, 1);}void Batch::do_glEnable(uint32& paramOffset) { glEnable(_params[paramOffset++]._uint);} void Batch::_glDisable(GLenum cap) { ADD_COMMAND(glDisable); _params.push_back(cap); DO_IT_NOW(_glDisable, 1);}void Batch::do_glDisable(uint32& paramOffset) { glDisable(_params[paramOffset++]._uint);} void Batch::_glEnableClientState(GLenum array) { ADD_COMMAND(glEnableClientState); _params.push_back(array); DO_IT_NOW(_glEnableClientState, 1 );}void Batch::do_glEnableClientState(uint32& paramOffset) { glEnableClientState(_params[paramOffset++]._uint);} void Batch::_glDisableClientState(GLenum array) { ADD_COMMAND(glDisableClientState); _params.push_back(array); DO_IT_NOW(_glDisableClientState, 1);}void Batch::do_glDisableClientState(uint32& paramOffset) { glDisableClientState(_params[paramOffset++]._uint);} void Batch::_glCullFace(GLenum mode) { ADD_COMMAND(glCullFace); _params.push_back(mode); DO_IT_NOW(_glCullFace, 1);}void Batch::do_glCullFace(uint32& paramOffset) { glCullFace(_params[paramOffset++]._uint);} void Batch::_glAlphaFunc(GLenum func, GLclampf ref) { ADD_COMMAND(glAlphaFunc); _params.push_back(ref); _params.push_back(func); DO_IT_NOW(_glAlphaFunc, 2);}void Batch::do_glAlphaFunc(uint32& paramOffset) { glAlphaFunc(_params[paramOffset++]._uint, _params[paramOffset++]._float);} void Batch::_glDepthFunc(GLenum func) { ADD_COMMAND(glDepthFunc); _params.push_back(func); DO_IT_NOW(_glDepthFunc, 1);}void Batch::do_glDepthFunc(uint32& paramOffset) { glDepthFunc(_params[paramOffset++]._uint);} void Batch::_glDepthMask(GLboolean flag) { ADD_COMMAND(glDepthMask); _params.push_back(flag); DO_IT_NOW(_glDepthMask, 1);}void Batch::do_glDepthMask(uint32& paramOffset) { glDepthMask(_params[paramOffset++]._uint);} void Batch::_glDepthRange(GLclampd zNear, GLclampd zFar) { ADD_COMMAND(glDepthRange); _params.push_back(zFar); _params.push_back(zNear); DO_IT_NOW(_glDepthRange, 2);}void Batch::do_glDepthRange(uint32& paramOffset) { glDepthRange(_params[paramOffset++]._double, _params[paramOffset++]._double);} void Batch::_glBindBuffer(GLenum target, GLuint buffer) { ADD_COMMAND(glBindBuffer); _params.push_back(buffer); _params.push_back(target); DO_IT_NOW(_glBindBuffer, 2);}void Batch::do_glBindBuffer(uint32& paramOffset) { glBindBuffer(_params[paramOffset++]._uint, _params[paramOffset++]._uint);} void Batch::_glBindTexture(GLenum target, GLuint texture) { ADD_COMMAND(glBindTexture); _params.push_back(texture); _params.push_back(target); DO_IT_NOW(_glBindTexture, 2);}void Batch::do_glBindTexture(uint32& paramOffset) { glBindTexture(_params[paramOffset++]._uint, _params[paramOffset++]._uint);} void Batch::_glActiveTexture(GLenum texture) { ADD_COMMAND(glActiveTexture); _params.push_back(texture); DO_IT_NOW(_glActiveTexture, 1);}void Batch::do_glActiveTexture(uint32& paramOffset) { glActiveTexture(_params[paramOffset++]._uint);} void Batch::_glDrawBuffers(GLsizei n, const GLenum* bufs) { ADD_COMMAND(glDrawBuffers); _params.push_back(cacheData(n * sizeof(GLenum), bufs)); _params.push_back(n); DO_IT_NOW(_glDrawBuffers, 2);}void Batch::do_glDrawBuffers(uint32& paramOffset) { glDrawBuffers(_params[paramOffset++]._uint, (const GLenum*) editData(_params[paramOffset++]._uint));} void Batch::_glUseProgram(GLuint program) { ADD_COMMAND(glUseProgram); _params.push_back(program); DO_IT_NOW(_glUseProgram, 1);}void Batch::do_glUseProgram(uint32& paramOffset) { glUseProgram(_params[paramOffset++]._uint);} void Batch::_glUniform1f(GLint location, GLfloat v0) { ADD_COMMAND(glUniform1f); _params.push_back(v0); _params.push_back(location); DO_IT_NOW(_glUniform1f, 1);}void Batch::do_glUniform1f(uint32& paramOffset) { glUniform1f(_params[paramOffset++]._int, _params[paramOffset++]._float);} void Batch::_glUniformMatrix4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) { ADD_COMMAND(glUniformMatrix4fv); const int MATRIX4_SIZE = 16 * sizeof(float); _params.push_back(cacheData(count * MATRIX4_SIZE, value)); _params.push_back(transpose); _params.push_back(count); _params.push_back(location); DO_IT_NOW(_glUniformMatrix4fv, 4);}void Batch::do_glUniformMatrix4fv(uint32& paramOffset) { glUniformMatrix4fv(_params[paramOffset++]._int, _params[paramOffset++]._uint, _params[paramOffset++]._uint, (const GLfloat*) editData(_params[paramOffset++]._uint));} void Batch::_glMatrixMode(GLenum mode) { ADD_COMMAND(glMatrixMode); _params.push_back(mode); DO_IT_NOW(_glMatrixMode, 1);}void Batch::do_glMatrixMode(uint32& paramOffset) { glMatrixMode(_params[paramOffset++]._uint);} void Batch::_glPushMatrix() { ADD_COMMAND(glPushMatrix); DO_IT_NOW(_glPushMatrix, 0);}void Batch::do_glPushMatrix(uint32& paramOffset) { glPushMatrix();} void Batch::_glPopMatrix() { ADD_COMMAND(glPopMatrix); DO_IT_NOW(_glPopMatrix, 0);}void Batch::do_glPopMatrix(uint32& paramOffset) { glPopMatrix();} void Batch::_glMultMatrixf(const GLfloat *m) { ADD_COMMAND(glMultMatrixf); const int MATRIX4_SIZE = 16 * sizeof(float); _params.push_back(cacheData(MATRIX4_SIZE, m)); DO_IT_NOW(_glMultMatrixf, 1);}void Batch::do_glMultMatrixf(uint32& paramOffset) { glMultMatrixf((const GLfloat*) editData(_params[paramOffset++]._uint));} void Batch::_glLoadMatrixf(const GLfloat *m) { ADD_COMMAND(glLoadMatrixf); const int MATRIX4_SIZE = 16 * sizeof(float); _params.push_back(cacheData(MATRIX4_SIZE, m)); DO_IT_NOW(_glLoadMatrixf, 1);}void Batch::do_glLoadMatrixf(uint32& paramOffset) { glLoadMatrixf((const GLfloat*)editData(_params[paramOffset++]._uint));} void Batch::_glLoadIdentity(void) { ADD_COMMAND(glLoadIdentity); DO_IT_NOW(_glLoadIdentity, 0);}void Batch::do_glLoadIdentity(uint32& paramOffset) { glLoadIdentity();} void Batch::_glRotatef(GLfloat angle, GLfloat x, GLfloat y, GLfloat z) { ADD_COMMAND(glRotatef); _params.push_back(z); _params.push_back(y); _params.push_back(x); _params.push_back(angle); DO_IT_NOW(_glRotatef, 4);}void Batch::do_glRotatef(uint32& paramOffset) { glRotatef(_params[paramOffset++]._float, _params[paramOffset++]._float, _params[paramOffset++]._float, _params[paramOffset++]._float);} void Batch::_glScalef(GLfloat x, GLfloat y, GLfloat z) { ADD_COMMAND(glScalef); _params.push_back(z); _params.push_back(y); _params.push_back(x); DO_IT_NOW(_glScalef, 3);}void Batch::do_glScalef(uint32& paramOffset) { glScalef(_params[paramOffset++]._float, _params[paramOffset++]._float, _params[paramOffset++]._float);} void Batch::_glTranslatef(GLfloat x, GLfloat y, GLfloat z) { ADD_COMMAND(glTranslatef); _params.push_back(z); _params.push_back(y); _params.push_back(x); DO_IT_NOW(_glTranslatef, 3);}void Batch::do_glTranslatef(uint32& paramOffset) { glTranslatef(_params[paramOffset++]._float, _params[paramOffset++]._float, _params[paramOffset++]._float);} void Batch::_glDrawArrays(GLenum mode, GLint first, GLsizei count) { ADD_COMMAND(glDrawArrays); _params.push_back(count); _params.push_back(first); _params.push_back(mode); DO_IT_NOW(_glDrawArrays, 3);}void Batch::do_glDrawArrays(uint32& paramOffset) { glDrawArrays(_params[paramOffset++]._uint, _params[paramOffset++]._int, _params[paramOffset++]._int);} void Batch::_glDrawRangeElements(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const void *indices) { ADD_COMMAND(glDrawRangeElements); _params.push_back(cacheResource(indices)); _params.push_back(type); _params.push_back(count); _params.push_back(end); _params.push_back(start); _params.push_back(mode); //do_glDrawRangeElements(_commandOffsets.back()); // runCommand(_commands.size() - 1); DO_IT_NOW(_glDrawRangeElements, 6);}void Batch::do_glDrawRangeElements(uint32& paramOffset) { glDrawRangeElements(_params[paramOffset++]._uint, _params[paramOffset++]._uint, _params[paramOffset++]._uint, _params[paramOffset++]._int, _params[paramOffset++]._uint, editResource(_params[paramOffset++]._uint)->_pointer);} void Batch::_glColorPointer(GLint size, GLenum type, GLsizei stride, const void *pointer) { ADD_COMMAND(glColorPointer); _params.push_back(cacheResource(pointer)); _params.push_back(stride); _params.push_back(type); _params.push_back(size); DO_IT_NOW(_glColorPointer, 4);}void Batch::do_glColorPointer(uint32& paramOffset) { glColorPointer(_params[paramOffset++]._int, _params[paramOffset++]._uint, _params[paramOffset++]._int, editResource(_params[paramOffset++]._uint)->_pointer);} void Batch::_glNormalPointer(GLenum type, GLsizei stride, const void *pointer) { ADD_COMMAND(glNormalPointer); _params.push_back(cacheResource(pointer)); _params.push_back(stride); _params.push_back(type); DO_IT_NOW(_glNormalPointer, 3);}void Batch::do_glNormalPointer(uint32& paramOffset) { glNormalPointer(_params[paramOffset++]._uint, _params[paramOffset++]._int,Lines 1–500 of 623. Load more
// // Batch.cpp // interface/src/gpu // // Created by Sam Gateau on 10/14/2014. // Copyright 2014 High Fidelity, Inc. // // Distributed under the Apache License, Version 2.0. // See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html // #include "Batch.h" #include <QDebug> #define ADD_COMMAND(call) _commands.push_back(COMMAND_##call); _commandCalls.push_back(&gpu::Batch::do_##call); _commandOffsets.push_back(_params.size()); //#define DO_IT_NOW(call, offset) uint32 __param = _params.size() - (offset); do##call(__param); //#define DO_IT_NOW(call, offset) uint32 __param = _commandOffsets.back(); CommandCall call = _commandCalls.back(); (this->*(call))(__param); //#define DO_IT_NOW(call, offset) runLastCommand(); //#define DO_IT_NOW(call, offset) uint32 __param = _params.size() - (offset); runCommand(_commands.size() -1);// do##call(__param); #define DO_IT_NOW(call, offset) using namespace gpu; Batch::Batch() : _commands(), _params(), _resources(), _data(){ } Batch::~Batch() { } void Batch::clear() { _commands.clear(); _params.clear(); _resources.clear(); _data.clear(); } uint32 Batch::cacheResource(Resource* res) { uint32 offset = _resources.size(); _resources.push_back(ResourceCache(res)); return offset; } uint32 Batch::cacheResource(const void* pointer) { uint32 offset = _resources.size(); _resources.push_back(ResourceCache(pointer)); return offset; } uint32 Batch::cacheData(uint32 size, const void* data) { uint32 offset = _data.size(); uint32 nbBytes = size; _data.resize(offset + nbBytes); memcpy(_data.data() + offset, data, size); return offset; } #define CASE_COMMAND(call) case COMMAND_##call: { do_##call(offset); } break; void Batch::runCommand(Command com, uint32 offset) { switch (com) { CASE_COMMAND(draw); CASE_COMMAND(drawIndexed); CASE_COMMAND(drawInstanced); CASE_COMMAND(drawIndexedInstanced); CASE_COMMAND(glEnable); CASE_COMMAND(glDisable); CASE_COMMAND(glEnableClientState); CASE_COMMAND(glDisableClientState); CASE_COMMAND(glCullFace); CASE_COMMAND(glAlphaFunc); CASE_COMMAND(glDepthFunc); CASE_COMMAND(glDepthMask); CASE_COMMAND(glDepthRange); CASE_COMMAND(glBindBuffer); CASE_COMMAND(glBindTexture); CASE_COMMAND(glActiveTexture); CASE_COMMAND(glDrawBuffers); CASE_COMMAND(glUseProgram); CASE_COMMAND(glUniform1f); CASE_COMMAND(glUniformMatrix4fv); CASE_COMMAND(glMatrixMode); CASE_COMMAND(glPushMatrix); CASE_COMMAND(glPopMatrix); CASE_COMMAND(glMultMatrixf); CASE_COMMAND(glLoadMatrixf); CASE_COMMAND(glLoadIdentity); CASE_COMMAND(glRotatef); CASE_COMMAND(glScalef); CASE_COMMAND(glTranslatef); CASE_COMMAND(glDrawArrays); CASE_COMMAND(glDrawRangeElements); CASE_COMMAND(glColorPointer); CASE_COMMAND(glNormalPointer); CASE_COMMAND(glTexCoordPointer); CASE_COMMAND(glVertexPointer); CASE_COMMAND(glVertexAttribPointer); CASE_COMMAND(glEnableVertexAttribArray); CASE_COMMAND(glDisableVertexAttribArray); CASE_COMMAND(glColor4f); CASE_COMMAND(glMaterialf); CASE_COMMAND(glMaterialfv); } } void Batch::draw( Primitive primitiveType, int nbVertices, int startVertex) { ADD_COMMAND(draw); _params.push_back(startVertex); _params.push_back(nbVertices); _params.push_back(primitiveType); } void Batch::drawIndexed( Primitive primitiveType, int nbIndices, int startIndex) { ADD_COMMAND(drawIndexed); _params.push_back(startIndex); _params.push_back(nbIndices); _params.push_back(primitiveType); } void Batch::drawInstanced( uint32 nbInstances, Primitive primitiveType, int nbVertices, int startVertex, int startInstance) { ADD_COMMAND(drawInstanced); _params.push_back(startInstance); _params.push_back(startVertex); _params.push_back(nbVertices); _params.push_back(primitiveType); _params.push_back(nbInstances); } void Batch::drawIndexedInstanced( uint32 nbInstances, Primitive primitiveType, int nbIndices, int startIndex, int startInstance) { ADD_COMMAND(drawIndexedInstanced); _params.push_back(startInstance); _params.push_back(startIndex); _params.push_back(nbIndices); _params.push_back(primitiveType); _params.push_back(nbInstances); } // TODO: As long as we have gl calls explicitely issued from interface // code, we need to be able to record and batch these calls. THe long // term strategy is to get rid of any GL calls in favor of the HIFI GPU API void Batch::_glEnable(GLenum cap) { ADD_COMMAND(glEnable); _params.push_back(cap); DO_IT_NOW(_glEnable, 1); } void Batch::do_glEnable(uint32& paramOffset) { glEnable(_params[paramOffset++]._uint); } void Batch::_glDisable(GLenum cap) { ADD_COMMAND(glDisable); _params.push_back(cap); DO_IT_NOW(_glDisable, 1); } void Batch::do_glDisable(uint32& paramOffset) { glDisable(_params[paramOffset++]._uint); } void Batch::_glEnableClientState(GLenum array) { ADD_COMMAND(glEnableClientState); _params.push_back(array); DO_IT_NOW(_glEnableClientState, 1 ); } void Batch::do_glEnableClientState(uint32& paramOffset) { glEnableClientState(_params[paramOffset++]._uint); } void Batch::_glDisableClientState(GLenum array) { ADD_COMMAND(glDisableClientState); _params.push_back(array); DO_IT_NOW(_glDisableClientState, 1); } void Batch::do_glDisableClientState(uint32& paramOffset) { glDisableClientState(_params[paramOffset++]._uint); } void Batch::_glCullFace(GLenum mode) { ADD_COMMAND(glCullFace); _params.push_back(mode); DO_IT_NOW(_glCullFace, 1); } void Batch::do_glCullFace(uint32& paramOffset) { glCullFace(_params[paramOffset++]._uint); } void Batch::_glAlphaFunc(GLenum func, GLclampf ref) { ADD_COMMAND(glAlphaFunc); _params.push_back(ref); _params.push_back(func); DO_IT_NOW(_glAlphaFunc, 2); } void Batch::do_glAlphaFunc(uint32& paramOffset) { glAlphaFunc(_params[paramOffset++]._uint, _params[paramOffset++]._float); } void Batch::_glDepthFunc(GLenum func) { ADD_COMMAND(glDepthFunc); _params.push_back(func); DO_IT_NOW(_glDepthFunc, 1); } void Batch::do_glDepthFunc(uint32& paramOffset) { glDepthFunc(_params[paramOffset++]._uint); } void Batch::_glDepthMask(GLboolean flag) { ADD_COMMAND(glDepthMask); _params.push_back(flag); DO_IT_NOW(_glDepthMask, 1); } void Batch::do_glDepthMask(uint32& paramOffset) { glDepthMask(_params[paramOffset++]._uint); } void Batch::_glDepthRange(GLclampd zNear, GLclampd zFar) { ADD_COMMAND(glDepthRange); _params.push_back(zFar); _params.push_back(zNear); DO_IT_NOW(_glDepthRange, 2); } void Batch::do_glDepthRange(uint32& paramOffset) { glDepthRange(_params[paramOffset++]._double, _params[paramOffset++]._double); } void Batch::_glBindBuffer(GLenum target, GLuint buffer) { ADD_COMMAND(glBindBuffer); _params.push_back(buffer); _params.push_back(target); DO_IT_NOW(_glBindBuffer, 2); } void Batch::do_glBindBuffer(uint32& paramOffset) { glBindBuffer(_params[paramOffset++]._uint, _params[paramOffset++]._uint); } void Batch::_glBindTexture(GLenum target, GLuint texture) { ADD_COMMAND(glBindTexture); _params.push_back(texture); _params.push_back(target); DO_IT_NOW(_glBindTexture, 2); } void Batch::do_glBindTexture(uint32& paramOffset) { glBindTexture(_params[paramOffset++]._uint, _params[paramOffset++]._uint); } void Batch::_glActiveTexture(GLenum texture) { ADD_COMMAND(glActiveTexture); _params.push_back(texture); DO_IT_NOW(_glActiveTexture, 1); } void Batch::do_glActiveTexture(uint32& paramOffset) { glActiveTexture(_params[paramOffset++]._uint); } void Batch::_glDrawBuffers(GLsizei n, const GLenum* bufs) { ADD_COMMAND(glDrawBuffers); _params.push_back(cacheData(n * sizeof(GLenum), bufs)); _params.push_back(n); DO_IT_NOW(_glDrawBuffers, 2); } void Batch::do_glDrawBuffers(uint32& paramOffset) { glDrawBuffers(_params[paramOffset++]._uint, (const GLenum*) editData(_params[paramOffset++]._uint)); } void Batch::_glUseProgram(GLuint program) { ADD_COMMAND(glUseProgram); _params.push_back(program); DO_IT_NOW(_glUseProgram, 1); } void Batch::do_glUseProgram(uint32& paramOffset) { glUseProgram(_params[paramOffset++]._uint); } void Batch::_glUniform1f(GLint location, GLfloat v0) { ADD_COMMAND(glUniform1f); _params.push_back(v0); _params.push_back(location); DO_IT_NOW(_glUniform1f, 1); } void Batch::do_glUniform1f(uint32& paramOffset) { glUniform1f(_params[paramOffset++]._int, _params[paramOffset++]._float); } void Batch::_glUniformMatrix4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) { ADD_COMMAND(glUniformMatrix4fv); const int MATRIX4_SIZE = 16 * sizeof(float); _params.push_back(cacheData(count * MATRIX4_SIZE, value)); _params.push_back(transpose); _params.push_back(count); _params.push_back(location); DO_IT_NOW(_glUniformMatrix4fv, 4); } void Batch::do_glUniformMatrix4fv(uint32& paramOffset) { glUniformMatrix4fv(_params[paramOffset++]._int, _params[paramOffset++]._uint, _params[paramOffset++]._uint, (const GLfloat*) editData(_params[paramOffset++]._uint)); } void Batch::_glMatrixMode(GLenum mode) { ADD_COMMAND(glMatrixMode); _params.push_back(mode); DO_IT_NOW(_glMatrixMode, 1); } void Batch::do_glMatrixMode(uint32& paramOffset) { glMatrixMode(_params[paramOffset++]._uint); } void Batch::_glPushMatrix() { ADD_COMMAND(glPushMatrix); DO_IT_NOW(_glPushMatrix, 0); } void Batch::do_glPushMatrix(uint32& paramOffset) { glPushMatrix(); } void Batch::_glPopMatrix() { ADD_COMMAND(glPopMatrix); DO_IT_NOW(_glPopMatrix, 0); } void Batch::do_glPopMatrix(uint32& paramOffset) { glPopMatrix(); } void Batch::_glMultMatrixf(const GLfloat *m) { ADD_COMMAND(glMultMatrixf); const int MATRIX4_SIZE = 16 * sizeof(float); _params.push_back(cacheData(MATRIX4_SIZE, m)); DO_IT_NOW(_glMultMatrixf, 1); } void Batch::do_glMultMatrixf(uint32& paramOffset) { glMultMatrixf((const GLfloat*) editData(_params[paramOffset++]._uint)); } void Batch::_glLoadMatrixf(const GLfloat *m) { ADD_COMMAND(glLoadMatrixf); const int MATRIX4_SIZE = 16 * sizeof(float); _params.push_back(cacheData(MATRIX4_SIZE, m)); DO_IT_NOW(_glLoadMatrixf, 1); } void Batch::do_glLoadMatrixf(uint32& paramOffset) { glLoadMatrixf((const GLfloat*)editData(_params[paramOffset++]._uint)); } void Batch::_glLoadIdentity(void) { ADD_COMMAND(glLoadIdentity); DO_IT_NOW(_glLoadIdentity, 0); } void Batch::do_glLoadIdentity(uint32& paramOffset) { glLoadIdentity(); } void Batch::_glRotatef(GLfloat angle, GLfloat x, GLfloat y, GLfloat z) { ADD_COMMAND(glRotatef); _params.push_back(z); _params.push_back(y); _params.push_back(x); _params.push_back(angle); DO_IT_NOW(_glRotatef, 4); } void Batch::do_glRotatef(uint32& paramOffset) { glRotatef(_params[paramOffset++]._float, _params[paramOffset++]._float, _params[paramOffset++]._float, _params[paramOffset++]._float); } void Batch::_glScalef(GLfloat x, GLfloat y, GLfloat z) { ADD_COMMAND(glScalef); _params.push_back(z); _params.push_back(y); _params.push_back(x); DO_IT_NOW(_glScalef, 3); } void Batch::do_glScalef(uint32& paramOffset) { glScalef(_params[paramOffset++]._float, _params[paramOffset++]._float, _params[paramOffset++]._float); } void Batch::_glTranslatef(GLfloat x, GLfloat y, GLfloat z) { ADD_COMMAND(glTranslatef); _params.push_back(z); _params.push_back(y); _params.push_back(x); DO_IT_NOW(_glTranslatef, 3); } void Batch::do_glTranslatef(uint32& paramOffset) { glTranslatef(_params[paramOffset++]._float, _params[paramOffset++]._float, _params[paramOffset++]._float); } void Batch::_glDrawArrays(GLenum mode, GLint first, GLsizei count) { ADD_COMMAND(glDrawArrays); _params.push_back(count); _params.push_back(first); _params.push_back(mode); DO_IT_NOW(_glDrawArrays, 3); } void Batch::do_glDrawArrays(uint32& paramOffset) { glDrawArrays(_params[paramOffset++]._uint, _params[paramOffset++]._int, _params[paramOffset++]._int); } void Batch::_glDrawRangeElements(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const void *indices) { ADD_COMMAND(glDrawRangeElements); _params.push_back(cacheResource(indices)); _params.push_back(type); _params.push_back(count); _params.push_back(end); _params.push_back(start); _params.push_back(mode); //do_glDrawRangeElements(_commandOffsets.back()); // runCommand(_commands.size() - 1); DO_IT_NOW(_glDrawRangeElements, 6); } void Batch::do_glDrawRangeElements(uint32& paramOffset) { glDrawRangeElements(_params[paramOffset++]._uint, _params[paramOffset++]._uint, _params[paramOffset++]._uint, _params[paramOffset++]._int, _params[paramOffset++]._uint, editResource(_params[paramOffset++]._uint)->_pointer); } void Batch::_glColorPointer(GLint size, GLenum type, GLsizei stride, const void *pointer) { ADD_COMMAND(glColorPointer); _params.push_back(cacheResource(pointer)); _params.push_back(stride); _params.push_back(type); _params.push_back(size); DO_IT_NOW(_glColorPointer, 4); } void Batch::do_glColorPointer(uint32& paramOffset) { glColorPointer(_params[paramOffset++]._int, _params[paramOffset++]._uint, _params[paramOffset++]._int, editResource(_params[paramOffset++]._uint)->_pointer); } void Batch::_glNormalPointer(GLenum type, GLsizei stride, const void *pointer) { ADD_COMMAND(glNormalPointer); _params.push_back(cacheResource(pointer)); _params.push_back(stride); _params.push_back(type); DO_IT_NOW(_glNormalPointer, 3); } void Batch::do_glNormalPointer(uint32& paramOffset) { glNormalPointer(_params[paramOffset++]._uint, _params[paramOffset++]._int,