added vector cross product; added signals in ugeentities

UGameEngine/entities/ugeentity.cpp

 void UGEEntity::setPosition(const Vector3D &position)
 {
     _position = position;
+    emit positionChanged();
+    emit positionChanged(_position);
 }
 
 void UGEEntity::move(const Vector3D &move)
 {
     _position += move;
+    emit positionChanged();
+    emit positionChanged(_position);
 }
 
-Vector3D UGEEntity::getSpeed() const
-{
-    return _speed;
-}
+//Vector3D UGEEntity::getSpeed() const
+//{
+//    return _speed;
+//}
 
-void UGEEntity::setSpeed(const Vector3D &speed)
-{
-    _speed = speed;
-}
+//void UGEEntity::setSpeed(const Vector3D &speed)
+//{
+//    _speed = speed;
+//}
 
-void UGEEntity::accelerate(const Vector3D &speed)
-{
-    _speed += speed;
-}
+//void UGEEntity::accelerate(const Vector3D &speed)
+//{
+//    _speed += speed;
+//}
 
 Vector3D UGEEntity::getRotation() const
 {
 void UGEEntity::setRotation(const Vector3D &rotation)
 {
     _rotation = rotation;
+    emit rotationChanged();
+    emit rotationChanged(rotation);
 }
 
 void UGEEntity::rotate(const Vector3D &rotation)
 {
     _rotation += rotation;
+    emit rotationChanged();
+    emit rotationChanged(rotation);
 }
 
 Vector3D UGEEntity::getScale() const
 void UGEEntity::setScale(const Vector3D &scale)
 {
     _scale = scale;
+    emit scaleChanged();
+    emit scaleChanged(_scale);
 }
 
 void UGEEntity::scale(const Vector3D &scale)
 {
     _scale += scale;
+    emit scaleChanged();
+    emit scaleChanged(_scale);
 }
 bool UGEEntity::isVisible() const
 {
 void UGEEntity::setVisible(bool visible)
 {
     _visible = visible;
+    emit visibilityChanged();
+    emit visibilityChanged(_visible);
 }
 
 void UGEEntity::show()
 {
     _visible = true;
+    emit visibilityChanged();
+    emit visibilityChanged(_visible);
 }
 
 void UGEEntity::hide()
 {
     _visible = false;
+    emit visibilityChanged();
+    emit visibilityChanged(_visible);
+}
+
+QColor UGEEntity::getColor() const
+{
+    return _color;
+}
+
+void UGEEntity::setColor(const QColor &color)
+{
+    _color = color;
+    emit colorChanged();
+    emit colorChanged(_color);
 }
 
 Vector3D UGEEntity::getRealPoint(const Vector3D &pos)
 {
-    return pos + _position;
+    Vector3D p = pos + _position;
+    return p;
 }
 
 ColorVector3D UGEEntity::getRealPoint(const ColorVector3D &pos)

UGameEngine/entities/ugeentity.h

     void setPosition(const Vector3D& position);
     void move(const Vector3D& move);
 
-    Vector3D getSpeed() const;
-    void setSpeed(const Vector3D& speed);
-    void accelerate(const Vector3D& speed);
+//    Vector3D getSpeed() const;
+//    void setSpeed(const Vector3D& speed);
+//    void accelerate(const Vector3D& speed);
 
     Vector3D getRotation() const;
     void setRotation(const Vector3D& rotation);
     void show();
     void hide();
 
+    QColor getColor() const;
+    void setColor(const QColor &color);
+
     Vector3D getRealPoint(const Vector3D& pos);
     ColorVector3D getRealPoint(const ColorVector3D& pos);
     TextureVector3D getRealPoint(const TextureVector3D& pos);
 
     virtual void draw(AbstractRenderDevice* device) = 0;
 
+signals:
+    void positionChanged();
+    void positionChanged(const Vector3D& position);
+
+    void rotationChanged();
+    void rotationChanged(const Vector3D& rotation);
+
+    void scaleChanged();
+    void scaleChanged(const Vector3D& scale);
+
+    void visibilityChanged();
+    void visibilityChanged(bool visible);
+
+    void colorChanged();
+    void colorChanged(QColor color);
+
 private:
     Vector3D _position;
 
-    Vector3D _speed;
+//    Vector3D _speed;
 
     Vector3D _rotation;
 
 
     bool _visible;
 
+    QColor _color;
+
 };
 
 #endif // UGEENTITY_H

UGameEngine/entities/ugeentitycube.cpp

     : UGEEntity(parent)
     , _size(1.0)
 {
+    updateFaces();
+    connect(this, SIGNAL(colorChanged()), this, SLOT(updateFaces()));
+    connect(this, SIGNAL(sizeChanged()), this, SLOT(updateFaces()));
+    connect(this, SIGNAL(textureChanged()), this, SLOT(updateFaces()));
 }
 
-float UGEEntityCube::getSize() const
+double UGEEntityCube::getSize() const
 {
     return _size;
 }
 
 void UGEEntityCube::draw(AbstractRenderDevice *device)
 {
-    float r = _size / 2;
-    if (_textureId.isNull()) {
-        QColor color = Qt::red;
-        QList<ColorVector3D> points;
-        points << ColorVector3D(color, -r, -r, r)  << ColorVector3D(color, -r, r, r)
-               << ColorVector3D(color, r, r, r)    << ColorVector3D(color, r, -r, r)
-               << ColorVector3D(color, -r, -r, -r) << ColorVector3D(color, -r, r, -r)
-               << ColorVector3D(color, r, r, -r)   << ColorVector3D(color, r, -r, -r);
-        drawPolygon(device, QList<ColorVector3D>() << points[3] << points[2] << points[1] << points[0]);
-        drawPolygon(device, QList<ColorVector3D>() << points[2] << points[3] << points[7] << points[6]);
-        drawPolygon(device, QList<ColorVector3D>() << points[6] << points[7] << points[4] << points[5]);
-        drawPolygon(device, QList<ColorVector3D>() << points[5] << points[4] << points[0] << points[1]);
-        drawPolygon(device, QList<ColorVector3D>() << points[1] << points[2] << points[6] << points[5]);
-        drawPolygon(device, QList<ColorVector3D>() << points[4] << points[7] << points[3] << points[0]);
+    if (!_facesColor.empty()) {
+        for (int i = 0; i < _facesColor.size(); ++i) {
+            drawPolygon(device, _facesColor[i]);
+        }
     }
     else {
-        QColor color = Qt::white;
-        drawPolygonTexture(device, QList<TextureVector3D>() << TextureVector3D(Vector2D(0.25, 0.50), color, r, -r, r)
-                           << TextureVector3D(Vector2D(0.25, 0.25), color, r, r, r)
-                           << TextureVector3D(Vector2D(0.00, 0.25), color, -r, r, r)
-                           << TextureVector3D(Vector2D(0.00, 0.50), color, -r, -r, r), _textureId);
-        drawPolygonTexture(device, QList<TextureVector3D>() << TextureVector3D(Vector2D(0.25, 0.50), color, r, r, r)
-                           << TextureVector3D(Vector2D(0.25, 0.25), color, r, -r, r)
-                           << TextureVector3D(Vector2D(0.50, 0.25), color, r, -r, -r)
-                           << TextureVector3D(Vector2D(0.50, 0.50), color, r, r, -r), _textureId);
-        drawPolygonTexture(device, QList<TextureVector3D>() << TextureVector3D(Vector2D(0.50, 0.25), color, r, r, -r)
-                           << TextureVector3D(Vector2D(0.50, 0.50), color, r, -r, -r)
-                           << TextureVector3D(Vector2D(0.75, 0.50), color, -r, -r, -r)
-                           << TextureVector3D(Vector2D(0.75, 0.25), color, -r, r, -r), _textureId);
-        drawPolygonTexture(device, QList<TextureVector3D>() << TextureVector3D(Vector2D(0.75, 0.25), color, -r, r, -r)
-                           << TextureVector3D(Vector2D(0.75, 0.50), color, -r, -r, -r)
-                           << TextureVector3D(Vector2D(1.00, 0.50), color, -r, -r, r)
-                           << TextureVector3D(Vector2D(1.00, 0.25), color, -r, r, r), _textureId);
-        drawPolygonTexture(device, QList<TextureVector3D>() << TextureVector3D(Vector2D(0.25, 0.00), color, -r, r, r)
-                           << TextureVector3D(Vector2D(0.25, 0.25), color, r, r, r)
-                           << TextureVector3D(Vector2D(0.50, 0.25), color, r, r, -r)
-                           << TextureVector3D(Vector2D(0.50, 0.00), color, -r, r, -r), _textureId);
-        drawPolygonTexture(device, QList<TextureVector3D>() << TextureVector3D(Vector2D(0.50, 0.75), color, -r, -r, -r)
-                           << TextureVector3D(Vector2D(0.50, 0.50), color, r, -r, -r)
-                           << TextureVector3D(Vector2D(0.25, 0.5), color, r, -r, r)
-                           << TextureVector3D(Vector2D(0.25, 0.75), color, -r, -r, r), _textureId);
+        for (int i = 0; i < _facesTexture.size(); ++i) {
+            drawPolygonTexture(device, _facesTexture[i], _textureId);
+        }
     }
 }
 
-QVariant UGEEntityCube::getTextureId() const
+void UGEEntityCube::setSize(double size)
 {
-    return _textureId;
+    _size = size;
+    emit sizeChanged();
+    emit sizeChanged(_size);
 }
 
-void UGEEntityCube::setSize(float size)
+void UGEEntityCube::increaseSize(double size)
 {
-    _size = size;
+    _size += size;
+    emit sizeChanged();
+    emit sizeChanged(_size);
+}
+
+QVariant UGEEntityCube::getTextureId() const
+{
+    return _textureId;
 }
 
 void UGEEntityCube::setTextureId(const QVariant &textureId)
 {
     _textureId = textureId;
+    setColor(Qt::white);
+    emit textureChanged();
+    emit textureChanged(_textureId);
 }
 
-
+void UGEEntityCube::updateFaces()
+{
+    _facesColor.clear();
+    _facesTexture.clear();
+    double r = _size / 2;
+    if (_textureId.isNull()) {
+        QList<ColorVector3D> points;
+        points << ColorVector3D(getColor(), -r, -r, r)  << ColorVector3D(getColor(), -r, r, r)
+               << ColorVector3D(getColor(), r, r, r)    << ColorVector3D(getColor(), r, -r, r)
+               << ColorVector3D(getColor(), -r, -r, -r) << ColorVector3D(getColor(), -r, r, -r)
+               << ColorVector3D(getColor(), r, r, -r)   << ColorVector3D(getColor(), r, -r, -r);
+        _facesColor.append(QList<ColorVector3D>() << points[3] << points[2] << points[1] << points[0]);
+        _facesColor.append(QList<ColorVector3D>() << points[2] << points[3] << points[7] << points[6]);
+        _facesColor.append(QList<ColorVector3D>() << points[6] << points[7] << points[4] << points[5]);
+        _facesColor.append(QList<ColorVector3D>() << points[5] << points[4] << points[0] << points[1]);
+        _facesColor.append(QList<ColorVector3D>() << points[1] << points[2] << points[6] << points[5]);
+        _facesColor.append(QList<ColorVector3D>() << points[4] << points[7] << points[3] << points[0]);
+    }
+    else {
+        _facesTexture.append(QList<TextureVector3D>() << TextureVector3D(Vector2D(0.25, 0.50), getColor(), r, -r, r)
+                             << TextureVector3D(Vector2D(0.25, 0.25), getColor(), r, r, r)
+                             << TextureVector3D(Vector2D(0.00, 0.25), getColor(), -r, r, r)
+                             << TextureVector3D(Vector2D(0.00, 0.50), getColor(), -r, -r, r));
+        _facesTexture.append(QList<TextureVector3D>() << TextureVector3D(Vector2D(0.25, 0.50), getColor(), r, r, r)
+                             << TextureVector3D(Vector2D(0.25, 0.25), getColor(), r, -r, r)
+                             << TextureVector3D(Vector2D(0.50, 0.25), getColor(), r, -r, -r)
+                             << TextureVector3D(Vector2D(0.50, 0.50), getColor(), r, r, -r));
+        _facesTexture.append(QList<TextureVector3D>() << TextureVector3D(Vector2D(0.50, 0.25), getColor(), r, r, -r)
+                             << TextureVector3D(Vector2D(0.50, 0.50), getColor(), r, -r, -r)
+                             << TextureVector3D(Vector2D(0.75, 0.50), getColor(), -r, -r, -r)
+                             << TextureVector3D(Vector2D(0.75, 0.25), getColor(), -r, r, -r));
+        _facesTexture.append(QList<TextureVector3D>() << TextureVector3D(Vector2D(0.75, 0.25), getColor(), -r, r, -r)
+                             << TextureVector3D(Vector2D(0.75, 0.50), getColor(), -r, -r, -r)
+                             << TextureVector3D(Vector2D(1.00, 0.50), getColor(), -r, -r, r)
+                             << TextureVector3D(Vector2D(1.00, 0.25), getColor(), -r, r, r));
+        _facesTexture.append(QList<TextureVector3D>() << TextureVector3D(Vector2D(0.25, 0.00), getColor(), -r, r, r)
+                             << TextureVector3D(Vector2D(0.25, 0.25), getColor(), r, r, r)
+                             << TextureVector3D(Vector2D(0.50, 0.25), getColor(), r, r, -r)
+                             << TextureVector3D(Vector2D(0.50, 0.00), getColor(), -r, r, -r));
+        _facesTexture.append(QList<TextureVector3D>() << TextureVector3D(Vector2D(0.50, 0.75), getColor(), -r, -r, -r)
+                             << TextureVector3D(Vector2D(0.50, 0.50), getColor(), r, -r, -r)
+                             << TextureVector3D(Vector2D(0.25, 0.5), getColor(), r, -r, r)
+                             << TextureVector3D(Vector2D(0.25, 0.75), getColor(), -r, -r, r));
+    }
+}

UGameEngine/entities/ugeentitycube.h

 public:
     explicit UGEEntityCube(QObject *parent = 0);
 
-    float getSize() const;
-
-    virtual void draw(AbstractRenderDevice* device);
+    double getSize() const;
 
     QVariant getTextureId() const;
 
+    virtual void draw(AbstractRenderDevice* device);
+
 signals:
+    void sizeChanged();
+    void sizeChanged(double);
+
+    void textureChanged();
+    void textureChanged(const QVariant& textureId);
 
 public slots:
-    void setSize(float size);
+    void setSize(double size);
+    void increaseSize(double size);
+
     void setTextureId(const QVariant &textureId);
 
+private slots:
+    void updateFaces();
+
 private:
-    float _size;
+    double _size;
+
     QVariant _textureId;
 
+    QList<QList<TextureVector3D> > _facesTexture;
+
+    QList<QList<ColorVector3D> > _facesColor;
+
 };
 
 #endif // UGEENTITYCUBE_H

UGameEngine/utils/vectorxd.h

     VectorXD<X>& sub(const VectorXD<X>& other);
 
     VectorXD<X>& mult(double k);
+    VectorXD<X>& mult(const VectorXD<X>& k);
 
     VectorXD<X>& div(double k);
 
     double dotProduct(const VectorXD<X>& other) const;
+    VectorXD<X>& crossProduct(const VectorXD<X>& other);
 
     double norm() const;
 
 
     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) const;
     VectorXD<X>& operator*=(const VectorXD<X>& other);
 
     VectorXD<X> operator/(const double& k) const;

