IMotionUpdater.h

Go to the documentation of this file.

//    Copyright (C) 2004-2013 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 IMOTION_UPDATER_H
#define IMOTION_UPDATER_H

#include "CUpdater.h"
#include "CPhysicalObject.h"

#include <set>

namespace OpenSkyNet {
    namespace Core {
        class CORE_DLL MotionUpdater : public Updater {
        public:
            inline static void setForward(Math::Matrix3x3& rot_, Math::Point<>& forward_) {
                assert(forward_.getLenSqrd() > Math::CLOSE_TO_ZERO);
                forward_.normalize();
                Math::Point<> cross(rot_.col(1).getCross3(forward_));
                //right = up cross forward iff up and forward are not 
                //parallel or antiparallel.
                if (cross.getLenSqrd() > Math::CLOSE_TO_ZERO)
                    rot_.col(0) = cross;
                //up = forward cross right.
                rot_.col(1) = forward_.getCross3(rot_.col(0));
                rot_.col(2) = forward_;
            }

            enum ATTACH_POINT {
                BASE,
                VIEW,
                NUM_ATTACH_POINTS
            };

            struct Anchor {
                Object* _obj;

                bool _updatePos, _updateRot;
                Math::Point<> _localPos;
                Math::Matrix3x3 _localRot;

                bool _useAttachPoint;
                ATTACH_POINT _attachPoint;

                Anchor() : _obj(0), _updatePos(true), _updateRot(true), _useAttachPoint(false), _attachPoint(BASE) {}

                Anchor(Object* obj_, bool updatePos_=true, bool updateRot_=true, 
                    ATTACH_POINT attachPoint_=BASE, const Math::Matrix3x3& localRot_=Math::g_identityMatrix3x3) : _obj(obj_), 
                    _updatePos(updatePos_), _updateRot(updateRot_), _localRot(localRot_), _useAttachPoint(true), _attachPoint(attachPoint_) {}

                Anchor(Object* obj_, bool updatePos_, bool updateRot_, const Math::Point<>& localPos_, const Math::Matrix3x3& localRot_) : _obj(obj_), 
                    _updatePos(updatePos_), _updateRot(updateRot_), _localPos(localPos_), _localRot(localRot_), _useAttachPoint(false), _attachPoint(BASE) {}

                bool operator==(const Anchor& rhs_) const { return (_obj == rhs_._obj); }
                bool operator<(const Anchor& rhs_) const { return (_obj < rhs_._obj); }
            };

            struct MotionInfo : public Updater::UpdateInfo {
                Math::Point<> _attachPoints[NUM_ATTACH_POINTS];
                std::set<Anchor> _anchors;

                MotionInfo(Updater::OBJECT_PRIORITY prio_=Updater::OBJ_DISABLED, bool isOneShot_=false) : Updater::UpdateInfo(prio_,isOneShot_) {}
            };

        protected:
            std::map<Object*, MotionInfo*> _nonCollidingInfoMap;

            virtual bool addObject(Object* obj_, Updater::OBJECT_PRIORITY prio_, bool isOneShot_) = 0;
            virtual bool removeObject(Object* obj_);
            virtual void removeAllObjects();

            virtual void updateAnchors(Object* obj_);
        public:
            MotionUpdater(Updater::UPDATER_TYPE type_, const char* typeName_, Updater::UPDATER_PRIORITY prio_, float interval_) : Updater(type_, typeName_, prio_, interval_) {}

            virtual void addAnchor(Object* base_, Object* anchor_, bool updatePos_, bool updateRot_, const Math::Point<>& localPos_, const Math::Matrix3x3& localRot_);
            virtual void addAnchor(Object* base_, Object* anchor_, bool updatePos_, bool updateRot_);

            virtual void removeAnchor(Object* base_, Object* anchor_);
            virtual void removeAllAnchors(Object* base_);
        };
    }
}

#endif //IMOTION_UPDATER_H