CrystalSpace

Public API Reference

iEngine Struct Reference
[Crystal Space 3D Engine]

This interface is the main interface to the 3D engine. More...

#include <iengine/engine.h>

Inheritance diagram for iEngine:

Inheritance graph
[legend]

List of all members.

Public Member Functions

virtual iObjectQueryObject ()=0
 Get the iObject for the engine.
Sector handling
virtual void AddEngineFrameCallback (iEngineFrameCallback *cb)=0
 Add a frame callback.
virtual void AddEngineSectorCallback (iEngineSectorCallback *cb)=0
 Add a sector callback.
virtual iSectorCreateSector (const char *name)=0
 Create a empty sector with given name.
virtual iSectorFindSector (const char *name, iRegion *region=0)=0
 Find the given sector.
virtual csPtr
< iSectorIterator
GetNearbySectors (iSector *sector, const csBox3 &box)=0
 This routine returns an iterator to iterate over all nearby sectors.
virtual csPtr
< iSectorIterator
GetNearbySectors (iSector *sector, const csVector3 &pos, float radius)=0
 This routine returns an iterator to iterate over all nearby sectors.
virtual iSectorListGetSectors ()=0
 Get the list of sectors.
virtual void RemoveEngineFrameCallback (iEngineFrameCallback *cb)=0
 Remove a frame callback.
virtual void RemoveEngineSectorCallback (iEngineSectorCallback *cb)=0
 Remove a sector callback.
Mesh handling
virtual void AddMeshAndChildren (iMeshWrapper *mesh)=0
 Convenience function to add a mesh and all children of that mesh to the engine.
virtual csPtr
< iMeshWrapper
CreateMeshWrapper (const char *name)=0
 Create an uninitialized mesh wrapper Assign to a csRef.
virtual csPtr
< iMeshWrapper
CreateMeshWrapper (const char *classid, const char *name, iSector *sector=0, const csVector3 &pos=csVector3(0, 0, 0))=0
 Create a mesh wrapper from a class id.
virtual csPtr
< iMeshWrapper
CreateMeshWrapper (iMeshObject *meshobj, const char *name, iSector *sector=0, const csVector3 &pos=csVector3(0, 0, 0))=0
 Create a mesh wrapper for an existing mesh object.
virtual csPtr
< iMeshWrapper
CreateMeshWrapper (iMeshFactoryWrapper *factory, const char *name, iSector *sector=0, const csVector3 &pos=csVector3(0, 0, 0))=0
 Convenience function to create a mesh object for a given factory.
virtual csPtr
< iMeshWrapper
CreateSectorWallsMesh (iSector *sector, const char *name)=0
 Convenience function to create the thing containing the convex outline of a sector.
virtual csPtr
< iMeshWrapper
CreateThingMesh (iSector *sector, const char *name)=0
 Convenience function to create a thing mesh in a sector.
virtual iMeshWrapperFindMeshObject (const char *name, iRegion *region=0)=0
 Find the given mesh object.
virtual iMeshListGetMeshes ()=0
 Get the list of meshes.
virtual csPtr
< iMeshWrapperIterator
GetNearbyMeshes (iSector *sector, const csVector3 &start, const csVector3 &end, bool crossPortals=true)=0
 This routine returns an iterator to iterate over all meshes that intersect with a beam.
virtual csPtr
< iMeshWrapperIterator
GetNearbyMeshes (iSector *sector, const csBox3 &box, bool crossPortals=true)=0
 This routine returns an iterator to iterate over all meshes that are in a box.
virtual csPtr
< iMeshWrapperIterator
GetNearbyMeshes (iSector *sector, const csVector3 &pos, float radius, bool crossPortals=true)=0
 This routine returns an iterator to iterate over all meshes that are within a radius of a given position.
virtual csPtr
< iMeshWrapper
LoadMeshWrapper (const char *name, const char *loaderClassId, iDataBuffer *input, iSector *sector, const csVector3 &pos)=0
 Convenience function to load a mesh object from a given loader plugin.
virtual void WantToDie (iMeshWrapper *mesh)=0
 Sometimes a mesh wants to destruct itself (for example a particle system that has only limited lifetime).
Render priority functions
virtual void ClearRenderPriorities ()=0
 Clear all render priorities.
virtual long GetAlphaRenderPriority ()=0
 Get the render priority for alpha objects (attached to 'alpha' name).
virtual long GetObjectRenderPriority ()=0
 Get the render priority for general objects (attached to 'object' name).
virtual long GetPortalRenderPriority ()=0
 Get the render priority for portal objects (attached to 'portal' name).
virtual long GetRenderPriority (const char *name) const =0
 Get a render priority by name.
virtual int GetRenderPriorityCount () const =0
 Get the number of render priorities.
virtual const char * GetRenderPriorityName (long priority) const =0
 Get the name of the render priority or 0 if none existant.
virtual
csRenderPrioritySorting 
GetRenderPrioritySorting (long priority) const =0
 Get the render priority sorting flag.
virtual
csRenderPrioritySorting 
GetRenderPrioritySorting (const char *name) const =0
 Get the render priority sorting flag.
virtual long GetSkyRenderPriority ()=0
 Get the render priority for sky objects (attached to 'sky' name).
virtual long GetWallRenderPriority ()=0
 Get the render priority for wall objects (attached to 'wall' name).
virtual void RegisterRenderPriority (const char *name, long priority, csRenderPrioritySorting rendsort=CS_RENDPRI_SORT_NONE)=0
 Register a new render priority.
Material handling
virtual csPtr
< iMaterial
CreateBaseMaterial (iTextureWrapper *txt)=0
 Create a base material that can be used to give to the texture manager.
virtual
iMaterialWrapper
CreateMaterial (const char *name, iTextureWrapper *texture)=0
 Register a material to be loaded during Prepare().
virtual
iMaterialWrapper
FindMaterial (const char *name, iRegion *region=0)=0
 Find the given material.
virtual iMaterialListGetMaterialList () const =0
 Get the list of all materials.
Texture handling
virtual iTextureWrapperCreateBlackTexture (const char *name, int w, int h, csColor *transp, int flags)=0
 Create a black texture.
virtual iTextureWrapperCreateTexture (const char *name, const char *fileName, csColor *transp, int flags)=0
 Create a texture from a file.
virtual iTextureWrapperFindTexture (const char *name, iRegion *region=0)=0
 Find the given texture.
virtual int GetTextureFormat () const =0
 Query the format to load textures (usually this depends on texture manager).
virtual iTextureListGetTextureList () const =0
 Get the list of all textures.
Camera handling
virtual csPtr< iCameraCreateCamera ()=0
 Create a new camera.
virtual iCameraPositionFindCameraPosition (const char *name, iRegion *region=0)=0
 Find the given camera position.
virtual
iCameraPositionList
GetCameraPositions ()=0
 Get the list of camera positions.
