switched vector3d to template class

TheGame/openglrenderdevice.cpp

@@ -43,13 +43,21 @@ void OpenGLRenderDevice::initialize(int fov, int width, int height)
     _fov = fov;
     _width = width;
     _height = height;
+
     glClearColor(_clearColor.redF(), _clearColor.greenF(),
                  _clearColor.blueF(), _clearColor.alphaF());
 
+
+//    GLfloat light_diffuse[] = {1.0, 0.0, 0.0, 1.0};  /* Red diffuse light. */
+//    GLfloat light_position[] = {1.0, 1.0, 1.0, 0.0};  /* Infinite light location. */
+//    glLightfv(GL_LIGHT0, GL_DIFFUSE, light_diffuse);
+//    glLightfv(GL_LIGHT0, GL_POSITION, light_position);
+//    glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, light_diffuse);
+//    glEnable(GL_LIGHT0);
+//    glEnable(GL_LIGHTING);
+    glDisable(GL_LIGHTING);
+
     glEnable(GL_DEPTH_TEST);
-    glEnable(GL_CULL_FACE);
-    glShadeModel(GL_SMOOTH);
-    glEnable(GL_MULTISAMPLE);
 
     glMatrixMode(GL_PROJECTION);
     gluPerspective(_fov, _width / _height, 0.1, 100.0);
@@ -81,6 +89,8 @@ void OpenGLRenderDevice::postDraw()
 
 void OpenGLRenderDevice::drawVertex(const ColorVector3D &point)
 {
+//    GLfloat d[] = { point.getColor().redF(), point.getColor().greenF(), point.getColor().blueF(), point.getColor().alphaF() };
+//    glMaterialfv(GL_FRONT, GL_AMBIENT_AND_DIFFUSE, d);
     glColor4f(point.getColor().redF(), point.getColor().greenF(),
                   point.getColor().blue(), point.getColor().alpha());
     glVertex3d(point.getX(), point.getY(), point.getZ());

TheGame/renderwidget.cpp

@@ -1,5 +1,4 @@
 #include "renderwidget.h"
-#include <GL/glu.h>
 #include <QTimer>
 #include <math.h>
 #include <QDebug>
@@ -17,17 +16,19 @@ RenderWidget::RenderWidget(QWidget *parent) :
     _device = new OpenGLRenderDevice(this);
     _engine = new UGameEngine(_device);
     UGEEntityCube* cube = new UGEEntityCube(_engine);
-    cube->move(Vector3D(0, 1, 0));
+//    cube->move(Vector3D(0, 1, 0));
+    cube->hide();
     _engine->addEntity(cube);
     _engine->addEntity(new UGEEntityAxes(_engine));
     setMouseTracking(true);
     setFocusPolicy(Qt::StrongFocus);
 
     WaveFrontObj* wavefrontObj = new WaveFrontObj(this);
-    qDebug() << wavefrontObj->openFile("/home/robin/Downloads/enterprise/obj/USSEnterprise.obj");
+    wavefrontObj->openFile("/home/robin/Downloads/enterprise/obj/USSEnterprise.obj");
 
     UGEEntityWaveFrontObj* obj = new UGEEntityWaveFrontObj(wavefrontObj, this);
     _engine->addEntity(obj);
+//    obj->hide();
 
 }
 

UGameEngine/UGameEngine.pro

@@ -19,7 +19,8 @@ SOURCES += engine/ugameengine.cpp \
     entities/ugeentitycube.cpp \
     entities/ugeentityaxes.cpp \
     utils/wavefrontobj.cpp \
-    entities/ugeentitywavefrontobj.cpp
+    entities/ugeentitywavefrontobj.cpp \
+    utils/texturevector3d.cpp
 
 HEADERS += engine/ugameengine.h\
     engine/abstractrenderdevice.h \
@@ -29,7 +30,10 @@ HEADERS += engine/ugameengine.h\
     entities/ugeentitycube.h \
     entities/ugeentityaxes.h \
     utils/wavefrontobj.h \
-    entities/ugeentitywavefrontobj.h
+    entities/ugeentitywavefrontobj.h \
+    utils/texturevector3d.h \
+    utils/vectorxd.h \
+    utils/vectorxd.hxx
 
 
 # FLEX && BISON

UGameEngine/engine/abstractrenderdevice.cpp

