INtroducing the stream format and the Stream and making it work for the model mesh

Sam Gateau committed 12 years ago

Commit 23905591 parent 7b5d2ef9 files · +547 −73Browse files

Showing the changes to interface/src/gpu/GLBackend.cpp (1 of 9 files). Show all

Unified · Split

 GLBackend::CommandCall GLBackend::_commandCalls[Batch::NUM_COMMANDS] =
 {
+    (&::gpu::GLBackend::do_draw),
+    (&::gpu::GLBackend::do_drawIndexed),
+    (&::gpu::GLBackend::do_drawInstanced),
+    (&::gpu::GLBackend::do_drawIndexedInstanced),
+    (&::gpu::GLBackend::do_setInputStream),
+    (&::gpu::GLBackend::do_setInputFormat),
     (&::gpu::GLBackend::do_glEnable),
     (&::gpu::GLBackend::do_glDisable),
     (&::gpu::GLBackend::do_glMaterialfv),
 };
+const GLenum GLBackend::_primitiveToGLmode[NUM_PRIMITIVES] = {
+    GL_POINTS,
+    GL_LINES,
+    GL_LINE_STRIP,
+    GL_TRIANGLES,
+    GL_TRIANGLE_STRIP,
+    GL_QUADS,
+};
-GLBackend::GLBackend() {
+static const GLenum _elementTypeToGLType[Element::NUM_TYPES]= {
+    GL_FLOAT,
+    GL_INT,
+    GL_UNSIGNED_INT,
+    GL_HALF_FLOAT,
+    GL_SHORT,
+    GL_UNSIGNED_SHORT,
+    GL_BYTE,
+    GL_UNSIGNED_BYTE,
+    GL_FLOAT,
+    GL_INT,
+    GL_UNSIGNED_INT,
+    GL_HALF_FLOAT,
+    GL_SHORT,
+    GL_UNSIGNED_SHORT,
+    GL_BYTE,
+    GL_UNSIGNED_BYTE
+};
+GLBackend::GLBackend() :
+    _inputFormat(0),
+    _inputStream(0),
+    _needInputFormatUpdate(true),
+    _needInputStreamUpdate(true),
+    _inputAttributeActivation(0)
+{
 }
     GLBackend backend;
     for (int i = 0; i < numCommands; i++) {
-        CommandCall call = _commandCalls[((*command) - Batch::COMMAND_glEnable)];
+        CommandCall call = _commandCalls[(*command)];
         (backend.*(call))(batch, *offset);
         command++;
         offset++;
     }
 }
