meshresource.h

/*--License:
        Lilith 3D Engine
        Copyright Lee Thomason (Grinning Lizard Software) 2002-2007
        www.grinninglizard.com/lilith

        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 2
        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.

        The full text of the license can be found in license.txt
*/

#ifndef LILITH_MESHRESOURCE_INCLUDED
#define LILITH_MESHRESOURCE_INCLUDED

#ifdef _MSC_VER
#pragma warning ( disable : 4786 )
#endif

#include "worlddefine.h"
#include "../grinliz/glutil.h"
#include "../grinliz/glgeometry.h"
#include "../grinliz/glcontainer.h"
#include "worlddefine.h"
#include "meshgroup.h"
#include "simplemesh.h"
#include "genericobject.h"


#include <string>
#include <vector>
#include <map>
#include <list>
#include <set>


namespace lilith3d
{

class Texture;
class TreeResource;
class AnimatedResource;
class MD2Resource;
class StaticResource;
class ShadowVolumeCache;

class Tri
{
public:
        // FIXME: get rid of constructor
        Tri() : facingLight(0) {
                Init();
        }
        bool NeedShadowSide( const Tri* triArray, int side ) const {
                GLASSERT( side >=0 && side < 3 );
                GLASSERT( facingLight );
                if ( adjacent[side] == NO_ADJACENT || !triArray[ adjacent[side] ].facingLight )
                        return true;
                return false;
        }
        void Init() {
                adjacent[0] = adjacent[1] = adjacent[2] = NO_ADJACENT;
                facingLight = 0;
        }

        // Indices are inferred. Every 3 index is a tri.
        mutable U32 facingLight;        // working flags - set during the lighting pass
        int adjacent[3];                        // indices of adjacent tris.
        enum { NO_ADJACENT = -1 };
};

enum
{
        SMOOTH_SHADING  = 0x01, 
};

struct PathSurface
{
        PathSurface()
        {
                numVertex = 0;
                pad.hasPad = 0;
                for( int i=0; i<4; ++i ) {
                        vertex[i].Set( 0.0f, 0.0f, 0.0f );
                        neighbor[i] = 0;
                }
                index = 0;
        }
        //void Init( const grinliz::Vector3F* v, int num ) 
        //{
        //      numVertex = num;
        //      memcpy( vertex, v, sizeof( grinliz::Vector3F) * num );
        //}

        unsigned                        numVertex;              // 3 or 4 vertices
        grinliz::Vector3F       vertex[4];              // the vertices of the path (will be in global coordinates for meshes)
        PathSurface                     *neighbor[4];
        union {
                U32 hasPad;
                U8 isPad[4];
        } pad;
        int                                     index;
};


// used by an instance of a building to record its path
struct PathSurfaceInstance
{
        PathSurfaceInstance() : numVertex( 0 )
        { 
                GLASSERT( !(psiMobRing.psi && psiMobRing.mob ) );
                psiMobRing.psi = this; 
                pad.hasPad = 0;
                for( unsigned i=0; i<4; ++i )
                {
                        neighbor[i] = 0;
                }
        }

        unsigned                        numVertex;              // 3 or 4 vertices
        grinliz::Vector3F       vertex[4];              // the vertices of the path (global coordinates for meshes)
        PathSurfaceInstance* neighbor[4];       // the neighbor is lined up with the vertex array and the
                                                                                // padVertex value.     
        union {
                U32 hasPad;
                U8 isPad[4];
        } pad;
        PSIMobRing                      psiMobRing;

        void CalcEdge( unsigned i, grinliz::Vector3F* v0, grinliz::Vector3F* v1 ) const
        {
                *v0 = vertex[i];
                *v1 = vertex[(i+1)%numVertex];
        }

