split independent classes out of Ragdoll files

interface/src/avatar/SkeletonModel.cpp

@@ -14,6 +14,8 @@
 
 #include <VerletCapsuleShape.h>
 #include <VerletSphereShape.h>
+#include <DistanceConstraint.h>
+#include <FixedConstraint.h>
 
 #include "Application.h"
 #include "Avatar.h"

libraries/shared/src/Constraint.h

@@ -0,0 +1,28 @@
+//
+//  Constraint.h
+//  libraries/shared/src
+//
+//  Created by Andrew Meadows 2014.07.24
+//  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_Constraint_h
+#define hifi_Constraint_h
+
+class Constraint {
+public:
+    Constraint() {}
+    virtual ~Constraint() {}
+
+    /// Enforce contraint by moving relevant points.
+    /// \return max distance of point movement
+    virtual float enforce() = 0;
+
+protected:
+    int _type;
+};
+
+#endif // hifi_Constraint_h

libraries/shared/src/DistanceConstraint.cpp

@@ -0,0 +1,43 @@
+//
+//  DistanceConstraint.cpp
+//  libraries/shared/src
+//
+//  Created by Andrew Meadows 2014.07.24
+//  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 "DistanceConstraint.h"
+#include "SharedUtil.h" // for EPSILON
+#include "VerletPoint.h"
+
+DistanceConstraint::DistanceConstraint(VerletPoint* startPoint, VerletPoint* endPoint) : _distance(-1.0f) {
+    _points[0] = startPoint;
+    _points[1] = endPoint;
+    _distance = glm::distance(_points[0]->_position, _points[1]->_position);
+}
+
+DistanceConstraint::DistanceConstraint(const DistanceConstraint& other) {
+    _distance = other._distance;
+    _points[0] = other._points[0];
+    _points[1] = other._points[1];
+}
+
+void DistanceConstraint::setDistance(float distance) {
+    _distance = fabsf(distance);
+}
+
+float DistanceConstraint::enforce() {
+    // TODO: use a fast distance approximation
+    float newDistance = glm::distance(_points[0]->_position, _points[1]->_position);
+    glm::vec3 direction(0.0f, 1.0f, 0.0f);
+    if (newDistance > EPSILON) {
+        direction = (_points[0]->_position - _points[1]->_position) / newDistance;
+    }
+    glm::vec3 center = 0.5f * (_points[0]->_position + _points[1]->_position);
+    _points[0]->_position = center + (0.5f * _distance) * direction;
+    _points[1]->_position = center - (0.5f * _distance) * direction;
+    return glm::abs(newDistance - _distance);
+}

libraries/shared/src/DistanceConstraint.h

@@ -0,0 +1,31 @@
+//
+//  DistanceConstraint.h
+//  libraries/shared/src
+//
+//  Created by Andrew Meadows 2014.07.24
+//  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_DistanceConstraint_h
+#define hifi_DistanceConstraint_h
+
+#include "Constraint.h"
+
+class VerletPoint;
+
+class DistanceConstraint : public Constraint {
+public:
+    DistanceConstraint(VerletPoint* startPoint, VerletPoint* endPoint);
+    DistanceConstraint(const DistanceConstraint& other);
+    float enforce();
+    void setDistance(float distance);
+    float getDistance() const { return _distance; }
+private:
+    float _distance;
+    VerletPoint* _points[2];
+};
+
+#endif // hifi_DistanceConstraint_h

libraries/shared/src/FixedConstraint.cpp

@@ -0,0 +1,35 @@
+//
+//  FixedConstraint.cpp
+//  libraries/shared/src
+//
+//  Created by Andrew Meadows 2014.07.24
+//  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 "FixedConstraint.h"
+#include "Shape.h"  // for MAX_SHAPE_MASS
+#include "VerletPoint.h"
+
+FixedConstraint::FixedConstraint(VerletPoint* point, const glm::vec3& anchor) : _point(point), _anchor(anchor) {
+}
+
+float FixedConstraint::enforce() {
+    assert(_point != NULL);
+    // TODO: use fast approximate sqrt here
+    float distance = glm::distance(_anchor, _point->_position);
+    _point->_position = _anchor;
+    return distance;
+}
+
+void FixedConstraint::setPoint(VerletPoint* point) {
+    assert(point);
+    _point = point;
+    _point->_mass = MAX_SHAPE_MASS;
+}
+
+void FixedConstraint::setAnchor(const glm::vec3& anchor) {
+    _anchor = anchor;
+}

