diff --git a/interface/src/gpu/Batch.cpp b/interface/src/gpu/Batch.cpp deleted file mode 100644 index 8a094d1024..0000000000 --- a/interface/src/gpu/Batch.cpp +++ /dev/null @@ -1,624 +0,0 @@ -// -// 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 - -#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) runLastCommand(); -#define DO_IT_NOW(call, offset) - -using namespace gpu; - -Batch::Batch() : - _commands(), - _commandCalls(), - _commandOffsets(), - _params(), - _resources(), - _data(){ -} - -Batch::~Batch() { -} - -void Batch::clear() { - _commands.clear(); - _commandCalls.clear(); - _commandOffsets.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, - editResource(_params[paramOffset++]._uint)->_pointer); -} - -void Batch::_glTexCoordPointer(GLint size, GLenum type, GLsizei stride, const void *pointer) { - ADD_COMMAND(glTexCoordPointer); - - _params.push_back(cacheResource(pointer)); - _params.push_back(stride); - _params.push_back(type); - _params.push_back(size); - - DO_IT_NOW(_glTexCoordPointer, 4); -} -void Batch::do_glTexCoordPointer(uint32& paramOffset) { - glTexCoordPointer(_params[paramOffset++]._int, _params[paramOffset++]._uint, - _params[paramOffset++]._int, editResource(_params[paramOffset++]._uint)->_pointer); -} - -void Batch::_glVertexPointer(GLint size, GLenum type, GLsizei stride, const void *pointer) { - ADD_COMMAND(glVertexPointer); - - _params.push_back(cacheResource(pointer)); - _params.push_back(stride); - _params.push_back(type); - _params.push_back(size); - - DO_IT_NOW(_glVertexPointer, 4); -} -void Batch::do_glVertexPointer(uint32& paramOffset) { - glVertexPointer(_params[paramOffset++]._int, _params[paramOffset++]._uint, - _params[paramOffset++]._int, editResource(_params[paramOffset++]._uint)->_pointer); -} - - -void Batch::_glVertexAttribPointer(GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const void *pointer) { - ADD_COMMAND(glVertexAttribPointer); - - _params.push_back(cacheResource(pointer)); - _params.push_back(stride); - _params.push_back(normalized); - _params.push_back(type); - _params.push_back(size); - _params.push_back(index); - - DO_IT_NOW(_glVertexAttribPointer, 6); -} -void Batch::do_glVertexAttribPointer(uint32& paramOffset) { - glVertexAttribPointer(_params[paramOffset++]._uint, _params[paramOffset++]._int, - _params[paramOffset++]._uint, _params[paramOffset++]._uint, - _params[paramOffset++]._int, editResource(_params[paramOffset++]._uint)->_pointer); -} - - - -void Batch::_glEnableVertexAttribArray(GLint location) { - ADD_COMMAND(glEnableVertexAttribArray); - - _params.push_back(location); - - DO_IT_NOW(_glEnableVertexAttribArray, 1); -} -void Batch::do_glEnableVertexAttribArray(uint32& paramOffset) { - glEnableVertexAttribArray(_params[paramOffset++]._uint); -} - -void Batch::_glDisableVertexAttribArray(GLint location) { - ADD_COMMAND(glDisableVertexAttribArray); - - _params.push_back(location); - - DO_IT_NOW(_glDisableVertexAttribArray, 1); -} -void Batch::do_glDisableVertexAttribArray(uint32& paramOffset) { - glDisableVertexAttribArray(_params[paramOffset++]._uint); -} - -void Batch::_glColor4f(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha) { - ADD_COMMAND(glColor4f); - - _params.push_back(alpha); - _params.push_back(blue); - _params.push_back(green); - _params.push_back(red); - - DO_IT_NOW(_glColor4f, 4); -} -void Batch::do_glColor4f(uint32& paramOffset) { - glColor4f(_params[paramOffset++]._float, _params[paramOffset++]._float, _params[paramOffset++]._float, _params[paramOffset++]._float); -} - -void Batch::_glMaterialf(GLenum face, GLenum pname, GLfloat param) { - ADD_COMMAND(glMaterialf); - - _params.push_back(param); - _params.push_back(pname); - _params.push_back(face); - - DO_IT_NOW(_glMaterialf, 3); -} -void Batch::do_glMaterialf(uint32& paramOffset) { - glMaterialf(_params[paramOffset++]._uint, _params[paramOffset++]._uint, _params[paramOffset++]._float); -} - -void Batch::_glMaterialfv(GLenum face, GLenum pname, const GLfloat *params) { - ADD_COMMAND(glMaterialfv); - - _params.push_back(cacheData(4 * sizeof(float), params)); - _params.push_back(pname); - _params.push_back(face); - - DO_IT_NOW(_glMaterialfv, 3); -} -void Batch::do_glMaterialfv(uint32& paramOffset) { - glMaterialfv(_params[paramOffset++]._uint, _params[paramOffset++]._uint, (const GLfloat*) editData(_params[paramOffset++]._uint)); -} - - - -void backend::renderBatch(Batch& batch) { - for (int i = 0; i < batch._commands.size(); i++) { - batch.runCommand(i); - } -} diff --git a/interface/src/gpu/Batch.h b/interface/src/gpu/Batch.h deleted file mode 100644 index 60c9c2d645..0000000000 --- a/interface/src/gpu/Batch.h +++ /dev/null @@ -1,316 +0,0 @@ -// -// Batch.h -// 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 -// -#ifndef hifi_gpu_Batch_h -#define hifi_gpu_Batch_h - -#include -#include "InterfaceConfig.h" - -#include - -namespace gpu { - -class Batch; -// TODO: move the backend namespace into dedicated files, for now we keep it close to the gpu objects definition for convenience -namespace backend { - - void renderBatch(Batch& batch); -}; - -class Buffer; -class Resource; -typedef int Stamp; -typedef unsigned int uint32; -typedef int int32; - -enum Primitive { - PRIMITIVE_POINTS = 0, - PRIMITIVE_LINES, - PRIMITIVE_LINE_STRIP, - PRIMITIVE_TRIANGLES, - PRIMITIVE_TRIANGLE_STRIP, - PRIMITIVE_QUADS, -}; - -class Batch { -public: - - Batch(); - Batch(const Batch& batch); - ~Batch(); - - void clear(); - - void draw(Primitive primitiveType, int nbVertices, int startVertex = 0); - void drawIndexed(Primitive primitiveType, int nbIndices, int startIndex = 0); - void drawInstanced(uint32 nbInstances, Primitive primitiveType, int nbVertices, int startVertex = 0, int startInstance = 0); - void drawIndexedInstanced(uint32 nbInstances, Primitive primitiveType, int nbIndices, int startIndex = 0, int startInstance = 0); - - // 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 _glEnable(GLenum cap); - void _glDisable(GLenum cap); - - void _glEnableClientState(GLenum array); - void _glDisableClientState(GLenum array); - - void _glCullFace(GLenum mode); - void _glAlphaFunc(GLenum func, GLclampf ref); - - void _glDepthFunc(GLenum func); - void _glDepthMask(GLboolean flag); - void _glDepthRange(GLclampd zNear, GLclampd zFar); - - void _glBindBuffer(GLenum target, GLuint buffer); - - void _glBindTexture(GLenum target, GLuint texture); - void _glActiveTexture(GLenum texture); - - void _glDrawBuffers(GLsizei n, const GLenum* bufs); - - void _glUseProgram(GLuint program); - void _glUniform1f(GLint location, GLfloat v0); - void _glUniformMatrix4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value); - - void _glMatrixMode(GLenum mode); - void _glPushMatrix(); - void _glPopMatrix(); - void _glMultMatrixf(const GLfloat *m); - void _glLoadMatrixf(const GLfloat *m); - void _glLoadIdentity(void); - void _glRotatef(GLfloat angle, GLfloat x, GLfloat y, GLfloat z); - void _glScalef(GLfloat x, GLfloat y, GLfloat z); - void _glTranslatef(GLfloat x, GLfloat y, GLfloat z); - - void _glDrawArrays(GLenum mode, GLint first, GLsizei count); - void _glDrawRangeElements(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const void *indices); - - void _glColorPointer(GLint size, GLenum type, GLsizei stride, const void *pointer); - void _glNormalPointer(GLenum type, GLsizei stride, const void *pointer); - void _glTexCoordPointer(GLint size, GLenum type, GLsizei stride, const void *pointer); - void _glVertexPointer(GLint size, GLenum type, GLsizei stride, const void *pointer); - - void _glVertexAttribPointer(GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const void *pointer); - void _glEnableVertexAttribArray(GLint location); - void _glDisableVertexAttribArray(GLint location); - - void _glColor4f(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha); - - void _glMaterialf(GLenum face, GLenum pname, GLfloat param); - void _glMaterialfv(GLenum face, GLenum pname, const GLfloat *params); - - -protected: - - enum Command { - COMMAND_draw = 0, - COMMAND_drawIndexed, - COMMAND_drawInstanced, - COMMAND_drawIndexedInstanced, - - COMMAND_SET_PIPE_STATE, - COMMAND_SET_VIEWPORT, - COMMAND_SET_FRAMEBUFFER, - COMMAND_SET_RESOURCE, - COMMAND_SET_VERTEX_STREAM, - COMMAND_SET_INDEX_STREAM, - - // 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 - COMMAND_glEnable, - COMMAND_glDisable, - - COMMAND_glEnableClientState, - COMMAND_glDisableClientState, - - COMMAND_glCullFace, - COMMAND_glAlphaFunc, - - COMMAND_glDepthFunc, - COMMAND_glDepthMask, - COMMAND_glDepthRange, - - COMMAND_glBindBuffer, - - COMMAND_glBindTexture, - COMMAND_glActiveTexture, - - COMMAND_glDrawBuffers, - - COMMAND_glUseProgram, - COMMAND_glUniform1f, - COMMAND_glUniformMatrix4fv, - - COMMAND_glMatrixMode, - COMMAND_glPushMatrix, - COMMAND_glPopMatrix, - COMMAND_glMultMatrixf, - COMMAND_glLoadMatrixf, - COMMAND_glLoadIdentity, - COMMAND_glRotatef, - COMMAND_glScalef, - COMMAND_glTranslatef, - - COMMAND_glDrawArrays, - COMMAND_glDrawRangeElements, - - COMMAND_glColorPointer, - COMMAND_glNormalPointer, - COMMAND_glTexCoordPointer, - COMMAND_glVertexPointer, - - COMMAND_glVertexAttribPointer, - COMMAND_glEnableVertexAttribArray, - COMMAND_glDisableVertexAttribArray, - - COMMAND_glColor4f, - - COMMAND_glMaterialf, - COMMAND_glMaterialfv, - }; - typedef std::vector Commands; - typedef void (Batch::*CommandCall)(uint32&); - typedef std::vector CommandCalls; - typedef std::vector CommandOffsets; - - - class Param { - public: - union { - int32 _int; - uint32 _uint; - float _float; - char _chars[4]; - double _double; - }; - Param(int32 val) : _int(val) {} - Param(uint32 val) : _uint(val) {} - Param(float val) : _float(val) {} - Param(double val) : _double(val) {} - }; - typedef std::vector Params; - - class ResourceCache { - public: - union { - Resource* _resource; - const void* _pointer; - }; - ResourceCache(Resource* res) : _resource(res) {} - ResourceCache(const void* pointer) : _pointer(pointer) {} - }; - typedef std::vector Resources; - - typedef unsigned char Byte; - typedef std::vector Bytes; - - Commands _commands; - CommandCalls _commandCalls; - CommandOffsets _commandOffsets; - Params _params; - Resources _resources; - Bytes _data; - - uint32 cacheResource(Resource* res); - uint32 cacheResource(const void* pointer); - ResourceCache* editResource(uint32 offset) { - if (offset >= _resources.size()) - return 0; - return (_resources.data() + offset); - } - - uint32 cacheData(uint32 size, const void* data); - Byte* editData(uint32 offset) { - if (offset >= _data.size()) - return 0; - return (_data.data() + offset); - } - - void runCommand(uint32 index) { - uint32 offset = _commandOffsets[index]; - CommandCall call = _commandCalls[index]; - (this->*(call))(offset); - } - - void runLastCommand() { - uint32 index = _commands.size() - 1; - runCommand(index); - } - - void runCommand(Command com, uint32 offset); - - void do_draw(uint32& paramOffset) {} - void do_drawIndexed(uint32& paramOffset) {} - void do_drawInstanced(uint32& paramOffset) {} - void do_drawIndexedInstanced(uint32& paramOffset) {} - - // 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 do_glEnable(uint32& paramOffset); - void do_glDisable(uint32& paramOffset); - - void do_glEnableClientState(uint32& paramOffset); - void do_glDisableClientState(uint32& paramOffset); - - void do_glCullFace(uint32& paramOffset); - void do_glAlphaFunc(uint32& paramOffset); - - void do_glDepthFunc(uint32& paramOffset); - void do_glDepthMask(uint32& paramOffset); - void do_glDepthRange(uint32& paramOffset); - - void do_glBindBuffer(uint32& paramOffset); - - void do_glBindTexture(uint32& paramOffset); - void do_glActiveTexture(uint32& paramOffset); - - void do_glDrawBuffers(uint32& paramOffset); - - void do_glUseProgram(uint32& paramOffset); - void do_glUniform1f(uint32& paramOffset); - void do_glUniformMatrix4fv(uint32& paramOffset); - - void do_glMatrixMode(uint32& paramOffset); - void do_glPushMatrix(uint32& paramOffset); - void do_glPopMatrix(uint32& paramOffset); - void do_glMultMatrixf(uint32& paramOffset); - void do_glLoadMatrixf(uint32& paramOffset); - void do_glLoadIdentity(uint32& paramOffset); - void do_glRotatef(uint32& paramOffset); - void do_glScalef(uint32& paramOffset); - void do_glTranslatef(uint32& paramOffset); - - void do_glDrawArrays(uint32& paramOffset); - void do_glDrawRangeElements(uint32& paramOffset); - - void do_glColorPointer(uint32& paramOffset); - void do_glNormalPointer(uint32& paramOffset); - void do_glTexCoordPointer(uint32& paramOffset); - void do_glVertexPointer(uint32& paramOffset); - - void do_glVertexAttribPointer(uint32& paramOffset); - void do_glEnableVertexAttribArray(uint32& paramOffset); - void do_glDisableVertexAttribArray(uint32& paramOffset); - - void do_glColor4f(uint32& paramOffset); - - void do_glMaterialf(uint32& paramOffset); - void do_glMaterialfv(uint32& paramOffset); - - friend void backend::renderBatch(Batch& batch); -}; - -}; - -#endif diff --git a/interface/src/renderer/Model.cpp b/interface/src/renderer/Model.cpp index 739f5d75b1..3800e78008 100644 --- a/interface/src/renderer/Model.cpp +++ b/interface/src/renderer/Model.cpp @@ -26,10 +26,6 @@ #include "Application.h" #include "Model.h" -#include "gpu/Batch.h" -#define GLBATCH( call ) batch._##call -//#define GLBATCH( call ) call - using namespace std; static int modelPointerTypeId = qRegisterMetaType >(); @@ -434,135 +430,97 @@ bool Model::render(float alpha, RenderMode mode, RenderArgs* args) { segregateMeshGroups(); } - // Let's introduce a gpu::Batch to capture all the calls to the graphics api - gpu::Batch batch; - - GLBATCH(glEnableClientState)(GL_VERTEX_ARRAY); - GLBATCH(glEnableClientState)(GL_NORMAL_ARRAY); - - GLBATCH(glDisable)(GL_COLOR_MATERIAL); + glEnableClientState(GL_VERTEX_ARRAY); + glEnableClientState(GL_NORMAL_ARRAY); + + glDisable(GL_COLOR_MATERIAL); if (mode == DIFFUSE_RENDER_MODE || mode == NORMAL_RENDER_MODE) { - GLBATCH(glDisable)(GL_CULL_FACE); + glDisable(GL_CULL_FACE); } else { - GLBATCH(glEnable)(GL_CULL_FACE); + glEnable(GL_CULL_FACE); if (mode == SHADOW_RENDER_MODE) { - GLBATCH(glCullFace)(GL_FRONT); + glCullFace(GL_FRONT); } } // render opaque meshes with alpha testing - - GLBATCH(glDisable)(GL_BLEND); - GLBATCH(glEnable)(GL_ALPHA_TEST); + + glDisable(GL_BLEND); + glEnable(GL_ALPHA_TEST); if (mode == SHADOW_RENDER_MODE) { - GLBATCH(glAlphaFunc)(GL_EQUAL, 0.0f); + glAlphaFunc(GL_EQUAL, 0.0f); } - - - /*Application::getInstance()->getTextureCache()->setPrimaryDrawBuffers( + + Application::getInstance()->getTextureCache()->setPrimaryDrawBuffers( mode == DEFAULT_RENDER_MODE || mode == DIFFUSE_RENDER_MODE, mode == DEFAULT_RENDER_MODE || mode == NORMAL_RENDER_MODE, mode == DEFAULT_RENDER_MODE); - */ - { - GLenum buffers[3]; - int bufferCount = 0; - if (mode == DEFAULT_RENDER_MODE || mode == DIFFUSE_RENDER_MODE) { - buffers[bufferCount++] = GL_COLOR_ATTACHMENT0; - } - if (mode == DEFAULT_RENDER_MODE || mode == NORMAL_RENDER_MODE) { - buffers[bufferCount++] = GL_COLOR_ATTACHMENT1; - } - if (mode == DEFAULT_RENDER_MODE) { - buffers[bufferCount++] = GL_COLOR_ATTACHMENT2; - } - GLBATCH(glDrawBuffers)(bufferCount, buffers); - } - + const float DEFAULT_ALPHA_THRESHOLD = 0.5f; - //renderMeshes(RenderMode mode, bool translucent, float alphaThreshold, bool hasTangents, bool hasSpecular, book isSkinned, args); int opaqueMeshPartsRendered = 0; - opaqueMeshPartsRendered += renderMeshes(batch, mode, false, DEFAULT_ALPHA_THRESHOLD, false, false, false, args); - opaqueMeshPartsRendered += renderMeshes(batch, mode, false, DEFAULT_ALPHA_THRESHOLD, false, false, true, args); - opaqueMeshPartsRendered += renderMeshes(batch, mode, false, DEFAULT_ALPHA_THRESHOLD, false, true, false, args); - opaqueMeshPartsRendered += renderMeshes(batch, mode, false, DEFAULT_ALPHA_THRESHOLD, false, true, true, args); - opaqueMeshPartsRendered += renderMeshes(batch, mode, false, DEFAULT_ALPHA_THRESHOLD, true, false, false, args); - opaqueMeshPartsRendered += renderMeshes(batch, mode, false, DEFAULT_ALPHA_THRESHOLD, true, false, true, args); - opaqueMeshPartsRendered += renderMeshes(batch, mode, false, DEFAULT_ALPHA_THRESHOLD, true, true, false, args); - opaqueMeshPartsRendered += renderMeshes(batch, mode, false, DEFAULT_ALPHA_THRESHOLD, true, false, true, args); - + opaqueMeshPartsRendered += renderMeshes(mode, false, DEFAULT_ALPHA_THRESHOLD, false, false, false, args); + opaqueMeshPartsRendered += renderMeshes(mode, false, DEFAULT_ALPHA_THRESHOLD, false, false, true, args); + opaqueMeshPartsRendered += renderMeshes(mode, false, DEFAULT_ALPHA_THRESHOLD, false, true, false, args); + opaqueMeshPartsRendered += renderMeshes(mode, false, DEFAULT_ALPHA_THRESHOLD, false, true, true, args); + opaqueMeshPartsRendered += renderMeshes(mode, false, DEFAULT_ALPHA_THRESHOLD, true, false, false, args); + opaqueMeshPartsRendered += renderMeshes(mode, false, DEFAULT_ALPHA_THRESHOLD, true, false, true, args); + opaqueMeshPartsRendered += renderMeshes(mode, false, DEFAULT_ALPHA_THRESHOLD, true, true, false, args); + opaqueMeshPartsRendered += renderMeshes(mode, false, DEFAULT_ALPHA_THRESHOLD, true, false, true, args); + // render translucent meshes afterwards - //Application::getInstance()->getTextureCache()->setPrimaryDrawBuffers(false, true, true); - { - GLenum buffers[2]; - int bufferCount = 0; - buffers[bufferCount++] = GL_COLOR_ATTACHMENT1; - buffers[bufferCount++] = GL_COLOR_ATTACHMENT2; - GLBATCH(glDrawBuffers)(bufferCount, buffers); - } - + Application::getInstance()->getTextureCache()->setPrimaryDrawBuffers(false, true, true); int translucentMeshPartsRendered = 0; const float MOSTLY_OPAQUE_THRESHOLD = 0.75f; - translucentMeshPartsRendered += renderMeshes(batch, mode, true, MOSTLY_OPAQUE_THRESHOLD, false, false, false, args); - translucentMeshPartsRendered += renderMeshes(batch, mode, true, MOSTLY_OPAQUE_THRESHOLD, false, false, true, args); - translucentMeshPartsRendered += renderMeshes(batch, mode, true, MOSTLY_OPAQUE_THRESHOLD, false, true, false, args); - translucentMeshPartsRendered += renderMeshes(batch, mode, true, MOSTLY_OPAQUE_THRESHOLD, false, true, true, args); - translucentMeshPartsRendered += renderMeshes(batch, mode, true, MOSTLY_OPAQUE_THRESHOLD, true, false, false, args); - translucentMeshPartsRendered += renderMeshes(batch, mode, true, MOSTLY_OPAQUE_THRESHOLD, true, false, true, args); - translucentMeshPartsRendered += renderMeshes(batch, mode, true, MOSTLY_OPAQUE_THRESHOLD, true, true, false, args); - translucentMeshPartsRendered += renderMeshes(batch, mode, true, MOSTLY_OPAQUE_THRESHOLD, true, false, true, args); - - GLBATCH(glDisable)(GL_ALPHA_TEST); - GLBATCH(glEnable)(GL_BLEND); - GLBATCH(glDepthMask)(false); - GLBATCH(glDepthFunc)(GL_LEQUAL); + translucentMeshPartsRendered += renderMeshes(mode, true, MOSTLY_OPAQUE_THRESHOLD, false, false, false, args); + translucentMeshPartsRendered += renderMeshes(mode, true, MOSTLY_OPAQUE_THRESHOLD, false, false, true, args); + translucentMeshPartsRendered += renderMeshes(mode, true, MOSTLY_OPAQUE_THRESHOLD, false, true, false, args); + translucentMeshPartsRendered += renderMeshes(mode, true, MOSTLY_OPAQUE_THRESHOLD, false, true, true, args); + translucentMeshPartsRendered += renderMeshes(mode, true, MOSTLY_OPAQUE_THRESHOLD, true, false, false, args); + translucentMeshPartsRendered += renderMeshes(mode, true, MOSTLY_OPAQUE_THRESHOLD, true, false, true, args); + translucentMeshPartsRendered += renderMeshes(mode, true, MOSTLY_OPAQUE_THRESHOLD, true, true, false, args); + translucentMeshPartsRendered += renderMeshes(mode, true, MOSTLY_OPAQUE_THRESHOLD, true, false, true, args); + + glDisable(GL_ALPHA_TEST); + glEnable(GL_BLEND); + glDepthMask(false); + glDepthFunc(GL_LEQUAL); + + Application::getInstance()->getTextureCache()->setPrimaryDrawBuffers(true); - //Application::getInstance()->getTextureCache()->setPrimaryDrawBuffers(true); - { - GLenum buffers[1]; - int bufferCount = 0; - buffers[bufferCount++] = GL_COLOR_ATTACHMENT0; - GLBATCH(glDrawBuffers)(bufferCount, buffers); - } - if (mode == DEFAULT_RENDER_MODE || mode == DIFFUSE_RENDER_MODE) { const float MOSTLY_TRANSPARENT_THRESHOLD = 0.0f; - translucentMeshPartsRendered += renderMeshes(batch, mode, true, MOSTLY_TRANSPARENT_THRESHOLD, false, false, false, args); - translucentMeshPartsRendered += renderMeshes(batch, mode, true, MOSTLY_TRANSPARENT_THRESHOLD, false, false, true, args); - translucentMeshPartsRendered += renderMeshes(batch, mode, true, MOSTLY_TRANSPARENT_THRESHOLD, false, true, false, args); - translucentMeshPartsRendered += renderMeshes(batch, mode, true, MOSTLY_TRANSPARENT_THRESHOLD, false, true, true, args); - translucentMeshPartsRendered += renderMeshes(batch, mode, true, MOSTLY_TRANSPARENT_THRESHOLD, true, false, false, args); - translucentMeshPartsRendered += renderMeshes(batch, mode, true, MOSTLY_TRANSPARENT_THRESHOLD, true, false, true, args); - translucentMeshPartsRendered += renderMeshes(batch, mode, true, MOSTLY_TRANSPARENT_THRESHOLD, true, true, false, args); - translucentMeshPartsRendered += renderMeshes(batch, mode, true, MOSTLY_TRANSPARENT_THRESHOLD, true, false, true, args); + translucentMeshPartsRendered += renderMeshes(mode, true, MOSTLY_TRANSPARENT_THRESHOLD, false, false, false, args); + translucentMeshPartsRendered += renderMeshes(mode, true, MOSTLY_TRANSPARENT_THRESHOLD, false, false, true, args); + translucentMeshPartsRendered += renderMeshes(mode, true, MOSTLY_TRANSPARENT_THRESHOLD, false, true, false, args); + translucentMeshPartsRendered += renderMeshes(mode, true, MOSTLY_TRANSPARENT_THRESHOLD, false, true, true, args); + translucentMeshPartsRendered += renderMeshes(mode, true, MOSTLY_TRANSPARENT_THRESHOLD, true, false, false, args); + translucentMeshPartsRendered += renderMeshes(mode, true, MOSTLY_TRANSPARENT_THRESHOLD, true, false, true, args); + translucentMeshPartsRendered += renderMeshes(mode, true, MOSTLY_TRANSPARENT_THRESHOLD, true, true, false, args); + translucentMeshPartsRendered += renderMeshes(mode, true, MOSTLY_TRANSPARENT_THRESHOLD, true, false, true, args); } - - GLBATCH(glDepthMask)(true); - GLBATCH(glDepthFunc)(GL_LESS); - GLBATCH(glDisable)(GL_CULL_FACE); + + glDepthMask(true); + glDepthFunc(GL_LESS); + glDisable(GL_CULL_FACE); if (mode == SHADOW_RENDER_MODE) { - GLBATCH(glCullFace)(GL_BACK); + glCullFace(GL_BACK); } - + // deactivate vertex arrays after drawing - GLBATCH(glDisableClientState)(GL_NORMAL_ARRAY); - GLBATCH(glDisableClientState)(GL_VERTEX_ARRAY); - GLBATCH(glDisableClientState)(GL_TEXTURE_COORD_ARRAY); + glDisableClientState(GL_NORMAL_ARRAY); + glDisableClientState(GL_VERTEX_ARRAY); + glDisableClientState(GL_TEXTURE_COORD_ARRAY); // bind with 0 to switch back to normal operation - GLBATCH(glBindBuffer)(GL_ARRAY_BUFFER, 0); - GLBATCH(glBindBuffer)(GL_ELEMENT_ARRAY_BUFFER, 0); - GLBATCH(glBindTexture)(GL_TEXTURE_2D, 0); - - // Render! - ::gpu::backend::renderBatch(batch); - batch.clear(); - + glBindBuffer(GL_ARRAY_BUFFER, 0); + glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0); + glBindTexture(GL_TEXTURE_2D, 0); + // restore all the default material settings Application::getInstance()->setupWorldLight(); @@ -1548,7 +1506,7 @@ void Model::segregateMeshGroups() { _meshGroupsKnown = true; } -int Model::renderMeshes(gpu::Batch& batch, RenderMode mode, bool translucent, float alphaThreshold, +int Model::renderMeshes(RenderMode mode, bool translucent, float alphaThreshold, bool hasTangents, bool hasSpecular, bool isSkinned, RenderArgs* args) { bool dontCullOutOfViewMeshParts = Menu::getInstance()->isOptionChecked(MenuOption::DontCullOutOfViewMeshParts); @@ -1648,30 +1606,16 @@ int Model::renderMeshes(gpu::Batch& batch, RenderMode mode, bool translucent, fl ProgramObject* activeProgram = program; Locations* activeLocations = locations; - - // Try to use the Batch - //gpu::Batch batch; - - /*if (isSkinned) { + + if (isSkinned) { skinProgram->bind(); activeProgram = skinProgram; activeLocations = skinLocations; } else { program->bind(); - }*/ - if (isSkinned) { - activeProgram = skinProgram; - activeLocations = skinLocations; } - if (!activeProgram->isLinked()) { - activeProgram->link(); - } - GLBATCH(glUseProgram)(activeProgram->programId()); - // activeProgram->setUniformValue(activeLocations->alphaThreshold, alphaThreshold); - GLBATCH(glUniform1f)(activeLocations->alphaThreshold, alphaThreshold); - - - + activeProgram->setUniformValue(activeLocations->alphaThreshold, alphaThreshold); + // i is the "index" from the original networkMeshes QVector... foreach (int i, list) { @@ -1687,8 +1631,7 @@ int Model::renderMeshes(gpu::Batch& batch, RenderMode mode, bool translucent, fl const NetworkMesh& networkMesh = networkMeshes.at(i); const FBXMesh& mesh = geometry.meshes.at(i); - //const_cast(networkMesh.indexBuffer).bind(); - GLBATCH(glBindBuffer)(GL_ELEMENT_ARRAY_BUFFER, const_cast(networkMesh.indexBuffer).bufferId()); + const_cast(networkMesh.indexBuffer).bind(); int vertexCount = mesh.vertices.size(); if (vertexCount == 0) { @@ -1723,70 +1666,56 @@ int Model::renderMeshes(gpu::Batch& batch, RenderMode mode, bool translucent, fl } } - //const_cast(networkMesh.vertexBuffer).bind(); - GLBATCH(glBindBuffer)(GL_ARRAY_BUFFER, const_cast(networkMesh.vertexBuffer).bufferId()); - - GLBATCH(glPushMatrix)(); - //Application::getInstance()->loadTranslatedViewMatrix(_translation); - GLBATCH(glLoadMatrixf)((const GLfloat*)&Application::getInstance()->getUntranslatedViewMatrix()); - glm::vec3 viewMatTranslation = Application::getInstance()->getViewMatrixTranslation(); - GLBATCH(glTranslatef)(_translation.x + viewMatTranslation.x, _translation.y + viewMatTranslation.y, - _translation.z + viewMatTranslation.z); + const_cast(networkMesh.vertexBuffer).bind(); + + glPushMatrix(); + Application::getInstance()->loadTranslatedViewMatrix(_translation); const MeshState& state = _meshStates.at(i); if (state.clusterMatrices.size() > 1) { - GLBATCH(glUniformMatrix4fv)(skinLocations->clusterMatrices, state.clusterMatrices.size(), false, + glUniformMatrix4fvARB(skinLocations->clusterMatrices, state.clusterMatrices.size(), false, (const float*)state.clusterMatrices.constData()); int offset = (mesh.tangents.size() + mesh.colors.size()) * sizeof(glm::vec3) + mesh.texCoords.size() * sizeof(glm::vec2) + (mesh.blendshapes.isEmpty() ? vertexCount * 2 * sizeof(glm::vec3) : 0); - //skinProgram->setAttributeBuffer(skinLocations->clusterIndices, GL_FLOAT, offset, 4); - GLBATCH(glVertexAttribPointer)(skinLocations->clusterIndices, 4, GL_FLOAT, GL_TRUE, 0, (const void*) offset); - //skinProgram->setAttributeBuffer(skinLocations->clusterWeights, GL_FLOAT, - // offset + vertexCount * sizeof(glm::vec4), 4); - GLBATCH(glVertexAttribPointer)(skinLocations->clusterWeights, 4, GL_FLOAT, GL_TRUE, 0, (const void*) (offset + vertexCount * sizeof(glm::vec4))); - //skinProgram->enableAttributeArray(skinLocations->clusterIndices); - GLBATCH(glEnableVertexAttribArray)(skinLocations->clusterIndices); - //skinProgram->enableAttributeArray(skinLocations->clusterWeights); - GLBATCH(glEnableVertexAttribArray)(skinLocations->clusterWeights); + skinProgram->setAttributeBuffer(skinLocations->clusterIndices, GL_FLOAT, offset, 4); + skinProgram->setAttributeBuffer(skinLocations->clusterWeights, GL_FLOAT, + offset + vertexCount * sizeof(glm::vec4), 4); + skinProgram->enableAttributeArray(skinLocations->clusterIndices); + skinProgram->enableAttributeArray(skinLocations->clusterWeights); } else { - GLBATCH(glMultMatrixf)((const GLfloat*)&state.clusterMatrices[0]); + glMultMatrixf((const GLfloat*)&state.clusterMatrices[0]); } if (mesh.blendshapes.isEmpty()) { if (!(mesh.tangents.isEmpty() || mode == SHADOW_RENDER_MODE)) { - //activeProgram->setAttributeBuffer(activeLocations->tangent, GL_FLOAT, vertexCount * 2 * sizeof(glm::vec3), 3); - GLBATCH(glVertexAttribPointer)(activeLocations->tangent, 3, GL_FLOAT, GL_TRUE, 0, (const void*)(vertexCount * 2 * sizeof(glm::vec3))); - //activeProgram->enableAttributeArray(activeLocations->tangent); - GLBATCH(glEnableVertexAttribArray)(activeLocations->tangent); + activeProgram->setAttributeBuffer(activeLocations->tangent, GL_FLOAT, vertexCount * 2 * sizeof(glm::vec3), 3); + activeProgram->enableAttributeArray(activeLocations->tangent); } - GLBATCH(glColorPointer)(3, GL_FLOAT, 0, (void*)(vertexCount * 2 * sizeof(glm::vec3) + + glColorPointer(3, GL_FLOAT, 0, (void*)(vertexCount * 2 * sizeof(glm::vec3) + mesh.tangents.size() * sizeof(glm::vec3))); - GLBATCH(glTexCoordPointer)(2, GL_FLOAT, 0, (void*)(vertexCount * 2 * sizeof(glm::vec3) + + glTexCoordPointer(2, GL_FLOAT, 0, (void*)(vertexCount * 2 * sizeof(glm::vec3) + (mesh.tangents.size() + mesh.colors.size()) * sizeof(glm::vec3))); } else { if (!(mesh.tangents.isEmpty() || mode == SHADOW_RENDER_MODE)) { - //activeProgram->setAttributeBuffer(activeLocations->tangent, GL_FLOAT, 0, 3); - GLBATCH(glVertexAttribPointer)(activeLocations->tangent, 3, GL_FLOAT, GL_TRUE, 0, 0); - //activeProgram->enableAttributeArray(activeLocations->tangent); - GLBATCH(glEnableVertexAttribArray)(activeLocations->tangent); + activeProgram->setAttributeBuffer(activeLocations->tangent, GL_FLOAT, 0, 3); + activeProgram->enableAttributeArray(activeLocations->tangent); } - GLBATCH(glColorPointer)(3, GL_FLOAT, 0, (void*)(mesh.tangents.size() * sizeof(glm::vec3))); - GLBATCH(glTexCoordPointer)(2, GL_FLOAT, 0, (void*)((mesh.tangents.size() + mesh.colors.size()) * sizeof(glm::vec3))); - // _blendedVertexBuffers[i].bind(); - GLBATCH(glBindBuffer)(GL_ARRAY_BUFFER, _blendedVertexBuffers[i].bufferId()); + glColorPointer(3, GL_FLOAT, 0, (void*)(mesh.tangents.size() * sizeof(glm::vec3))); + glTexCoordPointer(2, GL_FLOAT, 0, (void*)((mesh.tangents.size() + mesh.colors.size()) * sizeof(glm::vec3))); + _blendedVertexBuffers[i].bind(); } - GLBATCH(glVertexPointer)(3, GL_FLOAT, 0, 0); - GLBATCH(glNormalPointer)(GL_FLOAT, 0, (void*)(vertexCount * sizeof(glm::vec3))); + glVertexPointer(3, GL_FLOAT, 0, 0); + glNormalPointer(GL_FLOAT, 0, (void*)(vertexCount * sizeof(glm::vec3))); if (!mesh.colors.isEmpty()) { - GLBATCH(glEnableClientState)(GL_COLOR_ARRAY); + glEnableClientState(GL_COLOR_ARRAY); } else { - GLBATCH(glColor4f)(1.0f, 1.0f, 1.0f, 1.0f); + glColor4f(1.0f, 1.0f, 1.0f, 1.0f); } if (!mesh.texCoords.isEmpty()) { - GLBATCH(glEnableClientState)(GL_TEXTURE_COORD_ARRAY); + glEnableClientState(GL_TEXTURE_COORD_ARRAY); } qint64 offset = 0; @@ -1797,10 +1726,9 @@ int Model::renderMeshes(gpu::Batch& batch, RenderMode mode, bool translucent, fl offset += (part.quadIndices.size() + part.triangleIndices.size()) * sizeof(int); continue; } - // apply material properties if (mode == SHADOW_RENDER_MODE) { - GLBATCH(glBindTexture)(GL_TEXTURE_2D, 0); + glBindTexture(GL_TEXTURE_2D, 0); } else { if (dontReduceMaterialSwitches || lastMaterialID != part.materialID) { @@ -1813,36 +1741,36 @@ int Model::renderMeshes(gpu::Batch& batch, RenderMode mode, bool translucent, fl glm::vec4 diffuse = glm::vec4(part.diffuseColor, part.opacity); if (!(translucent && alphaThreshold == 0.0f)) { - GLBATCH(glAlphaFunc)(GL_EQUAL, diffuse.a = Application::getInstance()->getGlowEffect()->getIntensity()); + glAlphaFunc(GL_EQUAL, diffuse.a = Application::getInstance()->getGlowEffect()->getIntensity()); } glm::vec4 specular = glm::vec4(part.specularColor, 1.0f); - GLBATCH(glMaterialfv)(GL_FRONT, GL_AMBIENT, (const float*)&diffuse); - GLBATCH(glMaterialfv)(GL_FRONT, GL_DIFFUSE, (const float*)&diffuse); - GLBATCH(glMaterialfv)(GL_FRONT, GL_SPECULAR, (const float*)&specular); - GLBATCH(glMaterialf)(GL_FRONT, GL_SHININESS, part.shininess); + glMaterialfv(GL_FRONT, GL_AMBIENT, (const float*)&diffuse); + glMaterialfv(GL_FRONT, GL_DIFFUSE, (const float*)&diffuse); + glMaterialfv(GL_FRONT, GL_SPECULAR, (const float*)&specular); + glMaterialf(GL_FRONT, GL_SHININESS, part.shininess); Texture* diffuseMap = networkPart.diffuseTexture.data(); if (mesh.isEye && diffuseMap) { diffuseMap = (_dilatedTextures[i][j] = static_cast(diffuseMap)->getDilatedTexture(_pupilDilation)).data(); } - GLBATCH(glBindTexture)(GL_TEXTURE_2D, !diffuseMap ? + glBindTexture(GL_TEXTURE_2D, !diffuseMap ? Application::getInstance()->getTextureCache()->getWhiteTextureID() : diffuseMap->getID()); if (!mesh.tangents.isEmpty()) { - GLBATCH(glActiveTexture)(GL_TEXTURE1); + glActiveTexture(GL_TEXTURE1); Texture* normalMap = networkPart.normalTexture.data(); - GLBATCH(glBindTexture)(GL_TEXTURE_2D, !normalMap ? + glBindTexture(GL_TEXTURE_2D, !normalMap ? Application::getInstance()->getTextureCache()->getBlueTextureID() : normalMap->getID()); - GLBATCH(glActiveTexture)(GL_TEXTURE0); + glActiveTexture(GL_TEXTURE0); } if (specularTextureUnit) { - GLBATCH(glActiveTexture)(specularTextureUnit); + glActiveTexture(specularTextureUnit); Texture* specularMap = networkPart.specularTexture.data(); - GLBATCH(glBindTexture)(GL_TEXTURE_2D, !specularMap ? + glBindTexture(GL_TEXTURE_2D, !specularMap ? Application::getInstance()->getTextureCache()->getWhiteTextureID() : specularMap->getID()); - GLBATCH(glActiveTexture)(GL_TEXTURE0); + glActiveTexture(GL_TEXTURE0); } if (args) { args->_materialSwitches++; @@ -1855,12 +1783,12 @@ int Model::renderMeshes(gpu::Batch& batch, RenderMode mode, bool translucent, fl meshPartsRendered++; if (part.quadIndices.size() > 0) { - GLBATCH(glDrawRangeElements)(GL_QUADS, 0, vertexCount - 1, part.quadIndices.size(), GL_UNSIGNED_INT, (void*)offset); + glDrawRangeElementsEXT(GL_QUADS, 0, vertexCount - 1, part.quadIndices.size(), GL_UNSIGNED_INT, (void*)offset); offset += part.quadIndices.size() * sizeof(int); } if (part.triangleIndices.size() > 0) { - GLBATCH(glDrawRangeElements)(GL_TRIANGLES, 0, vertexCount - 1, part.triangleIndices.size(), + glDrawRangeElementsEXT(GL_TRIANGLES, 0, vertexCount - 1, part.triangleIndices.size(), GL_UNSIGNED_INT, (void*)offset); offset += part.triangleIndices.size() * sizeof(int); } @@ -1874,39 +1802,35 @@ int Model::renderMeshes(gpu::Batch& batch, RenderMode mode, bool translucent, fl } if (!mesh.colors.isEmpty()) { - GLBATCH(glDisableClientState)(GL_COLOR_ARRAY); + glDisableClientState(GL_COLOR_ARRAY); } if (!mesh.texCoords.isEmpty()) { - GLBATCH(glDisableClientState)(GL_TEXTURE_COORD_ARRAY); + glDisableClientState(GL_TEXTURE_COORD_ARRAY); } if (!(mesh.tangents.isEmpty() || mode == SHADOW_RENDER_MODE)) { - GLBATCH(glActiveTexture)(GL_TEXTURE1); - GLBATCH(glBindTexture)(GL_TEXTURE_2D, 0); - GLBATCH(glActiveTexture)(GL_TEXTURE0); + glActiveTexture(GL_TEXTURE1); + glBindTexture(GL_TEXTURE_2D, 0); + glActiveTexture(GL_TEXTURE0); - // activeProgram->disableAttributeArray(activeLocations->tangent); - GLBATCH(glDisableVertexAttribArray)(activeLocations->tangent); + activeProgram->disableAttributeArray(activeLocations->tangent); } if (specularTextureUnit) { - GLBATCH(glActiveTexture)(specularTextureUnit); - GLBATCH(glBindTexture)(GL_TEXTURE_2D, 0); - GLBATCH(glActiveTexture)(GL_TEXTURE0); + glActiveTexture(specularTextureUnit); + glBindTexture(GL_TEXTURE_2D, 0); + glActiveTexture(GL_TEXTURE0); } if (state.clusterMatrices.size() > 1) { - // skinProgram->disableAttributeArray(skinLocations->clusterIndices); - GLBATCH(glDisableVertexAttribArray)(skinLocations->clusterIndices); - // skinProgram->disableAttributeArray(skinLocations->clusterWeights); - GLBATCH(glDisableVertexAttribArray)(skinLocations->clusterWeights); + skinProgram->disableAttributeArray(skinLocations->clusterIndices); + skinProgram->disableAttributeArray(skinLocations->clusterWeights); } - GLBATCH(glPopMatrix)(); + glPopMatrix(); } - //activeProgram->release(); - GLBATCH(glUseProgram)(0); - + activeProgram->release(); + return meshPartsRendered; } diff --git a/interface/src/renderer/Model.h b/interface/src/renderer/Model.h index b6c9987807..86fa0c2b7a 100644 --- a/interface/src/renderer/Model.h +++ b/interface/src/renderer/Model.h @@ -36,10 +36,6 @@ class ViewFrustum; typedef QSharedPointer AnimationHandlePointer; typedef QWeakPointer WeakAnimationHandlePointer; -namespace gpu { - class Batch; -} - /// A generic 3D model displaying geometry loaded from a URL. class Model : public QObject, public PhysicsEntity { Q_OBJECT @@ -256,7 +252,7 @@ private: void applyNextGeometry(); void deleteGeometry(); - int renderMeshes(gpu::Batch& batch, RenderMode mode, bool translucent, float alphaThreshold, bool hasTangents, bool hasSpecular, bool isSkinned, RenderArgs* args = NULL); + int renderMeshes(RenderMode mode, bool translucent, float alphaThreshold, bool hasTangents, bool hasSpecular, bool isSkinned, RenderArgs* args = NULL); QVector createJointStates(const FBXGeometry& geometry); void initJointTransforms();