1

#ifndef VECTOR_HH

     2

#define VECTOR_HH

     3

     4

#include <iostream>

     5

#include <cmath>

     6

     7

/**

     8

 * A 2D Vector class. Implements standard vector operations.

     9

 */

    10

template <typename T> class VectorType {

    11

public:

    12

    /** Horizontal component */

    13

    T x;

    14

    /** Vertical component */

    15

    T y;

    16

    17

    /**

    18

     * Default constructor. Values are zero

    19

     */

    20

    VectorType() : 

    21

        x(0), y(0) 

    22

    {

    23

    24

    }

    25

    26

    /**

    27

     * Scalar constuctor.

    28

     *

    29

     * @param x Initial x-coordinate

    30

     * @param y Initial y-coordinate

    31

     */

    32

    VectorType (const T &x, const T &y) : 

    33

        x(x), y(y) 

    34

    {

    35

    36

    }

    37

    38

    /**

    39

     * Copy constructor.

    40

     *

    41

     * @param v Vector to be copied.

    42

     */

    43

    VectorType (const VectorType &v) : 

    44

        x(v.x), 

    45

        y(v.y) 

    46

    {

    47

    48

    }

    49

    50

    /**

    51

     * @name Standard operators

    52

     *

    53

     * @{

    54

     */

    55

    VectorType& operator= (const VectorType &v) {

    56

        x = v.x;

    57

        y = v.y;

    58

    59

        return *this;

    60

    }

    61

    62

    VectorType operator+ (const VectorType &v) const {

    63

        return VectorType(x + v.x, y + v.y);

    64

    }

    65

    66

    VectorType operator- (const VectorType &v) const {

    67

        return VectorType(x - v.x, y - v.y);

    68

    }

    69

    70

    /** Unary minus (v + -v = 0) */

    71

    VectorType operator- (void) const {

    72

        return VectorType(-x, -y);

    73

    }

    74

    75

    /** Scalar multiplication */

    76

    VectorType operator* (const T &scalar) const {

    77

        return VectorType(x * scalar, y * scalar);

    78

    }

    79

    80

    /** Scalar division */

    81

    VectorType operator/ (const T &scalar) const {

    82

        return VectorType(x / scalar, y / scalar);

    83

    }

    84

    85

    /** Dot product */

    86

    T operator* (const VectorType &v) const {

    87

        return (x * v.x + y * v.y);

    88

    }

    89

    90

    void operator+= (const VectorType &v) {

    91

        x += v.x;

    92

        y += v.y;

    93

    }

    94

    95

    void operator-= (const VectorType &v) {

    96

        x -= v.x;

    97

        y -= v.y;

    98

    }

    99

   100

    void operator*= (const T &scalar) {

   101

        x *= scalar;

   102

        y *= scalar;

   103

    }

   104

   105

    void operator/= (const T &scalar) {

   106

        x /= scalar;

   107

        y /= scalar;

   108

    }

   109

   110

    /**

   111

     * XXX: This needs to do some rounding for float-vectors

   112

     */

   113

    bool operator== (const VectorType &other) const {

   114

        return (x == other.x) && (y ==  other.y);

   115

    }

   116

   117

    /**

   118

     * XXX: This needs to do some rounding for float-vectors

   119

     */

   120

    bool operator!= (const VectorType &other) const {

   121

        return (x != other.x) || (y !=  other.y);

   122

    }

   123

   124

    // @}

   125

   126

    /**

   127

     * Vector scalar length

   128

     */

   129

    T length (void) const {

   130

        return sqrt(sqrLength());

   131

    }

   132

   133

    /**

   134

     * Vector scalar length, squared

   135

     */

   136

    T sqrLength (void) const {

   137

        return (x * x) + (y * y);

   138

    }

   139

   140

    /**

   141

     * XXX: should be replaced with a working operator== implementation

   142

     *

   143

     * This doesn't actually *round*, it *truncates*

   144

     */

   145

    VectorType roundToInt (void) const {

   146

        return VectorType((int)(x), (int)(y));

   147

    }

   148

   149

    /**

   150

     * Test for a zero-length vector.

   151

     *

   152

     * XXX: this is currently only used when testing for Vector(0, 0), probably breaks otherwise

   153

     */

   154

    bool zero (void) const {

   155

        return x == 0 && y == 0;

   156

    }

   157

   158

    /**

   159

     * Returns the corresponding unit vector, i.e. the vector divided by its own length

   160

     *

   161

     * @return Vector with length() == 1

   162

     */

   163

    VectorType unitVector (void) const {

   164

        T len = length();

   165

   166

        return VectorType(x / len, y / len);

   167

    }

   168

   169

    /**

   170

     * Returns a normalized vector such that the x/y coordinates are both either -1, 0 or 1, to indicate which

   171

     * direction this vector points in.

   172

     *

   173

     * @return normalized Vector

   174

     */

   175

    VectorType normalizeDirection (void) const;

   176

   177

    /**

   178

     * Returns a vector's normal (one of the two)

   179

     */

   180

    VectorType normal (void) const {

   181

        return VectorType(y, -x);

   182

    }

   183

   184

};

   185

   186

/**

   187

 * @name Postfix operators

   188

 * Operators with the vector as the second argument :)

   189

 *

   190

 * @{

   191

 */

   192

template<typename T> VectorType<T> operator* (const T &scalar, const VectorType<T> &v) {

   193

    return (v * scalar);

   194

} 

   195

   196

/**

   197

 * Make vectors printable

   198

 */

   199

template<typename T> std::ostream& operator<< (std::ostream &s, const VectorType<T> &v) {

   200

    return s << "(" << v.x << ", " << v.y << ")";

   201

}

   202

   203

/*

   204

 * Vector template method implementation

   205

 */

   206

   207

/**

   208

 * Direction-normalize the given coordinate against the tangent coordinate.

   209

 *

   210

 * Returns 1 if the coordinate is positive and greater than the tangent, -1 if the coordinate is less than and

   211

 * negative, else zero.

   212

 */

   213

template<typename T> static T normalizeCoordinate (T coord, T tangent) {

   214

    // XXX: use hand-crafted abs because GCC 4.3/4.2 static template functions seem to be broken somehow

   215

    if (coord > (tangent < 0 ? -tangent : tangent))

   216

        return 1;

   217

   218

    else if (coord < (tangent > 0 ? -tangent : tangent))

   219

        return -1;

   220

   221

    else

   222

        return 0;

   223

}

   224

   225

template<typename T> VectorType<T> VectorType<T>::normalizeDirection (void) const {

   226

    return VectorType<T>(

   227

        normalizeCoordinate(x, y),

   228

        normalizeCoordinate(y, x)

   229

    );

   230

}

   231

   232

#endif