Index: /trunk/nv.lua =================================================================== --- /trunk/nv.lua (revision 470) +++ /trunk/nv.lua (revision 471) @@ -106,6 +106,4 @@ -- injection! solution( solution().name ) - configuration "*" - includedirs { os.getenv("GLM_PATH") } configuration "gmake" if _ACTION == "gmake-clang" then Index: /trunk/nv/base/capi.hh =================================================================== --- /trunk/nv/base/capi.hh (revision 470) +++ /trunk/nv/base/capi.hh (revision 471) @@ -102,6 +102,6 @@ inline void* nvmemcpy( void *dest, const void *src, size_t count ) { + if ( dest == src || count == 0 ) return dest; NV_ASSERT( dest && src, "Bad parameter to nvmemcpy!" ); - if ( dest == src ) return dest; return NV_CAPI_CALL( memcpy )( dest, src, count ); } @@ -109,6 +109,6 @@ inline void* nvmemmove( void *dest, const void *src, size_t count ) { + if ( dest == src || count == 0 ) return dest; NV_ASSERT( dest && src, "Bad parameter to nvmemmove!" ); - if ( dest == src ) return dest; return NV_CAPI_CALL( memmove )( dest, src, count ); } Index: /trunk/nv/base/cmath.hh =================================================================== --- /trunk/nv/base/cmath.hh (revision 470) +++ /trunk/nv/base/cmath.hh (revision 471) @@ -19,7 +19,292 @@ #include - #include +namespace nv +{ + + namespace detail + { + template< typename T > + inline T pow_int( T x, int y ) + { + unsigned int n = static_cast( y >= 0 ? y : -y ); + for ( T z = static_cast( 1 ); ; x *= x ) + { + if ( ( n & 1 ) != 0 ) + z *= x; + if ( ( n >>= 1 ) == 0 ) + return ( y < 0 ? static_cast( 1 ) / z : z ); + } + } + + } + + inline double abs( double x ) + { + return ( ::fabs( x ) ); + } + + inline double pow( double x, int y ) + { + return ( detail::pow_int( x, y ) ); + } + + inline float abs( float x ) + { + return ( ::fabsf( x ) ); + } + + inline float acos( float x ) + { + return ( ::acosf( x ) ); + } + + inline float cosh( float x ) + { + return ( ::coshf( x ) ); + } + + inline float acosh( float x ) + { + return ( ::acoshf( x ) ); + } + + inline float asin( float x ) + { + return ( ::asinf( x ) ); + } + + inline float asinh( float x ) + { + return ( ::asinhf( x ) ); + } + + inline float atan( float x ) + { + return ( ::atanf( x ) ); + } + + inline float atanh( float x ) + { + return ( ::atanhf( x ) ); + } + + inline float atan2( float y, float x ) + { + return ( ::atan2f( y, x ) ); + } + + inline float cbrt( float x ) + { + return ( ::cbrtf( x ) ); + } + + inline float ceil( float x ) + { + return ( ::ceilf( x ) ); + } + + inline float cos( float x ) + { + return ( ::cosf( x ) ); + } + + inline float erf( float x ) + { + return ( ::erff( x ) ); + } + + inline float erfc( float x ) + { + return ( ::erfcf( x ) ); + } + + inline float exp( float x ) + { + return ( ::expf( x ) ); + } + + inline float exp2( float x ) + { + return ( ::exp2f( x ) ); + } + + inline float expm1( float x ) + { + return ( ::expm1f( x ) ); + } + + inline float fabs( float x ) + { + return ( ::fabsf( x ) ); + } + + inline float fdim( float x, float y ) + { + return ( ::fdimf( x, y ) ); + } + + inline float floor( float x ) + { + return ( ::floorf( x ) ); + } + + inline float fma( float x, float y, float z ) + { + return ( ::fmaf( x, y, z ) ); + } + + inline float fmax( float x, float y ) + { + return ( ::fmaxf( x, y ) ); + } + + inline float fmin( float x, float y ) + { + return ( ::fminf( x, y ) ); + } + + inline float fmodf( float x, float y ) + { + return ( ::fmodf( x, y ) ); + } + + inline float frexp( float x, int* y ) + { + return ( ::frexpf( x, y ) ); + } + + inline float hypot( float x, float y ) + { + return ( ::hypotf( x, y ) ); + } + + inline int ilogb( float x ) + { + return ( ::ilogbf( x ) ); + } + + inline float ldexp( float x, int y ) + { + return ( ::ldexpf( x, y ) ); + } + + inline float lgamma( float x ) + { + return ( ::lgammaf( x ) ); + } + + inline long long llrint( float x ) + { + return ( ::llrintf( x ) ); + } + + inline long long llround( float x ) + { + return ( ::llroundf( x ) ); + } + + inline float log( float x ) + { + return ( ::logf( x ) ); + } + + inline float log10( float x ) + { + return ( ::log10f( x ) ); + } + + inline float log1p( float x ) + { + return ( ::log1pf( x ) ); + } + + inline float log2( float x ) + { + return ( ::log2f( x ) ); + } + + inline float logb( float x ) + { + return ( ::logbf( x ) ); + } + + inline long lrint( float x ) + { + return ( ::lrintf( x ) ); + } + + inline long lround( float x ) + { + return ( ::lroundf( x ) ); + } + + inline float modf( float x, float* y ) + { + return ( ::modff( x, y ) ); + } + + inline float pow( float x, float y ) + { + return ( ::powf( x, y ) ); + } + + inline float pow( float x, int y ) + { + return ( detail::pow_int( x, y ) ); + } + + inline float remainder( float x, float y ) + { + return ( ::remainderf( x, y ) ); + } + + inline float rint( float x ) + { + return ( ::rintf( x ) ); + } + + inline float round( float x ) + { + return ( ::roundf( x ) ); + } + + inline float sin( float x ) + { + return ( ::sinf( x ) ); + } + + inline float sinh( float x ) + { + return ( ::sinhf( x ) ); + } + + inline float sqrt( float x ) + { + return ( ::sqrtf( x ) ); + } + + inline float tan( float x ) + { + return ( ::tanf( x ) ); + } + + inline float tanh( float x ) + { + return ( ::tanhf( x ) ); + } + + inline float tgamma( float x ) + { + return ( ::tgammaf( x ) ); + } + + inline float trunc( float x ) + { + return ( ::truncf( x ) ); + } + +} #endif // NV_BASE_CMATH_HH Index: /trunk/nv/base/common.hh =================================================================== --- /trunk/nv/base/common.hh (revision 470) +++ /trunk/nv/base/common.hh (revision 471) @@ -207,4 +207,9 @@ #endif + enum no_init_t + { + no_init + }; + // Typedefs for fixed size types. typedef signed char sint8; @@ -288,4 +293,47 @@ void set_log_handler( log_handler_t ); + template < typename T > + constexpr size_t size( const T& t ) + { + return t.size(); + } + + template < typename T, size_t N > + constexpr size_t size( const T (&)[N] ) + { + return N; + } + + template < typename T > + constexpr bool empty( const T& t ) + { + return t.empty(); + } + + template < typename T, size_t N > + constexpr bool empty( const T(&)[N] ) + { + return N > 0; + } + + template < typename T > + constexpr auto data( T& t ) -> decltype( t.data() ) + { + return t.data(); + } + + template < typename T > + constexpr auto data( const T& t ) -> decltype( t.data() ) + { + return t.data(); + } + + template < typename T, size_t N > + constexpr T* data( T(&array)[N] ) + { + return array; + } + + } // namespace nv Index: /trunk/nv/interface/animated_mesh.hh =================================================================== --- /trunk/nv/interface/animated_mesh.hh (revision 470) +++ /trunk/nv/interface/animated_mesh.hh (revision 471) @@ -30,5 +30,5 @@ uint32 get_fps() const { return m_fps; } // TODO : if loop +1? - uint32 get_frame_count() const { int todo; return m_fend - m_fstart; } + uint32 get_frame_count() const { return m_fend - m_fstart; } uint32 get_start_frame() const { return m_fstart; } uint32 get_end_frame() const { return m_fend; } Index: /trunk/nv/interface/interpolation_raw.hh =================================================================== --- /trunk/nv/interface/interpolation_raw.hh (revision 470) +++ /trunk/nv/interface/interpolation_raw.hh (revision 471) @@ -53,5 +53,5 @@ { quat result; - memcpy(reinterpret_cast(&result), data, sizeof(quat)); + nvmemcpy(reinterpret_cast(&result), data, sizeof(quat)); return result; } Index: /trunk/nv/stl/math.hh =================================================================== --- /trunk/nv/stl/math.hh (revision 470) +++ /trunk/nv/stl/math.hh (revision 471) @@ -4,6 +4,4 @@ // This file is part of Nova libraries. // For conditions of distribution and use, see copying.txt file in root folder. -// -// TODO: https://github.com/cinder/Cinder/commit/56fd3996be207ccca8063bc81648e199930c909d #ifndef NV_STL_MATH_HH @@ -11,4 +9,12 @@ #include +#include +#include +#include +#include +#include +#include +#include +#include #include #include @@ -16,8 +22,9 @@ #include #include +#include #include #include #include - +#include #include Index: /trunk/nv/stl/math/angle.hh =================================================================== --- /trunk/nv/stl/math/angle.hh (revision 470) +++ /trunk/nv/stl/math/angle.hh (revision 471) @@ -167,5 +167,5 @@ static_assert( is_floating_point::value, "Type expected to be floating point!" ); - const T result( acos( clamp( dot( a, b ), T( -1 ), T( 1 ) ) ) ); + const T result( nv::acos( clamp( dot( a, b ), T( -1 ), T( 1 ) ) ) ); return mix( result, -result, dot( ref, cross( a, b ) ) < T( 0 ) ); } Index: /trunk/nv/stl/math/basic.hh =================================================================== --- /trunk/nv/stl/math/basic.hh (revision 470) +++ /trunk/nv/stl/math/basic.hh (revision 471) @@ -77,6 +77,6 @@ inline static T call( const T& a, const T& b, const U& m ) { - T result( ctor::uninitialize ); - for ( component_count_t i = 0; i < component_count( a ); ++i ) + T result( no_init ); + for ( size_t i = 0; i < nv::size( a ); ++i ) result[i] = m[i] ? b[i] : a[i]; return result; @@ -102,14 +102,10 @@ }; - template < typename T, typename U > - struct sign_helper< T, U, false, true > + template < typename T, bool IsFloating > + struct sign_helper< T, T, IsFloating, true > { inline static T call( const T& a ) { - typedef typename make_unsigned::type UT; - typedef typename make_unsigned::type UU; - const U shift( static_cast( sizeof( U ) * 8 - 1 ) ); - const T y( UT( -a ) >> UU( shift ) ); - return ( a >> shift ) | y; + return ( a > T(0) ? T(1) : ( a < T(0) ? T(-1) : T(0) ) ); } }; @@ -278,4 +274,43 @@ } + template < typename T, typename enable_if< !is_vec::value >::type* = nullptr > + constexpr T step( T edge, T x ) + { + return mix( static_cast( 1 ), static_cast( 0 ), less_than( x, edge ) ); + } + + template < typename T, typename enable_if< is_vec::value >::type* = nullptr > + constexpr T step( const T& edge, const T& x ) + { + return mix( static_cast( 1 ), static_cast( 0 ), less_than( x, edge ) ); + } + + template < typename T, typename enable_if< is_vec::value >::type* = nullptr > + constexpr T step( value_type_t edge, const T& x ) + { + return mix( static_cast( 1 ), static_cast( 0 ), less_than( x, edge ) ); + } + + template < typename T, typename enable_if< is_floating_point::value >::type* = nullptr > + constexpr T smoothstep( T edge0, T edge1, T x ) + { + T y( clamp( ( x - edge0 ) / ( edge1 - edge0 ), static_cast( 0 ), static_cast( 1 ) ) ); + return y * y * ( static_cast( 3 ) - static_cast( 2 ) * y ); + } + + template < typename T, typename enable_if< is_fp_vec::value >::type* = nullptr > + constexpr T smoothstep( const T& edge0, const T& edge1, const T& x ) + { + T y( clamp( ( x - edge0 ) / ( edge1 - edge0 ), static_cast( 0 ), static_cast( 1 ) ) ); + return y * y * ( static_cast( 3 ) - static_cast( 2 ) * y ); + } + + template < typename T, typename enable_if< is_fp_vec::value >::type* = nullptr > + constexpr T smoothstep( value_type_t edge0, value_type_t edge1, const T& x ) + { + T y( clamp( ( x - edge0 ) / ( edge1 - edge0 ), static_cast( 0 ), static_cast( 1 ) ) ); + return y * y * ( static_cast( 3 ) - static_cast( 2 ) * y ); + } + } } Index: /trunk/nv/stl/math/cast.hh =================================================================== --- /trunk/nv/stl/math/cast.hh (revision 470) +++ /trunk/nv/stl/math/cast.hh (revision 471) @@ -107,5 +107,5 @@ inline math::tvec2 make_vec2( const T * const ptr ) { - math::tvec2 result( math::ctor::uninitialize ); + math::tvec2 result( no_init ); nvmemcpy( data_cast( result ), ptr, sizeof( math::tvec2 ) ); return result; @@ -115,5 +115,5 @@ inline math::tvec3 make_vec3( const T * const ptr ) { - math::tvec3 result( math::ctor::uninitialize ); + math::tvec3 result( no_init ); nvmemcpy( data_cast( result ), ptr, sizeof( math::tvec3 ) ); return result; @@ -123,5 +123,5 @@ inline math::tvec4 make_vec4( const T * const ptr ) { - math::tvec4 result( math::ctor::uninitialize ); + math::tvec4 result( no_init ); nvmemcpy( data_cast( result ), ptr, sizeof( math::tvec4 ) ); return result; @@ -131,5 +131,5 @@ inline math::tmat2 make_mat2( const T * const ptr ) { - math::tmat2 result( math::ctor::uninitialize ); + math::tmat2 result( no_init ); nvmemcpy( data_cast( result ), ptr, sizeof( math::tmat2 ) ); return result; @@ -139,5 +139,5 @@ inline math::tmat3 make_mat3( const T * const ptr ) { - math::tmat3 result( math::ctor::uninitialize ); + math::tmat3 result( no_init ); nvmemcpy( data_cast( result ), ptr, sizeof( math::tmat3 ) ); return result; @@ -147,5 +147,5 @@ inline math::tmat4 make_mat4( const T * const ptr ) { - math::tmat4 result( math::ctor::uninitialize ); + math::tmat4 result( no_init ); nvmemcpy( data_cast( result ), ptr, sizeof( math::tmat4 ) ); return result; @@ -155,5 +155,5 @@ inline math::tquat make_quat( const T * const ptr ) { - math::tquat result( math::ctor::uninitialize ); + math::tquat result( no_init ); nvmemcpy( data_cast( result ), ptr, sizeof( math::tquat ) ); return result; Index: /trunk/nv/stl/math/common.hh =================================================================== --- /trunk/nv/stl/math/common.hh (revision 470) +++ /trunk/nv/stl/math/common.hh (revision 471) @@ -24,5 +24,4 @@ #include -#include namespace nv @@ -31,13 +30,24 @@ namespace math { - - // TODO: Remove - using glm::inverse; - using glm::transpose; - - using glm::detail::component_count_t; - using glm::detail::component_count; - - using glm::ctor; + template < typename T > struct tvec2; + template < typename T > struct tvec3; + template < typename T > struct tvec4; + + template < typename T > struct tmat2; + template < typename T > struct tmat3; + template < typename T > struct tmat4; + + template < typename T > struct tquat; + + namespace detail + { + template < typename T > + inline tmat2 compute_inverse( const tmat2 & ); + template < typename T > + inline tmat3 compute_inverse( const tmat3 & ); + template < typename T > + inline tmat4 compute_inverse( const tmat4 & ); + } + using ::cos; @@ -58,27 +68,12 @@ using ::round; -#if 0 - template < typename T > using tvec2 = ::glm::detail::tvec2; - template < typename T > using tvec3 = ::glm::detail::tvec3; - template < typename T > using tvec4 = ::glm::detail::tvec4; - template < typename T > using tmat2 = ::glm::detail::tmat2x2; - template < typename T > using tmat3 = ::glm::detail::tmat3x3; - template < typename T > using tmat4 = ::glm::detail::tmat4x4; -#else - template < typename T > using tvec2 = ::glm::tvec2; - template < typename T > using tvec3 = ::glm::tvec3; - template < typename T > using tvec4 = ::glm::tvec4; - template < typename T > using tmat2 = ::glm::tmat2x2; - template < typename T > using tmat3 = ::glm::tmat3x3; - template < typename T > using tmat4 = ::glm::tmat4x4; -#endif - - template < typename T > struct is_vec : false_type {}; - template < typename T > struct is_mat : false_type {}; + template < typename T > struct is_vec : false_type {}; + template < typename T > struct is_mat : false_type {}; + template < typename T > struct is_quat : false_type {}; template < typename T > struct is_fp : is_floating_point< T > {}; template < typename T > struct is_fp_vec : false_type {}; template < typename T > struct is_fp_mat : false_type {}; - + template < typename T > struct is_fp_quat : false_type {}; template < typename T > struct is_bool_vec : false_type {}; @@ -86,17 +81,27 @@ template < typename T > struct is_vec < tvec3< T > > : true_type {}; template < typename T > struct is_vec < tvec4< T > > : true_type {}; + template < typename T > struct is_mat < tmat2< T > > : true_type {}; template < typename T > struct is_mat < tmat3< T > > : true_type {}; template < typename T > struct is_mat < tmat4< T > > : true_type {}; + template < typename T > struct is_quat < tquat< T > > : true_type {}; + template < typename T > struct is_fp < tvec2< T > > : is_floating_point< T > {}; template < typename T > struct is_fp < tvec3< T > > : is_floating_point< T > {}; template < typename T > struct is_fp < tvec4< T > > : is_floating_point< T > {}; + template < typename T > struct is_fp_vec < tvec2< T > > : is_floating_point< T > {}; template < typename T > struct is_fp_vec < tvec3< T > > : is_floating_point< T > {}; template < typename T > struct is_fp_vec < tvec4< T > > : is_floating_point< T > {}; + template < typename T > struct is_fp_mat < tmat2< T > > : is_floating_point< T > {}; template < typename T > struct is_fp_mat < tmat3< T > > : is_floating_point< T > {}; template < typename T > struct is_fp_mat < tmat4< T > > : is_floating_point< T > {}; + + template < typename T > struct is_fp_quat< tquat< T > > : is_floating_point< T > {}; + + template < typename T > struct is_vec_or_quat : is_vec< T > {}; + template < typename T > struct is_vec_or_quat< tquat< T > > : true_type {}; template <> struct is_bool_vec < tvec2< bool > > : true_type {}; Index: /trunk/nv/stl/math/exponential.hh =================================================================== --- /trunk/nv/stl/math/exponential.hh (revision 470) +++ /trunk/nv/stl/math/exponential.hh (revision 471) @@ -68,5 +68,5 @@ inline T inversesqrt( const T& x ) { - return static_cast( 1 ) / sqrt( x ); + return static_cast( 1 ) / nv::sqrt( x ); } Index: /trunk/nv/stl/math/geometric.hh =================================================================== --- /trunk/nv/stl/math/geometric.hh (revision 470) +++ /trunk/nv/stl/math/geometric.hh (revision 471) @@ -34,5 +34,5 @@ inline static T get( const tvec2& a, const tvec2& b ) { - tvec2 tmp( a * b ); + tvec2 tmp( a * b ); return tmp.x + tmp.y; } @@ -69,5 +69,5 @@ inline value_type_t length( const T& v ) { - return sqrt( dot( v, v ) ); + return nv::sqrt( dot( v, v ) ); } Index: /trunk/nv/stl/math/mat2.hh =================================================================== --- /trunk/nv/stl/math/mat2.hh (revision 471) +++ /trunk/nv/stl/math/mat2.hh (revision 471) @@ -0,0 +1,373 @@ +// Copyright (C) 2015-2015 ChaosForge Ltd +// http://chaosforge.org/ +// +// This file is part of Nova libraries. +// For conditions of distribution and use, see copying.txt file in root folder. + +/** +* @file mat2.hh +* @author Kornel Kisielewicz epyon@chaosforge.org +* @brief matrix 2x2 +*/ + +#ifndef NV_STL_MATH_MAT2_HH +#define NV_STL_MATH_MAT2_HH + +#include + +namespace nv +{ + + namespace math + { + + template < typename T > + struct tmat2 + { + typedef tvec2 column_type; + typedef tvec2 row_type; + typedef tmat2 this_type; + typedef size_t size_type; + typedef T value_type; + + static constexpr size_type SIZE = 2; + inline constexpr size_type size() const { return 2; } + + private: + column_type value[2]; + + public: + + inline tmat2() + : value{ + column_type( static_cast( 1 ), static_cast( 0 ) ), + column_type( static_cast( 0 ), static_cast( 1 ) ) + } + {} + + inline tmat2( const tmat2 & m ) = default; + inline tmat2( tmat2 && m ) = default; + inline tmat2 & operator=( const tmat2 & m ) = default; + inline tmat2 & operator=( tmat2 && m ) = default; + + inline explicit tmat2( T x ) + : value{ + column_type( static_cast( x ), static_cast( 0 ) ), + column_type( static_cast( 0 ), static_cast( x ) ) + } + {} + + inline explicit tmat2( no_init_t ) + : value{ + column_type( no_init ), + column_type( no_init ) + } + {} + + inline tmat2( + T x0, T y0, + T x1, T y1 + ) : value{ + column_type( x0, y0 ), + column_type( x1, y1 ) + } + {} + + inline tmat2( + const column_type & v0, + const column_type & v1 + ) : value{ v0, v1 } + {} + + template + inline explicit tmat2( const tmat2 & m ) + : value{ + column_type( m[0] ), + column_type( m[1] ) + } + {} + + inline explicit tmat2( const tmat3 & m ) + : value{ + column_type( m[0] ), + column_type( m[1] ) + } + {} + + inline explicit tmat2( const tmat4 & m ) + : value{ + column_type( m[0] ), + column_type( m[1] ) + } + {} + + inline column_type & operator[]( size_type i ) + { + NV_ASSERT_DEBUG( i >= 0 && i < this->size(), "index out of range!" ); + return this->value[i]; + } + + inline const column_type& operator[]( size_type i ) const + { + NV_ASSERT_DEBUG( i >= 0 && i < this->size(), "index out of range!" ); + return this->value[i]; + } + + + inline tmat2 & operator+=( T s ) + { + this->value[0] += s; + this->value[1] += s; + return *this; + } + + inline tmat2 & operator+=( const tmat2 & m ) + { + this->value[0] += m[0]; + this->value[1] += m[1]; + return *this; + } + + inline tmat2 & operator-=( T s ) + { + this->value[0] -= s; + this->value[1] -= s; + return *this; + } + + inline tmat2 & operator-=( const tmat2 & m ) + { + this->value[0] -= m[0]; + this->value[1] -= m[1]; + return *this; + } + + inline tmat2 & operator*=( T s ) + { + this->value[0] *= s; + this->value[1] *= s; + return *this; + } + + inline tmat2 & operator*=( const tmat2 & m ) + { + return ( *this = *this * m ); + } + + inline tmat2 & operator/=( T s ) + { + this->value[0] /= s; + this->value[1] /= s; + return *this; + } + + inline tmat2 & operator/=( const tmat2 & m ) + { + return ( *this = *this * detail::compute_inverse( m ) ); + } + + inline tmat2 & operator++ () + { + ++this->value[0]; + ++this->value[1]; + return *this; + } + + inline tmat2 & operator-- () + { + --this->value[0]; + --this->value[1]; + return *this; + } + + inline tmat2 operator++( int ) + { + tmat2 result( *this ); + ++*this; + return result; + } + + inline tmat2 operator--( int ) + { + tmat2 result( *this ); + --*this; + return result; + } + + }; + + namespace detail + { + template + inline tmat2 compute_inverse( const tmat2 & m ) + { + T one_over_det = static_cast( 1 ) / ( m[0][0] * m[1][1] - m[1][0] * m[0][1] ); + + return tmat2( + +m[1][1] * one_over_det, + -m[0][1] * one_over_det, + -m[1][0] * one_over_det, + +m[0][0] * one_over_det + ); + } + + } + + template + inline tmat2 const operator-( const tmat2 & m ) + { + return tmat2( + -m[0], + -m[1] ); + } + + template + inline tmat2 operator+( const tmat2 & m, T s ) + { + return tmat2( + m[0] + s, + m[1] + s ); + } + + template + inline tmat2 operator+( T s, const tmat2 & m ) + { + return tmat2( + m[0] + s, + m[1] + s ); + } + + template + inline tmat2 operator+( const tmat2 & m1, const tmat2 & m2 ) + { + return tmat2( + m1[0] + m2[0], + m1[1] + m2[1] ); + } + + template + inline tmat2 operator-( const tmat2 & m, T s ) + { + return tmat2( + m[0] - s, + m[1] - s ); + } + + template + inline tmat2 operator-( T s, const tmat2 & m ) + { + return tmat2( + s - m[0], + s - m[1] ); + } + + template + inline tmat2 operator-( const tmat2 & m1, const tmat2 & m2 ) + { + return tmat2( + m1[0] - m2[0], + m1[1] - m2[1] ); + } + + template + inline tmat2 operator*( const tmat2 & m, T s ) + { + return tmat2( + m[0] * s, + m[1] * s ); + } + + template + inline tmat2 operator*( T s, const tmat2 & m ) + { + return tmat2( + m[0] * s, + m[1] * s ); + } + + template + inline typename tmat2::column_type operator* + ( + const tmat2 & m, + typename const tmat2::row_type & v + ) + { + return tvec2( + m[0][0] * v.x + m[1][0] * v.y, + m[0][1] * v.x + m[1][1] * v.y ); + } + + template + inline typename tmat2::row_type operator* + ( + typename const tmat2::column_type & v, + const tmat2 & m + ) + { + return tvec2( + v.x * m[0][0] + v.y * m[0][1], + v.x * m[1][0] + v.y * m[1][1] ); + } + + template + inline tmat2 operator*( const tmat2 & m1, const tmat2 & m2 ) + { + return tmat2( + m1[0][0] * m2[0][0] + m1[1][0] * m2[0][1], + m1[0][1] * m2[0][0] + m1[1][1] * m2[0][1], + m1[0][0] * m2[1][0] + m1[1][0] * m2[1][1], + m1[0][1] * m2[1][0] + m1[1][1] * m2[1][1] ); + } + + template + inline tmat2 operator/( const tmat2 & m, T s ) + { + return tmat2( + m[0] / s, + m[1] / s ); + } + + template + inline tmat2 operator/( T s, const tmat2 & m ) + { + return tmat2( + s / m[0], + s / m[1] ); + } + + template + inline typename tmat2::column_type operator/( const tmat2 & m, typename const tmat2::row_type & v ) + { + return detail::compute_inverse( m ) * v; + } + + template + inline typename tmat2::row_type operator/( typename const tmat2::column_type & v, const tmat2 & m ) + { + return v * detail::compute_inverse( m ); + } + + template + inline tmat2 operator/( const tmat2 & m1, const tmat2 & m2 ) + { + tmat2 m1_copy( m1 ); + return m1_copy /= m2; + } + + template + inline bool operator==( const tmat2 & m1, const tmat2 & m2 ) + { + return ( m1[0] == m2[0] ) && ( m1[1] == m2[1] ); + } + + template + inline bool operator!=( const tmat2 & m1, const tmat2 & m2 ) + { + return ( m1[0] != m2[0] ) || ( m1[1] != m2[1] ); + } + + } + +} + +#endif // NV_STL_MATH_MAT2_HH Index: /trunk/nv/stl/math/mat3.hh =================================================================== --- /trunk/nv/stl/math/mat3.hh (revision 471) +++ /trunk/nv/stl/math/mat3.hh (revision 471) @@ -0,0 +1,408 @@ +// Copyright (C) 2015-2015 ChaosForge Ltd +// http://chaosforge.org/ +// +// This file is part of Nova libraries. +// For conditions of distribution and use, see copying.txt file in root folder. + +/** +* @file mat3.hh +* @author Kornel Kisielewicz epyon@chaosforge.org +* @brief matrix 3x3 +*/ + +#ifndef NV_STL_MATH_MAT3_HH +#define NV_STL_MATH_MAT3_HH + +#include + +namespace nv +{ + + namespace math + { + template + struct tmat3 + { + typedef tvec3 column_type; + typedef tvec3 row_type; + typedef tmat3 type; + typedef size_t size_type; + typedef T value_type; + + static constexpr size_type SIZE = 3; + inline constexpr size_type size() const { return 3; } + private: + column_type value[3]; + + public: + + inline tmat3() + : value{ + column_type( static_cast( 1 ), static_cast( 0 ), static_cast( 0 ) ), + column_type( static_cast( 0 ), static_cast( 1 ), static_cast( 0 ) ), + column_type( static_cast( 0 ), static_cast( 0 ), static_cast( 1 ) ) + } + {} + + inline tmat3( const tmat3& m ) = default; + inline tmat3( tmat3&& m ) = default; + inline tmat3 & operator=( const tmat3 & m ) = default; + inline tmat3 & operator=( tmat3 && m ) = default; + + inline explicit tmat3( T s ) + : value{ + column_type( static_cast( s ), static_cast( 0 ), static_cast( 0 ) ), + column_type( static_cast( 0 ), static_cast( s ), static_cast( 0 ) ), + column_type( static_cast( 0 ), static_cast( 0 ), static_cast( s ) ) + } + {} + + inline explicit tmat3( no_init_t ) + : value{ + column_type( no_init ), + column_type( no_init ), + column_type( no_init ) + } + {} + + inline tmat3( + T x0, T y0, T z0, + T x1, T y1, T z1, + T x2, T y2, T z2 + ) : value{ + column_type( x0, y0, z0 ), + column_type( x1, y1, z1 ), + column_type( x2, y2, z2 ) + } + {} + + inline tmat3( + const column_type & v0, + const column_type & v1, + const column_type & v2 + ) : value{ v0, v1, v2 } + {} + + template + inline explicit tmat3( const tmat3 & m ) + : value{ + column_type( m[0] ), + column_type( m[1] ), + column_type( m[2] ) + } + {} + + inline explicit tmat3( const tmat2 & m ) + : value{ + column_type( m[0], static_cast( 0 ) ), + column_type( m[1], static_cast( 0 ) ), + column_type( static_cast( 0 ), static_cast( 1 ) ) + } + {} + + inline explicit tmat3( const tmat4 & m ) + : value{ + column_type( m[0] ), + column_type( m[1] ), + column_type( m[2] ) + } + {} + + inline column_type & operator[]( size_type i ) + { + NV_ASSERT_DEBUG( i >= 0 && i < this->size(), "index out of range!" ); + return this->value[i]; + } + + inline const column_type& operator[]( size_type i ) const + { + NV_ASSERT_DEBUG( i >= 0 && i < this->size(), "index out of range!" ); + return this->value[i]; + } + + + inline tmat3 & operator+=( T s ) + { + this->value[0] += s; + this->value[1] += s; + this->value[2] += s; + return *this; + } + + inline tmat3 & operator+=( const tmat3 & m ) + { + this->value[0] += m[0]; + this->value[1] += m[1]; + this->value[2] += m[2]; + return *this; + } + + inline tmat3 & operator-=( T s ) + { + this->value[0] -= s; + this->value[1] -= s; + this->value[2] -= s; + return *this; + } + + inline tmat3 & operator-=( const tmat3 & m ) + { + this->value[0] -= m[0]; + this->value[1] -= m[1]; + this->value[2] -= m[2]; + return *this; + } + + inline tmat3 & operator*=( T s ) + { + this->value[0] *= s; + this->value[1] *= s; + this->value[2] *= s; + return *this; + } + + inline tmat3 & operator*=( const tmat3 & m ) + { + return ( *this = *this * m ); + } + + inline tmat3 & operator/=( T s ) + { + this->value[0] /= s; + this->value[1] /= s; + this->value[2] /= s; + return *this; + } + + inline tmat3 & operator/=( const tmat3 & m ) + { + return ( *this = *this * detail::compute_inverse( m ) ); + } + + inline tmat3 & operator++() + { + ++this->value[0]; + ++this->value[1]; + ++this->value[2]; + return *this; + } + + inline tmat3 & operator--() + { + --this->value[0]; + --this->value[1]; + --this->value[2]; + return *this; + } + + inline tmat3 operator++( int ) + { + tmat3 result( *this ); + ++*this; + return result; + } + + inline tmat3 operator--( int ) + { + tmat3 result( *this ); + --*this; + return result; + } + }; + + namespace detail + { + template + inline tmat3 compute_inverse( const tmat3 & m ) + { + T one_over_det = static_cast( 1 ) / ( + + m[0][0] * ( m[1][1] * m[2][2] - m[2][1] * m[1][2] ) + - m[1][0] * ( m[0][1] * m[2][2] - m[2][1] * m[0][2] ) + + m[2][0] * ( m[0][1] * m[1][2] - m[1][1] * m[0][2] ) + ); + + tmat3 result( no_init ); + result[0][0] = +( m[1][1] * m[2][2] - m[2][1] * m[1][2] ) * one_over_det; + result[1][0] = -( m[1][0] * m[2][2] - m[2][0] * m[1][2] ) * one_over_det; + result[2][0] = +( m[1][0] * m[2][1] - m[2][0] * m[1][1] ) * one_over_det; + result[0][1] = -( m[0][1] * m[2][2] - m[2][1] * m[0][2] ) * one_over_det; + result[1][1] = +( m[0][0] * m[2][2] - m[2][0] * m[0][2] ) * one_over_det; + result[2][1] = -( m[0][0] * m[2][1] - m[2][0] * m[0][1] ) * one_over_det; + result[0][2] = +( m[0][1] * m[1][2] - m[1][1] * m[0][2] ) * one_over_det; + result[1][2] = -( m[0][0] * m[1][2] - m[1][0] * m[0][2] ) * one_over_det; + result[2][2] = +( m[0][0] * m[1][1] - m[1][0] * m[0][1] ) * one_over_det; + + return result; + } + + } + + template + inline tmat3 const operator-( const tmat3 & m ) + { + return tmat3( + -m[0], + -m[1], + -m[2] ); + } + + template + inline tmat3 operator+( const tmat3 & m, T s ) + { + return tmat3( + m[0] + s, + m[1] + s, + m[2] + s ); + } + + template + inline tmat3 operator+( T s, const tmat3 & m ) + { + return tmat3( + m[0] + s, + m[1] + s, + m[2] + s ); + } + + template + inline tmat3 operator+( const tmat3 & m1, const tmat3 & m2 ) + { + return tmat3( + m1[0] + m2[0], + m1[1] + m2[1], + m1[2] + m2[2] ); + } + + template + inline tmat3 operator-( const tmat3 & m, T s ) + { + return tmat3( + m[0] - s, + m[1] - s, + m[2] - s ); + } + + template + inline tmat3 operator-( T s, const tmat3 & m ) + { + return tmat3( + s - m[0], + s - m[1], + s - m[2] ); + } + + template + inline tmat3 operator-( const tmat3 & m1, const tmat3 & m2 ) + { + return tmat3( + m1[0] - m2[0], + m1[1] - m2[1], + m1[2] - m2[2] ); + } + + template + inline tmat3 operator*( const tmat3 & m, T s ) + { + return tmat3( + m[0] * s, + m[1] * s, + m[2] * s ); + } + + template + inline tmat3 operator*( T s, const tmat3 & m ) + { + return tmat3( + m[0] * s, + m[1] * s, + m[2] * s ); + } + + template + inline typename tmat3::column_type operator*( const tmat3 & m, typename const tmat3::row_type & v ) + { + return typename tmat3::column_type( + m[0][0] * v.x + m[1][0] * v.y + m[2][0] * v.z, + m[0][1] * v.x + m[1][1] * v.y + m[2][1] * v.z, + m[0][2] * v.x + m[1][2] * v.y + m[2][2] * v.z ); + } + + template + inline typename tmat3::row_type operator*( typename const tmat3::column_type & v, const tmat3 & m ) + { + return typename tmat3::row_type( + m[0][0] * v.x + m[0][1] * v.y + m[0][2] * v.z, + m[1][0] * v.x + m[1][1] * v.y + m[1][2] * v.z, + m[2][0] * v.x + m[2][1] * v.y + m[2][2] * v.z ); + } + + template + inline tmat3 operator*( const tmat3 & m1, const tmat3 & m2 ) + { + tmat3 result( no_init ); + result[0][0] = m1[0][0] * m2[0][0] + m1[1][0] * m2[0][1] + m1[2][0] * m2[0][2]; + result[0][1] = m1[0][1] * m2[0][0] + m1[1][1] * m2[0][1] + m1[2][1] * m2[0][2]; + result[0][2] = m1[0][2] * m2[0][0] + m1[1][2] * m2[0][1] + m1[2][2] * m2[0][2]; + result[1][0] = m1[0][0] * m2[1][0] + m1[1][0] * m2[1][1] + m1[2][0] * m2[1][2]; + result[1][1] = m1[0][1] * m2[1][0] + m1[1][1] * m2[1][1] + m1[2][1] * m2[1][2]; + result[1][2] = m1[0][2] * m2[1][0] + m1[1][2] * m2[1][1] + m1[2][2] * m2[1][2]; + result[2][0] = m1[0][0] * m2[2][0] + m1[1][0] * m2[2][1] + m1[2][0] * m2[2][2]; + result[2][1] = m1[0][1] * m2[2][0] + m1[1][1] * m2[2][1] + m1[2][1] * m2[2][2]; + result[2][2] = m1[0][2] * m2[2][0] + m1[1][2] * m2[2][1] + m1[2][2] * m2[2][2]; + return result; + } + + template + inline tmat3 operator/( const tmat3 & m, T s ) + { + return tmat3( + m[0] / s, + m[1] / s, + m[2] / s ); + } + + template + inline tmat3 operator/( T s, const tmat3 & m ) + { + return tmat3( + s / m[0], + s / m[1], + s / m[2] ); + } + + template + inline typename tmat3::column_type operator/( const tmat3 & m, typename const tmat3::row_type & v ) + { + return detail::compute_inverse( m ) * v; + } + + template + inline typename tmat3::row_type operator/( typename const tmat3::column_type & v, const tmat3 & m ) + { + return v * detail::compute_inverse( m ); + } + + template + inline tmat3 operator/( const tmat3 & m1, const tmat3 & m2 ) + { + tmat3 m1_copy( m1 ); + return m1_copy /= m2; + } + + template + inline bool operator==( const tmat3 & m1, const tmat3 & m2 ) + { + return ( m1[0] == m2[0] ) && ( m1[1] == m2[1] ) && ( m1[2] == m2[2] ); + } + + template + inline bool operator!=( const tmat3 & m1, const tmat3 & m2 ) + { + return ( m1[0] != m2[0] ) || ( m1[1] != m2[1] ) || ( m1[2] != m2[2] ); + } + + } + +} + +#endif // NV_STL_MATH_MAT3_HH Index: /trunk/nv/stl/math/mat4.hh =================================================================== --- /trunk/nv/stl/math/mat4.hh (revision 471) +++ /trunk/nv/stl/math/mat4.hh (revision 471) @@ -0,0 +1,475 @@ +// Copyright (C) 2015-2015 ChaosForge Ltd +// http://chaosforge.org/ +// +// This file is part of Nova libraries. +// For conditions of distribution and use, see copying.txt file in root folder. + +/** + * @file mat4.hh + * @author Kornel Kisielewicz epyon@chaosforge.org + * @brief matrix 4x4 + */ + +#ifndef NV_STL_MATH_MAT4_HH +#define NV_STL_MATH_MAT4_HH + +#include + +namespace nv +{ + + namespace math + { + + template + struct tmat4 + { + typedef tvec4 column_type; + typedef tvec4 row_type; + typedef tmat4 this_type; + typedef size_t size_type; + typedef T value_type; + + static constexpr size_type SIZE = 4; + inline constexpr size_type size() const { return 4; } + + private: + column_type value[4]; + + public: + inline tmat4() + : value{ + column_type( static_cast( 1 ), static_cast( 0 ), static_cast( 0 ), static_cast( 0 ) ), + column_type( static_cast( 0 ), static_cast( 1 ), static_cast( 0 ), static_cast( 0 ) ), + column_type( static_cast( 0 ), static_cast( 0 ), static_cast( 1 ), static_cast( 0 ) ), + column_type( static_cast( 0 ), static_cast( 0 ), static_cast( 0 ), static_cast( 1 ) ) + } + {} + + inline tmat4( const tmat4 & m ) = default; + inline tmat4( tmat4 && m ) = default; + inline tmat4 & operator=( const tmat4 & m ) = default; + inline tmat4 & operator=( tmat4 && m ) = default; + + inline explicit tmat4( T s ) + : value{ + column_type( static_cast( s ), static_cast( 0 ), static_cast( 0 ), static_cast( 0 ) ), + column_type( static_cast( 0 ), static_cast( s ), static_cast( 0 ), static_cast( 0 ) ), + column_type( static_cast( 0 ), static_cast( 0 ), static_cast( s ), static_cast( 0 ) ), + column_type( static_cast( 0 ), static_cast( 0 ), static_cast( 0 ), static_cast( s ) ) + } + {} + + inline explicit tmat4( no_init_t ) + : value{ + column_type( no_init ), + column_type( no_init ), + column_type( no_init ), + column_type( no_init ) + } + {} + + inline tmat4( + T x0, T y0, T z0, T w0, + T x1, T y1, T z1, T w1, + T x2, T y2, T z2, T w2, + T x3, T y3, T z3, T w3 + ) : value{ + column_type( x0, y0, z0, w0 ), + column_type( x1, y1, z1, w1 ), + column_type( x2, y2, z2, w2 ), + column_type( x3, y3, z3, w3 ) + } + {} + + inline tmat4( + const column_type & v0, + const column_type & v1, + const column_type & v2, + const column_type & v3 + ) : value{ v0, v1, v2, v3 } + {} + + template + inline explicit tmat4( const tmat4 & m ) + : value{ + column_type( m[0] ), + column_type( m[1] ), + column_type( m[2] ), + column_type( m[3] ) + } + {} + + inline explicit tmat4( const tmat2 & m ) + : value{ + column_type( m[0], static_cast( 0 ), static_cast( 0 ) ), + column_type( m[1], static_cast( 0 ), static_cast( 0 ) ), + column_type( static_cast( 0 ), static_cast( 0 ), static_cast( 1 ), static_cast( 0 ) ), + column_type( static_cast( 0 ), static_cast( 0 ), static_cast( 0 ), static_cast( 1 ) ) + } + {} + + inline explicit tmat4( const tmat3 & m ) + : value{ + column_type( m[0], static_cast( 0 ) ), + column_type( m[1], static_cast( 0 ) ), + column_type( m[2], static_cast( 0 ) ), + column_type( static_cast( 0 ), static_cast( 0 ), static_cast( 0 ), static_cast( 1 ) ) + } + {} + + inline column_type & operator[]( size_type i ) + { + NV_ASSERT_DEBUG( i >= 0 && i < this->size(), "index out of range!" ); + return this->value[i]; + } + + inline const column_type& operator[]( size_type i ) const + { + NV_ASSERT_DEBUG( i >= 0 && i < this->size(), "index out of range!" ); + return this->value[i]; + } + + inline tmat4& operator+=( T s ) + { + this->value[0] += s; + this->value[1] += s; + this->value[2] += s; + this->value[3] += s; + return *this; + } + + inline tmat4& operator+=( const tmat4 & m ) + { + this->value[0] += m[0]; + this->value[1] += m[1]; + this->value[2] += m[2]; + this->value[3] += m[3]; + return *this; + } + + inline tmat4 & operator-=( T s ) + { + this->value[0] -= s; + this->value[1] -= s; + this->value[2] -= s; + this->value[3] -= s; + return *this; + } + + inline tmat4 & operator-=( const tmat4 & m ) + { + this->value[0] -= m[0]; + this->value[1] -= m[1]; + this->value[2] -= m[2]; + this->value[3] -= m[3]; + return *this; + } + + inline tmat4 & operator*=( T s ) + { + this->value[0] *= s; + this->value[1] *= s; + this->value[2] *= s; + this->value[3] *= s; + return *this; + } + + inline tmat4 & operator*=( const tmat4 & m ) + { + return ( *this = *this * m ); + } + + inline tmat4 & operator/=( T s ) + { + this->value[0] /= s; + this->value[1] /= s; + this->value[2] /= s; + this->value[3] /= s; + return *this; + } + + inline tmat4 & operator/=( const tmat4 & m ) + { + return ( *this = *this * detail::compute_inverse( m ) ); + } + + inline tmat4 & operator++() + { + ++this->value[0]; + ++this->value[1]; + ++this->value[2]; + ++this->value[3]; + return *this; + } + + inline tmat4 & operator--() + { + --this->value[0]; + --this->value[1]; + --this->value[2]; + --this->value[3]; + return *this; + } + + inline tmat4 operator++( int ) + { + tmat4 result( *this ); + ++*this; + return result; + } + + inline tmat4 operator--( int ) + { + tmat4 result( *this ); + --*this; + return result; + } + + }; + + namespace detail + { + template + inline tmat4 compute_inverse( const tmat4 & m ) + { + T cf00 = m[2][2] * m[3][3] - m[3][2] * m[2][3]; + T cf02 = m[1][2] * m[3][3] - m[3][2] * m[1][3]; + T cf03 = m[1][2] * m[2][3] - m[2][2] * m[1][3]; + + T cf04 = m[2][1] * m[3][3] - m[3][1] * m[2][3]; + T cf06 = m[1][1] * m[3][3] - m[3][1] * m[1][3]; + T cf07 = m[1][1] * m[2][3] - m[2][1] * m[1][3]; + + T cf08 = m[2][1] * m[3][2] - m[3][1] * m[2][2]; + T cf10 = m[1][1] * m[3][2] - m[3][1] * m[1][2]; + T cf11 = m[1][1] * m[2][2] - m[2][1] * m[1][2]; + + T cf12 = m[2][0] * m[3][3] - m[3][0] * m[2][3]; + T cf14 = m[1][0] * m[3][3] - m[3][0] * m[1][3]; + T cf15 = m[1][0] * m[2][3] - m[2][0] * m[1][3]; + + T cf16 = m[2][0] * m[3][2] - m[3][0] * m[2][2]; + T cf18 = m[1][0] * m[3][2] - m[3][0] * m[1][2]; + T cf19 = m[1][0] * m[2][2] - m[2][0] * m[1][2]; + + T cf20 = m[2][0] * m[3][1] - m[3][0] * m[2][1]; + T cf22 = m[1][0] * m[3][1] - m[3][0] * m[1][1]; + T cf23 = m[1][0] * m[2][1] - m[2][0] * m[1][1]; + + tvec4 f0( cf00, cf00, cf02, cf03 ); + tvec4 f1( cf04, cf04, cf06, cf07 ); + tvec4 f2( cf08, cf08, cf10, cf11 ); + tvec4 f3( cf12, cf12, cf14, cf15 ); + tvec4 f4( cf16, cf16, cf18, cf19 ); + tvec4 f5( cf20, cf20, cf22, cf23 ); + + tvec4 v0( m[1][0], m[0][0], m[0][0], m[0][0] ); + tvec4 v1( m[1][1], m[0][1], m[0][1], m[0][1] ); + tvec4 v2( m[1][2], m[0][2], m[0][2], m[0][2] ); + tvec4 v3( m[1][3], m[0][3], m[0][3], m[0][3] ); + + tvec4 i0( v1 * f0 - v2 * f1 + v3 * f2 ); + tvec4 i1( v0 * f0 - v2 * f3 + v3 * f4 ); + tvec4 i2( v0 * f1 - v1 * f3 + v3 * f5 ); + tvec4 i3( v0 * f2 - v1 * f4 + v2 * f5 ); + + tvec4 sgn_a( +1, -1, +1, -1 ); + tvec4 sgn_b( -1, +1, -1, +1 ); + tmat4 inv( i0 * sgn_a, i1 * sgn_b, i2 * sgn_a, i3 * sgn_b ); + + tvec4 rz( inv[0][0], inv[1][0], inv[2][0], inv[3][0] ); + tvec4 d0( m[0] * rz ); + T d1 = ( d0.x + d0.y ) + ( d0.z + d0.w ); + T one_over_det = static_cast( 1 ) / d1; + + return inv * one_over_det; + } + + } + + + template + inline tmat4 const operator-( const tmat4 & m ) + { + return tmat4( + -m[0], + -m[1], + -m[2], + -m[3] ); + } + + template + inline tmat4 operator+( const tmat4 & m, T s ) + { + return tmat4( + m[0] + s, + m[1] + s, + m[2] + s, + m[3] + s ); + } + + template + inline tmat4 operator+( T s, const tmat4 & m ) + { + return tmat4( + m[0] + s, + m[1] + s, + m[2] + s, + m[3] + s ); + } + + template + inline tmat4 operator+( const tmat4 & m1, const tmat4 & m2 ) + { + return tmat4( + m1[0] + m2[0], + m1[1] + m2[1], + m1[2] + m2[2], + m1[3] + m2[3] ); + } + + template + inline tmat4 operator-( const tmat4 & m, T s ) + { + return tmat4( + m[0] - s, + m[1] - s, + m[2] - s, + m[3] - s ); + } + + template + inline tmat4 operator-( T s, const tmat4 & m ) + { + return tmat4( + s - m[0], + s - m[1], + s - m[2], + s - m[3] ); + } + + template + inline tmat4 operator-( const tmat4 & m1, const tmat4 & m2 ) + { + return tmat4( + m1[0] - m2[0], + m1[1] - m2[1], + m1[2] - m2[2], + m1[3] - m2[3] ); + } + + template + inline tmat4 operator*( const tmat4 & m, T s ) + { + return tmat4( + m[0] * s, + m[1] * s, + m[2] * s, + m[3] * s ); + } + + template + inline tmat4 operator*( T s, const tmat4 & m ) + { + return tmat4( + m[0] * s, + m[1] * s, + m[2] * s, + m[3] * s ); + } + + template + inline typename tmat4::column_type operator*( const tmat4 & m, const typename tmat4::row_type & v ) + { + typedef typename tmat4::column_type column_type; + column_type u0 = m[0] * column_type( v[0] ); + column_type u1 = m[1] * column_type( v[1] ); + column_type u2 = m[2] * column_type( v[2] ); + column_type u3 = m[3] * column_type( v[3] ); + return ( u0 + u1 ) + ( u2 + u3 ); + } + + template + inline typename tmat4::row_type operator* ( const typename tmat4::column_type & v, const tmat4 & m ) + { + return typename tmat4::row_type( + m[0][0] * v[0] + m[0][1] * v[1] + m[0][2] * v[2] + m[0][3] * v[3], + m[1][0] * v[0] + m[1][1] * v[1] + m[1][2] * v[2] + m[1][3] * v[3], + m[2][0] * v[0] + m[2][1] * v[1] + m[2][2] * v[2] + m[2][3] * v[3], + m[3][0] * v[0] + m[3][1] * v[1] + m[3][2] * v[2] + m[3][3] * v[3] + ); + } + + template + inline tmat4 operator*( const tmat4 & m1, const tmat4 & m2 ) + { + typedef typename tmat4::column_type column_type; + column_type m2_0 = m2[0]; + column_type m2_1 = m2[1]; + column_type m2_2 = m2[2]; + column_type m2_3 = m2[3]; + + tmat4 result( no_init ); + result[0] = m1[0] * m2_0[0] + m1[1] * m2_0[1] + m1[2] * m2_0[2] + m1[3] * m2_0[3]; + result[1] = m1[0] * m2_1[0] + m1[1] * m2_1[1] + m1[2] * m2_1[2] + m1[3] * m2_1[3]; + result[2] = m1[0] * m2_2[0] + m1[1] * m2_2[1] + m1[2] * m2_2[2] + m1[3] * m2_2[3]; + result[3] = m1[0] * m2_3[0] + m1[1] * m2_3[1] + m1[2] * m2_3[2] + m1[3] * m2_3[3]; + return result; + } + + template + inline tmat4 operator/( const tmat4 & m, T s ) + { + return tmat4( + m[0] / s, + m[1] / s, + m[2] / s, + m[3] / s ); + } + + template + inline tmat4 operator/( T s, const tmat4 & m ) + { + return tmat4( + s / m[0], + s / m[1], + s / m[2], + s / m[3] ); + } + + template + inline typename tmat4::column_type operator/( const tmat4 & m, typename tmat4::row_type const & v ) + { + return detail::compute_inverse( m ) * v; + } + + template + inline typename tmat4::row_type operator/( typename tmat4::column_type const & v, const tmat4 & m ) + { + return v * detail::compute_inverse( m ); + } + + template + inline tmat4 operator/( const tmat4 & m1, const tmat4 & m2 ) + { + tmat4 m1_copy( m1 ); + return m1_copy /= m2; + } + + template + inline bool operator==( const tmat4 & m1, const tmat4 & m2 ) + { + return ( m1[0] == m2[0] ) && ( m1[1] == m2[1] ) && ( m1[2] == m2[2] ) && ( m1[3] == m2[3] ); + } + + template + inline bool operator!=( const tmat4 & m1, const tmat4 & m2 ) + { + return ( m1[0] != m2[0] ) || ( m1[1] != m2[1] ) || ( m1[2] != m2[2] ) || ( m1[3] != m2[3] ); + } + } + +} + +#endif // NV_STL_MATH_MAT4_HH Index: /trunk/nv/stl/math/matrix.hh =================================================================== --- /trunk/nv/stl/math/matrix.hh (revision 471) +++ /trunk/nv/stl/math/matrix.hh (revision 471) @@ -0,0 +1,144 @@ +// Copyright (C) 2015-2015 ChaosForge Ltd +// http://chaosforge.org/ +// +// This file is part of Nova libraries. +// For conditions of distribution and use, see copying.txt file in root folder. + +/** + * @file basic.hh + * @author Kornel Kisielewicz epyon@chaosforge.org + * @brief basic matrix ops + */ + +#ifndef NV_STL_MATH_MATRIX_HH +#define NV_STL_MATH_MATRIX_HH + +#include +#include +#include +#include +#include + +namespace nv +{ + + namespace math + { + + namespace detail + { + template < typename T > + struct vec_to_mat; + + template < typename T > + struct vec_to_mat< tvec2< T > > + { + typedef tmat2< T > type; + }; + + template < typename T > + struct vec_to_mat< tvec3< T > > + { + typedef tmat3< T > type; + }; + + template < typename T > + struct vec_to_mat< tvec4< T > > + { + typedef tmat4< T > type; + }; + } + + template < typename T, typename enable_if< is_mat::value >::type* = nullptr > + inline T matrix_comp_mult( const T& x, const T& y ) + { + T result( no_init ); + for ( size_t i = 0; i < nv::size( result ); ++i ) + result[i] = x[i] * y[i]; + return result; + } + + template < typename T, typename enable_if< is_fp_vec::value >::type* = nullptr > + inline typename detail::vec_to_mat::type outer_product( const T& c, const T& r ) + { + typename detail::vec_to_mat::type result( no_init ); + for ( size_t i = 0; i < nv::size( result ); ++i ) + result[i] = c * r[i]; + return result; + } + + template < typename T > + inline tmat2 transpose( const tmat2& m ) + { + tmat2 result( no_init ); + result[0][0] = m[0][0]; result[0][1] = m[1][0]; + result[1][0] = m[0][1]; result[1][1] = m[1][1]; + return result; + } + + template < typename T > + inline tmat3 transpose( const tmat3& m ) + { + tmat3 result( no_init ); + result[0][0] = m[0][0]; result[0][1] = m[1][0]; result[0][2] = m[2][0]; + result[1][0] = m[0][1]; result[1][1] = m[1][1]; result[1][2] = m[2][1]; + result[2][0] = m[0][2]; result[2][1] = m[1][2]; result[2][2] = m[2][2]; + return result; + } + + template < typename T > + inline tmat4 transpose( const tmat4& m ) + { + tmat4 result( no_init ); + result[0][0] = m[0][0]; result[0][1] = m[1][0]; result[0][2] = m[2][0]; result[0][3] = m[3][0]; + result[1][0] = m[0][1]; result[1][1] = m[1][1]; result[1][2] = m[2][1]; result[1][3] = m[3][1]; + result[2][0] = m[0][2]; result[2][1] = m[1][2]; result[2][2] = m[2][2]; result[2][3] = m[3][2]; + result[3][0] = m[0][3]; result[3][1] = m[1][3]; result[3][2] = m[2][3]; result[3][3] = m[3][3]; + return result; + } + + template < typename T > + inline T determinant( const tmat2& m ) + { + return m[0][0] * m[1][1] - m[1][0] * m[0][1]; + } + + template < typename T > + inline T determinant( const tmat3& m ) + { + return + m[0][0] * ( m[1][1] * m[2][2] - m[2][1] * m[1][2] ) + - m[1][0] * ( m[0][1] * m[2][2] - m[2][1] * m[0][2] ) + + m[2][0] * ( m[0][1] * m[1][2] - m[1][1] * m[0][2] ); + } + + template < typename T > + inline T determinant( const tmat4& m ) + { + T sub0 = m[2][2] * m[3][3] - m[3][2] * m[2][3]; + T sub1 = m[2][1] * m[3][3] - m[3][1] * m[2][3]; + T sub2 = m[2][1] * m[3][2] - m[3][1] * m[2][2]; + T sub3 = m[2][0] * m[3][3] - m[3][0] * m[2][3]; + T sub4 = m[2][0] * m[3][2] - m[3][0] * m[2][2]; + T sub5 = m[2][0] * m[3][1] - m[3][0] * m[2][1]; + + tvec4 cf( + +( m[1][1] * sub0 - m[1][2] * sub1 + m[1][3] * sub2 ), + -( m[1][0] * sub0 - m[1][2] * sub3 + m[1][3] * sub4 ), + +( m[1][0] * sub1 - m[1][1] * sub3 + m[1][3] * sub5 ), + -( m[1][0] * sub2 - m[1][1] * sub4 + m[1][2] * sub5 ) + ); + + return m[0][0] * cf[0] + m[0][1] * cf[1] + m[0][2] * cf[2] + m[0][3] * cf[3]; + } + + template < typename T, typename enable_if< is_fp_mat< T >::value >::type* = nullptr > + inline T inverse( const T& m ) + { + return detail::compute_inverse( m ); + } + + } + +} + +#endif // NV_STL_MATH_MATRIX_HH Index: /trunk/nv/stl/math/matrix_transform.hh =================================================================== --- /trunk/nv/stl/math/matrix_transform.hh (revision 470) +++ /trunk/nv/stl/math/matrix_transform.hh (revision 471) @@ -34,11 +34,11 @@ { T const a = angle; - T const c = math::cos( a ); - T const s = math::sin( a ); + T const c = nv::cos( a ); + T const s = nv::sin( a ); tvec3 axis( normalize( v ) ); tvec3 temp( ( T( 1 ) - c ) * axis ); - tmat4 Rotate( ctor::uninitialize ); + tmat4 Rotate( no_init ); Rotate[0][0] = c + temp[0] * axis[0]; Rotate[0][1] = 0 + temp[0] * axis[1] + s * axis[2]; @@ -53,5 +53,5 @@ Rotate[2][2] = c + temp[2] * axis[2]; - tmat4 result( ctor::uninitialize ); + tmat4 result( no_init ); result[0] = m[0] * Rotate[0][0] + m[1] * Rotate[0][1] + m[2] * Rotate[0][2]; result[1] = m[0] * Rotate[1][0] + m[1] * Rotate[1][1] + m[2] * Rotate[1][2]; @@ -64,5 +64,5 @@ inline tmat4 scale( const tmat4& m, const tvec3& v ) { - tmat4 result( ctor::uninitialize ); + tmat4 result( no_init ); result[0] = m[0] * v[0]; result[1] = m[1] * v[1]; @@ -134,5 +134,5 @@ NV_ASSERT( abs( aspect - epsilon() ) > static_cast( 0 ), "bad parameters to math::perspective!" ); - const T tan_half_fovy = math::tan( fovy / static_cast( 2 ) ); + const T tan_half_fovy = nv::tan( fovy / static_cast( 2 ) ); tmat4 result( static_cast( 0 ) ); @@ -153,5 +153,5 @@ const T rad = fov; - const T h = math::cos( static_cast( 0.5 ) * rad ) / math::sin( static_cast( 0.5 ) * rad ); + const T h = nv::cos( static_cast( 0.5 ) * rad ) / math::sin( static_cast( 0.5 ) * rad ); const T w = h * height / width; Index: /trunk/nv/stl/math/quaternion.hh =================================================================== --- /trunk/nv/stl/math/quaternion.hh (revision 470) +++ /trunk/nv/stl/math/quaternion.hh (revision 471) @@ -18,4 +18,5 @@ #include #include +#include namespace nv @@ -52,5 +53,5 @@ : x( q.x ), y( q.y ), z( q.z ), w( q.w ) {} - inline explicit tquat( ctor ) {} + inline explicit tquat( no_init_t ) {} constexpr explicit tquat( const T& s, const tvec3& v ) : x( v.x ), y( v.y ), z( v.z ), w( s ) {} @@ -113,10 +114,4 @@ typedef tquat< f32 > quat; - template < typename T > struct is_fp_quat : false_type {}; - template < typename T > struct is_quat : false_type {}; - - template < typename T > struct is_quat< tquat< T > > : true_type {}; - template < typename T > struct is_fp_quat< tquat< T > > : is_floating_point< T > {}; - namespace detail { @@ -192,5 +187,5 @@ else { - T angle = acos( cos_theta ); + T angle = nv::acos( cos_theta ); return ( sin( ( T( 1 ) - m ) * angle ) * a + sin( m * angle ) * b ) / sin( angle ); } @@ -226,6 +221,6 @@ else { - T angle = acos( cos_theta ); - return ( sin( ( T( 1 ) - m ) * angle ) * x + sin( m * angle ) * z ) / sin( angle ); + T angle = nv::acos( cos_theta ); + return ( nv::sin( ( T( 1 ) - m ) * angle ) * x + nv::sin( m * angle ) * z ) / nv::sin( angle ); } } @@ -332,8 +327,8 @@ } - T vmax = sqrt( fmax + T( 1 ) ) * T( 0.5 ); + T vmax = nv::sqrt( fmax + T( 1 ) ) * T( 0.5 ); T mult = static_cast( 0.25 ) / vmax; - tquat result( ctor::uninitialize ); + tquat result( no_init ); switch ( imax ) { @@ -392,7 +387,7 @@ inline tquat angle_axis( T angle, const tvec3& v ) { - tquat result( ctor::uninitialize ); - T sina = sin( angle * static_cast( 0.5 ) ); - result.w = cos( angle * static_cast( 0.5 ) ); + tquat result( no_init ); + T sina = nv::sin( angle * static_cast( 0.5 ) ); + result.w = nv::cos( angle * static_cast( 0.5 ) ); result.x = v.x * sina; result.y = v.y * sina; @@ -402,58 +397,4 @@ template < typename T > - inline tvec4 less_than( const tquat& lhs, const tquat& rhs ) - { - tvec4 result( ctor::uninitialize ); - for ( component_count_t i = 0; i < component_count( x ); ++i ) - result[i] = rhs[i] < lhs[i]; - return result; - } - - template < typename T > - inline tvec4 less_than_equal( const tquat& lhs, const tquat& rhs ) - { - tvec4 result( ctor::uninitialize ); - for ( component_count_t i = 0; i < component_count( x ); ++i ) - result[i] = rhs[i] <= lhs[i]; - return result; - } - - template < typename T > - inline tvec4 greater_than( const tquat& lhs, const tquat& rhs ) - { - tvec4 result( ctor::uninitialize ); - for ( component_count_t i = 0; i < component_count( x ); ++i ) - result[i] = rhs[i] > lhs[i]; - return result; - } - - template < typename T > - inline tvec4 greater_than_equal( const tquat& lhs, const tquat& rhs ) - { - tvec4 result( ctor::uninitialize ); - for ( component_count_t i = 0; i < component_count( x ); ++i ) - result[i] = rhs[i] >= lhs[i]; - return result; - } - - template < typename T > - inline tvec4 equal( const tquat& lhs, const tquat& rhs ) - { - tvec4 result( ctor::uninitialize ); - for ( component_count_t i = 0; i < component_count( x ); ++i ) - result[i] = rhs[i] == lhs[i]; - return result; - } - - template < typename T > - inline tvec4 not_equal( const tquat& lhs, const tquat& rhs ) - { - tvec4 result( ctor::uninitialize ); - for ( component_count_t i = 0; i < component_count( x ); ++i ) - result[i] = rhs[i] != lhs[i]; - return result; - } - - template < typename T > inline tquat::operator tmat3() { Index: /trunk/nv/stl/math/relational.hh =================================================================== --- /trunk/nv/stl/math/relational.hh (revision 470) +++ /trunk/nv/stl/math/relational.hh (revision 471) @@ -45,4 +45,9 @@ }; + template < typename T > + struct make_bool_vec< tquat< T > > + { + typedef tvec4< bool > type; + }; } @@ -50,9 +55,9 @@ using bool_vec_t = typename detail::make_bool_vec::type; - template < typename T, typename enable_if< is_vec::value >::type* = nullptr > + template < typename T, typename enable_if< is_vec_or_quat::value >::type* = nullptr > inline bool_vec_t less_than( const T& lhs, const T& rhs ) { - bool_vec_t result( ctor::uninitialize ); - for ( component_count_t i = 0; i < component_count( lhs ); ++i ) + bool_vec_t result( no_init ); + for ( size_t i = 0; i < nv::size( lhs ); ++i ) result[i] = lhs[i] < rhs[i]; @@ -60,45 +65,45 @@ } - template < typename T, typename enable_if< is_vec::value >::type* = nullptr > + template < typename T, typename enable_if< is_vec_or_quat::value >::type* = nullptr > inline bool_vec_t less_than_equal( const T& lhs, const T& rhs ) { - bool_vec_t result( ctor::uninitialize ); - for ( component_count_t i = 0; i < component_count( lhs ); ++i ) + bool_vec_t result( no_init ); + for ( size_t i = 0; i < nv::size( lhs ); ++i ) result[i] = lhs[i] <= rhs[i]; return result; } - template < typename T, typename enable_if< is_vec::value >::type* = nullptr > + template < typename T, typename enable_if< is_vec_or_quat::value >::type* = nullptr > inline bool_vec_t greater_than( const T& lhs, const T& rhs ) { - bool_vec_t result( ctor::uninitialize ); - for ( component_count_t i = 0; i < component_count( lhs ); ++i ) + bool_vec_t result( no_init ); + for ( size_t i = 0; i < nv::size( lhs ); ++i ) result[i] = lhs[i] > rhs[i]; return result; } - template < typename T, typename enable_if< is_vec::value >::type* = nullptr > + template < typename T, typename enable_if< is_vec_or_quat::value >::type* = nullptr > inline bool_vec_t greater_than_equal( const T& lhs, const T& rhs ) { - bool_vec_t result( ctor::uninitialize ); - for ( component_count_t i = 0; i < component_count( lhs ); ++i ) + bool_vec_t result( no_init ); + for ( size_t i = 0; i < nv::size( lhs ); ++i ) result[i] = lhs[i] >= rhs[i]; return result; } - template < typename T, typename enable_if< is_vec::value >::type* = nullptr > + template < typename T, typename enable_if< is_vec_or_quat::value >::type* = nullptr > inline bool_vec_t equal( const T& lhs, const T& rhs ) { - bool_vec_t result( ctor::uninitialize ); - for ( component_count_t i = 0; i < component_count( lhs ); ++i ) + bool_vec_t result( no_init ); + for ( size_t i = 0; i < nv::size( lhs ); ++i ) result[i] = lhs[i] == rhs[i]; return result; } - template < typename T, typename enable_if< is_vec::value >::type* = nullptr > + template < typename T, typename enable_if< is_vec_or_quat::value >::type* = nullptr > inline bool_vec_t not_equal( const T& lhs, const T& rhs ) { - bool_vec_t result( ctor::uninitialize ); - for ( component_count_t i = 0; i < component_count( lhs ); ++i ) + bool_vec_t result( no_init ); + for ( size_t i = 0; i < nv::size( lhs ); ++i ) result[i] = lhs[i] != rhs[i]; return result; @@ -109,5 +114,5 @@ { bool result = false; - for ( component_count_t i = 0; i < component_count( v ); ++i ) + for ( size_t i = 0; i < nv::size( v ); ++i ) result = result || v[i]; return result; @@ -118,5 +123,5 @@ { bool result = true; - for ( component_count_t i = 0; i < component_count( v ); ++i ) + for ( size_t i = 0; i < nv::size( v ); ++i ) result = result && v[i]; return result; @@ -126,6 +131,6 @@ inline T not_( const T& v ) { - T result( ctor::uninitialize ); - for ( component_count_t i = 0; i < component_count( v ); ++i ) + T result( no_init ); + for ( size_t i = 0; i < nv::size( v ); ++i ) result[i] = !v[i]; return result; Index: /trunk/nv/stl/math/trigonometric.hh =================================================================== --- /trunk/nv/stl/math/trigonometric.hh (revision 471) +++ /trunk/nv/stl/math/trigonometric.hh (revision 471) @@ -0,0 +1,119 @@ +// Copyright (C) 2015-2015 ChaosForge Ltd +// http://chaosforge.org/ +// +// This file is part of Nova libraries. +// For conditions of distribution and use, see copying.txt file in root folder. + +/** +* @file trigonometric.hh +* @author Kornel Kisielewicz epyon@chaosforge.org +* @brief relational math ops +*/ + +#ifndef NV_STL_MATH_TRIGONOMETRIC_HH +#define NV_STL_MATH_TRIGONOMETRIC_HH + +#include + +namespace nv +{ + + namespace math + { + + using nv::sin; + template < typename T, typename enable_if< is_fp_vec::value >::type* = nullptr > + inline T sin( const T& v ) + { + return detail::unary_functor::call( nv::sin, v ); + } + + using nv::cos; + template < typename T, typename enable_if< is_fp_vec::value >::type* = nullptr > + inline T cos( const T& v ) + { + return detail::unary_functor::call( nv::cos, v ); + } + + using nv::tan; + template < typename T, typename enable_if< is_fp_vec::value >::type* = nullptr > + inline T tan( const T& v ) + { + return detail::unary_functor::call( nv::tan, v ); + } + + using nv::asin; + template < typename T, typename enable_if< is_fp_vec::value >::type* = nullptr > + inline T asin( const T& v ) + { + return detail::unary_functor::call( nv::asin, v ); + } + + using nv::acos; + template < typename T, typename enable_if< is_fp_vec::value >::type* = nullptr > + inline T acos( const T& v ) + { + return detail::unary_functor::call( nv::acos, v ); + } + + using nv::atan; + template < typename T, typename enable_if< is_fp_vec::value >::type* = nullptr > + inline T atan( const T& v ) + { + return detail::unary_functor::call( nv::atan, v ); + } + + using nv::atan2; + template < typename T, typename enable_if< is_fp_vec::value >::type* = nullptr > + inline T atan2( const T& a, const T& b ) + { + return detail::binary_functor::call( nv::atan2, a, b ); + } + + using nv::sinh; + template < typename T, typename enable_if< is_fp_vec::value >::type* = nullptr > + inline T sinh( const T& v ) + { + return detail::unary_functor::call( nv::sinh, v ); + } + + using nv::cosh; + template < typename T, typename enable_if< is_fp_vec::value >::type* = nullptr > + inline T cosh( const T& v ) + { + return detail::unary_functor::call( nv::cosh, v ); + } + + using nv::tanh; + template < typename T, typename enable_if< is_fp_vec::value >::type* = nullptr > + inline T tanh( const T& v ) + { + return detail::unary_functor::call( nv::tanh, v ); + } + + using nv::asinh; + template < typename T, typename enable_if< is_fp_vec::value >::type* = nullptr > + inline T asinh( const T& v ) + { + return detail::unary_functor::call( nv::asinh, v ); + } + + using nv::acosh; + template < typename T, typename enable_if< is_fp_vec::value >::type* = nullptr > + inline T acosh( const T& v ) + { + return detail::unary_functor::call( nv::acosh, v ); + } + + using nv::atanh; + template < typename T, typename enable_if< is_fp_vec::value >::type* = nullptr > + inline T atanh( const T& v ) + { + return detail::unary_functor::call( nv::atanh, v ); + } + } + +} + + +#endif // NV_STL_MATH_TRIGONOMETRIC_HH Index: /trunk/nv/stl/math/vec2.hh =================================================================== --- /trunk/nv/stl/math/vec2.hh (revision 471) +++ /trunk/nv/stl/math/vec2.hh (revision 471) @@ -0,0 +1,307 @@ +// Copyright (C) 2015-2015 ChaosForge Ltd +// http://chaosforge.org/ +// +// This file is part of Nova libraries. +// For conditions of distribution and use, see copying.txt file in root folder. + +/** + * @file vec2.hh + * @author Kornel Kisielewicz epyon@chaosforge.org + * @brief vec2 + */ + +#ifndef NV_STL_MATH_VEC2_HH +#define NV_STL_MATH_VEC2_HH + +#include + +namespace nv +{ + + namespace math + { + + template + struct tvec2 + { + typedef tvec2 type; + typedef T value_type; + + static constexpr size_t SIZE = 2; + + union + { + struct { T x, y; }; + struct { T r, g; }; + struct { T s, t; }; + }; + + typedef size_t size_type; + inline constexpr size_type size() const { return 2; } + + inline T & operator[]( size_type i ) + { + NV_ASSERT_DEBUG( i >= 0 && i < this->size(), "index out of range!" ); + return ( &x )[i]; + } + + inline T operator[]( size_type i ) const + { + NV_ASSERT_DEBUG( i >= 0 && i < this->size(), "index out of range!" ); + return ( &x )[i]; + } + + inline tvec2() + : x( static_cast( 0 ) ) + , y( static_cast( 0 ) ) + {} + + inline tvec2( const tvec2 & m ) = default; + inline tvec2( tvec2 && m ) = default; + inline tvec2 & operator=( const tvec2 & m ) = default; + inline tvec2 & operator=( tvec2 && m ) = default; + + inline explicit tvec2( T scalar ) + : x( scalar ) + , y( scalar ) + {} + + inline explicit tvec2( no_init_t ) {} + + inline tvec2( T sx, T sy ) + : x( sx ) + , y( sy ) + {} + + template < typename A, typename B > + inline tvec2( A sx, B sy ) + : x( static_cast( sx ) ) + , y( static_cast( sy ) ) + {} + + template + inline explicit tvec2( const tvec3 & v ) + : x( static_cast( v.x ) ) + , y( static_cast( v.y ) ) + {} + + template + inline explicit tvec2( const tvec4 & v ) + : x( static_cast( v.x ) ) + , y( static_cast( v.y ) ) + {} + + template + inline explicit tvec2( const tvec2 & v ) + : x( static_cast( v.x ) ) + , y( static_cast( v.y ) ) + {} + + inline tvec2 & tvec2::operator+=( T scalar ) + { + this->x += static_cast( scalar ); + this->y += static_cast( scalar ); + return *this; + } + + inline tvec2 & operator+=( const tvec2 & v ) + { + this->x += static_cast( v.x ); + this->y += static_cast( v.y ); + return *this; + } + + inline tvec2 & operator-=( T scalar ) + { + this->x -= static_cast( scalar ); + this->y -= static_cast( scalar ); + return *this; + } + + inline tvec2 & operator-=( const tvec2 & v ) + { + this->x -= static_cast( v.x ); + this->y -= static_cast( v.y ); + return *this; + } + + inline tvec2 & operator*=( T scalar ) + { + this->x *= static_cast( scalar ); + this->y *= static_cast( scalar ); + return *this; + } + + inline tvec2 & operator*=( const tvec2 & v ) + { + this->x *= static_cast( v.x ); + this->y *= static_cast( v.y ); + return *this; + } + + inline tvec2 & operator/=( T scalar ) + { + this->x /= static_cast( scalar ); + this->y /= static_cast( scalar ); + return *this; + } + + inline tvec2 & operator/=( const tvec2 & v ) + { + this->x /= static_cast( v.x ); + this->y /= static_cast( v.y ); + return *this; + } + + inline tvec2 & operator++() + { + ++this->x; + ++this->y; + return *this; + } + + inline tvec2 & operator--() + { + --this->x; + --this->y; + return *this; + } + + inline tvec2 operator++( int ) + { + tvec2 result( *this ); + ++*this; + return result; + } + + inline tvec2 operator--( int ) + { + tvec2 result( *this ); + --*this; + return result; + } + + }; + + + template + inline tvec2 operator-( const tvec2 & v ) + { + return tvec2( + -v.x, + -v.y ); + } + + template + inline tvec2 operator+( const tvec2 & v, T scalar ) + { + return tvec2( + v.x + scalar, + v.y + scalar ); + } + + template + inline tvec2 operator+( T scalar, const tvec2 & v ) + { + return tvec2( + scalar + v.x, + scalar + v.y ); + } + + template + inline tvec2 operator+( const tvec2 & v1, const tvec2 & v2 ) + { + return tvec2( + v1.x + v2.x, + v1.y + v2.y ); + } + + template + inline tvec2 operator-( const tvec2 & v, T scalar ) + { + return tvec2( + v.x - scalar, + v.y - scalar ); + } + + template + inline tvec2 operator-( T scalar, const tvec2 & v ) + { + return tvec2( + scalar - v.x, + scalar - v.y ); + } + + template + inline tvec2 operator-( const tvec2 & v1, const tvec2 & v2 ) + { + return tvec2( + v1.x - v2.x, + v1.y - v2.y ); + } + + template + inline tvec2 operator*( const tvec2 & v1, T v2 ) + { + return tvec2( + v1.x * v2, + v1.y * v2 ); + } + + template + inline tvec2 operator*( T scalar, const tvec2 & v ) + { + return tvec2( + scalar * v.x, + scalar * v.y ); + } + + template + inline tvec2 operator*( const tvec2 & v1, const tvec2 & v2 ) + { + return tvec2( + v1.x * v2.x, + v1.y * v2.y ); + } + + template + inline tvec2 operator/( const tvec2 & v, T scalar ) + { + return tvec2( + v.x / scalar, + v.y / scalar ); + } + + template + inline tvec2 operator/( T scalar, const tvec2 & v ) + { + return tvec2( + scalar / v.x, + scalar / v.y ); + } + + template + inline tvec2 operator/( const tvec2 & v1, const tvec2 & v2 ) + { + return tvec2( + v1.x / v2.x, + v1.y / v2.y ); + } + + template + inline bool operator==( const tvec2 & v1, const tvec2 & v2 ) + { + return ( v1.x == v2.x ) && ( v1.y == v2.y ); + } + + template + inline bool operator!=( const tvec2 & v1, const tvec2 & v2 ) + { + return ( v1.x != v2.x ) || ( v1.y != v2.y ); + } + + } + +} + +#endif // NV_STL_MATH_VEC2_HH Index: /trunk/nv/stl/math/vec3.hh =================================================================== --- /trunk/nv/stl/math/vec3.hh (revision 471) +++ /trunk/nv/stl/math/vec3.hh (revision 471) @@ -0,0 +1,342 @@ +// Copyright (C) 2015-2015 ChaosForge Ltd +// http://chaosforge.org/ +// +// This file is part of Nova libraries. +// For conditions of distribution and use, see copying.txt file in root folder. + +/** + * @file vec3.hh + * @author Kornel Kisielewicz epyon@chaosforge.org + * @brief vec3 + */ + +#ifndef NV_STL_MATH_VEC3_HH +#define NV_STL_MATH_VEC3_HH + +#include + +namespace nv +{ + + namespace math + { + template + struct tvec3 + { + typedef tvec3 type; + typedef T value_type; + static constexpr size_t SIZE = 3; + + union + { + struct { T x, y, z; }; + struct { T r, g, b; }; + struct { T s, t, p; }; + }; + + typedef size_t size_type; + inline constexpr size_type size() const { return 3; } + + inline T & operator[]( size_type i ) + { + NV_ASSERT_DEBUG( i >= 0 && i < this->size(), "index out of range!" ); + return ( &x )[i]; + } + + inline T operator[]( size_type i ) const + { + NV_ASSERT_DEBUG( i >= 0 && i < this->size(), "index out of range!" ); + return ( &x )[i]; + } + + + inline tvec3() + : x( static_cast( 0 ) ) + , y( static_cast( 0 ) ) + , z( static_cast( 0 ) ) + {} + + inline tvec3( const tvec3 & m ) = default; + inline tvec3( tvec3 && m ) = default; + inline tvec3 & operator=( const tvec3 & m ) = default; + inline tvec3 & operator=( tvec3 && m ) = default; + + inline explicit tvec3( T scalar ) + : x( scalar ) + , y( scalar ) + , z( scalar ) + {} + + inline explicit tvec3( no_init_t ) {} + + inline tvec3( T sx, T sy, T sz ) + : x( sx ) + , y( sy ) + , z( sz ) + {} + + template + inline tvec3( A sx, B sy, C sz ) + : x( static_cast( sx ) ) + , y( static_cast( sy ) ) + , z( static_cast( sz ) ) + {} + + template + inline explicit tvec3( const tvec2 &a, B b ) + : x( static_cast( a.x ) ) + , y( static_cast( a.y ) ) + , z( static_cast( b ) ) + {} + + template + inline tvec3( A a, const tvec2 & b ) + : x( static_cast( a ) ) + , y( static_cast( b.x ) ) + , z( static_cast( b.y ) ) + {} + + template + inline explicit tvec3( const tvec4 & v ) + : x( static_cast( v.x ) ) + , y( static_cast( v.y ) ) + , z( static_cast( v.z ) ) + {} + + template + inline explicit tvec3( const tvec3 & v ) + : x( static_cast( v.x ) ) + , y( static_cast( v.y ) ) + , z( static_cast( v.z ) ) + {} + + inline tvec3 & operator+=( T scalar ) + { + this->x += static_cast( scalar ); + this->y += static_cast( scalar ); + this->z += static_cast( scalar ); + return *this; + } + + inline tvec3 & operator+=( const tvec3 & v ) + { + this->x += static_cast( v.x ); + this->y += static_cast( v.y ); + this->z += static_cast( v.z ); + return *this; + } + + inline tvec3 & operator-=( T scalar ) + { + this->x -= static_cast( scalar ); + this->y -= static_cast( scalar ); + this->z -= static_cast( scalar ); + return *this; + } + + inline tvec3 & operator-=( const tvec3 & v ) + { + this->x -= static_cast( v.x ); + this->y -= static_cast( v.y ); + this->z -= static_cast( v.z ); + return *this; + } + + inline tvec3 & operator*=( T scalar ) + { + this->x *= static_cast( scalar ); + this->y *= static_cast( scalar ); + this->z *= static_cast( scalar ); + return *this; + } + + inline tvec3 & operator*=( const tvec3 & v ) + { + this->x *= static_cast( v.x ); + this->y *= static_cast( v.y ); + this->z *= static_cast( v.z ); + return *this; + } + + inline tvec3 & operator/=( T v ) + { + this->x /= static_cast( v ); + this->y /= static_cast( v ); + this->z /= static_cast( v ); + return *this; + } + + inline tvec3 & operator/=( const tvec3 & v ) + { + this->x /= static_cast( v.x ); + this->y /= static_cast( v.y ); + this->z /= static_cast( v.z ); + return *this; + } + + inline tvec3 & operator++() + { + ++this->x; + ++this->y; + ++this->z; + return *this; + } + + inline tvec3 & operator--() + { + --this->x; + --this->y; + --this->z; + return *this; + } + + inline tvec3 operator++( int ) + { + tvec3 result( *this ); + ++*this; + return result; + } + + inline tvec3 operator--( int ) + { + tvec3 result( *this ); + --*this; + return result; + } + + }; + + template + inline tvec3 operator-( const tvec3 & v ) + { + return tvec3( + -v.x, + -v.y, + -v.z ); + } + + template + inline tvec3 operator+( const tvec3 & v, T scalar ) + { + return tvec3( + v.x + scalar, + v.y + scalar, + v.z + scalar ); + } + + template + inline tvec3 operator+( T scalar, const tvec3 & v ) + { + return tvec3( + scalar + v.x, + scalar + v.y, + scalar + v.z ); + } + + template + inline tvec3 operator+( const tvec3 & v1, const tvec3 & v2 ) + { + return tvec3( + v1.x + v2.x, + v1.y + v2.y, + v1.z + v2.z ); + } + + template + inline tvec3 operator-( const tvec3 & v, T scalar ) + { + return tvec3( + v.x - scalar, + v.y - scalar, + v.z - scalar ); + } + + template + inline tvec3 operator-( T scalar, const tvec3 & v ) + { + return tvec3( + scalar - v.x, + scalar - v.y, + scalar - v.z ); + } + + template + inline tvec3 operator-( const tvec3 & v1, const tvec3 & v2 ) + { + return tvec3( + v1.x - v2.x, + v1.y - v2.y, + v1.z - v2.z ); + } + + template + inline tvec3 operator*( const tvec3 & v, T scalar ) + { + return tvec3( + v.x * scalar, + v.y * scalar, + v.z * scalar ); + } + + template + inline tvec3 operator*( T scalar, const tvec3 & v ) + { + return tvec3( + scalar * v.x, + scalar * v.y, + scalar * v.z ); + } + + template + inline tvec3 operator*( const tvec3 & v1, const tvec3 & v2 ) + { + return tvec3( + v1.x * v2.x, + v1.y * v2.y, + v1.z * v2.z ); + } + + template + inline tvec3 operator/( const tvec3 & v, T scalar ) + { + return tvec3( + v.x / scalar, + v.y / scalar, + v.z / scalar ); + } + + template + inline tvec3 operator/( T scalar, const tvec3 & v ) + { + return tvec3( + scalar / v.x, + scalar / v.y, + scalar / v.z ); + } + + template + inline tvec3 operator/( const tvec3 & v1, const tvec3 & v2 ) + { + return tvec3( + v1.x / v2.x, + v1.y / v2.y, + v1.z / v2.z ); + } + + template + inline bool operator==( const tvec3 & v1, const tvec3 & v2 ) + { + return ( v1.x == v2.x ) && ( v1.y == v2.y ) && ( v1.z == v2.z ); + } + + template + inline bool operator!=( const tvec3 & v1, const tvec3 & v2 ) + { + return ( v1.x != v2.x ) || ( v1.y != v2.y ) || ( v1.z != v2.z ); + } + + } + +} + +#endif // NV_STL_MATH_VEC3_HH Index: /trunk/nv/stl/math/vec4.hh =================================================================== --- /trunk/nv/stl/math/vec4.hh (revision 471) +++ /trunk/nv/stl/math/vec4.hh (revision 471) @@ -0,0 +1,427 @@ +// Copyright (C) 2015-2015 ChaosForge Ltd +// http://chaosforge.org/ +// +// This file is part of Nova libraries. +// For conditions of distribution and use, see copying.txt file in root folder. + +/** + * @file vec4.hh + * @author Kornel Kisielewicz epyon@chaosforge.org + * @brief vec4 + */ + +#ifndef NV_STL_MATH_VEC4_HH +#define NV_STL_MATH_VEC4_HH + +#include + +namespace nv +{ + + namespace math + { + + template + struct tvec4 + { + typedef tvec4 type; + typedef T value_type; + static constexpr size_t SIZE = 4; + + union + { + struct { T x, y, z, w; }; + struct { T r, g, b, a; }; + struct { T s, t, p, q; }; + }; + + typedef size_t size_type; + inline constexpr size_type size() const { return 4; } + + inline T & operator[]( size_type i ) + { + NV_ASSERT_DEBUG( i >= 0 && i < this->size(), "index out of range!" ); + return ( &x )[i]; + } + + inline T operator[]( size_type i ) const + { + NV_ASSERT_DEBUG( i >= 0 && i < this->size(), "index out of range!" ); + return ( &x )[i]; + } + + inline tvec4() + : x( static_cast( 0 ) ) + , y( static_cast( 0 ) ) + , z( static_cast( 0 ) ) + , w( static_cast( 0 ) ) + {} + + inline tvec4( const tvec4 & m ) = default; + inline tvec4( tvec4 && m ) = default; + inline tvec4 & operator=( const tvec4 & m ) = default; + inline tvec4 & operator=( tvec4 && m ) = default; + + inline explicit tvec4( T scalar ) + : x( scalar ) + , y( scalar ) + , z( scalar ) + , w( scalar ) + {} + + inline explicit tvec4( no_init_t ) {} + + inline tvec4( T sx, T sy, T sz, T sw ) + : x( sx ) + , y( sy ) + , z( sz ) + , w( sw ) + {} + + template + inline tvec4( A sx, B sy, C sz, D sw ) + : x( static_cast( sx ) ) + , y( static_cast( sy ) ) + , z( static_cast( sz ) ) + , w( static_cast( sw ) ) + {} + + template + inline explicit tvec4( const tvec2 & a, B b, C c ) + : x( static_cast( a.x ) ) + , y( static_cast( a.y ) ) + , z( static_cast( b ) ) + , w( static_cast( c ) ) + {} + + template + inline explicit tvec4( A a, const tvec2 & b, C c ) + : x( static_cast( a ) ) + , y( static_cast( b.x ) ) + , z( static_cast( b.y ) ) + , w( static_cast( c ) ) + {} + + template + inline explicit tvec4( A a, B b, const tvec2 & c ) + : x( static_cast( a ) ) + , y( static_cast( b ) ) + , z( static_cast( c.x ) ) + , w( static_cast( c.y ) ) + {} + + template + inline explicit tvec4( const tvec3 & a, B b ) + : x( static_cast( a.x ) ) + , y( static_cast( a.y ) ) + , z( static_cast( a.z ) ) + , w( static_cast( b ) ) + {} + + template + inline explicit tvec4( A a, const tvec3 & b ) + : x( static_cast( a ) ) + , y( static_cast( b.x ) ) + , z( static_cast( b.y ) ) + , w( static_cast( b.z ) ) + {} + + template + inline explicit tvec4( const tvec2 & a, const tvec2 & b ) + : x( static_cast( a.x ) ) + , y( static_cast( a.y ) ) + , z( static_cast( b.x ) ) + , w( static_cast( b.y ) ) + {} + + template + inline explicit tvec4( const tvec4 & v ) + : x( static_cast( v.x ) ) + , y( static_cast( v.y ) ) + , z( static_cast( v.z ) ) + , w( static_cast( v.w ) ) + {} + + inline tvec4 & operator+=( T scalar ) + { + this->x += static_cast( scalar ); + this->y += static_cast( scalar ); + this->z += static_cast( scalar ); + this->w += static_cast( scalar ); + return *this; + } + + inline tvec4 & operator+=( const tvec4 & v ) + { + this->x += static_cast( v.x ); + this->y += static_cast( v.y ); + this->z += static_cast( v.z ); + this->w += static_cast( v.w ); + return *this; + } + + inline tvec4 & operator-=( T scalar ) + { + this->x -= static_cast( scalar ); + this->y -= static_cast( scalar ); + this->z -= static_cast( scalar ); + this->w -= static_cast( scalar ); + return *this; + } + + inline tvec4 & operator-=( const tvec4 & v ) + { + this->x -= static_cast( v.x ); + this->y -= static_cast( v.y ); + this->z -= static_cast( v.z ); + this->w -= static_cast( v.w ); + return *this; + } + + inline tvec4 & operator*=( T v ) + { + this->x *= static_cast( v ); + this->y *= static_cast( v ); + this->z *= static_cast( v ); + this->w *= static_cast( v ); + return *this; + } + + inline tvec4 & operator*=( const tvec4 & v ) + { + this->x *= static_cast( v.x ); + this->y *= static_cast( v.y ); + this->z *= static_cast( v.z ); + this->w *= static_cast( v.w ); + return *this; + } + + inline tvec4 & operator/=( T v ) + { + this->x /= static_cast( v ); + this->y /= static_cast( v ); + this->z /= static_cast( v ); + this->w /= static_cast( v ); + return *this; + } + + inline tvec4 & operator/=( const tvec4 & v ) + { + this->x /= static_cast( v.x ); + this->y /= static_cast( v.y ); + this->z /= static_cast( v.z ); + this->w /= static_cast( v.w ); + return *this; + } + + inline tvec4 & operator++() + { + ++this->x; + ++this->y; + ++this->z; + ++this->w; + return *this; + } + + inline tvec4 & operator--() + { + --this->x; + --this->y; + --this->z; + --this->w; + return *this; + } + + inline tvec4 operator++( int ) + { + tvec4 result( *this ); + ++*this; + return result; + } + + inline tvec4 operator--( int ) + { + tvec4 result( *this ); + --*this; + return result; + } + + }; + + template + inline tvec4 operator-( const tvec4 & v ) + { + return tvec4( + -v.x, + -v.y, + -v.z, + -v.w ); + } + + template + inline tvec4 operator+( const tvec4 & v, T scalar ) + { + return tvec4( + v.x + scalar, + v.y + scalar, + v.z + scalar, + v.w + scalar ); + } + + template + inline tvec4 operator+( T scalar, const tvec4 & v ) + { + return tvec4( + scalar + v.x, + scalar + v.y, + scalar + v.z, + scalar + v.w ); + } + + template + inline tvec4 operator+( const tvec4 & v1, const tvec4 & v2 ) + { + return tvec4( + v1.x + v2.x, + v1.y + v2.y, + v1.z + v2.z, + v1.w + v2.w ); + } + + template + inline tvec4 operator-( const tvec4 & v, T scalar ) + { + return tvec4( + v.x - scalar, + v.y - scalar, + v.z - scalar, + v.w - scalar ); + } + + template + inline tvec4 operator-( T scalar, const tvec4 & v ) + { + return tvec4( + scalar - v.x, + scalar - v.y, + scalar - v.z, + scalar - v.w ); + } + + template + inline tvec4 operator-( const tvec4 & v1, const tvec4 & v2 ) + { + return tvec4( + v1.x - v2.x, + v1.y - v2.y, + v1.z - v2.z, + v1.w - v2.w ); + } + + template + inline tvec4 operator*( const tvec4 & v, T scalar ) + { + return tvec4( + v.x * scalar, + v.y * scalar, + v.z * scalar, + v.w * scalar ); + } + + template + inline tvec4 operator*( T scalar, const tvec4 & v ) + { + return tvec4( + scalar * v.x, + scalar * v.y, + scalar * v.z, + scalar * v.w ); + } + + template + inline tvec4 operator*( const tvec4 & v1, const tvec4 & v2 ) + { + return tvec4( + v1.x * v2.x, + v1.y * v2.y, + v1.z * v2.z, + v1.w * v2.w ); + } + + template + inline tvec4 operator/( const tvec4 & v, T scalar ) + { + return tvec4( + v.x / scalar, + v.y / scalar, + v.z / scalar, + v.w / scalar ); + } + + template + inline tvec4 operator/( T scalar, const tvec4 & v ) + { + return tvec4( + scalar / v.x, + scalar / v.y, + scalar / v.z, + scalar / v.w ); + } + + template + inline tvec4 operator/( const tvec4 & v1, const tvec4 & v2 ) + { + return tvec4( + v1.x / v2.x, + v1.y / v2.y, + v1.z / v2.z, + v1.w / v2.w ); + } + + template + inline tvec4 operator%( const tvec4 & v, T scalar ) + { + return tvec4( + v.x % scalar, + v.y % scalar, + v.z % scalar, + v.w % scalar ); + } + + template + inline tvec4 operator%( T scalar, const tvec4 & v ) + { + return tvec4( + scalar % v.x, + scalar % v.y, + scalar % v.z, + scalar % v.w ); + } + + template + inline tvec4 operator%( const tvec4 & v1, const tvec4 & v2 ) + { + return tvec4( + v1.x % v2.x, + v1.y % v2.y, + v1.z % v2.z, + v1.w % v2.w ); + } + + template + inline bool operator==( const tvec4 & v1, const tvec4 & v2 ) + { + return ( v1.x == v2.x ) && ( v1.y == v2.y ) && ( v1.z == v2.z ) && ( v1.w == v2.w ); + } + + template + inline bool operator!=( const tvec4 & v1, const tvec4 & v2 ) + { + return ( v1.x != v2.x ) || ( v1.y != v2.y ) || ( v1.z != v2.z ) || ( v1.w != v2.w ); + } + + } + +} + +#endif // NV_STL_MATH_VEC4_HH Index: /trunk/nv/stl/type_erasure.hh =================================================================== --- /trunk/nv/stl/type_erasure.hh (revision 470) +++ /trunk/nv/stl/type_erasure.hh (revision 471) @@ -83,13 +83,13 @@ constexpr pointer operator->() const { return reinterpret_cast( m_current ); } - constexpr const_raw_data_iterator& operator++() { m_current += stride; return *this; } - constexpr const_raw_data_iterator operator++( int ) { const_raw_data_iterator ri( *this ); m_current += stride; return ri; } - constexpr const_raw_data_iterator& operator--() { m_current -= stride; return *this; } - constexpr const_raw_data_iterator operator--( int ) { const_raw_data_iterator ri( *this ); m_current -= stride; return ri; } + inline const_raw_data_iterator& operator++() { m_current += stride; return *this; } + inline const_raw_data_iterator operator++( int ) { const_raw_data_iterator ri( *this ); m_current += stride; return ri; } + inline const_raw_data_iterator& operator--() { m_current -= stride; return *this; } + inline const_raw_data_iterator operator--( int ) { const_raw_data_iterator ri( *this ); m_current -= stride; return ri; } constexpr const_raw_data_iterator operator+( difference_type n ) const { return const_raw_data_iterator( m_current + n * m_stride, m_stride ); } - constexpr const_raw_data_iterator& operator+=( difference_type n ) { m_current += n * m_stride; return *this; } + inline const_raw_data_iterator& operator+=( difference_type n ) { m_current += n * m_stride; return *this; } constexpr const_raw_data_iterator operator-( difference_type n ) const { return const_raw_data_iterator( m_current - n * m_stride, m_stride ); } - constexpr const_raw_data_iterator& operator-=( difference_type n ) { m_current -= n * m_stride; return *this; } + inline const_raw_data_iterator& operator-=( difference_type n ) { m_current -= n * m_stride; return *this; } constexpr reference operator[]( difference_type n ) const { return *reinterpret_cast( m_current + n * m_stride ); } Index: /trunk/src/core/random.cc =================================================================== --- /trunk/src/core/random.cc (revision 470) +++ /trunk/src/core/random.cc (revision 471) @@ -21,5 +21,5 @@ void random::mt_init( uint32 seed ) { - m_state[0] = static_cast( seed & mt_full_mask ); + m_state[0] = static_cast( seed & mt_full_mask ); for ( int i = 1; i < mersenne_n; i++ ) { @@ -111,5 +111,5 @@ { f32 angle = frand( math::pi() * 2.f ); - return vec2( math::cos( angle ), math::sin( angle ) ); + return vec2( cos( angle ), sin( angle ) ); } @@ -117,9 +117,9 @@ { f32 cos_theta = frange( -1.0f, 1.0f ); - f32 sin_theta = math::sqrt( 1.0f - cos_theta * cos_theta ); + f32 sin_theta = sqrt( 1.0f - cos_theta * cos_theta ); f32 phi = frand( 2 * math::pi() ); return vec3( - sin_theta * math::sin(phi), - sin_theta * math::cos(phi), + sin_theta * sin(phi), + sin_theta * cos(phi), cos_theta ); @@ -132,12 +132,12 @@ if ( r1 > r2 ) swap( r1, r2 ); f32 rf = 2* math::pi()*(r1/r2); - return vec2( r2*math::cos( rf ), r2*math::sin( rf ) ); + return vec2( r2*cos( rf ), r2*sin( rf ) ); } nv::vec2 nv::random::precise_disk_point() { - f32 r = math::sqrt( frand() ); + f32 r = sqrt( frand() ); f32 rangle = frand( math::pi() ); - return vec2( r*math::cos( rangle ), r*math::sin( rangle ) ); + return vec2( r*cos( rangle ), r*sin( rangle ) ); } @@ -146,11 +146,11 @@ f32 rad = frand(); f32 pi = math::pi(); - f32 phi = math::asin( frange( -1.0f, 1.0f ) ) + pi*.5f; + f32 phi = asin( frange( -1.0f, 1.0f ) ) + pi*.5f; f32 theta = frange( 0.0f, 2 * math::pi() ); - f32 sin_phi = math::sin( phi ); + f32 sin_phi = sin( phi ); return vec3( - rad * math::cos(theta) * sin_phi, - rad * math::sin(theta) * sin_phi, - rad * math::cos(phi) + rad * cos(theta) * sin_phi, + rad * sin(theta) * sin_phi, + rad * cos(phi) ); } @@ -158,11 +158,11 @@ nv::vec3 nv::random::precise_sphere_point() { - f32 radius = math::pow( frand(), 1.f/3.f ); + f32 radius = pow( frand(), 1.f/3.f ); f32 cos_theta = frange( -1.0f, 1.0f ); - f32 sin_theta = math::sqrt( 1.0f - cos_theta * cos_theta ); + f32 sin_theta = sqrt( 1.0f - cos_theta * cos_theta ); f32 phi = frange( 0.0f, 2 * math::pi() ); return vec3( - radius * sin_theta * math::sin(phi), - radius * sin_theta * math::cos(phi), + radius * sin_theta * sin(phi), + radius * sin_theta * cos(phi), radius * cos_theta ); @@ -203,5 +203,5 @@ f32 idist2 = iradius * iradius; f32 odist2 = oradius * oradius; - f32 rdist = math::sqrt( frange( idist2, odist2 ) ); + f32 rdist = sqrt( frange( idist2, odist2 ) ); return rdist * precise_unit_vec2(); } @@ -216,5 +216,5 @@ f32 idist3 = iradius * iradius * iradius; f32 odist3 = oradius * oradius * oradius; - f32 rdist = math::pow( frange( idist3, odist3 ), 1.f/3.f ); + f32 rdist = pow( frange( idist3, odist3 ), 1.f/3.f ); return rdist * precise_unit_vec3(); } @@ -237,5 +237,5 @@ f32 idist2 = ((iradii2.x * iradii2.y) / low ) * odist2; - f32 rdist = math::sqrt( frange( idist2, odist2 ) ); + f32 rdist = sqrt( frange( idist2, odist2 ) ); return odir * rdist; } @@ -260,8 +260,8 @@ f32 idist2 = ((iradii2.x * iradii2.y * iradii2.z) / low ) * odist2; - f32 odist3 = odist2 * math::sqrt( odist2 ); - f32 idist3 = idist2 * math::sqrt( idist2 ); - - f32 rdist = math::pow( frange( idist3, odist3 ), 1.f/3.f ); + f32 odist3 = odist2 * sqrt( odist2 ); + f32 idist3 = idist2 * sqrt( idist2 ); + + f32 rdist = pow( frange( idist3, odist3 ), 1.f/3.f ); return odir * rdist; } Index: /trunk/src/engine/particle_engine.cc =================================================================== --- /trunk/src/engine/particle_engine.cc (revision 470) +++ /trunk/src/engine/particle_engine.cc (revision 471) @@ -231,5 +231,5 @@ datap->plane_normal = normalize_safe( datap->plane_normal, vec3(0.0f,1.0f,0.0f) ); datap->bounce = table->get("bounce", 0.0f ); - datap->distance = -math::dot( datap->plane_normal, datap->plane_point ) / math::sqrt( math::dot( datap->plane_normal, datap->plane_normal ) ); + datap->distance = -math::dot( datap->plane_normal, datap->plane_point ) / sqrt( math::dot( datap->plane_normal, datap->plane_normal ) ); return true; } @@ -751,10 +751,10 @@ { float emission_angle = math::radians( edata.angle ); - float cos_theta = r.frange( math::cos( emission_angle ), 1.0f ); - float sin_theta = math::sqrt(1.0f - cos_theta * cos_theta ); + float cos_theta = r.frange( cos( emission_angle ), 1.0f ); + float sin_theta = sqrt(1.0f - cos_theta * cos_theta ); float phi = r.frange( 0.0f, 2* math::pi() ); pinfo.velocity = orient * - ( edata.odir * ( math::cos(phi) * sin_theta ) + - edata.cdir * ( math::sin(phi)*sin_theta ) + + ( edata.odir * ( cos(phi) * sin_theta ) + + edata.cdir * ( sin(phi)*sin_theta ) + edata.dir * cos_theta ); } Index: /trunk/src/formats/assimp_loader.cc =================================================================== --- /trunk/src/formats/assimp_loader.cc (revision 470) +++ /trunk/src/formats/assimp_loader.cc (revision 471) @@ -350,5 +350,4 @@ uint16 frame_rate = static_cast( anim->mTicksPerSecond ); - int check_this; uint16 duration = static_cast( anim->mDuration ); bool flat = false; Index: /trunk/src/formats/md3_loader.cc =================================================================== --- /trunk/src/formats/md3_loader.cc (revision 470) +++ /trunk/src/formats/md3_loader.cc (revision 471) @@ -246,11 +246,11 @@ { float flat = lat * convert; - float sin_lat = math::sin( flat ); - float cos_lat = math::cos( flat ); + float sin_lat = nv::sin( flat ); + float cos_lat = nv::cos( flat ); for ( int lng = 0; lng < 256; ++lng, ++n ) { float flng = lng * convert; - float sin_lng = math::sin( flng ); - float cos_lng = math::cos( flng ); + float sin_lng = nv::sin( flng ); + float cos_lng = nv::cos( flng ); s_normal_cache[n].x = cos_lat * sin_lng; // s_normal_cache[n].y = sin_lat * sin_lng; Index: /trunk/src/gfx/mesh_creator.cc =================================================================== --- /trunk/src/gfx/mesh_creator.cc (revision 470) +++ /trunk/src/gfx/mesh_creator.cc (revision 471) @@ -17,5 +17,5 @@ if ( m_data->m_flat ) return; merge_keys(); - uint32 max_frames = 0; + uint16 max_frames = 0; nv::vector< sint16 > ids; @@ -65,5 +65,5 @@ size_t count = ( keys ? keys->get_channel_size(0) : 0 ); size_t pcount = ( pkeys ? pkeys->get_channel_size(0) : 0 ); - max_frames = nv::max( count, max_frames ); + max_frames = nv::max( uint16( count ), max_frames ); if ( pkeys && pkeys->size() > 0 && keys && keys->size() > 0 ) { Index: /trunk/src/gfx/skeletal_mesh.cc =================================================================== --- /trunk/src/gfx/skeletal_mesh.cc (revision 470) +++ /trunk/src/gfx/skeletal_mesh.cc (revision 471) @@ -48,5 +48,5 @@ { float fframe = ( a_ms_time * 0.001f ) * m_fps; - uint32 frame = math::floor( fframe ); + uint32 frame = uint32( math::floor( fframe ) ); float reminder = fframe - static_cast( frame ); uint32 duration = get_frame_count(); Index: /trunk/src/gfx/texture_atlas.cc =================================================================== --- /trunk/src/gfx/texture_atlas.cc (revision 470) +++ /trunk/src/gfx/texture_atlas.cc (revision 471) @@ -22,7 +22,7 @@ region r ( ivec2(0,0), size ); - int best_height = INT_MAX; + int best_height = nv::limits::si_max; int best_index = -1; - int best_width = INT_MAX; + int best_width = nv::limits::si_max; for( size_t i=0; i < m_nodes.size(); ++i ) Index: /trunk/src/gfx/texture_font.cc =================================================================== --- /trunk/src/gfx/texture_font.cc (revision 470) +++ /trunk/src/gfx/texture_font.cc (revision 471) @@ -172,5 +172,5 @@ FT_Load_Glyph( face, glyph_index, FT_LOAD_RENDER | FT_LOAD_NO_HINTING); slot = face->glyph; - g->advance = ivec2( slot->advance.x/64.0f, slot->advance.y/64.0f ); + g->advance = vec2( slot->advance.x/64.0f, slot->advance.y/64.0f ); } generate_kerning(); Index: /trunk/src/gl/gl_device.cc =================================================================== --- /trunk/src/gl/gl_device.cc (revision 470) +++ /trunk/src/gl/gl_device.cc (revision 471) @@ -76,5 +76,5 @@ } // TODO: BGR vs RGB, single channel - assert( image->format->BytesPerPixel > 2 ); + NV_ASSERT( image->format->BytesPerPixel > 2, "bytes per pixel > 2!" ); image_format format( image->format->BytesPerPixel == 3 ? RGB : RGBA, UBYTE ); image_data* idata = new image_data( format, ivec2( image->w, image->h ), static_cast( image->pixels ) ); Index: /trunk/src/gui/gui_gfx_renderer.cc =================================================================== --- /trunk/src/gui/gui_gfx_renderer.cc (revision 470) +++ /trunk/src/gui/gui_gfx_renderer.cc (revision 471) @@ -215,5 +215,5 @@ image_data* data = m_window->get_device()->create_image_data( filename ); // TODO: Repitching - assert( data->get_depth() == 4 ); + NV_ASSERT( data->get_depth() == 4, "depth != 4" ); region r = m_atlas.get_region( data->get_size() ); m_atlas.set_region( r, data->get_data() ); @@ -327,5 +327,5 @@ position p2 = p + g->size + gp; qvec.emplace_back( p + gp, p2, color, g->tl, g->br ); - p += g->advance; + p += ivec2( g->advance ); } } Index: /trunk/src/lua/lua_math.cc =================================================================== --- /trunk/src/lua/lua_math.cc (revision 470) +++ /trunk/src/lua/lua_math.cc (revision 471) @@ -214,9 +214,9 @@ { T v = to_vec( L, 1 ); - for ( int i = 0; i < v.length(); ++i ) + for ( size_t i = 0; i < v.size(); ++i ) { lua_pushnumber( L, v[i] ); } - return v.length(); + return v.size(); } @@ -226,7 +226,7 @@ T* v = to_pvec( L, 1 ); size_t len = 0; - int vlen = v->length(); + size_t vlen = v->size(); const unsigned char * key = reinterpret_cast( lua_tolstring( L, 2, &len ) ); - int idx = 255; + size_t idx = 255; if ( len == 1 ) @@ -264,7 +264,7 @@ T* v = to_pvec( L, 1 ); size_t len = 0; - int vlen = v->length(); + size_t vlen = v->size(); const unsigned char * key = reinterpret_cast( lua_tolstring( L, 2, &len ) ); - int idx = 255; + size_t idx = 255; if( len == 1 ) { @@ -293,5 +293,5 @@ T v = to_vec( L, 1 ); bool fl = nv::is_floating_point::value; - switch ( v.length() ) + switch ( v.size() ) { case 1: lua_pushfstring( L, ( fl ? "(%f)" : "(%d)" ), v[0] ); break;