Other
virtual csPtr
< iFrustumView
CreateFrustumView ()=0
 Create a iFrustumView instance that you can give to iVisibilityCuller->CastShadows().
virtual csPtr
< iObjectWatcher
CreateObjectWatcher ()=0
 Create an object watcher instance that you can use to watch other objects.
virtual void DelayedRemoveObject (csTicks delay, iBase *object)=0
 This function can be used to remove an object after a specific amount of time.
virtual void DeleteAll ()=0
 Delete everything in the engine.
virtual csPtr
< iObjectIterator
GetNearbyObjects (iSector *sector, const csVector3 &pos, float radius, bool crossPortals=true)=0
 This routine returns an iterator to iterate over all objects that are within a radius of a given position.
virtual
iSharedVariableList
GetVariableList () const =0
 Get the list of all shared variables.
virtual csPtr
< iMeshWrapperIterator
GetVisibleMeshes (iSector *sector, const csFrustum &frustum)=0
 This routine returns an iterator to iterate over all meshes that are potentially visible as seen from a given position.
virtual csPtr
< iMeshWrapperIterator
GetVisibleMeshes (iSector *sector, const csVector3 &pos)=0
 This routine returns an iterator to iterate over all meshes that are potentially visible as seen from a given position.
virtual csPtr
< iObjectIterator
GetVisibleObjects (iSector *sector, const csFrustum &frustum)=0
 This routine returns an iterator to iterate over all objects that are potentially visible as seen from a given position.
virtual csPtr
< iObjectIterator
GetVisibleObjects (iSector *sector, const csVector3 &pos)=0
 This routine returns an iterator to iterate over all objects that are potentially visible as seen from a given position.
virtual void RemoveDelayedRemoves (bool remove=false)=0
 Clear all delayed removals.
virtual bool RemoveObject (iBase *object)=0
 Convenience function to 'remove' a CS object from the engine.
virtual void ResetWorldSpecificSettings ()=0
 Reset a subset of flags/settings (which may differ from one world/map to another) to its defaults.
Light handling
virtual csPtr< iLightCreateLight (const char *name, const csVector3 &pos, float radius, const csColor &color, csLightDynamicType dyntype=CS_LIGHT_DYNAMICTYPE_STATIC)=0
 Create a static/pseudo-dynamic light.
virtual iLightFindLight (const char *Name, bool RegionOnly=false) const =0
 Find a static/pseudo-dynamic light by name.
virtual iLightFindLightID (const char *light_id) const =0
 Find a static/pseudo-dynamic light by id.
virtual void GetAmbientLight (csColor &) const =0
 Return the amount of ambient light.
virtual void GetDefaultAmbientLight (csColor &c) const =0
 Return the default amount of ambient light.
virtual csPtr
< iLightIterator
GetLightIterator (iRegion *region=0)=0
 Create an iterator to iterate over all static lights of the engine.
virtual int GetNearbyLights (iSector *sector, const csBox3 &box, iLight **lights, int max_num_lights)=0
 This routine returns all lights which might affect an object with some bounding box.
virtual int GetNearbyLights (iSector *sector, const csVector3 &pos, iLight **lights, int max_num_lights)=0
 This routine returns all lights which might affect an object at some position.
virtual void RemoveLight (iLight *light)=0
 Remove a light and update all lightmaps.
virtual void SetAmbientLight (const csColor &)=0
 Set the amount of ambient light.
Saving/loading
virtual csPtr
< iLoaderContext
CreateLoaderContext (iRegion *region=0, bool curRegOnly=true)=0
 Create a loader context that you can give to loader plugins.
virtual bool GetSaveableFlag ()=0
 Get whether saving should be possible (default OFF).
virtual void SetSaveableFlag (bool enable)=0
 Set whether saving should be possible (default OFF).
Mesh factory handling
virtual csPtr
< iMeshFactoryWrapper
CreateMeshFactory (const char *name)=0
 Create an uninitialized mesh factory wrapper Assign to a csRef.
virtual csPtr
< iMeshFactoryWrapper
CreateMeshFactory (iMeshObjectFactory *factory, const char *name)=0
 Create a mesh factory wrapper for an existing mesh factory Assign to a csRef.
virtual csPtr
< iMeshFactoryWrapper
CreateMeshFactory (const char *classId, const char *name)=0
 Convenience function to create a mesh factory from a given type.
virtual
iMeshFactoryWrapper
FindMeshFactory (const char *name, iRegion *region=0)=0
 Find the given mesh factory.
virtual
iMeshFactoryList
GetMeshFactories ()=0
 Get the list of mesh factories.
virtual csPtr
< iMeshFactoryWrapper
LoadMeshFactory (const char *name, const char *loaderClassId, iDataBuffer *input)=0
 Convenience function to load a mesh factory from a given loader plugin.
Portal handling
virtual csPtr
< iMeshWrapper
CreatePortal (const char *name, iSector *sourceSector, const csVector3 &pos, iSector *destSector, csVector3 *vertices, int num_vertices, iPortal *&portal)=0
 Convenience function to create a portal from one sector to another.
virtual csPtr
< iMeshWrapper
CreatePortal (const char *name, iMeshWrapper *parentMesh, iSector *destSector, csVector3 *vertices, int num_vertices, iPortal *&portal)=0
 Convenience function to create a portal from one sector to another and make this portal a child mesh of another mesh.
virtual csPtr
< iMeshWrapper
CreatePortalContainer (const char *name, iSector *sector=0, const csVector3 &pos=csVector3(0, 0, 0))=0
 Create an empty portal container in some sector.
Region handling
virtual iRegionCreateRegion (const char *name)=0
 Create a new region and add it to the region list.
virtual iRegionListGetRegions ()=0
 Get the list of all regions.
Drawing related
virtual void Draw (iCamera *c, iClipper2D *clipper, iMeshWrapper *mesh=0)=0
 Draw the 3D world given a camera and a clipper.
virtual int GetBeginDrawFlags () const =0
 Get the required flags for 3D->BeginDraw() which should be called from the application.
virtual bool GetClearScreen () const =0
 Get the value of the clear screen flag set with SetClearScreen().
virtual bool GetClearZBuf () const =0
 Get the value of the clear Z-buffer flag set with SetClearZBuf().
virtual iTextureHandleGetContext () const =0
 Return the current drawing context.
virtual iRenderLoopGetCurrentDefaultRenderloop ()=0
 Returns the current render loop.
virtual uint GetCurrentFrameNumber () const =0
 Get the current framenumber.
virtual bool GetDefaultClearScreen () const =0
 Get default clear screen flag.
virtual bool GetDefaultClearZBuf () const =0
 Get default clear z-buffer flag.
virtual
iRenderLoopManager
GetRenderLoopManager ()=0
 Retrieve the render loop manager.
virtual iRenderViewGetTopLevelClipper () const =0
 Get the top-level clipper.
