Moving all the variables for the Input stage cache into a struct just like for transformStage

Sam Gateau committed 12 years ago

Commit 5c9c78e1 parent 420118e2 files · +63 −54Browse files

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

Unified · Split

 GLBackend::GLBackend() :
-    _needInputFormatUpdate(true),
+    _input(),
-    _inputFormat(0),
-    _inputBuffersState(0),
-    _inputBuffers(_inputBuffersState.size(), BufferPointer(0)),
-    _inputBufferOffsets(_inputBuffersState.size(), 0),
-    _inputBufferStrides(_inputBuffersState.size(), 0),
-    _indexBuffer(0),
-    _indexBufferOffset(0),
-    _inputAttributeActivation(0),
     _transform()
 {
     uint32 numIndices = batch._params[paramOffset + 1]._uint;
     uint32 startIndex = batch._params[paramOffset + 0]._uint;
-    GLenum glType = _elementTypeToGLType[_indexBufferType];
+    GLenum glType = _elementTypeToGLType[_input._indexBufferType];
-    glDrawElements(mode, numIndices, glType, reinterpret_cast<GLvoid*>(startIndex + _indexBufferOffset));
+    glDrawElements(mode, numIndices, glType, reinterpret_cast<GLvoid*>(startIndex + _input._indexBufferOffset));
     CHECK_GL_ERROR();
 }
 void GLBackend::do_setInputFormat(Batch& batch, uint32 paramOffset) {
     Stream::FormatPointer format = batch._streamFormats.get(batch._params[paramOffset]._uint);
-    if (format != _inputFormat) {
+    if (format != _input._format) {
-        _inputFormat = format;
+        _input._format = format;
-        _needInputFormatUpdate = true;
+        _input._invalidFormat = true;
     }
 }
     uint32 channel = batch._params[paramOffset + 3]._uint;
     if (channel < getNumInputBuffers()) {
-        _inputBuffers[channel] = buffer;
+        _input._buffers[channel] = buffer;
-        _inputBufferOffsets[channel] = offset;
+        _input._bufferOffsets[channel] = offset;
-        _inputBufferStrides[channel] = stride;
+        _input._bufferStrides[channel] = stride;
-        _inputBuffersState.set(channel);
+        _input._buffersState.set(channel);
     }
 }
 #endif
 void GLBackend::updateInput() {
-    if (_needInputFormatUpdate || _inputBuffersState.any()) {
+    if (_input._invalidFormat || _input._buffersState.any()) {
-        if (_needInputFormatUpdate) {
+        if (_input._invalidFormat) {
-            InputActivationCache newActivation;
+            InputStageState::ActivationCache newActivation;
             // Check expected activation
-            if (_inputFormat) {
+            if (_input._format) {
-                const Stream::Format::AttributeMap& attributes = _inputFormat->getAttributes();
+                const Stream::Format::AttributeMap& attributes = _input._format->getAttributes();
                 for (Stream::Format::AttributeMap::const_iterator it = attributes.begin(); it != attributes.end(); it++) {
                     const Stream::Attribute& attrib = (*it).second;
                     newActivation.set(attrib._slot);
             // Manage Activation what was and what is expected now
             for (unsigned int i = 0; i < newActivation.size(); i++) {
                 bool newState = newActivation[i];
-                if (newState != _inputAttributeActivation[i]) {
+                if (newState != _input._attributeActivation[i]) {
 #if defined(SUPPORT_LEGACY_OPENGL)
                     if (i < NUM_CLASSIC_ATTRIBS) {
                         if (newState) {
                     }
                     CHECK_GL_ERROR();
-                    _inputAttributeActivation.flip(i);
+                    _input._attributeActivation.flip(i);
                 }
             }
         }
         // now we need to bind the buffers and assign the attrib pointers
-        if (_inputFormat) {
+        if (_input._format) {
-            const Buffers& buffers = _inputBuffers;
+            const Buffers& buffers = _input._buffers;
-            const Offsets& offsets = _inputBufferOffsets;
+            const Offsets& offsets = _input._bufferOffsets;
-            const Offsets& strides = _inputBufferStrides;
+            const Offsets& strides = _input._bufferStrides;
-            const Stream::Format::AttributeMap& attributes = _inputFormat->getAttributes();
+            const Stream::Format::AttributeMap& attributes = _input._format->getAttributes();
-            for (Stream::Format::ChannelMap::const_iterator channelIt = _inputFormat->getChannels().begin();
+            for (Stream::Format::ChannelMap::const_iterator channelIt = _input._format->getChannels().begin();
-                    channelIt != _inputFormat->getChannels().end();
+                    channelIt != _input._format->getChannels().end();
                     channelIt++) {
                 const Stream::Format::ChannelMap::value_type::second_type& channel = (*channelIt).second;
                 if ((*channelIt).first < buffers.size()) {
                     int bufferNum = (*channelIt).first;
-                    if (_inputBuffersState.test(bufferNum) || _needInputFormatUpdate) {
+                    if (_input._buffersState.test(bufferNum) || _input._invalidFormat) {
                         GLuint vbo = gpu::GLBackend::getBufferID((*buffers[bufferNum]));
                         glBindBuffer(GL_ARRAY_BUFFER, vbo);
                         CHECK_GL_ERROR();
-                        _inputBuffersState[bufferNum] = false;
+                        _input._buffersState[bufferNum] = false;
                         for (unsigned int i = 0; i < channel._slots.size(); i++) {
                             const Stream::Attribute& attrib = attributes.at(channel._slots[i]);
             }
         }
         // everything format related should be in sync now
-        _needInputFormatUpdate = false;
+        _input._invalidFormat = false;
     }
 /* TODO: Fancy version GL4.4
 void GLBackend::do_setIndexBuffer(Batch& batch, uint32 paramOffset) {
-    _indexBufferType = (Type) batch._params[paramOffset + 2]._uint;
+    _input._indexBufferType = (Type) batch._params[paramOffset + 2]._uint;
     BufferPointer indexBuffer = batch._buffers.get(batch._params[paramOffset + 1]._uint);
-    _indexBufferOffset = batch._params[paramOffset + 0]._uint;
+    _input._indexBufferOffset = batch._params[paramOffset + 0]._uint;
-    _indexBuffer = indexBuffer;
+    _input._indexBuffer = indexBuffer;
     if (indexBuffer) {
         glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, getBufferID(*indexBuffer));
     } else {