CrystalSpace

Public API Reference

iLoader Struct Reference
[Loading & Saving support]

This interface represents the map loader. More...

#include <imap/loader.h>

Inheritance diagram for iLoader:

List of all members.

Public Member Functions

virtual bool GetAutoRegions ()=0
 Get whether to load each file into a separate region.
virtual bool Load (const char *fname, iBase *&result, iRegion *region=0, bool curRegOnly=true, bool checkDupes=false, iStreamSource *ssource=0, const char *override_name=0, iMissingLoaderData *missingdata=0)=0
 Load a file.
virtual bool Load (iDocumentNode *node, iBase *&result, iRegion *region=0, bool curRegOnly=true, bool checkDupes=false, iStreamSource *ssource=0, const char *override_name=0, iMissingLoaderData *missingdata=0)=0
 Load a node.
virtual bool Load (iDataBuffer *buffer, iBase *&result, iRegion *region=0, bool curRegOnly=true, bool checkDupes=false, iStreamSource *ssource=0, const char *override_name=0, iMissingLoaderData *missingdata=0)=0
 Load a file.
virtual csPtr< iImageLoadImage (const char *Filename, int Format=CS_IMGFMT_INVALID)=0
 Load an image file.
virtual csPtr< iImageLoadImage (iDataBuffer *buf, int Format=CS_IMGFMT_INVALID)=0
 Load an image file.
virtual bool LoadMapFile (const char *filename, bool clearEngine=true, iCollection *collection=0, bool curRegOnly=true, bool checkDupes=false, iStreamSource *ssource=0, iMissingLoaderData *missingdata=0, uint keepFlags=KEEP_ALL)=0
 Load a map file.
virtual csPtr< iMeshWrapperLoadMeshObject (const char *fname, iStreamSource *ssource=0)=0
 Load a mesh object from a file.
virtual csPtr
< iMeshFactoryWrapper
LoadMeshObjectFactory (const char *fname, iStreamSource *ssource=0)=0
 Load a Mesh Object Factory from a file.
virtual csRef< iShaderLoadShader (const char *filename, bool registerShader=true)=0
 Load a shader from a file.
virtual csPtr< iSndSysStreamLoadSoundStream (const char *fname, int mode3d)=0
 New Sound System: Load a sound file and create a stream from it.
virtual csPtr< iSndSysDataLoadSoundSysData (const char *fname)=0
 New Sound System: Load a sound file and return an iSndSysData object.
virtual iSndSysWrapperLoadSoundWrapper (const char *name, const char *fname)=0
 New Sound System: Load a sound file, create sound data and create a wrapper object for it.
virtual iTextureWrapperLoadTexture (const char *Name, iDataBuffer *buf, int Flags=CS_TEXTURE_3D, iTextureManager *tm=0, bool reg=true, bool create_material=true, bool free_image=true)=0
 Load a texture as with LoadTexture() above and register it with the engine.
virtual csPtr< iTextureHandleLoadTexture (iDataBuffer *buf, int Flags=CS_TEXTURE_3D, iTextureManager *tm=0, csRef< iImage > *image=0)=0
 Load an image as with LoadImage() and create a texture handle from it.
virtual csPtr< iTextureHandleLoadTexture (const char *Filename, int Flags=CS_TEXTURE_3D, iTextureManager *tm=0, csRef< iImage > *image=0)=0
 Load an image as with LoadImage() and create a texture handle from it.
virtual void SetAutoRegions (bool autoRegions)=0
 Set whether to load each file into a separate region.

virtual iTextureWrapperLoadTexture (const char *Name, const char *FileName, int Flags=CS_TEXTURE_3D, iTextureManager *tm=0, bool reg=true, bool create_material=true, bool free_image=true, iCollection *Collection=0, uint keepFlags=KEEP_ALL)=0
 Load a texture as with LoadTexture() above and register it with the engine.
virtual iTextureWrapperLoadTexture (const char *Name, const char *FileName, int Flags, iTextureManager *tm, bool reg, bool create_material, bool free_image, iRegion *region)=0
 Load a texture as with LoadTexture() above and register it with the engine.
iTextureWrapperLoadTexture (const char *Name, const char *FileName, int Flags, iTextureManager *tm, bool reg, bool create_material, bool free_image, int dummy)
 Load a texture as with LoadTexture() above and register it with the engine.

virtual bool LoadMap (iDocumentNode *world_node, bool clearEngine=true, iCollection *collection=0, bool curRegOnly=true, bool checkDupes=false, iStreamSource *ssource=0, iMissingLoaderData *missingdata=0, uint keepFlags=KEEP_ALL)=0
 Load a map from the given 'world' node.
virtual bool LoadMap (iDocumentNode *world_node, bool clearEngine, iRegion *region, bool curRegOnly=true, bool checkDupes=false, iStreamSource *ssource=0, iMissingLoaderData *missingdata=0)=0
 Load a map from the given 'world' node.
bool LoadMap (iDocumentNode *world_node, bool clearEngine, int dummy, bool curRegOnly=true, bool checkDupes=false, iStreamSource *ssource=0, iMissingLoaderData *missingdata=0)
 Load a map from the given 'world' node.

virtual bool LoadLibraryFile (const char *filename, iCollection *collection=0, bool searchCollectionOnly=true, bool checkDupes=false, iStreamSource *ssource=0, iMissingLoaderData *missingdata=0, uint keepFlags=KEEP_ALL)=0
 Load library from a VFS file.
virtual bool LoadLibraryFile (const char *filename, iRegion *region, bool searchregionOnly=true, bool checkDupes=false, iStreamSource *ssource=0, iMissingLoaderData *missingdata=0)=0
 Load library from a VFS file.
bool LoadLibraryFile (const char *filename, int dummy, bool searchregionOnly=true, bool checkDupes=false, iStreamSource *ssource=0, iMissingLoaderData *missingdata=0)
 Load library from a VFS file.

virtual bool LoadLibrary (iDocumentNode *lib_node, iCollection *collection=0, bool searchCollectionOnly=true, bool checkDupes=false, iStreamSource *ssource=0, iMissingLoaderData *missingdata=0, uint keepFlags=KEEP_ALL)=0
 Load library from a 'library' node.
virtual bool LoadLibrary (iDocumentNode *lib_node, iRegion *region, bool searchRegionOnly=true, bool checkDupes=false, iStreamSource *ssource=0, iMissingLoaderData *missingdata=0)=0
 Load library from a 'library' node.