virtual void PrecacheDraw (iRegion *region=0)=0
 This function precaches all meshes by calling GetRenderMeshes() on them.
virtual void SetClearScreen (bool yesno)=0
 Require that the screen is cleared every frame.
virtual void SetClearZBuf (bool yesno)=0
 Require that the Z-buffer is cleared every frame.
virtual void SetContext (iTextureHandle *ctxt)=0
 Set the drawing context.
virtual bool SetCurrentDefaultRenderloop (iRenderLoop *loop)=0
 Set the current render loop.
Preparation and relighting methods
virtual void ForceRelight (iLight *light, iRegion *region=0)=0
 Force a relight for the given light.
virtual void ForceRelight (iRegion *region=0, iProgressMeter *meter=0)=0
 Force a relight of all lighting.
virtual iCacheManagerGetCacheManager ()=0
 Get the cache manager that the engine is currently using.
virtual void GetDefaultMaxLightmapSize (int &w, int &h)=0
 Retrieve default maximum lightmap size.
virtual int GetLightingCacheMode ()=0
 Get the mode for the lighting cache.
virtual int GetMaxLightmapAspectRatio () const =0
 Get the maximum aspect ratio for lightmaps.
virtual void GetMaxLightmapSize (int &w, int &h)=0
 Retrieve maximum lightmap size.
virtual bool Prepare (iProgressMeter *meter=0)=0
 Prepare the engine.
virtual void PrepareMeshes ()=0
 Calls UpdateMove for all meshes to initialise bounding boxes.
virtual void PrepareTextures ()=0
 Prepare the textures.
virtual void SetCacheManager (iCacheManager *cache_mgr)=0
 Set the cache manager that the engine will use.
virtual void SetLightingCacheMode (int mode)=0
 Set the mode for the lighting cache (combination of CS_ENGINE_CACHE_???).
virtual void SetMaxLightmapSize (int w, int h)=0
 Set the maximum lightmap dimensions.
virtual void SetVFSCacheManager (const char *vfspath=0)=0
 Set the cache manager to the default VFS based cache manager.
virtual void ShineLights (iRegion *region=0, iProgressMeter *meter=0)=0
 Calculate all lighting information.


Detailed Description

This interface is the main interface to the 3D engine.

The engine is responsible for creating new engine-specific objects such as sectors, mesh objects, mesh object factories, lights, and so on.

Main creators of instances implementing this interface:

Main ways to get pointers to this interface:

Main users of this interface:

Definition at line 174 of file engine.h.


Member Function Documentation

virtual void iEngine::AddEngineFrameCallback ( iEngineFrameCallback cb  )  [pure virtual]

Add a frame callback.

This will call IncRef() on the callback So make sure you call DecRef() to release your own reference.

virtual void iEngine::AddEngineSectorCallback ( iEngineSectorCallback cb  )  [pure virtual]

Add a sector callback.

This will call IncRef() on the callback So make sure you call DecRef() to release your own reference.

virtual void iEngine::AddMeshAndChildren ( iMeshWrapper mesh  )  [pure virtual]

Convenience function to add a mesh and all children of that mesh to the engine.

virtual void iEngine::ClearRenderPriorities (  )  [pure virtual]

Clear all render priorities.

virtual csPtr<iMaterial> iEngine::CreateBaseMaterial ( iTextureWrapper txt  )  [pure virtual]

Create a base material that can be used to give to the texture manager.

Assign to a csRef.

Parameters:
txt The texture map this material will use. Note that this can be 0 in which case a base material without texture will be created.
Note:
You will need to call iMaterialWrapper::Register() and iMaterialWrapper::GetMaterialHandler()->Prepare() on you new material if you load the material after iEngine::Prepare() has been called.

virtual iTextureWrapper* iEngine::CreateBlackTexture ( const char *  name,
int  w,
int  h,
csColor transp,
int  flags 
) [pure virtual]

Create a black texture.

This is mostly useful for procedural textures.

Parameters:
name The name to use for this texture in the engine
w the texture width (must be a power of 2, eg 64, 128, 256, 512...)
h the texture height (must be a power of 2, eg 64, 128, 256, 512...)
transp pixels in the image with this key color will be considered transparent instead of being drawn
flags see CreateTexture()
See also:
CreateTexture() note about registering textures.

virtual csPtr<iCamera> iEngine::CreateCamera (  )  [pure virtual]

Create a new camera.

Assign to a csRef.

virtual csPtr<iFrustumView> iEngine::CreateFrustumView (  )  [pure virtual]

Create a iFrustumView instance that you can give to iVisibilityCuller->CastShadows().

You can initialize that instance so that your own function is called for every object that is being visited.

virtual csPtr<iLight> iEngine::CreateLight ( const char *  name,
const csVector3 pos,
float  radius,
const csColor color,
csLightDynamicType  dyntype = CS_LIGHT_DYNAMICTYPE_STATIC 
) [pure virtual]

Create a static/pseudo-dynamic light.

Assign to a csRef.

Parameters:
name the engine name for this light (may be 0)
pos the position of this light in world coordinates
radius the maximum distance at which this light will affect objects
color the color of this light (also affects light intensity)
dyntype is the type of the light. This can be CS_LIGHT_DYNAMICTYPE_DYNAMIC, CS_LIGHT_DYNAMICTYPE_PSEUDO, or CS_LIGHT_DYNAMICTYPE_STATIC. Note that after creating a light you must add it to a sector by calling sector->GetLights ()->Add (light); If the light is dynamic you also must call Setup() to calculate lighting. Otherwise you must use engine->ForceRelight() if you create a light after calling engine->Prepare(). Otherwise you can let engine->Prepare() do it.
Note! If you are using a system with hardware accelerated lighting (i.e. no lightmaps) then the discussion above is not relevant.

virtual csPtr<iLoaderContext> iEngine::CreateLoaderContext ( iRegion region = 0,
bool  curRegOnly = true 
) [pure virtual]

Create a loader context that you can give to loader plugins.

It will basically allow loader plugins to find materials.

Parameters:
region optional loader region
curRegOnly if region is valid and and curRegOnly is true then only that region will be searched. Assign to a csRef.

virtual iMaterialWrapper* iEngine::CreateMaterial ( const char *  name,
iTextureWrapper texture 
) [pure virtual]

Register a material to be loaded during Prepare().

Parameters:
name engine name for this material
texture texture to use for this material

virtual csPtr<iMeshFactoryWrapper> iEngine::CreateMeshFactory ( const char *  name  )  [pure virtual]

Create an uninitialized mesh factory wrapper Assign to a csRef.

Parameters:
name the engine name for the factory wrapper

virtual csPtr<iMeshFactoryWrapper> iEngine::CreateMeshFactory ( iMeshObjectFactory factory,
const char *  name 
) [pure virtual]

Create a mesh factory wrapper for an existing mesh factory Assign to a csRef.

