tree.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 L3TREE_INCLUDED
#define L3TREE_INCLUDED

#include "../grinliz/gltypes.h"
#include "meshresource.h"
#include "mesh.h"
#include "SDL_video.h"
#include "worlddefine.h"

namespace lilith3d
{
class TreeMesh;

class TreeResource : public StaticResource
{
  public:
        TreeResource( const std::string& name );
        ~TreeResource();

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

        void StreamOutTree( bool enableState ) const;                                   // used by the TreeMesh
        void StreamOutShadow( ShadowVolumeCache* cache, const grinliz::Matrix4& mat ) const;
        virtual void ImportDone();                                                              // used to pre-render the tree billboards

        void SetShadow( const Texture* tex )    { shadow = tex; }
        const Texture* Shadow() const                   { return shadow; }

        /*
        const Texture* GetBillboardTex( int i ) const   { return billboard[i]; }

        enum {
                NUM_ROTATIONS = 3
        };
         */

  private:
        void PreRender();
        //const Texture* billboard[4];  // each tree resource has 4 billboards: N,S,E,W
        const Texture* shadow;

  public:
        mutable std::vector< TreeMesh* > tree;

        /*
        // OPTIMIZATION: do not use
        struct TreeData 
        {
                TreeMesh* mesh;
                float alpha;
                float d2;
        };
        struct BBData 
        {
                TreeMesh* mesh;
                float alpha;
                float d2;
        };

        mutable TreeData treeCache[MAX_TREE_CACHE];
        mutable int nTreeCache;
        mutable BBData bbCache[4][MAX_BB_CACHE];
        mutable int nBBCache[4];

        mutable U16 triPos[ NUM_ROTATIONS ],  
                        triCount[ NUM_ROTATIONS ];
        
        void PushBBCache( int i, const BBData& data ) const {
                GLASSERT( i>=0 && i<4 );
                GLASSERT( nBBCache[i] < MAX_BB_CACHE );
                if ( nBBCache[i] < MAX_BB_CACHE ) {
                        bbCache[i][nBBCache[i]] = data;
                        ++nBBCache[i];
                }
        }
        void PushTreeCache( const TreeData& data ) const {
                GLASSERT( nTreeCache < MAX_TREE_CACHE );
                if ( nTreeCache < MAX_TREE_CACHE ) {
                        treeCache[nTreeCache] = data;
                        ++nTreeCache;
                }
        }
        */
};


class TreeMesh : public StaticMesh
{
  public:
        TreeMesh( const TreeResource* meshResource );
        virtual ~TreeMesh();

        // Streams out all the trees, and culls them from the render list
        // as it goes. Called by the engine directly. 
        static void StreamAllTrees( Lilith3D* lilith, Mesh* list );
        static void TreeMesh::StreamAllTreesVBO( Lilith3D* lilith, Mesh* list );

        //static void DeleteStatics();

        //virtual void StreamOutShadow( ShadowVolumeCache* cache );

        virtual void SetPosV( const grinliz::Vector3F& pos, const grinliz::Matrix4& rotation );

        // does nothing - use StreamAllTrees
        virtual void StreamOut()        {}

        const lilith3d::TreeResource* GetTreeResource() const   { return treeResource; }
        //int RotationIndex() { GLASSERT( rotationIndex >= 0 && rotationIndex < TreeResource::NUM_ROTATIONS );
        //                                              return rotationIndex; }

        float dSquared;
  private:

        //static bool init;
        //static grinliz::Vector2F frontUnit[TreeResource::NUM_ROTATIONS];
        //static grinliz::Vector2F leftUnit[TreeResource::NUM_ROTATIONS];

        //static TreeMesh* renderList[TREE_COUNT];
        //static int             nRenderList;

        //int rotationIndex;
        const TreeResource *treeResource;
        DecalMesh* decal;
};
};      // namespace lilith3d

#endif

---