bool LoadLibrary (iDocumentNode *lib_node, int dummy, bool searchRegionOnly=true, bool checkDupes=false, iStreamSource *ssource=0, iMissingLoaderData *missingdata=0)
 Load library from a 'library' node.
virtual csLoadResult Load (const char *fname, iCollection *collection=0, bool searchCollectionOnly=true, bool checkDupes=false, iStreamSource *ssource=0, const char *override_name=0, iMissingLoaderData *missingdata=0, uint keepFlags=KEEP_ALL)=0
 Load a file.
virtual csLoadResult Load (const char *fname, iRegion *region, bool searchRegionOnly=true, bool checkDupes=false, iStreamSource *ssource=0, const char *override_name=0, iMissingLoaderData *missingdata=0)=0
 Load library from a 'library' node.
csLoadResult Load (const char *fname, int dummy, bool searchRegionOnly=true, bool checkDupes=false, iStreamSource *ssource=0, const char *override_name=0, iMissingLoaderData *missingdata=0)
 Load library from a 'library' node.

virtual csLoadResult Load (iDataBuffer *buffer, iCollection *collection=0, bool searchCollectionOnly=true, bool checkDupes=false, iStreamSource *ssource=0, const char *override_name=0, iMissingLoaderData *missingdata=0, uint keepFlags=KEEP_ALL)=0
 Load a file.
virtual csLoadResult Load (iDataBuffer *buffer, iRegion *region, bool searchRegionOnly=true, bool checkDupes=false, iStreamSource *ssource=0, const char *override_name=0, iMissingLoaderData *missingdata=0)=0
 Load a file.
csLoadResult Load (iDataBuffer *buffer, int dummy, bool searchRegionOnly=true, bool checkDupes=false, iStreamSource *ssource=0, const char *override_name=0, iMissingLoaderData *missingdata=0)
 Load a file.

virtual csLoadResult Load (iDocumentNode *node, iCollection *collection=0, bool searchCollectionOnly=true, bool checkDupes=false, iStreamSource *ssource=0, const char *override_name=0, iMissingLoaderData *missingdata=0, uint keepFlags=KEEP_ALL)=0
 Load a node.
virtual csLoadResult Load (iDocumentNode *node, iRegion *region, bool searchRegionOnly=true, bool checkDupes=false, iStreamSource *ssource=0, const char *override_name=0, iMissingLoaderData *missingdata=0)=0
 Load a node.
csLoadResult Load (iDocumentNode *node, int dummy, bool searchRegionOnly=true, bool checkDupes=false, iStreamSource *ssource=0, const char *override_name=0, iMissingLoaderData *missingdata=0)
 Load a node.

Detailed Description

This interface represents the map loader.

Definition at line 151 of file loader.h.


Member Function Documentation

virtual bool iLoader::GetAutoRegions (  )  [pure virtual]

Get whether to load each file into a separate region.

Deprecated:
Deprecated in 1.3. Use the iCollections instead.
virtual csLoadResult iLoader::Load ( const char *  fname,
iCollection collection = 0,
bool  searchCollectionOnly = true,
bool  checkDupes = false,
iStreamSource ssource = 0,
const char *  override_name = 0,
iMissingLoaderData missingdata = 0,
uint  keepFlags = KEEP_ALL 
) [pure virtual]

Load a file.

This is a smart function that will try to recognize what kind of file it is. It recognizes the following types of files:

  • 'world' file: in that case 'result' will be set to the engine.
  • 'library' file: 'result' will be 0.
  • 'meshfact' file: 'result' will be the mesh factory wrapper.
  • 'meshobj' file: 'result' will be the mesh wrapper.
  • 'meshref' file: 'result' will be the mesh wrapper.
  • 3ds/md2 models: 'result' will be the mesh factory wrapper.
  • 'portals' file: 'result' will be the portal's mesh wrapper.
  • 'light' file: 'result' will be the light.

Returns csLoadResult.
Note! In case a world file is loaded this function will NOT clear the engine!
Note! In case a mesh factory or mesh object is loaded this function will not actually do anything if checkDupes is true and the mesh or factory is already in memory (with that name). This function will still return true in that case and set 'result' to the correct object.

Parameters:
fname is a VFS filename for the XML file.
collection is 0 by default which means that all loaded objects are either added to the default collection or not added to any collection, depending on the value of the keepFlags argument.
searchCollectionOnly is true by default which means that it will only find materials/factories/... from current collection if that is given.
checkDupes if true then materials, textures, and mesh factories will only be loaded if they don't already exist in the entire engine (ignoring regions). By default this is false because it is very legal for different world files to have different objects with the same name. Only use checkDupes == true if you know that your objects have unique names accross all world files.
ssource is an optional stream source for faster loading.
override_name if this is given the the name of the loaded object will be set to that. This only works in case of meshfact, meshobj, and 3ds or md2 model.
missingdata is an optional callback in case data is missing. The application can then provide that missing data in some other way.
keepFlags Use these to define whether or not you wish to guarantee that all loaded resources are kept (default to KEEP_ALL). KEEP_USED is useful when you are loading from a shared library containing more resources than you actually need (a world file loading from a shared library of textures for example).
csLoadResult iLoader::Load ( iDataBuffer buffer,
int  dummy,
bool  searchRegionOnly = true,
bool  checkDupes = false,
iStreamSource ssource = 0,
const char *  override_name = 0,
iMissingLoaderData missingdata = 0 
) [inline]

Load a file.

This is a smart function that will try to recognize what kind of file it is. It recognizes the following types of files:

  • 'world' file: in that case 'result' will be set to the engine.
  • 'library' file: 'result' will be 0.
  • 'meshfact' file: 'result' will be the mesh factory wrapper.
  • 'meshobj' file: 'result' will be the mesh wrapper.
  • 'meshref' file: 'result' will be the mesh wrapper.
  • 3ds/md2 models: 'result' will be the mesh factory wrapper.
  • 'portals' file: 'result' will be the portal's mesh wrapper.
  • 'light' file: 'result' will be the light.

Returns csLoadResult.
Note! In case a world file is loaded this function will NOT clear the engine!
Note! In case a mesh factory or mesh object is loaded this function will not actually do anything if checkDupes is true and the mesh or factory is already in memory (with that name). This function will still return true in that case and set 'result' to the correct object.