Parameters:
factory the mesh factory to be wrapped, the engine doesn't "know" about a mesh factory until associated with a FactoryWrapper
name the engine name for the factory wrapper

virtual csPtr<iMeshFactoryWrapper> iEngine::CreateMeshFactory ( const char *  classId,
const char *  name 
) [pure virtual]

Convenience function to create a mesh factory from a given type.

Parameters:
classId the SCF name of the plugin (like 'crystalspace.mesh.object.ball'). The type plugin will only be loaded if needed.
name The factory will be registered with the engine under the given name. If there is already a factory with that name no new factory will be created but the found one is returned instead. If the name is 0 then no name will be set and no check will happen if the factory already exists.
Returns:
0 on failure; you must assign the result to a csRef or use DecRef().

virtual csPtr<iMeshWrapper> iEngine::CreateMeshWrapper ( const char *  name  )  [pure virtual]

Create an uninitialized mesh wrapper Assign to a csRef.

virtual csPtr<iMeshWrapper> iEngine::CreateMeshWrapper ( const char *  classid,
const char *  name,
iSector sector = 0,
const csVector3 pos = csVector3(0, 0, 0) 
) [pure virtual]

Create a mesh wrapper from a class id.

This function will first make a factory from the plugin and then see if that factory itself implements iMeshObject too. This means this function is useful to create thing mesh objects (which are both factory and object at the same time). If that fails this function will call NewInstance() on the factory and return that object then.

Parameters:
classid The SCF name of the plugin (like 'crystalspace.mesh.object.ball'). The type plugin will only be loaded if needed.
name The engine name for the mesh wrapper; may be null. Different mesh objects can have the same name (in contrast with factory objects).
sector the sector to initially place this mesh in If 'sector' is 0 then the mesh object will not be set to a position.
pos the position in the sector
Returns:
The meshwrapper on success (assign to a csRef), or 0 on failure.

virtual csPtr<iMeshWrapper> iEngine::CreateMeshWrapper ( iMeshObject meshobj,
const char *  name,
iSector sector = 0,
const csVector3 pos = csVector3(0, 0, 0) 
) [pure virtual]

Create a mesh wrapper for an existing mesh object.

Parameters:
meshobj the mesh object
name The engine name for the mesh wrapper; may be null. Different mesh objects can have the same name (in contrast with factory objects).
sector the sector to initially place this mesh in If 'sector' is 0 then the mesh object will not be set to a position.
pos the position in the sector
Returns:
The meshwrapper on success (assign to a csRef), or 0 on failure.

virtual csPtr<iMeshWrapper> iEngine::CreateMeshWrapper ( iMeshFactoryWrapper factory,
const char *  name,
iSector sector = 0,
const csVector3 pos = csVector3(0, 0, 0) 
) [pure virtual]

Convenience function to create a mesh object for a given factory.

Parameters:
factory the factory that will produce this mesh
name The engine name for the mesh wrapper; may be null. Different mesh objects can have the same name (in contrast with factory objects).
sector the sector to initially place this mesh in If 'sector' is 0 then the mesh object will not be set to a position.
pos the position in the sector
Returns:
The meshwrapper on success (assign to a csRef), or 0 on failure.

virtual csPtr<iObjectWatcher> iEngine::CreateObjectWatcher (  )  [pure virtual]

Create an object watcher instance that you can use to watch other objects.

The engine will not keep a reference to this object.

virtual csPtr<iMeshWrapper> iEngine::CreatePortal ( const char *  name,
iSector sourceSector,
const csVector3 pos,
iSector destSector,
csVector3 vertices,
int  num_vertices,
iPortal *&  portal 
) [pure virtual]

Convenience function to create a portal from one sector to another.

Use SCF_QUERY_INTERFACE with iPortalContainer on the returned mesh for more control over the portal(s) in the portal object.

Parameters:
name is the name of the portal container mesh to create the portal in. If the sourceSector already has a mesh with that name then that will be used. If there is already a mesh with that name but it is not a portal container then a new mesh will be created.
sourceSector is the sector where the portal container will be placed.
pos the position inside that sector.
destSector the sector where the single portal that is created inside the portal object will point too.
vertices list of vertices comprising the portal.
num_vertices number of elements in 'vertices'.
portal return value for the created portal.
Returns:
The meshwrapper on success (assign to a csRef), or 0 on failure.

virtual csPtr<iMeshWrapper> iEngine::CreatePortal ( const char *  name,
iMeshWrapper parentMesh,
iSector destSector,
csVector3 vertices,
int  num_vertices,
iPortal *&  portal 
) [pure virtual]

Convenience function to create a portal from one sector to another and make this portal a child mesh of another mesh.

Use SCF_QUERY_INTERFACE with iPortalContainer on the returned mesh for more control over the portal(s) in the portal object.

Parameters:
name is the name of the portal container mesh to create the portal in. If the parentMesh already has a mesh with that name then that will be used. If there is already a mesh with that name but it is not a portal container then a new mesh will be created.
parentMesh is the mesh where the portal container will be placed as a child.
destSector is the sector where the single portal that is created inside the portal object will point too.
vertices list of vertices comprising the portal.
num_vertices number of elements in 'vertices'.
portal is a return value for the created portal.
Returns:
The meshwrapper on success (assign to a csRef), or 0 on failure.

virtual csPtr<iMeshWrapper> iEngine::CreatePortalContainer ( const char *  name,
iSector sector = 0,
const csVector3 pos = csVector3(0, 0, 0) 
) [pure virtual]

Create an empty portal container in some sector.

Use this portal container to create portals to other sectors. Use SCF_QUERY_INTERFACE with iPortalContainer on the mesh object inside the returned mesh to control the portals.

Parameters:
name of the portal mesh.
sector is the location of the portal object and not the sector the portals will point too. If not given then the portal container is not put in any mesh.
pos is an optional position inside the sector (if given).
Returns:
The meshwrapper on success (assign to a csRef), or 0 on failure.

virtual iRegion* iEngine::CreateRegion ( const char *  name  )  [pure virtual]

Create a new region and add it to the region list.

If the region already exists then this function will just return the pointer to that region.

Parameters:
name the engine name for the region
Remarks:
Can be removed with RemoveObject().

virtual iSector* iEngine::CreateSector ( const char *  name  )  [pure virtual]

Create a empty sector with given name.

Parameters:
name the sector name

virtual csPtr<iMeshWrapper> iEngine::CreateSectorWallsMesh ( iSector sector,
const char *  name 
) [pure virtual]

Convenience function to create the thing containing the convex outline of a sector.

The thing will be empty but it will have CS_ZBUF_FILL set (so that the Z-buffer will be filled by the polygons of this object) and have 'wall' as render priority. This version creates a mesh wrapper. Assign to a csRef.

Parameters:
sector the sector to add walls to
name the engine name of the walls mesh that will be created

