Changeset 471

Timestamp:

09/21/15 19:13:26 (10 years ago)

Author:

epyon

Message:

• full math library
• GLM dependency removed

Location:

trunk

Files:

• nv.lua (modified) (1 diff)
• nv/base/capi.hh (modified) (2 diffs)
• nv/base/cmath.hh (modified) (1 diff)
• nv/base/common.hh (modified) (2 diffs)
• nv/interface/animated_mesh.hh (modified) (1 diff)
• nv/interface/interpolation_raw.hh (modified) (1 diff)
• nv/stl/math.hh (modified) (3 diffs)
• nv/stl/math/angle.hh (modified) (1 diff)
• nv/stl/math/basic.hh (modified) (3 diffs)
• nv/stl/math/cast.hh (modified) (7 diffs)
• nv/stl/math/common.hh (modified) (4 diffs)
• nv/stl/math/exponential.hh (modified) (1 diff)
• nv/stl/math/geometric.hh (modified) (2 diffs)
• nv/stl/math/mat2.hh (added)
• nv/stl/math/mat3.hh (added)
• nv/stl/math/mat4.hh (added)
• nv/stl/math/matrix.hh (added)
• nv/stl/math/matrix_transform.hh (modified) (5 diffs)
• nv/stl/math/quaternion.hh (modified) (8 diffs)
• nv/stl/math/relational.hh (modified) (6 diffs)
• nv/stl/math/trigonometric.hh (added)
• nv/stl/math/vec2.hh (added)
• nv/stl/math/vec3.hh (added)
• nv/stl/math/vec4.hh (added)
• nv/stl/type_erasure.hh (modified) (1 diff)
• src/core/random.cc (modified) (10 diffs)
• src/engine/particle_engine.cc (modified) (2 diffs)
• src/formats/assimp_loader.cc (modified) (1 diff)
• src/formats/md3_loader.cc (modified) (1 diff)
• src/gfx/mesh_creator.cc (modified) (2 diffs)
• src/gfx/skeletal_mesh.cc (modified) (1 diff)
• src/gfx/texture_atlas.cc (modified) (1 diff)
• src/gfx/texture_font.cc (modified) (1 diff)
• src/gl/gl_device.cc (modified) (1 diff)
• src/gui/gui_gfx_renderer.cc (modified) (2 diffs)
• src/lua/lua_math.cc (modified) (4 diffs)

trunk/nv.lua

@@ -106 +106 @@
 -- injection!
 solution( solution().name )
-        configuration "*"
-                includedirs { os.getenv("GLM_PATH") }
         configuration "gmake"
                 if _ACTION == "gmake-clang" then

trunk/nv/base/capi.hh

@@ -102 +102 @@
         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 +109 @@
         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 );
         }

trunk/nv/base/cmath.hh

@@ -19 +19 @@
 
 #include <nv/base/common.hh>
-
 #include <math.h>
 