        void CalcCentroid( grinliz::Vector3F* center ) const {
                center->Set( 0.0f, 0.0f, 0.0f );
                for( unsigned i=0; i<numVertex; ++i ) {
                        center->x += vertex[i].x;
                        center->y += vertex[i].y;
                        center->z += vertex[i].z;
                }
                center->x /= (float)numVertex;
                center->y /= (float)numVertex;
                center->z /= (float)numVertex;
        }

private:
        PathSurfaceInstance( const PathSurfaceInstance& );
        void operator=( const PathSurfaceInstance& );
};

typedef std::vector< PathSurfaceInstance* > PSIVector;
typedef std::vector< PathSurface* > PathSurfaceVector;
typedef std::list< PathSurface* > PadList;
typedef std::list< PathSurface* >::iterator PadListIterator;

class MeshResource
{
  public:
        MeshResource( const std::string& name );
        virtual ~MeshResource();

//  Note this is specifically *not* virtual. Too hard to have one consistent model.
//      virtual void  StreamOut( bool useBlend, 
//                                                       bool useAlphaTest, 
//                                                       float testAlpha ) const = 0;

        const grinliz::Rectangle3F& AABB() const        { return aabb; }

        const std::string& Name() const                         { return name; }
        int   TotalTri() const                                          { return totalTri; }

        virtual int IntersectRay( const grinliz::Vector3F& /*point*/, const grinliz::Vector3F& /*dir*/, grinliz::Vector3F* /*intersection*/ )
        {
                return grinliz::REJECT;
        }

        // Sleazy RTTI
        virtual const StaticResource*   ToStatic() const                { return 0; }
        virtual const TreeResource*             ToTree() const                  { return 0; }
        virtual const AnimatedResource* ToAnimated() const              { return 0; }
        virtual const MD2Resource*              ToMD2() const                   { return 0; }

  protected:
        int totalTri;
        grinliz::Rectangle3F            aabb;
        
  private:
        std::string                                     name;
};

#ifdef _MSC_VER
#pragma warning( disable : 4355 )       // this in initializer list
#endif

class StaticResource : public MeshResource
{
#ifdef DEBUG
        friend class MeshResManager;
#endif
  public:
        StaticResource( const std::string& name, int flags );
        virtual ~StaticResource();
        virtual const StaticResource* ToStatic() const { return this; }

        //bool Import( const std::string& filename );

        int NumObject() const           { return (int) objects.size(); }

        void StreamOut( const Shader* shader, float alpha, ELightPass light ) const;
        void StreamOutVertex() const;

        #ifdef SHADOW_VOLUME
        void StreamOutShadow( ShadowVolumeCache*, const grinliz::Matrix4& mat ) const;
        #endif

        // Importing
        void SetBaseMatrix( const grinliz::Matrix4& matrix );
        void PushObject( const char* name, const grinliz::Matrix4& matrix, const Texture* tex );
        void PushSurface( int numVertex, float normalX, float normalY, float normalZ );
        void PushVertex( float x, float y, float z, float tx, float ty );

        void PopObject();
        virtual void ImportDone();

        virtual const TreeResource* ToTreeResource() const      { return 0; }

        // Used by the instace class to get to the pathing information.
        void CalcPathingInfo(   PSIVector* psi,
                                                        //TerrainConnectorVector* tcv,
                                                        const grinliz::Vector3F& location ) const;

        // Debugging / Info
        void Dump();
        int NumVertex() const 
                                        {       U32 num = 0;
                                                for( unsigned i=0; i<objects.size(); ++i )
                                                        num += objects[i]->NVertex();
                                                return (int)num;
                                        }
        int NumIndex() const
                                        {       U32 num = 0;
                                                for( unsigned i=0; i<objects.size(); ++i )
                                                        num += objects[i]->NIndex();
                                                return (int)num;
                                        }

        virtual int IntersectRay( const grinliz::Vector3F& point, const grinliz::Vector3F& dir, grinliz::Vector3F* intersection ) const;
        int TotalTri() const    { return totalTri; }

