From cd1e910844ca3d7e9f6d0e722a6df07473fd9672 Mon Sep 17 00:00:00 2001
From: Brad Davis <bdavis@saintandreas.org>
Date: Tue, 10 May 2016 09:27:01 -0700
Subject: [PATCH 1/2] Add a generic shape primitive

---
 .../src/EntityTreeRenderer.cpp                |  10 +-
 .../src/RenderableBoxEntityItem.cpp           |  76 ------
 .../src/RenderableBoxEntityItem.h             |  34 ---
 .../src/RenderableShapeEntityItem.cpp         | 113 +++++++++
 .../src/RenderableShapeEntityItem.h           |  36 +++
 .../src/RenderableSphereEntityItem.cpp        |  80 ------
 .../src/RenderableSphereEntityItem.h          |  35 ---
 libraries/entities/src/BoxEntityItem.cpp      | 103 --------
 libraries/entities/src/BoxEntityItem.h        |  64 -----
 .../entities/src/EntityItemProperties.cpp     |  15 +-
 libraries/entities/src/EntityItemProperties.h |   4 +-
 libraries/entities/src/EntityPropertyFlags.h  |   2 +
 libraries/entities/src/EntityTypes.cpp        |  10 +-
 libraries/entities/src/EntityTypes.h          |  18 +-
 libraries/entities/src/ShapeEntityItem.cpp    | 230 ++++++++++++++++++
 libraries/entities/src/ShapeEntityItem.h      | 103 ++++++++
 libraries/entities/src/SphereEntityItem.cpp   | 132 ----------
 libraries/entities/src/SphereEntityItem.h     |  70 ------
 libraries/render-utils/src/GeometryCache.cpp  |  41 ++--
 libraries/render-utils/src/GeometryCache.h    |   7 +
 .../developer/tests/entityEditStressTest.js   | 164 +------------
 scripts/developer/tests/entitySpawnTool.js    | 184 ++++++++++++++
 scripts/developer/tests/primitivesTest.js     |  24 ++
 scripts/system/html/entityProperties.html     |  51 +++-
 tests/entities/src/main.cpp                   |   4 +-
 25 files changed, 819 insertions(+), 791 deletions(-)
 delete mode 100644 libraries/entities-renderer/src/RenderableBoxEntityItem.cpp
 delete mode 100644 libraries/entities-renderer/src/RenderableBoxEntityItem.h
 create mode 100644 libraries/entities-renderer/src/RenderableShapeEntityItem.cpp
 create mode 100644 libraries/entities-renderer/src/RenderableShapeEntityItem.h
 delete mode 100644 libraries/entities-renderer/src/RenderableSphereEntityItem.cpp
 delete mode 100644 libraries/entities-renderer/src/RenderableSphereEntityItem.h
 delete mode 100644 libraries/entities/src/BoxEntityItem.cpp
 delete mode 100644 libraries/entities/src/BoxEntityItem.h
 create mode 100644 libraries/entities/src/ShapeEntityItem.cpp
 create mode 100644 libraries/entities/src/ShapeEntityItem.h
 delete mode 100644 libraries/entities/src/SphereEntityItem.cpp
 delete mode 100644 libraries/entities/src/SphereEntityItem.h
 create mode 100644 scripts/developer/tests/entitySpawnTool.js
 create mode 100644 scripts/developer/tests/primitivesTest.js

diff --git a/libraries/entities-renderer/src/EntityTreeRenderer.cpp b/libraries/entities-renderer/src/EntityTreeRenderer.cpp
index bec2fa9b8d..56f6438e70 100644
--- a/libraries/entities-renderer/src/EntityTreeRenderer.cpp
+++ b/libraries/entities-renderer/src/EntityTreeRenderer.cpp
@@ -29,17 +29,16 @@
 
 #include "RenderableEntityItem.h"
 
-#include "RenderableBoxEntityItem.h"
 #include "RenderableLightEntityItem.h"
 #include "RenderableModelEntityItem.h"
 #include "RenderableParticleEffectEntityItem.h"
-#include "RenderableSphereEntityItem.h"
 #include "RenderableTextEntityItem.h"
 #include "RenderableWebEntityItem.h"
 #include "RenderableZoneEntityItem.h"
 #include "RenderableLineEntityItem.h"
 #include "RenderablePolyVoxEntityItem.h"
 #include "RenderablePolyLineEntityItem.h"
+#include "RenderableShapeEntityItem.h"
 #include "EntitiesRendererLogging.h"
 #include "AddressManager.h"
 #include <Rig.h>