virtual iTextureWrapper* iEngine::CreateTexture ( const char *  name,
const char *  fileName,
csColor transp,
int  flags 
) [pure virtual]

Create a texture from a file.

Parameters:
name The name to use for this texture in the engine
fileName the filename (on the VFS!) of the texture to load
transp pixels in the image with this key color will be considered transparent instead of being drawn
flags One or more texturing flags OR'd together, flag include
  • CS_TEXTURE_2D image will be used only for 2D drawing
  • CS_TEXTURE_3D image will be textured onto 3D polygon (this is almost always the flag you want)
  • CS_TEXTURE_NOMIPMAPS texture will not be mipmapped before use
Note:
You will need to call iTextureWrapper::Register() on you new texture if you load the texture after iEngine::Prepare() has been called.

virtual csPtr<iMeshWrapper> iEngine::CreateThingMesh ( iSector sector,
const char *  name 
) [pure virtual]

Convenience function to create a thing mesh in a sector.

This mesh will have CS_ZBUF_USE set (use Z-buffer fully) and have 'object' as render priority. This means this function is useful for general objects. Assign to a csRef.

Parameters:
sector the sector to add the object to
name the engine name of the mesh that will be created

virtual void iEngine::DelayedRemoveObject ( csTicks  delay,
iBase object 
) [pure virtual]

This function can be used to remove an object after a specific amount of time.

This is mostly useful for particle systems (like explosions) that you want to live for a specific time before they are automatically cleaned up by the engine. Note that calling this function will cause the engine to keep an additional reference until it is time to delete the object.

virtual void iEngine::DeleteAll (  )  [pure virtual]

Delete everything in the engine.

virtual void iEngine::Draw ( iCamera c,
iClipper2D clipper,
iMeshWrapper mesh = 0 
) [pure virtual]

Draw the 3D world given a camera and a clipper.

Note that in order to be able to draw using the given 3D driver all textures must have been registered to that driver (using Prepare()). Note that you need to call Prepare() again if you switch to another 3D driver.

If a mesh is given then only that single mesh is rendered. Note that in that case the mesh will only be rendered if it is in the same sector as the camera!

virtual iCameraPosition* iEngine::FindCameraPosition ( const char *  name,
iRegion region = 0 
) [pure virtual]

Find the given camera position.

The name can be a normal name. In that case this function will look in all regions except if region is not 0 in which case it will only look in that region. If the name is specified as 'regionname/objectname' then this function will only look in the specified region and return 0 if that region doesn't contain the object or the region doesn't exist. In this case the region parameter is ignored.

Parameters:
name the engine name of the desired camera position
region if specified, search only this region (also see note above)

virtual iLight* iEngine::FindLight ( const char *  Name,
bool  RegionOnly = false 
) const [pure virtual]

Find a static/pseudo-dynamic light by name.

Parameters:
Name the engine name of the desired light
RegionOnly (parameter presently unused)

virtual iLight* iEngine::FindLightID ( const char *  light_id  )  const [pure virtual]

Find a static/pseudo-dynamic light by id.

Parameters:
light_id a 16-byte MD5 checksum for the light.

virtual iMaterialWrapper* iEngine::FindMaterial ( const char *  name,
iRegion region = 0 
) [pure virtual]

Find the given material.

The name can be a normal name. In that case this function will look in all regions except if region is not 0 in which case it will only look in that region. If the name is specified as 'regionname/objectname' then this function will only look in the specified region and return 0 if that region doesn't contain the object or the region doesn't exist. In this case the region parameter is ignored.

Parameters:
name the engine name of the desired material
region if specified, search only this region (also see note above)

virtual iMeshFactoryWrapper* iEngine::FindMeshFactory ( const char *  name,
iRegion region = 0 
) [pure virtual]

Find the given mesh factory.

The name can be a normal name. In that case this function will look in all regions except if region is not 0 in which case it will only look in that region. If the name is specified as 'regionname/objectname' then this function will only look in the specified region and return 0 if that region doesn't contain the object or the region doesn't exist. In this case the region parameter is ignored.

Parameters:
name the engine name of the desired mesh factory
region if specified, search only this region (also see note above)

virtual iMeshWrapper* iEngine::FindMeshObject ( const char *  name,
iRegion region = 0 
) [pure virtual]

Find the given mesh object.

The name can be a normal name. In that case this function will look in all regions except if region is not 0 in which case it will only look in that region. If the name is specified as 'regionname/objectname' then this function will only look in the specified region and return 0 if that region doesn't contain the object or the region doesn't exist. In this case the region parameter is ignored.

Parameters:
name the engine name of the desired mesh
region if specified, search only this region (also see note above)

virtual iSector* iEngine::FindSector ( const char *  name,
iRegion region = 0 
) [pure virtual]

Find the given sector.

The name can be a normal name. In that case this function will look in all regions except if region is not 0 in which case it will only look in that region. If the name is specified as 'regionname/objectname' then this function will only look in the specified region and return 0 if that region doesn't contain the object or the region doesn't exist. In this case the region parameter is ignored.

Parameters:
name the engine name of the desired sector
region if specified, search only this region (also see note above)

virtual iTextureWrapper* iEngine::FindTexture ( const char *  name,
iRegion region = 0 
) [pure virtual]

Find the given texture.

The name can be a normal name. In that case this function will look in all regions except if region is not 0 in which case it will only look in that region. If the name is specified as 'regionname/objectname' then this function will only look in the specified region and return 0 if that region doesn't contain the object or the region doesn't exist. In this case the region parameter is ignored.

Parameters:
name the engine name of the desired texture
region if specified, search only this region (also see note above)

virtual void iEngine::ForceRelight ( iLight light,
iRegion region = 0 
) [pure virtual]

Force a relight for the given light.