UGameEngine/utils/vectorxd.hxx

     return *this;
 }
 
+tmpl VectorXD<X> &VectorXD<X>::mult(const VectorXD<X> &other)
+{
+    for (unsigned i = 0; i < X; ++i) {
+        _scalars[i] *= other._scalars[i];
+    }
+    return *this;
+}
+
 tmpl VectorXD<X> &VectorXD<X>::div(double k)
 {
     for (unsigned i = 0; i < X; ++i) {
     return total;
 }
 
+tmpl VectorXD<X>& VectorXD<X>::crossProduct(const VectorXD<X>& other)
+{
+    VectorXD<X> t = *this;
+    for (unsigned i = 0; i < X; ++i) {
+        unsigned j = (i + 1) % X;
+        unsigned k = (i + 2) % X;
+        _scalars[i] = (t._scalars[j] * other._scalars[k]) - (t._scalars[k] * other._scalars[j]);
+    }
+    return *this;
+}
+
 tmpl double VectorXD<X>::norm() const
 {
     double total = 0;
     return mult(k);
 }
 
-tmpl double VectorXD<X>::operator*(const VectorXD<X> &other) const
+tmpl VectorXD<X> VectorXD<X>::operator*(const VectorXD<X> &other) const
 {
-    return VectorXD<X>(*this).dotProduct(other);
+    return VectorXD<X>(*this).mult(other);
 }
 
 tmpl VectorXD<X> &VectorXD<X>::operator*=(const VectorXD<X> &other)

tests/testvector3d.cpp

     void sub3Op();
 
     void mult();
-    void multOp();
+    void mult1Op();
+    void mult2Op();
+    void mult3Op();
 
     void div();
     void divOp();
 
     void dotProduct1();
-    void dotProduct1Op();
     void dotProduct2();
-    void dotProduct2Op();
+
+    void crossProduct1();
+    void crossProduct2();
 
     void norm1();
     void norm2();
     QCOMPARE(v.getZ(), z * m);
 }
 
