hydra hand spheres and lasers are rendering again

examples/lineRotations.js

@@ -0,0 +1,134 @@
+//
+//  RenderableQuadEntityItem.cpp
+//  libraries/entities-renderer/src/
+//
+//  Created by Eric Levin on 6/22/15
+//  Copyright 2015 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 <glm/gtx/quaternion.hpp>
+
+#include <gpu/GPUConfig.h>
+#include <GeometryCache.h>
+
+#include <DeferredLightingEffect.h>
+#include <PerfStat.h>
+
+#include "RenderableQuadEntityItem.h"
+
+
+
+
+
+
+
+EntityItemPointer RenderableQuadEntityItem::factory(const EntityItemID& entityID, const EntityItemProperties& properties) {
+    return EntityItemPointer(new RenderableQuadEntityItem(entityID, properties));
+}
+
+RenderableQuadEntityItem::RenderableQuadEntityItem(const EntityItemID& entityItemID, const EntityItemProperties& properties) :
+QuadEntityItem(entityItemID, properties) {
+    _numVertices = 0;
+
+}
+
+gpu::PipelinePointer RenderableQuadEntityItem::_pipeline;
+gpu::Stream::FormatPointer RenderableQuadEntityItem::_format;
+
+void RenderableQuadEntityItem::createPipeline() {
+    static const int NORMAL_OFFSET = 12;
+    static const int COLOR_OFFSET = 24;
+    _format.reset(new gpu::Stream::Format());
+    _format->setAttribute(gpu::Stream::POSITION, 0, gpu::Element(gpu::VEC3, gpu::FLOAT, gpu::XYZ), 0);
+    _format->setAttribute(gpu::Stream::NORMAL, 0, gpu::Element(gpu::VEC3, gpu::FLOAT, gpu::XYZ), NORMAL_OFFSET);
+    _format->setAttribute(gpu::Stream::COLOR, 0, gpu::Element(gpu::VEC4, gpu::UINT8, gpu::RGBA), COLOR_OFFSET);
+    
+    auto VS = DependencyManager::get<DeferredLightingEffect>()->getSimpleVertexShader();
+    auto PS = DependencyManager::get<DeferredLightingEffect>()->getSimplePixelShader();
+    gpu::ShaderPointer program = gpu::ShaderPointer(gpu::Shader::createProgram(VS, PS));
+    
+    gpu::Shader::BindingSet slotBindings;
+    gpu::Shader::makeProgram(*program, slotBindings);
+    
+    gpu::StatePointer state = gpu::StatePointer(new gpu::State());
+    //state->setCullMode(gpu::State::CULL_BACK);
+    state->setDepthTest(true, true, gpu::LESS_EQUAL);
+    state->setBlendFunction(false,
+                            gpu::State::SRC_ALPHA, gpu::State::BLEND_OP_ADD, gpu::State::INV_SRC_ALPHA,
+                            gpu::State::FACTOR_ALPHA, gpu::State::BLEND_OP_ADD, gpu::State::ONE);
+   _pipeline = gpu::PipelinePointer(gpu::Pipeline::create(program, state));
+}
+int generateColor() {
+    float c1 = static_cast <float> (rand()) / static_cast <float> (RAND_MAX);
+    float c2 = static_cast <float> (rand()) / static_cast <float> (RAND_MAX);
+    float c3 = static_cast <float> (rand()) / static_cast <float> (RAND_MAX);
+    return ((int(c1 * 255.0f) & 0xFF)) |
+    ((int(c2 * 255.0f) & 0xFF) << 8) |
+    ((int(c3 * 255.0f) & 0xFF) << 16) |
+    ((int(255.0f) & 0xFF) << 24);
+}
+
+void RenderableQuadEntityItem::updateGeometry() {
+    QReadLocker lock(&_quadReadWriteLock);
+    int compactColor = generateColor();
+    _numVertices = 0;
+    _verticesBuffer.reset(new gpu::Buffer());
+    int vertexIndex = 0;
+    for (int i = 0; i < _normals.size(); i++) {
+        compactColor = generateColor();
+        _verticesBuffer->append(sizeof(glm::vec3), (const gpu::Byte*)&_vertices.at(vertexIndex));
+         vertexIndex++;
+        _verticesBuffer->append(sizeof(glm::vec3), (const gpu::Byte*)&_normals.at(i));
+        _verticesBuffer->append(sizeof(int), (gpu::Byte*)&compactColor);
+        _verticesBuffer->append(sizeof(glm::vec3), (const gpu::Byte*)&_vertices.at(vertexIndex));
+        vertexIndex++;
+        _verticesBuffer->append(sizeof(glm::vec3), (const gpu::Byte*)&_normals.at(i));
+        _verticesBuffer->append(sizeof(int), (gpu::Byte*)&compactColor);
+        
+        _numVertices +=2;
+    }
+    _pointsChanged = false;
+    
+
+    
+}
+
+
+
+void RenderableQuadEntityItem::render(RenderArgs* args) {
+    if (_points.size() < 2  || _vertices.size() != _normals.size() * 2) {
+        return;
+    }
+    
+    if (!_pipeline) {
+        createPipeline();
+    }
+ 
+    PerformanceTimer perfTimer("RenderableQuadEntityItem::render");
+    Q_ASSERT(getType() == EntityTypes::Quad);
+    
+    Q_ASSERT(args->_batch);
+    if (_pointsChanged) {
+        updateGeometry();
+    }
+
+    
+    gpu::Batch& batch = *args->_batch;
+    Transform transform = Transform();
+    transform.setTranslation(getPosition());
+    transform.setRotation(getRotation());
+    batch.setModelTransform(transform);
+
+
+    batch.setPipeline(_pipeline);
+    
+    batch.setInputFormat(_format);
+    batch.setInputBuffer(0, _verticesBuffer, 0, _format->getChannels().at(0)._stride);
+     
+    batch.draw(gpu::TRIANGLE_STRIP, _numVertices, 0);
+    
+    RenderableDebugableEntityItem::render(this, args);
+};

