diff --git a/libraries/entities-renderer/src/RenderableLightEntityItem.cpp b/libraries/entities-renderer/src/RenderableLightEntityItem.cpp
index 5a20633044..ab6445cc6e 100644
--- a/libraries/entities-renderer/src/RenderableLightEntityItem.cpp
+++ b/libraries/entities-renderer/src/RenderableLightEntityItem.cpp
@@ -80,7 +80,7 @@ void RenderableLightEntityItem::render(RenderArgs* args) {
 #endif
 };
 
-bool RenderableLightEntityItem::findDetailedRayIntersection(const glm::vec3& origin, const glm::vec3& direction,
+bool RenderableLightEntityItem::findDetailedRayIntersectionInMeters(const glm::vec3& origin, const glm::vec3& direction,
                          bool& keepSearching, OctreeElement*& element, float& distance, BoxFace& face, 
                          void** intersectedObject, bool precisionPicking) const {
 
diff --git a/libraries/entities-renderer/src/RenderableLightEntityItem.h b/libraries/entities-renderer/src/RenderableLightEntityItem.h
index cfafb85983..1ea3e7e884 100644
--- a/libraries/entities-renderer/src/RenderableLightEntityItem.h
+++ b/libraries/entities-renderer/src/RenderableLightEntityItem.h
@@ -24,7 +24,7 @@ public:
 
     virtual void render(RenderArgs* args);
     virtual bool supportsDetailedRayIntersection() const { return true; }
-    virtual bool findDetailedRayIntersection(const glm::vec3& origin, const glm::vec3& direction,
+    virtual bool findDetailedRayIntersectionInMeters(const glm::vec3& origin, const glm::vec3& direction,
                          bool& keepSearching, OctreeElement*& element, float& distance, BoxFace& face, 
                          void** intersectedObject, bool precisionPicking) const;
 };
diff --git a/libraries/entities-renderer/src/RenderableModelEntityItem.cpp b/libraries/entities-renderer/src/RenderableModelEntityItem.cpp
index 5f2c0baa5f..6c1d24b845 100644
--- a/libraries/entities-renderer/src/RenderableModelEntityItem.cpp
+++ b/libraries/entities-renderer/src/RenderableModelEntityItem.cpp
@@ -254,29 +254,16 @@ EntityItemProperties RenderableModelEntityItem::getProperties() const {
     return properties;
 }
 
-bool RenderableModelEntityItem::findDetailedRayIntersection(const glm::vec3& origin, const glm::vec3& direction,
+bool RenderableModelEntityItem::findDetailedRayIntersectionInMeters(const glm::vec3& origin, const glm::vec3& direction,
                          bool& keepSearching, OctreeElement*& element, float& distance, BoxFace& face, 
                          void** intersectedObject, bool precisionPicking) const {
     if (!_model) {
         return true;
     }
+    //qDebug() << "RenderableModelEntityItem::findDetailedRayIntersectionInMeters() precisionPicking:" << precisionPicking;
     
-    glm::vec3 originInMeters = origin * (float)TREE_SCALE;
     QString extraInfo;
-    float localDistance;
-    
-    //qDebug() << "RenderableModelEntityItem::findDetailedRayIntersection() precisionPicking:" << precisionPicking;
-    
-    bool intersectsModel = _model->findRayIntersectionAgainstSubMeshes(originInMeters, direction, 
-                                            localDistance, face, extraInfo, precisionPicking);
-    
-    if (intersectsModel) {
-        // NOTE: findRayIntersectionAgainstSubMeshes() does work in meters, but we're expected to return
-        // results in tree scale.
-        distance = localDistance / (float)TREE_SCALE;
-    }
-
-    return intersectsModel; // we only got here if we intersected our non-aabox                         
+    return _model->findRayIntersectionAgainstSubMeshes(origin, direction, distance, face, extraInfo, precisionPicking);
 }
 
 
diff --git a/libraries/entities-renderer/src/RenderableModelEntityItem.h b/libraries/entities-renderer/src/RenderableModelEntityItem.h
index 65cded0207..7e20b0bd15 100644
--- a/libraries/entities-renderer/src/RenderableModelEntityItem.h
+++ b/libraries/entities-renderer/src/RenderableModelEntityItem.h
@@ -44,7 +44,7 @@ public:
 
     virtual void render(RenderArgs* args);
     virtual bool supportsDetailedRayIntersection() const { return true; }
-    virtual bool findDetailedRayIntersection(const glm::vec3& origin, const glm::vec3& direction,
+    virtual bool findDetailedRayIntersectionInMeters(const glm::vec3& origin, const glm::vec3& direction,
                          bool& keepSearching, OctreeElement*& element, float& distance, BoxFace& face, 
                          void** intersectedObject, bool precisionPicking) const;
 
diff --git a/libraries/entities/src/EntityItem.h b/libraries/entities/src/EntityItem.h
index 09a2c7bc6b..64fe712e43 100644
--- a/libraries/entities/src/EntityItem.h
+++ b/libraries/entities/src/EntityItem.h
@@ -139,7 +139,7 @@ public:
     virtual void debugDump() const;
     
     virtual bool supportsDetailedRayIntersection() const { return false; }
-    virtual bool findDetailedRayIntersection(const glm::vec3& origin, const glm::vec3& direction,
+    virtual bool findDetailedRayIntersectionInMeters(const glm::vec3& origin, const glm::vec3& direction,
                          bool& keepSearching, OctreeElement*& element, float& distance, BoxFace& face, 
                          void** intersectedObject, bool precisionPicking) const { return true; }
 
diff --git a/libraries/entities/src/EntityTreeElement.cpp b/libraries/entities/src/EntityTreeElement.cpp
index 4b4bae662a..abdc7c4768 100644
--- a/libraries/entities/src/EntityTreeElement.cpp
+++ b/libraries/entities/src/EntityTreeElement.cpp
@@ -469,7 +469,7 @@ bool EntityTreeElement::bestFitBounds(const glm::vec3& minPoint, const glm::vec3
     return false;
 }
 
-bool EntityTreeElement::findDetailedRayIntersection(const glm::vec3& origin, const glm::vec3& direction,
+bool EntityTreeElement::findDetailedRayIntersectionInMeters(const glm::vec3& origin, const glm::vec3& direction,
                          bool& keepSearching, OctreeElement*& element, float& distance, BoxFace& face, 
                          void** intersectedObject, bool precisionPicking, float distanceToElementCube) {
 
@@ -485,7 +485,7 @@ bool EntityTreeElement::findDetailedRayIntersection(const glm::vec3& origin, con
     while(entityItr != entityEnd) {
         EntityItem* entity = (*entityItr);
         
-        AABox entityBox = entity->getAABox();
+        AABox entityBox = entity->getAABoxInMeters();
         float localDistance;
         BoxFace localFace;
 
@@ -494,11 +494,11 @@ bool EntityTreeElement::findDetailedRayIntersection(const glm::vec3& origin, con
 
             // extents is the entity relative, scaled, centered extents of the entity
             glm::mat4 rotation = glm::mat4_cast(entity->getRotation());
-            glm::mat4 translation = glm::translate(entity->getPositionInDomainUnits());
+            glm::mat4 translation = glm::translate(entity->getPositionInMeters());
             glm::mat4 entityToWorldMatrix = translation * rotation;
             glm::mat4 worldToEntityMatrix = glm::inverse(entityToWorldMatrix);
 
-            glm::vec3 dimensions = entity->getDimensionsInDomainUnits();
+            glm::vec3 dimensions = entity->getDimensionsInMeters();
             glm::vec3 registrationPoint = entity->getRegistrationPoint();
             glm::vec3 corner = -(dimensions * registrationPoint);
 
@@ -513,7 +513,7 @@ bool EntityTreeElement::findDetailedRayIntersection(const glm::vec3& origin, con
                 if (localDistance < distance) {
                     // now ask the entity if we actually intersect
                     if (entity->supportsDetailedRayIntersection()) {
-                        if (entity->findDetailedRayIntersection(origin, direction, keepSearching, element, localDistance, 
+                        if (entity->findDetailedRayIntersectionInMeters(origin, direction, keepSearching, element, localDistance, 
                                                                     localFace, intersectedObject, precisionPicking)) {
     
                             if (localDistance < distance) {
diff --git a/libraries/entities/src/EntityTreeElement.h b/libraries/entities/src/EntityTreeElement.h
index 0b28dd30d0..424e3ca520 100644
--- a/libraries/entities/src/EntityTreeElement.h
+++ b/libraries/entities/src/EntityTreeElement.h
@@ -135,7 +135,7 @@ public:
     virtual bool deleteApproved() const { return !hasEntities(); }
 
     virtual bool canRayIntersect() const { return hasEntities(); }
-    virtual bool findDetailedRayIntersection(const glm::vec3& origin, const glm::vec3& direction,
+    virtual bool findDetailedRayIntersectionInMeters(const glm::vec3& origin, const glm::vec3& direction,
                          bool& keepSearching, OctreeElement*& element, float& distance, BoxFace& face, 
                          void** intersectedObject, bool precisionPicking, float distanceToElementCube);
 
diff --git a/libraries/entities/src/SphereEntityItem.cpp b/libraries/entities/src/SphereEntityItem.cpp
index 6b773d8189..75788c979f 100644
--- a/libraries/entities/src/SphereEntityItem.cpp
+++ b/libraries/entities/src/SphereEntityItem.cpp
@@ -94,13 +94,13 @@ void SphereEntityItem::appendSubclassData(OctreePacketData* packetData, EncodeBi
     APPEND_ENTITY_PROPERTY(PROP_COLOR, appendColor, getColor());
 }
 
-bool SphereEntityItem::findDetailedRayIntersection(const glm::vec3& origin, const glm::vec3& direction,
+bool SphereEntityItem::findDetailedRayIntersectionInMeters(const glm::vec3& origin, const glm::vec3& direction,
                      bool& keepSearching, OctreeElement*& element, float& distance, BoxFace& face, 
                      void** intersectedObject, bool precisionPicking) const {
     // determine the ray in the frame of the entity transformed from a unit sphere
-    glm::mat4 translation = glm::translate(getPositionInDomainUnits());
+    glm::mat4 translation = glm::translate(getPositionInMeters());
     glm::mat4 rotation = glm::mat4_cast(getRotation());
-    glm::mat4 scale = glm::scale(getDimensionsInDomainUnits());
+    glm::mat4 scale = glm::scale(getDimensionsInMeters());
     glm::mat4 registration = glm::translate(glm::vec3(0.5f, 0.5f, 0.5f) - getRegistrationPoint());
     glm::mat4 entityToWorldMatrix = translation * rotation * scale * registration;
     glm::mat4 worldToEntityMatrix = glm::inverse(entityToWorldMatrix);
diff --git a/libraries/entities/src/SphereEntityItem.h b/libraries/entities/src/SphereEntityItem.h
index f79a2db7ff..f8419e75b9 100644
--- a/libraries/entities/src/SphereEntityItem.h
+++ b/libraries/entities/src/SphereEntityItem.h
@@ -56,7 +56,7 @@ public:
     virtual ShapeType getShapeType() const { return SHAPE_TYPE_SPHERE; }
     
     virtual bool supportsDetailedRayIntersection() const { return true; }
-    virtual bool findDetailedRayIntersection(const glm::vec3& origin, const glm::vec3& direction,
+    virtual bool findDetailedRayIntersectionInMeters(const glm::vec3& origin, const glm::vec3& direction,
                          bool& keepSearching, OctreeElement*& element, float& distance, BoxFace& face, 
                          void** intersectedObject, bool precisionPicking) const;
 
diff --git a/libraries/entities/src/TextEntityItem.cpp b/libraries/entities/src/TextEntityItem.cpp
index 051463929c..a716bba0e2 100644
--- a/libraries/entities/src/TextEntityItem.cpp
+++ b/libraries/entities/src/TextEntityItem.cpp
@@ -122,7 +122,7 @@ void TextEntityItem::appendSubclassData(OctreePacketData* packetData, EncodeBits
 }
 
 
-bool TextEntityItem::findDetailedRayIntersection(const glm::vec3& origin, const glm::vec3& direction,
+bool TextEntityItem::findDetailedRayIntersectionInMeters(const glm::vec3& origin, const glm::vec3& direction,
                      bool& keepSearching, OctreeElement*& element, float& distance, BoxFace& face, 
                      void** intersectedObject, bool precisionPicking) const {
                      
@@ -136,7 +136,7 @@ bool TextEntityItem::findDetailedRayIntersection(const glm::vec3& origin, const
     const glm::vec3 UNROTATED_NORMAL(0.0f, 0.0f, -1.0f);
     glm::vec3 normal = _rotation * UNROTATED_NORMAL;
     plane.setNormal(normal);
-    plane.setPoint(_position); // the position is definitely a point on our plane
+    plane.setPoint(getPositionInMeters()); // the position is definitely a point on our plane
 
     bool intersects = plane.findRayIntersection(rayInfo);
 
@@ -145,11 +145,11 @@ bool TextEntityItem::findDetailedRayIntersection(const glm::vec3& origin, const
         // now we know the point the ray hit our plane
 
         glm::mat4 rotation = glm::mat4_cast(getRotation());
-        glm::mat4 translation = glm::translate(getPositionInDomainUnits());
+        glm::mat4 translation = glm::translate(getPositionInMeters());
         glm::mat4 entityToWorldMatrix = translation * rotation;
         glm::mat4 worldToEntityMatrix = glm::inverse(entityToWorldMatrix);
 
-        glm::vec3 dimensions = getDimensionsInDomainUnits();
+        glm::vec3 dimensions = getDimensionsInMeters();
         glm::vec3 registrationPoint = getRegistrationPoint();
         glm::vec3 corner = -(dimensions * registrationPoint);
         AABox entityFrameBox(corner, dimensions);
diff --git a/libraries/entities/src/TextEntityItem.h b/libraries/entities/src/TextEntityItem.h
index 5804c9af1e..60f82f4936 100644
--- a/libraries/entities/src/TextEntityItem.h
+++ b/libraries/entities/src/TextEntityItem.h
@@ -46,7 +46,7 @@ public:
                                                 EntityPropertyFlags& propertyFlags, bool overwriteLocalData);
 
     virtual bool supportsDetailedRayIntersection() const { return true; }
-    virtual bool findDetailedRayIntersection(const glm::vec3& origin, const glm::vec3& direction,
+    virtual bool findDetailedRayIntersectionInMeters(const glm::vec3& origin, const glm::vec3& direction,
                          bool& keepSearching, OctreeElement*& element, float& distance, BoxFace& face, 
                          void** intersectedObject, bool precisionPicking) const;
 
diff --git a/libraries/octree/src/Octree.cpp b/libraries/octree/src/Octree.cpp
index e925ea5aba..4a57b8047f 100644
--- a/libraries/octree/src/Octree.cpp
+++ b/libraries/octree/src/Octree.cpp
@@ -706,7 +706,7 @@ bool findRayIntersectionOp(OctreeElement* element, void* extraData) {
 bool Octree::findRayIntersection(const glm::vec3& origin, const glm::vec3& direction,
                                     OctreeElement*& element, float& distance, BoxFace& face, void** intersectedObject,
                                     Octree::lockType lockType, bool* accurateResult, bool precisionPicking) {
-    RayArgs args = { origin / (float)(TREE_SCALE), direction, element, distance, face, 
+    RayArgs args = { origin, direction, element, distance, face, 
                         intersectedObject, false, precisionPicking};
     distance = FLT_MAX;
 
@@ -726,10 +726,6 @@ bool Octree::findRayIntersection(const glm::vec3& origin, const glm::vec3& direc
 
     recurseTreeWithOperation(findRayIntersectionOp, &args);
     
-    if (args.found) {
-        args.distance *= (float)(TREE_SCALE); // scale back up to meters
-    }
-
     if (gotLock) {
         unlock();
     }
diff --git a/libraries/octree/src/OctreeElement.cpp b/libraries/octree/src/OctreeElement.cpp
index 93792678e2..b686796b9d 100644
--- a/libraries/octree/src/OctreeElement.cpp
+++ b/libraries/octree/src/OctreeElement.cpp
@@ -1338,13 +1338,11 @@ bool OctreeElement::findRayIntersection(const glm::vec3& origin, const glm::vec3
     keepSearching = true; // assume that we will continue searching after this.
 
     AACube cube = getAACube();
+    cube *= (float)TREE_SCALE;
     float distanceToElementCube = std::numeric_limits<float>::max();
     float distanceToElementDetails = distance;
     BoxFace localFace;
 
-    AACube debugCube = cube;
-    debugCube.scale((float)TREE_SCALE);
-
     // if the ray doesn't intersect with our cube, we can stop searching!
     if (!cube.findRayIntersection(origin, direction, distanceToElementCube, localFace)) {
         keepSearching = false; // no point in continuing to search
diff --git a/libraries/shared/src/AACube.h b/libraries/shared/src/AACube.h
index b29bc49bef..5bcf9527cf 100644
--- a/libraries/shared/src/AACube.h
+++ b/libraries/shared/src/AACube.h
@@ -63,6 +63,8 @@ public:
     AABox clamp(const glm::vec3& min, const glm::vec3& max) const;
     AABox clamp(float min, float max) const;
 
+    AACube& operator *= (float scale);
+
 private:
     glm::vec3 getClosestPointOnFace(const glm::vec3& point, BoxFace face) const;
     glm::vec3 getClosestPointOnFace(const glm::vec4& origin, const glm::vec4& direction, BoxFace face) const;
@@ -74,6 +76,12 @@ private:
     float _scale;
 };
 
+inline AACube& AACube::operator *= (float scale) {
+    _corner *= scale;
+    _scale *= scale;
+    return *this;
+}
+
 inline bool operator==(const AACube& a, const AACube& b) {
     return a.getCorner() == b.getCorner() && a.getScale() == b.getScale();
 }