hgePolygon.h

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

#ifndef HGEPOLYGON__
#define HGEPOLYGON__

// Shape
#include "hgeShape.h"

// Polygon
#include "hgeLine.h"
#include "hgeTriangle.h"
#include "hgeProperties.h"

// Resource
#include "hgeResourceReader.h"

// HGE
#include <hge.h>
#include <hgevector.h>
#include <hgesprite.h>

// STD
#include <vector>

class hgeEntityEx;

// Cached Texture Data

struct hgePolyTextureData
{
    HTEXTURE tex;
    hgeVector original_size;
};

// Polygon Texture Data

struct hgePolyData
{
    hgePolyTextureData tex;

    int blend;
    DWORD color;

    bool tiled;
    float xoffset;
    float yoffset;
    float scale;

    bool bordered;
    hgePolyTextureData bordertex;
    float bordermin;
    float bordermax;
    float borderheight;
    float borderscale;

    bool shadowed;
    bool shadow_follow_border;
    hgePolyTextureData shadowtex;
    float shadowheight;
    float shadowscale;
    DWORD shadowcolor;

};

// Polygon Vertex


struct hgePVertex
{
    hgeVector pos;
    hgePVertex * next;
    float normal;

    hgePVertex(hgeVector p)
    {
        normal = 0;
        pos = p;
        next = NULL;
    }
};

// Polygon

class hgePolygon : public hgeShape
{
private:

    // Border Data
    std::vector<hgeQuad *> borderquads;
    std::vector<hgeTriple *> bordertris;
    std::vector<hgeQuad *> shadowquads;

    // Creates texture data - used internally on load
    hgePolyTextureData GetTexture(const char *filename);

    // Hotspot for move operations
    hgeVector hotspot;

    // Triangle Ops

    // Triangle Count
    inline int TriCount() { return (int)triangles.size(); }

    // Clear all triangles
    void ClearTris();

    // Add a triangle
    inline void AddTri(hgeTriangle * t) { triangles.push_back(t); }

    // Core

    // Calculate & store vertex normals
    void CalcNormals();

    void CalcAABB();

    // Generates triangle mesh
    bool GenerateMesh(bool testc = true);

    // Generates border
    void GenerateBorder();

    // Calculate texture coordinates on the main mesh
    void CalcTexCoords(bool calcall = true);

protected:

        bool is_entity;

    hgeRect aabb;

    hgeVector center;

    hgeSprite *sprite;

    HGE *hge;

    class hgePolygonMap * map;

public:

    // Public Data

    std::vector<hgePVertex *>vertices;

    std::vector<hgeTriangle *>triangles;

    hgePolyData texture_data;

    hgeProperties entity_data;


    // Public Interface

    // Load Interface
        void Load(hgeResourceReader *file);

    // Renders polygon
        virtual void Render();

    // Renders polygon outline
    void RenderOutline();

    inline bool IsPoint() { return vertices.size() <= 1; }

        inline bool IsPoly() { return !IsPoint(); }

    inline bool IsEntity() { return is_entity; }


    void Copy(hgePolygon *);

    inline void SetMap(hgePolygonMap *m_Map) { map = m_Map; }

    // Collision Routines

    hgeIntersect Intersects(hgeCircle circle, hgeVector offset = hgeVector(0,0));
    hgeIntersect Intersects(hgeCircle *circle, hgeVector offset = hgeVector(0,0));
    hgeIntersect Intersects(hgeLine line,     hgeVector offset = hgeVector(0,0));
    hgeIntersect Intersects(hgeLine *line,     hgeVector offset = hgeVector(0,0));
    hgeIntersect Intersects(hgePolygon *p,     hgeVector offset = hgeVector(0,0));
    hgeIntersect Intersects(hgeEntityEx *p,     hgeVector offset = hgeVector(0,0), float rot = 0);

    // Fetches triangle from polygon at given point
        hgeTriangle * TestGetTriangle(hgeVector point);

        inline bool TestPoint(hgeVector point)
    {
        if (IsPoint())
            return aabb.TestPoint(point.x, point.y);
        else
            return TestGetTriangle( point ) != NULL;
    }


    // Manipulation

    inline hgeSprite *GetSprite() { return sprite; }

    inline hgeRect GetAABB() { return aabb; }

    inline hgeVector GetCenter() { return center; }

    inline void SetAABBSize(hgeVector m_size)
    {
        aabb.x2 = aabb.x1 + m_size.x;
        aabb.y2 = aabb.y1 + m_size.y;
        center = hgeVector(aabb.x1 + (m_size.x / 2), aabb.y1 + (m_size.y / 2));
    }

    inline void SetAABB(hgeVector m_position, hgeVector m_size)
    {
        aabb.x1 = m_position.x;
        aabb.y1 = m_position.y;
        SetAABBSize(m_size);
    }

    // Sets texture
    void SetTexture(HTEXTURE m_texture, int m_blend = -1);

        inline void SetHotSpot(hgeVector m_hotspot) { hotspot = m_hotspot; }

    inline hgeVector GetHotSpot() { return hotspot; }

    // Moves Polygon
        void Shift(hgeVector amount);

        inline hgeVector GetPosition() { return hgeVector(aabb.x1, aabb.y1) + hotspot; }

        inline void SetPosition(hgeVector pos) { Shift(pos - (hgeVector(aabb.x1, aabb.y1) + hotspot)); }


    // Vertex Ops

    // Adds a vertex to the polygon
        hgePVertex * AddVertex(hgeVector pos);

    // Removes a vertex from the polygon
    void RemoveVertex(hgePVertex * which);

    // Clears all vertices
    void ClearVertices();
        
    // Vertex Count
    inline int VertexCount() { return (int)vertices.size(); }


    // Constructor / Destructor

        hgePolygon(class hgePolygonMap *pmap = NULL) : hgeShape(HGESHAPE_POLYGON)
        {
        map = pmap;
        hge = hgeCreate(HGE_VERSION);
        is_entity = false;
        aabb.x1 = 0; aabb.y1 = 0;
        aabb.x2 = 0; aabb.y2 = 0;
        sprite = NULL;
        }

        ~hgePolygon()
        {
                ClearVertices();
                ClearTris();

        // Clear Border
        for (unsigned i=0; i<borderquads.size(); i++)
            delete borderquads[i];

        for (unsigned i=0; i<bordertris.size(); i++)
            delete bordertris[i];

        for (unsigned i=0; i<shadowquads.size(); i++)
            delete shadowquads[i];

        hge->Release();
        };
};



#endif

---