Merge pull request #802 from ey6es/master

Added a textured rendering mode for depth data that doesn't use video input; rather, it computes normals from the depth and uses local lighting.

interface/resources/shaders/face_textured.frag

@@ -0,0 +1,83 @@
+#version 120
+
+//
+//  face_textured.frag
+//  fragment shader
+//
+//  Created by Andrzej Kapolka on 8/6/13.
+//  Copyright (c) 2013 High Fidelity, Inc. All rights reserved.
+//
+
+// the texture coordinate vector from left to right
+uniform vec2 texCoordRight;
+
+// the texture coordinate vector from bottom to the top
+uniform vec2 texCoordUp;
+
+// the permutation/normal texture
+uniform sampler2D permutationNormalTexture;
+
+// the depth texture
+uniform sampler2D depthTexture;
+
+// the position in model space
+varying vec3 position;
+
+// returns the gradient at a single corner of our sampling cube
+vec3 grad(vec3 location) {
+    float p1 = texture2D(permutationNormalTexture, vec2(location.x / 256.0, 0.25)).r;
+    float p2 = texture2D(permutationNormalTexture, vec2(p1 + location.y / 256.0, 0.25)).r;
+    return texture2D(permutationNormalTexture, vec2(p2 + location.z / 256.0, 0.75)).xyz * 2.0 - vec3(1.0, 1.0, 1.0);
+}
+
+// returns the perlin noise value for the specified location
+float perlin(vec3 location) {
+    vec3 floors = floor(location);
+    vec3 ceils = ceil(location);
+    vec3 fff = grad(floors);
+    vec3 ffc = grad(vec3(floors.x, floors.y, ceils.z));
+    vec3 fcf = grad(vec3(floors.x, ceils.y, floors.z));
+    vec3 fcc = grad(vec3(floors.x, ceils.y, ceils.z));
+    vec3 cff = grad(vec3(ceils.x, floors.y, floors.z));
+    vec3 cfc = grad(vec3(ceils.x, floors.y, ceils.z));
+    vec3 ccf = grad(vec3(ceils.x, ceils.y, floors.z));
+    vec3 ccc = grad(ceils);
+    vec3 ffracts = fract(location);
+    vec3 cfracts = ffracts - vec3(1.0, 1.0, 1.0);
+    vec3 params = ffracts*ffracts*(3.0 - 2.0*ffracts);
+    
+    float fffv = dot(fff, ffracts);
+    float ffcv = dot(ffc, vec3(ffracts.x, ffracts.y, cfracts.z));
+    float fcfv = dot(fcf, vec3(ffracts.x, cfracts.y, ffracts.z));
+    float fccv = dot(fcc, vec3(ffracts.x, cfracts.y, cfracts.z));
+    float cffv = dot(cff, vec3(cfracts.x, ffracts.y, ffracts.z));
+    float cfcv = dot(cfc, vec3(cfracts.x, ffracts.y, cfracts.z));
+    float ccfv = dot(ccf, vec3(cfracts.x, cfracts.y, ffracts.z)); 
+    float cccv = dot(ccc, cfracts);
+    
+    return mix(
+        mix(mix(fffv, cffv, params.x), mix(fcfv, ccfv, params.x), params.y),
+        mix(mix(ffcv, cfcv, params.x), mix(fccv, cccv, params.x), params.y),
+        params.z);
+}
+
+void main(void) {
+    // compute normal from adjacent depth values
+    float left = texture2D(depthTexture, gl_TexCoord[0].st - texCoordRight * 0.01).r;
+    float right = texture2D(depthTexture, gl_TexCoord[0].st + texCoordRight * 0.01).r;
+    float bottom = texture2D(depthTexture, gl_TexCoord[0].st - texCoordUp * 0.01).r;
+    float top = texture2D(depthTexture, gl_TexCoord[0].st + texCoordUp * 0.01).r;
+    vec3 normal = normalize(gl_NormalMatrix * vec3(left - right, top - bottom, -0.05));
+    
+    // compute the specular component (sans exponent) based on the normal OpenGL lighting model
+    float specular = max(0.0, dot(normalize(gl_LightSource[0].position.xyz + vec3(0.0, 0.0, 1.0)), normal));
+    
+    // the base color is a subtle marble texture produced by modulating the phase of a sine wave by perlin noise
+    vec3 color = mix(vec3(1.0, 1.0, 1.0), vec3(0.75, 0.75, 0.75),
+        sin(dot(position, vec3(25.0, 25.0, 25.0)) + 2.0 * perlin(position * 10.0)));
+    
+    // standard lighting
+    gl_FragColor = vec4(color * ( gl_LightModel.ambient.rgb + /* gl_LightSource[0].ambient.rgb + */
+        gl_LightSource[0].diffuse.rgb * max(0.0, dot(normal, gl_LightSource[0].position.xyz))) +
+            pow(specular, gl_FrontMaterial.shininess) * gl_FrontLightProduct[0].specular.rgb, gl_Color.a);
+}

