mesh.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_MESH_INCLUDED
#define LILITH_MESH_INCLUDED

#include <stdio.h>

#ifdef _MSC_VER
#pragma warning( disable : 4786 )       // Debugger truncating names.
#endif
#include <vector>
#include <list>
#include <string>
#include <map>

#include "worlddefine.h"
#include "meshgroup.h"
#include "meshnode.h"
#include "../grinliz/glcolor.h"
#include "../grinliz/glutil.h"
#include "../grinliz/glcontainer.h"
#include "genericobject.h"
#include "shader.h"

namespace lilith3d
{
class MeshResource;
class Texture;
class TerrainMesh;
class StaticResource;
class AnimatedResource;
class BuildingMesh;
class ShadowVolumeCache;

enum MeshClass
{
        DECALMESH               = 0x01,
        STATICMESH              = 0x02,
        FOLIAGEMESH             = 0x04, // grass, plants, etc. Uses a special shader.
        SOLIDMESH               = 0x08,
        BUILDINGMESH    = 0x10,
        ANIMATEDMESH    = 0x20,
        TREEMESH                = 0x40,

        SHADOW_CASTER_MESH = STATICMESH | BUILDINGMESH | ANIMATEDMESH,
        SHADOW_RECEIVER_MESH = DECALMESH | STATICMESH | BUILDINGMESH,
};


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

struct PathSurfaceInstance;
class Tri;



class Mesh : public MeshNode
{
  public:
        // After culling, the singly linked list of things that are drawn
        Mesh* nextRender;

  public:
        Mesh(   const MeshResource* meshResource, MeshClass type );
        virtual ~Mesh();

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

        /*  [Internal]
                Set the position of the mesh. This has to be virtual since the terrain can change
                and change the Z with it. (Although the QuadTree actually calls the UpdateZ() method.)
                This should only be called by the QuadTree()
        */
        virtual void UpdateZ( float z ) = 0;

        virtual void StreamOutMesh( ELightPass light, EPass pass ) = 0;

        #ifdef SHADOW_VOLUME
        virtual void StreamOutShadow( ShadowVolumeCache* ) {}
        #endif

        MeshClass                               Type() const                    { return type; }
        const MeshResource*             Resource() const                { return meshResource; }
        
        void AttachToTerrain( bool attach )                     { attachedToTerrain = attach; }
        bool AttachedToTerrain() const                          { return attachedToTerrain; }   

        void SetVisible( bool _visible )                        { this->visible = _visible; }
        bool Visible() const                                            { return visible; }

        const grinliz::Color3F& Color() const           { return color; }
        void SetColor( const grinliz::Color3F& c )      { color = c; }
        void SetColor( float r, float g, float b )      { color.r = r; color.g = g; color.b = b; }

        float Alpha() const                                                     { return m_alpha; }
        virtual void SetAlpha( float _alpha )           { m_alpha = grinliz::Clamp( _alpha, 0.0f, 1.0f ); }

        const Shader* GetShader()                                       { return m_shader; }
        void SetShader( const Shader* _shader )         { m_shader = _shader; }

        void SetStencil( bool _stencil )                        {       GLASSERT( this->Type() == DECALMESH );
                                                                                                        stencil = _stencil; 
                                                                                                }
        bool Stencil() const                                            { return stencil; }

        // Does this mesh cast shadows? Currently not set-able. Also trees are handle as a special case.
        // In the future it would be nice to have this a set-able property.
        int IsShadowCaster()                                            { return type & ( SHADOW_CASTER_MESH ); }

        // Does this mesh cast shadows? Currently not set-able. Also terrain is a special case.
        // In the future it would be nice to have this a set-able property.
        int IsShadowReceiver()                                          { return type & ( SHADOW_RECEIVER_MESH ); }

        const grinliz::Vector3F& Pos() const            { return pos; }

        float ZRot() const;
        const grinliz::Matrix4& Rotation() const        { return rotation; }

        void SetPos( const grinliz::Vector3F& pos, float z );
        void SetPos( const grinliz::Vector3F& pos, const grinliz::Quaternion& quat );
        void SetPos( const grinliz::Vector3F& pos );
        void SetPos( float x, float y, float z );
        void SetPos( const grinliz::Vector3F& _pos, const grinliz::Matrix4& _rotation ) {
                SetPosV( _pos, _rotation );
        }

        // All implementations of SetPos call SetPoSV.
        virtual void SetPosV( const grinliz::Vector3F& pos, const grinliz::Matrix4& rotation ) = 0;

        virtual void IntersectRay(      int flags, 
                                                                const grinliz::Vector3F& point, 
                                                                const grinliz::Vector3F& dir, 
                                                                LilithObjectList* vec ) = 0;

        int ID() const  { return id; }
        std::string Name() const;

  protected:
        // 1. Set up transformation matrices.
        // 2. Modify alpha to account for fade.
    // 3. Return true if mesh should render.
        bool PreStreamOut( float fade, float fadeout, float *alpha );
        void PostStreamOut();

