X3DBaseTypes.h

Go to the documentation of this file.

#ifndef X3DTK_X3DBASETYPES_H
#define X3DTK_X3DBASETYPES_H

#include "Platform.h"
#include "SFString.h"
#include "SFVec3f.h"
#include "SFVec2f.h"
#include "SFPoint3f.h"
#include "SFPoint2f.h"
#include "SFMatrix34f.h"

#include <iostream>
#include <string>
#include <list>
#include <vector>
#include <map>


namespace X3DTK {

class nil {};

class MFString : public std::vector<SFString>
{
public:
  MFString() {};
  explicit MFString(const SFString &s);
  SFString toSFString() const;
};

typedef bool SFBool;

class MFBool : public std::vector<SFBool>
{
public:
  MFBool(){};
  explicit MFBool(const SFString &s);
  SFString toSFString() const;
};

typedef int SFInt32;

class MFInt32 : public std::vector<SFInt32>
{
public:
  MFInt32(){};
  explicit MFInt32(size_type n, const SFInt32 &V = SFInt32()); 
  explicit MFInt32(const SFString &s);
  SFString toSFString() const;
};

typedef float SFFloat;

class MFFloat : public std::vector<SFFloat>
{
public:
  MFFloat(){};
  explicit MFFloat(size_type n, const SFFloat &V = SFFloat());
  explicit MFFloat(const SFString &s);
  SFString toSFString() const;
};

typedef double SFDouble;

class MFDouble : public std::vector<SFDouble>
{
public:
  MFDouble(){};
  explicit MFDouble(const SFString &s);
  SFString toSFString() const;
};

class SFColor;

class SFColorRGBA
{
public:
  SFFloat r;
  SFFloat g;
  SFFloat b;
  SFFloat a;
  SFColorRGBA(){};
  SFColorRGBA(const SFColor &color);
  SFColorRGBA(SFFloat r, SFFloat g, SFFloat b, SFFloat a);
  explicit SFColorRGBA(const SFString &s);
  inline float *f_data() {return &r;};
  inline const float *f_data() const {return &r;};
  inline operator float *() {return &r;};
  inline operator const float *() const {return &r;};
 
  friend bool operator== (const SFColorRGBA &r1, const SFColorRGBA &r2);
  friend bool operator!= (const SFColorRGBA &r1, const SFColorRGBA &r2);
  SFString toSFString() const;  
  
  static const SFColorRGBA null;
};

class MFColorRGBA : public std::vector<SFColorRGBA>
{
public:
  MFColorRGBA(){};
  MFColorRGBA(size_type n, const SFColorRGBA &C = SFColorRGBA());
  explicit MFColorRGBA(const SFString &s);
  SFString toSFString() const;
};

class SFColor
{
public:
  SFFloat r;
  SFFloat g;
  SFFloat b;
  SFColor(){};
  SFColor(SFFloat r, SFFloat g, SFFloat b);
  explicit SFColor(const SFString &s);
  inline float *f_data() {return &r;};
  inline const float *f_data() const {return &r;};
  inline operator float *() {return &r;};
  inline operator const float *() const {return &r;};
 
  friend bool operator== (const SFColor &r1, const SFColor &r2);
  friend bool operator!= (const SFColor &r1, const SFColor &r2);
  SFString toSFString() const;
  
  static const SFColor null;
};

class MFColor : public std::vector<SFColor>
{
public:
  MFColor(){};
  explicit MFColor(const SFString &s);
  operator const MFColorRGBA() const;
  SFString toSFString() const;
};

class X3DAbstractNode;

typedef X3DAbstractNode *SFNode;

typedef std::list<X3DAbstractNode *> MFNode;

class SFVec2d
{
public:
  SFDouble x, y;
  SFVec2d();
  SFVec2d(SFDouble x, SFDouble y);
  explicit SFVec2d(const SFString &s);
  SFString toSFString() const;
};
  
class MFVec2d : public std::vector<SFVec2d>
{
public:
  MFVec2d(){};
  explicit MFVec2d(const SFString &s);
  SFString toSFString() const;
};
  
class MFVec2f : public std::vector<SFVec2f>
{
public:
  MFVec2f(){};
  explicit MFVec2f(size_type n, const SFVec2f &V = SFVec2f());
  explicit MFVec2f(const SFString &s);
  SFString toSFString() const;
};

class MFPoint2f : public std::vector<SFPoint2f>
{
public:
  MFPoint2f(){};
  explicit MFPoint2f(size_type n, const SFPoint2f &V = SFPoint2f());
  explicit MFPoint2f(const SFString &s);
  SFString toSFString() const;
};

class SFVec3d
{
public:
  SFDouble x, y, z;
  SFVec3d();
  SFVec3d(SFDouble x, SFDouble y, SFDouble z);
  explicit SFVec3d(const SFString &s);    
  SFString toSFString() const;
};

class MFVec3d : public std::vector<SFVec3d>
{
public:
  MFVec3d(){};
  explicit MFVec3d(const SFString &s);
  SFString toSFString() const;
};

class MFVec3f : public std::vector<SFVec3f>
{
public:
  MFVec3f(){};
  explicit MFVec3f(size_type n, const SFVec3f &V = SFVec3f());
  explicit MFVec3f(const SFString &s);
  SFString toSFString() const;
};

class MFPoint3f : public std::vector<SFPoint3f>
{
public:
  MFPoint3f(){};
  explicit MFPoint3f(size_type n, const SFPoint3f &V = SFPoint3f());
  explicit MFPoint3f(const SFString &s);
  SFString toSFString() const;
};

class SFRotation
{
public:
  SFFloat x, y, z, angle;
  SFRotation(){};
  SFRotation(SFFloat x, SFFloat y, SFFloat z, SFFloat angle);
  explicit SFRotation(const SFString &s);
  SFString toSFString() const;
  