interface/resources/shaders/face_textured.vert

@@ -0,0 +1,38 @@
+#version 120
+
+//
+//  face_textured.vert
+//  vertex shader
+//
+//  Created by Andrzej Kapolka on 8/6/13.
+//  Copyright (c) 2013 High Fidelity, Inc. All rights reserved.
+//
+
+// the lower left texture coordinate
+uniform vec2 texCoordCorner;
+
+// the texture coordinate vector from left to right
+uniform vec2 texCoordRight;
+
+// the texture coordinate vector from bottom to the top
+uniform vec2 texCoordUp;
+
+// the depth texture
+uniform sampler2D depthTexture;
+
+// the position in model space
+varying vec3 position;
+
+void main(void) {
+    gl_TexCoord[0] = vec4(texCoordCorner + gl_Vertex.x * texCoordRight + gl_Vertex.y * texCoordUp, 0.0, 1.0);
+    float depth = texture2D(depthTexture, gl_TexCoord[0].st).r;
+    
+    // store the model space vertex
+    position = gl_Vertex.xyz;
+    
+    // set alpha to zero for invalid depth values
+    const float MIN_VISIBLE_DEPTH = 1.0 / 255.0;
+    const float MAX_VISIBLE_DEPTH = 254.0 / 255.0;
+    gl_FrontColor = vec4(1.0, 1.0, 1.0, step(MIN_VISIBLE_DEPTH, depth) * (1.0 - step(MAX_VISIBLE_DEPTH, depth)));
+    gl_Position = gl_ModelViewProjectionMatrix * vec4(0.5 - gl_Vertex.x, gl_Vertex.y - 0.5, depth - 0.5, 1.0);
+}

interface/src/Application.cpp

