Roads.h

//
// Roads.h
//
// Copyright (c) 2001-2011 Virtual Terrain Project
// Free for all uses, see license.txt for details.
//

#ifndef TERRAINROADSH
#define TERRAINROADSH


#include "vtdata/FilePath.h"
#include "vtdata/RoadMap.h"
#include "vtdata/HeightField.h"
#include "LodGrid.h"

#define ROAD_CLUSTER    16

class NodeGeom : public TNode
{
public:
    NodeGeom();
    virtual ~NodeGeom();

    class LinkGeom *GetLink(int n)
    {
        return (class LinkGeom *)m_connect[n].pLink;
    }
    void BuildIntersection();
    void FindVerticesForLink(TLink *pR, bool bStart, FPoint3 &p0, FPoint3 &p1);
    vtMesh *GenerateGeometry();
    FPoint3 GetLinkVector(int i);
    FPoint3 GetUnitLinkVector(int i);
    const FPoint3 &GetAdjacentRoadpoint(int iLinkNumber);

    int m_iVerts;
    FLine3 m_v;     // vertices of the polygon
    FPoint3 m_p3;
};

//
// Holds information about a roadway, used internally by vtRoadMap3d during
// road construction.
//
class RoadBuildInfo
{
public:
    RoadBuildInfo(int iCoords);
    FLine3 center;
    FLine3 crossvector;
    vtArray<float> fvLength;

    int verts;
    int vert_index;
};

enum normal_direction {
    ND_UP,
    ND_LEFT,
    ND_RIGHT
};

class VirtualTexture
{
public:
    int     m_idx;  // material index
    FRECT   m_rect; // region of the base texture to use

    void Adapt(const FPoint2 &in, FPoint2 &out)
    {
        out.x = m_rect.left + in.x * (m_rect.right - m_rect.left);
        out.y = m_rect.bottom + in.y * (m_rect.top - m_rect.bottom);
    }
};

//
// virtual texture indices
//
enum RoadVTIndices
{
    VTI_MARGIN,
    VTI_SIDEWALK,
    VTI_1LANE,
    VTI_2LANE1WAY,
    VTI_2LANE2WAY,
    VTI_3LANE1WAY,
    VTI_3LANE2WAY,
    VTI_4LANE1WAY,
    VTI_4LANE2WAY,
    VTI_RAIL,
    VTI_4WD,
    VTI_TRAIL,
    VTI_STONE,
    VTI_TOTAL
};

class LinkGeom : public TLink
{
public:
    LinkGeom();
    virtual ~LinkGeom();

    FPoint3 FindPointAlongRoad(float fDistance);
    float   Length();   // find 2D length in world units

    // link-construction methods
    void SetupBuildInfo(RoadBuildInfo &bi);
    void AddRoadStrip(vtMesh *pGeom, RoadBuildInfo &bi,
                    float offset_left, float offset_right,
                    float height_left, float height_right,
                    VirtualTexture &vt,
                    float u1, float u2, float uv_scale,
                    normal_direction nd);
    void GenerateGeometry(class vtRoadMap3d *rmgeom);

    NodeGeom *GetNode(int n) { return (NodeGeom *)m_pNode[n]; }
    LinkGeom *GetNext() { return (LinkGeom *)m_pNext; }

    int m_vti;
    FLine3 m_centerline;

    /* Lanes lines, which define the centerline of each trafficable lane,
     * are created by vtRoadMap3d for traffic simulation/visualization
     * purposes.
     */
    std::vector<FLine3> m_Lanes;
};


class vtRoadMap3d : public vtRoadMap, public osg::Referenced
{
public:
    vtRoadMap3d();
    ~vtRoadMap3d();

    // overrides for virtual methods
    LinkGeom    *GetFirstLink() { return (LinkGeom *) m_pFirstLink; }
    NodeGeom    *GetFirstNode() { return (NodeGeom *) m_pFirstNode; }
    TNode       *NewNode() { return new NodeGeom; }
    TLink       *NewLink() { return new LinkGeom; }

    void DrapeOnTerrain(vtHeightField3d *pHeightField);
    void BuildIntersections();
    void AddMeshToGrid(vtMesh *pMesh, int iMatIdx);
    vtGroup *GenerateGeometry(bool do_texture, bool progress_callback(int) = NULL);
    void GenerateSigns(vtLodGrid *pLodGrid);
    vtGroup *GetGroup() { return m_pGroup; }
    void SetHeightOffGround(float fHeight) { s_fHeight = fHeight; }
    void DetermineSurfaceAppearance();

    void SetLodDistance(float fDistance);
    float GetLodDistance();

public:
    static float s_fHeight;

    // virtual textures
    VirtualTexture  m_vt[VTI_TOTAL];

    // material indices
    int     m_mi_roadside;
    int     m_mi_pavement;
    int     m_mi_roads;
    int     m_mi_4wd;
    int     m_mi_trail;
    int     m_mi_red;

protected:
    void _CreateMaterials(bool do_texture);
    void _GatherExtents();

    vtGroup *m_pGroup;
    vtMaterialArrayPtr m_pMats;

    vtLOD       *m_pRoads[ROAD_CLUSTER][ROAD_CLUSTER];
    FBox3       m_extents;
    FPoint3     m_extent_range;
    float       m_fLodDistance;     // in meters
};
typedef osg::ref_ptr<vtRoadMap3d> vtRoadMap3dPtr;

// Useful typedefs
typedef NodeGeom *NodeGeomPtr;
typedef LinkGeom *LinkGeomPtr;
  // transp

#endif