CDVolume.h

Go to the documentation of this file.

//    Copyright (C) 2004-2012 Dylan Blair
//
//    email: dblair@alumni.cs.utexas.edu
//
//    This library is free software; you can redistribute it and/or
//    modify it under the terms of the GNU Lesser General Public
//    License as published by the Free Software Foundation; either
//    version 2.1 of the License, or (at your option) any later version.
//
//    This library is distributed in the hope that it will be useful,
//    but WITHOUT ANY WARRANTY; without even the implied warranty of
//    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
//    Lesser General Public License for more details.
//
//    You should have received a copy of the GNU Lesser General Public
//    License along with this library; if not, write to the Free Software
//    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

#ifndef CDVOLUME_H
#define CDVOLUME_H

#include "../Math_LIB/MMatrix3x3.h"

namespace OpenSkyNet {
    namespace CD {
        enum SHAPE_TYPE { SPHERE, BOX, PLANE };

        class Volume;

        struct HitInfo {
            Volume* _collider;

            float _hitSecs;

            Math::Point<> _hitPos, _hitNormal;

            Math::Point<> _collideeStartCenter, _collideeVel;
            Math::Point<> _colliderStartCenter, _colliderVel;

            HitInfo(Volume* collider_=0) : _collider(collider_), _hitSecs(Math::PSEUDO_INFINITY) {}
        };

        struct Shape {
            float _boundingRadius;

            Shape(const float& boundingRadius_=0.0f) : _boundingRadius(boundingRadius_) {}

            virtual ~Shape() {}

            virtual SHAPE_TYPE getType() const = 0;

            virtual float getDist(const Math::Point<>& thisCenter_, const Math::Matrix3x3& thisRot_, const Shape* otherShape_, 
                                  const Math::Point<>& otherCenter_, const Math::Matrix3x3& otherRot_) const;

            virtual bool getFirstIntersection(const Math::Point<>& thisCenter_, const Math::Matrix3x3& thisRot_, const Math::Point<>& thisVel_, const Shape* otherShape_, 
                                              const Math::Point<>& otherCenter_, const Math::Matrix3x3& otherRot_, const Math::Point<>& otherVel_, HitInfo& hitInfo_) const;

            virtual bool getClosestRayIntersection(const Math::Point<>& thisCenter_, const Math::Matrix3x3& thisRot_, 
                const Math::Point<>& rayOrigin_, const Math::Point<>& rayDir_, 
                Math::Point<>& hitPos_, float& t_, Math::Point<>& hitNormal_) const;

            virtual void scale(const Math::Point<>& factor_) { UNUSED(factor_); }
        };

        struct Sphere : public Shape {
            Sphere(const float& boundingRadius_) : Shape(boundingRadius_) {}

            virtual SHAPE_TYPE getType() const { return SPHERE; }
        };

        struct Box : public Shape {
            float _widthDiv2, _heightDiv2, _depthDiv2;

            Box(const float& boundingRadius_, const float& width_, const float& height_, const float& depth_) : Shape(boundingRadius_), 
                _widthDiv2(width_), _heightDiv2(height_), _depthDiv2(depth_) { _widthDiv2 /= 2; _heightDiv2 /= 2; _depthDiv2 /= 2; }

            virtual SHAPE_TYPE getType() const { return BOX; }

            inline Math::Point<> getDimensions() const { return Math::Point<>(_widthDiv2, _heightDiv2, _depthDiv2); }

            virtual float getDist(const Math::Point<>& thisCenter_, const Math::Matrix3x3& thisRot_, const Shape* otherShape_, 
                                  const Math::Point<>& otherCenter_, const Math::Matrix3x3& otherRot_) const;

            virtual bool getFirstIntersection(const Math::Point<>& thisCenter_, const Math::Matrix3x3& thisRot_, const Math::Point<>& thisVel_, const Shape* otherShape_, 
                                              const Math::Point<>& otherCenter_, const Math::Matrix3x3& otherRot_, const Math::Point<>& otherVel_, HitInfo& hitInfo_) const;

            virtual void scale(const Math::Point<>& factor_);
        };

        struct Plane : public Shape {
            enum AXIS_ALIGNMENT { NONE, NEG_X, POS_X, NEG_Y, POS_Y, NEG_Z, POS_Z };

            Math::Point<> _n;

            Plane(const Math::Point<>& n_) : _n(n_) {}

            virtual SHAPE_TYPE getType() const { return PLANE; }

            virtual float getDist(const Math::Point<>& thisCenter_, const Math::Matrix3x3& thisRot_, const Shape* otherShape_, 
                                  const Math::Point<>& otherCenter_, const Math::Matrix3x3& otherRot_) const;

            inline float getDist(const Math::Point<>& thisP_, const Math::Point<>& otherP_) const {
                Math::Point<> v(otherP_ - thisP_);
                return _n.getDot3(v);
            }