This is useful to update the lightmaps after a static or pseudo-dynamic light has been added (don't use this for dynamic lights). If there are a lot of objects this function can be slow. The optional region can be given to limit calculation to objects in the region.

The current flags set with SetLightingCacheMode() controls if the lightmaps will be cached or not.

Parameters:
light The newly added light to shine
region If supplied, only affect objects in this region

virtual void iEngine::ForceRelight ( iRegion region = 0,
iProgressMeter meter = 0 
) [pure virtual]

Force a relight of all lighting.

It is better to call this instead of calling engine->Prepare() again as engine->Prepare() will also do other stuff (like registering textures). Warning! This function can be very slow (depending on the number of lights and objects in the world). The optional region can be given to limit calculation to objects in the region.

The current flags set with SetLightingCacheMode() controls if the lightmaps will be cached or not.

Parameters:
region only relight objects in this region (will relight every object in the engine by default)
meter If supplied, the meter object will be called back periodically to report the progress of engine lighting calculation.

virtual long iEngine::GetAlphaRenderPriority (  )  [pure virtual]

Get the render priority for alpha objects (attached to 'alpha' name).

virtual void iEngine::GetAmbientLight ( csColor  )  const [pure virtual]

Return the amount of ambient light.

virtual int iEngine::GetBeginDrawFlags (  )  const [pure virtual]

Get the required flags for 3D->BeginDraw() which should be called from the application.

These flags must be or-ed with optional other flags that the application might be interested in. Use SetClearZBuf() to let this function return that the Z-buffer must be cleared.

virtual iCacheManager* iEngine::GetCacheManager (  )  [pure virtual]

Get the cache manager that the engine is currently using.

virtual iCameraPositionList* iEngine::GetCameraPositions (  )  [pure virtual]

Get the list of camera positions.

virtual bool iEngine::GetClearScreen (  )  const [pure virtual]

Get the value of the clear screen flag set with SetClearScreen().

virtual bool iEngine::GetClearZBuf (  )  const [pure virtual]

Get the value of the clear Z-buffer flag set with SetClearZBuf().

virtual iTextureHandle* iEngine::GetContext (  )  const [pure virtual]

Return the current drawing context.

virtual iRenderLoop* iEngine::GetCurrentDefaultRenderloop (  )  [pure virtual]

Returns the current render loop.

Remarks:
This will the loop that is set to be the current default with SetCurrentDefaultRenderloop(). This doesn't have to be the engine's default render loop (note the difference between the "current" and "default" render loop - former one is the loop used currently for drawing, latter one is a default loop created at engine initialization time.) To retrieve the default loop, use

virtual uint iEngine::GetCurrentFrameNumber (  )  const [pure virtual]

Get the current framenumber.

This should be incremented once every Draw

virtual void iEngine::GetDefaultAmbientLight ( csColor c  )  const [pure virtual]

Return the default amount of ambient light.

virtual bool iEngine::GetDefaultClearScreen (  )  const [pure virtual]

Get default clear screen flag.

virtual bool iEngine::GetDefaultClearZBuf (  )  const [pure virtual]

Get default clear z-buffer flag.

virtual void iEngine::GetDefaultMaxLightmapSize ( int &  w,
int &  h 
) [pure virtual]

Retrieve default maximum lightmap size.

Parameters:
w lightmap width
h lightmap height

virtual int iEngine::GetLightingCacheMode (  )  [pure virtual]

Get the mode for the lighting cache.

virtual csPtr<iLightIterator> iEngine::GetLightIterator ( iRegion region = 0  )  [pure virtual]

Create an iterator to iterate over all static lights of the engine.

Assign to a csRef.

Parameters:
region only iterate over the lights in this region (otherwise iterate over all lights)

virtual iMaterialList* iEngine::GetMaterialList (  )  const [pure virtual]

Get the list of all materials.

virtual int iEngine::GetMaxLightmapAspectRatio (  )  const [pure virtual]

Get the maximum aspect ratio for lightmaps.

virtual void iEngine::GetMaxLightmapSize ( int &  w,
int &  h 
) [pure virtual]

Retrieve maximum lightmap size.

Parameters:
w lightmap width
h lightmap height

virtual iMeshList* iEngine::GetMeshes (  )  [pure virtual]

Get the list of meshes.

virtual iMeshFactoryList* iEngine::GetMeshFactories (  )  [pure virtual]

Get the list of mesh factories.

virtual int iEngine::GetNearbyLights ( iSector sector,
const csBox3 box,
iLight **  lights,
int  max_num_lights 
) [pure virtual]

This routine returns all lights which might affect an object with some bounding box.


It will only return as many lights as the size that you specified for the light array. The returned lights are not guaranteed to be sorted but they are guaranteed to be the specified number of lights closest to the given position.
This function returns the actual number of lights added to the 'lights' array.

virtual int iEngine::GetNearbyLights ( iSector sector,
const csVector3 pos,
iLight **  lights,
int  max_num_lights 
) [pure virtual]

This routine returns all lights which might affect an object at some position.


It will only return as many lights as the size that you specified for the light array. The returned lights are not guaranteed to be sorted but they are guaranteed to be the specified number of lights closest to the given position.
This function returns the actual number of lights added to the 'lights' array.

virtual csPtr<iMeshWrapperIterator> iEngine::GetNearbyMeshes ( iSector sector,
const csVector3 start,
const csVector3 end,
bool  crossPortals = true 
) [pure virtual]

This routine returns an iterator to iterate over all meshes that intersect with a beam.

If crossPortals is true it will search through portals. Otherwise it will limit the search to the sector passed in. Portal visibility is tested fromt the start of the beam.

virtual csPtr<iMeshWrapperIterator> iEngine::GetNearbyMeshes ( iSector sector,
const csBox3 box,
bool  crossPortals = true 
) [pure virtual]

This routine returns an iterator to iterate over all meshes that are in a box.

If crossPortals is true it will search through portals. Otherwise it will limit the search to the sector passed in. Portal visibility is tested with the center of the box.

virtual csPtr<iMeshWrapperIterator> iEngine::GetNearbyMeshes ( iSector sector,
const csVector3 pos,
float  radius,
bool  crossPortals = true 
) [pure virtual]

This routine returns an iterator to iterate over all meshes that are within a radius of a given position.

If crossPortals is true it will search through portals. Otherwise it will limit the search to the sector passed in.

virtual csPtr<iObjectIterator> iEngine::GetNearbyObjects ( iSector sector,
const csVector3 pos,
float  radius,
bool  crossPortals = true 
) [pure virtual]

This routine returns an iterator to iterate over all objects that are within a radius of a given position.

The current implementation only does meshes but in future lights will also be supported. You can use SCF_QUERY_INTERFACE to get any interface from the returned objects. If crossPortals is true it will search through portals. Otherwise it will limit the search to the sector passed in. If you only want to have meshes then it is more efficient to call GetNearbyMeshes() as you can then avoid the call to SCF_QUERY_INTERFACE.

virtual csPtr<iSectorIterator> iEngine::GetNearbySectors ( iSector sector,
const csBox3 box 
) [pure virtual]

This routine returns an iterator to iterate over all nearby sectors.

Assign to a csRef. In the iterator you can also fetch the position for every sector. Normally that position will be equal to the given input position here (pos) but if there are space warping portals involved then the position returned by the iterator is the warped position relative to the sector returned by the iterator.

virtual csPtr<iSectorIterator> iEngine::GetNearbySectors ( iSector sector,
const csVector3 pos,
float  radius 
) [pure virtual]

This routine returns an iterator to iterate over all nearby sectors.

Assign to a csRef. In the iterator you can also fetch the position for every sector. Normally that position will be equal to the given input position here (pos) but if there are space warping portals involved then the position returned by the iterator is the warped position relative to the sector returned by the iterator.

virtual long iEngine::GetObjectRenderPriority (  )  [pure virtual]

Get the render priority for general objects (attached to 'object' name).

virtual long iEngine::GetPortalRenderPriority (  )  [pure virtual]

Get the render priority for portal objects (attached to 'portal' name).

virtual iRegionList* iEngine::GetRegions (  )  [pure virtual]

Get the list of all regions.

virtual iRenderLoopManager* iEngine::GetRenderLoopManager (  )  [pure virtual]

Retrieve the render loop manager.

virtual long iEngine::GetRenderPriority ( const char *  name  )  const [pure virtual]

Get a render priority by name.

Parameters:
name is the name you want (one of the standard names or your own if you have defined your own render priorities).
Returns:
0 if render priority doesn't exist.

virtual int iEngine::GetRenderPriorityCount (  )  const [pure virtual]

Get the number of render priorities.

virtual const char* iEngine::GetRenderPriorityName ( long  priority  )  const [pure virtual]

Get the name of the render priority or 0 if none existant.

virtual csRenderPrioritySorting iEngine::GetRenderPrioritySorting ( long  priority  )  const [pure virtual]

Get the render priority sorting flag.

virtual csRenderPrioritySorting iEngine::GetRenderPrioritySorting ( const char *  name  )  const [pure virtual]

Get the render priority sorting flag.

virtual bool iEngine::GetSaveableFlag (  )  [pure virtual]

Get whether saving should be possible (default OFF).

virtual iSectorList* iEngine::GetSectors (  )  [pure virtual]

Get the list of sectors.

virtual long iEngine::GetSkyRenderPriority (  )  [pure virtual]

Get the render priority for sky objects (attached to 'sky' name).

virtual int iEngine::GetTextureFormat (  )  const [pure virtual]

Query the format to load textures (usually this depends on texture manager).

virtual iTextureList* iEngine::GetTextureList (  )  const [pure virtual]

Get the list of all textures.

virtual iRenderView* iEngine::GetTopLevelClipper (  )  const [pure virtual]

Get the top-level clipper.

virtual iSharedVariableList* iEngine::GetVariableList (  )  const [pure virtual]

Get the list of all shared variables.

virtual csPtr<iMeshWrapperIterator> iEngine::GetVisibleMeshes ( iSector sector,
const csFrustum frustum 
) [pure virtual]

This routine returns an iterator to iterate over all meshes that are potentially visible as seen from a given position.

This routine has a frustum restricting the view. CURRENTLY NOT IMPLEMENTED!

virtual csPtr<iMeshWrapperIterator> iEngine::GetVisibleMeshes ( iSector sector,
const csVector3 pos 
) [pure virtual]

This routine returns an iterator to iterate over all meshes that are potentially visible as seen from a given position.

This routine assumes full 360 degree visibility. CURRENTLY NOT IMPLEMENTED!

virtual csPtr<iObjectIterator> iEngine::GetVisibleObjects ( iSector sector,
const csFrustum frustum 
) [pure virtual]

This routine returns an iterator to iterate over all objects that are potentially visible as seen from a given position.

This routine has a frustum restricting the view. You can use SCF_QUERY_INTERFACE to get any interface from the returned objects.

If you only want meshes then use GetVisibleMeshes(). CURRENTLY NOT IMPLEMENTED!

virtual csPtr<iObjectIterator> iEngine::GetVisibleObjects ( iSector sector,
const csVector3 pos 
) [pure virtual]

This routine returns an iterator to iterate over all objects that are potentially visible as seen from a given position.

This routine assumes full 360 degree visibility. You can use SCF_QUERY_INTERFACE to get any interface from the returned objects.

If you only want meshes then use GetVisibleMeshes(). CURRENTLY NOT IMPLEMENTED!

virtual long iEngine::GetWallRenderPriority (  )  [pure virtual]

Get the render priority for wall objects (attached to 'wall' name).

virtual csPtr<iMeshFactoryWrapper> iEngine::LoadMeshFactory ( const char *  name,
const char *  loaderClassId,
iDataBuffer input 
) [pure virtual]

Convenience function to load a mesh factory from a given loader plugin.

Parameters:
name engine name for the mesh factory
loaderClassId the SCF class name of the desired mesh factory plugin
input data to initialize the mesh factory (plugin-specific) Assign to a csRef.

virtual csPtr<iMeshWrapper> iEngine::LoadMeshWrapper ( const char *  name,
const char *  loaderClassId,
iDataBuffer input,
iSector sector,
const csVector3 pos 
) [pure virtual]

Convenience function to load a mesh object from a given loader plugin.

Parameters:
name The engine name for the mesh wrapper; may be null. Different mesh objects can have the same name (in contrast with factory objects).
loaderClassId the SCF class of the loader to use to create the meshwrapper
input data passed to the loader to generate the mesh
sector the sector to initially place this mesh in If 'sector' is 0 then the mesh object will not be set to a position.
pos the position in the sector
Returns:
The meshwrapper on success (assign to a csRef), or 0 on failure.

virtual void iEngine::PrecacheDraw ( iRegion region = 0  )  [pure virtual]

This function precaches all meshes by calling GetRenderMeshes() on them.

By doing this the level will run smoother if you walk through it because all meshes will have had a chance to update caches and stuff.

Parameters:
region is an optional region. If given then only objects in that region will be precached.

virtual bool iEngine::Prepare ( iProgressMeter meter = 0  )  [pure virtual]

Prepare the engine.

This function must be called after you loaded/created the world and before it is rendered.

Actions include:

  • Preparation of all lightmaps for use
  • Registering of textures with texture manager and freeing of loaded images (as the texture manager will have created textures from them) The optional progress meter will be used to report progress.

The behaviour regarding cached lighting depends on the flag you can set with the SetLightingCacheMode() function. The default behaviour is to read the lightmap cache when present but don't calculate lighting if cache is not present.

Parameters:
meter If supplied, the meter object will be called back periodically to report the progress of engine preparation.

virtual void iEngine::PrepareMeshes (  )  [pure virtual]

Calls UpdateMove for all meshes to initialise bounding boxes.

Prepare() will call this function automatically so you normally don't have to call it.

virtual void iEngine::PrepareTextures (  )  [pure virtual]

Prepare the textures.

It will initialise all loaded textures for the texture manager. (Normally you shouldn't call this function directly, because it will be called by Prepare() for you. This function will also prepare all loaded materials after preparing the textures.

virtual iObject* iEngine::QueryObject (  )  [pure virtual]

Get the iObject for the engine.

virtual void iEngine::RegisterRenderPriority ( const char *  name,
long  priority,
csRenderPrioritySorting  rendsort = CS_RENDPRI_SORT_NONE 
) [pure virtual]

Register a new render priority.

Render priorities are assigned to objects and controls the order in which objects are rendered by the engine.

Parameters:
name a name to refer to this render priority
priority a numerical priority; this is used to order the render priorities where lower numbers are rendered before higher numbers.
rendsort One of the CS_RENDPRI_... flags. By default this is CS_RENDPRI_SORT_NONE. The following values are possible:
Note:
The default render priorities are:
  • init: 1
  • sky: 2
  • sky2: 3
  • portal: 4
  • wall: 5
  • wall2: 6
  • object: 7
  • object2: 8
  • transp: 9
  • alpha: 10 (uses back2front sorting for meshes)
  • final: 11 (in that priority order, where 'init' is rendered first and 'final' is rendered last). Should you wish to add your own render priority, you must call ClearRenderPriorities() and re-add the default render priorities along with your own new priorities.

virtual void iEngine::RemoveDelayedRemoves ( bool  remove = false  )  [pure virtual]

Clear all delayed removals.

Parameters:
remove if true then the objects will also be removed from engine. Otherwise they are simply removed from this list.

virtual void iEngine::RemoveEngineFrameCallback ( iEngineFrameCallback cb  )  [pure virtual]

Remove a frame callback.

virtual void iEngine::RemoveEngineSectorCallback ( iEngineSectorCallback cb  )  [pure virtual]

Remove a sector callback.

virtual void iEngine::RemoveLight ( iLight light  )  [pure virtual]

Remove a light and update all lightmaps.

This function only works correctly for dynamic or pseudo-dynamic static lights. If you give a normal static light then the light will be removed but lightmaps will not be affected. You can call ForceRelight() to force relighting then.

The current flags set with SetLightingCacheMode() controls if the lightmaps will be cached or not.

Parameters:
light the light to remove

virtual bool iEngine::RemoveObject ( iBase object  )  [pure virtual]

Convenience function to 'remove' a CS object from the engine.

This will not clear the object but it will remove all references to that object that the engine itself keeps. This function works for: iCameraPosition, iCollection, iLight, iMaterialWrapper, iMeshFactoryWrapper,iMeshWrapper, iRegion, iSector and iTextureWrapper. Note that the object is only removed if the resulting ref count will become zero. So basically this function only releases the references that the engine holds.

This function returns true if the engine recognized the object as one on which it can operate.

This function will also remove the object from the region it may be in.

virtual void iEngine::ResetWorldSpecificSettings (  )  [pure virtual]

Reset a subset of flags/settings (which may differ from one world/map to another) to its defaults.

This currently includes:

  • clear z buffer flag
  • lightmap cell size
  • maximum lightmap size

virtual void iEngine::SetAmbientLight ( const csColor  )  [pure virtual]

Set the amount of ambient light.

This has no effect until you recalculate the lightmaps.

virtual void iEngine::SetCacheManager ( iCacheManager cache_mgr  )  [pure virtual]

Set the cache manager that the engine will use.

If this is not done then the engine will use its own cache manager based on VFS. This will do an incref on the given cache manager and a decref on the old one. The engine will release the cache manager at destruction time. To set the cache manager to the default VFS based cache manager for a given VFS directory you can use the following code:

 engine->SetVFSCacheManager ("/bla/bla");

virtual void iEngine::SetClearScreen ( bool  yesno  )  [pure virtual]

Require that the screen is cleared every frame.

The engine itself will not use this setting but will only return the correct flag in GetBeginDrawFlags() so that the screen is actually cleared. Note that this requires that the application actually uses GetBeginDrawFlags() in the call to g3d->BeginDraw() (which it should). By default this flag is false. It is useful to set this flag to true if you have a level that doesn't itself have another way to initialize the screen.

Parameters:
yesno true to clear the screen before each frame, false to leave the screen as-is (which may leave garbage on the screen)

virtual void iEngine::SetClearZBuf ( bool  yesno  )  [pure virtual]

Require that the Z-buffer is cleared every frame.

The engine itself will not use this setting but will only return the correct flag in GetBeginDrawFlags() so that the Z-buffer is actually cleared. Note that this requires that the application actually uses GetBeginDrawFlags() in the call to g3d->BeginDraw() (which it should). By default this flag is false. It is useful to set this flag to true if you have a level that doesn't itself have another way to initialize the Z-buffer.

Parameters:
yesno true to clear the Z buffer after each frame, false to leave the zbuffer as-is

virtual void iEngine::SetContext ( iTextureHandle ctxt  )  [pure virtual]

Set the drawing context.

This is a texture handle that is used as the procedural texture to render on. If this is 0 then the screen is assumed.

virtual bool iEngine::SetCurrentDefaultRenderloop ( iRenderLoop loop  )  [pure virtual]

Set the current render loop.

Parameters:
loop The loop to be made the current render loop.
Returns:
Whether the change was successful (a value of 0 for will let the method fail.)

virtual void iEngine::SetLightingCacheMode ( int  mode  )  [pure virtual]

Set the mode for the lighting cache (combination of CS_ENGINE_CACHE_???).

Default is CS_ENGINE_CACHE_READ | CS_ENGINE_CACHE_NOUPDATE.

Parameters:
mode 
  • CS_ENGINE_CACHE_READ: Read the cache.
  • CS_ENGINE_CACHE_WRITE: Write the cache.
  • CS_ENGINE_CACHE_NOUPDATE: Don't update lighting automatically if it is not up-to-date. This is on by default. If you disable this then lighting will be calculated even if CS_ENGINE_CACHE_WRITE is not set which means that the resulting calculation is not written to the cache.

virtual void iEngine::SetMaxLightmapSize ( int  w,
int  h 
) [pure virtual]

Set the maximum lightmap dimensions.

Polys with lightmaps larger than this are not lit.

Parameters:
w lightmap width
h lightmap height

virtual void iEngine::SetSaveableFlag ( bool  enable  )  [pure virtual]

Set whether saving should be possible (default OFF).

To allow saving of a world after it has been loaded, some objects may need to keep track of extra data that would otherwise not be needed if the world will never be written out again. The 'saveable' flag informs those objects about whether to keep that information or not. Saving a world with this flag disables is still possible, but the result might incomplete.

virtual void iEngine::SetVFSCacheManager ( const char *  vfspath = 0  )  [pure virtual]

Set the cache manager to the default VFS based cache manager.

Note that this function will not change the VFS current directory.

Parameters:
vfspath is the path that will be used for the cache manager. If 0 then the current VFS directory will be used instead.

virtual void iEngine::ShineLights ( iRegion region = 0,
iProgressMeter meter = 0 
) [pure virtual]

Calculate all lighting information.

Normally you shouldn't call this function directly, because it will be called by Prepare(). If the optional 'region' parameter is given then only lights will be recalculated for the given region.

Parameters:
region If supplied, only calculate lighting for lights and objects in the given region.
meter If supplied, the meter object will be called back periodically to report the progress of engine lighting calculation.

virtual void iEngine::WantToDie ( iMeshWrapper mesh  )  [pure virtual]

Sometimes a mesh wants to destruct itself (for example a particle system that has only limited lifetime).

It can do that by calling this function on itself. The engine will then remove the object before the next frame.


The documentation for this struct was generated from the following file:
Generated for Crystal Space 1.2.1 by doxygen 1.5.3