libraries/shared/src/FixedConstraint.h

@@ -0,0 +1,32 @@
+//
+//  FixedConstraint.h
+//  libraries/shared/src
+//
+//  Created by Andrew Meadows 2014.07.24
+//  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_FixedConstraint_h
+#define hifi_FixedConstraint_h
+
+#include <glm/glm.hpp>
+
+#include "Constraint.h"
+
+class VerletPoint;
+
+class FixedConstraint : public Constraint {
+public:
+    FixedConstraint(VerletPoint* point, const glm::vec3& anchor);
+    float enforce();
+    void setPoint(VerletPoint* point);
+    void setAnchor(const glm::vec3& anchor);
+private:
+    VerletPoint* _point;
+    glm::vec3 _anchor;
+};
+
+#endif // hifi_FixedConstraint_h

libraries/shared/src/Ragdoll.cpp

@@ -11,86 +11,9 @@
 
 #include "Ragdoll.h"
 
-#include "CapsuleShape.h"
-#include "CollisionInfo.h"
-#include "SharedUtil.h"
-#include "SphereShape.h"
-
-// ----------------------------------------------------------------------------
-// VerletPoint
-// ----------------------------------------------------------------------------
-void VerletPoint::accumulateDelta(const glm::vec3& delta) {
-    _accumulatedDelta += delta;
-    ++_numDeltas;
-}
-
-void VerletPoint::applyAccumulatedDelta() {
-    if (_numDeltas > 0) { 
-        _position += _accumulatedDelta / (float)_numDeltas;
-        _accumulatedDelta = glm::vec3(0.0f);
-        _numDeltas = 0;
-    }
-}
-
-// ----------------------------------------------------------------------------
-// FixedConstraint
-// ----------------------------------------------------------------------------
-FixedConstraint::FixedConstraint(VerletPoint* point, const glm::vec3& anchor) : _point(point), _anchor(anchor) {
-}
-
-float FixedConstraint::enforce() {
-    assert(_point != NULL);
-    // TODO: use fast approximate sqrt here
-    float distance = glm::distance(_anchor, _point->_position);
-    _point->_position = _anchor;
-    return distance;
-}
-
-void FixedConstraint::setPoint(VerletPoint* point) {
-    assert(point);
-    _point = point;
-    _point->_mass = MAX_SHAPE_MASS;
-}
-
-void FixedConstraint::setAnchor(const glm::vec3& anchor) {
-    _anchor = anchor;
-}
-
-// ----------------------------------------------------------------------------
-// DistanceConstraint
-// ----------------------------------------------------------------------------
-DistanceConstraint::DistanceConstraint(VerletPoint* startPoint, VerletPoint* endPoint) : _distance(-1.0f) {
-    _points[0] = startPoint;
-    _points[1] = endPoint;
-    _distance = glm::distance(_points[0]->_position, _points[1]->_position);
-}
-
-DistanceConstraint::DistanceConstraint(const DistanceConstraint& other) {
-    _distance = other._distance;
-    _points[0] = other._points[0];
-    _points[1] = other._points[1];
-}
-
-void DistanceConstraint::setDistance(float distance) {
-    _distance = fabsf(distance);
-}
-
-float DistanceConstraint::enforce() {
-    // TODO: use a fast distance approximation
-    float newDistance = glm::distance(_points[0]->_position, _points[1]->_position);
-    glm::vec3 direction(0.0f, 1.0f, 0.0f);
-    if (newDistance > EPSILON) {
-        direction = (_points[0]->_position - _points[1]->_position) / newDistance;
-    }
-    glm::vec3 center = 0.5f * (_points[0]->_position + _points[1]->_position);
-    _points[0]->_position = center + (0.5f * _distance) * direction;
-    _points[1]->_position = center - (0.5f * _distance) * direction;
-    return glm::abs(newDistance - _distance);
-}
-
-// ----------------------------------------------------------------------------
-// Ragdoll
-// ----------------------------------------------------------------------------
+#include "Constraint.h"
+#include "DistanceConstraint.h"
+#include "FixedConstraint.h"
 
 Ragdoll::Ragdoll() {
 }
