lilith3d.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 LILITH3D_INCLUDED
#define LILITH3D_INCLUDED

#ifdef _MSC_VER
#pragma warning( disable : 4786 )       // Debugger truncating names.
#pragma warning( disable : 4530 )       // Exception handler isn't used
#endif

#include "terrainmesh.h"
#include "worlddefine.h"
#include "lilith3dgl.h"
#include "terraindecor.h"
#include "quadtree.h"
#include "mob.h"
#include "weather.h"
#include "camera.h"
#include "texture.h"
#include "meshresource.h"
#include "timeclock.h"
#include "particle.h"
#include "light.h"
#include "terrainmorph.h"
#include "shadowvolumecache.h"
#include "building.h"

#include <list>
#include <vector>

namespace lilith3d
{

class TerrainMorph;
class ParticleSystem;
class PointLight;
class TerrainDecor;
class QuadTree;
class GravParticles;
class RainDropParticles;
class RainSplashParticles;
class ISequence;
class Camera;
class Mesh;

typedef std::list< ISequence* >                 SequenceList;
typedef SequenceList::iterator                  SequenceListIterator;
typedef std::vector< ParticleSystem* >  ParticleSystemVector;
typedef std::vector< MeshGroup* >               MeshGroupVector;


const int LilithVersionMajor = 2;
const int LilithVersionMinor = 0;
const int LilithVersionPatch = 0;

enum
{
        // Ordering depends on the Lilith Engine culling code. Don't change!
        L3_LEFT_PLANE,
        L3_RIGHT_PLANE,
        L3_BOTTOM_PLANE,
        L3_TOP_PLANE,
        L3_NEAR_PLANE,
        L3_FAR_PLANE,
};


class IMapDraw
{
public:
        virtual void DrawToMap() = 0;
};


class Lilith3D
{
  public:
        Lilith3D( U32 msecPerDay = DEFAULT_MSEC_PER_DAY, U32 msecStart = DEFUALT_MSEC_DAY_START );
        virtual ~Lilith3D();

        virtual void BeginDraw();
        virtual void Draw();
        virtual void EndDraw();

        static Lilith3D* Instance()             { return instance; }
        static SDL_Surface* SetSDLVideoMode( int width, int height, int multisample, bool fullscreen );

        static TerrainMesh*  GetTerrainMesh()   { return Instance() ? Instance()->terrainMesh : 0; }    
        static TerrainDecor* GetTerrainDecor()  { return Instance() ? Instance()->terrainDecor : 0; }   
        static TimeClock*        GetTimeClock()         { return Instance() ? &Instance()->timeClock : 0; }     

        void AddSequence( ISequence* orphanSequence );
        
        // [internal] Add a mobile object to lilith - managed by the Mob Object.
        void AddMob( Mob* mob )                                                 { mobGroup.Add( mob ); }
        // [internal] Remove a mobile object - managed by the Mob Object.
        void RemoveMob( Mob* mob )                                              { mobGroup.Remove( mob ); }

        QuadTree*                       GetQuadTree()                                   { return quadTree; }

        // --- Weather --- //
        Weather*                GetTargetWeather()      { return &targetWeather; }
        const Weather&  CurrentWeather()        { return weather; }


        // ------ Rendering options ------- //
        enum {
                // Rendering modes.
                RENDER_FLAT = 0,
                RENDER_LOD,
                RENDER_PATH,
                RENDER_COUNT,
        };      
        void SetRenderMode( int r );
        int  RenderMode()                                               { return renderMode; }                  
        void SetRenderFoliage( bool foliage )   { renderFoliage = foliage; }    
        bool RenderFoliage()                                    { return renderFoliage; }               
        void SetRenderShadows( bool shadows )   { renderShadows = shadows; }    
        bool RenderShadows()                                    { return renderShadows; }               
        void SetPerfDataDisplay( bool perfData) { displayPerfData = perfData; } 
        bool PerfDataDisplay()                                  { return displayPerfData; }             

        void SetMapSize( float size )   { targetMapSize = grinliz::Clamp( size, 0.0f, 1.0f ); }
        float MapSize()                                 { return targetMapSize; }
        void AddMapDrawer( IMapDraw* draw )             { mapDrawerSet.insert( draw ); }
        void RemoveMapDrawer( IMapDraw* draw )  { mapDrawerSet.erase( draw ); }

        enum {
                INFO_VERSION = 0x01,    
                INFO_TIME = 0x02,               
                INFO_INTERSECT = 0x04,  
                INFO_MINIMAP = 0x08,    

                INFO_DEFAULT = INFO_VERSION | INFO_TIME | INFO_INTERSECT | INFO_MINIMAP
        };
        void SetInfoDisplay( int flags )        { infoDisplay = flags; }

        void ScreenCapture( const char* baseFilename );
        
        // --- Selection and picking --- //
        void IntersectRayFromScreen( int x, int y, int flags, LilithObjectList* vec );

        int IntersectMapFromScreen( int x, int y, grinliz::Vector3F* vertex );

        void IntersectRay( const grinliz::Ray& ray, int flags, LilithObjectList* vec );