-void TestVector3D::multOp()
+void TestVector3D::mult1Op()
 {
     double x = 1.42, y = 2.0, z = 3.0, m = 2.0;
     Vector3D v1(x, y, z);
     QCOMPARE(v.getZ(), z * m);
 }
 
+void TestVector3D::mult2Op()
+{
+    Vector3D v1(1.5, 2.0, 3.0);
+    Vector3D v2(42.0, 5.0, 7.0);
+    Vector3D v = v1 * v2;
+    QCOMPARE(v.getX(), v1.getX() * v2.getX());
+    QCOMPARE(v.getY(), v1.getY() * v2.getY());
+    QCOMPARE(v.getZ(), v1.getZ() * v2.getZ());
+}
+
+void TestVector3D::mult3Op()
+{
+    Vector3D v1(20.0, 42.0, 10.0);
+    Vector3D v2(42.0, 5.0, 7.0);
+    Vector3D v = v1 * v2;
+    QCOMPARE(v.getX(), v1.getX() * v2.getX());
+    QCOMPARE(v.getY(), v1.getY() * v2.getY());
+    QCOMPARE(v.getZ(), v1.getZ() * v2.getZ());
+}
+
 void TestVector3D::div()
 {
     double x = 1.42, y = 2.0, z = 3.0, m = 2.0;
     QCOMPARE(v1.dotProduct(v2), 94.0);
 }
 
