--- /dev/null
+
+/*******************************************************************************
+
+ Copyright (c) 2009, Charles McGarvey
+ All rights reserved.
+
+ Redistribution and use in source and binary forms, with or without
+ modification, are permitted provided that the following conditions are met:
+
+ * Redistributions of source code must retain the above copyright notice,
+ this list of conditions and the following disclaimer.
+ * Redistributions in binary form must reproduce the above copyright notice,
+ this list of conditions and the following disclaimer in the documentation
+ and/or other materials provided with the distribution.
+
+ THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+ FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+ OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+*******************************************************************************/
+
+#ifndef _VECTOR_HH_
+#define _VECTOR_HH_
+
+/**
+ * @file vector.hh
+ * Vector classes.
+ */
+
+#include <iostream>
+#include <cassert>
+
+#include "math.hh"
+#include "random.hh"
+
+
+// TODO: project, reflect, random, normal (of plane), orthonormal
+
+namespace dc {
+
+/**
+ * 2-dimensional vector.
+ */
+
+struct vector2
+{
+ vector2() {}
+ vector2(scalar X, scalar Y) : x(X), y(Y) {}
+ vector2(scalar v[2]) : x(v[0]), y(v[1]) {}
+
+ const scalar& operator[](int i) const
+ {
+ assert(i >= 0 && i <= 1 && "Index into vector2 out of bounds.");
+ return array[i];
+ }
+ scalar& operator[](int i)
+ {
+ assert(i >= 0 && i <= 1 && "Index into vector2 out of bounds.");
+ return array[i];
+ }
+
+ vector2 operator+(const vector2& v) const
+ {
+ return vector2(x + v.x, y + v.y);
+ }
+ vector2 operator-(const vector2& v) const
+ {
+ return vector2(x - v.x, y - v.y);
+ }
+ vector2 operator*(scalar s) const
+ {
+ return vector2(x * s, y * s);
+ }
+ vector2 operator/(scalar s) const
+ {
+ return vector2(x / s, y / s);
+ }
+
+ vector2& operator+=(const vector2& v)
+ {
+ x += v.x; y += v.y;
+ return *this;
+ }
+ vector2& operator-=(const vector2& v)
+ {
+ x -= v.x; y -= v.y;
+ return *this;
+ }
+ vector2& operator*=(scalar s)
+ {
+ x *= s; y *= s;
+ return *this;
+ }
+ vector2& operator/=(scalar s)
+ {
+ x /= s; y /= s;
+ return *this;
+ }
+
+ vector2 operator-() const
+ {
+ return vector2(-x, -y);
+ }
+
+ scalar dot(const vector2& v) const /// dot product
+ {
+ return x * v.x + y * v.y;
+ }
+ scalar angleBetween(const vector2& v) const
+ {
+ scalar lens = length() * v.length();
+ if (lens == 0.0) { return HUGE_VAL; }
+ return std::acos(dot(v) / lens);
+ }
+
+ void normalize() /// scale such that length is one
+ {
+ scalar len = length();
+ if (len != 0.0) { *this /= len; }
+ }
+ vector2 normalized() const
+ {
+ scalar len = length();
+ if (len != 0.0) { return *this / len; }
+ return vector2(0.0, 0.0);
+ }
+
+ scalar length2() const /// magnitude squared
+ {
+ return dot(*this);
+ }
+ scalar length() const /// magnitude
+ {
+ return std::sqrt(length2());
+ }
+
+ bool operator==(const vector2& v) const
+ {
+ return equals(x, v.x) && equals(y, v.y);
+ }
+ bool operator!=(const vector2& v) const
+ {
+ return !(*this == v);
+ }
+
+
+ static vector2 random()
+ {
+ vector2 v = random(-1.0, 1.0);
+ v.normalize();
+ return v;
+ }
+
+ static vector2 random(scalar lower, scalar upper)
+ {
+ return vector2(rng::get<scalar>(lower, upper),
+ rng::get<scalar>(lower, upper));
+ }
+
+
+ union
+ {
+ struct
+ {
+ scalar x, y; ///< euler coordinates
+ };
+ scalar array[2]; ///< array
+ };
+
+ static vector2 zero; ///< zero vector
+};
+
+inline vector2 operator*(scalar s, const vector2& v)
+{
+ return v * s;
+}
+inline vector2 operator/(scalar s, const vector2& v)
+{
+ return vector2(s / v.x, s / v.y);
+}
+
+inline std::ostream& operator<<(std::ostream& output, const vector2& v)
+{
+ output << "(" << v.x << "," << v.y << ")";
+ return output;
+}
+
+
+typedef vector2 point;
+
+
+//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+/**
+ * 3-dimensional vector.
+ */
+
+struct vector3
+{
+ vector3() {}
+ vector3(scalar X, scalar Y, scalar Z) : x(X), y(Y), z(Z) {}
+ vector3(scalar v[3]) : x(v[0]), y(v[1]), z(v[2]) {}
+
+ const scalar& operator[](int i) const
+ {
+ assert(i >= 0 && i <= 2 && "Index into vector3 out of bounds.");
+ return array[i];
+ }
+ scalar& operator[](int i)
+ {
+ assert(i >= 0 && i <= 2 && "Index into vector3 out of bounds.");
+ return array[i];
+ }
+
+ vector3 operator+(const vector3& v) const
+ {
+ return vector3(x + v.x, y + v.y, z + v.z);
+ }
+ vector3 operator-(const vector3& v) const
+ {
+ return vector3(x - v.x, y - v.y, z - v.z);
+ }
+ vector3 operator*(scalar s) const
+ {
+ return vector3(x * s, y * s, z * s);
+ }
+ vector3 operator/(scalar s) const
+ {
+ return vector3(x / s, y / s, z / s);
+ }
+
+ vector3& operator+=(const vector3& v)
+ {
+ x += v.x; y += v.y; z += v.z;
+ return *this;
+ }
+ vector3& operator-=(const vector3& v)
+ {
+ x -= v.x; y -= v.y; z -= v.z;
+ return *this;
+ }
+ vector3& operator*=(scalar s)
+ {
+ x *= s; y *= s; z *= s;
+ return *this;
+ }
+ vector3& operator/=(scalar s)
+ {
+ x /= s; y /= s; z /= s;
+ return *this;
+ }
+
+ vector3 operator-() const
+ {
+ return vector3(-x, -y, -z);
+ }
+
+ scalar dot(const vector3& v) const /// dot product
+ {
+ return x * v.x + y * v.y + z * v.z;
+ }
+ vector3 cross(const vector3& v) const /// cross product
+ {
+ return vector3(y * v.z - z * v.y,
+ z * v.x - x * v.z,
+ x * v.y - y * v.x);
+ }
+
+ scalar angleBetween(const vector3& v) const
+ {
+ scalar lens = length() * v.length();
+ if (lens == 0.0) { return HUGE_VAL; }
+ return std::acos(dot(v) / lens);
+ }
+
+ void normalize() /// scale such that length is one
+ {
+ scalar len = length();
+ if (len != 0.0) { *this /= len; }
+ }
+ vector3 normalized() const
+ {
+ scalar len = length();
+ if (len != 0.0) { return *this / len; }
+ return vector3(0.0, 0.0, 0.0);
+ }
+
+ scalar length2() const /// magnitude squared
+ {
+ return dot(*this);
+ }
+ scalar length() const /// magnitude
+ {
+ return std::sqrt(length2());
+ }
+
+ bool operator==(const vector3& v) const
+ {
+ return equals(x, v.x) && equals(y, v.y) && equals(z, v.z);
+ }
+ bool operator!=(const vector3& v) const
+ {
+ return !(*this == v);
+ }
+
+
+ static vector3 random()
+ {
+ vector3 v = random(-1.0, 1.0);
+ v.normalize();
+ return v;
+ }
+
+ static vector3 random(scalar lower, scalar upper)
+ {
+ return vector3(rng::get<scalar>(lower, upper),
+ rng::get<scalar>(lower, upper),
+ rng::get<scalar>(lower, upper));
+ }
+
+
+ union
+ {
+ struct
+ {
+ scalar x, y, z; ///< euler coordinates
+ };
+ struct
+ {
+ scalar u, v, w; ///< texture coordinates
+ };
+ struct
+ {
+ scalar r, g, b; ///< color intensities
+ };
+ scalar array[3]; ///< array
+ };
+
+ static vector3 zero; ///< zero vector
+};
+
+inline vector3 operator*(scalar s, const vector3& v)
+{
+ return v * s;
+}
+inline vector3 operator/(scalar s, const vector3& v)
+{
+ return vector3(s / v.x, s / v.y, s / v.z);
+}
+
+inline std::ostream& operator<<(std::ostream& output, const vector3& v)
+{
+ output << "(" << v.x << "," << v.y << "," << v.z << ")";
+ return output;
+}
+
+
+typedef vector3 color;
+
+
+} // namespace dc
+
+
+#endif // _VECTOR_HH_
+
projects / chaz / yoink / blobdiff