NoEdge/Danbias
NoEdge
/
Danbias
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Oops .. cpp were needed afterall 

* Turns out that VS wont generate a lib file if there is no cpp file.
* last letter in all FloatN::standard_unit_C constants were in
uppercase. Breach against documented coding practice. (N = 2..4, C =
{x,y,z,w} )
This commit is contained in:
Dander7BD 2013-11-09 14:59:10 +01:00
parent 60f448e97a
commit 0ad4bca1b4
3 changed files with 127 additions and 67 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

83
OysterMath/OysterMath.cpp Normal file
View File

@ -0,0 +1,83 @@
/////////////////////////////////////////////////////////////////////
// Created by Dan Andersson 2013
/////////////////////////////////////////////////////////////////////
#include "OysterMath.h"
namespace Oyster { namespace Math
{
bool IsSupported()
{ return true; }
bool SuperpositionMatrix( const Float2x2 &in, const Float2x2 &out, Float2x2 &targetMem )
{ return ::LinearAlgebra::SuperpositionMatrix( in, out, targetMem ); }
bool SuperpositionMatrix( const Float3x3 &in, const Float3x3 &out, Float3x3 &targetMem )
{ return ::LinearAlgebra::SuperpositionMatrix( in, out, targetMem ); }
bool SuperpositionMatrix( const Float4x4 &in, const Float4x4 &out, Float4x4 &targetMem )
{ return ::LinearAlgebra::SuperpositionMatrix( in, out, targetMem ); }
} }
namespace Oyster { namespace Math2D
{
Float2 X_AxisTo( const Float2 &yAxis )
{ return ::LinearAlgebra2D::X_AxisTo(yAxis); }
Float2 Y_AxisTo( const Float2 &xAxis )
{ return ::LinearAlgebra2D::Y_AxisTo(xAxis); }
Float3x3 & TranslationMatrix( const Float2 &position, Float3x3 &targetMem )
{ return ::LinearAlgebra2D::TranslationMatrix( position, targetMem ); }
Float3x3 & RotationMatrix( const Float &radian, Float3x3 &targetMem )
{ return ::LinearAlgebra2D::RotationMatrix( radian, targetMem ); }
Float3x3 & OrientationMatrix( const Float2 &position, const Float &radian, Float3x3 &targetMem )
{ return ::LinearAlgebra2D::OrientationMatrix( radian, position, targetMem ); }
Float3x3 & OrientationMatrix( const Float2 &position, const Float2 &lookAt, Float3x3 &targetMem )
{ return ::LinearAlgebra2D::OrientationMatrix( lookAt, position, targetMem ); }
Float3x3 & OrientationMatrix( const Float2 &position, Float radian, const Float2 &localCenterOfRotation, Float3x3 &targetMem )
{ return ::LinearAlgebra2D::OrientationMatrix( radian, position, localCenterOfRotation, targetMem ); }
Float3x3 & InverseOrientationMatrix( const Float3x3 &orientationMatrix, Float3x3 &targetMem )
{ return ::LinearAlgebra2D::InverseOrientationMatrix( orientationMatrix, targetMem ); }
} }
namespace Oyster { namespace Math3D
{
Float4x4 & TranslationMatrix( const Float3 &position, Float4x4 &targetMem )
{ return ::LinearAlgebra3D::TranslationMatrix( position, targetMem ); }
Float4x4 & RotationMatrix_AxisX( const Float &radian, Float4x4 &targetMem )
{ return ::LinearAlgebra3D::RotationMatrix_AxisX( radian, targetMem ); }
Float4x4 & RotationMatrix_AxisY( const Float &radian, Float4x4 &targetMem )
{ return ::LinearAlgebra3D::RotationMatrix_AxisY( radian, targetMem ); }
Float4x4 & RotationMatrix_AxisZ( const Float &radian, Float4x4 &targetMem )
{ return ::LinearAlgebra3D::RotationMatrix_AxisZ( radian, targetMem ); }
Float4x4 & RotationMatrix( const Float &radian, const Float3 &normalizedAxis, Float4x4 &targetMem )
{ return ::LinearAlgebra3D::RotationMatrix( normalizedAxis, radian, targetMem ); }
Float4x4 & OrientationMatrix( const Float3 &sumDeltaAngularAxis, const Float3 &sumTranslation, Float4x4 &targetMem )
{ return ::LinearAlgebra3D::OrientationMatrix( sumDeltaAngularAxis, sumTranslation, targetMem ); }
Float4x4 & OrientationMatrix( const Float3 &sumDeltaAngularAxis, const Float3 &sumTranslation, const Float3 &centerOfMass, Float4x4 &targetMem )
{ return ::LinearAlgebra3D::OrientationMatrix( sumDeltaAngularAxis, sumTranslation, centerOfMass, targetMem ); }
Float4x4 & InverseOrientationMatrix( const Float4x4 &orientationMatrix, Float4x4 &targetMem )
{ return ::LinearAlgebra3D::InverseOrientationMatrix( orientationMatrix, targetMem ); }
Float4x4 & ProjectionMatrix_Orthographic( const Float &width, const Float &height, const Float &nearClip, const Float &farClip, Float4x4 &targetMem )
{ return ::LinearAlgebra3D::ProjectionMatrix_Orthographic( width, height, nearClip, farClip, targetMem ); }
Float4x4 & ProjectionMatrix_Perspective( const Float &verticalFoV, const Float &aspectRatio, const Float &nearClip, const Float &farClip, Float4x4 &targetMem )
{ return ::LinearAlgebra3D::ProjectionMatrix_Perspective( verticalFoV, aspectRatio, nearClip, farClip, targetMem ); }
Float3 VectorProjection( const Float3 &vector, const Float3 &axis )
{ return ::LinearAlgebra3D::VectorProjection( vector, axis ); }
} }

