Merge branch 'master' of github.com:highfidelity/hifi into dice-on-table-1

interface/src/Application.cpp

@@ -3174,39 +3174,62 @@ void Application::displaySide(Camera& theCamera, bool selfAvatarOnly, RenderArgs
         glTexGenfv(GL_R, GL_EYE_PLANE, (const GLfloat*)&_shadowMatrices[i][2]);
     }
 
-    if (!selfAvatarOnly && Menu::getInstance()->isOptionChecked(MenuOption::Stars)) {
+    // Background rendering decision
-        PerformanceTimer perfTimer("stars");
+    auto skyStage = DependencyManager::get<SceneScriptingInterface>()->getSkyStage();
-        PerformanceWarning warn(Menu::getInstance()->isOptionChecked(MenuOption::PipelineWarnings),
+    if (skyStage->getBackgroundMode() == model::SunSkyStage::NO_BACKGROUND) {
-            "Application::displaySide() ... stars...");
+    } else if (skyStage->getBackgroundMode() == model::SunSkyStage::SKY_DOME) {
-        if (!_stars.isStarsLoaded()) {
+       if (!selfAvatarOnly && Menu::getInstance()->isOptionChecked(MenuOption::Stars)) {
-            _stars.generate(STARFIELD_NUM_STARS, STARFIELD_SEED);
+            PerformanceTimer perfTimer("stars");
-        }
+            PerformanceWarning warn(Menu::getInstance()->isOptionChecked(MenuOption::PipelineWarnings),
-        // should be the first rendering pass - w/o depth buffer / lighting
+                "Application::displaySide() ... stars...");
-
+            if (!_stars.isStarsLoaded()) {
-        // compute starfield alpha based on distance from atmosphere
+                _stars.generate(STARFIELD_NUM_STARS, STARFIELD_SEED);
-        float alpha = 1.0f;
-        bool hasStars = true;
-        if (Menu::getInstance()->isOptionChecked(MenuOption::Atmosphere)) {
-            // TODO: handle this correctly for zones
-            const EnvironmentData& closestData = _environment.getClosestData(theCamera.getPosition());
-            
-            if (closestData.getHasStars()) {
-                float height = glm::distance(theCamera.getPosition(), closestData.getAtmosphereCenter());
-                if (height < closestData.getAtmosphereInnerRadius()) {
-                    alpha = 0.0f;
-
-                } else if (height < closestData.getAtmosphereOuterRadius()) {
-                    alpha = (height - closestData.getAtmosphereInnerRadius()) /
-                        (closestData.getAtmosphereOuterRadius() - closestData.getAtmosphereInnerRadius());
-                }
-            } else {
-                hasStars = false;
             }
-        }
+            // should be the first rendering pass - w/o depth buffer / lighting
 
-        // finally render the starfield
+            // compute starfield alpha based on distance from atmosphere
-        if (hasStars) {
+            float alpha = 1.0f;
-            _stars.render(theCamera.getFieldOfView(), theCamera.getAspectRatio(), theCamera.getNearClip(), alpha);
+            bool hasStars = true;
+            if (Menu::getInstance()->isOptionChecked(MenuOption::Atmosphere)) {
+                // TODO: handle this correctly for zones
+                const EnvironmentData& closestData = _environment.getClosestData(theCamera.getPosition());
+            
+                if (closestData.getHasStars()) {
+                    float height = glm::distance(theCamera.getPosition(), closestData.getAtmosphereCenter());
+                    if (height < closestData.getAtmosphereInnerRadius()) {
+                        alpha = 0.0f;
+
+                    } else if (height < closestData.getAtmosphereOuterRadius()) {
+                        alpha = (height - closestData.getAtmosphereInnerRadius()) /
+                            (closestData.getAtmosphereOuterRadius() - closestData.getAtmosphereInnerRadius());
+                    }
+                } else {
+                    hasStars = false;
+                }
+            }
+
+            // finally render the starfield
+            if (hasStars) {
+                _stars.render(theCamera.getFieldOfView(), theCamera.getAspectRatio(), theCamera.getNearClip(), alpha);
+            }
+
+            // draw the sky dome
+            if (!selfAvatarOnly && Menu::getInstance()->isOptionChecked(MenuOption::Atmosphere)) {
+                PerformanceTimer perfTimer("atmosphere");
+                PerformanceWarning warn(Menu::getInstance()->isOptionChecked(MenuOption::PipelineWarnings),
+                    "Application::displaySide() ... atmosphere...");
+                _environment.renderAtmospheres(theCamera);
+            }
+
+        }
+    } else if (skyStage->getBackgroundMode() == model::SunSkyStage::SKY_BOX) {
+        auto skybox = skyStage->getSkybox();
+        if (skybox) {
+            gpu::Batch batch;
+            model::Skybox::render(batch, _viewFrustum, *skybox);
+
+            gpu::GLBackend::renderBatch(batch);
+            glUseProgram(0);
         }
     }
 
@@ -3214,13 +3237,6 @@ void Application::displaySide(Camera& theCamera, bool selfAvatarOnly, RenderArgs
         glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
     }
 
-    // draw the sky dome
-    if (!selfAvatarOnly && Menu::getInstance()->isOptionChecked(MenuOption::Atmosphere)) {
-        PerformanceTimer perfTimer("atmosphere");
-        PerformanceWarning warn(Menu::getInstance()->isOptionChecked(MenuOption::PipelineWarnings),
-            "Application::displaySide() ... atmosphere...");
-        _environment.renderAtmospheres(theCamera);
-    }
     glEnable(GL_LIGHTING);
     glEnable(GL_DEPTH_TEST);
     

interface/src/devices/KeyboardMouseDevice.cpp

@@ -123,7 +123,11 @@ void KeyboardMouseDevice::touchUpdateEvent(const QTouchEvent* event) {
 }
 
 UserInputMapper::Input KeyboardMouseDevice::makeInput(Qt::Key code) {
-    return UserInputMapper::Input(_deviceID, code & KEYBOARD_MASK, UserInputMapper::ChannelType::BUTTON);
+    auto shortCode = (UserInputMapper::uint16)(code & KEYBOARD_MASK);
+    if (shortCode != code) {
+       shortCode |= 0x0800; // add this bit instead of the way Qt::Key add a bit on the 3rd byte for some keys
+    }
+    return UserInputMapper::Input(_deviceID, shortCode, UserInputMapper::ChannelType::BUTTON);
 }
 
 UserInputMapper::Input KeyboardMouseDevice::makeInput(Qt::MouseButton code) {

libraries/fbx/src/FBXReader.cpp

@@ -1688,7 +1688,7 @@ FBXGeometry extractFBXGeometry(const FBXNode& node, const QVariantHash& mapping,
                     }
                 } else if (object.name == "Material") {
                     Material material = { glm::vec3(1.0f, 1.0f, 1.0f), glm::vec3(1.0f, 1.0f, 1.0f), glm::vec3(), 96.0f, 1.0f,
-                                          QString(""), QSharedPointer<model::Material>(NULL)};
+                                          QString(""), model::MaterialPointer(NULL)};
                     foreach (const FBXNode& subobject, object.children) {
                         bool properties = false;
                         QByteArray propertyName;

libraries/gpu/src/gpu/Batch.cpp

@@ -91,6 +91,18 @@ void Batch::drawIndexedInstanced(uint32 nbInstances, Primitive primitiveType, ui
     _params.push_back(nbInstances);
 }
 
+void Batch::clearFramebuffer(Framebuffer::Masks targets, const Vec4& color, float depth, int stencil) {
+    ADD_COMMAND(clearFramebuffer);
+
+    _params.push_back(stencil);
+    _params.push_back(depth);
+    _params.push_back(color.w);
+    _params.push_back(color.z);
+    _params.push_back(color.y);
+    _params.push_back(color.x);
+    _params.push_back(targets);
+}
+
 void Batch::setInputFormat(const Stream::FormatPointer& format) {
     ADD_COMMAND(setInputFormat);
 

libraries/gpu/src/gpu/Batch.h

@@ -81,6 +81,9 @@ public:
     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);
 
+    // Clear framebuffer layers
+    void clearFramebuffer(Framebuffer::Masks targets, const Vec4& color, float depth, int stencil);
+    
     // Input Stage
     // InputFormat
     // InputBuffers
@@ -160,6 +163,8 @@ public:
         COMMAND_drawInstanced,
         COMMAND_drawIndexedInstanced,
 
+        COMMAND_clearFramebuffer,
+
         COMMAND_setInputFormat,
         COMMAND_setInputBuffer,
         COMMAND_setIndexBuffer,

libraries/gpu/src/gpu/Context.h

@@ -43,6 +43,7 @@ public:
         Mat4 _viewInverse;
         Mat4 _projectionViewUntranslated;
         Mat4 _projection;
+        Mat4 _projectionInverse;
         Vec4 _viewport;
     };
 

libraries/gpu/src/gpu/Format.h

@@ -27,6 +27,8 @@ typedef short int16;
 typedef unsigned char uint8;
 typedef char int8;
 
+typedef unsigned char Byte;
+    
 typedef uint32 Offset;
 
 typedef glm::mat4 Mat4;

libraries/gpu/src/gpu/Framebuffer.h

@@ -81,6 +81,7 @@ public:
         BUFFER_STENCIL = 0x80000000,
         BUFFER_DEPTHSTENCIL = 0xC0000000,
     };
+    typedef uint32 Masks;
 
     ~Framebuffer();
 
@@ -111,7 +112,7 @@ public:
 
 
     // Properties
-    uint32 getBufferMask() const { return _bufferMask; }
+    Masks getBufferMask() const { return _bufferMask; }
     bool isEmpty() const { return (_bufferMask == 0); }
     bool hasColor() const { return (getBufferMask() & BUFFER_COLORS); }
     bool hasDepthStencil() const { return (getBufferMask() & BUFFER_DEPTHSTENCIL); }
@@ -137,7 +138,7 @@ protected:
     TextureViews _renderBuffers;
     TextureView _depthStencilBuffer;
 
-    uint32 _bufferMask = 0;
+    Masks _bufferMask = 0;
 
     uint32 _frameCount = 0;
 

libraries/gpu/src/gpu/GLBackend.cpp

@@ -17,6 +17,7 @@ GLBackend::CommandCall GLBackend::_commandCalls[Batch::NUM_COMMANDS] =
     (&::gpu::GLBackend::do_drawIndexed),
     (&::gpu::GLBackend::do_drawInstanced),
     (&::gpu::GLBackend::do_drawIndexedInstanced),
+    (&::gpu::GLBackend::do_clearFramebuffer),
     
     (&::gpu::GLBackend::do_setInputFormat),
     (&::gpu::GLBackend::do_setInputBuffer),
@@ -170,6 +171,39 @@ void GLBackend::do_drawIndexedInstanced(Batch& batch, uint32 paramOffset) {
     (void) CHECK_GL_ERROR();
 }
 
+void GLBackend::do_clearFramebuffer(Batch& batch, uint32 paramOffset) {
+
+    uint32 masks = batch._params[paramOffset + 6]._uint;
+    Vec4 color;
+    color.x = batch._params[paramOffset + 5]._float;
+    color.y = batch._params[paramOffset + 4]._float;
+    color.z = batch._params[paramOffset + 3]._float;
+    color.w = batch._params[paramOffset + 2]._float;
+    float depth = batch._params[paramOffset + 1]._float;
+    int stencil = batch._params[paramOffset + 0]._float;
+
+    GLuint glmask = 0;
+    if (masks & Framebuffer::BUFFER_DEPTH) {
+        glClearStencil(stencil);
+        glmask |= GL_STENCIL_BUFFER_BIT;
+    }
+
+    if (masks & Framebuffer::BUFFER_DEPTH) {
+        glClearDepth(depth);
+        glmask |= GL_DEPTH_BUFFER_BIT;
+    } 
+
+    if (masks & Framebuffer::BUFFER_COLORS) {
+        glClearColor(color.x, color.y, color.z, color.w);
+        glmask |= GL_COLOR_BUFFER_BIT;
+    }
+
+    glClear(glmask);
+
+    (void) CHECK_GL_ERROR();
+}
+
+
 // 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

libraries/gpu/src/gpu/GLBackend.h

@@ -191,6 +191,8 @@ protected:
     void do_drawInstanced(Batch& batch, uint32 paramOffset);
     void do_drawIndexedInstanced(Batch& batch, uint32 paramOffset);
 
+    void do_clearFramebuffer(Batch& batch, uint32 paramOffset);
+
     // Input Stage
     void do_setInputFormat(Batch& batch, uint32 paramOffset);
     void do_setInputBuffer(Batch& batch, uint32 paramOffset);

libraries/gpu/src/gpu/GLBackendPipeline.cpp

@@ -171,10 +171,21 @@ void GLBackend::do_setUniformTexture(Batch& batch, uint32 paramOffset) {
     GLuint slot = batch._params[paramOffset + 1]._uint;
     TexturePointer uniformTexture = batch._textures.get(batch._params[paramOffset + 0]._uint);
 
-    GLuint to = getTextureID(uniformTexture);
+    if (!uniformTexture) {
-    glActiveTexture(GL_TEXTURE0 + slot);
+        return;
-    glBindTexture(GL_TEXTURE_2D, to);
+    }
 
-    (void) CHECK_GL_ERROR();
+    GLTexture* object = GLBackend::syncGPUObject(*uniformTexture);
+    if (object) {
+        GLuint to = object->_texture;
+        GLuint target = object->_target;
+        glActiveTexture(GL_TEXTURE0 + slot);
+        glBindTexture(target, to);
+
+        (void) CHECK_GL_ERROR();
+
+    } else {
+        return;
+    }
 }
 

libraries/gpu/src/gpu/GLBackendTexture.cpp

@@ -297,7 +297,7 @@ GLBackend::GLTexture* GLBackend::syncGPUObject(const Texture& texture) {
             if (needUpdate) {
                 if (texture.isStoredMipAvailable(0)) {
                     Texture::PixelsPointer mip = texture.accessStoredMip(0);
-                    const GLvoid* bytes = mip->_sysmem.read<Resource::Byte>();
+                    const GLvoid* bytes = mip->_sysmem.read<Byte>();
                     Element srcFormat = mip->_format;
                 
                     GLTexelFormat texelFormat = GLTexelFormat::evalGLTexelFormat(texture.getTexelFormat(), srcFormat);
@@ -328,7 +328,7 @@ GLBackend::GLTexture* GLBackend::syncGPUObject(const Texture& texture) {
                 if (texture.isStoredMipAvailable(0)) {
                     Texture::PixelsPointer mip = texture.accessStoredMip(0);
                 
-                    bytes = mip->_sysmem.read<Resource::Byte>();
+                    bytes = mip->_sysmem.read<Byte>();
                     srcFormat = mip->_format;
 
                     object->_contentStamp = texture.getDataStamp();
@@ -363,6 +363,93 @@ GLBackend::GLTexture* GLBackend::syncGPUObject(const Texture& texture) {
         }
         break;
     }
+    case Texture::TEX_CUBE: {
+        if (texture.getNumSlices() == 1) {
+            GLint boundTex = -1;
+            glGetIntegerv(GL_TEXTURE_BINDING_CUBE_MAP, &boundTex);
+            glBindTexture(GL_TEXTURE_CUBE_MAP, object->_texture);
+            const int NUM_FACES = 6;
+            const GLenum FACE_LAYOUT[] = {
+                GL_TEXTURE_CUBE_MAP_POSITIVE_X, GL_TEXTURE_CUBE_MAP_NEGATIVE_X,
+                GL_TEXTURE_CUBE_MAP_POSITIVE_Y, GL_TEXTURE_CUBE_MAP_NEGATIVE_Y,
+                GL_TEXTURE_CUBE_MAP_POSITIVE_Z, GL_TEXTURE_CUBE_MAP_NEGATIVE_Z };
+
+            if (needUpdate) {
+                if (texture.isStoredMipAvailable(0)) {
+                    Texture::PixelsPointer mip = texture.accessStoredMip(0);
+                    Element srcFormat = mip->_format;
+                    GLTexelFormat texelFormat = GLTexelFormat::evalGLTexelFormat(texture.getTexelFormat(), srcFormat);
+                    
+                    uint16 width = texture.getWidth();
+                    int faceSize = mip->_sysmem.getSize() / NUM_FACES;
+
+                    glBindTexture(GL_TEXTURE_CUBE_MAP, object->_texture);
+                    for (int f = 0; f < NUM_FACES; f++) {
+                        glTexSubImage2D(FACE_LAYOUT[f], 0, texelFormat.internalFormat, width, width, 0,
+                            texelFormat.format, texelFormat.type, (GLvoid*) (mip->_sysmem.read<Byte>() + f * faceSize));
+                    }
+
+                    if (texture.isAutogenerateMips()) {
+                        glGenerateMipmap(GL_TEXTURE_CUBE_MAP);
+                        glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);
+                    }
+
+                    object->_target = GL_TEXTURE_CUBE_MAP;
+
+                    syncSampler(texture.getSampler(), texture.getType(), object);
+
+                    // At this point the mip piels have been loaded, we can notify
+                    texture.notifyGPULoaded(0);
+
+                    object->_contentStamp = texture.getDataStamp();
+                }
+            } else {
+                const gpu::Byte* bytes = 0;
+                Element srcFormat = texture.getTexelFormat();
+                uint16 width = texture.getWidth();
+                int faceSize = 0;
+
+                if (texture.isStoredMipAvailable(0)) {
+                    Texture::PixelsPointer mip = texture.accessStoredMip(0);
+                
+                    bytes = mip->_sysmem.read<Byte>();
+                    srcFormat = mip->_format;
+                    faceSize = mip->_sysmem.getSize() / NUM_FACES;
+
+                    object->_contentStamp = texture.getDataStamp();
+                }
+
+                GLTexelFormat texelFormat = GLTexelFormat::evalGLTexelFormat(texture.getTexelFormat(), srcFormat);
+
+                glBindTexture(GL_TEXTURE_CUBE_MAP, object->_texture);
+                for (int f = 0; f < NUM_FACES; f++) {
+                    glTexImage2D(FACE_LAYOUT[f], 0, texelFormat.internalFormat, width, width, 0,
+                        texelFormat.format, texelFormat.type, (GLvoid*) (bytes + f * faceSize));
+                }
+
+                if (bytes && texture.isAutogenerateMips()) {
+                    glGenerateMipmap(GL_TEXTURE_CUBE_MAP);
+                    glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);
+                } else {
+                    glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
+                    glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
+                }
+                
+                object->_target = GL_TEXTURE_CUBE_MAP;
+
+                syncSampler(texture.getSampler(), texture.getType(), object);
+
+                // At this point the mip piels have been loaded, we can notify
+                texture.notifyGPULoaded(0);
+
+                object->_storageStamp = texture.getStamp();
+                object->_size = texture.getSize();
+            }
+
+            glBindTexture(GL_TEXTURE_CUBE_MAP, boundTex);
+        }
+        break;
+    }
     default:
         qCDebug(gpulogging) << "GLBackend::syncGPUObject(const Texture&) case for Texture Type " << texture.getType() << " not supported";	
     }
@@ -449,6 +536,5 @@ void GLBackend::syncSampler(const Sampler& sampler, Texture::Type type, GLTextur
     glTexParameterf(object->_target, GL_TEXTURE_MIN_LOD, (float) sampler.getMinMip());
     glTexParameterf(object->_target, GL_TEXTURE_MAX_LOD, (sampler.getMaxMip() == Sampler::MAX_MIP_LEVEL ? 1000.f : sampler.getMaxMip()));
     glTexParameterf(object->_target, GL_TEXTURE_MAX_ANISOTROPY_EXT, sampler.getMaxAnisotropy());
-    (void) CHECK_GL_ERROR();
 
 }

libraries/gpu/src/gpu/GLBackendTransform.cpp

@@ -59,6 +59,7 @@ void GLBackend::updateTransform() {
     // Check all the dirty flags and update the state accordingly
     if (_transform._invalidProj) {
         _transform._transformCamera._projection = _transform._projection;
+        _transform._transformCamera._projectionInverse = glm::inverse(_transform._projection);
     }
 
     if (_transform._invalidView) {

libraries/gpu/src/gpu/Resource.h

@@ -17,7 +17,7 @@
 
 #include <vector>
 
-#include <QSharedPointer>
+#include <memory>
 #ifdef _DEBUG
 #include <QDebug>
 #endif
@@ -26,7 +26,6 @@ namespace gpu {
 
 class Resource {
 public:
-    typedef unsigned char Byte;
     typedef unsigned int Size;
 
     static const Size NOT_ALLOCATED = -1;
@@ -156,7 +155,7 @@ protected:
     friend class Backend;
 };
 
-typedef QSharedPointer<Buffer> BufferPointer;
+typedef std::shared_ptr<Buffer> BufferPointer;
 typedef std::vector< BufferPointer > Buffers;
 
 
@@ -317,7 +316,7 @@ public:
 
     template <typename T> const T& get() const {
  #if _DEBUG
-        if (_buffer.isNull()) {
+        if (!_buffer) {
             qDebug() << "Accessing null gpu::buffer!";
         }
         if (sizeof(T) > (_buffer->getSize() - _offset)) {
@@ -333,7 +332,7 @@ public:
 
     template <typename T> T& edit() {
  #if _DEBUG
-        if (_buffer.isNull()) {
+        if (!_buffer) {
             qDebug() << "Accessing null gpu::buffer!";
         }
         if (sizeof(T) > (_buffer->getSize() - _offset)) {
@@ -350,7 +349,7 @@ public:
     template <typename T> const T& get(const Index index) const {
         Resource::Size elementOffset = index * sizeof(T) + _offset;
  #if _DEBUG
-        if (_buffer.isNull()) {
+        if (!_buffer) {
             qDebug() << "Accessing null gpu::buffer!";
         }
         if (sizeof(T) > (_buffer->getSize() - elementOffset)) {
@@ -366,7 +365,7 @@ public:
     template <typename T> T& edit(const Index index) const {
         Resource::Size elementOffset = index * sizeof(T) + _offset;
  #if _DEBUG
-        if (_buffer.isNull()) {
+        if (!_buffer) {
             qDebug() << "Accessing null gpu::buffer!";
         }
         if (sizeof(T) > (_buffer->getSize() - elementOffset)) {

libraries/gpu/src/gpu/Shader.h

@@ -12,6 +12,7 @@
 #define hifi_gpu_Shader_h
 
 #include "Resource.h"
+#include <string>
 #include <memory>
 #include <set>
  
@@ -20,7 +21,7 @@ namespace gpu {
 class Shader {
 public:
 
-    typedef QSharedPointer< Shader > Pointer;
+    typedef std::shared_ptr< Shader > Pointer;
     typedef std::vector< Pointer > Shaders;
 
     class Source {

libraries/gpu/src/gpu/Stream.cpp

@@ -11,6 +11,8 @@
 
 #include "Stream.h"
 
+#include <algorithm> //min max and more
+
 using namespace gpu;
 
 void Stream::Format::evaluateCache() {

libraries/gpu/src/gpu/Stream.h

@@ -117,7 +117,7 @@ public:
         void evaluateCache();
     };
 
-    typedef QSharedPointer<Format> FormatPointer;
+    typedef std::shared_ptr<Format> FormatPointer;
 };
 
 typedef std::vector< Offset > Offsets;
@@ -143,7 +143,7 @@ protected:
     Offsets _offsets;
     Strides _strides;
 };
-typedef QSharedPointer<BufferStream> BufferStreamPointer;
+typedef std::shared_ptr<BufferStream> BufferStreamPointer;
 
 };
 

libraries/gpu/src/gpu/Texture.cpp

@@ -15,6 +15,8 @@
 
 using namespace gpu;
 
+uint8 Texture::NUM_FACES_PER_TYPE[NUM_TYPES] = {1, 1, 1, 6};
+
 Texture::Pixels::Pixels(const Element& format, Size size, const Byte* bytes) :
     _sysmem(size, bytes),
     _format(format),
@@ -131,19 +133,7 @@ Texture* Texture::createFromStorage(Storage* storage) {
 }
 
 Texture::Texture():
-    Resource(),
+    Resource()
-    _storage(),
-    _stamp(0),
-    _size(0),
-    _width(1),
-    _height(1),
-    _depth(1),
-    _numSamples(1),
-    _numSlices(1),
-    _maxMip(0),
-    _type(TEX_1D),
-    _autoGenerateMips(false),
-    _defined(false)
 {
 }
 
@@ -188,8 +178,7 @@ Texture::Size Texture::resize(Type type, const Element& texelFormat, uint16 widt
         }
         
         // Evaluate the new size with the new format
-        const int DIM_SIZE[] = {1, 1, 1, 6};
+        uint32_t size = NUM_FACES_PER_TYPE[_type] *_width * _height * _depth * _numSamples * texelFormat.getSize();
-        uint32_t size = DIM_SIZE[_type] *_width * _height * _depth * _numSamples * texelFormat.getSize();
 
         // If size change then we need to reset 
         if (changed || (size != getSize())) {

libraries/gpu/src/gpu/Texture.h

@@ -12,7 +12,8 @@
 #define hifi_gpu_Texture_h
 
 #include "Resource.h"
-#include <memory>
+
+#include <algorithm> //min max and more
 
 namespace gpu {
 
@@ -109,7 +110,7 @@ public:
         Element _format;
         bool _isGPULoaded;
     };
-    typedef QSharedPointer< Pixels > PixelsPointer;
+    typedef std::shared_ptr< Pixels > PixelsPointer;
 
     class Storage {
     public:
@@ -138,6 +139,8 @@ public:
         TEX_2D,
         TEX_3D,
         TEX_CUBE,
+
+        NUM_TYPES,
     };
 
     static Texture* create1D(const Element& texelFormat, uint16 width, const Sampler& sampler = Sampler());
@@ -180,11 +183,19 @@ public:
     uint16 getDepth() const { return _depth; }
 
     uint32 getRowPitch() const { return getWidth() * getTexelFormat().getSize(); }
-    uint32 getNumTexels() const { return _width * _height * _depth; }
+ 
+    // The number of faces is mostly used for cube map, and maybe for stereo ? otherwise it's 1
+    // For cube maps, this means the pixels of the different faces are supposed to be packed back to back in a mip
+    // as if the height was NUM_FACES time bigger.
+    static uint8 NUM_FACES_PER_TYPE[NUM_TYPES];
+    uint8 getNumFaces() const { return NUM_FACES_PER_TYPE[getType()]; }
+
+    uint32 getNumTexels() const { return _width * _height * _depth * getNumFaces(); }
 
     uint16 getNumSlices() const { return _numSlices; }
     uint16 getNumSamples() const { return _numSamples; }
 
+
     // NumSamples can only have certain values based on the hw
     static uint16 evalNumSamplesUsed(uint16 numSamplesTried);
 
@@ -203,7 +214,7 @@ public:
     uint16 evalMipWidth(uint16 level) const { return std::max(_width >> level, 1); }
     uint16 evalMipHeight(uint16 level) const { return std::max(_height >> level, 1); }
     uint16 evalMipDepth(uint16 level) const { return std::max(_depth >> level, 1); }
-    uint32 evalMipNumTexels(uint16 level) const { return evalMipWidth(level) * evalMipHeight(level) * evalMipDepth(level); }
+    uint32 evalMipNumTexels(uint16 level) const { return evalMipWidth(level) * evalMipHeight(level) * evalMipDepth(level) * getNumFaces(); }
     uint32 evalMipSize(uint16 level) const { return evalMipNumTexels(level) * getTexelFormat().getSize(); }
     uint32 evalStoredMipSize(uint16 level, const Element& format) const { return evalMipNumTexels(level) * format.getSize(); }
 
@@ -269,27 +280,26 @@ public:
 protected:
     std::unique_ptr< Storage > _storage;
  
-    Stamp _stamp;
+    Stamp _stamp = 0;
 
     Sampler _sampler;
     Stamp _samplerStamp;
 
-
+    uint32 _size = 0;
-    uint32 _size;
     Element _texelFormat;
 
-    uint16 _width;
+    uint16 _width = 1;
-    uint16 _height;
+    uint16 _height = 1;
-    uint16 _depth;
+    uint16 _depth = 1;
 
-    uint16 _numSamples;
+    uint16 _numSamples = 1;
-    uint16 _numSlices;
+    uint16 _numSlices = 1;
 
-    uint16 _maxMip;
+    uint16 _maxMip = 0;
  
-    Type _type;
+    Type _type = TEX_1D;
-    bool _autoGenerateMips;
+    bool _autoGenerateMips = false;
-    bool _defined;
+    bool _defined = false;
    
     static Texture* create(Type type, const Element& texelFormat, uint16 width, uint16 height, uint16 depth, uint16 numSamples, uint16 numSlices, const Sampler& sampler);
     Texture();
@@ -303,7 +313,7 @@ protected:
     friend class Backend;
 };
 
-typedef QSharedPointer<Texture> TexturePointer;
+typedef std::shared_ptr<Texture> TexturePointer;
 typedef std::vector< TexturePointer > Textures;
 
 
@@ -344,7 +354,7 @@ public:
     TextureView(const TextureView& view) = default;
     TextureView& operator=(const TextureView& view) = default;
 
-    explicit operator bool() const { return (_texture); }
+    explicit operator bool() const { return bool(_texture); }
     bool operator !() const { return (!_texture); }
 };
 typedef std::vector<TextureView> TextureViews;

libraries/gpu/src/gpu/Transform.slh

@@ -21,6 +21,7 @@ struct TransformCamera {
     mat4 _viewInverse;
     mat4 _projectionViewUntranslated;
     mat4 _projection;
+    mat4 _projectionInverse;
     vec4 _viewport;
 };
 
@@ -120,4 +121,24 @@ TransformCamera getTransformCamera() {
 <@endif@>
 <@endfunc@>
 
+<@func transformEyeToWorldDir(cameraTransform, eyeDir, worldDir)@>
+<@if GPU_TRANSFORM_PROFILE == GPU_CORE@>
+    { // transformEyeToWorldDir
+        <$worldDir$> = vec3(<$cameraTransform$>._viewInverse * vec4(<$eyeDir$>.xyz, 0.0));
+    }
+<@else@>
+    <$worldDir$> = vec3(gl_ModelViewMatrixInverse * vec4(<$eyeDir$>.xyz, 0.0));
+<@endif@>
+<@endfunc@>
+
+<@func transformClipToEyeDir(cameraTransform, clipPos, eyeDir)@>
+<@if GPU_TRANSFORM_PROFILE == GPU_CORE@>
+    { // transformClipToEyeDir
+        <$eyeDir$> = vec3(<$cameraTransform$>._projectionInverse * vec4(<$clipPos$>.xyz, 1.0));
+    }
+<@else@>
+    <$eyeDir$> = vec3(gl_ProjectionMatrixInverse * vec4(<$clipPos$>.xyz, 1.0));
+<@endif@>
+<@endfunc@>
+
 <@endif@>

libraries/model/src/model/Geometry.h

@@ -47,7 +47,7 @@ public:
     void setVertexBuffer(const BufferView& buffer);
     const BufferView& getVertexBuffer() const { return _vertexBuffer; }
     uint getNumVertices() const { return _vertexBuffer.getNumElements(); }
-    bool hasVertexData() const { return !_vertexBuffer._buffer.isNull(); }
+    bool hasVertexData() const { return !_vertexBuffer._buffer; }
 
     // Attribute Buffers
     int getNumAttributes() const { return _attributeBuffers.size(); }
@@ -126,7 +126,7 @@ protected:
     void evalVertexFormat();
 
 };
-typedef QSharedPointer< Mesh > MeshPointer;
+typedef std::shared_ptr< Mesh > MeshPointer;
 
 
 class Geometry {

libraries/model/src/model/Light.cpp

@@ -18,7 +18,7 @@ Light::Light() :
     _transform() {
     // only if created from nothing shall we create the Buffer to store the properties
     Schema schema;
-    _schemaBuffer = gpu::BufferView(new gpu::Buffer(sizeof(Schema), (const gpu::Buffer::Byte*) &schema));
+    _schemaBuffer = gpu::BufferView(new gpu::Buffer(sizeof(Schema), (const gpu::Byte*) &schema));
 }
 
 Light::Light(const Light& light) :

libraries/model/src/model/Light.h

@@ -282,7 +282,7 @@ protected:
     const Schema& getSchema() const { return _schemaBuffer.get<Schema>(); }
     Schema& editSchema() { return _schemaBuffer.edit<Schema>(); }
 };
-typedef QSharedPointer< Light > LightPointer;
+typedef std::shared_ptr< Light > LightPointer;
 
 };
 

libraries/model/src/model/Material.cpp

@@ -11,6 +11,7 @@
 #include "Material.h"
 
 using namespace model;
+using namespace gpu;
 
 Material::Material() :
     _flags(0),
@@ -19,7 +20,7 @@ Material::Material() :
        
         // only if created from nothing shall we create the Buffer to store the properties
         Schema schema;
-        _schemaBuffer = gpu::BufferView(new gpu::Buffer(sizeof(Schema), (const gpu::Buffer::Byte*) &schema));
+        _schemaBuffer = gpu::BufferView(new gpu::Buffer(sizeof(Schema), (const gpu::Byte*) &schema));
         
 
 }
@@ -86,7 +87,20 @@ void Material::setOpacity(float opacity) {
     _schemaBuffer.edit<Schema>()._opacity = opacity;
 }
 
-void Material::setTextureView(MapChannel channel, const TextureView& view) {
+void Material::setTextureView(MapChannel channel, const gpu::TextureView& view) {
     _flags.set(DIFFUSE_MAP_BIT + channel);
     _textureMap[channel] = view;
 }
+
+// TextureStorage
+TextureStorage::TextureStorage(const QUrl& url) : gpu::Texture::Storage(), _url(url) {
+    init();
+}
+
+TextureStorage::~TextureStorage() {
+}
+
+void TextureStorage::init() {
+    _gpuTexture = TexturePointer(Texture::createFromStorage(this));
+}
+

libraries/model/src/model/Material.h

@@ -19,12 +19,35 @@
 #include "gpu/Resource.h"
 #include "gpu/Texture.h"
 
+#include <qurl.h>
+
 namespace model {
-typedef gpu::BufferView UniformBufferView;
+
-typedef gpu::TextureView TextureView;
+typedef glm::vec3 Color;
+
+// TextureStorage is a specialized version of the gpu::Texture::Storage
+// It adds the URL and the notion that it owns the gpu::Texture
+class TextureStorage : public gpu::Texture::Storage {
+public:
+    TextureStorage(const QUrl& url);
+    ~TextureStorage();
+
+    const QUrl& getUrl() const { return _url; }
+    const gpu::TexturePointer& getGPUTexture() const { return _gpuTexture; }
+
+protected:
+    gpu::TexturePointer _gpuTexture;
+    QUrl _url;
+    void init();
+};
+typedef std::shared_ptr< TextureStorage > TextureStoragePointer;
+
+
 
 class Material {
 public:
+    typedef gpu::BufferView UniformBufferView;
+    typedef gpu::TextureView TextureView;
 
     typedef glm::vec3 Color;
 
@@ -102,7 +125,7 @@ protected:
     TextureMap _textureMap;
 
 };
-typedef QSharedPointer< Material > MaterialPointer;
+typedef std::shared_ptr< Material > MaterialPointer;
 
 };
 

libraries/model/src/model/Skybox.cpp

@@ -0,0 +1,94 @@
+//
+//  Skybox.cpp
+//  libraries/model/src/model
+//
+//  Created by Sam Gateau on 5/4/2015.
+//  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 "Skybox.h"
+
+#include "gpu/Batch.h"
+#include "gpu/Context.h"
+
+#include "ViewFrustum.h"
+#include "Skybox_vert.h"
+#include "Skybox_frag.h"
+
+using namespace model;
+
+Skybox::Skybox() {
+
+    _cubemap.reset( gpu::Texture::createCube(gpu::Element::COLOR_RGBA_32, 1));
+    unsigned char texels[] = {
+        255, 0, 0, 255,
+        0, 255, 255, 255,
+        0, 0, 255, 255,
+        255, 255, 0, 255,
+        0, 255, 0, 255,
+        255, 0, 255, 255,
+    };
+    _cubemap->assignStoredMip(0, gpu::Element::COLOR_RGBA_32, sizeof(texels), texels); 
+}
+
+void Skybox::setColor(const Color& color) {
+    _color = color;
+}
+
+void Skybox::setCubemap(const gpu::TexturePointer& cubemap) {
+    _cubemap = cubemap;
+}
+
+void Skybox::render(gpu::Batch& batch, const ViewFrustum& viewFrustum, const Skybox& skybox) {
+
+    if (skybox.getCubemap()) {
+
+        static gpu::PipelinePointer thePipeline;
+        static gpu::BufferPointer theBuffer;
+        static gpu::Stream::FormatPointer theFormat;
+        if (!thePipeline) {
+            auto skyVS = gpu::ShaderPointer(gpu::Shader::createVertex(std::string(Skybox_vert)));
+            auto skyFS = gpu::ShaderPointer(gpu::Shader::createPixel(std::string(Skybox_frag)));
+            auto skyShader = gpu::ShaderPointer(gpu::Shader::createProgram(skyVS, skyFS));
+
+            gpu::Shader::BindingSet bindings;
+            bindings.insert(gpu::Shader::Binding(std::string("cubeMap"), 0));
+
+            if (!gpu::Shader::makeProgram(*skyShader, bindings)) {
+
+            }
+
+            auto skyState = gpu::StatePointer(new gpu::State());
+
+            thePipeline = gpu::PipelinePointer(gpu::Pipeline::create(skyShader, skyState));
+        
+            const float CLIP = 1.0;
+            const glm::vec2 vertices[4] = { {-CLIP, -CLIP}, {CLIP, -CLIP}, {-CLIP, CLIP}, {CLIP, CLIP}};
+            theBuffer.reset(new gpu::Buffer(sizeof(vertices), (const gpu::Byte*) vertices));
+        
+            theFormat.reset(new gpu::Stream::Format());
+            theFormat->setAttribute(gpu::Stream::POSITION, gpu::Stream::POSITION, gpu::Element(gpu::VEC2, gpu::FLOAT, gpu::XYZ));
+        }
+
+        glm::mat4 projMat;
+        viewFrustum.evalProjectionMatrix(projMat);
+
+        Transform viewTransform;
+        viewFrustum.evalViewTransform(viewTransform);
+
+        batch.setProjectionTransform(projMat);
+        batch.setViewTransform(viewTransform);
+        batch.setModelTransform(Transform()); // only for Mac
+        batch.setPipeline(thePipeline);
+        batch.setInputBuffer(gpu::Stream::POSITION, theBuffer, 0, 8);
+        batch.setInputFormat(theFormat);
+        batch.setUniformTexture(0, skybox.getCubemap());
+        batch.draw(gpu::TRIANGLE_STRIP, 4);
+    } else {
+        // skybox has no cubemap, just clear the color buffer
+        auto color = skybox.getColor();
+        batch.clearFramebuffer(gpu::Framebuffer::BUFFER_COLOR0, glm::vec4(skybox.getColor(),1.0f), 0.f, 0); 
+    }
+}

libraries/model/src/model/Skybox.h

@@ -0,0 +1,46 @@
+//
+//  Skybox.h
+//  libraries/model/src/model
+//
+//  Created by Sam Gateau on 5/4/2015.
+//  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
+//
+#ifndef hifi_model_Skybox_h
+#define hifi_model_Skybox_h
+
+#include "gpu/Texture.h"
+
+class ViewFrustum;
+//class Transform;
+namespace gpu { class Batch; }
+
+namespace model {
+
+typedef glm::vec3 Color;
+
+class Skybox {
+public:
+    Skybox();
+    Skybox& operator= (const Skybox& skybox);
+    virtual ~Skybox() {};
+ 
+    void setColor(const Color& color);
+    const Color& getColor() const { return _color; }
+
+    void setCubemap(const gpu::TexturePointer& cubemap);
+    const gpu::TexturePointer& getCubemap() const { return _cubemap; }
+
+    static void render(gpu::Batch& batch, const ViewFrustum& frustum, const Skybox& skybox);
+
+protected:
+    gpu::TexturePointer _cubemap;
+    Color _color{1.0f, 1.0f, 1.0f};
+};
+typedef std::shared_ptr< Skybox > SkyboxPointer;
+
+};
+
+#endif //hifi_model_Skybox_h

libraries/model/src/model/Skybox.slf

@@ -0,0 +1,24 @@
+<@include gpu/Config.slh@>
+<$VERSION_HEADER$>
+//  Generated on <$_SCRIBE_DATE$>
+//  skybox.frag
+//
+//  Created by Sam Gateau on 5/5/2015.
+//  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
+//
+
+uniform samplerCube cubeMap;
+
+varying vec3 normal;
+varying vec2 texcoord;
+varying vec3 color;
+
+
+void main(void) {
+    vec4 texel = textureCube(cubeMap, normalize(normal));
+    gl_FragData[0] = texel;
+  //  gl_FragData[0] = vec4(normal, 1.0);
+}

libraries/model/src/model/Skybox.slv

@@ -0,0 +1,40 @@
+<@include gpu/Config.slh@>
+<$VERSION_HEADER$>
+//  Generated on <$_SCRIBE_DATE$>
+//  skybox.vert
+//  vertex shader
+//
+//  Created by Sam Gateau on 5/5/2015.
+//  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 gpu/Transform.slh@>
+
+<$declareStandardTransform()$>
+
+varying vec3 normal;
+varying vec2 texcoord;
+varying vec3 color;
+
+void main(void) {
+    texcoord = gl_Vertex.xy;
+
+    // pass along the diffuse color
+    color = vec3(texcoord, 0.0);
+
+    // standard transform
+    TransformCamera cam = getTransformCamera();
+    vec3 clipDir = vec3(texcoord.xy, 0.0);
+    vec3 eyeDir;
+    
+    <$transformClipToEyeDir(cam, clipDir, eyeDir)$>;
+    normal = normalize(eyeDir);
+    <$transformEyeToWorldDir(cam, eyeDir, normal)$>;
+    normal = normalize(normal);
+
+    // Position is supposed to cmoe in clip space
+    gl_Position = vec4(texcoord.xy, 0.0, 1.0);
+}

libraries/model/src/model/Stage.cpp

@@ -138,7 +138,7 @@ void EarthSunModel::setSunLongitude(float lon) {
 Atmosphere::Atmosphere() {
     // only if created from nothing shall we create the Buffer to store the properties
     Data data;
-    _dataBuffer = gpu::BufferView(new gpu::Buffer(sizeof(Data), (const gpu::Buffer::Byte*) &data));
+    _dataBuffer = gpu::BufferView(new gpu::Buffer(sizeof(Data), (const gpu::Byte*) &data));
 
     setScatteringWavelength(_scatteringWavelength);
     setRayleighScattering(_rayleighScattering);
@@ -184,14 +184,6 @@ void Atmosphere::setInnerOuterRadiuses(float inner, float outer) {
     data._scales.z = data._scales.x / data._scales.y;
 }
 
-Skybox::Skybox() {
-}
-
-void Skybox::setCubemap(const gpu::TexturePointer& cubemap) {
-    _cubemap = cubemap;
-}
-
-
 
 const int NUM_DAYS_PER_YEAR = 365;
 const float NUM_HOURS_PER_DAY = 24.0f;
@@ -223,6 +215,10 @@ SunSkyStage::SunSkyStage() :
 
     _skyPipeline = gpu::PipelinePointer(gpu::Pipeline::create(skyShader, skyState));
 
+
+    _skybox.reset(new Skybox());
+    _skybox->setColor(Color(1.0f, 0.0f, 0.0f));
+
 }
 
 SunSkyStage::~SunSkyStage() {
@@ -301,6 +297,11 @@ void SunSkyStage::updateGraphicsObject() const {
     }
 }
 
+void SunSkyStage::setBackgroundMode(BackgroundMode mode) {
+    _backgroundMode = mode;
+    invalidate();
+}
+
 void SunSkyStage::setSkybox(const SkyboxPointer& skybox) {
     _skybox = skybox;
     invalidate();

libraries/model/src/model/Stage.h

@@ -14,6 +14,7 @@
 #include "gpu/Pipeline.h"
 
 #include "Light.h"
+#include "Skybox.h"
 
 namespace model {
 
@@ -158,22 +159,7 @@ protected:
 
     void updateScattering();
 };
-typedef QSharedPointer< Atmosphere > AtmospherePointer;
+typedef std::shared_ptr< Atmosphere > AtmospherePointer;
-
-
-class Skybox {
-public:
-    Skybox();
-    Skybox& operator= (const Atmosphere& Skybox);
-    virtual ~Skybox() {};
-
-    void setCubemap(const gpu::TexturePointer& cubemap);
-    const gpu::TexturePointer& getCubemap() const { return _cubemap; }
-
-protected:
-    gpu::TexturePointer _cubemap;
-};
-typedef QSharedPointer< Skybox > SkyboxPointer;
 
 // Sun sky stage generates the rendering primitives to display a scene realistically
 // at the specified location and time around earth
@@ -222,11 +208,23 @@ public:
     LightPointer getSunLight() const { valid(); return _sunLight;  }
     AtmospherePointer getAtmosphere() const { valid(); return _atmosphere;  }
  
+    enum BackgroundMode {
+        NO_BACKGROUND = 0,
+        SKY_DOME,
+        SKY_BOX,
+
+        NUM_BACKGROUND_MODES,
+    };
+    void setBackgroundMode(BackgroundMode mode);
+    BackgroundMode getBackgroundMode() const { return _backgroundMode; }
+
     // Skybox
     void setSkybox(const SkyboxPointer& skybox);
     const SkyboxPointer& getSkybox() const { valid(); return _skybox; }
 
 protected:
+    BackgroundMode _backgroundMode = SKY_DOME;
+
     LightPointer _sunLight;
     AtmospherePointer _atmosphere;
     SkyboxPointer _skybox;
@@ -244,7 +242,7 @@ protected:
     void updateGraphicsObject() const;
 };
 
-typedef QSharedPointer< SunSkyStage > SunSkyStagePointer;
+typedef std::shared_ptr< SunSkyStage > SunSkyStagePointer;
 
 };
 

libraries/octree/src/ViewFrustum.cpp

@@ -862,3 +862,7 @@ void ViewFrustum::evalProjectionMatrix(glm::mat4& proj) const {
     }
 }
 
+void ViewFrustum::evalViewTransform(Transform& view) const {
+    view.setTranslation(getPosition());
+    view.setRotation(getOrientation());
+}

libraries/octree/src/ViewFrustum.h

@@ -20,6 +20,7 @@
 #include <GLMHelpers.h>
 #include <RegisteredMetaTypes.h>
 
+#include "Transform.h"
 #include "AABox.h"
 #include "AACube.h"
 #include "Plane.h"
@@ -121,6 +122,8 @@ public:
     float distanceToCamera(const glm::vec3& point) const;
     
     void evalProjectionMatrix(glm::mat4& proj) const;
+    void evalViewTransform(Transform& view) const;
+
 private:
     // Used for keyhole calculations
     ViewFrustum::location pointInKeyhole(const glm::vec3& point) const;

libraries/render-utils/src/GeometryCache.cpp

@@ -69,7 +69,7 @@ void GeometryCache::renderSphere(float radius, int slices, int stacks, const glm
         || (!registered && !_sphereVertices.contains(radiusKey))) {
 
         if (registered && _registeredSphereVertices.contains(id)) {
-            _registeredSphereVertices[id].clear();
+            _registeredSphereVertices[id].reset();
             #ifdef WANT_DEBUG
                 qCDebug(renderutils) << "renderSphere()... RELEASING REGISTERED VERTICES BUFFER";
             #endif
@@ -111,7 +111,7 @@ void GeometryCache::renderSphere(float radius, int slices, int stacks, const glm
         *(vertex++) = 0.0f;
         *(vertex++) = 1.0f * radius;
 
-        verticesBuffer->append(sizeof(GLfloat) * vertices * NUM_COORDS_PER_VERTEX, (gpu::Buffer::Byte*) vertexData);
+        verticesBuffer->append(sizeof(GLfloat) * vertices * NUM_COORDS_PER_VERTEX, (gpu::Byte*) vertexData);
         delete[] vertexData;
 
         #ifdef WANT_DEBUG
@@ -133,7 +133,7 @@ void GeometryCache::renderSphere(float radius, int slices, int stacks, const glm
         || (!registered && !_sphereIndices.contains(slicesStacksKey))) {
 
         if (registered && _registeredSphereIndices.contains(id)) {
-            _registeredSphereIndices[id].clear();
+            _registeredSphereIndices[id].reset();
             #ifdef WANT_DEBUG
                 qCDebug(renderutils) << "renderSphere()... RELEASING REGISTERED INDICES BUFFER";
             #endif
@@ -196,7 +196,7 @@ void GeometryCache::renderSphere(float radius, int slices, int stacks, const glm
             indexCount += 3;
 
         }
-        indicesBuffer->append(sizeof(GLushort) * indices, (gpu::Buffer::Byte*) indexData);
+        indicesBuffer->append(sizeof(GLushort) * indices, (gpu::Byte*) indexData);
         delete[] indexData;
         
         #ifdef WANT_DEBUG
@@ -219,7 +219,7 @@ void GeometryCache::renderSphere(float radius, int slices, int stacks, const glm
         || (!registered && !_sphereColors.contains(colorKey))) {
 
         if (registered && _registeredSphereColors.contains(id)) {
-            _registeredSphereColors[id].clear();
+            _registeredSphereColors[id].reset();
             #ifdef WANT_DEBUG
                 qCDebug(renderutils) << "renderSphere()... RELEASING REGISTERED COLORS BUFFER";
             #endif
@@ -245,7 +245,7 @@ void GeometryCache::renderSphere(float radius, int slices, int stacks, const glm
             *(colorDataAt++) = compactColor;
         }
 
-        colorBuffer->append(sizeof(int) * vertices, (gpu::Buffer::Byte*) colorData);
+        colorBuffer->append(sizeof(int) * vertices, (gpu::Byte*) colorData);
         delete[] colorData;
 
         #ifdef WANT_DEBUG
@@ -432,7 +432,7 @@ void GeometryCache::renderGrid(int xDivisions, int yDivisions, const glm::vec4&
             *(vertex++) = y;
         }
 
-        verticesBuffer->append(sizeof(GLfloat) * vertices * 2, (gpu::Buffer::Byte*) vertexData);
+        verticesBuffer->append(sizeof(GLfloat) * vertices * 2, (gpu::Byte*) vertexData);
         delete[] vertexData;
         
         _gridBuffers[key] = verticesBuffer;
@@ -454,7 +454,7 @@ void GeometryCache::renderGrid(int xDivisions, int yDivisions, const glm::vec4&
             *(colorDataAt++) = compactColor;
         }
 
-        colorBuffer->append(sizeof(int) * vertices, (gpu::Buffer::Byte*) colorData);
+        colorBuffer->append(sizeof(int) * vertices, (gpu::Byte*) colorData);
         delete[] colorData;
     }
     gpu::BufferPointer verticesBuffer = _gridBuffers[key];
@@ -537,7 +537,7 @@ void GeometryCache::renderGrid(int x, int y, int width, int height, int rows, in
             tx += dx;
         }
 
-        verticesBuffer->append(sizeof(GLfloat) * vertices * 2, (gpu::Buffer::Byte*) vertexData);
+        verticesBuffer->append(sizeof(GLfloat) * vertices * 2, (gpu::Byte*) vertexData);
         delete[] vertexData;
         
         if (registered) {
@@ -564,7 +564,7 @@ void GeometryCache::renderGrid(int x, int y, int width, int height, int rows, in
             *(colorDataAt++) = compactColor;
         }
 
-        colorBuffer->append(sizeof(int) * vertices, (gpu::Buffer::Byte*) colorData);
+        colorBuffer->append(sizeof(int) * vertices, (gpu::Byte*) colorData);
         delete[] colorData;
     }
     gpu::BufferPointer verticesBuffer = registered ? _registeredAlternateGridBuffers[id] : _alternateGridBuffers[key];
@@ -648,8 +648,8 @@ void GeometryCache::updateVertices(int id, const QVector<glm::vec2>& points, con
         *(colorDataAt++) = compactColor;
     }
 
-    details.verticesBuffer->append(sizeof(GLfloat) * FLOATS_PER_VERTEX * details.vertices, (gpu::Buffer::Byte*) vertexData);
+    details.verticesBuffer->append(sizeof(GLfloat) * FLOATS_PER_VERTEX * details.vertices, (gpu::Byte*) vertexData);
-    details.colorBuffer->append(sizeof(int) * details.vertices, (gpu::Buffer::Byte*) colorData);
+    details.colorBuffer->append(sizeof(int) * details.vertices, (gpu::Byte*) colorData);
     delete[] vertexData;
     delete[] colorData;
 
@@ -711,8 +711,8 @@ void GeometryCache::updateVertices(int id, const QVector<glm::vec3>& points, con
         *(colorDataAt++) = compactColor;
     }
 
-    details.verticesBuffer->append(sizeof(GLfloat) * FLOATS_PER_VERTEX * details.vertices, (gpu::Buffer::Byte*) vertexData);
+    details.verticesBuffer->append(sizeof(GLfloat) * FLOATS_PER_VERTEX * details.vertices, (gpu::Byte*) vertexData);
-    details.colorBuffer->append(sizeof(int) * details.vertices, (gpu::Buffer::Byte*) colorData);
+    details.colorBuffer->append(sizeof(int) * details.vertices, (gpu::Byte*) colorData);
     delete[] vertexData;
     delete[] colorData;
 
@@ -793,7 +793,7 @@ void GeometryCache::renderSolidCube(float size, const glm::vec4& color) {
             *(vertex++) = *cannonicalNormal++;
         }
 
-        verticesBuffer->append(sizeof(GLfloat) * vertexPoints * 2, (gpu::Buffer::Byte*) vertexData);
+        verticesBuffer->append(sizeof(GLfloat) * vertexPoints * 2, (gpu::Byte*) vertexData);
     }
 
     if (!_solidCubeIndexBuffer) {
@@ -808,7 +808,7 @@ void GeometryCache::renderSolidCube(float size, const glm::vec4& color) {
         gpu::BufferPointer indexBuffer(new gpu::Buffer());
         _solidCubeIndexBuffer = indexBuffer;
     
-        _solidCubeIndexBuffer->append(sizeof(cannonicalIndices), (gpu::Buffer::Byte*) cannonicalIndices);
+        _solidCubeIndexBuffer->append(sizeof(cannonicalIndices), (gpu::Byte*) cannonicalIndices);
     }
 
     if (!_solidCubeColors.contains(colorKey)) {
@@ -827,7 +827,7 @@ void GeometryCache::renderSolidCube(float size, const glm::vec4& color) {
                                                    compactColor, compactColor, compactColor, compactColor,
                                                    compactColor, compactColor, compactColor, compactColor };
 
-        colorBuffer->append(sizeof(colors), (gpu::Buffer::Byte*) colors);
+        colorBuffer->append(sizeof(colors), (gpu::Byte*) colors);
     }
     gpu::BufferPointer verticesBuffer = _solidCubeVerticies[size];
     gpu::BufferPointer colorBuffer = _solidCubeColors[colorKey];
@@ -891,7 +891,7 @@ void GeometryCache::renderWireCube(float size, const glm::vec4& color) {
             vertex[i] = cannonicalVertices[i] * halfSize;
         }
 
-        verticesBuffer->append(sizeof(GLfloat) * vertexPoints, (gpu::Buffer::Byte*) vertexData); // I'm skeptical that this is right
+        verticesBuffer->append(sizeof(GLfloat) * vertexPoints, (gpu::Byte*) vertexData); // I'm skeptical that this is right
     }
 
     if (!_wireCubeIndexBuffer) {
@@ -904,7 +904,7 @@ void GeometryCache::renderWireCube(float size, const glm::vec4& color) {
         gpu::BufferPointer indexBuffer(new gpu::Buffer());
         _wireCubeIndexBuffer = indexBuffer;
     
-        _wireCubeIndexBuffer->append(sizeof(cannonicalIndices), (gpu::Buffer::Byte*) cannonicalIndices);
+        _wireCubeIndexBuffer->append(sizeof(cannonicalIndices), (gpu::Byte*) cannonicalIndices);
     }
 
     if (!_cubeColors.contains(colorKey)) {
@@ -919,7 +919,7 @@ void GeometryCache::renderWireCube(float size, const glm::vec4& color) {
         int colors[NUM_COLOR_SCALARS_PER_CUBE] = { compactColor, compactColor, compactColor, compactColor,
                                                    compactColor, compactColor, compactColor, compactColor };
 
-        colorBuffer->append(sizeof(colors), (gpu::Buffer::Byte*) colors);
+        colorBuffer->append(sizeof(colors), (gpu::Byte*) colors);
     }
     gpu::BufferPointer verticesBuffer = _cubeVerticies[size];
     gpu::BufferPointer colorBuffer = _cubeColors[colorKey];
@@ -1037,8 +1037,8 @@ void GeometryCache::renderBevelCornersRect(int x, int y, int width, int height,
                                                    compactColor, compactColor, compactColor, compactColor };
 
 
-        details.verticesBuffer->append(sizeof(vertexBuffer), (gpu::Buffer::Byte*) vertexBuffer);
+        details.verticesBuffer->append(sizeof(vertexBuffer), (gpu::Byte*) vertexBuffer);
-        details.colorBuffer->append(sizeof(colors), (gpu::Buffer::Byte*) colors);
+        details.colorBuffer->append(sizeof(colors), (gpu::Byte*) colors);
 
         delete[] vertexBuffer;
     }
@@ -1119,8 +1119,8 @@ void GeometryCache::renderQuad(const glm::vec2& minCorner, const glm::vec2& maxC
         int colors[NUM_COLOR_SCALARS_PER_QUAD] = { compactColor, compactColor, compactColor, compactColor };
 
 
-        details.verticesBuffer->append(sizeof(vertexBuffer), (gpu::Buffer::Byte*) vertexBuffer);
+        details.verticesBuffer->append(sizeof(vertexBuffer), (gpu::Byte*) vertexBuffer);
-        details.colorBuffer->append(sizeof(colors), (gpu::Buffer::Byte*) colors);
+        details.colorBuffer->append(sizeof(colors), (gpu::Byte*) colors);
     }
 
     gpu::Batch batch;
@@ -1208,8 +1208,8 @@ void GeometryCache::renderQuad(const glm::vec2& minCorner, const glm::vec2& maxC
         int colors[NUM_COLOR_SCALARS_PER_QUAD] = { compactColor, compactColor, compactColor, compactColor };
 
 
-        details.verticesBuffer->append(sizeof(vertexBuffer), (gpu::Buffer::Byte*) vertexBuffer);
+        details.verticesBuffer->append(sizeof(vertexBuffer), (gpu::Byte*) vertexBuffer);
-        details.colorBuffer->append(sizeof(colors), (gpu::Buffer::Byte*) colors);
+        details.colorBuffer->append(sizeof(colors), (gpu::Byte*) colors);
     }
 
     gpu::Batch batch;
@@ -1294,8 +1294,8 @@ void GeometryCache::renderQuad(const glm::vec3& minCorner, const glm::vec3& maxC
         int colors[NUM_COLOR_SCALARS_PER_QUAD] = { compactColor, compactColor, compactColor, compactColor };
 
 
-        details.verticesBuffer->append(sizeof(vertexBuffer), (gpu::Buffer::Byte*) vertexBuffer);
+        details.verticesBuffer->append(sizeof(vertexBuffer), (gpu::Byte*) vertexBuffer);
-        details.colorBuffer->append(sizeof(colors), (gpu::Buffer::Byte*) colors);
+        details.colorBuffer->append(sizeof(colors), (gpu::Byte*) colors);
     }
 
     gpu::Batch batch;
@@ -1396,8 +1396,8 @@ void GeometryCache::renderQuad(const glm::vec3& topLeft, const glm::vec3& bottom
                             ((int(color.w * 255.0f) & 0xFF) << 24);
         int colors[NUM_COLOR_SCALARS_PER_QUAD] = { compactColor, compactColor, compactColor, compactColor };
 
-        details.verticesBuffer->append(sizeof(vertexBuffer), (gpu::Buffer::Byte*) vertexBuffer);
+        details.verticesBuffer->append(sizeof(vertexBuffer), (gpu::Byte*) vertexBuffer);
-        details.colorBuffer->append(sizeof(colors), (gpu::Buffer::Byte*) colors);
+        details.colorBuffer->append(sizeof(colors), (gpu::Byte*) colors);
     }
 
     gpu::Batch batch;
@@ -1510,8 +1510,8 @@ void GeometryCache::renderDashedLine(const glm::vec3& start, const glm::vec3& en
         *(vertex++) = end.z;
         *(colorDataAt++) = compactColor;
 
-        details.verticesBuffer->append(sizeof(GLfloat) * FLOATS_PER_VERTEX * details.vertices, (gpu::Buffer::Byte*) vertexData);
+        details.verticesBuffer->append(sizeof(GLfloat) * FLOATS_PER_VERTEX * details.vertices, (gpu::Byte*) vertexData);
-        details.colorBuffer->append(sizeof(int) * details.vertices, (gpu::Buffer::Byte*) colorData);
+        details.colorBuffer->append(sizeof(int) * details.vertices, (gpu::Byte*) colorData);
         delete[] vertexData;
         delete[] colorData;
 
@@ -1581,10 +1581,10 @@ GeometryCache::BatchItemDetails::~BatchItemDetails() {
 
 void GeometryCache::BatchItemDetails::clear() {
     isCreated = false;
-    verticesBuffer.clear();
+    verticesBuffer.reset();
-    colorBuffer.clear();
+    colorBuffer.reset();
-    streamFormat.clear();
+    streamFormat.reset();
-    stream.clear();
+    stream.reset();
 }
 
 void GeometryCache::renderLine(const glm::vec3& p1, const glm::vec3& p2, 
@@ -1653,8 +1653,8 @@ void GeometryCache::renderLine(const glm::vec3& p1, const glm::vec3& p2,
         const int NUM_COLOR_SCALARS = 2;
         int colors[NUM_COLOR_SCALARS] = { compactColor1, compactColor2 };
 
-        details.verticesBuffer->append(sizeof(vertexBuffer), (gpu::Buffer::Byte*) vertexBuffer);
+        details.verticesBuffer->append(sizeof(vertexBuffer), (gpu::Byte*) vertexBuffer);
-        details.colorBuffer->append(sizeof(colors), (gpu::Buffer::Byte*) colors);
+        details.colorBuffer->append(sizeof(colors), (gpu::Byte*) colors);
 
         #ifdef WANT_DEBUG
             if (id == UNKNOWN_ID) {
@@ -1745,8 +1745,8 @@ void GeometryCache::renderLine(const glm::vec2& p1, const glm::vec2& p2,
         const int NUM_COLOR_SCALARS = 2;
         int colors[NUM_COLOR_SCALARS] = { compactColor1, compactColor2 };
 
-        details.verticesBuffer->append(sizeof(vertexBuffer), (gpu::Buffer::Byte*) vertexBuffer);
+        details.verticesBuffer->append(sizeof(vertexBuffer), (gpu::Byte*) vertexBuffer);
-        details.colorBuffer->append(sizeof(colors), (gpu::Buffer::Byte*) colors);
+        details.colorBuffer->append(sizeof(colors), (gpu::Byte*) colors);
 
         #ifdef WANT_DEBUG
             if (id == UNKNOWN_ID) {
@@ -2234,10 +2234,10 @@ void NetworkGeometry::setGeometry(const FBXGeometry& geometry) {
             int offset = 0;
             foreach(const FBXMeshPart& part, mesh.parts) {
                 networkMesh._indexBuffer->setSubData(offset, part.quadIndices.size() * sizeof(int),
-                    (gpu::Resource::Byte*) part.quadIndices.constData());
+                    (gpu::Byte*) part.quadIndices.constData());
                 offset += part.quadIndices.size() * sizeof(int);
                 networkMesh._indexBuffer->setSubData(offset, part.triangleIndices.size() * sizeof(int),
-                    (gpu::Resource::Byte*) part.triangleIndices.constData());
+                    (gpu::Byte*) part.triangleIndices.constData());
                 offset += part.triangleIndices.size() * sizeof(int);
             }
         }
@@ -2256,19 +2256,19 @@ void NetworkGeometry::setGeometry(const FBXGeometry& geometry) {
 
                 networkMesh._vertexBuffer->resize(clusterWeightsOffset + mesh.clusterWeights.size() * sizeof(glm::vec4));
 
-                networkMesh._vertexBuffer->setSubData(0, mesh.vertices.size() * sizeof(glm::vec3), (gpu::Resource::Byte*) mesh.vertices.constData());
+                networkMesh._vertexBuffer->setSubData(0, mesh.vertices.size() * sizeof(glm::vec3), (gpu::Byte*) mesh.vertices.constData());
-                networkMesh._vertexBuffer->setSubData(normalsOffset, mesh.normals.size() * sizeof(glm::vec3), (gpu::Resource::Byte*) mesh.normals.constData());
+                networkMesh._vertexBuffer->setSubData(normalsOffset, mesh.normals.size() * sizeof(glm::vec3), (gpu::Byte*) mesh.normals.constData());
                 networkMesh._vertexBuffer->setSubData(tangentsOffset,
-                    mesh.tangents.size() * sizeof(glm::vec3), (gpu::Resource::Byte*) mesh.tangents.constData());
+                    mesh.tangents.size() * sizeof(glm::vec3), (gpu::Byte*) mesh.tangents.constData());
-                networkMesh._vertexBuffer->setSubData(colorsOffset, mesh.colors.size() * sizeof(glm::vec3), (gpu::Resource::Byte*) mesh.colors.constData());
+                networkMesh._vertexBuffer->setSubData(colorsOffset, mesh.colors.size() * sizeof(glm::vec3), (gpu::Byte*) mesh.colors.constData());
                 networkMesh._vertexBuffer->setSubData(texCoordsOffset,
-                    mesh.texCoords.size() * sizeof(glm::vec2), (gpu::Resource::Byte*) mesh.texCoords.constData());
+                    mesh.texCoords.size() * sizeof(glm::vec2), (gpu::Byte*) mesh.texCoords.constData());
                 networkMesh._vertexBuffer->setSubData(texCoords1Offset,
-                    mesh.texCoords1.size() * sizeof(glm::vec2), (gpu::Resource::Byte*) mesh.texCoords1.constData());
+                    mesh.texCoords1.size() * sizeof(glm::vec2), (gpu::Byte*) mesh.texCoords1.constData());
                 networkMesh._vertexBuffer->setSubData(clusterIndicesOffset,
-                    mesh.clusterIndices.size() * sizeof(glm::vec4), (gpu::Resource::Byte*) mesh.clusterIndices.constData());
+                    mesh.clusterIndices.size() * sizeof(glm::vec4), (gpu::Byte*) mesh.clusterIndices.constData());
                 networkMesh._vertexBuffer->setSubData(clusterWeightsOffset,
-                    mesh.clusterWeights.size() * sizeof(glm::vec4), (gpu::Resource::Byte*) mesh.clusterWeights.constData());
+                    mesh.clusterWeights.size() * sizeof(glm::vec4), (gpu::Byte*) mesh.clusterWeights.constData());
 
                 // otherwise, at least the cluster indices/weights can be static
                 networkMesh._vertexStream = gpu::BufferStreamPointer(new gpu::BufferStream());
@@ -2304,14 +2304,14 @@ void NetworkGeometry::setGeometry(const FBXGeometry& geometry) {
                 int clusterWeightsOffset = clusterIndicesOffset + mesh.clusterIndices.size() * sizeof(glm::vec4);
 
                 networkMesh._vertexBuffer->resize(clusterWeightsOffset + mesh.clusterWeights.size() * sizeof(glm::vec4));
-                networkMesh._vertexBuffer->setSubData(0, mesh.tangents.size() * sizeof(glm::vec3), (gpu::Resource::Byte*) mesh.tangents.constData());
+                networkMesh._vertexBuffer->setSubData(0, mesh.tangents.size() * sizeof(glm::vec3), (gpu::Byte*) mesh.tangents.constData());
-                networkMesh._vertexBuffer->setSubData(colorsOffset, mesh.colors.size() * sizeof(glm::vec3), (gpu::Resource::Byte*) mesh.colors.constData());
+                networkMesh._vertexBuffer->setSubData(colorsOffset, mesh.colors.size() * sizeof(glm::vec3), (gpu::Byte*) mesh.colors.constData());
                 networkMesh._vertexBuffer->setSubData(texCoordsOffset,
-                    mesh.texCoords.size() * sizeof(glm::vec2), (gpu::Resource::Byte*) mesh.texCoords.constData());
+                    mesh.texCoords.size() * sizeof(glm::vec2), (gpu::Byte*) mesh.texCoords.constData());
                 networkMesh._vertexBuffer->setSubData(clusterIndicesOffset,
-                    mesh.clusterIndices.size() * sizeof(glm::vec4), (gpu::Resource::Byte*) mesh.clusterIndices.constData());
+                    mesh.clusterIndices.size() * sizeof(glm::vec4), (gpu::Byte*) mesh.clusterIndices.constData());
                 networkMesh._vertexBuffer->setSubData(clusterWeightsOffset,
-                    mesh.clusterWeights.size() * sizeof(glm::vec4), (gpu::Resource::Byte*) mesh.clusterWeights.constData());
+                    mesh.clusterWeights.size() * sizeof(glm::vec4), (gpu::Byte*) mesh.clusterWeights.constData());
 
                 networkMesh._vertexStream = gpu::BufferStreamPointer(new gpu::BufferStream());
                 if (mesh.tangents.size()) networkMesh._vertexStream->addBuffer(networkMesh._vertexBuffer, 0, sizeof(glm::vec3));

libraries/render-utils/src/Model.cpp

@@ -451,9 +451,9 @@ bool Model::updateGeometry() {
             gpu::BufferPointer buffer(new gpu::Buffer());
             if (!mesh.blendshapes.isEmpty()) {
                 buffer->resize((mesh.vertices.size() + mesh.normals.size()) * sizeof(glm::vec3));
-                buffer->setSubData(0, mesh.vertices.size() * sizeof(glm::vec3), (gpu::Resource::Byte*) mesh.vertices.constData());
+                buffer->setSubData(0, mesh.vertices.size() * sizeof(glm::vec3), (gpu::Byte*) mesh.vertices.constData());
                 buffer->setSubData(mesh.vertices.size() * sizeof(glm::vec3),
-                    mesh.normals.size() * sizeof(glm::vec3), (gpu::Resource::Byte*) mesh.normals.constData());
+                    mesh.normals.size() * sizeof(glm::vec3), (gpu::Byte*) mesh.normals.constData());
             }
             _blendedVertexBuffers.push_back(buffer);
         }
@@ -1732,9 +1732,9 @@ void Model::setBlendedVertices(int blendNumber, const QWeakPointer<NetworkGeomet
         }
 
         gpu::BufferPointer& buffer = _blendedVertexBuffers[i];
-        buffer->setSubData(0, mesh.vertices.size() * sizeof(glm::vec3), (gpu::Resource::Byte*) vertices.constData() + index*sizeof(glm::vec3));
+        buffer->setSubData(0, mesh.vertices.size() * sizeof(glm::vec3), (gpu::Byte*) vertices.constData() + index*sizeof(glm::vec3));
         buffer->setSubData(mesh.vertices.size() * sizeof(glm::vec3),
-            mesh.normals.size() * sizeof(glm::vec3), (gpu::Resource::Byte*) normals.constData() + index*sizeof(glm::vec3));
+            mesh.normals.size() * sizeof(glm::vec3), (gpu::Byte*) normals.constData() + index*sizeof(glm::vec3));
 
         index += mesh.vertices.size();
     }

libraries/render-utils/src/TextureCache.cpp

@@ -89,7 +89,7 @@ const int permutation[256] =
 #define USE_CHRIS_NOISE 1
 
 const gpu::TexturePointer& TextureCache::getPermutationNormalTexture() {
-    if (_permutationNormalTexture.isNull()) {
+    if (!_permutationNormalTexture) {
 
         // the first line consists of random permutation offsets
         unsigned char data[256 * 2 * 3];
@@ -133,7 +133,7 @@ static void loadSingleColorTexture(const unsigned char* color) {
 */
 
 const gpu::TexturePointer& TextureCache::getWhiteTexture() {
-    if (_whiteTexture.isNull()) {
+    if (!_whiteTexture) {
         _whiteTexture = gpu::TexturePointer(gpu::Texture::create2D(gpu::Element(gpu::VEC4, gpu::UINT8, gpu::RGBA), 1, 1));
         _whiteTexture->assignStoredMip(0, _whiteTexture->getTexelFormat(), sizeof(OPAQUE_WHITE), OPAQUE_WHITE);
     }
@@ -141,7 +141,7 @@ const gpu::TexturePointer& TextureCache::getWhiteTexture() {
 }
 
 const gpu::TexturePointer& TextureCache::getBlueTexture() {
-    if (_blueTexture.isNull()) {
+    if (!_blueTexture) {
         _blueTexture = gpu::TexturePointer(gpu::Texture::create2D(gpu::Element(gpu::VEC4, gpu::UINT8, gpu::RGBA), 1, 1));
         _blueTexture->assignStoredMip(0, _blueTexture->getTexelFormat(), sizeof(OPAQUE_BLUE), OPAQUE_BLUE);
     }