Parameters:
buffer is a buffer for the model contents.
collection is 0 by default which means that all loaded objects are either added to the default collection or not added to any collection, depending on the value of the keepFlags argument.
searchCollectionOnly is true by default which means that it will only find materials/factories/... from current collection if that is given.
checkDupes if true then materials, textures, and mesh factories will only be loaded if they don't already exist in the entire engine (ignoring regions). By default this is false because it is very legal for different world files to have different objects with the same name. Only use checkDupes == true if you know that your objects have unique names accross all world files.
ssource is an optional stream source for faster loading.
override_name if this is given the the name of the loaded object will be set to that. This only works in case of meshfact, meshobj, and 3ds or md2 model.
missingdata is an optional callback in case data is missing. The application can then provide that missing data in some other way.
keepFlags Use these to define whether or not you wish to guarantee that all loaded resources are kept (default to KEEP_ALL). KEEP_USED is useful when you are loading from a shared library containing more resources than you actually need (a world file loading from a shared library of textures for example).

Definition at line 646 of file loader.h.

virtual bool iLoader::Load ( iDocumentNode node,
iBase *&  result,
iRegion region = 0,
bool  curRegOnly = true,
bool  checkDupes = false,
iStreamSource ssource = 0,
const char *  override_name = 0,
iMissingLoaderData missingdata = 0 
) [pure virtual]

Load a node.

Deprecated:
Deprecated in 1.3. Use the iLoader::Load() that returns a csLoadResult object instead.
virtual csLoadResult iLoader::Load ( iDocumentNode node,
iCollection collection = 0,
bool  searchCollectionOnly = true,
bool  checkDupes = false,
iStreamSource ssource = 0,
const char *  override_name = 0,
iMissingLoaderData missingdata = 0,
uint  keepFlags = KEEP_ALL 
) [pure virtual]

Load a node.

This is a smart function that will try to recognize what kind of node it is. It recognizes the following types of nodes:

  • 'world' node: in that case 'result' will be set to the engine.
  • 'library' node: 'result' will be 0.
  • 'meshfact' node: 'result' will be the mesh factory wrapper.
  • 'meshobj' node: 'result' will be the mesh wrapper.
  • 'meshref' file: 'result' will be the mesh wrapper.
  • 'portals' file: 'result' will be the portal's mesh wrapper.
  • 'light' file: 'result' will be the light.

Returns csLoadResult.
Note! In case a world node is loaded this function will NOT clear the engine!
Note! In case a mesh factory or mesh object is loaded this function will not actually do anything if checkDupes is true and the mesh or factory is already in memory (with that name). This function will still return true in that case and set 'result' to the correct object.

Parameters:
node is the node from which to read.
collection is 0 by default which means that all loaded objects are either added to the default collection or not added to any collection, depending on the value of the keepFlags argument.
searchCollectionOnly is true by default which means that it will only find materials/factories/... from current collection if that is given.
checkDupes if true then materials, textures, and mesh factories will only be loaded if they don't already exist in the entire engine (ignoring regions). By default this is false because it is very legal for different world files to have different objects with the same name. Only use checkDupes == true if you know that your objects have unique names accross all world files.
ssource is an optional stream source for faster loading.
override_name if this is given the the name of the loaded object will be set to that. This only works in case of meshfact, meshobj, and 3ds or md2 model.
missingdata is an optional callback in case data is missing. The application can then provide that missing data in some other way.
keepFlags Use these to define whether or not you wish to guarantee that all loaded resources are kept (default to KEEP_ALL). KEEP_USED is useful when you are loading from a shared library containing more resources than you actually need (a world file loading from a shared library of textures for example).
virtual csLoadResult iLoader::Load ( iDocumentNode node,
iRegion region,
bool  searchRegionOnly = true,
bool  checkDupes = false,
iStreamSource ssource = 0,
const char *  override_name = 0,
iMissingLoaderData missingdata = 0 
) [pure virtual]

Load a node.

This is a smart function that will try to recognize what kind of node it is. It recognizes the following types of nodes:

  • 'world' node: in that case 'result' will be set to the engine.
  • 'library' node: 'result' will be 0.
  • 'meshfact' node: 'result' will be the mesh factory wrapper.
  • 'meshobj' node: 'result' will be the mesh wrapper.
  • 'meshref' file: 'result' will be the mesh wrapper.
  • 'portals' file: 'result' will be the portal's mesh wrapper.
  • 'light' file: 'result' will be the light.

Returns csLoadResult.
Note! In case a world node is loaded this function will NOT clear the engine!
Note! In case a mesh factory or mesh object is loaded this function will not actually do anything if checkDupes is true and the mesh or factory is already in memory (with that name). This function will still return true in that case and set 'result' to the correct object.

Parameters:
node is the node from which to read.
collection is 0 by default which means that all loaded objects are either added to the default collection or not added to any collection, depending on the value of the keepFlags argument.
searchCollectionOnly is true by default which means that it will only find materials/factories/... from current collection if that is given.
checkDupes if true then materials, textures, and mesh factories will only be loaded if they don't already exist in the entire engine (ignoring regions). By default this is false because it is very legal for different world files to have different objects with the same name. Only use checkDupes == true if you know that your objects have unique names accross all world files.
ssource is an optional stream source for faster loading.
override_name if this is given the the name of the loaded object will be set to that. This only works in case of meshfact, meshobj, and 3ds or md2 model.
missingdata is an optional callback in case data is missing. The application can then provide that missing data in some other way.
keepFlags Use these to define whether or not you wish to guarantee that all loaded resources are kept (default to KEEP_ALL). KEEP_USED is useful when you are loading from a shared library containing more resources than you actually need (a world file loading from a shared library of textures for example).
csLoadResult iLoader::Load ( iDocumentNode node,
int  dummy,
bool  searchRegionOnly = true,
bool  checkDupes = false,
iStreamSource ssource = 0,
const char *  override_name = 0,
iMissingLoaderData missingdata = 0 
) [inline]

Load a node.

This is a smart function that will try to recognize what kind of node it is. It recognizes the following types of nodes:

  • 'world' node: in that case 'result' will be set to the engine.
  • 'library' node: 'result' will be 0.
  • 'meshfact' node: 'result' will be the mesh factory wrapper.
  • 'meshobj' node: 'result' will be the mesh wrapper.
  • 'meshref' file: 'result' will be the mesh wrapper.
  • 'portals' file: 'result' will be the portal's mesh wrapper.
  • 'light' file: 'result' will be the light.