75
OysterMath/OysterMath.h
View File

@ -1,5 +1,5 @@
///////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////
// by Dan Andersson 2013 // Created by Dan Andersson 2013
///////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////
#ifndef OYSTER_MATH_H #ifndef OYSTER_MATH_H
@ -28,23 +28,19 @@ namespace Oyster { namespace Math /// Oyster's native math library
/// Function Highly recommended to check at start, just in case current version is using a feature that might be available. /// Function Highly recommended to check at start, just in case current version is using a feature that might be available.
/// @todo TODO: create a template UniquePointer to use here /// @todo TODO: create a template UniquePointer to use here
inline bool IsSupported() bool IsSupported();
{ return true; }
/// Creates a solution matrix for 'out´= 'targetMem' * 'in'. /// Creates a solution matrix for 'out´= 'targetMem' * 'in'.
/// Returns false if there is no explicit solution. /// Returns false if there is no explicit solution.
inline bool SuperpositionMatrix( const Float2x2 &in, const Float2x2 &out, Float2x2 &targetMem ) bool SuperpositionMatrix( const Float2x2 &in, const Float2x2 &out, Float2x2 &targetMem );
{ return ::LinearAlgebra::SuperpositionMatrix( in, out, targetMem ); }
/// Creates a solution matrix for 'out´= 'targetMem' * 'in'. /// Creates a solution matrix for 'out´= 'targetMem' * 'in'.
/// Returns false if there is no explicit solution. /// Returns false if there is no explicit solution.
inline bool SuperpositionMatrix( const Float3x3 &in, const Float3x3 &out, Float3x3 &targetMem ) bool SuperpositionMatrix( const Float3x3 &in, const Float3x3 &out, Float3x3 &targetMem );
{ return ::LinearAlgebra::SuperpositionMatrix( in, out, targetMem ); }
/// Creates a solution matrix for 'out´= 'targetMem' * 'in'. /// Creates a solution matrix for 'out´= 'targetMem' * 'in'.
/// Returns false if there is no explicit solution. /// Returns false if there is no explicit solution.
inline bool SuperpositionMatrix( const Float4x4 &in, const Float4x4 &out, Float4x4 &targetMem ) bool SuperpositionMatrix( const Float4x4 &in, const Float4x4 &out, Float4x4 &targetMem );
{ return ::LinearAlgebra::SuperpositionMatrix( in, out, targetMem ); }
} } } }
inline ::Oyster::Math::Float2 & operator *= ( ::Oyster::Math::Float2 &left, const ::Oyster::Math::Float2 &right ) inline ::Oyster::Math::Float2 & operator *= ( ::Oyster::Math::Float2 &left, const ::Oyster::Math::Float2 &right )
@ -104,38 +100,30 @@ namespace Oyster { namespace Math2D /// Oyster's native math library specialized
/// If there is an Y-axis on a 2D plane, then there is an explicit X-axis on and that is what is returned. /// If there is an Y-axis on a 2D plane, then there is an explicit X-axis on and that is what is returned.
/// Recommended too make sure that yAxis is normalized. /// Recommended too make sure that yAxis is normalized.
inline Float2 X_AxisTo( const Float2 &yAxis ) Float2 X_AxisTo( const Float2 &yAxis );
{ return ::LinearAlgebra2D::X_AxisTo(yAxis); }
/// If there is an X-axis on a 2D plane, then there is an explicit Y-axis and that is what is returned. /// If there is an X-axis on a 2D plane, then there is an explicit Y-axis and that is what is returned.
/// Recommended too make sure that yAxis is normalized. /// Recommended too make sure that yAxis is normalized.
inline Float2 Y_AxisTo( const Float2 &xAxis ) Float2 Y_AxisTo( const Float2 &xAxis );
{ return ::LinearAlgebra2D::Y_AxisTo(xAxis); }
/// Sets and returns targetMem to a translationMatrix with position as translation. /// Sets and returns targetMem to a translationMatrix with position as translation.
inline Float3x3 & TranslationMatrix( const Float2 &position, Float3x3 &targetMem = Float3x3() ) Float3x3 & TranslationMatrix( const Float2 &position, Float3x3 &targetMem = Float3x3() );
{ return ::LinearAlgebra2D::TranslationMatrix( position, targetMem ); }
/// Sets and returns targetMem as a counterclockwise rotationMatrix /// Sets and returns targetMem as a counterclockwise rotationMatrix
inline Float3x3 & RotationMatrix( const Float &radian, Float3x3 &targetMem = Float3x3() ) Float3x3 & RotationMatrix( const Float &radian, Float3x3 &targetMem = Float3x3() );
{ return ::LinearAlgebra2D::RotationMatrix( radian, targetMem ); }
/// Sets and returns targetMem as an orientation Matrix with position as translation and radian rotation /// Sets and returns targetMem as an orientation Matrix with position as translation and radian rotation
inline Float3x3 & OrientationMatrix( const Float2 &position, const Float &radian, Float3x3 &targetMem = Float3x3() ) Float3x3 & OrientationMatrix( const Float2 &position, const Float &radian, Float3x3 &targetMem = Float3x3() );
{ return ::LinearAlgebra2D::OrientationMatrix( radian, position, targetMem ); }
/// Sets and returns targetMem as an orientation Matrix with position as translation and local y-axis directed at lookAt /// Sets and returns targetMem as an orientation Matrix with position as translation and local y-axis directed at lookAt
inline Float3x3 & OrientationMatrix( const Float2 &position, const Float2 &lookAt, Float3x3 &targetMem = Float3x3() ) Float3x3 & OrientationMatrix( const Float2 &position, const Float2 &lookAt, Float3x3 &targetMem = Float3x3() );
{ return ::LinearAlgebra2D::OrientationMatrix( lookAt, position, targetMem ); }
/// Sets and returns targetMem as an orientation Matrix that is rotated around localCenterOfRotation and then translated with position. /// Sets and returns targetMem as an orientation Matrix that is rotated around localCenterOfRotation and then translated with position.
/// TODO: not tested /// TODO: not tested
inline Float3x3 & OrientationMatrix( const Float2 &position, Float radian, const Float2 &localCenterOfRotation, Float3x3 &targetMem = Float3x3() ) Float3x3 & OrientationMatrix( const Float2 &position, Float radian, const Float2 &localCenterOfRotation, Float3x3 &targetMem = Float3x3() );
{ return ::LinearAlgebra2D::OrientationMatrix( radian, position, localCenterOfRotation, targetMem ); }
/// If orientationMatrix is assumed to be by all definitions a rigid orientation matrix aka rigid body matrix. Then this is a much faster inverse method. /// If orientationMatrix is assumed to be by all definitions a rigid orientation matrix aka rigid body matrix. Then this is a much faster inverse method.
inline Float3x3 & InverseOrientationMatrix( const Float3x3 &orientationMatrix, Float3x3 &targetMem = Float3x3() ) Float3x3 & InverseOrientationMatrix( const Float3x3 &orientationMatrix, Float3x3 &targetMem = Float3x3() );
{ return ::LinearAlgebra2D::InverseOrientationMatrix( orientationMatrix, targetMem ); }
} } } }
namespace Oyster { namespace Math3D /// Oyster's native math library specialized for 3D namespace Oyster { namespace Math3D /// Oyster's native math library specialized for 3D
@ -143,29 +131,20 @@ namespace Oyster { namespace Math3D /// Oyster's native math library specialized
using namespace ::Oyster::Math; // deliberate inheritance from ::Oyster::Math namespace using namespace ::Oyster::Math; // deliberate inheritance from ::Oyster::Math namespace
/// Sets and returns targetMem to a translationMatrix with position as translation. /// Sets and returns targetMem to a translationMatrix with position as translation.
inline Float4x4 & TranslationMatrix( const Float3 &position, Float4x4 &targetMem = Float4x4() ) Float4x4 & TranslationMatrix( const Float3 &position, Float4x4 &targetMem = Float4x4() );
{ return ::LinearAlgebra3D::TranslationMatrix( position, targetMem ); }
/// Sets and returns targetMem as an counterclockwise rotation matrix around the global X-axis /// Sets and returns targetMem as an counterclockwise rotation matrix around the global X-axis
inline Float4x4 & RotationMatrix_AxisX( const Float &radian, Float4x4 &targetMem = Float4x4() ) Float4x4 & RotationMatrix_AxisX( const Float &radian, Float4x4 &targetMem = Float4x4() );
{ return ::LinearAlgebra3D::RotationMatrix_AxisX( radian, targetMem ); }
/// Sets and returns targetMem as an counterclockwise rotation matrix around the global Y-axis /// Sets and returns targetMem as an counterclockwise rotation matrix around the global Y-axis
inline Float4x4 & RotationMatrix_AxisY( const Float &radian, Float4x4 &targetMem = Float4x4() ) Float4x4 & RotationMatrix_AxisY( const Float &radian, Float4x4 &targetMem = Float4x4() );
{ return ::LinearAlgebra3D::RotationMatrix_AxisY( radian, targetMem ); }
/// Sets and returns targetMem as an counterclockwise rotation matrix around the global Z-axis /// Sets and returns targetMem as an counterclockwise rotation matrix around the global Z-axis
inline Float4x4 & RotationMatrix_AxisZ( const Float &radian, Float4x4 &targetMem = Float4x4() ) Float4x4 & RotationMatrix_AxisZ( const Float &radian, Float4x4 &targetMem = Float4x4() );
{ return ::LinearAlgebra3D::RotationMatrix_AxisZ( radian, targetMem ); }
/// Sets and returns targetMem as an counterclockwise rotation matrix around the normalizedAxis. /// Sets and returns targetMem as an counterclockwise rotation matrix around the normalizedAxis.
/// Please make sure normalizedAxis is normalized. /// Please make sure normalizedAxis is normalized.
inline Float4x4 & RotationMatrix( const Float &radian, const Float3 &normalizedAxis, Float4x4 &targetMem = Float4x4() ) Float4x4 & RotationMatrix( const Float &radian, const Float3 &normalizedAxis, Float4x4 &targetMem = Float4x4() );
{ return ::LinearAlgebra3D::RotationMatrix( normalizedAxis, radian, targetMem ); }
/// If orientationMatrix is assumed to be by all definitions a rigid orientation matrix aka rigid body matrix. Then this is a much faster inverse method.
inline Float4x4 & InverseOrientationMatrix( const Float4x4 &orientationMatrix, Float4x4 &targetMem = Float4x4() )
{ return ::LinearAlgebra3D::InverseOrientationMatrix( orientationMatrix, targetMem ); }
/** Sets and returns targetMem as an orientation Matrix /** Sets and returns targetMem as an orientation Matrix
* @param targetMem: is set to a rigibody matrix that rotate counterclockwise and then translates. * @param targetMem: is set to a rigibody matrix that rotate counterclockwise and then translates.
@ -174,8 +153,7 @@ namespace Oyster { namespace Math3D /// Oyster's native math library specialized
* @return targetMem * @return targetMem
@todo TODO: not tested @todo TODO: not tested
*/ */
inline Float4x4 & OrientationMatrix( const Float3 &sumDeltaAngularAxis, const Float3 &sumTranslation, Float4x4 &targetMem = Float4x4() ) Float4x4 & OrientationMatrix( const Float3 &sumDeltaAngularAxis, const Float3 &sumTranslation, Float4x4 &targetMem = Float4x4() );
{ return ::LinearAlgebra3D::OrientationMatrix( sumDeltaAngularAxis, sumTranslation, targetMem ); }
/** Sets and returns targetMem as an orientation Matrix /** Sets and returns targetMem as an orientation Matrix
* @param targetMem: is set to a rigibody matrix that revolve/rotate counterclockwise around centerOfMass and then translates. * @param targetMem: is set to a rigibody matrix that revolve/rotate counterclockwise around centerOfMass and then translates.
@ -185,8 +163,10 @@ namespace Oyster { namespace Math3D /// Oyster's native math library specialized
* @return targetMem * @return targetMem
@todo TODO: not tested @todo TODO: not tested
*/ */
inline Float4x4 & OrientationMatrix( const Float3 &sumDeltaAngularAxis, const Float3 &sumTranslation, const Float3 &centerOfMass, Float4x4 &targetMem = Float4x4() ) Float4x4 & OrientationMatrix( const Float3 &sumDeltaAngularAxis, const Float3 &sumTranslation, const Float3 &centerOfMass, Float4x4 &targetMem = Float4x4() );
{ return ::LinearAlgebra3D::OrientationMatrix( sumDeltaAngularAxis, sumTranslation, centerOfMass, targetMem ); }
/// If orientationMatrix is assumed to be by all definitions a rigid orientation matrix aka rigid body matrix. Then this is a much faster inverse method.
Float4x4 & InverseOrientationMatrix( const Float4x4 &orientationMatrix, Float4x4 &targetMem = Float4x4() );
/** Creates an orthographic projection matrix designed for DirectX enviroment. /** Creates an orthographic projection matrix designed for DirectX enviroment.
* @param targetMem; is set to an orthographic projection matrix. * @param targetMem; is set to an orthographic projection matrix.
@ -197,8 +177,7 @@ namespace Oyster { namespace Math3D /// Oyster's native math library specialized
* @return targetMem * @return targetMem
@todo TODO: not tested @todo TODO: not tested
*/ */
inline Float4x4 & ProjectionMatrix_Orthographic( const Float &width, const Float &height, const Float &nearClip = ::std::numeric_limits<Float>::epsilon(), const Float &farClip = ::std::numeric_limits<Float>::max(), Float4x4 &targetMem = Float4x4() ) Float4x4 & ProjectionMatrix_Orthographic( const Float &width, const Float &height, const Float &nearClip = ::std::numeric_limits<Float>::epsilon(), const Float &farClip = ::std::numeric_limits<Float>::max(), Float4x4 &targetMem = Float4x4() );
{ return ::LinearAlgebra3D::ProjectionMatrix_Orthographic( width, height, nearClip, farClip, targetMem ); }
/** Creates a perspective projection matrix designed for DirectX enviroment. /** Creates a perspective projection matrix designed for DirectX enviroment.
* @param targetMem; is set to a perspective transform matrix. * @param targetMem; is set to a perspective transform matrix.
@ -209,12 +188,10 @@ namespace Oyster { namespace Math3D /// Oyster's native math library specialized
* @return targetMem * @return targetMem
@todo TODO: not tested @todo TODO: not tested
*/ */
inline Float4x4 & ProjectionMatrix_Perspective( const Float &verticalFoV, const Float &aspectRatio, const Float &nearClip = ::std::numeric_limits<Float>::epsilon(), const Float &farClip = ::std::numeric_limits<Float>::max(), Float4x4 &targetMem = Float4x4() ) Float4x4 & ProjectionMatrix_Perspective( const Float &verticalFoV, const Float &aspectRatio, const Float &nearClip = ::std::numeric_limits<Float>::epsilon(), const Float &farClip = ::std::numeric_limits<Float>::max(), Float4x4 &targetMem = Float4x4() );
{ return ::LinearAlgebra3D::ProjectionMatrix_Perspective( verticalFoV, aspectRatio, nearClip, farClip, targetMem ); }
/// returns the component vector of vector that is parallell with axis /// returns the component vector of vector that is parallell with axis
inline Float3 VectorProjection( const Float3 &vector, const Float3 &axis ) Float3 VectorProjection( const Float3 &vector, const Float3 &axis );
{ return ::LinearAlgebra3D::VectorProjection( vector, axis ); }
/// Helper inline function that sets and then returns targetMem = projection * view /// Helper inline function that sets and then returns targetMem = projection * view
inline Float4x4 & ViewProjectionMatrix( const Float4x4 &view, const Float4x4 &projection, Float4x4 &targetMem = Float4x4() ) inline Float4x4 & ViewProjectionMatrix( const Float4x4 &view, const Float4x4 &projection, Float4x4 &targetMem = Float4x4() )

36
OysterMath/Vector.h
View File

@ -22,8 +22,8 @@ namespace LinearAlgebra
}; };
static const Vector2<ScalarType> null; static const Vector2<ScalarType> null;
static const Vector2<ScalarType> standard_unit_X; static const Vector2<ScalarType> standard_unit_x;
static const Vector2<ScalarType> standard_unit_Y; static const Vector2<ScalarType> standard_unit_y;
Vector2( ); Vector2( );
Vector2( const Vector2<ScalarType> &vector ); Vector2( const Vector2<ScalarType> &vector );
@ -74,9 +74,9 @@ namespace LinearAlgebra
}; };
static const Vector3<ScalarType> null; static const Vector3<ScalarType> null;
static const Vector3<ScalarType> standard_unit_X; static const Vector3<ScalarType> standard_unit_x;
static const Vector3<ScalarType> standard_unit_Y; static const Vector3<ScalarType> standard_unit_y;
static const Vector3<ScalarType> standard_unit_Z; static const Vector3<ScalarType> standard_unit_z;
Vector3( ); Vector3( );
Vector3( const Vector3<ScalarType> &vector ); Vector3( const Vector3<ScalarType> &vector );
@ -130,10 +130,10 @@ namespace LinearAlgebra
}; };
static const Vector4<ScalarType> null; static const Vector4<ScalarType> null;
static const Vector4<ScalarType> standard_unit_X; static const Vector4<ScalarType> standard_unit_x;
static const Vector4<ScalarType> standard_unit_Y; static const Vector4<ScalarType> standard_unit_y;
static const Vector4<ScalarType> standard_unit_Z; static const Vector4<ScalarType> standard_unit_z;
static const Vector4<ScalarType> standard_unit_W; static const Vector4<ScalarType> standard_unit_w;
Vector4( ); Vector4( );
Vector4( const Vector4<ScalarType> &vector ); Vector4( const Vector4<ScalarType> &vector );
@ -180,8 +180,8 @@ namespace LinearAlgebra
// Vector2<ScalarType> /////////////////////////////////////// // Vector2<ScalarType> ///////////////////////////////////////
template<typename ScalarType> const Vector2<ScalarType> Vector2<ScalarType>::null = Vector2<ScalarType>( ); template<typename ScalarType> const Vector2<ScalarType> Vector2<ScalarType>::null = Vector2<ScalarType>( );
template<typename ScalarType> const Vector2<ScalarType> Vector2<ScalarType>::standard_unit_X = Vector2<ScalarType>( 1, 0 ); template<typename ScalarType> const Vector2<ScalarType> Vector2<ScalarType>::standard_unit_x = Vector2<ScalarType>( 1, 0 );
template<typename ScalarType> const Vector2<ScalarType> Vector2<ScalarType>::standard_unit_Y = Vector2<ScalarType>( 0, 1 ); template<typename ScalarType> const Vector2<ScalarType> Vector2<ScalarType>::standard_unit_y = Vector2<ScalarType>( 0, 1 );
template<typename ScalarType> template<typename ScalarType>
Vector2<ScalarType>::Vector2( ) : x(), y() {} Vector2<ScalarType>::Vector2( ) : x(), y() {}
@ -338,9 +338,9 @@ namespace LinearAlgebra
// Vector3<ScalarType> /////////////////////////////////////// // Vector3<ScalarType> ///////////////////////////////////////
template<typename ScalarType> const Vector3<ScalarType> Vector3<ScalarType>::null = Vector3<ScalarType>( ); template<typename ScalarType> const Vector3<ScalarType> Vector3<ScalarType>::null = Vector3<ScalarType>( );
template<typename ScalarType> const Vector3<ScalarType> Vector3<ScalarType>::standard_unit_X = Vector3<ScalarType>( 1, 0, 0 ); template<typename ScalarType> const Vector3<ScalarType> Vector3<ScalarType>::standard_unit_x = Vector3<ScalarType>( 1, 0, 0 );
template<typename ScalarType> const Vector3<ScalarType> Vector3<ScalarType>::standard_unit_Y = Vector3<ScalarType>( 0, 1, 0 ); template<typename ScalarType> const Vector3<ScalarType> Vector3<ScalarType>::standard_unit_y = Vector3<ScalarType>( 0, 1, 0 );
template<typename ScalarType> const Vector3<ScalarType> Vector3<ScalarType>::standard_unit_Z = Vector3<ScalarType>( 0, 0, 1 ); template<typename ScalarType> const Vector3<ScalarType> Vector3<ScalarType>::standard_unit_z = Vector3<ScalarType>( 0, 0, 1 );
template<typename ScalarType> template<typename ScalarType>
Vector3<ScalarType>::Vector3( ) : x(), y(), z() {} Vector3<ScalarType>::Vector3( ) : x(), y(), z() {}
@ -510,10 +510,10 @@ namespace LinearAlgebra
// Vector4<ScalarType> /////////////////////////////////////// // Vector4<ScalarType> ///////////////////////////////////////
template<typename ScalarType> const Vector4<ScalarType> Vector4<ScalarType>::null = Vector4<ScalarType>( ); template<typename ScalarType> const Vector4<ScalarType> Vector4<ScalarType>::null = Vector4<ScalarType>( );
template<typename ScalarType> const Vector4<ScalarType> Vector4<ScalarType>::standard_unit_X = Vector4<ScalarType>( 1, 0, 0, 0 ); template<typename ScalarType> const Vector4<ScalarType> Vector4<ScalarType>::standard_unit_x = Vector4<ScalarType>( 1, 0, 0, 0 );
template<typename ScalarType> const Vector4<ScalarType> Vector4<ScalarType>::standard_unit_Y = Vector4<ScalarType>( 0, 1, 0, 0 ); template<typename ScalarType> const Vector4<ScalarType> Vector4<ScalarType>::standard_unit_y = Vector4<ScalarType>( 0, 1, 0, 0 );
template<typename ScalarType> const Vector4<ScalarType> Vector4<ScalarType>::standard_unit_Z = Vector4<ScalarType>( 0, 0, 1, 0 ); template<typename ScalarType> const Vector4<ScalarType> Vector4<ScalarType>::standard_unit_z = Vector4<ScalarType>( 0, 0, 1, 0 );
template<typename ScalarType> const Vector4<ScalarType> Vector4<ScalarType>::standard_unit_W = Vector4<ScalarType>( 0, 0, 0, 1 ); template<typename ScalarType> const Vector4<ScalarType> Vector4<ScalarType>::standard_unit_w = Vector4<ScalarType>( 0, 0, 0, 1 );
template<typename ScalarType> template<typename ScalarType>
Vector4<ScalarType>::Vector4( ) : x(), y(), z(), w() {} Vector4<ScalarType>::Vector4( ) : x(), y(), z(), w() {}