CollisionGrid.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 engine_area_CollisionGrid_hpp
#define engine_area_CollisionGrid_hpp

#include "util/type/util_type.hpp"
#include "sim_react.hpp"
#include "sim/pos/sim_pos.hpp"
#include "sim/sim.hpp"
#include "sim/config/sim_config.hpp"
#include "sim/thing/sim_thing.hpp"
#include "sim/stat/sim_stat.hpp"
#include "util/vecmath/util_vecmath.hpp"
#include "util/template/SinglyLinkedList.hpp"



namespace se_core {
    // CollisionGridThingList
    // Typedef of singly linked lists container that
    // will hold members of all singly linked lists
    // of all grid containers.
    typedef SinglyLinkedList<class CollisionComponent, MAX_GAME_OBJECTS, 243> CGTL;
    struct CollisionGridCollisionComponentList : public CGTL {
        CollisionGridCollisionComponentList(const char* name) : CGTL(name) {}
    };

    class _SeCoreExport CollisionGrid {
    public:
        CollisionGrid(coor_tile_t width, coor_tile_t height, short depth);
        virtual ~CollisionGrid();

        void setSize(int width, int height);

        void setOffset(const Point3& c);

        inline int lineOffset(short level) {
            return 1 << level;
        }

        inline coor_tile_t nodeSize(short level) {
            return shiftRight(rootNodeSize_, level);
        }

        inline coor_tile_t halfNodeSize(short level) {
            return shiftRight(halfRootNodeSize_, level);
        }

        inline int calcLevel(coor_tile_t size) {
            // Find the right level
            short level = 0;
            while((level + 1) < depth_ && halfNodeSize(level) > size)
                ++level;
            return level;
        }


        inline int indexAtLevel(coor_tile_t x, coor_tile_t z, short level) {
            Assert(level < depth_);
            coor_tile_t nodeX = shiftRight(x, (rootNodeShift_ - level));
            coor_tile_t nodeZ = shiftRight(z, (rootNodeShift_ - level));
            return nodeX + nodeZ * lineOffset(level);
        }

        inline int indexAtLevelAndNode(coor_tile_t nodeX, coor_tile_t nodeZ, short level) {
            Assert(level < depth_);
            return nodeX + nodeZ * lineOffset(level);
        }

        void insert(const Point3& c, coor_t size, CollisionComponent& thing);

        bool remove(const Point3& c, coor_t size, CollisionComponent& thing);

        void move(const Point3& from, coor_t oldSize
                  , const Point3& to, coor_t newSize, CollisionComponent& thing);

        short collisionCandidates(const Point3& c, coor_t size
                                    , CollisionComponent* things[], short max);

        bool find(CollisionComponent& thing);

        void clear();

    private:
        static coor_tile_t shiftRight(coor_tile_t value, short shift) {
            return value >> shift;
            //return value / ((coor_world_t)(1L << shift));
        }

        static coor_tile_t shiftLeft(coor_tile_t value, short shift) {
            return value << shift;
            //return value * (1L << shift);
        }

        coor_tile_t xOffset_, zOffset_;

        coor_tile_t rootNodeSize_;
        short rootNodeShift_;

        short depth_;

        coor_tile_t halfRootNodeSize_;

        CollisionGridCollisionComponentList::iterator_type* nodes_;
        short totalNodeCount_;

        CollisionGridCollisionComponentList::iterator_type** nodeLevels_;

        static CollisionGridCollisionComponentList& thingList() {
            static CollisionGridCollisionComponentList instance(__FILE__);
            return instance;
        }

    };
}

#endif

---

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