shadowvolumecache.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 SHADOW_VOLUME_CACHE_INCLUDED
#define SHADOW_VOLUME_CACHE_INCLUDED

#include "../grinliz/glvector.h"
#include "../grinliz/glmatrix.h"
#include "worlddefine.h"
#include <vector>

namespace lilith3d 
{
class Tri;


class ShadowVolumeCache
{
public:
        ShadowVolumeCache();
        ~ShadowVolumeCache();

        void SetSun( const grinliz::Vector3F& normal );
        const grinliz::Vector3F& Sun()          { return toSun; }

        void AddTri( const grinliz::Vector3F* vertex,   // input, required
                                 unsigned vertexStride,                         // input, required, byte count between vertices
                                 unsigned vertexCount,                          
                                 const Tri* triArray,                           // input, can be 0
                                 unsigned triCount,
                                 const U16* index,                                      // input, required
                                 unsigned indexCount,
                                 const grinliz::Matrix4& mat );


        const grinliz::Vector3F* GetVertex()            { return &vertex[0]; }
        U32                                              NumVertex()            { return vertex.size();; }
        const U16*                               GetIndex()                     { return &index[0]; }
        U32                                              NumIndex()                     { GLASSERT( index.size()%3 == 0 );
                                                                                                  return index.size();
                                                                                                }

        void StreamToStencil();

private:

        U32 OFFSET( U32 idx ) { return (base + idx*2 ); }
        U32 SHADOW( U32 idx ) { return (base + idx*2+1 ); }

        inline void AddSideToTri( U32 i0, U32 i1, U32 i2, U32 side )
        {
                const U32 arr[4] = { i0, i1, i2, i0 };
                U32 off0 = OFFSET( arr[side+0] );
                U32 off1 = OFFSET( arr[side+1] );
                U32 shadow0 = SHADOW( arr[side+0] );
                U32 shadow1 = SHADOW( arr[side+1] );

                unsigned ib = index.size();
                index.resize( ib+6 );

                index[ib+0] = off1;
                index[ib+1] = off0;
                index[ib+2] = shadow0;

                index[ib+3] = off1;
                index[ib+4] = shadow0;
                index[ib+5] = shadow1;
        }

        grinliz::Vector3F toSun;
        grinliz::Vector3F shadow;
        grinliz::Vector3F offset;

        std::vector< U16 > index;
        std::vector< grinliz::Vector3F > vertex;
        std::vector< Tri > tri;
        U32 base;
};
};
#endif

---