  protected:
        // The lower call of push vertex. This expects 3 vertices in a row
        // that define a Tri. PushVertex will "buffer" this method in order
        // to make quads work.
        void PushVertexTri( float x, float y, float z, float tx, float ty );
        void GetCompMatrix( grinliz::Matrix4* out );

        // Output
        std::vector< SimpleMesh* >      objects;

        int                                                     flags;

  private:
        void StreamOutPather() const;
        void PushPatherSurface( grinliz::Vector3F* vertices, unsigned numVertex );
        bool ConnectPaths();
        void ConnectEdge( PathSurface* ps, int edgeIndex);
        void CheckForPad( PathSurface* ps );    // take a look at the PS and decide if it is a pad.

        void DeletePathData();
        void CleanPathData();

        // Use vectors so the generation of instance paths is reasonable.
        PathSurfaceVector                               pathSurface;

        // State
        std::vector< grinliz::Matrix4 > matrixStack;
        grinliz::Vector3F                               currentNormal;
        int                                                             currentObject;
        int                                                             numVertexInSurface;
        int                                                             currentVertex;
        int                                                             totalTri;

        // When vertices are getting pushed, they are accumulated
        // before being added in order to accept either quads or tris
        grinliz::Vector3F vertexBuffer[4];
        grinliz::Vector2F textureXYBuffer[4];
        
        PadList padList;
        grinliz::Rectangle2I pathBound;         // PathSurfaces must be inside the building bounds else
                                                                                // walkers will "jump" onto the upper floors.

        unsigned displayListId;
        void DumpRec( SimpleMesh*, int d );
};


typedef std::map< std::string, MeshResource* > MeshResourceMap;
typedef MeshResourceMap::iterator MeshResourceMapIterator;

class MeshResManager
{
  public:
        enum
        {
                NORMAL,
                TREE
        };

        static MeshResManager* Instance()       {       //if ( !instance ) instance = new MeshResManager();
                                                                                        return instance;
                                                                                }
        MeshResManager();
        ~MeshResManager();

        void SetImportPath( const std::string& path )   { importPath = path; }
        const std::string& ImportPath()                                 { return importPath; }

        bool LoadRequiredModels();

        StaticResource* LoadStaticRes(  const std::string& filename, const std::string& name, U32 flags );
        MD2Resource*    LoadMD2Res(     const std::string& md2Filename, const std::string& name );
        MD2Resource*    LoadMD2ResComplete(     const std::string& name,
                                                                                const std::string& md2Tri,
                                                                                const std::string& skin,
                                                                                const std::string& md2Weapon,
                                                                                const std::string& weaponSkin );        
        TreeResource*   LoadTreeRes(    const std::string& filename, const std::string& name,
                                                                        const std::string& shadowName, U32 shadowId );

        bool IsResource( const std::string& meshName );
        const MeshResource*     GetMeshRes( const std::string& meshName );

        const StaticResource* GetStaticRes( const std::string& meshName )
        {
                const MeshResource* res = GetMeshRes( meshName );
                if ( res ) return res->ToStatic();
                return 0;       
        }
        const AnimatedResource* GetAnimatedRes( const std::string& meshName )
        {
                const MeshResource* res = GetMeshRes( meshName );
                if ( res ) return res->ToAnimated();
                return 0;       
        }
        const MD2Resource* GetMD2Res( const std::string& meshName )
        {
                const MeshResource* res = GetMeshRes( meshName );
                if ( res ) return res->ToMD2();
                return 0;       
        }

        // OPTIMIZATION: do not use.
        const TreeResource* treeResourceArray[MAX_TREE_RESOURCE];
        int                                     nTreeResource;

  protected:
        // Imports to 'static' and 'tree'
        bool Import( const std::string& filename, StaticResource* meshRes );

        static MeshResManager*  instance;
        MeshResourceMap                 resourceMap;
        std::string                             importPath;
};
};      //namespace lilith3d

#endif

---