Pos.hpp

Go to the documentation of this file.

/*
SagaEngine library
Copyright (c) 2002-2006 Skalden Studio AS

This software is provided 'as-is', without any express or implied 
warranty. In no event will the authors be held liable for any 
damages arising from the use of this software.

Permission is granted to distribute the library under the terms of the 
Q Public License version 1.0. Be sure to read and understand the license
before using the library. It should be included here, or you may read it
at http://www.trolltech.com/products/qt/licenses/licensing/qpl

The original version of this library can be located at:
http://www.sagaengine.com/

Rune Myrland
rune@skalden.com
*/


#ifndef Pos_hpp
#define Pos_hpp

#include "Anim.hpp"
#include "util/vecmath/ViewPoint.hpp"
#include "util/bounds/BoundingBox.hpp"
#include "sim_pos.hpp"
#include "../sim.hpp"
#include "comp/comp.hpp"
#include "../area/sim_area.hpp"
#include "../config/sim_config.hpp"


namespace se_core {
    class _SeCoreExport Pos {
    public:
        static const short TS_VOID = 0;
        static const long TSM_VOID = (1 << TS_VOID);

        enum Direction {
            EAST = 0, SOUTH_EAST = 32,
            SOUTH = 64, SOUTH_WEST = 96,
            WEST = 128, NORTH_WEST = 160,
            NORTH = 192, NORTH_EAST = 224
        };

        Pos();

        void setPos(const Pos& original);

        void setXZ(const Pos& original);

        inline void setLocalCoor(Point3& original) {
            localCoor().set(original);
        }

        inline const Point3& worldCoor() const { return world_.coor_; }

        inline Point3& worldCoor() { return world_.coor_; }
        inline const ViewPoint& worldViewPoint() const { return world_; }
        inline ViewPoint& worldViewPoint() { return world_; }

        #ifdef SE_QUAT
        const Quat4& worldFace() const { return world_.face_; }
        Quat4& worldFace() { return world_.face_; }
        #else
        const Euler3& worldFace() const { return world_.face_; }
        Euler3& worldFace() { return world_.face_; }
        #endif


        inline const Point3& localCoor() const { return local_.coor_; }
        inline Point3& localCoor() { return local_.coor_; }
        inline const ViewPoint& localViewPoint() const { return local_; }
        inline ViewPoint& localViewPoint() { return local_; }

        #ifdef SE_QUAT
        const Quat4& localFace() const { return local_.face_; }
        Quat4& localFace() { return local_.face_; }
        #else
        const Euler3& localFace() const { return local_.face_; }
        Euler3& localFace() { return local_.face_; }
        #endif


        inline bool localEquals(const ViewPoint& vp) const {
            return local_.viewPointEquals(vp);
        }

        inline bool localEquals(const Pos& p) const {
            return local_.viewPointEquals(p.local_);
        }

        inline bool worldEquals(const ViewPoint& vp) const {
            return world_.viewPointEquals(vp);
        }

        inline bool worldEquals(const Pos& p) const {
            return world_.viewPointEquals(p.world_);
        }


        void setArea(PosComponent& area, bool doKeepWorldCoor = false);

        void setArea(PosComponent& area, const ViewPoint& vp, bool isLocalViewPoint = true);

        void resetArea();

        void setParent(PosComponent& p, bool doKeepWorldCoor = false);

        void resetParent(bool doKeepWorldCoor = true);

        bool hasParent() const { return parent_ != 0; }

        bool didParentMove() const;

        PosComponent* parent() { return parent_; }
        const PosComponent* parent() const { return parent_; }

        void updateWorldViewPoint();
        void areaCoor(const PosComponent& area, Point3& dest) const;
        void areaFace(const PosComponent& area, Euler3& dest) const;
        void areaViewPoint(const PosComponent& area, ViewPoint& dest) const;

        void updateLocalViewPoint();

        PosComponent* area() { return area_; }

        const PosComponent* area() const { return area_; }


        bool hasArea() const { return area_ != 0; }

        bool hasArea(Composite& area) const;
        bool hasArea(Component& area) const;
        bool hasArea(PosComponent& area) const { return area_ != 0 && area_ == &area; }

        short terrainStyle() const;

        long touchedTerrain() const;

        bool isKeyFramePath(const Pos& other) const;


        short clockwiseFaceDirection(short subdivisions) const;


        bool hasInFront(const Point3& coor) const;


        bray_t xzFaceAwayAngle(const Point3& towards) const;


        inline coor_t radius() const { return bounds_.radius(); }


        inline void setRadius(coor_t radius) {
            bounds_.setMin(-radius, 0, -radius);
            bounds_.setMax(radius, 2 * radius, radius);
        }

        inline void setBounds(coor_t radius) {
            bounds_.setMin(-radius, 0, -radius);
            bounds_.setMax(radius, 2 * radius, radius);
        }

        inline void setBounds(coor_t radius, coor_t height) {
            bounds_.setMin(-radius, 0, -radius);
            bounds_.setMax(radius, height, radius);
        }

        inline void setBounds(const BoundingBox& b) {
            bounds_ = b;
        }

        inline bool hasInside(const Point3& p) const {
            return bounds_.hasInside(worldCoor(), p);
        }

        bool isInsideCollisionRange(const Pos& p) const;


        bool isInsideCollisionRangeLinf(const Pos& p) const;


        inline bool isGrounded() const { return isGrounded_; }

        inline void setGrounded(bool state) { 
            isGrounded_ = state;
            if(isGrounded_)
                updateY();
        }

        inline void setIndex(short i) { index_ = i; }
        
        inline short index() const { return index_; }

        inline bool hasIndex() const { return index_ >= 0; }

        inline void setNoIndex() { index_ = -1; }

        PosComponent* updateArea();
        void updateIndex();

        inline Anim& anim(int index) {
            return anim_[index];
        }


        inline const Anim& anim(int index) const {
            return anim_[index];
        }

        void swapAnims(int a, int b);


        void updateY();

        // Deprecated as the result of world_
        //coor_world_t pageDistanceSquared(const Pos& p) const;

        void reset() {
            area_ = 0;
            parent_ = 0;
            local_.setIdentity();
            world_.setIdentity();
            bounds_.reset();
            index_ = -1;
            isGrounded_ = false;
            anim_[0].setMovementMode(0, 0);
        }


    public:
        PosComponent* area_;

        PosComponent* parent_;

        ViewPoint local_;

        ViewPoint world_;

        enum { MAX_ANIMS = 4 };
        Anim anim_[MAX_ANIMS];

        //coor_t radius_;
        BoundingBox bounds_;

        short index_;

        bool isGrounded_;
    };

}

#endif

---

Home Page | SagaEngine trunk (updated nightly) reference generated Sun Dec 2 20:06:11 2007 by Doxygen version 1.3.9.1.