        void RegisterParticleSystem( ParticleSystem* system );
        ParticleSystem* FindParticleSystem( const char* name );
        GravParticles* GetGravParticles()       { return gravityParticles; }

        Camera* GetCamera()     { return &camera; }

        // --- Internal --- //
        // Mesh's react to lights in different ways. So they have to walk the
        // light list itself and decide what to do with it. Nothing should
        // change this list...and it should be const. But that's a pain.
        grinliz::InnerCircle<PointLight>* PointLights() { return &pointLightSentinel; }

        // Only valid *after* DoCulling has been called, through the rendering pass.
        const grinliz::Plane& CullingPlane( int i )     {       GLASSERT( i >= L3_LEFT_PLANE && i <= L3_FAR_PLANE );
                                                                                                        return cullingPlane[i];
                                                                                                }
                                
        bool InFrustum( const grinliz::Rectangle3F& aabb );

        int IntersectFrustum( const grinliz::Rectangle3F& aabb );

        static void CreateOpenGLToLilith( grinliz::Matrix4* matrix );

        #ifdef SHADOW_VOLUME
        float ShadowFade() { return shadowFade; }
        #endif

        // Bounds check for shadows.
        static inline bool CheckShadowInBounds( const grinliz::Vector3F& eye,
                                                                                        const grinliz::Vector3F& dir,
                                                                                        const grinliz::Rectangle2F& shadow,
                                                                                        const grinliz::Rectangle3F& aabb )

        {
                // Presumably we can see the shadow, so look for the corner opposite the
                // direction of the eye. If we are in the shadow, hopefully any corner
                // is close enough
                grinliz::Rectangle3F bounds = aabb;
                bounds.min.x += shadow.min.x;           // take advantage that all lilith shadows are from the sun.
                bounds.max.x += shadow.max.x;

                grinliz::Vector3F close;
                close.x = ( dir.x > 0.0f ) ? bounds.min.x : bounds.max.x;
                close.y = ( dir.y > 0.0f ) ? bounds.min.y : bounds.max.y;
                close.z = ( dir.z > 0.0f ) ? bounds.min.z : bounds.max.z;

                float dsquared =   (eye.x-close.x) * (eye.x-close.x)
                                                 + (eye.y-close.y) * (eye.y-close.y)
                                                 + (eye.z-close.z) * (eye.z-close.z);

                if ( dsquared < SHADOW_END_FADE_SQUARED )
                        return true;
                return false;
        }
                                                                                        
        Mesh* GetMesh( int id ) {       GLASSERT( id >= 0 );
                                                                return meshPool.Get( (U32)id ); }
        // [internal]
        grinliz::MapId< Mesh* > meshPool;

  private:
        static Lilith3D* instance;
        TimeClock timeClock;

        void InitShadows();

        #ifdef SHADOW_VOLUME
        void DrawShadowVolumes();
        void StreamShadowList( Mesh* root, const grinliz::Rectangle2F& shadow );

        ShadowVolumeCache shadowVolumeCache;
        float shadowFade;
        #endif

        enum { LEFT, RIGHT, BOTTOM, TOP, NEAR, FAR };
        void CalcCullingPlanes();       // normally called by "DoCulling" but also called by the shadow code.
        void DoCulling();
        void AdjustWeather();
        void GetMapInfo( grinliz::Vector2F* translation, grinliz::Vector2F* scale );

        Camera                                  camera;

        int                                             surfaceWidth, surfaceHeight;    // actual screen size
        GLuint                                  shadowId;
        GLuint                                  frameBufferObject;
        grinliz::Matrix4                worldToLight;

        int                                             renderMode;
        bool                                    renderFoliage;
        //bool                                  renderFromLight;
        bool                                    renderShadows;          // Set true if we want to render shadows
        float                                   sunCircle;                      // The radius that that the sun takes through the sky.
                                                                                                // The view distance is double this.

        TerrainMesh*                    terrainMesh;
        TerrainDecor*                   terrainDecor;
        QuadTree*                               quadTree;

        SequenceList                    sequenceList;           // owned: clean up memory
        ParticleSystemVector    particleSystems;        // owned: clean up particle memory
        grinliz::InnerCircle<PointLight>        pointLightSentinel;

        // Not owned: just a reference! Collection
        // of all the above items.
        MeshGroupVector         meshSystems;            // includes terrain, particle, objects. Pointer to, not owned.
        MobGroup                        mobGroup;

        U32             sequenceStart;
        int             sequenceLength;

        enum
        {
                // left, right, bottom, top, near, far
                NUM_CULLING = 6,
        };
        grinliz::Plane          cullingPlane[ NUM_CULLING ];

        Weather weather, targetWeather;

        GravParticles*          gravityParticles;
        RainDropParticles*      rainDropParticles;
        RainSplashParticles*    rainSplashParticles;

        bool displayPerfData;
        int infoDisplay;
        float targetMapSize;
        float mapSize;

        std::set< IMapDraw* > mapDrawerSet;
};
};      // namespace lilith3d

#endif

---