first take at the Transform encapsulating a transform matrix

interface/src/gpu/Batch.cpp

@@ -156,3 +156,22 @@ void Batch::setIndexBuffer(Type type, const BufferPointer& buffer, Offset offset
     _params.push_back(_buffers.cache(buffer));
     _params.push_back(type);
 }
+
+void Batch::setModelTransform(const TransformPointer& model) {
+    ADD_COMMAND(setModelTransform);
+
+    _params.push_back(_transforms.cache(model));
+}
+
+void Batch::setViewTransform(const TransformPointer& view) {
+    ADD_COMMAND(setViewTransform);
+
+    _params.push_back(_transforms.cache(view));
+}
+
+void Batch::setProjectionTransform(const TransformPointer& proj) {
+    ADD_COMMAND(setProjectionTransform);
+
+    _params.push_back(_transforms.cache(proj));
+}
+

interface/src/gpu/Batch.h

@@ -16,9 +16,8 @@
 
 #include <vector>
 
-#include "gpu/Format.h"
-#include "gpu/Resource.h"
 #include "gpu/Stream.h"
+#include "gpu/Transform.h"
 
 #if defined(NSIGHT_FOUND)
     #include "nvToolsExt.h"
@@ -60,11 +59,16 @@ public:
 
     void clear();
 
+    // Drawcalls
     void draw(Primitive primitiveType, uint32 numVertices, uint32 startVertex = 0);
     void drawIndexed(Primitive primitiveType, uint32 nbIndices, uint32 startIndex = 0);
     void drawInstanced(uint32 nbInstances, Primitive primitiveType, uint32 nbVertices, uint32 startVertex = 0, uint32 startInstance = 0);
     void drawIndexedInstanced(uint32 nbInstances, Primitive primitiveType, uint32 nbIndices, uint32 startIndex = 0, uint32 startInstance = 0);
 
+    // Input Stage
+    // InputFormat
+    // InputBuffers
+    // IndexBuffer
     void setInputFormat(const Stream::FormatPointer& format);
 
     void setInputStream(Slot startChannel, const BufferStream& stream); // not a command, just unroll into a loop of setInputBuffer
@@ -72,6 +76,11 @@ public:
 
     void setIndexBuffer(Type type, const BufferPointer& buffer, Offset offset);
 
+    // Transform Stage
+    void setModelTransform(const TransformPointer& model);
+    void setViewTransform(const TransformPointer& view);
+    void setProjectionTransform(const TransformPointer& proj);
+
 
     // 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 
@@ -138,11 +147,13 @@ public:
         COMMAND_drawIndexedInstanced,
 
         COMMAND_setInputFormat,
-
         COMMAND_setInputBuffer,
-
         COMMAND_setIndexBuffer,
 
+        COMMAND_setModelTransform,
+        COMMAND_setViewTransform,
+        COMMAND_setProjectionTransform,
+
         // 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
@@ -265,6 +276,7 @@ public:
     
     typedef Cache<Buffer>::Vector BufferCaches;
     typedef Cache<Stream::Format>::Vector StreamFormatCaches;
+    typedef Cache<Transform>::Vector TransformCaches;
 
     typedef unsigned char Byte;
     typedef std::vector<Byte> Bytes;
@@ -299,6 +311,8 @@ public:
     BufferCaches _buffers;
     StreamFormatCaches _streamFormats;
 
+    TransformCaches _transforms;
+
     Bytes _data;
 protected:
 };

interface/src/gpu/GLBackend.cpp

@@ -24,11 +24,13 @@ GLBackend::CommandCall GLBackend::_commandCalls[Batch::NUM_COMMANDS] =
     (&::gpu::GLBackend::do_drawIndexedInstanced),
 
     (&::gpu::GLBackend::do_setInputFormat),
-
     (&::gpu::GLBackend::do_setInputBuffer),
-
     (&::gpu::GLBackend::do_setIndexBuffer),
 
+    (&::gpu::GLBackend::do_setModelTransform),
+    (&::gpu::GLBackend::do_setViewTransform),
+    (&::gpu::GLBackend::do_setProjectionTransform),
+
     (&::gpu::GLBackend::do_glEnable),
     (&::gpu::GLBackend::do_glDisable),
 