            inline AXIS_ALIGNMENT getAxisAlignment() const {
                if (_n.equals(Math::g_xAxis,Math::CLOSE_TO_ZERO)) return POS_X;
                if (_n.equals(Math::g_yAxis,Math::CLOSE_TO_ZERO)) return POS_Y;
                if (_n.equals(Math::g_zAxis,Math::CLOSE_TO_ZERO)) return POS_Z;
                if (_n.equals(-Math::g_xAxis,Math::CLOSE_TO_ZERO)) return NEG_X;
                if (_n.equals(-Math::g_yAxis,Math::CLOSE_TO_ZERO)) return NEG_Y;
                if (_n.equals(-Math::g_zAxis,Math::CLOSE_TO_ZERO)) return NEG_Z;
                return NONE;
            }
        };

        #define COL_GROUP_HIT_ALL_HIT_BY_ALL          0xFFFFFFFF
        #define COL_GROUP_HIT_ALL_HIT_BY_NONE         0xFFFF0000
        #define COL_GROUP_HIT_NONE_HIT_BY_ALL         0x0000FFFF
        #define COL_GROUP_HIT_NONE_HIT_BY_NONE        0x00000000
        #define COL_GROUP_HIT_NONE_HIT_BY_1           0x00000001
        #define COL_GROUP_HIT_ALL_BUT_1_HIT_BY_NONE   0xFFFE0000
        #define COL_GROUP_HITTABLE_MASK               0x0000FFFF

        class Collidable {
            Math::Point<> _center, _nonCollidingCenter;
            Math::Matrix3x3 _rot, _nonCollidingRot;
            void* _userPointer;
            Utils::uint _colGroup;
        public:
            Collidable(const Math::Point<>& center_=Math::g_origin, const Math::Matrix3x3& rot_=Math::g_identityMatrix3x3, 
                void* userPointer_=0, Utils::uint colGroup_=COL_GROUP_HIT_ALL_HIT_BY_ALL) : _center(center_), 
                _nonCollidingCenter(center_), _rot(rot_), _userPointer(userPointer_), _colGroup(colGroup_) {}

            virtual ~Collidable() {}

            inline void translate(const Math::Point<>& delta_) { _center += delta_; }

            inline void setCenter(const Math::Point<>& center_) { _center = center_; }

            inline Math::Point<> getCenter() const { return _center; }

            inline void setNonColTransform(const Math::Point<>& center_, const Math::Matrix3x3& rot_) {
                _nonCollidingCenter = center_;
                _nonCollidingRot = rot_;
            }

            inline const Math::Point<>& getNonColCenter() const { return _nonCollidingCenter; }
            inline const Math::Matrix3x3& getNonColRot() const { return _nonCollidingRot; }

            inline void setRot(const Math::Matrix3x3& rot_) { _rot = rot_; }

            inline Math::Matrix3x3 getRot() const { return _rot; }

            inline void setUserPointer(void* userPointer_) { _userPointer = userPointer_; }

            inline void* getUserPointer() const { return _userPointer; }

            inline Utils::uint canGroupHitMe(Utils::uint colGroup_) const { return (colGroup_ & ((_colGroup & COL_GROUP_HITTABLE_MASK) << 16)); }

            inline Utils::uint getColGroup() const { return _colGroup; }

            inline void setColGroup(Utils::uint colGroup_) { _colGroup = colGroup_; }

            virtual Shape* getShape() = 0;

            virtual const Shape* getShape() const = 0;

            virtual SHAPE_TYPE getType() const { return getShape()->getType(); }

            virtual float getDist(const Collidable* aCollidable_) const {
                return getShape()->getDist(_center, _rot, aCollidable_->getShape(), aCollidable_->getCenter(), aCollidable_->getRot());
            }

            virtual bool getFirstIntersection(const Math::Point<>& thisVel_, const Collidable* otherCollidable_, 
                                              const Math::Point<>& otherVel_, HitInfo& hitInfo_) const {
                return getShape()->getFirstIntersection(_center, _rot, thisVel_, otherCollidable_->getShape(), 
                                                        otherCollidable_->getCenter(), otherCollidable_->getRot(), otherVel_, hitInfo_);
            }

            virtual bool getClosestRayIntersection(const Math::Point<>& rayOrigin_, const Math::Point<>& rayDir_, 
                Math::Point<>& hitPos_, float& t_, Math::Point<>& hitNormal_) const {
                return getShape()->getClosestRayIntersection(_center, _rot, rayOrigin_, rayDir_, hitPos_, t_, hitNormal_);
            }
        };

        class Volume : public Collidable {
            Shape* _shape;
        public:
            Volume(Shape* shape_, const Math::Point<>& center_=Math::g_origin, const Math::Matrix3x3& rot_=Math::g_identityMatrix3x3, 
                void* userPointer_=0, Utils::uint colGroup_=COL_GROUP_HIT_ALL_HIT_BY_ALL) : Collidable(center_,rot_,userPointer_,colGroup_), 
                _shape(shape_) {}

            inline void setBoundingRadius(const float& boundingRadius_) { _shape->_boundingRadius = boundingRadius_; }

            inline float getBoundingRadius() const { return _shape->_boundingRadius; }

            virtual Shape* getShape() { return _shape; }

            virtual const Shape* getShape() const { return _shape; }
        };
    }
}

#endif //CDVOLUME_H