  friend bool operator== (const SFRotation &r1, const SFRotation &r2);
  friend bool operator!= (const SFRotation &r1, const SFRotation &r2);
};


class MFRotation : public std::vector<SFRotation>
{
public:
  MFRotation(){};
  explicit MFRotation(const SFString &s);
  SFString toSFString() const;
};

static const double PI = 3.14159265358979323846;

static const double radCoef = 180.0/PI;

inline SFFloat radiansToDegrees(SFFloat alpha)
{
  return static_cast<SFFloat>(radCoef*alpha);
}

}

#ifndef DOXYGEN

namespace X3DTK {

struct eqSFString
{
  inline bool operator()(const SFString &s1, const SFString &s2) const
  {
    return s1 == s2;
  }
};

struct ltSFString
{
  bool operator()(const SFString &s1, const SFString &s2) const
  {
    return strcmp(s1, s2) < 0;
  }
};

}

#endif

namespace X3DTK {

// other types
class SFType;
class SFComponent;
class SFSceneGraph;
class WalkFunction;
class VisitingFunctions;
class EnterFunction;
class WalkOnFunction;
class CreationFunction;
class LeaveFunction;

typedef std::map<SFString, SFType *, ltSFString> MFType;

typedef std::map<SFString, SFComponent *, ltSFString> MFComponent;

typedef std::map<SFString, SFSceneGraph *, ltSFString> MFSceneGraph;

typedef std::map<SFString, WalkFunction *, ltSFString> WalkingDict;

typedef std::map<SFString, EnterFunction *, ltSFString> EnterDict;

typedef std::map<SFString, WalkOnFunction *, ltSFString> WalkOnDict;

typedef std::map<SFString, LeaveFunction *, ltSFString> LeaveDict;

typedef std::map<SFString, CreationFunction *, ltSFString> CreationDict;


typedef std::vector<WalkFunction *> WalkingArray;

typedef std::vector<VisitingFunctions *> VisitingArray;

std::ostream& operator<<(std::ostream& o, const MFString &ms);
std::ostream& operator<<(std::ostream& o, const MFBool &mb);
std::ostream& operator<<(std::ostream& o, const MFInt32 &mi);
std::ostream& operator<<(std::ostream& o, const MFFloat &mf);
std::ostream& operator<<(std::ostream& o, const MFDouble &md);
std::ostream& operator<<(std::ostream& o, const SFColor &c);
std::ostream& operator<<(std::ostream& o, const MFColor &mc);
std::ostream& operator<<(std::ostream& o, const SFColorRGBA &c);
std::ostream& operator<<(std::ostream& o, const MFColorRGBA &mc);
std::ostream& operator<<(std::ostream& o, const SFVec2d &v);
std::ostream& operator<<(std::ostream& o, const MFVec2d &mv);
std::ostream& operator<<(std::ostream& o, const SFVec2f &v);
std::ostream& operator<<(std::ostream& o, const MFVec2f &mv);
std::ostream& operator<<(std::ostream& o, const SFVec3d &v);
std::ostream& operator<<(std::ostream& o, const MFVec3d &mv);
std::ostream& operator<<(std::ostream& o, const SFVec3f &v);
std::ostream& operator<<(std::ostream& o, const MFVec3f &mv);
std::ostream& operator<<(std::ostream& o, const SFPoint3f &v);
std::ostream& operator<<(std::ostream& o, const SFRotation &r);
std::ostream& operator<<(std::ostream& o, const MFRotation &mr);
std::ostream& operator<<(std::ostream& o, const SFMatrix34f &M);

}

#endif

---