Public API Reference

iengine/sector.h

Go to the documentation of this file.

/*
    Crystal Space 3D engine
    Copyright (C) 1998-2001 by Jorrit Tyberghein
                  2004 by Marten Svanfeldt

    This library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Library General Public
    License as published by the Free Software Foundation; either
    version 2 of the License, or (at your option) any later version.

    This library is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
    Library General Public License for more details.

    You should have received a copy of the GNU Library General Public
    License along with this library; if not, write to the Free
    Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*/

#ifndef __CS_IENGINE_SECTOR_H__
#define __CS_IENGINE_SECTOR_H__

#include "csutil/cscolor.h"
#include "csutil/scf.h"
#include "csutil/set.h"
#include "csgeom/vector3.h"

struct iMeshWrapper;
struct iMeshGenerator;
struct iMeshList;
struct iLightList;
struct iLight;
struct iVisibilityCuller;

struct iObject;

struct iRenderView;
struct iRenderLoop;
struct iFrustumView;
struct iSector;
struct iDocumentNode;

struct iShaderVariableContext;

class csBox3;
class csRenderMeshList;
class csReversibleTransform;
class csVector3;

enum csFogMode
{
  CS_FOG_MODE_NONE = 0,
  CS_FOG_MODE_LINEAR,
  CS_FOG_MODE_EXP,
  CS_FOG_MODE_EXP2,
  CS_FOG_MODE_CRYSTALSPACE
};

struct csFog
{
  float density;
  csColor color;
  float start;
  float end;
  csFogMode mode;

  csFog() : density (0), color (0, 0, 0), start (0), end (0), 
    mode (CS_FOG_MODE_NONE) {}
};

struct iSectorCallback : public virtual iBase
{
  SCF_INTERFACE (iSectorCallback, 0, 0, 1);

  virtual void Traverse (iSector* sector, iBase* context) = 0;
};

struct iSectorMeshCallback : public virtual iBase
{
  SCF_INTERFACE (iSectorMeshCallback, 0, 0, 1);

  virtual void NewMesh (iSector* sector, iMeshWrapper* mesh) = 0;

  virtual void RemoveMesh (iSector* sector, iMeshWrapper* mesh) = 0;
};

struct iLightVisibleCallback : public virtual iBase
{
  SCF_INTERFACE (iLightVisibleCallback, 0, 0, 1);

  virtual void LightVisible (iSector* sector, iLight* light) = 0;
};

struct csSectorHitBeamResult
{
  iMeshWrapper* mesh;

  csVector3 isect;

  int polygon_idx;

  iSector* final_sector;
};

struct iSector : public virtual iBase
{
  SCF_INTERFACE(iSector,2,1,0);
  virtual iObject *QueryObject () = 0;


  virtual iMeshList* GetMeshes () = 0;

  virtual csRenderMeshList* GetVisibleMeshes (iRenderView *) = 0;

  virtual const csSet<csPtrKey<iMeshWrapper> >& GetPortalMeshes () const = 0;

  virtual void UnlinkObjects () = 0;

  virtual void AddSectorMeshCallback (iSectorMeshCallback* cb) = 0;

  virtual void RemoveSectorMeshCallback (iSectorMeshCallback* cb) = 0;

  virtual void Draw (iRenderView* rview) = 0;

  virtual void PrepareDraw (iRenderView* rview) = 0;

  virtual int GetRecLevel () const = 0;

  virtual void IncRecLevel () = 0;

  virtual void DecRecLevel () = 0;

  virtual void SetRenderLoop (iRenderLoop* rl) = 0;

  virtual iRenderLoop* GetRenderLoop () = 0;
  virtual iMeshGenerator* CreateMeshGenerator (const char* name) = 0;

  virtual size_t GetMeshGeneratorCount () const = 0;

  virtual iMeshGenerator* GetMeshGenerator (size_t idx) = 0;

  virtual iMeshGenerator* GetMeshGeneratorByName (const char* name) = 0;

  virtual void RemoveMeshGenerator (size_t idx) = 0;

  virtual void RemoveMeshGenerators () = 0;

  virtual bool HasFog () const = 0;
  virtual const csFog& GetFog () const = 0;
  virtual void SetFog (float density, const csColor& color) = 0;
  virtual void SetFog (const csFog& fog) = 0;
  virtual void DisableFog () = 0;
  virtual iLightList* GetLights () = 0;

  virtual void ShineLights () = 0;
  virtual void ShineLights (iMeshWrapper*) = 0;

  virtual void SetDynamicAmbientLight (const csColor& color) = 0;

  virtual csColor GetDynamicAmbientLight () const = 0;

  virtual uint GetDynamicAmbientVersion () const = 0;
  virtual void CalculateSectorBBox (csBox3& bbox,
    bool do_meshes) const = 0;

  virtual bool SetVisibilityCullerPlugin (const char* name,
        iDocumentNode* culler_params = 0) = 0;
  virtual iVisibilityCuller* GetVisibilityCuller () = 0;

  virtual void CheckFrustum (iFrustumView* lview) = 0;

  
  CS_DEPRECATED_METHOD_MSG("Use the csSectorHitBeamResult version instead")
  virtual iMeshWrapper* HitBeamPortals (
        const csVector3& start, const csVector3& end, csVector3& isect,
        int* polygon_idx, iSector** final_sector = 0) = 0;

  CS_DEPRECATED_METHOD_MSG("Use the csSectorHitBeamResult version instead")
  virtual iMeshWrapper* HitBeam (const csVector3& start,
        const csVector3& end, csVector3& intersect, int* polygon_idx,
        bool accurate = false) = 0;

  virtual csSectorHitBeamResult HitBeamPortals (const csVector3& start,
        const csVector3& end) = 0;

  virtual csSectorHitBeamResult HitBeam (const csVector3& start,
        const csVector3& end, bool accurate = false) = 0;

  virtual iSector* FollowSegment (csReversibleTransform& t,
    csVector3& new_position, bool& mirror, bool only_portals = false) = 0;
  virtual void SetSectorCallback (iSectorCallback* cb) = 0;

  virtual void RemoveSectorCallback (iSectorCallback* cb) = 0;

  virtual int GetSectorCallbackCount () const = 0;

  virtual iSectorCallback* GetSectorCallback (int idx) const = 0;
  virtual void SetLightCulling (bool enable) = 0;
  virtual bool IsLightCullingEnabled () const = 0;
  virtual void AddLightVisibleCallback (iLightVisibleCallback* cb) = 0;
  virtual void RemoveLightVisibleCallback (iLightVisibleCallback* cb) = 0;

  virtual iShaderVariableContext* GetSVContext() = 0;
};


struct iSectorList : public virtual iBase
{
  SCF_INTERFACE(iSectorList, 2,0,0);
  virtual int GetCount () const = 0;

  virtual iSector *Get (int n) const = 0;

  virtual int Add (iSector *obj) = 0;

  virtual bool Remove (iSector *obj) = 0;

  virtual bool Remove (int n) = 0;

  virtual void RemoveAll () = 0;

  virtual int Find (iSector *obj) const = 0;

  virtual iSector *FindByName (const char *Name) const = 0;
};


struct iSectorIterator : public virtual iBase
{
  SCF_INTERFACE(iSectorIterator,2,0,0);
  virtual bool HasNext () const = 0;

  virtual iSector* Next () = 0;

  virtual const csVector3& GetLastPosition () const = 0;

  virtual void Reset () = 0;
};

#endif // __CS_IENGINE_SECTOR_H__

---