@@ -111,7 +113,6 @@ static const GLenum _elementTypeToGLType[NUM_TYPES]= {
 
 
 GLBackend::GLBackend() :
-
     _inputFormat(0),
     _inputAttributeActivation(0),
     _needInputFormatUpdate(true),
@@ -122,7 +123,10 @@ GLBackend::GLBackend() :
     _inputBufferStrides(_inputBuffersState.size(), 0),
 
     _indexBuffer(0),
-    _indexBufferOffset(0)
+    _indexBufferOffset(0),
+
+    _transform()
+
 {
 
 }
@@ -183,6 +187,7 @@ void GLBackend::checkGLError() {
 
 void GLBackend::do_draw(Batch& batch, uint32 paramOffset) {
     updateInput();
+    updateTransform();
 
     Primitive primitiveType = (Primitive)batch._params[paramOffset + 2]._uint;
     GLenum mode = _primitiveToGLmode[primitiveType];
@@ -195,6 +200,7 @@ void GLBackend::do_draw(Batch& batch, uint32 paramOffset) {
 
 void GLBackend::do_drawIndexed(Batch& batch, uint32 paramOffset) {
     updateInput();
+    updateTransform();
 
     Primitive primitiveType = (Primitive)batch._params[paramOffset + 2]._uint;
     GLenum mode = _primitiveToGLmode[primitiveType];
@@ -424,6 +430,68 @@ void GLBackend::do_setIndexBuffer(Batch& batch, uint32 paramOffset) {
     CHECK_GL_ERROR();
 }
 
+// Transform Stage
+
+void GLBackend::do_setModelTransform(Batch& batch, uint32 paramOffset) {
+    TransformPointer modelTransform = batch._transforms.get(batch._params[paramOffset]._uint);
+
+    if (modelTransform != _transform._model) {
+        _transform._invalidModel = true;
+    }
+}
+
+void GLBackend::do_setViewTransform(Batch& batch, uint32 paramOffset) {
+    TransformPointer viewTransform = batch._transforms.get(batch._params[paramOffset]._uint);
+
+    if (viewTransform != _transform._view) {
+        _transform._invalidView = true;
+    }
+}
+
+void GLBackend::do_setProjectionTransform(Batch& batch, uint32 paramOffset) {
+    TransformPointer projectionTransform = batch._transforms.get(batch._params[paramOffset]._uint);
+
+    if (projectionTransform != _transform._projection) {
+        _transform._invalidProj = true;
+    }
+}
+
+void GLBackend::updateTransform() {
+    if (_transform._invalidProj) {
+        if (_transform._lastMode != GL_PROJECTION) {
+            glMatrixMode(GL_PROJECTION);
+            _transform._lastMode = GL_PROJECTION;
+        }
+        CHECK_GL_ERROR();
+    }
+
+    if (_transform._invalidModel || _transform._invalidView) {
+        if (_transform._lastMode != GL_MODELVIEW) {
+            glMatrixMode(GL_MODELVIEW);
+            _transform._lastMode = GL_MODELVIEW;
+        }
+
+        if (!_transform._model.isNull()) {
+            if (!_transform._view.isNull()) {
+                Transform::Mat4 mv = _transform._view->getMatrix() * _transform._model->getMatrix();
+                glLoadMatrixf((const GLfloat*) &mv[0]);
+            } else {
+                glLoadMatrixf((const GLfloat*) &_transform._model->getMatrix());
+            }
+        } else {
+            if (!_transform._view.isNull()) {
+                glLoadMatrixf((const GLfloat*) & _transform._view->getMatrix());
+            } else {
+               // glLoadIdentity();
+            }
+        }
+        CHECK_GL_ERROR();
+
+        _transform._invalidModel = false;
+        _transform._invalidView = 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

interface/src/gpu/GLBackend.h

@@ -52,11 +52,22 @@ public:
 
 protected:
 
+    // Draw Stage
+    void do_draw(Batch& batch, uint32 paramOffset);
+    void do_drawIndexed(Batch& batch, uint32 paramOffset);
+    void do_drawInstanced(Batch& batch, uint32 paramOffset);
+    void do_drawIndexedInstanced(Batch& batch, uint32 paramOffset);
+
+    // Input Stage
+    void do_setInputFormat(Batch& batch, uint32 paramOffset);
+    void do_setInputBuffer(Batch& batch, uint32 paramOffset);
+    void do_setIndexBuffer(Batch& batch, uint32 paramOffset);
+    void updateInput();
     bool _needInputFormatUpdate;
     Stream::FormatPointer _inputFormat;
-
     typedef std::bitset<MAX_NUM_INPUT_BUFFERS> InputBuffersState;
     InputBuffersState _inputBuffersState;
+
     Buffers _inputBuffers;
     Offsets _inputBufferOffsets;
     Offsets _inputBufferStrides;
@@ -68,18 +79,31 @@ protected:
     typedef std::bitset<MAX_NUM_ATTRIBUTES> InputActivationCache;
     InputActivationCache _inputAttributeActivation;
 
-    void do_draw(Batch& batch, uint32 paramOffset);
+    // Transform Stage
-    void do_drawIndexed(Batch& batch, uint32 paramOffset);
+    void do_setModelTransform(Batch& batch, uint32 paramOffset);
-    void do_drawInstanced(Batch& batch, uint32 paramOffset);
+    void do_setViewTransform(Batch& batch, uint32 paramOffset);
-    void do_drawIndexedInstanced(Batch& batch, uint32 paramOffset);
+    void do_setProjectionTransform(Batch& batch, uint32 paramOffset);
 
-    void updateInput();
+    void updateTransform();
-    void do_setInputFormat(Batch& batch, uint32 paramOffset);
+    struct TransformStageState {
-
+        TransformPointer _model;
-    void do_setInputBuffer(Batch& batch, uint32 paramOffset);
+        TransformPointer _view;
+        TransformPointer _projection;
+        bool _invalidModel;
+        bool _invalidView;
+        bool _invalidProj;
 
-    void do_setVertexBuffer(Batch& batch, uint32 paramOffset);
+        GLenum _lastMode;
-    void do_setIndexBuffer(Batch& batch, uint32 paramOffset);
+
+        TransformStageState() :
+            _model(0),
+            _view(0),
+            _projection(0),
+            _invalidModel(true),
+            _invalidView(true),
+            _invalidProj(true),
+            _lastMode(GL_TEXTURE) {}
+    } _transform;
 
     // 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 

interface/src/renderer/Model.cpp

@@ -556,6 +556,16 @@ bool Model::render(float alpha, RenderMode mode, RenderArgs* args) {
     // Let's introduce a gpu::Batch to capture all the calls to the graphics api
     gpu::Batch batch;
 
+    // Capture the view matrix once for the rendering of this model
+    gpu::TransformPointer viewTransform(new gpu::Transform());
+
+    glm::mat4 v = Application::getInstance()->getUntranslatedViewMatrix();
+    viewTransform->evalFromRawMatrix(v);
+    glm::mat4 v2 = viewTransform->getMatrix();
+
+    viewTransform->localTranslate(Application::getInstance()->getViewMatrixTranslation());
+
+  //  batch.setViewTransform(viewTransform);
 
     GLBATCH(glDisable)(GL_COLOR_MATERIAL);
     
@@ -1853,17 +1863,42 @@ int Model::renderMeshes(gpu::Batch& batch, RenderMode mode, bool translucent, fl
 
         GLBATCH(glPushMatrix)();
         //Application::getInstance()->loadTranslatedViewMatrix(_translation);
-        GLBATCH(glLoadMatrixf)((const GLfloat*)&Application::getInstance()->getUntranslatedViewMatrix());
+    //    GLBATCH(glLoadMatrixf)((const GLfloat*)&Application::getInstance()->getUntranslatedViewMatrix());
+
+        // Capture the view matrix once for the rendering of this model
+        glm::mat4 v = Application::getInstance()->getUntranslatedViewMatrix();
+        
+        gpu::TransformPointer viewTransform(new gpu::Transform());
+        viewTransform->evalFromRawMatrix(v);
+
         glm::vec3 viewMatTranslation = Application::getInstance()->getViewMatrixTranslation();
-        GLBATCH(glTranslatef)(_translation.x + viewMatTranslation.x, _translation.y + viewMatTranslation.y,
+
-            _translation.z + viewMatTranslation.z);
+        viewTransform->localTranslate(viewMatTranslation + _translation);
+        glm::mat4 v2 = viewTransform->getMatrix();
+       // batch.setViewTransform(viewTransform);
+
+   //     GLBATCH(glTranslatef)(_translation.x + viewMatTranslation.x, _translation.y + viewMatTranslation.y,
+    //        _translation.z + viewMatTranslation.z);
 
         const MeshState& state = _meshStates.at(i);
         if (state.clusterMatrices.size() > 1) {
             GLBATCH(glUniformMatrix4fv)(skinLocations->clusterMatrices, state.clusterMatrices.size(), false,
                 (const float*)state.clusterMatrices.constData());
+
+        //    gpu::TransformPointer modelTransform(new gpu::Transform());
+        //    modelTransform->setTranslation(_translation);
+         //   batch.setModelTransform(viewTransform);
+
+          //  gpu::TransformPointer mv(new gpu::Transform());
+          //  gpu::Transform::mult(*mv, *viewTransform, *modelTransform);
+            batch.setModelTransform(viewTransform);
         } else {
-            GLBATCH(glMultMatrixf)((const GLfloat*)&state.clusterMatrices[0]);
+           // GLBATCH(glMultMatrixf)((const GLfloat*)&state.clusterMatrices[0]);
+            gpu::TransformPointer modelTransform(new gpu::Transform(state.clusterMatrices[0]));
+            
+            gpu::TransformPointer mv(new gpu::Transform());
+            gpu::Transform::mult(*mv, *viewTransform, *modelTransform);
+            batch.setModelTransform(mv);
         }
         
         if (mesh.blendshapes.isEmpty()) {