---

Vertex3.h

/*
  File: Vertex3.h

  Copyright(C) C. Kotterink, Computed Graphics
*/
#ifndef VERTEX3_H
#define VERTEX3_H

#include<real.h>

#include<iostream>
#include<algorithm>

class Vertex4;
class ObjectFile;

class Vertex3
{
public:
    typedef enum Component { X, Y, Z };

    // Constructors
    Vertex3() {};
    Vertex3(real xx, real yy, real zz) : x(xx), y(yy), z(zz) {}
    Vertex3(const Vertex3 &v) : x(v.x), y(v.y), z(v.z) {}

    // Get
    real &operator [](unsigned int i) {
        return ((real*)(this))[i];
    }

    Component largestComponent() const;
    Vertex3 &lerp(Vertex3 &from, Vertex3 &to, float t);

    // Assignment operators
    Vertex3 &operator =(const Vertex3 &v) {
        x = v.x;
        y = v.y;
        z = v.z;
        return *this;
    }
    Vertex3 &operator =(const Vertex4 &v);
    void operator -=(const Vertex3 &v) {
        x -= v.x;
        y -= v.y;
        z -= v.z;
    }
    void operator += (const Vertex3 &v) {
        x += v.x;
        y += v.y;
        z += v.z;
    }
    void operator *=(real r) {
        x *= r;
        y *= r;
        z *= r;
    }
    void operator /=(real r) {
        x /= r;
        y /= r;
        z /= r;
    }
    void operator &=(const Vertex3 &v) {        // Cross product
        real xx = x;
        real yy = y;
        x = y*v.z - z*v.y;
        y = z*v.x - xx*v.z;
        z = xx*v.y - yy*v.x;
    }

    // Operators
    Vertex3 operator -(const Vertex3 &v) const {
        Vertex3 vv(x - v.x, y - v.y, z - v.z);
        return vv;
    }
    Vertex3 operator +(const Vertex3 &v) const {
        Vertex3 vv(x + v.x, y + v.y, z + v.z);
        return vv;
    }
    Vertex3 operator *(real r) const {
        Vertex3 v(x * r, y * r, z * r);
        return v;
    }
    Vertex3 operator /(real r) const {
        Vertex3 v(x / r, y / r, z / r);
        return v;
    }
    real operator *(const Vertex3 &v) const {
        return x*v.x + y*v.y + z*v.z;
    }
    Vertex3 operator &(const Vertex3 &v) const {
        Vertex3 vv;
        vv.x = y*v.z - z*v.y;
        vv.y = z*v.x - x*v.z;
        vv.z = x*v.y - y*v.x;
        return vv;
    }

    real sqrNorm() const {
        return x*x + y*y + z*z;
    }
    real norm() const {
        return (real)sqrt(x*x + y*y + z*z);
    }
    real maxNorm() {
        return max(x, max(y, z));
    }
    Vertex3 &normalize();
    Vertex3 &setLength(real s) {
        *this *= (s/norm());
        return *this;
    }
    Vertex3 &invert() {
        x = -x;
        y = -y;
        z = -z;
        return *this;
    }

    // 3D Transformation, righthanded

    Vertex3 &scale(Vertex3 &v);
    Vertex3 &rotateX(real alpha);
    Vertex3 &rotateY(real alpha);
    Vertex3 &rotateZ(real alpha);

    real x, y, z;
};
inline Vertex3 operator *(real r, const Vertex3 &vv)
{
    Vertex3 v(vv.x * r, vv.y * r, vv.z * r);
    return v;
}

ostream &operator<<(ostream &stream, const Vertex3 &v);
ObjectFile &operator>>(ObjectFile &f, Vertex3 &v);
#endif

---

This documentation was generated using doxygen. If you have any comments or additions please mail me.