+#define CHECK_GL_ERROR() ::gpu::GLBackend::checkGLError()
+//#define CHECK_GL_ERROR()
+void GLBackend::do_draw(Batch& batch, uint32 paramOffset) {
+    updateInput();
+    Primitive primitiveType = (Primitive)batch._params[paramOffset + 2]._uint;
+    GLenum mode = _primitiveToGLmode[primitiveType];
+    uint32 numVertices = batch._params[paramOffset + 1]._uint;
+    uint32 startVertex = batch._params[paramOffset + 0]._uint;
+    glDrawArrays(mode, startVertex, numVertices);
+    CHECK_GL_ERROR();
+}
+void GLBackend::do_drawIndexed(Batch& batch, uint32 paramOffset) {
+    updateInput();
+    Primitive primitiveType = (Primitive)batch._params[paramOffset + 2]._uint;
+    GLenum mode = _primitiveToGLmode[primitiveType];
+    uint32 numIndices = batch._params[paramOffset + 1]._uint;
+    uint32 startIndex = batch._params[paramOffset + 0]._uint;
+    glDrawElements(mode, numIndices, GL_UNSIGNED_INT, (GLvoid*) startIndex);
+    CHECK_GL_ERROR();
+}
+void GLBackend::do_drawInstanced(Batch& batch, uint32 paramOffset) {
+    CHECK_GL_ERROR();
+}
+void GLBackend::do_drawIndexedInstanced(Batch& batch, uint32 paramOffset) {
+    CHECK_GL_ERROR();
+}
+void GLBackend::do_setInputStream(Batch& batch, uint32 paramOffset) {
+    const Stream* stream = reinterpret_cast<const Stream*>(batch.editResource(batch._params[paramOffset]._uint)->_pointer);
+    if (stream != _inputStream) {
+        _inputStream = stream;
+        _needInputStreamUpdate = true;
+    }
+}
+void GLBackend::do_setInputFormat(Batch& batch, uint32 paramOffset) {
+    const StreamFormat* format = reinterpret_cast<const StreamFormat*>(batch.editResource(batch._params[paramOffset]._uint)->_pointer);
+    if (format != _inputFormat) {
+        _inputFormat = format;
+        _needInputFormatUpdate = true;
+    }
+}
+#define SUPPORT_LEGACY_OPENGL
+#if defined(SUPPORT_LEGACY_OPENGL)
+static const int NUM_CLASSIC_ATTRIBS = StreamFormat::SLOT_TANGENT;
+static const GLenum attributeSlotToClassicAttribName[NUM_CLASSIC_ATTRIBS] = {
+    GL_VERTEX_ARRAY,
+    GL_NORMAL_ARRAY,
+    GL_TEXTURE_COORD_ARRAY,
+    GL_COLOR_ARRAY
+};
+#endif
+void GLBackend::updateInput() {
+    if (_needInputFormatUpdate || _needInputStreamUpdate) {
+        if (_needInputFormatUpdate) {
+            InputActivationCache newActivation;
+            // Check expected activation
+            if (_inputFormat) {
+                const StreamFormat::AttributeMap& attributes = _inputFormat->getAttributes();
+                for (StreamFormat::AttributeMap::const_iterator it = attributes.begin(); it != attributes.end(); it++) {
+                    const StreamFormat::Attribute& attrib = (*it).second;
+                    newActivation.set(attrib._slot);
+                }
+            }
+            // Manage Activation what was and what is expected now
+            for (int i = 0; i < newActivation.size(); i++) {
+                bool newState = newActivation[i];
+                if (newState != _inputAttributeActivation[i]) {
+#if defined(SUPPORT_LEGACY_OPENGL)
+                    if (i < NUM_CLASSIC_ATTRIBS) {
+                        if (newState) {
+                            glEnableClientState(attributeSlotToClassicAttribName[i]);
+                        }
+                        else {
+                            glDisableClientState(attributeSlotToClassicAttribName[i]);
+                        }
+                    } else {
+#else
+                    {
+#endif
+                        if (newState) {
+                            glEnableVertexAttribArray(i);
+                        } else {
+                            glDisableVertexAttribArray(i);
+                        }
+                    }
+                    CHECK_GL_ERROR();
+                    _inputAttributeActivation.flip(i);
+                }
+            }
+        }
+        // now we need to bind the buffers and assign the attrib pointers
+        if (_inputStream && _inputFormat) {
+            const Stream::Buffers& buffers = _inputStream->getBuffers();
+            const Stream::Offsets& offsets = _inputStream->getOffsets();
+            const Stream::Strides& strides = _inputStream->getStrides();
+            const StreamFormat::AttributeMap& attributes = _inputFormat->getAttributes();
+            for (StreamFormat::ChannelMap::const_iterator channelIt = _inputFormat->getChannels().begin();
+                    channelIt != _inputFormat->getChannels().end();
+                    channelIt++) {
+                const StreamFormat::ChannelMap::value_type::second_type& channel = (*channelIt).second;
+                if ((*channelIt).first < buffers.size()) {
+                    int bufferNum = (*channelIt).first;
+                    GLuint vbo = gpu::GLBackend::getBufferID((*buffers[bufferNum]));
+                    glBindBuffer(GL_ARRAY_BUFFER, vbo);
+                    CHECK_GL_ERROR();
+                    for (int i = 0; i < channel._slots.size(); i++) {
+                        const StreamFormat::Attribute& attrib = attributes.at(channel._slots[i]);
+                        GLuint count = attrib._element.getDimensionCount();
+                        GLenum type = _elementTypeToGLType[attrib._element.getType()];
+                        GLuint stride = strides[bufferNum];
+                        GLuint pointer = attrib._offset + offsets[bufferNum];
+#if defined(SUPPORT_LEGACY_OPENGL)
+                        if (attrib._slot < NUM_CLASSIC_ATTRIBS) {
+                            switch (attrib._slot) {
+                            case StreamFormat::SLOT_POSITION:
+                                glVertexPointer(count, type, stride, (GLvoid*)pointer);
+                                break;
+                            case StreamFormat::SLOT_COLOR:
+                                glColorPointer(count, type, stride, (GLvoid*)pointer);
+                                break;
+                            case StreamFormat::SLOT_TEXCOORD:
+                                glTexCoordPointer(count, type, stride, (GLvoid*)pointer);
+                                break;
+                            case StreamFormat::SLOT_NORMAL:
+                                glNormalPointer(type, stride, (GLvoid*)pointer);
+                                break;
+                            };
+                        } else {
+#else
+                        {
+#endif
+                            glVertexAttribPointer(attrib._slot, count, type, attrib._element.isNormalized(), stride, (GLvoid*)pointer);
+                        }
+                        CHECK_GL_ERROR();
+                    }
+                }
+            }
+        }
+        _needInputStreamUpdate = false;
+        _needInputFormatUpdate = false;
+    }
+/* Fancy version GL4.4
+    if (_needInputFormatUpdate) {
+        InputActivationCache newActivation;
+        // Assign the vertex format required
+        if (_inputFormat) {
+            const StreamFormat::AttributeMap& attributes = _inputFormat->getAttributes();
+            for (StreamFormat::AttributeMap::const_iterator it = attributes.begin(); it != attributes.end(); it++) {
+                const StreamFormat::Attribute& attrib = (*it).second;
+                newActivation.set(attrib._slot);
+                glVertexAttribFormat(
+                    attrib._slot,
+                    attrib._element.getDimensionCount(),
+                    _elementTypeToGLType[attrib._element.getType()],
+                    attrib._element.isNormalized(),
+                    attrib._stride);
+            }
+            CHECK_GL_ERROR();
+        }
+        // Manage Activation what was and what is expected now
+        for (int i = 0; i < newActivation.size(); i++) {
+            bool newState = newActivation[i];
+            if (newState != _inputAttributeActivation[i]) {
+                if (newState) {
+                    glEnableVertexAttribArray(i);
+                } else {
+                    glDisableVertexAttribArray(i);
+                }
+                _inputAttributeActivation.flip(i);
+            }
+        }
+        CHECK_GL_ERROR();
+        _needInputFormatUpdate = false;
+    }
+    if (_needInputStreamUpdate) {
+        if (_inputStream) {
+            const Stream::Buffers& buffers = _inputStream->getBuffers();
+            const Stream::Offsets& offsets = _inputStream->getOffsets();
+            const Stream::Strides& strides = _inputStream->getStrides();
+            for (int i = 0; i < buffers.size(); i++) {
+                GLuint vbo = gpu::GLBackend::getBufferID((*buffers[i]));
+                glBindVertexBuffer(i, vbo, offsets[i], strides[i]);
+            }
+            CHECK_GL_ERROR();
+        }
+        _needInputStreamUpdate = false;
+    }
+*/
+}
 // 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
-//#define ADD_COMMAND(call) _commands.push_back(COMMAND_##call); _commandCalls.push_back(&gpu::Batch::do_##call); _commandOffsets.push_back(_params.size());
-#define ADD_COMMAND(call) _commands.push_back(COMMAND_##call); _commandOffsets.push_back(_params.size());
-//#define ADD_COMMAND_GL(call) _commands.push_back(COMMAND_##call); _commandCalls.push_back(&gpu::GLBackend::do_##call); _commandOffsets.push_back(_params.size());
 #define ADD_COMMAND_GL(call) _commands.push_back(COMMAND_##call); _commandOffsets.push_back(_params.size());
 //#define DO_IT_NOW(call, offset) runLastCommand();
 #define DO_IT_NOW(call, offset)
-//#define CHECK_GL_ERROR() ::gpu::backend::checkGLError()
-#define CHECK_GL_ERROR()
 void Batch::_glEnable(GLenum cap) {
-    ADD_COMMAND(glEnable);
+    ADD_COMMAND_GL(glEnable);
     _params.push_back(cap);
 }
 void Batch::_glDisable(GLenum cap) {
-    ADD_COMMAND(glDisable);
+    ADD_COMMAND_GL(glDisable);
     _params.push_back(cap);
 }
 void Batch::_glEnableClientState(GLenum array) {
-    ADD_COMMAND(glEnableClientState);
+    ADD_COMMAND_GL(glEnableClientState);
     _params.push_back(array);
 }
 void Batch::_glDisableClientState(GLenum array) {
-    ADD_COMMAND(glDisableClientState);
+    ADD_COMMAND_GL(glDisableClientState);
     _params.push_back(array);
 }
 void Batch::_glCullFace(GLenum mode) {
-    ADD_COMMAND(glCullFace);
+    ADD_COMMAND_GL(glCullFace);
     _params.push_back(mode);
 }
 void Batch::_glAlphaFunc(GLenum func, GLclampf ref) {
-    ADD_COMMAND(glAlphaFunc);
+    ADD_COMMAND_GL(glAlphaFunc);
     _params.push_back(ref);
     _params.push_back(func);
 }
 void Batch::_glDepthFunc(GLenum func) {
-    ADD_COMMAND(glDepthFunc);
+    ADD_COMMAND_GL(glDepthFunc);
     _params.push_back(func);
 }
 void Batch::_glDepthMask(GLboolean flag) {
-    ADD_COMMAND(glDepthMask);
+    ADD_COMMAND_GL(glDepthMask);
     _params.push_back(flag);
 }
 void Batch::_glDepthRange(GLclampd zNear, GLclampd zFar) {
-    ADD_COMMAND(glDepthRange);
+    ADD_COMMAND_GL(glDepthRange);
     _params.push_back(zFar);
     _params.push_back(zNear);
 }
 void Batch::_glBindBuffer(GLenum target, GLuint buffer) {
-    ADD_COMMAND(glBindBuffer);
+    ADD_COMMAND_GL(glBindBuffer);
     _params.push_back(buffer);
     _params.push_back(target);
 }
 void Batch::_glBindTexture(GLenum target, GLuint texture) {
-    ADD_COMMAND(glBindTexture);
+    ADD_COMMAND_GL(glBindTexture);
     _params.push_back(texture);
     _params.push_back(target);
 }
 void Batch::_glActiveTexture(GLenum texture) {
-    ADD_COMMAND(glActiveTexture);
+    ADD_COMMAND_GL(glActiveTexture);
     _params.push_back(texture);
 }
 void Batch::_glDrawBuffers(GLsizei n, const GLenum* bufs) {
-    ADD_COMMAND(glDrawBuffers);
+    ADD_COMMAND_GL(glDrawBuffers);
     _params.push_back(cacheData(n * sizeof(GLenum), bufs));
     _params.push_back(n);
 }
 void Batch::_glUseProgram(GLuint program) {
-    ADD_COMMAND(glUseProgram);
+    ADD_COMMAND_GL(glUseProgram);
     _params.push_back(program);
 }
 void Batch::_glUniform1f(GLint location, GLfloat v0) {
-    ADD_COMMAND(glUniform1f);
+    ADD_COMMAND_GL(glUniform1f);
     _params.push_back(v0);
     _params.push_back(location);
 }
 void Batch::_glUniformMatrix4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) {
-    ADD_COMMAND(glUniformMatrix4fv);
+    ADD_COMMAND_GL(glUniformMatrix4fv);
     const int MATRIX4_SIZE = 16 * sizeof(float);
     _params.push_back(cacheData(count * MATRIX4_SIZE, value));
 }
 void Batch::_glMatrixMode(GLenum mode) {
-    ADD_COMMAND(glMatrixMode);
+    ADD_COMMAND_GL(glMatrixMode);
     _params.push_back(mode);
 }
 void Batch::_glPushMatrix() {
-    ADD_COMMAND(glPushMatrix);
+    ADD_COMMAND_GL(glPushMatrix);
     DO_IT_NOW(_glPushMatrix, 0);
 }
 }
 void Batch::_glPopMatrix() {
-    ADD_COMMAND(glPopMatrix);
+    ADD_COMMAND_GL(glPopMatrix);
     DO_IT_NOW(_glPopMatrix, 0);
 }
 }
 void Batch::_glMultMatrixf(const GLfloat *m) {
-    ADD_COMMAND(glMultMatrixf);
+    ADD_COMMAND_GL(glMultMatrixf);
     const int MATRIX4_SIZE = 16 * sizeof(float);
     _params.push_back(cacheData(MATRIX4_SIZE, m));
 }
 void Batch::_glLoadMatrixf(const GLfloat *m) {
-    ADD_COMMAND(glLoadMatrixf);
+    ADD_COMMAND_GL(glLoadMatrixf);
     const int MATRIX4_SIZE = 16 * sizeof(float);
     _params.push_back(cacheData(MATRIX4_SIZE, m));
 }
 void Batch::_glLoadIdentity(void) {
-    ADD_COMMAND(glLoadIdentity);
+    ADD_COMMAND_GL(glLoadIdentity);
     DO_IT_NOW(_glLoadIdentity, 0);
 }
 }
 void Batch::_glRotatef(GLfloat angle, GLfloat x, GLfloat y, GLfloat z) {
-    ADD_COMMAND(glRotatef);
+    ADD_COMMAND_GL(glRotatef);
     _params.push_back(z);
     _params.push_back(y);
 }
 void Batch::_glScalef(GLfloat x, GLfloat y, GLfloat z) {
-    ADD_COMMAND(glScalef);
+    ADD_COMMAND_GL(glScalef);
     _params.push_back(z);
     _params.push_back(y);
 }
 void Batch::_glTranslatef(GLfloat x, GLfloat y, GLfloat z) {
-    ADD_COMMAND(glTranslatef);
+    ADD_COMMAND_GL(glTranslatef);
     _params.push_back(z);
     _params.push_back(y);
 }
 void Batch::_glDrawArrays(GLenum mode, GLint first, GLsizei count) {
-    ADD_COMMAND(glDrawArrays);
+    ADD_COMMAND_GL(glDrawArrays);
     _params.push_back(count);
     _params.push_back(first);
 }
 void Batch::_glDrawRangeElements(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const void *indices) {
-    ADD_COMMAND(glDrawRangeElements);
+    ADD_COMMAND_GL(glDrawRangeElements);
     _params.push_back(cacheResource(indices));
     _params.push_back(type);
 }
 void Batch::_glColorPointer(GLint size, GLenum type, GLsizei stride, const void *pointer) {
-    ADD_COMMAND(glColorPointer);
+    ADD_COMMAND_GL(glColorPointer);
     _params.push_back(cacheResource(pointer));
     _params.push_back(stride);
 }
 void Batch::_glNormalPointer(GLenum type, GLsizei stride, const void *pointer) {
-    ADD_COMMAND(glNormalPointer);
+    ADD_COMMAND_GL(glNormalPointer);
     _params.push_back(cacheResource(pointer));
     _params.push_back(stride);
 }
 void Batch::_glTexCoordPointer(GLint size, GLenum type, GLsizei stride, const void *pointer) {
-    ADD_COMMAND(glTexCoordPointer);
+    ADD_COMMAND_GL(glTexCoordPointer);
     _params.push_back(cacheResource(pointer));
     _params.push_back(stride);
 }
 void Batch::_glVertexPointer(GLint size, GLenum type, GLsizei stride, const void *pointer) {
-    ADD_COMMAND(glVertexPointer);
+    ADD_COMMAND_GL(glVertexPointer);
     _params.push_back(cacheResource(pointer));
     _params.push_back(stride);
 void Batch::_glVertexAttribPointer(GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const void *pointer) {
-    ADD_COMMAND(glVertexAttribPointer);
+    ADD_COMMAND_GL(glVertexAttribPointer);
     _params.push_back(cacheResource(pointer));
     _params.push_back(stride);
 }
 void Batch::_glEnableVertexAttribArray(GLint location) {
-    ADD_COMMAND(glEnableVertexAttribArray);
+    ADD_COMMAND_GL(glEnableVertexAttribArray);
     _params.push_back(location);
 }
 void Batch::_glDisableVertexAttribArray(GLint location) {
-    ADD_COMMAND(glDisableVertexAttribArray);
+    ADD_COMMAND_GL(glDisableVertexAttribArray);
     _params.push_back(location);
 }
 void Batch::_glColor4f(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha) {
-    ADD_COMMAND(glColor4f);
+    ADD_COMMAND_GL(glColor4f);
     _params.push_back(alpha);
     _params.push_back(blue);
 }
 void Batch::_glMaterialf(GLenum face, GLenum pname, GLfloat param) {
-    ADD_COMMAND(glMaterialf);
+    ADD_COMMAND_GL(glMaterialf);
     _params.push_back(param);
     _params.push_back(pname);
 }
 void Batch::_glMaterialfv(GLenum face, GLenum pname, const GLfloat *params) {
-    ADD_COMMAND(glMaterialfv);
+    ADD_COMMAND_GL(glMaterialfv);
     _params.push_back(cacheData(4 * sizeof(float), params));
     _params.push_back(pname);

INtroducing the stream format and the Stream and making it work for the model mesh

Keyboard shortcuts

General

Issues and pull requests

Issues, pull requests and Inbox

Repository code