Returns csLoadResult.
Note! In case a world node is loaded this function will NOT clear the engine!
Note! In case a mesh factory or mesh object is loaded this function will not actually do anything if checkDupes is true and the mesh or factory is already in memory (with that name). This function will still return true in that case and set 'result' to the correct object.

Parameters:
node is the node from which to read.
collection is 0 by default which means that all loaded objects are either added to the default collection or not added to any collection, depending on the value of the keepFlags argument.
searchCollectionOnly is true by default which means that it will only find materials/factories/... from current collection if that is given.
checkDupes if true then materials, textures, and mesh factories will only be loaded if they don't already exist in the entire engine (ignoring regions). By default this is false because it is very legal for different world files to have different objects with the same name. Only use checkDupes == true if you know that your objects have unique names accross all world files.
ssource is an optional stream source for faster loading.
override_name if this is given the the name of the loaded object will be set to that. This only works in case of meshfact, meshobj, and 3ds or md2 model.
missingdata is an optional callback in case data is missing. The application can then provide that missing data in some other way.
keepFlags Use these to define whether or not you wish to guarantee that all loaded resources are kept (default to KEEP_ALL). KEEP_USED is useful when you are loading from a shared library containing more resources than you actually need (a world file loading from a shared library of textures for example).

Definition at line 711 of file loader.h.

virtual bool iLoader::Load ( const char *  fname,
iBase *&  result,
iRegion region = 0,
bool  curRegOnly = true,
bool  checkDupes = false,
iStreamSource ssource = 0,
const char *  override_name = 0,
iMissingLoaderData missingdata = 0 
) [pure virtual]

Load a file.

Deprecated:
Deprecated in 1.3. Use the iLoader::Load() that returns a csLoadResult object instead.
virtual bool iLoader::Load ( iDataBuffer buffer,
iBase *&  result,
iRegion region = 0,
bool  curRegOnly = true,
bool  checkDupes = false,
iStreamSource ssource = 0,
const char *  override_name = 0,
iMissingLoaderData missingdata = 0 
) [pure virtual]

Load a file.

Deprecated:
Deprecated in 1.3. Use the iLoader::Load() that returns a csLoadResult object instead.
virtual csLoadResult iLoader::Load ( iDataBuffer buffer,
iRegion region,
bool  searchRegionOnly = true,
bool  checkDupes = false,
iStreamSource ssource = 0,
const char *  override_name = 0,
iMissingLoaderData missingdata = 0 
) [pure virtual]

Load a file.

This is a smart function that will try to recognize what kind of file it is. It recognizes the following types of files:

  • 'world' file: in that case 'result' will be set to the engine.
  • 'library' file: 'result' will be 0.
  • 'meshfact' file: 'result' will be the mesh factory wrapper.
  • 'meshobj' file: 'result' will be the mesh wrapper.
  • 'meshref' file: 'result' will be the mesh wrapper.
  • 3ds/md2 models: 'result' will be the mesh factory wrapper.
  • 'portals' file: 'result' will be the portal's mesh wrapper.
  • 'light' file: 'result' will be the light.

Returns csLoadResult.
Note! In case a world file is loaded this function will NOT clear the engine!
Note! In case a mesh factory or mesh object is loaded this function will not actually do anything if checkDupes is true and the mesh or factory is already in memory (with that name). This function will still return true in that case and set 'result' to the correct object.

Parameters:
buffer is a buffer for the model contents.
collection is 0 by default which means that all loaded objects are either added to the default collection or not added to any collection, depending on the value of the keepFlags argument.
searchCollectionOnly is true by default which means that it will only find materials/factories/... from current collection if that is given.
checkDupes if true then materials, textures, and mesh factories will only be loaded if they don't already exist in the entire engine (ignoring regions). By default this is false because it is very legal for different world files to have different objects with the same name. Only use checkDupes == true if you know that your objects have unique names accross all world files.
ssource is an optional stream source for faster loading.
override_name if this is given the the name of the loaded object will be set to that. This only works in case of meshfact, meshobj, and 3ds or md2 model.
missingdata is an optional callback in case data is missing. The application can then provide that missing data in some other way.
keepFlags Use these to define whether or not you wish to guarantee that all loaded resources are kept (default to KEEP_ALL). KEEP_USED is useful when you are loading from a shared library containing more resources than you actually need (a world file loading from a shared library of textures for example).
virtual csLoadResult iLoader::Load ( const char *  fname,
iRegion region,
bool  searchRegionOnly = true,
bool  checkDupes = false,
iStreamSource ssource = 0,
const char *  override_name = 0,
iMissingLoaderData missingdata = 0 
) [pure virtual]

Load library from a 'library' node.

Parameters:
lib_node is the 'library' node from an XML document.
collection is 0 by default which means that all loaded objects are either added to the default collection or not added to any collection, depending on the value of the keepFlags argument.
searchCollectionOnly is true by default which means that it will only find materials/factories/... from current collection if that is given.
checkDupes if true then materials, textures, and mesh factories will only be loaded if they don't already exist in the entire engine (ignoring regions). By default this is false because it is very legal for different world files to have different objects with the same name. Only use checkDupes == true if you know that your objects have unique names accross all world files.
ssource is an optional stream source for faster loading.
missingdata is an optional callback in case data is missing. The application can then provide that missing data in some other way.
keepFlags Use these to define whether or not you wish to guarantee that all loaded resources are kept (default to KEEP_ALL). KEEP_USED is useful when you are loading from a shared library containing more resources than you actually need (a world file loading from a shared library of textures for example).
csLoadResult iLoader::Load ( const char *  fname,
int  dummy,
bool  searchRegionOnly = true,
bool  checkDupes = false,
iStreamSource ssource = 0,
const char *  override_name = 0,
iMissingLoaderData missingdata = 0 
) [inline]

Load library from a 'library' node.

Parameters:
lib_node is the 'library' node from an XML document.
collection is 0 by default which means that all loaded objects are either added to the default collection or not added to any collection, depending on the value of the keepFlags argument.
searchCollectionOnly is true by default which means that it will only find materials/factories/... from current collection if that is given.
checkDupes if true then materials, textures, and mesh factories will only be loaded if they don't already exist in the entire engine (ignoring regions). By default this is false because it is very legal for different world files to have different objects with the same name. Only use checkDupes == true if you know that your objects have unique names accross all world files.
ssource is an optional stream source for faster loading.
missingdata is an optional callback in case data is missing. The application can then provide that missing data in some other way.
keepFlags Use these to define whether or not you wish to guarantee that all loaded resources are kept (default to KEEP_ALL). KEEP_USED is useful when you are loading from a shared library containing more resources than you actually need (a world file loading from a shared library of textures for example).