@@ -118,4 +41,3 @@ float Ragdoll::enforceRagdollConstraints() {
     }
     return maxDistance;
 }
-

libraries/shared/src/Ragdoll.h

@@ -14,67 +14,11 @@
 
 #include <glm/glm.hpp>
 #include <glm/gtx/quaternion.hpp>
+#include "VerletPoint.h"
 
 #include <QVector>
 
-class Shape;
-
-// TODO: Andrew to move VerletPoint class to its own file
-class VerletPoint {
-public:
-    VerletPoint() : _position(0.0f), _lastPosition(0.0f), _mass(1.0f), _accumulatedDelta(0.0f), _numDeltas(0) {}
-
-    void accumulateDelta(const glm::vec3& delta);
-    void applyAccumulatedDelta();
-
-    glm::vec3 getAccumulatedDelta() const { 
-        return (_numDeltas > 0) ?  _accumulatedDelta / (float)_numDeltas : glm::vec3(0.0f);
-    }
-
-    glm::vec3 _position;
-    glm::vec3 _lastPosition;
-    float _mass;
-
-private:
-    glm::vec3 _accumulatedDelta;
-    int _numDeltas;
-};
-
-class Constraint {
-public:
-    Constraint() {}
-    virtual ~Constraint() {}
-
-    /// Enforce contraint by moving relevant points.
-    /// \return max distance of point movement
-    virtual float enforce() = 0;
-
-protected:
-    int _type;
-};
-
-class FixedConstraint : public Constraint {
-public:
-    FixedConstraint(VerletPoint* point, const glm::vec3& anchor);
-    float enforce();
-    void setPoint(VerletPoint* point);
-    void setAnchor(const glm::vec3& anchor);
-private:
-    VerletPoint* _point;
-    glm::vec3 _anchor;
-};
-
-class DistanceConstraint : public Constraint {
-public:
-    DistanceConstraint(VerletPoint* startPoint, VerletPoint* endPoint);
-    DistanceConstraint(const DistanceConstraint& other);
-    float enforce();
-    void setDistance(float distance);
-    float getDistance() const { return _distance; }
-private:
-    float _distance;
-    VerletPoint* _points[2];
-};
+class Constraint;
 
 class Ragdoll {
 public:

libraries/shared/src/VerletPoint.cpp

@@ -0,0 +1,25 @@
+//
+//  VerletPoint.cpp
+//  libraries/shared/src
+//
+//  Created by Andrew Meadows 2014.07.24
+//  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 "VerletPoint.h"
+
+void VerletPoint::accumulateDelta(const glm::vec3& delta) {
+    _accumulatedDelta += delta;
+    ++_numDeltas;
+}
+
+void VerletPoint::applyAccumulatedDelta() {
+    if (_numDeltas > 0) { 
+        _position += _accumulatedDelta / (float)_numDeltas;
+        _accumulatedDelta = glm::vec3(0.0f);
+        _numDeltas = 0;
+    }
+}

libraries/shared/src/VerletPoint.h

@@ -0,0 +1,37 @@
+//
+//  VerletPoint.h
+//  libraries/shared/src
+//
+//  Created by Andrew Meadows 2014.07.24
+//  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_VerletPoint_h
+#define hifi_VerletPoint_h
+
+#include <glm/glm.hpp>
+
+class VerletPoint {
+public:
+    VerletPoint() : _position(0.0f), _lastPosition(0.0f), _mass(1.0f), _accumulatedDelta(0.0f), _numDeltas(0) {}
+
+    void accumulateDelta(const glm::vec3& delta);
+    void applyAccumulatedDelta();
+
+    glm::vec3 getAccumulatedDelta() const { 
+        return (_numDeltas > 0) ?  _accumulatedDelta / (float)_numDeltas : glm::vec3(0.0f);
+    }
+
+    glm::vec3 _position;
+    glm::vec3 _lastPosition;
+    float _mass;
+
+private:
+    glm::vec3 _accumulatedDelta;
+    int _numDeltas;
+};
+
+#endif // hifi_VerletPoint_h