---

cybworldc.h

Go to the documentation of this file.

/*
Copyright (C) 1999-2003  Carsten Winkelholz, Malte Weiß

Malte Weiß, 09.04.2003: Added pointer for font manager.

Address:  FGAN Forschungsgesellschaft fuer Angewandte Naturwissenschaften e. V.
      Neuenahrer Str. 20
      D - 53343 Wachtberg
      
Email:    winkelholz@fgan.de

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

This program 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 General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
*/


#ifndef CYBWORLD_HC
#define CYBWORLD_HC


#include "oaw/misc/matrixc.h"
#include "oaw/ctk/cybnodec.h"
#include "oaw/ctk/cybtransformc.h"
#include "oaw/misc/modelc.h"
#include "oaw/misc/vectorc.h"
#include "oaw/misc/stringc.h"
#include "oaw/misc/arrayc.h"
#include "oaw/misc/urlc.h"
#include "oaw/misc/timec.h"
#include "oaw/pdtk/dismodelc.h"
#include "oaw/ctk/cybinterfacec.h"
#include "oaw/ctk/cybwrlfields.h"
#include "oaw/ctk/cybviewpointc.h"
#include "oaw/ctk/cybtexturec.h"
#include "oaw/ctk/ctkutils.h"
#include "oaw/misc/mapc.h"
#include "../oawconfig.h"


OAW_BEGIN_NAMESPACE


//#define TRUE 1
//#define FALSE 0

class CybGLViewC;
class CybViewC;
class CybChannelC;
class CybNodeC;
class CybTimeSensorC;
class CybTimeC;
class CybViewpointSensorC;
class CybSixDOFSensorC;
class CybProtoC;
class CybViewpointC;
class CybPointingDeviceC;
class CybScriptC;
class CybUserC;
class CybProxyC;
class CybFogC;
class CybBackgroundC;
class CybTextureManagerC;
class CybSoundManagerC;
class CybFontManagerC;
class CybSoundC;
class CybJSEngineC;

struct FV_DataStruct{
  float* data;
  long len;
};


struct LV_DataStruct{
  long* data;
  long len;
};


struct Pixelmap_DataStruct{
  unsigned char* pixel;
  long width;
  long height;
  long channel;
};

class DefUseC
{
public:
  DefUseC(){pRef=0;}
  int operator == (const DefUseC&);
public:
  StringC DefName;
  CybNodeC* pRef;
};

typedef KetteC<StringC> StringListC ;


// cybworldc.h : interface of the CybWorldC class  //////

class OAW_DLLMAPPING CybWorldC : public DisModelC, public SharedObjectC
{
  friend class CybShapeC;
  friend class CybViewpointC;
public:
  struct IsectResultS{
    SFVec3f hitPoint;
    SFFloat hitMinZ;
    CybNodeC* pNode;
    SFInt32 nodeType;
  };
  CybWorldC();
  virtual ~CybWorldC();
  inline CybGroupC* GetGroup() const {return m_pGroup;}
  virtual void* GetImpl(){return this;}
  inline virtual SFVec3f GetScale()const{ return m_pGroup->GetScale(); }


  virtual void LoadFromFile(const StringC&);
  virtual void Unload();
  virtual void* Malloc(long);
  virtual void* Realloc(void *buf, long size);
  virtual void Free(void*);
  virtual short isectSceneWithNode(SFNode*, IsectResultS&){return 0;}

  virtual void Update();
  virtual void UpdateAllViews(int);
  virtual void FinishInit();

  virtual void ToChannel(CybChannelC*,long);

  virtual void SetEventBroker(EventBrokerC*);
  virtual void AddInterface(const StringC&, InterfaceC*);
  virtual void AddSensor(CybSensorC*);
  virtual void AddPointingDevice(CybPointingDeviceC*);
  virtual void RemoveInterface(InterfaceC*);

  virtual CybNodeC* CreateNode(long);
  virtual void LoadVRML(char*&, const char*,long&);

  virtual void TravApp();

  //void InlineNodeLoadBegin();
  //void InlineNodeLoadEnd();
  void ProtoLoadBegin(CybProtoC*);
  void ProtoLoadEnd(CybProtoC*);
  void ProtoCreateBegin(CybProtoC*);
  void ProtoCreateEnd(CybProtoC*);
  CybProtoC* GetCurrentProto();
  
  bool CreateRoute(const StringC&,const StringC&,const StringC&,const StringC&);
  
  StringC GetDefNodeName(CybNodeC*);
  CybNodeC* GetDefNode(const StringC&);
  void DefineNode(CybNodeC*, const StringC&);
  //void UndefineNode(CybNodeC*);

  NodeInfo *GetNodeInfo(const StringC& strName);
  
  ArrayC<CybNodeC*> CreateVrmlFromString(const char*);
  const char* GetWrlMainUrl();
  const StringC& GetHomePath();
  const StringC& GetCurrentFilepath();
  const StringC& GetCurrentFilename();
  void ChangeToAbsUrlPath(MFString& urlList);
  void SetCurrentFilename(const StringC&);