Definition at line 580 of file loader.h.

virtual csLoadResult iLoader::Load ( iDataBuffer buffer,
iCollection collection = 0,
bool  searchCollectionOnly = true,
bool  checkDupes = false,
iStreamSource ssource = 0,
const char *  override_name = 0,
iMissingLoaderData missingdata = 0,
uint  keepFlags = KEEP_ALL 
) [pure virtual]

Load a file.

This is a smart function that will try to recognize what kind of file it is. It recognizes the following types of files:

  • 'world' file: in that case 'result' will be set to the engine.
  • 'library' file: 'result' will be 0.
  • 'meshfact' file: 'result' will be the mesh factory wrapper.
  • 'meshobj' file: 'result' will be the mesh wrapper.
  • 'meshref' file: 'result' will be the mesh wrapper.
  • 3ds/md2 models: 'result' will be the mesh factory wrapper.
  • 'portals' file: 'result' will be the portal's mesh wrapper.
  • 'light' file: 'result' will be the light.

Returns csLoadResult.
Note! In case a world file is loaded this function will NOT clear the engine!
Note! In case a mesh factory or mesh object is loaded this function will not actually do anything if checkDupes is true and the mesh or factory is already in memory (with that name). This function will still return true in that case and set 'result' to the correct object.

Parameters:
buffer is a buffer for the model contents.
collection is 0 by default which means that all loaded objects are either added to the default collection or not added to any collection, depending on the value of the keepFlags argument.
searchCollectionOnly is true by default which means that it will only find materials/factories/... from current collection if that is given.
checkDupes if true then materials, textures, and mesh factories will only be loaded if they don't already exist in the entire engine (ignoring regions). By default this is false because it is very legal for different world files to have different objects with the same name. Only use checkDupes == true if you know that your objects have unique names accross all world files.
ssource is an optional stream source for faster loading.
override_name if this is given the the name of the loaded object will be set to that. This only works in case of meshfact, meshobj, and 3ds or md2 model.
missingdata is an optional callback in case data is missing. The application can then provide that missing data in some other way.
keepFlags Use these to define whether or not you wish to guarantee that all loaded resources are kept (default to KEEP_ALL). KEEP_USED is useful when you are loading from a shared library containing more resources than you actually need (a world file loading from a shared library of textures for example).
virtual csPtr<iImage> iLoader::LoadImage ( iDataBuffer buf,
int  Format = CS_IMGFMT_INVALID 
) [pure virtual]

Load an image file.

The image will be loaded in the format requested by the engine. If no engine exists, the format is taken from the video renderer. If no video renderer exists, this function fails. You may also request an alternate format to override the above sequence. This version reads the image from a data buffer.

virtual csPtr<iImage> iLoader::LoadImage ( const char *  Filename,
int  Format = CS_IMGFMT_INVALID 
) [pure virtual]

Load an image file.

The image will be loaded in the format requested by the engine. If no engine exists, the format is taken from the video renderer. If no video renderer exists, this function fails. You may also request an alternate format to override the above sequence.

virtual bool iLoader::LoadLibrary ( iDocumentNode lib_node,
iCollection collection = 0,
bool  searchCollectionOnly = true,
bool  checkDupes = false,
iStreamSource ssource = 0,
iMissingLoaderData missingdata = 0,
uint  keepFlags = KEEP_ALL 
) [pure virtual]

Load library from a 'library' node.

Parameters:
lib_node is the 'library' node from an XML document.
collection is 0 by default which means that all loaded objects are either added to the default collection or not added to any collection, depending on the value of the keepFlags argument.
searchCollectionOnly is true by default which means that it will only find materials/factories/... from current collection if that is given.
checkDupes if true then materials, textures, and mesh factories will only be loaded if they don't already exist in the entire engine (ignoring regions). By default this is false because it is very legal for different world files to have different objects with the same name. Only use checkDupes == true if you know that your objects have unique names accross all world files.
ssource is an optional stream source for faster loading.
missingdata is an optional callback in case data is missing. The application can then provide that missing data in some other way.
keepFlags Use these to define whether or not you wish to guarantee that all loaded resources are kept (default to KEEP_ALL). KEEP_USED is useful when you are loading from a shared library containing more resources than you actually need (a world file loading from a shared library of textures for example).
virtual bool iLoader::LoadLibrary ( iDocumentNode lib_node,
iRegion region,
bool  searchRegionOnly = true,
bool  checkDupes = false,
iStreamSource ssource = 0,
iMissingLoaderData missingdata = 0 
) [pure virtual]

Load library from a 'library' node.

Parameters:
lib_node is the 'library' node from an XML document.
collection is 0 by default which means that all loaded objects are either added to the default collection or not added to any collection, depending on the value of the keepFlags argument.
searchCollectionOnly is true by default which means that it will only find materials/factories/... from current collection if that is given.
checkDupes if true then materials, textures, and mesh factories will only be loaded if they don't already exist in the entire engine (ignoring regions). By default this is false because it is very legal for different world files to have different objects with the same name. Only use checkDupes == true if you know that your objects have unique names accross all world files.
ssource is an optional stream source for faster loading.
missingdata is an optional callback in case data is missing. The application can then provide that missing data in some other way.
keepFlags Use these to define whether or not you wish to guarantee that all loaded resources are kept (default to KEEP_ALL). KEEP_USED is useful when you are loading from a shared library containing more resources than you actually need (a world file loading from a shared library of textures for example).
bool iLoader::LoadLibrary ( iDocumentNode lib_node,
int  dummy,
bool  searchRegionOnly = true,
bool  checkDupes = false,
iStreamSource ssource = 0,
iMissingLoaderData missingdata = 0 
) [inline]

Load library from a 'library' node.

