Ignore:
Timestamp:
03/31/06 17:29:32 (18 years ago)
Author:
igarcia
Message:
 
Location:
GTP/trunk/Lib/Illum/IBRBillboardCloudTrees/OGRE/include
Files:
10 added
2 deleted
45 edited

Legend:

Unmodified
Added
Removed

  • GTP/trunk/Lib/Illum/IBRBillboardCloudTrees/OGRE/include/BBC/BBCBillboard.h

    r700 r721  
    66namespace BBC { 
    77 
    8 class _BBCExport Billboard { 
     8// Forward declarations 
     9class Billboard; 
     10 
     11namespace boost 
     12{ 
     13    void intrusive_ptr_add_ref(Billboard * p); 
     14    void intrusive_ptr_release(Billboard * p); 
     15}; 
     16 
     17 
     18class _BBCExport Billboard  
     19{ 
     20private: 
     21    long references; 
     22    friend void boost::intrusive_ptr_add_ref(Billboard * p); 
     23    friend void boost::intrusive_ptr_release(Billboard * p); 
     24 
    925  public: 
    1026    Billboard(); 
    1127 
    12     ~Billboard(); 
     28    virtual ~Billboard(); 
    1329 
    1430 
    … …  
    2541  protected: 
    2642 
    27         BillboardClusterData *mBillboardClusterData; 
     43        BillboardClusterDataPtr mBillboardClusterData; 
    2844 
    2945  public: 
    3046 
    31         void setBillboardClusterData(BillboardClusterData *value); 
     47        void setBillboardClusterData(BillboardClusterDataPtr value); 
    3248 
    33         BillboardClusterData* getBillboardClusterData(); 
     49        BillboardClusterDataPtr getBillboardClusterData(); 
    3450 
    3551}; 
    3652 
     53// class specific addref/release implementation 
     54// the two function overloads must be in the boost namespace on most compilers: 
     55namespace boost 
     56{ 
     57 inline void intrusive_ptr_add_ref(Billboard * p) 
     58  { 
     59    // increment reference count of object *p 
     60    ++(p->references); 
     61  } 
     62 
     63 
     64 
     65 inline void intrusive_ptr_release(Billboard * p) 
     66  { 
     67   // decrement reference count, and delete object when reference count reaches 0 
     68   if (--(p->references) == 0) 
     69     delete p; 
     70  }  
     71} // namespace boost 
     72 
     73typedef ::boost::intrusive_ptr<Billboard> BillboardPtr; 
     74 
    3775} 
    3876#endif 

  • GTP/trunk/Lib/Illum/IBRBillboardCloudTrees/OGRE/include/BBC/BBCBillboardCloud.h

    r709 r721  
    1313    BillboardCloud(); 
    1414 
    15     ~BillboardCloud(); 
     15    virtual ~BillboardCloud(); 
    1616 
    1717 
    1818  protected: 
    19           std::vector<Billboard*> mBillboardList; 
     19          std::vector<BillboardPtr> mBillboardList; 
    2020           
    21           std::vector<BillboardGroup*> mBillboardGroupList; 
     21          std::vector<BillboardGroupPtr> mBillboardGroupList; 
    2222 
    2323  public: 
    24         std::vector<Billboard*>* getBillboardList(); 
     24        std::vector<BillboardPtr>* getBillboardList(); 
    2525 
    26         void setBillboardList(std::vector<Billboard*> &value); 
     26        void setBillboardList(std::vector<BillboardPtr> &value); 
    2727 
    28     void addBillboard(Billboard* value); 
     28    void addBillboard(BillboardPtr value); 
    2929 
    3030    void removeBillboard(unsigned int value); 
    3131 
    32         Billboard* getBillboard(unsigned int value);     
     32        BillboardPtr getBillboard(unsigned int value);   
    3333 
    3434        unsigned int BillboardCloud::getNumBillboards(); 
    … …  
    4242        unsigned int getNumBillboardGroups(); 
    4343 
    44         BillboardGroup* getBillboardGroup(unsigned int iBillboardGroup); 
     44        BillboardGroupPtr getBillboardGroup(unsigned int iBillboardGroup); 
    4545 
    46         void addBillboardGroup(BillboardGroup *value);  
     46        void addBillboardGroup(BillboardGroupPtr value);  
    4747 
    4848        void removeBillboardGroup(unsigned int value); 
    4949 
    5050  protected: 
    51         Entity *mEntity; 
     51        EntityPtr mEntity; 
    5252 
    5353 
    5454  public: 
    55         Entity* getEntity(); 
     55        EntityPtr getEntity(); 
    5656 
    57         void setEntity(Entity *value); 
     57        void setEntity(EntityPtr value); 
    5858 
    5959}; 

  • GTP/trunk/Lib/Illum/IBRBillboardCloudTrees/OGRE/include/BBC/BBCBillboardCloudGenerator.h

    r700 r721  
    1111class _BBCExport BillboardCloudGenerator { 
    1212  public: 
     13 
     14    BillboardCloudGenerator(); 
     15 
     16        virtual ~BillboardCloudGenerator(); 
     17 
    1318    void generate(); 
    1419 

  • GTP/trunk/Lib/Illum/IBRBillboardCloudTrees/OGRE/include/BBC/BBCBillboardCloudSerializer.h

    r700 r721  
    1717    BillboardCloudSerializer(); 
    1818 
    19     ~BillboardCloudSerializer(); 
     19    virtual ~BillboardCloudSerializer(); 
    2020 
    2121 

  • GTP/trunk/Lib/Illum/IBRBillboardCloudTrees/OGRE/include/BBC/BBCBillboardCloudUVMapper.h

    r709 r721  
    6666        void removeClusterList(unsigned int iClusterList); 
    6767 
    68         void clear(); 
     68        void shutdown(); 
    6969 
    7070        unsigned int getNumClusterLists(); 
    … …  
    7474    BillboardCloudUVMapper(); 
    7575 
    76     ~BillboardCloudUVMapper(); 
     76    virtual ~BillboardCloudUVMapper(); 
    7777 
    7878}; 

  • GTP/trunk/Lib/Illum/IBRBillboardCloudTrees/OGRE/include/BBC/BBCBillboardClusterData.h

    r700 r721  
    66namespace BBC { 
    77 
    8 class _BBCExport BillboardClusterData { 
     8// Fordward declaration... 
     9class BillboardClusterData; 
     10 
     11namespace boost 
     12{ 
     13    void intrusive_ptr_add_ref(BillboardClusterData * p); 
     14    void intrusive_ptr_release(BillboardClusterData * p); 
     15}; 
     16 
     17class _BBCExport BillboardClusterData  
     18{ 
     19private: 
     20    long references; 
     21    friend void boost::intrusive_ptr_add_ref(BillboardClusterData * p); 
     22    friend void boost::intrusive_ptr_release(BillboardClusterData * p); 
     23 
    924  public: 
    1025    BillboardClusterData(); 
    1126 
    12     ~BillboardClusterData(); 
     27    virtual ~BillboardClusterData(); 
    1328 
    1429        void setNormal(Ogre::Vector3 value); 
    … …  
    2035        float getD(); 
    2136 
    22     EntityCluster* getEntityCluster(); 
     37    EntityClusterPtr getEntityCluster(); 
    2338 
    24         void setEntityCluster(EntityCluster *value); 
     39        void setEntityCluster(EntityClusterPtr value); 
    2540 
    2641        virtual void readBillboardClusterData(TiXmlNode *parentNode); 
    … …  
    4762 
    4863protected: 
    49         EntityCluster *mEntityCluster; 
     64        EntityClusterPtr mEntityCluster; 
    5065         
    5166        Ogre::Vector3 mAxisX; 
    … …  
    7085}; 
    7186 
     87// class specific addref/release implementation 
     88// the two function overloads must be in the boost namespace on most compilers: 
     89namespace boost 
     90{ 
     91 inline void intrusive_ptr_add_ref(BillboardClusterData * p) 
     92  { 
     93    // increment reference count of object *p 
     94    ++(p->references); 
     95  } 
     96 
     97 
     98 
     99 inline void intrusive_ptr_release(BillboardClusterData * p) 
     100  { 
     101   // decrement reference count, and delete object when reference count reaches 0 
     102   if (--(p->references) == 0) 
     103     delete p; 
     104  }  
     105} // namespace boost 
     106 
     107typedef ::boost::intrusive_ptr<BillboardClusterData> BillboardClusterDataPtr; 
     108 
    72109} 
    73110#endif 

  • GTP/trunk/Lib/Illum/IBRBillboardCloudTrees/OGRE/include/BBC/BBCBillboardGroup.h

    r709 r721  
    66namespace BBC { 
    77 
    8 class BillboardGroup { 
     8typedef struct 
     9{ 
     10        unsigned int billboardHandle; 
     11        unsigned int width; 
     12        unsigned int height; 
     13        Ogre::Vector2 min; 
     14        Ogre::Vector2 max;  
     15} BillboardGroupedInfo; 
     16 
     17// Forward declarations 
     18class BillboardGroup; 
     19 
     20 
     21namespace boost 
     22{ 
     23    void intrusive_ptr_add_ref(BillboardGroup * p); 
     24    void intrusive_ptr_release(BillboardGroup * p); 
     25}; 
     26 
     27class BillboardGroup  
     28{ 
     29private: 
     30    long references; 
     31    friend void boost::intrusive_ptr_add_ref(BillboardGroup * p); 
     32    friend void boost::intrusive_ptr_release(BillboardGroup * p); 
     33 
    934  protected: 
    1035        std::vector<unsigned int> mBillboardHandleList; 
    1136 
    1237  public: 
     38 
     39    BillboardGroup(); 
     40 
     41        virtual ~BillboardGroup(); 
     42 
    1343    unsigned int getBillboardHandle(unsigned int iBillboard); 
    1444 
    … …  
    1949}; 
    2050 
     51// class specific addref/release implementation 
     52// the two function overloads must be in the boost namespace on most compilers: 
     53namespace boost 
     54{ 
     55 inline void intrusive_ptr_add_ref(BillboardGroup * p) 
     56  { 
     57    // increment reference count of object *p 
     58    ++(p->references); 
     59  } 
     60 
     61 
     62 
     63 inline void intrusive_ptr_release(BillboardGroup * p) 
     64  { 
     65   // decrement reference count, and delete object when reference count reaches 0 
     66   if (--(p->references) == 0) 
     67     delete p; 
     68  }  
     69} // namespace boost 
     70 
     71typedef ::boost::intrusive_ptr<BillboardGroup> BillboardGroupPtr; 
     72 
    2173} 
    2274#endif 

  • GTP/trunk/Lib/Illum/IBRBillboardCloudTrees/OGRE/include/BBC/BBCEntity.h

    r700 r721  
    44#include <BBCPrerequisites.h> 
    55#include <BBCSubEntity.h> 
     6#include <BBCMesh.h> 
    67 
    78namespace BBC { 
    89 
     10// Forward declarations 
     11class Entity; 
     12 
     13 
     14namespace boost 
     15{ 
     16    void intrusive_ptr_add_ref(Entity * p); 
     17    void intrusive_ptr_release(Entity * p); 
     18}; 
     19 
    920class _BBCExport Entity  
    1021{ 
     22private: 
     23    long references; 
     24    friend void boost::intrusive_ptr_add_ref(Entity * p); 
     25    friend void boost::intrusive_ptr_release(Entity * p); 
     26 
    1127  protected: 
    1228 
    13         typedef std::vector<SubEntity*> SubEntityList; 
     29        typedef std::vector<SubEntityPtr> SubEntityList; 
    1430 
    1531        unsigned int mEntityHandle; 
    … …  
    1935        SubEntityList mSubEntityList; 
    2036 
    21         Ogre::Mesh *mMesh; 
     37        MeshPtr mMesh; 
    2238         
    2339  public: 
    … …  
    2541    Entity(); 
    2642 
    27     ~Entity(); 
     43    virtual ~Entity(); 
    2844 
    2945        void createSubEntity(); 
    3046 
    31         void addSubEntity(SubEntity *value); 
     47        void addSubEntity(SubEntityPtr value); 
    3248 
    33         SubEntity* getSubEntity(unsigned int index); 
     49        SubEntityPtr getSubEntity(unsigned int index); 
    3450 
    3551        void removeSubEntity(unsigned int index); 
    3652 
    37         virtual Ogre::Mesh* getMesh(); 
     53        virtual MeshPtr getMesh(); 
    3854 
    39         virtual void setMesh(Ogre::Mesh *value); 
     55        virtual void setMesh(MeshPtr value); 
    4056 
    4157        void loadMesh(bool mergeSubMeshes); 
    … …  
    6581}; 
    6682 
     83// class specific addref/release implementation 
     84// the two function overloads must be in the boost namespace on most compilers: 
     85namespace boost 
     86{ 
     87 inline void intrusive_ptr_add_ref(Entity * p) 
     88  { 
     89    // increment reference count of object *p 
     90    ++(p->references); 
     91  } 
     92 
     93 
     94 
     95 inline void intrusive_ptr_release(Entity * p) 
     96  { 
     97   // decrement reference count, and delete object when reference count reaches 0 
     98   if (--(p->references) == 0) 
     99     delete p; 
     100  }  
     101} // namespace boost 
     102 
     103typedef ::boost::intrusive_ptr<Entity> EntityPtr; 
     104 
    67105} 
    68106#endif 

  • GTP/trunk/Lib/Illum/IBRBillboardCloudTrees/OGRE/include/BBC/BBCEntityCluster.h

    r700 r721  
    1111namespace BBC { 
    1212 
    13 class _BBCExport EntityCluster { 
     13// Forward declarations 
     14class EntityCluster; 
     15 
     16 
     17namespace boost 
     18{ 
     19    void intrusive_ptr_add_ref(EntityCluster * p); 
     20    void intrusive_ptr_release(EntityCluster * p); 
     21}; 
     22 
     23class _BBCExport EntityCluster  
     24{ 
     25private: 
     26    long references; 
     27    friend void boost::intrusive_ptr_add_ref(EntityCluster * p); 
     28    friend void boost::intrusive_ptr_release(EntityCluster * p); 
     29 
    1430  public: 
    1531    EntityCluster(); 
    1632 
    17     ~EntityCluster(); 
     33    virtual ~EntityCluster(); 
    1834 
    19         EntityClusterData* getEntityClusterData(unsigned int value); 
     35        void removeEntityClusterData(unsigned int value); 
    2036 
    21         void addEntityClusterData(EntityClusterData *value); 
     37        EntityClusterDataPtr getEntityClusterData(unsigned int value); 
     38 
     39        void addEntityClusterData(EntityClusterDataPtr value); 
    2240 
    2341        void removeEntitClusterData(unsigned int value); 
    2442 
    25         EntityDistribution* getEntityDistribution(); 
     43        EntityDistributionPtr getEntityDistribution(); 
    2644 
    27         void setEntityDistribution(EntityDistribution *value); 
     45        void setEntityDistribution(EntityDistributionPtr value); 
    2846 
    2947  protected: 
    3048 
    31         EntityDistribution *mEntityDistribution; 
     49        EntityDistributionPtr mEntityDistribution; 
    3250         
    33         std::vector<EntityClusterData*> mEntityClusterDataList; 
     51        std::vector<EntityClusterDataPtr> mEntityClusterDataList; 
    3452     
    3553        std::vector<unsigned int> mBillboarHandle; 
    3654 
    37         Entity *mEntity; 
     55        EntityPtr mEntity; 
    3856 
    3957        unsigned int mBillboardHandle; 
    … …  
    4159  public: 
    4260 
    43         Entity* getEntity(); 
     61        EntityPtr getEntity(); 
    4462 
    45         void setEntity(Entity* value); 
     63        void setEntity(EntityPtr value); 
    4664 
    4765        unsigned int getNumEntitiesClusterData(); 
    … …  
    5573}; 
    5674 
     75// class specific addref/release implementation 
     76// the two function overloads must be in the boost namespace on most compilers: 
     77namespace boost 
     78{ 
     79 inline void intrusive_ptr_add_ref(EntityCluster * p) 
     80  { 
     81    // increment reference count of object *p 
     82    ++(p->references); 
     83  } 
     84 
     85 
     86 
     87 inline void intrusive_ptr_release(EntityCluster * p) 
     88  { 
     89   // decrement reference count, and delete object when reference count reaches 0 
     90   if (--(p->references) == 0) 
     91     delete p; 
     92  }  
     93} // namespace boost 
     94 
     95typedef ::boost::intrusive_ptr<EntityCluster> EntityClusterPtr; 
     96 
     97 
    5798} 
    5899#endif 

  • GTP/trunk/Lib/Illum/IBRBillboardCloudTrees/OGRE/include/BBC/BBCEntityClusterData.h

    r700 r721  
    66namespace BBC { 
    77 
    8 class _BBCExport EntityClusterData { 
     8// Fordward declaration... 
     9class EntityClusterData; 
     10 
     11namespace boost 
     12{ 
     13    void intrusive_ptr_add_ref(EntityClusterData * p); 
     14    void intrusive_ptr_release(EntityClusterData * p); 
     15}; 
     16 
     17class _BBCExport EntityClusterData  
     18{ 
     19private: 
     20    long references; 
     21    friend void boost::intrusive_ptr_add_ref(EntityClusterData * p); 
     22    friend void boost::intrusive_ptr_release(EntityClusterData * p); 
     23 
    924  public: 
    1025    EntityClusterData(); 
    1126 
    12     ~EntityClusterData(); 
     27    virtual ~EntityClusterData(); 
    1328 
    14         void setEntity(Entity *value); 
     29        void setEntity(EntityPtr value); 
    1530 
    16         Entity* getEntity(); 
     31        EntityPtr getEntity(); 
    1732 
    1833  protected: 
    19         Entity *mEntity; 
     34        EntityPtr mEntity; 
    2035 
    2136}; 
    2237 
     38// class specific addref/release implementation 
     39// the two function overloads must be in the boost namespace on most compilers: 
     40namespace boost 
     41{ 
     42 inline void intrusive_ptr_add_ref(EntityClusterData * p) 
     43  { 
     44    // increment reference count of object *p 
     45    ++(p->references); 
     46  } 
     47 
     48 
     49 
     50 inline void intrusive_ptr_release(EntityClusterData * p) 
     51  { 
     52   // decrement reference count, and delete object when reference count reaches 0 
     53   if (--(p->references) == 0) 
     54     delete p; 
     55  }  
     56} // namespace boost 
     57 
     58typedef ::boost::intrusive_ptr<EntityClusterData> EntityClusterDataPtr; 
     59 
    2360} 
    2461#endif 

  • GTP/trunk/Lib/Illum/IBRBillboardCloudTrees/OGRE/include/BBC/BBCEntityDistribution.h

    r700 r721  
    66namespace BBC { 
    77 
    8 class _BBCExport EntityDistribution { 
     8// Forward declarations 
     9class EntityDistribution; 
     10 
     11 
     12namespace boost 
     13{ 
     14    void intrusive_ptr_add_ref(EntityDistribution * p); 
     15    void intrusive_ptr_release(EntityDistribution * p); 
     16}; 
     17 
     18class _BBCExport EntityDistribution  
     19{ 
     20private: 
     21    long references; 
     22    friend void boost::intrusive_ptr_add_ref(EntityDistribution * p); 
     23    friend void boost::intrusive_ptr_release(EntityDistribution * p); 
     24 
    925  protected: 
    10         std::vector<Entity*> mEntityList; 
     26        std::vector<EntityPtr> mEntityList; 
    1127 
    1228  public: 
    13         Entity* getEntity(unsigned int value); 
     29    EntityDistribution(); 
    1430 
    15         void addEntity(Entity *value); 
     31        virtual ~EntityDistribution(); 
     32 
     33        EntityPtr getEntity(unsigned int value); 
     34 
     35        void addEntity(EntityPtr value); 
    1636 
    1737        void removeEntity(unsigned int value); 
    … …  
    2040}; 
    2141 
     42 
     43// class specific addref/release implementation 
     44// the two function overloads must be in the boost namespace on most compilers: 
     45namespace boost 
     46{ 
     47 inline void intrusive_ptr_add_ref(EntityDistribution * p) 
     48  { 
     49    // increment reference count of object *p 
     50    ++(p->references); 
     51  } 
     52 
     53 
     54 
     55 inline void intrusive_ptr_release(EntityDistribution * p) 
     56  { 
     57   // decrement reference count, and delete object when reference count reaches 0 
     58   if (--(p->references) == 0) 
     59     delete p; 
     60  }  
     61} // namespace boost 
     62 
     63typedef ::boost::intrusive_ptr<EntityDistribution> EntityDistributionPtr; 
     64 
    2265} 
    2366#endif 

  • GTP/trunk/Lib/Illum/IBRBillboardCloudTrees/OGRE/include/BBC/BBCEntityDistributionGenerator.h

    r700 r721  
    1313        EntityDistribution *mEntityDistribution; 
    1414 
    15     Entity *mEntity; 
     15    EntityPtr mEntity; 
    1616 
    1717  public: 
    … …  
    2020    void init(); 
    2121 
    22         Entity* getEntity(); 
     22        EntityPtr getEntity(); 
    2323 
    24         void setEntity(Entity *value); 
     24        void setEntity(EntityPtr value); 
    2525 
    2626        void setDistribution(EntityDistribution *value); 

  • GTP/trunk/Lib/Illum/IBRBillboardCloudTrees/OGRE/include/BBC/BBCEntityDistributionSerializer.h

    r700 r721  
    1010class _BBCExport EntityDistributionSerializer: public BBC::XmlSerializer { 
    1111  protected: 
    12         Entity* mEntity; 
     12        EntityPtr mEntity; 
    1313 
    1414  public: 
    15     Entity* getEntity(); 
     15    EntityPtr getEntity(); 
    1616 
    17     void setEntity(Entity * value); 
     17    void setEntity(EntityPtr value); 
    1818 
    1919    void generate(); 
    … …  
    2323    EntityDistributionSerializer(); 
    2424 
    25     ~EntityDistributionSerializer(); 
     25    virtual ~EntityDistributionSerializer(); 
    2626 
    2727}; 

  • GTP/trunk/Lib/Illum/IBRBillboardCloudTrees/OGRE/include/BBC/BBCManager.h

    r700 r721  
    44#include <BBCPrerequisites.h> 
    55#include <BBCSingleton.h> 
    6  
    7 //#include <ExampleFrameListener.h> 
    86 
    97namespace BBC { 
    … …  
    1917        static Manager* getSingletonPtr(void); 
    2018 
    21         void initRenderWindow(); 
    22  
    23         Ogre::Mesh* loadMesh(Ogre::String name); 
     19        Ogre::Mesh* loadMesh(Ogre::String folderName, Ogre::String fileName); 
    2420 
    2521        Ogre::Mesh* loadXMLMesh(Ogre::String name); 
    26  
    27         void loadResources(); 
    2822 
    2923        void saveMesh(Ogre::String name); 
    … …  
    4034 
    4135  protected: 
    42           Ogre::Root* mOgreRoot; 
    43           Ogre::MeshSerializer *mMeshSerializer; 
    44           Ogre::XMLMeshSerializer *mXMLMeshSerializer; 
    45           Ogre::DefaultHardwareBufferManager *mDefaultHardwareBufferManager; 
    46           Ogre::RenderWindow *mWnd; 
    47           Ogre::SceneManager *mScene; 
    48           Ogre::RenderSystem *mRSys; 
    49           Ogre::Camera *mCam; 
    50           Ogre::Viewport *mView; 
    51           Ogre::Math *mMath; 
    52           //ExampleFrameListener *mFrameListener; 
     36 
    5337}; 
    5438 

  • GTP/trunk/Lib/Illum/IBRBillboardCloudTrees/OGRE/include/BBC/BBCOgreMeshSerializer.h

    r700 r721  
    44#include <BBCPrerequisites.h> 
    55#include <BBCEntity.h> 
     6#include <BBCMesh.h> 
    67 
    78namespace BBC { 
    … …  
    1415        virtual ~OgreMeshSerializer(); 
    1516 
    16                 void setEntity(Entity *entity); 
     17                void setEntity(EntityPtr entity); 
    1718 
    18                 Entity* getEntity(); 
     19                EntityPtr getEntity(); 
    1920 
    2021                void exportMesh(const Ogre::String& fileName, bool mergeSubMeshes, bool tangents); 
    … …  
    2223    protected: 
    2324 
    24                 Entity *mEntity; 
     25                EntityPtr mEntity; 
    2526                 
    26                 void buildMesh(Ogre::Mesh* pMesh, bool mergeSubmeshes); 
     27                void buildMesh(MeshPtr pMesh, bool mergeSubmeshes); 
    2728                 
    28                 void generateEntityAABB(Ogre::Mesh* pMesh); 
     29                void generateEntityAABB(MeshPtr pMesh); 
    2930                 
    30                 void exportSubMeshes(Ogre::Mesh* pMesh); 
     31                void exportSubMeshes(MeshPtr pMesh); 
    3132         
    32                 void exportSubMesh(Ogre::Mesh* pMesh, SubEntity *subEntity); 
     33                void exportSubMesh(MeshPtr pMesh, SubEntityPtr subEntity); 
    3334         
    34                 template <typename T> void writeIndexes(T* buf, SubEntity *subEntity); 
     35                template <typename T> void writeIndexes(T* buf, SubEntityPtr subEntity); 
    3536         
    3637                void createVertexBuffer(Ogre::VertexData* vd, unsigned short bufIdx, UniqueVertexList *uniqueVertexList); 

  • GTP/trunk/Lib/Illum/IBRBillboardCloudTrees/OGRE/include/BBC/BBCPrerequisites.h

    r700 r721  
    2323#include <OgreVertexBoneAssignment.h> 
    2424#include <OgreAxisAlignedBox.h> 
    25  
    2625#include <OgreKeyEvent.h> 
    2726#include <OgreEventListeners.h> 
    … …  
    3130#include <OgrePixelFormat.h> 
    3231#include <OgreGpuProgram.h> 
     32#include <OgreSharedPtr.h> 
     33 
     34#include <OBA.h> 
     35 
     36#include <boost/smart_ptr.hpp> 
    3337 
    3438//#include <ospace/stl/hashset.h> 
    … …  
    3640 
    3741#define _BBCExport __declspec( dllexport ) 
     42 
    3843#endif 

  • GTP/trunk/Lib/Illum/IBRBillboardCloudTrees/OGRE/include/BBC/BBCSingleton.h

    r700 r721  
    1 #ifndef __SINGLETON_H__ 
    2 #define __SINGLETON_H__ 
     1#ifndef __BBCSINGLETON_H__ 
     2#define __BBCSINGLETON_H__ 
    33 
    44namespace BBC { 

  • GTP/trunk/Lib/Illum/IBRBillboardCloudTrees/OGRE/include/BBC/BBCSubEntity.h

    r700 r721  
    55 
    66namespace BBC { 
    7  
     7  
    88class _BBCExport UniqueVertex 
    99{ 
    … …  
    2424typedef std::vector<UniqueVertex> UniqueVertexList; 
    2525 
    26 class _BBCExport SubEntity { 
    27   public: 
     26// Fordward declaration 
     27class SubEntity; 
     28 
     29namespace boost 
     30{ 
     31    void intrusive_ptr_add_ref(SubEntity * p); 
     32    void intrusive_ptr_release(SubEntity * p); 
     33}; 
     34 
     35class _BBCExport SubEntity 
     36{ 
     37  private: 
     38    long references; 
     39 
     40    friend void boost::intrusive_ptr_add_ref(SubEntity * p); 
     41 
     42    friend void boost::intrusive_ptr_release(SubEntity * p); 
     43 
     44  protected: 
    2845 
    2946        typedef std::vector<unsigned short int> TextureCoordSetsDimensions; 
     47 
    3048        typedef std::vector<Ogre::Vector3> Indices; 
    31  
    32   protected: 
    3349 
    3450        UniqueVertexList mUniqueVertexList; 
    … …  
    5672    SubEntity(); 
    5773 
    58     ~SubEntity(); 
     74    virtual ~SubEntity(); 
    5975 
    6076        void enableTangents(bool value); 
    … …  
    129145 
    130146        void generateAABBox(); 
     147 
     148        const char *GetClassName(void) const; 
     149 
    131150}; 
     151 
     152// class specific addref/release implementation 
     153// the two function overloads must be in the boost namespace on most compilers: 
     154namespace boost 
     155{ 
     156  inline void intrusive_ptr_add_ref(SubEntity * p) 
     157  { 
     158    // increment reference count of object *p 
     159    ++(p->references); 
     160  } 
     161 
     162 
     163 
     164  inline void intrusive_ptr_release(SubEntity * p) 
     165  { 
     166   // decrement reference count, and delete object when reference count reaches 0 
     167   if (--(p->references) == 0) 
     168     delete p; 
     169  }  
     170} // namespace boost 
     171 
     172typedef ::boost::intrusive_ptr<SubEntity> SubEntityPtr; 
    132173 
    133174} 

  • GTP/trunk/Lib/Illum/IBRBillboardCloudTrees/OGRE/include/BBC/BBCXmlSerializer.h

    r700 r721  
    1111    XmlSerializer(); 
    1212 
    13     ~XmlSerializer(); 
     13    virtual ~XmlSerializer(); 
    1414 
    1515  protected: 
    1616    Ogre::String mFilename; 
     17 
    1718        TiXmlDocument *mFile; 
     19 
    1820    bool mLoaded; 
    1921 

  • GTP/trunk/Lib/Illum/IBRBillboardCloudTrees/OGRE/include/IMG/IMG.h

    r700 r721  
    1 #ifndef _LBBC_H 
    2 #define _LBBC_H 
    3  
    4 #include <LBBCPrerequisites.h> 
    5 #include <LBBCRoot.h> 
    6 #include <LBBCLeaves.h> 
    7 #include <LBBCLeafKdTreeClusterData.h> 
    8 #include <LBBCSampleConfigFile.h> 
     1#ifndef _IMG_H 
     2#define _IMG_H 
    93 
    104#endif 

  • GTP/trunk/Lib/Illum/IBRBillboardCloudTrees/OGRE/include/IMG/IMGBBox.h

    r700 r721  
    2727class BBox: public Ogre::AxisAlignedBox { 
    2828  public: 
    29     inline BBox() { BBox::StartBoundingBox(); } 
     29    BBox(); 
    3030 
    31     inline void StartBoundingBox() { 
    32                  mMinimum.x =  BOUNDINGBOX_MAXVALUE; 
    33          mMinimum.y =  BOUNDINGBOX_MAXVALUE; 
    34          mMinimum.z =  BOUNDINGBOX_MAXVALUE; 
    35          mMaximum.x = -BOUNDINGBOX_MAXVALUE; 
    36          mMaximum.y = -BOUNDINGBOX_MAXVALUE; 
    37          mMaximum.z = -BOUNDINGBOX_MAXVALUE; 
    38        }; 
     31        ~BBox(); 
    3932 
    40         inline Ogre::Vector3 GetMinimum() { return mMinimum; } 
     33    void StartBoundingBox(); 
    4134 
    42     //   
    43     //  Vector3 * GetMinimum() 
    44     //  {  
    45     //          Vector3 *Vector3; 
    46     //   
    47     //  Ogre::Vector3 v = mMinimum;      
    48     //  Vector3.x = v.x; 
    49     //  Vector3.y = v.y; 
    50     //  Vector3.z = v.z; 
    51     //   
    52     //  return v; 
    53     //  } 
    54      
    55         inline Ogre::Vector3 GetMaximum() { return mMaximum;}; 
     35        Ogre::Vector3 GetMinimum(); 
    5636 
    57     // 
    58     //  Vector3 GetMaximum() 
    59     //  {  
    60     //   
    61     //          Vector3 Vector3; 
    62     //  Ogre::Vector3 v = mMaximum;      
    63     //  Vector3.x = v.x; 
    64     //  Vector3.y = v.y; 
    65     //  Vector3.z = v.z; 
    66     //          return Vector3; 
    67     //  } 
    68     //   
    69     inline void AddBoundingVector3(float x, float y, float z) { 
    70         if (x < mMinimum.x) mMinimum.x = x; if (x > mMaximum.x) mMaximum.x = x; 
    71         if (y < mMinimum.y) mMinimum.y = y; if (y > mMaximum.y) mMaximum.y = y; 
    72         if (z < mMinimum.z) mMinimum.z = z; if (z > mMaximum.z) mMaximum.z = z; 
    73       }; 
     37        Ogre::Vector3 GetMaximum(); 
    7438 
    75     inline void Print() { 
    76         printf("\nValor de la Caixa: (%.4f, %.4f, %.4f) - (%.4f, %.4f, %.4f)\n\n", mMinimum.x, mMinimum.y, mMinimum.z, mMaximum.x, mMaximum.y, mMaximum.z); 
    77       }; 
     39    void AddBoundingVector3(float x, float y, float z); 
    7840 
    79     //Ogre::Vector3* GetCorner (int corner) const 
    80         inline Ogre::Vector3 * GetCorner(int corner) const { 
    81         
    82         //if (corner < 0 || corner > 7) return Ogre::Vector3 (-1111111111, -1111111111, -1111111111); 
    83         //return Ogre::AxisAlignedBox::getAllCorners ()[corner]; 
    84         //printf("\nGetCorner: %d", corner); 
    85          
    86         if (corner < 0 || corner > 7) return NULL; 
    87          
    88         Ogre::Vector3 *vector;           
    89         switch (corner) 
    90         { 
    91                 /* 
    92                 case BOX_CORNER_xyz: return vector = new Ogre::Vector3(mMinimum.x, mMinimum.y, mMinimum.z ); 
    93                 case BOX_CORNER_xyZ: return vector = new Ogre::Vector3(mMinimum.x, mMinimum.y, mMaximum.z ); 
    94                 case BOX_CORNER_xYz: return vector = new Ogre::Vector3(mMinimum.x, mMaximum.y, mMinimum.z ); 
    95                 case BOX_CORNER_xYZ: return vector = new Ogre::Vector3(mMinimum.x, mMaximum.y, mMaximum.z ); 
    96                 case BOX_CORNER_Xyz: return vector = new Ogre::Vector3(mMaximum.x, mMinimum.y, mMinimum.z ); 
    97                 case BOX_CORNER_XyZ: return vector = new Ogre::Vector3(mMaximum.x, mMinimum.y, mMaximum.z ); 
    98                 case BOX_CORNER_XYz: return vector = new Ogre::Vector3(mMaximum.x, mMaximum.y, mMinimum.z ); 
    99                 case BOX_CORNER_XYZ: return vector = new Ogre::Vector3(mMaximum.x, mMaximum.y, mMaximum.z ); 
    100                 */ 
    101                         case BOX_CORNER_xyz: vector = new Ogre::Vector3(mMinimum.x, mMinimum.y, mMinimum.z ); break; 
    102                 case BOX_CORNER_xyZ: vector = new Ogre::Vector3(mMinimum.x, mMinimum.y, mMaximum.z ); break; 
    103                 case BOX_CORNER_xYz: vector = new Ogre::Vector3(mMinimum.x, mMaximum.y, mMinimum.z ); break; 
    104                 case BOX_CORNER_xYZ: vector = new Ogre::Vector3(mMinimum.x, mMaximum.y, mMaximum.z ); break; 
    105                 case BOX_CORNER_Xyz: vector = new Ogre::Vector3(mMaximum.x, mMinimum.y, mMinimum.z ); break; 
    106                 case BOX_CORNER_XyZ: vector = new Ogre::Vector3(mMaximum.x, mMinimum.y, mMaximum.z ); break; 
    107                 case BOX_CORNER_XYz: vector = new Ogre::Vector3(mMaximum.x, mMaximum.y, mMinimum.z ); break; 
    108                 case BOX_CORNER_XYZ: vector = new Ogre::Vector3(mMaximum.x, mMaximum.y, mMaximum.z ); break; 
    109         } 
    110          
    111         //vector->Print(); 
    112         return vector; 
    113        }; 
     41    void Print(); 
    11442 
    115     inline bool intersects(Ogre::Vector3 * v) { 
    116                 return Ogre::AxisAlignedBox::intersects(*v);  
    117         }; 
     43        Ogre::Vector3 GetCorner(int corner) const; 
    11844 
    119     ~BBox(); 
     45    bool intersects(Ogre::Vector3 v); 
    12046 
    12147}; 

  • GTP/trunk/Lib/Illum/IBRBillboardCloudTrees/OGRE/include/IMG/IMGBox2d.h

    r700 r721  
    22#define _IMGBOX2D_H 
    33 
    4 #include "IMGBBox.h" 
     4#include <IMGBBox.h> 
    55 
    66namespace IMG { 
    77 
    88//* this class represents a 2d bound box for a texture  
    9 class Box2d { 
    10   public: 
    11     inline Box2d() { 
    12                 mMinimum.x =  BOUNDINGBOX_MAXVALUE; 
    13                 mMinimum.y =  BOUNDINGBOX_MAXVALUE; 
    14                  
    15                 mMaximum.x = -BOUNDINGBOX_MAXVALUE; 
    16                 mMaximum.y = -BOUNDINGBOX_MAXVALUE;              
    17         }; 
     9class Box2d  
     10{ 
     11        public: 
     12                Box2d(); 
    1813 
    19     // GametoolsError -- Isma 17/08/2005 
    20     inline Box2d & operator =(const Box2d & p) { 
    21                 mMinimum = p.mMinimum; 
    22                 mMaximum = p.mMaximum; 
    23         }; 
     14                ~Box2d(); 
    2415 
    25         inline Ogre::Vector2 GetMinimum() {  
    26                 return mMinimum; 
    27         }; 
     16                // GametoolsError -- Isma 17/08/2005 
     17                Box2d & Box2d::operator =(const Box2d & p) 
     18                { 
     19                        mMinimum = p.mMinimum; 
     20                        mMaximum = p.mMaximum; 
     21                        return (*this); 
     22                } 
    2823 
    29         inline Ogre::Vector2 GetMaximum() {  
    30                 return mMaximum;  
    31         }; 
     24                Ogre::Vector2 GetMinimum(); 
    3225 
    33     inline void SetBoundBox(float x, float y, float X, float Y) { 
    34                 mMinimum.x = x; 
    35                 mMinimum.y = y; 
    36                 mMaximum.x = X; 
    37                 mMaximum.y = Y; 
    38         }; 
     26                Ogre::Vector2 GetMaximum();  
    3927 
    40     inline void AddBoundingVector3(float x, float y) { 
    41                         if (x < mMinimum.x) mMinimum.x = x; if (x > mMaximum.x) mMaximum.x = x; 
    42                         if (y < mMinimum.y) mMinimum.y = y; if (y > mMaximum.y) mMaximum.y = y; 
    43         }; 
     28                void SetBoundBox(float x, float y, float X, float Y);  
    4429 
    45     inline void Print() { 
    46                 printf("\nValor de la Caixa: (%.4f, %.4f) - (%.4f, %.4f)", mMinimum.x, mMinimum.y, mMaximum.x, mMaximum.y); 
    47         }; 
     30                void AddBoundingVector3(float x, float y); 
    4831 
    49         inline Ogre::Vector2 * GetCorner(int corner) const { 
    50         
    51                 //if (corner < 0 || corner > 7) return Ogre::Vector3 (-1111111111, -1111111111, -1111111111); 
    52                 //return Ogre::AxisAlignedBox::getAllCorners ()[corner]; 
    53                 //printf("\nGetCorner: %d", corner); 
    54                  
    55                 if (corner < 0 || corner > 4) return NULL; 
    56                                  
    57                         Ogre::Vector2 *vector; 
    58                 switch (corner) 
    59                 {                
    60                         case BOX_CORNER_xy: vector = new Ogre::Vector2(mMinimum.x, mMinimum.y ); break; 
    61                         case BOX_CORNER_xY: vector = new Ogre::Vector2(mMinimum.x, mMaximum.y ); break; 
    62                         case BOX_CORNER_Xy: vector = new Ogre::Vector2(mMaximum.x, mMinimum.y ); break; 
    63                         case BOX_CORNER_XY: vector = new Ogre::Vector2(mMaximum.x, mMaximum.y ); break; 
    64                          
    65                 } 
    66                  
    67                 return vector; 
    68          }; 
     32                void Print();  
    6933 
    70     inline bool In(int w, int h) { 
    71                 if (w <= (mMaximum.x - mMinimum.x) && 
    72                     h <= (mMaximum.y - mMinimum.y)) return true; 
    73                     
    74                 return false; 
    75         }; 
     34                Ogre::Vector2 GetCorner(int corner) const; 
    7635 
    77     inline bool FitPerfect(int w, int h) {       
    78                 if (w == (mMaximum.x - mMinimum.x) && 
    79                     h == (mMaximum.y - mMinimum.y)) return true; 
    80                    
    81                 return false; 
    82         }; 
     36                bool In(int w, int h);  
    8337 
    84     ~Box2d(); 
     38                bool FitPerfect(int w, int h); 
    8539 
    86         private: 
     40        protected: 
    8741                Ogre::Vector2 mMinimum, mMaximum; 
    8842}; 

  • GTP/trunk/Lib/Illum/IBRBillboardCloudTrees/OGRE/include/IMG/IMGBsp.h

    r700 r721  
    99class Bsp { 
    1010  public: 
    11     inline Bsp() : root(NULL), countleaf(0), counttotal(0){}; 
     11    Bsp(); 
    1212 
    13     inline void SetRoot(NodeBsp * node) { 
    14                 root = node; 
    15                 counttotal++; 
    16         }; 
     13    virtual ~Bsp(); 
    1714 
    18     inline void Print() { 
    19                 printf("\nImprimint Arbre BSP, num nodes leaf: %d, totals: %d", countleaf, counttotal); 
    20                 Print(root); 
    21         }; 
     15    void SetRoot(NodeBspPtr node); 
    2216 
    23     inline void PrintLeaf() { 
    24                 PrintLeaf(root); 
    25         }; 
     17    void Print(); 
    2618 
    27     inline NodeBsp * Insert(int w, int h, int idcluster) { 
    28                 //printf("\nInsret dins Bsp: %d, %d", w, h); 
    29                  
    30                 NodeBsp *node = root->Insert (w,h); 
    31                  
    32                 //printf("\nNode on s'insertarà finalment éS: "); node->Print(); 
    33                  
    34                 if (idcluster != -1) 
    35                 { 
    36                         node->SetId (idcluster); 
    37                         countleaf++;                     
    38                 } 
    39                 else counttotal++; 
    40                  
    41                 //Copiar pixels de la imatge al node 
    42                  
    43                 return node; 
    44         }; 
     19    void PrintLeaf();  
    4520 
    46     inline NodeBsp * Get(int i) { 
    47                 return root->Get (root, i); 
    48         }; 
     21    NodeBspPtr Insert(int w, int h, int idcluster); 
    4922 
     23    NodeBspPtr Get(int i); 
    5024 
    51   private: 
    52     NodeBsp * root; 
     25  protected: 
     26    NodeBspPtr root; 
    5327 
    5428    int countleaf; 
    … …  
    5630    int counttotal; 
    5731 
    58     inline void Print(NodeBsp * node) { 
    59                 if (!node) return; 
    60                 node->Print(); 
    61                 Print(node->GetChild(0)); 
    62                 Print(node->GetChild(1)); 
    63         }; 
     32    void Print(NodeBspPtr node); 
    6433 
    65     inline void PrintLeaf(NodeBsp * node) { 
    66                 if (!node) return; 
    67                  
    68                  
    69                 if (node->GetChild(0) == NULL && node->GetChild(1) == NULL) node->Print(); 
    70                  
    71                 PrintLeaf (node->GetChild(0)); 
    72                 PrintLeaf (node->GetChild(1)); 
    73                  
    74         }; 
    75  
    76  
    77   public: 
    78     ~Bsp(); 
     34    void PrintLeaf(NodeBspPtr node); 
    7935 
    8036}; 

  • GTP/trunk/Lib/Illum/IBRBillboardCloudTrees/OGRE/include/IMG/IMGCluster.h

    r700 r721  
    22#define _IMGCLUSTER_H 
    33 
    4 #include "IMGPrerequisites.h" 
    5 #include "IMGBBox.h" 
    6 #include "IMGBox2d.h" 
    7 #include "IMGPlane3.h" 
     4#include <IMGPrerequisites.h> 
     5#include <IMGBBox.h> 
     6#include <IMGBox2d.h> 
     7#include <IMGPlane3.h> 
     8#include <IMGCluster2d.h> 
    89 
    9 namespace IMG { class Cluster2d; }  
     10namespace IMG  
     11{ 
    1012 
    11 namespace IMG { 
    12  
    13 class Cluster { 
     13class Cluster  
     14{ 
    1415  public: 
    1516    Cluster(); 
    … …  
    1920    Cluster(const Cluster & p); 
    2021 
    21     // Gametools -- Isma 17/08/2005 
    22     //void Insert (Triangle *t); 
    23     // Gametools -- Isma 17/08/2005 
    24     //* return the patchs that the point is in 
    25     //int CalculaPatch (Vector3 &point); 
    26         inline void SetNormal(Ogre::Vector3* n) { normal = *n; }; 
     22        void SetNormal(Ogre::Vector3* n); 
    2723 
    28         inline Ogre::Vector3* GetNormal() { return &normal; }; 
     24        Ogre::Vector3* GetNormal(); 
    2925 
    30     inline BBox* GetBound() { return bound; }; 
     26    BBox* GetBound(); 
    3127 
    32     inline Box2d* GetBspNodeBound() { return bspnodebound; }; 
     28    Box2d* GetBspNodeBound(); 
    3329 
    34     inline void SetBspNodeBound(Box2d* box) { 
    35                 bspnodebound = box; 
    36         }; 
     30    void SetBspNodeBound(Box2d* box); 
    3731 
    3832    void Print(); 
    … …  
    4135    int AxisProjected(); 
    4236 
    43     inline int GetId() const { return id; }; 
     37    int GetId() const; 
    4438 
    45     inline void SetId(int id_) { id = id;}; 
     39    void SetId(int id_); 
    4640 
    47     //Vector3 * GetVector3s() const{ return Vector3s;} 
    48     //Vector3 * GetVector3s(); 
    49     //Vector3 * GetVector3s() { return Vector3s_triangle_text; } 
    50         inline std::vector<Ogre::Vector3>* GetVector3sVector() { return &Vector3s_vector; }; 
     41        std::vector<Ogre::Vector3>* GetVector3sVector(); 
    5142 
    52         inline Ogre::Vector3* GetVector3sTex() const { return Vector3s_triangle_text;}; 
     43        Ogre::Vector3* GetVector3sTex() const; 
    5344 
    54     // Gametools -- Isma 17/08/2005 
    55     //bool CreatePatches(bool dinamic = false); 
    56     // Gametools -- Isma 17/08/2005 
    57     //Listid *GetPatchList() { return &patchlistid;} 
    58     //Listid *GetTriangleList(){ return &trianglelistid; } 
    59     // Gametools -- Isma 17/08/2005 
    60     //int GetIdPatch (unsigned int i) 
    61     //{ 
    62     //  if (i > patchlistid.GetSize()) return -1; 
    63     //   
    64     //  return patchlistid.Get(i); 
    65     //} 
    66     // Gametools -- Isma 17/08/2005 
    67     //int GetIdTriangle  (unsigned int i) 
    68     //{ 
    69     //  if (i > trianglelistid.GetSize()) return -1; 
    70     //   
    71     //  return trianglelistid.Get(i); 
    72     //} 
    7345    void Finish(); 
    7446 
    75         inline void SetPlane(Ogre::Vector3* normal, Ogre::Vector3 * point) { 
    76                 plane.normal = *normal; 
    77                 plane.normal = -plane.normal; 
    78                 plane.d = -normal->dotProduct (*point);          
    79                 //plane.d = normal->dotProduct (*point);                 
    80         }; 
     47        void SetPlane(Ogre::Vector3* normal, Ogre::Vector3 * point); 
    8148 
    82     inline Plane3 * GetPlane() { return &plane; }; 
     49    Plane3 * GetPlane(); 
    8350 
    8451    //* Return the increment in U (lumel increment in x). For patchs calculation  
    … …  
    9158        Ogre::Vector3 GetOrigin(); 
    9259 
    93     // 
    94     //  void CreateVector3s() 
    95     //  {  
    96     //           
    97     //          //Vector3s = new Vector3[4]; 
    98     //          //Vector3s_triangle_text = new Vector3[4]; 
    99     //  } 
    100     //   
    10160        bool PointIn(Ogre::Vector3 & point); 
    10261 
    103         Ogre::Real *pointeru[4]; //coordentate u for obscurancemap 
    104         Ogre::Real *pointerv[4]; //coordentate v for obscurancemap 
    105         Ogre::Vector2 *uv;      //Vector3 coordenates for the original texture 
     62        Ogre::Real *pointeru[4];  
     63 
     64        Ogre::Real *pointerv[4];  
     65 
     66        Ogre::Vector2 *uv; 
    10667 
    10768  private: 
    108     BBox * bound; 
     69    BBox bound; 
    10970 
    110     Box2d * bspnodebound; 
     71    Box2d bspnodebound; 
    11172 
    11273    static unsigned int ID_CLUSTER; 
    … …  
    11778 
    11879        std::vector<Ogre::Vector3> Vector3s_vector; 
     80 
    11981        Ogre::Vector3 *Vector3s; 
     82 
    12083        Ogre::Vector3 *Vector3s_triangle_text; 
    12184 
    … …  
    13093    Plane3 plane; 
    13194 
    132     // Gametools -- Isma 17/08/2005 
    133     //Listid patchlistid; 
    134     //Listid trianglelistid; 
    135         int CalcPatch(Ogre::Vector3 & point); 
    136  
    137  
    13895  public: 
    139     ~Cluster(); 
     96    virtual ~Cluster(); 
    14097 
    14198}; 

  • GTP/trunk/Lib/Illum/IBRBillboardCloudTrees/OGRE/include/IMG/IMGCluster2d.h

    r700 r721  
    22#define _IMGCLUSTER2D_H 
    33 
    4 #include "IMGCluster.h" 
     4#include <IMGPrerequisites.h> 
    55 
    66namespace IMG { 
    77 
     8class Cluster; 
     9 
    810class Cluster2d { 
    911  public: 
    10     inline Cluster2d() { 
    11                 Vector3s = NULL; 
    12                 cluster =NULL; 
    13                 normal = NULL; 
    14         }; 
     12    Cluster2d(); 
     13 
     14        virtual ~Cluster2d(); 
    1515 
    1616    //* Create a 2d polygon from a polygon 3d. The projecte polygon is belong the dominant normal. 
    … …  
    2121    void Print(); 
    2222 
    23         inline Ogre::Vector2 * GetVector3s() { return Vector3s; } 
     23        Ogre::Vector2 * GetVector3s(); 
    2424 
    25         inline std::vector<Ogre::Vector2> * GetVector3sVector() { return &Vector3s2_vector; }  
     25        std::vector<Ogre::Vector2> * GetVector3sVector(); 
    2626 
    27         inline Ogre::Vector3 * GetNormal() { return normal; } 
     27        Ogre::Vector3 * GetNormal(); 
    2828 
     29  protected: 
    2930 
    30   private: 
    3131    unsigned int id; 
    3232 
    … …  
    3434 
    3535        Ogre::Vector2 *Vector3s; 
     36 
    3637        std::vector<Ogre::Vector2> Vector3s2_vector; 
    3738 
    3839        Ogre::Vector3 *normal; 
    39  
    40   public: 
    41     ~Cluster2d(); 
    4240 
    4341}; 

  • GTP/trunk/Lib/Illum/IBRBillboardCloudTrees/OGRE/include/IMG/IMGClusterList.h

    r709 r721  
    77namespace IMG { 
    88 
    9 //* 
    10 //      ClusterList 
    11 //* 
    12 class ClusterList { 
     9class ClusterList  
     10{ 
    1311  public: 
    14     inline ClusterList() { 
    15         list.reserve(100); 
    16       }; 
     12    ClusterList(); 
    1713 
    18     //std::vector<Polygon*> * GetList() { return &list;}        //return the pointer to the list of voxels 
    19     inline std::vector<Cluster> * GetList() { return &list;}; 
     14    virtual ~ClusterList(); 
     15     
     16    std::vector<Cluster> * GetList(); 
    2017 
    2118    //return the pointer to the list of voxels 
    22     inline unsigned int GetSize() const { return list.size(); } 
     19    unsigned int GetSize() const; 
    2320 
    2421    //return the number of elements of list 
    25     inline Cluster * Get(unsigned int i) { 
    26         if (i <= list.size()) return &list[i]; 
    27         //if (i <= list.size()) return list[i]; 
    28         return NULL; 
    29       }; 
     22    Cluster * Get(unsigned int i); 
    3023 
    3124    bool Insert(Cluster * p); 
    … …  
    3427 
    3528 
    36   private: 
     29  protected: 
     30 
    3731    std::vector<Cluster> list; 
    38  
    39   public: 
    40     ~ClusterList(); 
    4132 
    4233}; 

  • GTP/trunk/Lib/Illum/IBRBillboardCloudTrees/OGRE/include/IMG/IMGNodeBsp.h

    r700 r721  
    77namespace IMG { 
    88 
    9 class NodeBsp { 
     9// Fordward declaration... 
     10class NodeBsp; 
     11 
     12typedef ::boost::intrusive_ptr<NodeBsp> NodeBspPtr; 
     13 
     14namespace boost 
     15{ 
     16    void intrusive_ptr_add_ref(NodeBsp * p); 
     17    void intrusive_ptr_release(NodeBsp * p); 
     18}; 
     19 
     20class NodeBsp  
     21{ 
    1022  public: 
    1123    NodeBsp(); 
    1224 
    13     Box2d * GetBound(); 
     25    virtual ~NodeBsp(); 
    1426 
    15     inline void SetBound(Box2d * box) { bound = box; }; 
     27    Box2d* GetBound(); 
    1628 
    17     inline NodeBsp * GetChild(int i) { return child[i]; }; 
     29    void SetBound(Box2d *box); 
    1830 
    19     inline void SetId(int id_) { id = id_; }; 
     31    NodeBspPtr GetChild(int i); 
    2032 
    21     inline unsigned int GetId() const { return id; }; 
     33    void SetId(int id_); 
    2234 
    23     inline void SetChild(NodeBsp * node, int i) { child[i] = node; }; 
     35    unsigned int GetId() const; 
     36 
     37    void SetChild(NodeBspPtr node, int i); 
    2438 
    2539    void Print(); 
    2640 
    27     //void SetPlane (Plane3 *pla) { plane = pla; } 
    28     //Plane3 * GetPlane () { return plane; } 
    29     NodeBsp * Insert(int w, int h); 
     41    NodeBspPtr Insert(int w, int h); 
    3042 
    31     inline NodeBsp * Get(NodeBsp * node, int i) { 
    32                 if (!node) return NULL; 
    33                 if (node->GetId() == i ) return node; 
    34                  
    35                 NodeBsp *nod;  
    36                 if (nod = node->GetChild(0)->Get (node->GetChild(0), i)) return nod; 
    37                  
    38                 return node->GetChild(0)->Get (node->GetChild(1), i); 
    39                  
    40         }; 
     43    NodeBspPtr Get(NodeBspPtr node, int i); 
    4144 
     45  protected: 
    4246 
    43   private: 
    4447    bool fit; 
    4548 
    46     Box2d * bound; 
     49    Box2d bound; 
    4750 
    48     NodeBsp * child[2]; 
     51    NodeBspPtr child[2]; 
    4952 
    5053    static unsigned int ID; 
    … …  
    5255    int id; 
    5356 
     57private: 
     58     
     59        long references; 
    5460 
    55   public: 
    56     ~NodeBsp(); 
     61    friend void boost::intrusive_ptr_add_ref(NodeBsp * p); 
    5762 
     63    friend void boost::intrusive_ptr_release(NodeBsp * p); 
    5864}; 
     65 
     66// class specific addref/release implementation 
     67// the two function overloads must be in the boost namespace on most compilers: 
     68namespace boost 
     69{ 
     70  inline void intrusive_ptr_add_ref(NodeBsp * p) 
     71  { 
     72    // increment reference count of object *p 
     73    ++(p->references); 
     74  } 
     75 
     76 
     77 
     78  inline void intrusive_ptr_release(NodeBsp * p) 
     79  { 
     80   // decrement reference count, and delete object when reference count reaches 0 
     81   if (--(p->references) == 0) 
     82     delete p; 
     83  }  
     84} // namespace boost 
    5985 
    6086} 

  • GTP/trunk/Lib/Illum/IBRBillboardCloudTrees/OGRE/include/IMG/IMGPlane3.h

    r700 r721  
    22#define _IMGPLANE3_H 
    33 
    4 #include "IMGPrerequisites.h" 
     4#include <IMGPrerequisites.h> 
    55 
    66namespace IMG { 
    … …  
    99  public: 
    1010    //a plane's interface 
    11     //Plane(); 
    12     //~Plane(); 
    13     inline Plane3 & operator =(const Plane3 & p) { 
    14                 normal.x = p.normal.x; 
    15                 normal.y = p.normal.y; 
    16                 normal.z = p.normal.z; 
    17                 d = p.d;                 
    18                 return *this; 
    19         }; 
     11    Plane3(); 
    2012 
    21         inline Ogre::Vector3 * GetNormal() { 
    22                 Ogre::Vector3 *v = new Ogre::Vector3; 
    23                 v->x = normal.x; 
    24                 v->y = normal.y; 
    25                 v->z = normal.z; 
    26                 return v; 
    27         }; 
     13    virtual ~Plane3(); 
    2814 
    29     inline void SetNormal(float x, float y, float z) { 
    30                 normal.x = x; 
    31                 normal.y = y; 
    32                 normal.z = z;            
    33         }; 
     15    Plane3 & operator =(const Plane3 & p); 
    3416 
    35     inline void SetDistance(float dist) { 
    36                 d = dist; 
    37         }; 
     17        Ogre::Vector3 * GetNormal(); 
    3818 
    39     inline float GetDistance() const { return d;}; 
     19    void SetNormal(float x, float y, float z); 
    4020 
    41     inline void Print() { 
    42                 printf("\nPrintant pla: (%.4f, %.4f, %.4f, %.4f)", normal.x, normal.y, normal.z, d); 
    43         }; 
     21    void SetDistance(float dist); 
    4422 
    45     ~Plane3(); 
     23    float GetDistance() const; 
     24 
     25    void Print(); 
    4626 
    4727}; 

  • GTP/trunk/Lib/Illum/IBRBillboardCloudTrees/OGRE/include/IMG/IMGPrerequisites.h

    r700 r721  
    99#include <OgreAxisAlignedBox.h>  
    1010 
     11#include <boost/smart_ptr.hpp> 
     12 
    1113#endif 

  • GTP/trunk/Lib/Illum/IBRBillboardCloudTrees/OGRE/include/LBBC/LBBC.h

    r700 r721  
    77#include <LBBCLeafKdTreeClusterData.h> 
    88#include <LBBCSampleConfigFile.h> 
     9#include <LBBCBillboardViewMode.h> 
     10#include <LBBCClusterViewMode.h> 
    911 
    1012#endif 

  • GTP/trunk/Lib/Illum/IBRBillboardCloudTrees/OGRE/include/LBBC/LBBCBillboardKMeansClusterData.h

    r700 r721  
    1 #ifndef _LBBCBILLBOARDKMEANSCLUSTERDATA_H 
    2 #define _LBBCBILLBOARDKMEANSCLUSTERDATA_H 
     1#ifndef _LBBCBILLBOARDKMeansCLUSTERDATA_H 
     2#define _LBBCBILLBOARDKMeansCLUSTERDATA_H 
    33 
    44#include <BBC.h> 
     5#include <LBBCLeafKMeansClusterData.h> 
     6#include <LBBCLeaf.h> 
    57 
    68namespace LBBC { 
    … …  
    1012    BillboardKMeansClusterData(); 
    1113 
    12     ~BillboardKMeansClusterData(); 
     14    virtual ~BillboardKMeansClusterData(); 
     15 
     16        virtual void readBillboardClusterData(TiXmlNode *parentNode); 
     17 
     18        virtual void writeBillboardClusterData(TiXmlNode *parentNode); 
     19 
     20        virtual void generateBillboardBoundingQuad(); 
    1321 
    1422}; 

  • GTP/trunk/Lib/Illum/IBRBillboardCloudTrees/OGRE/include/LBBC/LBBCBillboardKdTreeClusterData.h

    r700 r721  
    1 #ifndef _LBBCBILLBOARDKDTREECLUSTERDATA_H 
    2 #define _LBBCBILLBOARDKDTREECLUSTERDATA_H 
     1#ifndef _LBBCBILLBOARDKdTreeCLUSTERDATA_H 
     2#define _LBBCBILLBOARDKdTreeCLUSTERDATA_H 
    33 
    44#include <BBC.h> 
    5 #include <LBBCLeafKdTreeClusterData.h> 
    6 #include <LBBCLeaf.h> 
    75 
    86namespace LBBC { 
    … …  
    1210    BillboardKdTreeClusterData(); 
    1311 
    14     ~BillboardKdTreeClusterData(); 
    15  
    16         virtual void readBillboardClusterData(TiXmlNode *parentNode); 
    17  
    18         virtual void writeBillboardClusterData(TiXmlNode *parentNode); 
    19  
    20         virtual void generateBillboardBoundingQuad(); 
     12    virtual ~BillboardKdTreeClusterData(); 
    2113 
    2214}; 

  • GTP/trunk/Lib/Illum/IBRBillboardCloudTrees/OGRE/include/LBBC/LBBCKMeansClusterGenerator.h

    r700 r721  
    1 #ifndef _LBBCKMEANSCLUSTERGENERATOR_H 
    2 #define _LBBCKMEANSCLUSTERGENERATOR_H 
    3  
     1#ifndef _LBBCKMeansCLUSTERGENERATOR_H 
     2#define _LBBCKMeansCLUSTERGENERATOR_H 
    43 
    54#include <BBC.h> 
     5#include <LBBCLeafKMeansClusterData.h> 
     6#include <LBBCBillboardKMeansClusterData.h> 
     7#include <LBBCLeaf.h> 
     8#include <LBBCLeafDistribution.h> 
    69 
    710namespace LBBC { 
    811 
    9 class _BBCExport KMeansClusterGenerator : public BBC::BillboardCloudGenerator { 
     12class _BBCExport KMeansClusterGenerator: public BBC::BillboardCloudGenerator  
     13{ 
    1014  public: 
    1115    void generate(); 
    … …  
    1317    void init(); 
    1418 
     19        void setAlpha(float value); 
     20 
     21        float getAlpha(); 
     22 
     23        void initializeBillboardCloud(); 
     24 
     25        BBC::BillboardPtr createBillboard(); 
     26 
     27        void initializeBillboardClusterData(BBC::BillboardPtr billboard); 
     28         
     29        void initializeRandomBillboard(BBC::BillboardPtr billboard); 
     30 
     31        void splitLeafDistribution(); 
     32 
     33        void assignLeafBillboard(Leaf *leaf, BBC::BillboardPtr billboard); 
     34 
     35        void recomputeBillboardCloud(); 
     36 
     37        void recomputeBillboard(BBC::BillboardPtr billboard); 
     38 
     39        void iterativeRecomputeBillboardCloud(); 
     40 
     41        unsigned int findBestBillboard(Leaf *leaf); 
     42 
     43        void generateBillboardCloudBounds(); 
     44 
     45        void setNumIterations(unsigned int value); 
     46 
     47        unsigned int getNumIterations(); 
     48 
    1549    KMeansClusterGenerator(); 
    1650 
    17     ~KMeansClusterGenerator(); 
     51    virtual ~KMeansClusterGenerator(); 
    1852 
    1953  protected: 
    2054 
    21         class Cell 
    22         { 
    23                 protected: 
    24                 Cell *right; 
    25                 Cell *left; 
    26                 Ogre::Vector4 min; 
    27                 Ogre::Vector4 max; 
    28                  
    29                 public: 
    30                 Cell() 
    31                 { 
    32                         right = NULL; 
    33                         left = NULL; 
    34                 } 
     55    float mAlpha; 
    3556 
    36                 void setLeftChild(Cell *lChild) 
    37                 { 
    38                         left = lChild; 
    39                 } 
     57        float mEpsilonYN; 
    4058 
    41                 void setRightChild(Cell *rChild) 
    42                 { 
    43                         right = rChild; 
    44                 } 
    45  
    46                 Cell* getRightChild() 
    47                 { 
    48                         return right; 
    49                 } 
    50                  
    51                 Cell* getLeftChild() 
    52                 { 
    53                         return left; 
    54                 } 
    55                  
    56                 Ogre::Vector4 getMin() 
    57                 { 
    58                         return min; 
    59                 } 
    60                  
    61                 Ogre::Vector4 getMax() 
    62                 { 
    63                         return max; 
    64                 }        
    65  
    66                 void setMax(Ogre::Vector4 vmax) 
    67                 { 
    68                         max = vmax; 
    69                 } 
    70  
    71                 void setMin(Ogre::Vector4 vmin) 
    72                 { 
    73                         min = vmin; 
    74                 } 
    75         }; 
    76  
     59        float mNumIterations; 
    7760}; 
    7861 

  • GTP/trunk/Lib/Illum/IBRBillboardCloudTrees/OGRE/include/LBBC/LBBCKMeansClusterSerializer.h

    r700 r721  
    1 #ifndef _LBBCKMEANSCLUSTERSERIALIZER_H 
    2 #define _LBBCKMEANSCLUSTERSERIALIZER_H 
     1#ifndef _LBBCKMeansCLUSTERSERIALIZER_H 
     2#define _LBBCKMeansCLUSTERSERIALIZER_H 
    33 
    44#include <BBC.h> 
     5#include <LBBCBillboardKMeansClusterData.h> 
     6 
     7#include <string> 
    58 
    69namespace LBBC { 
    … …  
    1013    KMeansClusterSerializer(); 
    1114 
    12     ~KMeansClusterSerializer(); 
     15    virtual ~KMeansClusterSerializer(); 
    1316 
    14     void writeBillboardCloud(TiXmlDocument *document); 
     17        virtual void writeBillboardCloud(TiXmlDocument *document); 
    1518 
    1619}; 

  • GTP/trunk/Lib/Illum/IBRBillboardCloudTrees/OGRE/include/LBBC/LBBCKdTreeClusterGenerator.h

    r700 r721  
    1 #ifndef _LBBCKDTREECLUSTERGENERATOR_H 
    2 #define _LBBCKDTREECLUSTERGENERATOR_H 
     1#ifndef _LBBCKdTreeCLUSTERGENERATOR_H 
     2#define _LBBCKdTreeCLUSTERGENERATOR_H 
     3 
    34 
    45#include <BBC.h> 
    5 #include <LBBCLeafKdTreeClusterData.h> 
    6 #include <LBBCBillboardKdTreeClusterData.h> 
    7 #include <LBBCLeaf.h> 
    8 #include <LBBCLeafDistribution.h> 
    96 
    107namespace LBBC { 
    … …  
    1613    void init(); 
    1714 
    18         void setAlpha(float value); 
    19  
    20         float getAlpha(); 
    21  
    22         void initializeBillboardCloud(); 
    23  
    24         BBC::Billboard* createBillboard(); 
    25  
    26         void initializeBillboardClusterData(BBC::Billboard *billboard); 
    27          
    28         void initializeRandomBillboard(BBC::Billboard *billboard); 
    29  
    30         void splitLeafDistribution(); 
    31  
    32         void assignLeafBillboard(Leaf *leaf, BBC::Billboard *billboard); 
    33  
    34         void recomputeBillboardCloud(); 
    35  
    36         void recomputeBillboard(BBC::Billboard *billboard); 
    37  
    38         void iterativeRecomputeBillboardCloud(); 
    39  
    40         unsigned int findBestBillboard(Leaf *leaf); 
    41  
    42         void generateBillboardCloudBounds(); 
    43  
    44         void setNumIterations(unsigned int value); 
    45  
    46         unsigned int getNumIterations(); 
    47  
    4815    KdTreeClusterGenerator(); 
    4916 
    50     ~KdTreeClusterGenerator(); 
     17    virtual ~KdTreeClusterGenerator(); 
    5118 
    5219  protected: 
    5320 
    54     float mAlpha; 
     21        class Cell 
     22        { 
     23                protected: 
     24                Cell *right; 
     25                Cell *left; 
     26                Ogre::Vector4 min; 
     27                Ogre::Vector4 max; 
     28                 
     29                public: 
     30                Cell() 
     31                { 
     32                        right = NULL; 
     33                        left = NULL; 
     34                } 
    5535 
    56         float mEpsilonYN; 
     36                void setLeftChild(Cell *lChild) 
     37                { 
     38                        left = lChild; 
     39                } 
    5740 
    58         float mNumIterations; 
     41                void setRightChild(Cell *rChild) 
     42                { 
     43                        right = rChild; 
     44                } 
     45 
     46                Cell* getRightChild() 
     47                { 
     48                        return right; 
     49                } 
     50                 
     51                Cell* getLeftChild() 
     52                { 
     53                        return left; 
     54                } 
     55                 
     56                Ogre::Vector4 getMin() 
     57                { 
     58                        return min; 
     59                } 
     60                 
     61                Ogre::Vector4 getMax() 
     62                { 
     63                        return max; 
     64                }        
     65 
     66                void setMax(Ogre::Vector4 vmax) 
     67                { 
     68                        max = vmax; 
     69                } 
     70 
     71                void setMin(Ogre::Vector4 vmin) 
     72                { 
     73                        min = vmin; 
     74                } 
     75        }; 
     76 
    5977}; 
    6078 

  • GTP/trunk/Lib/Illum/IBRBillboardCloudTrees/OGRE/include/LBBC/LBBCKdTreeClusterSerializer.h

    r700 r721  
    1 #ifndef _LBBCKDTREECLUSTERSERIALIZER_H 
    2 #define _LBBCKDTREECLUSTERSERIALIZER_H 
     1#ifndef _LBBCKdTreeCLUSTERSERIALIZER_H 
     2#define _LBBCKdTreeCLUSTERSERIALIZER_H 
    33 
    44#include <BBC.h> 
    5 #include <LBBCBillboardKdTreeClusterData.h> 
    6  
    7 #include <string> 
    85 
    96namespace LBBC { 
    … …  
    1310    KdTreeClusterSerializer(); 
    1411 
    15     ~KdTreeClusterSerializer(); 
     12    virtual ~KdTreeClusterSerializer(); 
    1613 
    17         virtual void writeBillboardCloud(TiXmlDocument *document); 
     14    void writeBillboardCloud(TiXmlDocument *document); 
    1815 
    1916}; 

  • GTP/trunk/Lib/Illum/IBRBillboardCloudTrees/OGRE/include/LBBC/LBBCLeaf.h

    r700 r721  
    8181    Leaf(); 
    8282 
    83     ~Leaf(); 
     83    virtual ~Leaf(); 
    8484 
    8585}; 

  • GTP/trunk/Lib/Illum/IBRBillboardCloudTrees/OGRE/include/LBBC/LBBCLeafDistribution.h

    r700 r721  
    1919    LeafDistribution(); 
    2020 
    21     ~LeafDistribution(); 
     21    virtual ~LeafDistribution(); 
    2222 
    2323        void setMinD(float value); 

  • GTP/trunk/Lib/Illum/IBRBillboardCloudTrees/OGRE/include/LBBC/LBBCLeafDistributionGenerator.h

    r700 r721  
    1414    LeafDistributionGenerator(); 
    1515 
    16     ~LeafDistributionGenerator(); 
     16    virtual ~LeafDistributionGenerator(); 
    1717 
    1818        void generateAverageLeafNormal(Leaf *leaf); 

  • GTP/trunk/Lib/Illum/IBRBillboardCloudTrees/OGRE/include/LBBC/LBBCLeafDistributionSerializer.h

    r700 r721  
    1313    LeafDistributionSerializer(); 
    1414 
    15     ~LeafDistributionSerializer(); 
     15    virtual ~LeafDistributionSerializer(); 
    1616 
    1717 

  • GTP/trunk/Lib/Illum/IBRBillboardCloudTrees/OGRE/include/LBBC/LBBCLeafKMeansClusterData.h

    r700 r721  
    1 #ifndef _LBBCLEAFKMEANSCLUSTERDATA_H 
    2 #define _LBBCLEAFKMEANSCLUSTERDATA_H 
     1#ifndef _LBBCLEAFKMeansCLUSTERDATA_H 
     2#define _LBBCLEAFKMeansCLUSTERDATA_H 
    33 
    44#include <BBCEntityClusterData.h> 
    … …  
    1010    LeafKMeansClusterData(); 
    1111 
    12     ~LeafKMeansClusterData(); 
     12    virtual ~LeafKMeansClusterData(); 
     13 
     14  protected: 
    1315 
    1416}; 

  • GTP/trunk/Lib/Illum/IBRBillboardCloudTrees/OGRE/include/LBBC/LBBCLeafKdTreeClusterData.h

    r700 r721  
    1 #ifndef _LBBCLEAFKDTREECLUSTERDATA_H 
    2 #define _LBBCLEAFKDTREECLUSTERDATA_H 
     1#ifndef _LBBCLEAFKdTreeCLUSTERDATA_H 
     2#define _LBBCLEAFKdTreeCLUSTERDATA_H 
    33 
    44#include <BBCEntityClusterData.h> 
    … …  
    1010    LeafKdTreeClusterData(); 
    1111 
    12     ~LeafKdTreeClusterData(); 
    13  
    14   protected: 
     12    virtual ~LeafKdTreeClusterData(); 
    1513 
    1614}; 

  • GTP/trunk/Lib/Illum/IBRBillboardCloudTrees/OGRE/include/LBBC/LBBCLeaves.h

    r700 r721  
    1111    Leaves(); 
    1212 
    13     ~Leaves(); 
     13    virtual ~Leaves(); 
    1414 
    1515  protected: 
    1616    bool mMeshLoaded; 
    1717 
    18         Ogre::Mesh *mMesh; 
     18        BBC::EntityPtr mEntity; 
    1919 
    2020        BBC::BillboardCloud *mBillboardCloud; 
    2121 
    2222  public: 
    23         Ogre::Mesh* getMesh(); 
     23        BBC::EntityPtr getEntity(); 
    2424 
    25         void setMesh(Ogre::Mesh * value); 
     25        void setEntity(BBC::EntityPtr value); 
    2626 
    2727    void load(); 

  • GTP/trunk/Lib/Illum/IBRBillboardCloudTrees/OGRE/include/LBBC/LBBCManager.h

    r709 r721  
    22#define _LBBCMANAGER_H 
    33 
    4 #include <BBC.h> 
    54#include <LBBCPrerequisites.h> 
    65#include <LBBCLeaves.h> 
    … …  
    2221    ~Manager(); 
    2322 
    24         void runSample(Ogre::String sampleConfigFile); 
     23        void runSampleConfigFile(); 
     24 
     25        void loadSampleConfigFile(Ogre::String sampleConfigFile); 
    2526 
    2627        SampleConfigFile* getSampleConfigFile(); 
     28 
     29        void setSampleConfigFile(SampleConfigFile *sampleConfigFile); 
    2730 
    2831        void generateEntityDistribution(); 
    … …  
    7275        BBC::OgreMeshSerializer *mOgreMeshSerializer; 
    7376 
    74         SampleConfigFile mSampleCf; 
     77        SampleConfigFile *mSampleConfigFile; 
    7578 
    76         Ogre::ConfigFile mCf; 
     79        Ogre::ConfigFile *mConfigFile; 
     80 
    7781}; 
    7882 

  • GTP/trunk/Lib/Illum/IBRBillboardCloudTrees/OGRE/include/LBBC/LBBCSampleConfigFile.h

    r709 r721  
    1010    SampleConfigFile(); 
    1111         
    12     ~SampleConfigFile(); 
     12    virtual ~SampleConfigFile(); 
    1313 
    1414        bool getEntityDistributionMerged(); 
Note: See TracChangeset for help on using the changeset viewer.