@@ -1952,10 +1952,11 @@ void Application::initMenu() {
     _testPing->setChecked(true);
     (_fullScreenMode = optionsMenu->addAction("Fullscreen", this, SLOT(setFullscreen(bool)), Qt::Key_F))->setCheckable(true);
     optionsMenu->addAction("Webcam", &_webcam, SLOT(setEnabled(bool)))->setCheckable(true);
-    optionsMenu->addAction("Toggle Skeleton Tracking", &_webcam, SLOT(setSkeletonTrackingOn(bool)))->setCheckable(true);
+    optionsMenu->addAction("Skeleton Tracking", &_webcam, SLOT(setSkeletonTrackingOn(bool)))->setCheckable(true);
     (_wantCollisionsOn = optionsMenu->addAction("Turn collisions On", this, SLOT(toggleWantCollisionsOn())))->setCheckable(true);
     _wantCollisionsOn->setChecked(true);
     optionsMenu->addAction("Cycle Webcam Send Mode", _webcam.getGrabber(), SLOT(cycleVideoSendMode()));
+    optionsMenu->addAction("Webcam Texture", _webcam.getGrabber(), SLOT(setDepthOnly(bool)))->setCheckable(true);
     optionsMenu->addAction("Go Home", this, SLOT(goHome()), Qt::CTRL | Qt::Key_G);
     
     QMenu* audioMenu = menuBar->addMenu("Audio");

interface/src/Application.h

@@ -31,7 +31,6 @@
 #include "Environment.h"
 #include "PacketHeaders.h"
 #include "ParticleSystem.h"
-#include "renderer/GeometryCache.h"
 #include "SerialInterface.h"
 #include "Stars.h"
 #include "Swatch.h"
@@ -43,6 +42,8 @@
 #include "PieMenu.h"
 #include "avatar/Avatar.h"
 #include "avatar/HandControl.h"
+#include "renderer/GeometryCache.h"
+#include "renderer/TextureCache.h"
 #include "ui/BandwidthDialog.h"
 #include "ui/ChatEntry.h"
 #include "ui/VoxelStatsDialog.h"
@@ -116,6 +117,7 @@ public:
     
     QNetworkAccessManager* getNetworkAccessManager() { return _networkAccessManager; }
     GeometryCache* getGeometryCache() { return &_geometryCache; }
+    TextureCache* getTextureCache() { return &_textureCache; }
     
     void resetSongMixMenuItem();
     void setupWorldLight(Camera& whichCamera);
@@ -438,6 +440,7 @@ private:
     int _hmdWarpParamLocation;
     
     GeometryCache _geometryCache;
+    TextureCache _textureCache;
     
     ParticleSystem _particleSystem;
     

interface/src/VoxelSystem.cpp

@@ -17,8 +17,6 @@
 #include <fstream> // to load voxels from file
 #include <pthread.h>
 
-#include <glm/gtc/random.hpp>
-
 #include <OctalCode.h>
 #include <PacketHeaders.h>
 #include <PerfStat.h>
@@ -493,7 +491,6 @@ glm::vec3 VoxelSystem::computeVoxelVertex(const glm::vec3& startVertex, float vo
 }
 
 ProgramObject* VoxelSystem::_perlinModulateProgram = 0;
-GLuint VoxelSystem::_permutationNormalTextureID = 0;
 
 void VoxelSystem::init() {
 
@@ -585,29 +582,9 @@ void VoxelSystem::init() {
     _perlinModulateProgram->addShaderFromSourceFile(QGLShader::Fragment, "resources/shaders/perlin_modulate.frag");
     _perlinModulateProgram->link();
     
+    _perlinModulateProgram->bind();
     _perlinModulateProgram->setUniformValue("permutationNormalTexture", 0);
-    
+    _perlinModulateProgram->release();
-    // create the permutation/normal texture
-    glGenTextures(1, &_permutationNormalTextureID);
-    glBindTexture(GL_TEXTURE_2D, _permutationNormalTextureID);
-    
-    // the first line consists of random permutation offsets
-    unsigned char data[256 * 2 * 3];
-    for (int i = 0; i < 256 * 3; i++) {
-        data[i] = rand() % 256;
-    }
-    // the next, random unit normals
-    for (int i = 256 * 3; i < 256 * 3 * 2; i += 3) {
-        glm::vec3 randvec = glm::sphericalRand(1.0f);
-        data[i] = ((randvec.x + 1.0f) / 2.0f) * 255.0f;
-        data[i + 1] = ((randvec.y + 1.0f) / 2.0f) * 255.0f;
-        data[i + 2] = ((randvec.z + 1.0f) / 2.0f) * 255.0f;
-    }
-    glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, 256, 2, 0, GL_RGB, GL_UNSIGNED_BYTE, data);
-    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
-    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
-    
-    glBindTexture(GL_TEXTURE_2D, 0);
 }
 
 void VoxelSystem::updateFullVBOs() {
@@ -734,7 +711,7 @@ void VoxelSystem::applyScaleAndBindProgram(bool texture) {
 
     if (texture) {
         _perlinModulateProgram->bind();
-        glBindTexture(GL_TEXTURE_2D, _permutationNormalTextureID);
+        glBindTexture(GL_TEXTURE_2D, Application::getInstance()->getTextureCache()->getPermutationNormalTextureID());
     }
 }
 

interface/src/VoxelSystem.h

@@ -196,7 +196,6 @@ private:
     bool _voxelsDirty;
     
     static ProgramObject* _perlinModulateProgram;
-    static GLuint _permutationNormalTextureID;
     
     int _hookID;
     std::vector<glBufferIndex> _freeIndexes;

interface/src/Webcam.cpp

@@ -71,16 +71,17 @@ void Webcam::reset() {
 }
 
 void Webcam::renderPreview(int screenWidth, int screenHeight) {
-    if (_enabled && _colorTextureID != 0) {
+    if (_enabled) {
-        glBindTexture(GL_TEXTURE_2D, _colorTextureID);
         glEnable(GL_TEXTURE_2D);
         glColor3f(1.0f, 1.0f, 1.0f);
-        glBegin(GL_QUADS);
+        
         const int PREVIEW_HEIGHT = 200;
         int previewWidth = _textureSize.width * PREVIEW_HEIGHT / _textureSize.height;
         int top = screenHeight - 600;
         int left = screenWidth - previewWidth - 10;
-
+        if (_colorTextureID != 0) {
+            glBindTexture(GL_TEXTURE_2D, _colorTextureID);        
+            glBegin(GL_QUADS);
                 glTexCoord2f(0, 0);
                 glVertex2f(left, top);
                 glTexCoord2f(1, 0);
@@ -90,6 +91,7 @@ void Webcam::renderPreview(int screenWidth, int screenHeight) {
                 glTexCoord2f(0, 1);
                 glVertex2f(left, top + PREVIEW_HEIGHT);
             glEnd();
+        }
         
         if (_depthTextureID != 0) {
             glBindTexture(GL_TEXTURE_2D, _depthTextureID);
@@ -157,6 +159,7 @@ const float METERS_PER_MM = 1.0f / 1000.0f;
 
 void Webcam::setFrame(const Mat& color, int format, const Mat& depth, float midFaceDepth,
         float aspectRatio, const RotatedRect& faceRect, bool sending, const JointVector& joints) {
+    if (!color.empty()) {
         IplImage colorImage = color;
         glPixelStorei(GL_UNPACK_ROW_LENGTH, colorImage.widthStep / 3);
         if (_colorTextureID == 0) {
@@ -165,13 +168,16 @@ void Webcam::setFrame(const Mat& color, int format, const Mat& depth, float midF
             glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, _textureSize.width = colorImage.width, _textureSize.height = colorImage.height,
                 0, format, GL_UNSIGNED_BYTE, colorImage.imageData);
             glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
-        qDebug("Capturing video at %gx%g.\n", _textureSize.width, _textureSize.height);
             
         } else {
             glBindTexture(GL_TEXTURE_2D, _colorTextureID);
             glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, _textureSize.width, _textureSize.height, format,
                 GL_UNSIGNED_BYTE, colorImage.imageData);
         }
+    } else if (_colorTextureID != 0) {
+        glDeleteTextures(1, &_colorTextureID);
+        _colorTextureID = 0;
+    }
     
     if (!depth.empty()) {
         IplImage depthImage = depth;
@@ -189,6 +195,9 @@ void Webcam::setFrame(const Mat& color, int format, const Mat& depth, float midF
             glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, _textureSize.width, _textureSize.height, GL_LUMINANCE,
                 GL_UNSIGNED_BYTE, depthImage.imageData);
         }
+    } else if (_depthTextureID != 0) {
+        glDeleteTextures(1, &_depthTextureID);
+        _depthTextureID = 0;
     }
     glPixelStorei(GL_UNPACK_ROW_LENGTH, 0);
     glBindTexture(GL_TEXTURE_2D, 0);
@@ -273,8 +282,8 @@ void Webcam::setFrame(const Mat& color, int format, const Mat& depth, float midF
     QTimer::singleShot(qMax((int)remaining / 1000, 0), _grabber, SLOT(grabFrame()));
 }
 
-FrameGrabber::FrameGrabber() : _initialized(false), _videoSendMode(FULL_FRAME_VIDEO), _capture(0), _searchWindow(0, 0, 0, 0),
+FrameGrabber::FrameGrabber() : _initialized(false), _videoSendMode(FULL_FRAME_VIDEO), _depthOnly(false), _capture(0),
-    _smoothedMidFaceDepth(UNINITIALIZED_FACE_DEPTH), _colorCodec(), _depthCodec(), _frameCount(0) {
+    _searchWindow(0, 0, 0, 0), _smoothedMidFaceDepth(UNINITIALIZED_FACE_DEPTH), _colorCodec(), _depthCodec(), _frameCount(0) {
 }
 
 FrameGrabber::~FrameGrabber() {
@@ -374,6 +383,11 @@ void FrameGrabber::cycleVideoSendMode() {
     destroyCodecs();
 }
 
+void FrameGrabber::setDepthOnly(bool depthOnly) {
+    _depthOnly = depthOnly;
+    destroyCodecs();
+}
+
 void FrameGrabber::reset() {
     _searchWindow = cv::Rect(0, 0, 0, 0);
 
@@ -479,7 +493,7 @@ void FrameGrabber::grabFrame() {
         encodedWidth = color.cols;
         encodedHeight = color.rows;
         aspectRatio = FULL_FRAME_ASPECT;
-        colorBitrateMultiplier = 4.0f;
+        colorBitrateMultiplier = depthBitrateMultiplier = 4.0f;
 
     } else {
         // if we don't have a search window (yet), try using the face cascade
@@ -591,10 +605,26 @@ void FrameGrabber::grabFrame() {
         depth.convertTo(_grayDepthFrame, CV_8UC1, 1.0, depthOffset);
     }
 
+    // increment the frame count that identifies frames
+    _frameCount++;
+    
     QByteArray payload;    
     if (_videoSendMode != NO_VIDEO) {
+        // start the payload off with the aspect ratio (zero for full frame)
+        payload.append((const char*)&aspectRatio, sizeof(float));
+   
+        // prepare the image in which we'll store the data
+        const int ENCODED_BITS_PER_Y = 8;
+        const int ENCODED_BITS_PER_VU = 2;
+        const int ENCODED_BITS_PER_PIXEL = ENCODED_BITS_PER_Y + 2 * ENCODED_BITS_PER_VU;
+        const int BITS_PER_BYTE = 8;
+        _encodedFace.resize(encodedWidth * encodedHeight * ENCODED_BITS_PER_PIXEL / BITS_PER_BYTE);
+        vpx_image_t vpxImage;
+        vpx_img_wrap(&vpxImage, VPX_IMG_FMT_YV12, encodedWidth, encodedHeight, 1, (unsigned char*)_encodedFace.data());
+        
+        if (!_depthOnly || depth.empty()) {
             if (_colorCodec.name == 0) {
-            // initialize encoder context(s)
+                // initialize encoder context
                 vpx_codec_enc_cfg_t codecConfig;
                 vpx_codec_enc_config_default(vpx_codec_vp8_cx(), &codecConfig, 0);
                 codecConfig.rc_target_bitrate = ENCODED_FACE_WIDTH * ENCODED_FACE_HEIGHT * colorBitrateMultiplier *
@@ -602,14 +632,8 @@ void FrameGrabber::grabFrame() {
                 codecConfig.g_w = encodedWidth;
                 codecConfig.g_h = encodedHeight;
                 vpx_codec_enc_init(&_colorCodec, vpx_codec_vp8_cx(), &codecConfig, 0);
-
-            if (!depth.empty()) {
-                codecConfig.rc_target_bitrate *= depthBitrateMultiplier;
-                vpx_codec_enc_init(&_depthCodec, vpx_codec_vp8_cx(), &codecConfig, 0);
-            }
             }
 
-        Mat transform;
             if (_videoSendMode == FACE_VIDEO) {
                 // resize/rotate face into encoding rectangle
                 _faceColor.create(encodedHeight, encodedWidth, CV_8UC3);
@@ -621,14 +645,6 @@ void FrameGrabber::grabFrame() {
 
             // convert from RGB to YV12: see http://www.fourcc.org/yuv.php and
             // http://docs.opencv.org/modules/imgproc/doc/miscellaneous_transformations.html#cvtcolor
-        const int ENCODED_BITS_PER_Y = 8;
-        const int ENCODED_BITS_PER_VU = 2;
-        const int ENCODED_BITS_PER_PIXEL = ENCODED_BITS_PER_Y + 2 * ENCODED_BITS_PER_VU;
-        const int BITS_PER_BYTE = 8;
-        _encodedFace.resize(encodedWidth * encodedHeight * ENCODED_BITS_PER_PIXEL / BITS_PER_BYTE);
-        vpx_image_t vpxImage;
-        vpx_img_wrap(&vpxImage, VPX_IMG_FMT_YV12, encodedWidth, encodedHeight, 1,
-            (unsigned char*)_encodedFace.data());
             uchar* yline = vpxImage.planes[0];
             uchar* vline = vpxImage.planes[1];
             uchar* uline = vpxImage.planes[2];
@@ -676,10 +692,7 @@ void FrameGrabber::grabFrame() {
             }
 
             // encode the frame
-        vpx_codec_encode(&_colorCodec, &vpxImage, ++_frameCount, 1, 0, VPX_DL_REALTIME);
+            vpx_codec_encode(&_colorCodec, &vpxImage, _frameCount, 1, 0, VPX_DL_REALTIME);
-
-        // start the payload off with the aspect ratio (zero for full frame)
-        payload.append((const char*)&aspectRatio, sizeof(float));
 
             // extract the encoded frame
             vpx_codec_iter_t iterator = 0;
@@ -691,8 +704,30 @@ void FrameGrabber::grabFrame() {
                     payload.append((const char*)packet->data.frame.buf, packet->data.frame.sz);
                 }
             }
+        } else {
+            // zero length indicates no color info
+            const size_t ZERO_SIZE = 0;
+            payload.append((const char*)&ZERO_SIZE, sizeof(size_t));
+            
+            // we can use more bits for depth
+            depthBitrateMultiplier *= 2.0f;
+            
+            // don't bother reporting the color
+            color = Mat();
+        }
         
         if (!depth.empty()) {
+            if (_depthCodec.name == 0) {
+                // initialize encoder context
+                vpx_codec_enc_cfg_t codecConfig;
+                vpx_codec_enc_config_default(vpx_codec_vp8_cx(), &codecConfig, 0);
+                codecConfig.rc_target_bitrate = ENCODED_FACE_WIDTH * ENCODED_FACE_HEIGHT * depthBitrateMultiplier *
+                    codecConfig.rc_target_bitrate / codecConfig.g_w / codecConfig.g_h;
+                codecConfig.g_w = encodedWidth;
+                codecConfig.g_h = encodedHeight;
+                vpx_codec_enc_init(&_depthCodec, vpx_codec_vp8_cx(), &codecConfig, 0);
+            }
+            
             // convert with mask
             uchar* yline = vpxImage.planes[0];
             uchar* vline = vpxImage.planes[1];

interface/src/Webcam.h

@@ -112,6 +112,7 @@ public:
 public slots:
 
     void cycleVideoSendMode();
+    void setDepthOnly(bool depthOnly);
     void reset();
     void shutdown();
     void grabFrame();
@@ -126,6 +127,7 @@ private:
 
     bool _initialized;
     VideoSendMode _videoSendMode;
+    bool _depthOnly;
     CvCapture* _capture;
     cv::CascadeClassifier _faceCascade;
     cv::Mat _hsvFrame;

interface/src/avatar/Face.cpp

@@ -22,10 +22,10 @@
 
 using namespace cv;
 
-ProgramObject* Face::_program = 0;
+ProgramObject* Face::_videoProgram = 0;
-int Face::_texCoordCornerLocation;
+Face::Locations Face::_videoProgramLocations;
-int Face::_texCoordRightLocation;
+ProgramObject* Face::_texturedProgram = 0;
-int Face::_texCoordUpLocation;
+Face::Locations Face::_texturedProgramLocations;
 GLuint Face::_vboID;
 GLuint Face::_iboID;
 
@@ -71,6 +71,7 @@ void Face::setFrameFromWebcam() {
 
 void Face::clearFrame() {
     _colorTextureID = 0;
+    _depthTextureID = 0;
 }
     
 int Face::processVideoMessage(unsigned char* packetData, size_t dataBytes) {
@@ -111,28 +112,32 @@ int Face::processVideoMessage(unsigned char* packetData, size_t dataBytes) {
         return dataBytes;
     }
     
-    // the switch from full frame to not (or vice versa) requires us to reinit the codecs
+    // the switch between full frame or depth only modes requires us to reinit the codecs
     float aspectRatio = *(const float*)_arrivingFrame.constData();
+    size_t colorSize = *(const size_t*)(_arrivingFrame.constData() + sizeof(float));
     bool fullFrame = (aspectRatio == FULL_FRAME_ASPECT);
-    if (fullFrame != _lastFullFrame) {
+    bool depthOnly = (colorSize == 0);
+    if (fullFrame != _lastFullFrame || depthOnly != _lastDepthOnly) {
         destroyCodecs();
         _lastFullFrame = fullFrame;
+        _lastDepthOnly = depthOnly;
     }
     
+    // read the color data, if non-empty
+    Mat color;
+    const uint8_t* colorData = (const uint8_t*)(_arrivingFrame.constData() + sizeof(float) + sizeof(size_t));
+    if (colorSize > 0) {
         if (_colorCodec.name == 0) {
             // initialize decoder context
             vpx_codec_dec_init(&_colorCodec, vpx_codec_vp8_dx(), 0, 0);
         }
-    
-    size_t colorSize = *(const size_t*)(_arrivingFrame.constData() + sizeof(float));
-    const uint8_t* colorData = (const uint8_t*)(_arrivingFrame.constData() + sizeof(float) + sizeof(size_t));
         vpx_codec_decode(&_colorCodec, colorData, colorSize, 0, 0);
         vpx_codec_iter_t iterator = 0;
         vpx_image_t* image;
         while ((image = vpx_codec_get_frame(&_colorCodec, &iterator)) != 0) {
             // convert from YV12 to RGB: see http://www.fourcc.org/yuv.php and
             // http://docs.opencv.org/modules/imgproc/doc/miscellaneous_transformations.html#cvtcolor
-        Mat color(image->d_h, image->d_w, CV_8UC3);
+            color.create(image->d_h, image->d_w, CV_8UC3);
             uchar* yline = image->planes[0];
             uchar* vline = image->planes[1];
             uchar* uline = image->planes[2];
@@ -183,8 +188,14 @@ int Face::processVideoMessage(unsigned char* packetData, size_t dataBytes) {
                 vline += image->stride[1];
                 uline += image->stride[2];
             }
-        Mat depth;
+        }
+    } else if (_colorCodec.name != 0) {
+        vpx_codec_destroy(&_colorCodec);
+        _colorCodec.name = 0;
+    }
     
+    // read the depth data, if non-empty
+    Mat depth;
     const uint8_t* depthData = colorData + colorSize;
     int depthSize = _arrivingFrame.size() - ((const char*)depthData - _arrivingFrame.constData());
     if (depthSize > 0) {
@@ -223,16 +234,18 @@ int Face::processVideoMessage(unsigned char* packetData, size_t dataBytes) {
                 vline += image->stride[1];
             }
         }
+    } else if (_depthCodec.name != 0) {
+        vpx_codec_destroy(&_depthCodec);
+        _depthCodec.name = 0;
     }
     QMetaObject::invokeMethod(this, "setFrame", Q_ARG(cv::Mat, color),
         Q_ARG(cv::Mat, depth), Q_ARG(float, aspectRatio));
-    }
     
     return dataBytes;
 }
 
 bool Face::render(float alpha) {
-    if (_colorTextureID == 0 || _textureRect.size.area() == 0) {
+    if (!isActive()) {
         return false;
     }
     glPushMatrix();
@@ -275,20 +288,9 @@ bool Face::render(float alpha) {
         const int INDICES_PER_TRIANGLE = 3;
         const int INDEX_COUNT = QUAD_COUNT * TRIANGLES_PER_QUAD * INDICES_PER_TRIANGLE;
         
-        if (_program == 0) {
+        if (_videoProgram == 0) {
-            _program = new ProgramObject();
+            _videoProgram = loadProgram(QString(), "colorTexture", _videoProgramLocations);
-            _program->addShaderFromSourceFile(QGLShader::Vertex, "resources/shaders/face.vert");
+            _texturedProgram = loadProgram("_textured", "permutationNormalTexture", _texturedProgramLocations);
-            _program->addShaderFromSourceFile(QGLShader::Fragment, "resources/shaders/face.frag");
-            _program->link();
-            
-            _program->bind();
-            _program->setUniformValue("depthTexture", 0);
-            _program->setUniformValue("colorTexture", 1);
-            _program->release();
-            
-            _texCoordCornerLocation = _program->uniformLocation("texCoordCorner");
-            _texCoordRightLocation = _program->uniformLocation("texCoordRight");
-            _texCoordUpLocation = _program->uniformLocation("texCoordUp");
             
             glGenBuffers(1, &_vboID);
             glBindBuffer(GL_ARRAY_BUFFER, _vboID);
@@ -328,14 +330,23 @@ bool Face::render(float alpha) {
         glBindTexture(GL_TEXTURE_2D, _depthTextureID);
         
         glActiveTexture(GL_TEXTURE1);
+        
+        ProgramObject* program = _videoProgram;
+        Locations* locations = &_videoProgramLocations;
+        if (_colorTextureID != 0) {
             glBindTexture(GL_TEXTURE_2D, _colorTextureID);        
         
-        _program->bind();
+        } else {
-        _program->setUniformValue(_texCoordCornerLocation, 
+            glBindTexture(GL_TEXTURE_2D, Application::getInstance()->getTextureCache()->getPermutationNormalTextureID());
+            program = _texturedProgram;
+            locations = &_texturedProgramLocations;
+        }
+        program->bind();
+        program->setUniformValue(locations->texCoordCorner, 
             points[0].x / _textureSize.width, points[0].y / _textureSize.height);
-        _program->setUniformValue(_texCoordRightLocation,
+        program->setUniformValue(locations->texCoordRight,
             (points[3].x - points[0].x) / _textureSize.width, (points[3].y - points[0].y) / _textureSize.height);
-        _program->setUniformValue(_texCoordUpLocation,
+        program->setUniformValue(locations->texCoordUp,
             (points[1].x - points[0].x) / _textureSize.width, (points[1].y - points[0].y) / _textureSize.height);
         glEnableClientState(GL_VERTEX_ARRAY);
         glVertexPointer(2, GL_FLOAT, 0, 0);
@@ -357,7 +368,7 @@ bool Face::render(float alpha) {
         
         glDisableClientState(GL_VERTEX_ARRAY);
         glBindBuffer(GL_ARRAY_BUFFER, 0);
-        _program->release();
+        program->release();
         
         glBindTexture(GL_TEXTURE_2D, 0);
         glActiveTexture(GL_TEXTURE0);
@@ -392,53 +403,52 @@ void Face::cycleRenderMode() {
 }
 
 void Face::setFrame(const cv::Mat& color, const cv::Mat& depth, float aspectRatio) {
-    if (color.empty()) {
+    Size2f textureSize = _textureSize;
-        // release our textures, if any; there's no more video
+    if (!color.empty()) {
-        if (_colorTextureID != 0) {
+        bool generate = (_colorTextureID == 0);
-            glDeleteTextures(1, &_colorTextureID);
+        if (generate) {
-            _colorTextureID = 0;
-        }
-        if (_depthTextureID != 0) {
-            glDeleteTextures(1, &_depthTextureID);
-            _depthTextureID = 0;
-        }
-        return;
-    }
-
-    if (_colorTextureID == 0) {
             glGenTextures(1, &_colorTextureID);
         }
         glBindTexture(GL_TEXTURE_2D, _colorTextureID);
-    bool recreateTextures = (_textureSize.width != color.cols || _textureSize.height != color.rows);
+        if (_textureSize.width != color.cols || _textureSize.height != color.rows || generate) {
-    if (recreateTextures) {
             glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, color.cols, color.rows, 0, GL_RGB, GL_UNSIGNED_BYTE, color.ptr());
             glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
-        _textureSize = color.size();
+            textureSize = color.size();
-        _textureRect = RotatedRect(Point2f(color.cols * 0.5f, color.rows * 0.5f), _textureSize, 0.0f);
+            _textureRect = RotatedRect(Point2f(color.cols * 0.5f, color.rows * 0.5f), textureSize, 0.0f);
         
         } else {
             glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, color.cols, color.rows, GL_RGB, GL_UNSIGNED_BYTE, color.ptr());
         }
+    } else if (_colorTextureID != 0) {
+        glDeleteTextures(1, &_colorTextureID);
+        _colorTextureID = 0;
+    }
     
     if (!depth.empty()) {
-        if (_depthTextureID == 0) {
+        bool generate = (_depthTextureID == 0);
+        if (generate) {
             glGenTextures(1, &_depthTextureID);
         }
         glBindTexture(GL_TEXTURE_2D, _depthTextureID);
-        if (recreateTextures) {
+        if (_textureSize.width != depth.cols || _textureSize.height != depth.rows || generate) {
             glTexImage2D(GL_TEXTURE_2D, 0, GL_LUMINANCE, depth.cols, depth.rows, 0,
                 GL_LUMINANCE, GL_UNSIGNED_BYTE, depth.ptr());
             glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
             glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
+            textureSize = depth.size();
+            _textureRect = RotatedRect(Point2f(depth.cols * 0.5f, depth.rows * 0.5f), textureSize, 0.0f);
             
         } else {
-            glBindTexture(GL_TEXTURE_2D, _depthTextureID);
             glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, depth.cols, depth.rows, GL_LUMINANCE, GL_UNSIGNED_BYTE, depth.ptr());
         }
+    } else if (_depthTextureID != 0) {
+        glDeleteTextures(1, &_depthTextureID);
+        _depthTextureID = 0;
     }
     glBindTexture(GL_TEXTURE_2D, 0);
     
     _aspectRatio = aspectRatio;
+    _textureSize = textureSize;
 }
 
 void Face::destroyCodecs() {
@@ -451,3 +461,21 @@ void Face::destroyCodecs() {
         _depthCodec.name = 0;
     }
 }
+
+ProgramObject* Face::loadProgram(const QString& suffix, const char* secondTextureUniform, Locations& locations) {
+    ProgramObject* program = new ProgramObject();
+    program->addShaderFromSourceFile(QGLShader::Vertex, "resources/shaders/face" + suffix + ".vert");
+    program->addShaderFromSourceFile(QGLShader::Fragment, "resources/shaders/face" + suffix + ".frag");
+    program->link();
+    
+    program->bind();
+    program->setUniformValue("depthTexture", 0);
+    program->setUniformValue(secondTextureUniform, 1);
+    program->release();
+    
+    locations.texCoordCorner = program->uniformLocation("texCoordCorner");
+    locations.texCoordRight = program->uniformLocation("texCoordRight");
+    locations.texCoordUp = program->uniformLocation("texCoordUp");
+    
+    return program;
+}

interface/src/avatar/Face.h

@@ -30,7 +30,8 @@ public:
     Face(Head* owningHead);
     ~Face();
 
-    bool isFullFrame() const { return _colorTextureID != 0 && _aspectRatio == FULL_FRAME_ASPECT; }
+    bool isActive() const { return _colorTextureID != 0 || _depthTextureID != 0; }
+    bool isFullFrame() const { return isActive() && _aspectRatio == FULL_FRAME_ASPECT; }
 
     void setFrameFromWebcam();
     void clearFrame();
@@ -64,15 +65,26 @@ private:
     vpx_codec_ctx_t _colorCodec;
     vpx_codec_ctx_t _depthCodec;
     bool _lastFullFrame;
+    bool _lastDepthOnly;
     
     QByteArray _arrivingFrame;
     int _frameCount;
     int _frameBytesRemaining;
     
-    static ProgramObject* _program;
+    struct Locations {
-    static int _texCoordCornerLocation;
+        int texCoordCorner;
-    static int _texCoordRightLocation;
+        int texCoordRight;
-    static int _texCoordUpLocation;
+        int texCoordUp;
+    };
+
+    static ProgramObject* loadProgram(const QString& suffix, const char* secondTextureUniform, Locations& locations);
+    
+    static ProgramObject* _videoProgram;
+    static Locations _videoProgramLocations;
+    
+    static ProgramObject* _texturedProgram;
+    static Locations _texturedProgramLocations;
+    
     static GLuint _vboID;
     static GLuint _iboID;
 };

interface/src/renderer/TextureCache.cpp

@@ -0,0 +1,45 @@
+//
+//  TextureCache.cpp
+//  interface
+//
+//  Created by Andrzej Kapolka on 8/6/13.
+//  Copyright (c) 2013 High Fidelity, Inc. All rights reserved.
+
+#include <glm/gtc/random.hpp>
+
+#include "TextureCache.h"
+
+TextureCache::TextureCache() : _permutationNormalTextureID(0) {
+}
+
+TextureCache::~TextureCache() {
+    if (_permutationNormalTextureID != 0) {
+        glDeleteTextures(1, &_permutationNormalTextureID);
+    }
+}
+
+GLuint TextureCache::getPermutationNormalTextureID() {
+    if (_permutationNormalTextureID == 0) {
+        glGenTextures(1, &_permutationNormalTextureID);
+        glBindTexture(GL_TEXTURE_2D, _permutationNormalTextureID);
+        
+        // the first line consists of random permutation offsets
+        unsigned char data[256 * 2 * 3];
+        for (int i = 0; i < 256 * 3; i++) {
+            data[i] = rand() % 256;
+        }
+        // the next, random unit normals
+        for (int i = 256 * 3; i < 256 * 3 * 2; i += 3) {
+            glm::vec3 randvec = glm::sphericalRand(1.0f);
+            data[i] = ((randvec.x + 1.0f) / 2.0f) * 255.0f;
+            data[i + 1] = ((randvec.y + 1.0f) / 2.0f) * 255.0f;
+            data[i + 2] = ((randvec.z + 1.0f) / 2.0f) * 255.0f;
+        }
+        glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, 256, 2, 0, GL_RGB, GL_UNSIGNED_BYTE, data);
+        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
+        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
+        
+        glBindTexture(GL_TEXTURE_2D, 0);
+    }
+    return _permutationNormalTextureID;
+}

interface/src/renderer/TextureCache.h

@@ -0,0 +1,27 @@
+//
+//  TextureCache.h
+//  interface
+//
+//  Created by Andrzej Kapolka on 8/6/13.
+//  Copyright (c) 2013 High Fidelity, Inc. All rights reserved.
+//
+
+#ifndef __interface__TextureCache__
+#define __interface__TextureCache__
+
+#include "InterfaceConfig.h"
+
+class TextureCache {
+public:
+    
+    TextureCache();
+    ~TextureCache();
+    
+    GLuint getPermutationNormalTextureID();
+
+private:
+    
+    GLuint _permutationNormalTextureID;
+};
+
+#endif /* defined(__interface__TextureCache__) */