Parameters:
lib_node is the 'library' node from an XML document.
collection is 0 by default which means that all loaded objects are either added to the default collection or not added to any collection, depending on the value of the keepFlags argument.
searchCollectionOnly is true by default which means that it will only find materials/factories/... from current collection if that is given.
checkDupes if true then materials, textures, and mesh factories will only be loaded if they don't already exist in the entire engine (ignoring regions). By default this is false because it is very legal for different world files to have different objects with the same name. Only use checkDupes == true if you know that your objects have unique names accross all world files.
ssource is an optional stream source for faster loading.
missingdata is an optional callback in case data is missing. The application can then provide that missing data in some other way.
keepFlags Use these to define whether or not you wish to guarantee that all loaded resources are kept (default to KEEP_ALL). KEEP_USED is useful when you are loading from a shared library containing more resources than you actually need (a world file loading from a shared library of textures for example).

Definition at line 514 of file loader.h.

virtual bool iLoader::LoadLibraryFile ( const char *  filename,
iCollection collection = 0,
bool  searchCollectionOnly = true,
bool  checkDupes = false,
iStreamSource ssource = 0,
iMissingLoaderData missingdata = 0,
uint  keepFlags = KEEP_ALL 
) [pure virtual]

Load library from a VFS file.

Parameters:
filename is a VFS filename for the XML file.
collection is 0 by default which means that all loaded objects are either added to the default collection or not added to any collection, depending on the value of the keepFlags argument.
searchCollectionOnly is true by default which means that it will only find materials/factories/... from current collection if that is given.
checkDupes if true then materials, textures, and mesh factories will only be loaded if they don't already exist in the entire engine (ignoring regions). By default this is false because it is very legal for different world files to have different objects with the same name. Only use checkDupes == true if you know that your objects have unique names accross all world files.
ssource is an optional stream source for faster loading.
missingdata is an optional callback in case data is missing. The application can then provide that missing data in some other way.
keepFlags Use these to define whether or not you wish to guarantee that all loaded resources are kept (default to KEEP_ALL). KEEP_USED is useful when you are loading from a shared library containing more resources than you actually need (a world file loading from a shared library of textures for example).
virtual bool iLoader::LoadLibraryFile ( const char *  filename,
iRegion region,
bool  searchregionOnly = true,
bool  checkDupes = false,
iStreamSource ssource = 0,
iMissingLoaderData missingdata = 0 
) [pure virtual]

Load library from a VFS file.

Parameters:
filename is a VFS filename for the XML file.
collection is 0 by default which means that all loaded objects are either added to the default collection or not added to any collection, depending on the value of the keepFlags argument.
searchCollectionOnly is true by default which means that it will only find materials/factories/... from current collection if that is given.
checkDupes if true then materials, textures, and mesh factories will only be loaded if they don't already exist in the entire engine (ignoring regions). By default this is false because it is very legal for different world files to have different objects with the same name. Only use checkDupes == true if you know that your objects have unique names accross all world files.
ssource is an optional stream source for faster loading.
missingdata is an optional callback in case data is missing. The application can then provide that missing data in some other way.
keepFlags Use these to define whether or not you wish to guarantee that all loaded resources are kept (default to KEEP_ALL). KEEP_USED is useful when you are loading from a shared library containing more resources than you actually need (a world file loading from a shared library of textures for example).
bool iLoader::LoadLibraryFile ( const char *  filename,
int  dummy,
bool  searchregionOnly = true,
bool  checkDupes = false,
iStreamSource ssource = 0,
iMissingLoaderData missingdata = 0 
) [inline]

Load library from a VFS file.

Parameters:
filename is a VFS filename for the XML file.
collection is 0 by default which means that all loaded objects are either added to the default collection or not added to any collection, depending on the value of the keepFlags argument.
searchCollectionOnly is true by default which means that it will only find materials/factories/... from current collection if that is given.
checkDupes if true then materials, textures, and mesh factories will only be loaded if they don't already exist in the entire engine (ignoring regions). By default this is false because it is very legal for different world files to have different objects with the same name. Only use checkDupes == true if you know that your objects have unique names accross all world files.
ssource is an optional stream source for faster loading.
missingdata is an optional callback in case data is missing. The application can then provide that missing data in some other way.
keepFlags Use these to define whether or not you wish to guarantee that all loaded resources are kept (default to KEEP_ALL). KEEP_USED is useful when you are loading from a shared library containing more resources than you actually need (a world file loading from a shared library of textures for example).

Definition at line 473 of file loader.h.

virtual bool iLoader::LoadMap ( iDocumentNode world_node,
bool  clearEngine,
iRegion region,
bool  curRegOnly = true,
bool  checkDupes = false,
iStreamSource ssource = 0,
iMissingLoaderData missingdata = 0 
) [pure virtual]

Load a map from the given 'world' node.

If 'clearEngine' is true then the current contents of the engine will be deleted before loading. If 'region' is not 0 then portals will only connect to the sectors in that region, things will only use thing templates defined in that region and meshes will only use mesh factories defined in that region. If the region is not 0 and curRegOnly is true then objects (materials, factories, ...) will only be found in the given region.

Parameters:
world_node is the 'world' node from an XML document.
clearEngine is true by default which means that the previous contents of the engine is cleared (all objects/sectors/... are removed).
collection is 0 by default which means that all loaded objects are not added to any collection. If you give a region here then all loaded objects will be added to that region.
curRegOnly is true by default which means that it will only find materials/factories/... from current region if that is given.
checkDupes if true then materials, textures, and mesh factories will only be loaded if they don't already exist in the entire engine (ignoring regions). By default this is false because it is very legal for different world files to have different objects with the same name. Only use checkDupes == true if you know that your objects have unique names accross all world files.
ssource is an optional stream source for faster loading.
missingdata is an optional callback in case data is missing. The application can then provide that missing data in some other way.
Set useProxyTextures to true if you're loading materials and textures from a library shared with other maps.
keepFlags Use these to define whether or not you wish to guarantee that all loaded resources are kept (default to KEEP_ALL). KEEP_USED is useful when you are loading from a shared library containing more resources than you actually need (a world file loading from a shared library of textures for example). This argument is only used in conjunction with Collections, and overrides the value of useProxyTextures in that case.
bool iLoader::LoadMap ( iDocumentNode world_node,
bool  clearEngine,
int  dummy,
bool  curRegOnly = true,
bool  checkDupes = false,
iStreamSource ssource = 0,
iMissingLoaderData missingdata = 0 
) [inline]

Load a map from the given 'world' node.

If 'clearEngine' is true then the current contents of the engine will be deleted before loading. If 'region' is not 0 then portals will only connect to the sectors in that region, things will only use thing templates defined in that region and meshes will only use mesh factories defined in that region. If the region is not 0 and curRegOnly is true then objects (materials, factories, ...) will only be found in the given region.

