imap/loader.h Source File (Crystal Space 2.0 Public API Reference)

| ## Public API Reference

- Main Page
- Related Pages
- Modules
- Namespaces
- Classes
- Files

- File List
- File Members

imap/loader.h
Go to the documentation of this file.

    00001 /*
    00002     The Crystal Space geometry loader interface
    00003     Copyright (C) 2000 by Andrew Zabolotny <bit@eltech.ru>
    00004
    00005     This library is free software; you can redistribute it and/or
    00006     modify it under the terms of the GNU Library General Public
    00007     License as published by the Free Software Foundation; either
    00008     version 2 of the License, or (at your option) any later version.
    00009
    00010     This library is distributed in the hope that it will be useful,
    00011     but WITHOUT ANY WARRANTY; without even the implied warranty of
    00012     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
    00013     Library General Public License for more details.
    00014
    00015     You should have received a copy of the GNU Library General Public
    00016     License along with this library; if not, write to the Free
    00017     Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
    00018 */
    00019
    00020 #ifndef __CS_IMAP_PARSER_H__
    00021 #define __CS_IMAP_PARSER_H__
    00022
    00029 #include "csutil/refarr.h"
    00030 #include "csutil/refcount.h"
    00031 #include "csutil/scf_interface.h"
    00032 #include "csutil/threading/condition.h"
    00033
    00034 #include "igraphic/image.h"
    00035 #include "ivideo/txtmgr.h"
    00036 #include "imap/streamsource.h"
    00037 #include "iutil/job.h"
    00038 #include "iutil/threadmanager.h"
    00039
    00040 #include "csutil/deprecated_warn_off.h"
    00041
    00042 struct iCameraPosition;
    00043 struct iCollection;
    00044 struct iDocumentNode;
    00045 struct iImage;
    00046 struct iLight;
    00047 struct iMaterialWrapper;
    00048 struct iMeshWrapper;
    00049 struct iMeshFactoryWrapper;
    00050 struct iSector;
    00051 struct iShader;
    00052 struct iTextureHandle;
    00053 struct iTextureManager;
    00054 struct iTextureWrapper;
    00055 struct iSharedVariable;
    00056 struct iSndSysData;
    00057 struct iSndSysWrapper;
    00058 struct iSndSysStream;
    00059
    00060 // The keep type flags for collections.
    00061 #define KEEP_ALL  0
    00062 #define KEEP_USED 1
    00063
    00069 struct iMissingLoaderData : public virtual iBase
    00070 {
    00071   SCF_INTERFACE (iMissingLoaderData, 1, 0, 0);
    00072
    00079   virtual iMaterialWrapper* MissingMaterial (const char* name,
    00080     const char* filename) = 0;
    00081
    00088   virtual iTextureWrapper* MissingTexture (const char* name,
    00089     const char* filename) = 0;
    00090
    00097   virtual iShader* MissingShader (const char* name) = 0;
    00098
    00105   virtual iMeshFactoryWrapper* MissingFactory (const char* name) = 0;
    00106
    00113   virtual iMeshWrapper* MissingMesh (const char* name) = 0;
    00114
    00121   virtual iSector* MissingSector (const char* name) = 0;
    00122
    00129   virtual iLight* MissingLight (const char* name) = 0;
    00130 };
    00131
    00135 struct csLoadResult
    00136 {
    00138   bool success;
    00139
    00153   csRef<iBase> result;
    00154 };
    00155
    00159 class csLoaderReturn : public scfImplementation1<csLoaderReturn, iThreadReturn>
    00160 {
    00161 public:
    00162   csLoaderReturn(iThreadManager* tm) : scfImplementationType(this),
    00163     finished(false), success(false), waitLock(0), wait(0), tm(tm)
    00164   {
    00165   }
    00166
    00167   virtual ~csLoaderReturn()
    00168   {
    00169   }
    00170
    00171   bool IsFinished()
    00172   {
    00173     CS::Threading::MutexScopedLock lock(updateLock);
    00174     return finished;
    00175   }
    00176
    00177   bool WasSuccessful()
    00178   {
    00179     CS::Threading::MutexScopedLock lock(updateLock);
    00180     return success;
    00181   }
    00182
    00183   void* GetResultPtr()
    00184   { CS_ASSERT_MSG("csLoaderReturn does not implement a void* result", false); return NULL; }
    00185
    00186   csRef<iBase> GetResultRefPtr() { return result; }
    00187
    00188   void MarkFinished()
    00189   {
    00190     if(waitLock)
    00191       waitLock->Lock();
    00192
    00193     {
    00194       CS::Threading::MutexScopedLock ulock(updateLock);
    00195
    00196       finished = true;
    00197       if(wait)
    00198       {
    00199         wait->NotifyAll();
    00200       }
    00201     }
    00202
    00203     if(waitLock)
    00204       waitLock->Unlock();
    00205   }
    00206
    00207   void MarkSuccessful()
    00208   {
    00209     CS::Threading::MutexScopedLock lock(updateLock);
    00210     success = true;
    00211   }
    00212
    00213   void SetResult(void* result)
    00214   { CS_ASSERT_MSG("csLoaderReturn does not implement a void* result", false); }
    00215
    00216   void SetResult(csRef<iBase> result) { this->result = result; }
    00217
    00218   void Copy(iThreadReturn* other)
    00219   {
    00220     result = other->GetResultRefPtr();
    00221   }
    00222
    00223   void Wait(bool process = true)
    00224   {
    00225     if(tm.IsValid())
    00226     {
    00227       csRefArray<iThreadReturn> rets;
    00228       rets.Push(this);
    00229       tm->Wait(rets, process);
    00230     }
    00231   }
    00232
    00233   void SetWaitPtrs(CS::Threading::Condition* c, CS::Threading::Mutex* m)
    00234   {
    00235     CS::Threading::MutexScopedLock lock(updateLock);
    00236     wait = c;
    00237     waitLock = m;
    00238   }
    00239
    00240   void SetJob(iJob* j)
    00241   {
    00242       job = j;
    00243   }
    00244
    00245   iJob* GetJob() const
    00246   {
    00247       return job;
    00248   }
    00249
    00250 private:
    00252   bool finished;
    00253
    00255   bool success;
    00256
    00258   CS::Threading::Mutex* waitLock;
    00259   CS::Threading::Condition* wait;
    00260   CS::Threading::Mutex updateLock;
    00261
    00275   csRef<iBase> result;
    00276
    00277   // Reference to the thread manager.
    00278   csRef<iThreadManager> tm;
    00279
    00280   // Pointer to the thread job.
    00281   csRef<iJob> job;
    00282 };
    00283
    00284 struct iSectorLoaderIterator : public virtual iBase
    00285 {
    00286   SCF_INTERFACE (iSectorLoaderIterator, 1, 0, 0);
    00287
    00288   virtual iSector* Next() = 0;
    00289
    00290   virtual bool HasNext() const = 0;
    00291 };
    00292
    00293 struct iMeshFactLoaderIterator : public virtual iBase
    00294 {
    00295   SCF_INTERFACE (iMeshFactLoaderIterator, 1, 0, 0);
    00296
    00297   virtual iMeshFactoryWrapper* Next() = 0;
    00298
    00299   virtual bool HasNext() const = 0;
    00300 };
    00301
    00302 struct iMeshLoaderIterator : public virtual iBase
    00303 {
    00304   SCF_INTERFACE (iMeshLoaderIterator, 1, 0, 0);
    00305
    00306   virtual iMeshWrapper* Next() = 0;
    00307
    00308   virtual bool HasNext() const = 0;
    00309 };
    00310
    00311 struct iCamposLoaderIterator : public virtual iBase
    00312 {
    00313   SCF_INTERFACE (iCamposLoaderIterator, 1, 0, 0);
    00314
    00315   virtual iCameraPosition* Next() = 0;
    00316
    00317   virtual bool HasNext() const = 0;
    00318 };
    00319
    00320 struct iTextureLoaderIterator : public virtual iBase
    00321 {
    00322   SCF_INTERFACE (iTextureLoaderIterator, 1, 0, 0);
    00323
    00324   virtual iTextureWrapper* Next() = 0;
    00325
    00326   virtual bool HasNext() const = 0;
    00327 };
    00328
    00329 struct iMaterialLoaderIterator : public virtual iBase
    00330 {
    00331   SCF_INTERFACE (iMaterialLoaderIterator, 1, 0, 0);
    00332
    00333   virtual iMaterialWrapper* Next() = 0;
    00334
    00335   virtual bool HasNext() const = 0;
    00336 };
    00337
    00338 struct iSharedVarLoaderIterator : public virtual iBase
    00339 {
    00340   SCF_INTERFACE (iSharedVarLoaderIterator, 1, 0, 0);
    00341
    00342   virtual iSharedVariable* Next() = 0;
    00343
    00344   virtual bool HasNext() const = 0;
    00345 };
    00346
    00350 #define CS_LOADER_NONE 0
    00351 #define CS_LOADER_CREATE_DUMMY_MATS 1
    00352
    00356 struct iThreadedLoader : public virtual iBase
    00357 {
    00358   SCF_INTERFACE (iThreadedLoader, 2, 3, 0);
    00359
    00363   virtual csPtr<iSectorLoaderIterator> GetLoaderSectors() = 0;
    00364
    00368   virtual csPtr<iMeshFactLoaderIterator> GetLoaderMeshFactories() = 0;
    00369
    00373   virtual csPtr<iMeshLoaderIterator> GetLoaderMeshes() = 0;
    00374
    00378   virtual csPtr<iCamposLoaderIterator> GetLoaderCameraPositions() = 0;
    00379
    00383   virtual csPtr<iTextureLoaderIterator> GetLoaderTextures() = 0;
    00384
    00388   virtual csPtr<iMaterialLoaderIterator> GetLoaderMaterials() = 0;
    00389
    00393   virtual csPtr<iSharedVarLoaderIterator> GetLoaderSharedVariables() = 0;
    00394
    00404   THREADED_INTERFACE4(LoadImage, const char* cwd, const char* Filename, int Format = CS_IMGFMT_INVALID,
    00405     bool do_verbose = false);
    00406
    00414   THREADED_INTERFACE4(LoadImage, const char* cwd, csRef<iDataBuffer> buf, int Format = CS_IMGFMT_INVALID,
    00415   bool do_verbose = false);
    00416
    00430   THREADED_INTERFACE6(LoadTexture, const char* cwd, const char* Filename, int Flags = CS_TEXTURE_3D,
    00431   csRef<iTextureManager> tm = 0, csRef<iImage>* image = 0, bool do_verbose = false);
    00432
    00446   THREADED_INTERFACE6(LoadTexture, const char* cwd, csRef<iDataBuffer> buf, int Flags = CS_TEXTURE_3D,
    00447   csRef<iTextureManager> texman = 0, csRef<iImage>* image = 0, bool do_verbose = false);
    00448
    00472   THREADED_INTERFACE9(LoadTexture, const char* cwd, const char *Name, csRef<iDataBuffer> buf,
    00473     int Flags = CS_TEXTURE_3D, csRef<iTextureManager> texman = 0, bool reg = true,
    00474     bool create_material = true, bool free_image = true, bool do_verbose = false);
    00475
    00477
    00502   THREADED_INTERFACE11(LoadTexture, const char* cwd, const char *Name, const char *FileName,
    00503   int Flags = CS_TEXTURE_3D, csRef<iTextureManager> texman = 0, bool reg = true,
    00504   bool create_material = true, bool free_image = true, csRef<iCollection> Collection = 0,
    00505   uint keepFlags = KEEP_ALL, bool do_verbose = false);
    00507
    00509   THREADED_INTERFACE3(LoadSoundSysData, const char* cwd, const char *fname,
    00510   bool do_verbose = false);
    00511
    00518   THREADED_INTERFACE4(LoadSoundStream, const char* cwd, const char *fname, int mode3d,
    00519   bool do_verbose = false);
    00520
    00527   THREADED_INTERFACE4(LoadSoundWrapper, const char* cwd, const char *name, const char *fname,
    00528   bool do_verbose = false);
    00529
    00530
    00536   THREADED_INTERFACE4(LoadMeshObjectFactory, const char* cwd, const char* fname, csRef<iStreamSource> ssource = 0,
    00537   bool do_verbose = false);
    00538
    00545   THREADED_INTERFACE4(LoadMeshObject, const char* cwd, const char* fname, csRef<iStreamSource> ssource = 0,
    00546   bool do_verbose = false);
    00547
    00548
    00552   THREADED_INTERFACE4(LoadShader, const char* cwd, const char* filename, bool registerShader = true,
    00553   bool do_verbose = false);
    00554
    00556
    00593   THREADED_INTERFACE8(LoadMapFile, const char* cwd, const char* filename, bool clearEngine = true,
    00594   csRef<iCollection> collection = 0, csRef<iStreamSource> ssource = 0, csRef<iMissingLoaderData> missingdata = 0,
    00595   uint keepFlags = KEEP_ALL, bool do_verbose = false);
    00597
    00599
    00635   THREADED_INTERFACE8(LoadMap, const char* cwd, csRef<iDocumentNode> world_node, bool clearEngine = true,
    00636   csRef<iCollection> collection = 0, csRef<iStreamSource> ssource = 0, csRef<iMissingLoaderData> missingdata = 0,
    00637   uint keepFlags = KEEP_ALL, bool do_verbose = false);
    00639
    00641
    00663   THREADED_INTERFACE7(LoadLibraryFile, const char* cwd, const char* filename, csRef<iCollection> collection = 0,
    00664   csRef<iStreamSource> ssource = 0, csRef<iMissingLoaderData> missingdata = 0, uint keepFlags = KEEP_ALL,
    00665   bool do_verbose = false);
    00667
    00669
    00691   THREADED_INTERFACE7(LoadLibrary, const char* cwd, csRef<iDocumentNode> lib_node, csRef<iCollection> collection = 0,
    00692   csRef<iStreamSource> ssource = 0, csRef<iMissingLoaderData> missingdata = 0, uint keepFlags = KEEP_ALL,
    00693   bool do_verbose = false);
    00694   //@)
    00695
    00697
    00740   THREADED_INTERFACE7(LoadFile, const char* cwd, const char* fname, csRef<iCollection> collection = 0,
    00741   csRef<iStreamSource> ssource = 0, csRef<iMissingLoaderData> missingdata = 0, uint keepFlags = KEEP_ALL,
    00742   bool do_verbose = false);
    00744
    00746
    00789   THREADED_INTERFACE7(LoadBuffer, const char* cwd, csRef<iDataBuffer> buffer, csRef<iCollection> collection = 0,
    00790   csRef<iStreamSource> ssource = 0, csRef<iMissingLoaderData> missingdata = 0, uint keepFlags = KEEP_ALL,
    00791   bool do_verbose = false);
    00793
    00795
    00836   THREADED_INTERFACE8(LoadNode, const char* cwd, csRef<iDocumentNode> node, csRef<iCollection> collection = 0,
    00837   csRef<iSector> sector = 0, csRef<iStreamSource> ssource = 0, csRef<iMissingLoaderData> missingdata = 0,
    00838   uint keepFlags = KEEP_ALL, bool do_verbose = false);
    00840
    00842   virtual void AddSectorToList(iSector* obj) = 0;
    00843   virtual void AddMeshFactToList(iMeshFactoryWrapper* obj) = 0;
    00844   virtual void AddMeshToList(iMeshWrapper* obj) = 0;
    00845   virtual void AddCamposToList(iCameraPosition* obj) = 0;
    00846   virtual void AddTextureToList(iTextureWrapper* obj) = 0;
    00847   virtual void AddMaterialToList(iMaterialWrapper* obj) = 0;
    00848   virtual void AddSharedVarToList(iSharedVariable* obj) = 0;
    00849
    00850   virtual void MarkSyncDone() = 0;
    00851
    00852   // Get/Set loader flags.
    00853   virtual const int& GetFlags () const = 0;
    00854   virtual void SetFlags (int flags) = 0;
    00855 };
    00856
    00860 struct iLoader : public virtual iBase
    00861 {
    00862   SCF_INTERFACE (iLoader, 5, 0, 0);
    00863
    00865
    00872   virtual csPtr<iImage> LoadImage (const char* Filename,
    00873     int Format = CS_IMGFMT_INVALID) = 0;
    00886   virtual csPtr<iTextureHandle> LoadTexture (const char* Filename,
    00887     int Flags = CS_TEXTURE_3D, iTextureManager *tm = 0,
    00888     csRef<iImage>* image=0) = 0;
    00889
    00891   virtual csPtr<iSndSysData> LoadSoundSysData (const char *fname) = 0;
    00892
    00899   virtual csPtr<iSndSysStream> LoadSoundStream (const char *fname,
    00900     int mode3d) = 0;
    00901
    00908   virtual iSndSysWrapper* LoadSoundWrapper (const char *name,
    00909     const char *fname) = 0;
    00910
    00918   virtual csPtr<iImage> LoadImage (iDataBuffer* buf,
    00919     int Format = CS_IMGFMT_INVALID) = 0;
    00933   virtual csPtr<iTextureHandle> LoadTexture (iDataBuffer* buf,
    00934     int Flags = CS_TEXTURE_3D, iTextureManager *tm = 0,
    00935     csRef<iImage>* image=0) = 0;
    00959   virtual iTextureWrapper* LoadTexture (const char *Name,
    00960     iDataBuffer* buf,
    00961     int Flags = CS_TEXTURE_3D, iTextureManager *tm = 0,
    00962     bool reg = true, bool create_material = true,
    00963     bool free_image = true) = 0;
    00964
    00970   virtual csPtr<iMeshFactoryWrapper> LoadMeshObjectFactory (
    00971     const char* fname, iStreamSource* ssource = 0) = 0;
    00978   virtual csPtr<iMeshWrapper> LoadMeshObject (const char* fname,
    00979     iStreamSource* ssource = 0) = 0;
    00980
    00984   virtual csRef<iShader> LoadShader (const char* filename, bool registerShader = true) = 0;
    00985
    00987
    01012   virtual iTextureWrapper* LoadTexture (const char *Name,
    01013     const char *FileName, int Flags = CS_TEXTURE_3D, iTextureManager *tm = 0,
    01014     bool reg = true, bool create_material = true, bool free_image = true,
    01015     iCollection* Collection = 0, uint keepFlags = KEEP_ALL) = 0;
    01017
    01019
    01056   virtual bool LoadMapFile (const char* filename, bool clearEngine = true,
    01057     iCollection* collection = 0, bool curRegOnly = true,
    01058     bool checkDupes = false, iStreamSource* ssource = 0,
    01059     iMissingLoaderData* missingdata = 0, uint keepFlags = KEEP_ALL) = 0;
    01061
    01063
    01099   virtual bool LoadMap (iDocumentNode* world_node, bool clearEngine = true,
    01100     iCollection* collection = 0, bool curRegOnly = true,
    01101     bool checkDupes = false, iStreamSource* ssource = 0,
    01102     iMissingLoaderData* missingdata = 0, uint keepFlags = KEEP_ALL) = 0;
    01104
    01106
    01128   virtual bool LoadLibraryFile (const char* filename, iCollection* collection = 0,
    01129     bool searchCollectionOnly = true, bool checkDupes = false, iStreamSource* ssource = 0,
    01130     iMissingLoaderData* missingdata = 0, uint keepFlags = KEEP_ALL) = 0;
    01132
    01134
    01156   virtual bool LoadLibrary (iDocumentNode* lib_node, iCollection* collection = 0,
    01157     bool searchCollectionOnly = true, bool checkDupes = false, iStreamSource* ssource = 0,
    01158     iMissingLoaderData* missingdata = 0, uint keepFlags = KEEP_ALL) = 0;
    01159   //@)
    01160
    01162
    01208   virtual csLoadResult Load (const char* fname, iCollection* collection = 0,
    01209     bool searchCollectionOnly = true, bool checkDupes = false, iStreamSource* ssource = 0,
    01210     const char* override_name = 0, iMissingLoaderData* missingdata = 0,
    01211     uint keepFlags = KEEP_ALL) = 0;
    01213
    01215
    01261   virtual csLoadResult Load (iDataBuffer* buffer, iCollection* collection = 0,
    01262     bool searchCollectionOnly = true, bool checkDupes = false, iStreamSource* ssource = 0,
    01263     const char* override_name = 0, iMissingLoaderData* missingdata = 0,
    01264     uint keepFlags = KEEP_ALL) = 0;
    01266
    01268
    01313   virtual csLoadResult Load (iDocumentNode* node, iCollection* collection = 0,
    01314     bool searchCollectionOnly = true, bool checkDupes = false, iStreamSource* ssource = 0,
    01315     const char* override_name = 0, iMissingLoaderData* missingdata = 0,
    01316     uint keepFlags = KEEP_ALL) = 0;
    01318 };
    01319
    01322 #include "csutil/deprecated_warn_on.h"
    01323
    01324 #endif // __CS_IMAP_PARSER_H__
    01325