-void TestVector3D::dotProduct1Op()
-{
-    Vector3D v1(1.5, 2.0, 3.0);
-    Vector3D v2(42.0, 5.0, 7.0);
-    QCOMPARE(v1 * v2, 94.0);
-}
-
 void TestVector3D::dotProduct2()
 {
     Vector3D v1(20, 42, 10);
     QCOMPARE(v1.dotProduct(v2), 1120.0);
 }
 
-void TestVector3D::dotProduct2Op()
+void TestVector3D::crossProduct1()
 {
-    Vector3D v1(20, 42, 10);
-    Vector3D v2(42.0, 5.0, 7.0);
-    QCOMPARE(v1 * v2, 1120.0);
+    Vector3D v(10.0, 42.0, 5.0);
+    Vector3D v2(9.0, 5.0, 4.0);
+    v.crossProduct(v2);
+    QCOMPARE(v.getX(), 143.0);
+    QCOMPARE(v.getY(), 5.0);
+    QCOMPARE(v.getZ(), -328.0);
+}
+
+void TestVector3D::crossProduct2()
+{
+    Vector3D v(10.0, 24.0, 8.0);
+    Vector3D v2(15.0, 5.0, 0.0);
+    v.crossProduct(v2);
+    QCOMPARE(v.getX(), -40.0);
+    QCOMPARE(v.getY(), 120.0);
+    QCOMPARE(v.getZ(), -310.0);
 }
 
 void TestVector3D::norm1()
 {
-    Vector3D v(3, 4, 0);;
+    Vector3D v(3.0, 4.0, 0.0);;
     QCOMPARE(v.norm(), 5.0);
 }
 
 void TestVector3D::norm2()
 {
-    Vector3D v(0, 30, 40);;
+    Vector3D v(0.0, 30.0, 40.0);;
     QCOMPARE(v.norm(), 50.0);
 }