Parameters:
world_node is the 'world' node from an XML document.
clearEngine is true by default which means that the previous contents of the engine is cleared (all objects/sectors/... are removed).
collection is 0 by default which means that all loaded objects are not added to any collection. If you give a region here then all loaded objects will be added to that region.
curRegOnly is true by default which means that it will only find materials/factories/... from current region if that is given.
checkDupes if true then materials, textures, and mesh factories will only be loaded if they don't already exist in the entire engine (ignoring regions). By default this is false because it is very legal for different world files to have different objects with the same name. Only use checkDupes == true if you know that your objects have unique names accross all world files.
ssource is an optional stream source for faster loading.
missingdata is an optional callback in case data is missing. The application can then provide that missing data in some other way.
Set useProxyTextures to true if you're loading materials and textures from a library shared with other maps.
keepFlags Use these to define whether or not you wish to guarantee that all loaded resources are kept (default to KEEP_ALL). KEEP_USED is useful when you are loading from a shared library containing more resources than you actually need (a world file loading from a shared library of textures for example). This argument is only used in conjunction with Collections, and overrides the value of useProxyTextures in that case.

Definition at line 431 of file loader.h.

virtual bool iLoader::LoadMap ( iDocumentNode world_node,
bool  clearEngine = true,
iCollection collection = 0,
bool  curRegOnly = true,
bool  checkDupes = false,
iStreamSource ssource = 0,
iMissingLoaderData missingdata = 0,
uint  keepFlags = KEEP_ALL 
) [pure virtual]

Load a map from the given 'world' node.

If 'clearEngine' is true then the current contents of the engine will be deleted before loading. If 'region' is not 0 then portals will only connect to the sectors in that region, things will only use thing templates defined in that region and meshes will only use mesh factories defined in that region. If the region is not 0 and curRegOnly is true then objects (materials, factories, ...) will only be found in the given region.

Parameters:
world_node is the 'world' node from an XML document.
clearEngine is true by default which means that the previous contents of the engine is cleared (all objects/sectors/... are removed).
collection is 0 by default which means that all loaded objects are not added to any collection. If you give a region here then all loaded objects will be added to that region.
curRegOnly is true by default which means that it will only find materials/factories/... from current region if that is given.
checkDupes if true then materials, textures, and mesh factories will only be loaded if they don't already exist in the entire engine (ignoring regions). By default this is false because it is very legal for different world files to have different objects with the same name. Only use checkDupes == true if you know that your objects have unique names accross all world files.
ssource is an optional stream source for faster loading.
missingdata is an optional callback in case data is missing. The application can then provide that missing data in some other way.
Set useProxyTextures to true if you're loading materials and textures from a library shared with other maps.
keepFlags Use these to define whether or not you wish to guarantee that all loaded resources are kept (default to KEEP_ALL). KEEP_USED is useful when you are loading from a shared library containing more resources than you actually need (a world file loading from a shared library of textures for example). This argument is only used in conjunction with Collections, and overrides the value of useProxyTextures in that case.
virtual bool iLoader::LoadMapFile ( const char *  filename,
bool  clearEngine = true,
iCollection collection = 0,
bool  curRegOnly = true,
bool  checkDupes = false,
iStreamSource ssource = 0,
iMissingLoaderData missingdata = 0,
uint  keepFlags = KEEP_ALL 
) [pure virtual]

Load a map file.

If 'clearEngine' is true then the current contents of the engine will be deleted before loading. If 'region' is not 0 then portals will only connect to the sectors in that region, things will only use thing templates defined in that region and meshes will only use mesh factories defined in that region. If the region is not 0 and curRegOnly is true then objects (materials, factories, ...) will only be found in the given region.

Parameters:
filename is a VFS filename for the XML file.
clearEngine is true by default which means that the previous contents of the engine is cleared (all objects/sectors/... are removed).
collection is 0 by default which means that all loaded objects are added to the default collection. If you give a collection here then all loaded objects will be added to that collection (subject to keepFlags).
curRegOnly is true by default which means that it will only find materials/factories/... from current region if that is given.
checkDupes if true then materials, textures, and mesh factories will only be loaded if they don't already exist in the entire engine (ignoring regions). By default this is false because it is very legal for different world files to have different objects with the same name. Only use checkDupes == true if you know that your objects have unique names accross all world files.
ssource is an optional stream source for faster loading.
missingdata is an optional callback in case data is missing. The application can then provide that missing data in some other way.
Set useProxyTextures to true if you're loading materials and textures from a library shared with other maps.
keepFlags Use these to define whether or not you wish to guarantee that all loaded resources are kept (default to KEEP_ALL). KEEP_USED is useful when you are loading from a shared library containing more resources than you actually need (a world file loading from a shared library of textures for example). This argument is only used in conjunction with Collections, and overrides the value of useProxyTextures in that case.
virtual csPtr<iMeshWrapper> iLoader::LoadMeshObject ( const char *  fname,
iStreamSource ssource = 0 
) [pure virtual]

Load a mesh object from a file.

The mesh object is not automatically added to any sector.

Parameters:
fname is the VFS name of the file.
ssource is an optional stream source for faster loading.
virtual csPtr<iMeshFactoryWrapper> iLoader::LoadMeshObjectFactory ( const char *  fname,
iStreamSource ssource = 0 
) [pure virtual]

Load a Mesh Object Factory from a file.

Parameters:
fname is the VFS name of the file.
ssource is an optional stream source for faster loading.
virtual csRef<iShader> iLoader::LoadShader ( const char *  filename,
bool  registerShader = true 
) [pure virtual]

Load a shader from a file.

virtual csPtr<iSndSysStream> iLoader::LoadSoundStream ( const char *  fname,
int  mode3d 
) [pure virtual]

New Sound System: Load a sound file and create a stream from it.

Parameters:
fname is the VFS filename.
mode3d is one of CS_SND3D_DISABLE, CS_SND3D_RELATIVE, or CS_SND3D_ABSOLUTE.
virtual csPtr<iSndSysData> iLoader::LoadSoundSysData ( const char *  fname  )  [pure virtual]

New Sound System: Load a sound file and return an iSndSysData object.

virtual iSndSysWrapper* iLoader::LoadSoundWrapper ( const char *  name,
const char *  fname 
) [pure virtual]

New Sound System: Load a sound file, create sound data and create a wrapper object for it.