        void CalcAABB( const grinliz::Rectangle3F& original );

        // utility function to do basic transformation from world to object space
        bool SetupIntersect(    const grinliz::Vector3F& point, 
                                                        const grinliz::Vector3F& dir, 
                                                        grinliz::Vector3F* point0, 
                                                        grinliz::Vector3F* dir0 ) const;

        grinliz::Vector3F       pos;                    // the location of the mesh
        grinliz::Matrix4        rotation;               // always a pure rotation matrix

        const MeshResource* meshResource;       // a pointer to its resource

        const grinliz::Matrix4& Transform()     const { return transform; }

        void ComputeTransform() {
                grinliz::Matrix4 translate;
                translate.SetTranslation( pos.x, pos.y, pos.z );
                transform = translate * rotation;
        }

        EPass CorrectPass() {
                if ( m_alpha < 1.0f ) 
                        return BLEND_PASS;
                return OPAQUE_PASS;
        }

  private:
        MeshClass                               type;   
        int                                             id;
        grinliz::Rectangle3F    aabb;
        grinliz::Rectangle3F    aabbWithShadow;
        bool                                    attachedToTerrain;
        bool                                    visible;
        bool                                    stencil;
        float                                   m_alpha;
        const Shader*                   m_shader;
        grinliz::Matrix4                transform;
        grinliz::Color3F                color;
};

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

class DecalMesh : public Mesh
{
  public:
        DecalMesh( const Texture* texture, float size );
        virtual ~DecalMesh();

        virtual void SetPosV( const grinliz::Vector3F& _newLoc, const grinliz::Matrix4& _newRot );
        virtual void StreamOutMesh( ELightPass light, EPass pass );
        static void StreamAllStencilDecals( Mesh* list );

        virtual void UpdateZ( float z );

        // Decal meshes don't report intersections.
        virtual void IntersectRay( int /*flags*/, const grinliz::Vector3F& /*point*/, const grinliz::Vector3F& /*dir*/, LilithObjectList* /*vec*/ )
        {
                GLASSERT( 0 ); 
        }

        const Texture* DecalTexture() { return texture; }

  private:
        enum { MAX_DECAL_STENCIL = VERTEXSIZE*VERTEXSIZE/TREE_COVERAGE_DIV };
        static DecalMesh* renderVec[ MAX_DECAL_STENCIL ];

        const Texture* texture;
        float size;
        grinliz::Matrix4 texMat;        // texture transformation matrix
};



class StaticMesh : public Mesh
{
 public:
        StaticMesh( const StaticResource* meshResource );
        virtual ~StaticMesh()   {}

        virtual void StreamOutMesh( ELightPass light, EPass pass );
        #ifdef SHADOW_VOLUME
        virtual void StreamOutShadow( ShadowVolumeCache* cache );
        #endif

        virtual void SetPosV( const grinliz::Vector3F& _newLoc, const grinliz::Matrix4& _newRot );

        virtual void UpdateZ( float z );

        virtual void IntersectRay(      int flags, 
                                                                const grinliz::Vector3F& point, 
                                                                const grinliz::Vector3F& dir, 
                                                                LilithObjectList* vec );

        const StaticResource* GetStaticResource() { return staticResource; }

 protected:
        StaticMesh( const StaticResource* meshResource, MeshClass type );
        const StaticResource* staticResource;
};


class FoliageMesh : public StaticMesh
{
public:
        FoliageMesh( const StaticResource* res ) : StaticMesh( res, FOLIAGEMESH )       {}
        virtual ~FoliageMesh()  {}

        static void StreamAllFoliage( Mesh* list );
};


class SolidMesh : public Mesh
{
  public:
        SolidMesh();
        virtual ~SolidMesh()    {}

        void GenerateSlab( float head, 
                                           float tail, 
                                           float width,
                                           const grinliz::Vector3F& dir,
                                           const grinliz::Vector3F& up );

        void GenerateCube( const grinliz::Rectangle3F& bounds );

        void GenerateSphere( float radius, int iterations );

        virtual void SetPosV( const grinliz::Vector3F& _newLoc, const grinliz::Matrix4& _newRot );

        virtual void UpdateZ( float z );

        virtual void StreamOutMesh( ELightPass light, EPass pass );

        void UseIntersection( bool intersection )       { this->useIntersection = intersection; }
        bool UsingIntersection()                                        { return useIntersection; }

        virtual void IntersectRay(      int flags, 
                                                                const grinliz::Vector3F& point, 
                                                                const grinliz::Vector3F& dir, 
                                                                LilithObjectList* vec );

        float Length()  { return length; }

  private:
        std::vector< grinliz::Vector3F >        vertex;
        std::vector< U32 >                                      index;
        std::vector< grinliz::Vector3F >        normal;

        bool useIntersection;
        float length;
        bool lighting;
        const Texture* texture;

        grinliz::Rectangle3F resAABB;
};


};      // namespace lilith3d

#endif

---