hgePolygonMap.h

//
// Opal SDK 1.0 
// Copyright(C) 2009, Paul Blower
//

#ifndef HGEPOLYGONMAP__
#define HGEPOLYGONMAP__

#include "hgeDataGrid.h"
#include "hgePolygon.h"
#include "hgeEntity.h"

// Definition of render layers for static entitys & polygons
enum hgePolygonMapLayers
{
    HGELAYER_BACK = 0,
    HGELAYER_MIDDLE = 1,
    HGELAYER_FRONT = 2
};

// Quick lookup struct for dynamic entity list
struct __quickEntityLookup
{
    int id;                             // Class ID
    int layer;                          // Render Layer
    std::string classname;              // Class string
    std::vector<hgeEntity *> entitys;   // Array

    __quickEntityLookup() : id(-1), layer(-1) {}
    __quickEntityLookup(int m_id, int m_layer, std::string m_classname) : id(m_id), layer(m_layer), classname(m_classname) { }
};

class hgePolygonMap
{
        private:

        // Viewport
        hgeRect view;
        hgeVector viewSize;
        hgeVector viewSize_2; // half size

        // Map size
        hgeRect map_size;

        // HGE Interface
        HGE *hge;

        // Linear polygon arrays
        // TODO
        std::vector<hgePolygon *> background;
                std::vector<hgePolygon *> middleground;
                std::vector<hgePolygon *> foreground;

        // Linear entity array of dynamic entitys
        std::vector<hgeEntity *> entitys;

        // Fast lookup list for dynamic entitys
        std::vector<__quickEntityLookup *> entity_lookup;

        // Lookup functions
        void CreateEntityLookup(__quickEntityLookup lookup);

        // Counter for generating unique class id's
        int entityClassIDCounter;
                
        // Entity class register
        std::vector<hgeEntity*> entClasses;

        // PolygonGrid for optimized functions
        hgePolygonGrid *grid;

        // Transform data
        float zoom;
        float rotation;
        hgeVector pos;

        hgePolygon *AddPolygon(hgePolygon * p, int layer = HGELAYER_BACK);

        // Gets pointer to the vector of given layer
        std::vector<hgePolygon *> * GetLayer(int l);

        public:

        // Save / Load interface
                bool SaveFile(std::string filename = "MyFile.map");
                bool LoadFile(std::string filename = "MyFile.map");

        // Gets lists of dynamic entitys
        std::vector<hgeEntity *> *GetDynamicEntityList(int m_renderlayer);
        std::vector<hgeEntity *> *GetDynamicEntityList(std::string m_classname);

        // Returns a polygon from its "name" property in entity data
        hgePolygon *GetStaticEntityFromProperty(std::string m_pname, std::string m_pval);
        hgePolygon *GetDynamicEntityFromProperty(std::string m_pname, std::string m_pval);
        // TODO: implement these as faster companions to the above
//         hgePolygon *GetStaticEntityFromProperty(std::string m_classname, std::string m_pname, std::string m_pval);
//         hgePolygon *GetDynamicEntityFromProperty(std::string m_classname, std::string m_pname, std::string m_pval);
         // TODO: GetEntitysFromClassname

        // Registers a hgeEntity derived class to the map
        void RegisterEntityClass(std::string entclass, hgeEntity *ent);

        // Set camera transformation
        void SetTransform(hgeVector m_pos, float m_zoom = 1);

        // Converts world coordinates to screen coordinates
        hgeVector MapToScreen(hgeVector pos);

        // Converts screen coordinates to world coordinates
        hgeVector ScreenToMap(hgeVector pos);

        // Adds a dynamic entity to the map
        void hgePolygonMap::AddDynamicEntity(hgeEntity *entity, bool initialize_entity = true);

        // Removes dynamic entitys by their classname
        void hgePolygonMap::RemoveDynamicEntitys(std::string entity_class);

        // Quick check to see if a polygon is visible - TODO: abstract to shape
        bool TestVisibility(hgePolygon *p, float padding = 0);

        // Returns a polygon closest to given point (point should be in map coordinates)
                hgePolygon * TestPoint(hgeVector pos, int test_type = COLLIDE_STATIC, std::string class_filter = "",  int layer_filter = -1);

        // Collision Test
                hgeIntersect Test(  hgeShape *shape, 
                            hgeVector offset = hgeVector(0,0), 
                            hgePolygon **return_poly = NULL, 
                            int test_type = COLLIDE_STATIC, 
                            std::string class_filter = "",  
                            int layer_filter = -1  );

        // Collision Test
        hgeIntersect TestEx(  hgeEntityEx *polygon, 
            hgeVector offset = hgeVector(0,0),
            float rot = 0,
            hgePolygon **return_poly = NULL, 
            int test_type = COLLIDE_STATIC, 
            std::string class_filter = "",  
            int layer_filter = -1  );

        // Clear the maps entitys + polygons. Doesn't clear registered entitys so no need to re-register.
        void Clear();

        // Update the map
                void Update(float dt);

        // Render the map
                void Render();

        // Constructor
                hgePolygonMap(hgeVector m_viewSize = hgeVector(800, 600));
};

#endif

---