+namespace nv
+{
+
+        namespace detail
+        {
+                template< typename T >
+                inline T pow_int( T x, int y )
+                {
+                        unsigned int n = static_cast<unsigned>( y >= 0 ? y : -y );
+                        for ( T z = static_cast<T>( 1 ); ; x *= x )
+                        {
+                                if ( ( n & 1 ) != 0 )
+                                        z *= x;
+                                if ( ( n >>= 1 ) == 0 )
+                                        return ( y < 0 ? static_cast<T>( 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

trunk/nv/base/common.hh

@@ -207 +207 @@
 #endif
 
+        enum no_init_t
+        {
+                no_init
+        };
+
         // Typedefs for fixed size types.
         typedef signed   char      sint8;
@@ -288 +293 @@
         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
 

trunk/nv/interface/animated_mesh.hh

@@ -30 +30 @@
                 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; }

trunk/nv/interface/interpolation_raw.hh

@@ -53 +53 @@
         {
                 quat result;
-                memcpy(reinterpret_cast<float*>(&result), data, sizeof(quat));
+                nvmemcpy(reinterpret_cast<float*>(&result), data, sizeof(quat));
                 return result;
         }

trunk/nv/stl/math.hh

@@ -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 +9 @@
 
 #include <nv/stl/math/common.hh>
+#include <nv/stl/math/vec2.hh>
+#include <nv/stl/math/vec3.hh>
+#include <nv/stl/math/vec4.hh>
+#include <nv/stl/math/mat3.hh>
+#include <nv/stl/math/mat4.hh>
+#include <nv/stl/math/mat2.hh>
+#include <nv/stl/math/mat3.hh>
+#include <nv/stl/math/mat4.hh>
 #include <nv/stl/math/constants.hh>
 #include <nv/stl/math/relational.hh>
@@ -16 +22 @@
 #include <nv/stl/math/geometric.hh>
 #include <nv/stl/math/exponential.hh>
+#include <nv/stl/math/trigonometric.hh>
 #include <nv/stl/math/matrix_transform.hh>
 #include <nv/stl/math/angle.hh>
 #include <nv/stl/math/quaternion.hh>
-
+#include <nv/stl/math/matrix.hh>
 #include <nv/stl/math/cast.hh>
 

trunk/nv/stl/math/angle.hh

@@ -167 +167 @@
                         static_assert( is_floating_point<T>::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 ) );
                 }

trunk/nv/stl/math/basic.hh

@@ -77 +77 @@
                                 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 +102 @@
                         };
 
-                        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<T>::type UT;
-                                        typedef typename make_unsigned<U>::type UU;
-                                        const U shift( static_cast<U>( 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 +274 @@
                 }
 
+                template < typename T, typename enable_if< !is_vec<T>::value >::type* = nullptr >
+                constexpr T step( T edge, T x )
+                {
+                        return mix( static_cast<T>( 1 ), static_cast<T>( 0 ), less_than( x, edge ) );
+                }
+
+                template < typename T, typename enable_if< is_vec<T>::value >::type* = nullptr >
+                constexpr T step( const T& edge, const T& x )
+                {
+                        return mix( static_cast<T>( 1 ), static_cast<T>( 0 ), less_than( x, edge ) );
+                }
+
+                template < typename T, typename enable_if< is_vec<T>::value >::type* = nullptr >
+                constexpr T step( value_type_t<T> edge, const T& x )
+                {
+                        return mix( static_cast<T>( 1 ), static_cast<T>( 0 ), less_than( x, edge ) );
+                }
+
+                template < typename T, typename enable_if< is_floating_point<T>::value >::type* = nullptr >
+                constexpr T smoothstep( T edge0, T edge1, T x )
+                {
+                        T y( clamp( ( x - edge0 ) / ( edge1 - edge0 ), static_cast<T>( 0 ), static_cast<T>( 1 ) ) );
+                        return y * y * ( static_cast<T>( 3 ) - static_cast<T>( 2 ) * y );
+                }
+
+                template < typename T, typename enable_if< is_fp_vec<T>::value >::type* = nullptr >
+                constexpr T smoothstep( const T& edge0, const T& edge1, const T& x )
+                {
+                        T y( clamp( ( x - edge0 ) / ( edge1 - edge0 ), static_cast<T>( 0 ), static_cast<T>( 1 ) ) );
+                        return y * y * ( static_cast<T>( 3 ) - static_cast<T>( 2 ) * y );
+                }
+
+                template < typename T, typename enable_if< is_fp_vec<T>::value >::type* = nullptr >
+                constexpr T smoothstep( value_type_t<T> edge0, value_type_t<T> edge1, const T& x )
+                {
+                        T y( clamp( ( x - edge0 ) / ( edge1 - edge0 ), static_cast<T>( 0 ), static_cast<T>( 1 ) ) );
+                        return y * y * ( static_cast<T>( 3 ) - static_cast<T>( 2 ) * y );
+                }
+
         }
 }

trunk/nv/stl/math/cast.hh

@@ -107 +107 @@
         inline math::tvec2<T> make_vec2( const T * const ptr )
         {
-                math::tvec2<T> result( math::ctor::uninitialize );
+                math::tvec2<T> result( no_init );
                 nvmemcpy( data_cast( result ), ptr, sizeof( math::tvec2<T> ) );
                 return result;
@@ -115 +115 @@
         inline math::tvec3<T> make_vec3( const T * const ptr )
         {
-                math::tvec3<T> result( math::ctor::uninitialize );
+                math::tvec3<T> result( no_init );
                 nvmemcpy( data_cast( result ), ptr, sizeof( math::tvec3<T> ) );
                 return result;
@@ -123 +123 @@
         inline math::tvec4<T> make_vec4( const T * const ptr )
         {
-                math::tvec4<T> result( math::ctor::uninitialize );
+                math::tvec4<T> result( no_init );
                 nvmemcpy( data_cast( result ), ptr, sizeof( math::tvec4<T> ) );
                 return result;
@@ -131 +131 @@
         inline math::tmat2<T> make_mat2( const T * const ptr )
         {
-                math::tmat2<T> result( math::ctor::uninitialize );
+                math::tmat2<T> result( no_init );
                 nvmemcpy( data_cast( result ), ptr, sizeof( math::tmat2<T> ) );
                 return result;
@@ -139 +139 @@
         inline math::tmat3<T> make_mat3( const T * const ptr )
         {
-                math::tmat3<T> result( math::ctor::uninitialize );
+                math::tmat3<T> result( no_init );
                 nvmemcpy( data_cast( result ), ptr, sizeof( math::tmat3<T> ) );
                 return result;
@@ -147 +147 @@
         inline math::tmat4<T> make_mat4( const T * const ptr )
         {
-                math::tmat4<T> result( math::ctor::uninitialize );
+                math::tmat4<T> result( no_init );
                 nvmemcpy( data_cast( result ), ptr, sizeof( math::tmat4<T> ) );
                 return result;
@@ -155 +155 @@
         inline math::tquat<T> make_quat( const T * const ptr )
         {
-                math::tquat<T> result( math::ctor::uninitialize );
+                math::tquat<T> result( no_init );
                 nvmemcpy( data_cast( result ), ptr, sizeof( math::tquat<T> ) );
                 return result;

trunk/nv/stl/math/common.hh

@@ -24 +24 @@
 
 #include <nv/base/cmath.hh>
-#include <glm/glm.hpp>
 
 namespace nv
@@ -31 +30 @@
         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<T> compute_inverse( const tmat2<T> & );
+                        template < typename T >
+                        inline tmat3<T> compute_inverse( const tmat3<T> & );
+                        template < typename T >
+                        inline tmat4<T> compute_inverse( const tmat4<T> & );
+                }
+
 
                 using ::cos;
@@ -58 +68 @@
                 using ::round;
 
-#if 0
-                template < typename T > using tvec2 = ::glm::detail::tvec2<T, glm::precision::highp>;
-                template < typename T > using tvec3 = ::glm::detail::tvec3<T, glm::precision::highp>;
-                template < typename T > using tvec4 = ::glm::detail::tvec4<T, glm::precision::highp>;
-                template < typename T > using tmat2 = ::glm::detail::tmat2x2<T, glm::precision::highp>;
-                template < typename T > using tmat3 = ::glm::detail::tmat3x3<T, glm::precision::highp>;
-                template < typename T > using tmat4 = ::glm::detail::tmat4x4<T, glm::precision::highp>;
-#else
-                template < typename T > using tvec2 = ::glm::tvec2<T>;
-                template < typename T > using tvec3 = ::glm::tvec3<T>;
-                template < typename T > using tvec4 = ::glm::tvec4<T>;
-                template < typename T > using tmat2 = ::glm::tmat2x2<T>;
-                template < typename T > using tmat3 = ::glm::tmat3x3<T>;
-                template < typename T > using tmat4 = ::glm::tmat4x4<T>;
-#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 +81 @@
                 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 {};

trunk/nv/stl/math/exponential.hh

@@ -68 +68 @@
                 inline T inversesqrt( const T& x )
                 {
-                        return static_cast<T>( 1 ) / sqrt( x );
+                        return static_cast<T>( 1 ) / nv::sqrt( x );
                 }
 

trunk/nv/stl/math/geometric.hh

@@ -34 +34 @@
                                 inline static T get( const tvec2<T>& a, const tvec2<T>& b )
                                 {
-                                        tvec2<T, P> tmp( a * b );
+                                        tvec2<T> tmp( a * b );
                                         return tmp.x + tmp.y;
                                 }
@@ -69 +69 @@
                 inline value_type_t<T> length( const T& v )
                 {
-                        return sqrt( dot( v, v ) );
+                        return nv::sqrt( dot( v, v ) );
                 }
 

trunk/nv/stl/math/matrix_transform.hh

@@ -34 +34 @@
                 {
                         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<T> axis( normalize( v ) );
                         tvec3<T> temp( ( T( 1 ) - c ) * axis );
 
-                        tmat4<T> Rotate( ctor::uninitialize );
+                        tmat4<T> Rotate( no_init );
                         Rotate[0][0] = c + temp[0] * axis[0];
                         Rotate[0][1] = 0 + temp[0] * axis[1] + s * axis[2];
@@ -53 +53 @@
                         Rotate[2][2] = c + temp[2] * axis[2];
 
-                        tmat4<T> result( ctor::uninitialize );
+                        tmat4<T> 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 +64 @@
                 inline tmat4<T> scale( const tmat4<T>& m, const tvec3<T>& v )
                 {
-                        tmat4<T> result( ctor::uninitialize );
+                        tmat4<T> result( no_init );
                         result[0] = m[0] * v[0];
                         result[1] = m[1] * v[1];
@@ -134 +134 @@
                         NV_ASSERT( abs( aspect - epsilon<T>() ) > static_cast<T>( 0 ), "bad parameters to math::perspective!" );
 
-                        const T tan_half_fovy = math::tan( fovy / static_cast<T>( 2 ) );
+                        const T tan_half_fovy = nv::tan( fovy / static_cast<T>( 2 ) );
 
                         tmat4<T> result( static_cast<T>( 0 ) );
@@ -153 +153 @@
 
                         const T rad = fov;
-                        const T h = math::cos( static_cast<T>( 0.5 ) * rad ) / math::sin( static_cast<T>( 0.5 ) * rad );
+                        const T h = nv::cos( static_cast<T>( 0.5 ) * rad ) / math::sin( static_cast<T>( 0.5 ) * rad );
                         const T w = h * height / width; 
 

trunk/nv/stl/math/quaternion.hh

@@ -18 +18 @@
 #include <nv/stl/math/geometric.hh>
 #include <nv/stl/math/angle.hh>
+#include <nv/base/cmath.hh>
 
 namespace nv
@@ -52 +53 @@
                                 : 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<T>& v )
                                 : x( v.x ), y( v.y ), z( v.z ), w( s ) {}
@@ -113 +114 @@
                 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 +187 @@
                         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 +221 @@
                         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 +327 @@
                         }
 
-                        T vmax = sqrt( fmax + T( 1 ) ) * T( 0.5 );
+                        T vmax = nv::sqrt( fmax + T( 1 ) ) * T( 0.5 );
                         T mult = static_cast<T>( 0.25 ) / vmax;
 
-                        tquat<T> result( ctor::uninitialize );
+                        tquat<T> result( no_init );
                         switch ( imax )
                         {
@@ -392 +387 @@
                 inline tquat<T> angle_axis( T angle, const tvec3<T>& v )
                 {
-                        tquat<T> result( ctor::uninitialize );
-                        T sina = sin( angle * static_cast<T>( 0.5 ) );
-                        result.w = cos( angle * static_cast<T>( 0.5 ) );
+                        tquat<T> result( no_init );
+                        T sina = nv::sin( angle * static_cast<T>( 0.5 ) );
+                        result.w = nv::cos( angle * static_cast<T>( 0.5 ) );
                         result.x = v.x * sina;
                         result.y = v.y * sina;
@@ -402 +397 @@
 
                 template < typename T >
-                inline tvec4<bool> less_than( const tquat<T>& lhs, const tquat<T>& rhs )
-                {
-                        tvec4<bool> 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<bool> less_than_equal( const tquat<T>& lhs, const tquat<T>& rhs )
-                {
-                        tvec4<bool> 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<bool> greater_than( const tquat<T>& lhs, const tquat<T>& rhs )
-                {
-                        tvec4<bool> 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<bool> greater_than_equal( const tquat<T>& lhs, const tquat<T>& rhs )
-                {
-                        tvec4<bool, P> 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<bool> equal( const tquat<T>& lhs, const tquat<T>& rhs )
-                {
-                        tvec4<bool, P> 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<bool> not_equal( const tquat<T>& lhs, const tquat<T>& rhs )
-                {
-                        tvec4<bool> 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<T>::operator tmat3<T>()
                 {

trunk/nv/stl/math/relational.hh

@@ -45 +45 @@
                         };
 
+                        template < typename T >
+                        struct make_bool_vec< tquat< T > >
+                        {
+                                typedef tvec4< bool > type;
+                        };
                 }
 
@@ -50 +55 @@
                 using bool_vec_t = typename detail::make_bool_vec<T>::type;
 
-                template < typename T, typename enable_if< is_vec<T>::value >::type* = nullptr >
+                template < typename T, typename enable_if< is_vec_or_quat<T>::value >::type* = nullptr >
                 inline bool_vec_t<T> less_than( const T& lhs, const T& rhs )
                 {
-                        bool_vec_t<T> result( ctor::uninitialize );
-                        for ( component_count_t i = 0; i < component_count( lhs ); ++i )
+                        bool_vec_t<T> result( no_init );
+                        for ( size_t i = 0; i < nv::size( lhs ); ++i )
                                 result[i] = lhs[i] < rhs[i];
 
@@ -60 +65 @@
                 }
 
-                template < typename T, typename enable_if< is_vec<T>::value >::type* = nullptr >
+                template < typename T, typename enable_if< is_vec_or_quat<T>::value >::type* = nullptr >
                 inline bool_vec_t<T> less_than_equal( const T& lhs, const T& rhs )
                 {
-                        bool_vec_t<T> result( ctor::uninitialize );
-                        for ( component_count_t i = 0; i < component_count( lhs ); ++i )
+                        bool_vec_t<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<T>::value >::type* = nullptr >
+                template < typename T, typename enable_if< is_vec_or_quat<T>::value >::type* = nullptr >
                 inline bool_vec_t<T> greater_than( const T& lhs, const T& rhs )
                 {
-                        bool_vec_t<T> result( ctor::uninitialize );
-                        for ( component_count_t i = 0; i < component_count( lhs ); ++i )
+                        bool_vec_t<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<T>::value >::type* = nullptr >
+                template < typename T, typename enable_if< is_vec_or_quat<T>::value >::type* = nullptr >
                 inline bool_vec_t<T> greater_than_equal( const T& lhs, const T& rhs )
                 {
-                        bool_vec_t<T> result( ctor::uninitialize );
-                        for ( component_count_t i = 0; i < component_count( lhs ); ++i )
+                        bool_vec_t<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<T>::value >::type* = nullptr >
+                template < typename T, typename enable_if< is_vec_or_quat<T>::value >::type* = nullptr >
                 inline bool_vec_t<T> equal( const T& lhs, const T& rhs )
                 {
-                        bool_vec_t<T> result( ctor::uninitialize );
-                        for ( component_count_t i = 0; i < component_count( lhs ); ++i )
+                        bool_vec_t<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<T>::value >::type* = nullptr >
+                template < typename T, typename enable_if< is_vec_or_quat<T>::value >::type* = nullptr >
                 inline bool_vec_t<T> not_equal( const T& lhs, const T& rhs )
                 {
-                        bool_vec_t<T> result( ctor::uninitialize );
-                        for ( component_count_t i = 0; i < component_count( lhs ); ++i )
+                        bool_vec_t<T> result( no_init );
+                        for ( size_t i = 0; i < nv::size( lhs ); ++i )
                                 result[i] = lhs[i] != rhs[i];
                         return result;
@@ -109 +114 @@
                 {
                         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 +123 @@
                 {
                         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 +131 @@
                 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;

trunk/nv/stl/type_erasure.hh

@@ -83 +83 @@
                 constexpr pointer operator->() const { return reinterpret_cast<pointer>( 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<pointer>( m_current + n * m_stride ); }
 

trunk/src/core/random.cc

@@ -21 +21 @@
 void random::mt_init( uint32 seed )
 {
-        m_state[0] = static_cast<uint32_t>( seed & mt_full_mask );
+        m_state[0] = static_cast<uint32>( seed & mt_full_mask );
         for ( int i = 1; i < mersenne_n; i++ )
         {
@@ -111 +111 @@
 {
         f32 angle = frand( math::pi<f32>() * 2.f );
-        return vec2( math::cos( angle ), math::sin( angle ) );
+        return vec2( cos( angle ), sin( angle ) );
 }
 
@@ -117 +117 @@
 {
         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<f32>() );
         return vec3( 
-                sin_theta * math::sin(phi),
-                sin_theta * math::cos(phi),
+                sin_theta * sin(phi),
+                sin_theta * cos(phi),
                 cos_theta
                 );
@@ -132 +132 @@
         if ( r1 > r2 ) swap( r1, r2 );
         f32 rf = 2* math::pi<f32>()*(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<f32>() );
-        return vec2( r*math::cos( rangle ), r*math::sin( rangle ) );
+        return vec2( r*cos( rangle ), r*sin( rangle ) );
 }
 
@@ -146 +146 @@
         f32 rad     = frand();
         f32 pi      = math::pi<f32>();
-        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>() );
-        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 +158 @@
 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<f32>() );
         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 +203 @@
         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 +216 @@
         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 +237 @@
         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 +260 @@
         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;    
 }

trunk/src/engine/particle_engine.cc

@@ -231 +231 @@
         datap->plane_normal = normalize_safe( datap->plane_normal, vec3(0.0f,1.0f,0.0f) );
         datap->bounce       = table->get<float>("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 +751 @@
                                         {
                                                 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<float>() );
                                                 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 );
                                         }

trunk/src/formats/assimp_loader.cc

@@ -350 +350 @@
 
         uint16 frame_rate     = static_cast<uint16>( anim->mTicksPerSecond );
-        int check_this;
         uint16 duration       = static_cast<uint16>( anim->mDuration );
         bool   flat           = false;

trunk/src/formats/md3_loader.cc

@@ -246 +246 @@
                 {
                         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;

trunk/src/gfx/mesh_creator.cc

@@ -17 +17 @@
         if ( m_data->m_flat ) return;
         merge_keys();
-        uint32 max_frames = 0;
+        uint16 max_frames = 0;
 
         nv::vector< sint16 > ids;
@@ -65 +65 @@
                 size_t count     = ( keys ? keys->get_channel_size(0) : 0 );
                 size_t pcount    = ( pkeys ? pkeys->get_channel_size(0) : 0 );
-                max_frames = nv::max<uint32>( count, max_frames );
+                max_frames = nv::max<uint16>( uint16( count ), max_frames );
                 if ( pkeys && pkeys->size() > 0 && keys && keys->size() > 0 )
                 {

trunk/src/gfx/skeletal_mesh.cc

@@ -48 +48 @@
 {
         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<float>( frame );
         uint32 duration = get_frame_count();

trunk/src/gfx/texture_atlas.cc

@@ -22 +22 @@
         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 )

trunk/src/gfx/texture_font.cc

@@ -172 +172 @@
                 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();

trunk/src/gl/gl_device.cc

@@ -76 +76 @@
         }
         // 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<nv::uint8*>( image->pixels ) );

trunk/src/gui/gui_gfx_renderer.cc

@@ -215 +215 @@
         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 +327 @@
                                                 position p2 = p + g->size + gp;
                                                 qvec.emplace_back( p + gp, p2, color, g->tl, g->br );
-                                                p += g->advance;
+                                                p += ivec2( g->advance );
                                         }
                                 }

trunk/src/lua/lua_math.cc

@@ -214 +214 @@
 {
         T v = to_vec<T>( 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 +226 @@
         T* v = to_pvec<T>( L, 1 );
         size_t len  = 0;
-        int vlen = v->length();
+        size_t vlen = v->size();
         const unsigned char * key = reinterpret_cast<const unsigned char *>( lua_tolstring( L, 2, &len ) );
-        int idx = 255;
+        size_t idx = 255;
 
         if ( len == 1 )
@@ -264 +264 @@
         T* v = to_pvec<T>( L, 1 );
         size_t len  = 0;
-        int vlen = v->length();
+        size_t vlen = v->size();
         const unsigned char * key = reinterpret_cast<const unsigned char *>( lua_tolstring( L, 2, &len ) );
-        int idx = 255;
+        size_t idx = 255;
         if( len == 1 )
         {
@@ -293 +293 @@
         T v = to_vec<T>( L, 1 );
         bool fl = nv::is_floating_point<typename T::value_type>::value;
-        switch ( v.length() )
+        switch ( v.size() )
         {
         case 1: lua_pushfstring( L, ( fl ? "(%f)"          : "(%d)" ),          v[0] ); break;