Move shape related contains() to ShapeInfo

libraries/entities-renderer/src/EntityTreeRenderer.cpp

@@ -324,7 +324,7 @@ void EntityTreeRenderer::checkEnterLeaveEntities() {
 
             // create a list of entities that actually contain the avatar's position
             foreach(const EntityItem* entity, foundEntities) {
-                if (entity->contains(avatarPosition)) {
+                if (const_cast<EntityItem*>(entity)->contains(avatarPosition)) {
                     entitiesContainingAvatar << entity->getEntityItemID();
                 }
             }

libraries/entities-renderer/src/RenderableModelEntityItem.cpp

@@ -415,7 +415,7 @@ void RenderableModelEntityItem::computeShapeInfo(ShapeInfo& info) {
     }
 }
 
-bool RenderableModelEntityItem::contains(const glm::vec3& point) const {
+bool RenderableModelEntityItem::contains(const glm::vec3& point) {
     if (EntityItem::contains(point) && _model && _model->getCollisionGeometry()) {
         const QSharedPointer<NetworkGeometry> collisionNetworkGeometry = _model->getCollisionGeometry();
         const FBXGeometry& collisionGeometry = collisionNetworkGeometry->getFBXGeometry();

libraries/entities-renderer/src/RenderableModelEntityItem.h

@@ -57,7 +57,7 @@ public:
     bool isReadyToComputeShape();
     void computeShapeInfo(ShapeInfo& info);
     
-    virtual bool contains(const glm::vec3& point) const;
+    virtual bool contains(const glm::vec3& point);
 
 private:
     void remapTextures();

libraries/entities-renderer/src/RenderableZoneEntityItem.cpp

@@ -39,12 +39,12 @@ int RenderableZoneEntityItem::readEntitySubclassDataFromBuffer(const unsigned ch
     return bytesRead;
 }
 
-bool RenderableZoneEntityItem::contains(const glm::vec3& point) const {
+bool RenderableZoneEntityItem::contains(const glm::vec3& point) {
     if (getShapeType() != SHAPE_TYPE_COMPOUND) {
         return EntityItem::contains(point);
     }
     if (!_compoundShapeModel && hasCompoundShapeURL()) {
-        const_cast<RenderableZoneEntityItem*>(this)->_compoundShapeModel = DependencyManager::get<GeometryCache>()->getGeometry(getCompoundShapeURL(), QUrl(), true);
+        _compoundShapeModel = DependencyManager::get<GeometryCache>()->getGeometry(getCompoundShapeURL(), QUrl(), true);
     }
     
     if (EntityItem::contains(point) && _compoundShapeModel && _compoundShapeModel->isLoaded()) {

libraries/entities-renderer/src/RenderableZoneEntityItem.h

@@ -29,7 +29,7 @@ public:
                                                  ReadBitstreamToTreeParams& args,
                                                  EntityPropertyFlags& propertyFlags, bool overwriteLocalData);
 
-    virtual bool contains(const glm::vec3& point) const;
+    virtual bool contains(const glm::vec3& point);
     
 private:
     

libraries/entities/src/EntityItem.cpp

@@ -1082,16 +1082,13 @@ float EntityItem::getRadius() const {
     return 0.5f * glm::length(_dimensions);
 }
 
-bool EntityItem::contains(const glm::vec3& point) const {
-    switch (getShapeType()) {
-        case SHAPE_TYPE_BOX:
-            return AABox(glm::vec3(0.0f, 0.0f, 0.0f), 1.0f).contains(worldToEntity(point));
-        case SHAPE_TYPE_SPHERE:
-        case SHAPE_TYPE_ELLIPSOID:
-            static const float UNIT_SPHERE_RADIUS = 1.0f / 2.0f;
-            return glm::length(worldToEntity(point)) <= UNIT_SPHERE_RADIUS;
-        default:
-            return getAABox().contains(point);
+bool EntityItem::contains(const glm::vec3& point) {
+    if (getShapeType() == SHAPE_TYPE_COMPOUND) {
+        return getAABox().contains(point);
+    } else {
+        ShapeInfo info;
+        info.setParams(getShapeType(), glm::vec3(0.5f));
+        return info.contains(worldToEntity(point));
     }
 }
 

libraries/entities/src/EntityItem.h

@@ -253,7 +253,7 @@ public:
     // TODO: get rid of users of getRadius()... 
     float getRadius() const;
     
-    virtual bool contains(const glm::vec3& point) const;
+    virtual bool contains(const glm::vec3& point);
 
     virtual bool isReadyToComputeShape() { return true; }
     virtual void computeShapeInfo(ShapeInfo& info);

libraries/shared/src/ShapeInfo.cpp

@@ -124,6 +124,54 @@ float ShapeInfo::computeVolume() const {
     return volume;
 }
 
+bool ShapeInfo::contains(const glm::vec3& point) const {
+    switch(_type) {
+        case SHAPE_TYPE_SPHERE:
+            return glm::length(point) <= _halfExtents.x;
+        case SHAPE_TYPE_ELLIPSOID: {
+            glm::vec3 scaledPoint = glm::abs(point) / _halfExtents;
+            return glm::length(scaledPoint) <= 1.0f;
+        }
+        case SHAPE_TYPE_CYLINDER_X:
+            return glm::length(glm::vec2(point.y, point.z)) <= _halfExtents.z;
+        case SHAPE_TYPE_CYLINDER_Y:
+            return glm::length(glm::vec2(point.x, point.z)) <= _halfExtents.x;
+        case SHAPE_TYPE_CYLINDER_Z:
+            return glm::length(glm::vec2(point.x, point.y)) <= _halfExtents.y;
+        case SHAPE_TYPE_CAPSULE_X: {
+            if (glm::abs(point.x) <= _halfExtents.x) {
+                return glm::length(glm::vec2(point.y, point.z)) <= _halfExtents.z;
+            } else {
+                glm::vec3 absPoint = glm::abs(point) - _halfExtents.x;
+                return glm::length(absPoint) <= _halfExtents.z;
+            }
+        }
+        case SHAPE_TYPE_CAPSULE_Y: {
+            if (glm::abs(point.y) <= _halfExtents.y) {
+                return glm::length(glm::vec2(point.x, point.z)) <= _halfExtents.x;
+            } else {
+                glm::vec3 absPoint = glm::abs(point) - _halfExtents.y;
+                return glm::length(absPoint) <= _halfExtents.x;
+            }
+        }
+        case SHAPE_TYPE_CAPSULE_Z: {
+            if (glm::abs(point.z) <= _halfExtents.z) {
+                return glm::length(glm::vec2(point.x, point.y)) <= _halfExtents.y;
+            } else {
+                glm::vec3 absPoint = glm::abs(point) - _halfExtents.z;
+                return glm::length(absPoint) <= _halfExtents.y;
+            }
+        }
+        case SHAPE_TYPE_BOX:
+        default: {
+            glm::vec3 absPoint = glm::abs(point);
+            return absPoint.x <= _halfExtents.x
+            && absPoint.y <= _halfExtents.y
+            && absPoint.z <= _halfExtents.z;
+        }
+    }
+}
+
 const DoubleHashKey& ShapeInfo::getHash() const {
     // NOTE: we cache the key so we only ever need to compute it once for any valid ShapeInfo instance.
     if (_doubleHashKey.isNull() && _type != SHAPE_TYPE_NONE) {

libraries/shared/src/ShapeInfo.h

@@ -57,6 +57,10 @@ public:
     void appendToPoints (const QVector<glm::vec3>& newPoints) { _points << newPoints; }
 
     float computeVolume() const;
+    
+    /// Returns whether point is inside the shape
+    /// For compound shapes it will only return whether it is inside the bounding box
+    bool contains(const glm::vec3& point) const;
 
     const DoubleHashKey& getHash() const;