Parameters:
name of the sound.
fname is the VFS filename.
virtual iTextureWrapper* iLoader::LoadTexture ( const char *  Name,
const char *  FileName,
int  Flags,
iTextureManager tm,
bool  reg,
bool  create_material,
bool  free_image,
iRegion region 
) [pure virtual]

Load a texture as with LoadTexture() above and register it with the engine.

Parameters:
Name The name that the engine will use for the wrapper.
FileName VFS path to the image file to load.
Flags Accepts the flags described in ivideo/txtmgr.h. The texture manager determines the format, so choosing an alternate format doesn't make sense here. Instead you may choose an alternate texture manager.
tm Texture manager, used to determine the format the image is to be loaded in (defaults to CS_IMGFMT_TRUECOLOR if no texture manager is specified).
reg If true then the texture and material will be registered to the texture manager. Set 'register' to false if you plan on calling 'engine->Prepare()' later as that function will take care of registering too.
create_material If true then this function also creates a material for the texture.
free_image If true then after registration the loaded image will be removed immediatelly. This saves some memory. Set to false if you want to keep it. free_image is ignored if reg is false.
collection [optional] Collection to register the texture and material to.
virtual iTextureWrapper* iLoader::LoadTexture ( const char *  Name,
iDataBuffer buf,
int  Flags = CS_TEXTURE_3D,
iTextureManager tm = 0,
bool  reg = true,
bool  create_material = true,
bool  free_image = true 
) [pure virtual]

Load a texture as with LoadTexture() above and register it with the engine.

This version reads the image from a data buffer.

Parameters:
Name The name that the engine will use for the wrapper.
buf Buffer containing the image file data.
Flags Accepts the flags described in ivideo/txtmgr.h. The texture manager determines the format, so choosing an alternate format doesn't make sense here. Instead you may choose an alternate texture manager.
tm Texture manager, used to determine the format the image is to be loaded in (defaults to CS_IMGFMT_TRUECOLOR if no texture manager is specified).
reg if true then the texture and material will be registered to the texture manager. Set 'register' to false if you plan on calling 'engine->Prepare()' later as that function will take care of registering too.
create_material if true then this function also creates a material for the texture.
free_image if true then after registration the loaded image will be removed immediatelly. This saves some memory. Set to false if you want to keep it. free_image is ignored if reg is false.
virtual csPtr<iTextureHandle> iLoader::LoadTexture ( const char *  Filename,
int  Flags = CS_TEXTURE_3D,
iTextureManager tm = 0,
csRef< iImage > *  image = 0 
) [pure virtual]

Load an image as with LoadImage() and create a texture handle from it.

Parameters:
Filename VFS path to the image file to load.
Flags Accepts the flags described in ivideo/txtmgr.h. The texture manager determines the format, so choosing an alternate format doesn't make sense here. Instead you may choose an alternate texture manager.
tm Texture manager, used to determine the format the image is to be loaded in (defaults to CS_IMGFMT_TRUECOLOR if no texture manager is specified).
image Optionally returns a reference to the loaded image.
virtual iTextureWrapper* iLoader::LoadTexture ( const char *  Name,
const char *  FileName,
int  Flags = CS_TEXTURE_3D,
iTextureManager tm = 0,
bool  reg = true,
bool  create_material = true,
bool  free_image = true,
iCollection Collection = 0,
uint  keepFlags = KEEP_ALL 
) [pure virtual]

Load a texture as with LoadTexture() above and register it with the engine.

Parameters:
Name The name that the engine will use for the wrapper.
FileName VFS path to the image file to load.
Flags Accepts the flags described in ivideo/txtmgr.h. The texture manager determines the format, so choosing an alternate format doesn't make sense here. Instead you may choose an alternate texture manager.
tm Texture manager, used to determine the format the image is to be loaded in (defaults to CS_IMGFMT_TRUECOLOR if no texture manager is specified).
reg If true then the texture and material will be registered to the texture manager. Set 'register' to false if you plan on calling 'engine->Prepare()' later as that function will take care of registering too.
create_material If true then this function also creates a material for the texture.
free_image If true then after registration the loaded image will be removed immediatelly. This saves some memory. Set to false if you want to keep it. free_image is ignored if reg is false.
collection [optional] Collection to register the texture and material to.
iTextureWrapper* iLoader::LoadTexture ( const char *  Name,
const char *  FileName,
int  Flags,
iTextureManager tm,
bool  reg,
bool  create_material,
bool  free_image,
int  dummy 
) [inline]

Load a texture as with LoadTexture() above and register it with the engine.

Parameters:
Name The name that the engine will use for the wrapper.
FileName VFS path to the image file to load.
Flags Accepts the flags described in ivideo/txtmgr.h. The texture manager determines the format, so choosing an alternate format doesn't make sense here. Instead you may choose an alternate texture manager.
tm Texture manager, used to determine the format the image is to be loaded in (defaults to CS_IMGFMT_TRUECOLOR if no texture manager is specified).
reg If true then the texture and material will be registered to the texture manager. Set 'register' to false if you plan on calling 'engine->Prepare()' later as that function will take care of registering too.
create_material If true then this function also creates a material for the texture.
free_image If true then after registration the loaded image will be removed immediatelly. This saves some memory. Set to false if you want to keep it. free_image is ignored if reg is false.
collection [optional] Collection to register the texture and material to.

Definition at line 314 of file loader.h.

virtual csPtr<iTextureHandle> iLoader::LoadTexture ( iDataBuffer buf,
int  Flags = CS_TEXTURE_3D,
iTextureManager tm = 0,
csRef< iImage > *  image = 0 
) [pure virtual]

Load an image as with LoadImage() and create a texture handle from it.

This version reads the image from a data buffer.

Parameters:
buf Buffer containing the image file data.
Flags Accepts the flags described in ivideo/txtmgr.h. The texture manager determines the format, so choosing an alternate format doesn't make sense here. Instead you may choose an alternate texture manager.
tm Texture manager, used to determine the format the image is to be loaded in (defaults to CS_IMGFMT_TRUECOLOR if no texture manager is specified).
image Optionally returns a reference to the loaded image.
virtual void iLoader::SetAutoRegions ( bool  autoRegions  )  [pure virtual]

Set whether to load each file into a separate region.

Deprecated:
Deprecated in 1.3. Use the iCollections instead.

The documentation for this struct was generated from the following file:

Generated for Crystal Space 1.4.1 by doxygen 1.7.1