  inline CybViewpointSensorC* GetViewpointSensor(){return m_pViewpointSensor;}
  void SetViewpointSensor(CybViewpointSensorC* p){m_pViewpointSensor = p;}
  CybUserC* GetUser();
  void SetUser(CybUserC*);

  VectorC GetViewpointPosA();
  VectorC GetViewpointNormA();
  double GetViewpointRolA();
  
  const CybViewpointC* GetActiveViewpoint(){return m_pActiveViewpoint;}
  short SetActiveViewpoint(long n);

  // Fog control
  void AddFog(CybFogC *pFog);           
  // Set active fog for rendering
  inline void SetActiveFog(CybFogC *pFog){m_pActiveFog = pFog;}
  // Get active fog for rendering
  inline CybFogC *GetActiveFog(){return m_pActiveFog;}
  
  // Background administration
  void AddBackground(CybBackgroundC *pBackground);           
  inline void SetActiveBackground(CybBackgroundC *pBackground){ m_pActiveBackground = pBackground; }
  inline CybBackgroundC *GetActiveBackground(){return m_pActiveBackground;}

  // Texture control
  TEXTURE LoadTexture(const char *pUrl);
  char SetTexture(const TEXTURE &pTexture);
  void UnloadTexture(TEXTURE &pTexture);


  CybProtoC* GetProto(const StringC&);
  void AddNewProtoName(const StringC&,CybProtoC* pP);
  
  const TimeC& GetSystemTime();
  const TimeC& GetSystemTimeLastFrame(){return m_timeLastFrame;}
  
  ArrayC<CybNodeC*> GetRouteList();
  long GetNodeID(CybNodeC*);
  void FreeNodeID(CybNodeC*,long);
  CybNodeC* GetNodeOfID(long);
  void SetMaxTexDim(long n){m_maxTexDim = n;}
  long GetMaxTexDim(){return m_maxTexDim;}
  const KetteC<NodeInfo>& GetVRMLNodeKeys();
  
  inline void EnableNavigation(short bNavigationEnabled)  { m_bNavigationEnabled = bNavigationEnabled; }
  inline short IsNavigationEnabled() { return m_bNavigationEnabled; }
  inline void SetArgv(const MFString& vstr){m_vstrArgv=vstr;}
  inline const MFString& GetArgv(){return m_vstrArgv;}

  
public:
  CybTextureManagerC* m_pTexManager;
  CybSoundManagerC* m_pSoundManager;
  CybFontManagerC* m_pFontManager;
  CybJSEngineC* m_pJSEngine;

protected:
  //CybTextureManagerC* m_pDefaultTexManager;
  CybSoundManagerC* m_pDefaultSoundManager;
  CybFontManagerC*  m_pDefaultFontManager;

  
protected:
  /*Serialization*/
  void InitKeyList();
  long AddViewpoint(CybViewpointC* p);
  
  void RouteSensorData();
  void RouteInterfaceScriptData();
  void RoutePointingDeviceData();
  void ProcessInterfaceScript();
protected:

  CybTransformC* m_pGroup;
  
  KetteC<DefUseC> m_DEFList;
  ArrayC<CybSensorC*> m_pSensor;
  ArrayC<CybInterfaceC*> m_pScript;
  ArrayC<CybProtoC*> m_pCurrentProto;
  ArrayC<CybProtoC*> m_pProto;
  ArrayC<StringListC> m_protoNodeNames;
  MapC<StringC,CybProtoC*> m_protoNodeMap;
  ArrayC<CybViewpointC*> m_viewpointList;
  ArrayC<CybPointingDeviceC*> m_pPointingDevice;
  ArrayC<CybFogC*> m_pFogs;   // List of available fogs
  ArrayC<CybBackgroundC*> m_pBackgrounds;   // List of available backgrounds
  
  TimeC m_lastUpdateAllViews;
  UrlC m_url;
  StringC m_homePath;
  StringC m_currentFilename;
  StringC m_currentFilepath;

  CybTimeC* m_pSystemTime;

  CybViewpointSensorC* m_pViewpointSensor;
  CybFogC* m_pActiveFog;   // Selected fog for rendering
  CybBackgroundC *m_pActiveBackground;  

  //User
  CybUserC* m_pUser; 
  VectorC m_vScale;
  //ArrayC<CybNodeC*>* m_pCreateVrmlNodeList;
  long m_nNumTouchSensors, m_nNumDragSensors;

  ArrayC<CybNodeC*> m_pNodeList;
  ArrayC<long> m_freeNodeIDList;
  CybViewpointC* m_pDefaultViewpoint;
  CybViewpointC* m_pActiveViewpoint;

  TimeC m_timeLastFrame;

  long m_maxTexDim;

  short m_bNavigationEnabled;
  MFString m_vstrArgv;

public:
  KetteC<NodeInfo> kVRMLKeyInfo;
protected:
  KetteC<NodeInfo> m_kVRMLNodeKeyInfo;
  KetteC<NodeInfo> m_kVRMLNodeKeyInfoCompl;
        long m_nNativeNodeKeys;
};

OAW_END_NAMESPACE


#endif

---