Switched Oculus UI to hemisphere. Added curved semicircle UI

interface/src/Application.cpp

@@ -1007,12 +1007,6 @@ void Application::keyPressEvent(QKeyEvent* event) {
             case Qt::Key_At:
                 Menu::getInstance()->goTo();
                 break;
-            case Qt::Key_B:
-                _applicationOverlay.setOculusAngle(_applicationOverlay.getOculusAngle() - RADIANS_PER_DEGREE);
-                break;
-            case Qt::Key_N:
-                _applicationOverlay.setOculusAngle(_applicationOverlay.getOculusAngle() + RADIANS_PER_DEGREE);
-                break;
             default:
                 event->ignore();
                 break;

interface/src/ui/ApplicationOverlay.cpp

@@ -22,7 +22,8 @@
 ApplicationOverlay::ApplicationOverlay() : 
     _framebufferObject(NULL),
     _oculusAngle(65.0f * RADIANS_PER_DEGREE),
-    _distance(0.5f) {
+    _distance(0.5f),
+    _uiType(HEMISPHERE) {
 
 }
 
@@ -305,6 +306,8 @@ inline float min(float a, float b) {
     return (a < b) ? a : b;
 }
 
+const float textureFov = PI / 2.5f;
+
 // Draws the FBO texture for Oculus rift. TODO: Draw a curved texture instead of plane.
 void ApplicationOverlay::displayOverlayTextureOculus(Camera& whichCamera) {
 
@@ -316,8 +319,8 @@ void ApplicationOverlay::displayOverlayTextureOculus(Camera& whichCamera) {
 
     int mouseX = application->getMouseX();
     int mouseY = application->getMouseY();
-    int widgetWidth = glWidget->width();
+    const int widgetWidth = glWidget->width();
-    int widgetHeight = glWidget->height();
+    const int widgetHeight = glWidget->height();
     float magnifyWidth = 80.0f;
     float magnifyHeight = 60.0f;
     const float magnification = 4.0f;
@@ -327,17 +330,22 @@ void ApplicationOverlay::displayOverlayTextureOculus(Camera& whichCamera) {
     const float verticalAngle = halfVerticalAngle * 2.0f;
     const float overlayAspectRatio = glWidget->width() / (float)glWidget->height();
     const float halfOverlayHeight = _distance * tan(halfVerticalAngle);
+    const float overlayHeight = halfOverlayHeight * 2.0f;
 
     // The more vertices, the better the curve
     const int numHorizontalVertices = 20;
+    const int numVerticalVertices = 20;
     // U texture coordinate width at each quad
     const float quadTexWidth = 1.0f / (numHorizontalVertices - 1);
+    const float quadTexHeight = 1.0f / (numVerticalVertices - 1);
 
     // Get horizontal angle and angle increment from vertical angle and aspect ratio
     const float horizontalAngle = halfVerticalAngle * 2.0f * overlayAspectRatio;
     const float angleIncrement = horizontalAngle / (numHorizontalVertices - 1);
     const float halfHorizontalAngle = horizontalAngle / 2;
 
+    const float verticalAngleIncrement = verticalAngle / (numVerticalVertices - 1);
+
     glActiveTexture(GL_TEXTURE0);
    
     glEnable(GL_BLEND);
@@ -391,9 +399,10 @@ void ApplicationOverlay::displayOverlayTextureOculus(Camera& whichCamera) {
         magnifyHeight = widgetHeight - mouseY;
     }
 
+    const float halfMagnifyHeight = magnifyHeight / 2.0f;
+
     float newWidth = magnifyWidth * magnification;
     float newHeight = magnifyHeight * magnification;
-    float tmp;
 
     // Magnification Texture Coordinates
     float magnifyULeft = mouseX / (float)widgetWidth;
@@ -408,55 +417,118 @@ void ApplicationOverlay::displayOverlayTextureOculus(Camera& whichCamera) {
     // Get angle on the UI
     float leftAngle = (newMouseX / (float)widgetWidth) * horizontalAngle - halfHorizontalAngle;
     float rightAngle = ((newMouseX + newWidth) / (float)widgetWidth) * horizontalAngle - halfHorizontalAngle;
+    float bottomAngle = (newMouseY / (float)widgetHeight) * verticalAngle - halfVerticalAngle;
+    float topAngle = ((newMouseY - newHeight) / (float)widgetHeight) * verticalAngle - halfVerticalAngle;
 
-    float halfMagnifyHeight = magnifyHeight / 2.0f;
 
-    float leftX, rightX, leftZ, rightZ;
+    float leftX, rightX, leftZ, rightZ, topZ, bottomZ;
     
     // Get position on hemisphere using angle
-    leftX = sin(leftAngle) * _distance;
+    if (_uiType == HEMISPHERE) {
-    rightX = sin(rightAngle) * _distance;
-    leftZ = -cos(leftAngle) * _distance;
-    rightZ = -cos(rightAngle) * _distance;
 
-    float bottomY = (1.0 - newMouseY / (float)widgetHeight) * halfOverlayHeight * 2.0f - halfOverlayHeight;
+        //Get new UV coordinates from our magnification window
-    float topY = bottomY + (newHeight / widgetHeight) * halfOverlayHeight * 2;
+        float newULeft = newMouseX / widgetWidth;
+        float newURight = (newMouseX + newWidth) / widgetWidth;
+        float newVBottom = 1.0 - newMouseY / widgetHeight;
+        float newVTop = 1.0 - (newMouseY - newHeight) / widgetHeight;
 
-    //TODO: Remove immediate mode in favor of VBO
+        // Project our position onto the hemisphere using the UV coordinates
-    glBegin(GL_QUADS);
+        float lX = sin((newULeft - 0.5f) * textureFov);
+        float rX = sin((newURight - 0.5f) * textureFov);
+        float bY = sin((newVBottom - 0.5f) * textureFov);
+        float tY = sin((newVTop - 0.5f) * textureFov);
         
-    glTexCoord2f(magnifyULeft, magnifyVBottom); glVertex3f(leftX, topY, leftZ);
+        float dist;
-    glTexCoord2f(magnifyURight, magnifyVBottom); glVertex3f(rightX, topY, rightZ);
+        //Bottom Left
-    glTexCoord2f(magnifyURight, magnifyVTop); glVertex3f(rightX, bottomY, rightZ);
+        dist = sqrt(lX * lX + bY * bY);
-    glTexCoord2f(magnifyULeft, magnifyVTop); glVertex3f(leftX, bottomY, leftZ);
+        float blZ = sqrt(1.0f - dist * dist);
+        //Top Left
+        dist = sqrt(lX * lX + tY * tY);
+        float tlZ = sqrt(1.0f - dist * dist);
+        //Bottom Right
+        dist = sqrt(rX * rX + bY * bY);
+        float brZ = sqrt(1.0f - dist * dist);
+        //Top Right
+        dist = sqrt(rX * rX + tY * tY);
+        float trZ = sqrt(1.0f - dist * dist);
 
-    glEnd();
+        glBegin(GL_QUADS);
 
+        glTexCoord2f(magnifyULeft, magnifyVBottom); glVertex3f(lX, tY, -tlZ);
+        glTexCoord2f(magnifyURight, magnifyVBottom); glVertex3f(rX, tY, -trZ);
+        glTexCoord2f(magnifyURight, magnifyVTop); glVertex3f(rX, bY, -brZ);
+        glTexCoord2f(magnifyULeft, magnifyVTop); glVertex3f(lX, bY, -blZ);
+
+        glEnd();
+
+    } else {
+        leftX = sin(leftAngle) * _distance;
+        rightX = sin(rightAngle) * _distance;
+        leftZ = -cos(leftAngle) * _distance;
+        rightZ = -cos(rightAngle) * _distance;
+        if (_uiType == CURVED_SEMICIRCLE) {
+            topZ = -cos(topAngle * overlayAspectRatio) * _distance;
+            bottomZ = -cos(bottomAngle * overlayAspectRatio) * _distance;
+        } else {
+            // Dont want to use topZ or bottomZ for SEMICIRCLE
+            topZ = -99999;
+            bottomZ = -99999;
+        }
+
+        float bottomY = (1.0 - newMouseY / (float)widgetHeight) * halfOverlayHeight * 2.0f - halfOverlayHeight;
+        float topY = bottomY + (newHeight / widgetHeight) * halfOverlayHeight * 2;
+
+        //TODO: Remove immediate mode in favor of VBO
+        glBegin(GL_QUADS);
+
+        glTexCoord2f(magnifyULeft, magnifyVBottom); glVertex3f(leftX, topY, max(topZ, leftZ));
+        glTexCoord2f(magnifyURight, magnifyVBottom); glVertex3f(rightX, topY, max(topZ, rightZ));
+        glTexCoord2f(magnifyURight, magnifyVTop); glVertex3f(rightX, bottomY, max(bottomZ, rightZ));
+        glTexCoord2f(magnifyULeft, magnifyVTop); glVertex3f(leftX, bottomY, max(bottomZ, leftZ));
+
+        glEnd();
+    }
     glDepthMask(GL_FALSE);   
     glDisable(GL_ALPHA_TEST);
 
     //TODO: Remove immediate mode in favor of VBO
-    glBegin(GL_QUADS);
+    if (_uiType == HEMISPHERE) {
-    // Place the vertices in a semicircle curve around the camera
+        renderTexturedHemisphere();
-    for (int i = 0; i < numHorizontalVertices-1; i++) {
+    } else{
+        glBegin(GL_QUADS);
+        // Place the vertices in a semicircle curve around the camera
+        for (int i = 0; i < numHorizontalVertices - 1; i++) {
+            for (int j = 0; j < numVerticalVertices - 1; j++) {
 
-        // Calculate the X and Z coordinates from the angles and radius from camera
+                // Calculate the X and Z coordinates from the angles and radius from camera
-        leftX = sin(angleIncrement * i - halfHorizontalAngle) * _distance;
+                leftX = sin(angleIncrement * i - halfHorizontalAngle) * _distance;
-        rightX = sin(angleIncrement * (i + 1) - halfHorizontalAngle) * _distance;
+                rightX = sin(angleIncrement * (i + 1) - halfHorizontalAngle) * _distance;
-        leftZ = -cos(angleIncrement * i - halfHorizontalAngle) * _distance;
+                leftZ = -cos(angleIncrement * i - halfHorizontalAngle) * _distance;
-        rightZ = -cos(angleIncrement * (i + 1) - halfHorizontalAngle) * _distance;
+                rightZ = -cos(angleIncrement * (i + 1) - halfHorizontalAngle) * _distance;
+                if (_uiType == 2) {
+                    topZ = -cos((verticalAngleIncrement * (j + 1) - halfVerticalAngle) * overlayAspectRatio) * _distance;
+                    bottomZ = -cos((verticalAngleIncrement * j - halfVerticalAngle) * overlayAspectRatio) * _distance;
+                } else {
+                    topZ = -99999;
+                    bottomZ = -99999;
+                }
 
-        glTexCoord2f(quadTexWidth * i, 1); glVertex3f(leftX, halfOverlayHeight, leftZ);
+                glTexCoord2f(quadTexWidth * i, (j + 1) * quadTexHeight); 
-        glTexCoord2f(quadTexWidth * (i + 1), 1); glVertex3f(rightX,  halfOverlayHeight, rightZ);
+                glVertex3f(leftX, (j + 1) * quadTexHeight * overlayHeight - halfOverlayHeight, max(topZ, leftZ));
-        glTexCoord2f(quadTexWidth * (i + 1), 0); glVertex3f(rightX, -halfOverlayHeight, rightZ);
+                glTexCoord2f(quadTexWidth * (i + 1), (j + 1) * quadTexHeight); 
-        glTexCoord2f(quadTexWidth * i, 0); glVertex3f(leftX, -halfOverlayHeight, leftZ);
+                glVertex3f(rightX, (j + 1) * quadTexHeight * overlayHeight - halfOverlayHeight, max(topZ, rightZ));
+                glTexCoord2f(quadTexWidth * (i + 1), j * quadTexHeight); 
+                glVertex3f(rightX, j * quadTexHeight * overlayHeight - halfOverlayHeight, max(bottomZ, rightZ));
+                glTexCoord2f(quadTexWidth * i, j * quadTexHeight); 
+                glVertex3f(leftX, j * quadTexHeight * overlayHeight - halfOverlayHeight, max(bottomZ, leftZ));
+            }
+        }
+
+        glEnd();
     }
 
-    glEnd();
-
     glPopMatrix();
 
-    
     glDepthMask(GL_TRUE);
     glBindTexture(GL_TEXTURE_2D, 0);
     glDisable(GL_TEXTURE_2D);
@@ -466,13 +538,106 @@ void ApplicationOverlay::displayOverlayTextureOculus(Camera& whichCamera) {
 
 }
 
+void ApplicationOverlay::renderTexturedHemisphere() {
+    const int slices = 80;
+    const int stacks = 80;
+
+    static VerticesIndices vbo(0, 0);
+    int vertices = slices * (stacks - 1) + 1;
+    int indices = slices * 2 * 3 * (stacks - 2) + slices * 3;
+    if (vbo.first == 0) {
+        TextureVertex* vertexData = new TextureVertex[vertices];
+        TextureVertex* vertex = vertexData;
+        for (int i = 0; i < stacks - 1; i++) {
+            float phi = PI_OVER_TWO * (float)i / (float)(stacks - 1);
+            float z = -sinf(phi), radius = cosf(phi);
+
+            for (int j = 0; j < slices; j++) {
+                float theta = TWO_PI * (float)j / (float)slices;
+
+                vertex->position.x = sinf(theta) * radius;
+                vertex->position.y = cosf(theta) * radius;
+                vertex->position.z = z;
+                vertex->uv.x = asin(vertex->position.x) / (textureFov) + 0.5f;
+                vertex->uv.y = asin(vertex->position.y) / (textureFov) + 0.5f;
+                vertex++;
+            }
+        }
+        vertex->position.x = 0.0f;
+        vertex->position.y = 0.0f;
+        vertex->position.z = -1.0f;
+        vertex->uv.x = 0.5f;
+        vertex->uv.y = 0.5f;
+        vertex++;
+
+        glGenBuffers(1, &vbo.first);
+        glBindBuffer(GL_ARRAY_BUFFER, vbo.first);
+        const int BYTES_PER_VERTEX = sizeof(TextureVertex);
+        glBufferData(GL_ARRAY_BUFFER, vertices * BYTES_PER_VERTEX, vertexData, GL_STATIC_DRAW);
+        delete[] vertexData;
+
+        GLushort* indexData = new GLushort[indices];
+        GLushort* index = indexData;
+        for (int i = 0; i < stacks - 2; i++) {
+            GLushort bottom = i * slices;
+            GLushort top = bottom + slices;
+            for (int j = 0; j < slices; j++) {
+                int next = (j + 1) % slices;
+
+                *(index++) = bottom + j;
+                *(index++) = top + next;
+                *(index++) = top + j;
+
+                *(index++) = bottom + j;
+                *(index++) = bottom + next;
+                *(index++) = top + next;
+            }
+        }
+        GLushort bottom = (stacks - 2) * slices;
+        GLushort top = bottom + slices;
+        for (int i = 0; i < slices; i++) {
+            *(index++) = bottom + i;
+            *(index++) = bottom + (i + 1) % slices;
+            *(index++) = top;
+        }
+
+        glGenBuffers(1, &vbo.second);
+        glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, vbo.second);
+        const int BYTES_PER_INDEX = sizeof(GLushort);
+        glBufferData(GL_ELEMENT_ARRAY_BUFFER, indices * BYTES_PER_INDEX, indexData, GL_STATIC_DRAW);
+        delete[] indexData;
+
+    } else {
+        glBindBuffer(GL_ARRAY_BUFFER, vbo.first);
+        glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, vbo.second);
+    }
+ 
+    glEnableClientState(GL_VERTEX_ARRAY);
+    glEnableClientState(GL_TEXTURE_COORD_ARRAY);
+
+    glVertexPointer(3, GL_FLOAT, sizeof(TextureVertex), (void*)0);
+    glTexCoordPointer(2, GL_FLOAT, sizeof(TextureVertex), (void*)12);
+    
+    glDrawRangeElements(GL_TRIANGLES, 0, vertices - 1, indices, GL_UNSIGNED_SHORT, 0);
+
+    glDisableClientState(GL_VERTEX_ARRAY);
+    glDisableClientState(GL_TEXTURE_COORD_ARRAY);
+
+    glBindBuffer(GL_ARRAY_BUFFER, 0);
+    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
+
+}
+
 QOpenGLFramebufferObject* ApplicationOverlay::getFramebufferObject() {
     if (!_framebufferObject) {
         _framebufferObject = new QOpenGLFramebufferObject(Application::getInstance()->getGLWidget()->size());
-
         glBindTexture(GL_TEXTURE_2D, _framebufferObject->texture());
         glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
         glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
+        GLfloat borderColor[4] = { 0.0f, 0.0f, 0.0f, 0.0f };
+        glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_BORDER);
+        glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_BORDER);
+        glTexParameterfv(GL_TEXTURE_2D, GL_TEXTURE_BORDER_COLOR, borderColor);
         glBindTexture(GL_TEXTURE_2D, 0);
     }
     return _framebufferObject;

interface/src/ui/ApplicationOverlay.h

@@ -19,6 +19,8 @@ class QOpenGLFramebufferObject;
 class ApplicationOverlay {
 public:
 
+    static enum UITYPES { HEMISPHERE, SEMICIRCLE, CURVED_SEMICIRCLE };
+
     ApplicationOverlay();
     ~ApplicationOverlay();
 
@@ -32,14 +34,24 @@ public:
 
     // Setters
     void setOculusAngle(float oculusAngle) { _oculusAngle = oculusAngle; }
+    void setUiType(UITYPES uiType) { _uiType = uiType; }
 
 private:
+    // Interleaved vertex data
+    struct TextureVertex {
+        glm::vec3 position;
+        glm::vec2 uv;
+    };
+
+    typedef QPair<GLuint, GLuint> VerticesIndices;
+
+    void renderTexturedHemisphere();
 
-    ProgramObject _textureProgram;
     QOpenGLFramebufferObject* _framebufferObject;
     float _trailingAudioLoudness;
     float _oculusAngle;
     float _distance;
+    int _uiType;
 };
 
 #endif // hifi_ApplicationOverlay_h