graph.hpp

//
//  SuperTuxKart - a fun racing game with go-kart
//  Copyright (C) 2016 SuperTuxKart Team
//
//  This program is free software; you can redistribute it and/or
//  modify it under the terms of the GNU General Public License
//  as published by the Free Software Foundation; either version 3
//  of the License, or (at your option) any later version.
//
//  This program 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 General Public License for more details.
//
//  You should have received a copy of the GNU General Public License
//  along with this program; if not, write to the Free Software
//  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.

#ifndef HEADER_GRAPH_HPP
#define HEADER_GRAPH_HPP

#include "utils/no_copy.hpp"
#include "utils/vec3.hpp"

#include <dimension2d.h>

#include <memory>
#include <string>
#include <vector>

namespace irr
{
    namespace scene { class ISceneNode; class IMesh; class IMeshBuffer; }
    namespace video { class ITexture; struct S3DVertex; class SColor; }
}

using namespace irr;

class Quad;
class RenderTarget;

class Graph : public NoCopy
{
protected:
    static Graph* m_graph;

    std::vector<Quad*> m_all_nodes;

    // ------------------------------------------------------------------------
    void createQuad(const Vec3 &p0, const Vec3 &p1, const Vec3 &p2,
                    const Vec3 &p3, unsigned int node_index,
                    bool invisible, bool ai_ignore, bool is_arena,
                    bool ignore);
    // ------------------------------------------------------------------------
    void loadBoundingBoxNodes();

private:
    Vec3 m_bb_min;
    Vec3 m_bb_max;

    int m_bb_nodes[4];

    scene::ISceneNode *m_node;

    scene::IMesh *m_mesh;

    scene::IMeshBuffer *m_mesh_buffer;

    float m_scaling;

    std::unique_ptr<RenderTarget> m_render_target;

    // ------------------------------------------------------------------------
    void createMesh(bool show_invisible=true,
                    bool enable_transparency=false,
                    const video::SColor *track_color=NULL,
                    bool invert_x_z = false, bool flatten = false);
    // ------------------------------------------------------------------------
    void createMeshSP(bool show_invisible=true,
                      bool enable_transparency=false,
                      const video::SColor *track_color=NULL,
                      bool invert_x_z = false);
    // ------------------------------------------------------------------------
    void cleanupDebugMesh();
    // ------------------------------------------------------------------------
    virtual bool hasLapLine() const = 0;
    // ------------------------------------------------------------------------
    virtual void differentNodeColor(int n, video::SColor* c) const = 0;

public:
    static const int UNKNOWN_SECTOR;
    // For 2d Quad
    static const float MIN_HEIGHT_TESTING;
    static const float MAX_HEIGHT_TESTING;
    // ------------------------------------------------------------------------
    static Graph* get() { return m_graph; }
    // ------------------------------------------------------------------------
    static void setGraph(Graph* graph)
    {
        assert(m_graph == NULL);
        m_graph = graph;
    }   // setGraph
    // ------------------------------------------------------------------------
    static void destroy()
    {
        if (m_graph)
        {
            delete m_graph;
            m_graph = NULL;
        }
    }   // destroy
    // ------------------------------------------------------------------------
    Graph();
    // ------------------------------------------------------------------------
    virtual ~Graph();
    // ------------------------------------------------------------------------
    void createDebugMesh();
    // ------------------------------------------------------------------------
    RenderTarget* makeMiniMap(const core::dimension2du &dimension,
                              const std::string &name,
                              const video::SColor &fill_color,
                              bool invert_x_z);
    // ------------------------------------------------------------------------
    void mapPoint2MiniMap(const Vec3 &xyz, Vec3 *out) const;
    // ------------------------------------------------------------------------
    Quad* getQuad(unsigned int i) const
    {
        assert(i < m_all_nodes.size());
        return m_all_nodes[i];
    }
    // ------------------------------------------------------------------------
    unsigned int getNumNodes() const { return (unsigned int)m_all_nodes.size(); }
    // ------------------------------------------------------------------------
    void findRoadSector(const Vec3& XYZ, int *sector,
                        std::vector<int> *all_sectors = NULL,
                        bool ignore_vertical = false) const;
    // ------------------------------------------------------------------------
    int findOutOfRoadSector(const Vec3& xyz,
                            const int curr_sector = UNKNOWN_SECTOR,
                            std::vector<int> *all_sectors = NULL,
                            bool ignore_vertical = false) const;
    // ------------------------------------------------------------------------
    const Vec3& getBBMin() const                           { return m_bb_min; }
    // ------------------------------------------------------------------------
    const Vec3& getBBMax() const                           { return m_bb_max; }
    // ------------------------------------------------------------------------
    const int* getBBNodes() const                        { return m_bb_nodes; }

};   // Graph

#endif