@@ -1,4 +1,5 @@
 #include "abstractrenderdevice.h"
+#include <QImage>
 
 AbstractRenderDevice::AbstractRenderDevice(QObject *parent) :
     QObject(parent)
@@ -42,6 +43,14 @@ void AbstractRenderDevice::lookAt(const Vector3D &eye, const Vector3D &center, c
     _lookUp = up;
 }
 
+//void AbstractRenderDevice::loadTextureFromFile(const QVariant &id, const QString &filename)
+//{
+//    QImage img;
+//    if (img.load(filename)) {
+//        loadTexture(id, img);
+//    }
+//}
+
 QColor AbstractRenderDevice::getClearColor() const
 {
     return _clearColor;

UGameEngine/engine/abstractrenderdevice.h

@@ -34,6 +34,10 @@ public slots:
 
     virtual void lookAt(const Vector3D& eye, const Vector3D& center, const Vector3D& up = Vector3D(0.0, 1.0, 0.0));
 
+//    void loadTextureFromFile(const QVariant& id, const QString& filename);
+
+//    virtual void loadTexture(const QVariant& id, const QImage& texture) = 0;
+
     virtual void initialize(int fov, int width, int height) = 0;
 
     virtual void resize(int width, int height) = 0;
@@ -48,6 +52,8 @@ public slots:
 
     virtual void drawPolygon(const QList<ColorVector3D>& points) = 0;
 
+//    virtual void drawPolygonTexture(const QList<ColorVector3D>& points) = 0;
+
 protected:
     QColor _clearColor;
 

UGameEngine/entities/ugeentitycube.cpp

@@ -13,7 +13,7 @@ float UGEEntityCube::getSize() const
 
 void UGEEntityCube::draw(AbstractRenderDevice *device)
 {
-    QColor color;
+    QColor color = Qt::red;
     float r = _size / 2;
     QList<ColorVector3D> points;
     points << ColorVector3D(color, -r, -r, r) << ColorVector3D(color, -r, r, r) << ColorVector3D(color, r, r, r) << ColorVector3D(color, r, -r, r);

UGameEngine/entities/ugeentitywavefrontobj.cpp

@@ -14,7 +14,7 @@ void UGEEntityWaveFrontObj::draw(AbstractRenderDevice *device)
         QList<int> face = faces[i];
         QList<ColorVector3D> poly;
         for (int j = 0; j < face.size(); ++j) {
-            poly.append(ColorVector3D(Qt::gray, vertexes[face[j] - 1]));
+            poly.append(ColorVector3D(Qt::black, vertexes[face[j] - 1]));
         }
         drawPolygon(device, poly);
     }

UGameEngine/utils/texturevector3d.cpp

@@ -0,0 +1,5 @@
+#include "texturevector3d.h"
+
+TextureVector3D::~TextureVector3D()
+{
+}

UGameEngine/utils/texturevector3d.h

@@ -0,0 +1,15 @@
+#ifndef TEXTUREVECTOR3D_H
+#define TEXTUREVECTOR3D_H
+
+#include "colorvector3d.h"
+
+class TextureVector3D : public ColorVector3D
+{
+public:
+    TextureVector3D(QColor color = Qt::white, double x = 0.0, double y = 0.0, double z = 0.0);
+    TextureVector3D(QColor color = Qt::white, const Vector3D& other = Vector3D());
+    TextureVector3D(const ColorVector3D& other);
+    virtual ~TextureVector3D();
+};
+
+#endif // TEXTUREVECTOR3D_H

UGameEngine/utils/vector3d.cpp

@@ -2,16 +2,20 @@
 #include <math.h>
 
 Vector3D::Vector3D(double x, double y, double z)
-    : _x(x)
-    , _y(y)
-    , _z(z)
+    : VectorXD<3>()
 {
+    _scalars[0] = x;
+    _scalars[1] = y;
+    _scalars[2] = z;
 }
 
 Vector3D::Vector3D(const Vector3D &other)
-    : _x(other._x)
-    , _y(other._y)
-    , _z(other._z)
+    : VectorXD<3>(other)
+{
+}
+
+Vector3D::Vector3D(const VectorXD<3> &other)
+    : VectorXD<3>(other)
 {
 }
 
@@ -21,94 +25,48 @@ Vector3D::~Vector3D()
 
 double Vector3D::getX() const
 {
-    return _x;
+    return _scalars[0];
 }
 
 Vector3D& Vector3D::setX(double x)
 {
-    _x = x;
+    _scalars[0] = x;
     return *this;
 }
 double Vector3D::getY() const
 {
-    return _y;
+    return _scalars[1];
 }
 
 Vector3D& Vector3D::setY(double y)
 {
-    _y = y;
+    _scalars[1] = y;
     return *this;
 }
 double Vector3D::getZ() const
 {
-    return _z;
+    return _scalars[2];
 }
 
 Vector3D& Vector3D::setZ(double z)
 {
-    _z = z;
+    _scalars[2] = z;
     return *this;
 }
 
-bool Vector3D::isNull() const
-{
-    return _x == 0 && _y == 0 && _z == 0;
-}
-
-bool Vector3D::equal(const Vector3D &other) const
-{
-    return _x == other._x && _y == other._y && _z == other._z;
-}
-
-Vector3D &Vector3D::add(double k)
-{
-    return add(Vector3D(k, k, k));
-}
-
 Vector3D &Vector3D::add(double x, double y, double z)
 {
-    return add(Vector3D(x, y, z));
-}
-
-Vector3D& Vector3D::add(const Vector3D &other)
-{
-    _x += other._x;
-    _y += other._y;
-    _z += other._z;
+    _scalars[0] += x;
+    _scalars[1] += y;
+    _scalars[2] += z;
     return *this;
 }
 
-Vector3D &Vector3D::sub(double k)
-{
-    return sub(Vector3D(k, k, k));
-}
-
 Vector3D &Vector3D::sub(double x, double y, double z)
 {
-    return sub(Vector3D(x, y, z));
-}
-
-Vector3D& Vector3D::sub(const Vector3D &other)
-{
-    _x -= other._x;
-    _y -= other._y;
-    _z -= other._z;
-    return *this;
-}
-
-Vector3D &Vector3D::mult(double k)
-{
-    _x *= k;
-    _y *= k;
-    _z *= k;
-    return *this;
-}
-
-Vector3D &Vector3D::div(double k)
-{
-    _x /= k;
-    _y /= k;
-    _z /= k;
+    _scalars[0] -= x;
+    _scalars[1] -= y;
+    _scalars[2] -= z;
     return *this;
 }
 
@@ -116,120 +74,3 @@ double Vector3D::dotProduct(double x, double y, double z) const
 {
     return dotProduct(Vector3D(x, y, z));
 }
-
-double Vector3D::dotProduct(const Vector3D &other) const
-{
-    return (_x * other._x) + (_y * other._y) + (_z * other._z);
-}
-
-double Vector3D::norm() const
-{
-    return sqrt((_x * _x) + (_y * _y) + (_z * _z));
-}
-
-Vector3D Vector3D::operator+() const
-{
-    return *this;
-}
-
-Vector3D Vector3D::operator+(const double &k) const
-{
-    return Vector3D(*this).add(k);
-}
-
-Vector3D &Vector3D::operator+=(const double &k)
-{
-    return add(k);
-}
-
-Vector3D Vector3D::operator+(const Vector3D &other) const
-{
-    return Vector3D(*this).add(other);
-}
-
-Vector3D &Vector3D::operator+=(const Vector3D &other)
-{
-    return add(other);
-}
-
-Vector3D Vector3D::operator-() const
-{
-    return Vector3D(-_x, -_y, -_z);
-}
-
-Vector3D Vector3D::operator-(const double &k) const
-{
-    return Vector3D(*this).sub(k);
-}
-
-Vector3D &Vector3D::operator-=(const double &k)
-{
-    return sub(k);
-}
-
-Vector3D Vector3D::operator-(const Vector3D &other) const
-{
-    return Vector3D(*this).sub(other);
-}
-
-Vector3D &Vector3D::operator-=(const Vector3D &other)
-{
-    return sub(other);
-}
-
-Vector3D Vector3D::operator*(const double &k) const
-{
-    return Vector3D(*this).mult(k);
-}
-
-Vector3D &Vector3D::operator*=(const double &k)
-{
-    return mult(k);
-}
-
-double Vector3D::operator*(const Vector3D &other) const
-{
-    return Vector3D(*this).dotProduct(other);
-}
-
-Vector3D &Vector3D::operator*=(const Vector3D &other)
-{
-    dotProduct(other);
-    return *this;
-}
-
-Vector3D Vector3D::operator/(const double &k) const
-{
-    return Vector3D(*this).div(k);
-}
-
-Vector3D &Vector3D::operator/=(const double &k)
-{
-    return div(k);
-}
-
-bool Vector3D::operator==(const Vector3D &other) const
-{
-    return equal(other);
-}
-
-bool Vector3D::operator!=(const Vector3D &other) const
-{
-    return !equal(other);
-}
-
-bool Vector3D::operator!() const
-{
-    return isNull();
-}
-
-Vector3D::operator bool() const
-{
-    return !isNull();
-}
-
-
-QDebug operator<<(QDebug dbg, const Vector3D &v)
-{
-    return dbg.nospace() << "(" << v.getX() << ", " << v.getY() << ", " << v.getZ() << ")";
-}

UGameEngine/utils/vector3d.h

@@ -1,13 +1,14 @@
 #ifndef VECTOR3D_H
 #define VECTOR3D_H
 
-#include <QDebug>
+#include "vectorxd.h"
 
-class Vector3D
+class Vector3D: public VectorXD<3>
 {
 public:
     explicit Vector3D(double x = 0.0, double y = 0.0, double z = 0.0);
     Vector3D(const Vector3D& other);
+    Vector3D(const VectorXD<3>& other);
     virtual ~Vector3D();
 
     double getX() const;
@@ -19,59 +20,14 @@ public:
     double getZ() const;
     Vector3D& setZ(double z);
 
-    bool isNull() const;
-
-    bool equal(const Vector3D& other) const;
-
-    Vector3D& add(double k);
+    using VectorXD<3>::add;
     Vector3D& add(double x, double y, double z);
-    Vector3D& add(const Vector3D& other);
 
-    Vector3D& sub(double k);
+    using VectorXD<3>::sub;
     Vector3D& sub(double x, double y, double z);
-    Vector3D& sub(const Vector3D& other);
-
-    Vector3D& mult(double k);
-
-    Vector3D& div(double k);
 
+    using VectorXD<3>::dotProduct;
     double dotProduct(double x, double y, double z) const;
-    double dotProduct(const Vector3D& other) const;
-
-    double norm() const;
-
-    Vector3D operator+() const;
-    Vector3D operator+(const double& k) const;
-    Vector3D& operator+=(const double& k);
-    Vector3D operator+(const Vector3D& other) const;
-    Vector3D& operator+=(const Vector3D& other);
-
-    Vector3D operator-() const;
-    Vector3D operator-(const double& k) const;
-    Vector3D& operator-=(const double& k);
-    Vector3D operator-(const Vector3D& other) const;
-    Vector3D& operator-=(const Vector3D& other);
-
-    Vector3D operator*(const double& k) const;
-    Vector3D& operator*=(const double& k);
-    double operator*(const Vector3D& other) const;
-    Vector3D& operator*=(const Vector3D& other);
-
-    Vector3D operator/(const double& k) const;
-    Vector3D& operator/=(const double& k);
-
-    bool operator==(const Vector3D& other) const;
-    bool operator!=(const Vector3D& other) const;
-
-    bool operator!() const;
-    operator bool() const;
-
-private:
-    double _x;
-    double _y;
-    double _z;
 };
 
-QDebug operator<<(QDebug dbg, const Vector3D& v);
-
 #endif // VECTOR3D_H

UGameEngine/utils/vectorxd.h

@@ -0,0 +1,72 @@
+#ifndef VECTORXD_H
+#define VECTORXD_H
+
+#include <QDebug>
+
+#define tmpl template<unsigned X>
+
+tmpl class VectorXD
+{
+public:
+    VectorXD();
+    VectorXD(const double scalars[X]);
+    VectorXD(const VectorXD<X>& other);
+
+    VectorXD<X>& setScalar(unsigned i, double value);
+    double getScalar(unsigned i);
+
+    bool isNull() const;
+
+    bool equal(const VectorXD<X>& other) const;
+
+    VectorXD<X>& add(double k);
+    VectorXD<X>& add(double scalars[X]);
+    VectorXD<X>& add(const VectorXD<X>& other);
+
+    VectorXD<X>& sub(double k);
+    VectorXD<X>& sub(double scalars[X]);
+    VectorXD<X>& sub(const VectorXD<X>& other);
+
+    VectorXD<X>& mult(double k);
+
+    VectorXD<X>& div(double k);
+
+    double dotProduct(const VectorXD<X>& other) const;
+
+    double norm() const;
+
+    VectorXD<X> operator+() const;
+    VectorXD<X> operator+(const double& k) const;
+    VectorXD<X>& operator+=(const double& k);
+    VectorXD<X> operator+(const VectorXD<X>& other) const;
+    VectorXD<X>& operator+=(const VectorXD<X>& other);
+
+    VectorXD<X> operator-() const;
+    VectorXD<X> operator-(const double& k) const;
+    VectorXD<X>& operator-=(const double& k);
+    VectorXD<X> operator-(const VectorXD<X>& other) const;
+    VectorXD<X>& operator-=(const VectorXD<X>& other);
+
+    VectorXD<X> operator*(const double& k) const;
+    VectorXD<X>& operator*=(const double& k);
+    double operator*(const VectorXD<X>& other) const;
+    VectorXD<X>& operator*=(const VectorXD<X>& other);
+
+    VectorXD<X> operator/(const double& k) const;
+    VectorXD<X>& operator/=(const double& k);
+
+    bool operator==(const VectorXD<X>& other) const;
+    bool operator!=(const VectorXD<X>& other) const;
+
+    bool operator!() const;
+    operator bool() const;
+
+protected:
+    double _scalars[X];
+};
+
+tmpl QDebug operator<<(QDebug dbg, const VectorXD<X>& v);
+
+#include "vectorxd.hxx"
+
+#endif // VECTORXD_H

UGameEngine/utils/vectorxd.hxx

@@ -0,0 +1,238 @@
+#include <math.h>
+
+#define tmpl template<unsigned X>
+
+tmpl VectorXD<X>::VectorXD()
+{
+    for (unsigned i = 0; i < X; ++i) {
+        _scalars[i] = 0;
+    }
+}
+
+tmpl VectorXD<X>::VectorXD(const double scalars[X])
+{
+    for (unsigned i = 0; i < X; ++i) {
+        _scalars[i] = scalars[i];
+    }
+}
+
+tmpl VectorXD<X>::VectorXD(const VectorXD<X>& other)
+{
+    for (unsigned i = 0; i < X; ++i) {
+        _scalars[i] = other._scalars[i];
+    }
+}
+
+tmpl VectorXD<X>& VectorXD<X>::setScalar(unsigned i, double value)
+{
+    _scalars[i] = value;
+    return *this;
+}
+
+tmpl double VectorXD<X>::getScalar(unsigned i)
+{
+    return _scalars[i];
+}
+
+tmpl bool VectorXD<X>::isNull() const
+{
+    return equal(VectorXD<X>());
+}
+
+tmpl bool VectorXD<X>::equal(const VectorXD<X> &other) const
+{
+    for (unsigned i = 0; i < X; ++i) {
+        if (_scalars[i] != other._scalars[i]) {
+            return false;
+        }
+    }
+    return true;
+}
+
+tmpl VectorXD<X> &VectorXD<X>::add(double k)
+{
+    double scalars[X];
+    for (unsigned i = 0; i < X; ++i) {
+        scalars[i] = k;
+    }
+    return add(VectorXD<X>(scalars));
+}
+
+tmpl VectorXD<X> &VectorXD<X>::add(double scalars[X])
+{
+    return add(VectorXD<X>(scalars));
+}
+
+tmpl VectorXD<X>& VectorXD<X>::add(const  VectorXD<X> &other)
+{
+    for (unsigned i = 0; i < X; ++i) {
+        _scalars[i] += other._scalars[i];
+    }
+    return *this;
+}
+
+tmpl VectorXD<X> &VectorXD<X>::sub(double k)
+{
+    double scalars[X];
+    for (unsigned i = 0; i < X; ++i) {
+        scalars[i] = k;
+    }
+    return sub(VectorXD<X>(scalars));
+}
+
+tmpl VectorXD<X> &VectorXD<X>::sub(double scalars[X])
+{
+    return sub(VectorXD<X>(scalars));
+}
+
+tmpl VectorXD<X>& VectorXD<X>::sub(const VectorXD<X> &other)
+{
+    for (unsigned i = 0; i < X; ++i) {
+        _scalars[i] -= other._scalars[i];
+    }
+    return *this;
+}
+
+tmpl VectorXD<X> &VectorXD<X>::mult(double k)
+{
+    for (unsigned i = 0; i < X; ++i) {
+        _scalars[i] *= k;
+    }
+    return *this;
+}
+
+tmpl VectorXD<X> &VectorXD<X>::div(double k)
+{
+    for (unsigned i = 0; i < X; ++i) {
+        _scalars[i] /= k;
+    }
+    return *this;
+}
+
+tmpl double VectorXD<X>::dotProduct(const VectorXD<X> &other) const
+{
+    double total = 0;
+    for (unsigned i = 0; i < X; ++i) {
+        total += _scalars[i] * other._scalars[i];
+    }
+    return total;
+}
+
+tmpl double VectorXD<X>::norm() const
+{
+    double total = 0;
+    for (unsigned i = 0; i < X; ++i) {
+        total += _scalars[i] * _scalars[i];
+    }
+    return sqrt(total);
+}
+
+tmpl VectorXD<X> VectorXD<X>::operator+() const
+{
+    return *this;
+}
+
+tmpl VectorXD<X> VectorXD<X>::operator+(const double &k) const
+{
+    return VectorXD(*this).add(k);
+}
+
+tmpl VectorXD<X> &VectorXD<X>::operator+=(const double &k)
+{
+    return add(k);
+}
+
+tmpl VectorXD<X> VectorXD<X>::operator+(const VectorXD<X> &other) const
+{
+    return VectorXD<X>(*this).add(other);
+}
+
+tmpl VectorXD<X> &VectorXD<X>::operator+=(const VectorXD<X> &other)
+{
+    return add(other);
+}
+
+tmpl VectorXD<X> VectorXD<X>::operator-() const
+{
+    double scalars[X];
+    for (unsigned i = 0; i < X; ++i) {
+        scalars[i] = -_scalars[i];
+    }
+    return VectorXD<X>(scalars);
+}
+
+tmpl VectorXD<X> VectorXD<X>::operator-(const double &k) const
+{
+    return VectorXD(*this).sub(k);
+}
+
+tmpl VectorXD<X> &VectorXD<X>::operator-=(const double &k)
+{
+    return sub(k);
+}
+
+tmpl VectorXD<X> VectorXD<X>::operator-(const VectorXD<X> &other) const
+{
+    return VectorXD(*this).sub(other);
+}
+
+tmpl VectorXD<X> &VectorXD<X>::operator-=(const VectorXD<X> &other)
+{
+    return sub(other);
+}
+
+tmpl VectorXD<X> VectorXD<X>::operator*(const double &k) const
+{
+    return VectorXD<X>(*this).mult(k);
+}
+
+tmpl VectorXD<X> &VectorXD<X>::operator*=(const double &k)
+{
+    return mult(k);
+}
+
+tmpl double VectorXD<X>::operator*(const VectorXD<X> &other) const
+{
+    return VectorXD<X>(*this).dotProduct(other);
+}
+
+tmpl VectorXD<X> &VectorXD<X>::operator*=(const VectorXD<X> &other)
+{
+    dotProduct(other);
+    return *this;
+}
+
+tmpl VectorXD<X> VectorXD<X>::operator/(const double &k) const
+{
+    return VectorXD<X>(*this).div(k);
+}
+
+tmpl VectorXD<X> &VectorXD<X>::operator/=(const double &k)
+{
+    return div(k);
+}
+
+tmpl bool VectorXD<X>::operator==(const VectorXD<X> &other) const
+{
+    return equal(other);
+}
+
+tmpl bool VectorXD<X>::operator!=(const VectorXD<X> &other) const
+{
+    return !equal(other);
+}
+
+tmpl bool VectorXD<X>::operator!() const
+{
+    return isNull();
+}
+
+tmpl VectorXD<X>::operator bool() const
+{
+    return !isNull();
+}
+
+tmpl QDebug operator<<(QDebug dbg, const VectorXD<X> &v)
+{
+    return dbg.nospace() << "(" << v.getX() << ", " << v.getY() << ", " << v.getZ() << ")";
+}