+++ /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