@@ -56,8 +55,6 @@ EntityTreeRenderer::EntityTreeRenderer(bool wantScripts, AbstractViewStateInterf
     _dontDoPrecisionPicking(false)
 {
     REGISTER_ENTITY_TYPE_WITH_FACTORY(Model, RenderableModelEntityItem::factory)
-    REGISTER_ENTITY_TYPE_WITH_FACTORY(Box, RenderableBoxEntityItem::factory)
-    REGISTER_ENTITY_TYPE_WITH_FACTORY(Sphere, RenderableSphereEntityItem::factory)
     REGISTER_ENTITY_TYPE_WITH_FACTORY(Light, RenderableLightEntityItem::factory)
     REGISTER_ENTITY_TYPE_WITH_FACTORY(Text, RenderableTextEntityItem::factory)
     REGISTER_ENTITY_TYPE_WITH_FACTORY(Web, RenderableWebEntityItem::factory)
@@ -66,7 +63,10 @@ EntityTreeRenderer::EntityTreeRenderer(bool wantScripts, AbstractViewStateInterf
     REGISTER_ENTITY_TYPE_WITH_FACTORY(Line, RenderableLineEntityItem::factory)
     REGISTER_ENTITY_TYPE_WITH_FACTORY(PolyVox, RenderablePolyVoxEntityItem::factory)
     REGISTER_ENTITY_TYPE_WITH_FACTORY(PolyLine, RenderablePolyLineEntityItem::factory)
-    
+    REGISTER_ENTITY_TYPE_WITH_FACTORY(Shape, RenderableShapeEntityItem::factory)
+    REGISTER_ENTITY_TYPE_WITH_FACTORY(Box, RenderableShapeEntityItem::boxFactory)
+    REGISTER_ENTITY_TYPE_WITH_FACTORY(Sphere, RenderableShapeEntityItem::sphereFactory)
+
     _currentHoverOverEntityID = UNKNOWN_ENTITY_ID;
     _currentClickingOnEntityID = UNKNOWN_ENTITY_ID;
 }
diff --git a/libraries/entities-renderer/src/RenderableBoxEntityItem.cpp b/libraries/entities-renderer/src/RenderableBoxEntityItem.cpp
deleted file mode 100644
index e392450c08..0000000000
--- a/libraries/entities-renderer/src/RenderableBoxEntityItem.cpp
+++ /dev/null
@@ -1,76 +0,0 @@
-//
-//  RenderableBoxEntityItem.cpp
-//  libraries/entities-renderer/src/
-//
-//  Created by Brad Hefta-Gaub on 8/6/14.
-//  Copyright 2014 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 "RenderableBoxEntityItem.h"
-
-#include <glm/gtx/quaternion.hpp>
-
-#include <gpu/Batch.h>
-
-#include <GeometryCache.h>
-#include <ObjectMotionState.h>
-#include <PerfStat.h>
-
-#include <render-utils/simple_vert.h>
-#include <render-utils/simple_frag.h>
-
-EntityItemPointer RenderableBoxEntityItem::factory(const EntityItemID& entityID, const EntityItemProperties& properties) {
-    EntityItemPointer entity{ new RenderableBoxEntityItem(entityID) };
-    entity->setProperties(properties);
-    return entity;
-}
-
-void RenderableBoxEntityItem::setUserData(const QString& value) {
-    if (value != getUserData()) {
-        BoxEntityItem::setUserData(value);
-        if (_procedural) {
-            _procedural->parse(value);
-        }
-    }
-}
-
-void RenderableBoxEntityItem::render(RenderArgs* args) {
-    PerformanceTimer perfTimer("RenderableBoxEntityItem::render");
-    Q_ASSERT(getType() == EntityTypes::Box);
-    Q_ASSERT(args->_batch);
-
-    if (!_procedural) {
-        _procedural.reset(new Procedural(this->getUserData()));
-        _procedural->_vertexSource = simple_vert;
-        _procedural->_fragmentSource = simple_frag;
-        _procedural->_state->setCullMode(gpu::State::CULL_NONE);
-        _procedural->_state->setDepthTest(true, true, gpu::LESS_EQUAL);
-        _procedural->_state->setBlendFunction(false,
-            gpu::State::SRC_ALPHA, gpu::State::BLEND_OP_ADD, gpu::State::INV_SRC_ALPHA,
-            gpu::State::FACTOR_ALPHA, gpu::State::BLEND_OP_ADD, gpu::State::ONE);
-    }
-
-    gpu::Batch& batch = *args->_batch;
-    glm::vec4 cubeColor(toGlm(getXColor()), getLocalRenderAlpha());
-
-    bool success;
-    auto transToCenter = getTransformToCenter(success);
-    if (!success) {
-        return;
-    }
-
-    batch.setModelTransform(transToCenter); // we want to include the scale as well
-    if (_procedural->ready()) {
-        _procedural->prepare(batch, getPosition(), getDimensions());
-        auto color = _procedural->getColor(cubeColor);
-        batch._glColor4f(color.r, color.g, color.b, color.a);
-        DependencyManager::get<GeometryCache>()->renderCube(batch);
-    } else {
-        DependencyManager::get<GeometryCache>()->renderSolidCubeInstance(batch, cubeColor);
-    }
-    static const auto triCount = DependencyManager::get<GeometryCache>()->getCubeTriangleCount();
-    args->_details._trianglesRendered += (int)triCount;
-}
diff --git a/libraries/entities-renderer/src/RenderableBoxEntityItem.h b/libraries/entities-renderer/src/RenderableBoxEntityItem.h
deleted file mode 100644
index 67f881dbd8..0000000000
--- a/libraries/entities-renderer/src/RenderableBoxEntityItem.h
+++ /dev/null
@@ -1,34 +0,0 @@
-//
-//  RenderableBoxEntityItem.h
-//  libraries/entities-renderer/src/
-//
-//  Created by Brad Hefta-Gaub on 8/6/14.
-//  Copyright 2014 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_RenderableBoxEntityItem_h
-#define hifi_RenderableBoxEntityItem_h
-
-#include <BoxEntityItem.h>
-#include <procedural/Procedural.h>
-
-#include "RenderableEntityItem.h"
-
-class RenderableBoxEntityItem : public BoxEntityItem {
-public:
-    static EntityItemPointer factory(const EntityItemID& entityID, const EntityItemProperties& properties);
-    RenderableBoxEntityItem(const EntityItemID& entityItemID) : BoxEntityItem(entityItemID) { }
-
-    virtual void render(RenderArgs* args) override;
-    virtual void setUserData(const QString& value) override;
-
-    SIMPLE_RENDERABLE()
-private:
-    QSharedPointer<Procedural> _procedural;
-};
-
-
-#endif // hifi_RenderableBoxEntityItem_h
diff --git a/libraries/entities-renderer/src/RenderableShapeEntityItem.cpp b/libraries/entities-renderer/src/RenderableShapeEntityItem.cpp
new file mode 100644
index 0000000000..7d30b7a47c
--- /dev/null
+++ b/libraries/entities-renderer/src/RenderableShapeEntityItem.cpp
@@ -0,0 +1,113 @@
+//
+//  Created by Bradley Austin Davis on 2016/05/09
+//  Copyright 2013 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 "RenderableShapeEntityItem.h"
+
+#include <glm/gtx/quaternion.hpp>
+
+#include <gpu/Batch.h>
+
+#include <DependencyManager.h>
+#include <GeometryCache.h>
+#include <PerfStat.h>
+
+#include <render-utils/simple_vert.h>
+#include <render-utils/simple_frag.h>
+
+// Sphere entities should fit inside a cube entity of the same size, so a sphere that has dimensions 1x1x1 
+// is a half unit sphere.  However, the geometry cache renders a UNIT sphere, so we need to scale down.
+static const float SPHERE_ENTITY_SCALE = 0.5f;
+
+static GeometryCache::Shape MAPPING[entity::NUM_SHAPES] = {
+    GeometryCache::Triangle,
+    GeometryCache::Quad,
+    GeometryCache::Circle,
+    GeometryCache::Cube,
+    GeometryCache::Sphere,
+    GeometryCache::Tetrahedron,
+    GeometryCache::Octahetron,
+    GeometryCache::Dodecahedron,
+    GeometryCache::Icosahedron,
+    GeometryCache::Torus,
+    GeometryCache::Cone,
+    GeometryCache::Cylinder,
+};
+
+
+RenderableShapeEntityItem::Pointer RenderableShapeEntityItem::baseFactory(const EntityItemID& entityID, const EntityItemProperties& properties) {
+    Pointer entity = std::make_shared<RenderableShapeEntityItem>(entityID);
+    entity->setProperties(properties);
+    return entity;
+}
+
+EntityItemPointer RenderableShapeEntityItem::factory(const EntityItemID& entityID, const EntityItemProperties& properties) {
+    return baseFactory(entityID, properties);
+}
+
+EntityItemPointer RenderableShapeEntityItem::boxFactory(const EntityItemID& entityID, const EntityItemProperties& properties) {
+    auto result = baseFactory(entityID, properties);
+    result->setShape(entity::Cube);
+    return result;
+}
+
+EntityItemPointer RenderableShapeEntityItem::sphereFactory(const EntityItemID& entityID, const EntityItemProperties& properties) {
+    auto result = baseFactory(entityID, properties);
+    result->setShape(entity::Sphere);
+    return result;
+}
+
+void RenderableShapeEntityItem::setUserData(const QString& value) {
+    if (value != getUserData()) {
+        ShapeEntityItem::setUserData(value);
+        if (_procedural) {
+            _procedural->parse(value);
+        }
+    }
+}
+
+void RenderableShapeEntityItem::render(RenderArgs* args) {
+    PerformanceTimer perfTimer("RenderableShapeEntityItem::render");
+    //Q_ASSERT(getType() == EntityTypes::Shape);
+    Q_ASSERT(args->_batch);
+
+    if (!_procedural) {
+        _procedural.reset(new Procedural(getUserData()));
+        _procedural->_vertexSource = simple_vert;
+        _procedural->_fragmentSource = simple_frag;
+        _procedural->_state->setCullMode(gpu::State::CULL_NONE);
+        _procedural->_state->setDepthTest(true, true, gpu::LESS_EQUAL);
+        _procedural->_state->setBlendFunction(false,
+            gpu::State::SRC_ALPHA, gpu::State::BLEND_OP_ADD, gpu::State::INV_SRC_ALPHA,
+            gpu::State::FACTOR_ALPHA, gpu::State::BLEND_OP_ADD, gpu::State::ONE);
+    }
+
+    gpu::Batch& batch = *args->_batch;
+    glm::vec4 color(toGlm(getXColor()), getLocalRenderAlpha());
+    bool success;
+    Transform modelTransform = getTransformToCenter(success);
+    if (!success) {
+        return;
+    }
+    if (_shape != entity::Cube) {
+        modelTransform.postScale(SPHERE_ENTITY_SCALE);
+    }
+    batch.setModelTransform(modelTransform); // use a transform with scale, rotation, registration point and translation
+    if (_procedural->ready()) {
+        _procedural->prepare(batch, getPosition(), getDimensions());
+        auto outColor = _procedural->getColor(color);
+        batch._glColor4f(outColor.r, outColor.g, outColor.b, outColor.a);
+        DependencyManager::get<GeometryCache>()->renderShape(batch, MAPPING[_shape]);
+    } else {
+        // FIXME, support instanced multi-shape rendering using multidraw indirect
+        DependencyManager::get<GeometryCache>()->renderSolidShapeInstance(batch, MAPPING[_shape], color);
+    }
+
+
+    static const auto triCount = DependencyManager::get<GeometryCache>()->getShapeTriangleCount(MAPPING[_shape]);
+    args->_details._trianglesRendered += (int)triCount;
+}
diff --git a/libraries/entities-renderer/src/RenderableShapeEntityItem.h b/libraries/entities-renderer/src/RenderableShapeEntityItem.h
new file mode 100644
index 0000000000..b18370b13c
--- /dev/null
+++ b/libraries/entities-renderer/src/RenderableShapeEntityItem.h
@@ -0,0 +1,36 @@
+//
+//  Created by Bradley Austin Davis on 2016/05/09
+//  Copyright 2013 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_RenderableShapeEntityItem_h
+#define hifi_RenderableShapeEntityItem_h
+
+#include <ShapeEntityItem.h>
+#include <procedural/Procedural.h>
+
+#include "RenderableEntityItem.h"
+
+class RenderableShapeEntityItem : public ShapeEntityItem {
+    using Pointer = std::shared_ptr<RenderableShapeEntityItem>;
+    static Pointer baseFactory(const EntityItemID& entityID, const EntityItemProperties& properties);
+public:
+    static EntityItemPointer factory(const EntityItemID& entityID, const EntityItemProperties& properties);
+    static EntityItemPointer boxFactory(const EntityItemID& entityID, const EntityItemProperties& properties);
+    static EntityItemPointer sphereFactory(const EntityItemID& entityID, const EntityItemProperties& properties);
+    RenderableShapeEntityItem(const EntityItemID& entityItemID) : ShapeEntityItem(entityItemID) {}
+
+    void render(RenderArgs* args) override;
+    void setUserData(const QString& value) override;
+
+    SIMPLE_RENDERABLE();
+
+private:
+    QSharedPointer<Procedural> _procedural;
+};
+
+
+#endif // hifi_RenderableShapeEntityItem_h
diff --git a/libraries/entities-renderer/src/RenderableSphereEntityItem.cpp b/libraries/entities-renderer/src/RenderableSphereEntityItem.cpp
deleted file mode 100644
index c3437b0e4a..0000000000
--- a/libraries/entities-renderer/src/RenderableSphereEntityItem.cpp
+++ /dev/null
@@ -1,80 +0,0 @@
-//
-//  RenderableSphereEntityItem.cpp
-//  interface/src
-//
-//  Created by Brad Hefta-Gaub on 8/6/14.
-//  Copyright 2014 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 "RenderableSphereEntityItem.h"
-
-#include <glm/gtx/quaternion.hpp>
-
-#include <gpu/Batch.h>
-
-#include <DependencyManager.h>
-#include <GeometryCache.h>
-#include <PerfStat.h>
-
-#include <render-utils/simple_vert.h>
-#include <render-utils/simple_frag.h>
-
-// Sphere entities should fit inside a cube entity of the same size, so a sphere that has dimensions 1x1x1 
-// is a half unit sphere.  However, the geometry cache renders a UNIT sphere, so we need to scale down.
-static const float SPHERE_ENTITY_SCALE = 0.5f;
-
-
-EntityItemPointer RenderableSphereEntityItem::factory(const EntityItemID& entityID, const EntityItemProperties& properties) {
-    EntityItemPointer entity{ new RenderableSphereEntityItem(entityID) };
-    entity->setProperties(properties);
-    return entity;
-}
-
-void RenderableSphereEntityItem::setUserData(const QString& value) {
-    if (value != getUserData()) {
-        SphereEntityItem::setUserData(value);
-        if (_procedural) {
-            _procedural->parse(value);
-        }
-    }
-}
-
-void RenderableSphereEntityItem::render(RenderArgs* args) {
-    PerformanceTimer perfTimer("RenderableSphereEntityItem::render");
-    Q_ASSERT(getType() == EntityTypes::Sphere);
-    Q_ASSERT(args->_batch);
-
-    if (!_procedural) {
-        _procedural.reset(new Procedural(getUserData()));
-        _procedural->_vertexSource = simple_vert;
-        _procedural->_fragmentSource = simple_frag;
-        _procedural->_state->setCullMode(gpu::State::CULL_NONE);
-        _procedural->_state->setDepthTest(true, true, gpu::LESS_EQUAL);
-        _procedural->_state->setBlendFunction(false,
-            gpu::State::SRC_ALPHA, gpu::State::BLEND_OP_ADD, gpu::State::INV_SRC_ALPHA,
-            gpu::State::FACTOR_ALPHA, gpu::State::BLEND_OP_ADD, gpu::State::ONE);
-    }
-
-    gpu::Batch& batch = *args->_batch;
-    glm::vec4 sphereColor(toGlm(getXColor()), getLocalRenderAlpha());
-    bool success;
-    Transform modelTransform = getTransformToCenter(success);
-    if (!success) {
-        return;
-    }
-    modelTransform.postScale(SPHERE_ENTITY_SCALE);
-    batch.setModelTransform(modelTransform); // use a transform with scale, rotation, registration point and translation
-    if (_procedural->ready()) {
-        _procedural->prepare(batch, getPosition(), getDimensions());
-        auto color = _procedural->getColor(sphereColor);
-        batch._glColor4f(color.r, color.g, color.b, color.a);
-        DependencyManager::get<GeometryCache>()->renderSphere(batch);
-    } else {
-        DependencyManager::get<GeometryCache>()->renderSolidSphereInstance(batch, sphereColor);
-    }
-    static const auto triCount = DependencyManager::get<GeometryCache>()->getSphereTriangleCount();
-    args->_details._trianglesRendered += (int)triCount;
-}
diff --git a/libraries/entities-renderer/src/RenderableSphereEntityItem.h b/libraries/entities-renderer/src/RenderableSphereEntityItem.h
deleted file mode 100644
index 5efe49854a..0000000000
--- a/libraries/entities-renderer/src/RenderableSphereEntityItem.h
+++ /dev/null
@@ -1,35 +0,0 @@
-//
-//  RenderableSphereEntityItem.h
-//  interface/src/entities
-//
-//  Created by Brad Hefta-Gaub on 8/6/14.
-//  Copyright 2014 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_RenderableSphereEntityItem_h
-#define hifi_RenderableSphereEntityItem_h
-
-#include <SphereEntityItem.h>
-#include <procedural/Procedural.h>
-
-#include "RenderableEntityItem.h"
-
-class RenderableSphereEntityItem : public SphereEntityItem {
-public:
-    static EntityItemPointer factory(const EntityItemID& entityID, const EntityItemProperties& properties);
-    RenderableSphereEntityItem(const EntityItemID& entityItemID) : SphereEntityItem(entityItemID) { }
-
-    virtual void render(RenderArgs* args) override;
-    virtual void setUserData(const QString& value) override;
-
-    SIMPLE_RENDERABLE();
-
-private:
-    QSharedPointer<Procedural> _procedural;
-};
-
-
-#endif // hifi_RenderableSphereEntityItem_h
diff --git a/libraries/entities/src/BoxEntityItem.cpp b/libraries/entities/src/BoxEntityItem.cpp
deleted file mode 100644
index bf02d383ab..0000000000
--- a/libraries/entities/src/BoxEntityItem.cpp
+++ /dev/null
@@ -1,103 +0,0 @@
-//
-//  BoxEntityItem.cpp
-//  libraries/entities/src
-//
-//  Created by Brad Hefta-Gaub on 12/4/13.
-//  Copyright 2013 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 <QDebug>
-
-#include <ByteCountCoding.h>
-
-#include "BoxEntityItem.h"
-#include "EntitiesLogging.h"
-#include "EntityItemProperties.h"
-#include "EntityTree.h"
-#include "EntityTreeElement.h"
-
-EntityItemPointer BoxEntityItem::factory(const EntityItemID& entityID, const EntityItemProperties& properties) {
-    EntityItemPointer entity { new BoxEntityItem(entityID) };
-    entity->setProperties(properties);
-    return entity;
-}
-
-BoxEntityItem::BoxEntityItem(const EntityItemID& entityItemID) : EntityItem(entityItemID) {
-    _type = EntityTypes::Box;
-}
-
-EntityItemProperties BoxEntityItem::getProperties(EntityPropertyFlags desiredProperties) const {
-    EntityItemProperties properties = EntityItem::getProperties(desiredProperties); // get the properties from our base class
-
-    properties._color = getXColor();
-    properties._colorChanged = false;
-
-    return properties;
-}
-
-bool BoxEntityItem::setProperties(const EntityItemProperties& properties) {
-    bool somethingChanged = false;
-    somethingChanged = EntityItem::setProperties(properties); // set the properties in our base class
-
-    SET_ENTITY_PROPERTY_FROM_PROPERTIES(color, setColor);
-
-    if (somethingChanged) {
-        bool wantDebug = false;
-        if (wantDebug) {
-            uint64_t now = usecTimestampNow();
-            int elapsed = now - getLastEdited();
-            qCDebug(entities) << "BoxEntityItem::setProperties() AFTER update... edited AGO=" << elapsed <<
-                    "now=" << now << " getLastEdited()=" << getLastEdited();
-        }
-        setLastEdited(properties._lastEdited);
-    }
-    return somethingChanged;
-}
-
-int BoxEntityItem::readEntitySubclassDataFromBuffer(const unsigned char* data, int bytesLeftToRead, 
-                                                ReadBitstreamToTreeParams& args,
-                                                EntityPropertyFlags& propertyFlags, bool overwriteLocalData,
-                                                bool& somethingChanged) {
-
-    int bytesRead = 0;
-    const unsigned char* dataAt = data;
-
-    READ_ENTITY_PROPERTY(PROP_COLOR, rgbColor, setColor);
-
-    return bytesRead;
-}
-
-
-// TODO: eventually only include properties changed since the params.lastViewFrustumSent time
-EntityPropertyFlags BoxEntityItem::getEntityProperties(EncodeBitstreamParams& params) const {
-    EntityPropertyFlags requestedProperties = EntityItem::getEntityProperties(params);
-    requestedProperties += PROP_COLOR;
-    return requestedProperties;
-}
-
-void BoxEntityItem::appendSubclassData(OctreePacketData* packetData, EncodeBitstreamParams& params, 
-                                    EntityTreeElementExtraEncodeData* modelTreeElementExtraEncodeData,
-                                    EntityPropertyFlags& requestedProperties,
-                                    EntityPropertyFlags& propertyFlags,
-                                    EntityPropertyFlags& propertiesDidntFit,
-                                    int& propertyCount, 
-                                    OctreeElement::AppendState& appendState) const { 
-
-    bool successPropertyFits = true;
-
-    APPEND_ENTITY_PROPERTY(PROP_COLOR, getColor());
-}
-
-void BoxEntityItem::debugDump() const {
-    quint64 now = usecTimestampNow();
-    qCDebug(entities) << "   BOX EntityItem id:" << getEntityItemID() << "---------------------------------------------";
-    qCDebug(entities) << "               color:" << _color[0] << "," << _color[1] << "," << _color[2];
-    qCDebug(entities) << "            position:" << debugTreeVector(getPosition());
-    qCDebug(entities) << "          dimensions:" << debugTreeVector(getDimensions());
-    qCDebug(entities) << "       getLastEdited:" << debugTime(getLastEdited(), now);
-}
-
diff --git a/libraries/entities/src/BoxEntityItem.h b/libraries/entities/src/BoxEntityItem.h
deleted file mode 100644
index 6196346b9a..0000000000
--- a/libraries/entities/src/BoxEntityItem.h
+++ /dev/null
@@ -1,64 +0,0 @@
-//
-//  BoxEntityItem.h
-//  libraries/entities/src
-//
-//  Created by Brad Hefta-Gaub on 12/4/13.
-//  Copyright 2013 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_BoxEntityItem_h
-#define hifi_BoxEntityItem_h
-
-#include "EntityItem.h" 
-
-class BoxEntityItem : public EntityItem {
-public:
-    static EntityItemPointer factory(const EntityItemID& entityID, const EntityItemProperties& properties);
-
-    BoxEntityItem(const EntityItemID& entityItemID);
-    
-    ALLOW_INSTANTIATION // This class can be instantiated
-    
-    // methods for getting/setting all properties of an entity
-    virtual EntityItemProperties getProperties(EntityPropertyFlags desiredProperties = EntityPropertyFlags()) const;
-    virtual bool setProperties(const EntityItemProperties& properties);
-
-    // TODO: eventually only include properties changed since the params.lastViewFrustumSent time
-    virtual EntityPropertyFlags getEntityProperties(EncodeBitstreamParams& params) const;
-
-    virtual void appendSubclassData(OctreePacketData* packetData, EncodeBitstreamParams& params, 
-                                    EntityTreeElementExtraEncodeData* modelTreeElementExtraEncodeData,
-                                    EntityPropertyFlags& requestedProperties,
-                                    EntityPropertyFlags& propertyFlags,
-                                    EntityPropertyFlags& propertiesDidntFit,
-                                    int& propertyCount, 
-                                    OctreeElement::AppendState& appendState) const;
-
-    virtual int readEntitySubclassDataFromBuffer(const unsigned char* data, int bytesLeftToRead, 
-                                                ReadBitstreamToTreeParams& args,
-                                                EntityPropertyFlags& propertyFlags, bool overwriteLocalData, 
-                                                bool& somethingChanged);
-
-    const rgbColor& getColor() const { return _color; }
-    xColor getXColor() const { xColor color = { _color[RED_INDEX], _color[GREEN_INDEX], _color[BLUE_INDEX] }; return color; }
-
-    void setColor(const rgbColor& value) { memcpy(_color, value, sizeof(_color)); }
-    void setColor(const xColor& value) {
-        _color[RED_INDEX] = value.red;
-        _color[GREEN_INDEX] = value.green;
-        _color[BLUE_INDEX] = value.blue;
-    }
-    
-    virtual ShapeType getShapeType() const { return SHAPE_TYPE_BOX; }
-    virtual bool shouldBePhysical() const { return !isDead(); }
-
-    virtual void debugDump() const;
-
-protected:
-    rgbColor _color;
-};
-
-#endif // hifi_BoxEntityItem_h
diff --git a/libraries/entities/src/EntityItemProperties.cpp b/libraries/entities/src/EntityItemProperties.cpp
index 99285b4986..f273507d0d 100644
--- a/libraries/entities/src/EntityItemProperties.cpp
+++ b/libraries/entities/src/EntityItemProperties.cpp
@@ -689,6 +689,7 @@ void EntityItemProperties::copyFromScriptValue(const QScriptValue& object, bool
     COPY_PROPERTY_FROM_QSCRIPTVALUE(jointRotations, qVectorQuat, setJointRotations);
     COPY_PROPERTY_FROM_QSCRIPTVALUE(jointTranslationsSet, qVectorBool, setJointTranslationsSet);
     COPY_PROPERTY_FROM_QSCRIPTVALUE(jointTranslations, qVectorVec3, setJointTranslations);
+    COPY_PROPERTY_FROM_QSCRIPTVALUE(shape, QString, setShape);
 
     COPY_PROPERTY_FROM_QSCRIPTVALUE(flyingAllowed, bool, setFlyingAllowed);
     COPY_PROPERTY_FROM_QSCRIPTVALUE(ghostingAllowed, bool, setGhostingAllowed);
@@ -846,6 +847,8 @@ void EntityItemProperties::entityPropertyFlagsFromScriptValue(const QScriptValue
         ADD_PROPERTY_TO_MAP(PROP_JOINT_TRANSLATIONS_SET, JointTranslationsSet, jointTranslationsSet, QVector<bool>);
         ADD_PROPERTY_TO_MAP(PROP_JOINT_TRANSLATIONS, JointTranslations, jointTranslations, QVector<glm::vec3>);
 
+        ADD_PROPERTY_TO_MAP(PROP_SHAPE, Shape, shape, QString);
+
         ADD_GROUP_PROPERTY_TO_MAP(PROP_ANIMATION_URL, Animation, animation, URL, url);
         ADD_GROUP_PROPERTY_TO_MAP(PROP_ANIMATION_FPS, Animation, animation, FPS, fps);
         ADD_GROUP_PROPERTY_TO_MAP(PROP_ANIMATION_FRAME_INDEX, Animation, animation, CurrentFrame, currentFrame);
@@ -1141,7 +1144,9 @@ bool EntityItemProperties::encodeEntityEditPacket(PacketType command, EntityItem
                 APPEND_ENTITY_PROPERTY(PROP_STROKE_WIDTHS, properties.getStrokeWidths());
                 APPEND_ENTITY_PROPERTY(PROP_TEXTURES, properties.getTextures());
             }
-
+            if (properties.getType() == EntityTypes::Shape) {
+                APPEND_ENTITY_PROPERTY(PROP_SHAPE, properties.getShape());
+            }
             APPEND_ENTITY_PROPERTY(PROP_MARKETPLACE_ID, properties.getMarketplaceID());
             APPEND_ENTITY_PROPERTY(PROP_NAME, properties.getName());
             APPEND_ENTITY_PROPERTY(PROP_COLLISION_SOUND_URL, properties.getCollisionSoundURL());
@@ -1429,6 +1434,9 @@ bool EntityItemProperties::decodeEntityEditPacket(const unsigned char* data, int
         READ_ENTITY_PROPERTY_TO_PROPERTIES(PROP_STROKE_WIDTHS, QVector<float>, setStrokeWidths);
         READ_ENTITY_PROPERTY_TO_PROPERTIES(PROP_TEXTURES, QString, setTextures);
     }
+    if (properties.getType() == EntityTypes::Shape) {
+        READ_ENTITY_PROPERTY_TO_PROPERTIES(PROP_SHAPE, QString, setShape);
+    }
 
     READ_ENTITY_PROPERTY_TO_PROPERTIES(PROP_MARKETPLACE_ID, QString, setMarketplaceID);
     READ_ENTITY_PROPERTY_TO_PROPERTIES(PROP_NAME, QString, setName);
@@ -1915,6 +1923,7 @@ QList<QString> EntityItemProperties::listChangedProperties() {
     if (queryAACubeChanged()) {
         out += "queryAACube";
     }
+
     if (clientOnlyChanged()) {
         out += "clientOnly";
     }
@@ -1929,6 +1938,10 @@ QList<QString> EntityItemProperties::listChangedProperties() {
         out += "ghostingAllowed";
     }
 
+    if (shapeChanged()) {
+        out += "shape";
+    }
+
     getAnimation().listChangedProperties(out);
     getKeyLight().listChangedProperties(out);
     getSkybox().listChangedProperties(out);
diff --git a/libraries/entities/src/EntityItemProperties.h b/libraries/entities/src/EntityItemProperties.h
index 59749cfef5..6018ba793f 100644
--- a/libraries/entities/src/EntityItemProperties.h
+++ b/libraries/entities/src/EntityItemProperties.h
@@ -50,7 +50,7 @@ const quint64 UNKNOWN_CREATED_TIME = 0;
 /// A collection of properties of an entity item used in the scripting API. Translates between the actual properties of an
 /// entity and a JavaScript style hash/QScriptValue storing a set of properties. Used in scripting to set/get the complete
 /// set of entity item properties via JavaScript hashes/QScriptValues
-/// all units for position, dimensions, etc are in meter units
+/// all units for SI units (meter, second, radian, etc) 
 class EntityItemProperties {
     friend class EntityItem; // TODO: consider removing this friend relationship and use public methods
     friend class ModelEntityItem; // TODO: consider removing this friend relationship and use public methods
@@ -64,6 +64,7 @@ class EntityItemProperties {
     friend class LineEntityItem; // TODO: consider removing this friend relationship and use public methods
     friend class PolyVoxEntityItem; // TODO: consider removing this friend relationship and use public methods
     friend class PolyLineEntityItem; // TODO: consider removing this friend relationship and use public methods
+    friend class ShapeEntityItem; // TODO: consider removing this friend relationship and use public methods
 public:
     EntityItemProperties(EntityPropertyFlags desiredProperties = EntityPropertyFlags());
     virtual ~EntityItemProperties() = default;
@@ -195,6 +196,7 @@ public:
     DEFINE_PROPERTY_REF(PROP_PARENT_ID, ParentID, parentID, QUuid, UNKNOWN_ENTITY_ID);
     DEFINE_PROPERTY_REF(PROP_PARENT_JOINT_INDEX, ParentJointIndex, parentJointIndex, quint16, -1);
     DEFINE_PROPERTY_REF(PROP_QUERY_AA_CUBE, QueryAACube, queryAACube, AACube, AACube());
+    DEFINE_PROPERTY_REF(PROP_SHAPE, Shape, shape, QString, "Sphere");
 
     // these are used when bouncing location data into and out of scripts
     DEFINE_PROPERTY_REF(PROP_LOCAL_POSITION, LocalPosition, localPosition, glmVec3, ENTITY_ITEM_ZERO_VEC3);
diff --git a/libraries/entities/src/EntityPropertyFlags.h b/libraries/entities/src/EntityPropertyFlags.h
index 20c451eaae..36bb37c8f3 100644
--- a/libraries/entities/src/EntityPropertyFlags.h
+++ b/libraries/entities/src/EntityPropertyFlags.h
@@ -175,6 +175,8 @@ enum EntityPropertyList {
     PROP_CLIENT_ONLY, // doesn't go over wire
     PROP_OWNING_AVATAR_ID, // doesn't go over wire
 
+    PROP_SHAPE,
+
     ////////////////////////////////////////////////////////////////////////////////////////////////////
     // ATTENTION: add new properties to end of list just ABOVE this line
     PROP_AFTER_LAST_ITEM,
diff --git a/libraries/entities/src/EntityTypes.cpp b/libraries/entities/src/EntityTypes.cpp
index 52c2242629..7b1133c2aa 100644
--- a/libraries/entities/src/EntityTypes.cpp
+++ b/libraries/entities/src/EntityTypes.cpp
@@ -18,17 +18,16 @@
 #include "EntityItemProperties.h"
 #include "EntityTypes.h"
 
-#include "BoxEntityItem.h"
 #include "LightEntityItem.h"
 #include "ModelEntityItem.h"
 #include "ParticleEffectEntityItem.h"
-#include "SphereEntityItem.h"
 #include "TextEntityItem.h"
 #include "WebEntityItem.h"
 #include "ZoneEntityItem.h"
 #include "LineEntityItem.h"
 #include "PolyVoxEntityItem.h"
 #include "PolyLineEntityItem.h"
+#include "ShapeEntityItem.h"
 
 QMap<EntityTypes::EntityType, QString> EntityTypes::_typeToNameMap;
 QMap<QString, EntityTypes::EntityType> EntityTypes::_nameToTypeMap;
@@ -39,16 +38,17 @@ const QString ENTITY_TYPE_NAME_UNKNOWN = "Unknown";
 
 // Register Entity the default implementations of entity types here...
 REGISTER_ENTITY_TYPE(Model)
-REGISTER_ENTITY_TYPE(Box)
 REGISTER_ENTITY_TYPE(Web)
-REGISTER_ENTITY_TYPE(Sphere)
 REGISTER_ENTITY_TYPE(Light)
 REGISTER_ENTITY_TYPE(Text)
 REGISTER_ENTITY_TYPE(ParticleEffect)
 REGISTER_ENTITY_TYPE(Zone)
 REGISTER_ENTITY_TYPE(Line)
 REGISTER_ENTITY_TYPE(PolyVox)
-REGISTER_ENTITY_TYPE(PolyLine);
+REGISTER_ENTITY_TYPE(PolyLine)
+REGISTER_ENTITY_TYPE(Shape)
+REGISTER_ENTITY_TYPE_WITH_FACTORY(Box, ShapeEntityItem::boxFactory)
+REGISTER_ENTITY_TYPE_WITH_FACTORY(Sphere, ShapeEntityItem::sphereFactory)
 
 const QString& EntityTypes::getEntityTypeName(EntityType entityType) {
     QMap<EntityType, QString>::iterator matchedTypeName = _typeToNameMap.find(entityType);
diff --git a/libraries/entities/src/EntityTypes.h b/libraries/entities/src/EntityTypes.h
index 3536327d18..be3be03713 100644
--- a/libraries/entities/src/EntityTypes.h
+++ b/libraries/entities/src/EntityTypes.h
@@ -48,7 +48,8 @@ public:
         Line,
         PolyVox,
         PolyLine,
-        LAST = PolyLine
+        Shape,
+        LAST = Shape
     } EntityType;
 
     static const QString& getEntityTypeName(EntityType entityType);
@@ -72,6 +73,15 @@ private:
 #define REGISTER_ENTITY_TYPE(x) static bool x##Registration = \
             EntityTypes::registerEntityType(EntityTypes::x, #x, x##EntityItem::factory);
 
+
+struct EntityRegistrationChecker {
+    EntityRegistrationChecker(bool result, const char* debugMessage) {
+        if (!result) {
+            qDebug() << debugMessage;
+        }
+    }
+};
+
 /// Macro for registering entity types with an overloaded factory. Like using the REGISTER_ENTITY_TYPE macro: Make sure to add
 /// an element to the EntityType enum with your name. But unlike  REGISTER_ENTITY_TYPE, your class can be named anything
 /// so long as you provide a static method passed to the macro, that takes an EnityItemID, and EntityItemProperties and 
@@ -79,9 +89,9 @@ private:
 //        static EntityItemPointer factory(const EntityItemID& entityID, const EntityItemProperties& properties);
 #define REGISTER_ENTITY_TYPE_WITH_FACTORY(x,y) static bool x##Registration = \
             EntityTypes::registerEntityType(EntityTypes::x, #x, y); \
-            if (!x##Registration) { \
-                qDebug() << "UNEXPECTED: REGISTER_ENTITY_TYPE_WITH_FACTORY(" #x "," #y ") FAILED.!"; \
-            }
+            EntityRegistrationChecker x##RegistrationChecker( \
+                x##Registration, \
+                "UNEXPECTED: REGISTER_ENTITY_TYPE_WITH_FACTORY(" #x "," #y ") FAILED.!");
 
 
 #endif // hifi_EntityTypes_h
diff --git a/libraries/entities/src/ShapeEntityItem.cpp b/libraries/entities/src/ShapeEntityItem.cpp
new file mode 100644
index 0000000000..a24c7e1df5
--- /dev/null
+++ b/libraries/entities/src/ShapeEntityItem.cpp
@@ -0,0 +1,230 @@
+//
+//  Created by Bradley Austin Davis on 2016/05/09
+//  Copyright 2013 High Fidelity, Inc.
+//
+//  Distributed under the Apache License, Version 2.0.
+//  See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html
+//
+
+
+#include <glm/gtx/transform.hpp>
+
+#include <QtCore/QDebug>
+
+#include <GeometryUtil.h>
+
+#include "EntitiesLogging.h"
+#include "EntityItemProperties.h"
+#include "EntityTree.h"
+#include "EntityTreeElement.h"
+#include "ShapeEntityItem.h"
+
+namespace entity {
+    static const std::vector<QString> shapeStrings { { 
+        "Triangle", 
+        "Quad", 
+        "Circle", 
+        "Cube", 
+        "Sphere", 
+        "Tetrahedron", 
+        "Octahetron", 
+        "Dodecahedron", 
+        "Icosahedron", 
+        "Torus", 
+        "Cone", 
+        "Cylinder" 
+    } };
+
+    Shape shapeFromString(const ::QString& shapeString) {
+        for (size_t i = 0; i < shapeStrings.size(); ++i) {
+            if (shapeString.toLower() == shapeStrings[i].toLower()) {
+                return static_cast<Shape>(i);
+            }
+        }
+        return Shape::Sphere;
+    }
+
+    ::QString stringFromShape(Shape shape) {
+        return shapeStrings[shape];
+    }
+}
+
+ShapeEntityItem::Pointer ShapeEntityItem::baseFactory(const EntityItemID& entityID, const EntityItemProperties& properties) {
+    Pointer entity { new ShapeEntityItem(entityID) };
+    entity->setProperties(properties);
+    return entity;
+}
+
+EntityItemPointer ShapeEntityItem::factory(const EntityItemID& entityID, const EntityItemProperties& properties) {
+    return baseFactory(entityID, properties);
+}
+
+EntityItemPointer ShapeEntityItem::boxFactory(const EntityItemID& entityID, const EntityItemProperties& properties) {
+    auto result = baseFactory(entityID, properties);
+    result->setShape(entity::Shape::Cube);
+    return result;
+}
+
+EntityItemPointer ShapeEntityItem::sphereFactory(const EntityItemID& entityID, const EntityItemProperties& properties) {
+    auto result = baseFactory(entityID, properties);
+    result->setShape(entity::Shape::Sphere);
+    return result;
+}
+
+// our non-pure virtual subclass for now...
+ShapeEntityItem::ShapeEntityItem(const EntityItemID& entityItemID) : EntityItem(entityItemID) {
+    _type = EntityTypes::Shape;
+    _volumeMultiplier *= PI / 6.0f;
+}
+
+EntityItemProperties ShapeEntityItem::getProperties(EntityPropertyFlags desiredProperties) const {
+    EntityItemProperties properties = EntityItem::getProperties(desiredProperties); // get the properties from our base class
+    properties.setColor(getXColor());
+    properties.setShape(entity::stringFromShape(getShape()));
+    return properties;
+}
+
+void ShapeEntityItem::setShape(const entity::Shape& shape) {
+    _shape = shape;
+    switch (_shape) {
+        case entity::Shape::Cube:
+            _type = EntityTypes::Box;
+            break;
+        case entity::Shape::Sphere:
+            _type = EntityTypes::Sphere;
+            break;
+        default:
+            _type = EntityTypes::Shape;
+            break;
+    }
+}
+
+bool ShapeEntityItem::setProperties(const EntityItemProperties& properties) {
+    bool somethingChanged = EntityItem::setProperties(properties); // set the properties in our base class
+
+    SET_ENTITY_PROPERTY_FROM_PROPERTIES(alpha, setAlpha);
+    SET_ENTITY_PROPERTY_FROM_PROPERTIES(color, setColor);
+    SET_ENTITY_PROPERTY_FROM_PROPERTIES(shape, setShape);
+
+    if (somethingChanged) {
+        bool wantDebug = false;
+        if (wantDebug) {
+            uint64_t now = usecTimestampNow();
+            int elapsed = now - getLastEdited();
+            qCDebug(entities) << "ShapeEntityItem::setProperties() AFTER update... edited AGO=" << elapsed <<
+                    "now=" << now << " getLastEdited()=" << getLastEdited();
+        }
+        setLastEdited(properties.getLastEdited());
+    }
+    return somethingChanged;
+}
+
+int ShapeEntityItem::readEntitySubclassDataFromBuffer(const unsigned char* data, int bytesLeftToRead,
+                                                ReadBitstreamToTreeParams& args,
+                                                EntityPropertyFlags& propertyFlags, bool overwriteLocalData,
+                                                bool& somethingChanged) {
+
+    int bytesRead = 0;
+    const unsigned char* dataAt = data;
+
+    READ_ENTITY_PROPERTY(PROP_SHAPE, QString, setShape);
+    READ_ENTITY_PROPERTY(PROP_COLOR, rgbColor, setColor);
+    READ_ENTITY_PROPERTY(PROP_ALPHA, float, setAlpha);
+
+    return bytesRead;
+}
+
+
+// TODO: eventually only include properties changed since the params.lastViewFrustumSent time
+EntityPropertyFlags ShapeEntityItem::getEntityProperties(EncodeBitstreamParams& params) const {
+    EntityPropertyFlags requestedProperties = EntityItem::getEntityProperties(params);
+    requestedProperties += PROP_SHAPE;
+    requestedProperties += PROP_COLOR;
+    requestedProperties += PROP_ALPHA;
+    return requestedProperties;
+}
+
+void ShapeEntityItem::appendSubclassData(OctreePacketData* packetData, EncodeBitstreamParams& params,
+                                    EntityTreeElementExtraEncodeData* modelTreeElementExtraEncodeData,
+                                    EntityPropertyFlags& requestedProperties,
+                                    EntityPropertyFlags& propertyFlags,
+                                    EntityPropertyFlags& propertiesDidntFit,
+                                    int& propertyCount, 
+                                    OctreeElement::AppendState& appendState) const { 
+
+    bool successPropertyFits = true;
+    APPEND_ENTITY_PROPERTY(PROP_SHAPE, entity::stringFromShape(getShape()));
+    APPEND_ENTITY_PROPERTY(PROP_COLOR, getColor());
+    APPEND_ENTITY_PROPERTY(PROP_COLOR, getAlpha());
+}
+
+// This value specifes how the shape should be treated by physics calculations.  
+// For now, all polys will act as spheres
+ShapeType ShapeEntityItem::getShapeType() const {
+    return SHAPE_TYPE_ELLIPSOID;
+}
+
+void ShapeEntityItem::setColor(const rgbColor& value) {
+    memcpy(_color, value, sizeof(rgbColor));
+}
+
+xColor ShapeEntityItem::getXColor() const {
+    return xColor { _color[0], _color[1], _color[2] };
+}
+
+void ShapeEntityItem::setColor(const xColor& value) {
+    setColor(rgbColor { value.red, value.green, value.blue });
+}
+
+QColor ShapeEntityItem::getQColor() const {
+    auto& color = getColor();
+    return QColor(color[0], color[1], color[2], (int)(getAlpha() * 255));
+}
+
+void ShapeEntityItem::setColor(const QColor& value) {
+    setColor(rgbColor { (uint8_t)value.red(), (uint8_t)value.green(), (uint8_t)value.blue() });
+    setAlpha(value.alpha());
+}
+
+bool ShapeEntityItem::supportsDetailedRayIntersection() const {
+    return _shape == entity::Sphere;
+}
+
+bool ShapeEntityItem::findDetailedRayIntersection(const glm::vec3& origin, const glm::vec3& direction,
+                                                   bool& keepSearching, OctreeElementPointer& element,
+                                                   float& distance, BoxFace& face, glm::vec3& surfaceNormal,
+                                                   void** intersectedObject, bool precisionPicking) const {
+    // determine the ray in the frame of the entity transformed from a unit sphere
+    glm::mat4 entityToWorldMatrix = getEntityToWorldMatrix();
+    glm::mat4 worldToEntityMatrix = glm::inverse(entityToWorldMatrix);
+    glm::vec3 entityFrameOrigin = glm::vec3(worldToEntityMatrix * glm::vec4(origin, 1.0f));
+    glm::vec3 entityFrameDirection = glm::normalize(glm::vec3(worldToEntityMatrix * glm::vec4(direction, 0.0f)));
+
+    float localDistance;
+    // NOTE: unit sphere has center of 0,0,0 and radius of 0.5
+    if (findRaySphereIntersection(entityFrameOrigin, entityFrameDirection, glm::vec3(0.0f), 0.5f, localDistance)) {
+        // determine where on the unit sphere the hit point occured
+        glm::vec3 entityFrameHitAt = entityFrameOrigin + (entityFrameDirection * localDistance);
+        // then translate back to work coordinates
+        glm::vec3 hitAt = glm::vec3(entityToWorldMatrix * glm::vec4(entityFrameHitAt, 1.0f));
+        distance = glm::distance(origin, hitAt);
+        bool success;
+        surfaceNormal = glm::normalize(hitAt - getCenterPosition(success));
+        if (!success) {
+            return false;
+        }
+        return true;
+    }
+    return false;
+}
+
+void ShapeEntityItem::debugDump() const {
+    quint64 now = usecTimestampNow();
+    qCDebug(entities) << "SHAPE EntityItem id:" << getEntityItemID() << "---------------------------------------------";
+    qCDebug(entities) << "              shape:" << stringFromShape(_shape);
+    qCDebug(entities) << "              color:" << _color[0] << "," << _color[1] << "," << _color[2];
+    qCDebug(entities) << "           position:" << debugTreeVector(getPosition());
+    qCDebug(entities) << "         dimensions:" << debugTreeVector(getDimensions());
+    qCDebug(entities) << "      getLastEdited:" << debugTime(getLastEdited(), now);
+}
+
diff --git a/libraries/entities/src/ShapeEntityItem.h b/libraries/entities/src/ShapeEntityItem.h
new file mode 100644
index 0000000000..f3cb2abd66
--- /dev/null
+++ b/libraries/entities/src/ShapeEntityItem.h
@@ -0,0 +1,103 @@
+//
+//  Created by Bradley Austin Davis on 2016/05/09
+//  Copyright 2013 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_ShapeEntityItem_h
+#define hifi_ShapeEntityItem_h
+
+#include "EntityItem.h"
+
+namespace entity {
+    enum Shape {
+        Triangle,
+        Quad,
+        Circle,
+        Cube,
+        Sphere,
+        Tetrahedron,
+        Octahetron,
+        Dodecahedron,
+        Icosahedron,
+        Torus,
+        Cone,
+        Cylinder,
+        NUM_SHAPES,
+    };
+
+    Shape shapeFromString(const ::QString& shapeString);
+    ::QString stringFromShape(Shape shape);
+}
+
+
+class ShapeEntityItem : public EntityItem {
+    using Pointer = std::shared_ptr<ShapeEntityItem>;
+    static Pointer baseFactory(const EntityItemID& entityID, const EntityItemProperties& properties);
+public:
+    static EntityItemPointer factory(const EntityItemID& entityID, const EntityItemProperties& properties);
+    static EntityItemPointer sphereFactory(const EntityItemID& entityID, const EntityItemProperties& properties);
+    static EntityItemPointer boxFactory(const EntityItemID& entityID, const EntityItemProperties& properties);
+
+    ShapeEntityItem(const EntityItemID& entityItemID);
+
+    void pureVirtualFunctionPlaceHolder() override { };
+    // Triggers warnings on OSX
+    //ALLOW_INSTANTIATION 
+    
+    // methods for getting/setting all properties of an entity
+    EntityItemProperties getProperties(EntityPropertyFlags desiredProperties = EntityPropertyFlags()) const override;
+    bool setProperties(const EntityItemProperties& properties) override;
+
+    EntityPropertyFlags getEntityProperties(EncodeBitstreamParams& params) const override;
+
+    void appendSubclassData(OctreePacketData* packetData, EncodeBitstreamParams& params,
+                                    EntityTreeElementExtraEncodeData* modelTreeElementExtraEncodeData,
+                                    EntityPropertyFlags& requestedProperties,
+                                    EntityPropertyFlags& propertyFlags,
+                                    EntityPropertyFlags& propertiesDidntFit,
+                                    int& propertyCount, 
+                                    OctreeElement::AppendState& appendState) const override;
+
+    int readEntitySubclassDataFromBuffer(const unsigned char* data, int bytesLeftToRead,
+                                                ReadBitstreamToTreeParams& args,
+                                                EntityPropertyFlags& propertyFlags, bool overwriteLocalData,
+                                                bool& somethingChanged) override;
+
+    entity::Shape getShape() const { return _shape; }
+    void setShape(const entity::Shape& shape);
+    void setShape(const QString& shape) { setShape(entity::shapeFromString(shape)); }
+
+    float getAlpha() const { return _alpha; };
+    void setAlpha(float alpha) { _alpha = alpha; }
+
+    const rgbColor& getColor() const { return _color; }
+    void setColor(const rgbColor& value);
+
+    xColor getXColor() const;
+    void setColor(const xColor& value);
+
+    QColor getQColor() const;
+    void setColor(const QColor& value);
+
+    ShapeType getShapeType() const override;
+    bool shouldBePhysical() const override { return !isDead(); }
+    
+    bool supportsDetailedRayIntersection() const override;
+    bool findDetailedRayIntersection(const glm::vec3& origin, const glm::vec3& direction,
+                                                bool& keepSearching, OctreeElementPointer& element, float& distance,
+                                                BoxFace& face, glm::vec3& surfaceNormal,
+                                                void** intersectedObject, bool precisionPicking) const override;
+
+    void debugDump() const override;
+
+protected:
+
+    float _alpha { 1 };
+    rgbColor _color;
+    entity::Shape _shape { entity::Shape::Sphere };
+};
+
+#endif // hifi_ShapeEntityItem_h
diff --git a/libraries/entities/src/SphereEntityItem.cpp b/libraries/entities/src/SphereEntityItem.cpp
deleted file mode 100644
index 7ad7b39f20..0000000000
--- a/libraries/entities/src/SphereEntityItem.cpp
+++ /dev/null
@@ -1,132 +0,0 @@
-//
-//  SphereEntityItem.cpp
-//  libraries/entities/src
-//
-//  Created by Brad Hefta-Gaub on 12/4/13.
-//  Copyright 2013 High Fidelity, Inc.
-//
-//  Distributed under the Apache License, Version 2.0.
-//  See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html
-//
-
-
-#include <glm/gtx/transform.hpp>
-
-#include <QDebug>
-
-#include <ByteCountCoding.h>
-#include <GeometryUtil.h>
-
-#include "EntitiesLogging.h"
-#include "EntityItemProperties.h"
-#include "EntityTree.h"
-#include "EntityTreeElement.h"
-#include "SphereEntityItem.h"
-
-EntityItemPointer SphereEntityItem::factory(const EntityItemID& entityID, const EntityItemProperties& properties) {
-    EntityItemPointer entity { new SphereEntityItem(entityID) };
-    entity->setProperties(properties);
-    return entity;
-}
-
-// our non-pure virtual subclass for now...
-SphereEntityItem::SphereEntityItem(const EntityItemID& entityItemID) : EntityItem(entityItemID) {
-    _type = EntityTypes::Sphere;
-    _volumeMultiplier *= PI / 6.0f;
-}
-
-EntityItemProperties SphereEntityItem::getProperties(EntityPropertyFlags desiredProperties) const {
-    EntityItemProperties properties = EntityItem::getProperties(desiredProperties); // get the properties from our base class
-    properties.setColor(getXColor());
-    return properties;
-}
-
-bool SphereEntityItem::setProperties(const EntityItemProperties& properties) {
-    bool somethingChanged = EntityItem::setProperties(properties); // set the properties in our base class
-
-    SET_ENTITY_PROPERTY_FROM_PROPERTIES(color, setColor);
-
-    if (somethingChanged) {
-        bool wantDebug = false;
-        if (wantDebug) {
-            uint64_t now = usecTimestampNow();
-            int elapsed = now - getLastEdited();
-            qCDebug(entities) << "SphereEntityItem::setProperties() AFTER update... edited AGO=" << elapsed <<
-                    "now=" << now << " getLastEdited()=" << getLastEdited();
-        }
-        setLastEdited(properties.getLastEdited());
-    }
-    return somethingChanged;
-}
-
-int SphereEntityItem::readEntitySubclassDataFromBuffer(const unsigned char* data, int bytesLeftToRead, 
-                                                ReadBitstreamToTreeParams& args,
-                                                EntityPropertyFlags& propertyFlags, bool overwriteLocalData,
-                                                bool& somethingChanged) {
-
-    int bytesRead = 0;
-    const unsigned char* dataAt = data;
-
-    READ_ENTITY_PROPERTY(PROP_COLOR, rgbColor, setColor);
-
-    return bytesRead;
-}
-
-
-// TODO: eventually only include properties changed since the params.lastViewFrustumSent time
-EntityPropertyFlags SphereEntityItem::getEntityProperties(EncodeBitstreamParams& params) const {
-    EntityPropertyFlags requestedProperties = EntityItem::getEntityProperties(params);
-    requestedProperties += PROP_COLOR;
-    return requestedProperties;
-}
-
-void SphereEntityItem::appendSubclassData(OctreePacketData* packetData, EncodeBitstreamParams& params, 
-                                    EntityTreeElementExtraEncodeData* modelTreeElementExtraEncodeData,
-                                    EntityPropertyFlags& requestedProperties,
-                                    EntityPropertyFlags& propertyFlags,
-                                    EntityPropertyFlags& propertiesDidntFit,
-                                    int& propertyCount, 
-                                    OctreeElement::AppendState& appendState) const { 
-
-    bool successPropertyFits = true;
-    APPEND_ENTITY_PROPERTY(PROP_COLOR, getColor());
-}
-
-bool SphereEntityItem::findDetailedRayIntersection(const glm::vec3& origin, const glm::vec3& direction,
-                                                   bool& keepSearching, OctreeElementPointer& element,
-                                                   float& distance, BoxFace& face, glm::vec3& surfaceNormal,
-                                                   void** intersectedObject, bool precisionPicking) const {
-    // determine the ray in the frame of the entity transformed from a unit sphere
-    glm::mat4 entityToWorldMatrix = getEntityToWorldMatrix();
-    glm::mat4 worldToEntityMatrix = glm::inverse(entityToWorldMatrix);
-    glm::vec3 entityFrameOrigin = glm::vec3(worldToEntityMatrix * glm::vec4(origin, 1.0f));
-    glm::vec3 entityFrameDirection = glm::normalize(glm::vec3(worldToEntityMatrix * glm::vec4(direction, 0.0f)));
-
-    float localDistance;
-    // NOTE: unit sphere has center of 0,0,0 and radius of 0.5
-    if (findRaySphereIntersection(entityFrameOrigin, entityFrameDirection, glm::vec3(0.0f), 0.5f, localDistance)) {
-        // determine where on the unit sphere the hit point occured
-        glm::vec3 entityFrameHitAt = entityFrameOrigin + (entityFrameDirection * localDistance);
-        // then translate back to work coordinates
-        glm::vec3 hitAt = glm::vec3(entityToWorldMatrix * glm::vec4(entityFrameHitAt, 1.0f));
-        distance = glm::distance(origin, hitAt);
-        bool success;
-        surfaceNormal = glm::normalize(hitAt - getCenterPosition(success));
-        if (!success) {
-            return false;
-        }
-        return true;
-    }
-    return false;
-}
-
-
-void SphereEntityItem::debugDump() const {
-    quint64 now = usecTimestampNow();
-    qCDebug(entities) << "SHPERE EntityItem id:" << getEntityItemID() << "---------------------------------------------";
-    qCDebug(entities) << "               color:" << _color[0] << "," << _color[1] << "," << _color[2];
-    qCDebug(entities) << "            position:" << debugTreeVector(getPosition());
-    qCDebug(entities) << "          dimensions:" << debugTreeVector(getDimensions());
-    qCDebug(entities) << "       getLastEdited:" << debugTime(getLastEdited(), now);
-}
-
diff --git a/libraries/entities/src/SphereEntityItem.h b/libraries/entities/src/SphereEntityItem.h
deleted file mode 100644
index fda5eab009..0000000000
--- a/libraries/entities/src/SphereEntityItem.h
+++ /dev/null
@@ -1,70 +0,0 @@
-//
-//  SphereEntityItem.h
-//  libraries/entities/src
-//
-//  Created by Brad Hefta-Gaub on 12/4/13.
-//  Copyright 2013 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_SphereEntityItem_h
-#define hifi_SphereEntityItem_h
-
-#include "EntityItem.h"
-
-class SphereEntityItem : public EntityItem {
-public:
-    static EntityItemPointer factory(const EntityItemID& entityID, const EntityItemProperties& properties);
-
-    SphereEntityItem(const EntityItemID& entityItemID);
-    
-    ALLOW_INSTANTIATION // This class can be instantiated
-    
-    // methods for getting/setting all properties of an entity
-    virtual EntityItemProperties getProperties(EntityPropertyFlags desiredProperties = EntityPropertyFlags()) const;
-    virtual bool setProperties(const EntityItemProperties& properties);
-
-    virtual EntityPropertyFlags getEntityProperties(EncodeBitstreamParams& params) const;
-
-    virtual void appendSubclassData(OctreePacketData* packetData, EncodeBitstreamParams& params, 
-                                    EntityTreeElementExtraEncodeData* modelTreeElementExtraEncodeData,
-                                    EntityPropertyFlags& requestedProperties,
-                                    EntityPropertyFlags& propertyFlags,
-                                    EntityPropertyFlags& propertiesDidntFit,
-                                    int& propertyCount, 
-                                    OctreeElement::AppendState& appendState) const;
-
-    virtual int readEntitySubclassDataFromBuffer(const unsigned char* data, int bytesLeftToRead, 
-                                                ReadBitstreamToTreeParams& args,
-                                                EntityPropertyFlags& propertyFlags, bool overwriteLocalData,
-                                                bool& somethingChanged);
-
-    const rgbColor& getColor() const { return _color; }
-    xColor getXColor() const { xColor color = { _color[RED_INDEX], _color[GREEN_INDEX], _color[BLUE_INDEX] }; return color; }
-
-    void setColor(const rgbColor& value) { memcpy(_color, value, sizeof(_color)); }
-    void setColor(const xColor& value) {
-            _color[RED_INDEX] = value.red;
-            _color[GREEN_INDEX] = value.green;
-            _color[BLUE_INDEX] = value.blue;
-    }
-
-    virtual ShapeType getShapeType() const { return SHAPE_TYPE_SPHERE; }
-    virtual bool shouldBePhysical() const { return !isDead(); }
-    
-    virtual bool supportsDetailedRayIntersection() const { return true; }
-    virtual bool findDetailedRayIntersection(const glm::vec3& origin, const glm::vec3& direction,
-                                                bool& keepSearching, OctreeElementPointer& element, float& distance,
-                                                BoxFace& face, glm::vec3& surfaceNormal,
-                                                void** intersectedObject, bool precisionPicking) const;
-
-    virtual void debugDump() const;
-
-protected:
-
-    rgbColor _color;
-};
-
-#endif // hifi_SphereEntityItem_h
diff --git a/libraries/render-utils/src/GeometryCache.cpp b/libraries/render-utils/src/GeometryCache.cpp
index 15bf44744c..6852d17882 100644
--- a/libraries/render-utils/src/GeometryCache.cpp
+++ b/libraries/render-utils/src/GeometryCache.cpp
@@ -112,10 +112,12 @@ void GeometryCache::ShapeData::drawWireInstances(gpu::Batch& batch, size_t count
     }
 }
 
+// The golden ratio
+static const float PHI = 1.61803398874f;
+
 const VertexVector& icosahedronVertices() {
-    static const float phi = (1.0f + sqrtf(5.0f)) / 2.0f;
-    static const float a = 0.5f;
-    static const float b = 1.0f / (2.0f * phi);
+    static const float a = 1;
+    static const float b = PHI / 2.0f;
 
     static const VertexVector vertices{ //
         vec3(0, b, -a), vec3(-b, a, 0), vec3(b, a, 0), // 
@@ -143,11 +145,10 @@ const VertexVector& icosahedronVertices() {
 }
 
 const VertexVector& tetrahedronVertices() {
-    static const float a = 1.0f / sqrtf(2.0f);
-    static const auto A = vec3(0, 1, a);
-    static const auto B = vec3(0, -1, a);
-    static const auto C = vec3(1, 0, -a);
-    static const auto D = vec3(-1, 0, -a);
+    static const auto A = vec3(1, 1, 1);
+    static const auto B = vec3(1, -1, -1);
+    static const auto C = vec3(-1, 1, -1);
+    static const auto D = vec3(-1, -1, 1);
     static const VertexVector vertices{
         A, B, C,
         D, B, A,
@@ -356,7 +357,7 @@ void GeometryCache::buildShapes() {
                 for (size_t j = 0; j < VERTICES_PER_TRIANGLE; ++j) {
                     auto triangleVertexIndex = j;
                     auto vertexIndex = triangleStartIndex + triangleVertexIndex;
-                    vertices.push_back(glm::normalize(originalVertices[vertexIndex]));
+                    vertices.push_back(originalVertices[vertexIndex]);
                     vertices.push_back(faceNormal);
                 }
             }
@@ -437,7 +438,7 @@ void GeometryCache::buildShapes() {
                 for (int j = 0; j < VERTICES_PER_TRIANGLE; ++j) {
                     auto triangleVertexIndex = j;
                     auto vertexIndex = triangleStartIndex + triangleVertexIndex;
-                    vertices.push_back(glm::normalize(originalVertices[vertexIndex]));
+                    vertices.push_back(originalVertices[vertexIndex]);
                     vertices.push_back(faceNormal);
                     indices.push_back((uint16_t)(vertexIndex + startingIndex));
                 }
@@ -1801,10 +1802,10 @@ uint32_t toCompactColor(const glm::vec4& color) {
 
 static const size_t INSTANCE_COLOR_BUFFER = 0;
 
-void renderInstances(const std::string& name, gpu::Batch& batch, const glm::vec4& color, bool isWire,
+void renderInstances(gpu::Batch& batch, const glm::vec4& color, bool isWire,
                     const render::ShapePipelinePointer& pipeline, GeometryCache::Shape shape) {
     // Add pipeline to name
-    std::string instanceName = name + std::to_string(std::hash<render::ShapePipelinePointer>()(pipeline));
+    std::string instanceName = (isWire ? "wire_shapes_" : "solid_shapes_") + std::to_string(shape) + "_" + std::to_string(std::hash<render::ShapePipelinePointer>()(pipeline));
 
     // Add color to named buffer
     {
@@ -1826,14 +1827,16 @@ void renderInstances(const std::string& name, gpu::Batch& batch, const glm::vec4
     });
 }
 
+void GeometryCache::renderSolidShapeInstance(gpu::Batch& batch, GeometryCache::Shape shape, const glm::vec4& color, const render::ShapePipelinePointer& pipeline) {
+    renderInstances(batch, color, false, pipeline, shape);
+}
+
 void GeometryCache::renderSolidSphereInstance(gpu::Batch& batch, const glm::vec4& color, const render::ShapePipelinePointer& pipeline) {
-    static const std::string INSTANCE_NAME = __FUNCTION__;
-    renderInstances(INSTANCE_NAME, batch, color, false, pipeline, GeometryCache::Sphere);
+    renderInstances(batch, color, false, pipeline, GeometryCache::Sphere);
 }
 
 void GeometryCache::renderWireSphereInstance(gpu::Batch& batch, const glm::vec4& color, const render::ShapePipelinePointer& pipeline) {
-    static const std::string INSTANCE_NAME = __FUNCTION__;
-    renderInstances(INSTANCE_NAME, batch, color, true, pipeline, GeometryCache::Sphere);
+    renderInstances(batch, color, true, pipeline, GeometryCache::Sphere);
 }
 
 // Enable this in a debug build to cause 'box' entities to iterate through all the
@@ -1841,8 +1844,6 @@ void GeometryCache::renderWireSphereInstance(gpu::Batch& batch, const glm::vec4&
 //#define DEBUG_SHAPES
 
 void GeometryCache::renderSolidCubeInstance(gpu::Batch& batch, const glm::vec4& color, const render::ShapePipelinePointer& pipeline) {
-    static const std::string INSTANCE_NAME = __FUNCTION__;
-    
 #ifdef DEBUG_SHAPES
     static auto startTime = usecTimestampNow();
     renderInstances(INSTANCE_NAME, batch, color, pipeline, [](gpu::Batch& batch, gpu::Batch::NamedBatchData& data) {
@@ -1876,11 +1877,11 @@ void GeometryCache::renderSolidCubeInstance(gpu::Batch& batch, const glm::vec4&
         }
     });
 #else
-    renderInstances(INSTANCE_NAME, batch, color, false, pipeline, GeometryCache::Cube);
+    renderInstances(batch, color, false, pipeline, GeometryCache::Cube);
 #endif
 }
 
 void GeometryCache::renderWireCubeInstance(gpu::Batch& batch, const glm::vec4& color, const render::ShapePipelinePointer& pipeline) {
     static const std::string INSTANCE_NAME = __FUNCTION__;
-    renderInstances(INSTANCE_NAME, batch, color, true, pipeline, GeometryCache::Cube);
+    renderInstances(batch, color, true, pipeline, GeometryCache::Cube);
 }
diff --git a/libraries/render-utils/src/GeometryCache.h b/libraries/render-utils/src/GeometryCache.h
index c4531aa102..7fa543abe2 100644
--- a/libraries/render-utils/src/GeometryCache.h
+++ b/libraries/render-utils/src/GeometryCache.h
@@ -163,6 +163,13 @@ public:
     void renderShapeInstances(gpu::Batch& batch, Shape shape, size_t count, gpu::BufferPointer& colorBuffer);
     void renderWireShapeInstances(gpu::Batch& batch, Shape shape, size_t count, gpu::BufferPointer& colorBuffer);
 
+    void renderSolidShapeInstance(gpu::Batch& batch, Shape shape, const glm::vec4& color = glm::vec4(1),
+                                    const render::ShapePipelinePointer& pipeline = _simplePipeline);
+    void renderSolidShapeInstance(gpu::Batch& batch, Shape shape, const glm::vec3& color,
+                                    const render::ShapePipelinePointer& pipeline = _simplePipeline) {
+        renderSolidShapeInstance(batch, shape, glm::vec4(color, 1.0f), pipeline);
+    }
+
     void renderSolidSphereInstance(gpu::Batch& batch, const glm::vec4& color,
                                     const render::ShapePipelinePointer& pipeline = _simplePipeline);
     void renderSolidSphereInstance(gpu::Batch& batch, const glm::vec3& color,
diff --git a/scripts/developer/tests/entityEditStressTest.js b/scripts/developer/tests/entityEditStressTest.js
index 2d3c8ad0e1..8fa06a968d 100644
--- a/scripts/developer/tests/entityEditStressTest.js
+++ b/scripts/developer/tests/entityEditStressTest.js
@@ -15,161 +15,11 @@
 // See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html
 //
 
-var NUM_ENTITIES = 20000;           // number of entities to spawn
-var ENTITY_SPAWN_LIMIT = 1000;
-var ENTITY_SPAWN_INTERVAL = 0.1;
+Script.include("./entitySpawnTool.js");
 
-var UPDATE_INTERVAL = 0.05;  // Re-randomize the entity's position every x seconds / ms
-var ENTITY_LIFETIME = 30;   // Entity timeout (when/if we crash, we need the entities to delete themselves)
-var KEEPALIVE_INTERVAL = 5; // Refreshes the timeout every X seconds 
-
-var RADIUS = 5.0;   // Spawn within this radius (square)
-var Y_OFFSET = 1.5; // Spawn at an offset below the avatar
-var TEST_ENTITY_NAME = "EntitySpawnTest";
-    
-(function () {
-    this.makeEntity = function (properties) {
-        var entity = Entities.addEntity(properties);
-        // print("spawning entity: " + JSON.stringify(properties));
-
-        return {
-            update: function (properties) {
-                Entities.editEntity(entity, properties);
-            },
-            destroy: function () {
-                Entities.deleteEntity(entity)
-            },
-            getAge: function () {
-                return Entities.getEntityProperties(entity).age;
-            }
-        };
-    }
-
-    this.randomPositionXZ = function (center, radius) {
-        return {
-            x: center.x + (Math.random() * radius * 2.0) - radius,
-            y: center.y,
-            z: center.z + (Math.random() * radius * 2.0) - radius
-        };
-    }
-    this.randomColor = function () {
-        var shade = Math.floor(Math.random() * 255);
-        var hue   = Math.floor(Math.random() * (255 - shade));
-
-        return {
-            red: shade + hue,
-            green: shade,
-            blue: shade
-        };
-    }
-    this.randomDimensions = function () {
-        return {
-            x: 0.1 + Math.random() * 0.5,
-            y: 0.1 + Math.random() * 0.1,
-            z: 0.1 + Math.random() * 0.5
-        };
-    }
-})();
-
-(function () {
-    var entities = [];
-    var entitiesToCreate = 0;
-    var entitiesSpawned = 0;
-
-
-    function clear () {
-        var ids = Entities.findEntities(MyAvatar.position, 50);
-        var that = this;
-        ids.forEach(function(id) {
-            var properties = Entities.getEntityProperties(id);
-            if (properties.name == TEST_ENTITY_NAME) {
-                Entities.deleteEntity(id);
-            }
-        }, this);
-    }    
-    
-    function createEntities () {
-        print("Creating " + NUM_ENTITIES + " entities (UPDATE_INTERVAL = " + UPDATE_INTERVAL + ", KEEPALIVE_INTERVAL = " + KEEPALIVE_INTERVAL + ")");
-        entitiesToCreate = NUM_ENTITIES;
-        Script.update.connect(spawnEntities);
-    }
-
-    var spawnTimer = 0.0;
-    function spawnEntities (dt) {
-        if (entitiesToCreate <= 0) {
-            Script.update.disconnect(spawnEntities);
-            print("Finished spawning entities");
-        } 
-        else if ((spawnTimer -= dt) < 0.0){
-            spawnTimer = ENTITY_SPAWN_INTERVAL;
-
-            var n = Math.min(entitiesToCreate, ENTITY_SPAWN_LIMIT);
-            print("Spawning " + n + " entities (" + (entitiesSpawned += n) + ")");
-
-            entitiesToCreate -= n;
-
-            var center = MyAvatar.position;
-            center.y -= Y_OFFSET;
-
-            for (; n > 0; --n) {
-                entities.push(makeEntity({
-                    type: "Box",
-                    name: TEST_ENTITY_NAME,
-                    position: randomPositionXZ(center, RADIUS),
-                    color: randomColor(),
-                    dimensions: randomDimensions(),
-                    lifetime: ENTITY_LIFETIME
-                }));
-            }
-        }
-    }
-
-    function despawnEntities () {
-        print("despawning entities");
-        entities.forEach(function (entity) {
-            entity.destroy();
-        });
-        entities = [];
-    }
-
-    var keepAliveTimer = 0.0;
-    var updateTimer = 0.0;
-
-    // Runs the following entity updates:
-    // a) refreshes the timeout interval every KEEPALIVE_INTERVAL seconds, and
-    // b) re-randomizes its position every UPDATE_INTERVAL seconds.
-    // This should be sufficient to crash the client until the entity tree bug is fixed (and thereafter if it shows up again).
-    function updateEntities (dt) {
-        var updateLifetime = ((keepAliveTimer -= dt) < 0.0) ? ((keepAliveTimer = KEEPALIVE_INTERVAL), true) : false;
-        var updateProperties = ((updateTimer -= dt) < 0.0) ? ((updateTimer = UPDATE_INTERVAL), true) : false;
-
-        if (updateLifetime || updateProperties) {
-            var center = MyAvatar.position;
-            center.y -= Y_OFFSET;
-
-            entities.forEach((updateLifetime && updateProperties && function (entity) {
-                entity.update({
-                    lifetime: entity.getAge() + ENTITY_LIFETIME,
-                    position: randomPositionXZ(center, RADIUS)
-                });
-            }) || (updateLifetime && function (entity) {
-                entity.update({
-                    lifetime: entity.getAge() + ENTITY_LIFETIME
-                });
-            }) || (updateProperties && function (entity) {
-                entity.update({
-                    position: randomPositionXZ(center, RADIUS)
-                });
-            }) || null, this);
-        }
-    }
-
-    function init () {
-        Script.update.disconnect(init);
-        clear();
-        createEntities();
-        Script.update.connect(updateEntities);
-        Script.scriptEnding.connect(despawnEntities);
-    }
-    Script.update.connect(init);
-})();
\ No newline at end of file
+ENTITY_SPAWNER({
+    count: 20000,
+    spawnLimit: 1000,
+    spawnInterval: 0.1,
+    updateInterval: 0.05
+});
diff --git a/scripts/developer/tests/entitySpawnTool.js b/scripts/developer/tests/entitySpawnTool.js
new file mode 100644
index 0000000000..d88933b867
--- /dev/null
+++ b/scripts/developer/tests/entitySpawnTool.js
@@ -0,0 +1,184 @@
+// entityEditStressTest.js
+//
+// Created by Seiji Emery on 8/31/15
+// Copyright 2015 High Fidelity, Inc.
+//
+// Stress tests the client + server-side entity trees by spawning huge numbers of entities in
+// close proximity to your avatar and updating them continuously (ie. applying position edits), 
+// with the intent of discovering crashes and other bugs related to the entity, scripting, 
+// rendering, networking, and/or physics subsystems.
+//
+// This script was originally created to find + diagnose an a clientside crash caused by improper
+// locking of the entity tree, but can be reused for other purposes.
+//
+// Distributed under the Apache License, Version 2.0.
+// See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html
+//
+
+ENTITY_SPAWNER = function (properties) {
+    properties = properties || {};
+    var RADIUS = properties.radius || 5.0;   // Spawn within this radius (square)
+    var Y_OFFSET = properties.yOffset || 1.5; // Spawn at an offset below the avatar
+    var TEST_ENTITY_NAME = properties.entityName || "EntitySpawnTest";
+
+    var NUM_ENTITIES = properties.count || 1000; // number of entities to spawn
+    var ENTITY_SPAWN_LIMIT = properties.spawnLimit || 100;
+    var ENTITY_SPAWN_INTERVAL = properties.spawnInterval || properties.interval || 1.0;
+
+    var UPDATE_INTERVAL = properties.updateInterval || properties.interval || 0.1;  // Re-randomize the entity's position every x seconds / ms
+    var ENTITY_LIFETIME = properties.lifetime || 30;   // Entity timeout (when/if we crash, we need the entities to delete themselves)
+    var KEEPALIVE_INTERVAL = properties.keepAlive || 5; // Refreshes the timeout every X seconds
+    var UPDATES = properties.updates || false
+    var SHAPES = properties.shapes || ["Icosahedron", "Tetrahedron", "Cube", "Sphere" ];
+
+    function makeEntity(properties) {
+        var entity = Entities.addEntity(properties);
+        // print("spawning entity: " + JSON.stringify(properties));
+
+        return {
+            update: function (properties) {
+                Entities.editEntity(entity, properties);
+            },
+            destroy: function () {
+                Entities.deleteEntity(entity)
+            },
+            getAge: function () {
+                return Entities.getEntityProperties(entity).age;
+            }
+        };
+    }
+
+    function randomPositionXZ(center, radius) {
+        return {
+            x: center.x + (Math.random() * radius * 2.0) - radius,
+            y: center.y,
+            z: center.z + (Math.random() * radius * 2.0) - radius
+        };
+    }
+    
+    function randomPosition(center, radius) {
+        return {
+            x: center.x + (Math.random() * radius * 2.0) - radius,
+            y: center.y + (Math.random() * radius * 2.0) - radius,
+            z: center.z + (Math.random() * radius * 2.0) - radius
+        };
+    }
+    
+    
+    function randomColor() {
+        return {
+            red: Math.floor(Math.random() * 255),
+            green: Math.floor(Math.random() * 255),
+            blue: Math.floor(Math.random() * 255),
+        };
+    }
+    
+    function randomDimensions() {
+        return {
+            x: 0.1 + Math.random() * 0.5,
+            y: 0.1 + Math.random() * 0.1,
+            z: 0.1 + Math.random() * 0.5
+        };
+    }
+
+    var entities = [];
+    var entitiesToCreate = 0;
+    var entitiesSpawned = 0;
+    var spawnTimer = 0.0;
+    var keepAliveTimer = 0.0;
+    var updateTimer = 0.0;
+
+    function clear () {
+        var ids = Entities.findEntities(MyAvatar.position, 50);
+        var that = this;
+        ids.forEach(function(id) {
+            var properties = Entities.getEntityProperties(id);
+            if (properties.name == TEST_ENTITY_NAME) {
+                Entities.deleteEntity(id);
+            }
+        }, this);
+    }    
+    
+    function createEntities () {
+        print("Creating " + NUM_ENTITIES + " entities (UPDATE_INTERVAL = " + UPDATE_INTERVAL + ", KEEPALIVE_INTERVAL = " + KEEPALIVE_INTERVAL + ")");
+        entitiesToCreate = NUM_ENTITIES;
+        Script.update.connect(spawnEntities);
+    }
+
+    function spawnEntities (dt) {
+        if (entitiesToCreate <= 0) {
+            Script.update.disconnect(spawnEntities);
+            print("Finished spawning entities");
+        } 
+        else if ((spawnTimer -= dt) < 0.0){
+            spawnTimer = ENTITY_SPAWN_INTERVAL;
+
+            var n = Math.min(entitiesToCreate, ENTITY_SPAWN_LIMIT);
+            print("Spawning " + n + " entities (" + (entitiesSpawned += n) + ")");
+
+            entitiesToCreate -= n;
+
+            var center = MyAvatar.position;
+            center.y -= Y_OFFSET;
+
+            for (; n > 0; --n) {
+                entities.push(makeEntity({
+                    type: "Shape",
+                    shape: SHAPES[n % SHAPES.length],
+                    name: TEST_ENTITY_NAME,
+                    position: randomPosition(center, RADIUS),
+                    color: randomColor(),
+                    dimensions: randomDimensions(),
+                    lifetime: ENTITY_LIFETIME
+                }));
+            }
+        }
+    }
+
+    function despawnEntities () {
+        print("despawning entities");
+        entities.forEach(function (entity) {
+            entity.destroy();
+        });
+        entities = [];
+    }
+
+    // Runs the following entity updates:
+    // a) refreshes the timeout interval every KEEPALIVE_INTERVAL seconds, and
+    // b) re-randomizes its position every UPDATE_INTERVAL seconds.
+    // This should be sufficient to crash the client until the entity tree bug is fixed (and thereafter if it shows up again).
+    function updateEntities (dt) {
+        var updateLifetime = ((keepAliveTimer -= dt) < 0.0) ? ((keepAliveTimer = KEEPALIVE_INTERVAL), true) : false;
+        var updateProperties = ((updateTimer -= dt) < 0.0) ? ((updateTimer = UPDATE_INTERVAL), true) : false;
+
+        if (updateLifetime || updateProperties) {
+            var center = MyAvatar.position;
+            center.y -= Y_OFFSET;
+
+            entities.forEach((updateLifetime && updateProperties && function (entity) {
+                entity.update({
+                    lifetime: entity.getAge() + ENTITY_LIFETIME,
+                    position: randomPosition(center, RADIUS)
+                });
+            }) || (updateLifetime && function (entity) {
+                entity.update({
+                    lifetime: entity.getAge() + ENTITY_LIFETIME
+                });
+            }) || (updateProperties && function (entity) {
+                entity.update({
+                    position: randomPosition(center, RADIUS)
+                });
+            }) || null, this);
+        }
+    }
+
+    function init () {
+        Script.update.disconnect(init);
+        clear();
+        createEntities();
+        Script.update.connect(updateEntities);
+        Script.scriptEnding.connect(despawnEntities);
+    }
+    
+    Script.update.connect(init);
+};
\ No newline at end of file
diff --git a/scripts/developer/tests/primitivesTest.js b/scripts/developer/tests/primitivesTest.js
new file mode 100644
index 0000000000..e401963a83
--- /dev/null
+++ b/scripts/developer/tests/primitivesTest.js
@@ -0,0 +1,24 @@
+// entityEditStressTest.js
+//
+// Created by Seiji Emery on 8/31/15
+// Copyright 2015 High Fidelity, Inc.
+//
+// Stress tests the client + server-side entity trees by spawning huge numbers of entities in
+// close proximity to your avatar and updating them continuously (ie. applying position edits), 
+// with the intent of discovering crashes and other bugs related to the entity, scripting, 
+// rendering, networking, and/or physics subsystems.
+//
+// This script was originally created to find + diagnose an a clientside crash caused by improper
+// locking of the entity tree, but can be reused for other purposes.
+//
+// Distributed under the Apache License, Version 2.0.
+// See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html
+//
+
+Script.include("./entitySpawnTool.js");
+
+
+ENTITY_SPAWNER({
+    updateInterval: 2.0
+})
+
diff --git a/scripts/system/html/entityProperties.html b/scripts/system/html/entityProperties.html
index efe7e6cc65..4a3b5a14a4 100644
--- a/scripts/system/html/entityProperties.html
+++ b/scripts/system/html/entityProperties.html
@@ -25,6 +25,7 @@
         var ICON_FOR_TYPE = {
             Box: "V",
             Sphere: "n",
+            Shape: "n",
             ParticleEffect: "&#xe004;",
             Model: "&#xe008;",
             Web: "q",
@@ -403,6 +404,10 @@
                 var elColorGreen = document.getElementById("property-color-green");
                 var elColorBlue = document.getElementById("property-color-blue");
     
+                var elShapeSections = document.querySelectorAll(".shape-section");
+                allSections.push(elShapeSections);
+                var elShape = document.getElementById("property-shape");
+                
                 var elLightSections = document.querySelectorAll(".light-section");
                 allSections.push(elLightSections);
                 var elLightSpotLight = document.getElementById("property-light-spot-light");
@@ -666,7 +671,18 @@
                                     elHyperlinkSections[i].style.display = 'table';
                                 }
 
-                                if (properties.type == "Box" || properties.type == "Sphere" || properties.type == "ParticleEffect") {
+                                if (properties.type == "Shape" || properties.type == "Box" || properties.type == "Sphere") {
+                                    for (var i = 0; i < elShapeSections.length; i++) {
+                                        elShapeSections[i].style.display = 'table';
+                                    }
+                                } else {
+                                    for (var i = 0; i < elShapeSections.length; i++) {
+                                        console.log("Hiding shape section " + elShapeSections[i])
+                                        elShapeSections[i].style.display = 'none';
+                                    }
+                                }
+                                
+                                if (properties.type == "Shape" || properties.type == "Box" || properties.type == "Sphere" || properties.type == "ParticleEffect") {
                                     for (var i = 0; i < elColorSections.length; i++) {
                                         elColorSections[i].style.display = 'table';
                                     }
@@ -958,6 +974,8 @@
                 elLightExponent.addEventListener('change', createEmitNumberPropertyUpdateFunction('exponent', 2));
                 elLightCutoff.addEventListener('change', createEmitNumberPropertyUpdateFunction('cutoff', 2));
     
+                elShape.addEventListener('change', createEmitTextPropertyUpdateFunction('shape'));
+
                 elWebSourceURL.addEventListener('change', createEmitTextPropertyUpdateFunction('sourceUrl'));
     
                 elModelURL.addEventListener('change', createEmitTextPropertyUpdateFunction('modelURL'));
@@ -1344,6 +1362,36 @@
             <span id="property-id" class="selectable"></span>
         </div>
 
+        <div class="section-header shape-group shape-section">
+            <label>Shape</label><span>M</span>
+        </div>
+        <div class="shape-group shape-section property dropdown">
+            <label for="property-shape">Shape</label>
+            <select name="SelectShape" id="property-shape">
+                <option value="Cube">Cube</option>
+                <option value="Sphere">Sphere</option>
+                <option value="Icosahedron">Icosahedron</option>
+                <option value="Tetrahedron">Tetrahedron</option>
+            </select>
+        </div>
+        <div class="shape-group shape-section property text">
+            <label>Temp</label>
+            <input type="text" id="property-temp-1">
+        </div>
+        <div class="shape-group shape-section property text">
+            <label>Temp</label>
+            <input type="text" id="property-temp-2">
+        </div>
+<!-- 
+        <div class="shape-group shape-section property text">
+            <label>Temp</label>
+            <input type="text" id="property-temp-3">
+        </div>
+        <div class="shape-group shape-section property text">
+            <label>Temp</label>
+            <input type="text" id="property-temp-4">
+        </div>
+ -->
 
         <div class="section-header hyperlink-group hyperlink-section">
             <label>Hyperlink</label><span>M</span>
@@ -1678,7 +1726,6 @@
             <textarea id="property-model-original-textures" readonly></textarea>
         </div>
 
-
         <div class="section-header text-group text-section">
             <label>Text</label><span>M</span>
         </div>
diff --git a/tests/entities/src/main.cpp b/tests/entities/src/main.cpp
index c0e21276d8..792ef7d9c6 100644
--- a/tests/entities/src/main.cpp
+++ b/tests/entities/src/main.cpp
@@ -16,7 +16,7 @@
 #include <QDir>
 #include <ByteCountCoding.h>
 
-#include <BoxEntityItem.h>
+#include <ShapeEntityItem.h>
 #include <EntityItemProperties.h>
 #include <Octree.h>
 #include <PathUtils.h>
@@ -155,7 +155,7 @@ int main(int argc, char** argv) {
     QFile file(getTestResourceDir() + "packet.bin");
     if (!file.open(QIODevice::ReadOnly)) return -1;
     QByteArray packet = file.readAll();
-    EntityItemPointer item = BoxEntityItem::factory(EntityItemID(), EntityItemProperties());
+    EntityItemPointer item = ShapeEntityItem::boxFactory(EntityItemID(), EntityItemProperties());
     ReadBitstreamToTreeParams params;
     params.bitstreamVersion = 33;
 

From 2c703e963cdb9780c241381948806416deffdd6a Mon Sep 17 00:00:00 2001
From: Brad Davis <bdavis@saintandreas.org>
Date: Sun, 22 May 2016 17:41:50 -0700
Subject: [PATCH 2/2] More shapes

---
 .../src/RenderableShapeEntityItem.cpp         |   4 +-
 libraries/entities/src/ShapeEntityItem.cpp    |   2 +-
 libraries/entities/src/ShapeEntityItem.h      |   2 +-
 libraries/render-utils/src/GeometryCache.cpp  | 651 +++++++++---------
 libraries/render-utils/src/GeometryCache.h    |   4 +-
 scripts/system/html/entityProperties.html     |   6 +-
 tests/gpu-test/CMakeLists.txt                 |   4 +-
 tests/gpu-test/src/TestHelpers.cpp            |  20 +
 tests/gpu-test/src/TestHelpers.h              |  33 +
 tests/gpu-test/src/TestInstancedShapes.cpp    |  84 +++
 tests/gpu-test/src/TestInstancedShapes.h      |  23 +
 tests/gpu-test/src/TestShapes.cpp             |  48 ++
 tests/gpu-test/src/TestShapes.h               |  22 +
 tests/gpu-test/src/TestWindow.cpp             | 180 +++++
 tests/gpu-test/src/TestWindow.h               |  53 ++
 tests/gpu-test/src/main.cpp                   | 539 +++------------
 16 files changed, 895 insertions(+), 780 deletions(-)
 create mode 100644 tests/gpu-test/src/TestHelpers.cpp
 create mode 100644 tests/gpu-test/src/TestHelpers.h
 create mode 100644 tests/gpu-test/src/TestInstancedShapes.cpp
 create mode 100644 tests/gpu-test/src/TestInstancedShapes.h
 create mode 100644 tests/gpu-test/src/TestShapes.cpp
 create mode 100644 tests/gpu-test/src/TestShapes.h
 create mode 100644 tests/gpu-test/src/TestWindow.cpp
 create mode 100644 tests/gpu-test/src/TestWindow.h

diff --git a/libraries/entities-renderer/src/RenderableShapeEntityItem.cpp b/libraries/entities-renderer/src/RenderableShapeEntityItem.cpp
index 7d30b7a47c..c93ae252e3 100644
--- a/libraries/entities-renderer/src/RenderableShapeEntityItem.cpp
+++ b/libraries/entities-renderer/src/RenderableShapeEntityItem.cpp
@@ -30,7 +30,7 @@ static GeometryCache::Shape MAPPING[entity::NUM_SHAPES] = {
     GeometryCache::Cube,
     GeometryCache::Sphere,
     GeometryCache::Tetrahedron,
-    GeometryCache::Octahetron,
+    GeometryCache::Octahedron,
     GeometryCache::Dodecahedron,
     GeometryCache::Icosahedron,
     GeometryCache::Torus,
@@ -93,7 +93,7 @@ void RenderableShapeEntityItem::render(RenderArgs* args) {
     if (!success) {
         return;
     }
-    if (_shape != entity::Cube) {
+    if (_shape == entity::Sphere) {
         modelTransform.postScale(SPHERE_ENTITY_SCALE);
     }
     batch.setModelTransform(modelTransform); // use a transform with scale, rotation, registration point and translation
diff --git a/libraries/entities/src/ShapeEntityItem.cpp b/libraries/entities/src/ShapeEntityItem.cpp
index a24c7e1df5..2527dedab2 100644
--- a/libraries/entities/src/ShapeEntityItem.cpp
+++ b/libraries/entities/src/ShapeEntityItem.cpp
@@ -27,7 +27,7 @@ namespace entity {
         "Cube", 
         "Sphere", 
         "Tetrahedron", 
-        "Octahetron", 
+        "Octahedron", 
         "Dodecahedron", 
         "Icosahedron", 
         "Torus", 
diff --git a/libraries/entities/src/ShapeEntityItem.h b/libraries/entities/src/ShapeEntityItem.h
index f3cb2abd66..2ae4ae2ca1 100644
--- a/libraries/entities/src/ShapeEntityItem.h
+++ b/libraries/entities/src/ShapeEntityItem.h
@@ -19,7 +19,7 @@ namespace entity {
         Cube,
         Sphere,
         Tetrahedron,
-        Octahetron,
+        Octahedron,
         Dodecahedron,
         Icosahedron,
         Torus,
diff --git a/libraries/render-utils/src/GeometryCache.cpp b/libraries/render-utils/src/GeometryCache.cpp
index 6852d17882..02aca4216e 100644
--- a/libraries/render-utils/src/GeometryCache.cpp
+++ b/libraries/render-utils/src/GeometryCache.cpp
@@ -51,8 +51,8 @@ static gpu::Stream::FormatPointer INSTANCED_SOLID_STREAM_FORMAT;
 
 static const uint SHAPE_VERTEX_STRIDE = sizeof(glm::vec3) * 2; // vertices and normals
 static const uint SHAPE_NORMALS_OFFSET = sizeof(glm::vec3);
-static const gpu::Type SHAPE_INDEX_TYPE = gpu::UINT16;
-static const uint SHAPE_INDEX_SIZE = sizeof(gpu::uint16);
+static const gpu::Type SHAPE_INDEX_TYPE = gpu::UINT32;
+static const uint SHAPE_INDEX_SIZE = sizeof(gpu::uint32);
 
 void GeometryCache::ShapeData::setupVertices(gpu::BufferPointer& vertexBuffer, const VertexVector& vertices) {
     vertexBuffer->append(vertices);
@@ -112,102 +112,7 @@ void GeometryCache::ShapeData::drawWireInstances(gpu::Batch& batch, size_t count
     }
 }
 
-// The golden ratio
-static const float PHI = 1.61803398874f;
-
-const VertexVector& icosahedronVertices() {
-    static const float a = 1;
-    static const float b = PHI / 2.0f;
-
-    static const VertexVector vertices{ //
-        vec3(0, b, -a), vec3(-b, a, 0), vec3(b, a, 0), // 
-        vec3(0, b, a), vec3(b, a, 0), vec3(-b, a, 0), //
-        vec3(0, b, a), vec3(-a, 0, b), vec3(0, -b, a), //
-        vec3(0, b, a), vec3(0, -b, a), vec3(a, 0, b),  //
-        vec3(0, b, -a), vec3(a, 0, -b), vec3(0, -b, -a),// 
-        vec3(0, b, -a), vec3(0, -b, -a), vec3(-a, 0, -b), //
-        vec3(0, -b, a), vec3(-b, -a, 0), vec3(b, -a, 0), //
-        vec3(0, -b, -a), vec3(b, -a, 0), vec3(-b, -a, 0), //
-        vec3(-b, a, 0), vec3(-a, 0, -b),  vec3(-a, 0, b), //
-        vec3(-b, -a, 0), vec3(-a, 0, b),  vec3(-a, 0, -b), //
-        vec3(b, a, 0), vec3(a, 0, b), vec3(a, 0, -b),   //
-        vec3(b, -a, 0), vec3(a, 0, -b), vec3(a, 0, b),  //
-        vec3(0, b, a), vec3(-b, a, 0),  vec3(-a, 0, b), //
-        vec3(0, b, a), vec3(a, 0, b), vec3(b, a, 0), //
-        vec3(0, b, -a), vec3(-a, 0, -b), vec3(-b, a, 0), // 
-        vec3(0, b, -a), vec3(b, a, 0),  vec3(a, 0, -b), //
-        vec3(0, -b, -a), vec3(-b, -a, 0), vec3(-a, 0, -b), // 
-        vec3(0, -b, -a), vec3(a, 0, -b), vec3(b, -a, 0), //
-        vec3(0, -b, a), vec3(-a, 0, b),  vec3(-b, -a, 0), //
-        vec3(0, -b, a), vec3(b, -a, 0), vec3(a, 0, b)
-    }; //
-    return vertices;
-}
-
-const VertexVector& tetrahedronVertices() {
-    static const auto A = vec3(1, 1, 1);
-    static const auto B = vec3(1, -1, -1);
-    static const auto C = vec3(-1, 1, -1);
-    static const auto D = vec3(-1, -1, 1);
-    static const VertexVector vertices{
-        A, B, C,
-        D, B, A,
-        C, D, A,
-        C, B, D,
-    };
-    return vertices;
-}
-
-static const size_t TESSELTATION_MULTIPLIER = 4;
 static const size_t ICOSAHEDRON_TO_SPHERE_TESSELATION_COUNT = 3;
-static const size_t VECTOR_TO_VECTOR_WITH_NORMAL_MULTIPLER = 2;
-
-
-VertexVector tesselate(const VertexVector& startingTriangles, int count) {
-    VertexVector triangles = startingTriangles;
-    if (0 != (triangles.size() % 3)) {
-        throw std::runtime_error("Bad number of vertices for tesselation");
-    }
-
-    for (size_t i = 0; i < triangles.size(); ++i) {
-        triangles[i] = glm::normalize(triangles[i]);
-    }
-
-    VertexVector newTriangles;
-    while (count) {
-        newTriangles.clear();
-        // Tesselation takes one triangle and makes it into 4 triangles
-        // See https://en.wikipedia.org/wiki/Space-filling_tree#/media/File:Space_Filling_Tree_Tri_iter_1_2_3.png
-        newTriangles.reserve(triangles.size() * TESSELTATION_MULTIPLIER);
-        for (size_t i = 0; i < triangles.size(); i += VERTICES_PER_TRIANGLE) {
-            const vec3& a = triangles[i];
-            const vec3& b = triangles[i + 1];
-            const vec3& c = triangles[i + 2];
-            vec3 ab = glm::normalize(a + b);
-            vec3 bc = glm::normalize(b + c);
-            vec3 ca = glm::normalize(c + a);
-
-            newTriangles.push_back(a);
-            newTriangles.push_back(ab);
-            newTriangles.push_back(ca);
-
-            newTriangles.push_back(b);
-            newTriangles.push_back(bc);
-            newTriangles.push_back(ab);
-
-            newTriangles.push_back(c);
-            newTriangles.push_back(ca);
-            newTriangles.push_back(bc);
-
-            newTriangles.push_back(ab);
-            newTriangles.push_back(bc);
-            newTriangles.push_back(ca);
-        }
-        triangles.swap(newTriangles);
-        --count;
-    }
-    return triangles;
-}
 
 size_t GeometryCache::getShapeTriangleCount(Shape shape) {
     return _shapes[shape]._indexCount / VERTICES_PER_TRIANGLE;
@@ -221,6 +126,324 @@ size_t GeometryCache::getCubeTriangleCount() {
     return getShapeTriangleCount(Cube);
 }
 
+using Index = uint32_t;
+using IndexPair = uint64_t;
+using IndexPairs = std::unordered_set<IndexPair>;
+
+template <size_t N>
+using Face = std::array<Index, N>;
+
+template <size_t N>
+using FaceVector = std::vector<Face<N>>;
+
+template <size_t N>
+struct Solid {
+    VertexVector vertices;
+    FaceVector<N> faces;
+
+    Solid<N>& fitDimension(float newMaxDimension) {
+        float maxDimension = 0;
+        for (const auto& vertex : vertices) {
+            maxDimension = std::max(maxDimension, std::max(std::max(vertex.x, vertex.y), vertex.z));
+        }
+        float multiplier = newMaxDimension / maxDimension;
+        for (auto& vertex : vertices) {
+            vertex *= multiplier;
+        }
+        return *this;
+    }
+
+    vec3 getFaceNormal(size_t faceIndex) const {
+        vec3 result;
+        const auto& face = faces[faceIndex];
+        for (size_t i = 0; i < N; ++i) {
+            result += vertices[face[i]];
+        }
+        result /= N;
+        return glm::normalize(result);
+    }
+};
+
+template <size_t N>
+static size_t triangulatedFaceTriangleCount() {
+    return N - 2;
+}
+
+template <size_t N> 
+static size_t triangulatedFaceIndexCount() {
+    return triangulatedFaceTriangleCount<N>() * VERTICES_PER_TRIANGLE;
+}
+
+static IndexPair indexToken(Index a, Index b) {
+    if (a > b) {
+        std::swap(a, b);
+    }
+    return (((IndexPair)a) << 32) | ((IndexPair)b);
+}
+
+static Solid<3> tesselate(Solid<3> solid, int count) {
+    float length = glm::length(solid.vertices[0]);
+    for (int i = 0; i < count; ++i) {
+        Solid<3> result { solid.vertices, {} };
+        result.vertices.reserve(solid.vertices.size() + solid.faces.size() * 3);
+        for (size_t f = 0; f < solid.faces.size(); ++f) {
+            Index baseVertex = (Index)result.vertices.size();
+            const Face<3>& oldFace = solid.faces[f];
+            const vec3& a = solid.vertices[oldFace[0]];
+            const vec3& b = solid.vertices[oldFace[1]];
+            const vec3& c = solid.vertices[oldFace[2]];
+            vec3 ab = glm::normalize(a + b) * length;
+            vec3 bc = glm::normalize(b + c) * length;
+            vec3 ca = glm::normalize(c + a) * length;
+            result.vertices.push_back(ab);
+            result.vertices.push_back(bc);
+            result.vertices.push_back(ca);
+            result.faces.push_back(Face<3>{ { oldFace[0], baseVertex, baseVertex + 2 } });
+            result.faces.push_back(Face<3>{ { baseVertex, oldFace[1], baseVertex + 1 } });
+            result.faces.push_back(Face<3>{ { baseVertex + 1, oldFace[2], baseVertex + 2 } });
+            result.faces.push_back(Face<3>{ { baseVertex, baseVertex + 1, baseVertex + 2 } });
+        }
+        solid = result;
+    }
+    return solid;
+}
+
+template <size_t N>
+void setupFlatShape(GeometryCache::ShapeData& shapeData, const Solid<N>& shape, gpu::BufferPointer& vertexBuffer, gpu::BufferPointer& indexBuffer) {
+    Index baseVertex = (Index)(vertexBuffer->getSize() / SHAPE_VERTEX_STRIDE);
+    VertexVector vertices;
+    IndexVector solidIndices, wireIndices;
+    IndexPairs wireSeenIndices;
+
+    size_t faceCount = shape.faces.size();
+    size_t faceIndexCount = triangulatedFaceIndexCount<N>();
+
+    vertices.reserve(N * faceCount * 2);
+    solidIndices.reserve(faceIndexCount * faceCount);
+
+    for (size_t f = 0; f < faceCount; ++f) {
+        const Face<N>& face = shape.faces[f];
+        // Compute the face normal
+        vec3 faceNormal = shape.getFaceNormal(f);
+
+        // Create the vertices for the face
+        for (Index i = 0; i < N; ++i) {
+            Index originalIndex = face[i];
+            vertices.push_back(shape.vertices[originalIndex]);
+            vertices.push_back(faceNormal);
+        }
+
+        // Create the wire indices for unseen edges
+        for (Index i = 0; i < N; ++i) {
+            Index a = i;
+            Index b = (i + 1) % N;
+            auto token = indexToken(face[a], face[b]);
+            if (0 == wireSeenIndices.count(token)) {
+                wireSeenIndices.insert(token);
+                wireIndices.push_back(a + baseVertex);
+                wireIndices.push_back(b + baseVertex);
+            }
+        }
+
+        // Create the solid face indices
+        for (Index i = 0; i < N - 2; ++i) {
+            solidIndices.push_back(0 + baseVertex);
+            solidIndices.push_back(i + 1 + baseVertex);
+            solidIndices.push_back(i + 2 + baseVertex);
+        }
+        baseVertex += (Index)N;
+    }
+
+    shapeData.setupVertices(vertexBuffer, vertices);
+    shapeData.setupIndices(indexBuffer, solidIndices, wireIndices);
+}
+
+template <size_t N>
+void setupSmoothShape(GeometryCache::ShapeData& shapeData, const Solid<N>& shape, gpu::BufferPointer& vertexBuffer, gpu::BufferPointer& indexBuffer) {
+    Index baseVertex = (Index)(vertexBuffer->getSize() / SHAPE_VERTEX_STRIDE);
+
+    VertexVector vertices;
+    vertices.reserve(shape.vertices.size() * 2);
+    for (const auto& vertex : shape.vertices) {
+        vertices.push_back(vertex);
+        vertices.push_back(vertex);
+    }
+
+    IndexVector solidIndices, wireIndices;
+    IndexPairs wireSeenIndices;
+
+    size_t faceCount = shape.faces.size();
+    size_t faceIndexCount = triangulatedFaceIndexCount<N>();
+
+    solidIndices.reserve(faceIndexCount * faceCount);
+
+    for (size_t f = 0; f < faceCount; ++f) {
+        const Face<N>& face = shape.faces[f];
+        // Create the wire indices for unseen edges
+        for (Index i = 0; i < N; ++i) {
+            Index a = face[i];
+            Index b = face[(i + 1) % N];
+            auto token = indexToken(a, b);
+            if (0 == wireSeenIndices.count(token)) {
+                wireSeenIndices.insert(token);
+                wireIndices.push_back(a + baseVertex);
+                wireIndices.push_back(b + baseVertex);
+            }
+        }
+
+        // Create the solid face indices
+        for (Index i = 0; i < N - 2; ++i) {
+            solidIndices.push_back(face[i] + baseVertex);
+            solidIndices.push_back(face[i + 1] + baseVertex);
+            solidIndices.push_back(face[i + 2] + baseVertex);
+        }
+    }
+
+    shapeData.setupVertices(vertexBuffer, vertices);
+    shapeData.setupIndices(indexBuffer, solidIndices, wireIndices);
+}
+
+// The golden ratio
+static const float PHI = 1.61803398874f;
+
+static const Solid<3>& tetrahedron() {
+    static const auto A = vec3(1, 1, 1);
+    static const auto B = vec3(1, -1, -1);
+    static const auto C = vec3(-1, 1, -1);
+    static const auto D = vec3(-1, -1, 1);
+    static const Solid<3> TETRAHEDRON = Solid<3>{
+        { A, B, C, D },
+        FaceVector<3>{
+            Face<3> { { 0, 1, 2 } },
+                Face<3> { { 3, 1, 0 } },
+                Face<3> { { 2, 3, 0 } },
+                Face<3> { { 2, 1, 3 } },
+        }
+    }.fitDimension(0.5f);
+    return TETRAHEDRON;
+}
+
+static const Solid<4>& cube() {
+    static const auto A = vec3(1, 1, 1);
+    static const auto B = vec3(-1, 1, 1);
+    static const auto C = vec3(-1, 1, -1);
+    static const auto D = vec3(1, 1, -1);
+    static const Solid<4> CUBE = Solid<4>{
+        { A, B, C, D, -A, -B, -C, -D },
+        FaceVector<4>{
+            Face<4> { { 3, 2, 1, 0 } },
+                Face<4> { { 0, 1, 7, 6 } },
+                Face<4> { { 1, 2, 4, 7 } },
+                Face<4> { { 2, 3, 5, 4 } },
+                Face<4> { { 3, 0, 6, 5 } },
+                Face<4> { { 4, 5, 6, 7 } },
+        }
+    }.fitDimension(0.5f);
+    return CUBE;
+}
+
+static const Solid<3>& octahedron() {
+    static const auto A = vec3(0, 1, 0);
+    static const auto B = vec3(0, -1, 0);
+    static const auto C = vec3(0, 0, 1);
+    static const auto D = vec3(0, 0, -1);
+    static const auto E = vec3(1, 0, 0);
+    static const auto F = vec3(-1, 0, 0);
+    static const Solid<3> OCTAHEDRON = Solid<3>{
+        { A, B, C, D, E, F},
+        FaceVector<3> {
+            Face<3> { { 0, 2, 4, } },
+            Face<3> { { 0, 4, 3, } },
+            Face<3> { { 0, 3, 5, } },
+            Face<3> { { 0, 5, 2, } },
+            Face<3> { { 1, 4, 2, } },
+            Face<3> { { 1, 3, 4, } },
+            Face<3> { { 1, 5, 3, } },
+            Face<3> { { 1, 2, 5, } },
+        }
+    }.fitDimension(0.5f);
+    return OCTAHEDRON;
+}
+
+static const Solid<5>& dodecahedron() {
+    static const float P = PHI;
+    static const float IP = 1.0f / PHI;
+    static const vec3 A = vec3(IP, P, 0);
+    static const vec3 B = vec3(-IP, P, 0);
+    static const vec3 C = vec3(-1, 1, 1);
+    static const vec3 D = vec3(0, IP, P);
+    static const vec3 E = vec3(1, 1, 1);
+    static const vec3 F = vec3(1, 1, -1);
+    static const vec3 G = vec3(-1, 1, -1);
+    static const vec3 H = vec3(-P, 0, IP);
+    static const vec3 I = vec3(0, -IP, P);
+    static const vec3 J = vec3(P, 0, IP);
+
+    static const Solid<5> DODECAHEDRON = Solid<5>{
+        { 
+            A,  B,  C,  D,  E,  F,  G,  H,  I,  J, 
+            -A, -B, -C, -D, -E, -F, -G, -H, -I, -J, 
+        },
+        FaceVector<5> {
+            Face<5> { { 0, 1, 2, 3, 4 } },
+            Face<5> { { 0, 5, 18, 6, 1 } },
+            Face<5> { { 1, 6, 19, 7, 2 } },
+            Face<5> { { 2, 7, 15, 8, 3 } },
+            Face<5> { { 3, 8, 16, 9, 4 } },
+            Face<5> { { 4, 9, 17, 5, 0 } },
+            Face<5> { { 14, 13, 12, 11, 10 } },
+            Face<5> { { 11, 16, 8, 15, 10 } },
+            Face<5> { { 12, 17, 9, 16, 11 } },
+            Face<5> { { 13, 18, 5, 17, 12 } },
+            Face<5> { { 14, 19, 6, 18, 13 } },
+            Face<5> { { 10, 15, 7, 19, 14 } },
+        }
+    }.fitDimension(0.5f);
+    return DODECAHEDRON;
+}
+
+static const Solid<3>& icosahedron() {
+    static const float N = 1.0f / PHI;
+    static const float P = 1.0f;
+    static const auto A = vec3(N, P, 0);
+    static const auto B = vec3(-N, P, 0);
+    static const auto C = vec3(0, N, P);
+    static const auto D = vec3(P, 0, N);
+    static const auto E = vec3(P, 0, -N);
+    static const auto F = vec3(0, N, -P);
+
+    static const Solid<3> ICOSAHEDRON = Solid<3> {
+        {
+            A, B, C, D, E, F,
+            -A, -B, -C, -D, -E, -F,
+        },
+        FaceVector<3> {
+            Face<3> { { 1, 2, 0 } },
+            Face<3> { { 2, 3, 0 } }, 
+            Face<3> { { 3, 4, 0 } },
+            Face<3> { { 4, 5, 0 } },
+            Face<3> { { 5, 1, 0 } },
+
+            Face<3> { { 1, 10, 2 } },
+            Face<3> { { 11, 2, 10 } },
+            Face<3> { { 2, 11, 3 } },
+            Face<3> { { 7, 3, 11 } },
+            Face<3> { { 3, 7, 4 } },
+            Face<3> { { 8, 4, 7 } },
+            Face<3> { { 4, 8, 5 } },
+            Face<3> { { 9, 5, 8 } },
+            Face<3> { { 5, 9, 1 } },
+            Face<3> { { 10, 1, 9 } },
+
+            Face<3> { { 8, 7, 6 } },
+            Face<3> { { 9, 8, 6 } },
+            Face<3> { { 10, 9, 6 } },
+            Face<3> { { 11, 10, 6 } },
+            Face<3> { { 7, 11, 6 } },
+        }
+    }.fitDimension(0.5f);
+    return ICOSAHEDRON;
+}
 
 // FIXME solids need per-face vertices, but smooth shaded
 // components do not.  Find a way to support using draw elements
@@ -230,229 +453,28 @@ size_t GeometryCache::getCubeTriangleCount() {
 void GeometryCache::buildShapes() {
     auto vertexBuffer = std::make_shared<gpu::Buffer>();
     auto indexBuffer = std::make_shared<gpu::Buffer>();
-    size_t startingIndex = 0;
-    
     // Cube 
-    startingIndex = _shapeVertices->getSize() / SHAPE_VERTEX_STRIDE;
-    {
-        ShapeData& shapeData = _shapes[Cube];
-        VertexVector vertices;
-        // front
-        vertices.push_back(vec3(1, 1, 1));
-        vertices.push_back(vec3(0, 0, 1));
-        vertices.push_back(vec3(-1, 1, 1));
-        vertices.push_back(vec3(0, 0, 1));
-        vertices.push_back(vec3(-1, -1, 1));
-        vertices.push_back(vec3(0, 0, 1));
-        vertices.push_back(vec3(1, -1, 1));
-        vertices.push_back(vec3(0, 0, 1));
-
-        // right
-        vertices.push_back(vec3(1, 1, 1));
-        vertices.push_back(vec3(1, 0, 0));
-        vertices.push_back(vec3(1, -1, 1));
-        vertices.push_back(vec3(1, 0, 0));
-        vertices.push_back(vec3(1, -1, -1));
-        vertices.push_back(vec3(1, 0, 0));
-        vertices.push_back(vec3(1, 1, -1));
-        vertices.push_back(vec3(1, 0, 0));
-
-        // top
-        vertices.push_back(vec3(1, 1, 1));
-        vertices.push_back(vec3(0, 1, 0));
-        vertices.push_back(vec3(1, 1, -1));
-        vertices.push_back(vec3(0, 1, 0));
-        vertices.push_back(vec3(-1, 1, -1));
-        vertices.push_back(vec3(0, 1, 0));
-        vertices.push_back(vec3(-1, 1, 1));
-        vertices.push_back(vec3(0, 1, 0));
-
-        // left
-        vertices.push_back(vec3(-1, 1, 1));
-        vertices.push_back(vec3(-1, 0, 0));
-        vertices.push_back(vec3(-1, 1, -1));
-        vertices.push_back(vec3(-1, 0, 0));
-        vertices.push_back(vec3(-1, -1, -1));
-        vertices.push_back(vec3(-1, 0, 0));
-        vertices.push_back(vec3(-1, -1, 1));
-        vertices.push_back(vec3(-1, 0, 0));
-
-        // bottom
-        vertices.push_back(vec3(-1, -1, -1));
-        vertices.push_back(vec3(0, -1, 0));
-        vertices.push_back(vec3(1, -1, -1));
-        vertices.push_back(vec3(0, -1, 0));
-        vertices.push_back(vec3(1, -1, 1));
-        vertices.push_back(vec3(0, -1, 0));
-        vertices.push_back(vec3(-1, -1, 1));
-        vertices.push_back(vec3(0, -1, 0));
-
-        // back
-        vertices.push_back(vec3(1, -1, -1));
-        vertices.push_back(vec3(0, 0, -1));
-        vertices.push_back(vec3(-1, -1, -1));
-        vertices.push_back(vec3(0, 0, -1));
-        vertices.push_back(vec3(-1, 1, -1));
-        vertices.push_back(vec3(0, 0, -1));
-        vertices.push_back(vec3(1, 1, -1));
-        vertices.push_back(vec3(0, 0, -1));
-
-        static const size_t VERTEX_FORMAT_SIZE = 2;
-        static const size_t VERTEX_OFFSET = 0;
-
-        for (size_t i = 0; i < vertices.size(); ++i) {
-            auto vertexIndex = i;
-            // Make a unit cube by having the vertices (at index N) 
-            // while leaving the normals (at index N + 1) alone
-            if (VERTEX_OFFSET == vertexIndex % VERTEX_FORMAT_SIZE) {
-                vertices[vertexIndex] *= 0.5f;
-            }
-        }
-        shapeData.setupVertices(_shapeVertices, vertices);
-
-        IndexVector indices{
-            0, 1, 2, 2, 3, 0, // front
-            4, 5, 6, 6, 7, 4, // right
-            8, 9, 10, 10, 11, 8, // top
-            12, 13, 14, 14, 15, 12, // left
-            16, 17, 18, 18, 19, 16, // bottom
-            20, 21, 22, 22, 23, 20  // back
-        };
-        for (auto& index : indices) {
-            index += (uint16_t)startingIndex;
-        }
-
-        IndexVector wireIndices{
-            0, 1, 1, 2, 2, 3, 3, 0, // front
-            20, 21, 21, 22, 22, 23, 23, 20, // back
-            0, 23, 1, 22, 2, 21, 3, 20 // sides
-        };
-
-        for (size_t i = 0; i < wireIndices.size(); ++i) {
-            indices[i] += (uint16_t)startingIndex;
-        }
-
-        shapeData.setupIndices(_shapeIndices, indices, wireIndices);
-    }
-
+    setupFlatShape(_shapes[Cube], cube(), _shapeVertices, _shapeIndices);
     // Tetrahedron
-    startingIndex = _shapeVertices->getSize() / SHAPE_VERTEX_STRIDE;
-    {
-        ShapeData& shapeData = _shapes[Tetrahedron];
-        size_t vertexCount = 4;
-        VertexVector vertices;
-        {
-            VertexVector originalVertices = tetrahedronVertices();
-            vertexCount = originalVertices.size();
-            vertices.reserve(originalVertices.size() * VECTOR_TO_VECTOR_WITH_NORMAL_MULTIPLER);
-            for (size_t i = 0; i < originalVertices.size(); i += VERTICES_PER_TRIANGLE) {
-                auto triangleStartIndex = i;
-                vec3 faceNormal;
-                for (size_t j = 0; j < VERTICES_PER_TRIANGLE; ++j) {
-                    auto triangleVertexIndex = j;
-                    auto vertexIndex = triangleStartIndex + triangleVertexIndex;
-                    faceNormal += originalVertices[vertexIndex];
-                }
-                faceNormal = glm::normalize(faceNormal);
-                for (size_t j = 0; j < VERTICES_PER_TRIANGLE; ++j) {
-                    auto triangleVertexIndex = j;
-                    auto vertexIndex = triangleStartIndex + triangleVertexIndex;
-                    vertices.push_back(originalVertices[vertexIndex]);
-                    vertices.push_back(faceNormal);
-                }
-            }
-        }
-        shapeData.setupVertices(_shapeVertices, vertices);
-
-        IndexVector indices;
-        for (size_t i = 0; i < vertexCount; i += VERTICES_PER_TRIANGLE) {
-            auto triangleStartIndex = i;
-            for (size_t j = 0; j < VERTICES_PER_TRIANGLE; ++j) {
-                auto triangleVertexIndex = j;
-                auto vertexIndex = triangleStartIndex + triangleVertexIndex;
-                indices.push_back((uint16_t)(vertexIndex + startingIndex));
-            }
-        }
-
-        IndexVector wireIndices{
-            0, 1, 1, 2, 2, 0,
-            0, 3, 1, 3, 2, 3,
-        };
-
-        for (size_t i = 0; i < wireIndices.size(); ++i) {
-            wireIndices[i] += (uint16_t)startingIndex;
-        }
-
-        shapeData.setupIndices(_shapeIndices, indices, wireIndices);
-    }
-
+    setupFlatShape(_shapes[Tetrahedron], tetrahedron(), _shapeVertices, _shapeIndices);
+    // Icosahedron
+    setupFlatShape(_shapes[Icosahedron], icosahedron(), _shapeVertices, _shapeIndices);
+    // Octahedron
+    setupFlatShape(_shapes[Octahedron], octahedron(), _shapeVertices, _shapeIndices);
+    // Dodecahedron
+    setupFlatShape(_shapes[Dodecahedron], dodecahedron(), _shapeVertices, _shapeIndices);
+    
     // Sphere
     // FIXME this uses way more vertices than required.  Should find a way to calculate the indices
     // using shared vertices for better vertex caching
-    startingIndex = _shapeVertices->getSize() / SHAPE_VERTEX_STRIDE;
-    {
-        ShapeData& shapeData = _shapes[Sphere];
-        VertexVector vertices;
-        IndexVector indices;
-        {
-            VertexVector originalVertices = tesselate(icosahedronVertices(), ICOSAHEDRON_TO_SPHERE_TESSELATION_COUNT);
-            vertices.reserve(originalVertices.size() * VECTOR_TO_VECTOR_WITH_NORMAL_MULTIPLER);
-            for (size_t i = 0; i < originalVertices.size(); i += VERTICES_PER_TRIANGLE) {
-                auto triangleStartIndex = i;
-                for (int j = 0; j < VERTICES_PER_TRIANGLE; ++j) {
-                    auto triangleVertexIndex = j;
-                    auto vertexIndex = triangleStartIndex + triangleVertexIndex;
-                    const auto& vertex = originalVertices[i + j];
-                    // Spheres use the same values for vertices and normals
-                    vertices.push_back(vertex);
-                    vertices.push_back(vertex);
-                    indices.push_back((uint16_t)(vertexIndex + startingIndex));
-                }
-            }
-        }
-        
-        shapeData.setupVertices(_shapeVertices, vertices);
-        // FIXME don't use solid indices for wire drawing.  
-        shapeData.setupIndices(_shapeIndices, indices, indices);
-    }
-
-    // Icosahedron
-    startingIndex = _shapeVertices->getSize() / SHAPE_VERTEX_STRIDE;
-    {
-        ShapeData& shapeData = _shapes[Icosahedron];
-
-        VertexVector vertices;
-        IndexVector indices;
-        {
-            const VertexVector& originalVertices = icosahedronVertices();
-            vertices.reserve(originalVertices.size() * VECTOR_TO_VECTOR_WITH_NORMAL_MULTIPLER);
-            for (size_t i = 0; i < originalVertices.size(); i += 3) {
-                auto triangleStartIndex = i;
-                vec3 faceNormal;
-                for (int j = 0; j < VERTICES_PER_TRIANGLE; ++j) {
-                    auto triangleVertexIndex = j;
-                    auto vertexIndex = triangleStartIndex + triangleVertexIndex;
-                    faceNormal += originalVertices[vertexIndex];
-                }
-                faceNormal = glm::normalize(faceNormal);
-                for (int j = 0; j < VERTICES_PER_TRIANGLE; ++j) {
-                    auto triangleVertexIndex = j;
-                    auto vertexIndex = triangleStartIndex + triangleVertexIndex;
-                    vertices.push_back(originalVertices[vertexIndex]);
-                    vertices.push_back(faceNormal);
-                    indices.push_back((uint16_t)(vertexIndex + startingIndex));
-                }
-            }
-        }
-
-        shapeData.setupVertices(_shapeVertices, vertices);
-        // FIXME don't use solid indices for wire drawing.  
-        shapeData.setupIndices(_shapeIndices, indices, indices);
-    }
+    Solid<3> sphere = icosahedron();
+    sphere = tesselate(sphere, ICOSAHEDRON_TO_SPHERE_TESSELATION_COUNT); 
+    sphere.fitDimension(1.0f);
+    setupSmoothShape(_shapes[Sphere], sphere, _shapeVertices, _shapeIndices);
 
     // Line
-    startingIndex = _shapeVertices->getSize() / SHAPE_VERTEX_STRIDE;
     {
+        Index baseVertex = (Index)(_shapeVertices->getSize() / SHAPE_VERTEX_STRIDE);
         ShapeData& shapeData = _shapes[Line];
         shapeData.setupVertices(_shapeVertices, VertexVector{
             vec3(-0.5, 0, 0), vec3(-0.5f, 0, 0),
@@ -460,9 +482,8 @@ void GeometryCache::buildShapes() {
         });
         IndexVector wireIndices;
         // Only two indices
-        wireIndices.push_back(0 + (uint16_t)startingIndex);
-        wireIndices.push_back(1 + (uint16_t)startingIndex);
-
+        wireIndices.push_back(0 + baseVertex);
+        wireIndices.push_back(1 + baseVertex);
         shapeData.setupIndices(_shapeIndices, IndexVector(), wireIndices);
     }
 
diff --git a/libraries/render-utils/src/GeometryCache.h b/libraries/render-utils/src/GeometryCache.h
index 7fa543abe2..a2f79de029 100644
--- a/libraries/render-utils/src/GeometryCache.h
+++ b/libraries/render-utils/src/GeometryCache.h
@@ -121,8 +121,8 @@ inline uint qHash(const Vec4PairVec4Pair& v, uint seed) {
                 seed);
 }
 
+using IndexVector = std::vector<uint32_t>;
 using VertexVector = std::vector<glm::vec3>;
-using IndexVector = std::vector<uint16_t>;
 
 /// Stores cached geometry.
 class GeometryCache : public Dependency {
@@ -137,7 +137,7 @@ public:
         Cube,
         Sphere,
         Tetrahedron,
-        Octahetron,
+        Octahedron,
         Dodecahedron,
         Icosahedron,
         Torus,
diff --git a/scripts/system/html/entityProperties.html b/scripts/system/html/entityProperties.html
index 4a3b5a14a4..c611fc5b38 100644
--- a/scripts/system/html/entityProperties.html
+++ b/scripts/system/html/entityProperties.html
@@ -1368,10 +1368,12 @@
         <div class="shape-group shape-section property dropdown">
             <label for="property-shape">Shape</label>
             <select name="SelectShape" id="property-shape">
-                <option value="Cube">Cube</option>
+                <option value="Cube">Box</option>
                 <option value="Sphere">Sphere</option>
-                <option value="Icosahedron">Icosahedron</option>
                 <option value="Tetrahedron">Tetrahedron</option>
+                <option value="Octahedron">Octahedron</option>
+                <option value="Icosahedron">Icosahedron</option>
+                <option value="Dodecahedron">Dodecahedron</option>
             </select>
         </div>
         <div class="shape-group shape-section property text">
diff --git a/tests/gpu-test/CMakeLists.txt b/tests/gpu-test/CMakeLists.txt
index 4fc6143ff5..21ae9c5a99 100644
--- a/tests/gpu-test/CMakeLists.txt
+++ b/tests/gpu-test/CMakeLists.txt
@@ -4,4 +4,6 @@ AUTOSCRIBE_SHADER_LIB(gpu model render-utils)
 setup_hifi_project(Quick Gui OpenGL Script Widgets)
 set_target_properties(${TARGET_NAME} PROPERTIES FOLDER "Tests/manual-tests/")
 link_hifi_libraries(networking gl gpu gpu-gl procedural shared fbx model model-networking animation script-engine render render-utils )
-package_libraries_for_deployment()
\ No newline at end of file
+package_libraries_for_deployment()
+
+target_nsight()
diff --git a/tests/gpu-test/src/TestHelpers.cpp b/tests/gpu-test/src/TestHelpers.cpp
new file mode 100644
index 0000000000..75586da904
--- /dev/null
+++ b/tests/gpu-test/src/TestHelpers.cpp
@@ -0,0 +1,20 @@
+//
+//  Created by Bradley Austin Davis on 2016/05/16
+//  Copyright 2014 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 "TestHelpers.h"
+
+gpu::ShaderPointer makeShader(const std::string & vertexShaderSrc, const std::string & fragmentShaderSrc, const gpu::Shader::BindingSet & bindings) {
+    auto vs = gpu::Shader::createVertex(vertexShaderSrc);
+    auto fs = gpu::Shader::createPixel(fragmentShaderSrc);
+    auto shader = gpu::Shader::createProgram(vs, fs);
+    if (!gpu::Shader::makeProgram(*shader, bindings)) {
+        printf("Could not compile shader\n");
+        exit(-1);
+    }
+    return shader;
+}
diff --git a/tests/gpu-test/src/TestHelpers.h b/tests/gpu-test/src/TestHelpers.h
new file mode 100644
index 0000000000..fd8989f628
--- /dev/null
+++ b/tests/gpu-test/src/TestHelpers.h
@@ -0,0 +1,33 @@
+//
+//  Created by Bradley Austin Davis on 2016/05/16
+//  Copyright 2014 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
+//
+
+#pragma once
+
+#include <vector>
+
+#include <GLMHelpers.h>
+#include <Transform.h>
+#include <GeometryCache.h>
+#include <NumericalConstants.h>
+
+#include <gpu/Resource.h>
+#include <gpu/Forward.h>
+#include <gpu/Shader.h>
+#include <gpu/Stream.h>
+
+class GpuTestBase {
+public:
+    virtual ~GpuTestBase() {}
+    virtual bool isReady() const { return true; }
+    virtual size_t getTestCount() const { return 1; }
+    virtual void renderTest(size_t test, RenderArgs* args) = 0;
+};
+
+uint32_t toCompactColor(const glm::vec4& color);
+gpu::ShaderPointer makeShader(const std::string & vertexShaderSrc, const std::string & fragmentShaderSrc, const gpu::Shader::BindingSet & bindings);
+
diff --git a/tests/gpu-test/src/TestInstancedShapes.cpp b/tests/gpu-test/src/TestInstancedShapes.cpp
new file mode 100644
index 0000000000..6a98ee58b9
--- /dev/null
+++ b/tests/gpu-test/src/TestInstancedShapes.cpp
@@ -0,0 +1,84 @@
+//
+//  Created by Bradley Austin Davis on 2016/05/16
+//  Copyright 2014 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 "TestInstancedShapes.h"
+
+gpu::Stream::FormatPointer& getInstancedSolidStreamFormat();
+
+static const size_t TYPE_COUNT = 4;
+static const size_t ITEM_COUNT = 50;
+static const float SHAPE_INTERVAL = (PI * 2.0f) / ITEM_COUNT;
+static const float ITEM_INTERVAL = SHAPE_INTERVAL / TYPE_COUNT;
+
+static GeometryCache::Shape SHAPE[TYPE_COUNT] = {
+    GeometryCache::Icosahedron,
+    GeometryCache::Cube,
+    GeometryCache::Sphere,
+    GeometryCache::Tetrahedron,
+};
+
+const gpu::Element POSITION_ELEMENT { gpu::VEC3, gpu::FLOAT, gpu::XYZ };
+const gpu::Element NORMAL_ELEMENT { gpu::VEC3, gpu::FLOAT, gpu::XYZ };
+const gpu::Element COLOR_ELEMENT { gpu::VEC4, gpu::NUINT8, gpu::RGBA };
+
+
+TestInstancedShapes::TestInstancedShapes() {
+    auto geometryCache = DependencyManager::get<GeometryCache>();
+    colorBuffer = std::make_shared<gpu::Buffer>();
+
+    static const float ITEM_RADIUS = 20;
+    static const vec3 ITEM_TRANSLATION { 0, 0, -ITEM_RADIUS };
+    for (size_t i = 0; i < TYPE_COUNT; ++i) {
+        GeometryCache::Shape shape = SHAPE[i];
+        GeometryCache::ShapeData shapeData = geometryCache->_shapes[shape];
+        //indirectCommand._count
+        float startingInterval = ITEM_INTERVAL * i;
+        std::vector<mat4> typeTransforms;
+        for (size_t j = 0; j < ITEM_COUNT; ++j) {
+            float theta = j * SHAPE_INTERVAL + startingInterval;
+            auto transform = glm::rotate(mat4(), theta, Vectors::UP);
+            transform = glm::rotate(transform, (randFloat() - 0.5f) * PI / 4.0f, Vectors::UNIT_X);
+            transform = glm::translate(transform, ITEM_TRANSLATION);
+            transform = glm::scale(transform, vec3(randFloat() / 2.0f + 0.5f));
+            typeTransforms.push_back(transform);
+            auto color = vec4 { randomColorValue(64), randomColorValue(64), randomColorValue(64), 255 };
+            color /= 255.0f;
+            colors.push_back(color);
+            colorBuffer->append(toCompactColor(color));
+        }
+        transforms.push_back(typeTransforms);
+    }
+}
+
+void TestInstancedShapes::renderTest(size_t testId, RenderArgs* args) {
+    gpu::Batch& batch = *(args->_batch);
+    auto geometryCache = DependencyManager::get<GeometryCache>();
+    geometryCache->bindSimpleProgram(batch);
+    batch.setInputFormat(getInstancedSolidStreamFormat());
+    for (size_t i = 0; i < TYPE_COUNT; ++i) {
+        GeometryCache::Shape shape = SHAPE[i];
+        GeometryCache::ShapeData shapeData = geometryCache->_shapes[shape];
+        
+        std::string namedCall = __FUNCTION__ + std::to_string(i);
+
+        //batch.addInstanceModelTransforms(transforms[i]);
+        for (size_t j = 0; j < ITEM_COUNT; ++j) {
+            batch.setModelTransform(transforms[i][j]);
+            batch.setupNamedCalls(namedCall, [=](gpu::Batch& batch, gpu::Batch::NamedBatchData&) {
+                batch.setInputBuffer(gpu::Stream::COLOR, gpu::BufferView(colorBuffer, i * ITEM_COUNT * 4, colorBuffer->getSize(), COLOR_ELEMENT));
+                shapeData.drawInstances(batch, ITEM_COUNT);
+            });
+        }
+
+        //for (size_t j = 0; j < ITEM_COUNT; ++j) {
+        //    batch.setModelTransform(transforms[j + i * ITEM_COUNT]);
+        //    shapeData.draw(batch);
+        //}
+    }
+}
+
diff --git a/tests/gpu-test/src/TestInstancedShapes.h b/tests/gpu-test/src/TestInstancedShapes.h
new file mode 100644
index 0000000000..b509a13e60
--- /dev/null
+++ b/tests/gpu-test/src/TestInstancedShapes.h
@@ -0,0 +1,23 @@
+//
+//  Created by Bradley Austin Davis on 2016/05/16
+//  Copyright 2014 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
+//
+
+#pragma once
+
+#include "TestHelpers.h"
+
+class TestInstancedShapes : public GpuTestBase {
+
+    std::vector<std::vector<mat4>> transforms;
+    std::vector<vec4> colors;
+    gpu::BufferPointer colorBuffer;
+    gpu::BufferView instanceXfmView;
+public:
+    TestInstancedShapes();
+    void renderTest(size_t testId, RenderArgs* args) override;
+};
+
diff --git a/tests/gpu-test/src/TestShapes.cpp b/tests/gpu-test/src/TestShapes.cpp
new file mode 100644
index 0000000000..253d89cf61
--- /dev/null
+++ b/tests/gpu-test/src/TestShapes.cpp
@@ -0,0 +1,48 @@
+//
+//  Created by Bradley Austin Davis on 2016/05/16
+//  Copyright 2014 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 "TestShapes.h"
+
+static const size_t TYPE_COUNT = 6;
+
+static GeometryCache::Shape SHAPE[TYPE_COUNT] = {
+    GeometryCache::Cube,
+    GeometryCache::Tetrahedron,
+    GeometryCache::Octahedron,
+    GeometryCache::Dodecahedron,
+    GeometryCache::Icosahedron,
+    GeometryCache::Sphere,
+};
+
+void TestShapes::renderTest(size_t testId, RenderArgs* args) {
+    gpu::Batch& batch = *(args->_batch);
+    auto geometryCache = DependencyManager::get<GeometryCache>();
+    geometryCache->bindSimpleProgram(batch);
+
+    // Render unlit cube + sphere
+    static auto startSecs = secTimestampNow();
+    float seconds = secTimestampNow() - startSecs;
+    seconds /= 4.0f;
+    batch.setModelTransform(Transform());
+    batch._glColor4f(0.8f, 0.25f, 0.25f, 1.0f);
+
+    bool wire = (seconds - floorf(seconds) > 0.5f);
+    int shapeIndex = ((int)seconds) % TYPE_COUNT;
+    if (wire) {
+        geometryCache->renderWireShape(batch, SHAPE[shapeIndex]);
+    } else {
+        geometryCache->renderShape(batch, SHAPE[shapeIndex]);
+    }
+
+    batch.setModelTransform(Transform().setScale(1.01f));
+    batch._glColor4f(1, 1, 1, 1);
+    geometryCache->renderWireCube(batch);
+}
+
+
+
diff --git a/tests/gpu-test/src/TestShapes.h b/tests/gpu-test/src/TestShapes.h
new file mode 100644
index 0000000000..606d3a45f7
--- /dev/null
+++ b/tests/gpu-test/src/TestShapes.h
@@ -0,0 +1,22 @@
+//
+//  Created by Bradley Austin Davis on 2016/05/16
+//  Copyright 2014 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
+//
+
+#pragma once
+
+#include "TestHelpers.h"
+
+class TestShapes : public GpuTestBase {
+
+    std::vector<std::vector<mat4>> transforms;
+    std::vector<vec4> colors;
+    gpu::BufferPointer colorBuffer;
+    gpu::BufferView instanceXfmView;
+public:
+    void renderTest(size_t testId, RenderArgs* args) override;
+};
+
diff --git a/tests/gpu-test/src/TestWindow.cpp b/tests/gpu-test/src/TestWindow.cpp
new file mode 100644
index 0000000000..4fe25e989d
--- /dev/null
+++ b/tests/gpu-test/src/TestWindow.cpp
@@ -0,0 +1,180 @@
+//
+//  Created by Bradley Austin Davis on 2016/05/16
+//  Copyright 2014 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 "TestWindow.h"
+
+#include <glm/glm.hpp>
+#include <glm/gtc/matrix_transform.hpp>
+
+#include <QtCore/QTimer>
+#include <QtGui/QResizeEvent>
+
+#include <gl/GLHelpers.h>
+#include <gl/QOpenGLDebugLoggerWrapper.h>
+
+#include <gpu/gl/GLBackend.h>
+
+#include <GeometryCache.h>
+#include <DeferredLightingEffect.h>
+#include <FramebufferCache.h>
+#include <TextureCache.h>
+
+#ifdef DEFERRED_LIGHTING
+extern void initDeferredPipelines(render::ShapePlumber& plumber);
+extern void initStencilPipeline(gpu::PipelinePointer& pipeline);
+#endif
+
+TestWindow::TestWindow() {
+    setSurfaceType(QSurface::OpenGLSurface);
+
+
+    auto timer = new QTimer(this);
+    timer->setInterval(5);
+    connect(timer, &QTimer::timeout, [&] { draw(); });
+    timer->start();
+
+    connect(qApp, &QCoreApplication::aboutToQuit, [this, timer] {
+        timer->stop();
+        _aboutToQuit = true;
+    });
+
+#ifdef DEFERRED_LIGHTING
+    _light->setType(model::Light::SUN);
+    _light->setAmbientSpherePreset(gpu::SphericalHarmonics::Preset::OLD_TOWN_SQUARE);
+    _light->setIntensity(1.0f);
+    _light->setAmbientIntensity(0.5f);
+    _light->setColor(vec3(1.0f));
+    _light->setPosition(vec3(1, 1, 1));
+    _renderContext->args = _renderArgs;
+#endif
+
+    QSurfaceFormat format = getDefaultOpenGLSurfaceFormat();
+    format.setOption(QSurfaceFormat::DebugContext);
+    //format.setSwapInterval(0);
+    setFormat(format);
+    _glContext.setFormat(format);
+    _glContext.create();
+    _glContext.makeCurrent(this);
+    show();
+}
+
+void TestWindow::initGl() {
+    _glContext.makeCurrent(this);
+    gpu::Context::init<gpu::gl::GLBackend>();
+    _renderArgs->_context = std::make_shared<gpu::Context>();
+    _glContext.makeCurrent(this);
+    DependencyManager::set<GeometryCache>();
+    DependencyManager::set<TextureCache>();
+    DependencyManager::set<FramebufferCache>();
+    DependencyManager::set<DeferredLightingEffect>();
+    resize(QSize(800, 600));
+
+    setupDebugLogger(this);
+#ifdef DEFERRED_LIGHTING
+    auto deferredLightingEffect = DependencyManager::get<DeferredLightingEffect>();
+    deferredLightingEffect->init();
+    deferredLightingEffect->setGlobalLight(_light);
+    initDeferredPipelines(*_shapePlumber);
+    initStencilPipeline(_opaquePipeline);
+#endif
+}
+
+void TestWindow::resizeWindow(const QSize& size) {
+    _size = size;
+    _renderArgs->_viewport = ivec4(0, 0, _size.width(), _size.height());
+    auto fboCache = DependencyManager::get<FramebufferCache>();
+    if (fboCache) {
+        fboCache->setFrameBufferSize(_size);
+    }
+}
+
+void TestWindow::beginFrame() {
+    _renderArgs->_context->syncCache();
+
+#ifdef DEFERRED_LIGHTING
+    auto deferredLightingEffect = DependencyManager::get<DeferredLightingEffect>();
+    deferredLightingEffect->prepare(_renderArgs);
+#else
+    gpu::doInBatch(_renderArgs->_context, [&](gpu::Batch& batch) {
+        batch.clearColorFramebuffer(gpu::Framebuffer::BUFFER_COLORS, { 0.0f, 0.1f, 0.2f, 1.0f });
+        batch.clearDepthFramebuffer(1e4);
+        batch.setViewportTransform({ 0, 0, _size.width() * devicePixelRatio(), _size.height() * devicePixelRatio() });
+    });
+#endif
+
+    gpu::doInBatch(_renderArgs->_context, [&](gpu::Batch& batch) {
+        batch.setViewportTransform(_renderArgs->_viewport);
+        batch.setStateScissorRect(_renderArgs->_viewport);
+        batch.setProjectionTransform(_projectionMatrix);
+    });
+}
+
+void TestWindow::endFrame() {
+#ifdef DEFERRED_LIGHTING
+    RenderArgs* args = _renderContext->args;
+    gpu::doInBatch(args->_context, [&](gpu::Batch& batch) {
+        args->_batch = &batch;
+        auto deferredFboColorDepthStencil = DependencyManager::get<FramebufferCache>()->getDeferredFramebufferDepthColor();
+        batch.setViewportTransform(args->_viewport);
+        batch.setStateScissorRect(args->_viewport);
+        batch.setFramebuffer(deferredFboColorDepthStencil);
+        batch.setPipeline(_opaquePipeline);
+        batch.draw(gpu::TRIANGLE_STRIP, 4);
+        batch.setResourceTexture(0, nullptr);
+    });
+
+    auto deferredLightingEffect = DependencyManager::get<DeferredLightingEffect>();
+    deferredLightingEffect->render(_renderContext);
+
+    gpu::doInBatch(_renderArgs->_context, [&](gpu::Batch& batch) {
+        PROFILE_RANGE_BATCH(batch, "blit");
+        // Blit to screen
+        auto framebufferCache = DependencyManager::get<FramebufferCache>();
+        auto framebuffer = framebufferCache->getLightingFramebuffer();
+        batch.blit(framebuffer, _renderArgs->_viewport, nullptr, _renderArgs->_viewport);
+    });
+#endif
+
+    gpu::doInBatch(_renderArgs->_context, [&](gpu::Batch& batch) {
+        batch.resetStages();
+    });
+    _glContext.swapBuffers(this);
+}
+
+void TestWindow::draw() {
+    if (_aboutToQuit) {
+        return;
+    }
+
+    // Attempting to draw before we're visible and have a valid size will
+    // produce GL errors.
+    if (!isVisible() || _size.width() <= 0 || _size.height() <= 0) {
+        return;
+    }
+
+    if (!_glContext.makeCurrent(this)) {
+        return;
+    }
+
+    static std::once_flag once;
+    std::call_once(once, [&] { initGl(); });
+    beginFrame();
+
+    renderFrame();
+
+    endFrame();
+}
+
+void TestWindow::resizeEvent(QResizeEvent* ev) {
+    resizeWindow(ev->size());
+    float fov_degrees = 60.0f;
+    float aspect_ratio = (float)_size.width() / _size.height();
+    float near_clip = 0.1f;
+    float far_clip = 1000.0f;
+    _projectionMatrix = glm::perspective(glm::radians(fov_degrees), aspect_ratio, near_clip, far_clip);
+}
diff --git a/tests/gpu-test/src/TestWindow.h b/tests/gpu-test/src/TestWindow.h
new file mode 100644
index 0000000000..b7f8df48f5
--- /dev/null
+++ b/tests/gpu-test/src/TestWindow.h
@@ -0,0 +1,53 @@
+//
+//  Created by Bradley Austin Davis on 2016/05/16
+//  Copyright 2014 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
+//
+
+#pragma once
+
+#include <QtGui/QWindow>
+#include <QtCore/QTime>
+
+#include <GLMHelpers.h>
+#include <gl/QOpenGLContextWrapper.h>
+#include <gpu/Forward.h>
+
+#include <DeferredLightingEffect.h>
+#include <render/ShapePipeline.h>
+#include <render/Context.h>
+
+#define DEFERRED_LIGHTING
+
+class TestWindow : public QWindow {
+protected:
+    QOpenGLContextWrapper _glContext;
+    QSize _size;
+    glm::mat4 _projectionMatrix;
+    bool _aboutToQuit { false };
+
+#ifdef DEFERRED_LIGHTING
+    // Prepare the ShapePipelines
+    render::ShapePlumberPointer _shapePlumber { std::make_shared<render::ShapePlumber>() };
+    render::RenderContextPointer _renderContext { std::make_shared<render::RenderContext>() };
+    gpu::PipelinePointer _opaquePipeline;
+    model::LightPointer _light { std::make_shared<model::Light>() };
+#endif
+
+    RenderArgs* _renderArgs { new RenderArgs() };
+
+    TestWindow();
+    virtual void initGl();
+    virtual void renderFrame() = 0;
+
+private:
+    void resizeWindow(const QSize& size);
+
+    void beginFrame();
+    void endFrame();
+    void draw();
+    void resizeEvent(QResizeEvent* ev) override;
+};
+
diff --git a/tests/gpu-test/src/main.cpp b/tests/gpu-test/src/main.cpp
index b80539b33a..e672fe3c86 100644
--- a/tests/gpu-test/src/main.cpp
+++ b/tests/gpu-test/src/main.cpp
@@ -42,238 +42,64 @@
 
 #include <GeometryCache.h>
 #include <DeferredLightingEffect.h>
+#include <FramebufferCache.h>
 #include <TextureCache.h>
+#include <PerfStat.h>
+#include <PathUtils.h>
+#include <RenderArgs.h>
+#include <ViewFrustum.h>
 
-#include "unlit_frag.h"
-#include "unlit_vert.h"
+#include <gpu/Pipeline.h>
+#include <gpu/Context.h>
 
-class RateCounter {
-    std::vector<float> times;
-    QElapsedTimer timer;
-public:
-    RateCounter() {
-        timer.start();
-    }
+#include <render/Engine.h>
+#include <render/Scene.h>
+#include <render/CullTask.h>
+#include <render/SortTask.h>
+#include <render/DrawTask.h>
+#include <render/DrawStatus.h>
+#include <render/DrawSceneOctree.h>
+#include <render/CullTask.h>
 
-    void reset() {
-        times.clear();
-    }
+#include "TestWindow.h"
+#include "TestInstancedShapes.h"
+#include "TestShapes.h"
 
-    unsigned int count() const {
-        return (unsigned int)times.size() - 1;
-    }
-
-    float elapsed() const {
-        if (times.size() < 1) {
-            return 0.0f;
-        }
-        float elapsed = *times.rbegin() - *times.begin();
-        return elapsed;
-    }
-
-    void increment() {
-        times.push_back(timer.elapsed() / 1000.0f);
-    }
-
-    float rate() const {
-        if (elapsed() == 0.0f) {
-            return NAN;
-        }
-        return (float) count() / elapsed();
-    }
-};
-
-uint32_t toCompactColor(const glm::vec4& color);
+using namespace render;
 
 
-const char* VERTEX_SHADER = R"SHADER(
-
-layout(location = 0) in vec4 inPosition;
-layout(location = 3) in vec2 inTexCoord0;
-
-struct TransformObject {
-    mat4 _model;
-    mat4 _modelInverse;
-};
-
-layout(location=15) in ivec2 _drawCallInfo;
-
-uniform samplerBuffer transformObjectBuffer;
-
-TransformObject getTransformObject() {
-    int offset = 8 * _drawCallInfo.x;
-    TransformObject object;
-    object._model[0] = texelFetch(transformObjectBuffer, offset);
-    object._model[1] = texelFetch(transformObjectBuffer, offset + 1);
-    object._model[2] = texelFetch(transformObjectBuffer, offset + 2);
-    object._model[3] = texelFetch(transformObjectBuffer, offset + 3);
-
-    object._modelInverse[0] = texelFetch(transformObjectBuffer, offset + 4);
-    object._modelInverse[1] = texelFetch(transformObjectBuffer, offset + 5);
-    object._modelInverse[2] = texelFetch(transformObjectBuffer, offset + 6);
-    object._modelInverse[3] = texelFetch(transformObjectBuffer, offset + 7);
-
-    return object;
-}
-
-struct TransformCamera {
-    mat4 _view;
-    mat4 _viewInverse;
-    mat4 _projectionViewUntranslated;
-    mat4 _projection;
-    mat4 _projectionInverse;
-    vec4 _viewport;
-};
-
-layout(std140) uniform transformCameraBuffer {
-    TransformCamera _camera;
-};
-
-TransformCamera getTransformCamera() {
-    return _camera;
-}
-
-// the interpolated normal
-out vec2 _texCoord0;
-
-void main(void) {
-    _texCoord0 = inTexCoord0.st;
-
-    // standard transform
-    TransformCamera cam = getTransformCamera();
-    TransformObject obj = getTransformObject();
-    { // transformModelToClipPos
-        vec4 eyeWAPos;
-        { // _transformModelToEyeWorldAlignedPos
-            highp mat4 _mv = obj._model;
-            _mv[3].xyz -= cam._viewInverse[3].xyz;
-            highp vec4 _eyeWApos = (_mv * inPosition);
-            eyeWAPos = _eyeWApos;
-        }
-        gl_Position = cam._projectionViewUntranslated * eyeWAPos;
-    }
-
-})SHADER";
-
-const char* FRAGMENT_SHADER = R"SHADER(
-
-uniform sampler2D originalTexture;
-
-in vec2 _texCoord0;
-
-layout(location = 0) out vec4 _fragColor0;
-
-void main(void) {
-    //_fragColor0 = vec4(_texCoord0, 0.0, 1.0);
-    _fragColor0 = texture(originalTexture, _texCoord0);
-}
-)SHADER";
+using TestBuilder = std::function<GpuTestBase*()>;
+using TestBuilders = std::list<TestBuilder>;
 
 
-gpu::ShaderPointer makeShader(const std::string & vertexShaderSrc, const std::string & fragmentShaderSrc, const gpu::Shader::BindingSet & bindings) {
-    auto vs = gpu::Shader::createVertex(vertexShaderSrc);
-    auto fs = gpu::Shader::createPixel(fragmentShaderSrc);
-    auto shader = gpu::Shader::createProgram(vs, fs);
-    if (!gpu::Shader::makeProgram(*shader, bindings)) {
-        printf("Could not compile shader\n");
-        exit(-1);
-    }
-    return shader;
-}
+#define INTERACTIVE
 
-float getSeconds(quint64 start = 0) {
-    auto usecs = usecTimestampNow() - start;
-    auto msecs = usecs / USECS_PER_MSEC;
-    float seconds = (float)msecs / MSECS_PER_SECOND;
-    return seconds;
-}
-
-static const size_t TYPE_COUNT = 4;
-static GeometryCache::Shape SHAPE[TYPE_COUNT] = {
-    GeometryCache::Icosahedron,
-    GeometryCache::Cube,
-    GeometryCache::Sphere,
-    GeometryCache::Tetrahedron,
-    //GeometryCache::Line,
-};
-
-gpu::Stream::FormatPointer& getInstancedSolidStreamFormat();
-
-// Creates an OpenGL window that renders a simple unlit scene using the gpu library and GeometryCache
-// Should eventually get refactored into something that supports multiple gpu backends.
-class QTestWindow : public QWindow {
-    Q_OBJECT
-
-    QOpenGLContextWrapper _qGlContext;
-    QSize _size;
-    
-    gpu::ContextPointer _context;
-    gpu::PipelinePointer _pipeline;
-    glm::mat4 _projectionMatrix;
-    RateCounter fps;
-    QTime _time;
+class MyTestWindow : public TestWindow {
+    using Parent = TestWindow;
+    TestBuilders _testBuilders;
+    GpuTestBase* _currentTest { nullptr };
+    size_t _currentTestId { 0 };
+    size_t _currentMaxTests { 0 };
     glm::mat4 _camera;
+    QTime _time;
 
-protected:
-    void renderText();
-
-private:
-    void resizeWindow(const QSize& size) {
-        _size = size;
-    }
-
-public:
-    QTestWindow() {
-        setSurfaceType(QSurface::OpenGLSurface);
-
-        QSurfaceFormat format;
-        // Qt Quick may need a depth and stencil buffer. Always make sure these are available.
-        format.setDepthBufferSize(16);
-        format.setStencilBufferSize(8);
-        setGLFormatVersion(format);
-        format.setProfile(QSurfaceFormat::OpenGLContextProfile::CoreProfile);
-        format.setOption(QSurfaceFormat::DebugContext);
-        //format.setSwapInterval(0);
-
-        setFormat(format);
-
-        _qGlContext.setFormat(format);
-        _qGlContext.create();
-
-        show();
-        makeCurrent();
-        setupDebugLogger(this);
-
-        gpu::Context::init<gpu::gl::GLBackend>();
-        _context = std::make_shared<gpu::Context>();
-        makeCurrent();
-        auto shader = makeShader(unlit_vert, unlit_frag, gpu::Shader::BindingSet{});
-        auto state = std::make_shared<gpu::State>();
-        state->setMultisampleEnable(true);
-        state->setDepthTest(gpu::State::DepthTest { true });
-        _pipeline = gpu::Pipeline::create(shader, state);
-        
-
-
-        // Clear screen
-        gpu::Batch batch;
-        batch.clearColorFramebuffer(gpu::Framebuffer::BUFFER_COLORS, { 1.0, 0.0, 0.5, 1.0 });
-        _context->render(batch);
-        
-        DependencyManager::set<GeometryCache>();
-        DependencyManager::set<TextureCache>();
-        DependencyManager::set<DeferredLightingEffect>();
-
-        resize(QSize(800, 600));
-        
+    void initGl() override {
+        Parent::initGl();
+#ifdef INTERACTIVE
         _time.start();
-    }
-
-    virtual ~QTestWindow() {
+#endif
+        updateCamera();
+        _testBuilders = TestBuilders({
+            //[this] { return new TestFbx(_shapePlumber); },
+            [] { return new TestShapes(); },
+        });
     }
 
     void updateCamera() {
-        float t = _time.elapsed() * 1e-4f;
+        float t = 0;
+#ifdef INTERACTIVE
+        t = _time.elapsed() * 1e-3f;
+#endif
         glm::vec3 unitscale { 1.0f };
         glm::vec3 up { 0.0f, 1.0f, 0.0f };
 
@@ -283,263 +109,64 @@ public:
         static const vec3 camera_focus(0);
         static const vec3 camera_up(0, 1, 0);
         _camera = glm::inverse(glm::lookAt(camera_position, camera_focus, up));
+
+        ViewFrustum frustum;
+        frustum.setPosition(camera_position);
+        frustum.setOrientation(glm::quat_cast(_camera));
+        frustum.setProjection(_projectionMatrix);
+        _renderArgs->setViewFrustum(frustum);
     }
 
+    void renderFrame() override {
+        updateCamera();
 
-    void drawFloorGrid(gpu::Batch& batch) {
-        auto geometryCache = DependencyManager::get<GeometryCache>();
-        // Render grid on xz plane (not the optimal way to do things, but w/e)
-        // Note: GeometryCache::renderGrid will *not* work, as it is apparenly unaffected by batch rotations and renders xy only
-        static const std::string GRID_INSTANCE = "Grid";
-        static auto compactColor1 = toCompactColor(vec4 { 0.35f, 0.25f, 0.15f, 1.0f });
-        static auto compactColor2 = toCompactColor(vec4 { 0.15f, 0.25f, 0.35f, 1.0f });
-        static std::vector<glm::mat4> transforms;
-        static gpu::BufferPointer colorBuffer;
-        if (!transforms.empty()) {
-            transforms.reserve(200);
-            colorBuffer = std::make_shared<gpu::Buffer>();
-            for (int i = 0; i < 100; ++i) {
-                {
-                    glm::mat4 transform = glm::translate(mat4(), vec3(0, -1, -50 + i));
-                    transform = glm::scale(transform, vec3(100, 1, 1));
-                    transforms.push_back(transform);
-                    colorBuffer->append(compactColor1);
-                }
+        while ((!_currentTest || (_currentTestId >= _currentMaxTests)) && !_testBuilders.empty()) {
+            if (_currentTest) {
+                delete _currentTest;
+                _currentTest = nullptr;
+            }
 
-                {
-                    glm::mat4 transform = glm::mat4_cast(quat(vec3(0, PI / 2.0f, 0)));
-                    transform = glm::translate(transform, vec3(0, -1, -50 + i));
-                    transform = glm::scale(transform, vec3(100, 1, 1));
-                    transforms.push_back(transform);
-                    colorBuffer->append(compactColor2);
-                }
+            _currentTest = _testBuilders.front()();
+            _testBuilders.pop_front();
+
+            if (_currentTest) {
+                _currentMaxTests = _currentTest->getTestCount();
+                _currentTestId = 0;
             }
         }
-        auto pipeline = geometryCache->getSimplePipeline();
-        for (auto& transform : transforms) {
-            batch.setModelTransform(transform);
-            batch.setupNamedCalls(GRID_INSTANCE, [=](gpu::Batch& batch, gpu::Batch::NamedBatchData& data) {
-                batch.setViewTransform(_camera);
-                batch.setPipeline(_pipeline);
-                geometryCache->renderWireShapeInstances(batch, GeometryCache::Line, data.count(), colorBuffer);
-            });
-        }
-    }
 
-    void drawSimpleShapes(gpu::Batch& batch) {
-        auto geometryCache = DependencyManager::get<GeometryCache>();
-        static const size_t ITEM_COUNT = 1000;
-        static const float SHAPE_INTERVAL = (PI * 2.0f) / ITEM_COUNT;
-        static const float ITEM_INTERVAL = SHAPE_INTERVAL / TYPE_COUNT;
-
-        static const gpu::Element POSITION_ELEMENT { gpu::VEC3, gpu::FLOAT, gpu::XYZ };
-        static const gpu::Element NORMAL_ELEMENT { gpu::VEC3, gpu::FLOAT, gpu::XYZ };
-        static const gpu::Element COLOR_ELEMENT { gpu::VEC4, gpu::NUINT8, gpu::RGBA };
-
-        static std::vector<Transform> transforms;
-        static std::vector<vec4> colors;
-        static gpu::BufferPointer colorBuffer;
-        static gpu::BufferView colorView;
-        static gpu::BufferView instanceXfmView;
-        if (!colorBuffer) {
-            colorBuffer = std::make_shared<gpu::Buffer>();
-
-            static const float ITEM_RADIUS = 20;
-            static const vec3 ITEM_TRANSLATION { 0, 0, -ITEM_RADIUS };
-            for (size_t i = 0; i < TYPE_COUNT; ++i) {
-                GeometryCache::Shape shape = SHAPE[i];
-                GeometryCache::ShapeData shapeData = geometryCache->_shapes[shape];
-                //indirectCommand._count
-                float startingInterval = ITEM_INTERVAL * i;
-                for (size_t j = 0; j < ITEM_COUNT; ++j) {
-                    float theta = j * SHAPE_INTERVAL + startingInterval;
-                    auto transform = glm::rotate(mat4(), theta, Vectors::UP);
-                    transform = glm::rotate(transform, (randFloat() - 0.5f) * PI / 4.0f, Vectors::UNIT_X);
-                    transform = glm::translate(transform, ITEM_TRANSLATION);
-                    transform = glm::scale(transform, vec3(randFloat() / 2.0f + 0.5f));
-                    transforms.push_back(transform);
-                    auto color = vec4 { randomColorValue(64), randomColorValue(64), randomColorValue(64), 255 };
-                    color /= 255.0f;
-                    colors.push_back(color);
-                    colorBuffer->append(toCompactColor(color));
-                }
-            }
-            colorView = gpu::BufferView(colorBuffer, COLOR_ELEMENT);
-        }
-
-        batch.setViewTransform(_camera);
-        batch.setPipeline(_pipeline);
-        batch.setInputFormat(getInstancedSolidStreamFormat());
-        for (size_t i = 0; i < TYPE_COUNT; ++i) {
-            GeometryCache::Shape shape = SHAPE[i];
-            GeometryCache::ShapeData shapeData = geometryCache->_shapes[shape];
-            batch.setInputBuffer(gpu::Stream::COLOR, colorView);
-            for (size_t j = 0; j < ITEM_COUNT; ++j) {
-                batch.setModelTransform(transforms[j]);
-                shapeData.draw(batch);
-            }
-        }
-    }
-
-    void drawCenterShape(gpu::Batch& batch) {
-        // Render unlit cube + sphere
-        static auto startUsecs = usecTimestampNow();
-        float seconds = getSeconds(startUsecs);
-        seconds /= 4.0f;
-        batch.setModelTransform(Transform());
-        batch._glColor4f(0.8f, 0.25f, 0.25f, 1.0f);
-
-        bool wire = (seconds - floorf(seconds) > 0.5f);
-        auto geometryCache = DependencyManager::get<GeometryCache>();
-        int shapeIndex = ((int)seconds) % TYPE_COUNT;
-        if (wire) {
-            geometryCache->renderWireShape(batch, SHAPE[shapeIndex]);
-        } else {
-            geometryCache->renderShape(batch, SHAPE[shapeIndex]);
-        }
-
-        batch.setModelTransform(Transform().setScale(2.05f));
-        batch._glColor4f(1, 1, 1, 1);
-        geometryCache->renderWireCube(batch);
-    }
-
-    void drawTerrain(gpu::Batch& batch) {
-        auto geometryCache = DependencyManager::get<GeometryCache>();
-        static std::once_flag once;
-        static gpu::BufferPointer vertexBuffer { std::make_shared<gpu::Buffer>() };
-        static gpu::BufferPointer indexBuffer { std::make_shared<gpu::Buffer>() };
-
-        static gpu::BufferView positionView;
-        static gpu::BufferView textureView;
-        static gpu::Stream::FormatPointer vertexFormat { std::make_shared<gpu::Stream::Format>() };
-
-        static gpu::TexturePointer texture;
-        static gpu::PipelinePointer pipeline;
-        std::call_once(once, [&] {
-            static const uint SHAPE_VERTEX_STRIDE = sizeof(glm::vec4) * 2; // position, normals, textures
-            static const uint SHAPE_TEXTURES_OFFSET = sizeof(glm::vec4);
-            static const gpu::Element POSITION_ELEMENT { gpu::VEC3, gpu::FLOAT, gpu::XYZ };
-            static const gpu::Element TEXTURE_ELEMENT { gpu::VEC2, gpu::FLOAT, gpu::UV };
-            std::vector<vec4> vertices;
-            const int MINX = -1000;
-            const int MAXX = 1000;
-
-            // top
-            vertices.push_back(vec4(MAXX, 0, MAXX, 1));
-            vertices.push_back(vec4(MAXX, MAXX, 0, 0));
-
-            vertices.push_back(vec4(MAXX, 0, MINX, 1));
-            vertices.push_back(vec4(MAXX, 0, 0, 0));
-
-            vertices.push_back(vec4(MINX, 0, MINX, 1));
-            vertices.push_back(vec4(0, 0, 0, 0));
-
-            vertices.push_back(vec4(MINX, 0, MAXX, 1));
-            vertices.push_back(vec4(0, MAXX, 0, 0));
-
-            vertexBuffer->append(vertices);
-            indexBuffer->append(std::vector<uint16_t>({ 0, 1, 2, 2, 3, 0 }));
-
-            positionView = gpu::BufferView(vertexBuffer, 0, vertexBuffer->getSize(), SHAPE_VERTEX_STRIDE, POSITION_ELEMENT);
-            textureView = gpu::BufferView(vertexBuffer, SHAPE_TEXTURES_OFFSET, vertexBuffer->getSize(), SHAPE_VERTEX_STRIDE, TEXTURE_ELEMENT);
-            texture = DependencyManager::get<TextureCache>()->getImageTexture("C:/Users/bdavis/Git/openvr/samples/bin/cube_texture.png");
-            // texture = DependencyManager::get<TextureCache>()->getImageTexture("H:/test.png");
-            //texture = DependencyManager::get<TextureCache>()->getImageTexture("H:/crate_blue.fbm/lambert8SG_Normal_OpenGL.png");
-
-            auto shader = makeShader(VERTEX_SHADER, FRAGMENT_SHADER, gpu::Shader::BindingSet {});
-            auto state = std::make_shared<gpu::State>();
-            state->setMultisampleEnable(false);
-            state->setDepthTest(gpu::State::DepthTest { true });
-            pipeline = gpu::Pipeline::create(shader, state);
-            vertexFormat->setAttribute(gpu::Stream::POSITION);
-            vertexFormat->setAttribute(gpu::Stream::TEXCOORD);
-        });
-
-        static auto start = usecTimestampNow();
-        auto now = usecTimestampNow();
-        if ((now - start) > USECS_PER_SECOND * 1) {
-            start = now;
-            texture->incremementMinMip();
-        }
-
-        batch.setPipeline(pipeline);
-        batch.setInputBuffer(gpu::Stream::POSITION, positionView);
-        batch.setInputBuffer(gpu::Stream::TEXCOORD, textureView);
-        batch.setIndexBuffer(gpu::UINT16, indexBuffer, 0);
-        batch.setInputFormat(vertexFormat);
-
-        batch.setResourceTexture(0, texture);
-        batch.setModelTransform(glm::translate(glm::mat4(), vec3(0, -0.1, 0)));
-        batch.drawIndexed(gpu::TRIANGLES, 6, 0);
-
-        batch.setResourceTexture(0, DependencyManager::get<TextureCache>()->getBlueTexture());
-        batch.setModelTransform(glm::translate(glm::mat4(), vec3(0, -0.2, 0)));
-        batch.drawIndexed(gpu::TRIANGLES, 6, 0);
-    }
-
-    void draw() {
-        // Attempting to draw before we're visible and have a valid size will
-        // produce GL errors.
-        if (!isVisible() || _size.width() <= 0 || _size.height() <= 0) {
+        if (!_currentTest && _testBuilders.empty()) {
+            qApp->quit();
             return;
         }
-        updateCamera();
-        makeCurrent();
-        
-        gpu::Batch batch;
-        batch.resetStages();
-        batch.clearColorFramebuffer(gpu::Framebuffer::BUFFER_COLORS, { 0.0f, 0.1f, 0.2f, 1.0f });
-        batch.clearDepthFramebuffer(1e4);
-        batch.setViewportTransform({ 0, 0, _size.width() * devicePixelRatio(), _size.height() * devicePixelRatio() });
-        batch.setProjectionTransform(_projectionMatrix);
-        
-        batch.setViewTransform(_camera);
-        batch.setPipeline(_pipeline);
-        batch.setModelTransform(Transform());
 
-        //drawFloorGrid(batch);
-        //drawSimpleShapes(batch);
-        //drawCenterShape(batch);
-        drawTerrain(batch);
-
-        _context->render(batch);
-        _qGlContext.swapBuffers(this);
-        
-        fps.increment();
-        if (fps.elapsed() >= 0.5f) {
-            qDebug() << "FPS: " << fps.rate();
-            fps.reset();
+        // Tests might need to wait for resources to download
+        if (!_currentTest->isReady()) {
+            return;
         }
-    }
-    
-    void makeCurrent() {
-        _qGlContext.makeCurrent(this);
-    }
 
-protected:
-    void resizeEvent(QResizeEvent* ev) override {
-        resizeWindow(ev->size());
-        
-        float fov_degrees = 60.0f;
-        float aspect_ratio = (float)_size.width() / _size.height();
-        float near_clip = 0.1f;
-        float far_clip = 1000.0f;
-        _projectionMatrix = glm::perspective(glm::radians(fov_degrees), aspect_ratio, near_clip, far_clip);
-    }
+        gpu::doInBatch(_renderArgs->_context, [&](gpu::Batch& batch) {
+            batch.setViewTransform(_camera);
+            _renderArgs->_batch = &batch;
+            _currentTest->renderTest(_currentTestId, _renderArgs);
+            _renderArgs->_batch = nullptr;
+        });
+
+#ifdef INTERACTIVE
+
+#else 
+        // TODO Capture the current rendered framebuffer and save
+        // Increment the test ID
+        ++_currentTestId;
+#endif
+        }
 };
 
+
 int main(int argc, char** argv) {    
     QGuiApplication app(argc, argv);
-    QTestWindow window;
-    auto timer = new QTimer(&app);
-    timer->setInterval(0);
-    app.connect(timer, &QTimer::timeout, &app, [&] {
-        window.draw();
-    });
-    timer->start();
+    MyTestWindow window;
     app.exec();
     return 0;
 }
 
-#include "main.moc"
-