interface/src/Application.cpp

@@ -3547,7 +3547,7 @@ void Application::displaySide(RenderArgs* renderArgs, Camera& theCamera, bool se
     }
     //Render the sixense lasers
     if (Menu::getInstance()->isOptionChecked(MenuOption::SixenseLasers)) {
-        _myAvatar->renderLaserPointers();
+        _myAvatar->renderLaserPointers(*renderArgs->_batch);
     }
 
     if (!selfAvatarOnly) {

interface/src/avatar/Avatar.cpp

@@ -575,9 +575,9 @@ void Avatar::renderBody(RenderArgs* renderArgs, ViewFrustum* renderFrustum, bool
             return;
         }
 
-        if (postLighting) {
+//        if (postLighting) {
             getHand()->render(renderArgs, false);
-        }
+//        }
     }
     getHead()->render(renderArgs, 1.0f, renderFrustum, postLighting);
 }
@@ -1010,7 +1010,7 @@ int Avatar::parseDataAtOffset(const QByteArray& packet, int offset) {
 int Avatar::_jointConesID = GeometryCache::UNKNOWN_ID;
 
 // render a makeshift cone section that serves as a body part connecting joint spheres
-void Avatar::renderJointConnectingCone(glm::vec3 position1, glm::vec3 position2,
+void Avatar::renderJointConnectingCone(gpu::Batch& batch, glm::vec3 position1, glm::vec3 position2,
                                             float radius1, float radius2, const glm::vec4& color) {
 
     auto geometryCache = DependencyManager::get<GeometryCache>();
@@ -1057,7 +1057,7 @@ void Avatar::renderJointConnectingCone(glm::vec3 position1, glm::vec3 position2,
         // TODO: this is really inefficient constantly recreating these vertices buffers. It would be
         // better if the avatars cached these buffers for each of the joints they are rendering
         geometryCache->updateVertices(_jointConesID, points, color);
-        geometryCache->renderVertices(gpu::TRIANGLES, _jointConesID);
+        geometryCache->renderVertices(batch, gpu::TRIANGLES, _jointConesID);
     }
 }
 

interface/src/avatar/Avatar.h

@@ -148,7 +148,7 @@ public:
     
     virtual int parseDataAtOffset(const QByteArray& packet, int offset);
 
-    static void renderJointConnectingCone(glm::vec3 position1, glm::vec3 position2, 
+    static void renderJointConnectingCone( gpu::Batch& batch, glm::vec3 position1, glm::vec3 position2,
                                                 float radius1, float radius2, const glm::vec4& color);
 
     virtual void applyCollision(const glm::vec3& contactPoint, const glm::vec3& penetration) { }

interface/src/avatar/Hand.cpp

@@ -103,7 +103,8 @@ void Hand::resolvePenetrations() {
 }
 
 void Hand::render(RenderArgs* renderArgs, bool isMine) {
-    if (renderArgs->_renderMode != RenderArgs::SHADOW_RENDER_MODE && 
+    gpu::Batch& batch = *renderArgs->_batch;
+    if (renderArgs->_renderMode != RenderArgs::SHADOW_RENDER_MODE &&
                 Menu::getInstance()->isOptionChecked(MenuOption::RenderSkeletonCollisionShapes)) {
         // draw a green sphere at hand joint location, which is actually near the wrist)
         for (size_t i = 0; i < getNumPalms(); i++) {
@@ -112,31 +113,25 @@ void Hand::render(RenderArgs* renderArgs, bool isMine) {
                 continue;
             }
             glm::vec3 position = palm.getPosition();
-            glPushMatrix();
-            glTranslatef(position.x, position.y, position.z);
-            DependencyManager::get<GeometryCache>()->renderSphere(PALM_COLLISION_RADIUS * _owningAvatar->getScale(), 10, 10, glm::vec3(0.0f, 1.0f, 0.0f));
-            glPopMatrix();
+            Transform transform = Transform();
+            transform.setTranslation(position);
+            batch.setModelTransform(transform);
+            DependencyManager::get<GeometryCache>()->renderSphere(batch, PALM_COLLISION_RADIUS * _owningAvatar->getScale(), 10, 10, glm::vec3(0.0f, 1.0f, 0.0f));
         }
     }
     
     if (renderArgs->_renderMode != RenderArgs::SHADOW_RENDER_MODE && Menu::getInstance()->isOptionChecked(MenuOption::DisplayHands)) {
-        renderHandTargets(isMine);
+        renderHandTargets(renderArgs, isMine);
     }
 
-    glEnable(GL_DEPTH_TEST);
-    glEnable(GL_RESCALE_NORMAL);
-} 
-
-void Hand::renderHandTargets(bool isMine) {
-    glPushMatrix();
+}
 
+void Hand::renderHandTargets(RenderArgs* renderArgs, bool isMine) {
+    gpu::Batch& batch = *renderArgs->_batch;
     const float avatarScale = DependencyManager::get<AvatarManager>()->getMyAvatar()->getScale();
 
     const float alpha = 1.0f;
     const glm::vec3 handColor(1.0, 0.0, 0.0); //  Color the hand targets red to be different than skin
-    
-    glEnable(GL_DEPTH_TEST);
-    glDepthMask(GL_TRUE);
 
     if (isMine && Menu::getInstance()->isOptionChecked(MenuOption::DisplayHandTargets)) {
         for (size_t i = 0; i < getNumPalms(); ++i) {
@@ -145,12 +140,12 @@ void Hand::renderHandTargets(bool isMine) {
                 continue;
             }
             glm::vec3 targetPosition = palm.getTipPosition();
-            glPushMatrix();
-            glTranslatef(targetPosition.x, targetPosition.y, targetPosition.z);
+            Transform transform = Transform();
+            transform.setTranslation(targetPosition);
+            batch.setModelTransform(transform);
         
             const float collisionRadius = 0.05f;
-            DependencyManager::get<GeometryCache>()->renderSphere(collisionRadius, 10, 10, glm::vec4(0.5f,0.5f,0.5f, alpha), false);
-            glPopMatrix();
+            DependencyManager::get<GeometryCache>()->renderSphere(batch, collisionRadius, 10, 10, glm::vec4(0.5f,0.5f,0.5f, alpha), false);
         }
     }
     
@@ -165,22 +160,19 @@ void Hand::renderHandTargets(bool isMine) {
         if (palm.isActive()) {
             glm::vec3 tip = palm.getTipPosition();
             glm::vec3 root = palm.getPosition();
-
-            Avatar::renderJointConnectingCone(root, tip, PALM_FINGER_ROD_RADIUS, PALM_FINGER_ROD_RADIUS, glm::vec4(handColor.r, handColor.g, handColor.b, alpha));
+            Transform transform = Transform();
+            transform.setTranslation(glm::vec3());
+            batch.setModelTransform(transform);
+            Avatar::renderJointConnectingCone(batch, root, tip, PALM_FINGER_ROD_RADIUS, PALM_FINGER_ROD_RADIUS, glm::vec4(handColor.r, handColor.g, handColor.b, alpha));
 
             //  Render sphere at palm/finger root
             glm::vec3 offsetFromPalm = root + palm.getNormal() * PALM_DISK_THICKNESS;
-            Avatar::renderJointConnectingCone(root, offsetFromPalm, PALM_DISK_RADIUS, 0.0f, glm::vec4(handColor.r, handColor.g, handColor.b, alpha));
-            glPushMatrix();
-            glTranslatef(root.x, root.y, root.z);
-            DependencyManager::get<GeometryCache>()->renderSphere(PALM_BALL_RADIUS, 20.0f, 20.0f, glm::vec4(handColor.r, handColor.g, handColor.b, alpha));
-            glPopMatrix();
+            Avatar::renderJointConnectingCone(batch, root, offsetFromPalm, PALM_DISK_RADIUS, 0.0f, glm::vec4(handColor.r, handColor.g, handColor.b, alpha));
+            transform = Transform();
+            transform.setTranslation(root);
+            batch.setModelTransform(transform);
+            DependencyManager::get<GeometryCache>()->renderSphere(batch, PALM_BALL_RADIUS, 20.0f, 20.0f, glm::vec4(handColor.r, handColor.g, handColor.b, alpha));
         }
     }
-
-    glDepthMask(GL_TRUE);
-    glEnable(GL_DEPTH_TEST);
-
-    glPopMatrix();
 }
 

interface/src/avatar/Hand.h

@@ -56,7 +56,7 @@ private:
 
     Avatar*        _owningAvatar;
     
-    void renderHandTargets(bool isMine);
+    void renderHandTargets(RenderArgs* renderArgs, bool isMine);
 };
 
 #endif // hifi_Hand_h

interface/src/avatar/MyAvatar.cpp

@@ -1212,9 +1212,9 @@ void MyAvatar::renderBody(RenderArgs* renderArgs, ViewFrustum* renderFrustum, bo
     if (shouldRenderHead(renderArgs)) {
         getHead()->render(renderArgs, 1.0f, renderFrustum, postLighting);
     }
-    if (postLighting) {
+//    if (postLighting) {
         getHand()->render(renderArgs, true);
-    }
+//    }
 }
 
 void MyAvatar::setVisibleInSceneIfReady(Model* model, render::ScenePointer scene, bool visible) {
@@ -1587,7 +1587,7 @@ void MyAvatar::updateMotionBehavior() {
 }
 
 //Renders sixense laser pointers for UI selection with controllers
-void MyAvatar::renderLaserPointers() {
+void MyAvatar::renderLaserPointers(gpu::Batch& batch) {
     const float PALM_TIP_ROD_RADIUS = 0.002f;
 
     //If the Oculus is enabled, we will draw a blue cursor ray
@@ -1600,8 +1600,10 @@ void MyAvatar::renderLaserPointers() {
 
             //Scale the root vector with the avatar scale
             scaleVectorRelativeToPosition(root);
-
-            Avatar::renderJointConnectingCone(root, tip, PALM_TIP_ROD_RADIUS, PALM_TIP_ROD_RADIUS, glm::vec4(0, 1, 1, 1));
+            Transform transform = Transform();
+            transform.setTranslation(glm::vec3());
+            batch.setModelTransform(transform);
+            Avatar::renderJointConnectingCone(batch, root, tip, PALM_TIP_ROD_RADIUS, PALM_TIP_ROD_RADIUS, glm::vec4(0, 1, 1, 1));
         }
     }
 }

interface/src/avatar/MyAvatar.h

@@ -157,7 +157,7 @@ public:
         bool allowDuplicates = false, bool useSaved = true);
         
     /// Renders a laser pointer for UI picking
-    void renderLaserPointers();
+    void renderLaserPointers(gpu::Batch& batch);
     glm::vec3 getLaserPointerTipPosition(const PalmData* palm);
     
     const RecorderPointer getRecorder() const { return _recorder; }

interface/src/avatar/SkeletonModel.cpp

@@ -805,7 +805,7 @@ void SkeletonModel::renderBoundingCollisionShapes(float alpha) {
 
     // draw a green cylinder between the two points
     glm::vec3 origin(0.0f);
-    Avatar::renderJointConnectingCone( origin, axis, _boundingShape.getRadius(), _boundingShape.getRadius(), glm::vec4(0.6f, 0.8f, 0.6f, alpha));
+//    Avatar::renderJointConnectingCone( origin, axis, _boundingShape.getRadius(), _boundingShape.getRadius(), glm::vec4(0.6f, 0.8f, 0.6f, alpha));
 
     glPopMatrix();
 }