e89a55d154
I didn't apply the changes to a few macro-heavy files as Visual Studio removes all indentation from macros, whereas the indentation can be handy to see nesting.
248 lines
11 KiB
C++
248 lines
11 KiB
C++
/*******************************************************************************
|
|
* The MIT License (MIT)
|
|
*
|
|
* Copyright (c) 2015 David Williams and Matthew Williams
|
|
*
|
|
* Permission is hereby granted, free of charge, to any person obtaining a copy
|
|
* of this software and associated documentation files (the "Software"), to deal
|
|
* in the Software without restriction, including without limitation the rights
|
|
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
|
* copies of the Software, and to permit persons to whom the Software is
|
|
* furnished to do so, subject to the following conditions:
|
|
*
|
|
* The above copyright notice and this permission notice shall be included in all
|
|
* copies or substantial portions of the Software.
|
|
*
|
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
|
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
|
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
|
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
|
* SOFTWARE.
|
|
*******************************************************************************/
|
|
|
|
#ifndef __PolyVox_Vector_H__
|
|
#define __PolyVox_Vector_H__
|
|
|
|
#include "Impl/ErrorHandling.h"
|
|
#include "Impl/PlatformDefinitions.h"
|
|
|
|
#include <algorithm>
|
|
#include <cmath>
|
|
#include <cstring>
|
|
#include <functional>
|
|
#include <iostream>
|
|
#include <memory>
|
|
|
|
namespace PolyVox
|
|
{
|
|
/**
|
|
* Represents a vector in space.
|
|
*
|
|
* This is a generl purpose vector class designed to represent both positions and directions. It is templatised
|
|
* on both size and data type but note that some of the operations do not make sense with integer types. For
|
|
* example it does not make conceptual sense to try and normalise an integer Vector.
|
|
*
|
|
* Every Vector must have at at least two elements, and the first four elements of any vector are known as the
|
|
* X, Y, Z and W elements. Note that W is last even though it comes before X in the alphabet. These elements can
|
|
* be accessed through getX(), setX(), getY(), setY(), getZ(), setZ(), getW() and setW(), while other elements
|
|
* can be accessed through getElemen() and setElement().
|
|
*
|
|
* This class includes a number of common mathematical operations (addition, subtraction, etc) as well as vector
|
|
* specific operations such as the dot and cross products. Note that this class is also templatised on an
|
|
* OperationType which is used for many internal calculations and some results. For example, the square of a
|
|
* vector's length will always be an integer if all the elements are integers, but the value might be outside
|
|
* that which can be represented by the StorageType. You don't need to worry about this as long as you are using
|
|
* the built in typedefs for common configurations.
|
|
*
|
|
* Typedefs are provided for 2, 3 and 4 dimensional vector with int8_t, uint8_t, int16_t, uint6_t, int32_t,
|
|
* uint32_t, float and double types. These typedefs are used as follows:
|
|
*
|
|
* \code
|
|
* Vector2DInt32 test(1,2); //Declares a 2 dimensional Vector of type int32_t.
|
|
* \endcode
|
|
*/
|
|
template <uint32_t Size, typename StorageType, typename OperationType = StorageType>
|
|
class Vector
|
|
{
|
|
public:
|
|
/// Constructor
|
|
Vector(void);
|
|
/// Constructor.
|
|
Vector(StorageType tFillValue);
|
|
/// Constructor.
|
|
Vector(StorageType x, StorageType y);
|
|
/// Constructor.
|
|
Vector(StorageType x, StorageType y, StorageType z);
|
|
/// Constructor.
|
|
Vector(StorageType x, StorageType y, StorageType z, StorageType w);
|
|
/// Copy Constructor.
|
|
Vector(const Vector<Size, StorageType, OperationType>& vector);
|
|
/// Copy Constructor which performs casting.
|
|
template <typename CastType> explicit Vector(const Vector<Size, CastType>& vector);
|
|
/// Destructor.
|
|
~Vector(void);
|
|
|
|
/// Assignment Operator.
|
|
Vector<Size, StorageType, OperationType>& operator=(const Vector<Size, StorageType, OperationType>& rhs);
|
|
/// Equality Operator.
|
|
bool operator==(const Vector<Size, StorageType, OperationType>& rhs) const;
|
|
/// Inequality Operator.
|
|
bool operator!=(const Vector<Size, StorageType, OperationType>& rhs) const;
|
|
/// Addition and Assignment Operator.
|
|
Vector<Size, StorageType, OperationType>& operator+=(const Vector<Size, StorageType, OperationType> &rhs);
|
|
/// Subtraction and Assignment Operator.
|
|
Vector<Size, StorageType, OperationType>& operator-=(const Vector<Size, StorageType, OperationType> &rhs);
|
|
/// Multiplication and Assignment Operator.
|
|
Vector<Size, StorageType, OperationType>& operator*=(const Vector<Size, StorageType, OperationType> &rhs);
|
|
/// Division and Assignment Operator.
|
|
Vector<Size, StorageType, OperationType>& operator/=(const Vector<Size, StorageType, OperationType> &rhs);
|
|
/// Multiplication and Assignment Operator.
|
|
Vector<Size, StorageType, OperationType>& operator*=(const StorageType& rhs);
|
|
/// Division and Assignment Operator.
|
|
Vector<Size, StorageType, OperationType>& operator/=(const StorageType& rhs);
|
|
|
|
/// Element Access.
|
|
StorageType getElement(uint32_t index) const;
|
|
/// Get the x component of the vector.
|
|
StorageType getX(void) const;
|
|
/// Get the y component of the vector.
|
|
StorageType getY(void) const;
|
|
/// Get the z component of the vector.
|
|
StorageType getZ(void) const;
|
|
/// Get the w component of the vector.
|
|
StorageType getW(void) const;
|
|
|
|
/// Element Access.
|
|
void setElement(uint32_t index, StorageType tValue);
|
|
/// Element Access.
|
|
void setElements(StorageType x, StorageType y);
|
|
/// Element Access.
|
|
void setElements(StorageType x, StorageType y, StorageType z);
|
|
/// Element Access.
|
|
void setElements(StorageType x, StorageType y, StorageType z, StorageType w);
|
|
/// Set the x component of the vector.
|
|
void setX(StorageType tX);
|
|
/// Set the y component of the vector.
|
|
void setY(StorageType tY);
|
|
/// Set the z component of the vector.
|
|
void setZ(StorageType tZ);
|
|
/// Set the w component of the vector.
|
|
void setW(StorageType tW);
|
|
|
|
/// Get the length of the vector.
|
|
float length(void) const;
|
|
/// Get the squared length of the vector.
|
|
OperationType lengthSquared(void) const;
|
|
/// Find the angle between this vector and that which is passed as a parameter.
|
|
float angleTo(const Vector<Size, StorageType, OperationType>& vector) const;
|
|
/// Find the cross product between this vector and the vector passed as a parameter.
|
|
Vector<Size, StorageType, OperationType> cross(const Vector<Size, StorageType, OperationType>& vector) const;
|
|
/// Find the dot product between this vector and the vector passed as a parameter.
|
|
OperationType dot(const Vector<Size, StorageType, OperationType>& rhs) const;
|
|
/// Normalise the vector.
|
|
void normalise(void);
|
|
|
|
private:
|
|
// Values for the vector
|
|
StorageType m_tElements[Size];
|
|
};
|
|
|
|
// Non-member overloaded operators.
|
|
/// Addition operator.
|
|
template <uint32_t Size, typename StorageType, typename OperationType>
|
|
Vector<Size, StorageType, OperationType> operator+(const Vector<Size, StorageType, OperationType>& lhs, const Vector<Size, StorageType, OperationType>& rhs);
|
|
/// Subtraction operator.
|
|
template <uint32_t Size, typename StorageType, typename OperationType>
|
|
Vector<Size, StorageType, OperationType> operator-(const Vector<Size, StorageType, OperationType>& lhs, const Vector<Size, StorageType, OperationType>& rhs);
|
|
/// Multiplication operator.
|
|
template <uint32_t Size, typename StorageType, typename OperationType>
|
|
Vector<Size, StorageType, OperationType> operator*(const Vector<Size, StorageType, OperationType>& lhs, const Vector<Size, StorageType, OperationType>& rhs);
|
|
/// Division operator.
|
|
template <uint32_t Size, typename StorageType, typename OperationType>
|
|
Vector<Size, StorageType, OperationType> operator/(const Vector<Size, StorageType, OperationType>& lhs, const Vector<Size, StorageType, OperationType>& rhs);
|
|
/// Multiplication operator.
|
|
template <uint32_t Size, typename StorageType, typename OperationType>
|
|
Vector<Size, StorageType, OperationType> operator*(const Vector<Size, StorageType, OperationType>& lhs, const StorageType& rhs);
|
|
/// Division operator.
|
|
template <uint32_t Size, typename StorageType, typename OperationType>
|
|
Vector<Size, StorageType, OperationType> operator/(const Vector<Size, StorageType, OperationType>& lhs, const StorageType& rhs);
|
|
/// Stream insertion operator.
|
|
template <uint32_t Size, typename StorageType, typename OperationType>
|
|
std::ostream& operator<<(std::ostream& os, const Vector<Size, StorageType, OperationType>& vector);
|
|
|
|
//Some handy typedefs
|
|
|
|
/// A 2D Vector of floats.
|
|
typedef Vector<2, float, float> Vector2DFloat;
|
|
/// A 2D Vector of doubles.
|
|
typedef Vector<2, double, double> Vector2DDouble;
|
|
/// A 2D Vector of signed 8-bit values.
|
|
typedef Vector<2, int8_t, int32_t> Vector2DInt8;
|
|
/// A 2D Vector of unsigned 8-bit values.
|
|
typedef Vector<2, uint8_t, int32_t> Vector2DUint8;
|
|
/// A 2D Vector of signed 16-bit values.
|
|
typedef Vector<2, int16_t, int32_t> Vector2DInt16;
|
|
/// A 2D Vector of unsigned 16-bit values.
|
|
typedef Vector<2, uint16_t, int32_t> Vector2DUint16;
|
|
/// A 2D Vector of signed 32-bit values.
|
|
typedef Vector<2, int32_t, int32_t> Vector2DInt32;
|
|
/// A 2D Vector of unsigned 32-bit values.
|
|
typedef Vector<2, uint32_t, int32_t> Vector2DUint32;
|
|
|
|
/// A 3D Vector of floats.
|
|
typedef Vector<3, float, float> Vector3DFloat;
|
|
/// A 3D Vector of doubles.
|
|
typedef Vector<3, double, double> Vector3DDouble;
|
|
/// A 3D Vector of signed 8-bit values.
|
|
typedef Vector<3, int8_t, int32_t> Vector3DInt8;
|
|
/// A 3D Vector of unsigned 8-bit values.
|
|
typedef Vector<3, uint8_t, int32_t> Vector3DUint8;
|
|
/// A 3D Vector of signed 16-bit values.
|
|
typedef Vector<3, int16_t, int32_t> Vector3DInt16;
|
|
/// A 3D Vector of unsigned 16-bit values.
|
|
typedef Vector<3, uint16_t, int32_t> Vector3DUint16;
|
|
/// A 3D Vector of signed 32-bit values.
|
|
typedef Vector<3, int32_t, int32_t> Vector3DInt32;
|
|
/// A 3D Vector of unsigned 32-bit values.
|
|
typedef Vector<3, uint32_t, int32_t> Vector3DUint32;
|
|
|
|
/// A 4D Vector of floats.
|
|
typedef Vector<4, float, float> Vector4DFloat;
|
|
/// A 4D Vector of doubles.
|
|
typedef Vector<4, double, double> Vector4DDouble;
|
|
/// A 4D Vector of signed 8-bit values.
|
|
typedef Vector<4, int8_t, int32_t> Vector4DInt8;
|
|
/// A 4D Vector of unsigned 8-bit values.
|
|
typedef Vector<4, uint8_t, int32_t> Vector4DUint8;
|
|
/// A 4D Vector of signed 16-bit values.
|
|
typedef Vector<4, int16_t, int32_t> Vector4DInt16;
|
|
/// A 4D Vector of unsigned 16-bit values.
|
|
typedef Vector<4, uint16_t, int32_t> Vector4DUint16;
|
|
/// A 4D Vector of signed 32-bit values.
|
|
typedef Vector<4, int32_t, int32_t> Vector4DInt32;
|
|
/// A 4D Vector of unsigned 32-bit values.
|
|
typedef Vector<4, uint32_t, int32_t> Vector4DUint32;
|
|
|
|
|
|
}//namespace PolyVox
|
|
|
|
namespace std
|
|
{
|
|
template <>
|
|
struct hash<PolyVox::Vector3DInt32>
|
|
{
|
|
std::size_t operator()(const PolyVox::Vector3DInt32& vec) const
|
|
{
|
|
return ((vec.getX() & 0xFF)) | ((vec.getY() & 0xFF) << 8) | ((vec.getZ() & 0xFF) << 16);
|
|
}
|
|
};
|
|
}
|
|
|
|
|
|
#include "Vector.inl"
|
|
|
|
#endif
|
|
|